1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/kernel.h>
21#include <linux/types.h>
22#include <linux/pci.h>
23#include <linux/list.h>
24#include <linux/moduleparam.h>
25#include <linux/module.h>
26#include <linux/spinlock.h>
27#include <linux/interrupt.h>
28#include <linux/delay.h>
29#include <linux/uio.h>
30#include <linux/uaccess.h>
31#include <linux/fs.h>
32#include <linux/compat.h>
33#include <linux/blkdev.h>
34#include <linux/mutex.h>
35#include <linux/poll.h>
36#include <linux/vmalloc.h>
37#include <linux/workqueue.h>
38#include <linux/irq_poll.h>
39
40#include <scsi/scsi.h>
41#include <scsi/scsi_cmnd.h>
42#include <scsi/scsi_device.h>
43#include <scsi/scsi_host.h>
44#include <scsi/scsi_dbg.h>
45#include <linux/dmi.h>
46
47#include "megaraid_sas_fusion.h"
48#include "megaraid_sas.h"
49
50
51extern void megasas_free_cmds(struct megasas_instance *instance);
52extern struct megasas_cmd *megasas_get_cmd(struct megasas_instance
53 *instance);
54extern void
55megasas_complete_cmd(struct megasas_instance *instance,
56 struct megasas_cmd *cmd, u8 alt_status);
57int
58wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
59 int seconds);
60
61void
62megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd);
63int megasas_alloc_cmds(struct megasas_instance *instance);
64int
65megasas_clear_intr_fusion(struct megasas_instance *instance);
66int
67megasas_issue_polled(struct megasas_instance *instance,
68 struct megasas_cmd *cmd);
69void
70megasas_check_and_restore_queue_depth(struct megasas_instance *instance);
71
72int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
73void megaraid_sas_kill_hba(struct megasas_instance *instance);
74
75extern u32 megasas_dbg_lvl;
76int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
77 int initial);
78void megasas_start_timer(struct megasas_instance *instance);
79extern struct megasas_mgmt_info megasas_mgmt_info;
80extern unsigned int resetwaittime;
81extern unsigned int dual_qdepth_disable;
82static void megasas_free_rdpq_fusion(struct megasas_instance *instance);
83static void megasas_free_reply_fusion(struct megasas_instance *instance);
84static inline
85void megasas_configure_queue_sizes(struct megasas_instance *instance);
86static void megasas_fusion_crash_dump(struct megasas_instance *instance);
87extern u32 megasas_readl(struct megasas_instance *instance,
88 const volatile void __iomem *addr);
89
90
91
92
93
94
95
96
97
98
99
100
101
102int
103megasas_adp_reset_wait_for_ready(struct megasas_instance *instance,
104 bool do_adp_reset,
105 int ocr_context)
106{
107 int ret = FAILED;
108
109
110
111
112
113 if (megasas_dbg_lvl & OCR_DEBUG)
114 dev_info(&instance->pdev->dev,
115 "Block access to PCI config space %s %d\n",
116 __func__, __LINE__);
117
118 pci_cfg_access_lock(instance->pdev);
119
120 if (do_adp_reset) {
121 if (instance->instancet->adp_reset
122 (instance, instance->reg_set))
123 goto out;
124 }
125
126
127 if (megasas_transition_to_ready(instance, ocr_context)) {
128 dev_warn(&instance->pdev->dev,
129 "Failed to transition controller to ready for scsi%d.\n",
130 instance->host->host_no);
131 goto out;
132 }
133
134 ret = SUCCESS;
135out:
136 if (megasas_dbg_lvl & OCR_DEBUG)
137 dev_info(&instance->pdev->dev,
138 "Unlock access to PCI config space %s %d\n",
139 __func__, __LINE__);
140
141 pci_cfg_access_unlock(instance->pdev);
142
143 return ret;
144}
145
146
147
148
149
150
151
152
153
154
155
156
157static inline bool megasas_check_same_4gb_region
158 (struct megasas_instance *instance, dma_addr_t start_addr, size_t size)
159{
160 dma_addr_t end_addr;
161
162 end_addr = start_addr + size;
163
164 if (upper_32_bits(start_addr) != upper_32_bits(end_addr)) {
165 dev_err(&instance->pdev->dev,
166 "Failed to get same 4GB boundary: start_addr: 0x%llx end_addr: 0x%llx\n",
167 (unsigned long long)start_addr,
168 (unsigned long long)end_addr);
169 return false;
170 }
171
172 return true;
173}
174
175
176
177
178
179void
180megasas_enable_intr_fusion(struct megasas_instance *instance)
181{
182 struct megasas_register_set __iomem *regs;
183 regs = instance->reg_set;
184
185 instance->mask_interrupts = 0;
186
187 writel(~0, ®s->outbound_intr_status);
188 readl(®s->outbound_intr_status);
189
190 writel(~MFI_FUSION_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
191
192
193 dev_info(&instance->pdev->dev, "%s is called outbound_intr_mask:0x%08x\n",
194 __func__, readl(®s->outbound_intr_mask));
195}
196
197
198
199
200
201void
202megasas_disable_intr_fusion(struct megasas_instance *instance)
203{
204 u32 mask = 0xFFFFFFFF;
205 struct megasas_register_set __iomem *regs;
206 regs = instance->reg_set;
207 instance->mask_interrupts = 1;
208
209 writel(mask, ®s->outbound_intr_mask);
210
211 dev_info(&instance->pdev->dev, "%s is called outbound_intr_mask:0x%08x\n",
212 __func__, readl(®s->outbound_intr_mask));
213}
214
215int
216megasas_clear_intr_fusion(struct megasas_instance *instance)
217{
218 u32 status;
219 struct megasas_register_set __iomem *regs;
220 regs = instance->reg_set;
221
222
223
224 status = megasas_readl(instance,
225 ®s->outbound_intr_status);
226
227 if (status & 1) {
228 writel(status, ®s->outbound_intr_status);
229 readl(®s->outbound_intr_status);
230 return 1;
231 }
232 if (!(status & MFI_FUSION_ENABLE_INTERRUPT_MASK))
233 return 0;
234
235 return 1;
236}
237
238
239
240
241
242
243
244inline struct megasas_cmd_fusion *megasas_get_cmd_fusion(struct megasas_instance
245 *instance, u32 blk_tag)
246{
247 struct fusion_context *fusion;
248
249 fusion = instance->ctrl_context;
250 return fusion->cmd_list[blk_tag];
251}
252
253
254
255
256
257
258inline void megasas_return_cmd_fusion(struct megasas_instance *instance,
259 struct megasas_cmd_fusion *cmd)
260{
261 cmd->scmd = NULL;
262 memset(cmd->io_request, 0, MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE);
263 cmd->r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
264 cmd->cmd_completed = false;
265}
266
267
268
269
270
271
272static void
273megasas_write_64bit_req_desc(struct megasas_instance *instance,
274 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc)
275{
276#if defined(writeq) && defined(CONFIG_64BIT)
277 u64 req_data = (((u64)le32_to_cpu(req_desc->u.high) << 32) |
278 le32_to_cpu(req_desc->u.low));
279 writeq(req_data, &instance->reg_set->inbound_low_queue_port);
280#else
281 unsigned long flags;
282 spin_lock_irqsave(&instance->hba_lock, flags);
283 writel(le32_to_cpu(req_desc->u.low),
284 &instance->reg_set->inbound_low_queue_port);
285 writel(le32_to_cpu(req_desc->u.high),
286 &instance->reg_set->inbound_high_queue_port);
287 spin_unlock_irqrestore(&instance->hba_lock, flags);
288#endif
289}
290
291
292
293
294
295
296
297
298
299static void
300megasas_fire_cmd_fusion(struct megasas_instance *instance,
301 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc)
302{
303 if (instance->atomic_desc_support)
304 writel(le32_to_cpu(req_desc->u.low),
305 &instance->reg_set->inbound_single_queue_port);
306 else
307 megasas_write_64bit_req_desc(instance, req_desc);
308}
309
310
311
312
313
314
315
316
317
318
319
320
321static void
322megasas_fusion_update_can_queue(struct megasas_instance *instance, int fw_boot_context)
323{
324 u16 cur_max_fw_cmds = 0;
325 u16 ldio_threshold = 0;
326 struct megasas_register_set __iomem *reg_set;
327
328 reg_set = instance->reg_set;
329
330
331 if (instance->adapter_type < VENTURA_SERIES)
332 cur_max_fw_cmds =
333 megasas_readl(instance,
334 &instance->reg_set->outbound_scratch_pad_2) & 0x00FFFF;
335
336 if (dual_qdepth_disable || !cur_max_fw_cmds)
337 cur_max_fw_cmds = instance->instancet->read_fw_status_reg(instance) & 0x00FFFF;
338 else
339 ldio_threshold =
340 (instance->instancet->read_fw_status_reg(instance) & 0x00FFFF) - MEGASAS_FUSION_IOCTL_CMDS;
341
342 dev_info(&instance->pdev->dev,
343 "Current firmware supports maximum commands: %d\t LDIO threshold: %d\n",
344 cur_max_fw_cmds, ldio_threshold);
345
346 if (fw_boot_context == OCR_CONTEXT) {
347 cur_max_fw_cmds = cur_max_fw_cmds - 1;
348 if (cur_max_fw_cmds < instance->max_fw_cmds) {
349 instance->cur_can_queue =
350 cur_max_fw_cmds - (MEGASAS_FUSION_INTERNAL_CMDS +
351 MEGASAS_FUSION_IOCTL_CMDS);
352 instance->host->can_queue = instance->cur_can_queue;
353 instance->ldio_threshold = ldio_threshold;
354 }
355 } else {
356 instance->max_fw_cmds = cur_max_fw_cmds;
357 instance->ldio_threshold = ldio_threshold;
358
359 if (reset_devices)
360 instance->max_fw_cmds = min(instance->max_fw_cmds,
361 (u16)MEGASAS_KDUMP_QUEUE_DEPTH);
362
363
364
365
366
367 instance->max_fw_cmds = instance->max_fw_cmds-1;
368 }
369}
370
371
372
373
374void
375megasas_free_cmds_fusion(struct megasas_instance *instance)
376{
377 int i;
378 struct fusion_context *fusion = instance->ctrl_context;
379 struct megasas_cmd_fusion *cmd;
380
381 if (fusion->sense)
382 dma_pool_free(fusion->sense_dma_pool, fusion->sense,
383 fusion->sense_phys_addr);
384
385
386 if (fusion->cmd_list) {
387 for (i = 0; i < instance->max_mpt_cmds; i++) {
388 cmd = fusion->cmd_list[i];
389 if (cmd) {
390 if (cmd->sg_frame)
391 dma_pool_free(fusion->sg_dma_pool,
392 cmd->sg_frame,
393 cmd->sg_frame_phys_addr);
394 }
395 kfree(cmd);
396 }
397 kfree(fusion->cmd_list);
398 }
399
400 if (fusion->sg_dma_pool) {
401 dma_pool_destroy(fusion->sg_dma_pool);
402 fusion->sg_dma_pool = NULL;
403 }
404 if (fusion->sense_dma_pool) {
405 dma_pool_destroy(fusion->sense_dma_pool);
406 fusion->sense_dma_pool = NULL;
407 }
408
409
410
411 if (instance->is_rdpq)
412 megasas_free_rdpq_fusion(instance);
413 else
414 megasas_free_reply_fusion(instance);
415
416
417 if (fusion->req_frames_desc)
418 dma_free_coherent(&instance->pdev->dev,
419 fusion->request_alloc_sz, fusion->req_frames_desc,
420 fusion->req_frames_desc_phys);
421 if (fusion->io_request_frames)
422 dma_pool_free(fusion->io_request_frames_pool,
423 fusion->io_request_frames,
424 fusion->io_request_frames_phys);
425 if (fusion->io_request_frames_pool) {
426 dma_pool_destroy(fusion->io_request_frames_pool);
427 fusion->io_request_frames_pool = NULL;
428 }
429}
430
431
432
433
434
435
436static int megasas_create_sg_sense_fusion(struct megasas_instance *instance)
437{
438 int i;
439 u16 max_cmd;
440 struct fusion_context *fusion;
441 struct megasas_cmd_fusion *cmd;
442 int sense_sz;
443 u32 offset;
444
445 fusion = instance->ctrl_context;
446 max_cmd = instance->max_fw_cmds;
447 sense_sz = instance->max_mpt_cmds * SCSI_SENSE_BUFFERSIZE;
448
449 fusion->sg_dma_pool =
450 dma_pool_create("mr_sg", &instance->pdev->dev,
451 instance->max_chain_frame_sz,
452 MR_DEFAULT_NVME_PAGE_SIZE, 0);
453
454 fusion->sense_dma_pool =
455 dma_pool_create("mr_sense", &instance->pdev->dev,
456 sense_sz, 64, 0);
457
458 if (!fusion->sense_dma_pool || !fusion->sg_dma_pool) {
459 dev_err(&instance->pdev->dev,
460 "Failed from %s %d\n", __func__, __LINE__);
461 return -ENOMEM;
462 }
463
464 fusion->sense = dma_pool_alloc(fusion->sense_dma_pool,
465 GFP_KERNEL, &fusion->sense_phys_addr);
466 if (!fusion->sense) {
467 dev_err(&instance->pdev->dev,
468 "failed from %s %d\n", __func__, __LINE__);
469 return -ENOMEM;
470 }
471
472
473
474
475
476
477
478
479
480
481
482
483 if (!megasas_check_same_4gb_region(instance, fusion->sense_phys_addr,
484 sense_sz)) {
485 dma_pool_free(fusion->sense_dma_pool, fusion->sense,
486 fusion->sense_phys_addr);
487 fusion->sense = NULL;
488 dma_pool_destroy(fusion->sense_dma_pool);
489
490 fusion->sense_dma_pool =
491 dma_pool_create("mr_sense_align", &instance->pdev->dev,
492 sense_sz, roundup_pow_of_two(sense_sz),
493 0);
494 if (!fusion->sense_dma_pool) {
495 dev_err(&instance->pdev->dev,
496 "Failed from %s %d\n", __func__, __LINE__);
497 return -ENOMEM;
498 }
499 fusion->sense = dma_pool_alloc(fusion->sense_dma_pool,
500 GFP_KERNEL,
501 &fusion->sense_phys_addr);
502 if (!fusion->sense) {
503 dev_err(&instance->pdev->dev,
504 "failed from %s %d\n", __func__, __LINE__);
505 return -ENOMEM;
506 }
507 }
508
509
510
511
512 for (i = 0; i < max_cmd; i++) {
513 cmd = fusion->cmd_list[i];
514 cmd->sg_frame = dma_pool_alloc(fusion->sg_dma_pool,
515 GFP_KERNEL, &cmd->sg_frame_phys_addr);
516
517 offset = SCSI_SENSE_BUFFERSIZE * i;
518 cmd->sense = (u8 *)fusion->sense + offset;
519 cmd->sense_phys_addr = fusion->sense_phys_addr + offset;
520
521 if (!cmd->sg_frame) {
522 dev_err(&instance->pdev->dev,
523 "Failed from %s %d\n", __func__, __LINE__);
524 return -ENOMEM;
525 }
526 }
527
528
529 for (i = max_cmd; i < instance->max_mpt_cmds; i++) {
530 cmd = fusion->cmd_list[i];
531 offset = SCSI_SENSE_BUFFERSIZE * i;
532 cmd->sense = (u8 *)fusion->sense + offset;
533 cmd->sense_phys_addr = fusion->sense_phys_addr + offset;
534
535 }
536
537 return 0;
538}
539
540static int
541megasas_alloc_cmdlist_fusion(struct megasas_instance *instance)
542{
543 u32 max_mpt_cmd, i, j;
544 struct fusion_context *fusion;
545
546 fusion = instance->ctrl_context;
547
548 max_mpt_cmd = instance->max_mpt_cmds;
549
550
551
552
553
554
555 fusion->cmd_list =
556 kcalloc(max_mpt_cmd, sizeof(struct megasas_cmd_fusion *),
557 GFP_KERNEL);
558 if (!fusion->cmd_list) {
559 dev_err(&instance->pdev->dev,
560 "Failed from %s %d\n", __func__, __LINE__);
561 return -ENOMEM;
562 }
563
564 for (i = 0; i < max_mpt_cmd; i++) {
565 fusion->cmd_list[i] = kzalloc(sizeof(struct megasas_cmd_fusion),
566 GFP_KERNEL);
567 if (!fusion->cmd_list[i]) {
568 for (j = 0; j < i; j++)
569 kfree(fusion->cmd_list[j]);
570 kfree(fusion->cmd_list);
571 dev_err(&instance->pdev->dev,
572 "Failed from %s %d\n", __func__, __LINE__);
573 return -ENOMEM;
574 }
575 }
576
577 return 0;
578}
579
580static int
581megasas_alloc_request_fusion(struct megasas_instance *instance)
582{
583 struct fusion_context *fusion;
584
585 fusion = instance->ctrl_context;
586
587retry_alloc:
588 fusion->io_request_frames_pool =
589 dma_pool_create("mr_ioreq", &instance->pdev->dev,
590 fusion->io_frames_alloc_sz, 16, 0);
591
592 if (!fusion->io_request_frames_pool) {
593 dev_err(&instance->pdev->dev,
594 "Failed from %s %d\n", __func__, __LINE__);
595 return -ENOMEM;
596 }
597
598 fusion->io_request_frames =
599 dma_pool_alloc(fusion->io_request_frames_pool,
600 GFP_KERNEL, &fusion->io_request_frames_phys);
601 if (!fusion->io_request_frames) {
602 if (instance->max_fw_cmds >= (MEGASAS_REDUCE_QD_COUNT * 2)) {
603 instance->max_fw_cmds -= MEGASAS_REDUCE_QD_COUNT;
604 dma_pool_destroy(fusion->io_request_frames_pool);
605 megasas_configure_queue_sizes(instance);
606 goto retry_alloc;
607 } else {
608 dev_err(&instance->pdev->dev,
609 "Failed from %s %d\n", __func__, __LINE__);
610 return -ENOMEM;
611 }
612 }
613
614 if (!megasas_check_same_4gb_region(instance,
615 fusion->io_request_frames_phys,
616 fusion->io_frames_alloc_sz)) {
617 dma_pool_free(fusion->io_request_frames_pool,
618 fusion->io_request_frames,
619 fusion->io_request_frames_phys);
620 fusion->io_request_frames = NULL;
621 dma_pool_destroy(fusion->io_request_frames_pool);
622
623 fusion->io_request_frames_pool =
624 dma_pool_create("mr_ioreq_align",
625 &instance->pdev->dev,
626 fusion->io_frames_alloc_sz,
627 roundup_pow_of_two(fusion->io_frames_alloc_sz),
628 0);
629
630 if (!fusion->io_request_frames_pool) {
631 dev_err(&instance->pdev->dev,
632 "Failed from %s %d\n", __func__, __LINE__);
633 return -ENOMEM;
634 }
635
636 fusion->io_request_frames =
637 dma_pool_alloc(fusion->io_request_frames_pool,
638 GFP_KERNEL,
639 &fusion->io_request_frames_phys);
640
641 if (!fusion->io_request_frames) {
642 dev_err(&instance->pdev->dev,
643 "Failed from %s %d\n", __func__, __LINE__);
644 return -ENOMEM;
645 }
646 }
647
648 fusion->req_frames_desc =
649 dma_alloc_coherent(&instance->pdev->dev,
650 fusion->request_alloc_sz,
651 &fusion->req_frames_desc_phys, GFP_KERNEL);
652 if (!fusion->req_frames_desc) {
653 dev_err(&instance->pdev->dev,
654 "Failed from %s %d\n", __func__, __LINE__);
655 return -ENOMEM;
656 }
657
658 return 0;
659}
660
661static int
662megasas_alloc_reply_fusion(struct megasas_instance *instance)
663{
664 int i, count;
665 struct fusion_context *fusion;
666 union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc;
667 fusion = instance->ctrl_context;
668
669 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
670 fusion->reply_frames_desc_pool =
671 dma_pool_create("mr_reply", &instance->pdev->dev,
672 fusion->reply_alloc_sz * count, 16, 0);
673
674 if (!fusion->reply_frames_desc_pool) {
675 dev_err(&instance->pdev->dev,
676 "Failed from %s %d\n", __func__, __LINE__);
677 return -ENOMEM;
678 }
679
680 fusion->reply_frames_desc[0] =
681 dma_pool_alloc(fusion->reply_frames_desc_pool,
682 GFP_KERNEL, &fusion->reply_frames_desc_phys[0]);
683 if (!fusion->reply_frames_desc[0]) {
684 dev_err(&instance->pdev->dev,
685 "Failed from %s %d\n", __func__, __LINE__);
686 return -ENOMEM;
687 }
688
689 if (!megasas_check_same_4gb_region(instance,
690 fusion->reply_frames_desc_phys[0],
691 (fusion->reply_alloc_sz * count))) {
692 dma_pool_free(fusion->reply_frames_desc_pool,
693 fusion->reply_frames_desc[0],
694 fusion->reply_frames_desc_phys[0]);
695 fusion->reply_frames_desc[0] = NULL;
696 dma_pool_destroy(fusion->reply_frames_desc_pool);
697
698 fusion->reply_frames_desc_pool =
699 dma_pool_create("mr_reply_align",
700 &instance->pdev->dev,
701 fusion->reply_alloc_sz * count,
702 roundup_pow_of_two(fusion->reply_alloc_sz * count),
703 0);
704
705 if (!fusion->reply_frames_desc_pool) {
706 dev_err(&instance->pdev->dev,
707 "Failed from %s %d\n", __func__, __LINE__);
708 return -ENOMEM;
709 }
710
711 fusion->reply_frames_desc[0] =
712 dma_pool_alloc(fusion->reply_frames_desc_pool,
713 GFP_KERNEL,
714 &fusion->reply_frames_desc_phys[0]);
715
716 if (!fusion->reply_frames_desc[0]) {
717 dev_err(&instance->pdev->dev,
718 "Failed from %s %d\n", __func__, __LINE__);
719 return -ENOMEM;
720 }
721 }
722
723 reply_desc = fusion->reply_frames_desc[0];
724 for (i = 0; i < fusion->reply_q_depth * count; i++, reply_desc++)
725 reply_desc->Words = cpu_to_le64(ULLONG_MAX);
726
727
728
729
730 for (i = 0; i < (count - 1); i++)
731 fusion->reply_frames_desc[i + 1] =
732 fusion->reply_frames_desc[i] +
733 (fusion->reply_alloc_sz)/sizeof(union MPI2_REPLY_DESCRIPTORS_UNION);
734
735 return 0;
736}
737
738static int
739megasas_alloc_rdpq_fusion(struct megasas_instance *instance)
740{
741 int i, j, k, msix_count;
742 struct fusion_context *fusion;
743 union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc;
744 union MPI2_REPLY_DESCRIPTORS_UNION *rdpq_chunk_virt[RDPQ_MAX_CHUNK_COUNT];
745 dma_addr_t rdpq_chunk_phys[RDPQ_MAX_CHUNK_COUNT];
746 u8 dma_alloc_count, abs_index;
747 u32 chunk_size, array_size, offset;
748
749 fusion = instance->ctrl_context;
750 chunk_size = fusion->reply_alloc_sz * RDPQ_MAX_INDEX_IN_ONE_CHUNK;
751 array_size = sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) *
752 MAX_MSIX_QUEUES_FUSION;
753
754 fusion->rdpq_virt = dma_alloc_coherent(&instance->pdev->dev,
755 array_size, &fusion->rdpq_phys,
756 GFP_KERNEL);
757 if (!fusion->rdpq_virt) {
758 dev_err(&instance->pdev->dev,
759 "Failed from %s %d\n", __func__, __LINE__);
760 return -ENOMEM;
761 }
762
763 msix_count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
764
765 fusion->reply_frames_desc_pool = dma_pool_create("mr_rdpq",
766 &instance->pdev->dev,
767 chunk_size, 16, 0);
768 fusion->reply_frames_desc_pool_align =
769 dma_pool_create("mr_rdpq_align",
770 &instance->pdev->dev,
771 chunk_size,
772 roundup_pow_of_two(chunk_size),
773 0);
774
775 if (!fusion->reply_frames_desc_pool ||
776 !fusion->reply_frames_desc_pool_align) {
777 dev_err(&instance->pdev->dev,
778 "Failed from %s %d\n", __func__, __LINE__);
779 return -ENOMEM;
780 }
781
782
783
784
785
786
787
788
789
790 dma_alloc_count = DIV_ROUND_UP(msix_count, RDPQ_MAX_INDEX_IN_ONE_CHUNK);
791
792 for (i = 0; i < dma_alloc_count; i++) {
793 rdpq_chunk_virt[i] =
794 dma_pool_alloc(fusion->reply_frames_desc_pool,
795 GFP_KERNEL, &rdpq_chunk_phys[i]);
796 if (!rdpq_chunk_virt[i]) {
797 dev_err(&instance->pdev->dev,
798 "Failed from %s %d\n", __func__, __LINE__);
799 return -ENOMEM;
800 }
801
802
803
804
805
806
807
808
809
810
811
812
813 if (!megasas_check_same_4gb_region(instance, rdpq_chunk_phys[i],
814 chunk_size)) {
815 dma_pool_free(fusion->reply_frames_desc_pool,
816 rdpq_chunk_virt[i],
817 rdpq_chunk_phys[i]);
818
819 rdpq_chunk_virt[i] =
820 dma_pool_alloc(fusion->reply_frames_desc_pool_align,
821 GFP_KERNEL, &rdpq_chunk_phys[i]);
822 if (!rdpq_chunk_virt[i]) {
823 dev_err(&instance->pdev->dev,
824 "Failed from %s %d\n",
825 __func__, __LINE__);
826 return -ENOMEM;
827 }
828 fusion->rdpq_tracker[i].dma_pool_ptr =
829 fusion->reply_frames_desc_pool_align;
830 } else {
831 fusion->rdpq_tracker[i].dma_pool_ptr =
832 fusion->reply_frames_desc_pool;
833 }
834
835 fusion->rdpq_tracker[i].pool_entry_phys = rdpq_chunk_phys[i];
836 fusion->rdpq_tracker[i].pool_entry_virt = rdpq_chunk_virt[i];
837 }
838
839 for (k = 0; k < dma_alloc_count; k++) {
840 for (i = 0; i < RDPQ_MAX_INDEX_IN_ONE_CHUNK; i++) {
841 abs_index = (k * RDPQ_MAX_INDEX_IN_ONE_CHUNK) + i;
842
843 if (abs_index == msix_count)
844 break;
845 offset = fusion->reply_alloc_sz * i;
846 fusion->rdpq_virt[abs_index].RDPQBaseAddress =
847 cpu_to_le64(rdpq_chunk_phys[k] + offset);
848 fusion->reply_frames_desc_phys[abs_index] =
849 rdpq_chunk_phys[k] + offset;
850 fusion->reply_frames_desc[abs_index] =
851 (union MPI2_REPLY_DESCRIPTORS_UNION *)((u8 *)rdpq_chunk_virt[k] + offset);
852
853 reply_desc = fusion->reply_frames_desc[abs_index];
854 for (j = 0; j < fusion->reply_q_depth; j++, reply_desc++)
855 reply_desc->Words = ULLONG_MAX;
856 }
857 }
858
859 return 0;
860}
861
862static void
863megasas_free_rdpq_fusion(struct megasas_instance *instance) {
864
865 int i;
866 struct fusion_context *fusion;
867
868 fusion = instance->ctrl_context;
869
870 for (i = 0; i < RDPQ_MAX_CHUNK_COUNT; i++) {
871 if (fusion->rdpq_tracker[i].pool_entry_virt)
872 dma_pool_free(fusion->rdpq_tracker[i].dma_pool_ptr,
873 fusion->rdpq_tracker[i].pool_entry_virt,
874 fusion->rdpq_tracker[i].pool_entry_phys);
875
876 }
877
878 dma_pool_destroy(fusion->reply_frames_desc_pool);
879 dma_pool_destroy(fusion->reply_frames_desc_pool_align);
880
881 if (fusion->rdpq_virt)
882 dma_free_coherent(&instance->pdev->dev,
883 sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) * MAX_MSIX_QUEUES_FUSION,
884 fusion->rdpq_virt, fusion->rdpq_phys);
885}
886
887static void
888megasas_free_reply_fusion(struct megasas_instance *instance) {
889
890 struct fusion_context *fusion;
891
892 fusion = instance->ctrl_context;
893
894 if (fusion->reply_frames_desc[0])
895 dma_pool_free(fusion->reply_frames_desc_pool,
896 fusion->reply_frames_desc[0],
897 fusion->reply_frames_desc_phys[0]);
898
899 dma_pool_destroy(fusion->reply_frames_desc_pool);
900
901}
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920static int
921megasas_alloc_cmds_fusion(struct megasas_instance *instance)
922{
923 int i;
924 struct fusion_context *fusion;
925 struct megasas_cmd_fusion *cmd;
926 u32 offset;
927 dma_addr_t io_req_base_phys;
928 u8 *io_req_base;
929
930
931 fusion = instance->ctrl_context;
932
933 if (megasas_alloc_request_fusion(instance))
934 goto fail_exit;
935
936 if (instance->is_rdpq) {
937 if (megasas_alloc_rdpq_fusion(instance))
938 goto fail_exit;
939 } else
940 if (megasas_alloc_reply_fusion(instance))
941 goto fail_exit;
942
943 if (megasas_alloc_cmdlist_fusion(instance))
944 goto fail_exit;
945
946 dev_info(&instance->pdev->dev, "Configured max firmware commands: %d\n",
947 instance->max_fw_cmds);
948
949
950 io_req_base = fusion->io_request_frames + MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE;
951 io_req_base_phys = fusion->io_request_frames_phys + MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE;
952
953
954
955
956
957
958 for (i = 0; i < instance->max_mpt_cmds; i++) {
959 cmd = fusion->cmd_list[i];
960 offset = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * i;
961 memset(cmd, 0, sizeof(struct megasas_cmd_fusion));
962 cmd->index = i + 1;
963 cmd->scmd = NULL;
964 cmd->sync_cmd_idx =
965 (i >= instance->max_scsi_cmds && i < instance->max_fw_cmds) ?
966 (i - instance->max_scsi_cmds) :
967 (u32)ULONG_MAX;
968 cmd->instance = instance;
969 cmd->io_request =
970 (struct MPI2_RAID_SCSI_IO_REQUEST *)
971 (io_req_base + offset);
972 memset(cmd->io_request, 0,
973 sizeof(struct MPI2_RAID_SCSI_IO_REQUEST));
974 cmd->io_request_phys_addr = io_req_base_phys + offset;
975 cmd->r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
976 }
977
978 if (megasas_create_sg_sense_fusion(instance))
979 goto fail_exit;
980
981 return 0;
982
983fail_exit:
984 megasas_free_cmds_fusion(instance);
985 return -ENOMEM;
986}
987
988
989
990
991
992
993
994
995int
996wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
997 int seconds)
998{
999 int i;
1000 struct megasas_header *frame_hdr = &cmd->frame->hdr;
1001 u32 status_reg;
1002
1003 u32 msecs = seconds * 1000;
1004
1005
1006
1007
1008 for (i = 0; (i < msecs) && (frame_hdr->cmd_status == 0xff); i += 20) {
1009 rmb();
1010 msleep(20);
1011 if (!(i % 5000)) {
1012 status_reg = instance->instancet->read_fw_status_reg(instance)
1013 & MFI_STATE_MASK;
1014 if (status_reg == MFI_STATE_FAULT)
1015 break;
1016 }
1017 }
1018
1019 if (frame_hdr->cmd_status == MFI_STAT_INVALID_STATUS)
1020 return DCMD_TIMEOUT;
1021 else if (frame_hdr->cmd_status == MFI_STAT_OK)
1022 return DCMD_SUCCESS;
1023 else
1024 return DCMD_FAILED;
1025}
1026
1027
1028
1029
1030
1031
1032
1033int
1034megasas_ioc_init_fusion(struct megasas_instance *instance)
1035{
1036 struct megasas_init_frame *init_frame;
1037 struct MPI2_IOC_INIT_REQUEST *IOCInitMessage = NULL;
1038 dma_addr_t ioc_init_handle;
1039 struct megasas_cmd *cmd;
1040 u8 ret, cur_rdpq_mode;
1041 struct fusion_context *fusion;
1042 union MEGASAS_REQUEST_DESCRIPTOR_UNION req_desc;
1043 int i;
1044 struct megasas_header *frame_hdr;
1045 const char *sys_info;
1046 MFI_CAPABILITIES *drv_ops;
1047 u32 scratch_pad_1;
1048 ktime_t time;
1049 bool cur_fw_64bit_dma_capable;
1050 bool cur_intr_coalescing;
1051
1052 fusion = instance->ctrl_context;
1053
1054 ioc_init_handle = fusion->ioc_init_request_phys;
1055 IOCInitMessage = fusion->ioc_init_request;
1056
1057 cmd = fusion->ioc_init_cmd;
1058
1059 scratch_pad_1 = megasas_readl
1060 (instance, &instance->reg_set->outbound_scratch_pad_1);
1061
1062 cur_rdpq_mode = (scratch_pad_1 & MR_RDPQ_MODE_OFFSET) ? 1 : 0;
1063
1064 if (instance->adapter_type == INVADER_SERIES) {
1065 cur_fw_64bit_dma_capable =
1066 (scratch_pad_1 & MR_CAN_HANDLE_64_BIT_DMA_OFFSET) ? true : false;
1067
1068 if (instance->consistent_mask_64bit && !cur_fw_64bit_dma_capable) {
1069 dev_err(&instance->pdev->dev, "Driver was operating on 64bit "
1070 "DMA mask, but upcoming FW does not support 64bit DMA mask\n");
1071 megaraid_sas_kill_hba(instance);
1072 ret = 1;
1073 goto fail_fw_init;
1074 }
1075 }
1076
1077 if (instance->is_rdpq && !cur_rdpq_mode) {
1078 dev_err(&instance->pdev->dev, "Firmware downgrade *NOT SUPPORTED*"
1079 " from RDPQ mode to non RDPQ mode\n");
1080 ret = 1;
1081 goto fail_fw_init;
1082 }
1083
1084 cur_intr_coalescing = (scratch_pad_1 & MR_INTR_COALESCING_SUPPORT_OFFSET) ?
1085 true : false;
1086
1087 if ((instance->low_latency_index_start ==
1088 MR_HIGH_IOPS_QUEUE_COUNT) && cur_intr_coalescing)
1089 instance->perf_mode = MR_BALANCED_PERF_MODE;
1090
1091 dev_info(&instance->pdev->dev, "Performance mode :%s\n",
1092 MEGASAS_PERF_MODE_2STR(instance->perf_mode));
1093
1094 instance->fw_sync_cache_support = (scratch_pad_1 &
1095 MR_CAN_HANDLE_SYNC_CACHE_OFFSET) ? 1 : 0;
1096 dev_info(&instance->pdev->dev, "FW supports sync cache\t: %s\n",
1097 instance->fw_sync_cache_support ? "Yes" : "No");
1098
1099 memset(IOCInitMessage, 0, sizeof(struct MPI2_IOC_INIT_REQUEST));
1100
1101 IOCInitMessage->Function = MPI2_FUNCTION_IOC_INIT;
1102 IOCInitMessage->WhoInit = MPI2_WHOINIT_HOST_DRIVER;
1103 IOCInitMessage->MsgVersion = cpu_to_le16(MPI2_VERSION);
1104 IOCInitMessage->HeaderVersion = cpu_to_le16(MPI2_HEADER_VERSION);
1105 IOCInitMessage->SystemRequestFrameSize = cpu_to_le16(MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE / 4);
1106
1107 IOCInitMessage->ReplyDescriptorPostQueueDepth = cpu_to_le16(fusion->reply_q_depth);
1108 IOCInitMessage->ReplyDescriptorPostQueueAddress = instance->is_rdpq ?
1109 cpu_to_le64(fusion->rdpq_phys) :
1110 cpu_to_le64(fusion->reply_frames_desc_phys[0]);
1111 IOCInitMessage->MsgFlags = instance->is_rdpq ?
1112 MPI2_IOCINIT_MSGFLAG_RDPQ_ARRAY_MODE : 0;
1113 IOCInitMessage->SystemRequestFrameBaseAddress = cpu_to_le64(fusion->io_request_frames_phys);
1114 IOCInitMessage->SenseBufferAddressHigh = cpu_to_le32(upper_32_bits(fusion->sense_phys_addr));
1115 IOCInitMessage->HostMSIxVectors = instance->msix_vectors;
1116 IOCInitMessage->HostPageSize = MR_DEFAULT_NVME_PAGE_SHIFT;
1117
1118 time = ktime_get_real();
1119
1120 IOCInitMessage->TimeStamp = cpu_to_le64(ktime_to_ms(time));
1121
1122 init_frame = (struct megasas_init_frame *)cmd->frame;
1123 memset(init_frame, 0, IOC_INIT_FRAME_SIZE);
1124
1125 frame_hdr = &cmd->frame->hdr;
1126 frame_hdr->cmd_status = 0xFF;
1127 frame_hdr->flags |= cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE);
1128
1129 init_frame->cmd = MFI_CMD_INIT;
1130 init_frame->cmd_status = 0xFF;
1131
1132 drv_ops = (MFI_CAPABILITIES *) &(init_frame->driver_operations);
1133
1134
1135 if (instance->adapter_type >= INVADER_SERIES)
1136 drv_ops->mfi_capabilities.support_additional_msix = 1;
1137
1138 drv_ops->mfi_capabilities.support_fp_remote_lun = 1;
1139
1140 drv_ops->mfi_capabilities.support_max_255lds = 1;
1141 drv_ops->mfi_capabilities.support_ndrive_r1_lb = 1;
1142 drv_ops->mfi_capabilities.security_protocol_cmds_fw = 1;
1143
1144 if (instance->max_chain_frame_sz > MEGASAS_CHAIN_FRAME_SZ_MIN)
1145 drv_ops->mfi_capabilities.support_ext_io_size = 1;
1146
1147 drv_ops->mfi_capabilities.support_fp_rlbypass = 1;
1148 if (!dual_qdepth_disable)
1149 drv_ops->mfi_capabilities.support_ext_queue_depth = 1;
1150
1151 drv_ops->mfi_capabilities.support_qd_throttling = 1;
1152 drv_ops->mfi_capabilities.support_pd_map_target_id = 1;
1153 drv_ops->mfi_capabilities.support_nvme_passthru = 1;
1154 drv_ops->mfi_capabilities.support_fw_exposed_dev_list = 1;
1155
1156 if (instance->consistent_mask_64bit)
1157 drv_ops->mfi_capabilities.support_64bit_mode = 1;
1158
1159
1160 cpu_to_le32s((u32 *)&init_frame->driver_operations.mfi_capabilities);
1161
1162 sys_info = dmi_get_system_info(DMI_PRODUCT_UUID);
1163 if (instance->system_info_buf && sys_info) {
1164 memcpy(instance->system_info_buf->systemId, sys_info,
1165 strlen(sys_info) > 64 ? 64 : strlen(sys_info));
1166 instance->system_info_buf->systemIdLength =
1167 strlen(sys_info) > 64 ? 64 : strlen(sys_info);
1168 init_frame->system_info_lo = cpu_to_le32(lower_32_bits(instance->system_info_h));
1169 init_frame->system_info_hi = cpu_to_le32(upper_32_bits(instance->system_info_h));
1170 }
1171
1172 init_frame->queue_info_new_phys_addr_hi =
1173 cpu_to_le32(upper_32_bits(ioc_init_handle));
1174 init_frame->queue_info_new_phys_addr_lo =
1175 cpu_to_le32(lower_32_bits(ioc_init_handle));
1176 init_frame->data_xfer_len = cpu_to_le32(sizeof(struct MPI2_IOC_INIT_REQUEST));
1177
1178
1179
1180
1181
1182 switch (instance->perf_mode) {
1183 case MR_BALANCED_PERF_MODE:
1184 init_frame->replyqueue_mask =
1185 cpu_to_le16(~(~0 << instance->low_latency_index_start/8));
1186 break;
1187 case MR_IOPS_PERF_MODE:
1188 init_frame->replyqueue_mask =
1189 cpu_to_le16(~(~0 << instance->msix_vectors/8));
1190 break;
1191 }
1192
1193
1194 req_desc.u.low = cpu_to_le32(lower_32_bits(cmd->frame_phys_addr));
1195 req_desc.u.high = cpu_to_le32(upper_32_bits(cmd->frame_phys_addr));
1196 req_desc.MFAIo.RequestFlags =
1197 (MEGASAS_REQ_DESCRIPT_FLAGS_MFA <<
1198 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
1199
1200
1201
1202
1203 instance->instancet->disable_intr(instance);
1204
1205 for (i = 0; i < (10 * 1000); i += 20) {
1206 if (megasas_readl(instance, &instance->reg_set->doorbell) & 1)
1207 msleep(20);
1208 else
1209 break;
1210 }
1211
1212
1213 megasas_write_64bit_req_desc(instance, &req_desc);
1214
1215 wait_and_poll(instance, cmd, MFI_IO_TIMEOUT_SECS);
1216
1217 frame_hdr = &cmd->frame->hdr;
1218 if (frame_hdr->cmd_status != 0) {
1219 ret = 1;
1220 goto fail_fw_init;
1221 }
1222
1223 if (instance->adapter_type >= AERO_SERIES) {
1224 scratch_pad_1 = megasas_readl
1225 (instance, &instance->reg_set->outbound_scratch_pad_1);
1226
1227 instance->atomic_desc_support =
1228 (scratch_pad_1 & MR_ATOMIC_DESCRIPTOR_SUPPORT_OFFSET) ? 1 : 0;
1229
1230 dev_info(&instance->pdev->dev, "FW supports atomic descriptor\t: %s\n",
1231 instance->atomic_desc_support ? "Yes" : "No");
1232 }
1233
1234 return 0;
1235
1236fail_fw_init:
1237 dev_err(&instance->pdev->dev,
1238 "Init cmd return status FAILED for SCSI host %d\n",
1239 instance->host->host_no);
1240
1241 return ret;
1242}
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253int
1254megasas_sync_pd_seq_num(struct megasas_instance *instance, bool pend) {
1255 int ret = 0;
1256 size_t pd_seq_map_sz;
1257 struct megasas_cmd *cmd;
1258 struct megasas_dcmd_frame *dcmd;
1259 struct fusion_context *fusion = instance->ctrl_context;
1260 struct MR_PD_CFG_SEQ_NUM_SYNC *pd_sync;
1261 dma_addr_t pd_seq_h;
1262
1263 pd_sync = (void *)fusion->pd_seq_sync[(instance->pd_seq_map_id & 1)];
1264 pd_seq_h = fusion->pd_seq_phys[(instance->pd_seq_map_id & 1)];
1265 pd_seq_map_sz = struct_size(pd_sync, seq, MAX_PHYSICAL_DEVICES - 1);
1266
1267 cmd = megasas_get_cmd(instance);
1268 if (!cmd) {
1269 dev_err(&instance->pdev->dev,
1270 "Could not get mfi cmd. Fail from %s %d\n",
1271 __func__, __LINE__);
1272 return -ENOMEM;
1273 }
1274
1275 dcmd = &cmd->frame->dcmd;
1276
1277 memset(pd_sync, 0, pd_seq_map_sz);
1278 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
1279
1280 if (pend) {
1281 dcmd->mbox.b[0] = MEGASAS_DCMD_MBOX_PEND_FLAG;
1282 dcmd->flags = MFI_FRAME_DIR_WRITE;
1283 instance->jbod_seq_cmd = cmd;
1284 } else {
1285 dcmd->flags = MFI_FRAME_DIR_READ;
1286 }
1287
1288 dcmd->cmd = MFI_CMD_DCMD;
1289 dcmd->cmd_status = 0xFF;
1290 dcmd->sge_count = 1;
1291 dcmd->timeout = 0;
1292 dcmd->pad_0 = 0;
1293 dcmd->data_xfer_len = cpu_to_le32(pd_seq_map_sz);
1294 dcmd->opcode = cpu_to_le32(MR_DCMD_SYSTEM_PD_MAP_GET_INFO);
1295
1296 megasas_set_dma_settings(instance, dcmd, pd_seq_h, pd_seq_map_sz);
1297
1298 if (pend) {
1299 instance->instancet->issue_dcmd(instance, cmd);
1300 return 0;
1301 }
1302
1303
1304 if (!instance->mask_interrupts)
1305 ret = megasas_issue_blocked_cmd(instance, cmd,
1306 MFI_IO_TIMEOUT_SECS);
1307 else
1308 ret = megasas_issue_polled(instance, cmd);
1309
1310 if (le32_to_cpu(pd_sync->count) > MAX_PHYSICAL_DEVICES) {
1311 dev_warn(&instance->pdev->dev,
1312 "driver supports max %d JBOD, but FW reports %d\n",
1313 MAX_PHYSICAL_DEVICES, le32_to_cpu(pd_sync->count));
1314 ret = -EINVAL;
1315 }
1316
1317 if (ret == DCMD_TIMEOUT)
1318 megaraid_sas_kill_hba(instance);
1319
1320 if (ret == DCMD_SUCCESS)
1321 instance->pd_seq_map_id++;
1322
1323 megasas_return_cmd(instance, cmd);
1324 return ret;
1325}
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342static int
1343megasas_get_ld_map_info(struct megasas_instance *instance)
1344{
1345 int ret = 0;
1346 struct megasas_cmd *cmd;
1347 struct megasas_dcmd_frame *dcmd;
1348 void *ci;
1349 dma_addr_t ci_h = 0;
1350 u32 size_map_info;
1351 struct fusion_context *fusion;
1352
1353 cmd = megasas_get_cmd(instance);
1354
1355 if (!cmd) {
1356 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get cmd for map info\n");
1357 return -ENOMEM;
1358 }
1359
1360 fusion = instance->ctrl_context;
1361
1362 if (!fusion) {
1363 megasas_return_cmd(instance, cmd);
1364 return -ENXIO;
1365 }
1366
1367 dcmd = &cmd->frame->dcmd;
1368
1369 size_map_info = fusion->current_map_sz;
1370
1371 ci = (void *) fusion->ld_map[(instance->map_id & 1)];
1372 ci_h = fusion->ld_map_phys[(instance->map_id & 1)];
1373
1374 if (!ci) {
1375 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc mem for ld_map_info\n");
1376 megasas_return_cmd(instance, cmd);
1377 return -ENOMEM;
1378 }
1379
1380 memset(ci, 0, fusion->max_map_sz);
1381 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
1382 dcmd->cmd = MFI_CMD_DCMD;
1383 dcmd->cmd_status = 0xFF;
1384 dcmd->sge_count = 1;
1385 dcmd->flags = MFI_FRAME_DIR_READ;
1386 dcmd->timeout = 0;
1387 dcmd->pad_0 = 0;
1388 dcmd->data_xfer_len = cpu_to_le32(size_map_info);
1389 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_MAP_GET_INFO);
1390
1391 megasas_set_dma_settings(instance, dcmd, ci_h, size_map_info);
1392
1393 if (!instance->mask_interrupts)
1394 ret = megasas_issue_blocked_cmd(instance, cmd,
1395 MFI_IO_TIMEOUT_SECS);
1396 else
1397 ret = megasas_issue_polled(instance, cmd);
1398
1399 if (ret == DCMD_TIMEOUT)
1400 megaraid_sas_kill_hba(instance);
1401
1402 megasas_return_cmd(instance, cmd);
1403
1404 return ret;
1405}
1406
1407u8
1408megasas_get_map_info(struct megasas_instance *instance)
1409{
1410 struct fusion_context *fusion = instance->ctrl_context;
1411
1412 fusion->fast_path_io = 0;
1413 if (!megasas_get_ld_map_info(instance)) {
1414 if (MR_ValidateMapInfo(instance, instance->map_id)) {
1415 fusion->fast_path_io = 1;
1416 return 0;
1417 }
1418 }
1419 return 1;
1420}
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430int
1431megasas_sync_map_info(struct megasas_instance *instance)
1432{
1433 int i;
1434 struct megasas_cmd *cmd;
1435 struct megasas_dcmd_frame *dcmd;
1436 u16 num_lds;
1437 struct fusion_context *fusion;
1438 struct MR_LD_TARGET_SYNC *ci = NULL;
1439 struct MR_DRV_RAID_MAP_ALL *map;
1440 struct MR_LD_RAID *raid;
1441 struct MR_LD_TARGET_SYNC *ld_sync;
1442 dma_addr_t ci_h = 0;
1443 u32 size_map_info;
1444
1445 cmd = megasas_get_cmd(instance);
1446
1447 if (!cmd) {
1448 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get cmd for sync info\n");
1449 return -ENOMEM;
1450 }
1451
1452 fusion = instance->ctrl_context;
1453
1454 if (!fusion) {
1455 megasas_return_cmd(instance, cmd);
1456 return 1;
1457 }
1458
1459 map = fusion->ld_drv_map[instance->map_id & 1];
1460
1461 num_lds = le16_to_cpu(map->raidMap.ldCount);
1462
1463 dcmd = &cmd->frame->dcmd;
1464
1465 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
1466
1467 ci = (struct MR_LD_TARGET_SYNC *)
1468 fusion->ld_map[(instance->map_id - 1) & 1];
1469 memset(ci, 0, fusion->max_map_sz);
1470
1471 ci_h = fusion->ld_map_phys[(instance->map_id - 1) & 1];
1472
1473 ld_sync = (struct MR_LD_TARGET_SYNC *)ci;
1474
1475 for (i = 0; i < num_lds; i++, ld_sync++) {
1476 raid = MR_LdRaidGet(i, map);
1477 ld_sync->targetId = MR_GetLDTgtId(i, map);
1478 ld_sync->seqNum = raid->seqNum;
1479 }
1480
1481 size_map_info = fusion->current_map_sz;
1482
1483 dcmd->cmd = MFI_CMD_DCMD;
1484 dcmd->cmd_status = 0xFF;
1485 dcmd->sge_count = 1;
1486 dcmd->flags = MFI_FRAME_DIR_WRITE;
1487 dcmd->timeout = 0;
1488 dcmd->pad_0 = 0;
1489 dcmd->data_xfer_len = cpu_to_le32(size_map_info);
1490 dcmd->mbox.b[0] = num_lds;
1491 dcmd->mbox.b[1] = MEGASAS_DCMD_MBOX_PEND_FLAG;
1492 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_MAP_GET_INFO);
1493
1494 megasas_set_dma_settings(instance, dcmd, ci_h, size_map_info);
1495
1496 instance->map_update_cmd = cmd;
1497
1498 instance->instancet->issue_dcmd(instance, cmd);
1499
1500 return 0;
1501}
1502
1503
1504
1505
1506
1507
1508
1509static void
1510megasas_display_intel_branding(struct megasas_instance *instance)
1511{
1512 if (instance->pdev->subsystem_vendor != PCI_VENDOR_ID_INTEL)
1513 return;
1514
1515 switch (instance->pdev->device) {
1516 case PCI_DEVICE_ID_LSI_INVADER:
1517 switch (instance->pdev->subsystem_device) {
1518 case MEGARAID_INTEL_RS3DC080_SSDID:
1519 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1520 instance->host->host_no,
1521 MEGARAID_INTEL_RS3DC080_BRANDING);
1522 break;
1523 case MEGARAID_INTEL_RS3DC040_SSDID:
1524 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1525 instance->host->host_no,
1526 MEGARAID_INTEL_RS3DC040_BRANDING);
1527 break;
1528 case MEGARAID_INTEL_RS3SC008_SSDID:
1529 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1530 instance->host->host_no,
1531 MEGARAID_INTEL_RS3SC008_BRANDING);
1532 break;
1533 case MEGARAID_INTEL_RS3MC044_SSDID:
1534 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1535 instance->host->host_no,
1536 MEGARAID_INTEL_RS3MC044_BRANDING);
1537 break;
1538 default:
1539 break;
1540 }
1541 break;
1542 case PCI_DEVICE_ID_LSI_FURY:
1543 switch (instance->pdev->subsystem_device) {
1544 case MEGARAID_INTEL_RS3WC080_SSDID:
1545 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1546 instance->host->host_no,
1547 MEGARAID_INTEL_RS3WC080_BRANDING);
1548 break;
1549 case MEGARAID_INTEL_RS3WC040_SSDID:
1550 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1551 instance->host->host_no,
1552 MEGARAID_INTEL_RS3WC040_BRANDING);
1553 break;
1554 default:
1555 break;
1556 }
1557 break;
1558 case PCI_DEVICE_ID_LSI_CUTLASS_52:
1559 case PCI_DEVICE_ID_LSI_CUTLASS_53:
1560 switch (instance->pdev->subsystem_device) {
1561 case MEGARAID_INTEL_RMS3BC160_SSDID:
1562 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1563 instance->host->host_no,
1564 MEGARAID_INTEL_RMS3BC160_BRANDING);
1565 break;
1566 default:
1567 break;
1568 }
1569 break;
1570 default:
1571 break;
1572 }
1573}
1574
1575
1576
1577
1578
1579
1580
1581
1582static inline int megasas_allocate_raid_maps(struct megasas_instance *instance)
1583{
1584 struct fusion_context *fusion;
1585 int i = 0;
1586
1587 fusion = instance->ctrl_context;
1588
1589 fusion->drv_map_pages = get_order(fusion->drv_map_sz);
1590
1591 for (i = 0; i < 2; i++) {
1592 fusion->ld_map[i] = NULL;
1593
1594 fusion->ld_drv_map[i] = (void *)
1595 __get_free_pages(__GFP_ZERO | GFP_KERNEL,
1596 fusion->drv_map_pages);
1597
1598 if (!fusion->ld_drv_map[i]) {
1599 fusion->ld_drv_map[i] = vzalloc(fusion->drv_map_sz);
1600
1601 if (!fusion->ld_drv_map[i]) {
1602 dev_err(&instance->pdev->dev,
1603 "Could not allocate memory for local map"
1604 " size requested: %d\n",
1605 fusion->drv_map_sz);
1606 goto ld_drv_map_alloc_fail;
1607 }
1608 }
1609 }
1610
1611 for (i = 0; i < 2; i++) {
1612 fusion->ld_map[i] = dma_alloc_coherent(&instance->pdev->dev,
1613 fusion->max_map_sz,
1614 &fusion->ld_map_phys[i],
1615 GFP_KERNEL);
1616 if (!fusion->ld_map[i]) {
1617 dev_err(&instance->pdev->dev,
1618 "Could not allocate memory for map info %s:%d\n",
1619 __func__, __LINE__);
1620 goto ld_map_alloc_fail;
1621 }
1622 }
1623
1624 return 0;
1625
1626ld_map_alloc_fail:
1627 for (i = 0; i < 2; i++) {
1628 if (fusion->ld_map[i])
1629 dma_free_coherent(&instance->pdev->dev,
1630 fusion->max_map_sz,
1631 fusion->ld_map[i],
1632 fusion->ld_map_phys[i]);
1633 }
1634
1635ld_drv_map_alloc_fail:
1636 for (i = 0; i < 2; i++) {
1637 if (fusion->ld_drv_map[i]) {
1638 if (is_vmalloc_addr(fusion->ld_drv_map[i]))
1639 vfree(fusion->ld_drv_map[i]);
1640 else
1641 free_pages((ulong)fusion->ld_drv_map[i],
1642 fusion->drv_map_pages);
1643 }
1644 }
1645
1646 return -ENOMEM;
1647}
1648
1649
1650
1651
1652
1653
1654
1655
1656static inline
1657void megasas_configure_queue_sizes(struct megasas_instance *instance)
1658{
1659 struct fusion_context *fusion;
1660 u16 max_cmd;
1661
1662 fusion = instance->ctrl_context;
1663 max_cmd = instance->max_fw_cmds;
1664
1665 if (instance->adapter_type >= VENTURA_SERIES)
1666 instance->max_mpt_cmds = instance->max_fw_cmds * RAID_1_PEER_CMDS;
1667 else
1668 instance->max_mpt_cmds = instance->max_fw_cmds;
1669
1670 instance->max_scsi_cmds = instance->max_fw_cmds - instance->max_mfi_cmds;
1671 instance->cur_can_queue = instance->max_scsi_cmds;
1672 instance->host->can_queue = instance->cur_can_queue;
1673
1674 fusion->reply_q_depth = 2 * ((max_cmd + 1 + 15) / 16) * 16;
1675
1676 fusion->request_alloc_sz = sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) *
1677 instance->max_mpt_cmds;
1678 fusion->reply_alloc_sz = sizeof(union MPI2_REPLY_DESCRIPTORS_UNION) *
1679 (fusion->reply_q_depth);
1680 fusion->io_frames_alloc_sz = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE +
1681 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE
1682 * (instance->max_mpt_cmds + 1));
1683}
1684
1685static int megasas_alloc_ioc_init_frame(struct megasas_instance *instance)
1686{
1687 struct fusion_context *fusion;
1688 struct megasas_cmd *cmd;
1689
1690 fusion = instance->ctrl_context;
1691
1692 cmd = kzalloc(sizeof(struct megasas_cmd), GFP_KERNEL);
1693
1694 if (!cmd) {
1695 dev_err(&instance->pdev->dev, "Failed from func: %s line: %d\n",
1696 __func__, __LINE__);
1697 return -ENOMEM;
1698 }
1699
1700 cmd->frame = dma_alloc_coherent(&instance->pdev->dev,
1701 IOC_INIT_FRAME_SIZE,
1702 &cmd->frame_phys_addr, GFP_KERNEL);
1703
1704 if (!cmd->frame) {
1705 dev_err(&instance->pdev->dev, "Failed from func: %s line: %d\n",
1706 __func__, __LINE__);
1707 kfree(cmd);
1708 return -ENOMEM;
1709 }
1710
1711 fusion->ioc_init_cmd = cmd;
1712 return 0;
1713}
1714
1715
1716
1717
1718
1719static inline void megasas_free_ioc_init_cmd(struct megasas_instance *instance)
1720{
1721 struct fusion_context *fusion;
1722
1723 fusion = instance->ctrl_context;
1724
1725 if (fusion->ioc_init_cmd && fusion->ioc_init_cmd->frame)
1726 dma_free_coherent(&instance->pdev->dev,
1727 IOC_INIT_FRAME_SIZE,
1728 fusion->ioc_init_cmd->frame,
1729 fusion->ioc_init_cmd->frame_phys_addr);
1730
1731 kfree(fusion->ioc_init_cmd);
1732}
1733
1734
1735
1736
1737
1738
1739
1740static u32
1741megasas_init_adapter_fusion(struct megasas_instance *instance)
1742{
1743 struct fusion_context *fusion;
1744 u32 scratch_pad_1;
1745 int i = 0, count;
1746 u32 status_reg;
1747
1748 fusion = instance->ctrl_context;
1749
1750 megasas_fusion_update_can_queue(instance, PROBE_CONTEXT);
1751
1752
1753
1754
1755 instance->max_mfi_cmds =
1756 MEGASAS_FUSION_INTERNAL_CMDS + MEGASAS_FUSION_IOCTL_CMDS;
1757
1758 megasas_configure_queue_sizes(instance);
1759
1760 scratch_pad_1 = megasas_readl(instance,
1761 &instance->reg_set->outbound_scratch_pad_1);
1762
1763
1764
1765
1766
1767
1768 if (scratch_pad_1 & MEGASAS_MAX_CHAIN_SIZE_UNITS_MASK)
1769 instance->max_chain_frame_sz =
1770 ((scratch_pad_1 & MEGASAS_MAX_CHAIN_SIZE_MASK) >>
1771 MEGASAS_MAX_CHAIN_SHIFT) * MEGASAS_1MB_IO;
1772 else
1773 instance->max_chain_frame_sz =
1774 ((scratch_pad_1 & MEGASAS_MAX_CHAIN_SIZE_MASK) >>
1775 MEGASAS_MAX_CHAIN_SHIFT) * MEGASAS_256K_IO;
1776
1777 if (instance->max_chain_frame_sz < MEGASAS_CHAIN_FRAME_SZ_MIN) {
1778 dev_warn(&instance->pdev->dev, "frame size %d invalid, fall back to legacy max frame size %d\n",
1779 instance->max_chain_frame_sz,
1780 MEGASAS_CHAIN_FRAME_SZ_MIN);
1781 instance->max_chain_frame_sz = MEGASAS_CHAIN_FRAME_SZ_MIN;
1782 }
1783
1784 fusion->max_sge_in_main_msg =
1785 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE
1786 - offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL))/16;
1787
1788 fusion->max_sge_in_chain =
1789 instance->max_chain_frame_sz
1790 / sizeof(union MPI2_SGE_IO_UNION);
1791
1792 instance->max_num_sge =
1793 rounddown_pow_of_two(fusion->max_sge_in_main_msg
1794 + fusion->max_sge_in_chain - 2);
1795
1796
1797 fusion->chain_offset_mfi_pthru =
1798 offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL)/16;
1799
1800 fusion->chain_offset_io_request =
1801 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE -
1802 sizeof(union MPI2_SGE_IO_UNION))/16;
1803
1804 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
1805 for (i = 0 ; i < count; i++)
1806 fusion->last_reply_idx[i] = 0;
1807
1808
1809
1810
1811
1812 instance->max_scsi_cmds = instance->max_fw_cmds -
1813 (MEGASAS_FUSION_INTERNAL_CMDS +
1814 MEGASAS_FUSION_IOCTL_CMDS);
1815 sema_init(&instance->ioctl_sem, MEGASAS_FUSION_IOCTL_CMDS);
1816
1817 if (megasas_alloc_ioc_init_frame(instance))
1818 return 1;
1819
1820
1821
1822
1823
1824 if (megasas_alloc_cmds(instance))
1825 goto fail_alloc_mfi_cmds;
1826 if (megasas_alloc_cmds_fusion(instance))
1827 goto fail_alloc_cmds;
1828
1829 if (megasas_ioc_init_fusion(instance)) {
1830 status_reg = instance->instancet->read_fw_status_reg(instance);
1831 if (((status_reg & MFI_STATE_MASK) == MFI_STATE_FAULT) &&
1832 (status_reg & MFI_RESET_ADAPTER)) {
1833
1834 if (megasas_adp_reset_wait_for_ready
1835 (instance, true, 0) == FAILED)
1836 goto fail_ioc_init;
1837
1838 if (megasas_ioc_init_fusion(instance))
1839 goto fail_ioc_init;
1840 } else {
1841 goto fail_ioc_init;
1842 }
1843 }
1844
1845 megasas_display_intel_branding(instance);
1846 if (megasas_get_ctrl_info(instance)) {
1847 dev_err(&instance->pdev->dev,
1848 "Could not get controller info. Fail from %s %d\n",
1849 __func__, __LINE__);
1850 goto fail_ioc_init;
1851 }
1852
1853 instance->flag_ieee = 1;
1854 instance->r1_ldio_hint_default = MR_R1_LDIO_PIGGYBACK_DEFAULT;
1855 instance->threshold_reply_count = instance->max_fw_cmds / 4;
1856 fusion->fast_path_io = 0;
1857
1858 if (megasas_allocate_raid_maps(instance))
1859 goto fail_ioc_init;
1860
1861 if (!megasas_get_map_info(instance))
1862 megasas_sync_map_info(instance);
1863
1864 return 0;
1865
1866fail_ioc_init:
1867 megasas_free_cmds_fusion(instance);
1868fail_alloc_cmds:
1869 megasas_free_cmds(instance);
1870fail_alloc_mfi_cmds:
1871 megasas_free_ioc_init_cmd(instance);
1872 return 1;
1873}
1874
1875
1876
1877
1878
1879static void
1880megasas_fault_detect_work(struct work_struct *work)
1881{
1882 struct megasas_instance *instance =
1883 container_of(work, struct megasas_instance,
1884 fw_fault_work.work);
1885 u32 fw_state, dma_state, status;
1886
1887
1888 fw_state = instance->instancet->read_fw_status_reg(instance) &
1889 MFI_STATE_MASK;
1890
1891 if (fw_state == MFI_STATE_FAULT) {
1892 dma_state = instance->instancet->read_fw_status_reg(instance) &
1893 MFI_STATE_DMADONE;
1894
1895 if (instance->crash_dump_drv_support &&
1896 instance->crash_dump_app_support && dma_state) {
1897 megasas_fusion_crash_dump(instance);
1898 } else {
1899 if (instance->unload == 0) {
1900 status = megasas_reset_fusion(instance->host, 0);
1901 if (status != SUCCESS) {
1902 dev_err(&instance->pdev->dev,
1903 "Failed from %s %d, do not re-arm timer\n",
1904 __func__, __LINE__);
1905 return;
1906 }
1907 }
1908 }
1909 }
1910
1911 if (instance->fw_fault_work_q)
1912 queue_delayed_work(instance->fw_fault_work_q,
1913 &instance->fw_fault_work,
1914 msecs_to_jiffies(MEGASAS_WATCHDOG_THREAD_INTERVAL));
1915}
1916
1917int
1918megasas_fusion_start_watchdog(struct megasas_instance *instance)
1919{
1920
1921 if (instance->fw_fault_work_q)
1922 return SUCCESS;
1923
1924 INIT_DELAYED_WORK(&instance->fw_fault_work, megasas_fault_detect_work);
1925
1926 snprintf(instance->fault_handler_work_q_name,
1927 sizeof(instance->fault_handler_work_q_name),
1928 "poll_megasas%d_status", instance->host->host_no);
1929
1930 instance->fw_fault_work_q =
1931 create_singlethread_workqueue(instance->fault_handler_work_q_name);
1932 if (!instance->fw_fault_work_q) {
1933 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1934 __func__, __LINE__);
1935 return FAILED;
1936 }
1937
1938 queue_delayed_work(instance->fw_fault_work_q,
1939 &instance->fw_fault_work,
1940 msecs_to_jiffies(MEGASAS_WATCHDOG_THREAD_INTERVAL));
1941
1942 return SUCCESS;
1943}
1944
1945void
1946megasas_fusion_stop_watchdog(struct megasas_instance *instance)
1947{
1948 struct workqueue_struct *wq;
1949
1950 if (instance->fw_fault_work_q) {
1951 wq = instance->fw_fault_work_q;
1952 instance->fw_fault_work_q = NULL;
1953 if (!cancel_delayed_work_sync(&instance->fw_fault_work))
1954 flush_workqueue(wq);
1955 destroy_workqueue(wq);
1956 }
1957}
1958
1959
1960
1961
1962
1963
1964
1965
1966static void
1967map_cmd_status(struct fusion_context *fusion,
1968 struct scsi_cmnd *scmd, u8 status, u8 ext_status,
1969 u32 data_length, u8 *sense)
1970{
1971 u8 cmd_type;
1972 int resid;
1973
1974 cmd_type = megasas_cmd_type(scmd);
1975 switch (status) {
1976
1977 case MFI_STAT_OK:
1978 scmd->result = DID_OK << 16;
1979 break;
1980
1981 case MFI_STAT_SCSI_IO_FAILED:
1982 case MFI_STAT_LD_INIT_IN_PROGRESS:
1983 scmd->result = (DID_ERROR << 16) | ext_status;
1984 break;
1985
1986 case MFI_STAT_SCSI_DONE_WITH_ERROR:
1987
1988 scmd->result = (DID_OK << 16) | ext_status;
1989 if (ext_status == SAM_STAT_CHECK_CONDITION) {
1990 memset(scmd->sense_buffer, 0,
1991 SCSI_SENSE_BUFFERSIZE);
1992 memcpy(scmd->sense_buffer, sense,
1993 SCSI_SENSE_BUFFERSIZE);
1994 scmd->result |= DRIVER_SENSE << 24;
1995 }
1996
1997
1998
1999
2000
2001
2002
2003 resid = (scsi_bufflen(scmd) - data_length);
2004 scsi_set_resid(scmd, resid);
2005
2006 if (resid &&
2007 ((cmd_type == READ_WRITE_LDIO) ||
2008 (cmd_type == READ_WRITE_SYSPDIO)))
2009 scmd_printk(KERN_INFO, scmd, "BRCM Debug mfi stat 0x%x, data len"
2010 " requested/completed 0x%x/0x%x\n",
2011 status, scsi_bufflen(scmd), data_length);
2012 break;
2013
2014 case MFI_STAT_LD_OFFLINE:
2015 case MFI_STAT_DEVICE_NOT_FOUND:
2016 scmd->result = DID_BAD_TARGET << 16;
2017 break;
2018 case MFI_STAT_CONFIG_SEQ_MISMATCH:
2019 scmd->result = DID_IMM_RETRY << 16;
2020 break;
2021 default:
2022 scmd->result = DID_ERROR << 16;
2023 break;
2024 }
2025}
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038static bool
2039megasas_is_prp_possible(struct megasas_instance *instance,
2040 struct scsi_cmnd *scmd, int sge_count)
2041{
2042 int i;
2043 u32 data_length = 0;
2044 struct scatterlist *sg_scmd;
2045 bool build_prp = false;
2046 u32 mr_nvme_pg_size;
2047
2048 mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
2049 MR_DEFAULT_NVME_PAGE_SIZE);
2050 data_length = scsi_bufflen(scmd);
2051 sg_scmd = scsi_sglist(scmd);
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062 if (data_length > (mr_nvme_pg_size * 5)) {
2063 build_prp = true;
2064 } else if ((data_length > (mr_nvme_pg_size * 4)) &&
2065 (data_length <= (mr_nvme_pg_size * 5))) {
2066
2067 if (sg_dma_len(sg_scmd) < (data_length - (mr_nvme_pg_size * 4)))
2068 build_prp = true;
2069 }
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100 scsi_for_each_sg(scmd, sg_scmd, sge_count, i) {
2101 if ((i != 0) && (i != (sge_count - 1))) {
2102 if (mega_mod64(sg_dma_len(sg_scmd), mr_nvme_pg_size) ||
2103 mega_mod64(sg_dma_address(sg_scmd),
2104 mr_nvme_pg_size)) {
2105 build_prp = false;
2106 break;
2107 }
2108 }
2109
2110 if ((sge_count > 1) && (i == 0)) {
2111 if ((mega_mod64((sg_dma_address(sg_scmd) +
2112 sg_dma_len(sg_scmd)),
2113 mr_nvme_pg_size))) {
2114 build_prp = false;
2115 break;
2116 }
2117 }
2118
2119 if ((sge_count > 1) && (i == (sge_count - 1))) {
2120 if (mega_mod64(sg_dma_address(sg_scmd),
2121 mr_nvme_pg_size)) {
2122 build_prp = false;
2123 break;
2124 }
2125 }
2126 }
2127
2128 return build_prp;
2129}
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144static bool
2145megasas_make_prp_nvme(struct megasas_instance *instance, struct scsi_cmnd *scmd,
2146 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr,
2147 struct megasas_cmd_fusion *cmd, int sge_count)
2148{
2149 int sge_len, offset, num_prp_in_chain = 0;
2150 struct MPI25_IEEE_SGE_CHAIN64 *main_chain_element, *ptr_first_sgl;
2151 u64 *ptr_sgl;
2152 dma_addr_t ptr_sgl_phys;
2153 u64 sge_addr;
2154 u32 page_mask, page_mask_result;
2155 struct scatterlist *sg_scmd;
2156 u32 first_prp_len;
2157 bool build_prp = false;
2158 int data_len = scsi_bufflen(scmd);
2159 u32 mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
2160 MR_DEFAULT_NVME_PAGE_SIZE);
2161
2162 build_prp = megasas_is_prp_possible(instance, scmd, sge_count);
2163
2164 if (!build_prp)
2165 return false;
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179 page_mask = mr_nvme_pg_size - 1;
2180 ptr_sgl = (u64 *)cmd->sg_frame;
2181 ptr_sgl_phys = cmd->sg_frame_phys_addr;
2182 memset(ptr_sgl, 0, instance->max_chain_frame_sz);
2183
2184
2185 main_chain_element = (struct MPI25_IEEE_SGE_CHAIN64 *)
2186 ((u8 *)sgl_ptr + sizeof(struct MPI25_IEEE_SGE_CHAIN64));
2187
2188 main_chain_element->Address = cpu_to_le64(ptr_sgl_phys);
2189 main_chain_element->NextChainOffset = 0;
2190 main_chain_element->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT |
2191 IEEE_SGE_FLAGS_SYSTEM_ADDR |
2192 MPI26_IEEE_SGE_FLAGS_NSF_NVME_PRP;
2193
2194
2195 ptr_first_sgl = sgl_ptr;
2196 sg_scmd = scsi_sglist(scmd);
2197 sge_addr = sg_dma_address(sg_scmd);
2198 sge_len = sg_dma_len(sg_scmd);
2199
2200 offset = (u32)(sge_addr & page_mask);
2201 first_prp_len = mr_nvme_pg_size - offset;
2202
2203 ptr_first_sgl->Address = cpu_to_le64(sge_addr);
2204 ptr_first_sgl->Length = cpu_to_le32(first_prp_len);
2205
2206 data_len -= first_prp_len;
2207
2208 if (sge_len > first_prp_len) {
2209 sge_addr += first_prp_len;
2210 sge_len -= first_prp_len;
2211 } else if (sge_len == first_prp_len) {
2212 sg_scmd = sg_next(sg_scmd);
2213 sge_addr = sg_dma_address(sg_scmd);
2214 sge_len = sg_dma_len(sg_scmd);
2215 }
2216
2217 for (;;) {
2218 offset = (u32)(sge_addr & page_mask);
2219
2220
2221 page_mask_result = (uintptr_t)(ptr_sgl + 1) & page_mask;
2222 if (unlikely(!page_mask_result)) {
2223 scmd_printk(KERN_NOTICE,
2224 scmd, "page boundary ptr_sgl: 0x%p\n",
2225 ptr_sgl);
2226 ptr_sgl_phys += 8;
2227 *ptr_sgl = cpu_to_le64(ptr_sgl_phys);
2228 ptr_sgl++;
2229 num_prp_in_chain++;
2230 }
2231
2232 *ptr_sgl = cpu_to_le64(sge_addr);
2233 ptr_sgl++;
2234 ptr_sgl_phys += 8;
2235 num_prp_in_chain++;
2236
2237 sge_addr += mr_nvme_pg_size;
2238 sge_len -= mr_nvme_pg_size;
2239 data_len -= mr_nvme_pg_size;
2240
2241 if (data_len <= 0)
2242 break;
2243
2244 if (sge_len > 0)
2245 continue;
2246
2247 sg_scmd = sg_next(sg_scmd);
2248 sge_addr = sg_dma_address(sg_scmd);
2249 sge_len = sg_dma_len(sg_scmd);
2250 }
2251
2252 main_chain_element->Length =
2253 cpu_to_le32(num_prp_in_chain * sizeof(u64));
2254
2255 return build_prp;
2256}
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267static void
2268megasas_make_sgl_fusion(struct megasas_instance *instance,
2269 struct scsi_cmnd *scp,
2270 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr,
2271 struct megasas_cmd_fusion *cmd, int sge_count)
2272{
2273 int i, sg_processed;
2274 struct scatterlist *os_sgl;
2275 struct fusion_context *fusion;
2276
2277 fusion = instance->ctrl_context;
2278
2279 if (instance->adapter_type >= INVADER_SERIES) {
2280 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr_end = sgl_ptr;
2281 sgl_ptr_end += fusion->max_sge_in_main_msg - 1;
2282 sgl_ptr_end->Flags = 0;
2283 }
2284
2285 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
2286 sgl_ptr->Length = cpu_to_le32(sg_dma_len(os_sgl));
2287 sgl_ptr->Address = cpu_to_le64(sg_dma_address(os_sgl));
2288 sgl_ptr->Flags = 0;
2289 if (instance->adapter_type >= INVADER_SERIES)
2290 if (i == sge_count - 1)
2291 sgl_ptr->Flags = IEEE_SGE_FLAGS_END_OF_LIST;
2292 sgl_ptr++;
2293 sg_processed = i + 1;
2294
2295 if ((sg_processed == (fusion->max_sge_in_main_msg - 1)) &&
2296 (sge_count > fusion->max_sge_in_main_msg)) {
2297
2298 struct MPI25_IEEE_SGE_CHAIN64 *sg_chain;
2299 if (instance->adapter_type >= INVADER_SERIES) {
2300 if ((le16_to_cpu(cmd->io_request->IoFlags) &
2301 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH) !=
2302 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH)
2303 cmd->io_request->ChainOffset =
2304 fusion->
2305 chain_offset_io_request;
2306 else
2307 cmd->io_request->ChainOffset = 0;
2308 } else
2309 cmd->io_request->ChainOffset =
2310 fusion->chain_offset_io_request;
2311
2312 sg_chain = sgl_ptr;
2313
2314 sg_chain->NextChainOffset = 0;
2315 if (instance->adapter_type >= INVADER_SERIES)
2316 sg_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT;
2317 else
2318 sg_chain->Flags =
2319 (IEEE_SGE_FLAGS_CHAIN_ELEMENT |
2320 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR);
2321 sg_chain->Length = cpu_to_le32((sizeof(union MPI2_SGE_IO_UNION) * (sge_count - sg_processed)));
2322 sg_chain->Address = cpu_to_le64(cmd->sg_frame_phys_addr);
2323
2324 sgl_ptr =
2325 (struct MPI25_IEEE_SGE_CHAIN64 *)cmd->sg_frame;
2326 memset(sgl_ptr, 0, instance->max_chain_frame_sz);
2327 }
2328 }
2329}
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344static
2345int megasas_make_sgl(struct megasas_instance *instance, struct scsi_cmnd *scp,
2346 struct megasas_cmd_fusion *cmd)
2347{
2348 int sge_count;
2349 bool build_prp = false;
2350 struct MPI25_IEEE_SGE_CHAIN64 *sgl_chain64;
2351
2352 sge_count = scsi_dma_map(scp);
2353
2354 if ((sge_count > instance->max_num_sge) || (sge_count <= 0))
2355 return sge_count;
2356
2357 sgl_chain64 = (struct MPI25_IEEE_SGE_CHAIN64 *)&cmd->io_request->SGL;
2358 if ((le16_to_cpu(cmd->io_request->IoFlags) &
2359 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH) &&
2360 (cmd->pd_interface == NVME_PD))
2361 build_prp = megasas_make_prp_nvme(instance, scp, sgl_chain64,
2362 cmd, sge_count);
2363
2364 if (!build_prp)
2365 megasas_make_sgl_fusion(instance, scp, sgl_chain64,
2366 cmd, sge_count);
2367
2368 return sge_count;
2369}
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379static void
2380megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len,
2381 struct IO_REQUEST_INFO *io_info, struct scsi_cmnd *scp,
2382 struct MR_DRV_RAID_MAP_ALL *local_map_ptr, u32 ref_tag)
2383{
2384 struct MR_LD_RAID *raid;
2385 u16 ld;
2386 u64 start_blk = io_info->pdBlock;
2387 u8 *cdb = io_request->CDB.CDB32;
2388 u32 num_blocks = io_info->numBlocks;
2389 u8 opcode = 0, flagvals = 0, groupnum = 0, control = 0;
2390
2391
2392 ld = MR_TargetIdToLdGet(io_info->ldTgtId, local_map_ptr);
2393 raid = MR_LdRaidGet(ld, local_map_ptr);
2394 if (raid->capability.ldPiMode == MR_PROT_INFO_TYPE_CONTROLLER) {
2395 memset(cdb, 0, sizeof(io_request->CDB.CDB32));
2396 cdb[0] = MEGASAS_SCSI_VARIABLE_LENGTH_CMD;
2397 cdb[7] = MEGASAS_SCSI_ADDL_CDB_LEN;
2398
2399 if (scp->sc_data_direction == DMA_FROM_DEVICE)
2400 cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_READ32;
2401 else
2402 cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_WRITE32;
2403 cdb[10] = MEGASAS_RD_WR_PROTECT_CHECK_ALL;
2404
2405
2406 cdb[12] = (u8)((start_blk >> 56) & 0xff);
2407 cdb[13] = (u8)((start_blk >> 48) & 0xff);
2408 cdb[14] = (u8)((start_blk >> 40) & 0xff);
2409 cdb[15] = (u8)((start_blk >> 32) & 0xff);
2410 cdb[16] = (u8)((start_blk >> 24) & 0xff);
2411 cdb[17] = (u8)((start_blk >> 16) & 0xff);
2412 cdb[18] = (u8)((start_blk >> 8) & 0xff);
2413 cdb[19] = (u8)(start_blk & 0xff);
2414
2415
2416 io_request->CDB.EEDP32.PrimaryReferenceTag =
2417 cpu_to_be32(ref_tag);
2418 io_request->CDB.EEDP32.PrimaryApplicationTagMask = cpu_to_be16(0xffff);
2419 io_request->IoFlags = cpu_to_le16(32);
2420
2421
2422 cdb[28] = (u8)((num_blocks >> 24) & 0xff);
2423 cdb[29] = (u8)((num_blocks >> 16) & 0xff);
2424 cdb[30] = (u8)((num_blocks >> 8) & 0xff);
2425 cdb[31] = (u8)(num_blocks & 0xff);
2426
2427
2428 if (scp->sc_data_direction == DMA_FROM_DEVICE) {
2429 io_request->EEDPFlags = cpu_to_le16(
2430 MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
2431 MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
2432 MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP |
2433 MPI2_SCSIIO_EEDPFLAGS_CHECK_APPTAG |
2434 MPI25_SCSIIO_EEDPFLAGS_DO_NOT_DISABLE_MODE |
2435 MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD);
2436 } else {
2437 io_request->EEDPFlags = cpu_to_le16(
2438 MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
2439 MPI2_SCSIIO_EEDPFLAGS_INSERT_OP);
2440 }
2441 io_request->Control |= cpu_to_le32((0x4 << 26));
2442 io_request->EEDPBlockSize = cpu_to_le32(scp->device->sector_size);
2443 } else {
2444
2445 if (((cdb_len == 12) || (cdb_len == 16)) &&
2446 (start_blk <= 0xffffffff)) {
2447 if (cdb_len == 16) {
2448 opcode = cdb[0] == READ_16 ? READ_10 : WRITE_10;
2449 flagvals = cdb[1];
2450 groupnum = cdb[14];
2451 control = cdb[15];
2452 } else {
2453 opcode = cdb[0] == READ_12 ? READ_10 : WRITE_10;
2454 flagvals = cdb[1];
2455 groupnum = cdb[10];
2456 control = cdb[11];
2457 }
2458
2459 memset(cdb, 0, sizeof(io_request->CDB.CDB32));
2460
2461 cdb[0] = opcode;
2462 cdb[1] = flagvals;
2463 cdb[6] = groupnum;
2464 cdb[9] = control;
2465
2466
2467 cdb[8] = (u8)(num_blocks & 0xff);
2468 cdb[7] = (u8)((num_blocks >> 8) & 0xff);
2469
2470 io_request->IoFlags = cpu_to_le16(10);
2471 cdb_len = 10;
2472 } else if ((cdb_len < 16) && (start_blk > 0xffffffff)) {
2473
2474 switch (cdb_len) {
2475 case 6:
2476 opcode = cdb[0] == READ_6 ? READ_16 : WRITE_16;
2477 control = cdb[5];
2478 break;
2479 case 10:
2480 opcode =
2481 cdb[0] == READ_10 ? READ_16 : WRITE_16;
2482 flagvals = cdb[1];
2483 groupnum = cdb[6];
2484 control = cdb[9];
2485 break;
2486 case 12:
2487 opcode =
2488 cdb[0] == READ_12 ? READ_16 : WRITE_16;
2489 flagvals = cdb[1];
2490 groupnum = cdb[10];
2491 control = cdb[11];
2492 break;
2493 }
2494
2495 memset(cdb, 0, sizeof(io_request->CDB.CDB32));
2496
2497 cdb[0] = opcode;
2498 cdb[1] = flagvals;
2499 cdb[14] = groupnum;
2500 cdb[15] = control;
2501
2502
2503 cdb[13] = (u8)(num_blocks & 0xff);
2504 cdb[12] = (u8)((num_blocks >> 8) & 0xff);
2505 cdb[11] = (u8)((num_blocks >> 16) & 0xff);
2506 cdb[10] = (u8)((num_blocks >> 24) & 0xff);
2507
2508 io_request->IoFlags = cpu_to_le16(16);
2509 cdb_len = 16;
2510 }
2511
2512
2513 switch (cdb_len) {
2514 case 6:
2515 {
2516 u8 val = cdb[1] & 0xE0;
2517 cdb[3] = (u8)(start_blk & 0xff);
2518 cdb[2] = (u8)((start_blk >> 8) & 0xff);
2519 cdb[1] = val | ((u8)(start_blk >> 16) & 0x1f);
2520 break;
2521 }
2522 case 10:
2523 cdb[5] = (u8)(start_blk & 0xff);
2524 cdb[4] = (u8)((start_blk >> 8) & 0xff);
2525 cdb[3] = (u8)((start_blk >> 16) & 0xff);
2526 cdb[2] = (u8)((start_blk >> 24) & 0xff);
2527 break;
2528 case 12:
2529 cdb[5] = (u8)(start_blk & 0xff);
2530 cdb[4] = (u8)((start_blk >> 8) & 0xff);
2531 cdb[3] = (u8)((start_blk >> 16) & 0xff);
2532 cdb[2] = (u8)((start_blk >> 24) & 0xff);
2533 break;
2534 case 16:
2535 cdb[9] = (u8)(start_blk & 0xff);
2536 cdb[8] = (u8)((start_blk >> 8) & 0xff);
2537 cdb[7] = (u8)((start_blk >> 16) & 0xff);
2538 cdb[6] = (u8)((start_blk >> 24) & 0xff);
2539 cdb[5] = (u8)((start_blk >> 32) & 0xff);
2540 cdb[4] = (u8)((start_blk >> 40) & 0xff);
2541 cdb[3] = (u8)((start_blk >> 48) & 0xff);
2542 cdb[2] = (u8)((start_blk >> 56) & 0xff);
2543 break;
2544 }
2545 }
2546}
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557static void megasas_stream_detect(struct megasas_instance *instance,
2558 struct megasas_cmd_fusion *cmd,
2559 struct IO_REQUEST_INFO *io_info)
2560{
2561 struct fusion_context *fusion = instance->ctrl_context;
2562 u32 device_id = io_info->ldTgtId;
2563 struct LD_STREAM_DETECT *current_ld_sd
2564 = fusion->stream_detect_by_ld[device_id];
2565 u32 *track_stream = ¤t_ld_sd->mru_bit_map, stream_num;
2566 u32 shifted_values, unshifted_values;
2567 u32 index_value_mask, shifted_values_mask;
2568 int i;
2569 bool is_read_ahead = false;
2570 struct STREAM_DETECT *current_sd;
2571
2572 for (i = 0; i < MAX_STREAMS_TRACKED; ++i) {
2573 stream_num = (*track_stream >>
2574 (i * BITS_PER_INDEX_STREAM)) &
2575 STREAM_MASK;
2576 current_sd = ¤t_ld_sd->stream_track[stream_num];
2577
2578
2579
2580
2581 if ((current_sd->next_seq_lba) &&
2582 (io_info->ldStartBlock >= current_sd->next_seq_lba) &&
2583 (io_info->ldStartBlock <= (current_sd->next_seq_lba + 32)) &&
2584 (current_sd->is_read == io_info->isRead)) {
2585
2586 if ((io_info->ldStartBlock != current_sd->next_seq_lba) &&
2587 ((!io_info->isRead) || (!is_read_ahead)))
2588
2589
2590
2591
2592 continue;
2593
2594 SET_STREAM_DETECTED(cmd->io_request->RaidContext.raid_context_g35);
2595 current_sd->next_seq_lba =
2596 io_info->ldStartBlock + io_info->numBlocks;
2597
2598
2599
2600 shifted_values_mask =
2601 (1 << i * BITS_PER_INDEX_STREAM) - 1;
2602 shifted_values = ((*track_stream & shifted_values_mask)
2603 << BITS_PER_INDEX_STREAM);
2604 index_value_mask =
2605 STREAM_MASK << i * BITS_PER_INDEX_STREAM;
2606 unshifted_values =
2607 *track_stream & ~(shifted_values_mask |
2608 index_value_mask);
2609 *track_stream =
2610 unshifted_values | shifted_values | stream_num;
2611 return;
2612 }
2613 }
2614
2615
2616
2617
2618 stream_num = (*track_stream >>
2619 ((MAX_STREAMS_TRACKED - 1) * BITS_PER_INDEX_STREAM)) &
2620 STREAM_MASK;
2621 current_sd = ¤t_ld_sd->stream_track[stream_num];
2622 current_sd->is_read = io_info->isRead;
2623 current_sd->next_seq_lba = io_info->ldStartBlock + io_info->numBlocks;
2624 *track_stream = (((*track_stream & ZERO_LAST_STREAM) << 4) | stream_num);
2625 return;
2626}
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639static void
2640megasas_set_raidflag_cpu_affinity(struct fusion_context *fusion,
2641 union RAID_CONTEXT_UNION *praid_context,
2642 struct MR_LD_RAID *raid, bool fp_possible,
2643 u8 is_read, u32 scsi_buff_len)
2644{
2645 u8 cpu_sel = MR_RAID_CTX_CPUSEL_0;
2646 struct RAID_CONTEXT_G35 *rctx_g35;
2647
2648 rctx_g35 = &praid_context->raid_context_g35;
2649 if (fp_possible) {
2650 if (is_read) {
2651 if ((raid->cpuAffinity.pdRead.cpu0) &&
2652 (raid->cpuAffinity.pdRead.cpu1))
2653 cpu_sel = MR_RAID_CTX_CPUSEL_FCFS;
2654 else if (raid->cpuAffinity.pdRead.cpu1)
2655 cpu_sel = MR_RAID_CTX_CPUSEL_1;
2656 } else {
2657 if ((raid->cpuAffinity.pdWrite.cpu0) &&
2658 (raid->cpuAffinity.pdWrite.cpu1))
2659 cpu_sel = MR_RAID_CTX_CPUSEL_FCFS;
2660 else if (raid->cpuAffinity.pdWrite.cpu1)
2661 cpu_sel = MR_RAID_CTX_CPUSEL_1;
2662
2663 if ((raid->level <= 1) &&
2664 (raid->capability.fp_cache_bypass_capable)) {
2665 rctx_g35->routing_flags |=
2666 (1 << MR_RAID_CTX_ROUTINGFLAGS_SLD_SHIFT);
2667 rctx_g35->raid_flags =
2668 (MR_RAID_FLAGS_IO_SUB_TYPE_CACHE_BYPASS
2669 << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT);
2670 }
2671 }
2672 } else {
2673 if (is_read) {
2674 if ((raid->cpuAffinity.ldRead.cpu0) &&
2675 (raid->cpuAffinity.ldRead.cpu1))
2676 cpu_sel = MR_RAID_CTX_CPUSEL_FCFS;
2677 else if (raid->cpuAffinity.ldRead.cpu1)
2678 cpu_sel = MR_RAID_CTX_CPUSEL_1;
2679 } else {
2680 if ((raid->cpuAffinity.ldWrite.cpu0) &&
2681 (raid->cpuAffinity.ldWrite.cpu1))
2682 cpu_sel = MR_RAID_CTX_CPUSEL_FCFS;
2683 else if (raid->cpuAffinity.ldWrite.cpu1)
2684 cpu_sel = MR_RAID_CTX_CPUSEL_1;
2685
2686 if (is_stream_detected(rctx_g35) &&
2687 ((raid->level == 5) || (raid->level == 6)) &&
2688 (raid->writeMode == MR_RL_WRITE_THROUGH_MODE) &&
2689 (cpu_sel == MR_RAID_CTX_CPUSEL_FCFS))
2690 cpu_sel = MR_RAID_CTX_CPUSEL_0;
2691 }
2692 }
2693
2694 rctx_g35->routing_flags |=
2695 (cpu_sel << MR_RAID_CTX_ROUTINGFLAGS_CPUSEL_SHIFT);
2696
2697
2698
2699
2700
2701 if ((fusion->pcie_bw_limitation) && (raid->level == 1) && (!is_read) &&
2702 (scsi_buff_len > MR_LARGE_IO_MIN_SIZE)) {
2703 praid_context->raid_context_g35.raid_flags =
2704 (MR_RAID_FLAGS_IO_SUB_TYPE_LDIO_BW_LIMIT
2705 << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT);
2706 }
2707}
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718static void
2719megasas_build_ldio_fusion(struct megasas_instance *instance,
2720 struct scsi_cmnd *scp,
2721 struct megasas_cmd_fusion *cmd)
2722{
2723 bool fp_possible;
2724 u16 ld;
2725 u32 start_lba_lo, start_lba_hi, device_id, datalength = 0;
2726 u32 scsi_buff_len;
2727 struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
2728 struct IO_REQUEST_INFO io_info;
2729 struct fusion_context *fusion;
2730 struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
2731 u8 *raidLUN;
2732 unsigned long spinlock_flags;
2733 struct MR_LD_RAID *raid = NULL;
2734 struct MR_PRIV_DEVICE *mrdev_priv;
2735 struct RAID_CONTEXT *rctx;
2736 struct RAID_CONTEXT_G35 *rctx_g35;
2737
2738 device_id = MEGASAS_DEV_INDEX(scp);
2739
2740 fusion = instance->ctrl_context;
2741
2742 io_request = cmd->io_request;
2743 rctx = &io_request->RaidContext.raid_context;
2744 rctx_g35 = &io_request->RaidContext.raid_context_g35;
2745
2746 rctx->virtual_disk_tgt_id = cpu_to_le16(device_id);
2747 rctx->status = 0;
2748 rctx->ex_status = 0;
2749
2750 start_lba_lo = 0;
2751 start_lba_hi = 0;
2752 fp_possible = false;
2753
2754
2755
2756
2757 if (scp->cmd_len == 6) {
2758 datalength = (u32) scp->cmnd[4];
2759 start_lba_lo = ((u32) scp->cmnd[1] << 16) |
2760 ((u32) scp->cmnd[2] << 8) | (u32) scp->cmnd[3];
2761
2762 start_lba_lo &= 0x1FFFFF;
2763 }
2764
2765
2766
2767
2768 else if (scp->cmd_len == 10) {
2769 datalength = (u32) scp->cmnd[8] |
2770 ((u32) scp->cmnd[7] << 8);
2771 start_lba_lo = ((u32) scp->cmnd[2] << 24) |
2772 ((u32) scp->cmnd[3] << 16) |
2773 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
2774 }
2775
2776
2777
2778
2779 else if (scp->cmd_len == 12) {
2780 datalength = ((u32) scp->cmnd[6] << 24) |
2781 ((u32) scp->cmnd[7] << 16) |
2782 ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
2783 start_lba_lo = ((u32) scp->cmnd[2] << 24) |
2784 ((u32) scp->cmnd[3] << 16) |
2785 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
2786 }
2787
2788
2789
2790
2791 else if (scp->cmd_len == 16) {
2792 datalength = ((u32) scp->cmnd[10] << 24) |
2793 ((u32) scp->cmnd[11] << 16) |
2794 ((u32) scp->cmnd[12] << 8) | (u32) scp->cmnd[13];
2795 start_lba_lo = ((u32) scp->cmnd[6] << 24) |
2796 ((u32) scp->cmnd[7] << 16) |
2797 ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
2798
2799 start_lba_hi = ((u32) scp->cmnd[2] << 24) |
2800 ((u32) scp->cmnd[3] << 16) |
2801 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
2802 }
2803
2804 memset(&io_info, 0, sizeof(struct IO_REQUEST_INFO));
2805 io_info.ldStartBlock = ((u64)start_lba_hi << 32) | start_lba_lo;
2806 io_info.numBlocks = datalength;
2807 io_info.ldTgtId = device_id;
2808 io_info.r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
2809 scsi_buff_len = scsi_bufflen(scp);
2810 io_request->DataLength = cpu_to_le32(scsi_buff_len);
2811 io_info.data_arms = 1;
2812
2813 if (scp->sc_data_direction == DMA_FROM_DEVICE)
2814 io_info.isRead = 1;
2815
2816 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
2817 ld = MR_TargetIdToLdGet(device_id, local_map_ptr);
2818
2819 if (ld < instance->fw_supported_vd_count)
2820 raid = MR_LdRaidGet(ld, local_map_ptr);
2821
2822 if (!raid || (!fusion->fast_path_io)) {
2823 rctx->reg_lock_flags = 0;
2824 fp_possible = false;
2825 } else {
2826 if (MR_BuildRaidContext(instance, &io_info, rctx,
2827 local_map_ptr, &raidLUN))
2828 fp_possible = (io_info.fpOkForIo > 0) ? true : false;
2829 }
2830
2831 if ((instance->perf_mode == MR_BALANCED_PERF_MODE) &&
2832 atomic_read(&scp->device->device_busy) >
2833 (io_info.data_arms * MR_DEVICE_HIGH_IOPS_DEPTH))
2834 cmd->request_desc->SCSIIO.MSIxIndex =
2835 mega_mod64((atomic64_add_return(1, &instance->high_iops_outstanding) /
2836 MR_HIGH_IOPS_BATCH_COUNT), instance->low_latency_index_start);
2837 else if (instance->msix_load_balance)
2838 cmd->request_desc->SCSIIO.MSIxIndex =
2839 (mega_mod64(atomic64_add_return(1, &instance->total_io_count),
2840 instance->msix_vectors));
2841 else
2842 cmd->request_desc->SCSIIO.MSIxIndex =
2843 instance->reply_map[raw_smp_processor_id()];
2844
2845 if (instance->adapter_type >= VENTURA_SERIES) {
2846
2847
2848
2849
2850
2851
2852
2853
2854 if (io_info.r1_alt_dev_handle != MR_DEVHANDLE_INVALID) {
2855 mrdev_priv = scp->device->hostdata;
2856
2857 if (atomic_inc_return(&instance->fw_outstanding) >
2858 (instance->host->can_queue)) {
2859 fp_possible = false;
2860 atomic_dec(&instance->fw_outstanding);
2861 } else if (fusion->pcie_bw_limitation &&
2862 ((scsi_buff_len > MR_LARGE_IO_MIN_SIZE) ||
2863 (atomic_dec_if_positive(&mrdev_priv->r1_ldio_hint) > 0))) {
2864 fp_possible = false;
2865 atomic_dec(&instance->fw_outstanding);
2866 if (scsi_buff_len > MR_LARGE_IO_MIN_SIZE)
2867 atomic_set(&mrdev_priv->r1_ldio_hint,
2868 instance->r1_ldio_hint_default);
2869 }
2870 }
2871
2872 if (!fp_possible ||
2873 (io_info.isRead && io_info.ra_capable)) {
2874 spin_lock_irqsave(&instance->stream_lock,
2875 spinlock_flags);
2876 megasas_stream_detect(instance, cmd, &io_info);
2877 spin_unlock_irqrestore(&instance->stream_lock,
2878 spinlock_flags);
2879
2880
2881
2882 if (is_stream_detected(rctx_g35))
2883 fp_possible = false;
2884 }
2885
2886
2887 if (raid)
2888 megasas_set_raidflag_cpu_affinity(fusion, &io_request->RaidContext,
2889 raid, fp_possible, io_info.isRead,
2890 scsi_buff_len);
2891 else
2892 rctx_g35->routing_flags |=
2893 (MR_RAID_CTX_CPUSEL_0 << MR_RAID_CTX_ROUTINGFLAGS_CPUSEL_SHIFT);
2894 }
2895
2896 if (fp_possible) {
2897 megasas_set_pd_lba(io_request, scp->cmd_len, &io_info, scp,
2898 local_map_ptr, start_lba_lo);
2899 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
2900 cmd->request_desc->SCSIIO.RequestFlags =
2901 (MPI2_REQ_DESCRIPT_FLAGS_FP_IO
2902 << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2903 if (instance->adapter_type == INVADER_SERIES) {
2904 rctx->type = MPI2_TYPE_CUDA;
2905 rctx->nseg = 0x1;
2906 io_request->IoFlags |= cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
2907 rctx->reg_lock_flags |=
2908 (MR_RL_FLAGS_GRANT_DESTINATION_CUDA |
2909 MR_RL_FLAGS_SEQ_NUM_ENABLE);
2910 } else if (instance->adapter_type >= VENTURA_SERIES) {
2911 rctx_g35->nseg_type |= (1 << RAID_CONTEXT_NSEG_SHIFT);
2912 rctx_g35->nseg_type |= (MPI2_TYPE_CUDA << RAID_CONTEXT_TYPE_SHIFT);
2913 rctx_g35->routing_flags |= (1 << MR_RAID_CTX_ROUTINGFLAGS_SQN_SHIFT);
2914 io_request->IoFlags |=
2915 cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
2916 }
2917 if (fusion->load_balance_info &&
2918 (fusion->load_balance_info[device_id].loadBalanceFlag) &&
2919 (io_info.isRead)) {
2920 io_info.devHandle =
2921 get_updated_dev_handle(instance,
2922 &fusion->load_balance_info[device_id],
2923 &io_info, local_map_ptr);
2924 scp->SCp.Status |= MEGASAS_LOAD_BALANCE_FLAG;
2925 cmd->pd_r1_lb = io_info.pd_after_lb;
2926 if (instance->adapter_type >= VENTURA_SERIES)
2927 rctx_g35->span_arm = io_info.span_arm;
2928 else
2929 rctx->span_arm = io_info.span_arm;
2930
2931 } else
2932 scp->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG;
2933
2934 if (instance->adapter_type >= VENTURA_SERIES)
2935 cmd->r1_alt_dev_handle = io_info.r1_alt_dev_handle;
2936 else
2937 cmd->r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
2938
2939 if ((raidLUN[0] == 1) &&
2940 (local_map_ptr->raidMap.devHndlInfo[io_info.pd_after_lb].validHandles > 1)) {
2941 instance->dev_handle = !(instance->dev_handle);
2942 io_info.devHandle =
2943 local_map_ptr->raidMap.devHndlInfo[io_info.pd_after_lb].devHandle[instance->dev_handle];
2944 }
2945
2946 cmd->request_desc->SCSIIO.DevHandle = io_info.devHandle;
2947 io_request->DevHandle = io_info.devHandle;
2948 cmd->pd_interface = io_info.pd_interface;
2949
2950 memcpy(io_request->LUN, raidLUN, 8);
2951 } else {
2952 rctx->timeout_value =
2953 cpu_to_le16(local_map_ptr->raidMap.fpPdIoTimeoutSec);
2954 cmd->request_desc->SCSIIO.RequestFlags =
2955 (MEGASAS_REQ_DESCRIPT_FLAGS_LD_IO
2956 << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2957 if (instance->adapter_type == INVADER_SERIES) {
2958 if (io_info.do_fp_rlbypass ||
2959 (rctx->reg_lock_flags == REGION_TYPE_UNUSED))
2960 cmd->request_desc->SCSIIO.RequestFlags =
2961 (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
2962 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2963 rctx->type = MPI2_TYPE_CUDA;
2964 rctx->reg_lock_flags |=
2965 (MR_RL_FLAGS_GRANT_DESTINATION_CPU0 |
2966 MR_RL_FLAGS_SEQ_NUM_ENABLE);
2967 rctx->nseg = 0x1;
2968 } else if (instance->adapter_type >= VENTURA_SERIES) {
2969 rctx_g35->routing_flags |= (1 << MR_RAID_CTX_ROUTINGFLAGS_SQN_SHIFT);
2970 rctx_g35->nseg_type |= (1 << RAID_CONTEXT_NSEG_SHIFT);
2971 rctx_g35->nseg_type |= (MPI2_TYPE_CUDA << RAID_CONTEXT_TYPE_SHIFT);
2972 }
2973 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
2974 io_request->DevHandle = cpu_to_le16(device_id);
2975
2976 }
2977}
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987static void megasas_build_ld_nonrw_fusion(struct megasas_instance *instance,
2988 struct scsi_cmnd *scmd, struct megasas_cmd_fusion *cmd)
2989{
2990 u32 device_id;
2991 struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
2992 u16 ld;
2993 struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
2994 struct fusion_context *fusion = instance->ctrl_context;
2995 u8 span, physArm;
2996 __le16 devHandle;
2997 u32 arRef, pd;
2998 struct MR_LD_RAID *raid;
2999 struct RAID_CONTEXT *pRAID_Context;
3000 u8 fp_possible = 1;
3001
3002 io_request = cmd->io_request;
3003 device_id = MEGASAS_DEV_INDEX(scmd);
3004 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
3005 io_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
3006
3007 pRAID_Context = &io_request->RaidContext.raid_context;
3008
3009 pRAID_Context->virtual_disk_tgt_id = cpu_to_le16(device_id);
3010 pRAID_Context->reg_lock_row_lba = 0;
3011 pRAID_Context->reg_lock_length = 0;
3012
3013 if (fusion->fast_path_io && (
3014 device_id < instance->fw_supported_vd_count)) {
3015
3016 ld = MR_TargetIdToLdGet(device_id, local_map_ptr);
3017 if (ld >= instance->fw_supported_vd_count - 1)
3018 fp_possible = 0;
3019 else {
3020 raid = MR_LdRaidGet(ld, local_map_ptr);
3021 if (!(raid->capability.fpNonRWCapable))
3022 fp_possible = 0;
3023 }
3024 } else
3025 fp_possible = 0;
3026
3027 if (!fp_possible) {
3028 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
3029 io_request->DevHandle = cpu_to_le16(device_id);
3030 io_request->LUN[1] = scmd->device->lun;
3031 pRAID_Context->timeout_value =
3032 cpu_to_le16 (scmd->request->timeout / HZ);
3033 cmd->request_desc->SCSIIO.RequestFlags =
3034 (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
3035 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
3036 } else {
3037
3038
3039 pRAID_Context->config_seq_num = raid->seqNum;
3040 if (instance->adapter_type < VENTURA_SERIES)
3041 pRAID_Context->reg_lock_flags = REGION_TYPE_SHARED_READ;
3042 pRAID_Context->timeout_value =
3043 cpu_to_le16(raid->fpIoTimeoutForLd);
3044
3045
3046
3047 span = physArm = 0;
3048 arRef = MR_LdSpanArrayGet(ld, span, local_map_ptr);
3049 pd = MR_ArPdGet(arRef, physArm, local_map_ptr);
3050 devHandle = MR_PdDevHandleGet(pd, local_map_ptr);
3051
3052
3053 cmd->request_desc->SCSIIO.RequestFlags =
3054 (MPI2_REQ_DESCRIPT_FLAGS_FP_IO <<
3055 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
3056 cmd->request_desc->SCSIIO.DevHandle = devHandle;
3057
3058
3059 memcpy(io_request->LUN, raid->LUN, 8);
3060
3061
3062 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
3063 io_request->DevHandle = devHandle;
3064 }
3065}
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076static void
3077megasas_build_syspd_fusion(struct megasas_instance *instance,
3078 struct scsi_cmnd *scmd, struct megasas_cmd_fusion *cmd,
3079 bool fp_possible)
3080{
3081 u32 device_id;
3082 struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
3083 u16 pd_index = 0;
3084 u16 os_timeout_value;
3085 u16 timeout_limit;
3086 struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
3087 struct RAID_CONTEXT *pRAID_Context;
3088 struct MR_PD_CFG_SEQ_NUM_SYNC *pd_sync;
3089 struct MR_PRIV_DEVICE *mr_device_priv_data;
3090 struct fusion_context *fusion = instance->ctrl_context;
3091 pd_sync = (void *)fusion->pd_seq_sync[(instance->pd_seq_map_id - 1) & 1];
3092
3093 device_id = MEGASAS_DEV_INDEX(scmd);
3094 pd_index = MEGASAS_PD_INDEX(scmd);
3095 os_timeout_value = scmd->request->timeout / HZ;
3096 mr_device_priv_data = scmd->device->hostdata;
3097 cmd->pd_interface = mr_device_priv_data->interface_type;
3098
3099 io_request = cmd->io_request;
3100
3101 pRAID_Context = &io_request->RaidContext.raid_context;
3102 pRAID_Context->reg_lock_flags = 0;
3103 pRAID_Context->reg_lock_row_lba = 0;
3104 pRAID_Context->reg_lock_length = 0;
3105 io_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
3106 io_request->LUN[1] = scmd->device->lun;
3107 pRAID_Context->raid_flags = MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD
3108 << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;
3109
3110
3111 if (instance->support_seqnum_jbod_fp) {
3112 if (instance->use_seqnum_jbod_fp &&
3113 instance->pd_list[pd_index].driveType == TYPE_DISK) {
3114
3115
3116 if (instance->support_morethan256jbod)
3117 pRAID_Context->virtual_disk_tgt_id =
3118 pd_sync->seq[pd_index].pd_target_id;
3119 else
3120 pRAID_Context->virtual_disk_tgt_id =
3121 cpu_to_le16(device_id +
3122 (MAX_PHYSICAL_DEVICES - 1));
3123 pRAID_Context->config_seq_num =
3124 pd_sync->seq[pd_index].seqNum;
3125 io_request->DevHandle =
3126 pd_sync->seq[pd_index].devHandle;
3127 if (instance->adapter_type >= VENTURA_SERIES) {
3128 io_request->RaidContext.raid_context_g35.routing_flags |=
3129 (1 << MR_RAID_CTX_ROUTINGFLAGS_SQN_SHIFT);
3130 io_request->RaidContext.raid_context_g35.nseg_type |=
3131 (1 << RAID_CONTEXT_NSEG_SHIFT);
3132 io_request->RaidContext.raid_context_g35.nseg_type |=
3133 (MPI2_TYPE_CUDA << RAID_CONTEXT_TYPE_SHIFT);
3134 } else {
3135 pRAID_Context->type = MPI2_TYPE_CUDA;
3136 pRAID_Context->nseg = 0x1;
3137 pRAID_Context->reg_lock_flags |=
3138 (MR_RL_FLAGS_SEQ_NUM_ENABLE |
3139 MR_RL_FLAGS_GRANT_DESTINATION_CUDA);
3140 }
3141 } else {
3142 pRAID_Context->virtual_disk_tgt_id =
3143 cpu_to_le16(device_id +
3144 (MAX_PHYSICAL_DEVICES - 1));
3145 pRAID_Context->config_seq_num = 0;
3146 io_request->DevHandle = cpu_to_le16(0xFFFF);
3147 }
3148 } else {
3149 pRAID_Context->virtual_disk_tgt_id = cpu_to_le16(device_id);
3150 pRAID_Context->config_seq_num = 0;
3151
3152 if (fusion->fast_path_io) {
3153 local_map_ptr =
3154 fusion->ld_drv_map[(instance->map_id & 1)];
3155 io_request->DevHandle =
3156 local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
3157 } else {
3158 io_request->DevHandle = cpu_to_le16(0xFFFF);
3159 }
3160 }
3161
3162 cmd->request_desc->SCSIIO.DevHandle = io_request->DevHandle;
3163
3164 if ((instance->perf_mode == MR_BALANCED_PERF_MODE) &&
3165 atomic_read(&scmd->device->device_busy) > MR_DEVICE_HIGH_IOPS_DEPTH)
3166 cmd->request_desc->SCSIIO.MSIxIndex =
3167 mega_mod64((atomic64_add_return(1, &instance->high_iops_outstanding) /
3168 MR_HIGH_IOPS_BATCH_COUNT), instance->low_latency_index_start);
3169 else if (instance->msix_load_balance)
3170 cmd->request_desc->SCSIIO.MSIxIndex =
3171 (mega_mod64(atomic64_add_return(1, &instance->total_io_count),
3172 instance->msix_vectors));
3173 else
3174 cmd->request_desc->SCSIIO.MSIxIndex =
3175 instance->reply_map[raw_smp_processor_id()];
3176
3177 if (!fp_possible) {
3178
3179 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
3180 cmd->request_desc->SCSIIO.RequestFlags =
3181 (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
3182 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
3183 pRAID_Context->timeout_value = cpu_to_le16(os_timeout_value);
3184 pRAID_Context->virtual_disk_tgt_id = cpu_to_le16(device_id);
3185 } else {
3186 if (os_timeout_value)
3187 os_timeout_value++;
3188
3189
3190 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
3191 timeout_limit = (scmd->device->type == TYPE_DISK) ?
3192 255 : 0xFFFF;
3193 pRAID_Context->timeout_value =
3194 cpu_to_le16((os_timeout_value > timeout_limit) ?
3195 timeout_limit : os_timeout_value);
3196 if (instance->adapter_type >= INVADER_SERIES)
3197 io_request->IoFlags |=
3198 cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
3199
3200 cmd->request_desc->SCSIIO.RequestFlags =
3201 (MPI2_REQ_DESCRIPT_FLAGS_FP_IO <<
3202 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
3203 }
3204}
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
3215static int
3216megasas_build_io_fusion(struct megasas_instance *instance,
3217 struct scsi_cmnd *scp,
3218 struct megasas_cmd_fusion *cmd)
3219{
3220 int sge_count;
3221 u8 cmd_type;
3222 struct MPI2_RAID_SCSI_IO_REQUEST *io_request = cmd->io_request;
3223 struct MR_PRIV_DEVICE *mr_device_priv_data;
3224 mr_device_priv_data = scp->device->hostdata;
3225
3226
3227 memset(io_request->LUN, 0x0, 8);
3228 io_request->CDB.EEDP32.PrimaryReferenceTag = 0;
3229 io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0;
3230 io_request->EEDPFlags = 0;
3231 io_request->Control = 0;
3232 io_request->EEDPBlockSize = 0;
3233 io_request->ChainOffset = 0;
3234 io_request->RaidContext.raid_context.raid_flags = 0;
3235 io_request->RaidContext.raid_context.type = 0;
3236 io_request->RaidContext.raid_context.nseg = 0;
3237
3238 memcpy(io_request->CDB.CDB32, scp->cmnd, scp->cmd_len);
3239
3240
3241
3242
3243 io_request->IoFlags = cpu_to_le16(scp->cmd_len);
3244
3245 switch (cmd_type = megasas_cmd_type(scp)) {
3246 case READ_WRITE_LDIO:
3247 megasas_build_ldio_fusion(instance, scp, cmd);
3248 break;
3249 case NON_READ_WRITE_LDIO:
3250 megasas_build_ld_nonrw_fusion(instance, scp, cmd);
3251 break;
3252 case READ_WRITE_SYSPDIO:
3253 megasas_build_syspd_fusion(instance, scp, cmd, true);
3254 break;
3255 case NON_READ_WRITE_SYSPDIO:
3256 if (instance->secure_jbod_support ||
3257 mr_device_priv_data->is_tm_capable)
3258 megasas_build_syspd_fusion(instance, scp, cmd, false);
3259 else
3260 megasas_build_syspd_fusion(instance, scp, cmd, true);
3261 break;
3262 default:
3263 break;
3264 }
3265
3266
3267
3268
3269
3270 sge_count = megasas_make_sgl(instance, scp, cmd);
3271
3272 if (sge_count > instance->max_num_sge || (sge_count < 0)) {
3273 dev_err(&instance->pdev->dev,
3274 "%s %d sge_count (%d) is out of range. Range is: 0-%d\n",
3275 __func__, __LINE__, sge_count, instance->max_num_sge);
3276 return 1;
3277 }
3278
3279 if (instance->adapter_type >= VENTURA_SERIES) {
3280 set_num_sge(&io_request->RaidContext.raid_context_g35, sge_count);
3281 cpu_to_le16s(&io_request->RaidContext.raid_context_g35.routing_flags);
3282 cpu_to_le16s(&io_request->RaidContext.raid_context_g35.nseg_type);
3283 } else {
3284
3285
3286
3287 io_request->RaidContext.raid_context.num_sge = sge_count;
3288 io_request->RaidContext.raid_context.num_sge_ext =
3289 (u8)(sge_count >> 8);
3290 }
3291
3292 io_request->SGLFlags = cpu_to_le16(MPI2_SGE_FLAGS_64_BIT_ADDRESSING);
3293
3294 if (scp->sc_data_direction == DMA_TO_DEVICE)
3295 io_request->Control |= cpu_to_le32(MPI2_SCSIIO_CONTROL_WRITE);
3296 else if (scp->sc_data_direction == DMA_FROM_DEVICE)
3297 io_request->Control |= cpu_to_le32(MPI2_SCSIIO_CONTROL_READ);
3298
3299 io_request->SGLOffset0 =
3300 offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL) / 4;
3301
3302 io_request->SenseBufferLowAddress =
3303 cpu_to_le32(lower_32_bits(cmd->sense_phys_addr));
3304 io_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
3305
3306 cmd->scmd = scp;
3307 scp->SCp.ptr = (char *)cmd;
3308
3309 return 0;
3310}
3311
3312static union MEGASAS_REQUEST_DESCRIPTOR_UNION *
3313megasas_get_request_descriptor(struct megasas_instance *instance, u16 index)
3314{
3315 u8 *p;
3316 struct fusion_context *fusion;
3317
3318 fusion = instance->ctrl_context;
3319 p = fusion->req_frames_desc +
3320 sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) * index;
3321
3322 return (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)p;
3323}
3324
3325
3326
3327
3328
3329static void megasas_prepare_secondRaid1_IO(struct megasas_instance *instance,
3330 struct megasas_cmd_fusion *cmd,
3331 struct megasas_cmd_fusion *r1_cmd)
3332{
3333 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc, *req_desc2 = NULL;
3334 struct fusion_context *fusion;
3335 fusion = instance->ctrl_context;
3336 req_desc = cmd->request_desc;
3337
3338 memcpy(r1_cmd->io_request, cmd->io_request,
3339 (sizeof(struct MPI2_RAID_SCSI_IO_REQUEST)));
3340 memcpy(&r1_cmd->io_request->SGL, &cmd->io_request->SGL,
3341 (fusion->max_sge_in_main_msg * sizeof(union MPI2_SGE_IO_UNION)));
3342
3343 r1_cmd->io_request->SenseBufferLowAddress =
3344 cpu_to_le32(lower_32_bits(r1_cmd->sense_phys_addr));
3345 r1_cmd->scmd = cmd->scmd;
3346 req_desc2 = megasas_get_request_descriptor(instance,
3347 (r1_cmd->index - 1));
3348 req_desc2->Words = 0;
3349 r1_cmd->request_desc = req_desc2;
3350 req_desc2->SCSIIO.SMID = cpu_to_le16(r1_cmd->index);
3351 req_desc2->SCSIIO.RequestFlags = req_desc->SCSIIO.RequestFlags;
3352 r1_cmd->request_desc->SCSIIO.DevHandle = cmd->r1_alt_dev_handle;
3353 r1_cmd->io_request->DevHandle = cmd->r1_alt_dev_handle;
3354 r1_cmd->r1_alt_dev_handle = cmd->io_request->DevHandle;
3355 cmd->io_request->RaidContext.raid_context_g35.flow_specific.peer_smid =
3356 cpu_to_le16(r1_cmd->index);
3357 r1_cmd->io_request->RaidContext.raid_context_g35.flow_specific.peer_smid =
3358 cpu_to_le16(cmd->index);
3359
3360 r1_cmd->request_desc->SCSIIO.MSIxIndex =
3361 cmd->request_desc->SCSIIO.MSIxIndex;
3362
3363 r1_cmd->io_request->RaidContext.raid_context_g35.span_arm =
3364 cmd->io_request->RaidContext.raid_context_g35.span_arm + 1;
3365}
3366
3367
3368
3369
3370
3371
3372
3373static u32
3374megasas_build_and_issue_cmd_fusion(struct megasas_instance *instance,
3375 struct scsi_cmnd *scmd)
3376{
3377 struct megasas_cmd_fusion *cmd, *r1_cmd = NULL;
3378 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
3379 u32 index;
3380
3381 if ((megasas_cmd_type(scmd) == READ_WRITE_LDIO) &&
3382 instance->ldio_threshold &&
3383 (atomic_inc_return(&instance->ldio_outstanding) >
3384 instance->ldio_threshold)) {
3385 atomic_dec(&instance->ldio_outstanding);
3386 return SCSI_MLQUEUE_DEVICE_BUSY;
3387 }
3388
3389 if (atomic_inc_return(&instance->fw_outstanding) >
3390 instance->host->can_queue) {
3391 atomic_dec(&instance->fw_outstanding);
3392 return SCSI_MLQUEUE_HOST_BUSY;
3393 }
3394
3395 cmd = megasas_get_cmd_fusion(instance, scmd->request->tag);
3396
3397 if (!cmd) {
3398 atomic_dec(&instance->fw_outstanding);
3399 return SCSI_MLQUEUE_HOST_BUSY;
3400 }
3401
3402 index = cmd->index;
3403
3404 req_desc = megasas_get_request_descriptor(instance, index-1);
3405
3406 req_desc->Words = 0;
3407 cmd->request_desc = req_desc;
3408
3409 if (megasas_build_io_fusion(instance, scmd, cmd)) {
3410 megasas_return_cmd_fusion(instance, cmd);
3411 dev_err(&instance->pdev->dev, "Error building command\n");
3412 cmd->request_desc = NULL;
3413 atomic_dec(&instance->fw_outstanding);
3414 return SCSI_MLQUEUE_HOST_BUSY;
3415 }
3416
3417 req_desc = cmd->request_desc;
3418 req_desc->SCSIIO.SMID = cpu_to_le16(index);
3419
3420 if (cmd->io_request->ChainOffset != 0 &&
3421 cmd->io_request->ChainOffset != 0xF)
3422 dev_err(&instance->pdev->dev, "The chain offset value is not "
3423 "correct : %x\n", cmd->io_request->ChainOffset);
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434 if (cmd->r1_alt_dev_handle != MR_DEVHANDLE_INVALID) {
3435 r1_cmd = megasas_get_cmd_fusion(instance,
3436 (scmd->request->tag + instance->max_fw_cmds));
3437 megasas_prepare_secondRaid1_IO(instance, cmd, r1_cmd);
3438 }
3439
3440
3441
3442
3443
3444
3445 megasas_fire_cmd_fusion(instance, req_desc);
3446
3447 if (r1_cmd)
3448 megasas_fire_cmd_fusion(instance, r1_cmd->request_desc);
3449
3450
3451 return 0;
3452}
3453
3454
3455
3456
3457
3458
3459
3460
3461static inline void
3462megasas_complete_r1_command(struct megasas_instance *instance,
3463 struct megasas_cmd_fusion *cmd)
3464{
3465 u8 *sense, status, ex_status;
3466 u32 data_length;
3467 u16 peer_smid;
3468 struct fusion_context *fusion;
3469 struct megasas_cmd_fusion *r1_cmd = NULL;
3470 struct scsi_cmnd *scmd_local = NULL;
3471 struct RAID_CONTEXT_G35 *rctx_g35;
3472
3473 rctx_g35 = &cmd->io_request->RaidContext.raid_context_g35;
3474 fusion = instance->ctrl_context;
3475 peer_smid = le16_to_cpu(rctx_g35->flow_specific.peer_smid);
3476
3477 r1_cmd = fusion->cmd_list[peer_smid - 1];
3478 scmd_local = cmd->scmd;
3479 status = rctx_g35->status;
3480 ex_status = rctx_g35->ex_status;
3481 data_length = cmd->io_request->DataLength;
3482 sense = cmd->sense;
3483
3484 cmd->cmd_completed = true;
3485
3486
3487 if (r1_cmd->cmd_completed) {
3488 rctx_g35 = &r1_cmd->io_request->RaidContext.raid_context_g35;
3489 if (rctx_g35->status != MFI_STAT_OK) {
3490 status = rctx_g35->status;
3491 ex_status = rctx_g35->ex_status;
3492 data_length = r1_cmd->io_request->DataLength;
3493 sense = r1_cmd->sense;
3494 }
3495
3496 megasas_return_cmd_fusion(instance, r1_cmd);
3497 map_cmd_status(fusion, scmd_local, status, ex_status,
3498 le32_to_cpu(data_length), sense);
3499 if (instance->ldio_threshold &&
3500 megasas_cmd_type(scmd_local) == READ_WRITE_LDIO)
3501 atomic_dec(&instance->ldio_outstanding);
3502 scmd_local->SCp.ptr = NULL;
3503 megasas_return_cmd_fusion(instance, cmd);
3504 scsi_dma_unmap(scmd_local);
3505 scmd_local->scsi_done(scmd_local);
3506 }
3507}
3508
3509
3510
3511
3512
3513
3514int
3515complete_cmd_fusion(struct megasas_instance *instance, u32 MSIxIndex,
3516 struct megasas_irq_context *irq_context)
3517{
3518 union MPI2_REPLY_DESCRIPTORS_UNION *desc;
3519 struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *reply_desc;
3520 struct MPI2_RAID_SCSI_IO_REQUEST *scsi_io_req;
3521 struct fusion_context *fusion;
3522 struct megasas_cmd *cmd_mfi;
3523 struct megasas_cmd_fusion *cmd_fusion;
3524 u16 smid, num_completed;
3525 u8 reply_descript_type, *sense, status, extStatus;
3526 u32 device_id, data_length;
3527 union desc_value d_val;
3528 struct LD_LOAD_BALANCE_INFO *lbinfo;
3529 int threshold_reply_count = 0;
3530 struct scsi_cmnd *scmd_local = NULL;
3531 struct MR_TASK_MANAGE_REQUEST *mr_tm_req;
3532 struct MPI2_SCSI_TASK_MANAGE_REQUEST *mpi_tm_req;
3533
3534 fusion = instance->ctrl_context;
3535
3536 if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
3537 return IRQ_HANDLED;
3538
3539 desc = fusion->reply_frames_desc[MSIxIndex] +
3540 fusion->last_reply_idx[MSIxIndex];
3541
3542 reply_desc = (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc;
3543
3544 d_val.word = desc->Words;
3545
3546 reply_descript_type = reply_desc->ReplyFlags &
3547 MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
3548
3549 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
3550 return IRQ_NONE;
3551
3552 num_completed = 0;
3553
3554 while (d_val.u.low != cpu_to_le32(UINT_MAX) &&
3555 d_val.u.high != cpu_to_le32(UINT_MAX)) {
3556
3557 smid = le16_to_cpu(reply_desc->SMID);
3558 cmd_fusion = fusion->cmd_list[smid - 1];
3559 scsi_io_req = (struct MPI2_RAID_SCSI_IO_REQUEST *)
3560 cmd_fusion->io_request;
3561
3562 scmd_local = cmd_fusion->scmd;
3563 status = scsi_io_req->RaidContext.raid_context.status;
3564 extStatus = scsi_io_req->RaidContext.raid_context.ex_status;
3565 sense = cmd_fusion->sense;
3566 data_length = scsi_io_req->DataLength;
3567
3568 switch (scsi_io_req->Function) {
3569 case MPI2_FUNCTION_SCSI_TASK_MGMT:
3570 mr_tm_req = (struct MR_TASK_MANAGE_REQUEST *)
3571 cmd_fusion->io_request;
3572 mpi_tm_req = (struct MPI2_SCSI_TASK_MANAGE_REQUEST *)
3573 &mr_tm_req->TmRequest;
3574 dev_dbg(&instance->pdev->dev, "TM completion:"
3575 "type: 0x%x TaskMID: 0x%x\n",
3576 mpi_tm_req->TaskType, mpi_tm_req->TaskMID);
3577 complete(&cmd_fusion->done);
3578 break;
3579 case MPI2_FUNCTION_SCSI_IO_REQUEST:
3580
3581 if (fusion->load_balance_info &&
3582 (cmd_fusion->scmd->SCp.Status &
3583 MEGASAS_LOAD_BALANCE_FLAG)) {
3584 device_id = MEGASAS_DEV_INDEX(scmd_local);
3585 lbinfo = &fusion->load_balance_info[device_id];
3586 atomic_dec(&lbinfo->scsi_pending_cmds[cmd_fusion->pd_r1_lb]);
3587 cmd_fusion->scmd->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG;
3588 }
3589
3590 case MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST:
3591 atomic_dec(&instance->fw_outstanding);
3592 if (cmd_fusion->r1_alt_dev_handle == MR_DEVHANDLE_INVALID) {
3593 map_cmd_status(fusion, scmd_local, status,
3594 extStatus, le32_to_cpu(data_length),
3595 sense);
3596 if (instance->ldio_threshold &&
3597 (megasas_cmd_type(scmd_local) == READ_WRITE_LDIO))
3598 atomic_dec(&instance->ldio_outstanding);
3599 scmd_local->SCp.ptr = NULL;
3600 megasas_return_cmd_fusion(instance, cmd_fusion);
3601 scsi_dma_unmap(scmd_local);
3602 scmd_local->scsi_done(scmd_local);
3603 } else
3604 megasas_complete_r1_command(instance, cmd_fusion);
3605 break;
3606 case MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST:
3607 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
3608
3609
3610
3611 if (cmd_mfi->flags & DRV_DCMD_POLLED_MODE) {
3612 cmd_mfi->flags &= ~DRV_DCMD_POLLED_MODE;
3613 megasas_return_cmd(instance, cmd_mfi);
3614 } else
3615 megasas_complete_cmd(instance, cmd_mfi, DID_OK);
3616 break;
3617 }
3618
3619 fusion->last_reply_idx[MSIxIndex]++;
3620 if (fusion->last_reply_idx[MSIxIndex] >=
3621 fusion->reply_q_depth)
3622 fusion->last_reply_idx[MSIxIndex] = 0;
3623
3624 desc->Words = cpu_to_le64(ULLONG_MAX);
3625 num_completed++;
3626 threshold_reply_count++;
3627
3628
3629 if (!fusion->last_reply_idx[MSIxIndex])
3630 desc = fusion->reply_frames_desc[MSIxIndex];
3631 else
3632 desc++;
3633
3634 reply_desc =
3635 (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc;
3636
3637 d_val.word = desc->Words;
3638
3639 reply_descript_type = reply_desc->ReplyFlags &
3640 MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
3641
3642 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
3643 break;
3644
3645
3646
3647
3648
3649 if (threshold_reply_count >= instance->threshold_reply_count) {
3650 if (instance->msix_combined)
3651 writel(((MSIxIndex & 0x7) << 24) |
3652 fusion->last_reply_idx[MSIxIndex],
3653 instance->reply_post_host_index_addr[MSIxIndex/8]);
3654 else
3655 writel((MSIxIndex << 24) |
3656 fusion->last_reply_idx[MSIxIndex],
3657 instance->reply_post_host_index_addr[0]);
3658 threshold_reply_count = 0;
3659 if (irq_context) {
3660 if (!irq_context->irq_poll_scheduled) {
3661 irq_context->irq_poll_scheduled = true;
3662 irq_context->irq_line_enable = true;
3663 irq_poll_sched(&irq_context->irqpoll);
3664 }
3665 return num_completed;
3666 }
3667 }
3668 }
3669
3670 if (num_completed) {
3671 wmb();
3672 if (instance->msix_combined)
3673 writel(((MSIxIndex & 0x7) << 24) |
3674 fusion->last_reply_idx[MSIxIndex],
3675 instance->reply_post_host_index_addr[MSIxIndex/8]);
3676 else
3677 writel((MSIxIndex << 24) |
3678 fusion->last_reply_idx[MSIxIndex],
3679 instance->reply_post_host_index_addr[0]);
3680 megasas_check_and_restore_queue_depth(instance);
3681 }
3682 return num_completed;
3683}
3684
3685
3686
3687
3688static void megasas_enable_irq_poll(struct megasas_instance *instance)
3689{
3690 u32 count, i;
3691 struct megasas_irq_context *irq_ctx;
3692
3693 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3694
3695 for (i = 0; i < count; i++) {
3696 irq_ctx = &instance->irq_context[i];
3697 irq_poll_enable(&irq_ctx->irqpoll);
3698 }
3699}
3700
3701
3702
3703
3704
3705void megasas_sync_irqs(unsigned long instance_addr)
3706{
3707 u32 count, i;
3708 struct megasas_instance *instance =
3709 (struct megasas_instance *)instance_addr;
3710 struct megasas_irq_context *irq_ctx;
3711
3712 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3713
3714 for (i = 0; i < count; i++) {
3715 synchronize_irq(pci_irq_vector(instance->pdev, i));
3716 irq_ctx = &instance->irq_context[i];
3717 irq_poll_disable(&irq_ctx->irqpoll);
3718 if (irq_ctx->irq_poll_scheduled) {
3719 irq_ctx->irq_poll_scheduled = false;
3720 enable_irq(irq_ctx->os_irq);
3721 }
3722 }
3723}
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733int megasas_irqpoll(struct irq_poll *irqpoll, int budget)
3734{
3735 struct megasas_irq_context *irq_ctx;
3736 struct megasas_instance *instance;
3737 int num_entries;
3738
3739 irq_ctx = container_of(irqpoll, struct megasas_irq_context, irqpoll);
3740 instance = irq_ctx->instance;
3741
3742 if (irq_ctx->irq_line_enable) {
3743 disable_irq(irq_ctx->os_irq);
3744 irq_ctx->irq_line_enable = false;
3745 }
3746
3747 num_entries = complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx);
3748 if (num_entries < budget) {
3749 irq_poll_complete(irqpoll);
3750 irq_ctx->irq_poll_scheduled = false;
3751 enable_irq(irq_ctx->os_irq);
3752 }
3753
3754 return num_entries;
3755}
3756
3757
3758
3759
3760
3761
3762
3763void
3764megasas_complete_cmd_dpc_fusion(unsigned long instance_addr)
3765{
3766 struct megasas_instance *instance =
3767 (struct megasas_instance *)instance_addr;
3768 u32 count, MSIxIndex;
3769
3770 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3771
3772
3773 if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
3774 return;
3775
3776 for (MSIxIndex = 0 ; MSIxIndex < count; MSIxIndex++)
3777 complete_cmd_fusion(instance, MSIxIndex, NULL);
3778}
3779
3780
3781
3782
3783irqreturn_t megasas_isr_fusion(int irq, void *devp)
3784{
3785 struct megasas_irq_context *irq_context = devp;
3786 struct megasas_instance *instance = irq_context->instance;
3787 u32 mfiStatus;
3788
3789 if (instance->mask_interrupts)
3790 return IRQ_NONE;
3791
3792#if defined(ENABLE_IRQ_POLL)
3793 if (irq_context->irq_poll_scheduled)
3794 return IRQ_HANDLED;
3795#endif
3796
3797 if (!instance->msix_vectors) {
3798 mfiStatus = instance->instancet->clear_intr(instance);
3799 if (!mfiStatus)
3800 return IRQ_NONE;
3801 }
3802
3803
3804 if (test_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags)) {
3805 instance->instancet->clear_intr(instance);
3806 return IRQ_HANDLED;
3807 }
3808
3809 return complete_cmd_fusion(instance, irq_context->MSIxIndex, irq_context)
3810 ? IRQ_HANDLED : IRQ_NONE;
3811}
3812
3813
3814
3815
3816
3817
3818
3819void
3820build_mpt_mfi_pass_thru(struct megasas_instance *instance,
3821 struct megasas_cmd *mfi_cmd)
3822{
3823 struct MPI25_IEEE_SGE_CHAIN64 *mpi25_ieee_chain;
3824 struct MPI2_RAID_SCSI_IO_REQUEST *io_req;
3825 struct megasas_cmd_fusion *cmd;
3826 struct fusion_context *fusion;
3827 struct megasas_header *frame_hdr = &mfi_cmd->frame->hdr;
3828
3829 fusion = instance->ctrl_context;
3830
3831 cmd = megasas_get_cmd_fusion(instance,
3832 instance->max_scsi_cmds + mfi_cmd->index);
3833
3834
3835 mfi_cmd->context.smid = cmd->index;
3836
3837
3838
3839
3840
3841
3842
3843 if (frame_hdr->flags & cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE))
3844 mfi_cmd->flags |= DRV_DCMD_POLLED_MODE;
3845
3846 io_req = cmd->io_request;
3847
3848 if (instance->adapter_type >= INVADER_SERIES) {
3849 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr_end =
3850 (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL;
3851 sgl_ptr_end += fusion->max_sge_in_main_msg - 1;
3852 sgl_ptr_end->Flags = 0;
3853 }
3854
3855 mpi25_ieee_chain =
3856 (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL.IeeeChain;
3857
3858 io_req->Function = MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST;
3859 io_req->SGLOffset0 = offsetof(struct MPI2_RAID_SCSI_IO_REQUEST,
3860 SGL) / 4;
3861 io_req->ChainOffset = fusion->chain_offset_mfi_pthru;
3862
3863 mpi25_ieee_chain->Address = cpu_to_le64(mfi_cmd->frame_phys_addr);
3864
3865 mpi25_ieee_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT |
3866 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR;
3867
3868 mpi25_ieee_chain->Length = cpu_to_le32(instance->mfi_frame_size);
3869}
3870
3871
3872
3873
3874
3875
3876
3877union MEGASAS_REQUEST_DESCRIPTOR_UNION *
3878build_mpt_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
3879{
3880 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc = NULL;
3881 u16 index;
3882
3883 build_mpt_mfi_pass_thru(instance, cmd);
3884 index = cmd->context.smid;
3885
3886 req_desc = megasas_get_request_descriptor(instance, index - 1);
3887
3888 req_desc->Words = 0;
3889 req_desc->SCSIIO.RequestFlags = (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
3890 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
3891
3892 req_desc->SCSIIO.SMID = cpu_to_le16(index);
3893
3894 return req_desc;
3895}
3896
3897
3898
3899
3900
3901
3902
3903void
3904megasas_issue_dcmd_fusion(struct megasas_instance *instance,
3905 struct megasas_cmd *cmd)
3906{
3907 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
3908
3909 req_desc = build_mpt_cmd(instance, cmd);
3910
3911 megasas_fire_cmd_fusion(instance, req_desc);
3912 return;
3913}
3914
3915
3916
3917
3918
3919void
3920megasas_release_fusion(struct megasas_instance *instance)
3921{
3922 megasas_free_ioc_init_cmd(instance);
3923 megasas_free_cmds(instance);
3924 megasas_free_cmds_fusion(instance);
3925
3926 iounmap(instance->reg_set);
3927
3928 pci_release_selected_regions(instance->pdev, 1<<instance->bar);
3929}
3930
3931
3932
3933
3934
3935static u32
3936megasas_read_fw_status_reg_fusion(struct megasas_instance *instance)
3937{
3938 return megasas_readl(instance, &instance->reg_set->outbound_scratch_pad_0);
3939}
3940
3941
3942
3943
3944
3945
3946static void
3947megasas_alloc_host_crash_buffer(struct megasas_instance *instance)
3948{
3949 unsigned int i;
3950
3951 for (i = 0; i < MAX_CRASH_DUMP_SIZE; i++) {
3952 instance->crash_buf[i] = vzalloc(CRASH_DMA_BUF_SIZE);
3953 if (!instance->crash_buf[i]) {
3954 dev_info(&instance->pdev->dev, "Firmware crash dump "
3955 "memory allocation failed at index %d\n", i);
3956 break;
3957 }
3958 }
3959 instance->drv_buf_alloc = i;
3960}
3961
3962
3963
3964
3965
3966void
3967megasas_free_host_crash_buffer(struct megasas_instance *instance)
3968{
3969 unsigned int i;
3970 for (i = 0; i < instance->drv_buf_alloc; i++) {
3971 if (instance->crash_buf[i])
3972 vfree(instance->crash_buf[i]);
3973 }
3974 instance->drv_buf_index = 0;
3975 instance->drv_buf_alloc = 0;
3976 instance->fw_crash_state = UNAVAILABLE;
3977 instance->fw_crash_buffer_size = 0;
3978}
3979
3980
3981
3982
3983
3984static int
3985megasas_adp_reset_fusion(struct megasas_instance *instance,
3986 struct megasas_register_set __iomem *regs)
3987{
3988 u32 host_diag, abs_state, retry;
3989
3990
3991 writel(MPI2_WRSEQ_FLUSH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3992 writel(MPI2_WRSEQ_1ST_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3993 writel(MPI2_WRSEQ_2ND_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3994 writel(MPI2_WRSEQ_3RD_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3995 writel(MPI2_WRSEQ_4TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3996 writel(MPI2_WRSEQ_5TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3997 writel(MPI2_WRSEQ_6TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3998
3999
4000 host_diag = megasas_readl(instance, &instance->reg_set->fusion_host_diag);
4001 retry = 0;
4002 while (!(host_diag & HOST_DIAG_WRITE_ENABLE)) {
4003 msleep(100);
4004 host_diag = megasas_readl(instance,
4005 &instance->reg_set->fusion_host_diag);
4006 if (retry++ == 100) {
4007 dev_warn(&instance->pdev->dev,
4008 "Host diag unlock failed from %s %d\n",
4009 __func__, __LINE__);
4010 break;
4011 }
4012 }
4013 if (!(host_diag & HOST_DIAG_WRITE_ENABLE))
4014 return -1;
4015
4016
4017 writel(host_diag | HOST_DIAG_RESET_ADAPTER,
4018 &instance->reg_set->fusion_host_diag);
4019 msleep(3000);
4020
4021
4022 host_diag = megasas_readl(instance, &instance->reg_set->fusion_host_diag);
4023 retry = 0;
4024 while (host_diag & HOST_DIAG_RESET_ADAPTER) {
4025 msleep(100);
4026 host_diag = megasas_readl(instance,
4027 &instance->reg_set->fusion_host_diag);
4028 if (retry++ == 1000) {
4029 dev_warn(&instance->pdev->dev,
4030 "Diag reset adapter never cleared %s %d\n",
4031 __func__, __LINE__);
4032 break;
4033 }
4034 }
4035 if (host_diag & HOST_DIAG_RESET_ADAPTER)
4036 return -1;
4037
4038 abs_state = instance->instancet->read_fw_status_reg(instance)
4039 & MFI_STATE_MASK;
4040 retry = 0;
4041
4042 while ((abs_state <= MFI_STATE_FW_INIT) && (retry++ < 1000)) {
4043 msleep(100);
4044 abs_state = instance->instancet->
4045 read_fw_status_reg(instance) & MFI_STATE_MASK;
4046 }
4047 if (abs_state <= MFI_STATE_FW_INIT) {
4048 dev_warn(&instance->pdev->dev,
4049 "fw state < MFI_STATE_FW_INIT, state = 0x%x %s %d\n",
4050 abs_state, __func__, __LINE__);
4051 return -1;
4052 }
4053
4054 return 0;
4055}
4056
4057
4058
4059
4060
4061static int
4062megasas_check_reset_fusion(struct megasas_instance *instance,
4063 struct megasas_register_set __iomem *regs)
4064{
4065 return 0;
4066}
4067
4068
4069
4070
4071
4072static inline void megasas_trigger_snap_dump(struct megasas_instance *instance)
4073{
4074 int j;
4075 u32 fw_state, abs_state;
4076
4077 if (!instance->disableOnlineCtrlReset) {
4078 dev_info(&instance->pdev->dev, "Trigger snap dump\n");
4079 writel(MFI_ADP_TRIGGER_SNAP_DUMP,
4080 &instance->reg_set->doorbell);
4081 readl(&instance->reg_set->doorbell);
4082 }
4083
4084 for (j = 0; j < instance->snapdump_wait_time; j++) {
4085 abs_state = instance->instancet->read_fw_status_reg(instance);
4086 fw_state = abs_state & MFI_STATE_MASK;
4087 if (fw_state == MFI_STATE_FAULT) {
4088 dev_printk(KERN_ERR, &instance->pdev->dev,
4089 "FW in FAULT state Fault code:0x%x subcode:0x%x func:%s\n",
4090 abs_state & MFI_STATE_FAULT_CODE,
4091 abs_state & MFI_STATE_FAULT_SUBCODE, __func__);
4092 return;
4093 }
4094 msleep(1000);
4095 }
4096}
4097
4098
4099int megasas_wait_for_outstanding_fusion(struct megasas_instance *instance,
4100 int reason, int *convert)
4101{
4102 int i, outstanding, retval = 0, hb_seconds_missed = 0;
4103 u32 fw_state, abs_state;
4104 u32 waittime_for_io_completion;
4105
4106 waittime_for_io_completion =
4107 min_t(u32, resetwaittime,
4108 (resetwaittime - instance->snapdump_wait_time));
4109
4110 if (reason == MFI_IO_TIMEOUT_OCR) {
4111 dev_info(&instance->pdev->dev,
4112 "MFI command is timed out\n");
4113 megasas_complete_cmd_dpc_fusion((unsigned long)instance);
4114 if (instance->snapdump_wait_time)
4115 megasas_trigger_snap_dump(instance);
4116 retval = 1;
4117 goto out;
4118 }
4119
4120 for (i = 0; i < waittime_for_io_completion; i++) {
4121
4122 abs_state = instance->instancet->read_fw_status_reg(instance);
4123 fw_state = abs_state & MFI_STATE_MASK;
4124 if (fw_state == MFI_STATE_FAULT) {
4125 dev_printk(KERN_ERR, &instance->pdev->dev,
4126 "FW in FAULT state Fault code:0x%x subcode:0x%x func:%s\n",
4127 abs_state & MFI_STATE_FAULT_CODE,
4128 abs_state & MFI_STATE_FAULT_SUBCODE, __func__);
4129 megasas_complete_cmd_dpc_fusion((unsigned long)instance);
4130 if (instance->requestorId && reason) {
4131 dev_warn(&instance->pdev->dev, "SR-IOV Found FW in FAULT"
4132 " state while polling during"
4133 " I/O timeout handling for %d\n",
4134 instance->host->host_no);
4135 *convert = 1;
4136 }
4137
4138 retval = 1;
4139 goto out;
4140 }
4141
4142
4143
4144 if (instance->requestorId && !reason) {
4145 retval = 1;
4146 goto out;
4147 }
4148
4149
4150 if (instance->requestorId && (reason == SCSIIO_TIMEOUT_OCR)) {
4151 if (instance->hb_host_mem->HB.fwCounter !=
4152 instance->hb_host_mem->HB.driverCounter) {
4153 instance->hb_host_mem->HB.driverCounter =
4154 instance->hb_host_mem->HB.fwCounter;
4155 hb_seconds_missed = 0;
4156 } else {
4157 hb_seconds_missed++;
4158 if (hb_seconds_missed ==
4159 (MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF/HZ)) {
4160 dev_warn(&instance->pdev->dev, "SR-IOV:"
4161 " Heartbeat never completed "
4162 " while polling during I/O "
4163 " timeout handling for "
4164 "scsi%d.\n",
4165 instance->host->host_no);
4166 *convert = 1;
4167 retval = 1;
4168 goto out;
4169 }
4170 }
4171 }
4172
4173 megasas_complete_cmd_dpc_fusion((unsigned long)instance);
4174 outstanding = atomic_read(&instance->fw_outstanding);
4175 if (!outstanding)
4176 goto out;
4177
4178 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
4179 dev_notice(&instance->pdev->dev, "[%2d]waiting for %d "
4180 "commands to complete for scsi%d\n", i,
4181 outstanding, instance->host->host_no);
4182 }
4183 msleep(1000);
4184 }
4185
4186 if (instance->snapdump_wait_time) {
4187 megasas_trigger_snap_dump(instance);
4188 retval = 1;
4189 goto out;
4190 }
4191
4192 if (atomic_read(&instance->fw_outstanding)) {
4193 dev_err(&instance->pdev->dev, "pending commands remain after waiting, "
4194 "will reset adapter scsi%d.\n",
4195 instance->host->host_no);
4196 *convert = 1;
4197 retval = 1;
4198 }
4199
4200out:
4201 return retval;
4202}
4203
4204void megasas_reset_reply_desc(struct megasas_instance *instance)
4205{
4206 int i, j, count;
4207 struct fusion_context *fusion;
4208 union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc;
4209
4210 fusion = instance->ctrl_context;
4211 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
4212 for (i = 0 ; i < count ; i++) {
4213 fusion->last_reply_idx[i] = 0;
4214 reply_desc = fusion->reply_frames_desc[i];
4215 for (j = 0 ; j < fusion->reply_q_depth; j++, reply_desc++)
4216 reply_desc->Words = cpu_to_le64(ULLONG_MAX);
4217 }
4218}
4219
4220
4221
4222
4223
4224void megasas_refire_mgmt_cmd(struct megasas_instance *instance)
4225{
4226 int j;
4227 struct megasas_cmd_fusion *cmd_fusion;
4228 struct fusion_context *fusion;
4229 struct megasas_cmd *cmd_mfi;
4230 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
4231 u16 smid;
4232 bool refire_cmd = 0;
4233 u8 result;
4234 u32 opcode = 0;
4235
4236 fusion = instance->ctrl_context;
4237
4238
4239
4240
4241 for (j = instance->max_scsi_cmds ; j < instance->max_fw_cmds; j++) {
4242 cmd_fusion = fusion->cmd_list[j];
4243 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
4244 smid = le16_to_cpu(cmd_mfi->context.smid);
4245 result = REFIRE_CMD;
4246
4247 if (!smid)
4248 continue;
4249
4250 req_desc = megasas_get_request_descriptor(instance, smid - 1);
4251
4252 switch (cmd_mfi->frame->hdr.cmd) {
4253 case MFI_CMD_DCMD:
4254 opcode = le32_to_cpu(cmd_mfi->frame->dcmd.opcode);
4255
4256 if (opcode == MR_DCMD_CTRL_SHUTDOWN) {
4257 cmd_mfi->frame->dcmd.cmd_status = MFI_STAT_OK;
4258 result = COMPLETE_CMD;
4259 break;
4260 }
4261
4262 refire_cmd = ((opcode != MR_DCMD_LD_MAP_GET_INFO)) &&
4263 (opcode != MR_DCMD_SYSTEM_PD_MAP_GET_INFO) &&
4264 !(cmd_mfi->flags & DRV_DCMD_SKIP_REFIRE);
4265
4266 if (!refire_cmd)
4267 result = RETURN_CMD;
4268
4269 break;
4270 case MFI_CMD_NVME:
4271 if (!instance->support_nvme_passthru) {
4272 cmd_mfi->frame->hdr.cmd_status = MFI_STAT_INVALID_CMD;
4273 result = COMPLETE_CMD;
4274 }
4275
4276 break;
4277 case MFI_CMD_TOOLBOX:
4278 if (!instance->support_pci_lane_margining) {
4279 cmd_mfi->frame->hdr.cmd_status = MFI_STAT_INVALID_CMD;
4280 result = COMPLETE_CMD;
4281 }
4282
4283 break;
4284 default:
4285 break;
4286 }
4287
4288 switch (result) {
4289 case REFIRE_CMD:
4290 megasas_fire_cmd_fusion(instance, req_desc);
4291 break;
4292 case RETURN_CMD:
4293 megasas_return_cmd(instance, cmd_mfi);
4294 break;
4295 case COMPLETE_CMD:
4296 megasas_complete_cmd(instance, cmd_mfi, DID_OK);
4297 break;
4298 }
4299 }
4300}
4301
4302
4303
4304
4305
4306
4307
4308
4309
4310
4311static int megasas_track_scsiio(struct megasas_instance *instance,
4312 int id, int channel)
4313{
4314 int i, found = 0;
4315 struct megasas_cmd_fusion *cmd_fusion;
4316 struct fusion_context *fusion;
4317 fusion = instance->ctrl_context;
4318
4319 for (i = 0 ; i < instance->max_scsi_cmds; i++) {
4320 cmd_fusion = fusion->cmd_list[i];
4321 if (cmd_fusion->scmd &&
4322 (cmd_fusion->scmd->device->id == id &&
4323 cmd_fusion->scmd->device->channel == channel)) {
4324 dev_info(&instance->pdev->dev,
4325 "SCSI commands pending to target"
4326 "channel %d id %d \tSMID: 0x%x\n",
4327 channel, id, cmd_fusion->index);
4328 scsi_print_command(cmd_fusion->scmd);
4329 found = 1;
4330 break;
4331 }
4332 }
4333
4334 return found ? FAILED : SUCCESS;
4335}
4336
4337
4338
4339
4340
4341
4342
4343
4344static void
4345megasas_tm_response_code(struct megasas_instance *instance,
4346 struct MPI2_SCSI_TASK_MANAGE_REPLY *mpi_reply)
4347{
4348 char *desc;
4349
4350 switch (mpi_reply->ResponseCode) {
4351 case MPI2_SCSITASKMGMT_RSP_TM_COMPLETE:
4352 desc = "task management request completed";
4353 break;
4354 case MPI2_SCSITASKMGMT_RSP_INVALID_FRAME:
4355 desc = "invalid frame";
4356 break;
4357 case MPI2_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
4358 desc = "task management request not supported";
4359 break;
4360 case MPI2_SCSITASKMGMT_RSP_TM_FAILED:
4361 desc = "task management request failed";
4362 break;
4363 case MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED:
4364 desc = "task management request succeeded";
4365 break;
4366 case MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN:
4367 desc = "invalid lun";
4368 break;
4369 case 0xA:
4370 desc = "overlapped tag attempted";
4371 break;
4372 case MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
4373 desc = "task queued, however not sent to target";
4374 break;
4375 default:
4376 desc = "unknown";
4377 break;
4378 }
4379 dev_dbg(&instance->pdev->dev, "response_code(%01x): %s\n",
4380 mpi_reply->ResponseCode, desc);
4381 dev_dbg(&instance->pdev->dev,
4382 "TerminationCount/DevHandle/Function/TaskType/IOCStat/IOCLoginfo"
4383 " 0x%x/0x%x/0x%x/0x%x/0x%x/0x%x\n",
4384 mpi_reply->TerminationCount, mpi_reply->DevHandle,
4385 mpi_reply->Function, mpi_reply->TaskType,
4386 mpi_reply->IOCStatus, mpi_reply->IOCLogInfo);
4387}
4388
4389
4390
4391
4392
4393
4394
4395
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405static int
4406megasas_issue_tm(struct megasas_instance *instance, u16 device_handle,
4407 uint channel, uint id, u16 smid_task, u8 type,
4408 struct MR_PRIV_DEVICE *mr_device_priv_data)
4409{
4410 struct MR_TASK_MANAGE_REQUEST *mr_request;
4411 struct MPI2_SCSI_TASK_MANAGE_REQUEST *mpi_request;
4412 unsigned long timeleft;
4413 struct megasas_cmd_fusion *cmd_fusion;
4414 struct megasas_cmd *cmd_mfi;
4415 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
4416 struct fusion_context *fusion = NULL;
4417 struct megasas_cmd_fusion *scsi_lookup;
4418 int rc;
4419 int timeout = MEGASAS_DEFAULT_TM_TIMEOUT;
4420 struct MPI2_SCSI_TASK_MANAGE_REPLY *mpi_reply;
4421
4422 fusion = instance->ctrl_context;
4423
4424 cmd_mfi = megasas_get_cmd(instance);
4425
4426 if (!cmd_mfi) {
4427 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
4428 __func__, __LINE__);
4429 return -ENOMEM;
4430 }
4431
4432 cmd_fusion = megasas_get_cmd_fusion(instance,
4433 instance->max_scsi_cmds + cmd_mfi->index);
4434
4435
4436 cmd_mfi->context.smid = cmd_fusion->index;
4437
4438 req_desc = megasas_get_request_descriptor(instance,
4439 (cmd_fusion->index - 1));
4440
4441 cmd_fusion->request_desc = req_desc;
4442 req_desc->Words = 0;
4443
4444 mr_request = (struct MR_TASK_MANAGE_REQUEST *) cmd_fusion->io_request;
4445 memset(mr_request, 0, sizeof(struct MR_TASK_MANAGE_REQUEST));
4446 mpi_request = (struct MPI2_SCSI_TASK_MANAGE_REQUEST *) &mr_request->TmRequest;
4447 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
4448 mpi_request->DevHandle = cpu_to_le16(device_handle);
4449 mpi_request->TaskType = type;
4450 mpi_request->TaskMID = cpu_to_le16(smid_task);
4451 mpi_request->LUN[1] = 0;
4452
4453
4454 req_desc = cmd_fusion->request_desc;
4455 req_desc->HighPriority.SMID = cpu_to_le16(cmd_fusion->index);
4456 req_desc->HighPriority.RequestFlags =
4457 (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<
4458 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
4459 req_desc->HighPriority.MSIxIndex = 0;
4460 req_desc->HighPriority.LMID = 0;
4461 req_desc->HighPriority.Reserved1 = 0;
4462
4463 if (channel < MEGASAS_MAX_PD_CHANNELS)
4464 mr_request->tmReqFlags.isTMForPD = 1;
4465 else
4466 mr_request->tmReqFlags.isTMForLD = 1;
4467
4468 init_completion(&cmd_fusion->done);
4469 megasas_fire_cmd_fusion(instance, req_desc);
4470
4471 switch (type) {
4472 case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
4473 timeout = mr_device_priv_data->task_abort_tmo;
4474 break;
4475 case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
4476 timeout = mr_device_priv_data->target_reset_tmo;
4477 break;
4478 }
4479
4480 timeleft = wait_for_completion_timeout(&cmd_fusion->done, timeout * HZ);
4481
4482 if (!timeleft) {
4483 dev_err(&instance->pdev->dev,
4484 "task mgmt type 0x%x timed out\n", type);
4485 cmd_mfi->flags |= DRV_DCMD_SKIP_REFIRE;
4486 mutex_unlock(&instance->reset_mutex);
4487 rc = megasas_reset_fusion(instance->host, MFI_IO_TIMEOUT_OCR);
4488 mutex_lock(&instance->reset_mutex);
4489 return rc;
4490 }
4491
4492 mpi_reply = (struct MPI2_SCSI_TASK_MANAGE_REPLY *) &mr_request->TMReply;
4493 megasas_tm_response_code(instance, mpi_reply);
4494
4495 megasas_return_cmd(instance, cmd_mfi);
4496 rc = SUCCESS;
4497 switch (type) {
4498 case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
4499 scsi_lookup = fusion->cmd_list[smid_task - 1];
4500
4501 if (scsi_lookup->scmd == NULL)
4502 break;
4503 else {
4504 instance->instancet->disable_intr(instance);
4505 megasas_sync_irqs((unsigned long)instance);
4506 instance->instancet->enable_intr(instance);
4507 megasas_enable_irq_poll(instance);
4508 if (scsi_lookup->scmd == NULL)
4509 break;
4510 }
4511 rc = FAILED;
4512 break;
4513
4514 case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
4515 if ((channel == 0xFFFFFFFF) && (id == 0xFFFFFFFF))
4516 break;
4517 instance->instancet->disable_intr(instance);
4518 megasas_sync_irqs((unsigned long)instance);
4519 rc = megasas_track_scsiio(instance, id, channel);
4520 instance->instancet->enable_intr(instance);
4521 megasas_enable_irq_poll(instance);
4522
4523 break;
4524 case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET:
4525 case MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK:
4526 break;
4527 default:
4528 rc = FAILED;
4529 break;
4530 }
4531
4532 return rc;
4533
4534}
4535
4536
4537
4538
4539
4540
4541
4542static u16 megasas_fusion_smid_lookup(struct scsi_cmnd *scmd)
4543{
4544 int i, ret = 0;
4545 struct megasas_instance *instance;
4546 struct megasas_cmd_fusion *cmd_fusion;
4547 struct fusion_context *fusion;
4548
4549 instance = (struct megasas_instance *)scmd->device->host->hostdata;
4550
4551 fusion = instance->ctrl_context;
4552
4553 for (i = 0; i < instance->max_scsi_cmds; i++) {
4554 cmd_fusion = fusion->cmd_list[i];
4555 if (cmd_fusion->scmd && (cmd_fusion->scmd == scmd)) {
4556 scmd_printk(KERN_NOTICE, scmd, "Abort request is for"
4557 " SMID: %d\n", cmd_fusion->index);
4558 ret = cmd_fusion->index;
4559 break;
4560 }
4561 }
4562
4563 return ret;
4564}
4565
4566
4567
4568
4569
4570
4571
4572static u16 megasas_get_tm_devhandle(struct scsi_device *sdev)
4573{
4574 u16 pd_index = 0;
4575 u32 device_id;
4576 struct megasas_instance *instance;
4577 struct fusion_context *fusion;
4578 struct MR_PD_CFG_SEQ_NUM_SYNC *pd_sync;
4579 u16 devhandle = (u16)ULONG_MAX;
4580
4581 instance = (struct megasas_instance *)sdev->host->hostdata;
4582 fusion = instance->ctrl_context;
4583
4584 if (!MEGASAS_IS_LOGICAL(sdev)) {
4585 if (instance->use_seqnum_jbod_fp) {
4586 pd_index = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL)
4587 + sdev->id;
4588 pd_sync = (void *)fusion->pd_seq_sync
4589 [(instance->pd_seq_map_id - 1) & 1];
4590 devhandle = pd_sync->seq[pd_index].devHandle;
4591 } else
4592 sdev_printk(KERN_ERR, sdev, "Firmware expose tmCapable"
4593 " without JBOD MAP support from %s %d\n", __func__, __LINE__);
4594 } else {
4595 device_id = ((sdev->channel % 2) * MEGASAS_MAX_DEV_PER_CHANNEL)
4596 + sdev->id;
4597 devhandle = device_id;
4598 }
4599
4600 return devhandle;
4601}
4602
4603
4604
4605
4606
4607
4608
4609
4610int megasas_task_abort_fusion(struct scsi_cmnd *scmd)
4611{
4612 struct megasas_instance *instance;
4613 u16 smid, devhandle;
4614 int ret;
4615 struct MR_PRIV_DEVICE *mr_device_priv_data;
4616 mr_device_priv_data = scmd->device->hostdata;
4617
4618 instance = (struct megasas_instance *)scmd->device->host->hostdata;
4619
4620 if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
4621 dev_err(&instance->pdev->dev, "Controller is not OPERATIONAL,"
4622 "SCSI host:%d\n", instance->host->host_no);
4623 ret = FAILED;
4624 return ret;
4625 }
4626
4627 if (!mr_device_priv_data) {
4628 sdev_printk(KERN_INFO, scmd->device, "device been deleted! "
4629 "scmd(%p)\n", scmd);
4630 scmd->result = DID_NO_CONNECT << 16;
4631 ret = SUCCESS;
4632 goto out;
4633 }
4634
4635 if (!mr_device_priv_data->is_tm_capable) {
4636 ret = FAILED;
4637 goto out;
4638 }
4639
4640 mutex_lock(&instance->reset_mutex);
4641
4642 smid = megasas_fusion_smid_lookup(scmd);
4643
4644 if (!smid) {
4645 ret = SUCCESS;
4646 scmd_printk(KERN_NOTICE, scmd, "Command for which abort is"
4647 " issued is not found in outstanding commands\n");
4648 mutex_unlock(&instance->reset_mutex);
4649 goto out;
4650 }
4651
4652 devhandle = megasas_get_tm_devhandle(scmd->device);
4653
4654 if (devhandle == (u16)ULONG_MAX) {
4655 ret = SUCCESS;
4656 sdev_printk(KERN_INFO, scmd->device,
4657 "task abort issued for invalid devhandle\n");
4658 mutex_unlock(&instance->reset_mutex);
4659 goto out;
4660 }
4661 sdev_printk(KERN_INFO, scmd->device,
4662 "attempting task abort! scmd(0x%p) tm_dev_handle 0x%x\n",
4663 scmd, devhandle);
4664
4665 mr_device_priv_data->tm_busy = 1;
4666 ret = megasas_issue_tm(instance, devhandle,
4667 scmd->device->channel, scmd->device->id, smid,
4668 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK,
4669 mr_device_priv_data);
4670 mr_device_priv_data->tm_busy = 0;
4671
4672 mutex_unlock(&instance->reset_mutex);
4673 scmd_printk(KERN_INFO, scmd, "task abort %s!! scmd(0x%p)\n",
4674 ((ret == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
4675out:
4676 scsi_print_command(scmd);
4677 if (megasas_dbg_lvl & TM_DEBUG)
4678 megasas_dump_fusion_io(scmd);
4679
4680 return ret;
4681}
4682
4683
4684
4685
4686
4687
4688
4689
4690int megasas_reset_target_fusion(struct scsi_cmnd *scmd)
4691{
4692
4693 struct megasas_instance *instance;
4694 int ret = FAILED;
4695 u16 devhandle;
4696 struct MR_PRIV_DEVICE *mr_device_priv_data;
4697 mr_device_priv_data = scmd->device->hostdata;
4698
4699 instance = (struct megasas_instance *)scmd->device->host->hostdata;
4700
4701 if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
4702 dev_err(&instance->pdev->dev, "Controller is not OPERATIONAL,"
4703 "SCSI host:%d\n", instance->host->host_no);
4704 ret = FAILED;
4705 return ret;
4706 }
4707
4708 if (!mr_device_priv_data) {
4709 sdev_printk(KERN_INFO, scmd->device,
4710 "device been deleted! scmd: (0x%p)\n", scmd);
4711 scmd->result = DID_NO_CONNECT << 16;
4712 ret = SUCCESS;
4713 goto out;
4714 }
4715
4716 if (!mr_device_priv_data->is_tm_capable) {
4717 ret = FAILED;
4718 goto out;
4719 }
4720
4721 mutex_lock(&instance->reset_mutex);
4722 devhandle = megasas_get_tm_devhandle(scmd->device);
4723
4724 if (devhandle == (u16)ULONG_MAX) {
4725 ret = SUCCESS;
4726 sdev_printk(KERN_INFO, scmd->device,
4727 "target reset issued for invalid devhandle\n");
4728 mutex_unlock(&instance->reset_mutex);
4729 goto out;
4730 }
4731
4732 sdev_printk(KERN_INFO, scmd->device,
4733 "attempting target reset! scmd(0x%p) tm_dev_handle: 0x%x\n",
4734 scmd, devhandle);
4735 mr_device_priv_data->tm_busy = 1;
4736 ret = megasas_issue_tm(instance, devhandle,
4737 scmd->device->channel, scmd->device->id, 0,
4738 MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET,
4739 mr_device_priv_data);
4740 mr_device_priv_data->tm_busy = 0;
4741 mutex_unlock(&instance->reset_mutex);
4742 scmd_printk(KERN_NOTICE, scmd, "target reset %s!!\n",
4743 (ret == SUCCESS) ? "SUCCESS" : "FAILED");
4744
4745out:
4746 return ret;
4747}
4748
4749
4750struct megasas_instance *megasas_get_peer_instance(struct megasas_instance *instance)
4751{
4752 int i;
4753
4754 for (i = 0; i < MAX_MGMT_ADAPTERS; i++) {
4755 if (megasas_mgmt_info.instance[i] &&
4756 (megasas_mgmt_info.instance[i] != instance) &&
4757 megasas_mgmt_info.instance[i]->requestorId &&
4758 megasas_mgmt_info.instance[i]->peerIsPresent &&
4759 (memcmp((megasas_mgmt_info.instance[i]->clusterId),
4760 instance->clusterId, MEGASAS_CLUSTER_ID_SIZE) == 0))
4761 return megasas_mgmt_info.instance[i];
4762 }
4763 return NULL;
4764}
4765
4766
4767int megasas_check_mpio_paths(struct megasas_instance *instance,
4768 struct scsi_cmnd *scmd)
4769{
4770 struct megasas_instance *peer_instance = NULL;
4771 int retval = (DID_REQUEUE << 16);
4772
4773 if (instance->peerIsPresent) {
4774 peer_instance = megasas_get_peer_instance(instance);
4775 if ((peer_instance) &&
4776 (atomic_read(&peer_instance->adprecovery) ==
4777 MEGASAS_HBA_OPERATIONAL))
4778 retval = (DID_NO_CONNECT << 16);
4779 }
4780 return retval;
4781}
4782
4783
4784int megasas_reset_fusion(struct Scsi_Host *shost, int reason)
4785{
4786 int retval = SUCCESS, i, j, convert = 0;
4787 struct megasas_instance *instance;
4788 struct megasas_cmd_fusion *cmd_fusion, *r1_cmd;
4789 struct fusion_context *fusion;
4790 u32 abs_state, status_reg, reset_adapter, fpio_count = 0;
4791 u32 io_timeout_in_crash_mode = 0;
4792 struct scsi_cmnd *scmd_local = NULL;
4793 struct scsi_device *sdev;
4794 int ret_target_prop = DCMD_FAILED;
4795 bool is_target_prop = false;
4796 bool do_adp_reset = true;
4797 int max_reset_tries = MEGASAS_FUSION_MAX_RESET_TRIES;
4798
4799 instance = (struct megasas_instance *)shost->hostdata;
4800 fusion = instance->ctrl_context;
4801
4802 mutex_lock(&instance->reset_mutex);
4803
4804 if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
4805 dev_warn(&instance->pdev->dev, "Hardware critical error, "
4806 "returning FAILED for scsi%d.\n",
4807 instance->host->host_no);
4808 mutex_unlock(&instance->reset_mutex);
4809 return FAILED;
4810 }
4811 status_reg = instance->instancet->read_fw_status_reg(instance);
4812 abs_state = status_reg & MFI_STATE_MASK;
4813
4814
4815 if (abs_state != MFI_STATE_FAULT && instance->crash_dump_buf &&
4816 instance->crash_dump_app_support && reason) {
4817 dev_info(&instance->pdev->dev, "IO/DCMD timeout is detected, "
4818 "forcibly FAULT Firmware\n");
4819 atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
4820 status_reg = megasas_readl(instance, &instance->reg_set->doorbell);
4821 writel(status_reg | MFI_STATE_FORCE_OCR,
4822 &instance->reg_set->doorbell);
4823 readl(&instance->reg_set->doorbell);
4824 mutex_unlock(&instance->reset_mutex);
4825 do {
4826 ssleep(3);
4827 io_timeout_in_crash_mode++;
4828 dev_dbg(&instance->pdev->dev, "waiting for [%d] "
4829 "seconds for crash dump collection and OCR "
4830 "to be done\n", (io_timeout_in_crash_mode * 3));
4831 } while ((atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) &&
4832 (io_timeout_in_crash_mode < 80));
4833
4834 if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL) {
4835 dev_info(&instance->pdev->dev, "OCR done for IO "
4836 "timeout case\n");
4837 retval = SUCCESS;
4838 } else {
4839 dev_info(&instance->pdev->dev, "Controller is not "
4840 "operational after 240 seconds wait for IO "
4841 "timeout case in FW crash dump mode\n do "
4842 "OCR/kill adapter\n");
4843 retval = megasas_reset_fusion(shost, 0);
4844 }
4845 return retval;
4846 }
4847
4848 if (instance->requestorId && !instance->skip_heartbeat_timer_del)
4849 del_timer_sync(&instance->sriov_heartbeat_timer);
4850 set_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
4851 atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_POLLING);
4852 instance->instancet->disable_intr(instance);
4853 megasas_sync_irqs((unsigned long)instance);
4854
4855
4856 if (megasas_wait_for_outstanding_fusion(instance, reason,
4857 &convert)) {
4858 atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
4859 dev_warn(&instance->pdev->dev, "resetting fusion "
4860 "adapter scsi%d.\n", instance->host->host_no);
4861 if (convert)
4862 reason = 0;
4863
4864 if (megasas_dbg_lvl & OCR_DEBUG)
4865 dev_info(&instance->pdev->dev, "\nPending SCSI commands:\n");
4866
4867
4868 for (i = 0 ; i < instance->max_scsi_cmds; i++) {
4869 cmd_fusion = fusion->cmd_list[i];
4870
4871 if (instance->adapter_type >= VENTURA_SERIES) {
4872 r1_cmd = fusion->cmd_list[i + instance->max_fw_cmds];
4873 megasas_return_cmd_fusion(instance, r1_cmd);
4874 }
4875 scmd_local = cmd_fusion->scmd;
4876 if (cmd_fusion->scmd) {
4877 if (megasas_dbg_lvl & OCR_DEBUG) {
4878 sdev_printk(KERN_INFO,
4879 cmd_fusion->scmd->device, "SMID: 0x%x\n",
4880 cmd_fusion->index);
4881 megasas_dump_fusion_io(cmd_fusion->scmd);
4882 }
4883
4884 if (cmd_fusion->io_request->Function ==
4885 MPI2_FUNCTION_SCSI_IO_REQUEST)
4886 fpio_count++;
4887
4888 scmd_local->result =
4889 megasas_check_mpio_paths(instance,
4890 scmd_local);
4891 if (instance->ldio_threshold &&
4892 megasas_cmd_type(scmd_local) == READ_WRITE_LDIO)
4893 atomic_dec(&instance->ldio_outstanding);
4894 megasas_return_cmd_fusion(instance, cmd_fusion);
4895 scsi_dma_unmap(scmd_local);
4896 scmd_local->scsi_done(scmd_local);
4897 }
4898 }
4899
4900 dev_info(&instance->pdev->dev, "Outstanding fastpath IOs: %d\n",
4901 fpio_count);
4902
4903 atomic_set(&instance->fw_outstanding, 0);
4904
4905 status_reg = instance->instancet->read_fw_status_reg(instance);
4906 abs_state = status_reg & MFI_STATE_MASK;
4907 reset_adapter = status_reg & MFI_RESET_ADAPTER;
4908 if (instance->disableOnlineCtrlReset ||
4909 (abs_state == MFI_STATE_FAULT && !reset_adapter)) {
4910
4911 dev_warn(&instance->pdev->dev, "Reset not supported"
4912 ", killing adapter scsi%d.\n",
4913 instance->host->host_no);
4914 goto kill_hba;
4915 }
4916
4917
4918 if (instance->requestorId && !reason) {
4919 msleep(MEGASAS_OCR_SETTLE_TIME_VF);
4920 do_adp_reset = false;
4921 max_reset_tries = MEGASAS_SRIOV_MAX_RESET_TRIES_VF;
4922 }
4923
4924
4925 for (i = 0; i < max_reset_tries; i++) {
4926
4927
4928
4929
4930 if (megasas_adp_reset_wait_for_ready(instance,
4931 do_adp_reset, 1) == FAILED)
4932 continue;
4933
4934
4935 if (megasas_transition_to_ready(instance, 1)) {
4936 dev_warn(&instance->pdev->dev,
4937 "Failed to transition controller to ready for "
4938 "scsi%d.\n", instance->host->host_no);
4939 continue;
4940 }
4941 megasas_reset_reply_desc(instance);
4942 megasas_fusion_update_can_queue(instance, OCR_CONTEXT);
4943
4944 if (megasas_ioc_init_fusion(instance)) {
4945 continue;
4946 }
4947
4948 if (megasas_get_ctrl_info(instance)) {
4949 dev_info(&instance->pdev->dev,
4950 "Failed from %s %d\n",
4951 __func__, __LINE__);
4952 goto kill_hba;
4953 }
4954
4955 megasas_refire_mgmt_cmd(instance);
4956
4957
4958 if (fusion->load_balance_info)
4959 memset(fusion->load_balance_info, 0,
4960 (sizeof(struct LD_LOAD_BALANCE_INFO) *
4961 MAX_LOGICAL_DRIVES_EXT));
4962
4963 if (!megasas_get_map_info(instance))
4964 megasas_sync_map_info(instance);
4965
4966 megasas_setup_jbod_map(instance);
4967
4968
4969 if (instance->adapter_type >= VENTURA_SERIES) {
4970 for (j = 0; j < MAX_LOGICAL_DRIVES_EXT; ++j) {
4971 memset(fusion->stream_detect_by_ld[j],
4972 0, sizeof(struct LD_STREAM_DETECT));
4973 fusion->stream_detect_by_ld[j]->mru_bit_map
4974 = MR_STREAM_BITMAP;
4975 }
4976 }
4977
4978 clear_bit(MEGASAS_FUSION_IN_RESET,
4979 &instance->reset_flags);
4980 instance->instancet->enable_intr(instance);
4981 megasas_enable_irq_poll(instance);
4982 shost_for_each_device(sdev, shost) {
4983 if ((instance->tgt_prop) &&
4984 (instance->nvme_page_size))
4985 ret_target_prop = megasas_get_target_prop(instance, sdev);
4986
4987 is_target_prop = (ret_target_prop == DCMD_SUCCESS) ? true : false;
4988 megasas_set_dynamic_target_properties(sdev, is_target_prop);
4989 }
4990
4991 atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
4992
4993 dev_info(&instance->pdev->dev,
4994 "Adapter is OPERATIONAL for scsi:%d\n",
4995 instance->host->host_no);
4996
4997
4998 if (instance->requestorId) {
4999 if (!megasas_sriov_start_heartbeat(instance, 0))
5000 megasas_start_timer(instance);
5001 else
5002 instance->skip_heartbeat_timer_del = 1;
5003 }
5004
5005 if (instance->crash_dump_drv_support &&
5006 instance->crash_dump_app_support)
5007 megasas_set_crash_dump_params(instance,
5008 MR_CRASH_BUF_TURN_ON);
5009 else
5010 megasas_set_crash_dump_params(instance,
5011 MR_CRASH_BUF_TURN_OFF);
5012
5013 if (instance->snapdump_wait_time) {
5014 megasas_get_snapdump_properties(instance);
5015 dev_info(&instance->pdev->dev,
5016 "Snap dump wait time\t: %d\n",
5017 instance->snapdump_wait_time);
5018 }
5019
5020 retval = SUCCESS;
5021
5022
5023 dev_warn(&instance->pdev->dev,
5024 "Reset successful for scsi%d.\n",
5025 instance->host->host_no);
5026
5027 goto out;
5028 }
5029
5030 dev_warn(&instance->pdev->dev, "Reset failed, killing "
5031 "adapter scsi%d.\n", instance->host->host_no);
5032 goto kill_hba;
5033 } else {
5034
5035 if (instance->requestorId) {
5036 megasas_start_timer(instance);
5037 }
5038 clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
5039 instance->instancet->enable_intr(instance);
5040 megasas_enable_irq_poll(instance);
5041 atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
5042 goto out;
5043 }
5044kill_hba:
5045 megaraid_sas_kill_hba(instance);
5046 megasas_enable_irq_poll(instance);
5047 instance->skip_heartbeat_timer_del = 1;
5048 retval = FAILED;
5049out:
5050 clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
5051 mutex_unlock(&instance->reset_mutex);
5052 return retval;
5053}
5054
5055
5056void megasas_fusion_crash_dump(struct megasas_instance *instance)
5057{
5058 u32 status_reg;
5059 u8 partial_copy = 0;
5060 int wait = 0;
5061
5062
5063 status_reg = instance->instancet->read_fw_status_reg(instance);
5064
5065
5066
5067
5068
5069 if (instance->drv_buf_index == 0) {
5070
5071
5072
5073 if (instance->drv_buf_alloc) {
5074 dev_info(&instance->pdev->dev, "earlier crash dump is "
5075 "not yet copied by application, ignoring this "
5076 "crash dump and initiating OCR\n");
5077 status_reg |= MFI_STATE_CRASH_DUMP_DONE;
5078 writel(status_reg,
5079 &instance->reg_set->outbound_scratch_pad_0);
5080 readl(&instance->reg_set->outbound_scratch_pad_0);
5081 return;
5082 }
5083 megasas_alloc_host_crash_buffer(instance);
5084 dev_info(&instance->pdev->dev, "Number of host crash buffers "
5085 "allocated: %d\n", instance->drv_buf_alloc);
5086 }
5087
5088 while (!(status_reg & MFI_STATE_CRASH_DUMP_DONE) &&
5089 (wait < MEGASAS_WATCHDOG_WAIT_COUNT)) {
5090 if (!(status_reg & MFI_STATE_DMADONE)) {
5091
5092
5093
5094
5095
5096 wait++;
5097 msleep(MEGASAS_WAIT_FOR_NEXT_DMA_MSECS);
5098 status_reg = instance->instancet->read_fw_status_reg(
5099 instance);
5100 continue;
5101 }
5102
5103 wait = 0;
5104 if (instance->drv_buf_index >= instance->drv_buf_alloc) {
5105 dev_info(&instance->pdev->dev,
5106 "Driver is done copying the buffer: %d\n",
5107 instance->drv_buf_alloc);
5108 status_reg |= MFI_STATE_CRASH_DUMP_DONE;
5109 partial_copy = 1;
5110 break;
5111 } else {
5112 memcpy(instance->crash_buf[instance->drv_buf_index],
5113 instance->crash_dump_buf, CRASH_DMA_BUF_SIZE);
5114 instance->drv_buf_index++;
5115 status_reg &= ~MFI_STATE_DMADONE;
5116 }
5117
5118 writel(status_reg, &instance->reg_set->outbound_scratch_pad_0);
5119 readl(&instance->reg_set->outbound_scratch_pad_0);
5120
5121 msleep(MEGASAS_WAIT_FOR_NEXT_DMA_MSECS);
5122 status_reg = instance->instancet->read_fw_status_reg(instance);
5123 }
5124
5125 if (status_reg & MFI_STATE_CRASH_DUMP_DONE) {
5126 dev_info(&instance->pdev->dev, "Crash Dump is available,number "
5127 "of copied buffers: %d\n", instance->drv_buf_index);
5128 instance->fw_crash_buffer_size = instance->drv_buf_index;
5129 instance->fw_crash_state = AVAILABLE;
5130 instance->drv_buf_index = 0;
5131 writel(status_reg, &instance->reg_set->outbound_scratch_pad_0);
5132 readl(&instance->reg_set->outbound_scratch_pad_0);
5133 if (!partial_copy)
5134 megasas_reset_fusion(instance->host, 0);
5135 }
5136}
5137
5138
5139
5140void megasas_fusion_ocr_wq(struct work_struct *work)
5141{
5142 struct megasas_instance *instance =
5143 container_of(work, struct megasas_instance, work_init);
5144
5145 megasas_reset_fusion(instance->host, 0);
5146}
5147
5148
5149int
5150megasas_alloc_fusion_context(struct megasas_instance *instance)
5151{
5152 struct fusion_context *fusion;
5153
5154 instance->ctrl_context = kzalloc(sizeof(struct fusion_context),
5155 GFP_KERNEL);
5156 if (!instance->ctrl_context) {
5157 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
5158 __func__, __LINE__);
5159 return -ENOMEM;
5160 }
5161
5162 fusion = instance->ctrl_context;
5163
5164 fusion->log_to_span_pages = get_order(MAX_LOGICAL_DRIVES_EXT *
5165 sizeof(LD_SPAN_INFO));
5166 fusion->log_to_span =
5167 (PLD_SPAN_INFO)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
5168 fusion->log_to_span_pages);
5169 if (!fusion->log_to_span) {
5170 fusion->log_to_span =
5171 vzalloc(array_size(MAX_LOGICAL_DRIVES_EXT,
5172 sizeof(LD_SPAN_INFO)));
5173 if (!fusion->log_to_span) {
5174 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
5175 __func__, __LINE__);
5176 return -ENOMEM;
5177 }
5178 }
5179
5180 fusion->load_balance_info_pages = get_order(MAX_LOGICAL_DRIVES_EXT *
5181 sizeof(struct LD_LOAD_BALANCE_INFO));
5182 fusion->load_balance_info =
5183 (struct LD_LOAD_BALANCE_INFO *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
5184 fusion->load_balance_info_pages);
5185 if (!fusion->load_balance_info) {
5186 fusion->load_balance_info =
5187 vzalloc(array_size(MAX_LOGICAL_DRIVES_EXT,
5188 sizeof(struct LD_LOAD_BALANCE_INFO)));
5189 if (!fusion->load_balance_info)
5190 dev_err(&instance->pdev->dev, "Failed to allocate load_balance_info, "
5191 "continuing without Load Balance support\n");
5192 }
5193
5194 return 0;
5195}
5196
5197void
5198megasas_free_fusion_context(struct megasas_instance *instance)
5199{
5200 struct fusion_context *fusion = instance->ctrl_context;
5201
5202 if (fusion) {
5203 if (fusion->load_balance_info) {
5204 if (is_vmalloc_addr(fusion->load_balance_info))
5205 vfree(fusion->load_balance_info);
5206 else
5207 free_pages((ulong)fusion->load_balance_info,
5208 fusion->load_balance_info_pages);
5209 }
5210
5211 if (fusion->log_to_span) {
5212 if (is_vmalloc_addr(fusion->log_to_span))
5213 vfree(fusion->log_to_span);
5214 else
5215 free_pages((ulong)fusion->log_to_span,
5216 fusion->log_to_span_pages);
5217 }
5218
5219 kfree(fusion);
5220 }
5221}
5222
5223struct megasas_instance_template megasas_instance_template_fusion = {
5224 .enable_intr = megasas_enable_intr_fusion,
5225 .disable_intr = megasas_disable_intr_fusion,
5226 .clear_intr = megasas_clear_intr_fusion,
5227 .read_fw_status_reg = megasas_read_fw_status_reg_fusion,
5228 .adp_reset = megasas_adp_reset_fusion,
5229 .check_reset = megasas_check_reset_fusion,
5230 .service_isr = megasas_isr_fusion,
5231 .tasklet = megasas_complete_cmd_dpc_fusion,
5232 .init_adapter = megasas_init_adapter_fusion,
5233 .build_and_issue_cmd = megasas_build_and_issue_cmd_fusion,
5234 .issue_dcmd = megasas_issue_dcmd_fusion,
5235};
5236