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