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 } else {
407 sg_count = 0;
408 cptr = NULL;
409 }
410
411
412
413
414 spin_lock_irqsave(sh->host_lock, flags);
415 mbo = aha1542->aha1542_last_mbo_used + 1;
416 if (mbo >= AHA1542_MAILBOXES)
417 mbo = 0;
418
419 do {
420 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL)
421 break;
422 mbo++;
423 if (mbo >= AHA1542_MAILBOXES)
424 mbo = 0;
425 } while (mbo != aha1542->aha1542_last_mbo_used);
426
427 if (mb[mbo].status || aha1542->int_cmds[mbo])
428 panic("Unable to find empty mailbox for aha1542.\n");
429
430 aha1542->int_cmds[mbo] = cmd;
431
432
433 aha1542->aha1542_last_mbo_used = mbo;
434
435#ifdef DEBUG
436 shost_printk(KERN_DEBUG, sh, "Sending command (%d %p)...", mbo, cmd->scsi_done);
437#endif
438
439 any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo]));
440
441 memset(&ccb[mbo], 0, sizeof(struct ccb));
442
443 ccb[mbo].cdblen = cmd->cmd_len;
444
445 direction = 0;
446 if (*cmd->cmnd == READ_10 || *cmd->cmnd == READ_6)
447 direction = 8;
448 else if (*cmd->cmnd == WRITE_10 || *cmd->cmnd == WRITE_6)
449 direction = 16;
450
451 memcpy(ccb[mbo].cdb, cmd->cmnd, ccb[mbo].cdblen);
452
453 if (bufflen) {
454 struct scatterlist *sg;
455 int i;
456
457 ccb[mbo].op = 2;
458 cmd->host_scribble = (void *)cptr;
459 scsi_for_each_sg(cmd, sg, sg_count, i) {
460 any2scsi(cptr[i].dataptr, isa_page_to_bus(sg_page(sg))
461 + sg->offset);
462 any2scsi(cptr[i].datalen, sg->length);
463 };
464 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain));
465 any2scsi(ccb[mbo].dataptr, isa_virt_to_bus(cptr));
466#ifdef DEBUG
467 shost_printk(KERN_DEBUG, sh, "cptr %p: ", cptr);
468 print_hex_dump_bytes("cptr: ", DUMP_PREFIX_NONE, cptr, 18);
469#endif
470 } else {
471 ccb[mbo].op = 0;
472 cmd->host_scribble = NULL;
473 any2scsi(ccb[mbo].datalen, 0);
474 any2scsi(ccb[mbo].dataptr, 0);
475 };
476 ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7);
477 ccb[mbo].rsalen = 16;
478 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
479 ccb[mbo].commlinkid = 0;
480
481#ifdef DEBUG
482 print_hex_dump_bytes("sending: ", DUMP_PREFIX_NONE, &ccb[mbo], sizeof(ccb[mbo]) - 10);
483 printk("aha1542_queuecommand: now waiting for interrupt ");
484#endif
485 mb[mbo].status = 1;
486 aha1542_outb(cmd->device->host->io_port, CMD_START_SCSI);
487 spin_unlock_irqrestore(sh->host_lock, flags);
488
489 return 0;
490}
491
492
493static void setup_mailboxes(struct Scsi_Host *sh)
494{
495 struct aha1542_hostdata *aha1542 = shost_priv(sh);
496 int i;
497 struct mailbox *mb = aha1542->mb;
498 struct ccb *ccb = aha1542->ccb;
499
500 u8 mb_cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
501
502 for (i = 0; i < AHA1542_MAILBOXES; i++) {
503 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
504 any2scsi(mb[i].ccbptr, isa_virt_to_bus(&ccb[i]));
505 };
506 aha1542_intr_reset(sh->io_port);
507 any2scsi((mb_cmd + 2), isa_virt_to_bus(mb));
508 if (aha1542_out(sh->io_port, mb_cmd, 5))
509 shost_printk(KERN_ERR, sh, "failed setting up mailboxes\n");
510 aha1542_intr_reset(sh->io_port);
511}
512
513static int aha1542_getconfig(struct Scsi_Host *sh)
514{
515 u8 inquiry_result[3];
516 int i;
517 i = inb(STATUS(sh->io_port));
518 if (i & DF) {
519 i = inb(DATA(sh->io_port));
520 };
521 aha1542_outb(sh->io_port, CMD_RETCONF);
522 aha1542_in(sh->io_port, inquiry_result, 3, 0);
523 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0))
524 shost_printk(KERN_ERR, sh, "error querying board settings\n");
525 aha1542_intr_reset(sh->io_port);
526 switch (inquiry_result[0]) {
527 case 0x80:
528 sh->dma_channel = 7;
529 break;
530 case 0x40:
531 sh->dma_channel = 6;
532 break;
533 case 0x20:
534 sh->dma_channel = 5;
535 break;
536 case 0x01:
537 sh->dma_channel = 0;
538 break;
539 case 0:
540
541
542 sh->dma_channel = 0xFF;
543 break;
544 default:
545 shost_printk(KERN_ERR, sh, "Unable to determine DMA channel.\n");
546 return -1;
547 };
548 switch (inquiry_result[1]) {
549 case 0x40:
550 sh->irq = 15;
551 break;
552 case 0x20:
553 sh->irq = 14;
554 break;
555 case 0x8:
556 sh->irq = 12;
557 break;
558 case 0x4:
559 sh->irq = 11;
560 break;
561 case 0x2:
562 sh->irq = 10;
563 break;
564 case 0x1:
565 sh->irq = 9;
566 break;
567 default:
568 shost_printk(KERN_ERR, sh, "Unable to determine IRQ level.\n");
569 return -1;
570 };
571 sh->this_id = inquiry_result[2] & 7;
572 return 0;
573}
574
575
576
577
578static int aha1542_mbenable(struct Scsi_Host *sh)
579{
580 static u8 mbenable_cmd[3];
581 static u8 mbenable_result[2];
582 int retval;
583
584 retval = BIOS_TRANSLATION_6432;
585
586 aha1542_outb(sh->io_port, CMD_EXTBIOS);
587 if (aha1542_in(sh->io_port, mbenable_result, 2, 100))
588 return retval;
589 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 100))
590 goto fail;
591 aha1542_intr_reset(sh->io_port);
592
593 if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
594 mbenable_cmd[0] = CMD_MBENABLE;
595 mbenable_cmd[1] = 0;
596 mbenable_cmd[2] = mbenable_result[1];
597
598 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
599 retval = BIOS_TRANSLATION_25563;
600
601 if (aha1542_out(sh->io_port, mbenable_cmd, 3))
602 goto fail;
603 };
604 while (0) {
605fail:
606 shost_printk(KERN_ERR, sh, "Mailbox init failed\n");
607 }
608 aha1542_intr_reset(sh->io_port);
609 return retval;
610}
611
612
613static int aha1542_query(struct Scsi_Host *sh)
614{
615 struct aha1542_hostdata *aha1542 = shost_priv(sh);
616 u8 inquiry_result[4];
617 int i;
618 i = inb(STATUS(sh->io_port));
619 if (i & DF) {
620 i = inb(DATA(sh->io_port));
621 };
622 aha1542_outb(sh->io_port, CMD_INQUIRY);
623 aha1542_in(sh->io_port, inquiry_result, 4, 0);
624 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0))
625 shost_printk(KERN_ERR, sh, "error querying card type\n");
626 aha1542_intr_reset(sh->io_port);
627
628 aha1542->bios_translation = BIOS_TRANSLATION_6432;
629
630
631
632
633
634
635
636 if (inquiry_result[0] == 0x43) {
637 shost_printk(KERN_INFO, sh, "Emulation mode not supported for AHA-1740 hardware, use aha1740 driver instead.\n");
638 return 1;
639 };
640
641
642
643
644 aha1542->bios_translation = aha1542_mbenable(sh);
645
646 return 0;
647}
648
649static u8 dma_speed_hw(int dma_speed)
650{
651 switch (dma_speed) {
652 case 5:
653 return 0x00;
654 case 6:
655 return 0x04;
656 case 7:
657 return 0x01;
658 case 8:
659 return 0x02;
660 case 10:
661 return 0x03;
662 }
663
664 return 0xff;
665}
666
667
668static void aha1542_set_bus_times(struct Scsi_Host *sh, int bus_on, int bus_off, int dma_speed)
669{
670 if (bus_on > 0) {
671 u8 oncmd[] = { CMD_BUSON_TIME, clamp(bus_on, 2, 15) };
672
673 aha1542_intr_reset(sh->io_port);
674 if (aha1542_out(sh->io_port, oncmd, 2))
675 goto fail;
676 }
677
678 if (bus_off > 0) {
679 u8 offcmd[] = { CMD_BUSOFF_TIME, clamp(bus_off, 1, 64) };
680
681 aha1542_intr_reset(sh->io_port);
682 if (aha1542_out(sh->io_port, offcmd, 2))
683 goto fail;
684 }
685
686 if (dma_speed_hw(dma_speed) != 0xff) {
687 u8 dmacmd[] = { CMD_DMASPEED, dma_speed_hw(dma_speed) };
688
689 aha1542_intr_reset(sh->io_port);
690 if (aha1542_out(sh->io_port, dmacmd, 2))
691 goto fail;
692 }
693 aha1542_intr_reset(sh->io_port);
694 return;
695fail:
696 shost_printk(KERN_ERR, sh, "setting bus on/off-time failed\n");
697 aha1542_intr_reset(sh->io_port);
698}
699
700
701static struct Scsi_Host *aha1542_hw_init(struct scsi_host_template *tpnt, struct device *pdev, int indx)
702{
703 unsigned int base_io = io[indx];
704 struct Scsi_Host *sh;
705 struct aha1542_hostdata *aha1542;
706 char dma_info[] = "no DMA";
707
708 if (base_io == 0)
709 return NULL;
710
711 if (!request_region(base_io, AHA1542_REGION_SIZE, "aha1542"))
712 return NULL;
713
714 sh = scsi_host_alloc(tpnt, sizeof(struct aha1542_hostdata));
715 if (!sh)
716 goto release;
717 aha1542 = shost_priv(sh);
718
719 sh->unique_id = base_io;
720 sh->io_port = base_io;
721 sh->n_io_port = AHA1542_REGION_SIZE;
722 aha1542->aha1542_last_mbi_used = 2 * AHA1542_MAILBOXES - 1;
723 aha1542->aha1542_last_mbo_used = AHA1542_MAILBOXES - 1;
724
725 if (!aha1542_test_port(sh))
726 goto unregister;
727
728 aha1542_set_bus_times(sh, bus_on[indx], bus_off[indx], dma_speed[indx]);
729 if (aha1542_query(sh))
730 goto unregister;
731 if (aha1542_getconfig(sh) == -1)
732 goto unregister;
733
734 if (sh->dma_channel != 0xFF)
735 snprintf(dma_info, sizeof(dma_info), "DMA %d", sh->dma_channel);
736 shost_printk(KERN_INFO, sh, "Adaptec AHA-1542 (SCSI-ID %d) at IO 0x%x, IRQ %d, %s\n",
737 sh->this_id, base_io, sh->irq, dma_info);
738 if (aha1542->bios_translation == BIOS_TRANSLATION_25563)
739 shost_printk(KERN_INFO, sh, "Using extended bios translation\n");
740
741 setup_mailboxes(sh);
742
743 if (request_irq(sh->irq, aha1542_interrupt, 0, "aha1542", sh)) {
744 shost_printk(KERN_ERR, sh, "Unable to allocate IRQ.\n");
745 goto unregister;
746 }
747 if (sh->dma_channel != 0xFF) {
748 if (request_dma(sh->dma_channel, "aha1542")) {
749 shost_printk(KERN_ERR, sh, "Unable to allocate DMA channel.\n");
750 goto free_irq;
751 }
752 if (sh->dma_channel == 0 || sh->dma_channel >= 5) {
753 set_dma_mode(sh->dma_channel, DMA_MODE_CASCADE);
754 enable_dma(sh->dma_channel);
755 }
756 }
757
758 if (scsi_add_host(sh, pdev))
759 goto free_dma;
760
761 scsi_scan_host(sh);
762
763 return sh;
764free_dma:
765 if (sh->dma_channel != 0xff)
766 free_dma(sh->dma_channel);
767free_irq:
768 free_irq(sh->irq, sh);
769unregister:
770 scsi_host_put(sh);
771release:
772 release_region(base_io, AHA1542_REGION_SIZE);
773
774 return NULL;
775}
776
777static int aha1542_release(struct Scsi_Host *sh)
778{
779 scsi_remove_host(sh);
780 if (sh->dma_channel != 0xff)
781 free_dma(sh->dma_channel);
782 if (sh->irq)
783 free_irq(sh->irq, sh);
784 if (sh->io_port && sh->n_io_port)
785 release_region(sh->io_port, sh->n_io_port);
786 scsi_host_put(sh);
787 return 0;
788}
789
790
791
792
793
794
795static int aha1542_dev_reset(struct scsi_cmnd *cmd)
796{
797 struct Scsi_Host *sh = cmd->device->host;
798 struct aha1542_hostdata *aha1542 = shost_priv(sh);
799 unsigned long flags;
800 struct mailbox *mb = aha1542->mb;
801 u8 target = cmd->device->id;
802 u8 lun = cmd->device->lun;
803 int mbo;
804 struct ccb *ccb = aha1542->ccb;
805
806 spin_lock_irqsave(sh->host_lock, flags);
807 mbo = aha1542->aha1542_last_mbo_used + 1;
808 if (mbo >= AHA1542_MAILBOXES)
809 mbo = 0;
810
811 do {
812 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL)
813 break;
814 mbo++;
815 if (mbo >= AHA1542_MAILBOXES)
816 mbo = 0;
817 } while (mbo != aha1542->aha1542_last_mbo_used);
818
819 if (mb[mbo].status || aha1542->int_cmds[mbo])
820 panic("Unable to find empty mailbox for aha1542.\n");
821
822 aha1542->int_cmds[mbo] = cmd;
823
824
825
826 aha1542->aha1542_last_mbo_used = mbo;
827
828 any2scsi(mb[mbo].ccbptr, isa_virt_to_bus(&ccb[mbo]));
829
830 memset(&ccb[mbo], 0, sizeof(struct ccb));
831
832 ccb[mbo].op = 0x81;
833
834 ccb[mbo].idlun = (target & 7) << 5 | (lun & 7);
835
836 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
837 ccb[mbo].commlinkid = 0;
838
839
840
841
842
843 aha1542_outb(sh->io_port, CMD_START_SCSI);
844 spin_unlock_irqrestore(sh->host_lock, flags);
845
846 scmd_printk(KERN_WARNING, cmd,
847 "Trying device reset for target\n");
848
849 return SUCCESS;
850}
851
852static int aha1542_reset(struct scsi_cmnd *cmd, u8 reset_cmd)
853{
854 struct Scsi_Host *sh = cmd->device->host;
855 struct aha1542_hostdata *aha1542 = shost_priv(sh);
856 unsigned long flags;
857 int i;
858
859 spin_lock_irqsave(sh->host_lock, flags);
860
861
862
863
864
865
866 outb(reset_cmd, CONTROL(cmd->device->host->io_port));
867
868 if (!wait_mask(STATUS(cmd->device->host->io_port),
869 STATMASK, IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0)) {
870 spin_unlock_irqrestore(sh->host_lock, flags);
871 return FAILED;
872 }
873
874
875
876
877
878 if (reset_cmd & HRST)
879 setup_mailboxes(cmd->device->host);
880
881
882
883
884
885
886
887 shost_printk(KERN_WARNING, cmd->device->host, "Sent BUS RESET to scsi host %d\n", cmd->device->host->host_no);
888
889 for (i = 0; i < AHA1542_MAILBOXES; i++) {
890 if (aha1542->int_cmds[i] != NULL) {
891 struct scsi_cmnd *tmp_cmd;
892 tmp_cmd = aha1542->int_cmds[i];
893
894 if (tmp_cmd->device->soft_reset) {
895
896
897
898
899
900
901 continue;
902 }
903 kfree(tmp_cmd->host_scribble);
904 tmp_cmd->host_scribble = NULL;
905 aha1542->int_cmds[i] = NULL;
906 aha1542->mb[i].status = 0;
907 }
908 }
909
910 spin_unlock_irqrestore(sh->host_lock, flags);
911 return SUCCESS;
912}
913
914static int aha1542_bus_reset(struct scsi_cmnd *cmd)
915{
916 return aha1542_reset(cmd, SCRST);
917}
918
919static int aha1542_host_reset(struct scsi_cmnd *cmd)
920{
921 return aha1542_reset(cmd, HRST | SCRST);
922}
923
924static int aha1542_biosparam(struct scsi_device *sdev,
925 struct block_device *bdev, sector_t capacity, int geom[])
926{
927 struct aha1542_hostdata *aha1542 = shost_priv(sdev->host);
928
929 if (capacity >= 0x200000 &&
930 aha1542->bios_translation == BIOS_TRANSLATION_25563) {
931
932 geom[0] = 255;
933 geom[1] = 63;
934 } else {
935 geom[0] = 64;
936 geom[1] = 32;
937 }
938 geom[2] = sector_div(capacity, geom[0] * geom[1]);
939
940 return 0;
941}
942MODULE_LICENSE("GPL");
943
944static struct scsi_host_template driver_template = {
945 .module = THIS_MODULE,
946 .proc_name = "aha1542",
947 .name = "Adaptec 1542",
948 .queuecommand = aha1542_queuecommand,
949 .eh_device_reset_handler= aha1542_dev_reset,
950 .eh_bus_reset_handler = aha1542_bus_reset,
951 .eh_host_reset_handler = aha1542_host_reset,
952 .bios_param = aha1542_biosparam,
953 .can_queue = AHA1542_MAILBOXES,
954 .this_id = 7,
955 .sg_tablesize = 16,
956 .unchecked_isa_dma = 1,
957 .use_clustering = ENABLE_CLUSTERING,
958};
959
960static int aha1542_isa_match(struct device *pdev, unsigned int ndev)
961{
962 struct Scsi_Host *sh = aha1542_hw_init(&driver_template, pdev, ndev);
963
964 if (!sh)
965 return 0;
966
967 dev_set_drvdata(pdev, sh);
968 return 1;
969}
970
971static int aha1542_isa_remove(struct device *pdev,
972 unsigned int ndev)
973{
974 aha1542_release(dev_get_drvdata(pdev));
975 dev_set_drvdata(pdev, NULL);
976 return 0;
977}
978
979static struct isa_driver aha1542_isa_driver = {
980 .match = aha1542_isa_match,
981 .remove = aha1542_isa_remove,
982 .driver = {
983 .name = "aha1542"
984 },
985};
986static int isa_registered;
987
988#ifdef CONFIG_PNP
989static struct pnp_device_id aha1542_pnp_ids[] = {
990 { .id = "ADP1542" },
991 { .id = "" }
992};
993MODULE_DEVICE_TABLE(pnp, aha1542_pnp_ids);
994
995static int aha1542_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id)
996{
997 int indx;
998 struct Scsi_Host *sh;
999
1000 for (indx = 0; indx < ARRAY_SIZE(io); indx++) {
1001 if (io[indx])
1002 continue;
1003
1004 if (pnp_activate_dev(pdev) < 0)
1005 continue;
1006
1007 io[indx] = pnp_port_start(pdev, 0);
1008
1009
1010
1011
1012 dev_info(&pdev->dev, "ISAPnP found an AHA1535 at I/O 0x%03X", io[indx]);
1013 }
1014
1015 sh = aha1542_hw_init(&driver_template, &pdev->dev, indx);
1016 if (!sh)
1017 return -ENODEV;
1018
1019 pnp_set_drvdata(pdev, sh);
1020 return 0;
1021}
1022
1023static void aha1542_pnp_remove(struct pnp_dev *pdev)
1024{
1025 aha1542_release(pnp_get_drvdata(pdev));
1026 pnp_set_drvdata(pdev, NULL);
1027}
1028
1029static struct pnp_driver aha1542_pnp_driver = {
1030 .name = "aha1542",
1031 .id_table = aha1542_pnp_ids,
1032 .probe = aha1542_pnp_probe,
1033 .remove = aha1542_pnp_remove,
1034};
1035static int pnp_registered;
1036#endif
1037
1038static int __init aha1542_init(void)
1039{
1040 int ret = 0;
1041
1042#ifdef CONFIG_PNP
1043 if (isapnp) {
1044 ret = pnp_register_driver(&aha1542_pnp_driver);
1045 if (!ret)
1046 pnp_registered = 1;
1047 }
1048#endif
1049 ret = isa_register_driver(&aha1542_isa_driver, MAXBOARDS);
1050 if (!ret)
1051 isa_registered = 1;
1052
1053#ifdef CONFIG_PNP
1054 if (pnp_registered)
1055 ret = 0;
1056#endif
1057 if (isa_registered)
1058 ret = 0;
1059
1060 return ret;
1061}
1062
1063static void __exit aha1542_exit(void)
1064{
1065#ifdef CONFIG_PNP
1066 if (pnp_registered)
1067 pnp_unregister_driver(&aha1542_pnp_driver);
1068#endif
1069 if (isa_registered)
1070 isa_unregister_driver(&aha1542_isa_driver);
1071}
1072
1073module_init(aha1542_init);
1074module_exit(aha1542_exit);
1075