git.openwrt.org Git - openwrt/staging/blogic.git/blob

1 /*

2 * Adaptec AIC7xxx device driver for Linux.

3 *

4 * $Id: //depot/aic7xxx/linux/drivers/scsi/aic7xxx/aic7xxx_osm.c#235 $

5 *

7 * The University of Calgary Department of Computer Science.

8 *

9 * This program is free software; you can redistribute it and/or modify

10 * it under the terms of the GNU General Public License as published by

11 * the Free Software Foundation; either version 2, or (at your option)

12 * any later version.

13 *

14 * This program is distributed in the hope that it will be useful,

15 * but WITHOUT ANY WARRANTY; without even the implied warranty of

16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17 * GNU General Public License for more details.

18 *

19 * You should have received a copy of the GNU General Public License

20 * along with this program; see the file COPYING. If not, write to

21 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

22 *

23 * Sources include the Adaptec 1740 driver (aha1740.c), the Ultrastor 24F

24 * driver (ultrastor.c), various Linux kernel source, the Adaptec EISA

25 * config file (!adp7771.cfg), the Adaptec AHA-2740A Series User's Guide,

26 * the Linux Kernel Hacker's Guide, Writing a SCSI Device Driver for Linux,

27 * the Adaptec 1542 driver (aha1542.c), the Adaptec EISA overlay file

28 * (adp7770.ovl), the Adaptec AHA-2740 Series Technical Reference Manual,

29 * the Adaptec AIC-7770 Data Book, the ANSI SCSI specification, the

30 * ANSI SCSI-2 specification (draft 10c), ...

31 *

32 * --------------------------------------------------------------------------

33 *

34 * Modifications by Daniel M. Eischen (deischen@iworks.InterWorks.org):

35 *

36 * Substantially modified to include support for wide and twin bus

37 * adapters, DMAing of SCBs, tagged queueing, IRQ sharing, bug fixes,

38 * SCB paging, and other rework of the code.

39 *

40 * --------------------------------------------------------------------------

44 *

45 * Redistribution and use in source and binary forms, with or without

46 * modification, are permitted provided that the following conditions

47 * are met:

48 * 1. Redistributions of source code must retain the above copyright

49 * notice, this list of conditions, and the following disclaimer,

50 * without modification.

51 * 2. Redistributions in binary form must reproduce at minimum a disclaimer

52 * substantially similar to the "NO WARRANTY" disclaimer below

53 * ("Disclaimer") and any redistribution must be conditioned upon

54 * including a substantially similar Disclaimer requirement for further

55 * binary redistribution.

56 * 3. Neither the names of the above-listed copyright holders nor the names

57 * of any contributors may be used to endorse or promote products derived

58 * from this software without specific prior written permission.

59 *

60 * Alternatively, this software may be distributed under the terms of the

61 * GNU General Public License ("GPL") version 2 as published by the Free

62 * Software Foundation.

63 *

64 * NO WARRANTY

65 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

66 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

67 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR

68 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

69 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

70 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

71 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

72 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

73 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING

74 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

75 * POSSIBILITY OF SUCH DAMAGES.

76 *

77 *---------------------------------------------------------------------------

78 *

79 * Thanks also go to (in alphabetical order) the following:

80 *

81 * Rory Bolt - Sequencer bug fixes

82 * Jay Estabrook - Initial DEC Alpha support

83 * Doug Ledford - Much needed abort/reset bug fixes

84 * Kai Makisara - DMAing of SCBs

85 *

86 * A Boot time option was also added for not resetting the scsi bus.

87 *

88 * Form: aic7xxx=extended

89 * aic7xxx=no_reset

90 * aic7xxx=verbose

91 *

92 * Daniel M. Eischen, deischen@iworks.InterWorks.org, 1/23/97

93 *

94 * Id: aic7xxx.c,v 4.1 1997/06/12 08:23:42 deang Exp

95 */

97 /*

98 * Further driver modifications made by Doug Ledford <dledford@redhat.com>

99 *

101 *

102 * These changes are released under the same licensing terms as the FreeBSD

103 * driver written by Justin Gibbs. Please see his Copyright notice above

104 * for the exact terms and conditions covering my changes as well as the

105 * warranty statement.

106 *

107 * Modifications made to the aic7xxx.c,v 4.1 driver from Dan Eischen include

108 * but are not limited to:

109 *

110 * 1: Import of the latest FreeBSD sequencer code for this driver

111 * 2: Modification of kernel code to accommodate different sequencer semantics

112 * 3: Extensive changes throughout kernel portion of driver to improve

113 * abort/reset processing and error hanndling

114 * 4: Other work contributed by various people on the Internet

115 * 5: Changes to printk information and verbosity selection code

116 * 6: General reliability related changes, especially in IRQ management

117 * 7: Modifications to the default probe/attach order for supported cards

118 * 8: SMP friendliness has been improved

119 *

120 */

121

122 #include "aic7xxx_osm.h"

123 #include "aic7xxx_inline.h"

124 #include <scsi/scsicam.h>

125 #include <scsi/scsi_transport.h>

126 #include <scsi/scsi_transport_spi.h>

127

128 static struct scsi_transport_template *ahc_linux_transport_template = NULL;

129

130 /*

131 * Include aiclib.c as part of our

132 * "module dependencies are hard" work around.

133 */

134 #include "aiclib.c"

135

136 #include <linux/init.h> /* __setup */

137 #include <linux/mm.h> /* For fetching system memory size */

138 #include <linux/blkdev.h> /* For block_size() */

139 #include <linux/delay.h> /* For ssleep/msleep */

140

141 /*

142 * Lock protecting manipulation of the ahc softc list.

143 */

144 spinlock_t ahc_list_spinlock;

145

146 /*

147 * Set this to the delay in seconds after SCSI bus reset.

148 * Note, we honor this only for the initial bus reset.

149 * The scsi error recovery code performs its own bus settle

150 * delay handling for error recovery actions.

151 */

152 #ifdef CONFIG_AIC7XXX_RESET_DELAY_MS

153 #define AIC7XXX_RESET_DELAY CONFIG_AIC7XXX_RESET_DELAY_MS

154 #else

155 #define AIC7XXX_RESET_DELAY 5000

156 #endif

157

158 /*

159 * Control collection of SCSI transfer statistics for the /proc filesystem.

160 *

161 * NOTE: Do NOT enable this when running on kernels version 1.2.x and below.

162 * NOTE: This does affect performance since it has to maintain statistics.

163 */

164 #ifdef CONFIG_AIC7XXX_PROC_STATS

165 #define AIC7XXX_PROC_STATS

166 #endif

167

168 /*

169 * To change the default number of tagged transactions allowed per-device,

170 * add a line to the lilo.conf file like:

171 * append="aic7xxx=verbose,tag_info:{{32,32,32,32},{32,32,32,32}}"

172 * which will result in the first four devices on the first two

173 * controllers being set to a tagged queue depth of 32.

174 *

175 * The tag_commands is an array of 16 to allow for wide and twin adapters.

176 * Twin adapters will use indexes 0-7 for channel 0, and indexes 8-15

177 * for channel 1.

178 */

179 typedef struct {

180 uint8_t tag_commands[16]; /* Allow for wide/twin adapters. */

181 } adapter_tag_info_t;

182

183 /*

184 * Modify this as you see fit for your system.

185 *

186 * 0 tagged queuing disabled

187 * 1 <= n <= 253 n == max tags ever dispatched.

188 *

189 * The driver will throttle the number of commands dispatched to a

190 * device if it returns queue full. For devices with a fixed maximum

191 * queue depth, the driver will eventually determine this depth and

192 * lock it in (a console message is printed to indicate that a lock

193 * has occurred). On some devices, queue full is returned for a temporary

194 * resource shortage. These devices will return queue full at varying

195 * depths. The driver will throttle back when the queue fulls occur and

196 * attempt to slowly increase the depth over time as the device recovers

197 * from the resource shortage.

198 *

199 * In this example, the first line will disable tagged queueing for all

200 * the devices on the first probed aic7xxx adapter.

201 *

202 * The second line enables tagged queueing with 4 commands/LUN for IDs

203 * (0, 2-11, 13-15), disables tagged queueing for ID 12, and tells the

204 * driver to attempt to use up to 64 tags for ID 1.

205 *

206 * The third line is the same as the first line.

207 *

208 * The fourth line disables tagged queueing for devices 0 and 3. It

209 * enables tagged queueing for the other IDs, with 16 commands/LUN

210 * for IDs 1 and 4, 127 commands/LUN for ID 8, and 4 commands/LUN for

211 * IDs 2, 5-7, and 9-15.

212 */

213

214 /*

215 * NOTE: The below structure is for reference only, the actual structure

216 * to modify in order to change things is just below this comment block.

217 adapter_tag_info_t aic7xxx_tag_info[] =

218 {

219 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},

220 {{4, 64, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 4, 4, 4}},

221 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},

222 {{0, 16, 4, 0, 16, 4, 4, 4, 127, 4, 4, 4, 4, 4, 4, 4}}

223 };

224 */

225

226 #ifdef CONFIG_AIC7XXX_CMDS_PER_DEVICE

227 #define AIC7XXX_CMDS_PER_DEVICE CONFIG_AIC7XXX_CMDS_PER_DEVICE

228 #else

229 #define AIC7XXX_CMDS_PER_DEVICE AHC_MAX_QUEUE

230 #endif

231

232 #define AIC7XXX_CONFIGED_TAG_COMMANDS { \

233 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \

234 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \

235 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \

236 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \

237 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \

238 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \

239 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE, \

240 AIC7XXX_CMDS_PER_DEVICE, AIC7XXX_CMDS_PER_DEVICE \

241 }

242

243 /*

244 * By default, use the number of commands specified by

245 * the users kernel configuration.

246 */

247 static adapter_tag_info_t aic7xxx_tag_info[] =

248 {

249 {AIC7XXX_CONFIGED_TAG_COMMANDS},

250 {AIC7XXX_CONFIGED_TAG_COMMANDS},

251 {AIC7XXX_CONFIGED_TAG_COMMANDS},

252 {AIC7XXX_CONFIGED_TAG_COMMANDS},

253 {AIC7XXX_CONFIGED_TAG_COMMANDS},

254 {AIC7XXX_CONFIGED_TAG_COMMANDS},

255 {AIC7XXX_CONFIGED_TAG_COMMANDS},

256 {AIC7XXX_CONFIGED_TAG_COMMANDS},

257 {AIC7XXX_CONFIGED_TAG_COMMANDS},

258 {AIC7XXX_CONFIGED_TAG_COMMANDS},

259 {AIC7XXX_CONFIGED_TAG_COMMANDS},

260 {AIC7XXX_CONFIGED_TAG_COMMANDS},

261 {AIC7XXX_CONFIGED_TAG_COMMANDS},

262 {AIC7XXX_CONFIGED_TAG_COMMANDS},

263 {AIC7XXX_CONFIGED_TAG_COMMANDS},

264 {AIC7XXX_CONFIGED_TAG_COMMANDS}

265 };

266

267 /*

268 * There should be a specific return value for this in scsi.h, but

269 * it seems that most drivers ignore it.

270 */

271 #define DID_UNDERFLOW DID_ERROR

272

273 void

274 ahc_print_path(struct ahc_softc *ahc, struct scb *scb)

275 {

276 printk("(scsi%d:%c:%d:%d): ",

277 ahc->platform_data->host->host_no,

278 scb != NULL ? SCB_GET_CHANNEL(ahc, scb) : 'X',

279 scb != NULL ? SCB_GET_TARGET(ahc, scb) : -1,

280 scb != NULL ? SCB_GET_LUN(scb) : -1);

281 }

282

283 /*

284 * XXX - these options apply unilaterally to _all_ 274x/284x/294x

285 * cards in the system. This should be fixed. Exceptions to this

286 * rule are noted in the comments.

287 */

288

289 /*

290 * Skip the scsi bus reset. Non 0 make us skip the reset at startup. This

291 * has no effect on any later resets that might occur due to things like

292 * SCSI bus timeouts.

293 */

294 static uint32_t aic7xxx_no_reset;

295

296 /*

297 * Certain PCI motherboards will scan PCI devices from highest to lowest,

298 * others scan from lowest to highest, and they tend to do all kinds of

299 * strange things when they come into contact with PCI bridge chips. The

300 * net result of all this is that the PCI card that is actually used to boot

301 * the machine is very hard to detect. Most motherboards go from lowest

302 * PCI slot number to highest, and the first SCSI controller found is the

303 * one you boot from. The only exceptions to this are when a controller

304 * has its BIOS disabled. So, we by default sort all of our SCSI controllers

305 * from lowest PCI slot number to highest PCI slot number. We also force

306 * all controllers with their BIOS disabled to the end of the list. This

307 * works on *almost* all computers. Where it doesn't work, we have this

308 * option. Setting this option to non-0 will reverse the order of the sort

309 * to highest first, then lowest, but will still leave cards with their BIOS

310 * disabled at the very end. That should fix everyone up unless there are

311 * really strange cirumstances.

312 */

313 static uint32_t aic7xxx_reverse_scan;

314

315 /*

316 * Should we force EXTENDED translation on a controller.

317 * 0 == Use whatever is in the SEEPROM or default to off

318 * 1 == Use whatever is in the SEEPROM or default to on

319 */

320 static uint32_t aic7xxx_extended;

321

322 /*

323 * PCI bus parity checking of the Adaptec controllers. This is somewhat

324 * dubious at best. To my knowledge, this option has never actually

325 * solved a PCI parity problem, but on certain machines with broken PCI

326 * chipset configurations where stray PCI transactions with bad parity are

327 * the norm rather than the exception, the error messages can be overwelming.

328 * It's included in the driver for completeness.

329 * 0 = Shut off PCI parity check

330 * non-0 = reverse polarity pci parity checking

331 */

332 static uint32_t aic7xxx_pci_parity = ~0;

333

334 /*

335 * Certain newer motherboards have put new PCI based devices into the

336 * IO spaces that used to typically be occupied by VLB or EISA cards.

337 * This overlap can cause these newer motherboards to lock up when scanned

338 * for older EISA and VLB devices. Setting this option to non-0 will

339 * cause the driver to skip scanning for any VLB or EISA controllers and

340 * only support the PCI controllers. NOTE: this means that if the kernel

341 * os compiled with PCI support disabled, then setting this to non-0

342 * would result in never finding any devices :)

343 */

