Commit b1abb4d6 authored by James Bottomley's avatar James Bottomley Committed by James Bottomley
Browse files

[SCSI] aic7xxx: remove separate target and device allocations 



Since the aic driver is now taught to speak in terms of the generic
linux devices, we can now also dispense with the transport class get
routines (since we update the parameters when the driver sees they
change) and also plumb it into the spi transport transfer agreement
reporting infrastructure.

Signed-off-by: default avatarJames Bottomley <James.Bottomley@SteelEye.com>
parent 153b1e1f

drivers/scsi/aic7xxx/aic7xxx_osm.c

+201 −374
Original line number Diff line number Diff line
@@ -122,8 +122,6 @@ 
#include "aic7xxx_osm.h"

#include "aic7xxx_inline.h"

#include <scsi/scsicam.h>

#include <scsi/scsi_transport.h>

#include <scsi/scsi_transport_spi.h>



static struct scsi_transport_template *ahc_linux_transport_template = NULL;
@@ -423,7 +421,7 @@ MODULE_PARM_DESC(aic7xxx, 
);



static void ahc_linux_handle_scsi_status(struct ahc_softc *,

					 struct ahc_linux_device *,

					 struct scsi_device *,

					 struct scb *);

static void ahc_linux_queue_cmd_complete(struct ahc_softc *ahc,

					 struct scsi_cmnd *cmd);
@@ -434,17 +432,7 @@ static int ahc_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag); 
static void ahc_linux_initialize_scsi_bus(struct ahc_softc *ahc);

static u_int ahc_linux_user_tagdepth(struct ahc_softc *ahc,

				     struct ahc_devinfo *devinfo);

static void ahc_linux_device_queue_depth(struct ahc_softc *ahc,

					 struct ahc_linux_device *dev);

static struct ahc_linux_target*	ahc_linux_alloc_target(struct ahc_softc*,

						       u_int, u_int);

static void			ahc_linux_free_target(struct ahc_softc*,

						      struct ahc_linux_target*);

static struct ahc_linux_device*	ahc_linux_alloc_device(struct ahc_softc*,

						       struct ahc_linux_target*,

						       u_int);

static void			ahc_linux_free_device(struct ahc_softc*,

						      struct ahc_linux_device*);

static void ahc_linux_device_queue_depth(struct scsi_device *);

static int ahc_linux_run_command(struct ahc_softc*,

				 struct ahc_linux_device *,

				 struct scsi_cmnd *);
@@ -454,32 +442,12 @@ static int aic7xxx_setup(char *s); 
static int  ahc_linux_next_unit(void);



/********************************* Inlines ************************************/

static __inline struct ahc_linux_device*

		     ahc_linux_get_device(struct ahc_softc *ahc, u_int channel,

					  u_int target, u_int lun);

static __inline void ahc_linux_unmap_scb(struct ahc_softc*, struct scb*);



static __inline int ahc_linux_map_seg(struct ahc_softc *ahc, struct scb *scb,

		 		      struct ahc_dma_seg *sg,

				      dma_addr_t addr, bus_size_t len);



static __inline struct ahc_linux_device*

ahc_linux_get_device(struct ahc_softc *ahc, u_int channel, u_int target,

		     u_int lun)

{

	struct ahc_linux_target *targ;

	struct ahc_linux_device *dev;

	u_int target_offset;



	target_offset = target;

	if (channel != 0)

		target_offset += 8;

	targ = ahc->platform_data->targets[target_offset];

	BUG_ON(targ == NULL);

	dev = targ->devices[lun];

	return dev;

}



static __inline void

ahc_linux_unmap_scb(struct ahc_softc *ahc, struct scb *scb)

