[PATCH] remove old scsi data direction macros
author <hch@lst.de> <>
Sun, 17 Apr 2005 20:26:13 +0000 (15:26 -0500)
committerJames Bottomley <jejb@titanic>
Mon, 18 Apr 2005 18:49:58 +0000 (13:49 -0500)
these have been wrappers for the generic dma direction bits since 2.5.x.
This patch converts the few remaining drivers and removes the macros.

Arjan noticed there's some hunk in here that shouldn't.  Updated patch
below:

Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
16 files changed:
Documentation/DMA-mapping.txt
Documentation/scsi/scsi_mid_low_api.txt
drivers/scsi/aic7xxx/aic79xx_osm.c
drivers/scsi/aic7xxx/aic7xxx_osm.c
drivers/scsi/aic7xxx/cam.h
drivers/scsi/aic7xxx_old.c
drivers/scsi/arm/fas216.c
drivers/scsi/cpqfcTSinit.c
drivers/scsi/cpqfcTSworker.c
drivers/scsi/ips.c
drivers/scsi/libata-scsi.c
drivers/scsi/pci2000.c
drivers/scsi/qlogicfc.c
drivers/scsi/qlogicisp.c
drivers/scsi/scsi.h
drivers/scsi/sg.c

index f4ac37f157ea905e06e132c6ee5a1587cb05cbae..684557474c156210114243f89b2f79667bdb179e 100644 (file)
@@ -443,15 +443,9 @@ Only streaming mappings specify a direction, consistent mappings
 implicitly have a direction attribute setting of
 PCI_DMA_BIDIRECTIONAL.
 
-The SCSI subsystem provides mechanisms for you to easily obtain
-the direction to use, in the SCSI command:
-
-       scsi_to_pci_dma_dir(SCSI_DIRECTION)
-
-Where SCSI_DIRECTION is obtained from the 'sc_data_direction'
-member of the SCSI command your driver is working on.  The
-mentioned interface above returns a value suitable for passing
-into the streaming DMA mapping interfaces below.
+The SCSI subsystem tells you the direction to use in the
+'sc_data_direction' member of the SCSI command your driver is
+working on.
 
 For Networking drivers, it's a rather simple affair.  For transmit
 packets, map/unmap them with the PCI_DMA_TODEVICE direction
index 1f24129a3099071dd253d5a341b07ab4c944cc96..e41703d7d24d3f0579acccdc0b28a56da2621ff1 100644 (file)
@@ -389,8 +389,6 @@ Summary:
    scsi_remove_host - detach and remove all SCSI devices owned by host
    scsi_report_bus_reset - report scsi _bus_ reset observed
    scsi_set_device - place device reference in host structure
-   scsi_to_pci_dma_dir - convert SCSI subsystem direction flag to PCI
-   scsi_to_sbus_dma_dir - convert SCSI subsystem direction flag to SBUS
    scsi_track_queue_full - track successive QUEUE_FULL events 
    scsi_unblock_requests - allow further commands to be queued to given host
    scsi_unregister - [calls scsi_host_put()]
@@ -756,48 +754,6 @@ void scsi_report_bus_reset(struct Scsi_Host * shost, int channel)
 void scsi_set_device(struct Scsi_Host * shost, struct device * dev)
 
 
-/**
- * scsi_to_pci_dma_dir - convert SCSI subsystem direction flag to PCI
- * @scsi_data_direction: SCSI subsystem direction flag
- *
- *      Returns DMA_TO_DEVICE given SCSI_DATA_WRITE,
- *              DMA_FROM_DEVICE given SCSI_DATA_READ
- *              DMA_BIDIRECTIONAL given SCSI_DATA_UNKNOWN
- *              else returns DMA_NONE
- *
- *      Might block: no
- *
- *      Notes: The SCSI subsystem now uses the same values for these
- *      constants as the PCI subsystem so this function is a nop.
- *      The recommendation is not to use this conversion function anymore
- *      (in the 2.6 kernel series) as it is not needed.
- *
- *      Defined in: drivers/scsi/scsi.h .
- **/
-int scsi_to_pci_dma_dir(unsigned char scsi_data_direction)
-
-
-/**
- * scsi_to_sbus_dma_dir - convert SCSI subsystem direction flag to SBUS
- * @scsi_data_direction: SCSI subsystem direction flag
- *
- *      Returns DMA_TO_DEVICE given SCSI_DATA_WRITE,
- *              FROM_DEVICE given SCSI_DATA_READ
- *              DMA_BIDIRECTIONAL given SCSI_DATA_UNKNOWN
- *              else returns DMA_NONE
- *
- *      Notes: The SCSI subsystem now uses the same values for these
- *      constants as the SBUS subsystem so this function is a nop.
- *      The recommendation is not to use this conversion function anymore
- *      (in the 2.6 kernel series) as it is not needed.
- *
- *      Might block: no
- *
- *      Defined in: drivers/scsi/scsi.h .
- **/
-int scsi_to_sbus_dma_dir(unsigned char scsi_data_direction)
-
-
 /**
  * scsi_track_queue_full - track successive QUEUE_FULL events on given
  *                      device to determine if and when there is a need
index fb2877c303f0f1b055ccbc35ad86813a69eecd59..550c9921691ad8df96602bf833d2c28ba7eba411 100644 (file)
@@ -687,7 +687,7 @@ ahd_linux_unmap_scb(struct ahd_softc *ahd, struct scb *scb)
        int direction;
 
        cmd = scb->io_ctx;
-       direction = scsi_to_pci_dma_dir(cmd->sc_data_direction);
+       direction = cmd->sc_data_direction;
        ahd_sync_sglist(ahd, scb, BUS_DMASYNC_POSTWRITE);
        if (cmd->use_sg != 0) {
                struct scatterlist *sg;
@@ -3338,7 +3338,7 @@ ahd_linux_dv_inq(struct ahd_softc *ahd, struct scsi_cmnd *cmd,
        }
 
        ahd_linux_dv_fill_cmd(ahd, cmd, devinfo);
-       cmd->sc_data_direction = SCSI_DATA_READ;
+       cmd->sc_data_direction = DMA_FROM_DEVICE;
        cmd->cmd_len = 6;
        cmd->cmnd[0] = INQUIRY;
        cmd->cmnd[4] = request_length;
@@ -3363,7 +3363,7 @@ ahd_linux_dv_tur(struct ahd_softc *ahd, struct scsi_cmnd *cmd,
 #endif
        /* Do a TUR to clear out any non-fatal transitional state */
        ahd_linux_dv_fill_cmd(ahd, cmd, devinfo);
