Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
aha152x.c
Go to the documentation of this file.
1 /* aha152x.c -- Adaptec AHA-152x driver
2  * Author: Jürgen E. Fischer, [email protected]
3  * Copyright 1993-2004 Jürgen E. Fischer
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License as published by the
7  * Free Software Foundation; either version 2, or (at your option) any
8  * later version.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * General Public License for more details.
14  *
15  *
16  * $Id: aha152x.c,v 2.7 2004/01/24 11:42:59 fischer Exp $
17  *
18  * $Log: aha152x.c,v $
19  * Revision 2.7 2004/01/24 11:42:59 fischer
20  * - gather code that is not used by PCMCIA at the end
21  * - move request_region for !PCMCIA case to detection
22  * - migration to new scsi host api (remove legacy code)
23  * - free host scribble before scsi_done
24  * - fix error handling
25  * - one isapnp device added to id_table
26  *
27  * Revision 2.6 2003/10/30 20:52:47 fischer
28  * - interfaces changes for kernel 2.6
29  * - aha152x_probe_one introduced for pcmcia stub
30  * - fixed pnpdev handling
31  * - instead of allocation a new one, reuse command for request sense after check condition and reset
32  * - fixes race in is_complete
33  *
34  * Revision 2.5 2002/04/14 11:24:53 fischer
35  * - isapnp support
36  * - abort fixed
37  * - 2.5 support
38  *
39  * Revision 2.4 2000/12/16 12:53:56 fischer
40  * - allow REQUEST SENSE to be queued
41  * - handle shared PCI interrupts
42  *
43  * Revision 2.3 2000/11/04 16:40:26 fischer
44  * - handle data overruns
45  * - extend timeout for data phases
46  *
47  * Revision 2.2 2000/08/08 19:54:53 fischer
48  * - minor changes
49  *
50  * Revision 2.1 2000/05/17 16:23:17 fischer
51  * - signature update
52  * - fix for data out w/o scatter gather
53  *
54  * Revision 2.0 1999/12/25 15:07:32 fischer
55  * - interrupt routine completly reworked
56  * - basic support for new eh code
57  *
58  * Revision 1.21 1999/11/10 23:46:36 fischer
59  * - default to synchronous operation
60  * - synchronous negotiation fixed
61  * - added timeout to loops
62  * - debugging output can be controlled through procfs
63  *
64  * Revision 1.20 1999/11/07 18:37:31 fischer
65  * - synchronous operation works
66  * - resid support for sg driver
67  *
68  * Revision 1.19 1999/11/02 22:39:59 fischer
69  * - moved leading comments to README.aha152x
70  * - new additional module parameters
71  * - updates for 2.3
72  * - support for the Tripace TC1550 controller
73  * - interrupt handling changed
74  *
75  * Revision 1.18 1996/09/07 20:10:40 fischer
76  * - fixed can_queue handling (multiple outstanding commands working again)
77  *
78  * Revision 1.17 1996/08/17 16:05:14 fischer
79  * - biosparam improved
80  * - interrupt verification
81  * - updated documentation
82  * - cleanups
83  *
84  * Revision 1.16 1996/06/09 00:04:56 root
85  * - added configuration symbols for insmod (aha152x/aha152x1)
86  *
87  * Revision 1.15 1996/04/30 14:52:06 fischer
88  * - proc info fixed
89  * - support for extended translation for >1GB disks
90  *
91  * Revision 1.14 1996/01/17 15:11:20 fischer
92  * - fixed lockup in MESSAGE IN phase after reconnection
93  *
94  * Revision 1.13 1996/01/09 02:15:53 fischer
95  * - some cleanups
96  * - moved request_irq behind controller initialization
97  * (to avoid spurious interrupts)
98  *
99  * Revision 1.12 1995/12/16 12:26:07 fischer
100  * - barrier()s added
101  * - configurable RESET delay added
102  *
103  * Revision 1.11 1995/12/06 21:18:35 fischer
104  * - some minor updates
105  *
106  * Revision 1.10 1995/07/22 19:18:45 fischer
107  * - support for 2 controllers
108  * - started synchronous data transfers (not working yet)
109  *
110  * Revision 1.9 1995/03/18 09:20:24 root
111  * - patches for PCMCIA and modules
112  *
113  * Revision 1.8 1995/01/21 22:07:19 root
114  * - snarf_region => request_region
115  * - aha152x_intr interface change
116  *
117  * Revision 1.7 1995/01/02 23:19:36 root
118  * - updated COMMAND_SIZE to cmd_len
119  * - changed sti() to restore_flags()
120  * - fixed some #ifdef which generated warnings
121  *
122  * Revision 1.6 1994/11/24 20:35:27 root
123  * - problem with odd number of bytes in fifo fixed
124  *
125  * Revision 1.5 1994/10/30 14:39:56 root
126  * - abort code fixed
127  * - debugging improved
128  *
129  * Revision 1.4 1994/09/12 11:33:01 root
130  * - irqaction to request_irq
131  * - abortion updated
132  *
133  * Revision 1.3 1994/08/04 13:53:05 root
134  * - updates for mid-level-driver changes
135  * - accept unexpected BUSFREE phase as error condition
136  * - parity check now configurable
137  *
138  * Revision 1.2 1994/07/03 12:56:36 root
139  * - cleaned up debugging code
140  * - more tweaking on reset delays
141  * - updated abort/reset code (pretty untested...)
142  *
143  * Revision 1.1 1994/05/28 21:18:49 root
144  * - update for mid-level interface change (abort-reset)
145  * - delays after resets adjusted for some slow devices
146  *
147  * Revision 1.0 1994/03/25 12:52:00 root
148  * - Fixed "more data than expected" problem
149  * - added new BIOS signatures
150  *
151  * Revision 0.102 1994/01/31 20:44:12 root
152  * - minor changes in insw/outsw handling
153  *
154  * Revision 0.101 1993/12/13 01:16:27 root
155  * - fixed STATUS phase (non-GOOD stati were dropped sometimes;
156  * fixes problems with CD-ROM sector size detection & media change)
157  *
158  * Revision 0.100 1993/12/10 16:58:47 root
159  * - fix for unsuccessful selections in case of non-continuous id assignments
160  * on the scsi bus.
161  *
162  * Revision 0.99 1993/10/24 16:19:59 root
163  * - fixed DATA IN (rare read errors gone)
164  *
165  * Revision 0.98 1993/10/17 12:54:44 root
166  * - fixed some recent fixes (shame on me)
167  * - moved initialization of scratch area to aha152x_queue
168  *
169  * Revision 0.97 1993/10/09 18:53:53 root
170  * - DATA IN fixed. Rarely left data in the fifo.
171  *
172  * Revision 0.96 1993/10/03 00:53:59 root
173  * - minor changes on DATA IN
174  *
175  * Revision 0.95 1993/09/24 10:36:01 root
176  * - change handling of MSGI after reselection
177  * - fixed sti/cli
178  * - minor changes
179  *
180  * Revision 0.94 1993/09/18 14:08:22 root
181  * - fixed bug in multiple outstanding command code
182  * - changed detection
183  * - support for kernel command line configuration
184  * - reset corrected
185  * - changed message handling
186  *
187  * Revision 0.93 1993/09/15 20:41:19 root
188  * - fixed bugs with multiple outstanding commands
189  *
190  * Revision 0.92 1993/09/13 02:46:33 root
191  * - multiple outstanding commands work (no problems with IBM drive)
192  *
193  * Revision 0.91 1993/09/12 20:51:46 root
194  * added multiple outstanding commands
195  * (some problem with this $%&? IBM device remain)
196  *
197  * Revision 0.9 1993/09/12 11:11:22 root
198  * - corrected auto-configuration
199  * - changed the auto-configuration (added some '#define's)
200  * - added support for dis-/reconnection
201  *
202  * Revision 0.8 1993/09/06 23:09:39 root
203  * - added support for the drive activity light
204  * - minor changes
205  *
206  * Revision 0.7 1993/09/05 14:30:15 root
207  * - improved phase detection
208  * - now using the new snarf_region code of 0.99pl13
209  *
210  * Revision 0.6 1993/09/02 11:01:38 root
211  * first public release; added some signatures and biosparam()
212  *
213  * Revision 0.5 1993/08/30 10:23:30 root
214  * fixed timing problems with my IBM drive
215  *
216  * Revision 0.4 1993/08/29 14:06:52 root
217  * fixed some problems with timeouts due incomplete commands
218  *
219  * Revision 0.3 1993/08/28 15:55:03 root
220  * writing data works too. mounted and worked on a dos partition
221  *
222  * Revision 0.2 1993/08/27 22:42:07 root
223  * reading data works. Mounted a msdos partition.
224  *
225  * Revision 0.1 1993/08/25 13:38:30 root
226  * first "damn thing doesn't work" version
227  *
228  * Revision 0.0 1993/08/14 19:54:25 root
229  * empty function bodies; detect() works.
230  *
231  *
232  **************************************************************************
233 
234  see Documentation/scsi/aha152x.txt for configuration details
235 
236  **************************************************************************/
237 
238 #include <linux/module.h>
239 #include <asm/irq.h>
240 #include <linux/io.h>
241 #include <linux/blkdev.h>
242 #include <linux/completion.h>
243 #include <linux/errno.h>
244 #include <linux/string.h>
245 #include <linux/wait.h>
246 #include <linux/ioport.h>
247 #include <linux/delay.h>
248 #include <linux/proc_fs.h>
249 #include <linux/interrupt.h>
250 #include <linux/init.h>
251 #include <linux/kernel.h>
252 #include <linux/isapnp.h>
253 #include <linux/spinlock.h>
254 #include <linux/workqueue.h>
255 #include <linux/list.h>
256 #include <linux/slab.h>
257 #include <scsi/scsicam.h>
258 
259 #include "scsi.h"
260 #include <scsi/scsi_dbg.h>
261 #include <scsi/scsi_host.h>
262 #include <scsi/scsi_transport_spi.h>
263 #include <scsi/scsi_eh.h>
264 #include "aha152x.h"
265 
266 static LIST_HEAD(aha152x_host_list);
267 
268 
269 /* DEFINES */
270 
271 /* For PCMCIA cards, always use AUTOCONF */
272 #if defined(PCMCIA) || defined(MODULE)
273 #if !defined(AUTOCONF)
274 #define AUTOCONF
275 #endif
276 #endif
277 
278 #if !defined(AUTOCONF) && !defined(SETUP0)
279 #error define AUTOCONF or SETUP0
280 #endif
281 
282 #if defined(AHA152X_DEBUG)
283 #define DEBUG_DEFAULT debug_eh
284 
285 #define DPRINTK(when,msgs...) \
286  do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0)
287 
288 #define DO_LOCK(flags) \
289  do { \
290  if(spin_is_locked(&QLOCK)) { \
291  DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __func__, __LINE__, QLOCKER, QLOCKERL); \
292  } \
293  DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
294  spin_lock_irqsave(&QLOCK,flags); \
295  DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
296  QLOCKER=__func__; \
297  QLOCKERL=__LINE__; \
298  } while(0)
299 
300 #define DO_UNLOCK(flags) \
301  do { \
302  DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __func__, __LINE__, QLOCKER, QLOCKERL); \
303  spin_unlock_irqrestore(&QLOCK,flags); \
304  DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
305  QLOCKER="(not locked)"; \
306  QLOCKERL=0; \
307  } while(0)
308 
309 #else
310 #define DPRINTK(when,msgs...)
311 #define DO_LOCK(flags) spin_lock_irqsave(&QLOCK,flags)
312 #define DO_UNLOCK(flags) spin_unlock_irqrestore(&QLOCK,flags)
313 #endif
314 
315 #define LEAD "(scsi%d:%d:%d) "
316 #define WARN_LEAD KERN_WARNING LEAD
317 #define INFO_LEAD KERN_INFO LEAD
318 #define NOTE_LEAD KERN_NOTICE LEAD
319 #define ERR_LEAD KERN_ERR LEAD
320 #define DEBUG_LEAD KERN_DEBUG LEAD
321 #define CMDINFO(cmd) \
322  (cmd) ? ((cmd)->device->host->host_no) : -1, \
323  (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
324  (cmd) ? ((cmd)->device->lun & 0x07) : -1
325 
326 static inline void
327 CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
328 {
329  scsi_set_resid(cmd, scsi_get_resid(cmd) + inc);
330 }
331 
332 #define DELAY_DEFAULT 1000
333 
334 #if defined(PCMCIA)
335 #define IRQ_MIN 0
336 #define IRQ_MAX 16
337 #else
338 #define IRQ_MIN 9
339 #if defined(__PPC)
340 #define IRQ_MAX (nr_irqs-1)
341 #else
342 #define IRQ_MAX 12
343 #endif
344 #endif
345 
346 enum {
347  not_issued = 0x0001, /* command not yet issued */
348  selecting = 0x0002, /* target is beeing selected */
349  identified = 0x0004, /* IDENTIFY was sent */
350  disconnected = 0x0008, /* target disconnected */
351  completed = 0x0010, /* target sent COMMAND COMPLETE */
352  aborted = 0x0020, /* ABORT was sent */
353  resetted = 0x0040, /* BUS DEVICE RESET was sent */
354  spiordy = 0x0080, /* waiting for SPIORDY to raise */
355  syncneg = 0x0100, /* synchronous negotiation in progress */
356  aborting = 0x0200, /* ABORT is pending */
357  resetting = 0x0400, /* BUS DEVICE RESET is pending */
358  check_condition = 0x0800, /* requesting sense after CHECK CONDITION */
359 };
360 
361 MODULE_AUTHOR("Jürgen Fischer");
362 MODULE_DESCRIPTION(AHA152X_REVID);
363 MODULE_LICENSE("GPL");
364 
365 #if !defined(PCMCIA)
366 #if defined(MODULE)
367 static int io[] = {0, 0};
368 module_param_array(io, int, NULL, 0);
369 MODULE_PARM_DESC(io,"base io address of controller");
370 
371 static int irq[] = {0, 0};
372 module_param_array(irq, int, NULL, 0);
373 MODULE_PARM_DESC(irq,"interrupt for controller");
374 
375 static int scsiid[] = {7, 7};
376 module_param_array(scsiid, int, NULL, 0);
377 MODULE_PARM_DESC(scsiid,"scsi id of controller");
378 
379 static int reconnect[] = {1, 1};
380 module_param_array(reconnect, int, NULL, 0);
381 MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
382 
383 static int parity[] = {1, 1};
384 module_param_array(parity, int, NULL, 0);
385 MODULE_PARM_DESC(parity,"use scsi parity");
386 
387 static int sync[] = {1, 1};
388 module_param_array(sync, int, NULL, 0);
389 MODULE_PARM_DESC(sync,"use synchronous transfers");
390 
391 static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
392 module_param_array(delay, int, NULL, 0);
393 MODULE_PARM_DESC(delay,"scsi reset delay");
394 
395 static int exttrans[] = {0, 0};
396 module_param_array(exttrans, int, NULL, 0);
397 MODULE_PARM_DESC(exttrans,"use extended translation");
398 
399 #if !defined(AHA152X_DEBUG)
400 static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
401 module_param_array(aha152x, int, NULL, 0);
402 MODULE_PARM_DESC(aha152x, "parameters for first controller");
403 
404 static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
405 module_param_array(aha152x1, int, NULL, 0);
406 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
407 #else
408 static int debug[] = {DEBUG_DEFAULT, DEBUG_DEFAULT};
409 module_param_array(debug, int, NULL, 0);
410 MODULE_PARM_DESC(debug, "flags for driver debugging");
411 
412 static int aha152x[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
413 module_param_array(aha152x, int, NULL, 0);
414 MODULE_PARM_DESC(aha152x, "parameters for first controller");
415 
416 static int aha152x1[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
417 module_param_array(aha152x1, int, NULL, 0);
418 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
419 #endif /* !defined(AHA152X_DEBUG) */
420 #endif /* MODULE */
421 
422 #ifdef __ISAPNP__
423 static struct isapnp_device_id id_table[] __devinitdata = {
424  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1502), 0 },
425  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1505), 0 },
426  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1510), 0 },
427  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1515), 0 },
428  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1520), 0 },
429  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2015), 0 },
430  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1522), 0 },
431  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2215), 0 },
432  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1530), 0 },
433  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3015), 0 },
434  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1532), 0 },
435  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3215), 0 },
436  { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x6360), 0 },
437  { ISAPNP_DEVICE_SINGLE_END, }
438 };
439 MODULE_DEVICE_TABLE(isapnp, id_table);
440 #endif /* ISAPNP */
441 
442 #endif /* !PCMCIA */
443 
444 static struct scsi_host_template aha152x_driver_template;
445 
446 /*
447  * internal states of the host
448  *
449  */
450 enum aha152x_state {
451  idle=0,
452  unknown,
453  seldo,
454  seldi,
455  selto,
456  busfree,
457  msgo,
458  cmd,
459  msgi,
460  status,
461  datai,
462  datao,
463  parerr,
464  rsti,
465  maxstate
466 };
467 
468 /*
469  * current state information of the host
470  *
471  */
472 struct aha152x_hostdata {
473  Scsi_Cmnd *issue_SC;
474  /* pending commands to issue */
475 
476  Scsi_Cmnd *current_SC;
477  /* current command on the bus */
478 
479  Scsi_Cmnd *disconnected_SC;
480  /* commands that disconnected */
481 
482  Scsi_Cmnd *done_SC;
483  /* command that was completed */
484 
485  spinlock_t lock;
486  /* host lock */
487 
488 #if defined(AHA152X_DEBUG)
489  const char *locker;
490  /* which function has the lock */
491  int lockerl; /* where did it get it */
492 
493  int debug; /* current debugging setting */
494 #endif
495 
496 #if defined(AHA152X_STAT)
497  int total_commands;
498  int disconnections;
499  int busfree_without_any_action;
500  int busfree_without_old_command;
501  int busfree_without_new_command;
502  int busfree_without_done_command;
503  int busfree_with_check_condition;
504  int count[maxstate];
505  int count_trans[maxstate];
506  unsigned long time[maxstate];
507 #endif
508 
509  int commands; /* current number of commands */
510 
511  int reconnect; /* disconnection allowed */
512  int parity; /* parity checking enabled */
513  int synchronous; /* synchronous transferes enabled */
514  int delay; /* reset out delay */
515  int ext_trans; /* extended translation enabled */
516 
517  int swint; /* software-interrupt was fired during detect() */
518  int service; /* bh needs to be run */
519  int in_intr; /* bh is running */
520 
521  /* current state,
522  previous state,
523  last state different from current state */
524  enum aha152x_state state, prevstate, laststate;
525 
526  int target;
527  /* reconnecting target */
528 
529  unsigned char syncrate[8];
530  /* current synchronous transfer agreements */
531 
532  unsigned char syncneg[8];
533  /* 0: no negotiation;
534  * 1: negotiation in progress;
535  * 2: negotiation completed
536  */
537 
538  int cmd_i;
539  /* number of sent bytes of current command */
540 
541  int msgi_len;
542  /* number of received message bytes */
543  unsigned char msgi[256];
544  /* received message bytes */
545 
546  int msgo_i, msgo_len;
547  /* number of sent bytes and length of current messages */
548  unsigned char msgo[256];
549  /* pending messages */
550 
551  int data_len;
552  /* number of sent/received bytes in dataphase */
553 
554  unsigned long io_port0;
555  unsigned long io_port1;
556 
557 #ifdef __ISAPNP__
558  struct pnp_dev *pnpdev;
559 #endif
560  struct list_head host_list;
561 };
562 
563 
564 /*
565  * host specific command extension
566  *
567  */
568 struct aha152x_scdata {
569  Scsi_Cmnd *next; /* next sc in queue */
570  struct completion *done;/* semaphore to block on */
571  struct scsi_eh_save ses;
572 };
573 
574 /* access macros for hostdata */
575 
576 #define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata)
577 
578 #define HOSTNO ((shpnt)->host_no)
579 
580 #define CURRENT_SC (HOSTDATA(shpnt)->current_SC)
581 #define DONE_SC (HOSTDATA(shpnt)->done_SC)
582 #define ISSUE_SC (HOSTDATA(shpnt)->issue_SC)
583 #define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC)
584 #define QLOCK (HOSTDATA(shpnt)->lock)
585 #define QLOCKER (HOSTDATA(shpnt)->locker)
586 #define QLOCKERL (HOSTDATA(shpnt)->lockerl)
587 
588 #define STATE (HOSTDATA(shpnt)->state)
589 #define PREVSTATE (HOSTDATA(shpnt)->prevstate)
590 #define LASTSTATE (HOSTDATA(shpnt)->laststate)
591 
592 #define RECONN_TARGET (HOSTDATA(shpnt)->target)
593 
594 #define CMD_I (HOSTDATA(shpnt)->cmd_i)
595 
596 #define MSGO(i) (HOSTDATA(shpnt)->msgo[i])
597 #define MSGO_I (HOSTDATA(shpnt)->msgo_i)
598 #define MSGOLEN (HOSTDATA(shpnt)->msgo_len)
599 #define ADDMSGO(x) (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
600 
601 #define MSGI(i) (HOSTDATA(shpnt)->msgi[i])
602 #define MSGILEN (HOSTDATA(shpnt)->msgi_len)
603 #define ADDMSGI(x) (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
604 
605 #define DATA_LEN (HOSTDATA(shpnt)->data_len)
606 
607 #define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
608 #define SYNCNEG (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
609 
610 #define DELAY (HOSTDATA(shpnt)->delay)
611 #define EXT_TRANS (HOSTDATA(shpnt)->ext_trans)
612 #define TC1550 (HOSTDATA(shpnt)->tc1550)
613 #define RECONNECT (HOSTDATA(shpnt)->reconnect)
614 #define PARITY (HOSTDATA(shpnt)->parity)
615 #define SYNCHRONOUS (HOSTDATA(shpnt)->synchronous)
616 
617 #define HOSTIOPORT0 (HOSTDATA(shpnt)->io_port0)
618 #define HOSTIOPORT1 (HOSTDATA(shpnt)->io_port1)
619 
620 #define SCDATA(SCpnt) ((struct aha152x_scdata *) (SCpnt)->host_scribble)
621 #define SCNEXT(SCpnt) SCDATA(SCpnt)->next
622 #define SCSEM(SCpnt) SCDATA(SCpnt)->done
623 
624 #define SG_ADDRESS(buffer) ((char *) sg_virt((buffer)))
625 
626 /* state handling */
627 static void seldi_run(struct Scsi_Host *shpnt);
628 static void seldo_run(struct Scsi_Host *shpnt);
629 static void selto_run(struct Scsi_Host *shpnt);
630 static void busfree_run(struct Scsi_Host *shpnt);
631 
632 static void msgo_init(struct Scsi_Host *shpnt);
633 static void msgo_run(struct Scsi_Host *shpnt);
634 static void msgo_end(struct Scsi_Host *shpnt);
635 
636 static void cmd_init(struct Scsi_Host *shpnt);
637 static void cmd_run(struct Scsi_Host *shpnt);
638 static void cmd_end(struct Scsi_Host *shpnt);
639 
640 static void datai_init(struct Scsi_Host *shpnt);
641 static void datai_run(struct Scsi_Host *shpnt);
642 static void datai_end(struct Scsi_Host *shpnt);
643 
644 static void datao_init(struct Scsi_Host *shpnt);
645 static void datao_run(struct Scsi_Host *shpnt);
646 static void datao_end(struct Scsi_Host *shpnt);
647 
648 static void status_run(struct Scsi_Host *shpnt);
649 
650 static void msgi_run(struct Scsi_Host *shpnt);
651 static void msgi_end(struct Scsi_Host *shpnt);
652 
653 static void parerr_run(struct Scsi_Host *shpnt);
654 static void rsti_run(struct Scsi_Host *shpnt);
655 
656 static void is_complete(struct Scsi_Host *shpnt);
657 
658 /*
659  * driver states
660  *
661  */
662 static struct {
663  char *name;
664  void (*init)(struct Scsi_Host *);
665  void (*run)(struct Scsi_Host *);
666  void (*end)(struct Scsi_Host *);
667  int spio;
668 } states[] = {
669  { "idle", NULL, NULL, NULL, 0},
670  { "unknown", NULL, NULL, NULL, 0},
671  { "seldo", NULL, seldo_run, NULL, 0},
672  { "seldi", NULL, seldi_run, NULL, 0},
673  { "selto", NULL, selto_run, NULL, 0},
674  { "busfree", NULL, busfree_run, NULL, 0},
675  { "msgo", msgo_init, msgo_run, msgo_end, 1},
676  { "cmd", cmd_init, cmd_run, cmd_end, 1},
677  { "msgi", NULL, msgi_run, msgi_end, 1},
678  { "status", NULL, status_run, NULL, 1},
679  { "datai", datai_init, datai_run, datai_end, 0},
680  { "datao", datao_init, datao_run, datao_end, 0},
681  { "parerr", NULL, parerr_run, NULL, 0},
682  { "rsti", NULL, rsti_run, NULL, 0},
683 };
684 
685 /* setup & interrupt */
686 static irqreturn_t intr(int irq, void *dev_id);
687 static void reset_ports(struct Scsi_Host *shpnt);
688 static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
689 static void done(struct Scsi_Host *shpnt, int error);
690 
691 /* diagnostics */
692 static void disp_ports(struct Scsi_Host *shpnt);
693 static void show_command(Scsi_Cmnd * ptr);
694 static void show_queues(struct Scsi_Host *shpnt);
695 static void disp_enintr(struct Scsi_Host *shpnt);
696 
697 
698 /*
699  * queue services:
700  *
701  */
702 static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
703 {
704  Scsi_Cmnd *end;
705 
706  SCNEXT(new_SC) = NULL;
707  if (!*SC)
708  *SC = new_SC;
709  else {
710  for (end = *SC; SCNEXT(end); end = SCNEXT(end))
711  ;
712  SCNEXT(end) = new_SC;
713  }
714 }
715 
716 static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC)
717 {
718  Scsi_Cmnd *ptr;
719 
720  ptr = *SC;
721  if (ptr) {
722  *SC = SCNEXT(*SC);
723  SCNEXT(ptr)=NULL;
724  }
725  return ptr;
726 }
727 
728 static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun)
729 {
730  Scsi_Cmnd *ptr, *prev;
731 
732  for (ptr = *SC, prev = NULL;
733  ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
734  prev = ptr, ptr = SCNEXT(ptr))
735  ;
736 
737  if (ptr) {
738  if (prev)
739  SCNEXT(prev) = SCNEXT(ptr);
740  else
741  *SC = SCNEXT(ptr);
742 
743  SCNEXT(ptr)=NULL;
744  }
745 
746  return ptr;
747 }
748 
749 static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp)
750 {
751  Scsi_Cmnd *ptr, *prev;
752 
753  for (ptr = *SC, prev = NULL;
754  ptr && SCp!=ptr;
755  prev = ptr, ptr = SCNEXT(ptr))
756  ;
757 
758  if (ptr) {
759  if (prev)
760  SCNEXT(prev) = SCNEXT(ptr);
761  else
762  *SC = SCNEXT(ptr);
763 
764  SCNEXT(ptr)=NULL;
765  }
766 
767  return ptr;
768 }
769 
770 static irqreturn_t swintr(int irqno, void *dev_id)
771 {
772  struct Scsi_Host *shpnt = dev_id;
773 
774  HOSTDATA(shpnt)->swint++;
775 
776  SETPORT(DMACNTRL0, INTEN);
777  return IRQ_HANDLED;
778 }
779 
780 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
781 {
782  struct Scsi_Host *shpnt;
783 
784  shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
785  if (!shpnt) {
786  printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
787  return NULL;
788  }
789 
790  memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
791  INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
792 
793  /* need to have host registered before triggering any interrupt */
794  list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
795 
796  shpnt->io_port = setup->io_port;
797  shpnt->n_io_port = IO_RANGE;
798  shpnt->irq = setup->irq;
799 
800  if (!setup->tc1550) {
801  HOSTIOPORT0 = setup->io_port;
802  HOSTIOPORT1 = setup->io_port;
803  } else {
804  HOSTIOPORT0 = setup->io_port+0x10;
805  HOSTIOPORT1 = setup->io_port-0x10;
806  }
807 
808  spin_lock_init(&QLOCK);
809  RECONNECT = setup->reconnect;
810  SYNCHRONOUS = setup->synchronous;
811  PARITY = setup->parity;
812  DELAY = setup->delay;
813  EXT_TRANS = setup->ext_trans;
814 
815 #if defined(AHA152X_DEBUG)
816  HOSTDATA(shpnt)->debug = setup->debug;
817 #endif
818 
819  SETPORT(SCSIID, setup->scsiid << 4);
820  shpnt->this_id = setup->scsiid;
821 
822  if (setup->reconnect)
823  shpnt->can_queue = AHA152X_MAXQUEUE;
824 
825  /* RESET OUT */
826  printk("aha152x: resetting bus...\n");
827  SETPORT(SCSISEQ, SCSIRSTO);
828  mdelay(256);
829  SETPORT(SCSISEQ, 0);
830  mdelay(DELAY);
831 
832  reset_ports(shpnt);
833 
834  printk(KERN_INFO
835  "aha152x%d%s: "
836  "vital data: rev=%x, "
837  "io=0x%03lx (0x%03lx/0x%03lx), "
838  "irq=%d, "
839  "scsiid=%d, "
840  "reconnect=%s, "
841  "parity=%s, "
842  "synchronous=%s, "
843  "delay=%d, "
844  "extended translation=%s\n",
845  shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
846  GETPORT(REV) & 0x7,
847  shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
848  shpnt->irq,
849  shpnt->this_id,
850  RECONNECT ? "enabled" : "disabled",
851  PARITY ? "enabled" : "disabled",
852  SYNCHRONOUS ? "enabled" : "disabled",
853  DELAY,
854  EXT_TRANS ? "enabled" : "disabled");
855 
856  /* not expecting any interrupts */
857  SETPORT(SIMODE0, 0);
858  SETPORT(SIMODE1, 0);
859 
860  if( request_irq(shpnt->irq, swintr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
861  printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
862  goto out_host_put;
863  }
864 
865  HOSTDATA(shpnt)->swint = 0;
866 
867  printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
868 
869  mb();
870  SETPORT(DMACNTRL0, SWINT|INTEN);
871  mdelay(1000);
872  free_irq(shpnt->irq, shpnt);
873 
874  if (!HOSTDATA(shpnt)->swint) {
875  if (TESTHI(DMASTAT, INTSTAT)) {
876  printk("lost.\n");
877  } else {
878  printk("failed.\n");
879  }
880 
881  SETPORT(DMACNTRL0, INTEN);
882 
883  printk(KERN_ERR "aha152x%d: irq %d possibly wrong. "
884  "Please verify.\n", shpnt->host_no, shpnt->irq);
885  goto out_host_put;
886  }
887  printk("ok.\n");
888 
889 
890  /* clear interrupts */
891  SETPORT(SSTAT0, 0x7f);
892  SETPORT(SSTAT1, 0xef);
893 
894  if ( request_irq(shpnt->irq, intr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
895  printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
896  goto out_host_put;
897  }
898 
899  if( scsi_add_host(shpnt, NULL) ) {
900  free_irq(shpnt->irq, shpnt);
901  printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
902  goto out_host_put;
903  }
904 
905  scsi_scan_host(shpnt);
906 
907  return shpnt;
908 
909 out_host_put:
910  list_del(&HOSTDATA(shpnt)->host_list);
911  scsi_host_put(shpnt);
912 
913  return NULL;
914 }
915 
916 void aha152x_release(struct Scsi_Host *shpnt)
917 {
918  if (!shpnt)
919  return;
920 
921  scsi_remove_host(shpnt);
922  if (shpnt->irq)
923  free_irq(shpnt->irq, shpnt);
924 
925 #if !defined(PCMCIA)
926  if (shpnt->io_port)
927  release_region(shpnt->io_port, IO_RANGE);
928 #endif
929 
930 #ifdef __ISAPNP__
931  if (HOSTDATA(shpnt)->pnpdev)
932  pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
933 #endif
934 
935  list_del(&HOSTDATA(shpnt)->host_list);
936  scsi_host_put(shpnt);
937 }
938 
939 
940 /*
941  * setup controller to generate interrupts depending
942  * on current state (lock has to be acquired)
943  *
944  */
945 static int setup_expected_interrupts(struct Scsi_Host *shpnt)
946 {
947  if(CURRENT_SC) {
948  CURRENT_SC->SCp.phase |= 1 << 16;
949 
950  if(CURRENT_SC->SCp.phase & selecting) {
951  DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC));
952  SETPORT(SSTAT1, SELTO);
953  SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
954  SETPORT(SIMODE1, ENSELTIMO);
955  } else {
956  DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : "");
957  SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
958  SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
959  }
960  } else if(STATE==seldi) {
961  DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC));
962  SETPORT(SIMODE0, 0);
963  SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
964  } else {
965  DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n",
966  CMDINFO(CURRENT_SC),
967  DISCONNECTED_SC ? "(reselection)" : "",
968  ISSUE_SC ? "(busfree)" : "");
969  SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
970  SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
971  }
972 
973  if(!HOSTDATA(shpnt)->in_intr)
974  SETBITS(DMACNTRL0, INTEN);
975 
976  return TESTHI(DMASTAT, INTSTAT);
977 }
978 
979 
980 /*
981  * Queue a command and setup interrupts for a free bus.
982  */
983 static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
984  int phase, void (*done)(Scsi_Cmnd *))
985 {
986  struct Scsi_Host *shpnt = SCpnt->device->host;
987  unsigned long flags;
988 
989 #if defined(AHA152X_DEBUG)
990  if (HOSTDATA(shpnt)->debug & debug_queue) {
991  printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
992  CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len,
993  scsi_sg_count(SCpnt), scsi_bufflen(SCpnt));
994  __scsi_print_command(SCpnt->cmnd);
995  }
996 #endif
997 
998  SCpnt->scsi_done = done;
999  SCpnt->SCp.phase = not_issued | phase;
1000  SCpnt->SCp.Status = 0x1; /* Ilegal status by SCSI standard */
1001  SCpnt->SCp.Message = 0;
1002  SCpnt->SCp.have_data_in = 0;
1003  SCpnt->SCp.sent_command = 0;
1004 
1005  if(SCpnt->SCp.phase & (resetting|check_condition)) {
1006  if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
1007  printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt));
1008  return FAILED;
1009  }
1010  } else {
1011  SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
1012  if(!SCpnt->host_scribble) {
1013  printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt));
1014  return FAILED;
1015  }
1016  }
1017 
1018  SCNEXT(SCpnt) = NULL;
1019  SCSEM(SCpnt) = complete;
1020 
1021  /* setup scratch area
1022  SCp.ptr : buffer pointer
1023  SCp.this_residual : buffer length
1024  SCp.buffer : next buffer
1025  SCp.buffers_residual : left buffers in list
1026  SCp.phase : current state of the command */
1027 
1028  if ((phase & resetting) || !scsi_sglist(SCpnt)) {
1029  SCpnt->SCp.ptr = NULL;
1030  SCpnt->SCp.this_residual = 0;
1031  scsi_set_resid(SCpnt, 0);
1032  SCpnt->SCp.buffer = NULL;
1033  SCpnt->SCp.buffers_residual = 0;
1034  } else {
1035  scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
1036  SCpnt->SCp.buffer = scsi_sglist(SCpnt);
1037  SCpnt->SCp.ptr = SG_ADDRESS(SCpnt->SCp.buffer);
1038  SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
1039  SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1;
1040  }
1041 
1042  DO_LOCK(flags);
1043 
1044 #if defined(AHA152X_STAT)
1045  HOSTDATA(shpnt)->total_commands++;
1046 #endif
1047 
1048  /* Turn led on, when this is the first command. */
1049  HOSTDATA(shpnt)->commands++;
1050  if (HOSTDATA(shpnt)->commands==1)
1051  SETPORT(PORTA, 1);
1052 
1053  append_SC(&ISSUE_SC, SCpnt);
1054 
1055  if(!HOSTDATA(shpnt)->in_intr)
1056  setup_expected_interrupts(shpnt);
1057 
1058  DO_UNLOCK(flags);
1059 
1060  return 0;
1061 }
1062 
1063 /*
1064  * queue a command
1065  *
1066  */
1067 static int aha152x_queue_lck(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
1068 {
1069 #if 0
1070  if(*SCpnt->cmnd == REQUEST_SENSE) {
1071  SCpnt->result = 0;
1072  done(SCpnt);
1073 
1074  return 0;
1075  }
1076 #endif
1077 
1078  return aha152x_internal_queue(SCpnt, NULL, 0, done);
1079 }
1080 
1081 static DEF_SCSI_QCMD(aha152x_queue)
1082 
1083 
1084 /*
1085  *
1086  *
1087  */
1088 static void reset_done(Scsi_Cmnd *SCpnt)
1089 {
1090 #if 0
1091  struct Scsi_Host *shpnt = SCpnt->host;
1092  DPRINTK(debug_eh, INFO_LEAD "reset_done called\n", CMDINFO(SCpnt));
1093 #endif
1094  if(SCSEM(SCpnt)) {
1095  complete(SCSEM(SCpnt));
1096  } else {
1097  printk(KERN_ERR "aha152x: reset_done w/o completion\n");
1098  }
1099 }
1100 
1101 /*
1102  * Abort a command
1103  *
1104  */
1105 static int aha152x_abort(Scsi_Cmnd *SCpnt)
1106 {
1107  struct Scsi_Host *shpnt = SCpnt->device->host;
1108  Scsi_Cmnd *ptr;
1109  unsigned long flags;
1110 
1111 #if defined(AHA152X_DEBUG)
1112  if(HOSTDATA(shpnt)->debug & debug_eh) {
1113  printk(DEBUG_LEAD "abort(%p)", CMDINFO(SCpnt), SCpnt);
1114  show_queues(shpnt);
1115  }
1116 #endif
1117 
1118  DO_LOCK(flags);
1119 
1120  ptr=remove_SC(&ISSUE_SC, SCpnt);
1121 
1122  if(ptr) {
1123  DPRINTK(debug_eh, DEBUG_LEAD "not yet issued - SUCCESS\n", CMDINFO(SCpnt));
1124 
1125  HOSTDATA(shpnt)->commands--;
1126  if (!HOSTDATA(shpnt)->commands)
1127  SETPORT(PORTA, 0);
1128  DO_UNLOCK(flags);
1129 
1130  kfree(SCpnt->host_scribble);
1131  SCpnt->host_scribble=NULL;
1132 
1133  return SUCCESS;
1134  }
1135 
1136  DO_UNLOCK(flags);
1137 
1138  /*
1139  * FIXME:
1140  * for current command: queue ABORT for message out and raise ATN
1141  * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1142  *
1143  */
1144 
1145  printk(ERR_LEAD "cannot abort running or disconnected command\n", CMDINFO(SCpnt));
1146 
1147  return FAILED;
1148 }
1149 
1150 /*
1151  * Reset a device
1152  *
1153  */
1154 static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
1155 {
1156  struct Scsi_Host *shpnt = SCpnt->device->host;
1157  DECLARE_COMPLETION(done);
1158  int ret, issued, disconnected;
1159  unsigned char old_cmd_len = SCpnt->cmd_len;
1160  unsigned long flags;
1161  unsigned long timeleft;
1162 
1163 #if defined(AHA152X_DEBUG)
1164  if(HOSTDATA(shpnt)->debug & debug_eh) {
1165  printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt);
1166  show_queues(shpnt);
1167  }
1168 #endif
1169 
1170  if(CURRENT_SC==SCpnt) {
1171  printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt));
1172  return FAILED;
1173  }
1174 
1175  DO_LOCK(flags);
1176  issued = remove_SC(&ISSUE_SC, SCpnt) == NULL;
1177  disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1178  DO_UNLOCK(flags);
1179 
1180  SCpnt->cmd_len = 0;
1181 
1182  aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
1183 
1184  timeleft = wait_for_completion_timeout(&done, 100*HZ);
1185  if (!timeleft) {
1186  /* remove command from issue queue */
1187  DO_LOCK(flags);
1188  remove_SC(&ISSUE_SC, SCpnt);
1189  DO_UNLOCK(flags);
1190  }
1191 
1192  SCpnt->cmd_len = old_cmd_len;
1193 
1194  DO_LOCK(flags);
1195 
1196  if(SCpnt->SCp.phase & resetted) {
1197  HOSTDATA(shpnt)->commands--;
1198  if (!HOSTDATA(shpnt)->commands)
1199  SETPORT(PORTA, 0);
1200  kfree(SCpnt->host_scribble);
1201  SCpnt->host_scribble=NULL;
1202 
1203  ret = SUCCESS;
1204  } else {
1205  /* requeue */
1206  if(!issued) {
1207  append_SC(&ISSUE_SC, SCpnt);
1208  } else if(disconnected) {
1209  append_SC(&DISCONNECTED_SC, SCpnt);
1210  }
1211 
1212  ret = FAILED;
1213  }
1214 
1215  DO_UNLOCK(flags);
1216  return ret;
1217 }
1218 
1219 static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1220 {
1221  Scsi_Cmnd *ptr;
1222 
1223  ptr=*SCs;
1224  while(ptr) {
1225  Scsi_Cmnd *next;
1226 
1227  if(SCDATA(ptr)) {
1228  next = SCNEXT(ptr);
1229  } else {
1230  printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
1231  next = NULL;
1232  }
1233 
1234  if (!ptr->device->soft_reset) {
1235  DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
1236  remove_SC(SCs, ptr);
1237  HOSTDATA(shpnt)->commands--;
1238  kfree(ptr->host_scribble);
1239  ptr->host_scribble=NULL;
1240  }
1241 
1242  ptr = next;
1243  }
1244 }
1245 
1246 /*
1247  * Reset the bus
1248  *
1249  */
1250 static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1251 {
1252  unsigned long flags;
1253 
1254  DO_LOCK(flags);
1255 
1256 #if defined(AHA152X_DEBUG)
1257  if(HOSTDATA(shpnt)->debug & debug_eh) {
1258  printk(KERN_DEBUG "scsi%d: bus reset", shpnt->host_no);
1259  show_queues(shpnt);
1260  }
1261 #endif
1262 
1263  free_hard_reset_SCs(shpnt, &ISSUE_SC);
1264  free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1265 
1266  DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting bus\n", shpnt->host_no);
1267 
1268  SETPORT(SCSISEQ, SCSIRSTO);
1269  mdelay(256);
1270  SETPORT(SCSISEQ, 0);
1271  mdelay(DELAY);
1272 
1273  DPRINTK(debug_eh, KERN_DEBUG "scsi%d: bus resetted\n", shpnt->host_no);
1274 
1275  setup_expected_interrupts(shpnt);
1276  if(HOSTDATA(shpnt)->commands==0)
1277  SETPORT(PORTA, 0);
1278 
1279  DO_UNLOCK(flags);
1280 
1281  return SUCCESS;
1282 }
1283 
1284 /*
1285  * Reset the bus
1286  *
1287  */
1288 static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1289 {
1290  return aha152x_bus_reset_host(SCpnt->device->host);
1291 }
1292 
1293 /*
1294  * Restore default values to the AIC-6260 registers and reset the fifos
1295  *
1296  */
1297 static void reset_ports(struct Scsi_Host *shpnt)
1298 {
1299  unsigned long flags;
1300 
1301  /* disable interrupts */
1302  SETPORT(DMACNTRL0, RSTFIFO);
1303 
1304  SETPORT(SCSISEQ, 0);
1305 
1306  SETPORT(SXFRCTL1, 0);
1307  SETPORT(SCSISIG, 0);
1308  SETRATE(0);
1309 
1310  /* clear all interrupt conditions */
1311  SETPORT(SSTAT0, 0x7f);
1312  SETPORT(SSTAT1, 0xef);
1313 
1314  SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1315 
1316  SETPORT(DMACNTRL0, 0);
1317  SETPORT(DMACNTRL1, 0);
1318 
1319  SETPORT(BRSTCNTRL, 0xf1);
1320 
1321  /* clear SCSI fifos and transfer count */
1322  SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1323  SETPORT(SXFRCTL0, CH1);
1324 
1325  DO_LOCK(flags);
1326  setup_expected_interrupts(shpnt);
1327  DO_UNLOCK(flags);
1328 }
1329 
1330 /*
1331  * Reset the host (bus and controller)
1332  *
1333  */
1334 int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1335 {
1336  DPRINTK(debug_eh, KERN_DEBUG "scsi%d: host reset\n", shpnt->host_no);
1337 
1338  aha152x_bus_reset_host(shpnt);
1339 
1340  DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting ports\n", shpnt->host_no);
1341  reset_ports(shpnt);
1342 
1343  return SUCCESS;
1344 }
1345 
1346 /*
1347  * Reset the host (bus and controller)
1348  *
1349  */
1350 static int aha152x_host_reset(Scsi_Cmnd *SCpnt)
1351 {
1352  return aha152x_host_reset_host(SCpnt->device->host);
1353 }
1354 
1355 /*
1356  * Return the "logical geometry"
1357  *
1358  */
1359 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1360  sector_t capacity, int *info_array)
1361 {
1362  struct Scsi_Host *shpnt = sdev->host;
1363 
1364  /* try default translation */
1365  info_array[0] = 64;
1366  info_array[1] = 32;
1367  info_array[2] = (unsigned long)capacity / (64 * 32);
1368 
1369  /* for disks >1GB do some guessing */
1370  if (info_array[2] >= 1024) {
1371  int info[3];
1372 
1373  /* try to figure out the geometry from the partition table */
1374  if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1375  !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1376  if (EXT_TRANS) {
1377  printk(KERN_NOTICE
1378  "aha152x: unable to verify geometry for disk with >1GB.\n"
1379  " using extended translation.\n");
1380  info_array[0] = 255;
1381  info_array[1] = 63;
1382  info_array[2] = (unsigned long)capacity / (255 * 63);
1383  } else {
1384  printk(KERN_NOTICE
1385  "aha152x: unable to verify geometry for disk with >1GB.\n"
1386  " Using default translation. Please verify yourself.\n"
1387  " Perhaps you need to enable extended translation in the driver.\n"
1388  " See Documentation/scsi/aha152x.txt for details.\n");
1389  }
1390  } else {
1391  info_array[0] = info[0];
1392  info_array[1] = info[1];
1393  info_array[2] = info[2];
1394 
1395  if (info[0] == 255 && !EXT_TRANS) {
1396  printk(KERN_NOTICE
1397  "aha152x: current partition table is using extended translation.\n"
1398  " using it also, although it's not explicitly enabled.\n");
1399  }
1400  }
1401  }
1402 
1403  return 0;
1404 }
1405 
1406 /*
1407  * Internal done function
1408  *
1409  */
1410 static void done(struct Scsi_Host *shpnt, int error)
1411 {
1412  if (CURRENT_SC) {
1413  if(DONE_SC)
1414  printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
1415 
1416  DONE_SC = CURRENT_SC;
1417  CURRENT_SC = NULL;
1418  DONE_SC->result = error;
1419  } else
1420  printk(KERN_ERR "aha152x: done() called outside of command\n");
1421 }
1422 
1423 static struct work_struct aha152x_tq;
1424 
1425 /*
1426  * Run service completions on the card with interrupts enabled.
1427  *
1428  */
1429 static void run(struct work_struct *work)
1430 {
1431  struct aha152x_hostdata *hd;
1432 
1433  list_for_each_entry(hd, &aha152x_host_list, host_list) {
1434  struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1435 
1436  is_complete(shost);
1437  }
1438 }
1439 
1440 /*
1441  * Interrupt handler
1442  *
1443  */
1444 static irqreturn_t intr(int irqno, void *dev_id)
1445 {
1446  struct Scsi_Host *shpnt = dev_id;
1447  unsigned long flags;
1448  unsigned char rev, dmacntrl0;
1449 
1450  /*
1451  * Read a couple of registers that are known to not be all 1's. If
1452  * we read all 1's (-1), that means that either:
1453  *
1454  * a. The host adapter chip has gone bad, and we cannot control it,
1455  * OR
1456  * b. The host adapter is a PCMCIA card that has been ejected
1457  *
1458  * In either case, we cannot do anything with the host adapter at
1459  * this point in time. So just ignore the interrupt and return.
1460  * In the latter case, the interrupt might actually be meant for
1461  * someone else sharing this IRQ, and that driver will handle it.
1462  */
1463  rev = GETPORT(REV);
1464  dmacntrl0 = GETPORT(DMACNTRL0);
1465  if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1466  return IRQ_NONE;
1467 
1468  if( TESTLO(DMASTAT, INTSTAT) )
1469  return IRQ_NONE;
1470 
1471  /* no more interrupts from the controller, while we're busy.
1472  INTEN is restored by the BH handler */
1473  CLRBITS(DMACNTRL0, INTEN);
1474 
1475  DO_LOCK(flags);
1476  if( HOSTDATA(shpnt)->service==0 ) {
1477  HOSTDATA(shpnt)->service=1;
1478 
1479  /* Poke the BH handler */
1480  INIT_WORK(&aha152x_tq, run);
1481  schedule_work(&aha152x_tq);
1482  }
1483  DO_UNLOCK(flags);
1484 
1485  return IRQ_HANDLED;
1486 }
1487 
1488 /*
1489  * busfree phase
1490  * - handle completition/disconnection/error of current command
1491  * - start selection for next command (if any)
1492  */
1493 static void busfree_run(struct Scsi_Host *shpnt)
1494 {
1495  unsigned long flags;
1496 #if defined(AHA152X_STAT)
1497  int action=0;
1498 #endif
1499 
1500  SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1501  SETPORT(SXFRCTL0, CH1);
1502 
1503  SETPORT(SSTAT1, CLRBUSFREE);
1504 
1505  if(CURRENT_SC) {
1506 #if defined(AHA152X_STAT)
1507  action++;
1508 #endif
1509  CURRENT_SC->SCp.phase &= ~syncneg;
1510 
1511  if(CURRENT_SC->SCp.phase & completed) {
1512  /* target sent COMMAND COMPLETE */
1513  done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1514 
1515  } else if(CURRENT_SC->SCp.phase & aborted) {
1516  DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
1517  done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1518 
1519  } else if(CURRENT_SC->SCp.phase & resetted) {
1520  DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
1521  done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1522 
1523  } else if(CURRENT_SC->SCp.phase & disconnected) {
1524  /* target sent DISCONNECT */
1525  DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
1526  CMDINFO(CURRENT_SC),
1527  scsi_get_resid(CURRENT_SC),
1528  scsi_bufflen(CURRENT_SC));
1529 #if defined(AHA152X_STAT)
1530  HOSTDATA(shpnt)->disconnections++;
1531 #endif
1532  append_SC(&DISCONNECTED_SC, CURRENT_SC);
1533  CURRENT_SC->SCp.phase |= 1 << 16;
1534  CURRENT_SC = NULL;
1535 
1536  } else {
1537  done(shpnt, DID_ERROR << 16);
1538  }
1539 #if defined(AHA152X_STAT)
1540  } else {
1541  HOSTDATA(shpnt)->busfree_without_old_command++;
1542 #endif
1543  }
1544 
1545  DO_LOCK(flags);
1546 
1547  if(DONE_SC) {
1548 #if defined(AHA152X_STAT)
1549  action++;
1550 #endif
1551 
1552  if(DONE_SC->SCp.phase & check_condition) {
1553  struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1554  struct aha152x_scdata *sc = SCDATA(cmd);
1555 
1556 #if 0
1557  if(HOSTDATA(shpnt)->debug & debug_eh) {
1558  printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
1559  scsi_print_sense("bh", DONE_SC);
1560  }
1561 #endif
1562 
1563  scsi_eh_restore_cmnd(cmd, &sc->ses);
1564 
1565  cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
1566 
1567  HOSTDATA(shpnt)->commands--;
1568  if (!HOSTDATA(shpnt)->commands)
1569  SETPORT(PORTA, 0); /* turn led off */
1570  } else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) {
1571 #if defined(AHA152X_STAT)
1572  HOSTDATA(shpnt)->busfree_with_check_condition++;
1573 #endif
1574 #if 0
1575  DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
1576 #endif
1577 
1578  if(!(DONE_SC->SCp.phase & not_issued)) {
1579  struct aha152x_scdata *sc;
1580  Scsi_Cmnd *ptr = DONE_SC;
1581  DONE_SC=NULL;
1582 #if 0
1583  DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
1584 #endif
1585 
1586  sc = SCDATA(ptr);
1587  /* It was allocated in aha152x_internal_queue? */
1588  BUG_ON(!sc);
1589  scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0);
1590 
1591  DO_UNLOCK(flags);
1592  aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1593  DO_LOCK(flags);
1594 #if 0
1595  } else {
1596  DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
1597 #endif
1598  }
1599  }
1600 
1601  if(DONE_SC && DONE_SC->scsi_done) {
1602 #if defined(AHA152X_DEBUG)
1603  int hostno=DONE_SC->device->host->host_no;
1604  int id=DONE_SC->device->id & 0xf;
1605  int lun=DONE_SC->device->lun & 0x7;
1606 #endif
1607  Scsi_Cmnd *ptr = DONE_SC;
1608  DONE_SC=NULL;
1609 
1610  /* turn led off, when no commands are in the driver */
1611  HOSTDATA(shpnt)->commands--;
1612  if (!HOSTDATA(shpnt)->commands)
1613  SETPORT(PORTA, 0); /* turn led off */
1614 
1615  if(ptr->scsi_done != reset_done) {
1616  kfree(ptr->host_scribble);
1617  ptr->host_scribble=NULL;
1618  }
1619 
1620  DO_UNLOCK(flags);
1621  DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
1622  ptr->scsi_done(ptr);
1623  DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
1624  DO_LOCK(flags);
1625  }
1626 
1627  DONE_SC=NULL;
1628 #if defined(AHA152X_STAT)
1629  } else {
1630  HOSTDATA(shpnt)->busfree_without_done_command++;
1631 #endif
1632  }
1633 
1634  if(ISSUE_SC)
1635  CURRENT_SC = remove_first_SC(&ISSUE_SC);
1636 
1637  DO_UNLOCK(flags);
1638 
1639  if(CURRENT_SC) {
1640 #if defined(AHA152X_STAT)
1641  action++;
1642 #endif
1643  CURRENT_SC->SCp.phase |= selecting;
1644 
1645  DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
1646 
1647  /* clear selection timeout */
1648  SETPORT(SSTAT1, SELTO);
1649 
1650  SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1651  SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1652  SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1653  } else {
1654 #if defined(AHA152X_STAT)
1655  HOSTDATA(shpnt)->busfree_without_new_command++;
1656 #endif
1657  SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1658  }
1659 
1660 #if defined(AHA152X_STAT)
1661  if(!action)
1662  HOSTDATA(shpnt)->busfree_without_any_action++;
1663 #endif
1664 }
1665 
1666 /*
1667  * Selection done (OUT)
1668  * - queue IDENTIFY message and SDTR to selected target for message out
1669  * (ATN asserted automagically via ENAUTOATNO in busfree())
1670  */
1671 static void seldo_run(struct Scsi_Host *shpnt)
1672 {
1673  SETPORT(SCSISIG, 0);
1674  SETPORT(SSTAT1, CLRBUSFREE);
1675  SETPORT(SSTAT1, CLRPHASECHG);
1676 
1677  CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1678 
1679  SETPORT(SCSISEQ, 0);
1680 
1681  if (TESTLO(SSTAT0, SELDO)) {
1682  printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
1683  done(shpnt, DID_NO_CONNECT << 16);
1684  return;
1685  }
1686 
1687  SETPORT(SSTAT0, CLRSELDO);
1688 
1689  ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1690 
1691  if (CURRENT_SC->SCp.phase & aborting) {
1692  ADDMSGO(ABORT);
1693  } else if (CURRENT_SC->SCp.phase & resetting) {
1694  ADDMSGO(BUS_DEVICE_RESET);
1695  } else if (SYNCNEG==0 && SYNCHRONOUS) {
1696  CURRENT_SC->SCp.phase |= syncneg;
1697  MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1698  SYNCNEG=1; /* negotiation in progress */
1699  }
1700 
1701  SETRATE(SYNCRATE);
1702 }
1703 
1704 /*
1705  * Selection timeout
1706  * - return command to mid-level with failure cause
1707  *
1708  */
1709 static void selto_run(struct Scsi_Host *shpnt)
1710 {
1711  SETPORT(SCSISEQ, 0);
1712  SETPORT(SSTAT1, CLRSELTIMO);
1713 
1714  DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1715 
1716  if(!CURRENT_SC) {
1717  DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1718  return;
1719  }
1720 
1721  CURRENT_SC->SCp.phase &= ~selecting;
1722 
1723  if (CURRENT_SC->SCp.phase & aborted) {
1724  DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1725  done(shpnt, DID_ABORT << 16);
1726  } else if (TESTLO(SSTAT0, SELINGO)) {
1727  DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1728  done(shpnt, DID_BUS_BUSY << 16);
1729  } else {
1730  /* ARBITRATION won, but SELECTION failed */
1731  DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1732  done(shpnt, DID_NO_CONNECT << 16);
1733  }
1734 }
1735 
1736 /*
1737  * Selection in done
1738  * - put current command back to issue queue
1739  * (reconnection of a disconnected nexus instead
1740  * of successful selection out)
1741  *
1742  */
1743 static void seldi_run(struct Scsi_Host *shpnt)
1744 {
1745  int selid;
1746  int target;
1747  unsigned long flags;
1748 
1749  SETPORT(SCSISIG, 0);
1750  SETPORT(SSTAT0, CLRSELDI);
1751  SETPORT(SSTAT1, CLRBUSFREE);
1752  SETPORT(SSTAT1, CLRPHASECHG);
1753 
1754  if(CURRENT_SC) {
1755  if(!(CURRENT_SC->SCp.phase & not_issued))
1756  printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1757 
1758  DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1759 
1760  DO_LOCK(flags);
1761  append_SC(&ISSUE_SC, CURRENT_SC);
1762  DO_UNLOCK(flags);
1763 
1764  CURRENT_SC = NULL;
1765  }
1766 
1767  if(!DISCONNECTED_SC) {
1768  DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1769  return;
1770  }
1771 
1772  RECONN_TARGET=-1;
1773 
1774  selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1775 
1776  if (selid==0) {
1777  printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1778  return;
1779  }
1780 
1781  for(target=7; !(selid & (1 << target)); target--)
1782  ;
1783 
1784  if(selid & ~(1 << target)) {
1785  printk("aha152x%d: multiple targets reconnected (%02x)\n",
1786  HOSTNO, selid);
1787  }
1788 
1789 
1790  SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1791  SETPORT(SCSISEQ, 0);
1792 
1793  SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1794 
1795  RECONN_TARGET=target;
1796  DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1797 }
1798 
1799 /*
1800  * message in phase
1801  * - handle initial message after reconnection to identify
1802  * reconnecting nexus
1803  * - queue command on DISCONNECTED_SC on DISCONNECT message
1804  * - set completed flag on COMMAND COMPLETE
1805  * (other completition code moved to busfree_run)
1806  * - handle response to SDTR
1807  * - clear synchronous transfer agreements on BUS RESET
1808  *
1809  * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1810  *
1811  */
1812 static void msgi_run(struct Scsi_Host *shpnt)
1813 {
1814  for(;;) {
1815  int sstat1 = GETPORT(SSTAT1);
1816 
1817  if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1818  return;
1819 
1820  if(TESTLO(SSTAT0,SPIORDY)) {
1821  DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1822  return;
1823  }
1824 
1825  ADDMSGI(GETPORT(SCSIDAT));
1826 
1827 #if defined(AHA152X_DEBUG)
1828  if (HOSTDATA(shpnt)->debug & debug_msgi) {
1829  printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1830  spi_print_msg(&MSGI(0));
1831  printk("\n");
1832  }
1833 #endif
1834 
1835  if(!CURRENT_SC) {
1836  if(LASTSTATE!=seldi) {
1837  printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1838  }
1839 
1840  /*
1841  * Handle reselection
1842  */
1843  if(!(MSGI(0) & IDENTIFY_BASE)) {
1844  printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1845  continue;
1846  }
1847 
1848  CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1849 
1850  if (!CURRENT_SC) {
1851  show_queues(shpnt);
1852  printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1853  continue;
1854  }
1855 
1856  DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1857 
1858  CURRENT_SC->SCp.Message = MSGI(0);
1859  CURRENT_SC->SCp.phase &= ~disconnected;
1860 
1861  MSGILEN=0;
1862 
1863  /* next message if any */
1864  continue;
1865  }
1866 
1867  CURRENT_SC->SCp.Message = MSGI(0);
1868 
1869  switch (MSGI(0)) {
1870  case DISCONNECT:
1871  if (!RECONNECT)
1872  printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1873 
1874  CURRENT_SC->SCp.phase |= disconnected;
1875  break;
1876 
1877  case COMMAND_COMPLETE:
1878  if(CURRENT_SC->SCp.phase & completed)
1879  DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1880 
1881  CURRENT_SC->SCp.phase |= completed;
1882  break;
1883 
1884  case MESSAGE_REJECT:
1885  if (SYNCNEG==1) {
1886  printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
1887  SYNCNEG=2; /* negotiation completed */
1888  } else
1889  printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
1890  break;
1891 
1892  case SAVE_POINTERS:
1893  break;
1894 
1895  case RESTORE_POINTERS:
1896  break;
1897 
1898  case EXTENDED_MESSAGE:
1899  if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1900  /* not yet completed */
1901  continue;
1902  }
1903 
1904  switch (MSGI(2)) {
1905  case EXTENDED_SDTR:
1906  {
1907  long ticks;
1908 
1909  if (MSGI(1) != 3) {
1910  printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
1911  break;
1912  }
1913 
1914  if (!HOSTDATA(shpnt)->synchronous)
1915  break;
1916 
1917  printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1918  spi_print_msg(&MSGI(0));
1919  printk("\n");
1920 
1921  ticks = (MSGI(3) * 4 + 49) / 50;
1922 
1923  if (syncneg) {
1924  /* negotiation in progress */
1925  if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1926  ADDMSGO(MESSAGE_REJECT);
1927  printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
1928  break;
1929  }
1930 
1931  SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1932  } else if (ticks <= 9 && MSGI(4) >= 1) {
1933  ADDMSGO(EXTENDED_MESSAGE);
1934  ADDMSGO(3);
1935  ADDMSGO(EXTENDED_SDTR);
1936  if (ticks < 4) {
1937  ticks = 4;
1938  ADDMSGO(50);
1939  } else
1940  ADDMSGO(MSGI(3));
1941 
1942  if (MSGI(4) > 8)
1943  MSGI(4) = 8;
1944 
1945  ADDMSGO(MSGI(4));
1946 
1947  SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1948  } else {
1949  /* requested SDTR is too slow, do it asynchronously */
1950  printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
1951  ADDMSGO(MESSAGE_REJECT);
1952  }
1953 
1954  SYNCNEG=2; /* negotiation completed */
1955  SETRATE(SYNCRATE);
1956  }
1957  break;
1958 
1959  case BUS_DEVICE_RESET:
1960  {
1961  int i;
1962 
1963  for(i=0; i<8; i++) {
1964  HOSTDATA(shpnt)->syncrate[i]=0;
1965  HOSTDATA(shpnt)->syncneg[i]=0;
1966  }
1967 
1968  }
1969  break;
1970 
1971  case EXTENDED_MODIFY_DATA_POINTER:
1972  case EXTENDED_EXTENDED_IDENTIFY:
1973  case EXTENDED_WDTR:
1974  default:
1975  ADDMSGO(MESSAGE_REJECT);
1976  break;
1977  }
1978  break;
1979  }
1980 
1981  MSGILEN=0;
1982  }
1983 }
1984 
1985 static void msgi_end(struct Scsi_Host *shpnt)
1986 {
1987  if(MSGILEN>0)
1988  printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
1989 
1990  if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
1991  DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
1992  SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
1993  }
1994 }
1995 
1996 /*
1997  * message out phase
1998  *
1999  */
2000 static void msgo_init(struct Scsi_Host *shpnt)
2001 {
2002  if(MSGOLEN==0) {
2003  if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
2004  ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
2005  } else {
2006  printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
2007  ADDMSGO(MESSAGE_REJECT);
2008  }
2009  }
2010 
2011 #if defined(AHA152X_DEBUG)
2012  if(HOSTDATA(shpnt)->debug & debug_msgo) {
2013  int i;
2014 
2015  printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
2016  for (i=0; i<MSGOLEN; i+=spi_print_msg(&MSGO(i)), printk(" "))
2017  ;
2018  printk(")\n");
2019  }
2020 #endif
2021 }
2022 
2023 /*
2024  * message out phase
2025  *
2026  */
2027 static void msgo_run(struct Scsi_Host *shpnt)
2028 {
2029  if(MSGO_I==MSGOLEN)
2030  DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2031 
2032  while(MSGO_I<MSGOLEN) {
2033  DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
2034 
2035  if(TESTLO(SSTAT0, SPIORDY)) {
2036  DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2037  return;
2038  }
2039 
2040  if (MSGO_I==MSGOLEN-1) {
2041  /* Leave MESSAGE OUT after transfer */
2042  SETPORT(SSTAT1, CLRATNO);
2043  }
2044 
2045 
2046  if (MSGO(MSGO_I) & IDENTIFY_BASE)
2047  CURRENT_SC->SCp.phase |= identified;
2048 
2049  if (MSGO(MSGO_I)==ABORT)
2050  CURRENT_SC->SCp.phase |= aborted;
2051 
2052  if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
2053  CURRENT_SC->SCp.phase |= resetted;
2054 
2055  SETPORT(SCSIDAT, MSGO(MSGO_I++));
2056  }
2057 }
2058 
2059 static void msgo_end(struct Scsi_Host *shpnt)
2060 {
2061  if(MSGO_I<MSGOLEN) {
2062  printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2063  if(SYNCNEG==1) {
2064  printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
2065  SYNCNEG=2;
2066  }
2067  }
2068 
2069  MSGO_I = 0;
2070  MSGOLEN = 0;
2071 }
2072 
2073 /*
2074  * command phase
2075  *
2076  */
2077 static void cmd_init(struct Scsi_Host *shpnt)
2078 {
2079  if (CURRENT_SC->SCp.sent_command) {
2080  printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
2081  done(shpnt, DID_ERROR << 16);
2082  return;
2083  }
2084 
2085 #if defined(AHA152X_DEBUG)
2086  if (HOSTDATA(shpnt)->debug & debug_cmd) {
2087  printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
2088  __scsi_print_command(CURRENT_SC->cmnd);
2089  }
2090 #endif
2091 
2092  CMD_I=0;
2093 }
2094 
2095 /*
2096  * command phase
2097  *
2098  */
2099 static void cmd_run(struct Scsi_Host *shpnt)
2100 {
2101  if(CMD_I==CURRENT_SC->cmd_len) {
2102  DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2103  disp_ports(shpnt);
2104  }
2105 
2106  while(CMD_I<CURRENT_SC->cmd_len) {
2107  DPRINTK(debug_cmd, DEBUG_LEAD "command byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), CURRENT_SC->cmnd[CMD_I], CMD_I, CURRENT_SC->cmd_len);
2108 
2109  if(TESTLO(SSTAT0, SPIORDY)) {
2110  DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2111  return;
2112  }
2113 
2114  SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
2115  }
2116 }
2117 
2118 static void cmd_end(struct Scsi_Host *shpnt)
2119 {
2120  if(CMD_I<CURRENT_SC->cmd_len)
2121  printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2122  else
2123  CURRENT_SC->SCp.sent_command++;
2124 }
2125 
2126 /*
2127  * status phase
2128  *
2129  */
2130 static void status_run(struct Scsi_Host *shpnt)
2131 {
2132  if(TESTLO(SSTAT0,SPIORDY)) {
2133  DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2134  return;
2135  }
2136 
2137  CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
2138 
2139 #if defined(AHA152X_DEBUG)
2140  if (HOSTDATA(shpnt)->debug & debug_status) {
2141  printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
2142  scsi_print_status(CURRENT_SC->SCp.Status);
2143  printk("\n");
2144  }
2145 #endif
2146 }
2147 
2148 /*
2149  * data in phase
2150  *
2151  */
2152 static void datai_init(struct Scsi_Host *shpnt)
2153 {
2154  SETPORT(DMACNTRL0, RSTFIFO);
2155  SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2156 
2157  SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2158  SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2159 
2160  SETPORT(SIMODE0, 0);
2161  SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
2162 
2163  DATA_LEN=0;
2164  DPRINTK(debug_datai,
2165  DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
2166  CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2167  scsi_get_resid(CURRENT_SC));
2168 }
2169 
2170 static void datai_run(struct Scsi_Host *shpnt)
2171 {
2172  unsigned long the_time;
2173  int fifodata, data_count;
2174 
2175  /*
2176  * loop while the phase persists or the fifos are not empty
2177  *
2178  */
2179  while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2180  /* FIXME: maybe this should be done by setting up
2181  * STCNT to trigger ENSWRAP interrupt, instead of
2182  * polling for DFIFOFULL
2183  */
2184  the_time=jiffies + 100*HZ;
2185  while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2186  barrier();
2187 
2188  if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2189  printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
2190  disp_ports(shpnt);
2191  break;
2192  }
2193 
2194  if(TESTHI(DMASTAT, DFIFOFULL)) {
2195  fifodata = 128;
2196  } else {
2197  the_time=jiffies + 100*HZ;
2198  while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2199  barrier();
2200 
2201  if(TESTLO(SSTAT2, SEMPTY)) {
2202  printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
2203  disp_ports(shpnt);
2204  break;
2205  }
2206 
2207  fifodata = GETPORT(FIFOSTAT);
2208  }
2209 
2210  if(CURRENT_SC->SCp.this_residual>0) {
2211  while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2212  data_count = fifodata>CURRENT_SC->SCp.this_residual ?
2213  CURRENT_SC->SCp.this_residual :
2214  fifodata;
2215  fifodata -= data_count;
2216 
2217  if(data_count & 1) {
2218  DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
2219  SETPORT(DMACNTRL0, ENDMA|_8BIT);
2220  *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2221  CURRENT_SC->SCp.this_residual--;
2222  DATA_LEN++;
2223  SETPORT(DMACNTRL0, ENDMA);
2224  }
2225 
2226  if(data_count > 1) {
2227  DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
2228  data_count >>= 1;
2229  insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2230  CURRENT_SC->SCp.ptr += 2 * data_count;
2231  CURRENT_SC->SCp.this_residual -= 2 * data_count;
2232  DATA_LEN += 2 * data_count;
2233  }
2234 
2235  if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2236  /* advance to next buffer */
2237  CURRENT_SC->SCp.buffers_residual--;
2238  CURRENT_SC->SCp.buffer++;
2239  CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2240  CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2241  }
2242  }
2243  } else if(fifodata>0) {
2244  printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
2245  SETPORT(DMACNTRL0, ENDMA|_8BIT);
2246  while(fifodata>0) {
2247  int data;
2248  data=GETPORT(DATAPORT);
2249  DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
2250  fifodata--;
2251  DATA_LEN++;
2252  }
2253  SETPORT(DMACNTRL0, ENDMA|_8BIT);
2254  }
2255  }
2256 
2257  if(TESTLO(DMASTAT, INTSTAT) ||
2258  TESTLO(DMASTAT, DFIFOEMP) ||
2259  TESTLO(SSTAT2, SEMPTY) ||
2260  GETPORT(FIFOSTAT)>0) {
2261  /*
2262  * something went wrong, if there's something left in the fifos
2263  * or the phase didn't change
2264  */
2265  printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
2266  disp_ports(shpnt);
2267  }
2268 
2269  if(DATA_LEN!=GETSTCNT()) {
2270  printk(ERR_LEAD
2271  "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2272  CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
2273  disp_ports(shpnt);
2274  mdelay(10000);
2275  }
2276 }
2277 
2278 static void datai_end(struct Scsi_Host *shpnt)
2279 {
2280  CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2281 
2282  DPRINTK(debug_datai,
2283  DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2284  CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2285  scsi_get_resid(CURRENT_SC), GETSTCNT());
2286 
2287  SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2288  SETPORT(DMACNTRL0, 0);
2289 }
2290 
2291 /*
2292  * data out phase
2293  *
2294  */
2295 static void datao_init(struct Scsi_Host *shpnt)
2296 {
2297  SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2298  SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2299 
2300  SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2301  SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2302 
2303  SETPORT(SIMODE0, 0);
2304  SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2305 
2306  DATA_LEN = scsi_get_resid(CURRENT_SC);
2307 
2308  DPRINTK(debug_datao,
2309  DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
2310  CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2311  scsi_get_resid(CURRENT_SC));
2312 }
2313 
2314 static void datao_run(struct Scsi_Host *shpnt)
2315 {
2316  unsigned long the_time;
2317  int data_count;
2318 
2319  /* until phase changes or all data sent */
2320  while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2321  data_count = 128;
2322  if(data_count > CURRENT_SC->SCp.this_residual)
2323  data_count=CURRENT_SC->SCp.this_residual;
2324 
2325  if(TESTLO(DMASTAT, DFIFOEMP)) {
2326  printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
2327  disp_ports(shpnt);
2328  break;
2329  }
2330 
2331  if(data_count & 1) {
2332  SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2333  SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2334  CURRENT_SC->SCp.this_residual--;
2335  CMD_INC_RESID(CURRENT_SC, -1);
2336  SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2337  }
2338 
2339  if(data_count > 1) {
2340  data_count >>= 1;
2341  outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2342  CURRENT_SC->SCp.ptr += 2 * data_count;
2343  CURRENT_SC->SCp.this_residual -= 2 * data_count;
2344  CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2345  }
2346 
2347  if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2348  /* advance to next buffer */
2349  CURRENT_SC->SCp.buffers_residual--;
2350  CURRENT_SC->SCp.buffer++;
2351  CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2352  CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2353  }
2354 
2355  the_time=jiffies + 100*HZ;
2356  while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2357  barrier();
2358 
2359  if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2360  printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
2361  disp_ports(shpnt);
2362  break;
2363  }
2364  }
2365 }
2366 
2367 static void datao_end(struct Scsi_Host *shpnt)
2368 {
2369  if(TESTLO(DMASTAT, DFIFOEMP)) {
2370  int data_count = (DATA_LEN - scsi_get_resid(CURRENT_SC)) -
2371  GETSTCNT();
2372 
2373  DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
2374  CMDINFO(CURRENT_SC),
2375  data_count,
2376  DATA_LEN - scsi_get_resid(CURRENT_SC),
2377  GETSTCNT());
2378 
2379  CMD_INC_RESID(CURRENT_SC, data_count);
2380 
2381  data_count -= CURRENT_SC->SCp.ptr -
2382  SG_ADDRESS(CURRENT_SC->SCp.buffer);
2383  while(data_count>0) {
2384  CURRENT_SC->SCp.buffer--;
2385  CURRENT_SC->SCp.buffers_residual++;
2386  data_count -= CURRENT_SC->SCp.buffer->length;
2387  }
2388  CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) -
2389  data_count;
2390  CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length +
2391  data_count;
2392  }
2393 
2394  DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2395  CMDINFO(CURRENT_SC),
2396  scsi_bufflen(CURRENT_SC),
2397  scsi_get_resid(CURRENT_SC),
2398  GETSTCNT());
2399 
2400  SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2401  SETPORT(SXFRCTL0, CH1);
2402 
2403  SETPORT(DMACNTRL0, 0);
2404 }
2405 
2406 /*
2407  * figure out what state we're in
2408  *
2409  */
2410 static int update_state(struct Scsi_Host *shpnt)
2411 {
2412  int dataphase=0;
2413  unsigned int stat0 = GETPORT(SSTAT0);
2414  unsigned int stat1 = GETPORT(SSTAT1);
2415 
2416  PREVSTATE = STATE;
2417  STATE=unknown;
2418 
2419  if(stat1 & SCSIRSTI) {
2420  STATE=rsti;
2421  SETPORT(SCSISEQ,0);
2422  SETPORT(SSTAT1,SCSIRSTI);
2423  } else if(stat0 & SELDI && PREVSTATE==busfree) {
2424  STATE=seldi;
2425  } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2426  STATE=seldo;
2427  } else if(stat1 & SELTO) {
2428  STATE=selto;
2429  } else if(stat1 & BUSFREE) {
2430  STATE=busfree;
2431  SETPORT(SSTAT1,BUSFREE);
2432  } else if(stat1 & SCSIPERR) {
2433  STATE=parerr;
2434  SETPORT(SSTAT1,SCSIPERR);
2435  } else if(stat1 & REQINIT) {
2436  switch(GETPORT(SCSISIG) & P_MASK) {
2437  case P_MSGI: STATE=msgi; break;
2438  case P_MSGO: STATE=msgo; break;
2439  case P_DATAO: STATE=datao; break;
2440  case P_DATAI: STATE=datai; break;
2441  case P_STATUS: STATE=status; break;
2442  case P_CMD: STATE=cmd; break;
2443  }
2444  dataphase=1;
2445  }
2446 
2447  if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2448  printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
2449  disp_ports(shpnt);
2450  }
2451 
2452  if(STATE!=PREVSTATE) {
2453  LASTSTATE=PREVSTATE;
2454  }
2455 
2456  return dataphase;
2457 }
2458 
2459 /*
2460  * handle parity error
2461  *
2462  * FIXME: in which phase?
2463  *
2464  */
2465 static void parerr_run(struct Scsi_Host *shpnt)
2466 {
2467  printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
2468  done(shpnt, DID_PARITY << 16);
2469 }
2470 
2471 /*
2472  * handle reset in
2473  *
2474  */
2475 static void rsti_run(struct Scsi_Host *shpnt)
2476 {
2477  Scsi_Cmnd *ptr;
2478 
2479  printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
2480 
2481  ptr=DISCONNECTED_SC;
2482  while(ptr) {
2483  Scsi_Cmnd *next = SCNEXT(ptr);
2484 
2485  if (!ptr->device->soft_reset) {
2486  remove_SC(&DISCONNECTED_SC, ptr);
2487 
2488  kfree(ptr->host_scribble);
2489  ptr->host_scribble=NULL;
2490 
2491  ptr->result = DID_RESET << 16;
2492  ptr->scsi_done(ptr);
2493  }
2494 
2495  ptr = next;
2496  }
2497 
2498  if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2499  done(shpnt, DID_RESET << 16 );
2500 }
2501 
2502 
2503 /*
2504  * bottom-half handler
2505  *
2506  */
2507 static void is_complete(struct Scsi_Host *shpnt)
2508 {
2509  int dataphase;
2510  unsigned long flags;
2511  int pending;
2512 
2513  if(!shpnt)
2514  return;
2515 
2516  DO_LOCK(flags);
2517 
2518  if( HOSTDATA(shpnt)->service==0 ) {
2519  DO_UNLOCK(flags);
2520  return;
2521  }
2522 
2523  HOSTDATA(shpnt)->service = 0;
2524 
2525  if(HOSTDATA(shpnt)->in_intr) {
2526  DO_UNLOCK(flags);
2527  /* aha152x_error never returns.. */
2528  aha152x_error(shpnt, "bottom-half already running!?");
2529  }
2530  HOSTDATA(shpnt)->in_intr++;
2531 
2532  /*
2533  * loop while there are interrupt conditions pending
2534  *
2535  */
2536  do {
2537  unsigned long start = jiffies;
2538  DO_UNLOCK(flags);
2539 
2540  dataphase=update_state(shpnt);
2541 
2542  DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2543 
2544  /*
2545  * end previous state
2546  *
2547  */
2548  if(PREVSTATE!=STATE && states[PREVSTATE].end)
2549  states[PREVSTATE].end(shpnt);
2550 
2551  /*
2552  * disable SPIO mode if previous phase used it
2553  * and this one doesn't
2554  *
2555  */
2556  if(states[PREVSTATE].spio && !states[STATE].spio) {
2557  SETPORT(SXFRCTL0, CH1);
2558  SETPORT(DMACNTRL0, 0);
2559  if(CURRENT_SC)
2560  CURRENT_SC->SCp.phase &= ~spiordy;
2561  }
2562 
2563  /*
2564  * accept current dataphase phase
2565  *
2566  */
2567  if(dataphase) {
2568  SETPORT(SSTAT0, REQINIT);
2569  SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2570  SETPORT(SSTAT1, PHASECHG);
2571  }
2572 
2573  /*
2574  * enable SPIO mode if previous didn't use it
2575  * and this one does
2576  *
2577  */
2578  if(!states[PREVSTATE].spio && states[STATE].spio) {
2579  SETPORT(DMACNTRL0, 0);
2580  SETPORT(SXFRCTL0, CH1|SPIOEN);
2581  if(CURRENT_SC)
2582  CURRENT_SC->SCp.phase |= spiordy;
2583  }
2584 
2585  /*
2586  * initialize for new state
2587  *
2588  */
2589  if(PREVSTATE!=STATE && states[STATE].init)
2590  states[STATE].init(shpnt);
2591 
2592  /*
2593  * handle current state
2594  *
2595  */
2596  if(states[STATE].run)
2597  states[STATE].run(shpnt);
2598  else
2599  printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
2600 
2601  /*
2602  * setup controller to interrupt on
2603  * the next expected condition and
2604  * loop if it's already there
2605  *
2606  */
2607  DO_LOCK(flags);
2608  pending=setup_expected_interrupts(shpnt);
2609 #if defined(AHA152X_STAT)
2610  HOSTDATA(shpnt)->count[STATE]++;
2611  if(PREVSTATE!=STATE)
2612  HOSTDATA(shpnt)->count_trans[STATE]++;
2613  HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2614 #endif
2615 
2616  DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2617  } while(pending);
2618 
2619  /*
2620  * enable interrupts and leave bottom-half
2621  *
2622  */
2623  HOSTDATA(shpnt)->in_intr--;
2624  SETBITS(DMACNTRL0, INTEN);
2625  DO_UNLOCK(flags);
2626 }
2627 
2628 
2629 /*
2630  * Dump the current driver status and panic
2631  */
2632 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2633 {
2634  printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
2635  show_queues(shpnt);
2636  panic("aha152x panic\n");
2637 }
2638 
2639 /*
2640  * Display registers of AIC-6260
2641  */
2642 static void disp_ports(struct Scsi_Host *shpnt)
2643 {
2644 #if defined(AHA152X_DEBUG)
2645  int s;
2646 
2647  printk("\n%s: %s(%s) ",
2648  CURRENT_SC ? "busy" : "waiting",
2649  states[STATE].name,
2650  states[PREVSTATE].name);
2651 
2652  s = GETPORT(SCSISEQ);
2653  printk("SCSISEQ( ");
2654  if (s & TEMODEO)
2655  printk("TARGET MODE ");
2656  if (s & ENSELO)
2657  printk("SELO ");
2658  if (s & ENSELI)
2659  printk("SELI ");
2660  if (s & ENRESELI)
2661  printk("RESELI ");
2662  if (s & ENAUTOATNO)
2663  printk("AUTOATNO ");
2664  if (s & ENAUTOATNI)
2665  printk("AUTOATNI ");
2666  if (s & ENAUTOATNP)
2667  printk("AUTOATNP ");
2668  if (s & SCSIRSTO)
2669  printk("SCSIRSTO ");
2670  printk(");");
2671 
2672  printk(" SCSISIG(");
2673  s = GETPORT(SCSISIG);
2674  switch (s & P_MASK) {
2675  case P_DATAO:
2676  printk("DATA OUT");
2677  break;
2678  case P_DATAI:
2679  printk("DATA IN");
2680  break;
2681  case P_CMD:
2682  printk("COMMAND");
2683  break;
2684  case P_STATUS:
2685  printk("STATUS");
2686  break;
2687  case P_MSGO:
2688  printk("MESSAGE OUT");
2689  break;
2690  case P_MSGI:
2691  printk("MESSAGE IN");
2692  break;
2693  default:
2694  printk("*invalid*");
2695  break;
2696  }
2697 
2698  printk("); ");
2699 
2700  printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2701 
2702  printk("SSTAT( ");
2703  s = GETPORT(SSTAT0);
2704  if (s & TARGET)
2705  printk("TARGET ");
2706  if (s & SELDO)
2707  printk("SELDO ");
2708  if (s & SELDI)
2709  printk("SELDI ");
2710  if (s & SELINGO)
2711  printk("SELINGO ");
2712  if (s & SWRAP)
2713  printk("SWRAP ");
2714  if (s & SDONE)
2715  printk("SDONE ");
2716  if (s & SPIORDY)
2717  printk("SPIORDY ");
2718  if (s & DMADONE)
2719  printk("DMADONE ");
2720 
2721  s = GETPORT(SSTAT1);
2722  if (s & SELTO)
2723  printk("SELTO ");
2724  if (s & ATNTARG)
2725  printk("ATNTARG ");
2726  if (s & SCSIRSTI)
2727  printk("SCSIRSTI ");
2728  if (s & PHASEMIS)
2729  printk("PHASEMIS ");
2730  if (s & BUSFREE)
2731  printk("BUSFREE ");
2732  if (s & SCSIPERR)
2733  printk("SCSIPERR ");
2734  if (s & PHASECHG)
2735  printk("PHASECHG ");
2736  if (s & REQINIT)
2737  printk("REQINIT ");
2738  printk("); ");
2739 
2740 
2741  printk("SSTAT( ");
2742 
2743  s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2744 
2745  if (s & TARGET)
2746  printk("TARGET ");
2747  if (s & SELDO)
2748  printk("SELDO ");
2749  if (s & SELDI)
2750  printk("SELDI ");
2751  if (s & SELINGO)
2752  printk("SELINGO ");
2753  if (s & SWRAP)
2754  printk("SWRAP ");
2755  if (s & SDONE)
2756  printk("SDONE ");
2757  if (s & SPIORDY)
2758  printk("SPIORDY ");
2759  if (s & DMADONE)
2760  printk("DMADONE ");
2761 
2762  s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2763 
2764  if (s & SELTO)
2765  printk("SELTO ");
2766  if (s & ATNTARG)
2767  printk("ATNTARG ");
2768  if (s & SCSIRSTI)
2769  printk("SCSIRSTI ");
2770  if (s & PHASEMIS)
2771  printk("PHASEMIS ");
2772  if (s & BUSFREE)
2773  printk("BUSFREE ");
2774  if (s & SCSIPERR)
2775  printk("SCSIPERR ");
2776  if (s & PHASECHG)
2777  printk("PHASECHG ");
2778  if (s & REQINIT)
2779  printk("REQINIT ");
2780  printk("); ");
2781 
2782  printk("SXFRCTL0( ");
2783 
2784  s = GETPORT(SXFRCTL0);
2785  if (s & SCSIEN)
2786  printk("SCSIEN ");
2787  if (s & DMAEN)
2788  printk("DMAEN ");
2789  if (s & CH1)
2790  printk("CH1 ");
2791  if (s & CLRSTCNT)
2792  printk("CLRSTCNT ");
2793  if (s & SPIOEN)
2794  printk("SPIOEN ");
2795  if (s & CLRCH1)
2796  printk("CLRCH1 ");
2797  printk("); ");
2798 
2799  printk("SIGNAL( ");
2800 
2801  s = GETPORT(SCSISIG);
2802  if (s & SIG_ATNI)
2803  printk("ATNI ");
2804  if (s & SIG_SELI)
2805  printk("SELI ");
2806  if (s & SIG_BSYI)
2807  printk("BSYI ");
2808  if (s & SIG_REQI)
2809  printk("REQI ");
2810  if (s & SIG_ACKI)
2811  printk("ACKI ");
2812  printk("); ");
2813 
2814  printk("SELID (%02x), ", GETPORT(SELID));
2815 
2816  printk("STCNT (%d), ", GETSTCNT());
2817 
2818  printk("SSTAT2( ");
2819 
2820  s = GETPORT(SSTAT2);
2821  if (s & SOFFSET)
2822  printk("SOFFSET ");
2823  if (s & SEMPTY)
2824  printk("SEMPTY ");
2825  if (s & SFULL)
2826  printk("SFULL ");
2827  printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
2828 
2829  s = GETPORT(SSTAT3);
2830  printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2831 
2832  printk("SSTAT4( ");
2833  s = GETPORT(SSTAT4);
2834  if (s & SYNCERR)
2835  printk("SYNCERR ");
2836  if (s & FWERR)
2837  printk("FWERR ");
2838  if (s & FRERR)
2839  printk("FRERR ");
2840  printk("); ");
2841 
2842  printk("DMACNTRL0( ");
2843  s = GETPORT(DMACNTRL0);
2844  printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2845  printk("%s ", s & DMA ? "DMA" : "PIO");
2846  printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
2847  if (s & ENDMA)
2848  printk("ENDMA ");
2849  if (s & INTEN)
2850  printk("INTEN ");
2851  if (s & RSTFIFO)
2852  printk("RSTFIFO ");
2853  if (s & SWINT)
2854  printk("SWINT ");
2855  printk("); ");
2856 
2857  printk("DMASTAT( ");
2858  s = GETPORT(DMASTAT);
2859  if (s & ATDONE)
2860  printk("ATDONE ");
2861  if (s & WORDRDY)
2862  printk("WORDRDY ");
2863  if (s & DFIFOFULL)
2864  printk("DFIFOFULL ");
2865  if (s & DFIFOEMP)
2866  printk("DFIFOEMP ");
2867  printk(")\n");
2868 #endif
2869 }
2870 
2871 /*
2872  * display enabled interrupts
2873  */
2874 static void disp_enintr(struct Scsi_Host *shpnt)
2875 {
2876  int s;
2877 
2878  printk(KERN_DEBUG "enabled interrupts ( ");
2879 
2880  s = GETPORT(SIMODE0);
2881  if (s & ENSELDO)
2882  printk("ENSELDO ");
2883  if (s & ENSELDI)
2884  printk("ENSELDI ");
2885  if (s & ENSELINGO)
2886  printk("ENSELINGO ");
2887  if (s & ENSWRAP)
2888  printk("ENSWRAP ");
2889  if (s & ENSDONE)
2890  printk("ENSDONE ");
2891  if (s & ENSPIORDY)
2892  printk("ENSPIORDY ");
2893  if (s & ENDMADONE)
2894  printk("ENDMADONE ");
2895 
2896  s = GETPORT(SIMODE1);
2897  if (s & ENSELTIMO)
2898  printk("ENSELTIMO ");
2899  if (s & ENATNTARG)
2900  printk("ENATNTARG ");
2901  if (s & ENPHASEMIS)
2902  printk("ENPHASEMIS ");
2903  if (s & ENBUSFREE)
2904  printk("ENBUSFREE ");
2905  if (s & ENSCSIPERR)
2906  printk("ENSCSIPERR ");
2907  if (s & ENPHASECHG)
2908  printk("ENPHASECHG ");
2909  if (s & ENREQINIT)
2910  printk("ENREQINIT ");
2911  printk(")\n");
2912 }
2913 
2914 /*
2915  * Show the command data of a command
2916  */
2917 static void show_command(Scsi_Cmnd *ptr)
2918 {
2919  scmd_printk(KERN_DEBUG, ptr, "%p: cmnd=(", ptr);
2920 
2921  __scsi_print_command(ptr->cmnd);
2922 
2923  printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
2924  scsi_bufflen(ptr), scsi_get_resid(ptr));
2925 
2926  if (ptr->SCp.phase & not_issued)
2927  printk("not issued|");
2928  if (ptr->SCp.phase & selecting)
2929  printk("selecting|");
2930  if (ptr->SCp.phase & identified)
2931  printk("identified|");
2932  if (ptr->SCp.phase & disconnected)
2933  printk("disconnected|");
2934  if (ptr->SCp.phase & completed)
2935  printk("completed|");
2936  if (ptr->SCp.phase & spiordy)
2937  printk("spiordy|");
2938  if (ptr->SCp.phase & syncneg)
2939  printk("syncneg|");
2940  if (ptr->SCp.phase & aborted)
2941  printk("aborted|");
2942  if (ptr->SCp.phase & resetted)
2943  printk("resetted|");
2944  if( SCDATA(ptr) ) {
2945  printk("; next=0x%p\n", SCNEXT(ptr));
2946  } else {
2947  printk("; next=(host scribble NULL)\n");
2948  }
2949 }
2950 
2951 /*
2952  * Dump the queued data
2953  */
2954 static void show_queues(struct Scsi_Host *shpnt)
2955 {
2956  Scsi_Cmnd *ptr;
2957  unsigned long flags;
2958 
2959  DO_LOCK(flags);
2960  printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2961  for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2962  show_command(ptr);
2963  DO_UNLOCK(flags);
2964 
2965  printk(KERN_DEBUG "current_SC:\n");
2966  if (CURRENT_SC)
2967  show_command(CURRENT_SC);
2968  else
2969  printk(KERN_DEBUG "none\n");
2970 
2971  printk(KERN_DEBUG "disconnected_SC:\n");
2972  for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2973  show_command(ptr);
2974 
2975  disp_ports(shpnt);
2976  disp_enintr(shpnt);
2977 }
2978 
2979 #undef SPRINTF
2980 #define SPRINTF(args...) pos += sprintf(pos, ## args)
2981 
2982 static int get_command(char *pos, Scsi_Cmnd * ptr)
2983 {
2984  char *start = pos;
2985  int i;
2986 
2987  SPRINTF("%p: target=%d; lun=%d; cmnd=( ",
2988  ptr, ptr->device->id, ptr->device->lun);
2989 
2990  for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2991  SPRINTF("0x%02x ", ptr->cmnd[i]);
2992 
2993  SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
2994  scsi_get_resid(ptr), ptr->SCp.this_residual,
2995  ptr->SCp.buffers_residual);
2996 
2997  if (ptr->SCp.phase & not_issued)
2998  SPRINTF("not issued|");
2999  if (ptr->SCp.phase & selecting)
3000  SPRINTF("selecting|");
3001  if (ptr->SCp.phase & disconnected)
3002  SPRINTF("disconnected|");
3003  if (ptr->SCp.phase & aborted)
3004  SPRINTF("aborted|");
3005  if (ptr->SCp.phase & identified)
3006  SPRINTF("identified|");
3007  if (ptr->SCp.phase & completed)
3008  SPRINTF("completed|");
3009  if (ptr->SCp.phase & spiordy)
3010  SPRINTF("spiordy|");
3011  if (ptr->SCp.phase & syncneg)
3012  SPRINTF("syncneg|");
3013  SPRINTF("; next=0x%p\n", SCNEXT(ptr));
3014 
3015  return (pos - start);
3016 }
3017 
3018 static int get_ports(struct Scsi_Host *shpnt, char *pos)
3019 {
3020  char *start = pos;
3021  int s;
3022 
3023  SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
3024 
3025  s = GETPORT(SCSISEQ);
3026  SPRINTF("SCSISEQ( ");
3027  if (s & TEMODEO)
3028  SPRINTF("TARGET MODE ");
3029  if (s & ENSELO)
3030  SPRINTF("SELO ");
3031  if (s & ENSELI)
3032  SPRINTF("SELI ");
3033  if (s & ENRESELI)
3034  SPRINTF("RESELI ");
3035  if (s & ENAUTOATNO)
3036  SPRINTF("AUTOATNO ");
3037  if (s & ENAUTOATNI)
3038  SPRINTF("AUTOATNI ");
3039  if (s & ENAUTOATNP)
3040  SPRINTF("AUTOATNP ");
3041  if (s & SCSIRSTO)
3042  SPRINTF("SCSIRSTO ");
3043  SPRINTF(");");
3044 
3045  SPRINTF(" SCSISIG(");
3046  s = GETPORT(SCSISIG);
3047  switch (s & P_MASK) {
3048  case P_DATAO:
3049  SPRINTF("DATA OUT");
3050  break;
3051  case P_DATAI:
3052  SPRINTF("DATA IN");
3053  break;
3054  case P_CMD:
3055  SPRINTF("COMMAND");
3056  break;
3057  case P_STATUS:
3058  SPRINTF("STATUS");
3059  break;
3060  case P_MSGO:
3061  SPRINTF("MESSAGE OUT");
3062  break;
3063  case P_MSGI:
3064  SPRINTF("MESSAGE IN");
3065  break;
3066  default:
3067  SPRINTF("*invalid*");
3068  break;
3069  }
3070 
3071  SPRINTF("); ");
3072 
3073  SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3074 
3075  SPRINTF("SSTAT( ");
3076  s = GETPORT(SSTAT0);
3077  if (s & TARGET)
3078  SPRINTF("TARGET ");
3079  if (s & SELDO)
3080  SPRINTF("SELDO ");
3081  if (s & SELDI)
3082  SPRINTF("SELDI ");
3083  if (s & SELINGO)
3084  SPRINTF("SELINGO ");
3085  if (s & SWRAP)
3086  SPRINTF("SWRAP ");
3087  if (s & SDONE)
3088  SPRINTF("SDONE ");
3089  if (s & SPIORDY)
3090  SPRINTF("SPIORDY ");
3091  if (s & DMADONE)
3092  SPRINTF("DMADONE ");
3093 
3094  s = GETPORT(SSTAT1);
3095  if (s & SELTO)
3096  SPRINTF("SELTO ");
3097  if (s & ATNTARG)
3098  SPRINTF("ATNTARG ");
3099  if (s & SCSIRSTI)
3100  SPRINTF("SCSIRSTI ");
3101  if (s & PHASEMIS)
3102  SPRINTF("PHASEMIS ");
3103  if (s & BUSFREE)
3104  SPRINTF("BUSFREE ");
3105  if (s & SCSIPERR)
3106  SPRINTF("SCSIPERR ");
3107  if (s & PHASECHG)
3108  SPRINTF("PHASECHG ");
3109  if (s & REQINIT)
3110  SPRINTF("REQINIT ");
3111  SPRINTF("); ");
3112 
3113 
3114  SPRINTF("SSTAT( ");
3115 
3116  s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
3117 
3118  if (s & TARGET)
3119  SPRINTF("TARGET ");
3120  if (s & SELDO)
3121  SPRINTF("SELDO ");
3122  if (s & SELDI)
3123  SPRINTF("SELDI ");
3124  if (s & SELINGO)
3125  SPRINTF("SELINGO ");
3126  if (s & SWRAP)
3127  SPRINTF("SWRAP ");
3128  if (s & SDONE)
3129  SPRINTF("SDONE ");
3130  if (s & SPIORDY)
3131  SPRINTF("SPIORDY ");
3132  if (s & DMADONE)
3133  SPRINTF("DMADONE ");
3134 
3135  s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
3136 
3137  if (s & SELTO)
3138  SPRINTF("SELTO ");
3139  if (s & ATNTARG)
3140  SPRINTF("ATNTARG ");
3141  if (s & SCSIRSTI)
3142  SPRINTF("SCSIRSTI ");
3143  if (s & PHASEMIS)
3144  SPRINTF("PHASEMIS ");
3145  if (s & BUSFREE)
3146  SPRINTF("BUSFREE ");
3147  if (s & SCSIPERR)
3148  SPRINTF("SCSIPERR ");
3149  if (s & PHASECHG)
3150  SPRINTF("PHASECHG ");
3151  if (s & REQINIT)
3152  SPRINTF("REQINIT ");
3153  SPRINTF("); ");
3154 
3155  SPRINTF("SXFRCTL0( ");
3156 
3157  s = GETPORT(SXFRCTL0);
3158  if (s & SCSIEN)
3159  SPRINTF("SCSIEN ");
3160  if (s & DMAEN)
3161  SPRINTF("DMAEN ");
3162  if (s & CH1)
3163  SPRINTF("CH1 ");
3164  if (s & CLRSTCNT)
3165  SPRINTF("CLRSTCNT ");
3166  if (s & SPIOEN)
3167  SPRINTF("SPIOEN ");
3168  if (s & CLRCH1)
3169  SPRINTF("CLRCH1 ");
3170  SPRINTF("); ");
3171 
3172  SPRINTF("SIGNAL( ");
3173 
3174  s = GETPORT(SCSISIG);
3175  if (s & SIG_ATNI)
3176  SPRINTF("ATNI ");
3177  if (s & SIG_SELI)
3178  SPRINTF("SELI ");
3179  if (s & SIG_BSYI)
3180  SPRINTF("BSYI ");
3181  if (s & SIG_REQI)
3182  SPRINTF("REQI ");
3183  if (s & SIG_ACKI)
3184  SPRINTF("ACKI ");
3185  SPRINTF("); ");
3186 
3187  SPRINTF("SELID(%02x), ", GETPORT(SELID));
3188 
3189  SPRINTF("STCNT(%d), ", GETSTCNT());
3190 
3191  SPRINTF("SSTAT2( ");
3192 
3193  s = GETPORT(SSTAT2);
3194  if (s & SOFFSET)
3195  SPRINTF("SOFFSET ");
3196  if (s & SEMPTY)
3197  SPRINTF("SEMPTY ");
3198  if (s & SFULL)
3199  SPRINTF("SFULL ");
3200  SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
3201 
3202  s = GETPORT(SSTAT3);
3203  SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
3204 
3205  SPRINTF("SSTAT4( ");
3206  s = GETPORT(SSTAT4);
3207  if (s & SYNCERR)
3208  SPRINTF("SYNCERR ");
3209  if (s & FWERR)
3210  SPRINTF("FWERR ");
3211  if (s & FRERR)
3212  SPRINTF("FRERR ");
3213  SPRINTF("); ");
3214 
3215  SPRINTF("DMACNTRL0( ");
3216  s = GETPORT(DMACNTRL0);
3217  SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3218  SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
3219  SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
3220  if (s & ENDMA)
3221  SPRINTF("ENDMA ");
3222  if (s & INTEN)
3223  SPRINTF("INTEN ");
3224  if (s & RSTFIFO)
3225  SPRINTF("RSTFIFO ");
3226  if (s & SWINT)
3227  SPRINTF("SWINT ");
3228  SPRINTF("); ");
3229 
3230  SPRINTF("DMASTAT( ");
3231  s = GETPORT(DMASTAT);
3232  if (s & ATDONE)
3233  SPRINTF("ATDONE ");
3234  if (s & WORDRDY)
3235  SPRINTF("WORDRDY ");
3236  if (s & DFIFOFULL)
3237  SPRINTF("DFIFOFULL ");
3238  if (s & DFIFOEMP)
3239  SPRINTF("DFIFOEMP ");
3240  SPRINTF(")\n");
3241 
3242  SPRINTF("enabled interrupts( ");
3243 
3244  s = GETPORT(SIMODE0);
3245  if (s & ENSELDO)
3246  SPRINTF("ENSELDO ");
3247  if (s & ENSELDI)
3248  SPRINTF("ENSELDI ");
3249  if (s & ENSELINGO)
3250  SPRINTF("ENSELINGO ");
3251  if (s & ENSWRAP)
3252  SPRINTF("ENSWRAP ");
3253  if (s & ENSDONE)
3254  SPRINTF("ENSDONE ");
3255  if (s & ENSPIORDY)
3256  SPRINTF("ENSPIORDY ");
3257  if (s & ENDMADONE)
3258  SPRINTF("ENDMADONE ");
3259 
3260  s = GETPORT(SIMODE1);
3261  if (s & ENSELTIMO)
3262  SPRINTF("ENSELTIMO ");
3263  if (s & ENATNTARG)
3264  SPRINTF("ENATNTARG ");
3265  if (s & ENPHASEMIS)
3266  SPRINTF("ENPHASEMIS ");
3267  if (s & ENBUSFREE)
3268  SPRINTF("ENBUSFREE ");
3269  if (s & ENSCSIPERR)
3270  SPRINTF("ENSCSIPERR ");
3271  if (s & ENPHASECHG)
3272  SPRINTF("ENPHASECHG ");
3273  if (s & ENREQINIT)
3274  SPRINTF("ENREQINIT ");
3275  SPRINTF(")\n");
3276 
3277  return (pos - start);
3278 }
3279 
3280 static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
3281 {
3282  if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
3283  return -EINVAL;
3284 
3285 #if defined(AHA152X_DEBUG)
3286  if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
3287  int debug = HOSTDATA(shpnt)->debug;
3288 
3289  HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
3290 
3291  printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
3292  } else
3293 #endif
3294 #if defined(AHA152X_STAT)
3295  if(length>13 && strncmp("reset", buffer+8, 5)==0) {
3296  int i;
3297 
3298  HOSTDATA(shpnt)->total_commands=0;
3299  HOSTDATA(shpnt)->disconnections=0;
3300  HOSTDATA(shpnt)->busfree_without_any_action=0;
3301  HOSTDATA(shpnt)->busfree_without_old_command=0;
3302  HOSTDATA(shpnt)->busfree_without_new_command=0;
3303  HOSTDATA(shpnt)->busfree_without_done_command=0;
3304  HOSTDATA(shpnt)->busfree_with_check_condition=0;
3305  for (i = idle; i<maxstate; i++) {
3306  HOSTDATA(shpnt)->count[i]=0;
3307  HOSTDATA(shpnt)->count_trans[i]=0;
3308  HOSTDATA(shpnt)->time[i]=0;
3309  }
3310 
3311  printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
3312 
3313  } else
3314 #endif
3315  {
3316  return -EINVAL;
3317  }
3318 
3319 
3320  return length;
3321 }
3322 
3323 #undef SPRINTF
3324 #define SPRINTF(args...) \
3325  do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3326 
3327 static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start,
3328  off_t offset, int length, int inout)
3329 {
3330  int i;
3331  char *pos = buffer;
3332  Scsi_Cmnd *ptr;
3333  unsigned long flags;
3334  int thislength;
3335 
3336  DPRINTK(debug_procinfo,
3337  KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n",
3338  buffer, offset, length, shpnt->host_no, inout);
3339 
3340 
3341  if (inout)
3342  return aha152x_set_info(buffer, length, shpnt);
3343 
3344  SPRINTF(AHA152X_REVID "\n");
3345 
3346  SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3347  shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
3348  SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3349  SPRINTF("disconnection/reconnection %s\n",
3350  RECONNECT ? "enabled" : "disabled");
3351  SPRINTF("parity checking %s\n",
3352  PARITY ? "enabled" : "disabled");
3353  SPRINTF("synchronous transfers %s\n",
3354  SYNCHRONOUS ? "enabled" : "disabled");
3355  SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
3356 
3357  if(SYNCHRONOUS) {
3358  SPRINTF("synchronously operating targets (tick=50 ns):\n");
3359  for (i = 0; i < 8; i++)
3360  if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
3361  SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3362  i,
3363  (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
3364  (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
3365  HOSTDATA(shpnt)->syncrate[i] & 0x0f);
3366  }
3367 #if defined(AHA152X_DEBUG)
3368 #define PDEBUG(flags,txt) \
3369  if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3370 
3371  SPRINTF("enabled debugging options: ");
3372 
3373  PDEBUG(debug_procinfo, "procinfo");
3374  PDEBUG(debug_queue, "queue");
3375  PDEBUG(debug_intr, "interrupt");
3376  PDEBUG(debug_selection, "selection");
3377  PDEBUG(debug_msgo, "message out");
3378  PDEBUG(debug_msgi, "message in");
3379  PDEBUG(debug_status, "status");
3380  PDEBUG(debug_cmd, "command");
3381  PDEBUG(debug_datai, "data in");
3382  PDEBUG(debug_datao, "data out");
3383  PDEBUG(debug_eh, "eh");
3384  PDEBUG(debug_locking, "locks");
3385  PDEBUG(debug_phases, "phases");
3386 
3387  SPRINTF("\n");
3388 #endif
3389 
3390  SPRINTF("\nqueue status:\n");
3391  DO_LOCK(flags);
3392  if (ISSUE_SC) {
3393  SPRINTF("not yet issued commands:\n");
3394  for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
3395  pos += get_command(pos, ptr);
3396  } else
3397  SPRINTF("no not yet issued commands\n");
3398  DO_UNLOCK(flags);
3399 
3400  if (CURRENT_SC) {
3401  SPRINTF("current command:\n");
3402  pos += get_command(pos, CURRENT_SC);
3403  } else
3404  SPRINTF("no current command\n");
3405 
3406  if (DISCONNECTED_SC) {
3407  SPRINTF("disconnected commands:\n");
3408  for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
3409  pos += get_command(pos, ptr);
3410  } else
3411  SPRINTF("no disconnected commands\n");
3412 
3413  pos += get_ports(shpnt, pos);
3414 
3415 #if defined(AHA152X_STAT)
3416  SPRINTF("statistics:\n"
3417  "total commands: %d\n"
3418  "disconnections: %d\n"
3419  "busfree with check condition: %d\n"
3420  "busfree without old command: %d\n"
3421  "busfree without new command: %d\n"
3422  "busfree without done command: %d\n"
3423  "busfree without any action: %d\n"
3424  "state "
3425  "transitions "
3426  "count "
3427  "time\n",
3428  HOSTDATA(shpnt)->total_commands,
3429  HOSTDATA(shpnt)->disconnections,
3430  HOSTDATA(shpnt)->busfree_with_check_condition,
3431  HOSTDATA(shpnt)->busfree_without_old_command,
3432  HOSTDATA(shpnt)->busfree_without_new_command,
3433  HOSTDATA(shpnt)->busfree_without_done_command,
3434  HOSTDATA(shpnt)->busfree_without_any_action);
3435  for(i=0; i<maxstate; i++) {
3436  SPRINTF("%-10s %-12d %-12d %-12ld\n",
3437  states[i].name,
3438  HOSTDATA(shpnt)->count_trans[i],
3439  HOSTDATA(shpnt)->count[i],
3440  HOSTDATA(shpnt)->time[i]);
3441  }
3442 #endif
3443 
3444  DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: pos=%p\n", pos);
3445 
3446  thislength = pos - (buffer + offset);
3447  DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: length=%d thislength=%d\n", length, thislength);
3448 
3449  if(thislength<0) {
3450  DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: output too short\n");
3451  *start = NULL;
3452  return 0;
3453  }
3454 
3455  thislength = thislength<length ? thislength : length;
3456 
3457  DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: return %d\n", thislength);
3458 
3459  *start = buffer + offset;
3460  return thislength < length ? thislength : length;
3461 }
3462 
3463 static int aha152x_adjust_queue(struct scsi_device *device)
3464 {
3465  blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
3466  return 0;
3467 }
3468 
3469 static struct scsi_host_template aha152x_driver_template = {
3470  .module = THIS_MODULE,
3471  .name = AHA152X_REVID,
3472  .proc_name = "aha152x",
3473  .proc_info = aha152x_proc_info,
3474  .queuecommand = aha152x_queue,
3475  .eh_abort_handler = aha152x_abort,
3476  .eh_device_reset_handler = aha152x_device_reset,
3477  .eh_bus_reset_handler = aha152x_bus_reset,
3478  .eh_host_reset_handler = aha152x_host_reset,
3479  .bios_param = aha152x_biosparam,
3480  .can_queue = 1,
3481  .this_id = 7,
3482  .sg_tablesize = SG_ALL,
3483  .cmd_per_lun = 1,
3484  .use_clustering = DISABLE_CLUSTERING,
3485  .slave_alloc = aha152x_adjust_queue,
3486 };
3487 
3488 #if !defined(PCMCIA)
3489 static int setup_count;
3490 static struct aha152x_setup setup[2];
3491 
3492 /* possible i/o addresses for the AIC-6260; default first */
3493 static unsigned short ports[] = { 0x340, 0x140 };
3494 
3495 #if !defined(SKIP_BIOSTEST)
3496 /* possible locations for the Adaptec BIOS; defaults first */
3497 static unsigned int addresses[] =
3498 {
3499  0xdc000, /* default first */
3500  0xc8000,
3501  0xcc000,
3502  0xd0000,
3503  0xd4000,
3504  0xd8000,
3505  0xe0000,
3506  0xeb800, /* VTech Platinum SMP */
3507  0xf0000,
3508 };
3509 
3510 /* signatures for various AIC-6[23]60 based controllers.
3511  The point in detecting signatures is to avoid useless and maybe
3512  harmful probes on ports. I'm not sure that all listed boards pass
3513  auto-configuration. For those which fail the BIOS signature is
3514  obsolete, because user intervention to supply the configuration is
3515  needed anyway. May be an information whether or not the BIOS supports
3516  extended translation could be also useful here. */
3517 static struct signature {
3518  unsigned char *signature;
3519  int sig_offset;
3520  int sig_length;
3521 } signatures[] =
3522 {
3523  { "Adaptec AHA-1520 BIOS", 0x102e, 21 },
3524  /* Adaptec 152x */
3525  { "Adaptec AHA-1520B", 0x000b, 17 },
3526  /* Adaptec 152x rev B */
3527  { "Adaptec AHA-1520B", 0x0026, 17 },
3528  /* Iomega Jaz Jet ISA (AIC6370Q) */
3529  { "Adaptec ASW-B626 BIOS", 0x1029, 21 },
3530  /* on-board controller */
3531  { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
3532  /* on-board controller */
3533  { "Adaptec ASW-B626 S2", 0x2e6c, 19 },
3534  /* on-board controller */
3535  { "Adaptec BIOS:AIC-6360", 0x000c, 21 },
3536  /* on-board controller */
3537  { "ScsiPro SP-360 BIOS", 0x2873, 19 },
3538  /* ScsiPro-Controller */
3539  { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3540  /* Gigabyte Local-Bus-SCSI */
3541  { "Adaptec BIOS:AVA-282X", 0x000c, 21 },
3542  /* Adaptec 282x */
3543  { "Adaptec IBM Dock II SCSI", 0x2edd, 24 },
3544  /* IBM Thinkpad Dock II */
3545  { "Adaptec BIOS:AHA-1532P", 0x001c, 22 },
3546  /* IBM Thinkpad Dock II SCSI */
3547  { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3548  /* DTC 3520A ISA SCSI */
3549 };
3550 #endif /* !SKIP_BIOSTEST */
3551 
3552 /*
3553  * Test, if port_base is valid.
3554  *
3555  */
3556 static int aha152x_porttest(int io_port)
3557 {
3558  int i;
3559 
3560  SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3561  for (i = 0; i < 16; i++)
3562  SETPORT(io_port + O_STACK, i);
3563 
3564  SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3565  for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3566  ;
3567 
3568  return (i == 16);
3569 }
3570 
3571 static int tc1550_porttest(int io_port)
3572 {
3573  int i;
3574 
3575  SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3576  for (i = 0; i < 16; i++)
3577  SETPORT(io_port + O_STACK, i);
3578 
3579  SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3580  for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3581  ;
3582 
3583  return (i == 16);
3584 }
3585 
3586 
3587 static int checksetup(struct aha152x_setup *setup)
3588 {
3589  int i;
3590  for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3591  ;
3592 
3593  if (i == ARRAY_SIZE(ports))
3594  return 0;
3595 
3596  if (!request_region(setup->io_port, IO_RANGE, "aha152x")) {
3597  printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3598  return 0;
3599  }
3600 
3601  if( aha152x_porttest(setup->io_port) ) {
3602  setup->tc1550=0;
3603  } else if( tc1550_porttest(setup->io_port) ) {
3604  setup->tc1550=1;
3605  } else {
3606  release_region(setup->io_port, IO_RANGE);
3607  return 0;
3608  }
3609 
3610  release_region(setup->io_port, IO_RANGE);
3611 
3612  if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3613  return 0;
3614 
3615  if ((setup->scsiid < 0) || (setup->scsiid > 7))
3616  return 0;
3617 
3618  if ((setup->reconnect < 0) || (setup->reconnect > 1))
3619  return 0;
3620 
3621  if ((setup->parity < 0) || (setup->parity > 1))
3622  return 0;
3623 
3624  if ((setup->synchronous < 0) || (setup->synchronous > 1))
3625  return 0;
3626 
3627  if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3628  return 0;
3629 
3630 
3631  return 1;
3632 }
3633 
3634 
3635 static int __init aha152x_init(void)
3636 {
3637  int i, j, ok;
3638 #if defined(AUTOCONF)
3639  aha152x_config conf;
3640 #endif
3641 #ifdef __ISAPNP__
3642  struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3643 #endif
3644 
3645  if ( setup_count ) {
3646  printk(KERN_INFO "aha152x: processing commandline: ");
3647 
3648  for (i = 0; i<setup_count; i++) {
3649  if (!checksetup(&setup[i])) {
3650  printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3651  printk(KERN_ERR "aha152x: invalid line\n");
3652  }
3653  }
3654  printk("ok\n");
3655  }
3656 
3657 #if defined(SETUP0)
3658  if (setup_count < ARRAY_SIZE(setup)) {
3659  struct aha152x_setup override = SETUP0;
3660 
3661  if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3662  if (!checksetup(&override)) {
3663  printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3664  override.io_port,
3665  override.irq,
3666  override.scsiid,
3667  override.reconnect,
3668  override.parity,
3669  override.synchronous,
3670  override.delay,
3671  override.ext_trans);
3672  } else
3673  setup[setup_count++] = override;
3674  }
3675  }
3676 #endif
3677 
3678 #if defined(SETUP1)
3679  if (setup_count < ARRAY_SIZE(setup)) {
3680  struct aha152x_setup override = SETUP1;
3681 
3682  if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3683  if (!checksetup(&override)) {
3684  printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3685  override.io_port,
3686  override.irq,
3687  override.scsiid,
3688  override.reconnect,
3689  override.parity,
3690  override.synchronous,
3691  override.delay,
3692  override.ext_trans);
3693  } else
3694  setup[setup_count++] = override;
3695  }
3696  }
3697 #endif
3698 
3699 #if defined(MODULE)
3700  if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3701  if(aha152x[0]!=0) {
3702  setup[setup_count].conf = "";
3703  setup[setup_count].io_port = aha152x[0];
3704  setup[setup_count].irq = aha152x[1];
3705  setup[setup_count].scsiid = aha152x[2];
3706  setup[setup_count].reconnect = aha152x[3];
3707  setup[setup_count].parity = aha152x[4];
3708  setup[setup_count].synchronous = aha152x[5];
3709  setup[setup_count].delay = aha152x[6];
3710  setup[setup_count].ext_trans = aha152x[7];
3711 #if defined(AHA152X_DEBUG)
3712  setup[setup_count].debug = aha152x[8];
3713 #endif
3714  } else if(io[0]!=0 || irq[0]!=0) {
3715  if(io[0]!=0) setup[setup_count].io_port = io[0];
3716  if(irq[0]!=0) setup[setup_count].irq = irq[0];
3717 
3718  setup[setup_count].scsiid = scsiid[0];
3719  setup[setup_count].reconnect = reconnect[0];
3720  setup[setup_count].parity = parity[0];
3721  setup[setup_count].synchronous = sync[0];
3722  setup[setup_count].delay = delay[0];
3723  setup[setup_count].ext_trans = exttrans[0];
3724 #if defined(AHA152X_DEBUG)
3725  setup[setup_count].debug = debug[0];
3726 #endif
3727  }
3728 
3729  if (checksetup(&setup[setup_count]))
3730  setup_count++;
3731  else
3732  printk(KERN_ERR "aha152x: invalid module params io=0x%x, irq=%d,scsiid=%d,reconnect=%d,parity=%d,sync=%d,delay=%d,exttrans=%d\n",
3733  setup[setup_count].io_port,
3734  setup[setup_count].irq,
3735  setup[setup_count].scsiid,
3736  setup[setup_count].reconnect,
3737  setup[setup_count].parity,
3738  setup[setup_count].synchronous,
3739  setup[setup_count].delay,
3740  setup[setup_count].ext_trans);
3741  }
3742 
3743  if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3744  if(aha152x1[0]!=0) {
3745  setup[setup_count].conf = "";
3746  setup[setup_count].io_port = aha152x1[0];
3747  setup[setup_count].irq = aha152x1[1];
3748  setup[setup_count].scsiid = aha152x1[2];
3749  setup[setup_count].reconnect = aha152x1[3];
3750  setup[setup_count].parity = aha152x1[4];
3751  setup[setup_count].synchronous = aha152x1[5];
3752  setup[setup_count].delay = aha152x1[6];
3753  setup[setup_count].ext_trans = aha152x1[7];
3754 #if defined(AHA152X_DEBUG)
3755  setup[setup_count].debug = aha152x1[8];
3756 #endif
3757  } else if(io[1]!=0 || irq[1]!=0) {
3758  if(io[1]!=0) setup[setup_count].io_port = io[1];
3759  if(irq[1]!=0) setup[setup_count].irq = irq[1];
3760 
3761  setup[setup_count].scsiid = scsiid[1];
3762  setup[setup_count].reconnect = reconnect[1];
3763  setup[setup_count].parity = parity[1];
3764  setup[setup_count].synchronous = sync[1];
3765  setup[setup_count].delay = delay[1];
3766  setup[setup_count].ext_trans = exttrans[1];
3767 #if defined(AHA152X_DEBUG)
3768  setup[setup_count].debug = debug[1];
3769 #endif
3770  }
3771  if (checksetup(&setup[setup_count]))
3772  setup_count++;
3773  else
3774  printk(KERN_ERR "aha152x: invalid module params io=0x%x, irq=%d,scsiid=%d,reconnect=%d,parity=%d,sync=%d,delay=%d,exttrans=%d\n",
3775  setup[setup_count].io_port,
3776  setup[setup_count].irq,
3777  setup[setup_count].scsiid,
3778  setup[setup_count].reconnect,
3779  setup[setup_count].parity,
3780  setup[setup_count].synchronous,
3781  setup[setup_count].delay,
3782  setup[setup_count].ext_trans);
3783  }
3784 #endif
3785 
3786 #ifdef __ISAPNP__
3787  for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3788  while ( setup_count<ARRAY_SIZE(setup) &&
3789  (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3790  if (pnp_device_attach(dev) < 0)
3791  continue;
3792 
3793  if (pnp_activate_dev(dev) < 0) {
3794  pnp_device_detach(dev);
3795  continue;
3796  }
3797 
3798  if (!pnp_port_valid(dev, 0)) {
3799  pnp_device_detach(dev);
3800  continue;
3801  }
3802 
3803  if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3804  pnp_device_detach(dev);
3805  continue;
3806  }
3807 
3808  setup[setup_count].io_port = pnp_port_start(dev, 0);
3809  setup[setup_count].irq = pnp_irq(dev, 0);
3810  setup[setup_count].scsiid = 7;
3811  setup[setup_count].reconnect = 1;
3812  setup[setup_count].parity = 1;
3813  setup[setup_count].synchronous = 1;
3814  setup[setup_count].delay = DELAY_DEFAULT;
3815  setup[setup_count].ext_trans = 0;
3816 #if defined(AHA152X_DEBUG)
3817  setup[setup_count].debug = DEBUG_DEFAULT;
3818 #endif
3819 #if defined(__ISAPNP__)
3820  pnpdev[setup_count] = dev;
3821 #endif
3822  printk (KERN_INFO
3823  "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3824  setup[setup_count].io_port, setup[setup_count].irq);
3825  setup_count++;
3826  }
3827  }
3828 #endif
3829 
3830 #if defined(AUTOCONF)
3831  if (setup_count<ARRAY_SIZE(setup)) {
3832 #if !defined(SKIP_BIOSTEST)
3833  ok = 0;
3834  for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3835  void __iomem *p = ioremap(addresses[i], 0x4000);
3836  if (!p)
3837  continue;
3838  for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3839  ok = check_signature(p + signatures[j].sig_offset,
3840  signatures[j].signature, signatures[j].sig_length);
3841  iounmap(p);
3842  }
3843  if (!ok && setup_count == 0)
3844  return -ENODEV;
3845 
3846  printk(KERN_INFO "aha152x: BIOS test: passed, ");
3847 #else
3848  printk(KERN_INFO "aha152x: ");
3849 #endif /* !SKIP_BIOSTEST */
3850 
3851  ok = 0;
3852  for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3853  if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3854  continue;
3855 
3856  if (!request_region(ports[i], IO_RANGE, "aha152x")) {
3857  printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3858  continue;
3859  }
3860 
3861  if (aha152x_porttest(ports[i])) {
3862  setup[setup_count].tc1550 = 0;
3863 
3864  conf.cf_port =
3865  (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3866  } else if (tc1550_porttest(ports[i])) {
3867  setup[setup_count].tc1550 = 1;
3868 
3869  conf.cf_port =
3870  (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3871  } else {
3872  release_region(ports[i], IO_RANGE);
3873  continue;
3874  }
3875 
3876  release_region(ports[i], IO_RANGE);
3877 
3878  ok++;
3879  setup[setup_count].io_port = ports[i];
3880  setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3881  setup[setup_count].scsiid = conf.cf_id;
3882  setup[setup_count].reconnect = conf.cf_tardisc;
3883  setup[setup_count].parity = !conf.cf_parity;
3884  setup[setup_count].synchronous = conf.cf_syncneg;
3885  setup[setup_count].delay = DELAY_DEFAULT;
3886  setup[setup_count].ext_trans = 0;
3887 #if defined(AHA152X_DEBUG)
3888  setup[setup_count].debug = DEBUG_DEFAULT;
3889 #endif
3890  setup_count++;
3891 
3892  }
3893 
3894  if (ok)
3895  printk("auto configuration: ok, ");
3896  }
3897 #endif
3898 
3899  printk("%d controller(s) configured\n", setup_count);
3900 
3901  for (i=0; i<setup_count; i++) {
3902  if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3903  struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3904 
3905  if( !shpnt ) {
3906  release_region(setup[i].io_port, IO_RANGE);
3907 #if defined(__ISAPNP__)
3908  } else if( pnpdev[i] ) {
3909  HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3910  pnpdev[i]=NULL;
3911 #endif
3912  }
3913  } else {
3914  printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3915  }
3916 
3917 #if defined(__ISAPNP__)
3918  if( pnpdev[i] )
3919  pnp_device_detach(pnpdev[i]);
3920 #endif
3921  }
3922 
3923  return 0;
3924 }
3925 
3926 static void __exit aha152x_exit(void)
3927 {
3928  struct aha152x_hostdata *hd, *tmp;
3929 
3930  list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
3931  struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3932 
3933  aha152x_release(shost);
3934  }
3935 }
3936 
3937 module_init(aha152x_init);
3938 module_exit(aha152x_exit);
3939 
3940 #if !defined(MODULE)
3941 static int __init aha152x_setup(char *str)
3942 {
3943 #if defined(AHA152X_DEBUG)
3944  int ints[11];
3945 #else
3946  int ints[10];
3947 #endif
3948  get_options(str, ARRAY_SIZE(ints), ints);
3949 
3950  if(setup_count>=ARRAY_SIZE(setup)) {
3951  printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3952  return 1;
3953  }
3954 
3955  setup[setup_count].conf = str;
3956  setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340;
3957  setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11;
3958  setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7;
3959  setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1;
3960  setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1;
3961  setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3962  setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3963  setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0;
3964 #if defined(AHA152X_DEBUG)
3965  setup[setup_count].debug = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
3966  if (ints[0] > 9) {
3967  printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3968  "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
3969 #else
3970  if (ints[0] > 8) { /*}*/
3971  printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3972  "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3973 #endif
3974  } else {
3975  setup_count++;
3976  return 0;
3977  }
3978 
3979  return 1;
3980 }
3981 __setup("aha152x=", aha152x_setup);
3982 #endif
3983 
3984 #endif /* !PCMCIA */
Generated on Thu Jan 10 2013 14:18:50 for Linux Kernel by   doxygen 1.8.2