evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[SCSI] remove cmd->serial_number litter

Browse source 
Stop using cmd->serial_number in printks.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
This commit is contained in:
Christoph Hellwig 2011-04-04 09:42:14 -04:00 • committed by James Bottomley
parent f04ca1b654
commit 5cd049a599
17 changed files with 255 additions and 286 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
drivers/message/i2o/i2o_scsi.c
View file

@ -361,7 +361,7 @@ static int i2o_scsi_reply(struct i2o_controller *c, u32 m,
*/ */
error = le32_to_cpu(msg->body[0]); error = le32_to_cpu(msg->body[0]);
osm_debug("Completed %ld\n", cmd->serial_number); osm_debug("Completed %0x%p\n", cmd);
cmd->result = error & 0xff; cmd->result = error & 0xff;
/* /*
@ -678,7 +678,7 @@ static int i2o_scsi_queuecommand_lck(struct scsi_cmnd *SCpnt,
/* Queue the message */ /* Queue the message */
i2o_msg_post(c, msg); i2o_msg_post(c, msg);
osm_debug("Issued %ld\n", SCpnt->serial_number); osm_debug("Issued %0x%p\n", SCpnt);
return 0; return 0;

193
drivers/scsi/dc395x.c
View file

@ -778,8 +778,8 @@ static void srb_free_insert(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb)
static void srb_waiting_insert(struct DeviceCtlBlk *dcb, static void srb_waiting_insert(struct DeviceCtlBlk *dcb,
struct ScsiReqBlk *srb) struct ScsiReqBlk *srb)
{ {
dprintkdbg(DBG_0, "srb_waiting_insert: (pid#%li) <%02i-%i> srb=%p\n", dprintkdbg(DBG_0, "srb_waiting_insert: (0x%p) <%02i-%i> srb=%p\n",
srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); srb->cmd, dcb->target_id, dcb->target_lun, srb);
list_add(&srb->list, &dcb->srb_waiting_list); list_add(&srb->list, &dcb->srb_waiting_list);
} }
@ -787,16 +787,16 @@ static void srb_waiting_insert(struct DeviceCtlBlk *dcb,
static void srb_waiting_append(struct DeviceCtlBlk *dcb, static void srb_waiting_append(struct DeviceCtlBlk *dcb,
struct ScsiReqBlk *srb) struct ScsiReqBlk *srb)
{ {
dprintkdbg(DBG_0, "srb_waiting_append: (pid#%li) <%02i-%i> srb=%p\n", dprintkdbg(DBG_0, "srb_waiting_append: (0x%p) <%02i-%i> srb=%p\n",
srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); srb->cmd, dcb->target_id, dcb->target_lun, srb);
list_add_tail(&srb->list, &dcb->srb_waiting_list); list_add_tail(&srb->list, &dcb->srb_waiting_list);
} }
static void srb_going_append(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb) static void srb_going_append(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)
{ {
dprintkdbg(DBG_0, "srb_going_append: (pid#%li) <%02i-%i> srb=%p\n", dprintkdbg(DBG_0, "srb_going_append: (0x%p) <%02i-%i> srb=%p\n",
srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); srb->cmd, dcb->target_id, dcb->target_lun, srb);
list_add_tail(&srb->list, &dcb->srb_going_list); list_add_tail(&srb->list, &dcb->srb_going_list);
} }
@ -805,8 +805,8 @@ static void srb_going_remove(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)
{ {
struct ScsiReqBlk *i; struct ScsiReqBlk *i;
struct ScsiReqBlk *tmp; struct ScsiReqBlk *tmp;
dprintkdbg(DBG_0, "srb_going_remove: (pid#%li) <%02i-%i> srb=%p\n", dprintkdbg(DBG_0, "srb_going_remove: (0x%p) <%02i-%i> srb=%p\n",
srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); srb->cmd, dcb->target_id, dcb->target_lun, srb);
list_for_each_entry_safe(i, tmp, &dcb->srb_going_list, list) list_for_each_entry_safe(i, tmp, &dcb->srb_going_list, list)
if (i == srb) { if (i == srb) {
@ -821,8 +821,8 @@ static void srb_waiting_remove(struct DeviceCtlBlk *dcb,
{ {
struct ScsiReqBlk *i; struct ScsiReqBlk *i;
struct ScsiReqBlk *tmp; struct ScsiReqBlk *tmp;
dprintkdbg(DBG_0, "srb_waiting_remove: (pid#%li) <%02i-%i> srb=%p\n", dprintkdbg(DBG_0, "srb_waiting_remove: (0x%p) <%02i-%i> srb=%p\n",
srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); srb->cmd, dcb->target_id, dcb->target_lun, srb);
list_for_each_entry_safe(i, tmp, &dcb->srb_waiting_list, list) list_for_each_entry_safe(i, tmp, &dcb->srb_waiting_list, list)
if (i == srb) { if (i == srb) {
@ -836,8 +836,8 @@ static void srb_going_to_waiting_move(struct DeviceCtlBlk *dcb,
struct ScsiReqBlk *srb) struct ScsiReqBlk *srb)
{ {
dprintkdbg(DBG_0, dprintkdbg(DBG_0,
"srb_going_to_waiting_move: (pid#%li) <%02i-%i> srb=%p\n", "srb_going_to_waiting_move: (0x%p) <%02i-%i> srb=%p\n",
srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); srb->cmd, dcb->target_id, dcb->target_lun, srb);
list_move(&srb->list, &dcb->srb_waiting_list); list_move(&srb->list, &dcb->srb_waiting_list);
} }
@ -846,8 +846,8 @@ static void srb_waiting_to_going_move(struct DeviceCtlBlk *dcb,
struct ScsiReqBlk *srb) struct ScsiReqBlk *srb)
{ {
dprintkdbg(DBG_0, dprintkdbg(DBG_0,
"srb_waiting_to_going_move: (pid#%li) <%02i-%i> srb=%p\n", "srb_waiting_to_going_move: (0x%p) <%02i-%i> srb=%p\n",
srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); srb->cmd, dcb->target_id, dcb->target_lun, srb);
list_move(&srb->list, &dcb->srb_going_list); list_move(&srb->list, &dcb->srb_going_list);
} }
@ -982,8 +982,8 @@ static void build_srb(struct scsi_cmnd *cmd, struct DeviceCtlBlk *dcb,
{ {
int nseg; int nseg;
enum dma_data_direction dir = cmd->sc_data_direction; enum dma_data_direction dir = cmd->sc_data_direction;
dprintkdbg(DBG_0, "build_srb: (pid#%li) <%02i-%i>\n", dprintkdbg(DBG_0, "build_srb: (0x%p) <%02i-%i>\n",
cmd->serial_number, dcb->target_id, dcb->target_lun); cmd, dcb->target_id, dcb->target_lun);
srb->dcb = dcb; srb->dcb = dcb;
srb->cmd = cmd; srb->cmd = cmd;
@ -1086,8 +1086,8 @@ static int dc395x_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct s
struct ScsiReqBlk *srb; struct ScsiReqBlk *srb;
struct AdapterCtlBlk *acb = struct AdapterCtlBlk *acb =
(struct AdapterCtlBlk *)cmd->device->host->hostdata; (struct AdapterCtlBlk *)cmd->device->host->hostdata;
dprintkdbg(DBG_0, "queue_command: (pid#%li) <%02i-%i> cmnd=0x%02x\n", dprintkdbg(DBG_0, "queue_command: (0x%p) <%02i-%i> cmnd=0x%02x\n",
cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); cmd, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
/* Assume BAD_TARGET; will be cleared later */ /* Assume BAD_TARGET; will be cleared later */
cmd->result = DID_BAD_TARGET << 16; cmd->result = DID_BAD_TARGET << 16;
@ -1140,7 +1140,7 @@ static int dc395x_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct s
/* process immediately */ /* process immediately */
send_srb(acb, srb); send_srb(acb, srb);
} }
dprintkdbg(DBG_1, "queue_command: (pid#%li) done\n", cmd->serial_number); dprintkdbg(DBG_1, "queue_command: (0x%p) done\n", cmd);
return 0; return 0;
complete: complete:
@ -1203,9 +1203,9 @@ static void dump_register_info(struct AdapterCtlBlk *acb,
dprintkl(KERN_INFO, "dump: srb=%p cmd=%p OOOPS!\n", dprintkl(KERN_INFO, "dump: srb=%p cmd=%p OOOPS!\n",
srb, srb->cmd); srb, srb->cmd);
else else
dprintkl(KERN_INFO, "dump: srb=%p cmd=%p (pid#%li) " dprintkl(KERN_INFO, "dump: srb=%p cmd=%p "
"cmnd=0x%02x <%02i-%i>\n", "cmnd=0x%02x <%02i-%i>\n",
srb, srb->cmd, srb->cmd->serial_number, srb, srb->cmd,
srb->cmd->cmnd[0], srb->cmd->device->id, srb->cmd->cmnd[0], srb->cmd->device->id,
srb->cmd->device->lun); srb->cmd->device->lun);
printk(" sglist=%p cnt=%i idx=%i len=%zu\n", printk(" sglist=%p cnt=%i idx=%i len=%zu\n",
@ -1301,8 +1301,8 @@ static int __dc395x_eh_bus_reset(struct scsi_cmnd *cmd)
struct AdapterCtlBlk *acb = struct AdapterCtlBlk *acb =
(struct AdapterCtlBlk *)cmd->device->host->hostdata; (struct AdapterCtlBlk *)cmd->device->host->hostdata;
dprintkl(KERN_INFO, dprintkl(KERN_INFO,
"eh_bus_reset: (pid#%li) target=<%02i-%i> cmd=%p\n", "eh_bus_reset: (0%p) target=<%02i-%i> cmd=%p\n",
cmd->serial_number, cmd->device->id, cmd->device->lun, cmd); cmd, cmd->device->id, cmd->device->lun, cmd);
if (timer_pending(&acb->waiting_timer)) if (timer_pending(&acb->waiting_timer))
del_timer(&acb->waiting_timer); del_timer(&acb->waiting_timer);
@ -1368,8 +1368,8 @@ static int dc395x_eh_abort(struct scsi_cmnd *cmd)
(struct AdapterCtlBlk *)cmd->device->host->hostdata; (struct AdapterCtlBlk *)cmd->device->host->hostdata;
struct DeviceCtlBlk *dcb; struct DeviceCtlBlk *dcb;
struct ScsiReqBlk *srb; struct ScsiReqBlk *srb;
dprintkl(KERN_INFO, "eh_abort: (pid#%li) target=<%02i-%i> cmd=%p\n", dprintkl(KERN_INFO, "eh_abort: (0x%p) target=<%02i-%i> cmd=%p\n",
cmd->serial_number, cmd->device->id, cmd->device->lun, cmd); cmd, cmd->device->id, cmd->device->lun, cmd);
dcb = find_dcb(acb, cmd->device->id, cmd->device->lun); dcb = find_dcb(acb, cmd->device->id, cmd->device->lun);
if (!dcb) { if (!dcb) {
@ -1495,8 +1495,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
u16 s_stat2, return_code; u16 s_stat2, return_code;
u8 s_stat, scsicommand, i, identify_message; u8 s_stat, scsicommand, i, identify_message;
u8 *ptr; u8 *ptr;
dprintkdbg(DBG_0, "start_scsi: (pid#%li) <%02i-%i> srb=%p\n", dprintkdbg(DBG_0, "start_scsi: (0x%p) <%02i-%i> srb=%p\n",
srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); dcb->target_id, dcb->target_lun, srb);
srb->tag_number = TAG_NONE; /* acb->tag_max_num: had error read in eeprom */ srb->tag_number = TAG_NONE; /* acb->tag_max_num: had error read in eeprom */
@ -1505,8 +1505,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
s_stat2 = DC395x_read16(acb, TRM_S1040_SCSI_STATUS); s_stat2 = DC395x_read16(acb, TRM_S1040_SCSI_STATUS);
#if 1 #if 1
if (s_stat & 0x20 /* s_stat2 & 0x02000 */ ) { if (s_stat & 0x20 /* s_stat2 & 0x02000 */ ) {
dprintkdbg(DBG_KG, "start_scsi: (pid#%li) BUSY %02x %04x\n", dprintkdbg(DBG_KG, "start_scsi: (0x%p) BUSY %02x %04x\n",
srb->cmd->serial_number, s_stat, s_stat2); s_stat, s_stat2);
/* /*
* Try anyway? * Try anyway?
* *
@ -1522,16 +1522,15 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
} }
#endif #endif
if (acb->active_dcb) { if (acb->active_dcb) {
dprintkl(KERN_DEBUG, "start_scsi: (pid#%li) Attempt to start a" dprintkl(KERN_DEBUG, "start_scsi: (0x%p) Attempt to start a"
"command while another command (pid#%li) is active.", "command while another command (0x%p) is active.",
srb->cmd->serial_number, srb->cmd,
acb->active_dcb->active_srb ? acb->active_dcb->active_srb ?
acb->active_dcb->active_srb->cmd->serial_number : 0); acb->active_dcb->active_srb->cmd : 0);
return 1; return 1;
} }
if (DC395x_read16(acb, TRM_S1040_SCSI_STATUS) & SCSIINTERRUPT) { if (DC395x_read16(acb, TRM_S1040_SCSI_STATUS) & SCSIINTERRUPT) {
dprintkdbg(DBG_KG, "start_scsi: (pid#%li) Failed (busy)\n", dprintkdbg(DBG_KG, "start_scsi: (0x%p) Failed (busy)\n", srb->cmd);
srb->cmd->serial_number);
return 1; return 1;
} }
/* Allow starting of SCSI commands half a second before we allow the mid-level /* Allow starting of SCSI commands half a second before we allow the mid-level
@ -1603,9 +1602,9 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
tag_number++; tag_number++;
} }
if (tag_number >= dcb->max_command) { if (tag_number >= dcb->max_command) {
dprintkl(KERN_WARNING, "start_scsi: (pid#%li) " dprintkl(KERN_WARNING, "start_scsi: (0x%p) "
"Out of tags target=<%02i-%i>)\n", "Out of tags target=<%02i-%i>)\n",
srb->cmd->serial_number, srb->cmd->device->id, srb->cmd, srb->cmd->device->id,
srb->cmd->device->lun); srb->cmd->device->lun);
srb->state = SRB_READY; srb->state = SRB_READY;
DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DC395x_write16(acb, TRM_S1040_SCSI_CONTROL,
@ -1623,8 +1622,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
#endif #endif
/*polling:*/ /*polling:*/
/* Send CDB ..command block ......... */ /* Send CDB ..command block ......... */
dprintkdbg(DBG_KG, "start_scsi: (pid#%li) <%02i-%i> cmnd=0x%02x tag=%i\n", dprintkdbg(DBG_KG, "start_scsi: (0x%p) <%02i-%i> cmnd=0x%02x tag=%i\n",
srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun, srb->cmd, srb->cmd->device->id, srb->cmd->device->lun,
srb->cmd->cmnd[0], srb->tag_number); srb->cmd->cmnd[0], srb->tag_number);
if (srb->flag & AUTO_REQSENSE) { if (srb->flag & AUTO_REQSENSE) {
DC395x_write8(acb, TRM_S1040_SCSI_FIFO, REQUEST_SENSE); DC395x_write8(acb, TRM_S1040_SCSI_FIFO, REQUEST_SENSE);
@ -1647,8 +1646,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
* we caught an interrupt (must be reset or reselection ... ) * we caught an interrupt (must be reset or reselection ... )
* : Let's process it first! * : Let's process it first!
*/ */
dprintkdbg(DBG_0, "start_scsi: (pid#%li) <%02i-%i> Failed - busy\n", dprintkdbg(DBG_0, "start_scsi: (0x%p) <%02i-%i> Failed - busy\n",
srb->cmd->serial_number, dcb->target_id, dcb->target_lun); srb->cmd, dcb->target_id, dcb->target_lun);
srb->state = SRB_READY; srb->state = SRB_READY;
free_tag(dcb, srb); free_tag(dcb, srb);
srb->msg_count = 0; srb->msg_count = 0;
@ -1843,7 +1842,7 @@ static irqreturn_t dc395x_interrupt(int irq, void *dev_id)
static void msgout_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, static void msgout_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status) u16 *pscsi_status)
{ {
dprintkdbg(DBG_0, "msgout_phase0: (pid#%li)\n", srb->cmd->serial_number); dprintkdbg(DBG_0, "msgout_phase0: (0x%p)\n", srb->cmd);
if (srb->state & (SRB_UNEXPECT_RESEL + SRB_ABORT_SENT)) if (srb->state & (SRB_UNEXPECT_RESEL + SRB_ABORT_SENT))
*pscsi_status = PH_BUS_FREE; /*.. initial phase */ *pscsi_status = PH_BUS_FREE; /*.. initial phase */
@ -1857,18 +1856,18 @@ static void msgout_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
{ {
u16 i; u16 i;
u8 *ptr; u8 *ptr;
dprintkdbg(DBG_0, "msgout_phase1: (pid#%li)\n", srb->cmd->serial_number); dprintkdbg(DBG_0, "msgout_phase1: (0x%p)\n", srb->cmd);
clear_fifo(acb, "msgout_phase1"); clear_fifo(acb, "msgout_phase1");
if (!(srb->state & SRB_MSGOUT)) { if (!(srb->state & SRB_MSGOUT)) {
srb->state |= SRB_MSGOUT; srb->state |= SRB_MSGOUT;
dprintkl(KERN_DEBUG, dprintkl(KERN_DEBUG,
"msgout_phase1: (pid#%li) Phase unexpected\n", "msgout_phase1: (0x%p) Phase unexpected\n",
srb->cmd->serial_number); /* So what ? */ srb->cmd); /* So what ? */
} }
if (!srb->msg_count) { if (!srb->msg_count) {
dprintkdbg(DBG_0, "msgout_phase1: (pid#%li) NOP msg\n", dprintkdbg(DBG_0, "msgout_phase1: (0x%p) NOP msg\n",
srb->cmd->serial_number); srb->cmd);
DC395x_write8(acb, TRM_S1040_SCSI_FIFO, MSG_NOP); DC395x_write8(acb, TRM_S1040_SCSI_FIFO, MSG_NOP);
DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */ DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */
DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_FIFO_OUT); DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_FIFO_OUT);
@ -1888,7 +1887,7 @@ static void msgout_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
static void command_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, static void command_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status) u16 *pscsi_status)
{ {
dprintkdbg(DBG_0, "command_phase0: (pid#%li)\n", srb->cmd->serial_number); dprintkdbg(DBG_0, "command_phase0: (0x%p)\n", srb->cmd);
DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);
} }
@ -1899,7 +1898,7 @@ static void command_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
struct DeviceCtlBlk *dcb; struct DeviceCtlBlk *dcb;
u8 *ptr; u8 *ptr;
u16 i; u16 i;
dprintkdbg(DBG_0, "command_phase1: (pid#%li)\n", srb->cmd->serial_number); dprintkdbg(DBG_0, "command_phase1: (0x%p)\n", srb->cmd);
clear_fifo(acb, "command_phase1"); clear_fifo(acb, "command_phase1");
DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_CLRATN); DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_CLRATN);
@ -2041,8 +2040,8 @@ static void data_out_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
struct DeviceCtlBlk *dcb = srb->dcb; struct DeviceCtlBlk *dcb = srb->dcb;
u16 scsi_status = *pscsi_status; u16 scsi_status = *pscsi_status;
u32 d_left_counter = 0; u32 d_left_counter = 0;
dprintkdbg(DBG_0, "data_out_phase0: (pid#%li) <%02i-%i>\n", dprintkdbg(DBG_0, "data_out_phase0: (0x%p) <%02i-%i>\n",
srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun); srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
/* /*
* KG: We need to drain the buffers before we draw any conclusions! * KG: We need to drain the buffers before we draw any conclusions!
@ -2171,8 +2170,8 @@ static void data_out_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
static void data_out_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, static void data_out_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status) u16 *pscsi_status)
{ {
dprintkdbg(DBG_0, "data_out_phase1: (pid#%li) <%02i-%i>\n", dprintkdbg(DBG_0, "data_out_phase1: (0x%p) <%02i-%i>\n",
srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun); srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
clear_fifo(acb, "data_out_phase1"); clear_fifo(acb, "data_out_phase1");
/* do prepare before transfer when data out phase */ /* do prepare before transfer when data out phase */
data_io_transfer(acb, srb, XFERDATAOUT); data_io_transfer(acb, srb, XFERDATAOUT);
@ -2183,8 +2182,8 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
{ {
u16 scsi_status = *pscsi_status; u16 scsi_status = *pscsi_status;
dprintkdbg(DBG_0, "data_in_phase0: (pid#%li) <%02i-%i>\n", dprintkdbg(DBG_0, "data_in_phase0: (0x%p) <%02i-%i>\n",
srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun); srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
/* /*
* KG: DataIn is much more tricky than DataOut. When the device is finished * KG: DataIn is much more tricky than DataOut. When the device is finished
@ -2204,8 +2203,8 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
unsigned int sc, fc; unsigned int sc, fc;
if (scsi_status & PARITYERROR) { if (scsi_status & PARITYERROR) {
dprintkl(KERN_INFO, "data_in_phase0: (pid#%li) " dprintkl(KERN_INFO, "data_in_phase0: (0x%p) "
"Parity Error\n", srb->cmd->serial_number); "Parity Error\n", srb->cmd);
srb->status |= PARITY_ERROR; srb->status |= PARITY_ERROR;
} }
/* /*
@ -2394,8 +2393,8 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
static void data_in_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, static void data_in_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status) u16 *pscsi_status)
{ {
dprintkdbg(DBG_0, "data_in_phase1: (pid#%li) <%02i-%i>\n", dprintkdbg(DBG_0, "data_in_phase1: (0x%p) <%02i-%i>\n",
srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun); srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
data_io_transfer(acb, srb, XFERDATAIN); data_io_transfer(acb, srb, XFERDATAIN);
} }
@ -2406,8 +2405,8 @@ static void data_io_transfer(struct AdapterCtlBlk *acb,
struct DeviceCtlBlk *dcb = srb->dcb; struct DeviceCtlBlk *dcb = srb->dcb;
u8 bval; u8 bval;
dprintkdbg(DBG_0, dprintkdbg(DBG_0,
"data_io_transfer: (pid#%li) <%02i-%i> %c len=%i, sg=(%i/%i)\n", "data_io_transfer: (0x%p) <%02i-%i> %c len=%i, sg=(%i/%i)\n",
srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun, srb->cmd, srb->cmd->device->id, srb->cmd->device->lun,
((io_dir & DMACMD_DIR) ? 'r' : 'w'), ((io_dir & DMACMD_DIR) ? 'r' : 'w'),
srb->total_xfer_length, srb->sg_index, srb->sg_count); srb->total_xfer_length, srb->sg_index, srb->sg_count);
if (srb == acb->tmp_srb) if (srb == acb->tmp_srb)
@ -2579,8 +2578,8 @@ static void data_io_transfer(struct AdapterCtlBlk *acb,
static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status) u16 *pscsi_status)
{ {
dprintkdbg(DBG_0, "status_phase0: (pid#%li) <%02i-%i>\n", dprintkdbg(DBG_0, "status_phase0: (0x%p) <%02i-%i>\n",
srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun); srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
srb->target_status = DC395x_read8(acb, TRM_S1040_SCSI_FIFO); srb->target_status = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
srb->end_message = DC395x_read8(acb, TRM_S1040_SCSI_FIFO); /* get message */ srb->end_message = DC395x_read8(acb, TRM_S1040_SCSI_FIFO); /* get message */
srb->state = SRB_COMPLETED; srb->state = SRB_COMPLETED;
@ -2593,8 +2592,8 @@ static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
static void status_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, static void status_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status) u16 *pscsi_status)
{ {
dprintkdbg(DBG_0, "status_phase1: (pid#%li) <%02i-%i>\n", dprintkdbg(DBG_0, "status_phase1: (0x%p) <%02i-%i>\n",
srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun); srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
srb->state = SRB_STATUS; srb->state = SRB_STATUS;
DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */ DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */
DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_COMP); DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_COMP);
@ -2635,8 +2634,8 @@ static struct ScsiReqBlk *msgin_qtag(struct AdapterCtlBlk *acb,
{ {
struct ScsiReqBlk *srb = NULL; struct ScsiReqBlk *srb = NULL;
struct ScsiReqBlk *i; struct ScsiReqBlk *i;
dprintkdbg(DBG_0, "msgin_qtag: (pid#%li) tag=%i srb=%p\n", dprintkdbg(DBG_0, "msgin_qtag: (0x%p) tag=%i srb=%p\n",
srb->cmd->serial_number, tag, srb); srb->cmd, tag, srb);
if (!(dcb->tag_mask & (1 << tag))) if (!(dcb->tag_mask & (1 << tag)))
dprintkl(KERN_DEBUG, dprintkl(KERN_DEBUG,
@ -2654,8 +2653,8 @@ static struct ScsiReqBlk *msgin_qtag(struct AdapterCtlBlk *acb,
if (!srb) if (!srb)
goto mingx0; goto mingx0;
dprintkdbg(DBG_0, "msgin_qtag: (pid#%li) <%02i-%i>\n", dprintkdbg(DBG_0, "msgin_qtag: (0x%p) <%02i-%i>\n",
srb->cmd->serial_number, srb->dcb->target_id, srb->dcb->target_lun); srb->cmd, srb->dcb->target_id, srb->dcb->target_lun);
if (dcb->flag & ABORT_DEV_) { if (dcb->flag & ABORT_DEV_) {
/*srb->state = SRB_ABORT_SENT; */ /*srb->state = SRB_ABORT_SENT; */
enable_msgout_abort(acb, srb); enable_msgout_abort(acb, srb);
@ -2865,7 +2864,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status) u16 *pscsi_status)
{ {
struct DeviceCtlBlk *dcb = acb->active_dcb; struct DeviceCtlBlk *dcb = acb->active_dcb;
dprintkdbg(DBG_0, "msgin_phase0: (pid#%li)\n", srb->cmd->serial_number); dprintkdbg(DBG_0, "msgin_phase0: (0x%p)\n", srb->cmd);
srb->msgin_buf[acb->msg_len++] = DC395x_read8(acb, TRM_S1040_SCSI_FIFO); srb->msgin_buf[acb->msg_len++] = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
if (msgin_completed(srb->msgin_buf, acb->msg_len)) { if (msgin_completed(srb->msgin_buf, acb->msg_len)) {
@ -2931,9 +2930,9 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
* SAVE POINTER may be ignored as we have the struct * SAVE POINTER may be ignored as we have the struct
* ScsiReqBlk* associated with the scsi command. * ScsiReqBlk* associated with the scsi command.
*/ */
dprintkdbg(DBG_0, "msgin_phase0: (pid#%li) " dprintkdbg(DBG_0, "msgin_phase0: (0x%p) "
"SAVE POINTER rem=%i Ignore\n", "SAVE POINTER rem=%i Ignore\n",
srb->cmd->serial_number, srb->total_xfer_length); srb->cmd, srb->total_xfer_length);
break; break;
case RESTORE_POINTERS: case RESTORE_POINTERS:
@ -2941,9 +2940,9 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
break; break;
case ABORT: case ABORT:
dprintkdbg(DBG_0, "msgin_phase0: (pid#%li) " dprintkdbg(DBG_0, "msgin_phase0: (0x%p) "
"<%02i-%i> ABORT msg\n", "<%02i-%i> ABORT msg\n",
srb->cmd->serial_number, dcb->target_id, srb->cmd, dcb->target_id,
dcb->target_lun); dcb->target_lun);
dcb->flag |= ABORT_DEV_; dcb->flag |= ABORT_DEV_;
enable_msgout_abort(acb, srb); enable_msgout_abort(acb, srb);
@ -2975,7 +2974,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
static void msgin_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, static void msgin_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
u16 *pscsi_status) u16 *pscsi_status)
{ {
dprintkdbg(DBG_0, "msgin_phase1: (pid#%li)\n", srb->cmd->serial_number); dprintkdbg(DBG_0, "msgin_phase1: (0x%p)\n", srb->cmd);
clear_fifo(acb, "msgin_phase1"); clear_fifo(acb, "msgin_phase1");
DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 1); DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 1);
if (!(srb->state & SRB_MSGIN)) { if (!(srb->state & SRB_MSGIN)) {
@ -3041,7 +3040,7 @@ static void disconnect(struct AdapterCtlBlk *acb)
} }
srb = dcb->active_srb; srb = dcb->active_srb;
acb->active_dcb = NULL; acb->active_dcb = NULL;
dprintkdbg(DBG_0, "disconnect: (pid#%li)\n", srb->cmd->serial_number); dprintkdbg(DBG_0, "disconnect: (0x%p)\n", srb->cmd);
srb->scsi_phase = PH_BUS_FREE; /* initial phase */ srb->scsi_phase = PH_BUS_FREE; /* initial phase */
clear_fifo(acb, "disconnect"); clear_fifo(acb, "disconnect");
@ -3071,14 +3070,14 @@ static void disconnect(struct AdapterCtlBlk *acb)
&& srb->state != SRB_MSGOUT) { && srb->state != SRB_MSGOUT) {
srb->state = SRB_READY; srb->state = SRB_READY;
dprintkl(KERN_DEBUG, dprintkl(KERN_DEBUG,
"disconnect: (pid#%li) Unexpected\n", "disconnect: (0x%p) Unexpected\n",
srb->cmd->serial_number); srb->cmd);
srb->target_status = SCSI_STAT_SEL_TIMEOUT; srb->target_status = SCSI_STAT_SEL_TIMEOUT;
goto disc1; goto disc1;
} else { } else {
/* Normal selection timeout */ /* Normal selection timeout */
dprintkdbg(DBG_KG, "disconnect: (pid#%li) " dprintkdbg(DBG_KG, "disconnect: (0x%p) "
"<%02i-%i> SelTO\n", srb->cmd->serial_number, "<%02i-%i> SelTO\n", srb->cmd,
dcb->target_id, dcb->target_lun); dcb->target_id, dcb->target_lun);
if (srb->retry_count++ > DC395x_MAX_RETRIES if (srb->retry_count++ > DC395x_MAX_RETRIES
|| acb->scan_devices) { || acb->scan_devices) {
@ -3089,8 +3088,8 @@ static void disconnect(struct AdapterCtlBlk *acb)
free_tag(dcb, srb); free_tag(dcb, srb);
srb_going_to_waiting_move(dcb, srb); srb_going_to_waiting_move(dcb, srb);
dprintkdbg(DBG_KG, dprintkdbg(DBG_KG,
"disconnect: (pid#%li) Retry\n", "disconnect: (0x%p) Retry\n",
srb->cmd->serial_number); srb->cmd);
waiting_set_timer(acb, HZ / 20); waiting_set_timer(acb, HZ / 20);
} }
} else if (srb->state & SRB_DISCONNECT) { } else if (srb->state & SRB_DISCONNECT) {
@ -3142,9 +3141,9 @@ static void reselect(struct AdapterCtlBlk *acb)
} }
/* Why the if ? */ /* Why the if ? */
if (!acb->scan_devices) { if (!acb->scan_devices) {
dprintkdbg(DBG_KG, "reselect: (pid#%li) <%02i-%i> " dprintkdbg(DBG_KG, "reselect: (0x%p) <%02i-%i> "
"Arb lost but Resel win rsel=%i stat=0x%04x\n", "Arb lost but Resel win rsel=%i stat=0x%04x\n",
srb->cmd->serial_number, dcb->target_id, srb->cmd, dcb->target_id,
dcb->target_lun, rsel_tar_lun_id, dcb->target_lun, rsel_tar_lun_id,
DC395x_read16(acb, TRM_S1040_SCSI_STATUS)); DC395x_read16(acb, TRM_S1040_SCSI_STATUS));
arblostflag = 1; arblostflag = 1;
@ -3318,7 +3317,7 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
enum dma_data_direction dir = cmd->sc_data_direction; enum dma_data_direction dir = cmd->sc_data_direction;
int ckc_only = 1; int ckc_only = 1;
dprintkdbg(DBG_1, "srb_done: (pid#%li) <%02i-%i>\n", srb->cmd->serial_number, dprintkdbg(DBG_1, "srb_done: (0x%p) <%02i-%i>\n", srb->cmd,
srb->cmd->device->id, srb->cmd->device->lun); srb->cmd->device->id, srb->cmd->device->lun);
dprintkdbg(DBG_SG, "srb_done: srb=%p sg=%i(%i/%i) buf=%p\n", dprintkdbg(DBG_SG, "srb_done: srb=%p sg=%i(%i/%i) buf=%p\n",
srb, scsi_sg_count(cmd), srb->sg_index, srb->sg_count, srb, scsi_sg_count(cmd), srb->sg_index, srb->sg_count,
@ -3497,9 +3496,9 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
cmd->SCp.buffers_residual = 0; cmd->SCp.buffers_residual = 0;
if (debug_enabled(DBG_KG)) { if (debug_enabled(DBG_KG)) {
if (srb->total_xfer_length) if (srb->total_xfer_length)
dprintkdbg(DBG_KG, "srb_done: (pid#%li) <%02i-%i> " dprintkdbg(DBG_KG, "srb_done: (0x%p) <%02i-%i> "
"cmnd=0x%02x Missed %i bytes\n", "cmnd=0x%02x Missed %i bytes\n",
cmd->serial_number, cmd->device->id, cmd->device->lun, cmd, cmd->device->id, cmd->device->lun,
cmd->cmnd[0], srb->total_xfer_length); cmd->cmnd[0], srb->total_xfer_length);
} }
@ -3508,8 +3507,8 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
if (srb == acb->tmp_srb) if (srb == acb->tmp_srb)
dprintkl(KERN_ERR, "srb_done: ERROR! Completed cmd with tmp_srb\n"); dprintkl(KERN_ERR, "srb_done: ERROR! Completed cmd with tmp_srb\n");
else { else {
dprintkdbg(DBG_0, "srb_done: (pid#%li) done result=0x%08x\n", dprintkdbg(DBG_0, "srb_done: (0x%p) done result=0x%08x\n",
cmd->serial_number, cmd->result); cmd, cmd->result);
srb_free_insert(acb, srb); srb_free_insert(acb, srb);
} }
pci_unmap_srb(acb, srb); pci_unmap_srb(acb, srb);
@ -3538,7 +3537,7 @@ static void doing_srb_done(struct AdapterCtlBlk *acb, u8 did_flag,
p = srb->cmd; p = srb->cmd;
dir = p->sc_data_direction; dir = p->sc_data_direction;
result = MK_RES(0, did_flag, 0, 0); result = MK_RES(0, did_flag, 0, 0);
printk("G:%li(%02i-%i) ", p->serial_number, printk("G:%p(%02i-%i) ", p,
p->device->id, p->device->lun); p->device->id, p->device->lun);
srb_going_remove(dcb, srb); srb_going_remove(dcb, srb);
free_tag(dcb, srb); free_tag(dcb, srb);
@ -3568,7 +3567,7 @@ static void doing_srb_done(struct AdapterCtlBlk *acb, u8 did_flag,
p = srb->cmd; p = srb->cmd;
result = MK_RES(0, did_flag, 0, 0); result = MK_RES(0, did_flag, 0, 0);
printk("W:%li<%02i-%i>", p->serial_number, p->device->id, printk("W:%p<%02i-%i>", p, p->device->id,
p->device->lun); p->device->lun);
srb_waiting_remove(dcb, srb); srb_waiting_remove(dcb, srb);
srb_free_insert(acb, srb); srb_free_insert(acb, srb);
@ -3677,8 +3676,8 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
struct ScsiReqBlk *srb) struct ScsiReqBlk *srb)
{ {
struct scsi_cmnd *cmd = srb->cmd; struct scsi_cmnd *cmd = srb->cmd;
dprintkdbg(DBG_1, "request_sense: (pid#%li) <%02i-%i>\n", dprintkdbg(DBG_1, "request_sense: (0x%p) <%02i-%i>\n",
cmd->serial_number, cmd->device->id, cmd->device->lun); cmd, cmd->device->id, cmd->device->lun);
srb->flag |= AUTO_REQSENSE; srb->flag |= AUTO_REQSENSE;
srb->adapter_status = 0; srb->adapter_status = 0;
@ -3708,8 +3707,8 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
if (start_scsi(acb, dcb, srb)) { /* Should only happen, if sb. else grabs the bus */ if (start_scsi(acb, dcb, srb)) { /* Should only happen, if sb. else grabs the bus */
dprintkl(KERN_DEBUG, dprintkl(KERN_DEBUG,
"request_sense: (pid#%li) failed <%02i-%i>\n", "request_sense: (0x%p) failed <%02i-%i>\n",
srb->cmd->serial_number, dcb->target_id, dcb->target_lun); srb->cmd, dcb->target_id, dcb->target_lun);
srb_going_to_waiting_move(dcb, srb); srb_going_to_waiting_move(dcb, srb);
waiting_set_timer(acb, HZ / 100); waiting_set_timer(acb, HZ / 100);
} }
@ -4717,13 +4716,13 @@ static int dc395x_proc_info(struct Scsi_Host *host, char *buffer,
dcb->target_id, dcb->target_lun, dcb->target_id, dcb->target_lun,
list_size(&dcb->srb_waiting_list)); list_size(&dcb->srb_waiting_list));
list_for_each_entry(srb, &dcb->srb_waiting_list, list) list_for_each_entry(srb, &dcb->srb_waiting_list, list)
SPRINTF(" %li", srb->cmd->serial_number); SPRINTF(" %p", srb->cmd);
if (!list_empty(&dcb->srb_going_list)) if (!list_empty(&dcb->srb_going_list))
SPRINTF("\nDCB (%02i-%i): Going : %i:", SPRINTF("\nDCB (%02i-%i): Going : %i:",
dcb->target_id, dcb->target_lun, dcb->target_id, dcb->target_lun,
list_size(&dcb->srb_going_list)); list_size(&dcb->srb_going_list));
list_for_each_entry(srb, &dcb->srb_going_list, list) list_for_each_entry(srb, &dcb->srb_going_list, list)
SPRINTF(" %li", srb->cmd->serial_number); SPRINTF(" %p", srb->cmd);
if (!list_empty(&dcb->srb_waiting_list) || !list_empty(&dcb->srb_going_list)) if (!list_empty(&dcb->srb_waiting_list) || !list_empty(&dcb->srb_going_list))
SPRINTF("\n"); SPRINTF("\n");
} }

6
drivers/scsi/dpt_i2o.c
View file

@ -780,7 +780,7 @@ static int adpt_abort(struct scsi_cmnd * cmd)
return FAILED; return FAILED;
} }
pHba = (adpt_hba*) cmd->device->host->hostdata[0]; pHba = (adpt_hba*) cmd->device->host->hostdata[0];
printk(KERN_INFO"%s: Trying to Abort cmd=%ld\n",pHba->name, cmd->serial_number); printk(KERN_INFO"%s: Trying to Abort\n",pHba->name);
if ((dptdevice = (void*) (cmd->device->hostdata)) == NULL) { if ((dptdevice = (void*) (cmd->device->hostdata)) == NULL) {
printk(KERN_ERR "%s: Unable to abort: No device in cmnd\n",pHba->name); printk(KERN_ERR "%s: Unable to abort: No device in cmnd\n",pHba->name);
return FAILED; return FAILED;
@ -802,10 +802,10 @@ static int adpt_abort(struct scsi_cmnd * cmd)
printk(KERN_INFO"%s: Abort cmd not supported\n",pHba->name); printk(KERN_INFO"%s: Abort cmd not supported\n",pHba->name);
return FAILED; return FAILED;
} }
printk(KERN_INFO"%s: Abort cmd=%ld failed.\n",pHba->name, cmd->serial_number); printk(KERN_INFO"%s: Abort failed.\n",pHba->name);
return FAILED; return FAILED;
} }
printk(KERN_INFO"%s: Abort cmd=%ld complete.\n",pHba->name, cmd->serial_number); printk(KERN_INFO"%s: Abort complete.\n",pHba->name);
return SUCCESS; return SUCCESS;
} }

66
drivers/scsi/eata.c
View file

@ -1766,8 +1766,8 @@ static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
struct mscp *cpp; struct mscp *cpp;
if (SCpnt->host_scribble) if (SCpnt->host_scribble)
panic("%s: qcomm, pid %ld, SCpnt %p already active.\n", panic("%s: qcomm, SCpnt %p already active.\n",
ha->board_name, SCpnt->serial_number, SCpnt); ha->board_name, SCpnt);
/* i is the mailbox number, look for the first free mailbox /* i is the mailbox number, look for the first free mailbox
starting from last_cp_used */ starting from last_cp_used */
@ -1801,7 +1801,7 @@ static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
if (do_trace) if (do_trace)
scmd_printk(KERN_INFO, SCpnt, scmd_printk(KERN_INFO, SCpnt,
"qcomm, mbox %d, pid %ld.\n", i, SCpnt->serial_number); "qcomm, mbox %d.\n", i);
cpp->reqsen = 1; cpp->reqsen = 1;
cpp->dispri = 1; cpp->dispri = 1;
@ -1833,8 +1833,7 @@ static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) { if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
unmap_dma(i, ha); unmap_dma(i, ha);
SCpnt->host_scribble = NULL; SCpnt->host_scribble = NULL;
scmd_printk(KERN_INFO, SCpnt, scmd_printk(KERN_INFO, SCpnt, "qcomm, adapter busy.\n");
"qcomm, pid %ld, adapter busy.\n", SCpnt->serial_number);
return 1; return 1;
} }
@ -1851,14 +1850,12 @@ static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
unsigned int i; unsigned int i;
if (SCarg->host_scribble == NULL) { if (SCarg->host_scribble == NULL) {
scmd_printk(KERN_INFO, SCarg, scmd_printk(KERN_INFO, SCarg, "abort, cmd inactive.\n");
"abort, pid %ld inactive.\n", SCarg->serial_number);
return SUCCESS; return SUCCESS;
} }
i = *(unsigned int *)SCarg->host_scribble; i = *(unsigned int *)SCarg->host_scribble;
scmd_printk(KERN_WARNING, SCarg, scmd_printk(KERN_WARNING, SCarg, "abort, mbox %d.\n", i);
"abort, mbox %d, pid %ld.\n", i, SCarg->serial_number);
if (i >= shost->can_queue) if (i >= shost->can_queue)
panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name); panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name);
@ -1902,8 +1899,8 @@ static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
SCarg->result = DID_ABORT << 16; SCarg->result = DID_ABORT << 16;
SCarg->host_scribble = NULL; SCarg->host_scribble = NULL;
ha->cp_stat[i] = FREE; ha->cp_stat[i] = FREE;
printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n", printk("%s, abort, mbox %d ready, DID_ABORT, done.\n",
ha->board_name, i, SCarg->serial_number); ha->board_name, i);
SCarg->scsi_done(SCarg); SCarg->scsi_done(SCarg);
return SUCCESS; return SUCCESS;
} }
@ -1919,13 +1916,12 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
struct Scsi_Host *shost = SCarg->device->host; struct Scsi_Host *shost = SCarg->device->host;
struct hostdata *ha = (struct hostdata *)shost->hostdata; struct hostdata *ha = (struct hostdata *)shost->hostdata;
scmd_printk(KERN_INFO, SCarg, scmd_printk(KERN_INFO, SCarg, "reset, enter.\n");
"reset, enter, pid %ld.\n", SCarg->serial_number);
spin_lock_irq(shost->host_lock); spin_lock_irq(shost->host_lock);
if (SCarg->host_scribble == NULL) if (SCarg->host_scribble == NULL)
printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->serial_number); printk("%s: reset, inactive.\n", ha->board_name);
if (ha->in_reset) { if (ha->in_reset) {
printk("%s: reset, exit, already in reset.\n", ha->board_name); printk("%s: reset, exit, already in reset.\n", ha->board_name);
@ -1964,14 +1960,14 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) { if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
ha->cp_stat[i] = ABORTING; ha->cp_stat[i] = ABORTING;
printk("%s: reset, mbox %d aborting, pid %ld.\n", printk("%s: reset, mbox %d aborting.\n",
ha->board_name, i, SCpnt->serial_number); ha->board_name, i);
} }
else { else {
ha->cp_stat[i] = IN_RESET; ha->cp_stat[i] = IN_RESET;
printk("%s: reset, mbox %d in reset, pid %ld.\n", printk("%s: reset, mbox %d in reset.\n",
ha->board_name, i, SCpnt->serial_number); ha->board_name, i);
} }
if (SCpnt->host_scribble == NULL) if (SCpnt->host_scribble == NULL)
@ -2025,8 +2021,8 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
ha->cp_stat[i] = LOCKED; ha->cp_stat[i] = LOCKED;
printk printk
("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n", ("%s, reset, mbox %d locked, DID_RESET, done.\n",
ha->board_name, i, SCpnt->serial_number); ha->board_name, i);
} }
else if (ha->cp_stat[i] == ABORTING) { else if (ha->cp_stat[i] == ABORTING) {
@ -2039,8 +2035,8 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
ha->cp_stat[i] = FREE; ha->cp_stat[i] = FREE;
printk printk
("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n", ("%s, reset, mbox %d aborting, DID_RESET, done.\n",
ha->board_name, i, SCpnt->serial_number); ha->board_name, i);
} }
else else
@ -2054,7 +2050,7 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
do_trace = 0; do_trace = 0;
if (arg_done) if (arg_done)
printk("%s: reset, exit, pid %ld done.\n", ha->board_name, SCarg->serial_number); printk("%s: reset, exit, done.\n", ha->board_name);
else else
printk("%s: reset, exit.\n", ha->board_name); printk("%s: reset, exit.\n", ha->board_name);
@ -2238,10 +2234,10 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
cpp = &ha->cp[k]; cpp = &ha->cp[k];
SCpnt = cpp->SCpnt; SCpnt = cpp->SCpnt;
scmd_printk(KERN_INFO, SCpnt, scmd_printk(KERN_INFO, SCpnt,
"%s pid %ld mb %d fc %d nr %d sec %ld ns %u" "%s mb %d fc %d nr %d sec %ld ns %u"
" cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n", " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
(ihdlr ? "ihdlr" : "qcomm"), (ihdlr ? "ihdlr" : "qcomm"),
SCpnt->serial_number, k, flushcount, k, flushcount,
n_ready, blk_rq_pos(SCpnt->request), n_ready, blk_rq_pos(SCpnt->request),
blk_rq_sectors(SCpnt->request), cursec, YESNO(s), blk_rq_sectors(SCpnt->request), cursec, YESNO(s),
YESNO(r), YESNO(rev), YESNO(input_only), YESNO(r), YESNO(rev), YESNO(input_only),
@ -2285,10 +2281,10 @@ static void flush_dev(struct scsi_device *dev, unsigned long cursec,
if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) { if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
scmd_printk(KERN_INFO, SCpnt, scmd_printk(KERN_INFO, SCpnt,
"%s, pid %ld, mbox %d, adapter" "%s, mbox %d, adapter"
" busy, will abort.\n", " busy, will abort.\n",
(ihdlr ? "ihdlr" : "qcomm"), (ihdlr ? "ihdlr" : "qcomm"),
SCpnt->serial_number, k); k);
ha->cp_stat[k] = ABORTING; ha->cp_stat[k] = ABORTING;
continue; continue;
} }
@ -2398,12 +2394,12 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i); panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
if (SCpnt->host_scribble == NULL) if (SCpnt->host_scribble == NULL)
panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", ha->board_name, panic("%s: ihdlr, mbox %d, SCpnt %p garbled.\n", ha->board_name,
i, SCpnt->serial_number, SCpnt); i, SCpnt);
if (*(unsigned int *)SCpnt->host_scribble != i) if (*(unsigned int *)SCpnt->host_scribble != i)
panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n", panic("%s: ihdlr, mbox %d, index mismatch %d.\n",
ha->board_name, i, SCpnt->serial_number, ha->board_name, i,
*(unsigned int *)SCpnt->host_scribble); *(unsigned int *)SCpnt->host_scribble);
sync_dma(i, ha); sync_dma(i, ha);
@ -2449,11 +2445,11 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
if (spp->target_status && SCpnt->device->type == TYPE_DISK && if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
(!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 && (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 &&
(SCpnt->sense_buffer[2] & 0xf) == NOT_READY))) (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
printk("%s: ihdlr, target %d.%d:%d, pid %ld, " printk("%s: ihdlr, target %d.%d:%d, "
"target_status 0x%x, sense key 0x%x.\n", "target_status 0x%x, sense key 0x%x.\n",
ha->board_name, ha->board_name,
SCpnt->device->channel, SCpnt->device->id, SCpnt->device->channel, SCpnt->device->id,
SCpnt->device->lun, SCpnt->serial_number, SCpnt->device->lun,
spp->target_status, SCpnt->sense_buffer[2]); spp->target_status, SCpnt->sense_buffer[2]);
ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0; ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;
@ -2522,9 +2518,9 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
do_trace || msg_byte(spp->target_status)) do_trace || msg_byte(spp->target_status))
#endif #endif
scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x," scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"
" pid %ld, reg 0x%x, count %d.\n", " reg 0x%x, count %d.\n",
i, spp->adapter_status, spp->target_status, i, spp->adapter_status, spp->target_status,
SCpnt->serial_number, reg, ha->iocount); reg, ha->iocount);
unmap_dma(i, ha); unmap_dma(i, ha);

19
drivers/scsi/eata_pio.c
View file

@ -372,8 +372,7 @@ static int eata_pio_queue_lck(struct scsi_cmnd *cmd,
cp->status = USED; /* claim free slot */ cp->status = USED; /* claim free slot */
DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd, DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd,
"eata_pio_queue pid %ld, y %d\n", "eata_pio_queue 0x%p, y %d\n", cmd, y));
cmd->serial_number, y));
cmd->scsi_done = (void *) done; cmd->scsi_done = (void *) done;
@ -417,8 +416,8 @@ static int eata_pio_queue_lck(struct scsi_cmnd *cmd,
if (eata_pio_send_command(base, EATA_CMD_PIO_SEND_CP)) { if (eata_pio_send_command(base, EATA_CMD_PIO_SEND_CP)) {
cmd->result = DID_BUS_BUSY << 16; cmd->result = DID_BUS_BUSY << 16;
scmd_printk(KERN_NOTICE, cmd, scmd_printk(KERN_NOTICE, cmd,
"eata_pio_queue pid %ld, HBA busy, " "eata_pio_queue pid 0x%p, HBA busy, "
"returning DID_BUS_BUSY, done.\n", cmd->serial_number); "returning DID_BUS_BUSY, done.\n", cmd);
done(cmd); done(cmd);
cp->status = FREE; cp->status = FREE;
return 0; return 0;
@ -432,8 +431,8 @@ static int eata_pio_queue_lck(struct scsi_cmnd *cmd,
outw(0, base + HA_RDATA); outw(0, base + HA_RDATA);
DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd, DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd,
"Queued base %#.4lx pid: %ld " "Queued base %#.4lx cmd: 0x%p "
"slot %d irq %d\n", sh->base, cmd->serial_number, y, sh->irq)); "slot %d irq %d\n", sh->base, cmd, y, sh->irq));
return 0; return 0;
} }
@ -445,8 +444,7 @@ static int eata_pio_abort(struct scsi_cmnd *cmd)
unsigned int loop = 100; unsigned int loop = 100;
DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd, DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd,
"eata_pio_abort called pid: %ld\n", "eata_pio_abort called pid: 0x%p\n", cmd));
cmd->serial_number));
while (inb(cmd->device->host->base + HA_RAUXSTAT) & HA_ABUSY) while (inb(cmd->device->host->base + HA_RAUXSTAT) & HA_ABUSY)
if (--loop == 0) { if (--loop == 0) {
@ -481,8 +479,7 @@ static int eata_pio_host_reset(struct scsi_cmnd *cmd)
struct Scsi_Host *host = cmd->device->host; struct Scsi_Host *host = cmd->device->host;
DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd, DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd,
"eata_pio_reset called pid:%ld\n", "eata_pio_reset called\n"));
cmd->serial_number));
spin_lock_irq(host->host_lock); spin_lock_irq(host->host_lock);
@ -501,7 +498,7 @@ static int eata_pio_host_reset(struct scsi_cmnd *cmd)
sp = HD(cmd)->ccb[x].cmd; sp = HD(cmd)->ccb[x].cmd;
HD(cmd)->ccb[x].status = RESET; HD(cmd)->ccb[x].status = RESET;
printk(KERN_WARNING "eata_pio_reset: slot %d in reset, pid %ld.\n", x, sp->serial_number); printk(KERN_WARNING "eata_pio_reset: slot %d in reset.\n", x);
if (sp == NULL) if (sp == NULL)
panic("eata_pio_reset: slot %d, sp==NULL.\n", x); panic("eata_pio_reset: slot %d, sp==NULL.\n", x);

