projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
megaraid: Use pci_enable_msix_range() instead of pci_enable_msix()
[deliverable/linux.git] / drivers / scsi / megaraid / megaraid_sas_base.c
CommitLineData
c4a3e0a5 1/*
3f1530c1 2 * Linux MegaRAID driver for SAS based RAID controllers
c4a3e0a5 3 *
ae59057b 4 * Copyright (c) 2003-2012 LSI Corporation.
c4a3e0a5 5 *
3f1530c1 6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
c4a3e0a5 10 *
3f1530c1 11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
c4a3e0a5 15 *
3f1530c1 16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
c4a3e0a5 19 *
3f1530c1 20 * FILE: megaraid_sas_base.c
10b1db86 21 * Version : 06.803.01.00-rc1
c4a3e0a5 22 *
3f1530c1 23 * Authors: LSI Corporation
24 * Sreenivas Bagalkote
25 * Sumant Patro
26 * Bo Yang
00fa2b19 27 * Adam Radford <linuxraid@lsi.com>
c4a3e0a5 28 *
3f1530c1 29 * Send feedback to: <megaraidlinux@lsi.com>
30 *
31 * Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
32 * ATTN: Linuxraid
c4a3e0a5
BS		 33 */
34
35#include <linux/kernel.h>
36#include <linux/types.h>
37#include <linux/pci.h>
38#include <linux/list.h>
c4a3e0a5
BS		 39#include <linux/moduleparam.h>
40#include <linux/module.h>
41#include <linux/spinlock.h>
42#include <linux/interrupt.h>
43#include <linux/delay.h>
44#include <linux/uio.h>
5a0e3ad6 45#include <linux/slab.h>
c4a3e0a5 46#include <asm/uaccess.h>
43399236 47#include <linux/fs.h>
c4a3e0a5 48#include <linux/compat.h>
cf62a0a5 49#include <linux/blkdev.h>
0b950672 50#include <linux/mutex.h>
c3518837 51#include <linux/poll.h>
c4a3e0a5
BS		 52
53#include <scsi/scsi.h>
54#include <scsi/scsi_cmnd.h>
55#include <scsi/scsi_device.h>
56#include <scsi/scsi_host.h>
4bcde509 57#include <scsi/scsi_tcq.h>
9c915a8c 58#include "megaraid_sas_fusion.h"
c4a3e0a5
BS		 59#include "megaraid_sas.h"
60
1fd10685
YB		 61/*
62 * Number of sectors per IO command
63 * Will be set in megasas_init_mfi if user does not provide
64 */
65static unsigned int max_sectors;
66module_param_named(max_sectors, max_sectors, int, 0);
67MODULE_PARM_DESC(max_sectors,
68 "Maximum number of sectors per IO command");
69
80d9da98 70static int msix_disable;
71module_param(msix_disable, int, S_IRUGO);
72MODULE_PARM_DESC(msix_disable, "Disable MSI-X interrupt handling. Default: 0");
73
079eaddf 74static unsigned int msix_vectors;
75module_param(msix_vectors, int, S_IRUGO);
76MODULE_PARM_DESC(msix_vectors, "MSI-X max vector count. Default: Set by FW");
77
229fe47c 78static int allow_vf_ioctls;
79module_param(allow_vf_ioctls, int, S_IRUGO);
80MODULE_PARM_DESC(allow_vf_ioctls, "Allow ioctls in SR-IOV VF mode. Default: 0");
81
c5daa6a9 82static int throttlequeuedepth = MEGASAS_THROTTLE_QUEUE_DEPTH;
83module_param(throttlequeuedepth, int, S_IRUGO);
84MODULE_PARM_DESC(throttlequeuedepth,
85 "Adapter queue depth when throttled due to I/O timeout. Default: 16");
86
c007b8b2 87int resetwaittime = MEGASAS_RESET_WAIT_TIME;
88module_param(resetwaittime, int, S_IRUGO);
89MODULE_PARM_DESC(resetwaittime, "Wait time in seconds after I/O timeout "
90 "before resetting adapter. Default: 180");
91
c4a3e0a5
BS		 92MODULE_LICENSE("GPL");
93MODULE_VERSION(MEGASAS_VERSION);
3d6d174a 94MODULE_AUTHOR("megaraidlinux@lsi.com");
f28cd7cf 95MODULE_DESCRIPTION("LSI MegaRAID SAS Driver");
c4a3e0a5 96
058a8fac 97int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
39a98554 98static int megasas_get_pd_list(struct megasas_instance *instance);
21c9e160 99static int megasas_ld_list_query(struct megasas_instance *instance,
100 u8 query_type);
39a98554 101static int megasas_issue_init_mfi(struct megasas_instance *instance);
102static int megasas_register_aen(struct megasas_instance *instance,
103 u32 seq_num, u32 class_locale_word);
c4a3e0a5
BS		 104/*
105 * PCI ID table for all supported controllers
106 */
107static struct pci_device_id megasas_pci_table[] = {
108
f3d7271c
HK		 109 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064R)},
110 /* xscale IOP */
111 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078R)},
112 /* ppc IOP */
af7a5647 113 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078DE)},
114 /* ppc IOP */
6610a6b3
YB		 115 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078GEN2)},
116 /* gen2*/
117 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0079GEN2)},
118 /* gen2*/
87911122
YB		 119 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0073SKINNY)},
120 /* skinny*/
121 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0071SKINNY)},
122 /* skinny*/
f3d7271c
HK		 123 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VERDE_ZCR)},
124 /* xscale IOP, vega */
125 {PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)},
126 /* xscale IOP */
9c915a8c 127 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FUSION)},
128 /* Fusion */
229fe47c 129 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_PLASMA)},
130 /* Plasma */
36807e67 131 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_INVADER)},
132 /* Invader */
21d3c710
SS		 133 {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FURY)},
134 /* Fury */
f3d7271c 135 {}
c4a3e0a5
BS		 136};
137
138MODULE_DEVICE_TABLE(pci, megasas_pci_table);
139
140static int megasas_mgmt_majorno;
229fe47c 141struct megasas_mgmt_info megasas_mgmt_info;
c4a3e0a5 142static struct fasync_struct *megasas_async_queue;
0b950672 143static DEFINE_MUTEX(megasas_async_queue_mutex);
c4a3e0a5 144
c3518837
YB		 145static int megasas_poll_wait_aen;
146static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait);
72c4fd36 147static u32 support_poll_for_event;
9c915a8c 148u32 megasas_dbg_lvl;
837f5fe8 149static u32 support_device_change;
658dcedb 150
c3518837
YB		 151/* define lock for aen poll */
152spinlock_t poll_aen_lock;
153
9c915a8c 154void
7343eb65 155megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
156 u8 alt_status);
ebf054b0 157static u32
158megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs);
159static int
160megasas_adp_reset_gen2(struct megasas_instance *instance,
161 struct megasas_register_set __iomem *reg_set);
cd50ba8e 162static irqreturn_t megasas_isr(int irq, void *devp);
163static u32
164megasas_init_adapter_mfi(struct megasas_instance *instance);
165u32
166megasas_build_and_issue_cmd(struct megasas_instance *instance,
167 struct scsi_cmnd *scmd);
168static void megasas_complete_cmd_dpc(unsigned long instance_addr);
9c915a8c 169void
170megasas_release_fusion(struct megasas_instance *instance);
171int
172megasas_ioc_init_fusion(struct megasas_instance *instance);
173void
174megasas_free_cmds_fusion(struct megasas_instance *instance);
175u8
176megasas_get_map_info(struct megasas_instance *instance);
177int
178megasas_sync_map_info(struct megasas_instance *instance);
179int
229fe47c 180wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
181 int seconds);
9c915a8c 182void megasas_reset_reply_desc(struct megasas_instance *instance);
229fe47c 183int megasas_reset_fusion(struct Scsi_Host *shost, int iotimeout);
9c915a8c 184void megasas_fusion_ocr_wq(struct work_struct *work);
229fe47c 185static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,
186 int initial);
187int megasas_check_mpio_paths(struct megasas_instance *instance,
188 struct scsi_cmnd *scmd);
cd50ba8e 189
190void
191megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
192{
193 instance->instancet->fire_cmd(instance,
194 cmd->frame_phys_addr, 0, instance->reg_set);
195}
7343eb65 196
c4a3e0a5
BS		 197/**
198 * megasas_get_cmd - Get a command from the free pool
199 * @instance: Adapter soft state
200 *
201 * Returns a free command from the pool
202 */
9c915a8c 203struct megasas_cmd *megasas_get_cmd(struct megasas_instance
c4a3e0a5
BS		 204 *instance)
205{
206 unsigned long flags;
207 struct megasas_cmd *cmd = NULL;
208
209 spin_lock_irqsave(&instance->cmd_pool_lock, flags);
210
211 if (!list_empty(&instance->cmd_pool)) {
212 cmd = list_entry((&instance->cmd_pool)->next,
213 struct megasas_cmd, list);
214 list_del_init(&cmd->list);
215 } else {
216 printk(KERN_ERR "megasas: Command pool empty!\n");
217 }
218
219 spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
220 return cmd;
221}
222
223/**
224 * megasas_return_cmd - Return a cmd to free command pool
225 * @instance: Adapter soft state
226 * @cmd: Command packet to be returned to free command pool
227 */
9c915a8c 228inline void
c4a3e0a5
BS		 229megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
230{
231 unsigned long flags;
232
233 spin_lock_irqsave(&instance->cmd_pool_lock, flags);
234
235 cmd->scmd = NULL;
9c915a8c 236 cmd->frame_count = 0;
e5f93a36 237 if ((instance->pdev->device != PCI_DEVICE_ID_LSI_FUSION) &&
229fe47c 238 (instance->pdev->device != PCI_DEVICE_ID_LSI_PLASMA) &&
e5f93a36 239 (instance->pdev->device != PCI_DEVICE_ID_LSI_INVADER) &&
21d3c710 240 (instance->pdev->device != PCI_DEVICE_ID_LSI_FURY) &&
e5f93a36 241 (reset_devices))
242 cmd->frame->hdr.cmd = MFI_CMD_INVALID;
c4a3e0a5
BS		 243 list_add_tail(&cmd->list, &instance->cmd_pool);
244
245 spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
246}
247
1341c939
SP		 248
249/**
0d49016b 250* The following functions are defined for xscale
1341c939
SP		 251* (deviceid : 1064R, PERC5) controllers
252*/
253
c4a3e0a5 254/**
1341c939 255 * megasas_enable_intr_xscale - Enables interrupts
c4a3e0a5
BS		 256 * @regs: MFI register set
257 */
258static inline void
d46a3ad6 259megasas_enable_intr_xscale(struct megasas_instance *instance)
c4a3e0a5 260{
d46a3ad6
SS		 261 struct megasas_register_set __iomem *regs;
262 regs = instance->reg_set;
39a98554 263 writel(0, &(regs)->outbound_intr_mask);
c4a3e0a5
BS		 264
265 /* Dummy readl to force pci flush */
266 readl(&regs->outbound_intr_mask);
267}
268
b274cab7
SP		 269/**
270 * megasas_disable_intr_xscale -Disables interrupt
271 * @regs: MFI register set
272 */
273static inline void
d46a3ad6 274megasas_disable_intr_xscale(struct megasas_instance *instance)
b274cab7 275{
d46a3ad6 276 struct megasas_register_set __iomem *regs;
b274cab7 277 u32 mask = 0x1f;
d46a3ad6 278 regs = instance->reg_set;
b274cab7
SP		 279 writel(mask, &regs->outbound_intr_mask);
280 /* Dummy readl to force pci flush */
281 readl(&regs->outbound_intr_mask);
282}
283
1341c939
SP		 284/**
285 * megasas_read_fw_status_reg_xscale - returns the current FW status value
286 * @regs: MFI register set
287 */
288static u32
289megasas_read_fw_status_reg_xscale(struct megasas_register_set __iomem * regs)
290{
291 return readl(&(regs)->outbound_msg_0);
292}
293/**
294 * megasas_clear_interrupt_xscale - Check & clear interrupt
295 * @regs: MFI register set
296 */
0d49016b 297static int
1341c939
SP		 298megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs)
299{
300 u32 status;
39a98554 301 u32 mfiStatus = 0;
1341c939
SP		 302 /*
303 * Check if it is our interrupt
304 */
305 status = readl(&regs->outbound_intr_status);
306
39a98554 307 if (status & MFI_OB_INTR_STATUS_MASK)
308 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
309 if (status & MFI_XSCALE_OMR0_CHANGE_INTERRUPT)
310 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
1341c939
SP		 311
312 /*
313 * Clear the interrupt by writing back the same value
314 */
39a98554 315 if (mfiStatus)
316 writel(status, &regs->outbound_intr_status);
1341c939 317
06f579de
YB		 318 /* Dummy readl to force pci flush */
319 readl(&regs->outbound_intr_status);
320
39a98554 321 return mfiStatus;
1341c939
SP		 322}
323
324/**
325 * megasas_fire_cmd_xscale - Sends command to the FW
326 * @frame_phys_addr : Physical address of cmd
327 * @frame_count : Number of frames for the command
328 * @regs : MFI register set
329 */
0d49016b 330static inline void
0c79e681
YB		 331megasas_fire_cmd_xscale(struct megasas_instance *instance,
332 dma_addr_t frame_phys_addr,
333 u32 frame_count,
334 struct megasas_register_set __iomem *regs)
1341c939 335{
39a98554 336 unsigned long flags;
337 spin_lock_irqsave(&instance->hba_lock, flags);
1341c939
SP		 338 writel((frame_phys_addr >> 3)|(frame_count),
339 &(regs)->inbound_queue_port);
39a98554 340 spin_unlock_irqrestore(&instance->hba_lock, flags);
341}
342
343/**
344 * megasas_adp_reset_xscale - For controller reset
345 * @regs: MFI register set
346 */
347static int
348megasas_adp_reset_xscale(struct megasas_instance *instance,
349 struct megasas_register_set __iomem *regs)
350{
351 u32 i;
352 u32 pcidata;
353 writel(MFI_ADP_RESET, &regs->inbound_doorbell);
354
355 for (i = 0; i < 3; i++)
356 msleep(1000); /* sleep for 3 secs */
357 pcidata = 0;
358 pci_read_config_dword(instance->pdev, MFI_1068_PCSR_OFFSET, &pcidata);
359 printk(KERN_NOTICE "pcidata = %x\n", pcidata);
360 if (pcidata & 0x2) {
361 printk(KERN_NOTICE "mfi 1068 offset read=%x\n", pcidata);
362 pcidata &= ~0x2;
363 pci_write_config_dword(instance->pdev,
364 MFI_1068_PCSR_OFFSET, pcidata);
365
366 for (i = 0; i < 2; i++)
367 msleep(1000); /* need to wait 2 secs again */
368
369 pcidata = 0;
370 pci_read_config_dword(instance->pdev,
371 MFI_1068_FW_HANDSHAKE_OFFSET, &pcidata);
372 printk(KERN_NOTICE "1068 offset handshake read=%x\n", pcidata);
373 if ((pcidata & 0xffff0000) == MFI_1068_FW_READY) {
374 printk(KERN_NOTICE "1068 offset pcidt=%x\n", pcidata);
375 pcidata = 0;
376 pci_write_config_dword(instance->pdev,
377 MFI_1068_FW_HANDSHAKE_OFFSET, pcidata);
378 }
379 }
380 return 0;
381}
382
383/**
384 * megasas_check_reset_xscale - For controller reset check
385 * @regs: MFI register set
386 */
387static int
388megasas_check_reset_xscale(struct megasas_instance *instance,
389 struct megasas_register_set __iomem *regs)
390{
39a98554 391
392 if ((instance->adprecovery != MEGASAS_HBA_OPERATIONAL) &&
94cd65dd
SS		 393 (le32_to_cpu(*instance->consumer) ==
394 MEGASAS_ADPRESET_INPROG_SIGN))
39a98554 395 return 1;
39a98554 396 return 0;
1341c939
SP		 397}
398
399static struct megasas_instance_template megasas_instance_template_xscale = {
400
401 .fire_cmd = megasas_fire_cmd_xscale,
402 .enable_intr = megasas_enable_intr_xscale,
b274cab7 403 .disable_intr = megasas_disable_intr_xscale,
1341c939
SP		 404 .clear_intr = megasas_clear_intr_xscale,
405 .read_fw_status_reg = megasas_read_fw_status_reg_xscale,
39a98554 406 .adp_reset = megasas_adp_reset_xscale,
407 .check_reset = megasas_check_reset_xscale,
cd50ba8e 408 .service_isr = megasas_isr,
409 .tasklet = megasas_complete_cmd_dpc,
410 .init_adapter = megasas_init_adapter_mfi,
411 .build_and_issue_cmd = megasas_build_and_issue_cmd,
412 .issue_dcmd = megasas_issue_dcmd,
1341c939
SP		 413};
414
415/**
0d49016b 416* This is the end of set of functions & definitions specific
1341c939
SP		 417* to xscale (deviceid : 1064R, PERC5) controllers
418*/
419
f9876f0b 420/**
0d49016b 421* The following functions are defined for ppc (deviceid : 0x60)
f9876f0b
SP		 422* controllers
423*/
424
425/**
426 * megasas_enable_intr_ppc - Enables interrupts
427 * @regs: MFI register set
428 */
429static inline void
d46a3ad6 430megasas_enable_intr_ppc(struct megasas_instance *instance)
f9876f0b 431{
d46a3ad6
SS		 432 struct megasas_register_set __iomem *regs;
433 regs = instance->reg_set;
f9876f0b 434 writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
0d49016b 435
39a98554 436 writel(~0x80000000, &(regs)->outbound_intr_mask);
f9876f0b
SP		 437
438 /* Dummy readl to force pci flush */
439 readl(&regs->outbound_intr_mask);
440}
441
b274cab7
SP		 442/**
443 * megasas_disable_intr_ppc - Disable interrupt
444 * @regs: MFI register set
445 */
446static inline void
d46a3ad6 447megasas_disable_intr_ppc(struct megasas_instance *instance)
b274cab7 448{
d46a3ad6 449 struct megasas_register_set __iomem *regs;
b274cab7 450 u32 mask = 0xFFFFFFFF;
d46a3ad6 451 regs = instance->reg_set;
b274cab7
SP		 452 writel(mask, &regs->outbound_intr_mask);
453 /* Dummy readl to force pci flush */
454 readl(&regs->outbound_intr_mask);
455}
456
f9876f0b
SP		 457/**
458 * megasas_read_fw_status_reg_ppc - returns the current FW status value
459 * @regs: MFI register set
460 */
461static u32
462megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem * regs)
463{
464 return readl(&(regs)->outbound_scratch_pad);
465}
466
467/**
468 * megasas_clear_interrupt_ppc - Check & clear interrupt
469 * @regs: MFI register set
470 */
0d49016b 471static int
f9876f0b
SP		 472megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
473{
3cc6851f 474 u32 status, mfiStatus = 0;
475
f9876f0b
SP		 476 /*
477 * Check if it is our interrupt
478 */
479 status = readl(&regs->outbound_intr_status);
480
3cc6851f 481 if (status & MFI_REPLY_1078_MESSAGE_INTERRUPT)
482 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
483
484 if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT)
485 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
f9876f0b
SP		 486
487 /*
488 * Clear the interrupt by writing back the same value
489 */
490 writel(status, &regs->outbound_doorbell_clear);
491
06f579de
YB		 492 /* Dummy readl to force pci flush */
493 readl(&regs->outbound_doorbell_clear);
494
3cc6851f 495 return mfiStatus;
f9876f0b 496}
3cc6851f 497
f9876f0b
SP		 498/**
499 * megasas_fire_cmd_ppc - Sends command to the FW
500 * @frame_phys_addr : Physical address of cmd
501 * @frame_count : Number of frames for the command
502 * @regs : MFI register set
503 */
0d49016b 504static inline void
0c79e681
YB		 505megasas_fire_cmd_ppc(struct megasas_instance *instance,
506 dma_addr_t frame_phys_addr,
507 u32 frame_count,
508 struct megasas_register_set __iomem *regs)
f9876f0b 509{
39a98554 510 unsigned long flags;
511 spin_lock_irqsave(&instance->hba_lock, flags);
0d49016b 512 writel((frame_phys_addr | (frame_count<<1))|1,
f9876f0b 513 &(regs)->inbound_queue_port);
39a98554 514 spin_unlock_irqrestore(&instance->hba_lock, flags);
f9876f0b
SP		 515}
516
39a98554 517/**
518 * megasas_check_reset_ppc - For controller reset check
519 * @regs: MFI register set
520 */
521static int
522megasas_check_reset_ppc(struct megasas_instance *instance,
523 struct megasas_register_set __iomem *regs)
524{
3cc6851f 525 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
526 return 1;
527
39a98554 528 return 0;
529}
3cc6851f 530
f9876f0b 531static struct megasas_instance_template megasas_instance_template_ppc = {
0d49016b 532
f9876f0b
SP		 533 .fire_cmd = megasas_fire_cmd_ppc,
534 .enable_intr = megasas_enable_intr_ppc,
b274cab7 535 .disable_intr = megasas_disable_intr_ppc,
f9876f0b
SP		 536 .clear_intr = megasas_clear_intr_ppc,
537 .read_fw_status_reg = megasas_read_fw_status_reg_ppc,
3cc6851f 538 .adp_reset = megasas_adp_reset_xscale,
39a98554 539 .check_reset = megasas_check_reset_ppc,
cd50ba8e 540 .service_isr = megasas_isr,
541 .tasklet = megasas_complete_cmd_dpc,
542 .init_adapter = megasas_init_adapter_mfi,
543 .build_and_issue_cmd = megasas_build_and_issue_cmd,
544 .issue_dcmd = megasas_issue_dcmd,
f9876f0b
SP		 545};
546
87911122
YB		 547/**
548 * megasas_enable_intr_skinny - Enables interrupts
549 * @regs: MFI register set
550 */
551static inline void
d46a3ad6 552megasas_enable_intr_skinny(struct megasas_instance *instance)
87911122 553{
d46a3ad6
SS		 554 struct megasas_register_set __iomem *regs;
555 regs = instance->reg_set;
87911122
YB		 556 writel(0xFFFFFFFF, &(regs)->outbound_intr_mask);
557
558 writel(~MFI_SKINNY_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
559
560 /* Dummy readl to force pci flush */
561 readl(&regs->outbound_intr_mask);
562}
563
564/**
565 * megasas_disable_intr_skinny - Disables interrupt
566 * @regs: MFI register set
567 */
568static inline void
d46a3ad6 569megasas_disable_intr_skinny(struct megasas_instance *instance)
87911122 570{
d46a3ad6 571 struct megasas_register_set __iomem *regs;
87911122 572 u32 mask = 0xFFFFFFFF;
d46a3ad6 573 regs = instance->reg_set;
87911122
YB		 574 writel(mask, &regs->outbound_intr_mask);
575 /* Dummy readl to force pci flush */
576 readl(&regs->outbound_intr_mask);
577}
578
579/**
580 * megasas_read_fw_status_reg_skinny - returns the current FW status value
581 * @regs: MFI register set
582 */
583static u32
584megasas_read_fw_status_reg_skinny(struct megasas_register_set __iomem *regs)
585{
586 return readl(&(regs)->outbound_scratch_pad);
587}
588
589/**
590 * megasas_clear_interrupt_skinny - Check & clear interrupt
591 * @regs: MFI register set
592 */
593static int
594megasas_clear_intr_skinny(struct megasas_register_set __iomem *regs)
595{
596 u32 status;
ebf054b0 597 u32 mfiStatus = 0;
598
87911122
YB		 599 /*
600 * Check if it is our interrupt
601 */
602 status = readl(&regs->outbound_intr_status);
603
604 if (!(status & MFI_SKINNY_ENABLE_INTERRUPT_MASK)) {
39a98554 605 return 0;
87911122
YB		 606 }
607
ebf054b0 608 /*
609 * Check if it is our interrupt
610 */
a3fda7dd 611 if ((megasas_read_fw_status_reg_skinny(regs) & MFI_STATE_MASK) ==
ebf054b0 612 MFI_STATE_FAULT) {
613 mfiStatus = MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
614 } else
615 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
616
87911122
YB		 617 /*
618 * Clear the interrupt by writing back the same value
619 */
620 writel(status, &regs->outbound_intr_status);
621
622 /*
623 * dummy read to flush PCI
624 */
625 readl(&regs->outbound_intr_status);
626
ebf054b0 627 return mfiStatus;
87911122
YB		 628}
629
630/**
631 * megasas_fire_cmd_skinny - Sends command to the FW
632 * @frame_phys_addr : Physical address of cmd
633 * @frame_count : Number of frames for the command
634 * @regs : MFI register set
635 */
636static inline void
0c79e681
YB		 637megasas_fire_cmd_skinny(struct megasas_instance *instance,
638 dma_addr_t frame_phys_addr,
639 u32 frame_count,
87911122
YB		 640 struct megasas_register_set __iomem *regs)
641{
0c79e681 642 unsigned long flags;
39a98554 643 spin_lock_irqsave(&instance->hba_lock, flags);
94cd65dd
SS		 644 writel(upper_32_bits(frame_phys_addr),
645 &(regs)->inbound_high_queue_port);
646 writel((lower_32_bits(frame_phys_addr) | (frame_count<<1))|1,
647 &(regs)->inbound_low_queue_port);
39a98554 648 spin_unlock_irqrestore(&instance->hba_lock, flags);
649}
650
39a98554 651/**
652 * megasas_check_reset_skinny - For controller reset check
653 * @regs: MFI register set
654 */
655static int
656megasas_check_reset_skinny(struct megasas_instance *instance,
657 struct megasas_register_set __iomem *regs)
658{
3cc6851f 659 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
660 return 1;
661
39a98554 662 return 0;
87911122
YB		 663}
664
665static struct megasas_instance_template megasas_instance_template_skinny = {
666
667 .fire_cmd = megasas_fire_cmd_skinny,
668 .enable_intr = megasas_enable_intr_skinny,
669 .disable_intr = megasas_disable_intr_skinny,
670 .clear_intr = megasas_clear_intr_skinny,
671 .read_fw_status_reg = megasas_read_fw_status_reg_skinny,
ebf054b0 672 .adp_reset = megasas_adp_reset_gen2,
39a98554 673 .check_reset = megasas_check_reset_skinny,
cd50ba8e 674 .service_isr = megasas_isr,
675 .tasklet = megasas_complete_cmd_dpc,
676 .init_adapter = megasas_init_adapter_mfi,
677 .build_and_issue_cmd = megasas_build_and_issue_cmd,
678 .issue_dcmd = megasas_issue_dcmd,
87911122
YB		 679};
680
681
6610a6b3
YB		 682/**
683* The following functions are defined for gen2 (deviceid : 0x78 0x79)
684* controllers
685*/
686
687/**
688 * megasas_enable_intr_gen2 - Enables interrupts
689 * @regs: MFI register set
690 */
691static inline void
d46a3ad6 692megasas_enable_intr_gen2(struct megasas_instance *instance)
6610a6b3 693{
d46a3ad6
SS		 694 struct megasas_register_set __iomem *regs;
695 regs = instance->reg_set;
6610a6b3
YB		 696 writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
697
698 /* write ~0x00000005 (4 & 1) to the intr mask*/
699 writel(~MFI_GEN2_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
700
701 /* Dummy readl to force pci flush */
702 readl(&regs->outbound_intr_mask);
703}
704
705/**
706 * megasas_disable_intr_gen2 - Disables interrupt
707 * @regs: MFI register set
708 */
709static inline void
d46a3ad6 710megasas_disable_intr_gen2(struct megasas_instance *instance)
6610a6b3 711{
d46a3ad6 712 struct megasas_register_set __iomem *regs;
6610a6b3 713 u32 mask = 0xFFFFFFFF;
d46a3ad6 714 regs = instance->reg_set;
6610a6b3
YB		 715 writel(mask, &regs->outbound_intr_mask);
716 /* Dummy readl to force pci flush */
717 readl(&regs->outbound_intr_mask);
718}
719
720/**
721 * megasas_read_fw_status_reg_gen2 - returns the current FW status value
722 * @regs: MFI register set
723 */
724static u32
725megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs)
726{
727 return readl(&(regs)->outbound_scratch_pad);
728}
729
730/**
731 * megasas_clear_interrupt_gen2 - Check & clear interrupt
732 * @regs: MFI register set
733 */
734static int
735megasas_clear_intr_gen2(struct megasas_register_set __iomem *regs)
736{
737 u32 status;
39a98554 738 u32 mfiStatus = 0;
6610a6b3
YB		 739 /*
740 * Check if it is our interrupt
741 */
742 status = readl(&regs->outbound_intr_status);
743
b5bccadd 744 if (status & MFI_INTR_FLAG_REPLY_MESSAGE) {
39a98554 745 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
746 }
747 if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT) {
748 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
749 }
6610a6b3
YB		 750
751 /*
752 * Clear the interrupt by writing back the same value
753 */
39a98554 754 if (mfiStatus)
755 writel(status, &regs->outbound_doorbell_clear);
6610a6b3
YB		 756
757 /* Dummy readl to force pci flush */
758 readl(&regs->outbound_intr_status);
759
39a98554 760 return mfiStatus;
6610a6b3
YB		 761}
762/**
763 * megasas_fire_cmd_gen2 - Sends command to the FW
764 * @frame_phys_addr : Physical address of cmd
765 * @frame_count : Number of frames for the command
766 * @regs : MFI register set
767 */
768static inline void
0c79e681
YB		 769megasas_fire_cmd_gen2(struct megasas_instance *instance,
770 dma_addr_t frame_phys_addr,
771 u32 frame_count,
6610a6b3
YB		 772 struct megasas_register_set __iomem *regs)
773{
39a98554 774 unsigned long flags;
775 spin_lock_irqsave(&instance->hba_lock, flags);
6610a6b3
YB		 776 writel((frame_phys_addr | (frame_count<<1))|1,
777 &(regs)->inbound_queue_port);
39a98554 778 spin_unlock_irqrestore(&instance->hba_lock, flags);
779}
780
781/**
782 * megasas_adp_reset_gen2 - For controller reset
783 * @regs: MFI register set
784 */
785static int
786megasas_adp_reset_gen2(struct megasas_instance *instance,
787 struct megasas_register_set __iomem *reg_set)
788{
789 u32 retry = 0 ;
790 u32 HostDiag;
ebf054b0 791 u32 *seq_offset = &reg_set->seq_offset;
792 u32 *hostdiag_offset = &reg_set->host_diag;
793
794 if (instance->instancet == &megasas_instance_template_skinny) {
795 seq_offset = &reg_set->fusion_seq_offset;
796 hostdiag_offset = &reg_set->fusion_host_diag;
797 }
798
799 writel(0, seq_offset);
800 writel(4, seq_offset);
801 writel(0xb, seq_offset);
802 writel(2, seq_offset);
803 writel(7, seq_offset);
804 writel(0xd, seq_offset);
39a98554 805
39a98554 806 msleep(1000);
807
ebf054b0 808 HostDiag = (u32)readl(hostdiag_offset);
39a98554 809
810 while ( !( HostDiag & DIAG_WRITE_ENABLE) ) {
811 msleep(100);
ebf054b0 812 HostDiag = (u32)readl(hostdiag_offset);
39a98554 813 printk(KERN_NOTICE "RESETGEN2: retry=%x, hostdiag=%x\n",
814 retry, HostDiag);
815
816 if (retry++ >= 100)
817 return 1;
818
819 }
820
821 printk(KERN_NOTICE "ADP_RESET_GEN2: HostDiag=%x\n", HostDiag);
822
ebf054b0 823 writel((HostDiag | DIAG_RESET_ADAPTER), hostdiag_offset);
39a98554 824
825 ssleep(10);
826
ebf054b0 827 HostDiag = (u32)readl(hostdiag_offset);
39a98554 828 while ( ( HostDiag & DIAG_RESET_ADAPTER) ) {
829 msleep(100);
ebf054b0 830 HostDiag = (u32)readl(hostdiag_offset);
39a98554 831 printk(KERN_NOTICE "RESET_GEN2: retry=%x, hostdiag=%x\n",
832 retry, HostDiag);
833
834 if (retry++ >= 1000)
835 return 1;
836
837 }
838 return 0;
839}
840
841/**
842 * megasas_check_reset_gen2 - For controller reset check
843 * @regs: MFI register set
844 */
845static int
846megasas_check_reset_gen2(struct megasas_instance *instance,
847 struct megasas_register_set __iomem *regs)
848{
707e09bd
YB		 849 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
850 return 1;
851 }
852
39a98554 853 return 0;
6610a6b3
YB		 854}
855
856static struct megasas_instance_template megasas_instance_template_gen2 = {
857
858 .fire_cmd = megasas_fire_cmd_gen2,
859 .enable_intr = megasas_enable_intr_gen2,
860 .disable_intr = megasas_disable_intr_gen2,
861 .clear_intr = megasas_clear_intr_gen2,
862 .read_fw_status_reg = megasas_read_fw_status_reg_gen2,
39a98554 863 .adp_reset = megasas_adp_reset_gen2,
864 .check_reset = megasas_check_reset_gen2,
cd50ba8e 865 .service_isr = megasas_isr,
866 .tasklet = megasas_complete_cmd_dpc,
867 .init_adapter = megasas_init_adapter_mfi,
868 .build_and_issue_cmd = megasas_build_and_issue_cmd,
869 .issue_dcmd = megasas_issue_dcmd,
6610a6b3
YB		 870};
871
f9876f0b
SP		 872/**
873* This is the end of set of functions & definitions
39a98554 874* specific to gen2 (deviceid : 0x78, 0x79) controllers
f9876f0b
SP		 875*/
876
9c915a8c 877/*
878 * Template added for TB (Fusion)
879 */
880extern struct megasas_instance_template megasas_instance_template_fusion;
881
c4a3e0a5
BS		 882/**
883 * megasas_issue_polled - Issues a polling command
884 * @instance: Adapter soft state
0d49016b 885 * @cmd: Command packet to be issued
c4a3e0a5
BS		 886 *
887 * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
888 */
9c915a8c 889int
c4a3e0a5
BS		 890megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
891{
229fe47c 892 int seconds;
c4a3e0a5
BS		 893
894 struct megasas_header *frame_hdr = &cmd->frame->hdr;
895
94cd65dd
SS		 896 frame_hdr->cmd_status = MFI_CMD_STATUS_POLL_MODE;
897 frame_hdr->flags |= cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE);
c4a3e0a5
BS		 898
899 /*
900 * Issue the frame using inbound queue port
901 */
9c915a8c 902 instance->instancet->issue_dcmd(instance, cmd);
c4a3e0a5
BS		 903
904 /*
905 * Wait for cmd_status to change
906 */
229fe47c 907 if (instance->requestorId)
908 seconds = MEGASAS_ROUTINE_WAIT_TIME_VF;
909 else
910 seconds = MFI_POLL_TIMEOUT_SECS;
911 return wait_and_poll(instance, cmd, seconds);
c4a3e0a5
BS		 912}
913
914/**
915 * megasas_issue_blocked_cmd - Synchronous wrapper around regular FW cmds
916 * @instance: Adapter soft state
917 * @cmd: Command to be issued
cfbe7554 918 * @timeout: Timeout in seconds
c4a3e0a5
BS		 919 *
920 * This function waits on an event for the command to be returned from ISR.
2a3681e5 921 * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
c4a3e0a5
BS		 922 * Used to issue ioctl commands.
923 */
924static int
925megasas_issue_blocked_cmd(struct megasas_instance *instance,
cfbe7554 926 struct megasas_cmd *cmd, int timeout)
c4a3e0a5 927{
cfbe7554 928 int ret = 0;
c4a3e0a5
BS		 929 cmd->cmd_status = ENODATA;
930
9c915a8c 931 instance->instancet->issue_dcmd(instance, cmd);
cfbe7554
SS		 932 if (timeout) {
933 ret = wait_event_timeout(instance->int_cmd_wait_q,
934 cmd->cmd_status != ENODATA, timeout * HZ);
935 if (!ret)
936 return 1;
937 } else
938 wait_event(instance->int_cmd_wait_q,
939 cmd->cmd_status != ENODATA);
c4a3e0a5
BS		 940
941 return 0;
942}
943
944/**
945 * megasas_issue_blocked_abort_cmd - Aborts previously issued cmd
946 * @instance: Adapter soft state
947 * @cmd_to_abort: Previously issued cmd to be aborted
cfbe7554 948 * @timeout: Timeout in seconds
c4a3e0a5 949 *
cfbe7554 950 * MFI firmware can abort previously issued AEN comamnd (automatic event
c4a3e0a5 951 * notification). The megasas_issue_blocked_abort_cmd() issues such abort
2a3681e5
SP		 952 * cmd and waits for return status.
953 * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
c4a3e0a5
BS		 954 */
955static int
956megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
cfbe7554 957 struct megasas_cmd *cmd_to_abort, int timeout)
c4a3e0a5
BS		 958{
959 struct megasas_cmd *cmd;
960 struct megasas_abort_frame *abort_fr;
cfbe7554 961 int ret = 0;
c4a3e0a5
BS		 962
963 cmd = megasas_get_cmd(instance);
964
965 if (!cmd)
966 return -1;
967
968 abort_fr = &cmd->frame->abort;
969
970 /*
971 * Prepare and issue the abort frame
972 */
973 abort_fr->cmd = MFI_CMD_ABORT;
974 abort_fr->cmd_status = 0xFF;
94cd65dd
SS		 975 abort_fr->flags = cpu_to_le16(0);
976 abort_fr->abort_context = cpu_to_le32(cmd_to_abort->index);
977 abort_fr->abort_mfi_phys_addr_lo =
978 cpu_to_le32(lower_32_bits(cmd_to_abort->frame_phys_addr));
979 abort_fr->abort_mfi_phys_addr_hi =
980 cpu_to_le32(upper_32_bits(cmd_to_abort->frame_phys_addr));
c4a3e0a5
BS		 981
982 cmd->sync_cmd = 1;
983 cmd->cmd_status = 0xFF;
984
9c915a8c 985 instance->instancet->issue_dcmd(instance, cmd);
c4a3e0a5 986
cfbe7554
SS		 987 if (timeout) {
988 ret = wait_event_timeout(instance->abort_cmd_wait_q,
989 cmd->cmd_status != ENODATA, timeout * HZ);
990 if (!ret) {
991 dev_err(&instance->pdev->dev, "Command timedout"
992 "from %s\n", __func__);
993 return 1;
994 }
995 } else
996 wait_event(instance->abort_cmd_wait_q,
997 cmd->cmd_status != ENODATA);
998
39a98554 999 cmd->sync_cmd = 0;
c4a3e0a5
BS		 1000
1001 megasas_return_cmd(instance, cmd);
1002 return 0;
1003}
1004
1005/**
1006 * megasas_make_sgl32 - Prepares 32-bit SGL
1007 * @instance: Adapter soft state
1008 * @scp: SCSI command from the mid-layer
1009 * @mfi_sgl: SGL to be filled in
1010 *
1011 * If successful, this function returns the number of SG elements. Otherwise,
1012 * it returnes -1.
1013 */
858119e1 1014static int
c4a3e0a5
BS		 1015megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
1016 union megasas_sgl *mfi_sgl)
1017{
1018 int i;
1019 int sge_count;
1020 struct scatterlist *os_sgl;
1021
155d98f0
FT		 1022 sge_count = scsi_dma_map(scp);
1023 BUG_ON(sge_count < 0);
c4a3e0a5 1024
155d98f0
FT		 1025 if (sge_count) {
1026 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
94cd65dd
SS		 1027 mfi_sgl->sge32[i].length = cpu_to_le32(sg_dma_len(os_sgl));
1028 mfi_sgl->sge32[i].phys_addr = cpu_to_le32(sg_dma_address(os_sgl));
155d98f0 1029 }
c4a3e0a5 1030 }
c4a3e0a5
BS		 1031 return sge_count;
1032}
1033
1034/**
1035 * megasas_make_sgl64 - Prepares 64-bit SGL
1036 * @instance: Adapter soft state
1037 * @scp: SCSI command from the mid-layer
1038 * @mfi_sgl: SGL to be filled in
1039 *
1040 * If successful, this function returns the number of SG elements. Otherwise,
1041 * it returnes -1.
1042 */
858119e1 1043static int
c4a3e0a5
BS		 1044megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
1045 union megasas_sgl *mfi_sgl)
1046{
1047 int i;
1048 int sge_count;
1049 struct scatterlist *os_sgl;
1050
155d98f0
FT		 1051 sge_count = scsi_dma_map(scp);
1052 BUG_ON(sge_count < 0);
c4a3e0a5 1053
155d98f0
FT		 1054 if (sge_count) {
1055 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
94cd65dd
SS		 1056 mfi_sgl->sge64[i].length = cpu_to_le32(sg_dma_len(os_sgl));
1057 mfi_sgl->sge64[i].phys_addr = cpu_to_le64(sg_dma_address(os_sgl));
155d98f0 1058 }
c4a3e0a5 1059 }
c4a3e0a5
BS		 1060 return sge_count;
1061}
1062
f4c9a131
YB		 1063/**
1064 * megasas_make_sgl_skinny - Prepares IEEE SGL
1065 * @instance: Adapter soft state
1066 * @scp: SCSI command from the mid-layer
1067 * @mfi_sgl: SGL to be filled in
1068 *
1069 * If successful, this function returns the number of SG elements. Otherwise,
1070 * it returnes -1.
1071 */
1072static int
1073megasas_make_sgl_skinny(struct megasas_instance *instance,
1074 struct scsi_cmnd *scp, union megasas_sgl *mfi_sgl)
1075{
1076 int i;
1077 int sge_count;
1078 struct scatterlist *os_sgl;
1079
1080 sge_count = scsi_dma_map(scp);
1081
1082 if (sge_count) {
1083 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
94cd65dd
SS		 1084 mfi_sgl->sge_skinny[i].length =
1085 cpu_to_le32(sg_dma_len(os_sgl));
f4c9a131 1086 mfi_sgl->sge_skinny[i].phys_addr =
94cd65dd
SS		 1087 cpu_to_le64(sg_dma_address(os_sgl));
1088 mfi_sgl->sge_skinny[i].flag = cpu_to_le32(0);
f4c9a131
YB		 1089 }
1090 }
1091 return sge_count;
1092}
1093
b1df99d9
SP		 1094 /**
1095 * megasas_get_frame_count - Computes the number of frames
d532dbe2 1096 * @frame_type : type of frame- io or pthru frame
b1df99d9
SP		 1097 * @sge_count : number of sg elements
1098 *
1099 * Returns the number of frames required for numnber of sge's (sge_count)
1100 */
1101
f4c9a131
YB		 1102static u32 megasas_get_frame_count(struct megasas_instance *instance,
1103 u8 sge_count, u8 frame_type)
b1df99d9
SP		 1104{
1105 int num_cnt;
1106 int sge_bytes;
1107 u32 sge_sz;
1108 u32 frame_count=0;
1109
1110 sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
1111 sizeof(struct megasas_sge32);
1112
f4c9a131
YB		 1113 if (instance->flag_ieee) {
1114 sge_sz = sizeof(struct megasas_sge_skinny);
1115 }
1116
b1df99d9 1117 /*
d532dbe2 1118 * Main frame can contain 2 SGEs for 64-bit SGLs and
1119 * 3 SGEs for 32-bit SGLs for ldio &
1120 * 1 SGEs for 64-bit SGLs and
1121 * 2 SGEs for 32-bit SGLs for pthru frame
1122 */
1123 if (unlikely(frame_type == PTHRU_FRAME)) {
f4c9a131
YB		 1124 if (instance->flag_ieee == 1) {
1125 num_cnt = sge_count - 1;
1126 } else if (IS_DMA64)
d532dbe2 1127 num_cnt = sge_count - 1;
1128 else
1129 num_cnt = sge_count - 2;
1130 } else {
f4c9a131
YB		 1131 if (instance->flag_ieee == 1) {
1132 num_cnt = sge_count - 1;
1133 } else if (IS_DMA64)
d532dbe2 1134 num_cnt = sge_count - 2;
1135 else
1136 num_cnt = sge_count - 3;
1137 }
b1df99d9
SP		 1138
1139 if(num_cnt>0){
1140 sge_bytes = sge_sz * num_cnt;
1141
1142 frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) +
1143 ((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) ;
1144 }
1145 /* Main frame */
1146 frame_count +=1;
1147
1148 if (frame_count > 7)
1149 frame_count = 8;
1150 return frame_count;
1151}
1152
c4a3e0a5
BS		 1153/**
1154 * megasas_build_dcdb - Prepares a direct cdb (DCDB) command
1155 * @instance: Adapter soft state
1156 * @scp: SCSI command
1157 * @cmd: Command to be prepared in
1158 *
1159 * This function prepares CDB commands. These are typcially pass-through
1160 * commands to the devices.
1161 */
858119e1 1162static int
c4a3e0a5
BS		 1163megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
1164 struct megasas_cmd *cmd)
1165{
c4a3e0a5
BS		 1166 u32 is_logical;
1167 u32 device_id;
1168 u16 flags = 0;
1169 struct megasas_pthru_frame *pthru;
1170
1171 is_logical = MEGASAS_IS_LOGICAL(scp);
1172 device_id = MEGASAS_DEV_INDEX(instance, scp);
1173 pthru = (struct megasas_pthru_frame *)cmd->frame;
1174
1175 if (scp->sc_data_direction == PCI_DMA_TODEVICE)
1176 flags = MFI_FRAME_DIR_WRITE;
1177 else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1178 flags = MFI_FRAME_DIR_READ;
1179 else if (scp->sc_data_direction == PCI_DMA_NONE)
1180 flags = MFI_FRAME_DIR_NONE;
1181
f4c9a131
YB		 1182 if (instance->flag_ieee == 1) {
1183 flags |= MFI_FRAME_IEEE;
1184 }
1185
c4a3e0a5
BS		 1186 /*
1187 * Prepare the DCDB frame
1188 */
1189 pthru->cmd = (is_logical) ? MFI_CMD_LD_SCSI_IO : MFI_CMD_PD_SCSI_IO;
1190 pthru->cmd_status = 0x0;
1191 pthru->scsi_status = 0x0;
1192 pthru->target_id = device_id;
1193 pthru->lun = scp->device->lun;
1194 pthru->cdb_len = scp->cmd_len;
1195 pthru->timeout = 0;
780a3762 1196 pthru->pad_0 = 0;
94cd65dd
SS		 1197 pthru->flags = cpu_to_le16(flags);
1198 pthru->data_xfer_len = cpu_to_le32(scsi_bufflen(scp));
c4a3e0a5
BS		 1199
1200 memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
1201
8d568253
YB		 1202 /*
1203 * If the command is for the tape device, set the
1204 * pthru timeout to the os layer timeout value.
1205 */
1206 if (scp->device->type == TYPE_TAPE) {
1207 if ((scp->request->timeout / HZ) > 0xFFFF)
1208 pthru->timeout = 0xFFFF;
1209 else
94cd65dd 1210 pthru->timeout = cpu_to_le16(scp->request->timeout / HZ);
8d568253
YB		 1211 }
1212
c4a3e0a5
BS		 1213 /*
1214 * Construct SGL
1215 */
f4c9a131 1216 if (instance->flag_ieee == 1) {
94cd65dd 1217 pthru->flags |= cpu_to_le16(MFI_FRAME_SGL64);
f4c9a131
YB		 1218 pthru->sge_count = megasas_make_sgl_skinny(instance, scp,
1219 &pthru->sgl);
1220 } else if (IS_DMA64) {
94cd65dd 1221 pthru->flags |= cpu_to_le16(MFI_FRAME_SGL64);
c4a3e0a5
BS		 1222 pthru->sge_count = megasas_make_sgl64(instance, scp,
1223 &pthru->sgl);
1224 } else
1225 pthru->sge_count = megasas_make_sgl32(instance, scp,
1226 &pthru->sgl);
1227
bdc6fb8d
YB		 1228 if (pthru->sge_count > instance->max_num_sge) {
1229 printk(KERN_ERR "megasas: DCDB two many SGE NUM=%x\n",
1230 pthru->sge_count);
1231 return 0;
1232 }
1233
c4a3e0a5
BS		 1234 /*
1235 * Sense info specific
1236 */
1237 pthru->sense_len = SCSI_SENSE_BUFFERSIZE;
94cd65dd
SS		 1238 pthru->sense_buf_phys_addr_hi =
1239 cpu_to_le32(upper_32_bits(cmd->sense_phys_addr));
1240 pthru->sense_buf_phys_addr_lo =
1241 cpu_to_le32(lower_32_bits(cmd->sense_phys_addr));
c4a3e0a5 1242
c4a3e0a5
BS		 1243 /*
1244 * Compute the total number of frames this command consumes. FW uses
1245 * this number to pull sufficient number of frames from host memory.
1246 */
f4c9a131 1247 cmd->frame_count = megasas_get_frame_count(instance, pthru->sge_count,
d532dbe2 1248 PTHRU_FRAME);
c4a3e0a5
BS		 1249
1250 return cmd->frame_count;
1251}
1252
1253/**
1254 * megasas_build_ldio - Prepares IOs to logical devices
1255 * @instance: Adapter soft state
1256 * @scp: SCSI command
fd589a8f 1257 * @cmd: Command to be prepared
c4a3e0a5
BS		 1258 *
1259 * Frames (and accompanying SGLs) for regular SCSI IOs use this function.
1260 */
858119e1 1261static int
c4a3e0a5
BS		 1262megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
1263 struct megasas_cmd *cmd)
1264{
c4a3e0a5
BS		 1265 u32 device_id;
1266 u8 sc = scp->cmnd[0];
1267 u16 flags = 0;
1268 struct megasas_io_frame *ldio;
1269
1270 device_id = MEGASAS_DEV_INDEX(instance, scp);
1271 ldio = (struct megasas_io_frame *)cmd->frame;
1272
1273 if (scp->sc_data_direction == PCI_DMA_TODEVICE)
1274 flags = MFI_FRAME_DIR_WRITE;
1275 else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1276 flags = MFI_FRAME_DIR_READ;
1277
f4c9a131
YB		 1278 if (instance->flag_ieee == 1) {
1279 flags |= MFI_FRAME_IEEE;
1280 }
1281
c4a3e0a5 1282 /*
b1df99d9 1283 * Prepare the Logical IO frame: 2nd bit is zero for all read cmds
c4a3e0a5
BS		 1284 */
1285 ldio->cmd = (sc & 0x02) ? MFI_CMD_LD_WRITE : MFI_CMD_LD_READ;
1286 ldio->cmd_status = 0x0;
1287 ldio->scsi_status = 0x0;
1288 ldio->target_id = device_id;
1289 ldio->timeout = 0;
1290 ldio->reserved_0 = 0;
1291 ldio->pad_0 = 0;
94cd65dd 1292 ldio->flags = cpu_to_le16(flags);
c4a3e0a5
BS		 1293 ldio->start_lba_hi = 0;
1294 ldio->access_byte = (scp->cmd_len != 6) ? scp->cmnd[1] : 0;
1295
1296 /*
1297 * 6-byte READ(0x08) or WRITE(0x0A) cdb
1298 */
1299 if (scp->cmd_len == 6) {
94cd65dd
SS		 1300 ldio->lba_count = cpu_to_le32((u32) scp->cmnd[4]);
1301 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[1] << 16) |
1302 ((u32) scp->cmnd[2] << 8) |
1303 (u32) scp->cmnd[3]);
c4a3e0a5 1304
94cd65dd 1305 ldio->start_lba_lo &= cpu_to_le32(0x1FFFFF);
c4a3e0a5
BS		 1306 }
1307
1308 /*
1309 * 10-byte READ(0x28) or WRITE(0x2A) cdb
1310 */
1311 else if (scp->cmd_len == 10) {
94cd65dd
SS		 1312 ldio->lba_count = cpu_to_le32((u32) scp->cmnd[8] |
1313 ((u32) scp->cmnd[7] << 8));
1314 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1315 ((u32) scp->cmnd[3] << 16) |
1316 ((u32) scp->cmnd[4] << 8) |
1317 (u32) scp->cmnd[5]);
c4a3e0a5
BS		 1318 }
1319
1320 /*
1321 * 12-byte READ(0xA8) or WRITE(0xAA) cdb
1322 */
1323 else if (scp->cmd_len == 12) {
94cd65dd
SS		 1324 ldio->lba_count = cpu_to_le32(((u32) scp->cmnd[6] << 24) |
1325 ((u32) scp->cmnd[7] << 16) |
1326 ((u32) scp->cmnd[8] << 8) |
1327 (u32) scp->cmnd[9]);
c4a3e0a5 1328
94cd65dd
SS		 1329 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1330 ((u32) scp->cmnd[3] << 16) |
1331 ((u32) scp->cmnd[4] << 8) |
1332 (u32) scp->cmnd[5]);
c4a3e0a5
BS		 1333 }
1334
1335 /*
1336 * 16-byte READ(0x88) or WRITE(0x8A) cdb
1337 */
1338 else if (scp->cmd_len == 16) {
94cd65dd
SS		 1339 ldio->lba_count = cpu_to_le32(((u32) scp->cmnd[10] << 24) |
1340 ((u32) scp->cmnd[11] << 16) |
1341 ((u32) scp->cmnd[12] << 8) |
1342 (u32) scp->cmnd[13]);
c4a3e0a5 1343
94cd65dd
SS		 1344 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[6] << 24) |
1345 ((u32) scp->cmnd[7] << 16) |
1346 ((u32) scp->cmnd[8] << 8) |
1347 (u32) scp->cmnd[9]);
c4a3e0a5 1348
94cd65dd
SS		 1349 ldio->start_lba_hi = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1350 ((u32) scp->cmnd[3] << 16) |
1351 ((u32) scp->cmnd[4] << 8) |
1352 (u32) scp->cmnd[5]);
c4a3e0a5
BS		 1353
1354 }
1355
1356 /*
1357 * Construct SGL
1358 */
f4c9a131 1359 if (instance->flag_ieee) {
94cd65dd 1360 ldio->flags |= cpu_to_le16(MFI_FRAME_SGL64);
f4c9a131
YB		 1361 ldio->sge_count = megasas_make_sgl_skinny(instance, scp,
1362 &ldio->sgl);
1363 } else if (IS_DMA64) {
94cd65dd 1364 ldio->flags |= cpu_to_le16(MFI_FRAME_SGL64);
c4a3e0a5
BS		 1365 ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl);
1366 } else
1367 ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
1368
bdc6fb8d
YB		 1369 if (ldio->sge_count > instance->max_num_sge) {
1370 printk(KERN_ERR "megasas: build_ld_io: sge_count = %x\n",
1371 ldio->sge_count);
1372 return 0;
1373 }
1374
c4a3e0a5
BS		 1375 /*
1376 * Sense info specific
1377 */
1378 ldio->sense_len = SCSI_SENSE_BUFFERSIZE;
1379 ldio->sense_buf_phys_addr_hi = 0;
94cd65dd 1380 ldio->sense_buf_phys_addr_lo = cpu_to_le32(cmd->sense_phys_addr);
c4a3e0a5 1381
b1df99d9
SP		 1382 /*
1383 * Compute the total number of frames this command consumes. FW uses
1384 * this number to pull sufficient number of frames from host memory.
1385 */
f4c9a131
YB		 1386 cmd->frame_count = megasas_get_frame_count(instance,
1387 ldio->sge_count, IO_FRAME);
c4a3e0a5
BS		 1388
1389 return cmd->frame_count;
1390}
1391
1392/**
cb59aa6a
SP		 1393 * megasas_is_ldio - Checks if the cmd is for logical drive
1394 * @scmd: SCSI command
0d49016b 1395 *
cb59aa6a 1396 * Called by megasas_queue_command to find out if the command to be queued
0d49016b 1397 * is a logical drive command
c4a3e0a5 1398 */
9c915a8c 1399inline int megasas_is_ldio(struct scsi_cmnd *cmd)
c4a3e0a5 1400{
cb59aa6a
SP		 1401 if (!MEGASAS_IS_LOGICAL(cmd))
1402 return 0;
1403 switch (cmd->cmnd[0]) {
1404 case READ_10:
1405 case WRITE_10:
1406 case READ_12:
1407 case WRITE_12:
1408 case READ_6:
1409 case WRITE_6:
1410 case READ_16:
1411 case WRITE_16:
1412 return 1;
1413 default:
1414 return 0;
c4a3e0a5 1415 }
c4a3e0a5
BS		 1416}
1417
658dcedb
SP		 1418 /**
1419 * megasas_dump_pending_frames - Dumps the frame address of all pending cmds
1420 * in FW
1421 * @instance: Adapter soft state
1422 */
1423static inline void
1424megasas_dump_pending_frames(struct megasas_instance *instance)
1425{
1426 struct megasas_cmd *cmd;
1427 int i,n;
1428 union megasas_sgl *mfi_sgl;
1429 struct megasas_io_frame *ldio;
1430 struct megasas_pthru_frame *pthru;
1431 u32 sgcount;
1432 u32 max_cmd = instance->max_fw_cmds;
1433
1434 printk(KERN_ERR "\nmegasas[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no);
1435 printk(KERN_ERR "megasas[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding));
1436 if (IS_DMA64)
1437 printk(KERN_ERR "\nmegasas[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no);
1438 else
1439 printk(KERN_ERR "\nmegasas[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no);
1440
1441 printk(KERN_ERR "megasas[%d]: Pending OS cmds in FW : \n",instance->host->host_no);
1442 for (i = 0; i < max_cmd; i++) {
1443 cmd = instance->cmd_list[i];
1444 if(!cmd->scmd)
1445 continue;
1446 printk(KERN_ERR "megasas[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
1447 if (megasas_is_ldio(cmd->scmd)){
1448 ldio = (struct megasas_io_frame *)cmd->frame;
1449 mfi_sgl = &ldio->sgl;
1450 sgcount = ldio->sge_count;
94cd65dd
SS		 1451 printk(KERN_ERR "megasas[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x,"
1452 " lba lo : 0x%x, lba_hi : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",
1453 instance->host->host_no, cmd->frame_count, ldio->cmd, ldio->target_id,
1454 le32_to_cpu(ldio->start_lba_lo), le32_to_cpu(ldio->start_lba_hi),
1455 le32_to_cpu(ldio->sense_buf_phys_addr_lo), sgcount);
658dcedb
SP		 1456 }
1457 else {
1458 pthru = (struct megasas_pthru_frame *) cmd->frame;
1459 mfi_sgl = &pthru->sgl;
1460 sgcount = pthru->sge_count;
94cd65dd
SS		 1461 printk(KERN_ERR "megasas[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x, "
1462 "lun : 0x%x, cdb_len : 0x%x, data xfer len : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",
1463 instance->host->host_no, cmd->frame_count, pthru->cmd, pthru->target_id,
1464 pthru->lun, pthru->cdb_len, le32_to_cpu(pthru->data_xfer_len),
1465 le32_to_cpu(pthru->sense_buf_phys_addr_lo), sgcount);
658dcedb
SP		 1466 }
1467 if(megasas_dbg_lvl & MEGASAS_DBG_LVL){
1468 for (n = 0; n < sgcount; n++){
1469 if (IS_DMA64)
94cd65dd
SS		 1470 printk(KERN_ERR "megasas: sgl len : 0x%x, sgl addr : 0x%llx ",
1471 le32_to_cpu(mfi_sgl->sge64[n].length),
1472 le64_to_cpu(mfi_sgl->sge64[n].phys_addr));
658dcedb 1473 else
94cd65dd
SS		 1474 printk(KERN_ERR "megasas: sgl len : 0x%x, sgl addr : 0x%x ",
1475 le32_to_cpu(mfi_sgl->sge32[n].length),
1476 le32_to_cpu(mfi_sgl->sge32[n].phys_addr));
658dcedb
SP		 1477 }
1478 }
1479 printk(KERN_ERR "\n");
1480 } /*for max_cmd*/
1481 printk(KERN_ERR "\nmegasas[%d]: Pending Internal cmds in FW : \n",instance->host->host_no);
1482 for (i = 0; i < max_cmd; i++) {
1483
1484 cmd = instance->cmd_list[i];
1485
1486 if(cmd->sync_cmd == 1){
1487 printk(KERN_ERR "0x%08lx : ", (unsigned long)cmd->frame_phys_addr);
1488 }
1489 }
1490 printk(KERN_ERR "megasas[%d]: Dumping Done.\n\n",instance->host->host_no);
1491}
1492
cd50ba8e 1493u32
1494megasas_build_and_issue_cmd(struct megasas_instance *instance,
1495 struct scsi_cmnd *scmd)
1496{
1497 struct megasas_cmd *cmd;
1498 u32 frame_count;
1499
1500 cmd = megasas_get_cmd(instance);
1501 if (!cmd)
1502 return SCSI_MLQUEUE_HOST_BUSY;
1503
1504 /*
1505 * Logical drive command
1506 */
1507 if (megasas_is_ldio(scmd))
1508 frame_count = megasas_build_ldio(instance, scmd, cmd);
1509 else
1510 frame_count = megasas_build_dcdb(instance, scmd, cmd);
1511
1512 if (!frame_count)
1513 goto out_return_cmd;
1514
1515 cmd->scmd = scmd;
1516 scmd->SCp.ptr = (char *)cmd;
1517
1518 /*
1519 * Issue the command to the FW
1520 */
1521 atomic_inc(&instance->fw_outstanding);
1522
1523 instance->instancet->fire_cmd(instance, cmd->frame_phys_addr,
1524 cmd->frame_count-1, instance->reg_set);
cd50ba8e 1525
1526 return 0;
1527out_return_cmd:
1528 megasas_return_cmd(instance, cmd);
1529 return 1;
1530}
1531
1532
c4a3e0a5
BS		 1533/**
1534 * megasas_queue_command - Queue entry point
1535 * @scmd: SCSI command to be queued
1536 * @done: Callback entry point
1537 */
1538static int
f281233d 1539megasas_queue_command_lck(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd *))
c4a3e0a5 1540{
c4a3e0a5 1541 struct megasas_instance *instance;
39a98554 1542 unsigned long flags;
c4a3e0a5
BS		 1543
1544 instance = (struct megasas_instance *)
1545 scmd->device->host->hostdata;
af37acfb 1546
39a98554 1547 if (instance->issuepend_done == 0)
af37acfb
SP		 1548 return SCSI_MLQUEUE_HOST_BUSY;
1549
39a98554 1550 spin_lock_irqsave(&instance->hba_lock, flags);
b09e66da 1551
229fe47c 1552 /* Check for an mpio path and adjust behavior */
1553 if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) {
1554 if (megasas_check_mpio_paths(instance, scmd) ==
1555 (DID_RESET << 16)) {
1556 spin_unlock_irqrestore(&instance->hba_lock, flags);
1557 return SCSI_MLQUEUE_HOST_BUSY;
1558 } else {
1559 spin_unlock_irqrestore(&instance->hba_lock, flags);
1560 scmd->result = DID_NO_CONNECT << 16;
1561 done(scmd);
1562 return 0;
1563 }
1564 }
1565
b09e66da
SS		 1566 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
1567 spin_unlock_irqrestore(&instance->hba_lock, flags);
229fe47c 1568 scmd->result = DID_NO_CONNECT << 16;
b09e66da
SS		 1569 done(scmd);
1570 return 0;
1571 }
1572
39a98554 1573 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
1574 spin_unlock_irqrestore(&instance->hba_lock, flags);
1575 return SCSI_MLQUEUE_HOST_BUSY;
1576 }
1577
1578 spin_unlock_irqrestore(&instance->hba_lock, flags);
1579
c4a3e0a5
BS		 1580 scmd->scsi_done = done;
1581 scmd->result = 0;
1582
cb59aa6a
SP		 1583 if (MEGASAS_IS_LOGICAL(scmd) &&
1584 (scmd->device->id >= MEGASAS_MAX_LD || scmd->device->lun)) {
1585 scmd->result = DID_BAD_TARGET << 16;
1586 goto out_done;
c4a3e0a5
BS		 1587 }
1588
02b01e01
SP		 1589 switch (scmd->cmnd[0]) {
1590 case SYNCHRONIZE_CACHE:
1591 /*
1592 * FW takes care of flush cache on its own
1593 * No need to send it down
1594 */
1595 scmd->result = DID_OK << 16;
1596 goto out_done;
1597 default:
1598 break;
1599 }
1600
cd50ba8e 1601 if (instance->instancet->build_and_issue_cmd(instance, scmd)) {
1602 printk(KERN_ERR "megasas: Err returned from build_and_issue_cmd\n");
cb59aa6a 1603 return SCSI_MLQUEUE_HOST_BUSY;
cd50ba8e 1604 }
c4a3e0a5
BS		 1605
1606 return 0;
cb59aa6a 1607
cb59aa6a
SP		 1608 out_done:
1609 done(scmd);
1610 return 0;
c4a3e0a5
BS		 1611}
1612
f281233d
JG		 1613static DEF_SCSI_QCMD(megasas_queue_command)
1614
044833b5
YB		 1615static struct megasas_instance *megasas_lookup_instance(u16 host_no)
1616{
1617 int i;
1618
1619 for (i = 0; i < megasas_mgmt_info.max_index; i++) {
1620
1621 if ((megasas_mgmt_info.instance[i]) &&
1622 (megasas_mgmt_info.instance[i]->host->host_no == host_no))
1623 return megasas_mgmt_info.instance[i];
1624 }
1625
1626 return NULL;
1627}
1628
147aab6a
CH		 1629static int megasas_slave_configure(struct scsi_device *sdev)
1630{
044833b5
YB		 1631 u16 pd_index = 0;
1632 struct megasas_instance *instance ;
1633
1634 instance = megasas_lookup_instance(sdev->host->host_no);
1635
147aab6a 1636 /*
044833b5
YB		 1637 * Don't export physical disk devices to the disk driver.
1638 *
1639 * FIXME: Currently we don't export them to the midlayer at all.
1640 * That will be fixed once LSI engineers have audited the
1641 * firmware for possible issues.
1642 */
1643 if (sdev->channel < MEGASAS_MAX_PD_CHANNELS &&
1644 sdev->type == TYPE_DISK) {
1645 pd_index = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
1646 sdev->id;
1647 if (instance->pd_list[pd_index].driveState ==
1648 MR_PD_STATE_SYSTEM) {
1649 blk_queue_rq_timeout(sdev->request_queue,
1650 MEGASAS_DEFAULT_CMD_TIMEOUT * HZ);
1651 return 0;
1652 }
147aab6a 1653 return -ENXIO;
044833b5 1654 }
e5b3a65f
CH		 1655
1656 /*
044833b5
YB		 1657 * The RAID firmware may require extended timeouts.
1658 */
1659 blk_queue_rq_timeout(sdev->request_queue,
1660 MEGASAS_DEFAULT_CMD_TIMEOUT * HZ);
1661 return 0;
1662}
1663
1664static int megasas_slave_alloc(struct scsi_device *sdev)
1665{
1666 u16 pd_index = 0;
1667 struct megasas_instance *instance ;
1668 instance = megasas_lookup_instance(sdev->host->host_no);
1669 if ((sdev->channel < MEGASAS_MAX_PD_CHANNELS) &&
1670 (sdev->type == TYPE_DISK)) {
1671 /*
1672 * Open the OS scan to the SYSTEM PD
1673 */
1674 pd_index =
1675 (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
1676 sdev->id;
1677 if ((instance->pd_list[pd_index].driveState ==
1678 MR_PD_STATE_SYSTEM) &&
1679 (instance->pd_list[pd_index].driveType ==
1680 TYPE_DISK)) {
1681 return 0;
1682 }
1683 return -ENXIO;
1684 }
147aab6a
CH		 1685 return 0;
1686}
1687
9c915a8c 1688void megaraid_sas_kill_hba(struct megasas_instance *instance)
39a98554 1689{
1690 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
9c915a8c 1691 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
36807e67 1692 (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
229fe47c 1693 (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) ||
21d3c710
SS		 1694 (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
1695 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) {
9c915a8c 1696 writel(MFI_STOP_ADP, &instance->reg_set->doorbell);
229fe47c 1697 /* Flush */
1698 readl(&instance->reg_set->doorbell);
1699 if (instance->mpio && instance->requestorId)
1700 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
39a98554 1701 } else {
9c915a8c 1702 writel(MFI_STOP_ADP, &instance->reg_set->inbound_doorbell);
1703 }
1704}
1705
1706 /**
1707 * megasas_check_and_restore_queue_depth - Check if queue depth needs to be
1708 * restored to max value
1709 * @instance: Adapter soft state
1710 *
1711 */
1712void
1713megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
1714{
1715 unsigned long flags;
1716 if (instance->flag & MEGASAS_FW_BUSY
c5daa6a9 1717 && time_after(jiffies, instance->last_time + 5 * HZ)
1718 && atomic_read(&instance->fw_outstanding) <
1719 instance->throttlequeuedepth + 1) {
9c915a8c 1720
1721 spin_lock_irqsave(instance->host->host_lock, flags);
1722 instance->flag &= ~MEGASAS_FW_BUSY;
404a8a1a 1723 if (instance->is_imr) {
9c915a8c 1724 instance->host->can_queue =
1725 instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
1726 } else
1727 instance->host->can_queue =
1728 instance->max_fw_cmds - MEGASAS_INT_CMDS;
1729
1730 spin_unlock_irqrestore(instance->host->host_lock, flags);
39a98554 1731 }
1732}
1733
7343eb65 1734/**
1735 * megasas_complete_cmd_dpc - Returns FW's controller structure
1736 * @instance_addr: Address of adapter soft state
1737 *
1738 * Tasklet to complete cmds
1739 */
1740static void megasas_complete_cmd_dpc(unsigned long instance_addr)
1741{
1742 u32 producer;
1743 u32 consumer;
1744 u32 context;
1745 struct megasas_cmd *cmd;
1746 struct megasas_instance *instance =
1747 (struct megasas_instance *)instance_addr;
1748 unsigned long flags;
1749
1750 /* If we have already declared adapter dead, donot complete cmds */
39a98554 1751 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR )
7343eb65 1752 return;
1753
1754 spin_lock_irqsave(&instance->completion_lock, flags);
1755
94cd65dd
SS		 1756 producer = le32_to_cpu(*instance->producer);
1757 consumer = le32_to_cpu(*instance->consumer);
7343eb65 1758
1759 while (consumer != producer) {
94cd65dd 1760 context = le32_to_cpu(instance->reply_queue[consumer]);
39a98554 1761 if (context >= instance->max_fw_cmds) {
1762 printk(KERN_ERR "Unexpected context value %x\n",
1763 context);
1764 BUG();
1765 }
7343eb65 1766
1767 cmd = instance->cmd_list[context];
1768
1769 megasas_complete_cmd(instance, cmd, DID_OK);
1770
1771 consumer++;
1772 if (consumer == (instance->max_fw_cmds + 1)) {
1773 consumer = 0;
1774 }
1775 }
1776
94cd65dd 1777 *instance->consumer = cpu_to_le32(producer);
7343eb65 1778
1779 spin_unlock_irqrestore(&instance->completion_lock, flags);
1780
1781 /*
1782 * Check if we can restore can_queue
1783 */
9c915a8c 1784 megasas_check_and_restore_queue_depth(instance);
7343eb65 1785}
1786
229fe47c 1787/**
1788 * megasas_start_timer - Initializes a timer object
1789 * @instance: Adapter soft state
1790 * @timer: timer object to be initialized
1791 * @fn: timer function
1792 * @interval: time interval between timer function call
1793 *
1794 */
1795void megasas_start_timer(struct megasas_instance *instance,
1796 struct timer_list *timer,
1797 void *fn, unsigned long interval)
1798{
1799 init_timer(timer);
1800 timer->expires = jiffies + interval;
1801 timer->data = (unsigned long)instance;
1802 timer->function = fn;
1803 add_timer(timer);
1804}
1805
707e09bd
YB		 1806static void
1807megasas_internal_reset_defer_cmds(struct megasas_instance *instance);
1808
1809static void
1810process_fw_state_change_wq(struct work_struct *work);
1811
1812void megasas_do_ocr(struct megasas_instance *instance)
1813{
1814 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
1815 (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
1816 (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
94cd65dd 1817 *instance->consumer = cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
707e09bd 1818 }
d46a3ad6 1819 instance->instancet->disable_intr(instance);
707e09bd
YB		 1820 instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT;
1821 instance->issuepend_done = 0;
1822
1823 atomic_set(&instance->fw_outstanding, 0);
1824 megasas_internal_reset_defer_cmds(instance);
1825 process_fw_state_change_wq(&instance->work_init);
1826}
1827
229fe47c 1828/* This function will get the current SR-IOV LD/VF affiliation */
1829static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,
1830 int initial)
1831{
1832 struct megasas_cmd *cmd;
1833 struct megasas_dcmd_frame *dcmd;
1834 struct MR_LD_VF_AFFILIATION *new_affiliation = NULL;
1835 struct MR_LD_VF_AFFILIATION_111 *new_affiliation_111 = NULL;
1836 struct MR_LD_VF_MAP *newmap = NULL, *savedmap = NULL;
1837 dma_addr_t new_affiliation_h;
1838 dma_addr_t new_affiliation_111_h;
1839 int ld, retval = 0;
1840 u8 thisVf;
1841
1842 cmd = megasas_get_cmd(instance);
1843
1844 if (!cmd) {
1845 printk(KERN_DEBUG "megasas: megasas_get_ld_vf_"
1846 "affiliation: Failed to get cmd for scsi%d.\n",
1847 instance->host->host_no);
1848 return -ENOMEM;
1849 }
1850
1851 dcmd = &cmd->frame->dcmd;
1852
1853 if (!instance->vf_affiliation && !instance->vf_affiliation_111) {
1854 printk(KERN_WARNING "megasas: SR-IOV: Couldn't get LD/VF "
1855 "affiliation for scsi%d.\n", instance->host->host_no);
1856 megasas_return_cmd(instance, cmd);
1857 return -ENOMEM;
1858 }
1859
1860 if (initial)
1861 if (instance->PlasmaFW111)
1862 memset(instance->vf_affiliation_111, 0,
1863 sizeof(struct MR_LD_VF_AFFILIATION_111));
1864 else
1865 memset(instance->vf_affiliation, 0,
1866 (MAX_LOGICAL_DRIVES + 1) *
1867 sizeof(struct MR_LD_VF_AFFILIATION));
1868 else {
1869 if (instance->PlasmaFW111)
1870 new_affiliation_111 =
1871 pci_alloc_consistent(instance->pdev,
1872 sizeof(struct MR_LD_VF_AFFILIATION_111),
1873 &new_affiliation_111_h);
1874 else
1875 new_affiliation =
1876 pci_alloc_consistent(instance->pdev,
1877 (MAX_LOGICAL_DRIVES + 1) *
1878 sizeof(struct MR_LD_VF_AFFILIATION),
1879 &new_affiliation_h);
1880 if (!new_affiliation && !new_affiliation_111) {
1881 printk(KERN_DEBUG "megasas: SR-IOV: Couldn't allocate "
1882 "memory for new affiliation for scsi%d.\n",
1883 instance->host->host_no);
1884 megasas_return_cmd(instance, cmd);
1885 return -ENOMEM;
1886 }
1887 if (instance->PlasmaFW111)
1888 memset(new_affiliation_111, 0,
1889 sizeof(struct MR_LD_VF_AFFILIATION_111));
1890 else
1891 memset(new_affiliation, 0, (MAX_LOGICAL_DRIVES + 1) *
1892 sizeof(struct MR_LD_VF_AFFILIATION));
1893 }
1894
1895 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
1896
1897 dcmd->cmd = MFI_CMD_DCMD;
1898 dcmd->cmd_status = 0xFF;
1899 dcmd->sge_count = 1;
1900 dcmd->flags = MFI_FRAME_DIR_BOTH;
1901 dcmd->timeout = 0;
1902 dcmd->pad_0 = 0;
1903 if (instance->PlasmaFW111) {
1904 dcmd->data_xfer_len = sizeof(struct MR_LD_VF_AFFILIATION_111);
1905 dcmd->opcode = MR_DCMD_LD_VF_MAP_GET_ALL_LDS_111;
1906 } else {
1907 dcmd->data_xfer_len = (MAX_LOGICAL_DRIVES + 1) *
1908 sizeof(struct MR_LD_VF_AFFILIATION);
1909 dcmd->opcode = MR_DCMD_LD_VF_MAP_GET_ALL_LDS;
1910 }
1911
1912 if (initial) {
1913 if (instance->PlasmaFW111)
1914 dcmd->sgl.sge32[0].phys_addr =
1915 instance->vf_affiliation_111_h;
1916 else
1917 dcmd->sgl.sge32[0].phys_addr =
1918 instance->vf_affiliation_h;
1919 } else {
1920 if (instance->PlasmaFW111)
1921 dcmd->sgl.sge32[0].phys_addr = new_affiliation_111_h;
1922 else
1923 dcmd->sgl.sge32[0].phys_addr = new_affiliation_h;
1924 }
1925 if (instance->PlasmaFW111)
1926 dcmd->sgl.sge32[0].length =
1927 sizeof(struct MR_LD_VF_AFFILIATION_111);
1928 else
1929 dcmd->sgl.sge32[0].length = (MAX_LOGICAL_DRIVES + 1) *
1930 sizeof(struct MR_LD_VF_AFFILIATION);
1931
1932 printk(KERN_WARNING "megasas: SR-IOV: Getting LD/VF affiliation for "
1933 "scsi%d\n", instance->host->host_no);
1934
1935 megasas_issue_blocked_cmd(instance, cmd, 0);
1936
1937 if (dcmd->cmd_status) {
1938 printk(KERN_WARNING "megasas: SR-IOV: LD/VF affiliation DCMD"
1939 " failed with status 0x%x for scsi%d.\n",
1940 dcmd->cmd_status, instance->host->host_no);
1941 retval = 1; /* Do a scan if we couldn't get affiliation */
1942 goto out;
1943 }
1944
1945 if (!initial) {
1946 if (instance->PlasmaFW111) {
1947 if (!new_affiliation_111->vdCount) {
1948 printk(KERN_WARNING "megasas: SR-IOV: Got new "
1949 "LD/VF affiliation for passive path "
1950 "for scsi%d.\n",
1951 instance->host->host_no);
1952 retval = 1;
1953 goto out;
1954 }
1955 thisVf = new_affiliation_111->thisVf;
1956 for (ld = 0 ; ld < new_affiliation_111->vdCount; ld++)
1957 if (instance->vf_affiliation_111->map[ld].policy[thisVf] != new_affiliation_111->map[ld].policy[thisVf]) {
1958 printk(KERN_WARNING "megasas: SR-IOV: "
1959 "Got new LD/VF affiliation "
1960 "for scsi%d.\n",
1961 instance->host->host_no);
1962 memcpy(instance->vf_affiliation_111,
1963 new_affiliation_111,
1964 sizeof(struct MR_LD_VF_AFFILIATION_111));
1965 retval = 1;
1966 goto out;
1967 }
1968 } else {
1969 if (!new_affiliation->ldCount) {
1970 printk(KERN_WARNING "megasas: SR-IOV: Got new "
1971 "LD/VF affiliation for passive "
1972 "path for scsi%d.\n",
1973 instance->host->host_no);
1974 retval = 1;
1975 goto out;
1976 }
1977 newmap = new_affiliation->map;
1978 savedmap = instance->vf_affiliation->map;
1979 thisVf = new_affiliation->thisVf;
1980 for (ld = 0 ; ld < new_affiliation->ldCount; ld++) {
1981 if (savedmap->policy[thisVf] !=
1982 newmap->policy[thisVf]) {
1983 printk(KERN_WARNING "megasas: SR-IOV: "
1984 "Got new LD/VF affiliation "
1985 "for scsi%d.\n",
1986 instance->host->host_no);
1987 memcpy(instance->vf_affiliation,
1988 new_affiliation,
1989 new_affiliation->size);
1990 retval = 1;
1991 goto out;
1992 }
1993 savedmap = (struct MR_LD_VF_MAP *)
1994 ((unsigned char *)savedmap +
1995 savedmap->size);
1996 newmap = (struct MR_LD_VF_MAP *)
1997 ((unsigned char *)newmap +
1998 newmap->size);
1999 }
2000 }
2001 }
2002out:
2003 if (new_affiliation) {
2004 if (instance->PlasmaFW111)
2005 pci_free_consistent(instance->pdev,
2006 sizeof(struct MR_LD_VF_AFFILIATION_111),
2007 new_affiliation_111,
2008 new_affiliation_111_h);
2009 else
2010 pci_free_consistent(instance->pdev,
2011 (MAX_LOGICAL_DRIVES + 1) *
2012 sizeof(struct MR_LD_VF_AFFILIATION),
2013 new_affiliation, new_affiliation_h);
2014 }
2015 megasas_return_cmd(instance, cmd);
2016
2017 return retval;
2018}
2019
2020/* This function will tell FW to start the SR-IOV heartbeat */
2021int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
2022 int initial)
2023{
2024 struct megasas_cmd *cmd;
2025 struct megasas_dcmd_frame *dcmd;
2026 int retval = 0;
2027
2028 cmd = megasas_get_cmd(instance);
2029
2030 if (!cmd) {
2031 printk(KERN_DEBUG "megasas: megasas_sriov_start_heartbeat: "
2032 "Failed to get cmd for scsi%d.\n",
2033 instance->host->host_no);
2034 return -ENOMEM;
2035 }
2036
2037 dcmd = &cmd->frame->dcmd;
2038
2039 if (initial) {
2040 instance->hb_host_mem =
7c845eb5
JP		 2041 pci_zalloc_consistent(instance->pdev,
2042 sizeof(struct MR_CTRL_HB_HOST_MEM),
2043 &instance->hb_host_mem_h);
229fe47c 2044 if (!instance->hb_host_mem) {
2045 printk(KERN_DEBUG "megasas: SR-IOV: Couldn't allocate"
2046 " memory for heartbeat host memory for "
2047 "scsi%d.\n", instance->host->host_no);
2048 retval = -ENOMEM;
2049 goto out;
2050 }
229fe47c 2051 }
2052
2053 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2054
2055 dcmd->mbox.s[0] = sizeof(struct MR_CTRL_HB_HOST_MEM);
2056 dcmd->cmd = MFI_CMD_DCMD;
2057 dcmd->cmd_status = 0xFF;
2058 dcmd->sge_count = 1;
2059 dcmd->flags = MFI_FRAME_DIR_BOTH;
2060 dcmd->timeout = 0;
2061 dcmd->pad_0 = 0;
2062 dcmd->data_xfer_len = sizeof(struct MR_CTRL_HB_HOST_MEM);
2063 dcmd->opcode = MR_DCMD_CTRL_SHARED_HOST_MEM_ALLOC;
2064 dcmd->sgl.sge32[0].phys_addr = instance->hb_host_mem_h;
2065 dcmd->sgl.sge32[0].length = sizeof(struct MR_CTRL_HB_HOST_MEM);
2066
2067 printk(KERN_WARNING "megasas: SR-IOV: Starting heartbeat for scsi%d\n",
2068 instance->host->host_no);
2069
2070 if (!megasas_issue_polled(instance, cmd)) {
2071 retval = 0;
2072 } else {
2073 printk(KERN_WARNING "megasas: SR-IOV: MR_DCMD_CTRL_SHARED_HOST"
2074 "_MEM_ALLOC DCMD timed out for scsi%d\n",
2075 instance->host->host_no);
2076 retval = 1;
2077 goto out;
2078 }
2079
2080
2081 if (dcmd->cmd_status) {
2082 printk(KERN_WARNING "megasas: SR-IOV: MR_DCMD_CTRL_SHARED_HOST"
2083 "_MEM_ALLOC DCMD failed with status 0x%x for scsi%d\n",
2084 dcmd->cmd_status,
2085 instance->host->host_no);
2086 retval = 1;
2087 goto out;
2088 }
2089
2090out:
2091 megasas_return_cmd(instance, cmd);
2092
2093 return retval;
2094}
2095
2096/* Handler for SR-IOV heartbeat */
2097void megasas_sriov_heartbeat_handler(unsigned long instance_addr)
2098{
2099 struct megasas_instance *instance =
2100 (struct megasas_instance *)instance_addr;
2101
2102 if (instance->hb_host_mem->HB.fwCounter !=
2103 instance->hb_host_mem->HB.driverCounter) {
2104 instance->hb_host_mem->HB.driverCounter =
2105 instance->hb_host_mem->HB.fwCounter;
2106 mod_timer(&instance->sriov_heartbeat_timer,
2107 jiffies + MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF);
2108 } else {
2109 printk(KERN_WARNING "megasas: SR-IOV: Heartbeat never "
2110 "completed for scsi%d\n", instance->host->host_no);
2111 schedule_work(&instance->work_init);
2112 }
2113}
2114
c4a3e0a5
BS		 2115/**
2116 * megasas_wait_for_outstanding - Wait for all outstanding cmds
2117 * @instance: Adapter soft state
2118 *
25985edc 2119 * This function waits for up to MEGASAS_RESET_WAIT_TIME seconds for FW to
c4a3e0a5
BS		 2120 * complete all its outstanding commands. Returns error if one or more IOs
2121 * are pending after this time period. It also marks the controller dead.
2122 */
2123static int megasas_wait_for_outstanding(struct megasas_instance *instance)
2124{
2125 int i;
39a98554 2126 u32 reset_index;
c4a3e0a5 2127 u32 wait_time = MEGASAS_RESET_WAIT_TIME;
39a98554 2128 u8 adprecovery;
2129 unsigned long flags;
2130 struct list_head clist_local;
2131 struct megasas_cmd *reset_cmd;
707e09bd
YB		 2132 u32 fw_state;
2133 u8 kill_adapter_flag;
39a98554 2134
2135 spin_lock_irqsave(&instance->hba_lock, flags);
2136 adprecovery = instance->adprecovery;
2137 spin_unlock_irqrestore(&instance->hba_lock, flags);
2138
2139 if (adprecovery != MEGASAS_HBA_OPERATIONAL) {
2140
2141 INIT_LIST_HEAD(&clist_local);
2142 spin_lock_irqsave(&instance->hba_lock, flags);
2143 list_splice_init(&instance->internal_reset_pending_q,
2144 &clist_local);
2145 spin_unlock_irqrestore(&instance->hba_lock, flags);
2146
2147 printk(KERN_NOTICE "megasas: HBA reset wait ...\n");
2148 for (i = 0; i < wait_time; i++) {
2149 msleep(1000);
2150 spin_lock_irqsave(&instance->hba_lock, flags);
2151 adprecovery = instance->adprecovery;
2152 spin_unlock_irqrestore(&instance->hba_lock, flags);
2153 if (adprecovery == MEGASAS_HBA_OPERATIONAL)
2154 break;
2155 }
2156
2157 if (adprecovery != MEGASAS_HBA_OPERATIONAL) {
2158 printk(KERN_NOTICE "megasas: reset: Stopping HBA.\n");
2159 spin_lock_irqsave(&instance->hba_lock, flags);
2160 instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR;
2161 spin_unlock_irqrestore(&instance->hba_lock, flags);
2162 return FAILED;
2163 }
2164
2165 reset_index = 0;
2166 while (!list_empty(&clist_local)) {
2167 reset_cmd = list_entry((&clist_local)->next,
2168 struct megasas_cmd, list);
2169 list_del_init(&reset_cmd->list);
2170 if (reset_cmd->scmd) {
2171 reset_cmd->scmd->result = DID_RESET << 16;
5cd049a5 2172 printk(KERN_NOTICE "%d:%p reset [%02x]\n",
39a98554 2173 reset_index, reset_cmd,
5cd049a5 2174 reset_cmd->scmd->cmnd[0]);
39a98554 2175
2176 reset_cmd->scmd->scsi_done(reset_cmd->scmd);
2177 megasas_return_cmd(instance, reset_cmd);
2178 } else if (reset_cmd->sync_cmd) {
2179 printk(KERN_NOTICE "megasas:%p synch cmds"
2180 "reset queue\n",
2181 reset_cmd);
2182
2183 reset_cmd->cmd_status = ENODATA;
2184 instance->instancet->fire_cmd(instance,
2185 reset_cmd->frame_phys_addr,
2186 0, instance->reg_set);
2187 } else {
2188 printk(KERN_NOTICE "megasas: %p unexpected"
2189 "cmds lst\n",
2190 reset_cmd);
2191 }
2192 reset_index++;
2193 }
2194
2195 return SUCCESS;
2196 }
c4a3e0a5 2197
c007b8b2 2198 for (i = 0; i < resetwaittime; i++) {
c4a3e0a5 2199
e4a082c7
SP		 2200 int outstanding = atomic_read(&instance->fw_outstanding);
2201
2202 if (!outstanding)
c4a3e0a5
BS		 2203 break;
2204
2205 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
2206 printk(KERN_NOTICE "megasas: [%2d]waiting for %d "
e4a082c7 2207 "commands to complete\n",i,outstanding);
7343eb65 2208 /*
2209 * Call cmd completion routine. Cmd to be
2210 * be completed directly without depending on isr.
2211 */
2212 megasas_complete_cmd_dpc((unsigned long)instance);
c4a3e0a5
BS		 2213 }
2214
2215 msleep(1000);
2216 }
2217
707e09bd
YB		 2218 i = 0;
2219 kill_adapter_flag = 0;
2220 do {
2221 fw_state = instance->instancet->read_fw_status_reg(
2222 instance->reg_set) & MFI_STATE_MASK;
2223 if ((fw_state == MFI_STATE_FAULT) &&
2224 (instance->disableOnlineCtrlReset == 0)) {
2225 if (i == 3) {
2226 kill_adapter_flag = 2;
2227 break;
2228 }
2229 megasas_do_ocr(instance);
2230 kill_adapter_flag = 1;
2231
2232 /* wait for 1 secs to let FW finish the pending cmds */
2233 msleep(1000);
2234 }
2235 i++;
2236 } while (i <= 3);
2237
2238 if (atomic_read(&instance->fw_outstanding) &&
2239 !kill_adapter_flag) {
2240 if (instance->disableOnlineCtrlReset == 0) {
2241
2242 megasas_do_ocr(instance);
2243
2244 /* wait for 5 secs to let FW finish the pending cmds */
2245 for (i = 0; i < wait_time; i++) {
2246 int outstanding =
2247 atomic_read(&instance->fw_outstanding);
2248 if (!outstanding)
2249 return SUCCESS;
2250 msleep(1000);
2251 }
2252 }
2253 }
2254
2255 if (atomic_read(&instance->fw_outstanding) ||
2256 (kill_adapter_flag == 2)) {
39a98554 2257 printk(KERN_NOTICE "megaraid_sas: pending cmds after reset\n");
e3bbff9f
SP		 2258 /*
2259 * Send signal to FW to stop processing any pending cmds.
2260 * The controller will be taken offline by the OS now.
2261 */
0c79e681
YB		 2262 if ((instance->pdev->device ==
2263 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2264 (instance->pdev->device ==
2265 PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
2266 writel(MFI_STOP_ADP,
9c915a8c 2267 &instance->reg_set->doorbell);
0c79e681
YB		 2268 } else {
2269 writel(MFI_STOP_ADP,
e3bbff9f 2270 &instance->reg_set->inbound_doorbell);
0c79e681 2271 }
658dcedb 2272 megasas_dump_pending_frames(instance);
39a98554 2273 spin_lock_irqsave(&instance->hba_lock, flags);
2274 instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR;
2275 spin_unlock_irqrestore(&instance->hba_lock, flags);
c4a3e0a5
BS		 2276 return FAILED;
2277 }
2278
39a98554 2279 printk(KERN_NOTICE "megaraid_sas: no pending cmds after reset\n");
2280
c4a3e0a5
BS		 2281 return SUCCESS;
2282}
2283
2284/**
2285 * megasas_generic_reset - Generic reset routine
2286 * @scmd: Mid-layer SCSI command
2287 *
2288 * This routine implements a generic reset handler for device, bus and host
2289 * reset requests. Device, bus and host specific reset handlers can use this
2290 * function after they do their specific tasks.
2291 */
2292static int megasas_generic_reset(struct scsi_cmnd *scmd)
2293{
2294 int ret_val;
2295 struct megasas_instance *instance;
2296
2297 instance = (struct megasas_instance *)scmd->device->host->hostdata;
2298
5cd049a5
CH		 2299 scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n",
2300 scmd->cmnd[0], scmd->retries);
c4a3e0a5 2301
39a98554 2302 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
c4a3e0a5
BS		 2303 printk(KERN_ERR "megasas: cannot recover from previous reset "
2304 "failures\n");
2305 return FAILED;
2306 }
2307
c4a3e0a5 2308 ret_val = megasas_wait_for_outstanding(instance);
c4a3e0a5
BS		 2309 if (ret_val == SUCCESS)
2310 printk(KERN_NOTICE "megasas: reset successful \n");
2311 else
2312 printk(KERN_ERR "megasas: failed to do reset\n");
2313
c4a3e0a5
BS		 2314 return ret_val;
2315}
2316
05e9ebbe
SP		 2317/**
2318 * megasas_reset_timer - quiesce the adapter if required
2319 * @scmd: scsi cmnd
2320 *
2321 * Sets the FW busy flag and reduces the host->can_queue if the
2322 * cmd has not been completed within the timeout period.
2323 */
2324static enum
242f9dcb 2325blk_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd)
05e9ebbe 2326{
05e9ebbe
SP		 2327 struct megasas_instance *instance;
2328 unsigned long flags;
2329
2330 if (time_after(jiffies, scmd->jiffies_at_alloc +
2331 (MEGASAS_DEFAULT_CMD_TIMEOUT * 2) * HZ)) {
242f9dcb 2332 return BLK_EH_NOT_HANDLED;
05e9ebbe
SP		 2333 }
2334
f575c5d3 2335 instance = (struct megasas_instance *)scmd->device->host->hostdata;
05e9ebbe
SP		 2336 if (!(instance->flag & MEGASAS_FW_BUSY)) {
2337 /* FW is busy, throttle IO */
2338 spin_lock_irqsave(instance->host->host_lock, flags);
2339
c5daa6a9 2340 instance->host->can_queue = instance->throttlequeuedepth;
05e9ebbe
SP		 2341 instance->last_time = jiffies;
2342 instance->flag |= MEGASAS_FW_BUSY;
2343
2344 spin_unlock_irqrestore(instance->host->host_lock, flags);
2345 }
242f9dcb 2346 return BLK_EH_RESET_TIMER;
05e9ebbe
SP		 2347}
2348
c4a3e0a5
BS		 2349/**
2350 * megasas_reset_device - Device reset handler entry point
2351 */
2352static int megasas_reset_device(struct scsi_cmnd *scmd)
2353{
2354 int ret;
2355
2356 /*
2357 * First wait for all commands to complete
2358 */
2359 ret = megasas_generic_reset(scmd);
2360
2361 return ret;
2362}
2363
2364/**
2365 * megasas_reset_bus_host - Bus & host reset handler entry point
2366 */
2367static int megasas_reset_bus_host(struct scsi_cmnd *scmd)
2368{
2369 int ret;
9c915a8c 2370 struct megasas_instance *instance;
2371 instance = (struct megasas_instance *)scmd->device->host->hostdata;
c4a3e0a5
BS		 2372
2373 /*
80682fa9 2374 * First wait for all commands to complete
c4a3e0a5 2375 */
36807e67 2376 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
229fe47c 2377 (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) ||
21d3c710
SS		 2378 (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
2379 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))
229fe47c 2380 ret = megasas_reset_fusion(scmd->device->host, 1);
9c915a8c 2381 else
2382 ret = megasas_generic_reset(scmd);
c4a3e0a5
BS		 2383
2384 return ret;
2385}
2386
cf62a0a5
SP		 2387/**
2388 * megasas_bios_param - Returns disk geometry for a disk
2389 * @sdev: device handle
2390 * @bdev: block device
2391 * @capacity: drive capacity
2392 * @geom: geometry parameters
2393 */
2394static int
2395megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2396 sector_t capacity, int geom[])
2397{
2398 int heads;
2399 int sectors;
2400 sector_t cylinders;
2401 unsigned long tmp;
2402 /* Default heads (64) & sectors (32) */
2403 heads = 64;
2404 sectors = 32;
2405
2406 tmp = heads * sectors;
2407 cylinders = capacity;
2408
2409 sector_div(cylinders, tmp);
2410
2411 /*
2412 * Handle extended translation size for logical drives > 1Gb
2413 */
2414
2415 if (capacity >= 0x200000) {
2416 heads = 255;
2417 sectors = 63;
2418 tmp = heads*sectors;
2419 cylinders = capacity;
2420 sector_div(cylinders, tmp);
2421 }
2422
2423 geom[0] = heads;
2424 geom[1] = sectors;
2425 geom[2] = cylinders;
2426
2427 return 0;
2428}
2429
7e8a75f4
YB		 2430static void megasas_aen_polling(struct work_struct *work);
2431
c4a3e0a5
BS		 2432/**
2433 * megasas_service_aen - Processes an event notification
2434 * @instance: Adapter soft state
2435 * @cmd: AEN command completed by the ISR
2436 *
2437 * For AEN, driver sends a command down to FW that is held by the FW till an
2438 * event occurs. When an event of interest occurs, FW completes the command
2439 * that it was previously holding.
2440 *
2441 * This routines sends SIGIO signal to processes that have registered with the
2442 * driver for AEN.
2443 */
2444static void
2445megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
2446{
c3518837 2447 unsigned long flags;
c4a3e0a5
BS		 2448 /*
2449 * Don't signal app if it is just an aborted previously registered aen
2450 */
c3518837
YB		 2451 if ((!cmd->abort_aen) && (instance->unload == 0)) {
2452 spin_lock_irqsave(&poll_aen_lock, flags);
2453 megasas_poll_wait_aen = 1;
2454 spin_unlock_irqrestore(&poll_aen_lock, flags);
2455 wake_up(&megasas_poll_wait);
c4a3e0a5 2456 kill_fasync(&megasas_async_queue, SIGIO, POLL_IN);
c3518837 2457 }
c4a3e0a5
BS		 2458 else
2459 cmd->abort_aen = 0;
2460
2461 instance->aen_cmd = NULL;
2462 megasas_return_cmd(instance, cmd);
7e8a75f4 2463
39a98554 2464 if ((instance->unload == 0) &&
2465 ((instance->issuepend_done == 1))) {
7e8a75f4
YB		 2466 struct megasas_aen_event *ev;
2467 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2468 if (!ev) {
2469 printk(KERN_ERR "megasas_service_aen: out of memory\n");
2470 } else {
2471 ev->instance = instance;
2472 instance->ev = ev;
c1d390d8
XF		 2473 INIT_DELAYED_WORK(&ev->hotplug_work,
2474 megasas_aen_polling);
2475 schedule_delayed_work(&ev->hotplug_work, 0);
7e8a75f4
YB		 2476 }
2477 }
c4a3e0a5
BS		 2478}
2479
4bcde509 2480static int megasas_change_queue_depth(struct scsi_device *sdev,
2481 int queue_depth, int reason)
2482{
2483 if (reason != SCSI_QDEPTH_DEFAULT)
2484 return -EOPNOTSUPP;
2485
2486 if (queue_depth > sdev->host->can_queue)
2487 queue_depth = sdev->host->can_queue;
2488 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev),
2489 queue_depth);
2490
2491 return queue_depth;
2492}
2493
c4a3e0a5
BS		 2494/*
2495 * Scsi host template for megaraid_sas driver
2496 */
2497static struct scsi_host_template megasas_template = {
2498
2499 .module = THIS_MODULE,
f28cd7cf 2500 .name = "LSI SAS based MegaRAID driver",
c4a3e0a5 2501 .proc_name = "megaraid_sas",
147aab6a 2502 .slave_configure = megasas_slave_configure,
044833b5 2503 .slave_alloc = megasas_slave_alloc,
c4a3e0a5
BS		 2504 .queuecommand = megasas_queue_command,
2505 .eh_device_reset_handler = megasas_reset_device,
2506 .eh_bus_reset_handler = megasas_reset_bus_host,
2507 .eh_host_reset_handler = megasas_reset_bus_host,
05e9ebbe 2508 .eh_timed_out = megasas_reset_timer,
cf62a0a5 2509 .bios_param = megasas_bios_param,
c4a3e0a5 2510 .use_clustering = ENABLE_CLUSTERING,
4bcde509 2511 .change_queue_depth = megasas_change_queue_depth,
54b2b50c 2512 .no_write_same = 1,
c4a3e0a5
BS		 2513};
2514
2515/**
2516 * megasas_complete_int_cmd - Completes an internal command
2517 * @instance: Adapter soft state
2518 * @cmd: Command to be completed
2519 *
2520 * The megasas_issue_blocked_cmd() function waits for a command to complete
2521 * after it issues a command. This function wakes up that waiting routine by
2522 * calling wake_up() on the wait queue.
2523 */
2524static void
2525megasas_complete_int_cmd(struct megasas_instance *instance,
2526 struct megasas_cmd *cmd)
2527{
2528 cmd->cmd_status = cmd->frame->io.cmd_status;
2529
2530 if (cmd->cmd_status == ENODATA) {
2531 cmd->cmd_status = 0;
2532 }
2533 wake_up(&instance->int_cmd_wait_q);
2534}
2535
2536/**
2537 * megasas_complete_abort - Completes aborting a command
2538 * @instance: Adapter soft state
2539 * @cmd: Cmd that was issued to abort another cmd
2540 *
0d49016b 2541 * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q
2542 * after it issues an abort on a previously issued command. This function
c4a3e0a5
BS		 2543 * wakes up all functions waiting on the same wait queue.
2544 */
2545static void
2546megasas_complete_abort(struct megasas_instance *instance,
2547 struct megasas_cmd *cmd)
2548{
2549 if (cmd->sync_cmd) {
2550 cmd->sync_cmd = 0;
2551 cmd->cmd_status = 0;
2552 wake_up(&instance->abort_cmd_wait_q);
2553 }
2554
2555 return;
2556}
2557
c4a3e0a5
BS		 2558/**
2559 * megasas_complete_cmd - Completes a command
2560 * @instance: Adapter soft state
2561 * @cmd: Command to be completed
0d49016b 2562 * @alt_status: If non-zero, use this value as status to
c4a3e0a5
BS		 2563 * SCSI mid-layer instead of the value returned
2564 * by the FW. This should be used if caller wants
2565 * an alternate status (as in the case of aborted
2566 * commands)
2567 */
9c915a8c 2568void
c4a3e0a5
BS		 2569megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
2570 u8 alt_status)
2571{
2572 int exception = 0;
2573 struct megasas_header *hdr = &cmd->frame->hdr;
c3518837 2574 unsigned long flags;
9c915a8c 2575 struct fusion_context *fusion = instance->ctrl_context;
94cd65dd 2576 u32 opcode;
c4a3e0a5 2577
39a98554 2578 /* flag for the retry reset */
2579 cmd->retry_for_fw_reset = 0;
2580
05e9ebbe
SP		 2581 if (cmd->scmd)
2582 cmd->scmd->SCp.ptr = NULL;
c4a3e0a5
BS		 2583
2584 switch (hdr->cmd) {
e5f93a36 2585 case MFI_CMD_INVALID:
2586 /* Some older 1068 controller FW may keep a pended
2587 MR_DCMD_CTRL_EVENT_GET_INFO left over from the main kernel
2588 when booting the kdump kernel. Ignore this command to
2589 prevent a kernel panic on shutdown of the kdump kernel. */
2590 printk(KERN_WARNING "megaraid_sas: MFI_CMD_INVALID command "
2591 "completed.\n");
2592 printk(KERN_WARNING "megaraid_sas: If you have a controller "
2593 "other than PERC5, please upgrade your firmware.\n");
2594 break;
c4a3e0a5
BS		 2595 case MFI_CMD_PD_SCSI_IO:
2596 case MFI_CMD_LD_SCSI_IO:
2597
2598 /*
2599 * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
2600 * issued either through an IO path or an IOCTL path. If it
2601 * was via IOCTL, we will send it to internal completion.
2602 */
2603 if (cmd->sync_cmd) {
2604 cmd->sync_cmd = 0;
2605 megasas_complete_int_cmd(instance, cmd);
2606 break;
2607 }
2608
c4a3e0a5
BS		 2609 case MFI_CMD_LD_READ:
2610 case MFI_CMD_LD_WRITE:
2611
2612 if (alt_status) {
2613 cmd->scmd->result = alt_status << 16;
2614 exception = 1;
2615 }
2616
2617 if (exception) {
2618
e4a082c7 2619 atomic_dec(&instance->fw_outstanding);
c4a3e0a5 2620
155d98f0 2621 scsi_dma_unmap(cmd->scmd);
c4a3e0a5
BS		 2622 cmd->scmd->scsi_done(cmd->scmd);
2623 megasas_return_cmd(instance, cmd);
2624
2625 break;
2626 }
2627
2628 switch (hdr->cmd_status) {
2629
2630 case MFI_STAT_OK:
2631 cmd->scmd->result = DID_OK << 16;
2632 break;
2633
2634 case MFI_STAT_SCSI_IO_FAILED:
2635 case MFI_STAT_LD_INIT_IN_PROGRESS:
2636 cmd->scmd->result =
2637 (DID_ERROR << 16) | hdr->scsi_status;
2638 break;
2639
2640 case MFI_STAT_SCSI_DONE_WITH_ERROR:
2641
2642 cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status;
2643
2644 if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) {
2645 memset(cmd->scmd->sense_buffer, 0,
2646 SCSI_SENSE_BUFFERSIZE);
2647 memcpy(cmd->scmd->sense_buffer, cmd->sense,
2648 hdr->sense_len);
2649
2650 cmd->scmd->result |= DRIVER_SENSE << 24;
2651 }
2652
2653 break;
2654
2655 case MFI_STAT_LD_OFFLINE:
2656 case MFI_STAT_DEVICE_NOT_FOUND:
2657 cmd->scmd->result = DID_BAD_TARGET << 16;
2658 break;
2659
2660 default:
2661 printk(KERN_DEBUG "megasas: MFI FW status %#x\n",
2662 hdr->cmd_status);
2663 cmd->scmd->result = DID_ERROR << 16;
2664 break;
2665 }
2666
e4a082c7 2667 atomic_dec(&instance->fw_outstanding);
c4a3e0a5 2668
155d98f0 2669 scsi_dma_unmap(cmd->scmd);
c4a3e0a5
BS		 2670 cmd->scmd->scsi_done(cmd->scmd);
2671 megasas_return_cmd(instance, cmd);
2672
2673 break;
2674
2675 case MFI_CMD_SMP:
2676 case MFI_CMD_STP:
2677 case MFI_CMD_DCMD:
94cd65dd 2678 opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
9c915a8c 2679 /* Check for LD map update */
94cd65dd
SS		 2680 if ((opcode == MR_DCMD_LD_MAP_GET_INFO)
2681 && (cmd->frame->dcmd.mbox.b[1] == 1)) {
bc93d425 2682 fusion->fast_path_io = 0;
9c915a8c 2683 spin_lock_irqsave(instance->host->host_lock, flags);
2684 if (cmd->frame->hdr.cmd_status != 0) {
2685 if (cmd->frame->hdr.cmd_status !=
2686 MFI_STAT_NOT_FOUND)
2687 printk(KERN_WARNING "megasas: map sync"
2688 "failed, status = 0x%x.\n",
2689 cmd->frame->hdr.cmd_status);
2690 else {
2691 megasas_return_cmd(instance, cmd);
2692 spin_unlock_irqrestore(
2693 instance->host->host_lock,
2694 flags);
2695 break;
2696 }
2697 } else
2698 instance->map_id++;
2699 megasas_return_cmd(instance, cmd);
bc93d425
SS		 2700
2701 /*
2702 * Set fast path IO to ZERO.
2703 * Validate Map will set proper value.
2704 * Meanwhile all IOs will go as LD IO.
2705 */
2706 if (MR_ValidateMapInfo(instance))
9c915a8c 2707 fusion->fast_path_io = 1;
2708 else
2709 fusion->fast_path_io = 0;
2710 megasas_sync_map_info(instance);
2711 spin_unlock_irqrestore(instance->host->host_lock,
2712 flags);
2713 break;
2714 }
94cd65dd
SS		 2715 if (opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||
2716 opcode == MR_DCMD_CTRL_EVENT_GET) {
c3518837
YB		 2717 spin_lock_irqsave(&poll_aen_lock, flags);
2718 megasas_poll_wait_aen = 0;
2719 spin_unlock_irqrestore(&poll_aen_lock, flags);
2720 }
c4a3e0a5
BS		 2721
2722 /*
2723 * See if got an event notification
2724 */
94cd65dd 2725 if (opcode == MR_DCMD_CTRL_EVENT_WAIT)
c4a3e0a5
BS		 2726 megasas_service_aen(instance, cmd);
2727 else
2728 megasas_complete_int_cmd(instance, cmd);
2729
2730 break;
2731
2732 case MFI_CMD_ABORT:
2733 /*
2734 * Cmd issued to abort another cmd returned
2735 */
2736 megasas_complete_abort(instance, cmd);
2737 break;
2738
2739 default:
2740 printk("megasas: Unknown command completed! [0x%X]\n",
2741 hdr->cmd);
2742 break;
2743 }
2744}
2745
39a98554 2746/**
2747 * megasas_issue_pending_cmds_again - issue all pending cmds
2748 * in FW again because of the fw reset
2749 * @instance: Adapter soft state
2750 */
2751static inline void
2752megasas_issue_pending_cmds_again(struct megasas_instance *instance)
2753{
2754 struct megasas_cmd *cmd;
2755 struct list_head clist_local;
2756 union megasas_evt_class_locale class_locale;
2757 unsigned long flags;
2758 u32 seq_num;
2759
2760 INIT_LIST_HEAD(&clist_local);
2761 spin_lock_irqsave(&instance->hba_lock, flags);
2762 list_splice_init(&instance->internal_reset_pending_q, &clist_local);
2763 spin_unlock_irqrestore(&instance->hba_lock, flags);
2764
2765 while (!list_empty(&clist_local)) {
2766 cmd = list_entry((&clist_local)->next,
2767 struct megasas_cmd, list);
2768 list_del_init(&cmd->list);
2769
2770 if (cmd->sync_cmd || cmd->scmd) {
2771 printk(KERN_NOTICE "megaraid_sas: command %p, %p:%d"
2772 "detected to be pending while HBA reset.\n",
2773 cmd, cmd->scmd, cmd->sync_cmd);
2774
2775 cmd->retry_for_fw_reset++;
2776
2777 if (cmd->retry_for_fw_reset == 3) {
2778 printk(KERN_NOTICE "megaraid_sas: cmd %p, %p:%d"
2779 "was tried multiple times during reset."
2780 "Shutting down the HBA\n",
2781 cmd, cmd->scmd, cmd->sync_cmd);
2782 megaraid_sas_kill_hba(instance);
2783
2784 instance->adprecovery =
2785 MEGASAS_HW_CRITICAL_ERROR;
2786 return;
2787 }
2788 }
2789
2790 if (cmd->sync_cmd == 1) {
2791 if (cmd->scmd) {
2792 printk(KERN_NOTICE "megaraid_sas: unexpected"
2793 "cmd attached to internal command!\n");
2794 }
2795 printk(KERN_NOTICE "megasas: %p synchronous cmd"
2796 "on the internal reset queue,"
2797 "issue it again.\n", cmd);
2798 cmd->cmd_status = ENODATA;
2799 instance->instancet->fire_cmd(instance,
2800 cmd->frame_phys_addr ,
2801 0, instance->reg_set);
2802 } else if (cmd->scmd) {
5cd049a5 2803 printk(KERN_NOTICE "megasas: %p scsi cmd [%02x]"
39a98554 2804 "detected on the internal queue, issue again.\n",
5cd049a5 2805 cmd, cmd->scmd->cmnd[0]);
39a98554 2806
2807 atomic_inc(&instance->fw_outstanding);
2808 instance->instancet->fire_cmd(instance,
2809 cmd->frame_phys_addr,
2810 cmd->frame_count-1, instance->reg_set);
2811 } else {
2812 printk(KERN_NOTICE "megasas: %p unexpected cmd on the"
2813 "internal reset defer list while re-issue!!\n",
2814 cmd);
2815 }
2816 }
2817
2818 if (instance->aen_cmd) {
2819 printk(KERN_NOTICE "megaraid_sas: aen_cmd in def process\n");
2820 megasas_return_cmd(instance, instance->aen_cmd);
2821
2822 instance->aen_cmd = NULL;
2823 }
2824
2825 /*
2826 * Initiate AEN (Asynchronous Event Notification)
2827 */
2828 seq_num = instance->last_seq_num;
2829 class_locale.members.reserved = 0;
2830 class_locale.members.locale = MR_EVT_LOCALE_ALL;
2831 class_locale.members.class = MR_EVT_CLASS_DEBUG;
2832
2833 megasas_register_aen(instance, seq_num, class_locale.word);
2834}
2835
2836/**
2837 * Move the internal reset pending commands to a deferred queue.
2838 *
2839 * We move the commands pending at internal reset time to a
2840 * pending queue. This queue would be flushed after successful
2841 * completion of the internal reset sequence. if the internal reset
2842 * did not complete in time, the kernel reset handler would flush
2843 * these commands.
2844 **/
2845static void
2846megasas_internal_reset_defer_cmds(struct megasas_instance *instance)
2847{
2848 struct megasas_cmd *cmd;
2849 int i;
2850 u32 max_cmd = instance->max_fw_cmds;
2851 u32 defer_index;
2852 unsigned long flags;
2853
2854 defer_index = 0;
2855 spin_lock_irqsave(&instance->cmd_pool_lock, flags);
2856 for (i = 0; i < max_cmd; i++) {
2857 cmd = instance->cmd_list[i];
2858 if (cmd->sync_cmd == 1 || cmd->scmd) {
2859 printk(KERN_NOTICE "megasas: moving cmd[%d]:%p:%d:%p"
2860 "on the defer queue as internal\n",
2861 defer_index, cmd, cmd->sync_cmd, cmd->scmd);
2862
2863 if (!list_empty(&cmd->list)) {
2864 printk(KERN_NOTICE "megaraid_sas: ERROR while"
2865 " moving this cmd:%p, %d %p, it was"
2866 "discovered on some list?\n",
2867 cmd, cmd->sync_cmd, cmd->scmd);
2868
2869 list_del_init(&cmd->list);
2870 }
2871 defer_index++;
2872 list_add_tail(&cmd->list,
2873 &instance->internal_reset_pending_q);
2874 }
2875 }
2876 spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
2877}
2878
2879
2880static void
2881process_fw_state_change_wq(struct work_struct *work)
2882{
2883 struct megasas_instance *instance =
2884 container_of(work, struct megasas_instance, work_init);
2885 u32 wait;
2886 unsigned long flags;
2887
2888 if (instance->adprecovery != MEGASAS_ADPRESET_SM_INFAULT) {
2889 printk(KERN_NOTICE "megaraid_sas: error, recovery st %x \n",
2890 instance->adprecovery);
2891 return ;
2892 }
2893
2894 if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) {
2895 printk(KERN_NOTICE "megaraid_sas: FW detected to be in fault"
2896 "state, restarting it...\n");
2897
d46a3ad6 2898 instance->instancet->disable_intr(instance);
39a98554 2899 atomic_set(&instance->fw_outstanding, 0);
2900
2901 atomic_set(&instance->fw_reset_no_pci_access, 1);
2902 instance->instancet->adp_reset(instance, instance->reg_set);
2903 atomic_set(&instance->fw_reset_no_pci_access, 0 );
2904
2905 printk(KERN_NOTICE "megaraid_sas: FW restarted successfully,"
2906 "initiating next stage...\n");
2907
2908 printk(KERN_NOTICE "megaraid_sas: HBA recovery state machine,"
2909 "state 2 starting...\n");
2910
2911 /*waitting for about 20 second before start the second init*/
2912 for (wait = 0; wait < 30; wait++) {
2913 msleep(1000);
2914 }
2915
058a8fac 2916 if (megasas_transition_to_ready(instance, 1)) {
39a98554 2917 printk(KERN_NOTICE "megaraid_sas:adapter not ready\n");
2918
2919 megaraid_sas_kill_hba(instance);
2920 instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR;
2921 return ;
2922 }
2923
2924 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
2925 (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
2926 (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)
2927 ) {
2928 *instance->consumer = *instance->producer;
2929 } else {
2930 *instance->consumer = 0;
2931 *instance->producer = 0;
2932 }
2933
2934 megasas_issue_init_mfi(instance);
2935
2936 spin_lock_irqsave(&instance->hba_lock, flags);
2937 instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
2938 spin_unlock_irqrestore(&instance->hba_lock, flags);
d46a3ad6 2939 instance->instancet->enable_intr(instance);
39a98554 2940
2941 megasas_issue_pending_cmds_again(instance);
2942 instance->issuepend_done = 1;
2943 }
2944 return ;
2945}
2946
c4a3e0a5
BS		 2947/**
2948 * megasas_deplete_reply_queue - Processes all completed commands
2949 * @instance: Adapter soft state
2950 * @alt_status: Alternate status to be returned to
2951 * SCSI mid-layer instead of the status
2952 * returned by the FW
39a98554 2953 * Note: this must be called with hba lock held
c4a3e0a5 2954 */
858119e1 2955static int
39a98554 2956megasas_deplete_reply_queue(struct megasas_instance *instance,
2957 u8 alt_status)
c4a3e0a5 2958{
39a98554 2959 u32 mfiStatus;
2960 u32 fw_state;
2961
2962 if ((mfiStatus = instance->instancet->check_reset(instance,
2963 instance->reg_set)) == 1) {
2964 return IRQ_HANDLED;
2965 }
2966
2967 if ((mfiStatus = instance->instancet->clear_intr(
2968 instance->reg_set)
2969 ) == 0) {
e1419191 2970 /* Hardware may not set outbound_intr_status in MSI-X mode */
c8e858fe 2971 if (!instance->msix_vectors)
e1419191 2972 return IRQ_NONE;
39a98554 2973 }
2974
2975 instance->mfiStatus = mfiStatus;
2976
2977 if ((mfiStatus & MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE)) {
2978 fw_state = instance->instancet->read_fw_status_reg(
2979 instance->reg_set) & MFI_STATE_MASK;
2980
2981 if (fw_state != MFI_STATE_FAULT) {
2982 printk(KERN_NOTICE "megaraid_sas: fw state:%x\n",
2983 fw_state);
2984 }
2985
2986 if ((fw_state == MFI_STATE_FAULT) &&
2987 (instance->disableOnlineCtrlReset == 0)) {
2988 printk(KERN_NOTICE "megaraid_sas: wait adp restart\n");
2989
2990 if ((instance->pdev->device ==
2991 PCI_DEVICE_ID_LSI_SAS1064R) ||
2992 (instance->pdev->device ==
2993 PCI_DEVICE_ID_DELL_PERC5) ||
2994 (instance->pdev->device ==
2995 PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
2996
2997 *instance->consumer =
94cd65dd 2998 cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
39a98554 2999 }
3000
3001
d46a3ad6 3002 instance->instancet->disable_intr(instance);
39a98554 3003 instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT;
3004 instance->issuepend_done = 0;
3005
3006 atomic_set(&instance->fw_outstanding, 0);
3007 megasas_internal_reset_defer_cmds(instance);
3008
3009 printk(KERN_NOTICE "megasas: fwState=%x, stage:%d\n",
3010 fw_state, instance->adprecovery);
3011
3012 schedule_work(&instance->work_init);
3013 return IRQ_HANDLED;
3014
3015 } else {
3016 printk(KERN_NOTICE "megasas: fwstate:%x, dis_OCR=%x\n",
3017 fw_state, instance->disableOnlineCtrlReset);
3018 }
3019 }
c4a3e0a5 3020
5d018ad0 3021 tasklet_schedule(&instance->isr_tasklet);
c4a3e0a5
BS		 3022 return IRQ_HANDLED;
3023}
c4a3e0a5
BS		 3024/**
3025 * megasas_isr - isr entry point
3026 */
7d12e780 3027static irqreturn_t megasas_isr(int irq, void *devp)
c4a3e0a5 3028{
c8e858fe 3029 struct megasas_irq_context *irq_context = devp;
3030 struct megasas_instance *instance = irq_context->instance;
39a98554 3031 unsigned long flags;
3032 irqreturn_t rc;
3033
c8e858fe 3034 if (atomic_read(&instance->fw_reset_no_pci_access))
39a98554 3035 return IRQ_HANDLED;
3036
39a98554 3037 spin_lock_irqsave(&instance->hba_lock, flags);
3038 rc = megasas_deplete_reply_queue(instance, DID_OK);
3039 spin_unlock_irqrestore(&instance->hba_lock, flags);
3040
3041 return rc;
c4a3e0a5
BS		 3042}
3043
3044/**
3045 * megasas_transition_to_ready - Move the FW to READY state
1341c939 3046 * @instance: Adapter soft state
c4a3e0a5
BS		 3047 *
3048 * During the initialization, FW passes can potentially be in any one of
3049 * several possible states. If the FW in operational, waiting-for-handshake
3050 * states, driver must take steps to bring it to ready state. Otherwise, it
3051 * has to wait for the ready state.
3052 */
9c915a8c 3053int
058a8fac 3054megasas_transition_to_ready(struct megasas_instance *instance, int ocr)
c4a3e0a5
BS		 3055{
3056 int i;
3057 u8 max_wait;
3058 u32 fw_state;
3059 u32 cur_state;
7218df69 3060 u32 abs_state, curr_abs_state;
c4a3e0a5 3061
bc6ac5e8
TH		 3062 abs_state = instance->instancet->read_fw_status_reg(instance->reg_set);
3063 fw_state = abs_state & MFI_STATE_MASK;
c4a3e0a5 3064
e3bbff9f 3065 if (fw_state != MFI_STATE_READY)
0d49016b 3066 printk(KERN_INFO "megasas: Waiting for FW to come to ready"
3067 " state\n");
e3bbff9f 3068
c4a3e0a5
BS		 3069 while (fw_state != MFI_STATE_READY) {
3070
c4a3e0a5
BS		 3071 switch (fw_state) {
3072
3073 case MFI_STATE_FAULT:
c4a3e0a5 3074 printk(KERN_DEBUG "megasas: FW in FAULT state!!\n");
058a8fac 3075 if (ocr) {
3076 max_wait = MEGASAS_RESET_WAIT_TIME;
3077 cur_state = MFI_STATE_FAULT;
3078 break;
3079 } else
3080 return -ENODEV;
c4a3e0a5
BS		 3081
3082 case MFI_STATE_WAIT_HANDSHAKE:
3083 /*
3084 * Set the CLR bit in inbound doorbell
3085 */
0c79e681 3086 if ((instance->pdev->device ==
87911122
YB		 3087 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
3088 (instance->pdev->device ==
9c915a8c 3089 PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
3090 (instance->pdev->device ==
21d3c710 3091 PCI_DEVICE_ID_LSI_FUSION) ||
36807e67 3092 (instance->pdev->device ==
229fe47c 3093 PCI_DEVICE_ID_LSI_PLASMA) ||
3094 (instance->pdev->device ==
21d3c710
SS		 3095 PCI_DEVICE_ID_LSI_INVADER) ||
3096 (instance->pdev->device ==
3097 PCI_DEVICE_ID_LSI_FURY)) {
87911122
YB		 3098 writel(
3099 MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
9c915a8c 3100 &instance->reg_set->doorbell);
87911122
YB		 3101 } else {
3102 writel(
3103 MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
3104 &instance->reg_set->inbound_doorbell);
3105 }
c4a3e0a5 3106
7218df69 3107 max_wait = MEGASAS_RESET_WAIT_TIME;
c4a3e0a5
BS		 3108 cur_state = MFI_STATE_WAIT_HANDSHAKE;
3109 break;
3110
e3bbff9f 3111 case MFI_STATE_BOOT_MESSAGE_PENDING:
87911122 3112 if ((instance->pdev->device ==
9c915a8c 3113 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
3114 (instance->pdev->device ==
3115 PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
3116 (instance->pdev->device ==
36807e67 3117 PCI_DEVICE_ID_LSI_FUSION) ||
229fe47c 3118 (instance->pdev->device ==
3119 PCI_DEVICE_ID_LSI_PLASMA) ||
36807e67 3120 (instance->pdev->device ==
21d3c710
SS		 3121 PCI_DEVICE_ID_LSI_INVADER) ||
3122 (instance->pdev->device ==
3123 PCI_DEVICE_ID_LSI_FURY)) {
87911122 3124 writel(MFI_INIT_HOTPLUG,
9c915a8c 3125 &instance->reg_set->doorbell);
87911122
YB		 3126 } else
3127 writel(MFI_INIT_HOTPLUG,
3128 &instance->reg_set->inbound_doorbell);
e3bbff9f 3129
7218df69 3130 max_wait = MEGASAS_RESET_WAIT_TIME;
e3bbff9f
SP		 3131 cur_state = MFI_STATE_BOOT_MESSAGE_PENDING;
3132 break;
3133
c4a3e0a5
BS		 3134 case MFI_STATE_OPERATIONAL:
3135 /*
e3bbff9f 3136 * Bring it to READY state; assuming max wait 10 secs
c4a3e0a5 3137 */
d46a3ad6 3138 instance->instancet->disable_intr(instance);
87911122
YB		 3139 if ((instance->pdev->device ==
3140 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
3141 (instance->pdev->device ==
9c915a8c 3142 PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
3143 (instance->pdev->device
36807e67 3144 == PCI_DEVICE_ID_LSI_FUSION) ||
229fe47c 3145 (instance->pdev->device
3146 == PCI_DEVICE_ID_LSI_PLASMA) ||
36807e67 3147 (instance->pdev->device
21d3c710
SS		 3148 == PCI_DEVICE_ID_LSI_INVADER) ||
3149 (instance->pdev->device
3150 == PCI_DEVICE_ID_LSI_FURY)) {
87911122 3151 writel(MFI_RESET_FLAGS,
9c915a8c 3152 &instance->reg_set->doorbell);
36807e67 3153 if ((instance->pdev->device ==
21d3c710
SS		 3154 PCI_DEVICE_ID_LSI_FUSION) ||
3155 (instance->pdev->device ==
229fe47c 3156 PCI_DEVICE_ID_LSI_PLASMA) ||
3157 (instance->pdev->device ==
21d3c710
SS		 3158 PCI_DEVICE_ID_LSI_INVADER) ||
3159 (instance->pdev->device ==
3160 PCI_DEVICE_ID_LSI_FURY)) {
9c915a8c 3161 for (i = 0; i < (10 * 1000); i += 20) {
3162 if (readl(
3163 &instance->
3164 reg_set->
3165 doorbell) & 1)
3166 msleep(20);
3167 else
3168 break;
3169 }
3170 }
87911122
YB		 3171 } else
3172 writel(MFI_RESET_FLAGS,
3173 &instance->reg_set->inbound_doorbell);
c4a3e0a5 3174
7218df69 3175 max_wait = MEGASAS_RESET_WAIT_TIME;
c4a3e0a5
BS		 3176 cur_state = MFI_STATE_OPERATIONAL;
3177 break;
3178
3179 case MFI_STATE_UNDEFINED:
3180 /*
3181 * This state should not last for more than 2 seconds
3182 */
7218df69 3183 max_wait = MEGASAS_RESET_WAIT_TIME;
c4a3e0a5
BS		 3184 cur_state = MFI_STATE_UNDEFINED;
3185 break;
3186
3187 case MFI_STATE_BB_INIT:
7218df69 3188 max_wait = MEGASAS_RESET_WAIT_TIME;
c4a3e0a5
BS		 3189 cur_state = MFI_STATE_BB_INIT;
3190 break;
3191
3192 case MFI_STATE_FW_INIT:
7218df69 3193 max_wait = MEGASAS_RESET_WAIT_TIME;
c4a3e0a5
BS		 3194 cur_state = MFI_STATE_FW_INIT;
3195 break;
3196
3197 case MFI_STATE_FW_INIT_2:
7218df69 3198 max_wait = MEGASAS_RESET_WAIT_TIME;
c4a3e0a5
BS		 3199 cur_state = MFI_STATE_FW_INIT_2;
3200 break;
3201
3202 case MFI_STATE_DEVICE_SCAN:
7218df69 3203 max_wait = MEGASAS_RESET_WAIT_TIME;
c4a3e0a5
BS		 3204 cur_state = MFI_STATE_DEVICE_SCAN;
3205 break;
3206
3207 case MFI_STATE_FLUSH_CACHE:
7218df69 3208 max_wait = MEGASAS_RESET_WAIT_TIME;
c4a3e0a5
BS		 3209 cur_state = MFI_STATE_FLUSH_CACHE;
3210 break;
3211
3212 default:
3213 printk(KERN_DEBUG "megasas: Unknown state 0x%x\n",
3214 fw_state);
3215 return -ENODEV;
3216 }
3217
3218 /*
3219 * The cur_state should not last for more than max_wait secs
3220 */
3221 for (i = 0; i < (max_wait * 1000); i++) {
bc6ac5e8
TH		 3222 curr_abs_state = instance->instancet->
3223 read_fw_status_reg(instance->reg_set);
c4a3e0a5 3224
7218df69 3225 if (abs_state == curr_abs_state) {
c4a3e0a5
BS		 3226 msleep(1);
3227 } else
3228 break;
3229 }
3230
3231 /*
3232 * Return error if fw_state hasn't changed after max_wait
3233 */
7218df69 3234 if (curr_abs_state == abs_state) {
c4a3e0a5
BS		 3235 printk(KERN_DEBUG "FW state [%d] hasn't changed "
3236 "in %d secs\n", fw_state, max_wait);
3237 return -ENODEV;
3238 }
bc6ac5e8
TH		 3239
3240 abs_state = curr_abs_state;
3241 fw_state = curr_abs_state & MFI_STATE_MASK;
39a98554 3242 }
0d49016b 3243 printk(KERN_INFO "megasas: FW now in Ready state\n");
c4a3e0a5
BS		 3244
3245 return 0;
3246}
3247
3248/**
3249 * megasas_teardown_frame_pool - Destroy the cmd frame DMA pool
3250 * @instance: Adapter soft state
3251 */
3252static void megasas_teardown_frame_pool(struct megasas_instance *instance)
3253{
3254 int i;
9c915a8c 3255 u32 max_cmd = instance->max_mfi_cmds;
c4a3e0a5
BS		 3256 struct megasas_cmd *cmd;
3257
3258 if (!instance->frame_dma_pool)
3259 return;
3260
3261 /*
3262 * Return all frames to pool
3263 */
3264 for (i = 0; i < max_cmd; i++) {
3265
3266 cmd = instance->cmd_list[i];
3267
3268 if (cmd->frame)
3269 pci_pool_free(instance->frame_dma_pool, cmd->frame,
3270 cmd->frame_phys_addr);
3271
3272 if (cmd->sense)
e3bbff9f 3273 pci_pool_free(instance->sense_dma_pool, cmd->sense,
c4a3e0a5
BS		 3274 cmd->sense_phys_addr);
3275 }
3276
3277 /*
3278 * Now destroy the pool itself
3279 */
3280 pci_pool_destroy(instance->frame_dma_pool);
3281 pci_pool_destroy(instance->sense_dma_pool);
3282
3283 instance->frame_dma_pool = NULL;
3284 instance->sense_dma_pool = NULL;
3285}
3286
3287/**
3288 * megasas_create_frame_pool - Creates DMA pool for cmd frames
3289 * @instance: Adapter soft state
3290 *
3291 * Each command packet has an embedded DMA memory buffer that is used for
3292 * filling MFI frame and the SG list that immediately follows the frame. This
3293 * function creates those DMA memory buffers for each command packet by using
3294 * PCI pool facility.
3295 */
3296static int megasas_create_frame_pool(struct megasas_instance *instance)
3297{
3298 int i;
3299 u32 max_cmd;
3300 u32 sge_sz;
3301 u32 sgl_sz;
3302 u32 total_sz;
3303 u32 frame_count;
3304 struct megasas_cmd *cmd;
3305
9c915a8c 3306 max_cmd = instance->max_mfi_cmds;
c4a3e0a5
BS		 3307
3308 /*
3309 * Size of our frame is 64 bytes for MFI frame, followed by max SG
3310 * elements and finally SCSI_SENSE_BUFFERSIZE bytes for sense buffer
3311 */
3312 sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
3313 sizeof(struct megasas_sge32);
3314
f4c9a131
YB		 3315 if (instance->flag_ieee) {
3316 sge_sz = sizeof(struct megasas_sge_skinny);
3317 }
3318
c4a3e0a5
BS		 3319 /*
3320 * Calculated the number of 64byte frames required for SGL
3321 */
3322 sgl_sz = sge_sz * instance->max_num_sge;
3323 frame_count = (sgl_sz + MEGAMFI_FRAME_SIZE - 1) / MEGAMFI_FRAME_SIZE;
39a98554 3324 frame_count = 15;
c4a3e0a5
BS		 3325
3326 /*
3327 * We need one extra frame for the MFI command
3328 */
3329 frame_count++;
3330
3331 total_sz = MEGAMFI_FRAME_SIZE * frame_count;
3332 /*
3333 * Use DMA pool facility provided by PCI layer
3334 */
3335 instance->frame_dma_pool = pci_pool_create("megasas frame pool",
3336 instance->pdev, total_sz, 64,
3337 0);
3338
3339 if (!instance->frame_dma_pool) {
3340 printk(KERN_DEBUG "megasas: failed to setup frame pool\n");
3341 return -ENOMEM;
3342 }
3343
3344 instance->sense_dma_pool = pci_pool_create("megasas sense pool",
3345 instance->pdev, 128, 4, 0);
3346
3347 if (!instance->sense_dma_pool) {
3348 printk(KERN_DEBUG "megasas: failed to setup sense pool\n");
3349
3350 pci_pool_destroy(instance->frame_dma_pool);
3351 instance->frame_dma_pool = NULL;
3352
3353 return -ENOMEM;
3354 }
3355
3356 /*
3357 * Allocate and attach a frame to each of the commands in cmd_list.
3358 * By making cmd->index as the context instead of the &cmd, we can
3359 * always use 32bit context regardless of the architecture
3360 */
3361 for (i = 0; i < max_cmd; i++) {
3362
3363 cmd = instance->cmd_list[i];
3364
3365 cmd->frame = pci_pool_alloc(instance->frame_dma_pool,
3366 GFP_KERNEL, &cmd->frame_phys_addr);
3367
3368 cmd->sense = pci_pool_alloc(instance->sense_dma_pool,
3369 GFP_KERNEL, &cmd->sense_phys_addr);
3370
3371 /*
3372 * megasas_teardown_frame_pool() takes care of freeing
3373 * whatever has been allocated
3374 */
3375 if (!cmd->frame || !cmd->sense) {
3376 printk(KERN_DEBUG "megasas: pci_pool_alloc failed \n");
3377 megasas_teardown_frame_pool(instance);
3378 return -ENOMEM;
3379 }
3380
707e09bd 3381 memset(cmd->frame, 0, total_sz);
94cd65dd 3382 cmd->frame->io.context = cpu_to_le32(cmd->index);
7e8a75f4 3383 cmd->frame->io.pad_0 = 0;
e5f93a36 3384 if ((instance->pdev->device != PCI_DEVICE_ID_LSI_FUSION) &&
229fe47c 3385 (instance->pdev->device != PCI_DEVICE_ID_LSI_PLASMA) &&
e5f93a36 3386 (instance->pdev->device != PCI_DEVICE_ID_LSI_INVADER) &&
21d3c710 3387 (instance->pdev->device != PCI_DEVICE_ID_LSI_FURY) &&
e5f93a36 3388 (reset_devices))
3389 cmd->frame->hdr.cmd = MFI_CMD_INVALID;
c4a3e0a5
BS		 3390 }
3391
3392 return 0;
3393}
3394
3395/**
3396 * megasas_free_cmds - Free all the cmds in the free cmd pool
3397 * @instance: Adapter soft state
3398 */
9c915a8c 3399void megasas_free_cmds(struct megasas_instance *instance)
c4a3e0a5
BS		 3400{
3401 int i;
3402 /* First free the MFI frame pool */
3403 megasas_teardown_frame_pool(instance);
3404
3405 /* Free all the commands in the cmd_list */
9c915a8c 3406 for (i = 0; i < instance->max_mfi_cmds; i++)
3407
c4a3e0a5
BS		 3408 kfree(instance->cmd_list[i]);
3409
3410 /* Free the cmd_list buffer itself */
3411 kfree(instance->cmd_list);
3412 instance->cmd_list = NULL;
3413
3414 INIT_LIST_HEAD(&instance->cmd_pool);
3415}
3416
3417/**
3418 * megasas_alloc_cmds - Allocates the command packets
3419 * @instance: Adapter soft state
3420 *
3421 * Each command that is issued to the FW, whether IO commands from the OS or
3422 * internal commands like IOCTLs, are wrapped in local data structure called
3423 * megasas_cmd. The frame embedded in this megasas_cmd is actually issued to
3424 * the FW.
3425 *
3426 * Each frame has a 32-bit field called context (tag). This context is used
3427 * to get back the megasas_cmd from the frame when a frame gets completed in
3428 * the ISR. Typically the address of the megasas_cmd itself would be used as
3429 * the context. But we wanted to keep the differences between 32 and 64 bit
3430 * systems to the mininum. We always use 32 bit integers for the context. In
3431 * this driver, the 32 bit values are the indices into an array cmd_list.
3432 * This array is used only to look up the megasas_cmd given the context. The
3433 * free commands themselves are maintained in a linked list called cmd_pool.
3434 */
9c915a8c 3435int megasas_alloc_cmds(struct megasas_instance *instance)
c4a3e0a5
BS		 3436{
3437 int i;
3438 int j;
3439 u32 max_cmd;
3440 struct megasas_cmd *cmd;
3441
9c915a8c 3442 max_cmd = instance->max_mfi_cmds;
c4a3e0a5
BS		 3443
3444 /*
3445 * instance->cmd_list is an array of struct megasas_cmd pointers.
3446 * Allocate the dynamic array first and then allocate individual
3447 * commands.
3448 */
dd00cc48 3449 instance->cmd_list = kcalloc(max_cmd, sizeof(struct megasas_cmd*), GFP_KERNEL);
c4a3e0a5
BS		 3450
3451 if (!instance->cmd_list) {
3452 printk(KERN_DEBUG "megasas: out of memory\n");
3453 return -ENOMEM;
3454 }
3455
9c915a8c 3456 memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) *max_cmd);
c4a3e0a5
BS		 3457
3458 for (i = 0; i < max_cmd; i++) {
3459 instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
3460 GFP_KERNEL);
3461
3462 if (!instance->cmd_list[i]) {
3463
3464 for (j = 0; j < i; j++)
3465 kfree(instance->cmd_list[j]);
3466
3467 kfree(instance->cmd_list);
3468 instance->cmd_list = NULL;
3469
3470 return -ENOMEM;
3471 }
3472 }
3473
3474 /*
3475 * Add all the commands to command pool (instance->cmd_pool)
3476 */
3477 for (i = 0; i < max_cmd; i++) {
3478 cmd = instance->cmd_list[i];
3479 memset(cmd, 0, sizeof(struct megasas_cmd));
3480 cmd->index = i;
39a98554 3481 cmd->scmd = NULL;
c4a3e0a5
BS		 3482 cmd->instance = instance;
3483
3484 list_add_tail(&cmd->list, &instance->cmd_pool);
3485 }
3486
3487 /*
3488 * Create a frame pool and assign one frame to each cmd
3489 */
3490 if (megasas_create_frame_pool(instance)) {
3491 printk(KERN_DEBUG "megasas: Error creating frame DMA pool\n");
3492 megasas_free_cmds(instance);
3493 }
3494
3495 return 0;
3496}
3497
81e403ce
YB		 3498/*
3499 * megasas_get_pd_list_info - Returns FW's pd_list structure
3500 * @instance: Adapter soft state
3501 * @pd_list: pd_list structure
3502 *
3503 * Issues an internal command (DCMD) to get the FW's controller PD
3504 * list structure. This information is mainly used to find out SYSTEM
3505 * supported by the FW.
3506 */
3507static int
3508megasas_get_pd_list(struct megasas_instance *instance)
3509{
3510 int ret = 0, pd_index = 0;
3511 struct megasas_cmd *cmd;
3512 struct megasas_dcmd_frame *dcmd;
3513 struct MR_PD_LIST *ci;
3514 struct MR_PD_ADDRESS *pd_addr;
3515 dma_addr_t ci_h = 0;
3516
3517 cmd = megasas_get_cmd(instance);
3518
3519 if (!cmd) {
3520 printk(KERN_DEBUG "megasas (get_pd_list): Failed to get cmd\n");
3521 return -ENOMEM;
3522 }
3523
3524 dcmd = &cmd->frame->dcmd;
3525
3526 ci = pci_alloc_consistent(instance->pdev,
3527 MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST), &ci_h);
3528
3529 if (!ci) {
3530 printk(KERN_DEBUG "Failed to alloc mem for pd_list\n");
3531 megasas_return_cmd(instance, cmd);
3532 return -ENOMEM;
3533 }
3534
3535 memset(ci, 0, sizeof(*ci));
3536 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3537
3538 dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;
3539 dcmd->mbox.b[1] = 0;
3540 dcmd->cmd = MFI_CMD_DCMD;
3541 dcmd->cmd_status = 0xFF;
3542 dcmd->sge_count = 1;
94cd65dd 3543 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
81e403ce 3544 dcmd->timeout = 0;
780a3762 3545 dcmd->pad_0 = 0;
94cd65dd
SS		 3546 dcmd->data_xfer_len = cpu_to_le32(MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST));
3547 dcmd->opcode = cpu_to_le32(MR_DCMD_PD_LIST_QUERY);
3548 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
3549 dcmd->sgl.sge32[0].length = cpu_to_le32(MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST));
81e403ce
YB		 3550
3551 if (!megasas_issue_polled(instance, cmd)) {
3552 ret = 0;
3553 } else {
3554 ret = -1;
3555 }
3556
3557 /*
3558 * the following function will get the instance PD LIST.
3559 */
3560
3561 pd_addr = ci->addr;
3562
3563 if ( ret == 0 &&
94cd65dd 3564 (le32_to_cpu(ci->count) <
81e403ce
YB		 3565 (MEGASAS_MAX_PD_CHANNELS * MEGASAS_MAX_DEV_PER_CHANNEL))) {
3566
999ece0a 3567 memset(instance->local_pd_list, 0,
81e403ce
YB		 3568 MEGASAS_MAX_PD * sizeof(struct megasas_pd_list));
3569
94cd65dd 3570 for (pd_index = 0; pd_index < le32_to_cpu(ci->count); pd_index++) {
81e403ce 3571
999ece0a 3572 instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].tid =
94cd65dd 3573 le16_to_cpu(pd_addr->deviceId);
999ece0a 3574 instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveType =
81e403ce 3575 pd_addr->scsiDevType;
999ece0a 3576 instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveState =
81e403ce
YB		 3577 MR_PD_STATE_SYSTEM;
3578 pd_addr++;
3579 }
999ece0a
SS		 3580 memcpy(instance->pd_list, instance->local_pd_list,
3581 sizeof(instance->pd_list));
81e403ce
YB		 3582 }
3583
3584 pci_free_consistent(instance->pdev,
3585 MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
3586 ci, ci_h);
3587 megasas_return_cmd(instance, cmd);
3588
3589 return ret;
3590}
3591
bdc6fb8d
YB		 3592/*
3593 * megasas_get_ld_list_info - Returns FW's ld_list structure
3594 * @instance: Adapter soft state
3595 * @ld_list: ld_list structure
3596 *
3597 * Issues an internal command (DCMD) to get the FW's controller PD
3598 * list structure. This information is mainly used to find out SYSTEM
3599 * supported by the FW.
3600 */
3601static int
3602megasas_get_ld_list(struct megasas_instance *instance)
3603{
3604 int ret = 0, ld_index = 0, ids = 0;
3605 struct megasas_cmd *cmd;
3606 struct megasas_dcmd_frame *dcmd;
3607 struct MR_LD_LIST *ci;
3608 dma_addr_t ci_h = 0;
94cd65dd 3609 u32 ld_count;
bdc6fb8d
YB		 3610
3611 cmd = megasas_get_cmd(instance);
3612
3613 if (!cmd) {
3614 printk(KERN_DEBUG "megasas_get_ld_list: Failed to get cmd\n");
3615 return -ENOMEM;
3616 }
3617
3618 dcmd = &cmd->frame->dcmd;
3619
3620 ci = pci_alloc_consistent(instance->pdev,
3621 sizeof(struct MR_LD_LIST),
3622 &ci_h);
3623
3624 if (!ci) {
3625 printk(KERN_DEBUG "Failed to alloc mem in get_ld_list\n");
3626 megasas_return_cmd(instance, cmd);
3627 return -ENOMEM;
3628 }
3629
3630 memset(ci, 0, sizeof(*ci));
3631 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3632
3633 dcmd->cmd = MFI_CMD_DCMD;
3634 dcmd->cmd_status = 0xFF;
3635 dcmd->sge_count = 1;
94cd65dd 3636 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
bdc6fb8d 3637 dcmd->timeout = 0;
94cd65dd
SS		 3638 dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_LIST));
3639 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_GET_LIST);
3640 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
3641 dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct MR_LD_LIST));
bdc6fb8d
YB		 3642 dcmd->pad_0 = 0;
3643
3644 if (!megasas_issue_polled(instance, cmd)) {
3645 ret = 0;
3646 } else {
3647 ret = -1;
3648 }
3649
94cd65dd
SS		 3650 ld_count = le32_to_cpu(ci->ldCount);
3651
bdc6fb8d
YB		 3652 /* the following function will get the instance PD LIST */
3653
94cd65dd 3654 if ((ret == 0) && (ld_count <= MAX_LOGICAL_DRIVES)) {
bdc6fb8d
YB		 3655 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
3656
94cd65dd 3657 for (ld_index = 0; ld_index < ld_count; ld_index++) {
bdc6fb8d
YB		 3658 if (ci->ldList[ld_index].state != 0) {
3659 ids = ci->ldList[ld_index].ref.targetId;
3660 instance->ld_ids[ids] =
3661 ci->ldList[ld_index].ref.targetId;
3662 }
3663 }
3664 }
3665
3666 pci_free_consistent(instance->pdev,
3667 sizeof(struct MR_LD_LIST),
3668 ci,
3669 ci_h);
3670
3671 megasas_return_cmd(instance, cmd);
3672 return ret;
3673}
3674
21c9e160 3675/**
3676 * megasas_ld_list_query - Returns FW's ld_list structure
3677 * @instance: Adapter soft state
3678 * @ld_list: ld_list structure
3679 *
3680 * Issues an internal command (DCMD) to get the FW's controller PD
3681 * list structure. This information is mainly used to find out SYSTEM
3682 * supported by the FW.
3683 */
3684static int
3685megasas_ld_list_query(struct megasas_instance *instance, u8 query_type)
3686{
3687 int ret = 0, ld_index = 0, ids = 0;
3688 struct megasas_cmd *cmd;
3689 struct megasas_dcmd_frame *dcmd;
3690 struct MR_LD_TARGETID_LIST *ci;
3691 dma_addr_t ci_h = 0;
94cd65dd 3692 u32 tgtid_count;
21c9e160 3693
3694 cmd = megasas_get_cmd(instance);
3695
3696 if (!cmd) {
3697 printk(KERN_WARNING
3698 "megasas:(megasas_ld_list_query): Failed to get cmd\n");
3699 return -ENOMEM;
3700 }
3701
3702 dcmd = &cmd->frame->dcmd;
3703
3704 ci = pci_alloc_consistent(instance->pdev,
3705 sizeof(struct MR_LD_TARGETID_LIST), &ci_h);
3706
3707 if (!ci) {
3708 printk(KERN_WARNING
3709 "megasas: Failed to alloc mem for ld_list_query\n");
3710 megasas_return_cmd(instance, cmd);
3711 return -ENOMEM;
3712 }
3713
3714 memset(ci, 0, sizeof(*ci));
3715 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3716
3717 dcmd->mbox.b[0] = query_type;
3718
3719 dcmd->cmd = MFI_CMD_DCMD;
3720 dcmd->cmd_status = 0xFF;
3721 dcmd->sge_count = 1;
94cd65dd 3722 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
21c9e160 3723 dcmd->timeout = 0;
94cd65dd
SS		 3724 dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST));
3725 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_LIST_QUERY);
3726 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
3727 dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST));
21c9e160 3728 dcmd->pad_0 = 0;
3729
3730 if (!megasas_issue_polled(instance, cmd) && !dcmd->cmd_status) {
3731 ret = 0;
3732 } else {
3733 /* On failure, call older LD list DCMD */
3734 ret = 1;
3735 }
3736
94cd65dd
SS		 3737 tgtid_count = le32_to_cpu(ci->count);
3738
3739 if ((ret == 0) && (tgtid_count <= (MAX_LOGICAL_DRIVES))) {
21c9e160 3740 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
94cd65dd 3741 for (ld_index = 0; ld_index < tgtid_count; ld_index++) {
21c9e160 3742 ids = ci->targetId[ld_index];
3743 instance->ld_ids[ids] = ci->targetId[ld_index];
3744 }
3745
3746 }
3747
3748 pci_free_consistent(instance->pdev, sizeof(struct MR_LD_TARGETID_LIST),
3749 ci, ci_h);
3750
3751 megasas_return_cmd(instance, cmd);
3752
3753 return ret;
3754}
3755
c4a3e0a5
BS		 3756/**
3757 * megasas_get_controller_info - Returns FW's controller structure
3758 * @instance: Adapter soft state
3759 * @ctrl_info: Controller information structure
3760 *
3761 * Issues an internal command (DCMD) to get the FW's controller structure.
3762 * This information is mainly used to find out the maximum IO transfer per
3763 * command supported by the FW.
3764 */
3765static int
3766megasas_get_ctrl_info(struct megasas_instance *instance,
3767 struct megasas_ctrl_info *ctrl_info)
3768{
3769 int ret = 0;
3770 struct megasas_cmd *cmd;
3771 struct megasas_dcmd_frame *dcmd;
3772 struct megasas_ctrl_info *ci;
3773 dma_addr_t ci_h = 0;
3774
3775 cmd = megasas_get_cmd(instance);
3776
3777 if (!cmd) {
3778 printk(KERN_DEBUG "megasas: Failed to get a free cmd\n");
3779 return -ENOMEM;
3780 }
3781
3782 dcmd = &cmd->frame->dcmd;
3783
3784 ci = pci_alloc_consistent(instance->pdev,
3785 sizeof(struct megasas_ctrl_info), &ci_h);
3786
3787 if (!ci) {
3788 printk(KERN_DEBUG "Failed to alloc mem for ctrl info\n");
3789 megasas_return_cmd(instance, cmd);
3790 return -ENOMEM;
3791 }
3792
3793 memset(ci, 0, sizeof(*ci));
3794 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3795
3796 dcmd->cmd = MFI_CMD_DCMD;
3797 dcmd->cmd_status = 0xFF;
3798 dcmd->sge_count = 1;
94cd65dd 3799 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
c4a3e0a5 3800 dcmd->timeout = 0;
780a3762 3801 dcmd->pad_0 = 0;
94cd65dd
SS		 3802 dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_ctrl_info));
3803 dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_GET_INFO);
3804 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
3805 dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct megasas_ctrl_info));
c4a3e0a5
BS		 3806
3807 if (!megasas_issue_polled(instance, cmd)) {
3808 ret = 0;
3809 memcpy(ctrl_info, ci, sizeof(struct megasas_ctrl_info));
3810 } else {
3811 ret = -1;
3812 }
3813
3814 pci_free_consistent(instance->pdev, sizeof(struct megasas_ctrl_info),
3815 ci, ci_h);
3816
3817 megasas_return_cmd(instance, cmd);
3818 return ret;
3819}
3820
31ea7088 3821/**
3822 * megasas_issue_init_mfi - Initializes the FW
3823 * @instance: Adapter soft state
3824 *
3825 * Issues the INIT MFI cmd
3826 */
3827static int
3828megasas_issue_init_mfi(struct megasas_instance *instance)
3829{
3830 u32 context;
3831
3832 struct megasas_cmd *cmd;
3833
3834 struct megasas_init_frame *init_frame;
3835 struct megasas_init_queue_info *initq_info;
3836 dma_addr_t init_frame_h;
3837 dma_addr_t initq_info_h;
3838
3839 /*
3840 * Prepare a init frame. Note the init frame points to queue info
3841 * structure. Each frame has SGL allocated after first 64 bytes. For
3842 * this frame - since we don't need any SGL - we use SGL's space as
3843 * queue info structure
3844 *
3845 * We will not get a NULL command below. We just created the pool.
3846 */
3847 cmd = megasas_get_cmd(instance);
3848
3849 init_frame = (struct megasas_init_frame *)cmd->frame;
3850 initq_info = (struct megasas_init_queue_info *)
3851 ((unsigned long)init_frame + 64);
3852
3853 init_frame_h = cmd->frame_phys_addr;
3854 initq_info_h = init_frame_h + 64;
3855
3856 context = init_frame->context;
3857 memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
3858 memset(initq_info, 0, sizeof(struct megasas_init_queue_info));
3859 init_frame->context = context;
3860
94cd65dd
SS		 3861 initq_info->reply_queue_entries = cpu_to_le32(instance->max_fw_cmds + 1);
3862 initq_info->reply_queue_start_phys_addr_lo = cpu_to_le32(instance->reply_queue_h);
31ea7088 3863
94cd65dd
SS		 3864 initq_info->producer_index_phys_addr_lo = cpu_to_le32(instance->producer_h);
3865 initq_info->consumer_index_phys_addr_lo = cpu_to_le32(instance->consumer_h);
31ea7088 3866
3867 init_frame->cmd = MFI_CMD_INIT;
3868 init_frame->cmd_status = 0xFF;
94cd65dd
SS		 3869 init_frame->queue_info_new_phys_addr_lo =
3870 cpu_to_le32(lower_32_bits(initq_info_h));
3871 init_frame->queue_info_new_phys_addr_hi =
3872 cpu_to_le32(upper_32_bits(initq_info_h));
31ea7088 3873
94cd65dd 3874 init_frame->data_xfer_len = cpu_to_le32(sizeof(struct megasas_init_queue_info));
31ea7088 3875
3876 /*
3877 * disable the intr before firing the init frame to FW
3878 */
d46a3ad6 3879 instance->instancet->disable_intr(instance);
31ea7088 3880
3881 /*
3882 * Issue the init frame in polled mode
3883 */
3884
3885 if (megasas_issue_polled(instance, cmd)) {
3886 printk(KERN_ERR "megasas: Failed to init firmware\n");
3887 megasas_return_cmd(instance, cmd);
3888 goto fail_fw_init;
3889 }
3890
3891 megasas_return_cmd(instance, cmd);
3892
3893 return 0;
3894
3895fail_fw_init:
3896 return -EINVAL;
3897}
3898
cd50ba8e 3899static u32
3900megasas_init_adapter_mfi(struct megasas_instance *instance)
c4a3e0a5 3901{
cd50ba8e 3902 struct megasas_register_set __iomem *reg_set;
c4a3e0a5
BS		 3903 u32 context_sz;
3904 u32 reply_q_sz;
c4a3e0a5
BS		 3905
3906 reg_set = instance->reg_set;
3907
c4a3e0a5
BS		 3908 /*
3909 * Get various operational parameters from status register
3910 */
1341c939 3911 instance->max_fw_cmds = instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF;
e3bbff9f
SP		 3912 /*
3913 * Reduce the max supported cmds by 1. This is to ensure that the
3914 * reply_q_sz (1 more than the max cmd that driver may send)
3915 * does not exceed max cmds that the FW can support
3916 */
3917 instance->max_fw_cmds = instance->max_fw_cmds-1;
9c915a8c 3918 instance->max_mfi_cmds = instance->max_fw_cmds;
0d49016b 3919 instance->max_num_sge = (instance->instancet->read_fw_status_reg(reg_set) & 0xFF0000) >>
1341c939 3920 0x10;
c4a3e0a5
BS		 3921 /*
3922 * Create a pool of commands
3923 */
3924 if (megasas_alloc_cmds(instance))
3925 goto fail_alloc_cmds;
3926
3927 /*
3928 * Allocate memory for reply queue. Length of reply queue should
3929 * be _one_ more than the maximum commands handled by the firmware.
3930 *
3931 * Note: When FW completes commands, it places corresponding contex
3932 * values in this circular reply queue. This circular queue is a fairly
3933 * typical producer-consumer queue. FW is the producer (of completed
3934 * commands) and the driver is the consumer.
3935 */
3936 context_sz = sizeof(u32);
3937 reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
3938
3939 instance->reply_queue = pci_alloc_consistent(instance->pdev,
3940 reply_q_sz,
3941 &instance->reply_queue_h);
3942
3943 if (!instance->reply_queue) {
3944 printk(KERN_DEBUG "megasas: Out of DMA mem for reply queue\n");
3945 goto fail_reply_queue;
3946 }
3947
31ea7088 3948 if (megasas_issue_init_mfi(instance))
c4a3e0a5 3949 goto fail_fw_init;
c4a3e0a5 3950
39a98554 3951 instance->fw_support_ieee = 0;
3952 instance->fw_support_ieee =
3953 (instance->instancet->read_fw_status_reg(reg_set) &
3954 0x04000000);
3955
3956 printk(KERN_NOTICE "megasas_init_mfi: fw_support_ieee=%d",
3957 instance->fw_support_ieee);
3958
3959 if (instance->fw_support_ieee)
3960 instance->flag_ieee = 1;
3961
cd50ba8e 3962 return 0;
3963
3964fail_fw_init:
3965
3966 pci_free_consistent(instance->pdev, reply_q_sz,
3967 instance->reply_queue, instance->reply_queue_h);
3968fail_reply_queue:
3969 megasas_free_cmds(instance);
3970
3971fail_alloc_cmds:
cd50ba8e 3972 return 1;
3973}
3974
3975/**
3976 * megasas_init_fw - Initializes the FW
3977 * @instance: Adapter soft state
3978 *
3979 * This is the main function for initializing firmware
3980 */
3981
3982static int megasas_init_fw(struct megasas_instance *instance)
3983{
3984 u32 max_sectors_1;
3985 u32 max_sectors_2;
d46a3ad6 3986 u32 tmp_sectors, msix_enable, scratch_pad_2;
11f8a7b3 3987 resource_size_t base_addr;
cd50ba8e 3988 struct megasas_register_set __iomem *reg_set;
3989 struct megasas_ctrl_info *ctrl_info;
3990 unsigned long bar_list;
d46a3ad6 3991 int i, loop, fw_msix_count = 0;
229fe47c 3992 struct IOV_111 *iovPtr;
cd50ba8e 3993
3994 /* Find first memory bar */
3995 bar_list = pci_select_bars(instance->pdev, IORESOURCE_MEM);
3996 instance->bar = find_first_bit(&bar_list, sizeof(unsigned long));
cd50ba8e 3997 if (pci_request_selected_regions(instance->pdev, instance->bar,
3998 "megasas: LSI")) {
3999 printk(KERN_DEBUG "megasas: IO memory region busy!\n");
4000 return -EBUSY;
4001 }
4002
11f8a7b3
BC		 4003 base_addr = pci_resource_start(instance->pdev, instance->bar);
4004 instance->reg_set = ioremap_nocache(base_addr, 8192);
cd50ba8e 4005
4006 if (!instance->reg_set) {
4007 printk(KERN_DEBUG "megasas: Failed to map IO mem\n");
4008 goto fail_ioremap;
4009 }
4010
4011 reg_set = instance->reg_set;
4012
4013 switch (instance->pdev->device) {
9c915a8c 4014 case PCI_DEVICE_ID_LSI_FUSION:
229fe47c 4015 case PCI_DEVICE_ID_LSI_PLASMA:
36807e67 4016 case PCI_DEVICE_ID_LSI_INVADER:
21d3c710 4017 case PCI_DEVICE_ID_LSI_FURY:
9c915a8c 4018 instance->instancet = &megasas_instance_template_fusion;
4019 break;
cd50ba8e 4020 case PCI_DEVICE_ID_LSI_SAS1078R:
4021 case PCI_DEVICE_ID_LSI_SAS1078DE:
4022 instance->instancet = &megasas_instance_template_ppc;
4023 break;
4024 case PCI_DEVICE_ID_LSI_SAS1078GEN2:
4025 case PCI_DEVICE_ID_LSI_SAS0079GEN2:
4026 instance->instancet = &megasas_instance_template_gen2;
4027 break;
4028 case PCI_DEVICE_ID_LSI_SAS0073SKINNY:
4029 case PCI_DEVICE_ID_LSI_SAS0071SKINNY:
4030 instance->instancet = &megasas_instance_template_skinny;
4031 break;
4032 case PCI_DEVICE_ID_LSI_SAS1064R:
4033 case PCI_DEVICE_ID_DELL_PERC5:
4034 default:
4035 instance->instancet = &megasas_instance_template_xscale;
4036 break;
4037 }
4038
6431f5d7
SS		 4039 if (megasas_transition_to_ready(instance, 0)) {
4040 atomic_set(&instance->fw_reset_no_pci_access, 1);
4041 instance->instancet->adp_reset
4042 (instance, instance->reg_set);
4043 atomic_set(&instance->fw_reset_no_pci_access, 0);
4044 dev_info(&instance->pdev->dev,
4045 "megasas: FW restarted successfully from %s!\n",
4046 __func__);
4047
4048 /*waitting for about 30 second before retry*/
4049 ssleep(30);
4050
4051 if (megasas_transition_to_ready(instance, 0))
4052 goto fail_ready_state;
4053 }
cd50ba8e 4054
d46a3ad6
SS		 4055 /*
4056 * MSI-X host index 0 is common for all adapter.
4057 * It is used for all MPT based Adapters.
4058 */
4059 instance->reply_post_host_index_addr[0] =
4060 (u32 *)((u8 *)instance->reg_set +
4061 MPI2_REPLY_POST_HOST_INDEX_OFFSET);
4062
3f1abce4 4063 /* Check if MSI-X is supported while in ready state */
4064 msix_enable = (instance->instancet->read_fw_status_reg(reg_set) &
4065 0x4000000) >> 0x1a;
c8e858fe 4066 if (msix_enable && !msix_disable) {
d46a3ad6
SS		 4067 scratch_pad_2 = readl
4068 (&instance->reg_set->outbound_scratch_pad_2);
c8e858fe 4069 /* Check max MSI-X vectors */
229fe47c 4070 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
4071 (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA)) {
d46a3ad6
SS		 4072 instance->msix_vectors = (scratch_pad_2
4073 & MR_MAX_REPLY_QUEUES_OFFSET) + 1;
4074 fw_msix_count = instance->msix_vectors;
079eaddf 4075 if (msix_vectors)
4076 instance->msix_vectors =
4077 min(msix_vectors,
4078 instance->msix_vectors);
d46a3ad6
SS		 4079 } else if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER)
4080 || (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) {
4081 /* Invader/Fury supports more than 8 MSI-X */
4082 instance->msix_vectors = ((scratch_pad_2
4083 & MR_MAX_REPLY_QUEUES_EXT_OFFSET)
4084 >> MR_MAX_REPLY_QUEUES_EXT_OFFSET_SHIFT) + 1;
4085 fw_msix_count = instance->msix_vectors;
4086 /* Save 1-15 reply post index address to local memory
4087 * Index 0 is already saved from reg offset
4088 * MPI2_REPLY_POST_HOST_INDEX_OFFSET
4089 */
4090 for (loop = 1; loop < MR_MAX_MSIX_REG_ARRAY; loop++) {
4091 instance->reply_post_host_index_addr[loop] =
4092 (u32 *)((u8 *)instance->reg_set +
4093 MPI2_SUP_REPLY_POST_HOST_INDEX_OFFSET
4094 + (loop * 0x10));
4095 }
4096 if (msix_vectors)
4097 instance->msix_vectors = min(msix_vectors,
4098 instance->msix_vectors);
c8e858fe 4099 } else
4100 instance->msix_vectors = 1;
4101 /* Don't bother allocating more MSI-X vectors than cpus */
4102 instance->msix_vectors = min(instance->msix_vectors,
4103 (unsigned int)num_online_cpus());
4104 for (i = 0; i < instance->msix_vectors; i++)
4105 instance->msixentry[i].entry = i;
8ae80ed1
AG		 4106 i = pci_enable_msix_range(instance->pdev, instance->msixentry,
4107 1, instance->msix_vectors);
4108 if (i)
4109 instance->msix_vectors = i;
4110 else
c8e858fe 4111 instance->msix_vectors = 0;
d46a3ad6
SS		 4112
4113 dev_info(&instance->pdev->dev, "[scsi%d]: FW supports"
4114 "<%d> MSIX vector,Online CPUs: <%d>,"
4115 "Current MSIX <%d>\n", instance->host->host_no,
4116 fw_msix_count, (unsigned int)num_online_cpus(),
4117 instance->msix_vectors);
c8e858fe 4118 }
3f1abce4 4119
cd50ba8e 4120 /* Get operational params, sge flags, send init cmd to controller */
4121 if (instance->instancet->init_adapter(instance))
eb1b1237 4122 goto fail_init_adapter;
cd50ba8e 4123
4124 printk(KERN_ERR "megasas: INIT adapter done\n");
4125
39a98554 4126 /** for passthrough
4127 * the following function will get the PD LIST.
4128 */
4129
81e403ce
YB		 4130 memset(instance->pd_list, 0 ,
4131 (MEGASAS_MAX_PD * sizeof(struct megasas_pd_list)));
58968fc8
HR		 4132 if (megasas_get_pd_list(instance) < 0) {
4133 printk(KERN_ERR "megasas: failed to get PD list\n");
4134 goto fail_init_adapter;
4135 }
81e403ce 4136
bdc6fb8d 4137 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
21c9e160 4138 if (megasas_ld_list_query(instance,
4139 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST))
4140 megasas_get_ld_list(instance);
bdc6fb8d 4141
c4a3e0a5
BS		 4142 ctrl_info = kmalloc(sizeof(struct megasas_ctrl_info), GFP_KERNEL);
4143
4144 /*
4145 * Compute the max allowed sectors per IO: The controller info has two
4146 * limits on max sectors. Driver should use the minimum of these two.
4147 *
4148 * 1 << stripe_sz_ops.min = max sectors per strip
4149 *
4150 * Note that older firmwares ( < FW ver 30) didn't report information
4151 * to calculate max_sectors_1. So the number ended up as zero always.
4152 */
14faea9f 4153 tmp_sectors = 0;
c4a3e0a5
BS		 4154 if (ctrl_info && !megasas_get_ctrl_info(instance, ctrl_info)) {
4155
4156 max_sectors_1 = (1 << ctrl_info->stripe_sz_ops.min) *
94cd65dd
SS		 4157 le16_to_cpu(ctrl_info->max_strips_per_io);
4158 max_sectors_2 = le32_to_cpu(ctrl_info->max_request_size);
c4a3e0a5 4159
14faea9f 4160 tmp_sectors = min_t(u32, max_sectors_1 , max_sectors_2);
404a8a1a
SS		 4161
4162 /*Check whether controller is iMR or MR */
4163 if (ctrl_info->memory_size) {
4164 instance->is_imr = 0;
4165 dev_info(&instance->pdev->dev, "Controller type: MR,"
4166 "Memory size is: %dMB\n",
94cd65dd 4167 le16_to_cpu(ctrl_info->memory_size));
404a8a1a
SS		 4168 } else {
4169 instance->is_imr = 1;
4170 dev_info(&instance->pdev->dev,
4171 "Controller type: iMR\n");
4172 }
94cd65dd
SS		 4173 /* OnOffProperties are converted into CPU arch*/
4174 le32_to_cpus((u32 *)&ctrl_info->properties.OnOffProperties);
39a98554 4175 instance->disableOnlineCtrlReset =
4176 ctrl_info->properties.OnOffProperties.disableOnlineCtrlReset;
94cd65dd
SS		 4177 /* adapterOperations2 are converted into CPU arch*/
4178 le32_to_cpus((u32 *)&ctrl_info->adapterOperations2);
229fe47c 4179 instance->mpio = ctrl_info->adapterOperations2.mpio;
bc93d425
SS		 4180 instance->UnevenSpanSupport =
4181 ctrl_info->adapterOperations2.supportUnevenSpans;
4182 if (instance->UnevenSpanSupport) {
4183 struct fusion_context *fusion = instance->ctrl_context;
4184 dev_info(&instance->pdev->dev, "FW supports: "
4185 "UnevenSpanSupport=%x\n", instance->UnevenSpanSupport);
4186 if (MR_ValidateMapInfo(instance))
4187 fusion->fast_path_io = 1;
4188 else
4189 fusion->fast_path_io = 0;
4190
4191 }
229fe47c 4192 if (ctrl_info->host_interface.SRIOV) {
4193 if (!ctrl_info->adapterOperations2.activePassive)
4194 instance->PlasmaFW111 = 1;
4195
4196 if (!instance->PlasmaFW111)
4197 instance->requestorId =
4198 ctrl_info->iov.requestorId;
4199 else {
4200 iovPtr = (struct IOV_111 *)((unsigned char *)ctrl_info + IOV_111_OFFSET);
4201 instance->requestorId = iovPtr->requestorId;
4202 }
4203 printk(KERN_WARNING "megaraid_sas: I am VF "
4204 "requestorId %d\n", instance->requestorId);
4205 }
14faea9f 4206 }
14faea9f 4207 instance->max_sectors_per_req = instance->max_num_sge *
4208 PAGE_SIZE / 512;
4209 if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
4210 instance->max_sectors_per_req = tmp_sectors;
c4a3e0a5
BS		 4211
4212 kfree(ctrl_info);
4213
c5daa6a9 4214 /* Check for valid throttlequeuedepth module parameter */
404a8a1a 4215 if (instance->is_imr) {
c5daa6a9 4216 if (throttlequeuedepth > (instance->max_fw_cmds -
4217 MEGASAS_SKINNY_INT_CMDS))
4218 instance->throttlequeuedepth =
4219 MEGASAS_THROTTLE_QUEUE_DEPTH;
4220 else
4221 instance->throttlequeuedepth = throttlequeuedepth;
4222 } else {
4223 if (throttlequeuedepth > (instance->max_fw_cmds -
4224 MEGASAS_INT_CMDS))
4225 instance->throttlequeuedepth =
4226 MEGASAS_THROTTLE_QUEUE_DEPTH;
4227 else
4228 instance->throttlequeuedepth = throttlequeuedepth;
4229 }
4230
5d018ad0
SP		 4231 /*
4232 * Setup tasklet for cmd completion
4233 */
4234
f86c5424 4235 tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
ad84db2e 4236 (unsigned long)instance);
4237
229fe47c 4238 /* Launch SR-IOV heartbeat timer */
4239 if (instance->requestorId) {
4240 if (!megasas_sriov_start_heartbeat(instance, 1))
4241 megasas_start_timer(instance,
4242 &instance->sriov_heartbeat_timer,
4243 megasas_sriov_heartbeat_handler,
4244 MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF);
4245 else
4246 instance->skip_heartbeat_timer_del = 1;
4247 }
4248
c4a3e0a5
BS		 4249 return 0;
4250
eb1b1237 4251fail_init_adapter:
cd50ba8e 4252fail_ready_state:
c4a3e0a5
BS		 4253 iounmap(instance->reg_set);
4254
4255 fail_ioremap:
b6d5d880 4256 pci_release_selected_regions(instance->pdev, instance->bar);
c4a3e0a5
BS		 4257
4258 return -EINVAL;
4259}
4260
4261/**
4262 * megasas_release_mfi - Reverses the FW initialization
4263 * @intance: Adapter soft state
4264 */
4265static void megasas_release_mfi(struct megasas_instance *instance)
4266{
9c915a8c 4267 u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1);
c4a3e0a5 4268
9c915a8c 4269 if (instance->reply_queue)
4270 pci_free_consistent(instance->pdev, reply_q_sz,
c4a3e0a5
BS		 4271 instance->reply_queue, instance->reply_queue_h);
4272
4273 megasas_free_cmds(instance);
4274
4275 iounmap(instance->reg_set);
4276
b6d5d880 4277 pci_release_selected_regions(instance->pdev, instance->bar);
c4a3e0a5
BS		 4278}
4279
4280/**
4281 * megasas_get_seq_num - Gets latest event sequence numbers
4282 * @instance: Adapter soft state
4283 * @eli: FW event log sequence numbers information
4284 *
4285 * FW maintains a log of all events in a non-volatile area. Upper layers would
4286 * usually find out the latest sequence number of the events, the seq number at
4287 * the boot etc. They would "read" all the events below the latest seq number
4288 * by issuing a direct fw cmd (DCMD). For the future events (beyond latest seq
4289 * number), they would subsribe to AEN (asynchronous event notification) and
4290 * wait for the events to happen.
4291 */
4292static int
4293megasas_get_seq_num(struct megasas_instance *instance,
4294 struct megasas_evt_log_info *eli)
4295{
4296 struct megasas_cmd *cmd;
4297 struct megasas_dcmd_frame *dcmd;
4298 struct megasas_evt_log_info *el_info;
4299 dma_addr_t el_info_h = 0;
4300
4301 cmd = megasas_get_cmd(instance);
4302
4303 if (!cmd) {
4304 return -ENOMEM;
4305 }
4306
4307 dcmd = &cmd->frame->dcmd;
4308 el_info = pci_alloc_consistent(instance->pdev,
4309 sizeof(struct megasas_evt_log_info),
4310 &el_info_h);
4311
4312 if (!el_info) {
4313 megasas_return_cmd(instance, cmd);
4314 return -ENOMEM;
4315 }
4316
4317 memset(el_info, 0, sizeof(*el_info));
4318 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4319
4320 dcmd->cmd = MFI_CMD_DCMD;
4321 dcmd->cmd_status = 0x0;
4322 dcmd->sge_count = 1;
94cd65dd 4323 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
c4a3e0a5 4324 dcmd->timeout = 0;
780a3762 4325 dcmd->pad_0 = 0;
94cd65dd
SS		 4326 dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_log_info));
4327 dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_GET_INFO);
4328 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(el_info_h);
4329 dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct megasas_evt_log_info));
c4a3e0a5 4330
cfbe7554
SS		 4331 if (megasas_issue_blocked_cmd(instance, cmd, 30))
4332 dev_err(&instance->pdev->dev, "Command timedout"
4333 "from %s\n", __func__);
4334 else {
4335 /*
4336 * Copy the data back into callers buffer
4337 */
4338 eli->newest_seq_num = le32_to_cpu(el_info->newest_seq_num);
4339 eli->oldest_seq_num = le32_to_cpu(el_info->oldest_seq_num);
4340 eli->clear_seq_num = le32_to_cpu(el_info->clear_seq_num);
4341 eli->shutdown_seq_num = le32_to_cpu(el_info->shutdown_seq_num);
4342 eli->boot_seq_num = le32_to_cpu(el_info->boot_seq_num);
4343 }
c4a3e0a5
BS		 4344
4345 pci_free_consistent(instance->pdev, sizeof(struct megasas_evt_log_info),
4346 el_info, el_info_h);
4347
4348 megasas_return_cmd(instance, cmd);
4349
4350 return 0;
4351}
4352
4353/**
4354 * megasas_register_aen - Registers for asynchronous event notification
4355 * @instance: Adapter soft state
4356 * @seq_num: The starting sequence number
4357 * @class_locale: Class of the event
4358 *
4359 * This function subscribes for AEN for events beyond the @seq_num. It requests
4360 * to be notified if and only if the event is of type @class_locale
4361 */
4362static int
4363megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
4364 u32 class_locale_word)
4365{
4366 int ret_val;
4367 struct megasas_cmd *cmd;
4368 struct megasas_dcmd_frame *dcmd;
4369 union megasas_evt_class_locale curr_aen;
4370 union megasas_evt_class_locale prev_aen;
4371
4372 /*
4373 * If there an AEN pending already (aen_cmd), check if the
4374 * class_locale of that pending AEN is inclusive of the new
4375 * AEN request we currently have. If it is, then we don't have
4376 * to do anything. In other words, whichever events the current
4377 * AEN request is subscribing to, have already been subscribed
4378 * to.
4379 *
4380 * If the old_cmd is _not_ inclusive, then we have to abort
4381 * that command, form a class_locale that is superset of both
4382 * old and current and re-issue to the FW
4383 */
4384
4385 curr_aen.word = class_locale_word;
4386
4387 if (instance->aen_cmd) {
4388
4389 prev_aen.word = instance->aen_cmd->frame->dcmd.mbox.w[1];
94cd65dd 4390 prev_aen.members.locale = le16_to_cpu(prev_aen.members.locale);
c4a3e0a5
BS		 4391
4392 /*
4393 * A class whose enum value is smaller is inclusive of all
4394 * higher values. If a PROGRESS (= -1) was previously
4395 * registered, then a new registration requests for higher
4396 * classes need not be sent to FW. They are automatically
4397 * included.
4398 *
4399 * Locale numbers don't have such hierarchy. They are bitmap
4400 * values
4401 */
4402 if ((prev_aen.members.class <= curr_aen.members.class) &&
3993a862 4403 !((prev_aen.members.locale & curr_aen.members.locale) ^
c4a3e0a5
BS		 4404 curr_aen.members.locale)) {
4405 /*
4406 * Previously issued event registration includes
4407 * current request. Nothing to do.
4408 */
4409 return 0;
4410 } else {
3993a862 4411 curr_aen.members.locale |= prev_aen.members.locale;
c4a3e0a5
BS		 4412
4413 if (prev_aen.members.class < curr_aen.members.class)
4414 curr_aen.members.class = prev_aen.members.class;
4415
4416 instance->aen_cmd->abort_aen = 1;
4417 ret_val = megasas_issue_blocked_abort_cmd(instance,
4418 instance->
cfbe7554 4419 aen_cmd, 30);
c4a3e0a5
BS		 4420
4421 if (ret_val) {
4422 printk(KERN_DEBUG "megasas: Failed to abort "
4423 "previous AEN command\n");
4424 return ret_val;
4425 }
4426 }
4427 }
4428
4429 cmd = megasas_get_cmd(instance);
4430
4431 if (!cmd)
4432 return -ENOMEM;
4433
4434 dcmd = &cmd->frame->dcmd;
4435
4436 memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail));
4437
4438 /*
4439 * Prepare DCMD for aen registration
4440 */
4441 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4442
4443 dcmd->cmd = MFI_CMD_DCMD;
4444 dcmd->cmd_status = 0x0;
4445 dcmd->sge_count = 1;
94cd65dd 4446 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
c4a3e0a5 4447 dcmd->timeout = 0;
780a3762 4448 dcmd->pad_0 = 0;
94cd65dd
SS		 4449 dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_detail));
4450 dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_WAIT);
4451 dcmd->mbox.w[0] = cpu_to_le32(seq_num);
39a98554 4452 instance->last_seq_num = seq_num;
94cd65dd
SS		 4453 dcmd->mbox.w[1] = cpu_to_le32(curr_aen.word);
4454 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(instance->evt_detail_h);
4455 dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct megasas_evt_detail));
c4a3e0a5 4456
f4c9a131
YB		 4457 if (instance->aen_cmd != NULL) {
4458 megasas_return_cmd(instance, cmd);
4459 return 0;
4460 }
4461
c4a3e0a5
BS		 4462 /*
4463 * Store reference to the cmd used to register for AEN. When an
4464 * application wants us to register for AEN, we have to abort this
4465 * cmd and re-register with a new EVENT LOCALE supplied by that app
4466 */
4467 instance->aen_cmd = cmd;
4468
4469 /*
4470 * Issue the aen registration frame
4471 */
9c915a8c 4472 instance->instancet->issue_dcmd(instance, cmd);
c4a3e0a5
BS		 4473
4474 return 0;
4475}
4476
4477/**
4478 * megasas_start_aen - Subscribes to AEN during driver load time
4479 * @instance: Adapter soft state
4480 */
4481static int megasas_start_aen(struct megasas_instance *instance)
4482{
4483 struct megasas_evt_log_info eli;
4484 union megasas_evt_class_locale class_locale;
4485
4486 /*
4487 * Get the latest sequence number from FW
4488 */
4489 memset(&eli, 0, sizeof(eli));
4490
4491 if (megasas_get_seq_num(instance, &eli))
4492 return -1;
4493
4494 /*
4495 * Register AEN with FW for latest sequence number plus 1
4496 */
4497 class_locale.members.reserved = 0;
4498 class_locale.members.locale = MR_EVT_LOCALE_ALL;
4499 class_locale.members.class = MR_EVT_CLASS_DEBUG;
4500
94cd65dd 4501 return megasas_register_aen(instance,
3993a862 4502 eli.newest_seq_num + 1,
94cd65dd 4503 class_locale.word);
c4a3e0a5
BS		 4504}
4505
4506/**
4507 * megasas_io_attach - Attaches this driver to SCSI mid-layer
4508 * @instance: Adapter soft state
4509 */
4510static int megasas_io_attach(struct megasas_instance *instance)
4511{
4512 struct Scsi_Host *host = instance->host;
4513
4514 /*
4515 * Export parameters required by SCSI mid-layer
4516 */
4517 host->irq = instance->pdev->irq;
4518 host->unique_id = instance->unique_id;
404a8a1a 4519 if (instance->is_imr) {
7bebf5c7
YB		 4520 host->can_queue =
4521 instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
4522 } else
4523 host->can_queue =
4524 instance->max_fw_cmds - MEGASAS_INT_CMDS;
c4a3e0a5
BS		 4525 host->this_id = instance->init_id;
4526 host->sg_tablesize = instance->max_num_sge;
42a8d2b3 4527
4528 if (instance->fw_support_ieee)
4529 instance->max_sectors_per_req = MEGASAS_MAX_SECTORS_IEEE;
4530
1fd10685
YB		 4531 /*
4532 * Check if the module parameter value for max_sectors can be used
4533 */
4534 if (max_sectors && max_sectors < instance->max_sectors_per_req)
4535 instance->max_sectors_per_req = max_sectors;
4536 else {
4537 if (max_sectors) {
4538 if (((instance->pdev->device ==
4539 PCI_DEVICE_ID_LSI_SAS1078GEN2) ||
4540 (instance->pdev->device ==
4541 PCI_DEVICE_ID_LSI_SAS0079GEN2)) &&
4542 (max_sectors <= MEGASAS_MAX_SECTORS)) {
4543 instance->max_sectors_per_req = max_sectors;
4544 } else {
4545 printk(KERN_INFO "megasas: max_sectors should be > 0"
4546 "and <= %d (or < 1MB for GEN2 controller)\n",
4547 instance->max_sectors_per_req);
4548 }
4549 }
4550 }
4551
c4a3e0a5 4552 host->max_sectors = instance->max_sectors_per_req;
9c915a8c 4553 host->cmd_per_lun = MEGASAS_DEFAULT_CMD_PER_LUN;
c4a3e0a5
BS		 4554 host->max_channel = MEGASAS_MAX_CHANNELS - 1;
4555 host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL;
4556 host->max_lun = MEGASAS_MAX_LUN;
122da302 4557 host->max_cmd_len = 16;
c4a3e0a5 4558
9c915a8c 4559 /* Fusion only supports host reset */
36807e67 4560 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
229fe47c 4561 (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) ||
21d3c710
SS		 4562 (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
4563 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) {
9c915a8c 4564 host->hostt->eh_device_reset_handler = NULL;
4565 host->hostt->eh_bus_reset_handler = NULL;
4566 }
4567
c4a3e0a5
BS		 4568 /*
4569 * Notify the mid-layer about the new controller
4570 */
4571 if (scsi_add_host(host, &instance->pdev->dev)) {
4572 printk(KERN_DEBUG "megasas: scsi_add_host failed\n");
4573 return -ENODEV;
4574 }
4575
4576 /*
4577 * Trigger SCSI to scan our drives
4578 */
4579 scsi_scan_host(host);
4580 return 0;
4581}
4582
31ea7088 4583static int
4584megasas_set_dma_mask(struct pci_dev *pdev)
4585{
4586 /*
4587 * All our contollers are capable of performing 64-bit DMA
4588 */
4589 if (IS_DMA64) {
6a35528a 4590 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) {
31ea7088 4591
284901a9 4592 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
31ea7088 4593 goto fail_set_dma_mask;
4594 }
4595 } else {
284901a9 4596 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
31ea7088 4597 goto fail_set_dma_mask;
4598 }
46de63e2
SS		 4599 /*
4600 * Ensure that all data structures are allocated in 32-bit
4601 * memory.
4602 */
4603 if (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) {
4604 /* Try 32bit DMA mask and 32 bit Consistent dma mask */
4605 if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
4606 && !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
4607 dev_info(&pdev->dev, "set 32bit DMA mask"
4608 "and 32 bit consistent mask\n");
4609 else
4610 goto fail_set_dma_mask;
4611 }
94cd65dd 4612
31ea7088 4613 return 0;
4614
4615fail_set_dma_mask:
4616 return 1;
4617}
4618
c4a3e0a5
BS		 4619/**
4620 * megasas_probe_one - PCI hotplug entry point
4621 * @pdev: PCI device structure
0d49016b 4622 * @id: PCI ids of supported hotplugged adapter
c4a3e0a5 4623 */
6f039790
GKH		 4624static int megasas_probe_one(struct pci_dev *pdev,
4625 const struct pci_device_id *id)
c4a3e0a5 4626{
8058a169 4627 int rval, pos, i, j, cpu;
c4a3e0a5
BS		 4628 struct Scsi_Host *host;
4629 struct megasas_instance *instance;
66192dfe 4630 u16 control = 0;
4631
4632 /* Reset MSI-X in the kdump kernel */
4633 if (reset_devices) {
4634 pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
4635 if (pos) {
99369065 4636 pci_read_config_word(pdev, pos + PCI_MSIX_FLAGS,
66192dfe 4637 &control);
4638 if (control & PCI_MSIX_FLAGS_ENABLE) {
4639 dev_info(&pdev->dev, "resetting MSI-X\n");
4640 pci_write_config_word(pdev,
99369065 4641 pos + PCI_MSIX_FLAGS,
66192dfe 4642 control &
4643 ~PCI_MSIX_FLAGS_ENABLE);
4644 }
4645 }
4646 }
c4a3e0a5
BS		 4647
4648 /*
4649 * Announce PCI information
4650 */
4651 printk(KERN_INFO "megasas: %#4.04x:%#4.04x:%#4.04x:%#4.04x: ",
4652 pdev->vendor, pdev->device, pdev->subsystem_vendor,
4653 pdev->subsystem_device);
4654
4655 printk("bus %d:slot %d:func %d\n",
4656 pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
4657
4658 /*
4659 * PCI prepping: enable device set bus mastering and dma mask
4660 */
aeab3fd7 4661 rval = pci_enable_device_mem(pdev);
c4a3e0a5
BS		 4662
4663 if (rval) {
4664 return rval;
4665 }
4666
4667 pci_set_master(pdev);
4668
31ea7088 4669 if (megasas_set_dma_mask(pdev))
4670 goto fail_set_dma_mask;
c4a3e0a5
BS		 4671
4672 host = scsi_host_alloc(&megasas_template,
4673 sizeof(struct megasas_instance));
4674
4675 if (!host) {
4676 printk(KERN_DEBUG "megasas: scsi_host_alloc failed\n");
4677 goto fail_alloc_instance;
4678 }
4679
4680 instance = (struct megasas_instance *)host->hostdata;
4681 memset(instance, 0, sizeof(*instance));
39a98554 4682 atomic_set( &instance->fw_reset_no_pci_access, 0 );
9c915a8c 4683 instance->pdev = pdev;
c4a3e0a5 4684
9c915a8c 4685 switch (instance->pdev->device) {
4686 case PCI_DEVICE_ID_LSI_FUSION:
229fe47c 4687 case PCI_DEVICE_ID_LSI_PLASMA:
36807e67 4688 case PCI_DEVICE_ID_LSI_INVADER:
21d3c710 4689 case PCI_DEVICE_ID_LSI_FURY:
9c915a8c 4690 {
4691 struct fusion_context *fusion;
4692
4693 instance->ctrl_context =
4694 kzalloc(sizeof(struct fusion_context), GFP_KERNEL);
4695 if (!instance->ctrl_context) {
4696 printk(KERN_DEBUG "megasas: Failed to allocate "
4697 "memory for Fusion context info\n");
4698 goto fail_alloc_dma_buf;
4699 }
4700 fusion = instance->ctrl_context;
4701 INIT_LIST_HEAD(&fusion->cmd_pool);
4702 spin_lock_init(&fusion->cmd_pool_lock);
4703 }
4704 break;
4705 default: /* For all other supported controllers */
4706
4707 instance->producer =
4708 pci_alloc_consistent(pdev, sizeof(u32),
4709 &instance->producer_h);
4710 instance->consumer =
4711 pci_alloc_consistent(pdev, sizeof(u32),
4712 &instance->consumer_h);
4713
4714 if (!instance->producer || !instance->consumer) {
4715 printk(KERN_DEBUG "megasas: Failed to allocate"
4716 "memory for producer, consumer\n");
4717 goto fail_alloc_dma_buf;
4718 }
c4a3e0a5 4719
9c915a8c 4720 *instance->producer = 0;
4721 *instance->consumer = 0;
4722 break;
c4a3e0a5
BS		 4723 }
4724
c3518837 4725 megasas_poll_wait_aen = 0;
f4c9a131 4726 instance->flag_ieee = 0;
7e8a75f4 4727 instance->ev = NULL;
39a98554 4728 instance->issuepend_done = 1;
4729 instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
404a8a1a 4730 instance->is_imr = 0;
39a98554 4731 megasas_poll_wait_aen = 0;
c4a3e0a5
BS		 4732
4733 instance->evt_detail = pci_alloc_consistent(pdev,
4734 sizeof(struct
4735 megasas_evt_detail),
4736 &instance->evt_detail_h);
4737
4738 if (!instance->evt_detail) {
4739 printk(KERN_DEBUG "megasas: Failed to allocate memory for "
4740 "event detail structure\n");
4741 goto fail_alloc_dma_buf;
4742 }
4743
4744 /*
4745 * Initialize locks and queues
4746 */
4747 INIT_LIST_HEAD(&instance->cmd_pool);
39a98554 4748 INIT_LIST_HEAD(&instance->internal_reset_pending_q);
c4a3e0a5 4749
e4a082c7
SP		 4750 atomic_set(&instance->fw_outstanding,0);
4751
c4a3e0a5
BS		 4752 init_waitqueue_head(&instance->int_cmd_wait_q);
4753 init_waitqueue_head(&instance->abort_cmd_wait_q);
4754
4755 spin_lock_init(&instance->cmd_pool_lock);
39a98554 4756 spin_lock_init(&instance->hba_lock);
7343eb65 4757 spin_lock_init(&instance->completion_lock);
c4a3e0a5 4758
e5a69e27 4759 mutex_init(&instance->aen_mutex);
9c915a8c 4760 mutex_init(&instance->reset_mutex);
c4a3e0a5
BS		 4761
4762 /*
4763 * Initialize PCI related and misc parameters
4764 */
c4a3e0a5
BS		 4765 instance->host = host;
4766 instance->unique_id = pdev->bus->number << 8 | pdev->devfn;
4767 instance->init_id = MEGASAS_DEFAULT_INIT_ID;
4768
7bebf5c7
YB		 4769 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4770 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
f4c9a131 4771 instance->flag_ieee = 1;
7bebf5c7
YB		 4772 sema_init(&instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS);
4773 } else
4774 sema_init(&instance->ioctl_sem, MEGASAS_INT_CMDS);
4775
658dcedb 4776 megasas_dbg_lvl = 0;
05e9ebbe 4777 instance->flag = 0;
0c79e681 4778 instance->unload = 1;
05e9ebbe 4779 instance->last_time = 0;
39a98554 4780 instance->disableOnlineCtrlReset = 1;
bc93d425 4781 instance->UnevenSpanSupport = 0;
39a98554 4782
36807e67 4783 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
229fe47c 4784 (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) ||
21d3c710
SS		 4785 (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
4786 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))
9c915a8c 4787 INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq);
4788 else
4789 INIT_WORK(&instance->work_init, process_fw_state_change_wq);
658dcedb 4790
0a77066a 4791 /*
4792 * Initialize MFI Firmware
4793 */
4794 if (megasas_init_fw(instance))
4795 goto fail_init_mfi;
4796
229fe47c 4797 if (instance->requestorId) {
4798 if (instance->PlasmaFW111) {
4799 instance->vf_affiliation_111 =
4800 pci_alloc_consistent(pdev, sizeof(struct MR_LD_VF_AFFILIATION_111),
4801 &instance->vf_affiliation_111_h);
4802 if (!instance->vf_affiliation_111)
4803 printk(KERN_WARNING "megasas: Can't allocate "
4804 "memory for VF affiliation buffer\n");
4805 } else {
4806 instance->vf_affiliation =
4807 pci_alloc_consistent(pdev,
4808 (MAX_LOGICAL_DRIVES + 1) *
4809 sizeof(struct MR_LD_VF_AFFILIATION),
4810 &instance->vf_affiliation_h);
4811 if (!instance->vf_affiliation)
4812 printk(KERN_WARNING "megasas: Can't allocate "
4813 "memory for VF affiliation buffer\n");
4814 }
4815 }
4816
d46a3ad6 4817retry_irq_register:
c4a3e0a5
BS		 4818 /*
4819 * Register IRQ
4820 */
c8e858fe 4821 if (instance->msix_vectors) {
8058a169
SS		 4822 cpu = cpumask_first(cpu_online_mask);
4823 for (i = 0; i < instance->msix_vectors; i++) {
c8e858fe 4824 instance->irq_context[i].instance = instance;
4825 instance->irq_context[i].MSIxIndex = i;
4826 if (request_irq(instance->msixentry[i].vector,
4827 instance->instancet->service_isr, 0,
4828 "megasas",
4829 &instance->irq_context[i])) {
4830 printk(KERN_DEBUG "megasas: Failed to "
4831 "register IRQ for vector %d.\n", i);
8058a169
SS		 4832 for (j = 0; j < i; j++) {
4833 irq_set_affinity_hint(
4834 instance->msixentry[j].vector, NULL);
c8e858fe 4835 free_irq(
4836 instance->msixentry[j].vector,
4837 &instance->irq_context[j]);
8058a169 4838 }
d46a3ad6
SS		 4839 /* Retry irq register for IO_APIC */
4840 instance->msix_vectors = 0;
4841 goto retry_irq_register;
c8e858fe 4842 }
8058a169
SS		 4843 if (irq_set_affinity_hint(instance->msixentry[i].vector,
4844 get_cpu_mask(cpu)))
4845 dev_err(&instance->pdev->dev, "Error setting"
4846 "affinity hint for cpu %d\n", cpu);
4847 cpu = cpumask_next(cpu, cpu_online_mask);
c8e858fe 4848 }
4849 } else {
4850 instance->irq_context[0].instance = instance;
4851 instance->irq_context[0].MSIxIndex = 0;
4852 if (request_irq(pdev->irq, instance->instancet->service_isr,
4853 IRQF_SHARED, "megasas",
4854 &instance->irq_context[0])) {
4855 printk(KERN_DEBUG "megasas: Failed to register IRQ\n");
4856 goto fail_irq;
4857 }
c4a3e0a5
BS		 4858 }
4859
d46a3ad6 4860 instance->instancet->enable_intr(instance);
c4a3e0a5
BS		 4861
4862 /*
4863 * Store instance in PCI softstate
4864 */
4865 pci_set_drvdata(pdev, instance);
4866
4867 /*
4868 * Add this controller to megasas_mgmt_info structure so that it
4869 * can be exported to management applications
4870 */
4871 megasas_mgmt_info.count++;
4872 megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance;
4873 megasas_mgmt_info.max_index++;
4874
541f90b7 4875 /*
4876 * Register with SCSI mid-layer
4877 */
4878 if (megasas_io_attach(instance))
4879 goto fail_io_attach;
4880
4881 instance->unload = 0;
4882
c4a3e0a5
BS		 4883 /*
4884 * Initiate AEN (Asynchronous Event Notification)
4885 */
4886 if (megasas_start_aen(instance)) {
4887 printk(KERN_DEBUG "megasas: start aen failed\n");
4888 goto fail_start_aen;
4889 }
4890
c4a3e0a5
BS		 4891 return 0;
4892
4893 fail_start_aen:
4894 fail_io_attach:
4895 megasas_mgmt_info.count--;
4896 megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL;
4897 megasas_mgmt_info.max_index--;
4898
d46a3ad6 4899 instance->instancet->disable_intr(instance);
c8e858fe 4900 if (instance->msix_vectors)
8058a169
SS		 4901 for (i = 0; i < instance->msix_vectors; i++) {
4902 irq_set_affinity_hint(
4903 instance->msixentry[i].vector, NULL);
c8e858fe 4904 free_irq(instance->msixentry[i].vector,
4905 &instance->irq_context[i]);
8058a169 4906 }
c8e858fe 4907 else
4908 free_irq(instance->pdev->irq, &instance->irq_context[0]);
eb1b1237 4909fail_irq:
36807e67 4910 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
229fe47c 4911 (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) ||
21d3c710
SS		 4912 (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
4913 (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))
eb1b1237 4914 megasas_release_fusion(instance);
4915 else
4916 megasas_release_mfi(instance);
c4a3e0a5 4917 fail_init_mfi:
c8e858fe 4918 if (instance->msix_vectors)
0a77066a 4919 pci_disable_msix(instance->pdev);
c4a3e0a5
BS		 4920 fail_alloc_dma_buf:
4921 if (instance->evt_detail)
4922 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
4923 instance->evt_detail,
4924 instance->evt_detail_h);
4925
eb1b1237 4926 if (instance->producer)
c4a3e0a5
BS		 4927 pci_free_consistent(pdev, sizeof(u32), instance->producer,
4928 instance->producer_h);
4929 if (instance->consumer)
4930 pci_free_consistent(pdev, sizeof(u32), instance->consumer,
4931 instance->consumer_h);
4932 scsi_host_put(host);
4933
4934 fail_alloc_instance:
4935 fail_set_dma_mask:
4936 pci_disable_device(pdev);
4937
4938 return -ENODEV;
4939}
4940
4941/**
4942 * megasas_flush_cache - Requests FW to flush all its caches
4943 * @instance: Adapter soft state
4944 */
4945static void megasas_flush_cache(struct megasas_instance *instance)
4946{
4947 struct megasas_cmd *cmd;
4948 struct megasas_dcmd_frame *dcmd;
4949
39a98554 4950 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
4951 return;
4952
c4a3e0a5
BS		 4953 cmd = megasas_get_cmd(instance);
4954
4955 if (!cmd)
4956 return;
4957
4958 dcmd = &cmd->frame->dcmd;
4959
4960 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4961
4962 dcmd->cmd = MFI_CMD_DCMD;
4963 dcmd->cmd_status = 0x0;
4964 dcmd->sge_count = 0;
94cd65dd 4965 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
c4a3e0a5 4966 dcmd->timeout = 0;
780a3762 4967 dcmd->pad_0 = 0;
c4a3e0a5 4968 dcmd->data_xfer_len = 0;
94cd65dd 4969 dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_CACHE_FLUSH);
c4a3e0a5
BS		 4970 dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
4971
cfbe7554
SS		 4972 if (megasas_issue_blocked_cmd(instance, cmd, 30))
4973 dev_err(&instance->pdev->dev, "Command timedout"
4974 " from %s\n", __func__);
c4a3e0a5
BS		 4975
4976 megasas_return_cmd(instance, cmd);
4977
4978 return;
4979}
4980
4981/**
4982 * megasas_shutdown_controller - Instructs FW to shutdown the controller
4983 * @instance: Adapter soft state
31ea7088 4984 * @opcode: Shutdown/Hibernate
c4a3e0a5 4985 */
31ea7088 4986static void megasas_shutdown_controller(struct megasas_instance *instance,
4987 u32 opcode)
c4a3e0a5
BS		 4988{
4989 struct megasas_cmd *cmd;
4990 struct megasas_dcmd_frame *dcmd;
4991
39a98554 4992 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
4993 return;
4994
c4a3e0a5
BS		 4995 cmd = megasas_get_cmd(instance);
4996
4997 if (!cmd)
4998 return;
4999
5000 if (instance->aen_cmd)
cfbe7554
SS		 5001 megasas_issue_blocked_abort_cmd(instance,
5002 instance->aen_cmd, 30);
9c915a8c 5003 if (instance->map_update_cmd)
5004 megasas_issue_blocked_abort_cmd(instance,
cfbe7554 5005 instance->map_update_cmd, 30);
c4a3e0a5
BS		 5006 dcmd = &cmd->frame->dcmd;
5007
5008 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5009
5010 dcmd->cmd = MFI_CMD_DCMD;
5011 dcmd->cmd_status = 0x0;
5012 dcmd->sge_count = 0;
94cd65dd 5013 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
c4a3e0a5 5014 dcmd->timeout = 0;
780a3762 5015 dcmd->pad_0 = 0;
c4a3e0a5 5016 dcmd->data_xfer_len = 0;
94cd65dd 5017 dcmd->opcode = cpu_to_le32(opcode);
c4a3e0a5 5018
cfbe7554
SS		 5019 if (megasas_issue_blocked_cmd(instance, cmd, 30))
5020 dev_err(&instance->pdev->dev, "Command timedout"
5021 "from %s\n", __func__);
c4a3e0a5
BS		 5022
5023 megasas_return_cmd(instance, cmd);
5024
5025 return;
5026}
5027
33139b21 5028#ifdef CONFIG_PM
31ea7088 5029/**
ad84db2e 5030 * megasas_suspend - driver suspend entry point
5031 * @pdev: PCI device structure
31ea7088 5032 * @state: PCI power state to suspend routine
5033 */
33139b21 5034static int
31ea7088 5035megasas_suspend(struct pci_dev *pdev, pm_message_t state)
5036{
5037 struct Scsi_Host *host;
5038 struct megasas_instance *instance;
c8e858fe 5039 int i;
31ea7088 5040
5041 instance = pci_get_drvdata(pdev);
5042 host = instance->host;
0c79e681 5043 instance->unload = 1;
31ea7088 5044
229fe47c 5045 /* Shutdown SR-IOV heartbeat timer */
5046 if (instance->requestorId && !instance->skip_heartbeat_timer_del)
5047 del_timer_sync(&instance->sriov_heartbeat_timer);
5048
31ea7088 5049 megasas_flush_cache(instance);
5050 megasas_shutdown_controller(instance, MR_DCMD_HIBERNATE_SHUTDOWN);
7e8a75f4
YB		 5051
5052 /* cancel the delayed work if this work still in queue */
5053 if (instance->ev != NULL) {
5054 struct megasas_aen_event *ev = instance->ev;
c1d390d8 5055 cancel_delayed_work_sync(&ev->hotplug_work);
7e8a75f4
YB		 5056 instance->ev = NULL;
5057 }
5058
31ea7088 5059 tasklet_kill(&instance->isr_tasklet);
5060
5061 pci_set_drvdata(instance->pdev, instance);
d46a3ad6 5062 instance->instancet->disable_intr(instance);
c8e858fe 5063
5064 if (instance->msix_vectors)
8058a169
SS		 5065 for (i = 0; i < instance->msix_vectors; i++) {
5066 irq_set_affinity_hint(
5067 instance->msixentry[i].vector, NULL);
c8e858fe 5068 free_irq(instance->msixentry[i].vector,
5069 &instance->irq_context[i]);
8058a169 5070 }
c8e858fe 5071 else
5072 free_irq(instance->pdev->irq, &instance->irq_context[0]);
5073 if (instance->msix_vectors)
80d9da98 5074 pci_disable_msix(instance->pdev);
31ea7088 5075
5076 pci_save_state(pdev);
5077 pci_disable_device(pdev);
5078
5079 pci_set_power_state(pdev, pci_choose_state(pdev, state));
5080
5081 return 0;
5082}
5083
5084/**
5085 * megasas_resume- driver resume entry point
5086 * @pdev: PCI device structure
5087 */
33139b21 5088static int
31ea7088 5089megasas_resume(struct pci_dev *pdev)
5090{
8058a169 5091 int rval, i, j, cpu;
31ea7088 5092 struct Scsi_Host *host;
5093 struct megasas_instance *instance;
5094
5095 instance = pci_get_drvdata(pdev);
5096 host = instance->host;
5097 pci_set_power_state(pdev, PCI_D0);
5098 pci_enable_wake(pdev, PCI_D0, 0);
5099 pci_restore_state(pdev);
5100
5101 /*
5102 * PCI prepping: enable device set bus mastering and dma mask
5103 */
aeab3fd7 5104 rval = pci_enable_device_mem(pdev);
31ea7088 5105
5106 if (rval) {
5107 printk(KERN_ERR "megasas: Enable device failed\n");
5108 return rval;
5109 }
5110
5111 pci_set_master(pdev);
5112
5113 if (megasas_set_dma_mask(pdev))
5114 goto fail_set_dma_mask;
5115
5116 /*
5117 * Initialize MFI Firmware
5118 */
5119
31ea7088 5120 atomic_set(&instance->fw_outstanding, 0);
5121
5122 /*
5123 * We expect the FW state to be READY
5124 */
058a8fac 5125 if (megasas_transition_to_ready(instance, 0))
31ea7088 5126 goto fail_ready_state;
5127
3f1abce4 5128 /* Now re-enable MSI-X */
dd088128 5129 if (instance->msix_vectors &&
8ae80ed1
AG		 5130 pci_enable_msix_exact(instance->pdev, instance->msixentry,
5131 instance->msix_vectors))
dd088128 5132 goto fail_reenable_msix;
3f1abce4 5133
9c915a8c 5134 switch (instance->pdev->device) {
5135 case PCI_DEVICE_ID_LSI_FUSION:
229fe47c 5136 case PCI_DEVICE_ID_LSI_PLASMA:
36807e67 5137 case PCI_DEVICE_ID_LSI_INVADER:
21d3c710 5138 case PCI_DEVICE_ID_LSI_FURY:
9c915a8c 5139 {
5140 megasas_reset_reply_desc(instance);
5141 if (megasas_ioc_init_fusion(instance)) {
5142 megasas_free_cmds(instance);
5143 megasas_free_cmds_fusion(instance);
5144 goto fail_init_mfi;
5145 }
5146 if (!megasas_get_map_info(instance))
5147 megasas_sync_map_info(instance);
5148 }
5149 break;
5150 default:
5151 *instance->producer = 0;
5152 *instance->consumer = 0;
5153 if (megasas_issue_init_mfi(instance))
5154 goto fail_init_mfi;
5155 break;
5156 }
31ea7088 5157
9c915a8c 5158 tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
5159 (unsigned long)instance);
31ea7088 5160
5161 /*
5162 * Register IRQ
5163 */
c8e858fe 5164 if (instance->msix_vectors) {
8058a169 5165 cpu = cpumask_first(cpu_online_mask);
c8e858fe 5166 for (i = 0 ; i < instance->msix_vectors; i++) {
5167 instance->irq_context[i].instance = instance;
5168 instance->irq_context[i].MSIxIndex = i;
5169 if (request_irq(instance->msixentry[i].vector,
5170 instance->instancet->service_isr, 0,
5171 "megasas",
5172 &instance->irq_context[i])) {
5173 printk(KERN_DEBUG "megasas: Failed to "
5174 "register IRQ for vector %d.\n", i);
8058a169
SS		 5175 for (j = 0; j < i; j++) {
5176 irq_set_affinity_hint(
5177 instance->msixentry[j].vector, NULL);
c8e858fe 5178 free_irq(
5179 instance->msixentry[j].vector,
5180 &instance->irq_context[j]);
8058a169 5181 }
c8e858fe 5182 goto fail_irq;
5183 }
8058a169
SS		 5184
5185 if (irq_set_affinity_hint(instance->msixentry[i].vector,
5186 get_cpu_mask(cpu)))
5187 dev_err(&instance->pdev->dev, "Error setting"
5188 "affinity hint for cpu %d\n", cpu);
5189 cpu = cpumask_next(cpu, cpu_online_mask);
c8e858fe 5190 }
5191 } else {
5192 instance->irq_context[0].instance = instance;
5193 instance->irq_context[0].MSIxIndex = 0;
5194 if (request_irq(pdev->irq, instance->instancet->service_isr,
5195 IRQF_SHARED, "megasas",
5196 &instance->irq_context[0])) {
5197 printk(KERN_DEBUG "megasas: Failed to register IRQ\n");
5198 goto fail_irq;
5199 }
31ea7088 5200 }
5201
229fe47c 5202 /* Re-launch SR-IOV heartbeat timer */
5203 if (instance->requestorId) {
5204 if (!megasas_sriov_start_heartbeat(instance, 0))
5205 megasas_start_timer(instance,
5206 &instance->sriov_heartbeat_timer,
5207 megasas_sriov_heartbeat_handler,
5208 MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF);
5209 else
5210 instance->skip_heartbeat_timer_del = 1;
5211 }
5212
d46a3ad6 5213 instance->instancet->enable_intr(instance);
0c79e681
YB		 5214 instance->unload = 0;
5215
541f90b7 5216 /*
5217 * Initiate AEN (Asynchronous Event Notification)
5218 */
5219 if (megasas_start_aen(instance))
5220 printk(KERN_ERR "megasas: Start AEN failed\n");
5221
31ea7088 5222 return 0;
5223
5224fail_irq:
5225fail_init_mfi:
5226 if (instance->evt_detail)
5227 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
5228 instance->evt_detail,
5229 instance->evt_detail_h);
5230
5231 if (instance->producer)
5232 pci_free_consistent(pdev, sizeof(u32), instance->producer,
5233 instance->producer_h);
5234 if (instance->consumer)
5235 pci_free_consistent(pdev, sizeof(u32), instance->consumer,
5236 instance->consumer_h);
5237 scsi_host_put(host);
5238
5239fail_set_dma_mask:
5240fail_ready_state:
dd088128 5241fail_reenable_msix:
31ea7088 5242
5243 pci_disable_device(pdev);
5244
5245 return -ENODEV;
5246}
33139b21
JS		 5247#else
5248#define megasas_suspend NULL
5249#define megasas_resume NULL
5250#endif
31ea7088 5251
c4a3e0a5
BS		 5252/**
5253 * megasas_detach_one - PCI hot"un"plug entry point
5254 * @pdev: PCI device structure
5255 */
6f039790 5256static void megasas_detach_one(struct pci_dev *pdev)
c4a3e0a5
BS		 5257{
5258 int i;
5259 struct Scsi_Host *host;
5260 struct megasas_instance *instance;
9c915a8c 5261 struct fusion_context *fusion;
c4a3e0a5
BS		 5262
5263 instance = pci_get_drvdata(pdev);
c3518837 5264 instance->unload = 1;
c4a3e0a5 5265 host = instance->host;
9c915a8c 5266 fusion = instance->ctrl_context;
c4a3e0a5 5267
229fe47c 5268 /* Shutdown SR-IOV heartbeat timer */
5269 if (instance->requestorId && !instance->skip_heartbeat_timer_del)
5270 del_timer_sync(&instance->sriov_heartbeat_timer);
5271
c4a3e0a5
BS		 5272 scsi_remove_host(instance->host);
5273 megasas_flush_cache(instance);
31ea7088 5274 megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
7e8a75f4
YB		 5275
5276 /* cancel the delayed work if this work still in queue*/
5277 if (instance->ev != NULL) {
5278 struct megasas_aen_event *ev = instance->ev;
c1d390d8 5279 cancel_delayed_work_sync(&ev->hotplug_work);
7e8a75f4
YB		 5280 instance->ev = NULL;
5281 }
5282
cfbe7554
SS		 5283 /* cancel all wait events */
5284 wake_up_all(&instance->int_cmd_wait_q);
5285
5d018ad0 5286 tasklet_kill(&instance->isr_tasklet);
c4a3e0a5
BS		 5287
5288 /*
5289 * Take the instance off the instance array. Note that we will not
5290 * decrement the max_index. We let this array be sparse array
5291 */
5292 for (i = 0; i < megasas_mgmt_info.max_index; i++) {
5293 if (megasas_mgmt_info.instance[i] == instance) {
5294 megasas_mgmt_info.count--;
5295 megasas_mgmt_info.instance[i] = NULL;
5296
5297 break;
5298 }
5299 }
5300
d46a3ad6 5301 instance->instancet->disable_intr(instance);
c4a3e0a5 5302
c8e858fe 5303 if (instance->msix_vectors)
8058a169
SS		 5304 for (i = 0; i < instance->msix_vectors; i++) {
5305 irq_set_affinity_hint(
5306 instance->msixentry[i].vector, NULL);
c8e858fe 5307 free_irq(instance->msixentry[i].vector,
5308 &instance->irq_context[i]);
8058a169 5309 }
c8e858fe 5310 else
5311 free_irq(instance->pdev->irq, &instance->irq_context[0]);
5312 if (instance->msix_vectors)
80d9da98 5313 pci_disable_msix(instance->pdev);
c4a3e0a5 5314
9c915a8c 5315 switch (instance->pdev->device) {
5316 case PCI_DEVICE_ID_LSI_FUSION:
229fe47c 5317 case PCI_DEVICE_ID_LSI_PLASMA:
36807e67 5318 case PCI_DEVICE_ID_LSI_INVADER:
21d3c710 5319 case PCI_DEVICE_ID_LSI_FURY:
9c915a8c 5320 megasas_release_fusion(instance);
5321 for (i = 0; i < 2 ; i++)
5322 if (fusion->ld_map[i])
5323 dma_free_coherent(&instance->pdev->dev,
5324 fusion->map_sz,
5325 fusion->ld_map[i],
5326 fusion->
5327 ld_map_phys[i]);
5328 kfree(instance->ctrl_context);
5329 break;
5330 default:
5331 megasas_release_mfi(instance);
9c915a8c 5332 pci_free_consistent(pdev, sizeof(u32),
5333 instance->producer,
5334 instance->producer_h);
5335 pci_free_consistent(pdev, sizeof(u32),
5336 instance->consumer,
5337 instance->consumer_h);
5338 break;
5339 }
c4a3e0a5 5340
105900d5
SS		 5341 if (instance->evt_detail)
5342 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
5343 instance->evt_detail, instance->evt_detail_h);
229fe47c 5344
5345 if (instance->vf_affiliation)
5346 pci_free_consistent(pdev, (MAX_LOGICAL_DRIVES + 1) *
5347 sizeof(struct MR_LD_VF_AFFILIATION),
5348 instance->vf_affiliation,
5349 instance->vf_affiliation_h);
5350
5351 if (instance->vf_affiliation_111)
5352 pci_free_consistent(pdev,
5353 sizeof(struct MR_LD_VF_AFFILIATION_111),
5354 instance->vf_affiliation_111,
5355 instance->vf_affiliation_111_h);
5356
5357 if (instance->hb_host_mem)
5358 pci_free_consistent(pdev, sizeof(struct MR_CTRL_HB_HOST_MEM),
5359 instance->hb_host_mem,
5360 instance->hb_host_mem_h);
5361
c4a3e0a5
BS		 5362 scsi_host_put(host);
5363
c4a3e0a5
BS		 5364 pci_disable_device(pdev);
5365
5366 return;
5367}
5368
5369/**
5370 * megasas_shutdown - Shutdown entry point
5371 * @device: Generic device structure
5372 */
5373static void megasas_shutdown(struct pci_dev *pdev)
5374{
c8e858fe 5375 int i;
c4a3e0a5 5376 struct megasas_instance *instance = pci_get_drvdata(pdev);
c8e858fe 5377
0c79e681 5378 instance->unload = 1;
c4a3e0a5 5379 megasas_flush_cache(instance);
530e6fc1 5380 megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
d46a3ad6 5381 instance->instancet->disable_intr(instance);
c8e858fe 5382 if (instance->msix_vectors)
8058a169
SS		 5383 for (i = 0; i < instance->msix_vectors; i++) {
5384 irq_set_affinity_hint(
5385 instance->msixentry[i].vector, NULL);
c8e858fe 5386 free_irq(instance->msixentry[i].vector,
5387 &instance->irq_context[i]);
8058a169 5388 }
c8e858fe 5389 else
5390 free_irq(instance->pdev->irq, &instance->irq_context[0]);
5391 if (instance->msix_vectors)
46fd256e 5392 pci_disable_msix(instance->pdev);
c4a3e0a5
BS		 5393}
5394
5395/**
5396 * megasas_mgmt_open - char node "open" entry point
5397 */
5398static int megasas_mgmt_open(struct inode *inode, struct file *filep)
5399{
5400 /*
5401 * Allow only those users with admin rights
5402 */
5403 if (!capable(CAP_SYS_ADMIN))
5404 return -EACCES;
5405
5406 return 0;
5407}
5408
c4a3e0a5
BS		 5409/**
5410 * megasas_mgmt_fasync - Async notifier registration from applications
5411 *
5412 * This function adds the calling process to a driver global queue. When an
5413 * event occurs, SIGIO will be sent to all processes in this queue.
5414 */
5415static int megasas_mgmt_fasync(int fd, struct file *filep, int mode)
5416{
5417 int rc;
5418
0b950672 5419 mutex_lock(&megasas_async_queue_mutex);
c4a3e0a5
BS		 5420
5421 rc = fasync_helper(fd, filep, mode, &megasas_async_queue);
5422
0b950672 5423 mutex_unlock(&megasas_async_queue_mutex);
c4a3e0a5
BS		 5424
5425 if (rc >= 0) {
5426 /* For sanity check when we get ioctl */
5427 filep->private_data = filep;
5428 return 0;
5429 }
5430
5431 printk(KERN_DEBUG "megasas: fasync_helper failed [%d]\n", rc);
5432
5433 return rc;
5434}
5435
c3518837
YB		 5436/**
5437 * megasas_mgmt_poll - char node "poll" entry point
5438 * */
5439static unsigned int megasas_mgmt_poll(struct file *file, poll_table *wait)
5440{
5441 unsigned int mask;
5442 unsigned long flags;
5443 poll_wait(file, &megasas_poll_wait, wait);
5444 spin_lock_irqsave(&poll_aen_lock, flags);
5445 if (megasas_poll_wait_aen)
5446 mask = (POLLIN | POLLRDNORM);
5447 else
5448 mask = 0;
5449 spin_unlock_irqrestore(&poll_aen_lock, flags);
5450 return mask;
5451}
5452
c4a3e0a5
BS		 5453/**
5454 * megasas_mgmt_fw_ioctl - Issues management ioctls to FW
5455 * @instance: Adapter soft state
5456 * @argp: User's ioctl packet
5457 */
5458static int
5459megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
5460 struct megasas_iocpacket __user * user_ioc,
5461 struct megasas_iocpacket *ioc)
5462{
5463 struct megasas_sge32 *kern_sge32;
5464 struct megasas_cmd *cmd;
5465 void *kbuff_arr[MAX_IOCTL_SGE];
5466 dma_addr_t buf_handle = 0;
5467 int error = 0, i;
5468 void *sense = NULL;
5469 dma_addr_t sense_handle;
7b2519af 5470 unsigned long *sense_ptr;
c4a3e0a5
BS		 5471
5472 memset(kbuff_arr, 0, sizeof(kbuff_arr));
5473
5474 if (ioc->sge_count > MAX_IOCTL_SGE) {
5475 printk(KERN_DEBUG "megasas: SGE count [%d] > max limit [%d]\n",
5476 ioc->sge_count, MAX_IOCTL_SGE);
5477 return -EINVAL;
5478 }
5479
5480 cmd = megasas_get_cmd(instance);
5481 if (!cmd) {
5482 printk(KERN_DEBUG "megasas: Failed to get a cmd packet\n");
5483 return -ENOMEM;
5484 }
5485
5486 /*
5487 * User's IOCTL packet has 2 frames (maximum). Copy those two
5488 * frames into our cmd's frames. cmd->frame's context will get
5489 * overwritten when we copy from user's frames. So set that value
5490 * alone separately
5491 */
5492 memcpy(cmd->frame, ioc->frame.raw, 2 * MEGAMFI_FRAME_SIZE);
94cd65dd 5493 cmd->frame->hdr.context = cpu_to_le32(cmd->index);
c3518837 5494 cmd->frame->hdr.pad_0 = 0;
94cd65dd
SS		 5495 cmd->frame->hdr.flags &= cpu_to_le16(~(MFI_FRAME_IEEE |
5496 MFI_FRAME_SGL64 |
5497 MFI_FRAME_SENSE64));
c4a3e0a5
BS		 5498
5499 /*
5500 * The management interface between applications and the fw uses
5501 * MFI frames. E.g, RAID configuration changes, LD property changes
5502 * etc are accomplishes through different kinds of MFI frames. The
5503 * driver needs to care only about substituting user buffers with
5504 * kernel buffers in SGLs. The location of SGL is embedded in the
5505 * struct iocpacket itself.
5506 */
5507 kern_sge32 = (struct megasas_sge32 *)
5508 ((unsigned long)cmd->frame + ioc->sgl_off);
5509
5510 /*
5511 * For each user buffer, create a mirror buffer and copy in
5512 */
5513 for (i = 0; i < ioc->sge_count; i++) {
98cb7e44
BM		 5514 if (!ioc->sgl[i].iov_len)
5515 continue;
5516
9f35fa8a 5517 kbuff_arr[i] = dma_alloc_coherent(&instance->pdev->dev,
c4a3e0a5 5518 ioc->sgl[i].iov_len,
9f35fa8a 5519 &buf_handle, GFP_KERNEL);
c4a3e0a5
BS		 5520 if (!kbuff_arr[i]) {
5521 printk(KERN_DEBUG "megasas: Failed to alloc "
5522 "kernel SGL buffer for IOCTL \n");
5523 error = -ENOMEM;
5524 goto out;
5525 }
5526
5527 /*
5528 * We don't change the dma_coherent_mask, so
5529 * pci_alloc_consistent only returns 32bit addresses
5530 */
94cd65dd
SS		 5531 kern_sge32[i].phys_addr = cpu_to_le32(buf_handle);
5532 kern_sge32[i].length = cpu_to_le32(ioc->sgl[i].iov_len);
c4a3e0a5
BS		 5533
5534 /*
5535 * We created a kernel buffer corresponding to the
5536 * user buffer. Now copy in from the user buffer
5537 */
5538 if (copy_from_user(kbuff_arr[i], ioc->sgl[i].iov_base,
5539 (u32) (ioc->sgl[i].iov_len))) {
5540 error = -EFAULT;
5541 goto out;
5542 }
5543 }
5544
5545 if (ioc->sense_len) {
9f35fa8a
SP		 5546 sense = dma_alloc_coherent(&instance->pdev->dev, ioc->sense_len,
5547 &sense_handle, GFP_KERNEL);
c4a3e0a5
BS		 5548 if (!sense) {
5549 error = -ENOMEM;
5550 goto out;
5551 }
5552
5553 sense_ptr =
7b2519af 5554 (unsigned long *) ((unsigned long)cmd->frame + ioc->sense_off);
94cd65dd 5555 *sense_ptr = cpu_to_le32(sense_handle);
c4a3e0a5
BS		 5556 }
5557
5558 /*
5559 * Set the sync_cmd flag so that the ISR knows not to complete this
5560 * cmd to the SCSI mid-layer
5561 */
5562 cmd->sync_cmd = 1;
cfbe7554 5563 megasas_issue_blocked_cmd(instance, cmd, 0);
c4a3e0a5
BS		 5564 cmd->sync_cmd = 0;
5565
5566 /*
5567 * copy out the kernel buffers to user buffers
5568 */
5569 for (i = 0; i < ioc->sge_count; i++) {
5570 if (copy_to_user(ioc->sgl[i].iov_base, kbuff_arr[i],
5571 ioc->sgl[i].iov_len)) {
5572 error = -EFAULT;
5573 goto out;
5574 }
5575 }
5576
5577 /*
5578 * copy out the sense
5579 */
5580 if (ioc->sense_len) {
5581 /*
b70a41e0 5582 * sense_ptr points to the location that has the user
c4a3e0a5
BS		 5583 * sense buffer address
5584 */
7b2519af
YB		 5585 sense_ptr = (unsigned long *) ((unsigned long)ioc->frame.raw +
5586 ioc->sense_off);
c4a3e0a5 5587
b70a41e0 5588 if (copy_to_user((void __user *)((unsigned long)(*sense_ptr)),
5589 sense, ioc->sense_len)) {
b10c36a5 5590 printk(KERN_ERR "megasas: Failed to copy out to user "
5591 "sense data\n");
c4a3e0a5
BS		 5592 error = -EFAULT;
5593 goto out;
5594 }
5595 }
5596
5597 /*
5598 * copy the status codes returned by the fw
5599 */
5600 if (copy_to_user(&user_ioc->frame.hdr.cmd_status,
5601 &cmd->frame->hdr.cmd_status, sizeof(u8))) {
5602 printk(KERN_DEBUG "megasas: Error copying out cmd_status\n");
5603 error = -EFAULT;
5604 }
5605
5606 out:
5607 if (sense) {
9f35fa8a 5608 dma_free_coherent(&instance->pdev->dev, ioc->sense_len,
c4a3e0a5
BS		 5609 sense, sense_handle);
5610 }
5611
7a6a731b
BM		 5612 for (i = 0; i < ioc->sge_count; i++) {
5613 if (kbuff_arr[i])
5614 dma_free_coherent(&instance->pdev->dev,
94cd65dd 5615 le32_to_cpu(kern_sge32[i].length),
7a6a731b 5616 kbuff_arr[i],
94cd65dd 5617 le32_to_cpu(kern_sge32[i].phys_addr));
c4a3e0a5
BS		 5618 }
5619
5620 megasas_return_cmd(instance, cmd);
5621 return error;
5622}
5623
c4a3e0a5
BS		 5624static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
5625{
5626 struct megasas_iocpacket __user *user_ioc =
5627 (struct megasas_iocpacket __user *)arg;
5628 struct megasas_iocpacket *ioc;
5629 struct megasas_instance *instance;
5630 int error;
39a98554 5631 int i;
5632 unsigned long flags;
5633 u32 wait_time = MEGASAS_RESET_WAIT_TIME;
c4a3e0a5
BS		 5634
5635 ioc = kmalloc(sizeof(*ioc), GFP_KERNEL);
5636 if (!ioc)
5637 return -ENOMEM;
5638
5639 if (copy_from_user(ioc, user_ioc, sizeof(*ioc))) {
5640 error = -EFAULT;
5641 goto out_kfree_ioc;
5642 }
5643
5644 instance = megasas_lookup_instance(ioc->host_no);
5645 if (!instance) {
5646 error = -ENODEV;
5647 goto out_kfree_ioc;
5648 }
5649
229fe47c 5650 /* Adjust ioctl wait time for VF mode */
5651 if (instance->requestorId)
5652 wait_time = MEGASAS_ROUTINE_WAIT_TIME_VF;
5653
5654 /* Block ioctls in VF mode */
5655 if (instance->requestorId && !allow_vf_ioctls) {
5656 error = -ENODEV;
5657 goto out_kfree_ioc;
5658 }
5659
39a98554 5660 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
5661 printk(KERN_ERR "Controller in crit error\n");
0c79e681
YB		 5662 error = -ENODEV;
5663 goto out_kfree_ioc;
5664 }
5665
5666 if (instance->unload == 1) {
5667 error = -ENODEV;
5668 goto out_kfree_ioc;
5669 }
5670
c4a3e0a5
BS		 5671 /*
5672 * We will allow only MEGASAS_INT_CMDS number of parallel ioctl cmds
5673 */
5674 if (down_interruptible(&instance->ioctl_sem)) {
5675 error = -ERESTARTSYS;
5676 goto out_kfree_ioc;
5677 }
39a98554 5678
5679 for (i = 0; i < wait_time; i++) {
5680
5681 spin_lock_irqsave(&instance->hba_lock, flags);
5682 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) {
5683 spin_unlock_irqrestore(&instance->hba_lock, flags);
5684 break;
5685 }
5686 spin_unlock_irqrestore(&instance->hba_lock, flags);
5687
5688 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
5689 printk(KERN_NOTICE "megasas: waiting"
5690 "for controller reset to finish\n");
5691 }
5692
5693 msleep(1000);
5694 }
5695
5696 spin_lock_irqsave(&instance->hba_lock, flags);
5697 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
5698 spin_unlock_irqrestore(&instance->hba_lock, flags);
5699
5700 printk(KERN_ERR "megaraid_sas: timed out while"
5701 "waiting for HBA to recover\n");
5702 error = -ENODEV;
c64e483e 5703 goto out_up;
39a98554 5704 }
5705 spin_unlock_irqrestore(&instance->hba_lock, flags);
5706
c4a3e0a5 5707 error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc);
c64e483e 5708 out_up:
c4a3e0a5
BS		 5709 up(&instance->ioctl_sem);
5710
5711 out_kfree_ioc:
5712 kfree(ioc);
5713 return error;
5714}
5715
5716static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
5717{
5718 struct megasas_instance *instance;
5719 struct megasas_aen aen;
5720 int error;
39a98554 5721 int i;
5722 unsigned long flags;
5723 u32 wait_time = MEGASAS_RESET_WAIT_TIME;
c4a3e0a5
BS		 5724
5725 if (file->private_data != file) {
5726 printk(KERN_DEBUG "megasas: fasync_helper was not "
5727 "called first\n");
5728 return -EINVAL;
5729 }
5730
5731 if (copy_from_user(&aen, (void __user *)arg, sizeof(aen)))
5732 return -EFAULT;
5733
5734 instance = megasas_lookup_instance(aen.host_no);
5735
5736 if (!instance)
5737 return -ENODEV;
5738
39a98554 5739 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
5740 return -ENODEV;
0c79e681
YB		 5741 }
5742
5743 if (instance->unload == 1) {
5744 return -ENODEV;
5745 }
5746
39a98554 5747 for (i = 0; i < wait_time; i++) {
5748
5749 spin_lock_irqsave(&instance->hba_lock, flags);
5750 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) {
5751 spin_unlock_irqrestore(&instance->hba_lock,
5752 flags);
5753 break;
5754 }
5755
5756 spin_unlock_irqrestore(&instance->hba_lock, flags);
5757
5758 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
5759 printk(KERN_NOTICE "megasas: waiting for"
5760 "controller reset to finish\n");
5761 }
5762
5763 msleep(1000);
5764 }
5765
5766 spin_lock_irqsave(&instance->hba_lock, flags);
5767 if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
5768 spin_unlock_irqrestore(&instance->hba_lock, flags);
5769 printk(KERN_ERR "megaraid_sas: timed out while waiting"
5770 "for HBA to recover.\n");
5771 return -ENODEV;
5772 }
5773 spin_unlock_irqrestore(&instance->hba_lock, flags);
5774
e5a69e27 5775 mutex_lock(&instance->aen_mutex);
c4a3e0a5
BS		 5776 error = megasas_register_aen(instance, aen.seq_num,
5777 aen.class_locale_word);
e5a69e27 5778 mutex_unlock(&instance->aen_mutex);
c4a3e0a5
BS		 5779 return error;
5780}
5781
5782/**
5783 * megasas_mgmt_ioctl - char node ioctl entry point
5784 */
5785static long
5786megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
5787{
5788 switch (cmd) {
5789 case MEGASAS_IOC_FIRMWARE:
5790 return megasas_mgmt_ioctl_fw(file, arg);
5791
5792 case MEGASAS_IOC_GET_AEN:
5793 return megasas_mgmt_ioctl_aen(file, arg);
5794 }
5795
5796 return -ENOTTY;
5797}
5798
5799#ifdef CONFIG_COMPAT
5800static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
5801{
5802 struct compat_megasas_iocpacket __user *cioc =
5803 (struct compat_megasas_iocpacket __user *)arg;
5804 struct megasas_iocpacket __user *ioc =
5805 compat_alloc_user_space(sizeof(struct megasas_iocpacket));
5806 int i;
5807 int error = 0;
b3dc1a21 5808 compat_uptr_t ptr;
c4a3e0a5 5809
83aabc1b
JG		 5810 if (clear_user(ioc, sizeof(*ioc)))
5811 return -EFAULT;
c4a3e0a5
BS		 5812
5813 if (copy_in_user(&ioc->host_no, &cioc->host_no, sizeof(u16)) ||
5814 copy_in_user(&ioc->sgl_off, &cioc->sgl_off, sizeof(u32)) ||
5815 copy_in_user(&ioc->sense_off, &cioc->sense_off, sizeof(u32)) ||
5816 copy_in_user(&ioc->sense_len, &cioc->sense_len, sizeof(u32)) ||
5817 copy_in_user(ioc->frame.raw, cioc->frame.raw, 128) ||
5818 copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32)))
5819 return -EFAULT;
5820
b3dc1a21
TH		 5821 /*
5822 * The sense_ptr is used in megasas_mgmt_fw_ioctl only when
5823 * sense_len is not null, so prepare the 64bit value under
5824 * the same condition.
5825 */
5826 if (ioc->sense_len) {
5827 void __user **sense_ioc_ptr =
5828 (void __user **)(ioc->frame.raw + ioc->sense_off);
5829 compat_uptr_t *sense_cioc_ptr =
5830 (compat_uptr_t *)(cioc->frame.raw + cioc->sense_off);
5831 if (get_user(ptr, sense_cioc_ptr) ||
5832 put_user(compat_ptr(ptr), sense_ioc_ptr))
5833 return -EFAULT;
5834 }
c4a3e0a5 5835
b3dc1a21 5836 for (i = 0; i < MAX_IOCTL_SGE; i++) {
c4a3e0a5
BS		 5837 if (get_user(ptr, &cioc->sgl[i].iov_base) ||
5838 put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) ||
5839 copy_in_user(&ioc->sgl[i].iov_len,
5840 &cioc->sgl[i].iov_len, sizeof(compat_size_t)))
5841 return -EFAULT;
5842 }
5843
5844 error = megasas_mgmt_ioctl_fw(file, (unsigned long)ioc);
5845
5846 if (copy_in_user(&cioc->frame.hdr.cmd_status,
5847 &ioc->frame.hdr.cmd_status, sizeof(u8))) {
5848 printk(KERN_DEBUG "megasas: error copy_in_user cmd_status\n");
5849 return -EFAULT;
5850 }
5851 return error;
5852}
5853
5854static long
5855megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd,
5856 unsigned long arg)
5857{
5858 switch (cmd) {
cb59aa6a
SP		 5859 case MEGASAS_IOC_FIRMWARE32:
5860 return megasas_mgmt_compat_ioctl_fw(file, arg);
c4a3e0a5
BS		 5861 case MEGASAS_IOC_GET_AEN:
5862 return megasas_mgmt_ioctl_aen(file, arg);
5863 }
5864
5865 return -ENOTTY;
5866}
5867#endif
5868
5869/*
5870 * File operations structure for management interface
5871 */
00977a59 5872static const struct file_operations megasas_mgmt_fops = {
c4a3e0a5
BS		 5873 .owner = THIS_MODULE,
5874 .open = megasas_mgmt_open,
c4a3e0a5
BS		 5875 .fasync = megasas_mgmt_fasync,
5876 .unlocked_ioctl = megasas_mgmt_ioctl,
c3518837 5877 .poll = megasas_mgmt_poll,
c4a3e0a5
BS		 5878#ifdef CONFIG_COMPAT
5879 .compat_ioctl = megasas_mgmt_compat_ioctl,
5880#endif
6038f373 5881 .llseek = noop_llseek,
c4a3e0a5
BS		 5882};
5883
5884/*
5885 * PCI hotplug support registration structure
5886 */
5887static struct pci_driver megasas_pci_driver = {
5888
5889 .name = "megaraid_sas",
5890 .id_table = megasas_pci_table,
5891 .probe = megasas_probe_one,
6f039790 5892 .remove = megasas_detach_one,
31ea7088 5893 .suspend = megasas_suspend,
5894 .resume = megasas_resume,
c4a3e0a5
BS		 5895 .shutdown = megasas_shutdown,
5896};
5897
5898/*
5899 * Sysfs driver attributes
5900 */
5901static ssize_t megasas_sysfs_show_version(struct device_driver *dd, char *buf)
5902{
5903 return snprintf(buf, strlen(MEGASAS_VERSION) + 2, "%s\n",
5904 MEGASAS_VERSION);
5905}
5906
5907static DRIVER_ATTR(version, S_IRUGO, megasas_sysfs_show_version, NULL);
5908
5909static ssize_t
5910megasas_sysfs_show_release_date(struct device_driver *dd, char *buf)
5911{
5912 return snprintf(buf, strlen(MEGASAS_RELDATE) + 2, "%s\n",
5913 MEGASAS_RELDATE);
5914}
5915
5916static DRIVER_ATTR(release_date, S_IRUGO, megasas_sysfs_show_release_date,
5917 NULL);
5918
72c4fd36
YB		 5919static ssize_t
5920megasas_sysfs_show_support_poll_for_event(struct device_driver *dd, char *buf)
5921{
5922 return sprintf(buf, "%u\n", support_poll_for_event);
5923}
5924
5925static DRIVER_ATTR(support_poll_for_event, S_IRUGO,
5926 megasas_sysfs_show_support_poll_for_event, NULL);
5927
837f5fe8
YB		 5928 static ssize_t
5929megasas_sysfs_show_support_device_change(struct device_driver *dd, char *buf)
5930{
5931 return sprintf(buf, "%u\n", support_device_change);
5932}
5933
5934static DRIVER_ATTR(support_device_change, S_IRUGO,
5935 megasas_sysfs_show_support_device_change, NULL);
5936
658dcedb
SP		 5937static ssize_t
5938megasas_sysfs_show_dbg_lvl(struct device_driver *dd, char *buf)
5939{
ad84db2e 5940 return sprintf(buf, "%u\n", megasas_dbg_lvl);
658dcedb
SP		 5941}
5942
5943static ssize_t
5944megasas_sysfs_set_dbg_lvl(struct device_driver *dd, const char *buf, size_t count)
5945{
5946 int retval = count;
5947 if(sscanf(buf,"%u",&megasas_dbg_lvl)<1){
5948 printk(KERN_ERR "megasas: could not set dbg_lvl\n");
5949 retval = -EINVAL;
5950 }
5951 return retval;
5952}
5953
66dca9b8 5954static DRIVER_ATTR(dbg_lvl, S_IRUGO|S_IWUSR, megasas_sysfs_show_dbg_lvl,
ad84db2e 5955 megasas_sysfs_set_dbg_lvl);
5956
7e8a75f4
YB		 5957static void
5958megasas_aen_polling(struct work_struct *work)
5959{
5960 struct megasas_aen_event *ev =
c1d390d8 5961 container_of(work, struct megasas_aen_event, hotplug_work.work);
7e8a75f4
YB		 5962 struct megasas_instance *instance = ev->instance;
5963 union megasas_evt_class_locale class_locale;
5964 struct Scsi_Host *host;
5965 struct scsi_device *sdev1;
5966 u16 pd_index = 0;
c9786842 5967 u16 ld_index = 0;
7e8a75f4 5968 int i, j, doscan = 0;
229fe47c 5969 u32 seq_num, wait_time = MEGASAS_RESET_WAIT_TIME;
7e8a75f4
YB		 5970 int error;
5971
5972 if (!instance) {
5973 printk(KERN_ERR "invalid instance!\n");
5974 kfree(ev);
5975 return;
5976 }
229fe47c 5977
5978 /* Adjust event workqueue thread wait time for VF mode */
5979 if (instance->requestorId)
5980 wait_time = MEGASAS_ROUTINE_WAIT_TIME_VF;
5981
5982 /* Don't run the event workqueue thread if OCR is running */
5983 for (i = 0; i < wait_time; i++) {
5984 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL)
5985 break;
5986 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
5987 printk(KERN_NOTICE "megasas: %s waiting for "
5988 "controller reset to finish for scsi%d\n",
5989 __func__, instance->host->host_no);
5990 }
5991 msleep(1000);
5992 }
5993
7e8a75f4
YB		 5994 instance->ev = NULL;
5995 host = instance->host;
5996 if (instance->evt_detail) {
5997
94cd65dd 5998 switch (le32_to_cpu(instance->evt_detail->code)) {
7e8a75f4 5999 case MR_EVT_PD_INSERTED:
c9786842
YB		 6000 if (megasas_get_pd_list(instance) == 0) {
6001 for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
6002 for (j = 0;
6003 j < MEGASAS_MAX_DEV_PER_CHANNEL;
6004 j++) {
6005
6006 pd_index =
6007 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
6008
6009 sdev1 =
6010 scsi_device_lookup(host, i, j, 0);
6011
6012 if (instance->pd_list[pd_index].driveState
6013 == MR_PD_STATE_SYSTEM) {
6014 if (!sdev1) {
6015 scsi_add_device(host, i, j, 0);
6016 }
6017
6018 if (sdev1)
6019 scsi_device_put(sdev1);
6020 }
6021 }
6022 }
6023 }
6024 doscan = 0;
6025 break;
6026
7e8a75f4 6027 case MR_EVT_PD_REMOVED:
c9786842 6028 if (megasas_get_pd_list(instance) == 0) {
c9786842
YB		 6029 for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
6030 for (j = 0;
6031 j < MEGASAS_MAX_DEV_PER_CHANNEL;
6032 j++) {
6033
6034 pd_index =
6035 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
6036
6037 sdev1 =
6038 scsi_device_lookup(host, i, j, 0);
6039
6040 if (instance->pd_list[pd_index].driveState
6041 == MR_PD_STATE_SYSTEM) {
6042 if (sdev1) {
6043 scsi_device_put(sdev1);
6044 }
6045 } else {
6046 if (sdev1) {
6047 scsi_remove_device(sdev1);
6048 scsi_device_put(sdev1);
6049 }
6050 }
6051 }
6052 }
6053 }
6054 doscan = 0;
6055 break;
6056
6057 case MR_EVT_LD_OFFLINE:
4c598b23 6058 case MR_EVT_CFG_CLEARED:
c9786842 6059 case MR_EVT_LD_DELETED:
229fe47c 6060 if (!instance->requestorId ||
6061 (instance->requestorId &&
6062 megasas_get_ld_vf_affiliation(instance, 0))) {
6063 if (megasas_ld_list_query(instance,
6064 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST))
6065 megasas_get_ld_list(instance);
6066 for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
6067 for (j = 0;
6068 j < MEGASAS_MAX_DEV_PER_CHANNEL;
6069 j++) {
6070
6071 ld_index =
6072 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
6073
6074 sdev1 = scsi_device_lookup(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0);
6075
6076 if (instance->ld_ids[ld_index]
6077 != 0xff) {
6078 if (sdev1)
6079 scsi_device_put(sdev1);
6080 } else {
6081 if (sdev1) {
6082 scsi_remove_device(sdev1);
6083 scsi_device_put(sdev1);
6084 }
6085 }
c9786842
YB		 6086 }
6087 }
229fe47c 6088 doscan = 0;
c9786842 6089 }
c9786842
YB		 6090 break;
6091 case MR_EVT_LD_CREATED:
229fe47c 6092 if (!instance->requestorId ||
6093 (instance->requestorId &&
6094 megasas_get_ld_vf_affiliation(instance, 0))) {
6095 if (megasas_ld_list_query(instance,
6096 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST))
6097 megasas_get_ld_list(instance);
6098 for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
6099 for (j = 0;
6100 j < MEGASAS_MAX_DEV_PER_CHANNEL;
6101 j++) {
6102 ld_index =
6103 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
6104
6105 sdev1 = scsi_device_lookup(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0);
6106
6107 if (instance->ld_ids[ld_index]
6108 != 0xff) {
6109 if (!sdev1)
6110 scsi_add_device(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0);
c9786842 6111 }
229fe47c 6112 if (sdev1)
6113 scsi_device_put(sdev1);
c9786842
YB		 6114 }
6115 }
229fe47c 6116 doscan = 0;
c9786842 6117 }
c9786842 6118 break;
7e8a75f4 6119 case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:
c9786842 6120 case MR_EVT_FOREIGN_CFG_IMPORTED:
9c915a8c 6121 case MR_EVT_LD_STATE_CHANGE:
7e8a75f4
YB		 6122 doscan = 1;
6123 break;
6124 default:
6125 doscan = 0;
6126 break;
6127 }
6128 } else {
6129 printk(KERN_ERR "invalid evt_detail!\n");
6130 kfree(ev);
6131 return;
6132 }
6133
6134 if (doscan) {
229fe47c 6135 printk(KERN_INFO "megaraid_sas: scanning for scsi%d...\n",
6136 instance->host->host_no);
58968fc8
HR		 6137 if (megasas_get_pd_list(instance) == 0) {
6138 for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
6139 for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
6140 pd_index = i*MEGASAS_MAX_DEV_PER_CHANNEL + j;
6141 sdev1 = scsi_device_lookup(host, i, j, 0);
6142 if (instance->pd_list[pd_index].driveState ==
6143 MR_PD_STATE_SYSTEM) {
6144 if (!sdev1) {
6145 scsi_add_device(host, i, j, 0);
6146 }
6147 if (sdev1)
6148 scsi_device_put(sdev1);
6149 } else {
6150 if (sdev1) {
6151 scsi_remove_device(sdev1);
6152 scsi_device_put(sdev1);
6153 }
7e8a75f4
YB		 6154 }
6155 }
6156 }
6157 }
c9786842 6158
229fe47c 6159 if (!instance->requestorId ||
6160 (instance->requestorId &&
6161 megasas_get_ld_vf_affiliation(instance, 0))) {
6162 if (megasas_ld_list_query(instance,
6163 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST))
6164 megasas_get_ld_list(instance);
6165 for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
6166 for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL;
6167 j++) {
6168 ld_index =
6169 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
c9786842 6170
229fe47c 6171 sdev1 = scsi_device_lookup(host,
6172 MEGASAS_MAX_PD_CHANNELS + i, j, 0);
6173 if (instance->ld_ids[ld_index]
6174 != 0xff) {
6175 if (!sdev1)
6176 scsi_add_device(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0);
6177 else
6178 scsi_device_put(sdev1);
c9786842 6179 } else {
229fe47c 6180 if (sdev1) {
6181 scsi_remove_device(sdev1);
6182 scsi_device_put(sdev1);
6183 }
c9786842
YB		 6184 }
6185 }
6186 }
6187 }
7e8a75f4
YB		 6188 }
6189
6190 if ( instance->aen_cmd != NULL ) {
6191 kfree(ev);
6192 return ;
6193 }
6194
94cd65dd 6195 seq_num = le32_to_cpu(instance->evt_detail->seq_num) + 1;
7e8a75f4
YB		 6196
6197 /* Register AEN with FW for latest sequence number plus 1 */
6198 class_locale.members.reserved = 0;
6199 class_locale.members.locale = MR_EVT_LOCALE_ALL;
6200 class_locale.members.class = MR_EVT_CLASS_DEBUG;
6201 mutex_lock(&instance->aen_mutex);
6202 error = megasas_register_aen(instance, seq_num,
6203 class_locale.word);
6204 mutex_unlock(&instance->aen_mutex);
6205
6206 if (error)
6207 printk(KERN_ERR "register aen failed error %x\n", error);
6208
6209 kfree(ev);
6210}
6211
c4a3e0a5
BS		 6212/**
6213 * megasas_init - Driver load entry point
6214 */
6215static int __init megasas_init(void)
6216{
6217 int rval;
6218
6219 /*
6220 * Announce driver version and other information
6221 */
6222 printk(KERN_INFO "megasas: %s %s\n", MEGASAS_VERSION,
6223 MEGASAS_EXT_VERSION);
6224
bd8d6dd4
KD		 6225 spin_lock_init(&poll_aen_lock);
6226
72c4fd36 6227 support_poll_for_event = 2;
837f5fe8 6228 support_device_change = 1;
72c4fd36 6229
c4a3e0a5
BS		 6230 memset(&megasas_mgmt_info, 0, sizeof(megasas_mgmt_info));
6231
6232 /*
6233 * Register character device node
6234 */
6235 rval = register_chrdev(0, "megaraid_sas_ioctl", &megasas_mgmt_fops);
6236
6237 if (rval < 0) {
6238 printk(KERN_DEBUG "megasas: failed to open device node\n");
6239 return rval;
6240 }
6241
6242 megasas_mgmt_majorno = rval;
6243
6244 /*
6245 * Register ourselves as PCI hotplug module
6246 */
4041b9cd 6247 rval = pci_register_driver(&megasas_pci_driver);
c4a3e0a5
BS		 6248
6249 if (rval) {
6250 printk(KERN_DEBUG "megasas: PCI hotplug regisration failed \n");
83aabc1b
JG		 6251 goto err_pcidrv;
6252 }
6253
6254 rval = driver_create_file(&megasas_pci_driver.driver,
6255 &driver_attr_version);
6256 if (rval)
6257 goto err_dcf_attr_ver;
6258 rval = driver_create_file(&megasas_pci_driver.driver,
6259 &driver_attr_release_date);
6260 if (rval)
6261 goto err_dcf_rel_date;
72c4fd36
YB		 6262
6263 rval = driver_create_file(&megasas_pci_driver.driver,
6264 &driver_attr_support_poll_for_event);
6265 if (rval)
6266 goto err_dcf_support_poll_for_event;
6267
83aabc1b
JG		 6268 rval = driver_create_file(&megasas_pci_driver.driver,
6269 &driver_attr_dbg_lvl);
6270 if (rval)
6271 goto err_dcf_dbg_lvl;
837f5fe8
YB		 6272 rval = driver_create_file(&megasas_pci_driver.driver,
6273 &driver_attr_support_device_change);
6274 if (rval)
6275 goto err_dcf_support_device_change;
6276
c4a3e0a5 6277 return rval;
ad84db2e 6278
837f5fe8 6279err_dcf_support_device_change:
ad84db2e 6280 driver_remove_file(&megasas_pci_driver.driver,
6281 &driver_attr_dbg_lvl);
83aabc1b 6282err_dcf_dbg_lvl:
72c4fd36
YB		 6283 driver_remove_file(&megasas_pci_driver.driver,
6284 &driver_attr_support_poll_for_event);
6285
6286err_dcf_support_poll_for_event:
83aabc1b
JG		 6287 driver_remove_file(&megasas_pci_driver.driver,
6288 &driver_attr_release_date);
72c4fd36 6289
83aabc1b
JG		 6290err_dcf_rel_date:
6291 driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
6292err_dcf_attr_ver:
6293 pci_unregister_driver(&megasas_pci_driver);
6294err_pcidrv:
6295 unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
0d49016b 6296 return rval;
c4a3e0a5
BS		 6297}
6298
6299/**
6300 * megasas_exit - Driver unload entry point
6301 */
6302static void __exit megasas_exit(void)
6303{
658dcedb
SP		 6304 driver_remove_file(&megasas_pci_driver.driver,
6305 &driver_attr_dbg_lvl);
837f5fe8
YB		 6306 driver_remove_file(&megasas_pci_driver.driver,
6307 &driver_attr_support_poll_for_event);
6308 driver_remove_file(&megasas_pci_driver.driver,
6309 &driver_attr_support_device_change);
83aabc1b
JG		 6310 driver_remove_file(&megasas_pci_driver.driver,
6311 &driver_attr_release_date);
6312 driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
c4a3e0a5
BS		 6313
6314 pci_unregister_driver(&megasas_pci_driver);
6315 unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
6316}
6317
6318module_init(megasas_init);
6319module_exit(megasas_exit);
Linux kernel - Deliverables
This page took 1.106708 seconds and 5 git commands to generate.