Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 12a44162 authored by Matthew Wilcox's avatar Matthew Wilcox Committed by James Bottomley
Browse files

[SCSI] Remove ->pid field from scsi_cmnd 



The pid field is a duplicate of the serial_number field and has been
scheduled for removal for a long time.  A few drivers were still using
it, so just change them to use serial_number instead.

Signed-off-by: default avatarMatthew Wilcox <willy@linux.intel.com>
Signed-off-by: default avatarJames Bottomley <James.Bottomley@SteelEye.com>
parent 13ba9bcb

drivers/scsi/dc395x.c

+55 −55
Original line number Diff line number Diff line
@@ -778,7 +778,7 @@ static void srb_waiting_insert(struct DeviceCtlBlk *dcb, 
		struct ScsiReqBlk *srb)

{

	dprintkdbg(DBG_0, "srb_waiting_insert: (pid#%li) <%02i-%i> srb=%p\n",

		srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);

		srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);

	list_add(&srb->list, &dcb->srb_waiting_list);

}
@@ -787,7 +787,7 @@ static void srb_waiting_append(struct DeviceCtlBlk *dcb, 
		struct ScsiReqBlk *srb)

{

	dprintkdbg(DBG_0, "srb_waiting_append: (pid#%li) <%02i-%i> srb=%p\n",

		 srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);