29
drivers/scsi/in2000.c
View file

@ -343,7 +343,7 @@ static int in2000_queuecommand_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
instance = cmd->device->host; instance = cmd->device->host;
hostdata = (struct IN2000_hostdata *) instance->hostdata; hostdata = (struct IN2000_hostdata *) instance->hostdata;
DB(DB_QUEUE_COMMAND, scmd_printk(KERN_DEBUG, cmd, "Q-%02x-%ld(", cmd->cmnd[0], cmd->serial_number)) DB(DB_QUEUE_COMMAND, scmd_printk(KERN_DEBUG, cmd, "Q-%02x(", cmd->cmnd[0]))
/* Set up a few fields in the Scsi_Cmnd structure for our own use: /* Set up a few fields in the Scsi_Cmnd structure for our own use:
* - host_scribble is the pointer to the next cmd in the input queue * - host_scribble is the pointer to the next cmd in the input queue
@ -427,7 +427,7 @@ static int in2000_queuecommand_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
in2000_execute(cmd->device->host); in2000_execute(cmd->device->host);
DB(DB_QUEUE_COMMAND, printk(")Q-%ld ", cmd->serial_number)) DB(DB_QUEUE_COMMAND, printk(")Q "))
return 0; return 0;
} }
@ -705,7 +705,7 @@ static void in2000_execute(struct Scsi_Host *instance)
* to search the input_Q again... * to search the input_Q again...
*/ */
DB(DB_EXECUTE, printk("%s%ld)EX-2 ", (cmd->SCp.phase) ? "d:" : "", cmd->serial_number)) DB(DB_EXECUTE, printk("%s)EX-2 ", (cmd->SCp.phase) ? "d:" : ""))
} }
@ -1149,7 +1149,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
case CSR_XFER_DONE | PHS_COMMAND: case CSR_XFER_DONE | PHS_COMMAND:
case CSR_UNEXP | PHS_COMMAND: case CSR_UNEXP | PHS_COMMAND:
case CSR_SRV_REQ | PHS_COMMAND: case CSR_SRV_REQ | PHS_COMMAND:
DB(DB_INTR, printk("CMND-%02x,%ld", cmd->cmnd[0], cmd->serial_number)) DB(DB_INTR, printk("CMND-%02x", cmd->cmnd[0]))
transfer_pio(cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata); transfer_pio(cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata);
hostdata->state = S_CONNECTED; hostdata->state = S_CONNECTED;
break; break;
@ -1191,7 +1191,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
switch (msg) { switch (msg) {
case COMMAND_COMPLETE: case COMMAND_COMPLETE:
DB(DB_INTR, printk("CCMP-%ld", cmd->serial_number)) DB(DB_INTR, printk("CCMP"))
write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK); write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
hostdata->state = S_PRE_CMP_DISC; hostdata->state = S_PRE_CMP_DISC;
break; break;
@ -1329,7 +1329,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
write_3393(hostdata, WD_SOURCE_ID, SRCID_ER); write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
if (phs == 0x60) { if (phs == 0x60) {
DB(DB_INTR, printk("SX-DONE-%ld", cmd->serial_number)) DB(DB_INTR, printk("SX-DONE"))
cmd->SCp.Message = COMMAND_COMPLETE; cmd->SCp.Message = COMMAND_COMPLETE;
lun = read_3393(hostdata, WD_TARGET_LUN); lun = read_3393(hostdata, WD_TARGET_LUN);
DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun)) DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
@ -1350,7 +1350,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
in2000_execute(instance); in2000_execute(instance);
} else { } else {
printk("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---", asr, sr, phs, cmd->serial_number); printk("%02x:%02x:%02x: Unknown SEL_XFER_DONE phase!!---", asr, sr, phs);
} }
break; break;
@ -1417,7 +1417,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
spin_unlock_irqrestore(instance->host_lock, flags); spin_unlock_irqrestore(instance->host_lock, flags);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
DB(DB_INTR, printk("UNEXP_DISC-%ld", cmd->serial_number)) DB(DB_INTR, printk("UNEXP_DISC"))
hostdata->connected = NULL; hostdata->connected = NULL;
hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun); hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
hostdata->state = S_UNCONNECTED; hostdata->state = S_UNCONNECTED;
@ -1442,7 +1442,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
*/ */
write_3393(hostdata, WD_SOURCE_ID, SRCID_ER); write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
DB(DB_INTR, printk("DISC-%ld", cmd->serial_number)) DB(DB_INTR, printk("DISC"))
if (cmd == NULL) { if (cmd == NULL) {
printk(" - Already disconnected! "); printk(" - Already disconnected! ");
hostdata->state = S_UNCONNECTED; hostdata->state = S_UNCONNECTED;
@ -1575,7 +1575,6 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
} else } else
hostdata->state = S_CONNECTED; hostdata->state = S_CONNECTED;
DB(DB_INTR, printk("-%ld", cmd->serial_number))
break; break;
default: default:
@ -1704,7 +1703,7 @@ static int __in2000_abort(Scsi_Cmnd * cmd)
prev->host_scribble = cmd->host_scribble; prev->host_scribble = cmd->host_scribble;
cmd->host_scribble = NULL; cmd->host_scribble = NULL;
cmd->result = DID_ABORT << 16; cmd->result = DID_ABORT << 16;
printk(KERN_WARNING "scsi%d: Abort - removing command %ld from input_Q. ", instance->host_no, cmd->serial_number); printk(KERN_WARNING "scsi%d: Abort - removing command from input_Q. ", instance->host_no);
cmd->scsi_done(cmd); cmd->scsi_done(cmd);
return SUCCESS; return SUCCESS;
} }
@ -1725,7 +1724,7 @@ static int __in2000_abort(Scsi_Cmnd * cmd)
if (hostdata->connected == cmd) { if (hostdata->connected == cmd) {
printk(KERN_WARNING "scsi%d: Aborting connected command %ld - ", instance->host_no, cmd->serial_number); printk(KERN_WARNING "scsi%d: Aborting connected command - ", instance->host_no);
printk("sending wd33c93 ABORT command - "); printk("sending wd33c93 ABORT command - ");
write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED); write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
@ -2270,7 +2269,7 @@ static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start,
strcat(bp, "\nconnected: "); strcat(bp, "\nconnected: ");
if (hd->connected) { if (hd->connected) {
cmd = (Scsi_Cmnd *) hd->connected; cmd = (Scsi_Cmnd *) hd->connected;
sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
strcat(bp, tbuf); strcat(bp, tbuf);
} }
} }
@ -2278,7 +2277,7 @@ static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start,
strcat(bp, "\ninput_Q: "); strcat(bp, "\ninput_Q: ");
cmd = (Scsi_Cmnd *) hd->input_Q; cmd = (Scsi_Cmnd *) hd->input_Q;
while (cmd) { while (cmd) {
sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
strcat(bp, tbuf); strcat(bp, tbuf);
cmd = (Scsi_Cmnd *) cmd->host_scribble; cmd = (Scsi_Cmnd *) cmd->host_scribble;
} }
@ -2287,7 +2286,7 @@ static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start,
strcat(bp, "\ndisconnected_Q:"); strcat(bp, "\ndisconnected_Q:");
cmd = (Scsi_Cmnd *) hd->disconnected_Q; cmd = (Scsi_Cmnd *) hd->disconnected_Q;
while (cmd) { while (cmd) {
sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
strcat(bp, tbuf); strcat(bp, tbuf);
cmd = (Scsi_Cmnd *) cmd->host_scribble; cmd = (Scsi_Cmnd *) cmd->host_scribble;
} }

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

