xref: /linux/drivers/scsi/aic7xxx/aic7xxx_osm.c (revision 06d07429858317ded2db7986113a9e0129cd599b)
1 
2 /*
3  * Adaptec AIC7xxx device driver for Linux.
4  *
5  * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic7xxx_osm.c#235 $
6  *
7  * Copyright (c) 1994 John Aycock
8  *   The University of Calgary Department of Computer Science.
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2, or (at your option)
13  * any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; see the file COPYING.  If not, write to
22  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
23  *
24  * Sources include the Adaptec 1740 driver (aha1740.c), the Ultrastor 24F
25  * driver (ultrastor.c), various Linux kernel source, the Adaptec EISA
26  * config file (!adp7771.cfg), the Adaptec AHA-2740A Series User's Guide,
27  * the Linux Kernel Hacker's Guide, Writing a SCSI Device Driver for Linux,
28  * the Adaptec 1542 driver (aha1542.c), the Adaptec EISA overlay file
29  * (adp7770.ovl), the Adaptec AHA-2740 Series Technical Reference Manual,
30  * the Adaptec AIC-7770 Data Book, the ANSI SCSI specification, the
31  * ANSI SCSI-2 specification (draft 10c), ...
32  *
33  * --------------------------------------------------------------------------
34  *
35  *  Modifications by Daniel M. Eischen (deischen@iworks.InterWorks.org):
36  *
37  *  Substantially modified to include support for wide and twin bus
38  *  adapters, DMAing of SCBs, tagged queueing, IRQ sharing, bug fixes,
39  *  SCB paging, and other rework of the code.
40  *
41  * --------------------------------------------------------------------------
42  * Copyright (c) 1994-2000 Justin T. Gibbs.
43  * Copyright (c) 2000-2001 Adaptec Inc.
44  * All rights reserved.
45  *
46  * Redistribution and use in source and binary forms, with or without
47  * modification, are permitted provided that the following conditions
48  * are met:
49  * 1. Redistributions of source code must retain the above copyright
50  *    notice, this list of conditions, and the following disclaimer,
51  *    without modification.
52  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
53  *    substantially similar to the "NO WARRANTY" disclaimer below
54  *    ("Disclaimer") and any redistribution must be conditioned upon
55  *    including a substantially similar Disclaimer requirement for further
56  *    binary redistribution.
57  * 3. Neither the names of the above-listed copyright holders nor the names
58  *    of any contributors may be used to endorse or promote products derived
59  *    from this software without specific prior written permission.
60  *
61  * Alternatively, this software may be distributed under the terms of the
62  * GNU General Public License ("GPL") version 2 as published by the Free
63  * Software Foundation.
64  *
65  * NO WARRANTY
66  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
67  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
68  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
69  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
70  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
71  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
72  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
73  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
74  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
75  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
76  * POSSIBILITY OF SUCH DAMAGES.
77  *
78  *---------------------------------------------------------------------------
79  *
80  *  Thanks also go to (in alphabetical order) the following:
81  *
82  *    Rory Bolt     - Sequencer bug fixes
83  *    Jay Estabrook - Initial DEC Alpha support
84  *    Doug Ledford  - Much needed abort/reset bug fixes
85  *    Kai Makisara  - DMAing of SCBs
86  *
87  *  A Boot time option was also added for not resetting the scsi bus.
88  *
89  *    Form:  aic7xxx=extended
90  *           aic7xxx=no_reset
91  *           aic7xxx=verbose
92  *
93  *  Daniel M. Eischen, deischen@iworks.InterWorks.org, 1/23/97
94  *
95  *  Id: aic7xxx.c,v 4.1 1997/06/12 08:23:42 deang Exp
96  */
97 
98 /*
99  * Further driver modifications made by Doug Ledford <dledford@redhat.com>
100  *
101  * Copyright (c) 1997-1999 Doug Ledford
102  *
103  * These changes are released under the same licensing terms as the FreeBSD
104  * driver written by Justin Gibbs.  Please see his Copyright notice above
105  * for the exact terms and conditions covering my changes as well as the
106  * warranty statement.
107  *
108  * Modifications made to the aic7xxx.c,v 4.1 driver from Dan Eischen include
109  * but are not limited to:
110  *
111  *  1: Import of the latest FreeBSD sequencer code for this driver
112  *  2: Modification of kernel code to accommodate different sequencer semantics
113  *  3: Extensive changes throughout kernel portion of driver to improve
114  *     abort/reset processing and error hanndling
115  *  4: Other work contributed by various people on the Internet
116  *  5: Changes to printk information and verbosity selection code
117  *  6: General reliability related changes, especially in IRQ management
118  *  7: Modifications to the default probe/attach order for supported cards
119  *  8: SMP friendliness has been improved
120  *
121  */
122 
123 #include "aic7xxx_osm.h"
124 #include "aic7xxx_inline.h"
125 #include <scsi/scsicam.h>
126 
127 static struct scsi_transport_template *ahc_linux_transport_template = NULL;
128 
129 #include <linux/init.h>		/* __setup */
130 #include <linux/mm.h>		/* For fetching system memory size */
131 #include <linux/blkdev.h>		/* For block_size() */
132 #include <linux/delay.h>	/* For ssleep/msleep */
133 #include <linux/slab.h>
134 
135 
136 /*
137  * Set this to the delay in seconds after SCSI bus reset.
138  * Note, we honor this only for the initial bus reset.
139  * The scsi error recovery code performs its own bus settle
140  * delay handling for error recovery actions.
141  */
142 #ifdef CONFIG_AIC7XXX_RESET_DELAY_MS
143 #define AIC7XXX_RESET_DELAY CONFIG_AIC7XXX_RESET_DELAY_MS
144 #else
145 #define AIC7XXX_RESET_DELAY 5000
146 #endif
147 
148 /*
149  * To change the default number of tagged transactions allowed per-device,
150  * add a line to the lilo.conf file like:
151  * append="aic7xxx=verbose,tag_info:{{32,32,32,32},{32,32,32,32}}"
152  * which will result in the first four devices on the first two
153  * controllers being set to a tagged queue depth of 32.
154  *
155  * The tag_commands is an array of 16 to allow for wide and twin adapters.
156  * Twin adapters will use indexes 0-7 for channel 0, and indexes 8-15
157  * for channel 1.
158  */
159 typedef struct {
160 	uint8_t tag_commands[16];	/* Allow for wide/twin adapters. */
161 } adapter_tag_info_t;
162 
163 /*
164  * Modify this as you see fit for your system.
165  *
166  * 0			tagged queuing disabled
167  * 1 <= n <= 253	n == max tags ever dispatched.
168  *
169  * The driver will throttle the number of commands dispatched to a
170  * device if it returns queue full.  For devices with a fixed maximum
171  * queue depth, the driver will eventually determine this depth and
172  * lock it in (a console message is printed to indicate that a lock
173  * has occurred).  On some devices, queue full is returned for a temporary
174  * resource shortage.  These devices will return queue full at varying
175  * depths.  The driver will throttle back when the queue fulls occur and
176  * attempt to slowly increase the depth over time as the device recovers
177  * from the resource shortage.
178  *
179  * In this example, the first line will disable tagged queueing for all
180  * the devices on the first probed aic7xxx adapter.
181  *
182  * The second line enables tagged queueing with 4 commands/LUN for IDs
183  * (0, 2-11, 13-15), disables tagged queueing for ID 12, and tells the
184  * driver to attempt to use up to 64 tags for ID 1.
185  *
186  * The third line is the same as the first line.
187  *
188  * The fourth line disables tagged queueing for devices 0 and 3.  It
189  * enables tagged queueing for the other IDs, with 16 commands/LUN
190  * for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for
191  * IDs 2, 5-7, and 9-15.
192  */
193 
194 /*
195  * NOTE: The below structure is for reference only, the actual structure
196  *       to modify in order to change things is just below this comment block.
197 adapter_tag_info_t aic7xxx_tag_info[] =
198 {
199 	{{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
200 	{{4, 64, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4}},
201 	{{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
202 	{{0, 16, 4, 0, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}}
203 };
204 */
205 
206 #ifdef CONFIG_AIC7XXX_CMDS_PER_DEVICE
207 #define AIC7XXX_CMDS_PER_DEVICE CONFIG_AIC7XXX_CMDS_PER_DEVICE
208 #else
209 #define AIC7XXX_CMDS_PER_DEVICE AHC_MAX_QUEUE
210 #endif
211 
212 #define AIC7XXX_CONFIGED_TAG_COMMANDS {					\
213 	AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,		\
214 	AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,		\
215 	AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,		\
216 	AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,		\
217 	AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,		\
218 	AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,		\
219 	AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE,		\
220 	AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE		\
221 }
222 
223 /*
224  * By default, use the number of commands specified by
225  * the users kernel configuration.
226  */
227 static adapter_tag_info_t aic7xxx_tag_info[] =
228 {
229 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
230 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
231 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
232 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
233 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
234 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
235 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
236 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
237 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
238 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
239 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
240 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
241 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
242 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
243 	{AIC7XXX_CONFIGED_TAG_COMMANDS},
244 	{AIC7XXX_CONFIGED_TAG_COMMANDS}
245 };
246 
247 /*
248  * There should be a specific return value for this in scsi.h, but
249  * it seems that most drivers ignore it.
250  */
251 #define DID_UNDERFLOW   DID_ERROR
252 
253 void
ahc_print_path(struct ahc_softc * ahc,struct scb * scb)254 ahc_print_path(struct ahc_softc *ahc, struct scb *scb)
255 {
256 	printk("(scsi%d:%c:%d:%d): ",
257 	       ahc->platform_data->host->host_no,
258 	       scb != NULL ? SCB_GET_CHANNEL(ahc, scb) : 'X',
259 	       scb != NULL ? SCB_GET_TARGET(ahc, scb) : -1,
260 	       scb != NULL ? SCB_GET_LUN(scb) : -1);
261 }
262 
263 /*
264  * XXX - these options apply unilaterally to _all_ 274x/284x/294x
265  *       cards in the system.  This should be fixed.  Exceptions to this
266  *       rule are noted in the comments.
267  */
268 
269 /*
270  * Skip the scsi bus reset.  Non 0 make us skip the reset at startup.  This
271  * has no effect on any later resets that might occur due to things like
272  * SCSI bus timeouts.
273  */
274 static uint32_t aic7xxx_no_reset;
275 
276 /*
277  * Should we force EXTENDED translation on a controller.
278  *     0 == Use whatever is in the SEEPROM or default to off
279  *     1 == Use whatever is in the SEEPROM or default to on
280  */
281 static uint32_t aic7xxx_extended;
282 
283 /*
284  * PCI bus parity checking of the Adaptec controllers.  This is somewhat
285  * dubious at best.  To my knowledge, this option has never actually
286  * solved a PCI parity problem, but on certain machines with broken PCI
287  * chipset configurations where stray PCI transactions with bad parity are
288  * the norm rather than the exception, the error messages can be overwhelming.
289  * It's included in the driver for completeness.
290  *   0	   = Shut off PCI parity check
291  *   non-0 = reverse polarity pci parity checking
292  */
293 static uint32_t aic7xxx_pci_parity = ~0;
294 
295 /*
296  * There are lots of broken chipsets in the world.  Some of them will
297  * violate the PCI spec when we issue byte sized memory writes to our
298  * controller.  I/O mapped register access, if allowed by the given
299  * platform, will work in almost all cases.
300  */
301 uint32_t aic7xxx_allow_memio = ~0;
302 
303 /*
304  * So that we can set how long each device is given as a selection timeout.
305  * The table of values goes like this:
306  *   0 - 256ms
307  *   1 - 128ms
308  *   2 - 64ms
309  *   3 - 32ms
310  * We default to 256ms because some older devices need a longer time
311  * to respond to initial selection.
312  */
313 static uint32_t aic7xxx_seltime;
314 
315 /*
316  * Certain devices do not perform any aging on commands.  Should the
317  * device be saturated by commands in one portion of the disk, it is
318  * possible for transactions on far away sectors to never be serviced.
319  * To handle these devices, we can periodically send an ordered tag to
320  * force all outstanding transactions to be serviced prior to a new
321  * transaction.
322  */
323 static uint32_t aic7xxx_periodic_otag;
324 
325 /*
326  * Module information and settable options.
327  */
328 static char *aic7xxx = NULL;
329 
330 MODULE_AUTHOR("Maintainer: Hannes Reinecke <hare@suse.de>");
331 MODULE_DESCRIPTION("Adaptec AIC77XX/78XX SCSI Host Bus Adapter driver");
332 MODULE_LICENSE("Dual BSD/GPL");
333 MODULE_VERSION(AIC7XXX_DRIVER_VERSION);
334 module_param(aic7xxx, charp, 0444);
335 MODULE_PARM_DESC(aic7xxx,
336 "period-delimited options string:\n"
337 "	verbose			Enable verbose/diagnostic logging\n"
338 "	allow_memio		Allow device registers to be memory mapped\n"
339 "	debug			Bitmask of debug values to enable\n"
340 "	no_probe		Toggle EISA/VLB controller probing\n"
341 "	probe_eisa_vl		Toggle EISA/VLB controller probing\n"
342 "	no_reset		Suppress initial bus resets\n"
343 "	extended		Enable extended geometry on all controllers\n"
344 "	periodic_otag		Send an ordered tagged transaction\n"
345 "				periodically to prevent tag starvation.\n"
346 "				This may be required by some older disk\n"
347 "				drives or RAID arrays.\n"
348 "	tag_info:<tag_str>	Set per-target tag depth\n"
349 "	global_tag_depth:<int>	Global tag depth for every target\n"
350 "				on every bus\n"
351 "	seltime:<int>		Selection Timeout\n"
352 "				(0/256ms,1/128ms,2/64ms,3/32ms)\n"
353 "\n"
354 "	Sample modprobe configuration file:\n"
355 "	#	Toggle EISA/VLB probing\n"
356 "	#	Set tag depth on Controller 1/Target 1 to 10 tags\n"
357 "	#	Shorten the selection timeout to 128ms\n"
358 "\n"
359 "	options aic7xxx 'aic7xxx=probe_eisa_vl.tag_info:{{}.{.10}}.seltime:1'\n"
360 );
361 
362 static void ahc_linux_handle_scsi_status(struct ahc_softc *,
363 					 struct scsi_device *,
364 					 struct scb *);
365 static void ahc_linux_queue_cmd_complete(struct ahc_softc *ahc,
366 					 struct scsi_cmnd *cmd);
367 static void ahc_linux_freeze_simq(struct ahc_softc *ahc);
368 static void ahc_linux_release_simq(struct ahc_softc *ahc);
369 static int  ahc_linux_queue_recovery_cmd(struct scsi_device *sdev,
370 					 struct scsi_cmnd *cmd);
371 static void ahc_linux_initialize_scsi_bus(struct ahc_softc *ahc);
372 static u_int ahc_linux_user_tagdepth(struct ahc_softc *ahc,
373 				     struct ahc_devinfo *devinfo);
374 static void ahc_linux_device_queue_depth(struct scsi_device *);
375 static int ahc_linux_run_command(struct ahc_softc*,
376 				 struct ahc_linux_device *,
377 				 struct scsi_cmnd *);
378 static void ahc_linux_setup_tag_info_global(char *p);
379 static int  aic7xxx_setup(char *s);
380 
381 static int ahc_linux_unit;
382 
383 
384 /************************** OS Utility Wrappers *******************************/
385 void
ahc_delay(long usec)386 ahc_delay(long usec)
387 {
388 	/*
389 	 * udelay on Linux can have problems for
390 	 * multi-millisecond waits.  Wait at most
391 	 * 1024us per call.
392 	 */
393 	while (usec > 0) {
394 		udelay(usec % 1024);
395 		usec -= 1024;
396 	}
397 }
398 
399 /***************************** Low Level I/O **********************************/
400 uint8_t
ahc_inb(struct ahc_softc * ahc,long port)401 ahc_inb(struct ahc_softc * ahc, long port)
402 {
403 	uint8_t x;
404 
405 	if (ahc->tag == BUS_SPACE_MEMIO) {
406 		x = readb(ahc->bsh.maddr + port);
407 	} else {
408 		x = inb(ahc->bsh.ioport + port);
409 	}
410 	mb();
411 	return (x);
412 }
413 
414 void
ahc_outb(struct ahc_softc * ahc,long port,uint8_t val)415 ahc_outb(struct ahc_softc * ahc, long port, uint8_t val)
416 {
417 	if (ahc->tag == BUS_SPACE_MEMIO) {
418 		writeb(val, ahc->bsh.maddr + port);
419 	} else {
420 		outb(val, ahc->bsh.ioport + port);
421 	}
422 	mb();
423 }
424 
425 void
ahc_outsb(struct ahc_softc * ahc,long port,uint8_t * array,int count)426 ahc_outsb(struct ahc_softc * ahc, long port, uint8_t *array, int count)
427 {
428 	int i;
429 
430 	/*
431 	 * There is probably a more efficient way to do this on Linux
432 	 * but we don't use this for anything speed critical and this
433 	 * should work.
434 	 */
435 	for (i = 0; i < count; i++)
436 		ahc_outb(ahc, port, *array++);
437 }
438 
439 void
ahc_insb(struct ahc_softc * ahc,long port,uint8_t * array,int count)440 ahc_insb(struct ahc_softc * ahc, long port, uint8_t *array, int count)
441 {
442 	int i;
443 
444 	/*
445 	 * There is probably a more efficient way to do this on Linux
446 	 * but we don't use this for anything speed critical and this
447 	 * should work.
448 	 */
449 	for (i = 0; i < count; i++)
450 		*array++ = ahc_inb(ahc, port);
451 }
452 
453 /********************************* Inlines ************************************/
454 static void ahc_linux_unmap_scb(struct ahc_softc*, struct scb*);
455 
456 static int ahc_linux_map_seg(struct ahc_softc *ahc, struct scb *scb,
457 				      struct ahc_dma_seg *sg,
458 				      dma_addr_t addr, bus_size_t len);
459 
460 static void
ahc_linux_unmap_scb(struct ahc_softc * ahc,struct scb * scb)461 ahc_linux_unmap_scb(struct ahc_softc *ahc, struct scb *scb)
462 {
463 	struct scsi_cmnd *cmd;
464 
465 	cmd = scb->io_ctx;
466 	ahc_sync_sglist(ahc, scb, BUS_DMASYNC_POSTWRITE);
467 
468 	scsi_dma_unmap(cmd);
469 }
470 
471 static int
ahc_linux_map_seg(struct ahc_softc * ahc,struct scb * scb,struct ahc_dma_seg * sg,dma_addr_t addr,bus_size_t len)472 ahc_linux_map_seg(struct ahc_softc *ahc, struct scb *scb,
473 		  struct ahc_dma_seg *sg, dma_addr_t addr, bus_size_t len)
474 {
475 	int	 consumed;
476 
477 	if ((scb->sg_count + 1) > AHC_NSEG)
478 		panic("Too few segs for dma mapping.  "
479 		      "Increase AHC_NSEG\n");
480 
481 	consumed = 1;
482 	sg->addr = ahc_htole32(addr & 0xFFFFFFFF);
483 	scb->platform_data->xfer_len += len;
484 
485 	if (sizeof(dma_addr_t) > 4
486 	 && (ahc->flags & AHC_39BIT_ADDRESSING) != 0)
487 		len |= (addr >> 8) & AHC_SG_HIGH_ADDR_MASK;
488 
489 	sg->len = ahc_htole32(len);
490 	return (consumed);
491 }
492 
493 /*
494  * Return a string describing the driver.
495  */
496 static const char *
ahc_linux_info(struct Scsi_Host * host)497 ahc_linux_info(struct Scsi_Host *host)
498 {
499 	static char buffer[512];
500 	char	ahc_info[256];
501 	char   *bp;
502 	struct ahc_softc *ahc;
503 
504 	bp = &buffer[0];
505 	ahc = *(struct ahc_softc **)host->hostdata;
506 	memset(bp, 0, sizeof(buffer));
507 	strcpy(bp, "Adaptec AIC7XXX EISA/VLB/PCI SCSI HBA DRIVER, Rev " AIC7XXX_DRIVER_VERSION "\n"
508 			"        <");
509 	strcat(bp, ahc->description);
510 	strcat(bp, ">\n"
511 			"        ");
512 	ahc_controller_info(ahc, ahc_info);
513 	strcat(bp, ahc_info);
514 	strcat(bp, "\n");
515 
516 	return (bp);
517 }
518 
519 /*
520  * Queue an SCB to the controller.
521  */
ahc_linux_queue_lck(struct scsi_cmnd * cmd)522 static int ahc_linux_queue_lck(struct scsi_cmnd *cmd)
523 {
524 	struct	 ahc_softc *ahc;
525 	struct	 ahc_linux_device *dev = scsi_transport_device_data(cmd->device);
526 	int rtn = SCSI_MLQUEUE_HOST_BUSY;
527 	unsigned long flags;
528 
529 	ahc = *(struct ahc_softc **)cmd->device->host->hostdata;
530 
531 	ahc_lock(ahc, &flags);
532 	if (ahc->platform_data->qfrozen == 0) {
533 		cmd->result = CAM_REQ_INPROG << 16;
534 		rtn = ahc_linux_run_command(ahc, dev, cmd);
535 	}
536 	ahc_unlock(ahc, &flags);
537 
538 	return rtn;
539 }
540 
DEF_SCSI_QCMD(ahc_linux_queue)541 static DEF_SCSI_QCMD(ahc_linux_queue)
542 
543 static inline struct scsi_target **
544 ahc_linux_target_in_softc(struct scsi_target *starget)
545 {
546 	struct	ahc_softc *ahc =
547 		*((struct ahc_softc **)dev_to_shost(&starget->dev)->hostdata);
548 	unsigned int target_offset;
549 
550 	target_offset = starget->id;
551 	if (starget->channel != 0)
552 		target_offset += 8;
553 
554 	return &ahc->platform_data->starget[target_offset];
555 }
556 
557 static int
ahc_linux_target_alloc(struct scsi_target * starget)558 ahc_linux_target_alloc(struct scsi_target *starget)
559 {
560 	struct	ahc_softc *ahc =
561 		*((struct ahc_softc **)dev_to_shost(&starget->dev)->hostdata);
562 	struct seeprom_config *sc = ahc->seep_config;
563 	unsigned long flags;
564 	struct scsi_target **ahc_targp = ahc_linux_target_in_softc(starget);
565 	unsigned short scsirate;
566 	struct ahc_devinfo devinfo;
567 	char channel = starget->channel + 'A';
568 	unsigned int our_id = ahc->our_id;
569 	unsigned int target_offset;
570 
571 	target_offset = starget->id;
572 	if (starget->channel != 0)
573 		target_offset += 8;
574 
575 	if (starget->channel)
576 		our_id = ahc->our_id_b;
577 
578 	ahc_lock(ahc, &flags);
579 
580 	BUG_ON(*ahc_targp != NULL);
581 
582 	*ahc_targp = starget;
583 
584 	if (sc) {
585 		int maxsync = AHC_SYNCRATE_DT;
586 		int ultra = 0;
587 		int flags = sc->device_flags[target_offset];
588 
589 		if (ahc->flags & AHC_NEWEEPROM_FMT) {
590 		    if (flags & CFSYNCHISULTRA)
591 			ultra = 1;
592 		} else if (flags & CFULTRAEN)
593 			ultra = 1;
594 		/* AIC nutcase; 10MHz appears as ultra = 1, CFXFER = 0x04
595 		 * change it to ultra=0, CFXFER = 0 */
596 		if(ultra && (flags & CFXFER) == 0x04) {
597 			ultra = 0;
598 			flags &= ~CFXFER;
599 		}
600 
601 		if ((ahc->features & AHC_ULTRA2) != 0) {
602 			scsirate = (flags & CFXFER) | (ultra ? 0x8 : 0);
603 		} else {
604 			scsirate = (flags & CFXFER) << 4;
605 			maxsync = ultra ? AHC_SYNCRATE_ULTRA :
606 				AHC_SYNCRATE_FAST;
607 		}
608 		spi_max_width(starget) = (flags & CFWIDEB) ? 1 : 0;
609 		if (!(flags & CFSYNCH))
610 			spi_max_offset(starget) = 0;
611 		spi_min_period(starget) =
612 			ahc_find_period(ahc, scsirate, maxsync);
613 	}
614 	ahc_compile_devinfo(&devinfo, our_id, starget->id,
615 			    CAM_LUN_WILDCARD, channel,
616 			    ROLE_INITIATOR);
617 	ahc_set_syncrate(ahc, &devinfo, NULL, 0, 0, 0,
618 			 AHC_TRANS_GOAL, /*paused*/FALSE);
619 	ahc_set_width(ahc, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,
620 		      AHC_TRANS_GOAL, /*paused*/FALSE);
621 	ahc_unlock(ahc, &flags);
622 
623 	return 0;
624 }
625 
626 static void
ahc_linux_target_destroy(struct scsi_target * starget)627 ahc_linux_target_destroy(struct scsi_target *starget)
628 {
629 	struct scsi_target **ahc_targp = ahc_linux_target_in_softc(starget);
630 
631 	*ahc_targp = NULL;
632 }
633 
634 static int
ahc_linux_slave_alloc(struct scsi_device * sdev)635 ahc_linux_slave_alloc(struct scsi_device *sdev)
636 {
637 	struct	ahc_softc *ahc =
638 		*((struct ahc_softc **)sdev->host->hostdata);
639 	struct scsi_target *starget = sdev->sdev_target;
640 	struct ahc_linux_device *dev;
641 
642 	if (bootverbose)
643 		printk("%s: Slave Alloc %d\n", ahc_name(ahc), sdev->id);
644 
645 	dev = scsi_transport_device_data(sdev);
646 	memset(dev, 0, sizeof(*dev));
647 
648 	/*
649 	 * We start out life using untagged
650 	 * transactions of which we allow one.
651 	 */
652 	dev->openings = 1;
653 
654 	/*
655 	 * Set maxtags to 0.  This will be changed if we
656 	 * later determine that we are dealing with
657 	 * a tagged queuing capable device.
658 	 */
659 	dev->maxtags = 0;
660 
661 	spi_period(starget) = 0;
662 
663 	return 0;
664 }
665 
666 static int
ahc_linux_slave_configure(struct scsi_device * sdev)667 ahc_linux_slave_configure(struct scsi_device *sdev)
668 {
669 	if (bootverbose)
670 		sdev_printk(KERN_INFO, sdev, "Slave Configure\n");
671 
672 	ahc_linux_device_queue_depth(sdev);
673 
674 	/* Initial Domain Validation */
675 	if (!spi_initial_dv(sdev->sdev_target))
676 		spi_dv_device(sdev);
677 
678 	return 0;
679 }
680 
681 #if defined(__i386__)
682 /*
683  * Return the disk geometry for the given SCSI device.
684  */
685 static int
ahc_linux_biosparam(struct scsi_device * sdev,struct block_device * bdev,sector_t capacity,int geom[])686 ahc_linux_biosparam(struct scsi_device *sdev, struct block_device *bdev,
687 		    sector_t capacity, int geom[])
688 {
689 	int	 heads;
690 	int	 sectors;
691 	int	 cylinders;
692 	int	 extended;
693 	struct	 ahc_softc *ahc;
694 	u_int	 channel;
695 
696 	ahc = *((struct ahc_softc **)sdev->host->hostdata);
697 	channel = sdev_channel(sdev);
698 
699 	if (scsi_partsize(bdev, capacity, geom))
700 		return 0;
701 
702 	heads = 64;
703 	sectors = 32;
704 	cylinders = aic_sector_div(capacity, heads, sectors);
705 
706 	if (aic7xxx_extended != 0)
707 		extended = 1;
708 	else if (channel == 0)
709 		extended = (ahc->flags & AHC_EXTENDED_TRANS_A) != 0;
710 	else
711 		extended = (ahc->flags & AHC_EXTENDED_TRANS_B) != 0;
712 	if (extended && cylinders >= 1024) {
713 		heads = 255;
714 		sectors = 63;
715 		cylinders = aic_sector_div(capacity, heads, sectors);
716 	}
717 	geom[0] = heads;
718 	geom[1] = sectors;
719 	geom[2] = cylinders;
720 	return (0);
721 }
722 #endif
723 
724 /*
725  * Abort the current SCSI command(s).
726  */
727 static int
ahc_linux_abort(struct scsi_cmnd * cmd)728 ahc_linux_abort(struct scsi_cmnd *cmd)
729 {
730 	int error;
731 
732 	error = ahc_linux_queue_recovery_cmd(cmd->device, cmd);
733 	if (error != SUCCESS)
734 		printk("aic7xxx_abort returns 0x%x\n", error);
735 	return (error);
736 }
737 
738 /*
739  * Attempt to send a target reset message to the device that timed out.
740  */
741 static int
ahc_linux_dev_reset(struct scsi_cmnd * cmd)742 ahc_linux_dev_reset(struct scsi_cmnd *cmd)
743 {
744 	int error;
745 
746 	error = ahc_linux_queue_recovery_cmd(cmd->device, NULL);
747 	if (error != SUCCESS)
748 		printk("aic7xxx_dev_reset returns 0x%x\n", error);
749 	return (error);
750 }
751 
752 /*
753  * Reset the SCSI bus.
754  */
755 static int
ahc_linux_bus_reset(struct scsi_cmnd * cmd)756 ahc_linux_bus_reset(struct scsi_cmnd *cmd)
757 {
758 	struct ahc_softc *ahc;
759 	int    found;
760 	unsigned long flags;
761 
762 	ahc = *(struct ahc_softc **)cmd->device->host->hostdata;
763 
764 	ahc_lock(ahc, &flags);
765 	found = ahc_reset_channel(ahc, scmd_channel(cmd) + 'A',
766 				  /*initiate reset*/TRUE);
767 	ahc_unlock(ahc, &flags);
768 
769 	if (bootverbose)
770 		printk("%s: SCSI bus reset delivered. "
771 		       "%d SCBs aborted.\n", ahc_name(ahc), found);
772 
773 	return SUCCESS;
774 }
775 
776 struct scsi_host_template aic7xxx_driver_template = {
777 	.module			= THIS_MODULE,
778 	.name			= "aic7xxx",
779 	.proc_name		= "aic7xxx",
780 	.show_info		= ahc_linux_show_info,
781 	.write_info		= ahc_proc_write_seeprom,
782 	.info			= ahc_linux_info,
783 	.queuecommand		= ahc_linux_queue,
784 	.eh_abort_handler	= ahc_linux_abort,
785 	.eh_device_reset_handler = ahc_linux_dev_reset,
786 	.eh_bus_reset_handler	= ahc_linux_bus_reset,
787 #if defined(__i386__)
788 	.bios_param		= ahc_linux_biosparam,
789 #endif
790 	.can_queue		= AHC_MAX_QUEUE,
791 	.this_id		= -1,
792 	.max_sectors		= 8192,
793 	.cmd_per_lun		= 2,
794 	.slave_alloc		= ahc_linux_slave_alloc,
795 	.slave_configure	= ahc_linux_slave_configure,
796 	.target_alloc		= ahc_linux_target_alloc,
797 	.target_destroy		= ahc_linux_target_destroy,
798 };
799 
800 /**************************** Tasklet Handler *********************************/
801 
802 
ahc_build_scsiid(struct ahc_softc * ahc,struct scsi_device * sdev)803 static inline unsigned int ahc_build_scsiid(struct ahc_softc *ahc,
804 					    struct scsi_device *sdev)
805 {
806 	unsigned int scsiid = (sdev->id << TID_SHIFT) & TID;
807 
808 	if (sdev->channel == 0)
809 		scsiid |= ahc->our_id;
810 	else
811 		scsiid |= ahc->our_id_b | TWIN_CHNLB;
812 	return scsiid;
813 }
814 
815 /******************************** Bus DMA *************************************/
816 int
ahc_dma_tag_create(struct ahc_softc * ahc,bus_dma_tag_t parent,bus_size_t alignment,bus_size_t boundary,dma_addr_t lowaddr,dma_addr_t highaddr,bus_dma_filter_t * filter,void * filterarg,bus_size_t maxsize,int nsegments,bus_size_t maxsegsz,int flags,bus_dma_tag_t * ret_tag)817 ahc_dma_tag_create(struct ahc_softc *ahc, bus_dma_tag_t parent,
818 		   bus_size_t alignment, bus_size_t boundary,
819 		   dma_addr_t lowaddr, dma_addr_t highaddr,
820 		   bus_dma_filter_t *filter, void *filterarg,
821 		   bus_size_t maxsize, int nsegments,
822 		   bus_size_t maxsegsz, int flags, bus_dma_tag_t *ret_tag)
823 {
824 	bus_dma_tag_t dmat;
825 
826 	dmat = kmalloc(sizeof(*dmat), GFP_ATOMIC);
827 	if (dmat == NULL)
828 		return (ENOMEM);
829 
830 	/*
831 	 * Linux is very simplistic about DMA memory.  For now don't
832 	 * maintain all specification information.  Once Linux supplies
833 	 * better facilities for doing these operations, or the
834 	 * needs of this particular driver change, we might need to do
835 	 * more here.
836 	 */
837 	dmat->alignment = alignment;
838 	dmat->boundary = boundary;
839 	dmat->maxsize = maxsize;
840 	*ret_tag = dmat;
841 	return (0);
842 }
843 
844 void
ahc_dma_tag_destroy(struct ahc_softc * ahc,bus_dma_tag_t dmat)845 ahc_dma_tag_destroy(struct ahc_softc *ahc, bus_dma_tag_t dmat)
846 {
847 	kfree(dmat);
848 }
849 
850 int
ahc_dmamem_alloc(struct ahc_softc * ahc,bus_dma_tag_t dmat,void ** vaddr,int flags,bus_dmamap_t * mapp)851 ahc_dmamem_alloc(struct ahc_softc *ahc, bus_dma_tag_t dmat, void** vaddr,
852 		 int flags, bus_dmamap_t *mapp)
853 {
854 	/* XXX: check if we really need the GFP_ATOMIC and unwind this mess! */
855 	*vaddr = dma_alloc_coherent(ahc->dev, dmat->maxsize, mapp, GFP_ATOMIC);
856 	if (*vaddr == NULL)
857 		return ENOMEM;
858 	return 0;
859 }
860 
861 void
ahc_dmamem_free(struct ahc_softc * ahc,bus_dma_tag_t dmat,void * vaddr,bus_dmamap_t map)862 ahc_dmamem_free(struct ahc_softc *ahc, bus_dma_tag_t dmat,
863 		void* vaddr, bus_dmamap_t map)
864 {
865 	dma_free_coherent(ahc->dev, dmat->maxsize, vaddr, map);
866 }
867 
868 int
ahc_dmamap_load(struct ahc_softc * ahc,bus_dma_tag_t dmat,bus_dmamap_t map,void * buf,bus_size_t buflen,bus_dmamap_callback_t * cb,void * cb_arg,int flags)869 ahc_dmamap_load(struct ahc_softc *ahc, bus_dma_tag_t dmat, bus_dmamap_t map,
870 		void *buf, bus_size_t buflen, bus_dmamap_callback_t *cb,
871 		void *cb_arg, int flags)
872 {
873 	/*
874 	 * Assume for now that this will only be used during
875 	 * initialization and not for per-transaction buffer mapping.
876 	 */
877 	bus_dma_segment_t stack_sg;
878 
879 	stack_sg.ds_addr = map;
880 	stack_sg.ds_len = dmat->maxsize;
881 	cb(cb_arg, &stack_sg, /*nseg*/1, /*error*/0);
882 	return (0);
883 }
884 
885 void
ahc_dmamap_destroy(struct ahc_softc * ahc,bus_dma_tag_t dmat,bus_dmamap_t map)886 ahc_dmamap_destroy(struct ahc_softc *ahc, bus_dma_tag_t dmat, bus_dmamap_t map)
887 {
888 }
889 
890 int
ahc_dmamap_unload(struct ahc_softc * ahc,bus_dma_tag_t dmat,bus_dmamap_t map)891 ahc_dmamap_unload(struct ahc_softc *ahc, bus_dma_tag_t dmat, bus_dmamap_t map)
892 {
893 	/* Nothing to do */
894 	return (0);
895 }
896 
897 static void
ahc_linux_setup_tag_info_global(char * p)898 ahc_linux_setup_tag_info_global(char *p)
899 {
900 	int tags, i, j;
901 
902 	tags = simple_strtoul(p + 1, NULL, 0) & 0xff;
903 	printk("Setting Global Tags= %d\n", tags);
904 
905 	for (i = 0; i < ARRAY_SIZE(aic7xxx_tag_info); i++) {
906 		for (j = 0; j < AHC_NUM_TARGETS; j++) {
907 			aic7xxx_tag_info[i].tag_commands[j] = tags;
908 		}
909 	}
910 }
911 
912 static void
ahc_linux_setup_tag_info(u_long arg,int instance,int targ,int32_t value)913 ahc_linux_setup_tag_info(u_long arg, int instance, int targ, int32_t value)
914 {
915 
916 	if ((instance >= 0) && (targ >= 0)
917 	 && (instance < ARRAY_SIZE(aic7xxx_tag_info))
918 	 && (targ < AHC_NUM_TARGETS)) {
919 		aic7xxx_tag_info[instance].tag_commands[targ] = value & 0xff;
920 		if (bootverbose)
921 			printk("tag_info[%d:%d] = %d\n", instance, targ, value);
922 	}
923 }
924 
925 static char *
ahc_parse_brace_option(char * opt_name,char * opt_arg,char * end,int depth,void (* callback)(u_long,int,int,int32_t),u_long callback_arg)926 ahc_parse_brace_option(char *opt_name, char *opt_arg, char *end, int depth,
927 		       void (*callback)(u_long, int, int, int32_t),
928 		       u_long callback_arg)
929 {
930 	char	*tok_end;
931 	char	*tok_end2;
932 	int      i;
933 	int      instance;
934 	int	 targ;
935 	int	 done;
936 	char	 tok_list[] = {'.', ',', '{', '}', '\0'};
937 
938 	/* All options use a ':' name/arg separator */
939 	if (*opt_arg != ':')
940 		return (opt_arg);
941 	opt_arg++;
942 	instance = -1;
943 	targ = -1;
944 	done = FALSE;
945 	/*
946 	 * Restore separator that may be in
947 	 * the middle of our option argument.
948 	 */
949 	tok_end = strchr(opt_arg, '\0');
950 	if (tok_end < end)
951 		*tok_end = ',';
952 	while (!done) {
953 		switch (*opt_arg) {
954 		case '{':
955 			if (instance == -1) {
956 				instance = 0;
957 			} else {
958 				if (depth > 1) {
959 					if (targ == -1)
960 						targ = 0;
961 				} else {
962 					printk("Malformed Option %s\n",
963 					       opt_name);
964 					done = TRUE;
965 				}
966 			}
967 			opt_arg++;
968 			break;
969 		case '}':
970 			if (targ != -1)
971 				targ = -1;
972 			else if (instance != -1)
973 				instance = -1;
974 			opt_arg++;
975 			break;
976 		case ',':
977 		case '.':
978 			if (instance == -1)
979 				done = TRUE;
980 			else if (targ >= 0)
981 				targ++;
982 			else if (instance >= 0)
983 				instance++;
984 			opt_arg++;
985 			break;
986 		case '\0':
987 			done = TRUE;
988 			break;
989 		default:
990 			tok_end = end;
991 			for (i = 0; tok_list[i]; i++) {
992 				tok_end2 = strchr(opt_arg, tok_list[i]);
993 				if ((tok_end2) && (tok_end2 < tok_end))
994 					tok_end = tok_end2;
995 			}
996 			callback(callback_arg, instance, targ,
997 				 simple_strtol(opt_arg, NULL, 0));
998 			opt_arg = tok_end;
999 			break;
1000 		}
1001 	}
1002 	return (opt_arg);
1003 }
1004 
1005 /*
1006  * Handle Linux boot parameters. This routine allows for assigning a value
1007  * to a parameter with a ':' between the parameter and the value.
1008  * ie. aic7xxx=stpwlev:1,extended
1009  */
1010 static int
aic7xxx_setup(char * s)1011 aic7xxx_setup(char *s)
1012 {
1013 	int	i, n;
1014 	char   *p;
1015 	char   *end;
1016 
1017 	static const struct {
1018 		const char *name;
1019 		uint32_t *flag;
1020 	} options[] = {
1021 		{ "extended", &aic7xxx_extended },
1022 		{ "no_reset", &aic7xxx_no_reset },
1023 		{ "verbose", &aic7xxx_verbose },
1024 		{ "allow_memio", &aic7xxx_allow_memio},
1025 #ifdef AHC_DEBUG
1026 		{ "debug", &ahc_debug },
1027 #endif
1028 		{ "periodic_otag", &aic7xxx_periodic_otag },
1029 		{ "pci_parity", &aic7xxx_pci_parity },
1030 		{ "seltime", &aic7xxx_seltime },
1031 		{ "tag_info", NULL },
1032 		{ "global_tag_depth", NULL },
1033 		{ "dv", NULL }
1034 	};
1035 
1036 	end = strchr(s, '\0');
1037 
1038 	/*
1039 	 * XXX ia64 gcc isn't smart enough to know that ARRAY_SIZE
1040 	 * will never be 0 in this case.
1041 	 */
1042 	n = 0;
1043 
1044 	while ((p = strsep(&s, ",.")) != NULL) {
1045 		if (*p == '\0')
1046 			continue;
1047 		for (i = 0; i < ARRAY_SIZE(options); i++) {
1048 
1049 			n = strlen(options[i].name);
1050 			if (strncmp(options[i].name, p, n) == 0)
1051 				break;
1052 		}
1053 		if (i == ARRAY_SIZE(options))
1054 			continue;
1055 
1056 		if (strncmp(p, "global_tag_depth", n) == 0) {
1057 			ahc_linux_setup_tag_info_global(p + n);
1058 		} else if (strncmp(p, "tag_info", n) == 0) {
1059 			s = ahc_parse_brace_option("tag_info", p + n, end,
1060 			    2, ahc_linux_setup_tag_info, 0);
1061 		} else if (p[n] == ':') {
1062 			*(options[i].flag) = simple_strtoul(p + n + 1, NULL, 0);
1063 		} else if (strncmp(p, "verbose", n) == 0) {
1064 			*(options[i].flag) = 1;
1065 		} else {
1066 			*(options[i].flag) ^= 0xFFFFFFFF;
1067 		}
1068 	}
1069 	return 1;
1070 }
1071 
1072 __setup("aic7xxx=", aic7xxx_setup);
1073 
1074 uint32_t aic7xxx_verbose;
1075 
1076 int
ahc_linux_register_host(struct ahc_softc * ahc,struct scsi_host_template * template)1077 ahc_linux_register_host(struct ahc_softc *ahc, struct scsi_host_template *template)
1078 {
1079 	char	buf[80];
1080 	struct	Scsi_Host *host;
1081 	char	*new_name;
1082 	u_long	s;
1083 	int	retval;
1084 
1085 	template->name = ahc->description;
1086 	host = scsi_host_alloc(template, sizeof(struct ahc_softc *));
1087 	if (host == NULL)
1088 		return -ENOMEM;
1089 
1090 	*((struct ahc_softc **)host->hostdata) = ahc;
1091 	ahc->platform_data->host = host;
1092 	host->can_queue = AHC_MAX_QUEUE;
1093 	host->cmd_per_lun = 2;
1094 	/* XXX No way to communicate the ID for multiple channels */
1095 	host->this_id = ahc->our_id;
1096 	host->irq = ahc->platform_data->irq;
1097 	host->max_id = (ahc->features & AHC_WIDE) ? 16 : 8;
1098 	host->max_lun = AHC_NUM_LUNS;
1099 	host->max_channel = (ahc->features & AHC_TWIN) ? 1 : 0;
1100 	host->sg_tablesize = AHC_NSEG;
1101 	ahc_lock(ahc, &s);
1102 	ahc_set_unit(ahc, ahc_linux_unit++);
1103 	ahc_unlock(ahc, &s);
1104 	sprintf(buf, "scsi%d", host->host_no);
1105 	new_name = kmalloc(strlen(buf) + 1, GFP_ATOMIC);
1106 	if (new_name != NULL) {
1107 		strcpy(new_name, buf);
1108 		ahc_set_name(ahc, new_name);
1109 	}
1110 	host->unique_id = ahc->unit;
1111 	ahc_linux_initialize_scsi_bus(ahc);
1112 	ahc_intr_enable(ahc, TRUE);
1113 
1114 	host->transportt = ahc_linux_transport_template;
1115 
1116 	retval = scsi_add_host(host, ahc->dev);
1117 	if (retval) {
1118 		printk(KERN_WARNING "aic7xxx: scsi_add_host failed\n");
1119 		scsi_host_put(host);
1120 		return retval;
1121 	}
1122 
1123 	scsi_scan_host(host);
1124 	return 0;
1125 }
1126 
1127 /*
1128  * Place the SCSI bus into a known state by either resetting it,
1129  * or forcing transfer negotiations on the next command to any
1130  * target.
1131  */
1132 static void
ahc_linux_initialize_scsi_bus(struct ahc_softc * ahc)1133 ahc_linux_initialize_scsi_bus(struct ahc_softc *ahc)
1134 {
1135 	int i;
1136 	int numtarg;
1137 	unsigned long s;
1138 
1139 	i = 0;
1140 	numtarg = 0;
1141 
1142 	ahc_lock(ahc, &s);
1143 
1144 	if (aic7xxx_no_reset != 0)
1145 		ahc->flags &= ~(AHC_RESET_BUS_A|AHC_RESET_BUS_B);
1146 
1147 	if ((ahc->flags & AHC_RESET_BUS_A) != 0)
1148 		ahc_reset_channel(ahc, 'A', /*initiate_reset*/TRUE);
1149 	else
1150 		numtarg = (ahc->features & AHC_WIDE) ? 16 : 8;
1151 
1152 	if ((ahc->features & AHC_TWIN) != 0) {
1153 
1154 		if ((ahc->flags & AHC_RESET_BUS_B) != 0) {
1155 			ahc_reset_channel(ahc, 'B', /*initiate_reset*/TRUE);
1156 		} else {
1157 			if (numtarg == 0)
1158 				i = 8;
1159 			numtarg += 8;
1160 		}
1161 	}
1162 
1163 	/*
1164 	 * Force negotiation to async for all targets that
1165 	 * will not see an initial bus reset.
1166 	 */
1167 	for (; i < numtarg; i++) {
1168 		struct ahc_devinfo devinfo;
1169 		struct ahc_initiator_tinfo *tinfo;
1170 		struct ahc_tmode_tstate *tstate;
1171 		u_int our_id;
1172 		u_int target_id;
1173 		char channel;
1174 
1175 		channel = 'A';
1176 		our_id = ahc->our_id;
1177 		target_id = i;
1178 		if (i > 7 && (ahc->features & AHC_TWIN) != 0) {
1179 			channel = 'B';
1180 			our_id = ahc->our_id_b;
1181 			target_id = i % 8;
1182 		}
1183 		tinfo = ahc_fetch_transinfo(ahc, channel, our_id,
1184 					    target_id, &tstate);
1185 		ahc_compile_devinfo(&devinfo, our_id, target_id,
1186 				    CAM_LUN_WILDCARD, channel, ROLE_INITIATOR);
1187 		ahc_update_neg_request(ahc, &devinfo, tstate,
1188 				       tinfo, AHC_NEG_ALWAYS);
1189 	}
1190 	ahc_unlock(ahc, &s);
1191 	/* Give the bus some time to recover */
1192 	if ((ahc->flags & (AHC_RESET_BUS_A|AHC_RESET_BUS_B)) != 0) {
1193 		ahc_linux_freeze_simq(ahc);
1194 		msleep(AIC7XXX_RESET_DELAY);
1195 		ahc_linux_release_simq(ahc);
1196 	}
1197 }
1198 
1199 int
ahc_platform_alloc(struct ahc_softc * ahc,void * platform_arg)1200 ahc_platform_alloc(struct ahc_softc *ahc, void *platform_arg)
1201 {
1202 
1203 	ahc->platform_data =
1204 	    kzalloc(sizeof(struct ahc_platform_data), GFP_ATOMIC);
1205 	if (ahc->platform_data == NULL)
1206 		return (ENOMEM);
1207 	ahc->platform_data->irq = AHC_LINUX_NOIRQ;
1208 	ahc_lockinit(ahc);
1209 	ahc->seltime = (aic7xxx_seltime & 0x3) << 4;
1210 	ahc->seltime_b = (aic7xxx_seltime & 0x3) << 4;
1211 	if (aic7xxx_pci_parity == 0)
1212 		ahc->flags |= AHC_DISABLE_PCI_PERR;
1213 
1214 	return (0);
1215 }
1216 
1217 void
ahc_platform_free(struct ahc_softc * ahc)1218 ahc_platform_free(struct ahc_softc *ahc)
1219 {
1220 	struct scsi_target *starget;
1221 	int i;
1222 
1223 	if (ahc->platform_data != NULL) {
1224 		/* destroy all of the device and target objects */
1225 		for (i = 0; i < AHC_NUM_TARGETS; i++) {
1226 			starget = ahc->platform_data->starget[i];
1227 			if (starget != NULL) {
1228 				ahc->platform_data->starget[i] = NULL;
1229 			}
1230 		}
1231 
1232 		if (ahc->platform_data->irq != AHC_LINUX_NOIRQ)
1233 			free_irq(ahc->platform_data->irq, ahc);
1234 		if (ahc->tag == BUS_SPACE_PIO
1235 		 && ahc->bsh.ioport != 0)
1236 			release_region(ahc->bsh.ioport, 256);
1237 		if (ahc->tag == BUS_SPACE_MEMIO
1238 		 && ahc->bsh.maddr != NULL) {
1239 			iounmap(ahc->bsh.maddr);
1240 			release_mem_region(ahc->platform_data->mem_busaddr,
1241 					   0x1000);
1242 		}
1243 
1244 		if (ahc->platform_data->host)
1245 			scsi_host_put(ahc->platform_data->host);
1246 
1247 		kfree(ahc->platform_data);
1248 	}
1249 }
1250 
1251 void
ahc_platform_freeze_devq(struct ahc_softc * ahc,struct scb * scb)1252 ahc_platform_freeze_devq(struct ahc_softc *ahc, struct scb *scb)
1253 {
1254 	ahc_platform_abort_scbs(ahc, SCB_GET_TARGET(ahc, scb),
1255 				SCB_GET_CHANNEL(ahc, scb),
1256 				SCB_GET_LUN(scb), SCB_LIST_NULL,
1257 				ROLE_UNKNOWN, CAM_REQUEUE_REQ);
1258 }
1259 
1260 void
ahc_platform_set_tags(struct ahc_softc * ahc,struct scsi_device * sdev,struct ahc_devinfo * devinfo,ahc_queue_alg alg)1261 ahc_platform_set_tags(struct ahc_softc *ahc, struct scsi_device *sdev,
1262 		      struct ahc_devinfo *devinfo, ahc_queue_alg alg)
1263 {
1264 	struct ahc_linux_device *dev;
1265 	int was_queuing;
1266 	int now_queuing;
1267 
1268 	if (sdev == NULL)
1269 		return;
1270 	dev = scsi_transport_device_data(sdev);
1271 
1272 	was_queuing = dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED);
1273 	switch (alg) {
1274 	default:
1275 	case AHC_QUEUE_NONE:
1276 		now_queuing = 0;
1277 		break;
1278 	case AHC_QUEUE_BASIC:
1279 		now_queuing = AHC_DEV_Q_BASIC;
1280 		break;
1281 	case AHC_QUEUE_TAGGED:
1282 		now_queuing = AHC_DEV_Q_TAGGED;
1283 		break;
1284 	}
1285 	if ((dev->flags & AHC_DEV_FREEZE_TIL_EMPTY) == 0
1286 	 && (was_queuing != now_queuing)
1287 	 && (dev->active != 0)) {
1288 		dev->flags |= AHC_DEV_FREEZE_TIL_EMPTY;
1289 		dev->qfrozen++;
1290 	}
1291 
1292 	dev->flags &= ~(AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED|AHC_DEV_PERIODIC_OTAG);
1293 	if (now_queuing) {
1294 		u_int usertags;
1295 
1296 		usertags = ahc_linux_user_tagdepth(ahc, devinfo);
1297 		if (!was_queuing) {
1298 			/*
1299 			 * Start out aggressively and allow our
1300 			 * dynamic queue depth algorithm to take
1301 			 * care of the rest.
1302 			 */
1303 			dev->maxtags = usertags;
1304 			dev->openings = dev->maxtags - dev->active;
1305 		}
1306 		if (dev->maxtags == 0) {
1307 			/*
1308 			 * Queueing is disabled by the user.
1309 			 */
1310 			dev->openings = 1;
1311 		} else if (alg == AHC_QUEUE_TAGGED) {
1312 			dev->flags |= AHC_DEV_Q_TAGGED;
1313 			if (aic7xxx_periodic_otag != 0)
1314 				dev->flags |= AHC_DEV_PERIODIC_OTAG;
1315 		} else
1316 			dev->flags |= AHC_DEV_Q_BASIC;
1317 	} else {
1318 		/* We can only have one opening. */
1319 		dev->maxtags = 0;
1320 		dev->openings =  1 - dev->active;
1321 	}
1322 	switch ((dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED))) {
1323 	case AHC_DEV_Q_BASIC:
1324 	case AHC_DEV_Q_TAGGED:
1325 		scsi_change_queue_depth(sdev,
1326 				dev->openings + dev->active);
1327 		break;
1328 	default:
1329 		/*
1330 		 * We allow the OS to queue 2 untagged transactions to
1331 		 * us at any time even though we can only execute them
1332 		 * serially on the controller/device.  This should
1333 		 * remove some latency.
1334 		 */
1335 		scsi_change_queue_depth(sdev, 2);
1336 		break;
1337 	}
1338 }
1339 
1340 int
ahc_platform_abort_scbs(struct ahc_softc * ahc,int target,char channel,int lun,u_int tag,role_t role,uint32_t status)1341 ahc_platform_abort_scbs(struct ahc_softc *ahc, int target, char channel,
1342 			int lun, u_int tag, role_t role, uint32_t status)
1343 {
1344 	return 0;
1345 }
1346 
1347 static u_int
ahc_linux_user_tagdepth(struct ahc_softc * ahc,struct ahc_devinfo * devinfo)1348 ahc_linux_user_tagdepth(struct ahc_softc *ahc, struct ahc_devinfo *devinfo)
1349 {
1350 	static int warned_user;
1351 	u_int tags;
1352 
1353 	tags = 0;
1354 	if ((ahc->user_discenable & devinfo->target_mask) != 0) {
1355 		if (ahc->unit >= ARRAY_SIZE(aic7xxx_tag_info)) {
1356 			if (warned_user == 0) {
1357 
1358 				printk(KERN_WARNING
1359 "aic7xxx: WARNING: Insufficient tag_info instances\n"
1360 "aic7xxx: for installed controllers. Using defaults\n"
1361 "aic7xxx: Please update the aic7xxx_tag_info array in\n"
1362 "aic7xxx: the aic7xxx_osm..c source file.\n");
1363 				warned_user++;
1364 			}
1365 			tags = AHC_MAX_QUEUE;
1366 		} else {
1367 			adapter_tag_info_t *tag_info;
1368 
1369 			tag_info = &aic7xxx_tag_info[ahc->unit];
1370 			tags = tag_info->tag_commands[devinfo->target_offset];
1371 			if (tags > AHC_MAX_QUEUE)
1372 				tags = AHC_MAX_QUEUE;
1373 		}
1374 	}
1375 	return (tags);
1376 }
1377 
1378 /*
1379  * Determines the queue depth for a given device.
1380  */
1381 static void
ahc_linux_device_queue_depth(struct scsi_device * sdev)1382 ahc_linux_device_queue_depth(struct scsi_device *sdev)
1383 {
1384 	struct	ahc_devinfo devinfo;
1385 	u_int	tags;
1386 	struct ahc_softc *ahc = *((struct ahc_softc **)sdev->host->hostdata);
1387 
1388 	ahc_compile_devinfo(&devinfo,
1389 			    sdev->sdev_target->channel == 0
1390 			  ? ahc->our_id : ahc->our_id_b,
1391 			    sdev->sdev_target->id, sdev->lun,
1392 			    sdev->sdev_target->channel == 0 ? 'A' : 'B',
1393 			    ROLE_INITIATOR);
1394 	tags = ahc_linux_user_tagdepth(ahc, &devinfo);
1395 	if (tags != 0 && sdev->tagged_supported != 0) {
1396 
1397 		ahc_platform_set_tags(ahc, sdev, &devinfo, AHC_QUEUE_TAGGED);
1398 		ahc_send_async(ahc, devinfo.channel, devinfo.target,
1399 			       devinfo.lun, AC_TRANSFER_NEG);
1400 		ahc_print_devinfo(ahc, &devinfo);
1401 		printk("Tagged Queuing enabled.  Depth %d\n", tags);
1402 	} else {
1403 		ahc_platform_set_tags(ahc, sdev, &devinfo, AHC_QUEUE_NONE);
1404 		ahc_send_async(ahc, devinfo.channel, devinfo.target,
1405 			       devinfo.lun, AC_TRANSFER_NEG);
1406 	}
1407 }
1408 
1409 static int
ahc_linux_run_command(struct ahc_softc * ahc,struct ahc_linux_device * dev,struct scsi_cmnd * cmd)1410 ahc_linux_run_command(struct ahc_softc *ahc, struct ahc_linux_device *dev,
1411 		      struct scsi_cmnd *cmd)
1412 {
1413 	struct	 scb *scb;
1414 	struct	 hardware_scb *hscb;
1415 	struct	 ahc_initiator_tinfo *tinfo;
1416 	struct	 ahc_tmode_tstate *tstate;
1417 	uint16_t mask;
1418 	struct scb_tailq *untagged_q = NULL;
1419 	int nseg;
1420 
1421 	/*
1422 	 * Schedule us to run later.  The only reason we are not
1423 	 * running is because the whole controller Q is frozen.
1424 	 */
1425 	if (ahc->platform_data->qfrozen != 0)
1426 		return SCSI_MLQUEUE_HOST_BUSY;
1427 
1428 	/*
1429 	 * We only allow one untagged transaction
1430 	 * per target in the initiator role unless
1431 	 * we are storing a full busy target *lun*
1432 	 * table in SCB space.
1433 	 */
1434 	if (!(cmd->flags & SCMD_TAGGED)
1435 	    && (ahc->features & AHC_SCB_BTT) == 0) {
1436 		int target_offset;
1437 
1438 		target_offset = cmd->device->id + cmd->device->channel * 8;
1439 		untagged_q = &(ahc->untagged_queues[target_offset]);
1440 		if (!TAILQ_EMPTY(untagged_q))
1441 			/* if we're already executing an untagged command
1442 			 * we're busy to another */
1443 			return SCSI_MLQUEUE_DEVICE_BUSY;
1444 	}
1445 
1446 	nseg = scsi_dma_map(cmd);
1447 	if (nseg < 0)
1448 		return SCSI_MLQUEUE_HOST_BUSY;
1449 
1450 	/*
1451 	 * Get an scb to use.
1452 	 */
1453 	scb = ahc_get_scb(ahc);
1454 	if (!scb) {
1455 		scsi_dma_unmap(cmd);
1456 		return SCSI_MLQUEUE_HOST_BUSY;
1457 	}
1458 
1459 	scb->io_ctx = cmd;
1460 	scb->platform_data->dev = dev;
1461 	hscb = scb->hscb;
1462 	cmd->host_scribble = (char *)scb;
1463 
1464 	/*
1465 	 * Fill out basics of the HSCB.
1466 	 */
1467 	hscb->control = 0;
1468 	hscb->scsiid = ahc_build_scsiid(ahc, cmd->device);
1469 	hscb->lun = cmd->device->lun;
1470 	mask = SCB_GET_TARGET_MASK(ahc, scb);
1471 	tinfo = ahc_fetch_transinfo(ahc, SCB_GET_CHANNEL(ahc, scb),
1472 				    SCB_GET_OUR_ID(scb),
1473 				    SCB_GET_TARGET(ahc, scb), &tstate);
1474 	hscb->scsirate = tinfo->scsirate;
1475 	hscb->scsioffset = tinfo->curr.offset;
1476 	if ((tstate->ultraenb & mask) != 0)
1477 		hscb->control |= ULTRAENB;
1478 
1479 	if ((ahc->user_discenable & mask) != 0)
1480 		hscb->control |= DISCENB;
1481 
1482 	if ((tstate->auto_negotiate & mask) != 0) {
1483 		scb->flags |= SCB_AUTO_NEGOTIATE;
1484 		scb->hscb->control |= MK_MESSAGE;
1485 	}
1486 
1487 	if ((dev->flags & (AHC_DEV_Q_TAGGED|AHC_DEV_Q_BASIC)) != 0) {
1488 		if (dev->commands_since_idle_or_otag == AHC_OTAG_THRESH
1489 				&& (dev->flags & AHC_DEV_Q_TAGGED) != 0) {
1490 			hscb->control |= ORDERED_QUEUE_TAG;
1491 			dev->commands_since_idle_or_otag = 0;
1492 		} else {
1493 			hscb->control |= SIMPLE_QUEUE_TAG;
1494 		}
1495 	}
1496 
1497 	hscb->cdb_len = cmd->cmd_len;
1498 	if (hscb->cdb_len <= 12) {
1499 		memcpy(hscb->shared_data.cdb, cmd->cmnd, hscb->cdb_len);
1500 	} else {
1501 		memcpy(hscb->cdb32, cmd->cmnd, hscb->cdb_len);
1502 		scb->flags |= SCB_CDB32_PTR;
1503 	}
1504 
1505 	scb->platform_data->xfer_len = 0;
1506 	ahc_set_residual(scb, 0);
1507 	ahc_set_sense_residual(scb, 0);
1508 	scb->sg_count = 0;
1509 
1510 	if (nseg > 0) {
1511 		struct	ahc_dma_seg *sg;
1512 		struct	scatterlist *cur_seg;
1513 		int i;
1514 
1515 		/* Copy the segments into the SG list. */
1516 		sg = scb->sg_list;
1517 		/*
1518 		 * The sg_count may be larger than nseg if
1519 		 * a transfer crosses a 32bit page.
1520 		 */
1521 		scsi_for_each_sg(cmd, cur_seg, nseg, i) {
1522 			dma_addr_t addr;
1523 			bus_size_t len;
1524 			int consumed;
1525 
1526 			addr = sg_dma_address(cur_seg);
1527 			len = sg_dma_len(cur_seg);
1528 			consumed = ahc_linux_map_seg(ahc, scb,
1529 						     sg, addr, len);
1530 			sg += consumed;
1531 			scb->sg_count += consumed;
1532 		}
1533 		sg--;
1534 		sg->len |= ahc_htole32(AHC_DMA_LAST_SEG);
1535 
1536 		/*
1537 		 * Reset the sg list pointer.
1538 		 */
1539 		scb->hscb->sgptr =
1540 			ahc_htole32(scb->sg_list_phys | SG_FULL_RESID);
1541 
1542 		/*
1543 		 * Copy the first SG into the "current"
1544 		 * data pointer area.
1545 		 */
1546 		scb->hscb->dataptr = scb->sg_list->addr;
1547 		scb->hscb->datacnt = scb->sg_list->len;
1548 	} else {
1549 		scb->hscb->sgptr = ahc_htole32(SG_LIST_NULL);
1550 		scb->hscb->dataptr = 0;
1551 		scb->hscb->datacnt = 0;
1552 		scb->sg_count = 0;
1553 	}
1554 
1555 	LIST_INSERT_HEAD(&ahc->pending_scbs, scb, pending_links);
1556 	dev->openings--;
1557 	dev->active++;
1558 	dev->commands_issued++;
1559 	if ((dev->flags & AHC_DEV_PERIODIC_OTAG) != 0)
1560 		dev->commands_since_idle_or_otag++;
1561 
1562 	scb->flags |= SCB_ACTIVE;
1563 	if (untagged_q) {
1564 		TAILQ_INSERT_TAIL(untagged_q, scb, links.tqe);
1565 		scb->flags |= SCB_UNTAGGEDQ;
1566 	}
1567 	ahc_queue_scb(ahc, scb);
1568 	return 0;
1569 }
1570 
1571 /*
1572  * SCSI controller interrupt handler.
1573  */
1574 irqreturn_t
ahc_linux_isr(int irq,void * dev_id)1575 ahc_linux_isr(int irq, void *dev_id)
1576 {
1577 	struct	ahc_softc *ahc;
1578 	u_long	flags;
1579 	int	ours;
1580 
1581 	ahc = (struct ahc_softc *) dev_id;
1582 	ahc_lock(ahc, &flags);
1583 	ours = ahc_intr(ahc);
1584 	ahc_unlock(ahc, &flags);
1585 	return IRQ_RETVAL(ours);
1586 }
1587 
1588 void
ahc_platform_flushwork(struct ahc_softc * ahc)1589 ahc_platform_flushwork(struct ahc_softc *ahc)
1590 {
1591 
1592 }
1593 
1594 void
ahc_send_async(struct ahc_softc * ahc,char channel,u_int target,u_int lun,ac_code code)1595 ahc_send_async(struct ahc_softc *ahc, char channel,
1596 	       u_int target, u_int lun, ac_code code)
1597 {
1598 	switch (code) {
1599 	case AC_TRANSFER_NEG:
1600 	{
1601 		struct	scsi_target *starget;
1602 		struct	ahc_initiator_tinfo *tinfo;
1603 		struct	ahc_tmode_tstate *tstate;
1604 		int	target_offset;
1605 		unsigned int target_ppr_options;
1606 
1607 		BUG_ON(target == CAM_TARGET_WILDCARD);
1608 
1609 		tinfo = ahc_fetch_transinfo(ahc, channel,
1610 						channel == 'A' ? ahc->our_id
1611 							       : ahc->our_id_b,
1612 						target, &tstate);
1613 
1614 		/*
1615 		 * Don't bother reporting results while
1616 		 * negotiations are still pending.
1617 		 */
1618 		if (tinfo->curr.period != tinfo->goal.period
1619 		 || tinfo->curr.width != tinfo->goal.width
1620 		 || tinfo->curr.offset != tinfo->goal.offset
1621 		 || tinfo->curr.ppr_options != tinfo->goal.ppr_options)
1622 			if (bootverbose == 0)
1623 				break;
1624 
1625 		/*
1626 		 * Don't bother reporting results that
1627 		 * are identical to those last reported.
1628 		 */
1629 		target_offset = target;
1630 		if (channel == 'B')
1631 			target_offset += 8;
1632 		starget = ahc->platform_data->starget[target_offset];
1633 		if (starget == NULL)
1634 			break;
1635 
1636 		target_ppr_options =
1637 			(spi_dt(starget) ? MSG_EXT_PPR_DT_REQ : 0)
1638 			+ (spi_qas(starget) ? MSG_EXT_PPR_QAS_REQ : 0)
1639 			+ (spi_iu(starget) ?  MSG_EXT_PPR_IU_REQ : 0);
1640 
1641 		if (tinfo->curr.period == spi_period(starget)
1642 		    && tinfo->curr.width == spi_width(starget)
1643 		    && tinfo->curr.offset == spi_offset(starget)
1644 		 && tinfo->curr.ppr_options == target_ppr_options)
1645 			if (bootverbose == 0)
1646 				break;
1647 
1648 		spi_period(starget) = tinfo->curr.period;
1649 		spi_width(starget) = tinfo->curr.width;
1650 		spi_offset(starget) = tinfo->curr.offset;
1651 		spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_DT_REQ ? 1 : 0;
1652 		spi_qas(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_QAS_REQ ? 1 : 0;
1653 		spi_iu(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ ? 1 : 0;
1654 		spi_display_xfer_agreement(starget);
1655 		break;
1656 	}
1657 	case AC_SENT_BDR:
1658 	{
1659 		WARN_ON(lun != CAM_LUN_WILDCARD);
1660 		scsi_report_device_reset(ahc->platform_data->host,
1661 					 channel - 'A', target);
1662 		break;
1663 	}
1664 	case AC_BUS_RESET:
1665 		if (ahc->platform_data->host != NULL) {
1666 			scsi_report_bus_reset(ahc->platform_data->host,
1667 					      channel - 'A');
1668 		}
1669 		break;
1670 	default:
1671 		panic("ahc_send_async: Unexpected async event");
1672 	}
1673 }
1674 
1675 /*
1676  * Calls the higher level scsi done function and frees the scb.
1677  */
1678 void
ahc_done(struct ahc_softc * ahc,struct scb * scb)1679 ahc_done(struct ahc_softc *ahc, struct scb *scb)
1680 {
1681 	struct scsi_cmnd *cmd;
1682 	struct	   ahc_linux_device *dev;
1683 
1684 	LIST_REMOVE(scb, pending_links);
1685 	if ((scb->flags & SCB_UNTAGGEDQ) != 0) {
1686 		struct scb_tailq *untagged_q;
1687 		int target_offset;
1688 
1689 		target_offset = SCB_GET_TARGET_OFFSET(ahc, scb);
1690 		untagged_q = &(ahc->untagged_queues[target_offset]);
1691 		TAILQ_REMOVE(untagged_q, scb, links.tqe);
1692 		BUG_ON(!TAILQ_EMPTY(untagged_q));
1693 	} else if ((scb->flags & SCB_ACTIVE) == 0) {
1694 		/*
1695 		 * Transactions aborted from the untagged queue may
1696 		 * not have been dispatched to the controller, so
1697 		 * only check the SCB_ACTIVE flag for tagged transactions.
1698 		 */
1699 		printk("SCB %d done'd twice\n", scb->hscb->tag);
1700 		ahc_dump_card_state(ahc);
1701 		panic("Stopping for safety");
1702 	}
1703 	cmd = scb->io_ctx;
1704 	dev = scb->platform_data->dev;
1705 	dev->active--;
1706 	dev->openings++;
1707 	if ((cmd->result & (CAM_DEV_QFRZN << 16)) != 0) {
1708 		cmd->result &= ~(CAM_DEV_QFRZN << 16);
1709 		dev->qfrozen--;
1710 	}
1711 	ahc_linux_unmap_scb(ahc, scb);
1712 
1713 	/*
1714 	 * Guard against stale sense data.
1715 	 * The Linux mid-layer assumes that sense
1716 	 * was retrieved anytime the first byte of
1717 	 * the sense buffer looks "sane".
1718 	 */
1719 	cmd->sense_buffer[0] = 0;
1720 	if (ahc_get_transaction_status(scb) == CAM_REQ_INPROG) {
1721 #ifdef AHC_REPORT_UNDERFLOWS
1722 		uint32_t amount_xferred;
1723 
1724 		amount_xferred =
1725 		    ahc_get_transfer_length(scb) - ahc_get_residual(scb);
1726 #endif
1727 		if ((scb->flags & SCB_TRANSMISSION_ERROR) != 0) {
1728 #ifdef AHC_DEBUG
1729 			if ((ahc_debug & AHC_SHOW_MISC) != 0) {
1730 				ahc_print_path(ahc, scb);
1731 				printk("Set CAM_UNCOR_PARITY\n");
1732 			}
1733 #endif
1734 			ahc_set_transaction_status(scb, CAM_UNCOR_PARITY);
1735 #ifdef AHC_REPORT_UNDERFLOWS
1736 		/*
1737 		 * This code is disabled by default as some
1738 		 * clients of the SCSI system do not properly
1739 		 * initialize the underflow parameter.  This
1740 		 * results in spurious termination of commands
1741 		 * that complete as expected (e.g. underflow is
1742 		 * allowed as command can return variable amounts
1743 		 * of data.
1744 		 */
1745 		} else if (amount_xferred < scb->io_ctx->underflow) {
1746 			u_int i;
1747 
1748 			ahc_print_path(ahc, scb);
1749 			printk("CDB:");
1750 			for (i = 0; i < scb->io_ctx->cmd_len; i++)
1751 				printk(" 0x%x", scb->io_ctx->cmnd[i]);
1752 			printk("\n");
1753 			ahc_print_path(ahc, scb);
1754 			printk("Saw underflow (%ld of %ld bytes). "
1755 			       "Treated as error\n",
1756 				ahc_get_residual(scb),
1757 				ahc_get_transfer_length(scb));
1758 			ahc_set_transaction_status(scb, CAM_DATA_RUN_ERR);
1759 #endif
1760 		} else {
1761 			ahc_set_transaction_status(scb, CAM_REQ_CMP);
1762 		}
1763 	} else if (ahc_get_transaction_status(scb) == CAM_SCSI_STATUS_ERROR) {
1764 		ahc_linux_handle_scsi_status(ahc, cmd->device, scb);
1765 	}
1766 
1767 	if (dev->openings == 1
1768 	 && ahc_get_transaction_status(scb) == CAM_REQ_CMP
1769 	 && ahc_get_scsi_status(scb) != SAM_STAT_TASK_SET_FULL)
1770 		dev->tag_success_count++;
1771 	/*
1772 	 * Some devices deal with temporary internal resource
1773 	 * shortages by returning queue full.  When the queue
1774 	 * full occurrs, we throttle back.  Slowly try to get
1775 	 * back to our previous queue depth.
1776 	 */
1777 	if ((dev->openings + dev->active) < dev->maxtags
1778 	 && dev->tag_success_count > AHC_TAG_SUCCESS_INTERVAL) {
1779 		dev->tag_success_count = 0;
1780 		dev->openings++;
1781 	}
1782 
1783 	if (dev->active == 0)
1784 		dev->commands_since_idle_or_otag = 0;
1785 
1786 	if ((scb->flags & SCB_RECOVERY_SCB) != 0) {
1787 		printk("Recovery SCB completes\n");
1788 		if (ahc_get_transaction_status(scb) == CAM_BDR_SENT
1789 		 || ahc_get_transaction_status(scb) == CAM_REQ_ABORTED)
1790 			ahc_set_transaction_status(scb, CAM_CMD_TIMEOUT);
1791 
1792 		if (ahc->platform_data->eh_done)
1793 			complete(ahc->platform_data->eh_done);
1794 	}
1795 
1796 	ahc_free_scb(ahc, scb);
1797 	ahc_linux_queue_cmd_complete(ahc, cmd);
1798 }
1799 
1800 static void
ahc_linux_handle_scsi_status(struct ahc_softc * ahc,struct scsi_device * sdev,struct scb * scb)1801 ahc_linux_handle_scsi_status(struct ahc_softc *ahc,
1802 			     struct scsi_device *sdev, struct scb *scb)
1803 {
1804 	struct	ahc_devinfo devinfo;
1805 	struct ahc_linux_device *dev = scsi_transport_device_data(sdev);
1806 
1807 	ahc_compile_devinfo(&devinfo,
1808 			    ahc->our_id,
1809 			    sdev->sdev_target->id, sdev->lun,
1810 			    sdev->sdev_target->channel == 0 ? 'A' : 'B',
1811 			    ROLE_INITIATOR);
1812 
1813 	/*
1814 	 * We don't currently trust the mid-layer to
1815 	 * properly deal with queue full or busy.  So,
1816 	 * when one occurs, we tell the mid-layer to
1817 	 * unconditionally requeue the command to us
1818 	 * so that we can retry it ourselves.  We also
1819 	 * implement our own throttling mechanism so
1820 	 * we don't clobber the device with too many
1821 	 * commands.
1822 	 */
1823 	switch (ahc_get_scsi_status(scb)) {
1824 	default:
1825 		break;
1826 	case SAM_STAT_CHECK_CONDITION:
1827 	case SAM_STAT_COMMAND_TERMINATED:
1828 	{
1829 		struct scsi_cmnd *cmd;
1830 
1831 		/*
1832 		 * Copy sense information to the OS's cmd
1833 		 * structure if it is available.
1834 		 */
1835 		cmd = scb->io_ctx;
1836 		if (scb->flags & SCB_SENSE) {
1837 			u_int sense_size;
1838 
1839 			sense_size = min(sizeof(struct scsi_sense_data)
1840 				       - ahc_get_sense_residual(scb),
1841 					 (u_long)SCSI_SENSE_BUFFERSIZE);
1842 			memcpy(cmd->sense_buffer,
1843 			       ahc_get_sense_buf(ahc, scb), sense_size);
1844 			if (sense_size < SCSI_SENSE_BUFFERSIZE)
1845 				memset(&cmd->sense_buffer[sense_size], 0,
1846 				       SCSI_SENSE_BUFFERSIZE - sense_size);
1847 #ifdef AHC_DEBUG
1848 			if (ahc_debug & AHC_SHOW_SENSE) {
1849 				int i;
1850 
1851 				printk("Copied %d bytes of sense data:",
1852 				       sense_size);
1853 				for (i = 0; i < sense_size; i++) {
1854 					if ((i & 0xF) == 0)
1855 						printk("\n");
1856 					printk("0x%x ", cmd->sense_buffer[i]);
1857 				}
1858 				printk("\n");
1859 			}
1860 #endif
1861 		}
1862 		break;
1863 	}
1864 	case SAM_STAT_TASK_SET_FULL:
1865 	{
1866 		/*
1867 		 * By the time the core driver has returned this
1868 		 * command, all other commands that were queued
1869 		 * to us but not the device have been returned.
1870 		 * This ensures that dev->active is equal to
1871 		 * the number of commands actually queued to
1872 		 * the device.
1873 		 */
1874 		dev->tag_success_count = 0;
1875 		if (dev->active != 0) {
1876 			/*
1877 			 * Drop our opening count to the number
1878 			 * of commands currently outstanding.
1879 			 */
1880 			dev->openings = 0;
1881 /*
1882 			ahc_print_path(ahc, scb);
1883 			printk("Dropping tag count to %d\n", dev->active);
1884  */
1885 			if (dev->active == dev->tags_on_last_queuefull) {
1886 
1887 				dev->last_queuefull_same_count++;
1888 				/*
1889 				 * If we repeatedly see a queue full
1890 				 * at the same queue depth, this
1891 				 * device has a fixed number of tag
1892 				 * slots.  Lock in this tag depth
1893 				 * so we stop seeing queue fulls from
1894 				 * this device.
1895 				 */
1896 				if (dev->last_queuefull_same_count
1897 				 == AHC_LOCK_TAGS_COUNT) {
1898 					dev->maxtags = dev->active;
1899 					ahc_print_path(ahc, scb);
1900 					printk("Locking max tag count at %d\n",
1901 					       dev->active);
1902 				}
1903 			} else {
1904 				dev->tags_on_last_queuefull = dev->active;
1905 				dev->last_queuefull_same_count = 0;
1906 			}
1907 			ahc_set_transaction_status(scb, CAM_REQUEUE_REQ);
1908 			ahc_set_scsi_status(scb, SAM_STAT_GOOD);
1909 			ahc_platform_set_tags(ahc, sdev, &devinfo,
1910 				     (dev->flags & AHC_DEV_Q_BASIC)
1911 				   ? AHC_QUEUE_BASIC : AHC_QUEUE_TAGGED);
1912 			break;
1913 		}
1914 		/*
1915 		 * Drop down to a single opening, and treat this
1916 		 * as if the target returned BUSY SCSI status.
1917 		 */
1918 		dev->openings = 1;
1919 		ahc_set_scsi_status(scb, SAM_STAT_BUSY);
1920 		ahc_platform_set_tags(ahc, sdev, &devinfo,
1921 			     (dev->flags & AHC_DEV_Q_BASIC)
1922 			   ? AHC_QUEUE_BASIC : AHC_QUEUE_TAGGED);
1923 		break;
1924 	}
1925 	}
1926 }
1927 
1928 static void
ahc_linux_queue_cmd_complete(struct ahc_softc * ahc,struct scsi_cmnd * cmd)1929 ahc_linux_queue_cmd_complete(struct ahc_softc *ahc, struct scsi_cmnd *cmd)
1930 {
1931 	/*
1932 	 * Map CAM error codes into Linux Error codes.  We
1933 	 * avoid the conversion so that the DV code has the
1934 	 * full error information available when making
1935 	 * state change decisions.
1936 	 */
1937 	{
1938 		u_int new_status;
1939 
1940 		switch (ahc_cmd_get_transaction_status(cmd)) {
1941 		case CAM_REQ_INPROG:
1942 		case CAM_REQ_CMP:
1943 		case CAM_SCSI_STATUS_ERROR:
1944 			new_status = DID_OK;
1945 			break;
1946 		case CAM_REQ_ABORTED:
1947 			new_status = DID_ABORT;
1948 			break;
1949 		case CAM_BUSY:
1950 			new_status = DID_BUS_BUSY;
1951 			break;
1952 		case CAM_REQ_INVALID:
1953 		case CAM_PATH_INVALID:
1954 			new_status = DID_BAD_TARGET;
1955 			break;
1956 		case CAM_SEL_TIMEOUT:
1957 			new_status = DID_NO_CONNECT;
1958 			break;
1959 		case CAM_SCSI_BUS_RESET:
1960 		case CAM_BDR_SENT:
1961 			new_status = DID_RESET;
1962 			break;
1963 		case CAM_UNCOR_PARITY:
1964 			new_status = DID_PARITY;
1965 			break;
1966 		case CAM_CMD_TIMEOUT:
1967 			new_status = DID_TIME_OUT;
1968 			break;
1969 		case CAM_UA_ABORT:
1970 		case CAM_REQ_CMP_ERR:
1971 		case CAM_AUTOSENSE_FAIL:
1972 		case CAM_NO_HBA:
1973 		case CAM_DATA_RUN_ERR:
1974 		case CAM_UNEXP_BUSFREE:
1975 		case CAM_SEQUENCE_FAIL:
1976 		case CAM_CCB_LEN_ERR:
1977 		case CAM_PROVIDE_FAIL:
1978 		case CAM_REQ_TERMIO:
1979 		case CAM_UNREC_HBA_ERROR:
1980 		case CAM_REQ_TOO_BIG:
1981 			new_status = DID_ERROR;
1982 			break;
1983 		case CAM_REQUEUE_REQ:
1984 			new_status = DID_REQUEUE;
1985 			break;
1986 		default:
1987 			/* We should never get here */
1988 			new_status = DID_ERROR;
1989 			break;
1990 		}
1991 
1992 		ahc_cmd_set_transaction_status(cmd, new_status);
1993 	}
1994 
1995 	scsi_done(cmd);
1996 }
1997 
1998 static void
ahc_linux_freeze_simq(struct ahc_softc * ahc)1999 ahc_linux_freeze_simq(struct ahc_softc *ahc)
2000 {
2001 	unsigned long s;
2002 
2003 	ahc_lock(ahc, &s);
2004 	ahc->platform_data->qfrozen++;
2005 	if (ahc->platform_data->qfrozen == 1) {
2006 		scsi_block_requests(ahc->platform_data->host);
2007 
2008 		/* XXX What about Twin channels? */
2009 		ahc_platform_abort_scbs(ahc, CAM_TARGET_WILDCARD, ALL_CHANNELS,
2010 					CAM_LUN_WILDCARD, SCB_LIST_NULL,
2011 					ROLE_INITIATOR, CAM_REQUEUE_REQ);
2012 	}
2013 	ahc_unlock(ahc, &s);
2014 }
2015 
2016 static void
ahc_linux_release_simq(struct ahc_softc * ahc)2017 ahc_linux_release_simq(struct ahc_softc *ahc)
2018 {
2019 	u_long s;
2020 	int    unblock_reqs;
2021 
2022 	unblock_reqs = 0;
2023 	ahc_lock(ahc, &s);
2024 	if (ahc->platform_data->qfrozen > 0)
2025 		ahc->platform_data->qfrozen--;
2026 	if (ahc->platform_data->qfrozen == 0)
2027 		unblock_reqs = 1;
2028 	ahc_unlock(ahc, &s);
2029 	/*
2030 	 * There is still a race here.  The mid-layer
2031 	 * should keep its own freeze count and use
2032 	 * a bottom half handler to run the queues
2033 	 * so we can unblock with our own lock held.
2034 	 */
2035 	if (unblock_reqs)
2036 		scsi_unblock_requests(ahc->platform_data->host);
2037 }
2038 
2039 static int
ahc_linux_queue_recovery_cmd(struct scsi_device * sdev,struct scsi_cmnd * cmd)2040 ahc_linux_queue_recovery_cmd(struct scsi_device *sdev,
2041 			     struct scsi_cmnd *cmd)
2042 {
2043 	struct ahc_softc *ahc;
2044 	struct ahc_linux_device *dev;
2045 	struct scb *pending_scb = NULL, *scb;
2046 	u_int  saved_scbptr;
2047 	u_int  active_scb_index;
2048 	u_int  last_phase;
2049 	u_int  saved_scsiid;
2050 	u_int  cdb_byte;
2051 	int    retval;
2052 	int    was_paused;
2053 	int    paused;
2054 	int    wait;
2055 	int    disconnected;
2056 	unsigned long flags;
2057 
2058 	paused = FALSE;
2059 	wait = FALSE;
2060 	ahc = *(struct ahc_softc **)sdev->host->hostdata;
2061 
2062 	sdev_printk(KERN_INFO, sdev, "Attempting to queue a%s message\n",
2063 	       cmd ? "n ABORT" : " TARGET RESET");
2064 
2065 	if (cmd) {
2066 		printk("CDB:");
2067 		for (cdb_byte = 0; cdb_byte < cmd->cmd_len; cdb_byte++)
2068 			printk(" 0x%x", cmd->cmnd[cdb_byte]);
2069 		printk("\n");
2070 	}
2071 
2072 	ahc_lock(ahc, &flags);
2073 
2074 	/*
2075 	 * First determine if we currently own this command.
2076 	 * Start by searching the device queue.  If not found
2077 	 * there, check the pending_scb list.  If not found
2078 	 * at all, and the system wanted us to just abort the
2079 	 * command, return success.
2080 	 */
2081 	dev = scsi_transport_device_data(sdev);
2082 
2083 	if (dev == NULL) {
2084 		/*
2085 		 * No target device for this command exists,
2086 		 * so we must not still own the command.
2087 		 */
2088 		printk("%s:%d:%d:%d: Is not an active device\n",
2089 		       ahc_name(ahc), sdev->channel, sdev->id, (u8)sdev->lun);
2090 		retval = SUCCESS;
2091 		goto no_cmd;
2092 	}
2093 
2094 	if (cmd && (dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED)) == 0
2095 	 && ahc_search_untagged_queues(ahc, cmd, cmd->device->id,
2096 				       cmd->device->channel + 'A',
2097 				       (u8)cmd->device->lun,
2098 				       CAM_REQ_ABORTED, SEARCH_COMPLETE) != 0) {
2099 		printk("%s:%d:%d:%d: Command found on untagged queue\n",
2100 		       ahc_name(ahc), cmd->device->channel, cmd->device->id,
2101 		       (u8)cmd->device->lun);
2102 		retval = SUCCESS;
2103 		goto done;
2104 	}
2105 
2106 	/*
2107 	 * See if we can find a matching cmd in the pending list.
2108 	 */
2109 	if (cmd) {
2110 		LIST_FOREACH(scb, &ahc->pending_scbs, pending_links) {
2111 			if (scb->io_ctx == cmd) {
2112 				pending_scb = scb;
2113 				break;
2114 			}
2115 		}
2116 	} else {
2117 		/* Any SCB for this device will do for a target reset */
2118 		LIST_FOREACH(scb, &ahc->pending_scbs, pending_links) {
2119 			if (ahc_match_scb(ahc, scb, sdev->id,
2120 					  sdev->channel + 'A',
2121 					  CAM_LUN_WILDCARD,
2122 					  SCB_LIST_NULL, ROLE_INITIATOR)) {
2123 				pending_scb = scb;
2124 				break;
2125 			}
2126 		}
2127 	}
2128 
2129 	if (pending_scb == NULL) {
2130 		sdev_printk(KERN_INFO, sdev, "Command not found\n");
2131 		goto no_cmd;
2132 	}
2133 
2134 	if ((pending_scb->flags & SCB_RECOVERY_SCB) != 0) {
2135 		/*
2136 		 * We can't queue two recovery actions using the same SCB
2137 		 */
2138 		retval = FAILED;
2139 		goto  done;
2140 	}
2141 
2142 	/*
2143 	 * Ensure that the card doesn't do anything
2144 	 * behind our back and that we didn't "just" miss
2145 	 * an interrupt that would affect this cmd.
2146 	 */
2147 	was_paused = ahc_is_paused(ahc);
2148 	ahc_pause_and_flushwork(ahc);
2149 	paused = TRUE;
2150 
2151 	if ((pending_scb->flags & SCB_ACTIVE) == 0) {
2152 		scmd_printk(KERN_INFO, cmd, "Command already completed\n");
2153 		goto no_cmd;
2154 	}
2155 
2156 	printk("%s: At time of recovery, card was %spaused\n",
2157 	       ahc_name(ahc), was_paused ? "" : "not ");
2158 	ahc_dump_card_state(ahc);
2159 
2160 	disconnected = TRUE;
2161 	if (cmd) {
2162 		if (ahc_search_qinfifo(ahc, sdev->id,
2163 				       sdev->channel + 'A',
2164 				       sdev->lun,
2165 				       pending_scb->hscb->tag,
2166 				       ROLE_INITIATOR, CAM_REQ_ABORTED,
2167 				       SEARCH_COMPLETE) > 0) {
2168 			printk("%s:%d:%d:%d: Cmd aborted from QINFIFO\n",
2169 			       ahc_name(ahc), sdev->channel,
2170 			       sdev->id, (u8)sdev->lun);
2171 			retval = SUCCESS;
2172 			goto done;
2173 		}
2174 	} else if (ahc_search_qinfifo(ahc, sdev->id,
2175 				      sdev->channel + 'A',
2176 				      sdev->lun,
2177 				      pending_scb->hscb->tag,
2178 				      ROLE_INITIATOR, /*status*/0,
2179 				      SEARCH_COUNT) > 0) {
2180 		disconnected = FALSE;
2181 	}
2182 
2183 	if (disconnected && (ahc_inb(ahc, SEQ_FLAGS) & NOT_IDENTIFIED) == 0) {
2184 		struct scb *bus_scb;
2185 
2186 		bus_scb = ahc_lookup_scb(ahc, ahc_inb(ahc, SCB_TAG));
2187 		if (bus_scb == pending_scb)
2188 			disconnected = FALSE;
2189 		else if (!cmd
2190 		      && ahc_inb(ahc, SAVED_SCSIID) == pending_scb->hscb->scsiid
2191 		      && ahc_inb(ahc, SAVED_LUN) == SCB_GET_LUN(pending_scb))
2192 			disconnected = FALSE;
2193 	}
2194 
2195 	/*
2196 	 * At this point, pending_scb is the scb associated with the
2197 	 * passed in command.  That command is currently active on the
2198 	 * bus, is in the disconnected state, or we're hoping to find
2199 	 * a command for the same target active on the bus to abuse to
2200 	 * send a BDR.  Queue the appropriate message based on which of
2201 	 * these states we are in.
2202 	 */
2203 	last_phase = ahc_inb(ahc, LASTPHASE);
2204 	saved_scbptr = ahc_inb(ahc, SCBPTR);
2205 	active_scb_index = ahc_inb(ahc, SCB_TAG);
2206 	saved_scsiid = ahc_inb(ahc, SAVED_SCSIID);
2207 	if (last_phase != P_BUSFREE
2208 	 && (pending_scb->hscb->tag == active_scb_index
2209 	  || (!cmd && SCSIID_TARGET(ahc, saved_scsiid) == sdev->id))) {
2210 
2211 		/*
2212 		 * We're active on the bus, so assert ATN
2213 		 * and hope that the target responds.
2214 		 */
2215 		pending_scb = ahc_lookup_scb(ahc, active_scb_index);
2216 		pending_scb->flags |= SCB_RECOVERY_SCB;
2217 		pending_scb->flags |= cmd ? SCB_ABORT : SCB_DEVICE_RESET;
2218 		ahc_outb(ahc, MSG_OUT, HOST_MSG);
2219 		ahc_outb(ahc, SCSISIGO, last_phase|ATNO);
2220 		sdev_printk(KERN_INFO, sdev, "Device is active, asserting ATN\n");
2221 		wait = TRUE;
2222 	} else if (disconnected) {
2223 
2224 		/*
2225 		 * Actually re-queue this SCB in an attempt
2226 		 * to select the device before it reconnects.
2227 		 * In either case (selection or reselection),
2228 		 * we will now issue the approprate message
2229 		 * to the timed-out device.
2230 		 *
2231 		 * Set the MK_MESSAGE control bit indicating
2232 		 * that we desire to send a message.  We
2233 		 * also set the disconnected flag since
2234 		 * in the paging case there is no guarantee
2235 		 * that our SCB control byte matches the
2236 		 * version on the card.  We don't want the
2237 		 * sequencer to abort the command thinking
2238 		 * an unsolicited reselection occurred.
2239 		 */
2240 		pending_scb->hscb->control |= MK_MESSAGE|DISCONNECTED;
2241 		pending_scb->flags |= SCB_RECOVERY_SCB;
2242 		pending_scb->flags |= cmd ? SCB_ABORT : SCB_DEVICE_RESET;
2243 
2244 		/*
2245 		 * Remove any cached copy of this SCB in the
2246 		 * disconnected list in preparation for the
2247 		 * queuing of our abort SCB.  We use the
2248 		 * same element in the SCB, SCB_NEXT, for
2249 		 * both the qinfifo and the disconnected list.
2250 		 */
2251 		ahc_search_disc_list(ahc, sdev->id,
2252 				     sdev->channel + 'A',
2253 				     sdev->lun, pending_scb->hscb->tag,
2254 				     /*stop_on_first*/TRUE,
2255 				     /*remove*/TRUE,
2256 				     /*save_state*/FALSE);
2257 
2258 		/*
2259 		 * In the non-paging case, the sequencer will
2260 		 * never re-reference the in-core SCB.
2261 		 * To make sure we are notified during
2262 		 * reselection, set the MK_MESSAGE flag in
2263 		 * the card's copy of the SCB.
2264 		 */
2265 		if ((ahc->flags & AHC_PAGESCBS) == 0) {
2266 			ahc_outb(ahc, SCBPTR, pending_scb->hscb->tag);
2267 			ahc_outb(ahc, SCB_CONTROL,
2268 				 ahc_inb(ahc, SCB_CONTROL)|MK_MESSAGE);
2269 		}
2270 
2271 		/*
2272 		 * Clear out any entries in the QINFIFO first
2273 		 * so we are the next SCB for this target
2274 		 * to run.
2275 		 */
2276 		ahc_search_qinfifo(ahc, sdev->id,
2277 				   sdev->channel + 'A',
2278 				   (u8)sdev->lun, SCB_LIST_NULL,
2279 				   ROLE_INITIATOR, CAM_REQUEUE_REQ,
2280 				   SEARCH_COMPLETE);
2281 		ahc_qinfifo_requeue_tail(ahc, pending_scb);
2282 		ahc_outb(ahc, SCBPTR, saved_scbptr);
2283 		ahc_print_path(ahc, pending_scb);
2284 		printk("Device is disconnected, re-queuing SCB\n");
2285 		wait = TRUE;
2286 	} else {
2287 		sdev_printk(KERN_INFO, sdev, "Unable to deliver message\n");
2288 		retval = FAILED;
2289 		goto done;
2290 	}
2291 
2292 no_cmd:
2293 	/*
2294 	 * Our assumption is that if we don't have the command, no
2295 	 * recovery action was required, so we return success.  Again,
2296 	 * the semantics of the mid-layer recovery engine are not
2297 	 * well defined, so this may change in time.
2298 	 */
2299 	retval = SUCCESS;
2300 done:
2301 	if (paused)
2302 		ahc_unpause(ahc);
2303 	if (wait) {
2304 		DECLARE_COMPLETION_ONSTACK(done);
2305 
2306 		ahc->platform_data->eh_done = &done;
2307 		ahc_unlock(ahc, &flags);
2308 
2309 		printk("Recovery code sleeping\n");
2310 		if (!wait_for_completion_timeout(&done, 5 * HZ)) {
2311 			ahc_lock(ahc, &flags);
2312 			ahc->platform_data->eh_done = NULL;
2313 			ahc_unlock(ahc, &flags);
2314 
2315 			printk("Timer Expired\n");
2316 			retval = FAILED;
2317 		}
2318 		printk("Recovery code awake\n");
2319 	} else
2320 		ahc_unlock(ahc, &flags);
2321 	return (retval);
2322 }
2323 
ahc_linux_set_width(struct scsi_target * starget,int width)2324 static void ahc_linux_set_width(struct scsi_target *starget, int width)
2325 {
2326 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2327 	struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);
2328 	struct ahc_devinfo devinfo;
2329 	unsigned long flags;
2330 
2331 	ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2332 			    starget->channel + 'A', ROLE_INITIATOR);
2333 	ahc_lock(ahc, &flags);
2334 	ahc_set_width(ahc, &devinfo, width, AHC_TRANS_GOAL, FALSE);
2335 	ahc_unlock(ahc, &flags);
2336 }
2337 
ahc_linux_set_period(struct scsi_target * starget,int period)2338 static void ahc_linux_set_period(struct scsi_target *starget, int period)
2339 {
2340 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2341 	struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);
2342 	struct ahc_tmode_tstate *tstate;
2343 	struct ahc_initiator_tinfo *tinfo
2344 		= ahc_fetch_transinfo(ahc,
2345 				      starget->channel + 'A',
2346 				      shost->this_id, starget->id, &tstate);
2347 	struct ahc_devinfo devinfo;
2348 	unsigned int ppr_options = tinfo->goal.ppr_options;
2349 	unsigned long flags;
2350 	unsigned long offset = tinfo->goal.offset;
2351 	const struct ahc_syncrate *syncrate;
2352 
2353 	if (offset == 0)
2354 		offset = MAX_OFFSET;
2355 
2356 	if (period < 9)
2357 		period = 9;	/* 12.5ns is our minimum */
2358 	if (period == 9) {
2359 		if (spi_max_width(starget))
2360 			ppr_options |= MSG_EXT_PPR_DT_REQ;
2361 		else
2362 			/* need wide for DT and need DT for 12.5 ns */
2363 			period = 10;
2364 	}
2365 
2366 	ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2367 			    starget->channel + 'A', ROLE_INITIATOR);
2368 
2369 	/* all PPR requests apart from QAS require wide transfers */
2370 	if (ppr_options & ~MSG_EXT_PPR_QAS_REQ) {
2371 		if (spi_width(starget) == 0)
2372 			ppr_options &= MSG_EXT_PPR_QAS_REQ;
2373 	}
2374 
2375 	syncrate = ahc_find_syncrate(ahc, &period, &ppr_options,
2376 				     AHC_SYNCRATE_DT);
2377 	ahc_lock(ahc, &flags);
2378 	ahc_set_syncrate(ahc, &devinfo, syncrate, period, offset,
2379 			 ppr_options, AHC_TRANS_GOAL, FALSE);
2380 	ahc_unlock(ahc, &flags);
2381 }
2382 
ahc_linux_set_offset(struct scsi_target * starget,int offset)2383 static void ahc_linux_set_offset(struct scsi_target *starget, int offset)
2384 {
2385 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2386 	struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);
2387 	struct ahc_tmode_tstate *tstate;
2388 	struct ahc_initiator_tinfo *tinfo
2389 		= ahc_fetch_transinfo(ahc,
2390 				      starget->channel + 'A',
2391 				      shost->this_id, starget->id, &tstate);
2392 	struct ahc_devinfo devinfo;
2393 	unsigned int ppr_options = 0;
2394 	unsigned int period = 0;
2395 	unsigned long flags;
2396 	const struct ahc_syncrate *syncrate = NULL;
2397 
2398 	ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2399 			    starget->channel + 'A', ROLE_INITIATOR);
2400 	if (offset != 0) {
2401 		syncrate = ahc_find_syncrate(ahc, &period, &ppr_options,
2402 					     AHC_SYNCRATE_DT);
2403 		period = tinfo->goal.period;
2404 		ppr_options = tinfo->goal.ppr_options;
2405 	}
2406 	ahc_lock(ahc, &flags);
2407 	ahc_set_syncrate(ahc, &devinfo, syncrate, period, offset,
2408 			 ppr_options, AHC_TRANS_GOAL, FALSE);
2409 	ahc_unlock(ahc, &flags);
2410 }
2411 
ahc_linux_set_dt(struct scsi_target * starget,int dt)2412 static void ahc_linux_set_dt(struct scsi_target *starget, int dt)
2413 {
2414 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2415 	struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);
2416 	struct ahc_tmode_tstate *tstate;
2417 	struct ahc_initiator_tinfo *tinfo
2418 		= ahc_fetch_transinfo(ahc,
2419 				      starget->channel + 'A',
2420 				      shost->this_id, starget->id, &tstate);
2421 	struct ahc_devinfo devinfo;
2422 	unsigned int ppr_options = tinfo->goal.ppr_options
2423 		& ~MSG_EXT_PPR_DT_REQ;
2424 	unsigned int period = tinfo->goal.period;
2425 	unsigned int width = tinfo->goal.width;
2426 	unsigned long flags;
2427 	const struct ahc_syncrate *syncrate;
2428 
2429 	if (dt && spi_max_width(starget)) {
2430 		ppr_options |= MSG_EXT_PPR_DT_REQ;
2431 		if (!width)
2432 			ahc_linux_set_width(starget, 1);
2433 	} else if (period == 9)
2434 		period = 10;	/* if resetting DT, period must be >= 25ns */
2435 
2436 	ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2437 			    starget->channel + 'A', ROLE_INITIATOR);
2438 	syncrate = ahc_find_syncrate(ahc, &period, &ppr_options,
2439 				     AHC_SYNCRATE_DT);
2440 	ahc_lock(ahc, &flags);
2441 	ahc_set_syncrate(ahc, &devinfo, syncrate, period, tinfo->goal.offset,
2442 			 ppr_options, AHC_TRANS_GOAL, FALSE);
2443 	ahc_unlock(ahc, &flags);
2444 }
2445 
2446 #if 0
2447 /* FIXME: This code claims to support IU and QAS.  However, the actual
2448  * sequencer code and aic7xxx_core have no support for these parameters and
2449  * will get into a bad state if they're negotiated.  Do not enable this
2450  * unless you know what you're doing */
2451 static void ahc_linux_set_qas(struct scsi_target *starget, int qas)
2452 {
2453 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2454 	struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);
2455 	struct ahc_tmode_tstate *tstate;
2456 	struct ahc_initiator_tinfo *tinfo
2457 		= ahc_fetch_transinfo(ahc,
2458 				      starget->channel + 'A',
2459 				      shost->this_id, starget->id, &tstate);
2460 	struct ahc_devinfo devinfo;
2461 	unsigned int ppr_options = tinfo->goal.ppr_options
2462 		& ~MSG_EXT_PPR_QAS_REQ;
2463 	unsigned int period = tinfo->goal.period;
2464 	unsigned long flags;
2465 	struct ahc_syncrate *syncrate;
2466 
2467 	if (qas)
2468 		ppr_options |= MSG_EXT_PPR_QAS_REQ;
2469 
2470 	ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2471 			    starget->channel + 'A', ROLE_INITIATOR);
2472 	syncrate = ahc_find_syncrate(ahc, &period, &ppr_options,
2473 				     AHC_SYNCRATE_DT);
2474 	ahc_lock(ahc, &flags);
2475 	ahc_set_syncrate(ahc, &devinfo, syncrate, period, tinfo->goal.offset,
2476 			 ppr_options, AHC_TRANS_GOAL, FALSE);
2477 	ahc_unlock(ahc, &flags);
2478 }
2479 
2480 static void ahc_linux_set_iu(struct scsi_target *starget, int iu)
2481 {
2482 	struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
2483 	struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);
2484 	struct ahc_tmode_tstate *tstate;
2485 	struct ahc_initiator_tinfo *tinfo
2486 		= ahc_fetch_transinfo(ahc,
2487 				      starget->channel + 'A',
2488 				      shost->this_id, starget->id, &tstate);
2489 	struct ahc_devinfo devinfo;
2490 	unsigned int ppr_options = tinfo->goal.ppr_options
2491 		& ~MSG_EXT_PPR_IU_REQ;
2492 	unsigned int period = tinfo->goal.period;
2493 	unsigned long flags;
2494 	struct ahc_syncrate *syncrate;
2495 
2496 	if (iu)
2497 		ppr_options |= MSG_EXT_PPR_IU_REQ;
2498 
2499 	ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,
2500 			    starget->channel + 'A', ROLE_INITIATOR);
2501 	syncrate = ahc_find_syncrate(ahc, &period, &ppr_options,
2502 				     AHC_SYNCRATE_DT);
2503 	ahc_lock(ahc, &flags);
2504 	ahc_set_syncrate(ahc, &devinfo, syncrate, period, tinfo->goal.offset,
2505 			 ppr_options, AHC_TRANS_GOAL, FALSE);
2506 	ahc_unlock(ahc, &flags);
2507 }
2508 #endif
2509 
ahc_linux_get_signalling(struct Scsi_Host * shost)2510 static void ahc_linux_get_signalling(struct Scsi_Host *shost)
2511 {
2512 	struct ahc_softc *ahc = *(struct ahc_softc **)shost->hostdata;
2513 	unsigned long flags;
2514 	u8 mode;
2515 
2516 	if (!(ahc->features & AHC_ULTRA2)) {
2517 		/* non-LVD chipset, may not have SBLKCTL reg */
2518 		spi_signalling(shost) =
2519 			ahc->features & AHC_HVD ?
2520 			SPI_SIGNAL_HVD :
2521 			SPI_SIGNAL_SE;
2522 		return;
2523 	}
2524 
2525 	ahc_lock(ahc, &flags);
2526 	ahc_pause(ahc);
2527 	mode = ahc_inb(ahc, SBLKCTL);
2528 	ahc_unpause(ahc);
2529 	ahc_unlock(ahc, &flags);
2530 
2531 	if (mode & ENAB40)
2532 		spi_signalling(shost) = SPI_SIGNAL_LVD;
2533 	else if (mode & ENAB20)
2534 		spi_signalling(shost) = SPI_SIGNAL_SE;
2535 	else
2536 		spi_signalling(shost) = SPI_SIGNAL_UNKNOWN;
2537 }
2538 
2539 static struct spi_function_template ahc_linux_transport_functions = {
2540 	.set_offset	= ahc_linux_set_offset,
2541 	.show_offset	= 1,
2542 	.set_period	= ahc_linux_set_period,
2543 	.show_period	= 1,
2544 	.set_width	= ahc_linux_set_width,
2545 	.show_width	= 1,
2546 	.set_dt		= ahc_linux_set_dt,
2547 	.show_dt	= 1,
2548 #if 0
2549 	.set_iu		= ahc_linux_set_iu,
2550 	.show_iu	= 1,
2551 	.set_qas	= ahc_linux_set_qas,
2552 	.show_qas	= 1,
2553 #endif
2554 	.get_signalling	= ahc_linux_get_signalling,
2555 };
2556 
2557 
2558 
2559 static int __init
ahc_linux_init(void)2560 ahc_linux_init(void)
2561 {
2562 	/*
2563 	 * If we've been passed any parameters, process them now.
2564 	 */
2565 	if (aic7xxx)
2566 		aic7xxx_setup(aic7xxx);
2567 
2568 	ahc_linux_transport_template =
2569 		spi_attach_transport(&ahc_linux_transport_functions);
2570 	if (!ahc_linux_transport_template)
2571 		return -ENODEV;
2572 
2573 	scsi_transport_reserve_device(ahc_linux_transport_template,
2574 				      sizeof(struct ahc_linux_device));
2575 
2576 	ahc_linux_pci_init();
2577 	ahc_linux_eisa_init();
2578 	return 0;
2579 }
2580 
2581 static void
ahc_linux_exit(void)2582 ahc_linux_exit(void)
2583 {
2584 	ahc_linux_pci_exit();
2585 	ahc_linux_eisa_exit();
2586 	spi_release_transport(ahc_linux_transport_template);
2587 }
2588 
2589 module_init(ahc_linux_init);
2590 module_exit(ahc_linux_exit);
2591