		 srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);

	list_add_tail(&srb->list, &dcb->srb_waiting_list);

}
@@ -795,7 +795,7 @@ static void srb_waiting_append(struct DeviceCtlBlk *dcb, 
static void srb_going_append(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)

{

	dprintkdbg(DBG_0, "srb_going_append: (pid#%li) <%02i-%i> srb=%p\n",

		srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);

		srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);

	list_add_tail(&srb->list, &dcb->srb_going_list);

}
@@ -805,7 +805,7 @@ static void srb_going_remove(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb) 
	struct ScsiReqBlk *i;

	struct ScsiReqBlk *tmp;

	dprintkdbg(DBG_0, "srb_going_remove: (pid#%li) <%02i-%i> srb=%p\n",

		srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);

		srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);



	list_for_each_entry_safe(i, tmp, &dcb->srb_going_list, list)

		if (i == srb) {
@@ -821,7 +821,7 @@ static void srb_waiting_remove(struct DeviceCtlBlk *dcb, 
	struct ScsiReqBlk *i;

	struct ScsiReqBlk *tmp;

	dprintkdbg(DBG_0, "srb_waiting_remove: (pid#%li) <%02i-%i> srb=%p\n",

		srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);

		srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);



	list_for_each_entry_safe(i, tmp, &dcb->srb_waiting_list, list)

		if (i == srb) {
@@ -836,7 +836,7 @@ static void srb_going_to_waiting_move(struct DeviceCtlBlk *dcb, 
{

	dprintkdbg(DBG_0,

		"srb_going_to_waiting_move: (pid#%li) <%02i-%i> srb=%p\n",

		srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);

		srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);

	list_move(&srb->list, &dcb->srb_waiting_list);

}
@@ -846,7 +846,7 @@ static void srb_waiting_to_going_move(struct DeviceCtlBlk *dcb, 
{

	dprintkdbg(DBG_0,

		"srb_waiting_to_going_move: (pid#%li) <%02i-%i> srb=%p\n",

		srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);

		srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);

	list_move(&srb->list, &dcb->srb_going_list);

}
@@ -982,7 +982,7 @@ static void build_srb(struct scsi_cmnd *cmd, struct DeviceCtlBlk *dcb, 
	int nseg;

	enum dma_data_direction dir = cmd->sc_data_direction;

	dprintkdbg(DBG_0, "build_srb: (pid#%li) <%02i-%i>\n",

		cmd->pid, dcb->target_id, dcb->target_lun);

		cmd->serial_number, dcb->target_id, dcb->target_lun);



	srb->dcb = dcb;

	srb->cmd = cmd;
@@ -1086,7 +1086,7 @@ static int dc395x_queue_command(struct scsi_cmnd *cmd, void (*done)(struct scsi_ 
	struct AdapterCtlBlk *acb =

	    (struct AdapterCtlBlk *)cmd->device->host->hostdata;

	dprintkdbg(DBG_0, "queue_command: (pid#%li) <%02i-%i> cmnd=0x%02x\n",

		cmd->pid, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);

		cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);



	/* Assume BAD_TARGET; will be cleared later */

	cmd->result = DID_BAD_TARGET << 16;
@@ -1139,7 +1139,7 @@ static int dc395x_queue_command(struct scsi_cmnd *cmd, void (*done)(struct scsi_ 
		/* process immediately */

		send_srb(acb, srb);

	}

	dprintkdbg(DBG_1, "queue_command: (pid#%li) done\n", cmd->pid);

	dprintkdbg(DBG_1, "queue_command: (pid#%li) done\n", cmd->serial_number);

	return 0;



complete:
@@ -1203,7 +1203,7 @@ static void dump_register_info(struct AdapterCtlBlk *acb, 
		else

			dprintkl(KERN_INFO, "dump: srb=%p cmd=%p (pid#%li) "

				 "cmnd=0x%02x <%02i-%i>\n",

			    	srb, srb->cmd, srb->cmd->pid,

				srb, srb->cmd, srb->cmd->serial_number,

				srb->cmd->cmnd[0], srb->cmd->device->id,

			       	srb->cmd->device->lun);

		printk("  sglist=%p cnt=%i idx=%i len=%zu\n",
@@ -1300,7 +1300,7 @@ static int __dc395x_eh_bus_reset(struct scsi_cmnd *cmd) 
		(struct AdapterCtlBlk *)cmd->device->host->hostdata;

	dprintkl(KERN_INFO,

		"eh_bus_reset: (pid#%li) target=<%02i-%i> cmd=%p\n",

		cmd->pid, cmd->device->id, cmd->device->lun, cmd);

		cmd->serial_number, cmd->device->id, cmd->device->lun, cmd);



	if (timer_pending(&acb->waiting_timer))

		del_timer(&acb->waiting_timer);
@@ -1367,7 +1367,7 @@ static int dc395x_eh_abort(struct scsi_cmnd *cmd) 
	struct DeviceCtlBlk *dcb;

	struct ScsiReqBlk *srb;

	dprintkl(KERN_INFO, "eh_abort: (pid#%li) target=<%02i-%i> cmd=%p\n",

		cmd->pid, cmd->device->id, cmd->device->lun, cmd);

		cmd->serial_number, cmd->device->id, cmd->device->lun, cmd);



	dcb = find_dcb(acb, cmd->device->id, cmd->device->lun);

	if (!dcb) {
@@ -1494,7 +1494,7 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb, 
	u8 s_stat, scsicommand, i, identify_message;

	u8 *ptr;

	dprintkdbg(DBG_0, "start_scsi: (pid#%li) <%02i-%i> srb=%p\n",

		srb->cmd->pid, dcb->target_id, dcb->target_lun, srb);

		srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);



	srb->tag_number = TAG_NONE;	/* acb->tag_max_num: had error read in eeprom */
@@ -1504,7 +1504,7 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb, 
#if 1

	if (s_stat & 0x20 /* s_stat2 & 0x02000 */ ) {

		dprintkdbg(DBG_KG, "start_scsi: (pid#%li) BUSY %02x %04x\n",

			srb->cmd->pid, s_stat, s_stat2);

			srb->cmd->serial_number, s_stat, s_stat2);

		/*

		 * Try anyway?

		 *
@@ -1522,14 +1522,14 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb, 
	if (acb->active_dcb) {

		dprintkl(KERN_DEBUG, "start_scsi: (pid#%li) Attempt to start a"

			"command while another command (pid#%li) is active.",

			srb->cmd->pid,

			srb->cmd->serial_number,

			acb->active_dcb->active_srb ?

			    acb->active_dcb->active_srb->cmd->pid : 0);

			    acb->active_dcb->active_srb->cmd->serial_number : 0);

		return 1;

	}

	if (DC395x_read16(acb, TRM_S1040_SCSI_STATUS) & SCSIINTERRUPT) {

		dprintkdbg(DBG_KG, "start_scsi: (pid#%li) Failed (busy)\n",

			srb->cmd->pid);

			srb->cmd->serial_number);

		return 1;

	}

	/* Allow starting of SCSI commands half a second before we allow the mid-level
@@ -1603,7 +1603,7 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb, 
		if (tag_number >= dcb->max_command) {

			dprintkl(KERN_WARNING, "start_scsi: (pid#%li) "

				"Out of tags target=<%02i-%i>)\n",

				srb->cmd->pid, srb->cmd->device->id,

				srb->cmd->serial_number, srb->cmd->device->id,

				srb->cmd->device->lun);

			srb->state = SRB_READY;

			DC395x_write16(acb, TRM_S1040_SCSI_CONTROL,
@@ -1622,7 +1622,7 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb, 
/*polling:*/

	/* Send CDB ..command block ......... */

	dprintkdbg(DBG_KG, "start_scsi: (pid#%li) <%02i-%i> cmnd=0x%02x tag=%i\n",

		srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun,

		srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun,

		srb->cmd->cmnd[0], srb->tag_number);

	if (srb->flag & AUTO_REQSENSE) {

		DC395x_write8(acb, TRM_S1040_SCSI_FIFO, REQUEST_SENSE);
@@ -1647,7 +1647,7 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb, 
		 * : Let's process it first!

		 */

		dprintkdbg(DBG_0, "start_scsi: (pid#%li) <%02i-%i> Failed - busy\n",

			srb->cmd->pid, dcb->target_id, dcb->target_lun);

			srb->cmd->serial_number, dcb->target_id, dcb->target_lun);

		srb->state = SRB_READY;

		free_tag(dcb, srb);

		srb->msg_count = 0;
@@ -1842,7 +1842,7 @@ static irqreturn_t dc395x_interrupt(int irq, void *dev_id) 
static void msgout_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,

		u16 *pscsi_status)

{

	dprintkdbg(DBG_0, "msgout_phase0: (pid#%li)\n", srb->cmd->pid);

	dprintkdbg(DBG_0, "msgout_phase0: (pid#%li)\n", srb->cmd->serial_number);

	if (srb->state & (SRB_UNEXPECT_RESEL + SRB_ABORT_SENT))

		*pscsi_status = PH_BUS_FREE;	/*.. initial phase */
@@ -1856,18 +1856,18 @@ static void msgout_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
{

	u16 i;

	u8 *ptr;

	dprintkdbg(DBG_0, "msgout_phase1: (pid#%li)\n", srb->cmd->pid);

	dprintkdbg(DBG_0, "msgout_phase1: (pid#%li)\n", srb->cmd->serial_number);



	clear_fifo(acb, "msgout_phase1");

	if (!(srb->state & SRB_MSGOUT)) {

		srb->state |= SRB_MSGOUT;

		dprintkl(KERN_DEBUG,

			"msgout_phase1: (pid#%li) Phase unexpected\n",

			srb->cmd->pid);	/* So what ? */

			srb->cmd->serial_number);	/* So what ? */

	}

	if (!srb->msg_count) {

		dprintkdbg(DBG_0, "msgout_phase1: (pid#%li) NOP msg\n",

			srb->cmd->pid);

			srb->cmd->serial_number);

		DC395x_write8(acb, TRM_S1040_SCSI_FIFO, MSG_NOP);

		DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);	/* it's important for atn stop */

		DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_FIFO_OUT);
@@ -1887,7 +1887,7 @@ static void msgout_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
static void command_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,

		u16 *pscsi_status)

{

	dprintkdbg(DBG_0, "command_phase0: (pid#%li)\n", srb->cmd->pid);

	dprintkdbg(DBG_0, "command_phase0: (pid#%li)\n", srb->cmd->serial_number);

	DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);

}
@@ -1898,7 +1898,7 @@ static void command_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
	struct DeviceCtlBlk *dcb;

	u8 *ptr;

	u16 i;

	dprintkdbg(DBG_0, "command_phase1: (pid#%li)\n", srb->cmd->pid);

	dprintkdbg(DBG_0, "command_phase1: (pid#%li)\n", srb->cmd->serial_number);



	clear_fifo(acb, "command_phase1");

	DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_CLRATN);
