Lines Matching defs:cmd
888 static blk_status_t sd_setup_unmap_cmnd(struct scsi_cmnd *cmd)
890 struct scsi_device *sdp = cmd->device;
891 struct request *rq = scsi_cmd_to_rq(cmd);
902 cmd->cmd_len = 10;
903 cmd->cmnd[0] = UNMAP;
904 cmd->cmnd[8] = 24;
911 cmd->allowed = sdkp->max_retries;
912 cmd->transfersize = data_len;
915 return scsi_alloc_sgtables(cmd);
918 static blk_status_t sd_setup_write_same16_cmnd(struct scsi_cmnd *cmd,
921 struct scsi_device *sdp = cmd->device;
922 struct request *rq = scsi_cmd_to_rq(cmd);
931 cmd->cmd_len = 16;
932 cmd->cmnd[0] = WRITE_SAME_16;
934 cmd->cmnd[1] = 0x8; /* UNMAP */
935 put_unaligned_be64(lba, &cmd->cmnd[2]);
936 put_unaligned_be32(nr_blocks, &cmd->cmnd[10]);
938 cmd->allowed = sdkp->max_retries;
939 cmd->transfersize = data_len;
942 return scsi_alloc_sgtables(cmd);
945 static blk_status_t sd_setup_write_same10_cmnd(struct scsi_cmnd *cmd,
948 struct scsi_device *sdp = cmd->device;
949 struct request *rq = scsi_cmd_to_rq(cmd);
958 cmd->cmd_len = 10;
959 cmd->cmnd[0] = WRITE_SAME;
961 cmd->cmnd[1] = 0x8; /* UNMAP */
962 put_unaligned_be32(lba, &cmd->cmnd[2]);
963 put_unaligned_be16(nr_blocks, &cmd->cmnd[7]);
965 cmd->allowed = sdkp->max_retries;
966 cmd->transfersize = data_len;
969 return scsi_alloc_sgtables(cmd);
972 static blk_status_t sd_setup_write_zeroes_cmnd(struct scsi_cmnd *cmd)
974 struct request *rq = scsi_cmd_to_rq(cmd);
975 struct scsi_device *sdp = cmd->device;
983 return sd_setup_write_same16_cmnd(cmd, true);
985 return sd_setup_write_same10_cmnd(cmd, true);
995 return sd_setup_write_same16_cmnd(cmd, false);
997 return sd_setup_write_same10_cmnd(cmd, false);
1060 static blk_status_t sd_setup_flush_cmnd(struct scsi_cmnd *cmd)
1062 struct request *rq = scsi_cmd_to_rq(cmd);
1066 memset(&cmd->sdb, 0, sizeof(cmd->sdb));
1068 if (cmd->device->use_16_for_sync) {
1069 cmd->cmnd[0] = SYNCHRONIZE_CACHE_16;
1070 cmd->cmd_len = 16;
1072 cmd->cmnd[0] = SYNCHRONIZE_CACHE;
1073 cmd->cmd_len = 10;
1075 cmd->transfersize = 0;
1076 cmd->allowed = sdkp->max_retries;
1082 static blk_status_t sd_setup_rw32_cmnd(struct scsi_cmnd *cmd, bool write,
1086 cmd->cmd_len = SD_EXT_CDB_SIZE;
1087 cmd->cmnd[0] = VARIABLE_LENGTH_CMD;
1088 cmd->cmnd[7] = 0x18; /* Additional CDB len */
1089 cmd->cmnd[9] = write ? WRITE_32 : READ_32;
1090 cmd->cmnd[10] = flags;
1091 cmd->cmnd[11] = dld & 0x07;
1092 put_unaligned_be64(lba, &cmd->cmnd[12]);
1093 put_unaligned_be32(lba, &cmd->cmnd[20]); /* Expected Indirect LBA */
1094 put_unaligned_be32(nr_blocks, &cmd->cmnd[28]);
1099 static blk_status_t sd_setup_rw16_cmnd(struct scsi_cmnd *cmd, bool write,
1103 cmd->cmd_len = 16;
1104 cmd->cmnd[0] = write ? WRITE_16 : READ_16;
1105 cmd->cmnd[1] = flags | ((dld >> 2) & 0x01);
1106 cmd->cmnd[14] = (dld & 0x03) << 6;
1107 cmd->cmnd[15] = 0;
1108 put_unaligned_be64(lba, &cmd->cmnd[2]);
1109 put_unaligned_be32(nr_blocks, &cmd->cmnd[10]);
1114 static blk_status_t sd_setup_rw10_cmnd(struct scsi_cmnd *cmd, bool write,
1118 cmd->cmd_len = 10;
1119 cmd->cmnd[0] = write ? WRITE_10 : READ_10;
1120 cmd->cmnd[1] = flags;
1121 cmd->cmnd[6] = 0;
1122 cmd->cmnd[9] = 0;
1123 put_unaligned_be32(lba, &cmd->cmnd[2]);
1124 put_unaligned_be16(nr_blocks, &cmd->cmnd[7]);
1129 static blk_status_t sd_setup_rw6_cmnd(struct scsi_cmnd *cmd, bool write,
1143 scmd_printk(KERN_ERR, cmd, "FUA write on READ/WRITE(6) drive\n");
1147 cmd->cmd_len = 6;
1148 cmd->cmnd[0] = write ? WRITE_6 : READ_6;
1149 cmd->cmnd[1] = (lba >> 16) & 0x1f;
1150 cmd->cmnd[2] = (lba >> 8) & 0xff;
1151 cmd->cmnd[3] = lba & 0xff;
1152 cmd->cmnd[4] = nr_blocks;
1153 cmd->cmnd[5] = 0;
1183 static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd)
1185 struct request *rq = scsi_cmd_to_rq(cmd);
1186 struct scsi_device *sdp = cmd->device;
1199 ret = scsi_alloc_sgtables(cmd);
1205 scmd_printk(KERN_ERR, cmd, "device offline or changed\n");
1210 scmd_printk(KERN_ERR, cmd, "access beyond end of device\n");
1215 scmd_printk(KERN_ERR, cmd, "request not aligned to the logical block size\n");
1236 ret = sd_zbc_prepare_zone_append(cmd, &lba, nr_blocks);
1242 dix = scsi_prot_sg_count(cmd);
1243 dif = scsi_host_dif_capable(cmd->device->host, sdkp->protection_type);
1244 dld = sd_cdl_dld(sdkp, cmd);
1247 protect = sd_setup_protect_cmnd(cmd, dix, dif);
1252 ret = sd_setup_rw32_cmnd(cmd, write, lba, nr_blocks,
1255 ret = sd_setup_rw16_cmnd(cmd, write, lba, nr_blocks,
1259 ret = sd_setup_rw10_cmnd(cmd, write, lba, nr_blocks,
1262 ret = sd_setup_rw6_cmnd(cmd, write, lba, nr_blocks,
1274 cmd->transfersize = sdp->sector_size;
1275 cmd->underflow = nr_blocks << 9;
1276 cmd->allowed = sdkp->max_retries;
1277 cmd->sdb.length = nr_blocks * sdp->sector_size;
1280 scmd_printk(KERN_INFO, cmd,
1285 scmd_printk(KERN_INFO, cmd,
1295 scsi_free_sgtables(cmd);
1299 static blk_status_t sd_init_command(struct scsi_cmnd *cmd)
1301 struct request *rq = scsi_cmd_to_rq(cmd);
1307 return sd_setup_unmap_cmnd(cmd);
1309 return sd_setup_write_same16_cmnd(cmd, true);
1311 return sd_setup_write_same10_cmnd(cmd, true);
1313 return sd_setup_write_same10_cmnd(cmd, false);
1318 return sd_setup_write_zeroes_cmnd(cmd);
1320 return sd_setup_flush_cmnd(cmd);
1324 return sd_setup_read_write_cmnd(cmd);
1326 return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_RESET_WRITE_POINTER,
1329 return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_RESET_WRITE_POINTER,
1332 return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_OPEN_ZONE, false);
1334 return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_CLOSE_ZONE, false);
1336 return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_FINISH_ZONE, false);
1497 * @cmd: ioctl command number
1508 unsigned int cmd, unsigned long arg)
1517 "cmd=0x%x\n", disk->disk_name, cmd));
1528 error = scsi_ioctl_block_when_processing_errors(sdp, cmd,
1533 if (is_sed_ioctl(cmd))
1534 return sed_ioctl(sdkp->opal_dev, cmd, p);
1535 return scsi_ioctl(sdp, mode & BLK_OPEN_WRITE, cmd, p);
1661 unsigned char cmd[16] = { 0 };
1664 cmd[0] = SYNCHRONIZE_CACHE_16;
1666 cmd[0] = SYNCHRONIZE_CACHE;
1671 res = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, NULL, 0,
1802 u8 cmd[10] = { PERSISTENT_RESERVE_IN, sa };
1808 put_unaligned_be16(data_len, &cmd[7]);
1810 result = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_IN, data, data_len,
1895 u8 cmd[16] = { 0, };
1898 cmd[0] = PERSISTENT_RESERVE_OUT;
1899 cmd[1] = sa;
1900 cmd[2] = type;
1901 put_unaligned_be32(sizeof(data), &cmd[5]);
1907 result = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_OUT, &data,
2237 unsigned char cmd[10];
2257 cmd[0] = TEST_UNIT_READY;
2258 memset((void *) &cmd[1], 0, 9);
2260 the_result = scsi_execute_cmd(sdkp->device, cmd,
2315 cmd[0] = START_STOP;
2316 cmd[1] = 1; /* Return immediately */
2317 memset((void *) &cmd[2], 0, 8);
2318 cmd[4] = 1; /* Start spin cycle */
2320 cmd[4] |= 1 << 4;
2321 scsi_execute_cmd(sdkp->device, cmd,
2449 unsigned char cmd[16];
2465 memset(cmd, 0, 16);
2466 cmd[0] = SERVICE_ACTION_IN_16;
2467 cmd[1] = SAI_READ_CAPACITY_16;
2468 cmd[13] = RC16_LEN;
2471 the_result = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN,
2543 unsigned char cmd[16];
2555 cmd[0] = READ_CAPACITY;
2556 memset(&cmd[1], 0, 9);
2559 the_result = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, buffer,
3410 char *buffer, cmd[10] = { };
3416 cmd[0] = READ_10;
3417 put_unaligned_be32(0, &cmd[2]); /* Logical block address 0 */
3418 put_unaligned_be16(1, &cmd[7]); /* Transfer 1 logical block */
3420 scsi_execute_cmd(sdkp->device, cmd, REQ_OP_DRV_IN, buffer, buf_len,
3825 unsigned char cmd[6] = { START_STOP }; /* START_VALID */
3835 cmd[4] |= 1; /* START */
3838 cmd[4] |= start ? 1 << 4 : 3 << 4; /* Active or Standby */
3843 res = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, NULL, 0, SD_TIMEOUT,
3998 static const u8 cmd[10] = { REQUEST_SENSE };
4003 if (scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, NULL, 0,