]> 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:


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