@@ -2042,7 +2042,7 @@ static void data_out_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
	u16 scsi_status = *pscsi_status;

	u32 d_left_counter = 0;

	dprintkdbg(DBG_0, "data_out_phase0: (pid#%li) <%02i-%i>\n",

		srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun);

		srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);



	/*

	 * KG: We need to drain the buffers before we draw any conclusions!
@@ -2172,7 +2172,7 @@ static void data_out_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
		u16 *pscsi_status)

{

	dprintkdbg(DBG_0, "data_out_phase1: (pid#%li) <%02i-%i>\n",

		srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun);

		srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);

	clear_fifo(acb, "data_out_phase1");

	/* do prepare before transfer when data out phase */

	data_io_transfer(acb, srb, XFERDATAOUT);
@@ -2184,7 +2184,7 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
	u16 scsi_status = *pscsi_status;



	dprintkdbg(DBG_0, "data_in_phase0: (pid#%li) <%02i-%i>\n",

		srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun);

		srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);



	/*

	 * KG: DataIn is much more tricky than DataOut. When the device is finished
@@ -2205,7 +2205,7 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 


		if (scsi_status & PARITYERROR) {

			dprintkl(KERN_INFO, "data_in_phase0: (pid#%li) "

				"Parity Error\n", srb->cmd->pid);

				"Parity Error\n", srb->cmd->serial_number);

			srb->status |= PARITY_ERROR;

		}

		/*
@@ -2395,7 +2395,7 @@ static void data_in_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
		u16 *pscsi_status)

{

	dprintkdbg(DBG_0, "data_in_phase1: (pid#%li) <%02i-%i>\n",

		srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun);

		srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);

	data_io_transfer(acb, srb, XFERDATAIN);

}
@@ -2407,7 +2407,7 @@ static void data_io_transfer(struct AdapterCtlBlk *acb, 
	u8 bval;

	dprintkdbg(DBG_0,

		"data_io_transfer: (pid#%li) <%02i-%i> %c len=%i, sg=(%i/%i)\n",

		srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun,

		srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun,

		((io_dir & DMACMD_DIR) ? 'r' : 'w'),

		srb->total_xfer_length, srb->sg_index, srb->sg_count);

	if (srb == acb->tmp_srb)
@@ -2580,7 +2580,7 @@ static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
		u16 *pscsi_status)

{

	dprintkdbg(DBG_0, "status_phase0: (pid#%li) <%02i-%i>\n",

		srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun);

		srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);

	srb->target_status = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);

	srb->end_message = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);	/* get message */

	srb->state = SRB_COMPLETED;
