Lines Matching refs:scb
209 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
210 DMA_NONE == scb->scsi_cmd->sc_data_direction) ? \
212 scb->scsi_cmd->sc_data_direction)
644 ips_scb_t *scb;
667 scb = &ha->scbs[ha->max_cmds - 1];
669 ips_init_scb(ha, scb);
671 scb->timeout = ips_cmd_timeout;
672 scb->cdb[0] = IPS_CMD_FLUSH;
674 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
675 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
676 scb->cmd.flush_cache.state = IPS_NORM_STATE;
677 scb->cmd.flush_cache.reserved = 0;
678 scb->cmd.flush_cache.reserved2 = 0;
679 scb->cmd.flush_cache.reserved3 = 0;
680 scb->cmd.flush_cache.reserved4 = 0;
685 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;
891 scb = &ha->scbs[ha->max_cmds - 1];
893 ips_init_scb(ha, scb);
895 scb->timeout = ips_cmd_timeout;
896 scb->cdb[0] = IPS_CMD_FLUSH;
898 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
899 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
900 scb->cmd.flush_cache.state = IPS_NORM_STATE;
901 scb->cmd.flush_cache.reserved = 0;
902 scb->cmd.flush_cache.reserved2 = 0;
903 scb->cmd.flush_cache.reserved3 = 0;
904 scb->cmd.flush_cache.reserved4 = 0;
907 ret = ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_IORL);
937 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
938 scb->scsi_cmd->result = DID_ERROR << 16;
939 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
940 ips_freescb(ha, scb);
966 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
967 scb->scsi_cmd->result = DID_ERROR << 16;
968 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
969 ips_freescb(ha, scb);
995 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
996 scb->scsi_cmd->result = DID_RESET << 16;
997 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
998 ips_freescb(ha, scb);
1268 ips_scb_t *scb;
1306 scb = (ips_scb_t *) sp->scb_addr;
1312 (*scb->callback) (ha, scb);
1332 ips_scb_t *scb;
1376 scb = (ips_scb_t *) sp->scb_addr;
1382 (*scb->callback) (ha, scb);
1557 ips_make_passthru(ips_ha_t *ha, struct scsi_cmnd *SC, ips_scb_t *scb, int intr)
1627 ret = ips_flash_copperhead(ha, pt, scb);
1632 if (ips_usrcmd(ha, pt, scb))
1651 ips_flash_copperhead(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1658 if (ips_usrcmd(ha, pt, scb))
1665 scb->scsi_cmd->result = DID_OK << 16;
1671 return ips_flash_bios(ha, pt, scb);
1709 return ips_flash_bios(ha, pt, scb);
1711 return ips_flash_firmware(ha, pt, scb);
1722 ips_flash_bios(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1782 /* Fill in a single scb sg_list element from an address */
1787 ips_scb_t * scb, int indx, unsigned int e_len)
1792 if ((scb->data_len + e_len) > ha->max_xfer) {
1793 e_len = ha->max_xfer - scb->data_len;
1794 scb->breakup = indx;
1795 ++scb->sg_break;
1798 scb->breakup = 0;
1799 scb->sg_break = 0;
1802 scb->sg_list.enh_list[indx].address_lo =
1804 scb->sg_list.enh_list[indx].address_hi =
1806 scb->sg_list.enh_list[indx].length = cpu_to_le32(e_len);
1808 scb->sg_list.std_list[indx].address =
1810 scb->sg_list.std_list[indx].length = cpu_to_le32(e_len);
1813 ++scb->sg_len;
1814 scb->data_len += e_len;
1824 ips_flash_firmware(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1841 sg_list.list = scb->sg_list.list;
1842 cmd_busaddr = scb->scb_busaddr;
1844 memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1846 scb->sg_list.list = sg_list.list;
1847 scb->scb_busaddr = cmd_busaddr;
1848 scb->bus = scb->scsi_cmd->device->channel;
1849 scb->target_id = scb->scsi_cmd->device->id;
1850 scb->lun = scb->scsi_cmd->device->lun;
1851 scb->sg_len = 0;
1852 scb->data_len = 0;
1853 scb->flags = 0;
1854 scb->op_code = 0;
1855 scb->callback = ipsintr_done;
1856 scb->timeout = ips_cmd_timeout;
1858 scb->data_len = ha->flash_datasize;
1859 scb->data_busaddr =
1860 dma_map_single(&ha->pcidev->dev, ha->flash_data, scb->data_len,
1861 IPS_DMA_DIR(scb));
1862 scb->flags |= IPS_SCB_MAP_SINGLE;
1863 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
1864 scb->cmd.flashfw.buffer_addr = cpu_to_le32(scb->data_busaddr);
1866 scb->timeout = pt->TimeOut;
1867 scb->scsi_cmd->result = DID_OK << 16;
1897 ips_usrcmd(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1904 if ((!scb) || (!pt) || (!ha))
1908 sg_list.list = scb->sg_list.list;
1909 cmd_busaddr = scb->scb_busaddr;
1911 memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1912 memcpy(&scb->dcdb, &pt->CoppCP.dcdb, sizeof (IPS_DCDB_TABLE));
1915 scb->sg_list.list = sg_list.list;
1916 scb->scb_busaddr = cmd_busaddr;
1917 scb->bus = scb->scsi_cmd->device->channel;
1918 scb->target_id = scb->scsi_cmd->device->id;
1919 scb->lun = scb->scsi_cmd->device->lun;
1920 scb->sg_len = 0;
1921 scb->data_len = 0;
1922 scb->flags = 0;
1923 scb->op_code = 0;
1924 scb->callback = ipsintr_done;
1925 scb->timeout = ips_cmd_timeout;
1926 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
1929 if ((scb->cmd.basic_io.op_code == IPS_CMD_READ_SG) ||
1930 (scb->cmd.basic_io.op_code == IPS_CMD_WRITE_SG) ||
1931 (scb->cmd.basic_io.op_code == IPS_CMD_DCDB_SG))
1935 scb->data_len = pt->CmdBSize;
1936 scb->data_busaddr = ha->ioctl_busaddr + sizeof (ips_passthru_t);
1938 scb->data_busaddr = 0L;
1941 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
1942 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
1943 (unsigned long) &scb->
1945 (unsigned long) scb);
1948 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
1949 scb->dcdb.buffer_pointer =
1950 cpu_to_le32(scb->data_busaddr);
1952 scb->cmd.basic_io.sg_addr =
1953 cpu_to_le32(scb->data_busaddr);
1958 scb->timeout = pt->TimeOut;
1961 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10;
1963 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60;
1965 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;
1969 scb->scsi_cmd->result = DID_OK << 16;
1985 ips_cleanup_passthru(ips_ha_t * ha, ips_scb_t * scb)
1991 if ((!scb) || (!scb->scsi_cmd) || (!scsi_sglist(scb->scsi_cmd))) {
2000 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB) /* Copy DCDB Back to Caller's Area */
2001 memcpy(&pt->CoppCP.dcdb, &scb->dcdb, sizeof (IPS_DCDB_TABLE));
2003 pt->BasicStatus = scb->basic_status;
2004 pt->ExtendedStatus = scb->extended_status;
2008 (scb->cmd.flashfw.op_code == IPS_CMD_DOWNLOAD ||
2009 scb->cmd.flashfw.op_code == IPS_CMD_RW_BIOSFW))
2012 ips_scmd_buf_write(scb->scsi_cmd, ha->ioctl_data, ha->ioctl_datasize);
2230 ips_scb_t *scb;
2329 scb = &ha->scbs[ha->max_cmds - 1];
2331 ips_init_scb(ha, scb);
2333 scb->timeout = ips_cmd_timeout;
2334 scb->cdb[0] = IPS_CMD_RW_BIOSFW;
2336 scb->cmd.flashfw.op_code = IPS_CMD_RW_BIOSFW;
2337 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
2338 scb->cmd.flashfw.type = 1;
2339 scb->cmd.flashfw.direction = 0;
2340 scb->cmd.flashfw.count = cpu_to_le32(0x800);
2341 scb->cmd.flashfw.total_packets = 1;
2342 scb->cmd.flashfw.packet_num = 0;
2343 scb->data_len = 0x1000;
2344 scb->cmd.flashfw.buffer_addr = ha->ioctl_busaddr;
2348 ips_send_wait(ha, scb, ips_cmd_timeout,
2351 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
2524 ips_scb_t *scb;
2560 (ha->copp_waitlist.head) && (scb = ips_getscb(ha))) {
2566 scb->scsi_cmd = item->scsi_cmd;
2569 ret = ips_make_passthru(ha, scb->scsi_cmd, scb, intr);
2575 if (scb->scsi_cmd) {
2576 scb->scsi_cmd->result = DID_ERROR << 16;
2577 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2580 ips_freescb(ha, scb);
2583 if (scb->scsi_cmd) {
2584 scb->scsi_cmd->result = DID_OK << 16;
2585 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2588 ips_freescb(ha, scb);
2599 ret = ips_send_cmd(ha, scb);
2602 ips_putq_scb_head(&ha->scb_activelist, scb);
2608 if (scb->scsi_cmd) {
2609 scb->scsi_cmd->result = DID_ERROR << 16;
2612 ips_freescb(ha, scb);
2615 ips_freescb(ha, scb);
2628 while ((p) && (scb = ips_getscb(ha))) {
2633 ips_freescb(ha, scb);
2647 scb->target_id = SC->device->id;
2648 scb->lun = SC->device->lun;
2649 scb->bus = SC->device->channel;
2650 scb->scsi_cmd = SC;
2651 scb->breakup = 0;
2652 scb->data_len = 0;
2653 scb->callback = ipsintr_done;
2654 scb->timeout = ips_cmd_timeout;
2655 memset(&scb->cmd, 0, 16);
2658 memcpy(scb->cdb, SC->cmnd, SC->cmd_len);
2660 scb->sg_count = scsi_dma_map(SC);
2661 BUG_ON(scb->sg_count < 0);
2662 if (scb->sg_count) {
2666 scb->flags |= IPS_SCB_MAP_SG;
2668 scsi_for_each_sg(SC, sg, scb->sg_count, i) {
2670 (ha, sg_dma_address(sg), scb, i,
2674 scb->dcdb.transfer_length = scb->data_len;
2676 scb->data_busaddr = 0L;
2677 scb->sg_len = 0;
2678 scb->data_len = 0;
2679 scb->dcdb.transfer_length = 0;
2682 scb->dcdb.cmd_attribute =
2683 ips_command_direction[scb->scsi_cmd->cmnd[0]];
2687 if ((scb->scsi_cmd->cmnd[0] == WRITE_BUFFER) &&
2688 (scb->data_len == 0))
2689 scb->dcdb.cmd_attribute = 0;
2691 if (!(scb->dcdb.cmd_attribute & 0x3))
2692 scb->dcdb.transfer_length = 0;
2694 if (scb->data_len >= IPS_MAX_XFER) {
2695 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
2696 scb->dcdb.transfer_length = 0;
2701 ret = ips_send_cmd(ha, scb);
2705 ips_putq_scb_head(&ha->scb_activelist, scb);
2708 if (scb->scsi_cmd) {
2709 scb->scsi_cmd->result = DID_ERROR << 16;
2710 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2713 if (scb->bus)
2714 ha->dcdb_active[scb->bus - 1] &=
2715 ~(1 << scb->target_id);
2717 ips_freescb(ha, scb);
2720 if (scb->scsi_cmd)
2721 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2723 if (scb->bus)
2724 ha->dcdb_active[scb->bus - 1] &=
2725 ~(1 << scb->target_id);
2727 ips_freescb(ha, scb);
3084 ipsintr_blocking(ips_ha_t * ha, ips_scb_t * scb)
3088 ips_freescb(ha, scb);
3089 if ((ha->waitflag == TRUE) && (ha->cmd_in_progress == scb->cdb[0])) {
3106 ipsintr_done(ips_ha_t * ha, ips_scb_t * scb)
3110 if (!scb) {
3112 "Spurious interrupt; scb NULL.\n");
3117 if (scb->scsi_cmd == NULL) {
3125 ips_done(ha, scb);
3138 ips_done(ips_ha_t * ha, ips_scb_t * scb)
3144 if (!scb)
3147 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd))) {
3148 ips_cleanup_passthru(ha, scb);
3156 if ((scb->breakup) || (scb->sg_break)) {
3161 scb->data_len = 0;
3163 sg = scsi_sglist(scb->scsi_cmd);
3166 sg_dma_index = scb->breakup;
3167 for (i = 0; i < scb->breakup; i++)
3173 scb, ips_sg_index++,
3176 for (; sg_dma_index < scsi_sg_count(scb->scsi_cmd);
3181 scb, ips_sg_index++,
3186 scb->dcdb.transfer_length = scb->data_len;
3187 scb->dcdb.cmd_attribute |=
3188 ips_command_direction[scb->scsi_cmd->cmnd[0]];
3190 if (!(scb->dcdb.cmd_attribute & 0x3))
3191 scb->dcdb.transfer_length = 0;
3193 if (scb->data_len >= IPS_MAX_XFER) {
3194 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
3195 scb->dcdb.transfer_length = 0;
3198 ret = ips_send_cmd(ha, scb);
3202 if (scb->scsi_cmd) {
3203 scb->scsi_cmd->result = DID_ERROR << 16;
3204 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3207 ips_freescb(ha, scb);
3210 if (scb->scsi_cmd) {
3211 scb->scsi_cmd->result = DID_ERROR << 16;
3212 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3215 ips_freescb(ha, scb);
3225 if (scb->bus) {
3226 ha->dcdb_active[scb->bus - 1] &= ~(1 << scb->target_id);
3229 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3231 ips_freescb(ha, scb);
3244 ips_map_status(ips_ha_t * ha, ips_scb_t * scb, ips_stat_t * sp)
3254 if (scb->bus) {
3258 scb->scsi_cmd->device->channel,
3259 scb->scsi_cmd->device->id, scb->scsi_cmd->device->lun,
3260 scb->basic_status, scb->extended_status,
3261 scb->extended_status ==
3262 IPS_ERR_CKCOND ? scb->dcdb.sense_info[2] & 0xf : 0,
3263 scb->extended_status ==
3264 IPS_ERR_CKCOND ? scb->dcdb.sense_info[12] : 0,
3265 scb->extended_status ==
3266 IPS_ERR_CKCOND ? scb->dcdb.sense_info[13] : 0);
3273 switch (scb->basic_status & IPS_GSC_STATUS_MASK) {
3286 switch (scb->extended_status) {
3288 if (scb->bus)
3294 if ((scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB) ||
3295 (scb->cmd.dcdb.op_code ==
3297 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3301 (uint32_t) scb->dcdb.transfer_length;
3304 if ((scb->bus) && (transfer_len < scb->data_len)) {
3309 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3310 ips_scmd_buf_read(scb->scsi_cmd,
3324 if (scb->bus)
3335 if (scb->bus) {
3336 if ((scb->cmd.dcdb.op_code ==
3338 || (scb->cmd.dcdb.op_code ==
3341 (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3342 memcpy(scb->scsi_cmd->sense_buffer,
3346 memcpy(scb->scsi_cmd->sense_buffer,
3347 scb->dcdb.sense_info,
3364 scb->scsi_cmd->result = device_error | (errcode << 16);
3381 ips_send_wait(ips_ha_t * ha, ips_scb_t * scb, int timeout, int intr)
3389 ha->cmd_in_progress = scb->cdb[0];
3391 scb->callback = ipsintr_blocking;
3392 ret = ips_send_cmd(ha, scb);
3447 ips_send_cmd(ips_ha_t * ha, ips_scb_t * scb)
3459 if (!scb->scsi_cmd) {
3462 if (scb->bus > 0) {
3466 (ha->cmd_in_progress == scb->cdb[0])) {
3472 } else if ((scb->bus == 0) && (!ips_is_passthru(scb->scsi_cmd))) {
3476 switch (scb->scsi_cmd->cmnd[0]) {
3482 scb->scsi_cmd->result = DID_ERROR << 16;
3486 scb->scsi_cmd->result = DID_OK << 16;
3491 if (scb->target_id == IPS_ADAPTER_ID) {
3496 if (scb->scsi_cmd->cmnd[0] == TEST_UNIT_READY)
3497 scb->scsi_cmd->result = DID_OK << 16;
3499 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3525 ips_scmd_buf_write(scb->scsi_cmd,
3529 scb->scsi_cmd->result = DID_OK << 16;
3532 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3533 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3534 scb->cmd.logical_info.reserved = 0;
3535 scb->cmd.logical_info.reserved2 = 0;
3536 scb->data_len = sizeof (IPS_LD_INFO);
3537 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3538 scb->flags = 0;
3539 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3546 ips_reqsen(ha, scb);
3547 scb->scsi_cmd->result = DID_OK << 16;
3552 if (!scb->sg_len) {
3553 scb->cmd.basic_io.op_code =
3554 (scb->scsi_cmd->cmnd[0] ==
3556 scb->cmd.basic_io.enhanced_sg = 0;
3557 scb->cmd.basic_io.sg_addr =
3558 cpu_to_le32(scb->data_busaddr);
3560 scb->cmd.basic_io.op_code =
3561 (scb->scsi_cmd->cmnd[0] ==
3564 scb->cmd.basic_io.enhanced_sg =
3566 scb->cmd.basic_io.sg_addr =
3567 cpu_to_le32(scb->sg_busaddr);
3570 scb->cmd.basic_io.segment_4G = 0;
3571 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3572 scb->cmd.basic_io.log_drv = scb->target_id;
3573 scb->cmd.basic_io.sg_count = scb->sg_len;
3575 if (scb->cmd.basic_io.lba)
3576 le32_add_cpu(&scb->cmd.basic_io.lba,
3577 le16_to_cpu(scb->cmd.basic_io.
3580 scb->cmd.basic_io.lba =
3581 (((scb->scsi_cmd->
3582 cmnd[1] & 0x1f) << 16) | (scb->scsi_cmd->
3584 (scb->scsi_cmd->cmnd[3]));
3586 scb->cmd.basic_io.sector_count =
3587 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3589 if (le16_to_cpu(scb->cmd.basic_io.sector_count) == 0)
3590 scb->cmd.basic_io.sector_count =
3598 if (!scb->sg_len) {
3599 scb->cmd.basic_io.op_code =
3600 (scb->scsi_cmd->cmnd[0] ==
3602 scb->cmd.basic_io.enhanced_sg = 0;
3603 scb->cmd.basic_io.sg_addr =
3604 cpu_to_le32(scb->data_busaddr);
3606 scb->cmd.basic_io.op_code =
3607 (scb->scsi_cmd->cmnd[0] ==
3610 scb->cmd.basic_io.enhanced_sg =
3612 scb->cmd.basic_io.sg_addr =
3613 cpu_to_le32(scb->sg_busaddr);
3616 scb->cmd.basic_io.segment_4G = 0;
3617 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3618 scb->cmd.basic_io.log_drv = scb->target_id;
3619 scb->cmd.basic_io.sg_count = scb->sg_len;
3621 if (scb->cmd.basic_io.lba)
3622 le32_add_cpu(&scb->cmd.basic_io.lba,
3623 le16_to_cpu(scb->cmd.basic_io.
3626 scb->cmd.basic_io.lba =
3627 ((scb->scsi_cmd->cmnd[2] << 24) | (scb->
3631 (scb->scsi_cmd->cmnd[4] << 8) | scb->
3634 scb->cmd.basic_io.sector_count =
3635 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3637 if (cpu_to_le16(scb->cmd.basic_io.sector_count) == 0) {
3643 scb->scsi_cmd->result = DID_OK << 16;
3651 scb->scsi_cmd->result = DID_OK << 16;
3655 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
3656 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3657 scb->cmd.basic_io.segment_4G = 0;
3658 scb->cmd.basic_io.enhanced_sg = 0;
3659 scb->data_len = sizeof (*ha->enq);
3660 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
3665 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3666 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3667 scb->cmd.logical_info.reserved = 0;
3668 scb->cmd.logical_info.reserved2 = 0;
3669 scb->cmd.logical_info.reserved3 = 0;
3670 scb->data_len = sizeof (IPS_LD_INFO);
3671 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3672 scb->flags = 0;
3673 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3685 scb->scsi_cmd->result = DID_OK << 16;
3692 sp = (char *) scb->scsi_cmd->sense_buffer;
3701 scb->scsi_cmd->result = device_error | (DID_OK << 16);
3710 if (scb->bus > 0) {
3714 if (ha->conf->dev[scb->bus - 1][scb->target_id].ucState == 0) {
3715 scb->scsi_cmd->result = DID_NO_CONNECT << 16;
3719 ha->dcdb_active[scb->bus - 1] |= (1 << scb->target_id);
3720 scb->cmd.dcdb.command_id = IPS_COMMAND_ID(ha, scb);
3721 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
3722 (unsigned long) &scb->
3724 (unsigned long) scb);
3725 scb->cmd.dcdb.reserved = 0;
3726 scb->cmd.dcdb.reserved2 = 0;
3727 scb->cmd.dcdb.reserved3 = 0;
3728 scb->cmd.dcdb.segment_4G = 0;
3729 scb->cmd.dcdb.enhanced_sg = 0;
3731 TimeOut = scb->scsi_cmd->request->timeout;
3734 if (!scb->sg_len) {
3735 scb->cmd.dcdb.op_code = IPS_CMD_EXTENDED_DCDB;
3737 scb->cmd.dcdb.op_code =
3739 scb->cmd.dcdb.enhanced_sg =
3743 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb; /* Use Same Data Area as Old DCDB Struct */
3745 ((scb->bus - 1) << 4) | scb->target_id;
3758 tapeDCDB->cdb_length = scb->scsi_cmd->cmd_len;
3760 tapeDCDB->transfer_length = scb->data_len;
3761 if (scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB_SG)
3763 cpu_to_le32(scb->sg_busaddr);
3766 cpu_to_le32(scb->data_busaddr);
3767 tapeDCDB->sg_count = scb->sg_len;
3771 memcpy(tapeDCDB->scsi_cdb, scb->scsi_cmd->cmnd,
3772 scb->scsi_cmd->cmd_len);
3774 if (!scb->sg_len) {
3775 scb->cmd.dcdb.op_code = IPS_CMD_DCDB;
3777 scb->cmd.dcdb.op_code = IPS_CMD_DCDB_SG;
3778 scb->cmd.dcdb.enhanced_sg =
3782 scb->dcdb.device_address =
3783 ((scb->bus - 1) << 4) | scb->target_id;
3784 scb->dcdb.cmd_attribute |= IPS_DISCONNECT_ALLOWED;
3788 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
3790 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
3792 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
3795 scb->dcdb.transfer_length = scb->data_len;
3796 if (scb->dcdb.cmd_attribute & IPS_TRANSFER64K)
3797 scb->dcdb.transfer_length = 0;
3798 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB_SG)
3799 scb->dcdb.buffer_pointer =
3800 cpu_to_le32(scb->sg_busaddr);
3802 scb->dcdb.buffer_pointer =
3803 cpu_to_le32(scb->data_busaddr);
3804 scb->dcdb.cdb_length = scb->scsi_cmd->cmd_len;
3805 scb->dcdb.sense_length = sizeof (scb->dcdb.sense_info);
3806 scb->dcdb.sg_count = scb->sg_len;
3807 scb->dcdb.reserved = 0;
3808 memcpy(scb->dcdb.scsi_cdb, scb->scsi_cmd->cmnd,
3809 scb->scsi_cmd->cmd_len);
3810 scb->dcdb.scsi_status = 0;
3811 scb->dcdb.reserved2[0] = 0;
3812 scb->dcdb.reserved2[1] = 0;
3813 scb->dcdb.reserved2[2] = 0;
3817 return ((*ha->func.issue) (ha, scb));
3832 ips_scb_t *scb;
3841 scb = &ha->scbs[pstatus->fields.command_id];
3842 scb->basic_status = basic_status =
3844 scb->extended_status = ext_status = pstatus->fields.extended_status;
3848 sp->scb_addr = (void *) scb;
3851 ips_removeq_scb(&ha->scb_activelist, scb);
3853 if (!scb->scsi_cmd)
3860 scb->cdb[0],
3861 scb->cmd.basic_io.command_id,
3862 scb->bus, scb->target_id, scb->lun);
3864 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd)))
3873 if (scb->bus == 0) {
3879 scb->cmd.basic_io.op_code,
3883 switch (scb->scsi_cmd->cmnd[0]) {
3896 if (!ips_online(ha, scb)) {
3902 if (ips_online(ha, scb)) {
3903 ips_inquiry(ha, scb);
3910 ips_reqsen(ha, scb);
3922 if (!ips_online(ha, scb)
3923 || !ips_msense(ha, scb)) {
3929 if (ips_online(ha, scb))
3930 ips_rdcap(ha, scb);
3955 scb->scsi_cmd->result = errcode << 16;
3958 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3959 ips_scmd_buf_read(scb->scsi_cmd,
3962 scb->scsi_cmd->result = DID_TIME_OUT << 16;
3966 if (scb->bus == 0) {
3970 scb->cmd.basic_io.op_code, basic_status,
3974 ips_map_status(ha, scb, sp);
3988 ips_online(ips_ha_t * ha, ips_scb_t * scb)
3992 if (scb->target_id >= IPS_MAX_LD)
3995 if ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1) {
4000 if (ha->logical_drive_info->drive_info[scb->target_id].state !=
4002 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4004 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4006 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4023 ips_inquiry(ips_ha_t * ha, ips_scb_t * scb)
4043 ips_scmd_buf_write(scb->scsi_cmd, &inquiry, sizeof (inquiry));
4058 ips_rdcap(ips_ha_t * ha, ips_scb_t * scb)
4064 if (scsi_bufflen(scb->scsi_cmd) < 8)
4070 drive_info[scb->target_id].sector_count) - 1);
4073 ips_scmd_buf_write(scb->scsi_cmd, &cap, sizeof (cap));
4088 ips_msense(ips_ha_t * ha, ips_scb_t * scb)
4097 if (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) > 0x400000 &&
4107 (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) -
4114 switch (scb->scsi_cmd->cmnd[2] & 0x3f) {
4164 ips_scmd_buf_write(scb->scsi_cmd, &mdata, sizeof (mdata));
4179 ips_reqsen(ips_ha_t * ha, ips_scb_t * scb)
4193 ips_scmd_buf_write(scb->scsi_cmd, &reqsen, sizeof (reqsen));
4364 ips_init_scb(ips_ha_t * ha, ips_scb_t * scb)
4370 if (scb == NULL)
4373 sg_list.list = scb->sg_list.list;
4374 cmd_busaddr = scb->scb_busaddr;
4375 sg_busaddr = scb->sg_busaddr;
4377 memset(scb, 0, sizeof (ips_scb_t));
4386 /* set bus address of scb */
4387 scb->scb_busaddr = cmd_busaddr;
4388 scb->sg_busaddr = sg_busaddr;
4389 scb->sg_list.list = sg_list.list;
4392 scb->cmd.basic_io.cccr = cpu_to_le32((uint32_t) IPS_BIT_ILE);
4393 scb->cmd.basic_io.ccsar = cpu_to_le32(ha->adapt->hw_status_start
4411 ips_scb_t *scb;
4415 if ((scb = ha->scb_freelist) == NULL) {
4420 ha->scb_freelist = scb->q_next;
4421 scb->flags = 0;
4422 scb->q_next = NULL;
4424 ips_init_scb(ha, scb);
4426 return (scb);
4441 ips_freescb(ips_ha_t * ha, ips_scb_t * scb)
4445 if (scb->flags & IPS_SCB_MAP_SG)
4446 scsi_dma_unmap(scb->scsi_cmd);
4447 else if (scb->flags & IPS_SCB_MAP_SINGLE)
4448 dma_unmap_single(&ha->pcidev->dev, scb->data_busaddr,
4449 scb->data_len, IPS_DMA_DIR(scb));
4451 /* check to make sure this is not our "special" scb */
4452 if (IPS_COMMAND_ID(ha, scb) < (ha->max_cmds - 1)) {
4453 scb->q_next = ha->scb_freelist;
4454 ha->scb_freelist = scb;
4554 ips_scb_t *scb;
4561 scb = dma_alloc_coherent(&ha->pcidev->dev, sizeof(ips_scb_t),
4563 if (scb) {
4564 memset(scb, 0, sizeof(ips_scb_t));
4565 ips_init_scb(ha, scb);
4566 scb->scb_busaddr = command_dma;
4568 scb->timeout = ips_cmd_timeout;
4569 scb->cdb[0] = IPS_CMD_FLUSH;
4571 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
4572 scb->cmd.flush_cache.command_id = IPS_MAX_CMDS; /* Use an ID that would otherwise not exist */
4573 scb->cmd.flush_cache.state = IPS_NORM_STATE;
4574 scb->cmd.flush_cache.reserved = 0;
4575 scb->cmd.flush_cache.reserved2 = 0;
4576 scb->cmd.flush_cache.reserved3 = 0;
4577 scb->cmd.flush_cache.reserved4 = 0;
4579 ret = ips_send_cmd(ha, scb); /* Send the Flush Command */
4597 dma_free_coherent(&ha->pcidev->dev, sizeof(ips_scb_t), scb, command_dma);
5270 ips_issue_copperhead(ips_ha_t * ha, ips_scb_t * scb)
5277 if (scb->scsi_cmd) {
5281 scb->cdb[0],
5282 scb->cmd.basic_io.command_id,
5283 scb->bus, scb->target_id, scb->lun);
5286 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5308 outl(scb->scb_busaddr, ha->io_addr + IPS_REG_CCSAR);
5324 ips_issue_copperhead_memio(ips_ha_t * ha, ips_scb_t * scb)
5331 if (scb->scsi_cmd) {
5335 scb->cdb[0],
5336 scb->cmd.basic_io.command_id,
5337 scb->bus, scb->target_id, scb->lun);
5340 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5361 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_CCSAR);
5377 ips_issue_i2o(ips_ha_t * ha, ips_scb_t * scb)
5382 if (scb->scsi_cmd) {
5386 scb->cdb[0],
5387 scb->cmd.basic_io.command_id,
5388 scb->bus, scb->target_id, scb->lun);
5391 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5394 outl(scb->scb_busaddr, ha->io_addr + IPS_REG_I2O_INMSGQ);
5409 ips_issue_i2o_memio(ips_ha_t * ha, ips_scb_t * scb)
5414 if (scb->scsi_cmd) {
5418 scb->cdb[0],
5419 scb->cmd.basic_io.command_id,
5420 scb->bus, scb->target_id, scb->lun);
5423 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5426 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_I2O_INMSGQ);
5656 ips_scb_t *scb;
5661 scb = &ha->scbs[ha->max_cmds - 1];
5663 ips_init_scb(ha, scb);
5665 scb->timeout = ips_cmd_timeout;
5666 scb->cdb[0] = IPS_CMD_ENQUIRY;
5668 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
5669 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5670 scb->cmd.basic_io.sg_count = 0;
5671 scb->cmd.basic_io.lba = 0;
5672 scb->cmd.basic_io.sector_count = 0;
5673 scb->cmd.basic_io.log_drv = 0;
5674 scb->data_len = sizeof (*ha->enq);
5675 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
5679 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5681 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5699 ips_scb_t *scb;
5704 scb = &ha->scbs[ha->max_cmds - 1];
5706 ips_init_scb(ha, scb);
5708 scb->timeout = ips_cmd_timeout;
5709 scb->cdb[0] = IPS_CMD_GET_SUBSYS;
5711 scb->cmd.basic_io.op_code = IPS_CMD_GET_SUBSYS;
5712 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5713 scb->cmd.basic_io.sg_count = 0;
5714 scb->cmd.basic_io.lba = 0;
5715 scb->cmd.basic_io.sector_count = 0;
5716 scb->cmd.basic_io.log_drv = 0;
5717 scb->data_len = sizeof (*ha->subsys);
5718 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
5722 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5724 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5743 ips_scb_t *scb;
5753 scb = &ha->scbs[ha->max_cmds - 1];
5755 ips_init_scb(ha, scb);
5757 scb->timeout = ips_cmd_timeout;
5758 scb->cdb[0] = IPS_CMD_READ_CONF;
5760 scb->cmd.basic_io.op_code = IPS_CMD_READ_CONF;
5761 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5762 scb->data_len = sizeof (*ha->conf);
5763 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
5767 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5769 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
5778 if ((scb->basic_status & IPS_GSC_STATUS_MASK) ==
5801 ips_scb_t *scb;
5806 scb = &ha->scbs[ha->max_cmds - 1];
5808 ips_init_scb(ha, scb);
5810 scb->timeout = ips_cmd_timeout;
5811 scb->cdb[0] = IPS_CMD_RW_NVRAM_PAGE;
5813 scb->cmd.nvram.op_code = IPS_CMD_RW_NVRAM_PAGE;
5814 scb->cmd.nvram.command_id = IPS_COMMAND_ID(ha, scb);
5815 scb->cmd.nvram.page = 5;
5816 scb->cmd.nvram.write = write;
5817 scb->cmd.nvram.reserved = 0;
5818 scb->cmd.nvram.reserved2 = 0;
5819 scb->data_len = sizeof (*ha->nvram);
5820 scb->cmd.nvram.buffer_addr = ha->ioctl_busaddr;
5826 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5828 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
5851 ips_scb_t *scb;
5856 scb = &ha->scbs[ha->max_cmds - 1];
5858 ips_init_scb(ha, scb);
5860 scb->timeout = ips_reset_timeout;
5861 scb->cdb[0] = IPS_CMD_CONFIG_SYNC;
5863 scb->cmd.config_sync.op_code = IPS_CMD_CONFIG_SYNC;
5864 scb->cmd.config_sync.command_id = IPS_COMMAND_ID(ha, scb);
5865 scb->cmd.config_sync.channel = 0;
5866 scb->cmd.config_sync.source_target = IPS_POCL;
5867 scb->cmd.config_sync.reserved = 0;
5868 scb->cmd.config_sync.reserved2 = 0;
5869 scb->cmd.config_sync.reserved3 = 0;
5873 ips_send_wait(ha, scb, ips_reset_timeout, intr)) == IPS_FAILURE)
5875 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5879 ips_init_scb(ha, scb);
5881 scb->cdb[0] = IPS_CMD_ERROR_TABLE;
5882 scb->timeout = ips_reset_timeout;
5884 scb->cmd.unlock_stripe.op_code = IPS_CMD_ERROR_TABLE;
5885 scb->cmd.unlock_stripe.command_id = IPS_COMMAND_ID(ha, scb);
5886 scb->cmd.unlock_stripe.log_drv = 0;
5887 scb->cmd.unlock_stripe.control = IPS_CSL;
5888 scb->cmd.unlock_stripe.reserved = 0;
5889 scb->cmd.unlock_stripe.reserved2 = 0;
5890 scb->cmd.unlock_stripe.reserved3 = 0;
5894 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5896 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5914 ips_scb_t *scb;
5918 scb = &ha->scbs[ha->max_cmds - 1];
5920 ips_init_scb(ha, scb);
5922 scb->timeout = ips_cmd_timeout;
5923 scb->cdb[0] = IPS_CMD_FFDC;
5924 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
5925 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
5926 scb->cmd.ffdc.reset_count = ha->reset_count;
5927 scb->cmd.ffdc.reset_type = 0x80;
5930 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
5933 ips_send_wait(ha, scb, ips_cmd_timeout, intr);
5948 ips_scb_t *scb;
5954 scb = &ha->scbs[ha->max_cmds - 1];
5956 ips_init_scb(ha, scb);
5958 scb->timeout = ips_cmd_timeout;
5959 scb->cdb[0] = IPS_CMD_FFDC;
5960 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
5961 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
5962 scb->cmd.ffdc.reset_count = 0;
5963 scb->cmd.ffdc.reset_type = 0;
5966 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
5969 ips_send_wait(ha, scb, ips_cmd_timeout, IPS_FFDC);
5981 ips_fix_ffdc_time(ips_ha_t * ha, ips_scb_t * scb, time64_t current_time)
5989 scb->cmd.ffdc.hour = tm.tm_hour;
5990 scb->cmd.ffdc.minute = tm.tm_min;
5991 scb->cmd.ffdc.second = tm.tm_sec;
5992 scb->cmd.ffdc.yearH = (tm.tm_year + 1900) / 100;
5993 scb->cmd.ffdc.yearL = tm.tm_year % 100;
5994 scb->cmd.ffdc.month = tm.tm_mon + 1;
5995 scb->cmd.ffdc.day = tm.tm_mday;