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