@@ -2594,7 +2594,7 @@ static void status_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
		u16 *pscsi_status)

{

	dprintkdbg(DBG_0, "status_phase1: (pid#%li) <%02i-%i>\n",

		srb->cmd->pid, srb->cmd->device->id, srb->cmd->device->lun);

		srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);

	srb->state = SRB_STATUS;

	DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);	/* it's important for atn stop */

	DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_COMP);
@@ -2636,7 +2636,7 @@ static struct ScsiReqBlk *msgin_qtag(struct AdapterCtlBlk *acb, 
	struct ScsiReqBlk *srb = NULL;

	struct ScsiReqBlk *i;

	dprintkdbg(DBG_0, "msgin_qtag: (pid#%li) tag=%i srb=%p\n",

		   srb->cmd->pid, tag, srb);

		   srb->cmd->serial_number, tag, srb);



	if (!(dcb->tag_mask & (1 << tag)))

		dprintkl(KERN_DEBUG,
@@ -2655,7 +2655,7 @@ static struct ScsiReqBlk *msgin_qtag(struct AdapterCtlBlk *acb, 
		goto mingx0;



	dprintkdbg(DBG_0, "msgin_qtag: (pid#%li) <%02i-%i>\n",

		srb->cmd->pid, srb->dcb->target_id, srb->dcb->target_lun);

		srb->cmd->serial_number, srb->dcb->target_id, srb->dcb->target_lun);

	if (dcb->flag & ABORT_DEV_) {

		/*srb->state = SRB_ABORT_SENT; */

		enable_msgout_abort(acb, srb);
@@ -2865,7 +2865,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
		u16 *pscsi_status)

{

	struct DeviceCtlBlk *dcb = acb->active_dcb;

	dprintkdbg(DBG_0, "msgin_phase0: (pid#%li)\n", srb->cmd->pid);

	dprintkdbg(DBG_0, "msgin_phase0: (pid#%li)\n", srb->cmd->serial_number);



	srb->msgin_buf[acb->msg_len++] = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);

	if (msgin_completed(srb->msgin_buf, acb->msg_len)) {
@@ -2933,7 +2933,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
			 */

			dprintkdbg(DBG_0, "msgin_phase0: (pid#%li) "

				"SAVE POINTER rem=%i Ignore\n",

				srb->cmd->pid, srb->total_xfer_length);

				srb->cmd->serial_number, srb->total_xfer_length);

			break;



		case RESTORE_POINTERS:
@@ -2943,7 +2943,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
		case ABORT:

			dprintkdbg(DBG_0, "msgin_phase0: (pid#%li) "

				"<%02i-%i> ABORT msg\n",

				srb->cmd->pid, dcb->target_id,

				srb->cmd->serial_number, dcb->target_id,

				dcb->target_lun);

			dcb->flag |= ABORT_DEV_;

			enable_msgout_abort(acb, srb);
@@ -2975,7 +2975,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb, 
static void msgin_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,

		u16 *pscsi_status)

