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