1 /*-
2 * Copyright (c) 2019 Justin Hibbits
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23 * SUCH DAMAGE.
24 */
25
26 #include <sys/cdefs.h>
27 __FBSDID("$FreeBSD$");
28
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/bio.h>
32 #include <sys/bus.h>
33 #include <sys/kernel.h>
34 #include <sys/kthread.h>
35 #include <sys/lock.h>
36 #include <sys/module.h>
37 #include <sys/mutex.h>
38 #include <sys/proc.h>
39 #include <geom/geom_disk.h>
40
41 #include <vm/vm.h>
42 #include <vm/pmap.h>
43
44 #include <dev/ofw/ofw_bus.h>
45 #include <dev/ofw/ofw_bus_subr.h>
46 #include <dev/ofw/openfirm.h>
47 #include "opal.h"
48
49 /*
50 * OPAL System flash driver, using OPAL firmware calls to access the device.
51 *
52 * This just presents the base block interface. The fdt_slicer can be used on
53 * top to present the partitions listed in the fdt.
54 *
55 * There are three OPAL methods used: OPAL_FLASH_READ, OPAL_FLASH_WRITE, and
56 * OPAL_FLASH_ERASE. At the firmware layer, READ and WRITE can be on arbitrary
57 * boundaries, but ERASE is only at flash-block-size block alignments and sizes.
58 * To account for this, the following restrictions are in place:
59 *
60 * - Reads are on a 512-byte block boundary and size
61 * - Writes and Erases are aligned and sized on flash-block-size bytes.
62 *
63 * In order to support the fdt_slicer we present a type attribute of
64 * NAND::device.
65 */
66 struct opalflash_softc {
67 device_t sc_dev;
68 struct mtx sc_mtx;
69 struct disk *sc_disk;
70 struct proc *sc_p;
71 struct bio_queue_head sc_bio_queue;
72 int sc_opal_id;
73 bool sc_erase; /* Erase is needed before write. */
74 };
75
76 #define OPALFLASH_LOCK(sc) mtx_lock(&(sc)->sc_mtx)
77 #define OPALFLASH_UNLOCK(sc) mtx_unlock(&(sc)->sc_mtx)
78 #define OPALFLASH_LOCK_INIT(sc) \
79 mtx_init(&(sc)->sc_mtx, device_get_nameunit((sc)->sc_dev), \
80 "opalflash", MTX_DEF)
81
82 #define FLASH_BLOCKSIZE 512
83
84 static int opalflash_probe(device_t);
85 static int opalflash_attach(device_t);
86
87 static device_method_t opalflash_methods[] = {
88 /* Device interface */
89 DEVMETHOD(device_probe, opalflash_probe),
90 DEVMETHOD(device_attach, opalflash_attach),
91
92 DEVMETHOD_END
93 };
94
95 static driver_t opalflash_driver = {
96 "opalflash",
97 opalflash_methods,
98 sizeof(struct opalflash_softc)
99 };
100
101 static devclass_t opalflash_devclass;
102
103 DRIVER_MODULE(opalflash, opal, opalflash_driver, opalflash_devclass, 0, 0);
104
105 /* GEOM Disk interfaces. */
106 static int
opalflash_open(struct disk * dp)107 opalflash_open(struct disk *dp)
108 {
109
110 return (0);
111 }
112
113 static int
opalflash_close(struct disk * dp)114 opalflash_close(struct disk *dp)
115 {
116
117 return (0);
118 }
119
120 static int
opalflash_ioctl(struct disk * dp,u_long cmd,void * data,int fflag,struct thread * td)121 opalflash_ioctl(struct disk *dp, u_long cmd, void *data, int fflag,
122 struct thread *td)
123 {
124
125 return (EINVAL);
126 }
127
128 /* Handle the one attribute we need to play nice with geom_flashmap. */
129 static int
opalflash_getattr(struct bio * bp)130 opalflash_getattr(struct bio *bp)
131 {
132 struct opalflash_softc *sc;
133 device_t dev;
134
135 if (bp->bio_disk == NULL || bp->bio_disk->d_drv1 == NULL)
136 return (ENXIO);
137
138 sc = bp->bio_disk->d_drv1;
139 dev = sc->sc_dev;
140
141 if (strcmp(bp->bio_attribute, "NAND::device") == 0) {
142 if (bp->bio_length != sizeof(dev))
143 return (EFAULT);
144 bcopy(&dev, bp->bio_data, sizeof(dev));
145 } else
146 return (-1);
147 return (0);
148 }
149
150 static void
opalflash_strategy(struct bio * bp)151 opalflash_strategy(struct bio *bp)
152 {
153 struct opalflash_softc *sc;
154
155 sc = (struct opalflash_softc *)bp->bio_disk->d_drv1;
156 OPALFLASH_LOCK(sc);
157 bioq_disksort(&sc->sc_bio_queue, bp);
158 wakeup(sc);
159 OPALFLASH_UNLOCK(sc);
160 }
161
162 static int
opalflash_read(struct opalflash_softc * sc,off_t off,caddr_t data,off_t count)163 opalflash_read(struct opalflash_softc *sc, off_t off,
164 caddr_t data, off_t count)
165 {
166 struct opal_msg msg;
167 int rv, size, token;
168
169 /* Ensure we write aligned to a full block size. */
170 if (off % sc->sc_disk->d_sectorsize != 0 ||
171 count % sc->sc_disk->d_sectorsize != 0)
172 return (EIO);
173
174 token = opal_alloc_async_token();
175
176 /*
177 * Read one page at a time. It's not guaranteed that the buffer is
178 * physically contiguous.
179 */
180 rv = 0;
181 while (count > 0) {
182 size = MIN(count, PAGE_SIZE);
183 size = MIN(size, PAGE_SIZE - ((u_long)data & PAGE_MASK));
184 rv = opal_call(OPAL_FLASH_READ, sc->sc_opal_id, off,
185 vtophys(data), size, token);
186 if (rv == OPAL_ASYNC_COMPLETION) {
187 rv = opal_wait_completion(&msg, sizeof(msg), token);
188 if (rv == OPAL_SUCCESS)
189 rv = msg.params[1];
190 }
191 if (rv != OPAL_SUCCESS)
192 break;
193 count -= size;
194 off += size;
195 data += size;
196 }
197 opal_free_async_token(token);
198 if (rv == OPAL_SUCCESS)
199 rv = 0;
200 else
201 rv = EIO;
202
203 return (rv);
204 }
205
206 static int
opalflash_erase(struct opalflash_softc * sc,off_t off,off_t count)207 opalflash_erase(struct opalflash_softc *sc, off_t off, off_t count)
208 {
209 struct opal_msg msg;
210 int rv, token;
211
212 /* Ensure we write aligned to a full block size. */
213 if (off % sc->sc_disk->d_stripesize != 0 ||
214 count % sc->sc_disk->d_stripesize != 0)
215 return (EIO);
216
217 token = opal_alloc_async_token();
218
219 rv = opal_call(OPAL_FLASH_ERASE, sc->sc_opal_id, off, count, token);
220 if (rv == OPAL_ASYNC_COMPLETION) {
221 rv = opal_wait_completion(&msg, sizeof(msg), token);
222 if (rv == OPAL_SUCCESS)
223 rv = msg.params[1];
224 }
225 opal_free_async_token(token);
226
227 if (rv == OPAL_SUCCESS)
228 rv = 0;
229 else
230 rv = EIO;
231
232 return (rv);
233 }
234
235 static int
opalflash_write(struct opalflash_softc * sc,off_t off,caddr_t data,off_t count)236 opalflash_write(struct opalflash_softc *sc, off_t off,
237 caddr_t data, off_t count)
238 {
239 struct opal_msg msg;
240 int rv, size, token;
241
242 /* Ensure we write aligned to a full block size. */
243 if (off % sc->sc_disk->d_sectorsize != 0 ||
244 count % sc->sc_disk->d_sectorsize != 0)
245 return (EIO);
246
247 if (sc->sc_erase) {
248 /* Erase the full block first, then write in page chunks. */
249 rv = opalflash_erase(sc, off, count);
250 if (rv != 0)
251 return (rv);
252 }
253
254 token = opal_alloc_async_token();
255
256 /*
257 * Write one page at a time. It's not guaranteed that the buffer is
258 * physically contiguous.
259 */
260 while (count > 0) {
261 size = MIN(count, PAGE_SIZE);
262 size = MIN(size, PAGE_SIZE - ((u_long)data & PAGE_MASK));
263 rv = opal_call(OPAL_FLASH_WRITE, sc->sc_opal_id, off,
264 vtophys(data), size, token);
265 if (rv == OPAL_ASYNC_COMPLETION) {
266 rv = opal_wait_completion(&msg, sizeof(msg), token);
267 if (rv == OPAL_SUCCESS)
268 rv = msg.params[1];
269 }
270 if (rv != OPAL_SUCCESS)
271 break;
272 count -= size;
273 off += size;
274 data += size;
275 }
276 opal_free_async_token(token);
277
278 if (rv == OPAL_SUCCESS)
279 rv = 0;
280 else
281 rv = EIO;
282
283 return (rv);
284 }
285
286 /* Main flash handling task. */
287 static void
opalflash_task(void * arg)288 opalflash_task(void *arg)
289 {
290 struct opalflash_softc *sc;
291 struct bio *bp;
292 device_t dev;
293
294 sc = arg;
295
296 for (;;) {
297 dev = sc->sc_dev;
298 OPALFLASH_LOCK(sc);
299 do {
300 bp = bioq_first(&sc->sc_bio_queue);
301 if (bp == NULL)
302 msleep(sc, &sc->sc_mtx, PRIBIO, "opalflash", 0);
303 } while (bp == NULL);
304 bioq_remove(&sc->sc_bio_queue, bp);
305 OPALFLASH_UNLOCK(sc);
306
307 switch (bp->bio_cmd) {
308 case BIO_DELETE:
309 bp->bio_error = opalflash_erase(sc, bp->bio_offset,
310 bp->bio_bcount);
311 break;
312 case BIO_READ:
313 bp->bio_error = opalflash_read(sc, bp->bio_offset,
314 bp->bio_data, bp->bio_bcount);
315 break;
316 case BIO_WRITE:
317 bp->bio_error = opalflash_write(sc, bp->bio_offset,
318 bp->bio_data, bp->bio_bcount);
319 break;
320 default:
321 bp->bio_error = EINVAL;
322 }
323 biodone(bp);
324 }
325 }
326
327 /* Device driver interfaces. */
328
329 static int
opalflash_probe(device_t dev)330 opalflash_probe(device_t dev)
331 {
332 if (!ofw_bus_is_compatible(dev, "ibm,opal-flash"))
333 return (ENXIO);
334
335 device_set_desc(dev, "OPAL System Flash");
336
337 return (BUS_PROBE_GENERIC);
338 }
339
340 static int
opalflash_attach(device_t dev)341 opalflash_attach(device_t dev)
342 {
343 struct opalflash_softc *sc;
344 phandle_t node;
345 cell_t flash_blocksize, opal_id;
346 uint32_t regs[2];
347
348 sc = device_get_softc(dev);
349 sc->sc_dev = dev;
350
351 node = ofw_bus_get_node(dev);
352 OF_getencprop(node, "ibm,opal-id", &opal_id, sizeof(opal_id));
353 sc->sc_opal_id = opal_id;
354
355 if (OF_getencprop(node, "ibm,flash-block-size",
356 &flash_blocksize, sizeof(flash_blocksize)) < 0) {
357 device_printf(dev, "Cannot determine flash block size.\n");
358 return (ENXIO);
359 }
360
361 if (!OF_hasprop(node, "no-erase"))
362 sc->sc_erase = true;
363
364 OPALFLASH_LOCK_INIT(sc);
365
366 if (OF_getencprop(node, "reg", regs, sizeof(regs)) < 0) {
367 device_printf(dev, "Unable to get flash size.\n");
368 return (ENXIO);
369 }
370
371 sc->sc_disk = disk_alloc();
372 sc->sc_disk->d_name = "opalflash";
373 sc->sc_disk->d_open = opalflash_open;
374 sc->sc_disk->d_close = opalflash_close;
375 sc->sc_disk->d_strategy = opalflash_strategy;
376 sc->sc_disk->d_ioctl = opalflash_ioctl;
377 sc->sc_disk->d_getattr = opalflash_getattr;
378 sc->sc_disk->d_drv1 = sc;
379 sc->sc_disk->d_maxsize = DFLTPHYS;
380 sc->sc_disk->d_mediasize = regs[1];
381 sc->sc_disk->d_unit = device_get_unit(sc->sc_dev);
382 sc->sc_disk->d_sectorsize = FLASH_BLOCKSIZE;
383 sc->sc_disk->d_stripesize = flash_blocksize;
384 sc->sc_disk->d_dump = NULL;
385
386 disk_create(sc->sc_disk, DISK_VERSION);
387 bioq_init(&sc->sc_bio_queue);
388
389 kproc_create(&opalflash_task, sc, &sc->sc_p, 0, 0, "task: OPAL Flash");
390
391 return (0);
392 }
393