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