?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
No empty .Rs/.Re
[netbsd-mini2440.git] / sys / arch / dreamcast / dev / maple / mmemcard.c
blob3b5efa35f215b642b4da2d45d5c69f7ddba38d4a
1 /* $NetBSD: mmemcard.c,v 1.17 2008/06/11 14:55:30 tsutsui Exp $ */
2
3 /*-
4 * Copyright (c) 2002 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by ITOH Yasufumi.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __KERNEL_RCSID(0, "$NetBSD: mmemcard.c,v 1.17 2008/06/11 14:55:30 tsutsui Exp $");
34
35 #include <sys/param.h>
36 #include <sys/buf.h>
37 #include <sys/bufq.h>
38 #include <sys/device.h>
39 #include <sys/disklabel.h>
40 #include <sys/disk.h>
41 #include <sys/kernel.h>
42 #include <sys/malloc.h>
43 #include <sys/proc.h>
44 #include <sys/stat.h>
45 #include <sys/systm.h>
46 #include <sys/vnode.h>
47 #include <sys/conf.h>
48
49 #include <dreamcast/dev/maple/maple.h>
50 #include <dreamcast/dev/maple/mapleconf.h>
51
52 #define MMEM_MAXACCSIZE 1012 /* (255*4) - 8 = 253*32 / 8 */
53
54 struct mmem_funcdef { /* XXX assuming little-endian structure packing */
55 unsigned unused : 8,
56 ra : 4, /* number of access / read */
57 wa : 4, /* number of access / write */
58 bb : 8, /* block size / 32 - 1 */
59 pt : 8; /* number of partition - 1 */
60 };
61
62 struct mmem_request_read_data {
63 uint32_t func_code;
64 uint8_t pt;
65 uint8_t phase;
66 uint16_t block;
67 };
68
69 struct mmem_response_read_data {
70 uint32_t func_code; /* function code (big endian) */
71 uint32_t blkno; /* 512byte block number (big endian) */
72 uint8_t data[MMEM_MAXACCSIZE];
73 };
74
75 struct mmem_request_write_data {
76 uint32_t func_code;
77 uint8_t pt;
78 uint8_t phase; /* 0, 1, 2, 3: for each 128 byte */
79 uint16_t block;
80 uint8_t data[MMEM_MAXACCSIZE];
81 };
82 #define MMEM_SIZE_REQW(sc) ((sc)->sc_waccsz + 8)
83
84 struct mmem_request_get_media_info {
85 uint32_t func_code;
86 uint32_t pt; /* pt (1 byte) and unused 3 bytes */
87 };
88
89 struct mmem_media_info {
90 uint16_t maxblk, minblk;
91 uint16_t infpos;
92 uint16_t fatpos, fatsz;
93 uint16_t dirpos, dirsz;
94 uint16_t icon;
95 uint16_t datasz;
96 uint16_t rsvd[3];
97 };
98
99 struct mmem_response_media_info {
100 uint32_t func_code; /* function code (big endian) */
101 struct mmem_media_info info;
102 };
103
104 struct mmem_softc {
105 struct device sc_dev;
106
107 struct device *sc_parent;
108 struct maple_unit *sc_unit;
109 struct maple_devinfo *sc_devinfo;
110
111 enum mmem_stat {
112 MMEM_INIT, /* during initialization */
113 MMEM_INIT2, /* during initialization */
114 MMEM_IDLE, /* init done, not in I/O */
115 MMEM_READ, /* in read operation */
116 MMEM_WRITE1, /* in write operation (read and compare) */
117 MMEM_WRITE2, /* in write operation (write) */
118 MMEM_DETACH /* detaching */
119 } sc_stat;
120
121 int sc_npt; /* number of partitions */
122 int sc_bsize; /* block size */
123 int sc_wacc; /* number of write access per block */
124 int sc_waccsz; /* size of a write access */
125 int sc_racc; /* number of read access per block */
126 int sc_raccsz; /* size of a read access */
127
128 struct mmem_pt {
129 int pt_flags;
130 #define MMEM_PT_OK 1 /* partition is alive */
131 struct disk pt_dk; /* disk(9) */
132 struct mmem_media_info pt_info; /* geometry per part */
133
134 char pt_name[16 /* see device.h */ + 4 /* ".255" */];
135 } *sc_pt;
136
137 /* write request buffer (only one is used at a time) */
138 union {
139 struct mmem_request_read_data req_read;
140 struct mmem_request_write_data req_write;
141 struct mmem_request_get_media_info req_minfo;
142 } sc_req;
143 #define sc_reqr sc_req.req_read
144 #define sc_reqw sc_req.req_write
145 #define sc_reqm sc_req.req_minfo
146
147 /* pending buffers */
148 struct bufq_state *sc_q;
149
150 /* current I/O access */
151 struct buf *sc_bp;
152 int sc_cnt;
153 char *sc_iobuf;
154 int sc_retry;
155 #define MMEM_MAXRETRY 12
156 };
157
158 /*
159 * minor number layout (mmemdetach() depends on this layout):
160 *
161 * 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
162 * |---------------------| |---------------------| |---------|
163 * unit part disklabel partition
164 */
165 #define MMEM_PART(diskunit) ((diskunit) & 0xff)
166 #define MMEM_UNIT(diskunit) ((diskunit) >> 8)
167 #define MMEM_DISKMINOR(unit, part, disklabel_partition) \
168 DISKMINOR(((unit) << 8) | (part), (disklabel_partition))
169
170 static int mmemmatch(struct device *, struct cfdata *, void *);
171 static void mmemattach(struct device *, struct device *, void *);
172 static void mmem_defaultlabel(struct mmem_softc *, struct mmem_pt *,
173 struct disklabel *);
174 static int mmemdetach(struct device *, int);
175 static void mmem_intr(void *, struct maple_response *, int, int);
176 static void mmem_printerror(const char *, int, int, uint32_t);
177 static void mmemstart(struct mmem_softc *);
178 static void mmemstart_bp(struct mmem_softc *);
179 static void mmemstart_write2(struct mmem_softc *);
180 static void mmemdone(struct mmem_softc *, struct mmem_pt *, int);
181
182 dev_type_open(mmemopen);
183 dev_type_close(mmemclose);
184 dev_type_read(mmemread);
185 dev_type_write(mmemwrite);
186 dev_type_ioctl(mmemioctl);
187 dev_type_strategy(mmemstrategy);
188
189 const struct bdevsw mmem_bdevsw = {
190 mmemopen, mmemclose, mmemstrategy, mmemioctl, nodump,
191 nosize, D_DISK
192 };
193
194 const struct cdevsw mmem_cdevsw = {
195 mmemopen, mmemclose, mmemread, mmemwrite, mmemioctl,
196 nostop, notty, nopoll, nommap, nokqfilter, D_DISK
197 };
198
199 CFATTACH_DECL(mmem, sizeof(struct mmem_softc),
200 mmemmatch, mmemattach, mmemdetach, NULL);
201
202 extern struct cfdriver mmem_cd;
203
204 struct dkdriver mmemdkdriver = { mmemstrategy };
205
206 static int
207 mmemmatch(struct device *parent, struct cfdata *cf, void *aux)
208 {
209 struct maple_attach_args *ma = aux;
210
211 return ma->ma_function == MAPLE_FN_MEMCARD ? MAPLE_MATCH_FUNC : 0;
212 }
213
214 static void
215 mmemattach(struct device *parent, struct device *self, void *aux)
216 {
217 struct mmem_softc *sc = (void *)self;
218 struct maple_attach_args *ma = aux;
219 int i;
220 union {
221 uint32_t v;
222 struct mmem_funcdef s;
223 } funcdef;
224
225 sc->sc_parent = parent;
226 sc->sc_unit = ma->ma_unit;
227 sc->sc_devinfo = ma->ma_devinfo;
228
229 funcdef.v = maple_get_function_data(ma->ma_devinfo, MAPLE_FN_MEMCARD);
230 printf(": Memory card\n");
231 printf("%s: %d part, %d bytes/block, ",
232 sc->sc_dev.dv_xname,
233 sc->sc_npt = funcdef.s.pt + 1,
234 sc->sc_bsize = (funcdef.s.bb + 1) << 5);
235 if ((sc->sc_wacc = funcdef.s.wa) == 0)
236 printf("no write, ");
237 else
238 printf("%d acc/write, ", sc->sc_wacc);
239 if ((sc->sc_racc = funcdef.s.ra) == 0)
240 printf("no read\n");
241 else
242 printf("%d acc/read\n", sc->sc_racc);
243
244 /*
245 * start init sequence
246 */
247 sc->sc_stat = MMEM_INIT;
248 bufq_alloc(&sc->sc_q, "disksort", BUFQ_SORT_RAWBLOCK);
249
250 /* check consistency */
251 if (sc->sc_wacc != 0) {
252 sc->sc_waccsz = sc->sc_bsize / sc->sc_wacc;
253 if (sc->sc_bsize != sc->sc_waccsz * sc->sc_wacc) {
254 printf("%s: write access isn't equally divided\n",
255 sc->sc_dev.dv_xname);
256 sc->sc_wacc = 0; /* no write */
257 } else if (sc->sc_waccsz > MMEM_MAXACCSIZE) {
258 printf("%s: write access size is too large\n",
259 sc->sc_dev.dv_xname);
260 sc->sc_wacc = 0; /* no write */
261 }
262 }
263 if (sc->sc_racc != 0) {
264 sc->sc_raccsz = sc->sc_bsize / sc->sc_racc;
265 if (sc->sc_bsize != sc->sc_raccsz * sc->sc_racc) {
266 printf("%s: read access isn't equally divided\n",
267 sc->sc_dev.dv_xname);
268 sc->sc_racc = 0; /* no read */
269 } else if (sc->sc_raccsz > MMEM_MAXACCSIZE) {
270 printf("%s: read access size is too large\n",
271 sc->sc_dev.dv_xname);
272 sc->sc_racc = 0; /* no read */
273 }
274 }
275 if (sc->sc_wacc == 0 && sc->sc_racc == 0) {
276 printf("%s: device doesn't support read nor write\n",
277 sc->sc_dev.dv_xname);
278 return;
279 }
280
281 /* per-part structure */
282 sc->sc_pt = malloc(sizeof(struct mmem_pt) * sc->sc_npt, M_DEVBUF,
283 M_WAITOK|M_ZERO);
284
285 for (i = 0; i < sc->sc_npt; i++) {
286 sprintf(sc->sc_pt[i].pt_name, "%s.%d", sc->sc_dev.dv_xname, i);
287 }
288
289 maple_set_callback(parent, sc->sc_unit, MAPLE_FN_MEMCARD,
290 mmem_intr, sc);
291
292 /*
293 * get capacity (start from partition 0)
294 */
295 sc->sc_reqm.func_code = htobe32(MAPLE_FUNC(MAPLE_FN_MEMCARD));
296 sc->sc_reqm.pt = 0;
297 maple_command(sc->sc_parent, sc->sc_unit, MAPLE_FN_MEMCARD,
298 MAPLE_COMMAND_GETMINFO, sizeof sc->sc_reqm / 4, &sc->sc_reqm, 0);
299 }
300
301 static int
302 mmemdetach(struct device *self, int flags)
303 {
304 struct mmem_softc *sc = (struct mmem_softc *) self;
305 struct buf *bp;
306 int i;
307 int minor_l, minor_h;
308
309 sc->sc_stat = MMEM_DETACH; /* just in case */
310
311 /*
312 * kill pending I/O
313 */
314 if ((bp = sc->sc_bp) != NULL) {
315 bp->b_error = EIO;
316 bp->b_resid = bp->b_bcount;
317 biodone(bp);
318 }
319 while ((bp = bufq_get(sc->sc_q)) != NULL) {
320 bp->b_error = EIO;
321 bp->b_resid = bp->b_bcount;
322 biodone(bp);
323 }
324 bufq_free(sc->sc_q);
325
326 /*
327 * revoke vnodes
328 */
329 #ifdef __HAVE_OLD_DISKLABEL
330 #error This code assumes DISKUNIT() is contiguous in minor number.
331 #endif
332 minor_l = MMEM_DISKMINOR(device_unit(self), 0, 0);
333 minor_h = MMEM_DISKMINOR(device_unit(self), sc->sc_npt - 1,
334 MAXPARTITIONS - 1);
335 vdevgone(bdevsw_lookup_major(&mmem_bdevsw), minor_l, minor_h, VBLK);
336 vdevgone(cdevsw_lookup_major(&mmem_cdevsw), minor_l, minor_h, VCHR);
337
338 /*
339 * free per-partition structure
340 */
341 if (sc->sc_pt) {
342 /*
343 * detach disks
344 */
345 for (i = 0; i < sc->sc_npt; i++) {
346 if (sc->sc_pt[i].pt_flags & MMEM_PT_OK) {
347 disk_detach(&sc->sc_pt[i].pt_dk);
348 disk_destroy(&sc->sc_pt[i].pt_dk);
349 }
350 }
351 free(sc->sc_pt, M_DEVBUF);
352 }
353
354 return 0;
355 }
356
357 /* fake disklabel */
358 static void
359 mmem_defaultlabel(struct mmem_softc *sc, struct mmem_pt *pt,
360 struct disklabel *d)
361 {
362
363 memset(d, 0, sizeof *d);
364
365 #if 0
366 d->d_type = DTYPE_FLOPPY; /* XXX? */
367 #endif
368 strncpy(d->d_typename, sc->sc_devinfo->di_product_name,
369 sizeof d->d_typename);
370 strcpy(d->d_packname, "fictitious");
371 d->d_secsize = sc->sc_bsize;
372 d->d_ntracks = 1; /* XXX */
373 d->d_nsectors = d->d_secpercyl = 8; /* XXX */
374 d->d_secperunit = pt->pt_info.maxblk - pt->pt_info.minblk + 1;
375 d->d_ncylinders = d->d_secperunit / d->d_secpercyl;
376 d->d_rpm = 1; /* when 4 acc/write */
377
378 d->d_npartitions = RAW_PART + 1;
379 d->d_partitions[RAW_PART].p_size = d->d_secperunit;
380
381 d->d_magic = d->d_magic2 = DISKMAGIC;
382 d->d_checksum = dkcksum(d);
383 }
384
385 /*
386 * called back from maple bus driver
387 */
388 static void
389 mmem_intr(void *dev, struct maple_response *response, int sz, int flags)
390 {
391 struct mmem_softc *sc = dev;
392 struct mmem_response_read_data *r = (void *) response->data;
393 struct mmem_response_media_info *rm = (void *) response->data;
394 struct buf *bp;
395 int part;
396 struct mmem_pt *pt;
397 char pbuf[9];
398 int off;
399
400 switch (sc->sc_stat) {
401 case MMEM_INIT:
402 /* checking part geometry */
403 part = sc->sc_reqm.pt;
404 pt = &sc->sc_pt[part];
405 switch ((maple_response_t) response->response_code) {
406 case MAPLE_RESPONSE_DATATRF:
407 pt->pt_info = rm->info;
408 format_bytes(pbuf, sizeof(pbuf),
409 (uint64_t)
410 ((pt->pt_info.maxblk - pt->pt_info.minblk + 1)
411 * sc->sc_bsize));
412 printf("%s: %s, blk %d %d, inf %d, fat %d %d, dir %d %d, icon %d, data %d\n",
413 pt->pt_name,
414 pbuf,
415 pt->pt_info.maxblk, pt->pt_info.minblk,
416 pt->pt_info.infpos,
417 pt->pt_info.fatpos, pt->pt_info.fatsz,
418 pt->pt_info.dirpos, pt->pt_info.dirsz,
419 pt->pt_info.icon,
420 pt->pt_info.datasz);
421
422 disk_init(&pt->pt_dk, pt->pt_name, &mmemdkdriver);
423 disk_attach(&pt->pt_dk);
424
425 mmem_defaultlabel(sc, pt, pt->pt_dk.dk_label);
426
427 /* this partition is active */
428 pt->pt_flags = MMEM_PT_OK;
429
430 break;
431 default:
432 printf("%s: init: unexpected response %#x, sz %d\n",
433 pt->pt_name, be32toh(response->response_code), sz);
434 break;
435 }
436 if (++part == sc->sc_npt) {
437 #if 1
438 /*
439 * XXX Read a block and discard the contents (only to
440 * turn off the access indicator on Visual Memory).
441 */
442 pt = &sc->sc_pt[0];
443 sc->sc_reqr.func_code =
444 htobe32(MAPLE_FUNC(MAPLE_FN_MEMCARD));
445 sc->sc_reqr.pt = 0;
446 sc->sc_reqr.block = htobe16(pt->pt_info.minblk);
447 sc->sc_reqr.phase = 0;
448 maple_command(sc->sc_parent, sc->sc_unit,
449 MAPLE_FN_MEMCARD, MAPLE_COMMAND_BREAD,
450 sizeof sc->sc_reqr / 4, &sc->sc_reqr, 0);
451 sc->sc_stat = MMEM_INIT2;
452 #else
453 sc->sc_stat = MMEM_IDLE; /* init done */
454 #endif
455 } else {
456 sc->sc_reqm.pt = part;
457 maple_command(sc->sc_parent, sc->sc_unit,
458 MAPLE_FN_MEMCARD, MAPLE_COMMAND_GETMINFO,
459 sizeof sc->sc_reqm / 4, &sc->sc_reqm, 0);
460 }
461 break;
462
463 case MMEM_INIT2:
464 /* XXX just discard */
465 sc->sc_stat = MMEM_IDLE; /* init done */
466 break;
467
468 case MMEM_READ:
469 bp = sc->sc_bp;
470
471 switch ((maple_response_t) response->response_code) {
472 case MAPLE_RESPONSE_DATATRF: /* read done */
473 off = sc->sc_raccsz * sc->sc_reqr.phase;
474 memcpy(sc->sc_iobuf + off, r->data + off,
475 sc->sc_raccsz);
476
477 if (++sc->sc_reqr.phase == sc->sc_racc) {
478 /* all phase done */
479 pt = &sc->sc_pt[sc->sc_reqr.pt];
480 mmemdone(sc, pt, 0);
481 } else {
482 /* go next phase */
483 maple_command(sc->sc_parent, sc->sc_unit,
484 MAPLE_FN_MEMCARD, MAPLE_COMMAND_BREAD,
485 sizeof sc->sc_reqr / 4, &sc->sc_reqr, 0);
486 }
487 break;
488 case MAPLE_RESPONSE_FILEERR:
489 mmem_printerror(sc->sc_pt[sc->sc_reqr.pt].pt_name,
490 1, bp->b_rawblkno,
491 r->func_code /* XXX */);
492 mmemstart_bp(sc); /* retry */
493 break;
494 default:
495 printf("%s: read: unexpected response %#x %#x, sz %d\n",
496 sc->sc_pt[sc->sc_reqr.pt].pt_name,
497 be32toh(response->response_code),
498 be32toh(r->func_code), sz);
499 mmemstart_bp(sc); /* retry */
500 break;
501 }
502 break;
503
504 case MMEM_WRITE1: /* read before write / verify after write */
505 bp = sc->sc_bp;
506
507 switch ((maple_response_t) response->response_code) {
508 case MAPLE_RESPONSE_DATATRF: /* read done */
509 off = sc->sc_raccsz * sc->sc_reqr.phase;
510 if (memcmp(r->data + off, sc->sc_iobuf + off,
511 sc->sc_raccsz)) {
512 /*
513 * data differ, start writing
514 */
515 mmemstart_write2(sc);
516 } else if (++sc->sc_reqr.phase == sc->sc_racc) {
517 /*
518 * all phase done and compared equal
519 */
520 pt = &sc->sc_pt[sc->sc_reqr.pt];
521 mmemdone(sc, pt, 0);
522 } else {
523 /* go next phase */
524 maple_command(sc->sc_parent, sc->sc_unit,
525 MAPLE_FN_MEMCARD, MAPLE_COMMAND_BREAD,
526 sizeof sc->sc_reqr / 4, &sc->sc_reqr, 0);
527 }
528 break;
529 case MAPLE_RESPONSE_FILEERR:
530 mmem_printerror(sc->sc_pt[sc->sc_reqr.pt].pt_name,
531 1, bp->b_rawblkno,
532 r->func_code /* XXX */);
533 mmemstart_write2(sc); /* start writing */
534 break;
535 default:
536 printf("%s: verify: unexpected response %#x %#x, sz %d\n",
537 sc->sc_pt[sc->sc_reqr.pt].pt_name,
538 be32toh(response->response_code),
539 be32toh(r->func_code), sz);
540 mmemstart_write2(sc); /* start writing */
541 break;
542 }
543 break;
544
545 case MMEM_WRITE2: /* write */
546 bp = sc->sc_bp;
547
548 switch ((maple_response_t) response->response_code) {
549 case MAPLE_RESPONSE_OK: /* write done */
550 if (sc->sc_reqw.phase == sc->sc_wacc) {
551 /* all phase done */
552 mmemstart_bp(sc); /* start verify */
553 } else if (++sc->sc_reqw.phase == sc->sc_wacc) {
554 /* check error */
555 maple_command(sc->sc_parent, sc->sc_unit,
556 MAPLE_FN_MEMCARD, MAPLE_COMMAND_GETLASTERR,
557 2 /* no data */ , &sc->sc_reqw,
558 MAPLE_FLAG_CMD_PERIODIC_TIMING);
559 } else {
560 /* go next phase */
561 memcpy(sc->sc_reqw.data, sc->sc_iobuf +
562 sc->sc_waccsz * sc->sc_reqw.phase,
563 sc->sc_waccsz);
564 maple_command(sc->sc_parent, sc->sc_unit,
565 MAPLE_FN_MEMCARD, MAPLE_COMMAND_BWRITE,
566 MMEM_SIZE_REQW(sc) / 4, &sc->sc_reqw,
567 MAPLE_FLAG_CMD_PERIODIC_TIMING);
568 }
569 break;
570 case MAPLE_RESPONSE_FILEERR:
571 mmem_printerror(sc->sc_pt[sc->sc_reqw.pt].pt_name,
572 0, bp->b_rawblkno,
573 r->func_code /* XXX */);
574 mmemstart_write2(sc); /* retry writing */
575 break;
576 default:
577 printf("%s: write: unexpected response %#x, %#x, sz %d\n",
578 sc->sc_pt[sc->sc_reqw.pt].pt_name,
579 be32toh(response->response_code),
580 be32toh(r->func_code), sz);
581 mmemstart_write2(sc); /* retry writing */
582 break;
583 }
584 break;
585
586 default:
587 break;
588 }
589 }
590
591 static void
592 mmem_printerror(const char *head, int rd, int blk, uint32_t code)
593 {
594
595 printf("%s: error %sing blk %d:", head, rd? "read" : "writ", blk);
596 NTOHL(code);
597 if (code & 1)
598 printf(" PT error");
599 if (code & 2)
600 printf(" Phase error");
601 if (code & 4)
602 printf(" Block error");
603 if (code & 010)
604 printf(" Write error");
605 if (code & 020)
606 printf(" Length error");
607 if (code & 040)
608 printf(" CRC error");
609 if (code & ~077)
610 printf(" Unknown error %#x", code & ~077);
611 printf("\n");
612 }
613
614 int
615 mmemopen(dev_t dev, int flags, int devtype, struct lwp *l)
616 {
617 int diskunit, unit, part, labelpart;
618 struct mmem_softc *sc;
619 struct mmem_pt *pt;
620
621 diskunit = DISKUNIT(dev);
622 unit = MMEM_UNIT(diskunit);
623 part = MMEM_PART(diskunit);
624 labelpart = DISKPART(dev);
625 if ((sc = device_lookup_private(&mmem_cd, unit)) == NULL
626 || sc->sc_stat == MMEM_INIT
627 || sc->sc_stat == MMEM_INIT2
628 || part >= sc->sc_npt || (pt = &sc->sc_pt[part])->pt_flags == 0)
629 return ENXIO;
630
631 switch (devtype) {
632 case S_IFCHR:
633 pt->pt_dk.dk_copenmask |= (1 << labelpart);
634 break;
635 case S_IFBLK:
636 pt->pt_dk.dk_bopenmask |= (1 << labelpart);
637 break;
638 }
639
640 return 0;
641 }
642
643 int
644 mmemclose(dev_t dev, int flags, int devtype, struct lwp *l)
645 {
646 int diskunit, unit, part, labelpart;
647 struct mmem_softc *sc;
648 struct mmem_pt *pt;
649
650 diskunit = DISKUNIT(dev);
651 unit = MMEM_UNIT(diskunit);
652 part = MMEM_PART(diskunit);
653 sc = device_lookup_private(&mmem_cd, unit);
654 pt = &sc->sc_pt[part];
655 labelpart = DISKPART(dev);
656
657 switch (devtype) {
658 case S_IFCHR:
659 pt->pt_dk.dk_copenmask &= ~(1 << labelpart);
660 break;
661 case S_IFBLK:
662 pt->pt_dk.dk_bopenmask &= ~(1 << labelpart);
663 break;
664 }
665
666 return 0;
667 }
668
669 void
670 mmemstrategy(struct buf *bp)
671 {
672 int diskunit, unit, part, labelpart;
673 struct mmem_softc *sc;
674 struct mmem_pt *pt;
675 daddr_t off, nblk, cnt;
676
677 diskunit = DISKUNIT(bp->b_dev);
678 unit = MMEM_UNIT(diskunit);
679 part = MMEM_PART(diskunit);
680 if ((sc = device_lookup_private(&mmem_cd, unit)) == NULL
681 || sc->sc_stat == MMEM_INIT
682 || sc->sc_stat == MMEM_INIT2
683 || part >= sc->sc_npt || (pt = &sc->sc_pt[part])->pt_flags == 0)
684 goto inval;
685
686 #if 0
687 printf("%s: mmemstrategy: blkno %d, count %ld\n",
688 pt->pt_name, bp->b_blkno, bp->b_bcount);
689 #endif
690
691 if (bp->b_flags & B_READ) {
692 if (sc->sc_racc == 0)
693 goto inval; /* no read */
694 } else if (sc->sc_wacc == 0) {
695 bp->b_error = EROFS; /* no write */
696 goto done;
697 }
698
699 if (bp->b_blkno & ~(~(daddr_t)0 >> (DEV_BSHIFT + 1 /* sign bit */))
700 || (bp->b_bcount % sc->sc_bsize) != 0)
701 goto inval;
702
703 cnt = howmany(bp->b_bcount, sc->sc_bsize);
704 if (cnt == 0)
705 goto done; /* no work */
706
707 off = bp->b_blkno * DEV_BSIZE / sc->sc_bsize;
708
709 /* offset to disklabel partition */
710 labelpart = DISKPART(bp->b_dev);
711 if (labelpart == RAW_PART) {
712 nblk = pt->pt_info.maxblk - pt->pt_info.minblk + 1;
713 } else {
714 off +=
715 nblk = pt->pt_dk.dk_label->d_partitions[labelpart].p_offset;
716 nblk += pt->pt_dk.dk_label->d_partitions[labelpart].p_size;
717 }
718
719 /* deal with the EOF condition */
720 if (off + cnt > nblk) {
721 if (off >= nblk) {
722 if (off == nblk)
723 goto done;
724 goto inval;
725 }
726 cnt = nblk - off;
727 bp->b_resid = bp->b_bcount - (cnt * sc->sc_bsize);
728 }
729
730 bp->b_rawblkno = off;
731
732 /* queue this transfer */
733 bufq_put(sc->sc_q, bp);
734
735 if (sc->sc_stat == MMEM_IDLE)
736 mmemstart(sc);
737
738 return;
739
740 inval: bp->b_error = EINVAL;
741 done: bp->b_resid = bp->b_bcount;
742 biodone(bp);
743 }
744
745 /*
746 * start I/O operations
747 */
748 static void
749 mmemstart(struct mmem_softc *sc)
750 {
751 struct buf *bp;
752 struct mmem_pt *pt;
753 int s;
754
755 if ((bp = bufq_get(sc->sc_q)) == NULL) {
756 sc->sc_stat = MMEM_IDLE;
757 maple_enable_unit_ping(sc->sc_parent, sc->sc_unit,
758 MAPLE_FN_MEMCARD, 1);
759 return;
760 }
761
762 sc->sc_bp = bp;
763 sc->sc_cnt = howmany(bp->b_bcount - bp->b_resid, sc->sc_bsize);
764 KASSERT(sc->sc_cnt);
765 sc->sc_iobuf = bp->b_data;
766 sc->sc_retry = 0;
767
768 pt = &sc->sc_pt[MMEM_PART(DISKUNIT(bp->b_dev))];
769 s = splbio();
770 disk_busy(&pt->pt_dk);
771 splx(s);
772
773 /*
774 * I/O access will fail if the removal detection (by maple driver)
775 * occurs before finishing the I/O, so disable it.
776 * We are sending commands, and the removal detection is still alive.
777 */
778 maple_enable_unit_ping(sc->sc_parent, sc->sc_unit, MAPLE_FN_MEMCARD, 0);
779
780 mmemstart_bp(sc);
781 }
782
783 /*
784 * start/retry a specified I/O operation
785 */
786 static void
787 mmemstart_bp(struct mmem_softc *sc)
788 {
789 struct buf *bp;
790 int diskunit, part;
791 struct mmem_pt *pt;
792
793 bp = sc->sc_bp;
794 diskunit = DISKUNIT(bp->b_dev);
795 part = MMEM_PART(diskunit);
796 pt = &sc->sc_pt[part];
797
798 /* handle retry */
799 if (sc->sc_retry++ > MMEM_MAXRETRY) {
800 /* retry count exceeded */
801 mmemdone(sc, pt, EIO);
802 return;
803 }
804
805 /*
806 * Start the first phase (phase# = 0).
807 */
808 /* start read */
809 sc->sc_stat = (bp->b_flags & B_READ) ? MMEM_READ : MMEM_WRITE1;
810 sc->sc_reqr.func_code = htobe32(MAPLE_FUNC(MAPLE_FN_MEMCARD));
811 sc->sc_reqr.pt = part;
812 sc->sc_reqr.block = htobe16(bp->b_rawblkno);
813 sc->sc_reqr.phase = 0; /* first phase */
814 maple_command(sc->sc_parent, sc->sc_unit, MAPLE_FN_MEMCARD,
815 MAPLE_COMMAND_BREAD, sizeof sc->sc_reqr / 4, &sc->sc_reqr, 0);
816 }
817
818 static void
819 mmemstart_write2(struct mmem_softc *sc)
820 {
821 struct buf *bp;
822 int diskunit, part;
823 struct mmem_pt *pt;
824
825 bp = sc->sc_bp;
826 diskunit = DISKUNIT(bp->b_dev);
827 part = MMEM_PART(diskunit);
828 pt = &sc->sc_pt[part];
829
830 /* handle retry */
831 if (sc->sc_retry++ > MMEM_MAXRETRY - 2 /* spare for verify read */) {
832 /* retry count exceeded */
833 mmemdone(sc, pt, EIO);
834 return;
835 }
836
837 /*
838 * Start the first phase (phase# = 0).
839 */
840 /* start write */
841 sc->sc_stat = MMEM_WRITE2;
842 sc->sc_reqw.func_code = htobe32(MAPLE_FUNC(MAPLE_FN_MEMCARD));
843 sc->sc_reqw.pt = part;
844 sc->sc_reqw.block = htobe16(bp->b_rawblkno);
845 sc->sc_reqw.phase = 0; /* first phase */
846 memcpy(sc->sc_reqw.data, sc->sc_iobuf /* + sc->sc_waccsz * phase */,
847 sc->sc_waccsz);
848 maple_command(sc->sc_parent, sc->sc_unit, MAPLE_FN_MEMCARD,
849 MAPLE_COMMAND_BWRITE, MMEM_SIZE_REQW(sc) / 4, &sc->sc_reqw,
850 MAPLE_FLAG_CMD_PERIODIC_TIMING);
851 }
852
853 static void
854 mmemdone(struct mmem_softc *sc, struct mmem_pt *pt, int err)
855 {
856 struct buf *bp = sc->sc_bp;
857 int s;
858 int bcnt;
859
860 KASSERT(bp);
861
862 if (err) {
863 bcnt = (char *)sc->sc_iobuf - (char *)bp->b_data;
864 bp->b_resid = bp->b_bcount - bcnt;
865
866 /* raise error if no block is read */
867 if (bcnt == 0) {
868 bp->b_error = err;
869 }
870 goto term_xfer;
871 }
872
873 sc->sc_iobuf += sc->sc_bsize;
874 if (--sc->sc_cnt == 0) {
875 term_xfer:
876 /* terminate current transfer */
877 sc->sc_bp = NULL;
878 s = splbio();
879 disk_unbusy(&pt->pt_dk,
880 (char *)sc->sc_iobuf - (char *)bp->b_data,
881 sc->sc_stat == MMEM_READ);
882 biodone(bp);
883 splx(s);
884
885 /* go next transfer */
886 mmemstart(sc);
887 } else {
888 /* go next block */
889 bp->b_rawblkno++;
890 sc->sc_retry = 0;
891 mmemstart_bp(sc);
892 }
893 }
894
895 int
896 mmemread(dev_t dev, struct uio *uio, int flags)
897 {
898
899 return physio(mmemstrategy, NULL, dev, B_READ, minphys, uio);
900 }
901
902 int
903 mmemwrite(dev_t dev, struct uio *uio, int flags)
904 {
905
906 return physio(mmemstrategy, NULL, dev, B_WRITE, minphys, uio);
907 }
908
909 int
910 mmemioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
911 {
912 int diskunit, unit, part;
913 struct mmem_softc *sc;
914 struct mmem_pt *pt;
915
916 diskunit = DISKUNIT(dev);
917 unit = MMEM_UNIT(diskunit);
918 part = MMEM_PART(diskunit);
919 sc = device_lookup_private(&mmem_cd, unit);
920 pt = &sc->sc_pt[part];
921
922 switch (cmd) {
923 case DIOCGDINFO:
924 *(struct disklabel *)data = *pt->pt_dk.dk_label; /* XXX */
925 break;
926
927 default:
928 /* generic maple ioctl */
929 return maple_unit_ioctl(sc->sc_parent, sc->sc_unit, cmd, data,
930 flag, l);
931 }
932
933 return 0;
934 }
NetBSD on the FriendlyARM MINI2440