![[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 / arch / mvme68k / dev|
Return to flash.c CVS log | Up to [local] / sys / arch / mvme68k / dev |
1.1 nbrk 1: /* $OpenBSD: flash.c,v 1.17 2005/12/17 07:31:26 miod Exp $ */
2:
3: /*
4: * Copyright (c) 1995 Theo de Raadt
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26: */
27:
28: #include <sys/param.h>
29: #include <sys/ioctl.h>
30: #include <sys/proc.h>
31: #include <sys/user.h>
32: #include <sys/tty.h>
33: #include <sys/uio.h>
34: #include <sys/systm.h>
35: #include <sys/kernel.h>
36: #include <sys/malloc.h>
37: #include <sys/syslog.h>
38: #include <sys/fcntl.h>
39: #include <sys/device.h>
40:
41: #include <machine/autoconf.h>
42: #include <machine/conf.h>
43: #include <machine/cpu.h>
44: #include <machine/mioctl.h>
45:
46: #include "mc.h"
47:
48: #if NMC > 0
49: #include <mvme68k/dev/mcreg.h>
50: #endif
51:
52: #include <mvme68k/dev/flashreg.h>
53:
54: struct flashsoftc {
55: struct device sc_dev;
56: paddr_t sc_paddr;
57: volatile u_char *sc_vaddr;
58: u_char sc_manu;
59: u_char sc_ii;
60: int sc_len;
61: int sc_zonesize;
62: };
63:
64: void flashattach(struct device *, struct device *, void *);
65: int flashmatch(struct device *, void *, void *);
66:
67: struct cfattach flash_ca = {
68: sizeof(struct flashsoftc), flashmatch, flashattach
69: };
70:
71: struct cfdriver flash_cd = {
72: NULL, "flash", DV_DULL
73: };
74:
75: int flashwritebyte(struct flashsoftc *sc, int addr, u_char val);
76: int flasherasezone(struct flashsoftc *sc, int addr);
77: u_char *flashsavezone(struct flashsoftc *, int);
78: int flashwritezone(struct flashsoftc *, u_char *, int);
79:
80: struct flashii intel_flashii[] = {
81: { "28F008SA", FLII_INTEL_28F008SA, 1024*1024, 64*1024 },
82: { "28F008SA-L", FLII_INTEL_28F008SA_L, 1024*1024, 64*1024 },
83: { "28F016SA", FLII_INTEL_28F016SA, 1024*1024, 64*1024 },
84: { NULL },
85: };
86:
87: struct flashmanu {
88: char *name;
89: u_char manu;
90: struct flashii *flashii;
91: } flashmanu[] = {
92: { "intel", FLMANU_INTEL, intel_flashii },
93: { NULL, 0, NULL }
94: };
95:
96: int
97: flashmatch(parent, cf, args)
98: struct device *parent;
99: void *cf;
100: void *args;
101: {
102: struct confargs *ca = args;
103:
104: #ifdef MVME147
105: if (cputyp == CPU_147)
106: return (0);
107: #endif
108: #ifdef MVME167
109: /*
110: * XXX: 166 has 4 byte-wide flash rams side-by-side, and
111: * isn't supported (yet).
112: */
113: if (cputyp == CPU_166)
114: return (0);
115: if (cputyp == CPU_167)
116: return (0);
117: #endif
118: #ifdef MVME177
119: /*
120: * XXX: 177 has no flash.
121: */
122: if (cputyp == CPU_177)
123: return (0);
124: #endif
125:
126: if (badpaddr(ca->ca_paddr, 1))
127: return (0);
128:
129: if (!mc_hasflash())
130: return 0;
131:
132: return (1);
133: }
134:
135: void
136: flashattach(parent, self, args)
137: struct device *parent, *self;
138: void *args;
139: {
140: struct flashsoftc *sc = (struct flashsoftc *)self;
141: struct confargs *ca = args;
142: int manu, ident;
143:
144: sc->sc_paddr = ca->ca_paddr;
145: sc->sc_vaddr = (volatile u_char *)mapiodev(sc->sc_paddr, NBPG);
146:
147: switch (cputyp) {
148: #ifdef MVME162
149: case CPU_162:
150: mc_enableflashwrite(1);
151: break;
152: #endif
153: #ifdef MVME172
154: case CPU_172:
155: mc_enableflashwrite(1);
156: break;
157: #endif
158: }
159:
160: /* read manufacturer and product identifier from flash */
161: sc->sc_vaddr[0] = FLCMD_RESET;
162: sc->sc_vaddr[0] = FLCMD_READII;
163: sc->sc_manu = sc->sc_vaddr[0];
164: sc->sc_ii = sc->sc_vaddr[1];
165: sc->sc_vaddr[0] = FLCMD_RESET;
166: for (manu = 0; flashmanu[manu].name; manu++)
167: if (flashmanu[manu].manu == sc->sc_manu)
168: break;
169: if (flashmanu[manu].name == NULL) {
170: printf(": unknown manu 0x%02x ident %02x\n",
171: sc->sc_manu, sc->sc_ii);
172: return;
173: }
174: for (ident = 0; flashmanu[manu].flashii[ident].name; ident++)
175: if (flashmanu[manu].flashii[ident].ii == sc->sc_ii)
176: break;
177: if (flashmanu[manu].flashii[ident].name == NULL) {
178: printf(": unknown manu %s ident 0x%02x\n",
179: flashmanu[manu].name, sc->sc_ii);
180: return;
181: }
182: sc->sc_len = flashmanu[manu].flashii[ident].size;
183: sc->sc_zonesize = flashmanu[manu].flashii[ident].zonesize;
184: printf(": %s %s len %d", flashmanu[manu].name,
185: flashmanu[manu].flashii[ident].name, sc->sc_len);
186:
187: sc->sc_vaddr[0] = FLCMD_CLEARSTAT;
188: sc->sc_vaddr[0] = FLCMD_RESET;
189:
190: unmapiodev((vaddr_t)sc->sc_vaddr, NBPG);
191: sc->sc_vaddr = (volatile u_char *)mapiodev(sc->sc_paddr, sc->sc_len);
192: if (sc->sc_vaddr == NULL) {
193: sc->sc_len = 0;
194: printf(" -- failed to map");
195: }
196: printf("\n");
197: }
198:
199: u_char *
200: flashsavezone(sc, start)
201: struct flashsoftc *sc;
202: int start;
203: {
204: u_char *zone;
205:
206: zone = (u_char *)malloc(sc->sc_zonesize, M_TEMP, M_WAITOK);
207: sc->sc_vaddr[0] = FLCMD_RESET;
208: bcopy((u_char *)&sc->sc_vaddr[start], zone, sc->sc_zonesize);
209: return (zone);
210: }
211:
212: int
213: flashwritezone(sc, zone, start)
214: struct flashsoftc *sc;
215: u_char *zone;
216: int start;
217: {
218: u_char sr;
219: int i;
220:
221: for (i = 0; i < sc->sc_zonesize; i++) {
222: if (zone[i] == 0xff)
223: continue;
224: sc->sc_vaddr[start + i] = FLCMD_WSETUP;
225: sc->sc_vaddr[start + i] = zone[i];
226: do {
227: sc->sc_vaddr[0] = FLCMD_READSTAT;
228: sr = sc->sc_vaddr[0];
229: } while ((sr & FLSR_WSMS) == 0);
230: if (sr & FLSR_BWS)
231: return (i); /* write failed on this byte! */
232: sc->sc_vaddr[0] = FLCMD_RESET;
233: }
234: free(zone, M_TEMP);
235: return (0);
236: }
237:
238: int
239: flasherasezone(sc, addr)
240: struct flashsoftc *sc;
241: int addr;
242: {
243: u_char sr;
244:
245: printf("erasing zone at %d\n", addr);
246:
247: sc->sc_vaddr[addr] = FLCMD_ESETUP;
248: sc->sc_vaddr[addr] = FLCMD_ECONFIRM;
249:
250: sc->sc_vaddr[0] = FLCMD_READSTAT;
251: sr = sc->sc_vaddr[0];
252: while ((sr & FLSR_WSMS) == 0) {
253: sc->sc_vaddr[0] = FLCMD_READSTAT;
254: sr = sc->sc_vaddr[0];
255: }
256: printf("sr=%2x\n", sr);
257:
258: sc->sc_vaddr[0] = FLCMD_RESET;
259: if (sr & FLSR_ES)
260: return (-1);
261: return (0);
262: }
263:
264: /*
265: * Should add some light retry code. If a write fails see if an
266: * erase helps the situation... eventually flash rams become
267: * useless but perhaps we can get just one more cycle out of it.
268: */
269: int
270: flashwritebyte(sc, addr, val)
271: struct flashsoftc *sc;
272: int addr;
273: u_char val;
274: {
275: u_char sr;
276:
277: sc->sc_vaddr[addr] = FLCMD_CLEARSTAT;
278: sr = sc->sc_vaddr[0];
279: sc->sc_vaddr[addr] = FLCMD_WSETUP;
280: sc->sc_vaddr[addr] = val;
281: delay(9);
282: do {
283: sr = sc->sc_vaddr[addr];
284: } while ((sr & FLSR_WSMS) == 0);
285: printf("write status %2x\n", sr);
286:
287: sc->sc_vaddr[0] = FLCMD_RESET;
288: if (sr & FLSR_BWS)
289: return (-1); /* write failed! */
290: return (0);
291: }
292:
293:
294: /*ARGSUSED*/
295: int
296: flashopen(dev, flag, mode, p)
297: dev_t dev;
298: int flag, mode;
299: struct proc *p;
300: {
301:
302: if (minor(dev) >= flash_cd.cd_ndevs ||
303: flash_cd.cd_devs[minor(dev)] == NULL)
304: return (ENODEV);
305:
306: return (0);
307: }
308:
309: /*ARGSUSED*/
310: int
311: flashclose(dev, flag, mode, p)
312: dev_t dev;
313: int flag, mode;
314: struct proc *p;
315: {
316:
317: return (0);
318: }
319:
320: /*ARGSUSED*/
321: int
322: flashioctl(dev, cmd, data, flag, p)
323: dev_t dev;
324: u_long cmd;
325: caddr_t data;
326: int flag;
327: struct proc *p;
328: {
329: int unit = minor(dev);
330: struct flashsoftc *sc = (struct flashsoftc *) flash_cd.cd_devs[unit];
331: int error = 0;
332:
333: switch (cmd) {
334: case MIOCGSIZ:
335: *(int *)data = sc->sc_len;
336: break;
337: default:
338: error = ENOTTY;
339: break;
340: }
341: return (error);
342: }
343:
344: /*ARGSUSED*/
345: int
346: flashread(dev, uio, flags)
347: dev_t dev;
348: struct uio *uio;
349: int flags;
350: {
351: int unit = minor(dev);
352: struct flashsoftc *sc = (struct flashsoftc *) flash_cd.cd_devs[unit];
353: vaddr_t v;
354: int c;
355: struct iovec *iov;
356: int error = 0;
357:
358: while (uio->uio_resid > 0 && error == 0) {
359: iov = uio->uio_iov;
360: if (iov->iov_len == 0) {
361: uio->uio_iov++;
362: uio->uio_iovcnt--;
363: if (uio->uio_iovcnt < 0)
364: panic("flashrw");
365: continue;
366: }
367:
368: v = uio->uio_offset;
369: c = min(iov->iov_len, MAXPHYS);
370: if (v + c > sc->sc_len)
371: c = sc->sc_len - v; /* till end of FLASH */
372: if (c == 0)
373: return (0);
374: error = uiomove((u_char *)sc->sc_vaddr + v, c, uio);
375: }
376: return (error);
377: }
378:
379: /*ARGSUSED*/
380: int
381: flashwrite(dev, uio, flags)
382: dev_t dev;
383: struct uio *uio;
384: int flags;
385: {
386: int unit = minor(dev);
387: struct flashsoftc *sc = (struct flashsoftc *) flash_cd.cd_devs[unit];
388: vaddr_t v;
389: int c, i, r;
390: struct iovec *iov;
391: int error = 0;
392: u_char *cmpbuf;
393: int neederase = 0, needwrite = 0;
394: int zonestart, zoneoff;
395:
396: cmpbuf = (u_char *)malloc(sc->sc_zonesize, M_TEMP, M_WAITOK);
397:
398: while (uio->uio_resid > 0 && error == 0) {
399: iov = uio->uio_iov;
400: if (iov->iov_len == 0) {
401: uio->uio_iov++;
402: uio->uio_iovcnt--;
403: if (uio->uio_iovcnt < 0)
404: panic("flashrw");
405: continue;
406: }
407:
408: /*
409: * constrain to be at most a zone in size, and
410: * aligned to be within that one zone only.
411: */
412: v = uio->uio_offset;
413: zonestart = v & ~(sc->sc_zonesize - 1);
414: zoneoff = v & (sc->sc_zonesize - 1);
415: c = min(iov->iov_len, MAXPHYS);
416: if (v + c > sc->sc_len)
417: c = sc->sc_len - v; /* till end of FLASH */
418: if (c > sc->sc_zonesize - zoneoff)
419: c = sc->sc_zonesize - zoneoff; /* till end of zone */
420: if (c == 0)
421: return (0);
422: error = uiomove((u_char *)cmpbuf, c, uio);
423:
424: /*
425: * compare to see if we are going to need a block erase
426: * operation.
427: */
428: sc->sc_vaddr[0] = FLCMD_RESET;
429: for (i = 0; i < c; i++) {
430: u_char x = sc->sc_vaddr[v + i];
431: if (cmpbuf[i] & ~x)
432: neederase = 1;
433: if (cmpbuf[i] != x)
434: needwrite = 1;
435: }
436: if (needwrite && !neederase) {
437: /*
438: * we don't need to erase. all the bytes being
439: * written (thankfully) set bits.
440: */
441: for (i = 0; i < c; i++) {
442: if (cmpbuf[i] == sc->sc_vaddr[v + i])
443: continue;
444: r = flashwritebyte(sc, v + i, cmpbuf[i]);
445: if (r == 0)
446: continue;
447: /*
448: * this doesn't make sense. we
449: * thought we didn't need to erase,
450: * but a write failed. let's try an
451: * erase operation..
452: */
453: printf("%s: failed write at %d, trying erase\n",
454: sc->sc_dev.dv_xname, i);
455: goto tryerase;
456: }
457: } else if (neederase) {
458: u_char *mem;
459:
460: tryerase:
461: mem = flashsavezone(sc, zonestart);
462: for (i = 0; i < c; i++)
463: mem[zoneoff + i] = cmpbuf[i];
464: flasherasezone(sc, zonestart);
465: r = flashwritezone(sc, mem, zonestart);
466: if (r) {
467: printf("%s: failed at offset %x\n",
468: sc->sc_dev.dv_xname, r);
469: free(mem, M_TEMP);
470: error = EIO;
471: }
472: }
473: }
474:
475: free(cmpbuf, M_TEMP);
476: return (error);
477: }
478:
479: paddr_t
480: flashmmap(dev, off, prot)
481: dev_t dev;
482: off_t off;
483: int prot;
484: {
485: int unit = minor(dev);
486: struct flashsoftc *sc = (struct flashsoftc *) flash_cd.cd_devs[unit];
487:
488: /* allow access only in RAM */
489: if (off < 0 || off > sc->sc_len)
490: return (-1);
491: return (atop(sc->sc_paddr + off));
492: }