blob: 4f785f254c1f7f7619f25f0beb4a966c4b733ec4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* $Id: aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $
2 * linux/kernel/aha1542.c
3 *
4 * Copyright (C) 1992 Tommy Thorn
5 * Copyright (C) 1993, 1994, 1995 Eric Youngdale
6 *
7 * Modified by Eric Youngdale
8 * Use request_irq and request_dma to help prevent unexpected conflicts
9 * Set up on-board DMA controller, such that we do not have to
10 * have the bios enabled to use the aha1542.
11 * Modified by David Gentzel
12 * Don't call request_dma if dma mask is 0 (for BusLogic BT-445S VL-Bus
13 * controller).
14 * Modified by Matti Aarnio
15 * Accept parameters from LILO cmd-line. -- 1-Oct-94
16 * Modified by Mike McLagan <mike.mclagan@linux.org>
17 * Recognise extended mode on AHA1542CP, different bit than 1542CF
18 * 1-Jan-97
19 * Modified by Bjorn L. Thordarson and Einar Thor Einarsson
20 * Recognize that DMA0 is valid DMA channel -- 13-Jul-98
21 * Modified by Chris Faulhaber <jedgar@fxp.org>
22 * Added module command-line options
23 * 19-Jul-99
Joe Perches726a6452008-02-03 16:36:24 +020024 * Modified by Adam Fritzler
Linus Torvalds1da177e2005-04-16 15:20:36 -070025 * Added proper detection of the AHA-1640 (MCA version of AHA-1540)
26 */
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/module.h>
29#include <linux/interrupt.h>
30#include <linux/kernel.h>
31#include <linux/types.h>
32#include <linux/string.h>
33#include <linux/ioport.h>
34#include <linux/delay.h>
35#include <linux/proc_fs.h>
36#include <linux/init.h>
37#include <linux/spinlock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/isapnp.h>
39#include <linux/blkdev.h>
40#include <linux/mca.h>
41#include <linux/mca-legacy.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090042#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
44#include <asm/dma.h>
45#include <asm/system.h>
46#include <asm/io.h>
47
48#include "scsi.h"
49#include <scsi/scsi_host.h>
50#include "aha1542.h"
51
52#define SCSI_BUF_PA(address) isa_virt_to_bus(address)
Jens Axboe45711f12007-10-22 21:19:53 +020053#define SCSI_SG_PA(sgent) (isa_page_to_bus(sg_page((sgent))) + (sgent)->offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#include<linux/stat.h>
56
57#ifdef DEBUG
58#define DEB(x) x
59#else
60#define DEB(x)
61#endif
62
63/*
64 static const char RCSid[] = "$Header: /usr/src/linux/kernel/blk_drv/scsi/RCS/aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $";
65 */
66
67/* The adaptec can be configured for quite a number of addresses, but
68 I generally do not want the card poking around at random. We allow
69 two addresses - this allows people to use the Adaptec with a Midi
70 card, which also used 0x330 -- can be overridden with LILO! */
71
72#define MAXBOARDS 4 /* Increase this and the sizes of the
73 arrays below, if you need more.. */
74
75/* Boards 3,4 slots are reserved for ISAPnP/MCA scans */
76
77static unsigned int bases[MAXBOARDS] __initdata = {0x330, 0x334, 0, 0};
78
79/* set by aha1542_setup according to the command line; they also may
80 be marked __initdata, but require zero initializers then */
81
82static int setup_called[MAXBOARDS];
83static int setup_buson[MAXBOARDS];
84static int setup_busoff[MAXBOARDS];
85static int setup_dmaspeed[MAXBOARDS] __initdata = { -1, -1, -1, -1 };
86
87/*
88 * LILO/Module params: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]
89 *
90 * Where: <PORTBASE> is any of the valid AHA addresses:
91 * 0x130, 0x134, 0x230, 0x234, 0x330, 0x334
92 * <BUSON> is the time (in microsecs) that AHA spends on the AT-bus
93 * when transferring data. 1542A power-on default is 11us,
94 * valid values are in range: 2..15 (decimal)
95 * <BUSOFF> is the time that AHA spends OFF THE BUS after while
96 * it is transferring data (not to monopolize the bus).
97 * Power-on default is 4us, valid range: 1..64 microseconds.
98 * <DMASPEED> Default is jumper selected (1542A: on the J1),
99 * but experimenter can alter it with this.
100 * Valid values: 5, 6, 7, 8, 10 (MB/s)
101 * Factory default is 5 MB/s.
102 */
103
104#if defined(MODULE)
105static int isapnp = 0;
106static int aha1542[] = {0x330, 11, 4, -1};
107module_param_array(aha1542, int, NULL, 0);
108module_param(isapnp, bool, 0);
109
110static struct isapnp_device_id id_table[] __initdata = {
111 {
112 ISAPNP_ANY_ID, ISAPNP_ANY_ID,
113 ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1542),
114 0
115 },
116 {0}
117};
118
119MODULE_DEVICE_TABLE(isapnp, id_table);
120
121#else
122static int isapnp = 1;
123#endif
124
125#define BIOS_TRANSLATION_1632 0 /* Used by some old 1542A boards */
126#define BIOS_TRANSLATION_6432 1 /* Default case these days */
127#define BIOS_TRANSLATION_25563 2 /* Big disk case */
128
129struct aha1542_hostdata {
130 /* This will effectively start both of them at the first mailbox */
131 int bios_translation; /* Mapping bios uses - for compatibility */
132 int aha1542_last_mbi_used;
133 int aha1542_last_mbo_used;
134 Scsi_Cmnd *SCint[AHA1542_MAILBOXES];
135 struct mailbox mb[2 * AHA1542_MAILBOXES];
136 struct ccb ccb[AHA1542_MAILBOXES];
137};
138
139#define HOSTDATA(host) ((struct aha1542_hostdata *) &host->hostdata)
140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141static DEFINE_SPINLOCK(aha1542_lock);
142
143
144
145#define WAITnexttimeout 3000000
146
147static void setup_mailboxes(int base_io, struct Scsi_Host *shpnt);
148static int aha1542_restart(struct Scsi_Host *shost);
Jeff Garzik87c4d7b2008-04-24 19:45:32 -0400149static void aha1542_intr_handle(struct Scsi_Host *shost);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
151#define aha1542_intr_reset(base) outb(IRST, CONTROL(base))
152
153#define WAIT(port, mask, allof, noneof) \
154 { register int WAITbits; \
155 register int WAITtimeout = WAITnexttimeout; \
156 while (1) { \
157 WAITbits = inb(port) & (mask); \
158 if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
159 break; \
160 if (--WAITtimeout == 0) goto fail; \
161 } \
162 }
163
164/* Similar to WAIT, except we use the udelay call to regulate the
165 amount of time we wait. */
166#define WAITd(port, mask, allof, noneof, timeout) \
167 { register int WAITbits; \
168 register int WAITtimeout = timeout; \
169 while (1) { \
170 WAITbits = inb(port) & (mask); \
171 if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
172 break; \
173 mdelay(1); \
174 if (--WAITtimeout == 0) goto fail; \
175 } \
176 }
177
178static void aha1542_stat(void)
179{
180/* int s = inb(STATUS), i = inb(INTRFLAGS);
181 printk("status=%x intrflags=%x\n", s, i, WAITnexttimeout-WAITtimeout); */
182}
183
184/* This is a bit complicated, but we need to make sure that an interrupt
185 routine does not send something out while we are in the middle of this.
186 Fortunately, it is only at boot time that multi-byte messages
187 are ever sent. */
188static int aha1542_out(unsigned int base, unchar * cmdp, int len)
189{
190 unsigned long flags = 0;
191 int got_lock;
192
193 if (len == 1) {
194 got_lock = 0;
195 while (1 == 1) {
196 WAIT(STATUS(base), CDF, 0, CDF);
197 spin_lock_irqsave(&aha1542_lock, flags);
198 if (inb(STATUS(base)) & CDF) {
199 spin_unlock_irqrestore(&aha1542_lock, flags);
200 continue;
201 }
202 outb(*cmdp, DATA(base));
203 spin_unlock_irqrestore(&aha1542_lock, flags);
204 return 0;
205 }
206 } else {
207 spin_lock_irqsave(&aha1542_lock, flags);
208 got_lock = 1;
209 while (len--) {
210 WAIT(STATUS(base), CDF, 0, CDF);
211 outb(*cmdp++, DATA(base));
212 }
213 spin_unlock_irqrestore(&aha1542_lock, flags);
214 }
215 return 0;
216fail:
217 if (got_lock)
218 spin_unlock_irqrestore(&aha1542_lock, flags);
219 printk(KERN_ERR "aha1542_out failed(%d): ", len + 1);
220 aha1542_stat();
221 return 1;
222}
223
224/* Only used at boot time, so we do not need to worry about latency as much
225 here */
226
227static int __init aha1542_in(unsigned int base, unchar * cmdp, int len)
228{
229 unsigned long flags;
230
231 spin_lock_irqsave(&aha1542_lock, flags);
232 while (len--) {
233 WAIT(STATUS(base), DF, DF, 0);
234 *cmdp++ = inb(DATA(base));
235 }
236 spin_unlock_irqrestore(&aha1542_lock, flags);
237 return 0;
238fail:
239 spin_unlock_irqrestore(&aha1542_lock, flags);
240 printk(KERN_ERR "aha1542_in failed(%d): ", len + 1);
241 aha1542_stat();
242 return 1;
243}
244
245/* Similar to aha1542_in, except that we wait a very short period of time.
246 We use this if we know the board is alive and awake, but we are not sure
247 if the board will respond to the command we are about to send or not */
248static int __init aha1542_in1(unsigned int base, unchar * cmdp, int len)
249{
250 unsigned long flags;
251
252 spin_lock_irqsave(&aha1542_lock, flags);
253 while (len--) {
254 WAITd(STATUS(base), DF, DF, 0, 100);
255 *cmdp++ = inb(DATA(base));
256 }
257 spin_unlock_irqrestore(&aha1542_lock, flags);
258 return 0;
259fail:
260 spin_unlock_irqrestore(&aha1542_lock, flags);
261 return 1;
262}
263
264static int makecode(unsigned hosterr, unsigned scsierr)
265{
266 switch (hosterr) {
267 case 0x0:
268 case 0xa: /* Linked command complete without error and linked normally */
269 case 0xb: /* Linked command complete without error, interrupt generated */
270 hosterr = 0;
271 break;
272
273 case 0x11: /* Selection time out-The initiator selection or target
274 reselection was not complete within the SCSI Time out period */
275 hosterr = DID_TIME_OUT;
276 break;
277
278 case 0x12: /* Data overrun/underrun-The target attempted to transfer more data
279 than was allocated by the Data Length field or the sum of the
280 Scatter / Gather Data Length fields. */
281
282 case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
283
284 case 0x15: /* MBO command was not 00, 01 or 02-The first byte of the CB was
285 invalid. This usually indicates a software failure. */
286
287 case 0x16: /* Invalid CCB Operation Code-The first byte of the CCB was invalid.
288 This usually indicates a software failure. */
289
290 case 0x17: /* Linked CCB does not have the same LUN-A subsequent CCB of a set
291 of linked CCB's does not specify the same logical unit number as
292 the first. */
293 case 0x18: /* Invalid Target Direction received from Host-The direction of a
294 Target Mode CCB was invalid. */
295
296 case 0x19: /* Duplicate CCB Received in Target Mode-More than once CCB was
297 received to service data transfer between the same target LUN
298 and initiator SCSI ID in the same direction. */
299
300 case 0x1a: /* Invalid CCB or Segment List Parameter-A segment list with a zero
301 length segment or invalid segment list boundaries was received.
302 A CCB parameter was invalid. */
303 DEB(printk("Aha1542: %x %x\n", hosterr, scsierr));
304 hosterr = DID_ERROR; /* Couldn't find any better */
305 break;
306
307 case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus
308 phase sequence was requested by the target. The host adapter
309 will generate a SCSI Reset Condition, notifying the host with
310 a SCRD interrupt */
311 hosterr = DID_RESET;
312 break;
313 default:
314 printk(KERN_ERR "aha1542: makecode: unknown hoststatus %x\n", hosterr);
315 break;
316 }
317 return scsierr | (hosterr << 16);
318}
319
320static int __init aha1542_test_port(int bse, struct Scsi_Host *shpnt)
321{
322 unchar inquiry_cmd[] = {CMD_INQUIRY};
323 unchar inquiry_result[4];
324 unchar *cmdp;
325 int len;
326 volatile int debug = 0;
327
328 /* Quick and dirty test for presence of the card. */
329 if (inb(STATUS(bse)) == 0xff)
330 return 0;
331
332 /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */
333
334 /* DEB(printk("aha1542_test_port called \n")); */
335
336 /* In case some other card was probing here, reset interrupts */
337 aha1542_intr_reset(bse); /* reset interrupts, so they don't block */
338
339 outb(SRST | IRST /*|SCRST */ , CONTROL(bse));
340
341 mdelay(20); /* Wait a little bit for things to settle down. */
342
343 debug = 1;
344 /* Expect INIT and IDLE, any of the others are bad */
345 WAIT(STATUS(bse), STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
346
347 debug = 2;
348 /* Shouldn't have generated any interrupts during reset */
349 if (inb(INTRFLAGS(bse)) & INTRMASK)
350 goto fail;
351
352
353 /* Perform a host adapter inquiry instead so we do not need to set
354 up the mailboxes ahead of time */
355
356 aha1542_out(bse, inquiry_cmd, 1);
357
358 debug = 3;
359 len = 4;
360 cmdp = &inquiry_result[0];
361
362 while (len--) {
363 WAIT(STATUS(bse), DF, DF, 0);
364 *cmdp++ = inb(DATA(bse));
365 }
366
367 debug = 8;
368 /* Reading port should reset DF */
369 if (inb(STATUS(bse)) & DF)
370 goto fail;
371
372 debug = 9;
373 /* When HACC, command is completed, and we're though testing */
374 WAIT(INTRFLAGS(bse), HACC, HACC, 0);
375 /* now initialize adapter */
376
377 debug = 10;
378 /* Clear interrupts */
379 outb(IRST, CONTROL(bse));
380
381 debug = 11;
382
383 return debug; /* 1 = ok */
384fail:
385 return 0; /* 0 = not ok */
386}
387
388/* A quick wrapper for do_aha1542_intr_handle to grab the spin lock */
Jeff Garzik87c4d7b2008-04-24 19:45:32 -0400389static irqreturn_t do_aha1542_intr_handle(int dummy, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390{
391 unsigned long flags;
Jeff Garzik87c4d7b2008-04-24 19:45:32 -0400392 struct Scsi_Host *shost = dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
394 spin_lock_irqsave(shost->host_lock, flags);
Jeff Garzik87c4d7b2008-04-24 19:45:32 -0400395 aha1542_intr_handle(shost);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 spin_unlock_irqrestore(shost->host_lock, flags);
397 return IRQ_HANDLED;
398}
399
400/* A "high" level interrupt handler */
Jeff Garzik87c4d7b2008-04-24 19:45:32 -0400401static void aha1542_intr_handle(struct Scsi_Host *shost)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402{
403 void (*my_done) (Scsi_Cmnd *) = NULL;
404 int errstatus, mbi, mbo, mbistatus;
405 int number_serviced;
406 unsigned long flags;
407 Scsi_Cmnd *SCtmp;
408 int flag;
409 int needs_restart;
410 struct mailbox *mb;
411 struct ccb *ccb;
412
413 mb = HOSTDATA(shost)->mb;
414 ccb = HOSTDATA(shost)->ccb;
415
416#ifdef DEBUG
417 {
418 flag = inb(INTRFLAGS(shost->io_port));
419 printk(KERN_DEBUG "aha1542_intr_handle: ");
420 if (!(flag & ANYINTR))
421 printk("no interrupt?");
422 if (flag & MBIF)
423 printk("MBIF ");
424 if (flag & MBOA)
425 printk("MBOF ");
426 if (flag & HACC)
427 printk("HACC ");
428 if (flag & SCRD)
429 printk("SCRD ");
430 printk("status %02x\n", inb(STATUS(shost->io_port)));
431 };
432#endif
433 number_serviced = 0;
434 needs_restart = 0;
435
436 while (1 == 1) {
437 flag = inb(INTRFLAGS(shost->io_port));
438
439 /* Check for unusual interrupts. If any of these happen, we should
440 probably do something special, but for now just printing a message
441 is sufficient. A SCSI reset detected is something that we really
442 need to deal with in some way. */
443 if (flag & ~MBIF) {
444 if (flag & MBOA)
445 printk("MBOF ");
446 if (flag & HACC)
447 printk("HACC ");
448 if (flag & SCRD) {
449 needs_restart = 1;
450 printk("SCRD ");
451 }
452 }
453 aha1542_intr_reset(shost->io_port);
454
455 spin_lock_irqsave(&aha1542_lock, flags);
456 mbi = HOSTDATA(shost)->aha1542_last_mbi_used + 1;
457 if (mbi >= 2 * AHA1542_MAILBOXES)
458 mbi = AHA1542_MAILBOXES;
459
460 do {
461 if (mb[mbi].status != 0)
462 break;
463 mbi++;
464 if (mbi >= 2 * AHA1542_MAILBOXES)
465 mbi = AHA1542_MAILBOXES;
466 } while (mbi != HOSTDATA(shost)->aha1542_last_mbi_used);
467
468 if (mb[mbi].status == 0) {
469 spin_unlock_irqrestore(&aha1542_lock, flags);
470 /* Hmm, no mail. Must have read it the last time around */
471 if (!number_serviced && !needs_restart)
472 printk(KERN_WARNING "aha1542.c: interrupt received, but no mail.\n");
473 /* We detected a reset. Restart all pending commands for
474 devices that use the hard reset option */
475 if (needs_restart)
476 aha1542_restart(shost);
477 return;
478 };
479
480 mbo = (scsi2int(mb[mbi].ccbptr) - (SCSI_BUF_PA(&ccb[0]))) / sizeof(struct ccb);
481 mbistatus = mb[mbi].status;
482 mb[mbi].status = 0;
483 HOSTDATA(shost)->aha1542_last_mbi_used = mbi;
484 spin_unlock_irqrestore(&aha1542_lock, flags);
485
486#ifdef DEBUG
487 {
488 if (ccb[mbo].tarstat | ccb[mbo].hastat)
489 printk(KERN_DEBUG "aha1542_command: returning %x (status %d)\n",
490 ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status);
491 };
492#endif
493
494 if (mbistatus == 3)
495 continue; /* Aborted command not found */
496
497#ifdef DEBUG
498 printk(KERN_DEBUG "...done %d %d\n", mbo, mbi);
499#endif
500
501 SCtmp = HOSTDATA(shost)->SCint[mbo];
502
503 if (!SCtmp || !SCtmp->scsi_done) {
504 printk(KERN_WARNING "aha1542_intr_handle: Unexpected interrupt\n");
505 printk(KERN_WARNING "tarstat=%x, hastat=%x idlun=%x ccb#=%d \n", ccb[mbo].tarstat,
506 ccb[mbo].hastat, ccb[mbo].idlun, mbo);
507 return;
508 }
509 my_done = SCtmp->scsi_done;
Jesper Juhlc9475cb2005-11-07 01:01:26 -0800510 kfree(SCtmp->host_scribble);
511 SCtmp->host_scribble = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 /* Fetch the sense data, and tuck it away, in the required slot. The
513 Adaptec automatically fetches it, and there is no guarantee that
514 we will still have it in the cdb when we come back */
515 if (ccb[mbo].tarstat == 2)
516 memcpy(SCtmp->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen],
FUJITA Tomonorib80ca4f2008-01-13 15:46:13 +0900517 SCSI_SENSE_BUFFERSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
519
520 /* is there mail :-) */
521
522 /* more error checking left out here */
523 if (mbistatus != 1)
524 /* This is surely wrong, but I don't know what's right */
525 errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
526 else
527 errstatus = 0;
528
529#ifdef DEBUG
530 if (errstatus)
531 printk(KERN_DEBUG "(aha1542 error:%x %x %x) ", errstatus,
532 ccb[mbo].hastat, ccb[mbo].tarstat);
533#endif
534
535 if (ccb[mbo].tarstat == 2) {
536#ifdef DEBUG
537 int i;
538#endif
539 DEB(printk("aha1542_intr_handle: sense:"));
540#ifdef DEBUG
541 for (i = 0; i < 12; i++)
542 printk("%02x ", ccb[mbo].cdb[ccb[mbo].cdblen + i]);
543 printk("\n");
544#endif
545 /*
546 DEB(printk("aha1542_intr_handle: buf:"));
547 for (i = 0; i < bufflen; i++)
548 printk("%02x ", ((unchar *)buff)[i]);
549 printk("\n");
550 */
551 }
552 DEB(if (errstatus) printk("aha1542_intr_handle: returning %6x\n", errstatus));
553 SCtmp->result = errstatus;
554 HOSTDATA(shost)->SCint[mbo] = NULL; /* This effectively frees up the mailbox slot, as
555 far as queuecommand is concerned */
556 my_done(SCtmp);
557 number_serviced++;
558 };
559}
560
561static int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
562{
563 unchar ahacmd = CMD_START_SCSI;
564 unchar direction;
565 unchar *cmd = (unchar *) SCpnt->cmnd;
566 unchar target = SCpnt->device->id;
567 unchar lun = SCpnt->device->lun;
568 unsigned long flags;
Boaz Harroshfc3fdfc2007-09-09 21:02:45 +0300569 int bufflen = scsi_bufflen(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 int mbo;
571 struct mailbox *mb;
572 struct ccb *ccb;
573
574 DEB(int i);
575
576 mb = HOSTDATA(SCpnt->device->host)->mb;
577 ccb = HOSTDATA(SCpnt->device->host)->ccb;
578
579 DEB(if (target > 1) {
580 SCpnt->result = DID_TIME_OUT << 16;
581 done(SCpnt); return 0;
582 }
583 );
584
585 if (*cmd == REQUEST_SENSE) {
586 /* Don't do the command - we have the sense data already */
587#if 0
588 /* scsi_request_sense() provides a buffer of size 256,
589 so there is no reason to expect equality */
FUJITA Tomonorib80ca4f2008-01-13 15:46:13 +0900590 if (bufflen != SCSI_SENSE_BUFFERSIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 printk(KERN_CRIT "aha1542: Wrong buffer length supplied "
592 "for request sense (%d)\n", bufflen);
593#endif
594 SCpnt->result = 0;
595 done(SCpnt);
596 return 0;
597 }
598#ifdef DEBUG
599 if (*cmd == READ_10 || *cmd == WRITE_10)
600 i = xscsi2int(cmd + 2);
601 else if (*cmd == READ_6 || *cmd == WRITE_6)
602 i = scsi2int(cmd + 2);
603 else
604 i = -1;
605 if (done)
606 printk(KERN_DEBUG "aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
607 else
608 printk(KERN_DEBUG "aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
609 aha1542_stat();
610 printk(KERN_DEBUG "aha1542_queuecommand: dumping scsi cmd:");
611 for (i = 0; i < SCpnt->cmd_len; i++)
612 printk("%02x ", cmd[i]);
613 printk("\n");
614 if (*cmd == WRITE_10 || *cmd == WRITE_6)
615 return 0; /* we are still testing, so *don't* write */
616#endif
617 /* Use the outgoing mailboxes in a round-robin fashion, because this
618 is how the host adapter will scan for them */
619
620 spin_lock_irqsave(&aha1542_lock, flags);
621 mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
622 if (mbo >= AHA1542_MAILBOXES)
623 mbo = 0;
624
625 do {
626 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
627 break;
628 mbo++;
629 if (mbo >= AHA1542_MAILBOXES)
630 mbo = 0;
631 } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
632
633 if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
634 panic("Unable to find empty mailbox for aha1542.\n");
635
636 HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt; /* This will effectively prevent someone else from
637 screwing with this cdb. */
638
639 HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
640 spin_unlock_irqrestore(&aha1542_lock, flags);
641
642#ifdef DEBUG
643 printk(KERN_DEBUG "Sending command (%d %x)...", mbo, done);
644#endif
645
646 any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo])); /* This gets trashed for some reason */
647
648 memset(&ccb[mbo], 0, sizeof(struct ccb));
649
650 ccb[mbo].cdblen = SCpnt->cmd_len;
651
652 direction = 0;
653 if (*cmd == READ_10 || *cmd == READ_6)
654 direction = 8;
655 else if (*cmd == WRITE_10 || *cmd == WRITE_6)
656 direction = 16;
657
658 memcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
659
Boaz Harroshfc3fdfc2007-09-09 21:02:45 +0300660 if (bufflen) {
Jens Axboe51cf2242007-07-16 10:00:31 +0200661 struct scatterlist *sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 struct chain *cptr;
663#ifdef DEBUG
664 unsigned char *ptr;
665#endif
Boaz Harroshfc3fdfc2007-09-09 21:02:45 +0300666 int i, sg_count = scsi_sg_count(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 ccb[mbo].op = 2; /* SCSI Initiator Command w/scatter-gather */
Boaz Harroshfc3fdfc2007-09-09 21:02:45 +0300668 SCpnt->host_scribble = kmalloc(sizeof(*cptr)*sg_count,
669 GFP_KERNEL | GFP_DMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 cptr = (struct chain *) SCpnt->host_scribble;
671 if (cptr == NULL) {
672 /* free the claimed mailbox slot */
673 HOSTDATA(SCpnt->device->host)->SCint[mbo] = NULL;
674 return SCSI_MLQUEUE_HOST_BUSY;
675 }
Boaz Harroshfc3fdfc2007-09-09 21:02:45 +0300676 scsi_for_each_sg(SCpnt, sg, sg_count, i) {
Jens Axboe51cf2242007-07-16 10:00:31 +0200677 any2scsi(cptr[i].dataptr, SCSI_SG_PA(sg));
Jens Axboe51cf2242007-07-16 10:00:31 +0200678 any2scsi(cptr[i].datalen, sg->length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 };
Boaz Harroshfc3fdfc2007-09-09 21:02:45 +0300680 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(cptr));
682#ifdef DEBUG
683 printk("cptr %x: ", cptr);
684 ptr = (unsigned char *) cptr;
685 for (i = 0; i < 18; i++)
686 printk("%02x ", ptr[i]);
687#endif
688 } else {
689 ccb[mbo].op = 0; /* SCSI Initiator Command */
690 SCpnt->host_scribble = NULL;
Boaz Harroshfc3fdfc2007-09-09 21:02:45 +0300691 any2scsi(ccb[mbo].datalen, 0);
692 any2scsi(ccb[mbo].dataptr, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 };
694 ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7); /*SCSI Target Id */
695 ccb[mbo].rsalen = 16;
696 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
697 ccb[mbo].commlinkid = 0;
698
699#ifdef DEBUG
700 {
701 int i;
702 printk(KERN_DEBUG "aha1542_command: sending.. ");
703 for (i = 0; i < sizeof(ccb[mbo]) - 10; i++)
704 printk("%02x ", ((unchar *) & ccb[mbo])[i]);
705 };
706#endif
707
708 if (done) {
709 DEB(printk("aha1542_queuecommand: now waiting for interrupt ");
710 aha1542_stat());
711 SCpnt->scsi_done = done;
712 mb[mbo].status = 1;
713 aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1); /* start scsi command */
714 DEB(aha1542_stat());
715 } else
716 printk("aha1542_queuecommand: done can't be NULL\n");
717
718 return 0;
719}
720
721/* Initialize mailboxes */
722static void setup_mailboxes(int bse, struct Scsi_Host *shpnt)
723{
724 int i;
725 struct mailbox *mb;
726 struct ccb *ccb;
727
728 unchar cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
729
730 mb = HOSTDATA(shpnt)->mb;
731 ccb = HOSTDATA(shpnt)->ccb;
732
733 for (i = 0; i < AHA1542_MAILBOXES; i++) {
734 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
735 any2scsi(mb[i].ccbptr, SCSI_BUF_PA(&ccb[i]));
736 };
737 aha1542_intr_reset(bse); /* reset interrupts, so they don't block */
738 any2scsi((cmd + 2), SCSI_BUF_PA(mb));
739 aha1542_out(bse, cmd, 5);
740 WAIT(INTRFLAGS(bse), INTRMASK, HACC, 0);
741 while (0) {
742fail:
743 printk(KERN_ERR "aha1542_detect: failed setting up mailboxes\n");
744 }
745 aha1542_intr_reset(bse);
746}
747
748static int __init aha1542_getconfig(int base_io, unsigned char *irq_level, unsigned char *dma_chan, unsigned char *scsi_id)
749{
750 unchar inquiry_cmd[] = {CMD_RETCONF};
751 unchar inquiry_result[3];
752 int i;
753 i = inb(STATUS(base_io));
754 if (i & DF) {
755 i = inb(DATA(base_io));
756 };
757 aha1542_out(base_io, inquiry_cmd, 1);
758 aha1542_in(base_io, inquiry_result, 3);
759 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
760 while (0) {
761fail:
762 printk(KERN_ERR "aha1542_detect: query board settings\n");
763 }
764 aha1542_intr_reset(base_io);
765 switch (inquiry_result[0]) {
766 case 0x80:
767 *dma_chan = 7;
768 break;
769 case 0x40:
770 *dma_chan = 6;
771 break;
772 case 0x20:
773 *dma_chan = 5;
774 break;
775 case 0x01:
776 *dma_chan = 0;
777 break;
778 case 0:
779 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
780 Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
781 *dma_chan = 0xFF;
782 break;
783 default:
784 printk(KERN_ERR "Unable to determine Adaptec DMA priority. Disabling board\n");
785 return -1;
786 };
787 switch (inquiry_result[1]) {
788 case 0x40:
789 *irq_level = 15;
790 break;
791 case 0x20:
792 *irq_level = 14;
793 break;
794 case 0x8:
795 *irq_level = 12;
796 break;
797 case 0x4:
798 *irq_level = 11;
799 break;
800 case 0x2:
801 *irq_level = 10;
802 break;
803 case 0x1:
804 *irq_level = 9;
805 break;
806 default:
807 printk(KERN_ERR "Unable to determine Adaptec IRQ level. Disabling board\n");
808 return -1;
809 };
810 *scsi_id = inquiry_result[2] & 7;
811 return 0;
812}
813
814/* This function should only be called for 1542C boards - we can detect
815 the special firmware settings and unlock the board */
816
817static int __init aha1542_mbenable(int base)
818{
819 static unchar mbenable_cmd[3];
820 static unchar mbenable_result[2];
821 int retval;
822
823 retval = BIOS_TRANSLATION_6432;
824
825 mbenable_cmd[0] = CMD_EXTBIOS;
826 aha1542_out(base, mbenable_cmd, 1);
827 if (aha1542_in1(base, mbenable_result, 2))
828 return retval;
829 WAITd(INTRFLAGS(base), INTRMASK, HACC, 0, 100);
830 aha1542_intr_reset(base);
831
832 if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
833 mbenable_cmd[0] = CMD_MBENABLE;
834 mbenable_cmd[1] = 0;
835 mbenable_cmd[2] = mbenable_result[1];
836
837 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
838 retval = BIOS_TRANSLATION_25563;
839
840 aha1542_out(base, mbenable_cmd, 3);
841 WAIT(INTRFLAGS(base), INTRMASK, HACC, 0);
842 };
843 while (0) {
844fail:
845 printk(KERN_ERR "aha1542_mbenable: Mailbox init failed\n");
846 }
847 aha1542_intr_reset(base);
848 return retval;
849}
850
851/* Query the board to find out if it is a 1542 or a 1740, or whatever. */
852static int __init aha1542_query(int base_io, int *transl)
853{
854 unchar inquiry_cmd[] = {CMD_INQUIRY};
855 unchar inquiry_result[4];
856 int i;
857 i = inb(STATUS(base_io));
858 if (i & DF) {
859 i = inb(DATA(base_io));
860 };
861 aha1542_out(base_io, inquiry_cmd, 1);
862 aha1542_in(base_io, inquiry_result, 4);
863 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
864 while (0) {
865fail:
866 printk(KERN_ERR "aha1542_detect: query card type\n");
867 }
868 aha1542_intr_reset(base_io);
869
870 *transl = BIOS_TRANSLATION_6432; /* Default case */
871
872 /* For an AHA1740 series board, we ignore the board since there is a
873 hardware bug which can lead to wrong blocks being returned if the board
874 is operating in the 1542 emulation mode. Since there is an extended mode
875 driver, we simply ignore the board and let the 1740 driver pick it up.
876 */
877
878 if (inquiry_result[0] == 0x43) {
879 printk(KERN_INFO "aha1542.c: Emulation mode not supported for AHA 174N hardware.\n");
880 return 1;
881 };
882
883 /* Always call this - boards that do not support extended bios translation
884 will ignore the command, and we will set the proper default */
885
886 *transl = aha1542_mbenable(base_io);
887
888 return 0;
889}
890
891#ifndef MODULE
892static char *setup_str[MAXBOARDS] __initdata;
893static int setup_idx = 0;
894
895static void __init aha1542_setup(char *str, int *ints)
896{
897 const char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
898 int setup_portbase;
899
900 if (setup_idx >= MAXBOARDS) {
901 printk(KERN_ERR "aha1542: aha1542_setup called too many times! Bad LILO params ?\n");
902 printk(KERN_ERR " Entryline 1: %s\n", setup_str[0]);
903 printk(KERN_ERR " Entryline 2: %s\n", setup_str[1]);
904 printk(KERN_ERR " This line: %s\n", str);
905 return;
906 }
907 if (ints[0] < 1 || ints[0] > 4) {
908 printk(KERN_ERR "aha1542: %s\n", str);
909 printk(ahausage);
910 printk(KERN_ERR "aha1542: Wrong parameters may cause system malfunction.. We try anyway..\n");
911 }
912 setup_called[setup_idx] = ints[0];
913 setup_str[setup_idx] = str;
914
915 setup_portbase = ints[0] >= 1 ? ints[1] : 0; /* Preserve the default value.. */
916 setup_buson[setup_idx] = ints[0] >= 2 ? ints[2] : 7;
917 setup_busoff[setup_idx] = ints[0] >= 3 ? ints[3] : 5;
918 if (ints[0] >= 4)
919 {
920 int atbt = -1;
921 switch (ints[4]) {
922 case 5:
923 atbt = 0x00;
924 break;
925 case 6:
926 atbt = 0x04;
927 break;
928 case 7:
929 atbt = 0x01;
930 break;
931 case 8:
932 atbt = 0x02;
933 break;
934 case 10:
935 atbt = 0x03;
936 break;
937 default:
938 printk(KERN_ERR "aha1542: %s\n", str);
939 printk(ahausage);
940 printk(KERN_ERR "aha1542: Valid values for DMASPEED are 5-8, 10 MB/s. Using jumper defaults.\n");
941 break;
942 }
943 setup_dmaspeed[setup_idx] = atbt;
944 }
945 if (setup_portbase != 0)
946 bases[setup_idx] = setup_portbase;
947
948 ++setup_idx;
949}
950
951static int __init do_setup(char *str)
952{
953 int ints[5];
954
955 int count=setup_idx;
956
Tobias Klauser6391a112006-06-08 22:23:48 -0700957 get_options(str, ARRAY_SIZE(ints), ints);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 aha1542_setup(str,ints);
959
960 return count<setup_idx;
961}
962
963__setup("aha1542=",do_setup);
964#endif
965
966/* return non-zero on detection */
Christoph Hellwigd0be4a7d2005-10-31 18:31:40 +0100967static int __init aha1542_detect(struct scsi_host_template * tpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968{
969 unsigned char dma_chan;
970 unsigned char irq_level;
971 unsigned char scsi_id;
972 unsigned long flags;
973 unsigned int base_io;
974 int trans;
975 struct Scsi_Host *shpnt = NULL;
976 int count = 0;
977 int indx;
978
979 DEB(printk("aha1542_detect: \n"));
980
981 tpnt->proc_name = "aha1542";
982
983#ifdef MODULE
984 bases[0] = aha1542[0];
985 setup_buson[0] = aha1542[1];
986 setup_busoff[0] = aha1542[2];
987 {
988 int atbt = -1;
989 switch (aha1542[3]) {
990 case 5:
991 atbt = 0x00;
992 break;
993 case 6:
994 atbt = 0x04;
995 break;
996 case 7:
997 atbt = 0x01;
998 break;
999 case 8:
1000 atbt = 0x02;
1001 break;
1002 case 10:
1003 atbt = 0x03;
1004 break;
1005 };
1006 setup_dmaspeed[0] = atbt;
1007 }
1008#endif
1009
1010 /*
1011 * Find MicroChannel cards (AHA1640)
1012 */
1013#ifdef CONFIG_MCA_LEGACY
1014 if(MCA_bus) {
1015 int slot = 0;
1016 int pos = 0;
1017
Tobias Klauser6391a112006-06-08 22:23:48 -07001018 for (indx = 0; (slot != MCA_NOTFOUND) && (indx < ARRAY_SIZE(bases)); indx++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019
1020 if (bases[indx])
1021 continue;
1022
1023 /* Detect only AHA-1640 cards -- MCA ID 0F1F */
1024 slot = mca_find_unused_adapter(0x0f1f, slot);
1025 if (slot == MCA_NOTFOUND)
1026 break;
1027
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 /* Found one */
1029 pos = mca_read_stored_pos(slot, 3);
Tobias Klauser6391a112006-06-08 22:23:48 -07001030
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 /* Decode address */
1032 if (pos & 0x80) {
1033 if (pos & 0x02) {
1034 if (pos & 0x01)
1035 bases[indx] = 0x334;
1036 else
1037 bases[indx] = 0x234;
1038 } else {
1039 if (pos & 0x01)
1040 bases[indx] = 0x134;
1041 }
1042 } else {
1043 if (pos & 0x02) {
1044 if (pos & 0x01)
1045 bases[indx] = 0x330;
1046 else
1047 bases[indx] = 0x230;
1048 } else {
1049 if (pos & 0x01)
1050 bases[indx] = 0x130;
1051 }
1052 }
1053
1054 /* No need to decode IRQ and Arb level -- those are
1055 * read off the card later.
1056 */
1057 printk(KERN_INFO "Found an AHA-1640 in MCA slot %d, I/O 0x%04x\n", slot, bases[indx]);
1058
1059 mca_set_adapter_name(slot, "Adapter AHA-1640");
1060 mca_set_adapter_procfn(slot, NULL, NULL);
1061 mca_mark_as_used(slot);
Tobias Klauser6391a112006-06-08 22:23:48 -07001062
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 /* Go on */
1064 slot++;
1065 }
Tobias Klauser6391a112006-06-08 22:23:48 -07001066
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 }
1068#endif
1069
1070 /*
1071 * Hunt for ISA Plug'n'Pray Adaptecs (AHA1535)
1072 */
Tobias Klauser6391a112006-06-08 22:23:48 -07001073
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 if(isapnp)
1075 {
1076 struct pnp_dev *pdev = NULL;
Tobias Klauser6391a112006-06-08 22:23:48 -07001077 for(indx = 0; indx < ARRAY_SIZE(bases); indx++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 if(bases[indx])
1079 continue;
1080 pdev = pnp_find_dev(NULL, ISAPNP_VENDOR('A', 'D', 'P'),
1081 ISAPNP_FUNCTION(0x1542), pdev);
1082 if(pdev==NULL)
1083 break;
1084 /*
1085 * Activate the PnP card
1086 */
Tobias Klauser6391a112006-06-08 22:23:48 -07001087
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 if(pnp_device_attach(pdev)<0)
1089 continue;
Tobias Klauser6391a112006-06-08 22:23:48 -07001090
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 if(pnp_activate_dev(pdev)<0) {
1092 pnp_device_detach(pdev);
1093 continue;
1094 }
Tobias Klauser6391a112006-06-08 22:23:48 -07001095
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 if(!pnp_port_valid(pdev, 0)) {
1097 pnp_device_detach(pdev);
1098 continue;
1099 }
Tobias Klauser6391a112006-06-08 22:23:48 -07001100
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 bases[indx] = pnp_port_start(pdev, 0);
Tobias Klauser6391a112006-06-08 22:23:48 -07001102
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 /* The card can be queried for its DMA, we have
1104 the DMA set up that is enough */
Tobias Klauser6391a112006-06-08 22:23:48 -07001105
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 printk(KERN_INFO "ISAPnP found an AHA1535 at I/O 0x%03X\n", bases[indx]);
1107 }
1108 }
Tobias Klauser6391a112006-06-08 22:23:48 -07001109 for (indx = 0; indx < ARRAY_SIZE(bases); indx++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 if (bases[indx] != 0 && request_region(bases[indx], 4, "aha1542")) {
1111 shpnt = scsi_register(tpnt,
1112 sizeof(struct aha1542_hostdata));
1113
1114 if(shpnt==NULL) {
1115 release_region(bases[indx], 4);
1116 continue;
1117 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 if (!aha1542_test_port(bases[indx], shpnt))
1119 goto unregister;
1120
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 base_io = bases[indx];
1122
1123 /* Set the Bus on/off-times as not to ruin floppy performance */
1124 {
1125 unchar oncmd[] = {CMD_BUSON_TIME, 7};
1126 unchar offcmd[] = {CMD_BUSOFF_TIME, 5};
1127
1128 if (setup_called[indx]) {
1129 oncmd[1] = setup_buson[indx];
1130 offcmd[1] = setup_busoff[indx];
1131 }
1132 aha1542_intr_reset(base_io);
1133 aha1542_out(base_io, oncmd, 2);
1134 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1135 aha1542_intr_reset(base_io);
1136 aha1542_out(base_io, offcmd, 2);
1137 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1138 if (setup_dmaspeed[indx] >= 0) {
1139 unchar dmacmd[] = {CMD_DMASPEED, 0};
1140 dmacmd[1] = setup_dmaspeed[indx];
1141 aha1542_intr_reset(base_io);
1142 aha1542_out(base_io, dmacmd, 2);
1143 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1144 }
1145 while (0) {
1146fail:
1147 printk(KERN_ERR "aha1542_detect: setting bus on/off-time failed\n");
1148 }
1149 aha1542_intr_reset(base_io);
1150 }
1151 if (aha1542_query(base_io, &trans))
1152 goto unregister;
1153
1154 if (aha1542_getconfig(base_io, &irq_level, &dma_chan, &scsi_id) == -1)
1155 goto unregister;
1156
1157 printk(KERN_INFO "Configuring Adaptec (SCSI-ID %d) at IO:%x, IRQ %d", scsi_id, base_io, irq_level);
1158 if (dma_chan != 0xFF)
1159 printk(", DMA priority %d", dma_chan);
1160 printk("\n");
1161
1162 DEB(aha1542_stat());
1163 setup_mailboxes(base_io, shpnt);
1164
1165 DEB(aha1542_stat());
1166
1167 DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level));
1168 spin_lock_irqsave(&aha1542_lock, flags);
Jeff Garzik87c4d7b2008-04-24 19:45:32 -04001169 if (request_irq(irq_level, do_aha1542_intr_handle, 0,
1170 "aha1542", shpnt)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 printk(KERN_ERR "Unable to allocate IRQ for adaptec controller.\n");
1172 spin_unlock_irqrestore(&aha1542_lock, flags);
1173 goto unregister;
1174 }
1175 if (dma_chan != 0xFF) {
1176 if (request_dma(dma_chan, "aha1542")) {
1177 printk(KERN_ERR "Unable to allocate DMA channel for Adaptec.\n");
Jeff Garzik87c4d7b2008-04-24 19:45:32 -04001178 free_irq(irq_level, shpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 spin_unlock_irqrestore(&aha1542_lock, flags);
1180 goto unregister;
1181 }
1182 if (dma_chan == 0 || dma_chan >= 5) {
1183 set_dma_mode(dma_chan, DMA_MODE_CASCADE);
1184 enable_dma(dma_chan);
1185 }
1186 }
Jeff Garzik87c4d7b2008-04-24 19:45:32 -04001187
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 shpnt->this_id = scsi_id;
1189 shpnt->unique_id = base_io;
1190 shpnt->io_port = base_io;
1191 shpnt->n_io_port = 4; /* Number of bytes of I/O space used */
1192 shpnt->dma_channel = dma_chan;
1193 shpnt->irq = irq_level;
1194 HOSTDATA(shpnt)->bios_translation = trans;
1195 if (trans == BIOS_TRANSLATION_25563)
1196 printk(KERN_INFO "aha1542.c: Using extended bios translation\n");
1197 HOSTDATA(shpnt)->aha1542_last_mbi_used = (2 * AHA1542_MAILBOXES - 1);
1198 HOSTDATA(shpnt)->aha1542_last_mbo_used = (AHA1542_MAILBOXES - 1);
1199 memset(HOSTDATA(shpnt)->SCint, 0, sizeof(HOSTDATA(shpnt)->SCint));
1200 spin_unlock_irqrestore(&aha1542_lock, flags);
1201#if 0
1202 DEB(printk(" *** READ CAPACITY ***\n"));
1203
1204 {
1205 unchar buf[8];
1206 static unchar cmd[] = { READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1207 int i;
1208
1209 for (i = 0; i < sizeof(buf); ++i)
1210 buf[i] = 0x87;
1211 for (i = 0; i < 2; ++i)
1212 if (!aha1542_command(i, cmd, buf, sizeof(buf))) {
1213 printk(KERN_DEBUG "aha_detect: LU %d sector_size %d device_size %d\n",
1214 i, xscsi2int(buf + 4), xscsi2int(buf));
1215 }
1216 }
1217
1218 DEB(printk(" *** NOW RUNNING MY OWN TEST *** \n"));
1219
1220 for (i = 0; i < 4; ++i) {
1221 unsigned char cmd[10];
1222 static buffer[512];
1223
1224 cmd[0] = READ_10;
1225 cmd[1] = 0;
1226 xany2scsi(cmd + 2, i);
1227 cmd[6] = 0;
1228 cmd[7] = 0;
1229 cmd[8] = 1;
1230 cmd[9] = 0;
1231 aha1542_command(0, cmd, buffer, 512);
1232 }
1233#endif
1234 count++;
1235 continue;
1236unregister:
1237 release_region(bases[indx], 4);
1238 scsi_unregister(shpnt);
1239 continue;
1240
1241 };
1242
1243 return count;
1244}
1245
1246static int aha1542_release(struct Scsi_Host *shost)
1247{
1248 if (shost->irq)
Jeff Garzik87c4d7b2008-04-24 19:45:32 -04001249 free_irq(shost->irq, shost);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 if (shost->dma_channel != 0xff)
1251 free_dma(shost->dma_channel);
1252 if (shost->io_port && shost->n_io_port)
1253 release_region(shost->io_port, shost->n_io_port);
1254 scsi_unregister(shost);
1255 return 0;
1256}
1257
1258static int aha1542_restart(struct Scsi_Host *shost)
1259{
1260 int i;
1261 int count = 0;
1262#if 0
1263 unchar ahacmd = CMD_START_SCSI;
1264#endif
1265
1266 for (i = 0; i < AHA1542_MAILBOXES; i++)
1267 if (HOSTDATA(shost)->SCint[i] &&
1268 !(HOSTDATA(shost)->SCint[i]->device->soft_reset)) {
1269#if 0
1270 HOSTDATA(shost)->mb[i].status = 1; /* Indicate ready to restart... */
1271#endif
1272 count++;
1273 }
1274 printk(KERN_DEBUG "Potential to restart %d stalled commands...\n", count);
1275#if 0
1276 /* start scsi command */
1277 if (count)
1278 aha1542_out(shost->io_port, &ahacmd, 1);
1279#endif
1280 return 0;
1281}
1282
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283/*
1284 * This is a device reset. This is handled by sending a special command
1285 * to the device.
1286 */
1287static int aha1542_dev_reset(Scsi_Cmnd * SCpnt)
1288{
1289 unsigned long flags;
1290 struct mailbox *mb;
1291 unchar target = SCpnt->device->id;
1292 unchar lun = SCpnt->device->lun;
1293 int mbo;
1294 struct ccb *ccb;
1295 unchar ahacmd = CMD_START_SCSI;
1296
1297 ccb = HOSTDATA(SCpnt->device->host)->ccb;
1298 mb = HOSTDATA(SCpnt->device->host)->mb;
1299
1300 spin_lock_irqsave(&aha1542_lock, flags);
1301 mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
1302 if (mbo >= AHA1542_MAILBOXES)
1303 mbo = 0;
1304
1305 do {
1306 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
1307 break;
1308 mbo++;
1309 if (mbo >= AHA1542_MAILBOXES)
1310 mbo = 0;
1311 } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
1312
1313 if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
1314 panic("Unable to find empty mailbox for aha1542.\n");
1315
1316 HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt; /* This will effectively
1317 prevent someone else from
1318 screwing with this cdb. */
1319
1320 HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
1321 spin_unlock_irqrestore(&aha1542_lock, flags);
1322
1323 any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo])); /* This gets trashed for some reason */
1324
1325 memset(&ccb[mbo], 0, sizeof(struct ccb));
1326
1327 ccb[mbo].op = 0x81; /* BUS DEVICE RESET */
1328
1329 ccb[mbo].idlun = (target & 7) << 5 | (lun & 7); /*SCSI Target Id */
1330
1331 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
1332 ccb[mbo].commlinkid = 0;
1333
1334 /*
1335 * Now tell the 1542 to flush all pending commands for this
1336 * target
1337 */
1338 aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1);
1339
Jeff Garzik017560f2005-10-24 18:04:36 -04001340 scmd_printk(KERN_WARNING, SCpnt,
1341 "Trying device reset for target\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342
1343 return SUCCESS;
1344
1345
1346#ifdef ERIC_neverdef
1347 /*
1348 * With the 1542 we apparently never get an interrupt to
1349 * acknowledge a device reset being sent. Then again, Leonard
1350 * says we are doing this wrong in the first place...
1351 *
1352 * Take a wait and see attitude. If we get spurious interrupts,
1353 * then the device reset is doing something sane and useful, and
1354 * we will wait for the interrupt to post completion.
1355 */
1356 printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1357
1358 /*
1359 * Free the command block for all commands running on this
1360 * target...
1361 */
1362 for (i = 0; i < AHA1542_MAILBOXES; i++) {
1363 if (HOSTDATA(SCpnt->host)->SCint[i] &&
1364 HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1365 Scsi_Cmnd *SCtmp;
1366 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
Jesper Juhlc9475cb2005-11-07 01:01:26 -08001367 kfree(SCtmp->host_scribble);
1368 SCtmp->host_scribble = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1370 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1371 }
1372 }
1373 return SUCCESS;
1374
1375 return FAILED;
1376#endif /* ERIC_neverdef */
1377}
1378
1379static int aha1542_bus_reset(Scsi_Cmnd * SCpnt)
1380{
1381 int i;
1382
1383 /*
1384 * This does a scsi reset for all devices on the bus.
1385 * In principle, we could also reset the 1542 - should
1386 * we do this? Try this first, and we can add that later
1387 * if it turns out to be useful.
1388 */
1389 outb(SCRST, CONTROL(SCpnt->device->host->io_port));
1390
1391 /*
1392 * Wait for the thing to settle down a bit. Unfortunately
1393 * this is going to basically lock up the machine while we
1394 * wait for this to complete. To be 100% correct, we need to
1395 * check for timeout, and if we are doing something like this
1396 * we are pretty desperate anyways.
1397 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 ssleep(4);
Jeff Garzik 68b3aa72005-05-28 07:56:31 -04001399
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 spin_lock_irq(SCpnt->device->host->host_lock);
1401
1402 WAIT(STATUS(SCpnt->device->host->io_port),
1403 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1404
1405 /*
1406 * Now try to pick up the pieces. For all pending commands,
1407 * free any internal data structures, and basically clear things
1408 * out. We do not try and restart any commands or anything -
1409 * the strategy handler takes care of that crap.
1410 */
1411 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1412
1413 for (i = 0; i < AHA1542_MAILBOXES; i++) {
1414 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1415 Scsi_Cmnd *SCtmp;
1416 SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1417
1418
1419 if (SCtmp->device->soft_reset) {
1420 /*
1421 * If this device implements the soft reset option,
1422 * then it is still holding onto the command, and
1423 * may yet complete it. In this case, we don't
1424 * flush the data.
1425 */
1426 continue;
1427 }
Jesper Juhlc9475cb2005-11-07 01:01:26 -08001428 kfree(SCtmp->host_scribble);
1429 SCtmp->host_scribble = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1431 HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1432 }
1433 }
1434
Jeff Garzik 68b3aa72005-05-28 07:56:31 -04001435 spin_unlock_irq(SCpnt->device->host->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 return SUCCESS;
1437
1438fail:
Jeff Garzik 68b3aa72005-05-28 07:56:31 -04001439 spin_unlock_irq(SCpnt->device->host->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 return FAILED;
1441}
1442
1443static int aha1542_host_reset(Scsi_Cmnd * SCpnt)
1444{
1445 int i;
1446
1447 /*
1448 * This does a scsi reset for all devices on the bus.
1449 * In principle, we could also reset the 1542 - should
1450 * we do this? Try this first, and we can add that later
1451 * if it turns out to be useful.
1452 */
1453 outb(HRST | SCRST, CONTROL(SCpnt->device->host->io_port));
1454
1455 /*
1456 * Wait for the thing to settle down a bit. Unfortunately
1457 * this is going to basically lock up the machine while we
1458 * wait for this to complete. To be 100% correct, we need to
1459 * check for timeout, and if we are doing something like this
1460 * we are pretty desperate anyways.
1461 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 ssleep(4);
1463 spin_lock_irq(SCpnt->device->host->host_lock);
1464
1465 WAIT(STATUS(SCpnt->device->host->io_port),
1466 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1467
1468 /*
1469 * We need to do this too before the 1542 can interact with
1470 * us again.
1471 */
1472 setup_mailboxes(SCpnt->device->host->io_port, SCpnt->device->host);
1473
1474 /*
1475 * Now try to pick up the pieces. For all pending commands,
1476 * free any internal data structures, and basically clear things
1477 * out. We do not try and restart any commands or anything -
1478 * the strategy handler takes care of that crap.
1479 */
1480 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1481
1482 for (i = 0; i < AHA1542_MAILBOXES; i++) {
1483 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1484 Scsi_Cmnd *SCtmp;
1485 SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1486
1487 if (SCtmp->device->soft_reset) {
1488 /*
1489 * If this device implements the soft reset option,
1490 * then it is still holding onto the command, and
1491 * may yet complete it. In this case, we don't
1492 * flush the data.
1493 */
1494 continue;
1495 }
Jesper Juhlc9475cb2005-11-07 01:01:26 -08001496 kfree(SCtmp->host_scribble);
1497 SCtmp->host_scribble = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1499 HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1500 }
1501 }
1502
Jeff Garzik df0ae242005-05-28 07:57:14 -04001503 spin_unlock_irq(SCpnt->device->host->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 return SUCCESS;
1505
1506fail:
Jeff Garzik df0ae242005-05-28 07:57:14 -04001507 spin_unlock_irq(SCpnt->device->host->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 return FAILED;
1509}
1510
1511#if 0
1512/*
1513 * These are the old error handling routines. They are only temporarily
1514 * here while we play with the new error handling code.
1515 */
1516static int aha1542_old_abort(Scsi_Cmnd * SCpnt)
1517{
1518#if 0
1519 unchar ahacmd = CMD_START_SCSI;
1520 unsigned long flags;
1521 struct mailbox *mb;
1522 int mbi, mbo, i;
1523
1524 printk(KERN_DEBUG "In aha1542_abort: %x %x\n",
1525 inb(STATUS(SCpnt->host->io_port)),
1526 inb(INTRFLAGS(SCpnt->host->io_port)));
1527
1528 spin_lock_irqsave(&aha1542_lock, flags);
1529 mb = HOSTDATA(SCpnt->host)->mb;
1530 mbi = HOSTDATA(SCpnt->host)->aha1542_last_mbi_used + 1;
1531 if (mbi >= 2 * AHA1542_MAILBOXES)
1532 mbi = AHA1542_MAILBOXES;
1533
1534 do {
1535 if (mb[mbi].status != 0)
1536 break;
1537 mbi++;
1538 if (mbi >= 2 * AHA1542_MAILBOXES)
1539 mbi = AHA1542_MAILBOXES;
1540 } while (mbi != HOSTDATA(SCpnt->host)->aha1542_last_mbi_used);
1541 spin_unlock_irqrestore(&aha1542_lock, flags);
1542
1543 if (mb[mbi].status) {
1544 printk(KERN_ERR "Lost interrupt discovered on irq %d - attempting to recover\n",
1545 SCpnt->host->irq);
1546 aha1542_intr_handle(SCpnt->host, NULL);
1547 return 0;
1548 }
1549 /* OK, no lost interrupt. Try looking to see how many pending commands
1550 we think we have. */
1551
1552 for (i = 0; i < AHA1542_MAILBOXES; i++)
1553 if (HOSTDATA(SCpnt->host)->SCint[i]) {
1554 if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1555 printk(KERN_ERR "Timed out command pending for %s\n",
1556 SCpnt->request->rq_disk ?
1557 SCpnt->request->rq_disk->disk_name : "?"
1558 );
1559 if (HOSTDATA(SCpnt->host)->mb[i].status) {
1560 printk(KERN_ERR "OGMB still full - restarting\n");
1561 aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1562 };
1563 } else
1564 printk(KERN_ERR "Other pending command %s\n",
1565 SCpnt->request->rq_disk ?
1566 SCpnt->request->rq_disk->disk_name : "?"
1567 );
1568 }
1569#endif
1570
1571 DEB(printk("aha1542_abort\n"));
1572#if 0
1573 spin_lock_irqsave(&aha1542_lock, flags);
1574 for (mbo = 0; mbo < AHA1542_MAILBOXES; mbo++) {
1575 if (SCpnt == HOSTDATA(SCpnt->host)->SCint[mbo]) {
1576 mb[mbo].status = 2; /* Abort command */
1577 aha1542_out(SCpnt->host->io_port, &ahacmd, 1); /* start scsi command */
1578 spin_unlock_irqrestore(&aha1542_lock, flags);
1579 break;
1580 }
1581 }
1582 if (AHA1542_MAILBOXES == mbo)
1583 spin_unlock_irqrestore(&aha1542_lock, flags);
1584#endif
1585 return SCSI_ABORT_SNOOZE;
1586}
1587
1588/* We do not implement a reset function here, but the upper level code
1589 assumes that it will get some kind of response for the command in
1590 SCpnt. We must oblige, or the command will hang the scsi system.
1591 For a first go, we assume that the 1542 notifies us with all of the
1592 pending commands (it does implement soft reset, after all). */
1593
1594static int aha1542_old_reset(Scsi_Cmnd * SCpnt, unsigned int reset_flags)
1595{
1596 unchar ahacmd = CMD_START_SCSI;
1597 int i;
1598
1599 /*
1600 * See if a bus reset was suggested.
1601 */
1602 if (reset_flags & SCSI_RESET_SUGGEST_BUS_RESET) {
1603 /*
1604 * This does a scsi reset for all devices on the bus.
1605 * In principle, we could also reset the 1542 - should
1606 * we do this? Try this first, and we can add that later
1607 * if it turns out to be useful.
1608 */
1609 outb(HRST | SCRST, CONTROL(SCpnt->host->io_port));
1610
1611 /*
1612 * Wait for the thing to settle down a bit. Unfortunately
1613 * this is going to basically lock up the machine while we
1614 * wait for this to complete. To be 100% correct, we need to
1615 * check for timeout, and if we are doing something like this
1616 * we are pretty desperate anyways.
1617 */
1618 WAIT(STATUS(SCpnt->host->io_port),
1619 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1620
1621 /*
1622 * We need to do this too before the 1542 can interact with
1623 * us again.
1624 */
1625 setup_mailboxes(SCpnt->host->io_port, SCpnt->host);
1626
1627 /*
1628 * Now try to pick up the pieces. Restart all commands
1629 * that are currently active on the bus, and reset all of
1630 * the datastructures. We have some time to kill while
1631 * things settle down, so print a nice message.
1632 */
1633 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->host->host_no);
1634
1635 for (i = 0; i < AHA1542_MAILBOXES; i++)
1636 if (HOSTDATA(SCpnt->host)->SCint[i] != NULL) {
1637 Scsi_Cmnd *SCtmp;
1638 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1639 SCtmp->result = DID_RESET << 16;
Jesper Juhlc9475cb2005-11-07 01:01:26 -08001640 kfree(SCtmp->host_scribble);
1641 SCtmp->host_scribble = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target);
1643 SCtmp->scsi_done(SCpnt);
1644
1645 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1646 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1647 }
1648 /*
1649 * Now tell the mid-level code what we did here. Since
1650 * we have restarted all of the outstanding commands,
1651 * then report SUCCESS.
1652 */
1653 return (SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET);
1654fail:
1655 printk(KERN_CRIT "aha1542.c: Unable to perform hard reset.\n");
1656 printk(KERN_CRIT "Power cycle machine to reset\n");
1657 return (SCSI_RESET_ERROR | SCSI_RESET_BUS_RESET);
1658
1659
1660 } else {
1661 /* This does a selective reset of just the one device */
1662 /* First locate the ccb for this command */
1663 for (i = 0; i < AHA1542_MAILBOXES; i++)
1664 if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1665 HOSTDATA(SCpnt->host)->ccb[i].op = 0x81; /* BUS DEVICE RESET */
1666 /* Now tell the 1542 to flush all pending commands for this target */
1667 aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1668
1669 /* Here is the tricky part. What to do next. Do we get an interrupt
1670 for the commands that we aborted with the specified target, or
1671 do we generate this on our own? Try it without first and see
1672 what happens */
1673 printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1674
1675 /* If the first does not work, then try the second. I think the
1676 first option is more likely to be correct. Free the command
1677 block for all commands running on this target... */
1678 for (i = 0; i < AHA1542_MAILBOXES; i++)
1679 if (HOSTDATA(SCpnt->host)->SCint[i] &&
1680 HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1681 Scsi_Cmnd *SCtmp;
1682 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1683 SCtmp->result = DID_RESET << 16;
Jesper Juhlc9475cb2005-11-07 01:01:26 -08001684 kfree(SCtmp->host_scribble);
1685 SCtmp->host_scribble = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target);
1687 SCtmp->scsi_done(SCpnt);
1688
1689 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1690 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1691 }
1692 return SCSI_RESET_SUCCESS;
1693 }
1694 }
1695 /* No active command at this time, so this means that each time we got
1696 some kind of response the last time through. Tell the mid-level code
1697 to request sense information in order to decide what to do next. */
1698 return SCSI_RESET_PUNT;
1699}
1700#endif /* end of big comment block around old_abort + old_reset */
1701
1702static int aha1542_biosparam(struct scsi_device *sdev,
1703 struct block_device *bdev, sector_t capacity, int *ip)
1704{
1705 int translation_algorithm;
1706 int size = capacity;
1707
1708 translation_algorithm = HOSTDATA(sdev->host)->bios_translation;
1709
1710 if ((size >> 11) > 1024 && translation_algorithm == BIOS_TRANSLATION_25563) {
1711 /* Please verify that this is the same as what DOS returns */
1712 ip[0] = 255;
1713 ip[1] = 63;
1714 ip[2] = size / 255 / 63;
1715 } else {
1716 ip[0] = 64;
1717 ip[1] = 32;
1718 ip[2] = size >> 11;
1719 }
1720
1721 return 0;
1722}
1723MODULE_LICENSE("GPL");
1724
1725
Christoph Hellwigd0be4a7d2005-10-31 18:31:40 +01001726static struct scsi_host_template driver_template = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 .proc_name = "aha1542",
1728 .name = "Adaptec 1542",
1729 .detect = aha1542_detect,
1730 .release = aha1542_release,
1731 .queuecommand = aha1542_queuecommand,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 .eh_device_reset_handler= aha1542_dev_reset,
1733 .eh_bus_reset_handler = aha1542_bus_reset,
1734 .eh_host_reset_handler = aha1542_host_reset,
1735 .bios_param = aha1542_biosparam,
1736 .can_queue = AHA1542_MAILBOXES,
1737 .this_id = 7,
1738 .sg_tablesize = AHA1542_SCATTER,
1739 .cmd_per_lun = AHA1542_CMDLUN,
1740 .unchecked_isa_dma = 1,
1741 .use_clustering = ENABLE_CLUSTERING,
1742};
1743#include "scsi_module.c"