Lines Matching refs:scb
213 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
214 DMA_NONE == scb->scsi_cmd->sc_data_direction) ? \
216 scb->scsi_cmd->sc_data_direction)
647 ips_scb_t *scb;
669 scb = &ha->scbs[ha->max_cmds - 1];
671 ips_init_scb(ha, scb);
673 scb->timeout = ips_cmd_timeout;
674 scb->cdb[0] = IPS_CMD_FLUSH;
676 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
677 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
678 scb->cmd.flush_cache.state = IPS_NORM_STATE;
679 scb->cmd.flush_cache.reserved = 0;
680 scb->cmd.flush_cache.reserved2 = 0;
681 scb->cmd.flush_cache.reserved3 = 0;
682 scb->cmd.flush_cache.reserved4 = 0;
687 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
718 ips_scb_t *scb;
736 scb = &ha->scbs[ha->max_cmds - 1];
738 ips_init_scb(ha, scb);
740 scb->timeout = ips_cmd_timeout;
741 scb->cdb[0] = IPS_CMD_FLUSH;
743 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
744 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
745 scb->cmd.flush_cache.state = IPS_NORM_STATE;
746 scb->cmd.flush_cache.reserved = 0;
747 scb->cmd.flush_cache.reserved2 = 0;
748 scb->cmd.flush_cache.reserved3 = 0;
749 scb->cmd.flush_cache.reserved4 = 0;
754 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) ==
837 ips_scb_t *scb;
873 scb = &ha->scbs[ha->max_cmds - 1];
875 ips_init_scb(ha, scb);
877 scb->timeout = ips_cmd_timeout;
878 scb->cdb[0] = IPS_CMD_FLUSH;
880 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
881 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
882 scb->cmd.flush_cache.state = IPS_NORM_STATE;
883 scb->cmd.flush_cache.reserved = 0;
884 scb->cmd.flush_cache.reserved2 = 0;
885 scb->cmd.flush_cache.reserved3 = 0;
886 scb->cmd.flush_cache.reserved4 = 0;
889 ret = ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_IORL);
919 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
920 scb->scsi_cmd->result = DID_ERROR << 16;
921 scsi_done(scb->scsi_cmd);
922 ips_freescb(ha, scb);
948 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
949 scb->scsi_cmd->result = DID_ERROR << 16;
950 scsi_done(scb->scsi_cmd);
951 ips_freescb(ha, scb);
977 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
978 scb->scsi_cmd->result = DID_RESET << 16;
979 scsi_done(scb->scsi_cmd);
980 ips_freescb(ha, scb);
1254 ips_scb_t *scb;
1292 scb = (ips_scb_t *) sp->scb_addr;
1298 (*scb->callback) (ha, scb);
1318 ips_scb_t *scb;
1362 scb = (ips_scb_t *) sp->scb_addr;
1368 (*scb->callback) (ha, scb);
1542 ips_make_passthru(ips_ha_t *ha, struct scsi_cmnd *SC, ips_scb_t *scb, int intr)
1612 ret = ips_flash_copperhead(ha, pt, scb);
1617 if (ips_usrcmd(ha, pt, scb))
1636 ips_flash_copperhead(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1643 if (ips_usrcmd(ha, pt, scb))
1650 scb->scsi_cmd->result = DID_OK << 16;
1656 return ips_flash_bios(ha, pt, scb);
1694 return ips_flash_bios(ha, pt, scb);
1696 return ips_flash_firmware(ha, pt, scb);
1707 ips_flash_bios(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1767 /* Fill in a single scb sg_list element from an address */
1772 ips_scb_t * scb, int indx, unsigned int e_len)
1777 if ((scb->data_len + e_len) > ha->max_xfer) {
1778 e_len = ha->max_xfer - scb->data_len;
1779 scb->breakup = indx;
1780 ++scb->sg_break;
1783 scb->breakup = 0;
1784 scb->sg_break = 0;
1787 scb->sg_list.enh_list[indx].address_lo =
1789 scb->sg_list.enh_list[indx].address_hi =
1791 scb->sg_list.enh_list[indx].length = cpu_to_le32(e_len);
1793 scb->sg_list.std_list[indx].address =
1795 scb->sg_list.std_list[indx].length = cpu_to_le32(e_len);
1798 ++scb->sg_len;
1799 scb->data_len += e_len;
1809 ips_flash_firmware(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1826 sg_list.list = scb->sg_list.list;
1827 cmd_busaddr = scb->scb_busaddr;
1829 memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1831 scb->sg_list.list = sg_list.list;
1832 scb->scb_busaddr = cmd_busaddr;
1833 scb->bus = scb->scsi_cmd->device->channel;
1834 scb->target_id = scb->scsi_cmd->device->id;
1835 scb->lun = scb->scsi_cmd->device->lun;
1836 scb->sg_len = 0;
1837 scb->data_len = 0;
1838 scb->flags = 0;
1839 scb->op_code = 0;
1840 scb->callback = ipsintr_done;
1841 scb->timeout = ips_cmd_timeout;
1843 scb->data_len = ha->flash_datasize;
1844 scb->data_busaddr =
1845 dma_map_single(&ha->pcidev->dev, ha->flash_data, scb->data_len,
1846 IPS_DMA_DIR(scb));
1847 scb->flags |= IPS_SCB_MAP_SINGLE;
1848 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
1849 scb->cmd.flashfw.buffer_addr = cpu_to_le32(scb->data_busaddr);
1851 scb->timeout = pt->TimeOut;
1852 scb->scsi_cmd->result = DID_OK << 16;
1882 ips_usrcmd(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1889 if ((!scb) || (!pt) || (!ha))
1893 sg_list.list = scb->sg_list.list;
1894 cmd_busaddr = scb->scb_busaddr;
1896 memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1897 memcpy(&scb->dcdb, &pt->CoppCP.dcdb, sizeof (IPS_DCDB_TABLE));
1900 scb->sg_list.list = sg_list.list;
1901 scb->scb_busaddr = cmd_busaddr;
1902 scb->bus = scb->scsi_cmd->device->channel;
1903 scb->target_id = scb->scsi_cmd->device->id;
1904 scb->lun = scb->scsi_cmd->device->lun;
1905 scb->sg_len = 0;
1906 scb->data_len = 0;
1907 scb->flags = 0;
1908 scb->op_code = 0;
1909 scb->callback = ipsintr_done;
1910 scb->timeout = ips_cmd_timeout;
1911 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
1914 if ((scb->cmd.basic_io.op_code == IPS_CMD_READ_SG) ||
1915 (scb->cmd.basic_io.op_code == IPS_CMD_WRITE_SG) ||
1916 (scb->cmd.basic_io.op_code == IPS_CMD_DCDB_SG))
1920 scb->data_len = pt->CmdBSize;
1921 scb->data_busaddr = ha->ioctl_busaddr + sizeof (ips_passthru_t);
1923 scb->data_busaddr = 0L;
1926 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
1927 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
1928 (unsigned long) &scb->
1930 (unsigned long) scb);
1933 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
1934 scb->dcdb.buffer_pointer =
1935 cpu_to_le32(scb->data_busaddr);
1937 scb->cmd.basic_io.sg_addr =
1938 cpu_to_le32(scb->data_busaddr);
1943 scb->timeout = pt->TimeOut;
1946 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10;
1948 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60;
1950 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;
1954 scb->scsi_cmd->result = DID_OK << 16;
1970 ips_cleanup_passthru(ips_ha_t * ha, ips_scb_t * scb)
1976 if ((!scb) || (!scb->scsi_cmd) || (!scsi_sglist(scb->scsi_cmd))) {
1985 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB) /* Copy DCDB Back to Caller's Area */
1986 memcpy(&pt->CoppCP.dcdb, &scb->dcdb, sizeof (IPS_DCDB_TABLE));
1988 pt->BasicStatus = scb->basic_status;
1989 pt->ExtendedStatus = scb->extended_status;
1993 (scb->cmd.flashfw.op_code == IPS_CMD_DOWNLOAD ||
1994 scb->cmd.flashfw.op_code == IPS_CMD_RW_BIOSFW))
1997 ips_scmd_buf_write(scb->scsi_cmd, ha->ioctl_data, ha->ioctl_datasize);
2215 ips_scb_t *scb;
2314 scb = &ha->scbs[ha->max_cmds - 1];
2316 ips_init_scb(ha, scb);
2318 scb->timeout = ips_cmd_timeout;
2319 scb->cdb[0] = IPS_CMD_RW_BIOSFW;
2321 scb->cmd.flashfw.op_code = IPS_CMD_RW_BIOSFW;
2322 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
2323 scb->cmd.flashfw.type = 1;
2324 scb->cmd.flashfw.direction = 0;
2325 scb->cmd.flashfw.count = cpu_to_le32(0x800);
2326 scb->cmd.flashfw.total_packets = 1;
2327 scb->cmd.flashfw.packet_num = 0;
2328 scb->data_len = 0x1000;
2329 scb->cmd.flashfw.buffer_addr = ha->ioctl_busaddr;
2333 ips_send_wait(ha, scb, ips_cmd_timeout,
2336 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
2509 ips_scb_t *scb;
2545 (ha->copp_waitlist.head) && (scb = ips_getscb(ha))) {
2551 scb->scsi_cmd = item->scsi_cmd;
2554 ret = ips_make_passthru(ha, scb->scsi_cmd, scb, intr);
2560 if (scb->scsi_cmd) {
2561 scb->scsi_cmd->result = DID_ERROR << 16;
2562 scsi_done(scb->scsi_cmd);
2565 ips_freescb(ha, scb);
2568 if (scb->scsi_cmd) {
2569 scb->scsi_cmd->result = DID_OK << 16;
2570 scsi_done(scb->scsi_cmd);
2573 ips_freescb(ha, scb);
2584 ret = ips_send_cmd(ha, scb);
2587 ips_putq_scb_head(&ha->scb_activelist, scb);
2593 if (scb->scsi_cmd) {
2594 scb->scsi_cmd->result = DID_ERROR << 16;
2597 ips_freescb(ha, scb);
2600 ips_freescb(ha, scb);
2613 while ((p) && (scb = ips_getscb(ha))) {
2618 ips_freescb(ha, scb);
2632 scb->target_id = SC->device->id;
2633 scb->lun = SC->device->lun;
2634 scb->bus = SC->device->channel;
2635 scb->scsi_cmd = SC;
2636 scb->breakup = 0;
2637 scb->data_len = 0;
2638 scb->callback = ipsintr_done;
2639 scb->timeout = ips_cmd_timeout;
2640 memset(&scb->cmd, 0, 16);
2643 memcpy(scb->cdb, SC->cmnd, SC->cmd_len);
2645 scb->sg_count = scsi_dma_map(SC);
2646 BUG_ON(scb->sg_count < 0);
2647 if (scb->sg_count) {
2651 scb->flags |= IPS_SCB_MAP_SG;
2653 scsi_for_each_sg(SC, sg, scb->sg_count, i) {
2655 (ha, sg_dma_address(sg), scb, i,
2659 scb->dcdb.transfer_length = scb->data_len;
2661 scb->data_busaddr = 0L;
2662 scb->sg_len = 0;
2663 scb->data_len = 0;
2664 scb->dcdb.transfer_length = 0;
2667 scb->dcdb.cmd_attribute =
2668 ips_command_direction[scb->scsi_cmd->cmnd[0]];
2672 if ((scb->scsi_cmd->cmnd[0] == WRITE_BUFFER) &&
2673 (scb->data_len == 0))
2674 scb->dcdb.cmd_attribute = 0;
2676 if (!(scb->dcdb.cmd_attribute & 0x3))
2677 scb->dcdb.transfer_length = 0;
2679 if (scb->data_len >= IPS_MAX_XFER) {
2680 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
2681 scb->dcdb.transfer_length = 0;
2686 ret = ips_send_cmd(ha, scb);
2690 ips_putq_scb_head(&ha->scb_activelist, scb);
2693 if (scb->scsi_cmd) {
2694 scb->scsi_cmd->result = DID_ERROR << 16;
2695 scsi_done(scb->scsi_cmd);
2698 if (scb->bus)
2699 ha->dcdb_active[scb->bus - 1] &=
2700 ~(1 << scb->target_id);
2702 ips_freescb(ha, scb);
2705 if (scb->scsi_cmd)
2706 scsi_done(scb->scsi_cmd);
2708 if (scb->bus)
2709 ha->dcdb_active[scb->bus - 1] &=
2710 ~(1 << scb->target_id);
2712 ips_freescb(ha, scb);
3069 ipsintr_blocking(ips_ha_t * ha, ips_scb_t * scb)
3073 ips_freescb(ha, scb);
3074 if (ha->waitflag && ha->cmd_in_progress == scb->cdb[0]) {
3091 ipsintr_done(ips_ha_t * ha, ips_scb_t * scb)
3095 if (!scb) {
3097 "Spurious interrupt; scb NULL.\n");
3102 if (scb->scsi_cmd == NULL) {
3110 ips_done(ha, scb);
3123 ips_done(ips_ha_t * ha, ips_scb_t * scb)
3129 if (!scb)
3132 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd))) {
3133 ips_cleanup_passthru(ha, scb);
3141 if ((scb->breakup) || (scb->sg_break)) {
3146 scb->data_len = 0;
3148 sg = scsi_sglist(scb->scsi_cmd);
3151 sg_dma_index = scb->breakup;
3152 for (i = 0; i < scb->breakup; i++)
3158 scb, ips_sg_index++,
3161 for (; sg_dma_index < scsi_sg_count(scb->scsi_cmd);
3166 scb, ips_sg_index++,
3171 scb->dcdb.transfer_length = scb->data_len;
3172 scb->dcdb.cmd_attribute |=
3173 ips_command_direction[scb->scsi_cmd->cmnd[0]];
3175 if (!(scb->dcdb.cmd_attribute & 0x3))
3176 scb->dcdb.transfer_length = 0;
3178 if (scb->data_len >= IPS_MAX_XFER) {
3179 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
3180 scb->dcdb.transfer_length = 0;
3183 ret = ips_send_cmd(ha, scb);
3187 if (scb->scsi_cmd) {
3188 scb->scsi_cmd->result = DID_ERROR << 16;
3189 scsi_done(scb->scsi_cmd);
3192 ips_freescb(ha, scb);
3195 if (scb->scsi_cmd) {
3196 scb->scsi_cmd->result = DID_ERROR << 16;
3197 scsi_done(scb->scsi_cmd);
3200 ips_freescb(ha, scb);
3210 if (scb->bus) {
3211 ha->dcdb_active[scb->bus - 1] &= ~(1 << scb->target_id);
3214 scsi_done(scb->scsi_cmd);
3216 ips_freescb(ha, scb);
3229 ips_map_status(ips_ha_t * ha, ips_scb_t * scb, ips_stat_t * sp)
3239 if (scb->bus) {
3243 scb->scsi_cmd->device->channel,
3244 scb->scsi_cmd->device->id, scb->scsi_cmd->device->lun,
3245 scb->basic_status, scb->extended_status,
3246 scb->extended_status ==
3247 IPS_ERR_CKCOND ? scb->dcdb.sense_info[2] & 0xf : 0,
3248 scb->extended_status ==
3249 IPS_ERR_CKCOND ? scb->dcdb.sense_info[12] : 0,
3250 scb->extended_status ==
3251 IPS_ERR_CKCOND ? scb->dcdb.sense_info[13] : 0);
3258 switch (scb->basic_status & IPS_GSC_STATUS_MASK) {
3271 switch (scb->extended_status) {
3273 if (scb->bus)
3279 if ((scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB) ||
3280 (scb->cmd.dcdb.op_code ==
3282 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3286 (uint32_t) scb->dcdb.transfer_length;
3289 if ((scb->bus) && (transfer_len < scb->data_len)) {
3294 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3295 ips_scmd_buf_read(scb->scsi_cmd,
3309 if (scb->bus)
3320 if (scb->bus) {
3321 if ((scb->cmd.dcdb.op_code ==
3323 || (scb->cmd.dcdb.op_code ==
3326 (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3327 memcpy_and_pad(scb->scsi_cmd->sense_buffer,
3332 memcpy_and_pad(scb->scsi_cmd->sense_buffer,
3334 scb->dcdb.sense_info,
3335 sizeof(scb->dcdb.sense_info), 0);
3351 scb->scsi_cmd->result = device_error | (errcode << 16);
3368 ips_send_wait(ips_ha_t * ha, ips_scb_t * scb, int timeout, int intr)
3376 ha->cmd_in_progress = scb->cdb[0];
3378 scb->callback = ipsintr_blocking;
3379 ret = ips_send_cmd(ha, scb);
3434 ips_send_cmd(ips_ha_t * ha, ips_scb_t * scb)
3446 if (!scb->scsi_cmd) {
3449 if (scb->bus > 0) {
3452 if (ha->waitflag && ha->cmd_in_progress == scb->cdb[0])
3457 } else if ((scb->bus == 0) && (!ips_is_passthru(scb->scsi_cmd))) {
3461 switch (scb->scsi_cmd->cmnd[0]) {
3467 scb->scsi_cmd->result = DID_ERROR << 16;
3471 scb->scsi_cmd->result = DID_OK << 16;
3476 if (scb->target_id == IPS_ADAPTER_ID) {
3481 if (scb->scsi_cmd->cmnd[0] == TEST_UNIT_READY)
3482 scb->scsi_cmd->result = DID_OK << 16;
3484 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3510 ips_scmd_buf_write(scb->scsi_cmd,
3514 scb->scsi_cmd->result = DID_OK << 16;
3517 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3518 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3519 scb->cmd.logical_info.reserved = 0;
3520 scb->cmd.logical_info.reserved2 = 0;
3521 scb->data_len = sizeof (IPS_LD_INFO);
3522 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3523 scb->flags = 0;
3524 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3531 ips_reqsen(ha, scb);
3532 scb->scsi_cmd->result = DID_OK << 16;
3537 if (!scb->sg_len) {
3538 scb->cmd.basic_io.op_code =
3539 (scb->scsi_cmd->cmnd[0] ==
3541 scb->cmd.basic_io.enhanced_sg = 0;
3542 scb->cmd.basic_io.sg_addr =
3543 cpu_to_le32(scb->data_busaddr);
3545 scb->cmd.basic_io.op_code =
3546 (scb->scsi_cmd->cmnd[0] ==
3549 scb->cmd.basic_io.enhanced_sg =
3551 scb->cmd.basic_io.sg_addr =
3552 cpu_to_le32(scb->sg_busaddr);
3555 scb->cmd.basic_io.segment_4G = 0;
3556 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3557 scb->cmd.basic_io.log_drv = scb->target_id;
3558 scb->cmd.basic_io.sg_count = scb->sg_len;
3560 if (scb->cmd.basic_io.lba)
3561 le32_add_cpu(&scb->cmd.basic_io.lba,
3562 le16_to_cpu(scb->cmd.basic_io.
3565 scb->cmd.basic_io.lba =
3566 (((scb->scsi_cmd->
3567 cmnd[1] & 0x1f) << 16) | (scb->scsi_cmd->
3569 (scb->scsi_cmd->cmnd[3]));
3571 scb->cmd.basic_io.sector_count =
3572 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3574 if (le16_to_cpu(scb->cmd.basic_io.sector_count) == 0)
3575 scb->cmd.basic_io.sector_count =
3583 if (!scb->sg_len) {
3584 scb->cmd.basic_io.op_code =
3585 (scb->scsi_cmd->cmnd[0] ==
3587 scb->cmd.basic_io.enhanced_sg = 0;
3588 scb->cmd.basic_io.sg_addr =
3589 cpu_to_le32(scb->data_busaddr);
3591 scb->cmd.basic_io.op_code =
3592 (scb->scsi_cmd->cmnd[0] ==
3595 scb->cmd.basic_io.enhanced_sg =
3597 scb->cmd.basic_io.sg_addr =
3598 cpu_to_le32(scb->sg_busaddr);
3601 scb->cmd.basic_io.segment_4G = 0;
3602 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3603 scb->cmd.basic_io.log_drv = scb->target_id;
3604 scb->cmd.basic_io.sg_count = scb->sg_len;
3606 if (scb->cmd.basic_io.lba)
3607 le32_add_cpu(&scb->cmd.basic_io.lba,
3608 le16_to_cpu(scb->cmd.basic_io.
3611 scb->cmd.basic_io.lba =
3612 ((scb->scsi_cmd->cmnd[2] << 24) | (scb->
3616 (scb->scsi_cmd->cmnd[4] << 8) | scb->
3619 scb->cmd.basic_io.sector_count =
3620 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3622 if (cpu_to_le16(scb->cmd.basic_io.sector_count) == 0) {
3628 scb->scsi_cmd->result = DID_OK << 16;
3636 scb->scsi_cmd->result = DID_OK << 16;
3640 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
3641 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3642 scb->cmd.basic_io.segment_4G = 0;
3643 scb->cmd.basic_io.enhanced_sg = 0;
3644 scb->data_len = sizeof (*ha->enq);
3645 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
3650 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3651 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3652 scb->cmd.logical_info.reserved = 0;
3653 scb->cmd.logical_info.reserved2 = 0;
3654 scb->cmd.logical_info.reserved3 = 0;
3655 scb->data_len = sizeof (IPS_LD_INFO);
3656 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3657 scb->flags = 0;
3658 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3670 scb->scsi_cmd->result = DID_OK << 16;
3677 sp = (char *) scb->scsi_cmd->sense_buffer;
3686 scb->scsi_cmd->result = device_error | (DID_OK << 16);
3695 if (scb->bus > 0) {
3699 if (ha->conf->dev[scb->bus - 1][scb->target_id].ucState == 0) {
3700 scb->scsi_cmd->result = DID_NO_CONNECT << 16;
3704 ha->dcdb_active[scb->bus - 1] |= (1 << scb->target_id);
3705 scb->cmd.dcdb.command_id = IPS_COMMAND_ID(ha, scb);
3706 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
3707 (unsigned long) &scb->
3709 (unsigned long) scb);
3710 scb->cmd.dcdb.reserved = 0;
3711 scb->cmd.dcdb.reserved2 = 0;
3712 scb->cmd.dcdb.reserved3 = 0;
3713 scb->cmd.dcdb.segment_4G = 0;
3714 scb->cmd.dcdb.enhanced_sg = 0;
3716 TimeOut = scsi_cmd_to_rq(scb->scsi_cmd)->timeout;
3719 if (!scb->sg_len) {
3720 scb->cmd.dcdb.op_code = IPS_CMD_EXTENDED_DCDB;
3722 scb->cmd.dcdb.op_code =
3724 scb->cmd.dcdb.enhanced_sg =
3728 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb; /* Use Same Data Area as Old DCDB Struct */
3730 ((scb->bus - 1) << 4) | scb->target_id;
3743 tapeDCDB->cdb_length = scb->scsi_cmd->cmd_len;
3745 tapeDCDB->transfer_length = scb->data_len;
3746 if (scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB_SG)
3748 cpu_to_le32(scb->sg_busaddr);
3751 cpu_to_le32(scb->data_busaddr);
3752 tapeDCDB->sg_count = scb->sg_len;
3756 memcpy(tapeDCDB->scsi_cdb, scb->scsi_cmd->cmnd,
3757 scb->scsi_cmd->cmd_len);
3759 if (!scb->sg_len) {
3760 scb->cmd.dcdb.op_code = IPS_CMD_DCDB;
3762 scb->cmd.dcdb.op_code = IPS_CMD_DCDB_SG;
3763 scb->cmd.dcdb.enhanced_sg =
3767 scb->dcdb.device_address =
3768 ((scb->bus - 1) << 4) | scb->target_id;
3769 scb->dcdb.cmd_attribute |= IPS_DISCONNECT_ALLOWED;
3773 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
3775 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
3777 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
3780 scb->dcdb.transfer_length = scb->data_len;
3781 if (scb->dcdb.cmd_attribute & IPS_TRANSFER64K)
3782 scb->dcdb.transfer_length = 0;
3783 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB_SG)
3784 scb->dcdb.buffer_pointer =
3785 cpu_to_le32(scb->sg_busaddr);
3787 scb->dcdb.buffer_pointer =
3788 cpu_to_le32(scb->data_busaddr);
3789 scb->dcdb.cdb_length = scb->scsi_cmd->cmd_len;
3790 scb->dcdb.sense_length = sizeof (scb->dcdb.sense_info);
3791 scb->dcdb.sg_count = scb->sg_len;
3792 scb->dcdb.reserved = 0;
3793 memcpy(scb->dcdb.scsi_cdb, scb->scsi_cmd->cmnd,
3794 scb->scsi_cmd->cmd_len);
3795 scb->dcdb.scsi_status = 0;
3796 scb->dcdb.reserved2[0] = 0;
3797 scb->dcdb.reserved2[1] = 0;
3798 scb->dcdb.reserved2[2] = 0;
3802 return ((*ha->func.issue) (ha, scb));
3817 ips_scb_t *scb;
3826 scb = &ha->scbs[pstatus->fields.command_id];
3827 scb->basic_status = basic_status =
3829 scb->extended_status = ext_status = pstatus->fields.extended_status;
3833 sp->scb_addr = (void *) scb;
3836 ips_removeq_scb(&ha->scb_activelist, scb);
3838 if (!scb->scsi_cmd)
3845 scb->cdb[0],
3846 scb->cmd.basic_io.command_id,
3847 scb->bus, scb->target_id, scb->lun);
3849 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd)))
3858 if (scb->bus == 0) {
3864 scb->cmd.basic_io.op_code,
3868 switch (scb->scsi_cmd->cmnd[0]) {
3881 if (!ips_online(ha, scb)) {
3887 if (ips_online(ha, scb)) {
3888 ips_inquiry(ha, scb);
3895 ips_reqsen(ha, scb);
3907 if (!ips_online(ha, scb)
3908 || !ips_msense(ha, scb)) {
3914 if (ips_online(ha, scb))
3915 ips_rdcap(ha, scb);
3940 scb->scsi_cmd->result = errcode << 16;
3943 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3944 ips_scmd_buf_read(scb->scsi_cmd,
3947 scb->scsi_cmd->result = DID_TIME_OUT << 16;
3951 if (scb->bus == 0) {
3955 scb->cmd.basic_io.op_code, basic_status,
3959 ips_map_status(ha, scb, sp);
3973 ips_online(ips_ha_t * ha, ips_scb_t * scb)
3977 if (scb->target_id >= IPS_MAX_LD)
3980 if ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1) {
3985 if (ha->logical_drive_info->drive_info[scb->target_id].state !=
3987 && ha->logical_drive_info->drive_info[scb->target_id].state !=
3989 && ha->logical_drive_info->drive_info[scb->target_id].state !=
3991 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4008 ips_inquiry(ips_ha_t * ha, ips_scb_t * scb)
4028 ips_scmd_buf_write(scb->scsi_cmd, &inquiry, sizeof (inquiry));
4043 ips_rdcap(ips_ha_t * ha, ips_scb_t * scb)
4049 if (scsi_bufflen(scb->scsi_cmd) < 8)
4055 drive_info[scb->target_id].sector_count) - 1);
4058 ips_scmd_buf_write(scb->scsi_cmd, &cap, sizeof (cap));
4073 ips_msense(ips_ha_t * ha, ips_scb_t * scb)
4082 if (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) > 0x400000 &&
4092 (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) -
4099 switch (scb->scsi_cmd->cmnd[2] & 0x3f) {
4149 ips_scmd_buf_write(scb->scsi_cmd, &mdata, sizeof (mdata));
4164 ips_reqsen(ips_ha_t * ha, ips_scb_t * scb)
4178 ips_scmd_buf_write(scb->scsi_cmd, &reqsen, sizeof (reqsen));
4349 ips_init_scb(ips_ha_t * ha, ips_scb_t * scb)
4355 if (scb == NULL)
4358 sg_list.list = scb->sg_list.list;
4359 cmd_busaddr = scb->scb_busaddr;
4360 sg_busaddr = scb->sg_busaddr;
4362 memset(scb, 0, sizeof (ips_scb_t));
4371 /* set bus address of scb */
4372 scb->scb_busaddr = cmd_busaddr;
4373 scb->sg_busaddr = sg_busaddr;
4374 scb->sg_list.list = sg_list.list;
4377 scb->cmd.basic_io.cccr = cpu_to_le32((uint32_t) IPS_BIT_ILE);
4378 scb->cmd.basic_io.ccsar = cpu_to_le32(ha->adapt->hw_status_start
4396 ips_scb_t *scb;
4400 if ((scb = ha->scb_freelist) == NULL) {
4405 ha->scb_freelist = scb->q_next;
4406 scb->flags = 0;
4407 scb->q_next = NULL;
4409 ips_init_scb(ha, scb);
4411 return (scb);
4426 ips_freescb(ips_ha_t * ha, ips_scb_t * scb)
4430 if (scb->flags & IPS_SCB_MAP_SG)
4431 scsi_dma_unmap(scb->scsi_cmd);
4432 else if (scb->flags & IPS_SCB_MAP_SINGLE)
4433 dma_unmap_single(&ha->pcidev->dev, scb->data_busaddr,
4434 scb->data_len, IPS_DMA_DIR(scb));
4436 /* check to make sure this is not our "special" scb */
4437 if (IPS_COMMAND_ID(ha, scb) < (ha->max_cmds - 1)) {
4438 scb->q_next = ha->scb_freelist;
4439 ha->scb_freelist = scb;
4539 ips_scb_t *scb;
4546 scb = dma_alloc_coherent(&ha->pcidev->dev, sizeof(ips_scb_t),
4548 if (scb) {
4549 memset(scb, 0, sizeof(ips_scb_t));
4550 ips_init_scb(ha, scb);
4551 scb->scb_busaddr = command_dma;
4553 scb->timeout = ips_cmd_timeout;
4554 scb->cdb[0] = IPS_CMD_FLUSH;
4556 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
4557 scb->cmd.flush_cache.command_id = IPS_MAX_CMDS; /* Use an ID that would otherwise not exist */
4558 scb->cmd.flush_cache.state = IPS_NORM_STATE;
4559 scb->cmd.flush_cache.reserved = 0;
4560 scb->cmd.flush_cache.reserved2 = 0;
4561 scb->cmd.flush_cache.reserved3 = 0;
4562 scb->cmd.flush_cache.reserved4 = 0;
4564 ret = ips_send_cmd(ha, scb); /* Send the Flush Command */
4582 dma_free_coherent(&ha->pcidev->dev, sizeof(ips_scb_t), scb, command_dma);
5255 ips_issue_copperhead(ips_ha_t * ha, ips_scb_t * scb)
5262 if (scb->scsi_cmd) {
5266 scb->cdb[0],
5267 scb->cmd.basic_io.command_id,
5268 scb->bus, scb->target_id, scb->lun);
5271 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5293 outl(scb->scb_busaddr, ha->io_addr + IPS_REG_CCSAR);
5309 ips_issue_copperhead_memio(ips_ha_t * ha, ips_scb_t * scb)
5316 if (scb->scsi_cmd) {
5320 scb->cdb[0],
5321 scb->cmd.basic_io.command_id,
5322 scb->bus, scb->target_id, scb->lun);
5325 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5346 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_CCSAR);
5362 ips_issue_i2o(ips_ha_t * ha, ips_scb_t * scb)
5367 if (scb->scsi_cmd) {
5371 scb->cdb[0],
5372 scb->cmd.basic_io.command_id,
5373 scb->bus, scb->target_id, scb->lun);
5376 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5379 outl(scb->scb_busaddr, ha->io_addr + IPS_REG_I2O_INMSGQ);
5394 ips_issue_i2o_memio(ips_ha_t * ha, ips_scb_t * scb)
5399 if (scb->scsi_cmd) {
5403 scb->cdb[0],
5404 scb->cmd.basic_io.command_id,
5405 scb->bus, scb->target_id, scb->lun);
5408 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5411 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_I2O_INMSGQ);
5641 ips_scb_t *scb;
5646 scb = &ha->scbs[ha->max_cmds - 1];
5648 ips_init_scb(ha, scb);
5650 scb->timeout = ips_cmd_timeout;
5651 scb->cdb[0] = IPS_CMD_ENQUIRY;
5653 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
5654 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5655 scb->cmd.basic_io.sg_count = 0;
5656 scb->cmd.basic_io.lba = 0;
5657 scb->cmd.basic_io.sector_count = 0;
5658 scb->cmd.basic_io.log_drv = 0;
5659 scb->data_len = sizeof (*ha->enq);
5660 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
5664 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5666 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5684 ips_scb_t *scb;
5689 scb = &ha->scbs[ha->max_cmds - 1];
5691 ips_init_scb(ha, scb);
5693 scb->timeout = ips_cmd_timeout;
5694 scb->cdb[0] = IPS_CMD_GET_SUBSYS;
5696 scb->cmd.basic_io.op_code = IPS_CMD_GET_SUBSYS;
5697 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5698 scb->cmd.basic_io.sg_count = 0;
5699 scb->cmd.basic_io.lba = 0;
5700 scb->cmd.basic_io.sector_count = 0;
5701 scb->cmd.basic_io.log_drv = 0;
5702 scb->data_len = sizeof (*ha->subsys);
5703 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
5707 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5709 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5728 ips_scb_t *scb;
5738 scb = &ha->scbs[ha->max_cmds - 1];
5740 ips_init_scb(ha, scb);
5742 scb->timeout = ips_cmd_timeout;
5743 scb->cdb[0] = IPS_CMD_READ_CONF;
5745 scb->cmd.basic_io.op_code = IPS_CMD_READ_CONF;
5746 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5747 scb->data_len = sizeof (*ha->conf);
5748 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
5752 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5754 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
5763 if ((scb->basic_status & IPS_GSC_STATUS_MASK) ==
5786 ips_scb_t *scb;
5791 scb = &ha->scbs[ha->max_cmds - 1];
5793 ips_init_scb(ha, scb);
5795 scb->timeout = ips_cmd_timeout;
5796 scb->cdb[0] = IPS_CMD_RW_NVRAM_PAGE;
5798 scb->cmd.nvram.op_code = IPS_CMD_RW_NVRAM_PAGE;
5799 scb->cmd.nvram.command_id = IPS_COMMAND_ID(ha, scb);
5800 scb->cmd.nvram.page = 5;
5801 scb->cmd.nvram.write = write;
5802 scb->cmd.nvram.reserved = 0;
5803 scb->cmd.nvram.reserved2 = 0;
5804 scb->data_len = sizeof (*ha->nvram);
5805 scb->cmd.nvram.buffer_addr = ha->ioctl_busaddr;
5811 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5813 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
5836 ips_scb_t *scb;
5841 scb = &ha->scbs[ha->max_cmds - 1];
5843 ips_init_scb(ha, scb);
5845 scb->timeout = ips_reset_timeout;
5846 scb->cdb[0] = IPS_CMD_CONFIG_SYNC;
5848 scb->cmd.config_sync.op_code = IPS_CMD_CONFIG_SYNC;
5849 scb->cmd.config_sync.command_id = IPS_COMMAND_ID(ha, scb);
5850 scb->cmd.config_sync.channel = 0;
5851 scb->cmd.config_sync.source_target = IPS_POCL;
5852 scb->cmd.config_sync.reserved = 0;
5853 scb->cmd.config_sync.reserved2 = 0;
5854 scb->cmd.config_sync.reserved3 = 0;
5858 ips_send_wait(ha, scb, ips_reset_timeout, intr)) == IPS_FAILURE)
5860 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5864 ips_init_scb(ha, scb);
5866 scb->cdb[0] = IPS_CMD_ERROR_TABLE;
5867 scb->timeout = ips_reset_timeout;
5869 scb->cmd.unlock_stripe.op_code = IPS_CMD_ERROR_TABLE;
5870 scb->cmd.unlock_stripe.command_id = IPS_COMMAND_ID(ha, scb);
5871 scb->cmd.unlock_stripe.log_drv = 0;
5872 scb->cmd.unlock_stripe.control = IPS_CSL;
5873 scb->cmd.unlock_stripe.reserved = 0;
5874 scb->cmd.unlock_stripe.reserved2 = 0;
5875 scb->cmd.unlock_stripe.reserved3 = 0;
5879 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5881 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5899 ips_scb_t *scb;
5903 scb = &ha->scbs[ha->max_cmds - 1];
5905 ips_init_scb(ha, scb);
5907 scb->timeout = ips_cmd_timeout;
5908 scb->cdb[0] = IPS_CMD_FFDC;
5909 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
5910 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
5911 scb->cmd.ffdc.reset_count = ha->reset_count;
5912 scb->cmd.ffdc.reset_type = 0x80;
5915 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
5918 ips_send_wait(ha, scb, ips_cmd_timeout, intr);
5933 ips_scb_t *scb;
5939 scb = &ha->scbs[ha->max_cmds - 1];
5941 ips_init_scb(ha, scb);
5943 scb->timeout = ips_cmd_timeout;
5944 scb->cdb[0] = IPS_CMD_FFDC;
5945 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
5946 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
5947 scb->cmd.ffdc.reset_count = 0;
5948 scb->cmd.ffdc.reset_type = 0;
5951 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
5954 ips_send_wait(ha, scb, ips_cmd_timeout, IPS_FFDC);
5966 ips_fix_ffdc_time(ips_ha_t * ha, ips_scb_t * scb, time64_t current_time)
5974 scb->cmd.ffdc.hour = tm.tm_hour;
5975 scb->cmd.ffdc.minute = tm.tm_min;
5976 scb->cmd.ffdc.second = tm.tm_sec;
5977 scb->cmd.ffdc.yearH = (tm.tm_year + 1900) / 100;
5978 scb->cmd.ffdc.yearL = tm.tm_year % 100;
5979 scb->cmd.ffdc.month = tm.tm_mon + 1;
5980 scb->cmd.ffdc.day = tm.tm_mday;