@ -3238,9 +3238,8 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
if (!lpfc_cmd) { if (!lpfc_cmd) {
lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
"2873 SCSI Layer I/O Abort Request IO CMPL Status " "2873 SCSI Layer I/O Abort Request IO CMPL Status "
"x%x ID %d " "x%x ID %d LUN %d\n",
"LUN %d snum %#lx\n", ret, cmnd->device->id, ret, cmnd->device->id, cmnd->device->lun);
cmnd->device->lun, cmnd->serial_number);
return SUCCESS; return SUCCESS;
} }
@ -3318,16 +3317,15 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
"0748 abort handler timed out waiting " "0748 abort handler timed out waiting "
"for abort to complete: ret %#x, ID %d, " "for abort to complete: ret %#x, ID %d, "
"LUN %d, snum %#lx\n", "LUN %d\n",
ret, cmnd->device->id, cmnd->device->lun, ret, cmnd->device->id, cmnd->device->lun);
cmnd->serial_number);
} }
out: out:
lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
"0749 SCSI Layer I/O Abort Request Status x%x ID %d " "0749 SCSI Layer I/O Abort Request Status x%x ID %d "
"LUN %d snum %#lx\n", ret, cmnd->device->id, "LUN %d\n", ret, cmnd->device->id,
cmnd->device->lun, cmnd->serial_number); cmnd->device->lun);
return ret; return ret;
} }

