mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-05 20:16:41 +07:00
d3f46f39b7
With the sg table code, every SCSI driver is now either chain capable or broken (or has sg_tablesize set so chaining is never activated), so there's no need to have a check in the host template. Also tidy up the code by moving the scatterlist size defines into the SCSI includes and permit the last entry of the scatterlist pools not to be a power of two. Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
229 lines
5.6 KiB
C
229 lines
5.6 KiB
C
/*
|
|
* Qlogic FAS408 ISA card driver
|
|
*
|
|
* Copyright 1994, Tom Zerucha.
|
|
* tz@execpc.com
|
|
*
|
|
* Redistributable under terms of the GNU General Public License
|
|
*
|
|
* For the avoidance of doubt the "preferred form" of this code is one which
|
|
* is in an open non patent encumbered format. Where cryptographic key signing
|
|
* forms part of the process of creating an executable the information
|
|
* including keys needed to generate an equivalently functional executable
|
|
* are deemed to be part of the source code.
|
|
*
|
|
* Check qlogicfas408.c for more credits and info.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/blkdev.h> /* to get disk capacity */
|
|
#include <linux/kernel.h>
|
|
#include <linux/string.h>
|
|
#include <linux/init.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/unistd.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/stat.h>
|
|
|
|
#include <asm/io.h>
|
|
#include <asm/irq.h>
|
|
#include <asm/dma.h>
|
|
|
|
#include "scsi.h"
|
|
#include <scsi/scsi_host.h>
|
|
#include "qlogicfas408.h"
|
|
|
|
/* Set the following to 2 to use normal interrupt (active high/totempole-
|
|
* tristate), otherwise use 0 (REQUIRED FOR PCMCIA) for active low, open
|
|
* drain
|
|
*/
|
|
#define INT_TYPE 2
|
|
|
|
static char qlogicfas_name[] = "qlogicfas";
|
|
|
|
/*
|
|
* Look for qlogic card and init if found
|
|
*/
|
|
|
|
static struct Scsi_Host *__qlogicfas_detect(struct scsi_host_template *host,
|
|
int qbase,
|
|
int qlirq)
|
|
{
|
|
int qltyp; /* type of chip */
|
|
int qinitid;
|
|
struct Scsi_Host *hreg; /* registered host structure */
|
|
struct qlogicfas408_priv *priv;
|
|
|
|
/* Qlogic Cards only exist at 0x230 or 0x330 (the chip itself
|
|
* decodes the address - I check 230 first since MIDI cards are
|
|
* typically at 0x330
|
|
*
|
|
* Theoretically, two Qlogic cards can coexist in the same system.
|
|
* This should work by simply using this as a loadable module for
|
|
* the second card, but I haven't tested this.
|
|
*/
|
|
|
|
if (!qbase || qlirq == -1)
|
|
goto err;
|
|
|
|
if (!request_region(qbase, 0x10, qlogicfas_name)) {
|
|
printk(KERN_INFO "%s: address %#x is busy\n", qlogicfas_name,
|
|
qbase);
|
|
goto err;
|
|
}
|
|
|
|
if (!qlogicfas408_detect(qbase, INT_TYPE)) {
|
|
printk(KERN_WARNING "%s: probe failed for %#x\n",
|
|
qlogicfas_name,
|
|
qbase);
|
|
goto err_release_mem;
|
|
}
|
|
|
|
printk(KERN_INFO "%s: Using preset base address of %03x,"
|
|
" IRQ %d\n", qlogicfas_name, qbase, qlirq);
|
|
|
|
qltyp = qlogicfas408_get_chip_type(qbase, INT_TYPE);
|
|
qinitid = host->this_id;
|
|
if (qinitid < 0)
|
|
qinitid = 7; /* if no ID, use 7 */
|
|
|
|
qlogicfas408_setup(qbase, qinitid, INT_TYPE);
|
|
|
|
hreg = scsi_host_alloc(host, sizeof(struct qlogicfas408_priv));
|
|
if (!hreg)
|
|
goto err_release_mem;
|
|
priv = get_priv_by_host(hreg);
|
|
hreg->io_port = qbase;
|
|
hreg->n_io_port = 16;
|
|
hreg->dma_channel = -1;
|
|
if (qlirq != -1)
|
|
hreg->irq = qlirq;
|
|
priv->qbase = qbase;
|
|
priv->qlirq = qlirq;
|
|
priv->qinitid = qinitid;
|
|
priv->shost = hreg;
|
|
priv->int_type = INT_TYPE;
|
|
|
|
sprintf(priv->qinfo,
|
|
"Qlogicfas Driver version 0.46, chip %02X at %03X, IRQ %d, TPdma:%d",
|
|
qltyp, qbase, qlirq, QL_TURBO_PDMA);
|
|
host->name = qlogicfas_name;
|
|
|
|
if (request_irq(qlirq, qlogicfas408_ihandl, 0, qlogicfas_name, hreg))
|
|
goto free_scsi_host;
|
|
|
|
if (scsi_add_host(hreg, NULL))
|
|
goto free_interrupt;
|
|
|
|
scsi_scan_host(hreg);
|
|
|
|
return hreg;
|
|
|
|
free_interrupt:
|
|
free_irq(qlirq, hreg);
|
|
|
|
free_scsi_host:
|
|
scsi_host_put(hreg);
|
|
|
|
err_release_mem:
|
|
release_region(qbase, 0x10);
|
|
err:
|
|
return NULL;
|
|
}
|
|
|
|
#define MAX_QLOGICFAS 8
|
|
static struct qlogicfas408_priv *cards;
|
|
static int iobase[MAX_QLOGICFAS];
|
|
static int irq[MAX_QLOGICFAS] = { [0 ... MAX_QLOGICFAS-1] = -1 };
|
|
module_param_array(iobase, int, NULL, 0);
|
|
module_param_array(irq, int, NULL, 0);
|
|
MODULE_PARM_DESC(iobase, "I/O address");
|
|
MODULE_PARM_DESC(irq, "IRQ");
|
|
|
|
static int __devinit qlogicfas_detect(struct scsi_host_template *sht)
|
|
{
|
|
struct Scsi_Host *shost;
|
|
struct qlogicfas408_priv *priv;
|
|
int num;
|
|
|
|
for (num = 0; num < MAX_QLOGICFAS; num++) {
|
|
shost = __qlogicfas_detect(sht, iobase[num], irq[num]);
|
|
if (shost == NULL) {
|
|
/* no more devices */
|
|
break;
|
|
}
|
|
priv = get_priv_by_host(shost);
|
|
priv->next = cards;
|
|
cards = priv;
|
|
}
|
|
|
|
return num;
|
|
}
|
|
|
|
static int qlogicfas_release(struct Scsi_Host *shost)
|
|
{
|
|
struct qlogicfas408_priv *priv = get_priv_by_host(shost);
|
|
|
|
scsi_remove_host(shost);
|
|
if (shost->irq) {
|
|
qlogicfas408_disable_ints(priv);
|
|
free_irq(shost->irq, shost);
|
|
}
|
|
if (shost->dma_channel != 0xff)
|
|
free_dma(shost->dma_channel);
|
|
if (shost->io_port && shost->n_io_port)
|
|
release_region(shost->io_port, shost->n_io_port);
|
|
scsi_host_put(shost);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* The driver template is also needed for PCMCIA
|
|
*/
|
|
static struct scsi_host_template qlogicfas_driver_template = {
|
|
.module = THIS_MODULE,
|
|
.name = qlogicfas_name,
|
|
.proc_name = qlogicfas_name,
|
|
.info = qlogicfas408_info,
|
|
.queuecommand = qlogicfas408_queuecommand,
|
|
.eh_abort_handler = qlogicfas408_abort,
|
|
.eh_bus_reset_handler = qlogicfas408_bus_reset,
|
|
.bios_param = qlogicfas408_biosparam,
|
|
.can_queue = 1,
|
|
.this_id = -1,
|
|
.sg_tablesize = SG_ALL,
|
|
.cmd_per_lun = 1,
|
|
.use_clustering = DISABLE_CLUSTERING,
|
|
};
|
|
|
|
static __init int qlogicfas_init(void)
|
|
{
|
|
if (!qlogicfas_detect(&qlogicfas_driver_template)) {
|
|
/* no cards found */
|
|
printk(KERN_INFO "%s: no cards were found, please specify "
|
|
"I/O address and IRQ using iobase= and irq= "
|
|
"options", qlogicfas_name);
|
|
return -ENODEV;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static __exit void qlogicfas_exit(void)
|
|
{
|
|
struct qlogicfas408_priv *priv;
|
|
|
|
for (priv = cards; priv != NULL; priv = priv->next)
|
|
qlogicfas_release(priv->shost);
|
|
}
|
|
|
|
MODULE_AUTHOR("Tom Zerucha, Michael Griffith");
|
|
MODULE_DESCRIPTION("Driver for the Qlogic FAS408 based ISA card");
|
|
MODULE_LICENSE("GPL");
|
|
module_init(qlogicfas_init);
|
|
module_exit(qlogicfas_exit);
|
|
|