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