aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/message/i2o/i2o_scsi.c4
-rw-r--r--drivers/scsi/dc395x.c193
-rw-r--r--drivers/scsi/dpt_i2o.c6
-rw-r--r--drivers/scsi/eata.c66
-rw-r--r--drivers/scsi/eata_pio.c19
-rw-r--r--drivers/scsi/in2000.c29
-rw-r--r--drivers/scsi/lpfc/lpfc_scsi.c14
-rw-r--r--drivers/scsi/megaraid.c20
-rw-r--r--drivers/scsi/megaraid/megaraid_mbox.c37
-rw-r--r--drivers/scsi/megaraid/megaraid_sas_base.c13
-rw-r--r--drivers/scsi/mesh.c3
-rw-r--r--drivers/scsi/ncr53c8xx.c2
-rw-r--r--drivers/scsi/qla1280.c2
-rw-r--r--drivers/scsi/qla4xxx/ql4_os.c5
-rw-r--r--drivers/scsi/tmscsim.c22
-rw-r--r--drivers/scsi/u14-34f.c61
-rw-r--r--drivers/scsi/wd33c93.c45
17 files changed, 255 insertions, 286 deletions
diff --git a/drivers/message/i2o/i2o_scsi.c b/drivers/message/i2o/i2o_scsi.c
index f003957e8e1c..74fbe56321ff 100644
--- a/drivers/message/i2o/i2o_scsi.c
+++ b/drivers/message/i2o/i2o_scsi.c
@@ -361,7 +361,7 @@ static int i2o_scsi_reply(struct i2o_controller *c, u32 m,
361 */ 361 */
362 error = le32_to_cpu(msg->body[0]); 362 error = le32_to_cpu(msg->body[0]);
363 363
364 osm_debug("Completed %ld\n", cmd->serial_number); 364 osm_debug("Completed %0x%p\n", cmd);
365 365
366 cmd->result = error & 0xff; 366 cmd->result = error & 0xff;
367 /* 367 /*
@@ -678,7 +678,7 @@ static int i2o_scsi_queuecommand_lck(struct scsi_cmnd *SCpnt,
678 /* Queue the message */ 678 /* Queue the message */
679 i2o_msg_post(c, msg); 679 i2o_msg_post(c, msg);
680 680
681 osm_debug("Issued %ld\n", SCpnt->serial_number); 681 osm_debug("Issued %0x%p\n", SCpnt);
682 682
683 return 0; 683 return 0;
684 684
diff --git a/drivers/scsi/dc395x.c b/drivers/scsi/dc395x.c
index b10b3841535c..f5b718d3c31b 100644
--- a/drivers/scsi/dc395x.c
+++ b/drivers/scsi/dc395x.c
@@ -778,8 +778,8 @@ static void srb_free_insert(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb)
778static void srb_waiting_insert(struct DeviceCtlBlk *dcb, 778static void srb_waiting_insert(struct DeviceCtlBlk *dcb,
779 struct ScsiReqBlk *srb) 779 struct ScsiReqBlk *srb)
780{ 780{
781 dprintkdbg(DBG_0, "srb_waiting_insert: (pid#%li) <%02i-%i> srb=%p\n", 781 dprintkdbg(DBG_0, "srb_waiting_insert: (0x%p) <%02i-%i> srb=%p\n",
782 srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); 782 srb->cmd, dcb->target_id, dcb->target_lun, srb);
783 list_add(&srb->list, &dcb->srb_waiting_list); 783 list_add(&srb->list, &dcb->srb_waiting_list);
784} 784}
785 785
@@ -787,16 +787,16 @@ static void srb_waiting_insert(struct DeviceCtlBlk *dcb,
787static void srb_waiting_append(struct DeviceCtlBlk *dcb, 787static void srb_waiting_append(struct DeviceCtlBlk *dcb,
788 struct ScsiReqBlk *srb) 788 struct ScsiReqBlk *srb)
789{ 789{
790 dprintkdbg(DBG_0, "srb_waiting_append: (pid#%li) <%02i-%i> srb=%p\n", 790 dprintkdbg(DBG_0, "srb_waiting_append: (0x%p) <%02i-%i> srb=%p\n",
791 srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); 791 srb->cmd, dcb->target_id, dcb->target_lun, srb);
792 list_add_tail(&srb->list, &dcb->srb_waiting_list); 792 list_add_tail(&srb->list, &dcb->srb_waiting_list);
793} 793}
794 794
795 795
796static void srb_going_append(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb) 796static void srb_going_append(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)
797{ 797{
798 dprintkdbg(DBG_0, "srb_going_append: (pid#%li) <%02i-%i> srb=%p\n", 798 dprintkdbg(DBG_0, "srb_going_append: (0x%p) <%02i-%i> srb=%p\n",
799 srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); 799 srb->cmd, dcb->target_id, dcb->target_lun, srb);
800 list_add_tail(&srb->list, &dcb->srb_going_list); 800 list_add_tail(&srb->list, &dcb->srb_going_list);
801} 801}
802 802
@@ -805,8 +805,8 @@ static void srb_going_remove(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)
805{ 805{
806 struct ScsiReqBlk *i; 806 struct ScsiReqBlk *i;
807 struct ScsiReqBlk *tmp; 807 struct ScsiReqBlk *tmp;
808 dprintkdbg(DBG_0, "srb_going_remove: (pid#%li) <%02i-%i> srb=%p\n", 808 dprintkdbg(DBG_0, "srb_going_remove: (0x%p) <%02i-%i> srb=%p\n",
809 srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); 809 srb->cmd, dcb->target_id, dcb->target_lun, srb);
810 810
811 list_for_each_entry_safe(i, tmp, &dcb->srb_going_list, list) 811 list_for_each_entry_safe(i, tmp, &dcb->srb_going_list, list)
812 if (i == srb) { 812 if (i == srb) {
@@ -821,8 +821,8 @@ static void srb_waiting_remove(struct DeviceCtlBlk *dcb,
821{ 821{
822 struct ScsiReqBlk *i; 822 struct ScsiReqBlk *i;
823 struct ScsiReqBlk *tmp; 823 struct ScsiReqBlk *tmp;
824 dprintkdbg(DBG_0, "srb_waiting_remove: (pid#%li) <%02i-%i> srb=%p\n", 824 dprintkdbg(DBG_0, "srb_waiting_remove: (0x%p) <%02i-%i> srb=%p\n",
825 srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); 825 srb->cmd, dcb->target_id, dcb->target_lun, srb);
826 826
827 list_for_each_entry_safe(i, tmp, &dcb->srb_waiting_list, list) 827 list_for_each_entry_safe(i, tmp, &dcb->srb_waiting_list, list)
828 if (i == srb) { 828 if (i == srb) {
@@ -836,8 +836,8 @@ static void srb_going_to_waiting_move(struct DeviceCtlBlk *dcb,
836 struct ScsiReqBlk *srb) 836 struct ScsiReqBlk *srb)
837{ 837{
838 dprintkdbg(DBG_0, 838 dprintkdbg(DBG_0,
839 "srb_going_to_waiting_move: (pid#%li) <%02i-%i> srb=%p\n", 839 "srb_going_to_waiting_move: (0x%p) <%02i-%i> srb=%p\n",
840 srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); 840 srb->cmd, dcb->target_id, dcb->target_lun, srb);
841 list_move(&srb->list, &dcb->srb_waiting_list); 841 list_move(&srb->list, &dcb->srb_waiting_list);
842} 842}
843 843
@@ -846,8 +846,8 @@ static void srb_waiting_to_going_move(struct DeviceCtlBlk *dcb,
846 struct ScsiReqBlk *srb) 846 struct ScsiReqBlk *srb)
847{ 847{
848 dprintkdbg(DBG_0, 848 dprintkdbg(DBG_0,
849 "srb_waiting_to_going_move: (pid#%li) <%02i-%i> srb=%p\n", 849 "srb_waiting_to_going_move: (0x%p) <%02i-%i> srb=%p\n",
850 srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); 850 srb->cmd, dcb->target_id, dcb->target_lun, srb);
851 list_move(&srb->list, &dcb->srb_going_list); 851 list_move(&srb->list, &dcb->srb_going_list);
852} 852}
853 853
@@ -982,8 +982,8 @@ static void build_srb(struct scsi_cmnd *cmd, struct DeviceCtlBlk *dcb,
982{ 982{
983 int nseg; 983 int nseg;
984 enum dma_data_direction dir = cmd->sc_data_direction; 984 enum dma_data_direction dir = cmd->sc_data_direction;
985 dprintkdbg(DBG_0, "build_srb: (pid#%li) <%02i-%i>\n", 985 dprintkdbg(DBG_0, "build_srb: (0x%p) <%02i-%i>\n",
986 cmd->serial_number, dcb->target_id, dcb->target_lun); 986 cmd, dcb->target_id, dcb->target_lun);
987 987
988 srb->dcb = dcb; 988 srb->dcb = dcb;
989 srb->cmd = cmd; 989 srb->cmd = cmd;
@@ -1086,8 +1086,8 @@ static int dc395x_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct s
1086 struct ScsiReqBlk *srb; 1086 struct ScsiReqBlk *srb;
1087 struct AdapterCtlBlk *acb = 1087 struct AdapterCtlBlk *acb =
1088 (struct AdapterCtlBlk *)cmd->device->host->hostdata; 1088 (struct AdapterCtlBlk *)cmd->device->host->hostdata;
1089 dprintkdbg(DBG_0, "queue_command: (pid#%li) <%02i-%i> cmnd=0x%02x\n", 1089 dprintkdbg(DBG_0, "queue_command: (0x%p) <%02i-%i> cmnd=0x%02x\n",
1090 cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); 1090 cmd, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
1091 1091
1092 /* Assume BAD_TARGET; will be cleared later */ 1092 /* Assume BAD_TARGET; will be cleared later */
1093 cmd->result = DID_BAD_TARGET << 16; 1093 cmd->result = DID_BAD_TARGET << 16;
@@ -1140,7 +1140,7 @@ static int dc395x_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct s
1140 /* process immediately */ 1140 /* process immediately */
1141 send_srb(acb, srb); 1141 send_srb(acb, srb);
1142 } 1142 }
1143 dprintkdbg(DBG_1, "queue_command: (pid#%li) done\n", cmd->serial_number); 1143 dprintkdbg(DBG_1, "queue_command: (0x%p) done\n", cmd);
1144 return 0; 1144 return 0;
1145 1145
1146complete: 1146complete:
@@ -1203,9 +1203,9 @@ static void dump_register_info(struct AdapterCtlBlk *acb,
1203 dprintkl(KERN_INFO, "dump: srb=%p cmd=%p OOOPS!\n", 1203 dprintkl(KERN_INFO, "dump: srb=%p cmd=%p OOOPS!\n",
1204 srb, srb->cmd); 1204 srb, srb->cmd);
1205 else 1205 else
1206 dprintkl(KERN_INFO, "dump: srb=%p cmd=%p (pid#%li) " 1206 dprintkl(KERN_INFO, "dump: srb=%p cmd=%p "
1207 "cmnd=0x%02x <%02i-%i>\n", 1207 "cmnd=0x%02x <%02i-%i>\n",
1208 srb, srb->cmd, srb->cmd->serial_number, 1208 srb, srb->cmd,
1209 srb->cmd->cmnd[0], srb->cmd->device->id, 1209 srb->cmd->cmnd[0], srb->cmd->device->id,
1210 srb->cmd->device->lun); 1210 srb->cmd->device->lun);
1211 printk(" sglist=%p cnt=%i idx=%i len=%zu\n", 1211 printk(" sglist=%p cnt=%i idx=%i len=%zu\n",
@@ -1301,8 +1301,8 @@ static int __dc395x_eh_bus_reset(struct scsi_cmnd *cmd)
1301 struct AdapterCtlBlk *acb = 1301 struct AdapterCtlBlk *acb =
1302 (struct AdapterCtlBlk *)cmd->device->host->hostdata; 1302 (struct AdapterCtlBlk *)cmd->device->host->hostdata;
1303 dprintkl(KERN_INFO, 1303 dprintkl(KERN_INFO,
1304 "eh_bus_reset: (pid#%li) target=<%02i-%i> cmd=%p\n", 1304 "eh_bus_reset: (0%p) target=<%02i-%i> cmd=%p\n",
1305 cmd->serial_number, cmd->device->id, cmd->device->lun, cmd); 1305 cmd, cmd->device->id, cmd->device->lun, cmd);
1306 1306
1307 if (timer_pending(&acb->waiting_timer)) 1307 if (timer_pending(&acb->waiting_timer))
1308 del_timer(&acb->waiting_timer); 1308 del_timer(&acb->waiting_timer);
@@ -1368,8 +1368,8 @@ static int dc395x_eh_abort(struct scsi_cmnd *cmd)
1368 (struct AdapterCtlBlk *)cmd->device->host->hostdata; 1368 (struct AdapterCtlBlk *)cmd->device->host->hostdata;
1369 struct DeviceCtlBlk *dcb; 1369 struct DeviceCtlBlk *dcb;
1370 struct ScsiReqBlk *srb; 1370 struct ScsiReqBlk *srb;
1371 dprintkl(KERN_INFO, "eh_abort: (pid#%li) target=<%02i-%i> cmd=%p\n", 1371 dprintkl(KERN_INFO, "eh_abort: (0x%p) target=<%02i-%i> cmd=%p\n",
1372 cmd->serial_number, cmd->device->id, cmd->device->lun, cmd); 1372 cmd, cmd->device->id, cmd->device->lun, cmd);
1373 1373
1374 dcb = find_dcb(acb, cmd->device->id, cmd->device->lun); 1374 dcb = find_dcb(acb, cmd->device->id, cmd->device->lun);
1375 if (!dcb) { 1375 if (!dcb) {
@@ -1495,8 +1495,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
1495 u16 s_stat2, return_code; 1495 u16 s_stat2, return_code;
1496 u8 s_stat, scsicommand, i, identify_message; 1496 u8 s_stat, scsicommand, i, identify_message;
1497 u8 *ptr; 1497 u8 *ptr;
1498 dprintkdbg(DBG_0, "start_scsi: (pid#%li) <%02i-%i> srb=%p\n", 1498 dprintkdbg(DBG_0, "start_scsi: (0x%p) <%02i-%i> srb=%p\n",
1499 srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb); 1499 dcb->target_id, dcb->target_lun, srb);
1500 1500
1501 srb->tag_number = TAG_NONE; /* acb->tag_max_num: had error read in eeprom */ 1501 srb->tag_number = TAG_NONE; /* acb->tag_max_num: had error read in eeprom */
1502 1502
@@ -1505,8 +1505,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
1505 s_stat2 = DC395x_read16(acb, TRM_S1040_SCSI_STATUS); 1505 s_stat2 = DC395x_read16(acb, TRM_S1040_SCSI_STATUS);
1506#if 1 1506#if 1
1507 if (s_stat & 0x20 /* s_stat2 & 0x02000 */ ) { 1507 if (s_stat & 0x20 /* s_stat2 & 0x02000 */ ) {
1508 dprintkdbg(DBG_KG, "start_scsi: (pid#%li) BUSY %02x %04x\n", 1508 dprintkdbg(DBG_KG, "start_scsi: (0x%p) BUSY %02x %04x\n",
1509 srb->cmd->serial_number, s_stat, s_stat2); 1509 s_stat, s_stat2);
1510 /* 1510 /*
1511 * Try anyway? 1511 * Try anyway?
1512 * 1512 *
@@ -1522,16 +1522,15 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
1522 } 1522 }
1523#endif 1523#endif
1524 if (acb->active_dcb) { 1524 if (acb->active_dcb) {
1525 dprintkl(KERN_DEBUG, "start_scsi: (pid#%li) Attempt to start a" 1525 dprintkl(KERN_DEBUG, "start_scsi: (0x%p) Attempt to start a"
1526 "command while another command (pid#%li) is active.", 1526 "command while another command (0x%p) is active.",
1527 srb->cmd->serial_number, 1527 srb->cmd,
1528 acb->active_dcb->active_srb ? 1528 acb->active_dcb->active_srb ?
1529 acb->active_dcb->active_srb->cmd->serial_number : 0); 1529 acb->active_dcb->active_srb->cmd : 0);
1530 return 1; 1530 return 1;
1531 } 1531 }
1532 if (DC395x_read16(acb, TRM_S1040_SCSI_STATUS) & SCSIINTERRUPT) { 1532 if (DC395x_read16(acb, TRM_S1040_SCSI_STATUS) & SCSIINTERRUPT) {
1533 dprintkdbg(DBG_KG, "start_scsi: (pid#%li) Failed (busy)\n", 1533 dprintkdbg(DBG_KG, "start_scsi: (0x%p) Failed (busy)\n", srb->cmd);
1534 srb->cmd->serial_number);
1535 return 1; 1534 return 1;
1536 } 1535 }
1537 /* Allow starting of SCSI commands half a second before we allow the mid-level 1536 /* 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,
1603 tag_number++; 1602 tag_number++;
1604 } 1603 }
1605 if (tag_number >= dcb->max_command) { 1604 if (tag_number >= dcb->max_command) {
1606 dprintkl(KERN_WARNING, "start_scsi: (pid#%li) " 1605 dprintkl(KERN_WARNING, "start_scsi: (0x%p) "
1607 "Out of tags target=<%02i-%i>)\n", 1606 "Out of tags target=<%02i-%i>)\n",
1608 srb->cmd->serial_number, srb->cmd->device->id, 1607 srb->cmd, srb->cmd->device->id,
1609 srb->cmd->device->lun); 1608 srb->cmd->device->lun);
1610 srb->state = SRB_READY; 1609 srb->state = SRB_READY;
1611 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, 1610 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL,
@@ -1623,8 +1622,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
1623#endif 1622#endif
1624/*polling:*/ 1623/*polling:*/
1625 /* Send CDB ..command block ......... */ 1624 /* Send CDB ..command block ......... */
1626 dprintkdbg(DBG_KG, "start_scsi: (pid#%li) <%02i-%i> cmnd=0x%02x tag=%i\n", 1625 dprintkdbg(DBG_KG, "start_scsi: (0x%p) <%02i-%i> cmnd=0x%02x tag=%i\n",
1627 srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun, 1626 srb->cmd, srb->cmd->device->id, srb->cmd->device->lun,
1628 srb->cmd->cmnd[0], srb->tag_number); 1627 srb->cmd->cmnd[0], srb->tag_number);
1629 if (srb->flag & AUTO_REQSENSE) { 1628 if (srb->flag & AUTO_REQSENSE) {
1630 DC395x_write8(acb, TRM_S1040_SCSI_FIFO, REQUEST_SENSE); 1629 DC395x_write8(acb, TRM_S1040_SCSI_FIFO, REQUEST_SENSE);
@@ -1647,8 +1646,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
1647 * we caught an interrupt (must be reset or reselection ... ) 1646 * we caught an interrupt (must be reset or reselection ... )
1648 * : Let's process it first! 1647 * : Let's process it first!
1649 */ 1648 */
1650 dprintkdbg(DBG_0, "start_scsi: (pid#%li) <%02i-%i> Failed - busy\n", 1649 dprintkdbg(DBG_0, "start_scsi: (0x%p) <%02i-%i> Failed - busy\n",
1651 srb->cmd->serial_number, dcb->target_id, dcb->target_lun); 1650 srb->cmd, dcb->target_id, dcb->target_lun);
1652 srb->state = SRB_READY; 1651 srb->state = SRB_READY;
1653 free_tag(dcb, srb); 1652 free_tag(dcb, srb);
1654 srb->msg_count = 0; 1653 srb->msg_count = 0;
@@ -1843,7 +1842,7 @@ static irqreturn_t dc395x_interrupt(int irq, void *dev_id)
1843static void msgout_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 1842static void msgout_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
1844 u16 *pscsi_status) 1843 u16 *pscsi_status)
1845{ 1844{
1846 dprintkdbg(DBG_0, "msgout_phase0: (pid#%li)\n", srb->cmd->serial_number); 1845 dprintkdbg(DBG_0, "msgout_phase0: (0x%p)\n", srb->cmd);
1847 if (srb->state & (SRB_UNEXPECT_RESEL + SRB_ABORT_SENT)) 1846 if (srb->state & (SRB_UNEXPECT_RESEL + SRB_ABORT_SENT))
1848 *pscsi_status = PH_BUS_FREE; /*.. initial phase */ 1847 *pscsi_status = PH_BUS_FREE; /*.. initial phase */
1849 1848
@@ -1857,18 +1856,18 @@ static void msgout_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
1857{ 1856{
1858 u16 i; 1857 u16 i;
1859 u8 *ptr; 1858 u8 *ptr;
1860 dprintkdbg(DBG_0, "msgout_phase1: (pid#%li)\n", srb->cmd->serial_number); 1859 dprintkdbg(DBG_0, "msgout_phase1: (0x%p)\n", srb->cmd);
1861 1860
1862 clear_fifo(acb, "msgout_phase1"); 1861 clear_fifo(acb, "msgout_phase1");
1863 if (!(srb->state & SRB_MSGOUT)) { 1862 if (!(srb->state & SRB_MSGOUT)) {
1864 srb->state |= SRB_MSGOUT; 1863 srb->state |= SRB_MSGOUT;
1865 dprintkl(KERN_DEBUG, 1864 dprintkl(KERN_DEBUG,
1866 "msgout_phase1: (pid#%li) Phase unexpected\n", 1865 "msgout_phase1: (0x%p) Phase unexpected\n",
1867 srb->cmd->serial_number); /* So what ? */ 1866 srb->cmd); /* So what ? */
1868 } 1867 }
1869 if (!srb->msg_count) { 1868 if (!srb->msg_count) {
1870 dprintkdbg(DBG_0, "msgout_phase1: (pid#%li) NOP msg\n", 1869 dprintkdbg(DBG_0, "msgout_phase1: (0x%p) NOP msg\n",
1871 srb->cmd->serial_number); 1870 srb->cmd);
1872 DC395x_write8(acb, TRM_S1040_SCSI_FIFO, MSG_NOP); 1871 DC395x_write8(acb, TRM_S1040_SCSI_FIFO, MSG_NOP);
1873 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */ 1872 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */
1874 DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_FIFO_OUT); 1873 DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_FIFO_OUT);
@@ -1888,7 +1887,7 @@ static void msgout_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
1888static void command_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 1887static void command_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
1889 u16 *pscsi_status) 1888 u16 *pscsi_status)
1890{ 1889{
1891 dprintkdbg(DBG_0, "command_phase0: (pid#%li)\n", srb->cmd->serial_number); 1890 dprintkdbg(DBG_0, "command_phase0: (0x%p)\n", srb->cmd);
1892 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); 1891 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);
1893} 1892}
1894 1893
@@ -1899,7 +1898,7 @@ static void command_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
1899 struct DeviceCtlBlk *dcb; 1898 struct DeviceCtlBlk *dcb;
1900 u8 *ptr; 1899 u8 *ptr;
1901 u16 i; 1900 u16 i;
1902 dprintkdbg(DBG_0, "command_phase1: (pid#%li)\n", srb->cmd->serial_number); 1901 dprintkdbg(DBG_0, "command_phase1: (0x%p)\n", srb->cmd);
1903 1902
1904 clear_fifo(acb, "command_phase1"); 1903 clear_fifo(acb, "command_phase1");
1905 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_CLRATN); 1904 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_CLRATN);
@@ -2041,8 +2040,8 @@ static void data_out_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2041 struct DeviceCtlBlk *dcb = srb->dcb; 2040 struct DeviceCtlBlk *dcb = srb->dcb;
2042 u16 scsi_status = *pscsi_status; 2041 u16 scsi_status = *pscsi_status;
2043 u32 d_left_counter = 0; 2042 u32 d_left_counter = 0;
2044 dprintkdbg(DBG_0, "data_out_phase0: (pid#%li) <%02i-%i>\n", 2043 dprintkdbg(DBG_0, "data_out_phase0: (0x%p) <%02i-%i>\n",
2045 srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun); 2044 srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
2046 2045
2047 /* 2046 /*
2048 * KG: We need to drain the buffers before we draw any conclusions! 2047 * 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,
2171static void data_out_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 2170static void data_out_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2172 u16 *pscsi_status) 2171 u16 *pscsi_status)
2173{ 2172{
2174 dprintkdbg(DBG_0, "data_out_phase1: (pid#%li) <%02i-%i>\n", 2173 dprintkdbg(DBG_0, "data_out_phase1: (0x%p) <%02i-%i>\n",
2175 srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun); 2174 srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
2176 clear_fifo(acb, "data_out_phase1"); 2175 clear_fifo(acb, "data_out_phase1");
2177 /* do prepare before transfer when data out phase */ 2176 /* do prepare before transfer when data out phase */
2178 data_io_transfer(acb, srb, XFERDATAOUT); 2177 data_io_transfer(acb, srb, XFERDATAOUT);
@@ -2183,8 +2182,8 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2183{ 2182{
2184 u16 scsi_status = *pscsi_status; 2183 u16 scsi_status = *pscsi_status;
2185 2184
2186 dprintkdbg(DBG_0, "data_in_phase0: (pid#%li) <%02i-%i>\n", 2185 dprintkdbg(DBG_0, "data_in_phase0: (0x%p) <%02i-%i>\n",
2187 srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun); 2186 srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
2188 2187
2189 /* 2188 /*
2190 * KG: DataIn is much more tricky than DataOut. When the device is finished 2189 * 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,
2204 unsigned int sc, fc; 2203 unsigned int sc, fc;
2205 2204
2206 if (scsi_status & PARITYERROR) { 2205 if (scsi_status & PARITYERROR) {
2207 dprintkl(KERN_INFO, "data_in_phase0: (pid#%li) " 2206 dprintkl(KERN_INFO, "data_in_phase0: (0x%p) "
2208 "Parity Error\n", srb->cmd->serial_number); 2207 "Parity Error\n", srb->cmd);
2209 srb->status |= PARITY_ERROR; 2208 srb->status |= PARITY_ERROR;
2210 } 2209 }
2211 /* 2210 /*
@@ -2394,8 +2393,8 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2394static void data_in_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 2393static void data_in_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2395 u16 *pscsi_status) 2394 u16 *pscsi_status)
2396{ 2395{
2397 dprintkdbg(DBG_0, "data_in_phase1: (pid#%li) <%02i-%i>\n", 2396 dprintkdbg(DBG_0, "data_in_phase1: (0x%p) <%02i-%i>\n",
2398 srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun); 2397 srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
2399 data_io_transfer(acb, srb, XFERDATAIN); 2398 data_io_transfer(acb, srb, XFERDATAIN);
2400} 2399}
2401 2400
@@ -2406,8 +2405,8 @@ static void data_io_transfer(struct AdapterCtlBlk *acb,
2406 struct DeviceCtlBlk *dcb = srb->dcb; 2405 struct DeviceCtlBlk *dcb = srb->dcb;
2407 u8 bval; 2406 u8 bval;
2408 dprintkdbg(DBG_0, 2407 dprintkdbg(DBG_0,
2409 "data_io_transfer: (pid#%li) <%02i-%i> %c len=%i, sg=(%i/%i)\n", 2408 "data_io_transfer: (0x%p) <%02i-%i> %c len=%i, sg=(%i/%i)\n",
2410 srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun, 2409 srb->cmd, srb->cmd->device->id, srb->cmd->device->lun,
2411 ((io_dir & DMACMD_DIR) ? 'r' : 'w'), 2410 ((io_dir & DMACMD_DIR) ? 'r' : 'w'),
2412 srb->total_xfer_length, srb->sg_index, srb->sg_count); 2411 srb->total_xfer_length, srb->sg_index, srb->sg_count);
2413 if (srb == acb->tmp_srb) 2412 if (srb == acb->tmp_srb)
@@ -2579,8 +2578,8 @@ static void data_io_transfer(struct AdapterCtlBlk *acb,
2579static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 2578static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2580 u16 *pscsi_status) 2579 u16 *pscsi_status)
2581{ 2580{
2582 dprintkdbg(DBG_0, "status_phase0: (pid#%li) <%02i-%i>\n", 2581 dprintkdbg(DBG_0, "status_phase0: (0x%p) <%02i-%i>\n",
2583 srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun); 2582 srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
2584 srb->target_status = DC395x_read8(acb, TRM_S1040_SCSI_FIFO); 2583 srb->target_status = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
2585 srb->end_message = DC395x_read8(acb, TRM_S1040_SCSI_FIFO); /* get message */ 2584 srb->end_message = DC395x_read8(acb, TRM_S1040_SCSI_FIFO); /* get message */
2586 srb->state = SRB_COMPLETED; 2585 srb->state = SRB_COMPLETED;
@@ -2593,8 +2592,8 @@ static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2593static void status_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 2592static void status_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2594 u16 *pscsi_status) 2593 u16 *pscsi_status)
2595{ 2594{
2596 dprintkdbg(DBG_0, "status_phase1: (pid#%li) <%02i-%i>\n", 2595 dprintkdbg(DBG_0, "status_phase1: (0x%p) <%02i-%i>\n",
2597 srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun); 2596 srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
2598 srb->state = SRB_STATUS; 2597 srb->state = SRB_STATUS;
2599 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */ 2598 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH); /* it's important for atn stop */
2600 DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_COMP); 2599 DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_COMP);
@@ -2635,8 +2634,8 @@ static struct ScsiReqBlk *msgin_qtag(struct AdapterCtlBlk *acb,
2635{ 2634{
2636 struct ScsiReqBlk *srb = NULL; 2635 struct ScsiReqBlk *srb = NULL;
2637 struct ScsiReqBlk *i; 2636 struct ScsiReqBlk *i;
2638 dprintkdbg(DBG_0, "msgin_qtag: (pid#%li) tag=%i srb=%p\n", 2637 dprintkdbg(DBG_0, "msgin_qtag: (0x%p) tag=%i srb=%p\n",
2639 srb->cmd->serial_number, tag, srb); 2638 srb->cmd, tag, srb);
2640 2639
2641 if (!(dcb->tag_mask & (1 << tag))) 2640 if (!(dcb->tag_mask & (1 << tag)))
2642 dprintkl(KERN_DEBUG, 2641 dprintkl(KERN_DEBUG,
@@ -2654,8 +2653,8 @@ static struct ScsiReqBlk *msgin_qtag(struct AdapterCtlBlk *acb,
2654 if (!srb) 2653 if (!srb)
2655 goto mingx0; 2654 goto mingx0;
2656 2655
2657 dprintkdbg(DBG_0, "msgin_qtag: (pid#%li) <%02i-%i>\n", 2656 dprintkdbg(DBG_0, "msgin_qtag: (0x%p) <%02i-%i>\n",
2658 srb->cmd->serial_number, srb->dcb->target_id, srb->dcb->target_lun); 2657 srb->cmd, srb->dcb->target_id, srb->dcb->target_lun);
2659 if (dcb->flag & ABORT_DEV_) { 2658 if (dcb->flag & ABORT_DEV_) {
2660 /*srb->state = SRB_ABORT_SENT; */ 2659 /*srb->state = SRB_ABORT_SENT; */
2661 enable_msgout_abort(acb, srb); 2660 enable_msgout_abort(acb, srb);
@@ -2865,7 +2864,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2865 u16 *pscsi_status) 2864 u16 *pscsi_status)
2866{ 2865{
2867 struct DeviceCtlBlk *dcb = acb->active_dcb; 2866 struct DeviceCtlBlk *dcb = acb->active_dcb;
2868 dprintkdbg(DBG_0, "msgin_phase0: (pid#%li)\n", srb->cmd->serial_number); 2867 dprintkdbg(DBG_0, "msgin_phase0: (0x%p)\n", srb->cmd);
2869 2868
2870 srb->msgin_buf[acb->msg_len++] = DC395x_read8(acb, TRM_S1040_SCSI_FIFO); 2869 srb->msgin_buf[acb->msg_len++] = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
2871 if (msgin_completed(srb->msgin_buf, acb->msg_len)) { 2870 if (msgin_completed(srb->msgin_buf, acb->msg_len)) {
@@ -2931,9 +2930,9 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2931 * SAVE POINTER may be ignored as we have the struct 2930 * SAVE POINTER may be ignored as we have the struct
2932 * ScsiReqBlk* associated with the scsi command. 2931 * ScsiReqBlk* associated with the scsi command.
2933 */ 2932 */
2934 dprintkdbg(DBG_0, "msgin_phase0: (pid#%li) " 2933 dprintkdbg(DBG_0, "msgin_phase0: (0x%p) "
2935 "SAVE POINTER rem=%i Ignore\n", 2934 "SAVE POINTER rem=%i Ignore\n",
2936 srb->cmd->serial_number, srb->total_xfer_length); 2935 srb->cmd, srb->total_xfer_length);
2937 break; 2936 break;
2938 2937
2939 case RESTORE_POINTERS: 2938 case RESTORE_POINTERS:
@@ -2941,9 +2940,9 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2941 break; 2940 break;
2942 2941
2943 case ABORT: 2942 case ABORT:
2944 dprintkdbg(DBG_0, "msgin_phase0: (pid#%li) " 2943 dprintkdbg(DBG_0, "msgin_phase0: (0x%p) "
2945 "<%02i-%i> ABORT msg\n", 2944 "<%02i-%i> ABORT msg\n",
2946 srb->cmd->serial_number, dcb->target_id, 2945 srb->cmd, dcb->target_id,
2947 dcb->target_lun); 2946 dcb->target_lun);
2948 dcb->flag |= ABORT_DEV_; 2947 dcb->flag |= ABORT_DEV_;
2949 enable_msgout_abort(acb, srb); 2948 enable_msgout_abort(acb, srb);
@@ -2975,7 +2974,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2975static void msgin_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 2974static void msgin_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
2976 u16 *pscsi_status) 2975 u16 *pscsi_status)
2977{ 2976{
2978 dprintkdbg(DBG_0, "msgin_phase1: (pid#%li)\n", srb->cmd->serial_number); 2977 dprintkdbg(DBG_0, "msgin_phase1: (0x%p)\n", srb->cmd);
2979 clear_fifo(acb, "msgin_phase1"); 2978 clear_fifo(acb, "msgin_phase1");
2980 DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 1); 2979 DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 1);
2981 if (!(srb->state & SRB_MSGIN)) { 2980 if (!(srb->state & SRB_MSGIN)) {
@@ -3041,7 +3040,7 @@ static void disconnect(struct AdapterCtlBlk *acb)
3041 } 3040 }
3042 srb = dcb->active_srb; 3041 srb = dcb->active_srb;
3043 acb->active_dcb = NULL; 3042 acb->active_dcb = NULL;
3044 dprintkdbg(DBG_0, "disconnect: (pid#%li)\n", srb->cmd->serial_number); 3043 dprintkdbg(DBG_0, "disconnect: (0x%p)\n", srb->cmd);
3045 3044
3046 srb->scsi_phase = PH_BUS_FREE; /* initial phase */ 3045 srb->scsi_phase = PH_BUS_FREE; /* initial phase */
3047 clear_fifo(acb, "disconnect"); 3046 clear_fifo(acb, "disconnect");
@@ -3071,14 +3070,14 @@ static void disconnect(struct AdapterCtlBlk *acb)
3071 && srb->state != SRB_MSGOUT) { 3070 && srb->state != SRB_MSGOUT) {
3072 srb->state = SRB_READY; 3071 srb->state = SRB_READY;
3073 dprintkl(KERN_DEBUG, 3072 dprintkl(KERN_DEBUG,
3074 "disconnect: (pid#%li) Unexpected\n", 3073 "disconnect: (0x%p) Unexpected\n",
3075 srb->cmd->serial_number); 3074 srb->cmd);
3076 srb->target_status = SCSI_STAT_SEL_TIMEOUT; 3075 srb->target_status = SCSI_STAT_SEL_TIMEOUT;
3077 goto disc1; 3076 goto disc1;
3078 } else { 3077 } else {
3079 /* Normal selection timeout */ 3078 /* Normal selection timeout */
3080 dprintkdbg(DBG_KG, "disconnect: (pid#%li) " 3079 dprintkdbg(DBG_KG, "disconnect: (0x%p) "
3081 "<%02i-%i> SelTO\n", srb->cmd->serial_number, 3080 "<%02i-%i> SelTO\n", srb->cmd,
3082 dcb->target_id, dcb->target_lun); 3081 dcb->target_id, dcb->target_lun);
3083 if (srb->retry_count++ > DC395x_MAX_RETRIES 3082 if (srb->retry_count++ > DC395x_MAX_RETRIES
3084 || acb->scan_devices) { 3083 || acb->scan_devices) {
@@ -3089,8 +3088,8 @@ static void disconnect(struct AdapterCtlBlk *acb)
3089 free_tag(dcb, srb); 3088 free_tag(dcb, srb);
3090 srb_going_to_waiting_move(dcb, srb); 3089 srb_going_to_waiting_move(dcb, srb);
3091 dprintkdbg(DBG_KG, 3090 dprintkdbg(DBG_KG,
3092 "disconnect: (pid#%li) Retry\n", 3091 "disconnect: (0x%p) Retry\n",
3093 srb->cmd->serial_number); 3092 srb->cmd);
3094 waiting_set_timer(acb, HZ / 20); 3093 waiting_set_timer(acb, HZ / 20);
3095 } 3094 }
3096 } else if (srb->state & SRB_DISCONNECT) { 3095 } else if (srb->state & SRB_DISCONNECT) {
@@ -3142,9 +3141,9 @@ static void reselect(struct AdapterCtlBlk *acb)
3142 } 3141 }
3143 /* Why the if ? */ 3142 /* Why the if ? */
3144 if (!acb->scan_devices) { 3143 if (!acb->scan_devices) {
3145 dprintkdbg(DBG_KG, "reselect: (pid#%li) <%02i-%i> " 3144 dprintkdbg(DBG_KG, "reselect: (0x%p) <%02i-%i> "
3146 "Arb lost but Resel win rsel=%i stat=0x%04x\n", 3145 "Arb lost but Resel win rsel=%i stat=0x%04x\n",
3147 srb->cmd->serial_number, dcb->target_id, 3146 srb->cmd, dcb->target_id,
3148 dcb->target_lun, rsel_tar_lun_id, 3147 dcb->target_lun, rsel_tar_lun_id,
3149 DC395x_read16(acb, TRM_S1040_SCSI_STATUS)); 3148 DC395x_read16(acb, TRM_S1040_SCSI_STATUS));
3150 arblostflag = 1; 3149 arblostflag = 1;
@@ -3318,7 +3317,7 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
3318 enum dma_data_direction dir = cmd->sc_data_direction; 3317 enum dma_data_direction dir = cmd->sc_data_direction;
3319 int ckc_only = 1; 3318 int ckc_only = 1;
3320 3319
3321 dprintkdbg(DBG_1, "srb_done: (pid#%li) <%02i-%i>\n", srb->cmd->serial_number, 3320 dprintkdbg(DBG_1, "srb_done: (0x%p) <%02i-%i>\n", srb->cmd,
3322 srb->cmd->device->id, srb->cmd->device->lun); 3321 srb->cmd->device->id, srb->cmd->device->lun);
3323 dprintkdbg(DBG_SG, "srb_done: srb=%p sg=%i(%i/%i) buf=%p\n", 3322 dprintkdbg(DBG_SG, "srb_done: srb=%p sg=%i(%i/%i) buf=%p\n",
3324 srb, scsi_sg_count(cmd), srb->sg_index, srb->sg_count, 3323 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,
3497 cmd->SCp.buffers_residual = 0; 3496 cmd->SCp.buffers_residual = 0;
3498 if (debug_enabled(DBG_KG)) { 3497 if (debug_enabled(DBG_KG)) {
3499 if (srb->total_xfer_length) 3498 if (srb->total_xfer_length)
3500 dprintkdbg(DBG_KG, "srb_done: (pid#%li) <%02i-%i> " 3499 dprintkdbg(DBG_KG, "srb_done: (0x%p) <%02i-%i> "
3501 "cmnd=0x%02x Missed %i bytes\n", 3500 "cmnd=0x%02x Missed %i bytes\n",
3502 cmd->serial_number, cmd->device->id, cmd->device->lun, 3501 cmd, cmd->device->id, cmd->device->lun,
3503 cmd->cmnd[0], srb->total_xfer_length); 3502 cmd->cmnd[0], srb->total_xfer_length);
3504 } 3503 }
3505 3504
@@ -3508,8 +3507,8 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
3508 if (srb == acb->tmp_srb) 3507 if (srb == acb->tmp_srb)
3509 dprintkl(KERN_ERR, "srb_done: ERROR! Completed cmd with tmp_srb\n"); 3508 dprintkl(KERN_ERR, "srb_done: ERROR! Completed cmd with tmp_srb\n");
3510 else { 3509 else {
3511 dprintkdbg(DBG_0, "srb_done: (pid#%li) done result=0x%08x\n", 3510 dprintkdbg(DBG_0, "srb_done: (0x%p) done result=0x%08x\n",
3512 cmd->serial_number, cmd->result); 3511 cmd, cmd->result);
3513 srb_free_insert(acb, srb); 3512 srb_free_insert(acb, srb);
3514 } 3513 }
3515 pci_unmap_srb(acb, srb); 3514 pci_unmap_srb(acb, srb);
@@ -3538,7 +3537,7 @@ static void doing_srb_done(struct AdapterCtlBlk *acb, u8 did_flag,
3538 p = srb->cmd; 3537 p = srb->cmd;
3539 dir = p->sc_data_direction; 3538 dir = p->sc_data_direction;
3540 result = MK_RES(0, did_flag, 0, 0); 3539 result = MK_RES(0, did_flag, 0, 0);
3541 printk("G:%li(%02i-%i) ", p->serial_number, 3540 printk("G:%p(%02i-%i) ", p,
3542 p->device->id, p->device->lun); 3541 p->device->id, p->device->lun);
3543 srb_going_remove(dcb, srb); 3542 srb_going_remove(dcb, srb);
3544 free_tag(dcb, srb); 3543 free_tag(dcb, srb);
@@ -3568,7 +3567,7 @@ static void doing_srb_done(struct AdapterCtlBlk *acb, u8 did_flag,
3568 p = srb->cmd; 3567 p = srb->cmd;
3569 3568
3570 result = MK_RES(0, did_flag, 0, 0); 3569 result = MK_RES(0, did_flag, 0, 0);
3571 printk("W:%li<%02i-%i>", p->serial_number, p->device->id, 3570 printk("W:%p<%02i-%i>", p, p->device->id,
3572 p->device->lun); 3571 p->device->lun);
3573 srb_waiting_remove(dcb, srb); 3572 srb_waiting_remove(dcb, srb);
3574 srb_free_insert(acb, srb); 3573 srb_free_insert(acb, srb);
@@ -3677,8 +3676,8 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
3677 struct ScsiReqBlk *srb) 3676 struct ScsiReqBlk *srb)
3678{ 3677{
3679 struct scsi_cmnd *cmd = srb->cmd; 3678 struct scsi_cmnd *cmd = srb->cmd;
3680 dprintkdbg(DBG_1, "request_sense: (pid#%li) <%02i-%i>\n", 3679 dprintkdbg(DBG_1, "request_sense: (0x%p) <%02i-%i>\n",
3681 cmd->serial_number, cmd->device->id, cmd->device->lun); 3680 cmd, cmd->device->id, cmd->device->lun);
3682 3681
3683 srb->flag |= AUTO_REQSENSE; 3682 srb->flag |= AUTO_REQSENSE;
3684 srb->adapter_status = 0; 3683 srb->adapter_status = 0;
@@ -3708,8 +3707,8 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
3708 3707
3709 if (start_scsi(acb, dcb, srb)) { /* Should only happen, if sb. else grabs the bus */ 3708 if (start_scsi(acb, dcb, srb)) { /* Should only happen, if sb. else grabs the bus */
3710 dprintkl(KERN_DEBUG, 3709 dprintkl(KERN_DEBUG,
3711 "request_sense: (pid#%li) failed <%02i-%i>\n", 3710 "request_sense: (0x%p) failed <%02i-%i>\n",
3712 srb->cmd->serial_number, dcb->target_id, dcb->target_lun); 3711 srb->cmd, dcb->target_id, dcb->target_lun);
3713 srb_going_to_waiting_move(dcb, srb); 3712 srb_going_to_waiting_move(dcb, srb);
3714 waiting_set_timer(acb, HZ / 100); 3713 waiting_set_timer(acb, HZ / 100);
3715 } 3714 }
@@ -4717,13 +4716,13 @@ static int dc395x_proc_info(struct Scsi_Host *host, char *buffer,
4717 dcb->target_id, dcb->target_lun, 4716 dcb->target_id, dcb->target_lun,
4718 list_size(&dcb->srb_waiting_list)); 4717 list_size(&dcb->srb_waiting_list));
4719 list_for_each_entry(srb, &dcb->srb_waiting_list, list) 4718 list_for_each_entry(srb, &dcb->srb_waiting_list, list)
4720 SPRINTF(" %li", srb->cmd->serial_number); 4719 SPRINTF(" %p", srb->cmd);
4721 if (!list_empty(&dcb->srb_going_list)) 4720 if (!list_empty(&dcb->srb_going_list))
4722 SPRINTF("\nDCB (%02i-%i): Going : %i:", 4721 SPRINTF("\nDCB (%02i-%i): Going : %i:",
4723 dcb->target_id, dcb->target_lun, 4722 dcb->target_id, dcb->target_lun,
4724 list_size(&dcb->srb_going_list)); 4723 list_size(&dcb->srb_going_list));
4725 list_for_each_entry(srb, &dcb->srb_going_list, list) 4724 list_for_each_entry(srb, &dcb->srb_going_list, list)
4726 SPRINTF(" %li", srb->cmd->serial_number); 4725 SPRINTF(" %p", srb->cmd);
4727 if (!list_empty(&dcb->srb_waiting_list) || !list_empty(&dcb->srb_going_list)) 4726 if (!list_empty(&dcb->srb_waiting_list) || !list_empty(&dcb->srb_going_list))
4728 SPRINTF("\n"); 4727 SPRINTF("\n");
4729 } 4728 }
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index cffcb108ac96..b4f6c9a84e71 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -780,7 +780,7 @@ static int adpt_abort(struct scsi_cmnd * cmd)
780 return FAILED; 780 return FAILED;
781 } 781 }
782 pHba = (adpt_hba*) cmd->device->host->hostdata[0]; 782 pHba = (adpt_hba*) cmd->device->host->hostdata[0];
783 printk(KERN_INFO"%s: Trying to Abort cmd=%ld\n",pHba->name, cmd->serial_number); 783 printk(KERN_INFO"%s: Trying to Abort\n",pHba->name);
784 if ((dptdevice = (void*) (cmd->device->hostdata)) == NULL) { 784 if ((dptdevice = (void*) (cmd->device->hostdata)) == NULL) {
785 printk(KERN_ERR "%s: Unable to abort: No device in cmnd\n",pHba->name); 785 printk(KERN_ERR "%s: Unable to abort: No device in cmnd\n",pHba->name);
786 return FAILED; 786 return FAILED;
@@ -802,10 +802,10 @@ static int adpt_abort(struct scsi_cmnd * cmd)
802 printk(KERN_INFO"%s: Abort cmd not supported\n",pHba->name); 802 printk(KERN_INFO"%s: Abort cmd not supported\n",pHba->name);
803 return FAILED; 803 return FAILED;
804 } 804 }
805 printk(KERN_INFO"%s: Abort cmd=%ld failed.\n",pHba->name, cmd->serial_number); 805 printk(KERN_INFO"%s: Abort failed.\n",pHba->name);
806 return FAILED; 806 return FAILED;
807 } 807 }
808 printk(KERN_INFO"%s: Abort cmd=%ld complete.\n",pHba->name, cmd->serial_number); 808 printk(KERN_INFO"%s: Abort complete.\n",pHba->name);
809 return SUCCESS; 809 return SUCCESS;
810} 810}
811 811
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index 0eb4fe6a4c8a..94de88955a99 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -1766,8 +1766,8 @@ static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
1766 struct mscp *cpp; 1766 struct mscp *cpp;
1767 1767
1768 if (SCpnt->host_scribble) 1768 if (SCpnt->host_scribble)
1769 panic("%s: qcomm, pid %ld, SCpnt %p already active.\n", 1769 panic("%s: qcomm, SCpnt %p already active.\n",
1770 ha->board_name, SCpnt->serial_number, SCpnt); 1770 ha->board_name, SCpnt);
1771 1771
1772 /* i is the mailbox number, look for the first free mailbox 1772 /* i is the mailbox number, look for the first free mailbox
1773 starting from last_cp_used */ 1773 starting from last_cp_used */
@@ -1801,7 +1801,7 @@ static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
1801 1801
1802 if (do_trace) 1802 if (do_trace)
1803 scmd_printk(KERN_INFO, SCpnt, 1803 scmd_printk(KERN_INFO, SCpnt,
1804 "qcomm, mbox %d, pid %ld.\n", i, SCpnt->serial_number); 1804 "qcomm, mbox %d.\n", i);
1805 1805
1806 cpp->reqsen = 1; 1806 cpp->reqsen = 1;
1807 cpp->dispri = 1; 1807 cpp->dispri = 1;
@@ -1833,8 +1833,7 @@ static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
1833 if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) { 1833 if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
1834 unmap_dma(i, ha); 1834 unmap_dma(i, ha);
1835 SCpnt->host_scribble = NULL; 1835 SCpnt->host_scribble = NULL;
1836 scmd_printk(KERN_INFO, SCpnt, 1836 scmd_printk(KERN_INFO, SCpnt, "qcomm, adapter busy.\n");
1837 "qcomm, pid %ld, adapter busy.\n", SCpnt->serial_number);
1838 return 1; 1837 return 1;
1839 } 1838 }
1840 1839
@@ -1851,14 +1850,12 @@ static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
1851 unsigned int i; 1850 unsigned int i;
1852 1851
1853 if (SCarg->host_scribble == NULL) { 1852 if (SCarg->host_scribble == NULL) {
1854 scmd_printk(KERN_INFO, SCarg, 1853 scmd_printk(KERN_INFO, SCarg, "abort, cmd inactive.\n");
1855 "abort, pid %ld inactive.\n", SCarg->serial_number);
1856 return SUCCESS; 1854 return SUCCESS;
1857 } 1855 }
1858 1856
1859 i = *(unsigned int *)SCarg->host_scribble; 1857 i = *(unsigned int *)SCarg->host_scribble;
1860 scmd_printk(KERN_WARNING, SCarg, 1858 scmd_printk(KERN_WARNING, SCarg, "abort, mbox %d.\n", i);
1861 "abort, mbox %d, pid %ld.\n", i, SCarg->serial_number);
1862 1859
1863 if (i >= shost->can_queue) 1860 if (i >= shost->can_queue)
1864 panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name); 1861 panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name);
@@ -1902,8 +1899,8 @@ static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
1902 SCarg->result = DID_ABORT << 16; 1899 SCarg->result = DID_ABORT << 16;
1903 SCarg->host_scribble = NULL; 1900 SCarg->host_scribble = NULL;
1904 ha->cp_stat[i] = FREE; 1901 ha->cp_stat[i] = FREE;
1905 printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n", 1902 printk("%s, abort, mbox %d ready, DID_ABORT, done.\n",
1906 ha->board_name, i, SCarg->serial_number); 1903 ha->board_name, i);
1907 SCarg->scsi_done(SCarg); 1904 SCarg->scsi_done(SCarg);
1908 return SUCCESS; 1905 return SUCCESS;
1909 } 1906 }
@@ -1919,13 +1916,12 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
1919 struct Scsi_Host *shost = SCarg->device->host; 1916 struct Scsi_Host *shost = SCarg->device->host;
1920 struct hostdata *ha = (struct hostdata *)shost->hostdata; 1917 struct hostdata *ha = (struct hostdata *)shost->hostdata;
1921 1918
1922 scmd_printk(KERN_INFO, SCarg, 1919 scmd_printk(KERN_INFO, SCarg, "reset, enter.\n");
1923 "reset, enter, pid %ld.\n", SCarg->serial_number);
1924 1920
1925 spin_lock_irq(shost->host_lock); 1921 spin_lock_irq(shost->host_lock);
1926 1922
1927 if (SCarg->host_scribble == NULL) 1923 if (SCarg->host_scribble == NULL)
1928 printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->serial_number); 1924 printk("%s: reset, inactive.\n", ha->board_name);
1929 1925
1930 if (ha->in_reset) { 1926 if (ha->in_reset) {
1931 printk("%s: reset, exit, already in reset.\n", ha->board_name); 1927 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)
1964 1960
1965 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) { 1961 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
1966 ha->cp_stat[i] = ABORTING; 1962 ha->cp_stat[i] = ABORTING;
1967 printk("%s: reset, mbox %d aborting, pid %ld.\n", 1963 printk("%s: reset, mbox %d aborting.\n",
1968 ha->board_name, i, SCpnt->serial_number); 1964 ha->board_name, i);
1969 } 1965 }
1970 1966
1971 else { 1967 else {
1972 ha->cp_stat[i] = IN_RESET; 1968 ha->cp_stat[i] = IN_RESET;
1973 printk("%s: reset, mbox %d in reset, pid %ld.\n", 1969 printk("%s: reset, mbox %d in reset.\n",
1974 ha->board_name, i, SCpnt->serial_number); 1970 ha->board_name, i);
1975 } 1971 }
1976 1972
1977 if (SCpnt->host_scribble == NULL) 1973 if (SCpnt->host_scribble == NULL)
@@ -2025,8 +2021,8 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
2025 ha->cp_stat[i] = LOCKED; 2021 ha->cp_stat[i] = LOCKED;
2026 2022
2027 printk 2023 printk
2028 ("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n", 2024 ("%s, reset, mbox %d locked, DID_RESET, done.\n",
2029 ha->board_name, i, SCpnt->serial_number); 2025 ha->board_name, i);
2030 } 2026 }
2031 2027
2032 else if (ha->cp_stat[i] == ABORTING) { 2028 else if (ha->cp_stat[i] == ABORTING) {
@@ -2039,8 +2035,8 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
2039 ha->cp_stat[i] = FREE; 2035 ha->cp_stat[i] = FREE;
2040 2036
2041 printk 2037 printk
2042 ("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n", 2038 ("%s, reset, mbox %d aborting, DID_RESET, done.\n",
2043 ha->board_name, i, SCpnt->serial_number); 2039 ha->board_name, i);
2044 } 2040 }
2045 2041
2046 else 2042 else
@@ -2054,7 +2050,7 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
2054 do_trace = 0; 2050 do_trace = 0;
2055 2051
2056 if (arg_done) 2052 if (arg_done)
2057 printk("%s: reset, exit, pid %ld done.\n", ha->board_name, SCarg->serial_number); 2053 printk("%s: reset, exit, done.\n", ha->board_name);
2058 else 2054 else
2059 printk("%s: reset, exit.\n", ha->board_name); 2055 printk("%s: reset, exit.\n", ha->board_name);
2060 2056
@@ -2238,10 +2234,10 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
2238 cpp = &ha->cp[k]; 2234 cpp = &ha->cp[k];
2239 SCpnt = cpp->SCpnt; 2235 SCpnt = cpp->SCpnt;
2240 scmd_printk(KERN_INFO, SCpnt, 2236 scmd_printk(KERN_INFO, SCpnt,
2241 "%s pid %ld mb %d fc %d nr %d sec %ld ns %u" 2237 "%s mb %d fc %d nr %d sec %ld ns %u"
2242 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n", 2238 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
2243 (ihdlr ? "ihdlr" : "qcomm"), 2239 (ihdlr ? "ihdlr" : "qcomm"),
2244 SCpnt->serial_number, k, flushcount, 2240 k, flushcount,
2245 n_ready, blk_rq_pos(SCpnt->request), 2241 n_ready, blk_rq_pos(SCpnt->request),
2246 blk_rq_sectors(SCpnt->request), cursec, YESNO(s), 2242 blk_rq_sectors(SCpnt->request), cursec, YESNO(s),
2247 YESNO(r), YESNO(rev), YESNO(input_only), 2243 YESNO(r), YESNO(rev), YESNO(input_only),
@@ -2285,10 +2281,10 @@ static void flush_dev(struct scsi_device *dev, unsigned long cursec,
2285 2281
2286 if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) { 2282 if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
2287 scmd_printk(KERN_INFO, SCpnt, 2283 scmd_printk(KERN_INFO, SCpnt,
2288 "%s, pid %ld, mbox %d, adapter" 2284 "%s, mbox %d, adapter"
2289 " busy, will abort.\n", 2285 " busy, will abort.\n",
2290 (ihdlr ? "ihdlr" : "qcomm"), 2286 (ihdlr ? "ihdlr" : "qcomm"),
2291 SCpnt->serial_number, k); 2287 k);
2292 ha->cp_stat[k] = ABORTING; 2288 ha->cp_stat[k] = ABORTING;
2293 continue; 2289 continue;
2294 } 2290 }
@@ -2398,12 +2394,12 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
2398 panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i); 2394 panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
2399 2395
2400 if (SCpnt->host_scribble == NULL) 2396 if (SCpnt->host_scribble == NULL)
2401 panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", ha->board_name, 2397 panic("%s: ihdlr, mbox %d, SCpnt %p garbled.\n", ha->board_name,
2402 i, SCpnt->serial_number, SCpnt); 2398 i, SCpnt);
2403 2399
2404 if (*(unsigned int *)SCpnt->host_scribble != i) 2400 if (*(unsigned int *)SCpnt->host_scribble != i)
2405 panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n", 2401 panic("%s: ihdlr, mbox %d, index mismatch %d.\n",
2406 ha->board_name, i, SCpnt->serial_number, 2402 ha->board_name, i,
2407 *(unsigned int *)SCpnt->host_scribble); 2403 *(unsigned int *)SCpnt->host_scribble);
2408 2404
2409 sync_dma(i, ha); 2405 sync_dma(i, ha);
@@ -2449,11 +2445,11 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
2449 if (spp->target_status && SCpnt->device->type == TYPE_DISK && 2445 if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
2450 (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 && 2446 (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 &&
2451 (SCpnt->sense_buffer[2] & 0xf) == NOT_READY))) 2447 (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
2452 printk("%s: ihdlr, target %d.%d:%d, pid %ld, " 2448 printk("%s: ihdlr, target %d.%d:%d, "
2453 "target_status 0x%x, sense key 0x%x.\n", 2449 "target_status 0x%x, sense key 0x%x.\n",
2454 ha->board_name, 2450 ha->board_name,
2455 SCpnt->device->channel, SCpnt->device->id, 2451 SCpnt->device->channel, SCpnt->device->id,
2456 SCpnt->device->lun, SCpnt->serial_number, 2452 SCpnt->device->lun,
2457 spp->target_status, SCpnt->sense_buffer[2]); 2453 spp->target_status, SCpnt->sense_buffer[2]);
2458 2454
2459 ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0; 2455 ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;
@@ -2522,9 +2518,9 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
2522 do_trace || msg_byte(spp->target_status)) 2518 do_trace || msg_byte(spp->target_status))
2523#endif 2519#endif
2524 scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x," 2520 scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"
2525 " pid %ld, reg 0x%x, count %d.\n", 2521 " reg 0x%x, count %d.\n",
2526 i, spp->adapter_status, spp->target_status, 2522 i, spp->adapter_status, spp->target_status,
2527 SCpnt->serial_number, reg, ha->iocount); 2523 reg, ha->iocount);
2528 2524
2529 unmap_dma(i, ha); 2525 unmap_dma(i, ha);
2530 2526
diff --git a/drivers/scsi/eata_pio.c b/drivers/scsi/eata_pio.c
index 4a9641e69f54..d5f8362335d3 100644
--- a/drivers/scsi/eata_pio.c
+++ b/drivers/scsi/eata_pio.c
@@ -372,8 +372,7 @@ static int eata_pio_queue_lck(struct scsi_cmnd *cmd,
372 cp->status = USED; /* claim free slot */ 372 cp->status = USED; /* claim free slot */
373 373
374 DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd, 374 DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd,
375 "eata_pio_queue pid %ld, y %d\n", 375 "eata_pio_queue 0x%p, y %d\n", cmd, y));
376 cmd->serial_number, y));
377 376
378 cmd->scsi_done = (void *) done; 377 cmd->scsi_done = (void *) done;
379 378
@@ -417,8 +416,8 @@ static int eata_pio_queue_lck(struct scsi_cmnd *cmd,
417 if (eata_pio_send_command(base, EATA_CMD_PIO_SEND_CP)) { 416 if (eata_pio_send_command(base, EATA_CMD_PIO_SEND_CP)) {
418 cmd->result = DID_BUS_BUSY << 16; 417 cmd->result = DID_BUS_BUSY << 16;
419 scmd_printk(KERN_NOTICE, cmd, 418 scmd_printk(KERN_NOTICE, cmd,
420 "eata_pio_queue pid %ld, HBA busy, " 419 "eata_pio_queue pid 0x%p, HBA busy, "
421 "returning DID_BUS_BUSY, done.\n", cmd->serial_number); 420 "returning DID_BUS_BUSY, done.\n", cmd);
422 done(cmd); 421 done(cmd);
423 cp->status = FREE; 422 cp->status = FREE;
424 return 0; 423 return 0;
@@ -432,8 +431,8 @@ static int eata_pio_queue_lck(struct scsi_cmnd *cmd,
432 outw(0, base + HA_RDATA); 431 outw(0, base + HA_RDATA);
433 432
434 DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd, 433 DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd,
435 "Queued base %#.4lx pid: %ld " 434 "Queued base %#.4lx cmd: 0x%p "
436 "slot %d irq %d\n", sh->base, cmd->serial_number, y, sh->irq)); 435 "slot %d irq %d\n", sh->base, cmd, y, sh->irq));
437 436
438 return 0; 437 return 0;
439} 438}
@@ -445,8 +444,7 @@ static int eata_pio_abort(struct scsi_cmnd *cmd)
445 unsigned int loop = 100; 444 unsigned int loop = 100;
446 445
447 DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd, 446 DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd,
448 "eata_pio_abort called pid: %ld\n", 447 "eata_pio_abort called pid: 0x%p\n", cmd));
449 cmd->serial_number));
450 448
451 while (inb(cmd->device->host->base + HA_RAUXSTAT) & HA_ABUSY) 449 while (inb(cmd->device->host->base + HA_RAUXSTAT) & HA_ABUSY)
452 if (--loop == 0) { 450 if (--loop == 0) {
@@ -481,8 +479,7 @@ static int eata_pio_host_reset(struct scsi_cmnd *cmd)
481 struct Scsi_Host *host = cmd->device->host; 479 struct Scsi_Host *host = cmd->device->host;
482 480
483 DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd, 481 DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd,
484 "eata_pio_reset called pid:%ld\n", 482 "eata_pio_reset called\n"));
485 cmd->serial_number));
486 483
487 spin_lock_irq(host->host_lock); 484 spin_lock_irq(host->host_lock);
488 485
@@ -501,7 +498,7 @@ static int eata_pio_host_reset(struct scsi_cmnd *cmd)
501 498
502 sp = HD(cmd)->ccb[x].cmd; 499 sp = HD(cmd)->ccb[x].cmd;
503 HD(cmd)->ccb[x].status = RESET; 500 HD(cmd)->ccb[x].status = RESET;
504 printk(KERN_WARNING "eata_pio_reset: slot %d in reset, pid %ld.\n", x, sp->serial_number); 501 printk(KERN_WARNING "eata_pio_reset: slot %d in reset.\n", x);
505 502
506 if (sp == NULL) 503 if (sp == NULL)
507 panic("eata_pio_reset: slot %d, sp==NULL.\n", x); 504 panic("eata_pio_reset: slot %d, sp==NULL.\n", x);
diff --git a/drivers/scsi/in2000.c b/drivers/scsi/in2000.c
index 6568aab745a0..92109b126391 100644
--- a/drivers/scsi/in2000.c
+++ b/drivers/scsi/in2000.c
@@ -343,7 +343,7 @@ static int in2000_queuecommand_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
343 instance = cmd->device->host; 343 instance = cmd->device->host;
344 hostdata = (struct IN2000_hostdata *) instance->hostdata; 344 hostdata = (struct IN2000_hostdata *) instance->hostdata;
345 345
346 DB(DB_QUEUE_COMMAND, scmd_printk(KERN_DEBUG, cmd, "Q-%02x-%ld(", cmd->cmnd[0], cmd->serial_number)) 346 DB(DB_QUEUE_COMMAND, scmd_printk(KERN_DEBUG, cmd, "Q-%02x(", cmd->cmnd[0]))
347 347
348/* Set up a few fields in the Scsi_Cmnd structure for our own use: 348/* Set up a few fields in the Scsi_Cmnd structure for our own use:
349 * - host_scribble is the pointer to the next cmd in the input queue 349 * - 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 *))
427 427
428 in2000_execute(cmd->device->host); 428 in2000_execute(cmd->device->host);
429 429
430 DB(DB_QUEUE_COMMAND, printk(")Q-%ld ", cmd->serial_number)) 430 DB(DB_QUEUE_COMMAND, printk(")Q "))
431 return 0; 431 return 0;
432} 432}
433 433
@@ -705,7 +705,7 @@ static void in2000_execute(struct Scsi_Host *instance)
705 * to search the input_Q again... 705 * to search the input_Q again...
706 */ 706 */
707 707
708 DB(DB_EXECUTE, printk("%s%ld)EX-2 ", (cmd->SCp.phase) ? "d:" : "", cmd->serial_number)) 708 DB(DB_EXECUTE, printk("%s)EX-2 ", (cmd->SCp.phase) ? "d:" : ""))
709 709
710} 710}
711 711
@@ -1149,7 +1149,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
1149 case CSR_XFER_DONE | PHS_COMMAND: 1149 case CSR_XFER_DONE | PHS_COMMAND:
1150 case CSR_UNEXP | PHS_COMMAND: 1150 case CSR_UNEXP | PHS_COMMAND:
1151 case CSR_SRV_REQ | PHS_COMMAND: 1151 case CSR_SRV_REQ | PHS_COMMAND:
1152 DB(DB_INTR, printk("CMND-%02x,%ld", cmd->cmnd[0], cmd->serial_number)) 1152 DB(DB_INTR, printk("CMND-%02x", cmd->cmnd[0]))
1153 transfer_pio(cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata); 1153 transfer_pio(cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata);
1154 hostdata->state = S_CONNECTED; 1154 hostdata->state = S_CONNECTED;
1155 break; 1155 break;
@@ -1191,7 +1191,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
1191 switch (msg) { 1191 switch (msg) {
1192 1192
1193 case COMMAND_COMPLETE: 1193 case COMMAND_COMPLETE:
1194 DB(DB_INTR, printk("CCMP-%ld", cmd->serial_number)) 1194 DB(DB_INTR, printk("CCMP"))
1195 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK); 1195 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1196 hostdata->state = S_PRE_CMP_DISC; 1196 hostdata->state = S_PRE_CMP_DISC;
1197 break; 1197 break;
@@ -1329,7 +1329,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
1329 1329
1330 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER); 1330 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1331 if (phs == 0x60) { 1331 if (phs == 0x60) {
1332 DB(DB_INTR, printk("SX-DONE-%ld", cmd->serial_number)) 1332 DB(DB_INTR, printk("SX-DONE"))
1333 cmd->SCp.Message = COMMAND_COMPLETE; 1333 cmd->SCp.Message = COMMAND_COMPLETE;
1334 lun = read_3393(hostdata, WD_TARGET_LUN); 1334 lun = read_3393(hostdata, WD_TARGET_LUN);
1335 DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun)) 1335 DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
@@ -1350,7 +1350,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
1350 1350
1351 in2000_execute(instance); 1351 in2000_execute(instance);
1352 } else { 1352 } else {
1353 printk("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---", asr, sr, phs, cmd->serial_number); 1353 printk("%02x:%02x:%02x: Unknown SEL_XFER_DONE phase!!---", asr, sr, phs);
1354 } 1354 }
1355 break; 1355 break;
1356 1356
@@ -1417,7 +1417,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
1417 spin_unlock_irqrestore(instance->host_lock, flags); 1417 spin_unlock_irqrestore(instance->host_lock, flags);
1418 return IRQ_HANDLED; 1418 return IRQ_HANDLED;
1419 } 1419 }
1420 DB(DB_INTR, printk("UNEXP_DISC-%ld", cmd->serial_number)) 1420 DB(DB_INTR, printk("UNEXP_DISC"))
1421 hostdata->connected = NULL; 1421 hostdata->connected = NULL;
1422 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun); 1422 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1423 hostdata->state = S_UNCONNECTED; 1423 hostdata->state = S_UNCONNECTED;
@@ -1442,7 +1442,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
1442 */ 1442 */
1443 1443
1444 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER); 1444 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1445 DB(DB_INTR, printk("DISC-%ld", cmd->serial_number)) 1445 DB(DB_INTR, printk("DISC"))
1446 if (cmd == NULL) { 1446 if (cmd == NULL) {
1447 printk(" - Already disconnected! "); 1447 printk(" - Already disconnected! ");
1448 hostdata->state = S_UNCONNECTED; 1448 hostdata->state = S_UNCONNECTED;
@@ -1575,7 +1575,6 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
1575 } else 1575 } else
1576 hostdata->state = S_CONNECTED; 1576 hostdata->state = S_CONNECTED;
1577 1577
1578 DB(DB_INTR, printk("-%ld", cmd->serial_number))
1579 break; 1578 break;
1580 1579
1581 default: 1580 default:
@@ -1704,7 +1703,7 @@ static int __in2000_abort(Scsi_Cmnd * cmd)
1704 prev->host_scribble = cmd->host_scribble; 1703 prev->host_scribble = cmd->host_scribble;
1705 cmd->host_scribble = NULL; 1704 cmd->host_scribble = NULL;
1706 cmd->result = DID_ABORT << 16; 1705 cmd->result = DID_ABORT << 16;
1707 printk(KERN_WARNING "scsi%d: Abort - removing command %ld from input_Q. ", instance->host_no, cmd->serial_number); 1706 printk(KERN_WARNING "scsi%d: Abort - removing command from input_Q. ", instance->host_no);
1708 cmd->scsi_done(cmd); 1707 cmd->scsi_done(cmd);
1709 return SUCCESS; 1708 return SUCCESS;
1710 } 1709 }
@@ -1725,7 +1724,7 @@ static int __in2000_abort(Scsi_Cmnd * cmd)
1725 1724
1726 if (hostdata->connected == cmd) { 1725 if (hostdata->connected == cmd) {
1727 1726
1728 printk(KERN_WARNING "scsi%d: Aborting connected command %ld - ", instance->host_no, cmd->serial_number); 1727 printk(KERN_WARNING "scsi%d: Aborting connected command - ", instance->host_no);
1729 1728
1730 printk("sending wd33c93 ABORT command - "); 1729 printk("sending wd33c93 ABORT command - ");
1731 write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED); 1730 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,
2270 strcat(bp, "\nconnected: "); 2269 strcat(bp, "\nconnected: ");
2271 if (hd->connected) { 2270 if (hd->connected) {
2272 cmd = (Scsi_Cmnd *) hd->connected; 2271 cmd = (Scsi_Cmnd *) hd->connected;
2273 sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); 2272 sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2274 strcat(bp, tbuf); 2273 strcat(bp, tbuf);
2275 } 2274 }
2276 } 2275 }
@@ -2278,7 +2277,7 @@ static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start,
2278 strcat(bp, "\ninput_Q: "); 2277 strcat(bp, "\ninput_Q: ");
2279 cmd = (Scsi_Cmnd *) hd->input_Q; 2278 cmd = (Scsi_Cmnd *) hd->input_Q;
2280 while (cmd) { 2279 while (cmd) {
2281 sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); 2280 sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2282 strcat(bp, tbuf); 2281 strcat(bp, tbuf);
2283 cmd = (Scsi_Cmnd *) cmd->host_scribble; 2282 cmd = (Scsi_Cmnd *) cmd->host_scribble;
2284 } 2283 }
@@ -2287,7 +2286,7 @@ static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start,
2287 strcat(bp, "\ndisconnected_Q:"); 2286 strcat(bp, "\ndisconnected_Q:");
2288 cmd = (Scsi_Cmnd *) hd->disconnected_Q; 2287 cmd = (Scsi_Cmnd *) hd->disconnected_Q;
2289 while (cmd) { 2288 while (cmd) {
2290 sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); 2289 sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2291 strcat(bp, tbuf); 2290 strcat(bp, tbuf);
2292 cmd = (Scsi_Cmnd *) cmd->host_scribble; 2291 cmd = (Scsi_Cmnd *) cmd->host_scribble;
2293 } 2292 }
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index fe7cc84e773b..84e4481b2406 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -3238,9 +3238,8 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
3238 if (!lpfc_cmd) { 3238 if (!lpfc_cmd) {
3239 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, 3239 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
3240 "2873 SCSI Layer I/O Abort Request IO CMPL Status " 3240 "2873 SCSI Layer I/O Abort Request IO CMPL Status "
3241 "x%x ID %d " 3241 "x%x ID %d LUN %d\n",
3242 "LUN %d snum %#lx\n", ret, cmnd->device->id, 3242 ret, cmnd->device->id, cmnd->device->lun);
3243 cmnd->device->lun, cmnd->serial_number);
3244 return SUCCESS; 3243 return SUCCESS;
3245 } 3244 }
3246 3245
@@ -3318,16 +3317,15 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
3318 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP, 3317 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
3319 "0748 abort handler timed out waiting " 3318 "0748 abort handler timed out waiting "
3320 "for abort to complete: ret %#x, ID %d, " 3319 "for abort to complete: ret %#x, ID %d, "
3321 "LUN %d, snum %#lx\n", 3320 "LUN %d\n",
3322 ret, cmnd->device->id, cmnd->device->lun, 3321 ret, cmnd->device->id, cmnd->device->lun);
3323 cmnd->serial_number);
3324 } 3322 }
3325 3323
3326 out: 3324 out:
3327 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP, 3325 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
3328 "0749 SCSI Layer I/O Abort Request Status x%x ID %d " 3326 "0749 SCSI Layer I/O Abort Request Status x%x ID %d "
3329 "LUN %d snum %#lx\n", ret, cmnd->device->id, 3327 "LUN %d\n", ret, cmnd->device->id,
3330 cmnd->device->lun, cmnd->serial_number); 3328 cmnd->device->lun);
3331 return ret; 3329 return ret;
3332} 3330}
3333 3331
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index f2684dd09ed0..5c1776406c96 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -1469,8 +1469,8 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
1469 if( scb->state & SCB_ABORT ) { 1469 if( scb->state & SCB_ABORT ) {
1470 1470
1471 printk(KERN_WARNING 1471 printk(KERN_WARNING
1472 "megaraid: aborted cmd %lx[%x] complete.\n", 1472 "megaraid: aborted cmd [%x] complete.\n",
1473 scb->cmd->serial_number, scb->idx); 1473 scb->idx);
1474 1474
1475 scb->cmd->result = (DID_ABORT << 16); 1475 scb->cmd->result = (DID_ABORT << 16);
1476 1476
@@ -1488,8 +1488,8 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
1488 if( scb->state & SCB_RESET ) { 1488 if( scb->state & SCB_RESET ) {
1489 1489
1490 printk(KERN_WARNING 1490 printk(KERN_WARNING
1491 "megaraid: reset cmd %lx[%x] complete.\n", 1491 "megaraid: reset cmd [%x] complete.\n",
1492 scb->cmd->serial_number, scb->idx); 1492 scb->idx);
1493 1493
1494 scb->cmd->result = (DID_RESET << 16); 1494 scb->cmd->result = (DID_RESET << 16);
1495 1495
@@ -1958,8 +1958,8 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
1958 struct list_head *pos, *next; 1958 struct list_head *pos, *next;
1959 scb_t *scb; 1959 scb_t *scb;
1960 1960
1961 printk(KERN_WARNING "megaraid: %s-%lx cmd=%x <c=%d t=%d l=%d>\n", 1961 printk(KERN_WARNING "megaraid: %s cmd=%x <c=%d t=%d l=%d>\n",
1962 (aor == SCB_ABORT)? "ABORTING":"RESET", cmd->serial_number, 1962 (aor == SCB_ABORT)? "ABORTING":"RESET",
1963 cmd->cmnd[0], cmd->device->channel, 1963 cmd->cmnd[0], cmd->device->channel,
1964 cmd->device->id, cmd->device->lun); 1964 cmd->device->id, cmd->device->lun);
1965 1965
@@ -1983,9 +1983,9 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
1983 if( scb->state & SCB_ISSUED ) { 1983 if( scb->state & SCB_ISSUED ) {
1984 1984
1985 printk(KERN_WARNING 1985 printk(KERN_WARNING
1986 "megaraid: %s-%lx[%x], fw owner.\n", 1986 "megaraid: %s[%x], fw owner.\n",
1987 (aor==SCB_ABORT) ? "ABORTING":"RESET", 1987 (aor==SCB_ABORT) ? "ABORTING":"RESET",
1988 cmd->serial_number, scb->idx); 1988 scb->idx);
1989 1989
1990 return FALSE; 1990 return FALSE;
1991 } 1991 }
@@ -1996,9 +1996,9 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
1996 * list 1996 * list
1997 */ 1997 */
1998 printk(KERN_WARNING 1998 printk(KERN_WARNING
1999 "megaraid: %s-%lx[%x], driver owner.\n", 1999 "megaraid: %s-[%x], driver owner.\n",
2000 (aor==SCB_ABORT) ? "ABORTING":"RESET", 2000 (aor==SCB_ABORT) ? "ABORTING":"RESET",
2001 cmd->serial_number, scb->idx); 2001 scb->idx);
2002 2002
2003 mega_free_scb(adapter, scb); 2003 mega_free_scb(adapter, scb);
2004 2004
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index 1dba32870b4c..2e6619eff3ea 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -2315,8 +2315,8 @@ megaraid_mbox_dpc(unsigned long devp)
2315 // Was an abort issued for this command earlier 2315 // Was an abort issued for this command earlier
2316 if (scb->state & SCB_ABORT) { 2316 if (scb->state & SCB_ABORT) {
2317 con_log(CL_ANN, (KERN_NOTICE 2317 con_log(CL_ANN, (KERN_NOTICE
2318 "megaraid: aborted cmd %lx[%x] completed\n", 2318 "megaraid: aborted cmd [%x] completed\n",
2319 scp->serial_number, scb->sno)); 2319 scb->sno));
2320 } 2320 }
2321 2321
2322 /* 2322 /*
@@ -2472,8 +2472,8 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
2472 raid_dev = ADAP2RAIDDEV(adapter); 2472 raid_dev = ADAP2RAIDDEV(adapter);
2473 2473
2474 con_log(CL_ANN, (KERN_WARNING 2474 con_log(CL_ANN, (KERN_WARNING
2475 "megaraid: aborting-%ld cmd=%x <c=%d t=%d l=%d>\n", 2475 "megaraid: aborting cmd=%x <c=%d t=%d l=%d>\n",
2476 scp->serial_number, scp->cmnd[0], SCP2CHANNEL(scp), 2476 scp->cmnd[0], SCP2CHANNEL(scp),
2477 SCP2TARGET(scp), SCP2LUN(scp))); 2477 SCP2TARGET(scp), SCP2LUN(scp)));
2478 2478
2479 // If FW has stopped responding, simply return failure 2479 // If FW has stopped responding, simply return failure
@@ -2496,9 +2496,8 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
2496 list_del_init(&scb->list); // from completed list 2496 list_del_init(&scb->list); // from completed list
2497 2497
2498 con_log(CL_ANN, (KERN_WARNING 2498 con_log(CL_ANN, (KERN_WARNING
2499 "megaraid: %ld:%d[%d:%d], abort from completed list\n", 2499 "megaraid: %d[%d:%d], abort from completed list\n",
2500 scp->serial_number, scb->sno, 2500 scb->sno, scb->dev_channel, scb->dev_target));
2501 scb->dev_channel, scb->dev_target));
2502 2501
2503 scp->result = (DID_ABORT << 16); 2502 scp->result = (DID_ABORT << 16);
2504 scp->scsi_done(scp); 2503 scp->scsi_done(scp);
@@ -2527,9 +2526,8 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
2527 ASSERT(!(scb->state & SCB_ISSUED)); 2526 ASSERT(!(scb->state & SCB_ISSUED));
2528 2527
2529 con_log(CL_ANN, (KERN_WARNING 2528 con_log(CL_ANN, (KERN_WARNING
2530 "megaraid abort: %ld[%d:%d], driver owner\n", 2529 "megaraid abort: [%d:%d], driver owner\n",
2531 scp->serial_number, scb->dev_channel, 2530 scb->dev_channel, scb->dev_target));
2532 scb->dev_target));
2533 2531
2534 scp->result = (DID_ABORT << 16); 2532 scp->result = (DID_ABORT << 16);
2535 scp->scsi_done(scp); 2533 scp->scsi_done(scp);
@@ -2560,25 +2558,21 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
2560 2558
2561 if (!(scb->state & SCB_ISSUED)) { 2559 if (!(scb->state & SCB_ISSUED)) {
2562 con_log(CL_ANN, (KERN_WARNING 2560 con_log(CL_ANN, (KERN_WARNING
2563 "megaraid abort: %ld%d[%d:%d], invalid state\n", 2561 "megaraid abort: %d[%d:%d], invalid state\n",
2564 scp->serial_number, scb->sno, scb->dev_channel, 2562 scb->sno, scb->dev_channel, scb->dev_target));
2565 scb->dev_target));
2566 BUG(); 2563 BUG();
2567 } 2564 }
2568 else { 2565 else {
2569 con_log(CL_ANN, (KERN_WARNING 2566 con_log(CL_ANN, (KERN_WARNING
2570 "megaraid abort: %ld:%d[%d:%d], fw owner\n", 2567 "megaraid abort: %d[%d:%d], fw owner\n",
2571 scp->serial_number, scb->sno, scb->dev_channel, 2568 scb->sno, scb->dev_channel, scb->dev_target));
2572 scb->dev_target));
2573 } 2569 }
2574 } 2570 }
2575 } 2571 }
2576 spin_unlock_irq(&adapter->lock); 2572 spin_unlock_irq(&adapter->lock);
2577 2573
2578 if (!found) { 2574 if (!found) {
2579 con_log(CL_ANN, (KERN_WARNING 2575 con_log(CL_ANN, (KERN_WARNING "megaraid abort: do now own\n"));
2580 "megaraid abort: scsi cmd:%ld, do now own\n",
2581 scp->serial_number));
2582 2576
2583 // FIXME: Should there be a callback for this command? 2577 // FIXME: Should there be a callback for this command?
2584 return SUCCESS; 2578 return SUCCESS;
@@ -2649,9 +2643,8 @@ megaraid_reset_handler(struct scsi_cmnd *scp)
2649 } else { 2643 } else {
2650 if (scb->scp == scp) { // Found command 2644 if (scb->scp == scp) { // Found command
2651 con_log(CL_ANN, (KERN_WARNING 2645 con_log(CL_ANN, (KERN_WARNING
2652 "megaraid: %ld:%d[%d:%d], reset from pending list\n", 2646 "megaraid: %d[%d:%d], reset from pending list\n",
2653 scp->serial_number, scb->sno, 2647 scb->sno, scb->dev_channel, scb->dev_target));
2654 scb->dev_channel, scb->dev_target));
2655 } else { 2648 } else {
2656 con_log(CL_ANN, (KERN_WARNING 2649 con_log(CL_ANN, (KERN_WARNING
2657 "megaraid: IO packet with %d[%d:%d] being reset\n", 2650 "megaraid: IO packet with %d[%d:%d] being reset\n",
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 66d4cea4df98..89c623ebadbc 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -1751,10 +1751,9 @@ static int megasas_wait_for_outstanding(struct megasas_instance *instance)
1751 list_del_init(&reset_cmd->list); 1751 list_del_init(&reset_cmd->list);
1752 if (reset_cmd->scmd) { 1752 if (reset_cmd->scmd) {
1753 reset_cmd->scmd->result = DID_RESET << 16; 1753 reset_cmd->scmd->result = DID_RESET << 16;
1754 printk(KERN_NOTICE "%d:%p reset [%02x], %#lx\n", 1754 printk(KERN_NOTICE "%d:%p reset [%02x]\n",
1755 reset_index, reset_cmd, 1755 reset_index, reset_cmd,
1756 reset_cmd->scmd->cmnd[0], 1756 reset_cmd->scmd->cmnd[0]);
1757 reset_cmd->scmd->serial_number);
1758 1757
1759 reset_cmd->scmd->scsi_done(reset_cmd->scmd); 1758 reset_cmd->scmd->scsi_done(reset_cmd->scmd);
1760 megasas_return_cmd(instance, reset_cmd); 1759 megasas_return_cmd(instance, reset_cmd);
@@ -1879,8 +1878,8 @@ static int megasas_generic_reset(struct scsi_cmnd *scmd)
1879 1878
1880 instance = (struct megasas_instance *)scmd->device->host->hostdata; 1879 instance = (struct megasas_instance *)scmd->device->host->hostdata;
1881 1880
1882 scmd_printk(KERN_NOTICE, scmd, "megasas: RESET -%ld cmd=%x retries=%x\n", 1881 scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n",
1883 scmd->serial_number, scmd->cmnd[0], scmd->retries); 1882 scmd->cmnd[0], scmd->retries);
1884 1883
1885 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) { 1884 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
1886 printk(KERN_ERR "megasas: cannot recover from previous reset " 1885 printk(KERN_ERR "megasas: cannot recover from previous reset "
@@ -2349,9 +2348,9 @@ megasas_issue_pending_cmds_again(struct megasas_instance *instance)
2349 cmd->frame_phys_addr , 2348 cmd->frame_phys_addr ,
2350 0, instance->reg_set); 2349 0, instance->reg_set);
2351 } else if (cmd->scmd) { 2350 } else if (cmd->scmd) {
2352 printk(KERN_NOTICE "megasas: %p scsi cmd [%02x],%#lx" 2351 printk(KERN_NOTICE "megasas: %p scsi cmd [%02x]"
2353 "detected on the internal queue, issue again.\n", 2352 "detected on the internal queue, issue again.\n",
2354 cmd, cmd->scmd->cmnd[0], cmd->scmd->serial_number); 2353 cmd, cmd->scmd->cmnd[0]);
2355 2354
2356 atomic_inc(&instance->fw_outstanding); 2355 atomic_inc(&instance->fw_outstanding);
2357 instance->instancet->fire_cmd(instance, 2356 instance->instancet->fire_cmd(instance,
diff --git a/drivers/scsi/mesh.c b/drivers/scsi/mesh.c
index 197aa1b3f0f3..494474779532 100644
--- a/drivers/scsi/mesh.c
+++ b/drivers/scsi/mesh.c
@@ -415,8 +415,7 @@ static void mesh_start_cmd(struct mesh_state *ms, struct scsi_cmnd *cmd)
415#if 1 415#if 1
416 if (DEBUG_TARGET(cmd)) { 416 if (DEBUG_TARGET(cmd)) {
417 int i; 417 int i;
418 printk(KERN_DEBUG "mesh_start: %p ser=%lu tgt=%d cmd=", 418 printk(KERN_DEBUG "mesh_start: %p tgt=%d cmd=", cmd, id);
419 cmd, cmd->serial_number, id);
420 for (i = 0; i < cmd->cmd_len; ++i) 419 for (i = 0; i < cmd->cmd_len; ++i)
421 printk(" %x", cmd->cmnd[i]); 420 printk(" %x", cmd->cmnd[i]);
422 printk(" use_sg=%d buffer=%p bufflen=%u\n", 421 printk(" use_sg=%d buffer=%p bufflen=%u\n",
diff --git a/drivers/scsi/ncr53c8xx.c b/drivers/scsi/ncr53c8xx.c
index 835d8d66e696..4b3b4755945c 100644
--- a/drivers/scsi/ncr53c8xx.c
+++ b/drivers/scsi/ncr53c8xx.c
@@ -8147,7 +8147,7 @@ static int ncr53c8xx_abort(struct scsi_cmnd *cmd)
8147 unsigned long flags; 8147 unsigned long flags;
8148 struct scsi_cmnd *done_list; 8148 struct scsi_cmnd *done_list;
8149 8149
8150 printk("ncr53c8xx_abort: command pid %lu\n", cmd->serial_number); 8150 printk("ncr53c8xx_abort\n");
8151 8151
8152 NCR_LOCK_NCB(np, flags); 8152 NCR_LOCK_NCB(np, flags);
8153 8153
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 8ba5744c267e..d838205ab169 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -4066,7 +4066,7 @@ __qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
4066 } */ 4066 } */
4067 printk(" tag=%d, transfersize=0x%x \n", 4067 printk(" tag=%d, transfersize=0x%x \n",
4068 cmd->tag, cmd->transfersize); 4068 cmd->tag, cmd->transfersize);
4069 printk(" Pid=%li, SP=0x%p\n", cmd->serial_number, CMD_SP(cmd)); 4069 printk(" SP=0x%p\n", CMD_SP(cmd));
4070 printk(" underflow size = 0x%x, direction=0x%x\n", 4070 printk(" underflow size = 0x%x, direction=0x%x\n",
4071 cmd->underflow, cmd->sc_data_direction); 4071 cmd->underflow, cmd->sc_data_direction);
4072} 4072}
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index 230ba097d28c..c22f2a764d9d 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -2068,15 +2068,14 @@ static int qla4xxx_eh_abort(struct scsi_cmnd *cmd)
2068 struct scsi_qla_host *ha = to_qla_host(cmd->device->host); 2068 struct scsi_qla_host *ha = to_qla_host(cmd->device->host);
2069 unsigned int id = cmd->device->id; 2069 unsigned int id = cmd->device->id;
2070 unsigned int lun = cmd->device->lun; 2070 unsigned int lun = cmd->device->lun;
2071 unsigned long serial = cmd->serial_number;
2072 unsigned long flags; 2071 unsigned long flags;
2073 struct srb *srb = NULL; 2072 struct srb *srb = NULL;
2074 int ret = SUCCESS; 2073 int ret = SUCCESS;
2075 int wait = 0; 2074 int wait = 0;
2076 2075
2077 ql4_printk(KERN_INFO, ha, 2076 ql4_printk(KERN_INFO, ha,
2078 "scsi%ld:%d:%d: Abort command issued cmd=%p, pid=%ld\n", 2077 "scsi%ld:%d:%d: Abort command issued cmd=%p\n",
2079 ha->host_no, id, lun, cmd, serial); 2078 ha->host_no, id, lun, cmd);
2080 2079
2081 spin_lock_irqsave(&ha->hardware_lock, flags); 2080 spin_lock_irqsave(&ha->hardware_lock, flags);
2082 srb = (struct srb *) CMD_SP(cmd); 2081 srb = (struct srb *) CMD_SP(cmd);
diff --git a/drivers/scsi/tmscsim.c b/drivers/scsi/tmscsim.c
index a124a28f2ccb..a1baccce05f0 100644
--- a/drivers/scsi/tmscsim.c
+++ b/drivers/scsi/tmscsim.c
@@ -565,12 +565,12 @@ dc390_StartSCSI( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_sr
565 pDCB->TagMask |= 1 << tag[1]; 565 pDCB->TagMask |= 1 << tag[1];
566 pSRB->TagNumber = tag[1]; 566 pSRB->TagNumber = tag[1];
567 DC390_write8(ScsiFifo, tag[1]); 567 DC390_write8(ScsiFifo, tag[1]);
568 DEBUG1(printk(KERN_INFO "DC390: Select w/DisCn for Cmd %li (SRB %p), block tag %02x\n", scmd->serial_number, pSRB, tag[1])); 568 DEBUG1(printk(KERN_INFO "DC390: Select w/DisCn for SRB %p, block tag %02x\n", pSRB, tag[1]));
569 cmd = SEL_W_ATN3; 569 cmd = SEL_W_ATN3;
570 } else { 570 } else {
571 /* No TagQ */ 571 /* No TagQ */
572//no_tag: 572//no_tag:
573 DEBUG1(printk(KERN_INFO "DC390: Select w%s/DisCn for Cmd %li (SRB %p), No TagQ\n", disc_allowed ? "" : "o", scmd->serial_number, pSRB)); 573 DEBUG1(printk(KERN_INFO "DC390: Select w%s/DisCn for SRB %p, No TagQ\n", disc_allowed ? "" : "o", pSRB));
574 } 574 }
575 575
576 pSRB->SRBState = SRB_START_; 576 pSRB->SRBState = SRB_START_;
@@ -620,8 +620,8 @@ dc390_StartSCSI( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_sr
620 if (DC390_read8 (Scsi_Status) & INTERRUPT) 620 if (DC390_read8 (Scsi_Status) & INTERRUPT)
621 { 621 {
622 dc390_freetag (pDCB, pSRB); 622 dc390_freetag (pDCB, pSRB);
623 DEBUG0(printk ("DC390: Interrupt during Start SCSI (pid %li, target %02i-%02i)\n", 623 DEBUG0(printk ("DC390: Interrupt during Start SCSI (target %02i-%02i)\n",
624 scmd->serial_number, scmd->device->id, scmd->device->lun)); 624 scmd->device->id, scmd->device->lun));
625 pSRB->SRBState = SRB_READY; 625 pSRB->SRBState = SRB_READY;
626 //DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD); 626 //DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
627 pACB->SelLost++; 627 pACB->SelLost++;
@@ -1705,8 +1705,7 @@ dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb*
1705 1705
1706 status = pSRB->TargetStatus; 1706 status = pSRB->TargetStatus;
1707 1707
1708 DEBUG0(printk (" SRBdone (%02x,%08x), SRB %p, pid %li\n", status, pcmd->result,\ 1708 DEBUG0(printk (" SRBdone (%02x,%08x), SRB %p\n", status, pcmd->result, pSRB));
1709 pSRB, pcmd->serial_number));
1710 if(pSRB->SRBFlag & AUTO_REQSENSE) 1709 if(pSRB->SRBFlag & AUTO_REQSENSE)
1711 { /* Last command was a Request Sense */ 1710 { /* Last command was a Request Sense */
1712 pSRB->SRBFlag &= ~AUTO_REQSENSE; 1711 pSRB->SRBFlag &= ~AUTO_REQSENSE;
@@ -1727,7 +1726,7 @@ dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb*
1727 } else { 1726 } else {
1728 SET_RES_DRV(pcmd->result, DRIVER_SENSE); 1727 SET_RES_DRV(pcmd->result, DRIVER_SENSE);
1729 //pSRB->ScsiCmdLen = (u8) (pSRB->Segment1[0] >> 8); 1728 //pSRB->ScsiCmdLen = (u8) (pSRB->Segment1[0] >> 8);
1730 DEBUG0 (printk ("DC390: RETRY pid %li (%02x), target %02i-%02i\n", pcmd->serial_number, pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun)); 1729 DEBUG0 (printk ("DC390: RETRY (%02x), target %02i-%02i\n", pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun));
1731 pSRB->TotalXferredLen = 0; 1730 pSRB->TotalXferredLen = 0;
1732 SET_RES_DID(pcmd->result, DID_SOFT_ERROR); 1731 SET_RES_DID(pcmd->result, DID_SOFT_ERROR);
1733 } 1732 }
@@ -1747,7 +1746,7 @@ dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb*
1747 else if (status == SAM_STAT_TASK_SET_FULL) 1746 else if (status == SAM_STAT_TASK_SET_FULL)
1748 { 1747 {
1749 scsi_track_queue_full(pcmd->device, pDCB->GoingSRBCnt - 1); 1748 scsi_track_queue_full(pcmd->device, pDCB->GoingSRBCnt - 1);
1750 DEBUG0 (printk ("DC390: RETRY pid %li (%02x), target %02i-%02i\n", pcmd->serial_number, pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun)); 1749 DEBUG0 (printk ("DC390: RETRY (%02x), target %02i-%02i\n", pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun));
1751 pSRB->TotalXferredLen = 0; 1750 pSRB->TotalXferredLen = 0;
1752 SET_RES_DID(pcmd->result, DID_SOFT_ERROR); 1751 SET_RES_DID(pcmd->result, DID_SOFT_ERROR);
1753 } 1752 }
@@ -1801,7 +1800,7 @@ cmd_done:
1801 /* Add to free list */ 1800 /* Add to free list */
1802 dc390_Free_insert (pACB, pSRB); 1801 dc390_Free_insert (pACB, pSRB);
1803 1802
1804 DEBUG0(printk (KERN_DEBUG "DC390: SRBdone: done pid %li\n", pcmd->serial_number)); 1803 DEBUG0(printk (KERN_DEBUG "DC390: SRBdone: done\n"));
1805 pcmd->scsi_done (pcmd); 1804 pcmd->scsi_done (pcmd);
1806 1805
1807 return; 1806 return;
@@ -1997,8 +1996,7 @@ static int DC390_abort(struct scsi_cmnd *cmd)
1997 struct dc390_acb *pACB = (struct dc390_acb*) cmd->device->host->hostdata; 1996 struct dc390_acb *pACB = (struct dc390_acb*) cmd->device->host->hostdata;
1998 struct dc390_dcb *pDCB = (struct dc390_dcb*) cmd->device->hostdata; 1997 struct dc390_dcb *pDCB = (struct dc390_dcb*) cmd->device->hostdata;
1999 1998
2000 scmd_printk(KERN_WARNING, cmd, 1999 scmd_printk(KERN_WARNING, cmd, "DC390: Abort command\n");
2001 "DC390: Abort command (pid %li)\n", cmd->serial_number);
2002 2000
2003 /* abort() is too stupid for already sent commands at the moment. 2001 /* abort() is too stupid for already sent commands at the moment.
2004 * If it's called we are in trouble anyway, so let's dump some info 2002 * 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)
2006 dc390_dumpinfo(pACB, pDCB, NULL); 2004 dc390_dumpinfo(pACB, pDCB, NULL);
2007 2005
2008 pDCB->DCBFlag |= ABORT_DEV_; 2006 pDCB->DCBFlag |= ABORT_DEV_;
2009 printk(KERN_INFO "DC390: Aborted pid %li\n", cmd->serial_number); 2007 printk(KERN_INFO "DC390: Aborted.\n");
2010 2008
2011 return FAILED; 2009 return FAILED;
2012} 2010}
diff --git a/drivers/scsi/u14-34f.c b/drivers/scsi/u14-34f.c
index edfc5da8be4c..90e104d6b558 100644
--- a/drivers/scsi/u14-34f.c
+++ b/drivers/scsi/u14-34f.c
@@ -1256,8 +1256,8 @@ static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct
1256 j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number; 1256 j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number;
1257 1257
1258 if (SCpnt->host_scribble) 1258 if (SCpnt->host_scribble)
1259 panic("%s: qcomm, pid %ld, SCpnt %p already active.\n", 1259 panic("%s: qcomm, SCpnt %p already active.\n",
1260 BN(j), SCpnt->serial_number, SCpnt); 1260 BN(j), SCpnt);
1261 1261
1262 /* i is the mailbox number, look for the first free mailbox 1262 /* i is the mailbox number, look for the first free mailbox
1263 starting from last_cp_used */ 1263 starting from last_cp_used */
@@ -1286,9 +1286,9 @@ static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct
1286 cpp->cpp_index = i; 1286 cpp->cpp_index = i;
1287 SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index; 1287 SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index;
1288 1288
1289 if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.\n", 1289 if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d.\n",
1290 BN(j), i, SCpnt->device->channel, SCpnt->device->id, 1290 BN(j), i, SCpnt->device->channel, SCpnt->device->id,
1291 SCpnt->device->lun, SCpnt->serial_number); 1291 SCpnt->device->lun);
1292 1292
1293 cpp->opcode = OP_SCSI; 1293 cpp->opcode = OP_SCSI;
1294 cpp->channel = SCpnt->device->channel; 1294 cpp->channel = SCpnt->device->channel;
@@ -1315,7 +1315,7 @@ static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct
1315 unmap_dma(i, j); 1315 unmap_dma(i, j);
1316 SCpnt->host_scribble = NULL; 1316 SCpnt->host_scribble = NULL;
1317 scmd_printk(KERN_INFO, SCpnt, 1317 scmd_printk(KERN_INFO, SCpnt,
1318 "qcomm, pid %ld, adapter busy.\n", SCpnt->serial_number); 1318 "qcomm, adapter busy.\n");
1319 return 1; 1319 return 1;
1320 } 1320 }
1321 1321
@@ -1337,14 +1337,12 @@ static int u14_34f_eh_abort(struct scsi_cmnd *SCarg) {
1337 j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number; 1337 j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
1338 1338
1339 if (SCarg->host_scribble == NULL) { 1339 if (SCarg->host_scribble == NULL) {
1340 scmd_printk(KERN_INFO, SCarg, "abort, pid %ld inactive.\n", 1340 scmd_printk(KERN_INFO, SCarg, "abort, command inactive.\n");
1341 SCarg->serial_number);
1342 return SUCCESS; 1341 return SUCCESS;
1343 } 1342 }
1344 1343
1345 i = *(unsigned int *)SCarg->host_scribble; 1344 i = *(unsigned int *)SCarg->host_scribble;
1346 scmd_printk(KERN_INFO, SCarg, "abort, mbox %d, pid %ld.\n", 1345 scmd_printk(KERN_INFO, SCarg, "abort, mbox %d.\n", i);
1347 i, SCarg->serial_number);
1348 1346
1349 if (i >= sh[j]->can_queue) 1347 if (i >= sh[j]->can_queue)
1350 panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j)); 1348 panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j));
@@ -1387,8 +1385,7 @@ static int u14_34f_eh_abort(struct scsi_cmnd *SCarg) {
1387 SCarg->result = DID_ABORT << 16; 1385 SCarg->result = DID_ABORT << 16;
1388 SCarg->host_scribble = NULL; 1386 SCarg->host_scribble = NULL;
1389 HD(j)->cp_stat[i] = FREE; 1387 HD(j)->cp_stat[i] = FREE;
1390 printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n", 1388 printk("%s, abort, mbox %d ready, DID_ABORT, done.\n", BN(j), i);
1391 BN(j), i, SCarg->serial_number);
1392 SCarg->scsi_done(SCarg); 1389 SCarg->scsi_done(SCarg);
1393 return SUCCESS; 1390 return SUCCESS;
1394 } 1391 }
@@ -1403,12 +1400,12 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
1403 struct scsi_cmnd *SCpnt; 1400 struct scsi_cmnd *SCpnt;
1404 1401
1405 j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number; 1402 j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
1406 scmd_printk(KERN_INFO, SCarg, "reset, enter, pid %ld.\n", SCarg->serial_number); 1403 scmd_printk(KERN_INFO, SCarg, "reset, enter.\n");
1407 1404
1408 spin_lock_irq(sh[j]->host_lock); 1405 spin_lock_irq(sh[j]->host_lock);
1409 1406
1410 if (SCarg->host_scribble == NULL) 1407 if (SCarg->host_scribble == NULL)
1411 printk("%s: reset, pid %ld inactive.\n", BN(j), SCarg->serial_number); 1408 printk("%s: reset, inactive.\n", BN(j));
1412 1409
1413 if (HD(j)->in_reset) { 1410 if (HD(j)->in_reset) {
1414 printk("%s: reset, exit, already in reset.\n", BN(j)); 1411 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) {
1445 1442
1446 if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) { 1443 if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
1447 HD(j)->cp_stat[i] = ABORTING; 1444 HD(j)->cp_stat[i] = ABORTING;
1448 printk("%s: reset, mbox %d aborting, pid %ld.\n", 1445 printk("%s: reset, mbox %d aborting.\n", BN(j), i);
1449 BN(j), i, SCpnt->serial_number);
1450 } 1446 }
1451 1447
1452 else { 1448 else {
1453 HD(j)->cp_stat[i] = IN_RESET; 1449 HD(j)->cp_stat[i] = IN_RESET;
1454 printk("%s: reset, mbox %d in reset, pid %ld.\n", 1450 printk("%s: reset, mbox %d in reset.\n", BN(j), i);
1455 BN(j), i, SCpnt->serial_number);
1456 } 1451 }
1457 1452
1458 if (SCpnt->host_scribble == NULL) 1453 if (SCpnt->host_scribble == NULL)
@@ -1500,8 +1495,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
1500 /* This mailbox is still waiting for its interrupt */ 1495 /* This mailbox is still waiting for its interrupt */
1501 HD(j)->cp_stat[i] = LOCKED; 1496 HD(j)->cp_stat[i] = LOCKED;
1502 1497
1503 printk("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n", 1498 printk("%s, reset, mbox %d locked, DID_RESET, done.\n", BN(j), i);
1504 BN(j), i, SCpnt->serial_number);
1505 } 1499 }
1506 1500
1507 else if (HD(j)->cp_stat[i] == ABORTING) { 1501 else if (HD(j)->cp_stat[i] == ABORTING) {
@@ -1513,8 +1507,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
1513 /* This mailbox was never queued to the adapter */ 1507 /* This mailbox was never queued to the adapter */
1514 HD(j)->cp_stat[i] = FREE; 1508 HD(j)->cp_stat[i] = FREE;
1515 1509
1516 printk("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n", 1510 printk("%s, reset, mbox %d aborting, DID_RESET, done.\n", BN(j), i);
1517 BN(j), i, SCpnt->serial_number);
1518 } 1511 }
1519 1512
1520 else 1513 else
@@ -1528,7 +1521,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
1528 HD(j)->in_reset = FALSE; 1521 HD(j)->in_reset = FALSE;
1529 do_trace = FALSE; 1522 do_trace = FALSE;
1530 1523
1531 if (arg_done) printk("%s: reset, exit, pid %ld done.\n", BN(j), SCarg->serial_number); 1524 if (arg_done) printk("%s: reset, exit, done.\n", BN(j));
1532 else printk("%s: reset, exit.\n", BN(j)); 1525 else printk("%s: reset, exit.\n", BN(j));
1533 1526
1534 spin_unlock_irq(sh[j]->host_lock); 1527 spin_unlock_irq(sh[j]->host_lock);
@@ -1671,10 +1664,10 @@ static int reorder(unsigned int j, unsigned long cursec,
1671 if (link_statistics && (overlap || !(flushcount % link_statistics))) 1664 if (link_statistics && (overlap || !(flushcount % link_statistics)))
1672 for (n = 0; n < n_ready; n++) { 1665 for (n = 0; n < n_ready; n++) {
1673 k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt; 1666 k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
1674 printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %u"\ 1667 printk("%s %d.%d:%d mb %d fc %d nr %d sec %ld ns %u"\
1675 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n", 1668 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
1676 (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target, 1669 (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target,
1677 SCpnt->lun, SCpnt->serial_number, k, flushcount, n_ready, 1670 SCpnt->lun, k, flushcount, n_ready,
1678 blk_rq_pos(SCpnt->request), blk_rq_sectors(SCpnt->request), 1671 blk_rq_pos(SCpnt->request), blk_rq_sectors(SCpnt->request),
1679 cursec, YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only), 1672 cursec, YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
1680 YESNO(overlap), cpp->xdir); 1673 YESNO(overlap), cpp->xdir);
@@ -1709,9 +1702,9 @@ static void flush_dev(struct scsi_device *dev, unsigned long cursec, unsigned in
1709 1702
1710 if (wait_on_busy(sh[j]->io_port, MAXLOOP)) { 1703 if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
1711 scmd_printk(KERN_INFO, SCpnt, 1704 scmd_printk(KERN_INFO, SCpnt,
1712 "%s, pid %ld, mbox %d, adapter" 1705 "%s, mbox %d, adapter"
1713 " busy, will abort.\n", (ihdlr ? "ihdlr" : "qcomm"), 1706 " busy, will abort.\n", (ihdlr ? "ihdlr" : "qcomm"),
1714 SCpnt->serial_number, k); 1707 k);
1715 HD(j)->cp_stat[k] = ABORTING; 1708 HD(j)->cp_stat[k] = ABORTING;
1716 continue; 1709 continue;
1717 } 1710 }
@@ -1793,12 +1786,12 @@ static irqreturn_t ihdlr(unsigned int j)
1793 if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i); 1786 if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i);
1794 1787
1795 if (SCpnt->host_scribble == NULL) 1788 if (SCpnt->host_scribble == NULL)
1796 panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", BN(j), i, 1789 panic("%s: ihdlr, mbox %d, SCpnt %p garbled.\n", BN(j), i,
1797 SCpnt->serial_number, SCpnt); 1790 SCpnt);
1798 1791
1799 if (*(unsigned int *)SCpnt->host_scribble != i) 1792 if (*(unsigned int *)SCpnt->host_scribble != i)
1800 panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n", 1793 panic("%s: ihdlr, mbox %d, index mismatch %d.\n",
1801 BN(j), i, SCpnt->serial_number, *(unsigned int *)SCpnt->host_scribble); 1794 BN(j), i, *(unsigned int *)SCpnt->host_scribble);
1802 1795
1803 sync_dma(i, j); 1796 sync_dma(i, j);
1804 1797
@@ -1841,8 +1834,8 @@ static irqreturn_t ihdlr(unsigned int j)
1841 (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 && 1834 (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 &&
1842 (SCpnt->sense_buffer[2] & 0xf) == NOT_READY))) 1835 (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
1843 scmd_printk(KERN_INFO, SCpnt, 1836 scmd_printk(KERN_INFO, SCpnt,
1844 "ihdlr, pid %ld, target_status 0x%x, sense key 0x%x.\n", 1837 "ihdlr, target_status 0x%x, sense key 0x%x.\n",
1845 SCpnt->serial_number, spp->target_status, 1838 spp->target_status,
1846 SCpnt->sense_buffer[2]); 1839 SCpnt->sense_buffer[2]);
1847 1840
1848 HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] = 0; 1841 HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] = 0;
@@ -1913,8 +1906,8 @@ static irqreturn_t ihdlr(unsigned int j)
1913 do_trace || msg_byte(spp->target_status)) 1906 do_trace || msg_byte(spp->target_status))
1914#endif 1907#endif
1915 scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"\ 1908 scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"\
1916 " pid %ld, reg 0x%x, count %d.\n", 1909 " reg 0x%x, count %d.\n",
1917 i, spp->adapter_status, spp->target_status, SCpnt->serial_number, 1910 i, spp->adapter_status, spp->target_status,
1918 reg, HD(j)->iocount); 1911 reg, HD(j)->iocount);
1919 1912
1920 unmap_dma(i, j); 1913 unmap_dma(i, j);
diff --git a/drivers/scsi/wd33c93.c b/drivers/scsi/wd33c93.c
index 4468ae3610f7..97ae716134d0 100644
--- a/drivers/scsi/wd33c93.c
+++ b/drivers/scsi/wd33c93.c
@@ -381,7 +381,7 @@ wd33c93_queuecommand_lck(struct scsi_cmnd *cmd,
381 hostdata = (struct WD33C93_hostdata *) cmd->device->host->hostdata; 381 hostdata = (struct WD33C93_hostdata *) cmd->device->host->hostdata;
382 382
383 DB(DB_QUEUE_COMMAND, 383 DB(DB_QUEUE_COMMAND,
384 printk("Q-%d-%02x-%ld( ", cmd->device->id, cmd->cmnd[0], cmd->serial_number)) 384 printk("Q-%d-%02x( ", cmd->device->id, cmd->cmnd[0]))
385 385
386/* Set up a few fields in the scsi_cmnd structure for our own use: 386/* Set up a few fields in the scsi_cmnd structure for our own use:
387 * - host_scribble is the pointer to the next cmd in the input queue 387 * - host_scribble is the pointer to the next cmd in the input queue
@@ -462,7 +462,7 @@ wd33c93_queuecommand_lck(struct scsi_cmnd *cmd,
462 462
463 wd33c93_execute(cmd->device->host); 463 wd33c93_execute(cmd->device->host);
464 464
465 DB(DB_QUEUE_COMMAND, printk(")Q-%ld ", cmd->serial_number)) 465 DB(DB_QUEUE_COMMAND, printk(")Q "))
466 466
467 spin_unlock_irq(&hostdata->lock); 467 spin_unlock_irq(&hostdata->lock);
468 return 0; 468 return 0;
@@ -687,7 +687,7 @@ wd33c93_execute(struct Scsi_Host *instance)
687 */ 687 */
688 688
689 DB(DB_EXECUTE, 689 DB(DB_EXECUTE,
690 printk("%s%ld)EX-2 ", (cmd->SCp.phase) ? "d:" : "", cmd->serial_number)) 690 printk("%s)EX-2 ", (cmd->SCp.phase) ? "d:" : ""))
691} 691}
692 692
693static void 693static void
@@ -963,7 +963,7 @@ wd33c93_intr(struct Scsi_Host *instance)
963 case CSR_XFER_DONE | PHS_COMMAND: 963 case CSR_XFER_DONE | PHS_COMMAND:
964 case CSR_UNEXP | PHS_COMMAND: 964 case CSR_UNEXP | PHS_COMMAND:
965 case CSR_SRV_REQ | PHS_COMMAND: 965 case CSR_SRV_REQ | PHS_COMMAND:
966 DB(DB_INTR, printk("CMND-%02x,%ld", cmd->cmnd[0], cmd->serial_number)) 966 DB(DB_INTR, printk("CMND-%02x", cmd->cmnd[0]))
967 transfer_pio(regs, cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, 967 transfer_pio(regs, cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR,
968 hostdata); 968 hostdata);
969 hostdata->state = S_CONNECTED; 969 hostdata->state = S_CONNECTED;
@@ -1007,7 +1007,7 @@ wd33c93_intr(struct Scsi_Host *instance)
1007 switch (msg) { 1007 switch (msg) {
1008 1008
1009 case COMMAND_COMPLETE: 1009 case COMMAND_COMPLETE:
1010 DB(DB_INTR, printk("CCMP-%ld", cmd->serial_number)) 1010 DB(DB_INTR, printk("CCMP"))
1011 write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK); 1011 write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK);
1012 hostdata->state = S_PRE_CMP_DISC; 1012 hostdata->state = S_PRE_CMP_DISC;
1013 break; 1013 break;
@@ -1174,7 +1174,7 @@ wd33c93_intr(struct Scsi_Host *instance)
1174 1174
1175 write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER); 1175 write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER);
1176 if (phs == 0x60) { 1176 if (phs == 0x60) {
1177 DB(DB_INTR, printk("SX-DONE-%ld", cmd->serial_number)) 1177 DB(DB_INTR, printk("SX-DONE"))
1178 cmd->SCp.Message = COMMAND_COMPLETE; 1178 cmd->SCp.Message = COMMAND_COMPLETE;
1179 lun = read_wd33c93(regs, WD_TARGET_LUN); 1179 lun = read_wd33c93(regs, WD_TARGET_LUN);
1180 DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun)) 1180 DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
@@ -1200,8 +1200,8 @@ wd33c93_intr(struct Scsi_Host *instance)
1200 wd33c93_execute(instance); 1200 wd33c93_execute(instance);
1201 } else { 1201 } else {
1202 printk 1202 printk
1203 ("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---", 1203 ("%02x:%02x:%02x: Unknown SEL_XFER_DONE phase!!---",
1204 asr, sr, phs, cmd->serial_number); 1204 asr, sr, phs);
1205 spin_unlock_irqrestore(&hostdata->lock, flags); 1205 spin_unlock_irqrestore(&hostdata->lock, flags);
1206 } 1206 }
1207 break; 1207 break;
@@ -1266,7 +1266,7 @@ wd33c93_intr(struct Scsi_Host *instance)
1266 spin_unlock_irqrestore(&hostdata->lock, flags); 1266 spin_unlock_irqrestore(&hostdata->lock, flags);
1267 return; 1267 return;
1268 } 1268 }
1269 DB(DB_INTR, printk("UNEXP_DISC-%ld", cmd->serial_number)) 1269 DB(DB_INTR, printk("UNEXP_DISC"))
1270 hostdata->connected = NULL; 1270 hostdata->connected = NULL;
1271 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun); 1271 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1272 hostdata->state = S_UNCONNECTED; 1272 hostdata->state = S_UNCONNECTED;
@@ -1292,7 +1292,7 @@ wd33c93_intr(struct Scsi_Host *instance)
1292 */ 1292 */
1293 1293
1294 write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER); 1294 write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER);
1295 DB(DB_INTR, printk("DISC-%ld", cmd->serial_number)) 1295 DB(DB_INTR, printk("DISC"))
1296 if (cmd == NULL) { 1296 if (cmd == NULL) {
1297 printk(" - Already disconnected! "); 1297 printk(" - Already disconnected! ");
1298 hostdata->state = S_UNCONNECTED; 1298 hostdata->state = S_UNCONNECTED;
@@ -1491,7 +1491,6 @@ wd33c93_intr(struct Scsi_Host *instance)
1491 } else 1491 } else
1492 hostdata->state = S_CONNECTED; 1492 hostdata->state = S_CONNECTED;
1493 1493
1494 DB(DB_INTR, printk("-%ld", cmd->serial_number))
1495 spin_unlock_irqrestore(&hostdata->lock, flags); 1494 spin_unlock_irqrestore(&hostdata->lock, flags);
1496 break; 1495 break;
1497 1496
@@ -1637,8 +1636,8 @@ wd33c93_abort(struct scsi_cmnd * cmd)
1637 cmd->host_scribble = NULL; 1636 cmd->host_scribble = NULL;
1638 cmd->result = DID_ABORT << 16; 1637 cmd->result = DID_ABORT << 16;
1639 printk 1638 printk
1640 ("scsi%d: Abort - removing command %ld from input_Q. ", 1639 ("scsi%d: Abort - removing command from input_Q. ",
1641 instance->host_no, cmd->serial_number); 1640 instance->host_no);
1642 enable_irq(cmd->device->host->irq); 1641 enable_irq(cmd->device->host->irq);
1643 cmd->scsi_done(cmd); 1642 cmd->scsi_done(cmd);
1644 return SUCCESS; 1643 return SUCCESS;
@@ -1662,8 +1661,8 @@ wd33c93_abort(struct scsi_cmnd * cmd)
1662 uchar sr, asr; 1661 uchar sr, asr;
1663 unsigned long timeout; 1662 unsigned long timeout;
1664 1663
1665 printk("scsi%d: Aborting connected command %ld - ", 1664 printk("scsi%d: Aborting connected command - ",
1666 instance->host_no, cmd->serial_number); 1665 instance->host_no);
1667 1666
1668 printk("stopping DMA - "); 1667 printk("stopping DMA - ");
1669 if (hostdata->dma == D_DMA_RUNNING) { 1668 if (hostdata->dma == D_DMA_RUNNING) {
@@ -1729,8 +1728,8 @@ wd33c93_abort(struct scsi_cmnd * cmd)
1729 while (tmp) { 1728 while (tmp) {
1730 if (tmp == cmd) { 1729 if (tmp == cmd) {
1731 printk 1730 printk
1732 ("scsi%d: Abort - command %ld found on disconnected_Q - ", 1731 ("scsi%d: Abort - command found on disconnected_Q - ",
1733 instance->host_no, cmd->serial_number); 1732 instance->host_no);
1734 printk("Abort SNOOZE. "); 1733 printk("Abort SNOOZE. ");
1735 enable_irq(cmd->device->host->irq); 1734 enable_irq(cmd->device->host->irq);
1736 return FAILED; 1735 return FAILED;
@@ -2180,8 +2179,8 @@ wd33c93_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off
2180 strcat(bp, "\nconnected: "); 2179 strcat(bp, "\nconnected: ");
2181 if (hd->connected) { 2180 if (hd->connected) {
2182 cmd = (struct scsi_cmnd *) hd->connected; 2181 cmd = (struct scsi_cmnd *) hd->connected;
2183 sprintf(tbuf, " %ld-%d:%d(%02x)", 2182 sprintf(tbuf, " %d:%d(%02x)",
2184 cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); 2183 cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2185 strcat(bp, tbuf); 2184 strcat(bp, tbuf);
2186 } 2185 }
2187 } 2186 }
@@ -2189,8 +2188,8 @@ wd33c93_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off
2189 strcat(bp, "\ninput_Q: "); 2188 strcat(bp, "\ninput_Q: ");
2190 cmd = (struct scsi_cmnd *) hd->input_Q; 2189 cmd = (struct scsi_cmnd *) hd->input_Q;
2191 while (cmd) { 2190 while (cmd) {
2192 sprintf(tbuf, " %ld-%d:%d(%02x)", 2191 sprintf(tbuf, " %d:%d(%02x)",
2193 cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); 2192 cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2194 strcat(bp, tbuf); 2193 strcat(bp, tbuf);
2195 cmd = (struct scsi_cmnd *) cmd->host_scribble; 2194 cmd = (struct scsi_cmnd *) cmd->host_scribble;
2196 } 2195 }
@@ -2199,8 +2198,8 @@ wd33c93_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off
2199 strcat(bp, "\ndisconnected_Q:"); 2198 strcat(bp, "\ndisconnected_Q:");
2200 cmd = (struct scsi_cmnd *) hd->disconnected_Q; 2199 cmd = (struct scsi_cmnd *) hd->disconnected_Q;
2201 while (cmd) { 2200 while (cmd) {
2202 sprintf(tbuf, " %ld-%d:%d(%02x)", 2201 sprintf(tbuf, " %d:%d(%02x)",
2203 cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]); 2202 cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2204 strcat(bp, tbuf); 2203 strcat(bp, tbuf);
2205 cmd = (struct scsi_cmnd *) cmd->host_scribble; 2204 cmd = (struct scsi_cmnd *) cmd->host_scribble;
2206 } 2205 }
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-30 07:37:57 -0400