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