1 files changed, 16 insertions, 56 deletions

diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.c b/drivers/scsi/aic7xxx/aic7xxx_osm.c
index 43ab753d2739..660f26e23a38 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.c
@@ -328,7 +328,7 @@ static uint32_t aic7xxx_seltime;
  * force all outstanding transactions to be serviced prior to a new
  * transaction.
  */
-uint32_t aic7xxx_periodic_otag;
+static uint32_t aic7xxx_periodic_otag;
 
 /*
  * Module information and settable options.
@@ -512,7 +512,6 @@ ahc_linux_target_alloc(struct scsi_target *starget)
         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;
@@ -533,7 +532,6 @@ ahc_linux_target_alloc(struct scsi_target *starget)
         BUG_ON(*ahc_targp != NULL);
 
         *ahc_targp = starget;
-        memset(targ, 0, sizeof(*targ));
 
         if (sc) {
                 int maxsync = AHC_SYNCRATE_DT;
@@ -594,14 +592,11 @@ 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));
 
@@ -618,8 +613,6 @@ ahc_linux_slave_alloc(struct scsi_device *sdev)
          */
         dev->maxtags = 0;
         
-        targ->sdev[sdev->lun] = sdev;
-
         spi_period(starget) = 0;
 
         return 0;
@@ -644,22 +637,6 @@ ahc_linux_slave_configure(struct scsi_device *sdev)
         return 0;
 }
 
-static void
-ahc_linux_slave_destroy(struct scsi_device *sdev)
-{
-        struct  ahc_softc *ahc;
-        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 **)sdev->host->hostdata);
-        if (bootverbose)
-                printf("%s: Slave Destroy %d\n", ahc_name(ahc), sdev->id);
-
-        BUG_ON(dev->active);
-
-        targ->sdev[sdev->lun] = NULL;
-}
-
 #if defined(__i386__)
 /*
  * Return the disk geometry for the given SCSI device.
@@ -777,11 +754,11 @@ struct scsi_host_template aic7xxx_driver_template = {
 #endif
         .can_queue              = AHC_MAX_QUEUE,
         .this_id                = -1,
+        .max_sectors            = 8192,
         .cmd_per_lun            = 2,
         .use_clustering         = ENABLE_CLUSTERING,
         .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,
 };
@@ -1203,21 +1180,13 @@ void
 ahc_platform_free(struct ahc_softc *ahc)
 {
         struct scsi_target *starget;
-        int i, j;
+        int i;
 
         if (ahc->platform_data != NULL) {
                 /* destroy all of the device and target objects */
                 for (i = 0; i < AHC_NUM_TARGETS; i++) {
                         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->sdev[j] == NULL)
-                                                continue;
-                                        targ->sdev[j] = NULL;
-                                }
                                 ahc->platform_data->starget[i] = NULL;
                         }
                 }
@@ -1251,24 +1220,13 @@ ahc_platform_freeze_devq(struct ahc_softc *ahc, struct scb *scb)
 }
 
 void
-ahc_platform_set_tags(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,
-                      ahc_queue_alg alg)
+ahc_platform_set_tags(struct ahc_softc *ahc, struct scsi_device *sdev,
+                      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;
 
-        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);
@@ -1401,11 +1359,15 @@ ahc_linux_device_queue_depth(struct scsi_device *sdev)
         tags = ahc_linux_user_tagdepth(ahc, &devinfo);
         if (tags != 0 && sdev->tagged_supported != 0) {
 
-                ahc_set_tags(ahc, &devinfo, AHC_QUEUE_TAGGED);
+                ahc_platform_set_tags(ahc, sdev, &devinfo, AHC_QUEUE_TAGGED);
+                ahc_send_async(ahc, devinfo.channel, devinfo.target,
+                               devinfo.lun, AC_TRANSFER_NEG);
                 ahc_print_devinfo(ahc, &devinfo);
                 printf("Tagged Queuing enabled.  Depth %d\n", tags);
         } else {
-                ahc_set_tags(ahc, &devinfo, AHC_QUEUE_NONE);
+                ahc_platform_set_tags(ahc, sdev, &devinfo, AHC_QUEUE_NONE);
+                ahc_send_async(ahc, devinfo.channel, devinfo.target,
+                               devinfo.lun, AC_TRANSFER_NEG);
         }
 }
 
@@ -1629,7 +1591,7 @@ ahc_platform_flushwork(struct ahc_softc *ahc)
 
 void
 ahc_send_async(struct ahc_softc *ahc, char channel,
-               u_int target, u_int lun, ac_code code, void *arg)
+               u_int target, u_int lun, ac_code code)
 {
         switch (code) {
         case AC_TRANSFER_NEG:
@@ -1875,9 +1837,9 @@ ahc_linux_handle_scsi_status(struct ahc_softc *ahc,
                 if (scb->flags & SCB_SENSE) {
                         u_int sense_size;
 
-                        sense_size = MIN(sizeof(struct scsi_sense_data)
+                        sense_size = min(sizeof(struct scsi_sense_data)
                                        - ahc_get_sense_residual(scb),
-                                         sizeof(cmd->sense_buffer));
+                                         (u_long)sizeof(cmd->sense_buffer));
                         memcpy(cmd->sense_buffer,
                                ahc_get_sense_buf(ahc, scb), sense_size);
                         if (sense_size < sizeof(cmd->sense_buffer))
@@ -1946,7 +1908,7 @@ ahc_linux_handle_scsi_status(struct ahc_softc *ahc,
                         }
                         ahc_set_transaction_status(scb, CAM_REQUEUE_REQ);
                         ahc_set_scsi_status(scb, SCSI_STATUS_OK);
-                        ahc_platform_set_tags(ahc, &devinfo,
+                        ahc_platform_set_tags(ahc, sdev, &devinfo,
                                      (dev->flags & AHC_DEV_Q_BASIC)
                                    ? AHC_QUEUE_BASIC : AHC_QUEUE_TAGGED);
                         break;
@@ -1957,7 +1919,7 @@ ahc_linux_handle_scsi_status(struct ahc_softc *ahc,
                  */
                 dev->openings = 1;
                 ahc_set_scsi_status(scb, SCSI_STATUS_BUSY);
-                ahc_platform_set_tags(ahc, &devinfo,
+                ahc_platform_set_tags(ahc, sdev, &devinfo,
                              (dev->flags & AHC_DEV_Q_BASIC)
                            ? AHC_QUEUE_BASIC : AHC_QUEUE_TAGGED);
                 break;
@@ -2599,8 +2561,6 @@ ahc_linux_init(void)
         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));