?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
irqchip/s3c24xx: Mark init_eint as __maybe_unused
[linux/fpc-iii.git] / drivers / scsi / megaraid / megaraid_sas_fusion.c
blob8d630a552b078721c5c5eea640995046a9907565
1 /*
2 * Linux MegaRAID driver for SAS based RAID controllers
3 *
4 * Copyright (c) 2009-2013 LSI Corporation
5 * Copyright (c) 2013-2014 Avago Technologies
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 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 *
20 * FILE: megaraid_sas_fusion.c
21 *
22 * Authors: Avago Technologies
23 * Sumant Patro
24 * Adam Radford
25 * Kashyap Desai <kashyap.desai@avagotech.com>
26 * Sumit Saxena <sumit.saxena@avagotech.com>
27 *
28 * Send feedback to: megaraidlinux.pdl@avagotech.com
29 *
30 * Mail to: Avago Technologies, 350 West Trimble Road, Building 90,
31 * San Jose, California 95131
32 */
33
34 #include <linux/kernel.h>
35 #include <linux/types.h>
36 #include <linux/pci.h>
37 #include <linux/list.h>
38 #include <linux/moduleparam.h>
39 #include <linux/module.h>
40 #include <linux/spinlock.h>
41 #include <linux/interrupt.h>
42 #include <linux/delay.h>
43 #include <linux/uio.h>
44 #include <linux/uaccess.h>
45 #include <linux/fs.h>
46 #include <linux/compat.h>
47 #include <linux/blkdev.h>
48 #include <linux/mutex.h>
49 #include <linux/poll.h>
50
51 #include <scsi/scsi.h>
52 #include <scsi/scsi_cmnd.h>
53 #include <scsi/scsi_device.h>
54 #include <scsi/scsi_host.h>
55 #include <scsi/scsi_dbg.h>
56 #include <linux/dmi.h>
57
58 #include "megaraid_sas_fusion.h"
59 #include "megaraid_sas.h"
60
61
62 extern void megasas_free_cmds(struct megasas_instance *instance);
63 extern struct megasas_cmd *megasas_get_cmd(struct megasas_instance
64 *instance);
65 extern void
66 megasas_complete_cmd(struct megasas_instance *instance,
67 struct megasas_cmd *cmd, u8 alt_status);
68 int
69 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
70 int seconds);
71
72 void
73 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd);
74 int megasas_alloc_cmds(struct megasas_instance *instance);
75 int
76 megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs);
77 int
78 megasas_issue_polled(struct megasas_instance *instance,
79 struct megasas_cmd *cmd);
80 void
81 megasas_check_and_restore_queue_depth(struct megasas_instance *instance);
82
83 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
84 void megaraid_sas_kill_hba(struct megasas_instance *instance);
85
86 extern u32 megasas_dbg_lvl;
87 void megasas_sriov_heartbeat_handler(unsigned long instance_addr);
88 int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
89 int initial);
90 void megasas_start_timer(struct megasas_instance *instance,
91 struct timer_list *timer,
92 void *fn, unsigned long interval);
93 extern struct megasas_mgmt_info megasas_mgmt_info;
94 extern int resetwaittime;
95
96
97
98 /**
99 * megasas_enable_intr_fusion - Enables interrupts
100 * @regs: MFI register set
101 */
102 void
103 megasas_enable_intr_fusion(struct megasas_instance *instance)
104 {
105 struct megasas_register_set __iomem *regs;
106 regs = instance->reg_set;
107
108 instance->mask_interrupts = 0;
109 /* For Thunderbolt/Invader also clear intr on enable */
110 writel(~0, &regs->outbound_intr_status);
111 readl(&regs->outbound_intr_status);
112
113 writel(~MFI_FUSION_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
114
115 /* Dummy readl to force pci flush */
116 readl(&regs->outbound_intr_mask);
117 }
118
119 /**
120 * megasas_disable_intr_fusion - Disables interrupt
121 * @regs: MFI register set
122 */
123 void
124 megasas_disable_intr_fusion(struct megasas_instance *instance)
125 {
126 u32 mask = 0xFFFFFFFF;
127 u32 status;
128 struct megasas_register_set __iomem *regs;
129 regs = instance->reg_set;
130 instance->mask_interrupts = 1;
131
132 writel(mask, &regs->outbound_intr_mask);
133 /* Dummy readl to force pci flush */
134 status = readl(&regs->outbound_intr_mask);
135 }
136
137 int
138 megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs)
139 {
140 u32 status;
141 /*
142 * Check if it is our interrupt
143 */
144 status = readl(&regs->outbound_intr_status);
145
146 if (status & 1) {
147 writel(status, &regs->outbound_intr_status);
148 readl(&regs->outbound_intr_status);
149 return 1;
150 }
151 if (!(status & MFI_FUSION_ENABLE_INTERRUPT_MASK))
152 return 0;
153
154 return 1;
155 }
156
157 /**
158 * megasas_get_cmd_fusion - Get a command from the free pool
159 * @instance: Adapter soft state
160 *
161 * Returns a blk_tag indexed mpt frame
162 */
163 inline struct megasas_cmd_fusion *megasas_get_cmd_fusion(struct megasas_instance
164 *instance, u32 blk_tag)
165 {
166 struct fusion_context *fusion;
167
168 fusion = instance->ctrl_context;
169 return fusion->cmd_list[blk_tag];
170 }
171
172 /**
173 * megasas_return_cmd_fusion - Return a cmd to free command pool
174 * @instance: Adapter soft state
175 * @cmd: Command packet to be returned to free command pool
176 */
177 inline void megasas_return_cmd_fusion(struct megasas_instance *instance,
178 struct megasas_cmd_fusion *cmd)
179 {
180 cmd->scmd = NULL;
181 memset(cmd->io_request, 0, sizeof(struct MPI2_RAID_SCSI_IO_REQUEST));
182 }
183
184 /**
185 * megasas_fire_cmd_fusion - Sends command to the FW
186 */
187 static void
188 megasas_fire_cmd_fusion(struct megasas_instance *instance,
189 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc)
190 {
191 #if defined(writeq) && defined(CONFIG_64BIT)
192 u64 req_data = (((u64)le32_to_cpu(req_desc->u.high) << 32) |
193 le32_to_cpu(req_desc->u.low));
194
195 writeq(req_data, &instance->reg_set->inbound_low_queue_port);
196 #else
197 unsigned long flags;
198
199 spin_lock_irqsave(&instance->hba_lock, flags);
200 writel(le32_to_cpu(req_desc->u.low),
201 &instance->reg_set->inbound_low_queue_port);
202 writel(le32_to_cpu(req_desc->u.high),
203 &instance->reg_set->inbound_high_queue_port);
204 spin_unlock_irqrestore(&instance->hba_lock, flags);
205 #endif
206 }
207
208
209 /**
210 * megasas_teardown_frame_pool_fusion - Destroy the cmd frame DMA pool
211 * @instance: Adapter soft state
212 */
213 static void megasas_teardown_frame_pool_fusion(
214 struct megasas_instance *instance)
215 {
216 int i;
217 struct fusion_context *fusion = instance->ctrl_context;
218
219 u16 max_cmd = instance->max_fw_cmds;
220
221 struct megasas_cmd_fusion *cmd;
222
223 if (!fusion->sg_dma_pool || !fusion->sense_dma_pool) {
224 dev_err(&instance->pdev->dev, "dma pool is null. SG Pool %p, "
225 "sense pool : %p\n", fusion->sg_dma_pool,
226 fusion->sense_dma_pool);
227 return;
228 }
229
230 /*
231 * Return all frames to pool
232 */
233 for (i = 0; i < max_cmd; i++) {
234
235 cmd = fusion->cmd_list[i];
236
237 if (cmd->sg_frame)
238 pci_pool_free(fusion->sg_dma_pool, cmd->sg_frame,
239 cmd->sg_frame_phys_addr);
240
241 if (cmd->sense)
242 pci_pool_free(fusion->sense_dma_pool, cmd->sense,
243 cmd->sense_phys_addr);
244 }
245
246 /*
247 * Now destroy the pool itself
248 */
249 pci_pool_destroy(fusion->sg_dma_pool);
250 pci_pool_destroy(fusion->sense_dma_pool);
251
252 fusion->sg_dma_pool = NULL;
253 fusion->sense_dma_pool = NULL;
254 }
255
256 /**
257 * megasas_free_cmds_fusion - Free all the cmds in the free cmd pool
258 * @instance: Adapter soft state
259 */
260 void
261 megasas_free_cmds_fusion(struct megasas_instance *instance)
262 {
263 int i;
264 struct fusion_context *fusion = instance->ctrl_context;
265
266 u32 max_cmds, req_sz, reply_sz, io_frames_sz;
267
268
269 req_sz = fusion->request_alloc_sz;
270 reply_sz = fusion->reply_alloc_sz;
271 io_frames_sz = fusion->io_frames_alloc_sz;
272
273 max_cmds = instance->max_fw_cmds;
274
275 /* Free descriptors and request Frames memory */
276 if (fusion->req_frames_desc)
277 dma_free_coherent(&instance->pdev->dev, req_sz,
278 fusion->req_frames_desc,
279 fusion->req_frames_desc_phys);
280
281 if (fusion->reply_frames_desc) {
282 pci_pool_free(fusion->reply_frames_desc_pool,
283 fusion->reply_frames_desc,
284 fusion->reply_frames_desc_phys);
285 pci_pool_destroy(fusion->reply_frames_desc_pool);
286 }
287
288 if (fusion->io_request_frames) {
289 pci_pool_free(fusion->io_request_frames_pool,
290 fusion->io_request_frames,
291 fusion->io_request_frames_phys);
292 pci_pool_destroy(fusion->io_request_frames_pool);
293 }
294
295 /* Free the Fusion frame pool */
296 megasas_teardown_frame_pool_fusion(instance);
297
298 /* Free all the commands in the cmd_list */
299 for (i = 0; i < max_cmds; i++)
300 kfree(fusion->cmd_list[i]);
301
302 /* Free the cmd_list buffer itself */
303 kfree(fusion->cmd_list);
304 fusion->cmd_list = NULL;
305
306 }
307
308 /**
309 * megasas_create_frame_pool_fusion - Creates DMA pool for cmd frames
310 * @instance: Adapter soft state
311 *
312 */
313 static int megasas_create_frame_pool_fusion(struct megasas_instance *instance)
314 {
315 int i;
316 u32 max_cmd;
317 struct fusion_context *fusion;
318 struct megasas_cmd_fusion *cmd;
319
320 fusion = instance->ctrl_context;
321 max_cmd = instance->max_fw_cmds;
322
323
324 /*
325 * Use DMA pool facility provided by PCI layer
326 */
327
328 fusion->sg_dma_pool = pci_pool_create("sg_pool_fusion", instance->pdev,
329 instance->max_chain_frame_sz,
330 4, 0);
331 if (!fusion->sg_dma_pool) {
332 dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup request pool fusion\n");
333 return -ENOMEM;
334 }
335 fusion->sense_dma_pool = pci_pool_create("sense pool fusion",
336 instance->pdev,
337 SCSI_SENSE_BUFFERSIZE, 64, 0);
338
339 if (!fusion->sense_dma_pool) {
340 dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup sense pool fusion\n");
341 pci_pool_destroy(fusion->sg_dma_pool);
342 fusion->sg_dma_pool = NULL;
343 return -ENOMEM;
344 }
345
346 /*
347 * Allocate and attach a frame to each of the commands in cmd_list
348 */
349 for (i = 0; i < max_cmd; i++) {
350
351 cmd = fusion->cmd_list[i];
352
353 cmd->sg_frame = pci_pool_alloc(fusion->sg_dma_pool,
354 GFP_KERNEL,
355 &cmd->sg_frame_phys_addr);
356
357 cmd->sense = pci_pool_alloc(fusion->sense_dma_pool,
358 GFP_KERNEL, &cmd->sense_phys_addr);
359 /*
360 * megasas_teardown_frame_pool_fusion() takes care of freeing
361 * whatever has been allocated
362 */
363 if (!cmd->sg_frame || !cmd->sense) {
364 dev_printk(KERN_DEBUG, &instance->pdev->dev, "pci_pool_alloc failed\n");
365 megasas_teardown_frame_pool_fusion(instance);
366 return -ENOMEM;
367 }
368 }
369 return 0;
370 }
371
372 /**
373 * megasas_alloc_cmds_fusion - Allocates the command packets
374 * @instance: Adapter soft state
375 *
376 *
377 * Each frame has a 32-bit field called context. This context is used to get
378 * back the megasas_cmd_fusion from the frame when a frame gets completed
379 * In this driver, the 32 bit values are the indices into an array cmd_list.
380 * This array is used only to look up the megasas_cmd_fusion given the context.
381 * The free commands themselves are maintained in a linked list called cmd_pool.
382 *
383 * cmds are formed in the io_request and sg_frame members of the
384 * megasas_cmd_fusion. The context field is used to get a request descriptor
385 * and is used as SMID of the cmd.
386 * SMID value range is from 1 to max_fw_cmds.
387 */
388 int
389 megasas_alloc_cmds_fusion(struct megasas_instance *instance)
390 {
391 int i, j, count;
392 u32 max_cmd, io_frames_sz;
393 struct fusion_context *fusion;
394 struct megasas_cmd_fusion *cmd;
395 union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc;
396 u32 offset;
397 dma_addr_t io_req_base_phys;
398 u8 *io_req_base;
399
400 fusion = instance->ctrl_context;
401
402 max_cmd = instance->max_fw_cmds;
403
404 fusion->req_frames_desc =
405 dma_alloc_coherent(&instance->pdev->dev,
406 fusion->request_alloc_sz,
407 &fusion->req_frames_desc_phys, GFP_KERNEL);
408
409 if (!fusion->req_frames_desc) {
410 dev_err(&instance->pdev->dev, "Could not allocate memory for "
411 "request_frames\n");
412 goto fail_req_desc;
413 }
414
415 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
416 fusion->reply_frames_desc_pool =
417 pci_pool_create("reply_frames pool", instance->pdev,
418 fusion->reply_alloc_sz * count, 16, 0);
419
420 if (!fusion->reply_frames_desc_pool) {
421 dev_err(&instance->pdev->dev, "Could not allocate memory for "
422 "reply_frame pool\n");
423 goto fail_reply_desc;
424 }
425
426 fusion->reply_frames_desc =
427 pci_pool_alloc(fusion->reply_frames_desc_pool, GFP_KERNEL,
428 &fusion->reply_frames_desc_phys);
429 if (!fusion->reply_frames_desc) {
430 dev_err(&instance->pdev->dev, "Could not allocate memory for "
431 "reply_frame pool\n");
432 pci_pool_destroy(fusion->reply_frames_desc_pool);
433 goto fail_reply_desc;
434 }
435
436 reply_desc = fusion->reply_frames_desc;
437 for (i = 0; i < fusion->reply_q_depth * count; i++, reply_desc++)
438 reply_desc->Words = cpu_to_le64(ULLONG_MAX);
439
440 io_frames_sz = fusion->io_frames_alloc_sz;
441
442 fusion->io_request_frames_pool =
443 pci_pool_create("io_request_frames pool", instance->pdev,
444 fusion->io_frames_alloc_sz, 16, 0);
445
446 if (!fusion->io_request_frames_pool) {
447 dev_err(&instance->pdev->dev, "Could not allocate memory for "
448 "io_request_frame pool\n");
449 goto fail_io_frames;
450 }
451
452 fusion->io_request_frames =
453 pci_pool_alloc(fusion->io_request_frames_pool, GFP_KERNEL,
454 &fusion->io_request_frames_phys);
455 if (!fusion->io_request_frames) {
456 dev_err(&instance->pdev->dev, "Could not allocate memory for "
457 "io_request_frames frames\n");
458 pci_pool_destroy(fusion->io_request_frames_pool);
459 goto fail_io_frames;
460 }
461
462 /*
463 * fusion->cmd_list is an array of struct megasas_cmd_fusion pointers.
464 * Allocate the dynamic array first and then allocate individual
465 * commands.
466 */
467 fusion->cmd_list = kzalloc(sizeof(struct megasas_cmd_fusion *)
468 * max_cmd, GFP_KERNEL);
469
470 if (!fusion->cmd_list) {
471 dev_printk(KERN_DEBUG, &instance->pdev->dev, "out of memory. Could not alloc "
472 "memory for cmd_list_fusion\n");
473 goto fail_cmd_list;
474 }
475
476 max_cmd = instance->max_fw_cmds;
477 for (i = 0; i < max_cmd; i++) {
478 fusion->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd_fusion),
479 GFP_KERNEL);
480 if (!fusion->cmd_list[i]) {
481 dev_err(&instance->pdev->dev, "Could not alloc cmd list fusion\n");
482
483 for (j = 0; j < i; j++)
484 kfree(fusion->cmd_list[j]);
485
486 kfree(fusion->cmd_list);
487 fusion->cmd_list = NULL;
488 goto fail_cmd_list;
489 }
490 }
491
492 /* The first 256 bytes (SMID 0) is not used. Don't add to cmd list */
493 io_req_base = fusion->io_request_frames +
494 MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE;
495 io_req_base_phys = fusion->io_request_frames_phys +
496 MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE;
497
498 /*
499 * Add all the commands to command pool (fusion->cmd_pool)
500 */
501
502 /* SMID 0 is reserved. Set SMID/index from 1 */
503 for (i = 0; i < max_cmd; i++) {
504 cmd = fusion->cmd_list[i];
505 offset = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * i;
506 memset(cmd, 0, sizeof(struct megasas_cmd_fusion));
507 cmd->index = i + 1;
508 cmd->scmd = NULL;
509 cmd->sync_cmd_idx = (i >= instance->max_scsi_cmds) ?
510 (i - instance->max_scsi_cmds) :
511 (u32)ULONG_MAX; /* Set to Invalid */
512 cmd->instance = instance;
513 cmd->io_request =
514 (struct MPI2_RAID_SCSI_IO_REQUEST *)
515 (io_req_base + offset);
516 memset(cmd->io_request, 0,
517 sizeof(struct MPI2_RAID_SCSI_IO_REQUEST));
518 cmd->io_request_phys_addr = io_req_base_phys + offset;
519 }
520
521 /*
522 * Create a frame pool and assign one frame to each cmd
523 */
524 if (megasas_create_frame_pool_fusion(instance)) {
525 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error creating frame DMA pool\n");
526 megasas_free_cmds_fusion(instance);
527 goto fail_req_desc;
528 }
529
530 return 0;
531
532 fail_cmd_list:
533 pci_pool_free(fusion->io_request_frames_pool, fusion->io_request_frames,
534 fusion->io_request_frames_phys);
535 pci_pool_destroy(fusion->io_request_frames_pool);
536 fail_io_frames:
537 dma_free_coherent(&instance->pdev->dev, fusion->request_alloc_sz,
538 fusion->reply_frames_desc,
539 fusion->reply_frames_desc_phys);
540 pci_pool_free(fusion->reply_frames_desc_pool,
541 fusion->reply_frames_desc,
542 fusion->reply_frames_desc_phys);
543 pci_pool_destroy(fusion->reply_frames_desc_pool);
544
545 fail_reply_desc:
546 dma_free_coherent(&instance->pdev->dev, fusion->request_alloc_sz,
547 fusion->req_frames_desc,
548 fusion->req_frames_desc_phys);
549 fail_req_desc:
550 return -ENOMEM;
551 }
552
553 /**
554 * wait_and_poll - Issues a polling command
555 * @instance: Adapter soft state
556 * @cmd: Command packet to be issued
557 *
558 * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
559 */
560 int
561 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
562 int seconds)
563 {
564 int i;
565 struct megasas_header *frame_hdr = &cmd->frame->hdr;
566 struct fusion_context *fusion;
567
568 u32 msecs = seconds * 1000;
569
570 fusion = instance->ctrl_context;
571 /*
572 * Wait for cmd_status to change
573 */
574 for (i = 0; (i < msecs) && (frame_hdr->cmd_status == 0xff); i += 20) {
575 rmb();
576 msleep(20);
577 }
578
579 if (frame_hdr->cmd_status == 0xff)
580 return -ETIME;
581
582 return (frame_hdr->cmd_status == MFI_STAT_OK) ?
583 0 : 1;
584 }
585
586 /**
587 * megasas_ioc_init_fusion - Initializes the FW
588 * @instance: Adapter soft state
589 *
590 * Issues the IOC Init cmd
591 */
592 int
593 megasas_ioc_init_fusion(struct megasas_instance *instance)
594 {
595 struct megasas_init_frame *init_frame;
596 struct MPI2_IOC_INIT_REQUEST *IOCInitMessage;
597 dma_addr_t ioc_init_handle;
598 struct megasas_cmd *cmd;
599 u8 ret;
600 struct fusion_context *fusion;
601 union MEGASAS_REQUEST_DESCRIPTOR_UNION req_desc;
602 int i;
603 struct megasas_header *frame_hdr;
604 const char *sys_info;
605 MFI_CAPABILITIES *drv_ops;
606
607 fusion = instance->ctrl_context;
608
609 cmd = megasas_get_cmd(instance);
610
611 if (!cmd) {
612 dev_err(&instance->pdev->dev, "Could not allocate cmd for INIT Frame\n");
613 ret = 1;
614 goto fail_get_cmd;
615 }
616
617 IOCInitMessage =
618 dma_alloc_coherent(&instance->pdev->dev,
619 sizeof(struct MPI2_IOC_INIT_REQUEST),
620 &ioc_init_handle, GFP_KERNEL);
621
622 if (!IOCInitMessage) {
623 dev_err(&instance->pdev->dev, "Could not allocate memory for "
624 "IOCInitMessage\n");
625 ret = 1;
626 goto fail_fw_init;
627 }
628
629 memset(IOCInitMessage, 0, sizeof(struct MPI2_IOC_INIT_REQUEST));
630
631 IOCInitMessage->Function = MPI2_FUNCTION_IOC_INIT;
632 IOCInitMessage->WhoInit = MPI2_WHOINIT_HOST_DRIVER;
633 IOCInitMessage->MsgVersion = cpu_to_le16(MPI2_VERSION);
634 IOCInitMessage->HeaderVersion = cpu_to_le16(MPI2_HEADER_VERSION);
635 IOCInitMessage->SystemRequestFrameSize = cpu_to_le16(MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE / 4);
636
637 IOCInitMessage->ReplyDescriptorPostQueueDepth = cpu_to_le16(fusion->reply_q_depth);
638 IOCInitMessage->ReplyDescriptorPostQueueAddress = cpu_to_le64(fusion->reply_frames_desc_phys);
639 IOCInitMessage->SystemRequestFrameBaseAddress = cpu_to_le64(fusion->io_request_frames_phys);
640 IOCInitMessage->HostMSIxVectors = instance->msix_vectors;
641 init_frame = (struct megasas_init_frame *)cmd->frame;
642 memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
643
644 frame_hdr = &cmd->frame->hdr;
645 frame_hdr->cmd_status = 0xFF;
646 frame_hdr->flags = cpu_to_le16(
647 le16_to_cpu(frame_hdr->flags) |
648 MFI_FRAME_DONT_POST_IN_REPLY_QUEUE);
649
650 init_frame->cmd = MFI_CMD_INIT;
651 init_frame->cmd_status = 0xFF;
652
653 drv_ops = (MFI_CAPABILITIES *) &(init_frame->driver_operations);
654
655 /* driver support Extended MSIX */
656 if (fusion->adapter_type == INVADER_SERIES)
657 drv_ops->mfi_capabilities.support_additional_msix = 1;
658 /* driver supports HA / Remote LUN over Fast Path interface */
659 drv_ops->mfi_capabilities.support_fp_remote_lun = 1;
660
661 drv_ops->mfi_capabilities.support_max_255lds = 1;
662 drv_ops->mfi_capabilities.support_ndrive_r1_lb = 1;
663 drv_ops->mfi_capabilities.security_protocol_cmds_fw = 1;
664
665 if (instance->max_chain_frame_sz > MEGASAS_CHAIN_FRAME_SZ_MIN)
666 drv_ops->mfi_capabilities.support_ext_io_size = 1;
667
668 /* Convert capability to LE32 */
669 cpu_to_le32s((u32 *)&init_frame->driver_operations.mfi_capabilities);
670
671 sys_info = dmi_get_system_info(DMI_PRODUCT_UUID);
672 if (instance->system_info_buf && sys_info) {
673 memcpy(instance->system_info_buf->systemId, sys_info,
674 strlen(sys_info) > 64 ? 64 : strlen(sys_info));
675 instance->system_info_buf->systemIdLength =
676 strlen(sys_info) > 64 ? 64 : strlen(sys_info);
677 init_frame->system_info_lo = instance->system_info_h;
678 init_frame->system_info_hi = 0;
679 }
680
681 init_frame->queue_info_new_phys_addr_hi =
682 cpu_to_le32(upper_32_bits(ioc_init_handle));
683 init_frame->queue_info_new_phys_addr_lo =
684 cpu_to_le32(lower_32_bits(ioc_init_handle));
685 init_frame->data_xfer_len = cpu_to_le32(sizeof(struct MPI2_IOC_INIT_REQUEST));
686
687 req_desc.u.low = cpu_to_le32(lower_32_bits(cmd->frame_phys_addr));
688 req_desc.u.high = cpu_to_le32(upper_32_bits(cmd->frame_phys_addr));
689 req_desc.MFAIo.RequestFlags =
690 (MEGASAS_REQ_DESCRIPT_FLAGS_MFA <<
691 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
692
693 /*
694 * disable the intr before firing the init frame
695 */
696 instance->instancet->disable_intr(instance);
697
698 for (i = 0; i < (10 * 1000); i += 20) {
699 if (readl(&instance->reg_set->doorbell) & 1)
700 msleep(20);
701 else
702 break;
703 }
704
705 megasas_fire_cmd_fusion(instance, &req_desc);
706
707 wait_and_poll(instance, cmd, MFI_POLL_TIMEOUT_SECS);
708
709 frame_hdr = &cmd->frame->hdr;
710 if (frame_hdr->cmd_status != 0) {
711 ret = 1;
712 goto fail_fw_init;
713 }
714 dev_err(&instance->pdev->dev, "Init cmd success\n");
715
716 ret = 0;
717
718 fail_fw_init:
719 megasas_return_cmd(instance, cmd);
720 if (IOCInitMessage)
721 dma_free_coherent(&instance->pdev->dev,
722 sizeof(struct MPI2_IOC_INIT_REQUEST),
723 IOCInitMessage, ioc_init_handle);
724 fail_get_cmd:
725 return ret;
726 }
727
728 /**
729 * megasas_sync_pd_seq_num - JBOD SEQ MAP
730 * @instance: Adapter soft state
731 * @pend: set to 1, if it is pended jbod map.
732 *
733 * Issue Jbod map to the firmware. If it is pended command,
734 * issue command and return. If it is first instance of jbod map
735 * issue and receive command.
736 */
737 int
738 megasas_sync_pd_seq_num(struct megasas_instance *instance, bool pend) {
739 int ret = 0;
740 u32 pd_seq_map_sz;
741 struct megasas_cmd *cmd;
742 struct megasas_dcmd_frame *dcmd;
743 struct fusion_context *fusion = instance->ctrl_context;
744 struct MR_PD_CFG_SEQ_NUM_SYNC *pd_sync;
745 dma_addr_t pd_seq_h;
746
747 pd_sync = (void *)fusion->pd_seq_sync[(instance->pd_seq_map_id & 1)];
748 pd_seq_h = fusion->pd_seq_phys[(instance->pd_seq_map_id & 1)];
749 pd_seq_map_sz = sizeof(struct MR_PD_CFG_SEQ_NUM_SYNC) +
750 (sizeof(struct MR_PD_CFG_SEQ) *
751 (MAX_PHYSICAL_DEVICES - 1));
752
753 cmd = megasas_get_cmd(instance);
754 if (!cmd) {
755 dev_err(&instance->pdev->dev,
756 "Could not get mfi cmd. Fail from %s %d\n",
757 __func__, __LINE__);
758 return -ENOMEM;
759 }
760
761 dcmd = &cmd->frame->dcmd;
762
763 memset(pd_sync, 0, pd_seq_map_sz);
764 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
765 dcmd->cmd = MFI_CMD_DCMD;
766 dcmd->cmd_status = 0xFF;
767 dcmd->sge_count = 1;
768 dcmd->timeout = 0;
769 dcmd->pad_0 = 0;
770 dcmd->data_xfer_len = cpu_to_le32(pd_seq_map_sz);
771 dcmd->opcode = cpu_to_le32(MR_DCMD_SYSTEM_PD_MAP_GET_INFO);
772 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(pd_seq_h);
773 dcmd->sgl.sge32[0].length = cpu_to_le32(pd_seq_map_sz);
774
775 if (pend) {
776 dcmd->mbox.b[0] = MEGASAS_DCMD_MBOX_PEND_FLAG;
777 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_WRITE);
778 instance->jbod_seq_cmd = cmd;
779 instance->instancet->issue_dcmd(instance, cmd);
780 return 0;
781 }
782
783 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
784
785 /* Below code is only for non pended DCMD */
786 if (instance->ctrl_context && !instance->mask_interrupts)
787 ret = megasas_issue_blocked_cmd(instance, cmd, 60);
788 else
789 ret = megasas_issue_polled(instance, cmd);
790
791 if (le32_to_cpu(pd_sync->count) > MAX_PHYSICAL_DEVICES) {
792 dev_warn(&instance->pdev->dev,
793 "driver supports max %d JBOD, but FW reports %d\n",
794 MAX_PHYSICAL_DEVICES, le32_to_cpu(pd_sync->count));
795 ret = -EINVAL;
796 }
797
798 if (!ret)
799 instance->pd_seq_map_id++;
800
801 megasas_return_cmd(instance, cmd);
802 return ret;
803 }
804
805 /*
806 * megasas_get_ld_map_info - Returns FW's ld_map structure
807 * @instance: Adapter soft state
808 * @pend: Pend the command or not
809 * Issues an internal command (DCMD) to get the FW's controller PD
810 * list structure. This information is mainly used to find out SYSTEM
811 * supported by the FW.
812 * dcmd.mbox value setting for MR_DCMD_LD_MAP_GET_INFO
813 * dcmd.mbox.b[0] - number of LDs being sync'd
814 * dcmd.mbox.b[1] - 0 - complete command immediately.
815 * - 1 - pend till config change
816 * dcmd.mbox.b[2] - 0 - supports max 64 lds and uses legacy MR_FW_RAID_MAP
817 * - 1 - supports max MAX_LOGICAL_DRIVES_EXT lds and
818 * uses extended struct MR_FW_RAID_MAP_EXT
819 */
820 static int
821 megasas_get_ld_map_info(struct megasas_instance *instance)
822 {
823 int ret = 0;
824 struct megasas_cmd *cmd;
825 struct megasas_dcmd_frame *dcmd;
826 void *ci;
827 dma_addr_t ci_h = 0;
828 u32 size_map_info;
829 struct fusion_context *fusion;
830
831 cmd = megasas_get_cmd(instance);
832
833 if (!cmd) {
834 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get cmd for map info\n");
835 return -ENOMEM;
836 }
837
838 fusion = instance->ctrl_context;
839
840 if (!fusion) {
841 megasas_return_cmd(instance, cmd);
842 return -ENXIO;
843 }
844
845 dcmd = &cmd->frame->dcmd;
846
847 size_map_info = fusion->current_map_sz;
848
849 ci = (void *) fusion->ld_map[(instance->map_id & 1)];
850 ci_h = fusion->ld_map_phys[(instance->map_id & 1)];
851
852 if (!ci) {
853 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc mem for ld_map_info\n");
854 megasas_return_cmd(instance, cmd);
855 return -ENOMEM;
856 }
857
858 memset(ci, 0, fusion->max_map_sz);
859 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
860 #if VD_EXT_DEBUG
861 dev_dbg(&instance->pdev->dev,
862 "%s sending MR_DCMD_LD_MAP_GET_INFO with size %d\n",
863 __func__, cpu_to_le32(size_map_info));
864 #endif
865 dcmd->cmd = MFI_CMD_DCMD;
866 dcmd->cmd_status = 0xFF;
867 dcmd->sge_count = 1;
868 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
869 dcmd->timeout = 0;
870 dcmd->pad_0 = 0;
871 dcmd->data_xfer_len = cpu_to_le32(size_map_info);
872 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_MAP_GET_INFO);
873 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
874 dcmd->sgl.sge32[0].length = cpu_to_le32(size_map_info);
875
876 if (instance->ctrl_context && !instance->mask_interrupts)
877 ret = megasas_issue_blocked_cmd(instance, cmd,
878 MEGASAS_BLOCKED_CMD_TIMEOUT);
879 else
880 ret = megasas_issue_polled(instance, cmd);
881
882 megasas_return_cmd(instance, cmd);
883
884 return ret;
885 }
886
887 u8
888 megasas_get_map_info(struct megasas_instance *instance)
889 {
890 struct fusion_context *fusion = instance->ctrl_context;
891
892 fusion->fast_path_io = 0;
893 if (!megasas_get_ld_map_info(instance)) {
894 if (MR_ValidateMapInfo(instance)) {
895 fusion->fast_path_io = 1;
896 return 0;
897 }
898 }
899 return 1;
900 }
901
902 /*
903 * megasas_sync_map_info - Returns FW's ld_map structure
904 * @instance: Adapter soft state
905 *
906 * Issues an internal command (DCMD) to get the FW's controller PD
907 * list structure. This information is mainly used to find out SYSTEM
908 * supported by the FW.
909 */
910 int
911 megasas_sync_map_info(struct megasas_instance *instance)
912 {
913 int ret = 0, i;
914 struct megasas_cmd *cmd;
915 struct megasas_dcmd_frame *dcmd;
916 u32 size_sync_info, num_lds;
917 struct fusion_context *fusion;
918 struct MR_LD_TARGET_SYNC *ci = NULL;
919 struct MR_DRV_RAID_MAP_ALL *map;
920 struct MR_LD_RAID *raid;
921 struct MR_LD_TARGET_SYNC *ld_sync;
922 dma_addr_t ci_h = 0;
923 u32 size_map_info;
924
925 cmd = megasas_get_cmd(instance);
926
927 if (!cmd) {
928 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get cmd for sync info\n");
929 return -ENOMEM;
930 }
931
932 fusion = instance->ctrl_context;
933
934 if (!fusion) {
935 megasas_return_cmd(instance, cmd);
936 return 1;
937 }
938
939 map = fusion->ld_drv_map[instance->map_id & 1];
940
941 num_lds = le16_to_cpu(map->raidMap.ldCount);
942
943 dcmd = &cmd->frame->dcmd;
944
945 size_sync_info = sizeof(struct MR_LD_TARGET_SYNC) *num_lds;
946
947 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
948
949 ci = (struct MR_LD_TARGET_SYNC *)
950 fusion->ld_map[(instance->map_id - 1) & 1];
951 memset(ci, 0, fusion->max_map_sz);
952
953 ci_h = fusion->ld_map_phys[(instance->map_id - 1) & 1];
954
955 ld_sync = (struct MR_LD_TARGET_SYNC *)ci;
956
957 for (i = 0; i < num_lds; i++, ld_sync++) {
958 raid = MR_LdRaidGet(i, map);
959 ld_sync->targetId = MR_GetLDTgtId(i, map);
960 ld_sync->seqNum = raid->seqNum;
961 }
962
963 size_map_info = fusion->current_map_sz;
964
965 dcmd->cmd = MFI_CMD_DCMD;
966 dcmd->cmd_status = 0xFF;
967 dcmd->sge_count = 1;
968 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_WRITE);
969 dcmd->timeout = 0;
970 dcmd->pad_0 = 0;
971 dcmd->data_xfer_len = cpu_to_le32(size_map_info);
972 dcmd->mbox.b[0] = num_lds;
973 dcmd->mbox.b[1] = MEGASAS_DCMD_MBOX_PEND_FLAG;
974 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_MAP_GET_INFO);
975 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
976 dcmd->sgl.sge32[0].length = cpu_to_le32(size_map_info);
977
978 instance->map_update_cmd = cmd;
979
980 instance->instancet->issue_dcmd(instance, cmd);
981
982 return ret;
983 }
984
985 /*
986 * meagasas_display_intel_branding - Display branding string
987 * @instance: per adapter object
988 *
989 * Return nothing.
990 */
991 static void
992 megasas_display_intel_branding(struct megasas_instance *instance)
993 {
994 if (instance->pdev->subsystem_vendor != PCI_VENDOR_ID_INTEL)
995 return;
996
997 switch (instance->pdev->device) {
998 case PCI_DEVICE_ID_LSI_INVADER:
999 switch (instance->pdev->subsystem_device) {
1000 case MEGARAID_INTEL_RS3DC080_SSDID:
1001 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1002 instance->host->host_no,
1003 MEGARAID_INTEL_RS3DC080_BRANDING);
1004 break;
1005 case MEGARAID_INTEL_RS3DC040_SSDID:
1006 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1007 instance->host->host_no,
1008 MEGARAID_INTEL_RS3DC040_BRANDING);
1009 break;
1010 case MEGARAID_INTEL_RS3SC008_SSDID:
1011 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1012 instance->host->host_no,
1013 MEGARAID_INTEL_RS3SC008_BRANDING);
1014 break;
1015 case MEGARAID_INTEL_RS3MC044_SSDID:
1016 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1017 instance->host->host_no,
1018 MEGARAID_INTEL_RS3MC044_BRANDING);
1019 break;
1020 default:
1021 break;
1022 }
1023 break;
1024 case PCI_DEVICE_ID_LSI_FURY:
1025 switch (instance->pdev->subsystem_device) {
1026 case MEGARAID_INTEL_RS3WC080_SSDID:
1027 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1028 instance->host->host_no,
1029 MEGARAID_INTEL_RS3WC080_BRANDING);
1030 break;
1031 case MEGARAID_INTEL_RS3WC040_SSDID:
1032 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1033 instance->host->host_no,
1034 MEGARAID_INTEL_RS3WC040_BRANDING);
1035 break;
1036 default:
1037 break;
1038 }
1039 break;
1040 case PCI_DEVICE_ID_LSI_CUTLASS_52:
1041 case PCI_DEVICE_ID_LSI_CUTLASS_53:
1042 switch (instance->pdev->subsystem_device) {
1043 case MEGARAID_INTEL_RMS3BC160_SSDID:
1044 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1045 instance->host->host_no,
1046 MEGARAID_INTEL_RMS3BC160_BRANDING);
1047 break;
1048 default:
1049 break;
1050 }
1051 break;
1052 default:
1053 break;
1054 }
1055 }
1056
1057 /**
1058 * megasas_init_adapter_fusion - Initializes the FW
1059 * @instance: Adapter soft state
1060 *
1061 * This is the main function for initializing firmware.
1062 */
1063 u32
1064 megasas_init_adapter_fusion(struct megasas_instance *instance)
1065 {
1066 struct megasas_register_set __iomem *reg_set;
1067 struct fusion_context *fusion;
1068 u32 max_cmd, scratch_pad_2;
1069 int i = 0, count;
1070
1071 fusion = instance->ctrl_context;
1072
1073 reg_set = instance->reg_set;
1074
1075 /*
1076 * Get various operational parameters from status register
1077 */
1078 instance->max_fw_cmds =
1079 instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF;
1080 instance->max_fw_cmds = min(instance->max_fw_cmds, (u16)1008);
1081
1082 /*
1083 * Reduce the max supported cmds by 1. This is to ensure that the
1084 * reply_q_sz (1 more than the max cmd that driver may send)
1085 * does not exceed max cmds that the FW can support
1086 */
1087 instance->max_fw_cmds = instance->max_fw_cmds-1;
1088
1089 /*
1090 * Only Driver's internal DCMDs and IOCTL DCMDs needs to have MFI frames
1091 */
1092 instance->max_mfi_cmds =
1093 MEGASAS_FUSION_INTERNAL_CMDS + MEGASAS_FUSION_IOCTL_CMDS;
1094
1095 max_cmd = instance->max_fw_cmds;
1096
1097 fusion->reply_q_depth = 2 * (((max_cmd + 1 + 15)/16)*16);
1098
1099 fusion->request_alloc_sz =
1100 sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) *max_cmd;
1101 fusion->reply_alloc_sz = sizeof(union MPI2_REPLY_DESCRIPTORS_UNION)
1102 *(fusion->reply_q_depth);
1103 fusion->io_frames_alloc_sz = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE +
1104 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE *
1105 (max_cmd + 1)); /* Extra 1 for SMID 0 */
1106
1107 scratch_pad_2 = readl(&instance->reg_set->outbound_scratch_pad_2);
1108 /* If scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_UNITS_MASK is set,
1109 * Firmware support extended IO chain frame which is 4 times more than
1110 * legacy Firmware.
1111 * Legacy Firmware - Frame size is (8 * 128) = 1K
1112 * 1M IO Firmware - Frame size is (8 * 128 * 4) = 4K
1113 */
1114 if (scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_UNITS_MASK)
1115 instance->max_chain_frame_sz =
1116 ((scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_MASK) >>
1117 MEGASAS_MAX_CHAIN_SHIFT) * MEGASAS_1MB_IO;
1118 else
1119 instance->max_chain_frame_sz =
1120 ((scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_MASK) >>
1121 MEGASAS_MAX_CHAIN_SHIFT) * MEGASAS_256K_IO;
1122
1123 if (instance->max_chain_frame_sz < MEGASAS_CHAIN_FRAME_SZ_MIN) {
1124 dev_warn(&instance->pdev->dev, "frame size %d invalid, fall back to legacy max frame size %d\n",
1125 instance->max_chain_frame_sz,
1126 MEGASAS_CHAIN_FRAME_SZ_MIN);
1127 instance->max_chain_frame_sz = MEGASAS_CHAIN_FRAME_SZ_MIN;
1128 }
1129
1130 fusion->max_sge_in_main_msg =
1131 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE
1132 - offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL))/16;
1133
1134 fusion->max_sge_in_chain =
1135 instance->max_chain_frame_sz
1136 / sizeof(union MPI2_SGE_IO_UNION);
1137
1138 instance->max_num_sge =
1139 rounddown_pow_of_two(fusion->max_sge_in_main_msg
1140 + fusion->max_sge_in_chain - 2);
1141
1142 /* Used for pass thru MFI frame (DCMD) */
1143 fusion->chain_offset_mfi_pthru =
1144 offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL)/16;
1145
1146 fusion->chain_offset_io_request =
1147 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE -
1148 sizeof(union MPI2_SGE_IO_UNION))/16;
1149
1150 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
1151 for (i = 0 ; i < count; i++)
1152 fusion->last_reply_idx[i] = 0;
1153
1154 /*
1155 * For fusion adapters, 3 commands for IOCTL and 5 commands
1156 * for driver's internal DCMDs.
1157 */
1158 instance->max_scsi_cmds = instance->max_fw_cmds -
1159 (MEGASAS_FUSION_INTERNAL_CMDS +
1160 MEGASAS_FUSION_IOCTL_CMDS);
1161 sema_init(&instance->ioctl_sem, MEGASAS_FUSION_IOCTL_CMDS);
1162
1163 /*
1164 * Allocate memory for descriptors
1165 * Create a pool of commands
1166 */
1167 if (megasas_alloc_cmds(instance))
1168 goto fail_alloc_mfi_cmds;
1169 if (megasas_alloc_cmds_fusion(instance))
1170 goto fail_alloc_cmds;
1171
1172 if (megasas_ioc_init_fusion(instance))
1173 goto fail_ioc_init;
1174
1175 megasas_display_intel_branding(instance);
1176 if (megasas_get_ctrl_info(instance)) {
1177 dev_err(&instance->pdev->dev,
1178 "Could not get controller info. Fail from %s %d\n",
1179 __func__, __LINE__);
1180 goto fail_ioc_init;
1181 }
1182
1183 instance->flag_ieee = 1;
1184 fusion->fast_path_io = 0;
1185
1186 fusion->drv_map_pages = get_order(fusion->drv_map_sz);
1187 for (i = 0; i < 2; i++) {
1188 fusion->ld_map[i] = NULL;
1189 fusion->ld_drv_map[i] = (void *)__get_free_pages(GFP_KERNEL,
1190 fusion->drv_map_pages);
1191 if (!fusion->ld_drv_map[i]) {
1192 dev_err(&instance->pdev->dev, "Could not allocate "
1193 "memory for local map info for %d pages\n",
1194 fusion->drv_map_pages);
1195 if (i == 1)
1196 free_pages((ulong)fusion->ld_drv_map[0],
1197 fusion->drv_map_pages);
1198 goto fail_ioc_init;
1199 }
1200 memset(fusion->ld_drv_map[i], 0,
1201 ((1 << PAGE_SHIFT) << fusion->drv_map_pages));
1202 }
1203
1204 for (i = 0; i < 2; i++) {
1205 fusion->ld_map[i] = dma_alloc_coherent(&instance->pdev->dev,
1206 fusion->max_map_sz,
1207 &fusion->ld_map_phys[i],
1208 GFP_KERNEL);
1209 if (!fusion->ld_map[i]) {
1210 dev_err(&instance->pdev->dev, "Could not allocate memory "
1211 "for map info\n");
1212 goto fail_map_info;
1213 }
1214 }
1215
1216 if (!megasas_get_map_info(instance))
1217 megasas_sync_map_info(instance);
1218
1219 return 0;
1220
1221 fail_map_info:
1222 if (i == 1)
1223 dma_free_coherent(&instance->pdev->dev, fusion->max_map_sz,
1224 fusion->ld_map[0], fusion->ld_map_phys[0]);
1225 fail_ioc_init:
1226 megasas_free_cmds_fusion(instance);
1227 fail_alloc_cmds:
1228 megasas_free_cmds(instance);
1229 fail_alloc_mfi_cmds:
1230 return 1;
1231 }
1232
1233 /**
1234 * map_cmd_status - Maps FW cmd status to OS cmd status
1235 * @cmd : Pointer to cmd
1236 * @status : status of cmd returned by FW
1237 * @ext_status : ext status of cmd returned by FW
1238 */
1239
1240 void
1241 map_cmd_status(struct megasas_cmd_fusion *cmd, u8 status, u8 ext_status)
1242 {
1243
1244 switch (status) {
1245
1246 case MFI_STAT_OK:
1247 cmd->scmd->result = DID_OK << 16;
1248 break;
1249
1250 case MFI_STAT_SCSI_IO_FAILED:
1251 case MFI_STAT_LD_INIT_IN_PROGRESS:
1252 cmd->scmd->result = (DID_ERROR << 16) | ext_status;
1253 break;
1254
1255 case MFI_STAT_SCSI_DONE_WITH_ERROR:
1256
1257 cmd->scmd->result = (DID_OK << 16) | ext_status;
1258 if (ext_status == SAM_STAT_CHECK_CONDITION) {
1259 memset(cmd->scmd->sense_buffer, 0,
1260 SCSI_SENSE_BUFFERSIZE);
1261 memcpy(cmd->scmd->sense_buffer, cmd->sense,
1262 SCSI_SENSE_BUFFERSIZE);
1263 cmd->scmd->result |= DRIVER_SENSE << 24;
1264 }
1265 break;
1266
1267 case MFI_STAT_LD_OFFLINE:
1268 case MFI_STAT_DEVICE_NOT_FOUND:
1269 cmd->scmd->result = DID_BAD_TARGET << 16;
1270 break;
1271 case MFI_STAT_CONFIG_SEQ_MISMATCH:
1272 cmd->scmd->result = DID_IMM_RETRY << 16;
1273 break;
1274 default:
1275 dev_printk(KERN_DEBUG, &cmd->instance->pdev->dev, "FW status %#x\n", status);
1276 cmd->scmd->result = DID_ERROR << 16;
1277 break;
1278 }
1279 }
1280
1281 /**
1282 * megasas_make_sgl_fusion - Prepares 32-bit SGL
1283 * @instance: Adapter soft state
1284 * @scp: SCSI command from the mid-layer
1285 * @sgl_ptr: SGL to be filled in
1286 * @cmd: cmd we are working on
1287 *
1288 * If successful, this function returns the number of SG elements.
1289 */
1290 static int
1291 megasas_make_sgl_fusion(struct megasas_instance *instance,
1292 struct scsi_cmnd *scp,
1293 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr,
1294 struct megasas_cmd_fusion *cmd)
1295 {
1296 int i, sg_processed, sge_count;
1297 struct scatterlist *os_sgl;
1298 struct fusion_context *fusion;
1299
1300 fusion = instance->ctrl_context;
1301
1302 if (fusion->adapter_type == INVADER_SERIES) {
1303 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr_end = sgl_ptr;
1304 sgl_ptr_end += fusion->max_sge_in_main_msg - 1;
1305 sgl_ptr_end->Flags = 0;
1306 }
1307
1308 sge_count = scsi_dma_map(scp);
1309
1310 BUG_ON(sge_count < 0);
1311
1312 if (sge_count > instance->max_num_sge || !sge_count)
1313 return sge_count;
1314
1315 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1316 sgl_ptr->Length = cpu_to_le32(sg_dma_len(os_sgl));
1317 sgl_ptr->Address = cpu_to_le64(sg_dma_address(os_sgl));
1318 sgl_ptr->Flags = 0;
1319 if (fusion->adapter_type == INVADER_SERIES)
1320 if (i == sge_count - 1)
1321 sgl_ptr->Flags = IEEE_SGE_FLAGS_END_OF_LIST;
1322 sgl_ptr++;
1323
1324 sg_processed = i + 1;
1325
1326 if ((sg_processed == (fusion->max_sge_in_main_msg - 1)) &&
1327 (sge_count > fusion->max_sge_in_main_msg)) {
1328
1329 struct MPI25_IEEE_SGE_CHAIN64 *sg_chain;
1330 if (fusion->adapter_type == INVADER_SERIES) {
1331 if ((le16_to_cpu(cmd->io_request->IoFlags) &
1332 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH) !=
1333 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH)
1334 cmd->io_request->ChainOffset =
1335 fusion->
1336 chain_offset_io_request;
1337 else
1338 cmd->io_request->ChainOffset = 0;
1339 } else
1340 cmd->io_request->ChainOffset =
1341 fusion->chain_offset_io_request;
1342
1343 sg_chain = sgl_ptr;
1344 /* Prepare chain element */
1345 sg_chain->NextChainOffset = 0;
1346 if (fusion->adapter_type == INVADER_SERIES)
1347 sg_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT;
1348 else
1349 sg_chain->Flags =
1350 (IEEE_SGE_FLAGS_CHAIN_ELEMENT |
1351 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR);
1352 sg_chain->Length = cpu_to_le32((sizeof(union MPI2_SGE_IO_UNION) * (sge_count - sg_processed)));
1353 sg_chain->Address = cpu_to_le64(cmd->sg_frame_phys_addr);
1354
1355 sgl_ptr =
1356 (struct MPI25_IEEE_SGE_CHAIN64 *)cmd->sg_frame;
1357 memset(sgl_ptr, 0, instance->max_chain_frame_sz);
1358 }
1359 }
1360
1361 return sge_count;
1362 }
1363
1364 /**
1365 * megasas_set_pd_lba - Sets PD LBA
1366 * @cdb: CDB
1367 * @cdb_len: cdb length
1368 * @start_blk: Start block of IO
1369 *
1370 * Used to set the PD LBA in CDB for FP IOs
1371 */
1372 void
1373 megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len,
1374 struct IO_REQUEST_INFO *io_info, struct scsi_cmnd *scp,
1375 struct MR_DRV_RAID_MAP_ALL *local_map_ptr, u32 ref_tag)
1376 {
1377 struct MR_LD_RAID *raid;
1378 u32 ld;
1379 u64 start_blk = io_info->pdBlock;
1380 u8 *cdb = io_request->CDB.CDB32;
1381 u32 num_blocks = io_info->numBlocks;
1382 u8 opcode = 0, flagvals = 0, groupnum = 0, control = 0;
1383
1384 /* Check if T10 PI (DIF) is enabled for this LD */
1385 ld = MR_TargetIdToLdGet(io_info->ldTgtId, local_map_ptr);
1386 raid = MR_LdRaidGet(ld, local_map_ptr);
1387 if (raid->capability.ldPiMode == MR_PROT_INFO_TYPE_CONTROLLER) {
1388 memset(cdb, 0, sizeof(io_request->CDB.CDB32));
1389 cdb[0] = MEGASAS_SCSI_VARIABLE_LENGTH_CMD;
1390 cdb[7] = MEGASAS_SCSI_ADDL_CDB_LEN;
1391
1392 if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1393 cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_READ32;
1394 else
1395 cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_WRITE32;
1396 cdb[10] = MEGASAS_RD_WR_PROTECT_CHECK_ALL;
1397
1398 /* LBA */
1399 cdb[12] = (u8)((start_blk >> 56) & 0xff);
1400 cdb[13] = (u8)((start_blk >> 48) & 0xff);
1401 cdb[14] = (u8)((start_blk >> 40) & 0xff);
1402 cdb[15] = (u8)((start_blk >> 32) & 0xff);
1403 cdb[16] = (u8)((start_blk >> 24) & 0xff);
1404 cdb[17] = (u8)((start_blk >> 16) & 0xff);
1405 cdb[18] = (u8)((start_blk >> 8) & 0xff);
1406 cdb[19] = (u8)(start_blk & 0xff);
1407
1408 /* Logical block reference tag */
1409 io_request->CDB.EEDP32.PrimaryReferenceTag =
1410 cpu_to_be32(ref_tag);
1411 io_request->CDB.EEDP32.PrimaryApplicationTagMask = cpu_to_be16(0xffff);
1412 io_request->IoFlags = cpu_to_le16(32); /* Specify 32-byte cdb */
1413
1414 /* Transfer length */
1415 cdb[28] = (u8)((num_blocks >> 24) & 0xff);
1416 cdb[29] = (u8)((num_blocks >> 16) & 0xff);
1417 cdb[30] = (u8)((num_blocks >> 8) & 0xff);
1418 cdb[31] = (u8)(num_blocks & 0xff);
1419
1420 /* set SCSI IO EEDPFlags */
1421 if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) {
1422 io_request->EEDPFlags = cpu_to_le16(
1423 MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
1424 MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
1425 MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP |
1426 MPI2_SCSIIO_EEDPFLAGS_CHECK_APPTAG |
1427 MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD);
1428 } else {
1429 io_request->EEDPFlags = cpu_to_le16(
1430 MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
1431 MPI2_SCSIIO_EEDPFLAGS_INSERT_OP);
1432 }
1433 io_request->Control |= cpu_to_le32((0x4 << 26));
1434 io_request->EEDPBlockSize = cpu_to_le32(scp->device->sector_size);
1435 } else {
1436 /* Some drives don't support 16/12 byte CDB's, convert to 10 */
1437 if (((cdb_len == 12) || (cdb_len == 16)) &&
1438 (start_blk <= 0xffffffff)) {
1439 if (cdb_len == 16) {
1440 opcode = cdb[0] == READ_16 ? READ_10 : WRITE_10;
1441 flagvals = cdb[1];
1442 groupnum = cdb[14];
1443 control = cdb[15];
1444 } else {
1445 opcode = cdb[0] == READ_12 ? READ_10 : WRITE_10;
1446 flagvals = cdb[1];
1447 groupnum = cdb[10];
1448 control = cdb[11];
1449 }
1450
1451 memset(cdb, 0, sizeof(io_request->CDB.CDB32));
1452
1453 cdb[0] = opcode;
1454 cdb[1] = flagvals;
1455 cdb[6] = groupnum;
1456 cdb[9] = control;
1457
1458 /* Transfer length */
1459 cdb[8] = (u8)(num_blocks & 0xff);
1460 cdb[7] = (u8)((num_blocks >> 8) & 0xff);
1461
1462 io_request->IoFlags = cpu_to_le16(10); /* Specify 10-byte cdb */
1463 cdb_len = 10;
1464 } else if ((cdb_len < 16) && (start_blk > 0xffffffff)) {
1465 /* Convert to 16 byte CDB for large LBA's */
1466 switch (cdb_len) {
1467 case 6:
1468 opcode = cdb[0] == READ_6 ? READ_16 : WRITE_16;
1469 control = cdb[5];
1470 break;
1471 case 10:
1472 opcode =
1473 cdb[0] == READ_10 ? READ_16 : WRITE_16;
1474 flagvals = cdb[1];
1475 groupnum = cdb[6];
1476 control = cdb[9];
1477 break;
1478 case 12:
1479 opcode =
1480 cdb[0] == READ_12 ? READ_16 : WRITE_16;
1481 flagvals = cdb[1];
1482 groupnum = cdb[10];
1483 control = cdb[11];
1484 break;
1485 }
1486
1487 memset(cdb, 0, sizeof(io_request->CDB.CDB32));
1488
1489 cdb[0] = opcode;
1490 cdb[1] = flagvals;
1491 cdb[14] = groupnum;
1492 cdb[15] = control;
1493
1494 /* Transfer length */
1495 cdb[13] = (u8)(num_blocks & 0xff);
1496 cdb[12] = (u8)((num_blocks >> 8) & 0xff);
1497 cdb[11] = (u8)((num_blocks >> 16) & 0xff);
1498 cdb[10] = (u8)((num_blocks >> 24) & 0xff);
1499
1500 io_request->IoFlags = cpu_to_le16(16); /* Specify 16-byte cdb */
1501 cdb_len = 16;
1502 }
1503
1504 /* Normal case, just load LBA here */
1505 switch (cdb_len) {
1506 case 6:
1507 {
1508 u8 val = cdb[1] & 0xE0;
1509 cdb[3] = (u8)(start_blk & 0xff);
1510 cdb[2] = (u8)((start_blk >> 8) & 0xff);
1511 cdb[1] = val | ((u8)(start_blk >> 16) & 0x1f);
1512 break;
1513 }
1514 case 10:
1515 cdb[5] = (u8)(start_blk & 0xff);
1516 cdb[4] = (u8)((start_blk >> 8) & 0xff);
1517 cdb[3] = (u8)((start_blk >> 16) & 0xff);
1518 cdb[2] = (u8)((start_blk >> 24) & 0xff);
1519 break;
1520 case 12:
1521 cdb[5] = (u8)(start_blk & 0xff);
1522 cdb[4] = (u8)((start_blk >> 8) & 0xff);
1523 cdb[3] = (u8)((start_blk >> 16) & 0xff);
1524 cdb[2] = (u8)((start_blk >> 24) & 0xff);
1525 break;
1526 case 16:
1527 cdb[9] = (u8)(start_blk & 0xff);
1528 cdb[8] = (u8)((start_blk >> 8) & 0xff);
1529 cdb[7] = (u8)((start_blk >> 16) & 0xff);
1530 cdb[6] = (u8)((start_blk >> 24) & 0xff);
1531 cdb[5] = (u8)((start_blk >> 32) & 0xff);
1532 cdb[4] = (u8)((start_blk >> 40) & 0xff);
1533 cdb[3] = (u8)((start_blk >> 48) & 0xff);
1534 cdb[2] = (u8)((start_blk >> 56) & 0xff);
1535 break;
1536 }
1537 }
1538 }
1539
1540 /**
1541 * megasas_build_ldio_fusion - Prepares IOs to devices
1542 * @instance: Adapter soft state
1543 * @scp: SCSI command
1544 * @cmd: Command to be prepared
1545 *
1546 * Prepares the io_request and chain elements (sg_frame) for IO
1547 * The IO can be for PD (Fast Path) or LD
1548 */
1549 void
1550 megasas_build_ldio_fusion(struct megasas_instance *instance,
1551 struct scsi_cmnd *scp,
1552 struct megasas_cmd_fusion *cmd)
1553 {
1554 u8 fp_possible;
1555 u32 start_lba_lo, start_lba_hi, device_id, datalength = 0;
1556 struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
1557 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
1558 struct IO_REQUEST_INFO io_info;
1559 struct fusion_context *fusion;
1560 struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
1561 u8 *raidLUN;
1562
1563 device_id = MEGASAS_DEV_INDEX(scp);
1564
1565 fusion = instance->ctrl_context;
1566
1567 io_request = cmd->io_request;
1568 io_request->RaidContext.VirtualDiskTgtId = cpu_to_le16(device_id);
1569 io_request->RaidContext.status = 0;
1570 io_request->RaidContext.exStatus = 0;
1571
1572 req_desc = (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)cmd->request_desc;
1573
1574 start_lba_lo = 0;
1575 start_lba_hi = 0;
1576 fp_possible = 0;
1577
1578 /*
1579 * 6-byte READ(0x08) or WRITE(0x0A) cdb
1580 */
1581 if (scp->cmd_len == 6) {
1582 datalength = (u32) scp->cmnd[4];
1583 start_lba_lo = ((u32) scp->cmnd[1] << 16) |
1584 ((u32) scp->cmnd[2] << 8) | (u32) scp->cmnd[3];
1585
1586 start_lba_lo &= 0x1FFFFF;
1587 }
1588
1589 /*
1590 * 10-byte READ(0x28) or WRITE(0x2A) cdb
1591 */
1592 else if (scp->cmd_len == 10) {
1593 datalength = (u32) scp->cmnd[8] |
1594 ((u32) scp->cmnd[7] << 8);
1595 start_lba_lo = ((u32) scp->cmnd[2] << 24) |
1596 ((u32) scp->cmnd[3] << 16) |
1597 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
1598 }
1599
1600 /*
1601 * 12-byte READ(0xA8) or WRITE(0xAA) cdb
1602 */
1603 else if (scp->cmd_len == 12) {
1604 datalength = ((u32) scp->cmnd[6] << 24) |
1605 ((u32) scp->cmnd[7] << 16) |
1606 ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
1607 start_lba_lo = ((u32) scp->cmnd[2] << 24) |
1608 ((u32) scp->cmnd[3] << 16) |
1609 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
1610 }
1611
1612 /*
1613 * 16-byte READ(0x88) or WRITE(0x8A) cdb
1614 */
1615 else if (scp->cmd_len == 16) {
1616 datalength = ((u32) scp->cmnd[10] << 24) |
1617 ((u32) scp->cmnd[11] << 16) |
1618 ((u32) scp->cmnd[12] << 8) | (u32) scp->cmnd[13];
1619 start_lba_lo = ((u32) scp->cmnd[6] << 24) |
1620 ((u32) scp->cmnd[7] << 16) |
1621 ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
1622
1623 start_lba_hi = ((u32) scp->cmnd[2] << 24) |
1624 ((u32) scp->cmnd[3] << 16) |
1625 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
1626 }
1627
1628 memset(&io_info, 0, sizeof(struct IO_REQUEST_INFO));
1629 io_info.ldStartBlock = ((u64)start_lba_hi << 32) | start_lba_lo;
1630 io_info.numBlocks = datalength;
1631 io_info.ldTgtId = device_id;
1632 io_request->DataLength = cpu_to_le32(scsi_bufflen(scp));
1633
1634 if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1635 io_info.isRead = 1;
1636
1637 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
1638
1639 if ((MR_TargetIdToLdGet(device_id, local_map_ptr) >=
1640 instance->fw_supported_vd_count) || (!fusion->fast_path_io)) {
1641 io_request->RaidContext.regLockFlags = 0;
1642 fp_possible = 0;
1643 } else {
1644 if (MR_BuildRaidContext(instance, &io_info,
1645 &io_request->RaidContext,
1646 local_map_ptr, &raidLUN))
1647 fp_possible = io_info.fpOkForIo;
1648 }
1649
1650 /* Use raw_smp_processor_id() for now until cmd->request->cpu is CPU
1651 id by default, not CPU group id, otherwise all MSI-X queues won't
1652 be utilized */
1653 cmd->request_desc->SCSIIO.MSIxIndex = instance->msix_vectors ?
1654 raw_smp_processor_id() % instance->msix_vectors : 0;
1655
1656 if (fp_possible) {
1657 megasas_set_pd_lba(io_request, scp->cmd_len, &io_info, scp,
1658 local_map_ptr, start_lba_lo);
1659 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
1660 cmd->request_desc->SCSIIO.RequestFlags =
1661 (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY
1662 << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1663 if (fusion->adapter_type == INVADER_SERIES) {
1664 if (io_request->RaidContext.regLockFlags ==
1665 REGION_TYPE_UNUSED)
1666 cmd->request_desc->SCSIIO.RequestFlags =
1667 (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
1668 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1669 io_request->RaidContext.Type = MPI2_TYPE_CUDA;
1670 io_request->RaidContext.nseg = 0x1;
1671 io_request->IoFlags |= cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
1672 io_request->RaidContext.regLockFlags |=
1673 (MR_RL_FLAGS_GRANT_DESTINATION_CUDA |
1674 MR_RL_FLAGS_SEQ_NUM_ENABLE);
1675 }
1676 if ((fusion->load_balance_info[device_id].loadBalanceFlag) &&
1677 (io_info.isRead)) {
1678 io_info.devHandle =
1679 get_updated_dev_handle(instance,
1680 &fusion->load_balance_info[device_id],
1681 &io_info);
1682 scp->SCp.Status |= MEGASAS_LOAD_BALANCE_FLAG;
1683 cmd->pd_r1_lb = io_info.pd_after_lb;
1684 } else
1685 scp->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG;
1686
1687 if ((raidLUN[0] == 1) &&
1688 (local_map_ptr->raidMap.devHndlInfo[io_info.pd_after_lb].validHandles > 1)) {
1689 instance->dev_handle = !(instance->dev_handle);
1690 io_info.devHandle =
1691 local_map_ptr->raidMap.devHndlInfo[io_info.pd_after_lb].devHandle[instance->dev_handle];
1692 }
1693
1694 cmd->request_desc->SCSIIO.DevHandle = io_info.devHandle;
1695 io_request->DevHandle = io_info.devHandle;
1696 /* populate the LUN field */
1697 memcpy(io_request->LUN, raidLUN, 8);
1698 } else {
1699 io_request->RaidContext.timeoutValue =
1700 cpu_to_le16(local_map_ptr->raidMap.fpPdIoTimeoutSec);
1701 cmd->request_desc->SCSIIO.RequestFlags =
1702 (MEGASAS_REQ_DESCRIPT_FLAGS_LD_IO
1703 << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1704 if (fusion->adapter_type == INVADER_SERIES) {
1705 if (io_request->RaidContext.regLockFlags ==
1706 REGION_TYPE_UNUSED)
1707 cmd->request_desc->SCSIIO.RequestFlags =
1708 (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
1709 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1710 io_request->RaidContext.Type = MPI2_TYPE_CUDA;
1711 io_request->RaidContext.regLockFlags |=
1712 (MR_RL_FLAGS_GRANT_DESTINATION_CPU0 |
1713 MR_RL_FLAGS_SEQ_NUM_ENABLE);
1714 io_request->RaidContext.nseg = 0x1;
1715 }
1716 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
1717 io_request->DevHandle = cpu_to_le16(device_id);
1718 } /* Not FP */
1719 }
1720
1721 /**
1722 * megasas_build_ld_nonrw_fusion - prepares non rw ios for virtual disk
1723 * @instance: Adapter soft state
1724 * @scp: SCSI command
1725 * @cmd: Command to be prepared
1726 *
1727 * Prepares the io_request frame for non-rw io cmds for vd.
1728 */
1729 static void megasas_build_ld_nonrw_fusion(struct megasas_instance *instance,
1730 struct scsi_cmnd *scmd, struct megasas_cmd_fusion *cmd)
1731 {
1732 u32 device_id;
1733 struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
1734 u16 pd_index = 0;
1735 struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
1736 struct fusion_context *fusion = instance->ctrl_context;
1737 u8 span, physArm;
1738 __le16 devHandle;
1739 u32 ld, arRef, pd;
1740 struct MR_LD_RAID *raid;
1741 struct RAID_CONTEXT *pRAID_Context;
1742 u8 fp_possible = 1;
1743
1744 io_request = cmd->io_request;
1745 device_id = MEGASAS_DEV_INDEX(scmd);
1746 pd_index = MEGASAS_PD_INDEX(scmd);
1747 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
1748 io_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
1749 /* get RAID_Context pointer */
1750 pRAID_Context = &io_request->RaidContext;
1751 /* Check with FW team */
1752 pRAID_Context->VirtualDiskTgtId = cpu_to_le16(device_id);
1753 pRAID_Context->regLockRowLBA = 0;
1754 pRAID_Context->regLockLength = 0;
1755
1756 if (fusion->fast_path_io && (
1757 device_id < instance->fw_supported_vd_count)) {
1758
1759 ld = MR_TargetIdToLdGet(device_id, local_map_ptr);
1760 if (ld >= instance->fw_supported_vd_count)
1761 fp_possible = 0;
1762
1763 raid = MR_LdRaidGet(ld, local_map_ptr);
1764 if (!(raid->capability.fpNonRWCapable))
1765 fp_possible = 0;
1766 } else
1767 fp_possible = 0;
1768
1769 if (!fp_possible) {
1770 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
1771 io_request->DevHandle = cpu_to_le16(device_id);
1772 io_request->LUN[1] = scmd->device->lun;
1773 pRAID_Context->timeoutValue =
1774 cpu_to_le16 (scmd->request->timeout / HZ);
1775 cmd->request_desc->SCSIIO.RequestFlags =
1776 (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
1777 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1778 } else {
1779
1780 /* set RAID context values */
1781 pRAID_Context->configSeqNum = raid->seqNum;
1782 pRAID_Context->regLockFlags = REGION_TYPE_SHARED_READ;
1783 pRAID_Context->timeoutValue = cpu_to_le16(raid->fpIoTimeoutForLd);
1784
1785 /* get the DevHandle for the PD (since this is
1786 fpNonRWCapable, this is a single disk RAID0) */
1787 span = physArm = 0;
1788 arRef = MR_LdSpanArrayGet(ld, span, local_map_ptr);
1789 pd = MR_ArPdGet(arRef, physArm, local_map_ptr);
1790 devHandle = MR_PdDevHandleGet(pd, local_map_ptr);
1791
1792 /* build request descriptor */
1793 cmd->request_desc->SCSIIO.RequestFlags =
1794 (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<
1795 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1796 cmd->request_desc->SCSIIO.DevHandle = devHandle;
1797
1798 /* populate the LUN field */
1799 memcpy(io_request->LUN, raid->LUN, 8);
1800
1801 /* build the raidScsiIO structure */
1802 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
1803 io_request->DevHandle = devHandle;
1804 }
1805 }
1806
1807 /**
1808 * megasas_build_syspd_fusion - prepares rw/non-rw ios for syspd
1809 * @instance: Adapter soft state
1810 * @scp: SCSI command
1811 * @cmd: Command to be prepared
1812 * @fp_possible: parameter to detect fast path or firmware path io.
1813 *
1814 * Prepares the io_request frame for rw/non-rw io cmds for syspds
1815 */
1816 static void
1817 megasas_build_syspd_fusion(struct megasas_instance *instance,
1818 struct scsi_cmnd *scmd, struct megasas_cmd_fusion *cmd, u8 fp_possible)
1819 {
1820 u32 device_id;
1821 struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
1822 u16 pd_index = 0;
1823 u16 os_timeout_value;
1824 u16 timeout_limit;
1825 struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
1826 struct RAID_CONTEXT *pRAID_Context;
1827 struct MR_PD_CFG_SEQ_NUM_SYNC *pd_sync;
1828 struct fusion_context *fusion = instance->ctrl_context;
1829 pd_sync = (void *)fusion->pd_seq_sync[(instance->pd_seq_map_id - 1) & 1];
1830
1831 device_id = MEGASAS_DEV_INDEX(scmd);
1832 pd_index = MEGASAS_PD_INDEX(scmd);
1833 os_timeout_value = scmd->request->timeout / HZ;
1834
1835 io_request = cmd->io_request;
1836 /* get RAID_Context pointer */
1837 pRAID_Context = &io_request->RaidContext;
1838 pRAID_Context->regLockFlags = 0;
1839 pRAID_Context->regLockRowLBA = 0;
1840 pRAID_Context->regLockLength = 0;
1841 io_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
1842 io_request->LUN[1] = scmd->device->lun;
1843 pRAID_Context->RAIDFlags = MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD
1844 << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;
1845
1846 /* If FW supports PD sequence number */
1847 if (instance->use_seqnum_jbod_fp &&
1848 instance->pd_list[pd_index].driveType == TYPE_DISK) {
1849 /* TgtId must be incremented by 255 as jbod seq number is index
1850 * below raid map
1851 */
1852 pRAID_Context->VirtualDiskTgtId =
1853 cpu_to_le16(device_id + (MAX_PHYSICAL_DEVICES - 1));
1854 pRAID_Context->configSeqNum = pd_sync->seq[pd_index].seqNum;
1855 io_request->DevHandle = pd_sync->seq[pd_index].devHandle;
1856 pRAID_Context->regLockFlags |=
1857 (MR_RL_FLAGS_SEQ_NUM_ENABLE|MR_RL_FLAGS_GRANT_DESTINATION_CUDA);
1858 } else if (fusion->fast_path_io) {
1859 pRAID_Context->VirtualDiskTgtId = cpu_to_le16(device_id);
1860 pRAID_Context->configSeqNum = 0;
1861 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
1862 io_request->DevHandle =
1863 local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
1864 } else {
1865 /* Want to send all IO via FW path */
1866 pRAID_Context->VirtualDiskTgtId = cpu_to_le16(device_id);
1867 pRAID_Context->configSeqNum = 0;
1868 io_request->DevHandle = cpu_to_le16(0xFFFF);
1869 }
1870
1871 cmd->request_desc->SCSIIO.DevHandle = io_request->DevHandle;
1872 cmd->request_desc->SCSIIO.MSIxIndex =
1873 instance->msix_vectors ?
1874 (raw_smp_processor_id() % instance->msix_vectors) : 0;
1875
1876
1877 if (!fp_possible) {
1878 /* system pd firmware path */
1879 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
1880 cmd->request_desc->SCSIIO.RequestFlags =
1881 (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
1882 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1883 pRAID_Context->timeoutValue = cpu_to_le16(os_timeout_value);
1884 pRAID_Context->VirtualDiskTgtId = cpu_to_le16(device_id);
1885 } else {
1886 /* system pd Fast Path */
1887 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
1888 timeout_limit = (scmd->device->type == TYPE_DISK) ?
1889 255 : 0xFFFF;
1890 pRAID_Context->timeoutValue =
1891 cpu_to_le16((os_timeout_value > timeout_limit) ?
1892 timeout_limit : os_timeout_value);
1893 if (fusion->adapter_type == INVADER_SERIES) {
1894 pRAID_Context->Type = MPI2_TYPE_CUDA;
1895 pRAID_Context->nseg = 0x1;
1896 io_request->IoFlags |=
1897 cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
1898 }
1899 cmd->request_desc->SCSIIO.RequestFlags =
1900 (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<
1901 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1902 }
1903 }
1904
1905 /**
1906 * megasas_build_io_fusion - Prepares IOs to devices
1907 * @instance: Adapter soft state
1908 * @scp: SCSI command
1909 * @cmd: Command to be prepared
1910 *
1911 * Invokes helper functions to prepare request frames
1912 * and sets flags appropriate for IO/Non-IO cmd
1913 */
1914 int
1915 megasas_build_io_fusion(struct megasas_instance *instance,
1916 struct scsi_cmnd *scp,
1917 struct megasas_cmd_fusion *cmd)
1918 {
1919 u16 sge_count;
1920 u8 cmd_type;
1921 struct MPI2_RAID_SCSI_IO_REQUEST *io_request = cmd->io_request;
1922
1923 /* Zero out some fields so they don't get reused */
1924 memset(io_request->LUN, 0x0, 8);
1925 io_request->CDB.EEDP32.PrimaryReferenceTag = 0;
1926 io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0;
1927 io_request->EEDPFlags = 0;
1928 io_request->Control = 0;
1929 io_request->EEDPBlockSize = 0;
1930 io_request->ChainOffset = 0;
1931 io_request->RaidContext.RAIDFlags = 0;
1932 io_request->RaidContext.Type = 0;
1933 io_request->RaidContext.nseg = 0;
1934
1935 memcpy(io_request->CDB.CDB32, scp->cmnd, scp->cmd_len);
1936 /*
1937 * Just the CDB length,rest of the Flags are zero
1938 * This will be modified for FP in build_ldio_fusion
1939 */
1940 io_request->IoFlags = cpu_to_le16(scp->cmd_len);
1941
1942 switch (cmd_type = megasas_cmd_type(scp)) {
1943 case READ_WRITE_LDIO:
1944 megasas_build_ldio_fusion(instance, scp, cmd);
1945 break;
1946 case NON_READ_WRITE_LDIO:
1947 megasas_build_ld_nonrw_fusion(instance, scp, cmd);
1948 break;
1949 case READ_WRITE_SYSPDIO:
1950 case NON_READ_WRITE_SYSPDIO:
1951 if (instance->secure_jbod_support &&
1952 (cmd_type == NON_READ_WRITE_SYSPDIO))
1953 megasas_build_syspd_fusion(instance, scp, cmd, 0);
1954 else
1955 megasas_build_syspd_fusion(instance, scp, cmd, 1);
1956 break;
1957 default:
1958 break;
1959 }
1960
1961 /*
1962 * Construct SGL
1963 */
1964
1965 sge_count =
1966 megasas_make_sgl_fusion(instance, scp,
1967 (struct MPI25_IEEE_SGE_CHAIN64 *)
1968 &io_request->SGL, cmd);
1969
1970 if (sge_count > instance->max_num_sge) {
1971 dev_err(&instance->pdev->dev, "Error. sge_count (0x%x) exceeds "
1972 "max (0x%x) allowed\n", sge_count,
1973 instance->max_num_sge);
1974 return 1;
1975 }
1976
1977 /* numSGE store lower 8 bit of sge_count.
1978 * numSGEExt store higher 8 bit of sge_count
1979 */
1980 io_request->RaidContext.numSGE = sge_count;
1981 io_request->RaidContext.numSGEExt = (u8)(sge_count >> 8);
1982
1983 io_request->SGLFlags = cpu_to_le16(MPI2_SGE_FLAGS_64_BIT_ADDRESSING);
1984
1985 if (scp->sc_data_direction == PCI_DMA_TODEVICE)
1986 io_request->Control |= cpu_to_le32(MPI2_SCSIIO_CONTROL_WRITE);
1987 else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1988 io_request->Control |= cpu_to_le32(MPI2_SCSIIO_CONTROL_READ);
1989
1990 io_request->SGLOffset0 =
1991 offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL) / 4;
1992
1993 io_request->SenseBufferLowAddress = cpu_to_le32(cmd->sense_phys_addr);
1994 io_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
1995
1996 cmd->scmd = scp;
1997 scp->SCp.ptr = (char *)cmd;
1998
1999 return 0;
2000 }
2001
2002 union MEGASAS_REQUEST_DESCRIPTOR_UNION *
2003 megasas_get_request_descriptor(struct megasas_instance *instance, u16 index)
2004 {
2005 u8 *p;
2006 struct fusion_context *fusion;
2007
2008 if (index >= instance->max_fw_cmds) {
2009 dev_err(&instance->pdev->dev, "Invalid SMID (0x%x)request for "
2010 "descriptor for scsi%d\n", index,
2011 instance->host->host_no);
2012 return NULL;
2013 }
2014 fusion = instance->ctrl_context;
2015 p = fusion->req_frames_desc
2016 +sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) *index;
2017
2018 return (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)p;
2019 }
2020
2021 /**
2022 * megasas_build_and_issue_cmd_fusion -Main routine for building and
2023 * issuing non IOCTL cmd
2024 * @instance: Adapter soft state
2025 * @scmd: pointer to scsi cmd from OS
2026 */
2027 static u32
2028 megasas_build_and_issue_cmd_fusion(struct megasas_instance *instance,
2029 struct scsi_cmnd *scmd)
2030 {
2031 struct megasas_cmd_fusion *cmd;
2032 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2033 u32 index;
2034 struct fusion_context *fusion;
2035
2036 fusion = instance->ctrl_context;
2037
2038 cmd = megasas_get_cmd_fusion(instance, scmd->request->tag);
2039
2040 index = cmd->index;
2041
2042 req_desc = megasas_get_request_descriptor(instance, index-1);
2043 if (!req_desc)
2044 return 1;
2045
2046 req_desc->Words = 0;
2047 cmd->request_desc = req_desc;
2048
2049 if (megasas_build_io_fusion(instance, scmd, cmd)) {
2050 megasas_return_cmd_fusion(instance, cmd);
2051 dev_err(&instance->pdev->dev, "Error building command\n");
2052 cmd->request_desc = NULL;
2053 return 1;
2054 }
2055
2056 req_desc = cmd->request_desc;
2057 req_desc->SCSIIO.SMID = cpu_to_le16(index);
2058
2059 if (cmd->io_request->ChainOffset != 0 &&
2060 cmd->io_request->ChainOffset != 0xF)
2061 dev_err(&instance->pdev->dev, "The chain offset value is not "
2062 "correct : %x\n", cmd->io_request->ChainOffset);
2063
2064 /*
2065 * Issue the command to the FW
2066 */
2067 atomic_inc(&instance->fw_outstanding);
2068
2069 megasas_fire_cmd_fusion(instance, req_desc);
2070
2071 return 0;
2072 }
2073
2074 /**
2075 * complete_cmd_fusion - Completes command
2076 * @instance: Adapter soft state
2077 * Completes all commands that is in reply descriptor queue
2078 */
2079 int
2080 complete_cmd_fusion(struct megasas_instance *instance, u32 MSIxIndex)
2081 {
2082 union MPI2_REPLY_DESCRIPTORS_UNION *desc;
2083 struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *reply_desc;
2084 struct MPI2_RAID_SCSI_IO_REQUEST *scsi_io_req;
2085 struct fusion_context *fusion;
2086 struct megasas_cmd *cmd_mfi;
2087 struct megasas_cmd_fusion *cmd_fusion;
2088 u16 smid, num_completed;
2089 u8 reply_descript_type;
2090 u32 status, extStatus, device_id;
2091 union desc_value d_val;
2092 struct LD_LOAD_BALANCE_INFO *lbinfo;
2093 int threshold_reply_count = 0;
2094 struct scsi_cmnd *scmd_local = NULL;
2095
2096 fusion = instance->ctrl_context;
2097
2098 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
2099 return IRQ_HANDLED;
2100
2101 desc = fusion->reply_frames_desc;
2102 desc += ((MSIxIndex * fusion->reply_alloc_sz)/
2103 sizeof(union MPI2_REPLY_DESCRIPTORS_UNION)) +
2104 fusion->last_reply_idx[MSIxIndex];
2105
2106 reply_desc = (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc;
2107
2108 d_val.word = desc->Words;
2109
2110 reply_descript_type = reply_desc->ReplyFlags &
2111 MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
2112
2113 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
2114 return IRQ_NONE;
2115
2116 num_completed = 0;
2117
2118 while (d_val.u.low != cpu_to_le32(UINT_MAX) &&
2119 d_val.u.high != cpu_to_le32(UINT_MAX)) {
2120 smid = le16_to_cpu(reply_desc->SMID);
2121
2122 cmd_fusion = fusion->cmd_list[smid - 1];
2123
2124 scsi_io_req =
2125 (struct MPI2_RAID_SCSI_IO_REQUEST *)
2126 cmd_fusion->io_request;
2127
2128 if (cmd_fusion->scmd)
2129 cmd_fusion->scmd->SCp.ptr = NULL;
2130
2131 scmd_local = cmd_fusion->scmd;
2132 status = scsi_io_req->RaidContext.status;
2133 extStatus = scsi_io_req->RaidContext.exStatus;
2134
2135 switch (scsi_io_req->Function) {
2136 case MPI2_FUNCTION_SCSI_IO_REQUEST: /*Fast Path IO.*/
2137 /* Update load balancing info */
2138 device_id = MEGASAS_DEV_INDEX(scmd_local);
2139 lbinfo = &fusion->load_balance_info[device_id];
2140 if (cmd_fusion->scmd->SCp.Status &
2141 MEGASAS_LOAD_BALANCE_FLAG) {
2142 atomic_dec(&lbinfo->scsi_pending_cmds[cmd_fusion->pd_r1_lb]);
2143 cmd_fusion->scmd->SCp.Status &=
2144 ~MEGASAS_LOAD_BALANCE_FLAG;
2145 }
2146 if (reply_descript_type ==
2147 MPI2_RPY_DESCRIPT_FLAGS_SCSI_IO_SUCCESS) {
2148 if (megasas_dbg_lvl == 5)
2149 dev_err(&instance->pdev->dev, "\nFAST Path "
2150 "IO Success\n");
2151 }
2152 /* Fall thru and complete IO */
2153 case MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST: /* LD-IO Path */
2154 /* Map the FW Cmd Status */
2155 map_cmd_status(cmd_fusion, status, extStatus);
2156 scsi_io_req->RaidContext.status = 0;
2157 scsi_io_req->RaidContext.exStatus = 0;
2158 megasas_return_cmd_fusion(instance, cmd_fusion);
2159 scsi_dma_unmap(scmd_local);
2160 scmd_local->scsi_done(scmd_local);
2161 atomic_dec(&instance->fw_outstanding);
2162
2163 break;
2164 case MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST: /*MFI command */
2165 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
2166
2167 /* Poll mode. Dummy free.
2168 * In case of Interrupt mode, caller has reverse check.
2169 */
2170 if (cmd_mfi->flags & DRV_DCMD_POLLED_MODE) {
2171 cmd_mfi->flags &= ~DRV_DCMD_POLLED_MODE;
2172 megasas_return_cmd(instance, cmd_mfi);
2173 } else
2174 megasas_complete_cmd(instance, cmd_mfi, DID_OK);
2175 break;
2176 }
2177
2178 fusion->last_reply_idx[MSIxIndex]++;
2179 if (fusion->last_reply_idx[MSIxIndex] >=
2180 fusion->reply_q_depth)
2181 fusion->last_reply_idx[MSIxIndex] = 0;
2182
2183 desc->Words = cpu_to_le64(ULLONG_MAX);
2184 num_completed++;
2185 threshold_reply_count++;
2186
2187 /* Get the next reply descriptor */
2188 if (!fusion->last_reply_idx[MSIxIndex])
2189 desc = fusion->reply_frames_desc +
2190 ((MSIxIndex * fusion->reply_alloc_sz)/
2191 sizeof(union MPI2_REPLY_DESCRIPTORS_UNION));
2192 else
2193 desc++;
2194
2195 reply_desc =
2196 (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc;
2197
2198 d_val.word = desc->Words;
2199
2200 reply_descript_type = reply_desc->ReplyFlags &
2201 MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
2202
2203 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
2204 break;
2205 /*
2206 * Write to reply post host index register after completing threshold
2207 * number of reply counts and still there are more replies in reply queue
2208 * pending to be completed
2209 */
2210 if (threshold_reply_count >= THRESHOLD_REPLY_COUNT) {
2211 if (fusion->adapter_type == INVADER_SERIES)
2212 writel(((MSIxIndex & 0x7) << 24) |
2213 fusion->last_reply_idx[MSIxIndex],
2214 instance->reply_post_host_index_addr[MSIxIndex/8]);
2215 else
2216 writel((MSIxIndex << 24) |
2217 fusion->last_reply_idx[MSIxIndex],
2218 instance->reply_post_host_index_addr[0]);
2219 threshold_reply_count = 0;
2220 }
2221 }
2222
2223 if (!num_completed)
2224 return IRQ_NONE;
2225
2226 wmb();
2227 if (fusion->adapter_type == INVADER_SERIES)
2228 writel(((MSIxIndex & 0x7) << 24) |
2229 fusion->last_reply_idx[MSIxIndex],
2230 instance->reply_post_host_index_addr[MSIxIndex/8]);
2231 else
2232 writel((MSIxIndex << 24) |
2233 fusion->last_reply_idx[MSIxIndex],
2234 instance->reply_post_host_index_addr[0]);
2235 megasas_check_and_restore_queue_depth(instance);
2236 return IRQ_HANDLED;
2237 }
2238
2239 /**
2240 * megasas_complete_cmd_dpc_fusion - Completes command
2241 * @instance: Adapter soft state
2242 *
2243 * Tasklet to complete cmds
2244 */
2245 void
2246 megasas_complete_cmd_dpc_fusion(unsigned long instance_addr)
2247 {
2248 struct megasas_instance *instance =
2249 (struct megasas_instance *)instance_addr;
2250 unsigned long flags;
2251 u32 count, MSIxIndex;
2252
2253 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
2254
2255 /* If we have already declared adapter dead, donot complete cmds */
2256 spin_lock_irqsave(&instance->hba_lock, flags);
2257 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
2258 spin_unlock_irqrestore(&instance->hba_lock, flags);
2259 return;
2260 }
2261 spin_unlock_irqrestore(&instance->hba_lock, flags);
2262
2263 for (MSIxIndex = 0 ; MSIxIndex < count; MSIxIndex++)
2264 complete_cmd_fusion(instance, MSIxIndex);
2265 }
2266
2267 /**
2268 * megasas_isr_fusion - isr entry point
2269 */
2270 irqreturn_t megasas_isr_fusion(int irq, void *devp)
2271 {
2272 struct megasas_irq_context *irq_context = devp;
2273 struct megasas_instance *instance = irq_context->instance;
2274 u32 mfiStatus, fw_state, dma_state;
2275
2276 if (instance->mask_interrupts)
2277 return IRQ_NONE;
2278
2279 if (!instance->msix_vectors) {
2280 mfiStatus = instance->instancet->clear_intr(instance->reg_set);
2281 if (!mfiStatus)
2282 return IRQ_NONE;
2283 }
2284
2285 /* If we are resetting, bail */
2286 if (test_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags)) {
2287 instance->instancet->clear_intr(instance->reg_set);
2288 return IRQ_HANDLED;
2289 }
2290
2291 if (!complete_cmd_fusion(instance, irq_context->MSIxIndex)) {
2292 instance->instancet->clear_intr(instance->reg_set);
2293 /* If we didn't complete any commands, check for FW fault */
2294 fw_state = instance->instancet->read_fw_status_reg(
2295 instance->reg_set) & MFI_STATE_MASK;
2296 dma_state = instance->instancet->read_fw_status_reg
2297 (instance->reg_set) & MFI_STATE_DMADONE;
2298 if (instance->crash_dump_drv_support &&
2299 instance->crash_dump_app_support) {
2300 /* Start collecting crash, if DMA bit is done */
2301 if ((fw_state == MFI_STATE_FAULT) && dma_state)
2302 schedule_work(&instance->crash_init);
2303 else if (fw_state == MFI_STATE_FAULT)
2304 schedule_work(&instance->work_init);
2305 } else if (fw_state == MFI_STATE_FAULT) {
2306 dev_warn(&instance->pdev->dev, "Iop2SysDoorbellInt"
2307 "for scsi%d\n", instance->host->host_no);
2308 schedule_work(&instance->work_init);
2309 }
2310 }
2311
2312 return IRQ_HANDLED;
2313 }
2314
2315 /**
2316 * build_mpt_mfi_pass_thru - builds a cmd fo MFI Pass thru
2317 * @instance: Adapter soft state
2318 * mfi_cmd: megasas_cmd pointer
2319 *
2320 */
2321 u8
2322 build_mpt_mfi_pass_thru(struct megasas_instance *instance,
2323 struct megasas_cmd *mfi_cmd)
2324 {
2325 struct MPI25_IEEE_SGE_CHAIN64 *mpi25_ieee_chain;
2326 struct MPI2_RAID_SCSI_IO_REQUEST *io_req;
2327 struct megasas_cmd_fusion *cmd;
2328 struct fusion_context *fusion;
2329 struct megasas_header *frame_hdr = &mfi_cmd->frame->hdr;
2330
2331 fusion = instance->ctrl_context;
2332
2333 cmd = megasas_get_cmd_fusion(instance,
2334 instance->max_scsi_cmds + mfi_cmd->index);
2335
2336 /* Save the smid. To be used for returning the cmd */
2337 mfi_cmd->context.smid = cmd->index;
2338
2339 /*
2340 * For cmds where the flag is set, store the flag and check
2341 * on completion. For cmds with this flag, don't call
2342 * megasas_complete_cmd
2343 */
2344
2345 if (frame_hdr->flags & cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE))
2346 mfi_cmd->flags |= DRV_DCMD_POLLED_MODE;
2347
2348 io_req = cmd->io_request;
2349
2350 if (fusion->adapter_type == INVADER_SERIES) {
2351 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr_end =
2352 (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL;
2353 sgl_ptr_end += fusion->max_sge_in_main_msg - 1;
2354 sgl_ptr_end->Flags = 0;
2355 }
2356
2357 mpi25_ieee_chain =
2358 (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL.IeeeChain;
2359
2360 io_req->Function = MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST;
2361 io_req->SGLOffset0 = offsetof(struct MPI2_RAID_SCSI_IO_REQUEST,
2362 SGL) / 4;
2363 io_req->ChainOffset = fusion->chain_offset_mfi_pthru;
2364
2365 mpi25_ieee_chain->Address = cpu_to_le64(mfi_cmd->frame_phys_addr);
2366
2367 mpi25_ieee_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT |
2368 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR;
2369
2370 mpi25_ieee_chain->Length = cpu_to_le32(instance->max_chain_frame_sz);
2371
2372 return 0;
2373 }
2374
2375 /**
2376 * build_mpt_cmd - Calls helper function to build a cmd MFI Pass thru cmd
2377 * @instance: Adapter soft state
2378 * @cmd: mfi cmd to build
2379 *
2380 */
2381 union MEGASAS_REQUEST_DESCRIPTOR_UNION *
2382 build_mpt_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
2383 {
2384 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2385 u16 index;
2386
2387 if (build_mpt_mfi_pass_thru(instance, cmd)) {
2388 dev_err(&instance->pdev->dev, "Couldn't build MFI pass thru cmd\n");
2389 return NULL;
2390 }
2391
2392 index = cmd->context.smid;
2393
2394 req_desc = megasas_get_request_descriptor(instance, index - 1);
2395
2396 if (!req_desc)
2397 return NULL;
2398
2399 req_desc->Words = 0;
2400 req_desc->SCSIIO.RequestFlags = (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
2401 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2402
2403 req_desc->SCSIIO.SMID = cpu_to_le16(index);
2404
2405 return req_desc;
2406 }
2407
2408 /**
2409 * megasas_issue_dcmd_fusion - Issues a MFI Pass thru cmd
2410 * @instance: Adapter soft state
2411 * @cmd: mfi cmd pointer
2412 *
2413 */
2414 void
2415 megasas_issue_dcmd_fusion(struct megasas_instance *instance,
2416 struct megasas_cmd *cmd)
2417 {
2418 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2419
2420 req_desc = build_mpt_cmd(instance, cmd);
2421 if (!req_desc) {
2422 dev_err(&instance->pdev->dev, "Couldn't issue MFI pass thru cmd\n");
2423 return;
2424 }
2425 megasas_fire_cmd_fusion(instance, req_desc);
2426 }
2427
2428 /**
2429 * megasas_release_fusion - Reverses the FW initialization
2430 * @instance: Adapter soft state
2431 */
2432 void
2433 megasas_release_fusion(struct megasas_instance *instance)
2434 {
2435 megasas_free_cmds(instance);
2436 megasas_free_cmds_fusion(instance);
2437
2438 iounmap(instance->reg_set);
2439
2440 pci_release_selected_regions(instance->pdev, instance->bar);
2441 }
2442
2443 /**
2444 * megasas_read_fw_status_reg_fusion - returns the current FW status value
2445 * @regs: MFI register set
2446 */
2447 static u32
2448 megasas_read_fw_status_reg_fusion(struct megasas_register_set __iomem *regs)
2449 {
2450 return readl(&(regs)->outbound_scratch_pad);
2451 }
2452
2453 /**
2454 * megasas_alloc_host_crash_buffer - Host buffers for Crash dump collection from Firmware
2455 * @instance: Controller's soft instance
2456 * return: Number of allocated host crash buffers
2457 */
2458 static void
2459 megasas_alloc_host_crash_buffer(struct megasas_instance *instance)
2460 {
2461 unsigned int i;
2462
2463 instance->crash_buf_pages = get_order(CRASH_DMA_BUF_SIZE);
2464 for (i = 0; i < MAX_CRASH_DUMP_SIZE; i++) {
2465 instance->crash_buf[i] = (void *)__get_free_pages(GFP_KERNEL,
2466 instance->crash_buf_pages);
2467 if (!instance->crash_buf[i]) {
2468 dev_info(&instance->pdev->dev, "Firmware crash dump "
2469 "memory allocation failed at index %d\n", i);
2470 break;
2471 }
2472 memset(instance->crash_buf[i], 0,
2473 ((1 << PAGE_SHIFT) << instance->crash_buf_pages));
2474 }
2475 instance->drv_buf_alloc = i;
2476 }
2477
2478 /**
2479 * megasas_free_host_crash_buffer - Host buffers for Crash dump collection from Firmware
2480 * @instance: Controller's soft instance
2481 */
2482 void
2483 megasas_free_host_crash_buffer(struct megasas_instance *instance)
2484 {
2485 unsigned int i
2486 ;
2487 for (i = 0; i < instance->drv_buf_alloc; i++) {
2488 if (instance->crash_buf[i])
2489 free_pages((ulong)instance->crash_buf[i],
2490 instance->crash_buf_pages);
2491 }
2492 instance->drv_buf_index = 0;
2493 instance->drv_buf_alloc = 0;
2494 instance->fw_crash_state = UNAVAILABLE;
2495 instance->fw_crash_buffer_size = 0;
2496 }
2497
2498 /**
2499 * megasas_adp_reset_fusion - For controller reset
2500 * @regs: MFI register set
2501 */
2502 static int
2503 megasas_adp_reset_fusion(struct megasas_instance *instance,
2504 struct megasas_register_set __iomem *regs)
2505 {
2506 u32 host_diag, abs_state, retry;
2507
2508 /* Now try to reset the chip */
2509 writel(MPI2_WRSEQ_FLUSH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
2510 writel(MPI2_WRSEQ_1ST_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
2511 writel(MPI2_WRSEQ_2ND_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
2512 writel(MPI2_WRSEQ_3RD_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
2513 writel(MPI2_WRSEQ_4TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
2514 writel(MPI2_WRSEQ_5TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
2515 writel(MPI2_WRSEQ_6TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
2516
2517 /* Check that the diag write enable (DRWE) bit is on */
2518 host_diag = readl(&instance->reg_set->fusion_host_diag);
2519 retry = 0;
2520 while (!(host_diag & HOST_DIAG_WRITE_ENABLE)) {
2521 msleep(100);
2522 host_diag = readl(&instance->reg_set->fusion_host_diag);
2523 if (retry++ == 100) {
2524 dev_warn(&instance->pdev->dev,
2525 "Host diag unlock failed from %s %d\n",
2526 __func__, __LINE__);
2527 break;
2528 }
2529 }
2530 if (!(host_diag & HOST_DIAG_WRITE_ENABLE))
2531 return -1;
2532
2533 /* Send chip reset command */
2534 writel(host_diag | HOST_DIAG_RESET_ADAPTER,
2535 &instance->reg_set->fusion_host_diag);
2536 msleep(3000);
2537
2538 /* Make sure reset adapter bit is cleared */
2539 host_diag = readl(&instance->reg_set->fusion_host_diag);
2540 retry = 0;
2541 while (host_diag & HOST_DIAG_RESET_ADAPTER) {
2542 msleep(100);
2543 host_diag = readl(&instance->reg_set->fusion_host_diag);
2544 if (retry++ == 1000) {
2545 dev_warn(&instance->pdev->dev,
2546 "Diag reset adapter never cleared %s %d\n",
2547 __func__, __LINE__);
2548 break;
2549 }
2550 }
2551 if (host_diag & HOST_DIAG_RESET_ADAPTER)
2552 return -1;
2553
2554 abs_state = instance->instancet->read_fw_status_reg(instance->reg_set)
2555 & MFI_STATE_MASK;
2556 retry = 0;
2557
2558 while ((abs_state <= MFI_STATE_FW_INIT) && (retry++ < 1000)) {
2559 msleep(100);
2560 abs_state = instance->instancet->
2561 read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
2562 }
2563 if (abs_state <= MFI_STATE_FW_INIT) {
2564 dev_warn(&instance->pdev->dev,
2565 "fw state < MFI_STATE_FW_INIT, state = 0x%x %s %d\n",
2566 abs_state, __func__, __LINE__);
2567 return -1;
2568 }
2569
2570 return 0;
2571 }
2572
2573 /**
2574 * megasas_check_reset_fusion - For controller reset check
2575 * @regs: MFI register set
2576 */
2577 static int
2578 megasas_check_reset_fusion(struct megasas_instance *instance,
2579 struct megasas_register_set __iomem *regs)
2580 {
2581 return 0;
2582 }
2583
2584 /* This function waits for outstanding commands on fusion to complete */
2585 int megasas_wait_for_outstanding_fusion(struct megasas_instance *instance,
2586 int iotimeout, int *convert)
2587 {
2588 int i, outstanding, retval = 0, hb_seconds_missed = 0;
2589 u32 fw_state;
2590
2591 for (i = 0; i < resetwaittime; i++) {
2592 /* Check if firmware is in fault state */
2593 fw_state = instance->instancet->read_fw_status_reg(
2594 instance->reg_set) & MFI_STATE_MASK;
2595 if (fw_state == MFI_STATE_FAULT) {
2596 dev_warn(&instance->pdev->dev, "Found FW in FAULT state,"
2597 " will reset adapter scsi%d.\n",
2598 instance->host->host_no);
2599 retval = 1;
2600 goto out;
2601 }
2602 /* If SR-IOV VF mode & heartbeat timeout, don't wait */
2603 if (instance->requestorId && !iotimeout) {
2604 retval = 1;
2605 goto out;
2606 }
2607
2608 /* If SR-IOV VF mode & I/O timeout, check for HB timeout */
2609 if (instance->requestorId && iotimeout) {
2610 if (instance->hb_host_mem->HB.fwCounter !=
2611 instance->hb_host_mem->HB.driverCounter) {
2612 instance->hb_host_mem->HB.driverCounter =
2613 instance->hb_host_mem->HB.fwCounter;
2614 hb_seconds_missed = 0;
2615 } else {
2616 hb_seconds_missed++;
2617 if (hb_seconds_missed ==
2618 (MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF/HZ)) {
2619 dev_warn(&instance->pdev->dev, "SR-IOV:"
2620 " Heartbeat never completed "
2621 " while polling during I/O "
2622 " timeout handling for "
2623 "scsi%d.\n",
2624 instance->host->host_no);
2625 *convert = 1;
2626 retval = 1;
2627 goto out;
2628 }
2629 }
2630 }
2631
2632 outstanding = atomic_read(&instance->fw_outstanding);
2633 if (!outstanding)
2634 goto out;
2635
2636 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
2637 dev_notice(&instance->pdev->dev, "[%2d]waiting for %d "
2638 "commands to complete for scsi%d\n", i,
2639 outstanding, instance->host->host_no);
2640 megasas_complete_cmd_dpc_fusion(
2641 (unsigned long)instance);
2642 }
2643 msleep(1000);
2644 }
2645
2646 if (atomic_read(&instance->fw_outstanding)) {
2647 dev_err(&instance->pdev->dev, "pending commands remain after waiting, "
2648 "will reset adapter scsi%d.\n",
2649 instance->host->host_no);
2650 retval = 1;
2651 }
2652 out:
2653 return retval;
2654 }
2655
2656 void megasas_reset_reply_desc(struct megasas_instance *instance)
2657 {
2658 int i, count;
2659 struct fusion_context *fusion;
2660 union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc;
2661
2662 fusion = instance->ctrl_context;
2663 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
2664 for (i = 0 ; i < count ; i++)
2665 fusion->last_reply_idx[i] = 0;
2666 reply_desc = fusion->reply_frames_desc;
2667 for (i = 0 ; i < fusion->reply_q_depth * count; i++, reply_desc++)
2668 reply_desc->Words = cpu_to_le64(ULLONG_MAX);
2669 }
2670
2671 /*
2672 * megasas_refire_mgmt_cmd : Re-fire management commands
2673 * @instance: Controller's soft instance
2674 */
2675 void megasas_refire_mgmt_cmd(struct megasas_instance *instance)
2676 {
2677 int j;
2678 struct megasas_cmd_fusion *cmd_fusion;
2679 struct fusion_context *fusion;
2680 struct megasas_cmd *cmd_mfi;
2681 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2682 u16 smid;
2683
2684 fusion = instance->ctrl_context;
2685
2686 /* Re-fire management commands.
2687 * Do not traverse complet MPT frame pool. Start from max_scsi_cmds.
2688 */
2689 for (j = instance->max_scsi_cmds ; j < instance->max_fw_cmds; j++) {
2690 cmd_fusion = fusion->cmd_list[j];
2691 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
2692 smid = le16_to_cpu(cmd_mfi->context.smid);
2693
2694 if (!smid)
2695 continue;
2696 req_desc = megasas_get_request_descriptor
2697 (instance, smid - 1);
2698 if (req_desc && ((cmd_mfi->frame->dcmd.opcode !=
2699 cpu_to_le32(MR_DCMD_LD_MAP_GET_INFO)) &&
2700 (cmd_mfi->frame->dcmd.opcode !=
2701 cpu_to_le32(MR_DCMD_SYSTEM_PD_MAP_GET_INFO))))
2702 megasas_fire_cmd_fusion(instance, req_desc);
2703 else
2704 megasas_return_cmd(instance, cmd_mfi);
2705 }
2706 }
2707
2708 /* Check for a second path that is currently UP */
2709 int megasas_check_mpio_paths(struct megasas_instance *instance,
2710 struct scsi_cmnd *scmd)
2711 {
2712 int i, j, retval = (DID_RESET << 16);
2713
2714 if (instance->mpio && instance->requestorId) {
2715 for (i = 0 ; i < MAX_MGMT_ADAPTERS ; i++)
2716 for (j = 0 ; j < MAX_LOGICAL_DRIVES; j++)
2717 if (megasas_mgmt_info.instance[i] &&
2718 (megasas_mgmt_info.instance[i] != instance) &&
2719 megasas_mgmt_info.instance[i]->mpio &&
2720 megasas_mgmt_info.instance[i]->requestorId
2721 &&
2722 (megasas_mgmt_info.instance[i]->ld_ids[j]
2723 == scmd->device->id)) {
2724 retval = (DID_NO_CONNECT << 16);
2725 goto out;
2726 }
2727 }
2728 out:
2729 return retval;
2730 }
2731
2732 /* Core fusion reset function */
2733 int megasas_reset_fusion(struct Scsi_Host *shost, int iotimeout)
2734 {
2735 int retval = SUCCESS, i, convert = 0;
2736 struct megasas_instance *instance;
2737 struct megasas_cmd_fusion *cmd_fusion;
2738 struct fusion_context *fusion;
2739 u32 abs_state, status_reg, reset_adapter;
2740 u32 io_timeout_in_crash_mode = 0;
2741 struct scsi_cmnd *scmd_local = NULL;
2742
2743 instance = (struct megasas_instance *)shost->hostdata;
2744 fusion = instance->ctrl_context;
2745
2746 mutex_lock(&instance->reset_mutex);
2747
2748 if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
2749 dev_warn(&instance->pdev->dev, "Hardware critical error, "
2750 "returning FAILED for scsi%d.\n",
2751 instance->host->host_no);
2752 mutex_unlock(&instance->reset_mutex);
2753 return FAILED;
2754 }
2755 status_reg = instance->instancet->read_fw_status_reg(instance->reg_set);
2756 abs_state = status_reg & MFI_STATE_MASK;
2757
2758 /* IO timeout detected, forcibly put FW in FAULT state */
2759 if (abs_state != MFI_STATE_FAULT && instance->crash_dump_buf &&
2760 instance->crash_dump_app_support && iotimeout) {
2761 dev_info(&instance->pdev->dev, "IO timeout is detected, "
2762 "forcibly FAULT Firmware\n");
2763 instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT;
2764 status_reg = readl(&instance->reg_set->doorbell);
2765 writel(status_reg | MFI_STATE_FORCE_OCR,
2766 &instance->reg_set->doorbell);
2767 readl(&instance->reg_set->doorbell);
2768 mutex_unlock(&instance->reset_mutex);
2769 do {
2770 ssleep(3);
2771 io_timeout_in_crash_mode++;
2772 dev_dbg(&instance->pdev->dev, "waiting for [%d] "
2773 "seconds for crash dump collection and OCR "
2774 "to be done\n", (io_timeout_in_crash_mode * 3));
2775 } while ((instance->adprecovery != MEGASAS_HBA_OPERATIONAL) &&
2776 (io_timeout_in_crash_mode < 80));
2777
2778 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) {
2779 dev_info(&instance->pdev->dev, "OCR done for IO "
2780 "timeout case\n");
2781 retval = SUCCESS;
2782 } else {
2783 dev_info(&instance->pdev->dev, "Controller is not "
2784 "operational after 240 seconds wait for IO "
2785 "timeout case in FW crash dump mode\n do "
2786 "OCR/kill adapter\n");
2787 retval = megasas_reset_fusion(shost, 0);
2788 }
2789 return retval;
2790 }
2791
2792 if (instance->requestorId && !instance->skip_heartbeat_timer_del)
2793 del_timer_sync(&instance->sriov_heartbeat_timer);
2794 set_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
2795 instance->adprecovery = MEGASAS_ADPRESET_SM_POLLING;
2796 instance->instancet->disable_intr(instance);
2797 msleep(1000);
2798
2799 /* First try waiting for commands to complete */
2800 if (megasas_wait_for_outstanding_fusion(instance, iotimeout,
2801 &convert)) {
2802 instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT;
2803 dev_warn(&instance->pdev->dev, "resetting fusion "
2804 "adapter scsi%d.\n", instance->host->host_no);
2805 if (convert)
2806 iotimeout = 0;
2807
2808 /* Now return commands back to the OS */
2809 for (i = 0 ; i < instance->max_scsi_cmds; i++) {
2810 cmd_fusion = fusion->cmd_list[i];
2811 scmd_local = cmd_fusion->scmd;
2812 if (cmd_fusion->scmd) {
2813 scmd_local->result =
2814 megasas_check_mpio_paths(instance,
2815 scmd_local);
2816 megasas_return_cmd_fusion(instance, cmd_fusion);
2817 scsi_dma_unmap(scmd_local);
2818 scmd_local->scsi_done(scmd_local);
2819 atomic_dec(&instance->fw_outstanding);
2820 }
2821 }
2822
2823 status_reg = instance->instancet->read_fw_status_reg(
2824 instance->reg_set);
2825 abs_state = status_reg & MFI_STATE_MASK;
2826 reset_adapter = status_reg & MFI_RESET_ADAPTER;
2827 if (instance->disableOnlineCtrlReset ||
2828 (abs_state == MFI_STATE_FAULT && !reset_adapter)) {
2829 /* Reset not supported, kill adapter */
2830 dev_warn(&instance->pdev->dev, "Reset not supported"
2831 ", killing adapter scsi%d.\n",
2832 instance->host->host_no);
2833 megaraid_sas_kill_hba(instance);
2834 instance->skip_heartbeat_timer_del = 1;
2835 retval = FAILED;
2836 goto out;
2837 }
2838
2839 /* Let SR-IOV VF & PF sync up if there was a HB failure */
2840 if (instance->requestorId && !iotimeout) {
2841 msleep(MEGASAS_OCR_SETTLE_TIME_VF);
2842 /* Look for a late HB update after VF settle time */
2843 if (abs_state == MFI_STATE_OPERATIONAL &&
2844 (instance->hb_host_mem->HB.fwCounter !=
2845 instance->hb_host_mem->HB.driverCounter)) {
2846 instance->hb_host_mem->HB.driverCounter =
2847 instance->hb_host_mem->HB.fwCounter;
2848 dev_warn(&instance->pdev->dev, "SR-IOV:"
2849 "Late FW heartbeat update for "
2850 "scsi%d.\n",
2851 instance->host->host_no);
2852 } else {
2853 /* In VF mode, first poll for FW ready */
2854 for (i = 0;
2855 i < (MEGASAS_RESET_WAIT_TIME * 1000);
2856 i += 20) {
2857 status_reg =
2858 instance->instancet->
2859 read_fw_status_reg(
2860 instance->reg_set);
2861 abs_state = status_reg &
2862 MFI_STATE_MASK;
2863 if (abs_state == MFI_STATE_READY) {
2864 dev_warn(&instance->pdev->dev,
2865 "SR-IOV: FW was found"
2866 "to be in ready state "
2867 "for scsi%d.\n",
2868 instance->host->host_no);
2869 break;
2870 }
2871 msleep(20);
2872 }
2873 if (abs_state != MFI_STATE_READY) {
2874 dev_warn(&instance->pdev->dev, "SR-IOV: "
2875 "FW not in ready state after %d"
2876 " seconds for scsi%d, status_reg = "
2877 "0x%x.\n",
2878 MEGASAS_RESET_WAIT_TIME,
2879 instance->host->host_no,
2880 status_reg);
2881 megaraid_sas_kill_hba(instance);
2882 instance->skip_heartbeat_timer_del = 1;
2883 instance->adprecovery =
2884 MEGASAS_HW_CRITICAL_ERROR;
2885 retval = FAILED;
2886 goto out;
2887 }
2888 }
2889 }
2890
2891 /* Now try to reset the chip */
2892 for (i = 0; i < MEGASAS_FUSION_MAX_RESET_TRIES; i++) {
2893
2894 if (instance->instancet->adp_reset
2895 (instance, instance->reg_set))
2896 continue;
2897
2898 /* Wait for FW to become ready */
2899 if (megasas_transition_to_ready(instance, 1)) {
2900 dev_warn(&instance->pdev->dev, "Failed to "
2901 "transition controller to ready "
2902 "for scsi%d.\n",
2903 instance->host->host_no);
2904 continue;
2905 }
2906
2907 megasas_reset_reply_desc(instance);
2908 if (megasas_ioc_init_fusion(instance)) {
2909 dev_warn(&instance->pdev->dev,
2910 "megasas_ioc_init_fusion() failed!"
2911 " for scsi%d\n",
2912 instance->host->host_no);
2913 continue;
2914 }
2915
2916 megasas_refire_mgmt_cmd(instance);
2917
2918 if (megasas_get_ctrl_info(instance)) {
2919 dev_info(&instance->pdev->dev,
2920 "Failed from %s %d\n",
2921 __func__, __LINE__);
2922 megaraid_sas_kill_hba(instance);
2923 retval = FAILED;
2924 }
2925 /* Reset load balance info */
2926 memset(fusion->load_balance_info, 0,
2927 sizeof(struct LD_LOAD_BALANCE_INFO)
2928 *MAX_LOGICAL_DRIVES_EXT);
2929
2930 if (!megasas_get_map_info(instance))
2931 megasas_sync_map_info(instance);
2932
2933 megasas_setup_jbod_map(instance);
2934
2935 clear_bit(MEGASAS_FUSION_IN_RESET,
2936 &instance->reset_flags);
2937 instance->instancet->enable_intr(instance);
2938 instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
2939
2940 /* Restart SR-IOV heartbeat */
2941 if (instance->requestorId) {
2942 if (!megasas_sriov_start_heartbeat(instance, 0))
2943 megasas_start_timer(instance,
2944 &instance->sriov_heartbeat_timer,
2945 megasas_sriov_heartbeat_handler,
2946 MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF);
2947 else
2948 instance->skip_heartbeat_timer_del = 1;
2949 }
2950
2951 /* Adapter reset completed successfully */
2952 dev_warn(&instance->pdev->dev, "Reset "
2953 "successful for scsi%d.\n",
2954 instance->host->host_no);
2955
2956 if (instance->crash_dump_drv_support &&
2957 instance->crash_dump_app_support)
2958 megasas_set_crash_dump_params(instance,
2959 MR_CRASH_BUF_TURN_ON);
2960 else
2961 megasas_set_crash_dump_params(instance,
2962 MR_CRASH_BUF_TURN_OFF);
2963
2964 retval = SUCCESS;
2965 goto out;
2966 }
2967 /* Reset failed, kill the adapter */
2968 dev_warn(&instance->pdev->dev, "Reset failed, killing "
2969 "adapter scsi%d.\n", instance->host->host_no);
2970 megaraid_sas_kill_hba(instance);
2971 instance->skip_heartbeat_timer_del = 1;
2972 retval = FAILED;
2973 } else {
2974 /* For VF: Restart HB timer if we didn't OCR */
2975 if (instance->requestorId) {
2976 megasas_start_timer(instance,
2977 &instance->sriov_heartbeat_timer,
2978 megasas_sriov_heartbeat_handler,
2979 MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF);
2980 }
2981 clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
2982 instance->instancet->enable_intr(instance);
2983 instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
2984 }
2985 out:
2986 clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
2987 mutex_unlock(&instance->reset_mutex);
2988 return retval;
2989 }
2990
2991 /* Fusion Crash dump collection work queue */
2992 void megasas_fusion_crash_dump_wq(struct work_struct *work)
2993 {
2994 struct megasas_instance *instance =
2995 container_of(work, struct megasas_instance, crash_init);
2996 u32 status_reg;
2997 u8 partial_copy = 0;
2998
2999
3000 status_reg = instance->instancet->read_fw_status_reg(instance->reg_set);
3001
3002 /*
3003 * Allocate host crash buffers to copy data from 1 MB DMA crash buffer
3004 * to host crash buffers
3005 */
3006 if (instance->drv_buf_index == 0) {
3007 /* Buffer is already allocated for old Crash dump.
3008 * Do OCR and do not wait for crash dump collection
3009 */
3010 if (instance->drv_buf_alloc) {
3011 dev_info(&instance->pdev->dev, "earlier crash dump is "
3012 "not yet copied by application, ignoring this "
3013 "crash dump and initiating OCR\n");
3014 status_reg |= MFI_STATE_CRASH_DUMP_DONE;
3015 writel(status_reg,
3016 &instance->reg_set->outbound_scratch_pad);
3017 readl(&instance->reg_set->outbound_scratch_pad);
3018 return;
3019 }
3020 megasas_alloc_host_crash_buffer(instance);
3021 dev_info(&instance->pdev->dev, "Number of host crash buffers "
3022 "allocated: %d\n", instance->drv_buf_alloc);
3023 }
3024
3025 /*
3026 * Driver has allocated max buffers, which can be allocated
3027 * and FW has more crash dump data, then driver will
3028 * ignore the data.
3029 */
3030 if (instance->drv_buf_index >= (instance->drv_buf_alloc)) {
3031 dev_info(&instance->pdev->dev, "Driver is done copying "
3032 "the buffer: %d\n", instance->drv_buf_alloc);
3033 status_reg |= MFI_STATE_CRASH_DUMP_DONE;
3034 partial_copy = 1;
3035 } else {
3036 memcpy(instance->crash_buf[instance->drv_buf_index],
3037 instance->crash_dump_buf, CRASH_DMA_BUF_SIZE);
3038 instance->drv_buf_index++;
3039 status_reg &= ~MFI_STATE_DMADONE;
3040 }
3041
3042 if (status_reg & MFI_STATE_CRASH_DUMP_DONE) {
3043 dev_info(&instance->pdev->dev, "Crash Dump is available,number "
3044 "of copied buffers: %d\n", instance->drv_buf_index);
3045 instance->fw_crash_buffer_size = instance->drv_buf_index;
3046 instance->fw_crash_state = AVAILABLE;
3047 instance->drv_buf_index = 0;
3048 writel(status_reg, &instance->reg_set->outbound_scratch_pad);
3049 readl(&instance->reg_set->outbound_scratch_pad);
3050 if (!partial_copy)
3051 megasas_reset_fusion(instance->host, 0);
3052 } else {
3053 writel(status_reg, &instance->reg_set->outbound_scratch_pad);
3054 readl(&instance->reg_set->outbound_scratch_pad);
3055 }
3056 }
3057
3058
3059 /* Fusion OCR work queue */
3060 void megasas_fusion_ocr_wq(struct work_struct *work)
3061 {
3062 struct megasas_instance *instance =
3063 container_of(work, struct megasas_instance, work_init);
3064
3065 megasas_reset_fusion(instance->host, 0);
3066 }
3067
3068 struct megasas_instance_template megasas_instance_template_fusion = {
3069 .enable_intr = megasas_enable_intr_fusion,
3070 .disable_intr = megasas_disable_intr_fusion,
3071 .clear_intr = megasas_clear_intr_fusion,
3072 .read_fw_status_reg = megasas_read_fw_status_reg_fusion,
3073 .adp_reset = megasas_adp_reset_fusion,
3074 .check_reset = megasas_check_reset_fusion,
3075 .service_isr = megasas_isr_fusion,
3076 .tasklet = megasas_complete_cmd_dpc_fusion,
3077 .init_adapter = megasas_init_adapter_fusion,
3078 .build_and_issue_cmd = megasas_build_and_issue_cmd_fusion,
3079 .issue_dcmd = megasas_issue_dcmd_fusion,
3080 };
Linux with added FPC-III support