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