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