Annotation of sys/dev/sdmmc/sdmmc_scsi.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: sdmmc_scsi.c,v 1.7 2006/11/28 23:59:45 dlg Exp $ */
2:
3: /*
4: * Copyright (c) 2006 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: /* A SCSI adapter emulation to access SD/MMC memory cards */
20:
21: #include <sys/param.h>
22: #include <sys/buf.h>
23: #include <sys/kernel.h>
24: #include <sys/malloc.h>
25: #include <sys/proc.h>
26: #include <sys/systm.h>
27:
28: #include <scsi/scsi_all.h>
29: #include <scsi/scsi_disk.h>
30: #include <scsi/scsiconf.h>
31:
32: #include <dev/sdmmc/sdmmc_scsi.h>
33: #include <dev/sdmmc/sdmmcvar.h>
34:
35: #define SDMMC_SCSIID_HOST 0x00
36: #define SDMMC_SCSIID_MAX 0x0f
37:
38: #define SDMMC_SCSI_MAXCMDS 8
39:
40: struct sdmmc_scsi_target {
41: struct sdmmc_function *card;
42: };
43:
44: struct sdmmc_ccb {
45: struct sdmmc_scsi_softc *ccb_scbus;
46: struct scsi_xfer *ccb_xs;
47: int ccb_flags;
48: #define SDMMC_CCB_F_ERR 0x0001
49: void (*ccb_done)(struct sdmmc_ccb *);
50: u_int32_t ccb_blockno;
51: u_int32_t ccb_blockcnt;
52: volatile enum {
53: SDMMC_CCB_FREE,
54: SDMMC_CCB_READY,
55: SDMMC_CCB_QUEUED
56: } ccb_state;
57: struct sdmmc_command ccb_cmd;
58: struct sdmmc_task ccb_task;
59: TAILQ_ENTRY(sdmmc_ccb) ccb_link;
60: };
61:
62: TAILQ_HEAD(sdmmc_ccb_list, sdmmc_ccb);
63:
64: struct sdmmc_scsi_softc {
65: struct scsi_adapter sc_adapter;
66: struct scsi_link sc_link;
67: struct device *sc_child;
68: struct sdmmc_scsi_target *sc_tgt;
69: int sc_ntargets;
70: struct sdmmc_ccb *sc_ccbs; /* allocated ccbs */
71: struct sdmmc_ccb_list sc_ccb_freeq; /* free ccbs */
72: struct sdmmc_ccb_list sc_ccb_runq; /* queued ccbs */
73: };
74:
75: int sdmmc_alloc_ccbs(struct sdmmc_scsi_softc *, int);
76: void sdmmc_free_ccbs(struct sdmmc_scsi_softc *);
77: struct sdmmc_ccb *sdmmc_get_ccb(struct sdmmc_scsi_softc *, int);
78: void sdmmc_put_ccb(struct sdmmc_ccb *);
79:
80: int sdmmc_scsi_cmd(struct scsi_xfer *);
81: int sdmmc_start_xs(struct sdmmc_softc *, struct sdmmc_ccb *);
82: void sdmmc_complete_xs(void *);
83: void sdmmc_done_xs(struct sdmmc_ccb *);
84: void sdmmc_stimeout(void *);
85: void sdmmc_scsi_minphys(struct buf *);
86:
87: #define DEVNAME(sc) SDMMCDEVNAME(sc)
88:
89: #ifdef SDMMC_DEBUG
90: #define DPRINTF(s) printf s
91: #else
92: #define DPRINTF(s) /**/
93: #endif
94:
95: void
96: sdmmc_scsi_attach(struct sdmmc_softc *sc)
97: {
98: struct scsibus_attach_args saa;
99: struct sdmmc_scsi_softc *scbus;
100: struct sdmmc_function *sf;
101:
102: MALLOC(scbus, struct sdmmc_scsi_softc *,
103: sizeof *scbus, M_DEVBUF, M_WAITOK);
104: bzero(scbus, sizeof *scbus);
105:
106: MALLOC(scbus->sc_tgt, struct sdmmc_scsi_target *,
107: sizeof(*scbus->sc_tgt) * (SDMMC_SCSIID_MAX+1),
108: M_DEVBUF, M_WAITOK);
109: bzero(scbus->sc_tgt, sizeof(*scbus->sc_tgt) * (SDMMC_SCSIID_MAX+1));
110:
111: /*
112: * Each card that sent us a CID in the identification stage
113: * gets a SCSI ID > 0, whether it is a memory card or not.
114: */
115: scbus->sc_ntargets = 1;
116: SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
117: if (scbus->sc_ntargets >= SDMMC_SCSIID_MAX+1)
118: break;
119: scbus->sc_tgt[scbus->sc_ntargets].card = sf;
120: scbus->sc_ntargets++;
121: }
122:
123: /* Preallocate some CCBs and initialize the CCB lists. */
124: if (sdmmc_alloc_ccbs(scbus, SDMMC_SCSI_MAXCMDS) != 0) {
125: printf("%s: can't allocate ccbs\n", sc->sc_dev.dv_xname);
126: goto free_sctgt;
127: }
128:
129: sc->sc_scsibus = scbus;
130:
131: scbus->sc_adapter.scsi_cmd = sdmmc_scsi_cmd;
132: scbus->sc_adapter.scsi_minphys = sdmmc_scsi_minphys;
133:
134: scbus->sc_link.adapter_target = SDMMC_SCSIID_HOST;
135: scbus->sc_link.adapter_buswidth = scbus->sc_ntargets;
136: scbus->sc_link.adapter_softc = sc;
137: scbus->sc_link.luns = 1;
138: scbus->sc_link.openings = 1;
139: scbus->sc_link.adapter = &scbus->sc_adapter;
140:
141: bzero(&saa, sizeof(saa));
142: saa.saa_sc_link = &scbus->sc_link;
143:
144: scbus->sc_child = config_found(&sc->sc_dev, &saa, scsiprint);
145: if (scbus->sc_child == NULL) {
146: printf("%s: can't attach scsibus\n", sc->sc_dev.dv_xname);
147: goto free_ccbs;
148: }
149: return;
150:
151: free_ccbs:
152: sc->sc_scsibus = NULL;
153: sdmmc_free_ccbs(scbus);
154: free_sctgt:
155: free(scbus->sc_tgt, M_DEVBUF);
156: free(scbus, M_DEVBUF);
157: }
158:
159: void
160: sdmmc_scsi_detach(struct sdmmc_softc *sc)
161: {
162: struct sdmmc_scsi_softc *scbus;
163: struct sdmmc_ccb *ccb;
164: int s;
165:
166: scbus = sc->sc_scsibus;
167: if (scbus == NULL)
168: return;
169:
170: /* Complete all open scsi xfers. */
171: s = splbio();
172: for (ccb = TAILQ_FIRST(&scbus->sc_ccb_runq); ccb != NULL;
173: ccb = TAILQ_FIRST(&scbus->sc_ccb_runq))
174: sdmmc_stimeout(ccb);
175: splx(s);
176:
177: if (scbus->sc_child != NULL)
178: config_detach(scbus->sc_child, DETACH_FORCE);
179:
180: if (scbus->sc_tgt != NULL)
181: FREE(scbus->sc_tgt, M_DEVBUF);
182:
183: sdmmc_free_ccbs(scbus);
184: FREE(scbus, M_DEVBUF);
185: sc->sc_scsibus = NULL;
186: }
187:
188: /*
189: * CCB management
190: */
191:
192: int
193: sdmmc_alloc_ccbs(struct sdmmc_scsi_softc *scbus, int nccbs)
194: {
195: struct sdmmc_ccb *ccb;
196: int i;
197:
198: scbus->sc_ccbs = malloc(sizeof(struct sdmmc_ccb) * nccbs,
199: M_DEVBUF, M_NOWAIT);
200: if (scbus->sc_ccbs == NULL)
201: return 1;
202:
203: TAILQ_INIT(&scbus->sc_ccb_freeq);
204: TAILQ_INIT(&scbus->sc_ccb_runq);
205:
206: for (i = 0; i < nccbs; i++) {
207: ccb = &scbus->sc_ccbs[i];
208: ccb->ccb_scbus = scbus;
209: ccb->ccb_state = SDMMC_CCB_FREE;
210: ccb->ccb_flags = 0;
211: ccb->ccb_xs = NULL;
212: ccb->ccb_done = NULL;
213:
214: TAILQ_INSERT_TAIL(&scbus->sc_ccb_freeq, ccb, ccb_link);
215: }
216: return 0;
217: }
218:
219: void
220: sdmmc_free_ccbs(struct sdmmc_scsi_softc *scbus)
221: {
222: if (scbus->sc_ccbs != NULL) {
223: free(scbus->sc_ccbs, M_DEVBUF);
224: scbus->sc_ccbs = NULL;
225: }
226: }
227:
228: struct sdmmc_ccb *
229: sdmmc_get_ccb(struct sdmmc_scsi_softc *scbus, int flags)
230: {
231: struct sdmmc_ccb *ccb;
232: int s;
233:
234: s = splbio();
235: while ((ccb = TAILQ_FIRST(&scbus->sc_ccb_freeq)) == NULL &&
236: !ISSET(flags, SCSI_NOSLEEP))
237: tsleep(&scbus->sc_ccb_freeq, PRIBIO, "getccb", 0);
238: if (ccb != NULL) {
239: TAILQ_REMOVE(&scbus->sc_ccb_freeq, ccb, ccb_link);
240: ccb->ccb_state = SDMMC_CCB_READY;
241: }
242: splx(s);
243: return ccb;
244: }
245:
246: void
247: sdmmc_put_ccb(struct sdmmc_ccb *ccb)
248: {
249: struct sdmmc_scsi_softc *scbus = ccb->ccb_scbus;
250: int s;
251:
252: s = splbio();
253: if (ccb->ccb_state == SDMMC_CCB_QUEUED)
254: TAILQ_REMOVE(&scbus->sc_ccb_runq, ccb, ccb_link);
255: ccb->ccb_state = SDMMC_CCB_FREE;
256: ccb->ccb_flags = 0;
257: ccb->ccb_xs = NULL;
258: ccb->ccb_done = NULL;
259: TAILQ_INSERT_TAIL(&scbus->sc_ccb_freeq, ccb, ccb_link);
260: if (TAILQ_NEXT(ccb, ccb_link) == NULL)
261: wakeup(&scbus->sc_ccb_freeq);
262: splx(s);
263: }
264:
265: /*
266: * SCSI command emulation
267: */
268:
269: /* XXX move to some sort of "scsi emulation layer". */
270: static void
271: sdmmc_scsi_decode_rw(struct scsi_xfer *xs, u_int32_t *blocknop,
272: u_int32_t *blockcntp)
273: {
274: struct scsi_rw *rw;
275: struct scsi_rw_big *rwb;
276:
277: if (xs->cmdlen == 6) {
278: rw = (struct scsi_rw *)xs->cmd;
279: *blocknop = _3btol(rw->addr) & (SRW_TOPADDR << 16 | 0xffff);
280: *blockcntp = rw->length ? rw->length : 0x100;
281: } else {
282: rwb = (struct scsi_rw_big *)xs->cmd;
283: *blocknop = _4btol(rwb->addr);
284: *blockcntp = _2btol(rwb->length);
285: }
286: }
287:
288: int
289: sdmmc_scsi_cmd(struct scsi_xfer *xs)
290: {
291: struct scsi_link *link = xs->sc_link;
292: struct sdmmc_softc *sc = link->adapter_softc;
293: struct sdmmc_scsi_softc *scbus = sc->sc_scsibus;
294: struct sdmmc_scsi_target *tgt = &scbus->sc_tgt[link->target];
295: struct scsi_inquiry_data inq;
296: struct scsi_read_cap_data rcd;
297: u_int32_t blockno;
298: u_int32_t blockcnt;
299: struct sdmmc_ccb *ccb;
300: int s;
301:
302: if (link->target >= scbus->sc_ntargets || tgt->card == NULL ||
303: link->lun != 0) {
304: DPRINTF(("%s: sdmmc_scsi_cmd: no target %d\n",
305: DEVNAME(sc), link->target));
306: /* XXX should be XS_SENSE and sense filled out */
307: xs->error = XS_DRIVER_STUFFUP;
308: xs->flags |= ITSDONE;
309: s = splbio();
310: scsi_done(xs);
311: splx(s);
312: return COMPLETE;
313: }
314:
315: DPRINTF(("%s: scsi cmd target=%d opcode=%#x proc=\"%s\" (poll=%#x)\n",
316: DEVNAME(sc), link->target, xs->cmd->opcode, curproc ?
317: curproc->p_comm : "", xs->flags & SCSI_POLL));
318:
319: xs->error = XS_NOERROR;
320:
321: switch (xs->cmd->opcode) {
322: case READ_COMMAND:
323: case READ_BIG:
324: case WRITE_COMMAND:
325: case WRITE_BIG:
326: /* Deal with I/O outside the switch. */
327: break;
328:
329: case INQUIRY:
330: bzero(&inq, sizeof inq);
331: inq.device = T_DIRECT;
332: inq.version = 2;
333: inq.response_format = 2;
334: inq.additional_length = 32;
335: strlcpy(inq.vendor, "SD/MMC ", sizeof(inq.vendor));
336: snprintf(inq.product, sizeof(inq.product),
337: "Drive #%02d", link->target);
338: strlcpy(inq.revision, " ", sizeof(inq.revision));
339: bcopy(&inq, xs->data, MIN(xs->datalen, sizeof inq));
340: s = splbio();
341: scsi_done(xs);
342: splx(s);
343: return COMPLETE;
344:
345: case TEST_UNIT_READY:
346: case START_STOP:
347: case SYNCHRONIZE_CACHE:
348: return COMPLETE;
349:
350: case READ_CAPACITY:
351: bzero(&rcd, sizeof rcd);
352: _lto4b(tgt->card->csd.capacity - 1, rcd.addr);
353: _lto4b(tgt->card->csd.sector_size, rcd.length);
354: bcopy(&rcd, xs->data, MIN(xs->datalen, sizeof rcd));
355: s = splbio();
356: scsi_done(xs);
357: splx(s);
358: return COMPLETE;
359:
360: default:
361: DPRINTF(("%s: unsupported scsi command %#x\n",
362: DEVNAME(sc), xs->cmd->opcode));
363: xs->error = XS_DRIVER_STUFFUP;
364: s = splbio();
365: scsi_done(xs);
366: splx(s);
367: return COMPLETE;
368: }
369:
370: /* A read or write operation. */
371: sdmmc_scsi_decode_rw(xs, &blockno, &blockcnt);
372:
373: if (blockno >= tgt->card->csd.capacity ||
374: blockno + blockcnt > tgt->card->csd.capacity) {
375: DPRINTF(("%s: out of bounds %u-%u >= %u\n", DEVNAME(sc),
376: blockno, blockcnt, tgt->card->csd.capacity));
377: xs->error = XS_DRIVER_STUFFUP;
378: s = splbio();
379: scsi_done(xs);
380: splx(s);
381: return COMPLETE;
382: }
383:
384: ccb = sdmmc_get_ccb(sc->sc_scsibus, xs->flags);
385: if (ccb == NULL) {
386: printf("%s: out of ccbs\n", DEVNAME(sc));
387: xs->error = XS_DRIVER_STUFFUP;
388: s = splbio();
389: scsi_done(xs);
390: splx(s);
391: return COMPLETE;
392: }
393:
394: ccb->ccb_xs = xs;
395: ccb->ccb_done = sdmmc_done_xs;
396:
397: ccb->ccb_blockcnt = blockcnt;
398: ccb->ccb_blockno = blockno;
399:
400: return sdmmc_start_xs(sc, ccb);
401: }
402:
403: int
404: sdmmc_start_xs(struct sdmmc_softc *sc, struct sdmmc_ccb *ccb)
405: {
406: struct sdmmc_scsi_softc *scbus = sc->sc_scsibus;
407: struct scsi_xfer *xs = ccb->ccb_xs;
408: int s;
409:
410: timeout_set(&xs->stimeout, sdmmc_stimeout, ccb);
411: sdmmc_init_task(&ccb->ccb_task, sdmmc_complete_xs, ccb);
412:
413: s = splbio();
414: TAILQ_INSERT_TAIL(&scbus->sc_ccb_runq, ccb, ccb_link);
415: ccb->ccb_state = SDMMC_CCB_QUEUED;
416: splx(s);
417:
418: if (ISSET(xs->flags, SCSI_POLL)) {
419: sdmmc_complete_xs(ccb);
420: return COMPLETE;
421: }
422:
423: timeout_add(&xs->stimeout, (xs->timeout * hz) / 1000);
424: sdmmc_add_task(sc, &ccb->ccb_task);
425: return SUCCESSFULLY_QUEUED;
426: }
427:
428: void
429: sdmmc_complete_xs(void *arg)
430: {
431: struct sdmmc_ccb *ccb = arg;
432: struct scsi_xfer *xs = ccb->ccb_xs;
433: struct scsi_link *link = xs->sc_link;
434: struct sdmmc_softc *sc = link->adapter_softc;
435: struct sdmmc_scsi_softc *scbus = sc->sc_scsibus;
436: struct sdmmc_scsi_target *tgt = &scbus->sc_tgt[link->target];
437: int error;
438: int s;
439:
440: DPRINTF(("%s: scsi cmd target=%d opcode=%#x proc=\"%s\" (poll=%#x)"
441: " complete\n", DEVNAME(sc), link->target, xs->cmd->opcode,
442: curproc ? curproc->p_comm : "", xs->flags & SCSI_POLL));
443:
444: s = splbio();
445:
446: if (ISSET(xs->flags, SCSI_DATA_IN))
447: error = sdmmc_mem_read_block(tgt->card, ccb->ccb_blockno,
448: xs->data, ccb->ccb_blockcnt * DEV_BSIZE);
449: else
450: error = sdmmc_mem_write_block(tgt->card, ccb->ccb_blockno,
451: xs->data, ccb->ccb_blockcnt * DEV_BSIZE);
452:
453: if (error != 0)
454: xs->error = XS_DRIVER_STUFFUP;
455:
456: ccb->ccb_done(ccb);
457: splx(s);
458: }
459:
460: void
461: sdmmc_done_xs(struct sdmmc_ccb *ccb)
462: {
463: struct scsi_xfer *xs = ccb->ccb_xs;
464: #ifdef SDMMC_DEBUG
465: struct scsi_link *link = xs->sc_link;
466: struct sdmmc_softc *sc = link->adapter_softc;
467: #endif
468:
469: timeout_del(&xs->stimeout);
470:
471: DPRINTF(("%s: scsi cmd target=%d opcode=%#x proc=\"%s\" (error=%#x)"
472: " done\n", DEVNAME(sc), link->target, xs->cmd->opcode,
473: curproc ? curproc->p_comm : "", xs->error));
474:
475: xs->resid = 0;
476: xs->flags |= ITSDONE;
477:
478: if (ISSET(ccb->ccb_flags, SDMMC_CCB_F_ERR))
479: xs->error = XS_DRIVER_STUFFUP;
480:
481: sdmmc_put_ccb(ccb);
482: scsi_done(xs);
483: }
484:
485: void
486: sdmmc_stimeout(void *arg)
487: {
488: struct sdmmc_ccb *ccb = arg;
489: int s;
490:
491: s = splbio();
492: ccb->ccb_flags |= SDMMC_CCB_F_ERR;
493: if (sdmmc_task_pending(&ccb->ccb_task)) {
494: sdmmc_del_task(&ccb->ccb_task);
495: ccb->ccb_done(ccb);
496: }
497: splx(s);
498: }
499:
500: void
501: sdmmc_scsi_minphys(struct buf *bp)
502: {
503: /* XXX limit to max. transfer size supported by card/host? */
504: if (bp->b_bcount > DEV_BSIZE)
505: bp->b_bcount = DEV_BSIZE;
506: minphys(bp);
507: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to sdmmc_scsi.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / sdmmc