-       cmd->sc_data_direction = SCSI_DATA_NONE;
+       cmd->sc_data_direction = DMA_NONE;
        cmd->cmd_len = 6;
        cmd->cmnd[0] = TEST_UNIT_READY;
 }
@@ -3385,7 +3385,7 @@ ahd_linux_dv_rebd(struct ahd_softc *ahd, struct scsi_cmnd *cmd,
                free(targ->dv_buffer, M_DEVBUF);
        targ->dv_buffer = malloc(AHD_REBD_LEN, M_DEVBUF, M_WAITOK);
        ahd_linux_dv_fill_cmd(ahd, cmd, devinfo);
-       cmd->sc_data_direction = SCSI_DATA_READ;
+       cmd->sc_data_direction = DMA_FROM_DEVICE;
        cmd->cmd_len = 10;
        cmd->cmnd[0] = READ_BUFFER;
        cmd->cmnd[1] = 0x0b;
@@ -3407,7 +3407,7 @@ ahd_linux_dv_web(struct ahd_softc *ahd, struct scsi_cmnd *cmd,
        }
 #endif
        ahd_linux_dv_fill_cmd(ahd, cmd, devinfo);
-       cmd->sc_data_direction = SCSI_DATA_WRITE;
+       cmd->sc_data_direction = DMA_TO_DEVICE;
        cmd->cmd_len = 10;
        cmd->cmnd[0] = WRITE_BUFFER;
        cmd->cmnd[1] = 0x0a;
@@ -3429,7 +3429,7 @@ ahd_linux_dv_reb(struct ahd_softc *ahd, struct scsi_cmnd *cmd,
        }
 #endif
        ahd_linux_dv_fill_cmd(ahd, cmd, devinfo);
-       cmd->sc_data_direction = SCSI_DATA_READ;
+       cmd->sc_data_direction = DMA_FROM_DEVICE;
        cmd->cmd_len = 10;
        cmd->cmnd[0] = READ_BUFFER;
        cmd->cmnd[1] = 0x0a;
@@ -3455,7 +3455,7 @@ ahd_linux_dv_su(struct ahd_softc *ahd, struct scsi_cmnd *cmd,
        }
 #endif
        ahd_linux_dv_fill_cmd(ahd, cmd, devinfo);
-       cmd->sc_data_direction = SCSI_DATA_NONE;
+       cmd->sc_data_direction = DMA_NONE;
        cmd->cmd_len = 6;
        cmd->cmnd[0] = START_STOP_UNIT;
        cmd->cmnd[4] = le | SSS_START;
@@ -4018,7 +4018,7 @@ ahd_linux_run_device_queue(struct ahd_softc *ahd, struct ahd_linux_device *dev)
                        int      dir;
 
                        cur_seg = (struct scatterlist *)cmd->request_buffer;
-                       dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
+                       dir = cmd->sc_data_direction;
                        nseg = pci_map_sg(ahd->dev_softc, cur_seg,
                                          cmd->use_sg, dir);
                        scb->platform_data->xfer_len = 0;
@@ -4038,7 +4038,7 @@ ahd_linux_run_device_queue(struct ahd_softc *ahd, struct ahd_linux_device *dev)
                        int dir;
 
                        sg = scb->sg_list;
-                       dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
+                       dir = cmd->sc_data_direction;
                        addr = pci_map_single(ahd->dev_softc,
                                              cmd->request_buffer,
                                              cmd->request_bufflen, dir);
index 031c6aaa5ca571456d1d4f8f3e0eabad56ef725e..35d6de5a4c9da99a8d33a3f0ddea9c9852948410 100644 (file)
@@ -693,12 +693,12 @@ ahc_linux_unmap_scb(struct ahc_softc *ahc, struct scb *scb)
 
                sg = (struct scatterlist *)cmd->request_buffer;
                pci_unmap_sg(ahc->dev_softc, sg, cmd->use_sg,
-                            scsi_to_pci_dma_dir(cmd->sc_data_direction));
+                            cmd->sc_data_direction);
        } else if (cmd->request_bufflen != 0) {
                pci_unmap_single(ahc->dev_softc,
                                 scb->platform_data->buf_busaddr,
                                 cmd->request_bufflen,
-                                scsi_to_pci_dma_dir(cmd->sc_data_direction));
+                                cmd->sc_data_direction);
        }
 }
 