{

	dprintkdbg(DBG_0, "msgin_phase1: (pid#%li)\n", srb->cmd->pid);

	dprintkdbg(DBG_0, "msgin_phase1: (pid#%li)\n", srb->cmd->serial_number);

	clear_fifo(acb, "msgin_phase1");

	DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 1);

	if (!(srb->state & SRB_MSGIN)) {
@@ -3041,7 +3041,7 @@ static void disconnect(struct AdapterCtlBlk *acb) 
	}

	srb = dcb->active_srb;

	acb->active_dcb = NULL;

	dprintkdbg(DBG_0, "disconnect: (pid#%li)\n", srb->cmd->pid);

	dprintkdbg(DBG_0, "disconnect: (pid#%li)\n", srb->cmd->serial_number);



	srb->scsi_phase = PH_BUS_FREE;	/* initial phase */

	clear_fifo(acb, "disconnect");
@@ -3072,13 +3072,13 @@ static void disconnect(struct AdapterCtlBlk *acb) 
				srb->state = SRB_READY;

				dprintkl(KERN_DEBUG,

					"disconnect: (pid#%li) Unexpected\n",

					srb->cmd->pid);

					srb->cmd->serial_number);

				srb->target_status = SCSI_STAT_SEL_TIMEOUT;

				goto disc1;

			} else {

				/* Normal selection timeout */

				dprintkdbg(DBG_KG, "disconnect: (pid#%li) "

					"<%02i-%i> SelTO\n", srb->cmd->pid,

					"<%02i-%i> SelTO\n", srb->cmd->serial_number,

					dcb->target_id, dcb->target_lun);

				if (srb->retry_count++ > DC395x_MAX_RETRIES

				    || acb->scan_devices) {
@@ -3090,7 +3090,7 @@ static void disconnect(struct AdapterCtlBlk *acb) 
				srb_going_to_waiting_move(dcb, srb);

				dprintkdbg(DBG_KG,

					"disconnect: (pid#%li) Retry\n",

					srb->cmd->pid);

					srb->cmd->serial_number);

				waiting_set_timer(acb, HZ / 20);

			}

		} else if (srb->state & SRB_DISCONNECT) {
@@ -3144,7 +3144,7 @@ static void reselect(struct AdapterCtlBlk *acb) 
		if (!acb->scan_devices) {

			dprintkdbg(DBG_KG, "reselect: (pid#%li) <%02i-%i> "

				"Arb lost but Resel win rsel=%i stat=0x%04x\n",

				srb->cmd->pid, dcb->target_id,

				srb->cmd->serial_number, dcb->target_id,

				dcb->target_lun, rsel_tar_lun_id,

				DC395x_read16(acb, TRM_S1040_SCSI_STATUS));

			arblostflag = 1;
@@ -3318,7 +3318,7 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb, 
	enum dma_data_direction dir = cmd->sc_data_direction;

	int ckc_only = 1;



	dprintkdbg(DBG_1, "srb_done: (pid#%li) <%02i-%i>\n", srb->cmd->pid,

	dprintkdbg(DBG_1, "srb_done: (pid#%li) <%02i-%i>\n", srb->cmd->serial_number,

		srb->cmd->device->id, srb->cmd->device->lun);

	dprintkdbg(DBG_SG, "srb_done: srb=%p sg=%i(%i/%i) buf=%p\n",

		   srb, scsi_sg_count(cmd), srb->sg_index, srb->sg_count,
@@ -3499,7 +3499,7 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb, 
		if (srb->total_xfer_length)

			dprintkdbg(DBG_KG, "srb_done: (pid#%li) <%02i-%i> "

				"cmnd=0x%02x Missed %i bytes\n",

				cmd->pid, cmd->device->id, cmd->device->lun,

				cmd->serial_number, cmd->device->id, cmd->device->lun,

				cmd->cmnd[0], srb->total_xfer_length);

	}
@@ -3509,7 +3509,7 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb, 
		dprintkl(KERN_ERR, "srb_done: ERROR! Completed cmd with tmp_srb\n");

	else {

		dprintkdbg(DBG_0, "srb_done: (pid#%li) done result=0x%08x\n",

			cmd->pid, cmd->result);

			cmd->serial_number, cmd->result);

		srb_free_insert(acb, srb);

	}

	pci_unmap_srb(acb, srb);
@@ -3538,7 +3538,7 @@ static void doing_srb_done(struct AdapterCtlBlk *acb, u8 did_flag, 
			p = srb->cmd;

			dir = p->sc_data_direction;

			result = MK_RES(0, did_flag, 0, 0);

			printk("G:%li(%02i-%i) ", p->pid,

			printk("G:%li(%02i-%i) ", p->serial_number,

			       p->device->id, p->device->lun);

			srb_going_remove(dcb, srb);

			free_tag(dcb, srb);
@@ -3568,7 +3568,7 @@ static void doing_srb_done(struct AdapterCtlBlk *acb, u8 did_flag, 
			p = srb->cmd;



			result = MK_RES(0, did_flag, 0, 0);

			printk("W:%li<%02i-%i>", p->pid, p->device->id,

			printk("W:%li<%02i-%i>", p->serial_number, p->device->id,

			       p->device->lun);

			srb_waiting_remove(dcb, srb);

			srb_free_insert(acb, srb);
@@ -3678,7 +3678,7 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb, 
{

	struct scsi_cmnd *cmd = srb->cmd;

	dprintkdbg(DBG_1, "request_sense: (pid#%li) <%02i-%i>\n",

		cmd->pid, cmd->device->id, cmd->device->lun);

		cmd->serial_number, cmd->device->id, cmd->device->lun);



	srb->flag |= AUTO_REQSENSE;

	srb->adapter_status = 0;
@@ -3709,7 +3709,7 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb, 
	if (start_scsi(acb, dcb, srb)) {	/* Should only happen, if sb. else grabs the bus */

		dprintkl(KERN_DEBUG,

			"request_sense: (pid#%li) failed <%02i-%i>\n",

			srb->cmd->pid, dcb->target_id, dcb->target_lun);

			srb->cmd->serial_number, dcb->target_id, dcb->target_lun);

		srb_going_to_waiting_move(dcb, srb);

		waiting_set_timer(acb, HZ / 100);

	}
@@ -4717,13 +4717,13 @@ static int dc395x_proc_info(struct Scsi_Host *host, char *buffer, 
				dcb->target_id, dcb->target_lun,

				list_size(&dcb->srb_waiting_list));

                list_for_each_entry(srb, &dcb->srb_waiting_list, list)

			SPRINTF(" %li", srb->cmd->pid);

			SPRINTF(" %li", srb->cmd->serial_number);

		if (!list_empty(&dcb->srb_going_list))

			SPRINTF("\nDCB (%02i-%i): Going  : %i:",

				dcb->target_id, dcb->target_lun,

				list_size(&dcb->srb_going_list));

		list_for_each_entry(srb, &dcb->srb_going_list, list)

			SPRINTF(" %li", srb->cmd->pid);

			SPRINTF(" %li", srb->cmd->serial_number);

		if (!list_empty(&dcb->srb_waiting_list) || !list_empty(&dcb->srb_going_list))

			SPRINTF("\n");

	}

drivers/scsi/eata.c

+22 −22
Original line number Diff line number Diff line
@@ -1758,7 +1758,7 @@ static int eata2x_queuecommand(struct scsi_cmnd *SCpnt, 


	if (SCpnt->host_scribble)

		panic("%s: qcomm, pid %ld, SCpnt %p already active.\n",

		      ha->board_name, SCpnt->pid, SCpnt);

		      ha->board_name, SCpnt->serial_number, SCpnt);



	/* i is the mailbox number, look for the first free mailbox

	   starting from last_cp_used */
@@ -1792,7 +1792,7 @@ static int eata2x_queuecommand(struct scsi_cmnd *SCpnt, 


	if (do_trace)

		scmd_printk(KERN_INFO, SCpnt,

			"qcomm, mbox %d, pid %ld.\n", i, SCpnt->pid);

			"qcomm, mbox %d, pid %ld.\n", i, SCpnt->serial_number);



	cpp->reqsen = 1;

	cpp->dispri = 1;
@@ -1825,7 +1825,7 @@ static int eata2x_queuecommand(struct scsi_cmnd *SCpnt, 
		unmap_dma(i, ha);

		SCpnt->host_scribble = NULL;

		scmd_printk(KERN_INFO, SCpnt,

			"qcomm, pid %ld, adapter busy.\n", SCpnt->pid);

			"qcomm, pid %ld, adapter busy.\n", SCpnt->serial_number);

		return 1;

	}
@@ -1841,13 +1841,13 @@ static int eata2x_eh_abort(struct scsi_cmnd *SCarg) 


	if (SCarg->host_scribble == NULL) {

		scmd_printk(KERN_INFO, SCarg,

			"abort, pid %ld inactive.\n", SCarg->pid);

			"abort, pid %ld inactive.\n", SCarg->serial_number);

		return SUCCESS;

	}



	i = *(unsigned int *)SCarg->host_scribble;

	scmd_printk(KERN_WARNING, SCarg,

		"abort, mbox %d, pid %ld.\n", i, SCarg->pid);

		"abort, mbox %d, pid %ld.\n", i, SCarg->serial_number);



	if (i >= shost->can_queue)

		panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name);
