]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/scsi/megaraid/megaraid_sas_fusion.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-4.14-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave...
[mirror_ubuntu-bionic-kernel.git] / drivers / scsi / megaraid / megaraid_sas_fusion.c
1 /*
2 * Linux MegaRAID driver for SAS based RAID controllers
3 *
4 * Copyright (c) 2009-2013 LSI Corporation
5 * Copyright (c) 2013-2014 Avago Technologies
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 *
20 * FILE: megaraid_sas_fusion.c
21 *
22 * Authors: Avago Technologies
23 * Sumant Patro
24 * Adam Radford
25 * Kashyap Desai <kashyap.desai@avagotech.com>
26 * Sumit Saxena <sumit.saxena@avagotech.com>
27 *
28 * Send feedback to: megaraidlinux.pdl@avagotech.com
29 *
30 * Mail to: Avago Technologies, 350 West Trimble Road, Building 90,
31 * San Jose, California 95131
32 */
33
34 #include <linux/kernel.h>
35 #include <linux/types.h>
36 #include <linux/pci.h>
37 #include <linux/list.h>
38 #include <linux/moduleparam.h>
39 #include <linux/module.h>
40 #include <linux/spinlock.h>
41 #include <linux/interrupt.h>
42 #include <linux/delay.h>
43 #include <linux/uio.h>
44 #include <linux/uaccess.h>
45 #include <linux/fs.h>
46 #include <linux/compat.h>
47 #include <linux/blkdev.h>
48 #include <linux/mutex.h>
49 #include <linux/poll.h>
50 #include <linux/vmalloc.h>
51
52 #include <scsi/scsi.h>
53 #include <scsi/scsi_cmnd.h>
54 #include <scsi/scsi_device.h>
55 #include <scsi/scsi_host.h>
56 #include <scsi/scsi_dbg.h>
57 #include <linux/dmi.h>
58
59 #include "megaraid_sas_fusion.h"
60 #include "megaraid_sas.h"
61
62
63 extern void megasas_free_cmds(struct megasas_instance *instance);
64 extern struct megasas_cmd *megasas_get_cmd(struct megasas_instance
65 *instance);
66 extern void
67 megasas_complete_cmd(struct megasas_instance *instance,
68 struct megasas_cmd *cmd, u8 alt_status);
69 int
70 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
71 int seconds);
72
73 void
74 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd);
75 int megasas_alloc_cmds(struct megasas_instance *instance);
76 int
77 megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs);
78 int
79 megasas_issue_polled(struct megasas_instance *instance,
80 struct megasas_cmd *cmd);
81 void
82 megasas_check_and_restore_queue_depth(struct megasas_instance *instance);
83
84 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
85 void megaraid_sas_kill_hba(struct megasas_instance *instance);
86
87 extern u32 megasas_dbg_lvl;
88 void megasas_sriov_heartbeat_handler(unsigned long instance_addr);
89 int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
90 int initial);
91 void megasas_start_timer(struct megasas_instance *instance,
92 struct timer_list *timer,
93 void *fn, unsigned long interval);
94 extern struct megasas_mgmt_info megasas_mgmt_info;
95 extern unsigned int resetwaittime;
96 extern unsigned int dual_qdepth_disable;
97 static void megasas_free_rdpq_fusion(struct megasas_instance *instance);
98 static void megasas_free_reply_fusion(struct megasas_instance *instance);
99
100
101
102 /**
103 * megasas_enable_intr_fusion - Enables interrupts
104 * @regs: MFI register set
105 */
106 void
107 megasas_enable_intr_fusion(struct megasas_instance *instance)
108 {
109 struct megasas_register_set __iomem *regs;
110 regs = instance->reg_set;
111
112 instance->mask_interrupts = 0;
113 /* For Thunderbolt/Invader also clear intr on enable */
114 writel(~0, &regs->outbound_intr_status);
115 readl(&regs->outbound_intr_status);
116
117 writel(~MFI_FUSION_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
118
119 /* Dummy readl to force pci flush */
120 readl(&regs->outbound_intr_mask);
121 }
122
123 /**
124 * megasas_disable_intr_fusion - Disables interrupt
125 * @regs: MFI register set
126 */
127 void
128 megasas_disable_intr_fusion(struct megasas_instance *instance)
129 {
130 u32 mask = 0xFFFFFFFF;
131 u32 status;
132 struct megasas_register_set __iomem *regs;
133 regs = instance->reg_set;
134 instance->mask_interrupts = 1;
135
136 writel(mask, &regs->outbound_intr_mask);
137 /* Dummy readl to force pci flush */
138 status = readl(&regs->outbound_intr_mask);
139 }
140
141 int
142 megasas_clear_intr_fusion(struct megasas_register_set __iomem *regs)
143 {
144 u32 status;
145 /*
146 * Check if it is our interrupt
147 */
148 status = readl(&regs->outbound_intr_status);
149
150 if (status & 1) {
151 writel(status, &regs->outbound_intr_status);
152 readl(&regs->outbound_intr_status);
153 return 1;
154 }
155 if (!(status & MFI_FUSION_ENABLE_INTERRUPT_MASK))
156 return 0;
157
158 return 1;
159 }
160
161 /**
162 * megasas_get_cmd_fusion - Get a command from the free pool
163 * @instance: Adapter soft state
164 *
165 * Returns a blk_tag indexed mpt frame
166 */
167 inline struct megasas_cmd_fusion *megasas_get_cmd_fusion(struct megasas_instance
168 *instance, u32 blk_tag)
169 {
170 struct fusion_context *fusion;
171
172 fusion = instance->ctrl_context;
173 return fusion->cmd_list[blk_tag];
174 }
175
176 /**
177 * megasas_return_cmd_fusion - Return a cmd to free command pool
178 * @instance: Adapter soft state
179 * @cmd: Command packet to be returned to free command pool
180 */
181 inline void megasas_return_cmd_fusion(struct megasas_instance *instance,
182 struct megasas_cmd_fusion *cmd)
183 {
184 cmd->scmd = NULL;
185 memset(cmd->io_request, 0, MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE);
186 cmd->r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
187 cmd->cmd_completed = false;
188 }
189
190 /**
191 * megasas_fire_cmd_fusion - Sends command to the FW
192 * @instance: Adapter soft state
193 * @req_desc: 32bit or 64bit Request descriptor
194 *
195 * Perform PCI Write. Ventura supports 32 bit Descriptor.
196 * Prior to Ventura (12G) MR controller supports 64 bit Descriptor.
197 */
198
199 static void
200 megasas_fire_cmd_fusion(struct megasas_instance *instance,
201 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc)
202 {
203 if (instance->is_ventura)
204 writel(le32_to_cpu(req_desc->u.low),
205 &instance->reg_set->inbound_single_queue_port);
206 else {
207 #if defined(writeq) && defined(CONFIG_64BIT)
208 u64 req_data = (((u64)le32_to_cpu(req_desc->u.high) << 32) |
209 le32_to_cpu(req_desc->u.low));
210
211 writeq(req_data, &instance->reg_set->inbound_low_queue_port);
212 #else
213 unsigned long flags;
214 spin_lock_irqsave(&instance->hba_lock, flags);
215 writel(le32_to_cpu(req_desc->u.low),
216 &instance->reg_set->inbound_low_queue_port);
217 writel(le32_to_cpu(req_desc->u.high),
218 &instance->reg_set->inbound_high_queue_port);
219 mmiowb();
220 spin_unlock_irqrestore(&instance->hba_lock, flags);
221 #endif
222 }
223 }
224
225 /**
226 * megasas_fusion_update_can_queue - Do all Adapter Queue depth related calculations here
227 * @instance: Adapter soft state
228 * fw_boot_context: Whether this function called during probe or after OCR
229 *
230 * This function is only for fusion controllers.
231 * Update host can queue, if firmware downgrade max supported firmware commands.
232 * Firmware upgrade case will be skiped because underlying firmware has
233 * more resource than exposed to the OS.
234 *
235 */
236 static void
237 megasas_fusion_update_can_queue(struct megasas_instance *instance, int fw_boot_context)
238 {
239 u16 cur_max_fw_cmds = 0;
240 u16 ldio_threshold = 0;
241 struct megasas_register_set __iomem *reg_set;
242
243 reg_set = instance->reg_set;
244
245 /* ventura FW does not fill outbound_scratch_pad_3 with queue depth */
246 if (!instance->is_ventura)
247 cur_max_fw_cmds =
248 readl(&instance->reg_set->outbound_scratch_pad_3) & 0x00FFFF;
249
250 if (dual_qdepth_disable || !cur_max_fw_cmds)
251 cur_max_fw_cmds = instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF;
252 else
253 ldio_threshold =
254 (instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF) - MEGASAS_FUSION_IOCTL_CMDS;
255
256 dev_info(&instance->pdev->dev,
257 "Current firmware maximum commands: %d\t LDIO threshold: %d\n",
258 cur_max_fw_cmds, ldio_threshold);
259
260 if (fw_boot_context == OCR_CONTEXT) {
261 cur_max_fw_cmds = cur_max_fw_cmds - 1;
262 if (cur_max_fw_cmds < instance->max_fw_cmds) {
263 instance->cur_can_queue =
264 cur_max_fw_cmds - (MEGASAS_FUSION_INTERNAL_CMDS +
265 MEGASAS_FUSION_IOCTL_CMDS);
266 instance->host->can_queue = instance->cur_can_queue;
267 instance->ldio_threshold = ldio_threshold;
268 }
269 } else {
270 instance->max_fw_cmds = cur_max_fw_cmds;
271 instance->ldio_threshold = ldio_threshold;
272
273 if (!instance->is_rdpq)
274 instance->max_fw_cmds =
275 min_t(u16, instance->max_fw_cmds, 1024);
276
277 if (reset_devices)
278 instance->max_fw_cmds = min(instance->max_fw_cmds,
279 (u16)MEGASAS_KDUMP_QUEUE_DEPTH);
280 /*
281 * Reduce the max supported cmds by 1. This is to ensure that the
282 * reply_q_sz (1 more than the max cmd that driver may send)
283 * does not exceed max cmds that the FW can support
284 */
285 instance->max_fw_cmds = instance->max_fw_cmds-1;
286
287 instance->max_scsi_cmds = instance->max_fw_cmds -
288 (MEGASAS_FUSION_INTERNAL_CMDS +
289 MEGASAS_FUSION_IOCTL_CMDS);
290 instance->cur_can_queue = instance->max_scsi_cmds;
291 instance->host->can_queue = instance->cur_can_queue;
292 }
293
294 if (instance->is_ventura)
295 instance->max_mpt_cmds =
296 instance->max_fw_cmds * RAID_1_PEER_CMDS;
297 else
298 instance->max_mpt_cmds = instance->max_fw_cmds;
299 }
300 /**
301 * megasas_free_cmds_fusion - Free all the cmds in the free cmd pool
302 * @instance: Adapter soft state
303 */
304 void
305 megasas_free_cmds_fusion(struct megasas_instance *instance)
306 {
307 int i;
308 struct fusion_context *fusion = instance->ctrl_context;
309 struct megasas_cmd_fusion *cmd;
310
311 /* SG, Sense */
312 for (i = 0; i < instance->max_mpt_cmds; i++) {
313 cmd = fusion->cmd_list[i];
314 if (cmd) {
315 if (cmd->sg_frame)
316 dma_pool_free(fusion->sg_dma_pool, cmd->sg_frame,
317 cmd->sg_frame_phys_addr);
318 if (cmd->sense)
319 dma_pool_free(fusion->sense_dma_pool, cmd->sense,
320 cmd->sense_phys_addr);
321 }
322 }
323
324 if (fusion->sg_dma_pool) {
325 dma_pool_destroy(fusion->sg_dma_pool);
326 fusion->sg_dma_pool = NULL;
327 }
328 if (fusion->sense_dma_pool) {
329 dma_pool_destroy(fusion->sense_dma_pool);
330 fusion->sense_dma_pool = NULL;
331 }
332
333
334 /* Reply Frame, Desc*/
335 if (instance->is_rdpq)
336 megasas_free_rdpq_fusion(instance);
337 else
338 megasas_free_reply_fusion(instance);
339
340 /* Request Frame, Desc*/
341 if (fusion->req_frames_desc)
342 dma_free_coherent(&instance->pdev->dev,
343 fusion->request_alloc_sz, fusion->req_frames_desc,
344 fusion->req_frames_desc_phys);
345 if (fusion->io_request_frames)
346 dma_pool_free(fusion->io_request_frames_pool,
347 fusion->io_request_frames,
348 fusion->io_request_frames_phys);
349 if (fusion->io_request_frames_pool) {
350 dma_pool_destroy(fusion->io_request_frames_pool);
351 fusion->io_request_frames_pool = NULL;
352 }
353
354
355 /* cmd_list */
356 for (i = 0; i < instance->max_mpt_cmds; i++)
357 kfree(fusion->cmd_list[i]);
358
359 kfree(fusion->cmd_list);
360 }
361
362 /**
363 * megasas_create_sg_sense_fusion - Creates DMA pool for cmd frames
364 * @instance: Adapter soft state
365 *
366 */
367 static int megasas_create_sg_sense_fusion(struct megasas_instance *instance)
368 {
369 int i;
370 u16 max_cmd;
371 struct fusion_context *fusion;
372 struct megasas_cmd_fusion *cmd;
373
374 fusion = instance->ctrl_context;
375 max_cmd = instance->max_fw_cmds;
376
377
378 fusion->sg_dma_pool =
379 dma_pool_create("mr_sg", &instance->pdev->dev,
380 instance->max_chain_frame_sz,
381 MR_DEFAULT_NVME_PAGE_SIZE, 0);
382 /* SCSI_SENSE_BUFFERSIZE = 96 bytes */
383 fusion->sense_dma_pool =
384 dma_pool_create("mr_sense", &instance->pdev->dev,
385 SCSI_SENSE_BUFFERSIZE, 64, 0);
386
387 if (!fusion->sense_dma_pool || !fusion->sg_dma_pool) {
388 dev_err(&instance->pdev->dev,
389 "Failed from %s %d\n", __func__, __LINE__);
390 return -ENOMEM;
391 }
392
393 /*
394 * Allocate and attach a frame to each of the commands in cmd_list
395 */
396 for (i = 0; i < max_cmd; i++) {
397 cmd = fusion->cmd_list[i];
398 cmd->sg_frame = dma_pool_alloc(fusion->sg_dma_pool,
399 GFP_KERNEL, &cmd->sg_frame_phys_addr);
400
401 cmd->sense = dma_pool_alloc(fusion->sense_dma_pool,
402 GFP_KERNEL, &cmd->sense_phys_addr);
403 if (!cmd->sg_frame || !cmd->sense) {
404 dev_err(&instance->pdev->dev,
405 "Failed from %s %d\n", __func__, __LINE__);
406 return -ENOMEM;
407 }
408 }
409
410 /* create sense buffer for the raid 1/10 fp */
411 for (i = max_cmd; i < instance->max_mpt_cmds; i++) {
412 cmd = fusion->cmd_list[i];
413 cmd->sense = dma_pool_alloc(fusion->sense_dma_pool,
414 GFP_KERNEL, &cmd->sense_phys_addr);
415 if (!cmd->sense) {
416 dev_err(&instance->pdev->dev,
417 "Failed from %s %d\n", __func__, __LINE__);
418 return -ENOMEM;
419 }
420 }
421
422 return 0;
423 }
424
425 int
426 megasas_alloc_cmdlist_fusion(struct megasas_instance *instance)
427 {
428 u32 max_mpt_cmd, i, j;
429 struct fusion_context *fusion;
430
431 fusion = instance->ctrl_context;
432
433 max_mpt_cmd = instance->max_mpt_cmds;
434
435 /*
436 * fusion->cmd_list is an array of struct megasas_cmd_fusion pointers.
437 * Allocate the dynamic array first and then allocate individual
438 * commands.
439 */
440 fusion->cmd_list =
441 kzalloc(sizeof(struct megasas_cmd_fusion *) * max_mpt_cmd,
442 GFP_KERNEL);
443 if (!fusion->cmd_list) {
444 dev_err(&instance->pdev->dev,
445 "Failed from %s %d\n", __func__, __LINE__);
446 return -ENOMEM;
447 }
448
449 for (i = 0; i < max_mpt_cmd; i++) {
450 fusion->cmd_list[i] = kzalloc(sizeof(struct megasas_cmd_fusion),
451 GFP_KERNEL);
452 if (!fusion->cmd_list[i]) {
453 for (j = 0; j < i; j++)
454 kfree(fusion->cmd_list[j]);
455 kfree(fusion->cmd_list);
456 dev_err(&instance->pdev->dev,
457 "Failed from %s %d\n", __func__, __LINE__);
458 return -ENOMEM;
459 }
460 }
461
462 return 0;
463 }
464 int
465 megasas_alloc_request_fusion(struct megasas_instance *instance)
466 {
467 struct fusion_context *fusion;
468
469 fusion = instance->ctrl_context;
470
471 fusion->req_frames_desc =
472 dma_alloc_coherent(&instance->pdev->dev,
473 fusion->request_alloc_sz,
474 &fusion->req_frames_desc_phys, GFP_KERNEL);
475 if (!fusion->req_frames_desc) {
476 dev_err(&instance->pdev->dev,
477 "Failed from %s %d\n", __func__, __LINE__);
478 return -ENOMEM;
479 }
480
481 fusion->io_request_frames_pool =
482 dma_pool_create("mr_ioreq", &instance->pdev->dev,
483 fusion->io_frames_alloc_sz, 16, 0);
484
485 if (!fusion->io_request_frames_pool) {
486 dev_err(&instance->pdev->dev,
487 "Failed from %s %d\n", __func__, __LINE__);
488 return -ENOMEM;
489 }
490
491 fusion->io_request_frames =
492 dma_pool_alloc(fusion->io_request_frames_pool,
493 GFP_KERNEL, &fusion->io_request_frames_phys);
494 if (!fusion->io_request_frames) {
495 dev_err(&instance->pdev->dev,
496 "Failed from %s %d\n", __func__, __LINE__);
497 return -ENOMEM;
498 }
499 return 0;
500 }
501
502 int
503 megasas_alloc_reply_fusion(struct megasas_instance *instance)
504 {
505 int i, count;
506 struct fusion_context *fusion;
507 union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc;
508 fusion = instance->ctrl_context;
509
510 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
511 fusion->reply_frames_desc_pool =
512 dma_pool_create("mr_reply", &instance->pdev->dev,
513 fusion->reply_alloc_sz * count, 16, 0);
514
515 if (!fusion->reply_frames_desc_pool) {
516 dev_err(&instance->pdev->dev,
517 "Failed from %s %d\n", __func__, __LINE__);
518 return -ENOMEM;
519 }
520
521 fusion->reply_frames_desc[0] =
522 dma_pool_alloc(fusion->reply_frames_desc_pool,
523 GFP_KERNEL, &fusion->reply_frames_desc_phys[0]);
524 if (!fusion->reply_frames_desc[0]) {
525 dev_err(&instance->pdev->dev,
526 "Failed from %s %d\n", __func__, __LINE__);
527 return -ENOMEM;
528 }
529 reply_desc = fusion->reply_frames_desc[0];
530 for (i = 0; i < fusion->reply_q_depth * count; i++, reply_desc++)
531 reply_desc->Words = cpu_to_le64(ULLONG_MAX);
532
533 /* This is not a rdpq mode, but driver still populate
534 * reply_frame_desc array to use same msix index in ISR path.
535 */
536 for (i = 0; i < (count - 1); i++)
537 fusion->reply_frames_desc[i + 1] =
538 fusion->reply_frames_desc[i] +
539 (fusion->reply_alloc_sz)/sizeof(union MPI2_REPLY_DESCRIPTORS_UNION);
540
541 return 0;
542 }
543
544 int
545 megasas_alloc_rdpq_fusion(struct megasas_instance *instance)
546 {
547 int i, j, count;
548 struct fusion_context *fusion;
549 union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc;
550
551 fusion = instance->ctrl_context;
552
553 fusion->rdpq_virt = pci_alloc_consistent(instance->pdev,
554 sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) * MAX_MSIX_QUEUES_FUSION,
555 &fusion->rdpq_phys);
556 if (!fusion->rdpq_virt) {
557 dev_err(&instance->pdev->dev,
558 "Failed from %s %d\n", __func__, __LINE__);
559 return -ENOMEM;
560 }
561
562 memset(fusion->rdpq_virt, 0,
563 sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) * MAX_MSIX_QUEUES_FUSION);
564 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
565 fusion->reply_frames_desc_pool = dma_pool_create("mr_rdpq",
566 &instance->pdev->dev,
567 fusion->reply_alloc_sz,
568 16, 0);
569
570 if (!fusion->reply_frames_desc_pool) {
571 dev_err(&instance->pdev->dev,
572 "Failed from %s %d\n", __func__, __LINE__);
573 return -ENOMEM;
574 }
575
576 for (i = 0; i < count; i++) {
577 fusion->reply_frames_desc[i] =
578 dma_pool_alloc(fusion->reply_frames_desc_pool,
579 GFP_KERNEL, &fusion->reply_frames_desc_phys[i]);
580 if (!fusion->reply_frames_desc[i]) {
581 dev_err(&instance->pdev->dev,
582 "Failed from %s %d\n", __func__, __LINE__);
583 return -ENOMEM;
584 }
585
586 fusion->rdpq_virt[i].RDPQBaseAddress =
587 cpu_to_le64(fusion->reply_frames_desc_phys[i]);
588
589 reply_desc = fusion->reply_frames_desc[i];
590 for (j = 0; j < fusion->reply_q_depth; j++, reply_desc++)
591 reply_desc->Words = cpu_to_le64(ULLONG_MAX);
592 }
593 return 0;
594 }
595
596 static void
597 megasas_free_rdpq_fusion(struct megasas_instance *instance) {
598
599 int i;
600 struct fusion_context *fusion;
601
602 fusion = instance->ctrl_context;
603
604 for (i = 0; i < MAX_MSIX_QUEUES_FUSION; i++) {
605 if (fusion->reply_frames_desc[i])
606 dma_pool_free(fusion->reply_frames_desc_pool,
607 fusion->reply_frames_desc[i],
608 fusion->reply_frames_desc_phys[i]);
609 }
610
611 if (fusion->reply_frames_desc_pool)
612 dma_pool_destroy(fusion->reply_frames_desc_pool);
613
614 if (fusion->rdpq_virt)
615 pci_free_consistent(instance->pdev,
616 sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) * MAX_MSIX_QUEUES_FUSION,
617 fusion->rdpq_virt, fusion->rdpq_phys);
618 }
619
620 static void
621 megasas_free_reply_fusion(struct megasas_instance *instance) {
622
623 struct fusion_context *fusion;
624
625 fusion = instance->ctrl_context;
626
627 if (fusion->reply_frames_desc[0])
628 dma_pool_free(fusion->reply_frames_desc_pool,
629 fusion->reply_frames_desc[0],
630 fusion->reply_frames_desc_phys[0]);
631
632 if (fusion->reply_frames_desc_pool)
633 dma_pool_destroy(fusion->reply_frames_desc_pool);
634
635 }
636
637
638 /**
639 * megasas_alloc_cmds_fusion - Allocates the command packets
640 * @instance: Adapter soft state
641 *
642 *
643 * Each frame has a 32-bit field called context. This context is used to get
644 * back the megasas_cmd_fusion from the frame when a frame gets completed
645 * In this driver, the 32 bit values are the indices into an array cmd_list.
646 * This array is used only to look up the megasas_cmd_fusion given the context.
647 * The free commands themselves are maintained in a linked list called cmd_pool.
648 *
649 * cmds are formed in the io_request and sg_frame members of the
650 * megasas_cmd_fusion. The context field is used to get a request descriptor
651 * and is used as SMID of the cmd.
652 * SMID value range is from 1 to max_fw_cmds.
653 */
654 int
655 megasas_alloc_cmds_fusion(struct megasas_instance *instance)
656 {
657 int i;
658 struct fusion_context *fusion;
659 struct megasas_cmd_fusion *cmd;
660 u32 offset;
661 dma_addr_t io_req_base_phys;
662 u8 *io_req_base;
663
664
665 fusion = instance->ctrl_context;
666
667 if (megasas_alloc_cmdlist_fusion(instance))
668 goto fail_exit;
669
670 if (megasas_alloc_request_fusion(instance))
671 goto fail_exit;
672
673 if (instance->is_rdpq) {
674 if (megasas_alloc_rdpq_fusion(instance))
675 goto fail_exit;
676 } else
677 if (megasas_alloc_reply_fusion(instance))
678 goto fail_exit;
679
680
681 /* The first 256 bytes (SMID 0) is not used. Don't add to the cmd list */
682 io_req_base = fusion->io_request_frames + MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE;
683 io_req_base_phys = fusion->io_request_frames_phys + MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE;
684
685 /*
686 * Add all the commands to command pool (fusion->cmd_pool)
687 */
688
689 /* SMID 0 is reserved. Set SMID/index from 1 */
690 for (i = 0; i < instance->max_mpt_cmds; i++) {
691 cmd = fusion->cmd_list[i];
692 offset = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE * i;
693 memset(cmd, 0, sizeof(struct megasas_cmd_fusion));
694 cmd->index = i + 1;
695 cmd->scmd = NULL;
696 cmd->sync_cmd_idx =
697 (i >= instance->max_scsi_cmds && i < instance->max_fw_cmds) ?
698 (i - instance->max_scsi_cmds) :
699 (u32)ULONG_MAX; /* Set to Invalid */
700 cmd->instance = instance;
701 cmd->io_request =
702 (struct MPI2_RAID_SCSI_IO_REQUEST *)
703 (io_req_base + offset);
704 memset(cmd->io_request, 0,
705 sizeof(struct MPI2_RAID_SCSI_IO_REQUEST));
706 cmd->io_request_phys_addr = io_req_base_phys + offset;
707 cmd->r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
708 }
709
710 if (megasas_create_sg_sense_fusion(instance))
711 goto fail_exit;
712
713 return 0;
714
715 fail_exit:
716 megasas_free_cmds_fusion(instance);
717 return -ENOMEM;
718 }
719
720 /**
721 * wait_and_poll - Issues a polling command
722 * @instance: Adapter soft state
723 * @cmd: Command packet to be issued
724 *
725 * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
726 */
727 int
728 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
729 int seconds)
730 {
731 int i;
732 struct megasas_header *frame_hdr = &cmd->frame->hdr;
733 struct fusion_context *fusion;
734
735 u32 msecs = seconds * 1000;
736
737 fusion = instance->ctrl_context;
738 /*
739 * Wait for cmd_status to change
740 */
741 for (i = 0; (i < msecs) && (frame_hdr->cmd_status == 0xff); i += 20) {
742 rmb();
743 msleep(20);
744 }
745
746 if (frame_hdr->cmd_status == MFI_STAT_INVALID_STATUS)
747 return DCMD_TIMEOUT;
748 else if (frame_hdr->cmd_status == MFI_STAT_OK)
749 return DCMD_SUCCESS;
750 else
751 return DCMD_FAILED;
752 }
753
754 /**
755 * megasas_ioc_init_fusion - Initializes the FW
756 * @instance: Adapter soft state
757 *
758 * Issues the IOC Init cmd
759 */
760 int
761 megasas_ioc_init_fusion(struct megasas_instance *instance)
762 {
763 struct megasas_init_frame *init_frame;
764 struct MPI2_IOC_INIT_REQUEST *IOCInitMessage = NULL;
765 dma_addr_t ioc_init_handle;
766 struct megasas_cmd *cmd;
767 u8 ret, cur_rdpq_mode;
768 struct fusion_context *fusion;
769 union MEGASAS_REQUEST_DESCRIPTOR_UNION req_desc;
770 int i;
771 struct megasas_header *frame_hdr;
772 const char *sys_info;
773 MFI_CAPABILITIES *drv_ops;
774 u32 scratch_pad_2;
775 unsigned long flags;
776
777 fusion = instance->ctrl_context;
778
779 cmd = megasas_get_cmd(instance);
780
781 if (!cmd) {
782 dev_err(&instance->pdev->dev, "Could not allocate cmd for INIT Frame\n");
783 ret = 1;
784 goto fail_get_cmd;
785 }
786
787 scratch_pad_2 = readl
788 (&instance->reg_set->outbound_scratch_pad_2);
789
790 cur_rdpq_mode = (scratch_pad_2 & MR_RDPQ_MODE_OFFSET) ? 1 : 0;
791
792 if (instance->is_rdpq && !cur_rdpq_mode) {
793 dev_err(&instance->pdev->dev, "Firmware downgrade *NOT SUPPORTED*"
794 " from RDPQ mode to non RDPQ mode\n");
795 ret = 1;
796 goto fail_fw_init;
797 }
798
799 instance->fw_sync_cache_support = (scratch_pad_2 &
800 MR_CAN_HANDLE_SYNC_CACHE_OFFSET) ? 1 : 0;
801 dev_info(&instance->pdev->dev, "FW supports sync cache\t: %s\n",
802 instance->fw_sync_cache_support ? "Yes" : "No");
803
804 IOCInitMessage =
805 dma_alloc_coherent(&instance->pdev->dev,
806 sizeof(struct MPI2_IOC_INIT_REQUEST),
807 &ioc_init_handle, GFP_KERNEL);
808
809 if (!IOCInitMessage) {
810 dev_err(&instance->pdev->dev, "Could not allocate memory for "
811 "IOCInitMessage\n");
812 ret = 1;
813 goto fail_fw_init;
814 }
815
816 memset(IOCInitMessage, 0, sizeof(struct MPI2_IOC_INIT_REQUEST));
817
818 IOCInitMessage->Function = MPI2_FUNCTION_IOC_INIT;
819 IOCInitMessage->WhoInit = MPI2_WHOINIT_HOST_DRIVER;
820 IOCInitMessage->MsgVersion = cpu_to_le16(MPI2_VERSION);
821 IOCInitMessage->HeaderVersion = cpu_to_le16(MPI2_HEADER_VERSION);
822 IOCInitMessage->SystemRequestFrameSize = cpu_to_le16(MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE / 4);
823
824 IOCInitMessage->ReplyDescriptorPostQueueDepth = cpu_to_le16(fusion->reply_q_depth);
825 IOCInitMessage->ReplyDescriptorPostQueueAddress = instance->is_rdpq ?
826 cpu_to_le64(fusion->rdpq_phys) :
827 cpu_to_le64(fusion->reply_frames_desc_phys[0]);
828 IOCInitMessage->MsgFlags = instance->is_rdpq ?
829 MPI2_IOCINIT_MSGFLAG_RDPQ_ARRAY_MODE : 0;
830 IOCInitMessage->SystemRequestFrameBaseAddress = cpu_to_le64(fusion->io_request_frames_phys);
831 IOCInitMessage->HostMSIxVectors = instance->msix_vectors;
832 IOCInitMessage->HostPageSize = MR_DEFAULT_NVME_PAGE_SHIFT;
833 init_frame = (struct megasas_init_frame *)cmd->frame;
834 memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
835
836 frame_hdr = &cmd->frame->hdr;
837 frame_hdr->cmd_status = 0xFF;
838 frame_hdr->flags = cpu_to_le16(
839 le16_to_cpu(frame_hdr->flags) |
840 MFI_FRAME_DONT_POST_IN_REPLY_QUEUE);
841
842 init_frame->cmd = MFI_CMD_INIT;
843 init_frame->cmd_status = 0xFF;
844
845 drv_ops = (MFI_CAPABILITIES *) &(init_frame->driver_operations);
846
847 /* driver support Extended MSIX */
848 if (fusion->adapter_type >= INVADER_SERIES)
849 drv_ops->mfi_capabilities.support_additional_msix = 1;
850 /* driver supports HA / Remote LUN over Fast Path interface */
851 drv_ops->mfi_capabilities.support_fp_remote_lun = 1;
852
853 drv_ops->mfi_capabilities.support_max_255lds = 1;
854 drv_ops->mfi_capabilities.support_ndrive_r1_lb = 1;
855 drv_ops->mfi_capabilities.security_protocol_cmds_fw = 1;
856
857 if (instance->max_chain_frame_sz > MEGASAS_CHAIN_FRAME_SZ_MIN)
858 drv_ops->mfi_capabilities.support_ext_io_size = 1;
859
860 drv_ops->mfi_capabilities.support_fp_rlbypass = 1;
861 if (!dual_qdepth_disable)
862 drv_ops->mfi_capabilities.support_ext_queue_depth = 1;
863
864 drv_ops->mfi_capabilities.support_qd_throttling = 1;
865 drv_ops->mfi_capabilities.support_pd_map_target_id = 1;
866 /* Convert capability to LE32 */
867 cpu_to_le32s((u32 *)&init_frame->driver_operations.mfi_capabilities);
868
869 sys_info = dmi_get_system_info(DMI_PRODUCT_UUID);
870 if (instance->system_info_buf && sys_info) {
871 memcpy(instance->system_info_buf->systemId, sys_info,
872 strlen(sys_info) > 64 ? 64 : strlen(sys_info));
873 instance->system_info_buf->systemIdLength =
874 strlen(sys_info) > 64 ? 64 : strlen(sys_info);
875 init_frame->system_info_lo = instance->system_info_h;
876 init_frame->system_info_hi = 0;
877 }
878
879 init_frame->queue_info_new_phys_addr_hi =
880 cpu_to_le32(upper_32_bits(ioc_init_handle));
881 init_frame->queue_info_new_phys_addr_lo =
882 cpu_to_le32(lower_32_bits(ioc_init_handle));
883 init_frame->data_xfer_len = cpu_to_le32(sizeof(struct MPI2_IOC_INIT_REQUEST));
884
885 req_desc.u.low = cpu_to_le32(lower_32_bits(cmd->frame_phys_addr));
886 req_desc.u.high = cpu_to_le32(upper_32_bits(cmd->frame_phys_addr));
887 req_desc.MFAIo.RequestFlags =
888 (MEGASAS_REQ_DESCRIPT_FLAGS_MFA <<
889 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
890
891 /*
892 * disable the intr before firing the init frame
893 */
894 instance->instancet->disable_intr(instance);
895
896 for (i = 0; i < (10 * 1000); i += 20) {
897 if (readl(&instance->reg_set->doorbell) & 1)
898 msleep(20);
899 else
900 break;
901 }
902
903 /* For Ventura also IOC INIT required 64 bit Descriptor write. */
904 spin_lock_irqsave(&instance->hba_lock, flags);
905 writel(le32_to_cpu(req_desc.u.low),
906 &instance->reg_set->inbound_low_queue_port);
907 writel(le32_to_cpu(req_desc.u.high),
908 &instance->reg_set->inbound_high_queue_port);
909 mmiowb();
910 spin_unlock_irqrestore(&instance->hba_lock, flags);
911
912 wait_and_poll(instance, cmd, MFI_POLL_TIMEOUT_SECS);
913
914 frame_hdr = &cmd->frame->hdr;
915 if (frame_hdr->cmd_status != 0) {
916 ret = 1;
917 goto fail_fw_init;
918 }
919
920 ret = 0;
921
922 fail_fw_init:
923 megasas_return_cmd(instance, cmd);
924 if (IOCInitMessage)
925 dma_free_coherent(&instance->pdev->dev,
926 sizeof(struct MPI2_IOC_INIT_REQUEST),
927 IOCInitMessage, ioc_init_handle);
928 fail_get_cmd:
929 dev_err(&instance->pdev->dev,
930 "Init cmd return status %s for SCSI host %d\n",
931 ret ? "FAILED" : "SUCCESS", instance->host->host_no);
932
933 return ret;
934 }
935
936 /**
937 * megasas_sync_pd_seq_num - JBOD SEQ MAP
938 * @instance: Adapter soft state
939 * @pend: set to 1, if it is pended jbod map.
940 *
941 * Issue Jbod map to the firmware. If it is pended command,
942 * issue command and return. If it is first instance of jbod map
943 * issue and receive command.
944 */
945 int
946 megasas_sync_pd_seq_num(struct megasas_instance *instance, bool pend) {
947 int ret = 0;
948 u32 pd_seq_map_sz;
949 struct megasas_cmd *cmd;
950 struct megasas_dcmd_frame *dcmd;
951 struct fusion_context *fusion = instance->ctrl_context;
952 struct MR_PD_CFG_SEQ_NUM_SYNC *pd_sync;
953 dma_addr_t pd_seq_h;
954
955 pd_sync = (void *)fusion->pd_seq_sync[(instance->pd_seq_map_id & 1)];
956 pd_seq_h = fusion->pd_seq_phys[(instance->pd_seq_map_id & 1)];
957 pd_seq_map_sz = sizeof(struct MR_PD_CFG_SEQ_NUM_SYNC) +
958 (sizeof(struct MR_PD_CFG_SEQ) *
959 (MAX_PHYSICAL_DEVICES - 1));
960
961 cmd = megasas_get_cmd(instance);
962 if (!cmd) {
963 dev_err(&instance->pdev->dev,
964 "Could not get mfi cmd. Fail from %s %d\n",
965 __func__, __LINE__);
966 return -ENOMEM;
967 }
968
969 dcmd = &cmd->frame->dcmd;
970
971 memset(pd_sync, 0, pd_seq_map_sz);
972 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
973 dcmd->cmd = MFI_CMD_DCMD;
974 dcmd->cmd_status = 0xFF;
975 dcmd->sge_count = 1;
976 dcmd->timeout = 0;
977 dcmd->pad_0 = 0;
978 dcmd->data_xfer_len = cpu_to_le32(pd_seq_map_sz);
979 dcmd->opcode = cpu_to_le32(MR_DCMD_SYSTEM_PD_MAP_GET_INFO);
980 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(pd_seq_h);
981 dcmd->sgl.sge32[0].length = cpu_to_le32(pd_seq_map_sz);
982
983 if (pend) {
984 dcmd->mbox.b[0] = MEGASAS_DCMD_MBOX_PEND_FLAG;
985 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_WRITE);
986 instance->jbod_seq_cmd = cmd;
987 instance->instancet->issue_dcmd(instance, cmd);
988 return 0;
989 }
990
991 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
992
993 /* Below code is only for non pended DCMD */
994 if (instance->ctrl_context && !instance->mask_interrupts)
995 ret = megasas_issue_blocked_cmd(instance, cmd,
996 MFI_IO_TIMEOUT_SECS);
997 else
998 ret = megasas_issue_polled(instance, cmd);
999
1000 if (le32_to_cpu(pd_sync->count) > MAX_PHYSICAL_DEVICES) {
1001 dev_warn(&instance->pdev->dev,
1002 "driver supports max %d JBOD, but FW reports %d\n",
1003 MAX_PHYSICAL_DEVICES, le32_to_cpu(pd_sync->count));
1004 ret = -EINVAL;
1005 }
1006
1007 if (ret == DCMD_TIMEOUT && instance->ctrl_context)
1008 megaraid_sas_kill_hba(instance);
1009
1010 if (ret == DCMD_SUCCESS)
1011 instance->pd_seq_map_id++;
1012
1013 megasas_return_cmd(instance, cmd);
1014 return ret;
1015 }
1016
1017 /*
1018 * megasas_get_ld_map_info - Returns FW's ld_map structure
1019 * @instance: Adapter soft state
1020 * @pend: Pend the command or not
1021 * Issues an internal command (DCMD) to get the FW's controller PD
1022 * list structure. This information is mainly used to find out SYSTEM
1023 * supported by the FW.
1024 * dcmd.mbox value setting for MR_DCMD_LD_MAP_GET_INFO
1025 * dcmd.mbox.b[0] - number of LDs being sync'd
1026 * dcmd.mbox.b[1] - 0 - complete command immediately.
1027 * - 1 - pend till config change
1028 * dcmd.mbox.b[2] - 0 - supports max 64 lds and uses legacy MR_FW_RAID_MAP
1029 * - 1 - supports max MAX_LOGICAL_DRIVES_EXT lds and
1030 * uses extended struct MR_FW_RAID_MAP_EXT
1031 */
1032 static int
1033 megasas_get_ld_map_info(struct megasas_instance *instance)
1034 {
1035 int ret = 0;
1036 struct megasas_cmd *cmd;
1037 struct megasas_dcmd_frame *dcmd;
1038 void *ci;
1039 dma_addr_t ci_h = 0;
1040 u32 size_map_info;
1041 struct fusion_context *fusion;
1042
1043 cmd = megasas_get_cmd(instance);
1044
1045 if (!cmd) {
1046 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get cmd for map info\n");
1047 return -ENOMEM;
1048 }
1049
1050 fusion = instance->ctrl_context;
1051
1052 if (!fusion) {
1053 megasas_return_cmd(instance, cmd);
1054 return -ENXIO;
1055 }
1056
1057 dcmd = &cmd->frame->dcmd;
1058
1059 size_map_info = fusion->current_map_sz;
1060
1061 ci = (void *) fusion->ld_map[(instance->map_id & 1)];
1062 ci_h = fusion->ld_map_phys[(instance->map_id & 1)];
1063
1064 if (!ci) {
1065 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc mem for ld_map_info\n");
1066 megasas_return_cmd(instance, cmd);
1067 return -ENOMEM;
1068 }
1069
1070 memset(ci, 0, fusion->max_map_sz);
1071 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
1072 dcmd->cmd = MFI_CMD_DCMD;
1073 dcmd->cmd_status = 0xFF;
1074 dcmd->sge_count = 1;
1075 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
1076 dcmd->timeout = 0;
1077 dcmd->pad_0 = 0;
1078 dcmd->data_xfer_len = cpu_to_le32(size_map_info);
1079 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_MAP_GET_INFO);
1080 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
1081 dcmd->sgl.sge32[0].length = cpu_to_le32(size_map_info);
1082
1083 if (instance->ctrl_context && !instance->mask_interrupts)
1084 ret = megasas_issue_blocked_cmd(instance, cmd,
1085 MFI_IO_TIMEOUT_SECS);
1086 else
1087 ret = megasas_issue_polled(instance, cmd);
1088
1089 if (ret == DCMD_TIMEOUT && instance->ctrl_context)
1090 megaraid_sas_kill_hba(instance);
1091
1092 megasas_return_cmd(instance, cmd);
1093
1094 return ret;
1095 }
1096
1097 u8
1098 megasas_get_map_info(struct megasas_instance *instance)
1099 {
1100 struct fusion_context *fusion = instance->ctrl_context;
1101
1102 fusion->fast_path_io = 0;
1103 if (!megasas_get_ld_map_info(instance)) {
1104 if (MR_ValidateMapInfo(instance)) {
1105 fusion->fast_path_io = 1;
1106 return 0;
1107 }
1108 }
1109 return 1;
1110 }
1111
1112 /*
1113 * megasas_sync_map_info - Returns FW's ld_map structure
1114 * @instance: Adapter soft state
1115 *
1116 * Issues an internal command (DCMD) to get the FW's controller PD
1117 * list structure. This information is mainly used to find out SYSTEM
1118 * supported by the FW.
1119 */
1120 int
1121 megasas_sync_map_info(struct megasas_instance *instance)
1122 {
1123 int i;
1124 struct megasas_cmd *cmd;
1125 struct megasas_dcmd_frame *dcmd;
1126 u16 num_lds;
1127 u32 size_sync_info;
1128 struct fusion_context *fusion;
1129 struct MR_LD_TARGET_SYNC *ci = NULL;
1130 struct MR_DRV_RAID_MAP_ALL *map;
1131 struct MR_LD_RAID *raid;
1132 struct MR_LD_TARGET_SYNC *ld_sync;
1133 dma_addr_t ci_h = 0;
1134 u32 size_map_info;
1135
1136 cmd = megasas_get_cmd(instance);
1137
1138 if (!cmd) {
1139 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get cmd for sync info\n");
1140 return -ENOMEM;
1141 }
1142
1143 fusion = instance->ctrl_context;
1144
1145 if (!fusion) {
1146 megasas_return_cmd(instance, cmd);
1147 return 1;
1148 }
1149
1150 map = fusion->ld_drv_map[instance->map_id & 1];
1151
1152 num_lds = le16_to_cpu(map->raidMap.ldCount);
1153
1154 dcmd = &cmd->frame->dcmd;
1155
1156 size_sync_info = sizeof(struct MR_LD_TARGET_SYNC) *num_lds;
1157
1158 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
1159
1160 ci = (struct MR_LD_TARGET_SYNC *)
1161 fusion->ld_map[(instance->map_id - 1) & 1];
1162 memset(ci, 0, fusion->max_map_sz);
1163
1164 ci_h = fusion->ld_map_phys[(instance->map_id - 1) & 1];
1165
1166 ld_sync = (struct MR_LD_TARGET_SYNC *)ci;
1167
1168 for (i = 0; i < num_lds; i++, ld_sync++) {
1169 raid = MR_LdRaidGet(i, map);
1170 ld_sync->targetId = MR_GetLDTgtId(i, map);
1171 ld_sync->seqNum = raid->seqNum;
1172 }
1173
1174 size_map_info = fusion->current_map_sz;
1175
1176 dcmd->cmd = MFI_CMD_DCMD;
1177 dcmd->cmd_status = 0xFF;
1178 dcmd->sge_count = 1;
1179 dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_WRITE);
1180 dcmd->timeout = 0;
1181 dcmd->pad_0 = 0;
1182 dcmd->data_xfer_len = cpu_to_le32(size_map_info);
1183 dcmd->mbox.b[0] = num_lds;
1184 dcmd->mbox.b[1] = MEGASAS_DCMD_MBOX_PEND_FLAG;
1185 dcmd->opcode = cpu_to_le32(MR_DCMD_LD_MAP_GET_INFO);
1186 dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
1187 dcmd->sgl.sge32[0].length = cpu_to_le32(size_map_info);
1188
1189 instance->map_update_cmd = cmd;
1190
1191 instance->instancet->issue_dcmd(instance, cmd);
1192
1193 return 0;
1194 }
1195
1196 /*
1197 * meagasas_display_intel_branding - Display branding string
1198 * @instance: per adapter object
1199 *
1200 * Return nothing.
1201 */
1202 static void
1203 megasas_display_intel_branding(struct megasas_instance *instance)
1204 {
1205 if (instance->pdev->subsystem_vendor != PCI_VENDOR_ID_INTEL)
1206 return;
1207
1208 switch (instance->pdev->device) {
1209 case PCI_DEVICE_ID_LSI_INVADER:
1210 switch (instance->pdev->subsystem_device) {
1211 case MEGARAID_INTEL_RS3DC080_SSDID:
1212 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1213 instance->host->host_no,
1214 MEGARAID_INTEL_RS3DC080_BRANDING);
1215 break;
1216 case MEGARAID_INTEL_RS3DC040_SSDID:
1217 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1218 instance->host->host_no,
1219 MEGARAID_INTEL_RS3DC040_BRANDING);
1220 break;
1221 case MEGARAID_INTEL_RS3SC008_SSDID:
1222 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1223 instance->host->host_no,
1224 MEGARAID_INTEL_RS3SC008_BRANDING);
1225 break;
1226 case MEGARAID_INTEL_RS3MC044_SSDID:
1227 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1228 instance->host->host_no,
1229 MEGARAID_INTEL_RS3MC044_BRANDING);
1230 break;
1231 default:
1232 break;
1233 }
1234 break;
1235 case PCI_DEVICE_ID_LSI_FURY:
1236 switch (instance->pdev->subsystem_device) {
1237 case MEGARAID_INTEL_RS3WC080_SSDID:
1238 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1239 instance->host->host_no,
1240 MEGARAID_INTEL_RS3WC080_BRANDING);
1241 break;
1242 case MEGARAID_INTEL_RS3WC040_SSDID:
1243 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1244 instance->host->host_no,
1245 MEGARAID_INTEL_RS3WC040_BRANDING);
1246 break;
1247 default:
1248 break;
1249 }
1250 break;
1251 case PCI_DEVICE_ID_LSI_CUTLASS_52:
1252 case PCI_DEVICE_ID_LSI_CUTLASS_53:
1253 switch (instance->pdev->subsystem_device) {
1254 case MEGARAID_INTEL_RMS3BC160_SSDID:
1255 dev_info(&instance->pdev->dev, "scsi host %d: %s\n",
1256 instance->host->host_no,
1257 MEGARAID_INTEL_RMS3BC160_BRANDING);
1258 break;
1259 default:
1260 break;
1261 }
1262 break;
1263 default:
1264 break;
1265 }
1266 }
1267
1268 /**
1269 * megasas_allocate_raid_maps - Allocate memory for RAID maps
1270 * @instance: Adapter soft state
1271 *
1272 * return: if success: return 0
1273 * failed: return -ENOMEM
1274 */
1275 static inline int megasas_allocate_raid_maps(struct megasas_instance *instance)
1276 {
1277 struct fusion_context *fusion;
1278 int i = 0;
1279
1280 fusion = instance->ctrl_context;
1281
1282 fusion->drv_map_pages = get_order(fusion->drv_map_sz);
1283
1284 for (i = 0; i < 2; i++) {
1285 fusion->ld_map[i] = NULL;
1286
1287 fusion->ld_drv_map[i] = (void *)
1288 __get_free_pages(__GFP_ZERO | GFP_KERNEL,
1289 fusion->drv_map_pages);
1290
1291 if (!fusion->ld_drv_map[i]) {
1292 fusion->ld_drv_map[i] = vzalloc(fusion->drv_map_sz);
1293
1294 if (!fusion->ld_drv_map[i]) {
1295 dev_err(&instance->pdev->dev,
1296 "Could not allocate memory for local map"
1297 " size requested: %d\n",
1298 fusion->drv_map_sz);
1299 goto ld_drv_map_alloc_fail;
1300 }
1301 }
1302 }
1303
1304 for (i = 0; i < 2; i++) {
1305 fusion->ld_map[i] = dma_alloc_coherent(&instance->pdev->dev,
1306 fusion->max_map_sz,
1307 &fusion->ld_map_phys[i],
1308 GFP_KERNEL);
1309 if (!fusion->ld_map[i]) {
1310 dev_err(&instance->pdev->dev,
1311 "Could not allocate memory for map info %s:%d\n",
1312 __func__, __LINE__);
1313 goto ld_map_alloc_fail;
1314 }
1315 }
1316
1317 return 0;
1318
1319 ld_map_alloc_fail:
1320 for (i = 0; i < 2; i++) {
1321 if (fusion->ld_map[i])
1322 dma_free_coherent(&instance->pdev->dev,
1323 fusion->max_map_sz,
1324 fusion->ld_map[i],
1325 fusion->ld_map_phys[i]);
1326 }
1327
1328 ld_drv_map_alloc_fail:
1329 for (i = 0; i < 2; i++) {
1330 if (fusion->ld_drv_map[i]) {
1331 if (is_vmalloc_addr(fusion->ld_drv_map[i]))
1332 vfree(fusion->ld_drv_map[i]);
1333 else
1334 free_pages((ulong)fusion->ld_drv_map[i],
1335 fusion->drv_map_pages);
1336 }
1337 }
1338
1339 return -ENOMEM;
1340 }
1341
1342 /**
1343 * megasas_init_adapter_fusion - Initializes the FW
1344 * @instance: Adapter soft state
1345 *
1346 * This is the main function for initializing firmware.
1347 */
1348 u32
1349 megasas_init_adapter_fusion(struct megasas_instance *instance)
1350 {
1351 struct megasas_register_set __iomem *reg_set;
1352 struct fusion_context *fusion;
1353 u16 max_cmd;
1354 u32 scratch_pad_2;
1355 int i = 0, count;
1356
1357 fusion = instance->ctrl_context;
1358
1359 reg_set = instance->reg_set;
1360
1361 megasas_fusion_update_can_queue(instance, PROBE_CONTEXT);
1362
1363 /*
1364 * Only Driver's internal DCMDs and IOCTL DCMDs needs to have MFI frames
1365 */
1366 instance->max_mfi_cmds =
1367 MEGASAS_FUSION_INTERNAL_CMDS + MEGASAS_FUSION_IOCTL_CMDS;
1368
1369 max_cmd = instance->max_fw_cmds;
1370
1371 fusion->reply_q_depth = 2 * (((max_cmd + 1 + 15)/16)*16);
1372
1373 fusion->request_alloc_sz =
1374 sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) * instance->max_mpt_cmds;
1375 fusion->reply_alloc_sz = sizeof(union MPI2_REPLY_DESCRIPTORS_UNION)
1376 *(fusion->reply_q_depth);
1377 fusion->io_frames_alloc_sz = MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE +
1378 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE
1379 * (instance->max_mpt_cmds + 1)); /* Extra 1 for SMID 0 */
1380
1381 scratch_pad_2 = readl(&instance->reg_set->outbound_scratch_pad_2);
1382 /* If scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_UNITS_MASK is set,
1383 * Firmware support extended IO chain frame which is 4 times more than
1384 * legacy Firmware.
1385 * Legacy Firmware - Frame size is (8 * 128) = 1K
1386 * 1M IO Firmware - Frame size is (8 * 128 * 4) = 4K
1387 */
1388 if (scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_UNITS_MASK)
1389 instance->max_chain_frame_sz =
1390 ((scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_MASK) >>
1391 MEGASAS_MAX_CHAIN_SHIFT) * MEGASAS_1MB_IO;
1392 else
1393 instance->max_chain_frame_sz =
1394 ((scratch_pad_2 & MEGASAS_MAX_CHAIN_SIZE_MASK) >>
1395 MEGASAS_MAX_CHAIN_SHIFT) * MEGASAS_256K_IO;
1396
1397 if (instance->max_chain_frame_sz < MEGASAS_CHAIN_FRAME_SZ_MIN) {
1398 dev_warn(&instance->pdev->dev, "frame size %d invalid, fall back to legacy max frame size %d\n",
1399 instance->max_chain_frame_sz,
1400 MEGASAS_CHAIN_FRAME_SZ_MIN);
1401 instance->max_chain_frame_sz = MEGASAS_CHAIN_FRAME_SZ_MIN;
1402 }
1403
1404 fusion->max_sge_in_main_msg =
1405 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE
1406 - offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL))/16;
1407
1408 fusion->max_sge_in_chain =
1409 instance->max_chain_frame_sz
1410 / sizeof(union MPI2_SGE_IO_UNION);
1411
1412 instance->max_num_sge =
1413 rounddown_pow_of_two(fusion->max_sge_in_main_msg
1414 + fusion->max_sge_in_chain - 2);
1415
1416 /* Used for pass thru MFI frame (DCMD) */
1417 fusion->chain_offset_mfi_pthru =
1418 offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL)/16;
1419
1420 fusion->chain_offset_io_request =
1421 (MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE -
1422 sizeof(union MPI2_SGE_IO_UNION))/16;
1423
1424 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
1425 for (i = 0 ; i < count; i++)
1426 fusion->last_reply_idx[i] = 0;
1427
1428 /*
1429 * For fusion adapters, 3 commands for IOCTL and 8 commands
1430 * for driver's internal DCMDs.
1431 */
1432 instance->max_scsi_cmds = instance->max_fw_cmds -
1433 (MEGASAS_FUSION_INTERNAL_CMDS +
1434 MEGASAS_FUSION_IOCTL_CMDS);
1435 sema_init(&instance->ioctl_sem, MEGASAS_FUSION_IOCTL_CMDS);
1436
1437 /*
1438 * Allocate memory for descriptors
1439 * Create a pool of commands
1440 */
1441 if (megasas_alloc_cmds(instance))
1442 goto fail_alloc_mfi_cmds;
1443 if (megasas_alloc_cmds_fusion(instance))
1444 goto fail_alloc_cmds;
1445
1446 if (megasas_ioc_init_fusion(instance))
1447 goto fail_ioc_init;
1448
1449 megasas_display_intel_branding(instance);
1450 if (megasas_get_ctrl_info(instance)) {
1451 dev_err(&instance->pdev->dev,
1452 "Could not get controller info. Fail from %s %d\n",
1453 __func__, __LINE__);
1454 goto fail_ioc_init;
1455 }
1456
1457 instance->flag_ieee = 1;
1458 instance->r1_ldio_hint_default = MR_R1_LDIO_PIGGYBACK_DEFAULT;
1459 fusion->fast_path_io = 0;
1460
1461 if (megasas_allocate_raid_maps(instance))
1462 goto fail_ioc_init;
1463
1464 if (!megasas_get_map_info(instance))
1465 megasas_sync_map_info(instance);
1466
1467 return 0;
1468
1469 fail_ioc_init:
1470 megasas_free_cmds_fusion(instance);
1471 fail_alloc_cmds:
1472 megasas_free_cmds(instance);
1473 fail_alloc_mfi_cmds:
1474 return 1;
1475 }
1476
1477 /**
1478 * map_cmd_status - Maps FW cmd status to OS cmd status
1479 * @cmd : Pointer to cmd
1480 * @status : status of cmd returned by FW
1481 * @ext_status : ext status of cmd returned by FW
1482 */
1483
1484 void
1485 map_cmd_status(struct fusion_context *fusion,
1486 struct scsi_cmnd *scmd, u8 status, u8 ext_status,
1487 u32 data_length, u8 *sense)
1488 {
1489 u8 cmd_type;
1490 int resid;
1491
1492 cmd_type = megasas_cmd_type(scmd);
1493 switch (status) {
1494
1495 case MFI_STAT_OK:
1496 scmd->result = DID_OK << 16;
1497 break;
1498
1499 case MFI_STAT_SCSI_IO_FAILED:
1500 case MFI_STAT_LD_INIT_IN_PROGRESS:
1501 scmd->result = (DID_ERROR << 16) | ext_status;
1502 break;
1503
1504 case MFI_STAT_SCSI_DONE_WITH_ERROR:
1505
1506 scmd->result = (DID_OK << 16) | ext_status;
1507 if (ext_status == SAM_STAT_CHECK_CONDITION) {
1508 memset(scmd->sense_buffer, 0,
1509 SCSI_SENSE_BUFFERSIZE);
1510 memcpy(scmd->sense_buffer, sense,
1511 SCSI_SENSE_BUFFERSIZE);
1512 scmd->result |= DRIVER_SENSE << 24;
1513 }
1514
1515 /*
1516 * If the IO request is partially completed, then MR FW will
1517 * update "io_request->DataLength" field with actual number of
1518 * bytes transferred.Driver will set residual bytes count in
1519 * SCSI command structure.
1520 */
1521 resid = (scsi_bufflen(scmd) - data_length);
1522 scsi_set_resid(scmd, resid);
1523
1524 if (resid &&
1525 ((cmd_type == READ_WRITE_LDIO) ||
1526 (cmd_type == READ_WRITE_SYSPDIO)))
1527 scmd_printk(KERN_INFO, scmd, "BRCM Debug mfi stat 0x%x, data len"
1528 " requested/completed 0x%x/0x%x\n",
1529 status, scsi_bufflen(scmd), data_length);
1530 break;
1531
1532 case MFI_STAT_LD_OFFLINE:
1533 case MFI_STAT_DEVICE_NOT_FOUND:
1534 scmd->result = DID_BAD_TARGET << 16;
1535 break;
1536 case MFI_STAT_CONFIG_SEQ_MISMATCH:
1537 scmd->result = DID_IMM_RETRY << 16;
1538 break;
1539 default:
1540 scmd->result = DID_ERROR << 16;
1541 break;
1542 }
1543 }
1544
1545 /**
1546 * megasas_is_prp_possible -
1547 * Checks if native NVMe PRPs can be built for the IO
1548 *
1549 * @instance: Adapter soft state
1550 * @scmd: SCSI command from the mid-layer
1551 * @sge_count: scatter gather element count.
1552 *
1553 * Returns: true: PRPs can be built
1554 * false: IEEE SGLs needs to be built
1555 */
1556 static bool
1557 megasas_is_prp_possible(struct megasas_instance *instance,
1558 struct scsi_cmnd *scmd, int sge_count)
1559 {
1560 struct fusion_context *fusion;
1561 int i;
1562 u32 data_length = 0;
1563 struct scatterlist *sg_scmd;
1564 bool build_prp = false;
1565 u32 mr_nvme_pg_size;
1566
1567 mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
1568 MR_DEFAULT_NVME_PAGE_SIZE);
1569 fusion = instance->ctrl_context;
1570 data_length = scsi_bufflen(scmd);
1571 sg_scmd = scsi_sglist(scmd);
1572
1573 /*
1574 * NVMe uses one PRP for each page (or part of a page)
1575 * look at the data length - if 4 pages or less then IEEE is OK
1576 * if > 5 pages then we need to build a native SGL
1577 * if > 4 and <= 5 pages, then check physical address of 1st SG entry
1578 * if this first size in the page is >= the residual beyond 4 pages
1579 * then use IEEE, otherwise use native SGL
1580 */
1581
1582 if (data_length > (mr_nvme_pg_size * 5)) {
1583 build_prp = true;
1584 } else if ((data_length > (mr_nvme_pg_size * 4)) &&
1585 (data_length <= (mr_nvme_pg_size * 5))) {
1586 /* check if 1st SG entry size is < residual beyond 4 pages */
1587 if (sg_dma_len(sg_scmd) < (data_length - (mr_nvme_pg_size * 4)))
1588 build_prp = true;
1589 }
1590
1591 /*
1592 * Below code detects gaps/holes in IO data buffers.
1593 * What does holes/gaps mean?
1594 * Any SGE except first one in a SGL starts at non NVME page size
1595 * aligned address OR Any SGE except last one in a SGL ends at
1596 * non NVME page size boundary.
1597 *
1598 * Driver has already informed block layer by setting boundary rules for
1599 * bio merging done at NVME page size boundary calling kernel API
1600 * blk_queue_virt_boundary inside slave_config.
1601 * Still there is possibility of IO coming with holes to driver because of
1602 * IO merging done by IO scheduler.
1603 *
1604 * With SCSI BLK MQ enabled, there will be no IO with holes as there is no
1605 * IO scheduling so no IO merging.
1606 *
1607 * With SCSI BLK MQ disabled, IO scheduler may attempt to merge IOs and
1608 * then sending IOs with holes.
1609 *
1610 * Though driver can request block layer to disable IO merging by calling-
1611 * queue_flag_set_unlocked(QUEUE_FLAG_NOMERGES, sdev->request_queue) but
1612 * user may tune sysfs parameter- nomerges again to 0 or 1.
1613 *
1614 * If in future IO scheduling is enabled with SCSI BLK MQ,
1615 * this algorithm to detect holes will be required in driver
1616 * for SCSI BLK MQ enabled case as well.
1617 *
1618 *
1619 */
1620 scsi_for_each_sg(scmd, sg_scmd, sge_count, i) {
1621 if ((i != 0) && (i != (sge_count - 1))) {
1622 if (mega_mod64(sg_dma_len(sg_scmd), mr_nvme_pg_size) ||
1623 mega_mod64(sg_dma_address(sg_scmd),
1624 mr_nvme_pg_size)) {
1625 build_prp = false;
1626 atomic_inc(&instance->sge_holes_type1);
1627 break;
1628 }
1629 }
1630
1631 if ((sge_count > 1) && (i == 0)) {
1632 if ((mega_mod64((sg_dma_address(sg_scmd) +
1633 sg_dma_len(sg_scmd)),
1634 mr_nvme_pg_size))) {
1635 build_prp = false;
1636 atomic_inc(&instance->sge_holes_type2);
1637 break;
1638 }
1639 }
1640
1641 if ((sge_count > 1) && (i == (sge_count - 1))) {
1642 if (mega_mod64(sg_dma_address(sg_scmd),
1643 mr_nvme_pg_size)) {
1644 build_prp = false;
1645 atomic_inc(&instance->sge_holes_type3);
1646 break;
1647 }
1648 }
1649 }
1650
1651 return build_prp;
1652 }
1653
1654 /**
1655 * megasas_make_prp_nvme -
1656 * Prepare PRPs(Physical Region Page)- SGLs specific to NVMe drives only
1657 *
1658 * @instance: Adapter soft state
1659 * @scmd: SCSI command from the mid-layer
1660 * @sgl_ptr: SGL to be filled in
1661 * @cmd: Fusion command frame
1662 * @sge_count: scatter gather element count.
1663 *
1664 * Returns: true: PRPs are built
1665 * false: IEEE SGLs needs to be built
1666 */
1667 static bool
1668 megasas_make_prp_nvme(struct megasas_instance *instance, struct scsi_cmnd *scmd,
1669 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr,
1670 struct megasas_cmd_fusion *cmd, int sge_count)
1671 {
1672 int sge_len, offset, num_prp_in_chain = 0;
1673 struct MPI25_IEEE_SGE_CHAIN64 *main_chain_element, *ptr_first_sgl;
1674 u64 *ptr_sgl;
1675 dma_addr_t ptr_sgl_phys;
1676 u64 sge_addr;
1677 u32 page_mask, page_mask_result;
1678 struct scatterlist *sg_scmd;
1679 u32 first_prp_len;
1680 bool build_prp = false;
1681 int data_len = scsi_bufflen(scmd);
1682 struct fusion_context *fusion;
1683 u32 mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
1684 MR_DEFAULT_NVME_PAGE_SIZE);
1685
1686 fusion = instance->ctrl_context;
1687
1688 build_prp = megasas_is_prp_possible(instance, scmd, sge_count);
1689
1690 if (!build_prp)
1691 return false;
1692
1693 /*
1694 * Nvme has a very convoluted prp format. One prp is required
1695 * for each page or partial page. Driver need to split up OS sg_list
1696 * entries if it is longer than one page or cross a page
1697 * boundary. Driver also have to insert a PRP list pointer entry as
1698 * the last entry in each physical page of the PRP list.
1699 *
1700 * NOTE: The first PRP "entry" is actually placed in the first
1701 * SGL entry in the main message as IEEE 64 format. The 2nd
1702 * entry in the main message is the chain element, and the rest
1703 * of the PRP entries are built in the contiguous pcie buffer.
1704 */
1705 page_mask = mr_nvme_pg_size - 1;
1706 ptr_sgl = (u64 *)cmd->sg_frame;
1707 ptr_sgl_phys = cmd->sg_frame_phys_addr;
1708 memset(ptr_sgl, 0, instance->max_chain_frame_sz);
1709
1710 /* Build chain frame element which holds all prps except first*/
1711 main_chain_element = (struct MPI25_IEEE_SGE_CHAIN64 *)
1712 ((u8 *)sgl_ptr + sizeof(struct MPI25_IEEE_SGE_CHAIN64));
1713
1714 main_chain_element->Address = cpu_to_le64(ptr_sgl_phys);
1715 main_chain_element->NextChainOffset = 0;
1716 main_chain_element->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT |
1717 IEEE_SGE_FLAGS_SYSTEM_ADDR |
1718 MPI26_IEEE_SGE_FLAGS_NSF_NVME_PRP;
1719
1720 /* Build first prp, sge need not to be page aligned*/
1721 ptr_first_sgl = sgl_ptr;
1722 sg_scmd = scsi_sglist(scmd);
1723 sge_addr = sg_dma_address(sg_scmd);
1724 sge_len = sg_dma_len(sg_scmd);
1725
1726 offset = (u32)(sge_addr & page_mask);
1727 first_prp_len = mr_nvme_pg_size - offset;
1728
1729 ptr_first_sgl->Address = cpu_to_le64(sge_addr);
1730 ptr_first_sgl->Length = cpu_to_le32(first_prp_len);
1731
1732 data_len -= first_prp_len;
1733
1734 if (sge_len > first_prp_len) {
1735 sge_addr += first_prp_len;
1736 sge_len -= first_prp_len;
1737 } else if (sge_len == first_prp_len) {
1738 sg_scmd = sg_next(sg_scmd);
1739 sge_addr = sg_dma_address(sg_scmd);
1740 sge_len = sg_dma_len(sg_scmd);
1741 }
1742
1743 for (;;) {
1744 offset = (u32)(sge_addr & page_mask);
1745
1746 /* Put PRP pointer due to page boundary*/
1747 page_mask_result = (uintptr_t)(ptr_sgl + 1) & page_mask;
1748 if (unlikely(!page_mask_result)) {
1749 scmd_printk(KERN_NOTICE,
1750 scmd, "page boundary ptr_sgl: 0x%p\n",
1751 ptr_sgl);
1752 ptr_sgl_phys += 8;
1753 *ptr_sgl = cpu_to_le64(ptr_sgl_phys);
1754 ptr_sgl++;
1755 num_prp_in_chain++;
1756 }
1757
1758 *ptr_sgl = cpu_to_le64(sge_addr);
1759 ptr_sgl++;
1760 ptr_sgl_phys += 8;
1761 num_prp_in_chain++;
1762
1763 sge_addr += mr_nvme_pg_size;
1764 sge_len -= mr_nvme_pg_size;
1765 data_len -= mr_nvme_pg_size;
1766
1767 if (data_len <= 0)
1768 break;
1769
1770 if (sge_len > 0)
1771 continue;
1772
1773 sg_scmd = sg_next(sg_scmd);
1774 sge_addr = sg_dma_address(sg_scmd);
1775 sge_len = sg_dma_len(sg_scmd);
1776 }
1777
1778 main_chain_element->Length =
1779 cpu_to_le32(num_prp_in_chain * sizeof(u64));
1780
1781 atomic_inc(&instance->prp_sgl);
1782 return build_prp;
1783 }
1784
1785 /**
1786 * megasas_make_sgl_fusion - Prepares 32-bit SGL
1787 * @instance: Adapter soft state
1788 * @scp: SCSI command from the mid-layer
1789 * @sgl_ptr: SGL to be filled in
1790 * @cmd: cmd we are working on
1791 * @sge_count sge count
1792 *
1793 */
1794 static void
1795 megasas_make_sgl_fusion(struct megasas_instance *instance,
1796 struct scsi_cmnd *scp,
1797 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr,
1798 struct megasas_cmd_fusion *cmd, int sge_count)
1799 {
1800 int i, sg_processed;
1801 struct scatterlist *os_sgl;
1802 struct fusion_context *fusion;
1803
1804 fusion = instance->ctrl_context;
1805
1806 if (fusion->adapter_type >= INVADER_SERIES) {
1807 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr_end = sgl_ptr;
1808 sgl_ptr_end += fusion->max_sge_in_main_msg - 1;
1809 sgl_ptr_end->Flags = 0;
1810 }
1811
1812 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1813 sgl_ptr->Length = cpu_to_le32(sg_dma_len(os_sgl));
1814 sgl_ptr->Address = cpu_to_le64(sg_dma_address(os_sgl));
1815 sgl_ptr->Flags = 0;
1816 if (fusion->adapter_type >= INVADER_SERIES)
1817 if (i == sge_count - 1)
1818 sgl_ptr->Flags = IEEE_SGE_FLAGS_END_OF_LIST;
1819 sgl_ptr++;
1820 sg_processed = i + 1;
1821
1822 if ((sg_processed == (fusion->max_sge_in_main_msg - 1)) &&
1823 (sge_count > fusion->max_sge_in_main_msg)) {
1824
1825 struct MPI25_IEEE_SGE_CHAIN64 *sg_chain;
1826 if (fusion->adapter_type >= INVADER_SERIES) {
1827 if ((le16_to_cpu(cmd->io_request->IoFlags) &
1828 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH) !=
1829 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH)
1830 cmd->io_request->ChainOffset =
1831 fusion->
1832 chain_offset_io_request;
1833 else
1834 cmd->io_request->ChainOffset = 0;
1835 } else
1836 cmd->io_request->ChainOffset =
1837 fusion->chain_offset_io_request;
1838
1839 sg_chain = sgl_ptr;
1840 /* Prepare chain element */
1841 sg_chain->NextChainOffset = 0;
1842 if (fusion->adapter_type >= INVADER_SERIES)
1843 sg_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT;
1844 else
1845 sg_chain->Flags =
1846 (IEEE_SGE_FLAGS_CHAIN_ELEMENT |
1847 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR);
1848 sg_chain->Length = cpu_to_le32((sizeof(union MPI2_SGE_IO_UNION) * (sge_count - sg_processed)));
1849 sg_chain->Address = cpu_to_le64(cmd->sg_frame_phys_addr);
1850
1851 sgl_ptr =
1852 (struct MPI25_IEEE_SGE_CHAIN64 *)cmd->sg_frame;
1853 memset(sgl_ptr, 0, instance->max_chain_frame_sz);
1854 }
1855 }
1856 atomic_inc(&instance->ieee_sgl);
1857 }
1858
1859 /**
1860 * megasas_make_sgl - Build Scatter Gather List(SGLs)
1861 * @scp: SCSI command pointer
1862 * @instance: Soft instance of controller
1863 * @cmd: Fusion command pointer
1864 *
1865 * This function will build sgls based on device type.
1866 * For nvme drives, there is different way of building sgls in nvme native
1867 * format- PRPs(Physical Region Page).
1868 *
1869 * Returns the number of sg lists actually used, zero if the sg lists
1870 * is NULL, or -ENOMEM if the mapping failed
1871 */
1872 static
1873 int megasas_make_sgl(struct megasas_instance *instance, struct scsi_cmnd *scp,
1874 struct megasas_cmd_fusion *cmd)
1875 {
1876 int sge_count;
1877 bool build_prp = false;
1878 struct MPI25_IEEE_SGE_CHAIN64 *sgl_chain64;
1879
1880 sge_count = scsi_dma_map(scp);
1881
1882 if ((sge_count > instance->max_num_sge) || (sge_count <= 0))
1883 return sge_count;
1884
1885 sgl_chain64 = (struct MPI25_IEEE_SGE_CHAIN64 *)&cmd->io_request->SGL;
1886 if ((le16_to_cpu(cmd->io_request->IoFlags) &
1887 MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH) &&
1888 (cmd->pd_interface == NVME_PD))
1889 build_prp = megasas_make_prp_nvme(instance, scp, sgl_chain64,
1890 cmd, sge_count);
1891
1892 if (!build_prp)
1893 megasas_make_sgl_fusion(instance, scp, sgl_chain64,
1894 cmd, sge_count);
1895
1896 return sge_count;
1897 }
1898
1899 /**
1900 * megasas_set_pd_lba - Sets PD LBA
1901 * @cdb: CDB
1902 * @cdb_len: cdb length
1903 * @start_blk: Start block of IO
1904 *
1905 * Used to set the PD LBA in CDB for FP IOs
1906 */
1907 void
1908 megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len,
1909 struct IO_REQUEST_INFO *io_info, struct scsi_cmnd *scp,
1910 struct MR_DRV_RAID_MAP_ALL *local_map_ptr, u32 ref_tag)
1911 {
1912 struct MR_LD_RAID *raid;
1913 u16 ld;
1914 u64 start_blk = io_info->pdBlock;
1915 u8 *cdb = io_request->CDB.CDB32;
1916 u32 num_blocks = io_info->numBlocks;
1917 u8 opcode = 0, flagvals = 0, groupnum = 0, control = 0;
1918
1919 /* Check if T10 PI (DIF) is enabled for this LD */
1920 ld = MR_TargetIdToLdGet(io_info->ldTgtId, local_map_ptr);
1921 raid = MR_LdRaidGet(ld, local_map_ptr);
1922 if (raid->capability.ldPiMode == MR_PROT_INFO_TYPE_CONTROLLER) {
1923 memset(cdb, 0, sizeof(io_request->CDB.CDB32));
1924 cdb[0] = MEGASAS_SCSI_VARIABLE_LENGTH_CMD;
1925 cdb[7] = MEGASAS_SCSI_ADDL_CDB_LEN;
1926
1927 if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1928 cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_READ32;
1929 else
1930 cdb[9] = MEGASAS_SCSI_SERVICE_ACTION_WRITE32;
1931 cdb[10] = MEGASAS_RD_WR_PROTECT_CHECK_ALL;
1932
1933 /* LBA */
1934 cdb[12] = (u8)((start_blk >> 56) & 0xff);
1935 cdb[13] = (u8)((start_blk >> 48) & 0xff);
1936 cdb[14] = (u8)((start_blk >> 40) & 0xff);
1937 cdb[15] = (u8)((start_blk >> 32) & 0xff);
1938 cdb[16] = (u8)((start_blk >> 24) & 0xff);
1939 cdb[17] = (u8)((start_blk >> 16) & 0xff);
1940 cdb[18] = (u8)((start_blk >> 8) & 0xff);
1941 cdb[19] = (u8)(start_blk & 0xff);
1942
1943 /* Logical block reference tag */
1944 io_request->CDB.EEDP32.PrimaryReferenceTag =
1945 cpu_to_be32(ref_tag);
1946 io_request->CDB.EEDP32.PrimaryApplicationTagMask = cpu_to_be16(0xffff);
1947 io_request->IoFlags = cpu_to_le16(32); /* Specify 32-byte cdb */
1948
1949 /* Transfer length */
1950 cdb[28] = (u8)((num_blocks >> 24) & 0xff);
1951 cdb[29] = (u8)((num_blocks >> 16) & 0xff);
1952 cdb[30] = (u8)((num_blocks >> 8) & 0xff);
1953 cdb[31] = (u8)(num_blocks & 0xff);
1954
1955 /* set SCSI IO EEDPFlags */
1956 if (scp->sc_data_direction == PCI_DMA_FROMDEVICE) {
1957 io_request->EEDPFlags = cpu_to_le16(
1958 MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
1959 MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
1960 MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP |
1961 MPI2_SCSIIO_EEDPFLAGS_CHECK_APPTAG |
1962 MPI25_SCSIIO_EEDPFLAGS_DO_NOT_DISABLE_MODE |
1963 MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD);
1964 } else {
1965 io_request->EEDPFlags = cpu_to_le16(
1966 MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
1967 MPI2_SCSIIO_EEDPFLAGS_INSERT_OP);
1968 }
1969 io_request->Control |= cpu_to_le32((0x4 << 26));
1970 io_request->EEDPBlockSize = cpu_to_le32(scp->device->sector_size);
1971 } else {
1972 /* Some drives don't support 16/12 byte CDB's, convert to 10 */
1973 if (((cdb_len == 12) || (cdb_len == 16)) &&
1974 (start_blk <= 0xffffffff)) {
1975 if (cdb_len == 16) {
1976 opcode = cdb[0] == READ_16 ? READ_10 : WRITE_10;
1977 flagvals = cdb[1];
1978 groupnum = cdb[14];
1979 control = cdb[15];
1980 } else {
1981 opcode = cdb[0] == READ_12 ? READ_10 : WRITE_10;
1982 flagvals = cdb[1];
1983 groupnum = cdb[10];
1984 control = cdb[11];
1985 }
1986
1987 memset(cdb, 0, sizeof(io_request->CDB.CDB32));
1988
1989 cdb[0] = opcode;
1990 cdb[1] = flagvals;
1991 cdb[6] = groupnum;
1992 cdb[9] = control;
1993
1994 /* Transfer length */
1995 cdb[8] = (u8)(num_blocks & 0xff);
1996 cdb[7] = (u8)((num_blocks >> 8) & 0xff);
1997
1998 io_request->IoFlags = cpu_to_le16(10); /* Specify 10-byte cdb */
1999 cdb_len = 10;
2000 } else if ((cdb_len < 16) && (start_blk > 0xffffffff)) {
2001 /* Convert to 16 byte CDB for large LBA's */
2002 switch (cdb_len) {
2003 case 6:
2004 opcode = cdb[0] == READ_6 ? READ_16 : WRITE_16;
2005 control = cdb[5];
2006 break;
2007 case 10:
2008 opcode =
2009 cdb[0] == READ_10 ? READ_16 : WRITE_16;
2010 flagvals = cdb[1];
2011 groupnum = cdb[6];
2012 control = cdb[9];
2013 break;
2014 case 12:
2015 opcode =
2016 cdb[0] == READ_12 ? READ_16 : WRITE_16;
2017 flagvals = cdb[1];
2018 groupnum = cdb[10];
2019 control = cdb[11];
2020 break;
2021 }
2022
2023 memset(cdb, 0, sizeof(io_request->CDB.CDB32));
2024
2025 cdb[0] = opcode;
2026 cdb[1] = flagvals;
2027 cdb[14] = groupnum;
2028 cdb[15] = control;
2029
2030 /* Transfer length */
2031 cdb[13] = (u8)(num_blocks & 0xff);
2032 cdb[12] = (u8)((num_blocks >> 8) & 0xff);
2033 cdb[11] = (u8)((num_blocks >> 16) & 0xff);
2034 cdb[10] = (u8)((num_blocks >> 24) & 0xff);
2035
2036 io_request->IoFlags = cpu_to_le16(16); /* Specify 16-byte cdb */
2037 cdb_len = 16;
2038 }
2039
2040 /* Normal case, just load LBA here */
2041 switch (cdb_len) {
2042 case 6:
2043 {
2044 u8 val = cdb[1] & 0xE0;
2045 cdb[3] = (u8)(start_blk & 0xff);
2046 cdb[2] = (u8)((start_blk >> 8) & 0xff);
2047 cdb[1] = val | ((u8)(start_blk >> 16) & 0x1f);
2048 break;
2049 }
2050 case 10:
2051 cdb[5] = (u8)(start_blk & 0xff);
2052 cdb[4] = (u8)((start_blk >> 8) & 0xff);
2053 cdb[3] = (u8)((start_blk >> 16) & 0xff);
2054 cdb[2] = (u8)((start_blk >> 24) & 0xff);
2055 break;
2056 case 12:
2057 cdb[5] = (u8)(start_blk & 0xff);
2058 cdb[4] = (u8)((start_blk >> 8) & 0xff);
2059 cdb[3] = (u8)((start_blk >> 16) & 0xff);
2060 cdb[2] = (u8)((start_blk >> 24) & 0xff);
2061 break;
2062 case 16:
2063 cdb[9] = (u8)(start_blk & 0xff);
2064 cdb[8] = (u8)((start_blk >> 8) & 0xff);
2065 cdb[7] = (u8)((start_blk >> 16) & 0xff);
2066 cdb[6] = (u8)((start_blk >> 24) & 0xff);
2067 cdb[5] = (u8)((start_blk >> 32) & 0xff);
2068 cdb[4] = (u8)((start_blk >> 40) & 0xff);
2069 cdb[3] = (u8)((start_blk >> 48) & 0xff);
2070 cdb[2] = (u8)((start_blk >> 56) & 0xff);
2071 break;
2072 }
2073 }
2074 }
2075
2076 /**
2077 * megasas_stream_detect - stream detection on read and and write IOs
2078 * @instance: Adapter soft state
2079 * @cmd: Command to be prepared
2080 * @io_info: IO Request info
2081 *
2082 */
2083
2084 /** stream detection on read and and write IOs */
2085 static void megasas_stream_detect(struct megasas_instance *instance,
2086 struct megasas_cmd_fusion *cmd,
2087 struct IO_REQUEST_INFO *io_info)
2088 {
2089 struct fusion_context *fusion = instance->ctrl_context;
2090 u32 device_id = io_info->ldTgtId;
2091 struct LD_STREAM_DETECT *current_ld_sd
2092 = fusion->stream_detect_by_ld[device_id];
2093 u32 *track_stream = &current_ld_sd->mru_bit_map, stream_num;
2094 u32 shifted_values, unshifted_values;
2095 u32 index_value_mask, shifted_values_mask;
2096 int i;
2097 bool is_read_ahead = false;
2098 struct STREAM_DETECT *current_sd;
2099 /* find possible stream */
2100 for (i = 0; i < MAX_STREAMS_TRACKED; ++i) {
2101 stream_num = (*track_stream >>
2102 (i * BITS_PER_INDEX_STREAM)) &
2103 STREAM_MASK;
2104 current_sd = &current_ld_sd->stream_track[stream_num];
2105 /* if we found a stream, update the raid
2106 * context and also update the mruBitMap
2107 */
2108 /* boundary condition */
2109 if ((current_sd->next_seq_lba) &&
2110 (io_info->ldStartBlock >= current_sd->next_seq_lba) &&
2111 (io_info->ldStartBlock <= (current_sd->next_seq_lba + 32)) &&
2112 (current_sd->is_read == io_info->isRead)) {
2113
2114 if ((io_info->ldStartBlock != current_sd->next_seq_lba) &&
2115 ((!io_info->isRead) || (!is_read_ahead)))
2116 /*
2117 * Once the API availible we need to change this.
2118 * At this point we are not allowing any gap
2119 */
2120 continue;
2121
2122 SET_STREAM_DETECTED(cmd->io_request->RaidContext.raid_context_g35);
2123 current_sd->next_seq_lba =
2124 io_info->ldStartBlock + io_info->numBlocks;
2125 /*
2126 * update the mruBitMap LRU
2127 */
2128 shifted_values_mask =
2129 (1 << i * BITS_PER_INDEX_STREAM) - 1;
2130 shifted_values = ((*track_stream & shifted_values_mask)
2131 << BITS_PER_INDEX_STREAM);
2132 index_value_mask =
2133 STREAM_MASK << i * BITS_PER_INDEX_STREAM;
2134 unshifted_values =
2135 *track_stream & ~(shifted_values_mask |
2136 index_value_mask);
2137 *track_stream =
2138 unshifted_values | shifted_values | stream_num;
2139 return;
2140 }
2141 }
2142 /*
2143 * if we did not find any stream, create a new one
2144 * from the least recently used
2145 */
2146 stream_num = (*track_stream >>
2147 ((MAX_STREAMS_TRACKED - 1) * BITS_PER_INDEX_STREAM)) &
2148 STREAM_MASK;
2149 current_sd = &current_ld_sd->stream_track[stream_num];
2150 current_sd->is_read = io_info->isRead;
2151 current_sd->next_seq_lba = io_info->ldStartBlock + io_info->numBlocks;
2152 *track_stream = (((*track_stream & ZERO_LAST_STREAM) << 4) | stream_num);
2153 return;
2154 }
2155
2156 /**
2157 * megasas_set_raidflag_cpu_affinity - This function sets the cpu
2158 * affinity (cpu of the controller) and raid_flags in the raid context
2159 * based on IO type.
2160 *
2161 * @praid_context: IO RAID context
2162 * @raid: LD raid map
2163 * @fp_possible: Is fast path possible?
2164 * @is_read: Is read IO?
2165 *
2166 */
2167 static void
2168 megasas_set_raidflag_cpu_affinity(union RAID_CONTEXT_UNION *praid_context,
2169 struct MR_LD_RAID *raid, bool fp_possible,
2170 u8 is_read, u32 scsi_buff_len)
2171 {
2172 u8 cpu_sel = MR_RAID_CTX_CPUSEL_0;
2173 struct RAID_CONTEXT_G35 *rctx_g35;
2174
2175 rctx_g35 = &praid_context->raid_context_g35;
2176 if (fp_possible) {
2177 if (is_read) {
2178 if ((raid->cpuAffinity.pdRead.cpu0) &&
2179 (raid->cpuAffinity.pdRead.cpu1))
2180 cpu_sel = MR_RAID_CTX_CPUSEL_FCFS;
2181 else if (raid->cpuAffinity.pdRead.cpu1)
2182 cpu_sel = MR_RAID_CTX_CPUSEL_1;
2183 } else {
2184 if ((raid->cpuAffinity.pdWrite.cpu0) &&
2185 (raid->cpuAffinity.pdWrite.cpu1))
2186 cpu_sel = MR_RAID_CTX_CPUSEL_FCFS;
2187 else if (raid->cpuAffinity.pdWrite.cpu1)
2188 cpu_sel = MR_RAID_CTX_CPUSEL_1;
2189 /* Fast path cache by pass capable R0/R1 VD */
2190 if ((raid->level <= 1) &&
2191 (raid->capability.fp_cache_bypass_capable)) {
2192 rctx_g35->routing_flags |=
2193 (1 << MR_RAID_CTX_ROUTINGFLAGS_SLD_SHIFT);
2194 rctx_g35->raid_flags =
2195 (MR_RAID_FLAGS_IO_SUB_TYPE_CACHE_BYPASS
2196 << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT);
2197 }
2198 }
2199 } else {
2200 if (is_read) {
2201 if ((raid->cpuAffinity.ldRead.cpu0) &&
2202 (raid->cpuAffinity.ldRead.cpu1))
2203 cpu_sel = MR_RAID_CTX_CPUSEL_FCFS;
2204 else if (raid->cpuAffinity.ldRead.cpu1)
2205 cpu_sel = MR_RAID_CTX_CPUSEL_1;
2206 } else {
2207 if ((raid->cpuAffinity.ldWrite.cpu0) &&
2208 (raid->cpuAffinity.ldWrite.cpu1))
2209 cpu_sel = MR_RAID_CTX_CPUSEL_FCFS;
2210 else if (raid->cpuAffinity.ldWrite.cpu1)
2211 cpu_sel = MR_RAID_CTX_CPUSEL_1;
2212
2213 if (is_stream_detected(rctx_g35) &&
2214 ((raid->level == 5) || (raid->level == 6)) &&
2215 (raid->writeMode == MR_RL_WRITE_THROUGH_MODE) &&
2216 (cpu_sel == MR_RAID_CTX_CPUSEL_FCFS))
2217 cpu_sel = MR_RAID_CTX_CPUSEL_0;
2218 }
2219 }
2220
2221 rctx_g35->routing_flags |=
2222 (cpu_sel << MR_RAID_CTX_ROUTINGFLAGS_CPUSEL_SHIFT);
2223
2224 /* Always give priority to MR_RAID_FLAGS_IO_SUB_TYPE_LDIO_BW_LIMIT
2225 * vs MR_RAID_FLAGS_IO_SUB_TYPE_CACHE_BYPASS.
2226 * IO Subtype is not bitmap.
2227 */
2228 if ((raid->level == 1) && (!is_read)) {
2229 if (scsi_buff_len > MR_LARGE_IO_MIN_SIZE)
2230 praid_context->raid_context_g35.raid_flags =
2231 (MR_RAID_FLAGS_IO_SUB_TYPE_LDIO_BW_LIMIT
2232 << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT);
2233 }
2234 }
2235
2236 /**
2237 * megasas_build_ldio_fusion - Prepares IOs to devices
2238 * @instance: Adapter soft state
2239 * @scp: SCSI command
2240 * @cmd: Command to be prepared
2241 *
2242 * Prepares the io_request and chain elements (sg_frame) for IO
2243 * The IO can be for PD (Fast Path) or LD
2244 */
2245 void
2246 megasas_build_ldio_fusion(struct megasas_instance *instance,
2247 struct scsi_cmnd *scp,
2248 struct megasas_cmd_fusion *cmd)
2249 {
2250 bool fp_possible;
2251 u16 ld;
2252 u32 start_lba_lo, start_lba_hi, device_id, datalength = 0;
2253 u32 scsi_buff_len;
2254 struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
2255 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2256 struct IO_REQUEST_INFO io_info;
2257 struct fusion_context *fusion;
2258 struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
2259 u8 *raidLUN;
2260 unsigned long spinlock_flags;
2261 union RAID_CONTEXT_UNION *praid_context;
2262 struct MR_LD_RAID *raid = NULL;
2263 struct MR_PRIV_DEVICE *mrdev_priv;
2264
2265 device_id = MEGASAS_DEV_INDEX(scp);
2266
2267 fusion = instance->ctrl_context;
2268
2269 io_request = cmd->io_request;
2270 io_request->RaidContext.raid_context.virtual_disk_tgt_id =
2271 cpu_to_le16(device_id);
2272 io_request->RaidContext.raid_context.status = 0;
2273 io_request->RaidContext.raid_context.ex_status = 0;
2274
2275 req_desc = (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)cmd->request_desc;
2276
2277 start_lba_lo = 0;
2278 start_lba_hi = 0;
2279 fp_possible = false;
2280
2281 /*
2282 * 6-byte READ(0x08) or WRITE(0x0A) cdb
2283 */
2284 if (scp->cmd_len == 6) {
2285 datalength = (u32) scp->cmnd[4];
2286 start_lba_lo = ((u32) scp->cmnd[1] << 16) |
2287 ((u32) scp->cmnd[2] << 8) | (u32) scp->cmnd[3];
2288
2289 start_lba_lo &= 0x1FFFFF;
2290 }
2291
2292 /*
2293 * 10-byte READ(0x28) or WRITE(0x2A) cdb
2294 */
2295 else if (scp->cmd_len == 10) {
2296 datalength = (u32) scp->cmnd[8] |
2297 ((u32) scp->cmnd[7] << 8);
2298 start_lba_lo = ((u32) scp->cmnd[2] << 24) |
2299 ((u32) scp->cmnd[3] << 16) |
2300 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
2301 }
2302
2303 /*
2304 * 12-byte READ(0xA8) or WRITE(0xAA) cdb
2305 */
2306 else if (scp->cmd_len == 12) {
2307 datalength = ((u32) scp->cmnd[6] << 24) |
2308 ((u32) scp->cmnd[7] << 16) |
2309 ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
2310 start_lba_lo = ((u32) scp->cmnd[2] << 24) |
2311 ((u32) scp->cmnd[3] << 16) |
2312 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
2313 }
2314
2315 /*
2316 * 16-byte READ(0x88) or WRITE(0x8A) cdb
2317 */
2318 else if (scp->cmd_len == 16) {
2319 datalength = ((u32) scp->cmnd[10] << 24) |
2320 ((u32) scp->cmnd[11] << 16) |
2321 ((u32) scp->cmnd[12] << 8) | (u32) scp->cmnd[13];
2322 start_lba_lo = ((u32) scp->cmnd[6] << 24) |
2323 ((u32) scp->cmnd[7] << 16) |
2324 ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
2325
2326 start_lba_hi = ((u32) scp->cmnd[2] << 24) |
2327 ((u32) scp->cmnd[3] << 16) |
2328 ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
2329 }
2330
2331 memset(&io_info, 0, sizeof(struct IO_REQUEST_INFO));
2332 io_info.ldStartBlock = ((u64)start_lba_hi << 32) | start_lba_lo;
2333 io_info.numBlocks = datalength;
2334 io_info.ldTgtId = device_id;
2335 io_info.r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
2336 scsi_buff_len = scsi_bufflen(scp);
2337 io_request->DataLength = cpu_to_le32(scsi_buff_len);
2338
2339 if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
2340 io_info.isRead = 1;
2341
2342 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
2343 ld = MR_TargetIdToLdGet(device_id, local_map_ptr);
2344
2345 if (ld < instance->fw_supported_vd_count)
2346 raid = MR_LdRaidGet(ld, local_map_ptr);
2347
2348 if (!raid || (!fusion->fast_path_io)) {
2349 io_request->RaidContext.raid_context.reg_lock_flags = 0;
2350 fp_possible = false;
2351 } else {
2352 if (MR_BuildRaidContext(instance, &io_info,
2353 &io_request->RaidContext.raid_context,
2354 local_map_ptr, &raidLUN))
2355 fp_possible = (io_info.fpOkForIo > 0) ? true : false;
2356 }
2357
2358 /* Use raw_smp_processor_id() for now until cmd->request->cpu is CPU
2359 id by default, not CPU group id, otherwise all MSI-X queues won't
2360 be utilized */
2361 cmd->request_desc->SCSIIO.MSIxIndex = instance->msix_vectors ?
2362 raw_smp_processor_id() % instance->msix_vectors : 0;
2363
2364 praid_context = &io_request->RaidContext;
2365
2366 if (instance->is_ventura) {
2367 spin_lock_irqsave(&instance->stream_lock, spinlock_flags);
2368 megasas_stream_detect(instance, cmd, &io_info);
2369 spin_unlock_irqrestore(&instance->stream_lock, spinlock_flags);
2370 /* In ventura if stream detected for a read and it is read ahead
2371 * capable make this IO as LDIO
2372 */
2373 if (is_stream_detected(&io_request->RaidContext.raid_context_g35) &&
2374 io_info.isRead && io_info.ra_capable)
2375 fp_possible = false;
2376
2377 /* FP for Optimal raid level 1.
2378 * All large RAID-1 writes (> 32 KiB, both WT and WB modes)
2379 * are built by the driver as LD I/Os.
2380 * All small RAID-1 WT writes (<= 32 KiB) are built as FP I/Os
2381 * (there is never a reason to process these as buffered writes)
2382 * All small RAID-1 WB writes (<= 32 KiB) are built as FP I/Os
2383 * with the SLD bit asserted.
2384 */
2385 if (io_info.r1_alt_dev_handle != MR_DEVHANDLE_INVALID) {
2386 mrdev_priv = scp->device->hostdata;
2387
2388 if (atomic_inc_return(&instance->fw_outstanding) >
2389 (instance->host->can_queue)) {
2390 fp_possible = false;
2391 atomic_dec(&instance->fw_outstanding);
2392 } else if ((scsi_buff_len > MR_LARGE_IO_MIN_SIZE) ||
2393 (atomic_dec_if_positive(&mrdev_priv->r1_ldio_hint) > 0)) {
2394 fp_possible = false;
2395 atomic_dec(&instance->fw_outstanding);
2396 if (scsi_buff_len > MR_LARGE_IO_MIN_SIZE)
2397 atomic_set(&mrdev_priv->r1_ldio_hint,
2398 instance->r1_ldio_hint_default);
2399 }
2400 }
2401
2402 /* If raid is NULL, set CPU affinity to default CPU0 */
2403 if (raid)
2404 megasas_set_raidflag_cpu_affinity(praid_context,
2405 raid, fp_possible, io_info.isRead,
2406 scsi_buff_len);
2407 else
2408 praid_context->raid_context_g35.routing_flags |=
2409 (MR_RAID_CTX_CPUSEL_0 << MR_RAID_CTX_ROUTINGFLAGS_CPUSEL_SHIFT);
2410 }
2411
2412 if (fp_possible) {
2413 megasas_set_pd_lba(io_request, scp->cmd_len, &io_info, scp,
2414 local_map_ptr, start_lba_lo);
2415 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
2416 cmd->request_desc->SCSIIO.RequestFlags =
2417 (MPI2_REQ_DESCRIPT_FLAGS_FP_IO
2418 << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2419 if (fusion->adapter_type == INVADER_SERIES) {
2420 if (io_request->RaidContext.raid_context.reg_lock_flags ==
2421 REGION_TYPE_UNUSED)
2422 cmd->request_desc->SCSIIO.RequestFlags =
2423 (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
2424 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2425 io_request->RaidContext.raid_context.type
2426 = MPI2_TYPE_CUDA;
2427 io_request->RaidContext.raid_context.nseg = 0x1;
2428 io_request->IoFlags |= cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
2429 io_request->RaidContext.raid_context.reg_lock_flags |=
2430 (MR_RL_FLAGS_GRANT_DESTINATION_CUDA |
2431 MR_RL_FLAGS_SEQ_NUM_ENABLE);
2432 } else if (instance->is_ventura) {
2433 io_request->RaidContext.raid_context_g35.nseg_type |=
2434 (1 << RAID_CONTEXT_NSEG_SHIFT);
2435 io_request->RaidContext.raid_context_g35.nseg_type |=
2436 (MPI2_TYPE_CUDA << RAID_CONTEXT_TYPE_SHIFT);
2437 io_request->RaidContext.raid_context_g35.routing_flags |=
2438 (1 << MR_RAID_CTX_ROUTINGFLAGS_SQN_SHIFT);
2439 io_request->IoFlags |=
2440 cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
2441 }
2442 if (fusion->load_balance_info &&
2443 (fusion->load_balance_info[device_id].loadBalanceFlag) &&
2444 (io_info.isRead)) {
2445 io_info.devHandle =
2446 get_updated_dev_handle(instance,
2447 &fusion->load_balance_info[device_id],
2448 &io_info, local_map_ptr);
2449 scp->SCp.Status |= MEGASAS_LOAD_BALANCE_FLAG;
2450 cmd->pd_r1_lb = io_info.pd_after_lb;
2451 if (instance->is_ventura)
2452 io_request->RaidContext.raid_context_g35.span_arm
2453 = io_info.span_arm;
2454 else
2455 io_request->RaidContext.raid_context.span_arm
2456 = io_info.span_arm;
2457
2458 } else
2459 scp->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG;
2460
2461 if (instance->is_ventura)
2462 cmd->r1_alt_dev_handle = io_info.r1_alt_dev_handle;
2463 else
2464 cmd->r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
2465
2466 if ((raidLUN[0] == 1) &&
2467 (local_map_ptr->raidMap.devHndlInfo[io_info.pd_after_lb].validHandles > 1)) {
2468 instance->dev_handle = !(instance->dev_handle);
2469 io_info.devHandle =
2470 local_map_ptr->raidMap.devHndlInfo[io_info.pd_after_lb].devHandle[instance->dev_handle];
2471 }
2472
2473 cmd->request_desc->SCSIIO.DevHandle = io_info.devHandle;
2474 io_request->DevHandle = io_info.devHandle;
2475 cmd->pd_interface = io_info.pd_interface;
2476 /* populate the LUN field */
2477 memcpy(io_request->LUN, raidLUN, 8);
2478 } else {
2479 io_request->RaidContext.raid_context.timeout_value =
2480 cpu_to_le16(local_map_ptr->raidMap.fpPdIoTimeoutSec);
2481 cmd->request_desc->SCSIIO.RequestFlags =
2482 (MEGASAS_REQ_DESCRIPT_FLAGS_LD_IO
2483 << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2484 if (fusion->adapter_type == INVADER_SERIES) {
2485 if (io_info.do_fp_rlbypass ||
2486 (io_request->RaidContext.raid_context.reg_lock_flags
2487 == REGION_TYPE_UNUSED))
2488 cmd->request_desc->SCSIIO.RequestFlags =
2489 (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
2490 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2491 io_request->RaidContext.raid_context.type
2492 = MPI2_TYPE_CUDA;
2493 io_request->RaidContext.raid_context.reg_lock_flags |=
2494 (MR_RL_FLAGS_GRANT_DESTINATION_CPU0 |
2495 MR_RL_FLAGS_SEQ_NUM_ENABLE);
2496 io_request->RaidContext.raid_context.nseg = 0x1;
2497 } else if (instance->is_ventura) {
2498 io_request->RaidContext.raid_context_g35.routing_flags |=
2499 (1 << MR_RAID_CTX_ROUTINGFLAGS_SQN_SHIFT);
2500 io_request->RaidContext.raid_context_g35.nseg_type |=
2501 (1 << RAID_CONTEXT_NSEG_SHIFT);
2502 io_request->RaidContext.raid_context_g35.nseg_type |=
2503 (MPI2_TYPE_CUDA << RAID_CONTEXT_TYPE_SHIFT);
2504 }
2505 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
2506 io_request->DevHandle = cpu_to_le16(device_id);
2507
2508 } /* Not FP */
2509 }
2510
2511 /**
2512 * megasas_build_ld_nonrw_fusion - prepares non rw ios for virtual disk
2513 * @instance: Adapter soft state
2514 * @scp: SCSI command
2515 * @cmd: Command to be prepared
2516 *
2517 * Prepares the io_request frame for non-rw io cmds for vd.
2518 */
2519 static void megasas_build_ld_nonrw_fusion(struct megasas_instance *instance,
2520 struct scsi_cmnd *scmd, struct megasas_cmd_fusion *cmd)
2521 {
2522 u32 device_id;
2523 struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
2524 u16 ld;
2525 struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
2526 struct fusion_context *fusion = instance->ctrl_context;
2527 u8 span, physArm;
2528 __le16 devHandle;
2529 u32 arRef, pd;
2530 struct MR_LD_RAID *raid;
2531 struct RAID_CONTEXT *pRAID_Context;
2532 u8 fp_possible = 1;
2533
2534 io_request = cmd->io_request;
2535 device_id = MEGASAS_DEV_INDEX(scmd);
2536 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
2537 io_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
2538 /* get RAID_Context pointer */
2539 pRAID_Context = &io_request->RaidContext.raid_context;
2540 /* Check with FW team */
2541 pRAID_Context->virtual_disk_tgt_id = cpu_to_le16(device_id);
2542 pRAID_Context->reg_lock_row_lba = 0;
2543 pRAID_Context->reg_lock_length = 0;
2544
2545 if (fusion->fast_path_io && (
2546 device_id < instance->fw_supported_vd_count)) {
2547
2548 ld = MR_TargetIdToLdGet(device_id, local_map_ptr);
2549 if (ld >= instance->fw_supported_vd_count)
2550 fp_possible = 0;
2551 else {
2552 raid = MR_LdRaidGet(ld, local_map_ptr);
2553 if (!(raid->capability.fpNonRWCapable))
2554 fp_possible = 0;
2555 }
2556 } else
2557 fp_possible = 0;
2558
2559 if (!fp_possible) {
2560 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
2561 io_request->DevHandle = cpu_to_le16(device_id);
2562 io_request->LUN[1] = scmd->device->lun;
2563 pRAID_Context->timeout_value =
2564 cpu_to_le16 (scmd->request->timeout / HZ);
2565 cmd->request_desc->SCSIIO.RequestFlags =
2566 (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
2567 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2568 } else {
2569
2570 /* set RAID context values */
2571 pRAID_Context->config_seq_num = raid->seqNum;
2572 if (!instance->is_ventura)
2573 pRAID_Context->reg_lock_flags = REGION_TYPE_SHARED_READ;
2574 pRAID_Context->timeout_value =
2575 cpu_to_le16(raid->fpIoTimeoutForLd);
2576
2577 /* get the DevHandle for the PD (since this is
2578 fpNonRWCapable, this is a single disk RAID0) */
2579 span = physArm = 0;
2580 arRef = MR_LdSpanArrayGet(ld, span, local_map_ptr);
2581 pd = MR_ArPdGet(arRef, physArm, local_map_ptr);
2582 devHandle = MR_PdDevHandleGet(pd, local_map_ptr);
2583
2584 /* build request descriptor */
2585 cmd->request_desc->SCSIIO.RequestFlags =
2586 (MPI2_REQ_DESCRIPT_FLAGS_FP_IO <<
2587 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2588 cmd->request_desc->SCSIIO.DevHandle = devHandle;
2589
2590 /* populate the LUN field */
2591 memcpy(io_request->LUN, raid->LUN, 8);
2592
2593 /* build the raidScsiIO structure */
2594 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
2595 io_request->DevHandle = devHandle;
2596 }
2597 }
2598
2599 /**
2600 * megasas_build_syspd_fusion - prepares rw/non-rw ios for syspd
2601 * @instance: Adapter soft state
2602 * @scp: SCSI command
2603 * @cmd: Command to be prepared
2604 * @fp_possible: parameter to detect fast path or firmware path io.
2605 *
2606 * Prepares the io_request frame for rw/non-rw io cmds for syspds
2607 */
2608 static void
2609 megasas_build_syspd_fusion(struct megasas_instance *instance,
2610 struct scsi_cmnd *scmd, struct megasas_cmd_fusion *cmd,
2611 bool fp_possible)
2612 {
2613 u32 device_id;
2614 struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
2615 u16 pd_index = 0;
2616 u16 os_timeout_value;
2617 u16 timeout_limit;
2618 struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
2619 struct RAID_CONTEXT *pRAID_Context;
2620 struct MR_PD_CFG_SEQ_NUM_SYNC *pd_sync;
2621 struct MR_PRIV_DEVICE *mr_device_priv_data;
2622 struct fusion_context *fusion = instance->ctrl_context;
2623 pd_sync = (void *)fusion->pd_seq_sync[(instance->pd_seq_map_id - 1) & 1];
2624
2625 device_id = MEGASAS_DEV_INDEX(scmd);
2626 pd_index = MEGASAS_PD_INDEX(scmd);
2627 os_timeout_value = scmd->request->timeout / HZ;
2628 mr_device_priv_data = scmd->device->hostdata;
2629 cmd->pd_interface = mr_device_priv_data->interface_type;
2630
2631 io_request = cmd->io_request;
2632 /* get RAID_Context pointer */
2633 pRAID_Context = &io_request->RaidContext.raid_context;
2634 pRAID_Context->reg_lock_flags = 0;
2635 pRAID_Context->reg_lock_row_lba = 0;
2636 pRAID_Context->reg_lock_length = 0;
2637 io_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
2638 io_request->LUN[1] = scmd->device->lun;
2639 pRAID_Context->raid_flags = MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD
2640 << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;
2641
2642 /* If FW supports PD sequence number */
2643 if (instance->use_seqnum_jbod_fp &&
2644 instance->pd_list[pd_index].driveType == TYPE_DISK) {
2645 /* TgtId must be incremented by 255 as jbod seq number is index
2646 * below raid map
2647 */
2648 /* More than 256 PD/JBOD support for Ventura */
2649 if (instance->support_morethan256jbod)
2650 pRAID_Context->virtual_disk_tgt_id =
2651 pd_sync->seq[pd_index].pd_target_id;
2652 else
2653 pRAID_Context->virtual_disk_tgt_id =
2654 cpu_to_le16(device_id + (MAX_PHYSICAL_DEVICES - 1));
2655 pRAID_Context->config_seq_num = pd_sync->seq[pd_index].seqNum;
2656 io_request->DevHandle = pd_sync->seq[pd_index].devHandle;
2657 if (instance->is_ventura) {
2658 io_request->RaidContext.raid_context_g35.routing_flags |=
2659 (1 << MR_RAID_CTX_ROUTINGFLAGS_SQN_SHIFT);
2660 io_request->RaidContext.raid_context_g35.nseg_type |=
2661 (1 << RAID_CONTEXT_NSEG_SHIFT);
2662 io_request->RaidContext.raid_context_g35.nseg_type |=
2663 (MPI2_TYPE_CUDA << RAID_CONTEXT_TYPE_SHIFT);
2664 } else {
2665 pRAID_Context->type = MPI2_TYPE_CUDA;
2666 pRAID_Context->nseg = 0x1;
2667 pRAID_Context->reg_lock_flags |=
2668 (MR_RL_FLAGS_SEQ_NUM_ENABLE|MR_RL_FLAGS_GRANT_DESTINATION_CUDA);
2669 }
2670 } else if (fusion->fast_path_io) {
2671 pRAID_Context->virtual_disk_tgt_id = cpu_to_le16(device_id);
2672 pRAID_Context->config_seq_num = 0;
2673 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
2674 io_request->DevHandle =
2675 local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
2676 } else {
2677 /* Want to send all IO via FW path */
2678 pRAID_Context->virtual_disk_tgt_id = cpu_to_le16(device_id);
2679 pRAID_Context->config_seq_num = 0;
2680 io_request->DevHandle = cpu_to_le16(0xFFFF);
2681 }
2682
2683 cmd->request_desc->SCSIIO.DevHandle = io_request->DevHandle;
2684 cmd->request_desc->SCSIIO.MSIxIndex =
2685 instance->msix_vectors ?
2686 (raw_smp_processor_id() % instance->msix_vectors) : 0;
2687
2688
2689 if (!fp_possible) {
2690 /* system pd firmware path */
2691 io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
2692 cmd->request_desc->SCSIIO.RequestFlags =
2693 (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
2694 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2695 pRAID_Context->timeout_value = cpu_to_le16(os_timeout_value);
2696 pRAID_Context->virtual_disk_tgt_id = cpu_to_le16(device_id);
2697 } else {
2698 /* system pd Fast Path */
2699 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
2700 timeout_limit = (scmd->device->type == TYPE_DISK) ?
2701 255 : 0xFFFF;
2702 pRAID_Context->timeout_value =
2703 cpu_to_le16((os_timeout_value > timeout_limit) ?
2704 timeout_limit : os_timeout_value);
2705 if (fusion->adapter_type >= INVADER_SERIES)
2706 io_request->IoFlags |=
2707 cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
2708
2709 cmd->request_desc->SCSIIO.RequestFlags =
2710 (MPI2_REQ_DESCRIPT_FLAGS_FP_IO <<
2711 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
2712 }
2713 }
2714
2715 /**
2716 * megasas_build_io_fusion - Prepares IOs to devices
2717 * @instance: Adapter soft state
2718 * @scp: SCSI command
2719 * @cmd: Command to be prepared
2720 *
2721 * Invokes helper functions to prepare request frames
2722 * and sets flags appropriate for IO/Non-IO cmd
2723 */
2724 int
2725 megasas_build_io_fusion(struct megasas_instance *instance,
2726 struct scsi_cmnd *scp,
2727 struct megasas_cmd_fusion *cmd)
2728 {
2729 int sge_count;
2730 u8 cmd_type;
2731 struct MPI2_RAID_SCSI_IO_REQUEST *io_request = cmd->io_request;
2732 struct MR_PRIV_DEVICE *mr_device_priv_data;
2733 mr_device_priv_data = scp->device->hostdata;
2734
2735 /* Zero out some fields so they don't get reused */
2736 memset(io_request->LUN, 0x0, 8);
2737 io_request->CDB.EEDP32.PrimaryReferenceTag = 0;
2738 io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0;
2739 io_request->EEDPFlags = 0;
2740 io_request->Control = 0;
2741 io_request->EEDPBlockSize = 0;
2742 io_request->ChainOffset = 0;
2743 io_request->RaidContext.raid_context.raid_flags = 0;
2744 io_request->RaidContext.raid_context.type = 0;
2745 io_request->RaidContext.raid_context.nseg = 0;
2746
2747 memcpy(io_request->CDB.CDB32, scp->cmnd, scp->cmd_len);
2748 /*
2749 * Just the CDB length,rest of the Flags are zero
2750 * This will be modified for FP in build_ldio_fusion
2751 */
2752 io_request->IoFlags = cpu_to_le16(scp->cmd_len);
2753
2754 switch (cmd_type = megasas_cmd_type(scp)) {
2755 case READ_WRITE_LDIO:
2756 megasas_build_ldio_fusion(instance, scp, cmd);
2757 break;
2758 case NON_READ_WRITE_LDIO:
2759 megasas_build_ld_nonrw_fusion(instance, scp, cmd);
2760 break;
2761 case READ_WRITE_SYSPDIO:
2762 megasas_build_syspd_fusion(instance, scp, cmd, true);
2763 break;
2764 case NON_READ_WRITE_SYSPDIO:
2765 if (instance->secure_jbod_support ||
2766 mr_device_priv_data->is_tm_capable)
2767 megasas_build_syspd_fusion(instance, scp, cmd, false);
2768 else
2769 megasas_build_syspd_fusion(instance, scp, cmd, true);
2770 break;
2771 default:
2772 break;
2773 }
2774
2775 /*
2776 * Construct SGL
2777 */
2778
2779 sge_count = megasas_make_sgl(instance, scp, cmd);
2780
2781 if (sge_count > instance->max_num_sge || (sge_count < 0)) {
2782 dev_err(&instance->pdev->dev,
2783 "%s %d sge_count (%d) is out of range. Range is: 0-%d\n",
2784 __func__, __LINE__, sge_count, instance->max_num_sge);
2785 return 1;
2786 }
2787
2788 if (instance->is_ventura) {
2789 set_num_sge(&io_request->RaidContext.raid_context_g35, sge_count);
2790 cpu_to_le16s(&io_request->RaidContext.raid_context_g35.routing_flags);
2791 cpu_to_le16s(&io_request->RaidContext.raid_context_g35.nseg_type);
2792 } else {
2793 /* numSGE store lower 8 bit of sge_count.
2794 * numSGEExt store higher 8 bit of sge_count
2795 */
2796 io_request->RaidContext.raid_context.num_sge = sge_count;
2797 io_request->RaidContext.raid_context.num_sge_ext =
2798 (u8)(sge_count >> 8);
2799 }
2800
2801 io_request->SGLFlags = cpu_to_le16(MPI2_SGE_FLAGS_64_BIT_ADDRESSING);
2802
2803 if (scp->sc_data_direction == PCI_DMA_TODEVICE)
2804 io_request->Control |= cpu_to_le32(MPI2_SCSIIO_CONTROL_WRITE);
2805 else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
2806 io_request->Control |= cpu_to_le32(MPI2_SCSIIO_CONTROL_READ);
2807
2808 io_request->SGLOffset0 =
2809 offsetof(struct MPI2_RAID_SCSI_IO_REQUEST, SGL) / 4;
2810
2811 io_request->SenseBufferLowAddress = cpu_to_le32(cmd->sense_phys_addr);
2812 io_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
2813
2814 cmd->scmd = scp;
2815 scp->SCp.ptr = (char *)cmd;
2816
2817 return 0;
2818 }
2819
2820 static union MEGASAS_REQUEST_DESCRIPTOR_UNION *
2821 megasas_get_request_descriptor(struct megasas_instance *instance, u16 index)
2822 {
2823 u8 *p;
2824 struct fusion_context *fusion;
2825
2826 fusion = instance->ctrl_context;
2827 p = fusion->req_frames_desc +
2828 sizeof(union MEGASAS_REQUEST_DESCRIPTOR_UNION) * index;
2829
2830 return (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)p;
2831 }
2832
2833
2834 /* megasas_prepate_secondRaid1_IO
2835 * It prepares the raid 1 second IO
2836 */
2837 void megasas_prepare_secondRaid1_IO(struct megasas_instance *instance,
2838 struct megasas_cmd_fusion *cmd,
2839 struct megasas_cmd_fusion *r1_cmd)
2840 {
2841 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc, *req_desc2 = NULL;
2842 struct fusion_context *fusion;
2843 fusion = instance->ctrl_context;
2844 req_desc = cmd->request_desc;
2845 /* copy the io request frame as well as 8 SGEs data for r1 command*/
2846 memcpy(r1_cmd->io_request, cmd->io_request,
2847 (sizeof(struct MPI2_RAID_SCSI_IO_REQUEST)));
2848 memcpy(&r1_cmd->io_request->SGL, &cmd->io_request->SGL,
2849 (fusion->max_sge_in_main_msg * sizeof(union MPI2_SGE_IO_UNION)));
2850 /*sense buffer is different for r1 command*/
2851 r1_cmd->io_request->SenseBufferLowAddress =
2852 cpu_to_le32(r1_cmd->sense_phys_addr);
2853 r1_cmd->scmd = cmd->scmd;
2854 req_desc2 = megasas_get_request_descriptor(instance,
2855 (r1_cmd->index - 1));
2856 req_desc2->Words = 0;
2857 r1_cmd->request_desc = req_desc2;
2858 req_desc2->SCSIIO.SMID = cpu_to_le16(r1_cmd->index);
2859 req_desc2->SCSIIO.RequestFlags = req_desc->SCSIIO.RequestFlags;
2860 r1_cmd->request_desc->SCSIIO.DevHandle = cmd->r1_alt_dev_handle;
2861 r1_cmd->io_request->DevHandle = cmd->r1_alt_dev_handle;
2862 r1_cmd->r1_alt_dev_handle = cmd->io_request->DevHandle;
2863 cmd->io_request->RaidContext.raid_context_g35.smid.peer_smid =
2864 cpu_to_le16(r1_cmd->index);
2865 r1_cmd->io_request->RaidContext.raid_context_g35.smid.peer_smid =
2866 cpu_to_le16(cmd->index);
2867 /*MSIxIndex of both commands request descriptors should be same*/
2868 r1_cmd->request_desc->SCSIIO.MSIxIndex =
2869 cmd->request_desc->SCSIIO.MSIxIndex;
2870 /*span arm is different for r1 cmd*/
2871 r1_cmd->io_request->RaidContext.raid_context_g35.span_arm =
2872 cmd->io_request->RaidContext.raid_context_g35.span_arm + 1;
2873 }
2874
2875 /**
2876 * megasas_build_and_issue_cmd_fusion -Main routine for building and
2877 * issuing non IOCTL cmd
2878 * @instance: Adapter soft state
2879 * @scmd: pointer to scsi cmd from OS
2880 */
2881 static u32
2882 megasas_build_and_issue_cmd_fusion(struct megasas_instance *instance,
2883 struct scsi_cmnd *scmd)
2884 {
2885 struct megasas_cmd_fusion *cmd, *r1_cmd = NULL;
2886 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2887 u32 index;
2888 struct fusion_context *fusion;
2889
2890 fusion = instance->ctrl_context;
2891
2892 if ((megasas_cmd_type(scmd) == READ_WRITE_LDIO) &&
2893 instance->ldio_threshold &&
2894 (atomic_inc_return(&instance->ldio_outstanding) >
2895 instance->ldio_threshold)) {
2896 atomic_dec(&instance->ldio_outstanding);
2897 return SCSI_MLQUEUE_DEVICE_BUSY;
2898 }
2899
2900 if (atomic_inc_return(&instance->fw_outstanding) >
2901 instance->host->can_queue) {
2902 atomic_dec(&instance->fw_outstanding);
2903 return SCSI_MLQUEUE_HOST_BUSY;
2904 }
2905
2906 cmd = megasas_get_cmd_fusion(instance, scmd->request->tag);
2907
2908 if (!cmd) {
2909 atomic_dec(&instance->fw_outstanding);
2910 return SCSI_MLQUEUE_HOST_BUSY;
2911 }
2912
2913 index = cmd->index;
2914
2915 req_desc = megasas_get_request_descriptor(instance, index-1);
2916
2917 req_desc->Words = 0;
2918 cmd->request_desc = req_desc;
2919
2920 if (megasas_build_io_fusion(instance, scmd, cmd)) {
2921 megasas_return_cmd_fusion(instance, cmd);
2922 dev_err(&instance->pdev->dev, "Error building command\n");
2923 cmd->request_desc = NULL;
2924 atomic_dec(&instance->fw_outstanding);
2925 return SCSI_MLQUEUE_HOST_BUSY;
2926 }
2927
2928 req_desc = cmd->request_desc;
2929 req_desc->SCSIIO.SMID = cpu_to_le16(index);
2930
2931 if (cmd->io_request->ChainOffset != 0 &&
2932 cmd->io_request->ChainOffset != 0xF)
2933 dev_err(&instance->pdev->dev, "The chain offset value is not "
2934 "correct : %x\n", cmd->io_request->ChainOffset);
2935 /*
2936 * if it is raid 1/10 fp write capable.
2937 * try to get second command from pool and construct it.
2938 * From FW, it has confirmed that lba values of two PDs
2939 * corresponds to single R1/10 LD are always same
2940 *
2941 */
2942 /* driver side count always should be less than max_fw_cmds
2943 * to get new command
2944 */
2945 if (cmd->r1_alt_dev_handle != MR_DEVHANDLE_INVALID) {
2946 r1_cmd = megasas_get_cmd_fusion(instance,
2947 (scmd->request->tag + instance->max_fw_cmds));
2948 megasas_prepare_secondRaid1_IO(instance, cmd, r1_cmd);
2949 }
2950
2951
2952 /*
2953 * Issue the command to the FW
2954 */
2955
2956 megasas_fire_cmd_fusion(instance, req_desc);
2957
2958 if (r1_cmd)
2959 megasas_fire_cmd_fusion(instance, r1_cmd->request_desc);
2960
2961
2962 return 0;
2963 }
2964
2965 /**
2966 * megasas_complete_r1_command -
2967 * completes R1 FP write commands which has valid peer smid
2968 * @instance: Adapter soft state
2969 * @cmd_fusion: MPT command frame
2970 *
2971 */
2972 static inline void
2973 megasas_complete_r1_command(struct megasas_instance *instance,
2974 struct megasas_cmd_fusion *cmd)
2975 {
2976 u8 *sense, status, ex_status;
2977 u32 data_length;
2978 u16 peer_smid;
2979 struct fusion_context *fusion;
2980 struct megasas_cmd_fusion *r1_cmd = NULL;
2981 struct scsi_cmnd *scmd_local = NULL;
2982 struct RAID_CONTEXT_G35 *rctx_g35;
2983
2984 rctx_g35 = &cmd->io_request->RaidContext.raid_context_g35;
2985 fusion = instance->ctrl_context;
2986 peer_smid = le16_to_cpu(rctx_g35->smid.peer_smid);
2987
2988 r1_cmd = fusion->cmd_list[peer_smid - 1];
2989 scmd_local = cmd->scmd;
2990 status = rctx_g35->status;
2991 ex_status = rctx_g35->ex_status;
2992 data_length = cmd->io_request->DataLength;
2993 sense = cmd->sense;
2994
2995 cmd->cmd_completed = true;
2996
2997 /* Check if peer command is completed or not*/
2998 if (r1_cmd->cmd_completed) {
2999 rctx_g35 = &r1_cmd->io_request->RaidContext.raid_context_g35;
3000 if (rctx_g35->status != MFI_STAT_OK) {
3001 status = rctx_g35->status;
3002 ex_status = rctx_g35->ex_status;
3003 data_length = r1_cmd->io_request->DataLength;
3004 sense = r1_cmd->sense;
3005 }
3006
3007 megasas_return_cmd_fusion(instance, r1_cmd);
3008 map_cmd_status(fusion, scmd_local, status, ex_status,
3009 le32_to_cpu(data_length), sense);
3010 if (instance->ldio_threshold &&
3011 megasas_cmd_type(scmd_local) == READ_WRITE_LDIO)
3012 atomic_dec(&instance->ldio_outstanding);
3013 scmd_local->SCp.ptr = NULL;
3014 megasas_return_cmd_fusion(instance, cmd);
3015 scsi_dma_unmap(scmd_local);
3016 scmd_local->scsi_done(scmd_local);
3017 }
3018 }
3019
3020 /**
3021 * complete_cmd_fusion - Completes command
3022 * @instance: Adapter soft state
3023 * Completes all commands that is in reply descriptor queue
3024 */
3025 int
3026 complete_cmd_fusion(struct megasas_instance *instance, u32 MSIxIndex)
3027 {
3028 union MPI2_REPLY_DESCRIPTORS_UNION *desc;
3029 struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *reply_desc;
3030 struct MPI2_RAID_SCSI_IO_REQUEST *scsi_io_req;
3031 struct fusion_context *fusion;
3032 struct megasas_cmd *cmd_mfi;
3033 struct megasas_cmd_fusion *cmd_fusion;
3034 u16 smid, num_completed;
3035 u8 reply_descript_type, *sense, status, extStatus;
3036 u32 device_id, data_length;
3037 union desc_value d_val;
3038 struct LD_LOAD_BALANCE_INFO *lbinfo;
3039 int threshold_reply_count = 0;
3040 struct scsi_cmnd *scmd_local = NULL;
3041 struct MR_TASK_MANAGE_REQUEST *mr_tm_req;
3042 struct MPI2_SCSI_TASK_MANAGE_REQUEST *mpi_tm_req;
3043
3044 fusion = instance->ctrl_context;
3045
3046 if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
3047 return IRQ_HANDLED;
3048
3049 desc = fusion->reply_frames_desc[MSIxIndex] +
3050 fusion->last_reply_idx[MSIxIndex];
3051
3052 reply_desc = (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc;
3053
3054 d_val.word = desc->Words;
3055
3056 reply_descript_type = reply_desc->ReplyFlags &
3057 MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
3058
3059 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
3060 return IRQ_NONE;
3061
3062 num_completed = 0;
3063
3064 while (d_val.u.low != cpu_to_le32(UINT_MAX) &&
3065 d_val.u.high != cpu_to_le32(UINT_MAX)) {
3066
3067 smid = le16_to_cpu(reply_desc->SMID);
3068 cmd_fusion = fusion->cmd_list[smid - 1];
3069 scsi_io_req = (struct MPI2_RAID_SCSI_IO_REQUEST *)
3070 cmd_fusion->io_request;
3071
3072 scmd_local = cmd_fusion->scmd;
3073 status = scsi_io_req->RaidContext.raid_context.status;
3074 extStatus = scsi_io_req->RaidContext.raid_context.ex_status;
3075 sense = cmd_fusion->sense;
3076 data_length = scsi_io_req->DataLength;
3077
3078 switch (scsi_io_req->Function) {
3079 case MPI2_FUNCTION_SCSI_TASK_MGMT:
3080 mr_tm_req = (struct MR_TASK_MANAGE_REQUEST *)
3081 cmd_fusion->io_request;
3082 mpi_tm_req = (struct MPI2_SCSI_TASK_MANAGE_REQUEST *)
3083 &mr_tm_req->TmRequest;
3084 dev_dbg(&instance->pdev->dev, "TM completion:"
3085 "type: 0x%x TaskMID: 0x%x\n",
3086 mpi_tm_req->TaskType, mpi_tm_req->TaskMID);
3087 complete(&cmd_fusion->done);
3088 break;
3089 case MPI2_FUNCTION_SCSI_IO_REQUEST: /*Fast Path IO.*/
3090 /* Update load balancing info */
3091 if (fusion->load_balance_info &&
3092 (cmd_fusion->scmd->SCp.Status &
3093 MEGASAS_LOAD_BALANCE_FLAG)) {
3094 device_id = MEGASAS_DEV_INDEX(scmd_local);
3095 lbinfo = &fusion->load_balance_info[device_id];
3096 atomic_dec(&lbinfo->scsi_pending_cmds[cmd_fusion->pd_r1_lb]);
3097 cmd_fusion->scmd->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG;
3098 }
3099 //Fall thru and complete IO
3100 case MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST: /* LD-IO Path */
3101 atomic_dec(&instance->fw_outstanding);
3102 if (cmd_fusion->r1_alt_dev_handle == MR_DEVHANDLE_INVALID) {
3103 map_cmd_status(fusion, scmd_local, status,
3104 extStatus, le32_to_cpu(data_length),
3105 sense);
3106 if (instance->ldio_threshold &&
3107 (megasas_cmd_type(scmd_local) == READ_WRITE_LDIO))
3108 atomic_dec(&instance->ldio_outstanding);
3109 scmd_local->SCp.ptr = NULL;
3110 megasas_return_cmd_fusion(instance, cmd_fusion);
3111 scsi_dma_unmap(scmd_local);
3112 scmd_local->scsi_done(scmd_local);
3113 } else /* Optimal VD - R1 FP command completion. */
3114 megasas_complete_r1_command(instance, cmd_fusion);
3115 break;
3116 case MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST: /*MFI command */
3117 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
3118 /* Poll mode. Dummy free.
3119 * In case of Interrupt mode, caller has reverse check.
3120 */
3121 if (cmd_mfi->flags & DRV_DCMD_POLLED_MODE) {
3122 cmd_mfi->flags &= ~DRV_DCMD_POLLED_MODE;
3123 megasas_return_cmd(instance, cmd_mfi);
3124 } else
3125 megasas_complete_cmd(instance, cmd_mfi, DID_OK);
3126 break;
3127 }
3128
3129 fusion->last_reply_idx[MSIxIndex]++;
3130 if (fusion->last_reply_idx[MSIxIndex] >=
3131 fusion->reply_q_depth)
3132 fusion->last_reply_idx[MSIxIndex] = 0;
3133
3134 desc->Words = cpu_to_le64(ULLONG_MAX);
3135 num_completed++;
3136 threshold_reply_count++;
3137
3138 /* Get the next reply descriptor */
3139 if (!fusion->last_reply_idx[MSIxIndex])
3140 desc = fusion->reply_frames_desc[MSIxIndex];
3141 else
3142 desc++;
3143
3144 reply_desc =
3145 (struct MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR *)desc;
3146
3147 d_val.word = desc->Words;
3148
3149 reply_descript_type = reply_desc->ReplyFlags &
3150 MPI2_RPY_DESCRIPT_FLAGS_TYPE_MASK;
3151
3152 if (reply_descript_type == MPI2_RPY_DESCRIPT_FLAGS_UNUSED)
3153 break;
3154 /*
3155 * Write to reply post host index register after completing threshold
3156 * number of reply counts and still there are more replies in reply queue
3157 * pending to be completed
3158 */
3159 if (threshold_reply_count >= THRESHOLD_REPLY_COUNT) {
3160 if (instance->msix_combined)
3161 writel(((MSIxIndex & 0x7) << 24) |
3162 fusion->last_reply_idx[MSIxIndex],
3163 instance->reply_post_host_index_addr[MSIxIndex/8]);
3164 else
3165 writel((MSIxIndex << 24) |
3166 fusion->last_reply_idx[MSIxIndex],
3167 instance->reply_post_host_index_addr[0]);
3168 threshold_reply_count = 0;
3169 }
3170 }
3171
3172 if (!num_completed)
3173 return IRQ_NONE;
3174
3175 wmb();
3176 if (instance->msix_combined)
3177 writel(((MSIxIndex & 0x7) << 24) |
3178 fusion->last_reply_idx[MSIxIndex],
3179 instance->reply_post_host_index_addr[MSIxIndex/8]);
3180 else
3181 writel((MSIxIndex << 24) |
3182 fusion->last_reply_idx[MSIxIndex],
3183 instance->reply_post_host_index_addr[0]);
3184 megasas_check_and_restore_queue_depth(instance);
3185 return IRQ_HANDLED;
3186 }
3187
3188 /**
3189 * megasas_sync_irqs - Synchronizes all IRQs owned by adapter
3190 * @instance: Adapter soft state
3191 */
3192 void megasas_sync_irqs(unsigned long instance_addr)
3193 {
3194 u32 count, i;
3195 struct megasas_instance *instance =
3196 (struct megasas_instance *)instance_addr;
3197
3198 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3199
3200 for (i = 0; i < count; i++)
3201 synchronize_irq(pci_irq_vector(instance->pdev, i));
3202 }
3203
3204 /**
3205 * megasas_complete_cmd_dpc_fusion - Completes command
3206 * @instance: Adapter soft state
3207 *
3208 * Tasklet to complete cmds
3209 */
3210 void
3211 megasas_complete_cmd_dpc_fusion(unsigned long instance_addr)
3212 {
3213 struct megasas_instance *instance =
3214 (struct megasas_instance *)instance_addr;
3215 unsigned long flags;
3216 u32 count, MSIxIndex;
3217
3218 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3219
3220 /* If we have already declared adapter dead, donot complete cmds */
3221 spin_lock_irqsave(&instance->hba_lock, flags);
3222 if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
3223 spin_unlock_irqrestore(&instance->hba_lock, flags);
3224 return;
3225 }
3226 spin_unlock_irqrestore(&instance->hba_lock, flags);
3227
3228 for (MSIxIndex = 0 ; MSIxIndex < count; MSIxIndex++)
3229 complete_cmd_fusion(instance, MSIxIndex);
3230 }
3231
3232 /**
3233 * megasas_isr_fusion - isr entry point
3234 */
3235 irqreturn_t megasas_isr_fusion(int irq, void *devp)
3236 {
3237 struct megasas_irq_context *irq_context = devp;
3238 struct megasas_instance *instance = irq_context->instance;
3239 u32 mfiStatus, fw_state, dma_state;
3240
3241 if (instance->mask_interrupts)
3242 return IRQ_NONE;
3243
3244 if (!instance->msix_vectors) {
3245 mfiStatus = instance->instancet->clear_intr(instance->reg_set);
3246 if (!mfiStatus)
3247 return IRQ_NONE;
3248 }
3249
3250 /* If we are resetting, bail */
3251 if (test_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags)) {
3252 instance->instancet->clear_intr(instance->reg_set);
3253 return IRQ_HANDLED;
3254 }
3255
3256 if (!complete_cmd_fusion(instance, irq_context->MSIxIndex)) {
3257 instance->instancet->clear_intr(instance->reg_set);
3258 /* If we didn't complete any commands, check for FW fault */
3259 fw_state = instance->instancet->read_fw_status_reg(
3260 instance->reg_set) & MFI_STATE_MASK;
3261 dma_state = instance->instancet->read_fw_status_reg
3262 (instance->reg_set) & MFI_STATE_DMADONE;
3263 if (instance->crash_dump_drv_support &&
3264 instance->crash_dump_app_support) {
3265 /* Start collecting crash, if DMA bit is done */
3266 if ((fw_state == MFI_STATE_FAULT) && dma_state)
3267 schedule_work(&instance->crash_init);
3268 else if (fw_state == MFI_STATE_FAULT) {
3269 if (instance->unload == 0)
3270 schedule_work(&instance->work_init);
3271 }
3272 } else if (fw_state == MFI_STATE_FAULT) {
3273 dev_warn(&instance->pdev->dev, "Iop2SysDoorbellInt"
3274 "for scsi%d\n", instance->host->host_no);
3275 if (instance->unload == 0)
3276 schedule_work(&instance->work_init);
3277 }
3278 }
3279
3280 return IRQ_HANDLED;
3281 }
3282
3283 /**
3284 * build_mpt_mfi_pass_thru - builds a cmd fo MFI Pass thru
3285 * @instance: Adapter soft state
3286 * mfi_cmd: megasas_cmd pointer
3287 *
3288 */
3289 void
3290 build_mpt_mfi_pass_thru(struct megasas_instance *instance,
3291 struct megasas_cmd *mfi_cmd)
3292 {
3293 struct MPI25_IEEE_SGE_CHAIN64 *mpi25_ieee_chain;
3294 struct MPI2_RAID_SCSI_IO_REQUEST *io_req;
3295 struct megasas_cmd_fusion *cmd;
3296 struct fusion_context *fusion;
3297 struct megasas_header *frame_hdr = &mfi_cmd->frame->hdr;
3298
3299 fusion = instance->ctrl_context;
3300
3301 cmd = megasas_get_cmd_fusion(instance,
3302 instance->max_scsi_cmds + mfi_cmd->index);
3303
3304 /* Save the smid. To be used for returning the cmd */
3305 mfi_cmd->context.smid = cmd->index;
3306
3307 /*
3308 * For cmds where the flag is set, store the flag and check
3309 * on completion. For cmds with this flag, don't call
3310 * megasas_complete_cmd
3311 */
3312
3313 if (frame_hdr->flags & cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE))
3314 mfi_cmd->flags |= DRV_DCMD_POLLED_MODE;
3315
3316 io_req = cmd->io_request;
3317
3318 if (fusion->adapter_type >= INVADER_SERIES) {
3319 struct MPI25_IEEE_SGE_CHAIN64 *sgl_ptr_end =
3320 (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL;
3321 sgl_ptr_end += fusion->max_sge_in_main_msg - 1;
3322 sgl_ptr_end->Flags = 0;
3323 }
3324
3325 mpi25_ieee_chain =
3326 (struct MPI25_IEEE_SGE_CHAIN64 *)&io_req->SGL.IeeeChain;
3327
3328 io_req->Function = MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST;
3329 io_req->SGLOffset0 = offsetof(struct MPI2_RAID_SCSI_IO_REQUEST,
3330 SGL) / 4;
3331 io_req->ChainOffset = fusion->chain_offset_mfi_pthru;
3332
3333 mpi25_ieee_chain->Address = cpu_to_le64(mfi_cmd->frame_phys_addr);
3334
3335 mpi25_ieee_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT |
3336 MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR;
3337
3338 mpi25_ieee_chain->Length = cpu_to_le32(instance->mfi_frame_size);
3339 }
3340
3341 /**
3342 * build_mpt_cmd - Calls helper function to build a cmd MFI Pass thru cmd
3343 * @instance: Adapter soft state
3344 * @cmd: mfi cmd to build
3345 *
3346 */
3347 union MEGASAS_REQUEST_DESCRIPTOR_UNION *
3348 build_mpt_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
3349 {
3350 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc = NULL;
3351 u16 index;
3352
3353 build_mpt_mfi_pass_thru(instance, cmd);
3354 index = cmd->context.smid;
3355
3356 req_desc = megasas_get_request_descriptor(instance, index - 1);
3357
3358 req_desc->Words = 0;
3359 req_desc->SCSIIO.RequestFlags = (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
3360 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
3361
3362 req_desc->SCSIIO.SMID = cpu_to_le16(index);
3363
3364 return req_desc;
3365 }
3366
3367 /**
3368 * megasas_issue_dcmd_fusion - Issues a MFI Pass thru cmd
3369 * @instance: Adapter soft state
3370 * @cmd: mfi cmd pointer
3371 *
3372 */
3373 void
3374 megasas_issue_dcmd_fusion(struct megasas_instance *instance,
3375 struct megasas_cmd *cmd)
3376 {
3377 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
3378
3379 req_desc = build_mpt_cmd(instance, cmd);
3380
3381 megasas_fire_cmd_fusion(instance, req_desc);
3382 return;
3383 }
3384
3385 /**
3386 * megasas_release_fusion - Reverses the FW initialization
3387 * @instance: Adapter soft state
3388 */
3389 void
3390 megasas_release_fusion(struct megasas_instance *instance)
3391 {
3392 megasas_free_cmds(instance);
3393 megasas_free_cmds_fusion(instance);
3394
3395 iounmap(instance->reg_set);
3396
3397 pci_release_selected_regions(instance->pdev, 1<<instance->bar);
3398 }
3399
3400 /**
3401 * megasas_read_fw_status_reg_fusion - returns the current FW status value
3402 * @regs: MFI register set
3403 */
3404 static u32
3405 megasas_read_fw_status_reg_fusion(struct megasas_register_set __iomem *regs)
3406 {
3407 return readl(&(regs)->outbound_scratch_pad);
3408 }
3409
3410 /**
3411 * megasas_alloc_host_crash_buffer - Host buffers for Crash dump collection from Firmware
3412 * @instance: Controller's soft instance
3413 * return: Number of allocated host crash buffers
3414 */
3415 static void
3416 megasas_alloc_host_crash_buffer(struct megasas_instance *instance)
3417 {
3418 unsigned int i;
3419
3420 for (i = 0; i < MAX_CRASH_DUMP_SIZE; i++) {
3421 instance->crash_buf[i] = vzalloc(CRASH_DMA_BUF_SIZE);
3422 if (!instance->crash_buf[i]) {
3423 dev_info(&instance->pdev->dev, "Firmware crash dump "
3424 "memory allocation failed at index %d\n", i);
3425 break;
3426 }
3427 }
3428 instance->drv_buf_alloc = i;
3429 }
3430
3431 /**
3432 * megasas_free_host_crash_buffer - Host buffers for Crash dump collection from Firmware
3433 * @instance: Controller's soft instance
3434 */
3435 void
3436 megasas_free_host_crash_buffer(struct megasas_instance *instance)
3437 {
3438 unsigned int i;
3439 for (i = 0; i < instance->drv_buf_alloc; i++) {
3440 if (instance->crash_buf[i])
3441 vfree(instance->crash_buf[i]);
3442 }
3443 instance->drv_buf_index = 0;
3444 instance->drv_buf_alloc = 0;
3445 instance->fw_crash_state = UNAVAILABLE;
3446 instance->fw_crash_buffer_size = 0;
3447 }
3448
3449 /**
3450 * megasas_adp_reset_fusion - For controller reset
3451 * @regs: MFI register set
3452 */
3453 static int
3454 megasas_adp_reset_fusion(struct megasas_instance *instance,
3455 struct megasas_register_set __iomem *regs)
3456 {
3457 u32 host_diag, abs_state, retry;
3458
3459 /* Now try to reset the chip */
3460 writel(MPI2_WRSEQ_FLUSH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3461 writel(MPI2_WRSEQ_1ST_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3462 writel(MPI2_WRSEQ_2ND_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3463 writel(MPI2_WRSEQ_3RD_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3464 writel(MPI2_WRSEQ_4TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3465 writel(MPI2_WRSEQ_5TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3466 writel(MPI2_WRSEQ_6TH_KEY_VALUE, &instance->reg_set->fusion_seq_offset);
3467
3468 /* Check that the diag write enable (DRWE) bit is on */
3469 host_diag = readl(&instance->reg_set->fusion_host_diag);
3470 retry = 0;
3471 while (!(host_diag & HOST_DIAG_WRITE_ENABLE)) {
3472 msleep(100);
3473 host_diag = readl(&instance->reg_set->fusion_host_diag);
3474 if (retry++ == 100) {
3475 dev_warn(&instance->pdev->dev,
3476 "Host diag unlock failed from %s %d\n",
3477 __func__, __LINE__);
3478 break;
3479 }
3480 }
3481 if (!(host_diag & HOST_DIAG_WRITE_ENABLE))
3482 return -1;
3483
3484 /* Send chip reset command */
3485 writel(host_diag | HOST_DIAG_RESET_ADAPTER,
3486 &instance->reg_set->fusion_host_diag);
3487 msleep(3000);
3488
3489 /* Make sure reset adapter bit is cleared */
3490 host_diag = readl(&instance->reg_set->fusion_host_diag);
3491 retry = 0;
3492 while (host_diag & HOST_DIAG_RESET_ADAPTER) {
3493 msleep(100);
3494 host_diag = readl(&instance->reg_set->fusion_host_diag);
3495 if (retry++ == 1000) {
3496 dev_warn(&instance->pdev->dev,
3497 "Diag reset adapter never cleared %s %d\n",
3498 __func__, __LINE__);
3499 break;
3500 }
3501 }
3502 if (host_diag & HOST_DIAG_RESET_ADAPTER)
3503 return -1;
3504
3505 abs_state = instance->instancet->read_fw_status_reg(instance->reg_set)
3506 & MFI_STATE_MASK;
3507 retry = 0;
3508
3509 while ((abs_state <= MFI_STATE_FW_INIT) && (retry++ < 1000)) {
3510 msleep(100);
3511 abs_state = instance->instancet->
3512 read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
3513 }
3514 if (abs_state <= MFI_STATE_FW_INIT) {
3515 dev_warn(&instance->pdev->dev,
3516 "fw state < MFI_STATE_FW_INIT, state = 0x%x %s %d\n",
3517 abs_state, __func__, __LINE__);
3518 return -1;
3519 }
3520
3521 return 0;
3522 }
3523
3524 /**
3525 * megasas_check_reset_fusion - For controller reset check
3526 * @regs: MFI register set
3527 */
3528 static int
3529 megasas_check_reset_fusion(struct megasas_instance *instance,
3530 struct megasas_register_set __iomem *regs)
3531 {
3532 return 0;
3533 }
3534
3535 /* This function waits for outstanding commands on fusion to complete */
3536 int megasas_wait_for_outstanding_fusion(struct megasas_instance *instance,
3537 int reason, int *convert)
3538 {
3539 int i, outstanding, retval = 0, hb_seconds_missed = 0;
3540 u32 fw_state;
3541
3542 for (i = 0; i < resetwaittime; i++) {
3543 /* Check if firmware is in fault state */
3544 fw_state = instance->instancet->read_fw_status_reg(
3545 instance->reg_set) & MFI_STATE_MASK;
3546 if (fw_state == MFI_STATE_FAULT) {
3547 dev_warn(&instance->pdev->dev, "Found FW in FAULT state,"
3548 " will reset adapter scsi%d.\n",
3549 instance->host->host_no);
3550 megasas_complete_cmd_dpc_fusion((unsigned long)instance);
3551 if (instance->requestorId && reason) {
3552 dev_warn(&instance->pdev->dev, "SR-IOV Found FW in FAULT"
3553 " state while polling during"
3554 " I/O timeout handling for %d\n",
3555 instance->host->host_no);
3556 *convert = 1;
3557 }
3558
3559 retval = 1;
3560 goto out;
3561 }
3562
3563 if (reason == MFI_IO_TIMEOUT_OCR) {
3564 dev_info(&instance->pdev->dev,
3565 "MFI IO is timed out, initiating OCR\n");
3566 megasas_complete_cmd_dpc_fusion((unsigned long)instance);
3567 retval = 1;
3568 goto out;
3569 }
3570
3571 /* If SR-IOV VF mode & heartbeat timeout, don't wait */
3572 if (instance->requestorId && !reason) {
3573 retval = 1;
3574 goto out;
3575 }
3576
3577 /* If SR-IOV VF mode & I/O timeout, check for HB timeout */
3578 if (instance->requestorId && (reason == SCSIIO_TIMEOUT_OCR)) {
3579 if (instance->hb_host_mem->HB.fwCounter !=
3580 instance->hb_host_mem->HB.driverCounter) {
3581 instance->hb_host_mem->HB.driverCounter =
3582 instance->hb_host_mem->HB.fwCounter;
3583 hb_seconds_missed = 0;
3584 } else {
3585 hb_seconds_missed++;
3586 if (hb_seconds_missed ==
3587 (MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF/HZ)) {
3588 dev_warn(&instance->pdev->dev, "SR-IOV:"
3589 " Heartbeat never completed "
3590 " while polling during I/O "
3591 " timeout handling for "
3592 "scsi%d.\n",
3593 instance->host->host_no);
3594 *convert = 1;
3595 retval = 1;
3596 goto out;
3597 }
3598 }
3599 }
3600
3601 megasas_complete_cmd_dpc_fusion((unsigned long)instance);
3602 outstanding = atomic_read(&instance->fw_outstanding);
3603 if (!outstanding)
3604 goto out;
3605
3606 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
3607 dev_notice(&instance->pdev->dev, "[%2d]waiting for %d "
3608 "commands to complete for scsi%d\n", i,
3609 outstanding, instance->host->host_no);
3610 }
3611 msleep(1000);
3612 }
3613
3614 if (atomic_read(&instance->fw_outstanding)) {
3615 dev_err(&instance->pdev->dev, "pending commands remain after waiting, "
3616 "will reset adapter scsi%d.\n",
3617 instance->host->host_no);
3618 *convert = 1;
3619 retval = 1;
3620 }
3621 out:
3622 return retval;
3623 }
3624
3625 void megasas_reset_reply_desc(struct megasas_instance *instance)
3626 {
3627 int i, j, count;
3628 struct fusion_context *fusion;
3629 union MPI2_REPLY_DESCRIPTORS_UNION *reply_desc;
3630
3631 fusion = instance->ctrl_context;
3632 count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
3633 for (i = 0 ; i < count ; i++) {
3634 fusion->last_reply_idx[i] = 0;
3635 reply_desc = fusion->reply_frames_desc[i];
3636 for (j = 0 ; j < fusion->reply_q_depth; j++, reply_desc++)
3637 reply_desc->Words = cpu_to_le64(ULLONG_MAX);
3638 }
3639 }
3640
3641 /*
3642 * megasas_refire_mgmt_cmd : Re-fire management commands
3643 * @instance: Controller's soft instance
3644 */
3645 void megasas_refire_mgmt_cmd(struct megasas_instance *instance)
3646 {
3647 int j;
3648 struct megasas_cmd_fusion *cmd_fusion;
3649 struct fusion_context *fusion;
3650 struct megasas_cmd *cmd_mfi;
3651 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
3652 u16 smid;
3653 bool refire_cmd = 0;
3654
3655 fusion = instance->ctrl_context;
3656
3657 /* Re-fire management commands.
3658 * Do not traverse complet MPT frame pool. Start from max_scsi_cmds.
3659 */
3660 for (j = instance->max_scsi_cmds ; j < instance->max_fw_cmds; j++) {
3661 cmd_fusion = fusion->cmd_list[j];
3662 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
3663 smid = le16_to_cpu(cmd_mfi->context.smid);
3664
3665 if (!smid)
3666 continue;
3667
3668 /* Do not refire shutdown command */
3669 if (le32_to_cpu(cmd_mfi->frame->dcmd.opcode) ==
3670 MR_DCMD_CTRL_SHUTDOWN) {
3671 cmd_mfi->frame->dcmd.cmd_status = MFI_STAT_OK;
3672 megasas_complete_cmd(instance, cmd_mfi, DID_OK);
3673 continue;
3674 }
3675
3676 req_desc = megasas_get_request_descriptor
3677 (instance, smid - 1);
3678 refire_cmd = req_desc && ((cmd_mfi->frame->dcmd.opcode !=
3679 cpu_to_le32(MR_DCMD_LD_MAP_GET_INFO)) &&
3680 (cmd_mfi->frame->dcmd.opcode !=
3681 cpu_to_le32(MR_DCMD_SYSTEM_PD_MAP_GET_INFO)))
3682 && !(cmd_mfi->flags & DRV_DCMD_SKIP_REFIRE);
3683 if (refire_cmd)
3684 megasas_fire_cmd_fusion(instance, req_desc);
3685 else
3686 megasas_return_cmd(instance, cmd_mfi);
3687 }
3688 }
3689
3690 /*
3691 * megasas_track_scsiio : Track SCSI IOs outstanding to a SCSI device
3692 * @instance: per adapter struct
3693 * @channel: the channel assigned by the OS
3694 * @id: the id assigned by the OS
3695 *
3696 * Returns SUCCESS if no IOs pending to SCSI device, else return FAILED
3697 */
3698
3699 static int megasas_track_scsiio(struct megasas_instance *instance,
3700 int id, int channel)
3701 {
3702 int i, found = 0;
3703 struct megasas_cmd_fusion *cmd_fusion;
3704 struct fusion_context *fusion;
3705 fusion = instance->ctrl_context;
3706
3707 for (i = 0 ; i < instance->max_scsi_cmds; i++) {
3708 cmd_fusion = fusion->cmd_list[i];
3709 if (cmd_fusion->scmd &&
3710 (cmd_fusion->scmd->device->id == id &&
3711 cmd_fusion->scmd->device->channel == channel)) {
3712 dev_info(&instance->pdev->dev,
3713 "SCSI commands pending to target"
3714 "channel %d id %d \tSMID: 0x%x\n",
3715 channel, id, cmd_fusion->index);
3716 scsi_print_command(cmd_fusion->scmd);
3717 found = 1;
3718 break;
3719 }
3720 }
3721
3722 return found ? FAILED : SUCCESS;
3723 }
3724
3725 /**
3726 * megasas_tm_response_code - translation of device response code
3727 * @ioc: per adapter object
3728 * @mpi_reply: MPI reply returned by firmware
3729 *
3730 * Return nothing.
3731 */
3732 static void
3733 megasas_tm_response_code(struct megasas_instance *instance,
3734 struct MPI2_SCSI_TASK_MANAGE_REPLY *mpi_reply)
3735 {
3736 char *desc;
3737
3738 switch (mpi_reply->ResponseCode) {
3739 case MPI2_SCSITASKMGMT_RSP_TM_COMPLETE:
3740 desc = "task management request completed";
3741 break;
3742 case MPI2_SCSITASKMGMT_RSP_INVALID_FRAME:
3743 desc = "invalid frame";
3744 break;
3745 case MPI2_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED:
3746 desc = "task management request not supported";
3747 break;
3748 case MPI2_SCSITASKMGMT_RSP_TM_FAILED:
3749 desc = "task management request failed";
3750 break;
3751 case MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED:
3752 desc = "task management request succeeded";
3753 break;
3754 case MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN:
3755 desc = "invalid lun";
3756 break;
3757 case 0xA:
3758 desc = "overlapped tag attempted";
3759 break;
3760 case MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC:
3761 desc = "task queued, however not sent to target";
3762 break;
3763 default:
3764 desc = "unknown";
3765 break;
3766 }
3767 dev_dbg(&instance->pdev->dev, "response_code(%01x): %s\n",
3768 mpi_reply->ResponseCode, desc);
3769 dev_dbg(&instance->pdev->dev,
3770 "TerminationCount/DevHandle/Function/TaskType/IOCStat/IOCLoginfo"
3771 " 0x%x/0x%x/0x%x/0x%x/0x%x/0x%x\n",
3772 mpi_reply->TerminationCount, mpi_reply->DevHandle,
3773 mpi_reply->Function, mpi_reply->TaskType,
3774 mpi_reply->IOCStatus, mpi_reply->IOCLogInfo);
3775 }
3776
3777 /**
3778 * megasas_issue_tm - main routine for sending tm requests
3779 * @instance: per adapter struct
3780 * @device_handle: device handle
3781 * @channel: the channel assigned by the OS
3782 * @id: the id assigned by the OS
3783 * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in megaraid_sas_fusion.c)
3784 * @smid_task: smid assigned to the task
3785 * @m_type: TM_MUTEX_ON or TM_MUTEX_OFF
3786 * Context: user
3787 *
3788 * MegaRaid use MPT interface for Task Magement request.
3789 * A generic API for sending task management requests to firmware.
3790 *
3791 * Return SUCCESS or FAILED.
3792 */
3793 static int
3794 megasas_issue_tm(struct megasas_instance *instance, u16 device_handle,
3795 uint channel, uint id, u16 smid_task, u8 type)
3796 {
3797 struct MR_TASK_MANAGE_REQUEST *mr_request;
3798 struct MPI2_SCSI_TASK_MANAGE_REQUEST *mpi_request;
3799 unsigned long timeleft;
3800 struct megasas_cmd_fusion *cmd_fusion;
3801 struct megasas_cmd *cmd_mfi;
3802 union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
3803 struct fusion_context *fusion = NULL;
3804 struct megasas_cmd_fusion *scsi_lookup;
3805 int rc;
3806 struct MPI2_SCSI_TASK_MANAGE_REPLY *mpi_reply;
3807
3808 fusion = instance->ctrl_context;
3809
3810 cmd_mfi = megasas_get_cmd(instance);
3811
3812 if (!cmd_mfi) {
3813 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
3814 __func__, __LINE__);
3815 return -ENOMEM;
3816 }
3817
3818 cmd_fusion = megasas_get_cmd_fusion(instance,
3819 instance->max_scsi_cmds + cmd_mfi->index);
3820
3821 /* Save the smid. To be used for returning the cmd */
3822 cmd_mfi->context.smid = cmd_fusion->index;
3823
3824 req_desc = megasas_get_request_descriptor(instance,
3825 (cmd_fusion->index - 1));
3826
3827 cmd_fusion->request_desc = req_desc;
3828 req_desc->Words = 0;
3829
3830 mr_request = (struct MR_TASK_MANAGE_REQUEST *) cmd_fusion->io_request;
3831 memset(mr_request, 0, sizeof(struct MR_TASK_MANAGE_REQUEST));
3832 mpi_request = (struct MPI2_SCSI_TASK_MANAGE_REQUEST *) &mr_request->TmRequest;
3833 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3834 mpi_request->DevHandle = cpu_to_le16(device_handle);
3835 mpi_request->TaskType = type;
3836 mpi_request->TaskMID = cpu_to_le16(smid_task);
3837 mpi_request->LUN[1] = 0;
3838
3839
3840 req_desc = cmd_fusion->request_desc;
3841 req_desc->HighPriority.SMID = cpu_to_le16(cmd_fusion->index);
3842 req_desc->HighPriority.RequestFlags =
3843 (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<
3844 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
3845 req_desc->HighPriority.MSIxIndex = 0;
3846 req_desc->HighPriority.LMID = 0;
3847 req_desc->HighPriority.Reserved1 = 0;
3848
3849 if (channel < MEGASAS_MAX_PD_CHANNELS)
3850 mr_request->tmReqFlags.isTMForPD = 1;
3851 else
3852 mr_request->tmReqFlags.isTMForLD = 1;
3853
3854 init_completion(&cmd_fusion->done);
3855 megasas_fire_cmd_fusion(instance, req_desc);
3856
3857 timeleft = wait_for_completion_timeout(&cmd_fusion->done, 50 * HZ);
3858
3859 if (!timeleft) {
3860 dev_err(&instance->pdev->dev,
3861 "task mgmt type 0x%x timed out\n", type);
3862 cmd_mfi->flags |= DRV_DCMD_SKIP_REFIRE;
3863 mutex_unlock(&instance->reset_mutex);
3864 rc = megasas_reset_fusion(instance->host, MFI_IO_TIMEOUT_OCR);
3865 mutex_lock(&instance->reset_mutex);
3866 return rc;
3867 }
3868
3869 mpi_reply = (struct MPI2_SCSI_TASK_MANAGE_REPLY *) &mr_request->TMReply;
3870 megasas_tm_response_code(instance, mpi_reply);
3871
3872 megasas_return_cmd(instance, cmd_mfi);
3873 rc = SUCCESS;
3874 switch (type) {
3875 case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
3876 scsi_lookup = fusion->cmd_list[smid_task - 1];
3877
3878 if (scsi_lookup->scmd == NULL)
3879 break;
3880 else {
3881 instance->instancet->disable_intr(instance);
3882 megasas_sync_irqs((unsigned long)instance);
3883 instance->instancet->enable_intr(instance);
3884 if (scsi_lookup->scmd == NULL)
3885 break;
3886 }
3887 rc = FAILED;
3888 break;
3889
3890 case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET:
3891 if ((channel == 0xFFFFFFFF) && (id == 0xFFFFFFFF))
3892 break;
3893 instance->instancet->disable_intr(instance);
3894 megasas_sync_irqs((unsigned long)instance);
3895 rc = megasas_track_scsiio(instance, id, channel);
3896 instance->instancet->enable_intr(instance);
3897
3898 break;
3899 case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET:
3900 case MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK:
3901 break;
3902 default:
3903 rc = FAILED;
3904 break;
3905 }
3906
3907 return rc;
3908
3909 }
3910
3911 /*
3912 * megasas_fusion_smid_lookup : Look for fusion command correpspodning to SCSI
3913 * @instance: per adapter struct
3914 *
3915 * Return Non Zero index, if SMID found in outstanding commands
3916 */
3917 static u16 megasas_fusion_smid_lookup(struct scsi_cmnd *scmd)
3918 {
3919 int i, ret = 0;
3920 struct megasas_instance *instance;
3921 struct megasas_cmd_fusion *cmd_fusion;
3922 struct fusion_context *fusion;
3923
3924 instance = (struct megasas_instance *)scmd->device->host->hostdata;
3925
3926 fusion = instance->ctrl_context;
3927
3928 for (i = 0; i < instance->max_scsi_cmds; i++) {
3929 cmd_fusion = fusion->cmd_list[i];
3930 if (cmd_fusion->scmd && (cmd_fusion->scmd == scmd)) {
3931 scmd_printk(KERN_NOTICE, scmd, "Abort request is for"
3932 " SMID: %d\n", cmd_fusion->index);
3933 ret = cmd_fusion->index;
3934 break;
3935 }
3936 }
3937
3938 return ret;
3939 }
3940
3941 /*
3942 * megasas_get_tm_devhandle - Get devhandle for TM request
3943 * @sdev- OS provided scsi device
3944 *
3945 * Returns- devhandle/targetID of SCSI device
3946 */
3947 static u16 megasas_get_tm_devhandle(struct scsi_device *sdev)
3948 {
3949 u16 pd_index = 0;
3950 u32 device_id;
3951 struct megasas_instance *instance;
3952 struct fusion_context *fusion;
3953 struct MR_PD_CFG_SEQ_NUM_SYNC *pd_sync;
3954 u16 devhandle = (u16)ULONG_MAX;
3955
3956 instance = (struct megasas_instance *)sdev->host->hostdata;
3957 fusion = instance->ctrl_context;
3958
3959 if (!MEGASAS_IS_LOGICAL(sdev)) {
3960 if (instance->use_seqnum_jbod_fp) {
3961 pd_index = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL)
3962 + sdev->id;
3963 pd_sync = (void *)fusion->pd_seq_sync
3964 [(instance->pd_seq_map_id - 1) & 1];
3965 devhandle = pd_sync->seq[pd_index].devHandle;
3966 } else
3967 sdev_printk(KERN_ERR, sdev, "Firmware expose tmCapable"
3968 " without JBOD MAP support from %s %d\n", __func__, __LINE__);
3969 } else {
3970 device_id = ((sdev->channel % 2) * MEGASAS_MAX_DEV_PER_CHANNEL)
3971 + sdev->id;
3972 devhandle = device_id;
3973 }
3974
3975 return devhandle;
3976 }
3977
3978 /*
3979 * megasas_task_abort_fusion : SCSI task abort function for fusion adapters
3980 * @scmd : pointer to scsi command object
3981 *
3982 * Return SUCCESS, if command aborted else FAILED
3983 */
3984
3985 int megasas_task_abort_fusion(struct scsi_cmnd *scmd)
3986 {
3987 struct megasas_instance *instance;
3988 u16 smid, devhandle;
3989 struct fusion_context *fusion;
3990 int ret;
3991 struct MR_PRIV_DEVICE *mr_device_priv_data;
3992 mr_device_priv_data = scmd->device->hostdata;
3993
3994
3995 instance = (struct megasas_instance *)scmd->device->host->hostdata;
3996 fusion = instance->ctrl_context;
3997
3998 scmd_printk(KERN_INFO, scmd, "task abort called for scmd(%p)\n", scmd);
3999 scsi_print_command(scmd);
4000
4001 if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
4002 dev_err(&instance->pdev->dev, "Controller is not OPERATIONAL,"
4003 "SCSI host:%d\n", instance->host->host_no);
4004 ret = FAILED;
4005 return ret;
4006 }
4007
4008 if (!mr_device_priv_data) {
4009 sdev_printk(KERN_INFO, scmd->device, "device been deleted! "
4010 "scmd(%p)\n", scmd);
4011 scmd->result = DID_NO_CONNECT << 16;
4012 ret = SUCCESS;
4013 goto out;
4014 }
4015
4016
4017 if (!mr_device_priv_data->is_tm_capable) {
4018 ret = FAILED;
4019 goto out;
4020 }
4021
4022 mutex_lock(&instance->reset_mutex);
4023
4024 smid = megasas_fusion_smid_lookup(scmd);
4025
4026 if (!smid) {
4027 ret = SUCCESS;
4028 scmd_printk(KERN_NOTICE, scmd, "Command for which abort is"
4029 " issued is not found in oustanding commands\n");
4030 mutex_unlock(&instance->reset_mutex);
4031 goto out;
4032 }
4033
4034 devhandle = megasas_get_tm_devhandle(scmd->device);
4035
4036 if (devhandle == (u16)ULONG_MAX) {
4037 ret = SUCCESS;
4038 sdev_printk(KERN_INFO, scmd->device,
4039 "task abort issued for invalid devhandle\n");
4040 mutex_unlock(&instance->reset_mutex);
4041 goto out;
4042 }
4043 sdev_printk(KERN_INFO, scmd->device,
4044 "attempting task abort! scmd(%p) tm_dev_handle 0x%x\n",
4045 scmd, devhandle);
4046
4047 mr_device_priv_data->tm_busy = 1;
4048 ret = megasas_issue_tm(instance, devhandle,
4049 scmd->device->channel, scmd->device->id, smid,
4050 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK);
4051 mr_device_priv_data->tm_busy = 0;
4052
4053 mutex_unlock(&instance->reset_mutex);
4054 out:
4055 sdev_printk(KERN_INFO, scmd->device, "task abort: %s scmd(%p)\n",
4056 ((ret == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
4057
4058 return ret;
4059 }
4060
4061 /*
4062 * megasas_reset_target_fusion : target reset function for fusion adapters
4063 * scmd: SCSI command pointer
4064 *
4065 * Returns SUCCESS if all commands associated with target aborted else FAILED
4066 */
4067
4068 int megasas_reset_target_fusion(struct scsi_cmnd *scmd)
4069 {
4070
4071 struct megasas_instance *instance;
4072 int ret = FAILED;
4073 u16 devhandle;
4074 struct fusion_context *fusion;
4075 struct MR_PRIV_DEVICE *mr_device_priv_data;
4076 mr_device_priv_data = scmd->device->hostdata;
4077
4078 instance = (struct megasas_instance *)scmd->device->host->hostdata;
4079 fusion = instance->ctrl_context;
4080
4081 sdev_printk(KERN_INFO, scmd->device,
4082 "target reset called for scmd(%p)\n", scmd);
4083
4084 if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
4085 dev_err(&instance->pdev->dev, "Controller is not OPERATIONAL,"
4086 "SCSI host:%d\n", instance->host->host_no);
4087 ret = FAILED;
4088 return ret;
4089 }
4090
4091 if (!mr_device_priv_data) {
4092 sdev_printk(KERN_INFO, scmd->device, "device been deleted! "
4093 "scmd(%p)\n", scmd);
4094 scmd->result = DID_NO_CONNECT << 16;
4095 ret = SUCCESS;
4096 goto out;
4097 }
4098
4099
4100 if (!mr_device_priv_data->is_tm_capable) {
4101 ret = FAILED;
4102 goto out;
4103 }
4104
4105 mutex_lock(&instance->reset_mutex);
4106 devhandle = megasas_get_tm_devhandle(scmd->device);
4107
4108 if (devhandle == (u16)ULONG_MAX) {
4109 ret = SUCCESS;
4110 sdev_printk(KERN_INFO, scmd->device,
4111 "target reset issued for invalid devhandle\n");
4112 mutex_unlock(&instance->reset_mutex);
4113 goto out;
4114 }
4115
4116 sdev_printk(KERN_INFO, scmd->device,
4117 "attempting target reset! scmd(%p) tm_dev_handle 0x%x\n",
4118 scmd, devhandle);
4119 mr_device_priv_data->tm_busy = 1;
4120 ret = megasas_issue_tm(instance, devhandle,
4121 scmd->device->channel, scmd->device->id, 0,
4122 MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET);
4123 mr_device_priv_data->tm_busy = 0;
4124 mutex_unlock(&instance->reset_mutex);
4125 out:
4126 scmd_printk(KERN_NOTICE, scmd, "megasas: target reset %s!!\n",
4127 (ret == SUCCESS) ? "SUCCESS" : "FAILED");
4128
4129 return ret;
4130 }
4131
4132 /*SRIOV get other instance in cluster if any*/
4133 struct megasas_instance *megasas_get_peer_instance(struct megasas_instance *instance)
4134 {
4135 int i;
4136
4137 for (i = 0; i < MAX_MGMT_ADAPTERS; i++) {
4138 if (megasas_mgmt_info.instance[i] &&
4139 (megasas_mgmt_info.instance[i] != instance) &&
4140 megasas_mgmt_info.instance[i]->requestorId &&
4141 megasas_mgmt_info.instance[i]->peerIsPresent &&
4142 (memcmp((megasas_mgmt_info.instance[i]->clusterId),
4143 instance->clusterId, MEGASAS_CLUSTER_ID_SIZE) == 0))
4144 return megasas_mgmt_info.instance[i];
4145 }
4146 return NULL;
4147 }
4148
4149 /* Check for a second path that is currently UP */
4150 int megasas_check_mpio_paths(struct megasas_instance *instance,
4151 struct scsi_cmnd *scmd)
4152 {
4153 struct megasas_instance *peer_instance = NULL;
4154 int retval = (DID_REQUEUE << 16);
4155
4156 if (instance->peerIsPresent) {
4157 peer_instance = megasas_get_peer_instance(instance);
4158 if ((peer_instance) &&
4159 (atomic_read(&peer_instance->adprecovery) ==
4160 MEGASAS_HBA_OPERATIONAL))
4161 retval = (DID_NO_CONNECT << 16);
4162 }
4163 return retval;
4164 }
4165
4166 /* Core fusion reset function */
4167 int megasas_reset_fusion(struct Scsi_Host *shost, int reason)
4168 {
4169 int retval = SUCCESS, i, j, convert = 0;
4170 struct megasas_instance *instance;
4171 struct megasas_cmd_fusion *cmd_fusion, *r1_cmd;
4172 struct fusion_context *fusion;
4173 u32 abs_state, status_reg, reset_adapter;
4174 u32 io_timeout_in_crash_mode = 0;
4175 struct scsi_cmnd *scmd_local = NULL;
4176 struct scsi_device *sdev;
4177
4178 instance = (struct megasas_instance *)shost->hostdata;
4179 fusion = instance->ctrl_context;
4180
4181 mutex_lock(&instance->reset_mutex);
4182
4183 if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
4184 dev_warn(&instance->pdev->dev, "Hardware critical error, "
4185 "returning FAILED for scsi%d.\n",
4186 instance->host->host_no);
4187 mutex_unlock(&instance->reset_mutex);
4188 return FAILED;
4189 }
4190 status_reg = instance->instancet->read_fw_status_reg(instance->reg_set);
4191 abs_state = status_reg & MFI_STATE_MASK;
4192
4193 /* IO timeout detected, forcibly put FW in FAULT state */
4194 if (abs_state != MFI_STATE_FAULT && instance->crash_dump_buf &&
4195 instance->crash_dump_app_support && reason) {
4196 dev_info(&instance->pdev->dev, "IO/DCMD timeout is detected, "
4197 "forcibly FAULT Firmware\n");
4198 atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
4199 status_reg = readl(&instance->reg_set->doorbell);
4200 writel(status_reg | MFI_STATE_FORCE_OCR,
4201 &instance->reg_set->doorbell);
4202 readl(&instance->reg_set->doorbell);
4203 mutex_unlock(&instance->reset_mutex);
4204 do {
4205 ssleep(3);
4206 io_timeout_in_crash_mode++;
4207 dev_dbg(&instance->pdev->dev, "waiting for [%d] "
4208 "seconds for crash dump collection and OCR "
4209 "to be done\n", (io_timeout_in_crash_mode * 3));
4210 } while ((atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) &&
4211 (io_timeout_in_crash_mode < 80));
4212
4213 if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL) {
4214 dev_info(&instance->pdev->dev, "OCR done for IO "
4215 "timeout case\n");
4216 retval = SUCCESS;
4217 } else {
4218 dev_info(&instance->pdev->dev, "Controller is not "
4219 "operational after 240 seconds wait for IO "
4220 "timeout case in FW crash dump mode\n do "
4221 "OCR/kill adapter\n");
4222 retval = megasas_reset_fusion(shost, 0);
4223 }
4224 return retval;
4225 }
4226
4227 if (instance->requestorId && !instance->skip_heartbeat_timer_del)
4228 del_timer_sync(&instance->sriov_heartbeat_timer);
4229 set_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
4230 atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_POLLING);
4231 instance->instancet->disable_intr(instance);
4232 megasas_sync_irqs((unsigned long)instance);
4233
4234 /* First try waiting for commands to complete */
4235 if (megasas_wait_for_outstanding_fusion(instance, reason,
4236 &convert)) {
4237 atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
4238 dev_warn(&instance->pdev->dev, "resetting fusion "
4239 "adapter scsi%d.\n", instance->host->host_no);
4240 if (convert)
4241 reason = 0;
4242
4243 if (megasas_dbg_lvl & OCR_LOGS)
4244 dev_info(&instance->pdev->dev, "\nPending SCSI commands:\n");
4245
4246 /* Now return commands back to the OS */
4247 for (i = 0 ; i < instance->max_scsi_cmds; i++) {
4248 cmd_fusion = fusion->cmd_list[i];
4249 /*check for extra commands issued by driver*/
4250 if (instance->is_ventura) {
4251 r1_cmd = fusion->cmd_list[i + instance->max_fw_cmds];
4252 megasas_return_cmd_fusion(instance, r1_cmd);
4253 }
4254 scmd_local = cmd_fusion->scmd;
4255 if (cmd_fusion->scmd) {
4256 if (megasas_dbg_lvl & OCR_LOGS) {
4257 sdev_printk(KERN_INFO,
4258 cmd_fusion->scmd->device, "SMID: 0x%x\n",
4259 cmd_fusion->index);
4260 scsi_print_command(cmd_fusion->scmd);
4261 }
4262
4263 scmd_local->result =
4264 megasas_check_mpio_paths(instance,
4265 scmd_local);
4266 if (instance->ldio_threshold &&
4267 megasas_cmd_type(scmd_local) == READ_WRITE_LDIO)
4268 atomic_dec(&instance->ldio_outstanding);
4269 megasas_return_cmd_fusion(instance, cmd_fusion);
4270 scsi_dma_unmap(scmd_local);
4271 scmd_local->scsi_done(scmd_local);
4272 }
4273 }
4274
4275 atomic_set(&instance->fw_outstanding, 0);
4276
4277 status_reg = instance->instancet->read_fw_status_reg(
4278 instance->reg_set);
4279 abs_state = status_reg & MFI_STATE_MASK;
4280 reset_adapter = status_reg & MFI_RESET_ADAPTER;
4281 if (instance->disableOnlineCtrlReset ||
4282 (abs_state == MFI_STATE_FAULT && !reset_adapter)) {
4283 /* Reset not supported, kill adapter */
4284 dev_warn(&instance->pdev->dev, "Reset not supported"
4285 ", killing adapter scsi%d.\n",
4286 instance->host->host_no);
4287 megaraid_sas_kill_hba(instance);
4288 instance->skip_heartbeat_timer_del = 1;
4289 retval = FAILED;
4290 goto out;
4291 }
4292
4293 /* Let SR-IOV VF & PF sync up if there was a HB failure */
4294 if (instance->requestorId && !reason) {
4295 msleep(MEGASAS_OCR_SETTLE_TIME_VF);
4296 goto transition_to_ready;
4297 }
4298
4299 /* Now try to reset the chip */
4300 for (i = 0; i < MEGASAS_FUSION_MAX_RESET_TRIES; i++) {
4301
4302 if (instance->instancet->adp_reset
4303 (instance, instance->reg_set))
4304 continue;
4305 transition_to_ready:
4306 /* Wait for FW to become ready */
4307 if (megasas_transition_to_ready(instance, 1)) {
4308 dev_warn(&instance->pdev->dev,
4309 "Failed to transition controller to ready for "
4310 "scsi%d.\n", instance->host->host_no);
4311 if (instance->requestorId && !reason)
4312 goto fail_kill_adapter;
4313 else
4314 continue;
4315 }
4316 megasas_reset_reply_desc(instance);
4317 megasas_fusion_update_can_queue(instance, OCR_CONTEXT);
4318
4319 if (megasas_ioc_init_fusion(instance)) {
4320 if (instance->requestorId && !reason)
4321 goto fail_kill_adapter;
4322 else
4323 continue;
4324 }
4325
4326 megasas_refire_mgmt_cmd(instance);
4327
4328 if (megasas_get_ctrl_info(instance)) {
4329 dev_info(&instance->pdev->dev,
4330 "Failed from %s %d\n",
4331 __func__, __LINE__);
4332 megaraid_sas_kill_hba(instance);
4333 retval = FAILED;
4334 goto out;
4335 }
4336 /* Reset load balance info */
4337 if (fusion->load_balance_info)
4338 memset(fusion->load_balance_info, 0,
4339 (sizeof(struct LD_LOAD_BALANCE_INFO) *
4340 MAX_LOGICAL_DRIVES_EXT));
4341
4342 if (!megasas_get_map_info(instance))
4343 megasas_sync_map_info(instance);
4344
4345 megasas_setup_jbod_map(instance);
4346
4347 shost_for_each_device(sdev, shost)
4348 megasas_set_dynamic_target_properties(sdev);
4349
4350 /* reset stream detection array */
4351 if (instance->is_ventura) {
4352 for (j = 0; j < MAX_LOGICAL_DRIVES_EXT; ++j) {
4353 memset(fusion->stream_detect_by_ld[j],
4354 0, sizeof(struct LD_STREAM_DETECT));
4355 fusion->stream_detect_by_ld[j]->mru_bit_map
4356 = MR_STREAM_BITMAP;
4357 }
4358 }
4359
4360 clear_bit(MEGASAS_FUSION_IN_RESET,
4361 &instance->reset_flags);
4362 instance->instancet->enable_intr(instance);
4363 atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
4364
4365 dev_info(&instance->pdev->dev, "Interrupts are enabled and"
4366 " controller is OPERATIONAL for scsi:%d\n",
4367 instance->host->host_no);
4368
4369 /* Restart SR-IOV heartbeat */
4370 if (instance->requestorId) {
4371 if (!megasas_sriov_start_heartbeat(instance, 0))
4372 megasas_start_timer(instance,
4373 &instance->sriov_heartbeat_timer,
4374 megasas_sriov_heartbeat_handler,
4375 MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF);
4376 else
4377 instance->skip_heartbeat_timer_del = 1;
4378 }
4379
4380 if (instance->crash_dump_drv_support &&
4381 instance->crash_dump_app_support)
4382 megasas_set_crash_dump_params(instance,
4383 MR_CRASH_BUF_TURN_ON);
4384 else
4385 megasas_set_crash_dump_params(instance,
4386 MR_CRASH_BUF_TURN_OFF);
4387
4388 retval = SUCCESS;
4389
4390 /* Adapter reset completed successfully */
4391 dev_warn(&instance->pdev->dev,
4392 "Reset successful for scsi%d.\n",
4393 instance->host->host_no);
4394
4395 goto out;
4396 }
4397 fail_kill_adapter:
4398 /* Reset failed, kill the adapter */
4399 dev_warn(&instance->pdev->dev, "Reset failed, killing "
4400 "adapter scsi%d.\n", instance->host->host_no);
4401 megaraid_sas_kill_hba(instance);
4402 instance->skip_heartbeat_timer_del = 1;
4403 retval = FAILED;
4404 } else {
4405 /* For VF: Restart HB timer if we didn't OCR */
4406 if (instance->requestorId) {
4407 megasas_start_timer(instance,
4408 &instance->sriov_heartbeat_timer,
4409 megasas_sriov_heartbeat_handler,
4410 MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF);
4411 }
4412 clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
4413 instance->instancet->enable_intr(instance);
4414 atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
4415 }
4416 out:
4417 clear_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
4418 mutex_unlock(&instance->reset_mutex);
4419 return retval;
4420 }
4421
4422 /* Fusion Crash dump collection work queue */
4423 void megasas_fusion_crash_dump_wq(struct work_struct *work)
4424 {
4425 struct megasas_instance *instance =
4426 container_of(work, struct megasas_instance, crash_init);
4427 u32 status_reg;
4428 u8 partial_copy = 0;
4429
4430
4431 status_reg = instance->instancet->read_fw_status_reg(instance->reg_set);
4432
4433 /*
4434 * Allocate host crash buffers to copy data from 1 MB DMA crash buffer
4435 * to host crash buffers
4436 */
4437 if (instance->drv_buf_index == 0) {
4438 /* Buffer is already allocated for old Crash dump.
4439 * Do OCR and do not wait for crash dump collection
4440 */
4441 if (instance->drv_buf_alloc) {
4442 dev_info(&instance->pdev->dev, "earlier crash dump is "
4443 "not yet copied by application, ignoring this "
4444 "crash dump and initiating OCR\n");
4445 status_reg |= MFI_STATE_CRASH_DUMP_DONE;
4446 writel(status_reg,
4447 &instance->reg_set->outbound_scratch_pad);
4448 readl(&instance->reg_set->outbound_scratch_pad);
4449 return;
4450 }
4451 megasas_alloc_host_crash_buffer(instance);
4452 dev_info(&instance->pdev->dev, "Number of host crash buffers "
4453 "allocated: %d\n", instance->drv_buf_alloc);
4454 }
4455
4456 /*
4457 * Driver has allocated max buffers, which can be allocated
4458 * and FW has more crash dump data, then driver will
4459 * ignore the data.
4460 */
4461 if (instance->drv_buf_index >= (instance->drv_buf_alloc)) {
4462 dev_info(&instance->pdev->dev, "Driver is done copying "
4463 "the buffer: %d\n", instance->drv_buf_alloc);
4464 status_reg |= MFI_STATE_CRASH_DUMP_DONE;
4465 partial_copy = 1;
4466 } else {
4467 memcpy(instance->crash_buf[instance->drv_buf_index],
4468 instance->crash_dump_buf, CRASH_DMA_BUF_SIZE);
4469 instance->drv_buf_index++;
4470 status_reg &= ~MFI_STATE_DMADONE;
4471 }
4472
4473 if (status_reg & MFI_STATE_CRASH_DUMP_DONE) {
4474 dev_info(&instance->pdev->dev, "Crash Dump is available,number "
4475 "of copied buffers: %d\n", instance->drv_buf_index);
4476 instance->fw_crash_buffer_size = instance->drv_buf_index;
4477 instance->fw_crash_state = AVAILABLE;
4478 instance->drv_buf_index = 0;
4479 writel(status_reg, &instance->reg_set->outbound_scratch_pad);
4480 readl(&instance->reg_set->outbound_scratch_pad);
4481 if (!partial_copy)
4482 megasas_reset_fusion(instance->host, 0);
4483 } else {
4484 writel(status_reg, &instance->reg_set->outbound_scratch_pad);
4485 readl(&instance->reg_set->outbound_scratch_pad);
4486 }
4487 }
4488
4489
4490 /* Fusion OCR work queue */
4491 void megasas_fusion_ocr_wq(struct work_struct *work)
4492 {
4493 struct megasas_instance *instance =
4494 container_of(work, struct megasas_instance, work_init);
4495
4496 megasas_reset_fusion(instance->host, 0);
4497 }
4498
4499 /* Allocate fusion context */
4500 int
4501 megasas_alloc_fusion_context(struct megasas_instance *instance)
4502 {
4503 struct fusion_context *fusion;
4504
4505 instance->ctrl_context_pages = get_order(sizeof(struct fusion_context));
4506 instance->ctrl_context = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
4507 instance->ctrl_context_pages);
4508 if (!instance->ctrl_context) {
4509 /* fall back to using vmalloc for fusion_context */
4510 instance->ctrl_context = vzalloc(sizeof(struct fusion_context));
4511 if (!instance->ctrl_context) {
4512 dev_err(&instance->pdev->dev, "Failed from %s %d\n", __func__, __LINE__);
4513 return -ENOMEM;
4514 }
4515 }
4516
4517 fusion = instance->ctrl_context;
4518
4519 fusion->load_balance_info_pages = get_order(MAX_LOGICAL_DRIVES_EXT *
4520 sizeof(struct LD_LOAD_BALANCE_INFO));
4521 fusion->load_balance_info =
4522 (struct LD_LOAD_BALANCE_INFO *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
4523 fusion->load_balance_info_pages);
4524 if (!fusion->load_balance_info) {
4525 fusion->load_balance_info = vzalloc(MAX_LOGICAL_DRIVES_EXT *
4526 sizeof(struct LD_LOAD_BALANCE_INFO));
4527 if (!fusion->load_balance_info)
4528 dev_err(&instance->pdev->dev, "Failed to allocate load_balance_info, "
4529 "continuing without Load Balance support\n");
4530 }
4531
4532 return 0;
4533 }
4534
4535 void
4536 megasas_free_fusion_context(struct megasas_instance *instance)
4537 {
4538 struct fusion_context *fusion = instance->ctrl_context;
4539
4540 if (fusion) {
4541 if (fusion->load_balance_info) {
4542 if (is_vmalloc_addr(fusion->load_balance_info))
4543 vfree(fusion->load_balance_info);
4544 else
4545 free_pages((ulong)fusion->load_balance_info,
4546 fusion->load_balance_info_pages);
4547 }
4548
4549 if (is_vmalloc_addr(fusion))
4550 vfree(fusion);
4551 else
4552 free_pages((ulong)fusion,
4553 instance->ctrl_context_pages);
4554 }
4555 }
4556
4557 struct megasas_instance_template megasas_instance_template_fusion = {
4558 .enable_intr = megasas_enable_intr_fusion,
4559 .disable_intr = megasas_disable_intr_fusion,
4560 .clear_intr = megasas_clear_intr_fusion,
4561 .read_fw_status_reg = megasas_read_fw_status_reg_fusion,
4562 .adp_reset = megasas_adp_reset_fusion,
4563 .check_reset = megasas_check_reset_fusion,
4564 .service_isr = megasas_isr_fusion,
4565 .tasklet = megasas_complete_cmd_dpc_fusion,
4566 .init_adapter = megasas_init_adapter_fusion,
4567 .build_and_issue_cmd = megasas_build_and_issue_cmd_fusion,
4568 .issue_dcmd = megasas_issue_dcmd_fusion,
4569 };
ubuntu-bionic-kernel mirror