@@ -3007,7 +3007,7 @@ ahc_linux_dv_inq(struct ahc_softc *ahc, struct scsi_cmnd *cmd,
        }
 
        ahc_linux_dv_fill_cmd(ahc, cmd, devinfo);
-       cmd->sc_data_direction = SCSI_DATA_READ;
+       cmd->sc_data_direction = DMA_FROM_DEVICE;
        cmd->cmd_len = 6;
        cmd->cmnd[0] = INQUIRY;
        cmd->cmnd[4] = request_length;
@@ -3032,7 +3032,7 @@ ahc_linux_dv_tur(struct ahc_softc *ahc, struct scsi_cmnd *cmd,
 #endif
        /* Do a TUR to clear out any non-fatal transitional state */
        ahc_linux_dv_fill_cmd(ahc, cmd, devinfo);
-       cmd->sc_data_direction = SCSI_DATA_NONE;
+       cmd->sc_data_direction = DMA_NONE;
        cmd->cmd_len = 6;
        cmd->cmnd[0] = TEST_UNIT_READY;
 }
@@ -3054,7 +3054,7 @@ ahc_linux_dv_rebd(struct ahc_softc *ahc, struct scsi_cmnd *cmd,
                free(targ->dv_buffer, M_DEVBUF);
        targ->dv_buffer = malloc(AHC_REBD_LEN, M_DEVBUF, M_WAITOK);
        ahc_linux_dv_fill_cmd(ahc, cmd, devinfo);
-       cmd->sc_data_direction = SCSI_DATA_READ;
+       cmd->sc_data_direction = DMA_FROM_DEVICE;
        cmd->cmd_len = 10;
        cmd->cmnd[0] = READ_BUFFER;
        cmd->cmnd[1] = 0x0b;
@@ -3076,7 +3076,7 @@ ahc_linux_dv_web(struct ahc_softc *ahc, struct scsi_cmnd *cmd,
        }
 #endif
        ahc_linux_dv_fill_cmd(ahc, cmd, devinfo);
-       cmd->sc_data_direction = SCSI_DATA_WRITE;
+       cmd->sc_data_direction = DMA_TO_DEVICE;
        cmd->cmd_len = 10;
        cmd->cmnd[0] = WRITE_BUFFER;
        cmd->cmnd[1] = 0x0a;
@@ -3098,7 +3098,7 @@ ahc_linux_dv_reb(struct ahc_softc *ahc, struct scsi_cmnd *cmd,
        }
 #endif
        ahc_linux_dv_fill_cmd(ahc, cmd, devinfo);
-       cmd->sc_data_direction = SCSI_DATA_READ;
+       cmd->sc_data_direction = DMA_FROM_DEVICE;
        cmd->cmd_len = 10;
        cmd->cmnd[0] = READ_BUFFER;
        cmd->cmnd[1] = 0x0a;
@@ -3124,7 +3124,7 @@ ahc_linux_dv_su(struct ahc_softc *ahc, struct scsi_cmnd *cmd,
        }
 #endif
        ahc_linux_dv_fill_cmd(ahc, cmd, devinfo);
-       cmd->sc_data_direction = SCSI_DATA_NONE;
+       cmd->sc_data_direction = DMA_NONE;
        cmd->cmd_len = 6;
        cmd->cmnd[0] = START_STOP_UNIT;
        cmd->cmnd[4] = le | SSS_START;
@@ -3659,7 +3659,7 @@ ahc_linux_run_device_queue(struct ahc_softc *ahc, struct ahc_linux_device *dev)
 
                        cur_seg = (struct scatterlist *)cmd->request_buffer;
                        nseg = pci_map_sg(ahc->dev_softc, cur_seg, cmd->use_sg,
-                           scsi_to_pci_dma_dir(cmd->sc_data_direction));
+                           cmd->sc_data_direction);
                        end_seg = cur_seg + nseg;
                        /* Copy the segments into the SG list. */
                        sg = scb->sg_list;
