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;
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 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 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 scsi_done(scb->scsi_cmd);
998 ips_freescb(ha, scb);
1272 ips_scb_t *scb;
1310 scb = (ips_scb_t *) sp->scb_addr;
1316 (*scb->callback) (ha, scb);
1336 ips_scb_t *scb;
1380 scb = (ips_scb_t *) sp->scb_addr;
1386 (*scb->callback) (ha, scb);
1560 ips_make_passthru(ips_ha_t *ha, struct scsi_cmnd *SC, ips_scb_t *scb, int intr)
1630 ret = ips_flash_copperhead(ha, pt, scb);
1635 if (ips_usrcmd(ha, pt, scb))
1654 ips_flash_copperhead(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1661 if (ips_usrcmd(ha, pt, scb))
1668 scb->scsi_cmd->result = DID_OK << 16;
1674 return ips_flash_bios(ha, pt, scb);
1712 return ips_flash_bios(ha, pt, scb);
1714 return ips_flash_firmware(ha, pt, scb);
1725 ips_flash_bios(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1785 /* Fill in a single scb sg_list element from an address */
1790 ips_scb_t * scb, int indx, unsigned int e_len)
1795 if ((scb->data_len + e_len) > ha->max_xfer) {
1796 e_len = ha->max_xfer - scb->data_len;
1797 scb->breakup = indx;
1798 ++scb->sg_break;
1801 scb->breakup = 0;
1802 scb->sg_break = 0;
1805 scb->sg_list.enh_list[indx].address_lo =
1807 scb->sg_list.enh_list[indx].address_hi =
1809 scb->sg_list.enh_list[indx].length = cpu_to_le32(e_len);
1811 scb->sg_list.std_list[indx].address =
1813 scb->sg_list.std_list[indx].length = cpu_to_le32(e_len);
1816 ++scb->sg_len;
1817 scb->data_len += e_len;
1827 ips_flash_firmware(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1844 sg_list.list = scb->sg_list.list;
1845 cmd_busaddr = scb->scb_busaddr;
1847 memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1849 scb->sg_list.list = sg_list.list;
1850 scb->scb_busaddr = cmd_busaddr;
1851 scb->bus = scb->scsi_cmd->device->channel;
1852 scb->target_id = scb->scsi_cmd->device->id;
1853 scb->lun = scb->scsi_cmd->device->lun;
1854 scb->sg_len = 0;
1855 scb->data_len = 0;
1856 scb->flags = 0;
1857 scb->op_code = 0;
1858 scb->callback = ipsintr_done;
1859 scb->timeout = ips_cmd_timeout;
1861 scb->data_len = ha->flash_datasize;
1862 scb->data_busaddr =
1863 dma_map_single(&ha->pcidev->dev, ha->flash_data, scb->data_len,
1864 IPS_DMA_DIR(scb));
1865 scb->flags |= IPS_SCB_MAP_SINGLE;
1866 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
1867 scb->cmd.flashfw.buffer_addr = cpu_to_le32(scb->data_busaddr);
1869 scb->timeout = pt->TimeOut;
1870 scb->scsi_cmd->result = DID_OK << 16;
1900 ips_usrcmd(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1907 if ((!scb) || (!pt) || (!ha))
1911 sg_list.list = scb->sg_list.list;
1912 cmd_busaddr = scb->scb_busaddr;
1914 memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1915 memcpy(&scb->dcdb, &pt->CoppCP.dcdb, sizeof (IPS_DCDB_TABLE));
1918 scb->sg_list.list = sg_list.list;
1919 scb->scb_busaddr = cmd_busaddr;
1920 scb->bus = scb->scsi_cmd->device->channel;
1921 scb->target_id = scb->scsi_cmd->device->id;
1922 scb->lun = scb->scsi_cmd->device->lun;
1923 scb->sg_len = 0;
1924 scb->data_len = 0;
1925 scb->flags = 0;
1926 scb->op_code = 0;
1927 scb->callback = ipsintr_done;
1928 scb->timeout = ips_cmd_timeout;
1929 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
1932 if ((scb->cmd.basic_io.op_code == IPS_CMD_READ_SG) ||
1933 (scb->cmd.basic_io.op_code == IPS_CMD_WRITE_SG) ||
1934 (scb->cmd.basic_io.op_code == IPS_CMD_DCDB_SG))
1938 scb->data_len = pt->CmdBSize;
1939 scb->data_busaddr = ha->ioctl_busaddr + sizeof (ips_passthru_t);
1941 scb->data_busaddr = 0L;
1944 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
1945 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
1946 (unsigned long) &scb->
1948 (unsigned long) scb);
1951 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
1952 scb->dcdb.buffer_pointer =
1953 cpu_to_le32(scb->data_busaddr);
1955 scb->cmd.basic_io.sg_addr =
1956 cpu_to_le32(scb->data_busaddr);
1961 scb->timeout = pt->TimeOut;
1964 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10;
1966 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60;
1968 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;
1972 scb->scsi_cmd->result = DID_OK << 16;
1988 ips_cleanup_passthru(ips_ha_t * ha, ips_scb_t * scb)
1994 if ((!scb) || (!scb->scsi_cmd) || (!scsi_sglist(scb->scsi_cmd))) {
2003 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB) /* Copy DCDB Back to Caller's Area */
2004 memcpy(&pt->CoppCP.dcdb, &scb->dcdb, sizeof (IPS_DCDB_TABLE));
2006 pt->BasicStatus = scb->basic_status;
2007 pt->ExtendedStatus = scb->extended_status;
2011 (scb->cmd.flashfw.op_code == IPS_CMD_DOWNLOAD ||
2012 scb->cmd.flashfw.op_code == IPS_CMD_RW_BIOSFW))
2015 ips_scmd_buf_write(scb->scsi_cmd, ha->ioctl_data, ha->ioctl_datasize);
2233 ips_scb_t *scb;
2332 scb = &ha->scbs[ha->max_cmds - 1];
2334 ips_init_scb(ha, scb);
2336 scb->timeout = ips_cmd_timeout;
2337 scb->cdb[0] = IPS_CMD_RW_BIOSFW;
2339 scb->cmd.flashfw.op_code = IPS_CMD_RW_BIOSFW;
2340 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
2341 scb->cmd.flashfw.type = 1;
2342 scb->cmd.flashfw.direction = 0;
2343 scb->cmd.flashfw.count = cpu_to_le32(0x800);
2344 scb->cmd.flashfw.total_packets = 1;
2345 scb->cmd.flashfw.packet_num = 0;
2346 scb->data_len = 0x1000;
2347 scb->cmd.flashfw.buffer_addr = ha->ioctl_busaddr;
2351 ips_send_wait(ha, scb, ips_cmd_timeout,
2354 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
2527 ips_scb_t *scb;
2563 (ha->copp_waitlist.head) && (scb = ips_getscb(ha))) {
2569 scb->scsi_cmd = item->scsi_cmd;
2572 ret = ips_make_passthru(ha, scb->scsi_cmd, scb, intr);
2578 if (scb->scsi_cmd) {
2579 scb->scsi_cmd->result = DID_ERROR << 16;
2580 scsi_done(scb->scsi_cmd);
2583 ips_freescb(ha, scb);
2586 if (scb->scsi_cmd) {
2587 scb->scsi_cmd->result = DID_OK << 16;
2588 scsi_done(scb->scsi_cmd);
2591 ips_freescb(ha, scb);
2602 ret = ips_send_cmd(ha, scb);
2605 ips_putq_scb_head(&ha->scb_activelist, scb);
2611 if (scb->scsi_cmd) {
2612 scb->scsi_cmd->result = DID_ERROR << 16;
2615 ips_freescb(ha, scb);
2618 ips_freescb(ha, scb);
2631 while ((p) && (scb = ips_getscb(ha))) {
2636 ips_freescb(ha, scb);
2650 scb->target_id = SC->device->id;
2651 scb->lun = SC->device->lun;
2652 scb->bus = SC->device->channel;
2653 scb->scsi_cmd = SC;
2654 scb->breakup = 0;
2655 scb->data_len = 0;
2656 scb->callback = ipsintr_done;
2657 scb->timeout = ips_cmd_timeout;
2658 memset(&scb->cmd, 0, 16);
2661 memcpy(scb->cdb, SC->cmnd, SC->cmd_len);
2663 scb->sg_count = scsi_dma_map(SC);
2664 BUG_ON(scb->sg_count < 0);
2665 if (scb->sg_count) {
2669 scb->flags |= IPS_SCB_MAP_SG;
2671 scsi_for_each_sg(SC, sg, scb->sg_count, i) {
2673 (ha, sg_dma_address(sg), scb, i,
2677 scb->dcdb.transfer_length = scb->data_len;
2679 scb->data_busaddr = 0L;
2680 scb->sg_len = 0;
2681 scb->data_len = 0;
2682 scb->dcdb.transfer_length = 0;
2685 scb->dcdb.cmd_attribute =
2686 ips_command_direction[scb->scsi_cmd->cmnd[0]];
2690 if ((scb->scsi_cmd->cmnd[0] == WRITE_BUFFER) &&
2691 (scb->data_len == 0))
2692 scb->dcdb.cmd_attribute = 0;
2694 if (!(scb->dcdb.cmd_attribute & 0x3))
2695 scb->dcdb.transfer_length = 0;
2697 if (scb->data_len >= IPS_MAX_XFER) {
2698 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
2699 scb->dcdb.transfer_length = 0;
2704 ret = ips_send_cmd(ha, scb);
2708 ips_putq_scb_head(&ha->scb_activelist, scb);
2711 if (scb->scsi_cmd) {
2712 scb->scsi_cmd->result = DID_ERROR << 16;
2713 scsi_done(scb->scsi_cmd);
2716 if (scb->bus)
2717 ha->dcdb_active[scb->bus - 1] &=
2718 ~(1 << scb->target_id);
2720 ips_freescb(ha, scb);
2723 if (scb->scsi_cmd)
2724 scsi_done(scb->scsi_cmd);
2726 if (scb->bus)
2727 ha->dcdb_active[scb->bus - 1] &=
2728 ~(1 << scb->target_id);
2730 ips_freescb(ha, scb);
3087 ipsintr_blocking(ips_ha_t * ha, ips_scb_t * scb)
3091 ips_freescb(ha, scb);
3092 if (ha->waitflag && ha->cmd_in_progress == scb->cdb[0]) {
3109 ipsintr_done(ips_ha_t * ha, ips_scb_t * scb)
3113 if (!scb) {
3115 "Spurious interrupt; scb NULL.\n");
3120 if (scb->scsi_cmd == NULL) {
3128 ips_done(ha, scb);
3141 ips_done(ips_ha_t * ha, ips_scb_t * scb)
3147 if (!scb)
3150 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd))) {
3151 ips_cleanup_passthru(ha, scb);
3159 if ((scb->breakup) || (scb->sg_break)) {
3164 scb->data_len = 0;
3166 sg = scsi_sglist(scb->scsi_cmd);
3169 sg_dma_index = scb->breakup;
3170 for (i = 0; i < scb->breakup; i++)
3176 scb, ips_sg_index++,
3179 for (; sg_dma_index < scsi_sg_count(scb->scsi_cmd);
3184 scb, ips_sg_index++,
3189 scb->dcdb.transfer_length = scb->data_len;
3190 scb->dcdb.cmd_attribute |=
3191 ips_command_direction[scb->scsi_cmd->cmnd[0]];
3193 if (!(scb->dcdb.cmd_attribute & 0x3))
3194 scb->dcdb.transfer_length = 0;
3196 if (scb->data_len >= IPS_MAX_XFER) {
3197 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
3198 scb->dcdb.transfer_length = 0;
3201 ret = ips_send_cmd(ha, scb);
3205 if (scb->scsi_cmd) {
3206 scb->scsi_cmd->result = DID_ERROR << 16;
3207 scsi_done(scb->scsi_cmd);
3210 ips_freescb(ha, scb);
3213 if (scb->scsi_cmd) {
3214 scb->scsi_cmd->result = DID_ERROR << 16;
3215 scsi_done(scb->scsi_cmd);
3218 ips_freescb(ha, scb);
3228 if (scb->bus) {
3229 ha->dcdb_active[scb->bus - 1] &= ~(1 << scb->target_id);
3232 scsi_done(scb->scsi_cmd);
3234 ips_freescb(ha, scb);
3247 ips_map_status(ips_ha_t * ha, ips_scb_t * scb, ips_stat_t * sp)
3257 if (scb->bus) {
3261 scb->scsi_cmd->device->channel,
3262 scb->scsi_cmd->device->id, scb->scsi_cmd->device->lun,
3263 scb->basic_status, scb->extended_status,
3264 scb->extended_status ==
3265 IPS_ERR_CKCOND ? scb->dcdb.sense_info[2] & 0xf : 0,
3266 scb->extended_status ==
3267 IPS_ERR_CKCOND ? scb->dcdb.sense_info[12] : 0,
3268 scb->extended_status ==
3269 IPS_ERR_CKCOND ? scb->dcdb.sense_info[13] : 0);
3276 switch (scb->basic_status & IPS_GSC_STATUS_MASK) {
3289 switch (scb->extended_status) {
3291 if (scb->bus)
3297 if ((scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB) ||
3298 (scb->cmd.dcdb.op_code ==
3300 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3304 (uint32_t) scb->dcdb.transfer_length;
3307 if ((scb->bus) && (transfer_len < scb->data_len)) {
3312 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3313 ips_scmd_buf_read(scb->scsi_cmd,
3327 if (scb->bus)
3338 if (scb->bus) {
3339 if ((scb->cmd.dcdb.op_code ==
3341 || (scb->cmd.dcdb.op_code ==
3344 (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3345 memcpy_and_pad(scb->scsi_cmd->sense_buffer,
3350 memcpy_and_pad(scb->scsi_cmd->sense_buffer,
3352 scb->dcdb.sense_info,
3353 sizeof(scb->dcdb.sense_info), 0);
3369 scb->scsi_cmd->result = device_error | (errcode << 16);
3386 ips_send_wait(ips_ha_t * ha, ips_scb_t * scb, int timeout, int intr)
3394 ha->cmd_in_progress = scb->cdb[0];
3396 scb->callback = ipsintr_blocking;
3397 ret = ips_send_cmd(ha, scb);
3452 ips_send_cmd(ips_ha_t * ha, ips_scb_t * scb)
3464 if (!scb->scsi_cmd) {
3467 if (scb->bus > 0) {
3470 if (ha->waitflag && ha->cmd_in_progress == scb->cdb[0])
3475 } else if ((scb->bus == 0) && (!ips_is_passthru(scb->scsi_cmd))) {
3479 switch (scb->scsi_cmd->cmnd[0]) {
3485 scb->scsi_cmd->result = DID_ERROR << 16;
3489 scb->scsi_cmd->result = DID_OK << 16;
3494 if (scb->target_id == IPS_ADAPTER_ID) {
3499 if (scb->scsi_cmd->cmnd[0] == TEST_UNIT_READY)
3500 scb->scsi_cmd->result = DID_OK << 16;
3502 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3528 ips_scmd_buf_write(scb->scsi_cmd,
3532 scb->scsi_cmd->result = DID_OK << 16;
3535 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3536 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3537 scb->cmd.logical_info.reserved = 0;
3538 scb->cmd.logical_info.reserved2 = 0;
3539 scb->data_len = sizeof (IPS_LD_INFO);
3540 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3541 scb->flags = 0;
3542 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3549 ips_reqsen(ha, scb);
3550 scb->scsi_cmd->result = DID_OK << 16;
3555 if (!scb->sg_len) {
3556 scb->cmd.basic_io.op_code =
3557 (scb->scsi_cmd->cmnd[0] ==
3559 scb->cmd.basic_io.enhanced_sg = 0;
3560 scb->cmd.basic_io.sg_addr =
3561 cpu_to_le32(scb->data_busaddr);
3563 scb->cmd.basic_io.op_code =
3564 (scb->scsi_cmd->cmnd[0] ==
3567 scb->cmd.basic_io.enhanced_sg =
3569 scb->cmd.basic_io.sg_addr =
3570 cpu_to_le32(scb->sg_busaddr);
3573 scb->cmd.basic_io.segment_4G = 0;
3574 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3575 scb->cmd.basic_io.log_drv = scb->target_id;
3576 scb->cmd.basic_io.sg_count = scb->sg_len;
3578 if (scb->cmd.basic_io.lba)
3579 le32_add_cpu(&scb->cmd.basic_io.lba,
3580 le16_to_cpu(scb->cmd.basic_io.
3583 scb->cmd.basic_io.lba =
3584 (((scb->scsi_cmd->
3585 cmnd[1] & 0x1f) << 16) | (scb->scsi_cmd->
3587 (scb->scsi_cmd->cmnd[3]));
3589 scb->cmd.basic_io.sector_count =
3590 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3592 if (le16_to_cpu(scb->cmd.basic_io.sector_count) == 0)
3593 scb->cmd.basic_io.sector_count =
3601 if (!scb->sg_len) {
3602 scb->cmd.basic_io.op_code =
3603 (scb->scsi_cmd->cmnd[0] ==
3605 scb->cmd.basic_io.enhanced_sg = 0;
3606 scb->cmd.basic_io.sg_addr =
3607 cpu_to_le32(scb->data_busaddr);
3609 scb->cmd.basic_io.op_code =
3610 (scb->scsi_cmd->cmnd[0] ==
3613 scb->cmd.basic_io.enhanced_sg =
3615 scb->cmd.basic_io.sg_addr =
3616 cpu_to_le32(scb->sg_busaddr);
3619 scb->cmd.basic_io.segment_4G = 0;
3620 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3621 scb->cmd.basic_io.log_drv = scb->target_id;
3622 scb->cmd.basic_io.sg_count = scb->sg_len;
3624 if (scb->cmd.basic_io.lba)
3625 le32_add_cpu(&scb->cmd.basic_io.lba,
3626 le16_to_cpu(scb->cmd.basic_io.
3629 scb->cmd.basic_io.lba =
3630 ((scb->scsi_cmd->cmnd[2] << 24) | (scb->
3634 (scb->scsi_cmd->cmnd[4] << 8) | scb->
3637 scb->cmd.basic_io.sector_count =
3638 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3640 if (cpu_to_le16(scb->cmd.basic_io.sector_count) == 0) {
3646 scb->scsi_cmd->result = DID_OK << 16;
3654 scb->scsi_cmd->result = DID_OK << 16;
3658 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
3659 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3660 scb->cmd.basic_io.segment_4G = 0;
3661 scb->cmd.basic_io.enhanced_sg = 0;
3662 scb->data_len = sizeof (*ha->enq);
3663 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
3668 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3669 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3670 scb->cmd.logical_info.reserved = 0;
3671 scb->cmd.logical_info.reserved2 = 0;
3672 scb->cmd.logical_info.reserved3 = 0;
3673 scb->data_len = sizeof (IPS_LD_INFO);
3674 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3675 scb->flags = 0;
3676 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3688 scb->scsi_cmd->result = DID_OK << 16;
3695 sp = (char *) scb->scsi_cmd->sense_buffer;
3704 scb->scsi_cmd->result = device_error | (DID_OK << 16);
3713 if (scb->bus > 0) {
3717 if (ha->conf->dev[scb->bus - 1][scb->target_id].ucState == 0) {
3718 scb->scsi_cmd->result = DID_NO_CONNECT << 16;
3722 ha->dcdb_active[scb->bus - 1] |= (1 << scb->target_id);
3723 scb->cmd.dcdb.command_id = IPS_COMMAND_ID(ha, scb);
3724 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
3725 (unsigned long) &scb->
3727 (unsigned long) scb);
3728 scb->cmd.dcdb.reserved = 0;
3729 scb->cmd.dcdb.reserved2 = 0;
3730 scb->cmd.dcdb.reserved3 = 0;
3731 scb->cmd.dcdb.segment_4G = 0;
3732 scb->cmd.dcdb.enhanced_sg = 0;
3734 TimeOut = scsi_cmd_to_rq(scb->scsi_cmd)->timeout;
3737 if (!scb->sg_len) {
3738 scb->cmd.dcdb.op_code = IPS_CMD_EXTENDED_DCDB;
3740 scb->cmd.dcdb.op_code =
3742 scb->cmd.dcdb.enhanced_sg =
3746 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb; /* Use Same Data Area as Old DCDB Struct */
3748 ((scb->bus - 1) << 4) | scb->target_id;
3761 tapeDCDB->cdb_length = scb->scsi_cmd->cmd_len;
3763 tapeDCDB->transfer_length = scb->data_len;
3764 if (scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB_SG)
3766 cpu_to_le32(scb->sg_busaddr);
3769 cpu_to_le32(scb->data_busaddr);
3770 tapeDCDB->sg_count = scb->sg_len;
3774 memcpy(tapeDCDB->scsi_cdb, scb->scsi_cmd->cmnd,
3775 scb->scsi_cmd->cmd_len);
3777 if (!scb->sg_len) {
3778 scb->cmd.dcdb.op_code = IPS_CMD_DCDB;
3780 scb->cmd.dcdb.op_code = IPS_CMD_DCDB_SG;
3781 scb->cmd.dcdb.enhanced_sg =
3785 scb->dcdb.device_address =
3786 ((scb->bus - 1) << 4) | scb->target_id;
3787 scb->dcdb.cmd_attribute |= IPS_DISCONNECT_ALLOWED;
3791 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
3793 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
3795 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
3798 scb->dcdb.transfer_length = scb->data_len;
3799 if (scb->dcdb.cmd_attribute & IPS_TRANSFER64K)
3800 scb->dcdb.transfer_length = 0;
3801 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB_SG)
3802 scb->dcdb.buffer_pointer =
3803 cpu_to_le32(scb->sg_busaddr);
3805 scb->dcdb.buffer_pointer =
3806 cpu_to_le32(scb->data_busaddr);
3807 scb->dcdb.cdb_length = scb->scsi_cmd->cmd_len;
3808 scb->dcdb.sense_length = sizeof (scb->dcdb.sense_info);
3809 scb->dcdb.sg_count = scb->sg_len;
3810 scb->dcdb.reserved = 0;
3811 memcpy(scb->dcdb.scsi_cdb, scb->scsi_cmd->cmnd,
3812 scb->scsi_cmd->cmd_len);
3813 scb->dcdb.scsi_status = 0;
3814 scb->dcdb.reserved2[0] = 0;
3815 scb->dcdb.reserved2[1] = 0;
3816 scb->dcdb.reserved2[2] = 0;
3820 return ((*ha->func.issue) (ha, scb));
3835 ips_scb_t *scb;
3844 scb = &ha->scbs[pstatus->fields.command_id];
3845 scb->basic_status = basic_status =
3847 scb->extended_status = ext_status = pstatus->fields.extended_status;
3851 sp->scb_addr = (void *) scb;
3854 ips_removeq_scb(&ha->scb_activelist, scb);
3856 if (!scb->scsi_cmd)
3863 scb->cdb[0],
3864 scb->cmd.basic_io.command_id,
3865 scb->bus, scb->target_id, scb->lun);
3867 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd)))
3876 if (scb->bus == 0) {
3882 scb->cmd.basic_io.op_code,
3886 switch (scb->scsi_cmd->cmnd[0]) {
3899 if (!ips_online(ha, scb)) {
3905 if (ips_online(ha, scb)) {
3906 ips_inquiry(ha, scb);
3913 ips_reqsen(ha, scb);
3925 if (!ips_online(ha, scb)
3926 || !ips_msense(ha, scb)) {
3932 if (ips_online(ha, scb))
3933 ips_rdcap(ha, scb);
3958 scb->scsi_cmd->result = errcode << 16;
3961 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3962 ips_scmd_buf_read(scb->scsi_cmd,
3965 scb->scsi_cmd->result = DID_TIME_OUT << 16;
3969 if (scb->bus == 0) {
3973 scb->cmd.basic_io.op_code, basic_status,
3977 ips_map_status(ha, scb, sp);
3991 ips_online(ips_ha_t * ha, ips_scb_t * scb)
3995 if (scb->target_id >= IPS_MAX_LD)
3998 if ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1) {
4003 if (ha->logical_drive_info->drive_info[scb->target_id].state !=
4005 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4007 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4009 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4026 ips_inquiry(ips_ha_t * ha, ips_scb_t * scb)
4046 ips_scmd_buf_write(scb->scsi_cmd, &inquiry, sizeof (inquiry));
4061 ips_rdcap(ips_ha_t * ha, ips_scb_t * scb)
4067 if (scsi_bufflen(scb->scsi_cmd) < 8)
4073 drive_info[scb->target_id].sector_count) - 1);
4076 ips_scmd_buf_write(scb->scsi_cmd, &cap, sizeof (cap));
4091 ips_msense(ips_ha_t * ha, ips_scb_t * scb)
4100 if (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) > 0x400000 &&
4110 (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) -
4117 switch (scb->scsi_cmd->cmnd[2] & 0x3f) {
4167 ips_scmd_buf_write(scb->scsi_cmd, &mdata, sizeof (mdata));
4182 ips_reqsen(ips_ha_t * ha, ips_scb_t * scb)
4196 ips_scmd_buf_write(scb->scsi_cmd, &reqsen, sizeof (reqsen));
4367 ips_init_scb(ips_ha_t * ha, ips_scb_t * scb)
4373 if (scb == NULL)
4376 sg_list.list = scb->sg_list.list;
4377 cmd_busaddr = scb->scb_busaddr;
4378 sg_busaddr = scb->sg_busaddr;
4380 memset(scb, 0, sizeof (ips_scb_t));
4389 /* set bus address of scb */
4390 scb->scb_busaddr = cmd_busaddr;
4391 scb->sg_busaddr = sg_busaddr;
4392 scb->sg_list.list = sg_list.list;
4395 scb->cmd.basic_io.cccr = cpu_to_le32((uint32_t) IPS_BIT_ILE);
4396 scb->cmd.basic_io.ccsar = cpu_to_le32(ha->adapt->hw_status_start
4414 ips_scb_t *scb;
4418 if ((scb = ha->scb_freelist) == NULL) {
4423 ha->scb_freelist = scb->q_next;
4424 scb->flags = 0;
4425 scb->q_next = NULL;
4427 ips_init_scb(ha, scb);
4429 return (scb);
4444 ips_freescb(ips_ha_t * ha, ips_scb_t * scb)
4448 if (scb->flags & IPS_SCB_MAP_SG)
4449 scsi_dma_unmap(scb->scsi_cmd);
4450 else if (scb->flags & IPS_SCB_MAP_SINGLE)
4451 dma_unmap_single(&ha->pcidev->dev, scb->data_busaddr,
4452 scb->data_len, IPS_DMA_DIR(scb));
4454 /* check to make sure this is not our "special" scb */
4455 if (IPS_COMMAND_ID(ha, scb) < (ha->max_cmds - 1)) {
4456 scb->q_next = ha->scb_freelist;
4457 ha->scb_freelist = scb;
4557 ips_scb_t *scb;
4564 scb = dma_alloc_coherent(&ha->pcidev->dev, sizeof(ips_scb_t),
4566 if (scb) {
4567 memset(scb, 0, sizeof(ips_scb_t));
4568 ips_init_scb(ha, scb);
4569 scb->scb_busaddr = command_dma;
4571 scb->timeout = ips_cmd_timeout;
4572 scb->cdb[0] = IPS_CMD_FLUSH;
4574 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
4575 scb->cmd.flush_cache.command_id = IPS_MAX_CMDS; /* Use an ID that would otherwise not exist */
4576 scb->cmd.flush_cache.state = IPS_NORM_STATE;
4577 scb->cmd.flush_cache.reserved = 0;
4578 scb->cmd.flush_cache.reserved2 = 0;
4579 scb->cmd.flush_cache.reserved3 = 0;
4580 scb->cmd.flush_cache.reserved4 = 0;
4582 ret = ips_send_cmd(ha, scb); /* Send the Flush Command */
4600 dma_free_coherent(&ha->pcidev->dev, sizeof(ips_scb_t), scb, command_dma);
5273 ips_issue_copperhead(ips_ha_t * ha, ips_scb_t * scb)
5280 if (scb->scsi_cmd) {
5284 scb->cdb[0],
5285 scb->cmd.basic_io.command_id,
5286 scb->bus, scb->target_id, scb->lun);
5289 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5311 outl(scb->scb_busaddr, ha->io_addr + IPS_REG_CCSAR);
5327 ips_issue_copperhead_memio(ips_ha_t * ha, ips_scb_t * scb)
5334 if (scb->scsi_cmd) {
5338 scb->cdb[0],
5339 scb->cmd.basic_io.command_id,
5340 scb->bus, scb->target_id, scb->lun);
5343 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5364 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_CCSAR);
5380 ips_issue_i2o(ips_ha_t * ha, ips_scb_t * scb)
5385 if (scb->scsi_cmd) {
5389 scb->cdb[0],
5390 scb->cmd.basic_io.command_id,
5391 scb->bus, scb->target_id, scb->lun);
5394 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5397 outl(scb->scb_busaddr, ha->io_addr + IPS_REG_I2O_INMSGQ);
5412 ips_issue_i2o_memio(ips_ha_t * ha, ips_scb_t * scb)
5417 if (scb->scsi_cmd) {
5421 scb->cdb[0],
5422 scb->cmd.basic_io.command_id,
5423 scb->bus, scb->target_id, scb->lun);
5426 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5429 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_I2O_INMSGQ);
5659 ips_scb_t *scb;
5664 scb = &ha->scbs[ha->max_cmds - 1];
5666 ips_init_scb(ha, scb);
5668 scb->timeout = ips_cmd_timeout;
5669 scb->cdb[0] = IPS_CMD_ENQUIRY;
5671 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
5672 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5673 scb->cmd.basic_io.sg_count = 0;
5674 scb->cmd.basic_io.lba = 0;
5675 scb->cmd.basic_io.sector_count = 0;
5676 scb->cmd.basic_io.log_drv = 0;
5677 scb->data_len = sizeof (*ha->enq);
5678 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
5682 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5684 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5702 ips_scb_t *scb;
5707 scb = &ha->scbs[ha->max_cmds - 1];
5709 ips_init_scb(ha, scb);
5711 scb->timeout = ips_cmd_timeout;
5712 scb->cdb[0] = IPS_CMD_GET_SUBSYS;
5714 scb->cmd.basic_io.op_code = IPS_CMD_GET_SUBSYS;
5715 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5716 scb->cmd.basic_io.sg_count = 0;
5717 scb->cmd.basic_io.lba = 0;
5718 scb->cmd.basic_io.sector_count = 0;
5719 scb->cmd.basic_io.log_drv = 0;
5720 scb->data_len = sizeof (*ha->subsys);
5721 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
5725 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5727 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5746 ips_scb_t *scb;
5756 scb = &ha->scbs[ha->max_cmds - 1];
5758 ips_init_scb(ha, scb);
5760 scb->timeout = ips_cmd_timeout;
5761 scb->cdb[0] = IPS_CMD_READ_CONF;
5763 scb->cmd.basic_io.op_code = IPS_CMD_READ_CONF;
5764 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5765 scb->data_len = sizeof (*ha->conf);
5766 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
5770 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5772 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
5781 if ((scb->basic_status & IPS_GSC_STATUS_MASK) ==
5804 ips_scb_t *scb;
5809 scb = &ha->scbs[ha->max_cmds - 1];
5811 ips_init_scb(ha, scb);
5813 scb->timeout = ips_cmd_timeout;
5814 scb->cdb[0] = IPS_CMD_RW_NVRAM_PAGE;
5816 scb->cmd.nvram.op_code = IPS_CMD_RW_NVRAM_PAGE;
5817 scb->cmd.nvram.command_id = IPS_COMMAND_ID(ha, scb);
5818 scb->cmd.nvram.page = 5;
5819 scb->cmd.nvram.write = write;
5820 scb->cmd.nvram.reserved = 0;
5821 scb->cmd.nvram.reserved2 = 0;
5822 scb->data_len = sizeof (*ha->nvram);
5823 scb->cmd.nvram.buffer_addr = ha->ioctl_busaddr;
5829 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5831 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
5854 ips_scb_t *scb;
5859 scb = &ha->scbs[ha->max_cmds - 1];
5861 ips_init_scb(ha, scb);
5863 scb->timeout = ips_reset_timeout;
5864 scb->cdb[0] = IPS_CMD_CONFIG_SYNC;
5866 scb->cmd.config_sync.op_code = IPS_CMD_CONFIG_SYNC;
5867 scb->cmd.config_sync.command_id = IPS_COMMAND_ID(ha, scb);
5868 scb->cmd.config_sync.channel = 0;
5869 scb->cmd.config_sync.source_target = IPS_POCL;
5870 scb->cmd.config_sync.reserved = 0;
5871 scb->cmd.config_sync.reserved2 = 0;
5872 scb->cmd.config_sync.reserved3 = 0;
5876 ips_send_wait(ha, scb, ips_reset_timeout, intr)) == IPS_FAILURE)
5878 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5882 ips_init_scb(ha, scb);
5884 scb->cdb[0] = IPS_CMD_ERROR_TABLE;
5885 scb->timeout = ips_reset_timeout;
5887 scb->cmd.unlock_stripe.op_code = IPS_CMD_ERROR_TABLE;
5888 scb->cmd.unlock_stripe.command_id = IPS_COMMAND_ID(ha, scb);
5889 scb->cmd.unlock_stripe.log_drv = 0;
5890 scb->cmd.unlock_stripe.control = IPS_CSL;
5891 scb->cmd.unlock_stripe.reserved = 0;
5892 scb->cmd.unlock_stripe.reserved2 = 0;
5893 scb->cmd.unlock_stripe.reserved3 = 0;
5897 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5899 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5917 ips_scb_t *scb;
5921 scb = &ha->scbs[ha->max_cmds - 1];
5923 ips_init_scb(ha, scb);
5925 scb->timeout = ips_cmd_timeout;
5926 scb->cdb[0] = IPS_CMD_FFDC;
5927 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
5928 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
5929 scb->cmd.ffdc.reset_count = ha->reset_count;
5930 scb->cmd.ffdc.reset_type = 0x80;
5933 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
5936 ips_send_wait(ha, scb, ips_cmd_timeout, intr);
5951 ips_scb_t *scb;
5957 scb = &ha->scbs[ha->max_cmds - 1];
5959 ips_init_scb(ha, scb);
5961 scb->timeout = ips_cmd_timeout;
5962 scb->cdb[0] = IPS_CMD_FFDC;
5963 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
5964 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
5965 scb->cmd.ffdc.reset_count = 0;
5966 scb->cmd.ffdc.reset_type = 0;
5969 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
5972 ips_send_wait(ha, scb, ips_cmd_timeout, IPS_FFDC);
5984 ips_fix_ffdc_time(ips_ha_t * ha, ips_scb_t * scb, time64_t current_time)
5992 scb->cmd.ffdc.hour = tm.tm_hour;
5993 scb->cmd.ffdc.minute = tm.tm_min;
5994 scb->cmd.ffdc.second = tm.tm_sec;
5995 scb->cmd.ffdc.yearH = (tm.tm_year + 1900) / 100;
5996 scb->cmd.ffdc.yearL = tm.tm_year % 100;
5997 scb->cmd.ffdc.month = tm.tm_mon + 1;
5998 scb->cmd.ffdc.day = tm.tm_mday;