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