2 * ipr.c -- driver for IBM Power Linux RAID adapters
4 * Written By: Brian King <brking@us.ibm.com>, IBM Corporation
6 * Copyright (C) 2003, 2004 IBM Corporation
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 * This driver is used to control the following SCSI adapters:
29 * IBM iSeries: 5702, 5703, 2780, 5709, 570A, 570B
31 * IBM pSeries: PCI-X Dual Channel Ultra 320 SCSI RAID Adapter
32 * PCI-X Dual Channel Ultra 320 SCSI Adapter
33 * PCI-X Dual Channel Ultra 320 SCSI RAID Enablement Card
34 * Embedded SCSI adapter on p615 and p655 systems
36 * Supported Hardware Features:
37 * - Ultra 320 SCSI controller
38 * - PCI-X host interface
39 * - Embedded PowerPC RISC Processor and Hardware XOR DMA Engine
40 * - Non-Volatile Write Cache
41 * - Supports attachment of non-RAID disks, tape, and optical devices
42 * - RAID Levels 0, 5, 10
44 * - Background Parity Checking
45 * - Background Data Scrubbing
46 * - Ability to increase the capacity of an existing RAID 5 disk array
50 * - Tagged command queuing
51 * - Adapter microcode download
53 * - SCSI device hot plug
57 #include <linux/config.h>
59 #include <linux/init.h>
60 #include <linux/types.h>
61 #include <linux/errno.h>
62 #include <linux/kernel.h>
63 #include <linux/ioport.h>
64 #include <linux/delay.h>
65 #include <linux/pci.h>
66 #include <linux/wait.h>
67 #include <linux/spinlock.h>
68 #include <linux/sched.h>
69 #include <linux/interrupt.h>
70 #include <linux/blkdev.h>
71 #include <linux/firmware.h>
72 #include <linux/module.h>
73 #include <linux/moduleparam.h>
76 #include <asm/processor.h>
77 #include <scsi/scsi.h>
78 #include <scsi/scsi_host.h>
79 #include <scsi/scsi_tcq.h>
80 #include <scsi/scsi_eh.h>
81 #include <scsi/scsi_cmnd.h>
82 #include <scsi/scsi_request.h>
88 static struct list_head ipr_ioa_head = LIST_HEAD_INIT(ipr_ioa_head);
89 static unsigned int ipr_log_level = IPR_DEFAULT_LOG_LEVEL;
90 static unsigned int ipr_max_speed = 1;
91 static int ipr_testmode = 0;
92 static unsigned int ipr_fastfail = 0;
93 static unsigned int ipr_transop_timeout = IPR_OPERATIONAL_TIMEOUT;
94 static DEFINE_SPINLOCK(ipr_driver_lock);
96 /* This table describes the differences between DMA controller chips */
97 static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
98 { /* Gemstone and Citrine */
100 .cache_line_size = 0x20,
102 .set_interrupt_mask_reg = 0x0022C,
103 .clr_interrupt_mask_reg = 0x00230,
104 .sense_interrupt_mask_reg = 0x0022C,
105 .clr_interrupt_reg = 0x00228,
106 .sense_interrupt_reg = 0x00224,
107 .ioarrin_reg = 0x00404,
108 .sense_uproc_interrupt_reg = 0x00214,
109 .set_uproc_interrupt_reg = 0x00214,
110 .clr_uproc_interrupt_reg = 0x00218
113 { /* Snipe and Scamp */
115 .cache_line_size = 0x20,
117 .set_interrupt_mask_reg = 0x00288,
118 .clr_interrupt_mask_reg = 0x0028C,
119 .sense_interrupt_mask_reg = 0x00288,
120 .clr_interrupt_reg = 0x00284,
121 .sense_interrupt_reg = 0x00280,
122 .ioarrin_reg = 0x00504,
123 .sense_uproc_interrupt_reg = 0x00290,
124 .set_uproc_interrupt_reg = 0x00290,
125 .clr_uproc_interrupt_reg = 0x00294
130 static const struct ipr_chip_t ipr_chip[] = {
131 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, &ipr_chip_cfg[0] },
132 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, &ipr_chip_cfg[0] },
133 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, &ipr_chip_cfg[1] },
134 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, &ipr_chip_cfg[1] }
137 static int ipr_max_bus_speeds [] = {
138 IPR_80MBs_SCSI_RATE, IPR_U160_SCSI_RATE, IPR_U320_SCSI_RATE
141 MODULE_AUTHOR("Brian King <brking@us.ibm.com>");
142 MODULE_DESCRIPTION("IBM Power RAID SCSI Adapter Driver");
143 module_param_named(max_speed, ipr_max_speed, uint, 0);
144 MODULE_PARM_DESC(max_speed, "Maximum bus speed (0-2). Default: 1=U160. Speeds: 0=80 MB/s, 1=U160, 2=U320");
145 module_param_named(log_level, ipr_log_level, uint, 0);
146 MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver");
147 module_param_named(testmode, ipr_testmode, int, 0);
148 MODULE_PARM_DESC(testmode, "DANGEROUS!!! Allows unsupported configurations");
149 module_param_named(fastfail, ipr_fastfail, int, 0);
150 MODULE_PARM_DESC(fastfail, "Reduce timeouts and retries");
151 module_param_named(transop_timeout, ipr_transop_timeout, int, 0);
152 MODULE_PARM_DESC(transop_timeout, "Time in seconds to wait for adapter to come operational (default: 300)");
153 MODULE_LICENSE("GPL");
154 MODULE_VERSION(IPR_DRIVER_VERSION);
156 static const char *ipr_gpdd_dev_end_states[] = {
158 "Terminated by host",
159 "Terminated by device reset",
160 "Terminated by bus reset",
162 "Command not started"
165 static const char *ipr_gpdd_dev_bus_phases[] = {
179 /* A constant array of IOASCs/URCs/Error Messages */
181 struct ipr_error_table_t ipr_error_table[] = {
183 "8155: An unknown error was received"},
185 "Soft underlength error"},
187 "Command to be cancelled not found"},
189 "Qualified success"},
191 "FFFE: Soft device bus error recovered by the IOA"},
193 "FFF9: Device sector reassign successful"},
195 "FFF7: Media error recovered by device rewrite procedures"},
197 "7001: IOA sector reassignment successful"},
199 "FFF9: Soft media error. Sector reassignment recommended"},
201 "FFF7: Media error recovered by IOA rewrite procedures"},
203 "FF3D: Soft PCI bus error recovered by the IOA"},
205 "FFF6: Device hardware error recovered by the IOA"},
207 "FFF6: Device hardware error recovered by the device"},
209 "FF3D: Soft IOA error recovered by the IOA"},
211 "FFFA: Undefined device response recovered by the IOA"},
213 "FFF6: Device bus error, message or command phase"},
215 "FFF6: Failure prediction threshold exceeded"},
217 "8009: Impending cache battery pack failure"},
219 "34FF: Disk device format in progress"},
221 "Synchronization required"},
223 "No ready, IOA shutdown"},
225 "Not ready, IOA has been shutdown"},
227 "3020: Storage subsystem configuration error"},
229 "FFF5: Medium error, data unreadable, recommend reassign"},
231 "7000: Medium error, data unreadable, do not reassign"},
233 "FFF3: Disk media format bad"},
235 "3002: Addressed device failed to respond to selection"},
237 "3100: Device bus error"},
239 "3109: IOA timed out a device command"},
241 "3120: SCSI bus is not operational"},
243 "9000: IOA reserved area data check"},
245 "9001: IOA reserved area invalid data pattern"},
247 "9002: IOA reserved area LRC error"},
249 "102E: Out of alternate sectors for disk storage"},
251 "FFF4: Data transfer underlength error"},
253 "FFF4: Data transfer overlength error"},
255 "3400: Logical unit failure"},
257 "FFF4: Device microcode is corrupt"},
259 "8150: PCI bus error"},
261 "Unsupported device bus message received"},
263 "FFF4: Disk device problem"},
265 "8150: Permanent IOA failure"},
267 "3010: Disk device returned wrong response to IOA"},
269 "8151: IOA microcode error"},
271 "Device bus status error"},
273 "8157: IOA error requiring IOA reset to recover"},
275 "Message reject received from the device"},
277 "8008: A permanent cache battery pack failure occurred"},
279 "9090: Disk unit has been modified after the last known status"},
281 "9081: IOA detected device error"},
283 "9082: IOA detected device error"},
285 "3110: Device bus error, message or command phase"},
287 "9091: Incorrect hardware configuration change has been detected"},
289 "FFF4: Command to logical unit failed"},
291 "Illegal request, invalid request type or request packet"},
293 "Illegal request, invalid resource handle"},
295 "Illegal request, invalid field in parameter list"},
297 "Illegal request, parameter not supported"},
299 "Illegal request, parameter value invalid"},
301 "Illegal request, command sequence error"},
303 "9031: Array protection temporarily suspended, protection resuming"},
305 "9040: Array protection temporarily suspended, protection resuming"},
307 "FFFB: SCSI bus was reset"},
309 "FFFE: SCSI bus transition to single ended"},
311 "FFFE: SCSI bus transition to LVD"},
313 "FFFB: SCSI bus was reset by another initiator"},
315 "3029: A device replacement has occurred"},
317 "9051: IOA cache data exists for a missing or failed device"},
319 "9025: Disk unit is not supported at its physical location"},
321 "3020: IOA detected a SCSI bus configuration error"},
323 "3150: SCSI bus configuration error"},
325 "9041: Array protection temporarily suspended"},
327 "9042: Corrupt array parity detected on specified device"},
329 "9030: Array no longer protected due to missing or failed disk unit"},
331 "9032: Array exposed but still protected"},
333 "Failure due to other device"},
335 "9008: IOA does not support functions expected by devices"},
337 "9010: Cache data associated with attached devices cannot be found"},
339 "9011: Cache data belongs to devices other than those attached"},
341 "9020: Array missing 2 or more devices with only 1 device present"},
343 "9021: Array missing 2 or more devices with 2 or more devices present"},
345 "9022: Exposed array is missing a required device"},
347 "9023: Array member(s) not at required physical locations"},
349 "9024: Array not functional due to present hardware configuration"},
351 "9026: Array not functional due to present hardware configuration"},
353 "9027: Array is missing a device and parity is out of sync"},
355 "9028: Maximum number of arrays already exist"},
357 "9050: Required cache data cannot be located for a disk unit"},
359 "9052: Cache data exists for a device that has been modified"},
361 "9054: IOA resources not available due to previous problems"},
363 "9092: Disk unit requires initialization before use"},
365 "9029: Incorrect hardware configuration change has been detected"},
367 "9060: One or more disk pairs are missing from an array"},
369 "9061: One or more disks are missing from an array"},
371 "9062: One or more disks are missing from an array"},
373 "9063: Maximum number of functional arrays has been exceeded"},
375 "Aborted command, invalid descriptor"},
377 "Command terminated by host"}
380 static const struct ipr_ses_table_entry ipr_ses_table[] = {
381 { "2104-DL1 ", "XXXXXXXXXXXXXXXX", 80 },
382 { "2104-TL1 ", "XXXXXXXXXXXXXXXX", 80 },
383 { "HSBP07M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 7 slot */
384 { "HSBP05M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 5 slot */
385 { "HSBP05M S U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Bowtie */
386 { "HSBP06E ASU2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* MartinFenning */
387 { "2104-DU3 ", "XXXXXXXXXXXXXXXX", 160 },
388 { "2104-TU3 ", "XXXXXXXXXXXXXXXX", 160 },
389 { "HSBP04C RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
390 { "HSBP06E RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
391 { "St V1S2 ", "XXXXXXXXXXXXXXXX", 160 },
392 { "HSBPD4M PU3SCSI", "XXXXXXX*XXXXXXXX", 160 },
393 { "VSBPD1H U3SCSI", "XXXXXXX*XXXXXXXX", 160 }
397 * Function Prototypes
399 static int ipr_reset_alert(struct ipr_cmnd *);
400 static void ipr_process_ccn(struct ipr_cmnd *);
401 static void ipr_process_error(struct ipr_cmnd *);
402 static void ipr_reset_ioa_job(struct ipr_cmnd *);
403 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *,
404 enum ipr_shutdown_type);
406 #ifdef CONFIG_SCSI_IPR_TRACE
408 * ipr_trc_hook - Add a trace entry to the driver trace
409 * @ipr_cmd: ipr command struct
411 * @add_data: additional data
416 static void ipr_trc_hook(struct ipr_cmnd *ipr_cmd,
417 u8 type, u32 add_data)
419 struct ipr_trace_entry *trace_entry;
420 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
422 trace_entry = &ioa_cfg->trace[ioa_cfg->trace_index++];
423 trace_entry->time = jiffies;
424 trace_entry->op_code = ipr_cmd->ioarcb.cmd_pkt.cdb[0];
425 trace_entry->type = type;
426 trace_entry->cmd_index = ipr_cmd->cmd_index;
427 trace_entry->res_handle = ipr_cmd->ioarcb.res_handle;
428 trace_entry->u.add_data = add_data;
431 #define ipr_trc_hook(ipr_cmd, type, add_data) do { } while(0)
435 * ipr_reinit_ipr_cmnd - Re-initialize an IPR Cmnd block for reuse
436 * @ipr_cmd: ipr command struct
441 static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
443 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
444 struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
446 memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
447 ioarcb->write_data_transfer_length = 0;
448 ioarcb->read_data_transfer_length = 0;
449 ioarcb->write_ioadl_len = 0;
450 ioarcb->read_ioadl_len = 0;
452 ioasa->residual_data_len = 0;
454 ipr_cmd->scsi_cmd = NULL;
455 ipr_cmd->sense_buffer[0] = 0;
456 ipr_cmd->dma_use_sg = 0;
460 * ipr_init_ipr_cmnd - Initialize an IPR Cmnd block
461 * @ipr_cmd: ipr command struct
466 static void ipr_init_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
468 ipr_reinit_ipr_cmnd(ipr_cmd);
469 ipr_cmd->u.scratch = 0;
470 ipr_cmd->sibling = NULL;
471 init_timer(&ipr_cmd->timer);
475 * ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
476 * @ioa_cfg: ioa config struct
479 * pointer to ipr command struct
482 struct ipr_cmnd *ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg *ioa_cfg)
484 struct ipr_cmnd *ipr_cmd;
486 ipr_cmd = list_entry(ioa_cfg->free_q.next, struct ipr_cmnd, queue);
487 list_del(&ipr_cmd->queue);
488 ipr_init_ipr_cmnd(ipr_cmd);
494 * ipr_unmap_sglist - Unmap scatterlist if mapped
495 * @ioa_cfg: ioa config struct
496 * @ipr_cmd: ipr command struct
501 static void ipr_unmap_sglist(struct ipr_ioa_cfg *ioa_cfg,
502 struct ipr_cmnd *ipr_cmd)
504 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
506 if (ipr_cmd->dma_use_sg) {
507 if (scsi_cmd->use_sg > 0) {
508 pci_unmap_sg(ioa_cfg->pdev, scsi_cmd->request_buffer,
510 scsi_cmd->sc_data_direction);
512 pci_unmap_single(ioa_cfg->pdev, ipr_cmd->dma_handle,
513 scsi_cmd->request_bufflen,
514 scsi_cmd->sc_data_direction);
520 * ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts
521 * @ioa_cfg: ioa config struct
522 * @clr_ints: interrupts to clear
524 * This function masks all interrupts on the adapter, then clears the
525 * interrupts specified in the mask
530 static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg,
533 volatile u32 int_reg;
535 /* Stop new interrupts */
536 ioa_cfg->allow_interrupts = 0;
538 /* Set interrupt mask to stop all new interrupts */
539 writel(~0, ioa_cfg->regs.set_interrupt_mask_reg);
541 /* Clear any pending interrupts */
542 writel(clr_ints, ioa_cfg->regs.clr_interrupt_reg);
543 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
547 * ipr_save_pcix_cmd_reg - Save PCI-X command register
548 * @ioa_cfg: ioa config struct
551 * 0 on success / -EIO on failure
553 static int ipr_save_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
555 int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
557 if (pcix_cmd_reg == 0) {
558 dev_err(&ioa_cfg->pdev->dev, "Failed to save PCI-X command register\n");
562 if (pci_read_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
563 &ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
564 dev_err(&ioa_cfg->pdev->dev, "Failed to save PCI-X command register\n");
568 ioa_cfg->saved_pcix_cmd_reg |= PCI_X_CMD_DPERR_E | PCI_X_CMD_ERO;
573 * ipr_set_pcix_cmd_reg - Setup PCI-X command register
574 * @ioa_cfg: ioa config struct
577 * 0 on success / -EIO on failure
579 static int ipr_set_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
581 int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
584 if (pci_write_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
585 ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
586 dev_err(&ioa_cfg->pdev->dev, "Failed to setup PCI-X command register\n");
590 dev_err(&ioa_cfg->pdev->dev,
591 "Failed to setup PCI-X command register\n");
599 * ipr_scsi_eh_done - mid-layer done function for aborted ops
600 * @ipr_cmd: ipr command struct
602 * This function is invoked by the interrupt handler for
603 * ops generated by the SCSI mid-layer which are being aborted.
608 static void ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
610 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
611 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
613 scsi_cmd->result |= (DID_ERROR << 16);
615 ipr_unmap_sglist(ioa_cfg, ipr_cmd);
616 scsi_cmd->scsi_done(scsi_cmd);
617 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
621 * ipr_fail_all_ops - Fails all outstanding ops.
622 * @ioa_cfg: ioa config struct
624 * This function fails all outstanding ops.
629 static void ipr_fail_all_ops(struct ipr_ioa_cfg *ioa_cfg)
631 struct ipr_cmnd *ipr_cmd, *temp;
634 list_for_each_entry_safe(ipr_cmd, temp, &ioa_cfg->pending_q, queue) {
635 list_del(&ipr_cmd->queue);
637 ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_IOA_WAS_RESET);
638 ipr_cmd->ioasa.ilid = cpu_to_be32(IPR_DRIVER_ILID);
640 if (ipr_cmd->scsi_cmd)
641 ipr_cmd->done = ipr_scsi_eh_done;
643 ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, IPR_IOASC_IOA_WAS_RESET);
644 del_timer(&ipr_cmd->timer);
645 ipr_cmd->done(ipr_cmd);
652 * ipr_do_req - Send driver initiated requests.
653 * @ipr_cmd: ipr command struct
654 * @done: done function
655 * @timeout_func: timeout function
656 * @timeout: timeout value
658 * This function sends the specified command to the adapter with the
659 * timeout given. The done function is invoked on command completion.
664 static void ipr_do_req(struct ipr_cmnd *ipr_cmd,
665 void (*done) (struct ipr_cmnd *),
666 void (*timeout_func) (struct ipr_cmnd *), u32 timeout)
668 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
670 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
672 ipr_cmd->done = done;
674 ipr_cmd->timer.data = (unsigned long) ipr_cmd;
675 ipr_cmd->timer.expires = jiffies + timeout;
676 ipr_cmd->timer.function = (void (*)(unsigned long))timeout_func;
678 add_timer(&ipr_cmd->timer);
680 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, 0);
683 writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
684 ioa_cfg->regs.ioarrin_reg);
688 * ipr_internal_cmd_done - Op done function for an internally generated op.
689 * @ipr_cmd: ipr command struct
691 * This function is the op done function for an internally generated,
692 * blocking op. It simply wakes the sleeping thread.
697 static void ipr_internal_cmd_done(struct ipr_cmnd *ipr_cmd)
699 if (ipr_cmd->sibling)
700 ipr_cmd->sibling = NULL;
702 complete(&ipr_cmd->completion);
706 * ipr_send_blocking_cmd - Send command and sleep on its completion.
707 * @ipr_cmd: ipr command struct
708 * @timeout_func: function to invoke if command times out
714 static void ipr_send_blocking_cmd(struct ipr_cmnd *ipr_cmd,
715 void (*timeout_func) (struct ipr_cmnd *ipr_cmd),
718 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
720 init_completion(&ipr_cmd->completion);
721 ipr_do_req(ipr_cmd, ipr_internal_cmd_done, timeout_func, timeout);
723 spin_unlock_irq(ioa_cfg->host->host_lock);
724 wait_for_completion(&ipr_cmd->completion);
725 spin_lock_irq(ioa_cfg->host->host_lock);
729 * ipr_send_hcam - Send an HCAM to the adapter.
730 * @ioa_cfg: ioa config struct
732 * @hostrcb: hostrcb struct
734 * This function will send a Host Controlled Async command to the adapter.
735 * If HCAMs are currently not allowed to be issued to the adapter, it will
736 * place the hostrcb on the free queue.
741 static void ipr_send_hcam(struct ipr_ioa_cfg *ioa_cfg, u8 type,
742 struct ipr_hostrcb *hostrcb)
744 struct ipr_cmnd *ipr_cmd;
745 struct ipr_ioarcb *ioarcb;
747 if (ioa_cfg->allow_cmds) {
748 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
749 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
750 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_pending_q);
752 ipr_cmd->u.hostrcb = hostrcb;
753 ioarcb = &ipr_cmd->ioarcb;
755 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
756 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_HCAM;
757 ioarcb->cmd_pkt.cdb[0] = IPR_HOST_CONTROLLED_ASYNC;
758 ioarcb->cmd_pkt.cdb[1] = type;
759 ioarcb->cmd_pkt.cdb[7] = (sizeof(hostrcb->hcam) >> 8) & 0xff;
760 ioarcb->cmd_pkt.cdb[8] = sizeof(hostrcb->hcam) & 0xff;
762 ioarcb->read_data_transfer_length = cpu_to_be32(sizeof(hostrcb->hcam));
763 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
764 ipr_cmd->ioadl[0].flags_and_data_len =
765 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | sizeof(hostrcb->hcam));
766 ipr_cmd->ioadl[0].address = cpu_to_be32(hostrcb->hostrcb_dma);
768 if (type == IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE)
769 ipr_cmd->done = ipr_process_ccn;
771 ipr_cmd->done = ipr_process_error;
773 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_IOA_RES_ADDR);
776 writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
777 ioa_cfg->regs.ioarrin_reg);
779 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
784 * ipr_init_res_entry - Initialize a resource entry struct.
785 * @res: resource entry struct
790 static void ipr_init_res_entry(struct ipr_resource_entry *res)
792 res->needs_sync_complete = 1;
795 res->del_from_ml = 0;
796 res->resetting_device = 0;
801 * ipr_handle_config_change - Handle a config change from the adapter
802 * @ioa_cfg: ioa config struct
808 static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg,
809 struct ipr_hostrcb *hostrcb)
811 struct ipr_resource_entry *res = NULL;
812 struct ipr_config_table_entry *cfgte;
815 cfgte = &hostrcb->hcam.u.ccn.cfgte;
817 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
818 if (!memcmp(&res->cfgte.res_addr, &cfgte->res_addr,
819 sizeof(cfgte->res_addr))) {
826 if (list_empty(&ioa_cfg->free_res_q)) {
827 ipr_send_hcam(ioa_cfg,
828 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
833 res = list_entry(ioa_cfg->free_res_q.next,
834 struct ipr_resource_entry, queue);
836 list_del(&res->queue);
837 ipr_init_res_entry(res);
838 list_add_tail(&res->queue, &ioa_cfg->used_res_q);
841 memcpy(&res->cfgte, cfgte, sizeof(struct ipr_config_table_entry));
843 if (hostrcb->hcam.notify_type == IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY) {
845 res->sdev->hostdata = NULL;
846 res->del_from_ml = 1;
847 if (ioa_cfg->allow_ml_add_del)
848 schedule_work(&ioa_cfg->work_q);
850 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
851 } else if (!res->sdev) {
853 if (ioa_cfg->allow_ml_add_del)
854 schedule_work(&ioa_cfg->work_q);
857 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
861 * ipr_process_ccn - Op done function for a CCN.
862 * @ipr_cmd: ipr command struct
864 * This function is the op done function for a configuration
865 * change notification host controlled async from the adapter.
870 static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd)
872 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
873 struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
874 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
876 list_del(&hostrcb->queue);
877 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
880 if (ioasc != IPR_IOASC_IOA_WAS_RESET)
881 dev_err(&ioa_cfg->pdev->dev,
882 "Host RCB failed with IOASC: 0x%08X\n", ioasc);
884 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
886 ipr_handle_config_change(ioa_cfg, hostrcb);
891 * ipr_log_vpd - Log the passed VPD to the error log.
892 * @vpd: vendor/product id/sn struct
897 static void ipr_log_vpd(struct ipr_vpd *vpd)
899 char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN
900 + IPR_SERIAL_NUM_LEN];
902 memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
903 memcpy(buffer + IPR_VENDOR_ID_LEN, vpd->vpids.product_id,
905 buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN] = '\0';
906 ipr_err("Vendor/Product ID: %s\n", buffer);
908 memcpy(buffer, vpd->sn, IPR_SERIAL_NUM_LEN);
909 buffer[IPR_SERIAL_NUM_LEN] = '\0';
910 ipr_err(" Serial Number: %s\n", buffer);
914 * ipr_log_cache_error - Log a cache error.
915 * @ioa_cfg: ioa config struct
916 * @hostrcb: hostrcb struct
921 static void ipr_log_cache_error(struct ipr_ioa_cfg *ioa_cfg,
922 struct ipr_hostrcb *hostrcb)
924 struct ipr_hostrcb_type_02_error *error =
925 &hostrcb->hcam.u.error.u.type_02_error;
927 ipr_err("-----Current Configuration-----\n");
928 ipr_err("Cache Directory Card Information:\n");
929 ipr_log_vpd(&error->ioa_vpd);
930 ipr_err("Adapter Card Information:\n");
931 ipr_log_vpd(&error->cfc_vpd);
933 ipr_err("-----Expected Configuration-----\n");
934 ipr_err("Cache Directory Card Information:\n");
935 ipr_log_vpd(&error->ioa_last_attached_to_cfc_vpd);
936 ipr_err("Adapter Card Information:\n");
937 ipr_log_vpd(&error->cfc_last_attached_to_ioa_vpd);
939 ipr_err("Additional IOA Data: %08X %08X %08X\n",
940 be32_to_cpu(error->ioa_data[0]),
941 be32_to_cpu(error->ioa_data[1]),
942 be32_to_cpu(error->ioa_data[2]));
946 * ipr_log_config_error - Log a configuration error.
947 * @ioa_cfg: ioa config struct
948 * @hostrcb: hostrcb struct
953 static void ipr_log_config_error(struct ipr_ioa_cfg *ioa_cfg,
954 struct ipr_hostrcb *hostrcb)
956 int errors_logged, i;
957 struct ipr_hostrcb_device_data_entry *dev_entry;
958 struct ipr_hostrcb_type_03_error *error;
960 error = &hostrcb->hcam.u.error.u.type_03_error;
961 errors_logged = be32_to_cpu(error->errors_logged);
963 ipr_err("Device Errors Detected/Logged: %d/%d\n",
964 be32_to_cpu(error->errors_detected), errors_logged);
966 dev_entry = error->dev;
968 for (i = 0; i < errors_logged; i++, dev_entry++) {
971 if (dev_entry->dev_res_addr.bus >= IPR_MAX_NUM_BUSES) {
972 ipr_err("Device %d: missing\n", i + 1);
974 ipr_err("Device %d: %d:%d:%d:%d\n", i + 1,
975 ioa_cfg->host->host_no, dev_entry->dev_res_addr.bus,
976 dev_entry->dev_res_addr.target, dev_entry->dev_res_addr.lun);
978 ipr_log_vpd(&dev_entry->vpd);
980 ipr_err("-----New Device Information-----\n");
981 ipr_log_vpd(&dev_entry->new_vpd);
983 ipr_err("Cache Directory Card Information:\n");
984 ipr_log_vpd(&dev_entry->ioa_last_with_dev_vpd);
986 ipr_err("Adapter Card Information:\n");
987 ipr_log_vpd(&dev_entry->cfc_last_with_dev_vpd);
989 ipr_err("Additional IOA Data: %08X %08X %08X %08X %08X\n",
990 be32_to_cpu(dev_entry->ioa_data[0]),
991 be32_to_cpu(dev_entry->ioa_data[1]),
992 be32_to_cpu(dev_entry->ioa_data[2]),
993 be32_to_cpu(dev_entry->ioa_data[3]),
994 be32_to_cpu(dev_entry->ioa_data[4]));
999 * ipr_log_array_error - Log an array configuration error.
1000 * @ioa_cfg: ioa config struct
1001 * @hostrcb: hostrcb struct
1006 static void ipr_log_array_error(struct ipr_ioa_cfg *ioa_cfg,
1007 struct ipr_hostrcb *hostrcb)
1010 struct ipr_hostrcb_type_04_error *error;
1011 struct ipr_hostrcb_array_data_entry *array_entry;
1012 const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1014 error = &hostrcb->hcam.u.error.u.type_04_error;
1018 ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1019 error->protection_level,
1020 ioa_cfg->host->host_no,
1021 error->last_func_vset_res_addr.bus,
1022 error->last_func_vset_res_addr.target,
1023 error->last_func_vset_res_addr.lun);
1027 array_entry = error->array_member;
1029 for (i = 0; i < 18; i++) {
1030 if (!memcmp(array_entry->vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1033 if (be32_to_cpu(error->exposed_mode_adn) == i) {
1034 ipr_err("Exposed Array Member %d:\n", i);
1036 ipr_err("Array Member %d:\n", i);
1039 ipr_log_vpd(&array_entry->vpd);
1041 if (array_entry->dev_res_addr.bus >= IPR_MAX_NUM_BUSES) {
1042 ipr_err("Current Location: unknown\n");
1044 ipr_err("Current Location: %d:%d:%d:%d\n",
1045 ioa_cfg->host->host_no,
1046 array_entry->dev_res_addr.bus,
1047 array_entry->dev_res_addr.target,
1048 array_entry->dev_res_addr.lun);
1051 if (array_entry->expected_dev_res_addr.bus >= IPR_MAX_NUM_BUSES) {
1052 ipr_err("Expected Location: unknown\n");
1054 ipr_err("Expected Location: %d:%d:%d:%d\n",
1055 ioa_cfg->host->host_no,
1056 array_entry->expected_dev_res_addr.bus,
1057 array_entry->expected_dev_res_addr.target,
1058 array_entry->expected_dev_res_addr.lun);
1064 array_entry = error->array_member2;
1071 * ipr_log_generic_error - Log an adapter error.
1072 * @ioa_cfg: ioa config struct
1073 * @hostrcb: hostrcb struct
1078 static void ipr_log_generic_error(struct ipr_ioa_cfg *ioa_cfg,
1079 struct ipr_hostrcb *hostrcb)
1082 int ioa_data_len = be32_to_cpu(hostrcb->hcam.length);
1084 if (ioa_data_len == 0)
1087 ipr_err("IOA Error Data:\n");
1088 ipr_err("Offset 0 1 2 3 4 5 6 7 8 9 A B C D E F\n");
1090 for (i = 0; i < ioa_data_len / 4; i += 4) {
1091 ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
1092 be32_to_cpu(hostrcb->hcam.u.raw.data[i]),
1093 be32_to_cpu(hostrcb->hcam.u.raw.data[i+1]),
1094 be32_to_cpu(hostrcb->hcam.u.raw.data[i+2]),
1095 be32_to_cpu(hostrcb->hcam.u.raw.data[i+3]));
1100 * ipr_get_error - Find the specfied IOASC in the ipr_error_table.
1103 * This function will return the index of into the ipr_error_table
1104 * for the specified IOASC. If the IOASC is not in the table,
1105 * 0 will be returned, which points to the entry used for unknown errors.
1108 * index into the ipr_error_table
1110 static u32 ipr_get_error(u32 ioasc)
1114 for (i = 0; i < ARRAY_SIZE(ipr_error_table); i++)
1115 if (ipr_error_table[i].ioasc == ioasc)
1122 * ipr_handle_log_data - Log an adapter error.
1123 * @ioa_cfg: ioa config struct
1124 * @hostrcb: hostrcb struct
1126 * This function logs an adapter error to the system.
1131 static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
1132 struct ipr_hostrcb *hostrcb)
1137 if (hostrcb->hcam.notify_type != IPR_HOST_RCB_NOTIF_TYPE_ERROR_LOG_ENTRY)
1140 if (hostrcb->hcam.notifications_lost == IPR_HOST_RCB_NOTIFICATIONS_LOST)
1141 dev_err(&ioa_cfg->pdev->dev, "Error notifications lost\n");
1143 ioasc = be32_to_cpu(hostrcb->hcam.u.error.failing_dev_ioasc);
1145 if (ioasc == IPR_IOASC_BUS_WAS_RESET ||
1146 ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER) {
1147 /* Tell the midlayer we had a bus reset so it will handle the UA properly */
1148 scsi_report_bus_reset(ioa_cfg->host,
1149 hostrcb->hcam.u.error.failing_dev_res_addr.bus);
1152 error_index = ipr_get_error(ioasc);
1154 if (!ipr_error_table[error_index].log_hcam)
1157 if (ipr_is_device(&hostrcb->hcam.u.error.failing_dev_res_addr)) {
1158 ipr_res_err(ioa_cfg, hostrcb->hcam.u.error.failing_dev_res_addr,
1159 "%s\n", ipr_error_table[error_index].error);
1161 dev_err(&ioa_cfg->pdev->dev, "%s\n",
1162 ipr_error_table[error_index].error);
1165 /* Set indication we have logged an error */
1166 ioa_cfg->errors_logged++;
1168 if (ioa_cfg->log_level < IPR_DEFAULT_LOG_LEVEL)
1171 switch (hostrcb->hcam.overlay_id) {
1172 case IPR_HOST_RCB_OVERLAY_ID_1:
1173 ipr_log_generic_error(ioa_cfg, hostrcb);
1175 case IPR_HOST_RCB_OVERLAY_ID_2:
1176 ipr_log_cache_error(ioa_cfg, hostrcb);
1178 case IPR_HOST_RCB_OVERLAY_ID_3:
1179 ipr_log_config_error(ioa_cfg, hostrcb);
1181 case IPR_HOST_RCB_OVERLAY_ID_4:
1182 case IPR_HOST_RCB_OVERLAY_ID_6:
1183 ipr_log_array_error(ioa_cfg, hostrcb);
1185 case IPR_HOST_RCB_OVERLAY_ID_DEFAULT:
1186 ipr_log_generic_error(ioa_cfg, hostrcb);
1189 dev_err(&ioa_cfg->pdev->dev,
1190 "Unknown error received. Overlay ID: %d\n",
1191 hostrcb->hcam.overlay_id);
1197 * ipr_process_error - Op done function for an adapter error log.
1198 * @ipr_cmd: ipr command struct
1200 * This function is the op done function for an error log host
1201 * controlled async from the adapter. It will log the error and
1202 * send the HCAM back to the adapter.
1207 static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
1209 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1210 struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
1211 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
1213 list_del(&hostrcb->queue);
1214 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
1217 ipr_handle_log_data(ioa_cfg, hostrcb);
1218 } else if (ioasc != IPR_IOASC_IOA_WAS_RESET) {
1219 dev_err(&ioa_cfg->pdev->dev,
1220 "Host RCB failed with IOASC: 0x%08X\n", ioasc);
1223 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
1227 * ipr_timeout - An internally generated op has timed out.
1228 * @ipr_cmd: ipr command struct
1230 * This function blocks host requests and initiates an
1236 static void ipr_timeout(struct ipr_cmnd *ipr_cmd)
1238 unsigned long lock_flags = 0;
1239 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1242 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1244 ioa_cfg->errors_logged++;
1245 dev_err(&ioa_cfg->pdev->dev,
1246 "Adapter being reset due to command timeout.\n");
1248 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
1249 ioa_cfg->sdt_state = GET_DUMP;
1251 if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd)
1252 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
1254 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1259 * ipr_oper_timeout - Adapter timed out transitioning to operational
1260 * @ipr_cmd: ipr command struct
1262 * This function blocks host requests and initiates an
1268 static void ipr_oper_timeout(struct ipr_cmnd *ipr_cmd)
1270 unsigned long lock_flags = 0;
1271 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1274 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1276 ioa_cfg->errors_logged++;
1277 dev_err(&ioa_cfg->pdev->dev,
1278 "Adapter timed out transitioning to operational.\n");
1280 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
1281 ioa_cfg->sdt_state = GET_DUMP;
1283 if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd) {
1285 ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
1286 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
1289 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1294 * ipr_reset_reload - Reset/Reload the IOA
1295 * @ioa_cfg: ioa config struct
1296 * @shutdown_type: shutdown type
1298 * This function resets the adapter and re-initializes it.
1299 * This function assumes that all new host commands have been stopped.
1303 static int ipr_reset_reload(struct ipr_ioa_cfg *ioa_cfg,
1304 enum ipr_shutdown_type shutdown_type)
1306 if (!ioa_cfg->in_reset_reload)
1307 ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
1309 spin_unlock_irq(ioa_cfg->host->host_lock);
1310 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
1311 spin_lock_irq(ioa_cfg->host->host_lock);
1313 /* If we got hit with a host reset while we were already resetting
1314 the adapter for some reason, and the reset failed. */
1315 if (ioa_cfg->ioa_is_dead) {
1324 * ipr_find_ses_entry - Find matching SES in SES table
1325 * @res: resource entry struct of SES
1328 * pointer to SES table entry / NULL on failure
1330 static const struct ipr_ses_table_entry *
1331 ipr_find_ses_entry(struct ipr_resource_entry *res)
1334 const struct ipr_ses_table_entry *ste = ipr_ses_table;
1336 for (i = 0; i < ARRAY_SIZE(ipr_ses_table); i++, ste++) {
1337 for (j = 0, matches = 0; j < IPR_PROD_ID_LEN; j++) {
1338 if (ste->compare_product_id_byte[j] == 'X') {
1339 if (res->cfgte.std_inq_data.vpids.product_id[j] == ste->product_id[j])
1347 if (matches == IPR_PROD_ID_LEN)
1355 * ipr_get_max_scsi_speed - Determine max SCSI speed for a given bus
1356 * @ioa_cfg: ioa config struct
1358 * @bus_width: bus width
1361 * SCSI bus speed in units of 100KHz, 1600 is 160 MHz
1362 * For a 2-byte wide SCSI bus, the maximum transfer speed is
1363 * twice the maximum transfer rate (e.g. for a wide enabled bus,
1364 * max 160MHz = max 320MB/sec).
1366 static u32 ipr_get_max_scsi_speed(struct ipr_ioa_cfg *ioa_cfg, u8 bus, u8 bus_width)
1368 struct ipr_resource_entry *res;
1369 const struct ipr_ses_table_entry *ste;
1370 u32 max_xfer_rate = IPR_MAX_SCSI_RATE(bus_width);
1372 /* Loop through each config table entry in the config table buffer */
1373 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
1374 if (!(IPR_IS_SES_DEVICE(res->cfgte.std_inq_data)))
1377 if (bus != res->cfgte.res_addr.bus)
1380 if (!(ste = ipr_find_ses_entry(res)))
1383 max_xfer_rate = (ste->max_bus_speed_limit * 10) / (bus_width / 8);
1386 return max_xfer_rate;
1390 * ipr_wait_iodbg_ack - Wait for an IODEBUG ACK from the IOA
1391 * @ioa_cfg: ioa config struct
1392 * @max_delay: max delay in micro-seconds to wait
1394 * Waits for an IODEBUG ACK from the IOA, doing busy looping.
1397 * 0 on success / other on failure
1399 static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg *ioa_cfg, int max_delay)
1401 volatile u32 pcii_reg;
1404 /* Read interrupt reg until IOA signals IO Debug Acknowledge */
1405 while (delay < max_delay) {
1406 pcii_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
1408 if (pcii_reg & IPR_PCII_IO_DEBUG_ACKNOWLEDGE)
1411 /* udelay cannot be used if delay is more than a few milliseconds */
1412 if ((delay / 1000) > MAX_UDELAY_MS)
1413 mdelay(delay / 1000);
1423 * ipr_get_ldump_data_section - Dump IOA memory
1424 * @ioa_cfg: ioa config struct
1425 * @start_addr: adapter address to dump
1426 * @dest: destination kernel buffer
1427 * @length_in_words: length to dump in 4 byte words
1430 * 0 on success / -EIO on failure
1432 static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
1434 __be32 *dest, u32 length_in_words)
1436 volatile u32 temp_pcii_reg;
1439 /* Write IOA interrupt reg starting LDUMP state */
1440 writel((IPR_UPROCI_RESET_ALERT | IPR_UPROCI_IO_DEBUG_ALERT),
1441 ioa_cfg->regs.set_uproc_interrupt_reg);
1443 /* Wait for IO debug acknowledge */
1444 if (ipr_wait_iodbg_ack(ioa_cfg,
1445 IPR_LDUMP_MAX_LONG_ACK_DELAY_IN_USEC)) {
1446 dev_err(&ioa_cfg->pdev->dev,
1447 "IOA dump long data transfer timeout\n");
1451 /* Signal LDUMP interlocked - clear IO debug ack */
1452 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
1453 ioa_cfg->regs.clr_interrupt_reg);
1455 /* Write Mailbox with starting address */
1456 writel(start_addr, ioa_cfg->ioa_mailbox);
1458 /* Signal address valid - clear IOA Reset alert */
1459 writel(IPR_UPROCI_RESET_ALERT,
1460 ioa_cfg->regs.clr_uproc_interrupt_reg);
1462 for (i = 0; i < length_in_words; i++) {
1463 /* Wait for IO debug acknowledge */
1464 if (ipr_wait_iodbg_ack(ioa_cfg,
1465 IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC)) {
1466 dev_err(&ioa_cfg->pdev->dev,
1467 "IOA dump short data transfer timeout\n");
1471 /* Read data from mailbox and increment destination pointer */
1472 *dest = cpu_to_be32(readl(ioa_cfg->ioa_mailbox));
1475 /* For all but the last word of data, signal data received */
1476 if (i < (length_in_words - 1)) {
1477 /* Signal dump data received - Clear IO debug Ack */
1478 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
1479 ioa_cfg->regs.clr_interrupt_reg);
1483 /* Signal end of block transfer. Set reset alert then clear IO debug ack */
1484 writel(IPR_UPROCI_RESET_ALERT,
1485 ioa_cfg->regs.set_uproc_interrupt_reg);
1487 writel(IPR_UPROCI_IO_DEBUG_ALERT,
1488 ioa_cfg->regs.clr_uproc_interrupt_reg);
1490 /* Signal dump data received - Clear IO debug Ack */
1491 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
1492 ioa_cfg->regs.clr_interrupt_reg);
1494 /* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
1495 while (delay < IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC) {
1497 readl(ioa_cfg->regs.sense_uproc_interrupt_reg);
1499 if (!(temp_pcii_reg & IPR_UPROCI_RESET_ALERT))
1509 #ifdef CONFIG_SCSI_IPR_DUMP
1511 * ipr_sdt_copy - Copy Smart Dump Table to kernel buffer
1512 * @ioa_cfg: ioa config struct
1513 * @pci_address: adapter address
1514 * @length: length of data to copy
1516 * Copy data from PCI adapter to kernel buffer.
1517 * Note: length MUST be a 4 byte multiple
1519 * 0 on success / other on failure
1521 static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
1522 unsigned long pci_address, u32 length)
1524 int bytes_copied = 0;
1525 int cur_len, rc, rem_len, rem_page_len;
1527 unsigned long lock_flags = 0;
1528 struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
1530 while (bytes_copied < length &&
1531 (ioa_dump->hdr.len + bytes_copied) < IPR_MAX_IOA_DUMP_SIZE) {
1532 if (ioa_dump->page_offset >= PAGE_SIZE ||
1533 ioa_dump->page_offset == 0) {
1534 page = (__be32 *)__get_free_page(GFP_ATOMIC);
1538 return bytes_copied;
1541 ioa_dump->page_offset = 0;
1542 ioa_dump->ioa_data[ioa_dump->next_page_index] = page;
1543 ioa_dump->next_page_index++;
1545 page = ioa_dump->ioa_data[ioa_dump->next_page_index - 1];
1547 rem_len = length - bytes_copied;
1548 rem_page_len = PAGE_SIZE - ioa_dump->page_offset;
1549 cur_len = min(rem_len, rem_page_len);
1551 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1552 if (ioa_cfg->sdt_state == ABORT_DUMP) {
1555 rc = ipr_get_ldump_data_section(ioa_cfg,
1556 pci_address + bytes_copied,
1557 &page[ioa_dump->page_offset / 4],
1558 (cur_len / sizeof(u32)));
1560 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1563 ioa_dump->page_offset += cur_len;
1564 bytes_copied += cur_len;
1572 return bytes_copied;
1576 * ipr_init_dump_entry_hdr - Initialize a dump entry header.
1577 * @hdr: dump entry header struct
1582 static void ipr_init_dump_entry_hdr(struct ipr_dump_entry_header *hdr)
1584 hdr->eye_catcher = IPR_DUMP_EYE_CATCHER;
1586 hdr->offset = sizeof(*hdr);
1587 hdr->status = IPR_DUMP_STATUS_SUCCESS;
1591 * ipr_dump_ioa_type_data - Fill in the adapter type in the dump.
1592 * @ioa_cfg: ioa config struct
1593 * @driver_dump: driver dump struct
1598 static void ipr_dump_ioa_type_data(struct ipr_ioa_cfg *ioa_cfg,
1599 struct ipr_driver_dump *driver_dump)
1601 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
1603 ipr_init_dump_entry_hdr(&driver_dump->ioa_type_entry.hdr);
1604 driver_dump->ioa_type_entry.hdr.len =
1605 sizeof(struct ipr_dump_ioa_type_entry) -
1606 sizeof(struct ipr_dump_entry_header);
1607 driver_dump->ioa_type_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
1608 driver_dump->ioa_type_entry.hdr.id = IPR_DUMP_DRIVER_TYPE_ID;
1609 driver_dump->ioa_type_entry.type = ioa_cfg->type;
1610 driver_dump->ioa_type_entry.fw_version = (ucode_vpd->major_release << 24) |
1611 (ucode_vpd->card_type << 16) | (ucode_vpd->minor_release[0] << 8) |
1612 ucode_vpd->minor_release[1];
1613 driver_dump->hdr.num_entries++;
1617 * ipr_dump_version_data - Fill in the driver version in the dump.
1618 * @ioa_cfg: ioa config struct
1619 * @driver_dump: driver dump struct
1624 static void ipr_dump_version_data(struct ipr_ioa_cfg *ioa_cfg,
1625 struct ipr_driver_dump *driver_dump)
1627 ipr_init_dump_entry_hdr(&driver_dump->version_entry.hdr);
1628 driver_dump->version_entry.hdr.len =
1629 sizeof(struct ipr_dump_version_entry) -
1630 sizeof(struct ipr_dump_entry_header);
1631 driver_dump->version_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
1632 driver_dump->version_entry.hdr.id = IPR_DUMP_DRIVER_VERSION_ID;
1633 strcpy(driver_dump->version_entry.version, IPR_DRIVER_VERSION);
1634 driver_dump->hdr.num_entries++;
1638 * ipr_dump_trace_data - Fill in the IOA trace in the dump.
1639 * @ioa_cfg: ioa config struct
1640 * @driver_dump: driver dump struct
1645 static void ipr_dump_trace_data(struct ipr_ioa_cfg *ioa_cfg,
1646 struct ipr_driver_dump *driver_dump)
1648 ipr_init_dump_entry_hdr(&driver_dump->trace_entry.hdr);
1649 driver_dump->trace_entry.hdr.len =
1650 sizeof(struct ipr_dump_trace_entry) -
1651 sizeof(struct ipr_dump_entry_header);
1652 driver_dump->trace_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
1653 driver_dump->trace_entry.hdr.id = IPR_DUMP_TRACE_ID;
1654 memcpy(driver_dump->trace_entry.trace, ioa_cfg->trace, IPR_TRACE_SIZE);
1655 driver_dump->hdr.num_entries++;
1659 * ipr_dump_location_data - Fill in the IOA location in the dump.
1660 * @ioa_cfg: ioa config struct
1661 * @driver_dump: driver dump struct
1666 static void ipr_dump_location_data(struct ipr_ioa_cfg *ioa_cfg,
1667 struct ipr_driver_dump *driver_dump)
1669 ipr_init_dump_entry_hdr(&driver_dump->location_entry.hdr);
1670 driver_dump->location_entry.hdr.len =
1671 sizeof(struct ipr_dump_location_entry) -
1672 sizeof(struct ipr_dump_entry_header);
1673 driver_dump->location_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
1674 driver_dump->location_entry.hdr.id = IPR_DUMP_LOCATION_ID;
1675 strcpy(driver_dump->location_entry.location, ioa_cfg->pdev->dev.bus_id);
1676 driver_dump->hdr.num_entries++;
1680 * ipr_get_ioa_dump - Perform a dump of the driver and adapter.
1681 * @ioa_cfg: ioa config struct
1682 * @dump: dump struct
1687 static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
1689 unsigned long start_addr, sdt_word;
1690 unsigned long lock_flags = 0;
1691 struct ipr_driver_dump *driver_dump = &dump->driver_dump;
1692 struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
1693 u32 num_entries, start_off, end_off;
1694 u32 bytes_to_copy, bytes_copied, rc;
1695 struct ipr_sdt *sdt;
1700 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1702 if (ioa_cfg->sdt_state != GET_DUMP) {
1703 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1707 start_addr = readl(ioa_cfg->ioa_mailbox);
1709 if (!ipr_sdt_is_fmt2(start_addr)) {
1710 dev_err(&ioa_cfg->pdev->dev,
1711 "Invalid dump table format: %lx\n", start_addr);
1712 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1716 dev_err(&ioa_cfg->pdev->dev, "Dump of IOA initiated\n");
1718 driver_dump->hdr.eye_catcher = IPR_DUMP_EYE_CATCHER;
1720 /* Initialize the overall dump header */
1721 driver_dump->hdr.len = sizeof(struct ipr_driver_dump);
1722 driver_dump->hdr.num_entries = 1;
1723 driver_dump->hdr.first_entry_offset = sizeof(struct ipr_dump_header);
1724 driver_dump->hdr.status = IPR_DUMP_STATUS_SUCCESS;
1725 driver_dump->hdr.os = IPR_DUMP_OS_LINUX;
1726 driver_dump->hdr.driver_name = IPR_DUMP_DRIVER_NAME;
1728 ipr_dump_version_data(ioa_cfg, driver_dump);
1729 ipr_dump_location_data(ioa_cfg, driver_dump);
1730 ipr_dump_ioa_type_data(ioa_cfg, driver_dump);
1731 ipr_dump_trace_data(ioa_cfg, driver_dump);
1733 /* Update dump_header */
1734 driver_dump->hdr.len += sizeof(struct ipr_dump_entry_header);
1736 /* IOA Dump entry */
1737 ipr_init_dump_entry_hdr(&ioa_dump->hdr);
1738 ioa_dump->format = IPR_SDT_FMT2;
1739 ioa_dump->hdr.len = 0;
1740 ioa_dump->hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
1741 ioa_dump->hdr.id = IPR_DUMP_IOA_DUMP_ID;
1743 /* First entries in sdt are actually a list of dump addresses and
1744 lengths to gather the real dump data. sdt represents the pointer
1745 to the ioa generated dump table. Dump data will be extracted based
1746 on entries in this table */
1747 sdt = &ioa_dump->sdt;
1749 rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
1750 sizeof(struct ipr_sdt) / sizeof(__be32));
1752 /* Smart Dump table is ready to use and the first entry is valid */
1753 if (rc || (be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE)) {
1754 dev_err(&ioa_cfg->pdev->dev,
1755 "Dump of IOA failed. Dump table not valid: %d, %X.\n",
1756 rc, be32_to_cpu(sdt->hdr.state));
1757 driver_dump->hdr.status = IPR_DUMP_STATUS_FAILED;
1758 ioa_cfg->sdt_state = DUMP_OBTAINED;
1759 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1763 num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
1765 if (num_entries > IPR_NUM_SDT_ENTRIES)
1766 num_entries = IPR_NUM_SDT_ENTRIES;
1768 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1770 for (i = 0; i < num_entries; i++) {
1771 if (ioa_dump->hdr.len > IPR_MAX_IOA_DUMP_SIZE) {
1772 driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
1776 if (sdt->entry[i].flags & IPR_SDT_VALID_ENTRY) {
1777 sdt_word = be32_to_cpu(sdt->entry[i].bar_str_offset);
1778 start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
1779 end_off = be32_to_cpu(sdt->entry[i].end_offset);
1781 if (ipr_sdt_is_fmt2(sdt_word) && sdt_word) {
1782 bytes_to_copy = end_off - start_off;
1783 if (bytes_to_copy > IPR_MAX_IOA_DUMP_SIZE) {
1784 sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
1788 /* Copy data from adapter to driver buffers */
1789 bytes_copied = ipr_sdt_copy(ioa_cfg, sdt_word,
1792 ioa_dump->hdr.len += bytes_copied;
1794 if (bytes_copied != bytes_to_copy) {
1795 driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
1802 dev_err(&ioa_cfg->pdev->dev, "Dump of IOA completed.\n");
1804 /* Update dump_header */
1805 driver_dump->hdr.len += ioa_dump->hdr.len;
1807 ioa_cfg->sdt_state = DUMP_OBTAINED;
1812 #define ipr_get_ioa_dump(ioa_cfg, dump) do { } while(0)
1816 * ipr_release_dump - Free adapter dump memory
1817 * @kref: kref struct
1822 static void ipr_release_dump(struct kref *kref)
1824 struct ipr_dump *dump = container_of(kref,struct ipr_dump,kref);
1825 struct ipr_ioa_cfg *ioa_cfg = dump->ioa_cfg;
1826 unsigned long lock_flags = 0;
1830 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1831 ioa_cfg->dump = NULL;
1832 ioa_cfg->sdt_state = INACTIVE;
1833 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1835 for (i = 0; i < dump->ioa_dump.next_page_index; i++)
1836 free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
1843 * ipr_worker_thread - Worker thread
1844 * @data: ioa config struct
1846 * Called at task level from a work thread. This function takes care
1847 * of adding and removing device from the mid-layer as configuration
1848 * changes are detected by the adapter.
1853 static void ipr_worker_thread(void *data)
1855 unsigned long lock_flags;
1856 struct ipr_resource_entry *res;
1857 struct scsi_device *sdev;
1858 struct ipr_dump *dump;
1859 struct ipr_ioa_cfg *ioa_cfg = data;
1860 u8 bus, target, lun;
1864 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1866 if (ioa_cfg->sdt_state == GET_DUMP) {
1867 dump = ioa_cfg->dump;
1869 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1872 kref_get(&dump->kref);
1873 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1874 ipr_get_ioa_dump(ioa_cfg, dump);
1875 kref_put(&dump->kref, ipr_release_dump);
1877 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1878 if (ioa_cfg->sdt_state == DUMP_OBTAINED)
1879 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
1880 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1887 if (!ioa_cfg->allow_cmds || !ioa_cfg->allow_ml_add_del) {
1888 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1892 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
1893 if (res->del_from_ml && res->sdev) {
1896 if (!scsi_device_get(sdev)) {
1898 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
1899 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1900 scsi_remove_device(sdev);
1901 scsi_device_put(sdev);
1902 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1909 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
1910 if (res->add_to_ml) {
1911 bus = res->cfgte.res_addr.bus;
1912 target = res->cfgte.res_addr.target;
1913 lun = res->cfgte.res_addr.lun;
1914 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1915 scsi_add_device(ioa_cfg->host, bus, target, lun);
1916 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1921 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1922 kobject_uevent(&ioa_cfg->host->shost_classdev.kobj, KOBJ_CHANGE, NULL);
1926 #ifdef CONFIG_SCSI_IPR_TRACE
1928 * ipr_read_trace - Dump the adapter trace
1929 * @kobj: kobject struct
1932 * @count: buffer size
1935 * number of bytes printed to buffer
1937 static ssize_t ipr_read_trace(struct kobject *kobj, char *buf,
1938 loff_t off, size_t count)
1940 struct class_device *cdev = container_of(kobj,struct class_device,kobj);
1941 struct Scsi_Host *shost = class_to_shost(cdev);
1942 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
1943 unsigned long lock_flags = 0;
1944 int size = IPR_TRACE_SIZE;
1945 char *src = (char *)ioa_cfg->trace;
1949 if (off + count > size) {
1954 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1955 memcpy(buf, &src[off], count);
1956 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1960 static struct bin_attribute ipr_trace_attr = {
1966 .read = ipr_read_trace,
1971 * ipr_show_fw_version - Show the firmware version
1972 * @class_dev: class device struct
1976 * number of bytes printed to buffer
1978 static ssize_t ipr_show_fw_version(struct class_device *class_dev, char *buf)
1980 struct Scsi_Host *shost = class_to_shost(class_dev);
1981 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
1982 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
1983 unsigned long lock_flags = 0;
1986 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1987 len = snprintf(buf, PAGE_SIZE, "%02X%02X%02X%02X\n",
1988 ucode_vpd->major_release, ucode_vpd->card_type,
1989 ucode_vpd->minor_release[0],
1990 ucode_vpd->minor_release[1]);
1991 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1995 static struct class_device_attribute ipr_fw_version_attr = {
1997 .name = "fw_version",
2000 .show = ipr_show_fw_version,
2004 * ipr_show_log_level - Show the adapter's error logging level
2005 * @class_dev: class device struct
2009 * number of bytes printed to buffer
2011 static ssize_t ipr_show_log_level(struct class_device *class_dev, char *buf)
2013 struct Scsi_Host *shost = class_to_shost(class_dev);
2014 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2015 unsigned long lock_flags = 0;
2018 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2019 len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->log_level);
2020 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2025 * ipr_store_log_level - Change the adapter's error logging level
2026 * @class_dev: class device struct
2030 * number of bytes printed to buffer
2032 static ssize_t ipr_store_log_level(struct class_device *class_dev,
2033 const char *buf, size_t count)
2035 struct Scsi_Host *shost = class_to_shost(class_dev);
2036 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2037 unsigned long lock_flags = 0;
2039 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2040 ioa_cfg->log_level = simple_strtoul(buf, NULL, 10);
2041 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2045 static struct class_device_attribute ipr_log_level_attr = {
2047 .name = "log_level",
2048 .mode = S_IRUGO | S_IWUSR,
2050 .show = ipr_show_log_level,
2051 .store = ipr_store_log_level
2055 * ipr_store_diagnostics - IOA Diagnostics interface
2056 * @class_dev: class_device struct
2058 * @count: buffer size
2060 * This function will reset the adapter and wait a reasonable
2061 * amount of time for any errors that the adapter might log.
2064 * count on success / other on failure
2066 static ssize_t ipr_store_diagnostics(struct class_device *class_dev,
2067 const char *buf, size_t count)
2069 struct Scsi_Host *shost = class_to_shost(class_dev);
2070 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2071 unsigned long lock_flags = 0;
2074 if (!capable(CAP_SYS_ADMIN))
2077 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2078 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2079 ioa_cfg->errors_logged = 0;
2080 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
2082 if (ioa_cfg->in_reset_reload) {
2083 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2084 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2086 /* Wait for a second for any errors to be logged */
2089 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2093 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2094 if (ioa_cfg->in_reset_reload || ioa_cfg->errors_logged)
2096 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2101 static struct class_device_attribute ipr_diagnostics_attr = {
2103 .name = "run_diagnostics",
2106 .store = ipr_store_diagnostics
2110 * ipr_store_reset_adapter - Reset the adapter
2111 * @class_dev: class_device struct
2113 * @count: buffer size
2115 * This function will reset the adapter.
2118 * count on success / other on failure
2120 static ssize_t ipr_store_reset_adapter(struct class_device *class_dev,
2121 const char *buf, size_t count)
2123 struct Scsi_Host *shost = class_to_shost(class_dev);
2124 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2125 unsigned long lock_flags;
2128 if (!capable(CAP_SYS_ADMIN))
2131 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2132 if (!ioa_cfg->in_reset_reload)
2133 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
2134 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2135 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2140 static struct class_device_attribute ipr_ioa_reset_attr = {
2142 .name = "reset_host",
2145 .store = ipr_store_reset_adapter
2149 * ipr_alloc_ucode_buffer - Allocates a microcode download buffer
2150 * @buf_len: buffer length
2152 * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
2153 * list to use for microcode download
2156 * pointer to sglist / NULL on failure
2158 static struct ipr_sglist *ipr_alloc_ucode_buffer(int buf_len)
2160 int sg_size, order, bsize_elem, num_elem, i, j;
2161 struct ipr_sglist *sglist;
2162 struct scatterlist *scatterlist;
2165 /* Get the minimum size per scatter/gather element */
2166 sg_size = buf_len / (IPR_MAX_SGLIST - 1);
2168 /* Get the actual size per element */
2169 order = get_order(sg_size);
2171 /* Determine the actual number of bytes per element */
2172 bsize_elem = PAGE_SIZE * (1 << order);
2174 /* Determine the actual number of sg entries needed */
2175 if (buf_len % bsize_elem)
2176 num_elem = (buf_len / bsize_elem) + 1;
2178 num_elem = buf_len / bsize_elem;
2180 /* Allocate a scatter/gather list for the DMA */
2181 sglist = kmalloc(sizeof(struct ipr_sglist) +
2182 (sizeof(struct scatterlist) * (num_elem - 1)),
2185 if (sglist == NULL) {
2190 memset(sglist, 0, sizeof(struct ipr_sglist) +
2191 (sizeof(struct scatterlist) * (num_elem - 1)));
2193 scatterlist = sglist->scatterlist;
2195 sglist->order = order;
2196 sglist->num_sg = num_elem;
2198 /* Allocate a bunch of sg elements */
2199 for (i = 0; i < num_elem; i++) {
2200 page = alloc_pages(GFP_KERNEL, order);
2204 /* Free up what we already allocated */
2205 for (j = i - 1; j >= 0; j--)
2206 __free_pages(scatterlist[j].page, order);
2211 scatterlist[i].page = page;
2218 * ipr_free_ucode_buffer - Frees a microcode download buffer
2219 * @p_dnld: scatter/gather list pointer
2221 * Free a DMA'able ucode download buffer previously allocated with
2222 * ipr_alloc_ucode_buffer
2227 static void ipr_free_ucode_buffer(struct ipr_sglist *sglist)
2231 for (i = 0; i < sglist->num_sg; i++)
2232 __free_pages(sglist->scatterlist[i].page, sglist->order);
2238 * ipr_copy_ucode_buffer - Copy user buffer to kernel buffer
2239 * @sglist: scatter/gather list pointer
2240 * @buffer: buffer pointer
2241 * @len: buffer length
2243 * Copy a microcode image from a user buffer into a buffer allocated by
2244 * ipr_alloc_ucode_buffer
2247 * 0 on success / other on failure
2249 static int ipr_copy_ucode_buffer(struct ipr_sglist *sglist,
2250 u8 *buffer, u32 len)
2252 int bsize_elem, i, result = 0;
2253 struct scatterlist *scatterlist;
2256 /* Determine the actual number of bytes per element */
2257 bsize_elem = PAGE_SIZE * (1 << sglist->order);
2259 scatterlist = sglist->scatterlist;
2261 for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) {
2262 kaddr = kmap(scatterlist[i].page);
2263 memcpy(kaddr, buffer, bsize_elem);
2264 kunmap(scatterlist[i].page);
2266 scatterlist[i].length = bsize_elem;
2274 if (len % bsize_elem) {
2275 kaddr = kmap(scatterlist[i].page);
2276 memcpy(kaddr, buffer, len % bsize_elem);
2277 kunmap(scatterlist[i].page);
2279 scatterlist[i].length = len % bsize_elem;
2282 sglist->buffer_len = len;
2287 * ipr_map_ucode_buffer - Map a microcode download buffer
2288 * @ipr_cmd: ipr command struct
2289 * @sglist: scatter/gather list
2290 * @len: total length of download buffer
2292 * Maps a microcode download scatter/gather list for DMA and
2296 * 0 on success / -EIO on failure
2298 static int ipr_map_ucode_buffer(struct ipr_cmnd *ipr_cmd,
2299 struct ipr_sglist *sglist, int len)
2301 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2302 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
2303 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
2304 struct scatterlist *scatterlist = sglist->scatterlist;
2307 ipr_cmd->dma_use_sg = pci_map_sg(ioa_cfg->pdev, scatterlist,
2308 sglist->num_sg, DMA_TO_DEVICE);
2310 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
2311 ioarcb->write_data_transfer_length = cpu_to_be32(len);
2312 ioarcb->write_ioadl_len =
2313 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
2315 for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
2316 ioadl[i].flags_and_data_len =
2317 cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(&scatterlist[i]));
2319 cpu_to_be32(sg_dma_address(&scatterlist[i]));
2322 if (likely(ipr_cmd->dma_use_sg)) {
2323 ioadl[i-1].flags_and_data_len |=
2324 cpu_to_be32(IPR_IOADL_FLAGS_LAST);
2327 dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
2335 * ipr_store_update_fw - Update the firmware on the adapter
2336 * @class_dev: class_device struct
2338 * @count: buffer size
2340 * This function will update the firmware on the adapter.
2343 * count on success / other on failure
2345 static ssize_t ipr_store_update_fw(struct class_device *class_dev,
2346 const char *buf, size_t count)
2348 struct Scsi_Host *shost = class_to_shost(class_dev);
2349 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2350 struct ipr_ucode_image_header *image_hdr;
2351 const struct firmware *fw_entry;
2352 struct ipr_sglist *sglist;
2353 unsigned long lock_flags;
2356 int len, result, dnld_size;
2358 if (!capable(CAP_SYS_ADMIN))
2361 len = snprintf(fname, 99, "%s", buf);
2362 fname[len-1] = '\0';
2364 if(request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
2365 dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
2369 image_hdr = (struct ipr_ucode_image_header *)fw_entry->data;
2371 if (be32_to_cpu(image_hdr->header_length) > fw_entry->size ||
2372 (ioa_cfg->vpd_cbs->page3_data.card_type &&
2373 ioa_cfg->vpd_cbs->page3_data.card_type != image_hdr->card_type)) {
2374 dev_err(&ioa_cfg->pdev->dev, "Invalid microcode buffer\n");
2375 release_firmware(fw_entry);
2379 src = (u8 *)image_hdr + be32_to_cpu(image_hdr->header_length);
2380 dnld_size = fw_entry->size - be32_to_cpu(image_hdr->header_length);
2381 sglist = ipr_alloc_ucode_buffer(dnld_size);
2384 dev_err(&ioa_cfg->pdev->dev, "Microcode buffer allocation failed\n");
2385 release_firmware(fw_entry);
2389 result = ipr_copy_ucode_buffer(sglist, src, dnld_size);
2392 dev_err(&ioa_cfg->pdev->dev,
2393 "Microcode buffer copy to DMA buffer failed\n");
2394 ipr_free_ucode_buffer(sglist);
2395 release_firmware(fw_entry);
2399 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2401 if (ioa_cfg->ucode_sglist) {
2402 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2403 dev_err(&ioa_cfg->pdev->dev,
2404 "Microcode download already in progress\n");
2405 ipr_free_ucode_buffer(sglist);
2406 release_firmware(fw_entry);
2410 ioa_cfg->ucode_sglist = sglist;
2411 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
2412 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2413 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2415 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2416 ioa_cfg->ucode_sglist = NULL;
2417 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2419 ipr_free_ucode_buffer(sglist);
2420 release_firmware(fw_entry);
2425 static struct class_device_attribute ipr_update_fw_attr = {
2427 .name = "update_fw",
2430 .store = ipr_store_update_fw
2433 static struct class_device_attribute *ipr_ioa_attrs[] = {
2434 &ipr_fw_version_attr,
2435 &ipr_log_level_attr,
2436 &ipr_diagnostics_attr,
2437 &ipr_ioa_reset_attr,
2438 &ipr_update_fw_attr,
2442 #ifdef CONFIG_SCSI_IPR_DUMP
2444 * ipr_read_dump - Dump the adapter
2445 * @kobj: kobject struct
2448 * @count: buffer size
2451 * number of bytes printed to buffer
2453 static ssize_t ipr_read_dump(struct kobject *kobj, char *buf,
2454 loff_t off, size_t count)
2456 struct class_device *cdev = container_of(kobj,struct class_device,kobj);
2457 struct Scsi_Host *shost = class_to_shost(cdev);
2458 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2459 struct ipr_dump *dump;
2460 unsigned long lock_flags = 0;
2465 if (!capable(CAP_SYS_ADMIN))
2468 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2469 dump = ioa_cfg->dump;
2471 if (ioa_cfg->sdt_state != DUMP_OBTAINED || !dump) {
2472 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2475 kref_get(&dump->kref);
2476 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2478 if (off > dump->driver_dump.hdr.len) {
2479 kref_put(&dump->kref, ipr_release_dump);
2483 if (off + count > dump->driver_dump.hdr.len) {
2484 count = dump->driver_dump.hdr.len - off;
2488 if (count && off < sizeof(dump->driver_dump)) {
2489 if (off + count > sizeof(dump->driver_dump))
2490 len = sizeof(dump->driver_dump) - off;
2493 src = (u8 *)&dump->driver_dump + off;
2494 memcpy(buf, src, len);
2500 off -= sizeof(dump->driver_dump);
2502 if (count && off < offsetof(struct ipr_ioa_dump, ioa_data)) {
2503 if (off + count > offsetof(struct ipr_ioa_dump, ioa_data))
2504 len = offsetof(struct ipr_ioa_dump, ioa_data) - off;
2507 src = (u8 *)&dump->ioa_dump + off;
2508 memcpy(buf, src, len);
2514 off -= offsetof(struct ipr_ioa_dump, ioa_data);
2517 if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
2518 len = PAGE_ALIGN(off) - off;
2521 src = (u8 *)dump->ioa_dump.ioa_data[(off & PAGE_MASK) >> PAGE_SHIFT];
2522 src += off & ~PAGE_MASK;
2523 memcpy(buf, src, len);
2529 kref_put(&dump->kref, ipr_release_dump);
2534 * ipr_alloc_dump - Prepare for adapter dump
2535 * @ioa_cfg: ioa config struct
2538 * 0 on success / other on failure
2540 static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
2542 struct ipr_dump *dump;
2543 unsigned long lock_flags = 0;
2546 dump = kmalloc(sizeof(struct ipr_dump), GFP_KERNEL);
2549 ipr_err("Dump memory allocation failed\n");
2553 memset(dump, 0, sizeof(struct ipr_dump));
2554 kref_init(&dump->kref);
2555 dump->ioa_cfg = ioa_cfg;
2557 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2559 if (INACTIVE != ioa_cfg->sdt_state) {
2560 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2565 ioa_cfg->dump = dump;
2566 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
2567 if (ioa_cfg->ioa_is_dead && !ioa_cfg->dump_taken) {
2568 ioa_cfg->dump_taken = 1;
2569 schedule_work(&ioa_cfg->work_q);
2571 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2578 * ipr_free_dump - Free adapter dump memory
2579 * @ioa_cfg: ioa config struct
2582 * 0 on success / other on failure
2584 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
2586 struct ipr_dump *dump;
2587 unsigned long lock_flags = 0;
2591 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2592 dump = ioa_cfg->dump;
2594 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2598 ioa_cfg->dump = NULL;
2599 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2601 kref_put(&dump->kref, ipr_release_dump);
2608 * ipr_write_dump - Setup dump state of adapter
2609 * @kobj: kobject struct
2612 * @count: buffer size
2615 * number of bytes printed to buffer
2617 static ssize_t ipr_write_dump(struct kobject *kobj, char *buf,
2618 loff_t off, size_t count)
2620 struct class_device *cdev = container_of(kobj,struct class_device,kobj);
2621 struct Scsi_Host *shost = class_to_shost(cdev);
2622 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2625 if (!capable(CAP_SYS_ADMIN))
2629 rc = ipr_alloc_dump(ioa_cfg);
2630 else if (buf[0] == '0')
2631 rc = ipr_free_dump(ioa_cfg);
2641 static struct bin_attribute ipr_dump_attr = {
2644 .mode = S_IRUSR | S_IWUSR,
2647 .read = ipr_read_dump,
2648 .write = ipr_write_dump
2651 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
2655 * ipr_change_queue_depth - Change the device's queue depth
2656 * @sdev: scsi device struct
2657 * @qdepth: depth to set
2662 static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth)
2664 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
2665 return sdev->queue_depth;
2669 * ipr_change_queue_type - Change the device's queue type
2670 * @dsev: scsi device struct
2671 * @tag_type: type of tags to use
2674 * actual queue type set
2676 static int ipr_change_queue_type(struct scsi_device *sdev, int tag_type)
2678 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
2679 struct ipr_resource_entry *res;
2680 unsigned long lock_flags = 0;
2682 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2683 res = (struct ipr_resource_entry *)sdev->hostdata;
2686 if (ipr_is_gscsi(res) && sdev->tagged_supported) {
2688 * We don't bother quiescing the device here since the
2689 * adapter firmware does it for us.
2691 scsi_set_tag_type(sdev, tag_type);
2694 scsi_activate_tcq(sdev, sdev->queue_depth);
2696 scsi_deactivate_tcq(sdev, sdev->queue_depth);
2702 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2707 * ipr_show_adapter_handle - Show the adapter's resource handle for this device
2708 * @dev: device struct
2712 * number of bytes printed to buffer
2714 static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribute *attr, char *buf)
2716 struct scsi_device *sdev = to_scsi_device(dev);
2717 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
2718 struct ipr_resource_entry *res;
2719 unsigned long lock_flags = 0;
2720 ssize_t len = -ENXIO;
2722 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2723 res = (struct ipr_resource_entry *)sdev->hostdata;
2725 len = snprintf(buf, PAGE_SIZE, "%08X\n", res->cfgte.res_handle);
2726 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2730 static struct device_attribute ipr_adapter_handle_attr = {
2732 .name = "adapter_handle",
2735 .show = ipr_show_adapter_handle
2738 static struct device_attribute *ipr_dev_attrs[] = {
2739 &ipr_adapter_handle_attr,
2744 * ipr_biosparam - Return the HSC mapping
2745 * @sdev: scsi device struct
2746 * @block_device: block device pointer
2747 * @capacity: capacity of the device
2748 * @parm: Array containing returned HSC values.
2750 * This function generates the HSC parms that fdisk uses.
2751 * We want to make sure we return something that places partitions
2752 * on 4k boundaries for best performance with the IOA.
2757 static int ipr_biosparam(struct scsi_device *sdev,
2758 struct block_device *block_device,
2759 sector_t capacity, int *parm)
2767 cylinders = capacity;
2768 sector_div(cylinders, (128 * 32));
2773 parm[2] = cylinders;
2779 * ipr_slave_destroy - Unconfigure a SCSI device
2780 * @sdev: scsi device struct
2785 static void ipr_slave_destroy(struct scsi_device *sdev)
2787 struct ipr_resource_entry *res;
2788 struct ipr_ioa_cfg *ioa_cfg;
2789 unsigned long lock_flags = 0;
2791 ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
2793 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2794 res = (struct ipr_resource_entry *) sdev->hostdata;
2796 sdev->hostdata = NULL;
2799 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2803 * ipr_slave_configure - Configure a SCSI device
2804 * @sdev: scsi device struct
2806 * This function configures the specified scsi device.
2811 static int ipr_slave_configure(struct scsi_device *sdev)
2813 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
2814 struct ipr_resource_entry *res;
2815 unsigned long lock_flags = 0;
2817 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2818 res = sdev->hostdata;
2820 if (ipr_is_af_dasd_device(res))
2821 sdev->type = TYPE_RAID;
2822 if (ipr_is_af_dasd_device(res) || ipr_is_ioa_resource(res))
2823 sdev->scsi_level = 4;
2824 if (ipr_is_vset_device(res)) {
2825 sdev->timeout = IPR_VSET_RW_TIMEOUT;
2826 blk_queue_max_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
2828 if (IPR_IS_DASD_DEVICE(res->cfgte.std_inq_data))
2829 sdev->allow_restart = 1;
2830 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
2832 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2837 * ipr_slave_alloc - Prepare for commands to a device.
2838 * @sdev: scsi device struct
2840 * This function saves a pointer to the resource entry
2841 * in the scsi device struct if the device exists. We
2842 * can then use this pointer in ipr_queuecommand when
2843 * handling new commands.
2848 static int ipr_slave_alloc(struct scsi_device *sdev)
2850 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
2851 struct ipr_resource_entry *res;
2852 unsigned long lock_flags;
2854 sdev->hostdata = NULL;
2856 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2858 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
2859 if ((res->cfgte.res_addr.bus == sdev->channel) &&
2860 (res->cfgte.res_addr.target == sdev->id) &&
2861 (res->cfgte.res_addr.lun == sdev->lun)) {
2865 sdev->hostdata = res;
2866 res->needs_sync_complete = 1;
2871 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2877 * ipr_eh_host_reset - Reset the host adapter
2878 * @scsi_cmd: scsi command struct
2883 static int __ipr_eh_host_reset(struct scsi_cmnd * scsi_cmd)
2885 struct ipr_ioa_cfg *ioa_cfg;
2889 ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
2891 dev_err(&ioa_cfg->pdev->dev,
2892 "Adapter being reset as a result of error recovery.\n");
2894 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2895 ioa_cfg->sdt_state = GET_DUMP;
2897 rc = ipr_reset_reload(ioa_cfg, IPR_SHUTDOWN_ABBREV);
2903 static int ipr_eh_host_reset(struct scsi_cmnd * cmd)
2907 spin_lock_irq(cmd->device->host->host_lock);
2908 rc = __ipr_eh_host_reset(cmd);
2909 spin_unlock_irq(cmd->device->host->host_lock);
2915 * ipr_eh_dev_reset - Reset the device
2916 * @scsi_cmd: scsi command struct
2918 * This function issues a device reset to the affected device.
2919 * A LUN reset will be sent to the device first. If that does
2920 * not work, a target reset will be sent.
2925 static int __ipr_eh_dev_reset(struct scsi_cmnd * scsi_cmd)
2927 struct ipr_cmnd *ipr_cmd;
2928 struct ipr_ioa_cfg *ioa_cfg;
2929 struct ipr_resource_entry *res;
2930 struct ipr_cmd_pkt *cmd_pkt;
2934 ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
2935 res = scsi_cmd->device->hostdata;
2937 if (!res || (!ipr_is_gscsi(res) && !ipr_is_vset_device(res)))
2941 * If we are currently going through reset/reload, return failed. This will force the
2942 * mid-layer to call ipr_eh_host_reset, which will then go to sleep and wait for the
2945 if (ioa_cfg->in_reset_reload)
2947 if (ioa_cfg->ioa_is_dead)
2950 list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
2951 if (ipr_cmd->ioarcb.res_handle == res->cfgte.res_handle) {
2952 if (ipr_cmd->scsi_cmd)
2953 ipr_cmd->done = ipr_scsi_eh_done;
2957 res->resetting_device = 1;
2959 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
2961 ipr_cmd->ioarcb.res_handle = res->cfgte.res_handle;
2962 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
2963 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
2964 cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
2966 ipr_sdev_err(scsi_cmd->device, "Resetting device\n");
2967 ipr_send_blocking_cmd(ipr_cmd, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
2969 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
2971 res->resetting_device = 0;
2973 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
2976 return (IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS);
2979 static int ipr_eh_dev_reset(struct scsi_cmnd * cmd)
2983 spin_lock_irq(cmd->device->host->host_lock);
2984 rc = __ipr_eh_dev_reset(cmd);
2985 spin_unlock_irq(cmd->device->host->host_lock);
2991 * ipr_bus_reset_done - Op done function for bus reset.
2992 * @ipr_cmd: ipr command struct
2994 * This function is the op done function for a bus reset
2999 static void ipr_bus_reset_done(struct ipr_cmnd *ipr_cmd)
3001 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
3002 struct ipr_resource_entry *res;
3005 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3006 if (!memcmp(&res->cfgte.res_handle, &ipr_cmd->ioarcb.res_handle,
3007 sizeof(res->cfgte.res_handle))) {
3008 scsi_report_bus_reset(ioa_cfg->host, res->cfgte.res_addr.bus);
3014 * If abort has not completed, indicate the reset has, else call the
3015 * abort's done function to wake the sleeping eh thread
3017 if (ipr_cmd->sibling->sibling)
3018 ipr_cmd->sibling->sibling = NULL;
3020 ipr_cmd->sibling->done(ipr_cmd->sibling);
3022 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
3027 * ipr_abort_timeout - An abort task has timed out
3028 * @ipr_cmd: ipr command struct
3030 * This function handles when an abort task times out. If this
3031 * happens we issue a bus reset since we have resources tied
3032 * up that must be freed before returning to the midlayer.
3037 static void ipr_abort_timeout(struct ipr_cmnd *ipr_cmd)
3039 struct ipr_cmnd *reset_cmd;
3040 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
3041 struct ipr_cmd_pkt *cmd_pkt;
3042 unsigned long lock_flags = 0;
3045 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3046 if (ipr_cmd->completion.done || ioa_cfg->in_reset_reload) {
3047 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3051 ipr_sdev_err(ipr_cmd->u.sdev, "Abort timed out. Resetting bus\n");
3052 reset_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
3053 ipr_cmd->sibling = reset_cmd;
3054 reset_cmd->sibling = ipr_cmd;
3055 reset_cmd->ioarcb.res_handle = ipr_cmd->ioarcb.res_handle;
3056 cmd_pkt = &reset_cmd->ioarcb.cmd_pkt;
3057 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
3058 cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
3059 cmd_pkt->cdb[2] = IPR_RESET_TYPE_SELECT | IPR_BUS_RESET;
3061 ipr_do_req(reset_cmd, ipr_bus_reset_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
3062 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3067 * ipr_cancel_op - Cancel specified op
3068 * @scsi_cmd: scsi command struct
3070 * This function cancels specified op.
3075 static int ipr_cancel_op(struct scsi_cmnd * scsi_cmd)
3077 struct ipr_cmnd *ipr_cmd;
3078 struct ipr_ioa_cfg *ioa_cfg;
3079 struct ipr_resource_entry *res;
3080 struct ipr_cmd_pkt *cmd_pkt;
3085 ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
3086 res = scsi_cmd->device->hostdata;
3088 /* If we are currently going through reset/reload, return failed.
3089 * This will force the mid-layer to call ipr_eh_host_reset,
3090 * which will then go to sleep and wait for the reset to complete
3092 if (ioa_cfg->in_reset_reload || ioa_cfg->ioa_is_dead)
3094 if (!res || (!ipr_is_gscsi(res) && !ipr_is_vset_device(res)))
3097 list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
3098 if (ipr_cmd->scsi_cmd == scsi_cmd) {
3099 ipr_cmd->done = ipr_scsi_eh_done;
3108 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
3109 ipr_cmd->ioarcb.res_handle = res->cfgte.res_handle;
3110 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
3111 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
3112 cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
3113 ipr_cmd->u.sdev = scsi_cmd->device;
3115 ipr_sdev_err(scsi_cmd->device, "Aborting command: %02X\n", scsi_cmd->cmnd[0]);
3116 ipr_send_blocking_cmd(ipr_cmd, ipr_abort_timeout, IPR_CANCEL_ALL_TIMEOUT);
3117 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
3120 * If the abort task timed out and we sent a bus reset, we will get
3121 * one the following responses to the abort
3123 if (ioasc == IPR_IOASC_BUS_WAS_RESET || ioasc == IPR_IOASC_SYNC_REQUIRED) {
3128 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
3129 res->needs_sync_complete = 1;
3132 return (IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS);
3136 * ipr_eh_abort - Abort a single op
3137 * @scsi_cmd: scsi command struct
3142 static int ipr_eh_abort(struct scsi_cmnd * scsi_cmd)
3144 unsigned long flags;
3149 spin_lock_irqsave(scsi_cmd->device->host->host_lock, flags);
3150 rc = ipr_cancel_op(scsi_cmd);
3151 spin_unlock_irqrestore(scsi_cmd->device->host->host_lock, flags);
3158 * ipr_handle_other_interrupt - Handle "other" interrupts
3159 * @ioa_cfg: ioa config struct
3160 * @int_reg: interrupt register
3163 * IRQ_NONE / IRQ_HANDLED
3165 static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
3166 volatile u32 int_reg)
3168 irqreturn_t rc = IRQ_HANDLED;
3170 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
3171 /* Mask the interrupt */
3172 writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.set_interrupt_mask_reg);
3174 /* Clear the interrupt */
3175 writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.clr_interrupt_reg);
3176 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
3178 list_del(&ioa_cfg->reset_cmd->queue);
3179 del_timer(&ioa_cfg->reset_cmd->timer);
3180 ipr_reset_ioa_job(ioa_cfg->reset_cmd);
3182 if (int_reg & IPR_PCII_IOA_UNIT_CHECKED)
3183 ioa_cfg->ioa_unit_checked = 1;
3185 dev_err(&ioa_cfg->pdev->dev,
3186 "Permanent IOA failure. 0x%08X\n", int_reg);
3188 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
3189 ioa_cfg->sdt_state = GET_DUMP;
3191 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
3192 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3199 * ipr_isr - Interrupt service routine
3201 * @devp: pointer to ioa config struct
3202 * @regs: pt_regs struct
3205 * IRQ_NONE / IRQ_HANDLED
3207 static irqreturn_t ipr_isr(int irq, void *devp, struct pt_regs *regs)
3209 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
3210 unsigned long lock_flags = 0;
3211 volatile u32 int_reg, int_mask_reg;
3214 struct ipr_cmnd *ipr_cmd;
3215 irqreturn_t rc = IRQ_NONE;
3217 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3219 /* If interrupts are disabled, ignore the interrupt */
3220 if (!ioa_cfg->allow_interrupts) {
3221 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3225 int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
3226 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
3228 /* If an interrupt on the adapter did not occur, ignore it */
3229 if (unlikely((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0)) {
3230 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3237 while ((be32_to_cpu(*ioa_cfg->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
3238 ioa_cfg->toggle_bit) {
3240 cmd_index = (be32_to_cpu(*ioa_cfg->hrrq_curr) &
3241 IPR_HRRQ_REQ_RESP_HANDLE_MASK) >> IPR_HRRQ_REQ_RESP_HANDLE_SHIFT;
3243 if (unlikely(cmd_index >= IPR_NUM_CMD_BLKS)) {
3244 ioa_cfg->errors_logged++;
3245 dev_err(&ioa_cfg->pdev->dev, "Invalid response handle from IOA\n");
3247 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
3248 ioa_cfg->sdt_state = GET_DUMP;
3250 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3251 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3255 ipr_cmd = ioa_cfg->ipr_cmnd_list[cmd_index];
3257 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
3259 ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, ioasc);
3261 list_del(&ipr_cmd->queue);
3262 del_timer(&ipr_cmd->timer);
3263 ipr_cmd->done(ipr_cmd);
3267 if (ioa_cfg->hrrq_curr < ioa_cfg->hrrq_end) {
3268 ioa_cfg->hrrq_curr++;
3270 ioa_cfg->hrrq_curr = ioa_cfg->hrrq_start;
3271 ioa_cfg->toggle_bit ^= 1u;
3275 if (ipr_cmd != NULL) {
3276 /* Clear the PCI interrupt */
3277 writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg);
3278 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
3283 if (unlikely(rc == IRQ_NONE))
3284 rc = ipr_handle_other_interrupt(ioa_cfg, int_reg);
3286 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3291 * ipr_build_ioadl - Build a scatter/gather list and map the buffer
3292 * @ioa_cfg: ioa config struct
3293 * @ipr_cmd: ipr command struct
3296 * 0 on success / -1 on failure
3298 static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
3299 struct ipr_cmnd *ipr_cmd)
3302 struct scatterlist *sglist;
3304 u32 ioadl_flags = 0;
3305 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
3306 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3307 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
3309 length = scsi_cmd->request_bufflen;
3314 if (scsi_cmd->use_sg) {
3315 ipr_cmd->dma_use_sg = pci_map_sg(ioa_cfg->pdev,
3316 scsi_cmd->request_buffer,
3318 scsi_cmd->sc_data_direction);
3320 if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
3321 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
3322 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3323 ioarcb->write_data_transfer_length = cpu_to_be32(length);
3324 ioarcb->write_ioadl_len =
3325 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
3326 } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) {
3327 ioadl_flags = IPR_IOADL_FLAGS_READ;
3328 ioarcb->read_data_transfer_length = cpu_to_be32(length);
3329 ioarcb->read_ioadl_len =
3330 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
3333 sglist = scsi_cmd->request_buffer;
3335 for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
3336 ioadl[i].flags_and_data_len =
3337 cpu_to_be32(ioadl_flags | sg_dma_len(&sglist[i]));
3339 cpu_to_be32(sg_dma_address(&sglist[i]));
3342 if (likely(ipr_cmd->dma_use_sg)) {
3343 ioadl[i-1].flags_and_data_len |=
3344 cpu_to_be32(IPR_IOADL_FLAGS_LAST);
3347 dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
3349 if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
3350 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
3351 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3352 ioarcb->write_data_transfer_length = cpu_to_be32(length);
3353 ioarcb->write_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
3354 } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) {
3355 ioadl_flags = IPR_IOADL_FLAGS_READ;
3356 ioarcb->read_data_transfer_length = cpu_to_be32(length);
3357 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
3360 ipr_cmd->dma_handle = pci_map_single(ioa_cfg->pdev,
3361 scsi_cmd->request_buffer, length,
3362 scsi_cmd->sc_data_direction);
3364 if (likely(!pci_dma_mapping_error(ipr_cmd->dma_handle))) {
3365 ipr_cmd->dma_use_sg = 1;
3366 ioadl[0].flags_and_data_len =
3367 cpu_to_be32(ioadl_flags | length | IPR_IOADL_FLAGS_LAST);
3368 ioadl[0].address = cpu_to_be32(ipr_cmd->dma_handle);
3371 dev_err(&ioa_cfg->pdev->dev, "pci_map_single failed!\n");
3378 * ipr_get_task_attributes - Translate SPI Q-Tag to task attributes
3379 * @scsi_cmd: scsi command struct
3384 static u8 ipr_get_task_attributes(struct scsi_cmnd *scsi_cmd)
3387 u8 rc = IPR_FLAGS_LO_UNTAGGED_TASK;
3389 if (scsi_populate_tag_msg(scsi_cmd, tag)) {
3391 case MSG_SIMPLE_TAG:
3392 rc = IPR_FLAGS_LO_SIMPLE_TASK;
3395 rc = IPR_FLAGS_LO_HEAD_OF_Q_TASK;
3397 case MSG_ORDERED_TAG:
3398 rc = IPR_FLAGS_LO_ORDERED_TASK;
3407 * ipr_erp_done - Process completion of ERP for a device
3408 * @ipr_cmd: ipr command struct
3410 * This function copies the sense buffer into the scsi_cmd
3411 * struct and pushes the scsi_done function.
3416 static void ipr_erp_done(struct ipr_cmnd *ipr_cmd)
3418 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
3419 struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
3420 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
3421 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
3423 if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
3424 scsi_cmd->result |= (DID_ERROR << 16);
3425 ipr_sdev_err(scsi_cmd->device,
3426 "Request Sense failed with IOASC: 0x%08X\n", ioasc);
3428 memcpy(scsi_cmd->sense_buffer, ipr_cmd->sense_buffer,
3429 SCSI_SENSE_BUFFERSIZE);
3433 res->needs_sync_complete = 1;
3436 ipr_unmap_sglist(ioa_cfg, ipr_cmd);
3437 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
3438 scsi_cmd->scsi_done(scsi_cmd);
3442 * ipr_reinit_ipr_cmnd_for_erp - Re-initialize a cmnd block to be used for ERP
3443 * @ipr_cmd: ipr command struct
3448 static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
3450 struct ipr_ioarcb *ioarcb;
3451 struct ipr_ioasa *ioasa;
3453 ioarcb = &ipr_cmd->ioarcb;
3454 ioasa = &ipr_cmd->ioasa;
3456 memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
3457 ioarcb->write_data_transfer_length = 0;
3458 ioarcb->read_data_transfer_length = 0;
3459 ioarcb->write_ioadl_len = 0;
3460 ioarcb->read_ioadl_len = 0;
3462 ioasa->residual_data_len = 0;
3466 * ipr_erp_request_sense - Send request sense to a device
3467 * @ipr_cmd: ipr command struct
3469 * This function sends a request sense to a device as a result
3470 * of a check condition.
3475 static void ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
3477 struct ipr_cmd_pkt *cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
3478 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
3480 if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
3481 ipr_erp_done(ipr_cmd);
3485 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
3487 cmd_pkt->request_type = IPR_RQTYPE_SCSICDB;
3488 cmd_pkt->cdb[0] = REQUEST_SENSE;
3489 cmd_pkt->cdb[4] = SCSI_SENSE_BUFFERSIZE;
3490 cmd_pkt->flags_hi |= IPR_FLAGS_HI_SYNC_OVERRIDE;
3491 cmd_pkt->flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
3492 cmd_pkt->timeout = cpu_to_be16(IPR_REQUEST_SENSE_TIMEOUT / HZ);
3494 ipr_cmd->ioadl[0].flags_and_data_len =
3495 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | SCSI_SENSE_BUFFERSIZE);
3496 ipr_cmd->ioadl[0].address =
3497 cpu_to_be32(ipr_cmd->sense_buffer_dma);
3499 ipr_cmd->ioarcb.read_ioadl_len =
3500 cpu_to_be32(sizeof(struct ipr_ioadl_desc));
3501 ipr_cmd->ioarcb.read_data_transfer_length =
3502 cpu_to_be32(SCSI_SENSE_BUFFERSIZE);
3504 ipr_do_req(ipr_cmd, ipr_erp_done, ipr_timeout,
3505 IPR_REQUEST_SENSE_TIMEOUT * 2);
3509 * ipr_erp_cancel_all - Send cancel all to a device
3510 * @ipr_cmd: ipr command struct
3512 * This function sends a cancel all to a device to clear the
3513 * queue. If we are running TCQ on the device, QERR is set to 1,
3514 * which means all outstanding ops have been dropped on the floor.
3515 * Cancel all will return them to us.
3520 static void ipr_erp_cancel_all(struct ipr_cmnd *ipr_cmd)
3522 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
3523 struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
3524 struct ipr_cmd_pkt *cmd_pkt;
3528 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
3530 if (!scsi_get_tag_type(scsi_cmd->device)) {
3531 ipr_erp_request_sense(ipr_cmd);
3535 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
3536 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
3537 cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
3539 ipr_do_req(ipr_cmd, ipr_erp_request_sense, ipr_timeout,
3540 IPR_CANCEL_ALL_TIMEOUT);
3544 * ipr_dump_ioasa - Dump contents of IOASA
3545 * @ioa_cfg: ioa config struct
3546 * @ipr_cmd: ipr command struct
3548 * This function is invoked by the interrupt handler when ops
3549 * fail. It will log the IOASA if appropriate. Only called
3555 static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg,
3556 struct ipr_cmnd *ipr_cmd)
3561 struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
3562 __be32 *ioasa_data = (__be32 *)ioasa;
3565 ioasc = be32_to_cpu(ioasa->ioasc) & IPR_IOASC_IOASC_MASK;
3570 if (ioa_cfg->log_level < IPR_DEFAULT_LOG_LEVEL)
3573 error_index = ipr_get_error(ioasc);
3575 if (ioa_cfg->log_level < IPR_MAX_LOG_LEVEL) {
3576 /* Don't log an error if the IOA already logged one */
3577 if (ioasa->ilid != 0)
3580 if (ipr_error_table[error_index].log_ioasa == 0)
3584 ipr_sdev_err(ipr_cmd->scsi_cmd->device, "%s\n",
3585 ipr_error_table[error_index].error);
3587 if ((ioasa->u.gpdd.end_state <= ARRAY_SIZE(ipr_gpdd_dev_end_states)) &&
3588 (ioasa->u.gpdd.bus_phase <= ARRAY_SIZE(ipr_gpdd_dev_bus_phases))) {
3589 ipr_sdev_err(ipr_cmd->scsi_cmd->device,
3590 "Device End state: %s Phase: %s\n",
3591 ipr_gpdd_dev_end_states[ioasa->u.gpdd.end_state],
3592 ipr_gpdd_dev_bus_phases[ioasa->u.gpdd.bus_phase]);
3595 if (sizeof(struct ipr_ioasa) < be16_to_cpu(ioasa->ret_stat_len))
3596 data_len = sizeof(struct ipr_ioasa);
3598 data_len = be16_to_cpu(ioasa->ret_stat_len);
3600 ipr_err("IOASA Dump:\n");
3602 for (i = 0; i < data_len / 4; i += 4) {
3603 ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
3604 be32_to_cpu(ioasa_data[i]),
3605 be32_to_cpu(ioasa_data[i+1]),
3606 be32_to_cpu(ioasa_data[i+2]),
3607 be32_to_cpu(ioasa_data[i+3]));
3612 * ipr_gen_sense - Generate SCSI sense data from an IOASA
3614 * @sense_buf: sense data buffer
3619 static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
3622 u8 *sense_buf = ipr_cmd->scsi_cmd->sense_buffer;
3623 struct ipr_resource_entry *res = ipr_cmd->scsi_cmd->device->hostdata;
3624 struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
3625 u32 ioasc = be32_to_cpu(ioasa->ioasc);
3627 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
3629 if (ioasc >= IPR_FIRST_DRIVER_IOASC)
3632 ipr_cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
3634 if (ipr_is_vset_device(res) &&
3635 ioasc == IPR_IOASC_MED_DO_NOT_REALLOC &&
3636 ioasa->u.vset.failing_lba_hi != 0) {
3637 sense_buf[0] = 0x72;
3638 sense_buf[1] = IPR_IOASC_SENSE_KEY(ioasc);
3639 sense_buf[2] = IPR_IOASC_SENSE_CODE(ioasc);
3640 sense_buf[3] = IPR_IOASC_SENSE_QUAL(ioasc);
3644 sense_buf[9] = 0x0A;
3645 sense_buf[10] = 0x80;
3647 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_hi);
3649 sense_buf[12] = (failing_lba & 0xff000000) >> 24;
3650 sense_buf[13] = (failing_lba & 0x00ff0000) >> 16;
3651 sense_buf[14] = (failing_lba & 0x0000ff00) >> 8;
3652 sense_buf[15] = failing_lba & 0x000000ff;
3654 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
3656 sense_buf[16] = (failing_lba & 0xff000000) >> 24;
3657 sense_buf[17] = (failing_lba & 0x00ff0000) >> 16;
3658 sense_buf[18] = (failing_lba & 0x0000ff00) >> 8;
3659 sense_buf[19] = failing_lba & 0x000000ff;
3661 sense_buf[0] = 0x70;
3662 sense_buf[2] = IPR_IOASC_SENSE_KEY(ioasc);
3663 sense_buf[12] = IPR_IOASC_SENSE_CODE(ioasc);
3664 sense_buf[13] = IPR_IOASC_SENSE_QUAL(ioasc);
3666 /* Illegal request */
3667 if ((IPR_IOASC_SENSE_KEY(ioasc) == 0x05) &&
3668 (be32_to_cpu(ioasa->ioasc_specific) & IPR_FIELD_POINTER_VALID)) {
3669 sense_buf[7] = 10; /* additional length */
3671 /* IOARCB was in error */
3672 if (IPR_IOASC_SENSE_CODE(ioasc) == 0x24)
3673 sense_buf[15] = 0xC0;
3674 else /* Parameter data was invalid */
3675 sense_buf[15] = 0x80;
3678 ((IPR_FIELD_POINTER_MASK &
3679 be32_to_cpu(ioasa->ioasc_specific)) >> 8) & 0xff;
3681 (IPR_FIELD_POINTER_MASK &
3682 be32_to_cpu(ioasa->ioasc_specific)) & 0xff;
3684 if (ioasc == IPR_IOASC_MED_DO_NOT_REALLOC) {
3685 if (ipr_is_vset_device(res))
3686 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
3688 failing_lba = be32_to_cpu(ioasa->u.dasd.failing_lba);
3690 sense_buf[0] |= 0x80; /* Or in the Valid bit */
3691 sense_buf[3] = (failing_lba & 0xff000000) >> 24;
3692 sense_buf[4] = (failing_lba & 0x00ff0000) >> 16;
3693 sense_buf[5] = (failing_lba & 0x0000ff00) >> 8;
3694 sense_buf[6] = failing_lba & 0x000000ff;
3697 sense_buf[7] = 6; /* additional length */
3703 * ipr_erp_start - Process an error response for a SCSI op
3704 * @ioa_cfg: ioa config struct
3705 * @ipr_cmd: ipr command struct
3707 * This function determines whether or not to initiate ERP
3708 * on the affected device.
3713 static void ipr_erp_start(struct ipr_ioa_cfg *ioa_cfg,
3714 struct ipr_cmnd *ipr_cmd)
3716 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
3717 struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
3718 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
3721 ipr_scsi_eh_done(ipr_cmd);
3725 if (ipr_is_gscsi(res))
3726 ipr_dump_ioasa(ioa_cfg, ipr_cmd);
3728 ipr_gen_sense(ipr_cmd);
3730 switch (ioasc & IPR_IOASC_IOASC_MASK) {
3731 case IPR_IOASC_ABORTED_CMD_TERM_BY_HOST:
3732 scsi_cmd->result |= (DID_IMM_RETRY << 16);
3734 case IPR_IOASC_IR_RESOURCE_HANDLE:
3735 scsi_cmd->result |= (DID_NO_CONNECT << 16);
3737 case IPR_IOASC_HW_SEL_TIMEOUT:
3738 scsi_cmd->result |= (DID_NO_CONNECT << 16);
3739 res->needs_sync_complete = 1;
3741 case IPR_IOASC_SYNC_REQUIRED:
3743 res->needs_sync_complete = 1;
3744 scsi_cmd->result |= (DID_IMM_RETRY << 16);
3746 case IPR_IOASC_MED_DO_NOT_REALLOC: /* prevent retries */
3747 scsi_cmd->result |= (DID_PASSTHROUGH << 16);
3749 case IPR_IOASC_BUS_WAS_RESET:
3750 case IPR_IOASC_BUS_WAS_RESET_BY_OTHER:
3752 * Report the bus reset and ask for a retry. The device
3753 * will give CC/UA the next command.
3755 if (!res->resetting_device)
3756 scsi_report_bus_reset(ioa_cfg->host, scsi_cmd->device->channel);
3757 scsi_cmd->result |= (DID_ERROR << 16);
3758 res->needs_sync_complete = 1;
3760 case IPR_IOASC_HW_DEV_BUS_STATUS:
3761 scsi_cmd->result |= IPR_IOASC_SENSE_STATUS(ioasc);
3762 if (IPR_IOASC_SENSE_STATUS(ioasc) == SAM_STAT_CHECK_CONDITION) {
3763 ipr_erp_cancel_all(ipr_cmd);
3766 res->needs_sync_complete = 1;
3768 case IPR_IOASC_NR_INIT_CMD_REQUIRED:
3771 scsi_cmd->result |= (DID_ERROR << 16);
3772 if (!ipr_is_vset_device(res))
3773 res->needs_sync_complete = 1;
3777 ipr_unmap_sglist(ioa_cfg, ipr_cmd);
3778 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
3779 scsi_cmd->scsi_done(scsi_cmd);
3783 * ipr_scsi_done - mid-layer done function
3784 * @ipr_cmd: ipr command struct
3786 * This function is invoked by the interrupt handler for
3787 * ops generated by the SCSI mid-layer
3792 static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd)
3794 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
3795 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
3796 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
3798 scsi_cmd->resid = be32_to_cpu(ipr_cmd->ioasa.residual_data_len);
3800 if (likely(IPR_IOASC_SENSE_KEY(ioasc) == 0)) {
3801 ipr_unmap_sglist(ioa_cfg, ipr_cmd);
3802 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
3803 scsi_cmd->scsi_done(scsi_cmd);
3805 ipr_erp_start(ioa_cfg, ipr_cmd);
3809 * ipr_save_ioafp_mode_select - Save adapters mode select data
3810 * @ioa_cfg: ioa config struct
3811 * @scsi_cmd: scsi command struct
3813 * This function saves mode select data for the adapter to
3814 * use following an adapter reset.
3817 * 0 on success / SCSI_MLQUEUE_HOST_BUSY on failure
3819 static int ipr_save_ioafp_mode_select(struct ipr_ioa_cfg *ioa_cfg,
3820 struct scsi_cmnd *scsi_cmd)
3822 if (!ioa_cfg->saved_mode_pages) {
3823 ioa_cfg->saved_mode_pages = kmalloc(sizeof(struct ipr_mode_pages),
3825 if (!ioa_cfg->saved_mode_pages) {
3826 dev_err(&ioa_cfg->pdev->dev,
3827 "IOA mode select buffer allocation failed\n");
3828 return SCSI_MLQUEUE_HOST_BUSY;
3832 memcpy(ioa_cfg->saved_mode_pages, scsi_cmd->buffer, scsi_cmd->cmnd[4]);
3833 ioa_cfg->saved_mode_page_len = scsi_cmd->cmnd[4];
3838 * ipr_queuecommand - Queue a mid-layer request
3839 * @scsi_cmd: scsi command struct
3840 * @done: done function
3842 * This function queues a request generated by the mid-layer.
3846 * SCSI_MLQUEUE_DEVICE_BUSY if device is busy
3847 * SCSI_MLQUEUE_HOST_BUSY if host is busy
3849 static int ipr_queuecommand(struct scsi_cmnd *scsi_cmd,
3850 void (*done) (struct scsi_cmnd *))
3852 struct ipr_ioa_cfg *ioa_cfg;
3853 struct ipr_resource_entry *res;
3854 struct ipr_ioarcb *ioarcb;
3855 struct ipr_cmnd *ipr_cmd;
3858 scsi_cmd->scsi_done = done;
3859 ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
3860 res = scsi_cmd->device->hostdata;
3861 scsi_cmd->result = (DID_OK << 16);
3864 * We are currently blocking all devices due to a host reset
3865 * We have told the host to stop giving us new requests, but
3866 * ERP ops don't count. FIXME
3868 if (unlikely(!ioa_cfg->allow_cmds && !ioa_cfg->ioa_is_dead))
3869 return SCSI_MLQUEUE_HOST_BUSY;
3872 * FIXME - Create scsi_set_host_offline interface
3873 * and the ioa_is_dead check can be removed
3875 if (unlikely(ioa_cfg->ioa_is_dead || !res)) {
3876 memset(scsi_cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
3877 scsi_cmd->result = (DID_NO_CONNECT << 16);
3878 scsi_cmd->scsi_done(scsi_cmd);
3882 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
3883 ioarcb = &ipr_cmd->ioarcb;
3884 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
3886 memcpy(ioarcb->cmd_pkt.cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);
3887 ipr_cmd->scsi_cmd = scsi_cmd;
3888 ioarcb->res_handle = res->cfgte.res_handle;
3889 ipr_cmd->done = ipr_scsi_done;
3890 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_PHYS_LOC(res->cfgte.res_addr));
3892 if (ipr_is_gscsi(res) || ipr_is_vset_device(res)) {
3893 if (scsi_cmd->underflow == 0)
3894 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
3896 if (res->needs_sync_complete) {
3897 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_SYNC_COMPLETE;
3898 res->needs_sync_complete = 0;
3901 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
3902 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
3903 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_ALIGNED_BFR;
3904 ioarcb->cmd_pkt.flags_lo |= ipr_get_task_attributes(scsi_cmd);
3907 if (scsi_cmd->cmnd[0] >= 0xC0 &&
3908 (!ipr_is_gscsi(res) || scsi_cmd->cmnd[0] == IPR_QUERY_RSRC_STATE))
3909 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
3911 if (ipr_is_ioa_resource(res) && scsi_cmd->cmnd[0] == MODE_SELECT)
3912 rc = ipr_save_ioafp_mode_select(ioa_cfg, scsi_cmd);
3914 if (likely(rc == 0))
3915 rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
3917 if (likely(rc == 0)) {
3919 writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
3920 ioa_cfg->regs.ioarrin_reg);
3922 list_move_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
3923 return SCSI_MLQUEUE_HOST_BUSY;
3930 * ipr_info - Get information about the card/driver
3931 * @scsi_host: scsi host struct
3934 * pointer to buffer with description string
3936 static const char * ipr_ioa_info(struct Scsi_Host *host)
3938 static char buffer[512];
3939 struct ipr_ioa_cfg *ioa_cfg;
3940 unsigned long lock_flags = 0;
3942 ioa_cfg = (struct ipr_ioa_cfg *) host->hostdata;
3944 spin_lock_irqsave(host->host_lock, lock_flags);
3945 sprintf(buffer, "IBM %X Storage Adapter", ioa_cfg->type);
3946 spin_unlock_irqrestore(host->host_lock, lock_flags);
3951 static struct scsi_host_template driver_template = {
3952 .module = THIS_MODULE,
3954 .info = ipr_ioa_info,
3955 .queuecommand = ipr_queuecommand,
3956 .eh_abort_handler = ipr_eh_abort,
3957 .eh_device_reset_handler = ipr_eh_dev_reset,
3958 .eh_host_reset_handler = ipr_eh_host_reset,
3959 .slave_alloc = ipr_slave_alloc,
3960 .slave_configure = ipr_slave_configure,
3961 .slave_destroy = ipr_slave_destroy,
3962 .change_queue_depth = ipr_change_queue_depth,
3963 .change_queue_type = ipr_change_queue_type,
3964 .bios_param = ipr_biosparam,
3965 .can_queue = IPR_MAX_COMMANDS,
3967 .sg_tablesize = IPR_MAX_SGLIST,
3968 .max_sectors = IPR_IOA_MAX_SECTORS,
3969 .cmd_per_lun = IPR_MAX_CMD_PER_LUN,
3970 .use_clustering = ENABLE_CLUSTERING,
3971 .shost_attrs = ipr_ioa_attrs,
3972 .sdev_attrs = ipr_dev_attrs,
3973 .proc_name = IPR_NAME
3976 #ifdef CONFIG_PPC_PSERIES
3977 static const u16 ipr_blocked_processors[] = {
3989 * ipr_invalid_adapter - Determine if this adapter is supported on this hardware
3990 * @ioa_cfg: ioa cfg struct
3992 * Adapters that use Gemstone revision < 3.1 do not work reliably on
3993 * certain pSeries hardware. This function determines if the given
3994 * adapter is in one of these confgurations or not.
3997 * 1 if adapter is not supported / 0 if adapter is supported
3999 static int ipr_invalid_adapter(struct ipr_ioa_cfg *ioa_cfg)
4004 if (ioa_cfg->type == 0x5702) {
4005 if (pci_read_config_byte(ioa_cfg->pdev, PCI_REVISION_ID,
4006 &rev_id) == PCIBIOS_SUCCESSFUL) {
4008 for (i = 0; i < ARRAY_SIZE(ipr_blocked_processors); i++){
4009 if (__is_processor(ipr_blocked_processors[i]))
4018 #define ipr_invalid_adapter(ioa_cfg) 0
4022 * ipr_ioa_bringdown_done - IOA bring down completion.
4023 * @ipr_cmd: ipr command struct
4025 * This function processes the completion of an adapter bring down.
4026 * It wakes any reset sleepers.
4031 static int ipr_ioa_bringdown_done(struct ipr_cmnd *ipr_cmd)
4033 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4036 ioa_cfg->in_reset_reload = 0;
4037 ioa_cfg->reset_retries = 0;
4038 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4039 wake_up_all(&ioa_cfg->reset_wait_q);
4041 spin_unlock_irq(ioa_cfg->host->host_lock);
4042 scsi_unblock_requests(ioa_cfg->host);
4043 spin_lock_irq(ioa_cfg->host->host_lock);
4046 return IPR_RC_JOB_RETURN;
4050 * ipr_ioa_reset_done - IOA reset completion.
4051 * @ipr_cmd: ipr command struct
4053 * This function processes the completion of an adapter reset.
4054 * It schedules any necessary mid-layer add/removes and
4055 * wakes any reset sleepers.
4060 static int ipr_ioa_reset_done(struct ipr_cmnd *ipr_cmd)
4062 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4063 struct ipr_resource_entry *res;
4064 struct ipr_hostrcb *hostrcb, *temp;
4068 ioa_cfg->in_reset_reload = 0;
4069 ioa_cfg->allow_cmds = 1;
4070 ioa_cfg->reset_cmd = NULL;
4072 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4073 if (ioa_cfg->allow_ml_add_del && (res->add_to_ml || res->del_from_ml)) {
4078 schedule_work(&ioa_cfg->work_q);
4080 list_for_each_entry_safe(hostrcb, temp, &ioa_cfg->hostrcb_free_q, queue) {
4081 list_del(&hostrcb->queue);
4082 if (i++ < IPR_NUM_LOG_HCAMS)
4083 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
4085 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
4088 dev_info(&ioa_cfg->pdev->dev, "IOA initialized.\n");
4090 ioa_cfg->reset_retries = 0;
4091 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4092 wake_up_all(&ioa_cfg->reset_wait_q);
4094 spin_unlock_irq(ioa_cfg->host->host_lock);
4095 scsi_unblock_requests(ioa_cfg->host);
4096 spin_lock_irq(ioa_cfg->host->host_lock);
4098 if (!ioa_cfg->allow_cmds)
4099 scsi_block_requests(ioa_cfg->host);
4102 return IPR_RC_JOB_RETURN;
4106 * ipr_set_sup_dev_dflt - Initialize a Set Supported Device buffer
4107 * @supported_dev: supported device struct
4108 * @vpids: vendor product id struct
4113 static void ipr_set_sup_dev_dflt(struct ipr_supported_device *supported_dev,
4114 struct ipr_std_inq_vpids *vpids)
4116 memset(supported_dev, 0, sizeof(struct ipr_supported_device));
4117 memcpy(&supported_dev->vpids, vpids, sizeof(struct ipr_std_inq_vpids));
4118 supported_dev->num_records = 1;
4119 supported_dev->data_length =
4120 cpu_to_be16(sizeof(struct ipr_supported_device));
4121 supported_dev->reserved = 0;
4125 * ipr_set_supported_devs - Send Set Supported Devices for a device
4126 * @ipr_cmd: ipr command struct
4128 * This function send a Set Supported Devices to the adapter
4131 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
4133 static int ipr_set_supported_devs(struct ipr_cmnd *ipr_cmd)
4135 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4136 struct ipr_supported_device *supp_dev = &ioa_cfg->vpd_cbs->supp_dev;
4137 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
4138 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
4139 struct ipr_resource_entry *res = ipr_cmd->u.res;
4141 ipr_cmd->job_step = ipr_ioa_reset_done;
4143 list_for_each_entry_continue(res, &ioa_cfg->used_res_q, queue) {
4144 if (!ipr_is_af_dasd_device(res))
4147 ipr_cmd->u.res = res;
4148 ipr_set_sup_dev_dflt(supp_dev, &res->cfgte.std_inq_data.vpids);
4150 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
4151 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
4152 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
4154 ioarcb->cmd_pkt.cdb[0] = IPR_SET_SUPPORTED_DEVICES;
4155 ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_supported_device) >> 8) & 0xff;
4156 ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_supported_device) & 0xff;
4158 ioadl->flags_and_data_len = cpu_to_be32(IPR_IOADL_FLAGS_WRITE_LAST |
4159 sizeof(struct ipr_supported_device));
4160 ioadl->address = cpu_to_be32(ioa_cfg->vpd_cbs_dma +
4161 offsetof(struct ipr_misc_cbs, supp_dev));
4162 ioarcb->write_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
4163 ioarcb->write_data_transfer_length =
4164 cpu_to_be32(sizeof(struct ipr_supported_device));
4166 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
4167 IPR_SET_SUP_DEVICE_TIMEOUT);
4169 ipr_cmd->job_step = ipr_set_supported_devs;
4170 return IPR_RC_JOB_RETURN;
4173 return IPR_RC_JOB_CONTINUE;
4177 * ipr_get_mode_page - Locate specified mode page
4178 * @mode_pages: mode page buffer
4179 * @page_code: page code to find
4180 * @len: minimum required length for mode page
4183 * pointer to mode page / NULL on failure
4185 static void *ipr_get_mode_page(struct ipr_mode_pages *mode_pages,
4186 u32 page_code, u32 len)
4188 struct ipr_mode_page_hdr *mode_hdr;
4192 if (!mode_pages || (mode_pages->hdr.length == 0))
4195 length = (mode_pages->hdr.length + 1) - 4 - mode_pages->hdr.block_desc_len;
4196 mode_hdr = (struct ipr_mode_page_hdr *)
4197 (mode_pages->data + mode_pages->hdr.block_desc_len);
4200 if (IPR_GET_MODE_PAGE_CODE(mode_hdr) == page_code) {
4201 if (mode_hdr->page_length >= (len - sizeof(struct ipr_mode_page_hdr)))
4205 page_length = (sizeof(struct ipr_mode_page_hdr) +
4206 mode_hdr->page_length);
4207 length -= page_length;
4208 mode_hdr = (struct ipr_mode_page_hdr *)
4209 ((unsigned long)mode_hdr + page_length);
4216 * ipr_check_term_power - Check for term power errors
4217 * @ioa_cfg: ioa config struct
4218 * @mode_pages: IOAFP mode pages buffer
4220 * Check the IOAFP's mode page 28 for term power errors
4225 static void ipr_check_term_power(struct ipr_ioa_cfg *ioa_cfg,
4226 struct ipr_mode_pages *mode_pages)
4230 struct ipr_dev_bus_entry *bus;
4231 struct ipr_mode_page28 *mode_page;
4233 mode_page = ipr_get_mode_page(mode_pages, 0x28,
4234 sizeof(struct ipr_mode_page28));
4236 entry_length = mode_page->entry_length;
4238 bus = mode_page->bus;
4240 for (i = 0; i < mode_page->num_entries; i++) {
4241 if (bus->flags & IPR_SCSI_ATTR_NO_TERM_PWR) {
4242 dev_err(&ioa_cfg->pdev->dev,
4243 "Term power is absent on scsi bus %d\n",
4247 bus = (struct ipr_dev_bus_entry *)((char *)bus + entry_length);
4252 * ipr_scsi_bus_speed_limit - Limit the SCSI speed based on SES table
4253 * @ioa_cfg: ioa config struct
4255 * Looks through the config table checking for SES devices. If
4256 * the SES device is in the SES table indicating a maximum SCSI
4257 * bus speed, the speed is limited for the bus.
4262 static void ipr_scsi_bus_speed_limit(struct ipr_ioa_cfg *ioa_cfg)
4267 for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
4268 max_xfer_rate = ipr_get_max_scsi_speed(ioa_cfg, i,
4269 ioa_cfg->bus_attr[i].bus_width);
4271 if (max_xfer_rate < ioa_cfg->bus_attr[i].max_xfer_rate)
4272 ioa_cfg->bus_attr[i].max_xfer_rate = max_xfer_rate;
4277 * ipr_modify_ioafp_mode_page_28 - Modify IOAFP Mode Page 28
4278 * @ioa_cfg: ioa config struct
4279 * @mode_pages: mode page 28 buffer
4281 * Updates mode page 28 based on driver configuration
4286 static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg *ioa_cfg,
4287 struct ipr_mode_pages *mode_pages)
4289 int i, entry_length;
4290 struct ipr_dev_bus_entry *bus;
4291 struct ipr_bus_attributes *bus_attr;
4292 struct ipr_mode_page28 *mode_page;
4294 mode_page = ipr_get_mode_page(mode_pages, 0x28,
4295 sizeof(struct ipr_mode_page28));
4297 entry_length = mode_page->entry_length;
4299 /* Loop for each device bus entry */
4300 for (i = 0, bus = mode_page->bus;
4301 i < mode_page->num_entries;
4302 i++, bus = (struct ipr_dev_bus_entry *)((u8 *)bus + entry_length)) {
4303 if (bus->res_addr.bus > IPR_MAX_NUM_BUSES) {
4304 dev_err(&ioa_cfg->pdev->dev,
4305 "Invalid resource address reported: 0x%08X\n",
4306 IPR_GET_PHYS_LOC(bus->res_addr));
4310 bus_attr = &ioa_cfg->bus_attr[i];
4311 bus->extended_reset_delay = IPR_EXTENDED_RESET_DELAY;
4312 bus->bus_width = bus_attr->bus_width;
4313 bus->max_xfer_rate = cpu_to_be32(bus_attr->max_xfer_rate);
4314 bus->flags &= ~IPR_SCSI_ATTR_QAS_MASK;
4315 if (bus_attr->qas_enabled)
4316 bus->flags |= IPR_SCSI_ATTR_ENABLE_QAS;
4318 bus->flags |= IPR_SCSI_ATTR_DISABLE_QAS;
4323 * ipr_build_mode_select - Build a mode select command
4324 * @ipr_cmd: ipr command struct
4325 * @res_handle: resource handle to send command to
4326 * @parm: Byte 2 of Mode Sense command
4327 * @dma_addr: DMA buffer address
4328 * @xfer_len: data transfer length
4333 static void ipr_build_mode_select(struct ipr_cmnd *ipr_cmd,
4334 __be32 res_handle, u8 parm, u32 dma_addr,
4337 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
4338 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
4340 ioarcb->res_handle = res_handle;
4341 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
4342 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
4343 ioarcb->cmd_pkt.cdb[0] = MODE_SELECT;
4344 ioarcb->cmd_pkt.cdb[1] = parm;
4345 ioarcb->cmd_pkt.cdb[4] = xfer_len;
4347 ioadl->flags_and_data_len =
4348 cpu_to_be32(IPR_IOADL_FLAGS_WRITE_LAST | xfer_len);
4349 ioadl->address = cpu_to_be32(dma_addr);
4350 ioarcb->write_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
4351 ioarcb->write_data_transfer_length = cpu_to_be32(xfer_len);
4355 * ipr_ioafp_mode_select_page28 - Issue Mode Select Page 28 to IOA
4356 * @ipr_cmd: ipr command struct
4358 * This function sets up the SCSI bus attributes and sends
4359 * a Mode Select for Page 28 to activate them.
4364 static int ipr_ioafp_mode_select_page28(struct ipr_cmnd *ipr_cmd)
4366 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4367 struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
4371 if (ioa_cfg->saved_mode_pages) {
4372 memcpy(mode_pages, ioa_cfg->saved_mode_pages,
4373 ioa_cfg->saved_mode_page_len);
4374 length = ioa_cfg->saved_mode_page_len;
4376 ipr_scsi_bus_speed_limit(ioa_cfg);
4377 ipr_check_term_power(ioa_cfg, mode_pages);
4378 ipr_modify_ioafp_mode_page_28(ioa_cfg, mode_pages);
4379 length = mode_pages->hdr.length + 1;
4380 mode_pages->hdr.length = 0;
4383 ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
4384 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
4387 ipr_cmd->job_step = ipr_set_supported_devs;
4388 ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
4389 struct ipr_resource_entry, queue);
4391 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
4394 return IPR_RC_JOB_RETURN;
4398 * ipr_build_mode_sense - Builds a mode sense command
4399 * @ipr_cmd: ipr command struct
4400 * @res: resource entry struct
4401 * @parm: Byte 2 of mode sense command
4402 * @dma_addr: DMA address of mode sense buffer
4403 * @xfer_len: Size of DMA buffer
4408 static void ipr_build_mode_sense(struct ipr_cmnd *ipr_cmd,
4410 u8 parm, u32 dma_addr, u8 xfer_len)
4412 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
4413 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
4415 ioarcb->res_handle = res_handle;
4416 ioarcb->cmd_pkt.cdb[0] = MODE_SENSE;
4417 ioarcb->cmd_pkt.cdb[2] = parm;
4418 ioarcb->cmd_pkt.cdb[4] = xfer_len;
4419 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
4421 ioadl->flags_and_data_len =
4422 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | xfer_len);
4423 ioadl->address = cpu_to_be32(dma_addr);
4424 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
4425 ioarcb->read_data_transfer_length = cpu_to_be32(xfer_len);
4429 * ipr_ioafp_mode_sense_page28 - Issue Mode Sense Page 28 to IOA
4430 * @ipr_cmd: ipr command struct
4432 * This function send a Page 28 mode sense to the IOA to
4433 * retrieve SCSI bus attributes.
4438 static int ipr_ioafp_mode_sense_page28(struct ipr_cmnd *ipr_cmd)
4440 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4443 ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
4444 0x28, ioa_cfg->vpd_cbs_dma +
4445 offsetof(struct ipr_misc_cbs, mode_pages),
4446 sizeof(struct ipr_mode_pages));
4448 ipr_cmd->job_step = ipr_ioafp_mode_select_page28;
4450 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
4453 return IPR_RC_JOB_RETURN;
4457 * ipr_init_res_table - Initialize the resource table
4458 * @ipr_cmd: ipr command struct
4460 * This function looks through the existing resource table, comparing
4461 * it with the config table. This function will take care of old/new
4462 * devices and schedule adding/removing them from the mid-layer
4466 * IPR_RC_JOB_CONTINUE
4468 static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd)
4470 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4471 struct ipr_resource_entry *res, *temp;
4472 struct ipr_config_table_entry *cfgte;
4477 if (ioa_cfg->cfg_table->hdr.flags & IPR_UCODE_DOWNLOAD_REQ)
4478 dev_err(&ioa_cfg->pdev->dev, "Microcode download required\n");
4480 list_for_each_entry_safe(res, temp, &ioa_cfg->used_res_q, queue)
4481 list_move_tail(&res->queue, &old_res);
4483 for (i = 0; i < ioa_cfg->cfg_table->hdr.num_entries; i++) {
4484 cfgte = &ioa_cfg->cfg_table->dev[i];
4487 list_for_each_entry_safe(res, temp, &old_res, queue) {
4488 if (!memcmp(&res->cfgte.res_addr,
4489 &cfgte->res_addr, sizeof(cfgte->res_addr))) {
4490 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
4497 if (list_empty(&ioa_cfg->free_res_q)) {
4498 dev_err(&ioa_cfg->pdev->dev, "Too many devices attached\n");
4503 res = list_entry(ioa_cfg->free_res_q.next,
4504 struct ipr_resource_entry, queue);
4505 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
4506 ipr_init_res_entry(res);
4511 memcpy(&res->cfgte, cfgte, sizeof(struct ipr_config_table_entry));
4514 list_for_each_entry_safe(res, temp, &old_res, queue) {
4516 res->del_from_ml = 1;
4517 res->sdev->hostdata = NULL;
4518 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
4520 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
4524 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
4527 return IPR_RC_JOB_CONTINUE;
4531 * ipr_ioafp_query_ioa_cfg - Send a Query IOA Config to the adapter.
4532 * @ipr_cmd: ipr command struct
4534 * This function sends a Query IOA Configuration command
4535 * to the adapter to retrieve the IOA configuration table.
4540 static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
4542 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4543 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
4544 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
4545 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
4548 dev_info(&ioa_cfg->pdev->dev, "Adapter firmware version: %02X%02X%02X%02X\n",
4549 ucode_vpd->major_release, ucode_vpd->card_type,
4550 ucode_vpd->minor_release[0], ucode_vpd->minor_release[1]);
4551 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
4552 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
4554 ioarcb->cmd_pkt.cdb[0] = IPR_QUERY_IOA_CONFIG;
4555 ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_config_table) >> 8) & 0xff;
4556 ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_config_table) & 0xff;
4558 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
4559 ioarcb->read_data_transfer_length =
4560 cpu_to_be32(sizeof(struct ipr_config_table));
4562 ioadl->address = cpu_to_be32(ioa_cfg->cfg_table_dma);
4563 ioadl->flags_and_data_len =
4564 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | sizeof(struct ipr_config_table));
4566 ipr_cmd->job_step = ipr_init_res_table;
4568 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
4571 return IPR_RC_JOB_RETURN;
4575 * ipr_ioafp_inquiry - Send an Inquiry to the adapter.
4576 * @ipr_cmd: ipr command struct
4578 * This utility function sends an inquiry to the adapter.
4583 static void ipr_ioafp_inquiry(struct ipr_cmnd *ipr_cmd, u8 flags, u8 page,
4584 u32 dma_addr, u8 xfer_len)
4586 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
4587 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
4590 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
4591 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
4593 ioarcb->cmd_pkt.cdb[0] = INQUIRY;
4594 ioarcb->cmd_pkt.cdb[1] = flags;
4595 ioarcb->cmd_pkt.cdb[2] = page;
4596 ioarcb->cmd_pkt.cdb[4] = xfer_len;
4598 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
4599 ioarcb->read_data_transfer_length = cpu_to_be32(xfer_len);
4601 ioadl->address = cpu_to_be32(dma_addr);
4602 ioadl->flags_and_data_len =
4603 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | xfer_len);
4605 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
4610 * ipr_ioafp_page3_inquiry - Send a Page 3 Inquiry to the adapter.
4611 * @ipr_cmd: ipr command struct
4613 * This function sends a Page 3 inquiry to the adapter
4614 * to retrieve software VPD information.
4617 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
4619 static int ipr_ioafp_page3_inquiry(struct ipr_cmnd *ipr_cmd)
4621 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4626 /* Grab the type out of the VPD and store it away */
4627 memcpy(type, ioa_cfg->vpd_cbs->ioa_vpd.std_inq_data.vpids.product_id, 4);
4629 ioa_cfg->type = simple_strtoul((char *)type, NULL, 16);
4631 ipr_cmd->job_step = ipr_ioafp_query_ioa_cfg;
4633 ipr_ioafp_inquiry(ipr_cmd, 1, 3,
4634 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page3_data),
4635 sizeof(struct ipr_inquiry_page3));
4638 return IPR_RC_JOB_RETURN;
4642 * ipr_ioafp_std_inquiry - Send a Standard Inquiry to the adapter.
4643 * @ipr_cmd: ipr command struct
4645 * This function sends a standard inquiry to the adapter.
4650 static int ipr_ioafp_std_inquiry(struct ipr_cmnd *ipr_cmd)
4652 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4655 ipr_cmd->job_step = ipr_ioafp_page3_inquiry;
4657 ipr_ioafp_inquiry(ipr_cmd, 0, 0,
4658 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, ioa_vpd),
4659 sizeof(struct ipr_ioa_vpd));
4662 return IPR_RC_JOB_RETURN;
4666 * ipr_ioafp_indentify_hrrq - Send Identify Host RRQ.
4667 * @ipr_cmd: ipr command struct
4669 * This function send an Identify Host Request Response Queue
4670 * command to establish the HRRQ with the adapter.
4675 static int ipr_ioafp_indentify_hrrq(struct ipr_cmnd *ipr_cmd)
4677 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4678 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
4681 dev_info(&ioa_cfg->pdev->dev, "Starting IOA initialization sequence.\n");
4683 ioarcb->cmd_pkt.cdb[0] = IPR_ID_HOST_RR_Q;
4684 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
4686 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
4687 ioarcb->cmd_pkt.cdb[2] =
4688 ((u32) ioa_cfg->host_rrq_dma >> 24) & 0xff;
4689 ioarcb->cmd_pkt.cdb[3] =
4690 ((u32) ioa_cfg->host_rrq_dma >> 16) & 0xff;
4691 ioarcb->cmd_pkt.cdb[4] =
4692 ((u32) ioa_cfg->host_rrq_dma >> 8) & 0xff;
4693 ioarcb->cmd_pkt.cdb[5] =
4694 ((u32) ioa_cfg->host_rrq_dma) & 0xff;
4695 ioarcb->cmd_pkt.cdb[7] =
4696 ((sizeof(u32) * IPR_NUM_CMD_BLKS) >> 8) & 0xff;
4697 ioarcb->cmd_pkt.cdb[8] =
4698 (sizeof(u32) * IPR_NUM_CMD_BLKS) & 0xff;
4700 ipr_cmd->job_step = ipr_ioafp_std_inquiry;
4702 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
4705 return IPR_RC_JOB_RETURN;
4709 * ipr_reset_timer_done - Adapter reset timer function
4710 * @ipr_cmd: ipr command struct
4712 * Description: This function is used in adapter reset processing
4713 * for timing events. If the reset_cmd pointer in the IOA
4714 * config struct is not this adapter's we are doing nested
4715 * resets and fail_all_ops will take care of freeing the
4721 static void ipr_reset_timer_done(struct ipr_cmnd *ipr_cmd)
4723 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4724 unsigned long lock_flags = 0;
4726 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4728 if (ioa_cfg->reset_cmd == ipr_cmd) {
4729 list_del(&ipr_cmd->queue);
4730 ipr_cmd->done(ipr_cmd);
4733 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4737 * ipr_reset_start_timer - Start a timer for adapter reset job
4738 * @ipr_cmd: ipr command struct
4739 * @timeout: timeout value
4741 * Description: This function is used in adapter reset processing
4742 * for timing events. If the reset_cmd pointer in the IOA
4743 * config struct is not this adapter's we are doing nested
4744 * resets and fail_all_ops will take care of freeing the
4750 static void ipr_reset_start_timer(struct ipr_cmnd *ipr_cmd,
4751 unsigned long timeout)
4753 list_add_tail(&ipr_cmd->queue, &ipr_cmd->ioa_cfg->pending_q);
4754 ipr_cmd->done = ipr_reset_ioa_job;
4756 ipr_cmd->timer.data = (unsigned long) ipr_cmd;
4757 ipr_cmd->timer.expires = jiffies + timeout;
4758 ipr_cmd->timer.function = (void (*)(unsigned long))ipr_reset_timer_done;
4759 add_timer(&ipr_cmd->timer);
4763 * ipr_init_ioa_mem - Initialize ioa_cfg control block
4764 * @ioa_cfg: ioa cfg struct
4769 static void ipr_init_ioa_mem(struct ipr_ioa_cfg *ioa_cfg)
4771 memset(ioa_cfg->host_rrq, 0, sizeof(u32) * IPR_NUM_CMD_BLKS);
4773 /* Initialize Host RRQ pointers */
4774 ioa_cfg->hrrq_start = ioa_cfg->host_rrq;
4775 ioa_cfg->hrrq_end = &ioa_cfg->host_rrq[IPR_NUM_CMD_BLKS - 1];
4776 ioa_cfg->hrrq_curr = ioa_cfg->hrrq_start;
4777 ioa_cfg->toggle_bit = 1;
4779 /* Zero out config table */
4780 memset(ioa_cfg->cfg_table, 0, sizeof(struct ipr_config_table));
4784 * ipr_reset_enable_ioa - Enable the IOA following a reset.
4785 * @ipr_cmd: ipr command struct
4787 * This function reinitializes some control blocks and
4788 * enables destructive diagnostics on the adapter.
4793 static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd)
4795 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4796 volatile u32 int_reg;
4799 ipr_cmd->job_step = ipr_ioafp_indentify_hrrq;
4800 ipr_init_ioa_mem(ioa_cfg);
4802 ioa_cfg->allow_interrupts = 1;
4803 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
4805 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
4806 writel((IPR_PCII_ERROR_INTERRUPTS | IPR_PCII_HRRQ_UPDATED),
4807 ioa_cfg->regs.clr_interrupt_mask_reg);
4808 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
4809 return IPR_RC_JOB_CONTINUE;
4812 /* Enable destructive diagnostics on IOA */
4813 writel(IPR_DOORBELL, ioa_cfg->regs.set_uproc_interrupt_reg);
4815 writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg);
4816 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
4818 dev_info(&ioa_cfg->pdev->dev, "Initializing IOA.\n");
4820 ipr_cmd->timer.data = (unsigned long) ipr_cmd;
4821 ipr_cmd->timer.expires = jiffies + (ipr_transop_timeout * HZ);
4822 ipr_cmd->timer.function = (void (*)(unsigned long))ipr_oper_timeout;
4823 ipr_cmd->done = ipr_reset_ioa_job;
4824 add_timer(&ipr_cmd->timer);
4825 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
4828 return IPR_RC_JOB_RETURN;
4832 * ipr_reset_wait_for_dump - Wait for a dump to timeout.
4833 * @ipr_cmd: ipr command struct
4835 * This function is invoked when an adapter dump has run out
4836 * of processing time.
4839 * IPR_RC_JOB_CONTINUE
4841 static int ipr_reset_wait_for_dump(struct ipr_cmnd *ipr_cmd)
4843 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4845 if (ioa_cfg->sdt_state == GET_DUMP)
4846 ioa_cfg->sdt_state = ABORT_DUMP;
4848 ipr_cmd->job_step = ipr_reset_alert;
4850 return IPR_RC_JOB_CONTINUE;
4854 * ipr_unit_check_no_data - Log a unit check/no data error log
4855 * @ioa_cfg: ioa config struct
4857 * Logs an error indicating the adapter unit checked, but for some
4858 * reason, we were unable to fetch the unit check buffer.
4863 static void ipr_unit_check_no_data(struct ipr_ioa_cfg *ioa_cfg)
4865 ioa_cfg->errors_logged++;
4866 dev_err(&ioa_cfg->pdev->dev, "IOA unit check with no data\n");
4870 * ipr_get_unit_check_buffer - Get the unit check buffer from the IOA
4871 * @ioa_cfg: ioa config struct
4873 * Fetches the unit check buffer from the adapter by clocking the data
4874 * through the mailbox register.
4879 static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
4881 unsigned long mailbox;
4882 struct ipr_hostrcb *hostrcb;
4883 struct ipr_uc_sdt sdt;
4886 mailbox = readl(ioa_cfg->ioa_mailbox);
4888 if (!ipr_sdt_is_fmt2(mailbox)) {
4889 ipr_unit_check_no_data(ioa_cfg);
4893 memset(&sdt, 0, sizeof(struct ipr_uc_sdt));
4894 rc = ipr_get_ldump_data_section(ioa_cfg, mailbox, (__be32 *) &sdt,
4895 (sizeof(struct ipr_uc_sdt)) / sizeof(__be32));
4897 if (rc || (be32_to_cpu(sdt.hdr.state) != IPR_FMT2_SDT_READY_TO_USE) ||
4898 !(sdt.entry[0].flags & IPR_SDT_VALID_ENTRY)) {
4899 ipr_unit_check_no_data(ioa_cfg);
4903 /* Find length of the first sdt entry (UC buffer) */
4904 length = (be32_to_cpu(sdt.entry[0].end_offset) -
4905 be32_to_cpu(sdt.entry[0].bar_str_offset)) & IPR_FMT2_MBX_ADDR_MASK;
4907 hostrcb = list_entry(ioa_cfg->hostrcb_free_q.next,
4908 struct ipr_hostrcb, queue);
4909 list_del(&hostrcb->queue);
4910 memset(&hostrcb->hcam, 0, sizeof(hostrcb->hcam));
4912 rc = ipr_get_ldump_data_section(ioa_cfg,
4913 be32_to_cpu(sdt.entry[0].bar_str_offset),
4914 (__be32 *)&hostrcb->hcam,
4915 min(length, (int)sizeof(hostrcb->hcam)) / sizeof(__be32));
4918 ipr_handle_log_data(ioa_cfg, hostrcb);
4920 ipr_unit_check_no_data(ioa_cfg);
4922 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
4926 * ipr_reset_restore_cfg_space - Restore PCI config space.
4927 * @ipr_cmd: ipr command struct
4929 * Description: This function restores the saved PCI config space of
4930 * the adapter, fails all outstanding ops back to the callers, and
4931 * fetches the dump/unit check if applicable to this reset.
4934 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
4936 static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
4938 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4942 pci_unblock_user_cfg_access(ioa_cfg->pdev);
4943 rc = pci_restore_state(ioa_cfg->pdev);
4945 if (rc != PCIBIOS_SUCCESSFUL) {
4946 ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
4947 return IPR_RC_JOB_CONTINUE;
4950 if (ipr_set_pcix_cmd_reg(ioa_cfg)) {
4951 ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
4952 return IPR_RC_JOB_CONTINUE;
4955 ipr_fail_all_ops(ioa_cfg);
4957 if (ioa_cfg->ioa_unit_checked) {
4958 ioa_cfg->ioa_unit_checked = 0;
4959 ipr_get_unit_check_buffer(ioa_cfg);
4960 ipr_cmd->job_step = ipr_reset_alert;
4961 ipr_reset_start_timer(ipr_cmd, 0);
4962 return IPR_RC_JOB_RETURN;
4965 if (ioa_cfg->in_ioa_bringdown) {
4966 ipr_cmd->job_step = ipr_ioa_bringdown_done;
4968 ipr_cmd->job_step = ipr_reset_enable_ioa;
4970 if (GET_DUMP == ioa_cfg->sdt_state) {
4971 ipr_reset_start_timer(ipr_cmd, IPR_DUMP_TIMEOUT);
4972 ipr_cmd->job_step = ipr_reset_wait_for_dump;
4973 schedule_work(&ioa_cfg->work_q);
4974 return IPR_RC_JOB_RETURN;
4979 return IPR_RC_JOB_CONTINUE;
4983 * ipr_reset_start_bist - Run BIST on the adapter.
4984 * @ipr_cmd: ipr command struct
4986 * Description: This function runs BIST on the adapter, then delays 2 seconds.
4989 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
4991 static int ipr_reset_start_bist(struct ipr_cmnd *ipr_cmd)
4993 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4997 pci_block_user_cfg_access(ioa_cfg->pdev);
4998 rc = pci_write_config_byte(ioa_cfg->pdev, PCI_BIST, PCI_BIST_START);
5000 if (rc != PCIBIOS_SUCCESSFUL) {
5001 ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
5002 rc = IPR_RC_JOB_CONTINUE;
5004 ipr_cmd->job_step = ipr_reset_restore_cfg_space;
5005 ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
5006 rc = IPR_RC_JOB_RETURN;
5014 * ipr_reset_allowed - Query whether or not IOA can be reset
5015 * @ioa_cfg: ioa config struct
5018 * 0 if reset not allowed / non-zero if reset is allowed
5020 static int ipr_reset_allowed(struct ipr_ioa_cfg *ioa_cfg)
5022 volatile u32 temp_reg;
5024 temp_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
5025 return ((temp_reg & IPR_PCII_CRITICAL_OPERATION) == 0);
5029 * ipr_reset_wait_to_start_bist - Wait for permission to reset IOA.
5030 * @ipr_cmd: ipr command struct
5032 * Description: This function waits for adapter permission to run BIST,
5033 * then runs BIST. If the adapter does not give permission after a
5034 * reasonable time, we will reset the adapter anyway. The impact of
5035 * resetting the adapter without warning the adapter is the risk of
5036 * losing the persistent error log on the adapter. If the adapter is
5037 * reset while it is writing to the flash on the adapter, the flash
5038 * segment will have bad ECC and be zeroed.
5041 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5043 static int ipr_reset_wait_to_start_bist(struct ipr_cmnd *ipr_cmd)
5045 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5046 int rc = IPR_RC_JOB_RETURN;
5048 if (!ipr_reset_allowed(ioa_cfg) && ipr_cmd->u.time_left) {
5049 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
5050 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
5052 ipr_cmd->job_step = ipr_reset_start_bist;
5053 rc = IPR_RC_JOB_CONTINUE;
5060 * ipr_reset_alert_part2 - Alert the adapter of a pending reset
5061 * @ipr_cmd: ipr command struct
5063 * Description: This function alerts the adapter that it will be reset.
5064 * If memory space is not currently enabled, proceed directly
5065 * to running BIST on the adapter. The timer must always be started
5066 * so we guarantee we do not run BIST from ipr_isr.
5071 static int ipr_reset_alert(struct ipr_cmnd *ipr_cmd)
5073 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5078 rc = pci_read_config_word(ioa_cfg->pdev, PCI_COMMAND, &cmd_reg);
5080 if ((rc == PCIBIOS_SUCCESSFUL) && (cmd_reg & PCI_COMMAND_MEMORY)) {
5081 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
5082 writel(IPR_UPROCI_RESET_ALERT, ioa_cfg->regs.set_uproc_interrupt_reg);
5083 ipr_cmd->job_step = ipr_reset_wait_to_start_bist;
5085 ipr_cmd->job_step = ipr_reset_start_bist;
5088 ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
5089 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
5092 return IPR_RC_JOB_RETURN;
5096 * ipr_reset_ucode_download_done - Microcode download completion
5097 * @ipr_cmd: ipr command struct
5099 * Description: This function unmaps the microcode download buffer.
5102 * IPR_RC_JOB_CONTINUE
5104 static int ipr_reset_ucode_download_done(struct ipr_cmnd *ipr_cmd)
5106 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5107 struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
5109 pci_unmap_sg(ioa_cfg->pdev, sglist->scatterlist,
5110 sglist->num_sg, DMA_TO_DEVICE);
5112 ipr_cmd->job_step = ipr_reset_alert;
5113 return IPR_RC_JOB_CONTINUE;
5117 * ipr_reset_ucode_download - Download microcode to the adapter
5118 * @ipr_cmd: ipr command struct
5120 * Description: This function checks to see if it there is microcode
5121 * to download to the adapter. If there is, a download is performed.
5124 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5126 static int ipr_reset_ucode_download(struct ipr_cmnd *ipr_cmd)
5128 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5129 struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
5132 ipr_cmd->job_step = ipr_reset_alert;
5135 return IPR_RC_JOB_CONTINUE;
5137 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
5138 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
5139 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = WRITE_BUFFER;
5140 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_WR_BUF_DOWNLOAD_AND_SAVE;
5141 ipr_cmd->ioarcb.cmd_pkt.cdb[6] = (sglist->buffer_len & 0xff0000) >> 16;
5142 ipr_cmd->ioarcb.cmd_pkt.cdb[7] = (sglist->buffer_len & 0x00ff00) >> 8;
5143 ipr_cmd->ioarcb.cmd_pkt.cdb[8] = sglist->buffer_len & 0x0000ff;
5145 if (ipr_map_ucode_buffer(ipr_cmd, sglist, sglist->buffer_len)) {
5146 dev_err(&ioa_cfg->pdev->dev,
5147 "Failed to map microcode download buffer\n");
5148 return IPR_RC_JOB_CONTINUE;
5151 ipr_cmd->job_step = ipr_reset_ucode_download_done;
5153 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
5154 IPR_WRITE_BUFFER_TIMEOUT);
5157 return IPR_RC_JOB_RETURN;
5161 * ipr_reset_shutdown_ioa - Shutdown the adapter
5162 * @ipr_cmd: ipr command struct
5164 * Description: This function issues an adapter shutdown of the
5165 * specified type to the specified adapter as part of the
5166 * adapter reset job.
5169 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5171 static int ipr_reset_shutdown_ioa(struct ipr_cmnd *ipr_cmd)
5173 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5174 enum ipr_shutdown_type shutdown_type = ipr_cmd->u.shutdown_type;
5175 unsigned long timeout;
5176 int rc = IPR_RC_JOB_CONTINUE;
5179 if (shutdown_type != IPR_SHUTDOWN_NONE && !ioa_cfg->ioa_is_dead) {
5180 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
5181 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
5182 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
5183 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = shutdown_type;
5185 if (shutdown_type == IPR_SHUTDOWN_ABBREV)
5186 timeout = IPR_ABBREV_SHUTDOWN_TIMEOUT;
5187 else if (shutdown_type == IPR_SHUTDOWN_PREPARE_FOR_NORMAL)
5188 timeout = IPR_INTERNAL_TIMEOUT;
5190 timeout = IPR_SHUTDOWN_TIMEOUT;
5192 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, timeout);
5194 rc = IPR_RC_JOB_RETURN;
5195 ipr_cmd->job_step = ipr_reset_ucode_download;
5197 ipr_cmd->job_step = ipr_reset_alert;
5204 * ipr_reset_ioa_job - Adapter reset job
5205 * @ipr_cmd: ipr command struct
5207 * Description: This function is the job router for the adapter reset job.
5212 static void ipr_reset_ioa_job(struct ipr_cmnd *ipr_cmd)
5215 unsigned long scratch = ipr_cmd->u.scratch;
5216 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5219 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
5221 if (ioa_cfg->reset_cmd != ipr_cmd) {
5223 * We are doing nested adapter resets and this is
5224 * not the current reset job.
5226 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
5230 if (IPR_IOASC_SENSE_KEY(ioasc)) {
5231 dev_err(&ioa_cfg->pdev->dev,
5232 "0x%02X failed with IOASC: 0x%08X\n",
5233 ipr_cmd->ioarcb.cmd_pkt.cdb[0], ioasc);
5235 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5236 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
5240 ipr_reinit_ipr_cmnd(ipr_cmd);
5241 ipr_cmd->u.scratch = scratch;
5242 rc = ipr_cmd->job_step(ipr_cmd);
5243 } while(rc == IPR_RC_JOB_CONTINUE);
5247 * _ipr_initiate_ioa_reset - Initiate an adapter reset
5248 * @ioa_cfg: ioa config struct
5249 * @job_step: first job step of reset job
5250 * @shutdown_type: shutdown type
5252 * Description: This function will initiate the reset of the given adapter
5253 * starting at the selected job step.
5254 * If the caller needs to wait on the completion of the reset,
5255 * the caller must sleep on the reset_wait_q.
5260 static void _ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
5261 int (*job_step) (struct ipr_cmnd *),
5262 enum ipr_shutdown_type shutdown_type)
5264 struct ipr_cmnd *ipr_cmd;
5266 ioa_cfg->in_reset_reload = 1;
5267 ioa_cfg->allow_cmds = 0;
5268 scsi_block_requests(ioa_cfg->host);
5270 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5271 ioa_cfg->reset_cmd = ipr_cmd;
5272 ipr_cmd->job_step = job_step;
5273 ipr_cmd->u.shutdown_type = shutdown_type;
5275 ipr_reset_ioa_job(ipr_cmd);
5279 * ipr_initiate_ioa_reset - Initiate an adapter reset
5280 * @ioa_cfg: ioa config struct
5281 * @shutdown_type: shutdown type
5283 * Description: This function will initiate the reset of the given adapter.
5284 * If the caller needs to wait on the completion of the reset,
5285 * the caller must sleep on the reset_wait_q.
5290 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
5291 enum ipr_shutdown_type shutdown_type)
5293 if (ioa_cfg->ioa_is_dead)
5296 if (ioa_cfg->in_reset_reload && ioa_cfg->sdt_state == GET_DUMP)
5297 ioa_cfg->sdt_state = ABORT_DUMP;
5299 if (ioa_cfg->reset_retries++ >= IPR_NUM_RESET_RELOAD_RETRIES) {
5300 dev_err(&ioa_cfg->pdev->dev,
5301 "IOA taken offline - error recovery failed\n");
5303 ioa_cfg->reset_retries = 0;
5304 ioa_cfg->ioa_is_dead = 1;
5306 if (ioa_cfg->in_ioa_bringdown) {
5307 ioa_cfg->reset_cmd = NULL;
5308 ioa_cfg->in_reset_reload = 0;
5309 ipr_fail_all_ops(ioa_cfg);
5310 wake_up_all(&ioa_cfg->reset_wait_q);
5312 spin_unlock_irq(ioa_cfg->host->host_lock);
5313 scsi_unblock_requests(ioa_cfg->host);
5314 spin_lock_irq(ioa_cfg->host->host_lock);
5317 ioa_cfg->in_ioa_bringdown = 1;
5318 shutdown_type = IPR_SHUTDOWN_NONE;
5322 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_shutdown_ioa,
5327 * ipr_probe_ioa_part2 - Initializes IOAs found in ipr_probe_ioa(..)
5328 * @ioa_cfg: ioa cfg struct
5330 * Description: This is the second phase of adapter intialization
5331 * This function takes care of initilizing the adapter to the point
5332 * where it can accept new commands.
5335 * 0 on sucess / -EIO on failure
5337 static int __devinit ipr_probe_ioa_part2(struct ipr_ioa_cfg *ioa_cfg)
5340 unsigned long host_lock_flags = 0;
5343 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
5344 dev_dbg(&ioa_cfg->pdev->dev, "ioa_cfg adx: 0x%p\n", ioa_cfg);
5345 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa, IPR_SHUTDOWN_NONE);
5347 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
5348 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5349 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
5351 if (ioa_cfg->ioa_is_dead) {
5353 } else if (ipr_invalid_adapter(ioa_cfg)) {
5357 dev_err(&ioa_cfg->pdev->dev,
5358 "Adapter not supported in this hardware configuration.\n");
5361 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
5368 * ipr_free_cmd_blks - Frees command blocks allocated for an adapter
5369 * @ioa_cfg: ioa config struct
5374 static void ipr_free_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
5378 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
5379 if (ioa_cfg->ipr_cmnd_list[i])
5380 pci_pool_free(ioa_cfg->ipr_cmd_pool,
5381 ioa_cfg->ipr_cmnd_list[i],
5382 ioa_cfg->ipr_cmnd_list_dma[i]);
5384 ioa_cfg->ipr_cmnd_list[i] = NULL;
5387 if (ioa_cfg->ipr_cmd_pool)
5388 pci_pool_destroy (ioa_cfg->ipr_cmd_pool);
5390 ioa_cfg->ipr_cmd_pool = NULL;
5394 * ipr_free_mem - Frees memory allocated for an adapter
5395 * @ioa_cfg: ioa cfg struct
5400 static void ipr_free_mem(struct ipr_ioa_cfg *ioa_cfg)
5404 kfree(ioa_cfg->res_entries);
5405 pci_free_consistent(ioa_cfg->pdev, sizeof(struct ipr_misc_cbs),
5406 ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
5407 ipr_free_cmd_blks(ioa_cfg);
5408 pci_free_consistent(ioa_cfg->pdev, sizeof(u32) * IPR_NUM_CMD_BLKS,
5409 ioa_cfg->host_rrq, ioa_cfg->host_rrq_dma);
5410 pci_free_consistent(ioa_cfg->pdev, sizeof(struct ipr_config_table),
5412 ioa_cfg->cfg_table_dma);
5414 for (i = 0; i < IPR_NUM_HCAMS; i++) {
5415 pci_free_consistent(ioa_cfg->pdev,
5416 sizeof(struct ipr_hostrcb),
5417 ioa_cfg->hostrcb[i],
5418 ioa_cfg->hostrcb_dma[i]);
5421 ipr_free_dump(ioa_cfg);
5422 kfree(ioa_cfg->saved_mode_pages);
5423 kfree(ioa_cfg->trace);
5427 * ipr_free_all_resources - Free all allocated resources for an adapter.
5428 * @ipr_cmd: ipr command struct
5430 * This function frees all allocated resources for the
5431 * specified adapter.
5436 static void ipr_free_all_resources(struct ipr_ioa_cfg *ioa_cfg)
5438 struct pci_dev *pdev = ioa_cfg->pdev;
5441 free_irq(pdev->irq, ioa_cfg);
5442 iounmap(ioa_cfg->hdw_dma_regs);
5443 pci_release_regions(pdev);
5444 ipr_free_mem(ioa_cfg);
5445 scsi_host_put(ioa_cfg->host);
5446 pci_disable_device(pdev);
5451 * ipr_alloc_cmd_blks - Allocate command blocks for an adapter
5452 * @ioa_cfg: ioa config struct
5455 * 0 on success / -ENOMEM on allocation failure
5457 static int __devinit ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
5459 struct ipr_cmnd *ipr_cmd;
5460 struct ipr_ioarcb *ioarcb;
5461 dma_addr_t dma_addr;
5464 ioa_cfg->ipr_cmd_pool = pci_pool_create (IPR_NAME, ioa_cfg->pdev,
5465 sizeof(struct ipr_cmnd), 8, 0);
5467 if (!ioa_cfg->ipr_cmd_pool)
5470 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
5471 ipr_cmd = pci_pool_alloc (ioa_cfg->ipr_cmd_pool, SLAB_KERNEL, &dma_addr);
5474 ipr_free_cmd_blks(ioa_cfg);
5478 memset(ipr_cmd, 0, sizeof(*ipr_cmd));
5479 ioa_cfg->ipr_cmnd_list[i] = ipr_cmd;
5480 ioa_cfg->ipr_cmnd_list_dma[i] = dma_addr;
5482 ioarcb = &ipr_cmd->ioarcb;
5483 ioarcb->ioarcb_host_pci_addr = cpu_to_be32(dma_addr);
5484 ioarcb->host_response_handle = cpu_to_be32(i << 2);
5485 ioarcb->write_ioadl_addr =
5486 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioadl));
5487 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
5488 ioarcb->ioasa_host_pci_addr =
5489 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioasa));
5490 ioarcb->ioasa_len = cpu_to_be16(sizeof(struct ipr_ioasa));
5491 ipr_cmd->cmd_index = i;
5492 ipr_cmd->ioa_cfg = ioa_cfg;
5493 ipr_cmd->sense_buffer_dma = dma_addr +
5494 offsetof(struct ipr_cmnd, sense_buffer);
5496 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
5503 * ipr_alloc_mem - Allocate memory for an adapter
5504 * @ioa_cfg: ioa config struct
5507 * 0 on success / non-zero for error
5509 static int __devinit ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
5511 struct pci_dev *pdev = ioa_cfg->pdev;
5512 int i, rc = -ENOMEM;
5515 ioa_cfg->res_entries = kmalloc(sizeof(struct ipr_resource_entry) *
5516 IPR_MAX_PHYSICAL_DEVS, GFP_KERNEL);
5518 if (!ioa_cfg->res_entries)
5521 memset(ioa_cfg->res_entries, 0,
5522 sizeof(struct ipr_resource_entry) * IPR_MAX_PHYSICAL_DEVS);
5524 for (i = 0; i < IPR_MAX_PHYSICAL_DEVS; i++)
5525 list_add_tail(&ioa_cfg->res_entries[i].queue, &ioa_cfg->free_res_q);
5527 ioa_cfg->vpd_cbs = pci_alloc_consistent(ioa_cfg->pdev,
5528 sizeof(struct ipr_misc_cbs),
5529 &ioa_cfg->vpd_cbs_dma);
5531 if (!ioa_cfg->vpd_cbs)
5532 goto out_free_res_entries;
5534 if (ipr_alloc_cmd_blks(ioa_cfg))
5535 goto out_free_vpd_cbs;
5537 ioa_cfg->host_rrq = pci_alloc_consistent(ioa_cfg->pdev,
5538 sizeof(u32) * IPR_NUM_CMD_BLKS,
5539 &ioa_cfg->host_rrq_dma);
5541 if (!ioa_cfg->host_rrq)
5542 goto out_ipr_free_cmd_blocks;
5544 ioa_cfg->cfg_table = pci_alloc_consistent(ioa_cfg->pdev,
5545 sizeof(struct ipr_config_table),
5546 &ioa_cfg->cfg_table_dma);
5548 if (!ioa_cfg->cfg_table)
5549 goto out_free_host_rrq;
5551 for (i = 0; i < IPR_NUM_HCAMS; i++) {
5552 ioa_cfg->hostrcb[i] = pci_alloc_consistent(ioa_cfg->pdev,
5553 sizeof(struct ipr_hostrcb),
5554 &ioa_cfg->hostrcb_dma[i]);
5556 if (!ioa_cfg->hostrcb[i])
5557 goto out_free_hostrcb_dma;
5559 ioa_cfg->hostrcb[i]->hostrcb_dma =
5560 ioa_cfg->hostrcb_dma[i] + offsetof(struct ipr_hostrcb, hcam);
5561 list_add_tail(&ioa_cfg->hostrcb[i]->queue, &ioa_cfg->hostrcb_free_q);
5564 ioa_cfg->trace = kmalloc(sizeof(struct ipr_trace_entry) *
5565 IPR_NUM_TRACE_ENTRIES, GFP_KERNEL);
5567 if (!ioa_cfg->trace)
5568 goto out_free_hostrcb_dma;
5570 memset(ioa_cfg->trace, 0,
5571 sizeof(struct ipr_trace_entry) * IPR_NUM_TRACE_ENTRIES);
5578 out_free_hostrcb_dma:
5580 pci_free_consistent(pdev, sizeof(struct ipr_hostrcb),
5581 ioa_cfg->hostrcb[i],
5582 ioa_cfg->hostrcb_dma[i]);
5584 pci_free_consistent(pdev, sizeof(struct ipr_config_table),
5585 ioa_cfg->cfg_table, ioa_cfg->cfg_table_dma);
5587 pci_free_consistent(pdev, sizeof(u32) * IPR_NUM_CMD_BLKS,
5588 ioa_cfg->host_rrq, ioa_cfg->host_rrq_dma);
5589 out_ipr_free_cmd_blocks:
5590 ipr_free_cmd_blks(ioa_cfg);
5592 pci_free_consistent(pdev, sizeof(struct ipr_misc_cbs),
5593 ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
5594 out_free_res_entries:
5595 kfree(ioa_cfg->res_entries);
5600 * ipr_initialize_bus_attr - Initialize SCSI bus attributes to default values
5601 * @ioa_cfg: ioa config struct
5606 static void __devinit ipr_initialize_bus_attr(struct ipr_ioa_cfg *ioa_cfg)
5610 for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
5611 ioa_cfg->bus_attr[i].bus = i;
5612 ioa_cfg->bus_attr[i].qas_enabled = 0;
5613 ioa_cfg->bus_attr[i].bus_width = IPR_DEFAULT_BUS_WIDTH;
5614 if (ipr_max_speed < ARRAY_SIZE(ipr_max_bus_speeds))
5615 ioa_cfg->bus_attr[i].max_xfer_rate = ipr_max_bus_speeds[ipr_max_speed];
5617 ioa_cfg->bus_attr[i].max_xfer_rate = IPR_U160_SCSI_RATE;
5622 * ipr_init_ioa_cfg - Initialize IOA config struct
5623 * @ioa_cfg: ioa config struct
5624 * @host: scsi host struct
5625 * @pdev: PCI dev struct
5630 static void __devinit ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg,
5631 struct Scsi_Host *host, struct pci_dev *pdev)
5633 const struct ipr_interrupt_offsets *p;
5634 struct ipr_interrupts *t;
5637 ioa_cfg->host = host;
5638 ioa_cfg->pdev = pdev;
5639 ioa_cfg->log_level = ipr_log_level;
5640 sprintf(ioa_cfg->eye_catcher, IPR_EYECATCHER);
5641 sprintf(ioa_cfg->trace_start, IPR_TRACE_START_LABEL);
5642 sprintf(ioa_cfg->ipr_free_label, IPR_FREEQ_LABEL);
5643 sprintf(ioa_cfg->ipr_pending_label, IPR_PENDQ_LABEL);
5644 sprintf(ioa_cfg->cfg_table_start, IPR_CFG_TBL_START);
5645 sprintf(ioa_cfg->resource_table_label, IPR_RES_TABLE_LABEL);
5646 sprintf(ioa_cfg->ipr_hcam_label, IPR_HCAM_LABEL);
5647 sprintf(ioa_cfg->ipr_cmd_label, IPR_CMD_LABEL);
5649 INIT_LIST_HEAD(&ioa_cfg->free_q);
5650 INIT_LIST_HEAD(&ioa_cfg->pending_q);
5651 INIT_LIST_HEAD(&ioa_cfg->hostrcb_free_q);
5652 INIT_LIST_HEAD(&ioa_cfg->hostrcb_pending_q);
5653 INIT_LIST_HEAD(&ioa_cfg->free_res_q);
5654 INIT_LIST_HEAD(&ioa_cfg->used_res_q);
5655 INIT_WORK(&ioa_cfg->work_q, ipr_worker_thread, ioa_cfg);
5656 init_waitqueue_head(&ioa_cfg->reset_wait_q);
5657 ioa_cfg->sdt_state = INACTIVE;
5659 ipr_initialize_bus_attr(ioa_cfg);
5661 host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS;
5662 host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET;
5663 host->max_channel = IPR_MAX_BUS_TO_SCAN;
5664 host->unique_id = host->host_no;
5665 host->max_cmd_len = IPR_MAX_CDB_LEN;
5666 pci_set_drvdata(pdev, ioa_cfg);
5668 p = &ioa_cfg->chip_cfg->regs;
5670 base = ioa_cfg->hdw_dma_regs;
5672 t->set_interrupt_mask_reg = base + p->set_interrupt_mask_reg;
5673 t->clr_interrupt_mask_reg = base + p->clr_interrupt_mask_reg;
5674 t->sense_interrupt_mask_reg = base + p->sense_interrupt_mask_reg;
5675 t->clr_interrupt_reg = base + p->clr_interrupt_reg;
5676 t->sense_interrupt_reg = base + p->sense_interrupt_reg;
5677 t->ioarrin_reg = base + p->ioarrin_reg;
5678 t->sense_uproc_interrupt_reg = base + p->sense_uproc_interrupt_reg;
5679 t->set_uproc_interrupt_reg = base + p->set_uproc_interrupt_reg;
5680 t->clr_uproc_interrupt_reg = base + p->clr_uproc_interrupt_reg;
5684 * ipr_get_chip_cfg - Find adapter chip configuration
5685 * @dev_id: PCI device id struct
5688 * ptr to chip config on success / NULL on failure
5690 static const struct ipr_chip_cfg_t * __devinit
5691 ipr_get_chip_cfg(const struct pci_device_id *dev_id)
5695 if (dev_id->driver_data)
5696 return (const struct ipr_chip_cfg_t *)dev_id->driver_data;
5698 for (i = 0; i < ARRAY_SIZE(ipr_chip); i++)
5699 if (ipr_chip[i].vendor == dev_id->vendor &&
5700 ipr_chip[i].device == dev_id->device)
5701 return ipr_chip[i].cfg;
5706 * ipr_probe_ioa - Allocates memory and does first stage of initialization
5707 * @pdev: PCI device struct
5708 * @dev_id: PCI device id struct
5711 * 0 on success / non-zero on failure
5713 static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
5714 const struct pci_device_id *dev_id)
5716 struct ipr_ioa_cfg *ioa_cfg;
5717 struct Scsi_Host *host;
5718 unsigned long ipr_regs_pci;
5719 void __iomem *ipr_regs;
5720 u32 rc = PCIBIOS_SUCCESSFUL;
5724 if ((rc = pci_enable_device(pdev))) {
5725 dev_err(&pdev->dev, "Cannot enable adapter\n");
5729 dev_info(&pdev->dev, "Found IOA with IRQ: %d\n", pdev->irq);
5731 host = scsi_host_alloc(&driver_template, sizeof(*ioa_cfg));
5734 dev_err(&pdev->dev, "call to scsi_host_alloc failed!\n");
5739 ioa_cfg = (struct ipr_ioa_cfg *)host->hostdata;
5740 memset(ioa_cfg, 0, sizeof(struct ipr_ioa_cfg));
5742 ioa_cfg->chip_cfg = ipr_get_chip_cfg(dev_id);
5744 if (!ioa_cfg->chip_cfg) {
5745 dev_err(&pdev->dev, "Unknown adapter chipset 0x%04X 0x%04X\n",
5746 dev_id->vendor, dev_id->device);
5747 goto out_scsi_host_put;
5750 ipr_regs_pci = pci_resource_start(pdev, 0);
5752 rc = pci_request_regions(pdev, IPR_NAME);
5755 "Couldn't register memory range of registers\n");
5756 goto out_scsi_host_put;
5759 ipr_regs = ioremap(ipr_regs_pci, pci_resource_len(pdev, 0));
5763 "Couldn't map memory range of registers\n");
5765 goto out_release_regions;
5768 ioa_cfg->hdw_dma_regs = ipr_regs;
5769 ioa_cfg->hdw_dma_regs_pci = ipr_regs_pci;
5770 ioa_cfg->ioa_mailbox = ioa_cfg->chip_cfg->mailbox + ipr_regs;
5772 ipr_init_ioa_cfg(ioa_cfg, host, pdev);
5774 pci_set_master(pdev);
5776 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
5778 dev_err(&pdev->dev, "Failed to set PCI DMA mask\n");
5782 rc = pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
5783 ioa_cfg->chip_cfg->cache_line_size);
5785 if (rc != PCIBIOS_SUCCESSFUL) {
5786 dev_err(&pdev->dev, "Write of cache line size failed\n");
5791 /* Save away PCI config space for use following IOA reset */
5792 rc = pci_save_state(pdev);
5794 if (rc != PCIBIOS_SUCCESSFUL) {
5795 dev_err(&pdev->dev, "Failed to save PCI config space\n");
5800 if ((rc = ipr_save_pcix_cmd_reg(ioa_cfg)))
5803 if ((rc = ipr_set_pcix_cmd_reg(ioa_cfg)))
5806 rc = ipr_alloc_mem(ioa_cfg);
5809 "Couldn't allocate enough memory for device driver!\n");
5813 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
5814 rc = request_irq(pdev->irq, ipr_isr, SA_SHIRQ, IPR_NAME, ioa_cfg);
5817 dev_err(&pdev->dev, "Couldn't register IRQ %d! rc=%d\n",
5822 spin_lock(&ipr_driver_lock);
5823 list_add_tail(&ioa_cfg->queue, &ipr_ioa_head);
5824 spin_unlock(&ipr_driver_lock);
5831 ipr_free_mem(ioa_cfg);
5834 out_release_regions:
5835 pci_release_regions(pdev);
5837 scsi_host_put(host);
5839 pci_disable_device(pdev);
5844 * ipr_scan_vsets - Scans for VSET devices
5845 * @ioa_cfg: ioa config struct
5847 * Description: Since the VSET resources do not follow SAM in that we can have
5848 * sparse LUNs with no LUN 0, we have to scan for these ourselves.
5853 static void ipr_scan_vsets(struct ipr_ioa_cfg *ioa_cfg)
5857 for (target = 0; target < IPR_MAX_NUM_TARGETS_PER_BUS; target++)
5858 for (lun = 0; lun < IPR_MAX_NUM_VSET_LUNS_PER_TARGET; lun++ )
5859 scsi_add_device(ioa_cfg->host, IPR_VSET_BUS, target, lun);
5863 * ipr_initiate_ioa_bringdown - Bring down an adapter
5864 * @ioa_cfg: ioa config struct
5865 * @shutdown_type: shutdown type
5867 * Description: This function will initiate bringing down the adapter.
5868 * This consists of issuing an IOA shutdown to the adapter
5869 * to flush the cache, and running BIST.
5870 * If the caller needs to wait on the completion of the reset,
5871 * the caller must sleep on the reset_wait_q.
5876 static void ipr_initiate_ioa_bringdown(struct ipr_ioa_cfg *ioa_cfg,
5877 enum ipr_shutdown_type shutdown_type)
5880 if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
5881 ioa_cfg->sdt_state = ABORT_DUMP;
5882 ioa_cfg->reset_retries = 0;
5883 ioa_cfg->in_ioa_bringdown = 1;
5884 ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
5889 * __ipr_remove - Remove a single adapter
5890 * @pdev: pci device struct
5892 * Adapter hot plug remove entry point.
5897 static void __ipr_remove(struct pci_dev *pdev)
5899 unsigned long host_lock_flags = 0;
5900 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
5903 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
5904 ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
5906 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
5907 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5908 flush_scheduled_work();
5909 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
5911 spin_lock(&ipr_driver_lock);
5912 list_del(&ioa_cfg->queue);
5913 spin_unlock(&ipr_driver_lock);
5915 if (ioa_cfg->sdt_state == ABORT_DUMP)
5916 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
5917 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
5919 ipr_free_all_resources(ioa_cfg);
5925 * ipr_remove - IOA hot plug remove entry point
5926 * @pdev: pci device struct
5928 * Adapter hot plug remove entry point.
5933 static void ipr_remove(struct pci_dev *pdev)
5935 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
5939 ipr_remove_trace_file(&ioa_cfg->host->shost_classdev.kobj,
5941 ipr_remove_dump_file(&ioa_cfg->host->shost_classdev.kobj,
5943 scsi_remove_host(ioa_cfg->host);
5951 * ipr_probe - Adapter hot plug add entry point
5954 * 0 on success / non-zero on failure
5956 static int __devinit ipr_probe(struct pci_dev *pdev,
5957 const struct pci_device_id *dev_id)
5959 struct ipr_ioa_cfg *ioa_cfg;
5962 rc = ipr_probe_ioa(pdev, dev_id);
5967 ioa_cfg = pci_get_drvdata(pdev);
5968 rc = ipr_probe_ioa_part2(ioa_cfg);
5975 rc = scsi_add_host(ioa_cfg->host, &pdev->dev);
5982 rc = ipr_create_trace_file(&ioa_cfg->host->shost_classdev.kobj,
5986 scsi_remove_host(ioa_cfg->host);
5991 rc = ipr_create_dump_file(&ioa_cfg->host->shost_classdev.kobj,
5995 ipr_remove_trace_file(&ioa_cfg->host->shost_classdev.kobj,
5997 scsi_remove_host(ioa_cfg->host);
6002 scsi_scan_host(ioa_cfg->host);
6003 ipr_scan_vsets(ioa_cfg);
6004 scsi_add_device(ioa_cfg->host, IPR_IOA_BUS, IPR_IOA_TARGET, IPR_IOA_LUN);
6005 ioa_cfg->allow_ml_add_del = 1;
6006 ioa_cfg->host->max_channel = IPR_VSET_BUS;
6007 schedule_work(&ioa_cfg->work_q);
6012 * ipr_shutdown - Shutdown handler.
6013 * @pdev: pci device struct
6015 * This function is invoked upon system shutdown/reboot. It will issue
6016 * an adapter shutdown to the adapter to flush the write cache.
6021 static void ipr_shutdown(struct pci_dev *pdev)
6023 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
6024 unsigned long lock_flags = 0;
6026 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
6027 ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
6028 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
6029 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
6032 static struct pci_device_id ipr_pci_table[] __devinitdata = {
6033 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
6034 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5702,
6035 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6036 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
6037 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5703,
6038 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6039 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
6040 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573D,
6041 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6042 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
6043 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573E,
6044 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6045 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
6046 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571B,
6047 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6048 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
6049 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572E,
6050 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6051 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
6052 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571A,
6053 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6054 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE,
6055 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2780,
6056 0, 0, (kernel_ulong_t)&ipr_chip_cfg[1] },
6057 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
6058 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571E,
6059 0, 0, (kernel_ulong_t)&ipr_chip_cfg[1] },
6062 MODULE_DEVICE_TABLE(pci, ipr_pci_table);
6064 static struct pci_driver ipr_driver = {
6066 .id_table = ipr_pci_table,
6068 .remove = ipr_remove,
6069 .shutdown = ipr_shutdown,
6073 * ipr_init - Module entry point
6076 * 0 on success / negative value on failure
6078 static int __init ipr_init(void)
6080 ipr_info("IBM Power RAID SCSI Device Driver version: %s %s\n",
6081 IPR_DRIVER_VERSION, IPR_DRIVER_DATE);
6083 return pci_module_init(&ipr_driver);
6087 * ipr_exit - Module unload
6089 * Module unload entry point.
6094 static void __exit ipr_exit(void)
6096 pci_unregister_driver(&ipr_driver);
6099 module_init(ipr_init);
6100 module_exit(ipr_exit);