{
@@ -611,7 +579,7 @@ static int 
ahc_linux_queue(struct scsi_cmnd * cmd, void (*scsi_done) (struct scsi_cmnd *))

{

	struct	 ahc_softc *ahc;

	struct	 ahc_linux_device *dev;

	struct	 ahc_linux_device *dev = scsi_transport_device_data(cmd->device);



	ahc = *(struct ahc_softc **)cmd->device->host->hostdata;
@@ -629,55 +597,57 @@ ahc_linux_queue(struct scsi_cmnd * cmd, void (*scsi_done) (struct scsi_cmnd *)) 
	if (ahc->platform_data->qfrozen != 0)

		return SCSI_MLQUEUE_HOST_BUSY;



	dev = ahc_linux_get_device(ahc, cmd->device->channel, cmd->device->id,

				   cmd->device->lun);

	BUG_ON(dev == NULL);



	cmd->result = CAM_REQ_INPROG << 16;



	return ahc_linux_run_command(ahc, dev, cmd);

}



static int

ahc_linux_slave_alloc(struct scsi_device *device)

static inline struct scsi_target **

ahc_linux_target_in_softc(struct scsi_target *starget)

{

	struct	ahc_softc *ahc;

	struct ahc_linux_target *targ;

	struct scsi_target *starget = device->sdev_target;

	struct ahc_linux_device *dev;

	struct	ahc_softc *ahc =

		*((struct ahc_softc **)dev_to_shost(&starget->dev)->hostdata);

	unsigned int target_offset;

	unsigned long flags;

	int retval = -ENOMEM;



	target_offset = starget->id;

	if (starget->channel != 0)

		target_offset += 8;



	ahc = *((struct ahc_softc **)device->host->hostdata);

	if (bootverbose)

		printf("%s: Slave Alloc %d\n", ahc_name(ahc), device->id);

	ahc_lock(ahc, &flags);

	targ = ahc->platform_data->targets[target_offset];

	if (targ == NULL) {

		struct seeprom_config *sc;



		targ = ahc_linux_alloc_target(ahc, starget->channel,

						starget->id);

		sc = ahc->seep_config;

		if (targ == NULL)

			goto out;

	return &ahc->platform_data->starget[target_offset];

}



		if (sc) {

static int

ahc_linux_target_alloc(struct scsi_target *starget)

{

	struct	ahc_softc *ahc =

		*((struct ahc_softc **)dev_to_shost(&starget->dev)->hostdata);

	struct seeprom_config *sc = ahc->seep_config;

	unsigned long flags;

	struct scsi_target **ahc_targp = ahc_linux_target_in_softc(starget);

	struct ahc_linux_target *targ = scsi_transport_target_data(starget);

	unsigned short scsirate;

	struct ahc_devinfo devinfo;

	struct ahc_initiator_tinfo *tinfo;

	struct ahc_tmode_tstate *tstate;

	char channel = starget->channel + 'A';

	unsigned int our_id = ahc->our_id;

	unsigned int target_offset;



	target_offset = starget->id;

	if (starget->channel != 0)

		target_offset += 8;

	  

	if (starget->channel)

		our_id = ahc->our_id_b;



	ahc_lock(ahc, &flags);



	BUG_ON(*ahc_targp != NULL);



	*ahc_targp = starget;

	memset(targ, 0, sizeof(*targ));



	if (sc) {

		if ((ahc->features & AHC_ULTRA2) != 0) {

			scsirate = sc->device_flags[target_offset] & CFXFER;

		} else {
@@ -693,68 +663,96 @@ ahc_linux_slave_alloc(struct scsi_device *device) 
		spi_min_period(starget) = 

			ahc_find_period(ahc, scsirate, AHC_SYNCRATE_DT);

		tinfo = ahc_fetch_transinfo(ahc, channel, ahc->our_id,

						    targ->target, &tstate);

			ahc_compile_devinfo(&devinfo, our_id, targ->target,

					    starget->id, &tstate);

	}

	ahc_compile_devinfo(&devinfo, our_id, starget->id,

			    CAM_LUN_WILDCARD, channel,

			    ROLE_INITIATOR);

	ahc_set_syncrate(ahc, &devinfo, NULL, 0, 0, 0,

			 AHC_TRANS_GOAL, /*paused*/FALSE);

	ahc_set_width(ahc, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,

		      AHC_TRANS_GOAL, /*paused*/FALSE);

		}

	ahc_unlock(ahc, &flags);



	return 0;

}

	dev = targ->devices[device->lun];

	if (dev == NULL) {

		dev = ahc_linux_alloc_device(ahc, targ, device->lun);

		if (dev == NULL)

			goto out;



static void

ahc_linux_target_destroy(struct scsi_target *starget)

{

	struct scsi_target **ahc_targp = ahc_linux_target_in_softc(starget);



	*ahc_targp = NULL;

}

	retval = 0;



 out:

	ahc_unlock(ahc, &flags);

	return retval;

static int

ahc_linux_slave_alloc(struct scsi_device *sdev)

{

	struct	ahc_softc *ahc =

		*((struct ahc_softc **)sdev->host->hostdata);

	struct scsi_target *starget = sdev->sdev_target;

	struct ahc_linux_target *targ = scsi_transport_target_data(starget);

	struct ahc_linux_device *dev;



	if (bootverbose)

		printf("%s: Slave Alloc %d\n", ahc_name(ahc), sdev->id);



	BUG_ON(targ->sdev[sdev->lun] != NULL);



	dev = scsi_transport_device_data(sdev);

	memset(dev, 0, sizeof(*dev));



	/*

	 * We start out life using untagged

	 * transactions of which we allow one.

	 */

	dev->openings = 1;



	/*

	 * Set maxtags to 0.  This will be changed if we

	 * later determine that we are dealing with

	 * a tagged queuing capable device.

	 */

	dev->maxtags = 0;

	

	targ->sdev[sdev->lun] = sdev;



	return 0;

}



static int

ahc_linux_slave_configure(struct scsi_device *device)

ahc_linux_slave_configure(struct scsi_device *sdev)

{

	struct	ahc_softc *ahc;

	struct	ahc_linux_device *dev;



	ahc = *((struct ahc_softc **)device->host->hostdata);

	ahc = *((struct ahc_softc **)sdev->host->hostdata);



	if (bootverbose)

		printf("%s: Slave Configure %d\n", ahc_name(ahc), device->id);

		printf("%s: Slave Configure %d\n", ahc_name(ahc), sdev->id);



	dev = ahc_linux_get_device(ahc, device->channel, device->id,

				   device->lun);

	dev->scsi_device = device;

	ahc_linux_device_queue_depth(ahc, dev);

	ahc_linux_device_queue_depth(sdev);



	/* Initial Domain Validation */

	if (!spi_initial_dv(device->sdev_target))

		spi_dv_device(device);

	if (!spi_initial_dv(sdev->sdev_target))

		spi_dv_device(sdev);



	return 0;

}



static void

ahc_linux_slave_destroy(struct scsi_device *device)

ahc_linux_slave_destroy(struct scsi_device *sdev)

{

	struct	ahc_softc *ahc;

	struct	ahc_linux_device *dev;

	struct	ahc_linux_device *dev = scsi_transport_device_data(sdev);

	struct	ahc_linux_target *targ = scsi_transport_target_data(sdev->sdev_target);



	ahc = *((struct ahc_softc **)device->host->hostdata);

	ahc = *((struct ahc_softc **)sdev->host->hostdata);

	if (bootverbose)

		printf("%s: Slave Destroy %d\n", ahc_name(ahc), device->id);

	dev = ahc_linux_get_device(ahc, device->channel,

				   device->id, device->lun);

		printf("%s: Slave Destroy %d\n", ahc_name(ahc), sdev->id);



	BUG_ON(dev->active);



	ahc_linux_free_device(ahc, dev);

	targ->sdev[sdev->lun] = NULL;

}



#if defined(__i386__)
@@ -874,6 +872,8 @@ struct scsi_host_template aic7xxx_driver_template = { 
	.slave_alloc		= ahc_linux_slave_alloc,

	.slave_configure	= ahc_linux_slave_configure,

	.slave_destroy		= ahc_linux_slave_destroy,

	.target_alloc		= ahc_linux_target_alloc,

	.target_destroy		= ahc_linux_target_destroy,

};



/**************************** Tasklet Handler *********************************/
@@ -1335,8 +1335,7 @@ ahc_platform_alloc(struct ahc_softc *ahc, void *platform_arg) 
void

ahc_platform_free(struct ahc_softc *ahc)

{

	struct ahc_linux_target *targ;

	struct ahc_linux_device *dev;

	struct scsi_target *starget;

	int i, j;



	if (ahc->platform_data != NULL) {
@@ -1347,22 +1346,17 @@ ahc_platform_free(struct ahc_softc *ahc) 


		/* destroy all of the device and target objects */

		for (i = 0; i < AHC_NUM_TARGETS; i++) {

			targ = ahc->platform_data->targets[i];

			if (targ != NULL) {

				/* Keep target around through the loop. */

				targ->refcount++;

			starget = ahc->platform_data->starget[i];

			if (starget != NULL) {

				for (j = 0; j < AHC_NUM_LUNS; j++) {

					struct ahc_linux_target *targ =

						scsi_transport_target_data(starget);



					if (targ->devices[j] == NULL)

					if (targ->sdev[j] == NULL)

						continue;

					dev = targ->devices[j];

					ahc_linux_free_device(ahc, dev);

					targ->sdev[j] = NULL;

				}

				/*

				 * Forcibly free the target now that

				 * all devices are gone.

				 */

				ahc_linux_free_target(ahc, targ);

				ahc->platform_data->starget[i] = NULL;

 			}

 		}
@@ -1395,15 +1389,25 @@ void 
ahc_platform_set_tags(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,

		      ahc_queue_alg alg)

{

	struct scsi_target *starget;

	struct ahc_linux_target *targ;

	struct ahc_linux_device *dev;

	struct scsi_device *sdev;

	u_int target_offset;

	int was_queuing;

	int now_queuing;



	dev = ahc_linux_get_device(ahc, devinfo->channel - 'A',

				   devinfo->target,

				   devinfo->lun);

	if (dev == NULL)

	target_offset = devinfo->target;

	if (devinfo->channel != 'A')

		target_offset += 8;

	starget = ahc->platform_data->starget[target_offset];

	targ = scsi_transport_target_data(starget);

	BUG_ON(targ == NULL);

	sdev = targ->sdev[devinfo->lun];

	if (sdev == NULL)

		return;

	dev = scsi_transport_device_data(sdev);



	was_queuing = dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED);

	switch (alg) {

	default:
@@ -1454,15 +1458,14 @@ ahc_platform_set_tags(struct ahc_softc *ahc, struct ahc_devinfo *devinfo, 
		dev->maxtags = 0;

		dev->openings =  1 - dev->active;

	}

	if (dev->scsi_device != NULL) {

	switch ((dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED))) {

	case AHC_DEV_Q_BASIC:

			scsi_adjust_queue_depth(dev->scsi_device,

		scsi_adjust_queue_depth(sdev,

					MSG_SIMPLE_TASK,

					dev->openings + dev->active);

		break;

	case AHC_DEV_Q_TAGGED:

			scsi_adjust_queue_depth(dev->scsi_device,

		scsi_adjust_queue_depth(sdev,

					MSG_ORDERED_TASK,

					dev->openings + dev->active);

		break;
@@ -1473,13 +1476,12 @@ ahc_platform_set_tags(struct ahc_softc *ahc, struct ahc_devinfo *devinfo, 
		 * serially on the controller/device.  This should

		 * remove some latency.

		 */

			scsi_adjust_queue_depth(dev->scsi_device,

		scsi_adjust_queue_depth(sdev,

					/*NON-TAGGED*/0,

					/*queue depth*/2);

		break;

	}

}

}



int

ahc_platform_abort_scbs(struct ahc_softc *ahc, int target, char channel,
@@ -1523,22 +1525,20 @@ ahc_linux_user_tagdepth(struct ahc_softc *ahc, struct ahc_devinfo *devinfo) 
 * Determines the queue depth for a given device.

 */

static void

ahc_linux_device_queue_depth(struct ahc_softc *ahc,

			     struct ahc_linux_device *dev)

ahc_linux_device_queue_depth(struct scsi_device *sdev)

{

	struct	ahc_devinfo devinfo;

	u_int	tags;

	struct ahc_softc *ahc = *((struct ahc_softc **)sdev->host->hostdata);



	ahc_compile_devinfo(&devinfo,

			    dev->target->channel == 0

			    sdev->sdev_target->channel == 0

			  ? ahc->our_id : ahc->our_id_b,

			    dev->target->target, dev->lun,

			    dev->target->channel == 0 ? 'A' : 'B',

			    sdev->sdev_target->id, sdev->lun,

			    sdev->sdev_target->channel == 0 ? 'A' : 'B',

			    ROLE_INITIATOR);

	tags = ahc_linux_user_tagdepth(ahc, &devinfo);

	if (tags != 0

	 && dev->scsi_device != NULL

	 && dev->scsi_device->tagged_supported != 0) {

	if (tags != 0 && sdev->tagged_supported != 0) {



		ahc_set_tags(ahc, &devinfo, AHC_QUEUE_TAGGED);

		ahc_print_devinfo(ahc, &devinfo);
@@ -1767,106 +1767,6 @@ ahc_platform_flushwork(struct ahc_softc *ahc) 


}



static struct ahc_linux_target*

ahc_linux_alloc_target(struct ahc_softc *ahc, u_int channel, u_int target)

{

	struct ahc_linux_target *targ;

	u_int target_offset;



	target_offset = target;

	if (channel != 0)

		target_offset += 8;



	targ = malloc(sizeof(*targ), M_DEVBUG, M_NOWAIT);

	if (targ == NULL)

		return (NULL);

	memset(targ, 0, sizeof(*targ));

	targ->channel = channel;

	targ->target = target;

	targ->ahc = ahc;

	ahc->platform_data->targets[target_offset] = targ;

	return (targ);

}



static void

ahc_linux_free_target(struct ahc_softc *ahc, struct ahc_linux_target *targ)

{

	struct ahc_devinfo devinfo;

	struct ahc_initiator_tinfo *tinfo;

	struct ahc_tmode_tstate *tstate;

	u_int our_id;

	u_int target_offset;

	char channel;



	/*

	 * Force a negotiation to async/narrow on any

	 * future command to this device unless a bus

	 * reset occurs between now and that command.

	 */

	channel = 'A' + targ->channel;

	our_id = ahc->our_id;

	target_offset = targ->target;

	if (targ->channel != 0) {

		target_offset += 8;

		our_id = ahc->our_id_b;

	}

	tinfo = ahc_fetch_transinfo(ahc, channel, our_id,

				    targ->target, &tstate);

	ahc_compile_devinfo(&devinfo, our_id, targ->target, CAM_LUN_WILDCARD,

			    channel, ROLE_INITIATOR);

	ahc_set_syncrate(ahc, &devinfo, NULL, 0, 0, 0,

			 AHC_TRANS_GOAL, /*paused*/FALSE);

	ahc_set_width(ahc, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,

		      AHC_TRANS_GOAL, /*paused*/FALSE);

	ahc_update_neg_request(ahc, &devinfo, tstate, tinfo, AHC_NEG_ALWAYS);

	ahc->platform_data->targets[target_offset] = NULL;

	free(targ, M_DEVBUF);

}



static struct ahc_linux_device*

ahc_linux_alloc_device(struct ahc_softc *ahc,

		 struct ahc_linux_target *targ, u_int lun)

{

	struct ahc_linux_device *dev;



	dev = malloc(sizeof(*dev), M_DEVBUG, M_NOWAIT);

	if (dev == NULL)

		return (NULL);

	memset(dev, 0, sizeof(*dev));

	dev->lun = lun;

	dev->target = targ;



	/*

	 * We start out life using untagged

	 * transactions of which we allow one.

	 */

	dev->openings = 1;



	/*

	 * Set maxtags to 0.  This will be changed if we

	 * later determine that we are dealing with

	 * a tagged queuing capable device.

	 */

	dev->maxtags = 0;

	

	targ->refcount++;

	targ->devices[lun] = dev;

	return (dev);

}



static void

ahc_linux_free_device(struct ahc_softc *ahc, struct ahc_linux_device *dev)

{

	struct ahc_linux_target *targ;



	targ = dev->target;

	targ->devices[dev->lun] = NULL;

	free(dev, M_DEVBUF);

	targ->refcount--;

	if (targ->refcount == 0)

		ahc_linux_free_target(ahc, targ);

}



void

ahc_send_async(struct ahc_softc *ahc, char channel,

	       u_int target, u_int lun, ac_code code, void *arg)
@@ -1875,11 +1775,15 @@ ahc_send_async(struct ahc_softc *ahc, char channel, 
	case AC_TRANSFER_NEG:

	{

		char	buf[80];

		struct	scsi_target *starget;

		struct	ahc_linux_target *targ;

		struct	info_str info;

		struct	ahc_initiator_tinfo *tinfo;

		struct	ahc_tmode_tstate *tstate;

		int	target_offset;

		unsigned int target_ppr_options;



		BUG_ON(target == CAM_TARGET_WILDCARD);



		info.buffer = buf;

		info.length = sizeof(buf);
@@ -1908,32 +1812,30 @@ ahc_send_async(struct ahc_softc *ahc, char channel, 
		target_offset = target;

		if (channel == 'B')

			target_offset += 8;

		targ = ahc->platform_data->targets[target_offset];

		starget = ahc->platform_data->starget[target_offset];

		targ = scsi_transport_target_data(starget);

		if (targ == NULL)

			break;

		if (tinfo->curr.period == targ->last_tinfo.period

		 && tinfo->curr.width == targ->last_tinfo.width

		 && tinfo->curr.offset == targ->last_tinfo.offset

		 && tinfo->curr.ppr_options == targ->last_tinfo.ppr_options)



		target_ppr_options =

			(spi_dt(starget) ? MSG_EXT_PPR_DT_REQ : 0)

			+ (spi_qas(starget) ? MSG_EXT_PPR_QAS_REQ : 0)

			+ (spi_iu(starget) ?  MSG_EXT_PPR_IU_REQ : 0);



		if (tinfo->curr.period == spi_period(starget)

		    && tinfo->curr.width == spi_width(starget)

		    && tinfo->curr.offset == spi_offset(starget)

		 && tinfo->curr.ppr_options == target_ppr_options)

			if (bootverbose == 0)

				break;



		targ->last_tinfo.period = tinfo->curr.period;

		targ->last_tinfo.width = tinfo->curr.width;

		targ->last_tinfo.offset = tinfo->curr.offset;

		targ->last_tinfo.ppr_options = tinfo->curr.ppr_options;



		printf("(%s:%c:", ahc_name(ahc), channel);

		if (target == CAM_TARGET_WILDCARD)

			printf("*): ");

		else

			printf("%d): ", target);

		ahc_format_transinfo(&info, &tinfo->curr);

		if (info.pos < info.length)

			*info.buffer = '\0';

		else

			buf[info.length - 1] = '\0';

		printf("%s", buf);

		spi_period(starget) = tinfo->curr.period;

		spi_width(starget) = tinfo->curr.width;

		spi_offset(starget) = tinfo->curr.offset;

		spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_DT_REQ;

		spi_qas(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_QAS_REQ;

		spi_iu(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ;

		spi_display_xfer_agreement(starget);

		break;

	}

        case AC_SENT_BDR:
@@ -2038,7 +1940,7 @@ ahc_done(struct ahc_softc *ahc, struct scb *scb) 
			ahc_set_transaction_status(scb, CAM_REQ_CMP);

		}

	} else if (ahc_get_transaction_status(scb) == CAM_SCSI_STATUS_ERROR) {

		ahc_linux_handle_scsi_status(ahc, dev, scb);

		ahc_linux_handle_scsi_status(ahc, cmd->device, scb);

	}



	if (dev->openings == 1
@@ -2077,14 +1979,15 @@ ahc_done(struct ahc_softc *ahc, struct scb *scb) 


static void

ahc_linux_handle_scsi_status(struct ahc_softc *ahc,

			     struct ahc_linux_device *dev, struct scb *scb)

			     struct scsi_device *sdev, struct scb *scb)

{

	struct	ahc_devinfo devinfo;

	struct ahc_linux_device *dev = scsi_transport_device_data(sdev);



	ahc_compile_devinfo(&devinfo,

			    ahc->our_id,

			    dev->target->target, dev->lun,

			    dev->target->channel == 0 ? 'A' : 'B',

			    sdev->sdev_target->id, sdev->lun,

			    sdev->sdev_target->channel == 0 ? 'A' : 'B',

			    ROLE_INITIATOR);

	

	/*
@@ -2368,8 +2271,7 @@ ahc_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag) 
	 * at all, and the system wanted us to just abort the

	 * command, return success.

	 */

	dev = ahc_linux_get_device(ahc, cmd->device->channel, cmd->device->id,

				   cmd->device->lun);

	dev = scsi_transport_device_data(cmd->device);



	if (dev == NULL) {

		/*
@@ -2626,18 +2528,6 @@ ahc_platform_dump_card_state(struct ahc_softc *ahc) 


static void ahc_linux_exit(void);



static void ahc_linux_get_width(struct scsi_target *starget)

{

	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

	struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

	struct ahc_tmode_tstate *tstate;

	struct ahc_initiator_tinfo *tinfo 

		= ahc_fetch_transinfo(ahc,

				      starget->channel + 'A',

				      shost->this_id, starget->id, &tstate);

	spi_width(starget) = tinfo->curr.width;

}



static void ahc_linux_set_width(struct scsi_target *starget, int width)

{

	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
@@ -2652,18 +2542,6 @@ static void ahc_linux_set_width(struct scsi_target *starget, int width) 
	ahc_unlock(ahc, &flags);

}



static void ahc_linux_get_period(struct scsi_target *starget)

{

	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

	struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

	struct ahc_tmode_tstate *tstate;

	struct ahc_initiator_tinfo *tinfo 

		= ahc_fetch_transinfo(ahc,

				      starget->channel + 'A',

				      shost->this_id, starget->id, &tstate);

	spi_period(starget) = tinfo->curr.period;

}



static void ahc_linux_set_period(struct scsi_target *starget, int period)

{

	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
@@ -2692,7 +2570,6 @@ static void ahc_linux_set_period(struct scsi_target *starget, int period) 


	/* all PPR requests apart from QAS require wide transfers */

	if (ppr_options & ~MSG_EXT_PPR_QAS_REQ) {

		ahc_linux_get_width(starget);

		if (spi_width(starget) == 0)

			ppr_options &= MSG_EXT_PPR_QAS_REQ;

	}
@@ -2704,18 +2581,6 @@ static void ahc_linux_set_period(struct scsi_target *starget, int period) 
	ahc_unlock(ahc, &flags);

}



static void ahc_linux_get_offset(struct scsi_target *starget)

{

	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

	struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

	struct ahc_tmode_tstate *tstate;

	struct ahc_initiator_tinfo *tinfo 

		= ahc_fetch_transinfo(ahc,

				      starget->channel + 'A',

				      shost->this_id, starget->id, &tstate);

	spi_offset(starget) = tinfo->curr.offset;

}



static void ahc_linux_set_offset(struct scsi_target *starget, int offset)

{

	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
@@ -2744,18 +2609,6 @@ static void ahc_linux_set_offset(struct scsi_target *starget, int offset) 
	ahc_unlock(ahc, &flags);

}



static void ahc_linux_get_dt(struct scsi_target *starget)

{

	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

	struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

	struct ahc_tmode_tstate *tstate;

	struct ahc_initiator_tinfo *tinfo 

		= ahc_fetch_transinfo(ahc,

				      starget->channel + 'A',

				      shost->this_id, starget->id, &tstate);

	spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_DT_REQ;

}



static void ahc_linux_set_dt(struct scsi_target *starget, int dt)

{

	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
@@ -2787,18 +2640,6 @@ static void ahc_linux_set_dt(struct scsi_target *starget, int dt) 
	ahc_unlock(ahc, &flags);

}



static void ahc_linux_get_qas(struct scsi_target *starget)

{

	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

	struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

	struct ahc_tmode_tstate *tstate;

	struct ahc_initiator_tinfo *tinfo 

		= ahc_fetch_transinfo(ahc,

				      starget->channel + 'A',

				      shost->this_id, starget->id, &tstate);

	spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_QAS_REQ;

}



static void ahc_linux_set_qas(struct scsi_target *starget, int qas)

{

	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
@@ -2827,18 +2668,6 @@ static void ahc_linux_set_qas(struct scsi_target *starget, int qas) 
	ahc_unlock(ahc, &flags);

}



static void ahc_linux_get_iu(struct scsi_target *starget)

{

	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

	struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

	struct ahc_tmode_tstate *tstate;

	struct ahc_initiator_tinfo *tinfo 

		= ahc_fetch_transinfo(ahc,

				      starget->channel + 'A',

				      shost->this_id, starget->id, &tstate);

	spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ;

}



static void ahc_linux_set_iu(struct scsi_target *starget, int iu)

{

	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
@@ -2868,22 +2697,16 @@ static void ahc_linux_set_iu(struct scsi_target *starget, int iu) 
}



static struct spi_function_template ahc_linux_transport_functions = {

	.get_offset	= ahc_linux_get_offset,

	.set_offset	= ahc_linux_set_offset,

	.show_offset	= 1,

	.get_period	= ahc_linux_get_period,

	.set_period	= ahc_linux_set_period,

	.show_period	= 1,

	.get_width	= ahc_linux_get_width,

	.set_width	= ahc_linux_set_width,

	.show_width	= 1,

	.get_dt		= ahc_linux_get_dt,

	.set_dt		= ahc_linux_set_dt,

	.show_dt	= 1,

	.get_iu		= ahc_linux_get_iu,

	.set_iu		= ahc_linux_set_iu,

	.show_iu	= 1,

	.get_qas	= ahc_linux_get_qas,

	.set_qas	= ahc_linux_set_qas,

	.show_qas	= 1,

};
@@ -2896,6 +2719,10 @@ ahc_linux_init(void) 
	ahc_linux_transport_template = spi_attach_transport(&ahc_linux_transport_functions);

	if (!ahc_linux_transport_template)

		return -ENODEV;

	scsi_transport_reserve_target(ahc_linux_transport_template,

				      sizeof(struct ahc_linux_target));

	scsi_transport_reserve_device(ahc_linux_transport_template,

				      sizeof(struct ahc_linux_device));

	if (ahc_linux_detect(&aic7xxx_driver_template))

		return 0;

	spi_release_transport(ahc_linux_transport_template);

drivers/scsi/aic7xxx/aic7xxx_osm.h

+4 −11
Original line number Diff line number Diff line
@@ -79,6 +79,8 @@ 
#include <scsi/scsi_device.h>

#include <scsi/scsi_host.h>

#include <scsi/scsi_tcq.h>

#include <scsi/scsi_transport.h>

#include <scsi/scsi_transport_spi.h>



/* Core SCSI definitions */

#define AIC_LIB_PREFIX ahc
@@ -330,8 +332,6 @@ typedef enum { 


struct ahc_linux_target;

struct ahc_linux_device {

	TAILQ_ENTRY(ahc_linux_device) links;



	/*

	 * The number of transactions currently

	 * queued to the device.
@@ -401,17 +401,10 @@ struct ahc_linux_device { 
	 */

	u_int			commands_since_idle_or_otag;

#define AHC_OTAG_THRESH	500



	int			lun;

	struct scsi_device       *scsi_device;

	struct			ahc_linux_target *target;

};



struct ahc_linux_target {

	struct ahc_linux_device	 *devices[AHC_NUM_LUNS];

	int			  channel;

	int			  target;

	int			  refcount;

	struct scsi_device	 *sdev[AHC_NUM_LUNS];

	struct ahc_transinfo	  last_tinfo;

	struct ahc_softc	 *ahc;

};
@@ -445,7 +438,7 @@ struct ahc_platform_data { 
	/*

	 * Fields accessed from interrupt context.

	 */

	struct ahc_linux_target *targets[AHC_NUM_TARGETS]; 

	struct scsi_target *starget[AHC_NUM_TARGETS]; 



	spinlock_t		 spin_lock;

	u_int			 qfrozen;

drivers/scsi/aic7xxx/aic7xxx_proc.c

+13 −8

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE