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