Annotation of sys/dev/flash.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: flash.c,v 1.8 2007/06/20 18:15:46 deraadt Exp $ */
2:
3: /*
4: * Copyright (c) 2005 Uwe Stuehler <uwe@openbsd.org>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: #include <sys/param.h>
20: #include <sys/buf.h>
21: #include <sys/conf.h>
22: #include <sys/device.h>
23: #include <sys/disk.h>
24: #include <sys/disklabel.h>
25: #include <sys/dkio.h>
26: #include <sys/kernel.h>
27: #include <sys/stat.h>
28: #include <sys/systm.h>
29:
30: #include <dev/flashvar.h>
31:
32: #include <ufs/ffs/fs.h> /* XXX */
33:
34: /* Samsung command set */
35: #define SAMSUNG_CMD_PTRLO 0x00
36: #define SAMSUNG_CMD_PTRHI 0x01
37: #define SAMSUNG_CMD_PTROOB 0x50
38: #define SAMSUNG_CMD_READ 0x30
39: #define SAMSUNG_CMD_SEQIN 0x80
40: #define SAMSUNG_CMD_WRITE 0x10
41: #define SAMSUNG_CMD_ERASE0 0x60
42: #define SAMSUNG_CMD_ERASE1 0xd0
43: #define SAMSUNG_CMD_STATUS 0x70
44: #define STATUS_FAIL (1<<0)
45: #define STATUS_READY (1<<6)
46: #define STATUS_NWP (1<<7)
47: #define SAMSUNG_CMD_READID 0x90
48: #define SAMSUNG_CMD_RESET 0xff
49:
50: int flash_wait_ready(struct flash_softc *);
51: int flash_wait_complete(struct flash_softc *);
52:
53: /* XXX: these should go elsewhere */
54: cdev_decl(flash);
55: bdev_decl(flash);
56:
57: #define flashlock(sc) disk_lock(&(sc)->sc_dk)
58: #define flashunlock(sc) disk_unlock(&(sc)->sc_dk)
59: #define flashlookup(unit) \
60: (struct flash_softc *)device_lookup(&flash_cd, (unit))
61:
62: void flashminphys(struct buf *);
63: void flashstart(struct flash_softc *);
64: void _flashstart(struct flash_softc *, struct buf *);
65: void flashdone(void *);
66:
67: int flashsafestrategy(struct flash_softc *, struct buf *);
68: void flashgetdefaultlabel(dev_t, struct flash_softc *,
69: struct disklabel *);
70: void flashgetdisklabel(dev_t, struct flash_softc *, struct disklabel *, int);
71:
72: /*
73: * Driver attachment glue
74: */
75:
76: struct flashvendor {
77: u_int8_t vendor;
78: const char *name;
79: };
80:
81: static const struct flashvendor flashvendors[] = {
82: { FLASH_VENDOR_SAMSUNG, "Samsung" }
83: };
84: #define FLASH_NVENDORS (sizeof(flashvendors) / sizeof(flashvendors[0]))
85:
86: static const struct flashdev flashdevs[] = {
87: { FLASH_DEVICE_SAMSUNG_K9F2808U0C, "K9F2808U0C 16Mx8 3.3V",
88: 512, 16, 32, 32768 },
89: { FLASH_DEVICE_SAMSUNG_K9F1G08U0A, "K9F1G08U0A 128Mx8 3.3V",
90: 2048, 64, 64, 65536 },
91: };
92: #define FLASH_NDEVS (sizeof(flashdevs) / sizeof(flashdevs[0]))
93:
94: struct cfdriver flash_cd = {
95: NULL, "flash", DV_DISK
96: };
97:
98: struct dkdriver flashdkdriver = { flashstrategy };
99:
100: void
101: flashattach(struct flash_softc *sc, struct flash_ctl_tag *tag,
102: void *cookie)
103: {
104: u_int8_t vendor, device;
105: u_int16_t id;
106: int i;
107:
108: sc->sc_tag = tag;
109: sc->sc_cookie = cookie;
110:
111: if (sc->sc_maxwaitready <= 0)
112: sc->sc_maxwaitready = 1000; /* 1ms */
113: if (sc->sc_maxwaitcomplete <= 0)
114: sc->sc_maxwaitcomplete = 200000; /* 200ms */
115:
116: flash_chip_enable(sc);
117:
118: /* Identify the flash device. */
119: if (flash_chip_identify(sc, &vendor, &device) != 0) {
120: printf(": identification failed\n");
121: flash_chip_disable(sc);
122: return;
123: }
124: id = (vendor << 8) | device;
125:
126: /* Look up device characteristics, abort if not recognized. */
127: for (i = 0; i < FLASH_NVENDORS; i++) {
128: if (flashvendors[i].vendor == vendor) {
129: printf(": %s", flashvendors[i].name);
130: break;
131: }
132: }
133: if (i == FLASH_NVENDORS)
134: printf(": vendor 0x%02x", vendor);
135: for (i = 0; i < FLASH_NDEVS; i++) {
136: if (flashdevs[i].id == id) {
137: printf(" %s\n", flashdevs[i].longname);
138: break;
139: }
140: }
141: if (i == FLASH_NDEVS) {
142: /* Need to add this device to flashdevs first. */
143: printf(" device 0x%02x\n", device);
144: flash_chip_disable(sc);
145: return;
146: }
147: sc->sc_flashdev = &flashdevs[i];
148:
149: /* Check if the device really works or fail early. */
150: if (flash_chip_reset(sc) != 0) {
151: printf("%s: reset failed\n", sc->sc_dev.dv_xname);
152: flash_chip_disable(sc);
153: return;
154: }
155:
156: flash_chip_disable(sc);
157:
158: /*
159: * Initialize and attach the disk structure.
160: */
161: sc->sc_dk.dk_driver = &flashdkdriver;
162: sc->sc_dk.dk_name = sc->sc_dev.dv_xname;
163: disk_attach(&sc->sc_dk);
164:
165: /* XXX establish shutdown hook to finish any commands. */
166: }
167:
168: int
169: flashdetach(struct device *self, int flags)
170: {
171: struct flash_softc *sc = (struct flash_softc *)self;
172:
173: /* Detach disk. */
174: disk_detach(&sc->sc_dk);
175:
176: /* XXX more resources need to be freed here. */
177: return 0;
178: }
179:
180: int
181: flashactivate(struct device *self, enum devact act)
182: {
183: /* XXX anything to be done here? */
184: return 0;
185: }
186:
187: /*
188: * Flash controller and chip functions
189: */
190:
191: u_int8_t
192: flash_reg8_read(struct flash_softc *sc, int reg)
193: {
194: return sc->sc_tag->reg8_read(sc->sc_cookie, reg);
195: }
196:
197: void
198: flash_reg8_read_page(struct flash_softc *sc, caddr_t data, caddr_t oob)
199: {
200: int i;
201:
202: for (i = 0; i < sc->sc_flashdev->pagesize; i++)
203: data[i] = flash_reg8_read(sc, FLASH_REG_DATA);
204:
205: if (oob != NULL)
206: for (i = 0; i < sc->sc_flashdev->oobsize; i++)
207: oob[i] = flash_reg8_read(sc, FLASH_REG_DATA);
208: }
209:
210: void
211: flash_reg8_write(struct flash_softc *sc, int reg, u_int8_t value)
212: {
213: sc->sc_tag->reg8_write(sc->sc_cookie, reg, value);
214: }
215:
216: void
217: flash_reg8_write_page(struct flash_softc *sc, caddr_t data, caddr_t oob)
218: {
219: int i;
220:
221: for (i = 0; i < sc->sc_flashdev->pagesize; i++)
222: flash_reg8_write(sc, FLASH_REG_DATA, data[i]);
223:
224: if (oob != NULL)
225: for (i = 0; i < sc->sc_flashdev->oobsize; i++)
226: flash_reg8_write(sc, FLASH_REG_DATA, oob[i]);
227: }
228:
229: /*
230: * Wait for the "Ready/Busy" signal to go high, indicating that the
231: * device is ready to accept another command.
232: */
233: int
234: flash_wait_ready(struct flash_softc *sc)
235: {
236: int timo = sc->sc_maxwaitready;
237: u_int8_t ready;
238:
239: ready = flash_reg8_read(sc, FLASH_REG_READY);
240: while (ready == 0 && timo-- > 0) {
241: delay(1);
242: ready = flash_reg8_read(sc, FLASH_REG_READY);
243: }
244: return (ready == 0 ? EIO : 0);
245: }
246:
247: /*
248: * Similar to flash_wait_ready() but looks at IO 6 and IO 0 signals
249: * besides R/B to decide whether the last operation was successful.
250: */
251: int
252: flash_wait_complete(struct flash_softc *sc)
253: {
254: int timo = sc->sc_maxwaitcomplete;
255: u_int8_t status;
256:
257: (void)flash_wait_ready(sc);
258:
259: flash_reg8_write(sc, FLASH_REG_CLE, 1);
260: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_STATUS);
261: flash_reg8_write(sc, FLASH_REG_CLE, 0);
262:
263: status = flash_reg8_read(sc, FLASH_REG_DATA);
264: while ((status & STATUS_READY) == 0 && timo-- > 0) {
265: if (flash_reg8_read(sc, FLASH_REG_READY))
266: break;
267: delay(1);
268: status = flash_reg8_read(sc, FLASH_REG_DATA);
269: }
270:
271: status = flash_reg8_read(sc, FLASH_REG_DATA);
272: return ((status & STATUS_FAIL) != 0 ? EIO : 0);
273: }
274:
275: void
276: flash_chip_enable(struct flash_softc *sc)
277: {
278: /* XXX aquire the lock. */
279: flash_reg8_write(sc, FLASH_REG_CE, 1);
280: }
281:
282: void
283: flash_chip_disable(struct flash_softc *sc)
284: {
285: flash_reg8_write(sc, FLASH_REG_CE, 0);
286: /* XXX release the lock. */
287: }
288:
289: int
290: flash_chip_reset(struct flash_softc *sc)
291: {
292: flash_reg8_write(sc, FLASH_REG_CLE, 1);
293: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_RESET);
294: flash_reg8_write(sc, FLASH_REG_CLE, 0);
295:
296: return flash_wait_ready(sc);
297: }
298:
299: int
300: flash_chip_identify(struct flash_softc *sc, u_int8_t *vendor,
301: u_int8_t *device)
302: {
303: int error;
304:
305: (void)flash_wait_ready(sc);
306:
307: flash_reg8_write(sc, FLASH_REG_CLE, 1);
308: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_READID);
309: flash_reg8_write(sc, FLASH_REG_CLE, 0);
310:
311: error = flash_wait_ready(sc);
312: if (error == 0) {
313: *vendor = flash_reg8_read(sc, FLASH_REG_DATA);
314: *device = flash_reg8_read(sc, FLASH_REG_DATA);
315: }
316: return error;
317: }
318:
319: int
320: flash_chip_erase_block(struct flash_softc *sc, long blkno)
321: {
322: long pageno = blkno * sc->sc_flashdev->blkpages;
323: int error;
324:
325: (void)flash_wait_ready(sc);
326:
327: /* Disable write-protection. */
328: flash_reg8_write(sc, FLASH_REG_WP, 0);
329:
330: switch (sc->sc_flashdev->id) {
331: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
332: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
333: flash_reg8_write(sc, FLASH_REG_CLE, 1);
334: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_ERASE0);
335: flash_reg8_write(sc, FLASH_REG_CLE, 0);
336: break;
337: }
338:
339: switch (sc->sc_flashdev->id) {
340: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
341: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
342: flash_reg8_write(sc, FLASH_REG_ALE, 1);
343: flash_reg8_write(sc, FLASH_REG_ROW, pageno);
344: flash_reg8_write(sc, FLASH_REG_ROW, pageno >> 8);
345: flash_reg8_write(sc, FLASH_REG_ALE, 0);
346: break;
347: }
348:
349: switch (sc->sc_flashdev->id) {
350: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
351: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
352: flash_reg8_write(sc, FLASH_REG_CLE, 1);
353: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_ERASE1);
354: flash_reg8_write(sc, FLASH_REG_CLE, 0);
355: break;
356: }
357:
358: error = flash_wait_complete(sc);
359:
360: /* Re-enable write-protection. */
361: flash_reg8_write(sc, FLASH_REG_WP, 1);
362:
363: return error;
364: }
365:
366: int
367: flash_chip_read_block(struct flash_softc *sc, long blkno, caddr_t data)
368: {
369: long pageno;
370: long blkend;
371: int error;
372:
373: pageno = blkno * sc->sc_flashdev->blkpages;
374: blkend = pageno + sc->sc_flashdev->blkpages;
375:
376: while (pageno < blkend) {
377: error = flash_chip_read_page(sc, pageno, data, NULL);
378: if (error != 0)
379: return error;
380: data += sc->sc_flashdev->pagesize;
381: pageno++;
382: }
383: return 0;
384: }
385:
386: int
387: flash_chip_read_page(struct flash_softc *sc, long pageno, caddr_t data,
388: caddr_t oob)
389: {
390: int error;
391:
392: (void)flash_wait_ready(sc);
393:
394: switch (sc->sc_flashdev->id) {
395: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
396: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
397: flash_reg8_write(sc, FLASH_REG_CLE, 1);
398: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_PTRLO);
399: flash_reg8_write(sc, FLASH_REG_CLE, 0);
400: break;
401: }
402:
403: switch (sc->sc_flashdev->id) {
404: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
405: flash_reg8_write(sc, FLASH_REG_ALE, 1);
406: flash_reg8_write(sc, FLASH_REG_COL, 0x00);
407: flash_reg8_write(sc, FLASH_REG_ALE, 0);
408: break;
409: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
410: flash_reg8_write(sc, FLASH_REG_ALE, 1);
411: flash_reg8_write(sc, FLASH_REG_COL, 0x00);
412: flash_reg8_write(sc, FLASH_REG_COL, 0x00);
413: flash_reg8_write(sc, FLASH_REG_ALE, 0);
414: break;
415: }
416:
417: switch (sc->sc_flashdev->id) {
418: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
419: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
420: flash_reg8_write(sc, FLASH_REG_ALE, 1);
421: flash_reg8_write(sc, FLASH_REG_ROW, pageno);
422: flash_reg8_write(sc, FLASH_REG_ROW, pageno >> 8);
423: flash_reg8_write(sc, FLASH_REG_ALE, 0);
424: break;
425: }
426:
427: switch (sc->sc_flashdev->id) {
428: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
429: flash_reg8_write(sc, FLASH_REG_CLE, 1);
430: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_READ);
431: flash_reg8_write(sc, FLASH_REG_CLE, 0);
432: break;
433: }
434:
435: if ((error = flash_wait_ready(sc)) != 0)
436: return error;
437:
438: /* Support hardware ECC calculation. */
439: if (sc->sc_tag->regx_read_page) {
440: error = sc->sc_tag->regx_read_page(sc->sc_cookie, data,
441: oob);
442: if (error != 0)
443: return error;
444: } else
445: flash_reg8_read_page(sc, data, oob);
446:
447: return 0;
448: }
449:
450: int
451: flash_chip_read_oob(struct flash_softc *sc, long pageno, caddr_t oob)
452: {
453: u_int8_t *p = (u_int8_t *)oob;
454: int error;
455: int i;
456:
457: (void)flash_wait_ready(sc);
458:
459: switch (sc->sc_flashdev->id) {
460: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
461: flash_reg8_write(sc, FLASH_REG_CLE, 1);
462: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_PTROOB);
463: flash_reg8_write(sc, FLASH_REG_CLE, 0);
464: break;
465: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
466: flash_reg8_write(sc, FLASH_REG_CLE, 1);
467: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_PTRLO);
468: flash_reg8_write(sc, FLASH_REG_CLE, 0);
469: break;
470: }
471:
472: switch (sc->sc_flashdev->id) {
473: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
474: flash_reg8_write(sc, FLASH_REG_ALE, 1);
475: flash_reg8_write(sc, FLASH_REG_COL, 0x00);
476: flash_reg8_write(sc, FLASH_REG_ALE, 0);
477: break;
478: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
479: flash_reg8_write(sc, FLASH_REG_ALE, 1);
480: flash_reg8_write(sc, FLASH_REG_COL, 0x00);
481: flash_reg8_write(sc, FLASH_REG_COL, 0x08);
482: flash_reg8_write(sc, FLASH_REG_ALE, 0);
483: break;
484: }
485:
486: switch (sc->sc_flashdev->id) {
487: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
488: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
489: flash_reg8_write(sc, FLASH_REG_ALE, 1);
490: flash_reg8_write(sc, FLASH_REG_ROW, pageno);
491: flash_reg8_write(sc, FLASH_REG_ROW, pageno >> 8);
492: flash_reg8_write(sc, FLASH_REG_ALE, 0);
493: break;
494: }
495:
496: switch (sc->sc_flashdev->id) {
497: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
498: flash_reg8_write(sc, FLASH_REG_CLE, 1);
499: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_READ);
500: flash_reg8_write(sc, FLASH_REG_CLE, 0);
501: break;
502: }
503:
504: if ((error = flash_wait_ready(sc)) != 0)
505: return error;
506:
507: for (i = 0; i < sc->sc_flashdev->oobsize; i++)
508: p[i] = flash_reg8_read(sc, FLASH_REG_DATA);
509:
510: return 0;
511: }
512:
513: int
514: flash_chip_write_block(struct flash_softc *sc, long blkno, caddr_t data,
515: caddr_t oob)
516: {
517: long pageno;
518: long blkend;
519: caddr_t p;
520: int error;
521:
522: pageno = blkno * sc->sc_flashdev->blkpages;
523: blkend = pageno + sc->sc_flashdev->blkpages;
524:
525: p = data;
526: while (pageno < blkend) {
527: error = flash_chip_write_page(sc, pageno, p, oob);
528: if (error != 0)
529: return error;
530: p += sc->sc_flashdev->pagesize;
531: pageno++;
532: }
533:
534: /* Verify the newly written block. */
535: return flash_chip_verify_block(sc, blkno, data, oob);
536: }
537:
538: int
539: flash_chip_write_page(struct flash_softc *sc, long pageno, caddr_t data,
540: caddr_t oob)
541: {
542: int error;
543:
544: (void)flash_wait_ready(sc);
545:
546: /* Disable write-protection. */
547: flash_reg8_write(sc, FLASH_REG_WP, 0);
548:
549: switch (sc->sc_flashdev->id) {
550: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
551: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
552: flash_reg8_write(sc, FLASH_REG_CLE, 1);
553: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_PTRLO);
554: flash_reg8_write(sc, FLASH_REG_CLE, 0);
555: break;
556: }
557:
558: switch (sc->sc_flashdev->id) {
559: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
560: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
561: flash_reg8_write(sc, FLASH_REG_CLE, 1);
562: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_SEQIN);
563: flash_reg8_write(sc, FLASH_REG_CLE, 0);
564: break;
565: }
566:
567: switch (sc->sc_flashdev->id) {
568: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
569: flash_reg8_write(sc, FLASH_REG_ALE, 1);
570: flash_reg8_write(sc, FLASH_REG_COL, 0x00);
571: flash_reg8_write(sc, FLASH_REG_ALE, 0);
572: break;
573: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
574: flash_reg8_write(sc, FLASH_REG_ALE, 1);
575: flash_reg8_write(sc, FLASH_REG_COL, 0x00);
576: flash_reg8_write(sc, FLASH_REG_COL, 0x00);
577: flash_reg8_write(sc, FLASH_REG_ALE, 0);
578: break;
579: }
580:
581: switch (sc->sc_flashdev->id) {
582: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
583: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
584: flash_reg8_write(sc, FLASH_REG_ALE, 1);
585: flash_reg8_write(sc, FLASH_REG_ROW, pageno);
586: flash_reg8_write(sc, FLASH_REG_ROW, pageno >> 8);
587: flash_reg8_write(sc, FLASH_REG_ALE, 0);
588: break;
589: }
590:
591: /* Support hardware ECC calculation. */
592: if (sc->sc_tag->regx_write_page) {
593: error = sc->sc_tag->regx_write_page(sc->sc_cookie, data,
594: oob);
595: if (error != 0)
596: return error;
597: } else
598: flash_reg8_write_page(sc, data, oob);
599:
600: switch (sc->sc_flashdev->id) {
601: case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
602: case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
603: flash_reg8_write(sc, FLASH_REG_CLE, 1);
604: flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_WRITE);
605: flash_reg8_write(sc, FLASH_REG_CLE, 0);
606: break;
607: }
608:
609: /*
610: * Wait for the write operation to complete although this can
611: * take up to 700 us for the K9F1G08U0A flash type.
612: */
613: error = flash_wait_complete(sc);
614:
615: /* Re-enable write-protection. */
616: flash_reg8_write(sc, FLASH_REG_WP, 1);
617:
618: return error;
619: }
620:
621: int
622: flash_chip_verify_block(struct flash_softc *sc, long blkno, caddr_t data,
623: caddr_t oob)
624: {
625: long pageno;
626: long blkend;
627: int error;
628:
629: pageno = blkno * sc->sc_flashdev->blkpages;
630: blkend = pageno + sc->sc_flashdev->blkpages;
631:
632: while (pageno < blkend) {
633: error = flash_chip_verify_page(sc, pageno, data, oob);
634: if (error != 0) {
635: printf("block %d page %d verify failed\n",
636: blkno, pageno);
637: return error;
638: }
639: data += sc->sc_flashdev->pagesize;
640: pageno++;
641: }
642: return 0;
643: }
644:
645: int
646: flash_chip_verify_page(struct flash_softc *sc, long pageno, caddr_t data,
647: caddr_t oob)
648: {
649: static u_char rbuf[FLASH_MAXPAGESIZE];
650: static u_char roob[FLASH_MAXOOBSIZE];
651: int error;
652:
653: error = flash_chip_read_page(sc, pageno, rbuf,
654: oob == NULL ? NULL : roob);
655: if (error != 0)
656: return error;
657:
658: if (memcmp((const void *)&rbuf[0], (const void *)data,
659: sc->sc_flashdev->pagesize) != 0)
660: return EIO;
661:
662: if (oob != NULL && memcmp((const void *)&roob[0],
663: (const void *)oob, sc->sc_flashdev->oobsize) != 0)
664: return EIO;
665:
666: return 0;
667: }
668:
669: /*
670: * Block device functions
671: */
672:
673: int
674: flashopen(dev_t dev, int oflags, int devtype, struct proc *p)
675: {
676: struct flash_softc *sc;
677: int error;
678: int part;
679:
680: sc = flashlookup(flashunit(dev));
681: if (sc == NULL)
682: return ENXIO;
683:
684: if ((error = flashlock(sc)) != 0) {
685: device_unref(&sc->sc_dev);
686: return error;
687: }
688:
689: /*
690: * If no partition is open load the partition info if it is
691: * not already valid. If partitions are already open, allow
692: * opens only for the same kind of device.
693: */
694: if (sc->sc_dk.dk_openmask == 0) {
695: if ((sc->sc_flags & FDK_LOADED) == 0 ||
696: ((sc->sc_flags & FDK_SAFE) == 0) !=
697: (flashsafe(dev) == 0)) {
698: sc->sc_flags &= ~FDK_SAFE;
699: sc->sc_flags |= FDK_LOADED;
700: if (flashsafe(dev))
701: sc->sc_flags |= FDK_SAFE;
702: flashgetdisklabel(dev, sc, sc->sc_dk.dk_label, 0);
703: }
704: } else if (((sc->sc_flags & FDK_SAFE) == 0) !=
705: (flashsafe(dev) == 0)) {
706: flashunlock(sc);
707: device_unref(&sc->sc_dev);
708: return EBUSY;
709: }
710:
711: /* Check that the partition exists. */
712: part = flashpart(dev);
713: if (part != RAW_PART &&
714: (part >= sc->sc_dk.dk_label->d_npartitions ||
715: sc->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
716: flashunlock(sc);
717: device_unref(&sc->sc_dev);
718: return ENXIO;
719: }
720:
721: /* Prevent our unit from being deconfigured while open. */
722: switch (devtype) {
723: case S_IFCHR:
724: sc->sc_dk.dk_copenmask |= (1 << part);
725: break;
726: case S_IFBLK:
727: sc->sc_dk.dk_bopenmask |= (1 << part);
728: break;
729: }
730: sc->sc_dk.dk_openmask =
731: sc->sc_dk.dk_copenmask | sc->sc_dk.dk_bopenmask;
732:
733: flashunlock(sc);
734: device_unref(&sc->sc_dev);
735: return 0;
736: }
737:
738: int
739: flashclose(dev_t dev, int fflag, int devtype, struct proc *p)
740: {
741: struct flash_softc *sc;
742: int error;
743: int part;
744:
745: sc = flashlookup(flashunit(dev));
746: if (sc == NULL)
747: return ENXIO;
748:
749: if ((error = flashlock(sc)) != 0) {
750: device_unref(&sc->sc_dev);
751: return error;
752: }
753:
754: /* Close one open partition. */
755: part = flashpart(dev);
756: switch (devtype) {
757: case S_IFCHR:
758: sc->sc_dk.dk_copenmask &= ~(1 << part);
759: break;
760: case S_IFBLK:
761: sc->sc_dk.dk_bopenmask &= ~(1 << part);
762: break;
763: }
764: sc->sc_dk.dk_openmask =
765: sc->sc_dk.dk_copenmask | sc->sc_dk.dk_bopenmask;
766:
767: if (sc->sc_dk.dk_openmask == 0) {
768: /* XXX wait for I/O to complete? */
769: }
770:
771: flashunlock(sc);
772: device_unref(&sc->sc_dev);
773: return 0;
774: }
775:
776: /*
777: * Queue the transfer of one or more flash pages.
778: */
779: void
780: flashstrategy(struct buf *bp)
781: {
782: struct flash_softc *sc;
783: int s;
784:
785: sc = flashlookup(flashunit(bp->b_dev));
786: if (sc == NULL) {
787: bp->b_error = ENXIO;
788: goto bad;
789: }
790:
791: /* Transfer only a multiple of the flash page size. */
792: if ((bp->b_bcount % sc->sc_flashdev->pagesize) != 0) {
793: bp->b_error = EINVAL;
794: goto bad;
795: }
796:
797: /* If the device has been invalidated, error out. */
798: if ((sc->sc_flags & FDK_LOADED) == 0) {
799: bp->b_error = EIO;
800: goto bad;
801: }
802:
803: /* Translate logical block numbers to physical. */
804: if (flashsafe(bp->b_dev) && flashsafestrategy(sc, bp) <= 0)
805: goto done;
806:
807: /* Return immediately if it is a null transfer. */
808: if (bp->b_bcount == 0)
809: goto done;
810:
811: /* Do bounds checking on partitions. */
812: if (flashpart(bp->b_dev) != RAW_PART &&
813: bounds_check_with_label(bp, sc->sc_dk.dk_label, 0) <= 0)
814: goto done;
815:
816: /* Queue the transfer. */
817: s = splbio();
818: disksort(&sc->sc_q, bp);
819: flashstart(sc);
820: splx(s);
821: device_unref(&sc->sc_dev);
822: return;
823:
824: bad:
825: bp->b_flags |= B_ERROR;
826: done:
827: if ((bp->b_flags & B_ERROR) != 0)
828: bp->b_resid = bp->b_bcount;
829: s = splbio();
830: biodone(bp);
831: splx(s);
832: if (sc != NULL)
833: device_unref(&sc->sc_dev);
834: }
835:
836: int
837: flashioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p)
838: {
839: struct flash_softc *sc;
840: int error = 0;
841:
842: sc = flashlookup(flashunit(dev));
843: if (sc == NULL)
844: return ENXIO;
845:
846: if ((sc->sc_flags & FDK_LOADED) == 0) {
847: device_unref(&sc->sc_dev);
848: return EIO;
849: }
850:
851: switch (cmd) {
852: case DIOCGDINFO:
853: *(struct disklabel *)data = *sc->sc_dk.dk_label;
854: break;
855: default:
856: error = ENOTTY;
857: break;
858: }
859:
860: device_unref(&sc->sc_dev);
861: return error;
862: }
863:
864: int
865: flashdump(dev_t dev, daddr64_t blkno, caddr_t va, size_t size)
866: {
867: printf("flashdump\n");
868: return ENODEV;
869: }
870:
871: daddr64_t
872: flashsize(dev_t dev)
873: {
874: printf("flashsize\n");
875: return ENODEV;
876: }
877:
878: void
879: flashstart(struct flash_softc *sc)
880: {
881: struct buf *dp, *bp;
882:
883: while (1) {
884: /* Remove the next buffer from the queue or stop. */
885: dp = &sc->sc_q;
886: bp = dp->b_actf;
887: if (bp == NULL)
888: return;
889: dp->b_actf = bp->b_actf;
890:
891: /* Transfer this buffer now. */
892: _flashstart(sc, bp);
893: }
894: }
895:
896: void
897: _flashstart(struct flash_softc *sc, struct buf *bp)
898: {
899: int part;
900: daddr64_t offset;
901: long pgno;
902:
903: part = flashpart(bp->b_dev);
904: offset = DL_GETPOFFSET(&sc->sc_dk.dk_label->d_partitions[part]) +
905: bp->b_blkno;
906: pgno = offset / (sc->sc_flashdev->pagesize / DEV_BSIZE);
907:
908: /*
909: * If the requested page is exactly at the end of flash and it
910: * is an "unsafe" device, return EOF, else error out.
911: */
912: if (!flashsafe(bp->b_dev) && pgno == sc->sc_flashdev->capacity) {
913: bp->b_resid = bp->b_bcount;
914: biodone(bp);
915: return;
916: } else if (pgno >= sc->sc_flashdev->capacity) {
917: bp->b_error = EINVAL;
918: bp->b_flags |= B_ERROR;
919: biodone(bp);
920: return;
921: }
922:
923: sc->sc_bp = bp;
924:
925: /* Instrumentation. */
926: disk_busy(&sc->sc_dk);
927:
928: /* XXX this should be done asynchronously. */
929: flash_chip_enable(sc);
930: if ((bp->b_flags & B_READ) != 0)
931: bp->b_error = flash_chip_read_page(sc, pgno, bp->b_data,
932: NULL);
933: else
934: bp->b_error = flash_chip_write_page(sc, pgno, bp->b_data,
935: NULL);
936: if (bp->b_error == 0)
937: bp->b_resid = bp->b_bcount - sc->sc_flashdev->pagesize;
938: flash_chip_disable(sc);
939: flashdone(sc);
940: }
941:
942: void
943: flashdone(void *v)
944: {
945: struct flash_softc *sc = v;
946: struct buf *bp = sc->sc_bp;
947:
948: /* Instrumentation. */
949: disk_unbusy(&sc->sc_dk, bp->b_bcount - bp->b_resid,
950: (bp->b_flags & B_READ) != 0);
951:
952: if (bp->b_error != 0)
953: bp->b_flags |= B_ERROR;
954:
955: biodone(bp);
956: flashstart(sc);
957: }
958:
959: void
960: flashgetdefaultlabel(dev_t dev, struct flash_softc *sc,
961: struct disklabel *lp)
962: {
963: size_t len;
964:
965: bzero(lp, sizeof(struct disklabel));
966:
967: lp->d_type = 0;
968: lp->d_subtype = 0;
969: strncpy(lp->d_typename, "NAND flash", sizeof(lp->d_typename));
970:
971: /* Use the product name up to the first space. */
972: strncpy(lp->d_packname, sc->sc_flashdev->longname,
973: sizeof(lp->d_packname));
974: for (len = 0; len < sizeof(lp->d_packname); len++)
975: if (lp->d_packname[len] == ' ') {
976: lp->d_packname[len] = '\0';
977: break;
978: }
979:
980: /* Fake the disk geometry. */
981: lp->d_ncylinders = 1;
982: lp->d_ntracks = 16;
983: lp->d_secsize = sc->sc_flashdev->pagesize;
984: lp->d_nsectors = sc->sc_flashdev->capacity / lp->d_ntracks
985: / lp->d_ncylinders;
986: lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
987: DL_SETDSIZE(lp, (daddr64_t)lp->d_ncylinders * lp->d_secpercyl);
988:
989: /* Fake hardware characteristics. */
990: lp->d_rpm = 3600;
991: lp->d_interleave = 1;
992: lp->d_version = 1;
993:
994: /* XXX these values assume ffs. */
995: lp->d_bbsize = BBSIZE;
996: lp->d_sbsize = SBSIZE;
997:
998: /* Wrap it up. */
999: lp->d_magic = DISKMAGIC;
1000: lp->d_magic2 = DISKMAGIC;
1001: lp->d_checksum = dkcksum(lp);
1002: }
1003:
1004: void
1005: flashgetdisklabel(dev_t dev, struct flash_softc *sc,
1006: struct disklabel *lp, int spoofonly)
1007: {
1008: char *errstring;
1009: dev_t labeldev;
1010:
1011: flashgetdefaultlabel(dev, sc, lp);
1012:
1013: if (sc->sc_tag->default_disklabel != NULL)
1014: sc->sc_tag->default_disklabel(sc->sc_cookie, dev, lp);
1015:
1016: /* Call the generic disklabel extraction routine. */
1017: labeldev = flashlabeldev(dev);
1018: errstring = readdisklabel(labeldev, flashstrategy, lp, spoofonly);
1019: if (errstring != NULL) {
1020: /*printf("%s: %s\n", sc->sc_dev.dv_xname, errstring);*/
1021: }
1022: }
1023:
1024: /*
1025: * Character device functions
1026: */
1027:
1028: void
1029: flashminphys(struct buf *bp)
1030: {
1031: struct flash_softc *sc;
1032:
1033: sc = flashlookup(flashunit(bp->b_dev));
1034:
1035: if (bp->b_bcount > sc->sc_flashdev->pagesize)
1036: bp->b_bcount = sc->sc_flashdev->pagesize;
1037: }
1038:
1039: int
1040: flashread(dev_t dev, struct uio *uio, int ioflag)
1041: {
1042: return physio(flashstrategy, NULL, dev, B_READ, flashminphys, uio);
1043: }
1044:
1045: int
1046: flashwrite(dev_t dev, struct uio *uio, int ioflag)
1047: {
1048: return physio(flashstrategy, NULL, dev, B_WRITE, flashminphys, uio);
1049: }
1050:
1051: /*
1052: * Physical access strategy "fixup" routines for transparent bad
1053: * blocks management, wear-leveling, etc.
1054: */
1055:
1056: /*
1057: * Call the machine-specific routine if there is any or use just a
1058: * default strategy for bad blocks management.
1059: */
1060: int
1061: flashsafestrategy(struct flash_softc *sc, struct buf *bp)
1062: {
1063: if (sc->sc_tag->safe_strategy) {
1064: return sc->sc_tag->safe_strategy(sc->sc_cookie, bp);
1065: }
1066:
1067: /* XXX no default bad blocks management strategy yet */
1068: return 1;
1069: }
1070:
1071: void dumppage(u_char *);
1072: void dumppage(u_char *buf)
1073: {
1074: int i;
1075: for (i = 0; i < 512; i++) {
1076: if ((i % 16) == 0)
1077: printf("%04x: ", i);
1078: if ((i % 16) == 8)
1079: printf(" ");
1080: printf(" %02x", buf[i]);
1081: if ((i % 16) == 15)
1082: printf("\n");
1083: }
1084: if ((i % 16) != 0)
1085: printf("\n");
1086: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to flash.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev