Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Generic Generic NCR5380 driver |
| 3 | * |
| 4 | * Copyright 1995-2002, Russell King |
| 5 | */ |
| 6 | #include <linux/module.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | #include <linux/ioport.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 8 | #include <linux/blkdev.h> |
| 9 | #include <linux/init.h> |
| 10 | |
| 11 | #include <asm/ecard.h> |
| 12 | #include <asm/io.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | #include <scsi/scsi_host.h> |
| 15 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 16 | #define priv(host) ((struct NCR5380_hostdata *)(host)->hostdata) |
Finn Thain | 54d8fe4 | 2016-01-03 16:05:06 +1100 | [diff] [blame] | 17 | #define NCR5380_read(reg) cumanascsi_read(instance, reg) |
| 18 | #define NCR5380_write(reg, value) cumanascsi_write(instance, reg, value) |
Finn Thain | ff3d457 | 2016-01-03 16:05:25 +1100 | [diff] [blame] | 19 | |
| 20 | #define NCR5380_dma_xfer_len(instance, cmd, phase) (cmd->transfersize) |
Finn Thain | 6c4b88c | 2016-03-23 21:10:17 +1100 | [diff] [blame] | 21 | #define NCR5380_dma_recv_setup cumanascsi_pread |
| 22 | #define NCR5380_dma_send_setup cumanascsi_pwrite |
Finn Thain | 8053b0e | 2016-03-23 21:10:19 +1100 | [diff] [blame^] | 23 | #define NCR5380_dma_residual(instance) (0) |
Finn Thain | ff3d457 | 2016-01-03 16:05:25 +1100 | [diff] [blame] | 24 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 25 | #define NCR5380_intr cumanascsi_intr |
| 26 | #define NCR5380_queue_command cumanascsi_queue_command |
Finn Thain | 8c32513 | 2014-11-12 16:11:58 +1100 | [diff] [blame] | 27 | #define NCR5380_info cumanascsi_info |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 29 | #define NCR5380_implementation_fields \ |
| 30 | unsigned ctrl; \ |
| 31 | void __iomem *base; \ |
| 32 | void __iomem *dma |
| 33 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | #include "../NCR5380.h" |
| 35 | |
| 36 | void cumanascsi_setup(char *str, int *ints) |
| 37 | { |
| 38 | } |
| 39 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 40 | #define CTRL 0x16fc |
| 41 | #define STAT 0x2004 |
| 42 | #define L(v) (((v)<<16)|((v) & 0x0000ffff)) |
| 43 | #define H(v) (((v)>>16)|((v) & 0xffff0000)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | |
Finn Thain | 6c4b88c | 2016-03-23 21:10:17 +1100 | [diff] [blame] | 45 | static inline int cumanascsi_pwrite(struct Scsi_Host *host, |
| 46 | unsigned char *addr, int len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | unsigned long *laddr; |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 49 | void __iomem *dma = priv(host)->dma + 0x2000; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | |
| 51 | if(!len) return 0; |
| 52 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 53 | writeb(0x02, priv(host)->base + CTRL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | laddr = (unsigned long *)addr; |
| 55 | while(len >= 32) |
| 56 | { |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 57 | unsigned int status; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | unsigned long v; |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 59 | status = readb(priv(host)->base + STAT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | if(status & 0x80) |
| 61 | goto end; |
| 62 | if(!(status & 0x40)) |
| 63 | continue; |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 64 | v=*laddr++; writew(L(v), dma); writew(H(v), dma); |
| 65 | v=*laddr++; writew(L(v), dma); writew(H(v), dma); |
| 66 | v=*laddr++; writew(L(v), dma); writew(H(v), dma); |
| 67 | v=*laddr++; writew(L(v), dma); writew(H(v), dma); |
| 68 | v=*laddr++; writew(L(v), dma); writew(H(v), dma); |
| 69 | v=*laddr++; writew(L(v), dma); writew(H(v), dma); |
| 70 | v=*laddr++; writew(L(v), dma); writew(H(v), dma); |
| 71 | v=*laddr++; writew(L(v), dma); writew(H(v), dma); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | len -= 32; |
| 73 | if(len == 0) |
| 74 | break; |
| 75 | } |
| 76 | |
| 77 | addr = (unsigned char *)laddr; |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 78 | writeb(0x12, priv(host)->base + CTRL); |
| 79 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | while(len > 0) |
| 81 | { |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 82 | unsigned int status; |
| 83 | status = readb(priv(host)->base + STAT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 84 | if(status & 0x80) |
| 85 | goto end; |
| 86 | if(status & 0x40) |
| 87 | { |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 88 | writeb(*addr++, dma); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | if(--len == 0) |
| 90 | break; |
| 91 | } |
| 92 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 93 | status = readb(priv(host)->base + STAT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | if(status & 0x80) |
| 95 | goto end; |
| 96 | if(status & 0x40) |
| 97 | { |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 98 | writeb(*addr++, dma); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 99 | if(--len == 0) |
| 100 | break; |
| 101 | } |
| 102 | } |
| 103 | end: |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 104 | writeb(priv(host)->ctrl | 0x40, priv(host)->base + CTRL); |
Finn Thain | 438af51 | 2016-03-23 21:10:18 +1100 | [diff] [blame] | 105 | |
| 106 | if (len) |
| 107 | return -1; |
| 108 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | } |
| 110 | |
Finn Thain | 6c4b88c | 2016-03-23 21:10:17 +1100 | [diff] [blame] | 111 | static inline int cumanascsi_pread(struct Scsi_Host *host, |
| 112 | unsigned char *addr, int len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | unsigned long *laddr; |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 115 | void __iomem *dma = priv(host)->dma + 0x2000; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | |
| 117 | if(!len) return 0; |
| 118 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 119 | writeb(0x00, priv(host)->base + CTRL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | laddr = (unsigned long *)addr; |
| 121 | while(len >= 32) |
| 122 | { |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 123 | unsigned int status; |
| 124 | status = readb(priv(host)->base + STAT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | if(status & 0x80) |
| 126 | goto end; |
| 127 | if(!(status & 0x40)) |
| 128 | continue; |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 129 | *laddr++ = readw(dma) | (readw(dma) << 16); |
| 130 | *laddr++ = readw(dma) | (readw(dma) << 16); |
| 131 | *laddr++ = readw(dma) | (readw(dma) << 16); |
| 132 | *laddr++ = readw(dma) | (readw(dma) << 16); |
| 133 | *laddr++ = readw(dma) | (readw(dma) << 16); |
| 134 | *laddr++ = readw(dma) | (readw(dma) << 16); |
| 135 | *laddr++ = readw(dma) | (readw(dma) << 16); |
| 136 | *laddr++ = readw(dma) | (readw(dma) << 16); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 137 | len -= 32; |
| 138 | if(len == 0) |
| 139 | break; |
| 140 | } |
| 141 | |
| 142 | addr = (unsigned char *)laddr; |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 143 | writeb(0x10, priv(host)->base + CTRL); |
| 144 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 145 | while(len > 0) |
| 146 | { |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 147 | unsigned int status; |
| 148 | status = readb(priv(host)->base + STAT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | if(status & 0x80) |
| 150 | goto end; |
| 151 | if(status & 0x40) |
| 152 | { |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 153 | *addr++ = readb(dma); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | if(--len == 0) |
| 155 | break; |
| 156 | } |
| 157 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 158 | status = readb(priv(host)->base + STAT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | if(status & 0x80) |
| 160 | goto end; |
| 161 | if(status & 0x40) |
| 162 | { |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 163 | *addr++ = readb(dma); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | if(--len == 0) |
| 165 | break; |
| 166 | } |
| 167 | } |
| 168 | end: |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 169 | writeb(priv(host)->ctrl | 0x40, priv(host)->base + CTRL); |
Finn Thain | 438af51 | 2016-03-23 21:10:18 +1100 | [diff] [blame] | 170 | |
| 171 | if (len) |
| 172 | return -1; |
| 173 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | } |
| 175 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 176 | static unsigned char cumanascsi_read(struct Scsi_Host *host, unsigned int reg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | { |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 178 | void __iomem *base = priv(host)->base; |
| 179 | unsigned char val; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 181 | writeb(0, base + CTRL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 183 | val = readb(base + 0x2100 + (reg << 2)); |
| 184 | |
| 185 | priv(host)->ctrl = 0x40; |
| 186 | writeb(0x40, base + CTRL); |
| 187 | |
| 188 | return val; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | } |
| 190 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 191 | static void cumanascsi_write(struct Scsi_Host *host, unsigned int reg, unsigned int value) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | { |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 193 | void __iomem *base = priv(host)->base; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 195 | writeb(0, base + CTRL); |
| 196 | |
| 197 | writeb(value, base + 0x2100 + (reg << 2)); |
| 198 | |
| 199 | priv(host)->ctrl = 0x40; |
| 200 | writeb(0x40, base + CTRL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | } |
| 202 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | #include "../NCR5380.c" |
| 204 | |
Christoph Hellwig | d0be4a7d | 2005-10-31 18:31:40 +0100 | [diff] [blame] | 205 | static struct scsi_host_template cumanascsi_template = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | .module = THIS_MODULE, |
| 207 | .name = "Cumana 16-bit SCSI", |
| 208 | .info = cumanascsi_info, |
| 209 | .queuecommand = cumanascsi_queue_command, |
| 210 | .eh_abort_handler = NCR5380_abort, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | .eh_bus_reset_handler = NCR5380_bus_reset, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | .can_queue = 16, |
| 213 | .this_id = 7, |
| 214 | .sg_tablesize = SG_ALL, |
| 215 | .cmd_per_lun = 2, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | .use_clustering = DISABLE_CLUSTERING, |
| 217 | .proc_name = "CumanaSCSI-1", |
Finn Thain | 32b26a1 | 2016-01-03 16:05:58 +1100 | [diff] [blame] | 218 | .cmd_size = NCR5380_CMD_SIZE, |
Finn Thain | 0a4e361 | 2016-01-03 16:06:07 +1100 | [diff] [blame] | 219 | .max_sectors = 128, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | }; |
| 221 | |
Greg Kroah-Hartman | 6f03979 | 2012-12-21 13:08:55 -0800 | [diff] [blame] | 222 | static int cumanascsi1_probe(struct expansion_card *ec, |
| 223 | const struct ecard_id *id) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 224 | { |
| 225 | struct Scsi_Host *host; |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 226 | int ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 227 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 228 | ret = ecard_request_resources(ec); |
| 229 | if (ret) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | goto out; |
| 231 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 232 | host = scsi_host_alloc(&cumanascsi_template, sizeof(struct NCR5380_hostdata)); |
| 233 | if (!host) { |
| 234 | ret = -ENOMEM; |
| 235 | goto out_release; |
| 236 | } |
| 237 | |
| 238 | priv(host)->base = ioremap(ecard_resource_start(ec, ECARD_RES_IOCSLOW), |
| 239 | ecard_resource_len(ec, ECARD_RES_IOCSLOW)); |
| 240 | priv(host)->dma = ioremap(ecard_resource_start(ec, ECARD_RES_MEMC), |
| 241 | ecard_resource_len(ec, ECARD_RES_MEMC)); |
| 242 | if (!priv(host)->base || !priv(host)->dma) { |
| 243 | ret = -ENOMEM; |
| 244 | goto out_unmap; |
| 245 | } |
| 246 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | host->irq = ec->irq; |
| 248 | |
Finn Thain | 8053b0e | 2016-03-23 21:10:19 +1100 | [diff] [blame^] | 249 | ret = NCR5380_init(host, FLAG_DMA_FIXUP | FLAG_LATE_DMA_SETUP); |
Finn Thain | 0ad0eff | 2016-01-03 16:05:21 +1100 | [diff] [blame] | 250 | if (ret) |
| 251 | goto out_unmap; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | |
Finn Thain | b6488f9 | 2016-01-03 16:05:08 +1100 | [diff] [blame] | 253 | NCR5380_maybe_reset_bus(host); |
| 254 | |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 255 | priv(host)->ctrl = 0; |
| 256 | writeb(0, priv(host)->base + CTRL); |
| 257 | |
Michael Opdenacker | 4909cc2 | 2014-03-05 06:09:41 +0100 | [diff] [blame] | 258 | ret = request_irq(host->irq, cumanascsi_intr, 0, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 259 | "CumanaSCSI-1", host); |
| 260 | if (ret) { |
| 261 | printk("scsi%d: IRQ%d not free: %d\n", |
| 262 | host->host_no, host->irq, ret); |
Finn Thain | 0ad0eff | 2016-01-03 16:05:21 +1100 | [diff] [blame] | 263 | goto out_exit; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 264 | } |
| 265 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 266 | ret = scsi_add_host(host, &ec->dev); |
| 267 | if (ret) |
| 268 | goto out_free_irq; |
| 269 | |
| 270 | scsi_scan_host(host); |
| 271 | goto out; |
| 272 | |
| 273 | out_free_irq: |
| 274 | free_irq(host->irq, host); |
Finn Thain | 0ad0eff | 2016-01-03 16:05:21 +1100 | [diff] [blame] | 275 | out_exit: |
| 276 | NCR5380_exit(host); |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 277 | out_unmap: |
| 278 | iounmap(priv(host)->base); |
| 279 | iounmap(priv(host)->dma); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | scsi_host_put(host); |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 281 | out_release: |
| 282 | ecard_release_resources(ec); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 283 | out: |
| 284 | return ret; |
| 285 | } |
| 286 | |
Greg Kroah-Hartman | 6f03979 | 2012-12-21 13:08:55 -0800 | [diff] [blame] | 287 | static void cumanascsi1_remove(struct expansion_card *ec) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 288 | { |
| 289 | struct Scsi_Host *host = ecard_get_drvdata(ec); |
| 290 | |
| 291 | ecard_set_drvdata(ec, NULL); |
| 292 | |
| 293 | scsi_remove_host(host); |
| 294 | free_irq(host->irq, host); |
| 295 | NCR5380_exit(host); |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 296 | iounmap(priv(host)->base); |
| 297 | iounmap(priv(host)->dma); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 298 | scsi_host_put(host); |
Russell King | 8b801ea | 2007-07-20 10:38:54 +0100 | [diff] [blame] | 299 | ecard_release_resources(ec); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 300 | } |
| 301 | |
| 302 | static const struct ecard_id cumanascsi1_cids[] = { |
| 303 | { MANU_CUMANA, PROD_CUMANA_SCSI_1 }, |
| 304 | { 0xffff, 0xffff } |
| 305 | }; |
| 306 | |
| 307 | static struct ecard_driver cumanascsi1_driver = { |
| 308 | .probe = cumanascsi1_probe, |
Greg Kroah-Hartman | 6f03979 | 2012-12-21 13:08:55 -0800 | [diff] [blame] | 309 | .remove = cumanascsi1_remove, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 310 | .id_table = cumanascsi1_cids, |
| 311 | .drv = { |
| 312 | .name = "cumanascsi1", |
| 313 | }, |
| 314 | }; |
| 315 | |
| 316 | static int __init cumanascsi_init(void) |
| 317 | { |
| 318 | return ecard_register_driver(&cumanascsi1_driver); |
| 319 | } |
| 320 | |
| 321 | static void __exit cumanascsi_exit(void) |
| 322 | { |
| 323 | ecard_remove_driver(&cumanascsi1_driver); |
| 324 | } |
| 325 | |
| 326 | module_init(cumanascsi_init); |
| 327 | module_exit(cumanascsi_exit); |
| 328 | |
| 329 | MODULE_DESCRIPTION("Cumana SCSI-1 driver for Acorn machines"); |
| 330 | MODULE_LICENSE("GPL"); |