344 #ifndef CONFIG_AIC7XXX_PROBE_EISA_VL

345 uint32_t aic7xxx_probe_eisa_vl;

346 #else

347 uint32_t aic7xxx_probe_eisa_vl = ~0;

348 #endif

349

350 /*

351 * There are lots of broken chipsets in the world. Some of them will

352 * violate the PCI spec when we issue byte sized memory writes to our

353 * controller. I/O mapped register access, if allowed by the given

354 * platform, will work in almost all cases.

355 */

356 uint32_t aic7xxx_allow_memio = ~0;

357

358 /*

359 * aic7xxx_detect() has been run, so register all device arrivals

360 * immediately with the system rather than deferring to the sorted

361 * attachment performed by aic7xxx_detect().

362 */

363 int aic7xxx_detect_complete;

364

365 /*

366 * So that we can set how long each device is given as a selection timeout.

367 * The table of values goes like this:

368 * 0 - 256ms

369 * 1 - 128ms

370 * 2 - 64ms

371 * 3 - 32ms

372 * We default to 256ms because some older devices need a longer time

373 * to respond to initial selection.

374 */

375 static uint32_t aic7xxx_seltime;

376

377 /*

378 * Certain devices do not perform any aging on commands. Should the

379 * device be saturated by commands in one portion of the disk, it is

380 * possible for transactions on far away sectors to never be serviced.

381 * To handle these devices, we can periodically send an ordered tag to

382 * force all outstanding transactions to be serviced prior to a new

383 * transaction.

384 */

385 uint32_t aic7xxx_periodic_otag;

386

387 /*

388 * Module information and settable options.

389 */

390 static char *aic7xxx = NULL;

391

392 MODULE_AUTHOR("Maintainer: Justin T. Gibbs <gibbs@scsiguy.com>");

393 MODULE_DESCRIPTION("Adaptec Aic77XX/78XX SCSI Host Bus Adapter driver");

394 MODULE_LICENSE("Dual BSD/GPL");

395 MODULE_VERSION(AIC7XXX_DRIVER_VERSION);

396 module_param(aic7xxx, charp, 0444);

397 MODULE_PARM_DESC(aic7xxx,

398 "period delimited, options string.\n"

399 " verbose Enable verbose/diagnostic logging\n"

400 " allow_memio Allow device registers to be memory mapped\n"

401 " debug Bitmask of debug values to enable\n"

402 " no_probe Toggle EISA/VLB controller probing\n"

403 " probe_eisa_vl Toggle EISA/VLB controller probing\n"

404 " no_reset Supress initial bus resets\n"

405 " extended Enable extended geometry on all controllers\n"

406 " periodic_otag Send an ordered tagged transaction\n"

407 " periodically to prevent tag starvation.\n"

408 " This may be required by some older disk\n"

409 " drives or RAID arrays.\n"

410 " reverse_scan Sort PCI devices highest Bus/Slot to lowest\n"

411 " tag_info:<tag_str> Set per-target tag depth\n"

412 " global_tag_depth:<int> Global tag depth for every target\n"

413 " on every bus\n"

414 " seltime:<int> Selection Timeout\n"

415 " (0/256ms,1/128ms,2/64ms,3/32ms)\n"

416 "\n"

417 " Sample /etc/modprobe.conf line:\n"

418 " Toggle EISA/VLB probing\n"

419 " Set tag depth on Controller 1/Target 1 to 10 tags\n"

420 " Shorten the selection timeout to 128ms\n"

421 "\n"

422 " options aic7xxx 'aic7xxx=probe_eisa_vl.tag_info:{{}.{.10}}.seltime:1'\n"

423 );

424

425 static void ahc_linux_handle_scsi_status(struct ahc_softc *,

426 struct ahc_linux_device *,

427 struct scb *);

428 static void ahc_linux_queue_cmd_complete(struct ahc_softc *ahc,

429 struct scsi_cmnd *cmd);

430 static void ahc_linux_sem_timeout(u_long arg);

431 static void ahc_linux_freeze_simq(struct ahc_softc *ahc);

432 static void ahc_linux_release_simq(u_long arg);

433 static int ahc_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag);

434 static void ahc_linux_initialize_scsi_bus(struct ahc_softc *ahc);

435 static u_int ahc_linux_user_tagdepth(struct ahc_softc *ahc,

436 struct ahc_devinfo *devinfo);

437 static void ahc_linux_device_queue_depth(struct ahc_softc *ahc,

438 struct ahc_linux_device *dev);

439 static struct ahc_linux_target* ahc_linux_alloc_target(struct ahc_softc*,

440 u_int, u_int);

441 static void ahc_linux_free_target(struct ahc_softc*,

442 struct ahc_linux_target*);

443 static struct ahc_linux_device* ahc_linux_alloc_device(struct ahc_softc*,

444 struct ahc_linux_target*,

445 u_int);

446 static void ahc_linux_free_device(struct ahc_softc*,

447 struct ahc_linux_device*);

448 static int ahc_linux_run_command(struct ahc_softc*,

449 struct ahc_linux_device *,

450 struct scsi_cmnd *);

451 static void ahc_linux_setup_tag_info_global(char *p);

452 static aic_option_callback_t ahc_linux_setup_tag_info;

453 static int aic7xxx_setup(char *s);

454 static int ahc_linux_next_unit(void);

455

456 /********************************* Inlines ************************************/

457 static __inline struct ahc_linux_device*

458 ahc_linux_get_device(struct ahc_softc *ahc, u_int channel,

459 u_int target, u_int lun);

460 static __inline void ahc_linux_unmap_scb(struct ahc_softc*, struct scb*);

461

462 static __inline int ahc_linux_map_seg(struct ahc_softc *ahc, struct scb *scb,

463 struct ahc_dma_seg *sg,

464 dma_addr_t addr, bus_size_t len);

465

466 static __inline struct ahc_linux_device*

467 ahc_linux_get_device(struct ahc_softc *ahc, u_int channel, u_int target,

468 u_int lun)

469 {

470 struct ahc_linux_target *targ;

471 struct ahc_linux_device *dev;

472 u_int target_offset;

473

474 target_offset = target;

475 if (channel != 0)

476 target_offset += 8;

477 targ = ahc->platform_data->targets[target_offset];

478 BUG_ON(targ == NULL);

479 dev = targ->devices[lun];

480 return dev;

481 }

482

483 static __inline void

484 ahc_linux_unmap_scb(struct ahc_softc *ahc, struct scb *scb)

485 {

486 struct scsi_cmnd *cmd;

487

488 cmd = scb->io_ctx;

489 ahc_sync_sglist(ahc, scb, BUS_DMASYNC_POSTWRITE);

490 if (cmd->use_sg != 0) {

491 struct scatterlist *sg;

492

493 sg = (struct scatterlist *)cmd->request_buffer;

494 pci_unmap_sg(ahc->dev_softc, sg, cmd->use_sg,

495 cmd->sc_data_direction);

496 } else if (cmd->request_bufflen != 0) {

497 pci_unmap_single(ahc->dev_softc,

498 scb->platform_data->buf_busaddr,

499 cmd->request_bufflen,

500 cmd->sc_data_direction);

501 }

502 }

503

504 static __inline int

505 ahc_linux_map_seg(struct ahc_softc *ahc, struct scb *scb,

506 struct ahc_dma_seg *sg, dma_addr_t addr, bus_size_t len)

507 {

508 int consumed;

509

510 if ((scb->sg_count + 1) > AHC_NSEG)

511 panic("Too few segs for dma mapping. "

512 "Increase AHC_NSEG\n");

513

514 consumed = 1;

515 sg->addr = ahc_htole32(addr & 0xFFFFFFFF);

516 scb->platform_data->xfer_len += len;

517

518 if (sizeof(dma_addr_t) > 4

519 && (ahc->flags & AHC_39BIT_ADDRESSING) != 0)

520 len |= (addr >> 8) & AHC_SG_HIGH_ADDR_MASK;

521

522 sg->len = ahc_htole32(len);

523 return (consumed);

524 }

525

526 /*

527 * Try to detect an Adaptec 7XXX controller.

528 */

529 static int

530 ahc_linux_detect(struct scsi_host_template *template)

531 {

532 struct ahc_softc *ahc;

533 int found = 0;

534

535 /*

536 * Sanity checking of Linux SCSI data structures so

537 * that some of our hacks^H^H^H^H^Hassumptions aren't

538 * violated.

539 */

540 if (offsetof(struct ahc_cmd_internal, end)

541 > offsetof(struct scsi_cmnd, host_scribble)) {

542 printf("ahc_linux_detect: SCSI data structures changed.\n");

543 printf("ahc_linux_detect: Unable to attach\n");

544 return (0);

545 }

546 /*

547 * If we've been passed any parameters, process them now.

548 */

549 if (aic7xxx)

550 aic7xxx_setup(aic7xxx);

551

552 template->proc_name = "aic7xxx";

553

554 /*

555 * Initialize our softc list lock prior to

556 * probing for any adapters.

557 */

558 ahc_list_lockinit();

559

560 found = ahc_linux_pci_init();

561 if (!ahc_linux_eisa_init())

562 found++;

563

564 /*

565 * Register with the SCSI layer all

566 * controllers we've found.

567 */

568 TAILQ_FOREACH(ahc, &ahc_tailq, links) {

569

570 if (ahc_linux_register_host(ahc, template) == 0)

571 found++;

572 }

573

574 aic7xxx_detect_complete++;

575

576 return (found);

577 }

578

579 /*

580 * Return a string describing the driver.

581 */

582 static const char *

583 ahc_linux_info(struct Scsi_Host *host)

584 {

585 static char buffer[512];

586 char ahc_info[256];

587 char *bp;

588 struct ahc_softc *ahc;

589

590 bp = &buffer[0];

591 ahc = *(struct ahc_softc **)host->hostdata;

592 memset(bp, 0, sizeof(buffer));

593 strcpy(bp, "Adaptec AIC7XXX EISA/VLB/PCI SCSI HBA DRIVER, Rev ");

594 strcat(bp, AIC7XXX_DRIVER_VERSION);

595 strcat(bp, "\n");

596 strcat(bp, " <");

597 strcat(bp, ahc->description);

598 strcat(bp, ">\n");

599 strcat(bp, " ");

600 ahc_controller_info(ahc, ahc_info);

601 strcat(bp, ahc_info);

602 strcat(bp, "\n");

603

604 return (bp);

605 }

606

607 /*

608 * Queue an SCB to the controller.

609 */

610 static int

611 ahc_linux_queue(struct scsi_cmnd * cmd, void (*scsi_done) (struct scsi_cmnd *))

612 {

613 struct ahc_softc *ahc;

614 struct ahc_linux_device *dev;

615

616 ahc = *(struct ahc_softc **)cmd->device->host->hostdata;

617

618 /*

619 * Save the callback on completion function.

620 */

621 cmd->scsi_done = scsi_done;

622

623 /*

624 * Close the race of a command that was in the process of

625 * being queued to us just as our simq was frozen. Let

626 * DV commands through so long as we are only frozen to

627 * perform DV.

628 */

629 if (ahc->platform_data->qfrozen != 0)

630 return SCSI_MLQUEUE_HOST_BUSY;

631

632 dev = ahc_linux_get_device(ahc, cmd->device->channel, cmd->device->id,

633 cmd->device->lun);

634 BUG_ON(dev == NULL);

635

636 cmd->result = CAM_REQ_INPROG << 16;

637

638 return ahc_linux_run_command(ahc, dev, cmd);

639 }

640

641 static int

642 ahc_linux_slave_alloc(struct scsi_device *device)

643 {

644 struct ahc_softc *ahc;

645 struct ahc_linux_target *targ;

646 struct scsi_target *starget = device->sdev_target;

647 struct ahc_linux_device *dev;

648 u_int target_offset;

649

650 target_offset = starget->id;

651 if (starget->channel != 0)

652 target_offset += 8;

653

654 ahc = *((struct ahc_softc **)device->host->hostdata);

655 if (bootverbose)

656 printf("%s: Slave Alloc %d\n", ahc_name(ahc), device->id);

657 targ = ahc->platform_data->targets[target_offset];

658 if (targ == NULL) {

659 targ = ahc_linux_alloc_target(ahc, starget->channel, starget->id);

660 struct seeprom_config *sc = ahc->seep_config;

661 if (targ == NULL)

662 return -ENOMEM;

663 if (sc) {

664 unsigned short scsirate;

665 struct ahc_devinfo devinfo;

666 struct ahc_initiator_tinfo *tinfo;

667 struct ahc_tmode_tstate *tstate;

668 char channel = starget->channel + 'A';

669 unsigned int our_id = ahc->our_id;

670

671 if (starget->channel)

672 our_id = ahc->our_id_b;

673

674 if ((ahc->features & AHC_ULTRA2) != 0) {

675 scsirate = sc->device_flags[target_offset] & CFXFER;

676 } else {

677 scsirate = (sc->device_flags[target_offset] & CFXFER) << 4;

678 if (sc->device_flags[target_offset] & CFSYNCH)

679 scsirate |= SOFS;

680 }

681 if (sc->device_flags[target_offset] & CFWIDEB) {

682 scsirate |= WIDEXFER;

683 spi_max_width(starget) = 1;

684 } else

685 spi_max_width(starget) = 0;

686 spi_min_period(starget) =

687 ahc_find_period(ahc, scsirate, AHC_SYNCRATE_DT);

688 tinfo = ahc_fetch_transinfo(ahc, channel, ahc->our_id,

689 targ->target, &tstate);

690 ahc_compile_devinfo(&devinfo, our_id, targ->target,

691 CAM_LUN_WILDCARD, channel,

692 ROLE_INITIATOR);

693 ahc_set_syncrate(ahc, &devinfo, NULL, 0, 0, 0,

694 AHC_TRANS_GOAL, /*paused*/FALSE);

695 ahc_set_width(ahc, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,

696 AHC_TRANS_GOAL, /*paused*/FALSE);

697 }

698

699 }

700 dev = targ->devices[device->lun];

701 if (dev == NULL) {

702 dev = ahc_linux_alloc_device(ahc, targ, device->lun);

703 if (dev == NULL)

704 return -ENOMEM;

705 }

706

707 return 0;

708 }

