archives/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-03-08 01:24:47 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

scsi: Change the return type of the .queuecommand() callback

Browse source 
In clang version 21.1 and later the -Wimplicit-enum-enum-cast warning
option has been introduced. This warning is enabled by default and can
be used to catch .queuecommand() implementations that return another
value than 0 or one of the SCSI_MLQUEUE_* constants. Hence this patch
that changes the return type of the .queuecommand() implementations from
'int' into 'enum scsi_qc_status'. No functionality has been changed.

Cc: Damien Le Moal <dlemoal@kernel.org>
Cc: John Garry <john.g.garry@oracle.com>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
Link: https://patch.msgid.link/20260115210357.2501991-6-bvanassche@acm.org
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
This commit is contained in:
Bart Van Assche 2026-01-15 13:03:41 -08:00 • committed by Martin K. Petersen
parent 5612404d02
commit 0db3f51839
104 changed files with 255 additions and 195 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Documentation/scsi/scsi_mid_low_api.rst
View file

@ -903,7 +903,8 @@ Details::
*
* Defined in: LLD
**/
int queuecommand(struct Scsi_Host *shost, struct scsi_cmnd * scp)
enum scsi_qc_status queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scp)
/**

8
drivers/ata/libata-scsi.c
View file

@ -4309,7 +4309,8 @@ static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
return NULL;
}
int __ata_scsi_queuecmd(struct scsi_cmnd *scmd, struct ata_device *dev)
enum scsi_qc_status __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
struct ata_device *dev)
{
struct ata_port *ap = dev->link->ap;
u8 scsi_op = scmd->cmnd[0];
@ -4383,12 +4384,13 @@ int __ata_scsi_queuecmd(struct scsi_cmnd *scmd, struct ata_device *dev)
* Return value from __ata_scsi_queuecmd() if @cmd can be queued,
* 0 otherwise.
*/
int ata_scsi_queuecmd(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
enum scsi_qc_status ata_scsi_queuecmd(struct Scsi_Host *shost,
struct scsi_cmnd *cmd)
{
struct ata_port *ap;
struct ata_device *dev;
struct scsi_device *scsidev = cmd->device;
int rc = 0;
enum scsi_qc_status rc = 0;
unsigned long irq_flags;
ap = ata_shost_to_port(shost);

3
drivers/ata/libata.h
View file

@ -164,7 +164,8 @@ extern int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
void ata_scsi_sdev_config(struct scsi_device *sdev);
int ata_scsi_dev_config(struct scsi_device *sdev, struct queue_limits *lim,
struct ata_device *dev);
int __ata_scsi_queuecmd(struct scsi_cmnd *scmd, struct ata_device *dev);
enum scsi_qc_status __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
struct ata_device *dev);
/* libata-eh.c */
extern unsigned int ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd);

7
drivers/firewire/sbp2.c
View file

@ -1440,13 +1440,14 @@ static int sbp2_map_scatterlist(struct sbp2_command_orb *orb,
/* SCSI stack integration */
static int sbp2_scsi_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *cmd)
static enum scsi_qc_status sbp2_scsi_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *cmd)
{
struct sbp2_logical_unit *lu = cmd->device->hostdata;
struct fw_device *device = target_parent_device(lu->tgt);
enum scsi_qc_status retval = SCSI_MLQUEUE_HOST_BUSY;
struct sbp2_command_orb *orb;
int generation, retval = SCSI_MLQUEUE_HOST_BUSY;
int generation;
orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
if (orb == NULL)

3
drivers/infiniband/ulp/srp/ib_srp.c
View file

@ -2148,7 +2148,8 @@ static void srp_handle_qp_err(struct ib_cq *cq, struct ib_wc *wc,
target->qp_in_error = true;
}
static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
static enum scsi_qc_status srp_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scmnd)
{
struct request *rq = scsi_cmd_to_rq(scmnd);
struct srp_target_port *target = host_to_target(shost);

7
drivers/message/fusion/mptfc.c
View file

@ -97,7 +97,8 @@ static u8 mptfcInternalCtx = MPT_MAX_PROTOCOL_DRIVERS;
static int mptfc_target_alloc(struct scsi_target *starget);
static int mptfc_sdev_init(struct scsi_device *sdev);
static int mptfc_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt);
static enum scsi_qc_status mptfc_qcmd(struct Scsi_Host *shost,
struct scsi_cmnd *SCpnt);
static void mptfc_target_destroy(struct scsi_target *starget);
static void mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout);
static void mptfc_remove(struct pci_dev *pdev);
@ -676,8 +677,8 @@ mptfc_sdev_init(struct scsi_device *sdev)
return 0;
}
static int
mptfc_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
static enum scsi_qc_status mptfc_qcmd(struct Scsi_Host *shost,
struct scsi_cmnd *SCpnt)
{
struct mptfc_rport_info *ri;
struct fc_rport *rport = starget_to_rport(scsi_target(SCpnt->device));

4
drivers/message/fusion/mptsas.c
View file

@ -1920,8 +1920,8 @@ mptsas_sdev_init(struct scsi_device *sdev)
return 0;
}
static int
mptsas_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
static enum scsi_qc_status mptsas_qcmd(struct Scsi_Host *shost,
struct scsi_cmnd *SCpnt)
{
MPT_SCSI_HOST *hd;
MPT_ADAPTER *ioc;

3
drivers/message/fusion/mptscsih.c
View file

@ -1309,8 +1309,7 @@ int mptscsih_show_info(struct seq_file *m, struct Scsi_Host *host)
*
* Returns 0. (rtn value discarded by linux scsi mid-layer)
*/
int
mptscsih_qcmd(struct scsi_cmnd *SCpnt)
enum scsi_qc_status mptscsih_qcmd(struct scsi_cmnd *SCpnt)
{
MPT_SCSI_HOST *hd;
MPT_FRAME_HDR *mf;

2
drivers/message/fusion/mptscsih.h
View file

@ -113,7 +113,7 @@ extern int mptscsih_resume(struct pci_dev *pdev);
#endif
extern int mptscsih_show_info(struct seq_file *, struct Scsi_Host *);
extern const char * mptscsih_info(struct Scsi_Host *SChost);
extern int mptscsih_qcmd(struct scsi_cmnd *SCpnt);
extern enum scsi_qc_status mptscsih_qcmd(struct scsi_cmnd *SCpnt);
extern int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel,
u8 id, u64 lun, int ctx2abort, ulong timeout);
extern void mptscsih_sdev_destroy(struct scsi_device *device);

4
drivers/message/fusion/mptspi.c
View file

@ -774,8 +774,8 @@ static int mptspi_sdev_configure(struct scsi_device *sdev,
return 0;
}
static int
mptspi_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
static enum scsi_qc_status mptspi_qcmd(struct Scsi_Host *shost,
struct scsi_cmnd *SCpnt)
{
struct _MPT_SCSI_HOST *hd = shost_priv(shost);
VirtDevice *vdevice = SCpnt->device->hostdata;

4
drivers/s390/scsi/zfcp_scsi.c
View file

@ -63,8 +63,8 @@ static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
scsi_done(scpnt);
}
static
int zfcp_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scpnt)
static enum scsi_qc_status zfcp_scsi_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scpnt)
{
struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
struct fc_rport *rport = starget_to_rport(scsi_target(scpnt->device));

2
drivers/scsi/3w-9xxx.c
View file

@ -1746,7 +1746,7 @@ out:
} /* End twa_scsi_eh_reset() */
/* This is the main scsi queue function to handle scsi opcodes */
static int twa_scsi_queue_lck(struct scsi_cmnd *SCpnt)
static enum scsi_qc_status twa_scsi_queue_lck(struct scsi_cmnd *SCpnt)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
int request_id, retval;

8
drivers/scsi/3w-sas.c
View file

