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 unsigned int ipr_enable_cache = 1;
95 static unsigned int ipr_debug = 0;
96 static int ipr_auto_create = 1;
97 static DEFINE_SPINLOCK(ipr_driver_lock);
99 /* This table describes the differences between DMA controller chips */
100 static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
101 { /* Gemstone, Citrine, and Obsidian */
103 .cache_line_size = 0x20,
105 .set_interrupt_mask_reg = 0x0022C,
106 .clr_interrupt_mask_reg = 0x00230,
107 .sense_interrupt_mask_reg = 0x0022C,
108 .clr_interrupt_reg = 0x00228,
109 .sense_interrupt_reg = 0x00224,
110 .ioarrin_reg = 0x00404,
111 .sense_uproc_interrupt_reg = 0x00214,
112 .set_uproc_interrupt_reg = 0x00214,
113 .clr_uproc_interrupt_reg = 0x00218
116 { /* Snipe and Scamp */
118 .cache_line_size = 0x20,
120 .set_interrupt_mask_reg = 0x00288,
121 .clr_interrupt_mask_reg = 0x0028C,
122 .sense_interrupt_mask_reg = 0x00288,
123 .clr_interrupt_reg = 0x00284,
124 .sense_interrupt_reg = 0x00280,
125 .ioarrin_reg = 0x00504,
126 .sense_uproc_interrupt_reg = 0x00290,
127 .set_uproc_interrupt_reg = 0x00290,
128 .clr_uproc_interrupt_reg = 0x00294
133 static const struct ipr_chip_t ipr_chip[] = {
134 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, &ipr_chip_cfg[0] },
135 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, &ipr_chip_cfg[0] },
136 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, &ipr_chip_cfg[0] },
137 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, &ipr_chip_cfg[0] },
138 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, &ipr_chip_cfg[1] },
139 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, &ipr_chip_cfg[1] }
142 static int ipr_max_bus_speeds [] = {
143 IPR_80MBs_SCSI_RATE, IPR_U160_SCSI_RATE, IPR_U320_SCSI_RATE
146 MODULE_AUTHOR("Brian King <brking@us.ibm.com>");
147 MODULE_DESCRIPTION("IBM Power RAID SCSI Adapter Driver");
148 module_param_named(max_speed, ipr_max_speed, uint, 0);
149 MODULE_PARM_DESC(max_speed, "Maximum bus speed (0-2). Default: 1=U160. Speeds: 0=80 MB/s, 1=U160, 2=U320");
150 module_param_named(log_level, ipr_log_level, uint, 0);
151 MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver");
152 module_param_named(testmode, ipr_testmode, int, 0);
153 MODULE_PARM_DESC(testmode, "DANGEROUS!!! Allows unsupported configurations");
154 module_param_named(fastfail, ipr_fastfail, int, 0);
155 MODULE_PARM_DESC(fastfail, "Reduce timeouts and retries");
156 module_param_named(transop_timeout, ipr_transop_timeout, int, 0);
157 MODULE_PARM_DESC(transop_timeout, "Time in seconds to wait for adapter to come operational (default: 300)");
158 module_param_named(enable_cache, ipr_enable_cache, int, 0);
159 MODULE_PARM_DESC(enable_cache, "Enable adapter's non-volatile write cache (default: 1)");
160 module_param_named(debug, ipr_debug, int, 0);
161 MODULE_PARM_DESC(debug, "Enable device driver debugging logging. Set to 1 to enable. (default: 0)");
162 module_param_named(auto_create, ipr_auto_create, int, 0);
163 MODULE_PARM_DESC(auto_create, "Auto-create single device RAID 0 arrays when initialized (default: 1)");
164 MODULE_LICENSE("GPL");
165 MODULE_VERSION(IPR_DRIVER_VERSION);
167 /* A constant array of IOASCs/URCs/Error Messages */
169 struct ipr_error_table_t ipr_error_table[] = {
171 "8155: An unknown error was received"},
173 "Soft underlength error"},
175 "Command to be cancelled not found"},
177 "Qualified success"},
179 "FFFE: Soft device bus error recovered by the IOA"},
181 "FFF9: Device sector reassign successful"},
183 "FFF7: Media error recovered by device rewrite procedures"},
185 "7001: IOA sector reassignment successful"},
187 "FFF9: Soft media error. Sector reassignment recommended"},
189 "FFF7: Media error recovered by IOA rewrite procedures"},
191 "FF3D: Soft PCI bus error recovered by the IOA"},
193 "FFF6: Device hardware error recovered by the IOA"},
195 "FFF6: Device hardware error recovered by the device"},
197 "FF3D: Soft IOA error recovered by the IOA"},
199 "FFFA: Undefined device response recovered by the IOA"},
201 "FFF6: Device bus error, message or command phase"},
203 "FFF6: Failure prediction threshold exceeded"},
205 "8009: Impending cache battery pack failure"},
207 "34FF: Disk device format in progress"},
209 "Synchronization required"},
211 "No ready, IOA shutdown"},
213 "Not ready, IOA has been shutdown"},
215 "3020: Storage subsystem configuration error"},
217 "FFF5: Medium error, data unreadable, recommend reassign"},
219 "7000: Medium error, data unreadable, do not reassign"},
221 "FFF3: Disk media format bad"},
223 "3002: Addressed device failed to respond to selection"},
225 "3100: Device bus error"},
227 "3109: IOA timed out a device command"},
229 "3120: SCSI bus is not operational"},
231 "9000: IOA reserved area data check"},
233 "9001: IOA reserved area invalid data pattern"},
235 "9002: IOA reserved area LRC error"},
237 "102E: Out of alternate sectors for disk storage"},
239 "FFF4: Data transfer underlength error"},
241 "FFF4: Data transfer overlength error"},
243 "3400: Logical unit failure"},
245 "FFF4: Device microcode is corrupt"},
247 "8150: PCI bus error"},
249 "Unsupported device bus message received"},
251 "FFF4: Disk device problem"},
253 "8150: Permanent IOA failure"},
255 "3010: Disk device returned wrong response to IOA"},
257 "8151: IOA microcode error"},
259 "Device bus status error"},
261 "8157: IOA error requiring IOA reset to recover"},
263 "Message reject received from the device"},
265 "8008: A permanent cache battery pack failure occurred"},
267 "9090: Disk unit has been modified after the last known status"},
269 "9081: IOA detected device error"},
271 "9082: IOA detected device error"},
273 "3110: Device bus error, message or command phase"},
275 "9091: Incorrect hardware configuration change has been detected"},
277 "9073: Invalid multi-adapter configuration"},
279 "FFF4: Command to logical unit failed"},
281 "Illegal request, invalid request type or request packet"},
283 "Illegal request, invalid resource handle"},
285 "Illegal request, commands not allowed to this device"},
287 "Illegal request, command not allowed to a secondary adapter"},
289 "Illegal request, invalid field in parameter list"},
291 "Illegal request, parameter not supported"},
293 "Illegal request, parameter value invalid"},
295 "Illegal request, command sequence error"},
297 "Illegal request, dual adapter support not enabled"},
299 "9031: Array protection temporarily suspended, protection resuming"},
301 "9040: Array protection temporarily suspended, protection resuming"},
303 "FFFB: SCSI bus was reset"},
305 "FFFE: SCSI bus transition to single ended"},
307 "FFFE: SCSI bus transition to LVD"},
309 "FFFB: SCSI bus was reset by another initiator"},
311 "3029: A device replacement has occurred"},
313 "9051: IOA cache data exists for a missing or failed device"},
315 "9055: Auxiliary cache IOA contains cache data needed by the primary IOA"},
317 "9025: Disk unit is not supported at its physical location"},
319 "3020: IOA detected a SCSI bus configuration error"},
321 "3150: SCSI bus configuration error"},
323 "9074: Asymmetric advanced function disk configuration"},
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 "9071: Link operational transition"},
333 "9072: Link not operational transition"},
335 "9032: Array exposed but still protected"},
337 "Failure due to other device"},
339 "9008: IOA does not support functions expected by devices"},
341 "9010: Cache data associated with attached devices cannot be found"},
343 "9011: Cache data belongs to devices other than those attached"},
345 "9020: Array missing 2 or more devices with only 1 device present"},
347 "9021: Array missing 2 or more devices with 2 or more devices present"},
349 "9022: Exposed array is missing a required device"},
351 "9023: Array member(s) not at required physical locations"},
353 "9024: Array not functional due to present hardware configuration"},
355 "9026: Array not functional due to present hardware configuration"},
357 "9027: Array is missing a device and parity is out of sync"},
359 "9028: Maximum number of arrays already exist"},
361 "9050: Required cache data cannot be located for a disk unit"},
363 "9052: Cache data exists for a device that has been modified"},
365 "9054: IOA resources not available due to previous problems"},
367 "9092: Disk unit requires initialization before use"},
369 "9029: Incorrect hardware configuration change has been detected"},
371 "9060: One or more disk pairs are missing from an array"},
373 "9061: One or more disks are missing from an array"},
375 "9062: One or more disks are missing from an array"},
377 "9063: Maximum number of functional arrays has been exceeded"},
379 "Aborted command, invalid descriptor"},
381 "Command terminated by host"}
384 static const struct ipr_ses_table_entry ipr_ses_table[] = {
385 { "2104-DL1 ", "XXXXXXXXXXXXXXXX", 80 },
386 { "2104-TL1 ", "XXXXXXXXXXXXXXXX", 80 },
387 { "HSBP07M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 7 slot */
388 { "HSBP05M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 5 slot */
389 { "HSBP05M S U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Bowtie */
390 { "HSBP06E ASU2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* MartinFenning */
391 { "2104-DU3 ", "XXXXXXXXXXXXXXXX", 160 },
392 { "2104-TU3 ", "XXXXXXXXXXXXXXXX", 160 },
393 { "HSBP04C RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
394 { "HSBP06E RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
395 { "St V1S2 ", "XXXXXXXXXXXXXXXX", 160 },
396 { "HSBPD4M PU3SCSI", "XXXXXXX*XXXXXXXX", 160 },
397 { "VSBPD1H U3SCSI", "XXXXXXX*XXXXXXXX", 160 }
401 * Function Prototypes
403 static int ipr_reset_alert(struct ipr_cmnd *);
404 static void ipr_process_ccn(struct ipr_cmnd *);
405 static void ipr_process_error(struct ipr_cmnd *);
406 static void ipr_reset_ioa_job(struct ipr_cmnd *);
407 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *,
408 enum ipr_shutdown_type);
410 #ifdef CONFIG_SCSI_IPR_TRACE
412 * ipr_trc_hook - Add a trace entry to the driver trace
413 * @ipr_cmd: ipr command struct
415 * @add_data: additional data
420 static void ipr_trc_hook(struct ipr_cmnd *ipr_cmd,
421 u8 type, u32 add_data)
423 struct ipr_trace_entry *trace_entry;
424 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
426 trace_entry = &ioa_cfg->trace[ioa_cfg->trace_index++];
427 trace_entry->time = jiffies;
428 trace_entry->op_code = ipr_cmd->ioarcb.cmd_pkt.cdb[0];
429 trace_entry->type = type;
430 trace_entry->cmd_index = ipr_cmd->cmd_index;
431 trace_entry->res_handle = ipr_cmd->ioarcb.res_handle;
432 trace_entry->u.add_data = add_data;
435 #define ipr_trc_hook(ipr_cmd, type, add_data) do { } while(0)
439 * ipr_reinit_ipr_cmnd - Re-initialize an IPR Cmnd block for reuse
440 * @ipr_cmd: ipr command struct
445 static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
447 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
448 struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
450 memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
451 ioarcb->write_data_transfer_length = 0;
452 ioarcb->read_data_transfer_length = 0;
453 ioarcb->write_ioadl_len = 0;
454 ioarcb->read_ioadl_len = 0;
456 ioasa->residual_data_len = 0;
458 ipr_cmd->scsi_cmd = NULL;
459 ipr_cmd->sense_buffer[0] = 0;
460 ipr_cmd->dma_use_sg = 0;
464 * ipr_init_ipr_cmnd - Initialize an IPR Cmnd block
465 * @ipr_cmd: ipr command struct
470 static void ipr_init_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
472 ipr_reinit_ipr_cmnd(ipr_cmd);
473 ipr_cmd->u.scratch = 0;
474 ipr_cmd->sibling = NULL;
475 init_timer(&ipr_cmd->timer);
479 * ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
480 * @ioa_cfg: ioa config struct
483 * pointer to ipr command struct
486 struct ipr_cmnd *ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg *ioa_cfg)
488 struct ipr_cmnd *ipr_cmd;
490 ipr_cmd = list_entry(ioa_cfg->free_q.next, struct ipr_cmnd, queue);
491 list_del(&ipr_cmd->queue);
492 ipr_init_ipr_cmnd(ipr_cmd);
498 * ipr_unmap_sglist - Unmap scatterlist if mapped
499 * @ioa_cfg: ioa config struct
500 * @ipr_cmd: ipr command struct
505 static void ipr_unmap_sglist(struct ipr_ioa_cfg *ioa_cfg,
506 struct ipr_cmnd *ipr_cmd)
508 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
510 if (ipr_cmd->dma_use_sg) {
511 if (scsi_cmd->use_sg > 0) {
512 pci_unmap_sg(ioa_cfg->pdev, scsi_cmd->request_buffer,
514 scsi_cmd->sc_data_direction);
516 pci_unmap_single(ioa_cfg->pdev, ipr_cmd->dma_handle,
517 scsi_cmd->request_bufflen,
518 scsi_cmd->sc_data_direction);
524 * ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts
525 * @ioa_cfg: ioa config struct
526 * @clr_ints: interrupts to clear
528 * This function masks all interrupts on the adapter, then clears the
529 * interrupts specified in the mask
534 static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg,
537 volatile u32 int_reg;
539 /* Stop new interrupts */
540 ioa_cfg->allow_interrupts = 0;
542 /* Set interrupt mask to stop all new interrupts */
543 writel(~0, ioa_cfg->regs.set_interrupt_mask_reg);
545 /* Clear any pending interrupts */
546 writel(clr_ints, ioa_cfg->regs.clr_interrupt_reg);
547 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
551 * ipr_save_pcix_cmd_reg - Save PCI-X command register
552 * @ioa_cfg: ioa config struct
555 * 0 on success / -EIO on failure
557 static int ipr_save_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
559 int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
561 if (pcix_cmd_reg == 0) {
562 dev_err(&ioa_cfg->pdev->dev, "Failed to save PCI-X command register\n");
566 if (pci_read_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
567 &ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
568 dev_err(&ioa_cfg->pdev->dev, "Failed to save PCI-X command register\n");
572 ioa_cfg->saved_pcix_cmd_reg |= PCI_X_CMD_DPERR_E | PCI_X_CMD_ERO;
577 * ipr_set_pcix_cmd_reg - Setup PCI-X command register
578 * @ioa_cfg: ioa config struct
581 * 0 on success / -EIO on failure
583 static int ipr_set_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
585 int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
588 if (pci_write_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
589 ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
590 dev_err(&ioa_cfg->pdev->dev, "Failed to setup PCI-X command register\n");
594 dev_err(&ioa_cfg->pdev->dev,
595 "Failed to setup PCI-X command register\n");
603 * ipr_scsi_eh_done - mid-layer done function for aborted ops
604 * @ipr_cmd: ipr command struct
606 * This function is invoked by the interrupt handler for
607 * ops generated by the SCSI mid-layer which are being aborted.
612 static void ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
614 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
615 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
617 scsi_cmd->result |= (DID_ERROR << 16);
619 ipr_unmap_sglist(ioa_cfg, ipr_cmd);
620 scsi_cmd->scsi_done(scsi_cmd);
621 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
625 * ipr_fail_all_ops - Fails all outstanding ops.
626 * @ioa_cfg: ioa config struct
628 * This function fails all outstanding ops.
633 static void ipr_fail_all_ops(struct ipr_ioa_cfg *ioa_cfg)
635 struct ipr_cmnd *ipr_cmd, *temp;
638 list_for_each_entry_safe(ipr_cmd, temp, &ioa_cfg->pending_q, queue) {
639 list_del(&ipr_cmd->queue);
641 ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_IOA_WAS_RESET);
642 ipr_cmd->ioasa.ilid = cpu_to_be32(IPR_DRIVER_ILID);
644 if (ipr_cmd->scsi_cmd)
645 ipr_cmd->done = ipr_scsi_eh_done;
647 ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, IPR_IOASC_IOA_WAS_RESET);
648 del_timer(&ipr_cmd->timer);
649 ipr_cmd->done(ipr_cmd);
656 * ipr_do_req - Send driver initiated requests.
657 * @ipr_cmd: ipr command struct
658 * @done: done function
659 * @timeout_func: timeout function
660 * @timeout: timeout value
662 * This function sends the specified command to the adapter with the
663 * timeout given. The done function is invoked on command completion.
668 static void ipr_do_req(struct ipr_cmnd *ipr_cmd,
669 void (*done) (struct ipr_cmnd *),
670 void (*timeout_func) (struct ipr_cmnd *), u32 timeout)
672 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
674 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
676 ipr_cmd->done = done;
678 ipr_cmd->timer.data = (unsigned long) ipr_cmd;
679 ipr_cmd->timer.expires = jiffies + timeout;
680 ipr_cmd->timer.function = (void (*)(unsigned long))timeout_func;
682 add_timer(&ipr_cmd->timer);
684 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, 0);
687 writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
688 ioa_cfg->regs.ioarrin_reg);
692 * ipr_internal_cmd_done - Op done function for an internally generated op.
693 * @ipr_cmd: ipr command struct
695 * This function is the op done function for an internally generated,
696 * blocking op. It simply wakes the sleeping thread.
701 static void ipr_internal_cmd_done(struct ipr_cmnd *ipr_cmd)
703 if (ipr_cmd->sibling)
704 ipr_cmd->sibling = NULL;
706 complete(&ipr_cmd->completion);
710 * ipr_send_blocking_cmd - Send command and sleep on its completion.
711 * @ipr_cmd: ipr command struct
712 * @timeout_func: function to invoke if command times out
718 static void ipr_send_blocking_cmd(struct ipr_cmnd *ipr_cmd,
719 void (*timeout_func) (struct ipr_cmnd *ipr_cmd),
722 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
724 init_completion(&ipr_cmd->completion);
725 ipr_do_req(ipr_cmd, ipr_internal_cmd_done, timeout_func, timeout);
727 spin_unlock_irq(ioa_cfg->host->host_lock);
728 wait_for_completion(&ipr_cmd->completion);
729 spin_lock_irq(ioa_cfg->host->host_lock);
733 * ipr_send_hcam - Send an HCAM to the adapter.
734 * @ioa_cfg: ioa config struct
736 * @hostrcb: hostrcb struct
738 * This function will send a Host Controlled Async command to the adapter.
739 * If HCAMs are currently not allowed to be issued to the adapter, it will
740 * place the hostrcb on the free queue.
745 static void ipr_send_hcam(struct ipr_ioa_cfg *ioa_cfg, u8 type,
746 struct ipr_hostrcb *hostrcb)
748 struct ipr_cmnd *ipr_cmd;
749 struct ipr_ioarcb *ioarcb;
751 if (ioa_cfg->allow_cmds) {
752 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
753 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
754 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_pending_q);
756 ipr_cmd->u.hostrcb = hostrcb;
757 ioarcb = &ipr_cmd->ioarcb;
759 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
760 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_HCAM;
761 ioarcb->cmd_pkt.cdb[0] = IPR_HOST_CONTROLLED_ASYNC;
762 ioarcb->cmd_pkt.cdb[1] = type;
763 ioarcb->cmd_pkt.cdb[7] = (sizeof(hostrcb->hcam) >> 8) & 0xff;
764 ioarcb->cmd_pkt.cdb[8] = sizeof(hostrcb->hcam) & 0xff;
766 ioarcb->read_data_transfer_length = cpu_to_be32(sizeof(hostrcb->hcam));
767 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
768 ipr_cmd->ioadl[0].flags_and_data_len =
769 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | sizeof(hostrcb->hcam));
770 ipr_cmd->ioadl[0].address = cpu_to_be32(hostrcb->hostrcb_dma);
772 if (type == IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE)
773 ipr_cmd->done = ipr_process_ccn;
775 ipr_cmd->done = ipr_process_error;
777 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_IOA_RES_ADDR);
780 writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
781 ioa_cfg->regs.ioarrin_reg);
783 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
788 * ipr_init_res_entry - Initialize a resource entry struct.
789 * @res: resource entry struct
794 static void ipr_init_res_entry(struct ipr_resource_entry *res)
796 res->needs_sync_complete = 0;
799 res->del_from_ml = 0;
800 res->resetting_device = 0;
805 * ipr_handle_config_change - Handle a config change from the adapter
806 * @ioa_cfg: ioa config struct
812 static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg,
813 struct ipr_hostrcb *hostrcb)
815 struct ipr_resource_entry *res = NULL;
816 struct ipr_config_table_entry *cfgte;
819 cfgte = &hostrcb->hcam.u.ccn.cfgte;
821 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
822 if (!memcmp(&res->cfgte.res_addr, &cfgte->res_addr,
823 sizeof(cfgte->res_addr))) {
830 if (list_empty(&ioa_cfg->free_res_q)) {
831 ipr_send_hcam(ioa_cfg,
832 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
837 res = list_entry(ioa_cfg->free_res_q.next,
838 struct ipr_resource_entry, queue);
840 list_del(&res->queue);
841 ipr_init_res_entry(res);
842 list_add_tail(&res->queue, &ioa_cfg->used_res_q);
845 memcpy(&res->cfgte, cfgte, sizeof(struct ipr_config_table_entry));
847 if (hostrcb->hcam.notify_type == IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY) {
849 res->del_from_ml = 1;
850 res->cfgte.res_handle = IPR_INVALID_RES_HANDLE;
851 if (ioa_cfg->allow_ml_add_del)
852 schedule_work(&ioa_cfg->work_q);
854 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
855 } else if (!res->sdev) {
857 if (ioa_cfg->allow_ml_add_del)
858 schedule_work(&ioa_cfg->work_q);
861 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
865 * ipr_process_ccn - Op done function for a CCN.
866 * @ipr_cmd: ipr command struct
868 * This function is the op done function for a configuration
869 * change notification host controlled async from the adapter.
874 static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd)
876 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
877 struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
878 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
880 list_del(&hostrcb->queue);
881 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
884 if (ioasc != IPR_IOASC_IOA_WAS_RESET)
885 dev_err(&ioa_cfg->pdev->dev,
886 "Host RCB failed with IOASC: 0x%08X\n", ioasc);
888 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
890 ipr_handle_config_change(ioa_cfg, hostrcb);
895 * ipr_log_vpd - Log the passed VPD to the error log.
896 * @vpd: vendor/product id/sn struct
901 static void ipr_log_vpd(struct ipr_vpd *vpd)
903 char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN
904 + IPR_SERIAL_NUM_LEN];
906 memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
907 memcpy(buffer + IPR_VENDOR_ID_LEN, vpd->vpids.product_id,
909 buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN] = '\0';
910 ipr_err("Vendor/Product ID: %s\n", buffer);
912 memcpy(buffer, vpd->sn, IPR_SERIAL_NUM_LEN);
913 buffer[IPR_SERIAL_NUM_LEN] = '\0';
914 ipr_err(" Serial Number: %s\n", buffer);
918 * ipr_log_ext_vpd - Log the passed extended VPD to the error log.
919 * @vpd: vendor/product id/sn/wwn struct
924 static void ipr_log_ext_vpd(struct ipr_ext_vpd *vpd)
926 ipr_log_vpd(&vpd->vpd);
927 ipr_err(" WWN: %08X%08X\n", be32_to_cpu(vpd->wwid[0]),
928 be32_to_cpu(vpd->wwid[1]));
932 * ipr_log_enhanced_cache_error - Log a cache error.
933 * @ioa_cfg: ioa config struct
934 * @hostrcb: hostrcb struct
939 static void ipr_log_enhanced_cache_error(struct ipr_ioa_cfg *ioa_cfg,
940 struct ipr_hostrcb *hostrcb)
942 struct ipr_hostrcb_type_12_error *error =
943 &hostrcb->hcam.u.error.u.type_12_error;
945 ipr_err("-----Current Configuration-----\n");
946 ipr_err("Cache Directory Card Information:\n");
947 ipr_log_ext_vpd(&error->ioa_vpd);
948 ipr_err("Adapter Card Information:\n");
949 ipr_log_ext_vpd(&error->cfc_vpd);
951 ipr_err("-----Expected Configuration-----\n");
952 ipr_err("Cache Directory Card Information:\n");
953 ipr_log_ext_vpd(&error->ioa_last_attached_to_cfc_vpd);
954 ipr_err("Adapter Card Information:\n");
955 ipr_log_ext_vpd(&error->cfc_last_attached_to_ioa_vpd);
957 ipr_err("Additional IOA Data: %08X %08X %08X\n",
958 be32_to_cpu(error->ioa_data[0]),
959 be32_to_cpu(error->ioa_data[1]),
960 be32_to_cpu(error->ioa_data[2]));
964 * ipr_log_cache_error - Log a cache error.
965 * @ioa_cfg: ioa config struct
966 * @hostrcb: hostrcb struct
971 static void ipr_log_cache_error(struct ipr_ioa_cfg *ioa_cfg,
972 struct ipr_hostrcb *hostrcb)
974 struct ipr_hostrcb_type_02_error *error =
975 &hostrcb->hcam.u.error.u.type_02_error;
977 ipr_err("-----Current Configuration-----\n");
978 ipr_err("Cache Directory Card Information:\n");
979 ipr_log_vpd(&error->ioa_vpd);
980 ipr_err("Adapter Card Information:\n");
981 ipr_log_vpd(&error->cfc_vpd);
983 ipr_err("-----Expected Configuration-----\n");
984 ipr_err("Cache Directory Card Information:\n");
985 ipr_log_vpd(&error->ioa_last_attached_to_cfc_vpd);
986 ipr_err("Adapter Card Information:\n");
987 ipr_log_vpd(&error->cfc_last_attached_to_ioa_vpd);
989 ipr_err("Additional IOA Data: %08X %08X %08X\n",
990 be32_to_cpu(error->ioa_data[0]),
991 be32_to_cpu(error->ioa_data[1]),
992 be32_to_cpu(error->ioa_data[2]));
996 * ipr_log_enhanced_config_error - Log a configuration error.
997 * @ioa_cfg: ioa config struct
998 * @hostrcb: hostrcb struct
1003 static void ipr_log_enhanced_config_error(struct ipr_ioa_cfg *ioa_cfg,
1004 struct ipr_hostrcb *hostrcb)
1006 int errors_logged, i;
1007 struct ipr_hostrcb_device_data_entry_enhanced *dev_entry;
1008 struct ipr_hostrcb_type_13_error *error;
1010 error = &hostrcb->hcam.u.error.u.type_13_error;
1011 errors_logged = be32_to_cpu(error->errors_logged);
1013 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1014 be32_to_cpu(error->errors_detected), errors_logged);
1016 dev_entry = error->dev;
1018 for (i = 0; i < errors_logged; i++, dev_entry++) {
1021 ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1022 ipr_log_ext_vpd(&dev_entry->vpd);
1024 ipr_err("-----New Device Information-----\n");
1025 ipr_log_ext_vpd(&dev_entry->new_vpd);
1027 ipr_err("Cache Directory Card Information:\n");
1028 ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1030 ipr_err("Adapter Card Information:\n");
1031 ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1036 * ipr_log_config_error - Log a configuration error.
1037 * @ioa_cfg: ioa config struct
1038 * @hostrcb: hostrcb struct
1043 static void ipr_log_config_error(struct ipr_ioa_cfg *ioa_cfg,
1044 struct ipr_hostrcb *hostrcb)
1046 int errors_logged, i;
1047 struct ipr_hostrcb_device_data_entry *dev_entry;
1048 struct ipr_hostrcb_type_03_error *error;
1050 error = &hostrcb->hcam.u.error.u.type_03_error;
1051 errors_logged = be32_to_cpu(error->errors_logged);
1053 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1054 be32_to_cpu(error->errors_detected), errors_logged);
1056 dev_entry = error->dev;
1058 for (i = 0; i < errors_logged; i++, dev_entry++) {
1061 ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1062 ipr_log_vpd(&dev_entry->vpd);
1064 ipr_err("-----New Device Information-----\n");
1065 ipr_log_vpd(&dev_entry->new_vpd);
1067 ipr_err("Cache Directory Card Information:\n");
1068 ipr_log_vpd(&dev_entry->ioa_last_with_dev_vpd);
1070 ipr_err("Adapter Card Information:\n");
1071 ipr_log_vpd(&dev_entry->cfc_last_with_dev_vpd);
1073 ipr_err("Additional IOA Data: %08X %08X %08X %08X %08X\n",
1074 be32_to_cpu(dev_entry->ioa_data[0]),
1075 be32_to_cpu(dev_entry->ioa_data[1]),
1076 be32_to_cpu(dev_entry->ioa_data[2]),
1077 be32_to_cpu(dev_entry->ioa_data[3]),
1078 be32_to_cpu(dev_entry->ioa_data[4]));
1083 * ipr_log_enhanced_array_error - Log an array configuration error.
1084 * @ioa_cfg: ioa config struct
1085 * @hostrcb: hostrcb struct
1090 static void ipr_log_enhanced_array_error(struct ipr_ioa_cfg *ioa_cfg,
1091 struct ipr_hostrcb *hostrcb)
1094 struct ipr_hostrcb_type_14_error *error;
1095 struct ipr_hostrcb_array_data_entry_enhanced *array_entry;
1096 const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1098 error = &hostrcb->hcam.u.error.u.type_14_error;
1102 ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1103 error->protection_level,
1104 ioa_cfg->host->host_no,
1105 error->last_func_vset_res_addr.bus,
1106 error->last_func_vset_res_addr.target,
1107 error->last_func_vset_res_addr.lun);
1111 array_entry = error->array_member;
1112 num_entries = min_t(u32, be32_to_cpu(error->num_entries),
1113 sizeof(error->array_member));
1115 for (i = 0; i < num_entries; i++, array_entry++) {
1116 if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1119 if (be32_to_cpu(error->exposed_mode_adn) == i)
1120 ipr_err("Exposed Array Member %d:\n", i);
1122 ipr_err("Array Member %d:\n", i);
1124 ipr_log_ext_vpd(&array_entry->vpd);
1125 ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1126 ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1127 "Expected Location");
1134 * ipr_log_array_error - Log an array configuration error.
1135 * @ioa_cfg: ioa config struct
1136 * @hostrcb: hostrcb struct
1141 static void ipr_log_array_error(struct ipr_ioa_cfg *ioa_cfg,
1142 struct ipr_hostrcb *hostrcb)
1145 struct ipr_hostrcb_type_04_error *error;
1146 struct ipr_hostrcb_array_data_entry *array_entry;
1147 const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1149 error = &hostrcb->hcam.u.error.u.type_04_error;
1153 ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1154 error->protection_level,
1155 ioa_cfg->host->host_no,
1156 error->last_func_vset_res_addr.bus,
1157 error->last_func_vset_res_addr.target,
1158 error->last_func_vset_res_addr.lun);
1162 array_entry = error->array_member;
1164 for (i = 0; i < 18; i++) {
1165 if (!memcmp(array_entry->vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1168 if (be32_to_cpu(error->exposed_mode_adn) == i)
1169 ipr_err("Exposed Array Member %d:\n", i);
1171 ipr_err("Array Member %d:\n", i);
1173 ipr_log_vpd(&array_entry->vpd);
1175 ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1176 ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1177 "Expected Location");
1182 array_entry = error->array_member2;
1189 * ipr_log_hex_data - Log additional hex IOA error data.
1190 * @data: IOA error data
1196 static void ipr_log_hex_data(u32 *data, int len)
1203 for (i = 0; i < len / 4; i += 4) {
1204 ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
1205 be32_to_cpu(data[i]),
1206 be32_to_cpu(data[i+1]),
1207 be32_to_cpu(data[i+2]),
1208 be32_to_cpu(data[i+3]));
1213 * ipr_log_enhanced_dual_ioa_error - Log an enhanced dual adapter error.
1214 * @ioa_cfg: ioa config struct
1215 * @hostrcb: hostrcb struct
1220 static void ipr_log_enhanced_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1221 struct ipr_hostrcb *hostrcb)
1223 struct ipr_hostrcb_type_17_error *error;
1225 error = &hostrcb->hcam.u.error.u.type_17_error;
1226 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1228 ipr_err("%s\n", error->failure_reason);
1229 ipr_err("Remote Adapter VPD:\n");
1230 ipr_log_ext_vpd(&error->vpd);
1231 ipr_log_hex_data(error->data,
1232 be32_to_cpu(hostrcb->hcam.length) -
1233 (offsetof(struct ipr_hostrcb_error, u) +
1234 offsetof(struct ipr_hostrcb_type_17_error, data)));
1238 * ipr_log_dual_ioa_error - Log a dual adapter error.
1239 * @ioa_cfg: ioa config struct
1240 * @hostrcb: hostrcb struct
1245 static void ipr_log_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1246 struct ipr_hostrcb *hostrcb)
1248 struct ipr_hostrcb_type_07_error *error;
1250 error = &hostrcb->hcam.u.error.u.type_07_error;
1251 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1253 ipr_err("%s\n", error->failure_reason);
1254 ipr_err("Remote Adapter VPD:\n");
1255 ipr_log_vpd(&error->vpd);
1256 ipr_log_hex_data(error->data,
1257 be32_to_cpu(hostrcb->hcam.length) -
1258 (offsetof(struct ipr_hostrcb_error, u) +
1259 offsetof(struct ipr_hostrcb_type_07_error, data)));
1263 * ipr_log_generic_error - Log an adapter error.
1264 * @ioa_cfg: ioa config struct
1265 * @hostrcb: hostrcb struct
1270 static void ipr_log_generic_error(struct ipr_ioa_cfg *ioa_cfg,
1271 struct ipr_hostrcb *hostrcb)
1273 ipr_log_hex_data(hostrcb->hcam.u.raw.data,
1274 be32_to_cpu(hostrcb->hcam.length));
1278 * ipr_get_error - Find the specfied IOASC in the ipr_error_table.
1281 * This function will return the index of into the ipr_error_table
1282 * for the specified IOASC. If the IOASC is not in the table,
1283 * 0 will be returned, which points to the entry used for unknown errors.
1286 * index into the ipr_error_table
1288 static u32 ipr_get_error(u32 ioasc)
1292 for (i = 0; i < ARRAY_SIZE(ipr_error_table); i++)
1293 if (ipr_error_table[i].ioasc == ioasc)
1300 * ipr_handle_log_data - Log an adapter error.
1301 * @ioa_cfg: ioa config struct
1302 * @hostrcb: hostrcb struct
1304 * This function logs an adapter error to the system.
1309 static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
1310 struct ipr_hostrcb *hostrcb)
1315 if (hostrcb->hcam.notify_type != IPR_HOST_RCB_NOTIF_TYPE_ERROR_LOG_ENTRY)
1318 if (hostrcb->hcam.notifications_lost == IPR_HOST_RCB_NOTIFICATIONS_LOST)
1319 dev_err(&ioa_cfg->pdev->dev, "Error notifications lost\n");
1321 ioasc = be32_to_cpu(hostrcb->hcam.u.error.failing_dev_ioasc);
1323 if (ioasc == IPR_IOASC_BUS_WAS_RESET ||
1324 ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER) {
1325 /* Tell the midlayer we had a bus reset so it will handle the UA properly */
1326 scsi_report_bus_reset(ioa_cfg->host,
1327 hostrcb->hcam.u.error.failing_dev_res_addr.bus);
1330 error_index = ipr_get_error(ioasc);
1332 if (!ipr_error_table[error_index].log_hcam)
1335 if (ipr_is_device(&hostrcb->hcam.u.error.failing_dev_res_addr)) {
1336 ipr_ra_err(ioa_cfg, hostrcb->hcam.u.error.failing_dev_res_addr,
1337 "%s\n", ipr_error_table[error_index].error);
1339 dev_err(&ioa_cfg->pdev->dev, "%s\n",
1340 ipr_error_table[error_index].error);
1343 /* Set indication we have logged an error */
1344 ioa_cfg->errors_logged++;
1346 if (ioa_cfg->log_level < IPR_DEFAULT_LOG_LEVEL)
1348 if (be32_to_cpu(hostrcb->hcam.length) > sizeof(hostrcb->hcam.u.raw))
1349 hostrcb->hcam.length = cpu_to_be32(sizeof(hostrcb->hcam.u.raw));
1351 switch (hostrcb->hcam.overlay_id) {
1352 case IPR_HOST_RCB_OVERLAY_ID_2:
1353 ipr_log_cache_error(ioa_cfg, hostrcb);
1355 case IPR_HOST_RCB_OVERLAY_ID_3:
1356 ipr_log_config_error(ioa_cfg, hostrcb);
1358 case IPR_HOST_RCB_OVERLAY_ID_4:
1359 case IPR_HOST_RCB_OVERLAY_ID_6:
1360 ipr_log_array_error(ioa_cfg, hostrcb);
1362 case IPR_HOST_RCB_OVERLAY_ID_7:
1363 ipr_log_dual_ioa_error(ioa_cfg, hostrcb);
1365 case IPR_HOST_RCB_OVERLAY_ID_12:
1366 ipr_log_enhanced_cache_error(ioa_cfg, hostrcb);
1368 case IPR_HOST_RCB_OVERLAY_ID_13:
1369 ipr_log_enhanced_config_error(ioa_cfg, hostrcb);
1371 case IPR_HOST_RCB_OVERLAY_ID_14:
1372 case IPR_HOST_RCB_OVERLAY_ID_16:
1373 ipr_log_enhanced_array_error(ioa_cfg, hostrcb);
1375 case IPR_HOST_RCB_OVERLAY_ID_17:
1376 ipr_log_enhanced_dual_ioa_error(ioa_cfg, hostrcb);
1378 case IPR_HOST_RCB_OVERLAY_ID_1:
1379 case IPR_HOST_RCB_OVERLAY_ID_DEFAULT:
1381 ipr_log_generic_error(ioa_cfg, hostrcb);
1387 * ipr_process_error - Op done function for an adapter error log.
1388 * @ipr_cmd: ipr command struct
1390 * This function is the op done function for an error log host
1391 * controlled async from the adapter. It will log the error and
1392 * send the HCAM back to the adapter.
1397 static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
1399 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1400 struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
1401 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
1403 list_del(&hostrcb->queue);
1404 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
1407 ipr_handle_log_data(ioa_cfg, hostrcb);
1408 } else if (ioasc != IPR_IOASC_IOA_WAS_RESET) {
1409 dev_err(&ioa_cfg->pdev->dev,
1410 "Host RCB failed with IOASC: 0x%08X\n", ioasc);
1413 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
1417 * ipr_timeout - An internally generated op has timed out.
1418 * @ipr_cmd: ipr command struct
1420 * This function blocks host requests and initiates an
1426 static void ipr_timeout(struct ipr_cmnd *ipr_cmd)
1428 unsigned long lock_flags = 0;
1429 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1432 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1434 ioa_cfg->errors_logged++;
1435 dev_err(&ioa_cfg->pdev->dev,
1436 "Adapter being reset due to command timeout.\n");
1438 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
1439 ioa_cfg->sdt_state = GET_DUMP;
1441 if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd)
1442 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
1444 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1449 * ipr_oper_timeout - Adapter timed out transitioning to operational
1450 * @ipr_cmd: ipr command struct
1452 * This function blocks host requests and initiates an
1458 static void ipr_oper_timeout(struct ipr_cmnd *ipr_cmd)
1460 unsigned long lock_flags = 0;
1461 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1464 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1466 ioa_cfg->errors_logged++;
1467 dev_err(&ioa_cfg->pdev->dev,
1468 "Adapter timed out transitioning to operational.\n");
1470 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
1471 ioa_cfg->sdt_state = GET_DUMP;
1473 if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd) {
1475 ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
1476 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
1479 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1484 * ipr_reset_reload - Reset/Reload the IOA
1485 * @ioa_cfg: ioa config struct
1486 * @shutdown_type: shutdown type
1488 * This function resets the adapter and re-initializes it.
1489 * This function assumes that all new host commands have been stopped.
1493 static int ipr_reset_reload(struct ipr_ioa_cfg *ioa_cfg,
1494 enum ipr_shutdown_type shutdown_type)
1496 if (!ioa_cfg->in_reset_reload)
1497 ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
1499 spin_unlock_irq(ioa_cfg->host->host_lock);
1500 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
1501 spin_lock_irq(ioa_cfg->host->host_lock);
1503 /* If we got hit with a host reset while we were already resetting
1504 the adapter for some reason, and the reset failed. */
1505 if (ioa_cfg->ioa_is_dead) {
1514 * ipr_find_ses_entry - Find matching SES in SES table
1515 * @res: resource entry struct of SES
1518 * pointer to SES table entry / NULL on failure
1520 static const struct ipr_ses_table_entry *
1521 ipr_find_ses_entry(struct ipr_resource_entry *res)
1524 const struct ipr_ses_table_entry *ste = ipr_ses_table;
1526 for (i = 0; i < ARRAY_SIZE(ipr_ses_table); i++, ste++) {
1527 for (j = 0, matches = 0; j < IPR_PROD_ID_LEN; j++) {
1528 if (ste->compare_product_id_byte[j] == 'X') {
1529 if (res->cfgte.std_inq_data.vpids.product_id[j] == ste->product_id[j])
1537 if (matches == IPR_PROD_ID_LEN)
1545 * ipr_get_max_scsi_speed - Determine max SCSI speed for a given bus
1546 * @ioa_cfg: ioa config struct
1548 * @bus_width: bus width
1551 * SCSI bus speed in units of 100KHz, 1600 is 160 MHz
1552 * For a 2-byte wide SCSI bus, the maximum transfer speed is
1553 * twice the maximum transfer rate (e.g. for a wide enabled bus,
1554 * max 160MHz = max 320MB/sec).
1556 static u32 ipr_get_max_scsi_speed(struct ipr_ioa_cfg *ioa_cfg, u8 bus, u8 bus_width)
1558 struct ipr_resource_entry *res;
1559 const struct ipr_ses_table_entry *ste;
1560 u32 max_xfer_rate = IPR_MAX_SCSI_RATE(bus_width);
1562 /* Loop through each config table entry in the config table buffer */
1563 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
1564 if (!(IPR_IS_SES_DEVICE(res->cfgte.std_inq_data)))
1567 if (bus != res->cfgte.res_addr.bus)
1570 if (!(ste = ipr_find_ses_entry(res)))
1573 max_xfer_rate = (ste->max_bus_speed_limit * 10) / (bus_width / 8);
1576 return max_xfer_rate;
1580 * ipr_wait_iodbg_ack - Wait for an IODEBUG ACK from the IOA
1581 * @ioa_cfg: ioa config struct
1582 * @max_delay: max delay in micro-seconds to wait
1584 * Waits for an IODEBUG ACK from the IOA, doing busy looping.
1587 * 0 on success / other on failure
1589 static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg *ioa_cfg, int max_delay)
1591 volatile u32 pcii_reg;
1594 /* Read interrupt reg until IOA signals IO Debug Acknowledge */
1595 while (delay < max_delay) {
1596 pcii_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
1598 if (pcii_reg & IPR_PCII_IO_DEBUG_ACKNOWLEDGE)
1601 /* udelay cannot be used if delay is more than a few milliseconds */
1602 if ((delay / 1000) > MAX_UDELAY_MS)
1603 mdelay(delay / 1000);
1613 * ipr_get_ldump_data_section - Dump IOA memory
1614 * @ioa_cfg: ioa config struct
1615 * @start_addr: adapter address to dump
1616 * @dest: destination kernel buffer
1617 * @length_in_words: length to dump in 4 byte words
1620 * 0 on success / -EIO on failure
1622 static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
1624 __be32 *dest, u32 length_in_words)
1626 volatile u32 temp_pcii_reg;
1629 /* Write IOA interrupt reg starting LDUMP state */
1630 writel((IPR_UPROCI_RESET_ALERT | IPR_UPROCI_IO_DEBUG_ALERT),
1631 ioa_cfg->regs.set_uproc_interrupt_reg);
1633 /* Wait for IO debug acknowledge */
1634 if (ipr_wait_iodbg_ack(ioa_cfg,
1635 IPR_LDUMP_MAX_LONG_ACK_DELAY_IN_USEC)) {
1636 dev_err(&ioa_cfg->pdev->dev,
1637 "IOA dump long data transfer timeout\n");
1641 /* Signal LDUMP interlocked - clear IO debug ack */
1642 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
1643 ioa_cfg->regs.clr_interrupt_reg);
1645 /* Write Mailbox with starting address */
1646 writel(start_addr, ioa_cfg->ioa_mailbox);
1648 /* Signal address valid - clear IOA Reset alert */
1649 writel(IPR_UPROCI_RESET_ALERT,
1650 ioa_cfg->regs.clr_uproc_interrupt_reg);
1652 for (i = 0; i < length_in_words; i++) {
1653 /* Wait for IO debug acknowledge */
1654 if (ipr_wait_iodbg_ack(ioa_cfg,
1655 IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC)) {
1656 dev_err(&ioa_cfg->pdev->dev,
1657 "IOA dump short data transfer timeout\n");
1661 /* Read data from mailbox and increment destination pointer */
1662 *dest = cpu_to_be32(readl(ioa_cfg->ioa_mailbox));
1665 /* For all but the last word of data, signal data received */
1666 if (i < (length_in_words - 1)) {
1667 /* Signal dump data received - Clear IO debug Ack */
1668 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
1669 ioa_cfg->regs.clr_interrupt_reg);
1673 /* Signal end of block transfer. Set reset alert then clear IO debug ack */
1674 writel(IPR_UPROCI_RESET_ALERT,
1675 ioa_cfg->regs.set_uproc_interrupt_reg);
1677 writel(IPR_UPROCI_IO_DEBUG_ALERT,
1678 ioa_cfg->regs.clr_uproc_interrupt_reg);
1680 /* Signal dump data received - Clear IO debug Ack */
1681 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
1682 ioa_cfg->regs.clr_interrupt_reg);
1684 /* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
1685 while (delay < IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC) {
1687 readl(ioa_cfg->regs.sense_uproc_interrupt_reg);
1689 if (!(temp_pcii_reg & IPR_UPROCI_RESET_ALERT))
1699 #ifdef CONFIG_SCSI_IPR_DUMP
1701 * ipr_sdt_copy - Copy Smart Dump Table to kernel buffer
1702 * @ioa_cfg: ioa config struct
1703 * @pci_address: adapter address
1704 * @length: length of data to copy
1706 * Copy data from PCI adapter to kernel buffer.
1707 * Note: length MUST be a 4 byte multiple
1709 * 0 on success / other on failure
1711 static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
1712 unsigned long pci_address, u32 length)
1714 int bytes_copied = 0;
1715 int cur_len, rc, rem_len, rem_page_len;
1717 unsigned long lock_flags = 0;
1718 struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
1720 while (bytes_copied < length &&
1721 (ioa_dump->hdr.len + bytes_copied) < IPR_MAX_IOA_DUMP_SIZE) {
1722 if (ioa_dump->page_offset >= PAGE_SIZE ||
1723 ioa_dump->page_offset == 0) {
1724 page = (__be32 *)__get_free_page(GFP_ATOMIC);
1728 return bytes_copied;
1731 ioa_dump->page_offset = 0;
1732 ioa_dump->ioa_data[ioa_dump->next_page_index] = page;
1733 ioa_dump->next_page_index++;
1735 page = ioa_dump->ioa_data[ioa_dump->next_page_index - 1];
1737 rem_len = length - bytes_copied;
1738 rem_page_len = PAGE_SIZE - ioa_dump->page_offset;
1739 cur_len = min(rem_len, rem_page_len);
1741 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1742 if (ioa_cfg->sdt_state == ABORT_DUMP) {
1745 rc = ipr_get_ldump_data_section(ioa_cfg,
1746 pci_address + bytes_copied,
1747 &page[ioa_dump->page_offset / 4],
1748 (cur_len / sizeof(u32)));
1750 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1753 ioa_dump->page_offset += cur_len;
1754 bytes_copied += cur_len;
1762 return bytes_copied;
1766 * ipr_init_dump_entry_hdr - Initialize a dump entry header.
1767 * @hdr: dump entry header struct
1772 static void ipr_init_dump_entry_hdr(struct ipr_dump_entry_header *hdr)
1774 hdr->eye_catcher = IPR_DUMP_EYE_CATCHER;
1776 hdr->offset = sizeof(*hdr);
1777 hdr->status = IPR_DUMP_STATUS_SUCCESS;
1781 * ipr_dump_ioa_type_data - Fill in the adapter type in the dump.
1782 * @ioa_cfg: ioa config struct
1783 * @driver_dump: driver dump struct
1788 static void ipr_dump_ioa_type_data(struct ipr_ioa_cfg *ioa_cfg,
1789 struct ipr_driver_dump *driver_dump)
1791 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
1793 ipr_init_dump_entry_hdr(&driver_dump->ioa_type_entry.hdr);
1794 driver_dump->ioa_type_entry.hdr.len =
1795 sizeof(struct ipr_dump_ioa_type_entry) -
1796 sizeof(struct ipr_dump_entry_header);
1797 driver_dump->ioa_type_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
1798 driver_dump->ioa_type_entry.hdr.id = IPR_DUMP_DRIVER_TYPE_ID;
1799 driver_dump->ioa_type_entry.type = ioa_cfg->type;
1800 driver_dump->ioa_type_entry.fw_version = (ucode_vpd->major_release << 24) |
1801 (ucode_vpd->card_type << 16) | (ucode_vpd->minor_release[0] << 8) |
1802 ucode_vpd->minor_release[1];
1803 driver_dump->hdr.num_entries++;
1807 * ipr_dump_version_data - Fill in the driver version in the dump.
1808 * @ioa_cfg: ioa config struct
1809 * @driver_dump: driver dump struct
1814 static void ipr_dump_version_data(struct ipr_ioa_cfg *ioa_cfg,
1815 struct ipr_driver_dump *driver_dump)
1817 ipr_init_dump_entry_hdr(&driver_dump->version_entry.hdr);
1818 driver_dump->version_entry.hdr.len =
1819 sizeof(struct ipr_dump_version_entry) -
1820 sizeof(struct ipr_dump_entry_header);
1821 driver_dump->version_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
1822 driver_dump->version_entry.hdr.id = IPR_DUMP_DRIVER_VERSION_ID;
1823 strcpy(driver_dump->version_entry.version, IPR_DRIVER_VERSION);
1824 driver_dump->hdr.num_entries++;
1828 * ipr_dump_trace_data - Fill in the IOA trace in the dump.
1829 * @ioa_cfg: ioa config struct
1830 * @driver_dump: driver dump struct
1835 static void ipr_dump_trace_data(struct ipr_ioa_cfg *ioa_cfg,
1836 struct ipr_driver_dump *driver_dump)
1838 ipr_init_dump_entry_hdr(&driver_dump->trace_entry.hdr);
1839 driver_dump->trace_entry.hdr.len =
1840 sizeof(struct ipr_dump_trace_entry) -
1841 sizeof(struct ipr_dump_entry_header);
1842 driver_dump->trace_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
1843 driver_dump->trace_entry.hdr.id = IPR_DUMP_TRACE_ID;
1844 memcpy(driver_dump->trace_entry.trace, ioa_cfg->trace, IPR_TRACE_SIZE);
1845 driver_dump->hdr.num_entries++;
1849 * ipr_dump_location_data - Fill in the IOA location in the dump.
1850 * @ioa_cfg: ioa config struct
1851 * @driver_dump: driver dump struct
1856 static void ipr_dump_location_data(struct ipr_ioa_cfg *ioa_cfg,
1857 struct ipr_driver_dump *driver_dump)
1859 ipr_init_dump_entry_hdr(&driver_dump->location_entry.hdr);
1860 driver_dump->location_entry.hdr.len =
1861 sizeof(struct ipr_dump_location_entry) -
1862 sizeof(struct ipr_dump_entry_header);
1863 driver_dump->location_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
1864 driver_dump->location_entry.hdr.id = IPR_DUMP_LOCATION_ID;
1865 strcpy(driver_dump->location_entry.location, ioa_cfg->pdev->dev.bus_id);
1866 driver_dump->hdr.num_entries++;
1870 * ipr_get_ioa_dump - Perform a dump of the driver and adapter.
1871 * @ioa_cfg: ioa config struct
1872 * @dump: dump struct
1877 static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
1879 unsigned long start_addr, sdt_word;
1880 unsigned long lock_flags = 0;
1881 struct ipr_driver_dump *driver_dump = &dump->driver_dump;
1882 struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
1883 u32 num_entries, start_off, end_off;
1884 u32 bytes_to_copy, bytes_copied, rc;
1885 struct ipr_sdt *sdt;
1890 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1892 if (ioa_cfg->sdt_state != GET_DUMP) {
1893 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1897 start_addr = readl(ioa_cfg->ioa_mailbox);
1899 if (!ipr_sdt_is_fmt2(start_addr)) {
1900 dev_err(&ioa_cfg->pdev->dev,
1901 "Invalid dump table format: %lx\n", start_addr);
1902 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1906 dev_err(&ioa_cfg->pdev->dev, "Dump of IOA initiated\n");
1908 driver_dump->hdr.eye_catcher = IPR_DUMP_EYE_CATCHER;
1910 /* Initialize the overall dump header */
1911 driver_dump->hdr.len = sizeof(struct ipr_driver_dump);
1912 driver_dump->hdr.num_entries = 1;
1913 driver_dump->hdr.first_entry_offset = sizeof(struct ipr_dump_header);
1914 driver_dump->hdr.status = IPR_DUMP_STATUS_SUCCESS;
1915 driver_dump->hdr.os = IPR_DUMP_OS_LINUX;
1916 driver_dump->hdr.driver_name = IPR_DUMP_DRIVER_NAME;
1918 ipr_dump_version_data(ioa_cfg, driver_dump);
1919 ipr_dump_location_data(ioa_cfg, driver_dump);
1920 ipr_dump_ioa_type_data(ioa_cfg, driver_dump);
1921 ipr_dump_trace_data(ioa_cfg, driver_dump);
1923 /* Update dump_header */
1924 driver_dump->hdr.len += sizeof(struct ipr_dump_entry_header);
1926 /* IOA Dump entry */
1927 ipr_init_dump_entry_hdr(&ioa_dump->hdr);
1928 ioa_dump->format = IPR_SDT_FMT2;
1929 ioa_dump->hdr.len = 0;
1930 ioa_dump->hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
1931 ioa_dump->hdr.id = IPR_DUMP_IOA_DUMP_ID;
1933 /* First entries in sdt are actually a list of dump addresses and
1934 lengths to gather the real dump data. sdt represents the pointer
1935 to the ioa generated dump table. Dump data will be extracted based
1936 on entries in this table */
1937 sdt = &ioa_dump->sdt;
1939 rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
1940 sizeof(struct ipr_sdt) / sizeof(__be32));
1942 /* Smart Dump table is ready to use and the first entry is valid */
1943 if (rc || (be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE)) {
1944 dev_err(&ioa_cfg->pdev->dev,
1945 "Dump of IOA failed. Dump table not valid: %d, %X.\n",
1946 rc, be32_to_cpu(sdt->hdr.state));
1947 driver_dump->hdr.status = IPR_DUMP_STATUS_FAILED;
1948 ioa_cfg->sdt_state = DUMP_OBTAINED;
1949 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1953 num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
1955 if (num_entries > IPR_NUM_SDT_ENTRIES)
1956 num_entries = IPR_NUM_SDT_ENTRIES;
1958 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1960 for (i = 0; i < num_entries; i++) {
1961 if (ioa_dump->hdr.len > IPR_MAX_IOA_DUMP_SIZE) {
1962 driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
1966 if (sdt->entry[i].flags & IPR_SDT_VALID_ENTRY) {
1967 sdt_word = be32_to_cpu(sdt->entry[i].bar_str_offset);
1968 start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
1969 end_off = be32_to_cpu(sdt->entry[i].end_offset);
1971 if (ipr_sdt_is_fmt2(sdt_word) && sdt_word) {
1972 bytes_to_copy = end_off - start_off;
1973 if (bytes_to_copy > IPR_MAX_IOA_DUMP_SIZE) {
1974 sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
1978 /* Copy data from adapter to driver buffers */
1979 bytes_copied = ipr_sdt_copy(ioa_cfg, sdt_word,
1982 ioa_dump->hdr.len += bytes_copied;
1984 if (bytes_copied != bytes_to_copy) {
1985 driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
1992 dev_err(&ioa_cfg->pdev->dev, "Dump of IOA completed.\n");
1994 /* Update dump_header */
1995 driver_dump->hdr.len += ioa_dump->hdr.len;
1997 ioa_cfg->sdt_state = DUMP_OBTAINED;
2002 #define ipr_get_ioa_dump(ioa_cfg, dump) do { } while(0)
2006 * ipr_release_dump - Free adapter dump memory
2007 * @kref: kref struct
2012 static void ipr_release_dump(struct kref *kref)
2014 struct ipr_dump *dump = container_of(kref,struct ipr_dump,kref);
2015 struct ipr_ioa_cfg *ioa_cfg = dump->ioa_cfg;
2016 unsigned long lock_flags = 0;
2020 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2021 ioa_cfg->dump = NULL;
2022 ioa_cfg->sdt_state = INACTIVE;
2023 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2025 for (i = 0; i < dump->ioa_dump.next_page_index; i++)
2026 free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
2033 * ipr_worker_thread - Worker thread
2034 * @data: ioa config struct
2036 * Called at task level from a work thread. This function takes care
2037 * of adding and removing device from the mid-layer as configuration
2038 * changes are detected by the adapter.
2043 static void ipr_worker_thread(void *data)
2045 unsigned long lock_flags;
2046 struct ipr_resource_entry *res;
2047 struct scsi_device *sdev;
2048 struct ipr_dump *dump;
2049 struct ipr_ioa_cfg *ioa_cfg = data;
2050 u8 bus, target, lun;
2054 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2056 if (ioa_cfg->sdt_state == GET_DUMP) {
2057 dump = ioa_cfg->dump;
2059 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2062 kref_get(&dump->kref);
2063 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2064 ipr_get_ioa_dump(ioa_cfg, dump);
2065 kref_put(&dump->kref, ipr_release_dump);
2067 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2068 if (ioa_cfg->sdt_state == DUMP_OBTAINED)
2069 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2070 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2077 if (!ioa_cfg->allow_cmds || !ioa_cfg->allow_ml_add_del) {
2078 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2082 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
2083 if (res->del_from_ml && res->sdev) {
2086 if (!scsi_device_get(sdev)) {
2087 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
2088 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2089 scsi_remove_device(sdev);
2090 scsi_device_put(sdev);
2091 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2098 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
2099 if (res->add_to_ml) {
2100 bus = res->cfgte.res_addr.bus;
2101 target = res->cfgte.res_addr.target;
2102 lun = res->cfgte.res_addr.lun;
2104 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2105 scsi_add_device(ioa_cfg->host, bus, target, lun);
2106 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2111 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2112 kobject_uevent(&ioa_cfg->host->shost_classdev.kobj, KOBJ_CHANGE);
2116 #ifdef CONFIG_SCSI_IPR_TRACE
2118 * ipr_read_trace - Dump the adapter trace
2119 * @kobj: kobject struct
2122 * @count: buffer size
2125 * number of bytes printed to buffer
2127 static ssize_t ipr_read_trace(struct kobject *kobj, char *buf,
2128 loff_t off, size_t count)
2130 struct class_device *cdev = container_of(kobj,struct class_device,kobj);
2131 struct Scsi_Host *shost = class_to_shost(cdev);
2132 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2133 unsigned long lock_flags = 0;
2134 int size = IPR_TRACE_SIZE;
2135 char *src = (char *)ioa_cfg->trace;
2139 if (off + count > size) {
2144 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2145 memcpy(buf, &src[off], count);
2146 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2150 static struct bin_attribute ipr_trace_attr = {
2156 .read = ipr_read_trace,
2160 static const struct {
2161 enum ipr_cache_state state;
2163 } cache_state [] = {
2164 { CACHE_NONE, "none" },
2165 { CACHE_DISABLED, "disabled" },
2166 { CACHE_ENABLED, "enabled" }
2170 * ipr_show_write_caching - Show the write caching attribute
2171 * @class_dev: class device struct
2175 * number of bytes printed to buffer
2177 static ssize_t ipr_show_write_caching(struct class_device *class_dev, char *buf)
2179 struct Scsi_Host *shost = class_to_shost(class_dev);
2180 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2181 unsigned long lock_flags = 0;
2184 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2185 for (i = 0; i < ARRAY_SIZE(cache_state); i++) {
2186 if (cache_state[i].state == ioa_cfg->cache_state) {
2187 len = snprintf(buf, PAGE_SIZE, "%s\n", cache_state[i].name);
2191 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2197 * ipr_store_write_caching - Enable/disable adapter write cache
2198 * @class_dev: class_device struct
2200 * @count: buffer size
2202 * This function will enable/disable adapter write cache.
2205 * count on success / other on failure
2207 static ssize_t ipr_store_write_caching(struct class_device *class_dev,
2208 const char *buf, size_t count)
2210 struct Scsi_Host *shost = class_to_shost(class_dev);
2211 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2212 unsigned long lock_flags = 0;
2213 enum ipr_cache_state new_state = CACHE_INVALID;
2216 if (!capable(CAP_SYS_ADMIN))
2218 if (ioa_cfg->cache_state == CACHE_NONE)
2221 for (i = 0; i < ARRAY_SIZE(cache_state); i++) {
2222 if (!strncmp(cache_state[i].name, buf, strlen(cache_state[i].name))) {
2223 new_state = cache_state[i].state;
2228 if (new_state != CACHE_DISABLED && new_state != CACHE_ENABLED)
2231 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2232 if (ioa_cfg->cache_state == new_state) {
2233 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2237 ioa_cfg->cache_state = new_state;
2238 dev_info(&ioa_cfg->pdev->dev, "%s adapter write cache.\n",
2239 new_state == CACHE_ENABLED ? "Enabling" : "Disabling");
2240 if (!ioa_cfg->in_reset_reload)
2241 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
2242 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2243 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2248 static struct class_device_attribute ipr_ioa_cache_attr = {
2250 .name = "write_cache",
2251 .mode = S_IRUGO | S_IWUSR,
2253 .show = ipr_show_write_caching,
2254 .store = ipr_store_write_caching
2258 * ipr_show_fw_version - Show the firmware version
2259 * @class_dev: class device struct
2263 * number of bytes printed to buffer
2265 static ssize_t ipr_show_fw_version(struct class_device *class_dev, char *buf)
2267 struct Scsi_Host *shost = class_to_shost(class_dev);
2268 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2269 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
2270 unsigned long lock_flags = 0;
2273 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2274 len = snprintf(buf, PAGE_SIZE, "%02X%02X%02X%02X\n",
2275 ucode_vpd->major_release, ucode_vpd->card_type,
2276 ucode_vpd->minor_release[0],
2277 ucode_vpd->minor_release[1]);
2278 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2282 static struct class_device_attribute ipr_fw_version_attr = {
2284 .name = "fw_version",
2287 .show = ipr_show_fw_version,
2291 * ipr_show_log_level - Show the adapter's error logging level
2292 * @class_dev: class device struct
2296 * number of bytes printed to buffer
2298 static ssize_t ipr_show_log_level(struct class_device *class_dev, char *buf)
2300 struct Scsi_Host *shost = class_to_shost(class_dev);
2301 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2302 unsigned long lock_flags = 0;
2305 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2306 len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->log_level);
2307 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2312 * ipr_store_log_level - Change the adapter's error logging level
2313 * @class_dev: class device struct
2317 * number of bytes printed to buffer
2319 static ssize_t ipr_store_log_level(struct class_device *class_dev,
2320 const char *buf, size_t count)
2322 struct Scsi_Host *shost = class_to_shost(class_dev);
2323 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2324 unsigned long lock_flags = 0;
2326 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2327 ioa_cfg->log_level = simple_strtoul(buf, NULL, 10);
2328 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2332 static struct class_device_attribute ipr_log_level_attr = {
2334 .name = "log_level",
2335 .mode = S_IRUGO | S_IWUSR,
2337 .show = ipr_show_log_level,
2338 .store = ipr_store_log_level
2342 * ipr_store_diagnostics - IOA Diagnostics interface
2343 * @class_dev: class_device struct
2345 * @count: buffer size
2347 * This function will reset the adapter and wait a reasonable
2348 * amount of time for any errors that the adapter might log.
2351 * count on success / other on failure
2353 static ssize_t ipr_store_diagnostics(struct class_device *class_dev,
2354 const char *buf, size_t count)
2356 struct Scsi_Host *shost = class_to_shost(class_dev);
2357 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2358 unsigned long lock_flags = 0;
2361 if (!capable(CAP_SYS_ADMIN))
2364 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2365 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2366 ioa_cfg->errors_logged = 0;
2367 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
2369 if (ioa_cfg->in_reset_reload) {
2370 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2371 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2373 /* Wait for a second for any errors to be logged */
2376 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2380 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2381 if (ioa_cfg->in_reset_reload || ioa_cfg->errors_logged)
2383 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2388 static struct class_device_attribute ipr_diagnostics_attr = {
2390 .name = "run_diagnostics",
2393 .store = ipr_store_diagnostics
2397 * ipr_show_adapter_state - Show the adapter's state
2398 * @class_dev: class device struct
2402 * number of bytes printed to buffer
2404 static ssize_t ipr_show_adapter_state(struct class_device *class_dev, char *buf)
2406 struct Scsi_Host *shost = class_to_shost(class_dev);
2407 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2408 unsigned long lock_flags = 0;
2411 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2412 if (ioa_cfg->ioa_is_dead)
2413 len = snprintf(buf, PAGE_SIZE, "offline\n");
2415 len = snprintf(buf, PAGE_SIZE, "online\n");
2416 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2421 * ipr_store_adapter_state - Change adapter state
2422 * @class_dev: class_device struct
2424 * @count: buffer size
2426 * This function will change the adapter's state.
2429 * count on success / other on failure
2431 static ssize_t ipr_store_adapter_state(struct class_device *class_dev,
2432 const char *buf, size_t count)
2434 struct Scsi_Host *shost = class_to_shost(class_dev);
2435 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2436 unsigned long lock_flags;
2439 if (!capable(CAP_SYS_ADMIN))
2442 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2443 if (ioa_cfg->ioa_is_dead && !strncmp(buf, "online", 6)) {
2444 ioa_cfg->ioa_is_dead = 0;
2445 ioa_cfg->reset_retries = 0;
2446 ioa_cfg->in_ioa_bringdown = 0;
2447 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2449 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2450 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2455 static struct class_device_attribute ipr_ioa_state_attr = {
2458 .mode = S_IRUGO | S_IWUSR,
2460 .show = ipr_show_adapter_state,
2461 .store = ipr_store_adapter_state
2465 * ipr_store_reset_adapter - Reset the adapter
2466 * @class_dev: class_device struct
2468 * @count: buffer size
2470 * This function will reset the adapter.
2473 * count on success / other on failure
2475 static ssize_t ipr_store_reset_adapter(struct class_device *class_dev,
2476 const char *buf, size_t count)
2478 struct Scsi_Host *shost = class_to_shost(class_dev);
2479 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2480 unsigned long lock_flags;
2483 if (!capable(CAP_SYS_ADMIN))
2486 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2487 if (!ioa_cfg->in_reset_reload)
2488 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
2489 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2490 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2495 static struct class_device_attribute ipr_ioa_reset_attr = {
2497 .name = "reset_host",
2500 .store = ipr_store_reset_adapter
2504 * ipr_alloc_ucode_buffer - Allocates a microcode download buffer
2505 * @buf_len: buffer length
2507 * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
2508 * list to use for microcode download
2511 * pointer to sglist / NULL on failure
2513 static struct ipr_sglist *ipr_alloc_ucode_buffer(int buf_len)
2515 int sg_size, order, bsize_elem, num_elem, i, j;
2516 struct ipr_sglist *sglist;
2517 struct scatterlist *scatterlist;
2520 /* Get the minimum size per scatter/gather element */
2521 sg_size = buf_len / (IPR_MAX_SGLIST - 1);
2523 /* Get the actual size per element */
2524 order = get_order(sg_size);
2526 /* Determine the actual number of bytes per element */
2527 bsize_elem = PAGE_SIZE * (1 << order);
2529 /* Determine the actual number of sg entries needed */
2530 if (buf_len % bsize_elem)
2531 num_elem = (buf_len / bsize_elem) + 1;
2533 num_elem = buf_len / bsize_elem;
2535 /* Allocate a scatter/gather list for the DMA */
2536 sglist = kzalloc(sizeof(struct ipr_sglist) +
2537 (sizeof(struct scatterlist) * (num_elem - 1)),
2540 if (sglist == NULL) {
2545 scatterlist = sglist->scatterlist;
2547 sglist->order = order;
2548 sglist->num_sg = num_elem;
2550 /* Allocate a bunch of sg elements */
2551 for (i = 0; i < num_elem; i++) {
2552 page = alloc_pages(GFP_KERNEL, order);
2556 /* Free up what we already allocated */
2557 for (j = i - 1; j >= 0; j--)
2558 __free_pages(scatterlist[j].page, order);
2563 scatterlist[i].page = page;
2570 * ipr_free_ucode_buffer - Frees a microcode download buffer
2571 * @p_dnld: scatter/gather list pointer
2573 * Free a DMA'able ucode download buffer previously allocated with
2574 * ipr_alloc_ucode_buffer
2579 static void ipr_free_ucode_buffer(struct ipr_sglist *sglist)
2583 for (i = 0; i < sglist->num_sg; i++)
2584 __free_pages(sglist->scatterlist[i].page, sglist->order);
2590 * ipr_copy_ucode_buffer - Copy user buffer to kernel buffer
2591 * @sglist: scatter/gather list pointer
2592 * @buffer: buffer pointer
2593 * @len: buffer length
2595 * Copy a microcode image from a user buffer into a buffer allocated by
2596 * ipr_alloc_ucode_buffer
2599 * 0 on success / other on failure
2601 static int ipr_copy_ucode_buffer(struct ipr_sglist *sglist,
2602 u8 *buffer, u32 len)
2604 int bsize_elem, i, result = 0;
2605 struct scatterlist *scatterlist;
2608 /* Determine the actual number of bytes per element */
2609 bsize_elem = PAGE_SIZE * (1 << sglist->order);
2611 scatterlist = sglist->scatterlist;
2613 for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) {
2614 kaddr = kmap(scatterlist[i].page);
2615 memcpy(kaddr, buffer, bsize_elem);
2616 kunmap(scatterlist[i].page);
2618 scatterlist[i].length = bsize_elem;
2626 if (len % bsize_elem) {
2627 kaddr = kmap(scatterlist[i].page);
2628 memcpy(kaddr, buffer, len % bsize_elem);
2629 kunmap(scatterlist[i].page);
2631 scatterlist[i].length = len % bsize_elem;
2634 sglist->buffer_len = len;
2639 * ipr_build_ucode_ioadl - Build a microcode download IOADL
2640 * @ipr_cmd: ipr command struct
2641 * @sglist: scatter/gather list
2643 * Builds a microcode download IOA data list (IOADL).
2646 static void ipr_build_ucode_ioadl(struct ipr_cmnd *ipr_cmd,
2647 struct ipr_sglist *sglist)
2649 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
2650 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
2651 struct scatterlist *scatterlist = sglist->scatterlist;
2654 ipr_cmd->dma_use_sg = sglist->num_dma_sg;
2655 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
2656 ioarcb->write_data_transfer_length = cpu_to_be32(sglist->buffer_len);
2657 ioarcb->write_ioadl_len =
2658 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
2660 for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
2661 ioadl[i].flags_and_data_len =
2662 cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(&scatterlist[i]));
2664 cpu_to_be32(sg_dma_address(&scatterlist[i]));
2667 ioadl[i-1].flags_and_data_len |=
2668 cpu_to_be32(IPR_IOADL_FLAGS_LAST);
2672 * ipr_update_ioa_ucode - Update IOA's microcode
2673 * @ioa_cfg: ioa config struct
2674 * @sglist: scatter/gather list
2676 * Initiate an adapter reset to update the IOA's microcode
2679 * 0 on success / -EIO on failure
2681 static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
2682 struct ipr_sglist *sglist)
2684 unsigned long lock_flags;
2686 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2688 if (ioa_cfg->ucode_sglist) {
2689 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2690 dev_err(&ioa_cfg->pdev->dev,
2691 "Microcode download already in progress\n");
2695 sglist->num_dma_sg = pci_map_sg(ioa_cfg->pdev, sglist->scatterlist,
2696 sglist->num_sg, DMA_TO_DEVICE);
2698 if (!sglist->num_dma_sg) {
2699 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2700 dev_err(&ioa_cfg->pdev->dev,
2701 "Failed to map microcode download buffer!\n");
2705 ioa_cfg->ucode_sglist = sglist;
2706 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
2707 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2708 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2710 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2711 ioa_cfg->ucode_sglist = NULL;
2712 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2717 * ipr_store_update_fw - Update the firmware on the adapter
2718 * @class_dev: class_device struct
2720 * @count: buffer size
2722 * This function will update the firmware on the adapter.
2725 * count on success / other on failure
2727 static ssize_t ipr_store_update_fw(struct class_device *class_dev,
2728 const char *buf, size_t count)
2730 struct Scsi_Host *shost = class_to_shost(class_dev);
2731 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2732 struct ipr_ucode_image_header *image_hdr;
2733 const struct firmware *fw_entry;
2734 struct ipr_sglist *sglist;
2737 int len, result, dnld_size;
2739 if (!capable(CAP_SYS_ADMIN))
2742 len = snprintf(fname, 99, "%s", buf);
2743 fname[len-1] = '\0';
2745 if(request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
2746 dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
2750 image_hdr = (struct ipr_ucode_image_header *)fw_entry->data;
2752 if (be32_to_cpu(image_hdr->header_length) > fw_entry->size ||
2753 (ioa_cfg->vpd_cbs->page3_data.card_type &&
2754 ioa_cfg->vpd_cbs->page3_data.card_type != image_hdr->card_type)) {
2755 dev_err(&ioa_cfg->pdev->dev, "Invalid microcode buffer\n");
2756 release_firmware(fw_entry);
2760 src = (u8 *)image_hdr + be32_to_cpu(image_hdr->header_length);
2761 dnld_size = fw_entry->size - be32_to_cpu(image_hdr->header_length);
2762 sglist = ipr_alloc_ucode_buffer(dnld_size);
2765 dev_err(&ioa_cfg->pdev->dev, "Microcode buffer allocation failed\n");
2766 release_firmware(fw_entry);
2770 result = ipr_copy_ucode_buffer(sglist, src, dnld_size);
2773 dev_err(&ioa_cfg->pdev->dev,
2774 "Microcode buffer copy to DMA buffer failed\n");
2778 result = ipr_update_ioa_ucode(ioa_cfg, sglist);
2783 ipr_free_ucode_buffer(sglist);
2784 release_firmware(fw_entry);
2788 static struct class_device_attribute ipr_update_fw_attr = {
2790 .name = "update_fw",
2793 .store = ipr_store_update_fw
2796 static struct class_device_attribute *ipr_ioa_attrs[] = {
2797 &ipr_fw_version_attr,
2798 &ipr_log_level_attr,
2799 &ipr_diagnostics_attr,
2800 &ipr_ioa_state_attr,
2801 &ipr_ioa_reset_attr,
2802 &ipr_update_fw_attr,
2803 &ipr_ioa_cache_attr,
2807 #ifdef CONFIG_SCSI_IPR_DUMP
2809 * ipr_read_dump - Dump the adapter
2810 * @kobj: kobject struct
2813 * @count: buffer size
2816 * number of bytes printed to buffer
2818 static ssize_t ipr_read_dump(struct kobject *kobj, char *buf,
2819 loff_t off, size_t count)
2821 struct class_device *cdev = container_of(kobj,struct class_device,kobj);
2822 struct Scsi_Host *shost = class_to_shost(cdev);
2823 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2824 struct ipr_dump *dump;
2825 unsigned long lock_flags = 0;
2830 if (!capable(CAP_SYS_ADMIN))
2833 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2834 dump = ioa_cfg->dump;
2836 if (ioa_cfg->sdt_state != DUMP_OBTAINED || !dump) {
2837 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2840 kref_get(&dump->kref);
2841 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2843 if (off > dump->driver_dump.hdr.len) {
2844 kref_put(&dump->kref, ipr_release_dump);
2848 if (off + count > dump->driver_dump.hdr.len) {
2849 count = dump->driver_dump.hdr.len - off;
2853 if (count && off < sizeof(dump->driver_dump)) {
2854 if (off + count > sizeof(dump->driver_dump))
2855 len = sizeof(dump->driver_dump) - off;
2858 src = (u8 *)&dump->driver_dump + off;
2859 memcpy(buf, src, len);
2865 off -= sizeof(dump->driver_dump);
2867 if (count && off < offsetof(struct ipr_ioa_dump, ioa_data)) {
2868 if (off + count > offsetof(struct ipr_ioa_dump, ioa_data))
2869 len = offsetof(struct ipr_ioa_dump, ioa_data) - off;
2872 src = (u8 *)&dump->ioa_dump + off;
2873 memcpy(buf, src, len);
2879 off -= offsetof(struct ipr_ioa_dump, ioa_data);
2882 if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
2883 len = PAGE_ALIGN(off) - off;
2886 src = (u8 *)dump->ioa_dump.ioa_data[(off & PAGE_MASK) >> PAGE_SHIFT];
2887 src += off & ~PAGE_MASK;
2888 memcpy(buf, src, len);
2894 kref_put(&dump->kref, ipr_release_dump);
2899 * ipr_alloc_dump - Prepare for adapter dump
2900 * @ioa_cfg: ioa config struct
2903 * 0 on success / other on failure
2905 static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
2907 struct ipr_dump *dump;
2908 unsigned long lock_flags = 0;
2911 dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL);
2914 ipr_err("Dump memory allocation failed\n");
2918 kref_init(&dump->kref);
2919 dump->ioa_cfg = ioa_cfg;
2921 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2923 if (INACTIVE != ioa_cfg->sdt_state) {
2924 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2929 ioa_cfg->dump = dump;
2930 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
2931 if (ioa_cfg->ioa_is_dead && !ioa_cfg->dump_taken) {
2932 ioa_cfg->dump_taken = 1;
2933 schedule_work(&ioa_cfg->work_q);
2935 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2942 * ipr_free_dump - Free adapter dump memory
2943 * @ioa_cfg: ioa config struct
2946 * 0 on success / other on failure
2948 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
2950 struct ipr_dump *dump;
2951 unsigned long lock_flags = 0;
2955 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2956 dump = ioa_cfg->dump;
2958 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2962 ioa_cfg->dump = NULL;
2963 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2965 kref_put(&dump->kref, ipr_release_dump);
2972 * ipr_write_dump - Setup dump state of adapter
2973 * @kobj: kobject struct
2976 * @count: buffer size
2979 * number of bytes printed to buffer
2981 static ssize_t ipr_write_dump(struct kobject *kobj, char *buf,
2982 loff_t off, size_t count)
2984 struct class_device *cdev = container_of(kobj,struct class_device,kobj);
2985 struct Scsi_Host *shost = class_to_shost(cdev);
2986 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2989 if (!capable(CAP_SYS_ADMIN))
2993 rc = ipr_alloc_dump(ioa_cfg);
2994 else if (buf[0] == '0')
2995 rc = ipr_free_dump(ioa_cfg);
3005 static struct bin_attribute ipr_dump_attr = {
3008 .mode = S_IRUSR | S_IWUSR,
3011 .read = ipr_read_dump,
3012 .write = ipr_write_dump
3015 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
3019 * ipr_change_queue_depth - Change the device's queue depth
3020 * @sdev: scsi device struct
3021 * @qdepth: depth to set
3026 static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth)
3028 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
3029 return sdev->queue_depth;
3033 * ipr_change_queue_type - Change the device's queue type
3034 * @dsev: scsi device struct
3035 * @tag_type: type of tags to use
3038 * actual queue type set
3040 static int ipr_change_queue_type(struct scsi_device *sdev, int tag_type)
3042 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
3043 struct ipr_resource_entry *res;
3044 unsigned long lock_flags = 0;
3046 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3047 res = (struct ipr_resource_entry *)sdev->hostdata;
3050 if (ipr_is_gscsi(res) && sdev->tagged_supported) {
3052 * We don't bother quiescing the device here since the
3053 * adapter firmware does it for us.
3055 scsi_set_tag_type(sdev, tag_type);
3058 scsi_activate_tcq(sdev, sdev->queue_depth);
3060 scsi_deactivate_tcq(sdev, sdev->queue_depth);
3066 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3071 * ipr_show_adapter_handle - Show the adapter's resource handle for this device
3072 * @dev: device struct
3076 * number of bytes printed to buffer
3078 static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribute *attr, char *buf)
3080 struct scsi_device *sdev = to_scsi_device(dev);
3081 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
3082 struct ipr_resource_entry *res;
3083 unsigned long lock_flags = 0;
3084 ssize_t len = -ENXIO;
3086 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3087 res = (struct ipr_resource_entry *)sdev->hostdata;
3089 len = snprintf(buf, PAGE_SIZE, "%08X\n", res->cfgte.res_handle);
3090 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3094 static struct device_attribute ipr_adapter_handle_attr = {
3096 .name = "adapter_handle",
3099 .show = ipr_show_adapter_handle
3102 static struct device_attribute *ipr_dev_attrs[] = {
3103 &ipr_adapter_handle_attr,
3108 * ipr_biosparam - Return the HSC mapping
3109 * @sdev: scsi device struct
3110 * @block_device: block device pointer
3111 * @capacity: capacity of the device
3112 * @parm: Array containing returned HSC values.
3114 * This function generates the HSC parms that fdisk uses.
3115 * We want to make sure we return something that places partitions
3116 * on 4k boundaries for best performance with the IOA.
3121 static int ipr_biosparam(struct scsi_device *sdev,
3122 struct block_device *block_device,
3123 sector_t capacity, int *parm)
3131 cylinders = capacity;
3132 sector_div(cylinders, (128 * 32));
3137 parm[2] = cylinders;
3143 * ipr_slave_destroy - Unconfigure a SCSI device
3144 * @sdev: scsi device struct
3149 static void ipr_slave_destroy(struct scsi_device *sdev)
3151 struct ipr_resource_entry *res;
3152 struct ipr_ioa_cfg *ioa_cfg;
3153 unsigned long lock_flags = 0;
3155 ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
3157 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3158 res = (struct ipr_resource_entry *) sdev->hostdata;
3160 sdev->hostdata = NULL;
3163 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3167 * ipr_slave_configure - Configure a SCSI device
3168 * @sdev: scsi device struct
3170 * This function configures the specified scsi device.
3175 static int ipr_slave_configure(struct scsi_device *sdev)
3177 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
3178 struct ipr_resource_entry *res;
3179 unsigned long lock_flags = 0;
3181 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3182 res = sdev->hostdata;
3184 if (ipr_is_af_dasd_device(res))
3185 sdev->type = TYPE_RAID;
3186 if (ipr_is_af_dasd_device(res) || ipr_is_ioa_resource(res)) {
3187 sdev->scsi_level = 4;
3188 sdev->no_uld_attach = 1;
3190 if (ipr_is_vset_device(res)) {
3191 sdev->timeout = IPR_VSET_RW_TIMEOUT;
3192 blk_queue_max_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
3194 if (ipr_is_vset_device(res) || ipr_is_scsi_disk(res))
3195 sdev->allow_restart = 1;
3196 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
3198 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3203 * ipr_slave_alloc - Prepare for commands to a device.
3204 * @sdev: scsi device struct
3206 * This function saves a pointer to the resource entry
3207 * in the scsi device struct if the device exists. We
3208 * can then use this pointer in ipr_queuecommand when
3209 * handling new commands.
3212 * 0 on success / -ENXIO if device does not exist
3214 static int ipr_slave_alloc(struct scsi_device *sdev)
3216 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
3217 struct ipr_resource_entry *res;
3218 unsigned long lock_flags;
3221 sdev->hostdata = NULL;
3223 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3225 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3226 if ((res->cfgte.res_addr.bus == sdev->channel) &&
3227 (res->cfgte.res_addr.target == sdev->id) &&
3228 (res->cfgte.res_addr.lun == sdev->lun)) {
3232 sdev->hostdata = res;
3233 if (!ipr_is_naca_model(res))
3234 res->needs_sync_complete = 1;
3240 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3246 * ipr_eh_host_reset - Reset the host adapter
3247 * @scsi_cmd: scsi command struct
3252 static int __ipr_eh_host_reset(struct scsi_cmnd * scsi_cmd)
3254 struct ipr_ioa_cfg *ioa_cfg;
3258 ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
3260 dev_err(&ioa_cfg->pdev->dev,
3261 "Adapter being reset as a result of error recovery.\n");
3263 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
3264 ioa_cfg->sdt_state = GET_DUMP;
3266 rc = ipr_reset_reload(ioa_cfg, IPR_SHUTDOWN_ABBREV);
3272 static int ipr_eh_host_reset(struct scsi_cmnd * cmd)
3276 spin_lock_irq(cmd->device->host->host_lock);
3277 rc = __ipr_eh_host_reset(cmd);
3278 spin_unlock_irq(cmd->device->host->host_lock);
3284 * ipr_eh_dev_reset - Reset the device
3285 * @scsi_cmd: scsi command struct
3287 * This function issues a device reset to the affected device.
3288 * A LUN reset will be sent to the device first. If that does
3289 * not work, a target reset will be sent.
3294 static int __ipr_eh_dev_reset(struct scsi_cmnd * scsi_cmd)
3296 struct ipr_cmnd *ipr_cmd;
3297 struct ipr_ioa_cfg *ioa_cfg;
3298 struct ipr_resource_entry *res;
3299 struct ipr_cmd_pkt *cmd_pkt;
3303 ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
3304 res = scsi_cmd->device->hostdata;
3310 * If we are currently going through reset/reload, return failed. This will force the
3311 * mid-layer to call ipr_eh_host_reset, which will then go to sleep and wait for the
3314 if (ioa_cfg->in_reset_reload)
3316 if (ioa_cfg->ioa_is_dead)
3319 list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
3320 if (ipr_cmd->ioarcb.res_handle == res->cfgte.res_handle) {
3321 if (ipr_cmd->scsi_cmd)
3322 ipr_cmd->done = ipr_scsi_eh_done;
3326 res->resetting_device = 1;
3328 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
3330 ipr_cmd->ioarcb.res_handle = res->cfgte.res_handle;
3331 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
3332 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
3333 cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
3335 scmd_printk(KERN_ERR, scsi_cmd, "Resetting device\n");
3336 ipr_send_blocking_cmd(ipr_cmd, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
3338 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
3340 res->resetting_device = 0;
3342 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
3345 return (IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS);
3348 static int ipr_eh_dev_reset(struct scsi_cmnd * cmd)
3352 spin_lock_irq(cmd->device->host->host_lock);
3353 rc = __ipr_eh_dev_reset(cmd);
3354 spin_unlock_irq(cmd->device->host->host_lock);
3360 * ipr_bus_reset_done - Op done function for bus reset.
3361 * @ipr_cmd: ipr command struct
3363 * This function is the op done function for a bus reset
3368 static void ipr_bus_reset_done(struct ipr_cmnd *ipr_cmd)
3370 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
3371 struct ipr_resource_entry *res;
3374 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3375 if (!memcmp(&res->cfgte.res_handle, &ipr_cmd->ioarcb.res_handle,
3376 sizeof(res->cfgte.res_handle))) {
3377 scsi_report_bus_reset(ioa_cfg->host, res->cfgte.res_addr.bus);
3383 * If abort has not completed, indicate the reset has, else call the
3384 * abort's done function to wake the sleeping eh thread
3386 if (ipr_cmd->sibling->sibling)
3387 ipr_cmd->sibling->sibling = NULL;
3389 ipr_cmd->sibling->done(ipr_cmd->sibling);
3391 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
3396 * ipr_abort_timeout - An abort task has timed out
3397 * @ipr_cmd: ipr command struct
3399 * This function handles when an abort task times out. If this
3400 * happens we issue a bus reset since we have resources tied
3401 * up that must be freed before returning to the midlayer.
3406 static void ipr_abort_timeout(struct ipr_cmnd *ipr_cmd)
3408 struct ipr_cmnd *reset_cmd;
3409 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
3410 struct ipr_cmd_pkt *cmd_pkt;
3411 unsigned long lock_flags = 0;
3414 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3415 if (ipr_cmd->completion.done || ioa_cfg->in_reset_reload) {
3416 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3420 sdev_printk(KERN_ERR, ipr_cmd->u.sdev, "Abort timed out. Resetting bus.\n");
3421 reset_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
3422 ipr_cmd->sibling = reset_cmd;
3423 reset_cmd->sibling = ipr_cmd;
3424 reset_cmd->ioarcb.res_handle = ipr_cmd->ioarcb.res_handle;
3425 cmd_pkt = &reset_cmd->ioarcb.cmd_pkt;
3426 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
3427 cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
3428 cmd_pkt->cdb[2] = IPR_RESET_TYPE_SELECT | IPR_BUS_RESET;
3430 ipr_do_req(reset_cmd, ipr_bus_reset_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
3431 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3436 * ipr_cancel_op - Cancel specified op
3437 * @scsi_cmd: scsi command struct
3439 * This function cancels specified op.
3444 static int ipr_cancel_op(struct scsi_cmnd * scsi_cmd)
3446 struct ipr_cmnd *ipr_cmd;
3447 struct ipr_ioa_cfg *ioa_cfg;
3448 struct ipr_resource_entry *res;
3449 struct ipr_cmd_pkt *cmd_pkt;
3454 ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
3455 res = scsi_cmd->device->hostdata;
3457 /* If we are currently going through reset/reload, return failed.
3458 * This will force the mid-layer to call ipr_eh_host_reset,
3459 * which will then go to sleep and wait for the reset to complete
3461 if (ioa_cfg->in_reset_reload || ioa_cfg->ioa_is_dead)
3463 if (!res || (!ipr_is_gscsi(res) && !ipr_is_vset_device(res)))
3466 list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
3467 if (ipr_cmd->scsi_cmd == scsi_cmd) {
3468 ipr_cmd->done = ipr_scsi_eh_done;
3477 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
3478 ipr_cmd->ioarcb.res_handle = res->cfgte.res_handle;
3479 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
3480 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
3481 cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
3482 ipr_cmd->u.sdev = scsi_cmd->device;
3484 scmd_printk(KERN_ERR, scsi_cmd, "Aborting command: %02X\n",
3486 ipr_send_blocking_cmd(ipr_cmd, ipr_abort_timeout, IPR_CANCEL_ALL_TIMEOUT);
3487 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
3490 * If the abort task timed out and we sent a bus reset, we will get
3491 * one the following responses to the abort
3493 if (ioasc == IPR_IOASC_BUS_WAS_RESET || ioasc == IPR_IOASC_SYNC_REQUIRED) {
3498 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
3499 if (!ipr_is_naca_model(res))
3500 res->needs_sync_complete = 1;
3503 return (IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS);
3507 * ipr_eh_abort - Abort a single op
3508 * @scsi_cmd: scsi command struct
3513 static int ipr_eh_abort(struct scsi_cmnd * scsi_cmd)
3515 unsigned long flags;
3520 spin_lock_irqsave(scsi_cmd->device->host->host_lock, flags);
3521 rc = ipr_cancel_op(scsi_cmd);
3522 spin_unlock_irqrestore(scsi_cmd->device->host->host_lock, flags);
3529 * ipr_handle_other_interrupt - Handle "other" interrupts
3530 * @ioa_cfg: ioa config struct
3531 * @int_reg: interrupt register
3534 * IRQ_NONE / IRQ_HANDLED
3536 static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
3537 volatile u32 int_reg)
3539 irqreturn_t rc = IRQ_HANDLED;
3541 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
3542 /* Mask the interrupt */
3543 writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.set_interrupt_mask_reg);
3545 /* Clear the interrupt */
3546 writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.clr_interrupt_reg);
3547 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
3549 list_del(&ioa_cfg->reset_cmd->queue);
3550 del_timer(&ioa_cfg->reset_cmd->timer);
3551 ipr_reset_ioa_job(ioa_cfg->reset_cmd);
3553 if (int_reg & IPR_PCII_IOA_UNIT_CHECKED)
3554 ioa_cfg->ioa_unit_checked = 1;
3556 dev_err(&ioa_cfg->pdev->dev,
3557 "Permanent IOA failure. 0x%08X\n", int_reg);
3559 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
3560 ioa_cfg->sdt_state = GET_DUMP;
3562 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
3563 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3570 * ipr_isr - Interrupt service routine
3572 * @devp: pointer to ioa config struct
3573 * @regs: pt_regs struct
3576 * IRQ_NONE / IRQ_HANDLED
3578 static irqreturn_t ipr_isr(int irq, void *devp, struct pt_regs *regs)
3580 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
3581 unsigned long lock_flags = 0;
3582 volatile u32 int_reg, int_mask_reg;
3585 struct ipr_cmnd *ipr_cmd;
3586 irqreturn_t rc = IRQ_NONE;
3588 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3590 /* If interrupts are disabled, ignore the interrupt */
3591 if (!ioa_cfg->allow_interrupts) {
3592 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3596 int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
3597 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
3599 /* If an interrupt on the adapter did not occur, ignore it */
3600 if (unlikely((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0)) {
3601 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3608 while ((be32_to_cpu(*ioa_cfg->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
3609 ioa_cfg->toggle_bit) {
3611 cmd_index = (be32_to_cpu(*ioa_cfg->hrrq_curr) &
3612 IPR_HRRQ_REQ_RESP_HANDLE_MASK) >> IPR_HRRQ_REQ_RESP_HANDLE_SHIFT;
3614 if (unlikely(cmd_index >= IPR_NUM_CMD_BLKS)) {
3615 ioa_cfg->errors_logged++;
3616 dev_err(&ioa_cfg->pdev->dev, "Invalid response handle from IOA\n");
3618 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
3619 ioa_cfg->sdt_state = GET_DUMP;
3621 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3622 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3626 ipr_cmd = ioa_cfg->ipr_cmnd_list[cmd_index];
3628 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
3630 ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, ioasc);
3632 list_del(&ipr_cmd->queue);
3633 del_timer(&ipr_cmd->timer);
3634 ipr_cmd->done(ipr_cmd);
3638 if (ioa_cfg->hrrq_curr < ioa_cfg->hrrq_end) {
3639 ioa_cfg->hrrq_curr++;
3641 ioa_cfg->hrrq_curr = ioa_cfg->hrrq_start;
3642 ioa_cfg->toggle_bit ^= 1u;
3646 if (ipr_cmd != NULL) {
3647 /* Clear the PCI interrupt */
3648 writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg);
3649 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
3654 if (unlikely(rc == IRQ_NONE))
3655 rc = ipr_handle_other_interrupt(ioa_cfg, int_reg);
3657 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3662 * ipr_build_ioadl - Build a scatter/gather list and map the buffer
3663 * @ioa_cfg: ioa config struct
3664 * @ipr_cmd: ipr command struct
3667 * 0 on success / -1 on failure
3669 static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
3670 struct ipr_cmnd *ipr_cmd)
3673 struct scatterlist *sglist;
3675 u32 ioadl_flags = 0;
3676 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
3677 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3678 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
3680 length = scsi_cmd->request_bufflen;
3685 if (scsi_cmd->use_sg) {
3686 ipr_cmd->dma_use_sg = pci_map_sg(ioa_cfg->pdev,
3687 scsi_cmd->request_buffer,
3689 scsi_cmd->sc_data_direction);
3691 if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
3692 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
3693 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3694 ioarcb->write_data_transfer_length = cpu_to_be32(length);
3695 ioarcb->write_ioadl_len =
3696 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
3697 } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) {
3698 ioadl_flags = IPR_IOADL_FLAGS_READ;
3699 ioarcb->read_data_transfer_length = cpu_to_be32(length);
3700 ioarcb->read_ioadl_len =
3701 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
3704 sglist = scsi_cmd->request_buffer;
3706 for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
3707 ioadl[i].flags_and_data_len =
3708 cpu_to_be32(ioadl_flags | sg_dma_len(&sglist[i]));
3710 cpu_to_be32(sg_dma_address(&sglist[i]));
3713 if (likely(ipr_cmd->dma_use_sg)) {
3714 ioadl[i-1].flags_and_data_len |=
3715 cpu_to_be32(IPR_IOADL_FLAGS_LAST);
3718 dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
3720 if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
3721 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
3722 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3723 ioarcb->write_data_transfer_length = cpu_to_be32(length);
3724 ioarcb->write_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
3725 } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) {
3726 ioadl_flags = IPR_IOADL_FLAGS_READ;
3727 ioarcb->read_data_transfer_length = cpu_to_be32(length);
3728 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
3731 ipr_cmd->dma_handle = pci_map_single(ioa_cfg->pdev,
3732 scsi_cmd->request_buffer, length,
3733 scsi_cmd->sc_data_direction);
3735 if (likely(!pci_dma_mapping_error(ipr_cmd->dma_handle))) {
3736 ipr_cmd->dma_use_sg = 1;
3737 ioadl[0].flags_and_data_len =
3738 cpu_to_be32(ioadl_flags | length | IPR_IOADL_FLAGS_LAST);
3739 ioadl[0].address = cpu_to_be32(ipr_cmd->dma_handle);
3742 dev_err(&ioa_cfg->pdev->dev, "pci_map_single failed!\n");
3749 * ipr_get_task_attributes - Translate SPI Q-Tag to task attributes
3750 * @scsi_cmd: scsi command struct
3755 static u8 ipr_get_task_attributes(struct scsi_cmnd *scsi_cmd)
3758 u8 rc = IPR_FLAGS_LO_UNTAGGED_TASK;
3760 if (scsi_populate_tag_msg(scsi_cmd, tag)) {
3762 case MSG_SIMPLE_TAG:
3763 rc = IPR_FLAGS_LO_SIMPLE_TASK;
3766 rc = IPR_FLAGS_LO_HEAD_OF_Q_TASK;
3768 case MSG_ORDERED_TAG:
3769 rc = IPR_FLAGS_LO_ORDERED_TASK;
3778 * ipr_erp_done - Process completion of ERP for a device
3779 * @ipr_cmd: ipr command struct
3781 * This function copies the sense buffer into the scsi_cmd
3782 * struct and pushes the scsi_done function.
3787 static void ipr_erp_done(struct ipr_cmnd *ipr_cmd)
3789 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
3790 struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
3791 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
3792 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
3794 if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
3795 scsi_cmd->result |= (DID_ERROR << 16);
3796 scmd_printk(KERN_ERR, scsi_cmd,
3797 "Request Sense failed with IOASC: 0x%08X\n", ioasc);
3799 memcpy(scsi_cmd->sense_buffer, ipr_cmd->sense_buffer,
3800 SCSI_SENSE_BUFFERSIZE);
3804 if (!ipr_is_naca_model(res))
3805 res->needs_sync_complete = 1;
3808 ipr_unmap_sglist(ioa_cfg, ipr_cmd);
3809 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
3810 scsi_cmd->scsi_done(scsi_cmd);
3814 * ipr_reinit_ipr_cmnd_for_erp - Re-initialize a cmnd block to be used for ERP
3815 * @ipr_cmd: ipr command struct
3820 static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
3822 struct ipr_ioarcb *ioarcb;
3823 struct ipr_ioasa *ioasa;
3825 ioarcb = &ipr_cmd->ioarcb;
3826 ioasa = &ipr_cmd->ioasa;
3828 memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
3829 ioarcb->write_data_transfer_length = 0;
3830 ioarcb->read_data_transfer_length = 0;
3831 ioarcb->write_ioadl_len = 0;
3832 ioarcb->read_ioadl_len = 0;
3834 ioasa->residual_data_len = 0;
3838 * ipr_erp_request_sense - Send request sense to a device
3839 * @ipr_cmd: ipr command struct
3841 * This function sends a request sense to a device as a result
3842 * of a check condition.
3847 static void ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
3849 struct ipr_cmd_pkt *cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
3850 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
3852 if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
3853 ipr_erp_done(ipr_cmd);
3857 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
3859 cmd_pkt->request_type = IPR_RQTYPE_SCSICDB;
3860 cmd_pkt->cdb[0] = REQUEST_SENSE;
3861 cmd_pkt->cdb[4] = SCSI_SENSE_BUFFERSIZE;
3862 cmd_pkt->flags_hi |= IPR_FLAGS_HI_SYNC_OVERRIDE;
3863 cmd_pkt->flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
3864 cmd_pkt->timeout = cpu_to_be16(IPR_REQUEST_SENSE_TIMEOUT / HZ);
3866 ipr_cmd->ioadl[0].flags_and_data_len =
3867 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | SCSI_SENSE_BUFFERSIZE);
3868 ipr_cmd->ioadl[0].address =
3869 cpu_to_be32(ipr_cmd->sense_buffer_dma);
3871 ipr_cmd->ioarcb.read_ioadl_len =
3872 cpu_to_be32(sizeof(struct ipr_ioadl_desc));
3873 ipr_cmd->ioarcb.read_data_transfer_length =
3874 cpu_to_be32(SCSI_SENSE_BUFFERSIZE);
3876 ipr_do_req(ipr_cmd, ipr_erp_done, ipr_timeout,
3877 IPR_REQUEST_SENSE_TIMEOUT * 2);
3881 * ipr_erp_cancel_all - Send cancel all to a device
3882 * @ipr_cmd: ipr command struct
3884 * This function sends a cancel all to a device to clear the
3885 * queue. If we are running TCQ on the device, QERR is set to 1,
3886 * which means all outstanding ops have been dropped on the floor.
3887 * Cancel all will return them to us.
3892 static void ipr_erp_cancel_all(struct ipr_cmnd *ipr_cmd)
3894 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
3895 struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
3896 struct ipr_cmd_pkt *cmd_pkt;
3900 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
3902 if (!scsi_get_tag_type(scsi_cmd->device)) {
3903 ipr_erp_request_sense(ipr_cmd);
3907 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
3908 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
3909 cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
3911 ipr_do_req(ipr_cmd, ipr_erp_request_sense, ipr_timeout,
3912 IPR_CANCEL_ALL_TIMEOUT);
3916 * ipr_dump_ioasa - Dump contents of IOASA
3917 * @ioa_cfg: ioa config struct
3918 * @ipr_cmd: ipr command struct
3919 * @res: resource entry struct
3921 * This function is invoked by the interrupt handler when ops
3922 * fail. It will log the IOASA if appropriate. Only called
3928 static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg,
3929 struct ipr_cmnd *ipr_cmd, struct ipr_resource_entry *res)
3934 struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
3935 __be32 *ioasa_data = (__be32 *)ioasa;
3938 ioasc = be32_to_cpu(ioasa->ioasc) & IPR_IOASC_IOASC_MASK;
3943 if (ioa_cfg->log_level < IPR_DEFAULT_LOG_LEVEL)
3946 error_index = ipr_get_error(ioasc);
3948 if (ioa_cfg->log_level < IPR_MAX_LOG_LEVEL) {
3949 /* Don't log an error if the IOA already logged one */
3950 if (ioasa->ilid != 0)
3953 if (ipr_error_table[error_index].log_ioasa == 0)
3957 ipr_res_err(ioa_cfg, res, "%s\n", ipr_error_table[error_index].error);
3959 if (sizeof(struct ipr_ioasa) < be16_to_cpu(ioasa->ret_stat_len))
3960 data_len = sizeof(struct ipr_ioasa);
3962 data_len = be16_to_cpu(ioasa->ret_stat_len);
3964 ipr_err("IOASA Dump:\n");
3966 for (i = 0; i < data_len / 4; i += 4) {
3967 ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
3968 be32_to_cpu(ioasa_data[i]),
3969 be32_to_cpu(ioasa_data[i+1]),
3970 be32_to_cpu(ioasa_data[i+2]),
3971 be32_to_cpu(ioasa_data[i+3]));
3976 * ipr_gen_sense - Generate SCSI sense data from an IOASA
3978 * @sense_buf: sense data buffer
3983 static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
3986 u8 *sense_buf = ipr_cmd->scsi_cmd->sense_buffer;
3987 struct ipr_resource_entry *res = ipr_cmd->scsi_cmd->device->hostdata;
3988 struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
3989 u32 ioasc = be32_to_cpu(ioasa->ioasc);
3991 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
3993 if (ioasc >= IPR_FIRST_DRIVER_IOASC)
3996 ipr_cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
3998 if (ipr_is_vset_device(res) &&
3999 ioasc == IPR_IOASC_MED_DO_NOT_REALLOC &&
4000 ioasa->u.vset.failing_lba_hi != 0) {
4001 sense_buf[0] = 0x72;
4002 sense_buf[1] = IPR_IOASC_SENSE_KEY(ioasc);
4003 sense_buf[2] = IPR_IOASC_SENSE_CODE(ioasc);
4004 sense_buf[3] = IPR_IOASC_SENSE_QUAL(ioasc);
4008 sense_buf[9] = 0x0A;
4009 sense_buf[10] = 0x80;
4011 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_hi);
4013 sense_buf[12] = (failing_lba & 0xff000000) >> 24;
4014 sense_buf[13] = (failing_lba & 0x00ff0000) >> 16;
4015 sense_buf[14] = (failing_lba & 0x0000ff00) >> 8;
4016 sense_buf[15] = failing_lba & 0x000000ff;
4018 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
4020 sense_buf[16] = (failing_lba & 0xff000000) >> 24;
4021 sense_buf[17] = (failing_lba & 0x00ff0000) >> 16;
4022 sense_buf[18] = (failing_lba & 0x0000ff00) >> 8;
4023 sense_buf[19] = failing_lba & 0x000000ff;
4025 sense_buf[0] = 0x70;
4026 sense_buf[2] = IPR_IOASC_SENSE_KEY(ioasc);
4027 sense_buf[12] = IPR_IOASC_SENSE_CODE(ioasc);
4028 sense_buf[13] = IPR_IOASC_SENSE_QUAL(ioasc);
4030 /* Illegal request */
4031 if ((IPR_IOASC_SENSE_KEY(ioasc) == 0x05) &&
4032 (be32_to_cpu(ioasa->ioasc_specific) & IPR_FIELD_POINTER_VALID)) {
4033 sense_buf[7] = 10; /* additional length */
4035 /* IOARCB was in error */
4036 if (IPR_IOASC_SENSE_CODE(ioasc) == 0x24)
4037 sense_buf[15] = 0xC0;
4038 else /* Parameter data was invalid */
4039 sense_buf[15] = 0x80;
4042 ((IPR_FIELD_POINTER_MASK &
4043 be32_to_cpu(ioasa->ioasc_specific)) >> 8) & 0xff;
4045 (IPR_FIELD_POINTER_MASK &
4046 be32_to_cpu(ioasa->ioasc_specific)) & 0xff;
4048 if (ioasc == IPR_IOASC_MED_DO_NOT_REALLOC) {
4049 if (ipr_is_vset_device(res))
4050 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
4052 failing_lba = be32_to_cpu(ioasa->u.dasd.failing_lba);
4054 sense_buf[0] |= 0x80; /* Or in the Valid bit */
4055 sense_buf[3] = (failing_lba & 0xff000000) >> 24;
4056 sense_buf[4] = (failing_lba & 0x00ff0000) >> 16;
4057 sense_buf[5] = (failing_lba & 0x0000ff00) >> 8;
4058 sense_buf[6] = failing_lba & 0x000000ff;
4061 sense_buf[7] = 6; /* additional length */
4067 * ipr_get_autosense - Copy autosense data to sense buffer
4068 * @ipr_cmd: ipr command struct
4070 * This function copies the autosense buffer to the buffer
4071 * in the scsi_cmd, if there is autosense available.
4074 * 1 if autosense was available / 0 if not
4076 static int ipr_get_autosense(struct ipr_cmnd *ipr_cmd)
4078 struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
4080 if ((be32_to_cpu(ioasa->ioasc_specific) &
4081 (IPR_ADDITIONAL_STATUS_FMT | IPR_AUTOSENSE_VALID)) == 0)
4084 memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa->auto_sense.data,
4085 min_t(u16, be16_to_cpu(ioasa->auto_sense.auto_sense_len),
4086 SCSI_SENSE_BUFFERSIZE));
4091 * ipr_erp_start - Process an error response for a SCSI op
4092 * @ioa_cfg: ioa config struct
4093 * @ipr_cmd: ipr command struct
4095 * This function determines whether or not to initiate ERP
4096 * on the affected device.
4101 static void ipr_erp_start(struct ipr_ioa_cfg *ioa_cfg,
4102 struct ipr_cmnd *ipr_cmd)
4104 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
4105 struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
4106 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
4109 ipr_scsi_eh_done(ipr_cmd);
4113 if (ipr_is_gscsi(res))
4114 ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
4116 ipr_gen_sense(ipr_cmd);
4118 switch (ioasc & IPR_IOASC_IOASC_MASK) {
4119 case IPR_IOASC_ABORTED_CMD_TERM_BY_HOST:
4120 if (ipr_is_naca_model(res))
4121 scsi_cmd->result |= (DID_ABORT << 16);
4123 scsi_cmd->result |= (DID_IMM_RETRY << 16);
4125 case IPR_IOASC_IR_RESOURCE_HANDLE:
4126 case IPR_IOASC_IR_NO_CMDS_TO_2ND_IOA:
4127 scsi_cmd->result |= (DID_NO_CONNECT << 16);
4129 case IPR_IOASC_HW_SEL_TIMEOUT:
4130 scsi_cmd->result |= (DID_NO_CONNECT << 16);
4131 if (!ipr_is_naca_model(res))
4132 res->needs_sync_complete = 1;
4134 case IPR_IOASC_SYNC_REQUIRED:
4136 res->needs_sync_complete = 1;
4137 scsi_cmd->result |= (DID_IMM_RETRY << 16);
4139 case IPR_IOASC_MED_DO_NOT_REALLOC: /* prevent retries */
4140 case IPR_IOASA_IR_DUAL_IOA_DISABLED:
4141 scsi_cmd->result |= (DID_PASSTHROUGH << 16);
4143 case IPR_IOASC_BUS_WAS_RESET:
4144 case IPR_IOASC_BUS_WAS_RESET_BY_OTHER:
4146 * Report the bus reset and ask for a retry. The device
4147 * will give CC/UA the next command.
4149 if (!res->resetting_device)
4150 scsi_report_bus_reset(ioa_cfg->host, scsi_cmd->device->channel);
4151 scsi_cmd->result |= (DID_ERROR << 16);
4152 if (!ipr_is_naca_model(res))
4153 res->needs_sync_complete = 1;
4155 case IPR_IOASC_HW_DEV_BUS_STATUS:
4156 scsi_cmd->result |= IPR_IOASC_SENSE_STATUS(ioasc);
4157 if (IPR_IOASC_SENSE_STATUS(ioasc) == SAM_STAT_CHECK_CONDITION) {
4158 if (!ipr_get_autosense(ipr_cmd)) {
4159 if (!ipr_is_naca_model(res)) {
4160 ipr_erp_cancel_all(ipr_cmd);
4165 if (!ipr_is_naca_model(res))
4166 res->needs_sync_complete = 1;
4168 case IPR_IOASC_NR_INIT_CMD_REQUIRED:
4171 scsi_cmd->result |= (DID_ERROR << 16);
4172 if (!ipr_is_vset_device(res) && !ipr_is_naca_model(res))
4173 res->needs_sync_complete = 1;
4177 ipr_unmap_sglist(ioa_cfg, ipr_cmd);
4178 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4179 scsi_cmd->scsi_done(scsi_cmd);
4183 * ipr_scsi_done - mid-layer done function
4184 * @ipr_cmd: ipr command struct
4186 * This function is invoked by the interrupt handler for
4187 * ops generated by the SCSI mid-layer
4192 static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd)
4194 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4195 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
4196 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
4198 scsi_cmd->resid = be32_to_cpu(ipr_cmd->ioasa.residual_data_len);
4200 if (likely(IPR_IOASC_SENSE_KEY(ioasc) == 0)) {
4201 ipr_unmap_sglist(ioa_cfg, ipr_cmd);
4202 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4203 scsi_cmd->scsi_done(scsi_cmd);
4205 ipr_erp_start(ioa_cfg, ipr_cmd);
4209 * ipr_queuecommand - Queue a mid-layer request
4210 * @scsi_cmd: scsi command struct
4211 * @done: done function
4213 * This function queues a request generated by the mid-layer.
4217 * SCSI_MLQUEUE_DEVICE_BUSY if device is busy
4218 * SCSI_MLQUEUE_HOST_BUSY if host is busy
4220 static int ipr_queuecommand(struct scsi_cmnd *scsi_cmd,
4221 void (*done) (struct scsi_cmnd *))
4223 struct ipr_ioa_cfg *ioa_cfg;
4224 struct ipr_resource_entry *res;
4225 struct ipr_ioarcb *ioarcb;
4226 struct ipr_cmnd *ipr_cmd;
4229 scsi_cmd->scsi_done = done;
4230 ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
4231 res = scsi_cmd->device->hostdata;
4232 scsi_cmd->result = (DID_OK << 16);
4235 * We are currently blocking all devices due to a host reset
4236 * We have told the host to stop giving us new requests, but
4237 * ERP ops don't count. FIXME
4239 if (unlikely(!ioa_cfg->allow_cmds && !ioa_cfg->ioa_is_dead))
4240 return SCSI_MLQUEUE_HOST_BUSY;
4243 * FIXME - Create scsi_set_host_offline interface
4244 * and the ioa_is_dead check can be removed
4246 if (unlikely(ioa_cfg->ioa_is_dead || !res)) {
4247 memset(scsi_cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
4248 scsi_cmd->result = (DID_NO_CONNECT << 16);
4249 scsi_cmd->scsi_done(scsi_cmd);
4253 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
4254 ioarcb = &ipr_cmd->ioarcb;
4255 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
4257 memcpy(ioarcb->cmd_pkt.cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);
4258 ipr_cmd->scsi_cmd = scsi_cmd;
4259 ioarcb->res_handle = res->cfgte.res_handle;
4260 ipr_cmd->done = ipr_scsi_done;
4261 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_PHYS_LOC(res->cfgte.res_addr));
4263 if (ipr_is_gscsi(res) || ipr_is_vset_device(res)) {
4264 if (scsi_cmd->underflow == 0)
4265 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
4267 if (res->needs_sync_complete) {
4268 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_SYNC_COMPLETE;
4269 res->needs_sync_complete = 0;
4272 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
4273 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
4274 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_ALIGNED_BFR;
4275 ioarcb->cmd_pkt.flags_lo |= ipr_get_task_attributes(scsi_cmd);
4278 if (scsi_cmd->cmnd[0] >= 0xC0 &&
4279 (!ipr_is_gscsi(res) || scsi_cmd->cmnd[0] == IPR_QUERY_RSRC_STATE))
4280 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
4282 if (likely(rc == 0))
4283 rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
4285 if (likely(rc == 0)) {
4287 writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
4288 ioa_cfg->regs.ioarrin_reg);
4290 list_move_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4291 return SCSI_MLQUEUE_HOST_BUSY;
4298 * ipr_info - Get information about the card/driver
4299 * @scsi_host: scsi host struct
4302 * pointer to buffer with description string
4304 static const char * ipr_ioa_info(struct Scsi_Host *host)
4306 static char buffer[512];
4307 struct ipr_ioa_cfg *ioa_cfg;
4308 unsigned long lock_flags = 0;
4310 ioa_cfg = (struct ipr_ioa_cfg *) host->hostdata;
4312 spin_lock_irqsave(host->host_lock, lock_flags);
4313 sprintf(buffer, "IBM %X Storage Adapter", ioa_cfg->type);
4314 spin_unlock_irqrestore(host->host_lock, lock_flags);
4319 static struct scsi_host_template driver_template = {
4320 .module = THIS_MODULE,
4322 .info = ipr_ioa_info,
4323 .queuecommand = ipr_queuecommand,
4324 .eh_abort_handler = ipr_eh_abort,
4325 .eh_device_reset_handler = ipr_eh_dev_reset,
4326 .eh_host_reset_handler = ipr_eh_host_reset,
4327 .slave_alloc = ipr_slave_alloc,
4328 .slave_configure = ipr_slave_configure,
4329 .slave_destroy = ipr_slave_destroy,
4330 .change_queue_depth = ipr_change_queue_depth,
4331 .change_queue_type = ipr_change_queue_type,
4332 .bios_param = ipr_biosparam,
4333 .can_queue = IPR_MAX_COMMANDS,
4335 .sg_tablesize = IPR_MAX_SGLIST,
4336 .max_sectors = IPR_IOA_MAX_SECTORS,
4337 .cmd_per_lun = IPR_MAX_CMD_PER_LUN,
4338 .use_clustering = ENABLE_CLUSTERING,
4339 .shost_attrs = ipr_ioa_attrs,
4340 .sdev_attrs = ipr_dev_attrs,
4341 .proc_name = IPR_NAME
4344 #ifdef CONFIG_PPC_PSERIES
4345 static const u16 ipr_blocked_processors[] = {
4357 * ipr_invalid_adapter - Determine if this adapter is supported on this hardware
4358 * @ioa_cfg: ioa cfg struct
4360 * Adapters that use Gemstone revision < 3.1 do not work reliably on
4361 * certain pSeries hardware. This function determines if the given
4362 * adapter is in one of these confgurations or not.
4365 * 1 if adapter is not supported / 0 if adapter is supported
4367 static int ipr_invalid_adapter(struct ipr_ioa_cfg *ioa_cfg)
4372 if (ioa_cfg->type == 0x5702) {
4373 if (pci_read_config_byte(ioa_cfg->pdev, PCI_REVISION_ID,
4374 &rev_id) == PCIBIOS_SUCCESSFUL) {
4376 for (i = 0; i < ARRAY_SIZE(ipr_blocked_processors); i++){
4377 if (__is_processor(ipr_blocked_processors[i]))
4386 #define ipr_invalid_adapter(ioa_cfg) 0
4390 * ipr_ioa_bringdown_done - IOA bring down completion.
4391 * @ipr_cmd: ipr command struct
4393 * This function processes the completion of an adapter bring down.
4394 * It wakes any reset sleepers.
4399 static int ipr_ioa_bringdown_done(struct ipr_cmnd *ipr_cmd)
4401 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4404 ioa_cfg->in_reset_reload = 0;
4405 ioa_cfg->reset_retries = 0;
4406 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4407 wake_up_all(&ioa_cfg->reset_wait_q);
4409 spin_unlock_irq(ioa_cfg->host->host_lock);
4410 scsi_unblock_requests(ioa_cfg->host);
4411 spin_lock_irq(ioa_cfg->host->host_lock);
4414 return IPR_RC_JOB_RETURN;
4418 * ipr_ioa_reset_done - IOA reset completion.
4419 * @ipr_cmd: ipr command struct
4421 * This function processes the completion of an adapter reset.
4422 * It schedules any necessary mid-layer add/removes and
4423 * wakes any reset sleepers.
4428 static int ipr_ioa_reset_done(struct ipr_cmnd *ipr_cmd)
4430 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4431 struct ipr_resource_entry *res;
4432 struct ipr_hostrcb *hostrcb, *temp;
4436 ioa_cfg->in_reset_reload = 0;
4437 ioa_cfg->allow_cmds = 1;
4438 ioa_cfg->reset_cmd = NULL;
4439 ioa_cfg->doorbell |= IPR_RUNTIME_RESET;
4441 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4442 if (ioa_cfg->allow_ml_add_del && (res->add_to_ml || res->del_from_ml)) {
4447 schedule_work(&ioa_cfg->work_q);
4449 list_for_each_entry_safe(hostrcb, temp, &ioa_cfg->hostrcb_free_q, queue) {
4450 list_del(&hostrcb->queue);
4451 if (i++ < IPR_NUM_LOG_HCAMS)
4452 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
4454 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
4457 dev_info(&ioa_cfg->pdev->dev, "IOA initialized.\n");
4459 ioa_cfg->reset_retries = 0;
4460 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4461 wake_up_all(&ioa_cfg->reset_wait_q);
4463 spin_unlock_irq(ioa_cfg->host->host_lock);
4464 scsi_unblock_requests(ioa_cfg->host);
4465 spin_lock_irq(ioa_cfg->host->host_lock);
4467 if (!ioa_cfg->allow_cmds)
4468 scsi_block_requests(ioa_cfg->host);
4471 return IPR_RC_JOB_RETURN;
4475 * ipr_set_sup_dev_dflt - Initialize a Set Supported Device buffer
4476 * @supported_dev: supported device struct
4477 * @vpids: vendor product id struct
4482 static void ipr_set_sup_dev_dflt(struct ipr_supported_device *supported_dev,
4483 struct ipr_std_inq_vpids *vpids)
4485 memset(supported_dev, 0, sizeof(struct ipr_supported_device));
4486 memcpy(&supported_dev->vpids, vpids, sizeof(struct ipr_std_inq_vpids));
4487 supported_dev->num_records = 1;
4488 supported_dev->data_length =
4489 cpu_to_be16(sizeof(struct ipr_supported_device));
4490 supported_dev->reserved = 0;
4494 * ipr_set_supported_devs - Send Set Supported Devices for a device
4495 * @ipr_cmd: ipr command struct
4497 * This function send a Set Supported Devices to the adapter
4500 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
4502 static int ipr_set_supported_devs(struct ipr_cmnd *ipr_cmd)
4504 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4505 struct ipr_supported_device *supp_dev = &ioa_cfg->vpd_cbs->supp_dev;
4506 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
4507 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
4508 struct ipr_resource_entry *res = ipr_cmd->u.res;
4510 ipr_cmd->job_step = ipr_ioa_reset_done;
4512 list_for_each_entry_continue(res, &ioa_cfg->used_res_q, queue) {
4513 if (!ipr_is_scsi_disk(res))
4516 ipr_cmd->u.res = res;
4517 ipr_set_sup_dev_dflt(supp_dev, &res->cfgte.std_inq_data.vpids);
4519 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
4520 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
4521 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
4523 ioarcb->cmd_pkt.cdb[0] = IPR_SET_SUPPORTED_DEVICES;
4524 ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_supported_device) >> 8) & 0xff;
4525 ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_supported_device) & 0xff;
4527 ioadl->flags_and_data_len = cpu_to_be32(IPR_IOADL_FLAGS_WRITE_LAST |
4528 sizeof(struct ipr_supported_device));
4529 ioadl->address = cpu_to_be32(ioa_cfg->vpd_cbs_dma +
4530 offsetof(struct ipr_misc_cbs, supp_dev));
4531 ioarcb->write_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
4532 ioarcb->write_data_transfer_length =
4533 cpu_to_be32(sizeof(struct ipr_supported_device));
4535 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
4536 IPR_SET_SUP_DEVICE_TIMEOUT);
4538 ipr_cmd->job_step = ipr_set_supported_devs;
4539 return IPR_RC_JOB_RETURN;
4542 return IPR_RC_JOB_CONTINUE;
4546 * ipr_setup_write_cache - Disable write cache if needed
4547 * @ipr_cmd: ipr command struct
4549 * This function sets up adapters write cache to desired setting
4552 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
4554 static int ipr_setup_write_cache(struct ipr_cmnd *ipr_cmd)
4556 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4558 ipr_cmd->job_step = ipr_set_supported_devs;
4559 ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
4560 struct ipr_resource_entry, queue);
4562 if (ioa_cfg->cache_state != CACHE_DISABLED)
4563 return IPR_RC_JOB_CONTINUE;
4565 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
4566 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
4567 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
4568 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_SHUTDOWN_PREPARE_FOR_NORMAL;
4570 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
4572 return IPR_RC_JOB_RETURN;
4576 * ipr_get_mode_page - Locate specified mode page
4577 * @mode_pages: mode page buffer
4578 * @page_code: page code to find
4579 * @len: minimum required length for mode page
4582 * pointer to mode page / NULL on failure
4584 static void *ipr_get_mode_page(struct ipr_mode_pages *mode_pages,
4585 u32 page_code, u32 len)
4587 struct ipr_mode_page_hdr *mode_hdr;
4591 if (!mode_pages || (mode_pages->hdr.length == 0))
4594 length = (mode_pages->hdr.length + 1) - 4 - mode_pages->hdr.block_desc_len;
4595 mode_hdr = (struct ipr_mode_page_hdr *)
4596 (mode_pages->data + mode_pages->hdr.block_desc_len);
4599 if (IPR_GET_MODE_PAGE_CODE(mode_hdr) == page_code) {
4600 if (mode_hdr->page_length >= (len - sizeof(struct ipr_mode_page_hdr)))
4604 page_length = (sizeof(struct ipr_mode_page_hdr) +
4605 mode_hdr->page_length);
4606 length -= page_length;
4607 mode_hdr = (struct ipr_mode_page_hdr *)
4608 ((unsigned long)mode_hdr + page_length);
4615 * ipr_check_term_power - Check for term power errors
4616 * @ioa_cfg: ioa config struct
4617 * @mode_pages: IOAFP mode pages buffer
4619 * Check the IOAFP's mode page 28 for term power errors
4624 static void ipr_check_term_power(struct ipr_ioa_cfg *ioa_cfg,
4625 struct ipr_mode_pages *mode_pages)
4629 struct ipr_dev_bus_entry *bus;
4630 struct ipr_mode_page28 *mode_page;
4632 mode_page = ipr_get_mode_page(mode_pages, 0x28,
4633 sizeof(struct ipr_mode_page28));
4635 entry_length = mode_page->entry_length;
4637 bus = mode_page->bus;
4639 for (i = 0; i < mode_page->num_entries; i++) {
4640 if (bus->flags & IPR_SCSI_ATTR_NO_TERM_PWR) {
4641 dev_err(&ioa_cfg->pdev->dev,
4642 "Term power is absent on scsi bus %d\n",
4646 bus = (struct ipr_dev_bus_entry *)((char *)bus + entry_length);
4651 * ipr_scsi_bus_speed_limit - Limit the SCSI speed based on SES table
4652 * @ioa_cfg: ioa config struct
4654 * Looks through the config table checking for SES devices. If
4655 * the SES device is in the SES table indicating a maximum SCSI
4656 * bus speed, the speed is limited for the bus.
4661 static void ipr_scsi_bus_speed_limit(struct ipr_ioa_cfg *ioa_cfg)
4666 for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
4667 max_xfer_rate = ipr_get_max_scsi_speed(ioa_cfg, i,
4668 ioa_cfg->bus_attr[i].bus_width);
4670 if (max_xfer_rate < ioa_cfg->bus_attr[i].max_xfer_rate)
4671 ioa_cfg->bus_attr[i].max_xfer_rate = max_xfer_rate;
4676 * ipr_modify_ioafp_mode_page_28 - Modify IOAFP Mode Page 28
4677 * @ioa_cfg: ioa config struct
4678 * @mode_pages: mode page 28 buffer
4680 * Updates mode page 28 based on driver configuration
4685 static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg *ioa_cfg,
4686 struct ipr_mode_pages *mode_pages)
4688 int i, entry_length;
4689 struct ipr_dev_bus_entry *bus;
4690 struct ipr_bus_attributes *bus_attr;
4691 struct ipr_mode_page28 *mode_page;
4693 mode_page = ipr_get_mode_page(mode_pages, 0x28,
4694 sizeof(struct ipr_mode_page28));
4696 entry_length = mode_page->entry_length;
4698 /* Loop for each device bus entry */
4699 for (i = 0, bus = mode_page->bus;
4700 i < mode_page->num_entries;
4701 i++, bus = (struct ipr_dev_bus_entry *)((u8 *)bus + entry_length)) {
4702 if (bus->res_addr.bus > IPR_MAX_NUM_BUSES) {
4703 dev_err(&ioa_cfg->pdev->dev,
4704 "Invalid resource address reported: 0x%08X\n",
4705 IPR_GET_PHYS_LOC(bus->res_addr));
4709 bus_attr = &ioa_cfg->bus_attr[i];
4710 bus->extended_reset_delay = IPR_EXTENDED_RESET_DELAY;
4711 bus->bus_width = bus_attr->bus_width;
4712 bus->max_xfer_rate = cpu_to_be32(bus_attr->max_xfer_rate);
4713 bus->flags &= ~IPR_SCSI_ATTR_QAS_MASK;
4714 if (bus_attr->qas_enabled)
4715 bus->flags |= IPR_SCSI_ATTR_ENABLE_QAS;
4717 bus->flags |= IPR_SCSI_ATTR_DISABLE_QAS;
4722 * ipr_build_mode_select - Build a mode select command
4723 * @ipr_cmd: ipr command struct
4724 * @res_handle: resource handle to send command to
4725 * @parm: Byte 2 of Mode Sense command
4726 * @dma_addr: DMA buffer address
4727 * @xfer_len: data transfer length
4732 static void ipr_build_mode_select(struct ipr_cmnd *ipr_cmd,
4733 __be32 res_handle, u8 parm, u32 dma_addr,
4736 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
4737 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
4739 ioarcb->res_handle = res_handle;
4740 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
4741 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
4742 ioarcb->cmd_pkt.cdb[0] = MODE_SELECT;
4743 ioarcb->cmd_pkt.cdb[1] = parm;
4744 ioarcb->cmd_pkt.cdb[4] = xfer_len;
4746 ioadl->flags_and_data_len =
4747 cpu_to_be32(IPR_IOADL_FLAGS_WRITE_LAST | xfer_len);
4748 ioadl->address = cpu_to_be32(dma_addr);
4749 ioarcb->write_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
4750 ioarcb->write_data_transfer_length = cpu_to_be32(xfer_len);
4754 * ipr_ioafp_mode_select_page28 - Issue Mode Select Page 28 to IOA
4755 * @ipr_cmd: ipr command struct
4757 * This function sets up the SCSI bus attributes and sends
4758 * a Mode Select for Page 28 to activate them.
4763 static int ipr_ioafp_mode_select_page28(struct ipr_cmnd *ipr_cmd)
4765 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4766 struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
4770 ipr_scsi_bus_speed_limit(ioa_cfg);
4771 ipr_check_term_power(ioa_cfg, mode_pages);
4772 ipr_modify_ioafp_mode_page_28(ioa_cfg, mode_pages);
4773 length = mode_pages->hdr.length + 1;
4774 mode_pages->hdr.length = 0;
4776 ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
4777 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
4780 ipr_cmd->job_step = ipr_setup_write_cache;
4781 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
4784 return IPR_RC_JOB_RETURN;
4788 * ipr_build_mode_sense - Builds a mode sense command
4789 * @ipr_cmd: ipr command struct
4790 * @res: resource entry struct
4791 * @parm: Byte 2 of mode sense command
4792 * @dma_addr: DMA address of mode sense buffer
4793 * @xfer_len: Size of DMA buffer
4798 static void ipr_build_mode_sense(struct ipr_cmnd *ipr_cmd,
4800 u8 parm, u32 dma_addr, u8 xfer_len)
4802 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
4803 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
4805 ioarcb->res_handle = res_handle;
4806 ioarcb->cmd_pkt.cdb[0] = MODE_SENSE;
4807 ioarcb->cmd_pkt.cdb[2] = parm;
4808 ioarcb->cmd_pkt.cdb[4] = xfer_len;
4809 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
4811 ioadl->flags_and_data_len =
4812 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | xfer_len);
4813 ioadl->address = cpu_to_be32(dma_addr);
4814 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
4815 ioarcb->read_data_transfer_length = cpu_to_be32(xfer_len);
4819 * ipr_reset_cmd_failed - Handle failure of IOA reset command
4820 * @ipr_cmd: ipr command struct
4822 * This function handles the failure of an IOA bringup command.
4827 static int ipr_reset_cmd_failed(struct ipr_cmnd *ipr_cmd)
4829 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4830 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
4832 dev_err(&ioa_cfg->pdev->dev,
4833 "0x%02X failed with IOASC: 0x%08X\n",
4834 ipr_cmd->ioarcb.cmd_pkt.cdb[0], ioasc);
4836 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
4837 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4838 return IPR_RC_JOB_RETURN;
4842 * ipr_reset_mode_sense_failed - Handle failure of IOAFP mode sense
4843 * @ipr_cmd: ipr command struct
4845 * This function handles the failure of a Mode Sense to the IOAFP.
4846 * Some adapters do not handle all mode pages.
4849 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
4851 static int ipr_reset_mode_sense_failed(struct ipr_cmnd *ipr_cmd)
4853 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
4855 if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
4856 ipr_cmd->job_step = ipr_setup_write_cache;
4857 return IPR_RC_JOB_CONTINUE;
4860 return ipr_reset_cmd_failed(ipr_cmd);
4864 * ipr_ioafp_mode_sense_page28 - Issue Mode Sense Page 28 to IOA
4865 * @ipr_cmd: ipr command struct
4867 * This function send a Page 28 mode sense to the IOA to
4868 * retrieve SCSI bus attributes.
4873 static int ipr_ioafp_mode_sense_page28(struct ipr_cmnd *ipr_cmd)
4875 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4878 ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
4879 0x28, ioa_cfg->vpd_cbs_dma +
4880 offsetof(struct ipr_misc_cbs, mode_pages),
4881 sizeof(struct ipr_mode_pages));
4883 ipr_cmd->job_step = ipr_ioafp_mode_select_page28;
4884 ipr_cmd->job_step_failed = ipr_reset_mode_sense_failed;
4886 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
4889 return IPR_RC_JOB_RETURN;
4893 * ipr_init_res_table - Initialize the resource table
4894 * @ipr_cmd: ipr command struct
4896 * This function looks through the existing resource table, comparing
4897 * it with the config table. This function will take care of old/new
4898 * devices and schedule adding/removing them from the mid-layer
4902 * IPR_RC_JOB_CONTINUE
4904 static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd)
4906 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4907 struct ipr_resource_entry *res, *temp;
4908 struct ipr_config_table_entry *cfgte;
4913 if (ioa_cfg->cfg_table->hdr.flags & IPR_UCODE_DOWNLOAD_REQ)
4914 dev_err(&ioa_cfg->pdev->dev, "Microcode download required\n");
4916 list_for_each_entry_safe(res, temp, &ioa_cfg->used_res_q, queue)
4917 list_move_tail(&res->queue, &old_res);
4919 for (i = 0; i < ioa_cfg->cfg_table->hdr.num_entries; i++) {
4920 cfgte = &ioa_cfg->cfg_table->dev[i];
4923 list_for_each_entry_safe(res, temp, &old_res, queue) {
4924 if (!memcmp(&res->cfgte.res_addr,
4925 &cfgte->res_addr, sizeof(cfgte->res_addr))) {
4926 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
4933 if (list_empty(&ioa_cfg->free_res_q)) {
4934 dev_err(&ioa_cfg->pdev->dev, "Too many devices attached\n");
4939 res = list_entry(ioa_cfg->free_res_q.next,
4940 struct ipr_resource_entry, queue);
4941 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
4942 ipr_init_res_entry(res);
4947 memcpy(&res->cfgte, cfgte, sizeof(struct ipr_config_table_entry));
4950 list_for_each_entry_safe(res, temp, &old_res, queue) {
4952 res->del_from_ml = 1;
4953 res->cfgte.res_handle = IPR_INVALID_RES_HANDLE;
4954 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
4956 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
4960 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
4963 return IPR_RC_JOB_CONTINUE;
4967 * ipr_ioafp_query_ioa_cfg - Send a Query IOA Config to the adapter.
4968 * @ipr_cmd: ipr command struct
4970 * This function sends a Query IOA Configuration command
4971 * to the adapter to retrieve the IOA configuration table.
4976 static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
4978 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4979 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
4980 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
4981 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
4984 dev_info(&ioa_cfg->pdev->dev, "Adapter firmware version: %02X%02X%02X%02X\n",
4985 ucode_vpd->major_release, ucode_vpd->card_type,
4986 ucode_vpd->minor_release[0], ucode_vpd->minor_release[1]);
4987 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
4988 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
4990 ioarcb->cmd_pkt.cdb[0] = IPR_QUERY_IOA_CONFIG;
4991 ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_config_table) >> 8) & 0xff;
4992 ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_config_table) & 0xff;
4994 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
4995 ioarcb->read_data_transfer_length =
4996 cpu_to_be32(sizeof(struct ipr_config_table));
4998 ioadl->address = cpu_to_be32(ioa_cfg->cfg_table_dma);
4999 ioadl->flags_and_data_len =
5000 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | sizeof(struct ipr_config_table));
5002 ipr_cmd->job_step = ipr_init_res_table;
5004 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
5007 return IPR_RC_JOB_RETURN;
5011 * ipr_ioafp_inquiry - Send an Inquiry to the adapter.
5012 * @ipr_cmd: ipr command struct
5014 * This utility function sends an inquiry to the adapter.
5019 static void ipr_ioafp_inquiry(struct ipr_cmnd *ipr_cmd, u8 flags, u8 page,
5020 u32 dma_addr, u8 xfer_len)
5022 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5023 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
5026 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
5027 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
5029 ioarcb->cmd_pkt.cdb[0] = INQUIRY;
5030 ioarcb->cmd_pkt.cdb[1] = flags;
5031 ioarcb->cmd_pkt.cdb[2] = page;
5032 ioarcb->cmd_pkt.cdb[4] = xfer_len;
5034 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
5035 ioarcb->read_data_transfer_length = cpu_to_be32(xfer_len);
5037 ioadl->address = cpu_to_be32(dma_addr);
5038 ioadl->flags_and_data_len =
5039 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | xfer_len);
5041 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
5046 * ipr_inquiry_page_supported - Is the given inquiry page supported
5047 * @page0: inquiry page 0 buffer
5050 * This function determines if the specified inquiry page is supported.
5053 * 1 if page is supported / 0 if not
5055 static int ipr_inquiry_page_supported(struct ipr_inquiry_page0 *page0, u8 page)
5059 for (i = 0; i < min_t(u8, page0->len, IPR_INQUIRY_PAGE0_ENTRIES); i++)
5060 if (page0->page[i] == page)
5067 * ipr_ioafp_page3_inquiry - Send a Page 3 Inquiry to the adapter.
5068 * @ipr_cmd: ipr command struct
5070 * This function sends a Page 3 inquiry to the adapter
5071 * to retrieve software VPD information.
5074 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5076 static int ipr_ioafp_page3_inquiry(struct ipr_cmnd *ipr_cmd)
5078 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5079 struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
5083 if (!ipr_inquiry_page_supported(page0, 1))
5084 ioa_cfg->cache_state = CACHE_NONE;
5086 ipr_cmd->job_step = ipr_ioafp_query_ioa_cfg;
5088 ipr_ioafp_inquiry(ipr_cmd, 1, 3,
5089 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page3_data),
5090 sizeof(struct ipr_inquiry_page3));
5093 return IPR_RC_JOB_RETURN;
5097 * ipr_ioafp_page0_inquiry - Send a Page 0 Inquiry to the adapter.
5098 * @ipr_cmd: ipr command struct
5100 * This function sends a Page 0 inquiry to the adapter
5101 * to retrieve supported inquiry pages.
5104 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5106 static int ipr_ioafp_page0_inquiry(struct ipr_cmnd *ipr_cmd)
5108 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5113 /* Grab the type out of the VPD and store it away */
5114 memcpy(type, ioa_cfg->vpd_cbs->ioa_vpd.std_inq_data.vpids.product_id, 4);
5116 ioa_cfg->type = simple_strtoul((char *)type, NULL, 16);
5118 ipr_cmd->job_step = ipr_ioafp_page3_inquiry;
5120 ipr_ioafp_inquiry(ipr_cmd, 1, 0,
5121 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page0_data),
5122 sizeof(struct ipr_inquiry_page0));
5125 return IPR_RC_JOB_RETURN;
5129 * ipr_ioafp_std_inquiry - Send a Standard Inquiry to the adapter.
5130 * @ipr_cmd: ipr command struct
5132 * This function sends a standard inquiry to the adapter.
5137 static int ipr_ioafp_std_inquiry(struct ipr_cmnd *ipr_cmd)
5139 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5142 ipr_cmd->job_step = ipr_ioafp_page0_inquiry;
5144 ipr_ioafp_inquiry(ipr_cmd, 0, 0,
5145 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, ioa_vpd),
5146 sizeof(struct ipr_ioa_vpd));
5149 return IPR_RC_JOB_RETURN;
5153 * ipr_ioafp_indentify_hrrq - Send Identify Host RRQ.
5154 * @ipr_cmd: ipr command struct
5156 * This function send an Identify Host Request Response Queue
5157 * command to establish the HRRQ with the adapter.
5162 static int ipr_ioafp_indentify_hrrq(struct ipr_cmnd *ipr_cmd)
5164 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5165 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5168 dev_info(&ioa_cfg->pdev->dev, "Starting IOA initialization sequence.\n");
5170 ioarcb->cmd_pkt.cdb[0] = IPR_ID_HOST_RR_Q;
5171 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
5173 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
5174 ioarcb->cmd_pkt.cdb[2] =
5175 ((u32) ioa_cfg->host_rrq_dma >> 24) & 0xff;
5176 ioarcb->cmd_pkt.cdb[3] =
5177 ((u32) ioa_cfg->host_rrq_dma >> 16) & 0xff;
5178 ioarcb->cmd_pkt.cdb[4] =
5179 ((u32) ioa_cfg->host_rrq_dma >> 8) & 0xff;
5180 ioarcb->cmd_pkt.cdb[5] =
5181 ((u32) ioa_cfg->host_rrq_dma) & 0xff;
5182 ioarcb->cmd_pkt.cdb[7] =
5183 ((sizeof(u32) * IPR_NUM_CMD_BLKS) >> 8) & 0xff;
5184 ioarcb->cmd_pkt.cdb[8] =
5185 (sizeof(u32) * IPR_NUM_CMD_BLKS) & 0xff;
5187 ipr_cmd->job_step = ipr_ioafp_std_inquiry;
5189 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
5192 return IPR_RC_JOB_RETURN;
5196 * ipr_reset_timer_done - Adapter reset timer function
5197 * @ipr_cmd: ipr command struct
5199 * Description: This function is used in adapter reset processing
5200 * for timing events. If the reset_cmd pointer in the IOA
5201 * config struct is not this adapter's we are doing nested
5202 * resets and fail_all_ops will take care of freeing the
5208 static void ipr_reset_timer_done(struct ipr_cmnd *ipr_cmd)
5210 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5211 unsigned long lock_flags = 0;
5213 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5215 if (ioa_cfg->reset_cmd == ipr_cmd) {
5216 list_del(&ipr_cmd->queue);
5217 ipr_cmd->done(ipr_cmd);
5220 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5224 * ipr_reset_start_timer - Start a timer for adapter reset job
5225 * @ipr_cmd: ipr command struct
5226 * @timeout: timeout value
5228 * Description: This function is used in adapter reset processing
5229 * for timing events. If the reset_cmd pointer in the IOA
5230 * config struct is not this adapter's we are doing nested
5231 * resets and fail_all_ops will take care of freeing the
5237 static void ipr_reset_start_timer(struct ipr_cmnd *ipr_cmd,
5238 unsigned long timeout)
5240 list_add_tail(&ipr_cmd->queue, &ipr_cmd->ioa_cfg->pending_q);
5241 ipr_cmd->done = ipr_reset_ioa_job;
5243 ipr_cmd->timer.data = (unsigned long) ipr_cmd;
5244 ipr_cmd->timer.expires = jiffies + timeout;
5245 ipr_cmd->timer.function = (void (*)(unsigned long))ipr_reset_timer_done;
5246 add_timer(&ipr_cmd->timer);
5250 * ipr_init_ioa_mem - Initialize ioa_cfg control block
5251 * @ioa_cfg: ioa cfg struct
5256 static void ipr_init_ioa_mem(struct ipr_ioa_cfg *ioa_cfg)
5258 memset(ioa_cfg->host_rrq, 0, sizeof(u32) * IPR_NUM_CMD_BLKS);
5260 /* Initialize Host RRQ pointers */
5261 ioa_cfg->hrrq_start = ioa_cfg->host_rrq;
5262 ioa_cfg->hrrq_end = &ioa_cfg->host_rrq[IPR_NUM_CMD_BLKS - 1];
5263 ioa_cfg->hrrq_curr = ioa_cfg->hrrq_start;
5264 ioa_cfg->toggle_bit = 1;
5266 /* Zero out config table */
5267 memset(ioa_cfg->cfg_table, 0, sizeof(struct ipr_config_table));
5271 * ipr_reset_enable_ioa - Enable the IOA following a reset.
5272 * @ipr_cmd: ipr command struct
5274 * This function reinitializes some control blocks and
5275 * enables destructive diagnostics on the adapter.
5280 static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd)
5282 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5283 volatile u32 int_reg;
5286 ipr_cmd->job_step = ipr_ioafp_indentify_hrrq;
5287 ipr_init_ioa_mem(ioa_cfg);
5289 ioa_cfg->allow_interrupts = 1;
5290 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
5292 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
5293 writel((IPR_PCII_ERROR_INTERRUPTS | IPR_PCII_HRRQ_UPDATED),
5294 ioa_cfg->regs.clr_interrupt_mask_reg);
5295 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
5296 return IPR_RC_JOB_CONTINUE;
5299 /* Enable destructive diagnostics on IOA */
5300 writel(ioa_cfg->doorbell, ioa_cfg->regs.set_uproc_interrupt_reg);
5302 writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg);
5303 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
5305 dev_info(&ioa_cfg->pdev->dev, "Initializing IOA.\n");
5307 ipr_cmd->timer.data = (unsigned long) ipr_cmd;
5308 ipr_cmd->timer.expires = jiffies + (ipr_transop_timeout * HZ);
5309 ipr_cmd->timer.function = (void (*)(unsigned long))ipr_oper_timeout;
5310 ipr_cmd->done = ipr_reset_ioa_job;
5311 add_timer(&ipr_cmd->timer);
5312 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
5315 return IPR_RC_JOB_RETURN;
5319 * ipr_reset_wait_for_dump - Wait for a dump to timeout.
5320 * @ipr_cmd: ipr command struct
5322 * This function is invoked when an adapter dump has run out
5323 * of processing time.
5326 * IPR_RC_JOB_CONTINUE
5328 static int ipr_reset_wait_for_dump(struct ipr_cmnd *ipr_cmd)
5330 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5332 if (ioa_cfg->sdt_state == GET_DUMP)
5333 ioa_cfg->sdt_state = ABORT_DUMP;
5335 ipr_cmd->job_step = ipr_reset_alert;
5337 return IPR_RC_JOB_CONTINUE;
5341 * ipr_unit_check_no_data - Log a unit check/no data error log
5342 * @ioa_cfg: ioa config struct
5344 * Logs an error indicating the adapter unit checked, but for some
5345 * reason, we were unable to fetch the unit check buffer.
5350 static void ipr_unit_check_no_data(struct ipr_ioa_cfg *ioa_cfg)
5352 ioa_cfg->errors_logged++;
5353 dev_err(&ioa_cfg->pdev->dev, "IOA unit check with no data\n");
5357 * ipr_get_unit_check_buffer - Get the unit check buffer from the IOA
5358 * @ioa_cfg: ioa config struct
5360 * Fetches the unit check buffer from the adapter by clocking the data
5361 * through the mailbox register.
5366 static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
5368 unsigned long mailbox;
5369 struct ipr_hostrcb *hostrcb;
5370 struct ipr_uc_sdt sdt;
5373 mailbox = readl(ioa_cfg->ioa_mailbox);
5375 if (!ipr_sdt_is_fmt2(mailbox)) {
5376 ipr_unit_check_no_data(ioa_cfg);
5380 memset(&sdt, 0, sizeof(struct ipr_uc_sdt));
5381 rc = ipr_get_ldump_data_section(ioa_cfg, mailbox, (__be32 *) &sdt,
5382 (sizeof(struct ipr_uc_sdt)) / sizeof(__be32));
5384 if (rc || (be32_to_cpu(sdt.hdr.state) != IPR_FMT2_SDT_READY_TO_USE) ||
5385 !(sdt.entry[0].flags & IPR_SDT_VALID_ENTRY)) {
5386 ipr_unit_check_no_data(ioa_cfg);
5390 /* Find length of the first sdt entry (UC buffer) */
5391 length = (be32_to_cpu(sdt.entry[0].end_offset) -
5392 be32_to_cpu(sdt.entry[0].bar_str_offset)) & IPR_FMT2_MBX_ADDR_MASK;
5394 hostrcb = list_entry(ioa_cfg->hostrcb_free_q.next,
5395 struct ipr_hostrcb, queue);
5396 list_del(&hostrcb->queue);
5397 memset(&hostrcb->hcam, 0, sizeof(hostrcb->hcam));
5399 rc = ipr_get_ldump_data_section(ioa_cfg,
5400 be32_to_cpu(sdt.entry[0].bar_str_offset),
5401 (__be32 *)&hostrcb->hcam,
5402 min(length, (int)sizeof(hostrcb->hcam)) / sizeof(__be32));
5405 ipr_handle_log_data(ioa_cfg, hostrcb);
5407 ipr_unit_check_no_data(ioa_cfg);
5409 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
5413 * ipr_reset_restore_cfg_space - Restore PCI config space.
5414 * @ipr_cmd: ipr command struct
5416 * Description: This function restores the saved PCI config space of
5417 * the adapter, fails all outstanding ops back to the callers, and
5418 * fetches the dump/unit check if applicable to this reset.
5421 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5423 static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
5425 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5429 pci_unblock_user_cfg_access(ioa_cfg->pdev);
5430 rc = pci_restore_state(ioa_cfg->pdev);
5432 if (rc != PCIBIOS_SUCCESSFUL) {
5433 ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
5434 return IPR_RC_JOB_CONTINUE;
5437 if (ipr_set_pcix_cmd_reg(ioa_cfg)) {
5438 ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
5439 return IPR_RC_JOB_CONTINUE;
5442 ipr_fail_all_ops(ioa_cfg);
5444 if (ioa_cfg->ioa_unit_checked) {
5445 ioa_cfg->ioa_unit_checked = 0;
5446 ipr_get_unit_check_buffer(ioa_cfg);
5447 ipr_cmd->job_step = ipr_reset_alert;
5448 ipr_reset_start_timer(ipr_cmd, 0);
5449 return IPR_RC_JOB_RETURN;
5452 if (ioa_cfg->in_ioa_bringdown) {
5453 ipr_cmd->job_step = ipr_ioa_bringdown_done;
5455 ipr_cmd->job_step = ipr_reset_enable_ioa;
5457 if (GET_DUMP == ioa_cfg->sdt_state) {
5458 ipr_reset_start_timer(ipr_cmd, IPR_DUMP_TIMEOUT);
5459 ipr_cmd->job_step = ipr_reset_wait_for_dump;
5460 schedule_work(&ioa_cfg->work_q);
5461 return IPR_RC_JOB_RETURN;
5466 return IPR_RC_JOB_CONTINUE;
5470 * ipr_reset_start_bist - Run BIST on the adapter.
5471 * @ipr_cmd: ipr command struct
5473 * Description: This function runs BIST on the adapter, then delays 2 seconds.
5476 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5478 static int ipr_reset_start_bist(struct ipr_cmnd *ipr_cmd)
5480 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5484 pci_block_user_cfg_access(ioa_cfg->pdev);
5485 rc = pci_write_config_byte(ioa_cfg->pdev, PCI_BIST, PCI_BIST_START);
5487 if (rc != PCIBIOS_SUCCESSFUL) {
5488 ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
5489 rc = IPR_RC_JOB_CONTINUE;
5491 ipr_cmd->job_step = ipr_reset_restore_cfg_space;
5492 ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
5493 rc = IPR_RC_JOB_RETURN;
5501 * ipr_reset_allowed - Query whether or not IOA can be reset
5502 * @ioa_cfg: ioa config struct
5505 * 0 if reset not allowed / non-zero if reset is allowed
5507 static int ipr_reset_allowed(struct ipr_ioa_cfg *ioa_cfg)
5509 volatile u32 temp_reg;
5511 temp_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
5512 return ((temp_reg & IPR_PCII_CRITICAL_OPERATION) == 0);
5516 * ipr_reset_wait_to_start_bist - Wait for permission to reset IOA.
5517 * @ipr_cmd: ipr command struct
5519 * Description: This function waits for adapter permission to run BIST,
5520 * then runs BIST. If the adapter does not give permission after a
5521 * reasonable time, we will reset the adapter anyway. The impact of
5522 * resetting the adapter without warning the adapter is the risk of
5523 * losing the persistent error log on the adapter. If the adapter is
5524 * reset while it is writing to the flash on the adapter, the flash
5525 * segment will have bad ECC and be zeroed.
5528 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5530 static int ipr_reset_wait_to_start_bist(struct ipr_cmnd *ipr_cmd)
5532 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5533 int rc = IPR_RC_JOB_RETURN;
5535 if (!ipr_reset_allowed(ioa_cfg) && ipr_cmd->u.time_left) {
5536 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
5537 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
5539 ipr_cmd->job_step = ipr_reset_start_bist;
5540 rc = IPR_RC_JOB_CONTINUE;
5547 * ipr_reset_alert_part2 - Alert the adapter of a pending reset
5548 * @ipr_cmd: ipr command struct
5550 * Description: This function alerts the adapter that it will be reset.
5551 * If memory space is not currently enabled, proceed directly
5552 * to running BIST on the adapter. The timer must always be started
5553 * so we guarantee we do not run BIST from ipr_isr.
5558 static int ipr_reset_alert(struct ipr_cmnd *ipr_cmd)
5560 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5565 rc = pci_read_config_word(ioa_cfg->pdev, PCI_COMMAND, &cmd_reg);
5567 if ((rc == PCIBIOS_SUCCESSFUL) && (cmd_reg & PCI_COMMAND_MEMORY)) {
5568 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
5569 writel(IPR_UPROCI_RESET_ALERT, ioa_cfg->regs.set_uproc_interrupt_reg);
5570 ipr_cmd->job_step = ipr_reset_wait_to_start_bist;
5572 ipr_cmd->job_step = ipr_reset_start_bist;
5575 ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
5576 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
5579 return IPR_RC_JOB_RETURN;
5583 * ipr_reset_ucode_download_done - Microcode download completion
5584 * @ipr_cmd: ipr command struct
5586 * Description: This function unmaps the microcode download buffer.
5589 * IPR_RC_JOB_CONTINUE
5591 static int ipr_reset_ucode_download_done(struct ipr_cmnd *ipr_cmd)
5593 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5594 struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
5596 pci_unmap_sg(ioa_cfg->pdev, sglist->scatterlist,
5597 sglist->num_sg, DMA_TO_DEVICE);
5599 ipr_cmd->job_step = ipr_reset_alert;
5600 return IPR_RC_JOB_CONTINUE;
5604 * ipr_reset_ucode_download - Download microcode to the adapter
5605 * @ipr_cmd: ipr command struct
5607 * Description: This function checks to see if it there is microcode
5608 * to download to the adapter. If there is, a download is performed.
5611 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5613 static int ipr_reset_ucode_download(struct ipr_cmnd *ipr_cmd)
5615 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5616 struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
5619 ipr_cmd->job_step = ipr_reset_alert;
5622 return IPR_RC_JOB_CONTINUE;
5624 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
5625 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
5626 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = WRITE_BUFFER;
5627 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_WR_BUF_DOWNLOAD_AND_SAVE;
5628 ipr_cmd->ioarcb.cmd_pkt.cdb[6] = (sglist->buffer_len & 0xff0000) >> 16;
5629 ipr_cmd->ioarcb.cmd_pkt.cdb[7] = (sglist->buffer_len & 0x00ff00) >> 8;
5630 ipr_cmd->ioarcb.cmd_pkt.cdb[8] = sglist->buffer_len & 0x0000ff;
5632 ipr_build_ucode_ioadl(ipr_cmd, sglist);
5633 ipr_cmd->job_step = ipr_reset_ucode_download_done;
5635 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
5636 IPR_WRITE_BUFFER_TIMEOUT);
5639 return IPR_RC_JOB_RETURN;
5643 * ipr_reset_shutdown_ioa - Shutdown the adapter
5644 * @ipr_cmd: ipr command struct
5646 * Description: This function issues an adapter shutdown of the
5647 * specified type to the specified adapter as part of the
5648 * adapter reset job.
5651 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5653 static int ipr_reset_shutdown_ioa(struct ipr_cmnd *ipr_cmd)
5655 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5656 enum ipr_shutdown_type shutdown_type = ipr_cmd->u.shutdown_type;
5657 unsigned long timeout;
5658 int rc = IPR_RC_JOB_CONTINUE;
5661 if (shutdown_type != IPR_SHUTDOWN_NONE && !ioa_cfg->ioa_is_dead) {
5662 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
5663 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
5664 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
5665 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = shutdown_type;
5667 if (shutdown_type == IPR_SHUTDOWN_ABBREV)
5668 timeout = IPR_ABBREV_SHUTDOWN_TIMEOUT;
5669 else if (shutdown_type == IPR_SHUTDOWN_PREPARE_FOR_NORMAL)
5670 timeout = IPR_INTERNAL_TIMEOUT;
5672 timeout = IPR_SHUTDOWN_TIMEOUT;
5674 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, timeout);
5676 rc = IPR_RC_JOB_RETURN;
5677 ipr_cmd->job_step = ipr_reset_ucode_download;
5679 ipr_cmd->job_step = ipr_reset_alert;
5686 * ipr_reset_ioa_job - Adapter reset job
5687 * @ipr_cmd: ipr command struct
5689 * Description: This function is the job router for the adapter reset job.
5694 static void ipr_reset_ioa_job(struct ipr_cmnd *ipr_cmd)
5697 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5700 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
5702 if (ioa_cfg->reset_cmd != ipr_cmd) {
5704 * We are doing nested adapter resets and this is
5705 * not the current reset job.
5707 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
5711 if (IPR_IOASC_SENSE_KEY(ioasc)) {
5712 rc = ipr_cmd->job_step_failed(ipr_cmd);
5713 if (rc == IPR_RC_JOB_RETURN)
5717 ipr_reinit_ipr_cmnd(ipr_cmd);
5718 ipr_cmd->job_step_failed = ipr_reset_cmd_failed;
5719 rc = ipr_cmd->job_step(ipr_cmd);
5720 } while(rc == IPR_RC_JOB_CONTINUE);
5724 * _ipr_initiate_ioa_reset - Initiate an adapter reset
5725 * @ioa_cfg: ioa config struct
5726 * @job_step: first job step of reset job
5727 * @shutdown_type: shutdown type
5729 * Description: This function will initiate the reset of the given adapter
5730 * starting at the selected job step.
5731 * If the caller needs to wait on the completion of the reset,
5732 * the caller must sleep on the reset_wait_q.
5737 static void _ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
5738 int (*job_step) (struct ipr_cmnd *),
5739 enum ipr_shutdown_type shutdown_type)
5741 struct ipr_cmnd *ipr_cmd;
5743 ioa_cfg->in_reset_reload = 1;
5744 ioa_cfg->allow_cmds = 0;
5745 scsi_block_requests(ioa_cfg->host);
5747 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5748 ioa_cfg->reset_cmd = ipr_cmd;
5749 ipr_cmd->job_step = job_step;
5750 ipr_cmd->u.shutdown_type = shutdown_type;
5752 ipr_reset_ioa_job(ipr_cmd);
5756 * ipr_initiate_ioa_reset - Initiate an adapter reset
5757 * @ioa_cfg: ioa config struct
5758 * @shutdown_type: shutdown type
5760 * Description: This function will initiate the reset of the given adapter.
5761 * If the caller needs to wait on the completion of the reset,
5762 * the caller must sleep on the reset_wait_q.
5767 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
5768 enum ipr_shutdown_type shutdown_type)
5770 if (ioa_cfg->ioa_is_dead)
5773 if (ioa_cfg->in_reset_reload && ioa_cfg->sdt_state == GET_DUMP)
5774 ioa_cfg->sdt_state = ABORT_DUMP;
5776 if (ioa_cfg->reset_retries++ >= IPR_NUM_RESET_RELOAD_RETRIES) {
5777 dev_err(&ioa_cfg->pdev->dev,
5778 "IOA taken offline - error recovery failed\n");
5780 ioa_cfg->reset_retries = 0;
5781 ioa_cfg->ioa_is_dead = 1;
5783 if (ioa_cfg->in_ioa_bringdown) {
5784 ioa_cfg->reset_cmd = NULL;
5785 ioa_cfg->in_reset_reload = 0;
5786 ipr_fail_all_ops(ioa_cfg);
5787 wake_up_all(&ioa_cfg->reset_wait_q);
5789 spin_unlock_irq(ioa_cfg->host->host_lock);
5790 scsi_unblock_requests(ioa_cfg->host);
5791 spin_lock_irq(ioa_cfg->host->host_lock);
5794 ioa_cfg->in_ioa_bringdown = 1;
5795 shutdown_type = IPR_SHUTDOWN_NONE;
5799 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_shutdown_ioa,
5804 * ipr_reset_freeze - Hold off all I/O activity
5805 * @ipr_cmd: ipr command struct
5807 * Description: If the PCI slot is frozen, hold off all I/O
5808 * activity; then, as soon as the slot is available again,
5809 * initiate an adapter reset.
5811 static int ipr_reset_freeze(struct ipr_cmnd *ipr_cmd)
5813 /* Disallow new interrupts, avoid loop */
5814 ipr_cmd->ioa_cfg->allow_interrupts = 0;
5815 list_add_tail(&ipr_cmd->queue, &ipr_cmd->ioa_cfg->pending_q);
5816 ipr_cmd->done = ipr_reset_ioa_job;
5817 return IPR_RC_JOB_RETURN;
5821 * ipr_pci_frozen - Called when slot has experienced a PCI bus error.
5822 * @pdev: PCI device struct
5824 * Description: This routine is called to tell us that the PCI bus
5825 * is down. Can't do anything here, except put the device driver
5826 * into a holding pattern, waiting for the PCI bus to come back.
5828 static void ipr_pci_frozen(struct pci_dev *pdev)
5830 unsigned long flags = 0;
5831 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
5833 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
5834 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_freeze, IPR_SHUTDOWN_NONE);
5835 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
5839 * ipr_pci_slot_reset - Called when PCI slot has been reset.
5840 * @pdev: PCI device struct
5842 * Description: This routine is called by the pci error recovery
5843 * code after the PCI slot has been reset, just before we
5844 * should resume normal operations.
5846 static pci_ers_result_t ipr_pci_slot_reset(struct pci_dev *pdev)
5848 unsigned long flags = 0;
5849 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
5851 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
5852 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_restore_cfg_space,
5854 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
5855 return PCI_ERS_RESULT_RECOVERED;
5859 * ipr_pci_perm_failure - Called when PCI slot is dead for good.
5860 * @pdev: PCI device struct
5862 * Description: This routine is called when the PCI bus has
5863 * permanently failed.
5865 static void ipr_pci_perm_failure(struct pci_dev *pdev)
5867 unsigned long flags = 0;
5868 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
5870 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
5871 if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
5872 ioa_cfg->sdt_state = ABORT_DUMP;
5873 ioa_cfg->reset_retries = IPR_NUM_RESET_RELOAD_RETRIES;
5874 ioa_cfg->in_ioa_bringdown = 1;
5875 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5876 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
5880 * ipr_pci_error_detected - Called when a PCI error is detected.
5881 * @pdev: PCI device struct
5882 * @state: PCI channel state
5884 * Description: Called when a PCI error is detected.
5887 * PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
5889 static pci_ers_result_t ipr_pci_error_detected(struct pci_dev *pdev,
5890 pci_channel_state_t state)
5893 case pci_channel_io_frozen:
5894 ipr_pci_frozen(pdev);
5895 return PCI_ERS_RESULT_NEED_RESET;
5896 case pci_channel_io_perm_failure:
5897 ipr_pci_perm_failure(pdev);
5898 return PCI_ERS_RESULT_DISCONNECT;
5903 return PCI_ERS_RESULT_NEED_RESET;
5907 * ipr_probe_ioa_part2 - Initializes IOAs found in ipr_probe_ioa(..)
5908 * @ioa_cfg: ioa cfg struct
5910 * Description: This is the second phase of adapter intialization
5911 * This function takes care of initilizing the adapter to the point
5912 * where it can accept new commands.
5915 * 0 on sucess / -EIO on failure
5917 static int __devinit ipr_probe_ioa_part2(struct ipr_ioa_cfg *ioa_cfg)
5920 unsigned long host_lock_flags = 0;
5923 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
5924 dev_dbg(&ioa_cfg->pdev->dev, "ioa_cfg adx: 0x%p\n", ioa_cfg);
5925 if (ioa_cfg->needs_hard_reset) {
5926 ioa_cfg->needs_hard_reset = 0;
5927 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5929 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa,
5932 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
5933 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5934 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
5936 if (ioa_cfg->ioa_is_dead) {
5938 } else if (ipr_invalid_adapter(ioa_cfg)) {
5942 dev_err(&ioa_cfg->pdev->dev,
5943 "Adapter not supported in this hardware configuration.\n");
5946 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
5953 * ipr_free_cmd_blks - Frees command blocks allocated for an adapter
5954 * @ioa_cfg: ioa config struct
5959 static void ipr_free_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
5963 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
5964 if (ioa_cfg->ipr_cmnd_list[i])
5965 pci_pool_free(ioa_cfg->ipr_cmd_pool,
5966 ioa_cfg->ipr_cmnd_list[i],
5967 ioa_cfg->ipr_cmnd_list_dma[i]);
5969 ioa_cfg->ipr_cmnd_list[i] = NULL;
5972 if (ioa_cfg->ipr_cmd_pool)
5973 pci_pool_destroy (ioa_cfg->ipr_cmd_pool);
5975 ioa_cfg->ipr_cmd_pool = NULL;
5979 * ipr_free_mem - Frees memory allocated for an adapter
5980 * @ioa_cfg: ioa cfg struct
5985 static void ipr_free_mem(struct ipr_ioa_cfg *ioa_cfg)
5989 kfree(ioa_cfg->res_entries);
5990 pci_free_consistent(ioa_cfg->pdev, sizeof(struct ipr_misc_cbs),
5991 ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
5992 ipr_free_cmd_blks(ioa_cfg);
5993 pci_free_consistent(ioa_cfg->pdev, sizeof(u32) * IPR_NUM_CMD_BLKS,
5994 ioa_cfg->host_rrq, ioa_cfg->host_rrq_dma);
5995 pci_free_consistent(ioa_cfg->pdev, sizeof(struct ipr_config_table),
5997 ioa_cfg->cfg_table_dma);
5999 for (i = 0; i < IPR_NUM_HCAMS; i++) {
6000 pci_free_consistent(ioa_cfg->pdev,
6001 sizeof(struct ipr_hostrcb),
6002 ioa_cfg->hostrcb[i],
6003 ioa_cfg->hostrcb_dma[i]);
6006 ipr_free_dump(ioa_cfg);
6007 kfree(ioa_cfg->trace);
6011 * ipr_free_all_resources - Free all allocated resources for an adapter.
6012 * @ipr_cmd: ipr command struct
6014 * This function frees all allocated resources for the
6015 * specified adapter.
6020 static void ipr_free_all_resources(struct ipr_ioa_cfg *ioa_cfg)
6022 struct pci_dev *pdev = ioa_cfg->pdev;
6025 free_irq(pdev->irq, ioa_cfg);
6026 iounmap(ioa_cfg->hdw_dma_regs);
6027 pci_release_regions(pdev);
6028 ipr_free_mem(ioa_cfg);
6029 scsi_host_put(ioa_cfg->host);
6030 pci_disable_device(pdev);
6035 * ipr_alloc_cmd_blks - Allocate command blocks for an adapter
6036 * @ioa_cfg: ioa config struct
6039 * 0 on success / -ENOMEM on allocation failure
6041 static int __devinit ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
6043 struct ipr_cmnd *ipr_cmd;
6044 struct ipr_ioarcb *ioarcb;
6045 dma_addr_t dma_addr;
6048 ioa_cfg->ipr_cmd_pool = pci_pool_create (IPR_NAME, ioa_cfg->pdev,
6049 sizeof(struct ipr_cmnd), 8, 0);
6051 if (!ioa_cfg->ipr_cmd_pool)
6054 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
6055 ipr_cmd = pci_pool_alloc (ioa_cfg->ipr_cmd_pool, SLAB_KERNEL, &dma_addr);
6058 ipr_free_cmd_blks(ioa_cfg);
6062 memset(ipr_cmd, 0, sizeof(*ipr_cmd));
6063 ioa_cfg->ipr_cmnd_list[i] = ipr_cmd;
6064 ioa_cfg->ipr_cmnd_list_dma[i] = dma_addr;
6066 ioarcb = &ipr_cmd->ioarcb;
6067 ioarcb->ioarcb_host_pci_addr = cpu_to_be32(dma_addr);
6068 ioarcb->host_response_handle = cpu_to_be32(i << 2);
6069 ioarcb->write_ioadl_addr =
6070 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioadl));
6071 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
6072 ioarcb->ioasa_host_pci_addr =
6073 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioasa));
6074 ioarcb->ioasa_len = cpu_to_be16(sizeof(struct ipr_ioasa));
6075 ipr_cmd->cmd_index = i;
6076 ipr_cmd->ioa_cfg = ioa_cfg;
6077 ipr_cmd->sense_buffer_dma = dma_addr +
6078 offsetof(struct ipr_cmnd, sense_buffer);
6080 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
6087 * ipr_alloc_mem - Allocate memory for an adapter
6088 * @ioa_cfg: ioa config struct
6091 * 0 on success / non-zero for error
6093 static int __devinit ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
6095 struct pci_dev *pdev = ioa_cfg->pdev;
6096 int i, rc = -ENOMEM;
6099 ioa_cfg->res_entries = kzalloc(sizeof(struct ipr_resource_entry) *
6100 IPR_MAX_PHYSICAL_DEVS, GFP_KERNEL);
6102 if (!ioa_cfg->res_entries)
6105 for (i = 0; i < IPR_MAX_PHYSICAL_DEVS; i++)
6106 list_add_tail(&ioa_cfg->res_entries[i].queue, &ioa_cfg->free_res_q);
6108 ioa_cfg->vpd_cbs = pci_alloc_consistent(ioa_cfg->pdev,
6109 sizeof(struct ipr_misc_cbs),
6110 &ioa_cfg->vpd_cbs_dma);
6112 if (!ioa_cfg->vpd_cbs)
6113 goto out_free_res_entries;
6115 if (ipr_alloc_cmd_blks(ioa_cfg))
6116 goto out_free_vpd_cbs;
6118 ioa_cfg->host_rrq = pci_alloc_consistent(ioa_cfg->pdev,
6119 sizeof(u32) * IPR_NUM_CMD_BLKS,
6120 &ioa_cfg->host_rrq_dma);
6122 if (!ioa_cfg->host_rrq)
6123 goto out_ipr_free_cmd_blocks;
6125 ioa_cfg->cfg_table = pci_alloc_consistent(ioa_cfg->pdev,
6126 sizeof(struct ipr_config_table),
6127 &ioa_cfg->cfg_table_dma);
6129 if (!ioa_cfg->cfg_table)
6130 goto out_free_host_rrq;
6132 for (i = 0; i < IPR_NUM_HCAMS; i++) {
6133 ioa_cfg->hostrcb[i] = pci_alloc_consistent(ioa_cfg->pdev,
6134 sizeof(struct ipr_hostrcb),
6135 &ioa_cfg->hostrcb_dma[i]);
6137 if (!ioa_cfg->hostrcb[i])
6138 goto out_free_hostrcb_dma;
6140 ioa_cfg->hostrcb[i]->hostrcb_dma =
6141 ioa_cfg->hostrcb_dma[i] + offsetof(struct ipr_hostrcb, hcam);
6142 list_add_tail(&ioa_cfg->hostrcb[i]->queue, &ioa_cfg->hostrcb_free_q);
6145 ioa_cfg->trace = kzalloc(sizeof(struct ipr_trace_entry) *
6146 IPR_NUM_TRACE_ENTRIES, GFP_KERNEL);
6148 if (!ioa_cfg->trace)
6149 goto out_free_hostrcb_dma;
6156 out_free_hostrcb_dma:
6158 pci_free_consistent(pdev, sizeof(struct ipr_hostrcb),
6159 ioa_cfg->hostrcb[i],
6160 ioa_cfg->hostrcb_dma[i]);
6162 pci_free_consistent(pdev, sizeof(struct ipr_config_table),
6163 ioa_cfg->cfg_table, ioa_cfg->cfg_table_dma);
6165 pci_free_consistent(pdev, sizeof(u32) * IPR_NUM_CMD_BLKS,
6166 ioa_cfg->host_rrq, ioa_cfg->host_rrq_dma);
6167 out_ipr_free_cmd_blocks:
6168 ipr_free_cmd_blks(ioa_cfg);
6170 pci_free_consistent(pdev, sizeof(struct ipr_misc_cbs),
6171 ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
6172 out_free_res_entries:
6173 kfree(ioa_cfg->res_entries);
6178 * ipr_initialize_bus_attr - Initialize SCSI bus attributes to default values
6179 * @ioa_cfg: ioa config struct
6184 static void __devinit ipr_initialize_bus_attr(struct ipr_ioa_cfg *ioa_cfg)
6188 for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
6189 ioa_cfg->bus_attr[i].bus = i;
6190 ioa_cfg->bus_attr[i].qas_enabled = 0;
6191 ioa_cfg->bus_attr[i].bus_width = IPR_DEFAULT_BUS_WIDTH;
6192 if (ipr_max_speed < ARRAY_SIZE(ipr_max_bus_speeds))
6193 ioa_cfg->bus_attr[i].max_xfer_rate = ipr_max_bus_speeds[ipr_max_speed];
6195 ioa_cfg->bus_attr[i].max_xfer_rate = IPR_U160_SCSI_RATE;
6200 * ipr_init_ioa_cfg - Initialize IOA config struct
6201 * @ioa_cfg: ioa config struct
6202 * @host: scsi host struct
6203 * @pdev: PCI dev struct
6208 static void __devinit ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg,
6209 struct Scsi_Host *host, struct pci_dev *pdev)
6211 const struct ipr_interrupt_offsets *p;
6212 struct ipr_interrupts *t;
6215 ioa_cfg->host = host;
6216 ioa_cfg->pdev = pdev;
6217 ioa_cfg->log_level = ipr_log_level;
6218 ioa_cfg->doorbell = IPR_DOORBELL;
6219 if (!ipr_auto_create)
6220 ioa_cfg->doorbell |= IPR_RUNTIME_RESET;
6221 sprintf(ioa_cfg->eye_catcher, IPR_EYECATCHER);
6222 sprintf(ioa_cfg->trace_start, IPR_TRACE_START_LABEL);
6223 sprintf(ioa_cfg->ipr_free_label, IPR_FREEQ_LABEL);
6224 sprintf(ioa_cfg->ipr_pending_label, IPR_PENDQ_LABEL);
6225 sprintf(ioa_cfg->cfg_table_start, IPR_CFG_TBL_START);
6226 sprintf(ioa_cfg->resource_table_label, IPR_RES_TABLE_LABEL);
6227 sprintf(ioa_cfg->ipr_hcam_label, IPR_HCAM_LABEL);
6228 sprintf(ioa_cfg->ipr_cmd_label, IPR_CMD_LABEL);
6230 INIT_LIST_HEAD(&ioa_cfg->free_q);
6231 INIT_LIST_HEAD(&ioa_cfg->pending_q);
6232 INIT_LIST_HEAD(&ioa_cfg->hostrcb_free_q);
6233 INIT_LIST_HEAD(&ioa_cfg->hostrcb_pending_q);
6234 INIT_LIST_HEAD(&ioa_cfg->free_res_q);
6235 INIT_LIST_HEAD(&ioa_cfg->used_res_q);
6236 INIT_WORK(&ioa_cfg->work_q, ipr_worker_thread, ioa_cfg);
6237 init_waitqueue_head(&ioa_cfg->reset_wait_q);
6238 ioa_cfg->sdt_state = INACTIVE;
6239 if (ipr_enable_cache)
6240 ioa_cfg->cache_state = CACHE_ENABLED;
6242 ioa_cfg->cache_state = CACHE_DISABLED;
6244 ipr_initialize_bus_attr(ioa_cfg);
6246 host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS;
6247 host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET;
6248 host->max_channel = IPR_MAX_BUS_TO_SCAN;
6249 host->unique_id = host->host_no;
6250 host->max_cmd_len = IPR_MAX_CDB_LEN;
6251 pci_set_drvdata(pdev, ioa_cfg);
6253 p = &ioa_cfg->chip_cfg->regs;
6255 base = ioa_cfg->hdw_dma_regs;
6257 t->set_interrupt_mask_reg = base + p->set_interrupt_mask_reg;
6258 t->clr_interrupt_mask_reg = base + p->clr_interrupt_mask_reg;
6259 t->sense_interrupt_mask_reg = base + p->sense_interrupt_mask_reg;
6260 t->clr_interrupt_reg = base + p->clr_interrupt_reg;
6261 t->sense_interrupt_reg = base + p->sense_interrupt_reg;
6262 t->ioarrin_reg = base + p->ioarrin_reg;
6263 t->sense_uproc_interrupt_reg = base + p->sense_uproc_interrupt_reg;
6264 t->set_uproc_interrupt_reg = base + p->set_uproc_interrupt_reg;
6265 t->clr_uproc_interrupt_reg = base + p->clr_uproc_interrupt_reg;
6269 * ipr_get_chip_cfg - Find adapter chip configuration
6270 * @dev_id: PCI device id struct
6273 * ptr to chip config on success / NULL on failure
6275 static const struct ipr_chip_cfg_t * __devinit
6276 ipr_get_chip_cfg(const struct pci_device_id *dev_id)
6280 if (dev_id->driver_data)
6281 return (const struct ipr_chip_cfg_t *)dev_id->driver_data;
6283 for (i = 0; i < ARRAY_SIZE(ipr_chip); i++)
6284 if (ipr_chip[i].vendor == dev_id->vendor &&
6285 ipr_chip[i].device == dev_id->device)
6286 return ipr_chip[i].cfg;
6291 * ipr_probe_ioa - Allocates memory and does first stage of initialization
6292 * @pdev: PCI device struct
6293 * @dev_id: PCI device id struct
6296 * 0 on success / non-zero on failure
6298 static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
6299 const struct pci_device_id *dev_id)
6301 struct ipr_ioa_cfg *ioa_cfg;
6302 struct Scsi_Host *host;
6303 unsigned long ipr_regs_pci;
6304 void __iomem *ipr_regs;
6305 u32 rc = PCIBIOS_SUCCESSFUL;
6306 volatile u32 mask, uproc;
6310 if ((rc = pci_enable_device(pdev))) {
6311 dev_err(&pdev->dev, "Cannot enable adapter\n");
6315 dev_info(&pdev->dev, "Found IOA with IRQ: %d\n", pdev->irq);
6317 host = scsi_host_alloc(&driver_template, sizeof(*ioa_cfg));
6320 dev_err(&pdev->dev, "call to scsi_host_alloc failed!\n");
6325 ioa_cfg = (struct ipr_ioa_cfg *)host->hostdata;
6326 memset(ioa_cfg, 0, sizeof(struct ipr_ioa_cfg));
6328 ioa_cfg->chip_cfg = ipr_get_chip_cfg(dev_id);
6330 if (!ioa_cfg->chip_cfg) {
6331 dev_err(&pdev->dev, "Unknown adapter chipset 0x%04X 0x%04X\n",
6332 dev_id->vendor, dev_id->device);
6333 goto out_scsi_host_put;
6336 ipr_regs_pci = pci_resource_start(pdev, 0);
6338 rc = pci_request_regions(pdev, IPR_NAME);
6341 "Couldn't register memory range of registers\n");
6342 goto out_scsi_host_put;
6345 ipr_regs = ioremap(ipr_regs_pci, pci_resource_len(pdev, 0));
6349 "Couldn't map memory range of registers\n");
6351 goto out_release_regions;
6354 ioa_cfg->hdw_dma_regs = ipr_regs;
6355 ioa_cfg->hdw_dma_regs_pci = ipr_regs_pci;
6356 ioa_cfg->ioa_mailbox = ioa_cfg->chip_cfg->mailbox + ipr_regs;
6358 ipr_init_ioa_cfg(ioa_cfg, host, pdev);
6360 pci_set_master(pdev);
6362 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
6364 dev_err(&pdev->dev, "Failed to set PCI DMA mask\n");
6368 rc = pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
6369 ioa_cfg->chip_cfg->cache_line_size);
6371 if (rc != PCIBIOS_SUCCESSFUL) {
6372 dev_err(&pdev->dev, "Write of cache line size failed\n");
6377 /* Save away PCI config space for use following IOA reset */
6378 rc = pci_save_state(pdev);
6380 if (rc != PCIBIOS_SUCCESSFUL) {
6381 dev_err(&pdev->dev, "Failed to save PCI config space\n");
6386 if ((rc = ipr_save_pcix_cmd_reg(ioa_cfg)))
6389 if ((rc = ipr_set_pcix_cmd_reg(ioa_cfg)))
6392 rc = ipr_alloc_mem(ioa_cfg);
6395 "Couldn't allocate enough memory for device driver!\n");
6400 * If HRRQ updated interrupt is not masked, or reset alert is set,
6401 * the card is in an unknown state and needs a hard reset
6403 mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
6404 uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg);
6405 if ((mask & IPR_PCII_HRRQ_UPDATED) == 0 || (uproc & IPR_UPROCI_RESET_ALERT))
6406 ioa_cfg->needs_hard_reset = 1;
6408 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
6409 rc = request_irq(pdev->irq, ipr_isr, SA_SHIRQ, IPR_NAME, ioa_cfg);
6412 dev_err(&pdev->dev, "Couldn't register IRQ %d! rc=%d\n",
6417 spin_lock(&ipr_driver_lock);
6418 list_add_tail(&ioa_cfg->queue, &ipr_ioa_head);
6419 spin_unlock(&ipr_driver_lock);
6426 ipr_free_mem(ioa_cfg);
6429 out_release_regions:
6430 pci_release_regions(pdev);
6432 scsi_host_put(host);
6434 pci_disable_device(pdev);
6439 * ipr_scan_vsets - Scans for VSET devices
6440 * @ioa_cfg: ioa config struct
6442 * Description: Since the VSET resources do not follow SAM in that we can have
6443 * sparse LUNs with no LUN 0, we have to scan for these ourselves.
6448 static void ipr_scan_vsets(struct ipr_ioa_cfg *ioa_cfg)
6452 for (target = 0; target < IPR_MAX_NUM_TARGETS_PER_BUS; target++)
6453 for (lun = 0; lun < IPR_MAX_NUM_VSET_LUNS_PER_TARGET; lun++ )
6454 scsi_add_device(ioa_cfg->host, IPR_VSET_BUS, target, lun);
6458 * ipr_initiate_ioa_bringdown - Bring down an adapter
6459 * @ioa_cfg: ioa config struct
6460 * @shutdown_type: shutdown type
6462 * Description: This function will initiate bringing down the adapter.
6463 * This consists of issuing an IOA shutdown to the adapter
6464 * to flush the cache, and running BIST.
6465 * If the caller needs to wait on the completion of the reset,
6466 * the caller must sleep on the reset_wait_q.
6471 static void ipr_initiate_ioa_bringdown(struct ipr_ioa_cfg *ioa_cfg,
6472 enum ipr_shutdown_type shutdown_type)
6475 if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
6476 ioa_cfg->sdt_state = ABORT_DUMP;
6477 ioa_cfg->reset_retries = 0;
6478 ioa_cfg->in_ioa_bringdown = 1;
6479 ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
6484 * __ipr_remove - Remove a single adapter
6485 * @pdev: pci device struct
6487 * Adapter hot plug remove entry point.
6492 static void __ipr_remove(struct pci_dev *pdev)
6494 unsigned long host_lock_flags = 0;
6495 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
6498 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
6499 ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
6501 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
6502 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
6503 flush_scheduled_work();
6504 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
6506 spin_lock(&ipr_driver_lock);
6507 list_del(&ioa_cfg->queue);
6508 spin_unlock(&ipr_driver_lock);
6510 if (ioa_cfg->sdt_state == ABORT_DUMP)
6511 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
6512 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
6514 ipr_free_all_resources(ioa_cfg);
6520 * ipr_remove - IOA hot plug remove entry point
6521 * @pdev: pci device struct
6523 * Adapter hot plug remove entry point.
6528 static void ipr_remove(struct pci_dev *pdev)
6530 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
6534 ipr_remove_trace_file(&ioa_cfg->host->shost_classdev.kobj,
6536 ipr_remove_dump_file(&ioa_cfg->host->shost_classdev.kobj,
6538 scsi_remove_host(ioa_cfg->host);
6546 * ipr_probe - Adapter hot plug add entry point
6549 * 0 on success / non-zero on failure
6551 static int __devinit ipr_probe(struct pci_dev *pdev,
6552 const struct pci_device_id *dev_id)
6554 struct ipr_ioa_cfg *ioa_cfg;
6557 rc = ipr_probe_ioa(pdev, dev_id);
6562 ioa_cfg = pci_get_drvdata(pdev);
6563 rc = ipr_probe_ioa_part2(ioa_cfg);
6570 rc = scsi_add_host(ioa_cfg->host, &pdev->dev);
6577 rc = ipr_create_trace_file(&ioa_cfg->host->shost_classdev.kobj,
6581 scsi_remove_host(ioa_cfg->host);
6586 rc = ipr_create_dump_file(&ioa_cfg->host->shost_classdev.kobj,
6590 ipr_remove_trace_file(&ioa_cfg->host->shost_classdev.kobj,
6592 scsi_remove_host(ioa_cfg->host);
6597 scsi_scan_host(ioa_cfg->host);
6598 ipr_scan_vsets(ioa_cfg);
6599 scsi_add_device(ioa_cfg->host, IPR_IOA_BUS, IPR_IOA_TARGET, IPR_IOA_LUN);
6600 ioa_cfg->allow_ml_add_del = 1;
6601 ioa_cfg->host->max_channel = IPR_VSET_BUS;
6602 schedule_work(&ioa_cfg->work_q);
6607 * ipr_shutdown - Shutdown handler.
6608 * @pdev: pci device struct
6610 * This function is invoked upon system shutdown/reboot. It will issue
6611 * an adapter shutdown to the adapter to flush the write cache.
6616 static void ipr_shutdown(struct pci_dev *pdev)
6618 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
6619 unsigned long lock_flags = 0;
6621 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
6622 ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
6623 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
6624 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
6627 static struct pci_device_id ipr_pci_table[] __devinitdata = {
6628 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
6629 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5702,
6630 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6631 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
6632 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5703,
6633 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6634 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
6635 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573D,
6636 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6637 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
6638 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573E,
6639 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6640 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
6641 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571B,
6642 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6643 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
6644 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572E,
6645 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6646 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
6647 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571A,
6648 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6649 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
6650 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575B,
6651 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6652 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
6653 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A,
6654 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6655 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
6656 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B,
6657 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6658 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
6659 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A,
6660 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6661 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
6662 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B,
6663 0, 0, (kernel_ulong_t)&ipr_chip_cfg[0] },
6664 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE,
6665 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2780,
6666 0, 0, (kernel_ulong_t)&ipr_chip_cfg[1] },
6667 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
6668 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571E,
6669 0, 0, (kernel_ulong_t)&ipr_chip_cfg[1] },
6670 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
6671 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571F,
6672 0, 0, (kernel_ulong_t)&ipr_chip_cfg[1] },
6675 MODULE_DEVICE_TABLE(pci, ipr_pci_table);
6677 static struct pci_error_handlers ipr_err_handler = {
6678 .error_detected = ipr_pci_error_detected,
6679 .slot_reset = ipr_pci_slot_reset,
6682 static struct pci_driver ipr_driver = {
6684 .id_table = ipr_pci_table,
6686 .remove = ipr_remove,
6687 .shutdown = ipr_shutdown,
6688 .err_handler = &ipr_err_handler,
6692 * ipr_init - Module entry point
6695 * 0 on success / negative value on failure
6697 static int __init ipr_init(void)
6699 ipr_info("IBM Power RAID SCSI Device Driver version: %s %s\n",
6700 IPR_DRIVER_VERSION, IPR_DRIVER_DATE);
6702 return pci_module_init(&ipr_driver);
6706 * ipr_exit - Module unload
6708 * Module unload entry point.
6713 static void __exit ipr_exit(void)
6715 pci_unregister_driver(&ipr_driver);
6718 module_init(ipr_init);
6719 module_exit(ipr_exit);