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