709

710 static int

711 ahc_linux_slave_configure(struct scsi_device *device)

712 {

713 struct ahc_softc *ahc;

714 struct ahc_linux_device *dev;

715

716 ahc = *((struct ahc_softc **)device->host->hostdata);

717

718 if (bootverbose)

719 printf("%s: Slave Configure %d\n", ahc_name(ahc), device->id);

720

721 dev = ahc_linux_get_device(ahc, device->channel, device->id,

722 device->lun);

723 dev->scsi_device = device;

724 ahc_linux_device_queue_depth(ahc, dev);

725

726 /* Initial Domain Validation */

727 if (!spi_initial_dv(device->sdev_target))

728 spi_dv_device(device);

729

730 return 0;

731 }

732

733 static void

734 ahc_linux_slave_destroy(struct scsi_device *device)

735 {

736 struct ahc_softc *ahc;

737 struct ahc_linux_device *dev;

738

739 ahc = *((struct ahc_softc **)device->host->hostdata);

740 if (bootverbose)

741 printf("%s: Slave Destroy %d\n", ahc_name(ahc), device->id);

742 dev = ahc_linux_get_device(ahc, device->channel,

743 device->id, device->lun);

744

745 BUG_ON(dev->active);

746

747 ahc_linux_free_device(ahc, dev);

748 }

749

750 #if defined(__i386__)

751 /*

752 * Return the disk geometry for the given SCSI device.

753 */

754 static int

755 ahc_linux_biosparam(struct scsi_device *sdev, struct block_device *bdev,

756 sector_t capacity, int geom[])

757 {

758 uint8_t *bh;

759 int heads;

760 int sectors;

761 int cylinders;

762 int ret;

763 int extended;

764 struct ahc_softc *ahc;

765 u_int channel;

766

767 ahc = *((struct ahc_softc **)sdev->host->hostdata);

768 channel = sdev->channel;

769

770 bh = scsi_bios_ptable(bdev);

771 if (bh) {

772 ret = scsi_partsize(bh, capacity,

773 &geom[2], &geom[0], &geom[1]);

774 kfree(bh);

775 if (ret != -1)

776 return (ret);

777 }

778 heads = 64;

779 sectors = 32;

780 cylinders = aic_sector_div(capacity, heads, sectors);

781

782 if (aic7xxx_extended != 0)

783 extended = 1;

784 else if (channel == 0)

785 extended = (ahc->flags & AHC_EXTENDED_TRANS_A) != 0;

786 else

787 extended = (ahc->flags & AHC_EXTENDED_TRANS_B) != 0;

788 if (extended && cylinders >= 1024) {

789 heads = 255;

790 sectors = 63;

791 cylinders = aic_sector_div(capacity, heads, sectors);

792 }

793 geom[0] = heads;

794 geom[1] = sectors;

795 geom[2] = cylinders;

796 return (0);

797 }

798 #endif

799

800 /*

801 * Abort the current SCSI command(s).

802 */

803 static int

804 ahc_linux_abort(struct scsi_cmnd *cmd)

805 {

806 int error;

807

808 error = ahc_linux_queue_recovery_cmd(cmd, SCB_ABORT);

809 if (error != 0)

810 printf("aic7xxx_abort returns 0x%x\n", error);

811 return (error);

812 }

813

814 /*

815 * Attempt to send a target reset message to the device that timed out.

816 */

817 static int

818 ahc_linux_dev_reset(struct scsi_cmnd *cmd)

819 {

820 int error;

821

822 error = ahc_linux_queue_recovery_cmd(cmd, SCB_DEVICE_RESET);

823 if (error != 0)

824 printf("aic7xxx_dev_reset returns 0x%x\n", error);

825 return (error);

826 }

827

828 /*

829 * Reset the SCSI bus.

830 */

831 static int

832 ahc_linux_bus_reset(struct scsi_cmnd *cmd)

833 {

834 struct ahc_softc *ahc;

835 int found;

836

837 ahc = *(struct ahc_softc **)cmd->device->host->hostdata;

838 found = ahc_reset_channel(ahc, cmd->device->channel + 'A',

839 /*initiate reset*/TRUE);

840

841 if (bootverbose)

842 printf("%s: SCSI bus reset delivered. "

843 "%d SCBs aborted.\n", ahc_name(ahc), found);

844

845 return SUCCESS;

846 }

847

848 struct scsi_host_template aic7xxx_driver_template = {

849 .module = THIS_MODULE,

850 .name = "aic7xxx",

851 .proc_info = ahc_linux_proc_info,

852 .info = ahc_linux_info,

853 .queuecommand = ahc_linux_queue,

854 .eh_abort_handler = ahc_linux_abort,

855 .eh_device_reset_handler = ahc_linux_dev_reset,

856 .eh_bus_reset_handler = ahc_linux_bus_reset,

857 #if defined(__i386__)

858 .bios_param = ahc_linux_biosparam,

859 #endif

860 .can_queue = AHC_MAX_QUEUE,

861 .this_id = -1,

862 .cmd_per_lun = 2,

863 .use_clustering = ENABLE_CLUSTERING,

864 .slave_alloc = ahc_linux_slave_alloc,

865 .slave_configure = ahc_linux_slave_configure,

866 .slave_destroy = ahc_linux_slave_destroy,

867 };

868

869 /**************************** Tasklet Handler *********************************/

870

871 /******************************** Macros **************************************/

872 #define BUILD_SCSIID(ahc, cmd) \

873 ((((cmd)->device->id << TID_SHIFT) & TID) \

874 | (((cmd)->device->channel == 0) ? (ahc)->our_id : (ahc)->our_id_b) \

875 | (((cmd)->device->channel == 0) ? 0 : TWIN_CHNLB))

876

877 /******************************** Bus DMA *************************************/

878 int

879 ahc_dma_tag_create(struct ahc_softc *ahc, bus_dma_tag_t parent,

880 bus_size_t alignment, bus_size_t boundary,

881 dma_addr_t lowaddr, dma_addr_t highaddr,

882 bus_dma_filter_t *filter, void *filterarg,

883 bus_size_t maxsize, int nsegments,

884 bus_size_t maxsegsz, int flags, bus_dma_tag_t *ret_tag)

885 {

886 bus_dma_tag_t dmat;

887

888 dmat = malloc(sizeof(*dmat), M_DEVBUF, M_NOWAIT);

889 if (dmat == NULL)

890 return (ENOMEM);

891

892 /*

893 * Linux is very simplistic about DMA memory. For now don't

894 * maintain all specification information. Once Linux supplies

895 * better facilities for doing these operations, or the

896 * needs of this particular driver change, we might need to do

897 * more here.

898 */

899 dmat->alignment = alignment;

900 dmat->boundary = boundary;

901 dmat->maxsize = maxsize;

902 *ret_tag = dmat;

903 return (0);

904 }

905

906 void

907 ahc_dma_tag_destroy(struct ahc_softc *ahc, bus_dma_tag_t dmat)

908 {

909 free(dmat, M_DEVBUF);

910 }

911

912 int

913 ahc_dmamem_alloc(struct ahc_softc *ahc, bus_dma_tag_t dmat, void** vaddr,

914 int flags, bus_dmamap_t *mapp)

915 {

916 *vaddr = pci_alloc_consistent(ahc->dev_softc,

917 dmat->maxsize, mapp);

918 if (*vaddr == NULL)

919 return ENOMEM;

920 return 0;

921 }

922

923 void

924 ahc_dmamem_free(struct ahc_softc *ahc, bus_dma_tag_t dmat,

925 void* vaddr, bus_dmamap_t map)

926 {

927 pci_free_consistent(ahc->dev_softc, dmat->maxsize,

928 vaddr, map);

929 }

930

931 int

932 ahc_dmamap_load(struct ahc_softc *ahc, bus_dma_tag_t dmat, bus_dmamap_t map,

933 void *buf, bus_size_t buflen, bus_dmamap_callback_t *cb,

934 void *cb_arg, int flags)

935 {

936 /*

937 * Assume for now that this will only be used during

938 * initialization and not for per-transaction buffer mapping.

939 */

940 bus_dma_segment_t stack_sg;

941

942 stack_sg.ds_addr = map;

943 stack_sg.ds_len = dmat->maxsize;

944 cb(cb_arg, &stack_sg, /*nseg*/1, /*error*/0);

945 return (0);

946 }

947

948 void

949 ahc_dmamap_destroy(struct ahc_softc *ahc, bus_dma_tag_t dmat, bus_dmamap_t map)

950 {

951 }

952

953 int

954 ahc_dmamap_unload(struct ahc_softc *ahc, bus_dma_tag_t dmat, bus_dmamap_t map)

955 {

956 /* Nothing to do */

957 return (0);

958 }

959

960 /********************* Platform Dependent Functions ***************************/

961 /*

962 * Compare "left hand" softc with "right hand" softc, returning:

963 * < 0 - lahc has a lower priority than rahc

964 * 0 - Softcs are equal

965 * > 0 - lahc has a higher priority than rahc

966 */

967 int

968 ahc_softc_comp(struct ahc_softc *lahc, struct ahc_softc *rahc)

969 {

970 int value;

971 int rvalue;

972 int lvalue;

973

974 /*

975 * Under Linux, cards are ordered as follows:

976 * 1) VLB/EISA BIOS enabled devices sorted by BIOS address.

977 * 2) PCI devices with BIOS enabled sorted by bus/slot/func.

978 * 3) All remaining VLB/EISA devices sorted by ioport.

979 * 4) All remaining PCI devices sorted by bus/slot/func.

980 */

981 value = (lahc->flags & AHC_BIOS_ENABLED)

982 - (rahc->flags & AHC_BIOS_ENABLED);

983 if (value != 0)

984 /* Controllers with BIOS enabled have a *higher* priority */

985 return (value);

986

987 /*

988 * Same BIOS setting, now sort based on bus type.

989 * EISA and VL controllers sort together. EISA/VL

990 * have higher priority than PCI.

991 */

992 rvalue = (rahc->chip & AHC_BUS_MASK);

993 if (rvalue == AHC_VL)

994 rvalue = AHC_EISA;

995 lvalue = (lahc->chip & AHC_BUS_MASK);

996 if (lvalue == AHC_VL)

997 lvalue = AHC_EISA;

998 value = rvalue - lvalue;

999 if (value != 0)

1000 return (value);

1001

1002 /* Still equal. Sort by BIOS address, ioport, or bus/slot/func. */

1003 switch (rvalue) {

1004 #ifdef CONFIG_PCI

1005 case AHC_PCI:

1006 {

1007 char primary_channel;

1008

1009 if (aic7xxx_reverse_scan != 0)

1010 value = ahc_get_pci_bus(lahc->dev_softc)

1011 - ahc_get_pci_bus(rahc->dev_softc);

1012 else

1013 value = ahc_get_pci_bus(rahc->dev_softc)

1014 - ahc_get_pci_bus(lahc->dev_softc);

1015 if (value != 0)

1016 break;

1017 if (aic7xxx_reverse_scan != 0)

1018 value = ahc_get_pci_slot(lahc->dev_softc)

1019 - ahc_get_pci_slot(rahc->dev_softc);

1020 else

1021 value = ahc_get_pci_slot(rahc->dev_softc)

1022 - ahc_get_pci_slot(lahc->dev_softc);

1023 if (value != 0)

1024 break;

1025 /*

1026 * On multi-function devices, the user can choose

1027 * to have function 1 probed before function 0.

1028 * Give whichever channel is the primary channel

1029 * the highest priority.

1030 */

1031 primary_channel = (lahc->flags & AHC_PRIMARY_CHANNEL) + 'A';

1032 value = -1;

1033 if (lahc->channel == primary_channel)

1034 value = 1;

1035 break;

1036 }

1037 #endif

1038 case AHC_EISA:

1039 if ((rahc->flags & AHC_BIOS_ENABLED) != 0) {

1040 value = rahc->platform_data->bios_address

1041 - lahc->platform_data->bios_address;

1042 } else {

1043 value = rahc->bsh.ioport

1044 - lahc->bsh.ioport;

1045 }

1046 break;

1047 default:

1048 panic("ahc_softc_sort: invalid bus type");

1049 }

1050 return (value);

1051 }

1052

1053 static void

1054 ahc_linux_setup_tag_info_global(char *p)

1055 {

1056 int tags, i, j;

1057

1058 tags = simple_strtoul(p + 1, NULL, 0) & 0xff;

1059 printf("Setting Global Tags= %d\n", tags);

1060

1061 for (i = 0; i < NUM_ELEMENTS(aic7xxx_tag_info); i++) {

1062 for (j = 0; j < AHC_NUM_TARGETS; j++) {

1063 aic7xxx_tag_info[i].tag_commands[j] = tags;

1064 }

1065 }

1066 }

1067

1068 static void

1069 ahc_linux_setup_tag_info(u_long arg, int instance, int targ, int32_t value)

1070 {

1071

1072 if ((instance >= 0) && (targ >= 0)

1073 && (instance < NUM_ELEMENTS(aic7xxx_tag_info))

1074 && (targ < AHC_NUM_TARGETS)) {

1075 aic7xxx_tag_info[instance].tag_commands[targ] = value & 0xff;

1076 if (bootverbose)

1077 printf("tag_info[%d:%d] = %d\n", instance, targ, value);

1078 }

1079 }

1080

1081 /*

1082 * Handle Linux boot parameters. This routine allows for assigning a value

1083 * to a parameter with a ':' between the parameter and the value.

1084 * ie. aic7xxx=stpwlev:1,extended

1085 */

1086 static int

1087 aic7xxx_setup(char *s)