20
drivers/scsi/megaraid.c
View file

@ -1469,8 +1469,8 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
if( scb->state & SCB_ABORT ) { if( scb->state & SCB_ABORT ) {
printk(KERN_WARNING printk(KERN_WARNING
"megaraid: aborted cmd %lx[%x] complete.\n", "megaraid: aborted cmd [%x] complete.\n",
scb->cmd->serial_number, scb->idx); scb->idx);
scb->cmd->result = (DID_ABORT << 16); scb->cmd->result = (DID_ABORT << 16);
@ -1488,8 +1488,8 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
if( scb->state & SCB_RESET ) { if( scb->state & SCB_RESET ) {
printk(KERN_WARNING printk(KERN_WARNING
"megaraid: reset cmd %lx[%x] complete.\n", "megaraid: reset cmd [%x] complete.\n",
scb->cmd->serial_number, scb->idx); scb->idx);
scb->cmd->result = (DID_RESET << 16); scb->cmd->result = (DID_RESET << 16);
@ -1958,8 +1958,8 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
struct list_head *pos, *next; struct list_head *pos, *next;
scb_t *scb; scb_t *scb;
printk(KERN_WARNING "megaraid: %s-%lx cmd=%x <c=%d t=%d l=%d>\n", printk(KERN_WARNING "megaraid: %s cmd=%x <c=%d t=%d l=%d>\n",
(aor == SCB_ABORT)? "ABORTING":"RESET", cmd->serial_number, (aor == SCB_ABORT)? "ABORTING":"RESET",
cmd->cmnd[0], cmd->device->channel, cmd->cmnd[0], cmd->device->channel,
cmd->device->id, cmd->device->lun); cmd->device->id, cmd->device->lun);
@ -1983,9 +1983,9 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
if( scb->state & SCB_ISSUED ) { if( scb->state & SCB_ISSUED ) {
printk(KERN_WARNING printk(KERN_WARNING
"megaraid: %s-%lx[%x], fw owner.\n", "megaraid: %s[%x], fw owner.\n",
(aor==SCB_ABORT) ? "ABORTING":"RESET", (aor==SCB_ABORT) ? "ABORTING":"RESET",
cmd->serial_number, scb->idx); scb->idx);
return FALSE; return FALSE;
} }
@ -1996,9 +1996,9 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
* list * list
*/ */
printk(KERN_WARNING printk(KERN_WARNING
"megaraid: %s-%lx[%x], driver owner.\n", "megaraid: %s-[%x], driver owner.\n",
(aor==SCB_ABORT) ? "ABORTING":"RESET", (aor==SCB_ABORT) ? "ABORTING":"RESET",
cmd->serial_number, scb->idx); scb->idx);
mega_free_scb(adapter, scb); mega_free_scb(adapter, scb);

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

@ -2315,8 +2315,8 @@ megaraid_mbox_dpc(unsigned long devp)
// Was an abort issued for this command earlier // Was an abort issued for this command earlier
if (scb->state & SCB_ABORT) { if (scb->state & SCB_ABORT) {
con_log(CL_ANN, (KERN_NOTICE con_log(CL_ANN, (KERN_NOTICE
"megaraid: aborted cmd %lx[%x] completed\n", "megaraid: aborted cmd [%x] completed\n",
scp->serial_number, scb->sno)); scb->sno));
} }
/* /*
@ -2472,8 +2472,8 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
raid_dev = ADAP2RAIDDEV(adapter); raid_dev = ADAP2RAIDDEV(adapter);
con_log(CL_ANN, (KERN_WARNING con_log(CL_ANN, (KERN_WARNING
"megaraid: aborting-%ld cmd=%x <c=%d t=%d l=%d>\n", "megaraid: aborting cmd=%x <c=%d t=%d l=%d>\n",
scp->serial_number, scp->cmnd[0], SCP2CHANNEL(scp), scp->cmnd[0], SCP2CHANNEL(scp),
SCP2TARGET(scp), SCP2LUN(scp))); SCP2TARGET(scp), SCP2LUN(scp)));
// If FW has stopped responding, simply return failure // If FW has stopped responding, simply return failure
@ -2496,9 +2496,8 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
list_del_init(&scb->list); // from completed list list_del_init(&scb->list); // from completed list
con_log(CL_ANN, (KERN_WARNING con_log(CL_ANN, (KERN_WARNING
"megaraid: %ld:%d[%d:%d], abort from completed list\n", "megaraid: %d[%d:%d], abort from completed list\n",
scp->serial_number, scb->sno, scb->sno, scb->dev_channel, scb->dev_target));
scb->dev_channel, scb->dev_target));
scp->result = (DID_ABORT << 16); scp->result = (DID_ABORT << 16);
scp->scsi_done(scp); scp->scsi_done(scp);
@ -2527,9 +2526,8 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
ASSERT(!(scb->state & SCB_ISSUED)); ASSERT(!(scb->state & SCB_ISSUED));
con_log(CL_ANN, (KERN_WARNING con_log(CL_ANN, (KERN_WARNING
"megaraid abort: %ld[%d:%d], driver owner\n", "megaraid abort: [%d:%d], driver owner\n",
scp->serial_number, scb->dev_channel, scb->dev_channel, scb->dev_target));
scb->dev_target));
scp->result = (DID_ABORT << 16); scp->result = (DID_ABORT << 16);
scp->scsi_done(scp); scp->scsi_done(scp);
@ -2560,25 +2558,21 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
if (!(scb->state & SCB_ISSUED)) { if (!(scb->state & SCB_ISSUED)) {
con_log(CL_ANN, (KERN_WARNING con_log(CL_ANN, (KERN_WARNING
"megaraid abort: %ld%d[%d:%d], invalid state\n", "megaraid abort: %d[%d:%d], invalid state\n",
scp->serial_number, scb->sno, scb->dev_channel, scb->sno, scb->dev_channel, scb->dev_target));
scb->dev_target));
BUG(); BUG();
} }
else { else {
con_log(CL_ANN, (KERN_WARNING con_log(CL_ANN, (KERN_WARNING
"megaraid abort: %ld:%d[%d:%d], fw owner\n", "megaraid abort: %d[%d:%d], fw owner\n",
scp->serial_number, scb->sno, scb->dev_channel, scb->sno, scb->dev_channel, scb->dev_target));
scb->dev_target));
} }
} }
} }
spin_unlock_irq(&adapter->lock); spin_unlock_irq(&adapter->lock);
if (!found) { if (!found) {
con_log(CL_ANN, (KERN_WARNING con_log(CL_ANN, (KERN_WARNING "megaraid abort: do now own\n"));
"megaraid abort: scsi cmd:%ld, do now own\n",
scp->serial_number));
// FIXME: Should there be a callback for this command? // FIXME: Should there be a callback for this command?
return SUCCESS; return SUCCESS;
@ -2649,9 +2643,8 @@ megaraid_reset_handler(struct scsi_cmnd *scp)
} else { } else {
if (scb->scp == scp) { // Found command if (scb->scp == scp) { // Found command
con_log(CL_ANN, (KERN_WARNING con_log(CL_ANN, (KERN_WARNING
"megaraid: %ld:%d[%d:%d], reset from pending list\n", "megaraid: %d[%d:%d], reset from pending list\n",
scp->serial_number, scb->sno, scb->sno, scb->dev_channel, scb->dev_target));
scb->dev_channel, scb->dev_target));
} else { } else {
con_log(CL_ANN, (KERN_WARNING con_log(CL_ANN, (KERN_WARNING
"megaraid: IO packet with %d[%d:%d] being reset\n", "megaraid: IO packet with %d[%d:%d] being reset\n",

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

@ -1751,10 +1751,9 @@ static int megasas_wait_for_outstanding(struct megasas_instance *instance)
list_del_init(&reset_cmd->list); list_del_init(&reset_cmd->list);
if (reset_cmd->scmd) { if (reset_cmd->scmd) {
reset_cmd->scmd->result = DID_RESET << 16; reset_cmd->scmd->result = DID_RESET << 16;
printk(KERN_NOTICE "%d:%p reset [%02x], %#lx\n", printk(KERN_NOTICE "%d:%p reset [%02x]\n",
reset_index, reset_cmd, reset_index, reset_cmd,
reset_cmd->scmd->cmnd[0], reset_cmd->scmd->cmnd[0]);
reset_cmd->scmd->serial_number);
reset_cmd->scmd->scsi_done(reset_cmd->scmd); reset_cmd->scmd->scsi_done(reset_cmd->scmd);
megasas_return_cmd(instance, reset_cmd); megasas_return_cmd(instance, reset_cmd);
@ -1879,8 +1878,8 @@ static int megasas_generic_reset(struct scsi_cmnd *scmd)
instance = (struct megasas_instance *)scmd->device->host->hostdata; instance = (struct megasas_instance *)scmd->device->host->hostdata;
scmd_printk(KERN_NOTICE, scmd, "megasas: RESET -%ld cmd=%x retries=%x\n", scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n",
scmd->serial_number, scmd->cmnd[0], scmd->retries); scmd->cmnd[0], scmd->retries);
if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
printk(KERN_ERR "megasas: cannot recover from previous reset " printk(KERN_ERR "megasas: cannot recover from previous reset "
@ -2349,9 +2348,9 @@ megasas_issue_pending_cmds_again(struct megasas_instance *instance)
cmd->frame_phys_addr , cmd->frame_phys_addr ,
0, instance->reg_set); 0, instance->reg_set);
} else if (cmd->scmd) { } else if (cmd->scmd) {
printk(KERN_NOTICE "megasas: %p scsi cmd [%02x],%#lx" printk(KERN_NOTICE "megasas: %p scsi cmd [%02x]"
"detected on the internal queue, issue again.\n", "detected on the internal queue, issue again.\n",
cmd, cmd->scmd->cmnd[0], cmd->scmd->serial_number); cmd, cmd->scmd->cmnd[0]);
atomic_inc(&instance->fw_outstanding); atomic_inc(&instance->fw_outstanding);
instance->instancet->fire_cmd(instance, instance->instancet->fire_cmd(instance,

3
drivers/scsi/mesh.c
View file

@ -415,8 +415,7 @@ static void mesh_start_cmd(struct mesh_state *ms, struct scsi_cmnd *cmd)
#if 1 #if 1
if (DEBUG_TARGET(cmd)) { if (DEBUG_TARGET(cmd)) {
int i; int i;
printk(KERN_DEBUG "mesh_start: %p ser=%lu tgt=%d cmd=", printk(KERN_DEBUG "mesh_start: %p tgt=%d cmd=", cmd, id);
cmd, cmd->serial_number, id);
for (i = 0; i < cmd->cmd_len; ++i) for (i = 0; i < cmd->cmd_len; ++i)
printk(" %x", cmd->cmnd[i]); printk(" %x", cmd->cmnd[i]);
printk(" use_sg=%d buffer=%p bufflen=%u\n", printk(" use_sg=%d buffer=%p bufflen=%u\n",

2
drivers/scsi/ncr53c8xx.c
View file

@ -8147,7 +8147,7 @@ static int ncr53c8xx_abort(struct scsi_cmnd *cmd)
unsigned long flags; unsigned long flags;
struct scsi_cmnd *done_list; struct scsi_cmnd *done_list;
printk("ncr53c8xx_abort: command pid %lu\n", cmd->serial_number); printk("ncr53c8xx_abort\n");
NCR_LOCK_NCB(np, flags); NCR_LOCK_NCB(np, flags);

2
drivers/scsi/qla1280.c
View file

@ -4066,7 +4066,7 @@ __qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
} */ } */
printk(" tag=%d, transfersize=0x%x \n", printk(" tag=%d, transfersize=0x%x \n",
cmd->tag, cmd->transfersize); cmd->tag, cmd->transfersize);
printk(" Pid=%li, SP=0x%p\n", cmd->serial_number, CMD_SP(cmd)); printk(" SP=0x%p\n", CMD_SP(cmd));
printk(" underflow size = 0x%x, direction=0x%x\n", printk(" underflow size = 0x%x, direction=0x%x\n",
cmd->underflow, cmd->sc_data_direction); cmd->underflow, cmd->sc_data_direction);
} }

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

@ -2068,15 +2068,14 @@ static int qla4xxx_eh_abort(struct scsi_cmnd *cmd)
struct scsi_qla_host *ha = to_qla_host(cmd->device->host); struct scsi_qla_host *ha = to_qla_host(cmd->device->host);
unsigned int id = cmd->device->id; unsigned int id = cmd->device->id;
unsigned int lun = cmd->device->lun; unsigned int lun = cmd->device->lun;
unsigned long serial = cmd->serial_number;
unsigned long flags; unsigned long flags;
struct srb *srb = NULL; struct srb *srb = NULL;
int ret = SUCCESS; int ret = SUCCESS;
int wait = 0; int wait = 0;
ql4_printk(KERN_INFO, ha, ql4_printk(KERN_INFO, ha,
"scsi%ld:%d:%d: Abort command issued cmd=%p, pid=%ld\n", "scsi%ld:%d:%d: Abort command issued cmd=%p\n",
ha->host_no, id, lun, cmd, serial); ha->host_no, id, lun, cmd);
spin_lock_irqsave(&ha->hardware_lock, flags); spin_lock_irqsave(&ha->hardware_lock, flags);
srb = (struct srb *) CMD_SP(cmd); srb = (struct srb *) CMD_SP(cmd);

22
drivers/scsi/tmscsim.c
View file

@ -565,12 +565,12 @@ dc390_StartSCSI( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_sr
pDCB->TagMask |= 1 << tag[1]; pDCB->TagMask |= 1 << tag[1];
pSRB->TagNumber = tag[1]; pSRB->TagNumber = tag[1];
DC390_write8(ScsiFifo, tag[1]); DC390_write8(ScsiFifo, tag[1]);
DEBUG1(printk(KERN_INFO "DC390: Select w/DisCn for Cmd %li (SRB %p), block tag %02x\n", scmd->serial_number, pSRB, tag[1])); DEBUG1(printk(KERN_INFO "DC390: Select w/DisCn for SRB %p, block tag %02x\n", pSRB, tag[1]));
cmd = SEL_W_ATN3; cmd = SEL_W_ATN3;
} else { } else {
/* No TagQ */ /* No TagQ */
//no_tag: //no_tag:
DEBUG1(printk(KERN_INFO "DC390: Select w%s/DisCn for Cmd %li (SRB %p), No TagQ\n", disc_allowed ? "" : "o", scmd->serial_number, pSRB)); DEBUG1(printk(KERN_INFO "DC390: Select w%s/DisCn for SRB %p, No TagQ\n", disc_allowed ? "" : "o", pSRB));
} }
pSRB->SRBState = SRB_START_; pSRB->SRBState = SRB_START_;
@ -620,8 +620,8 @@ dc390_StartSCSI( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_sr
if (DC390_read8 (Scsi_Status) & INTERRUPT) if (DC390_read8 (Scsi_Status) & INTERRUPT)
{ {
dc390_freetag (pDCB, pSRB); dc390_freetag (pDCB, pSRB);
DEBUG0(printk ("DC390: Interrupt during Start SCSI (pid %li, target %02i-%02i)\n", DEBUG0(printk ("DC390: Interrupt during Start SCSI (target %02i-%02i)\n",
scmd->serial_number, scmd->device->id, scmd->device->lun)); scmd->device->id, scmd->device->lun));
pSRB->SRBState = SRB_READY; pSRB->SRBState = SRB_READY;
//DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD); //DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
pACB->SelLost++; pACB->SelLost++;
@ -1705,8 +1705,7 @@ dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb*
status = pSRB->TargetStatus; status = pSRB->TargetStatus;
DEBUG0(printk (" SRBdone (%02x,%08x), SRB %p, pid %li\n", status, pcmd->result,\ DEBUG0(printk (" SRBdone (%02x,%08x), SRB %p\n", status, pcmd->result, pSRB));
pSRB, pcmd->serial_number));
if(pSRB->SRBFlag & AUTO_REQSENSE) if(pSRB->SRBFlag & AUTO_REQSENSE)
{ /* Last command was a Request Sense */ { /* Last command was a Request Sense */
pSRB->SRBFlag &= ~AUTO_REQSENSE; pSRB->SRBFlag &= ~AUTO_REQSENSE;
@ -1727,7 +1726,7 @@ dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb*
} else { } else {
SET_RES_DRV(pcmd->result, DRIVER_SENSE); SET_RES_DRV(pcmd->result, DRIVER_SENSE);
//pSRB->ScsiCmdLen = (u8) (pSRB->Segment1[0] >> 8); //pSRB->ScsiCmdLen = (u8) (pSRB->Segment1[0] >> 8);
DEBUG0 (printk ("DC390: RETRY pid %li (%02x), target %02i-%02i\n", pcmd->serial_number, pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun)); DEBUG0 (printk ("DC390: RETRY (%02x), target %02i-%02i\n", pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun));
pSRB->TotalXferredLen = 0; pSRB->TotalXferredLen = 0;
SET_RES_DID(pcmd->result, DID_SOFT_ERROR); SET_RES_DID(pcmd->result, DID_SOFT_ERROR);
} }
@ -1747,7 +1746,7 @@ dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb*
else if (status == SAM_STAT_TASK_SET_FULL) else if (status == SAM_STAT_TASK_SET_FULL)
{ {
scsi_track_queue_full(pcmd->device, pDCB->GoingSRBCnt - 1); scsi_track_queue_full(pcmd->device, pDCB->GoingSRBCnt - 1);
DEBUG0 (printk ("DC390: RETRY pid %li (%02x), target %02i-%02i\n", pcmd->serial_number, pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun)); DEBUG0 (printk ("DC390: RETRY (%02x), target %02i-%02i\n", pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun));
pSRB->TotalXferredLen = 0; pSRB->TotalXferredLen = 0;
SET_RES_DID(pcmd->result, DID_SOFT_ERROR); SET_RES_DID(pcmd->result, DID_SOFT_ERROR);
} }
@ -1801,7 +1800,7 @@ cmd_done:
/* Add to free list */ /* Add to free list */
dc390_Free_insert (pACB, pSRB); dc390_Free_insert (pACB, pSRB);
DEBUG0(printk (KERN_DEBUG "DC390: SRBdone: done pid %li\n", pcmd->serial_number)); DEBUG0(printk (KERN_DEBUG "DC390: SRBdone: done\n"));
pcmd->scsi_done (pcmd); pcmd->scsi_done (pcmd);
return; return;
@ -1997,8 +1996,7 @@ static int DC390_abort(struct scsi_cmnd *cmd)
struct dc390_acb *pACB = (struct dc390_acb*) cmd->device->host->hostdata; struct dc390_acb *pACB = (struct dc390_acb*) cmd->device->host->hostdata;
struct dc390_dcb *pDCB = (struct dc390_dcb*) cmd->device->hostdata; struct dc390_dcb *pDCB = (struct dc390_dcb*) cmd->device->hostdata;
scmd_printk(KERN_WARNING, cmd, scmd_printk(KERN_WARNING, cmd, "DC390: Abort command\n");
"DC390: Abort command (pid %li)\n", cmd->serial_number);
/* abort() is too stupid for already sent commands at the moment. /* abort() is too stupid for already sent commands at the moment.
* If it's called we are in trouble anyway, so let's dump some info * If it's called we are in trouble anyway, so let's dump some info
@ -2006,7 +2004,7 @@ static int DC390_abort(struct scsi_cmnd *cmd)
dc390_dumpinfo(pACB, pDCB, NULL); dc390_dumpinfo(pACB, pDCB, NULL);
pDCB->DCBFlag |= ABORT_DEV_; pDCB->DCBFlag |= ABORT_DEV_;
printk(KERN_INFO "DC390: Aborted pid %li\n", cmd->serial_number); printk(KERN_INFO "DC390: Aborted.\n");
return FAILED; return FAILED;
} }

61
drivers/scsi/u14-34f.c
View file

@ -1256,8 +1256,8 @@ static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct
j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number; j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number;
if (SCpnt->host_scribble) if (SCpnt->host_scribble)
panic("%s: qcomm, pid %ld, SCpnt %p already active.\n", panic("%s: qcomm, SCpnt %p already active.\n",
BN(j), SCpnt->serial_number, SCpnt); BN(j), SCpnt);
/* i is the mailbox number, look for the first free mailbox /* i is the mailbox number, look for the first free mailbox
starting from last_cp_used */ starting from last_cp_used */
@ -1286,9 +1286,9 @@ static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct
cpp->cpp_index = i; cpp->cpp_index = i;
SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index; SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index;
if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.\n", if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d.\n",
BN(j), i, SCpnt->device->channel, SCpnt->device->id, BN(j), i, SCpnt->device->channel, SCpnt->device->id,
SCpnt->device->lun, SCpnt->serial_number); SCpnt->device->lun);
cpp->opcode = OP_SCSI; cpp->opcode = OP_SCSI;
cpp->channel = SCpnt->device->channel; cpp->channel = SCpnt->device->channel;
@ -1315,7 +1315,7 @@ static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct
unmap_dma(i, j); unmap_dma(i, j);
SCpnt->host_scribble = NULL; SCpnt->host_scribble = NULL;
scmd_printk(KERN_INFO, SCpnt, scmd_printk(KERN_INFO, SCpnt,
"qcomm, pid %ld, adapter busy.\n", SCpnt->serial_number); "qcomm, adapter busy.\n");
return 1; return 1;
} }
@ -1337,14 +1337,12 @@ static int u14_34f_eh_abort(struct scsi_cmnd *SCarg) {
j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number; j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
if (SCarg->host_scribble == NULL) { if (SCarg->host_scribble == NULL) {
scmd_printk(KERN_INFO, SCarg, "abort, pid %ld inactive.\n", scmd_printk(KERN_INFO, SCarg, "abort, command inactive.\n");
SCarg->serial_number);
return SUCCESS; return SUCCESS;
} }
i = *(unsigned int *)SCarg->host_scribble; i = *(unsigned int *)SCarg->host_scribble;
scmd_printk(KERN_INFO, SCarg, "abort, mbox %d, pid %ld.\n", scmd_printk(KERN_INFO, SCarg, "abort, mbox %d.\n", i);
i, SCarg->serial_number);
if (i >= sh[j]->can_queue) if (i >= sh[j]->can_queue)
panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j)); panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j));
@ -1387,8 +1385,7 @@ static int u14_34f_eh_abort(struct scsi_cmnd *SCarg) {
SCarg->result = DID_ABORT << 16; SCarg->result = DID_ABORT << 16;
SCarg->host_scribble = NULL; SCarg->host_scribble = NULL;
HD(j)->cp_stat[i] = FREE; HD(j)->cp_stat[i] = FREE;
printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n", printk("%s, abort, mbox %d ready, DID_ABORT, done.\n", BN(j), i);
BN(j), i, SCarg->serial_number);
SCarg->scsi_done(SCarg); SCarg->scsi_done(SCarg);
return SUCCESS; return SUCCESS;
} }
@ -1403,12 +1400,12 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
struct scsi_cmnd *SCpnt; struct scsi_cmnd *SCpnt;
j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number; j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
scmd_printk(KERN_INFO, SCarg, "reset, enter, pid %ld.\n", SCarg->serial_number); scmd_printk(KERN_INFO, SCarg, "reset, enter.\n");
spin_lock_irq(sh[j]->host_lock); spin_lock_irq(sh[j]->host_lock);
if (SCarg->host_scribble == NULL) if (SCarg->host_scribble == NULL)
printk("%s: reset, pid %ld inactive.\n", BN(j), SCarg->serial_number); printk("%s: reset, inactive.\n", BN(j));
if (HD(j)->in_reset) { if (HD(j)->in_reset) {
printk("%s: reset, exit, already in reset.\n", BN(j)); printk("%s: reset, exit, already in reset.\n", BN(j));
@ -1445,14 +1442,12 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) { if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
HD(j)->cp_stat[i] = ABORTING; HD(j)->cp_stat[i] = ABORTING;
printk("%s: reset, mbox %d aborting, pid %ld.\n", printk("%s: reset, mbox %d aborting.\n", BN(j), i);
BN(j), i, SCpnt->serial_number);
} }
else { else {
HD(j)->cp_stat[i] = IN_RESET; HD(j)->cp_stat[i] = IN_RESET;
printk("%s: reset, mbox %d in reset, pid %ld.\n", printk("%s: reset, mbox %d in reset.\n", BN(j), i);
BN(j), i, SCpnt->serial_number);
} }
if (SCpnt->host_scribble == NULL) if (SCpnt->host_scribble == NULL)
@ -1500,8 +1495,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
/* This mailbox is still waiting for its interrupt */ /* This mailbox is still waiting for its interrupt */
HD(j)->cp_stat[i] = LOCKED; HD(j)->cp_stat[i] = LOCKED;
printk("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n", printk("%s, reset, mbox %d locked, DID_RESET, done.\n", BN(j), i);
BN(j), i, SCpnt->serial_number);
} }
else if (HD(j)->cp_stat[i] == ABORTING) { else if (HD(j)->cp_stat[i] == ABORTING) {
@ -1513,8 +1507,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
/* This mailbox was never queued to the adapter */ /* This mailbox was never queued to the adapter */
HD(j)->cp_stat[i] = FREE; HD(j)->cp_stat[i] = FREE;
printk("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n", printk("%s, reset, mbox %d aborting, DID_RESET, done.\n", BN(j), i);
BN(j), i, SCpnt->serial_number);
} }
else else
@ -1528,7 +1521,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
HD(j)->in_reset = FALSE; HD(j)->in_reset = FALSE;
do_trace = FALSE; do_trace = FALSE;
if (arg_done) printk("%s: reset, exit, pid %ld done.\n", BN(j), SCarg->serial_number); if (arg_done) printk("%s: reset, exit, done.\n", BN(j));
else printk("%s: reset, exit.\n", BN(j)); else printk("%s: reset, exit.\n", BN(j));
spin_unlock_irq(sh[j]->host_lock); spin_unlock_irq(sh[j]->host_lock);
@ -1671,10 +1664,10 @@ static int reorder(unsigned int j, unsigned long cursec,
if (link_statistics && (overlap || !(flushcount % link_statistics))) if (link_statistics && (overlap || !(flushcount % link_statistics)))
for (n = 0; n < n_ready; n++) { for (n = 0; n < n_ready; n++) {
k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %u"\ printk("%s %d.%d:%d mb %d fc %d nr %d sec %ld ns %u"\
" cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n", " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
(ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target, (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target,
SCpnt->lun, SCpnt->serial_number, k, flushcount, n_ready, SCpnt->lun, k, flushcount, n_ready,
blk_rq_pos(SCpnt->request), blk_rq_sectors(SCpnt->request), blk_rq_pos(SCpnt->request), blk_rq_sectors(SCpnt->request),
cursec, YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only), cursec, YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
YESNO(overlap), cpp->xdir); YESNO(overlap), cpp->xdir);
@ -1709,9 +1702,9 @@ static void flush_dev(struct scsi_device *dev, unsigned long cursec, unsigned in
if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
scmd_printk(KERN_INFO, SCpnt, scmd_printk(KERN_INFO, SCpnt,
"%s, pid %ld, mbox %d, adapter" "%s, mbox %d, adapter"
" busy, will abort.\n", (ihdlr ? "ihdlr" : "qcomm"), " busy, will abort.\n", (ihdlr ? "ihdlr" : "qcomm"),
SCpnt->serial_number, k); k);
HD(j)->cp_stat[k] = ABORTING; HD(j)->cp_stat[k] = ABORTING;
continue; continue;
} }
@ -1793,12 +1786,12 @@ static irqreturn_t ihdlr(unsigned int j)
if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i); if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i);
if (SCpnt->host_scribble == NULL) if (SCpnt->host_scribble == NULL)
panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", BN(j), i, panic("%s: ihdlr, mbox %d, SCpnt %p garbled.\n", BN(j), i,
SCpnt->serial_number, SCpnt); SCpnt);
if (*(unsigned int *)SCpnt->host_scribble != i) if (*(unsigned int *)SCpnt->host_scribble != i)
panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n", panic("%s: ihdlr, mbox %d, index mismatch %d.\n",
BN(j), i, SCpnt->serial_number, *(unsigned int *)SCpnt->host_scribble); BN(j), i, *(unsigned int *)SCpnt->host_scribble);
sync_dma(i, j); sync_dma(i, j);
@ -1841,8 +1834,8 @@ static irqreturn_t ihdlr(unsigned int j)
(!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 && (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 &&
(SCpnt->sense_buffer[2] & 0xf) == NOT_READY))) (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
scmd_printk(KERN_INFO, SCpnt, scmd_printk(KERN_INFO, SCpnt,
"ihdlr, pid %ld, target_status 0x%x, sense key 0x%x.\n", "ihdlr, target_status 0x%x, sense key 0x%x.\n",
SCpnt->serial_number, spp->target_status, spp->target_status,
SCpnt->sense_buffer[2]); SCpnt->sense_buffer[2]);
HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] = 0; HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] = 0;
@ -1913,8 +1906,8 @@ static irqreturn_t ihdlr(unsigned int j)
do_trace || msg_byte(spp->target_status)) do_trace || msg_byte(spp->target_status))
#endif #endif
scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"\ scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"\
" pid %ld, reg 0x%x, count %d.\n", " reg 0x%x, count %d.\n",
i, spp->adapter_status, spp->target_status, SCpnt->serial_number, i, spp->adapter_status, spp->target_status,
reg, HD(j)->iocount); reg, HD(j)->iocount);
unmap_dma(i, j); unmap_dma(i, j);

