Anything SATA related. Part 2/2.
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_control_mode_select(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+uint8_t *bufptr
+)
+{
+ if (bufptr[1] != (CONTROL_MODE_PAGE_LEN - 2)) {
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ /*
+ * T10/04-136r0 doesn't support this command, and Linux libata does
+ * not support select, so we will do nothing.
+ */
+
+ return ASD_COMMAND_BUILD_FINISHED;
+}
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_informational_exception_control_select(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+uint8_t *bufptr
+)
+{
+ unsigned *features_enabled;
+ unsigned *features_state;
+ struct asd_target *target;
+
+ if (bufptr[1] != (INFORMATIONAL_EXCEPTION_CONTROL_PAGE_LEN - 2)) {
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ target = dev->target;
+
+ switch (target->command_set_type) {
+ case ASD_COMMAND_SET_ATA:
+ features_enabled = &target->ata_cmdset.features_enabled;
+ features_state = &target->ata_cmdset.features_state;
+ break;
+
+ case ASD_COMMAND_SET_ATAPI:
+ features_enabled = &target->atapi_cmdset.features_enabled;
+ features_state = &target->ata_cmdset.features_state;
+ break;
+
+ default:
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ /*
+ * Sense we only support polling and we are translating, there is
+ * nothing more to do.
+ */
+ if (bufptr[2] & SCSI_DEXCPT) {
+ *features_enabled &= ~SMART_FEATURE_ENABLED;
+ *features_state &= ~SMART_FEATURE_ENABLED;
+ } else {
+ *features_enabled |= SMART_FEATURE_ENABLED;
+ *features_state |= SMART_FEATURE_ENABLED;
+ }
+
+ return ASD_COMMAND_BUILD_FINISHED;
+}
+
+/* -----------------------------------
+ * MODE_SENSE: (emulated)
+ * MODE_SENSE_10: (emulated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_mode_sense_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ struct asd_ata_task_hscb *ata_hscb;
+ unsigned page_code;
+ unsigned page_control;
+ unsigned subpage_code;
+ unsigned allocation_length;
+ unsigned long_lba_accepted;
+ uint8_t *buffer;
+ uint8_t *bufptr;
+ unsigned transfer_length;
+ unsigned len;
+ struct hd_driveid *hd_driveidp;
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ if (cmd->cmnd[1] & DBD_BIT) {
+ /*
+ * We don't support disabling block discriptors.
+ */
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ page_control = cmd->cmnd[2] & PAGE_CONTROL_MASK;
+
+ if (page_control != 0) {
+ /*
+ * We only support the current values.
+ */
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ subpage_code = cmd->cmnd[3];
+
+ long_lba_accepted = 0;
+ transfer_length = 0;
+ allocation_length = 0;
+
+ /*
+ * the first thing we need is a mode_parameter_header
+ * this depends on whether we are using 6 byte or 10 byte CDBs
+ */
+ switch (cmd->cmnd[0]) {
+ case MODE_SENSE:
+ transfer_length = MODE_PARAMETER_HEADER_LENGTH_6;
+ allocation_length = cmd->cmnd[4];
+ break;
+ case MODE_SENSE_10:
+ transfer_length = MODE_PARAMETER_HEADER_LENGTH_10;
+ long_lba_accepted = cmd->cmnd[1] & LLBA_MASK;
+ allocation_length = (cmd->cmnd[7] << 8) | cmd->cmnd[8];
+ break;
+ }
+
+ if (long_lba_accepted) {
+ transfer_length += BLOCK_DESCRIPTOR_LENGTH_8;
+ }
+ else {
+ transfer_length += BLOCK_DESCRIPTOR_LENGTH_16;
+ }
+
+ page_code = cmd->cmnd[2] & PAGE_CODE_MASK;
+
+ switch (page_code) {
+ case READ_WRITE_ERROR_RECOVERY_MODE_PAGE:
+ transfer_length += READ_WRITE_ERROR_RECOVERY_MODE_PAGE_LEN;
+ break;
+
+ case CACHING_MODE_PAGE:
+ transfer_length += CACHING_MODE_PAGE_LEN;
+ break;
+
+ case CONTROL_MODE_PAGE:
+ transfer_length += CONTROL_MODE_PAGE_LEN;
+ break;
+
+ case INFORMATIONAL_EXCEPTION_CONTROL_PAGE:
+ transfer_length += INFORMATIONAL_EXCEPTION_CONTROL_PAGE_LEN;
+ break;
+
+ case RETURN_ALL_PAGES:
+ transfer_length += + READ_WRITE_ERROR_RECOVERY_MODE_PAGE_LEN + + CACHING_MODE_PAGE_LEN + + CONTROL_MODE_PAGE_LEN + + INFORMATIONAL_EXCEPTION_CONTROL_PAGE_LEN;
+ break;
+ default:
+ /*
+ * We don't support disabling block discriptors.
+ */
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ len = MIN(transfer_length, cmd->request_bufflen);
+ len = MIN(len, allocation_length);
+
+ /*
+ * We can't transfer more than the size of the buffer.
+ */
+ cmd->request_bufflen = len;
+
+ /*
+ * MODE_SENSE (6 byte) only supports 256 bytes of data length. This
+ * length doesn't include
+ */
+ if (cmd->cmnd[0] == MODE_SENSE) {
+ /*
+ * The length doesn't include the length field itself, so we
+ * can have 256 bytes even though the length field only holds
+ * 0-255.
+ */
+ if (len > 256) {
+ len = 256;
+ }
+ }
+
+ /*
+ * Allocate the whole length that we are going to fill in, fill the
+ * buffer up, and then transfer back what was requested.
+ */
+ buffer = (uint8_t *)asd_alloc_mem(transfer_length, GFP_KERNEL);
+
+ if (buffer == NULL) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ RESOURCE_FAILURE, MEMORY_OUT_OF_SPACE);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ memset(buffer, 0, transfer_length);
+
+ bufptr = buffer;
+
+ /*
+ * SPC-3 says that the medium type should be 0.
+ *
+ * MODE_SENSE: bufptr[1] == 0
+ * MODE_SENSE_10: bufptr[2] == 0
+ */
+ /*
+ * 3.10.2 and 3.11.2 of T10/04-136r0 says that DPO is ignored and that
+ * FUA is only supported for NCQ (Native Command Queuing) drives. We
+ * are not supporting NCQ in this release, so the answer to DPOFUA will
+ * be 0 for now.
+ *
+ * MODE_SENSE: bufptr[2] == 0
+ * MODE_SENSE_10: bufptr[3] == 0
+ */
+
+ /*
+ * Now we can fill in the response. Start with the mode parameter + * header.
+ */
+ switch (cmd->cmnd[0]) {
+ case MODE_SENSE:
+ bufptr[0] = len - 1;
+ bufptr[3] = 8; // only one block descriptor
+ bufptr += MODE_PARAMETER_HEADER_LENGTH_6;
+ break;
+
+ case MODE_SENSE_10:
+ bufptr[0] = ((len - 2) >> 8) & 0xff;
+ bufptr[1] = (len - 2) & 0xff;
+ bufptr[6] = 0;
+ if (long_lba_accepted) {
+ bufptr[7] = 16; // only one block descriptor
+ } else {
+ bufptr[7] = 8; // only one block descriptor
+ }
+ bufptr += MODE_PARAMETER_HEADER_LENGTH_10;
+ break;
+ }
+
+ hd_driveidp = &dev->target->ata_cmdset.adp_hd_driveid;
+
+ if (long_lba_accepted) {
+ *((uint64_t *)&bufptr[0]) =
+ ATA2SCSI_8(*((uint64_t *)&hd_driveidp->lba_capacity_2));
+
+ bufptr[8] = 0; // density code: T10/04-136r0 - 3.21.2.1.3
+
+ *((uint32_t *)&bufptr[12]) = ATA2SCSI_4(ATA_BLOCK_SIZE);
+
+ bufptr += BLOCK_DESCRIPTOR_LENGTH_16;
+ } else {
+ *((uint32_t *)&bufptr[0]) =
+ ATA2SCSI_4(*((uint64_t *)&hd_driveidp->lba_capacity_2));
+
+ bufptr[4] = 0; // density code: T10/04-136r0 - 3.21.2.1.3
+
+ bufptr[5] = (ATA_BLOCK_SIZE >> 16) & 0xff;
+ bufptr[6] = (ATA_BLOCK_SIZE >> 8) & 0xff;
+ bufptr[7] = ATA_BLOCK_SIZE & 0xff;
+
+ bufptr += BLOCK_DESCRIPTOR_LENGTH_8;
+ }
+
+ switch (page_code) {
+ case READ_WRITE_ERROR_RECOVERY_MODE_PAGE:
+ bufptr = asd_sata_read_write_error_recovery_sense(asd,
+ dev, bufptr);
+ break;
+
+ case CACHING_MODE_PAGE:
+ bufptr = asd_sata_caching_sense(asd, dev, bufptr);
+ break;
+
+ case CONTROL_MODE_PAGE:
+ bufptr = asd_sata_control_sense(asd, dev, bufptr);
+ break;
+
+ case INFORMATIONAL_EXCEPTION_CONTROL_PAGE:
+ bufptr = asd_sata_informational_exception_control_sense(asd,
+ dev, bufptr);
+ break;
+
+ case RETURN_ALL_PAGES:
+ bufptr = asd_sata_read_write_error_recovery_sense(asd,
+ dev, bufptr);
+
+ bufptr = asd_sata_caching_sense(asd, dev, bufptr);
+
+ bufptr = asd_sata_control_sense(asd, dev, bufptr);
+
+ bufptr = asd_sata_informational_exception_control_sense(asd,
+ dev, bufptr);
+
+ break;
+ }
+
+ memcpy(cmd->request_buffer, buffer, len);
+
+ asd_free_mem(buffer);
+
+ asd_cmd_set_host_status(cmd, DID_OK);
+
+ return ASD_COMMAND_BUILD_FINISHED;
+}
+
+uint8_t *
+asd_sata_read_write_error_recovery_sense(
+struct asd_softc *asd,
+struct asd_device *dev,
+uint8_t *bufptr
+)
+{
+ bufptr[0] = READ_WRITE_ERROR_RECOVERY_MODE_PAGE; // PS == 0
+
+ bufptr[1] = READ_WRITE_ERROR_RECOVERY_MODE_PAGE_LEN - 2;
+ bufptr[2] = 0xc0; // DCR == 0, DTE == 0, PER == 0, ERR == 0
+ // RC == 0, TB == 0, ARRE == 1, AWRE == 1
+
+ bufptr[3] = 0x00; // READ_RETRY_COUNT == 0
+ bufptr[8] = 0x00; // WRITE_RETRY_COUNT == 0
+
+ bufptr[10] = 0x00; // RECOVERY_TIME_LIMIT == 0
+ bufptr[11] = 0x00;
+
+ return bufptr + bufptr[1] + 2;
+}
+
+uint8_t *
+asd_sata_caching_sense(
+struct asd_softc *asd,
+struct asd_device *dev,
+uint8_t *bufptr
+)
+{
+ struct hd_driveid *hd_driveidp;
+ unsigned features_state;
+ struct asd_target *target;
+
+ target = dev->target;
+
+ switch (target->command_set_type) {
+ case ASD_COMMAND_SET_ATA:
+ hd_driveidp = &target->ata_cmdset.adp_hd_driveid;
+ features_state = target->ata_cmdset.features_state;
+ break;
+
+ case ASD_COMMAND_SET_ATAPI:
+ hd_driveidp = &target->atapi_cmdset.adp_hd_driveid;
+ features_state = target->atapi_cmdset.features_state;
+ break;
+
+ default:
+ return bufptr + CACHING_MODE_PAGE_LEN;
+ }
+
+ bufptr[0] = CACHING_MODE_PAGE; // PS == 0
+ bufptr[1] = CACHING_MODE_PAGE_LEN - 2;
+
+ bufptr[2] = 0;
+
+ if (features_state & WRITE_CACHE_FEATURE_ENABLED) {
+ /* + * RCD == 0, MF == 0, SIZE == 0, DISC == 0,
+ * CAP == 0, ABPF == 0, IC == 0
+ */
+ /*
+ * After drive reset, we should re-issue IDENTIFY.
+ */
+ bufptr[2] |= SCSI_WCE;
+ } else {
+ bufptr[2] &= ~SCSI_WCE;
+ }
+
+ bufptr[3] = 0; // DEMAND_READ_RETENTION_PROPERTY == 0
+ // WRITE_RETENTION_PROPERTY == 0
+
+ bufptr[4] = 0; // DISABLE_PRE_FETCH_TRANSFER_LENGTH == 0
+ bufptr[5] = 0;
+
+ bufptr[6] = 0; // MINIMUM_PRE_FETCH == 0
+ bufptr[7] = 0;
+
+ bufptr[8] = 0; // MAXIMUM_PRE_FETCH == 0
+ bufptr[9] = 0;
+
+ bufptr[10] = 0; // MAXIMUM_PRE_FETCH_CEILING == 0
+ bufptr[11] = 0;
+
+ bufptr[12] = 0;
+
+ if ((features_state & READ_AHEAD_FEATURE_ENABLED) == 0) {
+ /*
+ * NV_DIS == 0, FSW == 0, LBCSS == 0, FSW == 0
+ */
+ /*
+ * After drive reset, we should re-issue IDENTIFY.
+ */
+ bufptr[12] |= SCSI_DRA;
+ } else {
+ bufptr[12] &= ~SCSI_DRA;
+ }
+
+ bufptr[13] = 0; // NUMBER_OF_CACHE_SEGMENTS == 0
+
+ bufptr[14] = 0; // CACHE_SEGMENT_SIZE == 0
+ bufptr[15] = 0;
+
+ bufptr[17] = 0; // NON_CACHE_SEGMENT_SIZE == 0
+ bufptr[18] = 0;
+ bufptr[19] = 0;
+
+ return bufptr + bufptr[1] + 2;
+}
+
+uint8_t *
+asd_sata_control_sense(
+struct asd_softc *asd,
+struct asd_device *dev,
+uint8_t *bufptr
+)
+{
+ bufptr[0] = CONTROL_MODE_PAGE;
+ bufptr[1] = CONTROL_MODE_PAGE_LEN - 2;
+ bufptr[2] = 2; // RLEC == 0, GLTSD == 0, D_SENSE == 0, TST == 0
+ bufptr[3] = 0; // QERR == 0, QUEUE_ALGORITHM_MODIFIER == 0
+ bufptr[4] = 0; // SWP == 0, UA_INTLCK_CTRL == 0, + // RAC == 0, TAS== 0
+ bufptr[5] = 0; // AUTOLOAD_MODE == 0, APTG_OWN == 0
+
+ bufptr[8] = 0xff;
+ bufptr[9] = 0xff;
+ bufptr[10] = 0;
+ bufptr[11] = 30;
+
+ return bufptr + bufptr[1] + 2;
+}
+
+uint8_t *
+asd_sata_informational_exception_control_sense(
+struct asd_softc *asd,
+struct asd_device *dev,
+uint8_t *bufptr
+)
+{
+ struct hd_driveid *hd_driveidp;
+ unsigned features_state;
+ struct asd_target *target;
+
+ target = dev->target;
+
+ switch (target->command_set_type) {
+ case ASD_COMMAND_SET_ATA:
+ hd_driveidp = &target->ata_cmdset.adp_hd_driveid;
+ features_state = target->ata_cmdset.features_state;
+ break;
+
+ case ASD_COMMAND_SET_ATAPI:
+ hd_driveidp = &target->atapi_cmdset.adp_hd_driveid;
+ features_state = target->atapi_cmdset.features_state;
+ break;
+
+ default:
+ return bufptr + INFORMATIONAL_EXCEPTION_CONTROL_PAGE_LEN;
+ }
+
+ bufptr[0] = INFORMATIONAL_EXCEPTION_CONTROL_PAGE; // PS == 0
+ bufptr[1] = INFORMATIONAL_EXCEPTION_CONTROL_PAGE_LEN - 2;
+
+ if ((features_state & SMART_FEATURE_ENABLED) == 0) {
+ /*
+ * LOGERR == 0, TEST == 0, EWASC == 0, EBF == 0, PERF == 0
+ */
+ bufptr[2] |= SCSI_DEXCPT; // disabled
+ }
+
+ bufptr[3] = 0x06; // MRIE - report on request
+
+ bufptr[4] = 0; // INTERVAL_TIMER == 0
+ bufptr[5] = 0;
+ bufptr[6] = 0;
+ bufptr[7] = 0;
+
+ bufptr[8] = 0; // REPORT_COUNT == 0
+ bufptr[9] = 0;
+ bufptr[10] = 0;
+ bufptr[11] = 0;
+
+ return bufptr + bufptr[1] + 2;
+}
+
+/* -----------------------------------
+ * READ_6: (translated)
+ * READ_10: (translated)
+ * READ_12: (translated)
+ */
+
+// RST - we need a tag somehow
+ASD_COMMAND_BUILD_STATUS
+asd_sata_read_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ struct asd_ata_task_hscb *ata_hscb;
+ uint32_t lba;
+ unsigned sectors;
+ unsigned fis_command;
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ switch (cmd->cmnd[0]) {
+ case READ_6:
+ lba = (cmd->cmnd[2] << 8) | cmd->cmnd[3];
+ sectors = cmd->cmnd[4];
+
+ break;
+
+ case READ_10:
+ if (cmd->cmnd[9] != 0) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+ }
+
+ lba = (cmd->cmnd[2] << 24) | (cmd->cmnd[3] << 16) |
+ (cmd->cmnd[4] << 8) | cmd->cmnd[5];
+ sectors = (cmd->cmnd[7] << 8) | cmd->cmnd[8];
+
+ break;
+
+ case READ_12:
+ if (cmd->cmnd[11] != 0) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+ }
+
+ lba = (cmd->cmnd[2] << 24) | (cmd->cmnd[3] << 16) |
+ (cmd->cmnd[4] << 8) | cmd->cmnd[5];
+ sectors = (cmd->cmnd[6] << 24) | (cmd->cmnd[7] << 16) |
+ (cmd->cmnd[8] << 8) | cmd->cmnd[9];
+
+ break;
+
+ default:
+ lba = 0;
+ sectors = 0;
+ break;
+ }
+
+ switch (cmd->cmnd[0]) {
+ case READ_10:
+ case READ_12:
+ if (cmd->cmnd[1] & 0x01) {
+ /*
+ * Obsolete field that we will fail.
+ */
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ if (sectors == 0) {
+ asd_cmd_set_host_status(cmd, DID_OK);
+
+ return ASD_COMMAND_BUILD_FINISHED;
+ }
+ }
+
+ fis_command = 0;
+
+ // RST - what about FUA??
+
+ switch (dev->target->ata_cmdset.features_state & + (SATA_USES_DMA | SATA_USES_48BIT | SATA_USES_QUEUEING)) {
+ case 0:
+ fis_command = WIN_READ;
+ break;
+ case SATA_USES_DMA:
+ fis_command = WIN_READDMA;
+ break;
+ case SATA_USES_48BIT:
+ fis_command = WIN_READ_EXT;
+ break;
+ case SATA_USES_QUEUEING:
+ // Doesn't exist;
+ break;
+ case SATA_USES_DMA | SATA_USES_48BIT:
+ fis_command = WIN_READDMA_EXT;
+ break;
+ case SATA_USES_DMA | SATA_USES_QUEUEING:
+ // RST - sector and feature are swapped for this command
+ fis_command = WIN_READDMA_QUEUED;
+ break;
+ case SATA_USES_48BIT | SATA_USES_QUEUEING:
+ // Doesn't exist
+ break;
+ case SATA_USES_DMA | SATA_USES_48BIT | SATA_USES_QUEUEING:
+ // RST - sector and feature are swapped for this command
+ fis_command = WIN_READDMA_QUEUED_EXT;
+ break;
+ default:
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ asd_sata_setup_fis(ata_hscb, fis_command);
+
+ if (dev->target->ata_cmdset.features_state & SATA_USES_DMA) {
+ SET_DMA_MODE(ata_hscb);
+ } else {
+ SET_PIO_MODE(ata_hscb);
+ }
+
+ if (dev->target->ata_cmdset.features_state & SATA_USES_48BIT) {
+
+ asd_sata_setup_lba_ext(ata_hscb, lba, sectors);
+
+ } else {
+ if (lba >= RW_DMA_LBA_SIZE) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ if (sectors > RW_DMA_MAX_SECTORS) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ if (sectors == RW_DMA_MAX_SECTORS) {
+ sectors = 0;
+ }
+
+ asd_sata_setup_lba(ata_hscb, lba, sectors);
+ }
+
+ ata_hscb->ata_flags |= DATA_DIR_INBOUND;
+
+ asd_push_post_stack(asd, scb, (void *)cmd, asd_sata_read_post);
+
+ return ASD_COMMAND_BUILD_OK;
+}
+
+void
+asd_sata_read_post(
+struct asd_softc *asd,
+struct scb *scb,
+struct asd_done_list *done_listp
+)
+{
+ struct ata_resp_edb *ata_resp_edbp;
+ struct scsi_cmnd *cmd;
+#if 0
+ unsigned sectors;
+ uint32_t lba;
+ struct asd_ata_task_hscb *ata_hscb;
+ unsigned remain;
+#endif
+
+ cmd = (struct scsi_cmnd *)scb->io_ctx;
+
+#if 0
+ ata_hscb = &scb->hscb->ata_task;
+#endif
+
+ switch (done_listp->opcode) {
+ case ATA_TASK_COMP_W_RESP:
+ ata_resp_edbp = asd_sata_get_edb(asd, done_listp);
+ asd_sata_check_registers(ata_resp_edbp, scb, cmd);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+
+ case TASK_COMP_WO_ERR:
+ break;
+
+ default:
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+
+ }
+
+#if 0
+ if (remain > 0) {
+
+ sectors = remain / RW_DMA_MAX_SECTORS ;
+
+ if (sectors >= RW_DMA_MAX_SECTORS) {
+ scb->transfer_length = RW_DMA_MAX_SECTORS *
+ ATA_BLOCK_SIZE;
+
+ sectors = 0;
+ } else {
+
+ scb->transfer_length = remain;
+ }
+
+
+ lba = (ASD_H2D_FIS(ata_hscb)->lba2 << 16) |
+ (ASD_H2D_FIS(ata_hscb)->lba1 << 8) |
+ (ASD_H2D_FIS(ata_hscb)->lba0);
+
+ lba = lba + sectors;
+
+ printk("%s:%d: finishing request lba 0x%x sectors 0x%x\n",
+ __FUNCTION__, __LINE__,
+ lba, sectors);
+
+ asd_sata_setup_lba(ata_hscb, lba, sectors);
+
+ asd_hwi_post_scb(asd, scb);
+
+ return;
+ }
+#endif
+
+ asd_cmd_set_host_status(cmd, DID_OK);
+
+ asd_pop_post_stack(asd, scb, done_listp);
+}
+
+/* -----------------------------------
+ * WRITE_BUFFER: (translated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_write_buffer_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ struct asd_ata_task_hscb *ata_hscb;
+ unsigned buffer_offset;
+ unsigned len;
+ unsigned allocation_length;
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ if ((dev->target->ata_cmdset.features_state & + SATA_USES_WRITE_BUFFER) == 0) {
+
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ if ((cmd->cmnd[1] & BUFFER_MODE_MASK) != DATA_ONLY_MODE) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ /*
+ * Only support Buffer ID of 0
+ */
+ if (cmd->cmnd[2] != 0) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ buffer_offset = + (cmd->cmnd[3] << 16) | (cmd->cmnd[4] << 8) | cmd->cmnd[5];
+
+ if (buffer_offset >= ATA_BUFFER_SIZE) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ allocation_length = + (cmd->cmnd[6] << 16) | (cmd->cmnd[7] << 8) | cmd->cmnd[8];
+
+ len = MIN(ATA_BUFFER_SIZE - buffer_offset, cmd->request_bufflen);
+ len = MIN(len, allocation_length);
+
+ /*
+ * We can't transfer more than the size of the buffer.
+ */
+ cmd->request_bufflen = len;
+
+ asd_sata_setup_fis(ata_hscb, WIN_WRITE_BUFFER);
+
+ ata_hscb->ata_flags |= DATA_DIR_OUTBOUND;
+ SET_PIO_MODE(ata_hscb);
+
+ asd_push_post_stack(asd, scb, (void *)cmd, asd_sata_write_buffer_post);
+
+ return ASD_COMMAND_BUILD_OK;
+}
+
+void
+asd_sata_write_buffer_post(
+struct asd_softc *asd,
+struct scb *scb,
+struct asd_done_list *done_listp
+)
+{
+ struct ata_resp_edb *ata_resp_edbp;
+ struct scsi_cmnd *cmd;
+
+ cmd = (struct scsi_cmnd *)scb->io_ctx;
+
+ switch (done_listp->opcode) {
+ case ATA_TASK_COMP_W_RESP:
+ ata_resp_edbp = asd_sata_get_edb(asd, done_listp);
+ asd_sata_check_registers(ata_resp_edbp, scb, cmd);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+
+ case TASK_COMP_WO_ERR:
+ asd_cmd_set_host_status(cmd, DID_OK);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+
+ default:
+ break;
+ }
+
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ asd_pop_post_stack(asd, scb, done_listp);
+}
+
+/* -----------------------------------
+ * READ_BUFFER: (translated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_read_buffer_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ struct asd_ata_task_hscb *ata_hscb;
+ uint8_t *read_buffer_descriptor;
+ unsigned buffer_offset;
+ unsigned allocation_length;
+ unsigned len;
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ if ((dev->target->ata_cmdset.features_state & + SATA_USES_READ_BUFFER) == 0) {
+
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ if (cmd->cmnd[2] != 0) {
+ /*
+ * We are only supporting 1 buffer ID (== 0).
+ */
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ allocation_length = 0;
+
+ if ((cmd->cmnd[1] & BUFFER_MODE_MASK) == DESCRIPTOR_MODE) {
+
+ if (cmd->request_bufflen < READ_BUFFER_DESCRIPTOR_LENGTH) {
+
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ read_buffer_descriptor = (uint8_t *)cmd->request_buffer;
+
+ memset(read_buffer_descriptor, 0, + READ_BUFFER_DESCRIPTOR_LENGTH);
+
+ /*
+ * ATA only supports ATA_BUFFER_SIZE byte buffer writes.
+ */
+ read_buffer_descriptor[0] = 0;
+ read_buffer_descriptor[1] = (ATA_BUFFER_SIZE >> 16) & 0xff;
+ read_buffer_descriptor[2] = (ATA_BUFFER_SIZE >> 8) & 0xff;
+ read_buffer_descriptor[3] = ATA_BUFFER_SIZE & 0xff;
+
+ asd_cmd_set_host_status(cmd, DID_OK);
+
+ return ASD_COMMAND_BUILD_FINISHED;
+ }
+
+ if ((cmd->cmnd[1] & BUFFER_MODE_MASK) != DATA_ONLY_MODE) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ buffer_offset = + (cmd->cmnd[3] << 16) | (cmd->cmnd[4] << 8) | cmd->cmnd[5];
+
+ if (buffer_offset >= ATA_BUFFER_SIZE) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ len = MIN(ATA_BUFFER_SIZE - buffer_offset, cmd->request_bufflen);
+ len = MIN(len, allocation_length);
+
+ /*
+ * We can't transfer more than the size of the buffer.
+ */
+ cmd->request_bufflen = len;
+
+ asd_sata_setup_fis(ata_hscb, WIN_READ_BUFFER);
+
+ ata_hscb->ata_flags |= DATA_DIR_INBOUND;
+ SET_PIO_MODE(ata_hscb);
+
+ asd_push_post_stack(asd, scb, (void *)cmd, asd_sata_read_buffer_post);
+
+ return ASD_COMMAND_BUILD_OK;
+}
+
+void
+asd_sata_read_buffer_post(
+struct asd_softc *asd,
+struct scb *scb,
+struct asd_done_list *done_listp
+)
+{
+ struct ata_resp_edb *ata_resp_edbp;
+ struct scsi_cmnd *cmd;
+
+ cmd = (struct scsi_cmnd *)scb->io_ctx;
+
+ switch (done_listp->opcode) {
+ case ATA_TASK_COMP_W_RESP:
+ ata_resp_edbp = asd_sata_get_edb(asd, done_listp);
+ asd_sata_check_registers(ata_resp_edbp, scb, cmd);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+
+ case TASK_COMP_WO_ERR:
+ asd_cmd_set_host_status(cmd, DID_OK);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+
+ default:
+ break;
+ }
+
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ asd_pop_post_stack(asd, scb, done_listp);
+}
+
+/* -----------------------------------
+ * READ_CAPACITY: (emulated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_read_capacity_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ struct asd_ata_task_hscb *ata_hscb;
+ struct hd_driveid *hd_driveidp;
+ u_char *read_capacity_data;
+ uint64_t lba_capacity;
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ hd_driveidp = &dev->target->ata_cmdset.adp_hd_driveid;
+
+ if (cmd->request_bufflen < READ_CAPACITY_DATA_LEN) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ read_capacity_data = (u_char *)cmd->request_buffer;
+
+ lba_capacity = *((uint64_t *)&hd_driveidp->lba_capacity_2);
+
+ /*
+ * Ignore the Logical Block Address field and the PMI bit
+ */
+ if (lba_capacity == 0) {
+ lba_capacity = *((uint32_t *)&hd_driveidp->lba_capacity);
+ }
+
+ *((uint32_t *)&read_capacity_data[0]) = ATA2SCSI_4(lba_capacity - 1);
+
+ *((uint32_t *)&read_capacity_data[4]) = ATA2SCSI_4(ATA_BLOCK_SIZE);
+
+ asd_cmd_set_host_status(cmd, DID_OK);
+
+ return ASD_COMMAND_BUILD_FINISHED;
+}
+
+/* -----------------------------------
+ * REPORT_LUNS: (emulated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_report_luns_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ u_char report_luns_data[REPORT_LUNS_SIZE];
+ unsigned len;
+
+ memset(report_luns_data, 0, REPORT_LUNS_SIZE);
+
+ *((uint32_t *)&report_luns_data[0]) = asd_htobe32(8);
+
+ len = MIN(cmd->request_bufflen, REPORT_LUNS_SIZE);
+
+ memcpy(cmd->request_buffer, &report_luns_data[0], len);
+
+ asd_cmd_set_host_status(cmd, DID_OK);
+
+ return ASD_COMMAND_BUILD_FINISHED;
+}
+
+/* -----------------------------------
+ * REQUEST_SENSE: (emulated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_request_sense_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ asd_cmd_set_host_status(cmd, DID_OK);
+
+ return ASD_COMMAND_BUILD_FINISHED;
+}
+
+/* -----------------------------------
+ * REZERO_UNIT: (emulated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_rezero_unit_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ asd_cmd_set_host_status(cmd, DID_OK);
+
+ return ASD_COMMAND_BUILD_FINISHED;
+}
+
+/* -----------------------------------
+ * SEEK_6: (emulated)
+ * SEEK_10: (emulated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_seek_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ switch (cmd->cmnd[0]) {
+ case SEEK_6:
+ case SEEK_10:
+ break;
+ }
+
+ asd_cmd_set_host_status(cmd, DID_OK);
+
+ return ASD_COMMAND_BUILD_FINISHED;
+}
+
+/* -----------------------------------
+ * SEND_DIAGNOSTIC: (translated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_send_diagnostic_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ struct asd_ata_task_hscb *ata_hscb;
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ /*
+ * "Execute Device Diagnostic"
+ */
+ asd_sata_setup_fis(ata_hscb, WIN_DIAGNOSE);
+
+ ata_hscb->ata_flags |= DATA_DIR_NO_XFER;
+ SET_NO_IO_MODE(ata_hscb);
+
+ asd_push_post_stack(asd, scb, (void *)cmd,
+ asd_sata_send_diagnostic_post);
+
+ if ((cmd->cmnd[1] & SELFTEST) == 0) {
+
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ if ((cmd->cmnd[1] & SELFTEST_CODE_MASK) != 0) {
+
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ return ASD_COMMAND_BUILD_OK;
+}
+
+void
+asd_sata_send_diagnostic_post(
+struct asd_softc *asd,
+struct scb *scb,
+struct asd_done_list *done_listp
+)
+{
+ struct ata_resp_edb *ata_resp_edbp;
+ struct scsi_cmnd *cmd;
+ COMMAND_SET_TYPE command_set_type;
+ struct asd_device *dev;
+ unsigned error;
+
+ cmd = (struct scsi_cmnd *)scb->io_ctx;
+
+ dev = scb->platform_data->dev;
+
+ switch (done_listp->opcode) {
+ case CSMI_TASK_COMP_WO_ERR:
+ ata_resp_edbp = asd_sata_get_edb(asd, done_listp);
+ break;
+ case ATA_TASK_COMP_W_RESP:
+ ata_resp_edbp = asd_sata_get_edb(asd, done_listp);
+ asd_sata_check_registers(ata_resp_edbp, scb, cmd);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+ default:
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+ }
+
+ command_set_type = asd_sata_get_type(ASD_D2H_FIS(ata_resp_edbp));
+
+ if (command_set_type != dev->target->command_set_type) {
+ /*
+ * Signatures don't match.
+ */
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+ }
+
+ asd_pop_post_stack(asd, scb, done_listp);
+
+ error = ASD_D2H_FIS(ata_resp_edbp)->error;
+
+ if (error == 0x01) {
+ /*
+ * device 0 passed
+ */
+ asd_cmd_set_host_status(cmd, DID_OK);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+ }
+
+ if ((error == 0x00) || (error > 0x02)) {
+ /*
+ * The device failed internal tests.
+ */
+ asd_sata_set_check_condition(cmd, HARDWARE_ERROR,
+ LOGICAL_UNIT_FAILURE, FAILED_SELF_TEST);
+
+ asd_pop_post_stack(asd, scb, done_listp);
+
+ return;
+ }
+
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ asd_pop_post_stack(asd, scb, done_listp);
+}
+
+/* -----------------------------------
+ * START_STOP: (translated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_start_stop_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ struct asd_ata_task_hscb *ata_hscb;
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ if (cmd->cmnd[4] & START_STOP_LOEJ) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ if (cmd->cmnd[4] & START_STOP_START) {
+ asd_sata_setup_fis(ata_hscb, WIN_IDLEIMMEDIATE);
+ } else {
+ /*
+ * "Standby Immediate"
+ */
+ asd_sata_setup_fis(ata_hscb, WIN_STANDBYNOW1);
+ }
+
+ ata_hscb->ata_flags |= DATA_DIR_NO_XFER;
+ SET_NO_IO_MODE(ata_hscb);
+
+ asd_push_post_stack(asd, scb, (void *)cmd, asd_sata_start_stop_post);
+
+ return ASD_COMMAND_BUILD_OK;
+}
+
+void
+asd_sata_start_stop_post(
+struct asd_softc *asd,
+struct scb *scb,
+struct asd_done_list *done_listp
+)
+{
+ struct ata_resp_edb *ata_resp_edbp;
+ struct scsi_cmnd *cmd;
+
+ cmd = (struct scsi_cmnd *)scb->io_ctx;
+
+ switch (done_listp->opcode) {
+ case ATA_TASK_COMP_W_RESP:
+ ata_resp_edbp = asd_sata_get_edb(asd, done_listp);
+ asd_sata_check_registers(ata_resp_edbp, scb, cmd);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+
+ case TASK_COMP_WO_ERR:
+ asd_cmd_set_host_status(cmd, DID_OK);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+
+ default:
+ break;
+ }
+
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ asd_pop_post_stack(asd, scb, done_listp);
+}
+
+/* -----------------------------------
+ * SYNCHRONIZE_CACHE: (translated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_synchronize_cache_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ struct asd_ata_task_hscb *ata_hscb;
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ asd_sata_setup_fis(ata_hscb, WIN_FLUSH_CACHE);
+
+ ata_hscb->ata_flags |= DATA_DIR_NO_XFER;
+ SET_NO_IO_MODE(ata_hscb);
+
+ asd_push_post_stack(asd, scb, (void *)cmd,
+ asd_sata_synchronize_cache_post);
+
+ return ASD_COMMAND_BUILD_OK;
+}
+
+void
+asd_sata_synchronize_cache_post(
+struct asd_softc *asd,
+struct scb *scb,
+struct asd_done_list *done_listp
+)
+{
+ struct ata_resp_edb *ata_resp_edbp;
+ struct scsi_cmnd *cmd;
+
+ cmd = (struct scsi_cmnd *)scb->io_ctx;
+
+ switch (done_listp->opcode) {
+ case ATA_TASK_COMP_W_RESP:
+ ata_resp_edbp = asd_sata_get_edb(asd, done_listp);
+ asd_sata_check_registers(ata_resp_edbp, scb, cmd);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+
+ case TASK_COMP_WO_ERR:
+ asd_cmd_set_host_status(cmd, DID_OK);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+
+ default:
+ break;
+ }
+
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ asd_pop_post_stack(asd, scb, done_listp);
+}
+
+/* -----------------------------------
+ * TEST_UNIT_READY: (translated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_test_unit_ready_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ struct asd_ata_task_hscb *ata_hscb;
+ struct hd_driveid *hd_driveidp;
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ hd_driveidp = &dev->target->ata_cmdset.adp_hd_driveid;
+
+ if ((hd_driveidp->command_set_1 & POWER_MANAGEMENT_SUPPORTED) == 0) {
+
+ asd_cmd_set_host_status(cmd, DID_OK);
+
+ return ASD_COMMAND_BUILD_FINISHED;
+ }
+
+ asd_sata_setup_fis(ata_hscb, WIN_CHECKPOWERMODE1);
+
+ /*
+ * The CSMI task bit is a misnomer. It really means to return an
+ * ATA Response Empty Buffer done list entry even though there was no
+ * error. Normally this buffer gets returned from a ATA TASK COMPLETE
+ * WITH RESPONSE done list entry.
+ */
+ ata_hscb->ata_flags |= (DATA_DIR_NO_XFER | CSMI_TASK);
+ SET_NO_IO_MODE(ata_hscb);
+
+ asd_push_post_stack(asd, scb, (void *)cmd,
+ asd_sata_test_unit_ready_post);
+
+ return ASD_COMMAND_BUILD_OK;
+}
+
+
+void
+asd_sata_test_unit_ready_post(
+struct asd_softc *asd,
+struct scb *scb,
+struct asd_done_list *done_listp
+)
+{
+ struct ata_resp_edb *ata_resp_edbp;
+ struct scsi_cmnd *cmd;
+ struct asd_ata_task_hscb *ata_hscb;
+
+ cmd = (struct scsi_cmnd *)scb->io_ctx;
+
+ switch (done_listp->opcode) {
+ case CSMI_TASK_COMP_WO_ERR:
+ ata_resp_edbp = asd_sata_get_edb(asd, done_listp);
+ break;
+ case ATA_TASK_COMP_W_RESP:
+ ata_resp_edbp = asd_sata_get_edb(asd, done_listp);
+ asd_sata_check_registers(ata_resp_edbp, scb, cmd);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+ default:
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+ }
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ switch (ASD_H2D_FIS(ata_hscb)->sector_count) {
+#if 0
+ // RST - this doesn't seem to work
+ case ATA_STANDBY_MODE:
+ asd_sata_set_check_condition(cmd, NOT_READY,
+ LOGICAL_UNIT_NOT_READY, NOTIFY_REQUIRED);
+ break;
+#endif
+
+ default:
+ case ATA_IDLE_MODE:
+ case ATA_ACTIVE:
+ asd_cmd_set_host_status(cmd, DID_OK);
+ break;
+ }
+
+ asd_pop_post_stack(asd, scb, done_listp);
+}
+
+#ifdef T10_04_136
+/* -----------------------------------
+ * VERIFY: (translated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_verify_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ struct asd_ata_task_hscb *ata_hscb;
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ if (target->ata_cmdset.features_state & SATA_USES_48BIT) {
+ asd_sata_setup_fis(ata_hscb, WIN_VERIFY_EXT);
+ } else {
+ asd_sata_setup_fis(ata_hscb, WIN_VERIFY);
+ }
+
+ ata_hscb->ata_flags |= DATA_DIR_NO_XFER;
+ SET_NO_IO_MODE(ata_hscb);
+
+ asd_push_post_stack(asd, scb, (void *)acmd,
+ asd_sata_verify_post);
+
+ return ASD_COMMAND_BUILD_OK;
+}
+
+void
+asd_sata_verify_post(
+struct asd_softc *asd,
+struct scb *scb,
+struct asd_done_list *done_listp
+)
+{
+ // RST - fill this in
+ asd_pop_post_stack(asd, scb, done_listp);
+}
+#endif
+
+
+/* -----------------------------------
+ * WRITE_6: (translated)
+ * WRITE_10: (translated)
+ * WRITE_12: (translated)
+ */
+
+// RST - we need a tag somehow
+ASD_COMMAND_BUILD_STATUS
+asd_sata_write_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ struct asd_ata_task_hscb *ata_hscb;
+ uint32_t lba;
+ unsigned sectors;
+ unsigned fis_command;
+ unsigned fua_bit;
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ switch (cmd->cmnd[0]) {
+ case WRITE_6:
+ lba = (cmd->cmnd[2] << 8) | cmd->cmnd[3];
+ sectors = cmd->cmnd[4];
+
+ break;
+
+ case WRITE_10:
+ lba = (cmd->cmnd[2] << 24) | (cmd->cmnd[3] << 16) |
+ (cmd->cmnd[4] << 8) | cmd->cmnd[5];
+ sectors = (cmd->cmnd[7] << 8) | cmd->cmnd[8];
+
+ break;
+
+ case WRITE_12:
+ lba = (cmd->cmnd[2] << 24) | (cmd->cmnd[3] << 16) |
+ (cmd->cmnd[4] << 8) | cmd->cmnd[5];
+ sectors = (cmd->cmnd[6] << 24) | (cmd->cmnd[7] << 16) |
+ (cmd->cmnd[8] << 8) | cmd->cmnd[9];
+
+ break;
+ default:
+ lba = 0;
+ sectors = 0;
+ }
+
+ fua_bit = 0;
+
+ switch (cmd->cmnd[0]) {
+ case WRITE_10:
+ case WRITE_12:
+ if (cmd->cmnd[1] & 0x01) {
+ /*
+ * Obsolete field that we will fail.
+ */
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ if (sectors == 0) {
+ asd_cmd_set_host_status(cmd, DID_OK);
+
+ return ASD_COMMAND_BUILD_FINISHED;
+ }
+
+ if ((dev->target->ata_cmdset.features_state & + SATA_USES_WRITE_FUA) != 0) {
+
+ fua_bit = cmd->cmnd[1] & SCSI_WRITE_FUA_BIT;
+ }
+ break;
+ }
+
+ fis_command = 0;
+
+ switch (dev->target->ata_cmdset.features_state & + (SATA_USES_DMA | SATA_USES_48BIT | SATA_USES_QUEUEING)) {
+ case 0:
+ fis_command = WIN_WRITE;
+ break;
+ case SATA_USES_DMA:
+ fis_command = WIN_WRITEDMA;
+ break;
+ case SATA_USES_48BIT:
+ fis_command = WIN_WRITE_EXT;
+ break;
+ case SATA_USES_QUEUEING:
+ // Doesn't exist;
+ break;
+ case SATA_USES_DMA | SATA_USES_48BIT:
+ if (fua_bit) {
+ fis_command = WIN_WRITE_DMA_FUA_EXT;
+ } else {
+ fis_command = WIN_WRITEDMA_EXT;
+ }
+ break;
+ case SATA_USES_DMA | SATA_USES_QUEUEING:
+ fis_command = WIN_WRITEDMA_QUEUED;
+ break;
+ case SATA_USES_48BIT | SATA_USES_QUEUEING:
+ // Doesn't exist
+ break;
+ case SATA_USES_DMA | SATA_USES_48BIT | SATA_USES_QUEUEING:
+ if (fua_bit) {
+ fis_command = WIN_WRITE_DMA_QUEUED_FUA_EXT;
+ } else {
+ fis_command = WIN_WRITEDMA_QUEUED_EXT;
+ }
+ break;
+ default:
+ fis_command = 0;
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ asd_sata_setup_fis(ata_hscb, fis_command);
+
+ if (dev->target->ata_cmdset.features_state & SATA_USES_DMA) {
+ SET_DMA_MODE(ata_hscb);
+ } else {
+ SET_PIO_MODE(ata_hscb);
+ }
+
+ if (dev->target->ata_cmdset.features_state & SATA_USES_48BIT) {
+
+ asd_sata_setup_lba_ext(ata_hscb, lba, sectors);
+
+ } else {
+ if (lba >= RW_DMA_LBA_SIZE) {
+
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ if (sectors > RW_DMA_MAX_SECTORS) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ if (sectors == RW_DMA_MAX_SECTORS) {
+ sectors = 0;
+ }
+
+ asd_sata_setup_lba(ata_hscb, lba, sectors);
+ }
+
+ ata_hscb->ata_flags |= DATA_DIR_OUTBOUND;
+
+ asd_push_post_stack(asd, scb, (void *)cmd,
+ asd_sata_write_post);
+
+ return ASD_COMMAND_BUILD_OK;
+}
+
+void
+asd_sata_write_post(
+struct asd_softc *asd,
+struct scb *scb,
+struct asd_done_list *done_listp
+)
+{
+ struct ata_resp_edb *ata_resp_edbp;
+ struct scsi_cmnd *cmd;
+#if 0
+ uint32_t lba;
+ struct asd_ata_task_hscb *ata_hscb;
+ unsigned sectors;
+#endif
+
+ cmd = (struct scsi_cmnd *)scb->io_ctx;
+
+#if 0
+ ata_hscb = &scb->hscb->ata_task;
+#endif
+
+ switch (done_listp->opcode) {
+ case ATA_TASK_COMP_W_RESP:
+ ata_resp_edbp = asd_sata_get_edb(asd, done_listp);
+ asd_sata_check_registers(ata_resp_edbp, scb, cmd);
+ asd_pop_post_stack(asd, scb, done_listp);
+ return;
+
+ case TASK_COMP_WO_ERR:
+ break;
+
+ default:
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_COMMAND_OPERATION, 0);
+
+ asd_pop_post_stack(asd, scb, done_listp);
+
+ return;
+ }
+
+#if 0
+ if (scb->sectors_remaining != 0) {
+
+ sectors = scb->sectors_remaining;
+
+ if (sectors >= RW_DMA_MAX_SECTORS) {
+ scb->sectors_remaining = + scb->sectors_remaining - RW_DMA_MAX_SECTORS;
+
+ sectors = 0;
+ } else {
+
+ scb->sectors_remaining = 0;
+ }
+
+ lba = (ASD_H2D_FIS(ata_hscb)->lba2 << 16) |
+ (ASD_H2D_FIS(ata_hscb)->lba1 << 8) |
+ (ASD_H2D_FIS(ata_hscb)->lba0);
+
+ lba = lba + sectors;
+
+ printk("%s:%d: finishing request lba 0x%x sectors 0x%x "
+ "remaining 0x%x\n",
+ __FUNCTION__, __LINE__,
+ lba, sectors, scb->sectors_remaining);
+
+ asd_sata_setup_lba(ata_hscb, lba, sectors);
+
+ ret = asd_setup_data(asd, scb, cmd);
+
+ asd_hwi_post_scb(asd, scb);
+
+
+ return;
+ }
+#endif
+
+ asd_cmd_set_host_status(cmd, DID_OK);
+
+ asd_pop_post_stack(asd, scb, done_listp);
+
+ return;
+}
+
+#ifdef T10_04_136
+/* -----------------------------------
+ * WRITE_VERIFY: (translated)
+ */
+
+ASD_COMMAND_BUILD_STATUS
+asd_sata_write_verify_build(
+struct asd_softc *asd,
+struct asd_device *dev,
+struct scb *scb,
+struct scsi_cmnd *cmd
+)
+{
+ struct asd_ata_task_hscb *ata_hscb;
+ uint32_t lba;
+ unsigned sectors;
+
+ ata_hscb = &scb->hscb->ata_task;
+
+ lba = (cmd->cmnd[2] << 24) | (cmd->cmnd[3] << 16) |
+ (cmd->cmnd[4] << 8) | cmd->cmnd[5];
+
+ sectors = (cmd->cmnd[7] << 8) | cmd->cmnd[8];
+
+ // RST - this should be a WRITE with FUA followed by a read verify.
+ // ... we will want to set affiliation bits in the ata_hscb
+
+ if (target->ata_cmdset.features_state & SATA_USES_48BIT) {
+ /*
+ * Read Verify Sectors
+ */
+ asd_sata_setup_fis(ata_hscb, WIN_VERIFY_EXT);
+ } else {
+ if (sectors > RW_DMA_MAX_SECTORS) {
+ asd_sata_set_check_condition(cmd, ILLEGAL_REQUEST,
+ INVALID_FIELD_IN_CDB, 0);
+
+ return ASD_COMMAND_BUILD_FAILED;
+ }
+
+ if (sectors == RW_DMA_MAX_SECTORS) {
+ sectors = 0;
+ }
+
+ asd_sata_setup_fis(ata_hscb, WIN_VERIFY);
+ }
+
+ ata_hscb->ata_flags |= DATA_DIR_NO_XFER;
+ SET_NO_IO_MODE(ata_hscb);
+
+ asd_push_post_stack(asd, scb, (void *)acmd,
+ asd_sata_write_verify_post);
+
+ return ASD_COMMAND_BUILD_OK;
+}
+
+void
+asd_sata_write_verify_post(
+struct asd_softc *asd,
+struct scb *scb,
+struct asd_done_list *done_listp
+)
+{
+ asd_pop_post_stack(asd, scb, done_listp);
+}
+#endif
+
+#if 0
+void
+asd_print_hex(
+unsigned char *s,
+unsigned len
+)
+{
+ unsigned i;
+ unsigned count;
+
+ while (len != 0) {
+ count = (len > 16) ? 16 : len;
+
+ for (i = 0 ; i < count ; i++) {
+ printk("%02x ", *(s + i));
+ }
+
+ for ( ; i < 16 ; i++) {
+ printk(" ");
+ }
+
+ for (i = 0 ; i < count ; i++) {
+ if (((*(s + i) >= 'a') && (*(s + i) <= 'z')) ||
+ ((*(s + i) >= 'A') && (*(s + i) <= 'Z')) ||
+ ((*(s + i) >= '0') && (*(s + i) <= '9'))) {
+ printk("%c", *(s + i));
+ } else {
+ printk(".");
+ }
+ }
+
+ printk("\n");
+
+ len = len - count;
+
+ s = s + count;
+ }
+}
+#endif
- To unsubscribe from this list: send the line "unsubscribe linux-scsi" in the body of a message to [EMAIL PROTECTED] More majordomo info at http://vger.kernel.org/majordomo-info.html