1088 {

1089 int i, n;

1090 char *p;

1091 char *end;

1092

1093 static struct {

1094 const char *name;

1095 uint32_t *flag;

1096 } options[] = {

1097 { "extended", &aic7xxx_extended },

1098 { "no_reset", &aic7xxx_no_reset },

1099 { "verbose", &aic7xxx_verbose },

1100 { "allow_memio", &aic7xxx_allow_memio},

1101 #ifdef AHC_DEBUG

1102 { "debug", &ahc_debug },

1103 #endif

1104 { "reverse_scan", &aic7xxx_reverse_scan },

1105 { "no_probe", &aic7xxx_probe_eisa_vl },

1106 { "probe_eisa_vl", &aic7xxx_probe_eisa_vl },

1107 { "periodic_otag", &aic7xxx_periodic_otag },

1108 { "pci_parity", &aic7xxx_pci_parity },

1109 { "seltime", &aic7xxx_seltime },

1110 { "tag_info", NULL },

1111 { "global_tag_depth", NULL },

1112 { "dv", NULL }

1113 };

1114

1115 end = strchr(s, '\0');

1116

1117 /*

1118 * XXX ia64 gcc isn't smart enough to know that NUM_ELEMENTS

1119 * will never be 0 in this case.

1120 */

1121 n = 0;

1122

1123 while ((p = strsep(&s, ",.")) != NULL) {

1124 if (*p == '\0')

1125 continue;

1126 for (i = 0; i < NUM_ELEMENTS(options); i++) {

1127

1128 n = strlen(options[i].name);

1129 if (strncmp(options[i].name, p, n) == 0)

1130 break;

1131 }

1132 if (i == NUM_ELEMENTS(options))

1133 continue;

1134

1135 if (strncmp(p, "global_tag_depth", n) == 0) {

1136 ahc_linux_setup_tag_info_global(p + n);

1137 } else if (strncmp(p, "tag_info", n) == 0) {

1138 s = aic_parse_brace_option("tag_info", p + n, end,

1139 2, ahc_linux_setup_tag_info, 0);

1140 } else if (p[n] == ':') {

1141 *(options[i].flag) = simple_strtoul(p + n + 1, NULL, 0);

1142 } else if (strncmp(p, "verbose", n) == 0) {

1143 *(options[i].flag) = 1;

1144 } else {

1145 *(options[i].flag) ^= 0xFFFFFFFF;

1146 }

1147 }

1148 return 1;

1149 }

1150

1151 __setup("aic7xxx=", aic7xxx_setup);

1152

1153 uint32_t aic7xxx_verbose;

1154

1155 int

1156 ahc_linux_register_host(struct ahc_softc *ahc, struct scsi_host_template *template)

1157 {

1158 char buf[80];

1159 struct Scsi_Host *host;

1160 char *new_name;

1161 u_long s;

1162

1163 template->name = ahc->description;

1164 host = scsi_host_alloc(template, sizeof(struct ahc_softc *));

1165 if (host == NULL)

1166 return (ENOMEM);

1167

1168 *((struct ahc_softc **)host->hostdata) = ahc;

1169 ahc_lock(ahc, &s);

1170 scsi_assign_lock(host, &ahc->platform_data->spin_lock);

1171 ahc->platform_data->host = host;

1172 host->can_queue = AHC_MAX_QUEUE;

1173 host->cmd_per_lun = 2;

1174 /* XXX No way to communicate the ID for multiple channels */

1175 host->this_id = ahc->our_id;

1176 host->irq = ahc->platform_data->irq;

1177 host->max_id = (ahc->features & AHC_WIDE) ? 16 : 8;

1178 host->max_lun = AHC_NUM_LUNS;

1179 host->max_channel = (ahc->features & AHC_TWIN) ? 1 : 0;

1180 host->sg_tablesize = AHC_NSEG;

1181 ahc_set_unit(ahc, ahc_linux_next_unit());

1182 sprintf(buf, "scsi%d", host->host_no);

1183 new_name = malloc(strlen(buf) + 1, M_DEVBUF, M_NOWAIT);

1184 if (new_name != NULL) {

1185 strcpy(new_name, buf);

1186 ahc_set_name(ahc, new_name);

1187 }

1188 host->unique_id = ahc->unit;

1189 ahc_linux_initialize_scsi_bus(ahc);

1190 ahc_intr_enable(ahc, TRUE);

1191 ahc_unlock(ahc, &s);

1192

1193 host->transportt = ahc_linux_transport_template;

1194

1195 scsi_add_host(host, (ahc->dev_softc ? &ahc->dev_softc->dev : NULL)); /* XXX handle failure */

1196 scsi_scan_host(host);

1197 return (0);

1198 }

1199

1200 uint64_t

1201 ahc_linux_get_memsize(void)

1202 {

1203 struct sysinfo si;

1204

1205 si_meminfo(&si);

1206 return ((uint64_t)si.totalram << PAGE_SHIFT);

1207 }

1208

1209 /*

1210 * Find the smallest available unit number to use

1211 * for a new device. We don't just use a static

1212 * count to handle the "repeated hot-(un)plug"

1213 * scenario.

1214 */

1215 static int

1216 ahc_linux_next_unit(void)

1217 {

1218 struct ahc_softc *ahc;

1219 int unit;

1220

1221 unit = 0;

1222 retry:

1223 TAILQ_FOREACH(ahc, &ahc_tailq, links) {

1224 if (ahc->unit == unit) {

1225 unit++;

1226 goto retry;

1227 }

1228 }

1229 return (unit);

1230 }

1231

1232 /*

1233 * Place the SCSI bus into a known state by either resetting it,

1234 * or forcing transfer negotiations on the next command to any

1235 * target.

1236 */

1237 void

1238 ahc_linux_initialize_scsi_bus(struct ahc_softc *ahc)

1239 {

1240 int i;

1241 int numtarg;

1242

1243 i = 0;

1244 numtarg = 0;

1245

1246 if (aic7xxx_no_reset != 0)

1247 ahc->flags &= ~(AHC_RESET_BUS_A|AHC_RESET_BUS_B);

1248

1249 if ((ahc->flags & AHC_RESET_BUS_A) != 0)

1250 ahc_reset_channel(ahc, 'A', /*initiate_reset*/TRUE);

1251 else

1252 numtarg = (ahc->features & AHC_WIDE) ? 16 : 8;

1253

1254 if ((ahc->features & AHC_TWIN) != 0) {

1255

1256 if ((ahc->flags & AHC_RESET_BUS_B) != 0) {

1257 ahc_reset_channel(ahc, 'B', /*initiate_reset*/TRUE);

1258 } else {

1259 if (numtarg == 0)

1260 i = 8;

1261 numtarg += 8;

1262 }

1263 }

1264

1265 /*

1266 * Force negotiation to async for all targets that

1267 * will not see an initial bus reset.

1268 */

1269 for (; i < numtarg; i++) {

1270 struct ahc_devinfo devinfo;

1271 struct ahc_initiator_tinfo *tinfo;

1272 struct ahc_tmode_tstate *tstate;

1273 u_int our_id;

1274 u_int target_id;

1275 char channel;

1276

1277 channel = 'A';

1278 our_id = ahc->our_id;

1279 target_id = i;

1280 if (i > 7 && (ahc->features & AHC_TWIN) != 0) {

1281 channel = 'B';

1282 our_id = ahc->our_id_b;

1283 target_id = i % 8;

1284 }

1285 tinfo = ahc_fetch_transinfo(ahc, channel, our_id,

1286 target_id, &tstate);

1287 ahc_compile_devinfo(&devinfo, our_id, target_id,

1288 CAM_LUN_WILDCARD, channel, ROLE_INITIATOR);

1289 ahc_update_neg_request(ahc, &devinfo, tstate,

1290 tinfo, AHC_NEG_ALWAYS);

1291 }

1292 /* Give the bus some time to recover */

1293 if ((ahc->flags & (AHC_RESET_BUS_A|AHC_RESET_BUS_B)) != 0) {

1294 ahc_linux_freeze_simq(ahc);

1295 init_timer(&ahc->platform_data->reset_timer);

1296 ahc->platform_data->reset_timer.data = (u_long)ahc;

1297 ahc->platform_data->reset_timer.expires =

1298 jiffies + (AIC7XXX_RESET_DELAY * HZ)/1000;

1299 ahc->platform_data->reset_timer.function =

1300 ahc_linux_release_simq;

1301 add_timer(&ahc->platform_data->reset_timer);

1302 }

1303 }

1304

1305 int

1306 ahc_platform_alloc(struct ahc_softc *ahc, void *platform_arg)

1307 {

1308

1309 ahc->platform_data =

1310 malloc(sizeof(struct ahc_platform_data), M_DEVBUF, M_NOWAIT);

1311 if (ahc->platform_data == NULL)

1312 return (ENOMEM);

1313 memset(ahc->platform_data, 0, sizeof(struct ahc_platform_data));

1314 ahc->platform_data->irq = AHC_LINUX_NOIRQ;

1315 ahc_lockinit(ahc);

1316 init_MUTEX_LOCKED(&ahc->platform_data->eh_sem);

1317 ahc->seltime = (aic7xxx_seltime & 0x3) << 4;

1318 ahc->seltime_b = (aic7xxx_seltime & 0x3) << 4;

1319 if (aic7xxx_pci_parity == 0)

1320 ahc->flags |= AHC_DISABLE_PCI_PERR;

1321

1322 return (0);

1323 }

1324

1325 void

1326 ahc_platform_free(struct ahc_softc *ahc)

1327 {

1328 struct ahc_linux_target *targ;

1329 struct ahc_linux_device *dev;

1330 int i, j;

1331

1332 if (ahc->platform_data != NULL) {

1333 if (ahc->platform_data->host != NULL) {

1334 scsi_remove_host(ahc->platform_data->host);

1335 scsi_host_put(ahc->platform_data->host);

1336 }

1337

1338 /* destroy all of the device and target objects */

1339 for (i = 0; i < AHC_NUM_TARGETS; i++) {

1340 targ = ahc->platform_data->targets[i];

1341 if (targ != NULL) {

1342 /* Keep target around through the loop. */

1343 targ->refcount++;

1344 for (j = 0; j < AHC_NUM_LUNS; j++) {

1345

1346 if (targ->devices[j] == NULL)

1347 continue;

1348 dev = targ->devices[j];

1349 ahc_linux_free_device(ahc, dev);

1350 }

1351 /*

1352 * Forcibly free the target now that

1353 * all devices are gone.

1354 */

1355 ahc_linux_free_target(ahc, targ);

1356 }

1357 }

1358

1359 if (ahc->platform_data->irq != AHC_LINUX_NOIRQ)

1360 free_irq(ahc->platform_data->irq, ahc);

1361 if (ahc->tag == BUS_SPACE_PIO

1362 && ahc->bsh.ioport != 0)

1363 release_region(ahc->bsh.ioport, 256);

1364 if (ahc->tag == BUS_SPACE_MEMIO

1365 && ahc->bsh.maddr != NULL) {

1366 iounmap(ahc->bsh.maddr);

1367 release_mem_region(ahc->platform_data->mem_busaddr,

1368 0x1000);

1369 }

1370

1371 free(ahc->platform_data, M_DEVBUF);

1372 }

1373 }

1374

1375 void

1376 ahc_platform_freeze_devq(struct ahc_softc *ahc, struct scb *scb)

1377 {

1378 ahc_platform_abort_scbs(ahc, SCB_GET_TARGET(ahc, scb),

1379 SCB_GET_CHANNEL(ahc, scb),

1380 SCB_GET_LUN(scb), SCB_LIST_NULL,

1381 ROLE_UNKNOWN, CAM_REQUEUE_REQ);

1382 }

1383

1384 void

1385 ahc_platform_set_tags(struct ahc_softc *ahc, struct ahc_devinfo *devinfo,

1386 ahc_queue_alg alg)

1387 {

1388 struct ahc_linux_device *dev;

1389 int was_queuing;

1390 int now_queuing;

1391

1392 dev = ahc_linux_get_device(ahc, devinfo->channel - 'A',

1393 devinfo->target,

1394 devinfo->lun);

1395 if (dev == NULL)

1396 return;

1397 was_queuing = dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED);

1398 switch (alg) {

1399 default:

1400 case AHC_QUEUE_NONE:

1401 now_queuing = 0;

1402 break;

1403 case AHC_QUEUE_BASIC:

1404 now_queuing = AHC_DEV_Q_BASIC;

1405 break;

1406 case AHC_QUEUE_TAGGED:

1407 now_queuing = AHC_DEV_Q_TAGGED;

1408 break;

1409 }

1410 if ((dev->flags & AHC_DEV_FREEZE_TIL_EMPTY) == 0

1411 && (was_queuing != now_queuing)

1412 && (dev->active != 0)) {

1413 dev->flags |= AHC_DEV_FREEZE_TIL_EMPTY;

1414 dev->qfrozen++;

1415 }

1416

1417 dev->flags &= ~(AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED|AHC_DEV_PERIODIC_OTAG);

1418 if (now_queuing) {

1419 u_int usertags;

1420

1421 usertags = ahc_linux_user_tagdepth(ahc, devinfo);

1422 if (!was_queuing) {

1423 /*

1424 * Start out agressively and allow our

1425 * dynamic queue depth algorithm to take

1426 * care of the rest.

1427 */

1428 dev->maxtags = usertags;

1429 dev->openings = dev->maxtags - dev->active;

1430 }

1431 if (dev->maxtags == 0) {

1432 /*

1433 * Queueing is disabled by the user.

1434 */

1435 dev->openings = 1;

1436 } else if (alg == AHC_QUEUE_TAGGED) {

1437 dev->flags |= AHC_DEV_Q_TAGGED;

1438 if (aic7xxx_periodic_otag != 0)

1439 dev->flags |= AHC_DEV_PERIODIC_OTAG;

1440 } else

1441 dev->flags |= AHC_DEV_Q_BASIC;

1442 } else {

1443 /* We can only have one opening. */

1444 dev->maxtags = 0;

1445 dev->openings = 1 - dev->active;

1446 }

1447 if (dev->scsi_device != NULL) {

1448 switch ((dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED))) {

1449 case AHC_DEV_Q_BASIC:

1450 scsi_adjust_queue_depth(dev->scsi_device,

1451 MSG_SIMPLE_TASK,

1452 dev->openings + dev->active);

1453 break;

1454 case AHC_DEV_Q_TAGGED:

1455 scsi_adjust_queue_depth(dev->scsi_device,

1456 MSG_ORDERED_TASK,

1457 dev->openings + dev->active);

1458 break;

1459 default:

1460 /*

1461 * We allow the OS to queue 2 untagged transactions to

1462 * us at any time even though we can only execute them

1463 * serially on the controller/device. This should

1464 * remove some latency.

1465 */

1466 scsi_adjust_queue_depth(dev->scsi_device,

1467 /*NON-TAGGED*/0,

1468 /*queue depth*/2);

1469 break;

1470 }