@@ -3703,7 +3703,7 @@ ahc_linux_run_device_queue(struct ahc_softc *ahc, struct ahc_linux_device *dev)
                        addr = pci_map_single(ahc->dev_softc,
                               cmd->request_buffer,
                               cmd->request_bufflen,
-                              scsi_to_pci_dma_dir(cmd->sc_data_direction));
+                              cmd->sc_data_direction);
                        scb->platform_data->buf_busaddr = addr;
                        scb->sg_count = ahc_linux_map_seg(ahc, scb,
                                                          sg, addr,
index d40ba0760c765a28503df3e566e3b0154b25b925..26f17e3fc45c6113b99e138dde03138502e85b4d 100644 (file)
@@ -103,9 +103,9 @@ typedef enum {
 } ac_code;
 
 typedef enum {
-       CAM_DIR_IN              = SCSI_DATA_READ,
-       CAM_DIR_OUT             = SCSI_DATA_WRITE,
-       CAM_DIR_NONE            = SCSI_DATA_NONE
+       CAM_DIR_IN              = DMA_FROM_DEVICE,
+       CAM_DIR_OUT             = DMA_TO_DEVICE,
+       CAM_DIR_NONE            = DMA_NONE,
 } ccb_flags;
 
 #endif /* _AIC7XXX_CAM_H */
index a6e7bb0d53f4a7becb3b6bbbb897af5ab8e20f79..9e9d0c40187e50ed1af8e5199514611e0903f26f 100644 (file)
@@ -2700,12 +2700,12 @@ aic7xxx_done(struct aic7xxx_host *p, struct aic7xxx_scb *scb)
     struct scatterlist *sg;
 
     sg = (struct scatterlist *)cmd->request_buffer;
-    pci_unmap_sg(p->pdev, sg, cmd->use_sg, scsi_to_pci_dma_dir(cmd->sc_data_direction));
+    pci_unmap_sg(p->pdev, sg, cmd->use_sg, cmd->sc_data_direction);
   }
   else if (cmd->request_bufflen)
     pci_unmap_single(p->pdev, aic7xxx_mapping(cmd),
                     cmd->request_bufflen,
-                     scsi_to_pci_dma_dir(cmd->sc_data_direction));
+                     cmd->sc_data_direction);
   if (scb->flags & SCB_SENSE)
   {
     pci_unmap_single(p->pdev,
@@ -10228,7 +10228,7 @@ aic7xxx_buildscb(struct aic7xxx_host *p, Scsi_Cmnd *cmd,
 
     sg = (struct scatterlist *)cmd->request_buffer;
     scb->sg_length = 0;
-    use_sg = pci_map_sg(p->pdev, sg, cmd->use_sg, scsi_to_pci_dma_dir(cmd->sc_data_direction));
+    use_sg = pci_map_sg(p->pdev, sg, cmd->use_sg, cmd->sc_data_direction);
     /*
      * Copy the segments into the SG array.  NOTE!!! - We used to
      * have the first entry both in the data_pointer area and the first
@@ -10256,7 +10256,7 @@ aic7xxx_buildscb(struct aic7xxx_host *p, Scsi_Cmnd *cmd,
     {
       unsigned int address = pci_map_single(p->pdev, cmd->request_buffer,
                                            cmd->request_bufflen,
-                                            scsi_to_pci_dma_dir(cmd->sc_data_direction));
+                                            cmd->sc_data_direction);
       aic7xxx_mapping(cmd) = address;
       scb->sg_list[0].address = cpu_to_le32(address);
       scb->sg_list[0].length = cpu_to_le32(cmd->request_bufflen);
index 0a172c1e9f7e6934beb7ddeb316d60919c4dcc5e..3838f88e1fe01ee38166b9bba6093520d6cf0728 100644 (file)
@@ -2117,7 +2117,7 @@ request_sense:
        SCpnt->SCp.Message = 0;
        SCpnt->SCp.Status = 0;
        SCpnt->request_bufflen = sizeof(SCpnt->sense_buffer);
-       SCpnt->sc_data_direction = SCSI_DATA_READ;
+       SCpnt->sc_data_direction = DMA_FROM_DEVICE;
        SCpnt->use_sg = 0;
        SCpnt->tag = 0;
        SCpnt->host_scribble = (void *)fas216_rq_sns_done;
index 2eeb493f5a2bf75d438c1301e28edd3fa7d5725b..5674ada6d5c249ca58fb1d39ffba9355171d1b18 100644 (file)
@@ -642,12 +642,12 @@ int cpqfcTS_ioctl( struct scsi_device *ScsiDev, int Cmnd, void *arg)
                                return( -EFAULT);
                        }
                }
-               ScsiPassThruReq->sr_data_direction = SCSI_DATA_WRITE; 
+               ScsiPassThruReq->sr_data_direction = DMA_TO_DEVICE; 
        } else if (vendor_cmd->rw_flag == VENDOR_READ_OPCODE) {
-               ScsiPassThruReq->sr_data_direction = SCSI_DATA_READ; 
+               ScsiPassThruReq->sr_data_direction = DMA_FROM_DEVICE;
        } else
                // maybe this means a bug in the user app
-               ScsiPassThruReq->sr_data_direction = SCSI_DATA_NONE;
+               ScsiPassThruReq->sr_data_direction = DMA_BIDIRECTIONAL;
            
        ScsiPassThruReq->sr_cmd_len = 0; // set correctly by scsi_do_req()
        ScsiPassThruReq->sr_sense_buffer[0] = 0;
index a5fd7427e9dafbc3f50a3d4b0234448fa2403d8f..d822ddcc52b2cad83260fa8eed310542ec09933c 100644 (file)
@@ -5129,7 +5129,7 @@ cpqfc_undo_SEST_mappings(struct pci_dev *pcidev,
        for (i=*sgPages_head; i != NULL ;i = next)
        {
                pci_unmap_single(pcidev, i->busaddr, i->maplen, 
-                       scsi_to_pci_dma_dir(PCI_DMA_TODEVICE));
+                       PCI_DMA_TODEVICE);
                i->busaddr = (dma_addr_t) NULL; 
                i->maplen = 0L; 
                next = i->next;
@@ -5195,7 +5195,7 @@ static ULONG build_SEST_sgList(
                        contigaddr = ulBuff = pci_map_single(pcidev, 
                                Cmnd->request_buffer, 
                                Cmnd->request_bufflen,
-                               scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                               Cmnd->sc_data_direction);
                        // printk("ms %p ", ulBuff);
                }
                else {
@@ -5224,7 +5224,7 @@ static ULONG build_SEST_sgList(
                unsigned long btg;
                contigaddr = pci_map_single(pcidev, Cmnd->request_buffer, 
                                Cmnd->request_bufflen,
-                               scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                               Cmnd->sc_data_direction);
 
                // printk("contigaddr = %p, len = %d\n", 
                //      (void *) contigaddr, bytes_to_go);
@@ -5247,7 +5247,7 @@ static ULONG build_SEST_sgList(
  
        sgl = (struct scatterlist*)Cmnd->request_buffer;  
        sg_count = pci_map_sg(pcidev, sgl, Cmnd->use_sg, 
-               scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+               Cmnd->sc_data_direction);
        if( sg_count <= 3 ) {
 
        // we need to be careful here that no individual mapping
@@ -5400,7 +5400,7 @@ static ULONG build_SEST_sgList(
 
                cpqfc_undo_SEST_mappings(pcidev, contigaddr, 
                        Cmnd->request_bufflen,
-                       scsi_to_pci_dma_dir(Cmnd->sc_data_direction),
+                       Cmnd->sc_data_direction,
                        sgl, Cmnd->use_sg, sgPages_head, AllocatedPages+1);
 
                // FIXME: testing shows that if we get here, 
@@ -5946,7 +5946,7 @@ cpqfc_pci_unmap_extended_sg(struct pci_dev *pcidev,
        // for each extended scatter gather region needing unmapping... 
        for (i=fcChip->SEST->sgPages[x_ID] ; i != NULL ; i = i->next)
                pci_unmap_single(pcidev, i->busaddr, i->maplen,
-                       scsi_to_pci_dma_dir(PCI_DMA_TODEVICE));
+                       PCI_DMA_TODEVICE);
 }
 
 // Called also from cpqfcTScontrol.o, so can't be static
@@ -5960,14 +5960,14 @@ cpqfc_pci_unmap(struct pci_dev *pcidev,
        if (cmd->use_sg) {      // Used scatter gather list for data buffer?
                cpqfc_pci_unmap_extended_sg(pcidev, fcChip, x_ID);
                pci_unmap_sg(pcidev, cmd->buffer, cmd->use_sg,
-                       scsi_to_pci_dma_dir(cmd->sc_data_direction));
+                       cmd->sc_data_direction);
                // printk("umsg %d\n", cmd->use_sg);
        }
        else if (cmd->request_bufflen) {
                // printk("ums %p ", fcChip->SEST->u[ x_ID ].IWE.GAddr1);
                pci_unmap_single(pcidev, fcChip->SEST->u[ x_ID ].IWE.GAddr1,
                        cmd->request_bufflen,
-                       scsi_to_pci_dma_dir(cmd->sc_data_direction));
+                       cmd->sc_data_direction);
        }        
 }
 
index 47c263e5cd39d355e15b061d6564cd131b47c249..fbc2cb6667a1a349e81aa559311e472ad7a94f91 100644 (file)
@@ -231,9 +231,9 @@ module_param(ips, charp, 0);
 #endif
 
 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
-                         SCSI_DATA_NONE == scb->scsi_cmd->sc_data_direction) ? \
+                         DMA_NONE == scb->scsi_cmd->sc_data_direction) ? \
                          PCI_DMA_BIDIRECTIONAL : \
-                         scsi_to_pci_dma_dir(scb->scsi_cmd->sc_data_direction))
+                         scb->scsi_cmd->sc_data_direction)
 
 #ifdef IPS_DEBUG
 #define METHOD_TRACE(s, i)    if (ips_debug >= (i+10)) printk(KERN_NOTICE s "\n");
@@ -2849,8 +2849,7 @@ ips_next(ips_ha_t * ha, int intr)
 
                        sg = SC->request_buffer;
                        scb->sg_count = pci_map_sg(ha->pcidev, sg, SC->use_sg,
-                                                  scsi_to_pci_dma_dir(SC->
-                                                                      sc_data_direction));
+                                                  SC->sc_data_direction);
                        scb->flags |= IPS_SCB_MAP_SG;
                        for (i = 0; i < scb->sg_count; i++) {
                                if (ips_fill_scb_sg_single
@@ -2865,8 +2864,7 @@ ips_next(ips_ha_t * ha, int intr)
                                    pci_map_single(ha->pcidev,
                                                   SC->request_buffer,
                                                   SC->request_bufflen,
-                                                  scsi_to_pci_dma_dir(SC->
-                                                                      sc_data_direction));
+                                                  SC->sc_data_direction);
                                scb->flags |= IPS_SCB_MAP_SINGLE;
                                ips_fill_scb_sg_single(ha, scb->data_busaddr,
                                                       scb, 0,
index 4e5e54a1564b571edd07e6ac5d2ccfa100696b82..4c96df060c3bad9af44ab4c4664d8cba38c63030 100644 (file)
@@ -305,7 +305,7 @@ void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat)
        sb[0] = 0x70;
        sb[2] = MEDIUM_ERROR;
        sb[7] = 0x0A;
-       if (cmd->sc_data_direction == SCSI_DATA_READ) {
+       if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
                sb[12] = 0x11; /* "unrecovered read error" */
                sb[13] = 0x04;
        } else {
@@ -671,8 +671,8 @@ static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
                return;
 
        /* data is present; dma-map it */
-       if (cmd->sc_data_direction == SCSI_DATA_READ ||
-           cmd->sc_data_direction == SCSI_DATA_WRITE) {
+       if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
+           cmd->sc_data_direction == DMA_TO_DEVICE) {
                if (unlikely(cmd->request_bufflen < 1)) {
                        printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
                               ap->id, dev->devno);
@@ -1304,7 +1304,7 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
        struct scsi_cmnd *cmd = qc->scsicmd;
        struct ata_device *dev = qc->dev;
        int using_pio = (dev->flags & ATA_DFLAG_PIO);
-       int nodata = (cmd->sc_data_direction == SCSI_DATA_NONE);
+       int nodata = (cmd->sc_data_direction == DMA_NONE);
 
        if (!using_pio)
                /* Check whether ATAPI DMA is safe */
@@ -1316,7 +1316,7 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
        qc->complete_fn = atapi_qc_complete;
 
        qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
-       if (cmd->sc_data_direction == SCSI_DATA_WRITE) {
+       if (cmd->sc_data_direction == DMA_TO_DEVICE) {
                qc->tf.flags |= ATA_TFLAG_WRITE;
                DPRINTK("direction: write\n");
        }
@@ -1340,7 +1340,7 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
 
 #ifdef ATAPI_ENABLE_DMADIR
                /* some SATA bridges need us to indicate data xfer direction */
-               if (cmd->sc_data_direction != SCSI_DATA_WRITE)
+               if (cmd->sc_data_direction != DMA_TO_DEVICE)
                        qc->tf.feature |= ATAPI_DMADIR;
 #endif
        }
index d58f303127f506ea2ea21f6c4f9c8e532e8eae48..377a4666b56834ad9be2125ed97727e6f499ed57 100644 (file)
@@ -209,7 +209,7 @@ static int BuildSgList (Scsi_Cmnd *SCpnt, PADAPTER2000 padapter, PDEV2000 pdev)
        if ( SCpnt->use_sg )
                {
                sg = (struct scatterlist *)SCpnt->request_buffer;
-               zc = pci_map_sg (padapter->pdev, sg, SCpnt->use_sg, scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
+               zc = pci_map_sg (padapter->pdev, sg, SCpnt->use_sg, SCpnt->sc_data_direction);
                for ( z = 0;  z < zc;  z++ )
                        {
                        pdev->scatGath[z].address = cpu_to_le32 (sg_dma_address (sg));
@@ -225,7 +225,9 @@ static int BuildSgList (Scsi_Cmnd *SCpnt, PADAPTER2000 padapter, PDEV2000 pdev)
                outl (0, padapter->mb3);
                return TRUE;
                }
-       SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer, SCpnt->request_bufflen, scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
+       SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev,
+                       SCpnt->request_buffer, SCpnt->request_bufflen,
+                       SCpnt->sc_data_direction);
        outl (SCpnt->SCp.have_data_in, padapter->mb2);
        outl (SCpnt->request_bufflen, padapter->mb3);
        return TRUE;
@@ -340,11 +342,11 @@ unmapProceed:;
                        }
                }
        if ( SCpnt->SCp.have_data_in )
-               pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, SCpnt->request_bufflen, scsi_to_pci_dma_dir(SCpnt->sc_data_direction));
+               pci_unmap_single (padapter->pdev, SCpnt->SCp.have_data_in, SCpnt->request_bufflen, SCpnt->sc_data_direction);
        else 
                {
                if ( SCpnt->use_sg )
-                       pci_unmap_sg (padapter->pdev, (struct scatterlist *)SCpnt->request_buffer, SCpnt->use_sg, scsi_to_pci_dma_dir(SCpnt->sc_data_direction));
+                       pci_unmap_sg (padapter->pdev, (struct scatterlist *)SCpnt->request_buffer, SCpnt->use_sg, SCpnt->sc_data_direction);
                }
 
 irqProceed:;
@@ -495,7 +497,7 @@ int Pci2000_QueueCommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
                                                else
                                                        {
                                                        SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer, SCpnt->request_bufflen,
-                                                                                                         scsi_to_pci_dma_dir(SCpnt->sc_data_direction));
+                                                                                                         SCpnt->sc_data_direction);
                                                        outl (SCpnt->SCp.have_data_in, padapter->mb2);
                                                        }
                                                outl (cdb[5], padapter->mb0);
