1
2
3
4
5
6
7
8
9#include <linux/module.h>
10#include <linux/interrupt.h>
11#include <linux/kernel.h>
12#include <linux/types.h>
13#include <linux/string.h>
14#include <linux/delay.h>
15#include <linux/init.h>
16#include <linux/spinlock.h>
17#include <linux/isa.h>
18#include <linux/pnp.h>
19#include <linux/slab.h>
20#include <linux/io.h>
21#include <asm/dma.h>
22#include <scsi/scsi_cmnd.h>
23#include <scsi/scsi_device.h>
24#include <scsi/scsi_host.h>
25#include "aha1542.h"
26
27#define MAXBOARDS 4
28
29static bool isapnp = 1;
30module_param(isapnp, bool, 0);
31MODULE_PARM_DESC(isapnp, "enable PnP support (default=1)");
32
33static int io[MAXBOARDS] = { 0x330, 0x334, 0, 0 };
34module_param_array(io, int, NULL, 0);
35MODULE_PARM_DESC(io, "base IO address of controller (0x130,0x134,0x230,0x234,0x330,0x334, default=0x330,0x334)");
36
37
38static int bus_on[MAXBOARDS] = { -1, -1, -1, -1 };
39module_param_array(bus_on, int, NULL, 0);
40MODULE_PARM_DESC(bus_on, "bus on time [us] (2-15, default=-1 [HW default: 11])");
41
42
43static int bus_off[MAXBOARDS] = { -1, -1, -1, -1 };
44module_param_array(bus_off, int, NULL, 0);
45MODULE_PARM_DESC(bus_off, "bus off time [us] (1-64, default=-1 [HW default: 4])");
46
47
48static int dma_speed[MAXBOARDS] = { -1, -1, -1, -1 };
49module_param_array(dma_speed, int, NULL, 0);
50MODULE_PARM_DESC(dma_speed, "DMA speed [MB/s] (5,6,7,8,10, default=-1 [by jumper])");
51
52#define BIOS_TRANSLATION_6432 1
53#define BIOS_TRANSLATION_25563 2
54
55struct aha1542_hostdata {
56
57 int bios_translation;
58 int aha1542_last_mbi_used;
59 int aha1542_last_mbo_used;
60 struct scsi_cmnd *int_cmds[AHA1542_MAILBOXES];
61 struct mailbox mb[2 * AHA1542_MAILBOXES];
62 struct ccb ccb[AHA1542_MAILBOXES];
63};
64
65static inline void aha1542_intr_reset(u16 base)
66{
67 outb(IRST, CONTROL(base));
68}
69
70static inline bool wait_mask(u16 port, u8 mask, u8 allof, u8 noneof, int timeout)
71{
72 bool delayed = true;
73
74 if (timeout == 0) {
75 timeout = 3000000;
76 delayed = false;
77 }
78
79 while (1) {
80 u8 bits = inb(port) & mask;
81 if ((bits & allof) == allof && ((bits & noneof) == 0))
82 break;
83 if (delayed)
84 mdelay(1);
85 if (--timeout == 0)
86 return false;
87 }
88
89 return true;
90}
91
92static int aha1542_outb(unsigned int base, u8 val)
93{
94 if (!wait_mask(STATUS(base), CDF, 0, CDF, 0))
95 return 1;
96 outb(val, DATA(base));
97
98 return 0;
99}
100
101static int aha1542_out(unsigned int base, u8 *buf, int len)
102{
103 while (len--) {
104 if (!wait_mask(STATUS(base), CDF, 0, CDF, 0))
105 return 1;
106 outb(*buf++, DATA(base));
107 }
108 if (!wait_mask(INTRFLAGS(base), INTRMASK, HACC, 0, 0))
109 return 1;
110
111 return 0;
112}
113
114
115
116
117static int aha1542_in(unsigned int base, u8 *buf, int len, int timeout)
118{
119 while (len--) {
120 if (!wait_mask(STATUS(base), DF, DF, 0, timeout))
121 return 1;
122 *buf++ = inb(DATA(base));
123 }
124 return 0;
125}
126
127static int makecode(unsigned hosterr, unsigned scsierr)
128{
129 switch (hosterr) {
130 case 0x0:
131 case 0xa:
132 case 0xb:
133 hosterr = 0;
134 break;
135
136 case 0x11:
137
138 hosterr = DID_TIME_OUT;
139 break;
140
141 case 0x12:
142
143
144
145 case 0x13:
146
147 case 0x15:
148
149
150 case 0x16:
151
152
153 case 0x17:
154
155
156 case 0x18:
157
158
159 case 0x19:
160
161
162
163 case 0x1a:
164
165
166#ifdef DEBUG
167 printk("Aha1542: %x %x\n", hosterr, scsierr);
168#endif
169 hosterr = DID_ERROR;
170 break;
171
172 case 0x14:
173
174
175
176 hosterr = DID_RESET;
177 break;
178 default:
179 printk(KERN_ERR "aha1542: makecode: unknown hoststatus %x\n", hosterr);
180 break;
181 }
182 return scsierr | (hosterr << 16);
183}
184
185static int aha1542_test_port(struct Scsi_Host *sh)
186{
187 u8 inquiry_result[4];
188 int i;
189
190
191 if (inb(STATUS(sh->io_port)) == 0xff)
192 return 0;
193
194
195
196
197 aha1542_intr_reset(sh->io_port);
198
199 outb(SRST | IRST , CONTROL(sh->io_port));
200
201 mdelay(20);
202
203
204 if (!wait_mask(STATUS(sh->io_port), STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0))
205 return 0;
206
207
208 if (inb(INTRFLAGS(sh->io_port)) & INTRMASK)
209 return 0;
210
211
212
213
214 aha1542_outb(sh->io_port, CMD_INQUIRY);
215
216 for (i = 0; i < 4; i++) {
217 if (!wait_mask(STATUS(sh->io_port), DF, DF, 0, 0))
218 return 0;
219 inquiry_result[i] = inb(DATA(sh->io_port));
220 }
221
222
223 if (inb(STATUS(sh->io_port)) & DF)
224 return 0;
225
226
227 if (!wait_mask(INTRFLAGS(sh->io_port), HACC, HACC, 0, 0))
228 return 0;
229
230
231 outb(IRST, CONTROL(sh->io_port));
232
233 return 1;
234}
235
236static irqreturn_t aha1542_interrupt(int irq, void *dev_id)
237{
238 struct Scsi_Host *sh = dev_id;
239 struct aha1542_hostdata *aha1542 = shost_priv(sh);
240 void (*my_done)(struct scsi_cmnd *) = NULL;
241 int errstatus, mbi, mbo, mbistatus;
242 int number_serviced;
243 unsigned long flags;
244 struct scsi_cmnd *tmp_cmd;
245 int flag;
246 struct mailbox *mb = aha1542->mb;
247 struct ccb *ccb = aha1542->ccb;
248
249#ifdef DEBUG
250 {
251 flag = inb(INTRFLAGS(sh->io_port));
252 shost_printk(KERN_DEBUG, sh, "aha1542_intr_handle: ");
253 if (!(flag & ANYINTR))
254 printk("no interrupt?");
255 if (flag & MBIF)
256 printk("MBIF ");
257 if (flag & MBOA)
258 printk("MBOF ");
259 if (flag & HACC)
260 printk("HACC ");
261 if (flag & SCRD)
262 printk("SCRD ");
263 printk("status %02x\n", inb(STATUS(sh->io_port)));
264 };
265#endif
266 number_serviced = 0;
267
268 spin_lock_irqsave(sh->host_lock, flags);
269 while (1) {
270 flag = inb(INTRFLAGS(sh->io_port));
271
272
273
274
275
276 if (flag & ~MBIF) {
277 if (flag & MBOA)
278 printk("MBOF ");
279 if (flag & HACC)
280 printk("HACC ");
281 if (flag & SCRD)
282 printk("SCRD ");
283 }
284 aha1542_intr_reset(sh->io_port);
285
286 mbi = aha1542->aha1542_last_mbi_used + 1;
287 if (mbi >= 2 * AHA1542_MAILBOXES)
288 mbi = AHA1542_MAILBOXES;
289
290 do {
291 if (mb[mbi].status != 0)
292 break;
293 mbi++;
294 if (mbi >= 2 * AHA1542_MAILBOXES)
295 mbi = AHA1542_MAILBOXES;
296 } while (mbi != aha1542->aha1542_last_mbi_used);
297
298 if (mb[mbi].status == 0) {
299 spin_unlock_irqrestore(sh->host_lock, flags);
300
301 if (!number_serviced)
302 shost_printk(KERN_WARNING, sh, "interrupt received, but no mail.\n");
303 return IRQ_HANDLED;
304 };
305
306 mbo = (scsi2int(mb[mbi].ccbptr) - (isa_virt_to_bus(&ccb[0]))) / sizeof(struct ccb);
307 mbistatus = mb[mbi].status;
308 mb[mbi].status = 0;
309 aha1542->aha1542_last_mbi_used = mbi;
310
311#ifdef DEBUG
312 if (ccb[mbo].tarstat | ccb[mbo].hastat)
313 shost_printk(KERN_DEBUG, sh, "aha1542_command: returning %x (status %d)\n",
314 ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status);
315#endif
316
317 if (mbistatus == 3)
318 continue;
319
320#ifdef DEBUG
321 shost_printk(KERN_DEBUG, sh, "...done %d %d\n", mbo, mbi);
322#endif
323
324 tmp_cmd = aha1542->int_cmds[mbo];
325
326 if (!tmp_cmd || !tmp_cmd->scsi_done) {
327 spin_unlock_irqrestore(sh->host_lock, flags);
328 shost_printk(KERN_WARNING, sh, "Unexpected interrupt\n");
329 shost_printk(KERN_WARNING, sh, "tarstat=%x, hastat=%x idlun=%x ccb#=%d\n", ccb[mbo].tarstat,
330 ccb[mbo].hastat, ccb[mbo].idlun, mbo);
331 return IRQ_HANDLED;
332 }
333 my_done = tmp_cmd->scsi_done;
334 kfree(tmp_cmd->host_scribble);
335 tmp_cmd->host_scribble = NULL;
336
337
338
339 if (ccb[mbo].tarstat == 2)
340 memcpy(tmp_cmd->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen],
341 SCSI_SENSE_BUFFERSIZE);
342
343
344
345
346
347 if (mbistatus != 1)
348
349 errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
350 else
351 errstatus = 0;
352
353#ifdef DEBUG
354 if (errstatus)
355 shost_printk(KERN_DEBUG, sh, "(aha1542 error:%x %x %x) ", errstatus,
356 ccb[mbo].hastat, ccb[mbo].tarstat);
357 if (ccb[mbo].tarstat == 2)
358 print_hex_dump_bytes("sense: ", DUMP_PREFIX_NONE, &ccb[mbo].cdb[ccb[mbo].cdblen], 12);
359 if (errstatus)
360 printk("aha1542_intr_handle: returning %6x\n", errstatus);
361#endif
362 tmp_cmd->result = errstatus;
363 aha1542->int_cmds[mbo] = NULL;
364
365 my_done(tmp_cmd);
366 number_serviced++;
367 };
368}
369
370static int aha1542_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
371{
372 struct aha1542_hostdata *aha1542 = shost_priv(sh);
373 u8 direction;
374 u8 target = cmd->device->id;
375 u8 lun = cmd->device->lun;
376 unsigned long flags;
377 int bufflen = scsi_bufflen(cmd);
378 int mbo, sg_count;
379 struct mailbox *mb = aha1542->mb;
380 struct ccb *ccb = aha1542->ccb;
381 struct chain *cptr;
382
383 if (*cmd->cmnd == REQUEST_SENSE) {
384
385 cmd->result = 0;
386 cmd->scsi_done(cmd);
387 return 0;
388 }
389#ifdef DEBUG
390 {
391 int i = -1;
392 if (*cmd->cmnd == READ_10 || *cmd->cmnd == WRITE_10)
393 i = xscsi2int(cmd->cmnd + 2);
394 else if (*cmd->cmnd == READ_6 || *cmd->cmnd == WRITE_6)
395 i = scsi2int(cmd->cmnd + 2);
396 shost_printk(KERN_DEBUG, sh, "aha1542_queuecommand: dev %d cmd %02x pos %d len %d",
397 target, *cmd->cmnd, i, bufflen);
398 print_hex_dump_bytes("command: ", DUMP_PREFIX_NONE, cmd->cmnd, cmd->cmd_len);
399 }
400#endif
401 if (bufflen) {
402 sg_count = scsi_sg_count(cmd);
403 cptr = kmalloc(sizeof(*cptr) * sg_count, GFP_KERNEL | GFP_DMA);
404 if (!cptr)
405 return SCSI_MLQUEUE_HOST_BUSY;
406 }
407
408
409
410
411 spin_lock_irqsave(sh->host_lock, flags);
412 mbo = aha1542->aha1542_last_mbo_used + 1;
413 if (mbo >= AHA1542_MAILBOXES)
414 mbo = 0;
415
416 do {
417 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL)
418 break;
419 mbo++;
420 if (mbo >= AHA1542_MAILBOXES)
421 mbo = 0;
422 } while (mbo != aha1542->aha1542_last_mbo_used);
423
424 if (mb[mbo].status || aha1542->int_cmds[mbo])
425 panic("Unable to find empty mailbox for aha1542.\n");
426
427 aha1542->int_cmds[mbo] = cmd;
428
429
430 aha1542->aha1542_last_mbo_used = mbo;
431
432#ifdef DEBUG
433 shost_printk(KERN_DEBUG, sh, "Sending command (%d %p)...", mbo, cmd->scsi_done);
434#endif
435
436 any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo]));
437
438 memset(&ccb[mbo], 0, sizeof(struct ccb));
439
440 ccb[mbo].cdblen = cmd->cmd_len;
441
442 direction = 0;
443 if (*cmd->cmnd == READ_10 || *cmd->cmnd == READ_6)
444 direction = 8;
445 else if (*cmd->cmnd == WRITE_10 || *cmd->cmnd == WRITE_6)
446 direction = 16;
447
448 memcpy(ccb[mbo].cdb, cmd->cmnd, ccb[mbo].cdblen);
449
450 if (bufflen) {
451 struct scatterlist *sg;
452 int i;
453
454 ccb[mbo].op = 2;
455 cmd->host_scribble = (void *)cptr;
456 scsi_for_each_sg(cmd, sg, sg_count, i) {
457 any2scsi(cptr[i].dataptr, isa_page_to_bus(sg_page(sg))
458 + sg->offset);
459 any2scsi(cptr[i].datalen, sg->length);
460 };
461 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain));
462 any2scsi(ccb[mbo].dataptr, isa_virt_to_bus(cptr));
463#ifdef DEBUG
464 shost_printk(KERN_DEBUG, sh, "cptr %p: ", cptr);
465 print_hex_dump_bytes("cptr: ", DUMP_PREFIX_NONE, cptr, 18);
466#endif
467 } else {
468 ccb[mbo].op = 0;
469 cmd->host_scribble = NULL;
470 any2scsi(ccb[mbo].datalen, 0);
471 any2scsi(ccb[mbo].dataptr, 0);
472 };
473 ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7);
474 ccb[mbo].rsalen = 16;
475 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
476 ccb[mbo].commlinkid = 0;
477
478#ifdef DEBUG
479 print_hex_dump_bytes("sending: ", DUMP_PREFIX_NONE, &ccb[mbo], sizeof(ccb[mbo]) - 10);
480 printk("aha1542_queuecommand: now waiting for interrupt ");
481#endif
482 mb[mbo].status = 1;
483 aha1542_outb(cmd->device->host->io_port, CMD_START_SCSI);
484 spin_unlock_irqrestore(sh->host_lock, flags);
485
486 return 0;
487}
488
489
490static void setup_mailboxes(struct Scsi_Host *sh)
491{
492 struct aha1542_hostdata *aha1542 = shost_priv(sh);
493 int i;
494 struct mailbox *mb = aha1542->mb;
495 struct ccb *ccb = aha1542->ccb;
496
497 u8 mb_cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
498
499 for (i = 0; i < AHA1542_MAILBOXES; i++) {
500 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
501 any2scsi(mb[i].ccbptr, isa_virt_to_bus(&ccb[i]));
502 };
503 aha1542_intr_reset(sh->io_port);
504 any2scsi((mb_cmd + 2), isa_virt_to_bus(mb));
505 if (aha1542_out(sh->io_port, mb_cmd, 5))
506 shost_printk(KERN_ERR, sh, "failed setting up mailboxes\n");
507 aha1542_intr_reset(sh->io_port);
508}
509
510static int aha1542_getconfig(struct Scsi_Host *sh)
511{
512 u8 inquiry_result[3];
513 int i;
514 i = inb(STATUS(sh->io_port));
515 if (i & DF) {
516 i = inb(DATA(sh->io_port));
517 };
518 aha1542_outb(sh->io_port, CMD_RETCONF);
519 aha1542_in(sh->io_port, inquiry_result, 3, 0);
520 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0))
521 shost_printk(KERN_ERR, sh, "error querying board settings\n");
522 aha1542_intr_reset(sh->io_port);
523 switch (inquiry_result[0]) {
524 case 0x80:
525 sh->dma_channel = 7;
526 break;
527 case 0x40:
528 sh->dma_channel = 6;
529 break;
530 case 0x20:
531 sh->dma_channel = 5;
532 break;
533 case 0x01:
534 sh->dma_channel = 0;
535 break;
536 case 0:
537
538
539 sh->dma_channel = 0xFF;
540 break;
541 default:
542 shost_printk(KERN_ERR, sh, "Unable to determine DMA channel.\n");
543 return -1;
544 };
545 switch (inquiry_result[1]) {
546 case 0x40:
547 sh->irq = 15;
548 break;
549 case 0x20:
550 sh->irq = 14;
551 break;
552 case 0x8:
553 sh->irq = 12;
554 break;
555 case 0x4:
556 sh->irq = 11;
557 break;
558 case 0x2:
559 sh->irq = 10;
560 break;
561 case 0x1:
562 sh->irq = 9;
563 break;
564 default:
565 shost_printk(KERN_ERR, sh, "Unable to determine IRQ level.\n");
566 return -1;
567 };
568 sh->this_id = inquiry_result[2] & 7;
569 return 0;
570}
571
572
573
574
575static int aha1542_mbenable(struct Scsi_Host *sh)
576{
577 static u8 mbenable_cmd[3];
578 static u8 mbenable_result[2];
579 int retval;
580
581 retval = BIOS_TRANSLATION_6432;
582
583 aha1542_outb(sh->io_port, CMD_EXTBIOS);
584 if (aha1542_in(sh->io_port, mbenable_result, 2, 100))
585 return retval;
586 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 100))
587 goto fail;
588 aha1542_intr_reset(sh->io_port);
589
590 if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
591 mbenable_cmd[0] = CMD_MBENABLE;
592 mbenable_cmd[1] = 0;
593 mbenable_cmd[2] = mbenable_result[1];
594
595 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
596 retval = BIOS_TRANSLATION_25563;
597
598 if (aha1542_out(sh->io_port, mbenable_cmd, 3))
599 goto fail;
600 };
601 while (0) {
602fail:
603 shost_printk(KERN_ERR, sh, "Mailbox init failed\n");
604 }
605 aha1542_intr_reset(sh->io_port);
606 return retval;
607}
608
609
610static int aha1542_query(struct Scsi_Host *sh)
611{
612 struct aha1542_hostdata *aha1542 = shost_priv(sh);
613 u8 inquiry_result[4];
614 int i;
615 i = inb(STATUS(sh->io_port));
616 if (i & DF) {
617 i = inb(DATA(sh->io_port));
618 };
619 aha1542_outb(sh->io_port, CMD_INQUIRY);
620 aha1542_in(sh->io_port, inquiry_result, 4, 0);
621 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0))
622 shost_printk(KERN_ERR, sh, "error querying card type\n");
623 aha1542_intr_reset(sh->io_port);
624
625 aha1542->bios_translation = BIOS_TRANSLATION_6432;
626
627
628
629
630
631
632
633 if (inquiry_result[0] == 0x43) {
634 shost_printk(KERN_INFO, sh, "Emulation mode not supported for AHA-1740 hardware, use aha1740 driver instead.\n");
635 return 1;
636 };
637
638
639
640
641 aha1542->bios_translation = aha1542_mbenable(sh);
642
643 return 0;
644}
645
646static u8 dma_speed_hw(int dma_speed)
647{
648 switch (dma_speed) {
649 case 5:
650 return 0x00;
651 case 6:
652 return 0x04;
653 case 7:
654 return 0x01;
655 case 8:
656 return 0x02;
657 case 10:
658 return 0x03;
659 }
660
661 return 0xff;
662}
663
664
665static void aha1542_set_bus_times(struct Scsi_Host *sh, int bus_on, int bus_off, int dma_speed)
666{
667 if (bus_on > 0) {
668 u8 oncmd[] = { CMD_BUSON_TIME, clamp(bus_on, 2, 15) };
669
670 aha1542_intr_reset(sh->io_port);
671 if (aha1542_out(sh->io_port, oncmd, 2))
672 goto fail;
673 }
674
675 if (bus_off > 0) {
676 u8 offcmd[] = { CMD_BUSOFF_TIME, clamp(bus_off, 1, 64) };
677
678 aha1542_intr_reset(sh->io_port);
679 if (aha1542_out(sh->io_port, offcmd, 2))
680 goto fail;
681 }
682
683 if (dma_speed_hw(dma_speed) != 0xff) {
684 u8 dmacmd[] = { CMD_DMASPEED, dma_speed_hw(dma_speed) };
685
686 aha1542_intr_reset(sh->io_port);
687 if (aha1542_out(sh->io_port, dmacmd, 2))
688 goto fail;
689 }
690 aha1542_intr_reset(sh->io_port);
691 return;
692fail:
693 shost_printk(KERN_ERR, sh, "setting bus on/off-time failed\n");
694 aha1542_intr_reset(sh->io_port);
695}
696
697
698static struct Scsi_Host *aha1542_hw_init(struct scsi_host_template *tpnt, struct device *pdev, int indx)
699{
700 unsigned int base_io = io[indx];
701 struct Scsi_Host *sh;
702 struct aha1542_hostdata *aha1542;
703 char dma_info[] = "no DMA";
704
705 if (base_io == 0)
706 return NULL;
707
708 if (!request_region(base_io, AHA1542_REGION_SIZE, "aha1542"))
709 return NULL;
710
711 sh = scsi_host_alloc(tpnt, sizeof(struct aha1542_hostdata));
712 if (!sh)
713 goto release;
714 aha1542 = shost_priv(sh);
715
716 sh->unique_id = base_io;
717 sh->io_port = base_io;
718 sh->n_io_port = AHA1542_REGION_SIZE;
719 aha1542->aha1542_last_mbi_used = 2 * AHA1542_MAILBOXES - 1;
720 aha1542->aha1542_last_mbo_used = AHA1542_MAILBOXES - 1;
721
722 if (!aha1542_test_port(sh))
723 goto unregister;
724
725 aha1542_set_bus_times(sh, bus_on[indx], bus_off[indx], dma_speed[indx]);
726 if (aha1542_query(sh))
727 goto unregister;
728 if (aha1542_getconfig(sh) == -1)
729 goto unregister;
730
731 if (sh->dma_channel != 0xFF)
732 snprintf(dma_info, sizeof(dma_info), "DMA %d", sh->dma_channel);
733 shost_printk(KERN_INFO, sh, "Adaptec AHA-1542 (SCSI-ID %d) at IO 0x%x, IRQ %d, %s\n",
734 sh->this_id, base_io, sh->irq, dma_info);
735 if (aha1542->bios_translation == BIOS_TRANSLATION_25563)
736 shost_printk(KERN_INFO, sh, "Using extended bios translation\n");
737
738 setup_mailboxes(sh);
739
740 if (request_irq(sh->irq, aha1542_interrupt, 0, "aha1542", sh)) {
741 shost_printk(KERN_ERR, sh, "Unable to allocate IRQ.\n");
742 goto unregister;
743 }
744 if (sh->dma_channel != 0xFF) {
745 if (request_dma(sh->dma_channel, "aha1542")) {
746 shost_printk(KERN_ERR, sh, "Unable to allocate DMA channel.\n");
747 goto free_irq;
748 }
749 if (sh->dma_channel == 0 || sh->dma_channel >= 5) {
750 set_dma_mode(sh->dma_channel, DMA_MODE_CASCADE);
751 enable_dma(sh->dma_channel);
752 }
753 }
754
755 if (scsi_add_host(sh, pdev))
756 goto free_dma;
757
758 scsi_scan_host(sh);
759
760 return sh;
761free_dma:
762 if (sh->dma_channel != 0xff)
763 free_dma(sh->dma_channel);
764free_irq:
765 free_irq(sh->irq, sh);
766unregister:
767 scsi_host_put(sh);
768release:
769 release_region(base_io, AHA1542_REGION_SIZE);
770
771 return NULL;
772}
773
774static int aha1542_release(struct Scsi_Host *sh)
775{
776 scsi_remove_host(sh);
777 if (sh->dma_channel != 0xff)
778 free_dma(sh->dma_channel);
779 if (sh->irq)
780 free_irq(sh->irq, sh);
781 if (sh->io_port && sh->n_io_port)
782 release_region(sh->io_port, sh->n_io_port);
783 scsi_host_put(sh);
784 return 0;
785}
786
787
788
789
790
791
792static int aha1542_dev_reset(struct scsi_cmnd *cmd)
793{
794 struct Scsi_Host *sh = cmd->device->host;
795 struct aha1542_hostdata *aha1542 = shost_priv(sh);
796 unsigned long flags;
797 struct mailbox *mb = aha1542->mb;
798 u8 target = cmd->device->id;
799 u8 lun = cmd->device->lun;
800 int mbo;
801 struct ccb *ccb = aha1542->ccb;
802
803 spin_lock_irqsave(sh->host_lock, flags);
804 mbo = aha1542->aha1542_last_mbo_used + 1;
805 if (mbo >= AHA1542_MAILBOXES)
806 mbo = 0;
807
808 do {
809 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL)
810 break;
811 mbo++;
812 if (mbo >= AHA1542_MAILBOXES)
813 mbo = 0;
814 } while (mbo != aha1542->aha1542_last_mbo_used);
815
816 if (mb[mbo].status || aha1542->int_cmds[mbo])
817 panic("Unable to find empty mailbox for aha1542.\n");
818
819 aha1542->int_cmds[mbo] = cmd;
820
821
822
823 aha1542->aha1542_last_mbo_used = mbo;
824
825 any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo]));
826
827 memset(&ccb[mbo], 0, sizeof(struct ccb));
828
829 ccb[mbo].op = 0x81;
830
831 ccb[mbo].idlun = (target & 7) << 5 | (lun & 7);
832
833 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
834 ccb[mbo].commlinkid = 0;
835
836
837
838
839
840 aha1542_outb(sh->io_port, CMD_START_SCSI);
841 spin_unlock_irqrestore(sh->host_lock, flags);
842
843 scmd_printk(KERN_WARNING, cmd,
844 "Trying device reset for target\n");
845
846 return SUCCESS;
847}
848
849static int aha1542_reset(struct scsi_cmnd *cmd, u8 reset_cmd)
850{
851 struct Scsi_Host *sh = cmd->device->host;
852 struct aha1542_hostdata *aha1542 = shost_priv(sh);
853 unsigned long flags;
854 int i;
855
856 spin_lock_irqsave(sh->host_lock, flags);
857
858
859
860
861
862
863 outb(reset_cmd, CONTROL(cmd->device->host->io_port));
864
865 if (!wait_mask(STATUS(cmd->device->host->io_port),
866 STATMASK, IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0)) {
867 spin_unlock_irqrestore(sh->host_lock, flags);
868 return FAILED;
869 }
870
871
872
873
874
875 if (reset_cmd & HRST)
876 setup_mailboxes(cmd->device->host);
877
878
879
880
881
882
883
884 shost_printk(KERN_WARNING, cmd->device->host, "Sent BUS RESET to scsi host %d\n", cmd->device->host->host_no);
885
886 for (i = 0; i < AHA1542_MAILBOXES; i++) {
887 if (aha1542->int_cmds[i] != NULL) {
888 struct scsi_cmnd *tmp_cmd;
889 tmp_cmd = aha1542->int_cmds[i];
890
891 if (tmp_cmd->device->soft_reset) {
892
893
894
895
896
897
898 continue;
899 }
900 kfree(tmp_cmd->host_scribble);
901 tmp_cmd->host_scribble = NULL;
902 aha1542->int_cmds[i] = NULL;
903 aha1542->mb[i].status = 0;
904 }
905 }
906
907 spin_unlock_irqrestore(sh->host_lock, flags);
908 return SUCCESS;
909}
910
911static int aha1542_bus_reset(struct scsi_cmnd *cmd)
912{
913 return aha1542_reset(cmd, SCRST);
914}
915
916static int aha1542_host_reset(struct scsi_cmnd *cmd)
917{
918 return aha1542_reset(cmd, HRST | SCRST);
919}
920
921static int aha1542_biosparam(struct scsi_device *sdev,
922 struct block_device *bdev, sector_t capacity, int geom[])
923{
924 struct aha1542_hostdata *aha1542 = shost_priv(sdev->host);
925
926 if (capacity >= 0x200000 &&
927 aha1542->bios_translation == BIOS_TRANSLATION_25563) {
928
929 geom[0] = 255;
930 geom[1] = 63;
931 } else {
932 geom[0] = 64;
933 geom[1] = 32;
934 }
935 geom[2] = sector_div(capacity, geom[0] * geom[1]);
936
937 return 0;
938}
939MODULE_LICENSE("GPL");
940
941static struct scsi_host_template driver_template = {
942 .module = THIS_MODULE,
943 .proc_name = "aha1542",
944 .name = "Adaptec 1542",
945 .queuecommand = aha1542_queuecommand,
946 .eh_device_reset_handler= aha1542_dev_reset,
947 .eh_bus_reset_handler = aha1542_bus_reset,
948 .eh_host_reset_handler = aha1542_host_reset,
949 .bios_param = aha1542_biosparam,
950 .can_queue = AHA1542_MAILBOXES,
951 .this_id = 7,
952 .sg_tablesize = 16,
953 .unchecked_isa_dma = 1,
954 .use_clustering = ENABLE_CLUSTERING,
955};
956
957static int aha1542_isa_match(struct device *pdev, unsigned int ndev)
958{
959 struct Scsi_Host *sh = aha1542_hw_init(&driver_template, pdev, ndev);
960
961 if (!sh)
962 return 0;
963
964 dev_set_drvdata(pdev, sh);
965 return 1;
966}
967
968static int aha1542_isa_remove(struct device *pdev,
969 unsigned int ndev)
970{
971 aha1542_release(dev_get_drvdata(pdev));
972 dev_set_drvdata(pdev, NULL);
973 return 0;
974}
975
976static struct isa_driver aha1542_isa_driver = {
977 .match = aha1542_isa_match,
978 .remove = aha1542_isa_remove,
979 .driver = {
980 .name = "aha1542"
981 },
982};
983static int isa_registered;
984
985#ifdef CONFIG_PNP
986static struct pnp_device_id aha1542_pnp_ids[] = {
987 { .id = "ADP1542" },
988 { .id = "" }
989};
990MODULE_DEVICE_TABLE(pnp, aha1542_pnp_ids);
991
992static int aha1542_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id)
993{
994 int indx;
995 struct Scsi_Host *sh;
996
997 for (indx = 0; indx < ARRAY_SIZE(io); indx++) {
998 if (io[indx])
999 continue;
1000
1001 if (pnp_activate_dev(pdev) < 0)
1002 continue;
1003
1004 io[indx] = pnp_port_start(pdev, 0);
1005
1006
1007
1008
1009 dev_info(&pdev->dev, "ISAPnP found an AHA1535 at I/O 0x%03X", io[indx]);
1010 }
1011
1012 sh = aha1542_hw_init(&driver_template, &pdev->dev, indx);
1013 if (!sh)
1014 return -ENODEV;
1015
1016 pnp_set_drvdata(pdev, sh);
1017 return 0;
1018}
1019
1020static void aha1542_pnp_remove(struct pnp_dev *pdev)
1021{
1022 aha1542_release(pnp_get_drvdata(pdev));
1023 pnp_set_drvdata(pdev, NULL);
1024}
1025
1026static struct pnp_driver aha1542_pnp_driver = {
1027 .name = "aha1542",
1028 .id_table = aha1542_pnp_ids,
1029 .probe = aha1542_pnp_probe,
1030 .remove = aha1542_pnp_remove,
1031};
1032static int pnp_registered;
1033#endif
1034
1035static int __init aha1542_init(void)
1036{
1037 int ret = 0;
1038
1039#ifdef CONFIG_PNP
1040 if (isapnp) {
1041 ret = pnp_register_driver(&aha1542_pnp_driver);
1042 if (!ret)
1043 pnp_registered = 1;
1044 }
1045#endif
1046 ret = isa_register_driver(&aha1542_isa_driver, MAXBOARDS);
1047 if (!ret)
1048 isa_registered = 1;
1049
1050#ifdef CONFIG_PNP
1051 if (pnp_registered)
1052 ret = 0;
1053#endif
1054 if (isa_registered)
1055 ret = 0;
1056
1057 return ret;
1058}
1059
1060static void __exit aha1542_exit(void)
1061{
1062#ifdef CONFIG_PNP
1063 if (pnp_registered)
1064 pnp_unregister_driver(&aha1542_pnp_driver);
1065#endif
1066 if (isa_registered)
1067 isa_unregister_driver(&aha1542_isa_driver);
1068}
1069
1070module_init(aha1542_init);
1071module_exit(aha1542_exit);
1072