1471 }

1472 }

1473

1474 int

1475 ahc_platform_abort_scbs(struct ahc_softc *ahc, int target, char channel,

1476 int lun, u_int tag, role_t role, uint32_t status)

1477 {

1478 return 0;

1479 }

1480

1481 static u_int

1482 ahc_linux_user_tagdepth(struct ahc_softc *ahc, struct ahc_devinfo *devinfo)

1483 {

1484 static int warned_user;

1485 u_int tags;

1486

1487 tags = 0;

1488 if ((ahc->user_discenable & devinfo->target_mask) != 0) {

1489 if (ahc->unit >= NUM_ELEMENTS(aic7xxx_tag_info)) {

1490 if (warned_user == 0) {

1491

1492 printf(KERN_WARNING

1493 "aic7xxx: WARNING: Insufficient tag_info instances\n"

1494 "aic7xxx: for installed controllers. Using defaults\n"

1495 "aic7xxx: Please update the aic7xxx_tag_info array in\n"

1496 "aic7xxx: the aic7xxx_osm..c source file.\n");

1497 warned_user++;

1498 }

1499 tags = AHC_MAX_QUEUE;

1500 } else {

1501 adapter_tag_info_t *tag_info;

1502

1503 tag_info = &aic7xxx_tag_info[ahc->unit];

1504 tags = tag_info->tag_commands[devinfo->target_offset];

1505 if (tags > AHC_MAX_QUEUE)

1506 tags = AHC_MAX_QUEUE;

1507 }

1508 }

1509 return (tags);

1510 }

1511

1512 /*

1513 * Determines the queue depth for a given device.

1514 */

1515 static void

1516 ahc_linux_device_queue_depth(struct ahc_softc *ahc,

1517 struct ahc_linux_device *dev)

1518 {

1519 struct ahc_devinfo devinfo;

1520 u_int tags;

1521

1522 ahc_compile_devinfo(&devinfo,

1523 dev->target->channel == 0

1524 ? ahc->our_id : ahc->our_id_b,

1525 dev->target->target, dev->lun,

1526 dev->target->channel == 0 ? 'A' : 'B',

1527 ROLE_INITIATOR);

1528 tags = ahc_linux_user_tagdepth(ahc, &devinfo);

1529 if (tags != 0

1530 && dev->scsi_device != NULL

1531 && dev->scsi_device->tagged_supported != 0) {

1532

1533 ahc_set_tags(ahc, &devinfo, AHC_QUEUE_TAGGED);

1534 ahc_print_devinfo(ahc, &devinfo);

1535 printf("Tagged Queuing enabled. Depth %d\n", tags);

1536 } else {

1537 ahc_set_tags(ahc, &devinfo, AHC_QUEUE_NONE);

1538 }

1539 }

1540

1541 static int

1542 ahc_linux_run_command(struct ahc_softc *ahc, struct ahc_linux_device *dev,

1543 struct scsi_cmnd *cmd)

1544 {

1545 struct scb *scb;

1546 struct hardware_scb *hscb;

1547 struct ahc_initiator_tinfo *tinfo;

1548 struct ahc_tmode_tstate *tstate;

1549 uint16_t mask;

1550 struct scb_tailq *untagged_q = NULL;

1551

1552 /*

1553 * Schedule us to run later. The only reason we are not

1554 * running is because the whole controller Q is frozen.

1555 */

1556 if (ahc->platform_data->qfrozen != 0)

1557 return SCSI_MLQUEUE_HOST_BUSY;

1558

1559 /*

1560 * We only allow one untagged transaction

1561 * per target in the initiator role unless

1562 * we are storing a full busy target *lun*

1563 * table in SCB space.

1564 */

1565 if (!blk_rq_tagged(cmd->request)

1566 && (ahc->features & AHC_SCB_BTT) == 0) {

1567 int target_offset;

1568

1569 target_offset = cmd->device->id + cmd->device->channel * 8;

1570 untagged_q = &(ahc->untagged_queues[target_offset]);

1571 if (!TAILQ_EMPTY(untagged_q))

1572 /* if we're already executing an untagged command

1573 * we're busy to another */

1574 return SCSI_MLQUEUE_DEVICE_BUSY;

1575 }

1576

1577 /*

1578 * Get an scb to use.

1579 */

1580 if ((scb = ahc_get_scb(ahc)) == NULL) {

1581 ahc->flags |= AHC_RESOURCE_SHORTAGE;

1582 return SCSI_MLQUEUE_HOST_BUSY;

1583 }

1584

1585 scb->io_ctx = cmd;

1586 scb->platform_data->dev = dev;

1587 hscb = scb->hscb;

1588 cmd->host_scribble = (char *)scb;

1589

1590 /*

1591 * Fill out basics of the HSCB.

1592 */

1593 hscb->control = 0;

1594 hscb->scsiid = BUILD_SCSIID(ahc, cmd);

1595 hscb->lun = cmd->device->lun;

1596 mask = SCB_GET_TARGET_MASK(ahc, scb);

1597 tinfo = ahc_fetch_transinfo(ahc, SCB_GET_CHANNEL(ahc, scb),

1598 SCB_GET_OUR_ID(scb),

1599 SCB_GET_TARGET(ahc, scb), &tstate);

1600 hscb->scsirate = tinfo->scsirate;

1601 hscb->scsioffset = tinfo->curr.offset;

1602 if ((tstate->ultraenb & mask) != 0)

1603 hscb->control |= ULTRAENB;

1604

1605 if ((ahc->user_discenable & mask) != 0)

1606 hscb->control |= DISCENB;

1607

1608 if ((tstate->auto_negotiate & mask) != 0) {

1609 scb->flags |= SCB_AUTO_NEGOTIATE;

1610 scb->hscb->control |= MK_MESSAGE;

1611 }

1612

1613 if ((dev->flags & (AHC_DEV_Q_TAGGED|AHC_DEV_Q_BASIC)) != 0) {

1614 int msg_bytes;

1615 uint8_t tag_msgs[2];

1616

1617 msg_bytes = scsi_populate_tag_msg(cmd, tag_msgs);

1618 if (msg_bytes && tag_msgs[0] != MSG_SIMPLE_TASK) {

1619 hscb->control |= tag_msgs[0];

1620 if (tag_msgs[0] == MSG_ORDERED_TASK)

1621 dev->commands_since_idle_or_otag = 0;

1622 } else if (dev->commands_since_idle_or_otag == AHC_OTAG_THRESH

1623 && (dev->flags & AHC_DEV_Q_TAGGED) != 0) {

1624 hscb->control |= MSG_ORDERED_TASK;

1625 dev->commands_since_idle_or_otag = 0;

1626 } else {

1627 hscb->control |= MSG_SIMPLE_TASK;

1628 }

1629 }

1630

1631 hscb->cdb_len = cmd->cmd_len;

1632 if (hscb->cdb_len <= 12) {

1633 memcpy(hscb->shared_data.cdb, cmd->cmnd, hscb->cdb_len);

1634 } else {

1635 memcpy(hscb->cdb32, cmd->cmnd, hscb->cdb_len);

1636 scb->flags |= SCB_CDB32_PTR;

1637 }

1638

1639 scb->platform_data->xfer_len = 0;

1640 ahc_set_residual(scb, 0);

1641 ahc_set_sense_residual(scb, 0);

1642 scb->sg_count = 0;

1643 if (cmd->use_sg != 0) {

1644 struct ahc_dma_seg *sg;

1645 struct scatterlist *cur_seg;

1646 struct scatterlist *end_seg;

1647 int nseg;

1648

1649 cur_seg = (struct scatterlist *)cmd->request_buffer;

1650 nseg = pci_map_sg(ahc->dev_softc, cur_seg, cmd->use_sg,

1651 cmd->sc_data_direction);

1652 end_seg = cur_seg + nseg;

1653 /* Copy the segments into the SG list. */

1654 sg = scb->sg_list;

1655 /*

1656 * The sg_count may be larger than nseg if

1657 * a transfer crosses a 32bit page.

1658 */

1659 while (cur_seg < end_seg) {

1660 dma_addr_t addr;

1661 bus_size_t len;

1662 int consumed;

1663

1664 addr = sg_dma_address(cur_seg);

1665 len = sg_dma_len(cur_seg);

1666 consumed = ahc_linux_map_seg(ahc, scb,

1667 sg, addr, len);

1668 sg += consumed;

1669 scb->sg_count += consumed;

1670 cur_seg++;

1671 }

1672 sg--;

1673 sg->len |= ahc_htole32(AHC_DMA_LAST_SEG);

1674

1675 /*

1676 * Reset the sg list pointer.

1677 */

1678 scb->hscb->sgptr =

1679 ahc_htole32(scb->sg_list_phys | SG_FULL_RESID);

1680

1681 /*

1682 * Copy the first SG into the "current"

1683 * data pointer area.

1684 */

1685 scb->hscb->dataptr = scb->sg_list->addr;

1686 scb->hscb->datacnt = scb->sg_list->len;

1687 } else if (cmd->request_bufflen != 0) {

1688 struct ahc_dma_seg *sg;

1689 dma_addr_t addr;

1690

1691 sg = scb->sg_list;

1692 addr = pci_map_single(ahc->dev_softc,

1693 cmd->request_buffer,

1694 cmd->request_bufflen,

1695 cmd->sc_data_direction);

1696 scb->platform_data->buf_busaddr = addr;

1697 scb->sg_count = ahc_linux_map_seg(ahc, scb,

1698 sg, addr,

1699 cmd->request_bufflen);

1700 sg->len |= ahc_htole32(AHC_DMA_LAST_SEG);

1701

1702 /*

1703 * Reset the sg list pointer.

1704 */

1705 scb->hscb->sgptr =

1706 ahc_htole32(scb->sg_list_phys | SG_FULL_RESID);

1707

1708 /*

1709 * Copy the first SG into the "current"

1710 * data pointer area.

1711 */

1712 scb->hscb->dataptr = sg->addr;

1713 scb->hscb->datacnt = sg->len;

1714 } else {

1715 scb->hscb->sgptr = ahc_htole32(SG_LIST_NULL);

1716 scb->hscb->dataptr = 0;

1717 scb->hscb->datacnt = 0;

1718 scb->sg_count = 0;

1719 }

1720

1721 LIST_INSERT_HEAD(&ahc->pending_scbs, scb, pending_links);

1722 dev->openings--;

1723 dev->active++;

1724 dev->commands_issued++;

1725 if ((dev->flags & AHC_DEV_PERIODIC_OTAG) != 0)

1726 dev->commands_since_idle_or_otag++;

1727

1728 scb->flags |= SCB_ACTIVE;

1729 if (untagged_q) {

1730 TAILQ_INSERT_TAIL(untagged_q, scb, links.tqe);

1731 scb->flags |= SCB_UNTAGGEDQ;

1732 }

1733 ahc_queue_scb(ahc, scb);

1734 return 0;

1735 }

1736

1737 /*

1738 * SCSI controller interrupt handler.

1739 */

1740 irqreturn_t

1741 ahc_linux_isr(int irq, void *dev_id, struct pt_regs * regs)

1742 {

1743 struct ahc_softc *ahc;

1744 u_long flags;

1745 int ours;

1746

1747 ahc = (struct ahc_softc *) dev_id;

1748 ahc_lock(ahc, &flags);

1749 ours = ahc_intr(ahc);

1750 ahc_unlock(ahc, &flags);

1751 return IRQ_RETVAL(ours);

1752 }

1753

1754 void

1755 ahc_platform_flushwork(struct ahc_softc *ahc)

1756 {

1757

1758 }

1759

1760 static struct ahc_linux_target*

1761 ahc_linux_alloc_target(struct ahc_softc *ahc, u_int channel, u_int target)

1762 {

1763 struct ahc_linux_target *targ;

1764 u_int target_offset;

1765

1766 target_offset = target;

1767 if (channel != 0)

1768 target_offset += 8;

1769

1770 targ = malloc(sizeof(*targ), M_DEVBUG, M_NOWAIT);

1771 if (targ == NULL)

1772 return (NULL);

1773 memset(targ, 0, sizeof(*targ));

1774 targ->channel = channel;

1775 targ->target = target;

1776 targ->ahc = ahc;

1777 ahc->platform_data->targets[target_offset] = targ;

1778 return (targ);

1779 }

1780

1781 static void

1782 ahc_linux_free_target(struct ahc_softc *ahc, struct ahc_linux_target *targ)

1783 {

1784 struct ahc_devinfo devinfo;

1785 struct ahc_initiator_tinfo *tinfo;

1786 struct ahc_tmode_tstate *tstate;

1787 u_int our_id;

1788 u_int target_offset;

1789 char channel;

1790

1791 /*

1792 * Force a negotiation to async/narrow on any

1793 * future command to this device unless a bus

1794 * reset occurs between now and that command.

1795 */

1796 channel = 'A' + targ->channel;

1797 our_id = ahc->our_id;

1798 target_offset = targ->target;

1799 if (targ->channel != 0) {

1800 target_offset += 8;

1801 our_id = ahc->our_id_b;

1802 }

1803 tinfo = ahc_fetch_transinfo(ahc, channel, our_id,

1804 targ->target, &tstate);

1805 ahc_compile_devinfo(&devinfo, our_id, targ->target, CAM_LUN_WILDCARD,

1806 channel, ROLE_INITIATOR);

1807 ahc_set_syncrate(ahc, &devinfo, NULL, 0, 0, 0,

1808 AHC_TRANS_GOAL, /*paused*/FALSE);

1809 ahc_set_width(ahc, &devinfo, MSG_EXT_WDTR_BUS_8_BIT,

1810 AHC_TRANS_GOAL, /*paused*/FALSE);

1811 ahc_update_neg_request(ahc, &devinfo, tstate, tinfo, AHC_NEG_ALWAYS);

1812 ahc->platform_data->targets[target_offset] = NULL;

1813 free(targ, M_DEVBUF);

1814 }

1815

1816 static struct ahc_linux_device*

1817 ahc_linux_alloc_device(struct ahc_softc *ahc,

1818 struct ahc_linux_target *targ, u_int lun)

