aic79xx_osm.c source code [linux/drivers/scsi/aic7xxx/aic79xx_osm.c]

1	/*
2	* Adaptec AIC79xx device driver for Linux.
3	*
4	* $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic79xx_osm.c#171 $
5	*
6	* --------------------------------------------------------------------------
7	* Copyright (c) 1994-2000 Justin T. Gibbs.
8	* Copyright (c) 1997-1999 Doug Ledford
9	* Copyright (c) 2000-2003 Adaptec Inc.
10	* All rights reserved.
11	*
12	* Redistribution and use in source and binary forms, with or without
13	* modification, are permitted provided that the following conditions
14	* are met:
15	* 1. Redistributions of source code must retain the above copyright
16	* notice, this list of conditions, and the following disclaimer,
17	* without modification.
18	* 2. Redistributions in binary form must reproduce at minimum a disclaimer
19	* substantially similar to the "NO WARRANTY" disclaimer below
20	* ("Disclaimer") and any redistribution must be conditioned upon
21	* including a substantially similar Disclaimer requirement for further
22	* binary redistribution.
23	* 3. Neither the names of the above-listed copyright holders nor the names
24	* of any contributors may be used to endorse or promote products derived
25	* from this software without specific prior written permission.
26	*
27	* Alternatively, this software may be distributed under the terms of the
28	* GNU General Public License ("GPL") version 2 as published by the Free
29	* Software Foundation.
30	*
31	* NO WARRANTY
32	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36	* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42	* POSSIBILITY OF SUCH DAMAGES.
43	*/
44
45	#include "aic79xx_osm.h"
46	#include "aic79xx_inline.h"
47	#include <scsi/scsicam.h>
48
49	static struct scsi_transport_template *ahd_linux_transport_template = NULL;
50
51	#include <linux/init.h> /* __setup */
52	#include <linux/mm.h> /* For fetching system memory size */
53	#include <linux/blkdev.h> /* For block_size() */
54	#include <linux/delay.h> /* For ssleep/msleep */
55	#include <linux/device.h>
56	#include <linux/slab.h>
57
58	/*
59	* Bucket size for counting good commands in between bad ones.
60	*/
61	#define AHD_LINUX_ERR_THRESH 1000
62
63	/*
64	* Set this to the delay in seconds after SCSI bus reset.
65	* Note, we honor this only for the initial bus reset.
66	* The scsi error recovery code performs its own bus settle
67	* delay handling for error recovery actions.
68	*/
69	#ifdef CONFIG_AIC79XX_RESET_DELAY_MS
70	#define AIC79XX_RESET_DELAY CONFIG_AIC79XX_RESET_DELAY_MS
71	#else
72	#define AIC79XX_RESET_DELAY 5000
73	#endif
74
75	/*
76	* To change the default number of tagged transactions allowed per-device,
77	* add a line to the lilo.conf file like:
78	* append="aic79xx=verbose,tag_info:{{32,32,32,32},{32,32,32,32}}"
79	* which will result in the first four devices on the first two
80	* controllers being set to a tagged queue depth of 32.
81	*
82	* The tag_commands is an array of 16 to allow for wide and twin adapters.
83	* Twin adapters will use indexes 0-7 for channel 0, and indexes 8-15
84	* for channel 1.
85	*/
86	typedef struct {
87	uint16_t tag_commands[`16`]; / Allow for wide/twin adapters. /
88	} adapter_tag_info_t;
89
90	/*
91	* Modify this as you see fit for your system.
92	*
93	* 0 tagged queuing disabled
94	* 1 <= n <= 253 n == max tags ever dispatched.
95	*
96	* The driver will throttle the number of commands dispatched to a
97	* device if it returns queue full. For devices with a fixed maximum
98	* queue depth, the driver will eventually determine this depth and
99	* lock it in (a console message is printed to indicate that a lock
100	* has occurred). On some devices, queue full is returned for a temporary
101	* resource shortage. These devices will return queue full at varying
102	* depths. The driver will throttle back when the queue fulls occur and
103	* attempt to slowly increase the depth over time as the device recovers
104	* from the resource shortage.
105	*
106	* In this example, the first line will disable tagged queueing for all
107	* the devices on the first probed aic79xx adapter.
108	*
109	* The second line enables tagged queueing with 4 commands/LUN for IDs
110	* (0, 2-11, 13-15), disables tagged queueing for ID 12, and tells the
111	* driver to attempt to use up to 64 tags for ID 1.
112	*
113	* The third line is the same as the first line.
114	*
115	* The fourth line disables tagged queueing for devices 0 and 3. It
116	* enables tagged queueing for the other IDs, with 16 commands/LUN
117	* for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for
118	* IDs 2, 5-7, and 9-15.
119	*/
120
121	/*
122	* NOTE: The below structure is for reference only, the actual structure
123	* to modify in order to change things is just below this comment block.
124	adapter_tag_info_t aic79xx_tag_info[] =
125	{
126	{{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
127	{{4, 64, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4}},
128	{{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
129	{{0, 16, 4, 0, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}}
130	};
131	*/
132
133	#ifdef CONFIG_AIC79XX_CMDS_PER_DEVICE
134	#define AIC79XX_CMDS_PER_DEVICE CONFIG_AIC79XX_CMDS_PER_DEVICE
135	#else
136	#define AIC79XX_CMDS_PER_DEVICE AHD_MAX_QUEUE
137	#endif
138
139	#define AIC79XX_CONFIGED_TAG_COMMANDS { \
140	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE, \
141	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE, \
142	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE, \
143	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE, \
144	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE, \
145	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE, \
146	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE, \
147	AIC79XX_CMDS_PER_DEVICE, AIC79XX_CMDS_PER_DEVICE \
148	}
149
150	/*
151	* By default, use the number of commands specified by
152	* the users kernel configuration.
153	*/
154	static adapter_tag_info_t aic79xx_tag_info[] =
155	{
156	{AIC79XX_CONFIGED_TAG_COMMANDS},
157	{AIC79XX_CONFIGED_TAG_COMMANDS},
158	{AIC79XX_CONFIGED_TAG_COMMANDS},
159	{AIC79XX_CONFIGED_TAG_COMMANDS},
160	{AIC79XX_CONFIGED_TAG_COMMANDS},
161	{AIC79XX_CONFIGED_TAG_COMMANDS},
162	{AIC79XX_CONFIGED_TAG_COMMANDS},
163	{AIC79XX_CONFIGED_TAG_COMMANDS},
164	{AIC79XX_CONFIGED_TAG_COMMANDS},
165	{AIC79XX_CONFIGED_TAG_COMMANDS},
166	{AIC79XX_CONFIGED_TAG_COMMANDS},
167	{AIC79XX_CONFIGED_TAG_COMMANDS},
168	{AIC79XX_CONFIGED_TAG_COMMANDS},
169	{AIC79XX_CONFIGED_TAG_COMMANDS},
170	{AIC79XX_CONFIGED_TAG_COMMANDS},
171	{AIC79XX_CONFIGED_TAG_COMMANDS}
172	};
173
174	/*
175	* The I/O cell on the chip is very configurable in respect to its analog
176	* characteristics. Set the defaults here; they can be overriden with
177	* the proper insmod parameters.
178	*/
179	struct ahd_linux_iocell_opts
180	{
181	uint8_t precomp;
182	uint8_t slewrate;
183	uint8_t amplitude;
184	};
185	#define AIC79XX_DEFAULT_PRECOMP 0xFF
186	#define AIC79XX_DEFAULT_SLEWRATE 0xFF
187	#define AIC79XX_DEFAULT_AMPLITUDE 0xFF
188	#define AIC79XX_DEFAULT_IOOPTS \
189	{ \
190	AIC79XX_DEFAULT_PRECOMP, \
191	AIC79XX_DEFAULT_SLEWRATE, \
192	AIC79XX_DEFAULT_AMPLITUDE \
193	}
194	#define AIC79XX_PRECOMP_INDEX 0
195	#define AIC79XX_SLEWRATE_INDEX 1
196	#define AIC79XX_AMPLITUDE_INDEX 2
197	static struct ahd_linux_iocell_opts aic79xx_iocell_info[] __ro_after_init =
198	{
199	AIC79XX_DEFAULT_IOOPTS,
200	AIC79XX_DEFAULT_IOOPTS,
201	AIC79XX_DEFAULT_IOOPTS,
202	AIC79XX_DEFAULT_IOOPTS,
203	AIC79XX_DEFAULT_IOOPTS,
204	AIC79XX_DEFAULT_IOOPTS,
205	AIC79XX_DEFAULT_IOOPTS,
206	AIC79XX_DEFAULT_IOOPTS,
207	AIC79XX_DEFAULT_IOOPTS,
208	AIC79XX_DEFAULT_IOOPTS,
209	AIC79XX_DEFAULT_IOOPTS,
210	AIC79XX_DEFAULT_IOOPTS,
211	AIC79XX_DEFAULT_IOOPTS,
212	AIC79XX_DEFAULT_IOOPTS,
213	AIC79XX_DEFAULT_IOOPTS,
214	AIC79XX_DEFAULT_IOOPTS
215	};
216
217	/*
218	* There should be a specific return value for this in scsi.h, but
219	* it seems that most drivers ignore it.
220	*/
221	#define DID_UNDERFLOW DID_ERROR
222
223	void
224	ahd_print_path(struct ahd_softc ahd, struct* scb *scb)
225	{
226	printk("(scsi%d:%c:%d:%d): ",
227	ahd->platform_data->host->host_no,
228	scb != NULL ? SCB_GET_CHANNEL(ahd, scb) : `'X'`,
229	scb != NULL ? SCB_GET_TARGET(ahd, scb) : -`1`,
230	scb != NULL ? SCB_GET_LUN(scb) : -`1`);
231	}
232
233	/*
234	* XXX - these options apply unilaterally to _all_ adapters
235	* cards in the system. This should be fixed. Exceptions to this
236	* rule are noted in the comments.
237	*/
238
239	/*
240	* Skip the scsi bus reset. Non 0 make us skip the reset at startup. This
241	* has no effect on any later resets that might occur due to things like
242	* SCSI bus timeouts.
243	*/
244	static uint32_t aic79xx_no_reset;
245
246	/*
247	* Should we force EXTENDED translation on a controller.
248	* 0 == Use whatever is in the SEEPROM or default to off
249	* 1 == Use whatever is in the SEEPROM or default to on
250	*/
251	static uint32_t aic79xx_extended;
252
253	/*
254	* PCI bus parity checking of the Adaptec controllers. This is somewhat
255	* dubious at best. To my knowledge, this option has never actually
256	* solved a PCI parity problem, but on certain machines with broken PCI
257	* chipset configurations, it can generate tons of false error messages.
258	* It's included in the driver for completeness.
259	* 0 = Shut off PCI parity check
260	* non-0 = Enable PCI parity check
261	*
262	* NOTE: you can't actually pass -1 on the lilo prompt. So, to set this
263	* variable to -1 you would actually want to simply pass the variable
264	* name without a number. That will invert the 0 which will result in
265	* -1.
266	*/
267	static uint32_t aic79xx_pci_parity = ~`0`;
268
269	/*
270	* There are lots of broken chipsets in the world. Some of them will
271	* violate the PCI spec when we issue byte sized memory writes to our
272	* controller. I/O mapped register access, if allowed by the given
273	* platform, will work in almost all cases.
274	*/
275	uint32_t aic79xx_allow_memio = ~`0`;
276
277	/*
278	* So that we can set how long each device is given as a selection timeout.
279	* The table of values goes like this:
280	* 0 - 256ms
281	* 1 - 128ms
282	* 2 - 64ms
283	* 3 - 32ms
284	* We default to 256ms because some older devices need a longer time
285	* to respond to initial selection.
286	*/
287	static uint32_t aic79xx_seltime;
288
289	/*
290	* Certain devices do not perform any aging on commands. Should the
291	* device be saturated by commands in one portion of the disk, it is
292	* possible for transactions on far away sectors to never be serviced.
293	* To handle these devices, we can periodically send an ordered tag to
294	* force all outstanding transactions to be serviced prior to a new
295	* transaction.
296	*/
297	static uint32_t aic79xx_periodic_otag;
298
299	/ Some storage boxes are using an LSI chip which has a bug making it*
300	* impossible to use aic79xx Rev B chip in 320 speeds. The following
301	* storage boxes have been reported to be buggy:
302	* EonStor 3U 16-Bay: U16U-G3A3
303	* EonStor 2U 12-Bay: U12U-G3A3
304	* SentinelRAID: 2500F R5 / R6
305	* SentinelRAID: 2500F R1
306	* SentinelRAID: 2500F/1500F
307	* SentinelRAID: 150F
308	*
309	* To get around this LSI bug, you can set your board to 160 mode
310	* or you can enable the SLOWCRC bit.
311	*/
312	uint32_t aic79xx_slowcrc;
313
314	/*
315	* Module information and settable options.
316	*/
317	static char *aic79xx = NULL;
318
319	MODULE_AUTHOR("Maintainer: Hannes Reinecke <hare@suse.de>");
320	MODULE_DESCRIPTION("Adaptec AIC790X U320 SCSI Host Bus Adapter driver");
321	MODULE_LICENSE("Dual BSD/GPL");
322	MODULE_VERSION(AIC79XX_DRIVER_VERSION);
323	module_param(aic79xx, charp, `0444`);
324	MODULE_PARM_DESC(aic79xx,
325	"period-delimited options string:\n"
326	" verbose Enable verbose/diagnostic logging\n"
327	" allow_memio Allow device registers to be memory mapped\n"
328	" debug Bitmask of debug values to enable\n"
329	" no_reset Suppress initial bus resets\n"
330	" extended Enable extended geometry on all controllers\n"
331	" periodic_otag Send an ordered tagged transaction\n"
332	" periodically to prevent tag starvation.\n"
333	" This may be required by some older disk\n"
334	" or drives/RAID arrays.\n"
335	" tag_info:<tag_str> Set per-target tag depth\n"
336	" global_tag_depth:<int> Global tag depth for all targets on all buses\n"
337	" slewrate:<slewrate_list>Set the signal slew rate (0-15).\n"
338	" precomp:<pcomp_list> Set the signal precompensation (0-7).\n"
339	" amplitude:<int> Set the signal amplitude (0-7).\n"
340	" seltime:<int> Selection Timeout:\n"
341	" (0/256ms,1/128ms,2/64ms,3/32ms)\n"
342	" slowcrc Turn on the SLOWCRC bit (Rev B only)\n"
343	"\n"
344	" Sample modprobe configuration file:\n"
345	" # Enable verbose logging\n"
346	" # Set tag depth on Controller 2/Target 2 to 10 tags\n"
347	" # Shorten the selection timeout to 128ms\n"
348	"\n"
349	" options aic79xx 'aic79xx=verbose.tag_info:{{}.{}.{..10}}.seltime:1'\n"
350	);
351
352	static void ahd_linux_handle_scsi_status(struct ahd_softc *,
353	struct scsi_device *,
354	struct scb *);
355	static void ahd_linux_queue_cmd_complete(struct ahd_softc *ahd,
356	struct scsi_cmnd *cmd);
357	static int ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd);
358	static void ahd_linux_initialize_scsi_bus(struct ahd_softc *ahd);
359	static u_int ahd_linux_user_tagdepth(struct ahd_softc *ahd,
360	struct ahd_devinfo *devinfo);
361	static void ahd_linux_device_queue_depth(struct scsi_device *);
362	static int ahd_linux_run_command(struct ahd_softc*,
363	struct ahd_linux_device *,
364	struct scsi_cmnd *);
365	static void ahd_linux_setup_tag_info_global(char *p);
366	static int aic79xx_setup(char *c);
367	static void ahd_freeze_simq(struct ahd_softc *ahd);
368	static void ahd_release_simq(struct ahd_softc *ahd);
369
370	static int ahd_linux_unit;
371
372
373	/*********************** OS Utility Wrappers ****************************/
374	void ahd_delay(long);
375	void
376	ahd_delay(long usec)
377	{
378	/*
379	* udelay on Linux can have problems for
380	* multi-millisecond waits. Wait at most
381	* 1024us per call.
382	*/
383	while (usec > `0`) {
384	udelay(usec % `1024`);
385	usec -= `1024`;
386	}
387	}
388
389
390	/************************** Low Level I/O *******************************/
391	uint8_t ahd_inb(struct ahd_softc * ahd, long port);
392	void ahd_outb(struct ahd_softc * ahd, long port, uint8_t val);
393	void ahd_outw_atomic(struct ahd_softc * ahd,
394	long port, uint16_t val);
395	void ahd_outsb(struct ahd_softc * ahd, long port,
396	uint8_t , int* count);
397	void ahd_insb(struct ahd_softc * ahd, long port,
398	uint8_t , int* count);
399
400	uint8_t
401	ahd_inb(struct ahd_softc * ahd, long port)
402	{
403	uint8_t x;
404
405	if (ahd->tags[`0`] == BUS_SPACE_MEMIO) {
406	x = readb(addr: ahd->bshs[`0`].maddr + port);
407	} else {
408	x = inb(port: ahd->bshs[(port) >> `8`].ioport + ((port) & `0xFF`));
409	}
410	mb();
411	return (x);
412	}
413
414	#if 0 /* unused */
415	static uint16_t
416	ahd_inw_atomic(struct ahd_softc * ahd, long port)
417	{
418	uint8_t x;
419
420	if (ahd->tags[`0`] == BUS_SPACE_MEMIO) {
421	x = readw(ahd->bshs[`0`].maddr + port);
422	} else {
423	x = inw(ahd->bshs[(port) >> `8`].ioport + ((port) & `0xFF`));
424	}
425	mb();
426	return (x);
427	}
428	#endif
429
430	void
431	ahd_outb(struct ahd_softc * ahd, long port, uint8_t val)
432	{
433	if (ahd->tags[`0`] == BUS_SPACE_MEMIO) {
434	writeb(val, addr: ahd->bshs[`0`].maddr + port);
435	} else {
436	outb(value: val, port: ahd->bshs[(port) >> `8`].ioport + (port & `0xFF`));
437	}
438	mb();
439	}
440
441	void
442	ahd_outw_atomic(struct ahd_softc * ahd, long port, uint16_t val)
443	{
444	if (ahd->tags[`0`] == BUS_SPACE_MEMIO) {
445	writew(val, addr: ahd->bshs[`0`].maddr + port);
446	} else {
447	outw(value: val, port: ahd->bshs[(port) >> `8`].ioport + (port & `0xFF`));
448	}
449	mb();
450	}
451
452	void
453	ahd_outsb(struct ahd_softc * ahd, long port, uint8_t array, int* count)
454	{
455	int i;
456
457	/*
458	* There is probably a more efficient way to do this on Linux
459	* but we don't use this for anything speed critical and this
460	* should work.
461	*/
462	for (i = `0`; i < count; i++)
463	ahd_outb(ahd, port, val: *array++);
464	}
465
466	void
467	ahd_insb(struct ahd_softc * ahd, long port, uint8_t array, int* count)
468	{
469	int i;
470
471	/*
472	* There is probably a more efficient way to do this on Linux
473	* but we don't use this for anything speed critical and this
474	* should work.
475	*/
476	for (i = `0`; i < count; i++)
477	*array++ = ahd_inb(ahd, port);
478	}
479
480	/**************************** PCI Routines ******************************/
481	uint32_t
482	ahd_pci_read_config(ahd_dev_softc_t pci, int reg, int width)
483	{
484	switch (width) {
485	case `1`:
486	{
487	uint8_t retval;
488
489	pci_read_config_byte(dev: pci, where: reg, val: &retval);
490	return (retval);
491	}
492	case `2`:
493	{
494	uint16_t retval;
495	pci_read_config_word(dev: pci, where: reg, val: &retval);
496	return (retval);
497	}
498	case `4`:
499	{
500	uint32_t retval;
501	pci_read_config_dword(dev: pci, where: reg, val: &retval);
502	return (retval);
503	}
504	default:
505	panic(fmt: "ahd_pci_read_config: Read size too big");
506	/ NOTREACHED /
507	return (`0`);
508	}
509	}
510
511	void
512	ahd_pci_write_config(ahd_dev_softc_t pci, int reg, uint32_t value, int width)
513	{
514	switch (width) {
515	case `1`:
516	pci_write_config_byte(dev: pci, where: reg, val: value);
517	break;
518	case `2`:
519	pci_write_config_word(dev: pci, where: reg, val: value);
520	break;
521	case `4`:
522	pci_write_config_dword(dev: pci, where: reg, val: value);
523	break;
524	default:
525	panic(fmt: "ahd_pci_write_config: Write size too big");
526	/ NOTREACHED /
527	}
528	}
529
530	/*************************** Inlines ************************************/
531	static void ahd_linux_unmap_scb(struct ahd_softc, struct* scb*);
532
533	static void
534	ahd_linux_unmap_scb(struct ahd_softc ahd, struct* scb *scb)
535	{
536	struct scsi_cmnd *cmd;
537
538	cmd = scb->io_ctx;
539	if (cmd) {
540	ahd_sync_sglist(ahd, scb, BUS_DMASYNC_POSTWRITE);
541	scsi_dma_unmap(cmd);
542	}
543	}
544
545	/***************************** Macros ***********************************/
546	static inline unsigned int ahd_build_scsiid(struct ahd_softc *ahd,
547	struct scsi_device *sdev)
548	{
549	return ((sdev_id(sdev) << TID_SHIFT) & TID) \| (ahd)->our_id;
550	}
551
552	/*
553	* Return a string describing the driver.
554	*/
555	static const char *
556	ahd_linux_info(struct Scsi_Host *host)
557	{
558	static char buffer[`512`];
559	char ahd_info[`256`];
560	char *bp;
561	struct ahd_softc *ahd;
562
563	bp = &buffer[`0`];
564	ahd = (struct* ahd_softc **)host->hostdata;
565	memset(bp, `0`, sizeof(buffer));
566	strcpy(p: bp, q: "Adaptec AIC79XX PCI-X SCSI HBA DRIVER, Rev " AIC79XX_DRIVER_VERSION "\n"
567	" <");
568	strcat(p: bp, q: ahd->description);
569	strcat(p: bp, q: ">\n"
570	" ");
571	ahd_controller_info(ahd, buf: ahd_info);
572	strcat(p: bp, q: ahd_info);
573
574	return (bp);
575	}
576
577	/*
578	* Queue an SCB to the controller.
579	*/
580	static int ahd_linux_queue_lck(struct scsi_cmnd *cmd)
581	{
582	struct ahd_softc *ahd;
583	struct ahd_linux_device *dev = scsi_transport_device_data(sdev: cmd->device);
584	int rtn = SCSI_MLQUEUE_HOST_BUSY;
585
586	ahd = (struct* ahd_softc **)cmd->device->host->hostdata;
587
588	cmd->result = CAM_REQ_INPROG << `16`;
589	rtn = ahd_linux_run_command(ahd, dev, cmd);
590
591	return rtn;
592	}
593
594	static DEF_SCSI_QCMD(ahd_linux_queue)
595
596	static struct scsi_target **
597	ahd_linux_target_in_softc(struct scsi_target *starget)
598	{
599	struct ahd_softc *ahd =
600	((struct* ahd_softc **)dev_to_shost(dev: &starget->dev)->hostdata);
601	unsigned int target_offset;
602
603	target_offset = starget->id;
604	if (starget->channel != `0`)
605	target_offset += `8`;
606
607	return &ahd->platform_data->starget[target_offset];
608	}
609
610	static int
611	ahd_linux_target_alloc(struct scsi_target *starget)
612	{
613	struct ahd_softc *ahd =
614	((struct* ahd_softc **)dev_to_shost(dev: &starget->dev)->hostdata);
615	struct seeprom_config *sc = ahd->seep_config;
616	unsigned long flags;
617	struct scsi_target **ahd_targp = ahd_linux_target_in_softc(starget);
618	struct ahd_devinfo devinfo;
619	struct ahd_initiator_tinfo *tinfo;
620	struct ahd_tmode_tstate *tstate;
621	char channel = starget->channel + `'A'`;
622
623	ahd_lock(ahd, flags: &flags);
624
625	BUG_ON(*ahd_targp != NULL);
626
627	*ahd_targp = starget;
628
629	if (sc) {
630	int flags = sc->device_flags[starget->id];
631
632	tinfo = ahd_fetch_transinfo(ahd, channel: `'A'`, our_id: ahd->our_id,
633	remote_id: starget->id, tstate: &tstate);
634
635	if ((flags & CFPACKETIZED) == `0`) {
636	/ don't negotiate packetized (IU) transfers /
637	spi_max_iu(starget) = `0`;
638	} else {
639	if ((ahd->features & AHD_RTI) == `0`)
640	spi_rti(starget) = `0`;
641	}
642
643	if ((flags & CFQAS) == `0`)
644	spi_max_qas(starget) = `0`;
645
646	/ Transinfo values have been set to BIOS settings /
647	spi_max_width(starget) = (flags & CFWIDEB) ? `1` : `0`;
648	spi_min_period(starget) = tinfo->user.period;
649	spi_max_offset(starget) = tinfo->user.offset;
650	}
651
652	tinfo = ahd_fetch_transinfo(ahd, channel, our_id: ahd->our_id,
653	remote_id: starget->id, tstate: &tstate);
654	ahd_compile_devinfo(devinfo: &devinfo, our_id: ahd->our_id, target: starget->id,
655	CAM_LUN_WILDCARD, channel,
656	role: ROLE_INITIATOR);
657	ahd_set_syncrate(ahd, devinfo: &devinfo, period: `0`, offset: `0`, ppr_options: `0`,
658	AHD_TRANS_GOAL, /paused/FALSE);
659	ahd_set_width(ahd, devinfo: &devinfo, MSG_EXT_WDTR_BUS_8_BIT,
660	AHD_TRANS_GOAL, /paused/FALSE);
661	ahd_unlock(ahd, flags: &flags);
662
663	return `0`;
664	}
665
666	static void
667	ahd_linux_target_destroy(struct scsi_target *starget)
668	{
669	struct scsi_target **ahd_targp = ahd_linux_target_in_softc(starget);
670
671	*ahd_targp = NULL;
672	}
673
674	static int
675	ahd_linux_slave_alloc(struct scsi_device *sdev)
676	{
677	struct ahd_softc *ahd =
678	((struct* ahd_softc **)sdev->host->hostdata);
679	struct ahd_linux_device *dev;
680
681	if (bootverbose)
682	printk("%s: Slave Alloc %d\n", ahd_name(ahd), sdev->id);
683
684	dev = scsi_transport_device_data(sdev);
685	memset(dev, `0`, sizeof(*dev));
686
687	/*
688	* We start out life using untagged
689	* transactions of which we allow one.
690	*/
691	dev->openings = `1`;
692
693	/*
694	* Set maxtags to 0. This will be changed if we
695	* later determine that we are dealing with
696	* a tagged queuing capable device.
697	*/
698	dev->maxtags = `0`;
699
700	return (`0`);
701	}
702
703	static int
704	ahd_linux_slave_configure(struct scsi_device *sdev)
705	{
706	if (bootverbose)
707	sdev_printk(KERN_INFO, sdev, "Slave Configure\n");
708
709	ahd_linux_device_queue_depth(sdev);
710
711	/ Initial Domain Validation /
712	if (!spi_initial_dv(sdev->sdev_target))
713	spi_dv_device(sdev);
714
715	return `0`;
716	}
717
718	#if defined(__i386__)
719	/*
720	* Return the disk geometry for the given SCSI device.
721	*/
722	static int
723	ahd_linux_biosparam(struct scsi_device sdev, struct* block_device *bdev,
724	sector_t capacity, int geom[])
725	{
726	int heads;
727	int sectors;
728	int cylinders;
729	int extended;
730	struct ahd_softc *ahd;
731
732	ahd = ((struct* ahd_softc **)sdev->host->hostdata);
733
734	if (scsi_partsize(bdev, capacity, geom))
735	return `0`;
736
737	heads = `64`;
738	sectors = `32`;
739	cylinders = aic_sector_div(capacity, heads, sectors);
740
741	if (aic79xx_extended != `0`)
742	extended = `1`;
743	else
744	extended = (ahd->flags & AHD_EXTENDED_TRANS_A) != `0`;
745	if (extended && cylinders >= `1024`) {
746	heads = `255`;
747	sectors = `63`;
748	cylinders = aic_sector_div(capacity, heads, sectors);
749	}
750	geom[`0`] = heads;
751	geom[`1`] = sectors;
752	geom[`2`] = cylinders;
753	return (`0`);
754	}
755	#endif
756
757	/*
758	* Abort the current SCSI command(s).
759	*/
760	static int
761	ahd_linux_abort(struct scsi_cmnd *cmd)
762	{
763	return ahd_linux_queue_abort_cmd(cmd);
764	}
765
766	/*
767	* Attempt to send a target reset message to the device that timed out.
768	*/
769	static int
770	ahd_linux_dev_reset(struct scsi_cmnd *cmd)
771	{
772	struct ahd_softc *ahd;
773	struct ahd_linux_device *dev;
774	struct scb *reset_scb;
775	u_int cdb_byte;
776	int retval = SUCCESS;
777	struct ahd_initiator_tinfo *tinfo;
778	struct ahd_tmode_tstate *tstate;
779	unsigned long flags;
780	DECLARE_COMPLETION_ONSTACK(done);
781
782	reset_scb = NULL;
783
784	ahd = (struct* ahd_softc **)cmd->device->host->hostdata;
785
786	scmd_printk(KERN_INFO, cmd,
787	"Attempting to queue a TARGET RESET message:");
788
789	printk("CDB:");
790	for (cdb_byte = `0`; cdb_byte < cmd->cmd_len; cdb_byte++)
791	printk(" 0x%x", cmd->cmnd[cdb_byte]);
792	printk("\n");
793
794	/*
795	* Determine if we currently own this command.
796	*/
797	dev = scsi_transport_device_data(sdev: cmd->device);
798
799	if (dev == NULL) {
800	/*
801	* No target device for this command exists,
802	* so we must not still own the command.
803	*/
804	scmd_printk(KERN_INFO, cmd, "Is not an active device\n");
805	return SUCCESS;
806	}
807
808	/*
809	* Generate us a new SCB
810	*/
811	reset_scb = ahd_get_scb(ahd, AHD_NEVER_COL_IDX);
812	if (!reset_scb) {
813	scmd_printk(KERN_INFO, cmd, "No SCB available\n");
814	return FAILED;
815	}
816
817	tinfo = ahd_fetch_transinfo(ahd, channel: `'A'`, our_id: ahd->our_id,
818	remote_id: cmd->device->id, tstate: &tstate);
819	reset_scb->io_ctx = NULL;
820	reset_scb->platform_data->dev = dev;
821	reset_scb->sg_count = `0`;
822	ahd_set_residual(scb: reset_scb, resid: `0`);
823	ahd_set_sense_residual(scb: reset_scb, resid: `0`);
824	reset_scb->platform_data->xfer_len = `0`;
825	reset_scb->hscb->control = `0`;
826	reset_scb->hscb->scsiid = ahd_build_scsiid(ahd, sdev: cmd->device);
827	reset_scb->hscb->lun = cmd->device->lun;
828	reset_scb->hscb->cdb_len = `0`;
829	reset_scb->hscb->task_management = SIU_TASKMGMT_LUN_RESET;
830	reset_scb->flags \|= SCB_DEVICE_RESET\|SCB_RECOVERY_SCB\|SCB_ACTIVE;
831	if ((tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ) != `0`) {
832	reset_scb->flags \|= SCB_PACKETIZED;
833	} else {
834	reset_scb->hscb->control \|= MK_MESSAGE;
835	}
836	dev->openings--;
837	dev->active++;
838	dev->commands_issued++;
839
840	ahd_lock(ahd, flags: &flags);
841
842	LIST_INSERT_HEAD(&ahd->pending_scbs, reset_scb, pending_links);
843	ahd_queue_scb(ahd, scb: reset_scb);
844
845	ahd->platform_data->eh_done = &done;
846	ahd_unlock(ahd, flags: &flags);
847
848	printk("%s: Device reset code sleeping\n", ahd_name(ahd));
849	if (!wait_for_completion_timeout(x: &done, timeout: `5` * HZ)) {
850	ahd_lock(ahd, flags: &flags);
851	ahd->platform_data->eh_done = NULL;
852	ahd_unlock(ahd, flags: &flags);
853	printk("%s: Device reset timer expired (active %d)\n",
854	ahd_name(ahd), dev->active);
855	retval = FAILED;
856	}
857	printk("%s: Device reset returning 0x%x\n", ahd_name(ahd), retval);
858
859	return (retval);
860	}
861
862	/*
863	* Reset the SCSI bus.
864	*/
865	static int
866	ahd_linux_bus_reset(struct scsi_cmnd *cmd)
867	{
868	struct ahd_softc *ahd;
869	int found;
870	unsigned long flags;
871
872	ahd = (struct* ahd_softc **)cmd->device->host->hostdata;
873	#ifdef AHD_DEBUG
874	if ((ahd_debug & AHD_SHOW_RECOVERY) != `0`)
875	printk("%s: Bus reset called for cmd %p\n",
876	ahd_name(ahd), cmd);
877	#endif
878	ahd_lock(ahd, flags: &flags);
879
880	found = ahd_reset_channel(ahd, scmd_channel(cmd) + `'A'`,
881	/initiate reset/TRUE);
882	ahd_unlock(ahd, flags: &flags);
883
884	if (bootverbose)
885	printk("%s: SCSI bus reset delivered. "
886	"%d SCBs aborted.\n", ahd_name(ahd), found);
887
888	return (SUCCESS);
889	}
890
891	struct scsi_host_template aic79xx_driver_template = {
892	.module = THIS_MODULE,
893	.name = "aic79xx",
894	.proc_name = "aic79xx",
895	.show_info = ahd_linux_show_info,
896	.write_info = ahd_proc_write_seeprom,
897	.info = ahd_linux_info,
898	.queuecommand = ahd_linux_queue,
899	.eh_abort_handler = ahd_linux_abort,
900	.eh_device_reset_handler = ahd_linux_dev_reset,
901	.eh_bus_reset_handler = ahd_linux_bus_reset,
902	#if defined(__i386__)
903	.bios_param = ahd_linux_biosparam,
904	#endif
905	.can_queue = AHD_MAX_QUEUE,
906	.this_id = -`1`,
907	.max_sectors = `8192`,
908	.cmd_per_lun = `2`,
909	.slave_alloc = ahd_linux_slave_alloc,
910	.slave_configure = ahd_linux_slave_configure,
911	.target_alloc = ahd_linux_target_alloc,
912	.target_destroy = ahd_linux_target_destroy,
913	};
914
915	/***************************** Bus DMA **********************************/
916	int
917	ahd_dma_tag_create(struct ahd_softc *ahd, bus_dma_tag_t parent,
918	bus_size_t alignment, bus_size_t boundary,
919	dma_addr_t lowaddr, dma_addr_t highaddr,
920	bus_dma_filter_t filter, void* *filterarg,
921	bus_size_t maxsize, int nsegments,
922	bus_size_t maxsegsz, int flags, bus_dma_tag_t *ret_tag)
923	{
924	bus_dma_tag_t dmat;
925
926	dmat = kmalloc(size: sizeof(*dmat), GFP_ATOMIC);
927	if (dmat == NULL)
928	return (ENOMEM);
929
930	/*
931	* Linux is very simplistic about DMA memory. For now don't
932	* maintain all specification information. Once Linux supplies
933	* better facilities for doing these operations, or the
934	* needs of this particular driver change, we might need to do
935	* more here.
936	*/
937	dmat->alignment = alignment;
938	dmat->boundary = boundary;
939	dmat->maxsize = maxsize;
940	*ret_tag = dmat;
941	return (`0`);
942	}
943
944	void
945	ahd_dma_tag_destroy(struct ahd_softc *ahd, bus_dma_tag_t dmat)
946	{
947	kfree(objp: dmat);
948	}
949
950	int
951	ahd_dmamem_alloc(struct ahd_softc ahd, bus_dma_tag_t dmat, void*** vaddr,
952	int flags, bus_dmamap_t *mapp)
953	{
954	*vaddr = dma_alloc_coherent(dev: &ahd->dev_softc->dev, size: dmat->maxsize, dma_handle: mapp,
955	GFP_ATOMIC);
956	if (*vaddr == NULL)
957	return (ENOMEM);
958	return(`0`);
959	}
960
961	void
962	ahd_dmamem_free(struct ahd_softc *ahd, bus_dma_tag_t dmat,
963	void* vaddr, bus_dmamap_t map)
964	{
965	dma_free_coherent(dev: &ahd->dev_softc->dev, size: dmat->maxsize, cpu_addr: vaddr, dma_handle: map);
966	}
967
968	int
969	ahd_dmamap_load(struct ahd_softc *ahd, bus_dma_tag_t dmat, bus_dmamap_t map,
970	void buf, bus_size_t buflen, bus_dmamap_callback_t cb,
971	void cb_arg, int* flags)
972	{
973	/*
974	* Assume for now that this will only be used during
975	* initialization and not for per-transaction buffer mapping.
976	*/
977	bus_dma_segment_t stack_sg;
978
979	stack_sg.ds_addr = map;
980	stack_sg.ds_len = dmat->maxsize;
981	cb(cb_arg, &stack_sg, /nseg/`1`, /error/`0`);
982	return (`0`);
983	}
984
985	void
986	ahd_dmamap_destroy(struct ahd_softc *ahd, bus_dma_tag_t dmat, bus_dmamap_t map)
987	{
988	}
989
990	int
991	ahd_dmamap_unload(struct ahd_softc *ahd, bus_dma_tag_t dmat, bus_dmamap_t map)
992	{
993	/ Nothing to do /
994	return (`0`);
995	}
996
997	/****************** Platform Dependent Functions ************************/
998	static void
999	ahd_linux_setup_iocell_info(u_long index, int instance, int targ, int32_t value)
1000	{
1001
1002	if ((instance >= `0`)
1003	&& (instance < ARRAY_SIZE(aic79xx_iocell_info))) {
1004	uint8_t *iocell_info;
1005
1006	iocell_info = (uint8_t*)&aic79xx_iocell_info[instance];
1007	iocell_info[index] = value & `0xFFFF`;
1008	if (bootverbose)
1009	printk("iocell[%d:%ld] = %d\n", instance, index, value);
1010	}
1011	}
1012
1013	static void
1014	ahd_linux_setup_tag_info_global(char *p)
1015	{
1016	int tags, i, j;
1017
1018	tags = simple_strtoul(p + `1`, NULL, `0`) & `0xff`;
1019	printk("Setting Global Tags= %d\n", tags);
1020
1021	for (i = `0`; i < ARRAY_SIZE(aic79xx_tag_info); i++) {
1022	for (j = `0`; j < AHD_NUM_TARGETS; j++) {
1023	aic79xx_tag_info[i].tag_commands[j] = tags;
1024	}
1025	}
1026	}
1027
1028	static void
1029	ahd_linux_setup_tag_info(u_long arg, int instance, int targ, int32_t value)
1030	{
1031
1032	if ((instance >= `0`) && (targ >= `0`)
1033	&& (instance < ARRAY_SIZE(aic79xx_tag_info))
1034	&& (targ < AHD_NUM_TARGETS)) {
1035	aic79xx_tag_info[instance].tag_commands[targ] = value & `0x1FF`;
1036	if (bootverbose)
1037	printk("tag_info[%d:%d] = %d\n", instance, targ, value);
1038	}
1039	}
1040
1041	static char *
1042	ahd_parse_brace_option(char opt_name, char* opt_arg, char* end, int* depth,
1043	void (callback)(u_long, int, int*, int32_t),
1044	u_long callback_arg)
1045	{
1046	char *tok_end;
1047	char *tok_end2;
1048	int i;
1049	int instance;
1050	int targ;
1051	int done;
1052	char tok_list[] = {`'.'`, `','`, `'{'`, `'}'`, `'\0'`};
1053
1054	/ All options use a ':' name/arg separator /
1055	if (*opt_arg != `':'`)
1056	return (opt_arg);
1057	opt_arg++;
1058	instance = -`1`;
1059	targ = -`1`;
1060	done = FALSE;
1061	/*
1062	* Restore separator that may be in
1063	* the middle of our option argument.
1064	*/
1065	tok_end = strchr(opt_arg, `'\0'`);
1066	if (tok_end < end)
1067	*tok_end = `','`;
1068	while (!done) {
1069	switch (*opt_arg) {
1070	case `'{'`:
1071	if (instance == -`1`) {
1072	instance = `0`;
1073	} else {
1074	if (depth > `1`) {
1075	if (targ == -`1`)
1076	targ = `0`;
1077	} else {
1078	printk("Malformed Option %s\n",
1079	opt_name);
1080	done = TRUE;
1081	}
1082	}
1083	opt_arg++;
1084	break;
1085	case `'}'`:
1086	if (targ != -`1`)
1087	targ = -`1`;
1088	else if (instance != -`1`)
1089	instance = -`1`;
1090	opt_arg++;
1091	break;
1092	case `','`:
1093	case `'.'`:
1094	if (instance == -`1`)
1095	done = TRUE;
1096	else if (targ >= `0`)
1097	targ++;
1098	else if (instance >= `0`)
1099	instance++;
1100	opt_arg++;
1101	break;
1102	case `'\0'`:
1103	done = TRUE;
1104	break;
1105	default:
1106	tok_end = end;
1107	for (i = `0`; tok_list[i]; i++) {
1108	tok_end2 = strchr(opt_arg, tok_list[i]);
1109	if ((tok_end2) && (tok_end2 < tok_end))
1110	tok_end = tok_end2;
1111	}
1112	callback(callback_arg, instance, targ,
1113	simple_strtol(opt_arg, NULL, `0`));
1114	opt_arg = tok_end;
1115	break;
1116	}
1117	}
1118	return (opt_arg);
1119	}
1120
1121	/*
1122	* Handle Linux boot parameters. This routine allows for assigning a value
1123	* to a parameter with a ':' between the parameter and the value.
1124	* ie. aic79xx=stpwlev:1,extended
1125	*/
1126	static int
1127	aic79xx_setup(char *s)
1128	{
1129	int i, n;
1130	char *p;
1131	char *end;
1132
1133	static const struct {
1134	const char *name;
1135	uint32_t *flag;
1136	} options[] = {
1137	{ "extended", &aic79xx_extended },
1138	{ "no_reset", &aic79xx_no_reset },
1139	{ "verbose", &aic79xx_verbose },
1140	{ "allow_memio", &aic79xx_allow_memio},
1141	#ifdef AHD_DEBUG
1142	{ "debug", &ahd_debug },
1143	#endif
1144	{ "periodic_otag", &aic79xx_periodic_otag },
1145	{ "pci_parity", &aic79xx_pci_parity },
1146	{ "seltime", &aic79xx_seltime },
1147	{ "tag_info", NULL },
1148	{ "global_tag_depth", NULL},
1149	{ "slewrate", NULL },
1150	{ "precomp", NULL },
1151	{ "amplitude", NULL },
1152	{ "slowcrc", &aic79xx_slowcrc },
1153	};
1154
1155	end = strchr(s, `'\0'`);
1156
1157	/*
1158	* XXX ia64 gcc isn't smart enough to know that ARRAY_SIZE
1159	* will never be 0 in this case.
1160	*/
1161	n = `0`;
1162
1163	while ((p = strsep(&s, ",.")) != NULL) {
1164	if (*p == `'\0'`)
1165	continue;
1166	for (i = `0`; i < ARRAY_SIZE(options); i++) {
1167
1168	n = strlen(options[i].name);
1169	if (strncmp(options[i].name, p, n) == `0`)
1170	break;
1171	}
1172	if (i == ARRAY_SIZE(options))
1173	continue;
1174
1175	if (strncmp(p, "global_tag_depth", n) == `0`) {
1176	ahd_linux_setup_tag_info_global(p: p + n);
1177	} else if (strncmp(p, "tag_info", n) == `0`) {
1178	s = ahd_parse_brace_option(opt_name: "tag_info", opt_arg: p + n, end,
1179	depth: `2`, callback: ahd_linux_setup_tag_info, callback_arg: `0`);
1180	} else if (strncmp(p, "slewrate", n) == `0`) {
1181	s = ahd_parse_brace_option(opt_name: "slewrate",
1182	opt_arg: p + n, end, depth: `1`, callback: ahd_linux_setup_iocell_info,
1183	AIC79XX_SLEWRATE_INDEX);
1184	} else if (strncmp(p, "precomp", n) == `0`) {
1185	s = ahd_parse_brace_option(opt_name: "precomp",
1186	opt_arg: p + n, end, depth: `1`, callback: ahd_linux_setup_iocell_info,
1187	AIC79XX_PRECOMP_INDEX);
1188	} else if (strncmp(p, "amplitude", n) == `0`) {
1189	s = ahd_parse_brace_option(opt_name: "amplitude",
1190	opt_arg: p + n, end, depth: `1`, callback: ahd_linux_setup_iocell_info,
1191	AIC79XX_AMPLITUDE_INDEX);
1192	} else if (p[n] == `':'`) {
1193	*(options[i].flag) = simple_strtoul(p + n + `1`, NULL, `0`);
1194	} else if (!strncmp(p, "verbose", n)) {
1195	*(options[i].flag) = `1`;
1196	} else {
1197	*(options[i].flag) ^= `0xFFFFFFFF`;
1198	}
1199	}
1200	return `1`;
1201	}
1202
1203	__setup("aic79xx=", aic79xx_setup);
1204
1205	uint32_t aic79xx_verbose;
1206
1207	int
1208	ahd_linux_register_host(struct ahd_softc ahd, struct* scsi_host_template *template)
1209	{
1210	char buf[`80`];
1211	struct Scsi_Host *host;
1212	char *new_name;
1213	u_long s;
1214	int retval;
1215
1216	template->name = ahd->description;
1217	host = scsi_host_alloc(template, sizeof(struct ahd_softc *));
1218	if (host == NULL)
1219	return (ENOMEM);
1220
1221	((struct* ahd_softc **)host->hostdata) = ahd;
1222	ahd->platform_data->host = host;
1223	host->can_queue = AHD_MAX_QUEUE;
1224	host->cmd_per_lun = `2`;
1225	host->sg_tablesize = AHD_NSEG;
1226	host->this_id = ahd->our_id;
1227	host->irq = ahd->platform_data->irq;
1228	host->max_id = (ahd->features & AHD_WIDE) ? `16` : `8`;
1229	host->max_lun = AHD_NUM_LUNS;
1230	host->max_channel = `0`;
1231	host->sg_tablesize = AHD_NSEG;
1232	ahd_lock(ahd, flags: &s);
1233	ahd_set_unit(ahd, ahd_linux_unit++);
1234	ahd_unlock(ahd, flags: &s);
1235	sprintf(buf, fmt: "scsi%d", host->host_no);
1236	new_name = kmalloc(strlen(buf) + `1`, GFP_ATOMIC);
1237	if (new_name != NULL) {
1238	strcpy(p: new_name, q: buf);
1239	ahd_set_name(ahd, new_name);
1240	}
1241	host->unique_id = ahd->unit;
1242	ahd_linux_initialize_scsi_bus(ahd);
1243	ahd_intr_enable(ahd, TRUE);
1244
1245	host->transportt = ahd_linux_transport_template;
1246
1247	retval = scsi_add_host(host, dev: &ahd->dev_softc->dev);
1248	if (retval) {
1249	printk(KERN_WARNING "aic79xx: scsi_add_host failed\n");
1250	scsi_host_put(t: host);
1251	return retval;
1252	}
1253
1254	scsi_scan_host(host);
1255	return `0`;
1256	}
1257
1258	/*
1259	* Place the SCSI bus into a known state by either resetting it,
1260	* or forcing transfer negotiations on the next command to any
1261	* target.
1262	*/
1263	static void
1264	ahd_linux_initialize_scsi_bus(struct ahd_softc *ahd)
1265	{
1266	u_int target_id;
1267	u_int numtarg;
1268	unsigned long s;
1269
1270	target_id = `0`;
1271	numtarg = `0`;
1272
1273	if (aic79xx_no_reset != `0`)
1274	ahd->flags &= ~AHD_RESET_BUS_A;
1275
1276	if ((ahd->flags & AHD_RESET_BUS_A) != `0`)
1277	ahd_reset_channel(ahd, channel: `'A'`, /initiate_reset/TRUE);
1278	else
1279	numtarg = (ahd->features & AHD_WIDE) ? `16` : `8`;
1280
1281	ahd_lock(ahd, flags: &s);
1282
1283	/*
1284	* Force negotiation to async for all targets that
1285	* will not see an initial bus reset.
1286	*/
1287	for (; target_id < numtarg; target_id++) {
1288	struct ahd_devinfo devinfo;
1289	struct ahd_initiator_tinfo *tinfo;
1290	struct ahd_tmode_tstate *tstate;
1291
1292	tinfo = ahd_fetch_transinfo(ahd, channel: `'A'`, our_id: ahd->our_id,
1293	remote_id: target_id, tstate: &tstate);
1294	ahd_compile_devinfo(devinfo: &devinfo, our_id: ahd->our_id, target: target_id,
1295	CAM_LUN_WILDCARD, channel: `'A'`, role: ROLE_INITIATOR);
1296	ahd_update_neg_request(ahd, &devinfo, tstate,
1297	tinfo, AHD_NEG_ALWAYS);
1298	}
1299	ahd_unlock(ahd, flags: &s);
1300	/ Give the bus some time to recover /
1301	if ((ahd->flags & AHD_RESET_BUS_A) != `0`) {
1302	ahd_freeze_simq(ahd);
1303	msleep(AIC79XX_RESET_DELAY);
1304	ahd_release_simq(ahd);
1305	}
1306	}
1307
1308	int
1309	ahd_platform_alloc(struct ahd_softc ahd, void* *platform_arg)
1310	{
1311	ahd->platform_data =
1312	kzalloc(size: sizeof(struct ahd_platform_data), GFP_ATOMIC);
1313	if (ahd->platform_data == NULL)
1314	return (ENOMEM);
1315	ahd->platform_data->irq = AHD_LINUX_NOIRQ;
1316	ahd_lockinit(ahd);
1317	ahd->seltime = (aic79xx_seltime & `0x3`) << `4`;
1318	return (`0`);
1319	}
1320
1321	void
1322	ahd_platform_free(struct ahd_softc *ahd)
1323	{
1324	struct scsi_target *starget;
1325	int i;
1326
1327	if (ahd->platform_data != NULL) {
1328	/ destroy all of the device and target objects /
1329	for (i = `0`; i < AHD_NUM_TARGETS; i++) {
1330	starget = ahd->platform_data->starget[i];
1331	if (starget != NULL) {
1332	ahd->platform_data->starget[i] = NULL;
1333	}
1334	}
1335
1336	if (ahd->platform_data->irq != AHD_LINUX_NOIRQ)
1337	free_irq(ahd->platform_data->irq, ahd);
1338	if (ahd->tags[`0`] == BUS_SPACE_PIO
1339	&& ahd->bshs[`0`].ioport != `0`)
1340	release_region(ahd->bshs[`0`].ioport, `256`);
1341	if (ahd->tags[`1`] == BUS_SPACE_PIO
1342	&& ahd->bshs[`1`].ioport != `0`)
1343	release_region(ahd->bshs[`1`].ioport, `256`);
1344	if (ahd->tags[`0`] == BUS_SPACE_MEMIO
1345	&& ahd->bshs[`0`].maddr != NULL) {
1346	iounmap(addr: ahd->bshs[`0`].maddr);
1347	release_mem_region(ahd->platform_data->mem_busaddr,
1348	`0x1000`);
1349	}
1350	if (ahd->platform_data->host)
1351	scsi_host_put(t: ahd->platform_data->host);
1352
1353	kfree(objp: ahd->platform_data);
1354	}
1355	}
1356
1357	void
1358	ahd_platform_init(struct ahd_softc *ahd)
1359	{
1360	/*
1361	* Lookup and commit any modified IO Cell options.
1362	*/
1363	if (ahd->unit < ARRAY_SIZE(aic79xx_iocell_info)) {
1364	const struct ahd_linux_iocell_opts *iocell_opts;
1365
1366	iocell_opts = &aic79xx_iocell_info[ahd->unit];
1367	if (iocell_opts->precomp != AIC79XX_DEFAULT_PRECOMP)
1368	AHD_SET_PRECOMP(ahd, iocell_opts->precomp);
1369	if (iocell_opts->slewrate != AIC79XX_DEFAULT_SLEWRATE)
1370	AHD_SET_SLEWRATE(ahd, iocell_opts->slewrate);
1371	if (iocell_opts->amplitude != AIC79XX_DEFAULT_AMPLITUDE)
1372	AHD_SET_AMPLITUDE(ahd, iocell_opts->amplitude);
1373	}
1374
1375	}
1376
1377	void
1378	ahd_platform_freeze_devq(struct ahd_softc ahd, struct* scb *scb)
1379	{
1380	ahd_platform_abort_scbs(ahd, SCB_GET_TARGET(ahd, scb),
1381	SCB_GET_CHANNEL(ahd, scb),
1382	SCB_GET_LUN(scb), SCB_LIST_NULL,
1383	ROLE_UNKNOWN, CAM_REQUEUE_REQ);
1384	}
1385
1386	void
1387	ahd_platform_set_tags(struct ahd_softc ahd, struct* scsi_device *sdev,
1388	struct ahd_devinfo *devinfo, ahd_queue_alg alg)
1389	{
1390	struct ahd_linux_device *dev;
1391	int was_queuing;
1392	int now_queuing;
1393
1394	if (sdev == NULL)
1395	return;
1396
1397	dev = scsi_transport_device_data(sdev);
1398
1399	if (dev == NULL)
1400	return;
1401	was_queuing = dev->flags & (AHD_DEV_Q_BASIC\|AHD_DEV_Q_TAGGED);
1402	switch (alg) {
1403	default:
1404	case AHD_QUEUE_NONE:
1405	now_queuing = `0`;
1406	break;
1407	case AHD_QUEUE_BASIC:
1408	now_queuing = AHD_DEV_Q_BASIC;
1409	break;
1410	case AHD_QUEUE_TAGGED:
1411	now_queuing = AHD_DEV_Q_TAGGED;
1412	break;
1413	}
1414	if ((dev->flags & AHD_DEV_FREEZE_TIL_EMPTY) == `0`
1415	&& (was_queuing != now_queuing)
1416	&& (dev->active != `0`)) {
1417	dev->flags \|= AHD_DEV_FREEZE_TIL_EMPTY;
1418	dev->qfrozen++;
1419	}
1420
1421	dev->flags &= ~(AHD_DEV_Q_BASIC\|AHD_DEV_Q_TAGGED\|AHD_DEV_PERIODIC_OTAG);
1422	if (now_queuing) {
1423	u_int usertags;
1424
1425	usertags = ahd_linux_user_tagdepth(ahd, devinfo);
1426	if (!was_queuing) {
1427	/*
1428	* Start out aggressively and allow our
1429	* dynamic queue depth algorithm to take
1430	* care of the rest.
1431	*/
1432	dev->maxtags = usertags;
1433	dev->openings = dev->maxtags - dev->active;
1434	}
1435	if (dev->maxtags == `0`) {
1436	/*
1437	* Queueing is disabled by the user.
1438	*/
1439	dev->openings = `1`;
1440	} else if (alg == AHD_QUEUE_TAGGED) {
1441	dev->flags \|= AHD_DEV_Q_TAGGED;
1442	if (aic79xx_periodic_otag != `0`)
1443	dev->flags \|= AHD_DEV_PERIODIC_OTAG;
1444	} else
1445	dev->flags \|= AHD_DEV_Q_BASIC;
1446	} else {
1447	/ We can only have one opening. /
1448	dev->maxtags = `0`;
1449	dev->openings = `1` - dev->active;
1450	}
1451
1452	switch ((dev->flags & (AHD_DEV_Q_BASIC\|AHD_DEV_Q_TAGGED))) {
1453	case AHD_DEV_Q_BASIC:
1454	case AHD_DEV_Q_TAGGED:
1455	scsi_change_queue_depth(sdev,
1456	dev->openings + dev->active);
1457	break;
1458	default:
1459	/*
1460	* We allow the OS to queue 2 untagged transactions to
1461	* us at any time even though we can only execute them
1462	* serially on the controller/device. This should
1463	* remove some latency.
1464	*/
1465	scsi_change_queue_depth(sdev, `1`);
1466	break;
1467	}
1468	}
1469
1470	int
1471	ahd_platform_abort_scbs(struct ahd_softc ahd, int* target, char channel,
1472	int lun, u_int tag, role_t role, uint32_t status)
1473	{
1474	return `0`;
1475	}
1476
1477	static u_int
1478	ahd_linux_user_tagdepth(struct ahd_softc ahd, struct* ahd_devinfo *devinfo)
1479	{
1480	static int warned_user;
1481	u_int tags;
1482
1483	tags = `0`;
1484	if ((ahd->user_discenable & devinfo->target_mask) != `0`) {
1485	if (ahd->unit >= ARRAY_SIZE(aic79xx_tag_info)) {
1486
1487	if (warned_user == `0`) {
1488	printk(KERN_WARNING
1489	"aic79xx: WARNING: Insufficient tag_info instances\n"
1490	"aic79xx: for installed controllers. Using defaults\n"
1491	"aic79xx: Please update the aic79xx_tag_info array in\n"
1492	"aic79xx: the aic79xx_osm.c source file.\n");
1493	warned_user++;
1494	}
1495	tags = AHD_MAX_QUEUE;
1496	} else {
1497	adapter_tag_info_t *tag_info;
1498
1499	tag_info = &aic79xx_tag_info[ahd->unit];
1500	tags = tag_info->tag_commands[devinfo->target_offset];
1501	if (tags > AHD_MAX_QUEUE)
1502	tags = AHD_MAX_QUEUE;
1503	}
1504	}
1505	return (tags);
1506	}
1507
1508	/*
1509	* Determines the queue depth for a given device.
1510	*/
1511	static void
1512	ahd_linux_device_queue_depth(struct scsi_device *sdev)
1513	{
1514	struct ahd_devinfo devinfo;
1515	u_int tags;
1516	struct ahd_softc ahd = ((struct ahd_softc **)sdev->host->hostdata);
1517
1518	ahd_compile_devinfo(devinfo: &devinfo,
1519	our_id: ahd->our_id,
1520	target: sdev->sdev_target->id, lun: sdev->lun,
1521	channel: sdev->sdev_target->channel == `0` ? `'A'` : `'B'`,
1522	role: ROLE_INITIATOR);
1523	tags = ahd_linux_user_tagdepth(ahd, devinfo: &devinfo);
1524	if (tags != `0` && sdev->tagged_supported != `0`) {
1525
1526	ahd_platform_set_tags(ahd, sdev, devinfo: &devinfo, alg: AHD_QUEUE_TAGGED);
1527	ahd_send_async(ahd, channel: devinfo.channel, target: devinfo.target,
1528	lun: devinfo.lun, AC_TRANSFER_NEG);
1529	ahd_print_devinfo(ahd, devinfo: &devinfo);
1530	printk("Tagged Queuing enabled. Depth %d\n", tags);
1531	} else {
1532	ahd_platform_set_tags(ahd, sdev, devinfo: &devinfo, alg: AHD_QUEUE_NONE);
1533	ahd_send_async(ahd, channel: devinfo.channel, target: devinfo.target,
1534	lun: devinfo.lun, AC_TRANSFER_NEG);
1535	}
1536	}
1537
1538	static int
1539	ahd_linux_run_command(struct ahd_softc ahd, struct* ahd_linux_device *dev,
1540	struct scsi_cmnd *cmd)
1541	{
1542	struct scb *scb;
1543	struct hardware_scb *hscb;
1544	struct ahd_initiator_tinfo *tinfo;
1545	struct ahd_tmode_tstate *tstate;
1546	u_int col_idx;
1547	uint16_t mask;
1548	unsigned long flags;
1549	int nseg;
1550
1551	nseg = scsi_dma_map(cmd);
1552	if (nseg < `0`)
1553	return SCSI_MLQUEUE_HOST_BUSY;
1554
1555	ahd_lock(ahd, flags: &flags);
1556
1557	/*
1558	* Get an scb to use.
1559	*/
1560	tinfo = ahd_fetch_transinfo(ahd, channel: `'A'`, our_id: ahd->our_id,
1561	remote_id: cmd->device->id, tstate: &tstate);
1562	if ((dev->flags & (AHD_DEV_Q_TAGGED\|AHD_DEV_Q_BASIC)) == `0`
1563	\|\| (tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ) != `0`) {
1564	col_idx = AHD_NEVER_COL_IDX;
1565	} else {
1566	col_idx = AHD_BUILD_COL_IDX(cmd->device->id,
1567	cmd->device->lun);
1568	}
1569	if ((scb = ahd_get_scb(ahd, col_idx)) == NULL) {
1570	ahd->flags \|= AHD_RESOURCE_SHORTAGE;
1571	ahd_unlock(ahd, flags: &flags);
1572	scsi_dma_unmap(cmd);
1573	return SCSI_MLQUEUE_HOST_BUSY;
1574	}
1575
1576	scb->io_ctx = cmd;
1577	scb->platform_data->dev = dev;
1578	hscb = scb->hscb;
1579	cmd->host_scribble = (char *)scb;
1580
1581	/*
1582	* Fill out basics of the HSCB.
1583	*/
1584	hscb->control = `0`;
1585	hscb->scsiid = ahd_build_scsiid(ahd, sdev: cmd->device);
1586	hscb->lun = cmd->device->lun;
1587	scb->hscb->task_management = `0`;
1588	mask = SCB_GET_TARGET_MASK(ahd, scb);
1589
1590	if ((ahd->user_discenable & mask) != `0`)
1591	hscb->control \|= DISCENB;
1592
1593	if ((tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ) != `0`)
1594	scb->flags \|= SCB_PACKETIZED;
1595
1596	if ((tstate->auto_negotiate & mask) != `0`) {
1597	scb->flags \|= SCB_AUTO_NEGOTIATE;
1598	scb->hscb->control \|= MK_MESSAGE;
1599	}
1600
1601	if ((dev->flags & (AHD_DEV_Q_TAGGED\|AHD_DEV_Q_BASIC)) != `0`) {
1602	if (dev->commands_since_idle_or_otag == AHD_OTAG_THRESH
1603	&& (dev->flags & AHD_DEV_Q_TAGGED) != `0`) {
1604	hscb->control \|= ORDERED_QUEUE_TAG;
1605	dev->commands_since_idle_or_otag = `0`;
1606	} else {
1607	hscb->control \|= SIMPLE_QUEUE_TAG;
1608	}
1609	}
1610
1611	hscb->cdb_len = cmd->cmd_len;
1612	memcpy(hscb->shared_data.idata.cdb, cmd->cmnd, hscb->cdb_len);
1613
1614	scb->platform_data->xfer_len = `0`;
1615	ahd_set_residual(scb, resid: `0`);
1616	ahd_set_sense_residual(scb, resid: `0`);
1617	scb->sg_count = `0`;
1618
1619	if (nseg > `0`) {
1620	void *sg = scb->sg_list;
1621	struct scatterlist *cur_seg;
1622	int i;
1623
1624	scb->platform_data->xfer_len = `0`;
1625
1626	scsi_for_each_sg(cmd, cur_seg, nseg, i) {
1627	dma_addr_t addr;
1628	bus_size_t len;
1629
1630	addr = sg_dma_address(cur_seg);
1631	len = sg_dma_len(cur_seg);
1632	scb->platform_data->xfer_len += len;
1633	sg = ahd_sg_setup(ahd, scb, sgptr: sg, addr, len,
1634	last: i == (nseg - `1`));
1635	}
1636	}
1637
1638	LIST_INSERT_HEAD(&ahd->pending_scbs, scb, pending_links);
1639	dev->openings--;
1640	dev->active++;
1641	dev->commands_issued++;
1642
1643	if ((dev->flags & AHD_DEV_PERIODIC_OTAG) != `0`)
1644	dev->commands_since_idle_or_otag++;
1645	scb->flags \|= SCB_ACTIVE;
1646	ahd_queue_scb(ahd, scb);
1647
1648	ahd_unlock(ahd, flags: &flags);
1649
1650	return `0`;
1651	}
1652
1653	/*
1654	* SCSI controller interrupt handler.
1655	*/
1656	irqreturn_t
1657	ahd_linux_isr(int irq, void *dev_id)
1658	{
1659	struct ahd_softc *ahd;
1660	u_long flags;
1661	int ours;
1662
1663	ahd = (struct ahd_softc *) dev_id;
1664	ahd_lock(ahd, flags: &flags);
1665	ours = ahd_intr(ahd);
1666	ahd_unlock(ahd, flags: &flags);
1667	return IRQ_RETVAL(ours);
1668	}
1669
1670	void
1671	ahd_send_async(struct ahd_softc ahd, char* channel,
1672	u_int target, u_int lun, ac_code code)
1673	{
1674	switch (code) {
1675	case AC_TRANSFER_NEG:
1676	{
1677	struct scsi_target *starget;
1678	struct ahd_initiator_tinfo *tinfo;
1679	struct ahd_tmode_tstate *tstate;
1680	unsigned int target_ppr_options;
1681
1682	BUG_ON(target == CAM_TARGET_WILDCARD);
1683
1684	tinfo = ahd_fetch_transinfo(ahd, channel, our_id: ahd->our_id,
1685	remote_id: target, tstate: &tstate);
1686
1687	/*
1688	* Don't bother reporting results while
1689	* negotiations are still pending.
1690	*/
1691	if (tinfo->curr.period != tinfo->goal.period
1692	\|\| tinfo->curr.width != tinfo->goal.width
1693	\|\| tinfo->curr.offset != tinfo->goal.offset
1694	\|\| tinfo->curr.ppr_options != tinfo->goal.ppr_options)
1695	if (bootverbose == `0`)
1696	break;
1697
1698	/*
1699	* Don't bother reporting results that
1700	* are identical to those last reported.
1701	*/
1702	starget = ahd->platform_data->starget[target];
1703	if (starget == NULL)
1704	break;
1705
1706	target_ppr_options =
1707	(spi_dt(starget) ? MSG_EXT_PPR_DT_REQ : `0`)
1708	+ (spi_qas(starget) ? MSG_EXT_PPR_QAS_REQ : `0`)
1709	+ (spi_iu(starget) ? MSG_EXT_PPR_IU_REQ : `0`)
1710	+ (spi_rd_strm(starget) ? MSG_EXT_PPR_RD_STRM : `0`)
1711	+ (spi_pcomp_en(starget) ? MSG_EXT_PPR_PCOMP_EN : `0`)
1712	+ (spi_rti(starget) ? MSG_EXT_PPR_RTI : `0`)
1713	+ (spi_wr_flow(starget) ? MSG_EXT_PPR_WR_FLOW : `0`)
1714	+ (spi_hold_mcs(starget) ? MSG_EXT_PPR_HOLD_MCS : `0`);
1715
1716	if (tinfo->curr.period == spi_period(starget)
1717	&& tinfo->curr.width == spi_width(starget)
1718	&& tinfo->curr.offset == spi_offset(starget)
1719	&& tinfo->curr.ppr_options == target_ppr_options)
1720	if (bootverbose == `0`)
1721	break;
1722
1723	spi_period(starget) = tinfo->curr.period;
1724	spi_width(starget) = tinfo->curr.width;
1725	spi_offset(starget) = tinfo->curr.offset;
1726	spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_DT_REQ ? `1` : `0`;
1727	spi_qas(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_QAS_REQ ? `1` : `0`;
1728	spi_iu(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ ? `1` : `0`;
1729	spi_rd_strm(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_RD_STRM ? `1` : `0`;
1730	spi_pcomp_en(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_PCOMP_EN ? `1` : `0`;
1731	spi_rti(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_RTI ? `1` : `0`;
1732	spi_wr_flow(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_WR_FLOW ? `1` : `0`;
1733	spi_hold_mcs(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_HOLD_MCS ? `1` : `0`;
1734	spi_display_xfer_agreement(starget);
1735	break;
1736	}
1737	case AC_SENT_BDR:
1738	{
1739	WARN_ON(lun != CAM_LUN_WILDCARD);
1740	scsi_report_device_reset(ahd->platform_data->host,
1741	channel - `'A'`, target);
1742	break;
1743	}
1744	case AC_BUS_RESET:
1745	if (ahd->platform_data->host != NULL) {
1746	scsi_report_bus_reset(ahd->platform_data->host,
1747	channel - `'A'`);
1748	}
1749	break;
1750	default:
1751	panic(fmt: "ahd_send_async: Unexpected async event");
1752	}
1753	}
1754
1755	/*
1756	* Calls the higher level scsi done function and frees the scb.
1757	*/
1758	void
1759	ahd_done(struct ahd_softc ahd, struct* scb *scb)
1760	{
1761	struct scsi_cmnd *cmd;
1762	struct ahd_linux_device *dev;
1763
1764	if ((scb->flags & SCB_ACTIVE) == `0`) {
1765	printk("SCB %d done'd twice\n", SCB_GET_TAG(scb));
1766	ahd_dump_card_state(ahd);
1767	panic(fmt: "Stopping for safety");
1768	}
1769	LIST_REMOVE(scb, pending_links);
1770	cmd = scb->io_ctx;
1771	dev = scb->platform_data->dev;
1772	dev->active--;
1773	dev->openings++;
1774	if (cmd) {
1775	if ((cmd->result & (CAM_DEV_QFRZN << `16`)) != `0`) {
1776	cmd->result &= ~(CAM_DEV_QFRZN << `16`);
1777	dev->qfrozen--;
1778	}
1779	} else if (scb->flags & SCB_DEVICE_RESET) {
1780	if (ahd->platform_data->eh_done)
1781	complete(ahd->platform_data->eh_done);
1782	ahd_free_scb(ahd, scb);
1783	return;
1784	}
1785	ahd_linux_unmap_scb(ahd, scb);
1786
1787	/*
1788	* Guard against stale sense data.
1789	* The Linux mid-layer assumes that sense
1790	* was retrieved anytime the first byte of
1791	* the sense buffer looks "sane".
1792	*/
1793	cmd->sense_buffer[`0`] = `0`;
1794	if (ahd_get_transaction_status(scb) == CAM_REQ_INPROG) {
1795	#ifdef AHD_REPORT_UNDERFLOWS
1796	uint32_t amount_xferred;
1797
1798	amount_xferred =
1799	ahd_get_transfer_length(scb) - ahd_get_residual(scb);
1800	#endif
1801	if ((scb->flags & SCB_TRANSMISSION_ERROR) != `0`) {
1802	#ifdef AHD_DEBUG
1803	if ((ahd_debug & AHD_SHOW_MISC) != `0`) {
1804	ahd_print_path(ahd, scb);
1805	printk("Set CAM_UNCOR_PARITY\n");
1806	}
1807	#endif
1808	ahd_set_transaction_status(scb, status: CAM_UNCOR_PARITY);
1809	#ifdef AHD_REPORT_UNDERFLOWS
1810	/*
1811	* This code is disabled by default as some
1812	* clients of the SCSI system do not properly
1813	* initialize the underflow parameter. This
1814	* results in spurious termination of commands
1815	* that complete as expected (e.g. underflow is
1816	* allowed as command can return variable amounts
1817	* of data.
1818	*/
1819	} else if (amount_xferred < scb->io_ctx->underflow) {
1820	u_int i;
1821
1822	ahd_print_path(ahd, scb);
1823	printk("CDB:");
1824	for (i = `0`; i < scb->io_ctx->cmd_len; i++)
1825	printk(" 0x%x", scb->io_ctx->cmnd[i]);
1826	printk("\n");
1827	ahd_print_path(ahd, scb);
1828	printk("Saw underflow (%ld of %ld bytes). "
1829	"Treated as error\n",
1830	ahd_get_residual(scb),
1831	ahd_get_transfer_length(scb));
1832	ahd_set_transaction_status(scb, CAM_DATA_RUN_ERR);
1833	#endif
1834	} else {
1835	ahd_set_transaction_status(scb, status: CAM_REQ_CMP);
1836	}
1837	} else if (cmd &&
1838	ahd_get_transaction_status(scb) == CAM_SCSI_STATUS_ERROR) {
1839	ahd_linux_handle_scsi_status(ahd, cmd->device, scb);
1840	}
1841
1842	if (dev->openings == `1`
1843	&& ahd_get_transaction_status(scb) == CAM_REQ_CMP
1844	&& ahd_get_scsi_status(scb) != SAM_STAT_TASK_SET_FULL)
1845	dev->tag_success_count++;
1846	/*
1847	* Some devices deal with temporary internal resource
1848	* shortages by returning queue full. When the queue
1849	* full occurrs, we throttle back. Slowly try to get
1850	* back to our previous queue depth.
1851	*/
1852	if ((dev->openings + dev->active) < dev->maxtags
1853	&& dev->tag_success_count > AHD_TAG_SUCCESS_INTERVAL) {
1854	dev->tag_success_count = `0`;
1855	dev->openings++;
1856	}
1857
1858	if (dev->active == `0`)
1859	dev->commands_since_idle_or_otag = `0`;
1860
1861	if ((scb->flags & SCB_RECOVERY_SCB) != `0`) {
1862	printk("Recovery SCB completes\n");
1863	if (ahd_get_transaction_status(scb) == CAM_BDR_SENT
1864	\|\| ahd_get_transaction_status(scb) == CAM_REQ_ABORTED)
1865	ahd_set_transaction_status(scb, status: CAM_CMD_TIMEOUT);
1866
1867	if (ahd->platform_data->eh_done)
1868	complete(ahd->platform_data->eh_done);
1869	}
1870
1871	ahd_free_scb(ahd, scb);
1872	if (cmd)
1873	ahd_linux_queue_cmd_complete(ahd, cmd);
1874	}
1875
1876	static void
1877	ahd_linux_handle_scsi_status(struct ahd_softc *ahd,
1878	struct scsi_device sdev, struct* scb *scb)
1879	{
1880	struct ahd_devinfo devinfo;
1881	struct ahd_linux_device *dev = scsi_transport_device_data(sdev);
1882
1883	ahd_compile_devinfo(devinfo: &devinfo,
1884	our_id: ahd->our_id,
1885	target: sdev->sdev_target->id, lun: sdev->lun,
1886	channel: sdev->sdev_target->channel == `0` ? `'A'` : `'B'`,
1887	role: ROLE_INITIATOR);
1888
1889	/*
1890	* We don't currently trust the mid-layer to
1891	* properly deal with queue full or busy. So,
1892	* when one occurs, we tell the mid-layer to
1893	* unconditionally requeue the command to us
1894	* so that we can retry it ourselves. We also
1895	* implement our own throttling mechanism so
1896	* we don't clobber the device with too many
1897	* commands.
1898	*/
1899	switch (ahd_get_scsi_status(scb)) {
1900	default:
1901	break;
1902	case SAM_STAT_CHECK_CONDITION:
1903	case SAM_STAT_COMMAND_TERMINATED:
1904	{
1905	struct scsi_cmnd *cmd;
1906
1907	/*
1908	* Copy sense information to the OS's cmd
1909	* structure if it is available.
1910	*/
1911	cmd = scb->io_ctx;
1912	if ((scb->flags & (SCB_SENSE\|SCB_PKT_SENSE)) != `0`) {
1913	struct scsi_status_iu_header *siu;
1914	u_int sense_size;
1915	u_int sense_offset;
1916
1917	if (scb->flags & SCB_SENSE) {
1918	sense_size = min(sizeof(struct scsi_sense_data)
1919	- ahd_get_sense_residual(scb),
1920	(u_long)SCSI_SENSE_BUFFERSIZE);
1921	sense_offset = `0`;
1922	} else {
1923	/*
1924	* Copy only the sense data into the provided
1925	* buffer.
1926	*/
1927	siu = (struct scsi_status_iu_header *)
1928	scb->sense_data;
1929	sense_size = min_t(size_t,
1930	scsi_4btoul(siu->sense_length),
1931	SCSI_SENSE_BUFFERSIZE);
1932	sense_offset = SIU_SENSE_OFFSET(siu);
1933	}
1934
1935	memset(cmd->sense_buffer, `0`, SCSI_SENSE_BUFFERSIZE);
1936	memcpy(cmd->sense_buffer,
1937	ahd_get_sense_buf(ahd, scb)
1938	+ sense_offset, sense_size);
1939	set_status_byte(cmd, status: SAM_STAT_CHECK_CONDITION);
1940
1941	#ifdef AHD_DEBUG
1942	if (ahd_debug & AHD_SHOW_SENSE) {
1943	int i;
1944
1945	printk("Copied %d bytes of sense data at %d:",
1946	sense_size, sense_offset);
1947	for (i = `0`; i < sense_size; i++) {
1948	if ((i & `0xF`) == `0`)
1949	printk("\n");
1950	printk("0x%x ", cmd->sense_buffer[i]);
1951	}
1952	printk("\n");
1953	}
1954	#endif
1955	}
1956	break;
1957	}
1958	case SAM_STAT_TASK_SET_FULL:
1959	/*
1960	* By the time the core driver has returned this
1961	* command, all other commands that were queued
1962	* to us but not the device have been returned.
1963	* This ensures that dev->active is equal to
1964	* the number of commands actually queued to
1965	* the device.
1966	*/
1967	dev->tag_success_count = `0`;
1968	if (dev->active != `0`) {
1969	/*
1970	* Drop our opening count to the number
1971	* of commands currently outstanding.
1972	*/
1973	dev->openings = `0`;
1974	#ifdef AHD_DEBUG
1975	if ((ahd_debug & AHD_SHOW_QFULL) != `0`) {
1976	ahd_print_path(ahd, scb);
1977	printk("Dropping tag count to %d\n",
1978	dev->active);
1979	}
1980	#endif
1981	if (dev->active == dev->tags_on_last_queuefull) {
1982
1983	dev->last_queuefull_same_count++;
1984	/*
1985	* If we repeatedly see a queue full
1986	* at the same queue depth, this
1987	* device has a fixed number of tag
1988	* slots. Lock in this tag depth
1989	* so we stop seeing queue fulls from
1990	* this device.
1991	*/
1992	if (dev->last_queuefull_same_count
1993	== AHD_LOCK_TAGS_COUNT) {
1994	dev->maxtags = dev->active;
1995	ahd_print_path(ahd, scb);
1996	printk("Locking max tag count at %d\n",
1997	dev->active);
1998	}
1999	} else {
2000	dev->tags_on_last_queuefull = dev->active;
2001	dev->last_queuefull_same_count = `0`;
2002	}
2003	ahd_set_transaction_status(scb, status: CAM_REQUEUE_REQ);
2004	ahd_set_scsi_status(scb, status: SAM_STAT_GOOD);
2005	ahd_platform_set_tags(ahd, sdev, devinfo: &devinfo,
2006	alg: (dev->flags & AHD_DEV_Q_BASIC)
2007	? AHD_QUEUE_BASIC : AHD_QUEUE_TAGGED);
2008	break;
2009	}
2010	/*
2011	* Drop down to a single opening, and treat this
2012	* as if the target returned BUSY SCSI status.
2013	*/
2014	dev->openings = `1`;
2015	ahd_platform_set_tags(ahd, sdev, devinfo: &devinfo,
2016	alg: (dev->flags & AHD_DEV_Q_BASIC)
2017	? AHD_QUEUE_BASIC : AHD_QUEUE_TAGGED);
2018	ahd_set_scsi_status(scb, status: SAM_STAT_BUSY);
2019	}
2020	}
2021
2022	static void
2023	ahd_linux_queue_cmd_complete(struct ahd_softc ahd, struct* scsi_cmnd *cmd)
2024	{
2025	int status;
2026	int new_status = DID_OK;
2027	int do_fallback = `0`;
2028	int scsi_status;
2029	struct scsi_sense_data *sense;
2030
2031	/*
2032	* Map CAM error codes into Linux Error codes. We
2033	* avoid the conversion so that the DV code has the
2034	* full error information available when making
2035	* state change decisions.
2036	*/
2037
2038	status = ahd_cmd_get_transaction_status(cmd);
2039	switch (status) {
2040	case CAM_REQ_INPROG:
2041	case CAM_REQ_CMP:
2042	new_status = DID_OK;
2043	break;
2044	case CAM_AUTOSENSE_FAIL:
2045	new_status = DID_ERROR;
2046	fallthrough;
2047	case CAM_SCSI_STATUS_ERROR:
2048	scsi_status = ahd_cmd_get_scsi_status(cmd);
2049
2050	switch(scsi_status) {
2051	case SAM_STAT_COMMAND_TERMINATED:
2052	case SAM_STAT_CHECK_CONDITION:
2053	sense = (struct scsi_sense_data *)
2054	cmd->sense_buffer;
2055	if (sense->extra_len >= `5` &&
2056	(sense->add_sense_code == `0x47`
2057	\|\| sense->add_sense_code == `0x48`))
2058	do_fallback = `1`;
2059	break;
2060	default:
2061	break;
2062	}
2063	break;
2064	case CAM_REQ_ABORTED:
2065	new_status = DID_ABORT;
2066	break;
2067	case CAM_BUSY:
2068	new_status = DID_BUS_BUSY;
2069	break;
2070	case CAM_REQ_INVALID:
2071	case CAM_PATH_INVALID:
2072	new_status = DID_BAD_TARGET;
2073	break;
2074	case CAM_SEL_TIMEOUT:
2075	new_status = DID_NO_CONNECT;
2076	break;
2077	case CAM_SCSI_BUS_RESET:
2078	case CAM_BDR_SENT:
2079	new_status = DID_RESET;
2080	break;
2081	case CAM_UNCOR_PARITY:
2082	new_status = DID_PARITY;
2083	do_fallback = `1`;
2084	break;
2085	case CAM_CMD_TIMEOUT:
2086	new_status = DID_TIME_OUT;
2087	do_fallback = `1`;
2088	break;
2089	case CAM_REQ_CMP_ERR:
2090	case CAM_UNEXP_BUSFREE:
2091	case CAM_DATA_RUN_ERR:
2092	new_status = DID_ERROR;
2093	do_fallback = `1`;
2094	break;
2095	case CAM_UA_ABORT:
2096	case CAM_NO_HBA:
2097	case CAM_SEQUENCE_FAIL:
2098	case CAM_CCB_LEN_ERR:
2099	case CAM_PROVIDE_FAIL:
2100	case CAM_REQ_TERMIO:
2101	case CAM_UNREC_HBA_ERROR:
2102	case CAM_REQ_TOO_BIG:
2103	new_status = DID_ERROR;
2104	break;
2105	case CAM_REQUEUE_REQ:
2106	new_status = DID_REQUEUE;
2107	break;
2108	default:
2109	/ We should never get here /
2110	new_status = DID_ERROR;
2111	break;
2112	}
2113
2114	if (do_fallback) {
2115	printk("%s: device overrun (status %x) on %d:%d:%d\n",
2116	ahd_name(ahd), status, cmd->device->channel,
2117	cmd->device->id, (u8)cmd->device->lun);
2118	}
2119
2120	ahd_cmd_set_transaction_status(cmd, status: new_status);
2121
2122	scsi_done(cmd);
2123	}
2124
2125	static void
2126	ahd_freeze_simq(struct ahd_softc *ahd)
2127	{
2128	scsi_block_requests(ahd->platform_data->host);
2129	}
2130
2131	static void
2132	ahd_release_simq(struct ahd_softc *ahd)
2133	{
2134	scsi_unblock_requests(ahd->platform_data->host);
2135	}
2136
2137	static int
2138	ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd)
2139	{
2140	struct ahd_softc *ahd;
2141	struct ahd_linux_device *dev;
2142	struct scb *pending_scb;
2143	u_int saved_scbptr;
2144	u_int active_scbptr;
2145	u_int last_phase;
2146	u_int cdb_byte;
2147	int retval = SUCCESS;
2148	int was_paused;
2149	int paused;
2150	int wait;
2151	int disconnected;
2152	ahd_mode_state saved_modes;
2153	unsigned long flags;
2154
2155	pending_scb = NULL;
2156	paused = FALSE;
2157	wait = FALSE;
2158	ahd = (struct* ahd_softc **)cmd->device->host->hostdata;
2159
2160	scmd_printk(KERN_INFO, cmd,
2161	"Attempting to queue an ABORT message:");
2162
2163	printk("CDB:");
2164	for (cdb_byte = `0`; cdb_byte < cmd->cmd_len; cdb_byte++)
2165	printk(" 0x%x", cmd->cmnd[cdb_byte]);
2166	printk("\n");
2167
2168	ahd_lock(ahd, flags: &flags);
2169
2170	/*
2171	* First determine if we currently own this command.
2172	* Start by searching the device queue. If not found
2173	* there, check the pending_scb list. If not found
2174	* at all, and the system wanted us to just abort the
2175	* command, return success.
2176	*/
2177	dev = scsi_transport_device_data(sdev: cmd->device);
2178
2179	if (dev == NULL) {
2180	/*
2181	* No target device for this command exists,
2182	* so we must not still own the command.
2183	*/
2184	scmd_printk(KERN_INFO, cmd, "Is not an active device\n");
2185	goto done;
2186	}
2187
2188	/*
2189	* See if we can find a matching cmd in the pending list.
2190	*/
2191	LIST_FOREACH(pending_scb, &ahd->pending_scbs, pending_links) {
2192	if (pending_scb->io_ctx == cmd)
2193	break;
2194	}
2195
2196	if (pending_scb == NULL) {
2197	scmd_printk(KERN_INFO, cmd, "Command not found\n");
2198	goto done;
2199	}
2200
2201	if ((pending_scb->flags & SCB_RECOVERY_SCB) != `0`) {
2202	/*
2203	* We can't queue two recovery actions using the same SCB
2204	*/
2205	retval = FAILED;
2206	goto done;
2207	}
2208
2209	/*
2210	* Ensure that the card doesn't do anything
2211	* behind our back. Also make sure that we
2212	* didn't "just" miss an interrupt that would
2213	* affect this cmd.
2214	*/
2215	was_paused = ahd_is_paused(ahd);
2216	ahd_pause_and_flushwork(ahd);
2217	paused = TRUE;
2218
2219	if ((pending_scb->flags & SCB_ACTIVE) == `0`) {
2220	scmd_printk(KERN_INFO, cmd, "Command already completed\n");
2221	goto done;
2222	}
2223
2224	printk("%s: At time of recovery, card was %spaused\n",
2225	ahd_name(ahd), was_paused ? "" : "not ");
2226	ahd_dump_card_state(ahd);
2227
2228	disconnected = TRUE;
2229	if (ahd_search_qinfifo(ahd, target: cmd->device->id,
2230	channel: cmd->device->channel + `'A'`,
2231	lun: cmd->device->lun,
2232	tag: pending_scb->hscb->tag,
2233	role: ROLE_INITIATOR, status: CAM_REQ_ABORTED,
2234	action: SEARCH_COMPLETE) > `0`) {
2235	printk("%s:%d:%d:%d: Cmd aborted from QINFIFO\n",
2236	ahd_name(ahd), cmd->device->channel,
2237	cmd->device->id, (u8)cmd->device->lun);
2238	goto done;
2239	}
2240
2241	saved_modes = ahd_save_modes(ahd);
2242	ahd_set_modes(ahd, src: AHD_MODE_SCSI, dst: AHD_MODE_SCSI);
2243	last_phase = ahd_inb(ahd, port: LASTPHASE);
2244	saved_scbptr = ahd_get_scbptr(ahd);
2245	active_scbptr = saved_scbptr;
2246	if (disconnected && (ahd_inb(ahd, SEQ_FLAGS) & NOT_IDENTIFIED) == `0`) {
2247	struct scb *bus_scb;
2248
2249	bus_scb = ahd_lookup_scb(ahd, tag: active_scbptr);
2250	if (bus_scb == pending_scb)
2251	disconnected = FALSE;
2252	}
2253
2254	/*
2255	* At this point, pending_scb is the scb associated with the
2256	* passed in command. That command is currently active on the
2257	* bus or is in the disconnected state.
2258	*/
2259	ahd_inb(ahd, port: SAVED_SCSIID);
2260	if (last_phase != P_BUSFREE
2261	&& SCB_GET_TAG(pending_scb) == active_scbptr) {
2262
2263	/*
2264	* We're active on the bus, so assert ATN
2265	* and hope that the target responds.
2266	*/
2267	pending_scb = ahd_lookup_scb(ahd, tag: active_scbptr);
2268	pending_scb->flags \|= SCB_RECOVERY_SCB\|SCB_ABORT;
2269	ahd_outb(ahd, port: MSG_OUT, val: HOST_MSG);
2270	ahd_outb(ahd, port: SCSISIGO, val: last_phase\|ATNO);
2271	scmd_printk(KERN_INFO, cmd, "Device is active, asserting ATN\n");
2272	wait = TRUE;
2273	} else if (disconnected) {
2274
2275	/*
2276	* Actually re-queue this SCB in an attempt
2277	* to select the device before it reconnects.
2278	*/
2279	pending_scb->flags \|= SCB_RECOVERY_SCB\|SCB_ABORT;
2280	ahd_set_scbptr(ahd, SCB_GET_TAG(pending_scb));
2281	pending_scb->hscb->cdb_len = `0`;
2282	pending_scb->hscb->task_attribute = `0`;
2283	pending_scb->hscb->task_management = SIU_TASKMGMT_ABORT_TASK;
2284
2285	if ((pending_scb->flags & SCB_PACKETIZED) != `0`) {
2286	/*
2287	* Mark the SCB has having an outstanding
2288	* task management function. Should the command
2289	* complete normally before the task management
2290	* function can be sent, the host will be notified
2291	* to abort our requeued SCB.
2292	*/
2293	ahd_outb(ahd, port: SCB_TASK_MANAGEMENT,
2294	val: pending_scb->hscb->task_management);
2295	} else {
2296	/*
2297	* If non-packetized, set the MK_MESSAGE control
2298	* bit indicating that we desire to send a message.
2299	* We also set the disconnected flag since there is
2300	* no guarantee that our SCB control byte matches
2301	* the version on the card. We don't want the
2302	* sequencer to abort the command thinking an
2303	* unsolicited reselection occurred.
2304	*/
2305	pending_scb->hscb->control \|= MK_MESSAGE\|DISCONNECTED;
2306
2307	/*
2308	* The sequencer will never re-reference the
2309	* in-core SCB. To make sure we are notified
2310	* during reselection, set the MK_MESSAGE flag in
2311	* the card's copy of the SCB.
2312	*/
2313	ahd_outb(ahd, SCB_CONTROL,
2314	ahd_inb(ahd, SCB_CONTROL)\|MK_MESSAGE);
2315	}
2316
2317	/*
2318	* Clear out any entries in the QINFIFO first
2319	* so we are the next SCB for this target
2320	* to run.
2321	*/
2322	ahd_search_qinfifo(ahd, target: cmd->device->id,
2323	channel: cmd->device->channel + `'A'`, lun: cmd->device->lun,
2324	SCB_LIST_NULL, role: ROLE_INITIATOR,
2325	status: CAM_REQUEUE_REQ, action: SEARCH_COMPLETE);
2326	ahd_qinfifo_requeue_tail(ahd, scb: pending_scb);
2327	ahd_set_scbptr(ahd, scbptr: saved_scbptr);
2328	ahd_print_path(ahd, scb: pending_scb);
2329	printk("Device is disconnected, re-queuing SCB\n");
2330	wait = TRUE;
2331	} else {
2332	scmd_printk(KERN_INFO, cmd, "Unable to deliver message\n");
2333	retval = FAILED;
2334	}
2335
2336
2337	ahd_restore_modes(ahd, state: saved_modes);
2338	done:
2339	if (paused)
2340	ahd_unpause(ahd);
2341	if (wait) {
2342	DECLARE_COMPLETION_ONSTACK(done);
2343
2344	ahd->platform_data->eh_done = &done;
2345	ahd_unlock(ahd, flags: &flags);
2346
2347	printk("%s: Recovery code sleeping\n", ahd_name(ahd));
2348	if (!wait_for_completion_timeout(x: &done, timeout: `5` * HZ)) {
2349	ahd_lock(ahd, flags: &flags);
2350	ahd->platform_data->eh_done = NULL;
2351	ahd_unlock(ahd, flags: &flags);
2352	printk("%s: Timer Expired (active %d)\n",
2353	ahd_name(ahd), dev->active);
2354	retval = FAILED;
2355	}
2356	printk("Recovery code awake\n");
2357	} else
2358	ahd_unlock(ahd, flags: &flags);
2359
2360	if (retval != SUCCESS)
2361	printk("%s: Command abort returning 0x%x\n",
2362	ahd_name(ahd), retval);
2363
2364	return retval;
2365	}
2366
2367	static void ahd_linux_set_width(struct scsi_target starget, int* width)
2368	{
2369	struct Scsi_Host *shost = dev_to_shost(dev: starget->dev.parent);
2370	struct ahd_softc ahd = ((struct ahd_softc **)shost->hostdata);
2371	struct ahd_devinfo devinfo;
2372	unsigned long flags;
2373
2374	ahd_compile_devinfo(devinfo: &devinfo, our_id: shost->this_id, target: starget->id, lun: `0`,
2375	channel: starget->channel + `'A'`, role: ROLE_INITIATOR);
2376	ahd_lock(ahd, flags: &flags);
2377	ahd_set_width(ahd, devinfo: &devinfo, width, AHD_TRANS_GOAL, FALSE);
2378	ahd_unlock(ahd, flags: &flags);
2379	}
2380
2381	static void ahd_linux_set_period(struct scsi_target starget, int* period)
2382	{
2383	struct Scsi_Host *shost = dev_to_shost(dev: starget->dev.parent);
2384	struct ahd_softc ahd = ((struct ahd_softc **)shost->hostdata);
2385	struct ahd_tmode_tstate *tstate;
2386	struct ahd_initiator_tinfo *tinfo
2387	= ahd_fetch_transinfo(ahd,
2388	channel: starget->channel + `'A'`,
2389	our_id: shost->this_id, remote_id: starget->id, tstate: &tstate);
2390	struct ahd_devinfo devinfo;
2391	unsigned int ppr_options = tinfo->goal.ppr_options;
2392	unsigned int dt;
2393	unsigned long flags;
2394	unsigned long offset = tinfo->goal.offset;
2395
2396	#ifdef AHD_DEBUG
2397	if ((ahd_debug & AHD_SHOW_DV) != `0`)
2398	printk("%s: set period to %d\n", ahd_name(ahd), period);
2399	#endif
2400	if (offset == `0`)
2401	offset = MAX_OFFSET;
2402
2403	if (period < `8`)
2404	period = `8`;
2405	if (period < `10`) {
2406	if (spi_max_width(starget)) {
2407	ppr_options \|= MSG_EXT_PPR_DT_REQ;
2408	if (period == `8`)
2409	ppr_options \|= MSG_EXT_PPR_IU_REQ;
2410	} else
2411	period = `10`;
2412	}
2413
2414	dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2415
2416	ahd_compile_devinfo(devinfo: &devinfo, our_id: shost->this_id, target: starget->id, lun: `0`,
2417	channel: starget->channel + `'A'`, role: ROLE_INITIATOR);
2418
2419	/ all PPR requests apart from QAS require wide transfers /
2420	if (ppr_options & ~MSG_EXT_PPR_QAS_REQ) {
2421	if (spi_width(starget) == `0`)
2422	ppr_options &= MSG_EXT_PPR_QAS_REQ;
2423	}
2424
2425	ahd_find_syncrate(ahd, period: &period, ppr_options: &ppr_options,
2426	maxsync: dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2427
2428	ahd_lock(ahd, flags: &flags);
2429	ahd_set_syncrate(ahd, devinfo: &devinfo, period, offset,
2430	ppr_options, AHD_TRANS_GOAL, FALSE);
2431	ahd_unlock(ahd, flags: &flags);
2432	}
2433
2434	static void ahd_linux_set_offset(struct scsi_target starget, int* offset)
2435	{
2436	struct Scsi_Host *shost = dev_to_shost(dev: starget->dev.parent);
2437	struct ahd_softc ahd = ((struct ahd_softc **)shost->hostdata);
2438	struct ahd_tmode_tstate *tstate;
2439	struct ahd_initiator_tinfo *tinfo
2440	= ahd_fetch_transinfo(ahd,
2441	channel: starget->channel + `'A'`,
2442	our_id: shost->this_id, remote_id: starget->id, tstate: &tstate);
2443	struct ahd_devinfo devinfo;
2444	unsigned int ppr_options = `0`;
2445	unsigned int period = `0`;
2446	unsigned int dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2447	unsigned long flags;
2448
2449	#ifdef AHD_DEBUG
2450	if ((ahd_debug & AHD_SHOW_DV) != `0`)
2451	printk("%s: set offset to %d\n", ahd_name(ahd), offset);
2452	#endif
2453
2454	ahd_compile_devinfo(devinfo: &devinfo, our_id: shost->this_id, target: starget->id, lun: `0`,
2455	channel: starget->channel + `'A'`, role: ROLE_INITIATOR);
2456	if (offset != `0`) {
2457	period = tinfo->goal.period;
2458	ppr_options = tinfo->goal.ppr_options;
2459	ahd_find_syncrate(ahd, period: &period, ppr_options: &ppr_options,
2460	maxsync: dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2461	}
2462
2463	ahd_lock(ahd, flags: &flags);
2464	ahd_set_syncrate(ahd, devinfo: &devinfo, period, offset, ppr_options,
2465	AHD_TRANS_GOAL, FALSE);
2466	ahd_unlock(ahd, flags: &flags);
2467	}
2468
2469	static void ahd_linux_set_dt(struct scsi_target starget, int* dt)
2470	{
2471	struct Scsi_Host *shost = dev_to_shost(dev: starget->dev.parent);
2472	struct ahd_softc ahd = ((struct ahd_softc **)shost->hostdata);
2473	struct ahd_tmode_tstate *tstate;
2474	struct ahd_initiator_tinfo *tinfo
2475	= ahd_fetch_transinfo(ahd,
2476	channel: starget->channel + `'A'`,
2477	our_id: shost->this_id, remote_id: starget->id, tstate: &tstate);
2478	struct ahd_devinfo devinfo;
2479	unsigned int ppr_options = tinfo->goal.ppr_options
2480	& ~MSG_EXT_PPR_DT_REQ;
2481	unsigned int period = tinfo->goal.period;
2482	unsigned int width = tinfo->goal.width;
2483	unsigned long flags;
2484
2485	#ifdef AHD_DEBUG
2486	if ((ahd_debug & AHD_SHOW_DV) != `0`)
2487	printk("%s: %s DT\n", ahd_name(ahd),
2488	dt ? "enabling" : "disabling");
2489	#endif
2490	if (dt && spi_max_width(starget)) {
2491	ppr_options \|= MSG_EXT_PPR_DT_REQ;
2492	if (!width)
2493	ahd_linux_set_width(starget, width: `1`);
2494	} else {
2495	if (period <= `9`)
2496	period = `10`; / If resetting DT, period must be >= 25ns /
2497	/ IU is invalid without DT set /
2498	ppr_options &= ~MSG_EXT_PPR_IU_REQ;
2499	}
2500	ahd_compile_devinfo(devinfo: &devinfo, our_id: shost->this_id, target: starget->id, lun: `0`,
2501	channel: starget->channel + `'A'`, role: ROLE_INITIATOR);
2502	ahd_find_syncrate(ahd, period: &period, ppr_options: &ppr_options,
2503	maxsync: dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2504
2505	ahd_lock(ahd, flags: &flags);
2506	ahd_set_syncrate(ahd, devinfo: &devinfo, period, offset: tinfo->goal.offset,
2507	ppr_options, AHD_TRANS_GOAL, FALSE);
2508	ahd_unlock(ahd, flags: &flags);
2509	}
2510
2511	static void ahd_linux_set_qas(struct scsi_target starget, int* qas)
2512	{
2513	struct Scsi_Host *shost = dev_to_shost(dev: starget->dev.parent);
2514	struct ahd_softc ahd = ((struct ahd_softc **)shost->hostdata);
2515	struct ahd_tmode_tstate *tstate;
2516	struct ahd_initiator_tinfo *tinfo
2517	= ahd_fetch_transinfo(ahd,
2518	channel: starget->channel + `'A'`,
2519	our_id: shost->this_id, remote_id: starget->id, tstate: &tstate);
2520	struct ahd_devinfo devinfo;
2521	unsigned int ppr_options = tinfo->goal.ppr_options
2522	& ~MSG_EXT_PPR_QAS_REQ;
2523	unsigned int period = tinfo->goal.period;
2524	unsigned int dt;
2525	unsigned long flags;
2526
2527	#ifdef AHD_DEBUG
2528	if ((ahd_debug & AHD_SHOW_DV) != `0`)
2529	printk("%s: %s QAS\n", ahd_name(ahd),
2530	qas ? "enabling" : "disabling");
2531	#endif
2532
2533	if (qas) {
2534	ppr_options \|= MSG_EXT_PPR_QAS_REQ;
2535	}
2536
2537	dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2538
2539	ahd_compile_devinfo(devinfo: &devinfo, our_id: shost->this_id, target: starget->id, lun: `0`,
2540	channel: starget->channel + `'A'`, role: ROLE_INITIATOR);
2541	ahd_find_syncrate(ahd, period: &period, ppr_options: &ppr_options,
2542	maxsync: dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2543
2544	ahd_lock(ahd, flags: &flags);
2545	ahd_set_syncrate(ahd, devinfo: &devinfo, period, offset: tinfo->goal.offset,
2546	ppr_options, AHD_TRANS_GOAL, FALSE);
2547	ahd_unlock(ahd, flags: &flags);
2548	}
2549
2550	static void ahd_linux_set_iu(struct scsi_target starget, int* iu)
2551	{
2552	struct Scsi_Host *shost = dev_to_shost(dev: starget->dev.parent);
2553	struct ahd_softc ahd = ((struct ahd_softc **)shost->hostdata);
2554	struct ahd_tmode_tstate *tstate;
2555	struct ahd_initiator_tinfo *tinfo
2556	= ahd_fetch_transinfo(ahd,
2557	channel: starget->channel + `'A'`,
2558	our_id: shost->this_id, remote_id: starget->id, tstate: &tstate);
2559	struct ahd_devinfo devinfo;
2560	unsigned int ppr_options = tinfo->goal.ppr_options
2561	& ~MSG_EXT_PPR_IU_REQ;
2562	unsigned int period = tinfo->goal.period;
2563	unsigned int dt;
2564	unsigned long flags;
2565
2566	#ifdef AHD_DEBUG
2567	if ((ahd_debug & AHD_SHOW_DV) != `0`)
2568	printk("%s: %s IU\n", ahd_name(ahd),
2569	iu ? "enabling" : "disabling");
2570	#endif
2571
2572	if (iu && spi_max_width(starget)) {
2573	ppr_options \|= MSG_EXT_PPR_IU_REQ;
2574	ppr_options \|= MSG_EXT_PPR_DT_REQ; / IU requires DT /
2575	}
2576
2577	dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2578
2579	ahd_compile_devinfo(devinfo: &devinfo, our_id: shost->this_id, target: starget->id, lun: `0`,
2580	channel: starget->channel + `'A'`, role: ROLE_INITIATOR);
2581	ahd_find_syncrate(ahd, period: &period, ppr_options: &ppr_options,
2582	maxsync: dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2583
2584	ahd_lock(ahd, flags: &flags);
2585	ahd_set_syncrate(ahd, devinfo: &devinfo, period, offset: tinfo->goal.offset,
2586	ppr_options, AHD_TRANS_GOAL, FALSE);
2587	ahd_unlock(ahd, flags: &flags);
2588	}
2589
2590	static void ahd_linux_set_rd_strm(struct scsi_target starget, int* rdstrm)
2591	{
2592	struct Scsi_Host *shost = dev_to_shost(dev: starget->dev.parent);
2593	struct ahd_softc ahd = ((struct ahd_softc **)shost->hostdata);
2594	struct ahd_tmode_tstate *tstate;
2595	struct ahd_initiator_tinfo *tinfo
2596	= ahd_fetch_transinfo(ahd,
2597	channel: starget->channel + `'A'`,
2598	our_id: shost->this_id, remote_id: starget->id, tstate: &tstate);
2599	struct ahd_devinfo devinfo;
2600	unsigned int ppr_options = tinfo->goal.ppr_options
2601	& ~MSG_EXT_PPR_RD_STRM;
2602	unsigned int period = tinfo->goal.period;
2603	unsigned int dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2604	unsigned long flags;
2605
2606	#ifdef AHD_DEBUG
2607	if ((ahd_debug & AHD_SHOW_DV) != `0`)
2608	printk("%s: %s Read Streaming\n", ahd_name(ahd),
2609	rdstrm ? "enabling" : "disabling");
2610	#endif
2611
2612	if (rdstrm && spi_max_width(starget))
2613	ppr_options \|= MSG_EXT_PPR_RD_STRM;
2614
2615	ahd_compile_devinfo(devinfo: &devinfo, our_id: shost->this_id, target: starget->id, lun: `0`,
2616	channel: starget->channel + `'A'`, role: ROLE_INITIATOR);
2617	ahd_find_syncrate(ahd, period: &period, ppr_options: &ppr_options,
2618	maxsync: dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2619
2620	ahd_lock(ahd, flags: &flags);
2621	ahd_set_syncrate(ahd, devinfo: &devinfo, period, offset: tinfo->goal.offset,
2622	ppr_options, AHD_TRANS_GOAL, FALSE);
2623	ahd_unlock(ahd, flags: &flags);
2624	}
2625
2626	static void ahd_linux_set_wr_flow(struct scsi_target starget, int* wrflow)
2627	{
2628	struct Scsi_Host *shost = dev_to_shost(dev: starget->dev.parent);
2629	struct ahd_softc ahd = ((struct ahd_softc **)shost->hostdata);
2630	struct ahd_tmode_tstate *tstate;
2631	struct ahd_initiator_tinfo *tinfo
2632	= ahd_fetch_transinfo(ahd,
2633	channel: starget->channel + `'A'`,
2634	our_id: shost->this_id, remote_id: starget->id, tstate: &tstate);
2635	struct ahd_devinfo devinfo;
2636	unsigned int ppr_options = tinfo->goal.ppr_options
2637	& ~MSG_EXT_PPR_WR_FLOW;
2638	unsigned int period = tinfo->goal.period;
2639	unsigned int dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2640	unsigned long flags;
2641
2642	#ifdef AHD_DEBUG
2643	if ((ahd_debug & AHD_SHOW_DV) != `0`)
2644	printk("%s: %s Write Flow Control\n", ahd_name(ahd),
2645	wrflow ? "enabling" : "disabling");
2646	#endif
2647
2648	if (wrflow && spi_max_width(starget))
2649	ppr_options \|= MSG_EXT_PPR_WR_FLOW;
2650
2651	ahd_compile_devinfo(devinfo: &devinfo, our_id: shost->this_id, target: starget->id, lun: `0`,
2652	channel: starget->channel + `'A'`, role: ROLE_INITIATOR);
2653	ahd_find_syncrate(ahd, period: &period, ppr_options: &ppr_options,
2654	maxsync: dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2655
2656	ahd_lock(ahd, flags: &flags);
2657	ahd_set_syncrate(ahd, devinfo: &devinfo, period, offset: tinfo->goal.offset,
2658	ppr_options, AHD_TRANS_GOAL, FALSE);
2659	ahd_unlock(ahd, flags: &flags);
2660	}
2661
2662	static void ahd_linux_set_rti(struct scsi_target starget, int* rti)
2663	{
2664	struct Scsi_Host *shost = dev_to_shost(dev: starget->dev.parent);
2665	struct ahd_softc ahd = ((struct ahd_softc **)shost->hostdata);
2666	struct ahd_tmode_tstate *tstate;
2667	struct ahd_initiator_tinfo *tinfo
2668	= ahd_fetch_transinfo(ahd,
2669	channel: starget->channel + `'A'`,
2670	our_id: shost->this_id, remote_id: starget->id, tstate: &tstate);
2671	struct ahd_devinfo devinfo;
2672	unsigned int ppr_options = tinfo->goal.ppr_options
2673	& ~MSG_EXT_PPR_RTI;
2674	unsigned int period = tinfo->goal.period;
2675	unsigned int dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2676	unsigned long flags;
2677
2678	if ((ahd->features & AHD_RTI) == `0`) {
2679	#ifdef AHD_DEBUG
2680	if ((ahd_debug & AHD_SHOW_DV) != `0`)
2681	printk("%s: RTI not available\n", ahd_name(ahd));
2682	#endif
2683	return;
2684	}
2685
2686	#ifdef AHD_DEBUG
2687	if ((ahd_debug & AHD_SHOW_DV) != `0`)
2688	printk("%s: %s RTI\n", ahd_name(ahd),
2689	rti ? "enabling" : "disabling");
2690	#endif
2691
2692	if (rti && spi_max_width(starget))
2693	ppr_options \|= MSG_EXT_PPR_RTI;
2694
2695	ahd_compile_devinfo(devinfo: &devinfo, our_id: shost->this_id, target: starget->id, lun: `0`,
2696	channel: starget->channel + `'A'`, role: ROLE_INITIATOR);
2697	ahd_find_syncrate(ahd, period: &period, ppr_options: &ppr_options,
2698	maxsync: dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2699
2700	ahd_lock(ahd, flags: &flags);
2701	ahd_set_syncrate(ahd, devinfo: &devinfo, period, offset: tinfo->goal.offset,
2702	ppr_options, AHD_TRANS_GOAL, FALSE);
2703	ahd_unlock(ahd, flags: &flags);
2704	}
2705
2706	static void ahd_linux_set_pcomp_en(struct scsi_target starget, int* pcomp)
2707	{
2708	struct Scsi_Host *shost = dev_to_shost(dev: starget->dev.parent);
2709	struct ahd_softc ahd = ((struct ahd_softc **)shost->hostdata);
2710	struct ahd_tmode_tstate *tstate;
2711	struct ahd_initiator_tinfo *tinfo
2712	= ahd_fetch_transinfo(ahd,
2713	channel: starget->channel + `'A'`,
2714	our_id: shost->this_id, remote_id: starget->id, tstate: &tstate);
2715	struct ahd_devinfo devinfo;
2716	unsigned int ppr_options = tinfo->goal.ppr_options
2717	& ~MSG_EXT_PPR_PCOMP_EN;
2718	unsigned int period = tinfo->goal.period;
2719	unsigned int dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2720	unsigned long flags;
2721
2722	#ifdef AHD_DEBUG
2723	if ((ahd_debug & AHD_SHOW_DV) != `0`)
2724	printk("%s: %s Precompensation\n", ahd_name(ahd),
2725	pcomp ? "Enable" : "Disable");
2726	#endif
2727
2728	if (pcomp && spi_max_width(starget)) {
2729	uint8_t precomp;
2730
2731	if (ahd->unit < ARRAY_SIZE(aic79xx_iocell_info)) {
2732	const struct ahd_linux_iocell_opts *iocell_opts;
2733
2734	iocell_opts = &aic79xx_iocell_info[ahd->unit];
2735	precomp = iocell_opts->precomp;
2736	} else {
2737	precomp = AIC79XX_DEFAULT_PRECOMP;
2738	}
2739	ppr_options \|= MSG_EXT_PPR_PCOMP_EN;
2740	AHD_SET_PRECOMP(ahd, precomp);
2741	} else {
2742	AHD_SET_PRECOMP(ahd, `0`);
2743	}
2744
2745	ahd_compile_devinfo(devinfo: &devinfo, our_id: shost->this_id, target: starget->id, lun: `0`,
2746	channel: starget->channel + `'A'`, role: ROLE_INITIATOR);
2747	ahd_find_syncrate(ahd, period: &period, ppr_options: &ppr_options,
2748	maxsync: dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2749
2750	ahd_lock(ahd, flags: &flags);
2751	ahd_set_syncrate(ahd, devinfo: &devinfo, period, offset: tinfo->goal.offset,
2752	ppr_options, AHD_TRANS_GOAL, FALSE);
2753	ahd_unlock(ahd, flags: &flags);
2754	}
2755
2756	static void ahd_linux_set_hold_mcs(struct scsi_target starget, int* hold)
2757	{
2758	struct Scsi_Host *shost = dev_to_shost(dev: starget->dev.parent);
2759	struct ahd_softc ahd = ((struct ahd_softc **)shost->hostdata);
2760	struct ahd_tmode_tstate *tstate;
2761	struct ahd_initiator_tinfo *tinfo
2762	= ahd_fetch_transinfo(ahd,
2763	channel: starget->channel + `'A'`,
2764	our_id: shost->this_id, remote_id: starget->id, tstate: &tstate);
2765	struct ahd_devinfo devinfo;
2766	unsigned int ppr_options = tinfo->goal.ppr_options
2767	& ~MSG_EXT_PPR_HOLD_MCS;
2768	unsigned int period = tinfo->goal.period;
2769	unsigned int dt = ppr_options & MSG_EXT_PPR_DT_REQ;
2770	unsigned long flags;
2771
2772	if (hold && spi_max_width(starget))
2773	ppr_options \|= MSG_EXT_PPR_HOLD_MCS;
2774
2775	ahd_compile_devinfo(devinfo: &devinfo, our_id: shost->this_id, target: starget->id, lun: `0`,
2776	channel: starget->channel + `'A'`, role: ROLE_INITIATOR);
2777	ahd_find_syncrate(ahd, period: &period, ppr_options: &ppr_options,
2778	maxsync: dt ? AHD_SYNCRATE_MAX : AHD_SYNCRATE_ULTRA2);
2779
2780	ahd_lock(ahd, flags: &flags);
2781	ahd_set_syncrate(ahd, devinfo: &devinfo, period, offset: tinfo->goal.offset,
2782	ppr_options, AHD_TRANS_GOAL, FALSE);
2783	ahd_unlock(ahd, flags: &flags);
2784	}
2785
2786	static void ahd_linux_get_signalling(struct Scsi_Host *shost)
2787	{
2788	struct ahd_softc ahd = (struct ahd_softc **)shost->hostdata;
2789	unsigned long flags;
2790	u8 mode;
2791
2792	ahd_lock(ahd, flags: &flags);
2793	ahd_pause(ahd);
2794	mode = ahd_inb(ahd, SBLKCTL);
2795	ahd_unpause(ahd);
2796	ahd_unlock(ahd, flags: &flags);
2797
2798	if (mode & ENAB40)
2799	spi_signalling(shost) = SPI_SIGNAL_LVD;
2800	else if (mode & ENAB20)
2801	spi_signalling(shost) = SPI_SIGNAL_SE;
2802	else
2803	spi_signalling(shost) = SPI_SIGNAL_UNKNOWN;
2804	}
2805
2806	static struct spi_function_template ahd_linux_transport_functions = {
2807	.set_offset = ahd_linux_set_offset,
2808	.show_offset = `1`,
2809	.set_period = ahd_linux_set_period,
2810	.show_period = `1`,
2811	.set_width = ahd_linux_set_width,
2812	.show_width = `1`,
2813	.set_dt = ahd_linux_set_dt,
2814	.show_dt = `1`,
2815	.set_iu = ahd_linux_set_iu,
2816	.show_iu = `1`,
2817	.set_qas = ahd_linux_set_qas,
2818	.show_qas = `1`,
2819	.set_rd_strm = ahd_linux_set_rd_strm,
2820	.show_rd_strm = `1`,
2821	.set_wr_flow = ahd_linux_set_wr_flow,
2822	.show_wr_flow = `1`,
2823	.set_rti = ahd_linux_set_rti,
2824	.show_rti = `1`,
2825	.set_pcomp_en = ahd_linux_set_pcomp_en,
2826	.show_pcomp_en = `1`,
2827	.set_hold_mcs = ahd_linux_set_hold_mcs,
2828	.show_hold_mcs = `1`,
2829	.get_signalling = ahd_linux_get_signalling,
2830	};
2831
2832	static int __init
2833	ahd_linux_init(void)
2834	{
2835	int error = `0`;
2836
2837	/*
2838	* If we've been passed any parameters, process them now.
2839	*/
2840	if (aic79xx)
2841	aic79xx_setup(s: aic79xx);
2842
2843	ahd_linux_transport_template =
2844	spi_attach_transport(&ahd_linux_transport_functions);
2845	if (!ahd_linux_transport_template)
2846	return -ENODEV;
2847
2848	scsi_transport_reserve_device(t: ahd_linux_transport_template,
2849	space: sizeof(struct ahd_linux_device));
2850
2851	error = ahd_linux_pci_init();
2852	if (error)
2853	spi_release_transport(ahd_linux_transport_template);
2854	return error;
2855	}
2856
2857	static void __exit
2858	ahd_linux_exit(void)
2859	{
2860	ahd_linux_pci_exit();
2861	spi_release_transport(ahd_linux_transport_template);
2862	}
2863
2864	module_init(ahd_linux_init);
2865	module_exit(ahd_linux_exit);
2866

source code of linux/drivers/scsi/aic7xxx/aic79xx_osm.c