@@ -1892,7 +1892,7 @@ static int eata2x_eh_abort(struct scsi_cmnd *SCarg) 
		SCarg->host_scribble = NULL;

		ha->cp_stat[i] = FREE;

		printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n",

		       ha->board_name, i, SCarg->pid);

		       ha->board_name, i, SCarg->serial_number);

		SCarg->scsi_done(SCarg);

		return SUCCESS;

	}
@@ -1909,12 +1909,12 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg) 
	struct hostdata *ha = (struct hostdata *)shost->hostdata;



	scmd_printk(KERN_INFO, SCarg,

		"reset, enter, pid %ld.\n", SCarg->pid);

		"reset, enter, pid %ld.\n", SCarg->serial_number);



	spin_lock_irq(shost->host_lock);



	if (SCarg->host_scribble == NULL)

		printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->pid);

		printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->serial_number);



	if (ha->in_reset) {

		printk("%s: reset, exit, already in reset.\n", ha->board_name);
@@ -1954,13 +1954,13 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg) 
		if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {

			ha->cp_stat[i] = ABORTING;

			printk("%s: reset, mbox %d aborting, pid %ld.\n",

			       ha->board_name, i, SCpnt->pid);

			       ha->board_name, i, SCpnt->serial_number);

		}



		else {

			ha->cp_stat[i] = IN_RESET;

			printk("%s: reset, mbox %d in reset, pid %ld.\n",

			       ha->board_name, i, SCpnt->pid);

			       ha->board_name, i, SCpnt->serial_number);

		}



		if (SCpnt->host_scribble == NULL)
