mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-22 00:40:03 +00:00
![Finn Thain](/assets/img/avatar_default.png)
Because of the rudimentary design of the chip, it is necessary to poll the SCSI bus signals during PIO and this tends to hog the CPU. The driver will accept new commands while others execute, and this causes a soft lockup because the workqueue item will not terminate until the issue queue is emptied. When exercising dmx3191d using sequential IO from dd, the driver is sent 512 KiB WRITE commands and 128 KiB READs. For a PIO transfer, the rate is is only about 300 KiB/s, so these are long-running commands. And although PDMA may run at several MiB/s, interrupts are disabled for the duration of the transfer. Fix the unresponsiveness and soft lockup issues by calling cond_resched() after each command is completed and by limiting max_sectors for drivers that don't implement real DMA. Signed-off-by: Finn Thain <fthain@telegraphics.com.au> Reviewed-by: Hannes Reinecke <hare@suse.com> Tested-by: Ondrej Zary <linux@rainbow-software.org> Tested-by: Michael Schmitz <schmitzmic@gmail.com> Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
412 lines
10 KiB
C
412 lines
10 KiB
C
#define PSEUDO_DMA
|
|
|
|
/*
|
|
* Trantor T128/T128F/T228 driver
|
|
* Note : architecturally, the T100 and T130 are different and won't
|
|
* work
|
|
*
|
|
* Copyright 1993, Drew Eckhardt
|
|
* Visionary Computing
|
|
* (Unix and Linux consulting and custom programming)
|
|
* drew@colorado.edu
|
|
* +1 (303) 440-4894
|
|
*
|
|
* For more information, please consult
|
|
*
|
|
* Trantor Systems, Ltd.
|
|
* T128/T128F/T228 SCSI Host Adapter
|
|
* Hardware Specifications
|
|
*
|
|
* Trantor Systems, Ltd.
|
|
* 5415 Randall Place
|
|
* Fremont, CA 94538
|
|
* 1+ (415) 770-1400, FAX 1+ (415) 770-9910
|
|
*/
|
|
|
|
/*
|
|
* The card is detected and initialized in one of several ways :
|
|
* 1. Autoprobe (default) - since the board is memory mapped,
|
|
* a BIOS signature is scanned for to locate the registers.
|
|
* An interrupt is triggered to autoprobe for the interrupt
|
|
* line.
|
|
*
|
|
* 2. With command line overrides - t128=address,irq may be
|
|
* used on the LILO command line to override the defaults.
|
|
*
|
|
* 3. With the T128_OVERRIDE compile time define. This is
|
|
* specified as an array of address, irq tuples. Ie, for
|
|
* one board at the default 0xcc000 address, IRQ5, I could say
|
|
* -DT128_OVERRIDE={{0xcc000, 5}}
|
|
*
|
|
* Note that if the override methods are used, place holders must
|
|
* be specified for other boards in the system.
|
|
*
|
|
* T128/T128F jumper/dipswitch settings (note : on my sample, the switches
|
|
* were epoxy'd shut, meaning I couldn't change the 0xcc000 base address) :
|
|
*
|
|
* T128 Sw7 Sw8 Sw6 = 0ws Sw5 = boot
|
|
* T128F Sw6 Sw7 Sw5 = 0ws Sw4 = boot Sw8 = floppy disable
|
|
* cc000 off off
|
|
* c8000 off on
|
|
* dc000 on off
|
|
* d8000 on on
|
|
*
|
|
*
|
|
* Interrupts
|
|
* There is a 12 pin jumper block, jp1, numbered as follows :
|
|
* T128 (JP1) T128F (J5)
|
|
* 2 4 6 8 10 12 11 9 7 5 3 1
|
|
* 1 3 5 7 9 11 12 10 8 6 4 2
|
|
*
|
|
* 3 2-4
|
|
* 5 1-3
|
|
* 7 3-5
|
|
* T128F only
|
|
* 10 8-10
|
|
* 12 7-9
|
|
* 14 10-12
|
|
* 15 9-11
|
|
*/
|
|
|
|
#include <linux/io.h>
|
|
#include <linux/blkdev.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/init.h>
|
|
#include <linux/module.h>
|
|
|
|
#include <scsi/scsi_host.h>
|
|
#include "t128.h"
|
|
#define AUTOPROBE_IRQ
|
|
#include "NCR5380.h"
|
|
|
|
static struct override {
|
|
unsigned long address;
|
|
int irq;
|
|
} overrides
|
|
#ifdef T128_OVERRIDE
|
|
[] __initdata = T128_OVERRIDE;
|
|
#else
|
|
[4] __initdata = {{0, IRQ_AUTO}, {0, IRQ_AUTO},
|
|
{0 ,IRQ_AUTO}, {0, IRQ_AUTO}};
|
|
#endif
|
|
|
|
#define NO_OVERRIDES ARRAY_SIZE(overrides)
|
|
|
|
static struct base {
|
|
unsigned int address;
|
|
int noauto;
|
|
} bases[] __initdata = {
|
|
{ 0xcc000, 0}, { 0xc8000, 0}, { 0xdc000, 0}, { 0xd8000, 0}
|
|
};
|
|
|
|
#define NO_BASES ARRAY_SIZE(bases)
|
|
|
|
static struct signature {
|
|
const char *string;
|
|
int offset;
|
|
} signatures[] __initdata = {
|
|
{"TSROM: SCSI BIOS, Version 1.12", 0x36},
|
|
};
|
|
|
|
#define NO_SIGNATURES ARRAY_SIZE(signatures)
|
|
|
|
#ifndef MODULE
|
|
/*
|
|
* Function : t128_setup(char *str, int *ints)
|
|
*
|
|
* Purpose : LILO command line initialization of the overrides array,
|
|
*
|
|
* Inputs : str - unused, ints - array of integer parameters with ints[0]
|
|
* equal to the number of ints.
|
|
*
|
|
*/
|
|
|
|
static int __init t128_setup(char *str)
|
|
{
|
|
static int commandline_current;
|
|
int i;
|
|
int ints[10];
|
|
|
|
get_options(str, ARRAY_SIZE(ints), ints);
|
|
if (ints[0] != 2)
|
|
printk("t128_setup : usage t128=address,irq\n");
|
|
else
|
|
if (commandline_current < NO_OVERRIDES) {
|
|
overrides[commandline_current].address = ints[1];
|
|
overrides[commandline_current].irq = ints[2];
|
|
for (i = 0; i < NO_BASES; ++i)
|
|
if (bases[i].address == ints[1]) {
|
|
bases[i].noauto = 1;
|
|
break;
|
|
}
|
|
++commandline_current;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
__setup("t128=", t128_setup);
|
|
#endif
|
|
|
|
/*
|
|
* Function : int t128_detect(struct scsi_host_template * tpnt)
|
|
*
|
|
* Purpose : detects and initializes T128,T128F, or T228 controllers
|
|
* that were autoprobed, overridden on the LILO command line,
|
|
* or specified at compile time.
|
|
*
|
|
* Inputs : tpnt - template for this SCSI adapter.
|
|
*
|
|
* Returns : 1 if a host adapter was found, 0 if not.
|
|
*
|
|
*/
|
|
|
|
static int __init t128_detect(struct scsi_host_template *tpnt)
|
|
{
|
|
static int current_override, current_base;
|
|
struct Scsi_Host *instance;
|
|
unsigned long base;
|
|
void __iomem *p;
|
|
int sig, count;
|
|
|
|
for (count = 0; current_override < NO_OVERRIDES; ++current_override) {
|
|
base = 0;
|
|
p = NULL;
|
|
|
|
if (overrides[current_override].address) {
|
|
base = overrides[current_override].address;
|
|
p = ioremap(bases[current_base].address, 0x2000);
|
|
if (!p)
|
|
base = 0;
|
|
} else
|
|
for (; !base && (current_base < NO_BASES); ++current_base) {
|
|
dprintk(NDEBUG_INIT, "t128: probing address 0x%08x\n",
|
|
bases[current_base].address);
|
|
if (bases[current_base].noauto)
|
|
continue;
|
|
p = ioremap(bases[current_base].address, 0x2000);
|
|
if (!p)
|
|
continue;
|
|
for (sig = 0; sig < NO_SIGNATURES; ++sig)
|
|
if (check_signature(p + signatures[sig].offset,
|
|
signatures[sig].string,
|
|
strlen(signatures[sig].string))) {
|
|
base = bases[current_base].address;
|
|
dprintk(NDEBUG_INIT, "t128: detected board\n");
|
|
goto found;
|
|
}
|
|
iounmap(p);
|
|
}
|
|
|
|
dprintk(NDEBUG_INIT, "t128: base = 0x%08x\n", (unsigned int)base);
|
|
|
|
if (!base)
|
|
break;
|
|
|
|
found:
|
|
instance = scsi_register (tpnt, sizeof(struct NCR5380_hostdata));
|
|
if(instance == NULL)
|
|
goto out_unmap;
|
|
|
|
instance->base = base;
|
|
((struct NCR5380_hostdata *)instance->hostdata)->base = p;
|
|
|
|
if (NCR5380_init(instance, 0))
|
|
goto out_unregister;
|
|
|
|
NCR5380_maybe_reset_bus(instance);
|
|
|
|
if (overrides[current_override].irq != IRQ_AUTO)
|
|
instance->irq = overrides[current_override].irq;
|
|
else
|
|
instance->irq = NCR5380_probe_irq(instance, T128_IRQS);
|
|
|
|
/* Compatibility with documented NCR5380 kernel parameters */
|
|
if (instance->irq == 255)
|
|
instance->irq = NO_IRQ;
|
|
|
|
if (instance->irq != NO_IRQ)
|
|
if (request_irq(instance->irq, t128_intr, 0, "t128",
|
|
instance)) {
|
|
printk("scsi%d : IRQ%d not free, interrupts disabled\n",
|
|
instance->host_no, instance->irq);
|
|
instance->irq = NO_IRQ;
|
|
}
|
|
|
|
if (instance->irq == NO_IRQ) {
|
|
printk("scsi%d : interrupts not enabled. for better interactive performance,\n", instance->host_no);
|
|
printk("scsi%d : please jumper the board for a free IRQ.\n", instance->host_no);
|
|
}
|
|
|
|
dprintk(NDEBUG_INIT, "scsi%d: irq = %d\n",
|
|
instance->host_no, instance->irq);
|
|
|
|
++current_override;
|
|
++count;
|
|
}
|
|
return count;
|
|
|
|
out_unregister:
|
|
scsi_unregister(instance);
|
|
out_unmap:
|
|
iounmap(p);
|
|
return count;
|
|
}
|
|
|
|
static int t128_release(struct Scsi_Host *shost)
|
|
{
|
|
struct NCR5380_hostdata *hostdata = shost_priv(shost);
|
|
|
|
if (shost->irq != NO_IRQ)
|
|
free_irq(shost->irq, shost);
|
|
NCR5380_exit(shost);
|
|
scsi_unregister(shost);
|
|
iounmap(hostdata->base);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Function : int t128_biosparam(Disk * disk, struct block_device *dev, int *ip)
|
|
*
|
|
* Purpose : Generates a BIOS / DOS compatible H-C-S mapping for
|
|
* the specified device / size.
|
|
*
|
|
* Inputs : size = size of device in sectors (512 bytes), dev = block device
|
|
* major / minor, ip[] = {heads, sectors, cylinders}
|
|
*
|
|
* Returns : always 0 (success), initializes ip
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* XXX Most SCSI boards use this mapping, I could be incorrect. Some one
|
|
* using hard disks on a trantor should verify that this mapping corresponds
|
|
* to that used by the BIOS / ASPI driver by running the linux fdisk program
|
|
* and matching the H_C_S coordinates to what DOS uses.
|
|
*/
|
|
|
|
static int t128_biosparam(struct scsi_device *sdev, struct block_device *bdev,
|
|
sector_t capacity, int *ip)
|
|
{
|
|
ip[0] = 64;
|
|
ip[1] = 32;
|
|
ip[2] = capacity >> 11;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Function : int NCR5380_pread (struct Scsi_Host *instance,
|
|
* unsigned char *dst, int len)
|
|
*
|
|
* Purpose : Fast 5380 pseudo-dma read function, transfers len bytes to
|
|
* dst
|
|
*
|
|
* Inputs : dst = destination, len = length in bytes
|
|
*
|
|
* Returns : 0 on success, non zero on a failure such as a watchdog
|
|
* timeout.
|
|
*/
|
|
|
|
static inline int
|
|
NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst, int len)
|
|
{
|
|
struct NCR5380_hostdata *hostdata = shost_priv(instance);
|
|
void __iomem *reg, *base = hostdata->base;
|
|
unsigned char *d = dst;
|
|
register int i = len;
|
|
|
|
reg = base + T_DATA_REG_OFFSET;
|
|
|
|
#if 0
|
|
for (; i; --i) {
|
|
while (!(readb(base+T_STATUS_REG_OFFSET) & T_ST_RDY)) barrier();
|
|
#else
|
|
while (!(readb(base+T_STATUS_REG_OFFSET) & T_ST_RDY)) barrier();
|
|
for (; i; --i) {
|
|
#endif
|
|
*d++ = readb(reg);
|
|
}
|
|
|
|
if (readb(base + T_STATUS_REG_OFFSET) & T_ST_TIM) {
|
|
unsigned char tmp;
|
|
void __iomem *foo = base + T_CONTROL_REG_OFFSET;
|
|
tmp = readb(foo);
|
|
writeb(tmp | T_CR_CT, foo);
|
|
writeb(tmp, foo);
|
|
printk("scsi%d : watchdog timer fired in NCR5380_pread()\n",
|
|
instance->host_no);
|
|
return -1;
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Function : int NCR5380_pwrite (struct Scsi_Host *instance,
|
|
* unsigned char *src, int len)
|
|
*
|
|
* Purpose : Fast 5380 pseudo-dma write function, transfers len bytes from
|
|
* src
|
|
*
|
|
* Inputs : src = source, len = length in bytes
|
|
*
|
|
* Returns : 0 on success, non zero on a failure such as a watchdog
|
|
* timeout.
|
|
*/
|
|
|
|
static inline int
|
|
NCR5380_pwrite(struct Scsi_Host *instance, unsigned char *src, int len)
|
|
{
|
|
struct NCR5380_hostdata *hostdata = shost_priv(instance);
|
|
void __iomem *reg, *base = hostdata->base;
|
|
unsigned char *s = src;
|
|
register int i = len;
|
|
|
|
reg = base + T_DATA_REG_OFFSET;
|
|
|
|
#if 0
|
|
for (; i; --i) {
|
|
while (!(readb(base+T_STATUS_REG_OFFSET) & T_ST_RDY)) barrier();
|
|
#else
|
|
while (!(readb(base+T_STATUS_REG_OFFSET) & T_ST_RDY)) barrier();
|
|
for (; i; --i) {
|
|
#endif
|
|
writeb(*s++, reg);
|
|
}
|
|
|
|
if (readb(base + T_STATUS_REG_OFFSET) & T_ST_TIM) {
|
|
unsigned char tmp;
|
|
void __iomem *foo = base + T_CONTROL_REG_OFFSET;
|
|
tmp = readb(foo);
|
|
writeb(tmp | T_CR_CT, foo);
|
|
writeb(tmp, foo);
|
|
printk("scsi%d : watchdog timer fired in NCR5380_pwrite()\n",
|
|
instance->host_no);
|
|
return -1;
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
#include "NCR5380.c"
|
|
|
|
static struct scsi_host_template driver_template = {
|
|
.name = "Trantor T128/T128F/T228",
|
|
.detect = t128_detect,
|
|
.release = t128_release,
|
|
.proc_name = "t128",
|
|
.show_info = t128_show_info,
|
|
.write_info = t128_write_info,
|
|
.info = t128_info,
|
|
.queuecommand = t128_queue_command,
|
|
.eh_abort_handler = t128_abort,
|
|
.eh_bus_reset_handler = t128_bus_reset,
|
|
.bios_param = t128_biosparam,
|
|
.can_queue = 32,
|
|
.this_id = 7,
|
|
.sg_tablesize = SG_ALL,
|
|
.cmd_per_lun = 2,
|
|
.use_clustering = DISABLE_CLUSTERING,
|
|
.cmd_size = NCR5380_CMD_SIZE,
|
|
.max_sectors = 128,
|
|
};
|
|
#include "scsi_module.c"
|