39 #include <sys/sunddi.h>
40
41 #include <sys/1394/targets/scsa1394/impl.h>
42 #include <sys/1394/targets/scsa1394/cmd.h>
43
44 /* DDI/DKI entry points */
45 static int scsa1394_attach(dev_info_t *, ddi_attach_cmd_t);
46 static int scsa1394_detach(dev_info_t *, ddi_detach_cmd_t);
47 static int scsa1394_power(dev_info_t *, int, int);
48 static int scsa1394_cpr_suspend(dev_info_t *);
49 static void scsa1394_cpr_resume(dev_info_t *);
50
51 /* configuration routines */
52 static void scsa1394_cleanup(scsa1394_state_t *, int);
53 static int scsa1394_attach_1394(scsa1394_state_t *);
54 static void scsa1394_detach_1394(scsa1394_state_t *);
55 static int scsa1394_attach_threads(scsa1394_state_t *);
56 static void scsa1394_detach_threads(scsa1394_state_t *);
57 static int scsa1394_attach_scsa(scsa1394_state_t *);
58 static void scsa1394_detach_scsa(scsa1394_state_t *);
59 static int scsa1394_create_cmd_cache(scsa1394_state_t *);
60 static void scsa1394_destroy_cmd_cache(scsa1394_state_t *);
61 static int scsa1394_add_events(scsa1394_state_t *);
62 static void scsa1394_remove_events(scsa1394_state_t *);
63
64 /* device configuration */
65 static int scsa1394_scsi_bus_config(dev_info_t *, uint_t,
66 ddi_bus_config_op_t, void *, dev_info_t **);
67 static int scsa1394_scsi_bus_unconfig(dev_info_t *, uint_t,
68 ddi_bus_config_op_t, void *);
69 static void scsa1394_create_children(scsa1394_state_t *);
70 static void scsa1394_bus_reset(dev_info_t *, ddi_eventcookie_t, void *,
71 void *);
72 static void scsa1394_disconnect(dev_info_t *, ddi_eventcookie_t, void *,
73 void *);
74 static void scsa1394_reconnect(dev_info_t *, ddi_eventcookie_t, void *,
75 void *);
76
77 /* SCSA HBA entry points */
78 static int scsa1394_scsi_tgt_init(dev_info_t *, dev_info_t *,
79 scsi_hba_tran_t *, struct scsi_device *);
80 static void scsa1394_scsi_tgt_free(dev_info_t *, dev_info_t *,
81 scsi_hba_tran_t *, struct scsi_device *);
82 static int scsa1394_scsi_tgt_probe(struct scsi_device *, int (*)());
83 static int scsa1394_probe_g0_nodata(struct scsi_device *, int (*)(),
84 uchar_t, uint_t, uint_t);
85 static int scsa1394_probe_tran(struct scsi_pkt *);
86 static struct scsi_pkt *scsa1394_scsi_init_pkt(struct scsi_address *,
87 struct scsi_pkt *, struct buf *, int, int, int, int,
88 int (*)(), caddr_t arg);
89 static void scsa1394_scsi_destroy_pkt(struct scsi_address *,
90 struct scsi_pkt *);
91 static int scsa1394_scsi_start(struct scsi_address *, struct scsi_pkt *);
92 static int scsa1394_scsi_abort(struct scsi_address *, struct scsi_pkt *);
93 static int scsa1394_scsi_reset(struct scsi_address *, int);
94 static int scsa1394_scsi_getcap(struct scsi_address *, char *, int);
95 static int scsa1394_scsi_setcap(struct scsi_address *, char *, int, int);
96 static void scsa1394_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
97 static void scsa1394_scsi_sync_pkt(struct scsi_address *,
98 struct scsi_pkt *);
99
100 /* pkt resource allocation routines */
101 static int scsa1394_cmd_cache_constructor(void *, void *, int);
102 static void scsa1394_cmd_cache_destructor(void *, void *);
103 static int scsa1394_cmd_ext_alloc(scsa1394_state_t *, scsa1394_cmd_t *,
104 int);
105 static void scsa1394_cmd_ext_free(scsa1394_state_t *, scsa1394_cmd_t *);
106 static int scsa1394_cmd_cdb_dma_alloc(scsa1394_state_t *, scsa1394_cmd_t *,
107 int, int (*)(), caddr_t);
108 static void scsa1394_cmd_cdb_dma_free(scsa1394_state_t *, scsa1394_cmd_t *);
109 static int scsa1394_cmd_buf_dma_alloc(scsa1394_state_t *, scsa1394_cmd_t *,
110 int, int (*)(), caddr_t, struct buf *);
111 static void scsa1394_cmd_buf_dma_free(scsa1394_state_t *, scsa1394_cmd_t *);
112 static int scsa1394_cmd_dmac2seg(scsa1394_state_t *, scsa1394_cmd_t *,
113 ddi_dma_cookie_t *, uint_t, int);
114 static void scsa1394_cmd_seg_free(scsa1394_state_t *, scsa1394_cmd_t *);
115 static int scsa1394_cmd_pt_dma_alloc(scsa1394_state_t *, scsa1394_cmd_t *,
116 int (*)(), caddr_t, int);
117 static void scsa1394_cmd_pt_dma_free(scsa1394_state_t *, scsa1394_cmd_t *);
118 static int scsa1394_cmd_buf_addr_alloc(scsa1394_state_t *,
119 scsa1394_cmd_t *);
120 static void scsa1394_cmd_buf_addr_free(scsa1394_state_t *,
121 scsa1394_cmd_t *);
122 static int scsa1394_cmd_buf_dma_move(scsa1394_state_t *, scsa1394_cmd_t *);
123
124
125 /* pkt and data transfer routines */
289 if (scsa1394_attach_1394(sp) != DDI_SUCCESS) {
290 scsa1394_cleanup(sp, 1);
291 return (DDI_FAILURE);
292 }
293
294 if (scsa1394_sbp2_attach(sp) != DDI_SUCCESS) {
295 scsa1394_cleanup(sp, 2);
296 return (DDI_FAILURE);
297 }
298
299 if (scsa1394_attach_threads(sp) != DDI_SUCCESS) {
300 scsa1394_cleanup(sp, 3);
301 return (DDI_FAILURE);
302 }
303
304 if (scsa1394_attach_scsa(sp) != DDI_SUCCESS) {
305 scsa1394_cleanup(sp, 4);
306 return (DDI_FAILURE);
307 }
308
309 if (scsa1394_create_cmd_cache(sp) != DDI_SUCCESS) {
310 scsa1394_cleanup(sp, 5);
311 return (DDI_FAILURE);
312 }
313
314 if (scsa1394_add_events(sp) != DDI_SUCCESS) {
315 scsa1394_cleanup(sp, 6);
316 return (DDI_FAILURE);
317 }
318
319 /* prevent async PM changes until we are done */
320 (void) pm_busy_component(dip, 0);
321
322 /* Set power to full on */
323 (void) pm_raise_power(dip, 0, PM_LEVEL_D0);
324
325 /* we are done */
326 (void) pm_idle_component(dip, 0);
327
328 #ifndef __lock_lint
329 sp->s_dev_state = SCSA1394_DEV_ONLINE;
330 #endif
331
332 ddi_report_dev(dip);
333
334 return (DDI_SUCCESS);
335 }
442 /* we are down so let the power get managed */
443 (void) pm_idle_component(dip, 0);
444 }
445
446
447
448 /*
449 *
450 * --- configuration routines
451 *
452 */
453 static void
454 scsa1394_cleanup(scsa1394_state_t *sp, int level)
455 {
456 ASSERT((level > 0) && (level <= SCSA1394_CLEANUP_LEVEL_MAX));
457
458 switch (level) {
459 default:
460 scsa1394_remove_events(sp);
461 /* FALLTHRU */
462 case 6:
463 scsa1394_detach_scsa(sp);
464 /* FALLTHRU */
465 case 5:
466 scsa1394_destroy_cmd_cache(sp);
467 /* FALLTHRU */
468 case 4:
469 scsa1394_detach_threads(sp);
470 /* FALLTHRU */
471 case 3:
472 scsa1394_sbp2_detach(sp);
473 /* FALLTHRU */
474 case 2:
475 scsa1394_detach_1394(sp);
476 /* FALLTHRU */
477 case 1:
478 cv_destroy(&sp->s_event_cv);
479 mutex_destroy(&sp->s_mutex);
480 ddi_soft_state_free(scsa1394_statep, sp->s_instance);
481 }
482 }
483
484 static int
485 scsa1394_attach_1394(scsa1394_state_t *sp)
486 {
580 tran, 0)) != DDI_SUCCESS) {
581 scsi_hba_tran_free(tran);
582 return (ret);
583 }
584
585 return (DDI_SUCCESS);
586 }
587
588 static void
589 scsa1394_detach_scsa(scsa1394_state_t *sp)
590 {
591 int ret;
592
593 ret = scsi_hba_detach(sp->s_dip);
594 ASSERT(ret == DDI_SUCCESS);
595
596 scsi_hba_tran_free(sp->s_tran);
597 }
598
599 static int
600 scsa1394_create_cmd_cache(scsa1394_state_t *sp)
601 {
602 char name[64];
603
604 (void) sprintf(name, "scsa1394%d_cache", sp->s_instance);
605 sp->s_cmd_cache = kmem_cache_create(name,
606 SCSA1394_CMD_SIZE, sizeof (void *),
607 scsa1394_cmd_cache_constructor, scsa1394_cmd_cache_destructor,
608 NULL, (void *)sp, NULL, 0);
609
610 return ((sp->s_cmd_cache == NULL) ? DDI_FAILURE : DDI_SUCCESS);
611 }
612
613 static void
614 scsa1394_destroy_cmd_cache(scsa1394_state_t *sp)
615 {
616 kmem_cache_destroy(sp->s_cmd_cache);
617 }
618
619 static int
620 scsa1394_add_events(scsa1394_state_t *sp)
621 {
622 ddi_eventcookie_t br_evc, rem_evc, ins_evc;
623
624 if (ddi_get_eventcookie(sp->s_dip, DDI_DEVI_BUS_RESET_EVENT,
625 &br_evc) != DDI_SUCCESS) {
626 return (DDI_FAILURE);
627 }
628 if (ddi_add_event_handler(sp->s_dip, br_evc, scsa1394_bus_reset,
629 sp, &sp->s_reset_cb_id) != DDI_SUCCESS) {
630 return (DDI_FAILURE);
631 }
632
633 if (ddi_get_eventcookie(sp->s_dip, DDI_DEVI_REMOVE_EVENT,
634 &rem_evc) != DDI_SUCCESS) {
635 (void) ddi_remove_event_handler(sp->s_reset_cb_id);
636 return (DDI_FAILURE);
637 }
638 if (ddi_add_event_handler(sp->s_dip, rem_evc, scsa1394_disconnect,
639 sp, &sp->s_remove_cb_id) != DDI_SUCCESS) {
1278 scsa1394_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
1279 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
1280 int (*callback)(), caddr_t arg)
1281 {
1282 scsa1394_state_t *sp = ADDR2STATE(ap);
1283 scsa1394_lun_t *lp;
1284 scsa1394_cmd_t *cmd;
1285 boolean_t is_new; /* new cmd is being allocated */
1286 int kf = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
1287
1288 if (ap->a_lun >= sp->s_nluns) {
1289 return (NULL);
1290 }
1291 lp = &sp->s_lun[ap->a_lun];
1292
1293 /*
1294 * allocate cmd space
1295 */
1296 if (pkt == NULL) {
1297 is_new = B_TRUE;
1298 if ((cmd = kmem_cache_alloc(sp->s_cmd_cache, kf)) == NULL) {
1299 return (NULL);
1300 }
1301
1302 /* initialize cmd */
1303 pkt = &cmd->sc_scsi_pkt;
1304 pkt->pkt_ha_private = cmd;
1305 pkt->pkt_address = *ap;
1306 pkt->pkt_private = cmd->sc_priv;
1307 pkt->pkt_scbp = (uchar_t *)&cmd->sc_scb;
1308 pkt->pkt_cdbp = (uchar_t *)&cmd->sc_pkt_cdb;
1309 pkt->pkt_resid = 0;
1310
1311 cmd->sc_lun = lp;
1312 cmd->sc_pkt = pkt;
1313 cmd->sc_cdb_len = cmdlen;
1314 cmd->sc_scb_len = statuslen;
1315 cmd->sc_priv_len = tgtlen;
1316
1317 /* need external space? */
1318 if ((cmdlen > sizeof (cmd->sc_pkt_cdb)) ||
1319 (statuslen > sizeof (cmd->sc_scb)) ||
1320 (tgtlen > sizeof (cmd->sc_priv))) {
1321 if (scsa1394_cmd_ext_alloc(sp, cmd, kf) !=
1322 DDI_SUCCESS) {
1323 kmem_cache_free(sp->s_cmd_cache, cmd);
1324 lp->l_stat.stat_err_pkt_kmem_alloc++;
1325 return (NULL);
1326 }
1327 }
1328
1329 /* allocate DMA resources for CDB */
1330 if (scsa1394_cmd_cdb_dma_alloc(sp, cmd, flags, callback, arg) !=
1331 DDI_SUCCESS) {
1332 scsa1394_scsi_destroy_pkt(ap, pkt);
1333 return (NULL);
1334 }
1335 } else {
1336 is_new = B_FALSE;
1337 cmd = PKT2CMD(pkt);
1338 }
1339
1340 cmd->sc_flags &= ~SCSA1394_CMD_RDWR;
1341
1342 /* allocate/move DMA resources for data buffer */
1343 if ((bp != NULL) && (bp->b_bcount > 0)) {
1344 if ((cmd->sc_flags & SCSA1394_CMD_DMA_BUF_VALID) == 0) {
1345 if (scsa1394_cmd_buf_dma_alloc(sp, cmd, flags, callback,
1346 arg, bp) != DDI_SUCCESS) {
1347 if (is_new) {
1372
1373 return (pkt);
1374 }
1375
1376 static void
1377 scsa1394_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
1378 {
1379 scsa1394_state_t *sp = ADDR2STATE(ap);
1380 scsa1394_cmd_t *cmd = PKT2CMD(pkt);
1381
1382 if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_VALID) {
1383 scsa1394_cmd_buf_dma_free(sp, cmd);
1384 }
1385 if (cmd->sc_flags & SCSA1394_CMD_DMA_CDB_VALID) {
1386 scsa1394_cmd_cdb_dma_free(sp, cmd);
1387 }
1388 if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_MAPIN) {
1389 bp_mapout(cmd->sc_bp);
1390 cmd->sc_flags &= ~SCSA1394_CMD_DMA_BUF_MAPIN;
1391 }
1392 if (cmd->sc_flags & SCSA1394_CMD_EXT) {
1393 scsa1394_cmd_ext_free(sp, cmd);
1394 }
1395
1396 kmem_cache_free(sp->s_cmd_cache, cmd);
1397 }
1398
1399 static void
1400 scsa1394_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
1401 {
1402 scsa1394_state_t *sp = ADDR2STATE(ap);
1403 scsa1394_cmd_t *cmd = PKT2CMD(pkt);
1404
1405 if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_VALID) {
1406 scsa1394_cmd_buf_dma_free(sp, cmd);
1407 }
1408 if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_MAPIN) {
1409 bp_mapout(cmd->sc_bp);
1410 cmd->sc_flags &= ~SCSA1394_CMD_DMA_BUF_MAPIN;
1411 }
1412 }
1413
1414 /*ARGSUSED*/
1415 static int
1416 scsa1394_cmd_cache_constructor(void *buf, void *cdrarg, int kf)
1417 {
1418 scsa1394_cmd_t *cmd = buf;
1419
1420 bzero(buf, SCSA1394_CMD_SIZE);
1421 cmd->sc_task.ts_drv_priv = cmd;
1422
1423 return (0);
1424 }
1425
1426 /*ARGSUSED*/
1427 static void
1428 scsa1394_cmd_cache_destructor(void *buf, void *cdrarg)
1429 {
1430 }
1431
1432 /*
1433 * allocate and deallocate external cmd space (ie. not part of scsa1394_cmd_t)
1434 * for non-standard length cdb, pkt_private, status areas
1435 */
1436 static int
1437 scsa1394_cmd_ext_alloc(scsa1394_state_t *sp, scsa1394_cmd_t *cmd, int kf)
1438 {
1439 struct scsi_pkt *pkt = cmd->sc_pkt;
1440 void *buf;
1441
1442 if (cmd->sc_cdb_len > sizeof (cmd->sc_pkt_cdb)) {
1443 if ((buf = kmem_zalloc(cmd->sc_cdb_len, kf)) == NULL) {
1444 return (DDI_FAILURE);
1445 }
1446 pkt->pkt_cdbp = buf;
1447 cmd->sc_flags |= SCSA1394_CMD_CDB_EXT;
1448 }
1449
1450 if (cmd->sc_scb_len > sizeof (cmd->sc_scb)) {
1451 if ((buf = kmem_zalloc(cmd->sc_scb_len, kf)) == NULL) {
1452 scsa1394_cmd_ext_free(sp, cmd);
1453 return (DDI_FAILURE);
1454 }
1455 pkt->pkt_scbp = buf;
1456 cmd->sc_flags |= SCSA1394_CMD_SCB_EXT;
1457 }
1458
1459 if (cmd->sc_priv_len > sizeof (cmd->sc_priv)) {
1460 if ((buf = kmem_zalloc(cmd->sc_priv_len, kf)) == NULL) {
1461 scsa1394_cmd_ext_free(sp, cmd);
1462 return (DDI_FAILURE);
1463 }
1464 pkt->pkt_private = buf;
1465 cmd->sc_flags |= SCSA1394_CMD_PRIV_EXT;
1466 }
1467
1468 return (DDI_SUCCESS);
1469 }
1470
1471 /*ARGSUSED*/
1472 static void
1473 scsa1394_cmd_ext_free(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
1474 {
1475 struct scsi_pkt *pkt = cmd->sc_pkt;
1476
1477 if (cmd->sc_flags & SCSA1394_CMD_CDB_EXT) {
1478 kmem_free(pkt->pkt_cdbp, cmd->sc_cdb_len);
1479 }
1480 if (cmd->sc_flags & SCSA1394_CMD_SCB_EXT) {
1481 kmem_free(pkt->pkt_scbp, cmd->sc_scb_len);
1482 }
1483 if (cmd->sc_flags & SCSA1394_CMD_PRIV_EXT) {
1484 kmem_free(pkt->pkt_private, cmd->sc_priv_len);
1485 }
1486 cmd->sc_flags &= ~SCSA1394_CMD_EXT;
1487 }
1488
1489 /*ARGSUSED*/
1490 static int
1491 scsa1394_cmd_cdb_dma_alloc(scsa1394_state_t *sp, scsa1394_cmd_t *cmd,
1492 int flags, int (*callback)(), caddr_t arg)
1493 {
1494 if (sbp2_task_orb_alloc(cmd->sc_lun->l_lun, &cmd->sc_task,
1495 sizeof (scsa1394_cmd_orb_t)) != SBP2_SUCCESS) {
1496 return (DDI_FAILURE);
1497 }
1498
1499 cmd->sc_flags |= SCSA1394_CMD_DMA_CDB_VALID;
1500 return (DDI_SUCCESS);
1501 }
1502
1503 /*ARGSUSED*/
1504 static void
1505 scsa1394_cmd_cdb_dma_free(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
1506 {
1507 sbp2_task_orb_free(cmd->sc_lun->l_lun, &cmd->sc_task);
1508 cmd->sc_flags &= ~SCSA1394_CMD_DMA_CDB_VALID;
1509 }
1510
2024 /* workarounds */
2025 switch (pkt->pkt_cdbp[0]) {
2026 /*
2027 * sd does START_STOP_UNIT during attach with a 200 sec timeout.
2028 * at this time devi_lock is held, prtconf will be stuck.
2029 * reduce timeout for the time being.
2030 */
2031 case SCMD_START_STOP:
2032 cmd->sc_timeout = min(cmd->sc_timeout,
2033 scsa1394_start_stop_timeout_max);
2034 break;
2035 default:
2036 break;
2037 }
2038 }
2039 }
2040
2041 static void
2042 scsa1394_cmd_fill_cdb(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
2043 {
2044 cmd->sc_cdb_actual_len = cmd->sc_cdb_len;
2045
2046 mutex_enter(&lp->l_mutex);
2047
2048 switch (lp->l_dtype_orig) {
2049 case DTYPE_DIRECT:
2050 case DTYPE_RODIRECT:
2051 case DTYPE_OPTICAL:
2052 case SCSA1394_DTYPE_RBC:
2053 scsa1394_cmd_fill_cdb_rbc(lp, cmd);
2054 break;
2055 default:
2056 scsa1394_cmd_fill_cdb_other(lp, cmd);
2057 break;
2058 }
2059
2060 mutex_exit(&lp->l_mutex);
2061 }
2062
2063 static void
2064 scsa1394_cmd_fill_cdb_rbc(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
2065 {
2066 scsa1394_state_t *sp = lp->l_sp;
2067 struct scsi_pkt *pkt = CMD2PKT(cmd);
2068 int lba, opcode;
2069 struct buf *bp = cmd->sc_bp;
2070 size_t len;
2071 size_t blk_size;
2072 int sz;
2073
2074 opcode = pkt->pkt_cdbp[0];
2075 blk_size = lp->l_lba_size;
2076
2077 switch (opcode) {
2078 case SCMD_READ:
2079 /* RBC only supports 10-byte read/write */
2080 lba = SCSA1394_LBA_6BYTE(pkt);
2081 len = SCSA1394_LEN_6BYTE(pkt);
2082 opcode = SCMD_READ_G1;
2083 cmd->sc_cdb_actual_len = CDB_GROUP1;
2084 break;
2085 case SCMD_WRITE:
2086 lba = SCSA1394_LBA_6BYTE(pkt);
2087 len = SCSA1394_LEN_6BYTE(pkt);
2088 opcode = SCMD_WRITE_G1;
2089 cmd->sc_cdb_actual_len = CDB_GROUP1;
2090 break;
2091 case SCMD_READ_G1:
2092 case SCMD_READ_LONG:
2093 lba = SCSA1394_LBA_10BYTE(pkt);
2094 len = SCSA1394_LEN_10BYTE(pkt);
2095 break;
2096 case SCMD_WRITE_G1:
2097 case SCMD_WRITE_LONG:
2098 lba = SCSA1394_LBA_10BYTE(pkt);
2099 len = SCSA1394_LEN_10BYTE(pkt);
2100 if ((lp->l_dtype_orig == DTYPE_RODIRECT) &&
2101 (bp != NULL) && (len != 0)) {
2102 sz = SCSA1394_CDRW_BLKSZ(bp->b_bcount, len);
2103 if (SCSA1394_VALID_CDRW_BLKSZ(sz)) {
2104 blk_size = sz;
2105 }
2106 }
2107 break;
2108 case SCMD_READ_CD:
2109 lba = SCSA1394_LBA_10BYTE(pkt);
2128 /* limit xfer length for Symbios workaround */
2129 if (sp->s_symbios && (len * blk_size > scsa1394_symbios_size_max)) {
2130 cmd->sc_flags |= SCSA1394_CMD_SYMBIOS_BREAKUP;
2131
2132 cmd->sc_total_blks = cmd->sc_resid_blks = len;
2133
2134 len = scsa1394_symbios_size_max / blk_size;
2135 }
2136 cmd->sc_xfer_blks = len;
2137 cmd->sc_xfer_bytes = len * blk_size;
2138
2139 /* finalize new CDB */
2140 switch (pkt->pkt_cdbp[0]) {
2141 case SCMD_READ:
2142 case SCMD_WRITE:
2143 /*
2144 * We rewrite READ/WRITE G0 commands as READ/WRITE G1.
2145 * Build new cdb from scatch.
2146 * The lba and length fields is updated below.
2147 */
2148 bzero(cmd->sc_cdb, cmd->sc_cdb_actual_len);
2149 break;
2150 default:
2151 /*
2152 * Copy the non lba/len fields.
2153 * The lba and length fields is updated below.
2154 */
2155 bcopy(pkt->pkt_cdbp, cmd->sc_cdb, cmd->sc_cdb_actual_len);
2156 break;
2157 }
2158
2159 cmd->sc_cdb[0] = (uchar_t)opcode;
2160 scsa1394_cmd_fill_cdb_lba(cmd, lba);
2161 switch (opcode) {
2162 case SCMD_READ_CD:
2163 scsa1394_cmd_fill_read_cd_cdb_len(cmd, len);
2164 break;
2165 case SCMD_WRITE_G5:
2166 case SCMD_READ_G5:
2167 scsa1394_cmd_fill_12byte_cdb_len(cmd, len);
2168 break;
2169 default:
2170 scsa1394_cmd_fill_cdb_len(cmd, len);
2171 break;
2172 }
2173 }
2174
2175 /*ARGSUSED*/
2176 static void
2177 scsa1394_cmd_fill_cdb_other(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
2178 {
2179 struct scsi_pkt *pkt = CMD2PKT(cmd);
2180
2181 cmd->sc_xfer_bytes = cmd->sc_win_len;
2182 cmd->sc_xfer_blks = cmd->sc_xfer_bytes / lp->l_lba_size;
2183 cmd->sc_total_blks = cmd->sc_xfer_blks;
2184 cmd->sc_lba = 0;
2185
2186 bcopy(pkt->pkt_cdbp, cmd->sc_cdb, cmd->sc_cdb_len);
2187 }
2188
2189 /*
2190 * fill up parts of CDB
2191 */
2192 static void
2193 scsa1394_cmd_fill_cdb_len(scsa1394_cmd_t *cmd, int len)
2194 {
2195 cmd->sc_cdb[7] = len >> 8;
2196 cmd->sc_cdb[8] = (uchar_t)len;
2197 }
2198
2199 static void
2200 scsa1394_cmd_fill_cdb_lba(scsa1394_cmd_t *cmd, int lba)
2201 {
2202 cmd->sc_cdb[2] = lba >> 24;
2203 cmd->sc_cdb[3] = lba >> 16;
2204 cmd->sc_cdb[4] = lba >> 8;
2205 cmd->sc_cdb[5] = (uchar_t)lba;
2206 cmd->sc_lba = lba;
2207 }
2208
2209 static void
2210 scsa1394_cmd_fill_12byte_cdb_len(scsa1394_cmd_t *cmd, int len)
2211 {
2212 cmd->sc_cdb[6] = len >> 24;
2213 cmd->sc_cdb[7] = len >> 16;
2214 cmd->sc_cdb[8] = len >> 8;
2215 cmd->sc_cdb[9] = (uchar_t)len;
2216 }
2217
2218 static void
2219 scsa1394_cmd_fill_read_cd_cdb_len(scsa1394_cmd_t *cmd, int len)
2220 {
2221 cmd->sc_cdb[6] = len >> 16;
2222 cmd->sc_cdb[7] = len >> 8;
2223 cmd->sc_cdb[8] = (uchar_t)len;
2224 }
2225
2226 /*
2227 * For SCMD_READ_CD, figure out the block size based on expected sector type.
2228 * See MMC SCSI Specs section 6.1.15
2229 */
2230 static int
2231 scsa1394_cmd_read_cd_blk_size(uchar_t expected_sector_type)
2232 {
2233 int blk_size;
2234
2235 switch (expected_sector_type) {
2236 case READ_CD_EST_CDDA:
2237 blk_size = CDROM_BLK_2352;
2238 break;
2239 case READ_CD_EST_MODE2:
2240 blk_size = CDROM_BLK_2336;
2241 break;
2242 case READ_CD_EST_MODE2FORM2:
2243 blk_size = CDROM_BLK_2324;
2431
2432 /*
2433 * new lba = current lba + previous xfer len
2434 */
2435 /*ARGSUSED*/
2436 static void
2437 scsa1394_cmd_adjust_cdb(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
2438 {
2439 int len;
2440
2441 ASSERT(cmd->sc_flags & SCSA1394_CMD_SYMBIOS_BREAKUP);
2442
2443 cmd->sc_lba += cmd->sc_xfer_blks;
2444 len = cmd->sc_resid_blks;
2445
2446 /* limit xfer length for Symbios workaround */
2447 if (len * cmd->sc_blk_size > scsa1394_symbios_size_max) {
2448 len = scsa1394_symbios_size_max / cmd->sc_blk_size;
2449 }
2450
2451 switch (cmd->sc_cdb[0]) {
2452 case SCMD_READ_CD:
2453 scsa1394_cmd_fill_read_cd_cdb_len(cmd, len);
2454 break;
2455 case SCMD_WRITE_G5:
2456 case SCMD_READ_G5:
2457 scsa1394_cmd_fill_12byte_cdb_len(cmd, len);
2458 break;
2459 case SCMD_WRITE_G1:
2460 case SCMD_WRITE_LONG:
2461 default:
2462 scsa1394_cmd_fill_cdb_len(cmd, len);
2463 }
2464
2465 scsa1394_cmd_fill_cdb_lba(cmd, cmd->sc_lba);
2466
2467 cmd->sc_xfer_blks = len;
2468 cmd->sc_xfer_bytes = len * cmd->sc_blk_size;
2469 }
2470
2471 void
|
39 #include <sys/sunddi.h>
40
41 #include <sys/1394/targets/scsa1394/impl.h>
42 #include <sys/1394/targets/scsa1394/cmd.h>
43
44 /* DDI/DKI entry points */
45 static int scsa1394_attach(dev_info_t *, ddi_attach_cmd_t);
46 static int scsa1394_detach(dev_info_t *, ddi_detach_cmd_t);
47 static int scsa1394_power(dev_info_t *, int, int);
48 static int scsa1394_cpr_suspend(dev_info_t *);
49 static void scsa1394_cpr_resume(dev_info_t *);
50
51 /* configuration routines */
52 static void scsa1394_cleanup(scsa1394_state_t *, int);
53 static int scsa1394_attach_1394(scsa1394_state_t *);
54 static void scsa1394_detach_1394(scsa1394_state_t *);
55 static int scsa1394_attach_threads(scsa1394_state_t *);
56 static void scsa1394_detach_threads(scsa1394_state_t *);
57 static int scsa1394_attach_scsa(scsa1394_state_t *);
58 static void scsa1394_detach_scsa(scsa1394_state_t *);
59 static int scsa1394_add_events(scsa1394_state_t *);
60 static void scsa1394_remove_events(scsa1394_state_t *);
61
62 /* device configuration */
63 static int scsa1394_scsi_bus_config(dev_info_t *, uint_t,
64 ddi_bus_config_op_t, void *, dev_info_t **);
65 static int scsa1394_scsi_bus_unconfig(dev_info_t *, uint_t,
66 ddi_bus_config_op_t, void *);
67 static void scsa1394_create_children(scsa1394_state_t *);
68 static void scsa1394_bus_reset(dev_info_t *, ddi_eventcookie_t, void *,
69 void *);
70 static void scsa1394_disconnect(dev_info_t *, ddi_eventcookie_t, void *,
71 void *);
72 static void scsa1394_reconnect(dev_info_t *, ddi_eventcookie_t, void *,
73 void *);
74
75 /* SCSA HBA entry points */
76 static int scsa1394_scsi_tgt_init(dev_info_t *, dev_info_t *,
77 scsi_hba_tran_t *, struct scsi_device *);
78 static void scsa1394_scsi_tgt_free(dev_info_t *, dev_info_t *,
79 scsi_hba_tran_t *, struct scsi_device *);
80 static int scsa1394_scsi_tgt_probe(struct scsi_device *, int (*)());
81 static int scsa1394_probe_g0_nodata(struct scsi_device *, int (*)(),
82 uchar_t, uint_t, uint_t);
83 static int scsa1394_probe_tran(struct scsi_pkt *);
84 static struct scsi_pkt *scsa1394_scsi_init_pkt(struct scsi_address *,
85 struct scsi_pkt *, struct buf *, int, int, int, int,
86 int (*)(), caddr_t arg);
87 static void scsa1394_scsi_destroy_pkt(struct scsi_address *,
88 struct scsi_pkt *);
89 static int scsa1394_scsi_start(struct scsi_address *, struct scsi_pkt *);
90 static int scsa1394_scsi_abort(struct scsi_address *, struct scsi_pkt *);
91 static int scsa1394_scsi_reset(struct scsi_address *, int);
92 static int scsa1394_scsi_getcap(struct scsi_address *, char *, int);
93 static int scsa1394_scsi_setcap(struct scsi_address *, char *, int, int);
94 static void scsa1394_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
95 static void scsa1394_scsi_sync_pkt(struct scsi_address *,
96 struct scsi_pkt *);
97
98 /* pkt resource allocation routines */
99 static int scsa1394_cmd_cdb_dma_alloc(scsa1394_state_t *, scsa1394_cmd_t *,
100 int, int (*)(), caddr_t);
101 static void scsa1394_cmd_cdb_dma_free(scsa1394_state_t *, scsa1394_cmd_t *);
102 static int scsa1394_cmd_buf_dma_alloc(scsa1394_state_t *, scsa1394_cmd_t *,
103 int, int (*)(), caddr_t, struct buf *);
104 static void scsa1394_cmd_buf_dma_free(scsa1394_state_t *, scsa1394_cmd_t *);
105 static int scsa1394_cmd_dmac2seg(scsa1394_state_t *, scsa1394_cmd_t *,
106 ddi_dma_cookie_t *, uint_t, int);
107 static void scsa1394_cmd_seg_free(scsa1394_state_t *, scsa1394_cmd_t *);
108 static int scsa1394_cmd_pt_dma_alloc(scsa1394_state_t *, scsa1394_cmd_t *,
109 int (*)(), caddr_t, int);
110 static void scsa1394_cmd_pt_dma_free(scsa1394_state_t *, scsa1394_cmd_t *);
111 static int scsa1394_cmd_buf_addr_alloc(scsa1394_state_t *,
112 scsa1394_cmd_t *);
113 static void scsa1394_cmd_buf_addr_free(scsa1394_state_t *,
114 scsa1394_cmd_t *);
115 static int scsa1394_cmd_buf_dma_move(scsa1394_state_t *, scsa1394_cmd_t *);
116
117
118 /* pkt and data transfer routines */
282 if (scsa1394_attach_1394(sp) != DDI_SUCCESS) {
283 scsa1394_cleanup(sp, 1);
284 return (DDI_FAILURE);
285 }
286
287 if (scsa1394_sbp2_attach(sp) != DDI_SUCCESS) {
288 scsa1394_cleanup(sp, 2);
289 return (DDI_FAILURE);
290 }
291
292 if (scsa1394_attach_threads(sp) != DDI_SUCCESS) {
293 scsa1394_cleanup(sp, 3);
294 return (DDI_FAILURE);
295 }
296
297 if (scsa1394_attach_scsa(sp) != DDI_SUCCESS) {
298 scsa1394_cleanup(sp, 4);
299 return (DDI_FAILURE);
300 }
301
302 if (scsa1394_add_events(sp) != DDI_SUCCESS) {
303 scsa1394_cleanup(sp, 5);
304 return (DDI_FAILURE);
305 }
306
307 /* prevent async PM changes until we are done */
308 (void) pm_busy_component(dip, 0);
309
310 /* Set power to full on */
311 (void) pm_raise_power(dip, 0, PM_LEVEL_D0);
312
313 /* we are done */
314 (void) pm_idle_component(dip, 0);
315
316 #ifndef __lock_lint
317 sp->s_dev_state = SCSA1394_DEV_ONLINE;
318 #endif
319
320 ddi_report_dev(dip);
321
322 return (DDI_SUCCESS);
323 }
430 /* we are down so let the power get managed */
431 (void) pm_idle_component(dip, 0);
432 }
433
434
435
436 /*
437 *
438 * --- configuration routines
439 *
440 */
441 static void
442 scsa1394_cleanup(scsa1394_state_t *sp, int level)
443 {
444 ASSERT((level > 0) && (level <= SCSA1394_CLEANUP_LEVEL_MAX));
445
446 switch (level) {
447 default:
448 scsa1394_remove_events(sp);
449 /* FALLTHRU */
450 case 5:
451 scsa1394_detach_scsa(sp);
452 /* FALLTHRU */
453 case 4:
454 scsa1394_detach_threads(sp);
455 /* FALLTHRU */
456 case 3:
457 scsa1394_sbp2_detach(sp);
458 /* FALLTHRU */
459 case 2:
460 scsa1394_detach_1394(sp);
461 /* FALLTHRU */
462 case 1:
463 cv_destroy(&sp->s_event_cv);
464 mutex_destroy(&sp->s_mutex);
465 ddi_soft_state_free(scsa1394_statep, sp->s_instance);
466 }
467 }
468
469 static int
470 scsa1394_attach_1394(scsa1394_state_t *sp)
471 {
565 tran, 0)) != DDI_SUCCESS) {
566 scsi_hba_tran_free(tran);
567 return (ret);
568 }
569
570 return (DDI_SUCCESS);
571 }
572
573 static void
574 scsa1394_detach_scsa(scsa1394_state_t *sp)
575 {
576 int ret;
577
578 ret = scsi_hba_detach(sp->s_dip);
579 ASSERT(ret == DDI_SUCCESS);
580
581 scsi_hba_tran_free(sp->s_tran);
582 }
583
584 static int
585 scsa1394_add_events(scsa1394_state_t *sp)
586 {
587 ddi_eventcookie_t br_evc, rem_evc, ins_evc;
588
589 if (ddi_get_eventcookie(sp->s_dip, DDI_DEVI_BUS_RESET_EVENT,
590 &br_evc) != DDI_SUCCESS) {
591 return (DDI_FAILURE);
592 }
593 if (ddi_add_event_handler(sp->s_dip, br_evc, scsa1394_bus_reset,
594 sp, &sp->s_reset_cb_id) != DDI_SUCCESS) {
595 return (DDI_FAILURE);
596 }
597
598 if (ddi_get_eventcookie(sp->s_dip, DDI_DEVI_REMOVE_EVENT,
599 &rem_evc) != DDI_SUCCESS) {
600 (void) ddi_remove_event_handler(sp->s_reset_cb_id);
601 return (DDI_FAILURE);
602 }
603 if (ddi_add_event_handler(sp->s_dip, rem_evc, scsa1394_disconnect,
604 sp, &sp->s_remove_cb_id) != DDI_SUCCESS) {
1243 scsa1394_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
1244 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags,
1245 int (*callback)(), caddr_t arg)
1246 {
1247 scsa1394_state_t *sp = ADDR2STATE(ap);
1248 scsa1394_lun_t *lp;
1249 scsa1394_cmd_t *cmd;
1250 boolean_t is_new; /* new cmd is being allocated */
1251 int kf = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP;
1252
1253 if (ap->a_lun >= sp->s_nluns) {
1254 return (NULL);
1255 }
1256 lp = &sp->s_lun[ap->a_lun];
1257
1258 /*
1259 * allocate cmd space
1260 */
1261 if (pkt == NULL) {
1262 is_new = B_TRUE;
1263 pkt = scsi_hba_pkt_alloc(NULL, ap, max(SCSI_CDB_SIZE, cmdlen),
1264 statuslen, tgtlen, sizeof (scsa1394_cmd_t), callback, arg);
1265 if (!pkt)
1266 return (NULL);
1267
1268 /* initialize cmd */
1269 cmd = pkt->pkt_ha_private;
1270 cmd->sc_lun = lp;
1271 cmd->sc_pkt = pkt;
1272 cmd->sc_orig_cdblen = cmdlen;
1273 cmd->sc_task.ts_drv_priv = cmd;
1274
1275 /* allocate DMA resources for CDB */
1276 if (scsa1394_cmd_cdb_dma_alloc(sp, cmd, flags, callback, arg) !=
1277 DDI_SUCCESS) {
1278 scsa1394_scsi_destroy_pkt(ap, pkt);
1279 return (NULL);
1280 }
1281 } else {
1282 is_new = B_FALSE;
1283 cmd = PKT2CMD(pkt);
1284 }
1285
1286 cmd->sc_flags &= ~SCSA1394_CMD_RDWR;
1287
1288 /* allocate/move DMA resources for data buffer */
1289 if ((bp != NULL) && (bp->b_bcount > 0)) {
1290 if ((cmd->sc_flags & SCSA1394_CMD_DMA_BUF_VALID) == 0) {
1291 if (scsa1394_cmd_buf_dma_alloc(sp, cmd, flags, callback,
1292 arg, bp) != DDI_SUCCESS) {
1293 if (is_new) {
1318
1319 return (pkt);
1320 }
1321
1322 static void
1323 scsa1394_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
1324 {
1325 scsa1394_state_t *sp = ADDR2STATE(ap);
1326 scsa1394_cmd_t *cmd = PKT2CMD(pkt);
1327
1328 if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_VALID) {
1329 scsa1394_cmd_buf_dma_free(sp, cmd);
1330 }
1331 if (cmd->sc_flags & SCSA1394_CMD_DMA_CDB_VALID) {
1332 scsa1394_cmd_cdb_dma_free(sp, cmd);
1333 }
1334 if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_MAPIN) {
1335 bp_mapout(cmd->sc_bp);
1336 cmd->sc_flags &= ~SCSA1394_CMD_DMA_BUF_MAPIN;
1337 }
1338
1339 scsi_hba_pkt_free(ap, pkt);
1340 }
1341
1342 static void
1343 scsa1394_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
1344 {
1345 scsa1394_state_t *sp = ADDR2STATE(ap);
1346 scsa1394_cmd_t *cmd = PKT2CMD(pkt);
1347
1348 if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_VALID) {
1349 scsa1394_cmd_buf_dma_free(sp, cmd);
1350 }
1351 if (cmd->sc_flags & SCSA1394_CMD_DMA_BUF_MAPIN) {
1352 bp_mapout(cmd->sc_bp);
1353 cmd->sc_flags &= ~SCSA1394_CMD_DMA_BUF_MAPIN;
1354 }
1355 }
1356
1357 /*ARGSUSED*/
1358 static int
1359 scsa1394_cmd_cdb_dma_alloc(scsa1394_state_t *sp, scsa1394_cmd_t *cmd,
1360 int flags, int (*callback)(), caddr_t arg)
1361 {
1362 if (sbp2_task_orb_alloc(cmd->sc_lun->l_lun, &cmd->sc_task,
1363 sizeof (scsa1394_cmd_orb_t)) != SBP2_SUCCESS) {
1364 return (DDI_FAILURE);
1365 }
1366
1367 cmd->sc_flags |= SCSA1394_CMD_DMA_CDB_VALID;
1368 return (DDI_SUCCESS);
1369 }
1370
1371 /*ARGSUSED*/
1372 static void
1373 scsa1394_cmd_cdb_dma_free(scsa1394_state_t *sp, scsa1394_cmd_t *cmd)
1374 {
1375 sbp2_task_orb_free(cmd->sc_lun->l_lun, &cmd->sc_task);
1376 cmd->sc_flags &= ~SCSA1394_CMD_DMA_CDB_VALID;
1377 }
1378
1892 /* workarounds */
1893 switch (pkt->pkt_cdbp[0]) {
1894 /*
1895 * sd does START_STOP_UNIT during attach with a 200 sec timeout.
1896 * at this time devi_lock is held, prtconf will be stuck.
1897 * reduce timeout for the time being.
1898 */
1899 case SCMD_START_STOP:
1900 cmd->sc_timeout = min(cmd->sc_timeout,
1901 scsa1394_start_stop_timeout_max);
1902 break;
1903 default:
1904 break;
1905 }
1906 }
1907 }
1908
1909 static void
1910 scsa1394_cmd_fill_cdb(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
1911 {
1912 mutex_enter(&lp->l_mutex);
1913
1914 switch (lp->l_dtype_orig) {
1915 case DTYPE_DIRECT:
1916 case DTYPE_RODIRECT:
1917 case DTYPE_OPTICAL:
1918 case SCSA1394_DTYPE_RBC:
1919 scsa1394_cmd_fill_cdb_rbc(lp, cmd);
1920 break;
1921 default:
1922 scsa1394_cmd_fill_cdb_other(lp, cmd);
1923 break;
1924 }
1925
1926 mutex_exit(&lp->l_mutex);
1927 }
1928
1929 static void
1930 scsa1394_cmd_fill_cdb_rbc(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
1931 {
1932 scsa1394_state_t *sp = lp->l_sp;
1933 struct scsi_pkt *pkt = CMD2PKT(cmd);
1934 int lba, opcode;
1935 struct buf *bp = cmd->sc_bp;
1936 size_t len;
1937 size_t blk_size;
1938 int sz;
1939
1940 opcode = pkt->pkt_cdbp[0];
1941 blk_size = lp->l_lba_size;
1942
1943 switch (opcode) {
1944 case SCMD_READ:
1945 /* RBC only supports 10-byte read/write */
1946 lba = SCSA1394_LBA_6BYTE(pkt);
1947 len = SCSA1394_LEN_6BYTE(pkt);
1948 opcode = SCMD_READ_G1;
1949 cmd->sc_orig_cdblen = CDB_GROUP1;
1950 break;
1951 case SCMD_WRITE:
1952 lba = SCSA1394_LBA_6BYTE(pkt);
1953 len = SCSA1394_LEN_6BYTE(pkt);
1954 opcode = SCMD_WRITE_G1;
1955 cmd->sc_orig_cdblen = CDB_GROUP1;
1956 break;
1957 case SCMD_READ_G1:
1958 case SCMD_READ_LONG:
1959 lba = SCSA1394_LBA_10BYTE(pkt);
1960 len = SCSA1394_LEN_10BYTE(pkt);
1961 break;
1962 case SCMD_WRITE_G1:
1963 case SCMD_WRITE_LONG:
1964 lba = SCSA1394_LBA_10BYTE(pkt);
1965 len = SCSA1394_LEN_10BYTE(pkt);
1966 if ((lp->l_dtype_orig == DTYPE_RODIRECT) &&
1967 (bp != NULL) && (len != 0)) {
1968 sz = SCSA1394_CDRW_BLKSZ(bp->b_bcount, len);
1969 if (SCSA1394_VALID_CDRW_BLKSZ(sz)) {
1970 blk_size = sz;
1971 }
1972 }
1973 break;
1974 case SCMD_READ_CD:
1975 lba = SCSA1394_LBA_10BYTE(pkt);
1994 /* limit xfer length for Symbios workaround */
1995 if (sp->s_symbios && (len * blk_size > scsa1394_symbios_size_max)) {
1996 cmd->sc_flags |= SCSA1394_CMD_SYMBIOS_BREAKUP;
1997
1998 cmd->sc_total_blks = cmd->sc_resid_blks = len;
1999
2000 len = scsa1394_symbios_size_max / blk_size;
2001 }
2002 cmd->sc_xfer_blks = len;
2003 cmd->sc_xfer_bytes = len * blk_size;
2004
2005 /* finalize new CDB */
2006 switch (pkt->pkt_cdbp[0]) {
2007 case SCMD_READ:
2008 case SCMD_WRITE:
2009 /*
2010 * We rewrite READ/WRITE G0 commands as READ/WRITE G1.
2011 * Build new cdb from scatch.
2012 * The lba and length fields is updated below.
2013 */
2014 bzero(pkt->pkt_cdbp, cmd->sc_orig_cdblen);
2015 break;
2016 default:
2017 break;
2018 }
2019
2020 pkt->pkt_cdbp[0] = (uchar_t)opcode;
2021 scsa1394_cmd_fill_cdb_lba(cmd, lba);
2022 switch (opcode) {
2023 case SCMD_READ_CD:
2024 scsa1394_cmd_fill_read_cd_cdb_len(cmd, len);
2025 break;
2026 case SCMD_WRITE_G5:
2027 case SCMD_READ_G5:
2028 scsa1394_cmd_fill_12byte_cdb_len(cmd, len);
2029 break;
2030 default:
2031 scsa1394_cmd_fill_cdb_len(cmd, len);
2032 break;
2033 }
2034 }
2035
2036 /*ARGSUSED*/
2037 static void
2038 scsa1394_cmd_fill_cdb_other(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
2039 {
2040 cmd->sc_xfer_bytes = cmd->sc_win_len;
2041 cmd->sc_xfer_blks = cmd->sc_xfer_bytes / lp->l_lba_size;
2042 cmd->sc_total_blks = cmd->sc_xfer_blks;
2043 cmd->sc_lba = 0;
2044 }
2045
2046 /*
2047 * fill up parts of CDB
2048 */
2049 static void
2050 scsa1394_cmd_fill_cdb_len(scsa1394_cmd_t *cmd, int len)
2051 {
2052 struct scsi_pkt *pkt = CMD2PKT(cmd);
2053
2054 pkt->pkt_cdbp[7] = len >> 8;
2055 pkt->pkt_cdbp[8] = (uchar_t)len;
2056 }
2057
2058 static void
2059 scsa1394_cmd_fill_cdb_lba(scsa1394_cmd_t *cmd, int lba)
2060 {
2061 struct scsi_pkt *pkt = CMD2PKT(cmd);
2062
2063 pkt->pkt_cdbp[2] = lba >> 24;
2064 pkt->pkt_cdbp[3] = lba >> 16;
2065 pkt->pkt_cdbp[4] = lba >> 8;
2066 pkt->pkt_cdbp[5] = (uchar_t)lba;
2067 cmd->sc_lba = lba;
2068 }
2069
2070 static void
2071 scsa1394_cmd_fill_12byte_cdb_len(scsa1394_cmd_t *cmd, int len)
2072 {
2073 struct scsi_pkt *pkt = CMD2PKT(cmd);
2074
2075 pkt->pkt_cdbp[6] = len >> 24;
2076 pkt->pkt_cdbp[7] = len >> 16;
2077 pkt->pkt_cdbp[8] = len >> 8;
2078 pkt->pkt_cdbp[9] = (uchar_t)len;
2079 }
2080
2081 static void
2082 scsa1394_cmd_fill_read_cd_cdb_len(scsa1394_cmd_t *cmd, int len)
2083 {
2084 struct scsi_pkt *pkt = CMD2PKT(cmd);
2085
2086 pkt->pkt_cdbp[6] = len >> 16;
2087 pkt->pkt_cdbp[7] = len >> 8;
2088 pkt->pkt_cdbp[8] = (uchar_t)len;
2089 }
2090
2091 /*
2092 * For SCMD_READ_CD, figure out the block size based on expected sector type.
2093 * See MMC SCSI Specs section 6.1.15
2094 */
2095 static int
2096 scsa1394_cmd_read_cd_blk_size(uchar_t expected_sector_type)
2097 {
2098 int blk_size;
2099
2100 switch (expected_sector_type) {
2101 case READ_CD_EST_CDDA:
2102 blk_size = CDROM_BLK_2352;
2103 break;
2104 case READ_CD_EST_MODE2:
2105 blk_size = CDROM_BLK_2336;
2106 break;
2107 case READ_CD_EST_MODE2FORM2:
2108 blk_size = CDROM_BLK_2324;
2296
2297 /*
2298 * new lba = current lba + previous xfer len
2299 */
2300 /*ARGSUSED*/
2301 static void
2302 scsa1394_cmd_adjust_cdb(scsa1394_lun_t *lp, scsa1394_cmd_t *cmd)
2303 {
2304 int len;
2305
2306 ASSERT(cmd->sc_flags & SCSA1394_CMD_SYMBIOS_BREAKUP);
2307
2308 cmd->sc_lba += cmd->sc_xfer_blks;
2309 len = cmd->sc_resid_blks;
2310
2311 /* limit xfer length for Symbios workaround */
2312 if (len * cmd->sc_blk_size > scsa1394_symbios_size_max) {
2313 len = scsa1394_symbios_size_max / cmd->sc_blk_size;
2314 }
2315
2316 switch (cmd->sc_pkt->pkt_cdbp[0]) {
2317 case SCMD_READ_CD:
2318 scsa1394_cmd_fill_read_cd_cdb_len(cmd, len);
2319 break;
2320 case SCMD_WRITE_G5:
2321 case SCMD_READ_G5:
2322 scsa1394_cmd_fill_12byte_cdb_len(cmd, len);
2323 break;
2324 case SCMD_WRITE_G1:
2325 case SCMD_WRITE_LONG:
2326 default:
2327 scsa1394_cmd_fill_cdb_len(cmd, len);
2328 }
2329
2330 scsa1394_cmd_fill_cdb_lba(cmd, cmd->sc_lba);
2331
2332 cmd->sc_xfer_blks = len;
2333 cmd->sc_xfer_bytes = len * cmd->sc_blk_size;
2334 }
2335
2336 void
|