scsi: gdth: remove gdth_{alloc,free}_ioctl

Out of the three callers once insists on the scratch buffer, and the
others are fine with a new allocation. Switch those two to just use
pci_alloc_consistent directly, and open code the scratch buffer
allocation in the remaining one. This avoids a case where we might
be doing a memory allocation under a spinlock with irqs disabled.

[mkp: typo]

Signed-off-by: Christoph Hellwig <[e-mail]>
Signed-off-by: Martin K. Petersen <[e-mail]>

drivers/scsi/gdth.c

···
 	gdth_ioctl_general gen;
 	gdth_ha_str *ha;
 	char *buf = NULL;
-	u64 paddr;
+	dma_addr_t paddr;
 	int rval;
 
 	if (copy_from_user(&gen, arg, sizeof(gdth_ioctl_general)))
···
 		return -EINVAL;
 
 	if (gen.data_len + gen.sense_len > 0) {
-		buf = gdth_ioctl_alloc(ha, gen.data_len + gen.sense_len, FALSE,
-				&paddr);
+		buf = pci_alloc_consistent(ha->pdev,
+				gen.data_len + gen.sense_len, &paddr);
 		if (!buf)
 			return -EFAULT;
 
···
 
 	rval = 0;
 out_free_buf:
-	gdth_ioctl_free(ha, gen.data_len+gen.sense_len, buf, paddr);
+	pci_free_consistent(ha->pdev, gen.data_len + gen.sense_len, buf, paddr);
 	return rval;
 }
  

drivers/scsi/gdth_proc.c

···
     int i, found;
     gdth_cmd_str    gdtcmd;
     gdth_cpar_str   *pcpar;
-    u64         paddr;
 
     char            cmnd[MAX_COMMAND_SIZE];
     memset(cmnd, 0xff, 12);
···
     }
 
     if (wb_mode) {
-        if (!gdth_ioctl_alloc(ha, sizeof(gdth_cpar_str), TRUE, &paddr))
-            return(-EBUSY);
+	unsigned long flags;
+
+	BUILD_BUG_ON(sizeof(gdth_cpar_str) > GDTH_SCRATCH);
+
+	spin_lock_irqsave(&ha->smp_lock, flags);
+	if (ha->scratch_busy) {
+	    spin_unlock_irqrestore(&ha->smp_lock, flags);
+            return -EBUSY;
+	}
+	ha->scratch_busy = TRUE;
+	spin_unlock_irqrestore(&ha->smp_lock, flags);
+
         pcpar = (gdth_cpar_str *)ha->pscratch;
         memcpy( pcpar, &ha->cpar, sizeof(gdth_cpar_str) );
         gdtcmd.Service = CACHESERVICE;
         gdtcmd.OpCode = GDT_IOCTL;
-        gdtcmd.u.ioctl.p_param = paddr;
+        gdtcmd.u.ioctl.p_param = ha->scratch_phys;
         gdtcmd.u.ioctl.param_size = sizeof(gdth_cpar_str);
         gdtcmd.u.ioctl.subfunc = CACHE_CONFIG;
         gdtcmd.u.ioctl.channel = INVALID_CHANNEL;
···
 
         gdth_execute(host, &gdtcmd, cmnd, 30, NULL);
 
-        gdth_ioctl_free(ha, GDTH_SCRATCH, ha->pscratch, paddr);
+	spin_lock_irqsave(&ha->smp_lock, flags);
+	ha->scratch_busy = FALSE;
+	spin_unlock_irqrestore(&ha->smp_lock, flags);
+
         printk("Done.\n");
         return(orig_length);
     }
···
     int id, i, j, k, sec, flag;
     int no_mdrv = 0, drv_no, is_mirr;
     u32 cnt;
-    u64 paddr;
+    dma_addr_t paddr;
     int rc = -ENOMEM;
 
     gdth_cmd_str *gdtcmd;
···
         seq_puts(m, "\nPhysical Devices:");
         flag = FALSE;
             
-        buf = gdth_ioctl_alloc(ha, size, FALSE, &paddr);
+        buf = pci_alloc_consistent(ha->pdev, size, &paddr);
         if (!buf) 
             goto stop_output;
         for (i = 0; i < ha->bus_cnt; ++i) {
···
             seq_printf(m,
                            " To Array Drv.:\t%s\n", hrec);
         }       
-        
+
         if (!flag)
             seq_puts(m, "\n --\n");
 
···
                 }
             }
         }
-        gdth_ioctl_free(ha, size, buf, paddr);
+	pci_free_consistent(ha->pdev, size, buf, paddr);
 
         for (i = 0; i < MAX_HDRIVES; ++i) {
             if (!(ha->hdr[i].present))
···
     kfree(gdtcmd);
     kfree(estr);
     return rc;
-}
-
-static char *gdth_ioctl_alloc(gdth_ha_str *ha, int size, int scratch,
-                              u64 *paddr)
-{
-    unsigned long flags;
-    char *ret_val;
-
-    if (size == 0)
-        return NULL;
-
-    spin_lock_irqsave(&ha->smp_lock, flags);
-
-    if (!ha->scratch_busy && size <= GDTH_SCRATCH) {
-        ha->scratch_busy = TRUE;
-        ret_val = ha->pscratch;
-        *paddr = ha->scratch_phys;
-    } else if (scratch) {
-        ret_val = NULL;
-    } else {
-        dma_addr_t dma_addr;
-
-        ret_val = pci_alloc_consistent(ha->pdev, size, &dma_addr);
-        *paddr = dma_addr;
-    }
-
-    spin_unlock_irqrestore(&ha->smp_lock, flags);
-    return ret_val;
-}
-
-static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, u64 paddr)
-{
-    unsigned long flags;
-
-    if (buf == ha->pscratch) {
-	spin_lock_irqsave(&ha->smp_lock, flags);
-        ha->scratch_busy = FALSE;
-	spin_unlock_irqrestore(&ha->smp_lock, flags);
-    } else {
-        pci_free_consistent(ha->pdev, size, buf, paddr);
-    }
 }
 
 #ifdef GDTH_IOCTL_PROC

drivers/scsi/gdth_proc.h

···
 static int gdth_set_asc_info(struct Scsi_Host *host, char *buffer,
                              int length, gdth_ha_str *ha);
 
-static char *gdth_ioctl_alloc(gdth_ha_str *ha, int size, int scratch,
-                              u64 *paddr);
-static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, u64 paddr);
 static void gdth_wait_completion(gdth_ha_str *ha, int busnum, int id);
 
 #endif