1819 {

1820 struct ahc_linux_device *dev;

1821

1822 dev = malloc(sizeof(*dev), M_DEVBUG, M_NOWAIT);

1823 if (dev == NULL)

1824 return (NULL);

1825 memset(dev, 0, sizeof(*dev));

1826 dev->lun = lun;

1827 dev->target = targ;

1828

1829 /*

1830 * We start out life using untagged

1831 * transactions of which we allow one.

1832 */

1833 dev->openings = 1;

1834

1835 /*

1836 * Set maxtags to 0. This will be changed if we

1837 * later determine that we are dealing with

1838 * a tagged queuing capable device.

1839 */

1840 dev->maxtags = 0;

1841

1842 targ->refcount++;

1843 targ->devices[lun] = dev;

1844 return (dev);

1845 }

1846

1847 static void

1848 ahc_linux_free_device(struct ahc_softc *ahc, struct ahc_linux_device *dev)

1849 {

1850 struct ahc_linux_target *targ;

1851

1852 targ = dev->target;

1853 targ->devices[dev->lun] = NULL;

1854 free(dev, M_DEVBUF);

1855 targ->refcount--;

1856 if (targ->refcount == 0)

1857 ahc_linux_free_target(ahc, targ);

1858 }

1859

1860 void

1861 ahc_send_async(struct ahc_softc *ahc, char channel,

1862 u_int target, u_int lun, ac_code code, void *arg)

1863 {

1864 switch (code) {

1865 case AC_TRANSFER_NEG:

1866 {

1867 char buf[80];

1868 struct ahc_linux_target *targ;

1869 struct info_str info;

1870 struct ahc_initiator_tinfo *tinfo;

1871 struct ahc_tmode_tstate *tstate;

1872 int target_offset;

1873

1874 info.buffer = buf;

1875 info.length = sizeof(buf);

1876 info.offset = 0;

1877 info.pos = 0;

1878 tinfo = ahc_fetch_transinfo(ahc, channel,

1879 channel == 'A' ? ahc->our_id

1880 : ahc->our_id_b,

1881 target, &tstate);

1882

1883 /*

1884 * Don't bother reporting results while

1885 * negotiations are still pending.

1886 */

1887 if (tinfo->curr.period != tinfo->goal.period

1888 || tinfo->curr.width != tinfo->goal.width

1889 || tinfo->curr.offset != tinfo->goal.offset

1890 || tinfo->curr.ppr_options != tinfo->goal.ppr_options)

1891 if (bootverbose == 0)

1892 break;

1893

1894 /*

1895 * Don't bother reporting results that

1896 * are identical to those last reported.

1897 */

1898 target_offset = target;

1899 if (channel == 'B')

1900 target_offset += 8;

1901 targ = ahc->platform_data->targets[target_offset];

1902 if (targ == NULL)

1903 break;

1904 if (tinfo->curr.period == targ->last_tinfo.period

1905 && tinfo->curr.width == targ->last_tinfo.width

1906 && tinfo->curr.offset == targ->last_tinfo.offset

1907 && tinfo->curr.ppr_options == targ->last_tinfo.ppr_options)

1908 if (bootverbose == 0)

1909 break;

1910

1911 targ->last_tinfo.period = tinfo->curr.period;

1912 targ->last_tinfo.width = tinfo->curr.width;

1913 targ->last_tinfo.offset = tinfo->curr.offset;

1914 targ->last_tinfo.ppr_options = tinfo->curr.ppr_options;

1915

1916 printf("(%s:%c:", ahc_name(ahc), channel);

1917 if (target == CAM_TARGET_WILDCARD)

1918 printf("*): ");

1919 else

1920 printf("%d): ", target);

1921 ahc_format_transinfo(&info, &tinfo->curr);

1922 if (info.pos < info.length)

1923 *info.buffer = '\0';

1924 else

1925 buf[info.length - 1] = '\0';

1926 printf("%s", buf);

1927 break;

1928 }

1929 case AC_SENT_BDR:

1930 {

1931 WARN_ON(lun != CAM_LUN_WILDCARD);

1932 scsi_report_device_reset(ahc->platform_data->host,

1933 channel - 'A', target);

1934 break;

1935 }

1936 case AC_BUS_RESET:

1937 if (ahc->platform_data->host != NULL) {

1938 scsi_report_bus_reset(ahc->platform_data->host,

1939 channel - 'A');

1940 }

1941 break;

1942 default:

1943 panic("ahc_send_async: Unexpected async event");

1944 }

1945 }

1946

1947 /*

1948 * Calls the higher level scsi done function and frees the scb.

1949 */

1950 void

1951 ahc_done(struct ahc_softc *ahc, struct scb *scb)

1952 {

1953 struct scsi_cmnd *cmd;

1954 struct ahc_linux_device *dev;

1955

1956 LIST_REMOVE(scb, pending_links);

1957 if ((scb->flags & SCB_UNTAGGEDQ) != 0) {

1958 struct scb_tailq *untagged_q;

1959 int target_offset;

1960

1961 target_offset = SCB_GET_TARGET_OFFSET(ahc, scb);

1962 untagged_q = &(ahc->untagged_queues[target_offset]);

1963 TAILQ_REMOVE(untagged_q, scb, links.tqe);

1964 BUG_ON(!TAILQ_EMPTY(untagged_q));

1965 }

1966

1967 if ((scb->flags & SCB_ACTIVE) == 0) {

1968 printf("SCB %d done'd twice\n", scb->hscb->tag);

1969 ahc_dump_card_state(ahc);

1970 panic("Stopping for safety");

1971 }

1972 cmd = scb->io_ctx;

1973 dev = scb->platform_data->dev;

1974 dev->active--;

1975 dev->openings++;

1976 if ((cmd->result & (CAM_DEV_QFRZN << 16)) != 0) {

1977 cmd->result &= ~(CAM_DEV_QFRZN << 16);

1978 dev->qfrozen--;

1979 }

1980 ahc_linux_unmap_scb(ahc, scb);

1981

1982 /*

1983 * Guard against stale sense data.

1984 * The Linux mid-layer assumes that sense

1985 * was retrieved anytime the first byte of

1986 * the sense buffer looks "sane".

1987 */

1988 cmd->sense_buffer[0] = 0;

1989 if (ahc_get_transaction_status(scb) == CAM_REQ_INPROG) {

1990 uint32_t amount_xferred;

1991

1992 amount_xferred =

1993 ahc_get_transfer_length(scb) - ahc_get_residual(scb);

1994 if ((scb->flags & SCB_TRANSMISSION_ERROR) != 0) {

1995 #ifdef AHC_DEBUG

1996 if ((ahc_debug & AHC_SHOW_MISC) != 0) {

1997 ahc_print_path(ahc, scb);

1998 printf("Set CAM_UNCOR_PARITY\n");

1999 }

2000 #endif

2001 ahc_set_transaction_status(scb, CAM_UNCOR_PARITY);

2002 #ifdef AHC_REPORT_UNDERFLOWS

2003 /*

2004 * This code is disabled by default as some

2005 * clients of the SCSI system do not properly

2006 * initialize the underflow parameter. This

2007 * results in spurious termination of commands

2008 * that complete as expected (e.g. underflow is

2009 * allowed as command can return variable amounts

2010 * of data.

2011 */

2012 } else if (amount_xferred < scb->io_ctx->underflow) {

2013 u_int i;

2014

2015 ahc_print_path(ahc, scb);

2016 printf("CDB:");

2017 for (i = 0; i < scb->io_ctx->cmd_len; i++)

2018 printf(" 0x%x", scb->io_ctx->cmnd[i]);

2019 printf("\n");

2020 ahc_print_path(ahc, scb);

2021 printf("Saw underflow (%ld of %ld bytes). "

2022 "Treated as error\n",

2023 ahc_get_residual(scb),

2024 ahc_get_transfer_length(scb));

2025 ahc_set_transaction_status(scb, CAM_DATA_RUN_ERR);

2026 #endif

2027 } else {

2028 ahc_set_transaction_status(scb, CAM_REQ_CMP);

2029 }

2030 } else if (ahc_get_transaction_status(scb) == CAM_SCSI_STATUS_ERROR) {

2031 ahc_linux_handle_scsi_status(ahc, dev, scb);

2032 }

2033

2034 if (dev->openings == 1

2035 && ahc_get_transaction_status(scb) == CAM_REQ_CMP

2036 && ahc_get_scsi_status(scb) != SCSI_STATUS_QUEUE_FULL)

2037 dev->tag_success_count++;

2038 /*

2039 * Some devices deal with temporary internal resource

2040 * shortages by returning queue full. When the queue

2041 * full occurrs, we throttle back. Slowly try to get

2042 * back to our previous queue depth.

2043 */

2044 if ((dev->openings + dev->active) < dev->maxtags

2045 && dev->tag_success_count > AHC_TAG_SUCCESS_INTERVAL) {

2046 dev->tag_success_count = 0;

2047 dev->openings++;

2048 }

2049

2050 if (dev->active == 0)

2051 dev->commands_since_idle_or_otag = 0;

2052

2053 if ((scb->flags & SCB_RECOVERY_SCB) != 0) {

2054 printf("Recovery SCB completes\n");

2055 if (ahc_get_transaction_status(scb) == CAM_BDR_SENT

2056 || ahc_get_transaction_status(scb) == CAM_REQ_ABORTED)

2057 ahc_set_transaction_status(scb, CAM_CMD_TIMEOUT);

2058 if ((ahc->platform_data->flags & AHC_UP_EH_SEMAPHORE) != 0) {

2059 ahc->platform_data->flags &= ~AHC_UP_EH_SEMAPHORE;

2060 up(&ahc->platform_data->eh_sem);

2061 }

2062 }

2063

2064 ahc_free_scb(ahc, scb);

2065 ahc_linux_queue_cmd_complete(ahc, cmd);

2066 }

2067

2068 static void

2069 ahc_linux_handle_scsi_status(struct ahc_softc *ahc,

2070 struct ahc_linux_device *dev, struct scb *scb)

2071 {

2072 struct ahc_devinfo devinfo;

2073

2074 ahc_compile_devinfo(&devinfo,

2075 ahc->our_id,

2076 dev->target->target, dev->lun,

2077 dev->target->channel == 0 ? 'A' : 'B',

2078 ROLE_INITIATOR);

2079

2080 /*

2081 * We don't currently trust the mid-layer to

2082 * properly deal with queue full or busy. So,

2083 * when one occurs, we tell the mid-layer to

2084 * unconditionally requeue the command to us

2085 * so that we can retry it ourselves. We also

2086 * implement our own throttling mechanism so

2087 * we don't clobber the device with too many

2088 * commands.

2089 */

2090 switch (ahc_get_scsi_status(scb)) {

2091 default:

2092 break;

2093 case SCSI_STATUS_CHECK_COND:

2094 case SCSI_STATUS_CMD_TERMINATED:

2095 {

2096 struct scsi_cmnd *cmd;

2097

2098 /*

2099 * Copy sense information to the OS's cmd

2100 * structure if it is available.

2101 */

2102 cmd = scb->io_ctx;

2103 if (scb->flags & SCB_SENSE) {

2104 u_int sense_size;

2105

2106 sense_size = MIN(sizeof(struct scsi_sense_data)

2107 - ahc_get_sense_residual(scb),

2108 sizeof(cmd->sense_buffer));

2109 memcpy(cmd->sense_buffer,

2110 ahc_get_sense_buf(ahc, scb), sense_size);

2111 if (sense_size < sizeof(cmd->sense_buffer))

2112 memset(&cmd->sense_buffer[sense_size], 0,

2113 sizeof(cmd->sense_buffer) - sense_size);

2114 cmd->result |= (DRIVER_SENSE << 24);

2115 #ifdef AHC_DEBUG

2116 if (ahc_debug & AHC_SHOW_SENSE) {

2117 int i;

2118

2119 printf("Copied %d bytes of sense data:",

2120 sense_size);

2121 for (i = 0; i < sense_size; i++) {

2122 if ((i & 0xF) == 0)

2123 printf("\n");

2124 printf("0x%x ", cmd->sense_buffer[i]);

2125 }

2126 printf("\n");

2127 }

2128 #endif

2129 }

2130 break;

2131 }

2132 case SCSI_STATUS_QUEUE_FULL:

2133 {

2134 /*

2135 * By the time the core driver has returned this

2136 * command, all other commands that were queued

2137 * to us but not the device have been returned.

2138 * This ensures that dev->active is equal to

2139 * the number of commands actually queued to

2140 * the device.

2141 */

2142 dev->tag_success_count = 0;

2143 if (dev->active != 0) {

2144 /*

2145 * Drop our opening count to the number

2146 * of commands currently outstanding.

2147 */

2148 dev->openings = 0;

2149 /*

2150 ahc_print_path(ahc, scb);

2151 printf("Dropping tag count to %d\n", dev->active);

2152 */

2153 if (dev->active == dev->tags_on_last_queuefull) {

2154

2155 dev->last_queuefull_same_count++;

2156 /*

2157 * If we repeatedly see a queue full

2158 * at the same queue depth, this

2159 * device has a fixed number of tag

2160 * slots. Lock in this tag depth

2161 * so we stop seeing queue fulls from

2162 * this device.

2163 */

2164 if (dev->last_queuefull_same_count

2165 == AHC_LOCK_TAGS_COUNT) {

2166 dev->maxtags = dev->active;

2167 ahc_print_path(ahc, scb);

2168 printf("Locking max tag count at %d\n",

2169 dev->active);

2170 }

2171 } else {

2172 dev->tags_on_last_queuefull = dev->active;

2173 dev->last_queuefull_same_count = 0;

2174 }

2175 ahc_set_transaction_status(scb, CAM_REQUEUE_REQ);

2176 ahc_set_scsi_status(scb, SCSI_STATUS_OK);

2177 ahc_platform_set_tags(ahc, &devinfo,

2178 (dev->flags & AHC_DEV_Q_BASIC)

2179 ? AHC_QUEUE_BASIC : AHC_QUEUE_TAGGED);

2180 break;

2181 }

2182 /*

2183 * Drop down to a single opening, and treat this

2184 * as if the target returned BUSY SCSI status.

2185 */

2186 dev->openings = 1;

2187 ahc_set_scsi_status(scb, SCSI_STATUS_BUSY);

2188 ahc_platform_set_tags(ahc, &devinfo,

2189 (dev->flags & AHC_DEV_Q_BASIC)

2190 ? AHC_QUEUE_BASIC : AHC_QUEUE_TAGGED);

2191 break;

2192 }

2193 }

2194 }

