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