Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-09-20 23:13:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

scsi: fdomain: Move the SCSI pointer to private command data

Browse Source 
Set .cmd_size in the SCSI host template instead of using the SCSI pointer
from struct scsi_cmnd. This patch prepares for removal of the SCSI pointer
from struct scsi_cmnd.

Link: https://lore.kernel.org/r/20220218195117.25689-21-bvanassche@acm.org
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Reviewed-by: Himanshu Madhani <himanshu.madhani@oracle.com>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
This commit is contained in:
Bart Van Assche 2022-02-18 11:50:48 -08:00 committed by Martin K. Petersen
parent dfae39874f
commit 211134c47c
1 changed files with 36 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
drivers/scsi/fdomain.c
View File

@ -115,6 +115,11 @@ struct fdomain {
struct work_struct work; struct work_struct work;
}; };
static struct scsi_pointer *fdomain_scsi_pointer(struct scsi_cmnd *cmd)
{
return scsi_cmd_priv(cmd);
}
static inline void fdomain_make_bus_idle(struct fdomain *fd) static inline void fdomain_make_bus_idle(struct fdomain *fd)
{ {
outb(0, fd->base + REG_BCTL); outb(0, fd->base + REG_BCTL);
@ -263,20 +268,21 @@ static void fdomain_work(struct work_struct *work)
struct Scsi_Host *sh = container_of((void *)fd, struct Scsi_Host, struct Scsi_Host *sh = container_of((void *)fd, struct Scsi_Host,
hostdata); hostdata);
struct scsi_cmnd *cmd = fd->cur_cmd; struct scsi_cmnd *cmd = fd->cur_cmd;
struct scsi_pointer *scsi_pointer = fdomain_scsi_pointer(cmd);
unsigned long flags; unsigned long flags;
int status; int status;
int done = 0; int done = 0;
spin_lock_irqsave(sh->host_lock, flags); spin_lock_irqsave(sh->host_lock, flags);
if (cmd->SCp.phase & in_arbitration) { if (scsi_pointer->phase & in_arbitration) {
status = inb(fd->base + REG_ASTAT); status = inb(fd->base + REG_ASTAT);
if (!(status & ASTAT_ARB)) { if (!(status & ASTAT_ARB)) {
set_host_byte(cmd, DID_BUS_BUSY); set_host_byte(cmd, DID_BUS_BUSY);
fdomain_finish_cmd(fd); fdomain_finish_cmd(fd);
goto out; goto out;
} }
cmd->SCp.phase = in_selection; scsi_pointer->phase = in_selection;
outb(ICTL_SEL | FIFO_COUNT, fd->base + REG_ICTL); outb(ICTL_SEL | FIFO_COUNT, fd->base + REG_ICTL);
outb(BCTL_BUSEN | BCTL_SEL, fd->base + REG_BCTL); outb(BCTL_BUSEN | BCTL_SEL, fd->base + REG_BCTL);
@ -285,7 +291,7 @@ static void fdomain_work(struct work_struct *work)
/* Stop arbitration and enable parity */ /* Stop arbitration and enable parity */
outb(ACTL_IRQEN | PARITY_MASK, fd->base + REG_ACTL); outb(ACTL_IRQEN | PARITY_MASK, fd->base + REG_ACTL);
goto out; goto out;
} else if (cmd->SCp.phase & in_selection) { } else if (scsi_pointer->phase & in_selection) {
status = inb(fd->base + REG_BSTAT); status = inb(fd->base + REG_BSTAT);
if (!(status & BSTAT_BSY)) { if (!(status & BSTAT_BSY)) {
/* Try again, for slow devices */ /* Try again, for slow devices */
@ -297,75 +303,75 @@ static void fdomain_work(struct work_struct *work)
/* Stop arbitration and enable parity */ /* Stop arbitration and enable parity */
outb(ACTL_IRQEN | PARITY_MASK, fd->base + REG_ACTL); outb(ACTL_IRQEN | PARITY_MASK, fd->base + REG_ACTL);
} }
cmd->SCp.phase = in_other; scsi_pointer->phase = in_other;
outb(ICTL_FIFO | ICTL_REQ | FIFO_COUNT, fd->base + REG_ICTL); outb(ICTL_FIFO | ICTL_REQ | FIFO_COUNT, fd->base + REG_ICTL);
outb(BCTL_BUSEN, fd->base + REG_BCTL); outb(BCTL_BUSEN, fd->base + REG_BCTL);
goto out; goto out;
} }
/* cur_cmd->SCp.phase == in_other: this is the body of the routine */ /* fdomain_scsi_pointer(cur_cmd)->phase == in_other: this is the body of the routine */
status = inb(fd->base + REG_BSTAT); status = inb(fd->base + REG_BSTAT);
if (status & BSTAT_REQ) { if (status & BSTAT_REQ) {
switch (status & (BSTAT_MSG | BSTAT_CMD | BSTAT_IO)) { switch (status & (BSTAT_MSG | BSTAT_CMD | BSTAT_IO)) {
case BSTAT_CMD: /* COMMAND OUT */ case BSTAT_CMD: /* COMMAND OUT */
outb(cmd->cmnd[cmd->SCp.sent_command++], outb(cmd->cmnd[scsi_pointer->sent_command++],
fd->base + REG_SCSI_DATA); fd->base + REG_SCSI_DATA);
break; break;
case 0: /* DATA OUT -- tmc18c50/tmc18c30 only */ case 0: /* DATA OUT -- tmc18c50/tmc18c30 only */
if (fd->chip != tmc1800 && !cmd->SCp.have_data_in) { if (fd->chip != tmc1800 && !scsi_pointer->have_data_in) {
cmd->SCp.have_data_in = -1; scsi_pointer->have_data_in = -1;
outb(ACTL_IRQEN | ACTL_FIFOWR | ACTL_FIFOEN | outb(ACTL_IRQEN | ACTL_FIFOWR | ACTL_FIFOEN |
PARITY_MASK, fd->base + REG_ACTL); PARITY_MASK, fd->base + REG_ACTL);
} }
break; break;
case BSTAT_IO: /* DATA IN -- tmc18c50/tmc18c30 only */ case BSTAT_IO: /* DATA IN -- tmc18c50/tmc18c30 only */
if (fd->chip != tmc1800 && !cmd->SCp.have_data_in) { if (fd->chip != tmc1800 && !scsi_pointer->have_data_in) {
cmd->SCp.have_data_in = 1; scsi_pointer->have_data_in = 1;
outb(ACTL_IRQEN | ACTL_FIFOEN | PARITY_MASK, outb(ACTL_IRQEN | ACTL_FIFOEN | PARITY_MASK,
fd->base + REG_ACTL); fd->base + REG_ACTL);
} }
break; break;
case BSTAT_CMD | BSTAT_IO: /* STATUS IN */ case BSTAT_CMD | BSTAT_IO: /* STATUS IN */
cmd->SCp.Status = inb(fd->base + REG_SCSI_DATA); scsi_pointer->Status = inb(fd->base + REG_SCSI_DATA);
break; break;
case BSTAT_MSG | BSTAT_CMD: /* MESSAGE OUT */ case BSTAT_MSG | BSTAT_CMD: /* MESSAGE OUT */
outb(MESSAGE_REJECT, fd->base + REG_SCSI_DATA); outb(MESSAGE_REJECT, fd->base + REG_SCSI_DATA);
break; break;
case BSTAT_MSG | BSTAT_CMD | BSTAT_IO: /* MESSAGE IN */ case BSTAT_MSG | BSTAT_CMD | BSTAT_IO: /* MESSAGE IN */
cmd->SCp.Message = inb(fd->base + REG_SCSI_DATA); scsi_pointer->Message = inb(fd->base + REG_SCSI_DATA);
if (cmd->SCp.Message == COMMAND_COMPLETE) if (scsi_pointer->Message == COMMAND_COMPLETE)
++done; ++done;
break; break;
} }
} }
if (fd->chip == tmc1800 && !cmd->SCp.have_data_in && if (fd->chip == tmc1800 && !scsi_pointer->have_data_in &&
cmd->SCp.sent_command >= cmd->cmd_len) { scsi_pointer->sent_command >= cmd->cmd_len) {
if (cmd->sc_data_direction == DMA_TO_DEVICE) { if (cmd->sc_data_direction == DMA_TO_DEVICE) {
cmd->SCp.have_data_in = -1; scsi_pointer->have_data_in = -1;
outb(ACTL_IRQEN | ACTL_FIFOWR | ACTL_FIFOEN | outb(ACTL_IRQEN | ACTL_FIFOWR | ACTL_FIFOEN |
PARITY_MASK, fd->base + REG_ACTL); PARITY_MASK, fd->base + REG_ACTL);
} else { } else {
cmd->SCp.have_data_in = 1; scsi_pointer->have_data_in = 1;
outb(ACTL_IRQEN | ACTL_FIFOEN | PARITY_MASK, outb(ACTL_IRQEN | ACTL_FIFOEN | PARITY_MASK,
fd->base + REG_ACTL); fd->base + REG_ACTL);
} }
} }
if (cmd->SCp.have_data_in == -1) /* DATA OUT */ if (scsi_pointer->have_data_in == -1) /* DATA OUT */
fdomain_write_data(cmd); fdomain_write_data(cmd);
if (cmd->SCp.have_data_in == 1) /* DATA IN */ if (scsi_pointer->have_data_in == 1) /* DATA IN */
fdomain_read_data(cmd); fdomain_read_data(cmd);
if (done) { if (done) {
set_status_byte(cmd, cmd->SCp.Status); set_status_byte(cmd, scsi_pointer->Status);
set_host_byte(cmd, DID_OK); set_host_byte(cmd, DID_OK);
scsi_msg_to_host_byte(cmd, cmd->SCp.Message); scsi_msg_to_host_byte(cmd, scsi_pointer->Message);
fdomain_finish_cmd(fd); fdomain_finish_cmd(fd);
} else { } else {
if (cmd->SCp.phase & disconnect) { if (scsi_pointer->phase & disconnect) {
outb(ICTL_FIFO | ICTL_SEL | ICTL_REQ | FIFO_COUNT, outb(ICTL_FIFO | ICTL_SEL | ICTL_REQ | FIFO_COUNT,
fd->base + REG_ICTL); fd->base + REG_ICTL);
outb(0, fd->base + REG_BCTL); outb(0, fd->base + REG_BCTL);
@ -398,14 +404,15 @@ static irqreturn_t fdomain_irq(int irq, void *dev_id)
static int fdomain_queue(struct Scsi_Host *sh, struct scsi_cmnd *cmd) static int 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); struct fdomain *fd = shost_priv(cmd->device->host);
unsigned long flags; unsigned long flags;
cmd->SCp.Status = 0; scsi_pointer->Status = 0;
cmd->SCp.Message = 0; scsi_pointer->Message = 0;
cmd->SCp.have_data_in = 0; scsi_pointer->have_data_in = 0;
cmd->SCp.sent_command = 0; scsi_pointer->sent_command = 0;
cmd->SCp.phase = in_arbitration; scsi_pointer->phase = in_arbitration;
scsi_set_resid(cmd, scsi_bufflen(cmd)); scsi_set_resid(cmd, scsi_bufflen(cmd));
spin_lock_irqsave(sh->host_lock, flags); spin_lock_irqsave(sh->host_lock, flags);
@ -440,7 +447,7 @@ static int fdomain_abort(struct scsi_cmnd *cmd)
spin_lock_irqsave(sh->host_lock, flags); spin_lock_irqsave(sh->host_lock, flags);
fdomain_make_bus_idle(fd); fdomain_make_bus_idle(fd);
fd->cur_cmd->SCp.phase |= aborted; fdomain_scsi_pointer(fd->cur_cmd)->phase |= aborted;
/* Aborts are not done well. . . */ /* Aborts are not done well. . . */
set_host_byte(fd->cur_cmd, DID_ABORT); set_host_byte(fd->cur_cmd, DID_ABORT);
@ -501,6 +508,7 @@ static struct scsi_host_template fdomain_template = {
.this_id = 7, .this_id = 7,
.sg_tablesize = 64, .sg_tablesize = 64,
.dma_boundary = PAGE_SIZE - 1, .dma_boundary = PAGE_SIZE - 1,
.cmd_size = sizeof(struct scsi_pointer),
}; };
struct Scsi_Host *fdomain_create(int base, int irq, int this_id, struct Scsi_Host *fdomain_create(int base, int irq, int this_id,