@@ -511,13 +513,13 @@ int Pci2000_QueueCommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
                                SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev,
                                                                          ((struct scatterlist *)SCpnt->request_buffer)->address,
                                                                          SCpnt->request_bufflen,
-                                                                         scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
+                                                                         SCpnt->sc_data_direction);
                                }
                        else
                                {
                                SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, SCpnt->request_buffer,
                                                                          SCpnt->request_bufflen,
-                                                                         scsi_to_pci_dma_dir (SCpnt->sc_data_direction));
+                                                                         SCpnt->sc_data_direction);
                                }
                        outl (SCpnt->SCp.have_data_in, padapter->mb2);
                        outl (SCpnt->request_bufflen, padapter->mb3);
index 24c1174b0c2f33574cf65a7afaa4ff0d754408de..ddf0f4277ee8cd087b24b007afb07adcb1b085c3 100644 (file)
@@ -1261,7 +1261,7 @@ static int isp2x00_queuecommand(Scsi_Cmnd * Cmnd, void (*done) (Scsi_Cmnd *))
 
        if (Cmnd->use_sg) {
                sg = (struct scatterlist *) Cmnd->request_buffer;
-               sg_count = pci_map_sg(hostdata->pci_dev, sg, Cmnd->use_sg, scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+               sg_count = pci_map_sg(hostdata->pci_dev, sg, Cmnd->use_sg, Cmnd->sc_data_direction);
                cmd->segment_cnt = cpu_to_le16(sg_count);
                ds = cmd->dataseg;
                /* fill in first two sg entries: */
@@ -1307,7 +1307,7 @@ static int isp2x00_queuecommand(Scsi_Cmnd * Cmnd, void (*done) (Scsi_Cmnd *))
                dma_addr_t busaddr = pci_map_page(hostdata->pci_dev,
                                                  page, offset,
                                                  Cmnd->request_bufflen,
-                                                 scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                                                 Cmnd->sc_data_direction);
                Cmnd->SCp.dma_handle = busaddr;
 
                cmd->dataseg[0].d_base = cpu_to_le32(pci64_dma_lo32(busaddr));
@@ -1320,7 +1320,7 @@ static int isp2x00_queuecommand(Scsi_Cmnd * Cmnd, void (*done) (Scsi_Cmnd *))
                cmd->segment_cnt = cpu_to_le16(1); /* Shouldn't this be 0? */
        }
 
-       if (Cmnd->sc_data_direction == SCSI_DATA_WRITE)
+       if (Cmnd->sc_data_direction == DMA_TO_DEVICE)
                cmd->control_flags = cpu_to_le16(CFLAG_WRITE);
        else 
                cmd->control_flags = cpu_to_le16(CFLAG_READ);
@@ -1405,13 +1405,13 @@ static void redo_port_db(unsigned long arg)
                                                 pci_unmap_sg(hostdata->pci_dev,
                                                              (struct scatterlist *)Cmnd->buffer,
                                                              Cmnd->use_sg,
-                                                             scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                                                             Cmnd->sc_data_direction);
                                         else if (Cmnd->request_bufflen &&
                                                  Cmnd->sc_data_direction != PCI_DMA_NONE) {
                                                 pci_unmap_page(hostdata->pci_dev,
                                                                Cmnd->SCp.dma_handle,
                                                                Cmnd->request_bufflen,
-                                                               scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                                                               Cmnd->sc_data_direction);
                                         }
 
                                         hostdata->handle_ptrs[i]->result = DID_SOFT_ERROR << 16;
@@ -1515,13 +1515,13 @@ void isp2x00_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
                                        pci_unmap_sg(hostdata->pci_dev,
                                                     (struct scatterlist *)Cmnd->buffer,
                                                     Cmnd->use_sg,
-                                                    scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                                                    Cmnd->sc_data_direction);
                                else if (Cmnd->request_bufflen &&
                                         Cmnd->sc_data_direction != PCI_DMA_NONE)
                                        pci_unmap_page(hostdata->pci_dev,
                                                       Cmnd->SCp.dma_handle,
                                                       Cmnd->request_bufflen,
-                                                      scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                                                      Cmnd->sc_data_direction);
                                Cmnd->result = 0x0;
                                (*Cmnd->scsi_done) (Cmnd);
                        } else
