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