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