Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/pci-2.6
[linux-2.6] / drivers / scsi / megaraid / megaraid_sas.c
1 /*
2  *
3  *              Linux MegaRAID driver for SAS based RAID controllers
4  *
5  * Copyright (c) 2003-2005  LSI Logic Corporation.
6  *
7  *         This program is free software; you can redistribute it and/or
8  *         modify it under the terms of the GNU General Public License
9  *         as published by the Free Software Foundation; either version
10  *         2 of the License, or (at your option) any later version.
11  *
12  * FILE         : megaraid_sas.c
13  * Version      : v00.00.03.10-rc1
14  *
15  * Authors:
16  *      (email-id : megaraidlinux@lsi.com)
17  *      Sreenivas Bagalkote
18  *      Sumant Patro
19  *      Bo Yang
20  *
21  * List of supported controllers
22  *
23  * OEM  Product Name                    VID     DID     SSVID   SSID
24  * ---  ------------                    ---     ---     ----    ----
25  */
26
27 #include <linux/kernel.h>
28 #include <linux/types.h>
29 #include <linux/pci.h>
30 #include <linux/list.h>
31 #include <linux/moduleparam.h>
32 #include <linux/module.h>
33 #include <linux/spinlock.h>
34 #include <linux/interrupt.h>
35 #include <linux/delay.h>
36 #include <linux/uio.h>
37 #include <asm/uaccess.h>
38 #include <linux/fs.h>
39 #include <linux/compat.h>
40 #include <linux/blkdev.h>
41 #include <linux/mutex.h>
42
43 #include <scsi/scsi.h>
44 #include <scsi/scsi_cmnd.h>
45 #include <scsi/scsi_device.h>
46 #include <scsi/scsi_host.h>
47 #include "megaraid_sas.h"
48
49 MODULE_LICENSE("GPL");
50 MODULE_VERSION(MEGASAS_VERSION);
51 MODULE_AUTHOR("megaraidlinux@lsi.com");
52 MODULE_DESCRIPTION("LSI Logic MegaRAID SAS Driver");
53
54 /*
55  * PCI ID table for all supported controllers
56  */
57 static struct pci_device_id megasas_pci_table[] = {
58
59         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064R)},
60         /* xscale IOP */
61         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078R)},
62         /* ppc IOP */
63         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VERDE_ZCR)},
64         /* xscale IOP, vega */
65         {PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)},
66         /* xscale IOP */
67         {}
68 };
69
70 MODULE_DEVICE_TABLE(pci, megasas_pci_table);
71
72 static int megasas_mgmt_majorno;
73 static struct megasas_mgmt_info megasas_mgmt_info;
74 static struct fasync_struct *megasas_async_queue;
75 static DEFINE_MUTEX(megasas_async_queue_mutex);
76
77 static u32 megasas_dbg_lvl;
78
79 /**
80  * megasas_get_cmd -    Get a command from the free pool
81  * @instance:           Adapter soft state
82  *
83  * Returns a free command from the pool
84  */
85 static struct megasas_cmd *megasas_get_cmd(struct megasas_instance
86                                                   *instance)
87 {
88         unsigned long flags;
89         struct megasas_cmd *cmd = NULL;
90
91         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
92
93         if (!list_empty(&instance->cmd_pool)) {
94                 cmd = list_entry((&instance->cmd_pool)->next,
95                                  struct megasas_cmd, list);
96                 list_del_init(&cmd->list);
97         } else {
98                 printk(KERN_ERR "megasas: Command pool empty!\n");
99         }
100
101         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
102         return cmd;
103 }
104
105 /**
106  * megasas_return_cmd - Return a cmd to free command pool
107  * @instance:           Adapter soft state
108  * @cmd:                Command packet to be returned to free command pool
109  */
110 static inline void
111 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
112 {
113         unsigned long flags;
114
115         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
116
117         cmd->scmd = NULL;
118         list_add_tail(&cmd->list, &instance->cmd_pool);
119
120         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
121 }
122
123
124 /**
125 *       The following functions are defined for xscale 
126 *       (deviceid : 1064R, PERC5) controllers
127 */
128
129 /**
130  * megasas_enable_intr_xscale - Enables interrupts
131  * @regs:                       MFI register set
132  */
133 static inline void
134 megasas_enable_intr_xscale(struct megasas_register_set __iomem * regs)
135 {
136         writel(1, &(regs)->outbound_intr_mask);
137
138         /* Dummy readl to force pci flush */
139         readl(&regs->outbound_intr_mask);
140 }
141
142 /**
143  * megasas_disable_intr_xscale -Disables interrupt
144  * @regs:                       MFI register set
145  */
146 static inline void
147 megasas_disable_intr_xscale(struct megasas_register_set __iomem * regs)
148 {
149         u32 mask = 0x1f;
150         writel(mask, &regs->outbound_intr_mask);
151         /* Dummy readl to force pci flush */
152         readl(&regs->outbound_intr_mask);
153 }
154
155 /**
156  * megasas_read_fw_status_reg_xscale - returns the current FW status value
157  * @regs:                       MFI register set
158  */
159 static u32
160 megasas_read_fw_status_reg_xscale(struct megasas_register_set __iomem * regs)
161 {
162         return readl(&(regs)->outbound_msg_0);
163 }
164 /**
165  * megasas_clear_interrupt_xscale -     Check & clear interrupt
166  * @regs:                               MFI register set
167  */
168 static int 
169 megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs)
170 {
171         u32 status;
172         /*
173          * Check if it is our interrupt
174          */
175         status = readl(&regs->outbound_intr_status);
176
177         if (!(status & MFI_OB_INTR_STATUS_MASK)) {
178                 return 1;
179         }
180
181         /*
182          * Clear the interrupt by writing back the same value
183          */
184         writel(status, &regs->outbound_intr_status);
185
186         return 0;
187 }
188
189 /**
190  * megasas_fire_cmd_xscale -    Sends command to the FW
191  * @frame_phys_addr :           Physical address of cmd
192  * @frame_count :               Number of frames for the command
193  * @regs :                      MFI register set
194  */
195 static inline void 
196 megasas_fire_cmd_xscale(dma_addr_t frame_phys_addr,u32 frame_count, struct megasas_register_set __iomem *regs)
197 {
198         writel((frame_phys_addr >> 3)|(frame_count),
199                &(regs)->inbound_queue_port);
200 }
201
202 static struct megasas_instance_template megasas_instance_template_xscale = {
203
204         .fire_cmd = megasas_fire_cmd_xscale,
205         .enable_intr = megasas_enable_intr_xscale,
206         .disable_intr = megasas_disable_intr_xscale,
207         .clear_intr = megasas_clear_intr_xscale,
208         .read_fw_status_reg = megasas_read_fw_status_reg_xscale,
209 };
210
211 /**
212 *       This is the end of set of functions & definitions specific 
213 *       to xscale (deviceid : 1064R, PERC5) controllers
214 */
215
216 /**
217 *       The following functions are defined for ppc (deviceid : 0x60) 
218 *       controllers
219 */
220
221 /**
222  * megasas_enable_intr_ppc -    Enables interrupts
223  * @regs:                       MFI register set
224  */
225 static inline void
226 megasas_enable_intr_ppc(struct megasas_register_set __iomem * regs)
227 {
228         writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
229     
230         writel(~0x80000004, &(regs)->outbound_intr_mask);
231
232         /* Dummy readl to force pci flush */
233         readl(&regs->outbound_intr_mask);
234 }
235
236 /**
237  * megasas_disable_intr_ppc -   Disable interrupt
238  * @regs:                       MFI register set
239  */
240 static inline void
241 megasas_disable_intr_ppc(struct megasas_register_set __iomem * regs)
242 {
243         u32 mask = 0xFFFFFFFF;
244         writel(mask, &regs->outbound_intr_mask);
245         /* Dummy readl to force pci flush */
246         readl(&regs->outbound_intr_mask);
247 }
248
249 /**
250  * megasas_read_fw_status_reg_ppc - returns the current FW status value
251  * @regs:                       MFI register set
252  */
253 static u32
254 megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem * regs)
255 {
256         return readl(&(regs)->outbound_scratch_pad);
257 }
258
259 /**
260  * megasas_clear_interrupt_ppc -        Check & clear interrupt
261  * @regs:                               MFI register set
262  */
263 static int 
264 megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
265 {
266         u32 status;
267         /*
268          * Check if it is our interrupt
269          */
270         status = readl(&regs->outbound_intr_status);
271
272         if (!(status & MFI_REPLY_1078_MESSAGE_INTERRUPT)) {
273                 return 1;
274         }
275
276         /*
277          * Clear the interrupt by writing back the same value
278          */
279         writel(status, &regs->outbound_doorbell_clear);
280
281         return 0;
282 }
283 /**
284  * megasas_fire_cmd_ppc -       Sends command to the FW
285  * @frame_phys_addr :           Physical address of cmd
286  * @frame_count :               Number of frames for the command
287  * @regs :                      MFI register set
288  */
289 static inline void 
290 megasas_fire_cmd_ppc(dma_addr_t frame_phys_addr, u32 frame_count, struct megasas_register_set __iomem *regs)
291 {
292         writel((frame_phys_addr | (frame_count<<1))|1, 
293                         &(regs)->inbound_queue_port);
294 }
295
296 static struct megasas_instance_template megasas_instance_template_ppc = {
297         
298         .fire_cmd = megasas_fire_cmd_ppc,
299         .enable_intr = megasas_enable_intr_ppc,
300         .disable_intr = megasas_disable_intr_ppc,
301         .clear_intr = megasas_clear_intr_ppc,
302         .read_fw_status_reg = megasas_read_fw_status_reg_ppc,
303 };
304
305 /**
306 *       This is the end of set of functions & definitions
307 *       specific to ppc (deviceid : 0x60) controllers
308 */
309
310 /**
311  * megasas_issue_polled -       Issues a polling command
312  * @instance:                   Adapter soft state
313  * @cmd:                        Command packet to be issued 
314  *
315  * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
316  */
317 static int
318 megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
319 {
320         int i;
321         u32 msecs = MFI_POLL_TIMEOUT_SECS * 1000;
322
323         struct megasas_header *frame_hdr = &cmd->frame->hdr;
324
325         frame_hdr->cmd_status = 0xFF;
326         frame_hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
327
328         /*
329          * Issue the frame using inbound queue port
330          */
331         instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
332
333         /*
334          * Wait for cmd_status to change
335          */
336         for (i = 0; (i < msecs) && (frame_hdr->cmd_status == 0xff); i++) {
337                 rmb();
338                 msleep(1);
339         }
340
341         if (frame_hdr->cmd_status == 0xff)
342                 return -ETIME;
343
344         return 0;
345 }
346
347 /**
348  * megasas_issue_blocked_cmd -  Synchronous wrapper around regular FW cmds
349  * @instance:                   Adapter soft state
350  * @cmd:                        Command to be issued
351  *
352  * This function waits on an event for the command to be returned from ISR.
353  * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
354  * Used to issue ioctl commands.
355  */
356 static int
357 megasas_issue_blocked_cmd(struct megasas_instance *instance,
358                           struct megasas_cmd *cmd)
359 {
360         cmd->cmd_status = ENODATA;
361
362         instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
363
364         wait_event_timeout(instance->int_cmd_wait_q, (cmd->cmd_status != ENODATA),
365                 MEGASAS_INTERNAL_CMD_WAIT_TIME*HZ);
366
367         return 0;
368 }
369
370 /**
371  * megasas_issue_blocked_abort_cmd -    Aborts previously issued cmd
372  * @instance:                           Adapter soft state
373  * @cmd_to_abort:                       Previously issued cmd to be aborted
374  *
375  * MFI firmware can abort previously issued AEN comamnd (automatic event
376  * notification). The megasas_issue_blocked_abort_cmd() issues such abort
377  * cmd and waits for return status.
378  * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
379  */
380 static int
381 megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
382                                 struct megasas_cmd *cmd_to_abort)
383 {
384         struct megasas_cmd *cmd;
385         struct megasas_abort_frame *abort_fr;
386
387         cmd = megasas_get_cmd(instance);
388
389         if (!cmd)
390                 return -1;
391
392         abort_fr = &cmd->frame->abort;
393
394         /*
395          * Prepare and issue the abort frame
396          */
397         abort_fr->cmd = MFI_CMD_ABORT;
398         abort_fr->cmd_status = 0xFF;
399         abort_fr->flags = 0;
400         abort_fr->abort_context = cmd_to_abort->index;
401         abort_fr->abort_mfi_phys_addr_lo = cmd_to_abort->frame_phys_addr;
402         abort_fr->abort_mfi_phys_addr_hi = 0;
403
404         cmd->sync_cmd = 1;
405         cmd->cmd_status = 0xFF;
406
407         instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
408
409         /*
410          * Wait for this cmd to complete
411          */
412         wait_event_timeout(instance->abort_cmd_wait_q, (cmd->cmd_status != 0xFF),
413                 MEGASAS_INTERNAL_CMD_WAIT_TIME*HZ);
414
415         megasas_return_cmd(instance, cmd);
416         return 0;
417 }
418
419 /**
420  * megasas_make_sgl32 - Prepares 32-bit SGL
421  * @instance:           Adapter soft state
422  * @scp:                SCSI command from the mid-layer
423  * @mfi_sgl:            SGL to be filled in
424  *
425  * If successful, this function returns the number of SG elements. Otherwise,
426  * it returnes -1.
427  */
428 static int
429 megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
430                    union megasas_sgl *mfi_sgl)
431 {
432         int i;
433         int sge_count;
434         struct scatterlist *os_sgl;
435
436         /*
437          * Return 0 if there is no data transfer
438          */
439         if (!scp->request_buffer || !scp->request_bufflen)
440                 return 0;
441
442         if (!scp->use_sg) {
443                 mfi_sgl->sge32[0].phys_addr = pci_map_single(instance->pdev,
444                                                              scp->
445                                                              request_buffer,
446                                                              scp->
447                                                              request_bufflen,
448                                                              scp->
449                                                              sc_data_direction);
450                 mfi_sgl->sge32[0].length = scp->request_bufflen;
451
452                 return 1;
453         }
454
455         os_sgl = (struct scatterlist *)scp->request_buffer;
456         sge_count = pci_map_sg(instance->pdev, os_sgl, scp->use_sg,
457                                scp->sc_data_direction);
458
459         for (i = 0; i < sge_count; i++, os_sgl++) {
460                 mfi_sgl->sge32[i].length = sg_dma_len(os_sgl);
461                 mfi_sgl->sge32[i].phys_addr = sg_dma_address(os_sgl);
462         }
463
464         return sge_count;
465 }
466
467 /**
468  * megasas_make_sgl64 - Prepares 64-bit SGL
469  * @instance:           Adapter soft state
470  * @scp:                SCSI command from the mid-layer
471  * @mfi_sgl:            SGL to be filled in
472  *
473  * If successful, this function returns the number of SG elements. Otherwise,
474  * it returnes -1.
475  */
476 static int
477 megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
478                    union megasas_sgl *mfi_sgl)
479 {
480         int i;
481         int sge_count;
482         struct scatterlist *os_sgl;
483
484         /*
485          * Return 0 if there is no data transfer
486          */
487         if (!scp->request_buffer || !scp->request_bufflen)
488                 return 0;
489
490         if (!scp->use_sg) {
491                 mfi_sgl->sge64[0].phys_addr = pci_map_single(instance->pdev,
492                                                              scp->
493                                                              request_buffer,
494                                                              scp->
495                                                              request_bufflen,
496                                                              scp->
497                                                              sc_data_direction);
498
499                 mfi_sgl->sge64[0].length = scp->request_bufflen;
500
501                 return 1;
502         }
503
504         os_sgl = (struct scatterlist *)scp->request_buffer;
505         sge_count = pci_map_sg(instance->pdev, os_sgl, scp->use_sg,
506                                scp->sc_data_direction);
507
508         for (i = 0; i < sge_count; i++, os_sgl++) {
509                 mfi_sgl->sge64[i].length = sg_dma_len(os_sgl);
510                 mfi_sgl->sge64[i].phys_addr = sg_dma_address(os_sgl);
511         }
512
513         return sge_count;
514 }
515
516  /**
517  * megasas_get_frame_count - Computes the number of frames
518  * @sge_count           : number of sg elements
519  *
520  * Returns the number of frames required for numnber of sge's (sge_count)
521  */
522
523 static u32 megasas_get_frame_count(u8 sge_count)
524 {
525         int num_cnt;
526         int sge_bytes;
527         u32 sge_sz;
528         u32 frame_count=0;
529
530         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
531             sizeof(struct megasas_sge32);
532
533         /*
534         * Main frame can contain 2 SGEs for 64-bit SGLs and
535         * 3 SGEs for 32-bit SGLs
536         */
537         if (IS_DMA64)
538                 num_cnt = sge_count - 2;
539         else
540                 num_cnt = sge_count - 3;
541
542         if(num_cnt>0){
543                 sge_bytes = sge_sz * num_cnt;
544
545                 frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) +
546                     ((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) ;
547         }
548         /* Main frame */
549         frame_count +=1;
550
551         if (frame_count > 7)
552                 frame_count = 8;
553         return frame_count;
554 }
555
556 /**
557  * megasas_build_dcdb - Prepares a direct cdb (DCDB) command
558  * @instance:           Adapter soft state
559  * @scp:                SCSI command
560  * @cmd:                Command to be prepared in
561  *
562  * This function prepares CDB commands. These are typcially pass-through
563  * commands to the devices.
564  */
565 static int
566 megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
567                    struct megasas_cmd *cmd)
568 {
569         u32 is_logical;
570         u32 device_id;
571         u16 flags = 0;
572         struct megasas_pthru_frame *pthru;
573
574         is_logical = MEGASAS_IS_LOGICAL(scp);
575         device_id = MEGASAS_DEV_INDEX(instance, scp);
576         pthru = (struct megasas_pthru_frame *)cmd->frame;
577
578         if (scp->sc_data_direction == PCI_DMA_TODEVICE)
579                 flags = MFI_FRAME_DIR_WRITE;
580         else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
581                 flags = MFI_FRAME_DIR_READ;
582         else if (scp->sc_data_direction == PCI_DMA_NONE)
583                 flags = MFI_FRAME_DIR_NONE;
584
585         /*
586          * Prepare the DCDB frame
587          */
588         pthru->cmd = (is_logical) ? MFI_CMD_LD_SCSI_IO : MFI_CMD_PD_SCSI_IO;
589         pthru->cmd_status = 0x0;
590         pthru->scsi_status = 0x0;
591         pthru->target_id = device_id;
592         pthru->lun = scp->device->lun;
593         pthru->cdb_len = scp->cmd_len;
594         pthru->timeout = 0;
595         pthru->flags = flags;
596         pthru->data_xfer_len = scp->request_bufflen;
597
598         memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
599
600         /*
601          * Construct SGL
602          */
603         if (IS_DMA64) {
604                 pthru->flags |= MFI_FRAME_SGL64;
605                 pthru->sge_count = megasas_make_sgl64(instance, scp,
606                                                       &pthru->sgl);
607         } else
608                 pthru->sge_count = megasas_make_sgl32(instance, scp,
609                                                       &pthru->sgl);
610
611         /*
612          * Sense info specific
613          */
614         pthru->sense_len = SCSI_SENSE_BUFFERSIZE;
615         pthru->sense_buf_phys_addr_hi = 0;
616         pthru->sense_buf_phys_addr_lo = cmd->sense_phys_addr;
617
618         /*
619          * Compute the total number of frames this command consumes. FW uses
620          * this number to pull sufficient number of frames from host memory.
621          */
622         cmd->frame_count = megasas_get_frame_count(pthru->sge_count);
623
624         return cmd->frame_count;
625 }
626
627 /**
628  * megasas_build_ldio - Prepares IOs to logical devices
629  * @instance:           Adapter soft state
630  * @scp:                SCSI command
631  * @cmd:                Command to to be prepared
632  *
633  * Frames (and accompanying SGLs) for regular SCSI IOs use this function.
634  */
635 static int
636 megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
637                    struct megasas_cmd *cmd)
638 {
639         u32 device_id;
640         u8 sc = scp->cmnd[0];
641         u16 flags = 0;
642         struct megasas_io_frame *ldio;
643
644         device_id = MEGASAS_DEV_INDEX(instance, scp);
645         ldio = (struct megasas_io_frame *)cmd->frame;
646
647         if (scp->sc_data_direction == PCI_DMA_TODEVICE)
648                 flags = MFI_FRAME_DIR_WRITE;
649         else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
650                 flags = MFI_FRAME_DIR_READ;
651
652         /*
653          * Prepare the Logical IO frame: 2nd bit is zero for all read cmds
654          */
655         ldio->cmd = (sc & 0x02) ? MFI_CMD_LD_WRITE : MFI_CMD_LD_READ;
656         ldio->cmd_status = 0x0;
657         ldio->scsi_status = 0x0;
658         ldio->target_id = device_id;
659         ldio->timeout = 0;
660         ldio->reserved_0 = 0;
661         ldio->pad_0 = 0;
662         ldio->flags = flags;
663         ldio->start_lba_hi = 0;
664         ldio->access_byte = (scp->cmd_len != 6) ? scp->cmnd[1] : 0;
665
666         /*
667          * 6-byte READ(0x08) or WRITE(0x0A) cdb
668          */
669         if (scp->cmd_len == 6) {
670                 ldio->lba_count = (u32) scp->cmnd[4];
671                 ldio->start_lba_lo = ((u32) scp->cmnd[1] << 16) |
672                     ((u32) scp->cmnd[2] << 8) | (u32) scp->cmnd[3];
673
674                 ldio->start_lba_lo &= 0x1FFFFF;
675         }
676
677         /*
678          * 10-byte READ(0x28) or WRITE(0x2A) cdb
679          */
680         else if (scp->cmd_len == 10) {
681                 ldio->lba_count = (u32) scp->cmnd[8] |
682                     ((u32) scp->cmnd[7] << 8);
683                 ldio->start_lba_lo = ((u32) scp->cmnd[2] << 24) |
684                     ((u32) scp->cmnd[3] << 16) |
685                     ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
686         }
687
688         /*
689          * 12-byte READ(0xA8) or WRITE(0xAA) cdb
690          */
691         else if (scp->cmd_len == 12) {
692                 ldio->lba_count = ((u32) scp->cmnd[6] << 24) |
693                     ((u32) scp->cmnd[7] << 16) |
694                     ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
695
696                 ldio->start_lba_lo = ((u32) scp->cmnd[2] << 24) |
697                     ((u32) scp->cmnd[3] << 16) |
698                     ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
699         }
700
701         /*
702          * 16-byte READ(0x88) or WRITE(0x8A) cdb
703          */
704         else if (scp->cmd_len == 16) {
705                 ldio->lba_count = ((u32) scp->cmnd[10] << 24) |
706                     ((u32) scp->cmnd[11] << 16) |
707                     ((u32) scp->cmnd[12] << 8) | (u32) scp->cmnd[13];
708
709                 ldio->start_lba_lo = ((u32) scp->cmnd[6] << 24) |
710                     ((u32) scp->cmnd[7] << 16) |
711                     ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
712
713                 ldio->start_lba_hi = ((u32) scp->cmnd[2] << 24) |
714                     ((u32) scp->cmnd[3] << 16) |
715                     ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
716
717         }
718
719         /*
720          * Construct SGL
721          */
722         if (IS_DMA64) {
723                 ldio->flags |= MFI_FRAME_SGL64;
724                 ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl);
725         } else
726                 ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
727
728         /*
729          * Sense info specific
730          */
731         ldio->sense_len = SCSI_SENSE_BUFFERSIZE;
732         ldio->sense_buf_phys_addr_hi = 0;
733         ldio->sense_buf_phys_addr_lo = cmd->sense_phys_addr;
734
735         /*
736          * Compute the total number of frames this command consumes. FW uses
737          * this number to pull sufficient number of frames from host memory.
738          */
739         cmd->frame_count = megasas_get_frame_count(ldio->sge_count);
740
741         return cmd->frame_count;
742 }
743
744 /**
745  * megasas_is_ldio -            Checks if the cmd is for logical drive
746  * @scmd:                       SCSI command
747  *      
748  * Called by megasas_queue_command to find out if the command to be queued
749  * is a logical drive command   
750  */
751 static inline int megasas_is_ldio(struct scsi_cmnd *cmd)
752 {
753         if (!MEGASAS_IS_LOGICAL(cmd))
754                 return 0;
755         switch (cmd->cmnd[0]) {
756         case READ_10:
757         case WRITE_10:
758         case READ_12:
759         case WRITE_12:
760         case READ_6:
761         case WRITE_6:
762         case READ_16:
763         case WRITE_16:
764                 return 1;
765         default:
766                 return 0;
767         }
768 }
769
770  /**
771  * megasas_dump_pending_frames -        Dumps the frame address of all pending cmds
772  *                                      in FW
773  * @instance:                           Adapter soft state
774  */
775 static inline void
776 megasas_dump_pending_frames(struct megasas_instance *instance)
777 {
778         struct megasas_cmd *cmd;
779         int i,n;
780         union megasas_sgl *mfi_sgl;
781         struct megasas_io_frame *ldio;
782         struct megasas_pthru_frame *pthru;
783         u32 sgcount;
784         u32 max_cmd = instance->max_fw_cmds;
785
786         printk(KERN_ERR "\nmegasas[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no);
787         printk(KERN_ERR "megasas[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding));
788         if (IS_DMA64)
789                 printk(KERN_ERR "\nmegasas[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no);
790         else
791                 printk(KERN_ERR "\nmegasas[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no);
792
793         printk(KERN_ERR "megasas[%d]: Pending OS cmds in FW : \n",instance->host->host_no);
794         for (i = 0; i < max_cmd; i++) {
795                 cmd = instance->cmd_list[i];
796                 if(!cmd->scmd)
797                         continue;
798                 printk(KERN_ERR "megasas[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
799                 if (megasas_is_ldio(cmd->scmd)){
800                         ldio = (struct megasas_io_frame *)cmd->frame;
801                         mfi_sgl = &ldio->sgl;
802                         sgcount = ldio->sge_count;
803                         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);
804                 }
805                 else {
806                         pthru = (struct megasas_pthru_frame *) cmd->frame;
807                         mfi_sgl = &pthru->sgl;
808                         sgcount = pthru->sge_count;
809                         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);
810                 }
811         if(megasas_dbg_lvl & MEGASAS_DBG_LVL){
812                 for (n = 0; n < sgcount; n++){
813                         if (IS_DMA64)
814                                 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) ;
815                         else
816                                 printk(KERN_ERR "megasas: sgl len : 0x%x, sgl addr : 0x%x ",mfi_sgl->sge32[n].length , mfi_sgl->sge32[n].phys_addr) ;
817                         }
818                 }
819                 printk(KERN_ERR "\n");
820         } /*for max_cmd*/
821         printk(KERN_ERR "\nmegasas[%d]: Pending Internal cmds in FW : \n",instance->host->host_no);
822         for (i = 0; i < max_cmd; i++) {
823
824                 cmd = instance->cmd_list[i];
825
826                 if(cmd->sync_cmd == 1){
827                         printk(KERN_ERR "0x%08lx : ", (unsigned long)cmd->frame_phys_addr);
828                 }
829         }
830         printk(KERN_ERR "megasas[%d]: Dumping Done.\n\n",instance->host->host_no);
831 }
832
833 /**
834  * megasas_queue_command -      Queue entry point
835  * @scmd:                       SCSI command to be queued
836  * @done:                       Callback entry point
837  */
838 static int
839 megasas_queue_command(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd *))
840 {
841         u32 frame_count;
842         struct megasas_cmd *cmd;
843         struct megasas_instance *instance;
844
845         instance = (struct megasas_instance *)
846             scmd->device->host->hostdata;
847
848         /* Don't process if we have already declared adapter dead */
849         if (instance->hw_crit_error)
850                 return SCSI_MLQUEUE_HOST_BUSY;
851
852         scmd->scsi_done = done;
853         scmd->result = 0;
854
855         if (MEGASAS_IS_LOGICAL(scmd) &&
856             (scmd->device->id >= MEGASAS_MAX_LD || scmd->device->lun)) {
857                 scmd->result = DID_BAD_TARGET << 16;
858                 goto out_done;
859         }
860
861         switch (scmd->cmnd[0]) {
862         case SYNCHRONIZE_CACHE:
863                 /*
864                  * FW takes care of flush cache on its own
865                  * No need to send it down
866                  */
867                 scmd->result = DID_OK << 16;
868                 goto out_done;
869         default:
870                 break;
871         }
872
873         cmd = megasas_get_cmd(instance);
874         if (!cmd)
875                 return SCSI_MLQUEUE_HOST_BUSY;
876
877         /*
878          * Logical drive command
879          */
880         if (megasas_is_ldio(scmd))
881                 frame_count = megasas_build_ldio(instance, scmd, cmd);
882         else
883                 frame_count = megasas_build_dcdb(instance, scmd, cmd);
884
885         if (!frame_count)
886                 goto out_return_cmd;
887
888         cmd->scmd = scmd;
889
890         /*
891          * Issue the command to the FW
892          */
893         atomic_inc(&instance->fw_outstanding);
894
895         instance->instancet->fire_cmd(cmd->frame_phys_addr ,cmd->frame_count-1,instance->reg_set);
896
897         return 0;
898
899  out_return_cmd:
900         megasas_return_cmd(instance, cmd);
901  out_done:
902         done(scmd);
903         return 0;
904 }
905
906 static int megasas_slave_configure(struct scsi_device *sdev)
907 {
908         /*
909          * Don't export physical disk devices to the disk driver.
910          *
911          * FIXME: Currently we don't export them to the midlayer at all.
912          *        That will be fixed once LSI engineers have audited the
913          *        firmware for possible issues.
914          */
915         if (sdev->channel < MEGASAS_MAX_PD_CHANNELS && sdev->type == TYPE_DISK)
916                 return -ENXIO;
917
918         /*
919          * The RAID firmware may require extended timeouts.
920          */
921         if (sdev->channel >= MEGASAS_MAX_PD_CHANNELS)
922                 sdev->timeout = 90 * HZ;
923         return 0;
924 }
925
926 /**
927  * megasas_wait_for_outstanding -       Wait for all outstanding cmds
928  * @instance:                           Adapter soft state
929  *
930  * This function waits for upto MEGASAS_RESET_WAIT_TIME seconds for FW to
931  * complete all its outstanding commands. Returns error if one or more IOs
932  * are pending after this time period. It also marks the controller dead.
933  */
934 static int megasas_wait_for_outstanding(struct megasas_instance *instance)
935 {
936         int i;
937         u32 wait_time = MEGASAS_RESET_WAIT_TIME;
938
939         for (i = 0; i < wait_time; i++) {
940
941                 int outstanding = atomic_read(&instance->fw_outstanding);
942
943                 if (!outstanding)
944                         break;
945
946                 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
947                         printk(KERN_NOTICE "megasas: [%2d]waiting for %d "
948                                "commands to complete\n",i,outstanding);
949                 }
950
951                 msleep(1000);
952         }
953
954         if (atomic_read(&instance->fw_outstanding)) {
955                 /*
956                 * Send signal to FW to stop processing any pending cmds.
957                 * The controller will be taken offline by the OS now.
958                 */
959                 writel(MFI_STOP_ADP,
960                                 &instance->reg_set->inbound_doorbell);
961                 megasas_dump_pending_frames(instance);
962                 instance->hw_crit_error = 1;
963                 return FAILED;
964         }
965
966         return SUCCESS;
967 }
968
969 /**
970  * megasas_generic_reset -      Generic reset routine
971  * @scmd:                       Mid-layer SCSI command
972  *
973  * This routine implements a generic reset handler for device, bus and host
974  * reset requests. Device, bus and host specific reset handlers can use this
975  * function after they do their specific tasks.
976  */
977 static int megasas_generic_reset(struct scsi_cmnd *scmd)
978 {
979         int ret_val;
980         struct megasas_instance *instance;
981
982         instance = (struct megasas_instance *)scmd->device->host->hostdata;
983
984         scmd_printk(KERN_NOTICE, scmd, "megasas: RESET -%ld cmd=%x\n",
985                scmd->serial_number, scmd->cmnd[0]);
986
987         if (instance->hw_crit_error) {
988                 printk(KERN_ERR "megasas: cannot recover from previous reset "
989                        "failures\n");
990                 return FAILED;
991         }
992
993         ret_val = megasas_wait_for_outstanding(instance);
994         if (ret_val == SUCCESS)
995                 printk(KERN_NOTICE "megasas: reset successful \n");
996         else
997                 printk(KERN_ERR "megasas: failed to do reset\n");
998
999         return ret_val;
1000 }
1001
1002 /**
1003  * megasas_reset_device -       Device reset handler entry point
1004  */
1005 static int megasas_reset_device(struct scsi_cmnd *scmd)
1006 {
1007         int ret;
1008
1009         /*
1010          * First wait for all commands to complete
1011          */
1012         ret = megasas_generic_reset(scmd);
1013
1014         return ret;
1015 }
1016
1017 /**
1018  * megasas_reset_bus_host -     Bus & host reset handler entry point
1019  */
1020 static int megasas_reset_bus_host(struct scsi_cmnd *scmd)
1021 {
1022         int ret;
1023
1024         /*
1025          * First wait for all commands to complete
1026          */
1027         ret = megasas_generic_reset(scmd);
1028
1029         return ret;
1030 }
1031
1032 /**
1033  * megasas_bios_param - Returns disk geometry for a disk
1034  * @sdev:               device handle
1035  * @bdev:               block device
1036  * @capacity:           drive capacity
1037  * @geom:               geometry parameters
1038  */
1039 static int
1040 megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
1041                  sector_t capacity, int geom[])
1042 {
1043         int heads;
1044         int sectors;
1045         sector_t cylinders;
1046         unsigned long tmp;
1047         /* Default heads (64) & sectors (32) */
1048         heads = 64;
1049         sectors = 32;
1050
1051         tmp = heads * sectors;
1052         cylinders = capacity;
1053
1054         sector_div(cylinders, tmp);
1055
1056         /*
1057          * Handle extended translation size for logical drives > 1Gb
1058          */
1059
1060         if (capacity >= 0x200000) {
1061                 heads = 255;
1062                 sectors = 63;
1063                 tmp = heads*sectors;
1064                 cylinders = capacity;
1065                 sector_div(cylinders, tmp);
1066         }
1067
1068         geom[0] = heads;
1069         geom[1] = sectors;
1070         geom[2] = cylinders;
1071
1072         return 0;
1073 }
1074
1075 /**
1076  * megasas_service_aen -        Processes an event notification
1077  * @instance:                   Adapter soft state
1078  * @cmd:                        AEN command completed by the ISR
1079  *
1080  * For AEN, driver sends a command down to FW that is held by the FW till an
1081  * event occurs. When an event of interest occurs, FW completes the command
1082  * that it was previously holding.
1083  *
1084  * This routines sends SIGIO signal to processes that have registered with the
1085  * driver for AEN.
1086  */
1087 static void
1088 megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
1089 {
1090         /*
1091          * Don't signal app if it is just an aborted previously registered aen
1092          */
1093         if (!cmd->abort_aen)
1094                 kill_fasync(&megasas_async_queue, SIGIO, POLL_IN);
1095         else
1096                 cmd->abort_aen = 0;
1097
1098         instance->aen_cmd = NULL;
1099         megasas_return_cmd(instance, cmd);
1100 }
1101
1102 /*
1103  * Scsi host template for megaraid_sas driver
1104  */
1105 static struct scsi_host_template megasas_template = {
1106
1107         .module = THIS_MODULE,
1108         .name = "LSI Logic SAS based MegaRAID driver",
1109         .proc_name = "megaraid_sas",
1110         .slave_configure = megasas_slave_configure,
1111         .queuecommand = megasas_queue_command,
1112         .eh_device_reset_handler = megasas_reset_device,
1113         .eh_bus_reset_handler = megasas_reset_bus_host,
1114         .eh_host_reset_handler = megasas_reset_bus_host,
1115         .bios_param = megasas_bios_param,
1116         .use_clustering = ENABLE_CLUSTERING,
1117 };
1118
1119 /**
1120  * megasas_complete_int_cmd -   Completes an internal command
1121  * @instance:                   Adapter soft state
1122  * @cmd:                        Command to be completed
1123  *
1124  * The megasas_issue_blocked_cmd() function waits for a command to complete
1125  * after it issues a command. This function wakes up that waiting routine by
1126  * calling wake_up() on the wait queue.
1127  */
1128 static void
1129 megasas_complete_int_cmd(struct megasas_instance *instance,
1130                          struct megasas_cmd *cmd)
1131 {
1132         cmd->cmd_status = cmd->frame->io.cmd_status;
1133
1134         if (cmd->cmd_status == ENODATA) {
1135                 cmd->cmd_status = 0;
1136         }
1137         wake_up(&instance->int_cmd_wait_q);
1138 }
1139
1140 /**
1141  * megasas_complete_abort -     Completes aborting a command
1142  * @instance:                   Adapter soft state
1143  * @cmd:                        Cmd that was issued to abort another cmd
1144  *
1145  * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q 
1146  * after it issues an abort on a previously issued command. This function 
1147  * wakes up all functions waiting on the same wait queue.
1148  */
1149 static void
1150 megasas_complete_abort(struct megasas_instance *instance,
1151                        struct megasas_cmd *cmd)
1152 {
1153         if (cmd->sync_cmd) {
1154                 cmd->sync_cmd = 0;
1155                 cmd->cmd_status = 0;
1156                 wake_up(&instance->abort_cmd_wait_q);
1157         }
1158
1159         return;
1160 }
1161
1162 /**
1163  * megasas_unmap_sgbuf -        Unmap SG buffers
1164  * @instance:                   Adapter soft state
1165  * @cmd:                        Completed command
1166  */
1167 static void
1168 megasas_unmap_sgbuf(struct megasas_instance *instance, struct megasas_cmd *cmd)
1169 {
1170         dma_addr_t buf_h;
1171         u8 opcode;
1172
1173         if (cmd->scmd->use_sg) {
1174                 pci_unmap_sg(instance->pdev, cmd->scmd->request_buffer,
1175                              cmd->scmd->use_sg, cmd->scmd->sc_data_direction);
1176                 return;
1177         }
1178
1179         if (!cmd->scmd->request_bufflen)
1180                 return;
1181
1182         opcode = cmd->frame->hdr.cmd;
1183
1184         if ((opcode == MFI_CMD_LD_READ) || (opcode == MFI_CMD_LD_WRITE)) {
1185                 if (IS_DMA64)
1186                         buf_h = cmd->frame->io.sgl.sge64[0].phys_addr;
1187                 else
1188                         buf_h = cmd->frame->io.sgl.sge32[0].phys_addr;
1189         } else {
1190                 if (IS_DMA64)
1191                         buf_h = cmd->frame->pthru.sgl.sge64[0].phys_addr;
1192                 else
1193                         buf_h = cmd->frame->pthru.sgl.sge32[0].phys_addr;
1194         }
1195
1196         pci_unmap_single(instance->pdev, buf_h, cmd->scmd->request_bufflen,
1197                          cmd->scmd->sc_data_direction);
1198         return;
1199 }
1200
1201 /**
1202  * megasas_complete_cmd -       Completes a command
1203  * @instance:                   Adapter soft state
1204  * @cmd:                        Command to be completed
1205  * @alt_status:                 If non-zero, use this value as status to 
1206  *                              SCSI mid-layer instead of the value returned
1207  *                              by the FW. This should be used if caller wants
1208  *                              an alternate status (as in the case of aborted
1209  *                              commands)
1210  */
1211 static void
1212 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
1213                      u8 alt_status)
1214 {
1215         int exception = 0;
1216         struct megasas_header *hdr = &cmd->frame->hdr;
1217
1218         if (cmd->scmd) {
1219                 cmd->scmd->SCp.ptr = (char *)0;
1220         }
1221
1222         switch (hdr->cmd) {
1223
1224         case MFI_CMD_PD_SCSI_IO:
1225         case MFI_CMD_LD_SCSI_IO:
1226
1227                 /*
1228                  * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
1229                  * issued either through an IO path or an IOCTL path. If it
1230                  * was via IOCTL, we will send it to internal completion.
1231                  */
1232                 if (cmd->sync_cmd) {
1233                         cmd->sync_cmd = 0;
1234                         megasas_complete_int_cmd(instance, cmd);
1235                         break;
1236                 }
1237
1238         case MFI_CMD_LD_READ:
1239         case MFI_CMD_LD_WRITE:
1240
1241                 if (alt_status) {
1242                         cmd->scmd->result = alt_status << 16;
1243                         exception = 1;
1244                 }
1245
1246                 if (exception) {
1247
1248                         atomic_dec(&instance->fw_outstanding);
1249
1250                         megasas_unmap_sgbuf(instance, cmd);
1251                         cmd->scmd->scsi_done(cmd->scmd);
1252                         megasas_return_cmd(instance, cmd);
1253
1254                         break;
1255                 }
1256
1257                 switch (hdr->cmd_status) {
1258
1259                 case MFI_STAT_OK:
1260                         cmd->scmd->result = DID_OK << 16;
1261                         break;
1262
1263                 case MFI_STAT_SCSI_IO_FAILED:
1264                 case MFI_STAT_LD_INIT_IN_PROGRESS:
1265                         cmd->scmd->result =
1266                             (DID_ERROR << 16) | hdr->scsi_status;
1267                         break;
1268
1269                 case MFI_STAT_SCSI_DONE_WITH_ERROR:
1270
1271                         cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status;
1272
1273                         if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) {
1274                                 memset(cmd->scmd->sense_buffer, 0,
1275                                        SCSI_SENSE_BUFFERSIZE);
1276                                 memcpy(cmd->scmd->sense_buffer, cmd->sense,
1277                                        hdr->sense_len);
1278
1279                                 cmd->scmd->result |= DRIVER_SENSE << 24;
1280                         }
1281
1282                         break;
1283
1284                 case MFI_STAT_LD_OFFLINE:
1285                 case MFI_STAT_DEVICE_NOT_FOUND:
1286                         cmd->scmd->result = DID_BAD_TARGET << 16;
1287                         break;
1288
1289                 default:
1290                         printk(KERN_DEBUG "megasas: MFI FW status %#x\n",
1291                                hdr->cmd_status);
1292                         cmd->scmd->result = DID_ERROR << 16;
1293                         break;
1294                 }
1295
1296                 atomic_dec(&instance->fw_outstanding);
1297
1298                 megasas_unmap_sgbuf(instance, cmd);
1299                 cmd->scmd->scsi_done(cmd->scmd);
1300                 megasas_return_cmd(instance, cmd);
1301
1302                 break;
1303
1304         case MFI_CMD_SMP:
1305         case MFI_CMD_STP:
1306         case MFI_CMD_DCMD:
1307
1308                 /*
1309                  * See if got an event notification
1310                  */
1311                 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_WAIT)
1312                         megasas_service_aen(instance, cmd);
1313                 else
1314                         megasas_complete_int_cmd(instance, cmd);
1315
1316                 break;
1317
1318         case MFI_CMD_ABORT:
1319                 /*
1320                  * Cmd issued to abort another cmd returned
1321                  */
1322                 megasas_complete_abort(instance, cmd);
1323                 break;
1324
1325         default:
1326                 printk("megasas: Unknown command completed! [0x%X]\n",
1327                        hdr->cmd);
1328                 break;
1329         }
1330 }
1331
1332 /**
1333  * megasas_deplete_reply_queue -        Processes all completed commands
1334  * @instance:                           Adapter soft state
1335  * @alt_status:                         Alternate status to be returned to
1336  *                                      SCSI mid-layer instead of the status
1337  *                                      returned by the FW
1338  */
1339 static int
1340 megasas_deplete_reply_queue(struct megasas_instance *instance, u8 alt_status)
1341 {
1342         /*
1343          * Check if it is our interrupt
1344          * Clear the interrupt 
1345          */
1346         if(instance->instancet->clear_intr(instance->reg_set))
1347                 return IRQ_NONE;
1348
1349         if (instance->hw_crit_error)
1350                 goto out_done;
1351         /*
1352          * Schedule the tasklet for cmd completion
1353          */
1354         tasklet_schedule(&instance->isr_tasklet);
1355 out_done:
1356         return IRQ_HANDLED;
1357 }
1358
1359 /**
1360  * megasas_isr - isr entry point
1361  */
1362 static irqreturn_t megasas_isr(int irq, void *devp)
1363 {
1364         return megasas_deplete_reply_queue((struct megasas_instance *)devp,
1365                                            DID_OK);
1366 }
1367
1368 /**
1369  * megasas_transition_to_ready -        Move the FW to READY state
1370  * @instance:                           Adapter soft state
1371  *
1372  * During the initialization, FW passes can potentially be in any one of
1373  * several possible states. If the FW in operational, waiting-for-handshake
1374  * states, driver must take steps to bring it to ready state. Otherwise, it
1375  * has to wait for the ready state.
1376  */
1377 static int
1378 megasas_transition_to_ready(struct megasas_instance* instance)
1379 {
1380         int i;
1381         u8 max_wait;
1382         u32 fw_state;
1383         u32 cur_state;
1384
1385         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
1386
1387         if (fw_state != MFI_STATE_READY)
1388                 printk(KERN_INFO "megasas: Waiting for FW to come to ready"
1389                        " state\n");
1390
1391         while (fw_state != MFI_STATE_READY) {
1392
1393                 switch (fw_state) {
1394
1395                 case MFI_STATE_FAULT:
1396
1397                         printk(KERN_DEBUG "megasas: FW in FAULT state!!\n");
1398                         return -ENODEV;
1399
1400                 case MFI_STATE_WAIT_HANDSHAKE:
1401                         /*
1402                          * Set the CLR bit in inbound doorbell
1403                          */
1404                         writel(MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
1405                                 &instance->reg_set->inbound_doorbell);
1406
1407                         max_wait = 2;
1408                         cur_state = MFI_STATE_WAIT_HANDSHAKE;
1409                         break;
1410
1411                 case MFI_STATE_BOOT_MESSAGE_PENDING:
1412                         writel(MFI_INIT_HOTPLUG,
1413                                 &instance->reg_set->inbound_doorbell);
1414
1415                         max_wait = 10;
1416                         cur_state = MFI_STATE_BOOT_MESSAGE_PENDING;
1417                         break;
1418
1419                 case MFI_STATE_OPERATIONAL:
1420                         /*
1421                          * Bring it to READY state; assuming max wait 10 secs
1422                          */
1423                         instance->instancet->disable_intr(instance->reg_set);
1424                         writel(MFI_RESET_FLAGS, &instance->reg_set->inbound_doorbell);
1425
1426                         max_wait = 10;
1427                         cur_state = MFI_STATE_OPERATIONAL;
1428                         break;
1429
1430                 case MFI_STATE_UNDEFINED:
1431                         /*
1432                          * This state should not last for more than 2 seconds
1433                          */
1434                         max_wait = 2;
1435                         cur_state = MFI_STATE_UNDEFINED;
1436                         break;
1437
1438                 case MFI_STATE_BB_INIT:
1439                         max_wait = 2;
1440                         cur_state = MFI_STATE_BB_INIT;
1441                         break;
1442
1443                 case MFI_STATE_FW_INIT:
1444                         max_wait = 20;
1445                         cur_state = MFI_STATE_FW_INIT;
1446                         break;
1447
1448                 case MFI_STATE_FW_INIT_2:
1449                         max_wait = 20;
1450                         cur_state = MFI_STATE_FW_INIT_2;
1451                         break;
1452
1453                 case MFI_STATE_DEVICE_SCAN:
1454                         max_wait = 20;
1455                         cur_state = MFI_STATE_DEVICE_SCAN;
1456                         break;
1457
1458                 case MFI_STATE_FLUSH_CACHE:
1459                         max_wait = 20;
1460                         cur_state = MFI_STATE_FLUSH_CACHE;
1461                         break;
1462
1463                 default:
1464                         printk(KERN_DEBUG "megasas: Unknown state 0x%x\n",
1465                                fw_state);
1466                         return -ENODEV;
1467                 }
1468
1469                 /*
1470                  * The cur_state should not last for more than max_wait secs
1471                  */
1472                 for (i = 0; i < (max_wait * 1000); i++) {
1473                         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) &  
1474                                         MFI_STATE_MASK ;
1475
1476                         if (fw_state == cur_state) {
1477                                 msleep(1);
1478                         } else
1479                                 break;
1480                 }
1481
1482                 /*
1483                  * Return error if fw_state hasn't changed after max_wait
1484                  */
1485                 if (fw_state == cur_state) {
1486                         printk(KERN_DEBUG "FW state [%d] hasn't changed "
1487                                "in %d secs\n", fw_state, max_wait);
1488                         return -ENODEV;
1489                 }
1490         };
1491         printk(KERN_INFO "megasas: FW now in Ready state\n");
1492
1493         return 0;
1494 }
1495
1496 /**
1497  * megasas_teardown_frame_pool -        Destroy the cmd frame DMA pool
1498  * @instance:                           Adapter soft state
1499  */
1500 static void megasas_teardown_frame_pool(struct megasas_instance *instance)
1501 {
1502         int i;
1503         u32 max_cmd = instance->max_fw_cmds;
1504         struct megasas_cmd *cmd;
1505
1506         if (!instance->frame_dma_pool)
1507                 return;
1508
1509         /*
1510          * Return all frames to pool
1511          */
1512         for (i = 0; i < max_cmd; i++) {
1513
1514                 cmd = instance->cmd_list[i];
1515
1516                 if (cmd->frame)
1517                         pci_pool_free(instance->frame_dma_pool, cmd->frame,
1518                                       cmd->frame_phys_addr);
1519
1520                 if (cmd->sense)
1521                         pci_pool_free(instance->sense_dma_pool, cmd->sense,
1522                                       cmd->sense_phys_addr);
1523         }
1524
1525         /*
1526          * Now destroy the pool itself
1527          */
1528         pci_pool_destroy(instance->frame_dma_pool);
1529         pci_pool_destroy(instance->sense_dma_pool);
1530
1531         instance->frame_dma_pool = NULL;
1532         instance->sense_dma_pool = NULL;
1533 }
1534
1535 /**
1536  * megasas_create_frame_pool -  Creates DMA pool for cmd frames
1537  * @instance:                   Adapter soft state
1538  *
1539  * Each command packet has an embedded DMA memory buffer that is used for
1540  * filling MFI frame and the SG list that immediately follows the frame. This
1541  * function creates those DMA memory buffers for each command packet by using
1542  * PCI pool facility.
1543  */
1544 static int megasas_create_frame_pool(struct megasas_instance *instance)
1545 {
1546         int i;
1547         u32 max_cmd;
1548         u32 sge_sz;
1549         u32 sgl_sz;
1550         u32 total_sz;
1551         u32 frame_count;
1552         struct megasas_cmd *cmd;
1553
1554         max_cmd = instance->max_fw_cmds;
1555
1556         /*
1557          * Size of our frame is 64 bytes for MFI frame, followed by max SG
1558          * elements and finally SCSI_SENSE_BUFFERSIZE bytes for sense buffer
1559          */
1560         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
1561             sizeof(struct megasas_sge32);
1562
1563         /*
1564          * Calculated the number of 64byte frames required for SGL
1565          */
1566         sgl_sz = sge_sz * instance->max_num_sge;
1567         frame_count = (sgl_sz + MEGAMFI_FRAME_SIZE - 1) / MEGAMFI_FRAME_SIZE;
1568
1569         /*
1570          * We need one extra frame for the MFI command
1571          */
1572         frame_count++;
1573
1574         total_sz = MEGAMFI_FRAME_SIZE * frame_count;
1575         /*
1576          * Use DMA pool facility provided by PCI layer
1577          */
1578         instance->frame_dma_pool = pci_pool_create("megasas frame pool",
1579                                                    instance->pdev, total_sz, 64,
1580                                                    0);
1581
1582         if (!instance->frame_dma_pool) {
1583                 printk(KERN_DEBUG "megasas: failed to setup frame pool\n");
1584                 return -ENOMEM;
1585         }
1586
1587         instance->sense_dma_pool = pci_pool_create("megasas sense pool",
1588                                                    instance->pdev, 128, 4, 0);
1589
1590         if (!instance->sense_dma_pool) {
1591                 printk(KERN_DEBUG "megasas: failed to setup sense pool\n");
1592
1593                 pci_pool_destroy(instance->frame_dma_pool);
1594                 instance->frame_dma_pool = NULL;
1595
1596                 return -ENOMEM;
1597         }
1598
1599         /*
1600          * Allocate and attach a frame to each of the commands in cmd_list.
1601          * By making cmd->index as the context instead of the &cmd, we can
1602          * always use 32bit context regardless of the architecture
1603          */
1604         for (i = 0; i < max_cmd; i++) {
1605
1606                 cmd = instance->cmd_list[i];
1607
1608                 cmd->frame = pci_pool_alloc(instance->frame_dma_pool,
1609                                             GFP_KERNEL, &cmd->frame_phys_addr);
1610
1611                 cmd->sense = pci_pool_alloc(instance->sense_dma_pool,
1612                                             GFP_KERNEL, &cmd->sense_phys_addr);
1613
1614                 /*
1615                  * megasas_teardown_frame_pool() takes care of freeing
1616                  * whatever has been allocated
1617                  */
1618                 if (!cmd->frame || !cmd->sense) {
1619                         printk(KERN_DEBUG "megasas: pci_pool_alloc failed \n");
1620                         megasas_teardown_frame_pool(instance);
1621                         return -ENOMEM;
1622                 }
1623
1624                 cmd->frame->io.context = cmd->index;
1625         }
1626
1627         return 0;
1628 }
1629
1630 /**
1631  * megasas_free_cmds -  Free all the cmds in the free cmd pool
1632  * @instance:           Adapter soft state
1633  */
1634 static void megasas_free_cmds(struct megasas_instance *instance)
1635 {
1636         int i;
1637         /* First free the MFI frame pool */
1638         megasas_teardown_frame_pool(instance);
1639
1640         /* Free all the commands in the cmd_list */
1641         for (i = 0; i < instance->max_fw_cmds; i++)
1642                 kfree(instance->cmd_list[i]);
1643
1644         /* Free the cmd_list buffer itself */
1645         kfree(instance->cmd_list);
1646         instance->cmd_list = NULL;
1647
1648         INIT_LIST_HEAD(&instance->cmd_pool);
1649 }
1650
1651 /**
1652  * megasas_alloc_cmds - Allocates the command packets
1653  * @instance:           Adapter soft state
1654  *
1655  * Each command that is issued to the FW, whether IO commands from the OS or
1656  * internal commands like IOCTLs, are wrapped in local data structure called
1657  * megasas_cmd. The frame embedded in this megasas_cmd is actually issued to
1658  * the FW.
1659  *
1660  * Each frame has a 32-bit field called context (tag). This context is used
1661  * to get back the megasas_cmd from the frame when a frame gets completed in
1662  * the ISR. Typically the address of the megasas_cmd itself would be used as
1663  * the context. But we wanted to keep the differences between 32 and 64 bit
1664  * systems to the mininum. We always use 32 bit integers for the context. In
1665  * this driver, the 32 bit values are the indices into an array cmd_list.
1666  * This array is used only to look up the megasas_cmd given the context. The
1667  * free commands themselves are maintained in a linked list called cmd_pool.
1668  */
1669 static int megasas_alloc_cmds(struct megasas_instance *instance)
1670 {
1671         int i;
1672         int j;
1673         u32 max_cmd;
1674         struct megasas_cmd *cmd;
1675
1676         max_cmd = instance->max_fw_cmds;
1677
1678         /*
1679          * instance->cmd_list is an array of struct megasas_cmd pointers.
1680          * Allocate the dynamic array first and then allocate individual
1681          * commands.
1682          */
1683         instance->cmd_list = kmalloc(sizeof(struct megasas_cmd *) * max_cmd,
1684                                      GFP_KERNEL);
1685
1686         if (!instance->cmd_list) {
1687                 printk(KERN_DEBUG "megasas: out of memory\n");
1688                 return -ENOMEM;
1689         }
1690
1691         memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) * max_cmd);
1692
1693         for (i = 0; i < max_cmd; i++) {
1694                 instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
1695                                                 GFP_KERNEL);
1696
1697                 if (!instance->cmd_list[i]) {
1698
1699                         for (j = 0; j < i; j++)
1700                                 kfree(instance->cmd_list[j]);
1701
1702                         kfree(instance->cmd_list);
1703                         instance->cmd_list = NULL;
1704
1705                         return -ENOMEM;
1706                 }
1707         }
1708
1709         /*
1710          * Add all the commands to command pool (instance->cmd_pool)
1711          */
1712         for (i = 0; i < max_cmd; i++) {
1713                 cmd = instance->cmd_list[i];
1714                 memset(cmd, 0, sizeof(struct megasas_cmd));
1715                 cmd->index = i;
1716                 cmd->instance = instance;
1717
1718                 list_add_tail(&cmd->list, &instance->cmd_pool);
1719         }
1720
1721         /*
1722          * Create a frame pool and assign one frame to each cmd
1723          */
1724         if (megasas_create_frame_pool(instance)) {
1725                 printk(KERN_DEBUG "megasas: Error creating frame DMA pool\n");
1726                 megasas_free_cmds(instance);
1727         }
1728
1729         return 0;
1730 }
1731
1732 /**
1733  * megasas_get_controller_info -        Returns FW's controller structure
1734  * @instance:                           Adapter soft state
1735  * @ctrl_info:                          Controller information structure
1736  *
1737  * Issues an internal command (DCMD) to get the FW's controller structure.
1738  * This information is mainly used to find out the maximum IO transfer per
1739  * command supported by the FW.
1740  */
1741 static int
1742 megasas_get_ctrl_info(struct megasas_instance *instance,
1743                       struct megasas_ctrl_info *ctrl_info)
1744 {
1745         int ret = 0;
1746         struct megasas_cmd *cmd;
1747         struct megasas_dcmd_frame *dcmd;
1748         struct megasas_ctrl_info *ci;
1749         dma_addr_t ci_h = 0;
1750
1751         cmd = megasas_get_cmd(instance);
1752
1753         if (!cmd) {
1754                 printk(KERN_DEBUG "megasas: Failed to get a free cmd\n");
1755                 return -ENOMEM;
1756         }
1757
1758         dcmd = &cmd->frame->dcmd;
1759
1760         ci = pci_alloc_consistent(instance->pdev,
1761                                   sizeof(struct megasas_ctrl_info), &ci_h);
1762
1763         if (!ci) {
1764                 printk(KERN_DEBUG "Failed to alloc mem for ctrl info\n");
1765                 megasas_return_cmd(instance, cmd);
1766                 return -ENOMEM;
1767         }
1768
1769         memset(ci, 0, sizeof(*ci));
1770         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
1771
1772         dcmd->cmd = MFI_CMD_DCMD;
1773         dcmd->cmd_status = 0xFF;
1774         dcmd->sge_count = 1;
1775         dcmd->flags = MFI_FRAME_DIR_READ;
1776         dcmd->timeout = 0;
1777         dcmd->data_xfer_len = sizeof(struct megasas_ctrl_info);
1778         dcmd->opcode = MR_DCMD_CTRL_GET_INFO;
1779         dcmd->sgl.sge32[0].phys_addr = ci_h;
1780         dcmd->sgl.sge32[0].length = sizeof(struct megasas_ctrl_info);
1781
1782         if (!megasas_issue_polled(instance, cmd)) {
1783                 ret = 0;
1784                 memcpy(ctrl_info, ci, sizeof(struct megasas_ctrl_info));
1785         } else {
1786                 ret = -1;
1787         }
1788
1789         pci_free_consistent(instance->pdev, sizeof(struct megasas_ctrl_info),
1790                             ci, ci_h);
1791
1792         megasas_return_cmd(instance, cmd);
1793         return ret;
1794 }
1795
1796 /**
1797  * megasas_complete_cmd_dpc      -      Returns FW's controller structure
1798  * @instance_addr:                      Address of adapter soft state
1799  *
1800  * Tasklet to complete cmds
1801  */
1802 static void megasas_complete_cmd_dpc(unsigned long instance_addr)
1803 {
1804         u32 producer;
1805         u32 consumer;
1806         u32 context;
1807         struct megasas_cmd *cmd;
1808         struct megasas_instance *instance = (struct megasas_instance *)instance_addr;
1809
1810         /* If we have already declared adapter dead, donot complete cmds */
1811         if (instance->hw_crit_error)
1812                 return;
1813
1814         producer = *instance->producer;
1815         consumer = *instance->consumer;
1816
1817         while (consumer != producer) {
1818                 context = instance->reply_queue[consumer];
1819
1820                 cmd = instance->cmd_list[context];
1821
1822                 megasas_complete_cmd(instance, cmd, DID_OK);
1823
1824                 consumer++;
1825                 if (consumer == (instance->max_fw_cmds + 1)) {
1826                         consumer = 0;
1827                 }
1828         }
1829
1830         *instance->consumer = producer;
1831 }
1832
1833 /**
1834  * megasas_init_mfi -   Initializes the FW
1835  * @instance:           Adapter soft state
1836  *
1837  * This is the main function for initializing MFI firmware.
1838  */
1839 static int megasas_init_mfi(struct megasas_instance *instance)
1840 {
1841         u32 context_sz;
1842         u32 reply_q_sz;
1843         u32 max_sectors_1;
1844         u32 max_sectors_2;
1845         struct megasas_register_set __iomem *reg_set;
1846
1847         struct megasas_cmd *cmd;
1848         struct megasas_ctrl_info *ctrl_info;
1849
1850         struct megasas_init_frame *init_frame;
1851         struct megasas_init_queue_info *initq_info;
1852         dma_addr_t init_frame_h;
1853         dma_addr_t initq_info_h;
1854
1855         /*
1856          * Map the message registers
1857          */
1858         instance->base_addr = pci_resource_start(instance->pdev, 0);
1859
1860         if (pci_request_regions(instance->pdev, "megasas: LSI Logic")) {
1861                 printk(KERN_DEBUG "megasas: IO memory region busy!\n");
1862                 return -EBUSY;
1863         }
1864
1865         instance->reg_set = ioremap_nocache(instance->base_addr, 8192);
1866
1867         if (!instance->reg_set) {
1868                 printk(KERN_DEBUG "megasas: Failed to map IO mem\n");
1869                 goto fail_ioremap;
1870         }
1871
1872         reg_set = instance->reg_set;
1873
1874         switch(instance->pdev->device)
1875         {
1876                 case PCI_DEVICE_ID_LSI_SAS1078R:        
1877                         instance->instancet = &megasas_instance_template_ppc;
1878                         break;
1879                 case PCI_DEVICE_ID_LSI_SAS1064R:
1880                 case PCI_DEVICE_ID_DELL_PERC5:
1881                 default:
1882                         instance->instancet = &megasas_instance_template_xscale;
1883                         break;
1884         }
1885
1886         /*
1887          * We expect the FW state to be READY
1888          */
1889         if (megasas_transition_to_ready(instance))
1890                 goto fail_ready_state;
1891
1892         /*
1893          * Get various operational parameters from status register
1894          */
1895         instance->max_fw_cmds = instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF;
1896         /*
1897          * Reduce the max supported cmds by 1. This is to ensure that the
1898          * reply_q_sz (1 more than the max cmd that driver may send)
1899          * does not exceed max cmds that the FW can support
1900          */
1901         instance->max_fw_cmds = instance->max_fw_cmds-1;
1902         instance->max_num_sge = (instance->instancet->read_fw_status_reg(reg_set) & 0xFF0000) >> 
1903                                         0x10;
1904         /*
1905          * Create a pool of commands
1906          */
1907         if (megasas_alloc_cmds(instance))
1908                 goto fail_alloc_cmds;
1909
1910         /*
1911          * Allocate memory for reply queue. Length of reply queue should
1912          * be _one_ more than the maximum commands handled by the firmware.
1913          *
1914          * Note: When FW completes commands, it places corresponding contex
1915          * values in this circular reply queue. This circular queue is a fairly
1916          * typical producer-consumer queue. FW is the producer (of completed
1917          * commands) and the driver is the consumer.
1918          */
1919         context_sz = sizeof(u32);
1920         reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
1921
1922         instance->reply_queue = pci_alloc_consistent(instance->pdev,
1923                                                      reply_q_sz,
1924                                                      &instance->reply_queue_h);
1925
1926         if (!instance->reply_queue) {
1927                 printk(KERN_DEBUG "megasas: Out of DMA mem for reply queue\n");
1928                 goto fail_reply_queue;
1929         }
1930
1931         /*
1932          * Prepare a init frame. Note the init frame points to queue info
1933          * structure. Each frame has SGL allocated after first 64 bytes. For
1934          * this frame - since we don't need any SGL - we use SGL's space as
1935          * queue info structure
1936          *
1937          * We will not get a NULL command below. We just created the pool.
1938          */
1939         cmd = megasas_get_cmd(instance);
1940
1941         init_frame = (struct megasas_init_frame *)cmd->frame;
1942         initq_info = (struct megasas_init_queue_info *)
1943             ((unsigned long)init_frame + 64);
1944
1945         init_frame_h = cmd->frame_phys_addr;
1946         initq_info_h = init_frame_h + 64;
1947
1948         memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
1949         memset(initq_info, 0, sizeof(struct megasas_init_queue_info));
1950
1951         initq_info->reply_queue_entries = instance->max_fw_cmds + 1;
1952         initq_info->reply_queue_start_phys_addr_lo = instance->reply_queue_h;
1953
1954         initq_info->producer_index_phys_addr_lo = instance->producer_h;
1955         initq_info->consumer_index_phys_addr_lo = instance->consumer_h;
1956
1957         init_frame->cmd = MFI_CMD_INIT;
1958         init_frame->cmd_status = 0xFF;
1959         init_frame->queue_info_new_phys_addr_lo = initq_info_h;
1960
1961         init_frame->data_xfer_len = sizeof(struct megasas_init_queue_info);
1962
1963         /*
1964          * disable the intr before firing the init frame to FW
1965          */
1966         instance->instancet->disable_intr(instance->reg_set);
1967
1968         /*
1969          * Issue the init frame in polled mode
1970          */
1971         if (megasas_issue_polled(instance, cmd)) {
1972                 printk(KERN_DEBUG "megasas: Failed to init firmware\n");
1973                 goto fail_fw_init;
1974         }
1975
1976         megasas_return_cmd(instance, cmd);
1977
1978         ctrl_info = kmalloc(sizeof(struct megasas_ctrl_info), GFP_KERNEL);
1979
1980         /*
1981          * Compute the max allowed sectors per IO: The controller info has two
1982          * limits on max sectors. Driver should use the minimum of these two.
1983          *
1984          * 1 << stripe_sz_ops.min = max sectors per strip
1985          *
1986          * Note that older firmwares ( < FW ver 30) didn't report information
1987          * to calculate max_sectors_1. So the number ended up as zero always.
1988          */
1989         if (ctrl_info && !megasas_get_ctrl_info(instance, ctrl_info)) {
1990
1991                 max_sectors_1 = (1 << ctrl_info->stripe_sz_ops.min) *
1992                     ctrl_info->max_strips_per_io;
1993                 max_sectors_2 = ctrl_info->max_request_size;
1994
1995                 instance->max_sectors_per_req = (max_sectors_1 < max_sectors_2)
1996                     ? max_sectors_1 : max_sectors_2;
1997         } else
1998                 instance->max_sectors_per_req = instance->max_num_sge *
1999                     PAGE_SIZE / 512;
2000
2001         kfree(ctrl_info);
2002
2003         /*
2004         * Setup tasklet for cmd completion
2005         */
2006
2007         tasklet_init(&instance->isr_tasklet, megasas_complete_cmd_dpc,
2008                         (unsigned long)instance);
2009         return 0;
2010
2011       fail_fw_init:
2012         megasas_return_cmd(instance, cmd);
2013
2014         pci_free_consistent(instance->pdev, reply_q_sz,
2015                             instance->reply_queue, instance->reply_queue_h);
2016       fail_reply_queue:
2017         megasas_free_cmds(instance);
2018
2019       fail_alloc_cmds:
2020       fail_ready_state:
2021         iounmap(instance->reg_set);
2022
2023       fail_ioremap:
2024         pci_release_regions(instance->pdev);
2025
2026         return -EINVAL;
2027 }
2028
2029 /**
2030  * megasas_release_mfi -        Reverses the FW initialization
2031  * @intance:                    Adapter soft state
2032  */
2033 static void megasas_release_mfi(struct megasas_instance *instance)
2034 {
2035         u32 reply_q_sz = sizeof(u32) * (instance->max_fw_cmds + 1);
2036
2037         pci_free_consistent(instance->pdev, reply_q_sz,
2038                             instance->reply_queue, instance->reply_queue_h);
2039
2040         megasas_free_cmds(instance);
2041
2042         iounmap(instance->reg_set);
2043
2044         pci_release_regions(instance->pdev);
2045 }
2046
2047 /**
2048  * megasas_get_seq_num -        Gets latest event sequence numbers
2049  * @instance:                   Adapter soft state
2050  * @eli:                        FW event log sequence numbers information
2051  *
2052  * FW maintains a log of all events in a non-volatile area. Upper layers would
2053  * usually find out the latest sequence number of the events, the seq number at
2054  * the boot etc. They would "read" all the events below the latest seq number
2055  * by issuing a direct fw cmd (DCMD). For the future events (beyond latest seq
2056  * number), they would subsribe to AEN (asynchronous event notification) and
2057  * wait for the events to happen.
2058  */
2059 static int
2060 megasas_get_seq_num(struct megasas_instance *instance,
2061                     struct megasas_evt_log_info *eli)
2062 {
2063         struct megasas_cmd *cmd;
2064         struct megasas_dcmd_frame *dcmd;
2065         struct megasas_evt_log_info *el_info;
2066         dma_addr_t el_info_h = 0;
2067
2068         cmd = megasas_get_cmd(instance);
2069
2070         if (!cmd) {
2071                 return -ENOMEM;
2072         }
2073
2074         dcmd = &cmd->frame->dcmd;
2075         el_info = pci_alloc_consistent(instance->pdev,
2076                                        sizeof(struct megasas_evt_log_info),
2077                                        &el_info_h);
2078
2079         if (!el_info) {
2080                 megasas_return_cmd(instance, cmd);
2081                 return -ENOMEM;
2082         }
2083
2084         memset(el_info, 0, sizeof(*el_info));
2085         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2086
2087         dcmd->cmd = MFI_CMD_DCMD;
2088         dcmd->cmd_status = 0x0;
2089         dcmd->sge_count = 1;
2090         dcmd->flags = MFI_FRAME_DIR_READ;
2091         dcmd->timeout = 0;
2092         dcmd->data_xfer_len = sizeof(struct megasas_evt_log_info);
2093         dcmd->opcode = MR_DCMD_CTRL_EVENT_GET_INFO;
2094         dcmd->sgl.sge32[0].phys_addr = el_info_h;
2095         dcmd->sgl.sge32[0].length = sizeof(struct megasas_evt_log_info);
2096
2097         megasas_issue_blocked_cmd(instance, cmd);
2098
2099         /*
2100          * Copy the data back into callers buffer
2101          */
2102         memcpy(eli, el_info, sizeof(struct megasas_evt_log_info));
2103
2104         pci_free_consistent(instance->pdev, sizeof(struct megasas_evt_log_info),
2105                             el_info, el_info_h);
2106
2107         megasas_return_cmd(instance, cmd);
2108
2109         return 0;
2110 }
2111
2112 /**
2113  * megasas_register_aen -       Registers for asynchronous event notification
2114  * @instance:                   Adapter soft state
2115  * @seq_num:                    The starting sequence number
2116  * @class_locale:               Class of the event
2117  *
2118  * This function subscribes for AEN for events beyond the @seq_num. It requests
2119  * to be notified if and only if the event is of type @class_locale
2120  */
2121 static int
2122 megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
2123                      u32 class_locale_word)
2124 {
2125         int ret_val;
2126         struct megasas_cmd *cmd;
2127         struct megasas_dcmd_frame *dcmd;
2128         union megasas_evt_class_locale curr_aen;
2129         union megasas_evt_class_locale prev_aen;
2130
2131         /*
2132          * If there an AEN pending already (aen_cmd), check if the
2133          * class_locale of that pending AEN is inclusive of the new
2134          * AEN request we currently have. If it is, then we don't have
2135          * to do anything. In other words, whichever events the current
2136          * AEN request is subscribing to, have already been subscribed
2137          * to.
2138          *
2139          * If the old_cmd is _not_ inclusive, then we have to abort
2140          * that command, form a class_locale that is superset of both
2141          * old and current and re-issue to the FW
2142          */
2143
2144         curr_aen.word = class_locale_word;
2145
2146         if (instance->aen_cmd) {
2147
2148                 prev_aen.word = instance->aen_cmd->frame->dcmd.mbox.w[1];
2149
2150                 /*
2151                  * A class whose enum value is smaller is inclusive of all
2152                  * higher values. If a PROGRESS (= -1) was previously
2153                  * registered, then a new registration requests for higher
2154                  * classes need not be sent to FW. They are automatically
2155                  * included.
2156                  *
2157                  * Locale numbers don't have such hierarchy. They are bitmap
2158                  * values
2159                  */
2160                 if ((prev_aen.members.class <= curr_aen.members.class) &&
2161                     !((prev_aen.members.locale & curr_aen.members.locale) ^
2162                       curr_aen.members.locale)) {
2163                         /*
2164                          * Previously issued event registration includes
2165                          * current request. Nothing to do.
2166                          */
2167                         return 0;
2168                 } else {
2169                         curr_aen.members.locale |= prev_aen.members.locale;
2170
2171                         if (prev_aen.members.class < curr_aen.members.class)
2172                                 curr_aen.members.class = prev_aen.members.class;
2173
2174                         instance->aen_cmd->abort_aen = 1;
2175                         ret_val = megasas_issue_blocked_abort_cmd(instance,
2176                                                                   instance->
2177                                                                   aen_cmd);
2178
2179                         if (ret_val) {
2180                                 printk(KERN_DEBUG "megasas: Failed to abort "
2181                                        "previous AEN command\n");
2182                                 return ret_val;
2183                         }
2184                 }
2185         }
2186
2187         cmd = megasas_get_cmd(instance);
2188
2189         if (!cmd)
2190                 return -ENOMEM;
2191
2192         dcmd = &cmd->frame->dcmd;
2193
2194         memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail));
2195
2196         /*
2197          * Prepare DCMD for aen registration
2198          */
2199         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2200
2201         dcmd->cmd = MFI_CMD_DCMD;
2202         dcmd->cmd_status = 0x0;
2203         dcmd->sge_count = 1;
2204         dcmd->flags = MFI_FRAME_DIR_READ;
2205         dcmd->timeout = 0;
2206         dcmd->data_xfer_len = sizeof(struct megasas_evt_detail);
2207         dcmd->opcode = MR_DCMD_CTRL_EVENT_WAIT;
2208         dcmd->mbox.w[0] = seq_num;
2209         dcmd->mbox.w[1] = curr_aen.word;
2210         dcmd->sgl.sge32[0].phys_addr = (u32) instance->evt_detail_h;
2211         dcmd->sgl.sge32[0].length = sizeof(struct megasas_evt_detail);
2212
2213         /*
2214          * Store reference to the cmd used to register for AEN. When an
2215          * application wants us to register for AEN, we have to abort this
2216          * cmd and re-register with a new EVENT LOCALE supplied by that app
2217          */
2218         instance->aen_cmd = cmd;
2219
2220         /*
2221          * Issue the aen registration frame
2222          */
2223         instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
2224
2225         return 0;
2226 }
2227
2228 /**
2229  * megasas_start_aen -  Subscribes to AEN during driver load time
2230  * @instance:           Adapter soft state
2231  */
2232 static int megasas_start_aen(struct megasas_instance *instance)
2233 {
2234         struct megasas_evt_log_info eli;
2235         union megasas_evt_class_locale class_locale;
2236
2237         /*
2238          * Get the latest sequence number from FW
2239          */
2240         memset(&eli, 0, sizeof(eli));
2241
2242         if (megasas_get_seq_num(instance, &eli))
2243                 return -1;
2244
2245         /*
2246          * Register AEN with FW for latest sequence number plus 1
2247          */
2248         class_locale.members.reserved = 0;
2249         class_locale.members.locale = MR_EVT_LOCALE_ALL;
2250         class_locale.members.class = MR_EVT_CLASS_DEBUG;
2251
2252         return megasas_register_aen(instance, eli.newest_seq_num + 1,
2253                                     class_locale.word);
2254 }
2255
2256 /**
2257  * megasas_io_attach -  Attaches this driver to SCSI mid-layer
2258  * @instance:           Adapter soft state
2259  */
2260 static int megasas_io_attach(struct megasas_instance *instance)
2261 {
2262         struct Scsi_Host *host = instance->host;
2263
2264         /*
2265          * Export parameters required by SCSI mid-layer
2266          */
2267         host->irq = instance->pdev->irq;
2268         host->unique_id = instance->unique_id;
2269         host->can_queue = instance->max_fw_cmds - MEGASAS_INT_CMDS;
2270         host->this_id = instance->init_id;
2271         host->sg_tablesize = instance->max_num_sge;
2272         host->max_sectors = instance->max_sectors_per_req;
2273         host->cmd_per_lun = 128;
2274         host->max_channel = MEGASAS_MAX_CHANNELS - 1;
2275         host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL;
2276         host->max_lun = MEGASAS_MAX_LUN;
2277         host->max_cmd_len = 16;
2278
2279         /*
2280          * Notify the mid-layer about the new controller
2281          */
2282         if (scsi_add_host(host, &instance->pdev->dev)) {
2283                 printk(KERN_DEBUG "megasas: scsi_add_host failed\n");
2284                 return -ENODEV;
2285         }
2286
2287         /*
2288          * Trigger SCSI to scan our drives
2289          */
2290         scsi_scan_host(host);
2291         return 0;
2292 }
2293
2294 /**
2295  * megasas_probe_one -  PCI hotplug entry point
2296  * @pdev:               PCI device structure
2297  * @id:                 PCI ids of supported hotplugged adapter 
2298  */
2299 static int __devinit
2300 megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
2301 {
2302         int rval;
2303         struct Scsi_Host *host;
2304         struct megasas_instance *instance;
2305
2306         /*
2307          * Announce PCI information
2308          */
2309         printk(KERN_INFO "megasas: %#4.04x:%#4.04x:%#4.04x:%#4.04x: ",
2310                pdev->vendor, pdev->device, pdev->subsystem_vendor,
2311                pdev->subsystem_device);
2312
2313         printk("bus %d:slot %d:func %d\n",
2314                pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
2315
2316         /*
2317          * PCI prepping: enable device set bus mastering and dma mask
2318          */
2319         rval = pci_enable_device(pdev);
2320
2321         if (rval) {
2322                 return rval;
2323         }
2324
2325         pci_set_master(pdev);
2326
2327         /*
2328          * All our contollers are capable of performing 64-bit DMA
2329          */
2330         if (IS_DMA64) {
2331                 if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) != 0) {
2332
2333                         if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0)
2334                                 goto fail_set_dma_mask;
2335                 }
2336         } else {
2337                 if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0)
2338                         goto fail_set_dma_mask;
2339         }
2340
2341         host = scsi_host_alloc(&megasas_template,
2342                                sizeof(struct megasas_instance));
2343
2344         if (!host) {
2345                 printk(KERN_DEBUG "megasas: scsi_host_alloc failed\n");
2346                 goto fail_alloc_instance;
2347         }
2348
2349         instance = (struct megasas_instance *)host->hostdata;
2350         memset(instance, 0, sizeof(*instance));
2351
2352         instance->producer = pci_alloc_consistent(pdev, sizeof(u32),
2353                                                   &instance->producer_h);
2354         instance->consumer = pci_alloc_consistent(pdev, sizeof(u32),
2355                                                   &instance->consumer_h);
2356
2357         if (!instance->producer || !instance->consumer) {
2358                 printk(KERN_DEBUG "megasas: Failed to allocate memory for "
2359                        "producer, consumer\n");
2360                 goto fail_alloc_dma_buf;
2361         }
2362
2363         *instance->producer = 0;
2364         *instance->consumer = 0;
2365
2366         instance->evt_detail = pci_alloc_consistent(pdev,
2367                                                     sizeof(struct
2368                                                            megasas_evt_detail),
2369                                                     &instance->evt_detail_h);
2370
2371         if (!instance->evt_detail) {
2372                 printk(KERN_DEBUG "megasas: Failed to allocate memory for "
2373                        "event detail structure\n");
2374                 goto fail_alloc_dma_buf;
2375         }
2376
2377         /*
2378          * Initialize locks and queues
2379          */
2380         INIT_LIST_HEAD(&instance->cmd_pool);
2381
2382         atomic_set(&instance->fw_outstanding,0);
2383
2384         init_waitqueue_head(&instance->int_cmd_wait_q);
2385         init_waitqueue_head(&instance->abort_cmd_wait_q);
2386
2387         spin_lock_init(&instance->cmd_pool_lock);
2388
2389         sema_init(&instance->aen_mutex, 1);
2390         sema_init(&instance->ioctl_sem, MEGASAS_INT_CMDS);
2391
2392         /*
2393          * Initialize PCI related and misc parameters
2394          */
2395         instance->pdev = pdev;
2396         instance->host = host;
2397         instance->unique_id = pdev->bus->number << 8 | pdev->devfn;
2398         instance->init_id = MEGASAS_DEFAULT_INIT_ID;
2399
2400         megasas_dbg_lvl = 0;
2401
2402         /*
2403          * Initialize MFI Firmware
2404          */
2405         if (megasas_init_mfi(instance))
2406                 goto fail_init_mfi;
2407
2408         /*
2409          * Register IRQ
2410          */
2411         if (request_irq(pdev->irq, megasas_isr, IRQF_SHARED, "megasas", instance)) {
2412                 printk(KERN_DEBUG "megasas: Failed to register IRQ\n");
2413                 goto fail_irq;
2414         }
2415
2416         instance->instancet->enable_intr(instance->reg_set);
2417
2418         /*
2419          * Store instance in PCI softstate
2420          */
2421         pci_set_drvdata(pdev, instance);
2422
2423         /*
2424          * Add this controller to megasas_mgmt_info structure so that it
2425          * can be exported to management applications
2426          */
2427         megasas_mgmt_info.count++;
2428         megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance;
2429         megasas_mgmt_info.max_index++;
2430
2431         /*
2432          * Initiate AEN (Asynchronous Event Notification)
2433          */
2434         if (megasas_start_aen(instance)) {
2435                 printk(KERN_DEBUG "megasas: start aen failed\n");
2436                 goto fail_start_aen;
2437         }
2438
2439         /*
2440          * Register with SCSI mid-layer
2441          */
2442         if (megasas_io_attach(instance))
2443                 goto fail_io_attach;
2444
2445         return 0;
2446
2447       fail_start_aen:
2448       fail_io_attach:
2449         megasas_mgmt_info.count--;
2450         megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL;
2451         megasas_mgmt_info.max_index--;
2452
2453         pci_set_drvdata(pdev, NULL);
2454         instance->instancet->disable_intr(instance->reg_set);
2455         free_irq(instance->pdev->irq, instance);
2456
2457         megasas_release_mfi(instance);
2458
2459       fail_irq:
2460       fail_init_mfi:
2461       fail_alloc_dma_buf:
2462         if (instance->evt_detail)
2463                 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
2464                                     instance->evt_detail,
2465                                     instance->evt_detail_h);
2466
2467         if (instance->producer)
2468                 pci_free_consistent(pdev, sizeof(u32), instance->producer,
2469                                     instance->producer_h);
2470         if (instance->consumer)
2471                 pci_free_consistent(pdev, sizeof(u32), instance->consumer,
2472                                     instance->consumer_h);
2473         scsi_host_put(host);
2474
2475       fail_alloc_instance:
2476       fail_set_dma_mask:
2477         pci_disable_device(pdev);
2478
2479         return -ENODEV;
2480 }
2481
2482 /**
2483  * megasas_flush_cache -        Requests FW to flush all its caches
2484  * @instance:                   Adapter soft state
2485  */
2486 static void megasas_flush_cache(struct megasas_instance *instance)
2487 {
2488         struct megasas_cmd *cmd;
2489         struct megasas_dcmd_frame *dcmd;
2490
2491         cmd = megasas_get_cmd(instance);
2492
2493         if (!cmd)
2494                 return;
2495
2496         dcmd = &cmd->frame->dcmd;
2497
2498         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2499
2500         dcmd->cmd = MFI_CMD_DCMD;
2501         dcmd->cmd_status = 0x0;
2502         dcmd->sge_count = 0;
2503         dcmd->flags = MFI_FRAME_DIR_NONE;
2504         dcmd->timeout = 0;
2505         dcmd->data_xfer_len = 0;
2506         dcmd->opcode = MR_DCMD_CTRL_CACHE_FLUSH;
2507         dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
2508
2509         megasas_issue_blocked_cmd(instance, cmd);
2510
2511         megasas_return_cmd(instance, cmd);
2512
2513         return;
2514 }
2515
2516 /**
2517  * megasas_shutdown_controller -        Instructs FW to shutdown the controller
2518  * @instance:                           Adapter soft state
2519  */
2520 static void megasas_shutdown_controller(struct megasas_instance *instance)
2521 {
2522         struct megasas_cmd *cmd;
2523         struct megasas_dcmd_frame *dcmd;
2524
2525         cmd = megasas_get_cmd(instance);
2526
2527         if (!cmd)
2528                 return;
2529
2530         if (instance->aen_cmd)
2531                 megasas_issue_blocked_abort_cmd(instance, instance->aen_cmd);
2532
2533         dcmd = &cmd->frame->dcmd;
2534
2535         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2536
2537         dcmd->cmd = MFI_CMD_DCMD;
2538         dcmd->cmd_status = 0x0;
2539         dcmd->sge_count = 0;
2540         dcmd->flags = MFI_FRAME_DIR_NONE;
2541         dcmd->timeout = 0;
2542         dcmd->data_xfer_len = 0;
2543         dcmd->opcode = MR_DCMD_CTRL_SHUTDOWN;
2544
2545         megasas_issue_blocked_cmd(instance, cmd);
2546
2547         megasas_return_cmd(instance, cmd);
2548
2549         return;
2550 }
2551
2552 /**
2553  * megasas_detach_one - PCI hot"un"plug entry point
2554  * @pdev:               PCI device structure
2555  */
2556 static void megasas_detach_one(struct pci_dev *pdev)
2557 {
2558         int i;
2559         struct Scsi_Host *host;
2560         struct megasas_instance *instance;
2561
2562         instance = pci_get_drvdata(pdev);
2563         host = instance->host;
2564
2565         scsi_remove_host(instance->host);
2566         megasas_flush_cache(instance);
2567         megasas_shutdown_controller(instance);
2568         tasklet_kill(&instance->isr_tasklet);
2569
2570         /*
2571          * Take the instance off the instance array. Note that we will not
2572          * decrement the max_index. We let this array be sparse array
2573          */
2574         for (i = 0; i < megasas_mgmt_info.max_index; i++) {
2575                 if (megasas_mgmt_info.instance[i] == instance) {
2576                         megasas_mgmt_info.count--;
2577                         megasas_mgmt_info.instance[i] = NULL;
2578
2579                         break;
2580                 }
2581         }
2582
2583         pci_set_drvdata(instance->pdev, NULL);
2584
2585         instance->instancet->disable_intr(instance->reg_set);
2586
2587         free_irq(instance->pdev->irq, instance);
2588
2589         megasas_release_mfi(instance);
2590
2591         pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
2592                             instance->evt_detail, instance->evt_detail_h);
2593
2594         pci_free_consistent(pdev, sizeof(u32), instance->producer,
2595                             instance->producer_h);
2596
2597         pci_free_consistent(pdev, sizeof(u32), instance->consumer,
2598                             instance->consumer_h);
2599
2600         scsi_host_put(host);
2601
2602         pci_set_drvdata(pdev, NULL);
2603
2604         pci_disable_device(pdev);
2605
2606         return;
2607 }
2608
2609 /**
2610  * megasas_shutdown -   Shutdown entry point
2611  * @device:             Generic device structure
2612  */
2613 static void megasas_shutdown(struct pci_dev *pdev)
2614 {
2615         struct megasas_instance *instance = pci_get_drvdata(pdev);
2616         megasas_flush_cache(instance);
2617 }
2618
2619 /**
2620  * megasas_mgmt_open -  char node "open" entry point
2621  */
2622 static int megasas_mgmt_open(struct inode *inode, struct file *filep)
2623 {
2624         /*
2625          * Allow only those users with admin rights
2626          */
2627         if (!capable(CAP_SYS_ADMIN))
2628                 return -EACCES;
2629
2630         return 0;
2631 }
2632
2633 /**
2634  * megasas_mgmt_release - char node "release" entry point
2635  */
2636 static int megasas_mgmt_release(struct inode *inode, struct file *filep)
2637 {
2638         filep->private_data = NULL;
2639         fasync_helper(-1, filep, 0, &megasas_async_queue);
2640
2641         return 0;
2642 }
2643
2644 /**
2645  * megasas_mgmt_fasync -        Async notifier registration from applications
2646  *
2647  * This function adds the calling process to a driver global queue. When an
2648  * event occurs, SIGIO will be sent to all processes in this queue.
2649  */
2650 static int megasas_mgmt_fasync(int fd, struct file *filep, int mode)
2651 {
2652         int rc;
2653
2654         mutex_lock(&megasas_async_queue_mutex);
2655
2656         rc = fasync_helper(fd, filep, mode, &megasas_async_queue);
2657
2658         mutex_unlock(&megasas_async_queue_mutex);
2659
2660         if (rc >= 0) {
2661                 /* For sanity check when we get ioctl */
2662                 filep->private_data = filep;
2663                 return 0;
2664         }
2665
2666         printk(KERN_DEBUG "megasas: fasync_helper failed [%d]\n", rc);
2667
2668         return rc;
2669 }
2670
2671 /**
2672  * megasas_mgmt_fw_ioctl -      Issues management ioctls to FW
2673  * @instance:                   Adapter soft state
2674  * @argp:                       User's ioctl packet
2675  */
2676 static int
2677 megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
2678                       struct megasas_iocpacket __user * user_ioc,
2679                       struct megasas_iocpacket *ioc)
2680 {
2681         struct megasas_sge32 *kern_sge32;
2682         struct megasas_cmd *cmd;
2683         void *kbuff_arr[MAX_IOCTL_SGE];
2684         dma_addr_t buf_handle = 0;
2685         int error = 0, i;
2686         void *sense = NULL;
2687         dma_addr_t sense_handle;
2688         u32 *sense_ptr;
2689
2690         memset(kbuff_arr, 0, sizeof(kbuff_arr));
2691
2692         if (ioc->sge_count > MAX_IOCTL_SGE) {
2693                 printk(KERN_DEBUG "megasas: SGE count [%d] >  max limit [%d]\n",
2694                        ioc->sge_count, MAX_IOCTL_SGE);
2695                 return -EINVAL;
2696         }
2697
2698         cmd = megasas_get_cmd(instance);
2699         if (!cmd) {
2700                 printk(KERN_DEBUG "megasas: Failed to get a cmd packet\n");
2701                 return -ENOMEM;
2702         }
2703
2704         /*
2705          * User's IOCTL packet has 2 frames (maximum). Copy those two
2706          * frames into our cmd's frames. cmd->frame's context will get
2707          * overwritten when we copy from user's frames. So set that value
2708          * alone separately
2709          */
2710         memcpy(cmd->frame, ioc->frame.raw, 2 * MEGAMFI_FRAME_SIZE);
2711         cmd->frame->hdr.context = cmd->index;
2712
2713         /*
2714          * The management interface between applications and the fw uses
2715          * MFI frames. E.g, RAID configuration changes, LD property changes
2716          * etc are accomplishes through different kinds of MFI frames. The
2717          * driver needs to care only about substituting user buffers with
2718          * kernel buffers in SGLs. The location of SGL is embedded in the
2719          * struct iocpacket itself.
2720          */
2721         kern_sge32 = (struct megasas_sge32 *)
2722             ((unsigned long)cmd->frame + ioc->sgl_off);
2723
2724         /*
2725          * For each user buffer, create a mirror buffer and copy in
2726          */
2727         for (i = 0; i < ioc->sge_count; i++) {
2728                 kbuff_arr[i] = dma_alloc_coherent(&instance->pdev->dev,
2729                                                     ioc->sgl[i].iov_len,
2730                                                     &buf_handle, GFP_KERNEL);
2731                 if (!kbuff_arr[i]) {
2732                         printk(KERN_DEBUG "megasas: Failed to alloc "
2733                                "kernel SGL buffer for IOCTL \n");
2734                         error = -ENOMEM;
2735                         goto out;
2736                 }
2737
2738                 /*
2739                  * We don't change the dma_coherent_mask, so
2740                  * pci_alloc_consistent only returns 32bit addresses
2741                  */
2742                 kern_sge32[i].phys_addr = (u32) buf_handle;
2743                 kern_sge32[i].length = ioc->sgl[i].iov_len;
2744
2745                 /*
2746                  * We created a kernel buffer corresponding to the
2747                  * user buffer. Now copy in from the user buffer
2748                  */
2749                 if (copy_from_user(kbuff_arr[i], ioc->sgl[i].iov_base,
2750                                    (u32) (ioc->sgl[i].iov_len))) {
2751                         error = -EFAULT;
2752                         goto out;
2753                 }
2754         }
2755
2756         if (ioc->sense_len) {
2757                 sense = dma_alloc_coherent(&instance->pdev->dev, ioc->sense_len,
2758                                              &sense_handle, GFP_KERNEL);
2759                 if (!sense) {
2760                         error = -ENOMEM;
2761                         goto out;
2762                 }
2763
2764                 sense_ptr =
2765                     (u32 *) ((unsigned long)cmd->frame + ioc->sense_off);
2766                 *sense_ptr = sense_handle;
2767         }
2768
2769         /*
2770          * Set the sync_cmd flag so that the ISR knows not to complete this
2771          * cmd to the SCSI mid-layer
2772          */
2773         cmd->sync_cmd = 1;
2774         megasas_issue_blocked_cmd(instance, cmd);
2775         cmd->sync_cmd = 0;
2776
2777         /*
2778          * copy out the kernel buffers to user buffers
2779          */
2780         for (i = 0; i < ioc->sge_count; i++) {
2781                 if (copy_to_user(ioc->sgl[i].iov_base, kbuff_arr[i],
2782                                  ioc->sgl[i].iov_len)) {
2783                         error = -EFAULT;
2784                         goto out;
2785                 }
2786         }
2787
2788         /*
2789          * copy out the sense
2790          */
2791         if (ioc->sense_len) {
2792                 /*
2793                  * sense_ptr points to the location that has the user
2794                  * sense buffer address
2795                  */
2796                 sense_ptr = (u32 *) ((unsigned long)ioc->frame.raw +
2797                                      ioc->sense_off);
2798
2799                 if (copy_to_user((void __user *)((unsigned long)(*sense_ptr)),
2800                                  sense, ioc->sense_len)) {
2801                         error = -EFAULT;
2802                         goto out;
2803                 }
2804         }
2805
2806         /*
2807          * copy the status codes returned by the fw
2808          */
2809         if (copy_to_user(&user_ioc->frame.hdr.cmd_status,
2810                          &cmd->frame->hdr.cmd_status, sizeof(u8))) {
2811                 printk(KERN_DEBUG "megasas: Error copying out cmd_status\n");
2812                 error = -EFAULT;
2813         }
2814
2815       out:
2816         if (sense) {
2817                 dma_free_coherent(&instance->pdev->dev, ioc->sense_len,
2818                                     sense, sense_handle);
2819         }
2820
2821         for (i = 0; i < ioc->sge_count && kbuff_arr[i]; i++) {
2822                 dma_free_coherent(&instance->pdev->dev,
2823                                     kern_sge32[i].length,
2824                                     kbuff_arr[i], kern_sge32[i].phys_addr);
2825         }
2826
2827         megasas_return_cmd(instance, cmd);
2828         return error;
2829 }
2830
2831 static struct megasas_instance *megasas_lookup_instance(u16 host_no)
2832 {
2833         int i;
2834
2835         for (i = 0; i < megasas_mgmt_info.max_index; i++) {
2836
2837                 if ((megasas_mgmt_info.instance[i]) &&
2838                     (megasas_mgmt_info.instance[i]->host->host_no == host_no))
2839                         return megasas_mgmt_info.instance[i];
2840         }
2841
2842         return NULL;
2843 }
2844
2845 static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
2846 {
2847         struct megasas_iocpacket __user *user_ioc =
2848             (struct megasas_iocpacket __user *)arg;
2849         struct megasas_iocpacket *ioc;
2850         struct megasas_instance *instance;
2851         int error;
2852
2853         ioc = kmalloc(sizeof(*ioc), GFP_KERNEL);
2854         if (!ioc)
2855                 return -ENOMEM;
2856
2857         if (copy_from_user(ioc, user_ioc, sizeof(*ioc))) {
2858                 error = -EFAULT;
2859                 goto out_kfree_ioc;
2860         }
2861
2862         instance = megasas_lookup_instance(ioc->host_no);
2863         if (!instance) {
2864                 error = -ENODEV;
2865                 goto out_kfree_ioc;
2866         }
2867
2868         /*
2869          * We will allow only MEGASAS_INT_CMDS number of parallel ioctl cmds
2870          */
2871         if (down_interruptible(&instance->ioctl_sem)) {
2872                 error = -ERESTARTSYS;
2873                 goto out_kfree_ioc;
2874         }
2875         error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc);
2876         up(&instance->ioctl_sem);
2877
2878       out_kfree_ioc:
2879         kfree(ioc);
2880         return error;
2881 }
2882
2883 static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
2884 {
2885         struct megasas_instance *instance;
2886         struct megasas_aen aen;
2887         int error;
2888
2889         if (file->private_data != file) {
2890                 printk(KERN_DEBUG "megasas: fasync_helper was not "
2891                        "called first\n");
2892                 return -EINVAL;
2893         }
2894
2895         if (copy_from_user(&aen, (void __user *)arg, sizeof(aen)))
2896                 return -EFAULT;
2897
2898         instance = megasas_lookup_instance(aen.host_no);
2899
2900         if (!instance)
2901                 return -ENODEV;
2902
2903         down(&instance->aen_mutex);
2904         error = megasas_register_aen(instance, aen.seq_num,
2905                                      aen.class_locale_word);
2906         up(&instance->aen_mutex);
2907         return error;
2908 }
2909
2910 /**
2911  * megasas_mgmt_ioctl - char node ioctl entry point
2912  */
2913 static long
2914 megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2915 {
2916         switch (cmd) {
2917         case MEGASAS_IOC_FIRMWARE:
2918                 return megasas_mgmt_ioctl_fw(file, arg);
2919
2920         case MEGASAS_IOC_GET_AEN:
2921                 return megasas_mgmt_ioctl_aen(file, arg);
2922         }
2923
2924         return -ENOTTY;
2925 }
2926
2927 #ifdef CONFIG_COMPAT
2928 static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
2929 {
2930         struct compat_megasas_iocpacket __user *cioc =
2931             (struct compat_megasas_iocpacket __user *)arg;
2932         struct megasas_iocpacket __user *ioc =
2933             compat_alloc_user_space(sizeof(struct megasas_iocpacket));
2934         int i;
2935         int error = 0;
2936
2937         if (clear_user(ioc, sizeof(*ioc)))
2938                 return -EFAULT;
2939
2940         if (copy_in_user(&ioc->host_no, &cioc->host_no, sizeof(u16)) ||
2941             copy_in_user(&ioc->sgl_off, &cioc->sgl_off, sizeof(u32)) ||
2942             copy_in_user(&ioc->sense_off, &cioc->sense_off, sizeof(u32)) ||
2943             copy_in_user(&ioc->sense_len, &cioc->sense_len, sizeof(u32)) ||
2944             copy_in_user(ioc->frame.raw, cioc->frame.raw, 128) ||
2945             copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32)))
2946                 return -EFAULT;
2947
2948         for (i = 0; i < MAX_IOCTL_SGE; i++) {
2949                 compat_uptr_t ptr;
2950
2951                 if (get_user(ptr, &cioc->sgl[i].iov_base) ||
2952                     put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) ||
2953                     copy_in_user(&ioc->sgl[i].iov_len,
2954                                  &cioc->sgl[i].iov_len, sizeof(compat_size_t)))
2955                         return -EFAULT;
2956         }
2957
2958         error = megasas_mgmt_ioctl_fw(file, (unsigned long)ioc);
2959
2960         if (copy_in_user(&cioc->frame.hdr.cmd_status,
2961                          &ioc->frame.hdr.cmd_status, sizeof(u8))) {
2962                 printk(KERN_DEBUG "megasas: error copy_in_user cmd_status\n");
2963                 return -EFAULT;
2964         }
2965         return error;
2966 }
2967
2968 static long
2969 megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd,
2970                           unsigned long arg)
2971 {
2972         switch (cmd) {
2973         case MEGASAS_IOC_FIRMWARE32:
2974                 return megasas_mgmt_compat_ioctl_fw(file, arg);
2975         case MEGASAS_IOC_GET_AEN:
2976                 return megasas_mgmt_ioctl_aen(file, arg);
2977         }
2978
2979         return -ENOTTY;
2980 }
2981 #endif
2982
2983 /*
2984  * File operations structure for management interface
2985  */
2986 static const struct file_operations megasas_mgmt_fops = {
2987         .owner = THIS_MODULE,
2988         .open = megasas_mgmt_open,
2989         .release = megasas_mgmt_release,
2990         .fasync = megasas_mgmt_fasync,
2991         .unlocked_ioctl = megasas_mgmt_ioctl,
2992 #ifdef CONFIG_COMPAT
2993         .compat_ioctl = megasas_mgmt_compat_ioctl,
2994 #endif
2995 };
2996
2997 /*
2998  * PCI hotplug support registration structure
2999  */
3000 static struct pci_driver megasas_pci_driver = {
3001
3002         .name = "megaraid_sas",
3003         .id_table = megasas_pci_table,
3004         .probe = megasas_probe_one,
3005         .remove = __devexit_p(megasas_detach_one),
3006         .shutdown = megasas_shutdown,
3007 };
3008
3009 /*
3010  * Sysfs driver attributes
3011  */
3012 static ssize_t megasas_sysfs_show_version(struct device_driver *dd, char *buf)
3013 {
3014         return snprintf(buf, strlen(MEGASAS_VERSION) + 2, "%s\n",
3015                         MEGASAS_VERSION);
3016 }
3017
3018 static DRIVER_ATTR(version, S_IRUGO, megasas_sysfs_show_version, NULL);
3019
3020 static ssize_t
3021 megasas_sysfs_show_release_date(struct device_driver *dd, char *buf)
3022 {
3023         return snprintf(buf, strlen(MEGASAS_RELDATE) + 2, "%s\n",
3024                         MEGASAS_RELDATE);
3025 }
3026
3027 static DRIVER_ATTR(release_date, S_IRUGO, megasas_sysfs_show_release_date,
3028                    NULL);
3029
3030 static ssize_t
3031 megasas_sysfs_show_dbg_lvl(struct device_driver *dd, char *buf)
3032 {
3033         return sprintf(buf,"%u",megasas_dbg_lvl);
3034 }
3035
3036 static ssize_t
3037 megasas_sysfs_set_dbg_lvl(struct device_driver *dd, const char *buf, size_t count)
3038 {
3039         int retval = count;
3040         if(sscanf(buf,"%u",&megasas_dbg_lvl)<1){
3041                 printk(KERN_ERR "megasas: could not set dbg_lvl\n");
3042                 retval = -EINVAL;
3043         }
3044         return retval;
3045 }
3046
3047 static DRIVER_ATTR(dbg_lvl, S_IRUGO|S_IWUGO, megasas_sysfs_show_dbg_lvl,
3048                    megasas_sysfs_set_dbg_lvl);
3049
3050 /**
3051  * megasas_init - Driver load entry point
3052  */
3053 static int __init megasas_init(void)
3054 {
3055         int rval;
3056
3057         /*
3058          * Announce driver version and other information
3059          */
3060         printk(KERN_INFO "megasas: %s %s\n", MEGASAS_VERSION,
3061                MEGASAS_EXT_VERSION);
3062
3063         memset(&megasas_mgmt_info, 0, sizeof(megasas_mgmt_info));
3064
3065         /*
3066          * Register character device node
3067          */
3068         rval = register_chrdev(0, "megaraid_sas_ioctl", &megasas_mgmt_fops);
3069
3070         if (rval < 0) {
3071                 printk(KERN_DEBUG "megasas: failed to open device node\n");
3072                 return rval;
3073         }
3074
3075         megasas_mgmt_majorno = rval;
3076
3077         /*
3078          * Register ourselves as PCI hotplug module
3079          */
3080         rval = pci_register_driver(&megasas_pci_driver);
3081
3082         if (rval) {
3083                 printk(KERN_DEBUG "megasas: PCI hotplug regisration failed \n");
3084                 goto err_pcidrv;
3085         }
3086
3087         rval = driver_create_file(&megasas_pci_driver.driver,
3088                                   &driver_attr_version);
3089         if (rval)
3090                 goto err_dcf_attr_ver;
3091         rval = driver_create_file(&megasas_pci_driver.driver,
3092                                   &driver_attr_release_date);
3093         if (rval)
3094                 goto err_dcf_rel_date;
3095         rval = driver_create_file(&megasas_pci_driver.driver,
3096                                   &driver_attr_dbg_lvl);
3097         if (rval)
3098                 goto err_dcf_dbg_lvl;
3099
3100         return rval;
3101 err_dcf_dbg_lvl:
3102         driver_remove_file(&megasas_pci_driver.driver,
3103                            &driver_attr_release_date);
3104 err_dcf_rel_date:
3105         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
3106 err_dcf_attr_ver:
3107         pci_unregister_driver(&megasas_pci_driver);
3108 err_pcidrv:
3109         unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
3110         return rval;
3111 }
3112
3113 /**
3114  * megasas_exit - Driver unload entry point
3115  */
3116 static void __exit megasas_exit(void)
3117 {
3118         driver_remove_file(&megasas_pci_driver.driver,
3119                            &driver_attr_dbg_lvl);
3120         driver_remove_file(&megasas_pci_driver.driver,
3121                            &driver_attr_release_date);
3122         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
3123
3124         pci_unregister_driver(&megasas_pci_driver);
3125         unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
3126 }
3127
3128 module_init(megasas_init);
3129 module_exit(megasas_exit);