projects/linux·blob master · refs

814 lines · 19.6 KiB

1// SPDX-License-Identifier: GPL-2.0
2/* Copyright(c) 2017 - 2019 Pensando Systems, Inc */
3
4#include <linux/printk.h>
5#include <linux/dynamic_debug.h>
6#include <linux/module.h>
7#include <linux/netdevice.h>
8#include <linux/utsname.h>
9#include <generated/utsrelease.h>
10#include <linux/ctype.h>
11
12#include "ionic.h"
13#include "ionic_bus.h"
14#include "ionic_lif.h"
15#include "ionic_debugfs.h"
16
17MODULE_DESCRIPTION(IONIC_DRV_DESCRIPTION);
18MODULE_AUTHOR("Shannon Nelson <[email protected]>");
19MODULE_LICENSE("GPL");
20
21static const char *ionic_error_to_str(enum ionic_status_code code)
22{
23 switch (code) {
24 case IONIC_RC_SUCCESS:
25 return "IONIC_RC_SUCCESS";
26 case IONIC_RC_EVERSION:
27 return "IONIC_RC_EVERSION";
28 case IONIC_RC_EOPCODE:
29 return "IONIC_RC_EOPCODE";
30 case IONIC_RC_EIO:
31 return "IONIC_RC_EIO";
32 case IONIC_RC_EPERM:
33 return "IONIC_RC_EPERM";
34 case IONIC_RC_EQID:
35 return "IONIC_RC_EQID";
36 case IONIC_RC_EQTYPE:
37 return "IONIC_RC_EQTYPE";
38 case IONIC_RC_ENOENT:
39 return "IONIC_RC_ENOENT";
40 case IONIC_RC_EINTR:
41 return "IONIC_RC_EINTR";
42 case IONIC_RC_EAGAIN:
43 return "IONIC_RC_EAGAIN";
44 case IONIC_RC_ENOMEM:
45 return "IONIC_RC_ENOMEM";
46 case IONIC_RC_EFAULT:
47 return "IONIC_RC_EFAULT";
48 case IONIC_RC_EBUSY:
49 return "IONIC_RC_EBUSY";
50 case IONIC_RC_EEXIST:
51 return "IONIC_RC_EEXIST";
52 case IONIC_RC_EINVAL:
53 return "IONIC_RC_EINVAL";
54 case IONIC_RC_ENOSPC:
55 return "IONIC_RC_ENOSPC";
56 case IONIC_RC_ERANGE:
57 return "IONIC_RC_ERANGE";
58 case IONIC_RC_BAD_ADDR:
59 return "IONIC_RC_BAD_ADDR";
60 case IONIC_RC_DEV_CMD:
61 return "IONIC_RC_DEV_CMD";
62 case IONIC_RC_ENOSUPP:
63 return "IONIC_RC_ENOSUPP";
64 case IONIC_RC_ERROR:
65 return "IONIC_RC_ERROR";
66 case IONIC_RC_ERDMA:
67 return "IONIC_RC_ERDMA";
68 case IONIC_RC_EBAD_FW:
69 return "IONIC_RC_EBAD_FW";
70 default:
71 return "IONIC_RC_UNKNOWN";
72 }
73}
74
75int ionic_error_to_errno(enum ionic_status_code code)
76{
77 switch (code) {
78 case IONIC_RC_SUCCESS:
79 return 0;
80 case IONIC_RC_EVERSION:
81 case IONIC_RC_EQTYPE:
82 case IONIC_RC_EQID:
83 case IONIC_RC_EINVAL:
84 return -EINVAL;
85 case IONIC_RC_ENOSUPP:
86 return -EOPNOTSUPP;
87 case IONIC_RC_EPERM:
88 return -EPERM;
89 case IONIC_RC_ENOENT:
90 return -ENOENT;
91 case IONIC_RC_EAGAIN:
92 return -EAGAIN;
93 case IONIC_RC_ENOMEM:
94 return -ENOMEM;
95 case IONIC_RC_EFAULT:
96 return -EFAULT;
97 case IONIC_RC_EBUSY:
98 return -EBUSY;
99 case IONIC_RC_EEXIST:
100 return -EEXIST;
101 case IONIC_RC_ENOSPC:
102 return -ENOSPC;
103 case IONIC_RC_ERANGE:
104 return -ERANGE;
105 case IONIC_RC_BAD_ADDR:
106 return -EFAULT;
107 case IONIC_RC_EOPCODE:
108 case IONIC_RC_EINTR:
109 case IONIC_RC_DEV_CMD:
110 case IONIC_RC_ERROR:
111 case IONIC_RC_ERDMA:
112 case IONIC_RC_EIO:
113 default:
114 return -EIO;
115 }
116}
117EXPORT_SYMBOL_NS(ionic_error_to_errno, "NET_IONIC");
118
119static const char *ionic_opcode_to_str(enum ionic_cmd_opcode opcode)
120{
121 switch (opcode) {
122 case IONIC_CMD_NOP:
123 return "IONIC_CMD_NOP";
124 case IONIC_CMD_INIT:
125 return "IONIC_CMD_INIT";
126 case IONIC_CMD_RESET:
127 return "IONIC_CMD_RESET";
128 case IONIC_CMD_IDENTIFY:
129 return "IONIC_CMD_IDENTIFY";
130 case IONIC_CMD_GETATTR:
131 return "IONIC_CMD_GETATTR";
132 case IONIC_CMD_SETATTR:
133 return "IONIC_CMD_SETATTR";
134 case IONIC_CMD_PORT_IDENTIFY:
135 return "IONIC_CMD_PORT_IDENTIFY";
136 case IONIC_CMD_PORT_INIT:
137 return "IONIC_CMD_PORT_INIT";
138 case IONIC_CMD_PORT_RESET:
139 return "IONIC_CMD_PORT_RESET";
140 case IONIC_CMD_PORT_GETATTR:
141 return "IONIC_CMD_PORT_GETATTR";
142 case IONIC_CMD_PORT_SETATTR:
143 return "IONIC_CMD_PORT_SETATTR";
144 case IONIC_CMD_LIF_INIT:
145 return "IONIC_CMD_LIF_INIT";
146 case IONIC_CMD_LIF_RESET:
147 return "IONIC_CMD_LIF_RESET";
148 case IONIC_CMD_LIF_IDENTIFY:
149 return "IONIC_CMD_LIF_IDENTIFY";
150 case IONIC_CMD_LIF_SETATTR:
151 return "IONIC_CMD_LIF_SETATTR";
152 case IONIC_CMD_LIF_GETATTR:
153 return "IONIC_CMD_LIF_GETATTR";
154 case IONIC_CMD_LIF_SETPHC:
155 return "IONIC_CMD_LIF_SETPHC";
156 case IONIC_CMD_RX_MODE_SET:
157 return "IONIC_CMD_RX_MODE_SET";
158 case IONIC_CMD_RX_FILTER_ADD:
159 return "IONIC_CMD_RX_FILTER_ADD";
160 case IONIC_CMD_RX_FILTER_DEL:
161 return "IONIC_CMD_RX_FILTER_DEL";
162 case IONIC_CMD_Q_IDENTIFY:
163 return "IONIC_CMD_Q_IDENTIFY";
164 case IONIC_CMD_Q_INIT:
165 return "IONIC_CMD_Q_INIT";
166 case IONIC_CMD_Q_CONTROL:
167 return "IONIC_CMD_Q_CONTROL";
168 case IONIC_CMD_RDMA_RESET_LIF:
169 return "IONIC_CMD_RDMA_RESET_LIF";
170 case IONIC_CMD_RDMA_CREATE_EQ:
171 return "IONIC_CMD_RDMA_CREATE_EQ";
172 case IONIC_CMD_RDMA_CREATE_CQ:
173 return "IONIC_CMD_RDMA_CREATE_CQ";
174 case IONIC_CMD_RDMA_CREATE_ADMINQ:
175 return "IONIC_CMD_RDMA_CREATE_ADMINQ";
176 case IONIC_CMD_FW_DOWNLOAD:
177 return "IONIC_CMD_FW_DOWNLOAD";
178 case IONIC_CMD_FW_CONTROL:
179 return "IONIC_CMD_FW_CONTROL";
180 case IONIC_CMD_FW_DOWNLOAD_V1:
181 return "IONIC_CMD_FW_DOWNLOAD_V1";
182 case IONIC_CMD_FW_CONTROL_V1:
183 return "IONIC_CMD_FW_CONTROL_V1";
184 case IONIC_CMD_VF_GETATTR:
185 return "IONIC_CMD_VF_GETATTR";
186 case IONIC_CMD_VF_SETATTR:
187 return "IONIC_CMD_VF_SETATTR";
188 default:
189 return "DEVCMD_UNKNOWN";
190 }
191}
192
193static void ionic_adminq_flush(struct ionic_lif *lif)
194{
195 struct ionic_admin_desc_info *desc_info;
196 struct ionic_admin_cmd *desc;
197 unsigned long irqflags;
198 struct ionic_queue *q;
199
200 spin_lock_irqsave(&lif->adminq_lock, irqflags);
201 if (!lif->adminqcq) {
202 spin_unlock_irqrestore(&lif->adminq_lock, irqflags);
203 return;
204 }
205
206 q = &lif->adminqcq->q;
207
208 while (q->tail_idx != q->head_idx) {
209 desc = &q->adminq[q->tail_idx];
210 desc_info = &q->admin_info[q->tail_idx];
211 memset(desc, 0, sizeof(union ionic_adminq_cmd));
212 desc_info->ctx = NULL;
213 q->tail_idx = (q->tail_idx + 1) & (q->num_descs - 1);
214 }
215 spin_unlock_irqrestore(&lif->adminq_lock, irqflags);
216}
217
218void ionic_adminq_netdev_err_print(struct ionic_lif *lif, u8 opcode,
219 u8 status, int err)
220{
221 const char *stat_str;
222
223 stat_str = (err == -ETIMEDOUT) ? "TIMEOUT" :
224 ionic_error_to_str(status);
225
226 netdev_err(lif->netdev, "%s (%d) failed: %s (%d)\n",
227 ionic_opcode_to_str(opcode), opcode, stat_str, err);
228}
229
230static int ionic_adminq_check_err(struct ionic_lif *lif,
231 struct ionic_admin_ctx *ctx,
232 const bool timeout,
233 const bool do_msg)
234{
235 int err = 0;
236
237 if (ctx->comp.comp.status || timeout) {
238 err = timeout ? -ETIMEDOUT :
239 ionic_error_to_errno(ctx->comp.comp.status);
240
241 if (do_msg)
242 ionic_adminq_netdev_err_print(lif, ctx->cmd.cmd.opcode,
243 ctx->comp.comp.status, err);
244
245 if (timeout)
246 ionic_adminq_flush(lif);
247 }
248
249 return err;
250}
251
252bool ionic_notifyq_service(struct ionic_cq *cq)
253{
254 struct ionic_deferred_work *work;
255 union ionic_notifyq_comp *comp;
256 struct net_device *netdev;
257 struct ionic_queue *q;
258 struct ionic_lif *lif;
259 u64 eid;
260
261 comp = &((union ionic_notifyq_comp *)cq->base)[cq->tail_idx];
262
263 q = cq->bound_q;
264 lif = q->admin_info[0].ctx;
265 netdev = lif->netdev;
266 eid = le64_to_cpu(comp->event.eid);
267
268 /* Have we run out of new completions to process? */
269 if ((s64)(eid - lif->last_eid) <= 0)
270 return false;
271
272 dma_rmb();
273
274 lif->last_eid = eid;
275
276 dev_dbg(lif->ionic->dev, "notifyq event:\n");
277 dynamic_hex_dump("event ", DUMP_PREFIX_OFFSET, 16, 1,
278 comp, sizeof(*comp), true);
279
280 switch (le16_to_cpu(comp->event.ecode)) {
281 case IONIC_EVENT_LINK_CHANGE:
282 ionic_link_status_check_request(lif, CAN_NOT_SLEEP);
283 break;
284 case IONIC_EVENT_RESET:
285 if (lif->ionic->idev.fw_status_ready &&
286 !test_bit(IONIC_LIF_F_FW_RESET, lif->state) &&
287 !test_and_set_bit(IONIC_LIF_F_FW_STOPPING, lif->state)) {
288 work = kzalloc_obj(*work, GFP_ATOMIC);
289 if (!work) {
290 netdev_err(lif->netdev, "Reset event dropped\n");
291 clear_bit(IONIC_LIF_F_FW_STOPPING, lif->state);
292 } else {
293 work->type = IONIC_DW_TYPE_LIF_RESET;
294 ionic_lif_deferred_enqueue(lif, work);
295 }
296 }
297 break;
298 default:
299 netdev_warn(netdev, "Notifyq event ecode=%d eid=%lld\n",
300 comp->event.ecode, eid);
301 break;
302 }
303
304 return true;
305}
306
307bool ionic_adminq_service(struct ionic_cq *cq)
308{
309 struct ionic_admin_desc_info *desc_info;
310 struct ionic_queue *q = cq->bound_q;
311 struct ionic_admin_comp *comp;
312 u16 index;
313
314 comp = &((struct ionic_admin_comp *)cq->base)[cq->tail_idx];
315
316 if (!color_match(comp->color, cq->done_color))
317 return false;
318
319 dma_rmb();
320
321 /* check for empty queue */
322 if (q->tail_idx == q->head_idx)
323 return false;
324
325 do {
326 desc_info = &q->admin_info[q->tail_idx];
327 index = q->tail_idx;
328 q->tail_idx = (q->tail_idx + 1) & (q->num_descs - 1);
329 if (likely(desc_info->ctx)) {
330 struct ionic_admin_ctx *ctx = desc_info->ctx;
331
332 memcpy(&ctx->comp, comp, sizeof(*comp));
333
334 dev_dbg(q->dev, "comp admin queue command:\n");
335 dynamic_hex_dump("comp ", DUMP_PREFIX_OFFSET, 16, 1,
336 &ctx->comp, sizeof(ctx->comp), true);
337 complete_all(&ctx->work);
338 desc_info->ctx = NULL;
339 }
340 } while (index != le16_to_cpu(comp->comp_index));
341
342 return true;
343}
344
345bool ionic_adminq_poke_doorbell(struct ionic_queue *q)
346{
347 struct ionic_lif *lif = q->lif;
348 unsigned long now, then, dif;
349 unsigned long irqflags;
350
351 spin_lock_irqsave(&lif->adminq_lock, irqflags);
352
353 if (q->tail_idx == q->head_idx) {
354 spin_unlock_irqrestore(&lif->adminq_lock, irqflags);
355 return false;
356 }
357
358 now = READ_ONCE(jiffies);
359 then = q->dbell_jiffies;
360 dif = now - then;
361
362 if (dif > q->dbell_deadline) {
363 ionic_dbell_ring(q->lif->kern_dbpage, q->hw_type,
364 q->dbval | q->head_idx);
365
366 q->dbell_jiffies = now;
367 }
368
369 spin_unlock_irqrestore(&lif->adminq_lock, irqflags);
370
371 return true;
372}
373
374int ionic_adminq_post(struct ionic_lif *lif, struct ionic_admin_ctx *ctx)
375{
376 struct ionic_admin_desc_info *desc_info;
377 struct ionic_admin_cmd *desc;
378 unsigned long irqflags;
379 struct ionic_queue *q;
380 int err = 0;
381
382 spin_lock_irqsave(&lif->adminq_lock, irqflags);
383 if (!lif->adminqcq) {
384 spin_unlock_irqrestore(&lif->adminq_lock, irqflags);
385 return -EIO;
386 }
387
388 q = &lif->adminqcq->q;
389
390 if (!ionic_q_has_space(q, 1)) {
391 err = -ENOSPC;
392 goto err_out;
393 }
394
395 err = ionic_heartbeat_check(lif->ionic);
396 if (err)
397 goto err_out;
398
399 desc_info = &q->admin_info[q->head_idx];
400 desc_info->ctx = ctx;
401
402 desc = &q->adminq[q->head_idx];
403 memcpy(desc, &ctx->cmd, sizeof(ctx->cmd));
404
405 dev_dbg(&lif->netdev->dev, "post admin queue command:\n");
406 dynamic_hex_dump("cmd ", DUMP_PREFIX_OFFSET, 16, 1,
407 &ctx->cmd, sizeof(ctx->cmd), true);
408
409 ionic_q_post(q, true);
410
411err_out:
412 spin_unlock_irqrestore(&lif->adminq_lock, irqflags);
413
414 return err;
415}
416
417int ionic_adminq_wait(struct ionic_lif *lif, struct ionic_admin_ctx *ctx,
418 const int err, const bool do_msg)
419{
420 struct net_device *netdev = lif->netdev;
421 unsigned long time_limit;
422 unsigned long time_start;
423 unsigned long time_done;
424 unsigned long remaining;
425 const char *name;
426
427 name = ionic_opcode_to_str(ctx->cmd.cmd.opcode);
428
429 if (err) {
430 if (do_msg && !test_bit(IONIC_LIF_F_FW_RESET, lif->state))
431 netdev_err(netdev, "Posting of %s (%d) failed: %d\n",
432 name, ctx->cmd.cmd.opcode, err);
433 ctx->comp.comp.status = IONIC_RC_ERROR;
434 return err;
435 }
436
437 time_start = jiffies;
438 time_limit = time_start + HZ * (ulong)DEVCMD_TIMEOUT;
439 do {
440 remaining = wait_for_completion_timeout(&ctx->work,
441 IONIC_ADMINQ_TIME_SLICE);
442
443 /* check for done */
444 if (remaining)
445 break;
446
447 /* force a check of FW status and break out if FW reset */
448 ionic_heartbeat_check(lif->ionic);
449 if ((test_bit(IONIC_LIF_F_FW_RESET, lif->state) &&
450 !lif->ionic->idev.fw_status_ready) ||
451 test_bit(IONIC_LIF_F_FW_STOPPING, lif->state)) {
452 if (do_msg)
453 netdev_warn(netdev, "%s (%d) interrupted, FW in reset\n",
454 name, ctx->cmd.cmd.opcode);
455 ctx->comp.comp.status = IONIC_RC_ERROR;
456 return -ENXIO;
457 }
458
459 } while (time_before(jiffies, time_limit));
460 time_done = jiffies;
461
462 dev_dbg(lif->ionic->dev, "%s: elapsed %d msecs\n",
463 __func__, jiffies_to_msecs(time_done - time_start));
464
465 return ionic_adminq_check_err(lif, ctx,
466 time_after_eq(time_done, time_limit),
467 do_msg);
468}
469
470static int __ionic_adminq_post_wait(struct ionic_lif *lif,
471 struct ionic_admin_ctx *ctx,
472 const bool do_msg)
473{
474 int err;
475
476 if (!ionic_is_fw_running(&lif->ionic->idev))
477 return 0;
478
479 err = ionic_adminq_post(lif, ctx);
480
481 return ionic_adminq_wait(lif, ctx, err, do_msg);
482}
483
484int ionic_adminq_post_wait(struct ionic_lif *lif, struct ionic_admin_ctx *ctx)
485{
486 return __ionic_adminq_post_wait(lif, ctx, true);
487}
488EXPORT_SYMBOL_NS(ionic_adminq_post_wait, "NET_IONIC");
489
490int ionic_adminq_post_wait_nomsg(struct ionic_lif *lif, struct ionic_admin_ctx *ctx)
491{
492 return __ionic_adminq_post_wait(lif, ctx, false);
493}
494
495static void ionic_dev_cmd_clean(struct ionic *ionic)
496{
497 struct ionic_dev *idev = &ionic->idev;
498
499 if (!idev->dev_cmd_regs)
500 return;
501
502 iowrite32(0, &idev->dev_cmd_regs->doorbell);
503 memset_io(&idev->dev_cmd_regs->cmd, 0, sizeof(idev->dev_cmd_regs->cmd));
504}
505
506void ionic_dev_cmd_dev_err_print(struct ionic *ionic, u8 opcode, u8 status,
507 int err)
508{
509 const char *stat_str;
510
511 stat_str = (err == -ETIMEDOUT) ? "TIMEOUT" :
512 ionic_error_to_str(status);
513
514 dev_err(ionic->dev, "DEV_CMD %s (%d) error, %s (%d) failed\n",
515 ionic_opcode_to_str(opcode), opcode, stat_str, err);
516}
517
518static int __ionic_dev_cmd_wait(struct ionic *ionic, unsigned long max_seconds,
519 const bool do_msg)
520{
521 struct ionic_dev *idev = &ionic->idev;
522 unsigned long start_time;
523 unsigned long max_wait;
524 unsigned long duration;
525 bool fw_up;
526 int opcode;
527 bool done;
528 int err;
529
530 /* Wait for dev cmd to complete, retrying if we get EAGAIN,
531 * but don't wait any longer than max_seconds.
532 */
533 max_wait = jiffies + (max_seconds * HZ);
534try_again:
535 done = false;
536 opcode = idev->opcode;
537 start_time = jiffies;
538 for (fw_up = ionic_is_fw_running(idev);
539 !done && fw_up && time_before(jiffies, max_wait);
540 fw_up = ionic_is_fw_running(idev)) {
541 done = ionic_dev_cmd_done(idev);
542 if (done)
543 break;
544 usleep_range(100, 200);
545 }
546 duration = jiffies - start_time;
547
548 dev_dbg(ionic->dev, "DEVCMD %s (%d) done=%d took %ld secs (%ld jiffies)\n",
549 ionic_opcode_to_str(opcode), opcode,
550 done, duration / HZ, duration);
551
552 if (!done && !fw_up) {
553 ionic_dev_cmd_clean(ionic);
554 dev_warn(ionic->dev, "DEVCMD %s (%d) interrupted - FW is down\n",
555 ionic_opcode_to_str(opcode), opcode);
556 return -ENXIO;
557 }
558
559 if (!done && !time_before(jiffies, max_wait)) {
560 ionic_dev_cmd_clean(ionic);
561 dev_warn(ionic->dev, "DEVCMD %s (%d) timeout after %ld secs\n",
562 ionic_opcode_to_str(opcode), opcode, max_seconds);
563 return -ETIMEDOUT;
564 }
565
566 err = ionic_dev_cmd_status(&ionic->idev);
567 if (err) {
568 if (err == IONIC_RC_EAGAIN &&
569 time_before(jiffies, (max_wait - HZ))) {
570 dev_dbg(ionic->dev, "DEV_CMD %s (%d), %s (%d) retrying...\n",
571 ionic_opcode_to_str(opcode), opcode,
572 ionic_error_to_str(err), err);
573
574 iowrite32(0, &idev->dev_cmd_regs->done);
575 msleep(1000);
576 iowrite32(1, &idev->dev_cmd_regs->doorbell);
577 goto try_again;
578 }
579
580 if (!(opcode == IONIC_CMD_FW_CONTROL && err == IONIC_RC_EAGAIN))
581 if (do_msg)
582 ionic_dev_cmd_dev_err_print(ionic, opcode, err,
583 ionic_error_to_errno(err));
584
585 return ionic_error_to_errno(err);
586 }
587
588 ionic_dev_cmd_clean(ionic);
589
590 return 0;
591}
592
593int ionic_dev_cmd_wait(struct ionic *ionic, unsigned long max_seconds)
594{
595 return __ionic_dev_cmd_wait(ionic, max_seconds, true);
596}
597
598int ionic_dev_cmd_wait_nomsg(struct ionic *ionic, unsigned long max_seconds)
599{
600 return __ionic_dev_cmd_wait(ionic, max_seconds, false);
601}
602
603int ionic_setup(struct ionic *ionic)
604{
605 int err;
606
607 err = ionic_dev_setup(ionic);
608 if (err)
609 return err;
610 ionic_reset(ionic);
611
612 return 0;
613}
614
615int ionic_identify(struct ionic *ionic)
616{
617 struct ionic_identity *ident = &ionic->ident;
618 struct ionic_dev *idev = &ionic->idev;
619 size_t sz;
620 int err;
621
622 memset(ident, 0, sizeof(*ident));
623
624 ident->drv.os_type = cpu_to_le32(IONIC_OS_TYPE_LINUX);
625 strscpy(ident->drv.driver_ver_str, UTS_RELEASE,
626 sizeof(ident->drv.driver_ver_str));
627
628 mutex_lock(&ionic->dev_cmd_lock);
629
630 sz = min(sizeof(ident->drv), sizeof(idev->dev_cmd_regs->data));
631 memcpy_toio(&idev->dev_cmd_regs->data, &ident->drv, sz);
632
633 ionic_dev_cmd_identify(idev, IONIC_DEV_IDENTITY_VERSION_2);
634 err = ionic_dev_cmd_wait(ionic, DEVCMD_TIMEOUT);
635 if (!err) {
636 sz = min(sizeof(ident->dev), sizeof(idev->dev_cmd_regs->data));
637 memcpy_fromio(&ident->dev, &idev->dev_cmd_regs->data, sz);
638 }
639 mutex_unlock(&ionic->dev_cmd_lock);
640
641 if (err) {
642 dev_err(ionic->dev, "Cannot identify ionic: %d\n", err);
643 goto err_out;
644 }
645
646 if (isprint(idev->dev_info.fw_version[0]) &&
647 isascii(idev->dev_info.fw_version[0]))
648 dev_info(ionic->dev, "FW: %.*s\n",
649 (int)(sizeof(idev->dev_info.fw_version) - 1),
650 idev->dev_info.fw_version);
651 else
652 dev_info(ionic->dev, "FW: (invalid string) 0x%02x 0x%02x 0x%02x 0x%02x ...\n",
653 (u8)idev->dev_info.fw_version[0],
654 (u8)idev->dev_info.fw_version[1],
655 (u8)idev->dev_info.fw_version[2],
656 (u8)idev->dev_info.fw_version[3]);
657
658 err = ionic_lif_identify(ionic, IONIC_LIF_TYPE_CLASSIC,
659 &ionic->ident.lif);
660 if (err) {
661 dev_err(ionic->dev, "Cannot identify LIFs: %d\n", err);
662 goto err_out;
663 }
664
665 return 0;
666
667err_out:
668 return err;
669}
670
671int ionic_init(struct ionic *ionic)
672{
673 struct ionic_dev *idev = &ionic->idev;
674 int err;
675
676 mutex_lock(&ionic->dev_cmd_lock);
677 ionic_dev_cmd_init(idev);
678 err = ionic_dev_cmd_wait(ionic, DEVCMD_TIMEOUT);
679 mutex_unlock(&ionic->dev_cmd_lock);
680
681 return err;
682}
683
684int ionic_reset(struct ionic *ionic)
685{
686 struct ionic_dev *idev = &ionic->idev;
687 int err;
688
689 if (!ionic_is_fw_running(idev))
690 return 0;
691
692 mutex_lock(&ionic->dev_cmd_lock);
693 ionic_dev_cmd_reset(idev);
694 err = ionic_dev_cmd_wait(ionic, DEVCMD_TIMEOUT);
695 mutex_unlock(&ionic->dev_cmd_lock);
696
697 return err;
698}
699
700int ionic_port_identify(struct ionic *ionic)
701{
702 struct ionic_identity *ident = &ionic->ident;
703 struct ionic_dev *idev = &ionic->idev;
704 size_t sz;
705 int err;
706
707 mutex_lock(&ionic->dev_cmd_lock);
708
709 ionic_dev_cmd_port_identify(idev);
710 err = ionic_dev_cmd_wait(ionic, DEVCMD_TIMEOUT);
711 if (!err) {
712 sz = min(sizeof(ident->port), sizeof(idev->dev_cmd_regs->data));
713 memcpy_fromio(&ident->port, &idev->dev_cmd_regs->data, sz);
714 }
715
716 mutex_unlock(&ionic->dev_cmd_lock);
717
718 return err;
719}
720
721int ionic_port_init(struct ionic *ionic)
722{
723 struct ionic_identity *ident = &ionic->ident;
724 struct ionic_dev *idev = &ionic->idev;
725 size_t sz;
726 int err;
727
728 if (!idev->port_info) {
729 idev->port_info_sz = ALIGN(sizeof(*idev->port_info), PAGE_SIZE);
730 idev->port_info = dma_alloc_coherent(ionic->dev,
731 idev->port_info_sz,
732 &idev->port_info_pa,
733 GFP_KERNEL);
734 if (!idev->port_info)
735 return -ENOMEM;
736 }
737
738 /* If the driver knows about more "extra stats" than the firmware,
739 * make sure these stats are marked as invalid.
740 */
741 memset(&idev->port_info->extra_stats, 0xff,
742 sizeof(idev->port_info->extra_stats));
743
744 WRITE_ONCE(idev->link_down_count_init, false);
745
746 sz = min(sizeof(ident->port.config), sizeof(idev->dev_cmd_regs->data));
747
748 mutex_lock(&ionic->dev_cmd_lock);
749
750 memcpy_toio(&idev->dev_cmd_regs->data, &ident->port.config, sz);
751 ionic_dev_cmd_port_init(idev);
752 err = ionic_dev_cmd_wait(ionic, DEVCMD_TIMEOUT);
753
754 ionic_dev_cmd_port_state(&ionic->idev, IONIC_PORT_ADMIN_STATE_UP);
755 ionic_dev_cmd_wait(ionic, DEVCMD_TIMEOUT);
756
757 mutex_unlock(&ionic->dev_cmd_lock);
758 if (err) {
759 dev_err(ionic->dev, "Failed to init port\n");
760 dma_free_coherent(ionic->dev, idev->port_info_sz,
761 idev->port_info, idev->port_info_pa);
762 idev->port_info = NULL;
763 idev->port_info_pa = 0;
764 }
765
766 return err;
767}
768
769int ionic_port_reset(struct ionic *ionic)
770{
771 struct ionic_dev *idev = &ionic->idev;
772 int err = 0;
773
774 if (!idev->port_info)
775 return 0;
776
777 if (ionic_is_fw_running(idev)) {
778 mutex_lock(&ionic->dev_cmd_lock);
779 ionic_dev_cmd_port_reset(idev);
780 err = ionic_dev_cmd_wait(ionic, DEVCMD_TIMEOUT);
781 mutex_unlock(&ionic->dev_cmd_lock);
782 }
783
784 dma_free_coherent(ionic->dev, idev->port_info_sz,
785 idev->port_info, idev->port_info_pa);
786
787 idev->port_info = NULL;
788 idev->port_info_pa = 0;
789
790 return err;
791}
792
793static int __init ionic_init_module(void)
794{
795 int ret;
796
797 ionic_debugfs_create();
798 ret = ionic_bus_register_driver();
799 if (ret)
800 ionic_debugfs_destroy();
801
802 return ret;
803}
804
805static void __exit ionic_cleanup_module(void)
806{
807 ionic_bus_unregister_driver();
808 ionic_debugfs_destroy();
809
810 pr_info("%s removed\n", IONIC_DRV_NAME);
811}
812
813module_init(ionic_init_module);
814module_exit(ionic_cleanup_module);