?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'locking-urgent-2020-12-27' of git://git.kernel.org/pub/scm/linux/kernel...
[linux/fpc-iii.git] / drivers / scsi / aha1740.c
blob0dc831026e9e1692fce6f63546b996fce0e40065
1 /* $Id$
2 * 1993/03/31
3 * linux/kernel/aha1740.c
4 *
5 * Based loosely on aha1542.c which is
6 * Copyright (C) 1992 Tommy Thorn and
7 * Modified by Eric Youngdale
8 *
9 * This file is aha1740.c, written and
10 * Copyright (C) 1992,1993 Brad McLean
11 * brad@saturn.gaylord.com or brad@bradpc.gaylord.com.
12 *
13 * Modifications to makecode and queuecommand
14 * for proper handling of multiple devices courteously
15 * provided by Michael Weller, March, 1993
16 *
17 * Multiple adapter support, extended translation detection,
18 * update to current scsi subsystem changes, proc fs support,
19 * working (!) module support based on patches from Andreas Arens,
20 * by Andreas Degert <ad@papyrus.hamburg.com>, 2/1997
21 *
22 * aha1740_makecode may still need even more work
23 * if it doesn't work for your devices, take a look.
24 *
25 * Reworked for new_eh and new locking by Alan Cox <alan@lxorguk.ukuu.org.uk>
26 *
27 * Converted to EISA and generic DMA APIs by Marc Zyngier
28 * <maz@wild-wind.fr.eu.org>, 4/2003.
29 *
30 * Shared interrupt support added by Rask Ingemann Lambertsen
31 * <rask@sygehus.dk>, 10/2003
32 *
33 * For the avoidance of doubt the "preferred form" of this code is one which
34 * is in an open non patent encumbered format. Where cryptographic key signing
35 * forms part of the process of creating an executable the information
36 * including keys needed to generate an equivalently functional executable
37 * are deemed to be part of the source code.
38 */
39
40 #include <linux/blkdev.h>
41 #include <linux/interrupt.h>
42 #include <linux/module.h>
43 #include <linux/kernel.h>
44 #include <linux/types.h>
45 #include <linux/string.h>
46 #include <linux/ioport.h>
47 #include <linux/proc_fs.h>
48 #include <linux/stat.h>
49 #include <linux/init.h>
50 #include <linux/device.h>
51 #include <linux/eisa.h>
52 #include <linux/dma-mapping.h>
53 #include <linux/gfp.h>
54
55 #include <asm/dma.h>
56 #include <asm/io.h>
57
58 #include "scsi.h"
59 #include <scsi/scsi_host.h>
60 #include "aha1740.h"
61
62 /* IF YOU ARE HAVING PROBLEMS WITH THIS DRIVER, AND WANT TO WATCH
63 IT WORK, THEN:
64 #define DEBUG
65 */
66 #ifdef DEBUG
67 #define DEB(x) x
68 #else
69 #define DEB(x)
70 #endif
71
72 struct aha1740_hostdata {
73 struct eisa_device *edev;
74 unsigned int translation;
75 unsigned int last_ecb_used;
76 dma_addr_t ecb_dma_addr;
77 struct ecb ecb[AHA1740_ECBS];
78 };
79
80 struct aha1740_sg {
81 struct aha1740_chain sg_chain[AHA1740_SCATTER];
82 dma_addr_t sg_dma_addr;
83 dma_addr_t buf_dma_addr;
84 };
85
86 #define HOSTDATA(host) ((struct aha1740_hostdata *) &host->hostdata)
87
88 static inline struct ecb *ecb_dma_to_cpu (struct Scsi_Host *host,
89 dma_addr_t dma)
90 {
91 struct aha1740_hostdata *hdata = HOSTDATA (host);
92 dma_addr_t offset;
93
94 offset = dma - hdata->ecb_dma_addr;
95
96 return (struct ecb *)(((char *) hdata->ecb) + (unsigned int) offset);
97 }
98
99 static inline dma_addr_t ecb_cpu_to_dma (struct Scsi_Host *host, void *cpu)
100 {
101 struct aha1740_hostdata *hdata = HOSTDATA (host);
102 dma_addr_t offset;
103
104 offset = (char *) cpu - (char *) hdata->ecb;
105
106 return hdata->ecb_dma_addr + offset;
107 }
108
109 static int aha1740_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
110 {
111 struct aha1740_hostdata *host = HOSTDATA(shpnt);
112 seq_printf(m, "aha174x at IO:%lx, IRQ %d, SLOT %d.\n"
113 "Extended translation %sabled.\n",
114 shpnt->io_port, shpnt->irq, host->edev->slot,
115 host->translation ? "en" : "dis");
116 return 0;
117 }
118
119 static int aha1740_makecode(unchar *sense, unchar *status)
120 {
121 struct statusword
122 {
123 ushort don:1, /* Command Done - No Error */
124 du:1, /* Data underrun */
125 :1, qf:1, /* Queue full */
126 sc:1, /* Specification Check */
127 dor:1, /* Data overrun */
128 ch:1, /* Chaining Halted */
129 intr:1, /* Interrupt issued */
130 asa:1, /* Additional Status Available */
131 sns:1, /* Sense information Stored */
132 :1, ini:1, /* Initialization Required */
133 me:1, /* Major error or exception */
134 :1, eca:1, /* Extended Contingent alliance */
135 :1;
136 } status_word;
137 int retval = DID_OK;
138
139 status_word = * (struct statusword *) status;
140 #ifdef DEBUG
141 printk("makecode from %x,%x,%x,%x %x,%x,%x,%x",
142 status[0], status[1], status[2], status[3],
143 sense[0], sense[1], sense[2], sense[3]);
144 #endif
145 if (!status_word.don) { /* Anything abnormal was detected */
146 if ( (status[1]&0x18) || status_word.sc ) {
147 /*Additional info available*/
148 /* Use the supplied info for further diagnostics */
149 switch ( status[2] ) {
150 case 0x12:
151 if ( status_word.dor )
152 retval=DID_ERROR; /* It's an Overrun */
153 /* If not overrun, assume underrun and
154 * ignore it! */
155 break;
156 case 0x00: /* No info, assume no error, should
157 * not occur */
158 break;
159 case 0x11:
160 case 0x21:
161 retval=DID_TIME_OUT;
162 break;
163 case 0x0a:
164 retval=DID_BAD_TARGET;
165 break;
166 case 0x04:
167 case 0x05:
168 retval=DID_ABORT;
169 /* Either by this driver or the
170 * AHA1740 itself */
171 break;
172 default:
173 retval=DID_ERROR; /* No further
174 * diagnostics
175 * possible */
176 }
177 } else {
178 /* Michael suggests, and Brad concurs: */
179 if ( status_word.qf ) {
180 retval = DID_TIME_OUT; /* forces a redo */
181 /* I think this specific one should
182 * not happen -Brad */
183 printk("aha1740.c: WARNING: AHA1740 queue overflow!\n");
184 } else
185 if ( status[0]&0x60 ) {
186 /* Didn't find a better error */
187 retval = DID_ERROR;
188 }
189 /* In any other case return DID_OK so for example
190 CONDITION_CHECKS make it through to the appropriate
191 device driver */
192 }
193 }
194 /* Under all circumstances supply the target status -Michael */
195 return status[3] | retval << 16;
196 }
197
198 static int aha1740_test_port(unsigned int base)
199 {
200 if ( inb(PORTADR(base)) & PORTADDR_ENH )
201 return 1; /* Okay, we're all set */
202
203 printk("aha174x: Board detected, but not in enhanced mode, so disabled it.\n");
204 return 0;
205 }
206
207 /* A "high" level interrupt handler */
208 static irqreturn_t aha1740_intr_handle(int irq, void *dev_id)
209 {
210 struct Scsi_Host *host = (struct Scsi_Host *) dev_id;
211 void (*my_done)(struct scsi_cmnd *);
212 int errstatus, adapstat;
213 int number_serviced;
214 struct ecb *ecbptr;
215 struct scsi_cmnd *SCtmp;
216 unsigned int base;
217 unsigned long flags;
218 int handled = 0;
219 struct aha1740_sg *sgptr;
220 struct eisa_device *edev;
221
222 if (!host)
223 panic("aha1740.c: Irq from unknown host!\n");
224 spin_lock_irqsave(host->host_lock, flags);
225 base = host->io_port;
226 number_serviced = 0;
227 edev = HOSTDATA(host)->edev;
228
229 while(inb(G2STAT(base)) & G2STAT_INTPEND) {
230 handled = 1;
231 DEB(printk("aha1740_intr top of loop.\n"));
232 adapstat = inb(G2INTST(base));
233 ecbptr = ecb_dma_to_cpu (host, inl(MBOXIN0(base)));
234 outb(G2CNTRL_IRST,G2CNTRL(base)); /* interrupt reset */
235
236 switch ( adapstat & G2INTST_MASK ) {
237 case G2INTST_CCBRETRY:
238 case G2INTST_CCBERROR:
239 case G2INTST_CCBGOOD:
240 /* Host Ready -> Mailbox in complete */
241 outb(G2CNTRL_HRDY,G2CNTRL(base));
242 if (!ecbptr) {
243 printk("Aha1740 null ecbptr in interrupt (%x,%x,%x,%d)\n",
244 inb(G2STAT(base)),adapstat,
245 inb(G2INTST(base)), number_serviced++);
246 continue;
247 }
248 SCtmp = ecbptr->SCpnt;
249 if (!SCtmp) {
250 printk("Aha1740 null SCtmp in interrupt (%x,%x,%x,%d)\n",
251 inb(G2STAT(base)),adapstat,
252 inb(G2INTST(base)), number_serviced++);
253 continue;
254 }
255 sgptr = (struct aha1740_sg *) SCtmp->host_scribble;
256 scsi_dma_unmap(SCtmp);
257
258 /* Free the sg block */
259 dma_free_coherent (&edev->dev,
260 sizeof (struct aha1740_sg),
261 SCtmp->host_scribble,
262 sgptr->sg_dma_addr);
263
264 /* Fetch the sense data, and tuck it away, in
265 the required slot. The Adaptec
266 automatically fetches it, and there is no
267 guarantee that we will still have it in the
268 cdb when we come back */
269 if ( (adapstat & G2INTST_MASK) == G2INTST_CCBERROR ) {
270 memcpy(SCtmp->sense_buffer, ecbptr->sense,
271 SCSI_SENSE_BUFFERSIZE);
272 errstatus = aha1740_makecode(ecbptr->sense,ecbptr->status);
273 } else
274 errstatus = 0;
275 DEB(if (errstatus)
276 printk("aha1740_intr_handle: returning %6x\n",
277 errstatus));
278 SCtmp->result = errstatus;
279 my_done = ecbptr->done;
280 memset(ecbptr,0,sizeof(struct ecb));
281 if ( my_done )
282 my_done(SCtmp);
283 break;
284
285 case G2INTST_HARDFAIL:
286 printk(KERN_ALERT "aha1740 hardware failure!\n");
287 panic("aha1740.c"); /* Goodbye */
288
289 case G2INTST_ASNEVENT:
290 printk("aha1740 asynchronous event: %02x %02x %02x %02x %02x\n",
291 adapstat,
292 inb(MBOXIN0(base)),
293 inb(MBOXIN1(base)),
294 inb(MBOXIN2(base)),
295 inb(MBOXIN3(base))); /* Say What? */
296 /* Host Ready -> Mailbox in complete */
297 outb(G2CNTRL_HRDY,G2CNTRL(base));
298 break;
299
300 case G2INTST_CMDGOOD:
301 /* set immediate command success flag here: */
302 break;
303
304 case G2INTST_CMDERROR:
305 /* Set immediate command failure flag here: */
306 break;
307 }
308 number_serviced++;
309 }
310
311 spin_unlock_irqrestore(host->host_lock, flags);
312 return IRQ_RETVAL(handled);
313 }
314
315 static int aha1740_queuecommand_lck(struct scsi_cmnd * SCpnt,
316 void (*done)(struct scsi_cmnd *))
317 {
318 unchar direction;
319 unchar *cmd = (unchar *) SCpnt->cmnd;
320 unchar target = scmd_id(SCpnt);
321 struct aha1740_hostdata *host = HOSTDATA(SCpnt->device->host);
322 unsigned long flags;
323 dma_addr_t sg_dma;
324 struct aha1740_sg *sgptr;
325 int ecbno, nseg;
326 DEB(int i);
327
328 if(*cmd == REQUEST_SENSE) {
329 SCpnt->result = 0;
330 done(SCpnt);
331 return 0;
332 }
333
334 #ifdef DEBUG
335 if (*cmd == READ_10 || *cmd == WRITE_10)
336 i = xscsi2int(cmd+2);
337 else if (*cmd == READ_6 || *cmd == WRITE_6)
338 i = scsi2int(cmd+2);
339 else
340 i = -1;
341 printk("aha1740_queuecommand: dev %d cmd %02x pos %d len %d ",
342 target, *cmd, i, bufflen);
343 printk("scsi cmd:");
344 for (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
345 printk("\n");
346 #endif
347
348 /* locate an available ecb */
349 spin_lock_irqsave(SCpnt->device->host->host_lock, flags);
350 ecbno = host->last_ecb_used + 1; /* An optimization */
351 if (ecbno >= AHA1740_ECBS)
352 ecbno = 0;
353 do {
354 if (!host->ecb[ecbno].cmdw)
355 break;
356 ecbno++;
357 if (ecbno >= AHA1740_ECBS)
358 ecbno = 0;
359 } while (ecbno != host->last_ecb_used);
360
361 if (host->ecb[ecbno].cmdw)
362 panic("Unable to find empty ecb for aha1740.\n");
363
364 host->ecb[ecbno].cmdw = AHA1740CMD_INIT; /* SCSI Initiator Command
365 doubles as reserved flag */
366
367 host->last_ecb_used = ecbno;
368 spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags);
369
370 #ifdef DEBUG
371 printk("Sending command (%d %x)...", ecbno, done);
372 #endif
373
374 host->ecb[ecbno].cdblen = SCpnt->cmd_len; /* SCSI Command
375 * Descriptor Block
376 * Length */
377
378 direction = 0;
379 if (*cmd == READ_10 || *cmd == READ_6)
380 direction = 1;
381 else if (*cmd == WRITE_10 || *cmd == WRITE_6)
382 direction = 0;
383
384 memcpy(host->ecb[ecbno].cdb, cmd, SCpnt->cmd_len);
385
386 SCpnt->host_scribble = dma_alloc_coherent (&host->edev->dev,
387 sizeof (struct aha1740_sg),
388 &sg_dma, GFP_ATOMIC);
389 if(SCpnt->host_scribble == NULL) {
390 printk(KERN_WARNING "aha1740: out of memory in queuecommand!\n");
391 return 1;
392 }
393 sgptr = (struct aha1740_sg *) SCpnt->host_scribble;
394 sgptr->sg_dma_addr = sg_dma;
395
396 nseg = scsi_dma_map(SCpnt);
397 BUG_ON(nseg < 0);
398 if (nseg) {
399 struct scatterlist *sg;
400 struct aha1740_chain * cptr;
401 int i;
402 DEB(unsigned char * ptr);
403
404 host->ecb[ecbno].sg = 1; /* SCSI Initiator Command
405 * w/scatter-gather*/
406 cptr = sgptr->sg_chain;
407 scsi_for_each_sg(SCpnt, sg, nseg, i) {
408 cptr[i].datalen = sg_dma_len (sg);
409 cptr[i].dataptr = sg_dma_address (sg);
410 }
411 host->ecb[ecbno].datalen = nseg * sizeof(struct aha1740_chain);
412 host->ecb[ecbno].dataptr = sg_dma;
413 #ifdef DEBUG
414 printk("cptr %x: ",cptr);
415 ptr = (unsigned char *) cptr;
416 for(i=0;i<24;i++) printk("%02x ", ptr[i]);
417 #endif
418 } else {
419 host->ecb[ecbno].datalen = 0;
420 host->ecb[ecbno].dataptr = 0;
421 }
422 host->ecb[ecbno].lun = SCpnt->device->lun;
423 host->ecb[ecbno].ses = 1; /* Suppress underrun errors */
424 host->ecb[ecbno].dir = direction;
425 host->ecb[ecbno].ars = 1; /* Yes, get the sense on an error */
426 host->ecb[ecbno].senselen = 12;
427 host->ecb[ecbno].senseptr = ecb_cpu_to_dma (SCpnt->device->host,
428 host->ecb[ecbno].sense);
429 host->ecb[ecbno].statusptr = ecb_cpu_to_dma (SCpnt->device->host,
430 host->ecb[ecbno].status);
431 host->ecb[ecbno].done = done;
432 host->ecb[ecbno].SCpnt = SCpnt;
433 #ifdef DEBUG
434 {
435 int i;
436 printk("aha1740_command: sending.. ");
437 for (i = 0; i < sizeof(host->ecb[ecbno]) - 10; i++)
438 printk("%02x ", ((unchar *)&host->ecb[ecbno])[i]);
439 }
440 printk("\n");
441 #endif
442 if (done) {
443 /* The Adaptec Spec says the card is so fast that the loops
444 will only be executed once in the code below. Even if this
445 was true with the fastest processors when the spec was
446 written, it doesn't seem to be true with today's fast
447 processors. We print a warning if the code is executed more
448 often than LOOPCNT_WARN. If this happens, it should be
449 investigated. If the count reaches LOOPCNT_MAX, we assume
450 something is broken; since there is no way to return an
451 error (the return value is ignored by the mid-level scsi
452 layer) we have to panic (and maybe that's the best thing we
453 can do then anyhow). */
454
455 #define LOOPCNT_WARN 10 /* excessive mbxout wait -> syslog-msg */
456 #define LOOPCNT_MAX 1000000 /* mbxout deadlock -> panic() after ~ 2 sec. */
457 int loopcnt;
458 unsigned int base = SCpnt->device->host->io_port;
459 DEB(printk("aha1740[%d] critical section\n",ecbno));
460
461 spin_lock_irqsave(SCpnt->device->host->host_lock, flags);
462 for (loopcnt = 0; ; loopcnt++) {
463 if (inb(G2STAT(base)) & G2STAT_MBXOUT) break;
464 if (loopcnt == LOOPCNT_WARN) {
465 printk("aha1740[%d]_mbxout wait!\n",ecbno);
466 }
467 if (loopcnt == LOOPCNT_MAX)
468 panic("aha1740.c: mbxout busy!\n");
469 }
470 outl (ecb_cpu_to_dma (SCpnt->device->host, host->ecb + ecbno),
471 MBOXOUT0(base));
472 for (loopcnt = 0; ; loopcnt++) {
473 if (! (inb(G2STAT(base)) & G2STAT_BUSY)) break;
474 if (loopcnt == LOOPCNT_WARN) {
475 printk("aha1740[%d]_attn wait!\n",ecbno);
476 }
477 if (loopcnt == LOOPCNT_MAX)
478 panic("aha1740.c: attn wait failed!\n");
479 }
480 outb(ATTN_START | (target & 7), ATTN(base)); /* Start it up */
481 spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags);
482 DEB(printk("aha1740[%d] request queued.\n",ecbno));
483 } else
484 printk(KERN_ALERT "aha1740_queuecommand: done can't be NULL\n");
485 return 0;
486 }
487
488 static DEF_SCSI_QCMD(aha1740_queuecommand)
489
490 /* Query the board for its irq_level and irq_type. Nothing else matters
491 in enhanced mode on an EISA bus. */
492
493 static void aha1740_getconfig(unsigned int base, unsigned int *irq_level,
494 unsigned int *irq_type,
495 unsigned int *translation)
496 {
497 static int intab[] = { 9, 10, 11, 12, 0, 14, 15, 0 };
498
499 *irq_level = intab[inb(INTDEF(base)) & 0x7];
500 *irq_type = (inb(INTDEF(base)) & 0x8) >> 3;
501 *translation = inb(RESV1(base)) & 0x1;
502 outb(inb(INTDEF(base)) | 0x10, INTDEF(base));
503 }
504
505 static int aha1740_biosparam(struct scsi_device *sdev,
506 struct block_device *dev,
507 sector_t capacity, int* ip)
508 {
509 int size = capacity;
510 int extended = HOSTDATA(sdev->host)->translation;
511
512 DEB(printk("aha1740_biosparam\n"));
513 if (extended && (ip[2] > 1024)) {
514 ip[0] = 255;
515 ip[1] = 63;
516 ip[2] = size / (255 * 63);
517 } else {
518 ip[0] = 64;
519 ip[1] = 32;
520 ip[2] = size >> 11;
521 }
522 return 0;
523 }
524
525 static int aha1740_eh_abort_handler (struct scsi_cmnd *dummy)
526 {
527 /*
528 * From Alan Cox :
529 * The AHA1740 has firmware handled abort/reset handling. The "head in
530 * sand" kernel code is correct for once 8)
531 *
532 * So we define a dummy handler just to keep the kernel SCSI code as
533 * quiet as possible...
534 */
535
536 return SUCCESS;
537 }
538
539 static struct scsi_host_template aha1740_template = {
540 .module = THIS_MODULE,
541 .proc_name = "aha1740",
542 .show_info = aha1740_show_info,
543 .name = "Adaptec 174x (EISA)",
544 .queuecommand = aha1740_queuecommand,
545 .bios_param = aha1740_biosparam,
546 .can_queue = AHA1740_ECBS,
547 .this_id = 7,
548 .sg_tablesize = AHA1740_SCATTER,
549 .eh_abort_handler = aha1740_eh_abort_handler,
550 };
551
552 static int aha1740_probe (struct device *dev)
553 {
554 int slotbase, rc;
555 unsigned int irq_level, irq_type, translation;
556 struct Scsi_Host *shpnt;
557 struct aha1740_hostdata *host;
558 struct eisa_device *edev = to_eisa_device (dev);
559
560 DEB(printk("aha1740_probe: \n"));
561
562 slotbase = edev->base_addr + EISA_VENDOR_ID_OFFSET;
563 if (!request_region(slotbase, SLOTSIZE, "aha1740")) /* See if in use */
564 return -EBUSY;
565 if (!aha1740_test_port(slotbase))
566 goto err_release_region;
567 aha1740_getconfig(slotbase,&irq_level,&irq_type,&translation);
568 if ((inb(G2STAT(slotbase)) &
569 (G2STAT_MBXOUT|G2STAT_BUSY)) != G2STAT_MBXOUT) {
570 /* If the card isn't ready, hard reset it */
571 outb(G2CNTRL_HRST, G2CNTRL(slotbase));
572 outb(0, G2CNTRL(slotbase));
573 }
574 printk(KERN_INFO "Configuring slot %d at IO:%x, IRQ %u (%s)\n",
575 edev->slot, slotbase, irq_level, irq_type ? "edge" : "level");
576 printk(KERN_INFO "aha174x: Extended translation %sabled.\n",
577 translation ? "en" : "dis");
578 shpnt = scsi_host_alloc(&aha1740_template,
579 sizeof(struct aha1740_hostdata));
580 if(shpnt == NULL)
581 goto err_release_region;
582
583 shpnt->base = 0;
584 shpnt->io_port = slotbase;
585 shpnt->n_io_port = SLOTSIZE;
586 shpnt->irq = irq_level;
587 shpnt->dma_channel = 0xff;
588 host = HOSTDATA(shpnt);
589 host->edev = edev;
590 host->translation = translation;
591 host->ecb_dma_addr = dma_map_single (&edev->dev, host->ecb,
592 sizeof (host->ecb),
593 DMA_BIDIRECTIONAL);
594 if (!host->ecb_dma_addr) {
595 printk (KERN_ERR "aha1740_probe: Couldn't map ECB, giving up\n");
596 goto err_host_put;
597 }
598
599 DEB(printk("aha1740_probe: enable interrupt channel %d\n",irq_level));
600 if (request_irq(irq_level,aha1740_intr_handle,irq_type ? 0 : IRQF_SHARED,
601 "aha1740",shpnt)) {
602 printk(KERN_ERR "aha1740_probe: Unable to allocate IRQ %d.\n",
603 irq_level);
604 goto err_unmap;
605 }
606
607 eisa_set_drvdata (edev, shpnt);
608
609 rc = scsi_add_host (shpnt, dev);
610 if (rc)
611 goto err_irq;
612
613 scsi_scan_host (shpnt);
614 return 0;
615
616 err_irq:
617 free_irq(irq_level, shpnt);
618 err_unmap:
619 dma_unmap_single (&edev->dev, host->ecb_dma_addr,
620 sizeof (host->ecb), DMA_BIDIRECTIONAL);
621 err_host_put:
622 scsi_host_put (shpnt);
623 err_release_region:
624 release_region(slotbase, SLOTSIZE);
625
626 return -ENODEV;
627 }
628
629 static int aha1740_remove (struct device *dev)
630 {
631 struct Scsi_Host *shpnt = dev_get_drvdata(dev);
632 struct aha1740_hostdata *host = HOSTDATA (shpnt);
633
634 scsi_remove_host(shpnt);
635
636 free_irq (shpnt->irq, shpnt);
637 dma_unmap_single (dev, host->ecb_dma_addr,
638 sizeof (host->ecb), DMA_BIDIRECTIONAL);
639 release_region (shpnt->io_port, SLOTSIZE);
640
641 scsi_host_put (shpnt);
642
643 return 0;
644 }
645
646 static struct eisa_device_id aha1740_ids[] = {
647 { "ADP0000" }, /* 1740 */
648 { "ADP0001" }, /* 1740A */
649 { "ADP0002" }, /* 1742A */
650 { "ADP0400" }, /* 1744 */
651 { "" }
652 };
653 MODULE_DEVICE_TABLE(eisa, aha1740_ids);
654
655 static struct eisa_driver aha1740_driver = {
656 .id_table = aha1740_ids,
657 .driver = {
658 .name = "aha1740",
659 .probe = aha1740_probe,
660 .remove = aha1740_remove,
661 },
662 };
663
664 static __init int aha1740_init (void)
665 {
666 return eisa_driver_register (&aha1740_driver);
667 }
668
669 static __exit void aha1740_exit (void)
670 {
671 eisa_driver_unregister (&aha1740_driver);
672 }
673
674 module_init (aha1740_init);
675 module_exit (aha1740_exit);
676
677 MODULE_LICENSE("GPL");
Linux with added FPC-III support