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