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