brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * pmcraid.c -- driver for PMC Sierra MaxRAID controller adapters4 *5 * Written By: Anil Ravindranath<anil_ravindranath@pmc-sierra.com>6 *             PMC-Sierra Inc7 *8 * Copyright (C) 2008, 2009 PMC Sierra Inc9 */10#include <linux/fs.h>11#include <linux/init.h>12#include <linux/types.h>13#include <linux/errno.h>14#include <linux/kernel.h>15#include <linux/ioport.h>16#include <linux/delay.h>17#include <linux/pci.h>18#include <linux/wait.h>19#include <linux/spinlock.h>20#include <linux/sched.h>21#include <linux/interrupt.h>22#include <linux/blkdev.h>23#include <linux/firmware.h>24#include <linux/module.h>25#include <linux/moduleparam.h>26#include <linux/hdreg.h>27#include <linux/io.h>28#include <linux/slab.h>29#include <asm/irq.h>30#include <asm/processor.h>31#include <linux/libata.h>32#include <linux/mutex.h>33#include <linux/ktime.h>34#include <scsi/scsi.h>35#include <scsi/scsi_host.h>36#include <scsi/scsi_device.h>37#include <scsi/scsi_tcq.h>38#include <scsi/scsi_eh.h>39#include <scsi/scsi_cmnd.h>40#include <scsi/scsicam.h>41 42#include "pmcraid.h"43 44/*45 *   Module configuration parameters46 */47static unsigned int pmcraid_debug_log;48static unsigned int pmcraid_disable_aen;49static unsigned int pmcraid_log_level = IOASC_LOG_LEVEL_MUST;50static unsigned int pmcraid_enable_msix;51 52/*53 * Data structures to support multiple adapters by the LLD.54 * pmcraid_adapter_count - count of configured adapters55 */56static atomic_t pmcraid_adapter_count = ATOMIC_INIT(0);57 58/*59 * Supporting user-level control interface through IOCTL commands.60 * pmcraid_major - major number to use61 * pmcraid_minor - minor number(s) to use62 */63static unsigned int pmcraid_major;64static const struct class pmcraid_class = {65	.name = PMCRAID_DEVFILE,66};67static DECLARE_BITMAP(pmcraid_minor, PMCRAID_MAX_ADAPTERS);68 69/*70 * Module parameters71 */72MODULE_AUTHOR("Anil Ravindranath<anil_ravindranath@pmc-sierra.com>");73MODULE_DESCRIPTION("PMC Sierra MaxRAID Controller Driver");74MODULE_LICENSE("GPL");75MODULE_VERSION(PMCRAID_DRIVER_VERSION);76 77module_param_named(log_level, pmcraid_log_level, uint, (S_IRUGO | S_IWUSR));78MODULE_PARM_DESC(log_level,79		 "Enables firmware error code logging, default :1 high-severity"80		 " errors, 2: all errors including high-severity errors,"81		 " 0: disables logging");82 83module_param_named(debug, pmcraid_debug_log, uint, (S_IRUGO | S_IWUSR));84MODULE_PARM_DESC(debug,85		 "Enable driver verbose message logging. Set 1 to enable."86		 "(default: 0)");87 88module_param_named(disable_aen, pmcraid_disable_aen, uint, (S_IRUGO | S_IWUSR));89MODULE_PARM_DESC(disable_aen,90		 "Disable driver aen notifications to apps. Set 1 to disable."91		 "(default: 0)");92 93/* chip specific constants for PMC MaxRAID controllers (same for94 * 0x5220 and 0x801095 */96static struct pmcraid_chip_details pmcraid_chip_cfg[] = {97	{98	 .ioastatus = 0x0,99	 .ioarrin = 0x00040,100	 .mailbox = 0x7FC30,101	 .global_intr_mask = 0x00034,102	 .ioa_host_intr = 0x0009C,103	 .ioa_host_intr_clr = 0x000A0,104	 .ioa_host_msix_intr = 0x7FC40,105	 .ioa_host_mask = 0x7FC28,106	 .ioa_host_mask_clr = 0x7FC28,107	 .host_ioa_intr = 0x00020,108	 .host_ioa_intr_clr = 0x00020,109	 .transop_timeout = 300110	 }111};112 113/*114 * PCI device ids supported by pmcraid driver115 */116static struct pci_device_id pmcraid_pci_table[] = {117	{ PCI_DEVICE(PCI_VENDOR_ID_PMC, PCI_DEVICE_ID_PMC_MAXRAID),118	  0, 0, (kernel_ulong_t)&pmcraid_chip_cfg[0]119	},120	{}121};122 123MODULE_DEVICE_TABLE(pci, pmcraid_pci_table);124 125 126 127/**128 * pmcraid_slave_alloc - Prepare for commands to a device129 * @scsi_dev: scsi device struct130 *131 * This function is called by mid-layer prior to sending any command to the new132 * device. Stores resource entry details of the device in scsi_device struct.133 * Queuecommand uses the resource handle and other details to fill up IOARCB134 * while sending commands to the device.135 *136 * Return value:137 *	  0 on success / -ENXIO if device does not exist138 */139static int pmcraid_slave_alloc(struct scsi_device *scsi_dev)140{141	struct pmcraid_resource_entry *temp, *res = NULL;142	struct pmcraid_instance *pinstance;143	u8 target, bus, lun;144	unsigned long lock_flags;145	int rc = -ENXIO;146	u16 fw_version;147 148	pinstance = shost_priv(scsi_dev->host);149 150	fw_version = be16_to_cpu(pinstance->inq_data->fw_version);151 152	/* Driver exposes VSET and GSCSI resources only; all other device types153	 * are not exposed. Resource list is synchronized using resource lock154	 * so any traversal or modifications to the list should be done inside155	 * this lock156	 */157	spin_lock_irqsave(&pinstance->resource_lock, lock_flags);158	list_for_each_entry(temp, &pinstance->used_res_q, queue) {159 160		/* do not expose VSETs with order-ids > MAX_VSET_TARGETS */161		if (RES_IS_VSET(temp->cfg_entry)) {162			if (fw_version <= PMCRAID_FW_VERSION_1)163				target = temp->cfg_entry.unique_flags1;164			else165				target = le16_to_cpu(temp->cfg_entry.array_id) & 0xFF;166 167			if (target > PMCRAID_MAX_VSET_TARGETS)168				continue;169			bus = PMCRAID_VSET_BUS_ID;170			lun = 0;171		} else if (RES_IS_GSCSI(temp->cfg_entry)) {172			target = RES_TARGET(temp->cfg_entry.resource_address);173			bus = PMCRAID_PHYS_BUS_ID;174			lun = RES_LUN(temp->cfg_entry.resource_address);175		} else {176			continue;177		}178 179		if (bus == scsi_dev->channel &&180		    target == scsi_dev->id &&181		    lun == scsi_dev->lun) {182			res = temp;183			break;184		}185	}186 187	if (res) {188		res->scsi_dev = scsi_dev;189		scsi_dev->hostdata = res;190		res->change_detected = 0;191		atomic_set(&res->read_failures, 0);192		atomic_set(&res->write_failures, 0);193		rc = 0;194	}195	spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);196	return rc;197}198 199/**200 * pmcraid_device_configure - Configures a SCSI device201 * @scsi_dev: scsi device struct202 * @lim: queue limits203 *204 * This function is executed by SCSI mid layer just after a device is first205 * scanned (i.e. it has responded to an INQUIRY). For VSET resources, the206 * timeout value (default 30s) will be over-written to a higher value (60s)207 * and max_sectors value will be over-written to 512. It also sets queue depth208 * to host->cmd_per_lun value209 *210 * Return value:211 *	  0 on success212 */213static int pmcraid_device_configure(struct scsi_device *scsi_dev,214		struct queue_limits *lim)215{216	struct pmcraid_resource_entry *res = scsi_dev->hostdata;217 218	if (!res)219		return 0;220 221	/* LLD exposes VSETs and Enclosure devices only */222	if (RES_IS_GSCSI(res->cfg_entry) &&223	    scsi_dev->type != TYPE_ENCLOSURE)224		return -ENXIO;225 226	pmcraid_info("configuring %x:%x:%x:%x\n",227		     scsi_dev->host->unique_id,228		     scsi_dev->channel,229		     scsi_dev->id,230		     (u8)scsi_dev->lun);231 232	if (RES_IS_GSCSI(res->cfg_entry)) {233		scsi_dev->allow_restart = 1;234	} else if (RES_IS_VSET(res->cfg_entry)) {235		scsi_dev->allow_restart = 1;236		blk_queue_rq_timeout(scsi_dev->request_queue,237				     PMCRAID_VSET_IO_TIMEOUT);238		lim->max_hw_sectors = PMCRAID_VSET_MAX_SECTORS;239	}240 241	/*242	 * We never want to report TCQ support for these types of devices.243	 */244	if (!RES_IS_GSCSI(res->cfg_entry) && !RES_IS_VSET(res->cfg_entry))245		scsi_dev->tagged_supported = 0;246 247	return 0;248}249 250/**251 * pmcraid_slave_destroy - Unconfigure a SCSI device before removing it252 *253 * @scsi_dev: scsi device struct254 *255 * This is called by mid-layer before removing a device. Pointer assignments256 * done in pmcraid_slave_alloc will be reset to NULL here.257 *258 * Return value259 *   none260 */261static void pmcraid_slave_destroy(struct scsi_device *scsi_dev)262{263	struct pmcraid_resource_entry *res;264 265	res = (struct pmcraid_resource_entry *)scsi_dev->hostdata;266 267	if (res)268		res->scsi_dev = NULL;269 270	scsi_dev->hostdata = NULL;271}272 273/**274 * pmcraid_change_queue_depth - Change the device's queue depth275 * @scsi_dev: scsi device struct276 * @depth: depth to set277 *278 * Return value279 *	actual depth set280 */281static int pmcraid_change_queue_depth(struct scsi_device *scsi_dev, int depth)282{283	if (depth > PMCRAID_MAX_CMD_PER_LUN)284		depth = PMCRAID_MAX_CMD_PER_LUN;285	return scsi_change_queue_depth(scsi_dev, depth);286}287 288/**289 * pmcraid_init_cmdblk - initializes a command block290 *291 * @cmd: pointer to struct pmcraid_cmd to be initialized292 * @index: if >=0 first time initialization; otherwise reinitialization293 *294 * Return Value295 *	 None296 */297static void pmcraid_init_cmdblk(struct pmcraid_cmd *cmd, int index)298{299	struct pmcraid_ioarcb *ioarcb = &(cmd->ioa_cb->ioarcb);300	dma_addr_t dma_addr = cmd->ioa_cb_bus_addr;301 302	if (index >= 0) {303		/* first time initialization (called from  probe) */304		u32 ioasa_offset =305			offsetof(struct pmcraid_control_block, ioasa);306 307		cmd->index = index;308		ioarcb->response_handle = cpu_to_le32(index << 2);309		ioarcb->ioarcb_bus_addr = cpu_to_le64(dma_addr);310		ioarcb->ioasa_bus_addr = cpu_to_le64(dma_addr + ioasa_offset);311		ioarcb->ioasa_len = cpu_to_le16(sizeof(struct pmcraid_ioasa));312	} else {313		/* re-initialization of various lengths, called once command is314		 * processed by IOA315		 */316		memset(&cmd->ioa_cb->ioarcb.cdb, 0, PMCRAID_MAX_CDB_LEN);317		ioarcb->hrrq_id = 0;318		ioarcb->request_flags0 = 0;319		ioarcb->request_flags1 = 0;320		ioarcb->cmd_timeout = 0;321		ioarcb->ioarcb_bus_addr &= cpu_to_le64(~0x1FULL);322		ioarcb->ioadl_bus_addr = 0;323		ioarcb->ioadl_length = 0;324		ioarcb->data_transfer_length = 0;325		ioarcb->add_cmd_param_length = 0;326		ioarcb->add_cmd_param_offset = 0;327		cmd->ioa_cb->ioasa.ioasc = 0;328		cmd->ioa_cb->ioasa.residual_data_length = 0;329		cmd->time_left = 0;330	}331 332	cmd->cmd_done = NULL;333	cmd->scsi_cmd = NULL;334	cmd->release = 0;335	cmd->completion_req = 0;336	cmd->sense_buffer = NULL;337	cmd->sense_buffer_dma = 0;338	cmd->dma_handle = 0;339	timer_setup(&cmd->timer, NULL, 0);340}341 342/**343 * pmcraid_reinit_cmdblk - reinitialize a command block344 *345 * @cmd: pointer to struct pmcraid_cmd to be reinitialized346 *347 * Return Value348 *	 None349 */350static void pmcraid_reinit_cmdblk(struct pmcraid_cmd *cmd)351{352	pmcraid_init_cmdblk(cmd, -1);353}354 355/**356 * pmcraid_get_free_cmd - get a free cmd block from command block pool357 * @pinstance: adapter instance structure358 *359 * Return Value:360 *	returns pointer to cmd block or NULL if no blocks are available361 */362static struct pmcraid_cmd *pmcraid_get_free_cmd(363	struct pmcraid_instance *pinstance364)365{366	struct pmcraid_cmd *cmd = NULL;367	unsigned long lock_flags;368 369	/* free cmd block list is protected by free_pool_lock */370	spin_lock_irqsave(&pinstance->free_pool_lock, lock_flags);371 372	if (!list_empty(&pinstance->free_cmd_pool)) {373		cmd = list_entry(pinstance->free_cmd_pool.next,374				 struct pmcraid_cmd, free_list);375		list_del(&cmd->free_list);376	}377	spin_unlock_irqrestore(&pinstance->free_pool_lock, lock_flags);378 379	/* Initialize the command block before giving it the caller */380	if (cmd != NULL)381		pmcraid_reinit_cmdblk(cmd);382	return cmd;383}384 385/**386 * pmcraid_return_cmd - return a completed command block back into free pool387 * @cmd: pointer to the command block388 *389 * Return Value:390 *	nothing391 */392static void pmcraid_return_cmd(struct pmcraid_cmd *cmd)393{394	struct pmcraid_instance *pinstance = cmd->drv_inst;395	unsigned long lock_flags;396 397	spin_lock_irqsave(&pinstance->free_pool_lock, lock_flags);398	list_add_tail(&cmd->free_list, &pinstance->free_cmd_pool);399	spin_unlock_irqrestore(&pinstance->free_pool_lock, lock_flags);400}401 402/**403 * pmcraid_read_interrupts -  reads IOA interrupts404 *405 * @pinstance: pointer to adapter instance structure406 *407 * Return value408 *	 interrupts read from IOA409 */410static u32 pmcraid_read_interrupts(struct pmcraid_instance *pinstance)411{412	return (pinstance->interrupt_mode) ?413		ioread32(pinstance->int_regs.ioa_host_msix_interrupt_reg) :414		ioread32(pinstance->int_regs.ioa_host_interrupt_reg);415}416 417/**418 * pmcraid_disable_interrupts - Masks and clears all specified interrupts419 *420 * @pinstance: pointer to per adapter instance structure421 * @intrs: interrupts to disable422 *423 * Return Value424 *	 None425 */426static void pmcraid_disable_interrupts(427	struct pmcraid_instance *pinstance,428	u32 intrs429)430{431	u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg);432	u32 nmask = gmask | GLOBAL_INTERRUPT_MASK;433 434	iowrite32(intrs, pinstance->int_regs.ioa_host_interrupt_clr_reg);435	iowrite32(nmask, pinstance->int_regs.global_interrupt_mask_reg);436	ioread32(pinstance->int_regs.global_interrupt_mask_reg);437 438	if (!pinstance->interrupt_mode) {439		iowrite32(intrs,440			pinstance->int_regs.ioa_host_interrupt_mask_reg);441		ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);442	}443}444 445/**446 * pmcraid_enable_interrupts - Enables specified interrupts447 *448 * @pinstance: pointer to per adapter instance structure449 * @intrs: interrupts to enable450 *451 * Return Value452 *	 None453 */454static void pmcraid_enable_interrupts(455	struct pmcraid_instance *pinstance,456	u32 intrs)457{458	u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg);459	u32 nmask = gmask & (~GLOBAL_INTERRUPT_MASK);460 461	iowrite32(nmask, pinstance->int_regs.global_interrupt_mask_reg);462 463	if (!pinstance->interrupt_mode) {464		iowrite32(~intrs,465			 pinstance->int_regs.ioa_host_interrupt_mask_reg);466		ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);467	}468 469	pmcraid_info("enabled interrupts global mask = %x intr_mask = %x\n",470		ioread32(pinstance->int_regs.global_interrupt_mask_reg),471		ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg));472}473 474/**475 * pmcraid_clr_trans_op - clear trans to op interrupt476 *477 * @pinstance: pointer to per adapter instance structure478 *479 * Return Value480 *	 None481 */482static void pmcraid_clr_trans_op(483	struct pmcraid_instance *pinstance484)485{486	unsigned long lock_flags;487 488	if (!pinstance->interrupt_mode) {489		iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,490			pinstance->int_regs.ioa_host_interrupt_mask_reg);491		ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);492		iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,493			pinstance->int_regs.ioa_host_interrupt_clr_reg);494		ioread32(pinstance->int_regs.ioa_host_interrupt_clr_reg);495	}496 497	if (pinstance->reset_cmd != NULL) {498		del_timer(&pinstance->reset_cmd->timer);499		spin_lock_irqsave(500			pinstance->host->host_lock, lock_flags);501		pinstance->reset_cmd->cmd_done(pinstance->reset_cmd);502		spin_unlock_irqrestore(503			pinstance->host->host_lock, lock_flags);504	}505}506 507/**508 * pmcraid_reset_type - Determine the required reset type509 * @pinstance: pointer to adapter instance structure510 *511 * IOA requires hard reset if any of the following conditions is true.512 * 1. If HRRQ valid interrupt is not masked513 * 2. IOA reset alert doorbell is set514 * 3. If there are any error interrupts515 */516static void pmcraid_reset_type(struct pmcraid_instance *pinstance)517{518	u32 mask;519	u32 intrs;520	u32 alerts;521 522	mask = ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);523	intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);524	alerts = ioread32(pinstance->int_regs.host_ioa_interrupt_reg);525 526	if ((mask & INTRS_HRRQ_VALID) == 0 ||527	    (alerts & DOORBELL_IOA_RESET_ALERT) ||528	    (intrs & PMCRAID_ERROR_INTERRUPTS)) {529		pmcraid_info("IOA requires hard reset\n");530		pinstance->ioa_hard_reset = 1;531	}532 533	/* If unit check is active, trigger the dump */534	if (intrs & INTRS_IOA_UNIT_CHECK)535		pinstance->ioa_unit_check = 1;536}537 538static void pmcraid_ioa_reset(struct pmcraid_cmd *);539/**540 * pmcraid_bist_done - completion function for PCI BIST541 * @t: pointer to reset command542 * Return Value543 *	none544 */545static void pmcraid_bist_done(struct timer_list *t)546{547	struct pmcraid_cmd *cmd = from_timer(cmd, t, timer);548	struct pmcraid_instance *pinstance = cmd->drv_inst;549	unsigned long lock_flags;550	int rc;551	u16 pci_reg;552 553	rc = pci_read_config_word(pinstance->pdev, PCI_COMMAND, &pci_reg);554 555	/* If PCI config space can't be accessed wait for another two secs */556	if ((rc != PCIBIOS_SUCCESSFUL || (!(pci_reg & PCI_COMMAND_MEMORY))) &&557	    cmd->time_left > 0) {558		pmcraid_info("BIST not complete, waiting another 2 secs\n");559		cmd->timer.expires = jiffies + cmd->time_left;560		cmd->time_left = 0;561		add_timer(&cmd->timer);562	} else {563		cmd->time_left = 0;564		pmcraid_info("BIST is complete, proceeding with reset\n");565		spin_lock_irqsave(pinstance->host->host_lock, lock_flags);566		pmcraid_ioa_reset(cmd);567		spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);568	}569}570 571/**572 * pmcraid_start_bist - starts BIST573 * @cmd: pointer to reset cmd574 * Return Value575 *   none576 */577static void pmcraid_start_bist(struct pmcraid_cmd *cmd)578{579	struct pmcraid_instance *pinstance = cmd->drv_inst;580	u32 doorbells, intrs;581 582	/* proceed with bist and wait for 2 seconds */583	iowrite32(DOORBELL_IOA_START_BIST,584		pinstance->int_regs.host_ioa_interrupt_reg);585	doorbells = ioread32(pinstance->int_regs.host_ioa_interrupt_reg);586	intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);587	pmcraid_info("doorbells after start bist: %x intrs: %x\n",588		      doorbells, intrs);589 590	cmd->time_left = msecs_to_jiffies(PMCRAID_BIST_TIMEOUT);591	cmd->timer.expires = jiffies + msecs_to_jiffies(PMCRAID_BIST_TIMEOUT);592	cmd->timer.function = pmcraid_bist_done;593	add_timer(&cmd->timer);594}595 596/**597 * pmcraid_reset_alert_done - completion routine for reset_alert598 * @t: pointer to command block used in reset sequence599 * Return value600 *  None601 */602static void pmcraid_reset_alert_done(struct timer_list *t)603{604	struct pmcraid_cmd *cmd = from_timer(cmd, t, timer);605	struct pmcraid_instance *pinstance = cmd->drv_inst;606	u32 status = ioread32(pinstance->ioa_status);607	unsigned long lock_flags;608 609	/* if the critical operation in progress bit is set or the wait times610	 * out, invoke reset engine to proceed with hard reset. If there is611	 * some more time to wait, restart the timer612	 */613	if (((status & INTRS_CRITICAL_OP_IN_PROGRESS) == 0) ||614	    cmd->time_left <= 0) {615		pmcraid_info("critical op is reset proceeding with reset\n");616		spin_lock_irqsave(pinstance->host->host_lock, lock_flags);617		pmcraid_ioa_reset(cmd);618		spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);619	} else {620		pmcraid_info("critical op is not yet reset waiting again\n");621		/* restart timer if some more time is available to wait */622		cmd->time_left -= PMCRAID_CHECK_FOR_RESET_TIMEOUT;623		cmd->timer.expires = jiffies + PMCRAID_CHECK_FOR_RESET_TIMEOUT;624		cmd->timer.function = pmcraid_reset_alert_done;625		add_timer(&cmd->timer);626	}627}628 629static void pmcraid_notify_ioastate(struct pmcraid_instance *, u32);630/**631 * pmcraid_reset_alert - alerts IOA for a possible reset632 * @cmd: command block to be used for reset sequence.633 *634 * Return Value635 *	returns 0 if pci config-space is accessible and RESET_DOORBELL is636 *	successfully written to IOA. Returns non-zero in case pci_config_space637 *	is not accessible638 */639static void pmcraid_reset_alert(struct pmcraid_cmd *cmd)640{641	struct pmcraid_instance *pinstance = cmd->drv_inst;642	u32 doorbells;643	int rc;644	u16 pci_reg;645 646	/* If we are able to access IOA PCI config space, alert IOA that we are647	 * going to reset it soon. This enables IOA to preserv persistent error648	 * data if any. In case memory space is not accessible, proceed with649	 * BIST or slot_reset650	 */651	rc = pci_read_config_word(pinstance->pdev, PCI_COMMAND, &pci_reg);652	if ((rc == PCIBIOS_SUCCESSFUL) && (pci_reg & PCI_COMMAND_MEMORY)) {653 654		/* wait for IOA permission i.e until CRITICAL_OPERATION bit is655		 * reset IOA doesn't generate any interrupts when CRITICAL656		 * OPERATION bit is reset. A timer is started to wait for this657		 * bit to be reset.658		 */659		cmd->time_left = PMCRAID_RESET_TIMEOUT;660		cmd->timer.expires = jiffies + PMCRAID_CHECK_FOR_RESET_TIMEOUT;661		cmd->timer.function = pmcraid_reset_alert_done;662		add_timer(&cmd->timer);663 664		iowrite32(DOORBELL_IOA_RESET_ALERT,665			pinstance->int_regs.host_ioa_interrupt_reg);666		doorbells =667			ioread32(pinstance->int_regs.host_ioa_interrupt_reg);668		pmcraid_info("doorbells after reset alert: %x\n", doorbells);669	} else {670		pmcraid_info("PCI config is not accessible starting BIST\n");671		pinstance->ioa_state = IOA_STATE_IN_HARD_RESET;672		pmcraid_start_bist(cmd);673	}674}675 676/**677 * pmcraid_timeout_handler -  Timeout handler for internally generated ops678 *679 * @t: pointer to command structure, that got timedout680 *681 * This function blocks host requests and initiates an adapter reset.682 *683 * Return value:684 *   None685 */686static void pmcraid_timeout_handler(struct timer_list *t)687{688	struct pmcraid_cmd *cmd = from_timer(cmd, t, timer);689	struct pmcraid_instance *pinstance = cmd->drv_inst;690	unsigned long lock_flags;691 692	dev_info(&pinstance->pdev->dev,693		"Adapter being reset due to cmd(CDB[0] = %x) timeout\n",694		cmd->ioa_cb->ioarcb.cdb[0]);695 696	/* Command timeouts result in hard reset sequence. The command that got697	 * timed out may be the one used as part of reset sequence. In this698	 * case restart reset sequence using the same command block even if699	 * reset is in progress. Otherwise fail this command and get a free700	 * command block to restart the reset sequence.701	 */702	spin_lock_irqsave(pinstance->host->host_lock, lock_flags);703	if (!pinstance->ioa_reset_in_progress) {704		pinstance->ioa_reset_attempts = 0;705		cmd = pmcraid_get_free_cmd(pinstance);706 707		/* If we are out of command blocks, just return here itself.708		 * Some other command's timeout handler can do the reset job709		 */710		if (cmd == NULL) {711			spin_unlock_irqrestore(pinstance->host->host_lock,712					       lock_flags);713			pmcraid_err("no free cmnd block for timeout handler\n");714			return;715		}716 717		pinstance->reset_cmd = cmd;718		pinstance->ioa_reset_in_progress = 1;719	} else {720		pmcraid_info("reset is already in progress\n");721 722		if (pinstance->reset_cmd != cmd) {723			/* This command should have been given to IOA, this724			 * command will be completed by fail_outstanding_cmds725			 * anyway726			 */727			pmcraid_err("cmd is pending but reset in progress\n");728		}729 730		/* If this command was being used as part of the reset731		 * sequence, set cmd_done pointer to pmcraid_ioa_reset. This732		 * causes fail_outstanding_commands not to return the command733		 * block back to free pool734		 */735		if (cmd == pinstance->reset_cmd)736			cmd->cmd_done = pmcraid_ioa_reset;737	}738 739	/* Notify apps of important IOA bringup/bringdown sequences */740	if (pinstance->scn.ioa_state != PMC_DEVICE_EVENT_RESET_START &&741	    pinstance->scn.ioa_state != PMC_DEVICE_EVENT_SHUTDOWN_START)742		pmcraid_notify_ioastate(pinstance,743					PMC_DEVICE_EVENT_RESET_START);744 745	pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;746	scsi_block_requests(pinstance->host);747	pmcraid_reset_alert(cmd);748	spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);749}750 751/**752 * pmcraid_internal_done - completion routine for internally generated cmds753 *754 * @cmd: command that got response from IOA755 *756 * Return Value:757 *	 none758 */759static void pmcraid_internal_done(struct pmcraid_cmd *cmd)760{761	pmcraid_info("response internal cmd CDB[0] = %x ioasc = %x\n",762		     cmd->ioa_cb->ioarcb.cdb[0],763		     le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));764 765	/* Some of the internal commands are sent with callers blocking for the766	 * response. Same will be indicated as part of cmd->completion_req767	 * field. Response path needs to wake up any waiters waiting for cmd768	 * completion if this flag is set.769	 */770	if (cmd->completion_req) {771		cmd->completion_req = 0;772		complete(&cmd->wait_for_completion);773	}774 775	/* most of the internal commands are completed by caller itself, so776	 * no need to return the command block back to free pool until we are777	 * required to do so (e.g once done with initialization).778	 */779	if (cmd->release) {780		cmd->release = 0;781		pmcraid_return_cmd(cmd);782	}783}784 785/**786 * pmcraid_reinit_cfgtable_done - done function for cfg table reinitialization787 *788 * @cmd: command that got response from IOA789 *790 * This routine is called after driver re-reads configuration table due to a791 * lost CCN. It returns the command block back to free pool and schedules792 * worker thread to add/delete devices into the system.793 *794 * Return Value:795 *	 none796 */797static void pmcraid_reinit_cfgtable_done(struct pmcraid_cmd *cmd)798{799	pmcraid_info("response internal cmd CDB[0] = %x ioasc = %x\n",800		     cmd->ioa_cb->ioarcb.cdb[0],801		     le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));802 803	if (cmd->release) {804		cmd->release = 0;805		pmcraid_return_cmd(cmd);806	}807	pmcraid_info("scheduling worker for config table reinitialization\n");808	schedule_work(&cmd->drv_inst->worker_q);809}810 811/**812 * pmcraid_erp_done - Process completion of SCSI error response from device813 * @cmd: pmcraid_command814 *815 * This function copies the sense buffer into the scsi_cmd struct and completes816 * scsi_cmd by calling scsi_done function.817 *818 * Return value:819 *  none820 */821static void pmcraid_erp_done(struct pmcraid_cmd *cmd)822{823	struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;824	struct pmcraid_instance *pinstance = cmd->drv_inst;825	u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);826 827	if (PMCRAID_IOASC_SENSE_KEY(ioasc) > 0) {828		scsi_cmd->result |= (DID_ERROR << 16);829		scmd_printk(KERN_INFO, scsi_cmd,830			    "command CDB[0] = %x failed with IOASC: 0x%08X\n",831			    cmd->ioa_cb->ioarcb.cdb[0], ioasc);832	}833 834	if (cmd->sense_buffer) {835		dma_unmap_single(&pinstance->pdev->dev, cmd->sense_buffer_dma,836				 SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);837		cmd->sense_buffer = NULL;838		cmd->sense_buffer_dma = 0;839	}840 841	scsi_dma_unmap(scsi_cmd);842	pmcraid_return_cmd(cmd);843	scsi_done(scsi_cmd);844}845 846/**847 * _pmcraid_fire_command - sends an IOA command to adapter848 *849 * This function adds the given block into pending command list850 * and returns without waiting851 *852 * @cmd : command to be sent to the device853 *854 * Return Value855 *	None856 */857static void _pmcraid_fire_command(struct pmcraid_cmd *cmd)858{859	struct pmcraid_instance *pinstance = cmd->drv_inst;860	unsigned long lock_flags;861 862	/* Add this command block to pending cmd pool. We do this prior to863	 * writting IOARCB to ioarrin because IOA might complete the command864	 * by the time we are about to add it to the list. Response handler865	 * (isr/tasklet) looks for cmd block in the pending pending list.866	 */867	spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);868	list_add_tail(&cmd->free_list, &pinstance->pending_cmd_pool);869	spin_unlock_irqrestore(&pinstance->pending_pool_lock, lock_flags);870	atomic_inc(&pinstance->outstanding_cmds);871 872	/* driver writes lower 32-bit value of IOARCB address only */873	mb();874	iowrite32(le64_to_cpu(cmd->ioa_cb->ioarcb.ioarcb_bus_addr), pinstance->ioarrin);875}876 877/**878 * pmcraid_send_cmd - fires a command to IOA879 *880 * This function also sets up timeout function, and command completion881 * function882 *883 * @cmd: pointer to the command block to be fired to IOA884 * @cmd_done: command completion function, called once IOA responds885 * @timeout: timeout to wait for this command completion886 * @timeout_func: timeout handler887 *888 * Return value889 *   none890 */891static void pmcraid_send_cmd(892	struct pmcraid_cmd *cmd,893	void (*cmd_done) (struct pmcraid_cmd *),894	unsigned long timeout,895	void (*timeout_func) (struct timer_list *)896)897{898	/* initialize done function */899	cmd->cmd_done = cmd_done;900 901	if (timeout_func) {902		/* setup timeout handler */903		cmd->timer.expires = jiffies + timeout;904		cmd->timer.function = timeout_func;905		add_timer(&cmd->timer);906	}907 908	/* fire the command to IOA */909	_pmcraid_fire_command(cmd);910}911 912/**913 * pmcraid_ioa_shutdown_done - completion function for IOA shutdown command914 * @cmd: pointer to the command block used for sending IOA shutdown command915 *916 * Return value917 *  None918 */919static void pmcraid_ioa_shutdown_done(struct pmcraid_cmd *cmd)920{921	struct pmcraid_instance *pinstance = cmd->drv_inst;922	unsigned long lock_flags;923 924	spin_lock_irqsave(pinstance->host->host_lock, lock_flags);925	pmcraid_ioa_reset(cmd);926	spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);927}928 929/**930 * pmcraid_ioa_shutdown - sends SHUTDOWN command to ioa931 *932 * @cmd: pointer to the command block used as part of reset sequence933 *934 * Return Value935 *  None936 */937static void pmcraid_ioa_shutdown(struct pmcraid_cmd *cmd)938{939	pmcraid_info("response for Cancel CCN CDB[0] = %x ioasc = %x\n",940		     cmd->ioa_cb->ioarcb.cdb[0],941		     le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));942 943	/* Note that commands sent during reset require next command to be sent944	 * to IOA. Hence reinit the done function as well as timeout function945	 */946	pmcraid_reinit_cmdblk(cmd);947	cmd->ioa_cb->ioarcb.request_type = REQ_TYPE_IOACMD;948	cmd->ioa_cb->ioarcb.resource_handle =949		cpu_to_le32(PMCRAID_IOA_RES_HANDLE);950	cmd->ioa_cb->ioarcb.cdb[0] = PMCRAID_IOA_SHUTDOWN;951	cmd->ioa_cb->ioarcb.cdb[1] = PMCRAID_SHUTDOWN_NORMAL;952 953	/* fire shutdown command to hardware. */954	pmcraid_info("firing normal shutdown command (%d) to IOA\n",955		     le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle));956 957	pmcraid_notify_ioastate(cmd->drv_inst, PMC_DEVICE_EVENT_SHUTDOWN_START);958 959	pmcraid_send_cmd(cmd, pmcraid_ioa_shutdown_done,960			 PMCRAID_SHUTDOWN_TIMEOUT,961			 pmcraid_timeout_handler);962}963 964static void pmcraid_querycfg(struct pmcraid_cmd *);965/**966 * pmcraid_get_fwversion_done - completion function for get_fwversion967 *968 * @cmd: pointer to command block used to send INQUIRY command969 *970 * Return Value971 *	none972 */973static void pmcraid_get_fwversion_done(struct pmcraid_cmd *cmd)974{975	struct pmcraid_instance *pinstance = cmd->drv_inst;976	u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);977	unsigned long lock_flags;978 979	/* configuration table entry size depends on firmware version. If fw980	 * version is not known, it is not possible to interpret IOA config981	 * table982	 */983	if (ioasc) {984		pmcraid_err("IOA Inquiry failed with %x\n", ioasc);985		spin_lock_irqsave(pinstance->host->host_lock, lock_flags);986		pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;987		pmcraid_reset_alert(cmd);988		spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);989	} else  {990		pmcraid_querycfg(cmd);991	}992}993 994/**995 * pmcraid_get_fwversion - reads firmware version information996 *997 * @cmd: pointer to command block used to send INQUIRY command998 *999 * Return Value1000 *	none1001 */1002static void pmcraid_get_fwversion(struct pmcraid_cmd *cmd)1003{1004	struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;1005	struct pmcraid_ioadl_desc *ioadl;1006	struct pmcraid_instance *pinstance = cmd->drv_inst;1007	u16 data_size = sizeof(struct pmcraid_inquiry_data);1008 1009	pmcraid_reinit_cmdblk(cmd);1010	ioarcb->request_type = REQ_TYPE_SCSI;1011	ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);1012	ioarcb->cdb[0] = INQUIRY;1013	ioarcb->cdb[1] = 1;1014	ioarcb->cdb[2] = 0xD0;1015	ioarcb->cdb[3] = (data_size >> 8) & 0xFF;1016	ioarcb->cdb[4] = data_size & 0xFF;1017 1018	/* Since entire inquiry data it can be part of IOARCB itself1019	 */1020	ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +1021					offsetof(struct pmcraid_ioarcb,1022						add_data.u.ioadl[0]));1023	ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));1024	ioarcb->ioarcb_bus_addr &= cpu_to_le64(~(0x1FULL));1025 1026	ioarcb->request_flags0 |= NO_LINK_DESCS;1027	ioarcb->data_transfer_length = cpu_to_le32(data_size);1028	ioadl = &(ioarcb->add_data.u.ioadl[0]);1029	ioadl->flags = IOADL_FLAGS_LAST_DESC;1030	ioadl->address = cpu_to_le64(pinstance->inq_data_baddr);1031	ioadl->data_len = cpu_to_le32(data_size);1032 1033	pmcraid_send_cmd(cmd, pmcraid_get_fwversion_done,1034			 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);1035}1036 1037/**1038 * pmcraid_identify_hrrq - registers host rrq buffers with IOA1039 * @cmd: pointer to command block to be used for identify hrrq1040 *1041 * Return Value1042 *	 none1043 */1044static void pmcraid_identify_hrrq(struct pmcraid_cmd *cmd)1045{1046	struct pmcraid_instance *pinstance = cmd->drv_inst;1047	struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;1048	int index = cmd->hrrq_index;1049	__be64 hrrq_addr = cpu_to_be64(pinstance->hrrq_start_bus_addr[index]);1050	__be32 hrrq_size = cpu_to_be32(sizeof(u32) * PMCRAID_MAX_CMD);1051	void (*done_function)(struct pmcraid_cmd *);1052 1053	pmcraid_reinit_cmdblk(cmd);1054	cmd->hrrq_index = index + 1;1055 1056	if (cmd->hrrq_index < pinstance->num_hrrq) {1057		done_function = pmcraid_identify_hrrq;1058	} else {1059		cmd->hrrq_index = 0;1060		done_function = pmcraid_get_fwversion;1061	}1062 1063	/* Initialize ioarcb */1064	ioarcb->request_type = REQ_TYPE_IOACMD;1065	ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);1066 1067	/* initialize the hrrq number where IOA will respond to this command */1068	ioarcb->hrrq_id = index;1069	ioarcb->cdb[0] = PMCRAID_IDENTIFY_HRRQ;1070	ioarcb->cdb[1] = index;1071 1072	/* IOA expects 64-bit pci address to be written in B.E format1073	 * (i.e cdb[2]=MSByte..cdb[9]=LSB.1074	 */1075	pmcraid_info("HRRQ_IDENTIFY with hrrq:ioarcb:index => %llx:%llx:%x\n",1076		     hrrq_addr, ioarcb->ioarcb_bus_addr, index);1077 1078	memcpy(&(ioarcb->cdb[2]), &hrrq_addr, sizeof(hrrq_addr));1079	memcpy(&(ioarcb->cdb[10]), &hrrq_size, sizeof(hrrq_size));1080 1081	/* Subsequent commands require HRRQ identification to be successful.1082	 * Note that this gets called even during reset from SCSI mid-layer1083	 * or tasklet1084	 */1085	pmcraid_send_cmd(cmd, done_function,1086			 PMCRAID_INTERNAL_TIMEOUT,1087			 pmcraid_timeout_handler);1088}1089 1090static void pmcraid_process_ccn(struct pmcraid_cmd *cmd);1091static void pmcraid_process_ldn(struct pmcraid_cmd *cmd);1092 1093/**1094 * pmcraid_send_hcam_cmd - send an initialized command block(HCAM) to IOA1095 *1096 * @cmd: initialized command block pointer1097 *1098 * Return Value1099 *   none1100 */1101static void pmcraid_send_hcam_cmd(struct pmcraid_cmd *cmd)1102{1103	if (cmd->ioa_cb->ioarcb.cdb[1] == PMCRAID_HCAM_CODE_CONFIG_CHANGE)1104		atomic_set(&(cmd->drv_inst->ccn.ignore), 0);1105	else1106		atomic_set(&(cmd->drv_inst->ldn.ignore), 0);1107 1108	pmcraid_send_cmd(cmd, cmd->cmd_done, 0, NULL);1109}1110 1111/**1112 * pmcraid_init_hcam - send an initialized command block(HCAM) to IOA1113 *1114 * @pinstance: pointer to adapter instance structure1115 * @type: HCAM type1116 *1117 * Return Value1118 *   pointer to initialized pmcraid_cmd structure or NULL1119 */1120static struct pmcraid_cmd *pmcraid_init_hcam1121(1122	struct pmcraid_instance *pinstance,1123	u8 type1124)1125{1126	struct pmcraid_cmd *cmd;1127	struct pmcraid_ioarcb *ioarcb;1128	struct pmcraid_ioadl_desc *ioadl;1129	struct pmcraid_hostrcb *hcam;1130	void (*cmd_done) (struct pmcraid_cmd *);1131	dma_addr_t dma;1132	int rcb_size;1133 1134	cmd = pmcraid_get_free_cmd(pinstance);1135 1136	if (!cmd) {1137		pmcraid_err("no free command blocks for hcam\n");1138		return cmd;1139	}1140 1141	if (type == PMCRAID_HCAM_CODE_CONFIG_CHANGE) {1142		rcb_size = sizeof(struct pmcraid_hcam_ccn_ext);1143		cmd_done = pmcraid_process_ccn;1144		dma = pinstance->ccn.baddr + PMCRAID_AEN_HDR_SIZE;1145		hcam = &pinstance->ccn;1146	} else {1147		rcb_size = sizeof(struct pmcraid_hcam_ldn);1148		cmd_done = pmcraid_process_ldn;1149		dma = pinstance->ldn.baddr + PMCRAID_AEN_HDR_SIZE;1150		hcam = &pinstance->ldn;1151	}1152 1153	/* initialize command pointer used for HCAM registration */1154	hcam->cmd = cmd;1155 1156	ioarcb = &cmd->ioa_cb->ioarcb;1157	ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +1158					offsetof(struct pmcraid_ioarcb,1159						add_data.u.ioadl[0]));1160	ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));1161	ioadl = ioarcb->add_data.u.ioadl;1162 1163	/* Initialize ioarcb */1164	ioarcb->request_type = REQ_TYPE_HCAM;1165	ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);1166	ioarcb->cdb[0] = PMCRAID_HOST_CONTROLLED_ASYNC;1167	ioarcb->cdb[1] = type;1168	ioarcb->cdb[7] = (rcb_size >> 8) & 0xFF;1169	ioarcb->cdb[8] = (rcb_size) & 0xFF;1170 1171	ioarcb->data_transfer_length = cpu_to_le32(rcb_size);1172 1173	ioadl[0].flags |= IOADL_FLAGS_READ_LAST;1174	ioadl[0].data_len = cpu_to_le32(rcb_size);1175	ioadl[0].address = cpu_to_le64(dma);1176 1177	cmd->cmd_done = cmd_done;1178	return cmd;1179}1180 1181/**1182 * pmcraid_send_hcam - Send an HCAM to IOA1183 * @pinstance: ioa config struct1184 * @type: HCAM type1185 *1186 * This function will send a Host Controlled Async command to IOA.1187 *1188 * Return value:1189 *	none1190 */1191static void pmcraid_send_hcam(struct pmcraid_instance *pinstance, u8 type)1192{1193	struct pmcraid_cmd *cmd = pmcraid_init_hcam(pinstance, type);1194	pmcraid_send_hcam_cmd(cmd);1195}1196 1197 1198/**1199 * pmcraid_prepare_cancel_cmd - prepares a command block to abort another1200 *1201 * @cmd: pointer to cmd that is used as cancelling command1202 * @cmd_to_cancel: pointer to the command that needs to be cancelled1203 */1204static void pmcraid_prepare_cancel_cmd(1205	struct pmcraid_cmd *cmd,1206	struct pmcraid_cmd *cmd_to_cancel1207)1208{1209	struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;1210	__be64 ioarcb_addr;1211 1212	/* IOARCB address of the command to be cancelled is given in1213	 * cdb[2]..cdb[9] is Big-Endian format. Note that length bits in1214	 * IOARCB address are not masked.1215	 */1216	ioarcb_addr = cpu_to_be64(le64_to_cpu(cmd_to_cancel->ioa_cb->ioarcb.ioarcb_bus_addr));1217 1218	/* Get the resource handle to where the command to be aborted has been1219	 * sent.1220	 */1221	ioarcb->resource_handle = cmd_to_cancel->ioa_cb->ioarcb.resource_handle;1222	ioarcb->request_type = REQ_TYPE_IOACMD;1223	memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN);1224	ioarcb->cdb[0] = PMCRAID_ABORT_CMD;1225 1226	memcpy(&(ioarcb->cdb[2]), &ioarcb_addr, sizeof(ioarcb_addr));1227}1228 1229/**1230 * pmcraid_cancel_hcam - sends ABORT task to abort a given HCAM1231 *1232 * @cmd: command to be used as cancelling command1233 * @type: HCAM type1234 * @cmd_done: op done function for the cancelling command1235 */1236static void pmcraid_cancel_hcam(1237	struct pmcraid_cmd *cmd,1238	u8 type,1239	void (*cmd_done) (struct pmcraid_cmd *)1240)1241{1242	struct pmcraid_instance *pinstance;1243	struct pmcraid_hostrcb  *hcam;1244 1245	pinstance = cmd->drv_inst;1246	hcam =  (type == PMCRAID_HCAM_CODE_LOG_DATA) ?1247		&pinstance->ldn : &pinstance->ccn;1248 1249	/* prepare for cancelling previous hcam command. If the HCAM is1250	 * currently not pending with IOA, we would have hcam->cmd as non-null1251	 */1252	if (hcam->cmd == NULL)1253		return;1254 1255	pmcraid_prepare_cancel_cmd(cmd, hcam->cmd);1256 1257	/* writing to IOARRIN must be protected by host_lock, as mid-layer1258	 * schedule queuecommand while we are doing this1259	 */1260	pmcraid_send_cmd(cmd, cmd_done,1261			 PMCRAID_INTERNAL_TIMEOUT,1262			 pmcraid_timeout_handler);1263}1264 1265/**1266 * pmcraid_cancel_ccn - cancel CCN HCAM already registered with IOA1267 *1268 * @cmd: command block to be used for cancelling the HCAM1269 */1270static void pmcraid_cancel_ccn(struct pmcraid_cmd *cmd)1271{1272	pmcraid_info("response for Cancel LDN CDB[0] = %x ioasc = %x\n",1273		     cmd->ioa_cb->ioarcb.cdb[0],1274		     le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));1275 1276	pmcraid_reinit_cmdblk(cmd);1277 1278	pmcraid_cancel_hcam(cmd,1279			    PMCRAID_HCAM_CODE_CONFIG_CHANGE,1280			    pmcraid_ioa_shutdown);1281}1282 1283/**1284 * pmcraid_cancel_ldn - cancel LDN HCAM already registered with IOA1285 *1286 * @cmd: command block to be used for cancelling the HCAM1287 */1288static void pmcraid_cancel_ldn(struct pmcraid_cmd *cmd)1289{1290	pmcraid_cancel_hcam(cmd,1291			    PMCRAID_HCAM_CODE_LOG_DATA,1292			    pmcraid_cancel_ccn);1293}1294 1295/**1296 * pmcraid_expose_resource - check if the resource can be exposed to OS1297 *1298 * @fw_version: firmware version code1299 * @cfgte: pointer to configuration table entry of the resource1300 *1301 * Return value:1302 *	true if resource can be added to midlayer, false(0) otherwise1303 */1304static int pmcraid_expose_resource(u16 fw_version,1305				   struct pmcraid_config_table_entry *cfgte)1306{1307	int retval = 0;1308 1309	if (cfgte->resource_type == RES_TYPE_VSET) {1310		if (fw_version <= PMCRAID_FW_VERSION_1)1311			retval = ((cfgte->unique_flags1 & 0x80) == 0);1312		else1313			retval = ((cfgte->unique_flags0 & 0x80) == 0 &&1314				  (cfgte->unique_flags1 & 0x80) == 0);1315 1316	} else if (cfgte->resource_type == RES_TYPE_GSCSI)1317		retval = (RES_BUS(cfgte->resource_address) !=1318				PMCRAID_VIRTUAL_ENCL_BUS_ID);1319	return retval;1320}1321 1322/* attributes supported by pmcraid_event_family */1323enum {1324	PMCRAID_AEN_ATTR_UNSPEC,1325	PMCRAID_AEN_ATTR_EVENT,1326	__PMCRAID_AEN_ATTR_MAX,1327};1328#define PMCRAID_AEN_ATTR_MAX (__PMCRAID_AEN_ATTR_MAX - 1)1329 1330/* commands supported by pmcraid_event_family */1331enum {1332	PMCRAID_AEN_CMD_UNSPEC,1333	PMCRAID_AEN_CMD_EVENT,1334	__PMCRAID_AEN_CMD_MAX,1335};1336#define PMCRAID_AEN_CMD_MAX (__PMCRAID_AEN_CMD_MAX - 1)1337 1338static struct genl_multicast_group pmcraid_mcgrps[] = {1339	{ .name = "events", /* not really used - see ID discussion below */ },1340};1341 1342static struct genl_family pmcraid_event_family __ro_after_init = {1343	.module = THIS_MODULE,1344	.name = "pmcraid",1345	.version = 1,1346	.maxattr = PMCRAID_AEN_ATTR_MAX,1347	.mcgrps = pmcraid_mcgrps,1348	.n_mcgrps = ARRAY_SIZE(pmcraid_mcgrps),1349};1350 1351/**1352 * pmcraid_netlink_init - registers pmcraid_event_family1353 *1354 * Return value:1355 *	0 if the pmcraid_event_family is successfully registered1356 *	with netlink generic, non-zero otherwise1357 */1358static int __init pmcraid_netlink_init(void)1359{1360	int result;1361 1362	result = genl_register_family(&pmcraid_event_family);1363 1364	if (result)1365		return result;1366 1367	pmcraid_info("registered NETLINK GENERIC group: %d\n",1368		     pmcraid_event_family.id);1369 1370	return result;1371}1372 1373/**1374 * pmcraid_netlink_release - unregisters pmcraid_event_family1375 *1376 * Return value:1377 *	none1378 */1379static void pmcraid_netlink_release(void)1380{1381	genl_unregister_family(&pmcraid_event_family);1382}1383 1384/*1385 * pmcraid_notify_aen - sends event msg to user space application1386 * @pinstance: pointer to adapter instance structure1387 *1388 * Return value:1389 *	0 if success, error value in case of any failure.1390 */1391static int pmcraid_notify_aen(1392	struct pmcraid_instance *pinstance,1393	struct pmcraid_aen_msg  *aen_msg,1394	u32    data_size)1395{1396	struct sk_buff *skb;1397	void *msg_header;1398	u32  total_size, nla_genl_hdr_total_size;1399	int result;1400 1401	aen_msg->hostno = (pinstance->host->unique_id << 16 |1402			   MINOR(pinstance->cdev.dev));1403	aen_msg->length = data_size;1404 1405	data_size += sizeof(*aen_msg);1406 1407	total_size = nla_total_size(data_size);1408	/* Add GENL_HDR to total_size */1409	nla_genl_hdr_total_size =1410		(total_size + (GENL_HDRLEN +1411		((struct genl_family *)&pmcraid_event_family)->hdrsize)1412		 + NLMSG_HDRLEN);1413	skb = genlmsg_new(nla_genl_hdr_total_size, GFP_ATOMIC);1414 1415 1416	if (!skb) {1417		pmcraid_err("Failed to allocate aen data SKB of size: %x\n",1418			     total_size);1419		return -ENOMEM;1420	}1421 1422	/* add the genetlink message header */1423	msg_header = genlmsg_put(skb, 0, 0,1424				 &pmcraid_event_family, 0,1425				 PMCRAID_AEN_CMD_EVENT);1426	if (!msg_header) {1427		pmcraid_err("failed to copy command details\n");1428		nlmsg_free(skb);1429		return -ENOMEM;1430	}1431 1432	result = nla_put(skb, PMCRAID_AEN_ATTR_EVENT, data_size, aen_msg);1433 1434	if (result) {1435		pmcraid_err("failed to copy AEN attribute data\n");1436		nlmsg_free(skb);1437		return -EINVAL;1438	}1439 1440	/* send genetlink multicast message to notify applications */1441	genlmsg_end(skb, msg_header);1442 1443	result = genlmsg_multicast(&pmcraid_event_family, skb,1444				   0, 0, GFP_ATOMIC);1445 1446	/* If there are no listeners, genlmsg_multicast may return non-zero1447	 * value.1448	 */1449	if (result)1450		pmcraid_info("error (%x) sending aen event message\n", result);1451	return result;1452}1453 1454/**1455 * pmcraid_notify_ccn - notifies about CCN event msg to user space1456 * @pinstance: pointer adapter instance structure1457 *1458 * Return value:1459 *	0 if success, error value in case of any failure1460 */1461static int pmcraid_notify_ccn(struct pmcraid_instance *pinstance)1462{1463	return pmcraid_notify_aen(pinstance,1464				pinstance->ccn.msg,1465				le32_to_cpu(pinstance->ccn.hcam->data_len) +1466				sizeof(struct pmcraid_hcam_hdr));1467}1468 1469/**1470 * pmcraid_notify_ldn - notifies about CCN event msg to user space1471 * @pinstance: pointer adapter instance structure1472 *1473 * Return value:1474 *	0 if success, error value in case of any failure1475 */1476static int pmcraid_notify_ldn(struct pmcraid_instance *pinstance)1477{1478	return pmcraid_notify_aen(pinstance,1479				pinstance->ldn.msg,1480				le32_to_cpu(pinstance->ldn.hcam->data_len) +1481				sizeof(struct pmcraid_hcam_hdr));1482}1483 1484/**1485 * pmcraid_notify_ioastate - sends IOA state event msg to user space1486 * @pinstance: pointer adapter instance structure1487 * @evt: controller state event to be sent1488 *1489 * Return value:1490 *	0 if success, error value in case of any failure1491 */1492static void pmcraid_notify_ioastate(struct pmcraid_instance *pinstance, u32 evt)1493{1494	pinstance->scn.ioa_state = evt;1495	pmcraid_notify_aen(pinstance,1496			  &pinstance->scn.msg,1497			  sizeof(u32));1498}1499 1500/**1501 * pmcraid_handle_config_change - Handle a config change from the adapter1502 * @pinstance: pointer to per adapter instance structure1503 *1504 * Return value:1505 *  none1506 */1507 1508static void pmcraid_handle_config_change(struct pmcraid_instance *pinstance)1509{1510	struct pmcraid_config_table_entry *cfg_entry;1511	struct pmcraid_hcam_ccn *ccn_hcam;1512	struct pmcraid_cmd *cmd;1513	struct pmcraid_cmd *cfgcmd;1514	struct pmcraid_resource_entry *res = NULL;1515	unsigned long lock_flags;1516	unsigned long host_lock_flags;1517	u32 new_entry = 1;1518	u32 hidden_entry = 0;1519	u16 fw_version;1520	int rc;1521 1522	ccn_hcam = (struct pmcraid_hcam_ccn *)pinstance->ccn.hcam;1523	cfg_entry = &ccn_hcam->cfg_entry;1524	fw_version = be16_to_cpu(pinstance->inq_data->fw_version);1525 1526	pmcraid_info("CCN(%x): %x timestamp: %llx type: %x lost: %x flags: %x \1527		 res: %x:%x:%x:%x\n",1528		 le32_to_cpu(pinstance->ccn.hcam->ilid),1529		 pinstance->ccn.hcam->op_code,1530		(le32_to_cpu(pinstance->ccn.hcam->timestamp1) |1531		((le32_to_cpu(pinstance->ccn.hcam->timestamp2) & 0xffffffffLL) << 32)),1532		 pinstance->ccn.hcam->notification_type,1533		 pinstance->ccn.hcam->notification_lost,1534		 pinstance->ccn.hcam->flags,1535		 pinstance->host->unique_id,1536		 RES_IS_VSET(*cfg_entry) ? PMCRAID_VSET_BUS_ID :1537		 (RES_IS_GSCSI(*cfg_entry) ? PMCRAID_PHYS_BUS_ID :1538			RES_BUS(cfg_entry->resource_address)),1539		 RES_IS_VSET(*cfg_entry) ?1540			(fw_version <= PMCRAID_FW_VERSION_1 ?1541				cfg_entry->unique_flags1 :1542				le16_to_cpu(cfg_entry->array_id) & 0xFF) :1543			RES_TARGET(cfg_entry->resource_address),1544		 RES_LUN(cfg_entry->resource_address));1545 1546 1547	/* If this HCAM indicates a lost notification, read the config table */1548	if (pinstance->ccn.hcam->notification_lost) {1549		cfgcmd = pmcraid_get_free_cmd(pinstance);1550		if (cfgcmd) {1551			pmcraid_info("lost CCN, reading config table\b");1552			pinstance->reinit_cfg_table = 1;1553			pmcraid_querycfg(cfgcmd);1554		} else {1555			pmcraid_err("lost CCN, no free cmd for querycfg\n");1556		}1557		goto out_notify_apps;1558	}1559 1560	/* If this resource is not going to be added to mid-layer, just notify1561	 * applications and return. If this notification is about hiding a VSET1562	 * resource, check if it was exposed already.1563	 */1564	if (pinstance->ccn.hcam->notification_type ==1565	    NOTIFICATION_TYPE_ENTRY_CHANGED &&1566	    cfg_entry->resource_type == RES_TYPE_VSET) {1567		hidden_entry = (cfg_entry->unique_flags1 & 0x80) != 0;1568	} else if (!pmcraid_expose_resource(fw_version, cfg_entry)) {1569		goto out_notify_apps;1570	}1571 1572	spin_lock_irqsave(&pinstance->resource_lock, lock_flags);1573	list_for_each_entry(res, &pinstance->used_res_q, queue) {1574		rc = memcmp(&res->cfg_entry.resource_address,1575			    &cfg_entry->resource_address,1576			    sizeof(cfg_entry->resource_address));1577		if (!rc) {1578			new_entry = 0;1579			break;1580		}1581	}1582 1583	if (new_entry) {1584 1585		if (hidden_entry) {1586			spin_unlock_irqrestore(&pinstance->resource_lock,1587						lock_flags);1588			goto out_notify_apps;1589		}1590 1591		/* If there are more number of resources than what driver can1592		 * manage, do not notify the applications about the CCN. Just1593		 * ignore this notifications and re-register the same HCAM1594		 */1595		if (list_empty(&pinstance->free_res_q)) {1596			spin_unlock_irqrestore(&pinstance->resource_lock,1597						lock_flags);1598			pmcraid_err("too many resources attached\n");1599			spin_lock_irqsave(pinstance->host->host_lock,1600					  host_lock_flags);1601			pmcraid_send_hcam(pinstance,1602					  PMCRAID_HCAM_CODE_CONFIG_CHANGE);1603			spin_unlock_irqrestore(pinstance->host->host_lock,1604					       host_lock_flags);1605			return;1606		}1607 1608		res = list_entry(pinstance->free_res_q.next,1609				 struct pmcraid_resource_entry, queue);1610 1611		list_del(&res->queue);1612		res->scsi_dev = NULL;1613		res->reset_progress = 0;1614		list_add_tail(&res->queue, &pinstance->used_res_q);1615	}1616 1617	memcpy(&res->cfg_entry, cfg_entry, pinstance->config_table_entry_size);1618 1619	if (pinstance->ccn.hcam->notification_type ==1620	    NOTIFICATION_TYPE_ENTRY_DELETED || hidden_entry) {1621		if (res->scsi_dev) {1622			if (fw_version <= PMCRAID_FW_VERSION_1)1623				res->cfg_entry.unique_flags1 &= 0x7F;1624			else1625				res->cfg_entry.array_id &= cpu_to_le16(0xFF);1626			res->change_detected = RES_CHANGE_DEL;1627			res->cfg_entry.resource_handle =1628				PMCRAID_INVALID_RES_HANDLE;1629			schedule_work(&pinstance->worker_q);1630		} else {1631			/* This may be one of the non-exposed resources */1632			list_move_tail(&res->queue, &pinstance->free_res_q);1633		}1634	} else if (!res->scsi_dev) {1635		res->change_detected = RES_CHANGE_ADD;1636		schedule_work(&pinstance->worker_q);1637	}1638	spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);1639 1640out_notify_apps:1641 1642	/* Notify configuration changes to registered applications.*/1643	if (!pmcraid_disable_aen)1644		pmcraid_notify_ccn(pinstance);1645 1646	cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);1647	if (cmd)1648		pmcraid_send_hcam_cmd(cmd);1649}1650 1651/**1652 * pmcraid_get_error_info - return error string for an ioasc1653 * @ioasc: ioasc code1654 * Return Value1655 *	 none1656 */1657static struct pmcraid_ioasc_error *pmcraid_get_error_info(u32 ioasc)1658{1659	int i;1660	for (i = 0; i < ARRAY_SIZE(pmcraid_ioasc_error_table); i++) {1661		if (pmcraid_ioasc_error_table[i].ioasc_code == ioasc)1662			return &pmcraid_ioasc_error_table[i];1663	}1664	return NULL;1665}1666 1667/**1668 * pmcraid_ioasc_logger - log IOASC information based user-settings1669 * @ioasc: ioasc code1670 * @cmd: pointer to command that resulted in 'ioasc'1671 */1672static void pmcraid_ioasc_logger(u32 ioasc, struct pmcraid_cmd *cmd)1673{1674	struct pmcraid_ioasc_error *error_info = pmcraid_get_error_info(ioasc);1675 1676	if (error_info == NULL ||1677		cmd->drv_inst->current_log_level < error_info->log_level)1678		return;1679 1680	/* log the error string */1681	pmcraid_err("cmd [%x] for resource %x failed with %x(%s)\n",1682		cmd->ioa_cb->ioarcb.cdb[0],1683		le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle),1684		ioasc, error_info->error_string);1685}1686 1687/**1688 * pmcraid_handle_error_log - Handle a config change (error log) from the IOA1689 *1690 * @pinstance: pointer to per adapter instance structure1691 *1692 * Return value:1693 *  none1694 */1695static void pmcraid_handle_error_log(struct pmcraid_instance *pinstance)1696{1697	struct pmcraid_hcam_ldn *hcam_ldn;1698	u32 ioasc;1699 1700	hcam_ldn = (struct pmcraid_hcam_ldn *)pinstance->ldn.hcam;1701 1702	pmcraid_info1703		("LDN(%x): %x type: %x lost: %x flags: %x overlay id: %x\n",1704		 pinstance->ldn.hcam->ilid,1705		 pinstance->ldn.hcam->op_code,1706		 pinstance->ldn.hcam->notification_type,1707		 pinstance->ldn.hcam->notification_lost,1708		 pinstance->ldn.hcam->flags,1709		 pinstance->ldn.hcam->overlay_id);1710 1711	/* log only the errors, no need to log informational log entries */1712	if (pinstance->ldn.hcam->notification_type !=1713	    NOTIFICATION_TYPE_ERROR_LOG)1714		return;1715 1716	if (pinstance->ldn.hcam->notification_lost ==1717	    HOSTRCB_NOTIFICATIONS_LOST)1718		dev_info(&pinstance->pdev->dev, "Error notifications lost\n");1719 1720	ioasc = le32_to_cpu(hcam_ldn->error_log.fd_ioasc);1721 1722	if (ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET ||1723		ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET_BY_OTHER) {1724		dev_info(&pinstance->pdev->dev,1725			"UnitAttention due to IOA Bus Reset\n");1726		scsi_report_bus_reset(1727			pinstance->host,1728			RES_BUS(hcam_ldn->error_log.fd_ra));1729	}1730 1731	return;1732}1733 1734/**1735 * pmcraid_process_ccn - Op done function for a CCN.1736 * @cmd: pointer to command struct1737 *1738 * This function is the op done function for a configuration1739 * change notification1740 *1741 * Return value:1742 * none1743 */1744static void pmcraid_process_ccn(struct pmcraid_cmd *cmd)1745{1746	struct pmcraid_instance *pinstance = cmd->drv_inst;1747	u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);1748	unsigned long lock_flags;1749 1750	pinstance->ccn.cmd = NULL;1751	pmcraid_return_cmd(cmd);1752 1753	/* If driver initiated IOA reset happened while this hcam was pending1754	 * with IOA, or IOA bringdown sequence is in progress, no need to1755	 * re-register the hcam1756	 */1757	if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET ||1758	    atomic_read(&pinstance->ccn.ignore) == 1) {1759		return;1760	} else if (ioasc) {1761		dev_info(&pinstance->pdev->dev,1762			"Host RCB (CCN) failed with IOASC: 0x%08X\n", ioasc);1763		spin_lock_irqsave(pinstance->host->host_lock, lock_flags);1764		pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);1765		spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);1766	} else {1767		pmcraid_handle_config_change(pinstance);1768	}1769}1770 1771static void pmcraid_initiate_reset(struct pmcraid_instance *);1772static void pmcraid_set_timestamp(struct pmcraid_cmd *cmd);1773/**1774 * pmcraid_process_ldn - op done function for an LDN1775 * @cmd: pointer to command block1776 *1777 * Return value1778 *   none1779 */1780static void pmcraid_process_ldn(struct pmcraid_cmd *cmd)1781{1782	struct pmcraid_instance *pinstance = cmd->drv_inst;1783	struct pmcraid_hcam_ldn *ldn_hcam =1784			(struct pmcraid_hcam_ldn *)pinstance->ldn.hcam;1785	u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);1786	u32 fd_ioasc = le32_to_cpu(ldn_hcam->error_log.fd_ioasc);1787	unsigned long lock_flags;1788 1789	/* return the command block back to freepool */1790	pinstance->ldn.cmd = NULL;1791	pmcraid_return_cmd(cmd);1792 1793	/* If driver initiated IOA reset happened while this hcam was pending1794	 * with IOA, no need to re-register the hcam as reset engine will do it1795	 * once reset sequence is complete1796	 */1797	if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET ||1798	    atomic_read(&pinstance->ccn.ignore) == 1) {1799		return;1800	} else if (!ioasc) {1801		pmcraid_handle_error_log(pinstance);1802		if (fd_ioasc == PMCRAID_IOASC_NR_IOA_RESET_REQUIRED) {1803			spin_lock_irqsave(pinstance->host->host_lock,1804					  lock_flags);1805			pmcraid_initiate_reset(pinstance);1806			spin_unlock_irqrestore(pinstance->host->host_lock,1807					       lock_flags);1808			return;1809		}1810		if (fd_ioasc == PMCRAID_IOASC_TIME_STAMP_OUT_OF_SYNC) {1811			pinstance->timestamp_error = 1;1812			pmcraid_set_timestamp(cmd);1813		}1814	} else {1815		dev_info(&pinstance->pdev->dev,1816			"Host RCB(LDN) failed with IOASC: 0x%08X\n", ioasc);1817	}1818	/* send netlink message for HCAM notification if enabled */1819	if (!pmcraid_disable_aen)1820		pmcraid_notify_ldn(pinstance);1821 1822	cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA);1823	if (cmd)1824		pmcraid_send_hcam_cmd(cmd);1825}1826 1827/**1828 * pmcraid_register_hcams - register HCAMs for CCN and LDN1829 *1830 * @pinstance: pointer per adapter instance structure1831 *1832 * Return Value1833 *   none1834 */1835static void pmcraid_register_hcams(struct pmcraid_instance *pinstance)1836{1837	pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);1838	pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA);1839}1840 1841/**1842 * pmcraid_unregister_hcams - cancel HCAMs registered already1843 * @cmd: pointer to command used as part of reset sequence1844 */1845static void pmcraid_unregister_hcams(struct pmcraid_cmd *cmd)1846{1847	struct pmcraid_instance *pinstance = cmd->drv_inst;1848 1849	/* During IOA bringdown, HCAM gets fired and tasklet proceeds with1850	 * handling hcam response though it is not necessary. In order to1851	 * prevent this, set 'ignore', so that bring-down sequence doesn't1852	 * re-send any more hcams1853	 */1854	atomic_set(&pinstance->ccn.ignore, 1);1855	atomic_set(&pinstance->ldn.ignore, 1);1856 1857	/* If adapter reset was forced as part of runtime reset sequence,1858	 * start the reset sequence. Reset will be triggered even in case1859	 * IOA unit_check.1860	 */1861	if ((pinstance->force_ioa_reset && !pinstance->ioa_bringdown) ||1862	     pinstance->ioa_unit_check) {1863		pinstance->force_ioa_reset = 0;1864		pinstance->ioa_unit_check = 0;1865		pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;1866		pmcraid_reset_alert(cmd);1867		return;1868	}1869 1870	/* Driver tries to cancel HCAMs by sending ABORT TASK for each HCAM1871	 * one after the other. So CCN cancellation will be triggered by1872	 * pmcraid_cancel_ldn itself.1873	 */1874	pmcraid_cancel_ldn(cmd);1875}1876 1877static void pmcraid_reinit_buffers(struct pmcraid_instance *);1878 1879/**1880 * pmcraid_reset_enable_ioa - re-enable IOA after a hard reset1881 * @pinstance: pointer to adapter instance structure1882 * Return Value1883 *  1 if TRANSITION_TO_OPERATIONAL is active, otherwise 01884 */1885static int pmcraid_reset_enable_ioa(struct pmcraid_instance *pinstance)1886{1887	u32 intrs;1888 1889	pmcraid_reinit_buffers(pinstance);1890	intrs = pmcraid_read_interrupts(pinstance);1891 1892	pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);1893 1894	if (intrs & INTRS_TRANSITION_TO_OPERATIONAL) {1895		if (!pinstance->interrupt_mode) {1896			iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,1897				pinstance->int_regs.1898				ioa_host_interrupt_mask_reg);1899			iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,1900				pinstance->int_regs.ioa_host_interrupt_clr_reg);1901		}1902		return 1;1903	} else {1904		return 0;1905	}1906}1907 1908/**1909 * pmcraid_soft_reset - performs a soft reset and makes IOA become ready1910 * @cmd : pointer to reset command block1911 *1912 * Return Value1913 *	none1914 */1915static void pmcraid_soft_reset(struct pmcraid_cmd *cmd)1916{1917	struct pmcraid_instance *pinstance = cmd->drv_inst;1918	u32 int_reg;1919	u32 doorbell;1920 1921	/* There will be an interrupt when Transition to Operational bit is1922	 * set so tasklet would execute next reset task. The timeout handler1923	 * would re-initiate a reset1924	 */1925	cmd->cmd_done = pmcraid_ioa_reset;1926	cmd->timer.expires = jiffies +1927			     msecs_to_jiffies(PMCRAID_TRANSOP_TIMEOUT);1928	cmd->timer.function = pmcraid_timeout_handler;1929 1930	if (!timer_pending(&cmd->timer))1931		add_timer(&cmd->timer);1932 1933	/* Enable destructive diagnostics on IOA if it is not yet in1934	 * operational state1935	 */1936	doorbell = DOORBELL_RUNTIME_RESET |1937		   DOORBELL_ENABLE_DESTRUCTIVE_DIAGS;1938 1939	/* Since we do RESET_ALERT and Start BIST we have to again write1940	 * MSIX Doorbell to indicate the interrupt mode1941	 */1942	if (pinstance->interrupt_mode) {1943		iowrite32(DOORBELL_INTR_MODE_MSIX,1944			  pinstance->int_regs.host_ioa_interrupt_reg);1945		ioread32(pinstance->int_regs.host_ioa_interrupt_reg);1946	}1947 1948	iowrite32(doorbell, pinstance->int_regs.host_ioa_interrupt_reg);1949	ioread32(pinstance->int_regs.host_ioa_interrupt_reg);1950	int_reg = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);1951 1952	pmcraid_info("Waiting for IOA to become operational %x:%x\n",1953		     ioread32(pinstance->int_regs.host_ioa_interrupt_reg),1954		     int_reg);1955}1956 1957/**1958 * pmcraid_get_dump - retrieves IOA dump in case of Unit Check interrupt1959 *1960 * @pinstance: pointer to adapter instance structure1961 *1962 * Return Value1963 *	none1964 */1965static void pmcraid_get_dump(struct pmcraid_instance *pinstance)1966{1967	pmcraid_info("%s is not yet implemented\n", __func__);1968}1969 1970/**1971 * pmcraid_fail_outstanding_cmds - Fails all outstanding ops.1972 * @pinstance: pointer to adapter instance structure1973 *1974 * This function fails all outstanding ops. If they are submitted to IOA1975 * already, it sends cancel all messages if IOA is still accepting IOARCBs,1976 * otherwise just completes the commands and returns the cmd blocks to free1977 * pool.1978 *1979 * Return value:1980 *	 none1981 */1982static void pmcraid_fail_outstanding_cmds(struct pmcraid_instance *pinstance)1983{1984	struct pmcraid_cmd *cmd, *temp;1985	unsigned long lock_flags;1986 1987	/* pending command list is protected by pending_pool_lock. Its1988	 * traversal must be done as within this lock1989	 */1990	spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);1991	list_for_each_entry_safe(cmd, temp, &pinstance->pending_cmd_pool,1992				 free_list) {1993		list_del(&cmd->free_list);1994		spin_unlock_irqrestore(&pinstance->pending_pool_lock,1995					lock_flags);1996		cmd->ioa_cb->ioasa.ioasc =1997			cpu_to_le32(PMCRAID_IOASC_IOA_WAS_RESET);1998		cmd->ioa_cb->ioasa.ilid =1999			cpu_to_le32(PMCRAID_DRIVER_ILID);2000 2001		/* In case the command timer is still running */2002		del_timer(&cmd->timer);2003 2004		/* If this is an IO command, complete it by invoking scsi_done2005		 * function. If this is one of the internal commands other2006		 * than pmcraid_ioa_reset and HCAM commands invoke cmd_done to2007		 * complete it2008		 */2009		if (cmd->scsi_cmd) {2010 2011			struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;2012			__le32 resp = cmd->ioa_cb->ioarcb.response_handle;2013 2014			scsi_cmd->result |= DID_ERROR << 16;2015 2016			scsi_dma_unmap(scsi_cmd);2017			pmcraid_return_cmd(cmd);2018 2019			pmcraid_info("failing(%d) CDB[0] = %x result: %x\n",2020				     le32_to_cpu(resp) >> 2,2021				     cmd->ioa_cb->ioarcb.cdb[0],2022				     scsi_cmd->result);2023			scsi_done(scsi_cmd);2024		} else if (cmd->cmd_done == pmcraid_internal_done ||2025			   cmd->cmd_done == pmcraid_erp_done) {2026			cmd->cmd_done(cmd);2027		} else if (cmd->cmd_done != pmcraid_ioa_reset &&2028			   cmd->cmd_done != pmcraid_ioa_shutdown_done) {2029			pmcraid_return_cmd(cmd);2030		}2031 2032		atomic_dec(&pinstance->outstanding_cmds);2033		spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);2034	}2035 2036	spin_unlock_irqrestore(&pinstance->pending_pool_lock, lock_flags);2037}2038 2039/**2040 * pmcraid_ioa_reset - Implementation of IOA reset logic2041 *2042 * @cmd: pointer to the cmd block to be used for entire reset process2043 *2044 * This function executes most of the steps required for IOA reset. This gets2045 * called by user threads (modprobe/insmod/rmmod) timer, tasklet and midlayer's2046 * 'eh_' thread. Access to variables used for controlling the reset sequence is2047 * synchronized using host lock. Various functions called during reset process2048 * would make use of a single command block, pointer to which is also stored in2049 * adapter instance structure.2050 *2051 * Return Value2052 *	 None2053 */2054static void pmcraid_ioa_reset(struct pmcraid_cmd *cmd)2055{2056	struct pmcraid_instance *pinstance = cmd->drv_inst;2057	u8 reset_complete = 0;2058 2059	pinstance->ioa_reset_in_progress = 1;2060 2061	if (pinstance->reset_cmd != cmd) {2062		pmcraid_err("reset is called with different command block\n");2063		pinstance->reset_cmd = cmd;2064	}2065 2066	pmcraid_info("reset_engine: state = %d, command = %p\n",2067		      pinstance->ioa_state, cmd);2068 2069	switch (pinstance->ioa_state) {2070 2071	case IOA_STATE_DEAD:2072		/* If IOA is offline, whatever may be the reset reason, just2073		 * return. callers might be waiting on the reset wait_q, wake2074		 * up them2075		 */2076		pmcraid_err("IOA is offline no reset is possible\n");2077		reset_complete = 1;2078		break;2079 2080	case IOA_STATE_IN_BRINGDOWN:2081		/* we enter here, once ioa shutdown command is processed by IOA2082		 * Alert IOA for a possible reset. If reset alert fails, IOA2083		 * goes through hard-reset2084		 */2085		pmcraid_disable_interrupts(pinstance, ~0);2086		pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;2087		pmcraid_reset_alert(cmd);2088		break;2089 2090	case IOA_STATE_UNKNOWN:2091		/* We may be called during probe or resume. Some pre-processing2092		 * is required for prior to reset2093		 */2094		scsi_block_requests(pinstance->host);2095 2096		/* If asked to reset while IOA was processing responses or2097		 * there are any error responses then IOA may require2098		 * hard-reset.2099		 */2100		if (pinstance->ioa_hard_reset == 0) {2101			if (ioread32(pinstance->ioa_status) &2102			    INTRS_TRANSITION_TO_OPERATIONAL) {2103				pmcraid_info("sticky bit set, bring-up\n");2104				pinstance->ioa_state = IOA_STATE_IN_BRINGUP;2105				pmcraid_reinit_cmdblk(cmd);2106				pmcraid_identify_hrrq(cmd);2107			} else {2108				pinstance->ioa_state = IOA_STATE_IN_SOFT_RESET;2109				pmcraid_soft_reset(cmd);2110			}2111		} else {2112			/* Alert IOA of a possible reset and wait for critical2113			 * operation in progress bit to reset2114			 */2115			pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;2116			pmcraid_reset_alert(cmd);2117		}2118		break;2119 2120	case IOA_STATE_IN_RESET_ALERT:2121		/* If critical operation in progress bit is reset or wait gets2122		 * timed out, reset proceeds with starting BIST on the IOA.2123		 * pmcraid_ioa_hard_reset keeps a count of reset attempts. If2124		 * they are 3 or more, reset engine marks IOA dead and returns2125		 */2126		pinstance->ioa_state = IOA_STATE_IN_HARD_RESET;2127		pmcraid_start_bist(cmd);2128		break;2129 2130	case IOA_STATE_IN_HARD_RESET:2131		pinstance->ioa_reset_attempts++;2132 2133		/* retry reset if we haven't reached maximum allowed limit */2134		if (pinstance->ioa_reset_attempts > PMCRAID_RESET_ATTEMPTS) {2135			pinstance->ioa_reset_attempts = 0;2136			pmcraid_err("IOA didn't respond marking it as dead\n");2137			pinstance->ioa_state = IOA_STATE_DEAD;2138 2139			if (pinstance->ioa_bringdown)2140				pmcraid_notify_ioastate(pinstance,2141					PMC_DEVICE_EVENT_SHUTDOWN_FAILED);2142			else2143				pmcraid_notify_ioastate(pinstance,2144						PMC_DEVICE_EVENT_RESET_FAILED);2145			reset_complete = 1;2146			break;2147		}2148 2149		/* Once either bist or pci reset is done, restore PCI config2150		 * space. If this fails, proceed with hard reset again2151		 */2152		pci_restore_state(pinstance->pdev);2153 2154		/* fail all pending commands */2155		pmcraid_fail_outstanding_cmds(pinstance);2156 2157		/* check if unit check is active, if so extract dump */2158		if (pinstance->ioa_unit_check) {2159			pmcraid_info("unit check is active\n");2160			pinstance->ioa_unit_check = 0;2161			pmcraid_get_dump(pinstance);2162			pinstance->ioa_reset_attempts--;2163			pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;2164			pmcraid_reset_alert(cmd);2165			break;2166		}2167 2168		/* if the reset reason is to bring-down the ioa, we might be2169		 * done with the reset restore pci_config_space and complete2170		 * the reset2171		 */2172		if (pinstance->ioa_bringdown) {2173			pmcraid_info("bringing down the adapter\n");2174			pinstance->ioa_shutdown_type = SHUTDOWN_NONE;2175			pinstance->ioa_bringdown = 0;2176			pinstance->ioa_state = IOA_STATE_UNKNOWN;2177			pmcraid_notify_ioastate(pinstance,2178					PMC_DEVICE_EVENT_SHUTDOWN_SUCCESS);2179			reset_complete = 1;2180		} else {2181			/* bring-up IOA, so proceed with soft reset2182			 * Reinitialize hrrq_buffers and their indices also2183			 * enable interrupts after a pci_restore_state2184			 */2185			if (pmcraid_reset_enable_ioa(pinstance)) {2186				pinstance->ioa_state = IOA_STATE_IN_BRINGUP;2187				pmcraid_info("bringing up the adapter\n");2188				pmcraid_reinit_cmdblk(cmd);2189				pmcraid_identify_hrrq(cmd);2190			} else {2191				pinstance->ioa_state = IOA_STATE_IN_SOFT_RESET;2192				pmcraid_soft_reset(cmd);2193			}2194		}2195		break;2196 2197	case IOA_STATE_IN_SOFT_RESET:2198		/* TRANSITION TO OPERATIONAL is on so start initialization2199		 * sequence2200		 */2201		pmcraid_info("In softreset proceeding with bring-up\n");2202		pinstance->ioa_state = IOA_STATE_IN_BRINGUP;2203 2204		/* Initialization commands start with HRRQ identification. From2205		 * now on tasklet completes most of the commands as IOA is up2206		 * and intrs are enabled2207		 */2208		pmcraid_identify_hrrq(cmd);2209		break;2210 2211	case IOA_STATE_IN_BRINGUP:2212		/* we are done with bringing up of IOA, change the ioa_state to2213		 * operational and wake up any waiters2214		 */2215		pinstance->ioa_state = IOA_STATE_OPERATIONAL;2216		reset_complete = 1;2217		break;2218 2219	case IOA_STATE_OPERATIONAL:2220	default:2221		/* When IOA is operational and a reset is requested, check for2222		 * the reset reason. If reset is to bring down IOA, unregister2223		 * HCAMs and initiate shutdown; if adapter reset is forced then2224		 * restart reset sequence again2225		 */2226		if (pinstance->ioa_shutdown_type == SHUTDOWN_NONE &&2227		    pinstance->force_ioa_reset == 0) {2228			pmcraid_notify_ioastate(pinstance,2229						PMC_DEVICE_EVENT_RESET_SUCCESS);2230			reset_complete = 1;2231		} else {2232			if (pinstance->ioa_shutdown_type != SHUTDOWN_NONE)2233				pinstance->ioa_state = IOA_STATE_IN_BRINGDOWN;2234			pmcraid_reinit_cmdblk(cmd);2235			pmcraid_unregister_hcams(cmd);2236		}2237		break;2238	}2239 2240	/* reset will be completed if ioa_state is either DEAD or UNKNOWN or2241	 * OPERATIONAL. Reset all control variables used during reset, wake up2242	 * any waiting threads and let the SCSI mid-layer send commands. Note2243	 * that host_lock must be held before invoking scsi_report_bus_reset.2244	 */2245	if (reset_complete) {2246		pinstance->ioa_reset_in_progress = 0;2247		pinstance->ioa_reset_attempts = 0;2248		pinstance->reset_cmd = NULL;2249		pinstance->ioa_shutdown_type = SHUTDOWN_NONE;2250		pinstance->ioa_bringdown = 0;2251		pmcraid_return_cmd(cmd);2252 2253		/* If target state is to bring up the adapter, proceed with2254		 * hcam registration and resource exposure to mid-layer.2255		 */2256		if (pinstance->ioa_state == IOA_STATE_OPERATIONAL)2257			pmcraid_register_hcams(pinstance);2258 2259		wake_up_all(&pinstance->reset_wait_q);2260	}2261 2262	return;2263}2264 2265/**2266 * pmcraid_initiate_reset - initiates reset sequence. This is called from2267 * ISR/tasklet during error interrupts including IOA unit check. If reset2268 * is already in progress, it just returns, otherwise initiates IOA reset2269 * to bring IOA up to operational state.2270 *2271 * @pinstance: pointer to adapter instance structure2272 *2273 * Return value2274 *	 none2275 */2276static void pmcraid_initiate_reset(struct pmcraid_instance *pinstance)2277{2278	struct pmcraid_cmd *cmd;2279 2280	/* If the reset is already in progress, just return, otherwise start2281	 * reset sequence and return2282	 */2283	if (!pinstance->ioa_reset_in_progress) {2284		scsi_block_requests(pinstance->host);2285		cmd = pmcraid_get_free_cmd(pinstance);2286 2287		if (cmd == NULL) {2288			pmcraid_err("no cmnd blocks for initiate_reset\n");2289			return;2290		}2291 2292		pinstance->ioa_shutdown_type = SHUTDOWN_NONE;2293		pinstance->reset_cmd = cmd;2294		pinstance->force_ioa_reset = 1;2295		pmcraid_notify_ioastate(pinstance,2296					PMC_DEVICE_EVENT_RESET_START);2297		pmcraid_ioa_reset(cmd);2298	}2299}2300 2301/**2302 * pmcraid_reset_reload - utility routine for doing IOA reset either to bringup2303 *			  or bringdown IOA2304 * @pinstance: pointer adapter instance structure2305 * @shutdown_type: shutdown type to be used NONE, NORMAL or ABRREV2306 * @target_state: expected target state after reset2307 *2308 * Note: This command initiates reset and waits for its completion. Hence this2309 * should not be called from isr/timer/tasklet functions (timeout handlers,2310 * error response handlers and interrupt handlers).2311 *2312 * Return Value2313 *	 1 in case ioa_state is not target_state, 0 otherwise.2314 */2315static int pmcraid_reset_reload(2316	struct pmcraid_instance *pinstance,2317	u8 shutdown_type,2318	u8 target_state2319)2320{2321	struct pmcraid_cmd *reset_cmd = NULL;2322	unsigned long lock_flags;2323	int reset = 1;2324 2325	spin_lock_irqsave(pinstance->host->host_lock, lock_flags);2326 2327	if (pinstance->ioa_reset_in_progress) {2328		pmcraid_info("reset_reload: reset is already in progress\n");2329 2330		spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);2331 2332		wait_event(pinstance->reset_wait_q,2333			   !pinstance->ioa_reset_in_progress);2334 2335		spin_lock_irqsave(pinstance->host->host_lock, lock_flags);2336 2337		if (pinstance->ioa_state == IOA_STATE_DEAD) {2338			pmcraid_info("reset_reload: IOA is dead\n");2339			goto out_unlock;2340		}2341 2342		if (pinstance->ioa_state == target_state) {2343			reset = 0;2344			goto out_unlock;2345		}2346	}2347 2348	pmcraid_info("reset_reload: proceeding with reset\n");2349	scsi_block_requests(pinstance->host);2350	reset_cmd = pmcraid_get_free_cmd(pinstance);2351	if (reset_cmd == NULL) {2352		pmcraid_err("no free cmnd for reset_reload\n");2353		goto out_unlock;2354	}2355 2356	if (shutdown_type == SHUTDOWN_NORMAL)2357		pinstance->ioa_bringdown = 1;2358 2359	pinstance->ioa_shutdown_type = shutdown_type;2360	pinstance->reset_cmd = reset_cmd;2361	pinstance->force_ioa_reset = reset;2362	pmcraid_info("reset_reload: initiating reset\n");2363	pmcraid_ioa_reset(reset_cmd);2364	spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);2365	pmcraid_info("reset_reload: waiting for reset to complete\n");2366	wait_event(pinstance->reset_wait_q,2367		   !pinstance->ioa_reset_in_progress);2368 2369	pmcraid_info("reset_reload: reset is complete !!\n");2370	scsi_unblock_requests(pinstance->host);2371	return pinstance->ioa_state != target_state;2372 2373out_unlock:2374	spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);2375	return reset;2376}2377 2378/**2379 * pmcraid_reset_bringdown - wrapper over pmcraid_reset_reload to bringdown IOA2380 *2381 * @pinstance: pointer to adapter instance structure2382 *2383 * Return Value2384 *	 whatever is returned from pmcraid_reset_reload2385 */2386static int pmcraid_reset_bringdown(struct pmcraid_instance *pinstance)2387{2388	return pmcraid_reset_reload(pinstance,2389				    SHUTDOWN_NORMAL,2390				    IOA_STATE_UNKNOWN);2391}2392 2393/**2394 * pmcraid_reset_bringup - wrapper over pmcraid_reset_reload to bring up IOA2395 *2396 * @pinstance: pointer to adapter instance structure2397 *2398 * Return Value2399 *	 whatever is returned from pmcraid_reset_reload2400 */2401static int pmcraid_reset_bringup(struct pmcraid_instance *pinstance)2402{2403	pmcraid_notify_ioastate(pinstance, PMC_DEVICE_EVENT_RESET_START);2404 2405	return pmcraid_reset_reload(pinstance,2406				    SHUTDOWN_NONE,2407				    IOA_STATE_OPERATIONAL);2408}2409 2410/**2411 * pmcraid_request_sense - Send request sense to a device2412 * @cmd: pmcraid command struct2413 *2414 * This function sends a request sense to a device as a result of a check2415 * condition. This method re-uses the same command block that failed earlier.2416 */2417static void pmcraid_request_sense(struct pmcraid_cmd *cmd)2418{2419	struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;2420	struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;2421	struct device *dev = &cmd->drv_inst->pdev->dev;2422 2423	cmd->sense_buffer = cmd->scsi_cmd->sense_buffer;2424	cmd->sense_buffer_dma = dma_map_single(dev, cmd->sense_buffer,2425			SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);2426	if (dma_mapping_error(dev, cmd->sense_buffer_dma)) {2427		pmcraid_err2428			("couldn't allocate sense buffer for request sense\n");2429		pmcraid_erp_done(cmd);2430		return;2431	}2432 2433	/* re-use the command block */2434	memset(&cmd->ioa_cb->ioasa, 0, sizeof(struct pmcraid_ioasa));2435	memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN);2436	ioarcb->request_flags0 = (SYNC_COMPLETE |2437				  NO_LINK_DESCS |2438				  INHIBIT_UL_CHECK);2439	ioarcb->request_type = REQ_TYPE_SCSI;2440	ioarcb->cdb[0] = REQUEST_SENSE;2441	ioarcb->cdb[4] = SCSI_SENSE_BUFFERSIZE;2442 2443	ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +2444					offsetof(struct pmcraid_ioarcb,2445						add_data.u.ioadl[0]));2446	ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));2447 2448	ioarcb->data_transfer_length = cpu_to_le32(SCSI_SENSE_BUFFERSIZE);2449 2450	ioadl->address = cpu_to_le64(cmd->sense_buffer_dma);2451	ioadl->data_len = cpu_to_le32(SCSI_SENSE_BUFFERSIZE);2452	ioadl->flags = IOADL_FLAGS_LAST_DESC;2453 2454	/* request sense might be called as part of error response processing2455	 * which runs in tasklets context. It is possible that mid-layer might2456	 * schedule queuecommand during this time, hence, writting to IOARRIN2457	 * must be protect by host_lock2458	 */2459	pmcraid_send_cmd(cmd, pmcraid_erp_done,2460			 PMCRAID_REQUEST_SENSE_TIMEOUT,2461			 pmcraid_timeout_handler);2462}2463 2464/**2465 * pmcraid_cancel_all - cancel all outstanding IOARCBs as part of error recovery2466 * @cmd: command that failed2467 * @need_sense: true if request_sense is required after cancel all2468 *2469 * This function sends a cancel all to a device to clear the queue.2470 */2471static void pmcraid_cancel_all(struct pmcraid_cmd *cmd, bool need_sense)2472{2473	struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;2474	struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;2475	struct pmcraid_resource_entry *res = scsi_cmd->device->hostdata;2476 2477	memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN);2478	ioarcb->request_flags0 = SYNC_OVERRIDE;2479	ioarcb->request_type = REQ_TYPE_IOACMD;2480	ioarcb->cdb[0] = PMCRAID_CANCEL_ALL_REQUESTS;2481 2482	if (RES_IS_GSCSI(res->cfg_entry))2483		ioarcb->cdb[1] = PMCRAID_SYNC_COMPLETE_AFTER_CANCEL;2484 2485	ioarcb->ioadl_bus_addr = 0;2486	ioarcb->ioadl_length = 0;2487	ioarcb->data_transfer_length = 0;2488	ioarcb->ioarcb_bus_addr &= cpu_to_le64((~0x1FULL));2489 2490	/* writing to IOARRIN must be protected by host_lock, as mid-layer2491	 * schedule queuecommand while we are doing this2492	 */2493	pmcraid_send_cmd(cmd, need_sense ?2494			 pmcraid_erp_done : pmcraid_request_sense,2495			 PMCRAID_REQUEST_SENSE_TIMEOUT,2496			 pmcraid_timeout_handler);2497}2498 2499/**2500 * pmcraid_frame_auto_sense: frame fixed format sense information2501 *2502 * @cmd: pointer to failing command block2503 *2504 * Return value2505 *  none2506 */2507static void pmcraid_frame_auto_sense(struct pmcraid_cmd *cmd)2508{2509	u8 *sense_buf = cmd->scsi_cmd->sense_buffer;2510	struct pmcraid_resource_entry *res = cmd->scsi_cmd->device->hostdata;2511	struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa;2512	u32 ioasc = le32_to_cpu(ioasa->ioasc);2513	u32 failing_lba = 0;2514 2515	memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);2516	cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;2517 2518	if (RES_IS_VSET(res->cfg_entry) &&2519	    ioasc == PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC &&2520	    ioasa->u.vset.failing_lba_hi != 0) {2521 2522		sense_buf[0] = 0x72;2523		sense_buf[1] = PMCRAID_IOASC_SENSE_KEY(ioasc);2524		sense_buf[2] = PMCRAID_IOASC_SENSE_CODE(ioasc);2525		sense_buf[3] = PMCRAID_IOASC_SENSE_QUAL(ioasc);2526 2527		sense_buf[7] = 12;2528		sense_buf[8] = 0;2529		sense_buf[9] = 0x0A;2530		sense_buf[10] = 0x80;2531 2532		failing_lba = le32_to_cpu(ioasa->u.vset.failing_lba_hi);2533 2534		sense_buf[12] = (failing_lba & 0xff000000) >> 24;2535		sense_buf[13] = (failing_lba & 0x00ff0000) >> 16;2536		sense_buf[14] = (failing_lba & 0x0000ff00) >> 8;2537		sense_buf[15] = failing_lba & 0x000000ff;2538 2539		failing_lba = le32_to_cpu(ioasa->u.vset.failing_lba_lo);2540 2541		sense_buf[16] = (failing_lba & 0xff000000) >> 24;2542		sense_buf[17] = (failing_lba & 0x00ff0000) >> 16;2543		sense_buf[18] = (failing_lba & 0x0000ff00) >> 8;2544		sense_buf[19] = failing_lba & 0x000000ff;2545	} else {2546		sense_buf[0] = 0x70;2547		sense_buf[2] = PMCRAID_IOASC_SENSE_KEY(ioasc);2548		sense_buf[12] = PMCRAID_IOASC_SENSE_CODE(ioasc);2549		sense_buf[13] = PMCRAID_IOASC_SENSE_QUAL(ioasc);2550 2551		if (ioasc == PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC) {2552			if (RES_IS_VSET(res->cfg_entry))2553				failing_lba =2554					le32_to_cpu(ioasa->u.2555						 vset.failing_lba_lo);2556			sense_buf[0] |= 0x80;2557			sense_buf[3] = (failing_lba >> 24) & 0xff;2558			sense_buf[4] = (failing_lba >> 16) & 0xff;2559			sense_buf[5] = (failing_lba >> 8) & 0xff;2560			sense_buf[6] = failing_lba & 0xff;2561		}2562 2563		sense_buf[7] = 6; /* additional length */2564	}2565}2566 2567/**2568 * pmcraid_error_handler - Error response handlers for a SCSI op2569 * @cmd: pointer to pmcraid_cmd that has failed2570 *2571 * This function determines whether or not to initiate ERP on the affected2572 * device. This is called from a tasklet, which doesn't hold any locks.2573 *2574 * Return value:2575 *	 0 it caller can complete the request, otherwise 1 where in error2576 *	 handler itself completes the request and returns the command block2577 *	 back to free-pool2578 */2579static int pmcraid_error_handler(struct pmcraid_cmd *cmd)2580{2581	struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;2582	struct pmcraid_resource_entry *res = scsi_cmd->device->hostdata;2583	struct pmcraid_instance *pinstance = cmd->drv_inst;2584	struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa;2585	u32 ioasc = le32_to_cpu(ioasa->ioasc);2586	u32 masked_ioasc = ioasc & PMCRAID_IOASC_SENSE_MASK;2587	bool sense_copied = false;2588 2589	if (!res) {2590		pmcraid_info("resource pointer is NULL\n");2591		return 0;2592	}2593 2594	/* If this was a SCSI read/write command keep count of errors */2595	if (SCSI_CMD_TYPE(scsi_cmd->cmnd[0]) == SCSI_READ_CMD)2596		atomic_inc(&res->read_failures);2597	else if (SCSI_CMD_TYPE(scsi_cmd->cmnd[0]) == SCSI_WRITE_CMD)2598		atomic_inc(&res->write_failures);2599 2600	if (!RES_IS_GSCSI(res->cfg_entry) &&2601		masked_ioasc != PMCRAID_IOASC_HW_DEVICE_BUS_STATUS_ERROR) {2602		pmcraid_frame_auto_sense(cmd);2603	}2604 2605	/* Log IOASC/IOASA information based on user settings */2606	pmcraid_ioasc_logger(ioasc, cmd);2607 2608	switch (masked_ioasc) {2609 2610	case PMCRAID_IOASC_AC_TERMINATED_BY_HOST:2611		scsi_cmd->result |= (DID_ABORT << 16);2612		break;2613 2614	case PMCRAID_IOASC_IR_INVALID_RESOURCE_HANDLE:2615	case PMCRAID_IOASC_HW_CANNOT_COMMUNICATE:2616		scsi_cmd->result |= (DID_NO_CONNECT << 16);2617		break;2618 2619	case PMCRAID_IOASC_NR_SYNC_REQUIRED:2620		res->sync_reqd = 1;2621		scsi_cmd->result |= (DID_IMM_RETRY << 16);2622		break;2623 2624	case PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC:2625		scsi_cmd->result |= (DID_PASSTHROUGH << 16);2626		break;2627 2628	case PMCRAID_IOASC_UA_BUS_WAS_RESET:2629	case PMCRAID_IOASC_UA_BUS_WAS_RESET_BY_OTHER:2630		if (!res->reset_progress)2631			scsi_report_bus_reset(pinstance->host,2632					      scsi_cmd->device->channel);2633		scsi_cmd->result |= (DID_ERROR << 16);2634		break;2635 2636	case PMCRAID_IOASC_HW_DEVICE_BUS_STATUS_ERROR:2637		scsi_cmd->result |= PMCRAID_IOASC_SENSE_STATUS(ioasc);2638		res->sync_reqd = 1;2639 2640		/* if check_condition is not active return with error otherwise2641		 * get/frame the sense buffer2642		 */2643		if (PMCRAID_IOASC_SENSE_STATUS(ioasc) !=2644		    SAM_STAT_CHECK_CONDITION &&2645		    PMCRAID_IOASC_SENSE_STATUS(ioasc) != SAM_STAT_ACA_ACTIVE)2646			return 0;2647 2648		/* If we have auto sense data as part of IOASA pass it to2649		 * mid-layer2650		 */2651		if (ioasa->auto_sense_length != 0) {2652			short sense_len = le16_to_cpu(ioasa->auto_sense_length);2653			int data_size = min_t(u16, sense_len,2654					      SCSI_SENSE_BUFFERSIZE);2655 2656			memcpy(scsi_cmd->sense_buffer,2657			       ioasa->sense_data,2658			       data_size);2659			sense_copied = true;2660		}2661 2662		if (RES_IS_GSCSI(res->cfg_entry))2663			pmcraid_cancel_all(cmd, sense_copied);2664		else if (sense_copied)2665			pmcraid_erp_done(cmd);2666		else2667			pmcraid_request_sense(cmd);2668 2669		return 1;2670 2671	case PMCRAID_IOASC_NR_INIT_CMD_REQUIRED:2672		break;2673 2674	default:2675		if (PMCRAID_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)2676			scsi_cmd->result |= (DID_ERROR << 16);2677		break;2678	}2679	return 0;2680}2681 2682/**2683 * pmcraid_reset_device - device reset handler functions2684 *2685 * @scsi_dev: scsi device struct2686 * @timeout: command timeout2687 * @modifier: reset modifier indicating the reset sequence to be performed2688 *2689 * This function issues a device reset to the affected device.2690 * A LUN reset will be sent to the device first. If that does2691 * not work, a target reset will be sent.2692 *2693 * Return value:2694 *	SUCCESS / FAILED2695 */2696static int pmcraid_reset_device(2697	struct scsi_device *scsi_dev,2698	unsigned long timeout,2699	u8 modifier)2700{2701	struct pmcraid_cmd *cmd;2702	struct pmcraid_instance *pinstance;2703	struct pmcraid_resource_entry *res;2704	struct pmcraid_ioarcb *ioarcb;2705	unsigned long lock_flags;2706	u32 ioasc;2707 2708	pinstance =2709		(struct pmcraid_instance *)scsi_dev->host->hostdata;2710	res = scsi_dev->hostdata;2711 2712	if (!res) {2713		sdev_printk(KERN_ERR, scsi_dev,2714			    "reset_device: NULL resource pointer\n");2715		return FAILED;2716	}2717 2718	/* If adapter is currently going through reset/reload, return failed.2719	 * This will force the mid-layer to call _eh_bus/host reset, which2720	 * will then go to sleep and wait for the reset to complete2721	 */2722	spin_lock_irqsave(pinstance->host->host_lock, lock_flags);2723	if (pinstance->ioa_reset_in_progress ||2724	    pinstance->ioa_state == IOA_STATE_DEAD) {2725		spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);2726		return FAILED;2727	}2728 2729	res->reset_progress = 1;2730	pmcraid_info("Resetting %s resource with addr %x\n",2731		     ((modifier & RESET_DEVICE_LUN) ? "LUN" :2732		     ((modifier & RESET_DEVICE_TARGET) ? "TARGET" : "BUS")),2733		     le32_to_cpu(res->cfg_entry.resource_address));2734 2735	/* get a free cmd block */2736	cmd = pmcraid_get_free_cmd(pinstance);2737 2738	if (cmd == NULL) {2739		spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);2740		pmcraid_err("%s: no cmd blocks are available\n", __func__);2741		return FAILED;2742	}2743 2744	ioarcb = &cmd->ioa_cb->ioarcb;2745	ioarcb->resource_handle = res->cfg_entry.resource_handle;2746	ioarcb->request_type = REQ_TYPE_IOACMD;2747	ioarcb->cdb[0] = PMCRAID_RESET_DEVICE;2748 2749	/* Initialize reset modifier bits */2750	if (modifier)2751		modifier = ENABLE_RESET_MODIFIER | modifier;2752 2753	ioarcb->cdb[1] = modifier;2754 2755	init_completion(&cmd->wait_for_completion);2756	cmd->completion_req = 1;2757 2758	pmcraid_info("cmd(CDB[0] = %x) for %x with index = %d\n",2759		     cmd->ioa_cb->ioarcb.cdb[0],2760		     le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle),2761		     le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2);2762 2763	pmcraid_send_cmd(cmd,2764			 pmcraid_internal_done,2765			 timeout,2766			 pmcraid_timeout_handler);2767 2768	spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);2769 2770	/* RESET_DEVICE command completes after all pending IOARCBs are2771	 * completed. Once this command is completed, pmcraind_internal_done2772	 * will wake up the 'completion' queue.2773	 */2774	wait_for_completion(&cmd->wait_for_completion);2775 2776	/* complete the command here itself and return the command block2777	 * to free list2778	 */2779	pmcraid_return_cmd(cmd);2780	res->reset_progress = 0;2781	ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);2782 2783	/* set the return value based on the returned ioasc */2784	return PMCRAID_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;2785}2786 2787/**2788 * _pmcraid_io_done - helper for pmcraid_io_done function2789 *2790 * @cmd: pointer to pmcraid command struct2791 * @reslen: residual data length to be set in the ioasa2792 * @ioasc: ioasc either returned by IOA or set by driver itself.2793 *2794 * This function is invoked by pmcraid_io_done to complete mid-layer2795 * scsi ops.2796 *2797 * Return value:2798 *	  0 if caller is required to return it to free_pool. Returns 1 if2799 *	  caller need not worry about freeing command block as error handler2800 *	  will take care of that.2801 */2802 2803static int _pmcraid_io_done(struct pmcraid_cmd *cmd, int reslen, int ioasc)2804{2805	struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;2806	int rc = 0;2807 2808	scsi_set_resid(scsi_cmd, reslen);2809 2810	pmcraid_info("response(%d) CDB[0] = %x ioasc:result: %x:%x\n",2811		le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2,2812		cmd->ioa_cb->ioarcb.cdb[0],2813		ioasc, scsi_cmd->result);2814 2815	if (PMCRAID_IOASC_SENSE_KEY(ioasc) != 0)2816		rc = pmcraid_error_handler(cmd);2817 2818	if (rc == 0) {2819		scsi_dma_unmap(scsi_cmd);2820		scsi_done(scsi_cmd);2821	}2822 2823	return rc;2824}2825 2826/**2827 * pmcraid_io_done - SCSI completion function2828 *2829 * @cmd: pointer to pmcraid command struct2830 *2831 * This function is invoked by tasklet/mid-layer error handler to completing2832 * the SCSI ops sent from mid-layer.2833 *2834 * Return value2835 *	  none2836 */2837 2838static void pmcraid_io_done(struct pmcraid_cmd *cmd)2839{2840	u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);2841	u32 reslen = le32_to_cpu(cmd->ioa_cb->ioasa.residual_data_length);2842 2843	if (_pmcraid_io_done(cmd, reslen, ioasc) == 0)2844		pmcraid_return_cmd(cmd);2845}2846 2847/**2848 * pmcraid_abort_cmd - Aborts a single IOARCB already submitted to IOA2849 *2850 * @cmd: command block of the command to be aborted2851 *2852 * Return Value:2853 *	 returns pointer to command structure used as cancelling cmd2854 */2855static struct pmcraid_cmd *pmcraid_abort_cmd(struct pmcraid_cmd *cmd)2856{2857	struct pmcraid_cmd *cancel_cmd;2858	struct pmcraid_instance *pinstance;2859 2860	pinstance = (struct pmcraid_instance *)cmd->drv_inst;2861 2862	cancel_cmd = pmcraid_get_free_cmd(pinstance);2863 2864	if (cancel_cmd == NULL) {2865		pmcraid_err("%s: no cmd blocks are available\n", __func__);2866		return NULL;2867	}2868 2869	pmcraid_prepare_cancel_cmd(cancel_cmd, cmd);2870 2871	pmcraid_info("aborting command CDB[0]= %x with index = %d\n",2872		cmd->ioa_cb->ioarcb.cdb[0],2873		le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2);2874 2875	init_completion(&cancel_cmd->wait_for_completion);2876	cancel_cmd->completion_req = 1;2877 2878	pmcraid_info("command (%d) CDB[0] = %x for %x\n",2879		le32_to_cpu(cancel_cmd->ioa_cb->ioarcb.response_handle) >> 2,2880		cancel_cmd->ioa_cb->ioarcb.cdb[0],2881		le32_to_cpu(cancel_cmd->ioa_cb->ioarcb.resource_handle));2882 2883	pmcraid_send_cmd(cancel_cmd,2884			 pmcraid_internal_done,2885			 PMCRAID_INTERNAL_TIMEOUT,2886			 pmcraid_timeout_handler);2887	return cancel_cmd;2888}2889 2890/**2891 * pmcraid_abort_complete - Waits for ABORT TASK completion2892 *2893 * @cancel_cmd: command block use as cancelling command2894 *2895 * Return Value:2896 *	 returns SUCCESS if ABORT TASK has good completion2897 *	 otherwise FAILED2898 */2899static int pmcraid_abort_complete(struct pmcraid_cmd *cancel_cmd)2900{2901	struct pmcraid_resource_entry *res;2902	u32 ioasc;2903 2904	wait_for_completion(&cancel_cmd->wait_for_completion);2905	res = cancel_cmd->res;2906	cancel_cmd->res = NULL;2907	ioasc = le32_to_cpu(cancel_cmd->ioa_cb->ioasa.ioasc);2908 2909	/* If the abort task is not timed out we will get a Good completion2910	 * as sense_key, otherwise we may get one the following responses2911	 * due to subsequent bus reset or device reset. In case IOASC is2912	 * NR_SYNC_REQUIRED, set sync_reqd flag for the corresponding resource2913	 */2914	if (ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET ||2915	    ioasc == PMCRAID_IOASC_NR_SYNC_REQUIRED) {2916		if (ioasc == PMCRAID_IOASC_NR_SYNC_REQUIRED)2917			res->sync_reqd = 1;2918		ioasc = 0;2919	}2920 2921	/* complete the command here itself */2922	pmcraid_return_cmd(cancel_cmd);2923	return PMCRAID_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;2924}2925 2926/**2927 * pmcraid_eh_abort_handler - entry point for aborting a single task on errors2928 *2929 * @scsi_cmd:   scsi command struct given by mid-layer. When this is called2930 *		mid-layer ensures that no other commands are queued. This2931 *		never gets called under interrupt, but a separate eh thread.2932 *2933 * Return value:2934 *	 SUCCESS / FAILED2935 */2936static int pmcraid_eh_abort_handler(struct scsi_cmnd *scsi_cmd)2937{2938	struct pmcraid_instance *pinstance;2939	struct pmcraid_cmd *cmd;2940	struct pmcraid_resource_entry *res;2941	unsigned long host_lock_flags;2942	unsigned long pending_lock_flags;2943	struct pmcraid_cmd *cancel_cmd = NULL;2944	int cmd_found = 0;2945	int rc = FAILED;2946 2947	pinstance =2948		(struct pmcraid_instance *)scsi_cmd->device->host->hostdata;2949 2950	scmd_printk(KERN_INFO, scsi_cmd,2951		    "I/O command timed out, aborting it.\n");2952 2953	res = scsi_cmd->device->hostdata;2954 2955	if (res == NULL)2956		return rc;2957 2958	/* If we are currently going through reset/reload, return failed.2959	 * This will force the mid-layer to eventually call2960	 * pmcraid_eh_host_reset which will then go to sleep and wait for the2961	 * reset to complete2962	 */2963	spin_lock_irqsave(pinstance->host->host_lock, host_lock_flags);2964 2965	if (pinstance->ioa_reset_in_progress ||2966	    pinstance->ioa_state == IOA_STATE_DEAD) {2967		spin_unlock_irqrestore(pinstance->host->host_lock,2968				       host_lock_flags);2969		return rc;2970	}2971 2972	/* loop over pending cmd list to find cmd corresponding to this2973	 * scsi_cmd. Note that this command might not have been completed2974	 * already. locking: all pending commands are protected with2975	 * pending_pool_lock.2976	 */2977	spin_lock_irqsave(&pinstance->pending_pool_lock, pending_lock_flags);2978	list_for_each_entry(cmd, &pinstance->pending_cmd_pool, free_list) {2979 2980		if (cmd->scsi_cmd == scsi_cmd) {2981			cmd_found = 1;2982			break;2983		}2984	}2985 2986	spin_unlock_irqrestore(&pinstance->pending_pool_lock,2987				pending_lock_flags);2988 2989	/* If the command to be aborted was given to IOA and still pending with2990	 * it, send ABORT_TASK to abort this and wait for its completion2991	 */2992	if (cmd_found)2993		cancel_cmd = pmcraid_abort_cmd(cmd);2994 2995	spin_unlock_irqrestore(pinstance->host->host_lock,2996			       host_lock_flags);2997 2998	if (cancel_cmd) {2999		cancel_cmd->res = cmd->scsi_cmd->device->hostdata;3000		rc = pmcraid_abort_complete(cancel_cmd);3001	}3002 3003	return cmd_found ? rc : SUCCESS;3004}3005 3006/**3007 * pmcraid_eh_device_reset_handler - bus/target/device reset handler callbacks3008 *3009 * @scmd: pointer to scsi_cmd that was sent to the resource to be reset.3010 *3011 * All these routines invokve pmcraid_reset_device with appropriate parameters.3012 * Since these are called from mid-layer EH thread, no other IO will be queued3013 * to the resource being reset. However, control path (IOCTL) may be active so3014 * it is necessary to synchronize IOARRIN writes which pmcraid_reset_device3015 * takes care by locking/unlocking host_lock.3016 *3017 * Return value3018 *	SUCCESS or FAILED3019 */3020static int pmcraid_eh_device_reset_handler(struct scsi_cmnd *scmd)3021{3022	scmd_printk(KERN_INFO, scmd,3023		    "resetting device due to an I/O command timeout.\n");3024	return pmcraid_reset_device(scmd->device,3025				    PMCRAID_INTERNAL_TIMEOUT,3026				    RESET_DEVICE_LUN);3027}3028 3029static int pmcraid_eh_bus_reset_handler(struct scsi_cmnd *scmd)3030{3031	struct Scsi_Host *host = scmd->device->host;3032	struct pmcraid_instance *pinstance =3033		(struct pmcraid_instance *)host->hostdata;3034	struct pmcraid_resource_entry *res = NULL;3035	struct pmcraid_resource_entry *temp;3036	struct scsi_device *sdev = NULL;3037	unsigned long lock_flags;3038 3039	/*3040	 * The reset device code insists on us passing down3041	 * a device, so grab the first device on the bus.3042	 */3043	spin_lock_irqsave(&pinstance->resource_lock, lock_flags);3044	list_for_each_entry(temp, &pinstance->used_res_q, queue) {3045		if (scmd->device->channel == PMCRAID_VSET_BUS_ID &&3046		    RES_IS_VSET(temp->cfg_entry)) {3047			res = temp;3048			break;3049		} else if (scmd->device->channel == PMCRAID_PHYS_BUS_ID &&3050			   RES_IS_GSCSI(temp->cfg_entry)) {3051			res = temp;3052			break;3053		}3054	}3055	if (res)3056		sdev = res->scsi_dev;3057	spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);3058	if (!sdev)3059		return FAILED;3060 3061	sdev_printk(KERN_INFO, sdev,3062		    "Doing bus reset due to an I/O command timeout.\n");3063	return pmcraid_reset_device(sdev,3064				    PMCRAID_RESET_BUS_TIMEOUT,3065				    RESET_DEVICE_BUS);3066}3067 3068static int pmcraid_eh_target_reset_handler(struct scsi_cmnd *scmd)3069{3070	struct Scsi_Host *shost = scmd->device->host;3071	struct scsi_device *scsi_dev = NULL, *tmp;3072	int ret;3073 3074	shost_for_each_device(tmp, shost) {3075		if ((tmp->channel == scmd->device->channel) &&3076		    (tmp->id == scmd->device->id)) {3077			scsi_dev = tmp;3078			break;3079		}3080	}3081	if (!scsi_dev)3082		return FAILED;3083	sdev_printk(KERN_INFO, scsi_dev,3084		    "Doing target reset due to an I/O command timeout.\n");3085	ret = pmcraid_reset_device(scsi_dev,3086				   PMCRAID_INTERNAL_TIMEOUT,3087				   RESET_DEVICE_TARGET);3088	scsi_device_put(scsi_dev);3089	return ret;3090}3091 3092/**3093 * pmcraid_eh_host_reset_handler - adapter reset handler callback3094 *3095 * @scmd: pointer to scsi_cmd that was sent to a resource of adapter3096 *3097 * Initiates adapter reset to bring it up to operational state3098 *3099 * Return value3100 *	SUCCESS or FAILED3101 */3102static int pmcraid_eh_host_reset_handler(struct scsi_cmnd *scmd)3103{3104	unsigned long interval = 10000; /* 10 seconds interval */3105	int waits = jiffies_to_msecs(PMCRAID_RESET_HOST_TIMEOUT) / interval;3106	struct pmcraid_instance *pinstance =3107		(struct pmcraid_instance *)(scmd->device->host->hostdata);3108 3109 3110	/* wait for an additional 150 seconds just in case firmware could come3111	 * up and if it could complete all the pending commands excluding the3112	 * two HCAM (CCN and LDN).3113	 */3114	while (waits--) {3115		if (atomic_read(&pinstance->outstanding_cmds) <=3116		    PMCRAID_MAX_HCAM_CMD)3117			return SUCCESS;3118		msleep(interval);3119	}3120 3121	dev_err(&pinstance->pdev->dev,3122		"Adapter being reset due to an I/O command timeout.\n");3123	return pmcraid_reset_bringup(pinstance) == 0 ? SUCCESS : FAILED;3124}3125 3126/**3127 * pmcraid_init_ioadls - initializes IOADL related fields in IOARCB3128 * @cmd: pmcraid command struct3129 * @sgcount: count of scatter-gather elements3130 *3131 * Return value3132 *   returns pointer pmcraid_ioadl_desc, initialized to point to internal3133 *   or external IOADLs3134 */3135static struct pmcraid_ioadl_desc *3136pmcraid_init_ioadls(struct pmcraid_cmd *cmd, int sgcount)3137{3138	struct pmcraid_ioadl_desc *ioadl;3139	struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;3140	int ioadl_count = 0;3141 3142	if (ioarcb->add_cmd_param_length)3143		ioadl_count = DIV_ROUND_UP(le16_to_cpu(ioarcb->add_cmd_param_length), 16);3144	ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc) * sgcount);3145 3146	if ((sgcount + ioadl_count) > (ARRAY_SIZE(ioarcb->add_data.u.ioadl))) {3147		/* external ioadls start at offset 0x80 from control_block3148		 * structure, re-using 24 out of 27 ioadls part of IOARCB.3149		 * It is necessary to indicate to firmware that driver is3150		 * using ioadls to be treated as external to IOARCB.3151		 */3152		ioarcb->ioarcb_bus_addr &= cpu_to_le64(~(0x1FULL));3153		ioarcb->ioadl_bus_addr =3154			cpu_to_le64((cmd->ioa_cb_bus_addr) +3155				offsetof(struct pmcraid_ioarcb,3156					add_data.u.ioadl[3]));3157		ioadl = &ioarcb->add_data.u.ioadl[3];3158	} else {3159		ioarcb->ioadl_bus_addr =3160			cpu_to_le64((cmd->ioa_cb_bus_addr) +3161				offsetof(struct pmcraid_ioarcb,3162					add_data.u.ioadl[ioadl_count]));3163 3164		ioadl = &ioarcb->add_data.u.ioadl[ioadl_count];3165		ioarcb->ioarcb_bus_addr |=3166			cpu_to_le64(DIV_ROUND_CLOSEST(sgcount + ioadl_count, 8));3167	}3168 3169	return ioadl;3170}3171 3172/**3173 * pmcraid_build_ioadl - Build a scatter/gather list and map the buffer3174 * @pinstance: pointer to adapter instance structure3175 * @cmd: pmcraid command struct3176 *3177 * This function is invoked by queuecommand entry point while sending a command3178 * to firmware. This builds ioadl descriptors and sets up ioarcb fields.3179 *3180 * Return value:3181 *	0 on success or -1 on failure3182 */3183static int pmcraid_build_ioadl(3184	struct pmcraid_instance *pinstance,3185	struct pmcraid_cmd *cmd3186)3187{3188	int i, nseg;3189	struct scatterlist *sglist;3190 3191	struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;3192	struct pmcraid_ioarcb *ioarcb = &(cmd->ioa_cb->ioarcb);3193	struct pmcraid_ioadl_desc *ioadl;3194 3195	u32 length = scsi_bufflen(scsi_cmd);3196 3197	if (!length)3198		return 0;3199 3200	nseg = scsi_dma_map(scsi_cmd);3201 3202	if (nseg < 0) {3203		scmd_printk(KERN_ERR, scsi_cmd, "scsi_map_dma failed!\n");3204		return -1;3205	} else if (nseg > PMCRAID_MAX_IOADLS) {3206		scsi_dma_unmap(scsi_cmd);3207		scmd_printk(KERN_ERR, scsi_cmd,3208			"sg count is (%d) more than allowed!\n", nseg);3209		return -1;3210	}3211 3212	/* Initialize IOARCB data transfer length fields */3213	if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE)3214		ioarcb->request_flags0 |= TRANSFER_DIR_WRITE;3215 3216	ioarcb->request_flags0 |= NO_LINK_DESCS;3217	ioarcb->data_transfer_length = cpu_to_le32(length);3218	ioadl = pmcraid_init_ioadls(cmd, nseg);3219 3220	/* Initialize IOADL descriptor addresses */3221	scsi_for_each_sg(scsi_cmd, sglist, nseg, i) {3222		ioadl[i].data_len = cpu_to_le32(sg_dma_len(sglist));3223		ioadl[i].address = cpu_to_le64(sg_dma_address(sglist));3224		ioadl[i].flags = 0;3225	}3226	/* setup last descriptor */3227	ioadl[i - 1].flags = IOADL_FLAGS_LAST_DESC;3228 3229	return 0;3230}3231 3232/**3233 * pmcraid_queuecommand_lck - Queue a mid-layer request3234 * @scsi_cmd: scsi command struct3235 *3236 * This function queues a request generated by the mid-layer. Midlayer calls3237 * this routine within host->lock. Some of the functions called by queuecommand3238 * would use cmd block queue locks (free_pool_lock and pending_pool_lock)3239 *3240 * Return value:3241 *	  0 on success3242 *	  SCSI_MLQUEUE_DEVICE_BUSY if device is busy3243 *	  SCSI_MLQUEUE_HOST_BUSY if host is busy3244 */3245static int pmcraid_queuecommand_lck(struct scsi_cmnd *scsi_cmd)3246{3247	struct pmcraid_instance *pinstance;3248	struct pmcraid_resource_entry *res;3249	struct pmcraid_ioarcb *ioarcb;3250	struct pmcraid_cmd *cmd;3251	u32 fw_version;3252	int rc = 0;3253 3254	pinstance =3255		(struct pmcraid_instance *)scsi_cmd->device->host->hostdata;3256	fw_version = be16_to_cpu(pinstance->inq_data->fw_version);3257	res = scsi_cmd->device->hostdata;3258	scsi_cmd->result = (DID_OK << 16);3259 3260	/* if adapter is marked as dead, set result to DID_NO_CONNECT complete3261	 * the command3262	 */3263	if (pinstance->ioa_state == IOA_STATE_DEAD) {3264		pmcraid_info("IOA is dead, but queuecommand is scheduled\n");3265		scsi_cmd->result = (DID_NO_CONNECT << 16);3266		scsi_done(scsi_cmd);3267		return 0;3268	}3269 3270	/* If IOA reset is in progress, can't queue the commands */3271	if (pinstance->ioa_reset_in_progress)3272		return SCSI_MLQUEUE_HOST_BUSY;3273 3274	/* Firmware doesn't support SYNCHRONIZE_CACHE command (0x35), complete3275	 * the command here itself with success return3276	 */3277	if (scsi_cmd->cmnd[0] == SYNCHRONIZE_CACHE) {3278		pmcraid_info("SYNC_CACHE(0x35), completing in driver itself\n");3279		scsi_done(scsi_cmd);3280		return 0;3281	}3282 3283	/* initialize the command and IOARCB to be sent to IOA */3284	cmd = pmcraid_get_free_cmd(pinstance);3285 3286	if (cmd == NULL) {3287		pmcraid_err("free command block is not available\n");3288		return SCSI_MLQUEUE_HOST_BUSY;3289	}3290 3291	cmd->scsi_cmd = scsi_cmd;3292	ioarcb = &(cmd->ioa_cb->ioarcb);3293	memcpy(ioarcb->cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);3294	ioarcb->resource_handle = res->cfg_entry.resource_handle;3295	ioarcb->request_type = REQ_TYPE_SCSI;3296 3297	/* set hrrq number where the IOA should respond to. Note that all cmds3298	 * generated internally uses hrrq_id 0, exception to this is the cmd3299	 * block of scsi_cmd which is re-used (e.g. cancel/abort), which uses3300	 * hrrq_id assigned here in queuecommand3301	 */3302	ioarcb->hrrq_id = atomic_add_return(1, &(pinstance->last_message_id)) %3303			  pinstance->num_hrrq;3304	cmd->cmd_done = pmcraid_io_done;3305 3306	if (RES_IS_GSCSI(res->cfg_entry) || RES_IS_VSET(res->cfg_entry)) {3307		if (scsi_cmd->underflow == 0)3308			ioarcb->request_flags0 |= INHIBIT_UL_CHECK;3309 3310		if (res->sync_reqd) {3311			ioarcb->request_flags0 |= SYNC_COMPLETE;3312			res->sync_reqd = 0;3313		}3314 3315		ioarcb->request_flags0 |= NO_LINK_DESCS;3316 3317		if (scsi_cmd->flags & SCMD_TAGGED)3318			ioarcb->request_flags1 |= TASK_TAG_SIMPLE;3319 3320		if (RES_IS_GSCSI(res->cfg_entry))3321			ioarcb->request_flags1 |= DELAY_AFTER_RESET;3322	}3323 3324	rc = pmcraid_build_ioadl(pinstance, cmd);3325 3326	pmcraid_info("command (%d) CDB[0] = %x for %x:%x:%x:%x\n",3327		     le32_to_cpu(ioarcb->response_handle) >> 2,3328		     scsi_cmd->cmnd[0], pinstance->host->unique_id,3329		     RES_IS_VSET(res->cfg_entry) ? PMCRAID_VSET_BUS_ID :3330			PMCRAID_PHYS_BUS_ID,3331		     RES_IS_VSET(res->cfg_entry) ?3332			(fw_version <= PMCRAID_FW_VERSION_1 ?3333				res->cfg_entry.unique_flags1 :3334				le16_to_cpu(res->cfg_entry.array_id) & 0xFF) :3335			RES_TARGET(res->cfg_entry.resource_address),3336		     RES_LUN(res->cfg_entry.resource_address));3337 3338	if (likely(rc == 0)) {3339		_pmcraid_fire_command(cmd);3340	} else {3341		pmcraid_err("queuecommand could not build ioadl\n");3342		pmcraid_return_cmd(cmd);3343		rc = SCSI_MLQUEUE_HOST_BUSY;3344	}3345 3346	return rc;3347}3348 3349static DEF_SCSI_QCMD(pmcraid_queuecommand)3350 3351/*3352 * pmcraid_open -char node "open" entry, allowed only users with admin access3353 */3354static int pmcraid_chr_open(struct inode *inode, struct file *filep)3355{3356	struct pmcraid_instance *pinstance;3357 3358	if (!capable(CAP_SYS_ADMIN))3359		return -EACCES;3360 3361	/* Populate adapter instance * pointer for use by ioctl */3362	pinstance = container_of(inode->i_cdev, struct pmcraid_instance, cdev);3363	filep->private_data = pinstance;3364 3365	return 0;3366}3367 3368/*3369 * pmcraid_fasync - Async notifier registration from applications3370 *3371 * This function adds the calling process to a driver global queue. When an3372 * event occurs, SIGIO will be sent to all processes in this queue.3373 */3374static int pmcraid_chr_fasync(int fd, struct file *filep, int mode)3375{3376	struct pmcraid_instance *pinstance;3377	int rc;3378 3379	pinstance = filep->private_data;3380	mutex_lock(&pinstance->aen_queue_lock);3381	rc = fasync_helper(fd, filep, mode, &pinstance->aen_queue);3382	mutex_unlock(&pinstance->aen_queue_lock);3383 3384	return rc;3385}3386 3387/**3388 * pmcraid_ioctl_driver - ioctl handler for commands handled by driver itself3389 *3390 * @pinstance: pointer to adapter instance structure3391 * @cmd: ioctl command passed in3392 * @buflen: length of user_buffer3393 * @user_buffer: user buffer pointer3394 *3395 * Return Value3396 *   0 in case of success, otherwise appropriate error code3397 */3398static long pmcraid_ioctl_driver(3399	struct pmcraid_instance *pinstance,3400	unsigned int cmd,3401	unsigned int buflen,3402	void __user *user_buffer3403)3404{3405	int rc = -ENOSYS;3406 3407	switch (cmd) {3408	case PMCRAID_IOCTL_RESET_ADAPTER:3409		pmcraid_reset_bringup(pinstance);3410		rc = 0;3411		break;3412 3413	default:3414		break;3415	}3416 3417	return rc;3418}3419 3420/**3421 * pmcraid_check_ioctl_buffer - check for proper access to user buffer3422 *3423 * @cmd: ioctl command3424 * @arg: user buffer3425 * @hdr: pointer to kernel memory for pmcraid_ioctl_header3426 *3427 * Return Value3428 *	negetive error code if there are access issues, otherwise zero.3429 *	Upon success, returns ioctl header copied out of user buffer.3430 */3431 3432static int pmcraid_check_ioctl_buffer(3433	int cmd,3434	void __user *arg,3435	struct pmcraid_ioctl_header *hdr3436)3437{3438	int rc;3439 3440	if (copy_from_user(hdr, arg, sizeof(struct pmcraid_ioctl_header))) {3441		pmcraid_err("couldn't copy ioctl header from user buffer\n");3442		return -EFAULT;3443	}3444 3445	/* check for valid driver signature */3446	rc = memcmp(hdr->signature,3447		    PMCRAID_IOCTL_SIGNATURE,3448		    sizeof(hdr->signature));3449	if (rc) {3450		pmcraid_err("signature verification failed\n");3451		return -EINVAL;3452	}3453 3454	return 0;3455}3456 3457/*3458 *  pmcraid_ioctl - char node ioctl entry point3459 */3460static long pmcraid_chr_ioctl(3461	struct file *filep,3462	unsigned int cmd,3463	unsigned long arg3464)3465{3466	struct pmcraid_instance *pinstance = NULL;3467	struct pmcraid_ioctl_header *hdr = NULL;3468	void __user *argp = (void __user *)arg;3469	int retval = -ENOTTY;3470 3471	hdr = kmalloc(sizeof(struct pmcraid_ioctl_header), GFP_KERNEL);3472 3473	if (!hdr) {3474		pmcraid_err("failed to allocate memory for ioctl header\n");3475		return -ENOMEM;3476	}3477 3478	retval = pmcraid_check_ioctl_buffer(cmd, argp, hdr);3479 3480	if (retval) {3481		pmcraid_info("chr_ioctl: header check failed\n");3482		kfree(hdr);3483		return retval;3484	}3485 3486	pinstance = filep->private_data;3487 3488	if (!pinstance) {3489		pmcraid_info("adapter instance is not found\n");3490		kfree(hdr);3491		return -ENOTTY;3492	}3493 3494	switch (_IOC_TYPE(cmd)) {3495 3496	case PMCRAID_DRIVER_IOCTL:3497		arg += sizeof(struct pmcraid_ioctl_header);3498		retval = pmcraid_ioctl_driver(pinstance, cmd,3499					      hdr->buffer_length, argp);3500		break;3501 3502	default:3503		retval = -ENOTTY;3504		break;3505	}3506 3507	kfree(hdr);3508 3509	return retval;3510}3511 3512/*3513 * File operations structure for management interface3514 */3515static const struct file_operations pmcraid_fops = {3516	.owner = THIS_MODULE,3517	.open = pmcraid_chr_open,3518	.fasync = pmcraid_chr_fasync,3519	.unlocked_ioctl = pmcraid_chr_ioctl,3520	.compat_ioctl = compat_ptr_ioctl,3521	.llseek = noop_llseek,3522};3523 3524 3525 3526 3527/**3528 * pmcraid_show_log_level - Display adapter's error logging level3529 * @dev: class device struct3530 * @attr: unused3531 * @buf: buffer3532 *3533 * Return value:3534 *  number of bytes printed to buffer3535 */3536static ssize_t pmcraid_show_log_level(3537	struct device *dev,3538	struct device_attribute *attr,3539	char *buf)3540{3541	struct Scsi_Host *shost = class_to_shost(dev);3542	struct pmcraid_instance *pinstance =3543		(struct pmcraid_instance *)shost->hostdata;3544	return snprintf(buf, PAGE_SIZE, "%d\n", pinstance->current_log_level);3545}3546 3547/**3548 * pmcraid_store_log_level - Change the adapter's error logging level3549 * @dev: class device struct3550 * @attr: unused3551 * @buf: buffer3552 * @count: not used3553 *3554 * Return value:3555 *  number of bytes printed to buffer3556 */3557static ssize_t pmcraid_store_log_level(3558	struct device *dev,3559	struct device_attribute *attr,3560	const char *buf,3561	size_t count3562)3563{3564	struct Scsi_Host *shost;3565	struct pmcraid_instance *pinstance;3566	u8 val;3567 3568	if (kstrtou8(buf, 10, &val))3569		return -EINVAL;3570	/* log-level should be from 0 to 2 */3571	if (val > 2)3572		return -EINVAL;3573 3574	shost = class_to_shost(dev);3575	pinstance = (struct pmcraid_instance *)shost->hostdata;3576	pinstance->current_log_level = val;3577 3578	return strlen(buf);3579}3580 3581static struct device_attribute pmcraid_log_level_attr = {3582	.attr = {3583		 .name = "log_level",3584		 .mode = S_IRUGO | S_IWUSR,3585		 },3586	.show = pmcraid_show_log_level,3587	.store = pmcraid_store_log_level,3588};3589 3590/**3591 * pmcraid_show_drv_version - Display driver version3592 * @dev: class device struct3593 * @attr: unused3594 * @buf: buffer3595 *3596 * Return value:3597 *  number of bytes printed to buffer3598 */3599static ssize_t pmcraid_show_drv_version(3600	struct device *dev,3601	struct device_attribute *attr,3602	char *buf3603)3604{3605	return snprintf(buf, PAGE_SIZE, "version: %s\n",3606			PMCRAID_DRIVER_VERSION);3607}3608 3609static struct device_attribute pmcraid_driver_version_attr = {3610	.attr = {3611		 .name = "drv_version",3612		 .mode = S_IRUGO,3613		 },3614	.show = pmcraid_show_drv_version,3615};3616 3617/**3618 * pmcraid_show_adapter_id - Display driver assigned adapter id3619 * @dev: class device struct3620 * @attr: unused3621 * @buf: buffer3622 *3623 * Return value:3624 *  number of bytes printed to buffer3625 */3626static ssize_t pmcraid_show_adapter_id(3627	struct device *dev,3628	struct device_attribute *attr,3629	char *buf3630)3631{3632	struct Scsi_Host *shost = class_to_shost(dev);3633	struct pmcraid_instance *pinstance =3634		(struct pmcraid_instance *)shost->hostdata;3635	u32 adapter_id = pci_dev_id(pinstance->pdev);3636	u32 aen_group = pmcraid_event_family.id;3637 3638	return snprintf(buf, PAGE_SIZE,3639			"adapter id: %d\nminor: %d\naen group: %d\n",3640			adapter_id, MINOR(pinstance->cdev.dev), aen_group);3641}3642 3643static struct device_attribute pmcraid_adapter_id_attr = {3644	.attr = {3645		 .name = "adapter_id",3646		 .mode = S_IRUGO,3647		 },3648	.show = pmcraid_show_adapter_id,3649};3650 3651static struct attribute *pmcraid_host_attrs[] = {3652	&pmcraid_log_level_attr.attr,3653	&pmcraid_driver_version_attr.attr,3654	&pmcraid_adapter_id_attr.attr,3655	NULL,3656};3657 3658ATTRIBUTE_GROUPS(pmcraid_host);3659 3660/* host template structure for pmcraid driver */3661static const struct scsi_host_template pmcraid_host_template = {3662	.module = THIS_MODULE,3663	.name = PMCRAID_DRIVER_NAME,3664	.queuecommand = pmcraid_queuecommand,3665	.eh_abort_handler = pmcraid_eh_abort_handler,3666	.eh_bus_reset_handler = pmcraid_eh_bus_reset_handler,3667	.eh_target_reset_handler = pmcraid_eh_target_reset_handler,3668	.eh_device_reset_handler = pmcraid_eh_device_reset_handler,3669	.eh_host_reset_handler = pmcraid_eh_host_reset_handler,3670 3671	.slave_alloc = pmcraid_slave_alloc,3672	.device_configure = pmcraid_device_configure,3673	.slave_destroy = pmcraid_slave_destroy,3674	.change_queue_depth = pmcraid_change_queue_depth,3675	.can_queue = PMCRAID_MAX_IO_CMD,3676	.this_id = -1,3677	.sg_tablesize = PMCRAID_MAX_IOADLS,3678	.max_sectors = PMCRAID_IOA_MAX_SECTORS,3679	.no_write_same = 1,3680	.cmd_per_lun = PMCRAID_MAX_CMD_PER_LUN,3681	.shost_groups = pmcraid_host_groups,3682	.proc_name = PMCRAID_DRIVER_NAME,3683};3684 3685/*3686 * pmcraid_isr_msix - implements MSI-X interrupt handling routine3687 * @irq: interrupt vector number3688 * @dev_id: pointer hrrq_vector3689 *3690 * Return Value3691 *	 IRQ_HANDLED if interrupt is handled or IRQ_NONE if ignored3692 */3693 3694static irqreturn_t pmcraid_isr_msix(int irq, void *dev_id)3695{3696	struct pmcraid_isr_param *hrrq_vector;3697	struct pmcraid_instance *pinstance;3698	unsigned long lock_flags;3699	u32 intrs_val;3700	int hrrq_id;3701 3702	hrrq_vector = (struct pmcraid_isr_param *)dev_id;3703	hrrq_id = hrrq_vector->hrrq_id;3704	pinstance = hrrq_vector->drv_inst;3705 3706	if (!hrrq_id) {3707		/* Read the interrupt */3708		intrs_val = pmcraid_read_interrupts(pinstance);3709		if (intrs_val &&3710			((ioread32(pinstance->int_regs.host_ioa_interrupt_reg)3711			& DOORBELL_INTR_MSIX_CLR) == 0)) {3712			/* Any error interrupts including unit_check,3713			 * initiate IOA reset.In case of unit check indicate3714			 * to reset_sequence that IOA unit checked and prepare3715			 * for a dump during reset sequence3716			 */3717			if (intrs_val & PMCRAID_ERROR_INTERRUPTS) {3718				if (intrs_val & INTRS_IOA_UNIT_CHECK)3719					pinstance->ioa_unit_check = 1;3720 3721				pmcraid_err("ISR: error interrupts: %x \3722					initiating reset\n", intrs_val);3723				spin_lock_irqsave(pinstance->host->host_lock,3724					lock_flags);3725				pmcraid_initiate_reset(pinstance);3726				spin_unlock_irqrestore(3727					pinstance->host->host_lock,3728					lock_flags);3729			}3730			/* If interrupt was as part of the ioa initialization,3731			 * clear it. Delete the timer and wakeup the3732			 * reset engine to proceed with reset sequence3733			 */3734			if (intrs_val & INTRS_TRANSITION_TO_OPERATIONAL)3735				pmcraid_clr_trans_op(pinstance);3736 3737			/* Clear the interrupt register by writing3738			 * to host to ioa doorbell. Once done3739			 * FW will clear the interrupt.3740			 */3741			iowrite32(DOORBELL_INTR_MSIX_CLR,3742				pinstance->int_regs.host_ioa_interrupt_reg);3743			ioread32(pinstance->int_regs.host_ioa_interrupt_reg);3744 3745 3746		}3747	}3748 3749	tasklet_schedule(&(pinstance->isr_tasklet[hrrq_id]));3750 3751	return IRQ_HANDLED;3752}3753 3754/**3755 * pmcraid_isr  - implements legacy interrupt handling routine3756 *3757 * @irq: interrupt vector number3758 * @dev_id: pointer hrrq_vector3759 *3760 * Return Value3761 *	 IRQ_HANDLED if interrupt is handled or IRQ_NONE if ignored3762 */3763static irqreturn_t pmcraid_isr(int irq, void *dev_id)3764{3765	struct pmcraid_isr_param *hrrq_vector;3766	struct pmcraid_instance *pinstance;3767	u32 intrs;3768	unsigned long lock_flags;3769	int hrrq_id = 0;3770 3771	/* In case of legacy interrupt mode where interrupts are shared across3772	 * isrs, it may be possible that the current interrupt is not from IOA3773	 */3774	if (!dev_id) {3775		printk(KERN_INFO "%s(): NULL host pointer\n", __func__);3776		return IRQ_NONE;3777	}3778	hrrq_vector = (struct pmcraid_isr_param *)dev_id;3779	pinstance = hrrq_vector->drv_inst;3780 3781	intrs = pmcraid_read_interrupts(pinstance);3782 3783	if (unlikely((intrs & PMCRAID_PCI_INTERRUPTS) == 0))3784		return IRQ_NONE;3785 3786	/* Any error interrupts including unit_check, initiate IOA reset.3787	 * In case of unit check indicate to reset_sequence that IOA unit3788	 * checked and prepare for a dump during reset sequence3789	 */3790	if (intrs & PMCRAID_ERROR_INTERRUPTS) {3791 3792		if (intrs & INTRS_IOA_UNIT_CHECK)3793			pinstance->ioa_unit_check = 1;3794 3795		iowrite32(intrs,3796			  pinstance->int_regs.ioa_host_interrupt_clr_reg);3797		pmcraid_err("ISR: error interrupts: %x initiating reset\n",3798			    intrs);3799		intrs = ioread32(3800				pinstance->int_regs.ioa_host_interrupt_clr_reg);3801		spin_lock_irqsave(pinstance->host->host_lock, lock_flags);3802		pmcraid_initiate_reset(pinstance);3803		spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);3804	} else {3805		/* If interrupt was as part of the ioa initialization,3806		 * clear. Delete the timer and wakeup the3807		 * reset engine to proceed with reset sequence3808		 */3809		if (intrs & INTRS_TRANSITION_TO_OPERATIONAL) {3810			pmcraid_clr_trans_op(pinstance);3811		} else {3812			iowrite32(intrs,3813				pinstance->int_regs.ioa_host_interrupt_clr_reg);3814			ioread32(3815				pinstance->int_regs.ioa_host_interrupt_clr_reg);3816 3817			tasklet_schedule(3818					&(pinstance->isr_tasklet[hrrq_id]));3819		}3820	}3821 3822	return IRQ_HANDLED;3823}3824 3825 3826/**3827 * pmcraid_worker_function -  worker thread function3828 *3829 * @workp: pointer to struct work queue3830 *3831 * Return Value3832 *	 None3833 */3834 3835static void pmcraid_worker_function(struct work_struct *workp)3836{3837	struct pmcraid_instance *pinstance;3838	struct pmcraid_resource_entry *res;3839	struct pmcraid_resource_entry *temp;3840	struct scsi_device *sdev;3841	unsigned long lock_flags;3842	unsigned long host_lock_flags;3843	u16 fw_version;3844	u8 bus, target, lun;3845 3846	pinstance = container_of(workp, struct pmcraid_instance, worker_q);3847	/* add resources only after host is added into system */3848	if (!atomic_read(&pinstance->expose_resources))3849		return;3850 3851	fw_version = be16_to_cpu(pinstance->inq_data->fw_version);3852 3853	spin_lock_irqsave(&pinstance->resource_lock, lock_flags);3854	list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue) {3855 3856		if (res->change_detected == RES_CHANGE_DEL && res->scsi_dev) {3857			sdev = res->scsi_dev;3858 3859			/* host_lock must be held before calling3860			 * scsi_device_get3861			 */3862			spin_lock_irqsave(pinstance->host->host_lock,3863					  host_lock_flags);3864			if (!scsi_device_get(sdev)) {3865				spin_unlock_irqrestore(3866						pinstance->host->host_lock,3867						host_lock_flags);3868				pmcraid_info("deleting %x from midlayer\n",3869					     res->cfg_entry.resource_address);3870				list_move_tail(&res->queue,3871						&pinstance->free_res_q);3872				spin_unlock_irqrestore(3873					&pinstance->resource_lock,3874					lock_flags);3875				scsi_remove_device(sdev);3876				scsi_device_put(sdev);3877				spin_lock_irqsave(&pinstance->resource_lock,3878						   lock_flags);3879				res->change_detected = 0;3880			} else {3881				spin_unlock_irqrestore(3882						pinstance->host->host_lock,3883						host_lock_flags);3884			}3885		}3886	}3887 3888	list_for_each_entry(res, &pinstance->used_res_q, queue) {3889 3890		if (res->change_detected == RES_CHANGE_ADD) {3891 3892			if (!pmcraid_expose_resource(fw_version,3893						     &res->cfg_entry))3894				continue;3895 3896			if (RES_IS_VSET(res->cfg_entry)) {3897				bus = PMCRAID_VSET_BUS_ID;3898				if (fw_version <= PMCRAID_FW_VERSION_1)3899					target = res->cfg_entry.unique_flags1;3900				else3901					target = le16_to_cpu(res->cfg_entry.array_id) & 0xFF;3902				lun = PMCRAID_VSET_LUN_ID;3903			} else {3904				bus = PMCRAID_PHYS_BUS_ID;3905				target =3906				     RES_TARGET(3907					res->cfg_entry.resource_address);3908				lun = RES_LUN(res->cfg_entry.resource_address);3909			}3910 3911			res->change_detected = 0;3912			spin_unlock_irqrestore(&pinstance->resource_lock,3913						lock_flags);3914			scsi_add_device(pinstance->host, bus, target, lun);3915			spin_lock_irqsave(&pinstance->resource_lock,3916					   lock_flags);3917		}3918	}3919 3920	spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);3921}3922 3923/**3924 * pmcraid_tasklet_function - Tasklet function3925 *3926 * @instance: pointer to msix param structure3927 *3928 * Return Value3929 *	None3930 */3931static void pmcraid_tasklet_function(unsigned long instance)3932{3933	struct pmcraid_isr_param *hrrq_vector;3934	struct pmcraid_instance *pinstance;3935	unsigned long hrrq_lock_flags;3936	unsigned long pending_lock_flags;3937	unsigned long host_lock_flags;3938	spinlock_t *lockp; /* hrrq buffer lock */3939	int id;3940	u32 resp;3941 3942	hrrq_vector = (struct pmcraid_isr_param *)instance;3943	pinstance = hrrq_vector->drv_inst;3944	id = hrrq_vector->hrrq_id;3945	lockp = &(pinstance->hrrq_lock[id]);3946 3947	/* loop through each of the commands responded by IOA. Each HRRQ buf is3948	 * protected by its own lock. Traversals must be done within this lock3949	 * as there may be multiple tasklets running on multiple CPUs. Note3950	 * that the lock is held just for picking up the response handle and3951	 * manipulating hrrq_curr/toggle_bit values.3952	 */3953	spin_lock_irqsave(lockp, hrrq_lock_flags);3954 3955	resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));3956 3957	while ((resp & HRRQ_TOGGLE_BIT) ==3958		pinstance->host_toggle_bit[id]) {3959 3960		int cmd_index = resp >> 2;3961		struct pmcraid_cmd *cmd = NULL;3962 3963		if (pinstance->hrrq_curr[id] < pinstance->hrrq_end[id]) {3964			pinstance->hrrq_curr[id]++;3965		} else {3966			pinstance->hrrq_curr[id] = pinstance->hrrq_start[id];3967			pinstance->host_toggle_bit[id] ^= 1u;3968		}3969 3970		if (cmd_index >= PMCRAID_MAX_CMD) {3971			/* In case of invalid response handle, log message */3972			pmcraid_err("Invalid response handle %d\n", cmd_index);3973			resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));3974			continue;3975		}3976 3977		cmd = pinstance->cmd_list[cmd_index];3978		spin_unlock_irqrestore(lockp, hrrq_lock_flags);3979 3980		spin_lock_irqsave(&pinstance->pending_pool_lock,3981				   pending_lock_flags);3982		list_del(&cmd->free_list);3983		spin_unlock_irqrestore(&pinstance->pending_pool_lock,3984					pending_lock_flags);3985		del_timer(&cmd->timer);3986		atomic_dec(&pinstance->outstanding_cmds);3987 3988		if (cmd->cmd_done == pmcraid_ioa_reset) {3989			spin_lock_irqsave(pinstance->host->host_lock,3990					  host_lock_flags);3991			cmd->cmd_done(cmd);3992			spin_unlock_irqrestore(pinstance->host->host_lock,3993					       host_lock_flags);3994		} else if (cmd->cmd_done != NULL) {3995			cmd->cmd_done(cmd);3996		}3997		/* loop over until we are done with all responses */3998		spin_lock_irqsave(lockp, hrrq_lock_flags);3999		resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));4000	}4001 4002	spin_unlock_irqrestore(lockp, hrrq_lock_flags);4003}4004 4005/**4006 * pmcraid_unregister_interrupt_handler - de-register interrupts handlers4007 * @pinstance: pointer to adapter instance structure4008 *4009 * This routine un-registers registered interrupt handler and4010 * also frees irqs/vectors.4011 *4012 * Return Value4013 *	None4014 */4015static4016void pmcraid_unregister_interrupt_handler(struct pmcraid_instance *pinstance)4017{4018	struct pci_dev *pdev = pinstance->pdev;4019	int i;4020 4021	for (i = 0; i < pinstance->num_hrrq; i++)4022		free_irq(pci_irq_vector(pdev, i), &pinstance->hrrq_vector[i]);4023 4024	pinstance->interrupt_mode = 0;4025	pci_free_irq_vectors(pdev);4026}4027 4028/**4029 * pmcraid_register_interrupt_handler - registers interrupt handler4030 * @pinstance: pointer to per-adapter instance structure4031 *4032 * Return Value4033 *	0 on success, non-zero error code otherwise.4034 */4035static int4036pmcraid_register_interrupt_handler(struct pmcraid_instance *pinstance)4037{4038	struct pci_dev *pdev = pinstance->pdev;4039	unsigned int irq_flag = PCI_IRQ_INTX, flag;4040	int num_hrrq, rc, i;4041	irq_handler_t isr;4042 4043	if (pmcraid_enable_msix)4044		irq_flag |= PCI_IRQ_MSIX;4045 4046	num_hrrq = pci_alloc_irq_vectors(pdev, 1, PMCRAID_NUM_MSIX_VECTORS,4047			irq_flag);4048	if (num_hrrq < 0)4049		return num_hrrq;4050 4051	if (pdev->msix_enabled) {4052		flag = 0;4053		isr = pmcraid_isr_msix;4054	} else {4055		flag = IRQF_SHARED;4056		isr = pmcraid_isr;4057	}4058 4059	for (i = 0; i < num_hrrq; i++) {4060		struct pmcraid_isr_param *vec = &pinstance->hrrq_vector[i];4061 4062		vec->hrrq_id = i;4063		vec->drv_inst = pinstance;4064		rc = request_irq(pci_irq_vector(pdev, i), isr, flag,4065				PMCRAID_DRIVER_NAME, vec);4066		if (rc)4067			goto out_unwind;4068	}4069 4070	pinstance->num_hrrq = num_hrrq;4071	if (pdev->msix_enabled) {4072		pinstance->interrupt_mode = 1;4073		iowrite32(DOORBELL_INTR_MODE_MSIX,4074			  pinstance->int_regs.host_ioa_interrupt_reg);4075		ioread32(pinstance->int_regs.host_ioa_interrupt_reg);4076	}4077 4078	return 0;4079 4080out_unwind:4081	while (--i >= 0)4082		free_irq(pci_irq_vector(pdev, i), &pinstance->hrrq_vector[i]);4083	pci_free_irq_vectors(pdev);4084	return rc;4085}4086 4087/**4088 * pmcraid_release_cmd_blocks - release buufers allocated for command blocks4089 * @pinstance: per adapter instance structure pointer4090 * @max_index: number of buffer blocks to release4091 *4092 * Return Value4093 *  None4094 */4095static void4096pmcraid_release_cmd_blocks(struct pmcraid_instance *pinstance, int max_index)4097{4098	int i;4099	for (i = 0; i < max_index; i++) {4100		kmem_cache_free(pinstance->cmd_cachep, pinstance->cmd_list[i]);4101		pinstance->cmd_list[i] = NULL;4102	}4103	kmem_cache_destroy(pinstance->cmd_cachep);4104	pinstance->cmd_cachep = NULL;4105}4106 4107/**4108 * pmcraid_release_control_blocks - releases buffers alloced for control blocks4109 * @pinstance: pointer to per adapter instance structure4110 * @max_index: number of buffers (from 0 onwards) to release4111 *4112 * This function assumes that the command blocks for which control blocks are4113 * linked are not released.4114 *4115 * Return Value4116 *	 None4117 */4118static void4119pmcraid_release_control_blocks(4120	struct pmcraid_instance *pinstance,4121	int max_index4122)4123{4124	int i;4125 4126	if (pinstance->control_pool == NULL)4127		return;4128 4129	for (i = 0; i < max_index; i++) {4130		dma_pool_free(pinstance->control_pool,4131			      pinstance->cmd_list[i]->ioa_cb,4132			      pinstance->cmd_list[i]->ioa_cb_bus_addr);4133		pinstance->cmd_list[i]->ioa_cb = NULL;4134		pinstance->cmd_list[i]->ioa_cb_bus_addr = 0;4135	}4136	dma_pool_destroy(pinstance->control_pool);4137	pinstance->control_pool = NULL;4138}4139 4140/**4141 * pmcraid_allocate_cmd_blocks - allocate memory for cmd block structures4142 * @pinstance: pointer to per adapter instance structure4143 *4144 * Allocates memory for command blocks using kernel slab allocator.4145 *4146 * Return Value4147 *	0 in case of success; -ENOMEM in case of failure4148 */4149static int pmcraid_allocate_cmd_blocks(struct pmcraid_instance *pinstance)4150{4151	int i;4152 4153	sprintf(pinstance->cmd_pool_name, "pmcraid_cmd_pool_%d",4154		pinstance->host->unique_id);4155 4156 4157	pinstance->cmd_cachep = kmem_cache_create(4158					pinstance->cmd_pool_name,4159					sizeof(struct pmcraid_cmd), 0,4160					SLAB_HWCACHE_ALIGN, NULL);4161	if (!pinstance->cmd_cachep)4162		return -ENOMEM;4163 4164	for (i = 0; i < PMCRAID_MAX_CMD; i++) {4165		pinstance->cmd_list[i] =4166			kmem_cache_alloc(pinstance->cmd_cachep, GFP_KERNEL);4167		if (!pinstance->cmd_list[i]) {4168			pmcraid_release_cmd_blocks(pinstance, i);4169			return -ENOMEM;4170		}4171	}4172	return 0;4173}4174 4175/**4176 * pmcraid_allocate_control_blocks - allocates memory control blocks4177 * @pinstance : pointer to per adapter instance structure4178 *4179 * This function allocates PCI memory for DMAable buffers like IOARCB, IOADLs4180 * and IOASAs. This is called after command blocks are already allocated.4181 *4182 * Return Value4183 *  0 in case it can allocate all control blocks, otherwise -ENOMEM4184 */4185static int pmcraid_allocate_control_blocks(struct pmcraid_instance *pinstance)4186{4187	int i;4188 4189	sprintf(pinstance->ctl_pool_name, "pmcraid_control_pool_%d",4190		pinstance->host->unique_id);4191 4192	pinstance->control_pool =4193		dma_pool_create(pinstance->ctl_pool_name,4194				&pinstance->pdev->dev,4195				sizeof(struct pmcraid_control_block),4196				PMCRAID_IOARCB_ALIGNMENT, 0);4197 4198	if (!pinstance->control_pool)4199		return -ENOMEM;4200 4201	for (i = 0; i < PMCRAID_MAX_CMD; i++) {4202		pinstance->cmd_list[i]->ioa_cb =4203			dma_pool_zalloc(4204				pinstance->control_pool,4205				GFP_KERNEL,4206				&(pinstance->cmd_list[i]->ioa_cb_bus_addr));4207 4208		if (!pinstance->cmd_list[i]->ioa_cb) {4209			pmcraid_release_control_blocks(pinstance, i);4210			return -ENOMEM;4211		}4212	}4213	return 0;4214}4215 4216/**4217 * pmcraid_release_host_rrqs - release memory allocated for hrrq buffer(s)4218 * @pinstance: pointer to per adapter instance structure4219 * @maxindex: size of hrrq buffer pointer array4220 *4221 * Return Value4222 *	None4223 */4224static void4225pmcraid_release_host_rrqs(struct pmcraid_instance *pinstance, int maxindex)4226{4227	int i;4228 4229	for (i = 0; i < maxindex; i++) {4230		dma_free_coherent(&pinstance->pdev->dev,4231				    HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD,4232				    pinstance->hrrq_start[i],4233				    pinstance->hrrq_start_bus_addr[i]);4234 4235		/* reset pointers and toggle bit to zeros */4236		pinstance->hrrq_start[i] = NULL;4237		pinstance->hrrq_start_bus_addr[i] = 0;4238		pinstance->host_toggle_bit[i] = 0;4239	}4240}4241 4242/**4243 * pmcraid_allocate_host_rrqs - Allocate and initialize host RRQ buffers4244 * @pinstance: pointer to per adapter instance structure4245 *4246 * Return value4247 *	0 hrrq buffers are allocated, -ENOMEM otherwise.4248 */4249static int pmcraid_allocate_host_rrqs(struct pmcraid_instance *pinstance)4250{4251	int i, buffer_size;4252 4253	buffer_size = HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD;4254 4255	for (i = 0; i < pinstance->num_hrrq; i++) {4256		pinstance->hrrq_start[i] =4257			dma_alloc_coherent(&pinstance->pdev->dev, buffer_size,4258					   &pinstance->hrrq_start_bus_addr[i],4259					   GFP_KERNEL);4260		if (!pinstance->hrrq_start[i]) {4261			pmcraid_err("pci_alloc failed for hrrq vector : %d\n",4262				    i);4263			pmcraid_release_host_rrqs(pinstance, i);4264			return -ENOMEM;4265		}4266 4267		pinstance->hrrq_curr[i] = pinstance->hrrq_start[i];4268		pinstance->hrrq_end[i] =4269			pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1;4270		pinstance->host_toggle_bit[i] = 1;4271		spin_lock_init(&pinstance->hrrq_lock[i]);4272	}4273	return 0;4274}4275 4276/**4277 * pmcraid_release_hcams - release HCAM buffers4278 *4279 * @pinstance: pointer to per adapter instance structure4280 *4281 * Return value4282 *  none4283 */4284static void pmcraid_release_hcams(struct pmcraid_instance *pinstance)4285{4286	if (pinstance->ccn.msg != NULL) {4287		dma_free_coherent(&pinstance->pdev->dev,4288				    PMCRAID_AEN_HDR_SIZE +4289				    sizeof(struct pmcraid_hcam_ccn_ext),4290				    pinstance->ccn.msg,4291				    pinstance->ccn.baddr);4292 4293		pinstance->ccn.msg = NULL;4294		pinstance->ccn.hcam = NULL;4295		pinstance->ccn.baddr = 0;4296	}4297 4298	if (pinstance->ldn.msg != NULL) {4299		dma_free_coherent(&pinstance->pdev->dev,4300				    PMCRAID_AEN_HDR_SIZE +4301				    sizeof(struct pmcraid_hcam_ldn),4302				    pinstance->ldn.msg,4303				    pinstance->ldn.baddr);4304 4305		pinstance->ldn.msg = NULL;4306		pinstance->ldn.hcam = NULL;4307		pinstance->ldn.baddr = 0;4308	}4309}4310 4311/**4312 * pmcraid_allocate_hcams - allocates HCAM buffers4313 * @pinstance : pointer to per adapter instance structure4314 *4315 * Return Value:4316 *   0 in case of successful allocation, non-zero otherwise4317 */4318static int pmcraid_allocate_hcams(struct pmcraid_instance *pinstance)4319{4320	pinstance->ccn.msg = dma_alloc_coherent(&pinstance->pdev->dev,4321					PMCRAID_AEN_HDR_SIZE +4322					sizeof(struct pmcraid_hcam_ccn_ext),4323					&pinstance->ccn.baddr, GFP_KERNEL);4324 4325	pinstance->ldn.msg = dma_alloc_coherent(&pinstance->pdev->dev,4326					PMCRAID_AEN_HDR_SIZE +4327					sizeof(struct pmcraid_hcam_ldn),4328					&pinstance->ldn.baddr, GFP_KERNEL);4329 4330	if (pinstance->ldn.msg == NULL || pinstance->ccn.msg == NULL) {4331		pmcraid_release_hcams(pinstance);4332	} else {4333		pinstance->ccn.hcam =4334			(void *)pinstance->ccn.msg + PMCRAID_AEN_HDR_SIZE;4335		pinstance->ldn.hcam =4336			(void *)pinstance->ldn.msg + PMCRAID_AEN_HDR_SIZE;4337 4338		atomic_set(&pinstance->ccn.ignore, 0);4339		atomic_set(&pinstance->ldn.ignore, 0);4340	}4341 4342	return (pinstance->ldn.msg == NULL) ? -ENOMEM : 0;4343}4344 4345/**4346 * pmcraid_release_config_buffers - release config.table buffers4347 * @pinstance: pointer to per adapter instance structure4348 *4349 * Return Value4350 *	 none4351 */4352static void pmcraid_release_config_buffers(struct pmcraid_instance *pinstance)4353{4354	if (pinstance->cfg_table != NULL &&4355	    pinstance->cfg_table_bus_addr != 0) {4356		dma_free_coherent(&pinstance->pdev->dev,4357				    sizeof(struct pmcraid_config_table),4358				    pinstance->cfg_table,4359				    pinstance->cfg_table_bus_addr);4360		pinstance->cfg_table = NULL;4361		pinstance->cfg_table_bus_addr = 0;4362	}4363 4364	if (pinstance->res_entries != NULL) {4365		int i;4366 4367		for (i = 0; i < PMCRAID_MAX_RESOURCES; i++)4368			list_del(&pinstance->res_entries[i].queue);4369		kfree(pinstance->res_entries);4370		pinstance->res_entries = NULL;4371	}4372 4373	pmcraid_release_hcams(pinstance);4374}4375 4376/**4377 * pmcraid_allocate_config_buffers - allocates DMAable memory for config table4378 * @pinstance : pointer to per adapter instance structure4379 *4380 * Return Value4381 *	0 for successful allocation, -ENOMEM for any failure4382 */4383static int pmcraid_allocate_config_buffers(struct pmcraid_instance *pinstance)4384{4385	int i;4386 4387	pinstance->res_entries =4388			kcalloc(PMCRAID_MAX_RESOURCES,4389				sizeof(struct pmcraid_resource_entry),4390				GFP_KERNEL);4391 4392	if (NULL == pinstance->res_entries) {4393		pmcraid_err("failed to allocate memory for resource table\n");4394		return -ENOMEM;4395	}4396 4397	for (i = 0; i < PMCRAID_MAX_RESOURCES; i++)4398		list_add_tail(&pinstance->res_entries[i].queue,4399			      &pinstance->free_res_q);4400 4401	pinstance->cfg_table = dma_alloc_coherent(&pinstance->pdev->dev,4402				     sizeof(struct pmcraid_config_table),4403				     &pinstance->cfg_table_bus_addr,4404				     GFP_KERNEL);4405 4406	if (NULL == pinstance->cfg_table) {4407		pmcraid_err("couldn't alloc DMA memory for config table\n");4408		pmcraid_release_config_buffers(pinstance);4409		return -ENOMEM;4410	}4411 4412	if (pmcraid_allocate_hcams(pinstance)) {4413		pmcraid_err("could not alloc DMA memory for HCAMS\n");4414		pmcraid_release_config_buffers(pinstance);4415		return -ENOMEM;4416	}4417 4418	return 0;4419}4420 4421/**4422 * pmcraid_init_tasklets - registers tasklets for response handling4423 *4424 * @pinstance: pointer adapter instance structure4425 *4426 * Return value4427 *	none4428 */4429static void pmcraid_init_tasklets(struct pmcraid_instance *pinstance)4430{4431	int i;4432	for (i = 0; i < pinstance->num_hrrq; i++)4433		tasklet_init(&pinstance->isr_tasklet[i],4434			     pmcraid_tasklet_function,4435			     (unsigned long)&pinstance->hrrq_vector[i]);4436}4437 4438/**4439 * pmcraid_kill_tasklets - destroys tasklets registered for response handling4440 *4441 * @pinstance: pointer to adapter instance structure4442 *4443 * Return value4444 *	none4445 */4446static void pmcraid_kill_tasklets(struct pmcraid_instance *pinstance)4447{4448	int i;4449	for (i = 0; i < pinstance->num_hrrq; i++)4450		tasklet_kill(&pinstance->isr_tasklet[i]);4451}4452 4453/**4454 * pmcraid_release_buffers - release per-adapter buffers allocated4455 *4456 * @pinstance: pointer to adapter soft state4457 *4458 * Return Value4459 *	none4460 */4461static void pmcraid_release_buffers(struct pmcraid_instance *pinstance)4462{4463	pmcraid_release_config_buffers(pinstance);4464	pmcraid_release_control_blocks(pinstance, PMCRAID_MAX_CMD);4465	pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD);4466	pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);4467 4468	if (pinstance->inq_data != NULL) {4469		dma_free_coherent(&pinstance->pdev->dev,4470				    sizeof(struct pmcraid_inquiry_data),4471				    pinstance->inq_data,4472				    pinstance->inq_data_baddr);4473 4474		pinstance->inq_data = NULL;4475		pinstance->inq_data_baddr = 0;4476	}4477 4478	if (pinstance->timestamp_data != NULL) {4479		dma_free_coherent(&pinstance->pdev->dev,4480				    sizeof(struct pmcraid_timestamp_data),4481				    pinstance->timestamp_data,4482				    pinstance->timestamp_data_baddr);4483 4484		pinstance->timestamp_data = NULL;4485		pinstance->timestamp_data_baddr = 0;4486	}4487}4488 4489/**4490 * pmcraid_init_buffers - allocates memory and initializes various structures4491 * @pinstance: pointer to per adapter instance structure4492 *4493 * This routine pre-allocates memory based on the type of block as below:4494 * cmdblocks(PMCRAID_MAX_CMD): kernel memory using kernel's slab_allocator,4495 * IOARCBs(PMCRAID_MAX_CMD)  : DMAable memory, using pci pool allocator4496 * config-table entries      : DMAable memory using dma_alloc_coherent4497 * HostRRQs                  : DMAable memory, using dma_alloc_coherent4498 *4499 * Return Value4500 *	 0 in case all of the blocks are allocated, -ENOMEM otherwise.4501 */4502static int pmcraid_init_buffers(struct pmcraid_instance *pinstance)4503{4504	int i;4505 4506	if (pmcraid_allocate_host_rrqs(pinstance)) {4507		pmcraid_err("couldn't allocate memory for %d host rrqs\n",4508			     pinstance->num_hrrq);4509		return -ENOMEM;4510	}4511 4512	if (pmcraid_allocate_config_buffers(pinstance)) {4513		pmcraid_err("couldn't allocate memory for config buffers\n");4514		pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);4515		return -ENOMEM;4516	}4517 4518	if (pmcraid_allocate_cmd_blocks(pinstance)) {4519		pmcraid_err("couldn't allocate memory for cmd blocks\n");4520		pmcraid_release_config_buffers(pinstance);4521		pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);4522		return -ENOMEM;4523	}4524 4525	if (pmcraid_allocate_control_blocks(pinstance)) {4526		pmcraid_err("couldn't allocate memory control blocks\n");4527		pmcraid_release_config_buffers(pinstance);4528		pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD);4529		pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);4530		return -ENOMEM;4531	}4532 4533	/* allocate DMAable memory for page D0 INQUIRY buffer */4534	pinstance->inq_data = dma_alloc_coherent(&pinstance->pdev->dev,4535					sizeof(struct pmcraid_inquiry_data),4536					&pinstance->inq_data_baddr, GFP_KERNEL);4537	if (pinstance->inq_data == NULL) {4538		pmcraid_err("couldn't allocate DMA memory for INQUIRY\n");4539		pmcraid_release_buffers(pinstance);4540		return -ENOMEM;4541	}4542 4543	/* allocate DMAable memory for set timestamp data buffer */4544	pinstance->timestamp_data = dma_alloc_coherent(&pinstance->pdev->dev,4545					sizeof(struct pmcraid_timestamp_data),4546					&pinstance->timestamp_data_baddr,4547					GFP_KERNEL);4548	if (pinstance->timestamp_data == NULL) {4549		pmcraid_err("couldn't allocate DMA memory for \4550				set time_stamp \n");4551		pmcraid_release_buffers(pinstance);4552		return -ENOMEM;4553	}4554 4555 4556	/* Initialize all the command blocks and add them to free pool. No4557	 * need to lock (free_pool_lock) as this is done in initialization4558	 * itself4559	 */4560	for (i = 0; i < PMCRAID_MAX_CMD; i++) {4561		struct pmcraid_cmd *cmdp = pinstance->cmd_list[i];4562		pmcraid_init_cmdblk(cmdp, i);4563		cmdp->drv_inst = pinstance;4564		list_add_tail(&cmdp->free_list, &pinstance->free_cmd_pool);4565	}4566 4567	return 0;4568}4569 4570/**4571 * pmcraid_reinit_buffers - resets various buffer pointers4572 * @pinstance: pointer to adapter instance4573 * Return value4574 *	none4575 */4576static void pmcraid_reinit_buffers(struct pmcraid_instance *pinstance)4577{4578	int i;4579	int buffer_size = HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD;4580 4581	for (i = 0; i < pinstance->num_hrrq; i++) {4582		memset(pinstance->hrrq_start[i], 0, buffer_size);4583		pinstance->hrrq_curr[i] = pinstance->hrrq_start[i];4584		pinstance->hrrq_end[i] =4585			pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1;4586		pinstance->host_toggle_bit[i] = 1;4587	}4588}4589 4590/**4591 * pmcraid_init_instance - initialize per instance data structure4592 * @pdev: pointer to pci device structure4593 * @host: pointer to Scsi_Host structure4594 * @mapped_pci_addr: memory mapped IOA configuration registers4595 *4596 * Return Value4597 *	 0 on success, non-zero in case of any failure4598 */4599static int pmcraid_init_instance(struct pci_dev *pdev, struct Scsi_Host *host,4600				 void __iomem *mapped_pci_addr)4601{4602	struct pmcraid_instance *pinstance =4603		(struct pmcraid_instance *)host->hostdata;4604 4605	pinstance->host = host;4606	pinstance->pdev = pdev;4607 4608	/* Initialize register addresses */4609	pinstance->mapped_dma_addr = mapped_pci_addr;4610 4611	/* Initialize chip-specific details */4612	{4613		struct pmcraid_chip_details *chip_cfg = pinstance->chip_cfg;4614		struct pmcraid_interrupts *pint_regs = &pinstance->int_regs;4615 4616		pinstance->ioarrin = mapped_pci_addr + chip_cfg->ioarrin;4617 4618		pint_regs->ioa_host_interrupt_reg =4619			mapped_pci_addr + chip_cfg->ioa_host_intr;4620		pint_regs->ioa_host_interrupt_clr_reg =4621			mapped_pci_addr + chip_cfg->ioa_host_intr_clr;4622		pint_regs->ioa_host_msix_interrupt_reg =4623			mapped_pci_addr + chip_cfg->ioa_host_msix_intr;4624		pint_regs->host_ioa_interrupt_reg =4625			mapped_pci_addr + chip_cfg->host_ioa_intr;4626		pint_regs->host_ioa_interrupt_clr_reg =4627			mapped_pci_addr + chip_cfg->host_ioa_intr_clr;4628 4629		/* Current version of firmware exposes interrupt mask set4630		 * and mask clr registers through memory mapped bar0.4631		 */4632		pinstance->mailbox = mapped_pci_addr + chip_cfg->mailbox;4633		pinstance->ioa_status = mapped_pci_addr + chip_cfg->ioastatus;4634		pint_regs->ioa_host_interrupt_mask_reg =4635			mapped_pci_addr + chip_cfg->ioa_host_mask;4636		pint_regs->ioa_host_interrupt_mask_clr_reg =4637			mapped_pci_addr + chip_cfg->ioa_host_mask_clr;4638		pint_regs->global_interrupt_mask_reg =4639			mapped_pci_addr + chip_cfg->global_intr_mask;4640	}4641 4642	pinstance->ioa_reset_attempts = 0;4643	init_waitqueue_head(&pinstance->reset_wait_q);4644 4645	atomic_set(&pinstance->outstanding_cmds, 0);4646	atomic_set(&pinstance->last_message_id, 0);4647	atomic_set(&pinstance->expose_resources, 0);4648 4649	INIT_LIST_HEAD(&pinstance->free_res_q);4650	INIT_LIST_HEAD(&pinstance->used_res_q);4651	INIT_LIST_HEAD(&pinstance->free_cmd_pool);4652	INIT_LIST_HEAD(&pinstance->pending_cmd_pool);4653 4654	spin_lock_init(&pinstance->free_pool_lock);4655	spin_lock_init(&pinstance->pending_pool_lock);4656	spin_lock_init(&pinstance->resource_lock);4657	mutex_init(&pinstance->aen_queue_lock);4658 4659	/* Work-queue (Shared) for deferred processing error handling */4660	INIT_WORK(&pinstance->worker_q, pmcraid_worker_function);4661 4662	/* Initialize the default log_level */4663	pinstance->current_log_level = pmcraid_log_level;4664 4665	/* Setup variables required for reset engine */4666	pinstance->ioa_state = IOA_STATE_UNKNOWN;4667	pinstance->reset_cmd = NULL;4668	return 0;4669}4670 4671/**4672 * pmcraid_shutdown - shutdown adapter controller.4673 * @pdev: pci device struct4674 *4675 * Issues an adapter shutdown to the card waits for its completion4676 *4677 * Return value4678 *	  none4679 */4680static void pmcraid_shutdown(struct pci_dev *pdev)4681{4682	struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);4683	pmcraid_reset_bringdown(pinstance);4684}4685 4686 4687/*4688 * pmcraid_get_minor - returns unused minor number from minor number bitmap4689 */4690static unsigned short pmcraid_get_minor(void)4691{4692	int minor;4693 4694	minor = find_first_zero_bit(pmcraid_minor, PMCRAID_MAX_ADAPTERS);4695	__set_bit(minor, pmcraid_minor);4696	return minor;4697}4698 4699/*4700 * pmcraid_release_minor - releases given minor back to minor number bitmap4701 */4702static void pmcraid_release_minor(unsigned short minor)4703{4704	__clear_bit(minor, pmcraid_minor);4705}4706 4707/**4708 * pmcraid_setup_chrdev - allocates a minor number and registers a char device4709 *4710 * @pinstance: pointer to adapter instance for which to register device4711 *4712 * Return value4713 *	0 in case of success, otherwise non-zero4714 */4715static int pmcraid_setup_chrdev(struct pmcraid_instance *pinstance)4716{4717	int minor;4718	int error;4719 4720	minor = pmcraid_get_minor();4721	cdev_init(&pinstance->cdev, &pmcraid_fops);4722	pinstance->cdev.owner = THIS_MODULE;4723 4724	error = cdev_add(&pinstance->cdev, MKDEV(pmcraid_major, minor), 1);4725 4726	if (error)4727		pmcraid_release_minor(minor);4728	else4729		device_create(&pmcraid_class, NULL, MKDEV(pmcraid_major, minor),4730			      NULL, "%s%u", PMCRAID_DEVFILE, minor);4731	return error;4732}4733 4734/**4735 * pmcraid_release_chrdev - unregisters per-adapter management interface4736 *4737 * @pinstance: pointer to adapter instance structure4738 *4739 * Return value4740 *  none4741 */4742static void pmcraid_release_chrdev(struct pmcraid_instance *pinstance)4743{4744	pmcraid_release_minor(MINOR(pinstance->cdev.dev));4745	device_destroy(&pmcraid_class,4746		       MKDEV(pmcraid_major, MINOR(pinstance->cdev.dev)));4747	cdev_del(&pinstance->cdev);4748}4749 4750/**4751 * pmcraid_remove - IOA hot plug remove entry point4752 * @pdev: pci device struct4753 *4754 * Return value4755 *	  none4756 */4757static void pmcraid_remove(struct pci_dev *pdev)4758{4759	struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);4760 4761	/* remove the management interface (/dev file) for this device */4762	pmcraid_release_chrdev(pinstance);4763 4764	/* remove host template from scsi midlayer */4765	scsi_remove_host(pinstance->host);4766 4767	/* block requests from mid-layer */4768	scsi_block_requests(pinstance->host);4769 4770	/* initiate shutdown adapter */4771	pmcraid_shutdown(pdev);4772 4773	pmcraid_disable_interrupts(pinstance, ~0);4774	flush_work(&pinstance->worker_q);4775 4776	pmcraid_kill_tasklets(pinstance);4777	pmcraid_unregister_interrupt_handler(pinstance);4778	pmcraid_release_buffers(pinstance);4779	iounmap(pinstance->mapped_dma_addr);4780	pci_release_regions(pdev);4781	scsi_host_put(pinstance->host);4782	pci_disable_device(pdev);4783 4784	return;4785}4786 4787/**4788 * pmcraid_suspend - driver suspend entry point for power management4789 * @dev:   Device structure4790 *4791 * Return Value - 0 always4792 */4793static int __maybe_unused pmcraid_suspend(struct device *dev)4794{4795	struct pci_dev *pdev = to_pci_dev(dev);4796	struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);4797 4798	pmcraid_shutdown(pdev);4799	pmcraid_disable_interrupts(pinstance, ~0);4800	pmcraid_kill_tasklets(pinstance);4801	pmcraid_unregister_interrupt_handler(pinstance);4802 4803	return 0;4804}4805 4806/**4807 * pmcraid_resume - driver resume entry point PCI power management4808 * @dev: Device structure4809 *4810 * Return Value - 0 in case of success. Error code in case of any failure4811 */4812static int __maybe_unused pmcraid_resume(struct device *dev)4813{4814	struct pci_dev *pdev = to_pci_dev(dev);4815	struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);4816	struct Scsi_Host *host = pinstance->host;4817	int rc = 0;4818 4819	if (sizeof(dma_addr_t) == 4 ||4820	    dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)))4821		rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));4822 4823	if (rc == 0)4824		rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));4825 4826	if (rc != 0) {4827		dev_err(&pdev->dev, "resume: Failed to set PCI DMA mask\n");4828		goto disable_device;4829	}4830 4831	pmcraid_disable_interrupts(pinstance, ~0);4832	atomic_set(&pinstance->outstanding_cmds, 0);4833	rc = pmcraid_register_interrupt_handler(pinstance);4834 4835	if (rc) {4836		dev_err(&pdev->dev,4837			"resume: couldn't register interrupt handlers\n");4838		rc = -ENODEV;4839		goto release_host;4840	}4841 4842	pmcraid_init_tasklets(pinstance);4843	pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);4844 4845	/* Start with hard reset sequence which brings up IOA to operational4846	 * state as well as completes the reset sequence.4847	 */4848	pinstance->ioa_hard_reset = 1;4849 4850	/* Start IOA firmware initialization and bring card to Operational4851	 * state.4852	 */4853	if (pmcraid_reset_bringup(pinstance)) {4854		dev_err(&pdev->dev, "couldn't initialize IOA\n");4855		rc = -ENODEV;4856		goto release_tasklets;4857	}4858 4859	return 0;4860 4861release_tasklets:4862	pmcraid_disable_interrupts(pinstance, ~0);4863	pmcraid_kill_tasklets(pinstance);4864	pmcraid_unregister_interrupt_handler(pinstance);4865 4866release_host:4867	scsi_host_put(host);4868 4869disable_device:4870 4871	return rc;4872}4873 4874/**4875 * pmcraid_complete_ioa_reset - Called by either timer or tasklet during4876 *				completion of the ioa reset4877 * @cmd: pointer to reset command block4878 */4879static void pmcraid_complete_ioa_reset(struct pmcraid_cmd *cmd)4880{4881	struct pmcraid_instance *pinstance = cmd->drv_inst;4882	unsigned long flags;4883 4884	spin_lock_irqsave(pinstance->host->host_lock, flags);4885	pmcraid_ioa_reset(cmd);4886	spin_unlock_irqrestore(pinstance->host->host_lock, flags);4887	scsi_unblock_requests(pinstance->host);4888	schedule_work(&pinstance->worker_q);4889}4890 4891/**4892 * pmcraid_set_supported_devs - sends SET SUPPORTED DEVICES to IOAFP4893 *4894 * @cmd: pointer to pmcraid_cmd structure4895 *4896 * Return Value4897 *  0 for success or non-zero for failure cases4898 */4899static void pmcraid_set_supported_devs(struct pmcraid_cmd *cmd)4900{4901	struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;4902	void (*cmd_done) (struct pmcraid_cmd *) = pmcraid_complete_ioa_reset;4903 4904	pmcraid_reinit_cmdblk(cmd);4905 4906	ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);4907	ioarcb->request_type = REQ_TYPE_IOACMD;4908	ioarcb->cdb[0] = PMCRAID_SET_SUPPORTED_DEVICES;4909	ioarcb->cdb[1] = ALL_DEVICES_SUPPORTED;4910 4911	/* If this was called as part of resource table reinitialization due to4912	 * lost CCN, it is enough to return the command block back to free pool4913	 * as part of set_supported_devs completion function.4914	 */4915	if (cmd->drv_inst->reinit_cfg_table) {4916		cmd->drv_inst->reinit_cfg_table = 0;4917		cmd->release = 1;4918		cmd_done = pmcraid_reinit_cfgtable_done;4919	}4920 4921	/* we will be done with the reset sequence after set supported devices,4922	 * setup the done function to return the command block back to free4923	 * pool4924	 */4925	pmcraid_send_cmd(cmd,4926			 cmd_done,4927			 PMCRAID_SET_SUP_DEV_TIMEOUT,4928			 pmcraid_timeout_handler);4929	return;4930}4931 4932/**4933 * pmcraid_set_timestamp - set the timestamp to IOAFP4934 *4935 * @cmd: pointer to pmcraid_cmd structure4936 *4937 * Return Value4938 *  0 for success or non-zero for failure cases4939 */4940static void pmcraid_set_timestamp(struct pmcraid_cmd *cmd)4941{4942	struct pmcraid_instance *pinstance = cmd->drv_inst;4943	struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;4944	__be32 time_stamp_len = cpu_to_be32(PMCRAID_TIMESTAMP_LEN);4945	struct pmcraid_ioadl_desc *ioadl;4946	u64 timestamp;4947 4948	timestamp = ktime_get_real_seconds() * 1000;4949 4950	pinstance->timestamp_data->timestamp[0] = (__u8)(timestamp);4951	pinstance->timestamp_data->timestamp[1] = (__u8)((timestamp) >> 8);4952	pinstance->timestamp_data->timestamp[2] = (__u8)((timestamp) >> 16);4953	pinstance->timestamp_data->timestamp[3] = (__u8)((timestamp) >> 24);4954	pinstance->timestamp_data->timestamp[4] = (__u8)((timestamp) >> 32);4955	pinstance->timestamp_data->timestamp[5] = (__u8)((timestamp)  >> 40);4956 4957	pmcraid_reinit_cmdblk(cmd);4958	ioarcb->request_type = REQ_TYPE_SCSI;4959	ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);4960	ioarcb->cdb[0] = PMCRAID_SCSI_SET_TIMESTAMP;4961	ioarcb->cdb[1] = PMCRAID_SCSI_SERVICE_ACTION;4962	memcpy(&(ioarcb->cdb[6]), &time_stamp_len, sizeof(time_stamp_len));4963 4964	ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +4965					offsetof(struct pmcraid_ioarcb,4966						add_data.u.ioadl[0]));4967	ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));4968	ioarcb->ioarcb_bus_addr &= cpu_to_le64(~(0x1FULL));4969 4970	ioarcb->request_flags0 |= NO_LINK_DESCS;4971	ioarcb->request_flags0 |= TRANSFER_DIR_WRITE;4972	ioarcb->data_transfer_length =4973		cpu_to_le32(sizeof(struct pmcraid_timestamp_data));4974	ioadl = &(ioarcb->add_data.u.ioadl[0]);4975	ioadl->flags = IOADL_FLAGS_LAST_DESC;4976	ioadl->address = cpu_to_le64(pinstance->timestamp_data_baddr);4977	ioadl->data_len = cpu_to_le32(sizeof(struct pmcraid_timestamp_data));4978 4979	if (!pinstance->timestamp_error) {4980		pinstance->timestamp_error = 0;4981		pmcraid_send_cmd(cmd, pmcraid_set_supported_devs,4982			 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);4983	} else {4984		pmcraid_send_cmd(cmd, pmcraid_return_cmd,4985			 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);4986		return;4987	}4988}4989 4990 4991/**4992 * pmcraid_init_res_table - Initialize the resource table4993 * @cmd:  pointer to pmcraid command struct4994 *4995 * This function looks through the existing resource table, comparing4996 * it with the config table. This function will take care of old/new4997 * devices and schedule adding/removing them from the mid-layer4998 * as appropriate.4999 *5000 * Return value5001 *	 None5002 */5003static void pmcraid_init_res_table(struct pmcraid_cmd *cmd)5004{5005	struct pmcraid_instance *pinstance = cmd->drv_inst;5006	struct pmcraid_resource_entry *res, *temp;5007	struct pmcraid_config_table_entry *cfgte;5008	unsigned long lock_flags;5009	int found, rc, i;5010	u16 fw_version;5011	LIST_HEAD(old_res);5012 5013	if (pinstance->cfg_table->flags & MICROCODE_UPDATE_REQUIRED)5014		pmcraid_err("IOA requires microcode download\n");5015 5016	fw_version = be16_to_cpu(pinstance->inq_data->fw_version);5017 5018	/* resource list is protected by pinstance->resource_lock.5019	 * init_res_table can be called from probe (user-thread) or runtime5020	 * reset (timer/tasklet)5021	 */5022	spin_lock_irqsave(&pinstance->resource_lock, lock_flags);5023 5024	list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue)5025		list_move_tail(&res->queue, &old_res);5026 5027	for (i = 0; i < le16_to_cpu(pinstance->cfg_table->num_entries); i++) {5028		if (be16_to_cpu(pinstance->inq_data->fw_version) <=5029						PMCRAID_FW_VERSION_1)5030			cfgte = &pinstance->cfg_table->entries[i];5031		else5032			cfgte = (struct pmcraid_config_table_entry *)5033					&pinstance->cfg_table->entries_ext[i];5034 5035		if (!pmcraid_expose_resource(fw_version, cfgte))5036			continue;5037 5038		found = 0;5039 5040		/* If this entry was already detected and initialized */5041		list_for_each_entry_safe(res, temp, &old_res, queue) {5042 5043			rc = memcmp(&res->cfg_entry.resource_address,5044				    &cfgte->resource_address,5045				    sizeof(cfgte->resource_address));5046			if (!rc) {5047				list_move_tail(&res->queue,5048						&pinstance->used_res_q);5049				found = 1;5050				break;5051			}5052		}5053 5054		/* If this is new entry, initialize it and add it the queue */5055		if (!found) {5056 5057			if (list_empty(&pinstance->free_res_q)) {5058				pmcraid_err("Too many devices attached\n");5059				break;5060			}5061 5062			found = 1;5063			res = list_entry(pinstance->free_res_q.next,5064					 struct pmcraid_resource_entry, queue);5065 5066			res->scsi_dev = NULL;5067			res->change_detected = RES_CHANGE_ADD;5068			res->reset_progress = 0;5069			list_move_tail(&res->queue, &pinstance->used_res_q);5070		}5071 5072		/* copy new configuration table entry details into driver5073		 * maintained resource entry5074		 */5075		if (found) {5076			memcpy(&res->cfg_entry, cfgte,5077					pinstance->config_table_entry_size);5078			pmcraid_info("New res type:%x, vset:%x, addr:%x:\n",5079				 res->cfg_entry.resource_type,5080				 (fw_version <= PMCRAID_FW_VERSION_1 ?5081					res->cfg_entry.unique_flags1 :5082					le16_to_cpu(res->cfg_entry.array_id) & 0xFF),5083				 le32_to_cpu(res->cfg_entry.resource_address));5084		}5085	}5086 5087	/* Detect any deleted entries, mark them for deletion from mid-layer */5088	list_for_each_entry_safe(res, temp, &old_res, queue) {5089 5090		if (res->scsi_dev) {5091			res->change_detected = RES_CHANGE_DEL;5092			res->cfg_entry.resource_handle =5093				PMCRAID_INVALID_RES_HANDLE;5094			list_move_tail(&res->queue, &pinstance->used_res_q);5095		} else {5096			list_move_tail(&res->queue, &pinstance->free_res_q);5097		}5098	}5099 5100	/* release the resource list lock */5101	spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);5102	pmcraid_set_timestamp(cmd);5103}5104 5105/**5106 * pmcraid_querycfg - Send a Query IOA Config to the adapter.5107 * @cmd: pointer pmcraid_cmd struct5108 *5109 * This function sends a Query IOA Configuration command to the adapter to5110 * retrieve the IOA configuration table.5111 *5112 * Return value:5113 *	none5114 */5115static void pmcraid_querycfg(struct pmcraid_cmd *cmd)5116{5117	struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;5118	struct pmcraid_ioadl_desc *ioadl;5119	struct pmcraid_instance *pinstance = cmd->drv_inst;5120	__be32 cfg_table_size = cpu_to_be32(sizeof(struct pmcraid_config_table));5121 5122	if (be16_to_cpu(pinstance->inq_data->fw_version) <=5123					PMCRAID_FW_VERSION_1)5124		pinstance->config_table_entry_size =5125			sizeof(struct pmcraid_config_table_entry);5126	else5127		pinstance->config_table_entry_size =5128			sizeof(struct pmcraid_config_table_entry_ext);5129 5130	ioarcb->request_type = REQ_TYPE_IOACMD;5131	ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);5132 5133	ioarcb->cdb[0] = PMCRAID_QUERY_IOA_CONFIG;5134 5135	/* firmware requires 4-byte length field, specified in B.E format */5136	memcpy(&(ioarcb->cdb[10]), &cfg_table_size, sizeof(cfg_table_size));5137 5138	/* Since entire config table can be described by single IOADL, it can5139	 * be part of IOARCB itself5140	 */5141	ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +5142					offsetof(struct pmcraid_ioarcb,5143						add_data.u.ioadl[0]));5144	ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));5145	ioarcb->ioarcb_bus_addr &= cpu_to_le64(~0x1FULL);5146 5147	ioarcb->request_flags0 |= NO_LINK_DESCS;5148	ioarcb->data_transfer_length =5149		cpu_to_le32(sizeof(struct pmcraid_config_table));5150 5151	ioadl = &(ioarcb->add_data.u.ioadl[0]);5152	ioadl->flags = IOADL_FLAGS_LAST_DESC;5153	ioadl->address = cpu_to_le64(pinstance->cfg_table_bus_addr);5154	ioadl->data_len = cpu_to_le32(sizeof(struct pmcraid_config_table));5155 5156	pmcraid_send_cmd(cmd, pmcraid_init_res_table,5157			 PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);5158}5159 5160 5161/**5162 * pmcraid_probe - PCI probe entry pointer for PMC MaxRAID controller driver5163 * @pdev: pointer to pci device structure5164 * @dev_id: pointer to device ids structure5165 *5166 * Return Value5167 *	returns 0 if the device is claimed and successfully configured.5168 *	returns non-zero error code in case of any failure5169 */5170static int pmcraid_probe(struct pci_dev *pdev,5171			 const struct pci_device_id *dev_id)5172{5173	struct pmcraid_instance *pinstance;5174	struct Scsi_Host *host;5175	void __iomem *mapped_pci_addr;5176	int rc = PCIBIOS_SUCCESSFUL;5177 5178	if (atomic_read(&pmcraid_adapter_count) >= PMCRAID_MAX_ADAPTERS) {5179		pmcraid_err5180			("maximum number(%d) of supported adapters reached\n",5181			 atomic_read(&pmcraid_adapter_count));5182		return -ENOMEM;5183	}5184 5185	atomic_inc(&pmcraid_adapter_count);5186	rc = pci_enable_device(pdev);5187 5188	if (rc) {5189		dev_err(&pdev->dev, "Cannot enable adapter\n");5190		atomic_dec(&pmcraid_adapter_count);5191		return rc;5192	}5193 5194	dev_info(&pdev->dev,5195		"Found new IOA(%x:%x), Total IOA count: %d\n",5196		 pdev->vendor, pdev->device,5197		 atomic_read(&pmcraid_adapter_count));5198 5199	rc = pci_request_regions(pdev, PMCRAID_DRIVER_NAME);5200 5201	if (rc < 0) {5202		dev_err(&pdev->dev,5203			"Couldn't register memory range of registers\n");5204		goto out_disable_device;5205	}5206 5207	mapped_pci_addr = pci_iomap(pdev, 0, 0);5208 5209	if (!mapped_pci_addr) {5210		dev_err(&pdev->dev, "Couldn't map PCI registers memory\n");5211		rc = -ENOMEM;5212		goto out_release_regions;5213	}5214 5215	pci_set_master(pdev);5216 5217	/* Firmware requires the system bus address of IOARCB to be within5218	 * 32-bit addressable range though it has 64-bit IOARRIN register.5219	 * However, firmware supports 64-bit streaming DMA buffers, whereas5220	 * coherent buffers are to be 32-bit. Since dma_alloc_coherent always5221	 * returns memory within 4GB (if not, change this logic), coherent5222	 * buffers are within firmware acceptable address ranges.5223	 */5224	if (sizeof(dma_addr_t) == 4 ||5225	    dma_set_mask(&pdev->dev, DMA_BIT_MASK(64)))5226		rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));5227 5228	/* firmware expects 32-bit DMA addresses for IOARRIN register; set 325229	 * bit mask for dma_alloc_coherent to return addresses within 4GB5230	 */5231	if (rc == 0)5232		rc = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));5233 5234	if (rc != 0) {5235		dev_err(&pdev->dev, "Failed to set PCI DMA mask\n");5236		goto cleanup_nomem;5237	}5238 5239	host = scsi_host_alloc(&pmcraid_host_template,5240				sizeof(struct pmcraid_instance));5241 5242	if (!host) {5243		dev_err(&pdev->dev, "scsi_host_alloc failed!\n");5244		rc = -ENOMEM;5245		goto cleanup_nomem;5246	}5247 5248	host->max_id = PMCRAID_MAX_NUM_TARGETS_PER_BUS;5249	host->max_lun = PMCRAID_MAX_NUM_LUNS_PER_TARGET;5250	host->unique_id = host->host_no;5251	host->max_channel = PMCRAID_MAX_BUS_TO_SCAN;5252	host->max_cmd_len = PMCRAID_MAX_CDB_LEN;5253 5254	/* zero out entire instance structure */5255	pinstance = (struct pmcraid_instance *)host->hostdata;5256	memset(pinstance, 0, sizeof(*pinstance));5257 5258	pinstance->chip_cfg =5259		(struct pmcraid_chip_details *)(dev_id->driver_data);5260 5261	rc = pmcraid_init_instance(pdev, host, mapped_pci_addr);5262 5263	if (rc < 0) {5264		dev_err(&pdev->dev, "failed to initialize adapter instance\n");5265		goto out_scsi_host_put;5266	}5267 5268	pci_set_drvdata(pdev, pinstance);5269 5270	/* Save PCI config-space for use following the reset */5271	rc = pci_save_state(pinstance->pdev);5272 5273	if (rc != 0) {5274		dev_err(&pdev->dev, "Failed to save PCI config space\n");5275		goto out_scsi_host_put;5276	}5277 5278	pmcraid_disable_interrupts(pinstance, ~0);5279 5280	rc = pmcraid_register_interrupt_handler(pinstance);5281 5282	if (rc) {5283		dev_err(&pdev->dev, "couldn't register interrupt handler\n");5284		goto out_scsi_host_put;5285	}5286 5287	pmcraid_init_tasklets(pinstance);5288 5289	/* allocate verious buffers used by LLD.*/5290	rc = pmcraid_init_buffers(pinstance);5291 5292	if (rc) {5293		pmcraid_err("couldn't allocate memory blocks\n");5294		goto out_unregister_isr;5295	}5296 5297	/* check the reset type required */5298	pmcraid_reset_type(pinstance);5299 5300	pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);5301 5302	/* Start IOA firmware initialization and bring card to Operational5303	 * state.5304	 */5305	pmcraid_info("starting IOA initialization sequence\n");5306	if (pmcraid_reset_bringup(pinstance)) {5307		dev_err(&pdev->dev, "couldn't initialize IOA\n");5308		rc = 1;5309		goto out_release_bufs;5310	}5311 5312	/* Add adapter instance into mid-layer list */5313	rc = scsi_add_host(pinstance->host, &pdev->dev);5314	if (rc != 0) {5315		pmcraid_err("couldn't add host into mid-layer: %d\n", rc);5316		goto out_release_bufs;5317	}5318 5319	scsi_scan_host(pinstance->host);5320 5321	rc = pmcraid_setup_chrdev(pinstance);5322 5323	if (rc != 0) {5324		pmcraid_err("couldn't create mgmt interface, error: %x\n",5325			     rc);5326		goto out_remove_host;5327	}5328 5329	/* Schedule worker thread to handle CCN and take care of adding and5330	 * removing devices to OS5331	 */5332	atomic_set(&pinstance->expose_resources, 1);5333	schedule_work(&pinstance->worker_q);5334	return rc;5335 5336out_remove_host:5337	scsi_remove_host(host);5338 5339out_release_bufs:5340	pmcraid_release_buffers(pinstance);5341 5342out_unregister_isr:5343	pmcraid_kill_tasklets(pinstance);5344	pmcraid_unregister_interrupt_handler(pinstance);5345 5346out_scsi_host_put:5347	scsi_host_put(host);5348 5349cleanup_nomem:5350	iounmap(mapped_pci_addr);5351 5352out_release_regions:5353	pci_release_regions(pdev);5354 5355out_disable_device:5356	atomic_dec(&pmcraid_adapter_count);5357	pci_disable_device(pdev);5358	return -ENODEV;5359}5360 5361static SIMPLE_DEV_PM_OPS(pmcraid_pm_ops, pmcraid_suspend, pmcraid_resume);5362 5363/*5364 * PCI driver structure of pmcraid driver5365 */5366static struct pci_driver pmcraid_driver = {5367	.name = PMCRAID_DRIVER_NAME,5368	.id_table = pmcraid_pci_table,5369	.probe = pmcraid_probe,5370	.remove = pmcraid_remove,5371	.driver.pm = &pmcraid_pm_ops,5372	.shutdown = pmcraid_shutdown5373};5374 5375/**5376 * pmcraid_init - module load entry point5377 */5378static int __init pmcraid_init(void)5379{5380	dev_t dev;5381	int error;5382 5383	pmcraid_info("%s Device Driver version: %s\n",5384			 PMCRAID_DRIVER_NAME, PMCRAID_DRIVER_VERSION);5385 5386	error = alloc_chrdev_region(&dev, 0,5387				    PMCRAID_MAX_ADAPTERS,5388				    PMCRAID_DEVFILE);5389 5390	if (error) {5391		pmcraid_err("failed to get a major number for adapters\n");5392		goto out_init;5393	}5394 5395	pmcraid_major = MAJOR(dev);5396 5397	error = class_register(&pmcraid_class);5398 5399	if (error) {5400		pmcraid_err("failed to register with sysfs, error = %x\n",5401			    error);5402		goto out_unreg_chrdev;5403	}5404 5405	error = pmcraid_netlink_init();5406 5407	if (error) {5408		class_unregister(&pmcraid_class);5409		goto out_unreg_chrdev;5410	}5411 5412	error = pci_register_driver(&pmcraid_driver);5413 5414	if (error == 0)5415		goto out_init;5416 5417	pmcraid_err("failed to register pmcraid driver, error = %x\n",5418		     error);5419	class_unregister(&pmcraid_class);5420	pmcraid_netlink_release();5421 5422out_unreg_chrdev:5423	unregister_chrdev_region(MKDEV(pmcraid_major, 0), PMCRAID_MAX_ADAPTERS);5424 5425out_init:5426	return error;5427}5428 5429/**5430 * pmcraid_exit - module unload entry point5431 */5432static void __exit pmcraid_exit(void)5433{5434	pmcraid_netlink_release();5435	unregister_chrdev_region(MKDEV(pmcraid_major, 0),5436				 PMCRAID_MAX_ADAPTERS);5437	pci_unregister_driver(&pmcraid_driver);5438	class_unregister(&pmcraid_class);5439}5440 5441module_init(pmcraid_init);5442module_exit(pmcraid_exit);5443