10550f3c7b45dbca571d0090cd403ceaf8178e67
[pandora-kernel.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.06.12-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 <scsi/scsi_tcq.h>
58 #include "megaraid_sas_fusion.h"
59 #include "megaraid_sas.h"
60
61 /*
62  * poll_mode_io:1- schedule complete completion from q cmd
63  */
64 static unsigned int poll_mode_io;
65 module_param_named(poll_mode_io, poll_mode_io, int, 0);
66 MODULE_PARM_DESC(poll_mode_io,
67         "Complete cmds from IO path, (default=0)");
68
69 /*
70  * Number of sectors per IO command
71  * Will be set in megasas_init_mfi if user does not provide
72  */
73 static unsigned int max_sectors;
74 module_param_named(max_sectors, max_sectors, int, 0);
75 MODULE_PARM_DESC(max_sectors,
76         "Maximum number of sectors per IO command");
77
78 static int msix_disable;
79 module_param(msix_disable, int, S_IRUGO);
80 MODULE_PARM_DESC(msix_disable, "Disable MSI-X interrupt handling. Default: 0");
81
82 MODULE_LICENSE("GPL");
83 MODULE_VERSION(MEGASAS_VERSION);
84 MODULE_AUTHOR("megaraidlinux@lsi.com");
85 MODULE_DESCRIPTION("LSI MegaRAID SAS Driver");
86
87 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
88 static int megasas_get_pd_list(struct megasas_instance *instance);
89 static int megasas_issue_init_mfi(struct megasas_instance *instance);
90 static int megasas_register_aen(struct megasas_instance *instance,
91                                 u32 seq_num, u32 class_locale_word);
92 /*
93  * PCI ID table for all supported controllers
94  */
95 static struct pci_device_id megasas_pci_table[] = {
96
97         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064R)},
98         /* xscale IOP */
99         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078R)},
100         /* ppc IOP */
101         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078DE)},
102         /* ppc IOP */
103         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078GEN2)},
104         /* gen2*/
105         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0079GEN2)},
106         /* gen2*/
107         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0073SKINNY)},
108         /* skinny*/
109         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0071SKINNY)},
110         /* skinny*/
111         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VERDE_ZCR)},
112         /* xscale IOP, vega */
113         {PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)},
114         /* xscale IOP */
115         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FUSION)},
116         /* Fusion */
117         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_INVADER)},
118         /* Invader */
119         {}
120 };
121
122 MODULE_DEVICE_TABLE(pci, megasas_pci_table);
123
124 static int megasas_mgmt_majorno;
125 static struct megasas_mgmt_info megasas_mgmt_info;
126 static struct fasync_struct *megasas_async_queue;
127 static DEFINE_MUTEX(megasas_async_queue_mutex);
128
129 static int megasas_poll_wait_aen;
130 static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait);
131 static u32 support_poll_for_event;
132 u32 megasas_dbg_lvl;
133 static u32 support_device_change;
134
135 /* define lock for aen poll */
136 spinlock_t poll_aen_lock;
137
138 void
139 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
140                      u8 alt_status);
141 static u32
142 megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs);
143 static int
144 megasas_adp_reset_gen2(struct megasas_instance *instance,
145                        struct megasas_register_set __iomem *reg_set);
146 static irqreturn_t megasas_isr(int irq, void *devp);
147 static u32
148 megasas_init_adapter_mfi(struct megasas_instance *instance);
149 u32
150 megasas_build_and_issue_cmd(struct megasas_instance *instance,
151                             struct scsi_cmnd *scmd);
152 static void megasas_complete_cmd_dpc(unsigned long instance_addr);
153 void
154 megasas_release_fusion(struct megasas_instance *instance);
155 int
156 megasas_ioc_init_fusion(struct megasas_instance *instance);
157 void
158 megasas_free_cmds_fusion(struct megasas_instance *instance);
159 u8
160 megasas_get_map_info(struct megasas_instance *instance);
161 int
162 megasas_sync_map_info(struct megasas_instance *instance);
163 int
164 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd);
165 void megasas_reset_reply_desc(struct megasas_instance *instance);
166 u8 MR_ValidateMapInfo(struct MR_FW_RAID_MAP_ALL *map,
167                       struct LD_LOAD_BALANCE_INFO *lbInfo);
168 int megasas_reset_fusion(struct Scsi_Host *shost);
169 void megasas_fusion_ocr_wq(struct work_struct *work);
170
171 void
172 megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
173 {
174         instance->instancet->fire_cmd(instance,
175                 cmd->frame_phys_addr, 0, instance->reg_set);
176 }
177
178 /**
179  * megasas_get_cmd -    Get a command from the free pool
180  * @instance:           Adapter soft state
181  *
182  * Returns a free command from the pool
183  */
184 struct megasas_cmd *megasas_get_cmd(struct megasas_instance
185                                                   *instance)
186 {
187         unsigned long flags;
188         struct megasas_cmd *cmd = NULL;
189
190         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
191
192         if (!list_empty(&instance->cmd_pool)) {
193                 cmd = list_entry((&instance->cmd_pool)->next,
194                                  struct megasas_cmd, list);
195                 list_del_init(&cmd->list);
196         } else {
197                 printk(KERN_ERR "megasas: Command pool empty!\n");
198         }
199
200         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
201         return cmd;
202 }
203
204 /**
205  * megasas_return_cmd - Return a cmd to free command pool
206  * @instance:           Adapter soft state
207  * @cmd:                Command packet to be returned to free command pool
208  */
209 inline void
210 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
211 {
212         unsigned long flags;
213
214         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
215
216         cmd->scmd = NULL;
217         cmd->frame_count = 0;
218         if ((instance->pdev->device != PCI_DEVICE_ID_LSI_FUSION) &&
219             (instance->pdev->device != PCI_DEVICE_ID_LSI_INVADER) &&
220             (reset_devices))
221                 cmd->frame->hdr.cmd = MFI_CMD_INVALID;
222         list_add_tail(&cmd->list, &instance->cmd_pool);
223
224         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
225 }
226
227
228 /**
229 *       The following functions are defined for xscale
230 *       (deviceid : 1064R, PERC5) controllers
231 */
232
233 /**
234  * megasas_enable_intr_xscale - Enables interrupts
235  * @regs:                       MFI register set
236  */
237 static inline void
238 megasas_enable_intr_xscale(struct megasas_register_set __iomem * regs)
239 {
240         writel(0, &(regs)->outbound_intr_mask);
241
242         /* Dummy readl to force pci flush */
243         readl(&regs->outbound_intr_mask);
244 }
245
246 /**
247  * megasas_disable_intr_xscale -Disables interrupt
248  * @regs:                       MFI register set
249  */
250 static inline void
251 megasas_disable_intr_xscale(struct megasas_register_set __iomem * regs)
252 {
253         u32 mask = 0x1f;
254         writel(mask, &regs->outbound_intr_mask);
255         /* Dummy readl to force pci flush */
256         readl(&regs->outbound_intr_mask);
257 }
258
259 /**
260  * megasas_read_fw_status_reg_xscale - returns the current FW status value
261  * @regs:                       MFI register set
262  */
263 static u32
264 megasas_read_fw_status_reg_xscale(struct megasas_register_set __iomem * regs)
265 {
266         return readl(&(regs)->outbound_msg_0);
267 }
268 /**
269  * megasas_clear_interrupt_xscale -     Check & clear interrupt
270  * @regs:                               MFI register set
271  */
272 static int
273 megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs)
274 {
275         u32 status;
276         u32 mfiStatus = 0;
277         /*
278          * Check if it is our interrupt
279          */
280         status = readl(&regs->outbound_intr_status);
281
282         if (status & MFI_OB_INTR_STATUS_MASK)
283                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
284         if (status & MFI_XSCALE_OMR0_CHANGE_INTERRUPT)
285                 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
286
287         /*
288          * Clear the interrupt by writing back the same value
289          */
290         if (mfiStatus)
291                 writel(status, &regs->outbound_intr_status);
292
293         /* Dummy readl to force pci flush */
294         readl(&regs->outbound_intr_status);
295
296         return mfiStatus;
297 }
298
299 /**
300  * megasas_fire_cmd_xscale -    Sends command to the FW
301  * @frame_phys_addr :           Physical address of cmd
302  * @frame_count :               Number of frames for the command
303  * @regs :                      MFI register set
304  */
305 static inline void
306 megasas_fire_cmd_xscale(struct megasas_instance *instance,
307                 dma_addr_t frame_phys_addr,
308                 u32 frame_count,
309                 struct megasas_register_set __iomem *regs)
310 {
311         unsigned long flags;
312         spin_lock_irqsave(&instance->hba_lock, flags);
313         writel((frame_phys_addr >> 3)|(frame_count),
314                &(regs)->inbound_queue_port);
315         spin_unlock_irqrestore(&instance->hba_lock, flags);
316 }
317
318 /**
319  * megasas_adp_reset_xscale -  For controller reset
320  * @regs:                              MFI register set
321  */
322 static int
323 megasas_adp_reset_xscale(struct megasas_instance *instance,
324         struct megasas_register_set __iomem *regs)
325 {
326         u32 i;
327         u32 pcidata;
328         writel(MFI_ADP_RESET, &regs->inbound_doorbell);
329
330         for (i = 0; i < 3; i++)
331                 msleep(1000); /* sleep for 3 secs */
332         pcidata  = 0;
333         pci_read_config_dword(instance->pdev, MFI_1068_PCSR_OFFSET, &pcidata);
334         printk(KERN_NOTICE "pcidata = %x\n", pcidata);
335         if (pcidata & 0x2) {
336                 printk(KERN_NOTICE "mfi 1068 offset read=%x\n", pcidata);
337                 pcidata &= ~0x2;
338                 pci_write_config_dword(instance->pdev,
339                                 MFI_1068_PCSR_OFFSET, pcidata);
340
341                 for (i = 0; i < 2; i++)
342                         msleep(1000); /* need to wait 2 secs again */
343
344                 pcidata  = 0;
345                 pci_read_config_dword(instance->pdev,
346                                 MFI_1068_FW_HANDSHAKE_OFFSET, &pcidata);
347                 printk(KERN_NOTICE "1068 offset handshake read=%x\n", pcidata);
348                 if ((pcidata & 0xffff0000) == MFI_1068_FW_READY) {
349                         printk(KERN_NOTICE "1068 offset pcidt=%x\n", pcidata);
350                         pcidata = 0;
351                         pci_write_config_dword(instance->pdev,
352                                 MFI_1068_FW_HANDSHAKE_OFFSET, pcidata);
353                 }
354         }
355         return 0;
356 }
357
358 /**
359  * megasas_check_reset_xscale - For controller reset check
360  * @regs:                               MFI register set
361  */
362 static int
363 megasas_check_reset_xscale(struct megasas_instance *instance,
364                 struct megasas_register_set __iomem *regs)
365 {
366         u32 consumer;
367         consumer = *instance->consumer;
368
369         if ((instance->adprecovery != MEGASAS_HBA_OPERATIONAL) &&
370                 (*instance->consumer == MEGASAS_ADPRESET_INPROG_SIGN)) {
371                 return 1;
372         }
373         return 0;
374 }
375
376 static struct megasas_instance_template megasas_instance_template_xscale = {
377
378         .fire_cmd = megasas_fire_cmd_xscale,
379         .enable_intr = megasas_enable_intr_xscale,
380         .disable_intr = megasas_disable_intr_xscale,
381         .clear_intr = megasas_clear_intr_xscale,
382         .read_fw_status_reg = megasas_read_fw_status_reg_xscale,
383         .adp_reset = megasas_adp_reset_xscale,
384         .check_reset = megasas_check_reset_xscale,
385         .service_isr = megasas_isr,
386         .tasklet = megasas_complete_cmd_dpc,
387         .init_adapter = megasas_init_adapter_mfi,
388         .build_and_issue_cmd = megasas_build_and_issue_cmd,
389         .issue_dcmd = megasas_issue_dcmd,
390 };
391
392 /**
393 *       This is the end of set of functions & definitions specific
394 *       to xscale (deviceid : 1064R, PERC5) controllers
395 */
396
397 /**
398 *       The following functions are defined for ppc (deviceid : 0x60)
399 *       controllers
400 */
401
402 /**
403  * megasas_enable_intr_ppc -    Enables interrupts
404  * @regs:                       MFI register set
405  */
406 static inline void
407 megasas_enable_intr_ppc(struct megasas_register_set __iomem * regs)
408 {
409         writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
410
411         writel(~0x80000000, &(regs)->outbound_intr_mask);
412
413         /* Dummy readl to force pci flush */
414         readl(&regs->outbound_intr_mask);
415 }
416
417 /**
418  * megasas_disable_intr_ppc -   Disable interrupt
419  * @regs:                       MFI register set
420  */
421 static inline void
422 megasas_disable_intr_ppc(struct megasas_register_set __iomem * regs)
423 {
424         u32 mask = 0xFFFFFFFF;
425         writel(mask, &regs->outbound_intr_mask);
426         /* Dummy readl to force pci flush */
427         readl(&regs->outbound_intr_mask);
428 }
429
430 /**
431  * megasas_read_fw_status_reg_ppc - returns the current FW status value
432  * @regs:                       MFI register set
433  */
434 static u32
435 megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem * regs)
436 {
437         return readl(&(regs)->outbound_scratch_pad);
438 }
439
440 /**
441  * megasas_clear_interrupt_ppc -        Check & clear interrupt
442  * @regs:                               MFI register set
443  */
444 static int
445 megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
446 {
447         u32 status, mfiStatus = 0;
448
449         /*
450          * Check if it is our interrupt
451          */
452         status = readl(&regs->outbound_intr_status);
453
454         if (status & MFI_REPLY_1078_MESSAGE_INTERRUPT)
455                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
456
457         if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT)
458                 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
459
460         /*
461          * Clear the interrupt by writing back the same value
462          */
463         writel(status, &regs->outbound_doorbell_clear);
464
465         /* Dummy readl to force pci flush */
466         readl(&regs->outbound_doorbell_clear);
467
468         return mfiStatus;
469 }
470
471 /**
472  * megasas_fire_cmd_ppc -       Sends command to the FW
473  * @frame_phys_addr :           Physical address of cmd
474  * @frame_count :               Number of frames for the command
475  * @regs :                      MFI register set
476  */
477 static inline void
478 megasas_fire_cmd_ppc(struct megasas_instance *instance,
479                 dma_addr_t frame_phys_addr,
480                 u32 frame_count,
481                 struct megasas_register_set __iomem *regs)
482 {
483         unsigned long flags;
484         spin_lock_irqsave(&instance->hba_lock, flags);
485         writel((frame_phys_addr | (frame_count<<1))|1,
486                         &(regs)->inbound_queue_port);
487         spin_unlock_irqrestore(&instance->hba_lock, flags);
488 }
489
490 /**
491  * megasas_check_reset_ppc -    For controller reset check
492  * @regs:                               MFI register set
493  */
494 static int
495 megasas_check_reset_ppc(struct megasas_instance *instance,
496                         struct megasas_register_set __iomem *regs)
497 {
498         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
499                 return 1;
500
501         return 0;
502 }
503
504 static struct megasas_instance_template megasas_instance_template_ppc = {
505
506         .fire_cmd = megasas_fire_cmd_ppc,
507         .enable_intr = megasas_enable_intr_ppc,
508         .disable_intr = megasas_disable_intr_ppc,
509         .clear_intr = megasas_clear_intr_ppc,
510         .read_fw_status_reg = megasas_read_fw_status_reg_ppc,
511         .adp_reset = megasas_adp_reset_xscale,
512         .check_reset = megasas_check_reset_ppc,
513         .service_isr = megasas_isr,
514         .tasklet = megasas_complete_cmd_dpc,
515         .init_adapter = megasas_init_adapter_mfi,
516         .build_and_issue_cmd = megasas_build_and_issue_cmd,
517         .issue_dcmd = megasas_issue_dcmd,
518 };
519
520 /**
521  * megasas_enable_intr_skinny - Enables interrupts
522  * @regs:                       MFI register set
523  */
524 static inline void
525 megasas_enable_intr_skinny(struct megasas_register_set __iomem *regs)
526 {
527         writel(0xFFFFFFFF, &(regs)->outbound_intr_mask);
528
529         writel(~MFI_SKINNY_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
530
531         /* Dummy readl to force pci flush */
532         readl(&regs->outbound_intr_mask);
533 }
534
535 /**
536  * megasas_disable_intr_skinny -        Disables interrupt
537  * @regs:                       MFI register set
538  */
539 static inline void
540 megasas_disable_intr_skinny(struct megasas_register_set __iomem *regs)
541 {
542         u32 mask = 0xFFFFFFFF;
543         writel(mask, &regs->outbound_intr_mask);
544         /* Dummy readl to force pci flush */
545         readl(&regs->outbound_intr_mask);
546 }
547
548 /**
549  * megasas_read_fw_status_reg_skinny - returns the current FW status value
550  * @regs:                       MFI register set
551  */
552 static u32
553 megasas_read_fw_status_reg_skinny(struct megasas_register_set __iomem *regs)
554 {
555         return readl(&(regs)->outbound_scratch_pad);
556 }
557
558 /**
559  * megasas_clear_interrupt_skinny -     Check & clear interrupt
560  * @regs:                               MFI register set
561  */
562 static int
563 megasas_clear_intr_skinny(struct megasas_register_set __iomem *regs)
564 {
565         u32 status;
566         u32 mfiStatus = 0;
567
568         /*
569          * Check if it is our interrupt
570          */
571         status = readl(&regs->outbound_intr_status);
572
573         if (!(status & MFI_SKINNY_ENABLE_INTERRUPT_MASK)) {
574                 return 0;
575         }
576
577         /*
578          * Check if it is our interrupt
579          */
580         if ((megasas_read_fw_status_reg_gen2(regs) & MFI_STATE_MASK) ==
581             MFI_STATE_FAULT) {
582                 mfiStatus = MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
583         } else
584                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
585
586         /*
587          * Clear the interrupt by writing back the same value
588          */
589         writel(status, &regs->outbound_intr_status);
590
591         /*
592         * dummy read to flush PCI
593         */
594         readl(&regs->outbound_intr_status);
595
596         return mfiStatus;
597 }
598
599 /**
600  * megasas_fire_cmd_skinny -    Sends command to the FW
601  * @frame_phys_addr :           Physical address of cmd
602  * @frame_count :               Number of frames for the command
603  * @regs :                      MFI register set
604  */
605 static inline void
606 megasas_fire_cmd_skinny(struct megasas_instance *instance,
607                         dma_addr_t frame_phys_addr,
608                         u32 frame_count,
609                         struct megasas_register_set __iomem *regs)
610 {
611         unsigned long flags;
612         spin_lock_irqsave(&instance->hba_lock, flags);
613         writel(0, &(regs)->inbound_high_queue_port);
614         writel((frame_phys_addr | (frame_count<<1))|1,
615                 &(regs)->inbound_low_queue_port);
616         spin_unlock_irqrestore(&instance->hba_lock, flags);
617 }
618
619 /**
620  * megasas_check_reset_skinny - For controller reset check
621  * @regs:                               MFI register set
622  */
623 static int
624 megasas_check_reset_skinny(struct megasas_instance *instance,
625                                 struct megasas_register_set __iomem *regs)
626 {
627         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
628                 return 1;
629
630         return 0;
631 }
632
633 static struct megasas_instance_template megasas_instance_template_skinny = {
634
635         .fire_cmd = megasas_fire_cmd_skinny,
636         .enable_intr = megasas_enable_intr_skinny,
637         .disable_intr = megasas_disable_intr_skinny,
638         .clear_intr = megasas_clear_intr_skinny,
639         .read_fw_status_reg = megasas_read_fw_status_reg_skinny,
640         .adp_reset = megasas_adp_reset_gen2,
641         .check_reset = megasas_check_reset_skinny,
642         .service_isr = megasas_isr,
643         .tasklet = megasas_complete_cmd_dpc,
644         .init_adapter = megasas_init_adapter_mfi,
645         .build_and_issue_cmd = megasas_build_and_issue_cmd,
646         .issue_dcmd = megasas_issue_dcmd,
647 };
648
649
650 /**
651 *       The following functions are defined for gen2 (deviceid : 0x78 0x79)
652 *       controllers
653 */
654
655 /**
656  * megasas_enable_intr_gen2 -  Enables interrupts
657  * @regs:                      MFI register set
658  */
659 static inline void
660 megasas_enable_intr_gen2(struct megasas_register_set __iomem *regs)
661 {
662         writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
663
664         /* write ~0x00000005 (4 & 1) to the intr mask*/
665         writel(~MFI_GEN2_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
666
667         /* Dummy readl to force pci flush */
668         readl(&regs->outbound_intr_mask);
669 }
670
671 /**
672  * megasas_disable_intr_gen2 - Disables interrupt
673  * @regs:                      MFI register set
674  */
675 static inline void
676 megasas_disable_intr_gen2(struct megasas_register_set __iomem *regs)
677 {
678         u32 mask = 0xFFFFFFFF;
679         writel(mask, &regs->outbound_intr_mask);
680         /* Dummy readl to force pci flush */
681         readl(&regs->outbound_intr_mask);
682 }
683
684 /**
685  * megasas_read_fw_status_reg_gen2 - returns the current FW status value
686  * @regs:                      MFI register set
687  */
688 static u32
689 megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs)
690 {
691         return readl(&(regs)->outbound_scratch_pad);
692 }
693
694 /**
695  * megasas_clear_interrupt_gen2 -      Check & clear interrupt
696  * @regs:                              MFI register set
697  */
698 static int
699 megasas_clear_intr_gen2(struct megasas_register_set __iomem *regs)
700 {
701         u32 status;
702         u32 mfiStatus = 0;
703         /*
704          * Check if it is our interrupt
705          */
706         status = readl(&regs->outbound_intr_status);
707
708         if (status & MFI_GEN2_ENABLE_INTERRUPT_MASK) {
709                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
710         }
711         if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT) {
712                 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
713         }
714
715         /*
716          * Clear the interrupt by writing back the same value
717          */
718         if (mfiStatus)
719                 writel(status, &regs->outbound_doorbell_clear);
720
721         /* Dummy readl to force pci flush */
722         readl(&regs->outbound_intr_status);
723
724         return mfiStatus;
725 }
726 /**
727  * megasas_fire_cmd_gen2 -     Sends command to the FW
728  * @frame_phys_addr :          Physical address of cmd
729  * @frame_count :              Number of frames for the command
730  * @regs :                     MFI register set
731  */
732 static inline void
733 megasas_fire_cmd_gen2(struct megasas_instance *instance,
734                         dma_addr_t frame_phys_addr,
735                         u32 frame_count,
736                         struct megasas_register_set __iomem *regs)
737 {
738         unsigned long flags;
739         spin_lock_irqsave(&instance->hba_lock, flags);
740         writel((frame_phys_addr | (frame_count<<1))|1,
741                         &(regs)->inbound_queue_port);
742         spin_unlock_irqrestore(&instance->hba_lock, flags);
743 }
744
745 /**
746  * megasas_adp_reset_gen2 -     For controller reset
747  * @regs:                               MFI register set
748  */
749 static int
750 megasas_adp_reset_gen2(struct megasas_instance *instance,
751                         struct megasas_register_set __iomem *reg_set)
752 {
753         u32                     retry = 0 ;
754         u32                     HostDiag;
755         u32                     *seq_offset = &reg_set->seq_offset;
756         u32                     *hostdiag_offset = &reg_set->host_diag;
757
758         if (instance->instancet == &megasas_instance_template_skinny) {
759                 seq_offset = &reg_set->fusion_seq_offset;
760                 hostdiag_offset = &reg_set->fusion_host_diag;
761         }
762
763         writel(0, seq_offset);
764         writel(4, seq_offset);
765         writel(0xb, seq_offset);
766         writel(2, seq_offset);
767         writel(7, seq_offset);
768         writel(0xd, seq_offset);
769
770         msleep(1000);
771
772         HostDiag = (u32)readl(hostdiag_offset);
773
774         while ( !( HostDiag & DIAG_WRITE_ENABLE) ) {
775                 msleep(100);
776                 HostDiag = (u32)readl(hostdiag_offset);
777                 printk(KERN_NOTICE "RESETGEN2: retry=%x, hostdiag=%x\n",
778                                         retry, HostDiag);
779
780                 if (retry++ >= 100)
781                         return 1;
782
783         }
784
785         printk(KERN_NOTICE "ADP_RESET_GEN2: HostDiag=%x\n", HostDiag);
786
787         writel((HostDiag | DIAG_RESET_ADAPTER), hostdiag_offset);
788
789         ssleep(10);
790
791         HostDiag = (u32)readl(hostdiag_offset);
792         while ( ( HostDiag & DIAG_RESET_ADAPTER) ) {
793                 msleep(100);
794                 HostDiag = (u32)readl(hostdiag_offset);
795                 printk(KERN_NOTICE "RESET_GEN2: retry=%x, hostdiag=%x\n",
796                                 retry, HostDiag);
797
798                 if (retry++ >= 1000)
799                         return 1;
800
801         }
802         return 0;
803 }
804
805 /**
806  * megasas_check_reset_gen2 -   For controller reset check
807  * @regs:                               MFI register set
808  */
809 static int
810 megasas_check_reset_gen2(struct megasas_instance *instance,
811                 struct megasas_register_set __iomem *regs)
812 {
813         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
814                 return 1;
815         }
816
817         return 0;
818 }
819
820 static struct megasas_instance_template megasas_instance_template_gen2 = {
821
822         .fire_cmd = megasas_fire_cmd_gen2,
823         .enable_intr = megasas_enable_intr_gen2,
824         .disable_intr = megasas_disable_intr_gen2,
825         .clear_intr = megasas_clear_intr_gen2,
826         .read_fw_status_reg = megasas_read_fw_status_reg_gen2,
827         .adp_reset = megasas_adp_reset_gen2,
828         .check_reset = megasas_check_reset_gen2,
829         .service_isr = megasas_isr,
830         .tasklet = megasas_complete_cmd_dpc,
831         .init_adapter = megasas_init_adapter_mfi,
832         .build_and_issue_cmd = megasas_build_and_issue_cmd,
833         .issue_dcmd = megasas_issue_dcmd,
834 };
835
836 /**
837 *       This is the end of set of functions & definitions
838 *       specific to gen2 (deviceid : 0x78, 0x79) controllers
839 */
840
841 /*
842  * Template added for TB (Fusion)
843  */
844 extern struct megasas_instance_template megasas_instance_template_fusion;
845
846 /**
847  * megasas_issue_polled -       Issues a polling command
848  * @instance:                   Adapter soft state
849  * @cmd:                        Command packet to be issued
850  *
851  * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
852  */
853 int
854 megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
855 {
856
857         struct megasas_header *frame_hdr = &cmd->frame->hdr;
858
859         frame_hdr->cmd_status = 0xFF;
860         frame_hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
861
862         /*
863          * Issue the frame using inbound queue port
864          */
865         instance->instancet->issue_dcmd(instance, cmd);
866
867         /*
868          * Wait for cmd_status to change
869          */
870         return wait_and_poll(instance, cmd);
871 }
872
873 /**
874  * megasas_issue_blocked_cmd -  Synchronous wrapper around regular FW cmds
875  * @instance:                   Adapter soft state
876  * @cmd:                        Command to be issued
877  *
878  * This function waits on an event for the command to be returned from ISR.
879  * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
880  * Used to issue ioctl commands.
881  */
882 static int
883 megasas_issue_blocked_cmd(struct megasas_instance *instance,
884                           struct megasas_cmd *cmd)
885 {
886         cmd->cmd_status = ENODATA;
887
888         instance->instancet->issue_dcmd(instance, cmd);
889
890         wait_event(instance->int_cmd_wait_q, cmd->cmd_status != ENODATA);
891
892         return 0;
893 }
894
895 /**
896  * megasas_issue_blocked_abort_cmd -    Aborts previously issued cmd
897  * @instance:                           Adapter soft state
898  * @cmd_to_abort:                       Previously issued cmd to be aborted
899  *
900  * MFI firmware can abort previously issued AEN command (automatic event
901  * notification). The megasas_issue_blocked_abort_cmd() issues such abort
902  * cmd and waits for return status.
903  * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
904  */
905 static int
906 megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
907                                 struct megasas_cmd *cmd_to_abort)
908 {
909         struct megasas_cmd *cmd;
910         struct megasas_abort_frame *abort_fr;
911
912         cmd = megasas_get_cmd(instance);
913
914         if (!cmd)
915                 return -1;
916
917         abort_fr = &cmd->frame->abort;
918
919         /*
920          * Prepare and issue the abort frame
921          */
922         abort_fr->cmd = MFI_CMD_ABORT;
923         abort_fr->cmd_status = 0xFF;
924         abort_fr->flags = 0;
925         abort_fr->abort_context = cmd_to_abort->index;
926         abort_fr->abort_mfi_phys_addr_lo = cmd_to_abort->frame_phys_addr;
927         abort_fr->abort_mfi_phys_addr_hi = 0;
928
929         cmd->sync_cmd = 1;
930         cmd->cmd_status = 0xFF;
931
932         instance->instancet->issue_dcmd(instance, cmd);
933
934         /*
935          * Wait for this cmd to complete
936          */
937         wait_event(instance->abort_cmd_wait_q, cmd->cmd_status != 0xFF);
938         cmd->sync_cmd = 0;
939
940         megasas_return_cmd(instance, cmd);
941         return 0;
942 }
943
944 /**
945  * megasas_make_sgl32 - Prepares 32-bit SGL
946  * @instance:           Adapter soft state
947  * @scp:                SCSI command from the mid-layer
948  * @mfi_sgl:            SGL to be filled in
949  *
950  * If successful, this function returns the number of SG elements. Otherwise,
951  * it returnes -1.
952  */
953 static int
954 megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
955                    union megasas_sgl *mfi_sgl)
956 {
957         int i;
958         int sge_count;
959         struct scatterlist *os_sgl;
960
961         sge_count = scsi_dma_map(scp);
962         BUG_ON(sge_count < 0);
963
964         if (sge_count) {
965                 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
966                         mfi_sgl->sge32[i].length = sg_dma_len(os_sgl);
967                         mfi_sgl->sge32[i].phys_addr = sg_dma_address(os_sgl);
968                 }
969         }
970         return sge_count;
971 }
972
973 /**
974  * megasas_make_sgl64 - Prepares 64-bit SGL
975  * @instance:           Adapter soft state
976  * @scp:                SCSI command from the mid-layer
977  * @mfi_sgl:            SGL to be filled in
978  *
979  * If successful, this function returns the number of SG elements. Otherwise,
980  * it returnes -1.
981  */
982 static int
983 megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
984                    union megasas_sgl *mfi_sgl)
985 {
986         int i;
987         int sge_count;
988         struct scatterlist *os_sgl;
989
990         sge_count = scsi_dma_map(scp);
991         BUG_ON(sge_count < 0);
992
993         if (sge_count) {
994                 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
995                         mfi_sgl->sge64[i].length = sg_dma_len(os_sgl);
996                         mfi_sgl->sge64[i].phys_addr = sg_dma_address(os_sgl);
997                 }
998         }
999         return sge_count;
1000 }
1001
1002 /**
1003  * megasas_make_sgl_skinny - Prepares IEEE SGL
1004  * @instance:           Adapter soft state
1005  * @scp:                SCSI command from the mid-layer
1006  * @mfi_sgl:            SGL to be filled in
1007  *
1008  * If successful, this function returns the number of SG elements. Otherwise,
1009  * it returnes -1.
1010  */
1011 static int
1012 megasas_make_sgl_skinny(struct megasas_instance *instance,
1013                 struct scsi_cmnd *scp, union megasas_sgl *mfi_sgl)
1014 {
1015         int i;
1016         int sge_count;
1017         struct scatterlist *os_sgl;
1018
1019         sge_count = scsi_dma_map(scp);
1020
1021         if (sge_count) {
1022                 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1023                         mfi_sgl->sge_skinny[i].length = sg_dma_len(os_sgl);
1024                         mfi_sgl->sge_skinny[i].phys_addr =
1025                                                 sg_dma_address(os_sgl);
1026                         mfi_sgl->sge_skinny[i].flag = 0;
1027                 }
1028         }
1029         return sge_count;
1030 }
1031
1032  /**
1033  * megasas_get_frame_count - Computes the number of frames
1034  * @frame_type          : type of frame- io or pthru frame
1035  * @sge_count           : number of sg elements
1036  *
1037  * Returns the number of frames required for numnber of sge's (sge_count)
1038  */
1039
1040 static u32 megasas_get_frame_count(struct megasas_instance *instance,
1041                         u8 sge_count, u8 frame_type)
1042 {
1043         int num_cnt;
1044         int sge_bytes;
1045         u32 sge_sz;
1046         u32 frame_count=0;
1047
1048         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
1049             sizeof(struct megasas_sge32);
1050
1051         if (instance->flag_ieee) {
1052                 sge_sz = sizeof(struct megasas_sge_skinny);
1053         }
1054
1055         /*
1056          * Main frame can contain 2 SGEs for 64-bit SGLs and
1057          * 3 SGEs for 32-bit SGLs for ldio &
1058          * 1 SGEs for 64-bit SGLs and
1059          * 2 SGEs for 32-bit SGLs for pthru frame
1060          */
1061         if (unlikely(frame_type == PTHRU_FRAME)) {
1062                 if (instance->flag_ieee == 1) {
1063                         num_cnt = sge_count - 1;
1064                 } else if (IS_DMA64)
1065                         num_cnt = sge_count - 1;
1066                 else
1067                         num_cnt = sge_count - 2;
1068         } else {
1069                 if (instance->flag_ieee == 1) {
1070                         num_cnt = sge_count - 1;
1071                 } else if (IS_DMA64)
1072                         num_cnt = sge_count - 2;
1073                 else
1074                         num_cnt = sge_count - 3;
1075         }
1076
1077         if(num_cnt>0){
1078                 sge_bytes = sge_sz * num_cnt;
1079
1080                 frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) +
1081                     ((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) ;
1082         }
1083         /* Main frame */
1084         frame_count +=1;
1085
1086         if (frame_count > 7)
1087                 frame_count = 8;
1088         return frame_count;
1089 }
1090
1091 /**
1092  * megasas_build_dcdb - Prepares a direct cdb (DCDB) command
1093  * @instance:           Adapter soft state
1094  * @scp:                SCSI command
1095  * @cmd:                Command to be prepared in
1096  *
1097  * This function prepares CDB commands. These are typcially pass-through
1098  * commands to the devices.
1099  */
1100 static int
1101 megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
1102                    struct megasas_cmd *cmd)
1103 {
1104         u32 is_logical;
1105         u32 device_id;
1106         u16 flags = 0;
1107         struct megasas_pthru_frame *pthru;
1108
1109         is_logical = MEGASAS_IS_LOGICAL(scp);
1110         device_id = MEGASAS_DEV_INDEX(instance, scp);
1111         pthru = (struct megasas_pthru_frame *)cmd->frame;
1112
1113         if (scp->sc_data_direction == PCI_DMA_TODEVICE)
1114                 flags = MFI_FRAME_DIR_WRITE;
1115         else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1116                 flags = MFI_FRAME_DIR_READ;
1117         else if (scp->sc_data_direction == PCI_DMA_NONE)
1118                 flags = MFI_FRAME_DIR_NONE;
1119
1120         if (instance->flag_ieee == 1) {
1121                 flags |= MFI_FRAME_IEEE;
1122         }
1123
1124         /*
1125          * Prepare the DCDB frame
1126          */
1127         pthru->cmd = (is_logical) ? MFI_CMD_LD_SCSI_IO : MFI_CMD_PD_SCSI_IO;
1128         pthru->cmd_status = 0x0;
1129         pthru->scsi_status = 0x0;
1130         pthru->target_id = device_id;
1131         pthru->lun = scp->device->lun;
1132         pthru->cdb_len = scp->cmd_len;
1133         pthru->timeout = 0;
1134         pthru->pad_0 = 0;
1135         pthru->flags = flags;
1136         pthru->data_xfer_len = scsi_bufflen(scp);
1137
1138         memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
1139
1140         /*
1141         * If the command is for the tape device, set the
1142         * pthru timeout to the os layer timeout value.
1143         */
1144         if (scp->device->type == TYPE_TAPE) {
1145                 if ((scp->request->timeout / HZ) > 0xFFFF)
1146                         pthru->timeout = 0xFFFF;
1147                 else
1148                         pthru->timeout = scp->request->timeout / HZ;
1149         }
1150
1151         /*
1152          * Construct SGL
1153          */
1154         if (instance->flag_ieee == 1) {
1155                 pthru->flags |= MFI_FRAME_SGL64;
1156                 pthru->sge_count = megasas_make_sgl_skinny(instance, scp,
1157                                                       &pthru->sgl);
1158         } else if (IS_DMA64) {
1159                 pthru->flags |= MFI_FRAME_SGL64;
1160                 pthru->sge_count = megasas_make_sgl64(instance, scp,
1161                                                       &pthru->sgl);
1162         } else
1163                 pthru->sge_count = megasas_make_sgl32(instance, scp,
1164                                                       &pthru->sgl);
1165
1166         if (pthru->sge_count > instance->max_num_sge) {
1167                 printk(KERN_ERR "megasas: DCDB two many SGE NUM=%x\n",
1168                         pthru->sge_count);
1169                 return 0;
1170         }
1171
1172         /*
1173          * Sense info specific
1174          */
1175         pthru->sense_len = SCSI_SENSE_BUFFERSIZE;
1176         pthru->sense_buf_phys_addr_hi = 0;
1177         pthru->sense_buf_phys_addr_lo = cmd->sense_phys_addr;
1178
1179         /*
1180          * Compute the total number of frames this command consumes. FW uses
1181          * this number to pull sufficient number of frames from host memory.
1182          */
1183         cmd->frame_count = megasas_get_frame_count(instance, pthru->sge_count,
1184                                                         PTHRU_FRAME);
1185
1186         return cmd->frame_count;
1187 }
1188
1189 /**
1190  * megasas_build_ldio - Prepares IOs to logical devices
1191  * @instance:           Adapter soft state
1192  * @scp:                SCSI command
1193  * @cmd:                Command to be prepared
1194  *
1195  * Frames (and accompanying SGLs) for regular SCSI IOs use this function.
1196  */
1197 static int
1198 megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
1199                    struct megasas_cmd *cmd)
1200 {
1201         u32 device_id;
1202         u8 sc = scp->cmnd[0];
1203         u16 flags = 0;
1204         struct megasas_io_frame *ldio;
1205
1206         device_id = MEGASAS_DEV_INDEX(instance, scp);
1207         ldio = (struct megasas_io_frame *)cmd->frame;
1208
1209         if (scp->sc_data_direction == PCI_DMA_TODEVICE)
1210                 flags = MFI_FRAME_DIR_WRITE;
1211         else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1212                 flags = MFI_FRAME_DIR_READ;
1213
1214         if (instance->flag_ieee == 1) {
1215                 flags |= MFI_FRAME_IEEE;
1216         }
1217
1218         /*
1219          * Prepare the Logical IO frame: 2nd bit is zero for all read cmds
1220          */
1221         ldio->cmd = (sc & 0x02) ? MFI_CMD_LD_WRITE : MFI_CMD_LD_READ;
1222         ldio->cmd_status = 0x0;
1223         ldio->scsi_status = 0x0;
1224         ldio->target_id = device_id;
1225         ldio->timeout = 0;
1226         ldio->reserved_0 = 0;
1227         ldio->pad_0 = 0;
1228         ldio->flags = flags;
1229         ldio->start_lba_hi = 0;
1230         ldio->access_byte = (scp->cmd_len != 6) ? scp->cmnd[1] : 0;
1231
1232         /*
1233          * 6-byte READ(0x08) or WRITE(0x0A) cdb
1234          */
1235         if (scp->cmd_len == 6) {
1236                 ldio->lba_count = (u32) scp->cmnd[4];
1237                 ldio->start_lba_lo = ((u32) scp->cmnd[1] << 16) |
1238                     ((u32) scp->cmnd[2] << 8) | (u32) scp->cmnd[3];
1239
1240                 ldio->start_lba_lo &= 0x1FFFFF;
1241         }
1242
1243         /*
1244          * 10-byte READ(0x28) or WRITE(0x2A) cdb
1245          */
1246         else if (scp->cmd_len == 10) {
1247                 ldio->lba_count = (u32) scp->cmnd[8] |
1248                     ((u32) scp->cmnd[7] << 8);
1249                 ldio->start_lba_lo = ((u32) scp->cmnd[2] << 24) |
1250                     ((u32) scp->cmnd[3] << 16) |
1251                     ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
1252         }
1253
1254         /*
1255          * 12-byte READ(0xA8) or WRITE(0xAA) cdb
1256          */
1257         else if (scp->cmd_len == 12) {
1258                 ldio->lba_count = ((u32) scp->cmnd[6] << 24) |
1259                     ((u32) scp->cmnd[7] << 16) |
1260                     ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
1261
1262                 ldio->start_lba_lo = ((u32) scp->cmnd[2] << 24) |
1263                     ((u32) scp->cmnd[3] << 16) |
1264                     ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
1265         }
1266
1267         /*
1268          * 16-byte READ(0x88) or WRITE(0x8A) cdb
1269          */
1270         else if (scp->cmd_len == 16) {
1271                 ldio->lba_count = ((u32) scp->cmnd[10] << 24) |
1272                     ((u32) scp->cmnd[11] << 16) |
1273                     ((u32) scp->cmnd[12] << 8) | (u32) scp->cmnd[13];
1274
1275                 ldio->start_lba_lo = ((u32) scp->cmnd[6] << 24) |
1276                     ((u32) scp->cmnd[7] << 16) |
1277                     ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
1278
1279                 ldio->start_lba_hi = ((u32) scp->cmnd[2] << 24) |
1280                     ((u32) scp->cmnd[3] << 16) |
1281                     ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
1282
1283         }
1284
1285         /*
1286          * Construct SGL
1287          */
1288         if (instance->flag_ieee) {
1289                 ldio->flags |= MFI_FRAME_SGL64;
1290                 ldio->sge_count = megasas_make_sgl_skinny(instance, scp,
1291                                               &ldio->sgl);
1292         } else if (IS_DMA64) {
1293                 ldio->flags |= MFI_FRAME_SGL64;
1294                 ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl);
1295         } else
1296                 ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
1297
1298         if (ldio->sge_count > instance->max_num_sge) {
1299                 printk(KERN_ERR "megasas: build_ld_io: sge_count = %x\n",
1300                         ldio->sge_count);
1301                 return 0;
1302         }
1303
1304         /*
1305          * Sense info specific
1306          */
1307         ldio->sense_len = SCSI_SENSE_BUFFERSIZE;
1308         ldio->sense_buf_phys_addr_hi = 0;
1309         ldio->sense_buf_phys_addr_lo = cmd->sense_phys_addr;
1310
1311         /*
1312          * Compute the total number of frames this command consumes. FW uses
1313          * this number to pull sufficient number of frames from host memory.
1314          */
1315         cmd->frame_count = megasas_get_frame_count(instance,
1316                         ldio->sge_count, IO_FRAME);
1317
1318         return cmd->frame_count;
1319 }
1320
1321 /**
1322  * megasas_is_ldio -            Checks if the cmd is for logical drive
1323  * @scmd:                       SCSI command
1324  *
1325  * Called by megasas_queue_command to find out if the command to be queued
1326  * is a logical drive command
1327  */
1328 inline int megasas_is_ldio(struct scsi_cmnd *cmd)
1329 {
1330         if (!MEGASAS_IS_LOGICAL(cmd))
1331                 return 0;
1332         switch (cmd->cmnd[0]) {
1333         case READ_10:
1334         case WRITE_10:
1335         case READ_12:
1336         case WRITE_12:
1337         case READ_6:
1338         case WRITE_6:
1339         case READ_16:
1340         case WRITE_16:
1341                 return 1;
1342         default:
1343                 return 0;
1344         }
1345 }
1346
1347  /**
1348  * megasas_dump_pending_frames -        Dumps the frame address of all pending cmds
1349  *                                      in FW
1350  * @instance:                           Adapter soft state
1351  */
1352 static inline void
1353 megasas_dump_pending_frames(struct megasas_instance *instance)
1354 {
1355         struct megasas_cmd *cmd;
1356         int i,n;
1357         union megasas_sgl *mfi_sgl;
1358         struct megasas_io_frame *ldio;
1359         struct megasas_pthru_frame *pthru;
1360         u32 sgcount;
1361         u32 max_cmd = instance->max_fw_cmds;
1362
1363         printk(KERN_ERR "\nmegasas[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no);
1364         printk(KERN_ERR "megasas[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding));
1365         if (IS_DMA64)
1366                 printk(KERN_ERR "\nmegasas[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no);
1367         else
1368                 printk(KERN_ERR "\nmegasas[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no);
1369
1370         printk(KERN_ERR "megasas[%d]: Pending OS cmds in FW : \n",instance->host->host_no);
1371         for (i = 0; i < max_cmd; i++) {
1372                 cmd = instance->cmd_list[i];
1373                 if(!cmd->scmd)
1374                         continue;
1375                 printk(KERN_ERR "megasas[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
1376                 if (megasas_is_ldio(cmd->scmd)){
1377                         ldio = (struct megasas_io_frame *)cmd->frame;
1378                         mfi_sgl = &ldio->sgl;
1379                         sgcount = ldio->sge_count;
1380                         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);
1381                 }
1382                 else {
1383                         pthru = (struct megasas_pthru_frame *) cmd->frame;
1384                         mfi_sgl = &pthru->sgl;
1385                         sgcount = pthru->sge_count;
1386                         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);
1387                 }
1388         if(megasas_dbg_lvl & MEGASAS_DBG_LVL){
1389                 for (n = 0; n < sgcount; n++){
1390                         if (IS_DMA64)
1391                                 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) ;
1392                         else
1393                                 printk(KERN_ERR "megasas: sgl len : 0x%x, sgl addr : 0x%x ",mfi_sgl->sge32[n].length , mfi_sgl->sge32[n].phys_addr) ;
1394                         }
1395                 }
1396                 printk(KERN_ERR "\n");
1397         } /*for max_cmd*/
1398         printk(KERN_ERR "\nmegasas[%d]: Pending Internal cmds in FW : \n",instance->host->host_no);
1399         for (i = 0; i < max_cmd; i++) {
1400
1401                 cmd = instance->cmd_list[i];
1402
1403                 if(cmd->sync_cmd == 1){
1404                         printk(KERN_ERR "0x%08lx : ", (unsigned long)cmd->frame_phys_addr);
1405                 }
1406         }
1407         printk(KERN_ERR "megasas[%d]: Dumping Done.\n\n",instance->host->host_no);
1408 }
1409
1410 u32
1411 megasas_build_and_issue_cmd(struct megasas_instance *instance,
1412                             struct scsi_cmnd *scmd)
1413 {
1414         struct megasas_cmd *cmd;
1415         u32 frame_count;
1416
1417         cmd = megasas_get_cmd(instance);
1418         if (!cmd)
1419                 return SCSI_MLQUEUE_HOST_BUSY;
1420
1421         /*
1422          * Logical drive command
1423          */
1424         if (megasas_is_ldio(scmd))
1425                 frame_count = megasas_build_ldio(instance, scmd, cmd);
1426         else
1427                 frame_count = megasas_build_dcdb(instance, scmd, cmd);
1428
1429         if (!frame_count)
1430                 goto out_return_cmd;
1431
1432         cmd->scmd = scmd;
1433         scmd->SCp.ptr = (char *)cmd;
1434
1435         /*
1436          * Issue the command to the FW
1437          */
1438         atomic_inc(&instance->fw_outstanding);
1439
1440         instance->instancet->fire_cmd(instance, cmd->frame_phys_addr,
1441                                 cmd->frame_count-1, instance->reg_set);
1442         /*
1443          * Check if we have pend cmds to be completed
1444          */
1445         if (poll_mode_io && atomic_read(&instance->fw_outstanding))
1446                 tasklet_schedule(&instance->isr_tasklet);
1447
1448         return 0;
1449 out_return_cmd:
1450         megasas_return_cmd(instance, cmd);
1451         return 1;
1452 }
1453
1454
1455 /**
1456  * megasas_queue_command -      Queue entry point
1457  * @scmd:                       SCSI command to be queued
1458  * @done:                       Callback entry point
1459  */
1460 static int
1461 megasas_queue_command_lck(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd *))
1462 {
1463         struct megasas_instance *instance;
1464         unsigned long flags;
1465
1466         instance = (struct megasas_instance *)
1467             scmd->device->host->hostdata;
1468
1469         if (instance->issuepend_done == 0)
1470                 return SCSI_MLQUEUE_HOST_BUSY;
1471
1472         spin_lock_irqsave(&instance->hba_lock, flags);
1473         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
1474                 spin_unlock_irqrestore(&instance->hba_lock, flags);
1475                 return SCSI_MLQUEUE_HOST_BUSY;
1476         }
1477
1478         spin_unlock_irqrestore(&instance->hba_lock, flags);
1479
1480         scmd->scsi_done = done;
1481         scmd->result = 0;
1482
1483         if (MEGASAS_IS_LOGICAL(scmd) &&
1484             (scmd->device->id >= MEGASAS_MAX_LD || scmd->device->lun)) {
1485                 scmd->result = DID_BAD_TARGET << 16;
1486                 goto out_done;
1487         }
1488
1489         switch (scmd->cmnd[0]) {
1490         case SYNCHRONIZE_CACHE:
1491                 /*
1492                  * FW takes care of flush cache on its own
1493                  * No need to send it down
1494                  */
1495                 scmd->result = DID_OK << 16;
1496                 goto out_done;
1497         default:
1498                 break;
1499         }
1500
1501         if (instance->instancet->build_and_issue_cmd(instance, scmd)) {
1502                 printk(KERN_ERR "megasas: Err returned from build_and_issue_cmd\n");
1503                 return SCSI_MLQUEUE_HOST_BUSY;
1504         }
1505
1506         return 0;
1507
1508  out_done:
1509         done(scmd);
1510         return 0;
1511 }
1512
1513 static DEF_SCSI_QCMD(megasas_queue_command)
1514
1515 static struct megasas_instance *megasas_lookup_instance(u16 host_no)
1516 {
1517         int i;
1518
1519         for (i = 0; i < megasas_mgmt_info.max_index; i++) {
1520
1521                 if ((megasas_mgmt_info.instance[i]) &&
1522                     (megasas_mgmt_info.instance[i]->host->host_no == host_no))
1523                         return megasas_mgmt_info.instance[i];
1524         }
1525
1526         return NULL;
1527 }
1528
1529 static int megasas_slave_configure(struct scsi_device *sdev)
1530 {
1531         u16             pd_index = 0;
1532         struct  megasas_instance *instance ;
1533
1534         instance = megasas_lookup_instance(sdev->host->host_no);
1535
1536         /*
1537         * Don't export physical disk devices to the disk driver.
1538         *
1539         * FIXME: Currently we don't export them to the midlayer at all.
1540         *        That will be fixed once LSI engineers have audited the
1541         *        firmware for possible issues.
1542         */
1543         if (sdev->channel < MEGASAS_MAX_PD_CHANNELS &&
1544                                 sdev->type == TYPE_DISK) {
1545                 pd_index = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
1546                                                                 sdev->id;
1547                 if (instance->pd_list[pd_index].driveState ==
1548                                                 MR_PD_STATE_SYSTEM) {
1549                         blk_queue_rq_timeout(sdev->request_queue,
1550                                 MEGASAS_DEFAULT_CMD_TIMEOUT * HZ);
1551                         return 0;
1552                 }
1553                 return -ENXIO;
1554         }
1555
1556         /*
1557         * The RAID firmware may require extended timeouts.
1558         */
1559         blk_queue_rq_timeout(sdev->request_queue,
1560                 MEGASAS_DEFAULT_CMD_TIMEOUT * HZ);
1561         return 0;
1562 }
1563
1564 static int megasas_slave_alloc(struct scsi_device *sdev)
1565 {
1566         u16             pd_index = 0;
1567         struct megasas_instance *instance ;
1568         instance = megasas_lookup_instance(sdev->host->host_no);
1569         if ((sdev->channel < MEGASAS_MAX_PD_CHANNELS) &&
1570                                 (sdev->type == TYPE_DISK)) {
1571                 /*
1572                  * Open the OS scan to the SYSTEM PD
1573                  */
1574                 pd_index =
1575                         (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
1576                         sdev->id;
1577                 if ((instance->pd_list[pd_index].driveState ==
1578                                         MR_PD_STATE_SYSTEM) &&
1579                         (instance->pd_list[pd_index].driveType ==
1580                                                 TYPE_DISK)) {
1581                         return 0;
1582                 }
1583                 return -ENXIO;
1584         }
1585         return 0;
1586 }
1587
1588 void megaraid_sas_kill_hba(struct megasas_instance *instance)
1589 {
1590         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
1591             (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
1592             (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
1593             (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER)) {
1594                 writel(MFI_STOP_ADP, &instance->reg_set->doorbell);
1595         } else {
1596                 writel(MFI_STOP_ADP, &instance->reg_set->inbound_doorbell);
1597         }
1598 }
1599
1600  /**
1601   * megasas_check_and_restore_queue_depth - Check if queue depth needs to be
1602   *                                     restored to max value
1603   * @instance:                  Adapter soft state
1604   *
1605   */
1606 void
1607 megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
1608 {
1609         unsigned long flags;
1610         if (instance->flag & MEGASAS_FW_BUSY
1611                 && time_after(jiffies, instance->last_time + 5 * HZ)
1612                 && atomic_read(&instance->fw_outstanding) < 17) {
1613
1614                 spin_lock_irqsave(instance->host->host_lock, flags);
1615                 instance->flag &= ~MEGASAS_FW_BUSY;
1616                 if ((instance->pdev->device ==
1617                         PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
1618                         (instance->pdev->device ==
1619                         PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
1620                         instance->host->can_queue =
1621                                 instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
1622                 } else
1623                         instance->host->can_queue =
1624                                 instance->max_fw_cmds - MEGASAS_INT_CMDS;
1625
1626                 spin_unlock_irqrestore(instance->host->host_lock, flags);
1627         }
1628 }
1629
1630 /**
1631  * megasas_complete_cmd_dpc      -      Returns FW's controller structure
1632  * @instance_addr:                      Address of adapter soft state
1633  *
1634  * Tasklet to complete cmds
1635  */
1636 static void megasas_complete_cmd_dpc(unsigned long instance_addr)
1637 {
1638         u32 producer;
1639         u32 consumer;
1640         u32 context;
1641         struct megasas_cmd *cmd;
1642         struct megasas_instance *instance =
1643                                 (struct megasas_instance *)instance_addr;
1644         unsigned long flags;
1645
1646         /* If we have already declared adapter dead, donot complete cmds */
1647         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR )
1648                 return;
1649
1650         spin_lock_irqsave(&instance->completion_lock, flags);
1651
1652         producer = *instance->producer;
1653         consumer = *instance->consumer;
1654
1655         while (consumer != producer) {
1656                 context = instance->reply_queue[consumer];
1657                 if (context >= instance->max_fw_cmds) {
1658                         printk(KERN_ERR "Unexpected context value %x\n",
1659                                 context);
1660                         BUG();
1661                 }
1662
1663                 cmd = instance->cmd_list[context];
1664
1665                 megasas_complete_cmd(instance, cmd, DID_OK);
1666
1667                 consumer++;
1668                 if (consumer == (instance->max_fw_cmds + 1)) {
1669                         consumer = 0;
1670                 }
1671         }
1672
1673         *instance->consumer = producer;
1674
1675         spin_unlock_irqrestore(&instance->completion_lock, flags);
1676
1677         /*
1678          * Check if we can restore can_queue
1679          */
1680         megasas_check_and_restore_queue_depth(instance);
1681 }
1682
1683 static void
1684 megasas_internal_reset_defer_cmds(struct megasas_instance *instance);
1685
1686 static void
1687 process_fw_state_change_wq(struct work_struct *work);
1688
1689 void megasas_do_ocr(struct megasas_instance *instance)
1690 {
1691         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
1692         (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
1693         (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
1694                 *instance->consumer     = MEGASAS_ADPRESET_INPROG_SIGN;
1695         }
1696         instance->instancet->disable_intr(instance->reg_set);
1697         instance->adprecovery   = MEGASAS_ADPRESET_SM_INFAULT;
1698         instance->issuepend_done = 0;
1699
1700         atomic_set(&instance->fw_outstanding, 0);
1701         megasas_internal_reset_defer_cmds(instance);
1702         process_fw_state_change_wq(&instance->work_init);
1703 }
1704
1705 /**
1706  * megasas_wait_for_outstanding -       Wait for all outstanding cmds
1707  * @instance:                           Adapter soft state
1708  *
1709  * This function waits for up to MEGASAS_RESET_WAIT_TIME seconds for FW to
1710  * complete all its outstanding commands. Returns error if one or more IOs
1711  * are pending after this time period. It also marks the controller dead.
1712  */
1713 static int megasas_wait_for_outstanding(struct megasas_instance *instance)
1714 {
1715         int i;
1716         u32 reset_index;
1717         u32 wait_time = MEGASAS_RESET_WAIT_TIME;
1718         u8 adprecovery;
1719         unsigned long flags;
1720         struct list_head clist_local;
1721         struct megasas_cmd *reset_cmd;
1722         u32 fw_state;
1723         u8 kill_adapter_flag;
1724
1725         spin_lock_irqsave(&instance->hba_lock, flags);
1726         adprecovery = instance->adprecovery;
1727         spin_unlock_irqrestore(&instance->hba_lock, flags);
1728
1729         if (adprecovery != MEGASAS_HBA_OPERATIONAL) {
1730
1731                 INIT_LIST_HEAD(&clist_local);
1732                 spin_lock_irqsave(&instance->hba_lock, flags);
1733                 list_splice_init(&instance->internal_reset_pending_q,
1734                                 &clist_local);
1735                 spin_unlock_irqrestore(&instance->hba_lock, flags);
1736
1737                 printk(KERN_NOTICE "megasas: HBA reset wait ...\n");
1738                 for (i = 0; i < wait_time; i++) {
1739                         msleep(1000);
1740                         spin_lock_irqsave(&instance->hba_lock, flags);
1741                         adprecovery = instance->adprecovery;
1742                         spin_unlock_irqrestore(&instance->hba_lock, flags);
1743                         if (adprecovery == MEGASAS_HBA_OPERATIONAL)
1744                                 break;
1745                 }
1746
1747                 if (adprecovery != MEGASAS_HBA_OPERATIONAL) {
1748                         printk(KERN_NOTICE "megasas: reset: Stopping HBA.\n");
1749                         spin_lock_irqsave(&instance->hba_lock, flags);
1750                         instance->adprecovery   = MEGASAS_HW_CRITICAL_ERROR;
1751                         spin_unlock_irqrestore(&instance->hba_lock, flags);
1752                         return FAILED;
1753                 }
1754
1755                 reset_index     = 0;
1756                 while (!list_empty(&clist_local)) {
1757                         reset_cmd       = list_entry((&clist_local)->next,
1758                                                 struct megasas_cmd, list);
1759                         list_del_init(&reset_cmd->list);
1760                         if (reset_cmd->scmd) {
1761                                 reset_cmd->scmd->result = DID_RESET << 16;
1762                                 printk(KERN_NOTICE "%d:%p reset [%02x]\n",
1763                                         reset_index, reset_cmd,
1764                                         reset_cmd->scmd->cmnd[0]);
1765
1766                                 reset_cmd->scmd->scsi_done(reset_cmd->scmd);
1767                                 megasas_return_cmd(instance, reset_cmd);
1768                         } else if (reset_cmd->sync_cmd) {
1769                                 printk(KERN_NOTICE "megasas:%p synch cmds"
1770                                                 "reset queue\n",
1771                                                 reset_cmd);
1772
1773                                 reset_cmd->cmd_status = ENODATA;
1774                                 instance->instancet->fire_cmd(instance,
1775                                                 reset_cmd->frame_phys_addr,
1776                                                 0, instance->reg_set);
1777                         } else {
1778                                 printk(KERN_NOTICE "megasas: %p unexpected"
1779                                         "cmds lst\n",
1780                                         reset_cmd);
1781                         }
1782                         reset_index++;
1783                 }
1784
1785                 return SUCCESS;
1786         }
1787
1788         for (i = 0; i < wait_time; i++) {
1789
1790                 int outstanding = atomic_read(&instance->fw_outstanding);
1791
1792                 if (!outstanding)
1793                         break;
1794
1795                 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
1796                         printk(KERN_NOTICE "megasas: [%2d]waiting for %d "
1797                                "commands to complete\n",i,outstanding);
1798                         /*
1799                          * Call cmd completion routine. Cmd to be
1800                          * be completed directly without depending on isr.
1801                          */
1802                         megasas_complete_cmd_dpc((unsigned long)instance);
1803                 }
1804
1805                 msleep(1000);
1806         }
1807
1808         i = 0;
1809         kill_adapter_flag = 0;
1810         do {
1811                 fw_state = instance->instancet->read_fw_status_reg(
1812                                         instance->reg_set) & MFI_STATE_MASK;
1813                 if ((fw_state == MFI_STATE_FAULT) &&
1814                         (instance->disableOnlineCtrlReset == 0)) {
1815                         if (i == 3) {
1816                                 kill_adapter_flag = 2;
1817                                 break;
1818                         }
1819                         megasas_do_ocr(instance);
1820                         kill_adapter_flag = 1;
1821
1822                         /* wait for 1 secs to let FW finish the pending cmds */
1823                         msleep(1000);
1824                 }
1825                 i++;
1826         } while (i <= 3);
1827
1828         if (atomic_read(&instance->fw_outstanding) &&
1829                                         !kill_adapter_flag) {
1830                 if (instance->disableOnlineCtrlReset == 0) {
1831
1832                         megasas_do_ocr(instance);
1833
1834                         /* wait for 5 secs to let FW finish the pending cmds */
1835                         for (i = 0; i < wait_time; i++) {
1836                                 int outstanding =
1837                                         atomic_read(&instance->fw_outstanding);
1838                                 if (!outstanding)
1839                                         return SUCCESS;
1840                                 msleep(1000);
1841                         }
1842                 }
1843         }
1844
1845         if (atomic_read(&instance->fw_outstanding) ||
1846                                         (kill_adapter_flag == 2)) {
1847                 printk(KERN_NOTICE "megaraid_sas: pending cmds after reset\n");
1848                 /*
1849                 * Send signal to FW to stop processing any pending cmds.
1850                 * The controller will be taken offline by the OS now.
1851                 */
1852                 if ((instance->pdev->device ==
1853                         PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
1854                         (instance->pdev->device ==
1855                         PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
1856                         writel(MFI_STOP_ADP,
1857                                 &instance->reg_set->doorbell);
1858                 } else {
1859                         writel(MFI_STOP_ADP,
1860                                 &instance->reg_set->inbound_doorbell);
1861                 }
1862                 megasas_dump_pending_frames(instance);
1863                 spin_lock_irqsave(&instance->hba_lock, flags);
1864                 instance->adprecovery   = MEGASAS_HW_CRITICAL_ERROR;
1865                 spin_unlock_irqrestore(&instance->hba_lock, flags);
1866                 return FAILED;
1867         }
1868
1869         printk(KERN_NOTICE "megaraid_sas: no pending cmds after reset\n");
1870
1871         return SUCCESS;
1872 }
1873
1874 /**
1875  * megasas_generic_reset -      Generic reset routine
1876  * @scmd:                       Mid-layer SCSI command
1877  *
1878  * This routine implements a generic reset handler for device, bus and host
1879  * reset requests. Device, bus and host specific reset handlers can use this
1880  * function after they do their specific tasks.
1881  */
1882 static int megasas_generic_reset(struct scsi_cmnd *scmd)
1883 {
1884         int ret_val;
1885         struct megasas_instance *instance;
1886
1887         instance = (struct megasas_instance *)scmd->device->host->hostdata;
1888
1889         scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n",
1890                  scmd->cmnd[0], scmd->retries);
1891
1892         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
1893                 printk(KERN_ERR "megasas: cannot recover from previous reset "
1894                        "failures\n");
1895                 return FAILED;
1896         }
1897
1898         ret_val = megasas_wait_for_outstanding(instance);
1899         if (ret_val == SUCCESS)
1900                 printk(KERN_NOTICE "megasas: reset successful \n");
1901         else
1902                 printk(KERN_ERR "megasas: failed to do reset\n");
1903
1904         return ret_val;
1905 }
1906
1907 /**
1908  * megasas_reset_timer - quiesce the adapter if required
1909  * @scmd:               scsi cmnd
1910  *
1911  * Sets the FW busy flag and reduces the host->can_queue if the
1912  * cmd has not been completed within the timeout period.
1913  */
1914 static enum
1915 blk_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd)
1916 {
1917         struct megasas_instance *instance;
1918         unsigned long flags;
1919
1920         if (time_after(jiffies, scmd->jiffies_at_alloc +
1921                                 (MEGASAS_DEFAULT_CMD_TIMEOUT * 2) * HZ)) {
1922                 return BLK_EH_NOT_HANDLED;
1923         }
1924
1925         instance = (struct megasas_instance *)scmd->device->host->hostdata;
1926         if (!(instance->flag & MEGASAS_FW_BUSY)) {
1927                 /* FW is busy, throttle IO */
1928                 spin_lock_irqsave(instance->host->host_lock, flags);
1929
1930                 instance->host->can_queue = 16;
1931                 instance->last_time = jiffies;
1932                 instance->flag |= MEGASAS_FW_BUSY;
1933
1934                 spin_unlock_irqrestore(instance->host->host_lock, flags);
1935         }
1936         return BLK_EH_RESET_TIMER;
1937 }
1938
1939 /**
1940  * megasas_reset_device -       Device reset handler entry point
1941  */
1942 static int megasas_reset_device(struct scsi_cmnd *scmd)
1943 {
1944         int ret;
1945
1946         /*
1947          * First wait for all commands to complete
1948          */
1949         ret = megasas_generic_reset(scmd);
1950
1951         return ret;
1952 }
1953
1954 /**
1955  * megasas_reset_bus_host -     Bus & host reset handler entry point
1956  */
1957 static int megasas_reset_bus_host(struct scsi_cmnd *scmd)
1958 {
1959         int ret;
1960         struct megasas_instance *instance;
1961         instance = (struct megasas_instance *)scmd->device->host->hostdata;
1962
1963         /*
1964          * First wait for all commands to complete
1965          */
1966         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
1967             (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER))
1968                 ret = megasas_reset_fusion(scmd->device->host);
1969         else
1970                 ret = megasas_generic_reset(scmd);
1971
1972         return ret;
1973 }
1974
1975 /**
1976  * megasas_bios_param - Returns disk geometry for a disk
1977  * @sdev:               device handle
1978  * @bdev:               block device
1979  * @capacity:           drive capacity
1980  * @geom:               geometry parameters
1981  */
1982 static int
1983 megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
1984                  sector_t capacity, int geom[])
1985 {
1986         int heads;
1987         int sectors;
1988         sector_t cylinders;
1989         unsigned long tmp;
1990         /* Default heads (64) & sectors (32) */
1991         heads = 64;
1992         sectors = 32;
1993
1994         tmp = heads * sectors;
1995         cylinders = capacity;
1996
1997         sector_div(cylinders, tmp);
1998
1999         /*
2000          * Handle extended translation size for logical drives > 1Gb
2001          */
2002
2003         if (capacity >= 0x200000) {
2004                 heads = 255;
2005                 sectors = 63;
2006                 tmp = heads*sectors;
2007                 cylinders = capacity;
2008                 sector_div(cylinders, tmp);
2009         }
2010
2011         geom[0] = heads;
2012         geom[1] = sectors;
2013         geom[2] = cylinders;
2014
2015         return 0;
2016 }
2017
2018 static void megasas_aen_polling(struct work_struct *work);
2019
2020 /**
2021  * megasas_service_aen -        Processes an event notification
2022  * @instance:                   Adapter soft state
2023  * @cmd:                        AEN command completed by the ISR
2024  *
2025  * For AEN, driver sends a command down to FW that is held by the FW till an
2026  * event occurs. When an event of interest occurs, FW completes the command
2027  * that it was previously holding.
2028  *
2029  * This routines sends SIGIO signal to processes that have registered with the
2030  * driver for AEN.
2031  */
2032 static void
2033 megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
2034 {
2035         unsigned long flags;
2036         /*
2037          * Don't signal app if it is just an aborted previously registered aen
2038          */
2039         if ((!cmd->abort_aen) && (instance->unload == 0)) {
2040                 spin_lock_irqsave(&poll_aen_lock, flags);
2041                 megasas_poll_wait_aen = 1;
2042                 spin_unlock_irqrestore(&poll_aen_lock, flags);
2043                 wake_up(&megasas_poll_wait);
2044                 kill_fasync(&megasas_async_queue, SIGIO, POLL_IN);
2045         }
2046         else
2047                 cmd->abort_aen = 0;
2048
2049         instance->aen_cmd = NULL;
2050         megasas_return_cmd(instance, cmd);
2051
2052         if ((instance->unload == 0) &&
2053                 ((instance->issuepend_done == 1))) {
2054                 struct megasas_aen_event *ev;
2055                 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2056                 if (!ev) {
2057                         printk(KERN_ERR "megasas_service_aen: out of memory\n");
2058                 } else {
2059                         ev->instance = instance;
2060                         instance->ev = ev;
2061                         INIT_WORK(&ev->hotplug_work, megasas_aen_polling);
2062                         schedule_delayed_work(
2063                                 (struct delayed_work *)&ev->hotplug_work, 0);
2064                 }
2065         }
2066 }
2067
2068 static int megasas_change_queue_depth(struct scsi_device *sdev,
2069                                       int queue_depth, int reason)
2070 {
2071         if (reason != SCSI_QDEPTH_DEFAULT)
2072                 return -EOPNOTSUPP;
2073
2074         if (queue_depth > sdev->host->can_queue)
2075                 queue_depth = sdev->host->can_queue;
2076         scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev),
2077                                 queue_depth);
2078
2079         return queue_depth;
2080 }
2081
2082 /*
2083  * Scsi host template for megaraid_sas driver
2084  */
2085 static struct scsi_host_template megasas_template = {
2086
2087         .module = THIS_MODULE,
2088         .name = "LSI SAS based MegaRAID driver",
2089         .proc_name = "megaraid_sas",
2090         .slave_configure = megasas_slave_configure,
2091         .slave_alloc = megasas_slave_alloc,
2092         .queuecommand = megasas_queue_command,
2093         .eh_device_reset_handler = megasas_reset_device,
2094         .eh_bus_reset_handler = megasas_reset_bus_host,
2095         .eh_host_reset_handler = megasas_reset_bus_host,
2096         .eh_timed_out = megasas_reset_timer,
2097         .bios_param = megasas_bios_param,
2098         .use_clustering = ENABLE_CLUSTERING,
2099         .change_queue_depth = megasas_change_queue_depth,
2100 };
2101
2102 /**
2103  * megasas_complete_int_cmd -   Completes an internal command
2104  * @instance:                   Adapter soft state
2105  * @cmd:                        Command to be completed
2106  *
2107  * The megasas_issue_blocked_cmd() function waits for a command to complete
2108  * after it issues a command. This function wakes up that waiting routine by
2109  * calling wake_up() on the wait queue.
2110  */
2111 static void
2112 megasas_complete_int_cmd(struct megasas_instance *instance,
2113                          struct megasas_cmd *cmd)
2114 {
2115         cmd->cmd_status = cmd->frame->io.cmd_status;
2116
2117         if (cmd->cmd_status == ENODATA) {
2118                 cmd->cmd_status = 0;
2119         }
2120         wake_up(&instance->int_cmd_wait_q);
2121 }
2122
2123 /**
2124  * megasas_complete_abort -     Completes aborting a command
2125  * @instance:                   Adapter soft state
2126  * @cmd:                        Cmd that was issued to abort another cmd
2127  *
2128  * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q
2129  * after it issues an abort on a previously issued command. This function
2130  * wakes up all functions waiting on the same wait queue.
2131  */
2132 static void
2133 megasas_complete_abort(struct megasas_instance *instance,
2134                        struct megasas_cmd *cmd)
2135 {
2136         if (cmd->sync_cmd) {
2137                 cmd->sync_cmd = 0;
2138                 cmd->cmd_status = 0;
2139                 wake_up(&instance->abort_cmd_wait_q);
2140         }
2141
2142         return;
2143 }
2144
2145 /**
2146  * megasas_complete_cmd -       Completes a command
2147  * @instance:                   Adapter soft state
2148  * @cmd:                        Command to be completed
2149  * @alt_status:                 If non-zero, use this value as status to
2150  *                              SCSI mid-layer instead of the value returned
2151  *                              by the FW. This should be used if caller wants
2152  *                              an alternate status (as in the case of aborted
2153  *                              commands)
2154  */
2155 void
2156 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
2157                      u8 alt_status)
2158 {
2159         int exception = 0;
2160         struct megasas_header *hdr = &cmd->frame->hdr;
2161         unsigned long flags;
2162         struct fusion_context *fusion = instance->ctrl_context;
2163
2164         /* flag for the retry reset */
2165         cmd->retry_for_fw_reset = 0;
2166
2167         if (cmd->scmd)
2168                 cmd->scmd->SCp.ptr = NULL;
2169
2170         switch (hdr->cmd) {
2171         case MFI_CMD_INVALID:
2172                 /* Some older 1068 controller FW may keep a pended
2173                    MR_DCMD_CTRL_EVENT_GET_INFO left over from the main kernel
2174                    when booting the kdump kernel.  Ignore this command to
2175                    prevent a kernel panic on shutdown of the kdump kernel. */
2176                 printk(KERN_WARNING "megaraid_sas: MFI_CMD_INVALID command "
2177                        "completed.\n");
2178                 printk(KERN_WARNING "megaraid_sas: If you have a controller "
2179                        "other than PERC5, please upgrade your firmware.\n");
2180                 break;
2181         case MFI_CMD_PD_SCSI_IO:
2182         case MFI_CMD_LD_SCSI_IO:
2183
2184                 /*
2185                  * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
2186                  * issued either through an IO path or an IOCTL path. If it
2187                  * was via IOCTL, we will send it to internal completion.
2188                  */
2189                 if (cmd->sync_cmd) {
2190                         cmd->sync_cmd = 0;
2191                         megasas_complete_int_cmd(instance, cmd);
2192                         break;
2193                 }
2194
2195         case MFI_CMD_LD_READ:
2196         case MFI_CMD_LD_WRITE:
2197
2198                 if (alt_status) {
2199                         cmd->scmd->result = alt_status << 16;
2200                         exception = 1;
2201                 }
2202
2203                 if (exception) {
2204
2205                         atomic_dec(&instance->fw_outstanding);
2206
2207                         scsi_dma_unmap(cmd->scmd);
2208                         cmd->scmd->scsi_done(cmd->scmd);
2209                         megasas_return_cmd(instance, cmd);
2210
2211                         break;
2212                 }
2213
2214                 switch (hdr->cmd_status) {
2215
2216                 case MFI_STAT_OK:
2217                         cmd->scmd->result = DID_OK << 16;
2218                         break;
2219
2220                 case MFI_STAT_SCSI_IO_FAILED:
2221                 case MFI_STAT_LD_INIT_IN_PROGRESS:
2222                         cmd->scmd->result =
2223                             (DID_ERROR << 16) | hdr->scsi_status;
2224                         break;
2225
2226                 case MFI_STAT_SCSI_DONE_WITH_ERROR:
2227
2228                         cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status;
2229
2230                         if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) {
2231                                 memset(cmd->scmd->sense_buffer, 0,
2232                                        SCSI_SENSE_BUFFERSIZE);
2233                                 memcpy(cmd->scmd->sense_buffer, cmd->sense,
2234                                        hdr->sense_len);
2235
2236                                 cmd->scmd->result |= DRIVER_SENSE << 24;
2237                         }
2238
2239                         break;
2240
2241                 case MFI_STAT_LD_OFFLINE:
2242                 case MFI_STAT_DEVICE_NOT_FOUND:
2243                         cmd->scmd->result = DID_BAD_TARGET << 16;
2244                         break;
2245
2246                 default:
2247                         printk(KERN_DEBUG "megasas: MFI FW status %#x\n",
2248                                hdr->cmd_status);
2249                         cmd->scmd->result = DID_ERROR << 16;
2250                         break;
2251                 }
2252
2253                 atomic_dec(&instance->fw_outstanding);
2254
2255                 scsi_dma_unmap(cmd->scmd);
2256                 cmd->scmd->scsi_done(cmd->scmd);
2257                 megasas_return_cmd(instance, cmd);
2258
2259                 break;
2260
2261         case MFI_CMD_SMP:
2262         case MFI_CMD_STP:
2263         case MFI_CMD_DCMD:
2264                 /* Check for LD map update */
2265                 if ((cmd->frame->dcmd.opcode == MR_DCMD_LD_MAP_GET_INFO) &&
2266                     (cmd->frame->dcmd.mbox.b[1] == 1)) {
2267                         spin_lock_irqsave(instance->host->host_lock, flags);
2268                         if (cmd->frame->hdr.cmd_status != 0) {
2269                                 if (cmd->frame->hdr.cmd_status !=
2270                                     MFI_STAT_NOT_FOUND)
2271                                         printk(KERN_WARNING "megasas: map sync"
2272                                                "failed, status = 0x%x.\n",
2273                                                cmd->frame->hdr.cmd_status);
2274                                 else {
2275                                         megasas_return_cmd(instance, cmd);
2276                                         spin_unlock_irqrestore(
2277                                                 instance->host->host_lock,
2278                                                 flags);
2279                                         break;
2280                                 }
2281                         } else
2282                                 instance->map_id++;
2283                         megasas_return_cmd(instance, cmd);
2284                         if (MR_ValidateMapInfo(
2285                                     fusion->ld_map[(instance->map_id & 1)],
2286                                     fusion->load_balance_info))
2287                                 fusion->fast_path_io = 1;
2288                         else
2289                                 fusion->fast_path_io = 0;
2290                         megasas_sync_map_info(instance);
2291                         spin_unlock_irqrestore(instance->host->host_lock,
2292                                                flags);
2293                         break;
2294                 }
2295                 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||
2296                         cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET) {
2297                         spin_lock_irqsave(&poll_aen_lock, flags);
2298                         megasas_poll_wait_aen = 0;
2299                         spin_unlock_irqrestore(&poll_aen_lock, flags);
2300                 }
2301
2302                 /*
2303                  * See if got an event notification
2304                  */
2305                 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_WAIT)
2306                         megasas_service_aen(instance, cmd);
2307                 else
2308                         megasas_complete_int_cmd(instance, cmd);
2309
2310                 break;
2311
2312         case MFI_CMD_ABORT:
2313                 /*
2314                  * Cmd issued to abort another cmd returned
2315                  */
2316                 megasas_complete_abort(instance, cmd);
2317                 break;
2318
2319         default:
2320                 printk("megasas: Unknown command completed! [0x%X]\n",
2321                        hdr->cmd);
2322                 break;
2323         }
2324 }
2325
2326 /**
2327  * megasas_issue_pending_cmds_again -   issue all pending cmds
2328  *                                      in FW again because of the fw reset
2329  * @instance:                           Adapter soft state
2330  */
2331 static inline void
2332 megasas_issue_pending_cmds_again(struct megasas_instance *instance)
2333 {
2334         struct megasas_cmd *cmd;
2335         struct list_head clist_local;
2336         union megasas_evt_class_locale class_locale;
2337         unsigned long flags;
2338         u32 seq_num;
2339
2340         INIT_LIST_HEAD(&clist_local);
2341         spin_lock_irqsave(&instance->hba_lock, flags);
2342         list_splice_init(&instance->internal_reset_pending_q, &clist_local);
2343         spin_unlock_irqrestore(&instance->hba_lock, flags);
2344
2345         while (!list_empty(&clist_local)) {
2346                 cmd     = list_entry((&clist_local)->next,
2347                                         struct megasas_cmd, list);
2348                 list_del_init(&cmd->list);
2349
2350                 if (cmd->sync_cmd || cmd->scmd) {
2351                         printk(KERN_NOTICE "megaraid_sas: command %p, %p:%d"
2352                                 "detected to be pending while HBA reset.\n",
2353                                         cmd, cmd->scmd, cmd->sync_cmd);
2354
2355                         cmd->retry_for_fw_reset++;
2356
2357                         if (cmd->retry_for_fw_reset == 3) {
2358                                 printk(KERN_NOTICE "megaraid_sas: cmd %p, %p:%d"
2359                                         "was tried multiple times during reset."
2360                                         "Shutting down the HBA\n",
2361                                         cmd, cmd->scmd, cmd->sync_cmd);
2362                                 megaraid_sas_kill_hba(instance);
2363
2364                                 instance->adprecovery =
2365                                                 MEGASAS_HW_CRITICAL_ERROR;
2366                                 return;
2367                         }
2368                 }
2369
2370                 if (cmd->sync_cmd == 1) {
2371                         if (cmd->scmd) {
2372                                 printk(KERN_NOTICE "megaraid_sas: unexpected"
2373                                         "cmd attached to internal command!\n");
2374                         }
2375                         printk(KERN_NOTICE "megasas: %p synchronous cmd"
2376                                                 "on the internal reset queue,"
2377                                                 "issue it again.\n", cmd);
2378                         cmd->cmd_status = ENODATA;
2379                         instance->instancet->fire_cmd(instance,
2380                                                         cmd->frame_phys_addr ,
2381                                                         0, instance->reg_set);
2382                 } else if (cmd->scmd) {
2383                         printk(KERN_NOTICE "megasas: %p scsi cmd [%02x]"
2384                         "detected on the internal queue, issue again.\n",
2385                         cmd, cmd->scmd->cmnd[0]);
2386
2387                         atomic_inc(&instance->fw_outstanding);
2388                         instance->instancet->fire_cmd(instance,
2389                                         cmd->frame_phys_addr,
2390                                         cmd->frame_count-1, instance->reg_set);
2391                 } else {
2392                         printk(KERN_NOTICE "megasas: %p unexpected cmd on the"
2393                                 "internal reset defer list while re-issue!!\n",
2394                                 cmd);
2395                 }
2396         }
2397
2398         if (instance->aen_cmd) {
2399                 printk(KERN_NOTICE "megaraid_sas: aen_cmd in def process\n");
2400                 megasas_return_cmd(instance, instance->aen_cmd);
2401
2402                 instance->aen_cmd       = NULL;
2403         }
2404
2405         /*
2406         * Initiate AEN (Asynchronous Event Notification)
2407         */
2408         seq_num = instance->last_seq_num;
2409         class_locale.members.reserved = 0;
2410         class_locale.members.locale = MR_EVT_LOCALE_ALL;
2411         class_locale.members.class = MR_EVT_CLASS_DEBUG;
2412
2413         megasas_register_aen(instance, seq_num, class_locale.word);
2414 }
2415
2416 /**
2417  * Move the internal reset pending commands to a deferred queue.
2418  *
2419  * We move the commands pending at internal reset time to a
2420  * pending queue. This queue would be flushed after successful
2421  * completion of the internal reset sequence. if the internal reset
2422  * did not complete in time, the kernel reset handler would flush
2423  * these commands.
2424  **/
2425 static void
2426 megasas_internal_reset_defer_cmds(struct megasas_instance *instance)
2427 {
2428         struct megasas_cmd *cmd;
2429         int i;
2430         u32 max_cmd = instance->max_fw_cmds;
2431         u32 defer_index;
2432         unsigned long flags;
2433
2434         defer_index     = 0;
2435         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
2436         for (i = 0; i < max_cmd; i++) {
2437                 cmd = instance->cmd_list[i];
2438                 if (cmd->sync_cmd == 1 || cmd->scmd) {
2439                         printk(KERN_NOTICE "megasas: moving cmd[%d]:%p:%d:%p"
2440                                         "on the defer queue as internal\n",
2441                                 defer_index, cmd, cmd->sync_cmd, cmd->scmd);
2442
2443                         if (!list_empty(&cmd->list)) {
2444                                 printk(KERN_NOTICE "megaraid_sas: ERROR while"
2445                                         " moving this cmd:%p, %d %p, it was"
2446                                         "discovered on some list?\n",
2447                                         cmd, cmd->sync_cmd, cmd->scmd);
2448
2449                                 list_del_init(&cmd->list);
2450                         }
2451                         defer_index++;
2452                         list_add_tail(&cmd->list,
2453                                 &instance->internal_reset_pending_q);
2454                 }
2455         }
2456         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
2457 }
2458
2459
2460 static void
2461 process_fw_state_change_wq(struct work_struct *work)
2462 {
2463         struct megasas_instance *instance =
2464                 container_of(work, struct megasas_instance, work_init);
2465         u32 wait;
2466         unsigned long flags;
2467
2468         if (instance->adprecovery != MEGASAS_ADPRESET_SM_INFAULT) {
2469                 printk(KERN_NOTICE "megaraid_sas: error, recovery st %x \n",
2470                                 instance->adprecovery);
2471                 return ;
2472         }
2473
2474         if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) {
2475                 printk(KERN_NOTICE "megaraid_sas: FW detected to be in fault"
2476                                         "state, restarting it...\n");
2477
2478                 instance->instancet->disable_intr(instance->reg_set);
2479                 atomic_set(&instance->fw_outstanding, 0);
2480
2481                 atomic_set(&instance->fw_reset_no_pci_access, 1);
2482                 instance->instancet->adp_reset(instance, instance->reg_set);
2483                 atomic_set(&instance->fw_reset_no_pci_access, 0 );
2484
2485                 printk(KERN_NOTICE "megaraid_sas: FW restarted successfully,"
2486                                         "initiating next stage...\n");
2487
2488                 printk(KERN_NOTICE "megaraid_sas: HBA recovery state machine,"
2489                                         "state 2 starting...\n");
2490
2491                 /*waitting for about 20 second before start the second init*/
2492                 for (wait = 0; wait < 30; wait++) {
2493                         msleep(1000);
2494                 }
2495
2496                 if (megasas_transition_to_ready(instance, 1)) {
2497                         printk(KERN_NOTICE "megaraid_sas:adapter not ready\n");
2498
2499                         megaraid_sas_kill_hba(instance);
2500                         instance->adprecovery   = MEGASAS_HW_CRITICAL_ERROR;
2501                         return ;
2502                 }
2503
2504                 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
2505                         (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
2506                         (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)
2507                         ) {
2508                         *instance->consumer = *instance->producer;
2509                 } else {
2510                         *instance->consumer = 0;
2511                         *instance->producer = 0;
2512                 }
2513
2514                 megasas_issue_init_mfi(instance);
2515
2516                 spin_lock_irqsave(&instance->hba_lock, flags);
2517                 instance->adprecovery   = MEGASAS_HBA_OPERATIONAL;
2518                 spin_unlock_irqrestore(&instance->hba_lock, flags);
2519                 instance->instancet->enable_intr(instance->reg_set);
2520
2521                 megasas_issue_pending_cmds_again(instance);
2522                 instance->issuepend_done = 1;
2523         }
2524         return ;
2525 }
2526
2527 /**
2528  * megasas_deplete_reply_queue -        Processes all completed commands
2529  * @instance:                           Adapter soft state
2530  * @alt_status:                         Alternate status to be returned to
2531  *                                      SCSI mid-layer instead of the status
2532  *                                      returned by the FW
2533  * Note: this must be called with hba lock held
2534  */
2535 static int
2536 megasas_deplete_reply_queue(struct megasas_instance *instance,
2537                                         u8 alt_status)
2538 {
2539         u32 mfiStatus;
2540         u32 fw_state;
2541
2542         if ((mfiStatus = instance->instancet->check_reset(instance,
2543                                         instance->reg_set)) == 1) {
2544                 return IRQ_HANDLED;
2545         }
2546
2547         if ((mfiStatus = instance->instancet->clear_intr(
2548                                                 instance->reg_set)
2549                                                 ) == 0) {
2550                 /* Hardware may not set outbound_intr_status in MSI-X mode */
2551                 if (!instance->msix_vectors)
2552                         return IRQ_NONE;
2553         }
2554
2555         instance->mfiStatus = mfiStatus;
2556
2557         if ((mfiStatus & MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE)) {
2558                 fw_state = instance->instancet->read_fw_status_reg(
2559                                 instance->reg_set) & MFI_STATE_MASK;
2560
2561                 if (fw_state != MFI_STATE_FAULT) {
2562                         printk(KERN_NOTICE "megaraid_sas: fw state:%x\n",
2563                                                 fw_state);
2564                 }
2565
2566                 if ((fw_state == MFI_STATE_FAULT) &&
2567                                 (instance->disableOnlineCtrlReset == 0)) {
2568                         printk(KERN_NOTICE "megaraid_sas: wait adp restart\n");
2569
2570                         if ((instance->pdev->device ==
2571                                         PCI_DEVICE_ID_LSI_SAS1064R) ||
2572                                 (instance->pdev->device ==
2573                                         PCI_DEVICE_ID_DELL_PERC5) ||
2574                                 (instance->pdev->device ==
2575                                         PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
2576
2577                                 *instance->consumer =
2578                                         MEGASAS_ADPRESET_INPROG_SIGN;
2579                         }
2580
2581
2582                         instance->instancet->disable_intr(instance->reg_set);
2583                         instance->adprecovery   = MEGASAS_ADPRESET_SM_INFAULT;
2584                         instance->issuepend_done = 0;
2585
2586                         atomic_set(&instance->fw_outstanding, 0);
2587                         megasas_internal_reset_defer_cmds(instance);
2588
2589                         printk(KERN_NOTICE "megasas: fwState=%x, stage:%d\n",
2590                                         fw_state, instance->adprecovery);
2591
2592                         schedule_work(&instance->work_init);
2593                         return IRQ_HANDLED;
2594
2595                 } else {
2596                         printk(KERN_NOTICE "megasas: fwstate:%x, dis_OCR=%x\n",
2597                                 fw_state, instance->disableOnlineCtrlReset);
2598                 }
2599         }
2600
2601         tasklet_schedule(&instance->isr_tasklet);
2602         return IRQ_HANDLED;
2603 }
2604 /**
2605  * megasas_isr - isr entry point
2606  */
2607 static irqreturn_t megasas_isr(int irq, void *devp)
2608 {
2609         struct megasas_irq_context *irq_context = devp;
2610         struct megasas_instance *instance = irq_context->instance;
2611         unsigned long flags;
2612         irqreturn_t     rc;
2613
2614         if (atomic_read(&instance->fw_reset_no_pci_access))
2615                 return IRQ_HANDLED;
2616
2617         spin_lock_irqsave(&instance->hba_lock, flags);
2618         rc =  megasas_deplete_reply_queue(instance, DID_OK);
2619         spin_unlock_irqrestore(&instance->hba_lock, flags);
2620
2621         return rc;
2622 }
2623
2624 /**
2625  * megasas_transition_to_ready -        Move the FW to READY state
2626  * @instance:                           Adapter soft state
2627  *
2628  * During the initialization, FW passes can potentially be in any one of
2629  * several possible states. If the FW in operational, waiting-for-handshake
2630  * states, driver must take steps to bring it to ready state. Otherwise, it
2631  * has to wait for the ready state.
2632  */
2633 int
2634 megasas_transition_to_ready(struct megasas_instance *instance, int ocr)
2635 {
2636         int i;
2637         u8 max_wait;
2638         u32 fw_state;
2639         u32 cur_state;
2640         u32 abs_state, curr_abs_state;
2641
2642         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
2643
2644         if (fw_state != MFI_STATE_READY)
2645                 printk(KERN_INFO "megasas: Waiting for FW to come to ready"
2646                        " state\n");
2647
2648         while (fw_state != MFI_STATE_READY) {
2649
2650                 abs_state =
2651                 instance->instancet->read_fw_status_reg(instance->reg_set);
2652
2653                 switch (fw_state) {
2654
2655                 case MFI_STATE_FAULT:
2656                         printk(KERN_DEBUG "megasas: FW in FAULT state!!\n");
2657                         if (ocr) {
2658                                 max_wait = MEGASAS_RESET_WAIT_TIME;
2659                                 cur_state = MFI_STATE_FAULT;
2660                                 break;
2661                         } else
2662                                 return -ENODEV;
2663
2664                 case MFI_STATE_WAIT_HANDSHAKE:
2665                         /*
2666                          * Set the CLR bit in inbound doorbell
2667                          */
2668                         if ((instance->pdev->device ==
2669                                 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2670                                 (instance->pdev->device ==
2671                                  PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
2672                                 (instance->pdev->device ==
2673                                  PCI_DEVICE_ID_LSI_FUSION) ||
2674                                 (instance->pdev->device ==
2675                                 PCI_DEVICE_ID_LSI_INVADER)) {
2676                                 writel(
2677                                   MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
2678                                   &instance->reg_set->doorbell);
2679                         } else {
2680                                 writel(
2681                                     MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
2682                                         &instance->reg_set->inbound_doorbell);
2683                         }
2684
2685                         max_wait = MEGASAS_RESET_WAIT_TIME;
2686                         cur_state = MFI_STATE_WAIT_HANDSHAKE;
2687                         break;
2688
2689                 case MFI_STATE_BOOT_MESSAGE_PENDING:
2690                         if ((instance->pdev->device ==
2691                              PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2692                                 (instance->pdev->device ==
2693                                  PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
2694                             (instance->pdev->device ==
2695                              PCI_DEVICE_ID_LSI_FUSION) ||
2696                             (instance->pdev->device ==
2697                              PCI_DEVICE_ID_LSI_INVADER)) {
2698                                 writel(MFI_INIT_HOTPLUG,
2699                                        &instance->reg_set->doorbell);
2700                         } else
2701                                 writel(MFI_INIT_HOTPLUG,
2702                                         &instance->reg_set->inbound_doorbell);
2703
2704                         max_wait = MEGASAS_RESET_WAIT_TIME;
2705                         cur_state = MFI_STATE_BOOT_MESSAGE_PENDING;
2706                         break;
2707
2708                 case MFI_STATE_OPERATIONAL:
2709                         /*
2710                          * Bring it to READY state; assuming max wait 10 secs
2711                          */
2712                         instance->instancet->disable_intr(instance->reg_set);
2713                         if ((instance->pdev->device ==
2714                                 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2715                                 (instance->pdev->device ==
2716                                 PCI_DEVICE_ID_LSI_SAS0071SKINNY)  ||
2717                                 (instance->pdev->device
2718                                         == PCI_DEVICE_ID_LSI_FUSION) ||
2719                                 (instance->pdev->device
2720                                         == PCI_DEVICE_ID_LSI_INVADER)) {
2721                                 writel(MFI_RESET_FLAGS,
2722                                         &instance->reg_set->doorbell);
2723                                 if ((instance->pdev->device ==
2724                                     PCI_DEVICE_ID_LSI_FUSION) ||
2725                                     (instance->pdev->device ==
2726                                      PCI_DEVICE_ID_LSI_INVADER)) {
2727                                         for (i = 0; i < (10 * 1000); i += 20) {
2728                                                 if (readl(
2729                                                             &instance->
2730                                                             reg_set->
2731                                                             doorbell) & 1)
2732                                                         msleep(20);
2733                                                 else
2734                                                         break;
2735                                         }
2736                                 }
2737                         } else
2738                                 writel(MFI_RESET_FLAGS,
2739                                         &instance->reg_set->inbound_doorbell);
2740
2741                         max_wait = MEGASAS_RESET_WAIT_TIME;
2742                         cur_state = MFI_STATE_OPERATIONAL;
2743                         break;
2744
2745                 case MFI_STATE_UNDEFINED:
2746                         /*
2747                          * This state should not last for more than 2 seconds
2748                          */
2749                         max_wait = MEGASAS_RESET_WAIT_TIME;
2750                         cur_state = MFI_STATE_UNDEFINED;
2751                         break;
2752
2753                 case MFI_STATE_BB_INIT:
2754                         max_wait = MEGASAS_RESET_WAIT_TIME;
2755                         cur_state = MFI_STATE_BB_INIT;
2756                         break;
2757
2758                 case MFI_STATE_FW_INIT:
2759                         max_wait = MEGASAS_RESET_WAIT_TIME;
2760                         cur_state = MFI_STATE_FW_INIT;
2761                         break;
2762
2763                 case MFI_STATE_FW_INIT_2:
2764                         max_wait = MEGASAS_RESET_WAIT_TIME;
2765                         cur_state = MFI_STATE_FW_INIT_2;
2766                         break;
2767
2768                 case MFI_STATE_DEVICE_SCAN:
2769                         max_wait = MEGASAS_RESET_WAIT_TIME;
2770                         cur_state = MFI_STATE_DEVICE_SCAN;
2771                         break;
2772
2773                 case MFI_STATE_FLUSH_CACHE:
2774                         max_wait = MEGASAS_RESET_WAIT_TIME;
2775                         cur_state = MFI_STATE_FLUSH_CACHE;
2776                         break;
2777
2778                 default:
2779                         printk(KERN_DEBUG "megasas: Unknown state 0x%x\n",
2780                                fw_state);
2781                         return -ENODEV;
2782                 }
2783
2784                 /*
2785                  * The cur_state should not last for more than max_wait secs
2786                  */
2787                 for (i = 0; i < (max_wait * 1000); i++) {
2788                         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) &
2789                                         MFI_STATE_MASK ;
2790                 curr_abs_state =
2791                 instance->instancet->read_fw_status_reg(instance->reg_set);
2792
2793                         if (abs_state == curr_abs_state) {
2794                                 msleep(1);
2795                         } else
2796                                 break;
2797                 }
2798
2799                 /*
2800                  * Return error if fw_state hasn't changed after max_wait
2801                  */
2802                 if (curr_abs_state == abs_state) {
2803                         printk(KERN_DEBUG "FW state [%d] hasn't changed "
2804                                "in %d secs\n", fw_state, max_wait);
2805                         return -ENODEV;
2806                 }
2807         }
2808         printk(KERN_INFO "megasas: FW now in Ready state\n");
2809
2810         return 0;
2811 }
2812
2813 /**
2814  * megasas_teardown_frame_pool -        Destroy the cmd frame DMA pool
2815  * @instance:                           Adapter soft state
2816  */
2817 static void megasas_teardown_frame_pool(struct megasas_instance *instance)
2818 {
2819         int i;
2820         u32 max_cmd = instance->max_mfi_cmds;
2821         struct megasas_cmd *cmd;
2822
2823         if (!instance->frame_dma_pool)
2824                 return;
2825
2826         /*
2827          * Return all frames to pool
2828          */
2829         for (i = 0; i < max_cmd; i++) {
2830
2831                 cmd = instance->cmd_list[i];
2832
2833                 if (cmd->frame)
2834                         pci_pool_free(instance->frame_dma_pool, cmd->frame,
2835                                       cmd->frame_phys_addr);
2836
2837                 if (cmd->sense)
2838                         pci_pool_free(instance->sense_dma_pool, cmd->sense,
2839                                       cmd->sense_phys_addr);
2840         }
2841
2842         /*
2843          * Now destroy the pool itself
2844          */
2845         pci_pool_destroy(instance->frame_dma_pool);
2846         pci_pool_destroy(instance->sense_dma_pool);
2847
2848         instance->frame_dma_pool = NULL;
2849         instance->sense_dma_pool = NULL;
2850 }
2851
2852 /**
2853  * megasas_create_frame_pool -  Creates DMA pool for cmd frames
2854  * @instance:                   Adapter soft state
2855  *
2856  * Each command packet has an embedded DMA memory buffer that is used for
2857  * filling MFI frame and the SG list that immediately follows the frame. This
2858  * function creates those DMA memory buffers for each command packet by using
2859  * PCI pool facility.
2860  */
2861 static int megasas_create_frame_pool(struct megasas_instance *instance)
2862 {
2863         int i;
2864         u32 max_cmd;
2865         u32 sge_sz;
2866         u32 sgl_sz;
2867         u32 total_sz;
2868         u32 frame_count;
2869         struct megasas_cmd *cmd;
2870
2871         max_cmd = instance->max_mfi_cmds;
2872
2873         /*
2874          * Size of our frame is 64 bytes for MFI frame, followed by max SG
2875          * elements and finally SCSI_SENSE_BUFFERSIZE bytes for sense buffer
2876          */
2877         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
2878             sizeof(struct megasas_sge32);
2879
2880         if (instance->flag_ieee) {
2881                 sge_sz = sizeof(struct megasas_sge_skinny);
2882         }
2883
2884         /*
2885          * Calculated the number of 64byte frames required for SGL
2886          */
2887         sgl_sz = sge_sz * instance->max_num_sge;
2888         frame_count = (sgl_sz + MEGAMFI_FRAME_SIZE - 1) / MEGAMFI_FRAME_SIZE;
2889         frame_count = 15;
2890
2891         /*
2892          * We need one extra frame for the MFI command
2893          */
2894         frame_count++;
2895
2896         total_sz = MEGAMFI_FRAME_SIZE * frame_count;
2897         /*
2898          * Use DMA pool facility provided by PCI layer
2899          */
2900         instance->frame_dma_pool = pci_pool_create("megasas frame pool",
2901                                                    instance->pdev, total_sz, 64,
2902                                                    0);
2903
2904         if (!instance->frame_dma_pool) {
2905                 printk(KERN_DEBUG "megasas: failed to setup frame pool\n");
2906                 return -ENOMEM;
2907         }
2908
2909         instance->sense_dma_pool = pci_pool_create("megasas sense pool",
2910                                                    instance->pdev, 128, 4, 0);
2911
2912         if (!instance->sense_dma_pool) {
2913                 printk(KERN_DEBUG "megasas: failed to setup sense pool\n");
2914
2915                 pci_pool_destroy(instance->frame_dma_pool);
2916                 instance->frame_dma_pool = NULL;
2917
2918                 return -ENOMEM;
2919         }
2920
2921         /*
2922          * Allocate and attach a frame to each of the commands in cmd_list.
2923          * By making cmd->index as the context instead of the &cmd, we can
2924          * always use 32bit context regardless of the architecture
2925          */
2926         for (i = 0; i < max_cmd; i++) {
2927
2928                 cmd = instance->cmd_list[i];
2929
2930                 cmd->frame = pci_pool_alloc(instance->frame_dma_pool,
2931                                             GFP_KERNEL, &cmd->frame_phys_addr);
2932
2933                 cmd->sense = pci_pool_alloc(instance->sense_dma_pool,
2934                                             GFP_KERNEL, &cmd->sense_phys_addr);
2935
2936                 /*
2937                  * megasas_teardown_frame_pool() takes care of freeing
2938                  * whatever has been allocated
2939                  */
2940                 if (!cmd->frame || !cmd->sense) {
2941                         printk(KERN_DEBUG "megasas: pci_pool_alloc failed \n");
2942                         megasas_teardown_frame_pool(instance);
2943                         return -ENOMEM;
2944                 }
2945
2946                 memset(cmd->frame, 0, total_sz);
2947                 cmd->frame->io.context = cmd->index;
2948                 cmd->frame->io.pad_0 = 0;
2949                 if ((instance->pdev->device != PCI_DEVICE_ID_LSI_FUSION) &&
2950                     (instance->pdev->device != PCI_DEVICE_ID_LSI_INVADER) &&
2951                     (reset_devices))
2952                         cmd->frame->hdr.cmd = MFI_CMD_INVALID;
2953         }
2954
2955         return 0;
2956 }
2957
2958 /**
2959  * megasas_free_cmds -  Free all the cmds in the free cmd pool
2960  * @instance:           Adapter soft state
2961  */
2962 void megasas_free_cmds(struct megasas_instance *instance)
2963 {
2964         int i;
2965         /* First free the MFI frame pool */
2966         megasas_teardown_frame_pool(instance);
2967
2968         /* Free all the commands in the cmd_list */
2969         for (i = 0; i < instance->max_mfi_cmds; i++)
2970
2971                 kfree(instance->cmd_list[i]);
2972
2973         /* Free the cmd_list buffer itself */
2974         kfree(instance->cmd_list);
2975         instance->cmd_list = NULL;
2976
2977         INIT_LIST_HEAD(&instance->cmd_pool);
2978 }
2979
2980 /**
2981  * megasas_alloc_cmds - Allocates the command packets
2982  * @instance:           Adapter soft state
2983  *
2984  * Each command that is issued to the FW, whether IO commands from the OS or
2985  * internal commands like IOCTLs, are wrapped in local data structure called
2986  * megasas_cmd. The frame embedded in this megasas_cmd is actually issued to
2987  * the FW.
2988  *
2989  * Each frame has a 32-bit field called context (tag). This context is used
2990  * to get back the megasas_cmd from the frame when a frame gets completed in
2991  * the ISR. Typically the address of the megasas_cmd itself would be used as
2992  * the context. But we wanted to keep the differences between 32 and 64 bit
2993  * systems to the mininum. We always use 32 bit integers for the context. In
2994  * this driver, the 32 bit values are the indices into an array cmd_list.
2995  * This array is used only to look up the megasas_cmd given the context. The
2996  * free commands themselves are maintained in a linked list called cmd_pool.
2997  */
2998 int megasas_alloc_cmds(struct megasas_instance *instance)
2999 {
3000         int i;
3001         int j;
3002         u32 max_cmd;
3003         struct megasas_cmd *cmd;
3004
3005         max_cmd = instance->max_mfi_cmds;
3006
3007         /*
3008          * instance->cmd_list is an array of struct megasas_cmd pointers.
3009          * Allocate the dynamic array first and then allocate individual
3010          * commands.
3011          */
3012         instance->cmd_list = kcalloc(max_cmd, sizeof(struct megasas_cmd*), GFP_KERNEL);
3013
3014         if (!instance->cmd_list) {
3015                 printk(KERN_DEBUG "megasas: out of memory\n");
3016                 return -ENOMEM;
3017         }
3018
3019         memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) *max_cmd);
3020
3021         for (i = 0; i < max_cmd; i++) {
3022                 instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
3023                                                 GFP_KERNEL);
3024
3025                 if (!instance->cmd_list[i]) {
3026
3027                         for (j = 0; j < i; j++)
3028                                 kfree(instance->cmd_list[j]);
3029
3030                         kfree(instance->cmd_list);
3031                         instance->cmd_list = NULL;
3032
3033                         return -ENOMEM;
3034                 }
3035         }
3036
3037         /*
3038          * Add all the commands to command pool (instance->cmd_pool)
3039          */
3040         for (i = 0; i < max_cmd; i++) {
3041                 cmd = instance->cmd_list[i];
3042                 memset(cmd, 0, sizeof(struct megasas_cmd));
3043                 cmd->index = i;
3044                 cmd->scmd = NULL;
3045                 cmd->instance = instance;
3046
3047                 list_add_tail(&cmd->list, &instance->cmd_pool);
3048         }
3049
3050         /*
3051          * Create a frame pool and assign one frame to each cmd
3052          */
3053         if (megasas_create_frame_pool(instance)) {
3054                 printk(KERN_DEBUG "megasas: Error creating frame DMA pool\n");
3055                 megasas_free_cmds(instance);
3056         }
3057
3058         return 0;
3059 }
3060
3061 /*
3062  * megasas_get_pd_list_info -   Returns FW's pd_list structure
3063  * @instance:                           Adapter soft state
3064  * @pd_list:                            pd_list structure
3065  *
3066  * Issues an internal command (DCMD) to get the FW's controller PD
3067  * list structure.  This information is mainly used to find out SYSTEM
3068  * supported by the FW.
3069  */
3070 static int
3071 megasas_get_pd_list(struct megasas_instance *instance)
3072 {
3073         int ret = 0, pd_index = 0;
3074         struct megasas_cmd *cmd;
3075         struct megasas_dcmd_frame *dcmd;
3076         struct MR_PD_LIST *ci;
3077         struct MR_PD_ADDRESS *pd_addr;
3078         dma_addr_t ci_h = 0;
3079
3080         cmd = megasas_get_cmd(instance);
3081
3082         if (!cmd) {
3083                 printk(KERN_DEBUG "megasas (get_pd_list): Failed to get cmd\n");
3084                 return -ENOMEM;
3085         }
3086
3087         dcmd = &cmd->frame->dcmd;
3088
3089         ci = pci_alloc_consistent(instance->pdev,
3090                   MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST), &ci_h);
3091
3092         if (!ci) {
3093                 printk(KERN_DEBUG "Failed to alloc mem for pd_list\n");
3094                 megasas_return_cmd(instance, cmd);
3095                 return -ENOMEM;
3096         }
3097
3098         memset(ci, 0, sizeof(*ci));
3099         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3100
3101         dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;
3102         dcmd->mbox.b[1] = 0;
3103         dcmd->cmd = MFI_CMD_DCMD;
3104         dcmd->cmd_status = 0xFF;
3105         dcmd->sge_count = 1;
3106         dcmd->flags = MFI_FRAME_DIR_READ;
3107         dcmd->timeout = 0;
3108         dcmd->pad_0 = 0;
3109         dcmd->data_xfer_len = MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST);
3110         dcmd->opcode = MR_DCMD_PD_LIST_QUERY;
3111         dcmd->sgl.sge32[0].phys_addr = ci_h;
3112         dcmd->sgl.sge32[0].length = MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST);
3113
3114         if (!megasas_issue_polled(instance, cmd)) {
3115                 ret = 0;
3116         } else {
3117                 ret = -1;
3118         }
3119
3120         /*
3121         * the following function will get the instance PD LIST.
3122         */
3123
3124         pd_addr = ci->addr;
3125
3126         if ( ret == 0 &&
3127                 (ci->count <
3128                   (MEGASAS_MAX_PD_CHANNELS * MEGASAS_MAX_DEV_PER_CHANNEL))) {
3129
3130                 memset(instance->pd_list, 0,
3131                         MEGASAS_MAX_PD * sizeof(struct megasas_pd_list));
3132
3133                 for (pd_index = 0; pd_index < ci->count; pd_index++) {
3134
3135                         instance->pd_list[pd_addr->deviceId].tid        =
3136                                                         pd_addr->deviceId;
3137                         instance->pd_list[pd_addr->deviceId].driveType  =
3138                                                         pd_addr->scsiDevType;
3139                         instance->pd_list[pd_addr->deviceId].driveState =
3140                                                         MR_PD_STATE_SYSTEM;
3141                         pd_addr++;
3142                 }
3143         }
3144
3145         pci_free_consistent(instance->pdev,
3146                                 MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
3147                                 ci, ci_h);
3148         megasas_return_cmd(instance, cmd);
3149
3150         return ret;
3151 }
3152
3153 /*
3154  * megasas_get_ld_list_info -   Returns FW's ld_list structure
3155  * @instance:                           Adapter soft state
3156  * @ld_list:                            ld_list structure
3157  *
3158  * Issues an internal command (DCMD) to get the FW's controller PD
3159  * list structure.  This information is mainly used to find out SYSTEM
3160  * supported by the FW.
3161  */
3162 static int
3163 megasas_get_ld_list(struct megasas_instance *instance)
3164 {
3165         int ret = 0, ld_index = 0, ids = 0;
3166         struct megasas_cmd *cmd;
3167         struct megasas_dcmd_frame *dcmd;
3168         struct MR_LD_LIST *ci;
3169         dma_addr_t ci_h = 0;
3170
3171         cmd = megasas_get_cmd(instance);
3172
3173         if (!cmd) {
3174                 printk(KERN_DEBUG "megasas_get_ld_list: Failed to get cmd\n");
3175                 return -ENOMEM;
3176         }
3177
3178         dcmd = &cmd->frame->dcmd;
3179
3180         ci = pci_alloc_consistent(instance->pdev,
3181                                 sizeof(struct MR_LD_LIST),
3182                                 &ci_h);
3183
3184         if (!ci) {
3185                 printk(KERN_DEBUG "Failed to alloc mem in get_ld_list\n");
3186                 megasas_return_cmd(instance, cmd);
3187                 return -ENOMEM;
3188         }
3189
3190         memset(ci, 0, sizeof(*ci));
3191         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3192
3193         dcmd->cmd = MFI_CMD_DCMD;
3194         dcmd->cmd_status = 0xFF;
3195         dcmd->sge_count = 1;
3196         dcmd->flags = MFI_FRAME_DIR_READ;
3197         dcmd->timeout = 0;
3198         dcmd->data_xfer_len = sizeof(struct MR_LD_LIST);
3199         dcmd->opcode = MR_DCMD_LD_GET_LIST;
3200         dcmd->sgl.sge32[0].phys_addr = ci_h;
3201         dcmd->sgl.sge32[0].length = sizeof(struct MR_LD_LIST);
3202         dcmd->pad_0  = 0;
3203
3204         if (!megasas_issue_polled(instance, cmd)) {
3205                 ret = 0;
3206         } else {
3207                 ret = -1;
3208         }
3209
3210         /* the following function will get the instance PD LIST */
3211
3212         if ((ret == 0) && (ci->ldCount <= MAX_LOGICAL_DRIVES)) {
3213                 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
3214
3215                 for (ld_index = 0; ld_index < ci->ldCount; ld_index++) {
3216                         if (ci->ldList[ld_index].state != 0) {
3217                                 ids = ci->ldList[ld_index].ref.targetId;
3218                                 instance->ld_ids[ids] =
3219                                         ci->ldList[ld_index].ref.targetId;
3220                         }
3221                 }
3222         }
3223
3224         pci_free_consistent(instance->pdev,
3225                                 sizeof(struct MR_LD_LIST),
3226                                 ci,
3227                                 ci_h);
3228
3229         megasas_return_cmd(instance, cmd);
3230         return ret;
3231 }
3232
3233 /**
3234  * megasas_get_controller_info -        Returns FW's controller structure
3235  * @instance:                           Adapter soft state
3236  * @ctrl_info:                          Controller information structure
3237  *
3238  * Issues an internal command (DCMD) to get the FW's controller structure.
3239  * This information is mainly used to find out the maximum IO transfer per
3240  * command supported by the FW.
3241  */
3242 static int
3243 megasas_get_ctrl_info(struct megasas_instance *instance,
3244                       struct megasas_ctrl_info *ctrl_info)
3245 {
3246         int ret = 0;
3247         struct megasas_cmd *cmd;
3248         struct megasas_dcmd_frame *dcmd;
3249         struct megasas_ctrl_info *ci;
3250         dma_addr_t ci_h = 0;
3251
3252         cmd = megasas_get_cmd(instance);
3253
3254         if (!cmd) {
3255                 printk(KERN_DEBUG "megasas: Failed to get a free cmd\n");
3256                 return -ENOMEM;
3257         }
3258
3259         dcmd = &cmd->frame->dcmd;
3260
3261         ci = pci_alloc_consistent(instance->pdev,
3262                                   sizeof(struct megasas_ctrl_info), &ci_h);
3263
3264         if (!ci) {
3265                 printk(KERN_DEBUG "Failed to alloc mem for ctrl info\n");
3266                 megasas_return_cmd(instance, cmd);
3267                 return -ENOMEM;
3268         }
3269
3270         memset(ci, 0, sizeof(*ci));
3271         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3272
3273         dcmd->cmd = MFI_CMD_DCMD;
3274         dcmd->cmd_status = 0xFF;
3275         dcmd->sge_count = 1;
3276         dcmd->flags = MFI_FRAME_DIR_READ;
3277         dcmd->timeout = 0;
3278         dcmd->pad_0 = 0;
3279         dcmd->data_xfer_len = sizeof(struct megasas_ctrl_info);
3280         dcmd->opcode = MR_DCMD_CTRL_GET_INFO;
3281         dcmd->sgl.sge32[0].phys_addr = ci_h;
3282         dcmd->sgl.sge32[0].length = sizeof(struct megasas_ctrl_info);
3283
3284         if (!megasas_issue_polled(instance, cmd)) {
3285                 ret = 0;
3286                 memcpy(ctrl_info, ci, sizeof(struct megasas_ctrl_info));
3287         } else {
3288                 ret = -1;
3289         }
3290
3291         pci_free_consistent(instance->pdev, sizeof(struct megasas_ctrl_info),
3292                             ci, ci_h);
3293
3294         megasas_return_cmd(instance, cmd);
3295         return ret;
3296 }
3297
3298 /**
3299  * megasas_issue_init_mfi -     Initializes the FW
3300  * @instance:           Adapter soft state
3301  *
3302  * Issues the INIT MFI cmd
3303  */
3304 static int
3305 megasas_issue_init_mfi(struct megasas_instance *instance)
3306 {
3307         u32 context;
3308
3309         struct megasas_cmd *cmd;
3310
3311         struct megasas_init_frame *init_frame;
3312         struct megasas_init_queue_info *initq_info;
3313         dma_addr_t init_frame_h;
3314         dma_addr_t initq_info_h;
3315
3316         /*
3317          * Prepare a init frame. Note the init frame points to queue info
3318          * structure. Each frame has SGL allocated after first 64 bytes. For
3319          * this frame - since we don't need any SGL - we use SGL's space as
3320          * queue info structure
3321          *
3322          * We will not get a NULL command below. We just created the pool.
3323          */
3324         cmd = megasas_get_cmd(instance);
3325
3326         init_frame = (struct megasas_init_frame *)cmd->frame;
3327         initq_info = (struct megasas_init_queue_info *)
3328                 ((unsigned long)init_frame + 64);
3329
3330         init_frame_h = cmd->frame_phys_addr;
3331         initq_info_h = init_frame_h + 64;
3332
3333         context = init_frame->context;
3334         memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
3335         memset(initq_info, 0, sizeof(struct megasas_init_queue_info));
3336         init_frame->context = context;
3337
3338         initq_info->reply_queue_entries = instance->max_fw_cmds + 1;
3339         initq_info->reply_queue_start_phys_addr_lo = instance->reply_queue_h;
3340
3341         initq_info->producer_index_phys_addr_lo = instance->producer_h;
3342         initq_info->consumer_index_phys_addr_lo = instance->consumer_h;
3343
3344         init_frame->cmd = MFI_CMD_INIT;
3345         init_frame->cmd_status = 0xFF;
3346         init_frame->queue_info_new_phys_addr_lo = initq_info_h;
3347
3348         init_frame->data_xfer_len = sizeof(struct megasas_init_queue_info);
3349
3350         /*
3351          * disable the intr before firing the init frame to FW
3352          */
3353         instance->instancet->disable_intr(instance->reg_set);
3354
3355         /*
3356          * Issue the init frame in polled mode
3357          */
3358
3359         if (megasas_issue_polled(instance, cmd)) {
3360                 printk(KERN_ERR "megasas: Failed to init firmware\n");
3361                 megasas_return_cmd(instance, cmd);
3362                 goto fail_fw_init;
3363         }
3364
3365         megasas_return_cmd(instance, cmd);
3366
3367         return 0;
3368
3369 fail_fw_init:
3370         return -EINVAL;
3371 }
3372
3373 /**
3374  * megasas_start_timer - Initializes a timer object
3375  * @instance:           Adapter soft state
3376  * @timer:              timer object to be initialized
3377  * @fn:                 timer function
3378  * @interval:           time interval between timer function call
3379  */
3380 static inline void
3381 megasas_start_timer(struct megasas_instance *instance,
3382                         struct timer_list *timer,
3383                         void *fn, unsigned long interval)
3384 {
3385         init_timer(timer);
3386         timer->expires = jiffies + interval;
3387         timer->data = (unsigned long)instance;
3388         timer->function = fn;
3389         add_timer(timer);
3390 }
3391
3392 /**
3393  * megasas_io_completion_timer - Timer fn
3394  * @instance_addr:      Address of adapter soft state
3395  *
3396  * Schedules tasklet for cmd completion
3397  * if poll_mode_io is set
3398  */
3399 static void
3400 megasas_io_completion_timer(unsigned long instance_addr)
3401 {
3402         struct megasas_instance *instance =
3403                         (struct megasas_instance *)instance_addr;
3404
3405         if (atomic_read(&instance->fw_outstanding))
3406                 tasklet_schedule(&instance->isr_tasklet);
3407
3408         /* Restart timer */
3409         if (poll_mode_io)
3410                 mod_timer(&instance->io_completion_timer,
3411                         jiffies + MEGASAS_COMPLETION_TIMER_INTERVAL);
3412 }
3413
3414 static u32
3415 megasas_init_adapter_mfi(struct megasas_instance *instance)
3416 {
3417         struct megasas_register_set __iomem *reg_set;
3418         u32 context_sz;
3419         u32 reply_q