@@ -2015,7 +2015,7 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg) 


			printk

			    ("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n",

			     ha->board_name, i, SCpnt->pid);

			     ha->board_name, i, SCpnt->serial_number);

		}



		else if (ha->cp_stat[i] == ABORTING) {
@@ -2029,7 +2029,7 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg) 


			printk

			    ("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n",

			     ha->board_name, i, SCpnt->pid);

			     ha->board_name, i, SCpnt->serial_number);

		}



		else
@@ -2043,7 +2043,7 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg) 
	do_trace = 0;



	if (arg_done)

		printk("%s: reset, exit, pid %ld done.\n", ha->board_name, SCarg->pid);

		printk("%s: reset, exit, pid %ld done.\n", ha->board_name, SCarg->serial_number);

	else

		printk("%s: reset, exit.\n", ha->board_name);
@@ -2182,7 +2182,7 @@ static int reorder(struct hostdata *ha, unsigned long cursec, 
			cpp = &ha->cp[k];

			SCpnt = cpp->SCpnt;

			ll[n] = SCpnt->request->nr_sectors;

			pl[n] = SCpnt->pid;

			pl[n] = SCpnt->serial_number;



			if (!n)

				continue;
@@ -2230,7 +2230,7 @@ static int reorder(struct hostdata *ha, unsigned long cursec, 
			    "%s pid %ld mb %d fc %d nr %d sec %ld ns %ld"

			     " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",

			     (ihdlr ? "ihdlr" : "qcomm"),

			     SCpnt->pid, k, flushcount,

			     SCpnt->serial_number, k, flushcount,

			     n_ready, SCpnt->request->sector,

			     SCpnt->request->nr_sectors, cursec, YESNO(s),

			     YESNO(r), YESNO(rev), YESNO(input_only),
@@ -2277,7 +2277,7 @@ static void flush_dev(struct scsi_device *dev, unsigned long cursec, 
			    "%s, pid %ld, mbox %d, adapter"

			     " busy, will abort.\n",

			     (ihdlr ? "ihdlr" : "qcomm"),

			     SCpnt->pid, k);

			     SCpnt->serial_number, k);

			ha->cp_stat[k] = ABORTING;

			continue;

		}
@@ -2391,11 +2391,11 @@ static irqreturn_t ihdlr(int irq, struct Scsi_Host *shost) 


	if (SCpnt->host_scribble == NULL)

		panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", ha->board_name,

		      i, SCpnt->pid, SCpnt);

		      i, SCpnt->serial_number, SCpnt);



	if (*(unsigned int *)SCpnt->host_scribble != i)

		panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n",

		      ha->board_name, i, SCpnt->pid,

		      ha->board_name, i, SCpnt->serial_number,

		      *(unsigned int *)SCpnt->host_scribble);



	sync_dma(i, ha);
