blob: e31c460a1335527e74816945dcb6ac9e35b6125b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* aha152x.c -- Adaptec AHA-152x driver
Jan Engelhardt96de0e22007-10-19 23:21:04 +02002 * Author: Jürgen E. Fischer, fischer@norbit.de
3 * Copyright 1993-2004 Jürgen E. Fischer
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2, or (at your option) any
8 * later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 *
16 * $Id: aha152x.c,v 2.7 2004/01/24 11:42:59 fischer Exp $
17 *
18 * $Log: aha152x.c,v $
19 * Revision 2.7 2004/01/24 11:42:59 fischer
20 * - gather code that is not used by PCMCIA at the end
21 * - move request_region for !PCMCIA case to detection
22 * - migration to new scsi host api (remove legacy code)
23 * - free host scribble before scsi_done
24 * - fix error handling
25 * - one isapnp device added to id_table
26 *
27 * Revision 2.6 2003/10/30 20:52:47 fischer
28 * - interfaces changes for kernel 2.6
29 * - aha152x_probe_one introduced for pcmcia stub
30 * - fixed pnpdev handling
31 * - instead of allocation a new one, reuse command for request sense after check condition and reset
32 * - fixes race in is_complete
33 *
34 * Revision 2.5 2002/04/14 11:24:53 fischer
35 * - isapnp support
36 * - abort fixed
37 * - 2.5 support
38 *
39 * Revision 2.4 2000/12/16 12:53:56 fischer
40 * - allow REQUEST SENSE to be queued
41 * - handle shared PCI interrupts
42 *
43 * Revision 2.3 2000/11/04 16:40:26 fischer
44 * - handle data overruns
45 * - extend timeout for data phases
46 *
47 * Revision 2.2 2000/08/08 19:54:53 fischer
48 * - minor changes
49 *
50 * Revision 2.1 2000/05/17 16:23:17 fischer
51 * - signature update
52 * - fix for data out w/o scatter gather
53 *
54 * Revision 2.0 1999/12/25 15:07:32 fischer
55 * - interrupt routine completly reworked
56 * - basic support for new eh code
57 *
58 * Revision 1.21 1999/11/10 23:46:36 fischer
59 * - default to synchronous operation
60 * - synchronous negotiation fixed
61 * - added timeout to loops
62 * - debugging output can be controlled through procfs
63 *
64 * Revision 1.20 1999/11/07 18:37:31 fischer
65 * - synchronous operation works
66 * - resid support for sg driver
67 *
68 * Revision 1.19 1999/11/02 22:39:59 fischer
69 * - moved leading comments to README.aha152x
70 * - new additional module parameters
71 * - updates for 2.3
72 * - support for the Tripace TC1550 controller
73 * - interrupt handling changed
74 *
75 * Revision 1.18 1996/09/07 20:10:40 fischer
76 * - fixed can_queue handling (multiple outstanding commands working again)
77 *
78 * Revision 1.17 1996/08/17 16:05:14 fischer
79 * - biosparam improved
80 * - interrupt verification
81 * - updated documentation
82 * - cleanups
83 *
84 * Revision 1.16 1996/06/09 00:04:56 root
85 * - added configuration symbols for insmod (aha152x/aha152x1)
86 *
87 * Revision 1.15 1996/04/30 14:52:06 fischer
88 * - proc info fixed
89 * - support for extended translation for >1GB disks
90 *
91 * Revision 1.14 1996/01/17 15:11:20 fischer
92 * - fixed lockup in MESSAGE IN phase after reconnection
93 *
94 * Revision 1.13 1996/01/09 02:15:53 fischer
95 * - some cleanups
96 * - moved request_irq behind controller initialization
97 * (to avoid spurious interrupts)
98 *
99 * Revision 1.12 1995/12/16 12:26:07 fischer
100 * - barrier()s added
101 * - configurable RESET delay added
102 *
103 * Revision 1.11 1995/12/06 21:18:35 fischer
104 * - some minor updates
105 *
106 * Revision 1.10 1995/07/22 19:18:45 fischer
107 * - support for 2 controllers
108 * - started synchronous data transfers (not working yet)
109 *
110 * Revision 1.9 1995/03/18 09:20:24 root
111 * - patches for PCMCIA and modules
112 *
113 * Revision 1.8 1995/01/21 22:07:19 root
114 * - snarf_region => request_region
115 * - aha152x_intr interface change
116 *
117 * Revision 1.7 1995/01/02 23:19:36 root
118 * - updated COMMAND_SIZE to cmd_len
119 * - changed sti() to restore_flags()
120 * - fixed some #ifdef which generated warnings
121 *
122 * Revision 1.6 1994/11/24 20:35:27 root
123 * - problem with odd number of bytes in fifo fixed
124 *
125 * Revision 1.5 1994/10/30 14:39:56 root
126 * - abort code fixed
127 * - debugging improved
128 *
129 * Revision 1.4 1994/09/12 11:33:01 root
130 * - irqaction to request_irq
131 * - abortion updated
132 *
133 * Revision 1.3 1994/08/04 13:53:05 root
134 * - updates for mid-level-driver changes
135 * - accept unexpected BUSFREE phase as error condition
136 * - parity check now configurable
137 *
138 * Revision 1.2 1994/07/03 12:56:36 root
139 * - cleaned up debugging code
140 * - more tweaking on reset delays
141 * - updated abort/reset code (pretty untested...)
142 *
143 * Revision 1.1 1994/05/28 21:18:49 root
144 * - update for mid-level interface change (abort-reset)
145 * - delays after resets adjusted for some slow devices
146 *
147 * Revision 1.0 1994/03/25 12:52:00 root
148 * - Fixed "more data than expected" problem
149 * - added new BIOS signatures
150 *
151 * Revision 0.102 1994/01/31 20:44:12 root
152 * - minor changes in insw/outsw handling
153 *
154 * Revision 0.101 1993/12/13 01:16:27 root
155 * - fixed STATUS phase (non-GOOD stati were dropped sometimes;
156 * fixes problems with CD-ROM sector size detection & media change)
157 *
158 * Revision 0.100 1993/12/10 16:58:47 root
159 * - fix for unsuccessful selections in case of non-continuous id assignments
160 * on the scsi bus.
161 *
162 * Revision 0.99 1993/10/24 16:19:59 root
163 * - fixed DATA IN (rare read errors gone)
164 *
165 * Revision 0.98 1993/10/17 12:54:44 root
166 * - fixed some recent fixes (shame on me)
167 * - moved initialization of scratch area to aha152x_queue
168 *
169 * Revision 0.97 1993/10/09 18:53:53 root
170 * - DATA IN fixed. Rarely left data in the fifo.
171 *
172 * Revision 0.96 1993/10/03 00:53:59 root
173 * - minor changes on DATA IN
174 *
175 * Revision 0.95 1993/09/24 10:36:01 root
176 * - change handling of MSGI after reselection
177 * - fixed sti/cli
178 * - minor changes
179 *
180 * Revision 0.94 1993/09/18 14:08:22 root
181 * - fixed bug in multiple outstanding command code
182 * - changed detection
183 * - support for kernel command line configuration
184 * - reset corrected
185 * - changed message handling
186 *
187 * Revision 0.93 1993/09/15 20:41:19 root
188 * - fixed bugs with multiple outstanding commands
189 *
190 * Revision 0.92 1993/09/13 02:46:33 root
191 * - multiple outstanding commands work (no problems with IBM drive)
192 *
193 * Revision 0.91 1993/09/12 20:51:46 root
194 * added multiple outstanding commands
195 * (some problem with this $%&? IBM device remain)
196 *
197 * Revision 0.9 1993/09/12 11:11:22 root
198 * - corrected auto-configuration
199 * - changed the auto-configuration (added some '#define's)
200 * - added support for dis-/reconnection
201 *
202 * Revision 0.8 1993/09/06 23:09:39 root
203 * - added support for the drive activity light
204 * - minor changes
205 *
206 * Revision 0.7 1993/09/05 14:30:15 root
207 * - improved phase detection
208 * - now using the new snarf_region code of 0.99pl13
209 *
210 * Revision 0.6 1993/09/02 11:01:38 root
211 * first public release; added some signatures and biosparam()
212 *
213 * Revision 0.5 1993/08/30 10:23:30 root
214 * fixed timing problems with my IBM drive
215 *
216 * Revision 0.4 1993/08/29 14:06:52 root
217 * fixed some problems with timeouts due incomplete commands
218 *
219 * Revision 0.3 1993/08/28 15:55:03 root
220 * writing data works too. mounted and worked on a dos partition
221 *
222 * Revision 0.2 1993/08/27 22:42:07 root
223 * reading data works. Mounted a msdos partition.
224 *
225 * Revision 0.1 1993/08/25 13:38:30 root
226 * first "damn thing doesn't work" version
227 *
228 * Revision 0.0 1993/08/14 19:54:25 root
229 * empty function bodies; detect() works.
230 *
231 *
232 **************************************************************************
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200233
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 see Documentation/scsi/aha152x.txt for configuration details
235
236 **************************************************************************/
237
238#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239#include <asm/irq.h>
Matthew Wilcox53d5ed62006-10-11 01:22:01 -0700240#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241#include <linux/blkdev.h>
Christoph Hellwig0f06bb32007-05-13 17:52:12 +0200242#include <linux/completion.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243#include <linux/errno.h>
244#include <linux/string.h>
245#include <linux/wait.h>
246#include <linux/ioport.h>
247#include <linux/delay.h>
248#include <linux/proc_fs.h>
249#include <linux/interrupt.h>
250#include <linux/init.h>
251#include <linux/kernel.h>
252#include <linux/isapnp.h>
253#include <linux/spinlock.h>
254#include <linux/workqueue.h>
James Bottomley5fcda422006-09-14 17:04:58 -0500255#include <linux/list.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +0900256#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257#include <scsi/scsicam.h>
258
259#include "scsi.h"
db9dff32005-04-03 14:53:59 -0500260#include <scsi/scsi_dbg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261#include <scsi/scsi_host.h>
Matthew Wilcox1abfd372005-12-15 16:22:01 -0500262#include <scsi/scsi_transport_spi.h>
Boaz Harrosh73d2cb12007-11-01 18:54:44 +0200263#include <scsi/scsi_eh.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264#include "aha152x.h"
265
James Bottomley5fcda422006-09-14 17:04:58 -0500266static LIST_HEAD(aha152x_host_list);
267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
269/* DEFINES */
270
271/* For PCMCIA cards, always use AUTOCONF */
272#if defined(PCMCIA) || defined(MODULE)
273#if !defined(AUTOCONF)
274#define AUTOCONF
275#endif
276#endif
277
278#if !defined(AUTOCONF) && !defined(SETUP0)
279#error define AUTOCONF or SETUP0
280#endif
281
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282#define DO_LOCK(flags) spin_lock_irqsave(&QLOCK,flags)
283#define DO_UNLOCK(flags) spin_unlock_irqrestore(&QLOCK,flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
285#define LEAD "(scsi%d:%d:%d) "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286#define INFO_LEAD KERN_INFO LEAD
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287#define CMDINFO(cmd) \
288 (cmd) ? ((cmd)->device->host->host_no) : -1, \
289 (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
Hannes Reinecke9cb78c12014-06-25 15:27:36 +0200290 (cmd) ? ((u8)(cmd)->device->lun & 0x07) : -1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
Boaz Harrosh23385452007-07-29 22:29:02 +0300292static inline void
293CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
294{
295 scsi_set_resid(cmd, scsi_get_resid(cmd) + inc);
296}
297
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298#define DELAY_DEFAULT 1000
299
300#if defined(PCMCIA)
301#define IRQ_MIN 0
302#define IRQ_MAX 16
303#else
304#define IRQ_MIN 9
305#if defined(__PPC)
Yinghai Lu171ac6a2008-08-19 20:49:54 -0700306#define IRQ_MAX (nr_irqs-1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307#else
308#define IRQ_MAX 12
309#endif
310#endif
311
312enum {
313 not_issued = 0x0001, /* command not yet issued */
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200314 selecting = 0x0002, /* target is being selected */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 identified = 0x0004, /* IDENTIFY was sent */
316 disconnected = 0x0008, /* target disconnected */
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200317 completed = 0x0010, /* target sent COMMAND COMPLETE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 aborted = 0x0020, /* ABORT was sent */
319 resetted = 0x0040, /* BUS DEVICE RESET was sent */
320 spiordy = 0x0080, /* waiting for SPIORDY to raise */
321 syncneg = 0x0100, /* synchronous negotiation in progress */
322 aborting = 0x0200, /* ABORT is pending */
323 resetting = 0x0400, /* BUS DEVICE RESET is pending */
324 check_condition = 0x0800, /* requesting sense after CHECK CONDITION */
325};
326
Jan Engelhardt96de0e22007-10-19 23:21:04 +0200327MODULE_AUTHOR("Jürgen Fischer");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328MODULE_DESCRIPTION(AHA152X_REVID);
329MODULE_LICENSE("GPL");
330
331#if !defined(PCMCIA)
332#if defined(MODULE)
333static int io[] = {0, 0};
334module_param_array(io, int, NULL, 0);
335MODULE_PARM_DESC(io,"base io address of controller");
336
337static int irq[] = {0, 0};
338module_param_array(irq, int, NULL, 0);
339MODULE_PARM_DESC(irq,"interrupt for controller");
340
341static int scsiid[] = {7, 7};
342module_param_array(scsiid, int, NULL, 0);
343MODULE_PARM_DESC(scsiid,"scsi id of controller");
344
345static int reconnect[] = {1, 1};
346module_param_array(reconnect, int, NULL, 0);
347MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
348
349static int parity[] = {1, 1};
350module_param_array(parity, int, NULL, 0);
351MODULE_PARM_DESC(parity,"use scsi parity");
352
353static int sync[] = {1, 1};
354module_param_array(sync, int, NULL, 0);
355MODULE_PARM_DESC(sync,"use synchronous transfers");
356
357static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
358module_param_array(delay, int, NULL, 0);
359MODULE_PARM_DESC(delay,"scsi reset delay");
360
361static int exttrans[] = {0, 0};
362module_param_array(exttrans, int, NULL, 0);
363MODULE_PARM_DESC(exttrans,"use extended translation");
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
366module_param_array(aha152x, int, NULL, 0);
367MODULE_PARM_DESC(aha152x, "parameters for first controller");
368
369static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
370module_param_array(aha152x1, int, NULL, 0);
371MODULE_PARM_DESC(aha152x1, "parameters for second controller");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372#endif /* MODULE */
373
374#ifdef __ISAPNP__
Greg Kroah-Hartman6f039792012-12-21 13:08:55 -0800375static struct isapnp_device_id id_table[] = {
Ondrej Zary50f87f92011-06-09 21:21:23 +0200376 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1502), 0 },
377 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1505), 0 },
378 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1510), 0 },
379 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1515), 0 },
380 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1520), 0 },
381 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2015), 0 },
382 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1522), 0 },
383 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2215), 0 },
384 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1530), 0 },
385 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3015), 0 },
386 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1532), 0 },
387 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3215), 0 },
388 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x6360), 0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 { ISAPNP_DEVICE_SINGLE_END, }
390};
391MODULE_DEVICE_TABLE(isapnp, id_table);
392#endif /* ISAPNP */
393
394#endif /* !PCMCIA */
395
Christoph Hellwigd0be4a7d2005-10-31 18:31:40 +0100396static struct scsi_host_template aha152x_driver_template;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
398/*
399 * internal states of the host
400 *
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200401 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402enum aha152x_state {
403 idle=0,
404 unknown,
405 seldo,
406 seldi,
407 selto,
408 busfree,
409 msgo,
410 cmd,
411 msgi,
412 status,
413 datai,
414 datao,
415 parerr,
416 rsti,
417 maxstate
418};
419
420/*
421 * current state information of the host
422 *
423 */
424struct aha152x_hostdata {
425 Scsi_Cmnd *issue_SC;
426 /* pending commands to issue */
427
428 Scsi_Cmnd *current_SC;
429 /* current command on the bus */
430
431 Scsi_Cmnd *disconnected_SC;
432 /* commands that disconnected */
433
434 Scsi_Cmnd *done_SC;
435 /* command that was completed */
436
437 spinlock_t lock;
438 /* host lock */
439
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440#if defined(AHA152X_STAT)
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200441 int total_commands;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 int disconnections;
443 int busfree_without_any_action;
444 int busfree_without_old_command;
445 int busfree_without_new_command;
446 int busfree_without_done_command;
447 int busfree_with_check_condition;
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200448 int count[maxstate];
449 int count_trans[maxstate];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 unsigned long time[maxstate];
451#endif
452
453 int commands; /* current number of commands */
454
455 int reconnect; /* disconnection allowed */
456 int parity; /* parity checking enabled */
457 int synchronous; /* synchronous transferes enabled */
458 int delay; /* reset out delay */
459 int ext_trans; /* extended translation enabled */
460
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200461 int swint; /* software-interrupt was fired during detect() */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 int service; /* bh needs to be run */
463 int in_intr; /* bh is running */
464
465 /* current state,
466 previous state,
467 last state different from current state */
468 enum aha152x_state state, prevstate, laststate;
469
470 int target;
471 /* reconnecting target */
472
473 unsigned char syncrate[8];
474 /* current synchronous transfer agreements */
475
476 unsigned char syncneg[8];
477 /* 0: no negotiation;
478 * 1: negotiation in progress;
479 * 2: negotiation completed
480 */
481
482 int cmd_i;
483 /* number of sent bytes of current command */
484
485 int msgi_len;
486 /* number of received message bytes */
487 unsigned char msgi[256];
488 /* received message bytes */
489
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200490 int msgo_i, msgo_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 /* number of sent bytes and length of current messages */
492 unsigned char msgo[256];
493 /* pending messages */
494
495 int data_len;
496 /* number of sent/received bytes in dataphase */
497
498 unsigned long io_port0;
499 unsigned long io_port1;
500
501#ifdef __ISAPNP__
502 struct pnp_dev *pnpdev;
503#endif
James Bottomley5fcda422006-09-14 17:04:58 -0500504 struct list_head host_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505};
506
507
508/*
509 * host specific command extension
510 *
511 */
512struct aha152x_scdata {
513 Scsi_Cmnd *next; /* next sc in queue */
Christoph Hellwig0f06bb32007-05-13 17:52:12 +0200514 struct completion *done;/* semaphore to block on */
Boaz Harrosh73d2cb12007-11-01 18:54:44 +0200515 struct scsi_eh_save ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516};
517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518/* access macros for hostdata */
519
520#define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata)
521
522#define HOSTNO ((shpnt)->host_no)
523
524#define CURRENT_SC (HOSTDATA(shpnt)->current_SC)
525#define DONE_SC (HOSTDATA(shpnt)->done_SC)
526#define ISSUE_SC (HOSTDATA(shpnt)->issue_SC)
527#define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC)
528#define QLOCK (HOSTDATA(shpnt)->lock)
529#define QLOCKER (HOSTDATA(shpnt)->locker)
530#define QLOCKERL (HOSTDATA(shpnt)->lockerl)
531
532#define STATE (HOSTDATA(shpnt)->state)
533#define PREVSTATE (HOSTDATA(shpnt)->prevstate)
534#define LASTSTATE (HOSTDATA(shpnt)->laststate)
535
536#define RECONN_TARGET (HOSTDATA(shpnt)->target)
537
538#define CMD_I (HOSTDATA(shpnt)->cmd_i)
539
540#define MSGO(i) (HOSTDATA(shpnt)->msgo[i])
541#define MSGO_I (HOSTDATA(shpnt)->msgo_i)
542#define MSGOLEN (HOSTDATA(shpnt)->msgo_len)
543#define ADDMSGO(x) (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
544
545#define MSGI(i) (HOSTDATA(shpnt)->msgi[i])
546#define MSGILEN (HOSTDATA(shpnt)->msgi_len)
547#define ADDMSGI(x) (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
548
549#define DATA_LEN (HOSTDATA(shpnt)->data_len)
550
551#define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
552#define SYNCNEG (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
553
554#define DELAY (HOSTDATA(shpnt)->delay)
555#define EXT_TRANS (HOSTDATA(shpnt)->ext_trans)
556#define TC1550 (HOSTDATA(shpnt)->tc1550)
557#define RECONNECT (HOSTDATA(shpnt)->reconnect)
558#define PARITY (HOSTDATA(shpnt)->parity)
559#define SYNCHRONOUS (HOSTDATA(shpnt)->synchronous)
560
561#define HOSTIOPORT0 (HOSTDATA(shpnt)->io_port0)
562#define HOSTIOPORT1 (HOSTDATA(shpnt)->io_port1)
563
564#define SCDATA(SCpnt) ((struct aha152x_scdata *) (SCpnt)->host_scribble)
565#define SCNEXT(SCpnt) SCDATA(SCpnt)->next
Christoph Hellwig0f06bb32007-05-13 17:52:12 +0200566#define SCSEM(SCpnt) SCDATA(SCpnt)->done
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
Jens Axboe45711f12007-10-22 21:19:53 +0200568#define SG_ADDRESS(buffer) ((char *) sg_virt((buffer)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570/* state handling */
571static void seldi_run(struct Scsi_Host *shpnt);
572static void seldo_run(struct Scsi_Host *shpnt);
573static void selto_run(struct Scsi_Host *shpnt);
574static void busfree_run(struct Scsi_Host *shpnt);
575
576static void msgo_init(struct Scsi_Host *shpnt);
577static void msgo_run(struct Scsi_Host *shpnt);
578static void msgo_end(struct Scsi_Host *shpnt);
579
580static void cmd_init(struct Scsi_Host *shpnt);
581static void cmd_run(struct Scsi_Host *shpnt);
582static void cmd_end(struct Scsi_Host *shpnt);
583
584static void datai_init(struct Scsi_Host *shpnt);
585static void datai_run(struct Scsi_Host *shpnt);
586static void datai_end(struct Scsi_Host *shpnt);
587
588static void datao_init(struct Scsi_Host *shpnt);
589static void datao_run(struct Scsi_Host *shpnt);
590static void datao_end(struct Scsi_Host *shpnt);
591
592static void status_run(struct Scsi_Host *shpnt);
593
594static void msgi_run(struct Scsi_Host *shpnt);
595static void msgi_end(struct Scsi_Host *shpnt);
596
597static void parerr_run(struct Scsi_Host *shpnt);
598static void rsti_run(struct Scsi_Host *shpnt);
599
600static void is_complete(struct Scsi_Host *shpnt);
601
602/*
603 * driver states
604 *
605 */
606static struct {
607 char *name;
608 void (*init)(struct Scsi_Host *);
609 void (*run)(struct Scsi_Host *);
610 void (*end)(struct Scsi_Host *);
611 int spio;
612} states[] = {
613 { "idle", NULL, NULL, NULL, 0},
614 { "unknown", NULL, NULL, NULL, 0},
615 { "seldo", NULL, seldo_run, NULL, 0},
616 { "seldi", NULL, seldi_run, NULL, 0},
617 { "selto", NULL, selto_run, NULL, 0},
618 { "busfree", NULL, busfree_run, NULL, 0},
619 { "msgo", msgo_init, msgo_run, msgo_end, 1},
620 { "cmd", cmd_init, cmd_run, cmd_end, 1},
621 { "msgi", NULL, msgi_run, msgi_end, 1},
622 { "status", NULL, status_run, NULL, 1},
623 { "datai", datai_init, datai_run, datai_end, 0},
624 { "datao", datao_init, datao_run, datao_end, 0},
625 { "parerr", NULL, parerr_run, NULL, 0},
626 { "rsti", NULL, rsti_run, NULL, 0},
627};
628
629/* setup & interrupt */
David Howells7d12e782006-10-05 14:55:46 +0100630static irqreturn_t intr(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631static void reset_ports(struct Scsi_Host *shpnt);
632static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
633static void done(struct Scsi_Host *shpnt, int error);
634
635/* diagnostics */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636static void show_command(Scsi_Cmnd * ptr);
637static void show_queues(struct Scsi_Host *shpnt);
638static void disp_enintr(struct Scsi_Host *shpnt);
639
640
641/*
642 * queue services:
643 *
644 */
645static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
646{
647 Scsi_Cmnd *end;
648
649 SCNEXT(new_SC) = NULL;
650 if (!*SC)
651 *SC = new_SC;
652 else {
653 for (end = *SC; SCNEXT(end); end = SCNEXT(end))
654 ;
655 SCNEXT(end) = new_SC;
656 }
657}
658
659static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC)
660{
661 Scsi_Cmnd *ptr;
662
663 ptr = *SC;
664 if (ptr) {
665 *SC = SCNEXT(*SC);
666 SCNEXT(ptr)=NULL;
667 }
668 return ptr;
669}
670
671static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun)
672{
673 Scsi_Cmnd *ptr, *prev;
674
675 for (ptr = *SC, prev = NULL;
676 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
677 prev = ptr, ptr = SCNEXT(ptr))
678 ;
679
680 if (ptr) {
681 if (prev)
682 SCNEXT(prev) = SCNEXT(ptr);
683 else
684 *SC = SCNEXT(ptr);
685
686 SCNEXT(ptr)=NULL;
687 }
688
689 return ptr;
690}
691
692static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp)
693{
694 Scsi_Cmnd *ptr, *prev;
695
696 for (ptr = *SC, prev = NULL;
697 ptr && SCp!=ptr;
698 prev = ptr, ptr = SCNEXT(ptr))
699 ;
700
701 if (ptr) {
702 if (prev)
703 SCNEXT(prev) = SCNEXT(ptr);
704 else
705 *SC = SCNEXT(ptr);
706
707 SCNEXT(ptr)=NULL;
708 }
709
710 return ptr;
711}
712
David Howells7d12e782006-10-05 14:55:46 +0100713static irqreturn_t swintr(int irqno, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
Jeff Garzikc7bec5a2006-10-06 15:00:58 -0400715 struct Scsi_Host *shpnt = dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
717 HOSTDATA(shpnt)->swint++;
718
719 SETPORT(DMACNTRL0, INTEN);
720 return IRQ_HANDLED;
721}
722
723struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
724{
725 struct Scsi_Host *shpnt;
726
727 shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
728 if (!shpnt) {
729 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
730 return NULL;
731 }
732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
James Bottomley5fcda422006-09-14 17:04:58 -0500734 INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
735
736 /* need to have host registered before triggering any interrupt */
737 list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
739 shpnt->io_port = setup->io_port;
740 shpnt->n_io_port = IO_RANGE;
741 shpnt->irq = setup->irq;
742
743 if (!setup->tc1550) {
744 HOSTIOPORT0 = setup->io_port;
745 HOSTIOPORT1 = setup->io_port;
746 } else {
747 HOSTIOPORT0 = setup->io_port+0x10;
748 HOSTIOPORT1 = setup->io_port-0x10;
749 }
750
751 spin_lock_init(&QLOCK);
752 RECONNECT = setup->reconnect;
753 SYNCHRONOUS = setup->synchronous;
754 PARITY = setup->parity;
755 DELAY = setup->delay;
756 EXT_TRANS = setup->ext_trans;
757
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 SETPORT(SCSIID, setup->scsiid << 4);
759 shpnt->this_id = setup->scsiid;
760
761 if (setup->reconnect)
762 shpnt->can_queue = AHA152X_MAXQUEUE;
763
764 /* RESET OUT */
765 printk("aha152x: resetting bus...\n");
766 SETPORT(SCSISEQ, SCSIRSTO);
767 mdelay(256);
768 SETPORT(SCSISEQ, 0);
769 mdelay(DELAY);
770
771 reset_ports(shpnt);
772
773 printk(KERN_INFO
774 "aha152x%d%s: "
775 "vital data: rev=%x, "
776 "io=0x%03lx (0x%03lx/0x%03lx), "
777 "irq=%d, "
778 "scsiid=%d, "
779 "reconnect=%s, "
780 "parity=%s, "
781 "synchronous=%s, "
782 "delay=%d, "
783 "extended translation=%s\n",
784 shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
785 GETPORT(REV) & 0x7,
786 shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
787 shpnt->irq,
788 shpnt->this_id,
789 RECONNECT ? "enabled" : "disabled",
790 PARITY ? "enabled" : "disabled",
791 SYNCHRONOUS ? "enabled" : "disabled",
792 DELAY,
793 EXT_TRANS ? "enabled" : "disabled");
794
795 /* not expecting any interrupts */
796 SETPORT(SIMODE0, 0);
797 SETPORT(SIMODE1, 0);
798
Michael Opdenacker4909cc22014-03-05 06:09:41 +0100799 if (request_irq(shpnt->irq, swintr, IRQF_SHARED, "aha152x", shpnt)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
801 goto out_host_put;
802 }
803
804 HOSTDATA(shpnt)->swint = 0;
805
806 printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
807
808 mb();
809 SETPORT(DMACNTRL0, SWINT|INTEN);
810 mdelay(1000);
811 free_irq(shpnt->irq, shpnt);
812
813 if (!HOSTDATA(shpnt)->swint) {
814 if (TESTHI(DMASTAT, INTSTAT)) {
815 printk("lost.\n");
816 } else {
817 printk("failed.\n");
818 }
819
820 SETPORT(DMACNTRL0, INTEN);
821
822 printk(KERN_ERR "aha152x%d: irq %d possibly wrong. "
823 "Please verify.\n", shpnt->host_no, shpnt->irq);
824 goto out_host_put;
825 }
826 printk("ok.\n");
827
828
829 /* clear interrupts */
830 SETPORT(SSTAT0, 0x7f);
831 SETPORT(SSTAT1, 0xef);
832
Michael Opdenacker4909cc22014-03-05 06:09:41 +0100833 if (request_irq(shpnt->irq, intr, IRQF_SHARED, "aha152x", shpnt)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
835 goto out_host_put;
836 }
837
838 if( scsi_add_host(shpnt, NULL) ) {
839 free_irq(shpnt->irq, shpnt);
840 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
841 goto out_host_put;
842 }
843
844 scsi_scan_host(shpnt);
845
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 return shpnt;
847
848out_host_put:
James Bottomley5fcda422006-09-14 17:04:58 -0500849 list_del(&HOSTDATA(shpnt)->host_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 scsi_host_put(shpnt);
851
852 return NULL;
853}
854
855void aha152x_release(struct Scsi_Host *shpnt)
856{
Matthew Wilcox1bd40572007-08-15 12:56:57 -0600857 if (!shpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 return;
859
Matthew Wilcox1bd40572007-08-15 12:56:57 -0600860 scsi_remove_host(shpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 if (shpnt->irq)
862 free_irq(shpnt->irq, shpnt);
863
864#if !defined(PCMCIA)
865 if (shpnt->io_port)
866 release_region(shpnt->io_port, IO_RANGE);
867#endif
868
869#ifdef __ISAPNP__
870 if (HOSTDATA(shpnt)->pnpdev)
871 pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
872#endif
873
James Bottomley5fcda422006-09-14 17:04:58 -0500874 list_del(&HOSTDATA(shpnt)->host_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 scsi_host_put(shpnt);
876}
877
878
879/*
880 * setup controller to generate interrupts depending
881 * on current state (lock has to be acquired)
882 *
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200883 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884static int setup_expected_interrupts(struct Scsi_Host *shpnt)
885{
886 if(CURRENT_SC) {
887 CURRENT_SC->SCp.phase |= 1 << 16;
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200888
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 if(CURRENT_SC->SCp.phase & selecting) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 SETPORT(SSTAT1, SELTO);
891 SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
892 SETPORT(SIMODE1, ENSELTIMO);
893 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200895 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 }
897 } else if(STATE==seldi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 SETPORT(SIMODE0, 0);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200899 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
902 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
903 }
904
905 if(!HOSTDATA(shpnt)->in_intr)
906 SETBITS(DMACNTRL0, INTEN);
907
908 return TESTHI(DMASTAT, INTSTAT);
909}
910
911
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200912/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 * Queue a command and setup interrupts for a free bus.
914 */
Christoph Hellwig0f06bb32007-05-13 17:52:12 +0200915static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
916 int phase, void (*done)(Scsi_Cmnd *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917{
918 struct Scsi_Host *shpnt = SCpnt->device->host;
919 unsigned long flags;
920
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 SCpnt->scsi_done = done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 SCpnt->SCp.phase = not_issued | phase;
Boaz Harrosh0ceb4792007-07-29 22:22:04 +0300923 SCpnt->SCp.Status = 0x1; /* Ilegal status by SCSI standard */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 SCpnt->SCp.Message = 0;
925 SCpnt->SCp.have_data_in = 0;
926 SCpnt->SCp.sent_command = 0;
927
928 if(SCpnt->SCp.phase & (resetting|check_condition)) {
Harvey Harrison172c1222008-04-28 16:50:03 -0700929 if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200930 scmd_printk(KERN_ERR, SCpnt, "cannot reuse command\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 return FAILED;
932 }
933 } else {
934 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
Harvey Harrison172c1222008-04-28 16:50:03 -0700935 if(!SCpnt->host_scribble) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +0200936 scmd_printk(KERN_ERR, SCpnt, "allocation failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 return FAILED;
938 }
939 }
940
941 SCNEXT(SCpnt) = NULL;
Christoph Hellwig0f06bb32007-05-13 17:52:12 +0200942 SCSEM(SCpnt) = complete;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
944 /* setup scratch area
945 SCp.ptr : buffer pointer
946 SCp.this_residual : buffer length
947 SCp.buffer : next buffer
948 SCp.buffers_residual : left buffers in list
949 SCp.phase : current state of the command */
Boaz Harrosh66acdb02007-07-29 22:24:09 +0300950
Boaz Harrosh73d2cb12007-11-01 18:54:44 +0200951 if ((phase & resetting) || !scsi_sglist(SCpnt)) {
952 SCpnt->SCp.ptr = NULL;
953 SCpnt->SCp.this_residual = 0;
954 scsi_set_resid(SCpnt, 0);
Boaz Harrosh66acdb02007-07-29 22:24:09 +0300955 SCpnt->SCp.buffer = NULL;
956 SCpnt->SCp.buffers_residual = 0;
957 } else {
Boaz Harrosh23385452007-07-29 22:29:02 +0300958 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
959 SCpnt->SCp.buffer = scsi_sglist(SCpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 SCpnt->SCp.ptr = SG_ADDRESS(SCpnt->SCp.buffer);
961 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
Boaz Harrosh23385452007-07-29 22:29:02 +0300962 SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1;
Boaz Harrosh66acdb02007-07-29 22:24:09 +0300963 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964
965 DO_LOCK(flags);
966
967#if defined(AHA152X_STAT)
968 HOSTDATA(shpnt)->total_commands++;
969#endif
970
971 /* Turn led on, when this is the first command. */
972 HOSTDATA(shpnt)->commands++;
973 if (HOSTDATA(shpnt)->commands==1)
974 SETPORT(PORTA, 1);
975
976 append_SC(&ISSUE_SC, SCpnt);
977
978 if(!HOSTDATA(shpnt)->in_intr)
979 setup_expected_interrupts(shpnt);
980
981 DO_UNLOCK(flags);
982
983 return 0;
984}
985
986/*
987 * queue a command
988 *
989 */
Jeff Garzikf2812332010-11-16 02:10:29 -0500990static int aha152x_queue_lck(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 return aha152x_internal_queue(SCpnt, NULL, 0, done);
993}
994
Jeff Garzikf2812332010-11-16 02:10:29 -0500995static DEF_SCSI_QCMD(aha152x_queue)
996
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
998/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 *
1000 */
1001static void reset_done(Scsi_Cmnd *SCpnt)
1002{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 if(SCSEM(SCpnt)) {
Christoph Hellwig0f06bb32007-05-13 17:52:12 +02001004 complete(SCSEM(SCpnt));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 } else {
Christoph Hellwig0f06bb32007-05-13 17:52:12 +02001006 printk(KERN_ERR "aha152x: reset_done w/o completion\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 }
1008}
1009
1010/*
1011 * Abort a command
1012 *
1013 */
1014static int aha152x_abort(Scsi_Cmnd *SCpnt)
1015{
1016 struct Scsi_Host *shpnt = SCpnt->device->host;
1017 Scsi_Cmnd *ptr;
1018 unsigned long flags;
1019
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 DO_LOCK(flags);
1021
1022 ptr=remove_SC(&ISSUE_SC, SCpnt);
1023
1024 if(ptr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 HOSTDATA(shpnt)->commands--;
1026 if (!HOSTDATA(shpnt)->commands)
1027 SETPORT(PORTA, 0);
1028 DO_UNLOCK(flags);
1029
1030 kfree(SCpnt->host_scribble);
1031 SCpnt->host_scribble=NULL;
1032
1033 return SUCCESS;
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001034 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035
1036 DO_UNLOCK(flags);
1037
1038 /*
1039 * FIXME:
1040 * for current command: queue ABORT for message out and raise ATN
1041 * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1042 *
1043 */
1044
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001045 scmd_printk(KERN_ERR, SCpnt,
1046 "cannot abort running or disconnected command\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047
1048 return FAILED;
1049}
1050
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051/*
1052 * Reset a device
1053 *
1054 */
1055static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
1056{
1057 struct Scsi_Host *shpnt = SCpnt->device->host;
Christoph Hellwig0f06bb32007-05-13 17:52:12 +02001058 DECLARE_COMPLETION(done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 int ret, issued, disconnected;
Christoph Hellwig631c2282006-07-08 20:42:15 +02001060 unsigned char old_cmd_len = SCpnt->cmd_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 unsigned long flags;
Christoph Hellwig0f06bb32007-05-13 17:52:12 +02001062 unsigned long timeleft;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 if(CURRENT_SC==SCpnt) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001065 scmd_printk(KERN_ERR, SCpnt, "cannot reset current device\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 return FAILED;
1067 }
1068
1069 DO_LOCK(flags);
Harvey Harrison172c1222008-04-28 16:50:03 -07001070 issued = remove_SC(&ISSUE_SC, SCpnt) == NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1072 DO_UNLOCK(flags);
1073
1074 SCpnt->cmd_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075
Christoph Hellwig0f06bb32007-05-13 17:52:12 +02001076 aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077
Christoph Hellwig0f06bb32007-05-13 17:52:12 +02001078 timeleft = wait_for_completion_timeout(&done, 100*HZ);
1079 if (!timeleft) {
1080 /* remove command from issue queue */
1081 DO_LOCK(flags);
1082 remove_SC(&ISSUE_SC, SCpnt);
1083 DO_UNLOCK(flags);
1084 }
Christoph Hellwig631c2282006-07-08 20:42:15 +02001085
1086 SCpnt->cmd_len = old_cmd_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087
1088 DO_LOCK(flags);
1089
1090 if(SCpnt->SCp.phase & resetted) {
1091 HOSTDATA(shpnt)->commands--;
1092 if (!HOSTDATA(shpnt)->commands)
1093 SETPORT(PORTA, 0);
1094 kfree(SCpnt->host_scribble);
1095 SCpnt->host_scribble=NULL;
1096
1097 ret = SUCCESS;
1098 } else {
1099 /* requeue */
1100 if(!issued) {
1101 append_SC(&ISSUE_SC, SCpnt);
1102 } else if(disconnected) {
1103 append_SC(&DISCONNECTED_SC, SCpnt);
1104 }
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001105
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 ret = FAILED;
1107 }
1108
1109 DO_UNLOCK(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 return ret;
1111}
1112
1113static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1114{
1115 Scsi_Cmnd *ptr;
1116
1117 ptr=*SCs;
1118 while(ptr) {
1119 Scsi_Cmnd *next;
1120
1121 if(SCDATA(ptr)) {
1122 next = SCNEXT(ptr);
1123 } else {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001124 scmd_printk(KERN_DEBUG, ptr,
1125 "queue corrupted at %p\n", ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 next = NULL;
1127 }
1128
1129 if (!ptr->device->soft_reset) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 remove_SC(SCs, ptr);
1131 HOSTDATA(shpnt)->commands--;
1132 kfree(ptr->host_scribble);
1133 ptr->host_scribble=NULL;
1134 }
1135
1136 ptr = next;
1137 }
1138}
1139
1140/*
1141 * Reset the bus
1142 *
1143 */
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001144static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 unsigned long flags;
1147
1148 DO_LOCK(flags);
1149
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 free_hard_reset_SCs(shpnt, &ISSUE_SC);
1151 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1152
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 SETPORT(SCSISEQ, SCSIRSTO);
1154 mdelay(256);
1155 SETPORT(SCSISEQ, 0);
1156 mdelay(DELAY);
1157
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 setup_expected_interrupts(shpnt);
1159 if(HOSTDATA(shpnt)->commands==0)
1160 SETPORT(PORTA, 0);
1161
1162 DO_UNLOCK(flags);
1163
1164 return SUCCESS;
1165}
1166
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001167/*
1168 * Reset the bus
1169 *
1170 */
1171static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1172{
1173 return aha152x_bus_reset_host(SCpnt->device->host);
1174}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175
1176/*
1177 * Restore default values to the AIC-6260 registers and reset the fifos
1178 *
1179 */
1180static void reset_ports(struct Scsi_Host *shpnt)
1181{
1182 unsigned long flags;
1183
1184 /* disable interrupts */
1185 SETPORT(DMACNTRL0, RSTFIFO);
1186
1187 SETPORT(SCSISEQ, 0);
1188
1189 SETPORT(SXFRCTL1, 0);
1190 SETPORT(SCSISIG, 0);
1191 SETRATE(0);
1192
1193 /* clear all interrupt conditions */
1194 SETPORT(SSTAT0, 0x7f);
1195 SETPORT(SSTAT1, 0xef);
1196
1197 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1198
1199 SETPORT(DMACNTRL0, 0);
1200 SETPORT(DMACNTRL1, 0);
1201
1202 SETPORT(BRSTCNTRL, 0xf1);
1203
1204 /* clear SCSI fifos and transfer count */
1205 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1206 SETPORT(SXFRCTL0, CH1);
1207
1208 DO_LOCK(flags);
1209 setup_expected_interrupts(shpnt);
1210 DO_UNLOCK(flags);
1211}
1212
1213/*
1214 * Reset the host (bus and controller)
1215 *
1216 */
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001217int aha152x_host_reset_host(struct Scsi_Host *shpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218{
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001219 aha152x_bus_reset_host(shpnt);
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001220 reset_ports(shpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221
1222 return SUCCESS;
1223}
1224
1225/*
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001226 * Reset the host (bus and controller)
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001227 *
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001228 */
1229static int aha152x_host_reset(Scsi_Cmnd *SCpnt)
1230{
1231 return aha152x_host_reset_host(SCpnt->device->host);
1232}
1233
1234/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 * Return the "logical geometry"
1236 *
1237 */
1238static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1239 sector_t capacity, int *info_array)
1240{
1241 struct Scsi_Host *shpnt = sdev->host;
1242
1243 /* try default translation */
1244 info_array[0] = 64;
1245 info_array[1] = 32;
1246 info_array[2] = (unsigned long)capacity / (64 * 32);
1247
1248 /* for disks >1GB do some guessing */
1249 if (info_array[2] >= 1024) {
1250 int info[3];
1251
1252 /* try to figure out the geometry from the partition table */
1253 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1254 !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1255 if (EXT_TRANS) {
1256 printk(KERN_NOTICE
1257 "aha152x: unable to verify geometry for disk with >1GB.\n"
1258 " using extended translation.\n");
1259 info_array[0] = 255;
1260 info_array[1] = 63;
1261 info_array[2] = (unsigned long)capacity / (255 * 63);
1262 } else {
1263 printk(KERN_NOTICE
1264 "aha152x: unable to verify geometry for disk with >1GB.\n"
1265 " Using default translation. Please verify yourself.\n"
1266 " Perhaps you need to enable extended translation in the driver.\n"
1267 " See Documentation/scsi/aha152x.txt for details.\n");
1268 }
1269 } else {
1270 info_array[0] = info[0];
1271 info_array[1] = info[1];
1272 info_array[2] = info[2];
1273
1274 if (info[0] == 255 && !EXT_TRANS) {
1275 printk(KERN_NOTICE
1276 "aha152x: current partition table is using extended translation.\n"
1277 " using it also, although it's not explicitly enabled.\n");
1278 }
1279 }
1280 }
1281
1282 return 0;
1283}
1284
1285/*
1286 * Internal done function
1287 *
1288 */
1289static void done(struct Scsi_Host *shpnt, int error)
1290{
1291 if (CURRENT_SC) {
1292 if(DONE_SC)
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001293 scmd_printk(KERN_ERR, CURRENT_SC,
1294 "there's already a completed command %p "
1295 "- will cause abort\n", DONE_SC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296
1297 DONE_SC = CURRENT_SC;
1298 CURRENT_SC = NULL;
1299 DONE_SC->result = error;
1300 } else
1301 printk(KERN_ERR "aha152x: done() called outside of command\n");
1302}
1303
1304static struct work_struct aha152x_tq;
1305
1306/*
1307 * Run service completions on the card with interrupts enabled.
1308 *
1309 */
David Howellsc4028952006-11-22 14:57:56 +00001310static void run(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311{
James Bottomley5fcda422006-09-14 17:04:58 -05001312 struct aha152x_hostdata *hd;
1313
1314 list_for_each_entry(hd, &aha152x_host_list, host_list) {
1315 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1316
1317 is_complete(shost);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 }
1319}
1320
1321/*
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001322 * Interrupt handler
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 *
1324 */
David Howells7d12e782006-10-05 14:55:46 +01001325static irqreturn_t intr(int irqno, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326{
Jeff Garzike19166d2008-04-18 19:22:52 -04001327 struct Scsi_Host *shpnt = dev_id;
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001328 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 unsigned char rev, dmacntrl0;
1330
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 /*
1332 * Read a couple of registers that are known to not be all 1's. If
1333 * we read all 1's (-1), that means that either:
1334 *
1335 * a. The host adapter chip has gone bad, and we cannot control it,
1336 * OR
1337 * b. The host adapter is a PCMCIA card that has been ejected
1338 *
1339 * In either case, we cannot do anything with the host adapter at
1340 * this point in time. So just ignore the interrupt and return.
1341 * In the latter case, the interrupt might actually be meant for
1342 * someone else sharing this IRQ, and that driver will handle it.
1343 */
1344 rev = GETPORT(REV);
1345 dmacntrl0 = GETPORT(DMACNTRL0);
1346 if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1347 return IRQ_NONE;
1348
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001349 if( TESTLO(DMASTAT, INTSTAT) )
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001350 return IRQ_NONE;
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001351
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 /* no more interrupts from the controller, while we're busy.
1353 INTEN is restored by the BH handler */
1354 CLRBITS(DMACNTRL0, INTEN);
1355
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001356 DO_LOCK(flags);
1357 if( HOSTDATA(shpnt)->service==0 ) {
1358 HOSTDATA(shpnt)->service=1;
1359
1360 /* Poke the BH handler */
David Howellsc4028952006-11-22 14:57:56 +00001361 INIT_WORK(&aha152x_tq, run);
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001362 schedule_work(&aha152x_tq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 }
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01001364 DO_UNLOCK(flags);
1365
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 return IRQ_HANDLED;
1367}
1368
1369/*
1370 * busfree phase
1371 * - handle completition/disconnection/error of current command
1372 * - start selection for next command (if any)
1373 */
1374static void busfree_run(struct Scsi_Host *shpnt)
1375{
1376 unsigned long flags;
1377#if defined(AHA152X_STAT)
1378 int action=0;
1379#endif
1380
1381 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1382 SETPORT(SXFRCTL0, CH1);
1383
1384 SETPORT(SSTAT1, CLRBUSFREE);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001385
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 if(CURRENT_SC) {
1387#if defined(AHA152X_STAT)
1388 action++;
1389#endif
1390 CURRENT_SC->SCp.phase &= ~syncneg;
1391
1392 if(CURRENT_SC->SCp.phase & completed) {
1393 /* target sent COMMAND COMPLETE */
1394 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1395
1396 } else if(CURRENT_SC->SCp.phase & aborted) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1398
1399 } else if(CURRENT_SC->SCp.phase & resetted) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1401
1402 } else if(CURRENT_SC->SCp.phase & disconnected) {
1403 /* target sent DISCONNECT */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404#if defined(AHA152X_STAT)
1405 HOSTDATA(shpnt)->disconnections++;
1406#endif
1407 append_SC(&DISCONNECTED_SC, CURRENT_SC);
1408 CURRENT_SC->SCp.phase |= 1 << 16;
1409 CURRENT_SC = NULL;
1410
1411 } else {
1412 done(shpnt, DID_ERROR << 16);
1413 }
1414#if defined(AHA152X_STAT)
1415 } else {
1416 HOSTDATA(shpnt)->busfree_without_old_command++;
1417#endif
1418 }
1419
1420 DO_LOCK(flags);
1421
1422 if(DONE_SC) {
1423#if defined(AHA152X_STAT)
1424 action++;
1425#endif
1426
1427 if(DONE_SC->SCp.phase & check_condition) {
Christoph Hellwig5e13cdf2006-07-08 20:39:30 +02001428 struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1429 struct aha152x_scdata *sc = SCDATA(cmd);
1430
Boaz Harrosh73d2cb12007-11-01 18:54:44 +02001431 scsi_eh_restore_cmnd(cmd, &sc->ses);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432
Boaz Harrosh0ceb4792007-07-29 22:22:04 +03001433 cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
1435 HOSTDATA(shpnt)->commands--;
1436 if (!HOSTDATA(shpnt)->commands)
1437 SETPORT(PORTA, 0); /* turn led off */
Boaz Harrosh0ceb4792007-07-29 22:22:04 +03001438 } else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439#if defined(AHA152X_STAT)
1440 HOSTDATA(shpnt)->busfree_with_check_condition++;
1441#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442
Boaz Harrosh0ceb4792007-07-29 22:22:04 +03001443 if(!(DONE_SC->SCp.phase & not_issued)) {
Boaz Harrosh45333ff2007-07-29 22:27:06 +03001444 struct aha152x_scdata *sc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 Scsi_Cmnd *ptr = DONE_SC;
1446 DONE_SC=NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
Boaz Harrosh45333ff2007-07-29 22:27:06 +03001448 sc = SCDATA(ptr);
1449 /* It was allocated in aha152x_internal_queue? */
1450 BUG_ON(!sc);
Boaz Harrosh73d2cb12007-11-01 18:54:44 +02001451 scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0);
Boaz Harrosh45333ff2007-07-29 22:27:06 +03001452
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 DO_UNLOCK(flags);
1454 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1455 DO_LOCK(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 }
1457 }
1458
1459 if(DONE_SC && DONE_SC->scsi_done) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 Scsi_Cmnd *ptr = DONE_SC;
1461 DONE_SC=NULL;
1462
1463 /* turn led off, when no commands are in the driver */
1464 HOSTDATA(shpnt)->commands--;
1465 if (!HOSTDATA(shpnt)->commands)
1466 SETPORT(PORTA, 0); /* turn led off */
1467
1468 if(ptr->scsi_done != reset_done) {
1469 kfree(ptr->host_scribble);
1470 ptr->host_scribble=NULL;
1471 }
1472
1473 DO_UNLOCK(flags);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001474 ptr->scsi_done(ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 DO_LOCK(flags);
1476 }
1477
1478 DONE_SC=NULL;
1479#if defined(AHA152X_STAT)
1480 } else {
1481 HOSTDATA(shpnt)->busfree_without_done_command++;
1482#endif
1483 }
1484
1485 if(ISSUE_SC)
1486 CURRENT_SC = remove_first_SC(&ISSUE_SC);
1487
1488 DO_UNLOCK(flags);
1489
1490 if(CURRENT_SC) {
1491#if defined(AHA152X_STAT)
1492 action++;
1493#endif
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001494 CURRENT_SC->SCp.phase |= selecting;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495
1496 /* clear selection timeout */
1497 SETPORT(SSTAT1, SELTO);
1498
1499 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1500 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1501 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1502 } else {
1503#if defined(AHA152X_STAT)
1504 HOSTDATA(shpnt)->busfree_without_new_command++;
1505#endif
1506 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1507 }
1508
1509#if defined(AHA152X_STAT)
1510 if(!action)
1511 HOSTDATA(shpnt)->busfree_without_any_action++;
1512#endif
1513}
1514
1515/*
1516 * Selection done (OUT)
1517 * - queue IDENTIFY message and SDTR to selected target for message out
1518 * (ATN asserted automagically via ENAUTOATNO in busfree())
1519 */
1520static void seldo_run(struct Scsi_Host *shpnt)
1521{
1522 SETPORT(SCSISIG, 0);
1523 SETPORT(SSTAT1, CLRBUSFREE);
1524 SETPORT(SSTAT1, CLRPHASECHG);
1525
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001526 CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527
1528 SETPORT(SCSISEQ, 0);
1529
1530 if (TESTLO(SSTAT0, SELDO)) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001531 scmd_printk(KERN_ERR, CURRENT_SC,
1532 "aha152x: passing bus free condition\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 done(shpnt, DID_NO_CONNECT << 16);
1534 return;
1535 }
1536
1537 SETPORT(SSTAT0, CLRSELDO);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001538
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1540
1541 if (CURRENT_SC->SCp.phase & aborting) {
1542 ADDMSGO(ABORT);
1543 } else if (CURRENT_SC->SCp.phase & resetting) {
1544 ADDMSGO(BUS_DEVICE_RESET);
1545 } else if (SYNCNEG==0 && SYNCHRONOUS) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001546 CURRENT_SC->SCp.phase |= syncneg;
Matthew Wilcox6ea3c0b2006-02-07 07:54:46 -07001547 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 SYNCNEG=1; /* negotiation in progress */
1549 }
1550
1551 SETRATE(SYNCRATE);
1552}
1553
1554/*
1555 * Selection timeout
1556 * - return command to mid-level with failure cause
1557 *
1558 */
1559static void selto_run(struct Scsi_Host *shpnt)
1560{
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001561 SETPORT(SCSISEQ, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 SETPORT(SSTAT1, CLRSELTIMO);
1563
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001564 if (!CURRENT_SC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001567 CURRENT_SC->SCp.phase &= ~selecting;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001569 if (CURRENT_SC->SCp.phase & aborted)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 done(shpnt, DID_ABORT << 16);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001571 else if (TESTLO(SSTAT0, SELINGO))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 done(shpnt, DID_BUS_BUSY << 16);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001573 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 /* ARBITRATION won, but SELECTION failed */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 done(shpnt, DID_NO_CONNECT << 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576}
1577
1578/*
1579 * Selection in done
1580 * - put current command back to issue queue
1581 * (reconnection of a disconnected nexus instead
1582 * of successful selection out)
1583 *
1584 */
1585static void seldi_run(struct Scsi_Host *shpnt)
1586{
1587 int selid;
1588 int target;
1589 unsigned long flags;
1590
1591 SETPORT(SCSISIG, 0);
1592 SETPORT(SSTAT0, CLRSELDI);
1593 SETPORT(SSTAT1, CLRBUSFREE);
1594 SETPORT(SSTAT1, CLRPHASECHG);
1595
1596 if(CURRENT_SC) {
1597 if(!(CURRENT_SC->SCp.phase & not_issued))
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001598 scmd_printk(KERN_ERR, CURRENT_SC,
1599 "command should not have been issued yet\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600
1601 DO_LOCK(flags);
1602 append_SC(&ISSUE_SC, CURRENT_SC);
1603 DO_UNLOCK(flags);
1604
1605 CURRENT_SC = NULL;
1606 }
1607
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001608 if (!DISCONNECTED_SC)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610
1611 RECONN_TARGET=-1;
1612
1613 selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1614
1615 if (selid==0) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001616 shost_printk(KERN_INFO, shpnt,
1617 "target id unknown (%02x)\n", selid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 return;
1619 }
1620
1621 for(target=7; !(selid & (1 << target)); target--)
1622 ;
1623
1624 if(selid & ~(1 << target)) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001625 shost_printk(KERN_INFO, shpnt,
1626 "multiple targets reconnected (%02x)\n", selid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 }
1628
1629
1630 SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1631 SETPORT(SCSISEQ, 0);
1632
1633 SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1634
1635 RECONN_TARGET=target;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636}
1637
1638/*
1639 * message in phase
1640 * - handle initial message after reconnection to identify
1641 * reconnecting nexus
1642 * - queue command on DISCONNECTED_SC on DISCONNECT message
1643 * - set completed flag on COMMAND COMPLETE
1644 * (other completition code moved to busfree_run)
1645 * - handle response to SDTR
1646 * - clear synchronous transfer agreements on BUS RESET
1647 *
1648 * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1649 *
1650 */
1651static void msgi_run(struct Scsi_Host *shpnt)
1652{
1653 for(;;) {
1654 int sstat1 = GETPORT(SSTAT1);
1655
1656 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1657 return;
1658
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001659 if (TESTLO(SSTAT0, SPIORDY))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661
1662 ADDMSGI(GETPORT(SCSIDAT));
1663
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 if(!CURRENT_SC) {
1665 if(LASTSTATE!=seldi) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001666 shost_printk(KERN_ERR, shpnt,
1667 "message in w/o current command"
1668 " not after reselection\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 }
1670
1671 /*
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001672 * Handle reselection
1673 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 if(!(MSGI(0) & IDENTIFY_BASE)) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001675 shost_printk(KERN_ERR, shpnt,
1676 "target didn't identify after reselection\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 continue;
1678 }
1679
1680 CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1681
1682 if (!CURRENT_SC) {
1683 show_queues(shpnt);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001684 shost_printk(KERN_ERR, shpnt,
1685 "no disconnected command"
1686 " for target %d/%d\n",
1687 RECONN_TARGET, MSGI(0) & 0x3f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 continue;
1689 }
1690
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 CURRENT_SC->SCp.Message = MSGI(0);
1692 CURRENT_SC->SCp.phase &= ~disconnected;
1693
1694 MSGILEN=0;
1695
1696 /* next message if any */
1697 continue;
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001698 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699
1700 CURRENT_SC->SCp.Message = MSGI(0);
1701
1702 switch (MSGI(0)) {
1703 case DISCONNECT:
1704 if (!RECONNECT)
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001705 scmd_printk(KERN_WARNING, CURRENT_SC,
1706 "target was not allowed to disconnect\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707
1708 CURRENT_SC->SCp.phase |= disconnected;
1709 break;
1710
1711 case COMMAND_COMPLETE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 CURRENT_SC->SCp.phase |= completed;
1713 break;
1714
1715 case MESSAGE_REJECT:
1716 if (SYNCNEG==1) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001717 scmd_printk(KERN_INFO, CURRENT_SC,
1718 "Synchronous Data Transfer Request"
1719 " was rejected\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 SYNCNEG=2; /* negotiation completed */
1721 } else
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001722 scmd_printk(KERN_INFO, CURRENT_SC,
1723 "inbound message (MESSAGE REJECT)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 break;
1725
1726 case SAVE_POINTERS:
1727 break;
1728
1729 case RESTORE_POINTERS:
1730 break;
1731
1732 case EXTENDED_MESSAGE:
1733 if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1734 /* not yet completed */
1735 continue;
1736 }
1737
1738 switch (MSGI(2)) {
1739 case EXTENDED_SDTR:
1740 {
1741 long ticks;
1742
1743 if (MSGI(1) != 3) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001744 scmd_printk(KERN_ERR, CURRENT_SC,
1745 "SDTR message length!=3\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 break;
1747 }
1748
1749 if (!HOSTDATA(shpnt)->synchronous)
1750 break;
1751
1752 printk(INFO_LEAD, CMDINFO(CURRENT_SC));
Matthew Wilcox1abfd372005-12-15 16:22:01 -05001753 spi_print_msg(&MSGI(0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 printk("\n");
1755
1756 ticks = (MSGI(3) * 4 + 49) / 50;
1757
1758 if (syncneg) {
1759 /* negotiation in progress */
1760 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1761 ADDMSGO(MESSAGE_REJECT);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001762 scmd_printk(KERN_INFO,
1763 CURRENT_SC,
1764 "received Synchronous Data Transfer Request invalid - rejected\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 break;
1766 }
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001767
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1769 } else if (ticks <= 9 && MSGI(4) >= 1) {
1770 ADDMSGO(EXTENDED_MESSAGE);
1771 ADDMSGO(3);
1772 ADDMSGO(EXTENDED_SDTR);
1773 if (ticks < 4) {
1774 ticks = 4;
1775 ADDMSGO(50);
1776 } else
1777 ADDMSGO(MSGI(3));
1778
1779 if (MSGI(4) > 8)
1780 MSGI(4) = 8;
1781
1782 ADDMSGO(MSGI(4));
1783
1784 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1785 } else {
1786 /* requested SDTR is too slow, do it asynchronously */
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001787 scmd_printk(KERN_INFO,
1788 CURRENT_SC,
1789 "Synchronous Data Transfer Request too slow - Rejecting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 ADDMSGO(MESSAGE_REJECT);
1791 }
1792
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001793 /* negotiation completed */
1794 SYNCNEG=2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 SETRATE(SYNCRATE);
1796 }
1797 break;
1798
1799 case BUS_DEVICE_RESET:
1800 {
1801 int i;
1802
1803 for(i=0; i<8; i++) {
1804 HOSTDATA(shpnt)->syncrate[i]=0;
1805 HOSTDATA(shpnt)->syncneg[i]=0;
1806 }
1807
1808 }
1809 break;
1810
1811 case EXTENDED_MODIFY_DATA_POINTER:
1812 case EXTENDED_EXTENDED_IDENTIFY:
1813 case EXTENDED_WDTR:
1814 default:
1815 ADDMSGO(MESSAGE_REJECT);
1816 break;
1817 }
1818 break;
1819 }
1820
1821 MSGILEN=0;
1822 }
1823}
1824
1825static void msgi_end(struct Scsi_Host *shpnt)
1826{
1827 if(MSGILEN>0)
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001828 scmd_printk(KERN_WARNING, CURRENT_SC,
1829 "target left before message completed (%d)\n",
1830 MSGILEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001832 if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834}
1835
1836/*
1837 * message out phase
1838 *
1839 */
1840static void msgo_init(struct Scsi_Host *shpnt)
1841{
1842 if(MSGOLEN==0) {
1843 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
1844 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1845 } else {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001846 scmd_printk(KERN_INFO, CURRENT_SC,
1847 "unexpected MESSAGE OUT phase; rejecting\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 ADDMSGO(MESSAGE_REJECT);
1849 }
1850 }
1851
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852}
1853
1854/*
1855 * message out phase
1856 *
1857 */
1858static void msgo_run(struct Scsi_Host *shpnt)
1859{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 while(MSGO_I<MSGOLEN) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001861 if (TESTLO(SSTAT0, SPIORDY))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863
1864 if (MSGO_I==MSGOLEN-1) {
1865 /* Leave MESSAGE OUT after transfer */
1866 SETPORT(SSTAT1, CLRATNO);
1867 }
1868
1869
1870 if (MSGO(MSGO_I) & IDENTIFY_BASE)
1871 CURRENT_SC->SCp.phase |= identified;
1872
1873 if (MSGO(MSGO_I)==ABORT)
1874 CURRENT_SC->SCp.phase |= aborted;
1875
1876 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
1877 CURRENT_SC->SCp.phase |= resetted;
1878
1879 SETPORT(SCSIDAT, MSGO(MSGO_I++));
1880 }
1881}
1882
1883static void msgo_end(struct Scsi_Host *shpnt)
1884{
1885 if(MSGO_I<MSGOLEN) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001886 scmd_printk(KERN_ERR, CURRENT_SC,
1887 "message sent incompletely (%d/%d)\n",
1888 MSGO_I, MSGOLEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 if(SYNCNEG==1) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001890 scmd_printk(KERN_INFO, CURRENT_SC,
1891 "Synchronous Data Transfer Request was rejected\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 SYNCNEG=2;
1893 }
1894 }
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001895
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 MSGO_I = 0;
1897 MSGOLEN = 0;
1898}
1899
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001900/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901 * command phase
1902 *
1903 */
1904static void cmd_init(struct Scsi_Host *shpnt)
1905{
1906 if (CURRENT_SC->SCp.sent_command) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001907 scmd_printk(KERN_ERR, CURRENT_SC,
1908 "command already sent\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 done(shpnt, DID_ERROR << 16);
1910 return;
1911 }
1912
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 CMD_I=0;
1914}
1915
1916/*
1917 * command phase
1918 *
1919 */
1920static void cmd_run(struct Scsi_Host *shpnt)
1921{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 while(CMD_I<CURRENT_SC->cmd_len) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001923 if (TESTLO(SSTAT0, SPIORDY))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925
1926 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
1927 }
1928}
1929
1930static void cmd_end(struct Scsi_Host *shpnt)
1931{
1932 if(CMD_I<CURRENT_SC->cmd_len)
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001933 scmd_printk(KERN_ERR, CURRENT_SC,
1934 "command sent incompletely (%d/%d)\n",
1935 CMD_I, CURRENT_SC->cmd_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 else
1937 CURRENT_SC->SCp.sent_command++;
1938}
1939
1940/*
1941 * status phase
1942 *
1943 */
1944static void status_run(struct Scsi_Host *shpnt)
1945{
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001946 if (TESTLO(SSTAT0, SPIORDY))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948
1949 CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
1950
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951}
1952
1953/*
1954 * data in phase
1955 *
1956 */
1957static void datai_init(struct Scsi_Host *shpnt)
1958{
1959 SETPORT(DMACNTRL0, RSTFIFO);
1960 SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
1961
1962 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
1963 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
1964
1965 SETPORT(SIMODE0, 0);
1966 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
1967
1968 DATA_LEN=0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969}
1970
1971static void datai_run(struct Scsi_Host *shpnt)
1972{
1973 unsigned long the_time;
1974 int fifodata, data_count;
1975
1976 /*
1977 * loop while the phase persists or the fifos are not empty
1978 *
1979 */
1980 while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
1981 /* FIXME: maybe this should be done by setting up
1982 * STCNT to trigger ENSWRAP interrupt, instead of
1983 * polling for DFIFOFULL
1984 */
1985 the_time=jiffies + 100*HZ;
1986 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
1987 barrier();
1988
1989 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02001990 scmd_printk(KERN_ERR, CURRENT_SC, "datai timeout\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 break;
1992 }
1993
1994 if(TESTHI(DMASTAT, DFIFOFULL)) {
1995 fifodata = 128;
1996 } else {
1997 the_time=jiffies + 100*HZ;
1998 while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
1999 barrier();
2000
2001 if(TESTLO(SSTAT2, SEMPTY)) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002002 scmd_printk(KERN_ERR, CURRENT_SC,
2003 "datai sempty timeout");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 break;
2005 }
2006
2007 fifodata = GETPORT(FIFOSTAT);
2008 }
2009
2010 if(CURRENT_SC->SCp.this_residual>0) {
2011 while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002012 data_count = fifodata > CURRENT_SC->SCp.this_residual ?
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 CURRENT_SC->SCp.this_residual :
2014 fifodata;
2015 fifodata -= data_count;
2016
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002017 if (data_count & 1) {
2018 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2019 *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2020 CURRENT_SC->SCp.this_residual--;
2021 DATA_LEN++;
2022 SETPORT(DMACNTRL0, ENDMA);
2023 }
2024
2025 if (data_count > 1) {
2026 data_count >>= 1;
2027 insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2028 CURRENT_SC->SCp.ptr += 2 * data_count;
2029 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2030 DATA_LEN += 2 * data_count;
2031 }
2032
2033 if (CURRENT_SC->SCp.this_residual == 0 &&
2034 CURRENT_SC->SCp.buffers_residual > 0) {
2035 /* advance to next buffer */
2036 CURRENT_SC->SCp.buffers_residual--;
2037 CURRENT_SC->SCp.buffer++;
2038 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2039 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2040 }
2041 }
2042 } else if (fifodata > 0) {
2043 scmd_printk(KERN_ERR, CURRENT_SC,
2044 "no buffers left for %d(%d) bytes"
2045 " (data overrun!?)\n",
2046 fifodata, GETPORT(FIFOSTAT));
2047 SETPORT(DMACNTRL0, ENDMA|_8BIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 while(fifodata>0) {
2049 int data;
2050 data=GETPORT(DATAPORT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 fifodata--;
2052 DATA_LEN++;
2053 }
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002054 SETPORT(DMACNTRL0, ENDMA|_8BIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 }
2056 }
2057
2058 if(TESTLO(DMASTAT, INTSTAT) ||
2059 TESTLO(DMASTAT, DFIFOEMP) ||
2060 TESTLO(SSTAT2, SEMPTY) ||
2061 GETPORT(FIFOSTAT)>0) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002062 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 * something went wrong, if there's something left in the fifos
2064 * or the phase didn't change
2065 */
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002066 scmd_printk(KERN_ERR, CURRENT_SC,
2067 "fifos should be empty and phase should have changed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068 }
2069
2070 if(DATA_LEN!=GETSTCNT()) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002071 scmd_printk(KERN_ERR, CURRENT_SC,
2072 "manual transfer count differs from automatic "
2073 "(count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2074 DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN,
2075 GETPORT(FIFOSTAT));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 mdelay(10000);
2077 }
2078}
2079
2080static void datai_end(struct Scsi_Host *shpnt)
2081{
Boaz Harrosh23385452007-07-29 22:29:02 +03002082 CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2085 SETPORT(DMACNTRL0, 0);
2086}
2087
2088/*
2089 * data out phase
2090 *
2091 */
2092static void datao_init(struct Scsi_Host *shpnt)
2093{
2094 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2095 SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2096
2097 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2098 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2099
2100 SETPORT(SIMODE0, 0);
2101 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2102
Boaz Harrosh23385452007-07-29 22:29:02 +03002103 DATA_LEN = scsi_get_resid(CURRENT_SC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104}
2105
2106static void datao_run(struct Scsi_Host *shpnt)
2107{
2108 unsigned long the_time;
2109 int data_count;
2110
2111 /* until phase changes or all data sent */
2112 while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2113 data_count = 128;
2114 if(data_count > CURRENT_SC->SCp.this_residual)
2115 data_count=CURRENT_SC->SCp.this_residual;
2116
2117 if(TESTLO(DMASTAT, DFIFOEMP)) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002118 scmd_printk(KERN_ERR, CURRENT_SC,
2119 "datao fifo not empty (%d)",
2120 GETPORT(FIFOSTAT));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 break;
2122 }
2123
2124 if(data_count & 1) {
2125 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2126 SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2127 CURRENT_SC->SCp.this_residual--;
Boaz Harrosh23385452007-07-29 22:29:02 +03002128 CMD_INC_RESID(CURRENT_SC, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2130 }
2131
2132 if(data_count > 1) {
2133 data_count >>= 1;
2134 outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2135 CURRENT_SC->SCp.ptr += 2 * data_count;
2136 CURRENT_SC->SCp.this_residual -= 2 * data_count;
Boaz Harrosh23385452007-07-29 22:29:02 +03002137 CMD_INC_RESID(CURRENT_SC, -2 * data_count);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002138 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139
2140 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2141 /* advance to next buffer */
2142 CURRENT_SC->SCp.buffers_residual--;
2143 CURRENT_SC->SCp.buffer++;
2144 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2145 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2146 }
2147
2148 the_time=jiffies + 100*HZ;
2149 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2150 barrier();
2151
2152 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002153 scmd_printk(KERN_ERR, CURRENT_SC, "dataout timeout\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154 break;
2155 }
2156 }
2157}
2158
2159static void datao_end(struct Scsi_Host *shpnt)
2160{
2161 if(TESTLO(DMASTAT, DFIFOEMP)) {
Boaz Harrosh23385452007-07-29 22:29:02 +03002162 int data_count = (DATA_LEN - scsi_get_resid(CURRENT_SC)) -
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002163 GETSTCNT();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164
Boaz Harrosh23385452007-07-29 22:29:02 +03002165 CMD_INC_RESID(CURRENT_SC, data_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166
Boaz Harrosh23385452007-07-29 22:29:02 +03002167 data_count -= CURRENT_SC->SCp.ptr -
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002168 SG_ADDRESS(CURRENT_SC->SCp.buffer);
Boaz Harrosh23385452007-07-29 22:29:02 +03002169 while(data_count>0) {
2170 CURRENT_SC->SCp.buffer--;
2171 CURRENT_SC->SCp.buffers_residual++;
2172 data_count -= CURRENT_SC->SCp.buffer->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 }
Boaz Harrosh23385452007-07-29 22:29:02 +03002174 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) -
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002175 data_count;
Boaz Harrosh23385452007-07-29 22:29:02 +03002176 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length +
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002177 data_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178 }
2179
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2181 SETPORT(SXFRCTL0, CH1);
2182
2183 SETPORT(DMACNTRL0, 0);
2184}
2185
2186/*
2187 * figure out what state we're in
2188 *
2189 */
2190static int update_state(struct Scsi_Host *shpnt)
2191{
2192 int dataphase=0;
2193 unsigned int stat0 = GETPORT(SSTAT0);
2194 unsigned int stat1 = GETPORT(SSTAT1);
2195
2196 PREVSTATE = STATE;
2197 STATE=unknown;
2198
2199 if(stat1 & SCSIRSTI) {
2200 STATE=rsti;
2201 SETPORT(SCSISEQ,0);
2202 SETPORT(SSTAT1,SCSIRSTI);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002203 } else if (stat0 & SELDI && PREVSTATE == busfree) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 STATE=seldi;
2205 } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2206 STATE=seldo;
2207 } else if(stat1 & SELTO) {
2208 STATE=selto;
2209 } else if(stat1 & BUSFREE) {
2210 STATE=busfree;
2211 SETPORT(SSTAT1,BUSFREE);
2212 } else if(stat1 & SCSIPERR) {
2213 STATE=parerr;
2214 SETPORT(SSTAT1,SCSIPERR);
2215 } else if(stat1 & REQINIT) {
2216 switch(GETPORT(SCSISIG) & P_MASK) {
2217 case P_MSGI: STATE=msgi; break;
2218 case P_MSGO: STATE=msgo; break;
2219 case P_DATAO: STATE=datao; break;
2220 case P_DATAI: STATE=datai; break;
2221 case P_STATUS: STATE=status; break;
2222 case P_CMD: STATE=cmd; break;
2223 }
2224 dataphase=1;
2225 }
2226
2227 if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002228 scmd_printk(KERN_INFO, CURRENT_SC, "reselection missed?");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229 }
2230
2231 if(STATE!=PREVSTATE) {
2232 LASTSTATE=PREVSTATE;
2233 }
2234
2235 return dataphase;
2236}
2237
2238/*
2239 * handle parity error
2240 *
2241 * FIXME: in which phase?
2242 *
2243 */
2244static void parerr_run(struct Scsi_Host *shpnt)
2245{
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002246 scmd_printk(KERN_ERR, CURRENT_SC, "parity error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 done(shpnt, DID_PARITY << 16);
2248}
2249
2250/*
2251 * handle reset in
2252 *
2253 */
2254static void rsti_run(struct Scsi_Host *shpnt)
2255{
2256 Scsi_Cmnd *ptr;
2257
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002258 shost_printk(KERN_NOTICE, shpnt, "scsi reset in\n");
2259
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 ptr=DISCONNECTED_SC;
2261 while(ptr) {
2262 Scsi_Cmnd *next = SCNEXT(ptr);
2263
2264 if (!ptr->device->soft_reset) {
2265 remove_SC(&DISCONNECTED_SC, ptr);
2266
2267 kfree(ptr->host_scribble);
2268 ptr->host_scribble=NULL;
2269
2270 ptr->result = DID_RESET << 16;
2271 ptr->scsi_done(ptr);
2272 }
2273
2274 ptr = next;
2275 }
2276
2277 if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2278 done(shpnt, DID_RESET << 16 );
2279}
2280
2281
2282/*
2283 * bottom-half handler
2284 *
2285 */
2286static void is_complete(struct Scsi_Host *shpnt)
2287{
2288 int dataphase;
2289 unsigned long flags;
2290 int pending;
2291
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01002292 if(!shpnt)
2293 return;
2294
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295 DO_LOCK(flags);
Jürgen E. Fischere2482fa2006-02-19 00:31:51 +01002296
2297 if( HOSTDATA(shpnt)->service==0 ) {
2298 DO_UNLOCK(flags);
2299 return;
2300 }
2301
2302 HOSTDATA(shpnt)->service = 0;
2303
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 if(HOSTDATA(shpnt)->in_intr) {
2305 DO_UNLOCK(flags);
2306 /* aha152x_error never returns.. */
2307 aha152x_error(shpnt, "bottom-half already running!?");
2308 }
2309 HOSTDATA(shpnt)->in_intr++;
2310
2311 /*
2312 * loop while there are interrupt conditions pending
2313 *
2314 */
2315 do {
2316 unsigned long start = jiffies;
2317 DO_UNLOCK(flags);
2318
2319 dataphase=update_state(shpnt);
2320
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321 /*
2322 * end previous state
2323 *
2324 */
2325 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2326 states[PREVSTATE].end(shpnt);
2327
2328 /*
2329 * disable SPIO mode if previous phase used it
2330 * and this one doesn't
2331 *
2332 */
2333 if(states[PREVSTATE].spio && !states[STATE].spio) {
2334 SETPORT(SXFRCTL0, CH1);
2335 SETPORT(DMACNTRL0, 0);
2336 if(CURRENT_SC)
2337 CURRENT_SC->SCp.phase &= ~spiordy;
2338 }
2339
2340 /*
2341 * accept current dataphase phase
2342 *
2343 */
2344 if(dataphase) {
2345 SETPORT(SSTAT0, REQINIT);
2346 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002347 SETPORT(SSTAT1, PHASECHG);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348 }
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002349
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350 /*
2351 * enable SPIO mode if previous didn't use it
2352 * and this one does
2353 *
2354 */
2355 if(!states[PREVSTATE].spio && states[STATE].spio) {
2356 SETPORT(DMACNTRL0, 0);
2357 SETPORT(SXFRCTL0, CH1|SPIOEN);
2358 if(CURRENT_SC)
2359 CURRENT_SC->SCp.phase |= spiordy;
2360 }
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002361
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 /*
2363 * initialize for new state
2364 *
2365 */
2366 if(PREVSTATE!=STATE && states[STATE].init)
2367 states[STATE].init(shpnt);
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002368
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 /*
2370 * handle current state
2371 *
2372 */
2373 if(states[STATE].run)
2374 states[STATE].run(shpnt);
2375 else
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002376 scmd_printk(KERN_ERR, CURRENT_SC,
2377 "unexpected state (%x)\n", STATE);
2378
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379 /*
2380 * setup controller to interrupt on
2381 * the next expected condition and
2382 * loop if it's already there
2383 *
2384 */
2385 DO_LOCK(flags);
2386 pending=setup_expected_interrupts(shpnt);
2387#if defined(AHA152X_STAT)
2388 HOSTDATA(shpnt)->count[STATE]++;
2389 if(PREVSTATE!=STATE)
2390 HOSTDATA(shpnt)->count_trans[STATE]++;
2391 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2392#endif
2393
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394 } while(pending);
2395
2396 /*
2397 * enable interrupts and leave bottom-half
2398 *
2399 */
2400 HOSTDATA(shpnt)->in_intr--;
2401 SETBITS(DMACNTRL0, INTEN);
2402 DO_UNLOCK(flags);
2403}
2404
2405
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002406/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 * Dump the current driver status and panic
2408 */
2409static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2410{
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002411 shost_printk(KERN_EMERG, shpnt, "%s\n", msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412 show_queues(shpnt);
2413 panic("aha152x panic\n");
2414}
2415
2416/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 * display enabled interrupts
2418 */
2419static void disp_enintr(struct Scsi_Host *shpnt)
2420{
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002421 int s0, s1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002423 s0 = GETPORT(SIMODE0);
2424 s1 = GETPORT(SIMODE1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002426 shost_printk(KERN_DEBUG, shpnt,
2427 "enabled interrupts (%s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
2428 (s0 & ENSELDO) ? "ENSELDO " : "",
2429 (s0 & ENSELDI) ? "ENSELDI " : "",
2430 (s0 & ENSELINGO) ? "ENSELINGO " : "",
2431 (s0 & ENSWRAP) ? "ENSWRAP " : "",
2432 (s0 & ENSDONE) ? "ENSDONE " : "",
2433 (s0 & ENSPIORDY) ? "ENSPIORDY " : "",
2434 (s0 & ENDMADONE) ? "ENDMADONE " : "",
2435 (s1 & ENSELTIMO) ? "ENSELTIMO " : "",
2436 (s1 & ENATNTARG) ? "ENATNTARG " : "",
2437 (s1 & ENPHASEMIS) ? "ENPHASEMIS " : "",
2438 (s1 & ENBUSFREE) ? "ENBUSFREE " : "",
2439 (s1 & ENSCSIPERR) ? "ENSCSIPERR " : "",
2440 (s1 & ENPHASECHG) ? "ENPHASECHG " : "",
2441 (s1 & ENREQINIT) ? "ENREQINIT " : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442}
2443
2444/*
2445 * Show the command data of a command
2446 */
2447static void show_command(Scsi_Cmnd *ptr)
2448{
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002449 scsi_print_command(ptr);
2450 scmd_printk(KERN_DEBUG, ptr,
2451 "request_bufflen=%d; resid=%d; "
2452 "phase |%s%s%s%s%s%s%s%s%s; next=0x%p",
2453 scsi_bufflen(ptr), scsi_get_resid(ptr),
2454 (ptr->SCp.phase & not_issued) ? "not issued|" : "",
2455 (ptr->SCp.phase & selecting) ? "selecting|" : "",
2456 (ptr->SCp.phase & identified) ? "identified|" : "",
2457 (ptr->SCp.phase & disconnected) ? "disconnected|" : "",
2458 (ptr->SCp.phase & completed) ? "completed|" : "",
2459 (ptr->SCp.phase & spiordy) ? "spiordy|" : "",
2460 (ptr->SCp.phase & syncneg) ? "syncneg|" : "",
2461 (ptr->SCp.phase & aborted) ? "aborted|" : "",
2462 (ptr->SCp.phase & resetted) ? "resetted|" : "",
2463 (SCDATA(ptr)) ? SCNEXT(ptr) : NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464}
2465
2466/*
2467 * Dump the queued data
2468 */
2469static void show_queues(struct Scsi_Host *shpnt)
2470{
2471 Scsi_Cmnd *ptr;
2472 unsigned long flags;
2473
2474 DO_LOCK(flags);
2475 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2476 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2477 show_command(ptr);
2478 DO_UNLOCK(flags);
2479
2480 printk(KERN_DEBUG "current_SC:\n");
2481 if (CURRENT_SC)
2482 show_command(CURRENT_SC);
2483 else
2484 printk(KERN_DEBUG "none\n");
2485
2486 printk(KERN_DEBUG "disconnected_SC:\n");
2487 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2488 show_command(ptr);
2489
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 disp_enintr(shpnt);
2491}
2492
Al Viro275084c2013-03-31 03:12:15 -04002493static void get_command(struct seq_file *m, Scsi_Cmnd * ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002494{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495 int i;
2496
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002497 seq_printf(m, "%p: target=%d; lun=%d; cmnd=( ",
Hannes Reinecke9cb78c12014-06-25 15:27:36 +02002498 ptr, ptr->device->id, (u8)ptr->device->lun);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499
2500 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002501 seq_printf(m, "0x%02x ", ptr->cmnd[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002503 seq_printf(m, "); resid=%d; residual=%d; buffers=%d; phase |",
Boaz Harrosh23385452007-07-29 22:29:02 +03002504 scsi_get_resid(ptr), ptr->SCp.this_residual,
2505 ptr->SCp.buffers_residual);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002506
2507 if (ptr->SCp.phase & not_issued)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002508 seq_puts(m, "not issued|");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509 if (ptr->SCp.phase & selecting)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002510 seq_puts(m, "selecting|");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511 if (ptr->SCp.phase & disconnected)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002512 seq_puts(m, "disconnected|");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513 if (ptr->SCp.phase & aborted)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002514 seq_puts(m, "aborted|");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 if (ptr->SCp.phase & identified)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002516 seq_puts(m, "identified|");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517 if (ptr->SCp.phase & completed)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002518 seq_puts(m, "completed|");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002519 if (ptr->SCp.phase & spiordy)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002520 seq_puts(m, "spiordy|");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002521 if (ptr->SCp.phase & syncneg)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002522 seq_puts(m, "syncneg|");
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002523 seq_printf(m, "; next=0x%p\n", SCNEXT(ptr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524}
2525
Al Viro275084c2013-03-31 03:12:15 -04002526static void get_ports(struct seq_file *m, struct Scsi_Host *shpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528 int s;
2529
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002530 seq_printf(m, "\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002531
2532 s = GETPORT(SCSISEQ);
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002533 seq_puts(m, "SCSISEQ( ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534 if (s & TEMODEO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002535 seq_puts(m, "TARGET MODE ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536 if (s & ENSELO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002537 seq_puts(m, "SELO ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538 if (s & ENSELI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002539 seq_puts(m, "SELI ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540 if (s & ENRESELI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002541 seq_puts(m, "RESELI ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 if (s & ENAUTOATNO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002543 seq_puts(m, "AUTOATNO ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 if (s & ENAUTOATNI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002545 seq_puts(m, "AUTOATNI ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546 if (s & ENAUTOATNP)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002547 seq_puts(m, "AUTOATNP ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 if (s & SCSIRSTO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002549 seq_puts(m, "SCSIRSTO ");
2550 seq_puts(m, ");");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002552 seq_puts(m, " SCSISIG(");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553 s = GETPORT(SCSISIG);
2554 switch (s & P_MASK) {
2555 case P_DATAO:
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002556 seq_puts(m, "DATA OUT");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557 break;
2558 case P_DATAI:
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002559 seq_puts(m, "DATA IN");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560 break;
2561 case P_CMD:
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002562 seq_puts(m, "COMMAND");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563 break;
2564 case P_STATUS:
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002565 seq_puts(m, "STATUS");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566 break;
2567 case P_MSGO:
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002568 seq_puts(m, "MESSAGE OUT");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569 break;
2570 case P_MSGI:
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002571 seq_puts(m, "MESSAGE IN");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572 break;
2573 default:
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002574 seq_puts(m, "*invalid*");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575 break;
2576 }
2577
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002578 seq_puts(m, "); ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002580 seq_printf(m, "INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002582 seq_puts(m, "SSTAT( ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583 s = GETPORT(SSTAT0);
2584 if (s & TARGET)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002585 seq_puts(m, "TARGET ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586 if (s & SELDO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002587 seq_puts(m, "SELDO ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 if (s & SELDI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002589 seq_puts(m, "SELDI ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590 if (s & SELINGO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002591 seq_puts(m, "SELINGO ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002592 if (s & SWRAP)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002593 seq_puts(m, "SWRAP ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002594 if (s & SDONE)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002595 seq_puts(m, "SDONE ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596 if (s & SPIORDY)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002597 seq_puts(m, "SPIORDY ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598 if (s & DMADONE)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002599 seq_puts(m, "DMADONE ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600
2601 s = GETPORT(SSTAT1);
2602 if (s & SELTO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002603 seq_puts(m, "SELTO ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604 if (s & ATNTARG)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002605 seq_puts(m, "ATNTARG ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606 if (s & SCSIRSTI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002607 seq_puts(m, "SCSIRSTI ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608 if (s & PHASEMIS)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002609 seq_puts(m, "PHASEMIS ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610 if (s & BUSFREE)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002611 seq_puts(m, "BUSFREE ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612 if (s & SCSIPERR)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002613 seq_puts(m, "SCSIPERR ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002614 if (s & PHASECHG)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002615 seq_puts(m, "PHASECHG ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002616 if (s & REQINIT)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002617 seq_puts(m, "REQINIT ");
2618 seq_puts(m, "); ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619
2620
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002621 seq_puts(m, "SSTAT( ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622
2623 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2624
2625 if (s & TARGET)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002626 seq_puts(m, "TARGET ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627 if (s & SELDO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002628 seq_puts(m, "SELDO ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629 if (s & SELDI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002630 seq_puts(m, "SELDI ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002631 if (s & SELINGO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002632 seq_puts(m, "SELINGO ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002633 if (s & SWRAP)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002634 seq_puts(m, "SWRAP ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635 if (s & SDONE)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002636 seq_puts(m, "SDONE ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637 if (s & SPIORDY)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002638 seq_puts(m, "SPIORDY ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639 if (s & DMADONE)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002640 seq_puts(m, "DMADONE ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641
2642 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2643
2644 if (s & SELTO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002645 seq_puts(m, "SELTO ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646 if (s & ATNTARG)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002647 seq_puts(m, "ATNTARG ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648 if (s & SCSIRSTI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002649 seq_puts(m, "SCSIRSTI ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650 if (s & PHASEMIS)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002651 seq_puts(m, "PHASEMIS ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 if (s & BUSFREE)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002653 seq_puts(m, "BUSFREE ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654 if (s & SCSIPERR)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002655 seq_puts(m, "SCSIPERR ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656 if (s & PHASECHG)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002657 seq_puts(m, "PHASECHG ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002658 if (s & REQINIT)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002659 seq_puts(m, "REQINIT ");
2660 seq_puts(m, "); ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002662 seq_puts(m, "SXFRCTL0( ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002663
2664 s = GETPORT(SXFRCTL0);
2665 if (s & SCSIEN)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002666 seq_puts(m, "SCSIEN ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 if (s & DMAEN)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002668 seq_puts(m, "DMAEN ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669 if (s & CH1)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002670 seq_puts(m, "CH1 ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002671 if (s & CLRSTCNT)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002672 seq_puts(m, "CLRSTCNT ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 if (s & SPIOEN)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002674 seq_puts(m, "SPIOEN ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675 if (s & CLRCH1)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002676 seq_puts(m, "CLRCH1 ");
2677 seq_puts(m, "); ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002679 seq_puts(m, "SIGNAL( ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680
2681 s = GETPORT(SCSISIG);
2682 if (s & SIG_ATNI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002683 seq_puts(m, "ATNI ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684 if (s & SIG_SELI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002685 seq_puts(m, "SELI ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686 if (s & SIG_BSYI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002687 seq_puts(m, "BSYI ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002688 if (s & SIG_REQI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002689 seq_puts(m, "REQI ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002690 if (s & SIG_ACKI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002691 seq_puts(m, "ACKI ");
2692 seq_puts(m, "); ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002693
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002694 seq_printf(m, "SELID(%02x), ", GETPORT(SELID));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002695
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002696 seq_printf(m, "STCNT(%d), ", GETSTCNT());
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002698 seq_puts(m, "SSTAT2( ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699
2700 s = GETPORT(SSTAT2);
2701 if (s & SOFFSET)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002702 seq_puts(m, "SOFFSET ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703 if (s & SEMPTY)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002704 seq_puts(m, "SEMPTY ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705 if (s & SFULL)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002706 seq_puts(m, "SFULL ");
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002707 seq_printf(m, "); SFCNT (%d); ", s & (SFULL | SFCNT));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708
2709 s = GETPORT(SSTAT3);
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002710 seq_printf(m, "SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002712 seq_puts(m, "SSTAT4( ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713 s = GETPORT(SSTAT4);
2714 if (s & SYNCERR)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002715 seq_puts(m, "SYNCERR ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716 if (s & FWERR)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002717 seq_puts(m, "FWERR ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718 if (s & FRERR)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002719 seq_puts(m, "FRERR ");
2720 seq_puts(m, "); ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002722 seq_puts(m, "DMACNTRL0( ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723 s = GETPORT(DMACNTRL0);
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002724 seq_printf(m, "%s ", s & _8BIT ? "8BIT" : "16BIT");
2725 seq_printf(m, "%s ", s & DMA ? "DMA" : "PIO");
2726 seq_printf(m, "%s ", s & WRITE_READ ? "WRITE" : "READ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002727 if (s & ENDMA)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002728 seq_puts(m, "ENDMA ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729 if (s & INTEN)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002730 seq_puts(m, "INTEN ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731 if (s & RSTFIFO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002732 seq_puts(m, "RSTFIFO ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733 if (s & SWINT)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002734 seq_puts(m, "SWINT ");
2735 seq_puts(m, "); ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002736
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002737 seq_puts(m, "DMASTAT( ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002738 s = GETPORT(DMASTAT);
2739 if (s & ATDONE)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002740 seq_puts(m, "ATDONE ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002741 if (s & WORDRDY)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002742 seq_puts(m, "WORDRDY ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743 if (s & DFIFOFULL)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002744 seq_puts(m, "DFIFOFULL ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745 if (s & DFIFOEMP)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002746 seq_puts(m, "DFIFOEMP ");
2747 seq_puts(m, ")\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002749 seq_puts(m, "enabled interrupts( ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750
2751 s = GETPORT(SIMODE0);
2752 if (s & ENSELDO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002753 seq_puts(m, "ENSELDO ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754 if (s & ENSELDI)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002755 seq_puts(m, "ENSELDI ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756 if (s & ENSELINGO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002757 seq_puts(m, "ENSELINGO ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758 if (s & ENSWRAP)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002759 seq_puts(m, "ENSWRAP ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760 if (s & ENSDONE)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002761 seq_puts(m, "ENSDONE ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762 if (s & ENSPIORDY)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002763 seq_puts(m, "ENSPIORDY ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002764 if (s & ENDMADONE)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002765 seq_puts(m, "ENDMADONE ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766
2767 s = GETPORT(SIMODE1);
2768 if (s & ENSELTIMO)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002769 seq_puts(m, "ENSELTIMO ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 if (s & ENATNTARG)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002771 seq_puts(m, "ENATNTARG ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772 if (s & ENPHASEMIS)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002773 seq_puts(m, "ENPHASEMIS ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774 if (s & ENBUSFREE)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002775 seq_puts(m, "ENBUSFREE ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776 if (s & ENSCSIPERR)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002777 seq_puts(m, "ENSCSIPERR ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778 if (s & ENPHASECHG)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002779 seq_puts(m, "ENPHASECHG ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 if (s & ENREQINIT)
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002781 seq_puts(m, "ENREQINIT ");
2782 seq_puts(m, ")\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783}
2784
Al Viro275084c2013-03-31 03:12:15 -04002785static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786{
2787 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
2788 return -EINVAL;
2789
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790#if defined(AHA152X_STAT)
2791 if(length>13 && strncmp("reset", buffer+8, 5)==0) {
2792 int i;
2793
2794 HOSTDATA(shpnt)->total_commands=0;
2795 HOSTDATA(shpnt)->disconnections=0;
2796 HOSTDATA(shpnt)->busfree_without_any_action=0;
2797 HOSTDATA(shpnt)->busfree_without_old_command=0;
2798 HOSTDATA(shpnt)->busfree_without_new_command=0;
2799 HOSTDATA(shpnt)->busfree_without_done_command=0;
2800 HOSTDATA(shpnt)->busfree_with_check_condition=0;
2801 for (i = idle; i<maxstate; i++) {
2802 HOSTDATA(shpnt)->count[i]=0;
2803 HOSTDATA(shpnt)->count_trans[i]=0;
2804 HOSTDATA(shpnt)->time[i]=0;
2805 }
2806
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002807 shost_printk(KERN_INFO, shpnt, "aha152x: stats reset.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808
2809 } else
2810#endif
2811 {
2812 return -EINVAL;
2813 }
2814
2815
2816 return length;
2817}
2818
Al Viro275084c2013-03-31 03:12:15 -04002819static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820{
2821 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822 Scsi_Cmnd *ptr;
2823 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002825 seq_puts(m, AHA152X_REVID "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002826
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002827 seq_printf(m, "ioports 0x%04lx to 0x%04lx\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002829 seq_printf(m, "interrupt 0x%02x\n", shpnt->irq);
2830 seq_printf(m, "disconnection/reconnection %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002831 RECONNECT ? "enabled" : "disabled");
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002832 seq_printf(m, "parity checking %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833 PARITY ? "enabled" : "disabled");
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002834 seq_printf(m, "synchronous transfers %s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835 SYNCHRONOUS ? "enabled" : "disabled");
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002836 seq_printf(m, "%d commands currently queued\n", HOSTDATA(shpnt)->commands);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837
2838 if(SYNCHRONOUS) {
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002839 seq_puts(m, "synchronously operating targets (tick=50 ns):\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840 for (i = 0; i < 8; i++)
2841 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002842 seq_printf(m, "target %d: period %dT/%dns; req/ack offset %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002843 i,
2844 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
2845 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
2846 HOSTDATA(shpnt)->syncrate[i] & 0x0f);
2847 }
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002848 seq_puts(m, "\nqueue status:\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849 DO_LOCK(flags);
2850 if (ISSUE_SC) {
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002851 seq_puts(m, "not yet issued commands:\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
Al Viro275084c2013-03-31 03:12:15 -04002853 get_command(m, ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 } else
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002855 seq_puts(m, "no not yet issued commands\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856 DO_UNLOCK(flags);
2857
2858 if (CURRENT_SC) {
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002859 seq_puts(m, "current command:\n");
Al Viro275084c2013-03-31 03:12:15 -04002860 get_command(m, CURRENT_SC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861 } else
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002862 seq_puts(m, "no current command\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863
2864 if (DISCONNECTED_SC) {
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002865 seq_puts(m, "disconnected commands:\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
Al Viro275084c2013-03-31 03:12:15 -04002867 get_command(m, ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868 } else
Rasmus Villemoesee7c7272014-12-03 00:10:51 +01002869 seq_puts(m, "no disconnected commands\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870
Al Viro275084c2013-03-31 03:12:15 -04002871 get_ports(m, shpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872
2873#if defined(AHA152X_STAT)
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002874 seq_printf(m, "statistics:\n"
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002875 "total commands: %d\n"
2876 "disconnections: %d\n"
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877 "busfree with check condition: %d\n"
2878 "busfree without old command: %d\n"
2879 "busfree without new command: %d\n"
2880 "busfree without done command: %d\n"
2881 "busfree without any action: %d\n"
2882 "state "
2883 "transitions "
2884 "count "
2885 "time\n",
2886 HOSTDATA(shpnt)->total_commands,
2887 HOSTDATA(shpnt)->disconnections,
2888 HOSTDATA(shpnt)->busfree_with_check_condition,
2889 HOSTDATA(shpnt)->busfree_without_old_command,
2890 HOSTDATA(shpnt)->busfree_without_new_command,
2891 HOSTDATA(shpnt)->busfree_without_done_command,
2892 HOSTDATA(shpnt)->busfree_without_any_action);
2893 for(i=0; i<maxstate; i++) {
Rasmus Villemoes0c3de382014-12-03 00:10:49 +01002894 seq_printf(m, "%-10s %-12d %-12d %-12ld\n",
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02002895 states[i].name,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002896 HOSTDATA(shpnt)->count_trans[i],
2897 HOSTDATA(shpnt)->count[i],
2898 HOSTDATA(shpnt)->time[i]);
2899 }
2900#endif
Al Viro275084c2013-03-31 03:12:15 -04002901 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902}
2903
Boaz Harroshb1ee0792007-07-29 22:18:20 +03002904static int aha152x_adjust_queue(struct scsi_device *device)
2905{
2906 blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
2907 return 0;
2908}
2909
Christoph Hellwigd0be4a7d2005-10-31 18:31:40 +01002910static struct scsi_host_template aha152x_driver_template = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002911 .module = THIS_MODULE,
2912 .name = AHA152X_REVID,
2913 .proc_name = "aha152x",
Al Viro275084c2013-03-31 03:12:15 -04002914 .show_info = aha152x_show_info,
2915 .write_info = aha152x_set_info,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916 .queuecommand = aha152x_queue,
2917 .eh_abort_handler = aha152x_abort,
2918 .eh_device_reset_handler = aha152x_device_reset,
2919 .eh_bus_reset_handler = aha152x_bus_reset,
2920 .eh_host_reset_handler = aha152x_host_reset,
2921 .bios_param = aha152x_biosparam,
2922 .can_queue = 1,
2923 .this_id = 7,
2924 .sg_tablesize = SG_ALL,
2925 .cmd_per_lun = 1,
2926 .use_clustering = DISABLE_CLUSTERING,
Boaz Harroshb1ee0792007-07-29 22:18:20 +03002927 .slave_alloc = aha152x_adjust_queue,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002928};
2929
2930#if !defined(PCMCIA)
2931static int setup_count;
2932static struct aha152x_setup setup[2];
2933
2934/* possible i/o addresses for the AIC-6260; default first */
2935static unsigned short ports[] = { 0x340, 0x140 };
2936
2937#if !defined(SKIP_BIOSTEST)
2938/* possible locations for the Adaptec BIOS; defaults first */
2939static unsigned int addresses[] =
2940{
2941 0xdc000, /* default first */
2942 0xc8000,
2943 0xcc000,
2944 0xd0000,
2945 0xd4000,
2946 0xd8000,
2947 0xe0000,
2948 0xeb800, /* VTech Platinum SMP */
2949 0xf0000,
2950};
2951
2952/* signatures for various AIC-6[23]60 based controllers.
2953 The point in detecting signatures is to avoid useless and maybe
2954 harmful probes on ports. I'm not sure that all listed boards pass
2955 auto-configuration. For those which fail the BIOS signature is
2956 obsolete, because user intervention to supply the configuration is
2957 needed anyway. May be an information whether or not the BIOS supports
2958 extended translation could be also useful here. */
2959static struct signature {
2960 unsigned char *signature;
2961 int sig_offset;
2962 int sig_length;
2963} signatures[] =
2964{
2965 { "Adaptec AHA-1520 BIOS", 0x102e, 21 },
2966 /* Adaptec 152x */
2967 { "Adaptec AHA-1520B", 0x000b, 17 },
2968 /* Adaptec 152x rev B */
2969 { "Adaptec AHA-1520B", 0x0026, 17 },
2970 /* Iomega Jaz Jet ISA (AIC6370Q) */
2971 { "Adaptec ASW-B626 BIOS", 0x1029, 21 },
2972 /* on-board controller */
2973 { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
2974 /* on-board controller */
2975 { "Adaptec ASW-B626 S2", 0x2e6c, 19 },
2976 /* on-board controller */
2977 { "Adaptec BIOS:AIC-6360", 0x000c, 21 },
2978 /* on-board controller */
2979 { "ScsiPro SP-360 BIOS", 0x2873, 19 },
2980 /* ScsiPro-Controller */
2981 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
2982 /* Gigabyte Local-Bus-SCSI */
2983 { "Adaptec BIOS:AVA-282X", 0x000c, 21 },
2984 /* Adaptec 282x */
2985 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 },
2986 /* IBM Thinkpad Dock II */
2987 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 },
2988 /* IBM Thinkpad Dock II SCSI */
2989 { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
2990 /* DTC 3520A ISA SCSI */
2991};
2992#endif /* !SKIP_BIOSTEST */
2993
2994/*
2995 * Test, if port_base is valid.
2996 *
2997 */
2998static int aha152x_porttest(int io_port)
2999{
3000 int i;
3001
3002 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3003 for (i = 0; i < 16; i++)
3004 SETPORT(io_port + O_STACK, i);
3005
3006 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3007 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3008 ;
3009
3010 return (i == 16);
3011}
3012
3013static int tc1550_porttest(int io_port)
3014{
3015 int i;
3016
3017 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3018 for (i = 0; i < 16; i++)
3019 SETPORT(io_port + O_STACK, i);
3020
3021 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3022 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3023 ;
3024
3025 return (i == 16);
3026}
3027
3028
3029static int checksetup(struct aha152x_setup *setup)
3030{
3031 int i;
3032 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3033 ;
3034
3035 if (i == ARRAY_SIZE(ports))
3036 return 0;
3037
Harvey Harrison9bcf0912008-05-22 15:45:07 -07003038 if (!request_region(setup->io_port, IO_RANGE, "aha152x")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003039 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3040 return 0;
3041 }
3042
3043 if( aha152x_porttest(setup->io_port) ) {
3044 setup->tc1550=0;
3045 } else if( tc1550_porttest(setup->io_port) ) {
3046 setup->tc1550=1;
3047 } else {
3048 release_region(setup->io_port, IO_RANGE);
3049 return 0;
3050 }
3051
3052 release_region(setup->io_port, IO_RANGE);
3053
3054 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3055 return 0;
3056
3057 if ((setup->scsiid < 0) || (setup->scsiid > 7))
3058 return 0;
3059
3060 if ((setup->reconnect < 0) || (setup->reconnect > 1))
3061 return 0;
3062
3063 if ((setup->parity < 0) || (setup->parity > 1))
3064 return 0;
3065
3066 if ((setup->synchronous < 0) || (setup->synchronous > 1))
3067 return 0;
3068
3069 if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3070 return 0;
3071
3072
3073 return 1;
3074}
3075
3076
3077static int __init aha152x_init(void)
3078{
3079 int i, j, ok;
3080#if defined(AUTOCONF)
3081 aha152x_config conf;
3082#endif
3083#ifdef __ISAPNP__
3084 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3085#endif
3086
3087 if ( setup_count ) {
3088 printk(KERN_INFO "aha152x: processing commandline: ");
3089
3090 for (i = 0; i<setup_count; i++) {
3091 if (!checksetup(&setup[i])) {
3092 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3093 printk(KERN_ERR "aha152x: invalid line\n");
3094 }
3095 }
3096 printk("ok\n");
3097 }
3098
3099#if defined(SETUP0)
3100 if (setup_count < ARRAY_SIZE(setup)) {
3101 struct aha152x_setup override = SETUP0;
3102
3103 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3104 if (!checksetup(&override)) {
3105 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3106 override.io_port,
3107 override.irq,
3108 override.scsiid,
3109 override.reconnect,
3110 override.parity,
3111 override.synchronous,
3112 override.delay,
3113 override.ext_trans);
3114 } else
3115 setup[setup_count++] = override;
3116 }
3117 }
3118#endif
3119
3120#if defined(SETUP1)
3121 if (setup_count < ARRAY_SIZE(setup)) {
3122 struct aha152x_setup override = SETUP1;
3123
3124 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3125 if (!checksetup(&override)) {
3126 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3127 override.io_port,
3128 override.irq,
3129 override.scsiid,
3130 override.reconnect,
3131 override.parity,
3132 override.synchronous,
3133 override.delay,
3134 override.ext_trans);
3135 } else
3136 setup[setup_count++] = override;
3137 }
3138 }
3139#endif
3140
3141#if defined(MODULE)
3142 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3143 if(aha152x[0]!=0) {
3144 setup[setup_count].conf = "";
3145 setup[setup_count].io_port = aha152x[0];
3146 setup[setup_count].irq = aha152x[1];
3147 setup[setup_count].scsiid = aha152x[2];
3148 setup[setup_count].reconnect = aha152x[3];
3149 setup[setup_count].parity = aha152x[4];
3150 setup[setup_count].synchronous = aha152x[5];
3151 setup[setup_count].delay = aha152x[6];
3152 setup[setup_count].ext_trans = aha152x[7];
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02003153 } else if (io[0] != 0 || irq[0] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154 if(io[0]!=0) setup[setup_count].io_port = io[0];
3155 if(irq[0]!=0) setup[setup_count].irq = irq[0];
3156
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02003157 setup[setup_count].scsiid = scsiid[0];
3158 setup[setup_count].reconnect = reconnect[0];
3159 setup[setup_count].parity = parity[0];
3160 setup[setup_count].synchronous = sync[0];
3161 setup[setup_count].delay = delay[0];
3162 setup[setup_count].ext_trans = exttrans[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163 }
3164
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02003165 if (checksetup(&setup[setup_count]))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003166 setup_count++;
3167 else
3168 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",
3169 setup[setup_count].io_port,
3170 setup[setup_count].irq,
3171 setup[setup_count].scsiid,
3172 setup[setup_count].reconnect,
3173 setup[setup_count].parity,
3174 setup[setup_count].synchronous,
3175 setup[setup_count].delay,
3176 setup[setup_count].ext_trans);
3177 }
3178
3179 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3180 if(aha152x1[0]!=0) {
3181 setup[setup_count].conf = "";
3182 setup[setup_count].io_port = aha152x1[0];
3183 setup[setup_count].irq = aha152x1[1];
3184 setup[setup_count].scsiid = aha152x1[2];
3185 setup[setup_count].reconnect = aha152x1[3];
3186 setup[setup_count].parity = aha152x1[4];
3187 setup[setup_count].synchronous = aha152x1[5];
3188 setup[setup_count].delay = aha152x1[6];
3189 setup[setup_count].ext_trans = aha152x1[7];
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02003190 } else if (io[1] != 0 || irq[1] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003191 if(io[1]!=0) setup[setup_count].io_port = io[1];
3192 if(irq[1]!=0) setup[setup_count].irq = irq[1];
3193
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02003194 setup[setup_count].scsiid = scsiid[1];
3195 setup[setup_count].reconnect = reconnect[1];
3196 setup[setup_count].parity = parity[1];
3197 setup[setup_count].synchronous = sync[1];
3198 setup[setup_count].delay = delay[1];
3199 setup[setup_count].ext_trans = exttrans[1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003200 }
3201 if (checksetup(&setup[setup_count]))
3202 setup_count++;
3203 else
3204 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",
3205 setup[setup_count].io_port,
3206 setup[setup_count].irq,
3207 setup[setup_count].scsiid,
3208 setup[setup_count].reconnect,
3209 setup[setup_count].parity,
3210 setup[setup_count].synchronous,
3211 setup[setup_count].delay,
3212 setup[setup_count].ext_trans);
3213 }
3214#endif
3215
3216#ifdef __ISAPNP__
3217 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3218 while ( setup_count<ARRAY_SIZE(setup) &&
3219 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3220 if (pnp_device_attach(dev) < 0)
3221 continue;
3222
3223 if (pnp_activate_dev(dev) < 0) {
3224 pnp_device_detach(dev);
3225 continue;
3226 }
3227
3228 if (!pnp_port_valid(dev, 0)) {
3229 pnp_device_detach(dev);
3230 continue;
3231 }
3232
3233 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3234 pnp_device_detach(dev);
3235 continue;
3236 }
3237
3238 setup[setup_count].io_port = pnp_port_start(dev, 0);
3239 setup[setup_count].irq = pnp_irq(dev, 0);
3240 setup[setup_count].scsiid = 7;
3241 setup[setup_count].reconnect = 1;
3242 setup[setup_count].parity = 1;
3243 setup[setup_count].synchronous = 1;
3244 setup[setup_count].delay = DELAY_DEFAULT;
3245 setup[setup_count].ext_trans = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003246#if defined(__ISAPNP__)
3247 pnpdev[setup_count] = dev;
3248#endif
3249 printk (KERN_INFO
3250 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3251 setup[setup_count].io_port, setup[setup_count].irq);
3252 setup_count++;
3253 }
3254 }
3255#endif
3256
3257#if defined(AUTOCONF)
3258 if (setup_count<ARRAY_SIZE(setup)) {
3259#if !defined(SKIP_BIOSTEST)
3260 ok = 0;
3261 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3262 void __iomem *p = ioremap(addresses[i], 0x4000);
3263 if (!p)
3264 continue;
3265 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3266 ok = check_signature(p + signatures[j].sig_offset,
3267 signatures[j].signature, signatures[j].sig_length);
3268 iounmap(p);
3269 }
3270 if (!ok && setup_count == 0)
James Bottomleyad2fa422008-05-10 08:33:58 -05003271 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272
3273 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3274#else
3275 printk(KERN_INFO "aha152x: ");
3276#endif /* !SKIP_BIOSTEST */
3277
3278 ok = 0;
3279 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3280 if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3281 continue;
3282
Harvey Harrison9bcf0912008-05-22 15:45:07 -07003283 if (!request_region(ports[i], IO_RANGE, "aha152x")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003284 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3285 continue;
3286 }
3287
3288 if (aha152x_porttest(ports[i])) {
3289 setup[setup_count].tc1550 = 0;
3290
3291 conf.cf_port =
3292 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3293 } else if (tc1550_porttest(ports[i])) {
3294 setup[setup_count].tc1550 = 1;
3295
3296 conf.cf_port =
3297 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3298 } else {
3299 release_region(ports[i], IO_RANGE);
3300 continue;
3301 }
3302
3303 release_region(ports[i], IO_RANGE);
3304
3305 ok++;
3306 setup[setup_count].io_port = ports[i];
3307 setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3308 setup[setup_count].scsiid = conf.cf_id;
3309 setup[setup_count].reconnect = conf.cf_tardisc;
3310 setup[setup_count].parity = !conf.cf_parity;
3311 setup[setup_count].synchronous = conf.cf_syncneg;
3312 setup[setup_count].delay = DELAY_DEFAULT;
3313 setup[setup_count].ext_trans = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314 setup_count++;
3315
3316 }
3317
3318 if (ok)
3319 printk("auto configuration: ok, ");
3320 }
3321#endif
3322
3323 printk("%d controller(s) configured\n", setup_count);
3324
3325 for (i=0; i<setup_count; i++) {
3326 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3327 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3328
3329 if( !shpnt ) {
3330 release_region(setup[i].io_port, IO_RANGE);
3331#if defined(__ISAPNP__)
3332 } else if( pnpdev[i] ) {
3333 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3334 pnpdev[i]=NULL;
3335#endif
3336 }
3337 } else {
3338 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3339 }
3340
3341#if defined(__ISAPNP__)
3342 if( pnpdev[i] )
3343 pnp_device_detach(pnpdev[i]);
3344#endif
3345 }
3346
James Bottomleyad2fa422008-05-10 08:33:58 -05003347 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003348}
3349
3350static void __exit aha152x_exit(void)
3351{
James Bottomley64976a02008-05-10 14:08:40 -05003352 struct aha152x_hostdata *hd, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003353
James Bottomley64976a02008-05-10 14:08:40 -05003354 list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
James Bottomley5fcda422006-09-14 17:04:58 -05003355 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3356
3357 aha152x_release(shost);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003358 }
3359}
3360
3361module_init(aha152x_init);
3362module_exit(aha152x_exit);
3363
3364#if !defined(MODULE)
3365static int __init aha152x_setup(char *str)
3366{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003367 int ints[10];
Hannes Reineckef75ae8e2014-10-24 14:26:43 +02003368
Linus Torvalds1da177e2005-04-16 15:20:36 -07003369 get_options(str, ARRAY_SIZE(ints), ints);
3370
3371 if(setup_count>=ARRAY_SIZE(setup)) {
3372 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3373 return 1;
3374 }
3375
3376 setup[setup_count].conf = str;
3377 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340;
3378 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11;
3379 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7;
3380 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1;
3381 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1;
3382 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3383 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3384 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003385 if (ints[0] > 8) { /*}*/
3386 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3387 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003388 } else {
3389 setup_count++;
3390 return 0;
3391 }
3392
3393 return 1;
3394}
3395__setup("aha152x=", aha152x_setup);
3396#endif
3397
3398#endif /* !PCMCIA */