1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * QLogic qlcnic NIC Driver
4  * Copyright (c) 2009-2013 QLogic Corporation
5  */
6 
7 #include <net/ip.h>
8 
9 #include "qlcnic.h"
10 #include "qlcnic_hdr.h"
11 #include "qlcnic_83xx_hw.h"
12 #include "qlcnic_hw.h"
13 
14 #define QLC_83XX_MINIDUMP_FLASH		0x520000
15 #define QLC_83XX_OCM_INDEX			3
16 #define QLC_83XX_PCI_INDEX			0
17 #define QLC_83XX_DMA_ENGINE_INDEX		8
18 
19 static const u32 qlcnic_ms_read_data[] = {
20 	0x410000A8, 0x410000AC, 0x410000B8, 0x410000BC
21 };
22 
23 #define QLCNIC_DUMP_WCRB	BIT_0
24 #define QLCNIC_DUMP_RWCRB	BIT_1
25 #define QLCNIC_DUMP_ANDCRB	BIT_2
26 #define QLCNIC_DUMP_ORCRB	BIT_3
27 #define QLCNIC_DUMP_POLLCRB	BIT_4
28 #define QLCNIC_DUMP_RD_SAVE	BIT_5
29 #define QLCNIC_DUMP_WRT_SAVED	BIT_6
30 #define QLCNIC_DUMP_MOD_SAVE_ST	BIT_7
31 #define QLCNIC_DUMP_SKIP	BIT_7
32 
33 #define QLCNIC_DUMP_MASK_MAX	0xff
34 
35 struct qlcnic_pex_dma_descriptor {
36 	u32	read_data_size;
37 	u32	dma_desc_cmd;
38 	u32	src_addr_low;
39 	u32	src_addr_high;
40 	u32	dma_bus_addr_low;
41 	u32	dma_bus_addr_high;
42 	u32	rsvd[6];
43 } __packed;
44 
45 struct qlcnic_common_entry_hdr {
46 	u32     type;
47 	u32     offset;
48 	u32     cap_size;
49 #if defined(__LITTLE_ENDIAN)
50 	u8      mask;
51 	u8      rsvd[2];
52 	u8      flags;
53 #else
54 	u8      flags;
55 	u8      rsvd[2];
56 	u8      mask;
57 #endif
58 } __packed;
59 
60 struct __crb {
61 	u32	addr;
62 #if defined(__LITTLE_ENDIAN)
63 	u8	stride;
64 	u8	rsvd1[3];
65 #else
66 	u8	rsvd1[3];
67 	u8	stride;
68 #endif
69 	u32	data_size;
70 	u32	no_ops;
71 	u32	rsvd2[4];
72 } __packed;
73 
74 struct __ctrl {
75 	u32	addr;
76 #if defined(__LITTLE_ENDIAN)
77 	u8	stride;
78 	u8	index_a;
79 	u16	timeout;
80 #else
81 	u16	timeout;
82 	u8	index_a;
83 	u8	stride;
84 #endif
85 	u32	data_size;
86 	u32	no_ops;
87 #if defined(__LITTLE_ENDIAN)
88 	u8	opcode;
89 	u8	index_v;
90 	u8	shl_val;
91 	u8	shr_val;
92 #else
93 	u8	shr_val;
94 	u8	shl_val;
95 	u8	index_v;
96 	u8	opcode;
97 #endif
98 	u32	val1;
99 	u32	val2;
100 	u32	val3;
101 } __packed;
102 
103 struct __cache {
104 	u32	addr;
105 #if defined(__LITTLE_ENDIAN)
106 	u16	stride;
107 	u16	init_tag_val;
108 #else
109 	u16	init_tag_val;
110 	u16	stride;
111 #endif
112 	u32	size;
113 	u32	no_ops;
114 	u32	ctrl_addr;
115 	u32	ctrl_val;
116 	u32	read_addr;
117 #if defined(__LITTLE_ENDIAN)
118 	u8	read_addr_stride;
119 	u8	read_addr_num;
120 	u8	rsvd1[2];
121 #else
122 	u8	rsvd1[2];
123 	u8	read_addr_num;
124 	u8	read_addr_stride;
125 #endif
126 } __packed;
127 
128 struct __ocm {
129 	u8	rsvd[8];
130 	u32	size;
131 	u32	no_ops;
132 	u8	rsvd1[8];
133 	u32	read_addr;
134 	u32	read_addr_stride;
135 } __packed;
136 
137 struct __mem {
138 	u32	desc_card_addr;
139 	u32	dma_desc_cmd;
140 	u32	start_dma_cmd;
141 	u32	rsvd[3];
142 	u32	addr;
143 	u32	size;
144 } __packed;
145 
146 struct __mux {
147 	u32	addr;
148 	u8	rsvd[4];
149 	u32	size;
150 	u32	no_ops;
151 	u32	val;
152 	u32	val_stride;
153 	u32	read_addr;
154 	u8	rsvd2[4];
155 } __packed;
156 
157 struct __queue {
158 	u32	sel_addr;
159 #if defined(__LITTLE_ENDIAN)
160 	u16	stride;
161 	u8	rsvd[2];
162 #else
163 	u8	rsvd[2];
164 	u16	stride;
165 #endif
166 	u32	size;
167 	u32	no_ops;
168 	u8	rsvd2[8];
169 	u32	read_addr;
170 #if defined(__LITTLE_ENDIAN)
171 	u8	read_addr_stride;
172 	u8	read_addr_cnt;
173 	u8	rsvd3[2];
174 #else
175 	u8	rsvd3[2];
176 	u8	read_addr_cnt;
177 	u8	read_addr_stride;
178 #endif
179 } __packed;
180 
181 struct __pollrd {
182 	u32	sel_addr;
183 	u32	read_addr;
184 	u32	sel_val;
185 #if defined(__LITTLE_ENDIAN)
186 	u16	sel_val_stride;
187 	u16	no_ops;
188 #else
189 	u16	no_ops;
190 	u16	sel_val_stride;
191 #endif
192 	u32	poll_wait;
193 	u32	poll_mask;
194 	u32	data_size;
195 	u8	rsvd[4];
196 } __packed;
197 
198 struct __mux2 {
199 	u32	sel_addr1;
200 	u32	sel_addr2;
201 	u32	sel_val1;
202 	u32	sel_val2;
203 	u32	no_ops;
204 	u32	sel_val_mask;
205 	u32	read_addr;
206 #if defined(__LITTLE_ENDIAN)
207 	u8	sel_val_stride;
208 	u8	data_size;
209 	u8	rsvd[2];
210 #else
211 	u8	rsvd[2];
212 	u8	data_size;
213 	u8	sel_val_stride;
214 #endif
215 } __packed;
216 
217 struct __pollrdmwr {
218 	u32	addr1;
219 	u32	addr2;
220 	u32	val1;
221 	u32	val2;
222 	u32	poll_wait;
223 	u32	poll_mask;
224 	u32	mod_mask;
225 	u32	data_size;
226 } __packed;
227 
228 struct qlcnic_dump_entry {
229 	struct qlcnic_common_entry_hdr hdr;
230 	union {
231 		struct __crb		crb;
232 		struct __cache		cache;
233 		struct __ocm		ocm;
234 		struct __mem		mem;
235 		struct __mux		mux;
236 		struct __queue		que;
237 		struct __ctrl		ctrl;
238 		struct __pollrdmwr	pollrdmwr;
239 		struct __mux2		mux2;
240 		struct __pollrd		pollrd;
241 	} region;
242 } __packed;
243 
244 enum qlcnic_minidump_opcode {
245 	QLCNIC_DUMP_NOP		= 0,
246 	QLCNIC_DUMP_READ_CRB	= 1,
247 	QLCNIC_DUMP_READ_MUX	= 2,
248 	QLCNIC_DUMP_QUEUE	= 3,
249 	QLCNIC_DUMP_BRD_CONFIG	= 4,
250 	QLCNIC_DUMP_READ_OCM	= 6,
251 	QLCNIC_DUMP_PEG_REG	= 7,
252 	QLCNIC_DUMP_L1_DTAG	= 8,
253 	QLCNIC_DUMP_L1_ITAG	= 9,
254 	QLCNIC_DUMP_L1_DATA	= 11,
255 	QLCNIC_DUMP_L1_INST	= 12,
256 	QLCNIC_DUMP_L2_DTAG	= 21,
257 	QLCNIC_DUMP_L2_ITAG	= 22,
258 	QLCNIC_DUMP_L2_DATA	= 23,
259 	QLCNIC_DUMP_L2_INST	= 24,
260 	QLCNIC_DUMP_POLL_RD	= 35,
261 	QLCNIC_READ_MUX2	= 36,
262 	QLCNIC_READ_POLLRDMWR	= 37,
263 	QLCNIC_DUMP_READ_ROM	= 71,
264 	QLCNIC_DUMP_READ_MEM	= 72,
265 	QLCNIC_DUMP_READ_CTRL	= 98,
266 	QLCNIC_DUMP_TLHDR	= 99,
267 	QLCNIC_DUMP_RDEND	= 255
268 };
269 
270 inline u32 qlcnic_82xx_get_saved_state(void *t_hdr, u32 index)
271 {
272 	struct qlcnic_82xx_dump_template_hdr *hdr = t_hdr;
273 
274 	return hdr->saved_state[index];
275 }
276 
277 inline void qlcnic_82xx_set_saved_state(void *t_hdr, u32 index,
278 					u32 value)
279 {
280 	struct qlcnic_82xx_dump_template_hdr *hdr = t_hdr;
281 
282 	hdr->saved_state[index] = value;
283 }
284 
285 void qlcnic_82xx_cache_tmpl_hdr_values(struct qlcnic_fw_dump *fw_dump)
286 {
287 	struct qlcnic_82xx_dump_template_hdr *hdr;
288 
289 	hdr = fw_dump->tmpl_hdr;
290 	fw_dump->tmpl_hdr_size = hdr->size;
291 	fw_dump->version = hdr->version;
292 	fw_dump->num_entries = hdr->num_entries;
293 	fw_dump->offset = hdr->offset;
294 
295 	hdr->drv_cap_mask = hdr->cap_mask;
296 	fw_dump->cap_mask = hdr->cap_mask;
297 
298 	fw_dump->use_pex_dma = (hdr->capabilities & BIT_0) ? true : false;
299 }
300 
301 inline u32 qlcnic_82xx_get_cap_size(void *t_hdr, int index)
302 {
303 	struct qlcnic_82xx_dump_template_hdr *hdr = t_hdr;
304 
305 	return hdr->cap_sizes[index];
306 }
307 
308 void qlcnic_82xx_set_sys_info(void *t_hdr, int idx, u32 value)
309 {
310 	struct qlcnic_82xx_dump_template_hdr *hdr = t_hdr;
311 
312 	hdr->sys_info[idx] = value;
313 }
314 
315 void qlcnic_82xx_store_cap_mask(void *tmpl_hdr, u32 mask)
316 {
317 	struct qlcnic_82xx_dump_template_hdr *hdr = tmpl_hdr;
318 
319 	hdr->drv_cap_mask = mask;
320 }
321 
322 inline u32 qlcnic_83xx_get_saved_state(void *t_hdr, u32 index)
323 {
324 	struct qlcnic_83xx_dump_template_hdr *hdr = t_hdr;
325 
326 	return hdr->saved_state[index];
327 }
328 
329 inline void qlcnic_83xx_set_saved_state(void *t_hdr, u32 index,
330 					u32 value)
331 {
332 	struct qlcnic_83xx_dump_template_hdr *hdr = t_hdr;
333 
334 	hdr->saved_state[index] = value;
335 }
336 
337 #define QLCNIC_TEMPLATE_VERSION (0x20001)
338 
339 void qlcnic_83xx_cache_tmpl_hdr_values(struct qlcnic_fw_dump *fw_dump)
340 {
341 	struct qlcnic_83xx_dump_template_hdr *hdr;
342 
343 	hdr = fw_dump->tmpl_hdr;
344 	fw_dump->tmpl_hdr_size = hdr->size;
345 	fw_dump->version = hdr->version;
346 	fw_dump->num_entries = hdr->num_entries;
347 	fw_dump->offset = hdr->offset;
348 
349 	hdr->drv_cap_mask = hdr->cap_mask;
350 	fw_dump->cap_mask = hdr->cap_mask;
351 
352 	fw_dump->use_pex_dma = (fw_dump->version & 0xfffff) >=
353 			       QLCNIC_TEMPLATE_VERSION;
354 }
355 
356 inline u32 qlcnic_83xx_get_cap_size(void *t_hdr, int index)
357 {
358 	struct qlcnic_83xx_dump_template_hdr *hdr = t_hdr;
359 
360 	return hdr->cap_sizes[index];
361 }
362 
363 void qlcnic_83xx_set_sys_info(void *t_hdr, int idx, u32 value)
364 {
365 	struct qlcnic_83xx_dump_template_hdr *hdr = t_hdr;
366 
367 	hdr->sys_info[idx] = value;
368 }
369 
370 void qlcnic_83xx_store_cap_mask(void *tmpl_hdr, u32 mask)
371 {
372 	struct qlcnic_83xx_dump_template_hdr *hdr;
373 
374 	hdr = tmpl_hdr;
375 	hdr->drv_cap_mask = mask;
376 }
377 
378 struct qlcnic_dump_operations {
379 	enum qlcnic_minidump_opcode opcode;
380 	u32 (*handler)(struct qlcnic_adapter *, struct qlcnic_dump_entry *,
381 		       __le32 *);
382 };
383 
384 static u32 qlcnic_dump_crb(struct qlcnic_adapter *adapter,
385 			   struct qlcnic_dump_entry *entry, __le32 *buffer)
386 {
387 	int i;
388 	u32 addr, data;
389 	struct __crb *crb = &entry->region.crb;
390 
391 	addr = crb->addr;
392 
393 	for (i = 0; i < crb->no_ops; i++) {
394 		data = qlcnic_ind_rd(adapter, addr);
395 		*buffer++ = cpu_to_le32(addr);
396 		*buffer++ = cpu_to_le32(data);
397 		addr += crb->stride;
398 	}
399 	return crb->no_ops * 2 * sizeof(u32);
400 }
401 
402 static u32 qlcnic_dump_ctrl(struct qlcnic_adapter *adapter,
403 			    struct qlcnic_dump_entry *entry, __le32 *buffer)
404 {
405 	void *hdr = adapter->ahw->fw_dump.tmpl_hdr;
406 	struct __ctrl *ctr = &entry->region.ctrl;
407 	int i, k, timeout = 0;
408 	u32 addr, data, temp;
409 	u8 no_ops;
410 
411 	addr = ctr->addr;
412 	no_ops = ctr->no_ops;
413 
414 	for (i = 0; i < no_ops; i++) {
415 		k = 0;
416 		for (k = 0; k < 8; k++) {
417 			if (!(ctr->opcode & (1 << k)))
418 				continue;
419 			switch (1 << k) {
420 			case QLCNIC_DUMP_WCRB:
421 				qlcnic_ind_wr(adapter, addr, ctr->val1);
422 				break;
423 			case QLCNIC_DUMP_RWCRB:
424 				data = qlcnic_ind_rd(adapter, addr);
425 				qlcnic_ind_wr(adapter, addr, data);
426 				break;
427 			case QLCNIC_DUMP_ANDCRB:
428 				data = qlcnic_ind_rd(adapter, addr);
429 				qlcnic_ind_wr(adapter, addr,
430 					      (data & ctr->val2));
431 				break;
432 			case QLCNIC_DUMP_ORCRB:
433 				data = qlcnic_ind_rd(adapter, addr);
434 				qlcnic_ind_wr(adapter, addr,
435 					      (data | ctr->val3));
436 				break;
437 			case QLCNIC_DUMP_POLLCRB:
438 				while (timeout <= ctr->timeout) {
439 					data = qlcnic_ind_rd(adapter, addr);
440 					if ((data & ctr->val2) == ctr->val1)
441 						break;
442 					usleep_range(1000, 2000);
443 					timeout++;
444 				}
445 				if (timeout > ctr->timeout) {
446 					dev_info(&adapter->pdev->dev,
447 					"Timed out, aborting poll CRB\n");
448 					return -EINVAL;
449 				}
450 				break;
451 			case QLCNIC_DUMP_RD_SAVE:
452 				temp = ctr->index_a;
453 				if (temp)
454 					addr = qlcnic_get_saved_state(adapter,
455 								      hdr,
456 								      temp);
457 				data = qlcnic_ind_rd(adapter, addr);
458 				qlcnic_set_saved_state(adapter, hdr,
459 						       ctr->index_v, data);
460 				break;
461 			case QLCNIC_DUMP_WRT_SAVED:
462 				temp = ctr->index_v;
463 				if (temp)
464 					data = qlcnic_get_saved_state(adapter,
465 								      hdr,
466 								      temp);
467 				else
468 					data = ctr->val1;
469 
470 				temp = ctr->index_a;
471 				if (temp)
472 					addr = qlcnic_get_saved_state(adapter,
473 								      hdr,
474 								      temp);
475 				qlcnic_ind_wr(adapter, addr, data);
476 				break;
477 			case QLCNIC_DUMP_MOD_SAVE_ST:
478 				data = qlcnic_get_saved_state(adapter, hdr,
479 							      ctr->index_v);
480 				data <<= ctr->shl_val;
481 				data >>= ctr->shr_val;
482 				if (ctr->val2)
483 					data &= ctr->val2;
484 				data |= ctr->val3;
485 				data += ctr->val1;
486 				qlcnic_set_saved_state(adapter, hdr,
487 						       ctr->index_v, data);
488 				break;
489 			default:
490 				dev_info(&adapter->pdev->dev,
491 					 "Unknown opcode\n");
492 				break;
493 			}
494 		}
495 		addr += ctr->stride;
496 	}
497 	return 0;
498 }
499 
500 static u32 qlcnic_dump_mux(struct qlcnic_adapter *adapter,
501 			   struct qlcnic_dump_entry *entry, __le32 *buffer)
502 {
503 	int loop;
504 	u32 val, data = 0;
505 	struct __mux *mux = &entry->region.mux;
506 
507 	val = mux->val;
508 	for (loop = 0; loop < mux->no_ops; loop++) {
509 		qlcnic_ind_wr(adapter, mux->addr, val);
510 		data = qlcnic_ind_rd(adapter, mux->read_addr);
511 		*buffer++ = cpu_to_le32(val);
512 		*buffer++ = cpu_to_le32(data);
513 		val += mux->val_stride;
514 	}
515 	return 2 * mux->no_ops * sizeof(u32);
516 }
517 
518 static u32 qlcnic_dump_que(struct qlcnic_adapter *adapter,
519 			   struct qlcnic_dump_entry *entry, __le32 *buffer)
520 {
521 	int i, loop;
522 	u32 cnt, addr, data, que_id = 0;
523 	struct __queue *que = &entry->region.que;
524 
525 	addr = que->read_addr;
526 	cnt = que->read_addr_cnt;
527 
528 	for (loop = 0; loop < que->no_ops; loop++) {
529 		qlcnic_ind_wr(adapter, que->sel_addr, que_id);
530 		addr = que->read_addr;
531 		for (i = 0; i < cnt; i++) {
532 			data = qlcnic_ind_rd(adapter, addr);
533 			*buffer++ = cpu_to_le32(data);
534 			addr += que->read_addr_stride;
535 		}
536 		que_id += que->stride;
537 	}
538 	return que->no_ops * cnt * sizeof(u32);
539 }
540 
541 static u32 qlcnic_dump_ocm(struct qlcnic_adapter *adapter,
542 			   struct qlcnic_dump_entry *entry, __le32 *buffer)
543 {
544 	int i;
545 	u32 data;
546 	void __iomem *addr;
547 	struct __ocm *ocm = &entry->region.ocm;
548 
549 	addr = adapter->ahw->pci_base0 + ocm->read_addr;
550 	for (i = 0; i < ocm->no_ops; i++) {
551 		data = readl(addr);
552 		*buffer++ = cpu_to_le32(data);
553 		addr += ocm->read_addr_stride;
554 	}
555 	return ocm->no_ops * sizeof(u32);
556 }
557 
558 static u32 qlcnic_read_rom(struct qlcnic_adapter *adapter,
559 			   struct qlcnic_dump_entry *entry, __le32 *buffer)
560 {
561 	int i, count = 0;
562 	u32 fl_addr, size, val, lck_val, addr;
563 	struct __mem *rom = &entry->region.mem;
564 
565 	fl_addr = rom->addr;
566 	size = rom->size / 4;
567 lock_try:
568 	lck_val = QLC_SHARED_REG_RD32(adapter, QLCNIC_FLASH_LOCK);
569 	if (!lck_val && count < MAX_CTL_CHECK) {
570 		usleep_range(10000, 11000);
571 		count++;
572 		goto lock_try;
573 	}
574 	QLC_SHARED_REG_WR32(adapter, QLCNIC_FLASH_LOCK_OWNER,
575 			    adapter->ahw->pci_func);
576 	for (i = 0; i < size; i++) {
577 		addr = fl_addr & 0xFFFF0000;
578 		qlcnic_ind_wr(adapter, FLASH_ROM_WINDOW, addr);
579 		addr = LSW(fl_addr) + FLASH_ROM_DATA;
580 		val = qlcnic_ind_rd(adapter, addr);
581 		fl_addr += 4;
582 		*buffer++ = cpu_to_le32(val);
583 	}
584 	QLC_SHARED_REG_RD32(adapter, QLCNIC_FLASH_UNLOCK);
585 	return rom->size;
586 }
587 
588 static u32 qlcnic_dump_l1_cache(struct qlcnic_adapter *adapter,
589 				struct qlcnic_dump_entry *entry, __le32 *buffer)
590 {
591 	int i;
592 	u32 cnt, val, data, addr;
593 	struct __cache *l1 = &entry->region.cache;
594 
595 	val = l1->init_tag_val;
596 
597 	for (i = 0; i < l1->no_ops; i++) {
598 		qlcnic_ind_wr(adapter, l1->addr, val);
599 		qlcnic_ind_wr(adapter, l1->ctrl_addr, LSW(l1->ctrl_val));
600 		addr = l1->read_addr;
601 		cnt = l1->read_addr_num;
602 		while (cnt) {
603 			data = qlcnic_ind_rd(adapter, addr);
604 			*buffer++ = cpu_to_le32(data);
605 			addr += l1->read_addr_stride;
606 			cnt--;
607 		}
608 		val += l1->stride;
609 	}
610 	return l1->no_ops * l1->read_addr_num * sizeof(u32);
611 }
612 
613 static u32 qlcnic_dump_l2_cache(struct qlcnic_adapter *adapter,
614 				struct qlcnic_dump_entry *entry, __le32 *buffer)
615 {
616 	int i;
617 	u32 cnt, val, data, addr;
618 	u8 poll_mask, poll_to, time_out = 0;
619 	struct __cache *l2 = &entry->region.cache;
620 
621 	val = l2->init_tag_val;
622 	poll_mask = LSB(MSW(l2->ctrl_val));
623 	poll_to = MSB(MSW(l2->ctrl_val));
624 
625 	for (i = 0; i < l2->no_ops; i++) {
626 		qlcnic_ind_wr(adapter, l2->addr, val);
627 		if (LSW(l2->ctrl_val))
628 			qlcnic_ind_wr(adapter, l2->ctrl_addr,
629 				      LSW(l2->ctrl_val));
630 		if (!poll_mask)
631 			goto skip_poll;
632 		do {
633 			data = qlcnic_ind_rd(adapter, l2->ctrl_addr);
634 			if (!(data & poll_mask))
635 				break;
636 			usleep_range(1000, 2000);
637 			time_out++;
638 		} while (time_out <= poll_to);
639 
640 		if (time_out > poll_to) {
641 			dev_err(&adapter->pdev->dev,
642 				"Timeout exceeded in %s, aborting dump\n",
643 				__func__);
644 			return -EINVAL;
645 		}
646 skip_poll:
647 		addr = l2->read_addr;
648 		cnt = l2->read_addr_num;
649 		while (cnt) {
650 			data = qlcnic_ind_rd(adapter, addr);
651 			*buffer++ = cpu_to_le32(data);
652 			addr += l2->read_addr_stride;
653 			cnt--;
654 		}
655 		val += l2->stride;
656 	}
657 	return l2->no_ops * l2->read_addr_num * sizeof(u32);
658 }
659 
660 static u32 qlcnic_read_memory_test_agent(struct qlcnic_adapter *adapter,
661 					 struct __mem *mem, __le32 *buffer,
662 					 int *ret)
663 {
664 	u32 addr, data, test;
665 	int i, reg_read;
666 
667 	reg_read = mem->size;
668 	addr = mem->addr;
669 	/* check for data size of multiple of 16 and 16 byte alignment */
670 	if ((addr & 0xf) || (reg_read%16)) {
671 		dev_info(&adapter->pdev->dev,
672 			 "Unaligned memory addr:0x%x size:0x%x\n",
673 			 addr, reg_read);
674 		*ret = -EINVAL;
675 		return 0;
676 	}
677 
678 	mutex_lock(&adapter->ahw->mem_lock);
679 
680 	while (reg_read != 0) {
681 		qlcnic_ind_wr(adapter, QLCNIC_MS_ADDR_LO, addr);
682 		qlcnic_ind_wr(adapter, QLCNIC_MS_ADDR_HI, 0);
683 		qlcnic_ind_wr(adapter, QLCNIC_MS_CTRL, QLCNIC_TA_START_ENABLE);
684 
685 		for (i = 0; i < MAX_CTL_CHECK; i++) {
686 			test = qlcnic_ind_rd(adapter, QLCNIC_MS_CTRL);
687 			if (!(test & TA_CTL_BUSY))
688 				break;
689 		}
690 		if (i == MAX_CTL_CHECK) {
691 			if (printk_ratelimit()) {
692 				dev_err(&adapter->pdev->dev,
693 					"failed to read through agent\n");
694 				*ret = -EIO;
695 				goto out;
696 			}
697 		}
698 		for (i = 0; i < 4; i++) {
699 			data = qlcnic_ind_rd(adapter, qlcnic_ms_read_data[i]);
700 			*buffer++ = cpu_to_le32(data);
701 		}
702 		addr += 16;
703 		reg_read -= 16;
704 		ret += 16;
705 		cond_resched();
706 	}
707 out:
708 	mutex_unlock(&adapter->ahw->mem_lock);
709 	return mem->size;
710 }
711 
712 /* DMA register base address */
713 #define QLC_DMA_REG_BASE_ADDR(dma_no)	(0x77320000 + (dma_no * 0x10000))
714 
715 /* DMA register offsets w.r.t base address */
716 #define QLC_DMA_CMD_BUFF_ADDR_LOW	0
717 #define QLC_DMA_CMD_BUFF_ADDR_HI	4
718 #define QLC_DMA_CMD_STATUS_CTRL		8
719 
720 static int qlcnic_start_pex_dma(struct qlcnic_adapter *adapter,
721 				struct __mem *mem)
722 {
723 	struct device *dev = &adapter->pdev->dev;
724 	u32 dma_no, dma_base_addr, temp_addr;
725 	int i, ret, dma_sts;
726 	void *tmpl_hdr;
727 
728 	tmpl_hdr = adapter->ahw->fw_dump.tmpl_hdr;
729 	dma_no = qlcnic_get_saved_state(adapter, tmpl_hdr,
730 					QLC_83XX_DMA_ENGINE_INDEX);
731 	dma_base_addr = QLC_DMA_REG_BASE_ADDR(dma_no);
732 
733 	temp_addr = dma_base_addr + QLC_DMA_CMD_BUFF_ADDR_LOW;
734 	ret = qlcnic_ind_wr(adapter, temp_addr, mem->desc_card_addr);
735 	if (ret)
736 		return ret;
737 
738 	temp_addr = dma_base_addr + QLC_DMA_CMD_BUFF_ADDR_HI;
739 	ret = qlcnic_ind_wr(adapter, temp_addr, 0);
740 	if (ret)
741 		return ret;
742 
743 	temp_addr = dma_base_addr + QLC_DMA_CMD_STATUS_CTRL;
744 	ret = qlcnic_ind_wr(adapter, temp_addr, mem->start_dma_cmd);
745 	if (ret)
746 		return ret;
747 
748 	/* Wait for DMA to complete */
749 	temp_addr = dma_base_addr + QLC_DMA_CMD_STATUS_CTRL;
750 	for (i = 0; i < 400; i++) {
751 		dma_sts = qlcnic_ind_rd(adapter, temp_addr);
752 
753 		if (dma_sts & BIT_1)
754 			usleep_range(250, 500);
755 		else
756 			break;
757 	}
758 
759 	if (i >= 400) {
760 		dev_info(dev, "PEX DMA operation timed out");
761 		ret = -EIO;
762 	}
763 
764 	return ret;
765 }
766 
767 static u32 qlcnic_read_memory_pexdma(struct qlcnic_adapter *adapter,
768 				     struct __mem *mem,
769 				     __le32 *buffer, int *ret)
770 {
771 	struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
772 	u32 temp, dma_base_addr, size = 0, read_size = 0;
773 	struct qlcnic_pex_dma_descriptor *dma_descr;
774 	struct device *dev = &adapter->pdev->dev;
775 	dma_addr_t dma_phys_addr;
776 	void *dma_buffer;
777 	void *tmpl_hdr;
778 
779 	tmpl_hdr = fw_dump->tmpl_hdr;
780 
781 	/* Check if DMA engine is available */
782 	temp = qlcnic_get_saved_state(adapter, tmpl_hdr,
783 				      QLC_83XX_DMA_ENGINE_INDEX);
784 	dma_base_addr = QLC_DMA_REG_BASE_ADDR(temp);
785 	temp = qlcnic_ind_rd(adapter,
786 			     dma_base_addr + QLC_DMA_CMD_STATUS_CTRL);
787 
788 	if (!(temp & BIT_31)) {
789 		dev_info(dev, "%s: DMA engine is not available\n", __func__);
790 		*ret = -EIO;
791 		return 0;
792 	}
793 
794 	/* Create DMA descriptor */
795 	dma_descr = kzalloc(sizeof(struct qlcnic_pex_dma_descriptor),
796 			    GFP_KERNEL);
797 	if (!dma_descr) {
798 		*ret = -ENOMEM;
799 		return 0;
800 	}
801 
802 	/* dma_desc_cmd  0:15  = 0
803 	 * dma_desc_cmd 16:19  = mem->dma_desc_cmd 0:3
804 	 * dma_desc_cmd 20:23  = pci function number
805 	 * dma_desc_cmd 24:31  = mem->dma_desc_cmd 8:15
806 	 */
807 	dma_phys_addr = fw_dump->phys_addr;
808 	dma_buffer = fw_dump->dma_buffer;
809 	temp = 0;
810 	temp = mem->dma_desc_cmd & 0xff0f;
811 	temp |= (adapter->ahw->pci_func & 0xf) << 4;
812 	dma_descr->dma_desc_cmd = (temp << 16) & 0xffff0000;
813 	dma_descr->dma_bus_addr_low = LSD(dma_phys_addr);
814 	dma_descr->dma_bus_addr_high = MSD(dma_phys_addr);
815 	dma_descr->src_addr_high = 0;
816 
817 	/* Collect memory dump using multiple DMA operations if required */
818 	while (read_size < mem->size) {
819 		if (mem->size - read_size >= QLC_PEX_DMA_READ_SIZE)
820 			size = QLC_PEX_DMA_READ_SIZE;
821 		else
822 			size = mem->size - read_size;
823 
824 		dma_descr->src_addr_low = mem->addr + read_size;
825 		dma_descr->read_data_size = size;
826 
827 		/* Write DMA descriptor to MS memory*/
828 		temp = sizeof(struct qlcnic_pex_dma_descriptor) / 16;
829 		*ret = qlcnic_ms_mem_write128(adapter, mem->desc_card_addr,
830 					      (u32 *)dma_descr, temp);
831 		if (*ret) {
832 			dev_info(dev, "Failed to write DMA descriptor to MS memory at address 0x%x\n",
833 				 mem->desc_card_addr);
834 			goto free_dma_descr;
835 		}
836 
837 		*ret = qlcnic_start_pex_dma(adapter, mem);
838 		if (*ret) {
839 			dev_info(dev, "Failed to start PEX DMA operation\n");
840 			goto free_dma_descr;
841 		}
842 
843 		memcpy(buffer, dma_buffer, size);
844 		buffer += size / 4;
845 		read_size += size;
846 	}
847 
848 free_dma_descr:
849 	kfree(dma_descr);
850 
851 	return read_size;
852 }
853 
854 static u32 qlcnic_read_memory(struct qlcnic_adapter *adapter,
855 			      struct qlcnic_dump_entry *entry, __le32 *buffer)
856 {
857 	struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
858 	struct device *dev = &adapter->pdev->dev;
859 	struct __mem *mem = &entry->region.mem;
860 	u32 data_size;
861 	int ret = 0;
862 
863 	if (fw_dump->use_pex_dma) {
864 		data_size = qlcnic_read_memory_pexdma(adapter, mem, buffer,
865 						      &ret);
866 		if (ret)
867 			dev_info(dev,
868 				 "Failed to read memory dump using PEX DMA: mask[0x%x]\n",
869 				 entry->hdr.mask);
870 		else
871 			return data_size;
872 	}
873 
874 	data_size = qlcnic_read_memory_test_agent(adapter, mem, buffer, &ret);
875 	if (ret) {
876 		dev_info(dev,
877 			 "Failed to read memory dump using test agent method: mask[0x%x]\n",
878 			 entry->hdr.mask);
879 		return 0;
880 	} else {
881 		return data_size;
882 	}
883 }
884 
885 static u32 qlcnic_dump_nop(struct qlcnic_adapter *adapter,
886 			   struct qlcnic_dump_entry *entry, __le32 *buffer)
887 {
888 	entry->hdr.flags |= QLCNIC_DUMP_SKIP;
889 	return 0;
890 }
891 
892 static int qlcnic_valid_dump_entry(struct device *dev,
893 				   struct qlcnic_dump_entry *entry, u32 size)
894 {
895 	int ret = 1;
896 	if (size != entry->hdr.cap_size) {
897 		dev_err(dev,
898 			"Invalid entry, Type:%d\tMask:%d\tSize:%dCap_size:%d\n",
899 			entry->hdr.type, entry->hdr.mask, size,
900 			entry->hdr.cap_size);
901 		ret = 0;
902 	}
903 	return ret;
904 }
905 
906 static u32 qlcnic_read_pollrdmwr(struct qlcnic_adapter *adapter,
907 				 struct qlcnic_dump_entry *entry,
908 				 __le32 *buffer)
909 {
910 	struct __pollrdmwr *poll = &entry->region.pollrdmwr;
911 	u32 data, wait_count, poll_wait, temp;
912 
913 	poll_wait = poll->poll_wait;
914 
915 	qlcnic_ind_wr(adapter, poll->addr1, poll->val1);
916 	wait_count = 0;
917 
918 	while (wait_count < poll_wait) {
919 		data = qlcnic_ind_rd(adapter, poll->addr1);
920 		if ((data & poll->poll_mask) != 0)
921 			break;
922 		wait_count++;
923 	}
924 
925 	if (wait_count == poll_wait) {
926 		dev_err(&adapter->pdev->dev,
927 			"Timeout exceeded in %s, aborting dump\n",
928 			__func__);
929 		return 0;
930 	}
931 
932 	data = qlcnic_ind_rd(adapter, poll->addr2) & poll->mod_mask;
933 	qlcnic_ind_wr(adapter, poll->addr2, data);
934 	qlcnic_ind_wr(adapter, poll->addr1, poll->val2);
935 	wait_count = 0;
936 
937 	while (wait_count < poll_wait) {
938 		temp = qlcnic_ind_rd(adapter, poll->addr1);
939 		if ((temp & poll->poll_mask) != 0)
940 			break;
941 		wait_count++;
942 	}
943 
944 	*buffer++ = cpu_to_le32(poll->addr2);
945 	*buffer++ = cpu_to_le32(data);
946 
947 	return 2 * sizeof(u32);
948 
949 }
950 
951 static u32 qlcnic_read_pollrd(struct qlcnic_adapter *adapter,
952 			      struct qlcnic_dump_entry *entry, __le32 *buffer)
953 {
954 	struct __pollrd *pollrd = &entry->region.pollrd;
955 	u32 data, wait_count, poll_wait, sel_val;
956 	int i;
957 
958 	poll_wait = pollrd->poll_wait;
959 	sel_val = pollrd->sel_val;
960 
961 	for (i = 0; i < pollrd->no_ops; i++) {
962 		qlcnic_ind_wr(adapter, pollrd->sel_addr, sel_val);
963 		wait_count = 0;
964 		while (wait_count < poll_wait) {
965 			data = qlcnic_ind_rd(adapter, pollrd->sel_addr);
966 			if ((data & pollrd->poll_mask) != 0)
967 				break;
968 			wait_count++;
969 		}
970 
971 		if (wait_count == poll_wait) {
972 			dev_err(&adapter->pdev->dev,
973 				"Timeout exceeded in %s, aborting dump\n",
974 				__func__);
975 			return 0;
976 		}
977 
978 		data = qlcnic_ind_rd(adapter, pollrd->read_addr);
979 		*buffer++ = cpu_to_le32(sel_val);
980 		*buffer++ = cpu_to_le32(data);
981 		sel_val += pollrd->sel_val_stride;
982 	}
983 	return pollrd->no_ops * (2 * sizeof(u32));
984 }
985 
986 static u32 qlcnic_read_mux2(struct qlcnic_adapter *adapter,
987 			    struct qlcnic_dump_entry *entry, __le32 *buffer)
988 {
989 	struct __mux2 *mux2 = &entry->region.mux2;
990 	u32 data;
991 	u32 t_sel_val, sel_val1, sel_val2;
992 	int i;
993 
994 	sel_val1 = mux2->sel_val1;
995 	sel_val2 = mux2->sel_val2;
996 
997 	for (i = 0; i < mux2->no_ops; i++) {
998 		qlcnic_ind_wr(adapter, mux2->sel_addr1, sel_val1);
999 		t_sel_val = sel_val1 & mux2->sel_val_mask;
1000 		qlcnic_ind_wr(adapter, mux2->sel_addr2, t_sel_val);
1001 		data = qlcnic_ind_rd(adapter, mux2->read_addr);
1002 		*buffer++ = cpu_to_le32(t_sel_val);
1003 		*buffer++ = cpu_to_le32(data);
1004 		qlcnic_ind_wr(adapter, mux2->sel_addr1, sel_val2);
1005 		t_sel_val = sel_val2 & mux2->sel_val_mask;
1006 		qlcnic_ind_wr(adapter, mux2->sel_addr2, t_sel_val);
1007 		data = qlcnic_ind_rd(adapter, mux2->read_addr);
1008 		*buffer++ = cpu_to_le32(t_sel_val);
1009 		*buffer++ = cpu_to_le32(data);
1010 		sel_val1 += mux2->sel_val_stride;
1011 		sel_val2 += mux2->sel_val_stride;
1012 	}
1013 
1014 	return mux2->no_ops * (4 * sizeof(u32));
1015 }
1016 
1017 static u32 qlcnic_83xx_dump_rom(struct qlcnic_adapter *adapter,
1018 				struct qlcnic_dump_entry *entry, __le32 *buffer)
1019 {
1020 	u32 fl_addr, size;
1021 	struct __mem *rom = &entry->region.mem;
1022 
1023 	fl_addr = rom->addr;
1024 	size = rom->size / 4;
1025 
1026 	if (!qlcnic_83xx_lockless_flash_read32(adapter, fl_addr,
1027 					       (u8 *)buffer, size))
1028 		return rom->size;
1029 
1030 	return 0;
1031 }
1032 
1033 static const struct qlcnic_dump_operations qlcnic_fw_dump_ops[] = {
1034 	{QLCNIC_DUMP_NOP, qlcnic_dump_nop},
1035 	{QLCNIC_DUMP_READ_CRB, qlcnic_dump_crb},
1036 	{QLCNIC_DUMP_READ_MUX, qlcnic_dump_mux},
1037 	{QLCNIC_DUMP_QUEUE, qlcnic_dump_que},
1038 	{QLCNIC_DUMP_BRD_CONFIG, qlcnic_read_rom},
1039 	{QLCNIC_DUMP_READ_OCM, qlcnic_dump_ocm},
1040 	{QLCNIC_DUMP_PEG_REG, qlcnic_dump_ctrl},
1041 	{QLCNIC_DUMP_L1_DTAG, qlcnic_dump_l1_cache},
1042 	{QLCNIC_DUMP_L1_ITAG, qlcnic_dump_l1_cache},
1043 	{QLCNIC_DUMP_L1_DATA, qlcnic_dump_l1_cache},
1044 	{QLCNIC_DUMP_L1_INST, qlcnic_dump_l1_cache},
1045 	{QLCNIC_DUMP_L2_DTAG, qlcnic_dump_l2_cache},
1046 	{QLCNIC_DUMP_L2_ITAG, qlcnic_dump_l2_cache},
1047 	{QLCNIC_DUMP_L2_DATA, qlcnic_dump_l2_cache},
1048 	{QLCNIC_DUMP_L2_INST, qlcnic_dump_l2_cache},
1049 	{QLCNIC_DUMP_READ_ROM, qlcnic_read_rom},
1050 	{QLCNIC_DUMP_READ_MEM, qlcnic_read_memory},
1051 	{QLCNIC_DUMP_READ_CTRL, qlcnic_dump_ctrl},
1052 	{QLCNIC_DUMP_TLHDR, qlcnic_dump_nop},
1053 	{QLCNIC_DUMP_RDEND, qlcnic_dump_nop},
1054 };
1055 
1056 static const struct qlcnic_dump_operations qlcnic_83xx_fw_dump_ops[] = {
1057 	{QLCNIC_DUMP_NOP, qlcnic_dump_nop},
1058 	{QLCNIC_DUMP_READ_CRB, qlcnic_dump_crb},
1059 	{QLCNIC_DUMP_READ_MUX, qlcnic_dump_mux},
1060 	{QLCNIC_DUMP_QUEUE, qlcnic_dump_que},
1061 	{QLCNIC_DUMP_BRD_CONFIG, qlcnic_83xx_dump_rom},
1062 	{QLCNIC_DUMP_READ_OCM, qlcnic_dump_ocm},
1063 	{QLCNIC_DUMP_PEG_REG, qlcnic_dump_ctrl},
1064 	{QLCNIC_DUMP_L1_DTAG, qlcnic_dump_l1_cache},
1065 	{QLCNIC_DUMP_L1_ITAG, qlcnic_dump_l1_cache},
1066 	{QLCNIC_DUMP_L1_DATA, qlcnic_dump_l1_cache},
1067 	{QLCNIC_DUMP_L1_INST, qlcnic_dump_l1_cache},
1068 	{QLCNIC_DUMP_L2_DTAG, qlcnic_dump_l2_cache},
1069 	{QLCNIC_DUMP_L2_ITAG, qlcnic_dump_l2_cache},
1070 	{QLCNIC_DUMP_L2_DATA, qlcnic_dump_l2_cache},
1071 	{QLCNIC_DUMP_L2_INST, qlcnic_dump_l2_cache},
1072 	{QLCNIC_DUMP_POLL_RD, qlcnic_read_pollrd},
1073 	{QLCNIC_READ_MUX2, qlcnic_read_mux2},
1074 	{QLCNIC_READ_POLLRDMWR, qlcnic_read_pollrdmwr},
1075 	{QLCNIC_DUMP_READ_ROM, qlcnic_83xx_dump_rom},
1076 	{QLCNIC_DUMP_READ_MEM, qlcnic_read_memory},
1077 	{QLCNIC_DUMP_READ_CTRL, qlcnic_dump_ctrl},
1078 	{QLCNIC_DUMP_TLHDR, qlcnic_dump_nop},
1079 	{QLCNIC_DUMP_RDEND, qlcnic_dump_nop},
1080 };
1081 
1082 static uint32_t qlcnic_temp_checksum(uint32_t *temp_buffer, u32 temp_size)
1083 {
1084 	uint64_t sum = 0;
1085 	int count = temp_size / sizeof(uint32_t);
1086 	while (count-- > 0)
1087 		sum += *temp_buffer++;
1088 	while (sum >> 32)
1089 		sum = (sum & 0xFFFFFFFF) + (sum >> 32);
1090 	return ~sum;
1091 }
1092 
1093 static int qlcnic_fw_flash_get_minidump_temp(struct qlcnic_adapter *adapter,
1094 					     u8 *buffer, u32 size)
1095 {
1096 	int ret = 0;
1097 
1098 	if (qlcnic_82xx_check(adapter))
1099 		return -EIO;
1100 
1101 	if (qlcnic_83xx_lock_flash(adapter))
1102 		return -EIO;
1103 
1104 	ret = qlcnic_83xx_lockless_flash_read32(adapter,
1105 						QLC_83XX_MINIDUMP_FLASH,
1106 						buffer, size / sizeof(u32));
1107 
1108 	qlcnic_83xx_unlock_flash(adapter);
1109 
1110 	return ret;
1111 }
1112 
1113 static int
1114 qlcnic_fw_flash_get_minidump_temp_size(struct qlcnic_adapter *adapter,
1115 				       struct qlcnic_cmd_args *cmd)
1116 {
1117 	struct qlcnic_83xx_dump_template_hdr tmp_hdr;
1118 	u32 size = sizeof(tmp_hdr) / sizeof(u32);
1119 	int ret = 0;
1120 
1121 	if (qlcnic_82xx_check(adapter))
1122 		return -EIO;
1123 
1124 	if (qlcnic_83xx_lock_flash(adapter))
1125 		return -EIO;
1126 
1127 	ret = qlcnic_83xx_lockless_flash_read32(adapter,
1128 						QLC_83XX_MINIDUMP_FLASH,
1129 						(u8 *)&tmp_hdr, size);
1130 
1131 	qlcnic_83xx_unlock_flash(adapter);
1132 
1133 	cmd->rsp.arg[2] = tmp_hdr.size;
1134 	cmd->rsp.arg[3] = tmp_hdr.version;
1135 
1136 	return ret;
1137 }
1138 
1139 static int qlcnic_fw_get_minidump_temp_size(struct qlcnic_adapter *adapter,
1140 					    u32 *version, u32 *temp_size,
1141 					    u8 *use_flash_temp)
1142 {
1143 	int err = 0;
1144 	struct qlcnic_cmd_args cmd;
1145 
1146 	if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_TEMP_SIZE))
1147 		return -ENOMEM;
1148 
1149 	err = qlcnic_issue_cmd(adapter, &cmd);
1150 	if (err != QLCNIC_RCODE_SUCCESS) {
1151 		if (qlcnic_fw_flash_get_minidump_temp_size(adapter, &cmd)) {
1152 			qlcnic_free_mbx_args(&cmd);
1153 			return -EIO;
1154 		}
1155 		*use_flash_temp = 1;
1156 	}
1157 
1158 	*temp_size = cmd.rsp.arg[2];
1159 	*version = cmd.rsp.arg[3];
1160 	qlcnic_free_mbx_args(&cmd);
1161 
1162 	if (!(*temp_size))
1163 		return -EIO;
1164 
1165 	return 0;
1166 }
1167 
1168 static int __qlcnic_fw_cmd_get_minidump_temp(struct qlcnic_adapter *adapter,
1169 					     u32 *buffer, u32 temp_size)
1170 {
1171 	int err = 0, i;
1172 	void *tmp_addr;
1173 	__le32 *tmp_buf;
1174 	struct qlcnic_cmd_args cmd;
1175 	dma_addr_t tmp_addr_t = 0;
1176 
1177 	tmp_addr = dma_alloc_coherent(&adapter->pdev->dev, temp_size,
1178 				      &tmp_addr_t, GFP_KERNEL);
1179 	if (!tmp_addr)
1180 		return -ENOMEM;
1181 
1182 	if (qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_GET_TEMP_HDR)) {
1183 		err = -ENOMEM;
1184 		goto free_mem;
1185 	}
1186 
1187 	cmd.req.arg[1] = LSD(tmp_addr_t);
1188 	cmd.req.arg[2] = MSD(tmp_addr_t);
1189 	cmd.req.arg[3] = temp_size;
1190 	err = qlcnic_issue_cmd(adapter, &cmd);
1191 
1192 	tmp_buf = tmp_addr;
1193 	if (err == QLCNIC_RCODE_SUCCESS) {
1194 		for (i = 0; i < temp_size / sizeof(u32); i++)
1195 			*buffer++ = __le32_to_cpu(*tmp_buf++);
1196 	}
1197 
1198 	qlcnic_free_mbx_args(&cmd);
1199 
1200 free_mem:
1201 	dma_free_coherent(&adapter->pdev->dev, temp_size, tmp_addr, tmp_addr_t);
1202 
1203 	return err;
1204 }
1205 
1206 int qlcnic_fw_cmd_get_minidump_temp(struct qlcnic_adapter *adapter)
1207 {
1208 	struct qlcnic_hardware_context *ahw;
1209 	struct qlcnic_fw_dump *fw_dump;
1210 	u32 version, csum, *tmp_buf;
1211 	u8 use_flash_temp = 0;
1212 	u32 temp_size = 0;
1213 	void *temp_buffer;
1214 	int err;
1215 
1216 	ahw = adapter->ahw;
1217 	fw_dump = &ahw->fw_dump;
1218 	err = qlcnic_fw_get_minidump_temp_size(adapter, &version, &temp_size,
1219 					       &use_flash_temp);
1220 	if (err) {
1221 		dev_err(&adapter->pdev->dev,
1222 			"Can't get template size %d\n", err);
1223 		return -EIO;
1224 	}
1225 
1226 	fw_dump->tmpl_hdr = vzalloc(temp_size);
1227 	if (!fw_dump->tmpl_hdr)
1228 		return -ENOMEM;
1229 
1230 	tmp_buf = (u32 *)fw_dump->tmpl_hdr;
1231 	if (use_flash_temp)
1232 		goto flash_temp;
1233 
1234 	err = __qlcnic_fw_cmd_get_minidump_temp(adapter, tmp_buf, temp_size);
1235 
1236 	if (err) {
1237 flash_temp:
1238 		err = qlcnic_fw_flash_get_minidump_temp(adapter, (u8 *)tmp_buf,
1239 							temp_size);
1240 
1241 		if (err) {
1242 			dev_err(&adapter->pdev->dev,
1243 				"Failed to get minidump template header %d\n",
1244 				err);
1245 			vfree(fw_dump->tmpl_hdr);
1246 			fw_dump->tmpl_hdr = NULL;
1247 			return -EIO;
1248 		}
1249 	}
1250 
1251 	csum = qlcnic_temp_checksum((uint32_t *)tmp_buf, temp_size);
1252 
1253 	if (csum) {
1254 		dev_err(&adapter->pdev->dev,
1255 			"Template header checksum validation failed\n");
1256 		vfree(fw_dump->tmpl_hdr);
1257 		fw_dump->tmpl_hdr = NULL;
1258 		return -EIO;
1259 	}
1260 
1261 	qlcnic_cache_tmpl_hdr_values(adapter, fw_dump);
1262 
1263 	if (fw_dump->use_pex_dma) {
1264 		fw_dump->dma_buffer = NULL;
1265 		temp_buffer = dma_alloc_coherent(&adapter->pdev->dev,
1266 						 QLC_PEX_DMA_READ_SIZE,
1267 						 &fw_dump->phys_addr,
1268 						 GFP_KERNEL);
1269 		if (!temp_buffer)
1270 			fw_dump->use_pex_dma = false;
1271 		else
1272 			fw_dump->dma_buffer = temp_buffer;
1273 	}
1274 
1275 
1276 	dev_info(&adapter->pdev->dev,
1277 		 "Default minidump capture mask 0x%x\n",
1278 		 fw_dump->cap_mask);
1279 
1280 	qlcnic_enable_fw_dump_state(adapter);
1281 
1282 	return 0;
1283 }
1284 
1285 int qlcnic_dump_fw(struct qlcnic_adapter *adapter)
1286 {
1287 	struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1288 	const struct qlcnic_dump_operations *fw_dump_ops;
1289 	struct qlcnic_83xx_dump_template_hdr *hdr_83xx;
1290 	u32 entry_offset, dump, no_entries, buf_offset = 0;
1291 	int i, k, ops_cnt, ops_index, dump_size = 0;
1292 	struct device *dev = &adapter->pdev->dev;
1293 	struct qlcnic_hardware_context *ahw;
1294 	struct qlcnic_dump_entry *entry;
1295 	void *tmpl_hdr;
1296 	u32 ocm_window;
1297 	__le32 *buffer;
1298 	char mesg[64];
1299 	char *msg[] = {mesg, NULL};
1300 
1301 	ahw = adapter->ahw;
1302 	tmpl_hdr = fw_dump->tmpl_hdr;
1303 
1304 	/* Return if we don't have firmware dump template header */
1305 	if (!tmpl_hdr)
1306 		return -EIO;
1307 
1308 	if (!qlcnic_check_fw_dump_state(adapter)) {
1309 		dev_info(&adapter->pdev->dev, "Dump not enabled\n");
1310 		return -EIO;
1311 	}
1312 
1313 	if (fw_dump->clr) {
1314 		dev_info(&adapter->pdev->dev,
1315 			 "Previous dump not cleared, not capturing dump\n");
1316 		return -EIO;
1317 	}
1318 
1319 	netif_info(adapter->ahw, drv, adapter->netdev, "Take FW dump\n");
1320 	/* Calculate the size for dump data area only */
1321 	for (i = 2, k = 1; (i & QLCNIC_DUMP_MASK_MAX); i <<= 1, k++)
1322 		if (i & fw_dump->cap_mask)
1323 			dump_size += qlcnic_get_cap_size(adapter, tmpl_hdr, k);
1324 
1325 	if (!dump_size)
1326 		return -EIO;
1327 
1328 	fw_dump->data = vzalloc(dump_size);
1329 	if (!fw_dump->data)
1330 		return -ENOMEM;
1331 
1332 	buffer = fw_dump->data;
1333 	fw_dump->size = dump_size;
1334 	no_entries = fw_dump->num_entries;
1335 	entry_offset = fw_dump->offset;
1336 	qlcnic_set_sys_info(adapter, tmpl_hdr, 0, QLCNIC_DRIVER_VERSION);
1337 	qlcnic_set_sys_info(adapter, tmpl_hdr, 1, adapter->fw_version);
1338 
1339 	if (qlcnic_82xx_check(adapter)) {
1340 		ops_cnt = ARRAY_SIZE(qlcnic_fw_dump_ops);
1341 		fw_dump_ops = qlcnic_fw_dump_ops;
1342 	} else {
1343 		hdr_83xx = tmpl_hdr;
1344 		ops_cnt = ARRAY_SIZE(qlcnic_83xx_fw_dump_ops);
1345 		fw_dump_ops = qlcnic_83xx_fw_dump_ops;
1346 		ocm_window = hdr_83xx->ocm_wnd_reg[ahw->pci_func];
1347 		hdr_83xx->saved_state[QLC_83XX_OCM_INDEX] = ocm_window;
1348 		hdr_83xx->saved_state[QLC_83XX_PCI_INDEX] = ahw->pci_func;
1349 	}
1350 
1351 	for (i = 0; i < no_entries; i++) {
1352 		entry = tmpl_hdr + entry_offset;
1353 		if (!(entry->hdr.mask & fw_dump->cap_mask)) {
1354 			entry->hdr.flags |= QLCNIC_DUMP_SKIP;
1355 			entry_offset += entry->hdr.offset;
1356 			continue;
1357 		}
1358 
1359 		/* Find the handler for this entry */
1360 		ops_index = 0;
1361 		while (ops_index < ops_cnt) {
1362 			if (entry->hdr.type == fw_dump_ops[ops_index].opcode)
1363 				break;
1364 			ops_index++;
1365 		}
1366 
1367 		if (ops_index == ops_cnt) {
1368 			dev_info(dev, "Skipping unknown entry opcode %d\n",
1369 				 entry->hdr.type);
1370 			entry->hdr.flags |= QLCNIC_DUMP_SKIP;
1371 			entry_offset += entry->hdr.offset;
1372 			continue;
1373 		}
1374 
1375 		/* Collect dump for this entry */
1376 		dump = fw_dump_ops[ops_index].handler(adapter, entry, buffer);
1377 		if (!qlcnic_valid_dump_entry(dev, entry, dump)) {
1378 			entry->hdr.flags |= QLCNIC_DUMP_SKIP;
1379 			entry_offset += entry->hdr.offset;
1380 			continue;
1381 		}
1382 
1383 		buf_offset += entry->hdr.cap_size;
1384 		entry_offset += entry->hdr.offset;
1385 		buffer = fw_dump->data + buf_offset;
1386 		cond_resched();
1387 	}
1388 
1389 	fw_dump->clr = 1;
1390 	snprintf(mesg, sizeof(mesg), "FW_DUMP=%s", adapter->netdev->name);
1391 	netdev_info(adapter->netdev,
1392 		    "Dump data %d bytes captured, dump data address = %p, template header size %d bytes, template address = %p\n",
1393 		    fw_dump->size, fw_dump->data, fw_dump->tmpl_hdr_size,
1394 		    fw_dump->tmpl_hdr);
1395 	/* Send a udev event to notify availability of FW dump */
1396 	kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, msg);
1397 
1398 	return 0;
1399 }
1400 
1401 static inline bool
1402 qlcnic_83xx_md_check_extended_dump_capability(struct qlcnic_adapter *adapter)
1403 {
1404 	/* For special adapters (with 0x8830 device ID), where iSCSI firmware
1405 	 * dump needs to be captured as part of regular firmware dump
1406 	 * collection process, firmware exports it's capability through
1407 	 * capability registers
1408 	 */
1409 	return ((adapter->pdev->device == PCI_DEVICE_ID_QLOGIC_QLE8830) &&
1410 		(adapter->ahw->extra_capability[0] &
1411 		 QLCNIC_FW_CAPABILITY_2_EXT_ISCSI_DUMP));
1412 }
1413 
1414 void qlcnic_83xx_get_minidump_template(struct qlcnic_adapter *adapter)
1415 {
1416 	u32 prev_version, current_version;
1417 	struct qlcnic_hardware_context *ahw = adapter->ahw;
1418 	struct qlcnic_fw_dump *fw_dump = &ahw->fw_dump;
1419 	struct pci_dev *pdev = adapter->pdev;
1420 	bool extended = false;
1421 	int ret;
1422 
1423 	prev_version = adapter->fw_version;
1424 	current_version = qlcnic_83xx_get_fw_version(adapter);
1425 
1426 	if (fw_dump->tmpl_hdr == NULL || current_version > prev_version) {
1427 		vfree(fw_dump->tmpl_hdr);
1428 
1429 		if (qlcnic_83xx_md_check_extended_dump_capability(adapter))
1430 			extended = !qlcnic_83xx_extend_md_capab(adapter);
1431 
1432 		ret = qlcnic_fw_cmd_get_minidump_temp(adapter);
1433 		if (ret)
1434 			return;
1435 
1436 		dev_info(&pdev->dev, "Supports FW dump capability\n");
1437 
1438 		/* Once we have minidump template with extended iSCSI dump
1439 		 * capability, update the minidump capture mask to 0x1f as
1440 		 * per FW requirement
1441 		 */
1442 		if (extended) {
1443 			struct qlcnic_83xx_dump_template_hdr *hdr;
1444 
1445 			hdr = fw_dump->tmpl_hdr;
1446 			hdr->drv_cap_mask = 0x1f;
1447 			fw_dump->cap_mask = 0x1f;
1448 			dev_info(&pdev->dev,
1449 				 "Extended iSCSI dump capability and updated capture mask to 0x1f\n");
1450 		}
1451 	}
1452 }
1453