2195

2196 static void

2197 ahc_linux_queue_cmd_complete(struct ahc_softc *ahc, struct scsi_cmnd *cmd)

2198 {

2199 /*

2200 * Map CAM error codes into Linux Error codes. We

2201 * avoid the conversion so that the DV code has the

2202 * full error information available when making

2203 * state change decisions.

2204 */

2205 {

2206 u_int new_status;

2207

2208 switch (ahc_cmd_get_transaction_status(cmd)) {

2209 case CAM_REQ_INPROG:

2210 case CAM_REQ_CMP:

2211 case CAM_SCSI_STATUS_ERROR:

2212 new_status = DID_OK;

2213 break;

2214 case CAM_REQ_ABORTED:

2215 new_status = DID_ABORT;

2216 break;

2217 case CAM_BUSY:

2218 new_status = DID_BUS_BUSY;

2219 break;

2220 case CAM_REQ_INVALID:

2221 case CAM_PATH_INVALID:

2222 new_status = DID_BAD_TARGET;

2223 break;

2224 case CAM_SEL_TIMEOUT:

2225 new_status = DID_NO_CONNECT;

2226 break;

2227 case CAM_SCSI_BUS_RESET:

2228 case CAM_BDR_SENT:

2229 new_status = DID_RESET;

2230 break;

2231 case CAM_UNCOR_PARITY:

2232 new_status = DID_PARITY;

2233 break;

2234 case CAM_CMD_TIMEOUT:

2235 new_status = DID_TIME_OUT;

2236 break;

2237 case CAM_UA_ABORT:

2238 case CAM_REQ_CMP_ERR:

2239 case CAM_AUTOSENSE_FAIL:

2240 case CAM_NO_HBA:

2241 case CAM_DATA_RUN_ERR:

2242 case CAM_UNEXP_BUSFREE:

2243 case CAM_SEQUENCE_FAIL:

2244 case CAM_CCB_LEN_ERR:

2245 case CAM_PROVIDE_FAIL:

2246 case CAM_REQ_TERMIO:

2247 case CAM_UNREC_HBA_ERROR:

2248 case CAM_REQ_TOO_BIG:

2249 new_status = DID_ERROR;

2250 break;

2251 case CAM_REQUEUE_REQ:

2252 new_status = DID_REQUEUE;

2253 break;

2254 default:

2255 /* We should never get here */

2256 new_status = DID_ERROR;

2257 break;

2258 }

2259

2260 ahc_cmd_set_transaction_status(cmd, new_status);

2261 }

2262

2263 cmd->scsi_done(cmd);

2264 }

2265

2266 static void

2267 ahc_linux_sem_timeout(u_long arg)

2268 {

2269 struct ahc_softc *ahc;

2270 u_long s;

2271

2272 ahc = (struct ahc_softc *)arg;

2273

2274 ahc_lock(ahc, &s);

2275 if ((ahc->platform_data->flags & AHC_UP_EH_SEMAPHORE) != 0) {

2276 ahc->platform_data->flags &= ~AHC_UP_EH_SEMAPHORE;

2277 up(&ahc->platform_data->eh_sem);

2278 }

2279 ahc_unlock(ahc, &s);

2280 }

2281

2282 static void

2283 ahc_linux_freeze_simq(struct ahc_softc *ahc)

2284 {

2285 ahc->platform_data->qfrozen++;

2286 if (ahc->platform_data->qfrozen == 1) {

2287 scsi_block_requests(ahc->platform_data->host);

2288

2289 /* XXX What about Twin channels? */

2290 ahc_platform_abort_scbs(ahc, CAM_TARGET_WILDCARD, ALL_CHANNELS,

2291 CAM_LUN_WILDCARD, SCB_LIST_NULL,

2292 ROLE_INITIATOR, CAM_REQUEUE_REQ);

2293 }

2294 }

2295

2296 static void

2297 ahc_linux_release_simq(u_long arg)

2298 {

2299 struct ahc_softc *ahc;

2300 u_long s;

2301 int unblock_reqs;

2302

2303 ahc = (struct ahc_softc *)arg;

2304

2305 unblock_reqs = 0;

2306 ahc_lock(ahc, &s);

2307 if (ahc->platform_data->qfrozen > 0)

2308 ahc->platform_data->qfrozen--;

2309 if (ahc->platform_data->qfrozen == 0)

2310 unblock_reqs = 1;

2311 ahc_unlock(ahc, &s);

2312 /*

2313 * There is still a race here. The mid-layer

2314 * should keep its own freeze count and use

2315 * a bottom half handler to run the queues

2316 * so we can unblock with our own lock held.

2317 */

2318 if (unblock_reqs)

2319 scsi_unblock_requests(ahc->platform_data->host);

2320 }

2321

2322 static int

2323 ahc_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag)

2324 {

2325 struct ahc_softc *ahc;

2326 struct ahc_linux_device *dev;

2327 struct scb *pending_scb;

2328 u_int saved_scbptr;

2329 u_int active_scb_index;

2330 u_int last_phase;

2331 u_int saved_scsiid;

2332 u_int cdb_byte;

2333 int retval;

2334 int was_paused;

2335 int paused;

2336 int wait;

2337 int disconnected;

2338

2339 pending_scb = NULL;

2340 paused = FALSE;

2341 wait = FALSE;

2342 ahc = *(struct ahc_softc **)cmd->device->host->hostdata;

2343

2344 printf("%s:%d:%d:%d: Attempting to queue a%s message\n",

2345 ahc_name(ahc), cmd->device->channel,

2346 cmd->device->id, cmd->device->lun,

2347 flag == SCB_ABORT ? "n ABORT" : " TARGET RESET");

2348

2349 printf("CDB:");

2350 for (cdb_byte = 0; cdb_byte < cmd->cmd_len; cdb_byte++)

2351 printf(" 0x%x", cmd->cmnd[cdb_byte]);

2352 printf("\n");

2353

2354 /*

2355 * First determine if we currently own this command.

2356 * Start by searching the device queue. If not found

2357 * there, check the pending_scb list. If not found

2358 * at all, and the system wanted us to just abort the

2359 * command, return success.

2360 */

2361 dev = ahc_linux_get_device(ahc, cmd->device->channel, cmd->device->id,

2362 cmd->device->lun);

2363

2364 if (dev == NULL) {

2365 /*

2366 * No target device for this command exists,

2367 * so we must not still own the command.

2368 */

2369 printf("%s:%d:%d:%d: Is not an active device\n",

2370 ahc_name(ahc), cmd->device->channel, cmd->device->id,

2371 cmd->device->lun);

2372 retval = SUCCESS;

2373 goto no_cmd;

2374 }

2375

2376 if ((dev->flags & (AHC_DEV_Q_BASIC|AHC_DEV_Q_TAGGED)) == 0

2377 && ahc_search_untagged_queues(ahc, cmd, cmd->device->id,

2378 cmd->device->channel + 'A',

2379 cmd->device->lun,

2380 CAM_REQ_ABORTED, SEARCH_COMPLETE) != 0) {

2381 printf("%s:%d:%d:%d: Command found on untagged queue\n",

2382 ahc_name(ahc), cmd->device->channel, cmd->device->id,

2383 cmd->device->lun);

2384 retval = SUCCESS;

2385 goto done;

2386 }

2387

2388 /*

2389 * See if we can find a matching cmd in the pending list.

2390 */

2391 LIST_FOREACH(pending_scb, &ahc->pending_scbs, pending_links) {

2392 if (pending_scb->io_ctx == cmd)

2393 break;

2394 }

2395

2396 if (pending_scb == NULL && flag == SCB_DEVICE_RESET) {

2397

2398 /* Any SCB for this device will do for a target reset */

2399 LIST_FOREACH(pending_scb, &ahc->pending_scbs, pending_links) {

2400 if (ahc_match_scb(ahc, pending_scb, cmd->device->id,

2401 cmd->device->channel + 'A',

2402 CAM_LUN_WILDCARD,

2403 SCB_LIST_NULL, ROLE_INITIATOR) == 0)

2404 break;

2405 }

2406 }

2407

2408 if (pending_scb == NULL) {

2409 printf("%s:%d:%d:%d: Command not found\n",

2410 ahc_name(ahc), cmd->device->channel, cmd->device->id,

2411 cmd->device->lun);

2412 goto no_cmd;

2413 }

2414

2415 if ((pending_scb->flags & SCB_RECOVERY_SCB) != 0) {

2416 /*

2417 * We can't queue two recovery actions using the same SCB

2418 */

2419 retval = FAILED;

2420 goto done;

2421 }

2422

2423 /*

2424 * Ensure that the card doesn't do anything

2425 * behind our back and that we didn't "just" miss

2426 * an interrupt that would affect this cmd.

2427 */

2428 was_paused = ahc_is_paused(ahc);

2429 ahc_pause_and_flushwork(ahc);

2430 paused = TRUE;

2431

2432 if ((pending_scb->flags & SCB_ACTIVE) == 0) {

2433 printf("%s:%d:%d:%d: Command already completed\n",

2434 ahc_name(ahc), cmd->device->channel, cmd->device->id,

2435 cmd->device->lun);

2436 goto no_cmd;

2437 }

2438

2439 printf("%s: At time of recovery, card was %spaused\n",

2440 ahc_name(ahc), was_paused ? "" : "not ");

2441 ahc_dump_card_state(ahc);

2442

2443 disconnected = TRUE;

2444 if (flag == SCB_ABORT) {

2445 if (ahc_search_qinfifo(ahc, cmd->device->id,

2446 cmd->device->channel + 'A',

2447 cmd->device->lun,

2448 pending_scb->hscb->tag,

2449 ROLE_INITIATOR, CAM_REQ_ABORTED,

2450 SEARCH_COMPLETE) > 0) {

2451 printf("%s:%d:%d:%d: Cmd aborted from QINFIFO\n",

2452 ahc_name(ahc), cmd->device->channel,

2453 cmd->device->id, cmd->device->lun);

2454 retval = SUCCESS;

2455 goto done;

2456 }

2457 } else if (ahc_search_qinfifo(ahc, cmd->device->id,

2458 cmd->device->channel + 'A',

2459 cmd->device->lun, pending_scb->hscb->tag,

2460 ROLE_INITIATOR, /*status*/0,

2461 SEARCH_COUNT) > 0) {

2462 disconnected = FALSE;

2463 }

2464

2465 if (disconnected && (ahc_inb(ahc, SEQ_FLAGS) & NOT_IDENTIFIED) == 0) {

2466 struct scb *bus_scb;

2467

2468 bus_scb = ahc_lookup_scb(ahc, ahc_inb(ahc, SCB_TAG));

2469 if (bus_scb == pending_scb)

2470 disconnected = FALSE;

2471 else if (flag != SCB_ABORT

2472 && ahc_inb(ahc, SAVED_SCSIID) == pending_scb->hscb->scsiid

2473 && ahc_inb(ahc, SAVED_LUN) == SCB_GET_LUN(pending_scb))

2474 disconnected = FALSE;

2475 }

2476

2477 /*

2478 * At this point, pending_scb is the scb associated with the

2479 * passed in command. That command is currently active on the

2480 * bus, is in the disconnected state, or we're hoping to find

2481 * a command for the same target active on the bus to abuse to

2482 * send a BDR. Queue the appropriate message based on which of

2483 * these states we are in.

2484 */

2485 last_phase = ahc_inb(ahc, LASTPHASE);

2486 saved_scbptr = ahc_inb(ahc, SCBPTR);

2487 active_scb_index = ahc_inb(ahc, SCB_TAG);

2488 saved_scsiid = ahc_inb(ahc, SAVED_SCSIID);

2489 if (last_phase != P_BUSFREE

2490 && (pending_scb->hscb->tag == active_scb_index

2491 || (flag == SCB_DEVICE_RESET

2492 && SCSIID_TARGET(ahc, saved_scsiid) == cmd->device->id))) {

2493

2494 /*

2495 * We're active on the bus, so assert ATN

2496 * and hope that the target responds.

2497 */

2498 pending_scb = ahc_lookup_scb(ahc, active_scb_index);

2499 pending_scb->flags |= SCB_RECOVERY_SCB|flag;

2500 ahc_outb(ahc, MSG_OUT, HOST_MSG);

2501 ahc_outb(ahc, SCSISIGO, last_phase|ATNO);

2502 printf("%s:%d:%d:%d: Device is active, asserting ATN\n",

2503 ahc_name(ahc), cmd->device->channel, cmd->device->id,

2504 cmd->device->lun);

2505 wait = TRUE;

2506 } else if (disconnected) {

2507

2508 /*

2509 * Actually re-queue this SCB in an attempt

2510 * to select the device before it reconnects.

2511 * In either case (selection or reselection),

2512 * we will now issue the approprate message

2513 * to the timed-out device.

2514 *

2515 * Set the MK_MESSAGE control bit indicating

2516 * that we desire to send a message. We

2517 * also set the disconnected flag since

2518 * in the paging case there is no guarantee

2519 * that our SCB control byte matches the

2520 * version on the card. We don't want the

2521 * sequencer to abort the command thinking

2522 * an unsolicited reselection occurred.

2523 */

2524 pending_scb->hscb->control |= MK_MESSAGE|DISCONNECTED;

2525 pending_scb->flags |= SCB_RECOVERY_SCB|flag;

2526

2527 /*

2528 * Remove any cached copy of this SCB in the

2529 * disconnected list in preparation for the

2530 * queuing of our abort SCB. We use the

2531 * same element in the SCB, SCB_NEXT, for

2532 * both the qinfifo and the disconnected list.

2533 */

2534 ahc_search_disc_list(ahc, cmd->device->id,

2535 cmd->device->channel + 'A',

2536 cmd->device->lun, pending_scb->hscb->tag,

2537 /*stop_on_first*/TRUE,

2538 /*remove*/TRUE,

2539 /*save_state*/FALSE);

2540

2541 /*

2542 * In the non-paging case, the sequencer will

2543 * never re-reference the in-core SCB.

2544 * To make sure we are notified during

2545 * reslection, set the MK_MESSAGE flag in

2546 * the card's copy of the SCB.

2547 */

2548 if ((ahc->flags & AHC_PAGESCBS) == 0) {

2549 ahc_outb(ahc, SCBPTR, pending_scb->hscb->tag);

2550 ahc_outb(ahc, SCB_CONTROL,

2551 ahc_inb(ahc, SCB_CONTROL)|MK_MESSAGE);

2552 }

2553

2554 /*

2555 * Clear out any entries in the QINFIFO first

2556 * so we are the next SCB for this target

2557 * to run.

2558 */

2559 ahc_search_qinfifo(ahc, cmd->device->id,

2560 cmd->device->channel + 'A',

2561 cmd->device->lun, SCB_LIST_NULL,

2562 ROLE_INITIATOR, CAM_REQUEUE_REQ,

2563 SEARCH_COMPLETE);

2564 ahc_qinfifo_requeue_tail(ahc, pending_scb);

2565 ahc_outb(ahc, SCBPTR, saved_scbptr);

2566 ahc_print_path(ahc, pending_scb);

2567 printf("Device is disconnected, re-queuing SCB\n");

2568 wait = TRUE;

2569 } else {

2570 printf("%s:%d:%d:%d: Unable to deliver message\n",

2571 ahc_name(ahc), cmd->device->channel, cmd->device->id,

2572 cmd->device->lun);

2573 retval = FAILED;

2574 goto done;

2575 }

2576

2577 no_cmd:

2578 /*

2579 * Our assumption is that if we don't have the command, no

2580 * recovery action was required, so we return success. Again,

2581 * the semantics of the mid-layer recovery engine are not

2582 * well defined, so this may change in time.

2583 */

2584 retval = SUCCESS;

2585 done:

2586 if (paused)

2587 ahc_unpause(ahc);

2588 if (wait) {

2589 struct timer_list timer;

2590 int ret;

2591

2592 ahc->platform_data->flags |= AHC_UP_EH_SEMAPHORE;

2593 spin_unlock_irq(&ahc->platform_data->spin_lock);

2594 init_timer(&timer);

2595 timer.data = (u_long)ahc;

2596 timer.expires = jiffies + (5 * HZ);

2597 timer.function = ahc_linux_sem_timeout;

2598 add_timer(&timer);

2599 printf("Recovery code sleeping\n");

2600 down(&ahc->platform_data->eh_sem);

2601 printf("Recovery code awake\n");

2602 ret = del_timer_sync(&timer);

2603 if (ret == 0) {

2604 printf("Timer Expired\n");

2605 retval = FAILED;

2606 }

2607 spin_lock_irq(&ahc->platform_data->spin_lock);

2608 }

2609 return (retval);

2610 }