@@ -2445,12 +2445,12 @@ static irqreturn_t ihdlr(int irq, struct Scsi_Host *shost) 
			       "target_status 0x%x, sense key 0x%x.\n",

			       ha->board_name,

			       SCpnt->device->channel, SCpnt->device->id,

			       SCpnt->device->lun, SCpnt->pid,

			       SCpnt->device->lun, SCpnt->serial_number,

			       spp->target_status, SCpnt->sense_buffer[2]);



		ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;



		if (ha->last_retried_pid == SCpnt->pid)

		if (ha->last_retried_pid == SCpnt->serial_number)

			ha->retries = 0;



		break;
@@ -2485,7 +2485,7 @@ static irqreturn_t ihdlr(int irq, struct Scsi_Host *shost) 
#endif



			ha->retries++;

			ha->last_retried_pid = SCpnt->pid;

			ha->last_retried_pid = SCpnt->serial_number;

		} else

			status = DID_ERROR << 16;
@@ -2516,7 +2516,7 @@ static irqreturn_t ihdlr(int irq, struct Scsi_Host *shost) 
		scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"

		       " pid %ld, reg 0x%x, count %d.\n",

		       i, spp->adapter_status, spp->target_status,

		       SCpnt->pid, reg, ha->iocount);

		       SCpnt->serial_number, reg, ha->iocount);



	unmap_dma(i, ha);

drivers/scsi/eata_pio.c

+6 −6
Original line number Diff line number Diff line
@@ -375,7 +375,7 @@ static int eata_pio_queue(struct scsi_cmnd *cmd, 


	DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd,

		"eata_pio_queue pid %ld, y %d\n",

		cmd->pid, y));

		cmd->serial_number, y));



	cmd->scsi_done = (void *) done;
@@ -420,7 +420,7 @@ static int eata_pio_queue(struct scsi_cmnd *cmd, 
		cmd->result = DID_BUS_BUSY << 16;

		scmd_printk(KERN_NOTICE, cmd,

			"eata_pio_queue pid %ld, HBA busy, "

			"returning DID_BUS_BUSY, done.\n", cmd->pid);

			"returning DID_BUS_BUSY, done.\n", cmd->serial_number);

		done(cmd);

		cp->status = FREE;

		return 0;
@@ -435,7 +435,7 @@ static int eata_pio_queue(struct scsi_cmnd *cmd, 


	DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd,

		"Queued base %#.4lx pid: %ld "

		"slot %d irq %d\n", sh->base, cmd->pid, y, sh->irq));

		"slot %d irq %d\n", sh->base, cmd->serial_number, y, sh->irq));



	return 0;

}
@@ -446,7 +446,7 @@ static int eata_pio_abort(struct scsi_cmnd *cmd) 


	DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd,

		"eata_pio_abort called pid: %ld\n",

		cmd->pid));

		cmd->serial_number));



	while (inb(cmd->device->host->base + HA_RAUXSTAT) & HA_ABUSY)

		if (--loop == 0) {
@@ -482,7 +482,7 @@ static int eata_pio_host_reset(struct scsi_cmnd *cmd) 


	DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd,

		"eata_pio_reset called pid:%ld\n",

		cmd->pid));

		cmd->serial_number));



	spin_lock_irq(host->host_lock);
@@ -501,7 +501,7 @@ static int eata_pio_host_reset(struct scsi_cmnd *cmd) 


		sp = HD(cmd)->ccb[x].cmd;

		HD(cmd)->ccb[x].status = RESET;

		printk(KERN_WARNING "eata_pio_reset: slot %d in reset, pid %ld.\n", x, sp->pid);

		printk(KERN_WARNING "eata_pio_reset: slot %d in reset, pid %ld.\n", x, sp->serial_number);



		if (sp == NULL)

			panic("eata_pio_reset: slot %d, sp==NULL.\n", x);

drivers/scsi/in2000.c

+15 −15

File changed.

Preview size limit exceeded, changes collapsed.

drivers/scsi/ncr53c8xx.c

+1 −6
Original line number Diff line number Diff line
@@ -8143,12 +8143,7 @@ static int ncr53c8xx_abort(struct scsi_cmnd *cmd) 
	unsigned long flags;

	struct scsi_cmnd *done_list;



#if defined SCSI_RESET_SYNCHRONOUS && defined SCSI_RESET_ASYNCHRONOUS

	printk("ncr53c8xx_abort: pid=%lu serial_number=%ld\n",

		cmd->pid, cmd->serial_number);

#else

	printk("ncr53c8xx_abort: command pid %lu\n", cmd->pid);

#endif

	printk("ncr53c8xx_abort: command pid %lu\n", cmd->serial_number);



	NCR_LOCK_NCB(np, flags);