Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
megaraid_sas_fusion.c
Go to the documentation of this file.
1 /*
2  * Linux MegaRAID driver for SAS based RAID controllers
3  *
4  * Copyright (c) 2009-2012 LSI Corporation.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  *
20  * FILE: megaraid_sas_fusion.c
21  *
22  * Authors: LSI Corporation
23  * Sumant Patro
24  * Adam Radford <[email protected]>
25  *
26  * Send feedback to: <[email protected]>
27  *
28  * Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
29  * ATTN: Linuxraid
30  */
31 
32 #include <linux/kernel.h>
33 #include <linux/types.h>
34 #include <linux/pci.h>
35 #include <linux/list.h>
36 #include <linux/moduleparam.h>
37 #include <linux/module.h>
38 #include <linux/spinlock.h>
39 #include <linux/interrupt.h>
40 #include <linux/delay.h>
41 #include <linux/uio.h>
42 #include <linux/uaccess.h>
43 #include <linux/fs.h>
44 #include <linux/compat.h>
45 #include <linux/blkdev.h>
46 #include <linux/mutex.h>
47 #include <linux/poll.h>
48 
49 #include <scsi/scsi.h>
50 #include <scsi/scsi_cmnd.h>
51 #include <scsi/scsi_device.h>
52 #include <scsi/scsi_host.h>
53 
54 #include "megaraid_sas_fusion.h"
55 #include "megaraid_sas.h"
56 
57 extern void megasas_free_cmds(struct megasas_instance *instance);
58 extern struct megasas_cmd *megasas_get_cmd(struct megasas_instance
59  *instance);
60 extern void
61 megasas_complete_cmd(struct megasas_instance *instance,
62  struct megasas_cmd *cmd, u8 alt_status);
63 int megasas_is_ldio(struct scsi_cmnd *cmd);
64 int
65 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd);
66 
67 void
68 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd);
69 int megasas_alloc_cmds(struct megasas_instance *instance);
70 int
71 megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs);
72 int
73 megasas_issue_polled(struct megasas_instance *instance,
74  struct megasas_cmd *cmd);
75 
76 u8
77 MR_BuildRaidContext(struct megasas_instance *instance,
78  struct IO_REQUEST_INFO *io_info,
79  struct RAID_CONTEXT *pRAID_Context,
80  struct MR_FW_RAID_MAP_ALL *map);
81 u16 MR_TargetIdToLdGet(u32 ldTgtId, struct MR_FW_RAID_MAP_ALL *map);
82 struct MR_LD_RAID *MR_LdRaidGet(u32 ld, struct MR_FW_RAID_MAP_ALL *map);
83 
84 u16 MR_GetLDTgtId(u32 ld, struct MR_FW_RAID_MAP_ALL *map);
85 
86 void
87 megasas_check_and_restore_queue_depth(struct megasas_instance *instance);
88 
89 u8 MR_ValidateMapInfo(struct MR_FW_RAID_MAP_ALL *map,
90  struct LD_LOAD_BALANCE_INFO *lbInfo);
91 u16 get_updated_dev_handle(struct LD_LOAD_BALANCE_INFO *lbInfo,
92  struct IO_REQUEST_INFO *in_info);
93 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
94 void megaraid_sas_kill_hba(struct megasas_instance *instance);
95 
96 extern u32 megasas_dbg_lvl;
97 extern int resetwaittime;
98 
103 void
104 megasas_enable_intr_fusion(struct megasas_register_set __iomem *regs)
105 {
106  /* For Thunderbolt/Invader also clear intr on enable */
107  writel(~0, &regs->outbound_intr_status);
108  readl(&regs->outbound_intr_status);
109 
110  writel(~MFI_FUSION_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
111 
112  /* Dummy readl to force pci flush */
113  readl(&regs->outbound_intr_mask);
114 }
115 
120 void
121 megasas_disable_intr_fusion(struct megasas_register_set __iomem *regs)
122 {
123  u32 mask = 0xFFFFFFFF;
124  u32 status;
125 
126  writel(mask, &regs->outbound_intr_mask);
127  /* Dummy readl to force pci flush */
128  status = readl(&regs->outbound_intr_mask);
129 }
130 
131 int
132 megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs)
133 {
134  u32 status;
135  /*
136  * Check if it is our interrupt
137  */
138  status = readl(&regs->outbound_intr_status);
139 
140  if (status & 1) {
141  writel(status, &regs->outbound_intr_status);
142  readl(&regs->outbound_intr_status);
143  return 1;
144  }
145  if (!(status & MFI_FUSION_ENABLE_INTERRUPT_MASK))
146  return 0;
147 
148  return 1;
149 }
150 
157 struct megasas_cmd_fusion *megasas_get_cmd_fusion(struct megasas_instance
158  *instance)
159 {
160  unsigned long flags;
161  struct fusion_context *fusion =
162  (struct fusion_context *)instance->ctrl_context;
163  struct megasas_cmd_fusion *cmd = NULL;
164 
165  spin_lock_irqsave(&fusion->cmd_pool_lock, flags);
166 
167  if (!list_empty(&fusion->cmd_pool)) {
168  cmd = list_entry((&fusion->cmd_pool)->next,
169  struct megasas_cmd_fusion, list);
170  list_del_init(&cmd->list);
171  } else {
172  printk(KERN_ERR "megasas: Command pool (fusion) empty!\n");
173  }
174 
175  spin_unlock_irqrestore(&fusion->cmd_pool_lock, flags);
176  return cmd;
177 }
178 
184 static inline void
185 megasas_return_cmd_fusion(struct megasas_instance *instance,
186  struct megasas_cmd_fusion *cmd)
187 {
188  unsigned long flags;
189  struct fusion_context *fusion =
190  (struct fusion_context *)instance->ctrl_context;
191 
192  spin_lock_irqsave(&fusion->cmd_pool_lock, flags);
193 
194  cmd->scmd = NULL;
195  cmd->sync_cmd_idx = (u32)ULONG_MAX;
196  list_add_tail(&cmd->list, &fusion->cmd_pool);
197 
198  spin_unlock_irqrestore(&fusion->cmd_pool_lock, flags);
199 }
200 
205 static void megasas_teardown_frame_pool_fusion(
206  struct megasas_instance *instance)
207 {
208  int i;
209  struct fusion_context *fusion = instance->ctrl_context;
210 
211  u16 max_cmd = instance->max_fw_cmds;
212 
213  struct megasas_cmd_fusion *cmd;
214 
215  if (!fusion->sg_dma_pool || !fusion->sense_dma_pool) {
216  printk(KERN_ERR "megasas: dma pool is null. SG Pool %p, "
217  "sense pool : %p\n", fusion->sg_dma_pool,
218  fusion->sense_dma_pool);
219  return;
220  }
221 
222  /*
223  * Return all frames to pool
224  */
225  for (i = 0; i < max_cmd; i++) {
226 
227  cmd = fusion->cmd_list[i];
228 
229  if (cmd->sg_frame)
230  pci_pool_free(fusion->sg_dma_pool, cmd->sg_frame,
231  cmd->sg_frame_phys_addr);
232 
233  if (cmd->sense)
234  pci_pool_free(fusion->sense_dma_pool, cmd->sense,
235  cmd->sense_phys_addr);
236  }
237 
238  /*
239  * Now destroy the pool itself
240  */
241  pci_pool_destroy(fusion->sg_dma_pool);
242  pci_pool_destroy(fusion->sense_dma_pool);
243 
244  fusion->sg_dma_pool = NULL;
245  fusion->sense_dma_pool = NULL;
246 }
247 
252 void
253 megasas_free_cmds_fusion(struct megasas_instance *instance)
254 {
255  int i;
256  struct fusion_context *fusion = instance->ctrl_context;
257 
258  u32 max_cmds, req_sz, reply_sz, io_frames_sz;
259 
260 
261  req_sz = fusion->request_alloc_sz;
262  reply_sz = fusion->reply_alloc_sz;
263  io_frames_sz = fusion->io_frames_alloc_sz;
264 
265  max_cmds = instance->max_fw_cmds;
266 
267  /* Free descriptors and request Frames memory */
268  if (fusion->req_frames_desc)
269  dma_free_coherent(&instance->pdev->dev, req_sz,
270  fusion->req_frames_desc,
271  fusion->req_frames_desc_phys);
272 
273  if (fusion->reply_frames_desc) {
274  pci_pool_free(fusion->reply_frames_desc_pool,
275  fusion->reply_frames_desc,
276  fusion->reply_frames_desc_phys);
277  pci_pool_destroy(fusion->reply_frames_desc_pool);
278  }
279 
280  if (fusion->io_request_frames) {
281  pci_pool_free(fusion->io_request_frames_pool,
282  fusion->io_request_frames,
283  fusion->io_request_frames_phys);
284  pci_pool_destroy(fusion->io_request_frames_pool);
285  }
286 
287  /* Free the Fusion frame pool */
288  megasas_teardown_frame_pool_fusion(instance);
289 
290  /* Free all the commands in the cmd_list */
291  for (i = 0; i < max_cmds; i++)
292  kfree(fusion->cmd_list[i]);
293 
294  /* Free the cmd_list buffer itself */
295  kfree(fusion->cmd_list);
296  fusion->cmd_list = NULL;
297 
298  INIT_LIST_HEAD(&fusion->cmd_pool);
299 }
300 
306 static int megasas_create_frame_pool_fusion(struct megasas_instance *instance)
307 {
308  int i;
309  u32 max_cmd;
310  struct fusion_context *fusion;
311  struct megasas_cmd_fusion *cmd;
312  u32 total_sz_chain_frame;
313 
314  fusion = instance->ctrl_context;
315  max_cmd = instance->max_fw_cmds;
316 
317  total_sz_chain_frame = MEGASAS_MAX_SZ_CHAIN_FRAME;
318 
319  /*
320  * Use DMA pool facility provided by PCI layer
321  */
322 
323  fusion->sg_dma_pool = pci_pool_create("megasas sg pool fusion",
324  instance->pdev,
325  total_sz_chain_frame, 4,
326  0);
327  if (!fusion->sg_dma_pool) {
328  printk(KERN_DEBUG "megasas: failed to setup request pool "
329  "fusion\n");
330  return -ENOMEM;
331  }
332  fusion->sense_dma_pool = pci_pool_create("megasas sense pool fusion",
333  instance->pdev,
334  SCSI_SENSE_BUFFERSIZE, 64, 0);
335 
336  if (!fusion->sense_dma_pool) {
337  printk(KERN_DEBUG "megasas: failed to setup sense pool "
338  "fusion\n");
339  pci_pool_destroy(fusion->sg_dma_pool);
340  fusion->sg_dma_pool = NULL;
341  return -ENOMEM;
342  }
343 
344  /*
345  * Allocate and attach a frame to each of the commands in cmd_list
346  */
347  for (i = 0; i < max_cmd; i++) {
348 
349  cmd = fusion->cmd_list[i];
350 
351  cmd->sg_frame = pci_pool_alloc(fusion->sg_dma_pool,
352  GFP_KERNEL,
353  &cmd->sg_frame_phys_addr);
354 
355  cmd->sense = pci_pool_alloc(fusion->sense_dma_pool,
356  GFP_KERNEL, &cmd->sense_phys_addr);
357  /*
358  * megasas_teardown_frame_pool_fusion() takes care of freeing
359  * whatever has been allocated
360  */
361  if (!cmd->sg_frame || !cmd->sense) {
362  printk(KERN_DEBUG "megasas: pci_pool_alloc failed\n");
363  megasas_teardown_frame_pool_fusion(instance);
364  return -ENOMEM;
365  }
366  }
367  return 0;
368 }
369 
386 int
387 megasas_alloc_cmds_fusion(struct megasas_instance *instance)
388 {
389  int i, j, count;
390  u32 max_cmd, io_frames_sz;
391  struct fusion_context *fusion;
392  struct megasas_cmd_fusion *cmd;
393  union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc;
394  u32 offset;
395  dma_addr_t io_req_base_phys;
396  u8 *io_req_base;
397 
398  fusion = instance->ctrl_context;
399 
400  max_cmd = instance->max_fw_cmds;
401 
402  fusion->req_frames_desc =
403  dma_alloc_coherent(&instance->pdev->dev,
404  fusion->request_alloc_sz,
405  &fusion->req_frames_desc_phys, GFP_KERNEL);
406 
407  if (!fusion->req_frames_desc) {
408  printk(KERN_ERR "megasas; Could not allocate memory for "
409  "request_frames\n");
410  goto fail_req_desc;
411  }
412 
413  count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
414  fusion->reply_frames_desc_pool =
415  pci_pool_create("reply_frames pool", instance->pdev,
416  fusion->reply_alloc_sz * count, 16, 0);
417 
418  if (!fusion->reply_frames_desc_pool) {
419  printk(KERN_ERR "megasas; Could not allocate memory for "
420  "reply_frame pool\n");
421  goto fail_reply_desc;
422  }
423 
424  fusion->reply_frames_desc =
425  pci_pool_alloc(fusion->reply_frames_desc_pool, GFP_KERNEL,
426  &fusion->reply_frames_desc_phys);
427  if (!fusion->reply_frames_desc) {
428  printk(KERN_ERR "megasas; Could not allocate memory for "
429  "reply_frame pool\n");
430  pci_pool_destroy(fusion->reply_frames_desc_pool);
431  goto fail_reply_desc;
432  }
433 
434  reply_desc = fusion->reply_frames_desc;
435  for (i = 0; i < fusion->reply_q_depth * count; i++, reply_desc++)
436  reply_desc->Words = ULLONG_MAX;
437 
438  io_frames_sz = fusion->io_frames_alloc_sz;
439 
440  fusion->io_request_frames_pool =
441  pci_pool_create("io_request_frames pool", instance->pdev,
442  fusion->io_frames_alloc_sz, 16, 0);
443 
444  if (!fusion->io_request_frames_pool) {
445  printk(KERN_ERR "megasas: Could not allocate memory for "
446  "io_request_frame pool\n");
447  goto fail_io_frames;
448  }
449 
450  fusion->io_request_frames =
451  pci_pool_alloc(fusion->io_request_frames_pool, GFP_KERNEL,
452  &fusion->io_request_frames_phys);
453  if (!fusion->io_request_frames) {
454  printk(KERN_ERR "megasas: Could not allocate memory for "
455  "io_request_frames frames\n");
456  pci_pool_destroy(fusion->io_request_frames_pool);
457  goto fail_io_frames;
458  }
459 
460  /*
461  * fusion->cmd_list is an array of struct megasas_cmd_fusion pointers.
462  * Allocate the dynamic array first and then allocate individual
463  * commands.
464  */
465  fusion->cmd_list = kzalloc(sizeof(struct megasas_cmd_fusion *)
466  * max_cmd, GFP_KERNEL);
467 
468  if (!fusion->cmd_list) {
469  printk(KERN_DEBUG "megasas: out of memory. Could not alloc "
470  "memory for cmd_list_fusion\n");
471  goto fail_cmd_list;
472  }
473 
474  max_cmd = instance->max_fw_cmds;
475  for (i = 0; i < max_cmd; i++) {
476  fusion->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd_fusion),
477  GFP_KERNEL);
478  if (!fusion->cmd_list[i]) {
479  printk(KERN_ERR "Could not alloc cmd list fusion\n");
480 
481  for (j = 0; j < i; j++)
482  kfree(fusion->cmd_list[j]);
483 
484  kfree(fusion->cmd_list);
485  fusion->cmd_list = NULL;
486  goto fail_cmd_list;
487  }
488  }
489 
490  /* The first 256 bytes (SMID 0) is not used. Don't add to cmd list */
491  io_req_base = fusion->io_request_frames +
492  MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE;
493  io_req_base_phys = fusion->io_request_frames_phys +
494  MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE;
495 
496  /*
497  * Add all the commands to command pool (fusion->cmd_pool)
498  */
499 
500  /* SMID 0 is reserved. Set SMID/index from 1 */
501  for (i = 0; i < max_cmd; i++) {
502  cmd = fusion->cmd_list[i];
503  offset = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * i;
504  memset(cmd, 0, sizeof(struct megasas_cmd_fusion));
505  cmd->index = i + 1;
506  cmd->scmd = NULL;
507  cmd->sync_cmd_idx = (u32)ULONG_MAX; /* Set to Invalid */
508  cmd->instance = instance;
509  cmd->io_request =
510  (struct MPI2_RAID_SCSI_IO_REQUEST *)
511  (io_req_base + offset);
512  memset(cmd->io_request, 0,
513  sizeof(struct MPI2_RAID_SCSI_IO_REQUEST));
514  cmd->io_request_phys_addr = io_req_base_phys + offset;
515 
516  list_add_tail(&cmd->list, &fusion->cmd_pool);
517  }
518 
519  /*
520  * Create a frame pool and assign one frame to each cmd
521  */
522  if (megasas_create_frame_pool_fusion(instance)) {
523  printk(KERN_DEBUG "megasas: Error creating frame DMA pool\n");
524  megasas_free_cmds_fusion(instance);
525  goto fail_req_desc;
526  }
527 
528  return 0;
529 
530 fail_cmd_list:
531  pci_pool_free(fusion->io_request_frames_pool, fusion->io_request_frames,
532  fusion->io_request_frames_phys);
533  pci_pool_destroy(fusion->io_request_frames_pool);
534 fail_io_frames:
535  dma_free_coherent(&instance->pdev->dev, fusion->request_alloc_sz,
536  fusion->reply_frames_desc,
537  fusion->reply_frames_desc_phys);
538  pci_pool_free(fusion->reply_frames_desc_pool,
539  fusion->reply_frames_desc,
540  fusion->reply_frames_desc_phys);
541  pci_pool_destroy(fusion->reply_frames_desc_pool);
542 
543 fail_reply_desc:
544  dma_free_coherent(&instance->pdev->dev, fusion->request_alloc_sz,
545  fusion->req_frames_desc,
546  fusion->req_frames_desc_phys);
547 fail_req_desc:
548  return -ENOMEM;
549 }
550 
558 int
559 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd)
560 {
561  int i;
562  struct megasas_header *frame_hdr = &cmd->frame->hdr;
563 
564  u32 msecs = MFI_POLL_TIMEOUT_SECS * 1000;
565 
566  /*
567  * Wait for cmd_status to change
568  */
569  for (i = 0; (i < msecs) && (frame_hdr->cmd_status == 0xff); i += 20) {
570  rmb();
571  msleep(20);
572  }
573 
574  if (frame_hdr->cmd_status == 0xff)
575  return -ETIME;
576 
577  return 0;
578 }
579 
586 int
587 megasas_ioc_init_fusion(struct megasas_instance *instance)
588 {
589  struct megasas_init_frame *init_frame;
590  struct MPI2_IOC_INIT_REQUEST *IOCInitMessage;
591  dma_addr_t ioc_init_handle;
592  struct megasas_cmd *cmd;
593  u8 ret;
594  struct fusion_context *fusion;
595  union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
596  int i;
597  struct megasas_header *frame_hdr;
598 
599  fusion = instance->ctrl_context;
600 
601  cmd = megasas_get_cmd(instance);
602 
603  if (!cmd) {
604  printk(KERN_ERR "Could not allocate cmd for INIT Frame\n");
605  ret = 1;
606  goto fail_get_cmd;
607  }
608 
609  IOCInitMessage =
610  dma_alloc_coherent(&instance->pdev->dev,
611  sizeof(struct MPI2_IOC_INIT_REQUEST),
612  &ioc_init_handle, GFP_KERNEL);
613 
614  if (!IOCInitMessage) {
615  printk(KERN_ERR "Could not allocate memory for "
616  "IOCInitMessage\n");
617  ret = 1;
618  goto fail_fw_init;
619  }
620 
621  memset(IOCInitMessage, 0, sizeof(struct MPI2_IOC_INIT_REQUEST));
622 
623  IOCInitMessage->Function = MPI2_FUNCTION_IOC_INIT;
624  IOCInitMessage->WhoInit = MPI2_WHOINIT_HOST_DRIVER;
625  IOCInitMessage->MsgVersion = MPI2_VERSION;
626  IOCInitMessage->HeaderVersion = MPI2_HEADER_VERSION;
627  IOCInitMessage->SystemRequestFrameSize =
628  MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE / 4;
629 
630  IOCInitMessage->ReplyDescriptorPostQueueDepth = fusion->reply_q_depth;
631  IOCInitMessage->ReplyDescriptorPostQueueAddress =
632  fusion->reply_frames_desc_phys;
633  IOCInitMessage->SystemRequestFrameBaseAddress =
634  fusion->io_request_frames_phys;
635  IOCInitMessage->HostMSIxVectors = instance->msix_vectors;
636  init_frame = (struct megasas_init_frame *)cmd->frame;
637  memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
638 
639  frame_hdr = &cmd->frame->hdr;
640  frame_hdr->cmd_status = 0xFF;
641  frame_hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
642 
643  init_frame->cmd = MFI_CMD_INIT;
644  init_frame->cmd_status = 0xFF;
645 
646  init_frame->queue_info_new_phys_addr_lo = ioc_init_handle;
647  init_frame->data_xfer_len = sizeof(struct MPI2_IOC_INIT_REQUEST);
648 
649  req_desc =
650  (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)fusion->req_frames_desc;
651 
652  req_desc->Words = cmd->frame_phys_addr;
653  req_desc->MFAIo.RequestFlags =
654  (MEGASAS_REQ_DESCRIPT_FLAGS_MFA <<
655  MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
656 
657  /*
658  * disable the intr before firing the init frame
659  */
660  instance->instancet->disable_intr(instance->reg_set);
661 
662  for (i = 0; i < (10 * 1000); i += 20) {
663  if (readl(&instance->reg_set->doorbell) & 1)
664  msleep(20);
665  else
666  break;
667  }
668 
669  instance->instancet->fire_cmd(instance, req_desc->u.low,
670  req_desc->u.high, instance->reg_set);
671 
672  wait_and_poll(instance, cmd);
673 
674  frame_hdr = &cmd->frame->hdr;
675  if (frame_hdr->cmd_status != 0) {
676  ret = 1;
677  goto fail_fw_init;
678  }
679  printk(KERN_ERR "megasas:IOC Init cmd success\n");
680 
681  ret = 0;
682 
683 fail_fw_init:
684  megasas_return_cmd(instance, cmd);
685  if (IOCInitMessage)
686  dma_free_coherent(&instance->pdev->dev,
687  sizeof(struct MPI2_IOC_INIT_REQUEST),
688  IOCInitMessage, ioc_init_handle);
689 fail_get_cmd:
690  return ret;
691 }
692 
693 /*
694  * megasas_get_ld_map_info - Returns FW's ld_map structure
695  * @instance: Adapter soft state
696  * @pend: Pend the command or not
697  * Issues an internal command (DCMD) to get the FW's controller PD
698  * list structure. This information is mainly used to find out SYSTEM
699  * supported by the FW.
700  */
701 static int
702 megasas_get_ld_map_info(struct megasas_instance *instance)
703 {
704  int ret = 0;
705  struct megasas_cmd *cmd;
706  struct megasas_dcmd_frame *dcmd;
707  struct MR_FW_RAID_MAP_ALL *ci;
708  dma_addr_t ci_h = 0;
709  u32 size_map_info;
710  struct fusion_context *fusion;
711 
712  cmd = megasas_get_cmd(instance);
713 
714  if (!cmd) {
715  printk(KERN_DEBUG "megasas: Failed to get cmd for map info.\n");
716  return -ENOMEM;
717  }
718 
719  fusion = instance->ctrl_context;
720 
721  if (!fusion) {
722  megasas_return_cmd(instance, cmd);
723  return 1;
724  }
725 
726  dcmd = &cmd->frame->dcmd;
727 
728  size_map_info = sizeof(struct MR_FW_RAID_MAP) +
729  (sizeof(struct MR_LD_SPAN_MAP) *(MAX_LOGICAL_DRIVES - 1));
730 
731  ci = fusion->ld_map[(instance->map_id & 1)];
732  ci_h = fusion->ld_map_phys[(instance->map_id & 1)];
733 
734  if (!ci) {
735  printk(KERN_DEBUG "Failed to alloc mem for ld_map_info\n");
736  megasas_return_cmd(instance, cmd);
737  return -ENOMEM;
738  }
739 
740  memset(ci, 0, sizeof(*ci));
741  memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
742 
743  dcmd->cmd = MFI_CMD_DCMD;
744  dcmd->cmd_status = 0xFF;
745  dcmd->sge_count = 1;
746  dcmd->flags = MFI_FRAME_DIR_READ;
747  dcmd->timeout = 0;
748  dcmd->pad_0 = 0;
749  dcmd->data_xfer_len = size_map_info;
750  dcmd->opcode = MR_DCMD_LD_MAP_GET_INFO;
751  dcmd->sgl.sge32[0].phys_addr = ci_h;
752  dcmd->sgl.sge32[0].length = size_map_info;
753 
754  if (!megasas_issue_polled(instance, cmd))
755  ret = 0;
756  else {
757  printk(KERN_ERR "megasas: Get LD Map Info Failed\n");
758  ret = -1;
759  }
760 
761  megasas_return_cmd(instance, cmd);
762 
763  return ret;
764 }
765 
766 u8
767 megasas_get_map_info(struct megasas_instance *instance)
768 {
769  struct fusion_context *fusion = instance->ctrl_context;
770 
771  fusion->fast_path_io = 0;
772  if (!megasas_get_ld_map_info(instance)) {
773  if (MR_ValidateMapInfo(fusion->ld_map[(instance->map_id & 1)],
774  fusion->load_balance_info)) {
775  fusion->fast_path_io = 1;
776  return 0;
777  }
778  }
779  return 1;
780 }
781 
782 /*
783  * megasas_sync_map_info - Returns FW's ld_map structure
784  * @instance: Adapter soft state
785  *
786  * Issues an internal command (DCMD) to get the FW's controller PD
787  * list structure. This information is mainly used to find out SYSTEM
788  * supported by the FW.
789  */
790 int
791 megasas_sync_map_info(struct megasas_instance *instance)
792 {
793  int ret = 0, i;
794  struct megasas_cmd *cmd;
795  struct megasas_dcmd_frame *dcmd;
796  u32 size_sync_info, num_lds;
797  struct fusion_context *fusion;
798  struct MR_LD_TARGET_SYNC *ci = NULL;
799  struct MR_FW_RAID_MAP_ALL *map;
800  struct MR_LD_RAID *raid;
801  struct MR_LD_TARGET_SYNC *ld_sync;
802  dma_addr_t ci_h = 0;
803  u32 size_map_info;
804 
805  cmd = megasas_get_cmd(instance);
806 
807  if (!cmd) {
808  printk(KERN_DEBUG "megasas: Failed to get cmd for sync"
809  "info.\n");
810  return -ENOMEM;
811  }
812 
813  fusion = instance->ctrl_context;
814 
815  if (!fusion) {
816  megasas_return_cmd(instance, cmd);
817  return 1;
818  }
819 
820  map = fusion->ld_map[instance->map_id & 1];
821 
822  num_lds = map->raidMap.ldCount;
823 
824  dcmd = &cmd->frame->dcmd;
825 
826  size_sync_info = sizeof(struct MR_LD_TARGET_SYNC) *num_lds;
827 
828  memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
829 
830  ci = (struct MR_LD_TARGET_SYNC *)
831  fusion->ld_map[(instance->map_id - 1) & 1];
832  memset(ci, 0, sizeof(struct MR_FW_RAID_MAP_ALL));
833 
834  ci_h = fusion->ld_map_phys[(instance->map_id - 1) & 1];
835 
836  ld_sync = (struct MR_LD_TARGET_SYNC *)ci;
837 
838  for (i = 0; i < num_lds; i++, ld_sync++) {
839  raid = MR_LdRaidGet(i, map);
840  ld_sync->targetId = MR_GetLDTgtId(i, map);
841  ld_sync->seqNum = raid->seqNum;
842  }
843 
844  size_map_info = sizeof(struct MR_FW_RAID_MAP) +
845  (sizeof(struct MR_LD_SPAN_MAP) *(MAX_LOGICAL_DRIVES - 1));
846 
847  dcmd->cmd = MFI_CMD_DCMD;
848  dcmd->cmd_status = 0xFF;
849  dcmd->sge_count = 1;
850  dcmd->flags = MFI_FRAME_DIR_WRITE;
851  dcmd->timeout = 0;
852  dcmd->pad_0 = 0;
853  dcmd->data_xfer_len = size_map_info;
854  dcmd->mbox.b[0] = num_lds;
855  dcmd->mbox.b[1] = MEGASAS_DCMD_MBOX_PEND_FLAG;
856  dcmd->opcode = MR_DCMD_LD_MAP_GET_INFO;
857  dcmd->sgl.sge32[0].phys_addr = ci_h;
858  dcmd->sgl.sge32[0].length = size_map_info;
859 
860  instance->map_update_cmd = cmd;
861 
862  instance->instancet->issue_dcmd(instance, cmd);
863 
864  return ret;
865 }
866 
873 u32
874 megasas_init_adapter_fusion(struct megasas_instance *instance)
875 {
876  struct megasas_register_set __iomem *reg_set;
877  struct fusion_context *fusion;
878  u32 max_cmd;
879  int i = 0, count;
880 
881  fusion = instance->ctrl_context;
882 
883  reg_set = instance->reg_set;
884 
885  /*
886  * Get various operational parameters from status register
887  */
888  instance->max_fw_cmds =
889  instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF;
890  instance->max_fw_cmds = min(instance->max_fw_cmds, (u16)1008);
891 
892  /*
893  * Reduce the max supported cmds by 1. This is to ensure that the
894  * reply_q_sz (1 more than the max cmd that driver may send)
895  * does not exceed max cmds that the FW can support
896  */
897  instance->max_fw_cmds = instance->max_fw_cmds-1;
898  /* Only internal cmds (DCMD) need to have MFI frames */
899  instance->max_mfi_cmds = MEGASAS_INT_CMDS;
900 
901  max_cmd = instance->max_fw_cmds;
902 
903  fusion->reply_q_depth = ((max_cmd + 1 + 15)/16)*16;
904 
905  fusion->request_alloc_sz =
906  sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) *max_cmd;
907  fusion->reply_alloc_sz = sizeof(union MPI2_REPLY_DESCRIPTORS_UNION)
908  *(fusion->reply_q_depth);
909  fusion->io_frames_alloc_sz = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE +
910  (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE *
911  (max_cmd + 1)); /* Extra 1 for SMID 0 */
912 
913  fusion->max_sge_in_main_msg =
914  (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE -
915  offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL))/16;
916 
917  fusion->max_sge_in_chain =
918  MEGASAS_MAX_SZ_CHAIN_FRAME / sizeof(union MPI2_SGE_IO_UNION);
919 
920  instance->max_num_sge = fusion->max_sge_in_main_msg +
921  fusion->max_sge_in_chain - 2;
922 
923  /* Used for pass thru MFI frame (DCMD) */
924  fusion->chain_offset_mfi_pthru =
925  offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL)/16;
926 
927  fusion->chain_offset_io_request =
928  (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE -
929  sizeof(union MPI2_SGE_IO_UNION))/16;
930 
931  count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
932  for (i = 0 ; i < count; i++)
933  fusion->last_reply_idx[i] = 0;
934 
935  /*
936  * Allocate memory for descriptors
937  * Create a pool of commands
938  */
939  if (megasas_alloc_cmds(instance))
940  goto fail_alloc_mfi_cmds;
941  if (megasas_alloc_cmds_fusion(instance))
942  goto fail_alloc_cmds;
943 
944  if (megasas_ioc_init_fusion(instance))
945  goto fail_ioc_init;
946 
947  instance->flag_ieee = 1;
948 
949  fusion->map_sz = sizeof(struct MR_FW_RAID_MAP) +
950  (sizeof(struct MR_LD_SPAN_MAP) *(MAX_LOGICAL_DRIVES - 1));
951 
952  fusion->fast_path_io = 0;
953 
954  for (i = 0; i < 2; i++) {
955  fusion->ld_map[i] = dma_alloc_coherent(&instance->pdev->dev,
956  fusion->map_sz,
957  &fusion->ld_map_phys[i],
958  GFP_KERNEL);
959  if (!fusion->ld_map[i]) {
960  printk(KERN_ERR "megasas: Could not allocate memory "
961  "for map info\n");
962  goto fail_map_info;
963  }
964  }
965 
966  if (!megasas_get_map_info(instance))
967  megasas_sync_map_info(instance);
968 
969  return 0;
970 
971 fail_map_info:
972  if (i == 1)
973  dma_free_coherent(&instance->pdev->dev, fusion->map_sz,
974  fusion->ld_map[0], fusion->ld_map_phys[0]);
975 fail_ioc_init:
976  megasas_free_cmds_fusion(instance);
977 fail_alloc_cmds:
978  megasas_free_cmds(instance);
979 fail_alloc_mfi_cmds:
980  return 1;
981 }
982 
989 void
990 megasas_fire_cmd_fusion(struct megasas_instance *instance,
991  dma_addr_t req_desc_lo,
992  u32 req_desc_hi,
993  struct megasas_register_set __iomem *regs)
994 {
995  unsigned long flags;
996 
997  spin_lock_irqsave(&instance->hba_lock, flags);
998 
999  writel(req_desc_lo,
1000  &(regs)->inbound_low_queue_port);
1001  writel(req_desc_hi, &(regs)->inbound_high_queue_port);
1002  spin_unlock_irqrestore(&instance->hba_lock, flags);
1003 }
1004 
1012 void
1013 map_cmd_status(struct megasas_cmd_fusion *cmd, u8 status, u8 ext_status)
1014 {
1015 
1016  switch (status) {
1017 
1018  case MFI_STAT_OK:
1019  cmd->scmd->result = DID_OK << 16;
1020  break;
1021 
1022  case MFI_STAT_SCSI_IO_FAILED:
1023  case MFI_STAT_LD_INIT_IN_PROGRESS:
1024  cmd->scmd->result = (DID_ERROR << 16) | ext_status;
1025  break;
1026 
1027  case MFI_STAT_SCSI_DONE_WITH_ERROR:
1028 
1029  cmd->scmd->result = (DID_OK << 16) | ext_status;
1030  if (ext_status == SAM_STAT_CHECK_CONDITION) {
1031  memset(cmd->scmd->sense_buffer, 0,
1032  SCSI_SENSE_BUFFERSIZE);
1033  memcpy(cmd->scmd->sense_buffer, cmd->sense,
1034  SCSI_SENSE_BUFFERSIZE);
1035  cmd->scmd->result |= DRIVER_SENSE << 24;
1036  }
1037  break;
1038 
1039  case MFI_STAT_LD_OFFLINE:
1040  case MFI_STAT_DEVICE_NOT_FOUND:
1041  cmd->scmd->result = DID_BAD_TARGET << 16;
1042  break;
1043  case MFI_STAT_CONFIG_SEQ_MISMATCH:
1044  cmd->scmd->result = DID_IMM_RETRY << 16;
1045  break;
1046  default:
1047  printk(KERN_DEBUG "megasas: FW status %#x\n", status);
1048  cmd->scmd->result = DID_ERROR << 16;
1049  break;
1050  }
1051 }
1052 
1062 static int
1063 megasas_make_sgl_fusion(struct megasas_instance *instance,
1064  struct scsi_cmnd *scp,
1065  struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr,
1066  struct megasas_cmd_fusion *cmd)
1067 {
1068  int i, sg_processed, sge_count;
1069  struct scatterlist *os_sgl;
1070  struct fusion_context *fusion;
1071 
1072  fusion = instance->ctrl_context;
1073 
1074  if (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) {
1075  struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr_end = sgl_ptr;
1076  sgl_ptr_end += fusion->max_sge_in_main_msg - 1;
1077  sgl_ptr_end->Flags = 0;
1078  }
1079 
1080  sge_count = scsi_dma_map(scp);
1081 
1082  BUG_ON(sge_count < 0);
1083 
1084  if (sge_count > instance->max_num_sge || !sge_count)
1085  return sge_count;
1086 
1087  scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1088  sgl_ptr->Length = sg_dma_len(os_sgl);
1089  sgl_ptr->Address = sg_dma_address(os_sgl);
1090  sgl_ptr->Flags = 0;
1091  if (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) {
1092  if (i == sge_count - 1)
1093  sgl_ptr->Flags = IEEE_SGE_FLAGS_END_OF_LIST;
1094  }
1095  sgl_ptr++;
1096 
1097  sg_processed = i + 1;
1098 
1099  if ((sg_processed == (fusion->max_sge_in_main_msg - 1)) &&
1100  (sge_count > fusion->max_sge_in_main_msg)) {
1101 
1102  struct MPI25_IEEE_SGE_CHAIN64 *sg_chain;
1103  if (instance->pdev->device ==
1104  PCI_DEVICE_ID_LSI_INVADER) {
1105  if ((cmd->io_request->IoFlags &
1106  MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH) !=
1107  MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH)
1108  cmd->io_request->ChainOffset =
1109  fusion->
1110  chain_offset_io_request;
1111  else
1112  cmd->io_request->ChainOffset = 0;
1113  } else
1114  cmd->io_request->ChainOffset =
1115  fusion->chain_offset_io_request;
1116 
1117  sg_chain = sgl_ptr;
1118  /* Prepare chain element */
1119  sg_chain->NextChainOffset = 0;
1120  if (instance->pdev->device ==
1121  PCI_DEVICE_ID_LSI_INVADER)
1122  sg_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT;
1123  else
1124  sg_chain->Flags =
1125  (IEEE_SGE_FLAGS_CHAIN_ELEMENT |
1126  MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR);
1127  sg_chain->Length = (sizeof(union MPI2_SGE_IO_UNION)
1128  *(sge_count - sg_processed));
1129  sg_chain->Address = cmd->sg_frame_phys_addr;
1130 
1131  sgl_ptr =
1132  (struct MPI25_IEEE_SGE_CHAIN64 *)cmd->sg_frame;
1133  }
1134  }
1135 
1136  return sge_count;
1137 }
1138 
1147 void
1148 megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len,
1149  struct IO_REQUEST_INFO *io_info, struct scsi_cmnd *scp,
1150  struct MR_FW_RAID_MAP_ALL *local_map_ptr, u32 ref_tag)
1151 {
1152  struct MR_LD_RAID *raid;
1153  u32 ld;
1154  u64 start_blk = io_info->pdBlock;
1155  u8 *cdb = io_request->CDB.CDB32;
1156  u32 num_blocks = io_info->numBlocks;
1157  u8 opcode = 0, flagvals = 0, groupnum = 0, control = 0;
1158 
1159  /* Check if T10 PI (DIF) is enabled for this LD */
1160  ld = MR_TargetIdToLdGet(io_info->ldTgtId, local_map_ptr);
1161  raid = MR_LdRaidGet(ld, local_map_ptr);
1162  if (raid->capability.ldPiMode == MR_PROT_INFO_TYPE_CONTROLLER) {
1163  memset(cdb, 0, sizeof(io_request->CDB.CDB32));
1164  cdb[0] = MEGASAS_SCSI_VARIABLE_LENGTH_CMD;
1165  cdb[7] = MEGASAS_SCSI_ADDL_CDB_LEN;
1166 
1167  if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1168  cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_READ32;
1169  else
1170  cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_WRITE32;
1171  cdb[10] = MEGASAS_RD_WR_PROTECT_CHECK_ALL;
1172 
1173  /* LBA */
1174  cdb[12] = (u8)((start_blk >> 56) & 0xff);
1175  cdb[13] = (u8)((start_blk >> 48) & 0xff);
1176  cdb[14] = (u8)((start_blk >> 40) & 0xff);
1177  cdb[15] = (u8)((start_blk >> 32) & 0xff);
1178  cdb[16] = (u8)((start_blk >> 24) & 0xff);
1179  cdb[17] = (u8)((start_blk >> 16) & 0xff);
1180  cdb[18] = (u8)((start_blk >> 8) & 0xff);
1181  cdb[19] = (u8)(start_blk & 0xff);
1182 
1183  /* Logical block reference tag */
1184  io_request->CDB.EEDP32.PrimaryReferenceTag =
1185  cpu_to_be32(ref_tag);
1186  io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0xffff;
1187  io_request->IoFlags = 32; /* Specify 32-byte cdb */
1188 
1189  /* Transfer length */
1190  cdb[28] = (u8)((num_blocks >> 24) & 0xff);
1191  cdb[29] = (u8)((num_blocks >> 16) & 0xff);
1192  cdb[30] = (u8)((num_blocks >> 8) & 0xff);
1193  cdb[31] = (u8)(num_blocks & 0xff);
1194 
1195  /* set SCSI IO EEDPFlags */
1196  if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) {
1197  io_request->EEDPFlags =
1198  MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
1199  MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
1200  MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP |
1201  MPI2_SCSIIO_EEDPFLAGS_CHECK_APPTAG |
1202  MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
1203  } else {
1204  io_request->EEDPFlags =
1205  MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
1206  MPI2_SCSIIO_EEDPFLAGS_INSERT_OP;
1207  }
1208  io_request->Control |= (0x4 << 26);
1209  io_request->EEDPBlockSize = MEGASAS_EEDPBLOCKSIZE;
1210  } else {
1211  /* Some drives don't support 16/12 byte CDB's, convert to 10 */
1212  if (((cdb_len == 12) || (cdb_len == 16)) &&
1213  (start_blk <= 0xffffffff)) {
1214  if (cdb_len == 16) {
1215  opcode = cdb[0] == READ_16 ? READ_10 : WRITE_10;
1216  flagvals = cdb[1];
1217  groupnum = cdb[14];
1218  control = cdb[15];
1219  } else {
1220  opcode = cdb[0] == READ_12 ? READ_10 : WRITE_10;
1221  flagvals = cdb[1];
1222  groupnum = cdb[10];
1223  control = cdb[11];
1224  }
1225 
1226  memset(cdb, 0, sizeof(io_request->CDB.CDB32));
1227 
1228  cdb[0] = opcode;
1229  cdb[1] = flagvals;
1230  cdb[6] = groupnum;
1231  cdb[9] = control;
1232 
1233  /* Transfer length */
1234  cdb[8] = (u8)(num_blocks & 0xff);
1235  cdb[7] = (u8)((num_blocks >> 8) & 0xff);
1236 
1237  io_request->IoFlags = 10; /* Specify 10-byte cdb */
1238  cdb_len = 10;
1239  } else if ((cdb_len < 16) && (start_blk > 0xffffffff)) {
1240  /* Convert to 16 byte CDB for large LBA's */
1241  switch (cdb_len) {
1242  case 6:
1243  opcode = cdb[0] == READ_6 ? READ_16 : WRITE_16;
1244  control = cdb[5];
1245  break;
1246  case 10:
1247  opcode =
1248  cdb[0] == READ_10 ? READ_16 : WRITE_16;
1249  flagvals = cdb[1];
1250  groupnum = cdb[6];
1251  control = cdb[9];
1252  break;
1253  case 12:
1254  opcode =
1255  cdb[0] == READ_12 ? READ_16 : WRITE_16;
1256  flagvals = cdb[1];
1257  groupnum = cdb[10];
1258  control = cdb[11];
1259  break;
1260  }
1261 
1262  memset(cdb, 0, sizeof(io_request->CDB.CDB32));
1263 
1264  cdb[0] = opcode;
1265  cdb[1] = flagvals;
1266  cdb[14] = groupnum;
1267  cdb[15] = control;
1268 
1269  /* Transfer length */
1270  cdb[13] = (u8)(num_blocks & 0xff);
1271  cdb[12] = (u8)((num_blocks >> 8) & 0xff);
1272  cdb[11] = (u8)((num_blocks >> 16) & 0xff);
1273  cdb[10] = (u8)((num_blocks >> 24) & 0xff);
1274 
1275  io_request->IoFlags = 16; /* Specify 16-byte cdb */
1276  cdb_len = 16;
1277  }
1278 
1279  /* Normal case, just load LBA here */
1280  switch (cdb_len) {
1281  case 6:
1282  {
1283  u8 val = cdb[1] & 0xE0;
1284  cdb[3] = (u8)(start_blk & 0xff);
1285  cdb[2] = (u8)((start_blk >> 8) & 0xff);
1286  cdb[1] = val | ((u8)(start_blk >> 16) & 0x1f);
1287  break;
1288  }
1289  case 10:
1290  cdb[5] = (u8)(start_blk & 0xff);
1291  cdb[4] = (u8)((start_blk >> 8) & 0xff);
1292  cdb[3] = (u8)((start_blk >> 16) & 0xff);
1293  cdb[2] = (u8)((start_blk >> 24) & 0xff);
1294  break;
1295  case 12:
1296  cdb[5] = (u8)(start_blk & 0xff);
1297  cdb[4] = (u8)((start_blk >> 8) & 0xff);
1298  cdb[3] = (u8)((start_blk >> 16) & 0xff);
1299  cdb[2] = (u8)((start_blk >> 24) & 0xff);
1300  break;
1301  case 16:
1302  cdb[9] = (u8)(start_blk & 0xff);
1303  cdb[8] = (u8)((start_blk >> 8) & 0xff);
1304  cdb[7] = (u8)((start_blk >> 16) & 0xff);
1305  cdb[6] = (u8)((start_blk >> 24) & 0xff);
1306  cdb[5] = (u8)((start_blk >> 32) & 0xff);
1307  cdb[4] = (u8)((start_blk >> 40) & 0xff);
1308  cdb[3] = (u8)((start_blk >> 48) & 0xff);
1309  cdb[2] = (u8)((start_blk >> 56) & 0xff);
1310  break;
1311  }
1312  }
1313 }
1314 
1324 void
1325 megasas_build_ldio_fusion(struct megasas_instance *instance,
1326  struct scsi_cmnd *scp,
1327  struct megasas_cmd_fusion *cmd)
1328 {
1329  u8 fp_possible;
1330  u32 start_lba_lo, start_lba_hi, device_id, datalength = 0;
1331  struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
1332  union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
1333  struct IO_REQUEST_INFO io_info;
1334  struct fusion_context *fusion;
1335  struct MR_FW_RAID_MAP_ALL *local_map_ptr;
1336 
1337  device_id = MEGASAS_DEV_INDEX(instance, scp);
1338 
1339  fusion = instance->ctrl_context;
1340 
1341  io_request = cmd->io_request;
1342  io_request->RaidContext.VirtualDiskTgtId = device_id;
1343  io_request->RaidContext.status = 0;
1344  io_request->RaidContext.exStatus = 0;
1345 
1346  req_desc = (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)cmd->request_desc;
1347 
1348  start_lba_lo = 0;
1349  start_lba_hi = 0;
1350  fp_possible = 0;
1351 
1352  /*
1353  * 6-byte READ(0x08) or WRITE(0x0A) cdb
1354  */
1355  if (scp->cmd_len == 6) {
1356  datalength = (u32) scp->cmnd[4];
1357  start_lba_lo = ((u32) scp->cmnd[1] << 16) |
1358  ((u32) scp->cmnd[2] << 8) | (u32) scp->cmnd[3];
1359 
1360  start_lba_lo &= 0x1FFFFF;
1361  }
1362 
1363  /*
1364  * 10-byte READ(0x28) or WRITE(0x2A) cdb
1365  */
1366  else if (scp->cmd_len == 10) {
1367  datalength = (u32) scp->cmnd[8] |
1368  ((u32) scp->cmnd[7] << 8);
1369  start_lba_lo = ((u32) scp->cmnd[2] << 24) |
1370  ((u32) scp->cmnd[3] << 16) |
1371  ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
1372  }
1373 
1374  /*
1375  * 12-byte READ(0xA8) or WRITE(0xAA) cdb
1376  */
1377  else if (scp->cmd_len == 12) {
1378  datalength = ((u32) scp->cmnd[6] << 24) |
1379  ((u32) scp->cmnd[7] << 16) |
1380  ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
1381  start_lba_lo = ((u32) scp->cmnd[2] << 24) |
1382  ((u32) scp->cmnd[3] << 16) |
1383  ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
1384  }
1385 
1386  /*
1387  * 16-byte READ(0x88) or WRITE(0x8A) cdb
1388  */
1389  else if (scp->cmd_len == 16) {
1390  datalength = ((u32) scp->cmnd[10] << 24) |
1391  ((u32) scp->cmnd[11] << 16) |
1392  ((u32) scp->cmnd[12] << 8) | (u32) scp->cmnd[13];
1393  start_lba_lo = ((u32) scp->cmnd[6] << 24) |
1394  ((u32) scp->cmnd[7] << 16) |
1395  ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
1396 
1397  start_lba_hi = ((u32) scp->cmnd[2] << 24) |
1398  ((u32) scp->cmnd[3] << 16) |
1399  ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
1400  }
1401 
1402  memset(&io_info, 0, sizeof(struct IO_REQUEST_INFO));
1403  io_info.ldStartBlock = ((u64)start_lba_hi << 32) | start_lba_lo;
1404  io_info.numBlocks = datalength;
1405  io_info.ldTgtId = device_id;
1406  io_request->DataLength = scsi_bufflen(scp);
1407 
1408  if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1409  io_info.isRead = 1;
1410 
1411  local_map_ptr = fusion->ld_map[(instance->map_id & 1)];
1412 
1413  if ((MR_TargetIdToLdGet(device_id, local_map_ptr) >=
1414  MAX_LOGICAL_DRIVES) || (!fusion->fast_path_io)) {
1415  io_request->RaidContext.regLockFlags = 0;
1416  fp_possible = 0;
1417  } else {
1418  if (MR_BuildRaidContext(instance, &io_info,
1419  &io_request->RaidContext,
1420  local_map_ptr))
1421  fp_possible = io_info.fpOkForIo;
1422  }
1423 
1424  /* Use smp_processor_id() for now until cmd->request->cpu is CPU
1425  id by default, not CPU group id, otherwise all MSI-X queues won't
1426  be utilized */
1427  cmd->request_desc->SCSIIO.MSIxIndex = instance->msix_vectors ?
1428  smp_processor_id() % instance->msix_vectors : 0;
1429 
1430  if (fp_possible) {
1431  megasas_set_pd_lba(io_request, scp->cmd_len, &io_info, scp,
1432  local_map_ptr, start_lba_lo);
1433  io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
1434  cmd->request_desc->SCSIIO.RequestFlags =
1435  (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY
1436  << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1437  if (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) {
1438  if (io_request->RaidContext.regLockFlags ==
1439  REGION_TYPE_UNUSED)
1440  cmd->request_desc->SCSIIO.RequestFlags =
1441  (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
1442  MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1443  io_request->RaidContext.Type = MPI2_TYPE_CUDA;
1444  io_request->RaidContext.nseg = 0x1;
1445  io_request->IoFlags |=
1446  MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH;
1447  io_request->RaidContext.regLockFlags |=
1448  (MR_RL_FLAGS_GRANT_DESTINATION_CUDA |
1449  MR_RL_FLAGS_SEQ_NUM_ENABLE);
1450  }
1451  if ((fusion->load_balance_info[device_id].loadBalanceFlag) &&
1452  (io_info.isRead)) {
1453  io_info.devHandle =
1454  get_updated_dev_handle(
1455  &fusion->load_balance_info[device_id],
1456  &io_info);
1457  scp->SCp.Status |= MEGASAS_LOAD_BALANCE_FLAG;
1458  } else
1459  scp->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG;
1460  cmd->request_desc->SCSIIO.DevHandle = io_info.devHandle;
1461  io_request->DevHandle = io_info.devHandle;
1462  } else {
1463  io_request->RaidContext.timeoutValue =
1464  local_map_ptr->raidMap.fpPdIoTimeoutSec;
1465  cmd->request_desc->SCSIIO.RequestFlags =
1466  (MEGASAS_REQ_DESCRIPT_FLAGS_LD_IO
1467  << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1468  if (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) {
1469  if (io_request->RaidContext.regLockFlags ==
1470  REGION_TYPE_UNUSED)
1471  cmd->request_desc->SCSIIO.RequestFlags =
1472  (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
1473  MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1474  io_request->RaidContext.Type = MPI2_TYPE_CUDA;
1475  io_request->RaidContext.regLockFlags |=
1476  (MR_RL_FLAGS_GRANT_DESTINATION_CPU0 |
1477  MR_RL_FLAGS_SEQ_NUM_ENABLE);
1478  io_request->RaidContext.nseg = 0x1;
1479  }
1480  io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
1481  io_request->DevHandle = device_id;
1482  } /* Not FP */
1483 }
1484 
1493 static void
1494 megasas_build_dcdb_fusion(struct megasas_instance *instance,
1495  struct scsi_cmnd *scmd,
1496  struct megasas_cmd_fusion *cmd)
1497 {
1498  u32 device_id;
1499  struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
1500  u16 pd_index = 0;
1501  struct MR_FW_RAID_MAP_ALL *local_map_ptr;
1502  struct fusion_context *fusion = instance->ctrl_context;
1503 
1504  io_request = cmd->io_request;
1505  device_id = MEGASAS_DEV_INDEX(instance, scmd);
1506  pd_index = (scmd->device->channel * MEGASAS_MAX_DEV_PER_CHANNEL)
1507  +scmd->device->id;
1508  local_map_ptr = fusion->ld_map[(instance->map_id & 1)];
1509 
1510  /* Check if this is a system PD I/O */
1511  if (scmd->device->channel < MEGASAS_MAX_PD_CHANNELS &&
1512  instance->pd_list[pd_index].driveState == MR_PD_STATE_SYSTEM) {
1513  io_request->Function = 0;
1514  io_request->DevHandle =
1515  local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
1516  io_request->RaidContext.timeoutValue =
1517  local_map_ptr->raidMap.fpPdIoTimeoutSec;
1518  io_request->RaidContext.regLockFlags = 0;
1519  io_request->RaidContext.regLockRowLBA = 0;
1520  io_request->RaidContext.regLockLength = 0;
1521  io_request->RaidContext.RAIDFlags =
1522  MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD <<
1523  MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;
1524  cmd->request_desc->SCSIIO.RequestFlags =
1525  (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<
1526  MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1527  cmd->request_desc->SCSIIO.DevHandle =
1528  local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
1529  } else {
1530  io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
1531  io_request->DevHandle = device_id;
1532  cmd->request_desc->SCSIIO.RequestFlags =
1533  (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
1534  MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1535  }
1536  io_request->RaidContext.VirtualDiskTgtId = device_id;
1537  io_request->LUN[1] = scmd->device->lun;
1538  io_request->DataLength = scsi_bufflen(scmd);
1539 }
1540 
1550 int
1551 megasas_build_io_fusion(struct megasas_instance *instance,
1552  struct scsi_cmnd *scp,
1553  struct megasas_cmd_fusion *cmd)
1554 {
1555  u32 device_id, sge_count;
1556  struct MPI2_RAID_SCSI_IO_REQUEST *io_request = cmd->io_request;
1557 
1558  device_id = MEGASAS_DEV_INDEX(instance, scp);
1559 
1560  /* Zero out some fields so they don't get reused */
1561  io_request->LUN[1] = 0;
1562  io_request->CDB.EEDP32.PrimaryReferenceTag = 0;
1563  io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0;
1564  io_request->EEDPFlags = 0;
1565  io_request->Control = 0;
1566  io_request->EEDPBlockSize = 0;
1567  io_request->ChainOffset = 0;
1568  io_request->RaidContext.RAIDFlags = 0;
1569  io_request->RaidContext.Type = 0;
1570  io_request->RaidContext.nseg = 0;
1571 
1572  memcpy(io_request->CDB.CDB32, scp->cmnd, scp->cmd_len);
1573  /*
1574  * Just the CDB length,rest of the Flags are zero
1575  * This will be modified for FP in build_ldio_fusion
1576  */
1577  io_request->IoFlags = scp->cmd_len;
1578 
1579  if (megasas_is_ldio(scp))
1580  megasas_build_ldio_fusion(instance, scp, cmd);
1581  else
1582  megasas_build_dcdb_fusion(instance, scp, cmd);
1583 
1584  /*
1585  * Construct SGL
1586  */
1587 
1588  sge_count =
1589  megasas_make_sgl_fusion(instance, scp,
1590  (struct MPI25_IEEE_SGE_CHAIN64 *)
1591  &io_request->SGL, cmd);
1592 
1593  if (sge_count > instance->max_num_sge) {
1594  printk(KERN_ERR "megasas: Error. sge_count (0x%x) exceeds "
1595  "max (0x%x) allowed\n", sge_count,
1596  instance->max_num_sge);
1597  return 1;
1598  }
1599 
1600  io_request->RaidContext.numSGE = sge_count;
1601 
1602  io_request->SGLFlags = MPI2_SGE_FLAGS_64_BIT_ADDRESSING;
1603 
1604  if (scp->sc_data_direction == PCI_DMA_TODEVICE)
1605  io_request->Control |= MPI2_SCSIIO_CONTROL_WRITE;
1606  else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1607  io_request->Control |= MPI2_SCSIIO_CONTROL_READ;
1608 
1609  io_request->SGLOffset0 =
1610  offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL) / 4;
1611 
1612  io_request->SenseBufferLowAddress = cmd->sense_phys_addr;
1613  io_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
1614 
1615  cmd->scmd = scp;
1616  scp->SCp.ptr = (char *)cmd;
1617 
1618  return 0;
1619 }
1620 
1621 union MEGASAS_REQUEST_DESCRIPTOR_UNION *
1622 megasas_get_request_descriptor(struct megasas_instance *instance, u16 index)
1623 {
1624  u8 *p;
1625  struct fusion_context *fusion;
1626 
1627  if (index >= instance->max_fw_cmds) {
1628  printk(KERN_ERR "megasas: Invalid SMID (0x%x)request for "
1629  "descriptor\n", index);
1630  return NULL;
1631  }
1632  fusion = instance->ctrl_context;
1633  p = fusion->req_frames_desc
1634  +sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) *index;
1635 
1636  return (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)p;
1637 }
1638 
1645 static u32
1646 megasas_build_and_issue_cmd_fusion(struct megasas_instance *instance,
1647  struct scsi_cmnd *scmd)
1648 {
1649  struct megasas_cmd_fusion *cmd;
1650  union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
1651  u32 index;
1652  struct fusion_context *fusion;
1653 
1654  fusion = instance->ctrl_context;
1655 
1656  cmd = megasas_get_cmd_fusion(instance);
1657  if (!cmd)
1658  return SCSI_MLQUEUE_HOST_BUSY;
1659 
1660  index = cmd->index;
1661 
1662  req_desc = megasas_get_request_descriptor(instance, index-1);
1663  if (!req_desc)
1664  return 1;
1665 
1666  req_desc->Words = 0;
1667  cmd->request_desc = req_desc;
1668 
1669  if (megasas_build_io_fusion(instance, scmd, cmd)) {
1670  megasas_return_cmd_fusion(instance, cmd);
1671  printk(KERN_ERR "megasas: Error building command.\n");
1672  cmd->request_desc = NULL;
1673  return 1;
1674  }
1675 
1676  req_desc = cmd->request_desc;
1677  req_desc->SCSIIO.SMID = index;
1678 
1679  if (cmd->io_request->ChainOffset != 0 &&
1680  cmd->io_request->ChainOffset != 0xF)
1681  printk(KERN_ERR "megasas: The chain offset value is not "
1682  "correct : %x\n", cmd->io_request->ChainOffset);
1683 
1684  /*
1685  * Issue the command to the FW
1686  */
1687  atomic_inc(&instance->fw_outstanding);
1688 
1689  instance->instancet->fire_cmd(instance,
1690  req_desc->u.low, req_desc->u.high,
1691  instance->reg_set);
1692 
1693  return 0;
1694 }
1695 
1701 int
1702 complete_cmd_fusion(struct megasas_instance *instance, u32 MSIxIndex)
1703 {
1704  union MPI2_REPLY_DESCRIPTORS_UNION *desc;
1705  struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *reply_desc;
1706  struct MPI2_RAID_SCSI_IO_REQUEST *scsi_io_req;
1707  struct fusion_context *fusion;
1708  struct megasas_cmd *cmd_mfi;
1709  struct megasas_cmd_fusion *cmd_fusion;
1710  u16 smid, num_completed;
1711  u8 reply_descript_type, arm;
1712  u32 status, extStatus, device_id;
1713  union desc_value d_val;
1714  struct LD_LOAD_BALANCE_INFO *lbinfo;
1715 
1716  fusion = instance->ctrl_context;
1717 
1718  if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
1719  return IRQ_HANDLED;
1720 
1721  desc = fusion->reply_frames_desc;
1722  desc += ((MSIxIndex * fusion->reply_alloc_sz)/
1723  sizeof(union MPI2_REPLY_DESCRIPTORS_UNION)) +
1724  fusion->last_reply_idx[MSIxIndex];
1725 
1726  reply_desc = (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc;
1727 
1728  d_val.word = desc->Words;
1729 
1730  reply_descript_type = reply_desc->ReplyFlags &
1731  MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
1732 
1733  if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
1734  return IRQ_NONE;
1735 
1736  num_completed = 0;
1737 
1738  while ((d_val.u.low != UINT_MAX) && (d_val.u.high != UINT_MAX)) {
1739  smid = reply_desc->SMID;
1740 
1741  cmd_fusion = fusion->cmd_list[smid - 1];
1742 
1743  scsi_io_req =
1744  (struct MPI2_RAID_SCSI_IO_REQUEST *)
1745  cmd_fusion->io_request;
1746 
1747  if (cmd_fusion->scmd)
1748  cmd_fusion->scmd->SCp.ptr = NULL;
1749 
1750  status = scsi_io_req->RaidContext.status;
1751  extStatus = scsi_io_req->RaidContext.exStatus;
1752 
1753  switch (scsi_io_req->Function) {
1754  case MPI2_FUNCTION_SCSI_IO_REQUEST: /*Fast Path IO.*/
1755  /* Update load balancing info */
1756  device_id = MEGASAS_DEV_INDEX(instance,
1757  cmd_fusion->scmd);
1758  lbinfo = &fusion->load_balance_info[device_id];
1759  if (cmd_fusion->scmd->SCp.Status &
1760  MEGASAS_LOAD_BALANCE_FLAG) {
1761  arm = lbinfo->raid1DevHandle[0] ==
1762  cmd_fusion->io_request->DevHandle ? 0 :
1763  1;
1764  atomic_dec(&lbinfo->scsi_pending_cmds[arm]);
1765  cmd_fusion->scmd->SCp.Status &=
1766  ~MEGASAS_LOAD_BALANCE_FLAG;
1767  }
1768  if (reply_descript_type ==
1769  MPI2_RPY_DESCRIPT_FLAGS_SCSI_IO_SUCCESS) {
1770  if (megasas_dbg_lvl == 5)
1771  printk(KERN_ERR "\nmegasas: FAST Path "
1772  "IO Success\n");
1773  }
1774  /* Fall thru and complete IO */
1775  case MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST: /* LD-IO Path */
1776  /* Map the FW Cmd Status */
1777  map_cmd_status(cmd_fusion, status, extStatus);
1778  scsi_dma_unmap(cmd_fusion->scmd);
1779  cmd_fusion->scmd->scsi_done(cmd_fusion->scmd);
1780  scsi_io_req->RaidContext.status = 0;
1781  scsi_io_req->RaidContext.exStatus = 0;
1782  megasas_return_cmd_fusion(instance, cmd_fusion);
1783  atomic_dec(&instance->fw_outstanding);
1784 
1785  break;
1786  case MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST: /*MFI command */
1787  cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
1788  megasas_complete_cmd(instance, cmd_mfi, DID_OK);
1789  cmd_fusion->flags = 0;
1790  megasas_return_cmd_fusion(instance, cmd_fusion);
1791 
1792  break;
1793  }
1794 
1795  fusion->last_reply_idx[MSIxIndex]++;
1796  if (fusion->last_reply_idx[MSIxIndex] >=
1797  fusion->reply_q_depth)
1798  fusion->last_reply_idx[MSIxIndex] = 0;
1799 
1800  desc->Words = ULLONG_MAX;
1801  num_completed++;
1802 
1803  /* Get the next reply descriptor */
1804  if (!fusion->last_reply_idx[MSIxIndex])
1805  desc = fusion->reply_frames_desc +
1806  ((MSIxIndex * fusion->reply_alloc_sz)/
1807  sizeof(union MPI2_REPLY_DESCRIPTORS_UNION));
1808  else
1809  desc++;
1810 
1811  reply_desc =
1812  (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc;
1813 
1814  d_val.word = desc->Words;
1815 
1816  reply_descript_type = reply_desc->ReplyFlags &
1817  MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
1818 
1819  if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
1820  break;
1821  }
1822 
1823  if (!num_completed)
1824  return IRQ_NONE;
1825 
1826  wmb();
1827  writel((MSIxIndex << 24) | fusion->last_reply_idx[MSIxIndex],
1828  &instance->reg_set->reply_post_host_index);
1829  megasas_check_and_restore_queue_depth(instance);
1830  return IRQ_HANDLED;
1831 }
1832 
1839 void
1840 megasas_complete_cmd_dpc_fusion(unsigned long instance_addr)
1841 {
1842  struct megasas_instance *instance =
1843  (struct megasas_instance *)instance_addr;
1844  unsigned long flags;
1845  u32 count, MSIxIndex;
1846 
1847  count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
1848 
1849  /* If we have already declared adapter dead, donot complete cmds */
1850  spin_lock_irqsave(&instance->hba_lock, flags);
1851  if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
1852  spin_unlock_irqrestore(&instance->hba_lock, flags);
1853  return;
1854  }
1855  spin_unlock_irqrestore(&instance->hba_lock, flags);
1856 
1857  for (MSIxIndex = 0 ; MSIxIndex < count; MSIxIndex++)
1858  complete_cmd_fusion(instance, MSIxIndex);
1859 }
1860 
1864 irqreturn_t megasas_isr_fusion(int irq, void *devp)
1865 {
1866  struct megasas_irq_context *irq_context = devp;
1867  struct megasas_instance *instance = irq_context->instance;
1868  u32 mfiStatus, fw_state;
1869 
1870  if (!instance->msix_vectors) {
1871  mfiStatus = instance->instancet->clear_intr(instance->reg_set);
1872  if (!mfiStatus)
1873  return IRQ_NONE;
1874  }
1875 
1876  /* If we are resetting, bail */
1877  if (test_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags)) {
1878  instance->instancet->clear_intr(instance->reg_set);
1879  return IRQ_HANDLED;
1880  }
1881 
1882  if (!complete_cmd_fusion(instance, irq_context->MSIxIndex)) {
1883  instance->instancet->clear_intr(instance->reg_set);
1884  /* If we didn't complete any commands, check for FW fault */
1885  fw_state = instance->instancet->read_fw_status_reg(
1886  instance->reg_set) & MFI_STATE_MASK;
1887  if (fw_state == MFI_STATE_FAULT)
1888  schedule_work(&instance->work_init);
1889  }
1890 
1891  return IRQ_HANDLED;
1892 }
1893 
1900 u8
1901 build_mpt_mfi_pass_thru(struct megasas_instance *instance,
1902  struct megasas_cmd *mfi_cmd)
1903 {
1904  struct MPI25_IEEE_SGE_CHAIN64 *mpi25_ieee_chain;
1905  struct MPI2_RAID_SCSI_IO_REQUEST *io_req;
1906  struct megasas_cmd_fusion *cmd;
1907  struct fusion_context *fusion;
1908  struct megasas_header *frame_hdr = &mfi_cmd->frame->hdr;
1909 
1910  cmd = megasas_get_cmd_fusion(instance);
1911  if (!cmd)
1912  return 1;
1913 
1914  /* Save the smid. To be used for returning the cmd */
1915  mfi_cmd->context.smid = cmd->index;
1916 
1917  cmd->sync_cmd_idx = mfi_cmd->index;
1918 
1919  /*
1920  * For cmds where the flag is set, store the flag and check
1921  * on completion. For cmds with this flag, don't call
1922  * megasas_complete_cmd
1923  */
1924 
1925  if (frame_hdr->flags & MFI_FRAME_DONT_POST_IN_REPLY_QUEUE)
1926  cmd->flags = MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
1927 
1928  fusion = instance->ctrl_context;
1929  io_req = cmd->io_request;
1930 
1931  if (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) {
1932  struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr_end =
1933  (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL;
1934  sgl_ptr_end += fusion->max_sge_in_main_msg - 1;
1935  sgl_ptr_end->Flags = 0;
1936  }
1937 
1938  mpi25_ieee_chain =
1939  (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL.IeeeChain;
1940 
1941  io_req->Function = MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST;
1942  io_req->SGLOffset0 = offsetof(struct MPI2_RAID_SCSI_IO_REQUEST,
1943  SGL) / 4;
1944  io_req->ChainOffset = fusion->chain_offset_mfi_pthru;
1945 
1946  mpi25_ieee_chain->Address = mfi_cmd->frame_phys_addr;
1947 
1948  mpi25_ieee_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT |
1949  MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR;
1950 
1951  mpi25_ieee_chain->Length = MEGASAS_MAX_SZ_CHAIN_FRAME;
1952 
1953  return 0;
1954 }
1955 
1962 union MEGASAS_REQUEST_DESCRIPTOR_UNION *
1963 build_mpt_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
1964 {
1965  union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
1966  u16 index;
1967 
1968  if (build_mpt_mfi_pass_thru(instance, cmd)) {
1969  printk(KERN_ERR "Couldn't build MFI pass thru cmd\n");
1970  return NULL;
1971  }
1972 
1973  index = cmd->context.smid;
1974 
1975  req_desc = megasas_get_request_descriptor(instance, index - 1);
1976 
1977  if (!req_desc)
1978  return NULL;
1979 
1980  req_desc->Words = 0;
1981  req_desc->SCSIIO.RequestFlags = (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
1982  MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1983 
1984  req_desc->SCSIIO.SMID = index;
1985 
1986  return req_desc;
1987 }
1988 
1995 void
1996 megasas_issue_dcmd_fusion(struct megasas_instance *instance,
1997  struct megasas_cmd *cmd)
1998 {
1999  union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2000 
2001  req_desc = build_mpt_cmd(instance, cmd);
2002  if (!req_desc) {
2003  printk(KERN_ERR "Couldn't issue MFI pass thru cmd\n");
2004  return;
2005  }
2006  instance->instancet->fire_cmd(instance, req_desc->u.low,
2007  req_desc->u.high, instance->reg_set);
2008 }
2009 
2014 void
2015 megasas_release_fusion(struct megasas_instance *instance)
2016 {
2017  megasas_free_cmds(instance);
2018  megasas_free_cmds_fusion(instance);
2019 
2020  iounmap(instance->reg_set);
2021 
2022  pci_release_selected_regions(instance->pdev, instance->bar);
2023 }
2024 
2029 static u32
2030 megasas_read_fw_status_reg_fusion(struct megasas_register_set __iomem *regs)
2031 {
2032  return readl(&(regs)->outbound_scratch_pad);
2033 }
2034 
2039 static int
2040 megasas_adp_reset_fusion(struct megasas_instance *instance,
2041  struct megasas_register_set __iomem *regs)
2042 {
2043  return 0;
2044 }
2045 
2050 static int
2051 megasas_check_reset_fusion(struct megasas_instance *instance,
2052  struct megasas_register_set __iomem *regs)
2053 {
2054  return 0;
2055 }
2056 
2057 /* This function waits for outstanding commands on fusion to complete */
2058 int megasas_wait_for_outstanding_fusion(struct megasas_instance *instance)
2059 {
2060  int i, outstanding, retval = 0;
2061  u32 fw_state;
2062 
2063  for (i = 0; i < resetwaittime; i++) {
2064  /* Check if firmware is in fault state */
2065  fw_state = instance->instancet->read_fw_status_reg(
2066  instance->reg_set) & MFI_STATE_MASK;
2067  if (fw_state == MFI_STATE_FAULT) {
2068  printk(KERN_WARNING "megasas: Found FW in FAULT state,"
2069  " will reset adapter.\n");
2070  retval = 1;
2071  goto out;
2072  }
2073 
2074  outstanding = atomic_read(&instance->fw_outstanding);
2075  if (!outstanding)
2076  goto out;
2077 
2078  if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
2079  printk(KERN_NOTICE "megasas: [%2d]waiting for %d "
2080  "commands to complete\n", i, outstanding);
2081  megasas_complete_cmd_dpc_fusion(
2082  (unsigned long)instance);
2083  }
2084  msleep(1000);
2085  }
2086 
2087  if (atomic_read(&instance->fw_outstanding)) {
2088  printk("megaraid_sas: pending commands remain after waiting, "
2089  "will reset adapter.\n");
2090  retval = 1;
2091  }
2092 out:
2093  return retval;
2094 }
2095 
2096 void megasas_reset_reply_desc(struct megasas_instance *instance)
2097 {
2098  int i, count;
2099  struct fusion_context *fusion;
2100  union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc;
2101 
2102  fusion = instance->ctrl_context;
2103  count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
2104  for (i = 0 ; i < count ; i++)
2105  fusion->last_reply_idx[i] = 0;
2106  reply_desc = fusion->reply_frames_desc;
2107  for (i = 0 ; i < fusion->reply_q_depth * count; i++, reply_desc++)
2108  reply_desc->Words = ULLONG_MAX;
2109 }
2110 
2111 /* Core fusion reset function */
2112 int megasas_reset_fusion(struct Scsi_Host *shost)
2113 {
2114  int retval = SUCCESS, i, j, retry = 0;
2115  struct megasas_instance *instance;
2116  struct megasas_cmd_fusion *cmd_fusion;
2117  struct fusion_context *fusion;
2118  struct megasas_cmd *cmd_mfi;
2119  union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2120  u32 host_diag, abs_state, status_reg, reset_adapter;
2121 
2122  instance = (struct megasas_instance *)shost->hostdata;
2123  fusion = instance->ctrl_context;
2124 
2125  if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
2126  printk(KERN_WARNING "megaraid_sas: Hardware critical error, "
2127  "returning FAILED.\n");
2128  return FAILED;
2129  }
2130 
2131  mutex_lock(&instance->reset_mutex);
2132  set_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
2133  instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT;
2134  instance->instancet->disable_intr(instance->reg_set);
2135  msleep(1000);
2136 
2137  /* First try waiting for commands to complete */
2138  if (megasas_wait_for_outstanding_fusion(instance)) {
2139  printk(KERN_WARNING "megaraid_sas: resetting fusion "
2140  "adapter.\n");
2141  /* Now return commands back to the OS */
2142  for (i = 0 ; i < instance->max_fw_cmds; i++) {
2143  cmd_fusion = fusion->cmd_list[i];
2144  if (cmd_fusion->scmd) {
2145  scsi_dma_unmap(cmd_fusion->scmd);
2146  cmd_fusion->scmd->result = (DID_RESET << 16);
2147  cmd_fusion->scmd->scsi_done(cmd_fusion->scmd);
2148  megasas_return_cmd_fusion(instance, cmd_fusion);
2149  atomic_dec(&instance->fw_outstanding);
2150  }
2151  }
2152 
2153  status_reg = instance->instancet->read_fw_status_reg(
2154  instance->reg_set);
2155  abs_state = status_reg & MFI_STATE_MASK;
2156  reset_adapter = status_reg & MFI_RESET_ADAPTER;
2157  if (instance->disableOnlineCtrlReset ||
2158  (abs_state == MFI_STATE_FAULT && !reset_adapter)) {
2159  /* Reset not supported, kill adapter */
2160  printk(KERN_WARNING "megaraid_sas: Reset not supported"
2161  ", killing adapter.\n");
2162  megaraid_sas_kill_hba(instance);
2163  instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR;
2164  retval = FAILED;
2165  goto out;
2166  }
2167 
2168  /* Now try to reset the chip */
2169  for (i = 0; i < MEGASAS_FUSION_MAX_RESET_TRIES; i++) {
2170  writel(MPI2_WRSEQ_FLUSH_KEY_VALUE,
2171  &instance->reg_set->fusion_seq_offset);
2172  writel(MPI2_WRSEQ_1ST_KEY_VALUE,
2173  &instance->reg_set->fusion_seq_offset);
2174  writel(MPI2_WRSEQ_2ND_KEY_VALUE,
2175  &instance->reg_set->fusion_seq_offset);
2176  writel(MPI2_WRSEQ_3RD_KEY_VALUE,
2177  &instance->reg_set->fusion_seq_offset);
2178  writel(MPI2_WRSEQ_4TH_KEY_VALUE,
2179  &instance->reg_set->fusion_seq_offset);
2180  writel(MPI2_WRSEQ_5TH_KEY_VALUE,
2181  &instance->reg_set->fusion_seq_offset);
2182  writel(MPI2_WRSEQ_6TH_KEY_VALUE,
2183  &instance->reg_set->fusion_seq_offset);
2184 
2185  /* Check that the diag write enable (DRWE) bit is on */
2186  host_diag = readl(&instance->reg_set->fusion_host_diag);
2187  retry = 0;
2188  while (!(host_diag & HOST_DIAG_WRITE_ENABLE)) {
2189  msleep(100);
2190  host_diag =
2191  readl(&instance->reg_set->fusion_host_diag);
2192  if (retry++ == 100) {
2193  printk(KERN_WARNING "megaraid_sas: "
2194  "Host diag unlock failed!\n");
2195  break;
2196  }
2197  }
2198  if (!(host_diag & HOST_DIAG_WRITE_ENABLE))
2199  continue;
2200 
2201  /* Send chip reset command */
2202  writel(host_diag | HOST_DIAG_RESET_ADAPTER,
2203  &instance->reg_set->fusion_host_diag);
2204  msleep(3000);
2205 
2206  /* Make sure reset adapter bit is cleared */
2207  host_diag = readl(&instance->reg_set->fusion_host_diag);
2208  retry = 0;
2209  while (host_diag & HOST_DIAG_RESET_ADAPTER) {
2210  msleep(100);
2211  host_diag =
2212  readl(&instance->reg_set->fusion_host_diag);
2213  if (retry++ == 1000) {
2214  printk(KERN_WARNING "megaraid_sas: "
2215  "Diag reset adapter never "
2216  "cleared!\n");
2217  break;
2218  }
2219  }
2220  if (host_diag & HOST_DIAG_RESET_ADAPTER)
2221  continue;
2222 
2223  abs_state =
2224  instance->instancet->read_fw_status_reg(
2225  instance->reg_set) & MFI_STATE_MASK;
2226  retry = 0;
2227 
2228  while ((abs_state <= MFI_STATE_FW_INIT) &&
2229  (retry++ < 1000)) {
2230  msleep(100);
2231  abs_state =
2232  instance->instancet->read_fw_status_reg(
2233  instance->reg_set) & MFI_STATE_MASK;
2234  }
2235  if (abs_state <= MFI_STATE_FW_INIT) {
2236  printk(KERN_WARNING "megaraid_sas: firmware "
2237  "state < MFI_STATE_FW_INIT, state = "
2238  "0x%x\n", abs_state);
2239  continue;
2240  }
2241 
2242  /* Wait for FW to become ready */
2243  if (megasas_transition_to_ready(instance, 1)) {
2244  printk(KERN_WARNING "megaraid_sas: Failed to "
2245  "transition controller to ready.\n");
2246  continue;
2247  }
2248 
2249  megasas_reset_reply_desc(instance);
2250  if (megasas_ioc_init_fusion(instance)) {
2251  printk(KERN_WARNING "megaraid_sas: "
2252  "megasas_ioc_init_fusion() failed!\n");
2253  continue;
2254  }
2255 
2256  clear_bit(MEGASAS_FUSION_IN_RESET,
2257  &instance->reset_flags);
2258  instance->instancet->enable_intr(instance->reg_set);
2259  instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
2260 
2261  /* Re-fire management commands */
2262  for (j = 0 ; j < instance->max_fw_cmds; j++) {
2263  cmd_fusion = fusion->cmd_list[j];
2264  if (cmd_fusion->sync_cmd_idx !=
2265  (u32)ULONG_MAX) {
2266  cmd_mfi =
2267  instance->
2268  cmd_list[cmd_fusion->sync_cmd_idx];
2269  if (cmd_mfi->frame->dcmd.opcode ==
2270  MR_DCMD_LD_MAP_GET_INFO) {
2271  megasas_return_cmd(instance,
2272  cmd_mfi);
2273  megasas_return_cmd_fusion(
2274  instance, cmd_fusion);
2275  } else {
2276  req_desc =
2277  megasas_get_request_descriptor(
2278  instance,
2279  cmd_mfi->context.smid
2280  -1);
2281  if (!req_desc)
2282  printk(KERN_WARNING
2283  "req_desc NULL"
2284  "\n");
2285  else {
2286  instance->instancet->
2287  fire_cmd(instance,
2288  req_desc->
2289  u.low,
2290  req_desc->
2291  u.high,
2292  instance->
2293  reg_set);
2294  }
2295  }
2296  }
2297  }
2298 
2299  /* Reset load balance info */
2300  memset(fusion->load_balance_info, 0,
2301  sizeof(struct LD_LOAD_BALANCE_INFO)
2302  *MAX_LOGICAL_DRIVES);
2303 
2304  if (!megasas_get_map_info(instance))
2305  megasas_sync_map_info(instance);
2306 
2307  /* Adapter reset completed successfully */
2308  printk(KERN_WARNING "megaraid_sas: Reset "
2309  "successful.\n");
2310  retval = SUCCESS;
2311  goto out;
2312  }
2313  /* Reset failed, kill the adapter */
2314  printk(KERN_WARNING "megaraid_sas: Reset failed, killing "
2315  "adapter.\n");
2316  megaraid_sas_kill_hba(instance);
2317  retval = FAILED;
2318  } else {
2319  clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
2320  instance->instancet->enable_intr(instance->reg_set);
2321  instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
2322  }
2323 out:
2324  clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
2325  mutex_unlock(&instance->reset_mutex);
2326  return retval;
2327 }
2328 
2329 /* Fusion OCR work queue */
2330 void megasas_fusion_ocr_wq(struct work_struct *work)
2331 {
2332  struct megasas_instance *instance =
2333  container_of(work, struct megasas_instance, work_init);
2334 
2335  megasas_reset_fusion(instance->host);
2336 }
2337 
2338 struct megasas_instance_template megasas_instance_template_fusion = {
2339  .fire_cmd = megasas_fire_cmd_fusion,
2340  .enable_intr = megasas_enable_intr_fusion,
2341  .disable_intr = megasas_disable_intr_fusion,
2342  .clear_intr = megasas_clear_intr_fusion,
2343  .read_fw_status_reg = megasas_read_fw_status_reg_fusion,
2344  .adp_reset = megasas_adp_reset_fusion,
2345  .check_reset = megasas_check_reset_fusion,
2346  .service_isr = megasas_isr_fusion,
2347  .tasklet = megasas_complete_cmd_dpc_fusion,
2348  .init_adapter = megasas_init_adapter_fusion,
2349  .build_and_issue_cmd = megasas_build_and_issue_cmd_fusion,
2350  .issue_dcmd = megasas_issue_dcmd_fusion,
2351 };
Generated on Thu Jan 10 2013 14:22:30 for Linux Kernel by   doxygen 1.8.2