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