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 "qlcnic_sriov.h"
8 #include "qlcnic.h"
9 #include "qlcnic_hw.h"
10
11 /* Reset template definitions */
12 #define QLC_83XX_RESTART_TEMPLATE_SIZE 0x2000
13 #define QLC_83XX_RESET_TEMPLATE_ADDR 0x4F0000
14 #define QLC_83XX_RESET_SEQ_VERSION 0x0101
15
16 #define QLC_83XX_OPCODE_NOP 0x0000
17 #define QLC_83XX_OPCODE_WRITE_LIST 0x0001
18 #define QLC_83XX_OPCODE_READ_WRITE_LIST 0x0002
19 #define QLC_83XX_OPCODE_POLL_LIST 0x0004
20 #define QLC_83XX_OPCODE_POLL_WRITE_LIST 0x0008
21 #define QLC_83XX_OPCODE_READ_MODIFY_WRITE 0x0010
22 #define QLC_83XX_OPCODE_SEQ_PAUSE 0x0020
23 #define QLC_83XX_OPCODE_SEQ_END 0x0040
24 #define QLC_83XX_OPCODE_TMPL_END 0x0080
25 #define QLC_83XX_OPCODE_POLL_READ_LIST 0x0100
26
27 /* EPORT control registers */
28 #define QLC_83XX_RESET_CONTROL 0x28084E50
29 #define QLC_83XX_RESET_REG 0x28084E60
30 #define QLC_83XX_RESET_PORT0 0x28084E70
31 #define QLC_83XX_RESET_PORT1 0x28084E80
32 #define QLC_83XX_RESET_PORT2 0x28084E90
33 #define QLC_83XX_RESET_PORT3 0x28084EA0
34 #define QLC_83XX_RESET_SRESHIM 0x28084EB0
35 #define QLC_83XX_RESET_EPGSHIM 0x28084EC0
36 #define QLC_83XX_RESET_ETHERPCS 0x28084ED0
37
38 static int qlcnic_83xx_init_default_driver(struct qlcnic_adapter *adapter);
39 static int qlcnic_83xx_check_heartbeat(struct qlcnic_adapter *p_dev);
40 static int qlcnic_83xx_restart_hw(struct qlcnic_adapter *adapter);
41 static int qlcnic_83xx_check_hw_status(struct qlcnic_adapter *p_dev);
42 static int qlcnic_83xx_get_reset_instruction_template(struct qlcnic_adapter *);
43 static void qlcnic_83xx_stop_hw(struct qlcnic_adapter *);
44
45 /* Template header */
46 struct qlc_83xx_reset_hdr {
47 #if defined(__LITTLE_ENDIAN)
48 u16 version;
49 u16 signature;
50 u16 size;
51 u16 entries;
52 u16 hdr_size;
53 u16 checksum;
54 u16 init_offset;
55 u16 start_offset;
56 #elif defined(__BIG_ENDIAN)
57 u16 signature;
58 u16 version;
59 u16 entries;
60 u16 size;
61 u16 checksum;
62 u16 hdr_size;
63 u16 start_offset;
64 u16 init_offset;
65 #endif
66 } __packed;
67
68 /* Command entry header. */
69 struct qlc_83xx_entry_hdr {
70 #if defined(__LITTLE_ENDIAN)
71 u16 cmd;
72 u16 size;
73 u16 count;
74 u16 delay;
75 #elif defined(__BIG_ENDIAN)
76 u16 size;
77 u16 cmd;
78 u16 delay;
79 u16 count;
80 #endif
81 } __packed;
82
83 /* Generic poll command */
84 struct qlc_83xx_poll {
85 u32 mask;
86 u32 status;
87 } __packed;
88
89 /* Read modify write command */
90 struct qlc_83xx_rmw {
91 u32 mask;
92 u32 xor_value;
93 u32 or_value;
94 #if defined(__LITTLE_ENDIAN)
95 u8 shl;
96 u8 shr;
97 u8 index_a;
98 u8 rsvd;
99 #elif defined(__BIG_ENDIAN)
100 u8 rsvd;
101 u8 index_a;
102 u8 shr;
103 u8 shl;
104 #endif
105 } __packed;
106
107 /* Generic command with 2 DWORD */
108 struct qlc_83xx_entry {
109 u32 arg1;
110 u32 arg2;
111 } __packed;
112
113 /* Generic command with 4 DWORD */
114 struct qlc_83xx_quad_entry {
115 u32 dr_addr;
116 u32 dr_value;
117 u32 ar_addr;
118 u32 ar_value;
119 } __packed;
120 static const char *const qlc_83xx_idc_states[] = {
121 "Unknown",
122 "Cold",
123 "Init",
124 "Ready",
125 "Need Reset",
126 "Need Quiesce",
127 "Failed",
128 "Quiesce"
129 };
130
131 static int
qlcnic_83xx_idc_check_driver_presence_reg(struct qlcnic_adapter * adapter)132 qlcnic_83xx_idc_check_driver_presence_reg(struct qlcnic_adapter *adapter)
133 {
134 u32 val;
135
136 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_DRV_PRESENCE);
137 if ((val & 0xFFFF))
138 return 1;
139 else
140 return 0;
141 }
142
qlcnic_83xx_idc_log_state_history(struct qlcnic_adapter * adapter)143 static void qlcnic_83xx_idc_log_state_history(struct qlcnic_adapter *adapter)
144 {
145 u32 cur, prev;
146 cur = adapter->ahw->idc.curr_state;
147 prev = adapter->ahw->idc.prev_state;
148
149 dev_info(&adapter->pdev->dev,
150 "current state = %s, prev state = %s\n",
151 adapter->ahw->idc.name[cur],
152 adapter->ahw->idc.name[prev]);
153 }
154
qlcnic_83xx_idc_update_audit_reg(struct qlcnic_adapter * adapter,u8 mode,int lock)155 static int qlcnic_83xx_idc_update_audit_reg(struct qlcnic_adapter *adapter,
156 u8 mode, int lock)
157 {
158 u32 val;
159 int seconds;
160
161 if (lock) {
162 if (qlcnic_83xx_lock_driver(adapter))
163 return -EBUSY;
164 }
165
166 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_DRV_AUDIT);
167 val |= (adapter->portnum & 0xf);
168 val |= mode << 7;
169 if (mode)
170 seconds = jiffies / HZ - adapter->ahw->idc.sec_counter;
171 else
172 seconds = jiffies / HZ;
173
174 val |= seconds << 8;
175 QLCWRX(adapter->ahw, QLC_83XX_IDC_DRV_AUDIT, val);
176 adapter->ahw->idc.sec_counter = jiffies / HZ;
177
178 if (lock)
179 qlcnic_83xx_unlock_driver(adapter);
180
181 return 0;
182 }
183
qlcnic_83xx_idc_update_minor_version(struct qlcnic_adapter * adapter)184 static void qlcnic_83xx_idc_update_minor_version(struct qlcnic_adapter *adapter)
185 {
186 u32 val;
187
188 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_MIN_VERSION);
189 val = val & ~(0x3 << (adapter->portnum * 2));
190 val = val | (QLC_83XX_IDC_MINOR_VERSION << (adapter->portnum * 2));
191 QLCWRX(adapter->ahw, QLC_83XX_IDC_MIN_VERSION, val);
192 }
193
qlcnic_83xx_idc_update_major_version(struct qlcnic_adapter * adapter,int lock)194 static int qlcnic_83xx_idc_update_major_version(struct qlcnic_adapter *adapter,
195 int lock)
196 {
197 u32 val;
198
199 if (lock) {
200 if (qlcnic_83xx_lock_driver(adapter))
201 return -EBUSY;
202 }
203
204 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_MAJ_VERSION);
205 val = val & ~0xFF;
206 val = val | QLC_83XX_IDC_MAJOR_VERSION;
207 QLCWRX(adapter->ahw, QLC_83XX_IDC_MAJ_VERSION, val);
208
209 if (lock)
210 qlcnic_83xx_unlock_driver(adapter);
211
212 return 0;
213 }
214
215 static int
qlcnic_83xx_idc_update_drv_presence_reg(struct qlcnic_adapter * adapter,int status,int lock)216 qlcnic_83xx_idc_update_drv_presence_reg(struct qlcnic_adapter *adapter,
217 int status, int lock)
218 {
219 u32 val;
220
221 if (lock) {
222 if (qlcnic_83xx_lock_driver(adapter))
223 return -EBUSY;
224 }
225
226 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_DRV_PRESENCE);
227
228 if (status)
229 val = val | (1 << adapter->portnum);
230 else
231 val = val & ~(1 << adapter->portnum);
232
233 QLCWRX(adapter->ahw, QLC_83XX_IDC_DRV_PRESENCE, val);
234 qlcnic_83xx_idc_update_minor_version(adapter);
235
236 if (lock)
237 qlcnic_83xx_unlock_driver(adapter);
238
239 return 0;
240 }
241
qlcnic_83xx_idc_check_major_version(struct qlcnic_adapter * adapter)242 static int qlcnic_83xx_idc_check_major_version(struct qlcnic_adapter *adapter)
243 {
244 u32 val;
245 u8 version;
246
247 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_MAJ_VERSION);
248 version = val & 0xFF;
249
250 if (version != QLC_83XX_IDC_MAJOR_VERSION) {
251 dev_info(&adapter->pdev->dev,
252 "%s:mismatch. version 0x%x, expected version 0x%x\n",
253 __func__, version, QLC_83XX_IDC_MAJOR_VERSION);
254 return -EIO;
255 }
256
257 return 0;
258 }
259
qlcnic_83xx_idc_clear_registers(struct qlcnic_adapter * adapter,int lock)260 static int qlcnic_83xx_idc_clear_registers(struct qlcnic_adapter *adapter,
261 int lock)
262 {
263 u32 val;
264
265 if (lock) {
266 if (qlcnic_83xx_lock_driver(adapter))
267 return -EBUSY;
268 }
269
270 QLCWRX(adapter->ahw, QLC_83XX_IDC_DRV_ACK, 0);
271 /* Clear graceful reset bit */
272 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
273 val &= ~QLC_83XX_IDC_GRACEFULL_RESET;
274 QLCWRX(adapter->ahw, QLC_83XX_IDC_CTRL, val);
275
276 if (lock)
277 qlcnic_83xx_unlock_driver(adapter);
278
279 return 0;
280 }
281
qlcnic_83xx_idc_update_drv_ack_reg(struct qlcnic_adapter * adapter,int flag,int lock)282 static int qlcnic_83xx_idc_update_drv_ack_reg(struct qlcnic_adapter *adapter,
283 int flag, int lock)
284 {
285 u32 val;
286
287 if (lock) {
288 if (qlcnic_83xx_lock_driver(adapter))
289 return -EBUSY;
290 }
291
292 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_DRV_ACK);
293 if (flag)
294 val = val | (1 << adapter->portnum);
295 else
296 val = val & ~(1 << adapter->portnum);
297 QLCWRX(adapter->ahw, QLC_83XX_IDC_DRV_ACK, val);
298
299 if (lock)
300 qlcnic_83xx_unlock_driver(adapter);
301
302 return 0;
303 }
304
qlcnic_83xx_idc_check_timeout(struct qlcnic_adapter * adapter,int time_limit)305 static int qlcnic_83xx_idc_check_timeout(struct qlcnic_adapter *adapter,
306 int time_limit)
307 {
308 u64 seconds;
309
310 seconds = jiffies / HZ - adapter->ahw->idc.sec_counter;
311 if (seconds <= time_limit)
312 return 0;
313 else
314 return -EBUSY;
315 }
316
317 /**
318 * qlcnic_83xx_idc_check_reset_ack_reg
319 *
320 * @adapter: adapter structure
321 *
322 * Check ACK wait limit and clear the functions which failed to ACK
323 *
324 * Return 0 if all functions have acknowledged the reset request.
325 **/
qlcnic_83xx_idc_check_reset_ack_reg(struct qlcnic_adapter * adapter)326 static int qlcnic_83xx_idc_check_reset_ack_reg(struct qlcnic_adapter *adapter)
327 {
328 int timeout;
329 u32 ack, presence, val;
330
331 timeout = QLC_83XX_IDC_RESET_TIMEOUT_SECS;
332 ack = QLCRDX(adapter->ahw, QLC_83XX_IDC_DRV_ACK);
333 presence = QLCRDX(adapter->ahw, QLC_83XX_IDC_DRV_PRESENCE);
334 dev_info(&adapter->pdev->dev,
335 "%s: ack = 0x%x, presence = 0x%x\n", __func__, ack, presence);
336 if (!((ack & presence) == presence)) {
337 if (qlcnic_83xx_idc_check_timeout(adapter, timeout)) {
338 /* Clear functions which failed to ACK */
339 dev_info(&adapter->pdev->dev,
340 "%s: ACK wait exceeds time limit\n", __func__);
341 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_DRV_PRESENCE);
342 val = val & ~(ack ^ presence);
343 if (qlcnic_83xx_lock_driver(adapter))
344 return -EBUSY;
345 QLCWRX(adapter->ahw, QLC_83XX_IDC_DRV_PRESENCE, val);
346 dev_info(&adapter->pdev->dev,
347 "%s: updated drv presence reg = 0x%x\n",
348 __func__, val);
349 qlcnic_83xx_unlock_driver(adapter);
350 return 0;
351
352 } else {
353 return 1;
354 }
355 } else {
356 dev_info(&adapter->pdev->dev,
357 "%s: Reset ACK received from all functions\n",
358 __func__);
359 return 0;
360 }
361 }
362
363 /**
364 * qlcnic_83xx_idc_tx_soft_reset
365 *
366 * @adapter: adapter structure
367 *
368 * Handle context deletion and recreation request from transmit routine
369 *
370 * Returns -EBUSY or Success (0)
371 *
372 **/
qlcnic_83xx_idc_tx_soft_reset(struct qlcnic_adapter * adapter)373 static int qlcnic_83xx_idc_tx_soft_reset(struct qlcnic_adapter *adapter)
374 {
375 struct net_device *netdev = adapter->netdev;
376
377 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
378 return -EBUSY;
379
380 netif_device_detach(netdev);
381 qlcnic_down(adapter, netdev);
382 qlcnic_up(adapter, netdev);
383 netif_device_attach(netdev);
384 clear_bit(__QLCNIC_RESETTING, &adapter->state);
385 netdev_info(adapter->netdev, "%s: soft reset complete.\n", __func__);
386
387 return 0;
388 }
389
390 /**
391 * qlcnic_83xx_idc_detach_driver
392 *
393 * @adapter: adapter structure
394 * Detach net interface, stop TX and cleanup resources before the HW reset.
395 * Returns: None
396 *
397 **/
qlcnic_83xx_idc_detach_driver(struct qlcnic_adapter * adapter)398 static void qlcnic_83xx_idc_detach_driver(struct qlcnic_adapter *adapter)
399 {
400 int i;
401 struct net_device *netdev = adapter->netdev;
402
403 netif_device_detach(netdev);
404 qlcnic_83xx_detach_mailbox_work(adapter);
405
406 /* Disable mailbox interrupt */
407 qlcnic_83xx_disable_mbx_intr(adapter);
408 qlcnic_down(adapter, netdev);
409 for (i = 0; i < adapter->ahw->num_msix; i++) {
410 adapter->ahw->intr_tbl[i].id = i;
411 adapter->ahw->intr_tbl[i].enabled = 0;
412 adapter->ahw->intr_tbl[i].src = 0;
413 }
414
415 if (qlcnic_sriov_pf_check(adapter))
416 qlcnic_sriov_pf_reset(adapter);
417 }
418
419 /**
420 * qlcnic_83xx_idc_attach_driver
421 *
422 * @adapter: adapter structure
423 *
424 * Re-attach and re-enable net interface
425 * Returns: None
426 *
427 **/
qlcnic_83xx_idc_attach_driver(struct qlcnic_adapter * adapter)428 static void qlcnic_83xx_idc_attach_driver(struct qlcnic_adapter *adapter)
429 {
430 struct net_device *netdev = adapter->netdev;
431
432 if (netif_running(netdev)) {
433 if (qlcnic_up(adapter, netdev))
434 goto done;
435 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
436 }
437 done:
438 netif_device_attach(netdev);
439 }
440
qlcnic_83xx_idc_enter_failed_state(struct qlcnic_adapter * adapter,int lock)441 static int qlcnic_83xx_idc_enter_failed_state(struct qlcnic_adapter *adapter,
442 int lock)
443 {
444 if (lock) {
445 if (qlcnic_83xx_lock_driver(adapter))
446 return -EBUSY;
447 }
448
449 qlcnic_83xx_idc_clear_registers(adapter, 0);
450 QLCWRX(adapter->ahw, QLC_83XX_IDC_DEV_STATE, QLC_83XX_IDC_DEV_FAILED);
451 if (lock)
452 qlcnic_83xx_unlock_driver(adapter);
453
454 qlcnic_83xx_idc_log_state_history(adapter);
455 dev_info(&adapter->pdev->dev, "Device will enter failed state\n");
456
457 return 0;
458 }
459
qlcnic_83xx_idc_enter_init_state(struct qlcnic_adapter * adapter,int lock)460 static int qlcnic_83xx_idc_enter_init_state(struct qlcnic_adapter *adapter,
461 int lock)
462 {
463 if (lock) {
464 if (qlcnic_83xx_lock_driver(adapter))
465 return -EBUSY;
466 }
467
468 QLCWRX(adapter->ahw, QLC_83XX_IDC_DEV_STATE, QLC_83XX_IDC_DEV_INIT);
469
470 if (lock)
471 qlcnic_83xx_unlock_driver(adapter);
472
473 return 0;
474 }
475
qlcnic_83xx_idc_enter_need_quiesce(struct qlcnic_adapter * adapter,int lock)476 static int qlcnic_83xx_idc_enter_need_quiesce(struct qlcnic_adapter *adapter,
477 int lock)
478 {
479 if (lock) {
480 if (qlcnic_83xx_lock_driver(adapter))
481 return -EBUSY;
482 }
483
484 QLCWRX(adapter->ahw, QLC_83XX_IDC_DEV_STATE,
485 QLC_83XX_IDC_DEV_NEED_QUISCENT);
486
487 if (lock)
488 qlcnic_83xx_unlock_driver(adapter);
489
490 return 0;
491 }
492
493 static int
qlcnic_83xx_idc_enter_need_reset_state(struct qlcnic_adapter * adapter,int lock)494 qlcnic_83xx_idc_enter_need_reset_state(struct qlcnic_adapter *adapter, int lock)
495 {
496 if (lock) {
497 if (qlcnic_83xx_lock_driver(adapter))
498 return -EBUSY;
499 }
500
501 QLCWRX(adapter->ahw, QLC_83XX_IDC_DEV_STATE,
502 QLC_83XX_IDC_DEV_NEED_RESET);
503
504 if (lock)
505 qlcnic_83xx_unlock_driver(adapter);
506
507 return 0;
508 }
509
qlcnic_83xx_idc_enter_ready_state(struct qlcnic_adapter * adapter,int lock)510 static int qlcnic_83xx_idc_enter_ready_state(struct qlcnic_adapter *adapter,
511 int lock)
512 {
513 if (lock) {
514 if (qlcnic_83xx_lock_driver(adapter))
515 return -EBUSY;
516 }
517
518 QLCWRX(adapter->ahw, QLC_83XX_IDC_DEV_STATE, QLC_83XX_IDC_DEV_READY);
519 if (lock)
520 qlcnic_83xx_unlock_driver(adapter);
521
522 return 0;
523 }
524
525 /**
526 * qlcnic_83xx_idc_find_reset_owner_id
527 *
528 * @adapter: adapter structure
529 *
530 * NIC gets precedence over ISCSI and ISCSI has precedence over FCOE.
531 * Within the same class, function with lowest PCI ID assumes ownership
532 *
533 * Returns: reset owner id or failure indication (-EIO)
534 *
535 **/
qlcnic_83xx_idc_find_reset_owner_id(struct qlcnic_adapter * adapter)536 static int qlcnic_83xx_idc_find_reset_owner_id(struct qlcnic_adapter *adapter)
537 {
538 u32 reg, reg1, reg2, i, j, owner, class;
539
540 reg1 = QLCRDX(adapter->ahw, QLC_83XX_IDC_DEV_PARTITION_INFO_1);
541 reg2 = QLCRDX(adapter->ahw, QLC_83XX_IDC_DEV_PARTITION_INFO_2);
542 owner = QLCNIC_TYPE_NIC;
543 i = 0;
544 j = 0;
545 reg = reg1;
546
547 do {
548 class = (((reg & (0xF << j * 4)) >> j * 4) & 0x3);
549 if (class == owner)
550 break;
551 if (i == (QLC_83XX_IDC_MAX_FUNC_PER_PARTITION_INFO - 1)) {
552 reg = reg2;
553 j = 0;
554 } else {
555 j++;
556 }
557
558 if (i == (QLC_83XX_IDC_MAX_CNA_FUNCTIONS - 1)) {
559 if (owner == QLCNIC_TYPE_NIC)
560 owner = QLCNIC_TYPE_ISCSI;
561 else if (owner == QLCNIC_TYPE_ISCSI)
562 owner = QLCNIC_TYPE_FCOE;
563 else if (owner == QLCNIC_TYPE_FCOE)
564 return -EIO;
565 reg = reg1;
566 j = 0;
567 i = 0;
568 }
569 } while (i++ < QLC_83XX_IDC_MAX_CNA_FUNCTIONS);
570
571 return i;
572 }
573
qlcnic_83xx_idc_restart_hw(struct qlcnic_adapter * adapter,int lock)574 static int qlcnic_83xx_idc_restart_hw(struct qlcnic_adapter *adapter, int lock)
575 {
576 int ret = 0;
577
578 ret = qlcnic_83xx_restart_hw(adapter);
579
580 if (ret) {
581 qlcnic_83xx_idc_enter_failed_state(adapter, lock);
582 } else {
583 qlcnic_83xx_idc_clear_registers(adapter, lock);
584 ret = qlcnic_83xx_idc_enter_ready_state(adapter, lock);
585 }
586
587 return ret;
588 }
589
qlcnic_83xx_idc_check_fan_failure(struct qlcnic_adapter * adapter)590 static int qlcnic_83xx_idc_check_fan_failure(struct qlcnic_adapter *adapter)
591 {
592 u32 status;
593
594 status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
595
596 if (status & QLCNIC_RCODE_FATAL_ERROR) {
597 dev_err(&adapter->pdev->dev,
598 "peg halt status1=0x%x\n", status);
599 if (QLCNIC_FWERROR_CODE(status) == QLCNIC_FWERROR_FAN_FAILURE) {
600 dev_err(&adapter->pdev->dev,
601 "On board active cooling fan failed. "
602 "Device has been halted.\n");
603 dev_err(&adapter->pdev->dev,
604 "Replace the adapter.\n");
605 return -EIO;
606 }
607 }
608
609 return 0;
610 }
611
qlcnic_83xx_idc_reattach_driver(struct qlcnic_adapter * adapter)612 int qlcnic_83xx_idc_reattach_driver(struct qlcnic_adapter *adapter)
613 {
614 int err;
615
616 qlcnic_83xx_reinit_mbx_work(adapter->ahw->mailbox);
617 qlcnic_83xx_enable_mbx_interrupt(adapter);
618
619 qlcnic_83xx_initialize_nic(adapter, 1);
620
621 err = qlcnic_sriov_pf_reinit(adapter);
622 if (err)
623 return err;
624
625 qlcnic_83xx_enable_mbx_interrupt(adapter);
626
627 if (qlcnic_83xx_configure_opmode(adapter)) {
628 qlcnic_83xx_idc_enter_failed_state(adapter, 1);
629 return -EIO;
630 }
631
632 if (adapter->nic_ops->init_driver(adapter)) {
633 qlcnic_83xx_idc_enter_failed_state(adapter, 1);
634 return -EIO;
635 }
636
637 if (adapter->portnum == 0)
638 qlcnic_set_drv_version(adapter);
639
640 qlcnic_dcb_get_info(adapter->dcb);
641 qlcnic_83xx_idc_attach_driver(adapter);
642
643 return 0;
644 }
645
qlcnic_83xx_idc_update_idc_params(struct qlcnic_adapter * adapter)646 static void qlcnic_83xx_idc_update_idc_params(struct qlcnic_adapter *adapter)
647 {
648 struct qlcnic_hardware_context *ahw = adapter->ahw;
649
650 qlcnic_83xx_idc_update_drv_presence_reg(adapter, 1, 1);
651 qlcnic_83xx_idc_update_audit_reg(adapter, 0, 1);
652 set_bit(QLC_83XX_MODULE_LOADED, &adapter->ahw->idc.status);
653
654 ahw->idc.quiesce_req = 0;
655 ahw->idc.delay = QLC_83XX_IDC_FW_POLL_DELAY;
656 ahw->idc.err_code = 0;
657 ahw->idc.collect_dump = 0;
658 ahw->reset_context = 0;
659 adapter->tx_timeo_cnt = 0;
660 ahw->idc.delay_reset = 0;
661
662 clear_bit(__QLCNIC_RESETTING, &adapter->state);
663 }
664
665 /**
666 * qlcnic_83xx_idc_ready_state_entry
667 *
668 * @adapter: adapter structure
669 *
670 * Perform ready state initialization, this routine will get invoked only
671 * once from READY state.
672 *
673 * Returns: Error code or Success(0)
674 *
675 **/
qlcnic_83xx_idc_ready_state_entry(struct qlcnic_adapter * adapter)676 int qlcnic_83xx_idc_ready_state_entry(struct qlcnic_adapter *adapter)
677 {
678 struct qlcnic_hardware_context *ahw = adapter->ahw;
679
680 if (ahw->idc.prev_state != QLC_83XX_IDC_DEV_READY) {
681 qlcnic_83xx_idc_update_idc_params(adapter);
682 /* Re-attach the device if required */
683 if ((ahw->idc.prev_state == QLC_83XX_IDC_DEV_NEED_RESET) ||
684 (ahw->idc.prev_state == QLC_83XX_IDC_DEV_INIT)) {
685 if (qlcnic_83xx_idc_reattach_driver(adapter))
686 return -EIO;
687 }
688 }
689
690 return 0;
691 }
692
693 /**
694 * qlcnic_83xx_idc_vnic_pf_entry
695 *
696 * @adapter: adapter structure
697 *
698 * Ensure vNIC mode privileged function starts only after vNIC mode is
699 * enabled by management function.
700 * If vNIC mode is ready, start initialization.
701 *
702 * Returns: -EIO or 0
703 *
704 **/
qlcnic_83xx_idc_vnic_pf_entry(struct qlcnic_adapter * adapter)705 int qlcnic_83xx_idc_vnic_pf_entry(struct qlcnic_adapter *adapter)
706 {
707 u32 state;
708 struct qlcnic_hardware_context *ahw = adapter->ahw;
709
710 /* Privileged function waits till mgmt function enables VNIC mode */
711 state = QLCRDX(adapter->ahw, QLC_83XX_VNIC_STATE);
712 if (state != QLCNIC_DEV_NPAR_OPER) {
713 if (!ahw->idc.vnic_wait_limit--) {
714 qlcnic_83xx_idc_enter_failed_state(adapter, 1);
715 return -EIO;
716 }
717 dev_info(&adapter->pdev->dev, "vNIC mode disabled\n");
718 return -EIO;
719
720 } else {
721 /* Perform one time initialization from ready state */
722 if (ahw->idc.vnic_state != QLCNIC_DEV_NPAR_OPER) {
723 qlcnic_83xx_idc_update_idc_params(adapter);
724
725 /* If the previous state is UNKNOWN, device will be
726 already attached properly by Init routine*/
727 if (ahw->idc.prev_state != QLC_83XX_IDC_DEV_UNKNOWN) {
728 if (qlcnic_83xx_idc_reattach_driver(adapter))
729 return -EIO;
730 }
731 adapter->ahw->idc.vnic_state = QLCNIC_DEV_NPAR_OPER;
732 dev_info(&adapter->pdev->dev, "vNIC mode enabled\n");
733 }
734 }
735
736 return 0;
737 }
738
qlcnic_83xx_idc_unknown_state(struct qlcnic_adapter * adapter)739 static int qlcnic_83xx_idc_unknown_state(struct qlcnic_adapter *adapter)
740 {
741 adapter->ahw->idc.err_code = -EIO;
742 dev_err(&adapter->pdev->dev,
743 "%s: Device in unknown state\n", __func__);
744 clear_bit(__QLCNIC_RESETTING, &adapter->state);
745 return 0;
746 }
747
748 /**
749 * qlcnic_83xx_idc_cold_state_handler
750 *
751 * @adapter: adapter structure
752 *
753 * If HW is up and running device will enter READY state.
754 * If firmware image from host needs to be loaded, device is
755 * forced to start with the file firmware image.
756 *
757 * Returns: Error code or Success(0)
758 *
759 **/
qlcnic_83xx_idc_cold_state_handler(struct qlcnic_adapter * adapter)760 static int qlcnic_83xx_idc_cold_state_handler(struct qlcnic_adapter *adapter)
761 {
762 qlcnic_83xx_idc_update_drv_presence_reg(adapter, 1, 0);
763 qlcnic_83xx_idc_update_audit_reg(adapter, 1, 0);
764
765 if (qlcnic_load_fw_file) {
766 qlcnic_83xx_idc_restart_hw(adapter, 0);
767 } else {
768 if (qlcnic_83xx_check_hw_status(adapter)) {
769 qlcnic_83xx_idc_enter_failed_state(adapter, 0);
770 return -EIO;
771 } else {
772 qlcnic_83xx_idc_enter_ready_state(adapter, 0);
773 }
774 }
775 return 0;
776 }
777
778 /**
779 * qlcnic_83xx_idc_init_state
780 *
781 * @adapter: adapter structure
782 *
783 * Reset owner will restart the device from this state.
784 * Device will enter failed state if it remains
785 * in this state for more than DEV_INIT time limit.
786 *
787 * Returns: Error code or Success(0)
788 *
789 **/
qlcnic_83xx_idc_init_state(struct qlcnic_adapter * adapter)790 static int qlcnic_83xx_idc_init_state(struct qlcnic_adapter *adapter)
791 {
792 int timeout, ret = 0;
793 u32 owner;
794
795 timeout = QLC_83XX_IDC_INIT_TIMEOUT_SECS;
796 if (adapter->ahw->idc.prev_state == QLC_83XX_IDC_DEV_NEED_RESET) {
797 owner = qlcnic_83xx_idc_find_reset_owner_id(adapter);
798 if (adapter->ahw->pci_func == owner)
799 ret = qlcnic_83xx_idc_restart_hw(adapter, 1);
800 } else {
801 ret = qlcnic_83xx_idc_check_timeout(adapter, timeout);
802 }
803
804 return ret;
805 }
806
807 /**
808 * qlcnic_83xx_idc_ready_state
809 *
810 * @adapter: adapter structure
811 *
812 * Perform IDC protocol specicifed actions after monitoring device state and
813 * events.
814 *
815 * Returns: Error code or Success(0)
816 *
817 **/
qlcnic_83xx_idc_ready_state(struct qlcnic_adapter * adapter)818 static int qlcnic_83xx_idc_ready_state(struct qlcnic_adapter *adapter)
819 {
820 struct qlcnic_hardware_context *ahw = adapter->ahw;
821 struct qlcnic_mailbox *mbx = ahw->mailbox;
822 int ret = 0;
823 u32 val;
824
825 /* Perform NIC configuration based ready state entry actions */
826 if (ahw->idc.state_entry(adapter))
827 return -EIO;
828
829 if (qlcnic_check_temp(adapter)) {
830 if (ahw->temp == QLCNIC_TEMP_PANIC) {
831 qlcnic_83xx_idc_check_fan_failure(adapter);
832 dev_err(&adapter->pdev->dev,
833 "Error: device temperature %d above limits\n",
834 adapter->ahw->temp);
835 clear_bit(QLC_83XX_MBX_READY, &mbx->status);
836 set_bit(__QLCNIC_RESETTING, &adapter->state);
837 qlcnic_83xx_idc_detach_driver(adapter);
838 qlcnic_83xx_idc_enter_failed_state(adapter, 1);
839 return -EIO;
840 }
841 }
842
843 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
844 ret = qlcnic_83xx_check_heartbeat(adapter);
845 if (ret) {
846 adapter->flags |= QLCNIC_FW_HANG;
847 if (!(val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY)) {
848 clear_bit(QLC_83XX_MBX_READY, &mbx->status);
849 set_bit(__QLCNIC_RESETTING, &adapter->state);
850 qlcnic_83xx_idc_enter_need_reset_state(adapter, 1);
851 } else {
852 netdev_info(adapter->netdev, "%s: Auto firmware recovery is disabled\n",
853 __func__);
854 qlcnic_83xx_idc_enter_failed_state(adapter, 1);
855 }
856 return -EIO;
857 }
858
859 if ((val & QLC_83XX_IDC_GRACEFULL_RESET) || ahw->idc.collect_dump) {
860 clear_bit(QLC_83XX_MBX_READY, &mbx->status);
861
862 /* Move to need reset state and prepare for reset */
863 qlcnic_83xx_idc_enter_need_reset_state(adapter, 1);
864 return ret;
865 }
866
867 /* Check for soft reset request */
868 if (ahw->reset_context &&
869 !(val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY)) {
870 adapter->ahw->reset_context = 0;
871 qlcnic_83xx_idc_tx_soft_reset(adapter);
872 return ret;
873 }
874
875 /* Move to need quiesce state if requested */
876 if (adapter->ahw->idc.quiesce_req) {
877 qlcnic_83xx_idc_enter_need_quiesce(adapter, 1);
878 qlcnic_83xx_idc_update_audit_reg(adapter, 0, 1);
879 return ret;
880 }
881
882 return ret;
883 }
884
885 /**
886 * qlcnic_83xx_idc_need_reset_state
887 *
888 * @adapter: adapter structure
889 *
890 * Device will remain in this state until:
891 * Reset request ACK's are received from all the functions
892 * Wait time exceeds max time limit
893 *
894 * Returns: Error code or Success(0)
895 *
896 **/
qlcnic_83xx_idc_need_reset_state(struct qlcnic_adapter * adapter)897 static int qlcnic_83xx_idc_need_reset_state(struct qlcnic_adapter *adapter)
898 {
899 struct qlcnic_mailbox *mbx = adapter->ahw->mailbox;
900 int ret = 0;
901
902 if (adapter->ahw->idc.prev_state != QLC_83XX_IDC_DEV_NEED_RESET) {
903 qlcnic_83xx_idc_update_audit_reg(adapter, 0, 1);
904 set_bit(__QLCNIC_RESETTING, &adapter->state);
905 clear_bit(QLC_83XX_MBX_READY, &mbx->status);
906 if (adapter->ahw->nic_mode == QLCNIC_VNIC_MODE)
907 qlcnic_83xx_disable_vnic_mode(adapter, 1);
908
909 if (qlcnic_check_diag_status(adapter)) {
910 dev_info(&adapter->pdev->dev,
911 "%s: Wait for diag completion\n", __func__);
912 adapter->ahw->idc.delay_reset = 1;
913 return 0;
914 } else {
915 qlcnic_83xx_idc_update_drv_ack_reg(adapter, 1, 1);
916 qlcnic_83xx_idc_detach_driver(adapter);
917 }
918 }
919
920 if (qlcnic_check_diag_status(adapter)) {
921 dev_info(&adapter->pdev->dev,
922 "%s: Wait for diag completion\n", __func__);
923 return -1;
924 } else {
925 if (adapter->ahw->idc.delay_reset) {
926 qlcnic_83xx_idc_update_drv_ack_reg(adapter, 1, 1);
927 qlcnic_83xx_idc_detach_driver(adapter);
928 adapter->ahw->idc.delay_reset = 0;
929 }
930
931 /* Check for ACK from other functions */
932 ret = qlcnic_83xx_idc_check_reset_ack_reg(adapter);
933 if (ret) {
934 dev_info(&adapter->pdev->dev,
935 "%s: Waiting for reset ACK\n", __func__);
936 return -1;
937 }
938 }
939
940 /* Transit to INIT state and restart the HW */
941 qlcnic_83xx_idc_enter_init_state(adapter, 1);
942
943 return ret;
944 }
945
qlcnic_83xx_idc_need_quiesce_state(struct qlcnic_adapter * adapter)946 static int qlcnic_83xx_idc_need_quiesce_state(struct qlcnic_adapter *adapter)
947 {
948 dev_err(&adapter->pdev->dev, "%s: TBD\n", __func__);
949 return 0;
950 }
951
qlcnic_83xx_idc_failed_state(struct qlcnic_adapter * adapter)952 static void qlcnic_83xx_idc_failed_state(struct qlcnic_adapter *adapter)
953 {
954 struct qlcnic_hardware_context *ahw = adapter->ahw;
955 u32 val, owner;
956
957 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
958 if (val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY) {
959 owner = qlcnic_83xx_idc_find_reset_owner_id(adapter);
960 if (ahw->pci_func == owner) {
961 qlcnic_83xx_stop_hw(adapter);
962 qlcnic_dump_fw(adapter);
963 }
964 }
965
966 netdev_warn(adapter->netdev, "%s: Reboot will be required to recover the adapter!!\n",
967 __func__);
968 clear_bit(__QLCNIC_RESETTING, &adapter->state);
969 ahw->idc.err_code = -EIO;
970
971 return;
972 }
973
qlcnic_83xx_idc_quiesce_state(struct qlcnic_adapter * adapter)974 static int qlcnic_83xx_idc_quiesce_state(struct qlcnic_adapter *adapter)
975 {
976 dev_info(&adapter->pdev->dev, "%s: TBD\n", __func__);
977 return 0;
978 }
979
qlcnic_83xx_idc_check_state_validity(struct qlcnic_adapter * adapter,u32 state)980 static int qlcnic_83xx_idc_check_state_validity(struct qlcnic_adapter *adapter,
981 u32 state)
982 {
983 u32 cur, prev, next;
984
985 cur = adapter->ahw->idc.curr_state;
986 prev = adapter->ahw->idc.prev_state;
987 next = state;
988
989 if ((next < QLC_83XX_IDC_DEV_COLD) ||
990 (next > QLC_83XX_IDC_DEV_QUISCENT)) {
991 dev_err(&adapter->pdev->dev,
992 "%s: curr %d, prev %d, next state %d is invalid\n",
993 __func__, cur, prev, state);
994 return 1;
995 }
996
997 if ((cur == QLC_83XX_IDC_DEV_UNKNOWN) &&
998 (prev == QLC_83XX_IDC_DEV_UNKNOWN)) {
999 if ((next != QLC_83XX_IDC_DEV_COLD) &&
1000 (next != QLC_83XX_IDC_DEV_READY)) {
1001 dev_err(&adapter->pdev->dev,
1002 "%s: failed, cur %d prev %d next %d\n",
1003 __func__, cur, prev, next);
1004 return 1;
1005 }
1006 }
1007
1008 if (next == QLC_83XX_IDC_DEV_INIT) {
1009 if ((prev != QLC_83XX_IDC_DEV_INIT) &&
1010 (prev != QLC_83XX_IDC_DEV_COLD) &&
1011 (prev != QLC_83XX_IDC_DEV_NEED_RESET)) {
1012 dev_err(&adapter->pdev->dev,
1013 "%s: failed, cur %d prev %d next %d\n",
1014 __func__, cur, prev, next);
1015 return 1;
1016 }
1017 }
1018
1019 return 0;
1020 }
1021
1022 #define QLC_83XX_ENCAP_TYPE_VXLAN BIT_1
1023 #define QLC_83XX_MATCH_ENCAP_ID BIT_2
1024 #define QLC_83XX_SET_VXLAN_UDP_DPORT BIT_3
1025 #define QLC_83XX_VXLAN_UDP_DPORT(PORT) ((PORT & 0xffff) << 16)
1026
1027 #define QLCNIC_ENABLE_INGRESS_ENCAP_PARSING 1
1028 #define QLCNIC_DISABLE_INGRESS_ENCAP_PARSING 0
1029
qlcnic_set_vxlan_port(struct qlcnic_adapter * adapter,u16 port)1030 int qlcnic_set_vxlan_port(struct qlcnic_adapter *adapter, u16 port)
1031 {
1032 struct qlcnic_cmd_args cmd;
1033 int ret = 0;
1034
1035 memset(&cmd, 0, sizeof(cmd));
1036
1037 ret = qlcnic_alloc_mbx_args(&cmd, adapter,
1038 QLCNIC_CMD_INIT_NIC_FUNC);
1039 if (ret)
1040 return ret;
1041
1042 cmd.req.arg[1] = QLC_83XX_MULTI_TENANCY_INFO;
1043 cmd.req.arg[2] = QLC_83XX_ENCAP_TYPE_VXLAN |
1044 QLC_83XX_SET_VXLAN_UDP_DPORT |
1045 QLC_83XX_VXLAN_UDP_DPORT(port);
1046
1047 ret = qlcnic_issue_cmd(adapter, &cmd);
1048 if (ret)
1049 netdev_err(adapter->netdev,
1050 "Failed to set VXLAN port %d in adapter\n",
1051 port);
1052
1053 qlcnic_free_mbx_args(&cmd);
1054
1055 return ret;
1056 }
1057
qlcnic_set_vxlan_parsing(struct qlcnic_adapter * adapter,u16 port)1058 int qlcnic_set_vxlan_parsing(struct qlcnic_adapter *adapter, u16 port)
1059 {
1060 struct qlcnic_cmd_args cmd;
1061 int ret = 0;
1062
1063 memset(&cmd, 0, sizeof(cmd));
1064
1065 ret = qlcnic_alloc_mbx_args(&cmd, adapter,
1066 QLCNIC_CMD_SET_INGRESS_ENCAP);
1067 if (ret)
1068 return ret;
1069
1070 cmd.req.arg[1] = port ? QLCNIC_ENABLE_INGRESS_ENCAP_PARSING :
1071 QLCNIC_DISABLE_INGRESS_ENCAP_PARSING;
1072
1073 ret = qlcnic_issue_cmd(adapter, &cmd);
1074 if (ret)
1075 netdev_err(adapter->netdev,
1076 "Failed to %s VXLAN parsing for port %d\n",
1077 port ? "enable" : "disable", port);
1078 else
1079 netdev_info(adapter->netdev,
1080 "%s VXLAN parsing for port %d\n",
1081 port ? "Enabled" : "Disabled", port);
1082
1083 qlcnic_free_mbx_args(&cmd);
1084
1085 return ret;
1086 }
1087
qlcnic_83xx_periodic_tasks(struct qlcnic_adapter * adapter)1088 static void qlcnic_83xx_periodic_tasks(struct qlcnic_adapter *adapter)
1089 {
1090 if (adapter->fhash.fnum)
1091 qlcnic_prune_lb_filters(adapter);
1092 }
1093
1094 /**
1095 * qlcnic_83xx_idc_poll_dev_state
1096 *
1097 * @work: kernel work queue structure used to schedule the function
1098 *
1099 * Poll device state periodically and perform state specific
1100 * actions defined by Inter Driver Communication (IDC) protocol.
1101 *
1102 * Returns: None
1103 *
1104 **/
qlcnic_83xx_idc_poll_dev_state(struct work_struct * work)1105 void qlcnic_83xx_idc_poll_dev_state(struct work_struct *work)
1106 {
1107 struct qlcnic_adapter *adapter;
1108 u32 state;
1109
1110 adapter = container_of(work, struct qlcnic_adapter, fw_work.work);
1111 state = QLCRDX(adapter->ahw, QLC_83XX_IDC_DEV_STATE);
1112
1113 if (qlcnic_83xx_idc_check_state_validity(adapter, state)) {
1114 qlcnic_83xx_idc_log_state_history(adapter);
1115 adapter->ahw->idc.curr_state = QLC_83XX_IDC_DEV_UNKNOWN;
1116 } else {
1117 adapter->ahw->idc.curr_state = state;
1118 }
1119
1120 switch (adapter->ahw->idc.curr_state) {
1121 case QLC_83XX_IDC_DEV_READY:
1122 qlcnic_83xx_idc_ready_state(adapter);
1123 break;
1124 case QLC_83XX_IDC_DEV_NEED_RESET:
1125 qlcnic_83xx_idc_need_reset_state(adapter);
1126 break;
1127 case QLC_83XX_IDC_DEV_NEED_QUISCENT:
1128 qlcnic_83xx_idc_need_quiesce_state(adapter);
1129 break;
1130 case QLC_83XX_IDC_DEV_FAILED:
1131 qlcnic_83xx_idc_failed_state(adapter);
1132 return;
1133 case QLC_83XX_IDC_DEV_INIT:
1134 qlcnic_83xx_idc_init_state(adapter);
1135 break;
1136 case QLC_83XX_IDC_DEV_QUISCENT:
1137 qlcnic_83xx_idc_quiesce_state(adapter);
1138 break;
1139 default:
1140 qlcnic_83xx_idc_unknown_state(adapter);
1141 return;
1142 }
1143 adapter->ahw->idc.prev_state = adapter->ahw->idc.curr_state;
1144 qlcnic_83xx_periodic_tasks(adapter);
1145
1146 /* Re-schedule the function */
1147 if (test_bit(QLC_83XX_MODULE_LOADED, &adapter->ahw->idc.status))
1148 qlcnic_schedule_work(adapter, qlcnic_83xx_idc_poll_dev_state,
1149 adapter->ahw->idc.delay);
1150 }
1151
qlcnic_83xx_setup_idc_parameters(struct qlcnic_adapter * adapter)1152 static void qlcnic_83xx_setup_idc_parameters(struct qlcnic_adapter *adapter)
1153 {
1154 u32 idc_params, val;
1155
1156 if (qlcnic_83xx_flash_read32(adapter, QLC_83XX_IDC_FLASH_PARAM_ADDR,
1157 (u8 *)&idc_params, 1)) {
1158 dev_info(&adapter->pdev->dev,
1159 "%s:failed to get IDC params from flash\n", __func__);
1160 adapter->dev_init_timeo = QLC_83XX_IDC_INIT_TIMEOUT_SECS;
1161 adapter->reset_ack_timeo = QLC_83XX_IDC_RESET_TIMEOUT_SECS;
1162 } else {
1163 adapter->dev_init_timeo = idc_params & 0xFFFF;
1164 adapter->reset_ack_timeo = ((idc_params >> 16) & 0xFFFF);
1165 }
1166
1167 adapter->ahw->idc.curr_state = QLC_83XX_IDC_DEV_UNKNOWN;
1168 adapter->ahw->idc.prev_state = QLC_83XX_IDC_DEV_UNKNOWN;
1169 adapter->ahw->idc.delay = QLC_83XX_IDC_FW_POLL_DELAY;
1170 adapter->ahw->idc.err_code = 0;
1171 adapter->ahw->idc.collect_dump = 0;
1172 adapter->ahw->idc.name = (char **)qlc_83xx_idc_states;
1173
1174 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1175 set_bit(QLC_83XX_MODULE_LOADED, &adapter->ahw->idc.status);
1176
1177 /* Check if reset recovery is disabled */
1178 if (!qlcnic_auto_fw_reset) {
1179 /* Propagate do not reset request to other functions */
1180 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
1181 val = val | QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY;
1182 QLCWRX(adapter->ahw, QLC_83XX_IDC_CTRL, val);
1183 }
1184 }
1185
1186 static int
qlcnic_83xx_idc_first_to_load_function_handler(struct qlcnic_adapter * adapter)1187 qlcnic_83xx_idc_first_to_load_function_handler(struct qlcnic_adapter *adapter)
1188 {
1189 u32 state, val;
1190
1191 if (qlcnic_83xx_lock_driver(adapter))
1192 return -EIO;
1193
1194 /* Clear driver lock register */
1195 QLCWRX(adapter->ahw, QLC_83XX_RECOVER_DRV_LOCK, 0);
1196 if (qlcnic_83xx_idc_update_major_version(adapter, 0)) {
1197 qlcnic_83xx_unlock_driver(adapter);
1198 return -EIO;
1199 }
1200
1201 state = QLCRDX(adapter->ahw, QLC_83XX_IDC_DEV_STATE);
1202 if (qlcnic_83xx_idc_check_state_validity(adapter, state)) {
1203 qlcnic_83xx_unlock_driver(adapter);
1204 return -EIO;
1205 }
1206
1207 if (state != QLC_83XX_IDC_DEV_COLD && qlcnic_load_fw_file) {
1208 QLCWRX(adapter->ahw, QLC_83XX_IDC_DEV_STATE,
1209 QLC_83XX_IDC_DEV_COLD);
1210 state = QLC_83XX_IDC_DEV_COLD;
1211 }
1212
1213 adapter->ahw->idc.curr_state = state;
1214 /* First to load function should cold boot the device */
1215 if (state == QLC_83XX_IDC_DEV_COLD)
1216 qlcnic_83xx_idc_cold_state_handler(adapter);
1217
1218 /* Check if reset recovery is enabled */
1219 if (qlcnic_auto_fw_reset) {
1220 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
1221 val = val & ~QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY;
1222 QLCWRX(adapter->ahw, QLC_83XX_IDC_CTRL, val);
1223 }
1224
1225 qlcnic_83xx_unlock_driver(adapter);
1226
1227 return 0;
1228 }
1229
qlcnic_83xx_idc_init(struct qlcnic_adapter * adapter)1230 int qlcnic_83xx_idc_init(struct qlcnic_adapter *adapter)
1231 {
1232 int ret = -EIO;
1233
1234 qlcnic_83xx_setup_idc_parameters(adapter);
1235
1236 if (qlcnic_83xx_get_reset_instruction_template(adapter))
1237 return ret;
1238
1239 if (!qlcnic_83xx_idc_check_driver_presence_reg(adapter)) {
1240 if (qlcnic_83xx_idc_first_to_load_function_handler(adapter))
1241 return -EIO;
1242 } else {
1243 if (qlcnic_83xx_idc_check_major_version(adapter))
1244 return -EIO;
1245 }
1246
1247 qlcnic_83xx_idc_update_audit_reg(adapter, 0, 1);
1248
1249 return 0;
1250 }
1251
qlcnic_83xx_idc_exit(struct qlcnic_adapter * adapter)1252 void qlcnic_83xx_idc_exit(struct qlcnic_adapter *adapter)
1253 {
1254 int id;
1255 u32 val;
1256
1257 while (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1258 usleep_range(10000, 11000);
1259
1260 id = QLCRDX(adapter->ahw, QLC_83XX_DRV_LOCK_ID);
1261 id = id & 0xFF;
1262
1263 if (id == adapter->portnum) {
1264 dev_err(&adapter->pdev->dev,
1265 "%s: wait for lock recovery.. %d\n", __func__, id);
1266 msleep(20);
1267 id = QLCRDX(adapter->ahw, QLC_83XX_DRV_LOCK_ID);
1268 id = id & 0xFF;
1269 }
1270
1271 /* Clear driver presence bit */
1272 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_DRV_PRESENCE);
1273 val = val & ~(1 << adapter->portnum);
1274 QLCWRX(adapter->ahw, QLC_83XX_IDC_DRV_PRESENCE, val);
1275 clear_bit(QLC_83XX_MODULE_LOADED, &adapter->ahw->idc.status);
1276 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1277
1278 cancel_delayed_work_sync(&adapter->fw_work);
1279 }
1280
qlcnic_83xx_idc_request_reset(struct qlcnic_adapter * adapter,u32 key)1281 void qlcnic_83xx_idc_request_reset(struct qlcnic_adapter *adapter, u32 key)
1282 {
1283 u32 val;
1284
1285 if (qlcnic_sriov_vf_check(adapter))
1286 return;
1287
1288 if (qlcnic_83xx_lock_driver(adapter)) {
1289 dev_err(&adapter->pdev->dev,
1290 "%s:failed, please retry\n", __func__);
1291 return;
1292 }
1293
1294 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
1295 if (val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY) {
1296 netdev_info(adapter->netdev, "%s: Auto firmware recovery is disabled\n",
1297 __func__);
1298 qlcnic_83xx_idc_enter_failed_state(adapter, 0);
1299 qlcnic_83xx_unlock_driver(adapter);
1300 return;
1301 }
1302
1303 if (key == QLCNIC_FORCE_FW_RESET) {
1304 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
1305 val = val | QLC_83XX_IDC_GRACEFULL_RESET;
1306 QLCWRX(adapter->ahw, QLC_83XX_IDC_CTRL, val);
1307 } else if (key == QLCNIC_FORCE_FW_DUMP_KEY) {
1308 adapter->ahw->idc.collect_dump = 1;
1309 }
1310
1311 qlcnic_83xx_unlock_driver(adapter);
1312 return;
1313 }
1314
qlcnic_83xx_copy_bootloader(struct qlcnic_adapter * adapter)1315 static int qlcnic_83xx_copy_bootloader(struct qlcnic_adapter *adapter)
1316 {
1317 u8 *p_cache;
1318 u32 src, size;
1319 u64 dest;
1320 int ret = -EIO;
1321
1322 src = QLC_83XX_BOOTLOADER_FLASH_ADDR;
1323 dest = QLCRDX(adapter->ahw, QLCNIC_BOOTLOADER_ADDR);
1324 size = QLCRDX(adapter->ahw, QLCNIC_BOOTLOADER_SIZE);
1325
1326 /* alignment check */
1327 if (size & 0xF)
1328 size = (size + 16) & ~0xF;
1329
1330 p_cache = vzalloc(size);
1331 if (p_cache == NULL)
1332 return -ENOMEM;
1333
1334 ret = qlcnic_83xx_lockless_flash_read32(adapter, src, p_cache,
1335 size / sizeof(u32));
1336 if (ret) {
1337 vfree(p_cache);
1338 return ret;
1339 }
1340 /* 16 byte write to MS memory */
1341 ret = qlcnic_ms_mem_write128(adapter, dest, (u32 *)p_cache,
1342 size / 16);
1343 if (ret) {
1344 vfree(p_cache);
1345 return ret;
1346 }
1347 vfree(p_cache);
1348
1349 return ret;
1350 }
1351
qlcnic_83xx_copy_fw_file(struct qlcnic_adapter * adapter)1352 static int qlcnic_83xx_copy_fw_file(struct qlcnic_adapter *adapter)
1353 {
1354 struct qlc_83xx_fw_info *fw_info = adapter->ahw->fw_info;
1355 const struct firmware *fw = fw_info->fw;
1356 u32 dest, *p_cache, *temp;
1357 __le32 *temp_le;
1358 u8 data[16];
1359 size_t size;
1360 int i, ret;
1361 u64 addr;
1362
1363 temp = vzalloc(fw->size);
1364 if (!temp) {
1365 release_firmware(fw);
1366 fw_info->fw = NULL;
1367 return -ENOMEM;
1368 }
1369
1370 temp_le = (__le32 *)fw->data;
1371
1372 /* FW image in file is in little endian, swap the data to nullify
1373 * the effect of writel() operation on big endian platform.
1374 */
1375 for (i = 0; i < fw->size / sizeof(u32); i++)
1376 temp[i] = __le32_to_cpu(temp_le[i]);
1377
1378 dest = QLCRDX(adapter->ahw, QLCNIC_FW_IMAGE_ADDR);
1379 size = (fw->size & ~0xF);
1380 p_cache = temp;
1381 addr = (u64)dest;
1382
1383 ret = qlcnic_ms_mem_write128(adapter, addr,
1384 p_cache, size / 16);
1385 if (ret) {
1386 dev_err(&adapter->pdev->dev, "MS memory write failed\n");
1387 goto exit;
1388 }
1389
1390 /* alignment check */
1391 if (fw->size & 0xF) {
1392 addr = dest + size;
1393 for (i = 0; i < (fw->size & 0xF); i++)
1394 data[i] = ((u8 *)temp)[size + i];
1395 for (; i < 16; i++)
1396 data[i] = 0;
1397 ret = qlcnic_ms_mem_write128(adapter, addr,
1398 (u32 *)data, 1);
1399 if (ret) {
1400 dev_err(&adapter->pdev->dev,
1401 "MS memory write failed\n");
1402 goto exit;
1403 }
1404 }
1405
1406 exit:
1407 release_firmware(fw);
1408 fw_info->fw = NULL;
1409 vfree(temp);
1410
1411 return ret;
1412 }
1413
qlcnic_83xx_dump_pause_control_regs(struct qlcnic_adapter * adapter)1414 static void qlcnic_83xx_dump_pause_control_regs(struct qlcnic_adapter *adapter)
1415 {
1416 int i, j;
1417 u32 val = 0, val1 = 0, reg = 0;
1418 int err = 0;
1419
1420 val = QLCRD32(adapter, QLC_83XX_SRE_SHIM_REG, &err);
1421 if (err == -EIO)
1422 return;
1423 dev_info(&adapter->pdev->dev, "SRE-Shim Ctrl:0x%x\n", val);
1424
1425 for (j = 0; j < 2; j++) {
1426 if (j == 0) {
1427 dev_info(&adapter->pdev->dev,
1428 "Port 0 RxB Pause Threshold Regs[TC7..TC0]:");
1429 reg = QLC_83XX_PORT0_THRESHOLD;
1430 } else if (j == 1) {
1431 dev_info(&adapter->pdev->dev,
1432 "Port 1 RxB Pause Threshold Regs[TC7..TC0]:");
1433 reg = QLC_83XX_PORT1_THRESHOLD;
1434 }
1435 for (i = 0; i < 8; i++) {
1436 val = QLCRD32(adapter, reg + (i * 0x4), &err);
1437 if (err == -EIO)
1438 return;
1439 dev_info(&adapter->pdev->dev, "0x%x ", val);
1440 }
1441 dev_info(&adapter->pdev->dev, "\n");
1442 }
1443
1444 for (j = 0; j < 2; j++) {
1445 if (j == 0) {
1446 dev_info(&adapter->pdev->dev,
1447 "Port 0 RxB TC Max Cell Registers[4..1]:");
1448 reg = QLC_83XX_PORT0_TC_MC_REG;
1449 } else if (j == 1) {
1450 dev_info(&adapter->pdev->dev,
1451 "Port 1 RxB TC Max Cell Registers[4..1]:");
1452 reg = QLC_83XX_PORT1_TC_MC_REG;
1453 }
1454 for (i = 0; i < 4; i++) {
1455 val = QLCRD32(adapter, reg + (i * 0x4), &err);
1456 if (err == -EIO)
1457 return;
1458 dev_info(&adapter->pdev->dev, "0x%x ", val);
1459 }
1460 dev_info(&adapter->pdev->dev, "\n");
1461 }
1462
1463 for (j = 0; j < 2; j++) {
1464 if (j == 0) {
1465 dev_info(&adapter->pdev->dev,
1466 "Port 0 RxB Rx TC Stats[TC7..TC0]:");
1467 reg = QLC_83XX_PORT0_TC_STATS;
1468 } else if (j == 1) {
1469 dev_info(&adapter->pdev->dev,
1470 "Port 1 RxB Rx TC Stats[TC7..TC0]:");
1471 reg = QLC_83XX_PORT1_TC_STATS;
1472 }
1473 for (i = 7; i >= 0; i--) {
1474 val = QLCRD32(adapter, reg, &err);
1475 if (err == -EIO)
1476 return;
1477 val &= ~(0x7 << 29); /* Reset bits 29 to 31 */
1478 QLCWR32(adapter, reg, (val | (i << 29)));
1479 val = QLCRD32(adapter, reg, &err);
1480 if (err == -EIO)
1481 return;
1482 dev_info(&adapter->pdev->dev, "0x%x ", val);
1483 }
1484 dev_info(&adapter->pdev->dev, "\n");
1485 }
1486
1487 val = QLCRD32(adapter, QLC_83XX_PORT2_IFB_THRESHOLD, &err);
1488 if (err == -EIO)
1489 return;
1490 val1 = QLCRD32(adapter, QLC_83XX_PORT3_IFB_THRESHOLD, &err);
1491 if (err == -EIO)
1492 return;
1493 dev_info(&adapter->pdev->dev,
1494 "IFB-Pause Thresholds: Port 2:0x%x, Port 3:0x%x\n",
1495 val, val1);
1496 }
1497
1498
qlcnic_83xx_disable_pause_frames(struct qlcnic_adapter * adapter)1499 static void qlcnic_83xx_disable_pause_frames(struct qlcnic_adapter *adapter)
1500 {
1501 u32 reg = 0, i, j;
1502
1503 if (qlcnic_83xx_lock_driver(adapter)) {
1504 dev_err(&adapter->pdev->dev,
1505 "%s:failed to acquire driver lock\n", __func__);
1506 return;
1507 }
1508
1509 qlcnic_83xx_dump_pause_control_regs(adapter);
1510 QLCWR32(adapter, QLC_83XX_SRE_SHIM_REG, 0x0);
1511
1512 for (j = 0; j < 2; j++) {
1513 if (j == 0)
1514 reg = QLC_83XX_PORT0_THRESHOLD;
1515 else if (j == 1)
1516 reg = QLC_83XX_PORT1_THRESHOLD;
1517
1518 for (i = 0; i < 8; i++)
1519 QLCWR32(adapter, reg + (i * 0x4), 0x0);
1520 }
1521
1522 for (j = 0; j < 2; j++) {
1523 if (j == 0)
1524 reg = QLC_83XX_PORT0_TC_MC_REG;
1525 else if (j == 1)
1526 reg = QLC_83XX_PORT1_TC_MC_REG;
1527
1528 for (i = 0; i < 4; i++)
1529 QLCWR32(adapter, reg + (i * 0x4), 0x03FF03FF);
1530 }
1531
1532 QLCWR32(adapter, QLC_83XX_PORT2_IFB_THRESHOLD, 0);
1533 QLCWR32(adapter, QLC_83XX_PORT3_IFB_THRESHOLD, 0);
1534 dev_info(&adapter->pdev->dev,
1535 "Disabled pause frames successfully on all ports\n");
1536 qlcnic_83xx_unlock_driver(adapter);
1537 }
1538
qlcnic_83xx_take_eport_out_of_reset(struct qlcnic_adapter * adapter)1539 static void qlcnic_83xx_take_eport_out_of_reset(struct qlcnic_adapter *adapter)
1540 {
1541 QLCWR32(adapter, QLC_83XX_RESET_REG, 0);
1542 QLCWR32(adapter, QLC_83XX_RESET_PORT0, 0);
1543 QLCWR32(adapter, QLC_83XX_RESET_PORT1, 0);
1544 QLCWR32(adapter, QLC_83XX_RESET_PORT2, 0);
1545 QLCWR32(adapter, QLC_83XX_RESET_PORT3, 0);
1546 QLCWR32(adapter, QLC_83XX_RESET_SRESHIM, 0);
1547 QLCWR32(adapter, QLC_83XX_RESET_EPGSHIM, 0);
1548 QLCWR32(adapter, QLC_83XX_RESET_ETHERPCS, 0);
1549 QLCWR32(adapter, QLC_83XX_RESET_CONTROL, 1);
1550 }
1551
qlcnic_83xx_check_heartbeat(struct qlcnic_adapter * p_dev)1552 static int qlcnic_83xx_check_heartbeat(struct qlcnic_adapter *p_dev)
1553 {
1554 u32 heartbeat, peg_status;
1555 int retries, ret = -EIO, err = 0;
1556
1557 retries = QLCNIC_HEARTBEAT_CHECK_RETRY_COUNT;
1558 p_dev->heartbeat = QLC_SHARED_REG_RD32(p_dev,
1559 QLCNIC_PEG_ALIVE_COUNTER);
1560
1561 do {
1562 msleep(QLCNIC_HEARTBEAT_PERIOD_MSECS);
1563 heartbeat = QLC_SHARED_REG_RD32(p_dev,
1564 QLCNIC_PEG_ALIVE_COUNTER);
1565 if (heartbeat != p_dev->heartbeat) {
1566 ret = QLCNIC_RCODE_SUCCESS;
1567 break;
1568 }
1569 } while (--retries);
1570
1571 if (ret) {
1572 dev_err(&p_dev->pdev->dev, "firmware hang detected\n");
1573 qlcnic_83xx_take_eport_out_of_reset(p_dev);
1574 qlcnic_83xx_disable_pause_frames(p_dev);
1575 peg_status = QLC_SHARED_REG_RD32(p_dev,
1576 QLCNIC_PEG_HALT_STATUS1);
1577 dev_info(&p_dev->pdev->dev, "Dumping HW/FW registers\n"
1578 "PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2: 0x%x,\n"
1579 "PEG_NET_0_PC: 0x%x, PEG_NET_1_PC: 0x%x,\n"
1580 "PEG_NET_2_PC: 0x%x, PEG_NET_3_PC: 0x%x,\n"
1581 "PEG_NET_4_PC: 0x%x\n", peg_status,
1582 QLC_SHARED_REG_RD32(p_dev, QLCNIC_PEG_HALT_STATUS2),
1583 QLCRD32(p_dev, QLC_83XX_CRB_PEG_NET_0, &err),
1584 QLCRD32(p_dev, QLC_83XX_CRB_PEG_NET_1, &err),
1585 QLCRD32(p_dev, QLC_83XX_CRB_PEG_NET_2, &err),
1586 QLCRD32(p_dev, QLC_83XX_CRB_PEG_NET_3, &err),
1587 QLCRD32(p_dev, QLC_83XX_CRB_PEG_NET_4, &err));
1588
1589 if (QLCNIC_FWERROR_CODE(peg_status) == 0x67)
1590 dev_err(&p_dev->pdev->dev,
1591 "Device is being reset err code 0x00006700.\n");
1592 }
1593
1594 return ret;
1595 }
1596
qlcnic_83xx_check_cmd_peg_status(struct qlcnic_adapter * p_dev)1597 static int qlcnic_83xx_check_cmd_peg_status(struct qlcnic_adapter *p_dev)
1598 {
1599 int retries = QLCNIC_CMDPEG_CHECK_RETRY_COUNT;
1600 u32 val;
1601
1602 do {
1603 val = QLC_SHARED_REG_RD32(p_dev, QLCNIC_CMDPEG_STATE);
1604 if (val == QLC_83XX_CMDPEG_COMPLETE)
1605 return 0;
1606 msleep(QLCNIC_CMDPEG_CHECK_DELAY);
1607 } while (--retries);
1608
1609 dev_err(&p_dev->pdev->dev, "%s: failed, state = 0x%x\n", __func__, val);
1610 return -EIO;
1611 }
1612
qlcnic_83xx_check_hw_status(struct qlcnic_adapter * p_dev)1613 static int qlcnic_83xx_check_hw_status(struct qlcnic_adapter *p_dev)
1614 {
1615 int err;
1616
1617 err = qlcnic_83xx_check_cmd_peg_status(p_dev);
1618 if (err)
1619 return err;
1620
1621 return qlcnic_83xx_check_heartbeat(p_dev);
1622 }
1623
qlcnic_83xx_poll_reg(struct qlcnic_adapter * p_dev,u32 addr,int duration,u32 mask,u32 status)1624 static int qlcnic_83xx_poll_reg(struct qlcnic_adapter *p_dev, u32 addr,
1625 int duration, u32 mask, u32 status)
1626 {
1627 int timeout_error, err = 0;
1628 u32 value;
1629 u8 retries;
1630
1631 value = QLCRD32(p_dev, addr, &err);
1632 if (err == -EIO)
1633 return err;
1634 retries = duration / 10;
1635
1636 do {
1637 if ((value & mask) != status) {
1638 timeout_error = 1;
1639 msleep(duration / 10);
1640 value = QLCRD32(p_dev, addr, &err);
1641 if (err == -EIO)
1642 return err;
1643 } else {
1644 timeout_error = 0;
1645 break;
1646 }
1647 } while (retries--);
1648
1649 if (timeout_error) {
1650 p_dev->ahw->reset.seq_error++;
1651 dev_err(&p_dev->pdev->dev,
1652 "%s: Timeout Err, entry_num = %d\n",
1653 __func__, p_dev->ahw->reset.seq_index);
1654 dev_err(&p_dev->pdev->dev,
1655 "0x%08x 0x%08x 0x%08x\n",
1656 value, mask, status);
1657 }
1658
1659 return timeout_error;
1660 }
1661
qlcnic_83xx_reset_template_checksum(struct qlcnic_adapter * p_dev)1662 static int qlcnic_83xx_reset_template_checksum(struct qlcnic_adapter *p_dev)
1663 {
1664 u32 sum = 0;
1665 u16 *buff = (u16 *)p_dev->ahw->reset.buff;
1666 int count = p_dev->ahw->reset.hdr->size / sizeof(u16);
1667
1668 while (count-- > 0)
1669 sum += *buff++;
1670
1671 while (sum >> 16)
1672 sum = (sum & 0xFFFF) + (sum >> 16);
1673
1674 if (~sum) {
1675 return 0;
1676 } else {
1677 dev_err(&p_dev->pdev->dev, "%s: failed\n", __func__);
1678 return -1;
1679 }
1680 }
1681
qlcnic_83xx_get_reset_instruction_template(struct qlcnic_adapter * p_dev)1682 static int qlcnic_83xx_get_reset_instruction_template(struct qlcnic_adapter *p_dev)
1683 {
1684 struct qlcnic_hardware_context *ahw = p_dev->ahw;
1685 u32 addr, count, prev_ver, curr_ver;
1686 u8 *p_buff;
1687
1688 if (ahw->reset.buff != NULL) {
1689 prev_ver = p_dev->fw_version;
1690 curr_ver = qlcnic_83xx_get_fw_version(p_dev);
1691 if (curr_ver > prev_ver)
1692 kfree(ahw->reset.buff);
1693 else
1694 return 0;
1695 }
1696
1697 ahw->reset.seq_error = 0;
1698 ahw->reset.buff = kzalloc(QLC_83XX_RESTART_TEMPLATE_SIZE, GFP_KERNEL);
1699 if (ahw->reset.buff == NULL)
1700 return -ENOMEM;
1701
1702 p_buff = p_dev->ahw->reset.buff;
1703 addr = QLC_83XX_RESET_TEMPLATE_ADDR;
1704 count = sizeof(struct qlc_83xx_reset_hdr) / sizeof(u32);
1705
1706 /* Copy template header from flash */
1707 if (qlcnic_83xx_flash_read32(p_dev, addr, p_buff, count)) {
1708 dev_err(&p_dev->pdev->dev, "%s: flash read failed\n", __func__);
1709 return -EIO;
1710 }
1711 ahw->reset.hdr = (struct qlc_83xx_reset_hdr *)ahw->reset.buff;
1712 addr = QLC_83XX_RESET_TEMPLATE_ADDR + ahw->reset.hdr->hdr_size;
1713 p_buff = ahw->reset.buff + ahw->reset.hdr->hdr_size;
1714 count = (ahw->reset.hdr->size - ahw->reset.hdr->hdr_size) / sizeof(u32);
1715
1716 /* Copy rest of the template */
1717 if (qlcnic_83xx_flash_read32(p_dev, addr, p_buff, count)) {
1718 dev_err(&p_dev->pdev->dev, "%s: flash read failed\n", __func__);
1719 return -EIO;
1720 }
1721
1722 if (qlcnic_83xx_reset_template_checksum(p_dev))
1723 return -EIO;
1724 /* Get Stop, Start and Init command offsets */
1725 ahw->reset.init_offset = ahw->reset.buff + ahw->reset.hdr->init_offset;
1726 ahw->reset.start_offset = ahw->reset.buff +
1727 ahw->reset.hdr->start_offset;
1728 ahw->reset.stop_offset = ahw->reset.buff + ahw->reset.hdr->hdr_size;
1729 return 0;
1730 }
1731
1732 /* Read Write HW register command */
qlcnic_83xx_read_write_crb_reg(struct qlcnic_adapter * p_dev,u32 raddr,u32 waddr)1733 static void qlcnic_83xx_read_write_crb_reg(struct qlcnic_adapter *p_dev,
1734 u32 raddr, u32 waddr)
1735 {
1736 int err = 0;
1737 u32 value;
1738
1739 value = QLCRD32(p_dev, raddr, &err);
1740 if (err == -EIO)
1741 return;
1742 qlcnic_83xx_wrt_reg_indirect(p_dev, waddr, value);
1743 }
1744
1745 /* Read Modify Write HW register command */
qlcnic_83xx_rmw_crb_reg(struct qlcnic_adapter * p_dev,u32 raddr,u32 waddr,struct qlc_83xx_rmw * p_rmw_hdr)1746 static void qlcnic_83xx_rmw_crb_reg(struct qlcnic_adapter *p_dev,
1747 u32 raddr, u32 waddr,
1748 struct qlc_83xx_rmw *p_rmw_hdr)
1749 {
1750 int err = 0;
1751 u32 value;
1752
1753 if (p_rmw_hdr->index_a) {
1754 value = p_dev->ahw->reset.array[p_rmw_hdr->index_a];
1755 } else {
1756 value = QLCRD32(p_dev, raddr, &err);
1757 if (err == -EIO)
1758 return;
1759 }
1760
1761 value &= p_rmw_hdr->mask;
1762 value <<= p_rmw_hdr->shl;
1763 value >>= p_rmw_hdr->shr;
1764 value |= p_rmw_hdr->or_value;
1765 value ^= p_rmw_hdr->xor_value;
1766 qlcnic_83xx_wrt_reg_indirect(p_dev, waddr, value);
1767 }
1768
1769 /* Write HW register command */
qlcnic_83xx_write_list(struct qlcnic_adapter * p_dev,struct qlc_83xx_entry_hdr * p_hdr)1770 static void qlcnic_83xx_write_list(struct qlcnic_adapter *p_dev,
1771 struct qlc_83xx_entry_hdr *p_hdr)
1772 {
1773 int i;
1774 struct qlc_83xx_entry *entry;
1775
1776 entry = (struct qlc_83xx_entry *)((char *)p_hdr +
1777 sizeof(struct qlc_83xx_entry_hdr));
1778
1779 for (i = 0; i < p_hdr->count; i++, entry++) {
1780 qlcnic_83xx_wrt_reg_indirect(p_dev, entry->arg1,
1781 entry->arg2);
1782 if (p_hdr->delay)
1783 udelay((u32)(p_hdr->delay));
1784 }
1785 }
1786
1787 /* Read and Write instruction */
qlcnic_83xx_read_write_list(struct qlcnic_adapter * p_dev,struct qlc_83xx_entry_hdr * p_hdr)1788 static void qlcnic_83xx_read_write_list(struct qlcnic_adapter *p_dev,
1789 struct qlc_83xx_entry_hdr *p_hdr)
1790 {
1791 int i;
1792 struct qlc_83xx_entry *entry;
1793
1794 entry = (struct qlc_83xx_entry *)((char *)p_hdr +
1795 sizeof(struct qlc_83xx_entry_hdr));
1796
1797 for (i = 0; i < p_hdr->count; i++, entry++) {
1798 qlcnic_83xx_read_write_crb_reg(p_dev, entry->arg1,
1799 entry->arg2);
1800 if (p_hdr->delay)
1801 udelay((u32)(p_hdr->delay));
1802 }
1803 }
1804
1805 /* Poll HW register command */
qlcnic_83xx_poll_list(struct qlcnic_adapter * p_dev,struct qlc_83xx_entry_hdr * p_hdr)1806 static void qlcnic_83xx_poll_list(struct qlcnic_adapter *p_dev,
1807 struct qlc_83xx_entry_hdr *p_hdr)
1808 {
1809 long delay;
1810 struct qlc_83xx_entry *entry;
1811 struct qlc_83xx_poll *poll;
1812 int i, err = 0;
1813 unsigned long arg1, arg2;
1814
1815 poll = (struct qlc_83xx_poll *)((char *)p_hdr +
1816 sizeof(struct qlc_83xx_entry_hdr));
1817
1818 entry = (struct qlc_83xx_entry *)((char *)poll +
1819 sizeof(struct qlc_83xx_poll));
1820 delay = (long)p_hdr->delay;
1821
1822 if (!delay) {
1823 for (i = 0; i < p_hdr->count; i++, entry++)
1824 qlcnic_83xx_poll_reg(p_dev, entry->arg1,
1825 delay, poll->mask,
1826 poll->status);
1827 } else {
1828 for (i = 0; i < p_hdr->count; i++, entry++) {
1829 arg1 = entry->arg1;
1830 arg2 = entry->arg2;
1831 if (delay) {
1832 if (qlcnic_83xx_poll_reg(p_dev,
1833 arg1, delay,
1834 poll->mask,
1835 poll->status)){
1836 QLCRD32(p_dev, arg1, &err);
1837 if (err == -EIO)
1838 return;
1839 QLCRD32(p_dev, arg2, &err);
1840 if (err == -EIO)
1841 return;
1842 }
1843 }
1844 }
1845 }
1846 }
1847
1848 /* Poll and write HW register command */
qlcnic_83xx_poll_write_list(struct qlcnic_adapter * p_dev,struct qlc_83xx_entry_hdr * p_hdr)1849 static void qlcnic_83xx_poll_write_list(struct qlcnic_adapter *p_dev,
1850 struct qlc_83xx_entry_hdr *p_hdr)
1851 {
1852 int i;
1853 long delay;
1854 struct qlc_83xx_quad_entry *entry;
1855 struct qlc_83xx_poll *poll;
1856
1857 poll = (struct qlc_83xx_poll *)((char *)p_hdr +
1858 sizeof(struct qlc_83xx_entry_hdr));
1859 entry = (struct qlc_83xx_quad_entry *)((char *)poll +
1860 sizeof(struct qlc_83xx_poll));
1861 delay = (long)p_hdr->delay;
1862
1863 for (i = 0; i < p_hdr->count; i++, entry++) {
1864 qlcnic_83xx_wrt_reg_indirect(p_dev, entry->dr_addr,
1865 entry->dr_value);
1866 qlcnic_83xx_wrt_reg_indirect(p_dev, entry->ar_addr,
1867 entry->ar_value);
1868 if (delay)
1869 qlcnic_83xx_poll_reg(p_dev, entry->ar_addr, delay,
1870 poll->mask, poll->status);
1871 }
1872 }
1873
1874 /* Read Modify Write register command */
qlcnic_83xx_read_modify_write(struct qlcnic_adapter * p_dev,struct qlc_83xx_entry_hdr * p_hdr)1875 static void qlcnic_83xx_read_modify_write(struct qlcnic_adapter *p_dev,
1876 struct qlc_83xx_entry_hdr *p_hdr)
1877 {
1878 int i;
1879 struct qlc_83xx_entry *entry;
1880 struct qlc_83xx_rmw *rmw_hdr;
1881
1882 rmw_hdr = (struct qlc_83xx_rmw *)((char *)p_hdr +
1883 sizeof(struct qlc_83xx_entry_hdr));
1884
1885 entry = (struct qlc_83xx_entry *)((char *)rmw_hdr +
1886 sizeof(struct qlc_83xx_rmw));
1887
1888 for (i = 0; i < p_hdr->count; i++, entry++) {
1889 qlcnic_83xx_rmw_crb_reg(p_dev, entry->arg1,
1890 entry->arg2, rmw_hdr);
1891 if (p_hdr->delay)
1892 udelay((u32)(p_hdr->delay));
1893 }
1894 }
1895
qlcnic_83xx_pause(struct qlc_83xx_entry_hdr * p_hdr)1896 static void qlcnic_83xx_pause(struct qlc_83xx_entry_hdr *p_hdr)
1897 {
1898 if (p_hdr->delay)
1899 mdelay((u32)((long)p_hdr->delay));
1900 }
1901
1902 /* Read and poll register command */
qlcnic_83xx_poll_read_list(struct qlcnic_adapter * p_dev,struct qlc_83xx_entry_hdr * p_hdr)1903 static void qlcnic_83xx_poll_read_list(struct qlcnic_adapter *p_dev,
1904 struct qlc_83xx_entry_hdr *p_hdr)
1905 {
1906 long delay;
1907 int index, i, j, err;
1908 struct qlc_83xx_quad_entry *entry;
1909 struct qlc_83xx_poll *poll;
1910 unsigned long addr;
1911
1912 poll = (struct qlc_83xx_poll *)((char *)p_hdr +
1913 sizeof(struct qlc_83xx_entry_hdr));
1914
1915 entry = (struct qlc_83xx_quad_entry *)((char *)poll +
1916 sizeof(struct qlc_83xx_poll));
1917 delay = (long)p_hdr->delay;
1918
1919 for (i = 0; i < p_hdr->count; i++, entry++) {
1920 qlcnic_83xx_wrt_reg_indirect(p_dev, entry->ar_addr,
1921 entry->ar_value);
1922 if (delay) {
1923 if (!qlcnic_83xx_poll_reg(p_dev, entry->ar_addr, delay,
1924 poll->mask, poll->status)){
1925 index = p_dev->ahw->reset.array_index;
1926 addr = entry->dr_addr;
1927 j = QLCRD32(p_dev, addr, &err);
1928 if (err == -EIO)
1929 return;
1930
1931 p_dev->ahw->reset.array[index++] = j;
1932
1933 if (index == QLC_83XX_MAX_RESET_SEQ_ENTRIES)
1934 p_dev->ahw->reset.array_index = 1;
1935 }
1936 }
1937 }
1938 }
1939
qlcnic_83xx_seq_end(struct qlcnic_adapter * p_dev)1940 static inline void qlcnic_83xx_seq_end(struct qlcnic_adapter *p_dev)
1941 {
1942 p_dev->ahw->reset.seq_end = 1;
1943 }
1944
qlcnic_83xx_template_end(struct qlcnic_adapter * p_dev)1945 static void qlcnic_83xx_template_end(struct qlcnic_adapter *p_dev)
1946 {
1947 p_dev->ahw->reset.template_end = 1;
1948 if (p_dev->ahw->reset.seq_error == 0)
1949 dev_err(&p_dev->pdev->dev,
1950 "HW restart process completed successfully.\n");
1951 else
1952 dev_err(&p_dev->pdev->dev,
1953 "HW restart completed with timeout errors.\n");
1954 }
1955
1956 /**
1957 * qlcnic_83xx_exec_template_cmd
1958 *
1959 * @p_dev: adapter structure
1960 * @p_buff: Poiter to instruction template
1961 *
1962 * Template provides instructions to stop, restart and initalize firmware.
1963 * These instructions are abstracted as a series of read, write and
1964 * poll operations on hardware registers. Register information and operation
1965 * specifics are not exposed to the driver. Driver reads the template from
1966 * flash and executes the instructions located at pre-defined offsets.
1967 *
1968 * Returns: None
1969 * */
qlcnic_83xx_exec_template_cmd(struct qlcnic_adapter * p_dev,char * p_buff)1970 static void qlcnic_83xx_exec_template_cmd(struct qlcnic_adapter *p_dev,
1971 char *p_buff)
1972 {
1973 int index, entries;
1974 struct qlc_83xx_entry_hdr *p_hdr;
1975 char *entry = p_buff;
1976
1977 p_dev->ahw->reset.seq_end = 0;
1978 p_dev->ahw->reset.template_end = 0;
1979 entries = p_dev->ahw->reset.hdr->entries;
1980 index = p_dev->ahw->reset.seq_index;
1981
1982 for (; (!p_dev->ahw->reset.seq_end) && (index < entries); index++) {
1983 p_hdr = (struct qlc_83xx_entry_hdr *)entry;
1984
1985 switch (p_hdr->cmd) {
1986 case QLC_83XX_OPCODE_NOP:
1987 break;
1988 case QLC_83XX_OPCODE_WRITE_LIST:
1989 qlcnic_83xx_write_list(p_dev, p_hdr);
1990 break;
1991 case QLC_83XX_OPCODE_READ_WRITE_LIST:
1992 qlcnic_83xx_read_write_list(p_dev, p_hdr);
1993 break;
1994 case QLC_83XX_OPCODE_POLL_LIST:
1995 qlcnic_83xx_poll_list(p_dev, p_hdr);
1996 break;
1997 case QLC_83XX_OPCODE_POLL_WRITE_LIST:
1998 qlcnic_83xx_poll_write_list(p_dev, p_hdr);
1999 break;
2000 case QLC_83XX_OPCODE_READ_MODIFY_WRITE:
2001 qlcnic_83xx_read_modify_write(p_dev, p_hdr);
2002 break;
2003 case QLC_83XX_OPCODE_SEQ_PAUSE:
2004 qlcnic_83xx_pause(p_hdr);
2005 break;
2006 case QLC_83XX_OPCODE_SEQ_END:
2007 qlcnic_83xx_seq_end(p_dev);
2008 break;
2009 case QLC_83XX_OPCODE_TMPL_END:
2010 qlcnic_83xx_template_end(p_dev);
2011 break;
2012 case QLC_83XX_OPCODE_POLL_READ_LIST:
2013 qlcnic_83xx_poll_read_list(p_dev, p_hdr);
2014 break;
2015 default:
2016 dev_err(&p_dev->pdev->dev,
2017 "%s: Unknown opcode 0x%04x in template %d\n",
2018 __func__, p_hdr->cmd, index);
2019 break;
2020 }
2021 entry += p_hdr->size;
2022 cond_resched();
2023 }
2024 p_dev->ahw->reset.seq_index = index;
2025 }
2026
qlcnic_83xx_stop_hw(struct qlcnic_adapter * p_dev)2027 static void qlcnic_83xx_stop_hw(struct qlcnic_adapter *p_dev)
2028 {
2029 p_dev->ahw->reset.seq_index = 0;
2030
2031 qlcnic_83xx_exec_template_cmd(p_dev, p_dev->ahw->reset.stop_offset);
2032 if (p_dev->ahw->reset.seq_end != 1)
2033 dev_err(&p_dev->pdev->dev, "%s: failed\n", __func__);
2034 }
2035
qlcnic_83xx_start_hw(struct qlcnic_adapter * p_dev)2036 static void qlcnic_83xx_start_hw(struct qlcnic_adapter *p_dev)
2037 {
2038 qlcnic_83xx_exec_template_cmd(p_dev, p_dev->ahw->reset.start_offset);
2039 if (p_dev->ahw->reset.template_end != 1)
2040 dev_err(&p_dev->pdev->dev, "%s: failed\n", __func__);
2041 }
2042
qlcnic_83xx_init_hw(struct qlcnic_adapter * p_dev)2043 static void qlcnic_83xx_init_hw(struct qlcnic_adapter *p_dev)
2044 {
2045 qlcnic_83xx_exec_template_cmd(p_dev, p_dev->ahw->reset.init_offset);
2046 if (p_dev->ahw->reset.seq_end != 1)
2047 dev_err(&p_dev->pdev->dev, "%s: failed\n", __func__);
2048 }
2049
2050 /* POST FW related definitions*/
2051 #define QLC_83XX_POST_SIGNATURE_REG 0x41602014
2052 #define QLC_83XX_POST_MODE_REG 0x41602018
2053 #define QLC_83XX_POST_FAST_MODE 0
2054 #define QLC_83XX_POST_MEDIUM_MODE 1
2055 #define QLC_83XX_POST_SLOW_MODE 2
2056
2057 /* POST Timeout values in milliseconds */
2058 #define QLC_83XX_POST_FAST_MODE_TIMEOUT 690
2059 #define QLC_83XX_POST_MED_MODE_TIMEOUT 2930
2060 #define QLC_83XX_POST_SLOW_MODE_TIMEOUT 7500
2061
2062 /* POST result values */
2063 #define QLC_83XX_POST_PASS 0xfffffff0
2064 #define QLC_83XX_POST_ASIC_STRESS_TEST_FAIL 0xffffffff
2065 #define QLC_83XX_POST_DDR_TEST_FAIL 0xfffffffe
2066 #define QLC_83XX_POST_ASIC_MEMORY_TEST_FAIL 0xfffffffc
2067 #define QLC_83XX_POST_FLASH_TEST_FAIL 0xfffffff8
2068
qlcnic_83xx_run_post(struct qlcnic_adapter * adapter)2069 static int qlcnic_83xx_run_post(struct qlcnic_adapter *adapter)
2070 {
2071 struct qlc_83xx_fw_info *fw_info = adapter->ahw->fw_info;
2072 struct device *dev = &adapter->pdev->dev;
2073 int timeout, count, ret = 0;
2074 u32 signature;
2075
2076 /* Set timeout values with extra 2 seconds of buffer */
2077 switch (adapter->ahw->post_mode) {
2078 case QLC_83XX_POST_FAST_MODE:
2079 timeout = QLC_83XX_POST_FAST_MODE_TIMEOUT + 2000;
2080 break;
2081 case QLC_83XX_POST_MEDIUM_MODE:
2082 timeout = QLC_83XX_POST_MED_MODE_TIMEOUT + 2000;
2083 break;
2084 case QLC_83XX_POST_SLOW_MODE:
2085 timeout = QLC_83XX_POST_SLOW_MODE_TIMEOUT + 2000;
2086 break;
2087 default:
2088 return -EINVAL;
2089 }
2090
2091 strscpy(fw_info->fw_file_name, QLC_83XX_POST_FW_FILE_NAME,
2092 sizeof(fw_info->fw_file_name));
2093
2094 ret = request_firmware(&fw_info->fw, fw_info->fw_file_name, dev);
2095 if (ret) {
2096 dev_err(dev, "POST firmware can not be loaded, skipping POST\n");
2097 return 0;
2098 }
2099
2100 ret = qlcnic_83xx_copy_fw_file(adapter);
2101 if (ret)
2102 return ret;
2103
2104 /* clear QLC_83XX_POST_SIGNATURE_REG register */
2105 qlcnic_ind_wr(adapter, QLC_83XX_POST_SIGNATURE_REG, 0);
2106
2107 /* Set POST mode */
2108 qlcnic_ind_wr(adapter, QLC_83XX_POST_MODE_REG,
2109 adapter->ahw->post_mode);
2110
2111 QLC_SHARED_REG_WR32(adapter, QLCNIC_FW_IMG_VALID,
2112 QLC_83XX_BOOT_FROM_FILE);
2113
2114 qlcnic_83xx_start_hw(adapter);
2115
2116 count = 0;
2117 do {
2118 msleep(100);
2119 count += 100;
2120
2121 signature = qlcnic_ind_rd(adapter, QLC_83XX_POST_SIGNATURE_REG);
2122 if (signature == QLC_83XX_POST_PASS)
2123 break;
2124 } while (timeout > count);
2125
2126 if (timeout <= count) {
2127 dev_err(dev, "POST timed out, signature = 0x%08x\n", signature);
2128 return -EIO;
2129 }
2130
2131 switch (signature) {
2132 case QLC_83XX_POST_PASS:
2133 dev_info(dev, "POST passed, Signature = 0x%08x\n", signature);
2134 break;
2135 case QLC_83XX_POST_ASIC_STRESS_TEST_FAIL:
2136 dev_err(dev, "POST failed, Test case : ASIC STRESS TEST, Signature = 0x%08x\n",
2137 signature);
2138 ret = -EIO;
2139 break;
2140 case QLC_83XX_POST_DDR_TEST_FAIL:
2141 dev_err(dev, "POST failed, Test case : DDT TEST, Signature = 0x%08x\n",
2142 signature);
2143 ret = -EIO;
2144 break;
2145 case QLC_83XX_POST_ASIC_MEMORY_TEST_FAIL:
2146 dev_err(dev, "POST failed, Test case : ASIC MEMORY TEST, Signature = 0x%08x\n",
2147 signature);
2148 ret = -EIO;
2149 break;
2150 case QLC_83XX_POST_FLASH_TEST_FAIL:
2151 dev_err(dev, "POST failed, Test case : FLASH TEST, Signature = 0x%08x\n",
2152 signature);
2153 ret = -EIO;
2154 break;
2155 default:
2156 dev_err(dev, "POST failed, Test case : INVALID, Signature = 0x%08x\n",
2157 signature);
2158 ret = -EIO;
2159 break;
2160 }
2161
2162 return ret;
2163 }
2164
qlcnic_83xx_load_fw_image_from_host(struct qlcnic_adapter * adapter)2165 static int qlcnic_83xx_load_fw_image_from_host(struct qlcnic_adapter *adapter)
2166 {
2167 struct qlc_83xx_fw_info *fw_info = adapter->ahw->fw_info;
2168 int err = -EIO;
2169
2170 if (request_firmware(&fw_info->fw, fw_info->fw_file_name,
2171 &(adapter->pdev->dev))) {
2172 dev_err(&adapter->pdev->dev,
2173 "No file FW image, loading flash FW image.\n");
2174 QLC_SHARED_REG_WR32(adapter, QLCNIC_FW_IMG_VALID,
2175 QLC_83XX_BOOT_FROM_FLASH);
2176 } else {
2177 if (qlcnic_83xx_copy_fw_file(adapter))
2178 return err;
2179 QLC_SHARED_REG_WR32(adapter, QLCNIC_FW_IMG_VALID,
2180 QLC_83XX_BOOT_FROM_FILE);
2181 }
2182
2183 return 0;
2184 }
2185
qlcnic_83xx_restart_hw(struct qlcnic_adapter * adapter)2186 static int qlcnic_83xx_restart_hw(struct qlcnic_adapter *adapter)
2187 {
2188 u32 val;
2189 int err = -EIO;
2190
2191 qlcnic_83xx_stop_hw(adapter);
2192
2193 /* Collect FW register dump if required */
2194 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
2195 if (!(val & QLC_83XX_IDC_GRACEFULL_RESET))
2196 qlcnic_dump_fw(adapter);
2197
2198 if (val & QLC_83XX_IDC_DISABLE_FW_RESET_RECOVERY) {
2199 netdev_info(adapter->netdev, "%s: Auto firmware recovery is disabled\n",
2200 __func__);
2201 qlcnic_83xx_idc_enter_failed_state(adapter, 1);
2202 return err;
2203 }
2204
2205 qlcnic_83xx_init_hw(adapter);
2206
2207 if (qlcnic_83xx_copy_bootloader(adapter))
2208 return err;
2209
2210 /* Check if POST needs to be run */
2211 if (adapter->ahw->run_post) {
2212 err = qlcnic_83xx_run_post(adapter);
2213 if (err)
2214 return err;
2215
2216 /* No need to run POST in next reset sequence */
2217 adapter->ahw->run_post = false;
2218
2219 /* Again reset the adapter to load regular firmware */
2220 qlcnic_83xx_stop_hw(adapter);
2221 qlcnic_83xx_init_hw(adapter);
2222
2223 err = qlcnic_83xx_copy_bootloader(adapter);
2224 if (err)
2225 return err;
2226 }
2227
2228 /* Boot either flash image or firmware image from host file system */
2229 if (qlcnic_load_fw_file == 1) {
2230 err = qlcnic_83xx_load_fw_image_from_host(adapter);
2231 if (err)
2232 return err;
2233 } else {
2234 QLC_SHARED_REG_WR32(adapter, QLCNIC_FW_IMG_VALID,
2235 QLC_83XX_BOOT_FROM_FLASH);
2236 }
2237
2238 qlcnic_83xx_start_hw(adapter);
2239 if (qlcnic_83xx_check_hw_status(adapter))
2240 return -EIO;
2241
2242 return 0;
2243 }
2244
qlcnic_83xx_get_nic_configuration(struct qlcnic_adapter * adapter)2245 static int qlcnic_83xx_get_nic_configuration(struct qlcnic_adapter *adapter)
2246 {
2247 int err;
2248 struct qlcnic_info nic_info;
2249 struct qlcnic_hardware_context *ahw = adapter->ahw;
2250
2251 memset(&nic_info, 0, sizeof(struct qlcnic_info));
2252 err = qlcnic_get_nic_info(adapter, &nic_info, ahw->pci_func);
2253 if (err)
2254 return -EIO;
2255
2256 ahw->physical_port = (u8) nic_info.phys_port;
2257 ahw->switch_mode = nic_info.switch_mode;
2258 ahw->max_tx_ques = nic_info.max_tx_ques;
2259 ahw->max_rx_ques = nic_info.max_rx_ques;
2260 ahw->capabilities = nic_info.capabilities;
2261 ahw->max_mac_filters = nic_info.max_mac_filters;
2262 ahw->max_mtu = nic_info.max_mtu;
2263
2264 /* eSwitch capability indicates vNIC mode.
2265 * vNIC and SRIOV are mutually exclusive operational modes.
2266 * If SR-IOV capability is detected, SR-IOV physical function
2267 * will get initialized in default mode.
2268 * SR-IOV virtual function initialization follows a
2269 * different code path and opmode.
2270 * SRIOV mode has precedence over vNIC mode.
2271 */
2272 if (test_bit(__QLCNIC_SRIOV_CAPABLE, &adapter->state))
2273 return QLC_83XX_DEFAULT_OPMODE;
2274
2275 if (ahw->capabilities & QLC_83XX_ESWITCH_CAPABILITY)
2276 return QLCNIC_VNIC_MODE;
2277
2278 return QLC_83XX_DEFAULT_OPMODE;
2279 }
2280
qlcnic_83xx_configure_opmode(struct qlcnic_adapter * adapter)2281 int qlcnic_83xx_configure_opmode(struct qlcnic_adapter *adapter)
2282 {
2283 struct qlcnic_hardware_context *ahw = adapter->ahw;
2284 u16 max_sds_rings, max_tx_rings;
2285 int ret;
2286
2287 ret = qlcnic_83xx_get_nic_configuration(adapter);
2288 if (ret == -EIO)
2289 return -EIO;
2290
2291 if (ret == QLCNIC_VNIC_MODE) {
2292 ahw->nic_mode = QLCNIC_VNIC_MODE;
2293
2294 if (qlcnic_83xx_config_vnic_opmode(adapter))
2295 return -EIO;
2296
2297 max_sds_rings = QLCNIC_MAX_VNIC_SDS_RINGS;
2298 max_tx_rings = QLCNIC_MAX_VNIC_TX_RINGS;
2299 } else if (ret == QLC_83XX_DEFAULT_OPMODE) {
2300 ahw->nic_mode = QLCNIC_DEFAULT_MODE;
2301 adapter->nic_ops->init_driver = qlcnic_83xx_init_default_driver;
2302 ahw->idc.state_entry = qlcnic_83xx_idc_ready_state_entry;
2303 max_sds_rings = QLCNIC_MAX_SDS_RINGS;
2304 max_tx_rings = QLCNIC_MAX_TX_RINGS;
2305 } else {
2306 dev_err(&adapter->pdev->dev, "%s: Invalid opmode %d\n",
2307 __func__, ret);
2308 return -EIO;
2309 }
2310
2311 adapter->max_sds_rings = min(ahw->max_rx_ques, max_sds_rings);
2312 adapter->max_tx_rings = min(ahw->max_tx_ques, max_tx_rings);
2313
2314 return 0;
2315 }
2316
qlcnic_83xx_config_buff_descriptors(struct qlcnic_adapter * adapter)2317 static void qlcnic_83xx_config_buff_descriptors(struct qlcnic_adapter *adapter)
2318 {
2319 struct qlcnic_hardware_context *ahw = adapter->ahw;
2320
2321 if (ahw->port_type == QLCNIC_XGBE) {
2322 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
2323 adapter->max_rxd = MAX_RCV_DESCRIPTORS_10G;
2324 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
2325 adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
2326
2327 } else if (ahw->port_type == QLCNIC_GBE) {
2328 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
2329 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
2330 adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
2331 adapter->max_rxd = MAX_RCV_DESCRIPTORS_1G;
2332 }
2333 adapter->num_txd = MAX_CMD_DESCRIPTORS;
2334 adapter->max_rds_rings = MAX_RDS_RINGS;
2335 }
2336
qlcnic_83xx_init_default_driver(struct qlcnic_adapter * adapter)2337 static int qlcnic_83xx_init_default_driver(struct qlcnic_adapter *adapter)
2338 {
2339 int err = -EIO;
2340
2341 qlcnic_83xx_get_minidump_template(adapter);
2342 if (qlcnic_83xx_get_port_info(adapter))
2343 return err;
2344
2345 qlcnic_83xx_config_buff_descriptors(adapter);
2346 adapter->ahw->msix_supported = !!qlcnic_use_msi_x;
2347 adapter->flags |= QLCNIC_ADAPTER_INITIALIZED;
2348
2349 dev_info(&adapter->pdev->dev, "HAL Version: %d\n",
2350 adapter->ahw->fw_hal_version);
2351
2352 return 0;
2353 }
2354
2355 #define IS_QLC_83XX_USED(a, b, c) (((1 << a->portnum) & b) || ((c >> 6) & 0x1))
qlcnic_83xx_clear_function_resources(struct qlcnic_adapter * adapter)2356 static void qlcnic_83xx_clear_function_resources(struct qlcnic_adapter *adapter)
2357 {
2358 struct qlcnic_cmd_args cmd;
2359 u32 presence_mask, audit_mask;
2360 int status;
2361
2362 presence_mask = QLCRDX(adapter->ahw, QLC_83XX_IDC_DRV_PRESENCE);
2363 audit_mask = QLCRDX(adapter->ahw, QLC_83XX_IDC_DRV_AUDIT);
2364
2365 if (IS_QLC_83XX_USED(adapter, presence_mask, audit_mask)) {
2366 status = qlcnic_alloc_mbx_args(&cmd, adapter,
2367 QLCNIC_CMD_STOP_NIC_FUNC);
2368 if (status)
2369 return;
2370
2371 cmd.req.arg[1] = BIT_31;
2372 status = qlcnic_issue_cmd(adapter, &cmd);
2373 if (status)
2374 dev_err(&adapter->pdev->dev,
2375 "Failed to clean up the function resources\n");
2376 qlcnic_free_mbx_args(&cmd);
2377 }
2378 }
2379
qlcnic_83xx_get_fw_info(struct qlcnic_adapter * adapter)2380 static int qlcnic_83xx_get_fw_info(struct qlcnic_adapter *adapter)
2381 {
2382 struct qlcnic_hardware_context *ahw = adapter->ahw;
2383 struct pci_dev *pdev = adapter->pdev;
2384 struct qlc_83xx_fw_info *fw_info;
2385 int err = 0;
2386
2387 ahw->fw_info = kzalloc_obj(*fw_info);
2388 if (!ahw->fw_info) {
2389 err = -ENOMEM;
2390 } else {
2391 fw_info = ahw->fw_info;
2392 switch (pdev->device) {
2393 case PCI_DEVICE_ID_QLOGIC_QLE834X:
2394 case PCI_DEVICE_ID_QLOGIC_QLE8830:
2395 strscpy(fw_info->fw_file_name, QLC_83XX_FW_FILE_NAME,
2396 sizeof(fw_info->fw_file_name));
2397 break;
2398 case PCI_DEVICE_ID_QLOGIC_QLE844X:
2399 strscpy(fw_info->fw_file_name, QLC_84XX_FW_FILE_NAME,
2400 sizeof(fw_info->fw_file_name));
2401 break;
2402 default:
2403 dev_err(&pdev->dev, "%s: Invalid device id\n",
2404 __func__);
2405 err = -EINVAL;
2406 break;
2407 }
2408 }
2409
2410 return err;
2411 }
2412
qlcnic_83xx_init_rings(struct qlcnic_adapter * adapter)2413 static void qlcnic_83xx_init_rings(struct qlcnic_adapter *adapter)
2414 {
2415 u8 rx_cnt = QLCNIC_DEF_SDS_RINGS;
2416 u8 tx_cnt = QLCNIC_DEF_TX_RINGS;
2417
2418 adapter->max_tx_rings = QLCNIC_MAX_TX_RINGS;
2419 adapter->max_sds_rings = QLCNIC_MAX_SDS_RINGS;
2420
2421 if (!adapter->ahw->msix_supported) {
2422 rx_cnt = QLCNIC_SINGLE_RING;
2423 tx_cnt = QLCNIC_SINGLE_RING;
2424 }
2425
2426 /* compute and set drv sds rings */
2427 qlcnic_set_tx_ring_count(adapter, tx_cnt);
2428 qlcnic_set_sds_ring_count(adapter, rx_cnt);
2429 }
2430
qlcnic_83xx_init(struct qlcnic_adapter * adapter)2431 int qlcnic_83xx_init(struct qlcnic_adapter *adapter)
2432 {
2433 struct qlcnic_hardware_context *ahw = adapter->ahw;
2434 int err = 0;
2435
2436 adapter->rx_mac_learn = false;
2437 ahw->msix_supported = !!qlcnic_use_msi_x;
2438
2439 /* Check if POST needs to be run */
2440 switch (qlcnic_load_fw_file) {
2441 case 2:
2442 ahw->post_mode = QLC_83XX_POST_FAST_MODE;
2443 ahw->run_post = true;
2444 break;
2445 case 3:
2446 ahw->post_mode = QLC_83XX_POST_MEDIUM_MODE;
2447 ahw->run_post = true;
2448 break;
2449 case 4:
2450 ahw->post_mode = QLC_83XX_POST_SLOW_MODE;
2451 ahw->run_post = true;
2452 break;
2453 default:
2454 ahw->run_post = false;
2455 break;
2456 }
2457
2458 qlcnic_83xx_init_rings(adapter);
2459
2460 err = qlcnic_83xx_init_mailbox_work(adapter);
2461 if (err)
2462 goto exit;
2463
2464 if (qlcnic_sriov_vf_check(adapter)) {
2465 err = qlcnic_sriov_vf_init(adapter);
2466 if (err)
2467 goto detach_mbx;
2468 else
2469 return err;
2470 }
2471
2472 if (qlcnic_83xx_read_flash_descriptor_table(adapter) ||
2473 qlcnic_83xx_read_flash_mfg_id(adapter)) {
2474 dev_err(&adapter->pdev->dev, "Failed reading flash mfg id\n");
2475 err = -ENOTRECOVERABLE;
2476 goto detach_mbx;
2477 }
2478
2479 err = qlcnic_83xx_check_hw_status(adapter);
2480 if (err)
2481 goto detach_mbx;
2482
2483 err = qlcnic_83xx_get_fw_info(adapter);
2484 if (err)
2485 goto detach_mbx;
2486
2487 err = qlcnic_83xx_idc_init(adapter);
2488 if (err)
2489 goto detach_mbx;
2490
2491 err = qlcnic_setup_intr(adapter);
2492 if (err) {
2493 dev_err(&adapter->pdev->dev, "Failed to setup interrupt\n");
2494 goto disable_intr;
2495 }
2496
2497 INIT_DELAYED_WORK(&adapter->idc_aen_work, qlcnic_83xx_idc_aen_work);
2498
2499 err = qlcnic_83xx_setup_mbx_intr(adapter);
2500 if (err)
2501 goto disable_mbx_intr;
2502
2503 qlcnic_83xx_clear_function_resources(adapter);
2504
2505 err = qlcnic_dcb_enable(adapter->dcb);
2506 if (err) {
2507 qlcnic_dcb_free(adapter->dcb);
2508 goto disable_mbx_intr;
2509 }
2510
2511 qlcnic_83xx_initialize_nic(adapter, 1);
2512 qlcnic_dcb_get_info(adapter->dcb);
2513
2514 /* Configure default, SR-IOV or Virtual NIC mode of operation */
2515 err = qlcnic_83xx_configure_opmode(adapter);
2516 if (err)
2517 goto disable_mbx_intr;
2518
2519
2520 /* Perform operating mode specific initialization */
2521 err = adapter->nic_ops->init_driver(adapter);
2522 if (err)
2523 goto disable_mbx_intr;
2524
2525 /* Periodically monitor device status */
2526 qlcnic_83xx_idc_poll_dev_state(&adapter->fw_work.work);
2527 return 0;
2528
2529 disable_mbx_intr:
2530 qlcnic_83xx_free_mbx_intr(adapter);
2531
2532 disable_intr:
2533 qlcnic_teardown_intr(adapter);
2534
2535 detach_mbx:
2536 qlcnic_83xx_detach_mailbox_work(adapter);
2537 qlcnic_83xx_free_mailbox(ahw->mailbox);
2538 ahw->mailbox = NULL;
2539 exit:
2540 return err;
2541 }
2542
qlcnic_83xx_aer_stop_poll_work(struct qlcnic_adapter * adapter)2543 void qlcnic_83xx_aer_stop_poll_work(struct qlcnic_adapter *adapter)
2544 {
2545 struct qlcnic_hardware_context *ahw = adapter->ahw;
2546 struct qlc_83xx_idc *idc = &ahw->idc;
2547
2548 clear_bit(QLC_83XX_MBX_READY, &idc->status);
2549 cancel_delayed_work_sync(&adapter->fw_work);
2550
2551 if (ahw->nic_mode == QLCNIC_VNIC_MODE)
2552 qlcnic_83xx_disable_vnic_mode(adapter, 1);
2553
2554 qlcnic_83xx_idc_detach_driver(adapter);
2555 qlcnic_83xx_initialize_nic(adapter, 0);
2556
2557 cancel_delayed_work_sync(&adapter->idc_aen_work);
2558 }
2559
qlcnic_83xx_aer_reset(struct qlcnic_adapter * adapter)2560 int qlcnic_83xx_aer_reset(struct qlcnic_adapter *adapter)
2561 {
2562 struct qlcnic_hardware_context *ahw = adapter->ahw;
2563 struct qlc_83xx_idc *idc = &ahw->idc;
2564 int ret = 0;
2565 u32 owner;
2566
2567 /* Mark the previous IDC state as NEED_RESET so
2568 * that state_entry() will perform the reattachment
2569 * and bringup the device
2570 */
2571 idc->prev_state = QLC_83XX_IDC_DEV_NEED_RESET;
2572 owner = qlcnic_83xx_idc_find_reset_owner_id(adapter);
2573 if (ahw->pci_func == owner) {
2574 ret = qlcnic_83xx_restart_hw(adapter);
2575 if (ret < 0)
2576 return ret;
2577 qlcnic_83xx_idc_clear_registers(adapter, 0);
2578 }
2579
2580 ret = idc->state_entry(adapter);
2581 return ret;
2582 }
2583
qlcnic_83xx_aer_start_poll_work(struct qlcnic_adapter * adapter)2584 void qlcnic_83xx_aer_start_poll_work(struct qlcnic_adapter *adapter)
2585 {
2586 struct qlcnic_hardware_context *ahw = adapter->ahw;
2587 struct qlc_83xx_idc *idc = &ahw->idc;
2588 u32 owner;
2589
2590 idc->prev_state = QLC_83XX_IDC_DEV_READY;
2591 owner = qlcnic_83xx_idc_find_reset_owner_id(adapter);
2592 if (ahw->pci_func == owner)
2593 qlcnic_83xx_idc_enter_ready_state(adapter, 0);
2594
2595 qlcnic_schedule_work(adapter, qlcnic_83xx_idc_poll_dev_state, 0);
2596 }
2597