45
drivers/scsi/wd33c93.c
View file

@ -381,7 +381,7 @@ wd33c93_queuecommand_lck(struct scsi_cmnd *cmd,
hostdata = (struct WD33C93_hostdata *) cmd->device->host->hostdata; hostdata = (struct WD33C93_hostdata *) cmd->device->host->hostdata;
DB(DB_QUEUE_COMMAND, DB(DB_QUEUE_COMMAND,
printk("Q-%d-%02x-%ld( ", cmd->device->id, cmd->cmnd[0], cmd->serial_number)) printk("Q-%d-%02x( ", cmd->device->id, cmd->cmnd[0]))
/* Set up a few fields in the scsi_cmnd structure for our own use: /* Set up a few fields in the scsi_cmnd structure for our own use:
* - host_scribble is the pointer to the next cmd in the input queue * - host_scribble is the pointer to the next cmd in the input queue
@ -462,7 +462,7 @@ wd33c93_queuecommand_lck(struct scsi_cmnd *cmd,
wd33c93_execute(cmd->device->host); wd33c93_execute(cmd->device->host);
DB(DB_QUEUE_COMMAND, printk(")Q-%ld ", cmd->serial_number)) DB(DB_QUEUE_COMMAND, printk(")Q "))
spin_unlock_irq(&hostdata->lock); spin_unlock_irq(&hostdata->lock);
return 0; return 0;
@ -687,7 +687,7 @@ wd33c93_execute(struct Scsi_Host *instance)
*/ */
DB(DB_EXECUTE, DB(DB_EXECUTE,
printk("%s%ld)EX-2 ", (cmd->SCp.phase) ? "d:" : "", cmd->serial_number)) printk("%s)EX-2 ", (cmd->SCp.phase) ? "d:" : ""))
} }
static void static void
@ -963,7 +963,7 @@ wd33c93_intr(struct Scsi_Host *instance)
case CSR_XFER_DONE | PHS_COMMAND: case CSR_XFER_DONE | PHS_COMMAND:
case CSR_UNEXP | PHS_COMMAND: case CSR_UNEXP | PHS_COMMAND:
case CSR_SRV_REQ | PHS_COMMAND: case CSR_SRV_REQ | PHS_COMMAND:
DB(DB_INTR, printk("CMND-%02x,%ld", cmd->cmnd[0], cmd->serial_number)) DB(DB_INTR, printk("CMND-%02x", cmd->cmnd[0]))
transfer_pio(regs, cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, transfer_pio(regs, cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR,
hostdata); hostdata);
hostdata->state = S_CONNECTED; hostdata->state = S_CONNECTED;
@ -1007,7 +1007,7 @@ wd33c93_intr(struct Scsi_Host *instance)
switch (msg) { switch (msg) {
case COMMAND_COMPLETE: case COMMAND_COMPLETE:
DB(DB_INTR, printk("CCMP-%ld", cmd->serial_number)) DB(DB_INTR, printk("CCMP"))
write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK); write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK);
hostdata->state = S_PRE_CMP_DISC; hostdata->state = S_PRE_CMP_DISC;
break; break;
@ -1174,7 +1174,7 @@ wd33c93_intr(struct Scsi_Host *instance)
write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER); write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER);
if (phs == 0x60) { if (phs == 0x60) {
DB(DB_INTR, printk("SX-DONE-%ld", cmd->serial_number)) DB(DB_INTR, printk("SX-DONE"))
cmd->SCp.Message = COMMAND_COMPLETE; cmd->SCp.Message = COMMAND_COMPLETE;
lun = read_wd33c93(regs, WD_TARGET_LUN); lun = read_wd33c93(regs, WD_TARGET_LUN);
DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun)) DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
@ -1200,8 +1200,8 @@ wd33c93_intr(struct Scsi_Host *instance)
wd33c93_execute(instance); wd33c93_execute(instance);
} else { } else {
printk printk
("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---", ("%02x:%02x:%02x: Unknown SEL_XFER_DONE phase!!---",
asr, sr, phs, cmd->serial_number); asr, sr, phs);
spin_unlock_irqrestore(&hostdata->lock, flags); spin_unlock_irqrestore(&hostdata->lock, flags);
} }
break; break;
@ -1266,7 +1266,7 @@ wd33c93_intr(struct Scsi_Host *instance)
spin_unlock_irqrestore(&hostdata->lock, flags); spin_unlock_irqrestore(&hostdata->lock, flags);
return; return;
} }
DB(DB_INTR, printk("UNEXP_DISC-%ld", cmd->serial_number)) DB(DB_INTR, printk("UNEXP_DISC"))
hostdata->connected = NULL; hostdata->connected = NULL;
hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun); hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
hostdata->state = S_UNCONNECTED; hostdata->state = S_UNCONNECTED;
@ -1292,7 +1292,7 @@ wd33c93_intr(struct Scsi_Host *instance)
*/ */
write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER); write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER);
DB(DB_INTR, printk("DISC-%ld", cmd->serial_number)) DB(DB_INTR, printk("DISC"))
if (cmd == NULL) { if (cmd == NULL) {
printk(" - Already disconnected! "); printk(" - Already disconnected! ");
hostdata->state = S_UNCONNECTED; hostdata->state = S_UNCONNECTED;
@ -1491,7 +1491,6 @@ wd33c93_intr(struct Scsi_Host *instance)
} else } else
hostdata->state = S_CONNECTED; hostdata->state = S_CONNECTED;
DB(DB_INTR, printk("-%ld", cmd->serial_number))
spin_unlock_irqrestore(&hostdata->lock, flags); spin_unlock_irqrestore(&hostdata->lock, flags);
break; break;
@ -1637,8 +1636,8 @@ wd33c93_abort(struct scsi_cmnd * cmd)
cmd->host_scribble = NULL; cmd->host_scribble = NULL;
cmd->result = DID_ABORT << 16; cmd->result = DID_ABORT << 16;
printk printk
("scsi%d: Abort - removing command %ld from input_Q. ", ("scsi%d: Abort - removing command from input_Q. ",
instance->host_no, cmd->serial_number); instance->host_no);
enable_irq(cmd->device->host->irq); enable_irq(cmd->device->host->irq);
cmd->scsi_done(cmd); cmd->scsi_done(cmd);
return SUCCESS; return SUCCESS;
@ -1662,8 +1661,8 @@ wd33c93_abort(struct scsi_cmnd * cmd)
uchar sr, asr; uchar sr, asr;
unsigned long timeout; unsigned long timeout;
printk("scsi%d: Aborting connected command %ld - ", printk("scsi%d: Aborting connected command - ",
instance->host_no, cmd->serial_number); instance->host_no);
printk("stopping DMA - "); printk("stopping DMA - ");
if (hostdata->dma == D_DMA_RUNNING) { if (hostdata->dma == D_DMA_RUNNING) {
@ -1729,8 +1728,8 @@ wd33c93_abort(struct scsi_cmnd * cmd)
while (tmp) { while (tmp) {
if (tmp == cmd) { if (tmp == cmd) {
printk printk
("scsi%d: Abort - command %ld found on disconnected_Q - ", ("scsi%d: Abort - command found on disconnected_Q - ",
instance->host_no, cmd->serial_number); instance->host_no);
printk("Abort SNOOZE. "); printk("Abort SNOOZE. ");
enable_irq(cmd->device->host->irq); enable_irq(cmd->device->host->irq);
return FAILED; return FAILED;
@ -2180,8 +2179,8 @@ wd33c93_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off
strcat(bp, "\nconnected: "); strcat(bp, "\nconnected: ");
if (hd->connected) { if (hd->connected) {
cmd = (struct scsi_cmnd *) hd->connected; cmd = (struct scsi_cmnd *) hd->connected;
sprintf(tbuf, " %ld-%d:%d(%02x)", sprintf(tbuf, " %d:%d(%02x)",
cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
strcat(bp, tbuf); strcat(bp, tbuf);
} }
} }
@ -2189,8 +2188,8 @@ wd33c93_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off
strcat(bp, "\ninput_Q: "); strcat(bp, "\ninput_Q: ");
cmd = (struct scsi_cmnd *) hd->input_Q; cmd = (struct scsi_cmnd *) hd->input_Q;
while (cmd) { while (cmd) {
sprintf(tbuf, " %ld-%d:%d(%02x)", sprintf(tbuf, " %d:%d(%02x)",
cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
strcat(bp, tbuf); strcat(bp, tbuf);
cmd = (struct scsi_cmnd *) cmd->host_scribble; cmd = (struct scsi_cmnd *) cmd->host_scribble;
} }
@ -2199,8 +2198,8 @@ wd33c93_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off
strcat(bp, "\ndisconnected_Q:"); strcat(bp, "\ndisconnected_Q:");
cmd = (struct scsi_cmnd *) hd->disconnected_Q; cmd = (struct scsi_cmnd *) hd->disconnected_Q;
while (cmd) { while (cmd) {
sprintf(tbuf, " %ld-%d:%d(%02x)", sprintf(tbuf, " %d:%d(%02x)",
cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
strcat(bp, tbuf); strcat(bp, tbuf);
cmd = (struct scsi_cmnd *) cmd->host_scribble; cmd = (struct scsi_cmnd *) cmd->host_scribble;
} }