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
30 static bool isapnp = 1;
31 module_param(isapnp, bool, 0);
32 MODULE_PARM_DESC(isapnp, "enable PnP support (default=1)");
33
34 static int io[MAXBOARDS] = { 0x330, 0x334, 0, 0 };
35 module_param_hw_array(io, int, ioport, NULL, 0);
36 MODULE_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 */
39 static int bus_on[MAXBOARDS] = { -1, -1, -1, -1 }; /* power-on default: 11us */
40 module_param_array(bus_on, int, NULL, 0);
41 MODULE_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 */
44 static int bus_off[MAXBOARDS] = { -1, -1, -1, -1 }; /* power-on default: 4us */
45 module_param_array(bus_off, int, NULL, 0);
46 MODULE_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 */
49 static int dma_speed[MAXBOARDS] = { -1, -1, -1, -1 };
50 module_param_array(dma_speed, int, NULL, 0);
51 MODULE_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
56 struct 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 struct aha1542_cmd {
69 struct chain *chain;
70 dma_addr_t chain_handle;
71 };
72
aha1542_intr_reset(u16 base)73 static inline void aha1542_intr_reset(u16 base)
74 {
75 outb(IRST, CONTROL(base));
76 }
77
wait_mask(u16 port,u8 mask,u8 allof,u8 noneof,int timeout)78 static inline bool wait_mask(u16 port, u8 mask, u8 allof, u8 noneof, int timeout)
79 {
80 bool delayed = true;
81
82 if (timeout == 0) {
83 timeout = 3000000;
84 delayed = false;
85 }
86
87 while (1) {
88 u8 bits = inb(port) & mask;
89 if ((bits & allof) == allof && ((bits & noneof) == 0))
90 break;
91 if (delayed)
92 mdelay(1);
93 if (--timeout == 0)
94 return false;
95 }
96
97 return true;
98 }
99
aha1542_outb(unsigned int base,u8 val)100 static int aha1542_outb(unsigned int base, u8 val)
101 {
102 if (!wait_mask(STATUS(base), CDF, 0, CDF, 0))
103 return 1;
104 outb(val, DATA(base));
105
106 return 0;
107 }
108
aha1542_out(unsigned int base,u8 * buf,int len)109 static int aha1542_out(unsigned int base, u8 *buf, int len)
110 {
111 while (len--) {
112 if (!wait_mask(STATUS(base), CDF, 0, CDF, 0))
113 return 1;
114 outb(*buf++, DATA(base));
115 }
116 if (!wait_mask(INTRFLAGS(base), INTRMASK, HACC, 0, 0))
117 return 1;
118
119 return 0;
120 }
121
122 /* Only used at boot time, so we do not need to worry about latency as much
123 here */
124
aha1542_in(unsigned int base,u8 * buf,int len,int timeout)125 static int aha1542_in(unsigned int base, u8 *buf, int len, int timeout)
126 {
127 while (len--) {
128 if (!wait_mask(STATUS(base), DF, DF, 0, timeout))
129 return 1;
130 *buf++ = inb(DATA(base));
131 }
132 return 0;
133 }
134
makecode(unsigned hosterr,unsigned scsierr)135 static int makecode(unsigned hosterr, unsigned scsierr)
136 {
137 switch (hosterr) {
138 case 0x0:
139 case 0xa: /* Linked command complete without error and linked normally */
140 case 0xb: /* Linked command complete without error, interrupt generated */
141 hosterr = 0;
142 break;
143
144 case 0x11: /* Selection time out-The initiator selection or target
145 reselection was not complete within the SCSI Time out period */
146 hosterr = DID_TIME_OUT;
147 break;
148
149 case 0x12: /* Data overrun/underrun-The target attempted to transfer more data
150 than was allocated by the Data Length field or the sum of the
151 Scatter / Gather Data Length fields. */
152
153 case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
154
155 case 0x15: /* MBO command was not 00, 01 or 02-The first byte of the CB was
156 invalid. This usually indicates a software failure. */
157
158 case 0x16: /* Invalid CCB Operation Code-The first byte of the CCB was invalid.
159 This usually indicates a software failure. */
160
161 case 0x17: /* Linked CCB does not have the same LUN-A subsequent CCB of a set
162 of linked CCB's does not specify the same logical unit number as
163 the first. */
164 case 0x18: /* Invalid Target Direction received from Host-The direction of a
165 Target Mode CCB was invalid. */
166
167 case 0x19: /* Duplicate CCB Received in Target Mode-More than once CCB was
168 received to service data transfer between the same target LUN
169 and initiator SCSI ID in the same direction. */
170
171 case 0x1a: /* Invalid CCB or Segment List Parameter-A segment list with a zero
172 length segment or invalid segment list boundaries was received.
173 A CCB parameter was invalid. */
174 #ifdef DEBUG
175 printk("Aha1542: %x %x\n", hosterr, scsierr);
176 #endif
177 hosterr = DID_ERROR; /* Couldn't find any better */
178 break;
179
180 case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus
181 phase sequence was requested by the target. The host adapter
182 will generate a SCSI Reset Condition, notifying the host with
183 a SCRD interrupt */
184 hosterr = DID_RESET;
185 break;
186 default:
187 printk(KERN_ERR "aha1542: makecode: unknown hoststatus %x\n", hosterr);
188 break;
189 }
190 return scsierr | (hosterr << 16);
191 }
192
aha1542_test_port(struct Scsi_Host * sh)193 static int aha1542_test_port(struct Scsi_Host *sh)
194 {
195 u8 inquiry_result[4];
196 int i;
197
198 /* Quick and dirty test for presence of the card. */
199 if (inb(STATUS(sh->io_port)) == 0xff)
200 return 0;
201
202 /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */
203
204 /* In case some other card was probing here, reset interrupts */
205 aha1542_intr_reset(sh->io_port); /* reset interrupts, so they don't block */
206
207 outb(SRST | IRST /*|SCRST */ , CONTROL(sh->io_port));
208
209 mdelay(20); /* Wait a little bit for things to settle down. */
210
211 /* Expect INIT and IDLE, any of the others are bad */
212 if (!wait_mask(STATUS(sh->io_port), STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0))
213 return 0;
214
215 /* Shouldn't have generated any interrupts during reset */
216 if (inb(INTRFLAGS(sh->io_port)) & INTRMASK)
217 return 0;
218
219 /* Perform a host adapter inquiry instead so we do not need to set
220 up the mailboxes ahead of time */
221
222 aha1542_outb(sh->io_port, CMD_INQUIRY);
223
224 for (i = 0; i < 4; i++) {
225 if (!wait_mask(STATUS(sh->io_port), DF, DF, 0, 0))
226 return 0;
227 inquiry_result[i] = inb(DATA(sh->io_port));
228 }
229
230 /* Reading port should reset DF */
231 if (inb(STATUS(sh->io_port)) & DF)
232 return 0;
233
234 /* When HACC, command is completed, and we're though testing */
235 if (!wait_mask(INTRFLAGS(sh->io_port), HACC, HACC, 0, 0))
236 return 0;
237
238 /* Clear interrupts */
239 outb(IRST, CONTROL(sh->io_port));
240
241 return 1;
242 }
243
aha1542_free_cmd(struct scsi_cmnd * cmd)244 static void aha1542_free_cmd(struct scsi_cmnd *cmd)
245 {
246 struct aha1542_cmd *acmd = scsi_cmd_priv(cmd);
247 struct device *dev = cmd->device->host->dma_dev;
248 size_t len = scsi_sg_count(cmd) * sizeof(struct chain);
249
250 if (acmd->chain) {
251 dma_unmap_single(dev, acmd->chain_handle, len, DMA_TO_DEVICE);
252 kfree(acmd->chain);
253 }
254
255 acmd->chain = NULL;
256 scsi_dma_unmap(cmd);
257 }
258
aha1542_interrupt(int irq,void * dev_id)259 static irqreturn_t aha1542_interrupt(int irq, void *dev_id)
260 {
261 struct Scsi_Host *sh = dev_id;
262 struct aha1542_hostdata *aha1542 = shost_priv(sh);
263 void (*my_done)(struct scsi_cmnd *) = NULL;
264 int errstatus, mbi, mbo, mbistatus;
265 int number_serviced;
266 unsigned long flags;
267 struct scsi_cmnd *tmp_cmd;
268 int flag;
269 struct mailbox *mb = aha1542->mb;
270 struct ccb *ccb = aha1542->ccb;
271
272 #ifdef DEBUG
273 {
274 flag = inb(INTRFLAGS(sh->io_port));
275 shost_printk(KERN_DEBUG, sh, "aha1542_intr_handle: ");
276 if (!(flag & ANYINTR))
277 printk("no interrupt?");
278 if (flag & MBIF)
279 printk("MBIF ");
280 if (flag & MBOA)
281 printk("MBOF ");
282 if (flag & HACC)
283 printk("HACC ");
284 if (flag & SCRD)
285 printk("SCRD ");
286 printk("status %02x\n", inb(STATUS(sh->io_port)));
287 };
288 #endif
289 number_serviced = 0;
290
291 spin_lock_irqsave(sh->host_lock, flags);
292 while (1) {
293 flag = inb(INTRFLAGS(sh->io_port));
294
295 /* Check for unusual interrupts. If any of these happen, we should
296 probably do something special, but for now just printing a message
297 is sufficient. A SCSI reset detected is something that we really
298 need to deal with in some way. */
299 if (flag & ~MBIF) {
300 if (flag & MBOA)
301 printk("MBOF ");
302 if (flag & HACC)
303 printk("HACC ");
304 if (flag & SCRD)
305 printk("SCRD ");
306 }
307 aha1542_intr_reset(sh->io_port);
308
309 mbi = aha1542->aha1542_last_mbi_used + 1;
310 if (mbi >= 2 * AHA1542_MAILBOXES)
311 mbi = AHA1542_MAILBOXES;
312
313 do {
314 if (mb[mbi].status != 0)
315 break;
316 mbi++;
317 if (mbi >= 2 * AHA1542_MAILBOXES)
318 mbi = AHA1542_MAILBOXES;
319 } while (mbi != aha1542->aha1542_last_mbi_used);
320
321 if (mb[mbi].status == 0) {
322 spin_unlock_irqrestore(sh->host_lock, flags);
323 /* Hmm, no mail. Must have read it the last time around */
324 if (!number_serviced)
325 shost_printk(KERN_WARNING, sh, "interrupt received, but no mail.\n");
326 return IRQ_HANDLED;
327 };
328
329 mbo = (scsi2int(mb[mbi].ccbptr) - (unsigned long)aha1542->ccb_handle) / sizeof(struct ccb);
330 mbistatus = mb[mbi].status;
331 mb[mbi].status = 0;
332 aha1542->aha1542_last_mbi_used = mbi;
333
334 #ifdef DEBUG
335 if (ccb[mbo].tarstat | ccb[mbo].hastat)
336 shost_printk(KERN_DEBUG, sh, "aha1542_command: returning %x (status %d)\n",
337 ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status);
338 #endif
339
340 if (mbistatus == 3)
341 continue; /* Aborted command not found */
342
343 #ifdef DEBUG
344 shost_printk(KERN_DEBUG, sh, "...done %d %d\n", mbo, mbi);
345 #endif
346
347 tmp_cmd = aha1542->int_cmds[mbo];
348
349 if (!tmp_cmd || !tmp_cmd->scsi_done) {
350 spin_unlock_irqrestore(sh->host_lock, flags);
351 shost_printk(KERN_WARNING, sh, "Unexpected interrupt\n");
352 shost_printk(KERN_WARNING, sh, "tarstat=%x, hastat=%x idlun=%x ccb#=%d\n", ccb[mbo].tarstat,
353 ccb[mbo].hastat, ccb[mbo].idlun, mbo);
354 return IRQ_HANDLED;
355 }
356 my_done = tmp_cmd->scsi_done;
357 aha1542_free_cmd(tmp_cmd);
358 /* Fetch the sense data, and tuck it away, in the required slot. The
359 Adaptec automatically fetches it, and there is no guarantee that
360 we will still have it in the cdb when we come back */
361 if (ccb[mbo].tarstat == 2)
362 memcpy(tmp_cmd->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen],
363 SCSI_SENSE_BUFFERSIZE);
364
365
366 /* is there mail :-) */
367
368 /* more error checking left out here */
369 if (mbistatus != 1)
370 /* This is surely wrong, but I don't know what's right */
371 errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
372 else
373 errstatus = 0;
374
375 #ifdef DEBUG
376 if (errstatus)
377 shost_printk(KERN_DEBUG, sh, "(aha1542 error:%x %x %x) ", errstatus,
378 ccb[mbo].hastat, ccb[mbo].tarstat);
379 if (ccb[mbo].tarstat == 2)
380 print_hex_dump_bytes("sense: ", DUMP_PREFIX_NONE, &ccb[mbo].cdb[ccb[mbo].cdblen], 12);
381 if (errstatus)
382 printk("aha1542_intr_handle: returning %6x\n", errstatus);
383 #endif
384 tmp_cmd->result = errstatus;
385 aha1542->int_cmds[mbo] = NULL; /* This effectively frees up the mailbox slot, as
386 far as queuecommand is concerned */
387 my_done(tmp_cmd);
388 number_serviced++;
389 };
390 }
391
aha1542_queuecommand(struct Scsi_Host * sh,struct scsi_cmnd * cmd)392 static int aha1542_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
393 {
394 struct aha1542_cmd *acmd = scsi_cmd_priv(cmd);
395 struct aha1542_hostdata *aha1542 = shost_priv(sh);
396 u8 direction;
397 u8 target = cmd->device->id;
398 u8 lun = cmd->device->lun;
399 unsigned long flags;
400 int bufflen = scsi_bufflen(cmd);
401 int mbo, sg_count;
402 struct mailbox *mb = aha1542->mb;
403 struct ccb *ccb = aha1542->ccb;
404
405 if (*cmd->cmnd == REQUEST_SENSE) {
406 /* Don't do the command - we have the sense data already */
407 cmd->result = 0;
408 cmd->scsi_done(cmd);
409 return 0;
410 }
411 #ifdef DEBUG
412 {
413 int i = -1;
414 if (*cmd->cmnd == READ_10 || *cmd->cmnd == WRITE_10)
415 i = xscsi2int(cmd->cmnd + 2);
416 else if (*cmd->cmnd == READ_6 || *cmd->cmnd == WRITE_6)
417 i = scsi2int(cmd->cmnd + 2);
418 shost_printk(KERN_DEBUG, sh, "aha1542_queuecommand: dev %d cmd %02x pos %d len %d",
419 target, *cmd->cmnd, i, bufflen);
420 print_hex_dump_bytes("command: ", DUMP_PREFIX_NONE, cmd->cmnd, cmd->cmd_len);
421 }
422 #endif
423 sg_count = scsi_dma_map(cmd);
424 if (sg_count) {
425 size_t len = sg_count * sizeof(struct chain);
426
427 acmd->chain = kmalloc(len, GFP_DMA);
428 if (!acmd->chain)
429 goto out_unmap;
430 acmd->chain_handle = dma_map_single(sh->dma_dev, acmd->chain,
431 len, DMA_TO_DEVICE);
432 if (dma_mapping_error(sh->dma_dev, acmd->chain_handle))
433 goto out_free_chain;
434 }
435
436 /* Use the outgoing mailboxes in a round-robin fashion, because this
437 is how the host adapter will scan for them */
438
439 spin_lock_irqsave(sh->host_lock, flags);
440 mbo = aha1542->aha1542_last_mbo_used + 1;
441 if (mbo >= AHA1542_MAILBOXES)
442 mbo = 0;
443
444 do {
445 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL)
446 break;
447 mbo++;
448 if (mbo >= AHA1542_MAILBOXES)
449 mbo = 0;
450 } while (mbo != aha1542->aha1542_last_mbo_used);
451
452 if (mb[mbo].status || aha1542->int_cmds[mbo])
453 panic("Unable to find empty mailbox for aha1542.\n");
454
455 aha1542->int_cmds[mbo] = cmd; /* This will effectively prevent someone else from
456 screwing with this cdb. */
457
458 aha1542->aha1542_last_mbo_used = mbo;
459
460 #ifdef DEBUG
461 shost_printk(KERN_DEBUG, sh, "Sending command (%d %p)...", mbo, cmd->scsi_done);
462 #endif
463
464 /* This gets trashed for some reason */
465 any2scsi(mb[mbo].ccbptr, aha1542->ccb_handle + mbo * sizeof(*ccb));
466
467 memset(&ccb[mbo], 0, sizeof(struct ccb));
468
469 ccb[mbo].cdblen = cmd->cmd_len;
470
471 direction = 0;
472 if (*cmd->cmnd == READ_10 || *cmd->cmnd == READ_6)
473 direction = 8;
474 else if (*cmd->cmnd == WRITE_10 || *cmd->cmnd == WRITE_6)
475 direction = 16;
476
477 memcpy(ccb[mbo].cdb, cmd->cmnd, ccb[mbo].cdblen);
478
479 if (bufflen) {
480 struct scatterlist *sg;
481 int i;
482
483 ccb[mbo].op = 2; /* SCSI Initiator Command w/scatter-gather */
484 scsi_for_each_sg(cmd, sg, sg_count, i) {
485 any2scsi(acmd->chain[i].dataptr, sg_dma_address(sg));
486 any2scsi(acmd->chain[i].datalen, sg_dma_len(sg));
487 };
488 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain));
489 any2scsi(ccb[mbo].dataptr, acmd->chain_handle);
490 #ifdef DEBUG
491 shost_printk(KERN_DEBUG, sh, "cptr %p: ", acmd->chain);
492 print_hex_dump_bytes("cptr: ", DUMP_PREFIX_NONE, acmd->chain, 18);
493 #endif
494 } else {
495 ccb[mbo].op = 0; /* SCSI Initiator Command */
496 any2scsi(ccb[mbo].datalen, 0);
497 any2scsi(ccb[mbo].dataptr, 0);
498 };
499 ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7); /*SCSI Target Id */
500 ccb[mbo].rsalen = 16;
501 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
502 ccb[mbo].commlinkid = 0;
503
504 #ifdef DEBUG
505 print_hex_dump_bytes("sending: ", DUMP_PREFIX_NONE, &ccb[mbo], sizeof(ccb[mbo]) - 10);
506 printk("aha1542_queuecommand: now waiting for interrupt ");
507 #endif
508 mb[mbo].status = 1;
509 aha1542_outb(cmd->device->host->io_port, CMD_START_SCSI);
510 spin_unlock_irqrestore(sh->host_lock, flags);
511
512 return 0;
513 out_free_chain:
514 kfree(acmd->chain);
515 acmd->chain = NULL;
516 out_unmap:
517 scsi_dma_unmap(cmd);
518 return SCSI_MLQUEUE_HOST_BUSY;
519 }
520
521 /* Initialize mailboxes */
setup_mailboxes(struct Scsi_Host * sh)522 static void setup_mailboxes(struct Scsi_Host *sh)
523 {
524 struct aha1542_hostdata *aha1542 = shost_priv(sh);
525 u8 mb_cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
526 int i;
527
528 for (i = 0; i < AHA1542_MAILBOXES; i++) {
529 aha1542->mb[i].status = 0;
530 any2scsi(aha1542->mb[i].ccbptr,
531 aha1542->ccb_handle + i * sizeof(struct ccb));
532 aha1542->mb[AHA1542_MAILBOXES + i].status = 0;
533 };
534 aha1542_intr_reset(sh->io_port); /* reset interrupts, so they don't block */
535 any2scsi(mb_cmd + 2, aha1542->mb_handle);
536 if (aha1542_out(sh->io_port, mb_cmd, 5))
537 shost_printk(KERN_ERR, sh, "failed setting up mailboxes\n");
538 aha1542_intr_reset(sh->io_port);
539 }
540
aha1542_getconfig(struct Scsi_Host * sh)541 static int aha1542_getconfig(struct Scsi_Host *sh)
542 {
543 u8 inquiry_result[3];
544 int i;
545 i = inb(STATUS(sh->io_port));
546 if (i & DF) {
547 i = inb(DATA(sh->io_port));
548 };
549 aha1542_outb(sh->io_port, CMD_RETCONF);
550 aha1542_in(sh->io_port, inquiry_result, 3, 0);
551 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0))
552 shost_printk(KERN_ERR, sh, "error querying board settings\n");
553 aha1542_intr_reset(sh->io_port);
554 switch (inquiry_result[0]) {
555 case 0x80:
556 sh->dma_channel = 7;
557 break;
558 case 0x40:
559 sh->dma_channel = 6;
560 break;
561 case 0x20:
562 sh->dma_channel = 5;
563 break;
564 case 0x01:
565 sh->dma_channel = 0;
566 break;
567 case 0:
568 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
569 Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
570 sh->dma_channel = 0xFF;
571 break;
572 default:
573 shost_printk(KERN_ERR, sh, "Unable to determine DMA channel.\n");
574 return -1;
575 };
576 switch (inquiry_result[1]) {
577 case 0x40:
578 sh->irq = 15;
579 break;
580 case 0x20:
581 sh->irq = 14;
582 break;
583 case 0x8:
584 sh->irq = 12;
585 break;
586 case 0x4:
587 sh->irq = 11;
588 break;
589 case 0x2:
590 sh->irq = 10;
591 break;
592 case 0x1:
593 sh->irq = 9;
594 break;
595 default:
596 shost_printk(KERN_ERR, sh, "Unable to determine IRQ level.\n");
597 return -1;
598 };
599 sh->this_id = inquiry_result[2] & 7;
600 return 0;
601 }
602
603 /* This function should only be called for 1542C boards - we can detect
604 the special firmware settings and unlock the board */
605
aha1542_mbenable(struct Scsi_Host * sh)606 static int aha1542_mbenable(struct Scsi_Host *sh)
607 {
608 static u8 mbenable_cmd[3];
609 static u8 mbenable_result[2];
610 int retval;
611
612 retval = BIOS_TRANSLATION_6432;
613
614 aha1542_outb(sh->io_port, CMD_EXTBIOS);
615 if (aha1542_in(sh->io_port, mbenable_result, 2, 100))
616 return retval;
617 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 100))
618 goto fail;
619 aha1542_intr_reset(sh->io_port);
620
621 if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
622 mbenable_cmd[0] = CMD_MBENABLE;
623 mbenable_cmd[1] = 0;
624 mbenable_cmd[2] = mbenable_result[1];
625
626 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
627 retval = BIOS_TRANSLATION_25563;
628
629 if (aha1542_out(sh->io_port, mbenable_cmd, 3))
630 goto fail;
631 };
632 while (0) {
633 fail:
634 shost_printk(KERN_ERR, sh, "Mailbox init failed\n");
635 }
636 aha1542_intr_reset(sh->io_port);
637 return retval;
638 }
639
640 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */
aha1542_query(struct Scsi_Host * sh)641 static int aha1542_query(struct Scsi_Host *sh)
642 {
643 struct aha1542_hostdata *aha1542 = shost_priv(sh);
644 u8 inquiry_result[4];
645 int i;
646 i = inb(STATUS(sh->io_port));
647 if (i & DF) {
648 i = inb(DATA(sh->io_port));
649 };
650 aha1542_outb(sh->io_port, CMD_INQUIRY);
651 aha1542_in(sh->io_port, inquiry_result, 4, 0);
652 if (!wait_mask(INTRFLAGS(sh->io_port), INTRMASK, HACC, 0, 0))
653 shost_printk(KERN_ERR, sh, "error querying card type\n");
654 aha1542_intr_reset(sh->io_port);
655
656 aha1542->bios_translation = BIOS_TRANSLATION_6432; /* Default case */
657
658 /* For an AHA1740 series board, we ignore the board since there is a
659 hardware bug which can lead to wrong blocks being returned if the board
660 is operating in the 1542 emulation mode. Since there is an extended mode
661 driver, we simply ignore the board and let the 1740 driver pick it up.
662 */
663
664 if (inquiry_result[0] == 0x43) {
665 shost_printk(KERN_INFO, sh, "Emulation mode not supported for AHA-1740 hardware, use aha1740 driver instead.\n");
666 return 1;
667 };
668
669 /* Always call this - boards that do not support extended bios translation
670 will ignore the command, and we will set the proper default */
671
672 aha1542->bios_translation = aha1542_mbenable(sh);
673
674 return 0;
675 }
676
dma_speed_hw(int dma_speed)677 static u8 dma_speed_hw(int dma_speed)
678 {
679 switch (dma_speed) {
680 case 5:
681 return 0x00;
682 case 6:
683 return 0x04;
684 case 7:
685 return 0x01;
686 case 8:
687 return 0x02;
688 case 10:
689 return 0x03;
690 }
691
692 return 0xff; /* invalid */
693 }
694
695 /* Set the Bus on/off-times as not to ruin floppy performance */
aha1542_set_bus_times(struct Scsi_Host * sh,int bus_on,int bus_off,int dma_speed)696 static void aha1542_set_bus_times(struct Scsi_Host *sh, int bus_on, int bus_off, int dma_speed)
697 {
698 if (bus_on > 0) {
699 u8 oncmd[] = { CMD_BUSON_TIME, clamp(bus_on, 2, 15) };
700
701 aha1542_intr_reset(sh->io_port);
702 if (aha1542_out(sh->io_port, oncmd, 2))
703 goto fail;
704 }
705
706 if (bus_off > 0) {
707 u8 offcmd[] = { CMD_BUSOFF_TIME, clamp(bus_off, 1, 64) };
708
709 aha1542_intr_reset(sh->io_port);
710 if (aha1542_out(sh->io_port, offcmd, 2))
711 goto fail;
712 }
713
714 if (dma_speed_hw(dma_speed) != 0xff) {
715 u8 dmacmd[] = { CMD_DMASPEED, dma_speed_hw(dma_speed) };
716
717 aha1542_intr_reset(sh->io_port);
718 if (aha1542_out(sh->io_port, dmacmd, 2))
719 goto fail;
720 }
721 aha1542_intr_reset(sh->io_port);
722 return;
723 fail:
724 shost_printk(KERN_ERR, sh, "setting bus on/off-time failed\n");
725 aha1542_intr_reset(sh->io_port);
726 }
727
728 /* return non-zero on detection */
aha1542_hw_init(struct scsi_host_template * tpnt,struct device * pdev,int indx)729 static struct Scsi_Host *aha1542_hw_init(struct scsi_host_template *tpnt, struct device *pdev, int indx)
730 {
731 unsigned int base_io = io[indx];
732 struct Scsi_Host *sh;
733 struct aha1542_hostdata *aha1542;
734 char dma_info[] = "no DMA";
735
736 if (base_io == 0)
737 return NULL;
738
739 if (!request_region(base_io, AHA1542_REGION_SIZE, "aha1542"))
740 return NULL;
741
742 sh = scsi_host_alloc(tpnt, sizeof(struct aha1542_hostdata));
743 if (!sh)
744 goto release;
745 aha1542 = shost_priv(sh);
746
747 sh->unique_id = base_io;
748 sh->io_port = base_io;
749 sh->n_io_port = AHA1542_REGION_SIZE;
750 aha1542->aha1542_last_mbi_used = 2 * AHA1542_MAILBOXES - 1;
751 aha1542->aha1542_last_mbo_used = AHA1542_MAILBOXES - 1;
752
753 if (!aha1542_test_port(sh))
754 goto unregister;
755
756 aha1542_set_bus_times(sh, bus_on[indx], bus_off[indx], dma_speed[indx]);
757 if (aha1542_query(sh))
758 goto unregister;
759 if (aha1542_getconfig(sh) == -1)
760 goto unregister;
761
762 if (sh->dma_channel != 0xFF)
763 snprintf(dma_info, sizeof(dma_info), "DMA %d", sh->dma_channel);
764 shost_printk(KERN_INFO, sh, "Adaptec AHA-1542 (SCSI-ID %d) at IO 0x%x, IRQ %d, %s\n",
765 sh->this_id, base_io, sh->irq, dma_info);
766 if (aha1542->bios_translation == BIOS_TRANSLATION_25563)
767 shost_printk(KERN_INFO, sh, "Using extended bios translation\n");
768
769 if (dma_set_mask_and_coherent(pdev, DMA_BIT_MASK(24)) < 0)
770 goto unregister;
771
772 aha1542->mb = dma_alloc_coherent(pdev,
773 AHA1542_MAILBOXES * 2 * sizeof(struct mailbox),
774 &aha1542->mb_handle, GFP_KERNEL);
775 if (!aha1542->mb)
776 goto unregister;
777
778 aha1542->ccb = dma_alloc_coherent(pdev,
779 AHA1542_MAILBOXES * sizeof(struct ccb),
780 &aha1542->ccb_handle, GFP_KERNEL);
781 if (!aha1542->ccb)
782 goto free_mb;
783
784 setup_mailboxes(sh);
785
786 if (request_irq(sh->irq, aha1542_interrupt, 0, "aha1542", sh)) {
787 shost_printk(KERN_ERR, sh, "Unable to allocate IRQ.\n");
788 goto free_ccb;
789 }
790 if (sh->dma_channel != 0xFF) {
791 if (request_dma(sh->dma_channel, "aha1542")) {
792 shost_printk(KERN_ERR, sh, "Unable to allocate DMA channel.\n");
793 goto free_irq;
794 }
795 if (sh->dma_channel == 0 || sh->dma_channel >= 5) {
796 set_dma_mode(sh->dma_channel, DMA_MODE_CASCADE);
797 enable_dma(sh->dma_channel);
798 }
799 }
800
801 if (scsi_add_host(sh, pdev))
802 goto free_dma;
803
804 scsi_scan_host(sh);
805
806 return sh;
807
808 free_dma:
809 if (sh->dma_channel != 0xff)
810 free_dma(sh->dma_channel);
811 free_irq:
812 free_irq(sh->irq, sh);
813 free_ccb:
814 dma_free_coherent(pdev, AHA1542_MAILBOXES * sizeof(struct ccb),
815 aha1542->ccb, aha1542->ccb_handle);
816 free_mb:
817 dma_free_coherent(pdev, AHA1542_MAILBOXES * 2 * sizeof(struct mailbox),
818 aha1542->mb, aha1542->mb_handle);
819 unregister:
820 scsi_host_put(sh);
821 release:
822 release_region(base_io, AHA1542_REGION_SIZE);
823
824 return NULL;
825 }
826
aha1542_release(struct Scsi_Host * sh)827 static int aha1542_release(struct Scsi_Host *sh)
828 {
829 struct aha1542_hostdata *aha1542 = shost_priv(sh);
830 struct device *dev = sh->dma_dev;
831
832 scsi_remove_host(sh);
833 if (sh->dma_channel != 0xff)
834 free_dma(sh->dma_channel);
835 dma_free_coherent(dev, AHA1542_MAILBOXES * sizeof(struct ccb),
836 aha1542->ccb, aha1542->ccb_handle);
837 dma_free_coherent(dev, AHA1542_MAILBOXES * 2 * sizeof(struct mailbox),
838 aha1542->mb, aha1542->mb_handle);
839 if (sh->irq)
840 free_irq(sh->irq, sh);
841 if (sh->io_port && sh->n_io_port)
842 release_region(sh->io_port, sh->n_io_port);
843 scsi_host_put(sh);
844 return 0;
845 }
846
847
848 /*
849 * This is a device reset. This is handled by sending a special command
850 * to the device.
851 */
aha1542_dev_reset(struct scsi_cmnd * cmd)852 static int aha1542_dev_reset(struct scsi_cmnd *cmd)
853 {
854 struct Scsi_Host *sh = cmd->device->host;
855 struct aha1542_hostdata *aha1542 = shost_priv(sh);
856 unsigned long flags;
857 struct mailbox *mb = aha1542->mb;
858 u8 target = cmd->device->id;
859 u8 lun = cmd->device->lun;
860 int mbo;
861 struct ccb *ccb = aha1542->ccb;
862
863 spin_lock_irqsave(sh->host_lock, flags);
864 mbo = aha1542->aha1542_last_mbo_used + 1;
865 if (mbo >= AHA1542_MAILBOXES)
866 mbo = 0;
867
868 do {
869 if (mb[mbo].status == 0 && aha1542->int_cmds[mbo] == NULL)
870 break;
871 mbo++;
872 if (mbo >= AHA1542_MAILBOXES)
873 mbo = 0;
874 } while (mbo != aha1542->aha1542_last_mbo_used);
875
876 if (mb[mbo].status || aha1542->int_cmds[mbo])
877 panic("Unable to find empty mailbox for aha1542.\n");
878
879 aha1542->int_cmds[mbo] = cmd; /* This will effectively
880 prevent someone else from
881 screwing with this cdb. */
882
883 aha1542->aha1542_last_mbo_used = mbo;
884
885 /* This gets trashed for some reason */
886 any2scsi(mb[mbo].ccbptr, aha1542->ccb_handle + mbo * sizeof(*ccb));
887
888 memset(&ccb[mbo], 0, sizeof(struct ccb));
889
890 ccb[mbo].op = 0x81; /* BUS DEVICE RESET */
891
892 ccb[mbo].idlun = (target & 7) << 5 | (lun & 7); /*SCSI Target Id */
893
894 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
895 ccb[mbo].commlinkid = 0;
896
897 /*
898 * Now tell the 1542 to flush all pending commands for this
899 * target
900 */
901 aha1542_outb(sh->io_port, CMD_START_SCSI);
902 spin_unlock_irqrestore(sh->host_lock, flags);
903
904 scmd_printk(KERN_WARNING, cmd,
905 "Trying device reset for target\n");
906
907 return SUCCESS;
908 }
909
aha1542_reset(struct scsi_cmnd * cmd,u8 reset_cmd)910 static int aha1542_reset(struct scsi_cmnd *cmd, u8 reset_cmd)
911 {
912 struct Scsi_Host *sh = cmd->device->host;
913 struct aha1542_hostdata *aha1542 = shost_priv(sh);
914 unsigned long flags;
915 int i;
916
917 spin_lock_irqsave(sh->host_lock, flags);
918 /*
919 * This does a scsi reset for all devices on the bus.
920 * In principle, we could also reset the 1542 - should
921 * we do this? Try this first, and we can add that later
922 * if it turns out to be useful.
923 */
924 outb(reset_cmd, CONTROL(cmd->device->host->io_port));
925
926 if (!wait_mask(STATUS(cmd->device->host->io_port),
927 STATMASK, IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0)) {
928 spin_unlock_irqrestore(sh->host_lock, flags);
929 return FAILED;
930 }
931
932 /*
933 * We need to do this too before the 1542 can interact with
934 * us again after host reset.
935 */
936 if (reset_cmd & HRST)
937 setup_mailboxes(cmd->device->host);
938
939 /*
940 * Now try to pick up the pieces. For all pending commands,
941 * free any internal data structures, and basically clear things
942 * out. We do not try and restart any commands or anything -
943 * the strategy handler takes care of that crap.
944 */
945 shost_printk(KERN_WARNING, cmd->device->host, "Sent BUS RESET to scsi host %d\n", cmd->device->host->host_no);
946
947 for (i = 0; i < AHA1542_MAILBOXES; i++) {
948 if (aha1542->int_cmds[i] != NULL) {
949 struct scsi_cmnd *tmp_cmd;
950 tmp_cmd = aha1542->int_cmds[i];
951
952 if (tmp_cmd->device->soft_reset) {
953 /*
954 * If this device implements the soft reset option,
955 * then it is still holding onto the command, and
956 * may yet complete it. In this case, we don't
957 * flush the data.
958 */
959 continue;
960 }
961 aha1542_free_cmd(tmp_cmd);
962 aha1542->int_cmds[i] = NULL;
963 aha1542->mb[i].status = 0;
964 }
965 }
966
967 spin_unlock_irqrestore(sh->host_lock, flags);
968 return SUCCESS;
969 }
970
aha1542_bus_reset(struct scsi_cmnd * cmd)971 static int aha1542_bus_reset(struct scsi_cmnd *cmd)
972 {
973 return aha1542_reset(cmd, SCRST);
974 }
975
aha1542_host_reset(struct scsi_cmnd * cmd)976 static int aha1542_host_reset(struct scsi_cmnd *cmd)
977 {
978 return aha1542_reset(cmd, HRST | SCRST);
979 }
980
aha1542_biosparam(struct scsi_device * sdev,struct block_device * bdev,sector_t capacity,int geom[])981 static int aha1542_biosparam(struct scsi_device *sdev,
982 struct block_device *bdev, sector_t capacity, int geom[])
983 {
984 struct aha1542_hostdata *aha1542 = shost_priv(sdev->host);
985
986 if (capacity >= 0x200000 &&
987 aha1542->bios_translation == BIOS_TRANSLATION_25563) {
988 /* Please verify that this is the same as what DOS returns */
989 geom[0] = 255; /* heads */
990 geom[1] = 63; /* sectors */
991 } else {
992 geom[0] = 64; /* heads */
993 geom[1] = 32; /* sectors */
994 }
995 geom[2] = sector_div(capacity, geom[0] * geom[1]); /* cylinders */
996
997 return 0;
998 }
999 MODULE_LICENSE("GPL");
1000
1001 static struct scsi_host_template driver_template = {
1002 .module = THIS_MODULE,
1003 .proc_name = "aha1542",
1004 .name = "Adaptec 1542",
1005 .cmd_size = sizeof(struct aha1542_cmd),
1006 .queuecommand = aha1542_queuecommand,
1007 .eh_device_reset_handler= aha1542_dev_reset,
1008 .eh_bus_reset_handler = aha1542_bus_reset,
1009 .eh_host_reset_handler = aha1542_host_reset,
1010 .bios_param = aha1542_biosparam,
1011 .can_queue = AHA1542_MAILBOXES,
1012 .this_id = 7,
1013 .sg_tablesize = 16,
1014 .unchecked_isa_dma = 1,
1015 };
1016
aha1542_isa_match(struct device * pdev,unsigned int ndev)1017 static int aha1542_isa_match(struct device *pdev, unsigned int ndev)
1018 {
1019 struct Scsi_Host *sh = aha1542_hw_init(&driver_template, pdev, ndev);
1020
1021 if (!sh)
1022 return 0;
1023
1024 dev_set_drvdata(pdev, sh);
1025 return 1;
1026 }
1027
aha1542_isa_remove(struct device * pdev,unsigned int ndev)1028 static int aha1542_isa_remove(struct device *pdev,
1029 unsigned int ndev)
1030 {
1031 aha1542_release(dev_get_drvdata(pdev));
1032 dev_set_drvdata(pdev, NULL);
1033 return 0;
1034 }
1035
1036 static struct isa_driver aha1542_isa_driver = {
1037 .match = aha1542_isa_match,
1038 .remove = aha1542_isa_remove,
1039 .driver = {
1040 .name = "aha1542"
1041 },
1042 };
1043 static int isa_registered;
1044
1045 #ifdef CONFIG_PNP
1046 static const struct pnp_device_id aha1542_pnp_ids[] = {
1047 { .id = "ADP1542" },
1048 { .id = "" }
1049 };
1050 MODULE_DEVICE_TABLE(pnp, aha1542_pnp_ids);
1051
aha1542_pnp_probe(struct pnp_dev * pdev,const struct pnp_device_id * id)1052 static int aha1542_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id)
1053 {
1054 int indx;
1055 struct Scsi_Host *sh;
1056
1057 for (indx = 0; indx < ARRAY_SIZE(io); indx++) {
1058 if (io[indx])
1059 continue;
1060
1061 if (pnp_activate_dev(pdev) < 0)
1062 continue;
1063
1064 io[indx] = pnp_port_start(pdev, 0);
1065
1066 /* The card can be queried for its DMA, we have
1067 the DMA set up that is enough */
1068
1069 dev_info(&pdev->dev, "ISAPnP found an AHA1535 at I/O 0x%03X", io[indx]);
1070 }
1071
1072 sh = aha1542_hw_init(&driver_template, &pdev->dev, indx);
1073 if (!sh)
1074 return -ENODEV;
1075
1076 pnp_set_drvdata(pdev, sh);
1077 return 0;
1078 }
1079
aha1542_pnp_remove(struct pnp_dev * pdev)1080 static void aha1542_pnp_remove(struct pnp_dev *pdev)
1081 {
1082 aha1542_release(pnp_get_drvdata(pdev));
1083 pnp_set_drvdata(pdev, NULL);
1084 }
1085
1086 static struct pnp_driver aha1542_pnp_driver = {
1087 .name = "aha1542",
1088 .id_table = aha1542_pnp_ids,
1089 .probe = aha1542_pnp_probe,
1090 .remove = aha1542_pnp_remove,
1091 };
1092 static int pnp_registered;
1093 #endif /* CONFIG_PNP */
1094
aha1542_init(void)1095 static int __init aha1542_init(void)
1096 {
1097 int ret = 0;
1098
1099 #ifdef CONFIG_PNP
1100 if (isapnp) {
1101 ret = pnp_register_driver(&aha1542_pnp_driver);
1102 if (!ret)
1103 pnp_registered = 1;
1104 }
1105 #endif
1106 ret = isa_register_driver(&aha1542_isa_driver, MAXBOARDS);
1107 if (!ret)
1108 isa_registered = 1;
1109
1110 #ifdef CONFIG_PNP
1111 if (pnp_registered)
1112 ret = 0;
1113 #endif
1114 if (isa_registered)
1115 ret = 0;
1116
1117 return ret;
1118 }
1119
aha1542_exit(void)1120 static void __exit aha1542_exit(void)
1121 {
1122 #ifdef CONFIG_PNP
1123 if (pnp_registered)
1124 pnp_unregister_driver(&aha1542_pnp_driver);
1125 #endif
1126 if (isa_registered)
1127 isa_unregister_driver(&aha1542_isa_driver);
1128 }
1129
1130 module_init(aha1542_init);
1131 module_exit(aha1542_exit);
1132