@ -1453,11 +1453,13 @@ out:
} /* End twl_scsi_eh_reset() */
/* This is the main scsi queue function to handle scsi opcodes */
static int twl_scsi_queue_lck(struct scsi_cmnd *SCpnt)
static enum scsi_qc_status twl_scsi_queue_lck(struct scsi_cmnd *SCpnt)
{
TW_Device_Extension *tw_dev =
(TW_Device_Extension *)SCpnt->device->host->hostdata;
void (*done)(struct scsi_cmnd *) = scsi_done;
int request_id, retval;
TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
enum scsi_qc_status retval;
int request_id;
/* If we are resetting due to timed out ioctl, report as busy */
if (test_bit(TW_IN_RESET, &tw_dev->flags)) {

2
drivers/scsi/3w-xxxx.c
View file

@ -1920,7 +1920,7 @@ static int tw_scsiop_test_unit_ready_complete(TW_Device_Extension *tw_dev, int r
} /* End tw_scsiop_test_unit_ready_complete() */
/* This is the main scsi queue function to handle scsi opcodes */
static int tw_scsi_queue_lck(struct scsi_cmnd *SCpnt)
static enum scsi_qc_status tw_scsi_queue_lck(struct scsi_cmnd *SCpnt)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
unsigned char *command = SCpnt->cmnd;

6
drivers/scsi/53c700.c
View file

@ -152,8 +152,8 @@ MODULE_LICENSE("GPL");
/* This is the script */
#include "53c700_d.h"
STATIC int NCR_700_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *);
STATIC enum scsi_qc_status NCR_700_queuecommand(struct Scsi_Host *h,
struct scsi_cmnd *);
STATIC int NCR_700_abort(struct scsi_cmnd * SCpnt);
STATIC int NCR_700_host_reset(struct scsi_cmnd * SCpnt);
STATIC void NCR_700_chip_setup(struct Scsi_Host *host);
@ -1751,7 +1751,7 @@ NCR_700_intr(int irq, void *dev_id)
return IRQ_RETVAL(handled);
}
static int NCR_700_queuecommand_lck(struct scsi_cmnd *SCp)
static enum scsi_qc_status NCR_700_queuecommand_lck(struct scsi_cmnd *SCp)
{
struct NCR_700_Host_Parameters *hostdata =
(struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];

2
drivers/scsi/BusLogic.c
View file

@ -2877,7 +2877,7 @@ static int blogic_hostreset(struct scsi_cmnd *SCpnt)
Outgoing Mailbox for execution by the associated Host Adapter.
*/
static int blogic_qcmd_lck(struct scsi_cmnd *command)
static enum scsi_qc_status blogic_qcmd_lck(struct scsi_cmnd *command)
{
void (*comp_cb)(struct scsi_cmnd *) = scsi_done;
struct blogic_adapter *adapter =

3
drivers/scsi/BusLogic.h
View file

@ -1272,7 +1272,8 @@ static inline void blogic_incszbucket(unsigned int *cmdsz_buckets,
*/
static const char *blogic_drvr_info(struct Scsi_Host *);
static int blogic_qcmd(struct Scsi_Host *h, struct scsi_cmnd *);
static enum scsi_qc_status blogic_qcmd(struct Scsi_Host *h,
struct scsi_cmnd *command);
static int blogic_diskparam(struct scsi_device *, struct gendisk *, sector_t, int *);
static int blogic_sdev_configure(struct scsi_device *,
struct queue_limits *lim);

4
drivers/scsi/NCR5380.c
View file

@ -555,8 +555,8 @@ static void complete_cmd(struct Scsi_Host *instance,
* main coroutine is not running, it is restarted.
*/
static int NCR5380_queue_command(struct Scsi_Host *instance,
struct scsi_cmnd *cmd)
static enum scsi_qc_status NCR5380_queue_command(struct Scsi_Host *instance,
struct scsi_cmnd *cmd)
{
struct NCR5380_hostdata *hostdata = shost_priv(instance);
struct NCR5380_cmd *ncmd = NCR5380_to_ncmd(cmd);

2
drivers/scsi/a100u2w.c
View file

@ -909,7 +909,7 @@ static int inia100_build_scb(struct orc_host * host, struct orc_scb * scb, struc
* block, build the host specific scb structures and if there is room
* queue the command down to the controller
*/
static int inia100_queue_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status inia100_queue_lck(struct scsi_cmnd *cmd)
{
struct orc_scb *scb;
struct orc_host *host; /* Point to Host adapter control block */

4
drivers/scsi/aacraid/linit.c
View file

@ -237,8 +237,8 @@ static struct aac_driver_ident aac_drivers[] = {
* TODO: unify with aac_scsi_cmd().
*/
static int aac_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *cmd)
static enum scsi_qc_status aac_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *cmd)
{
aac_priv(cmd)->owner = AAC_OWNER_LOWLEVEL;

5
drivers/scsi/advansys.c
View file

@ -8462,10 +8462,11 @@ static int asc_execute_scsi_cmnd(struct scsi_cmnd *scp)
* This function always returns 0. Command return status is saved
* in the 'scp' result field.
*/
static int advansys_queuecommand_lck(struct scsi_cmnd *scp)
static enum scsi_qc_status advansys_queuecommand_lck(struct scsi_cmnd *scp)
{
struct Scsi_Host *shost = scp->device->host;
int asc_res, result = 0;
enum scsi_qc_status result = 0;
int asc_res;
ASC_STATS(shost, queuecommand);

4
drivers/scsi/aha152x.c
View file

@ -924,7 +924,7 @@ static int setup_expected_interrupts(struct Scsi_Host *shpnt)
/*
* Queue a command and setup interrupts for a free bus.
*/
static int aha152x_internal_queue(struct scsi_cmnd *SCpnt,
static enum scsi_qc_status aha152x_internal_queue(struct scsi_cmnd *SCpnt,
struct completion *complete, int phase)
{
struct aha152x_cmd_priv *acp = aha152x_priv(SCpnt);
@ -995,7 +995,7 @@ static int aha152x_internal_queue(struct scsi_cmnd *SCpnt,
* queue a command
*
*/
static int aha152x_queue_lck(struct scsi_cmnd *SCpnt)
static enum scsi_qc_status aha152x_queue_lck(struct scsi_cmnd *SCpnt)
{
return aha152x_internal_queue(SCpnt, NULL, 0);
}

3
drivers/scsi/aha1542.c
View file

@ -411,7 +411,8 @@ static irqreturn_t aha1542_interrupt(int irq, void *dev_id)
}
}
static int aha1542_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
static enum scsi_qc_status aha1542_queuecommand(struct Scsi_Host *sh,
struct scsi_cmnd *cmd)
{
struct aha1542_cmd *acmd = scsi_cmd_priv(cmd);
struct aha1542_hostdata *aha1542 = shost_priv(sh);

2
drivers/scsi/aha1740.c
View file

@ -319,7 +319,7 @@ static irqreturn_t aha1740_intr_handle(int irq, void *dev_id)
return IRQ_RETVAL(handled);
}
static int aha1740_queuecommand_lck(struct scsi_cmnd *SCpnt)
static enum scsi_qc_status aha1740_queuecommand_lck(struct scsi_cmnd *SCpnt)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
unchar direction;

12
drivers/scsi/aic7xxx/aic79xx_osm.c
View file

@ -359,7 +359,7 @@ static void ahd_linux_initialize_scsi_bus(struct ahd_softc *ahd);
static u_int ahd_linux_user_tagdepth(struct ahd_softc *ahd,
struct ahd_devinfo *devinfo);
static void ahd_linux_device_queue_depth(struct scsi_device *);
static int ahd_linux_run_command(struct ahd_softc*,
static enum scsi_qc_status ahd_linux_run_command(struct ahd_softc*,
struct ahd_linux_device *,
struct scsi_cmnd *);
static void ahd_linux_setup_tag_info_global(char *p);
@ -577,11 +577,11 @@ ahd_linux_info(struct Scsi_Host *host)
/*
* Queue an SCB to the controller.
*/
static int ahd_linux_queue_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status ahd_linux_queue_lck(struct scsi_cmnd *cmd)
{
struct ahd_softc *ahd;
struct ahd_linux_device *dev = scsi_transport_device_data(cmd->device);
int rtn = SCSI_MLQUEUE_HOST_BUSY;
struct ahd_linux_device *dev = scsi_transport_device_data(cmd->device);
enum scsi_qc_status rtn = SCSI_MLQUEUE_HOST_BUSY;
struct ahd_softc *ahd;
ahd = *(struct ahd_softc **)cmd->device->host->hostdata;
@ -1535,7 +1535,7 @@ ahd_linux_device_queue_depth(struct scsi_device *sdev)
}
}
static int
static enum scsi_qc_status
ahd_linux_run_command(struct ahd_softc *ahd, struct ahd_linux_device *dev,
struct scsi_cmnd *cmd)
{

4
drivers/scsi/aic7xxx/aic7xxx_osm.c
View file

@ -519,11 +519,11 @@ ahc_linux_info(struct Scsi_Host *host)
/*
* Queue an SCB to the controller.
*/
static int ahc_linux_queue_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status ahc_linux_queue_lck(struct scsi_cmnd *cmd)
{
struct ahc_softc *ahc;
struct ahc_linux_device *dev = scsi_transport_device_data(cmd->device);
int rtn = SCSI_MLQUEUE_HOST_BUSY;
enum scsi_qc_status rtn = SCSI_MLQUEUE_HOST_BUSY;
unsigned long flags;
ahc = *(struct ahc_softc **)cmd->device->host->hostdata;

5
drivers/scsi/arcmsr/arcmsr_hba.c
View file

@ -113,7 +113,8 @@ static int arcmsr_abort(struct scsi_cmnd *);
static int arcmsr_bus_reset(struct scsi_cmnd *);
static int arcmsr_bios_param(struct scsi_device *sdev,
struct gendisk *disk, sector_t capacity, int *info);
static int arcmsr_queue_command(struct Scsi_Host *h, struct scsi_cmnd *cmd);
static enum scsi_qc_status arcmsr_queue_command(struct Scsi_Host *h,
struct scsi_cmnd *cmd);
static int arcmsr_probe(struct pci_dev *pdev,
const struct pci_device_id *id);
static int __maybe_unused arcmsr_suspend(struct device *dev);
@ -3312,7 +3313,7 @@ static void arcmsr_handle_virtual_command(struct AdapterControlBlock *acb,
}
}
static int arcmsr_queue_command_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status arcmsr_queue_command_lck(struct scsi_cmnd *cmd)
{
struct Scsi_Host *host = cmd->device->host;
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;

2
drivers/scsi/arm/acornscsi.c
View file

@ -2408,7 +2408,7 @@ acornscsi_intr(int irq, void *dev_id)
* Params : cmd - SCSI command
* Returns : 0, or < 0 on error.
*/
static int acornscsi_queuecmd_lck(struct scsi_cmnd *SCpnt)
static enum scsi_qc_status acornscsi_queuecmd_lck(struct scsi_cmnd *SCpnt)
{
struct scsi_pointer *scsi_pointer = arm_scsi_pointer(SCpnt);
void (*done)(struct scsi_cmnd *) = scsi_done;

11
drivers/scsi/arm/fas216.c
View file

@ -2202,11 +2202,12 @@ no_command:
* Returns: 0 on success, else error.
* Notes: io_request_lock is held, interrupts are disabled.
*/
static int fas216_queue_command_internal(struct scsi_cmnd *SCpnt,
void (*done)(struct scsi_cmnd *))
static enum scsi_qc_status
fas216_queue_command_internal(struct scsi_cmnd *SCpnt,
void (*done)(struct scsi_cmnd *))
{
FAS216_Info *info = (FAS216_Info *)SCpnt->device->host->hostdata;
int result;
enum scsi_qc_status result;
fas216_checkmagic(info);
@ -2243,7 +2244,7 @@ static int fas216_queue_command_internal(struct scsi_cmnd *SCpnt,
return result;
}
static int fas216_queue_command_lck(struct scsi_cmnd *SCpnt)
static enum scsi_qc_status fas216_queue_command_lck(struct scsi_cmnd *SCpnt)
{
return fas216_queue_command_internal(SCpnt, scsi_done);
}
@ -2273,7 +2274,7 @@ static void fas216_internal_done(struct scsi_cmnd *SCpnt)
* Returns: scsi result code.
* Notes: io_request_lock is held, interrupts are disabled.
*/
static int fas216_noqueue_command_lck(struct scsi_cmnd *SCpnt)
static enum scsi_qc_status fas216_noqueue_command_lck(struct scsi_cmnd *SCpnt)
{
FAS216_Info *info = (FAS216_Info *)SCpnt->device->host->hostdata;

11
drivers/scsi/arm/fas216.h
View file

@ -338,21 +338,24 @@ extern int fas216_init (struct Scsi_Host *instance);
*/
extern int fas216_add (struct Scsi_Host *instance, struct device *dev);
/* Function: int fas216_queue_command(struct Scsi_Host *h, struct scsi_cmnd *SCpnt)
/* Function: enum scsi_qc_status fas216_queue_command(struct Scsi_Host *h, struct scsi_cmnd *SCpnt)
* Purpose : queue a command for adapter to process.
* Params : h - host adapter
* : SCpnt - Command to queue
* Returns : 0 - success, else error
*/
extern int fas216_queue_command(struct Scsi_Host *h, struct scsi_cmnd *SCpnt);
extern enum scsi_qc_status fas216_queue_command(struct Scsi_Host *h,
struct scsi_cmnd *SCpnt);
/* Function: int fas216_noqueue_command(struct Scsi_Host *h, struct scsi_cmnd *SCpnt)
/* Function: enum scsi_qc_status fas216_noqueue_command(struct Scsi_Host *h,
* struct scsi_cmnd *SCpnt)
* Purpose : queue a command for adapter to process, and process it to completion.
* Params : h - host adapter
* : SCpnt - Command to queue
* Returns : 0 - success, else error
*/
extern int fas216_noqueue_command(struct Scsi_Host *, struct scsi_cmnd *);
extern enum scsi_qc_status fas216_noqueue_command(struct Scsi_Host *h,
struct scsi_cmnd *SCpnt);
/* Function: irqreturn_t fas216_intr (FAS216_Info *info)
* Purpose : handle interrupts from the interface to progress a command

2
drivers/scsi/atp870u.c
View file

@ -617,7 +617,7 @@ static irqreturn_t atp870u_intr_handle(int irq, void *dev_id)
*
* Queue a command to the ATP queue. Called with the host lock held.
*/
static int atp870u_queuecommand_lck(struct scsi_cmnd *req_p)
static enum scsi_qc_status atp870u_queuecommand_lck(struct scsi_cmnd *req_p)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
unsigned char c;

5
drivers/scsi/bfa/bfad_im.c
View file

@ -24,7 +24,8 @@ DEFINE_IDR(bfad_im_port_index);
struct scsi_transport_template *bfad_im_scsi_transport_template;
struct scsi_transport_template *bfad_im_scsi_vport_transport_template;
static void bfad_im_itnim_work_handler(struct work_struct *work);
static int bfad_im_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmnd);
static enum scsi_qc_status bfad_im_queuecommand(struct Scsi_Host *h,
struct scsi_cmnd *cmnd);
static int bfad_im_sdev_init(struct scsi_device *sdev);
static void bfad_im_fc_rport_add(struct bfad_im_port_s *im_port,
struct bfad_itnim_s *itnim);
@ -1199,7 +1200,7 @@ bfad_im_itnim_work_handler(struct work_struct *work)
/*
* Scsi_Host template entry, queue a SCSI command to the BFAD.
*/
static int bfad_im_queuecommand_lck(struct scsi_cmnd *cmnd)
static enum scsi_qc_status bfad_im_queuecommand_lck(struct scsi_cmnd *cmnd)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
struct bfad_im_port_s *im_port =

3
drivers/scsi/bnx2fc/bnx2fc.h
View file

@ -498,7 +498,8 @@ static inline struct bnx2fc_priv *bnx2fc_priv(struct scsi_cmnd *cmd)
struct bnx2fc_cmd *bnx2fc_cmd_alloc(struct bnx2fc_rport *tgt);
struct bnx2fc_cmd *bnx2fc_elstm_alloc(struct bnx2fc_rport *tgt, int type);
void bnx2fc_cmd_release(struct kref *ref);
int bnx2fc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc_cmd);
enum scsi_qc_status bnx2fc_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *sc_cmd);
int bnx2fc_send_fw_fcoe_init_msg(struct bnx2fc_hba *hba);
int bnx2fc_send_fw_fcoe_destroy_msg(struct bnx2fc_hba *hba);
int bnx2fc_send_session_ofld_req(struct fcoe_port *port,

4
drivers/scsi/bnx2fc/bnx2fc_io.c
View file

@ -1836,8 +1836,8 @@ static void bnx2fc_parse_fcp_rsp(struct bnx2fc_cmd *io_req,
*
* This is the IO strategy routine, called by SCSI-ML
**/
int bnx2fc_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *sc_cmd)
enum scsi_qc_status bnx2fc_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *sc_cmd)
{
struct fc_lport *lport = shost_priv(host);
struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));

4
drivers/scsi/csiostor/csio_scsi.c
View file

@ -1775,8 +1775,8 @@ csio_scsi_cbfn(struct csio_hw *hw, struct csio_ioreq *req)
* - Kicks off the SCSI state machine for this IO.
* - Returns busy status on error.
*/
static int
csio_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmnd)
static enum scsi_qc_status csio_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *cmnd)
{
struct csio_lnode *ln = shost_priv(host);
struct csio_hw *hw = csio_lnode_to_hw(ln);

2
drivers/scsi/dc395x.c
View file

@ -873,7 +873,7 @@ static void build_srb(struct scsi_cmnd *cmd, struct DeviceCtlBlk *dcb,
* and is expected to be held on return.
*
*/
static int dc395x_queue_command_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status dc395x_queue_command_lck(struct scsi_cmnd *cmd)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
struct DeviceCtlBlk *dcb;

3
drivers/scsi/esas2r/esas2r.h
View file

@ -968,7 +968,8 @@ int esas2r_ioctl_handler(void *hostdata, unsigned int cmd, void __user *arg);
int esas2r_ioctl(struct scsi_device *dev, unsigned int cmd, void __user *arg);
u8 handle_hba_ioctl(struct esas2r_adapter *a,
struct atto_ioctl *ioctl_hba);
int esas2r_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd);
enum scsi_qc_status esas2r_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *cmd);
int esas2r_show_info(struct seq_file *m, struct Scsi_Host *sh);
long esas2r_proc_ioctl(struct file *fp, unsigned int cmd, unsigned long arg);

3
drivers/scsi/esas2r/esas2r_main.c
View file

@ -818,7 +818,8 @@ static u32 get_physaddr_from_sgc(struct esas2r_sg_context *sgc, u64 *addr)
return len;
}
int esas2r_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
enum scsi_qc_status esas2r_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *cmd)
{
struct esas2r_adapter *a =
(struct esas2r_adapter *)cmd->device->host->hostdata;

2
drivers/scsi/esp_scsi.c
View file

@ -952,7 +952,7 @@ static void esp_event_queue_full(struct esp *esp, struct esp_cmd_entry *ent)
scsi_track_queue_full(dev, lp->num_tagged - 1);
}
static int esp_queuecommand_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status esp_queuecommand_lck(struct scsi_cmnd *cmd)
{
struct scsi_device *dev = cmd->device;
struct esp *esp = shost_priv(dev->host);

3
drivers/scsi/fdomain.c
View file

@ -402,7 +402,8 @@ static irqreturn_t fdomain_irq(int irq, void *dev_id)
return IRQ_HANDLED;
}
static int fdomain_queue(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
static enum scsi_qc_status fdomain_queue(struct Scsi_Host *sh,
struct scsi_cmnd *cmd)
{
struct scsi_pointer *scsi_pointer = fdomain_scsi_pointer(cmd);
struct fdomain *fd = shost_priv(cmd->device->host);

3
drivers/scsi/fnic/fnic.h
View file

@ -503,7 +503,8 @@ void fnic_free_rq_buf(struct vnic_rq *rq, struct vnic_rq_buf *buf);
void fnic_flush_tx(struct work_struct *work);
void fnic_update_mac_locked(struct fnic *, u8 *new);
int fnic_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
enum scsi_qc_status fnic_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *sc);
int fnic_abort_cmd(struct scsi_cmnd *);
int fnic_device_reset(struct scsi_cmnd *);
int fnic_eh_host_reset_handler(struct scsi_cmnd *sc);

3
drivers/scsi/fnic/fnic_scsi.c
View file

@ -454,7 +454,8 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
return 0;
}
int fnic_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc)
enum scsi_qc_status fnic_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *sc)
{
struct request *const rq = scsi_cmd_to_rq(sc);
uint32_t mqtag = 0;

6
drivers/scsi/hpsa.c
View file

@ -276,7 +276,8 @@ static void hpsa_free_cmd_pool(struct ctlr_info *h);
#define VPD_PAGE (1 << 8)
#define HPSA_SIMPLE_ERROR_BITS 0x03
static int hpsa_scsi_queue_command(struct Scsi_Host *h, struct scsi_cmnd *cmd);
static enum scsi_qc_status hpsa_scsi_queue_command(struct Scsi_Host *h,
struct scsi_cmnd *cmd);
static void hpsa_scan_start(struct Scsi_Host *);
static int hpsa_scan_finished(struct Scsi_Host *sh,
unsigned long elapsed_time);
@ -5667,7 +5668,8 @@ static void hpsa_command_resubmit_worker(struct work_struct *work)
}
/* Running in struct Scsi_Host->host_lock less mode */
static int hpsa_scsi_queue_command(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
static enum scsi_qc_status hpsa_scsi_queue_command(struct Scsi_Host *sh,
struct scsi_cmnd *cmd)
{
struct ctlr_info *h;
struct hpsa_scsi_dev_t *dev;

2
drivers/scsi/hptiop.c
View file

@ -993,7 +993,7 @@ static int hptiop_reset_comm_mvfrey(struct hptiop_hba *hba)
return 0;
}
static int hptiop_queuecommand_lck(struct scsi_cmnd *scp)
static enum scsi_qc_status hptiop_queuecommand_lck(struct scsi_cmnd *scp)
{
struct Scsi_Host *host = scp->device->host;
struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata;

3
drivers/scsi/ibmvscsi/ibmvfc.c
View file

@ -1960,7 +1960,8 @@ static struct ibmvfc_cmd *ibmvfc_init_vfc_cmd(struct ibmvfc_event *evt, struct s
* Returns:
* 0 on success / other on failure
**/
static int ibmvfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
static enum scsi_qc_status ibmvfc_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *cmnd)
{
struct ibmvfc_host *vhost = shost_priv(shost);
struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));

9
drivers/scsi/ibmvscsi/ibmvscsi.c
View file

@ -868,9 +868,10 @@ static void ibmvscsi_timeout(struct timer_list *t)
* Returns the value returned from ibmvscsi_send_crq(). (Zero for success)
* Note that this routine assumes that host_lock is held for synchronization
*/
static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
struct ibmvscsi_host_data *hostdata,
unsigned long timeout)
static enum scsi_qc_status
ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
struct ibmvscsi_host_data *hostdata,
unsigned long timeout)
{
__be64 *crq_as_u64 = (__be64 *)&evt_struct->crq;
int request_status = 0;
@ -1040,7 +1041,7 @@ static inline u16 lun_from_dev(struct scsi_device *dev)
* @cmnd: struct scsi_cmnd to be executed
* @done: Callback function to be called when cmd is completed
*/
static int ibmvscsi_queuecommand_lck(struct scsi_cmnd *cmnd)
static enum scsi_qc_status ibmvscsi_queuecommand_lck(struct scsi_cmnd *cmnd)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
struct srp_cmd *srp_cmd;

2
drivers/scsi/imm.c
View file

@ -925,7 +925,7 @@ static int imm_engine(imm_struct *dev, struct scsi_cmnd *const cmd)
return 0;
}
static int imm_queuecommand_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status imm_queuecommand_lck(struct scsi_cmnd *cmd)
{
imm_struct *dev = imm_dev(cmd->device->host);

2
drivers/scsi/initio.c
View file

@ -2606,7 +2606,7 @@ static void initio_build_scb(struct initio_host * host, struct scsi_ctrl_blk * c
* zero if successful or indicate a host busy condition if not (which
* will cause the mid layer to call us again later with the command)
*/
static int i91u_queuecommand_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status i91u_queuecommand_lck(struct scsi_cmnd *cmd)
{
struct initio_host *host = (struct initio_host *) cmd->device->host->hostdata;
struct scsi_ctrl_blk *cmnd;

4
drivers/scsi/ipr.c
View file

@ -6242,8 +6242,8 @@ static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd)
* SCSI_MLQUEUE_DEVICE_BUSY if device is busy
* SCSI_MLQUEUE_HOST_BUSY if host is busy
**/
static int ipr_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scsi_cmd)
static enum scsi_qc_status ipr_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scsi_cmd)
{
struct ipr_ioa_cfg *ioa_cfg;
struct ipr_resource_entry *res;

4
drivers/scsi/ips.c
View file

@ -230,7 +230,7 @@ module_param(ips, charp, 0);
*/
static int ips_eh_abort(struct scsi_cmnd *);
static int ips_eh_reset(struct scsi_cmnd *);
static int ips_queue(struct Scsi_Host *, struct scsi_cmnd *);
static enum scsi_qc_status ips_queue(struct Scsi_Host *, struct scsi_cmnd *);
static const char *ips_info(struct Scsi_Host *);
static irqreturn_t do_ipsintr(int, void *);
static int ips_hainit(ips_ha_t *);
@ -1017,7 +1017,7 @@ static int ips_eh_reset(struct scsi_cmnd *SC)
/* Linux obtains io_request_lock before calling this function */
/* */
/****************************************************************************/
static int ips_queue_lck(struct scsi_cmnd *SC)
static enum scsi_qc_status ips_queue_lck(struct scsi_cmnd *SC)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
ips_ha_t *ha;

3
drivers/scsi/libfc/fc_fcp.c
View file

@ -1854,7 +1854,8 @@ static inline int fc_fcp_lport_queue_ready(struct fc_lport *lport)
*
* This is the i/o strategy routine, called by the SCSI layer.
*/
int fc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc_cmd)
enum scsi_qc_status fc_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *sc_cmd)
{
struct fc_lport *lport = shost_priv(shost);
struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));

3
drivers/scsi/libiscsi.c
View file

@ -1747,7 +1747,8 @@ enum {
FAILURE_SESSION_NOT_READY,
};
int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc)
enum scsi_qc_status iscsi_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *sc)
{
struct iscsi_cls_session *cls_session;
struct iscsi_host *ihost;

3
drivers/scsi/libsas/sas_scsi_host.c
View file

@ -157,7 +157,8 @@ static struct sas_task *sas_create_task(struct scsi_cmnd *cmd,
return task;
}
int sas_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
enum scsi_qc_status sas_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *cmd)
{
struct sas_internal *i = to_sas_internal(host->transportt);
struct domain_device *dev = cmd_to_domain_dev(cmd);

8
drivers/scsi/lpfc/lpfc_scsi.c
View file

@ -5233,8 +5233,8 @@ static char *lpfc_is_command_vm_io(struct scsi_cmnd *cmd)
* 0 - Success
* SCSI_MLQUEUE_HOST_BUSY - Block all devices served by this host temporarily.
**/
static int
lpfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
static enum scsi_qc_status lpfc_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *cmnd)
{
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba;
@ -6743,8 +6743,8 @@ lpfc_disable_oas_lun(struct lpfc_hba *phba, struct lpfc_name *vport_wwpn,
return false;
}
static int
lpfc_no_command(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
static enum scsi_qc_status lpfc_no_command(struct Scsi_Host *shost,
struct scsi_cmnd *cmnd)
{
return SCSI_MLQUEUE_HOST_BUSY;
}

2
drivers/scsi/mac53c94.c
View file

@ -66,7 +66,7 @@ static irqreturn_t do_mac53c94_interrupt(int, void *);
static void cmd_done(struct fsc_state *, int result);
static void set_dma_cmds(struct fsc_state *, struct scsi_cmnd *);
static int mac53c94_queue_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status mac53c94_queue_lck(struct scsi_cmnd *cmd)
{
struct fsc_state *state;

7
drivers/scsi/megaraid.c
View file

@ -372,11 +372,11 @@ mega_runpendq(adapter_t *adapter)
*
* The command queuing entry point for the mid-layer.
*/
static int megaraid_queue_lck(struct scsi_cmnd *scmd)
static enum scsi_qc_status megaraid_queue_lck(struct scsi_cmnd *scmd)
{
adapter_t *adapter;
scb_t *scb;
int busy=0;
enum scsi_qc_status busy = 0;
unsigned long flags;
adapter = (adapter_t *)scmd->device->host->hostdata;
@ -518,7 +518,8 @@ mega_get_ldrv_num(adapter_t *adapter, struct scsi_cmnd *cmd, int channel)
* boot settings.
*/
static scb_t *
mega_build_cmd(adapter_t *adapter, struct scsi_cmnd *cmd, int *busy)
mega_build_cmd(adapter_t *adapter, struct scsi_cmnd *cmd,
enum scsi_qc_status *busy)
{
mega_passthru *pthru;
scb_t *scb;

6
drivers/scsi/megaraid.h
View file

@ -962,8 +962,10 @@ static int mega_query_adapter(adapter_t *);
static int issue_scb(adapter_t *, scb_t *);
static int mega_setup_mailbox(adapter_t *);
static int megaraid_queue (struct Scsi_Host *, struct scsi_cmnd *);
static scb_t * mega_build_cmd(adapter_t *, struct scsi_cmnd *, int *);
static enum scsi_qc_status megaraid_queue(struct Scsi_Host *,
struct scsi_cmnd *);
static scb_t *mega_build_cmd(adapter_t *, struct scsi_cmnd *,
enum scsi_qc_status *);
static void __mega_runpendq(adapter_t *);
static int issue_scb_block(adapter_t *, u_char *);

13
drivers/scsi/megaraid/megaraid_mbox.c
View file

@ -109,8 +109,10 @@ static int megaraid_mbox_fire_sync_cmd(adapter_t *);
static void megaraid_mbox_display_scb(adapter_t *, scb_t *);
static void megaraid_mbox_setup_device_map(adapter_t *);
static int megaraid_queue_command(struct Scsi_Host *, struct scsi_cmnd *);
static scb_t *megaraid_mbox_build_cmd(adapter_t *, struct scsi_cmnd *, int *);
static enum scsi_qc_status megaraid_queue_command(struct Scsi_Host *,
struct scsi_cmnd *);
static scb_t *megaraid_mbox_build_cmd(adapter_t *, struct scsi_cmnd *,
enum scsi_qc_status *);
static void megaraid_mbox_runpendq(adapter_t *, scb_t *);
static void megaraid_mbox_prepare_pthru(adapter_t *, scb_t *,
struct scsi_cmnd *);
@ -1434,12 +1436,12 @@ mbox_post_cmd(adapter_t *adapter, scb_t *scb)
*
* Queue entry point for mailbox based controllers.
*/
static int megaraid_queue_command_lck(struct scsi_cmnd *scp)
static enum scsi_qc_status megaraid_queue_command_lck(struct scsi_cmnd *scp)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
adapter_t *adapter;
scb_t *scb;
int if_busy;
enum scsi_qc_status if_busy;
adapter = SCP2ADAPTER(scp);
scp->result = 0;
@ -1477,7 +1479,8 @@ static DEF_SCSI_QCMD(megaraid_queue_command)
* firmware. We also complete certain commands without sending them to firmware.
*/
static scb_t *
megaraid_mbox_build_cmd(adapter_t *adapter, struct scsi_cmnd *scp, int *busy)
megaraid_mbox_build_cmd(adapter_t *adapter, struct scsi_cmnd *scp,
enum scsi_qc_status *busy)
{
mraid_device_t *rdev = ADAP2RAIDDEV(adapter);
int channel;

4
drivers/scsi/megaraid/megaraid_sas_base.c
View file

@ -1781,8 +1781,8 @@ out_return_cmd:
* @shost: adapter SCSI host
* @scmd: SCSI command to be queued
*/
static int
megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
static enum scsi_qc_status megasas_queue_command(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
{
struct megasas_instance *instance;
struct MR_PRIV_DEVICE *mr_device_priv_data;

2
drivers/scsi/mesh.c
View file

@ -1625,7 +1625,7 @@ static void cmd_complete(struct mesh_state *ms)
* Called by midlayer with host locked to queue a new
* request
*/
static int mesh_queue_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status mesh_queue_lck(struct scsi_cmnd *cmd)
{
struct mesh_state *ms;

4
drivers/scsi/mpi3mr/mpi3mr_os.c
View file

@ -5029,8 +5029,8 @@ inline bool mpi3mr_allow_scmd_to_fw(struct scsi_cmnd *scmd)
* SCSI_MLQUEUE_DEVICE_BUSY when the device is busy.
* SCSI_MLQUEUE_HOST_BUSY when the host queue is full.
*/
static int mpi3mr_qcmd(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
static enum scsi_qc_status mpi3mr_qcmd(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
{
struct mpi3mr_ioc *mrioc = shost_priv(shost);
struct mpi3mr_stgt_priv_data *stgt_priv_data;

4
drivers/scsi/mpt3sas/mpt3sas_scsih.c
View file

@ -5422,8 +5422,8 @@ _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
* SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or
* SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full
*/
static int
scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
static enum scsi_qc_status scsih_qcmd(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
{
struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
struct MPT3SAS_DEVICE *sas_device_priv_data;

4
drivers/scsi/mvumi.c
View file

@ -2077,8 +2077,8 @@ error:
* @shost: Scsi host to queue command on
* @scmd: SCSI command to be queued
*/
static int mvumi_queue_command(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
static enum scsi_qc_status mvumi_queue_command(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
{
struct mvumi_cmd *cmd;
struct mvumi_hba *mhba;

12
drivers/scsi/myrb.c
View file

@ -1260,8 +1260,8 @@ static int myrb_host_reset(struct scsi_cmnd *scmd)
return SUCCESS;
}
static int myrb_pthru_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
static enum scsi_qc_status myrb_pthru_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
{
struct request *rq = scsi_cmd_to_rq(scmd);
struct myrb_hba *cb = shost_priv(shost);
@ -1416,8 +1416,8 @@ static void myrb_read_capacity(struct myrb_hba *cb, struct scsi_cmnd *scmd,
scsi_sg_copy_from_buffer(scmd, data, 8);
}
static int myrb_ldev_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
{
struct myrb_hba *cb = shost_priv(shost);
struct myrb_cmdblk *cmd_blk = scsi_cmd_priv(scmd);
@ -1603,8 +1603,8 @@ submit:
return 0;
}
static int myrb_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
static enum scsi_qc_status myrb_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
{
struct scsi_device *sdev = scmd->device;

4
drivers/scsi/myrs.c
View file

@ -1581,8 +1581,8 @@ static void myrs_mode_sense(struct myrs_hba *cs, struct scsi_cmnd *scmd,
scsi_sg_copy_from_buffer(scmd, modes, mode_len);
}
static int myrs_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
static enum scsi_qc_status myrs_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
{
struct request *rq = scsi_cmd_to_rq(scmd);
struct myrs_hba *cs = shost_priv(shost);

2
drivers/scsi/ncr53c8xx.c
View file

@ -7852,7 +7852,7 @@ static int ncr53c8xx_sdev_configure(struct scsi_device *device,
return 0;
}
static int ncr53c8xx_queue_command_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status ncr53c8xx_queue_command_lck(struct scsi_cmnd *cmd)
{
struct ncr_cmd_priv *cmd_priv = scsi_cmd_priv(cmd);
void (*done)(struct scsi_cmnd *) = scsi_done;

5
drivers/scsi/nsp32.c
View file

@ -185,7 +185,8 @@ static void __exit exit_nsp32 (void);
static int nsp32_show_info (struct seq_file *, struct Scsi_Host *);
static int nsp32_detect (struct pci_dev *pdev);
static int nsp32_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
static enum scsi_qc_status nsp32_queuecommand(struct Scsi_Host *,
struct scsi_cmnd *);
static const char *nsp32_info (struct Scsi_Host *);
static int nsp32_release (struct Scsi_Host *);
@ -905,7 +906,7 @@ static int nsp32_setup_sg_table(struct scsi_cmnd *SCpnt)
return TRUE;
}
static int nsp32_queuecommand_lck(struct scsi_cmnd *SCpnt)
static enum scsi_qc_status nsp32_queuecommand_lck(struct scsi_cmnd *SCpnt)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
nsp32_hw_data *data = (nsp32_hw_data *)SCpnt->device->host->hostdata;

2
drivers/scsi/pcmcia/nsp_cs.c
View file

@ -186,7 +186,7 @@ static void nsp_scsi_done(struct scsi_cmnd *SCpnt)
scsi_done(SCpnt);
}
static int nsp_queuecommand_lck(struct scsi_cmnd *const SCpnt)
static enum scsi_qc_status nsp_queuecommand_lck(struct scsi_cmnd *const SCpnt)
{
struct scsi_pointer *scsi_pointer = nsp_priv(SCpnt);
#ifdef NSP_DEBUG

3
drivers/scsi/pcmcia/nsp_cs.h
View file

@ -294,7 +294,8 @@ static struct Scsi_Host *nsp_detect (struct scsi_host_template *sht);
static const char *nsp_info (struct Scsi_Host *shpnt);
static int nsp_show_info (struct seq_file *m,
struct Scsi_Host *host);
static int nsp_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *SCpnt);
static enum scsi_qc_status nsp_queuecommand(struct Scsi_Host *h,
struct scsi_cmnd *SCpnt);
/* Error handler */
/*static int nsp_eh_abort (struct scsi_cmnd *SCpnt);*/

2
drivers/scsi/pcmcia/sym53c500_cs.c
View file

@ -544,7 +544,7 @@ SYM53C500_info(struct Scsi_Host *SChost)
return (info_msg);
}
static int SYM53C500_queue_lck(struct scsi_cmnd *SCpnt)
static enum scsi_qc_status SYM53C500_queue_lck(struct scsi_cmnd *SCpnt)
{
struct sym53c500_cmd_priv *scp = scsi_cmd_priv(SCpnt);
int i;

4
drivers/scsi/pmcraid.c
View file

@ -3242,14 +3242,14 @@ static int pmcraid_build_ioadl(
* SCSI_MLQUEUE_DEVICE_BUSY if device is busy
* SCSI_MLQUEUE_HOST_BUSY if host is busy
*/
static int pmcraid_queuecommand_lck(struct scsi_cmnd *scsi_cmd)
static enum scsi_qc_status pmcraid_queuecommand_lck(struct scsi_cmnd *scsi_cmd)
{
struct pmcraid_instance *pinstance;
struct pmcraid_resource_entry *res;
struct pmcraid_ioarcb *ioarcb;
enum scsi_qc_status rc = 0;
struct pmcraid_cmd *cmd;
u32 fw_version;
int rc = 0;
pinstance =
(struct pmcraid_instance *)scsi_cmd->device->host->hostdata;

2
drivers/scsi/ppa.c
View file

@ -816,7 +816,7 @@ static int ppa_engine(ppa_struct *dev, struct scsi_cmnd *cmd)
return 0;
}
static int ppa_queuecommand_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status ppa_queuecommand_lck(struct scsi_cmnd *cmd)
{
ppa_struct *dev = ppa_dev(cmd->device->host);

2
drivers/scsi/ps3rom.c
View file

@ -201,7 +201,7 @@ static int ps3rom_write_request(struct ps3_storage_device *dev,
return 0;
}
static int ps3rom_queuecommand_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status ps3rom_queuecommand_lck(struct scsi_cmnd *cmd)
{
struct ps3rom_private *priv = shost_priv(cmd->device->host);
struct ps3_storage_device *dev = priv->dev;

4
drivers/scsi/qedf/qedf.h
View file

@ -487,8 +487,8 @@ extern uint qedf_debug;
extern struct qedf_cmd_mgr *qedf_cmd_mgr_alloc(struct qedf_ctx *qedf);
extern void qedf_cmd_mgr_free(struct qedf_cmd_mgr *cmgr);
extern int qedf_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *sc_cmd);
extern enum scsi_qc_status qedf_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *sc_cmd);
extern void qedf_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb);
extern u8 *qedf_get_src_mac(struct fc_lport *lport);
extern void qedf_fip_recv(struct qedf_ctx *qedf, struct sk_buff *skb);

4
drivers/scsi/qedf/qedf_io.c
View file

@ -930,8 +930,8 @@ int qedf_post_io_req(struct qedf_rport *fcport, struct qedf_ioreq *io_req)
return false;
}
int
qedf_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc_cmd)
enum scsi_qc_status qedf_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *sc_cmd)
{
struct fc_lport *lport = shost_priv(host);
struct qedf_ctx *qedf = lport_priv(lport);

18
drivers/scsi/qla1280.c
View file

@ -406,9 +406,11 @@ static int qla1280_device_reset(struct scsi_qla_host *, int, int);
static int qla1280_abort_command(struct scsi_qla_host *, struct srb *, int);
static int qla1280_abort_isp(struct scsi_qla_host *);
#ifdef QLA_64BIT_PTR
static int qla1280_64bit_start_scsi(struct scsi_qla_host *, struct srb *);
static enum scsi_qc_status qla1280_64bit_start_scsi(struct scsi_qla_host *,
struct srb *);
#else
static int qla1280_32bit_start_scsi(struct scsi_qla_host *, struct srb *);
static enum scsi_qc_status qla1280_32bit_start_scsi(struct scsi_qla_host *,
struct srb *);
#endif
static void qla1280_nv_write(struct scsi_qla_host *, uint16_t);
static void qla1280_poll(struct scsi_qla_host *);
@ -682,12 +684,12 @@ qla1280_info(struct Scsi_Host *host)
* handling). Unfortunately, it sometimes calls the scheduler in interrupt
* context which is a big NO! NO!.
**************************************************************************/
static int qla1280_queuecommand_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status qla1280_queuecommand_lck(struct scsi_cmnd *cmd)
{
struct Scsi_Host *host = cmd->device->host;
struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
struct srb *sp = scsi_cmd_priv(cmd);
int status;
enum scsi_qc_status status;
sp->cmd = cmd;
sp->flags = 0;
@ -2730,7 +2732,7 @@ qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type)
* 0 = success, was able to issue command.
*/
#ifdef QLA_64BIT_PTR
static int
static enum scsi_qc_status
qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
{
struct device_reg __iomem *reg = ha->iobase;
@ -2738,7 +2740,7 @@ qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
cmd_a64_entry_t *pkt;
__le32 *dword_ptr;
dma_addr_t dma_handle;
int status = 0;
enum scsi_qc_status status = 0;
int cnt;
int req_cnt;
int seg_cnt;
@ -2984,14 +2986,14 @@ qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
* Returns:
* 0 = success, was able to issue command.
*/
static int
static enum scsi_qc_status
qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
{
struct device_reg __iomem *reg = ha->iobase;
struct scsi_cmnd *cmd = sp->cmd;
struct cmd_entry *pkt;
__le32 *dword_ptr;
int status = 0;
enum scsi_qc_status status = 0;
int cnt;
int req_cnt;
int seg_cnt;

13
drivers/scsi/qla2xxx/qla_os.c
View file

@ -402,8 +402,9 @@ static int qla2x00_mem_alloc(struct qla_hw_data *, uint16_t, uint16_t,
struct req_que **, struct rsp_que **);
static void qla2x00_free_fw_dump(struct qla_hw_data *);
static void qla2x00_mem_free(struct qla_hw_data *);
static int qla2xxx_mqueuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd,
struct qla_qpair *qpair);
static enum scsi_qc_status qla2xxx_mqueuecommand(struct Scsi_Host *host,
struct scsi_cmnd *cmd,
struct qla_qpair *qpair);
/* -------------------------------------------------------------------------- */
static void qla_init_base_qpair(struct scsi_qla_host *vha, struct req_que *req,
@ -858,8 +859,8 @@ void qla2xxx_qpair_sp_compl(srb_t *sp, int res)
complete(comp);
}
static int
qla2xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
static enum scsi_qc_status qla2xxx_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *cmd)
{
scsi_qla_host_t *vha = shost_priv(host);
fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
@ -981,9 +982,9 @@ qc24_fail_command:
}
/* For MQ supported I/O */
static int
static enum scsi_qc_status
qla2xxx_mqueuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd,
struct qla_qpair *qpair)
struct qla_qpair *qpair)
{
scsi_qla_host_t *vha = shost_priv(host);
fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;

6
drivers/scsi/qla4xxx/ql4_os.c
View file

@ -155,7 +155,8 @@ static int qla4xxx_get_host_stats(struct Scsi_Host *shost, char *buf, int len);
/*
* SCSI host template entry points
*/
static int qla4xxx_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmd);
static enum scsi_qc_status qla4xxx_queuecommand(struct Scsi_Host *h,
struct scsi_cmnd *cmd);
static int qla4xxx_eh_abort(struct scsi_cmnd *cmd);
static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd);
static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd);
@ -4107,7 +4108,8 @@ void qla4xxx_srb_compl(struct kref *ref)
* completion handling). Unfortunately, it sometimes calls the scheduler
* in interrupt context which is a big NO! NO!.
**/
static int qla4xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
static enum scsi_qc_status qla4xxx_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *cmd)
{
struct scsi_qla_host *ha = to_qla_host(host);
struct ddb_entry *ddb_entry = cmd->device->hostdata;

2
drivers/scsi/qlogicfas408.c
View file

@ -464,7 +464,7 @@ irqreturn_t qlogicfas408_ihandl(int irq, void *dev_id)
* Queued command
*/
static int qlogicfas408_queuecommand_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status qlogicfas408_queuecommand_lck(struct scsi_cmnd *cmd)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);

3
drivers/scsi/qlogicfas408.h
View file

@ -104,7 +104,8 @@ struct qlogicfas408_priv {
#define get_priv_by_host(x) (struct qlogicfas408_priv *)&((x)->hostdata[0])
irqreturn_t qlogicfas408_ihandl(int irq, void *dev_id);
int qlogicfas408_queuecommand(struct Scsi_Host *h, struct scsi_cmnd * cmd);
enum scsi_qc_status qlogicfas408_queuecommand(struct Scsi_Host *h,
struct scsi_cmnd *cmd);
int qlogicfas408_biosparam(struct scsi_device * disk,
struct gendisk *unused,
sector_t capacity, int ip[]);

2
drivers/scsi/qlogicpti.c
View file

@ -1015,7 +1015,7 @@ static int qlogicpti_sdev_configure(struct scsi_device *sdev,
*
* "This code must fly." -davem
*/
static int qlogicpti_queuecommand_lck(struct scsi_cmnd *Cmnd)
static enum scsi_qc_status qlogicpti_queuecommand_lck(struct scsi_cmnd *Cmnd)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
struct Scsi_Host *host = Cmnd->device->host;

9
drivers/scsi/scsi_debug.c
View file

@ -9284,8 +9284,9 @@ static void scsi_debug_abort_cmd(struct Scsi_Host *shost, struct scsi_cmnd *scp)
set_host_byte(scp, res ? DID_OK : DID_ERROR);
}
static int scsi_debug_process_reserved_command(struct Scsi_Host *shost,
struct scsi_cmnd *scp)
static enum scsi_qc_status
scsi_debug_process_reserved_command(struct Scsi_Host *shost,
struct scsi_cmnd *scp)
{
struct sdebug_internal_cmd *internal_cmd = scsi_cmd_priv(scp);
@ -9303,8 +9304,8 @@ static int scsi_debug_process_reserved_command(struct Scsi_Host *shost,
return 0;
}
static int scsi_debug_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scp)
static enum scsi_qc_status scsi_debug_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *scp)
{
u8 sdeb_i;
struct scsi_device *sdp = scp->device;

3
drivers/scsi/smartpqi/smartpqi_init.c
View file

@ -6047,7 +6047,8 @@ static bool pqi_is_parity_write_stream(struct pqi_ctrl_info *ctrl_info,
return false;
}
static int pqi_scsi_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
static enum scsi_qc_status pqi_scsi_queue_command(struct Scsi_Host *shost,
struct scsi_cmnd *scmd)
{
int rc;
struct pqi_ctrl_info *ctrl_info;

3
drivers/scsi/snic/snic.h
View file

@ -362,7 +362,8 @@ void snic_glob_cleanup(void);
extern struct workqueue_struct *snic_event_queue;
extern const struct attribute_group *snic_host_groups[];
int snic_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
enum scsi_qc_status snic_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *sc);
int snic_abort_cmd(struct scsi_cmnd *);
int snic_device_reset(struct scsi_cmnd *);
int snic_host_reset(struct scsi_cmnd *);

4
drivers/scsi/snic/snic_scsi.c
View file

@ -315,8 +315,8 @@ issue_sc_end:
* Routine to send a scsi cdb to LLD
* Called with host_lock held and interrupts disabled
*/
int
snic_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc)
enum scsi_qc_status snic_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *sc)
{
struct snic_tgt *tgt = NULL;
struct snic *snic = shost_priv(shost);

2
drivers/scsi/stex.c
View file

@ -593,7 +593,7 @@ stex_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)
return 0;
}
static int stex_queuecommand_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status stex_queuecommand_lck(struct scsi_cmnd *cmd)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
struct st_hba *hba;

3
drivers/scsi/storvsc_drv.c
View file

@ -1714,7 +1714,8 @@ static bool storvsc_scsi_cmd_ok(struct scsi_cmnd *scmnd)
return allowed;
}
static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
static enum scsi_qc_status storvsc_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *scmnd)
{
int ret;
struct hv_host_device *host_dev = shost_priv(host);

2
drivers/scsi/sym53c8xx_2/sym_glue.c
View file

@ -485,7 +485,7 @@ void sym_log_bus_error(struct Scsi_Host *shost)
* queuecommand method. Entered with the host adapter lock held and
* interrupts disabled.
*/
static int sym53c8xx_queue_command_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status sym53c8xx_queue_command_lck(struct scsi_cmnd *cmd)
{
struct sym_hcb *np = SYM_SOFTC_PTR(cmd);
struct sym_ucmd *ucp = SYM_UCMD_PTR(cmd);

4
drivers/scsi/virtio_scsi.c
View file

@ -561,8 +561,8 @@ static struct virtio_scsi_vq *virtscsi_pick_vq_mq(struct virtio_scsi *vscsi,
return &vscsi->req_vqs[hwq];
}
static int virtscsi_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *sc)
static enum scsi_qc_status virtscsi_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *sc)
{
struct virtio_scsi *vscsi = shost_priv(shost);
struct virtio_scsi_vq *req_vq = virtscsi_pick_vq_mq(vscsi, sc);

2
drivers/scsi/vmw_pvscsi.c
View file

@ -771,7 +771,7 @@ static int pvscsi_queue_ring(struct pvscsi_adapter *adapter,
return 0;
}
static int pvscsi_queue_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status pvscsi_queue_lck(struct scsi_cmnd *cmd)
{
struct Scsi_Host *host = cmd->device->host;
struct pvscsi_adapter *adapter = shost_priv(host);

2
drivers/scsi/wd33c93.c
View file

@ -302,7 +302,7 @@ calc_sync_msg(unsigned int period, unsigned int offset, unsigned int fast,
msg[1] = offset;
}
static int wd33c93_queuecommand_lck(struct scsi_cmnd *cmd)
static enum scsi_qc_status wd33c93_queuecommand_lck(struct scsi_cmnd *cmd)
{
struct scsi_pointer *scsi_pointer = WD33C93_scsi_pointer(cmd);
struct WD33C93_hostdata *hostdata;

3
drivers/scsi/wd33c93.h
View file

@ -332,7 +332,8 @@ static inline struct scsi_pointer *WD33C93_scsi_pointer(struct scsi_cmnd *cmd)
void wd33c93_init (struct Scsi_Host *instance, const wd33c93_regs regs,
dma_setup_t setup, dma_stop_t stop, int clock_freq);
int wd33c93_abort (struct scsi_cmnd *cmd);
int wd33c93_queuecommand (struct Scsi_Host *h, struct scsi_cmnd *cmd);
enum scsi_qc_status wd33c93_queuecommand(struct Scsi_Host *h,
struct scsi_cmnd *cmd);
void wd33c93_intr (struct Scsi_Host *instance);
int wd33c93_show_info(struct seq_file *, struct Scsi_Host *);
int wd33c93_write_info(struct Scsi_Host *, char *, int);

3
drivers/scsi/wd719x.c
View file

@ -204,7 +204,8 @@ static void wd719x_finish_cmd(struct wd719x_scb *scb, int result)
}
/* Build a SCB and send it to the card */
static int wd719x_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
static enum scsi_qc_status wd719x_queuecommand(struct Scsi_Host *sh,
struct scsi_cmnd *cmd)
{
int i, count_sg;
unsigned long flags;

4
drivers/scsi/xen-scsifront.c
View file

@ -603,8 +603,8 @@ static void scsifront_return(struct vscsifrnt_info *info)
wake_up(&info->wq_pause);
}
static int scsifront_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *sc)
static enum scsi_qc_status scsifront_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *sc)
{
struct vscsifrnt_info *info = shost_priv(shost);
struct vscsifrnt_shadow *shadow = scsi_cmd_priv(sc);

3
drivers/target/loopback/tcm_loop.c
View file

@ -165,7 +165,8 @@ out_done:
* ->queuecommand can be and usually is called from interrupt context, so
* defer the actual submission to a workqueue.
*/
static int tcm_loop_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *sc)
static enum scsi_qc_status tcm_loop_queuecommand(struct Scsi_Host *sh,
struct scsi_cmnd *sc)
{
struct tcm_loop_cmd *tl_cmd = scsi_cmd_priv(sc);

7
drivers/ufs/core/ufshcd.c
View file

@ -3033,7 +3033,8 @@ static int ufshcd_init_cmd_priv(struct Scsi_Host *host, struct scsi_cmnd *cmd)
*
* Return: 0 for success, non-zero in case of failure.
*/
static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
static enum scsi_qc_status ufshcd_queuecommand(struct Scsi_Host *host,
struct scsi_cmnd *cmd)
{
struct ufs_hba *hba = shost_priv(host);
int tag = scsi_cmd_to_rq(cmd)->tag;
@ -3113,8 +3114,8 @@ out:
return err;
}
static int ufshcd_queue_reserved_command(struct Scsi_Host *host,
struct scsi_cmnd *cmd)
static enum scsi_qc_status ufshcd_queue_reserved_command(struct Scsi_Host *host,
struct scsi_cmnd *cmd)
{
struct ufshcd_lrb *lrbp = scsi_cmd_priv(cmd);
struct request *rq = scsi_cmd_to_rq(cmd);

6
drivers/usb/image/microtek.c
View file

@ -355,8 +355,8 @@ static int mts_scsi_host_reset(struct scsi_cmnd *srb)
return result ? FAILED : SUCCESS;
}
static int
mts_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *srb);
static enum scsi_qc_status mts_scsi_queuecommand(struct Scsi_Host *shost,
struct scsi_cmnd *srb);
static void mts_transfer_cleanup( struct urb *transfer );
static void mts_do_sg(struct urb * transfer);
@ -559,7 +559,7 @@ mts_build_transfer_context(struct scsi_cmnd *srb, struct mts_desc* desc)
desc->context.data_pipe = pipe;
}
static int mts_scsi_queuecommand_lck(struct scsi_cmnd *srb)
static enum scsi_qc_status mts_scsi_queuecommand_lck(struct scsi_cmnd *srb)
{
mts_scsi_cmnd_callback callback = scsi_done;
struct mts_desc* desc = (struct mts_desc*)(srb->device->host->hostdata[0]);

2
drivers/usb/storage/scsiglue.c
View file

@ -357,7 +357,7 @@ static int target_alloc(struct scsi_target *starget)
/* queue a command */
/* This is always called with scsi_lock(host) held */
static int queuecommand_lck(struct scsi_cmnd *srb)
static enum scsi_qc_status queuecommand_lck(struct scsi_cmnd *srb)
{
void (*done)(struct scsi_cmnd *) = scsi_done;
struct us_data *us = host_to_us(srb->device->host);

2
drivers/usb/storage/uas.c
View file

@ -636,7 +636,7 @@ static int uas_submit_urbs(struct scsi_cmnd *cmnd,
return 0;
}
static int uas_queuecommand_lck(struct scsi_cmnd *cmnd)
static enum scsi_qc_status uas_queuecommand_lck(struct scsi_cmnd *cmnd)
{
struct scsi_device *sdev = cmnd->device;
struct uas_dev_info *devinfo = sdev->hostdata;

3
include/linux/libata.h
View file

@ -1150,7 +1150,8 @@ extern int ata_scsi_ioctl(struct scsi_device *dev, unsigned int cmd,
#else
#define ATA_SCSI_COMPAT_IOCTL /* empty */
#endif
extern int ata_scsi_queuecmd(struct Scsi_Host *h, struct scsi_cmnd *cmd);
extern enum scsi_qc_status ata_scsi_queuecmd(struct Scsi_Host *h,
struct scsi_cmnd *cmd);
#if IS_REACHABLE(CONFIG_ATA)
bool ata_scsi_dma_need_drain(struct request *rq);
#else

Some files were not shown because too many files have changed in this diff Show more