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