root/drivers/scsi/qlogicfas.c

DEFINITIONS

1. __qlogicfas_detect
2. qlogicfas_detect
3. qlogicfas_release
4. qlogicfas_init
5. qlogicfas_exit

   1 /*
   2  * Qlogic FAS408 ISA card driver
   3  *
   4  * Copyright 1994, Tom Zerucha.   
   5  * tz@execpc.com
   6  * 
   7  * Redistributable under terms of the GNU General Public License
   8  *
   9  * For the avoidance of doubt the "preferred form" of this code is one which
  10  * is in an open non patent encumbered format. Where cryptographic key signing
  11  * forms part of the process of creating an executable the information
  12  * including keys needed to generate an equivalently functional executable
  13  * are deemed to be part of the source code.
  14  *
  15  * Check qlogicfas408.c for more credits and info.
  16  */
  17 
  18 #include <linux/module.h>
  19 #include <linux/blkdev.h>               /* to get disk capacity */
  20 #include <linux/kernel.h>
  21 #include <linux/string.h>
  22 #include <linux/init.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/ioport.h>
  25 #include <linux/proc_fs.h>
  26 #include <linux/unistd.h>
  27 #include <linux/spinlock.h>
  28 #include <linux/stat.h>
  29 
  30 #include <asm/io.h>
  31 #include <asm/irq.h>
  32 #include <asm/dma.h>
  33 
  34 #include "scsi.h"
  35 #include <scsi/scsi_host.h>
  36 #include "qlogicfas408.h"
  37 
  38 /* Set the following to 2 to use normal interrupt (active high/totempole-
  39  * tristate), otherwise use 0 (REQUIRED FOR PCMCIA) for active low, open
  40  * drain
  41  */
  42 #define INT_TYPE        2
  43 
  44 static char qlogicfas_name[] = "qlogicfas";
  45 
  46 /*
  47  *      Look for qlogic card and init if found 
  48  */
  49  
  50 static struct Scsi_Host *__qlogicfas_detect(struct scsi_host_template *host,
  51                                                                 int qbase,
  52                                                                 int qlirq)
  53 {
  54         int qltyp;              /* type of chip */
  55         int qinitid;
  56         struct Scsi_Host *hreg; /* registered host structure */
  57         struct qlogicfas408_priv *priv;
  58 
  59         /*      Qlogic Cards only exist at 0x230 or 0x330 (the chip itself
  60          *      decodes the address - I check 230 first since MIDI cards are
  61          *      typically at 0x330
  62          *
  63          *      Theoretically, two Qlogic cards can coexist in the same system.
  64          *      This should work by simply using this as a loadable module for
  65          *      the second card, but I haven't tested this.
  66          */
  67 
  68         if (!qbase || qlirq == -1)
  69                 goto err;
  70 
  71         if (!request_region(qbase, 0x10, qlogicfas_name)) {
  72                 printk(KERN_INFO "%s: address %#x is busy\n", qlogicfas_name,
  73                                                               qbase);
  74                 goto err;
  75         }
  76 
  77         if (!qlogicfas408_detect(qbase, INT_TYPE)) {
  78                 printk(KERN_WARNING "%s: probe failed for %#x\n",
  79                                                                 qlogicfas_name,
  80                                                                 qbase);
  81                 goto err_release_mem;
  82         }
  83 
  84         printk(KERN_INFO "%s: Using preset base address of %03x,"
  85                          " IRQ %d\n", qlogicfas_name, qbase, qlirq);
  86 
  87         qltyp = qlogicfas408_get_chip_type(qbase, INT_TYPE);
  88         qinitid = host->this_id;
  89         if (qinitid < 0)
  90                 qinitid = 7;    /* if no ID, use 7 */
  91 
  92         qlogicfas408_setup(qbase, qinitid, INT_TYPE);
  93 
  94         hreg = scsi_host_alloc(host, sizeof(struct qlogicfas408_priv));
  95         if (!hreg)
  96                 goto err_release_mem;
  97         priv = get_priv_by_host(hreg);
  98         hreg->io_port = qbase;
  99         hreg->n_io_port = 16;
 100         hreg->dma_channel = -1;
 101         if (qlirq != -1)
 102                 hreg->irq = qlirq;
 103         priv->qbase = qbase;
 104         priv->qlirq = qlirq;
 105         priv->qinitid = qinitid;
 106         priv->shost = hreg;
 107         priv->int_type = INT_TYPE;
 108 
 109         sprintf(priv->qinfo,
 110                 "Qlogicfas Driver version 0.46, chip %02X at %03X, IRQ %d, TPdma:%d",
 111                 qltyp, qbase, qlirq, QL_TURBO_PDMA);
 112         host->name = qlogicfas_name;
 113 
 114         if (request_irq(qlirq, qlogicfas408_ihandl, 0, qlogicfas_name, hreg))
 115                 goto free_scsi_host;
 116 
 117         if (scsi_add_host(hreg, NULL))
 118                 goto free_interrupt;
 119 
 120         scsi_scan_host(hreg);
 121 
 122         return hreg;
 123 
 124 free_interrupt:
 125         free_irq(qlirq, hreg);
 126 
 127 free_scsi_host:
 128         scsi_host_put(hreg);
 129 
 130 err_release_mem:
 131         release_region(qbase, 0x10);
 132 err:
 133         return NULL;
 134 }
 135 
 136 #define MAX_QLOGICFAS   8
 137 static struct qlogicfas408_priv *cards;
 138 static int iobase[MAX_QLOGICFAS];
 139 static int irq[MAX_QLOGICFAS] = { [0 ... MAX_QLOGICFAS-1] = -1 };
 140 module_param_hw_array(iobase, int, ioport, NULL, 0);
 141 module_param_hw_array(irq, int, irq, NULL, 0);
 142 MODULE_PARM_DESC(iobase, "I/O address");
 143 MODULE_PARM_DESC(irq, "IRQ");
 144 
 145 static int qlogicfas_detect(struct scsi_host_template *sht)
 146 {
 147         struct Scsi_Host *shost;
 148         struct qlogicfas408_priv *priv;
 149         int num;
 150 
 151         for (num = 0; num < MAX_QLOGICFAS; num++) {
 152                 shost = __qlogicfas_detect(sht, iobase[num], irq[num]);
 153                 if (shost == NULL) {
 154                         /* no more devices */
 155                         break;
 156                 }
 157                 priv = get_priv_by_host(shost);
 158                 priv->next = cards;
 159                 cards = priv;
 160         }
 161 
 162         return num;
 163 }
 164 
 165 static int qlogicfas_release(struct Scsi_Host *shost)
 166 {
 167         struct qlogicfas408_priv *priv = get_priv_by_host(shost);
 168 
 169         scsi_remove_host(shost);
 170         if (shost->irq) {
 171                 qlogicfas408_disable_ints(priv);        
 172                 free_irq(shost->irq, shost);
 173         }
 174         if (shost->io_port && shost->n_io_port)
 175                 release_region(shost->io_port, shost->n_io_port);
 176         scsi_host_put(shost);
 177 
 178         return 0;
 179 }
 180 
 181 /*
 182  *      The driver template is also needed for PCMCIA
 183  */
 184 static struct scsi_host_template qlogicfas_driver_template = {
 185         .module                 = THIS_MODULE,
 186         .name                   = qlogicfas_name,
 187         .proc_name              = qlogicfas_name,
 188         .info                   = qlogicfas408_info,
 189         .queuecommand           = qlogicfas408_queuecommand,
 190         .eh_abort_handler       = qlogicfas408_abort,
 191         .eh_host_reset_handler  = qlogicfas408_host_reset,
 192         .bios_param             = qlogicfas408_biosparam,
 193         .can_queue              = 1,
 194         .this_id                = -1,
 195         .sg_tablesize           = SG_ALL,
 196         .dma_boundary           = PAGE_SIZE - 1,
 197 };
 198 
 199 static __init int qlogicfas_init(void)
 200 {
 201         if (!qlogicfas_detect(&qlogicfas_driver_template)) {
 202                 /* no cards found */
 203                 printk(KERN_INFO "%s: no cards were found, please specify "
 204                                  "I/O address and IRQ using iobase= and irq= "
 205                                  "options", qlogicfas_name);
 206                 return -ENODEV;
 207         }
 208 
 209         return 0;
 210 }
 211 
 212 static __exit void qlogicfas_exit(void)
 213 {
 214         struct qlogicfas408_priv *priv;
 215 
 216         for (priv = cards; priv != NULL; priv = priv->next)
 217                 qlogicfas_release(priv->shost);
 218 }
 219 
 220 MODULE_AUTHOR("Tom Zerucha, Michael Griffith");
 221 MODULE_DESCRIPTION("Driver for the Qlogic FAS408 based ISA card");
 222 MODULE_LICENSE("GPL");
 223 module_init(qlogicfas_init);
 224 module_exit(qlogicfas_exit);
 225