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