2611

2612 void

2613 ahc_platform_dump_card_state(struct ahc_softc *ahc)

2614 {

2615 }

2616

2617 static void ahc_linux_exit(void);

2618

2619 static void ahc_linux_get_width(struct scsi_target *starget)

2620 {

2621 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

2622 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

2623 struct ahc_tmode_tstate *tstate;

2624 struct ahc_initiator_tinfo *tinfo

2625 = ahc_fetch_transinfo(ahc,

2626 starget->channel + 'A',

2627 shost->this_id, starget->id, &tstate);

2628 spi_width(starget) = tinfo->curr.width;

2629 }

2630

2631 static void ahc_linux_set_width(struct scsi_target *starget, int width)

2632 {

2633 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

2634 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

2635 struct ahc_devinfo devinfo;

2636 unsigned long flags;

2637

2638 ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,

2639 starget->channel + 'A', ROLE_INITIATOR);

2640 ahc_lock(ahc, &flags);

2641 ahc_set_width(ahc, &devinfo, width, AHC_TRANS_GOAL, FALSE);

2642 ahc_unlock(ahc, &flags);

2643 }

2644

2645 static void ahc_linux_get_period(struct scsi_target *starget)

2646 {

2647 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

2648 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

2649 struct ahc_tmode_tstate *tstate;

2650 struct ahc_initiator_tinfo *tinfo

2651 = ahc_fetch_transinfo(ahc,

2652 starget->channel + 'A',

2653 shost->this_id, starget->id, &tstate);

2654 spi_period(starget) = tinfo->curr.period;

2655 }

2656

2657 static void ahc_linux_set_period(struct scsi_target *starget, int period)

2658 {

2659 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

2660 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

2661 struct ahc_tmode_tstate *tstate;

2662 struct ahc_initiator_tinfo *tinfo

2663 = ahc_fetch_transinfo(ahc,

2664 starget->channel + 'A',

2665 shost->this_id, starget->id, &tstate);

2666 struct ahc_devinfo devinfo;

2667 unsigned int ppr_options = tinfo->curr.ppr_options;

2668 unsigned long flags;

2669 unsigned long offset = tinfo->curr.offset;

2670 struct ahc_syncrate *syncrate;

2671

2672 if (offset == 0)

2673 offset = MAX_OFFSET;

2674

2675 ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,

2676 starget->channel + 'A', ROLE_INITIATOR);

2677

2678 /* all PPR requests apart from QAS require wide transfers */

2679 if (ppr_options & ~MSG_EXT_PPR_QAS_REQ) {

2680 ahc_linux_get_width(starget);

2681 if (spi_width(starget) == 0)

2682 ppr_options &= MSG_EXT_PPR_QAS_REQ;

2683 }

2684

2685 syncrate = ahc_find_syncrate(ahc, &period, &ppr_options, AHC_SYNCRATE_DT);

2686 ahc_lock(ahc, &flags);

2687 ahc_set_syncrate(ahc, &devinfo, syncrate, period, offset,

2688 ppr_options, AHC_TRANS_GOAL, FALSE);

2689 ahc_unlock(ahc, &flags);

2690 }

2691

2692 static void ahc_linux_get_offset(struct scsi_target *starget)

2693 {

2694 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

2695 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

2696 struct ahc_tmode_tstate *tstate;

2697 struct ahc_initiator_tinfo *tinfo

2698 = ahc_fetch_transinfo(ahc,

2699 starget->channel + 'A',

2700 shost->this_id, starget->id, &tstate);

2701 spi_offset(starget) = tinfo->curr.offset;

2702 }

2703

2704 static void ahc_linux_set_offset(struct scsi_target *starget, int offset)

2705 {

2706 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

2707 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

2708 struct ahc_tmode_tstate *tstate;

2709 struct ahc_initiator_tinfo *tinfo

2710 = ahc_fetch_transinfo(ahc,

2711 starget->channel + 'A',

2712 shost->this_id, starget->id, &tstate);

2713 struct ahc_devinfo devinfo;

2714 unsigned int ppr_options = 0;

2715 unsigned int period = 0;

2716 unsigned long flags;

2717 struct ahc_syncrate *syncrate = NULL;

2718

2719 ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,

2720 starget->channel + 'A', ROLE_INITIATOR);

2721 if (offset != 0) {

2722 syncrate = ahc_find_syncrate(ahc, &period, &ppr_options, AHC_SYNCRATE_DT);

2723 period = tinfo->curr.period;

2724 ppr_options = tinfo->curr.ppr_options;

2725 }

2726 ahc_lock(ahc, &flags);

2727 ahc_set_syncrate(ahc, &devinfo, syncrate, period, offset,

2728 ppr_options, AHC_TRANS_GOAL, FALSE);

2729 ahc_unlock(ahc, &flags);

2730 }

2731

2732 static void ahc_linux_get_dt(struct scsi_target *starget)

2733 {

2734 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

2735 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

2736 struct ahc_tmode_tstate *tstate;

2737 struct ahc_initiator_tinfo *tinfo

2738 = ahc_fetch_transinfo(ahc,

2739 starget->channel + 'A',

2740 shost->this_id, starget->id, &tstate);

2741 spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_DT_REQ;

2742 }

2743

2744 static void ahc_linux_set_dt(struct scsi_target *starget, int dt)

2745 {

2746 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

2747 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

2748 struct ahc_tmode_tstate *tstate;

2749 struct ahc_initiator_tinfo *tinfo

2750 = ahc_fetch_transinfo(ahc,

2751 starget->channel + 'A',

2752 shost->this_id, starget->id, &tstate);

2753 struct ahc_devinfo devinfo;

2754 unsigned int ppr_options = tinfo->curr.ppr_options

2755 & ~MSG_EXT_PPR_DT_REQ;

2756 unsigned int period = tinfo->curr.period;

2757 unsigned long flags;

2758 struct ahc_syncrate *syncrate;

2759

2760 ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,

2761 starget->channel + 'A', ROLE_INITIATOR);

2762 syncrate = ahc_find_syncrate(ahc, &period, &ppr_options,AHC_SYNCRATE_DT);

2763 ahc_lock(ahc, &flags);

2764 ahc_set_syncrate(ahc, &devinfo, syncrate, period, tinfo->curr.offset,

2765 ppr_options, AHC_TRANS_GOAL, FALSE);

2766 ahc_unlock(ahc, &flags);

2767 }

2768

2769 static void ahc_linux_get_qas(struct scsi_target *starget)

2770 {

2771 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

2772 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

2773 struct ahc_tmode_tstate *tstate;

2774 struct ahc_initiator_tinfo *tinfo

2775 = ahc_fetch_transinfo(ahc,

2776 starget->channel + 'A',

2777 shost->this_id, starget->id, &tstate);

2778 spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_QAS_REQ;

2779 }

2780

2781 static void ahc_linux_set_qas(struct scsi_target *starget, int qas)

2782 {

2783 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

2784 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

2785 struct ahc_tmode_tstate *tstate;

2786 struct ahc_initiator_tinfo *tinfo

2787 = ahc_fetch_transinfo(ahc,

2788 starget->channel + 'A',

2789 shost->this_id, starget->id, &tstate);

2790 struct ahc_devinfo devinfo;

2791 unsigned int ppr_options = tinfo->curr.ppr_options

2792 & ~MSG_EXT_PPR_QAS_REQ;

2793 unsigned int period = tinfo->curr.period;

2794 unsigned long flags;

2795 struct ahc_syncrate *syncrate;

2796

2797 if (qas)

2798 ppr_options |= MSG_EXT_PPR_QAS_REQ;

2799

2800 ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,

2801 starget->channel + 'A', ROLE_INITIATOR);

2802 syncrate = ahc_find_syncrate(ahc, &period, &ppr_options, AHC_SYNCRATE_DT);

2803 ahc_lock(ahc, &flags);

2804 ahc_set_syncrate(ahc, &devinfo, syncrate, period, tinfo->curr.offset,

2805 ppr_options, AHC_TRANS_GOAL, FALSE);

2806 ahc_unlock(ahc, &flags);

2807 }

2808

2809 static void ahc_linux_get_iu(struct scsi_target *starget)

2810 {

2811 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

2812 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

2813 struct ahc_tmode_tstate *tstate;

2814 struct ahc_initiator_tinfo *tinfo

2815 = ahc_fetch_transinfo(ahc,

2816 starget->channel + 'A',

2817 shost->this_id, starget->id, &tstate);

2818 spi_dt(starget) = tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ;

2819 }

2820

2821 static void ahc_linux_set_iu(struct scsi_target *starget, int iu)

2822 {

2823 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);

2824 struct ahc_softc *ahc = *((struct ahc_softc **)shost->hostdata);

2825 struct ahc_tmode_tstate *tstate;

2826 struct ahc_initiator_tinfo *tinfo

2827 = ahc_fetch_transinfo(ahc,

2828 starget->channel + 'A',

2829 shost->this_id, starget->id, &tstate);

2830 struct ahc_devinfo devinfo;

2831 unsigned int ppr_options = tinfo->curr.ppr_options

2832 & ~MSG_EXT_PPR_IU_REQ;

2833 unsigned int period = tinfo->curr.period;

2834 unsigned long flags;

2835 struct ahc_syncrate *syncrate;

2836

2837 if (iu)

2838 ppr_options |= MSG_EXT_PPR_IU_REQ;

2839

2840 ahc_compile_devinfo(&devinfo, shost->this_id, starget->id, 0,

2841 starget->channel + 'A', ROLE_INITIATOR);

2842 syncrate = ahc_find_syncrate(ahc, &period, &ppr_options, AHC_SYNCRATE_DT);

2843 ahc_lock(ahc, &flags);

2844 ahc_set_syncrate(ahc, &devinfo, syncrate, period, tinfo->curr.offset,

2845 ppr_options, AHC_TRANS_GOAL, FALSE);

2846 ahc_unlock(ahc, &flags);

2847 }

2848

2849 static struct spi_function_template ahc_linux_transport_functions = {

2850 .get_offset = ahc_linux_get_offset,

2851 .set_offset = ahc_linux_set_offset,

2852 .show_offset = 1,

2853 .get_period = ahc_linux_get_period,

2854 .set_period = ahc_linux_set_period,

2855 .show_period = 1,

2856 .get_width = ahc_linux_get_width,

2857 .set_width = ahc_linux_set_width,

2858 .show_width = 1,

2859 .get_dt = ahc_linux_get_dt,

2860 .set_dt = ahc_linux_set_dt,

2861 .show_dt = 1,

2862 .get_iu = ahc_linux_get_iu,

2863 .set_iu = ahc_linux_set_iu,

2864 .show_iu = 1,

2865 .get_qas = ahc_linux_get_qas,

2866 .set_qas = ahc_linux_set_qas,

2867 .show_qas = 1,

2868 };

2869

2870

2871

2872 static int __init

2873 ahc_linux_init(void)

2874 {

2875 ahc_linux_transport_template = spi_attach_transport(&ahc_linux_transport_functions);

2876 if (!ahc_linux_transport_template)

2877 return -ENODEV;

2878 if (ahc_linux_detect(&aic7xxx_driver_template))

2879 return 0;

2880 spi_release_transport(ahc_linux_transport_template);

2881 ahc_linux_exit();

2882 return -ENODEV;

2883 }

2884

2885 static void

2886 ahc_linux_exit(void)

2887 {

2888 ahc_linux_pci_exit();

2889 ahc_linux_eisa_exit();

2890 spi_release_transport(ahc_linux_transport_template);

2891 }

2892

2893 module_init(ahc_linux_init);

2894 module_exit(ahc_linux_exit);