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