@@ -1569,12 +1569,12 @@ void isp2x00_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
                                if (Cmnd->use_sg)
                                        pci_unmap_sg(hostdata->pci_dev,
                                                     (struct scatterlist *)Cmnd->buffer, Cmnd->use_sg,
-                                                    scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                                                    Cmnd->sc_data_direction);
                                else if (Cmnd->request_bufflen && Cmnd->sc_data_direction != PCI_DMA_NONE)
                                        pci_unmap_page(hostdata->pci_dev,
                                                       Cmnd->SCp.dma_handle,
                                                       Cmnd->request_bufflen,
-                                                      scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                                                      Cmnd->sc_data_direction);
 
                                /* 
                                 * if any of the following are true we do not
index 71d597a9b0b008ab1ea82d6a9cf67e27b4a02861..6d29e1b864e2361ec067280be8d586bf04e17d38 100644 (file)
@@ -877,7 +877,7 @@ static int isp1020_queuecommand(Scsi_Cmnd *Cmnd, void (*done)(Scsi_Cmnd *))
                ds = cmd->dataseg;
 
                sg_count = pci_map_sg(hostdata->pci_dev, sg, Cmnd->use_sg,
-                                     scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                                     Cmnd->sc_data_direction);
 
                cmd->segment_cnt = cpu_to_le16(sg_count);
 
@@ -934,7 +934,7 @@ static int isp1020_queuecommand(Scsi_Cmnd *Cmnd, void (*done)(Scsi_Cmnd *))
                dma_addr = pci_map_single(hostdata->pci_dev,
                                       Cmnd->request_buffer,
                                       Cmnd->request_bufflen,
-                                      scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                                      Cmnd->sc_data_direction);
                Cmnd->SCp.ptr = (char *)(unsigned long) dma_addr;
 
                cmd->dataseg[0].d_base =
@@ -1067,7 +1067,7 @@ void isp1020_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
                        pci_unmap_sg(hostdata->pci_dev,
                                     (struct scatterlist *)Cmnd->buffer,
                                     Cmnd->use_sg,
-                                    scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                                    Cmnd->sc_data_direction);
                else if (Cmnd->request_bufflen)
                        pci_unmap_single(hostdata->pci_dev,
 #ifdef CONFIG_QL_ISP_A64
@@ -1076,7 +1076,7 @@ void isp1020_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
                                         (u32)((long)Cmnd->SCp.ptr),
 #endif
                                         Cmnd->request_bufflen,
-                                        scsi_to_pci_dma_dir(Cmnd->sc_data_direction));
+                                        Cmnd->sc_data_direction);
 
                isp_outw(out_ptr, host, MBOX5);
                (*Cmnd->scsi_done)(Cmnd);
index e2360c26ef01f3eed5027bf730b1376442f96473..5ee5d80a9931376920033f8338989491694552be 100644 (file)
@@ -45,21 +45,6 @@ struct scsi_device;
 struct scsi_target;
 struct scatterlist;
 
-/*
- * Legacy dma direction interfaces.
- *
- * This assumes the pci/sbus dma mapping flags have the same numercial
- * values as the generic dma-mapping ones.  Currently they have but there's
- * no way to check.  Better don't use these interfaces!
- */
-#define SCSI_DATA_UNKNOWN      (DMA_BIDIRECTIONAL)
-#define SCSI_DATA_WRITE                (DMA_TO_DEVICE)
-#define SCSI_DATA_READ         (DMA_FROM_DEVICE)
-#define SCSI_DATA_NONE         (DMA_NONE)
-
-#define scsi_to_pci_dma_dir(scsi_dir)  ((int)(scsi_dir))
-#define scsi_to_sbus_dma_dir(scsi_dir) ((int)(scsi_dir))
-
 /* obsolete typedef junk. */
 #include "scsi_typedefs.h"
 
index ce8332297dfa434a62a004af56e43f1d74447083..7936aafc3d05644bad589d0776b4ac9e6fcda00b 100644 (file)
@@ -747,16 +747,16 @@ sg_common_write(Sg_fd * sfp, Sg_request * srp,
        switch (hp->dxfer_direction) {
        case SG_DXFER_TO_FROM_DEV:
        case SG_DXFER_FROM_DEV:
-               SRpnt->sr_data_direction = SCSI_DATA_READ;
+               SRpnt->sr_data_direction = DMA_FROM_DEVICE;
                break;
        case SG_DXFER_TO_DEV:
-               SRpnt->sr_data_direction = SCSI_DATA_WRITE;
+               SRpnt->sr_data_direction = DMA_TO_DEVICE;
                break;
        case SG_DXFER_UNKNOWN:
-               SRpnt->sr_data_direction = SCSI_DATA_UNKNOWN;
+               SRpnt->sr_data_direction = DMA_BIDIRECTIONAL;
                break;
        default:
-               SRpnt->sr_data_direction = SCSI_DATA_NONE;
+               SRpnt->sr_data_direction = DMA_NONE;
                break;
        }
        SRpnt->upper_private_data = srp;