1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2017 - 2019 Pensando Systems, Inc */
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 <linux/vermagic.h>
12 #include "ionic_bus.h"
13 #include "ionic_lif.h"
14 #include "ionic_debugfs.h"
16 MODULE_DESCRIPTION(IONIC_DRV_DESCRIPTION
);
17 MODULE_AUTHOR("Pensando Systems, Inc");
18 MODULE_LICENSE("GPL");
20 static const char *ionic_error_to_str(enum ionic_status_code code
)
23 case IONIC_RC_SUCCESS
:
24 return "IONIC_RC_SUCCESS";
25 case IONIC_RC_EVERSION
:
26 return "IONIC_RC_EVERSION";
27 case IONIC_RC_EOPCODE
:
28 return "IONIC_RC_EOPCODE";
30 return "IONIC_RC_EIO";
32 return "IONIC_RC_EPERM";
34 return "IONIC_RC_EQID";
36 return "IONIC_RC_EQTYPE";
38 return "IONIC_RC_ENOENT";
40 return "IONIC_RC_EINTR";
42 return "IONIC_RC_EAGAIN";
44 return "IONIC_RC_ENOMEM";
46 return "IONIC_RC_EFAULT";
48 return "IONIC_RC_EBUSY";
50 return "IONIC_RC_EEXIST";
52 return "IONIC_RC_EINVAL";
54 return "IONIC_RC_ENOSPC";
56 return "IONIC_RC_ERANGE";
57 case IONIC_RC_BAD_ADDR
:
58 return "IONIC_RC_BAD_ADDR";
59 case IONIC_RC_DEV_CMD
:
60 return "IONIC_RC_DEV_CMD";
61 case IONIC_RC_ENOSUPP
:
62 return "IONIC_RC_ENOSUPP";
64 return "IONIC_RC_ERROR";
66 return "IONIC_RC_ERDMA";
68 return "IONIC_RC_UNKNOWN";
72 static int ionic_error_to_errno(enum ionic_status_code code
)
75 case IONIC_RC_SUCCESS
:
77 case IONIC_RC_EVERSION
:
81 case IONIC_RC_ENOSUPP
:
101 case IONIC_RC_BAD_ADDR
:
103 case IONIC_RC_EOPCODE
:
105 case IONIC_RC_DEV_CMD
:
114 static const char *ionic_opcode_to_str(enum ionic_cmd_opcode opcode
)
118 return "IONIC_CMD_NOP";
120 return "IONIC_CMD_INIT";
121 case IONIC_CMD_RESET
:
122 return "IONIC_CMD_RESET";
123 case IONIC_CMD_IDENTIFY
:
124 return "IONIC_CMD_IDENTIFY";
125 case IONIC_CMD_GETATTR
:
126 return "IONIC_CMD_GETATTR";
127 case IONIC_CMD_SETATTR
:
128 return "IONIC_CMD_SETATTR";
129 case IONIC_CMD_PORT_IDENTIFY
:
130 return "IONIC_CMD_PORT_IDENTIFY";
131 case IONIC_CMD_PORT_INIT
:
132 return "IONIC_CMD_PORT_INIT";
133 case IONIC_CMD_PORT_RESET
:
134 return "IONIC_CMD_PORT_RESET";
135 case IONIC_CMD_PORT_GETATTR
:
136 return "IONIC_CMD_PORT_GETATTR";
137 case IONIC_CMD_PORT_SETATTR
:
138 return "IONIC_CMD_PORT_SETATTR";
139 case IONIC_CMD_LIF_INIT
:
140 return "IONIC_CMD_LIF_INIT";
141 case IONIC_CMD_LIF_RESET
:
142 return "IONIC_CMD_LIF_RESET";
143 case IONIC_CMD_LIF_IDENTIFY
:
144 return "IONIC_CMD_LIF_IDENTIFY";
145 case IONIC_CMD_LIF_SETATTR
:
146 return "IONIC_CMD_LIF_SETATTR";
147 case IONIC_CMD_LIF_GETATTR
:
148 return "IONIC_CMD_LIF_GETATTR";
149 case IONIC_CMD_RX_MODE_SET
:
150 return "IONIC_CMD_RX_MODE_SET";
151 case IONIC_CMD_RX_FILTER_ADD
:
152 return "IONIC_CMD_RX_FILTER_ADD";
153 case IONIC_CMD_RX_FILTER_DEL
:
154 return "IONIC_CMD_RX_FILTER_DEL";
155 case IONIC_CMD_Q_INIT
:
156 return "IONIC_CMD_Q_INIT";
157 case IONIC_CMD_Q_CONTROL
:
158 return "IONIC_CMD_Q_CONTROL";
159 case IONIC_CMD_RDMA_RESET_LIF
:
160 return "IONIC_CMD_RDMA_RESET_LIF";
161 case IONIC_CMD_RDMA_CREATE_EQ
:
162 return "IONIC_CMD_RDMA_CREATE_EQ";
163 case IONIC_CMD_RDMA_CREATE_CQ
:
164 return "IONIC_CMD_RDMA_CREATE_CQ";
165 case IONIC_CMD_RDMA_CREATE_ADMINQ
:
166 return "IONIC_CMD_RDMA_CREATE_ADMINQ";
167 case IONIC_CMD_FW_DOWNLOAD
:
168 return "IONIC_CMD_FW_DOWNLOAD";
169 case IONIC_CMD_FW_CONTROL
:
170 return "IONIC_CMD_FW_CONTROL";
171 case IONIC_CMD_VF_GETATTR
:
172 return "IONIC_CMD_VF_GETATTR";
173 case IONIC_CMD_VF_SETATTR
:
174 return "IONIC_CMD_VF_SETATTR";
176 return "DEVCMD_UNKNOWN";
180 static void ionic_adminq_flush(struct ionic_lif
*lif
)
182 struct ionic_queue
*adminq
= &lif
->adminqcq
->q
;
184 spin_lock(&lif
->adminq_lock
);
186 while (adminq
->tail
!= adminq
->head
) {
187 memset(adminq
->tail
->desc
, 0, sizeof(union ionic_adminq_cmd
));
188 adminq
->tail
->cb
= NULL
;
189 adminq
->tail
->cb_arg
= NULL
;
190 adminq
->tail
= adminq
->tail
->next
;
192 spin_unlock(&lif
->adminq_lock
);
195 static int ionic_adminq_check_err(struct ionic_lif
*lif
,
196 struct ionic_admin_ctx
*ctx
,
199 struct net_device
*netdev
= lif
->netdev
;
200 const char *opcode_str
;
201 const char *status_str
;
204 if (ctx
->comp
.comp
.status
|| timeout
) {
205 opcode_str
= ionic_opcode_to_str(ctx
->cmd
.cmd
.opcode
);
206 status_str
= ionic_error_to_str(ctx
->comp
.comp
.status
);
207 err
= timeout
? -ETIMEDOUT
:
208 ionic_error_to_errno(ctx
->comp
.comp
.status
);
210 netdev_err(netdev
, "%s (%d) failed: %s (%d)\n",
211 opcode_str
, ctx
->cmd
.cmd
.opcode
,
212 timeout
? "TIMEOUT" : status_str
, err
);
215 ionic_adminq_flush(lif
);
221 static void ionic_adminq_cb(struct ionic_queue
*q
,
222 struct ionic_desc_info
*desc_info
,
223 struct ionic_cq_info
*cq_info
, void *cb_arg
)
225 struct ionic_admin_ctx
*ctx
= cb_arg
;
226 struct ionic_admin_comp
*comp
;
232 comp
= cq_info
->cq_desc
;
233 dev
= &q
->lif
->netdev
->dev
;
235 memcpy(&ctx
->comp
, comp
, sizeof(*comp
));
237 dev_dbg(dev
, "comp admin queue command:\n");
238 dynamic_hex_dump("comp ", DUMP_PREFIX_OFFSET
, 16, 1,
239 &ctx
->comp
, sizeof(ctx
->comp
), true);
241 complete_all(&ctx
->work
);
244 static int ionic_adminq_post(struct ionic_lif
*lif
, struct ionic_admin_ctx
*ctx
)
246 struct ionic_queue
*adminq
;
249 WARN_ON(in_interrupt());
254 adminq
= &lif
->adminqcq
->q
;
256 spin_lock(&lif
->adminq_lock
);
257 if (!ionic_q_has_space(adminq
, 1)) {
262 err
= ionic_heartbeat_check(lif
->ionic
);
266 memcpy(adminq
->head
->desc
, &ctx
->cmd
, sizeof(ctx
->cmd
));
268 dev_dbg(&lif
->netdev
->dev
, "post admin queue command:\n");
269 dynamic_hex_dump("cmd ", DUMP_PREFIX_OFFSET
, 16, 1,
270 &ctx
->cmd
, sizeof(ctx
->cmd
), true);
272 ionic_q_post(adminq
, true, ionic_adminq_cb
, ctx
);
275 spin_unlock(&lif
->adminq_lock
);
280 int ionic_adminq_post_wait(struct ionic_lif
*lif
, struct ionic_admin_ctx
*ctx
)
282 struct net_device
*netdev
= lif
->netdev
;
283 unsigned long remaining
;
287 err
= ionic_adminq_post(lif
, ctx
);
289 if (!test_bit(IONIC_LIF_F_FW_RESET
, lif
->state
)) {
290 name
= ionic_opcode_to_str(ctx
->cmd
.cmd
.opcode
);
291 netdev_err(netdev
, "Posting of %s (%d) failed: %d\n",
292 name
, ctx
->cmd
.cmd
.opcode
, err
);
297 remaining
= wait_for_completion_timeout(&ctx
->work
,
298 HZ
* (ulong
)DEVCMD_TIMEOUT
);
299 return ionic_adminq_check_err(lif
, ctx
, (remaining
== 0));
302 int ionic_napi(struct napi_struct
*napi
, int budget
, ionic_cq_cb cb
,
303 ionic_cq_done_cb done_cb
, void *done_arg
)
305 struct ionic_qcq
*qcq
= napi_to_qcq(napi
);
306 struct ionic_cq
*cq
= &qcq
->cq
;
307 u32 work_done
, flags
= 0;
309 work_done
= ionic_cq_service(cq
, budget
, cb
, done_cb
, done_arg
);
311 if (work_done
< budget
&& napi_complete_done(napi
, work_done
)) {
312 flags
|= IONIC_INTR_CRED_UNMASK
;
313 DEBUG_STATS_INTR_REARM(cq
->bound_intr
);
316 if (work_done
|| flags
) {
317 flags
|= IONIC_INTR_CRED_RESET_COALESCE
;
318 ionic_intr_credits(cq
->lif
->ionic
->idev
.intr_ctrl
,
319 cq
->bound_intr
->index
,
323 DEBUG_STATS_NAPI_POLL(qcq
, work_done
);
328 static void ionic_dev_cmd_clean(struct ionic
*ionic
)
330 union ionic_dev_cmd_regs
*regs
= ionic
->idev
.dev_cmd_regs
;
332 iowrite32(0, ®s
->doorbell
);
333 memset_io(®s
->cmd
, 0, sizeof(regs
->cmd
));
336 int ionic_dev_cmd_wait(struct ionic
*ionic
, unsigned long max_seconds
)
338 struct ionic_dev
*idev
= &ionic
->idev
;
339 unsigned long start_time
;
340 unsigned long max_wait
;
341 unsigned long duration
;
347 WARN_ON(in_interrupt());
349 /* Wait for dev cmd to complete, retrying if we get EAGAIN,
350 * but don't wait any longer than max_seconds.
352 max_wait
= jiffies
+ (max_seconds
* HZ
);
354 start_time
= jiffies
;
356 done
= ionic_dev_cmd_done(idev
);
360 hb
= ionic_heartbeat_check(ionic
);
361 } while (!done
&& !hb
&& time_before(jiffies
, max_wait
));
362 duration
= jiffies
- start_time
;
364 opcode
= idev
->dev_cmd_regs
->cmd
.cmd
.opcode
;
365 dev_dbg(ionic
->dev
, "DEVCMD %s (%d) done=%d took %ld secs (%ld jiffies)\n",
366 ionic_opcode_to_str(opcode
), opcode
,
367 done
, duration
/ HZ
, duration
);
370 /* It is possible (but unlikely) that FW was busy and missed a
371 * heartbeat check but is still alive and will process this
372 * request, so don't clean the dev_cmd in this case.
374 dev_warn(ionic
->dev
, "DEVCMD %s (%d) failed - FW halted\n",
375 ionic_opcode_to_str(opcode
), opcode
);
379 if (!done
&& !time_before(jiffies
, max_wait
)) {
380 ionic_dev_cmd_clean(ionic
);
381 dev_warn(ionic
->dev
, "DEVCMD %s (%d) timeout after %ld secs\n",
382 ionic_opcode_to_str(opcode
), opcode
, max_seconds
);
386 err
= ionic_dev_cmd_status(&ionic
->idev
);
388 if (err
== IONIC_RC_EAGAIN
&& !time_after(jiffies
, max_wait
)) {
389 dev_err(ionic
->dev
, "DEV_CMD %s (%d) error, %s (%d) retrying...\n",
390 ionic_opcode_to_str(opcode
), opcode
,
391 ionic_error_to_str(err
), err
);
394 iowrite32(0, &idev
->dev_cmd_regs
->done
);
395 iowrite32(1, &idev
->dev_cmd_regs
->doorbell
);
399 dev_err(ionic
->dev
, "DEV_CMD %s (%d) error, %s (%d) failed\n",
400 ionic_opcode_to_str(opcode
), opcode
,
401 ionic_error_to_str(err
), err
);
403 return ionic_error_to_errno(err
);
409 int ionic_setup(struct ionic
*ionic
)
413 err
= ionic_dev_setup(ionic
);
420 int ionic_identify(struct ionic
*ionic
)
422 struct ionic_identity
*ident
= &ionic
->ident
;
423 struct ionic_dev
*idev
= &ionic
->idev
;
427 memset(ident
, 0, sizeof(*ident
));
429 ident
->drv
.os_type
= cpu_to_le32(IONIC_OS_TYPE_LINUX
);
430 strncpy(ident
->drv
.driver_ver_str
, UTS_RELEASE
,
431 sizeof(ident
->drv
.driver_ver_str
) - 1);
433 mutex_lock(&ionic
->dev_cmd_lock
);
435 sz
= min(sizeof(ident
->drv
), sizeof(idev
->dev_cmd_regs
->data
));
436 memcpy_toio(&idev
->dev_cmd_regs
->data
, &ident
->drv
, sz
);
438 ionic_dev_cmd_identify(idev
, IONIC_IDENTITY_VERSION_1
);
439 err
= ionic_dev_cmd_wait(ionic
, DEVCMD_TIMEOUT
);
441 sz
= min(sizeof(ident
->dev
), sizeof(idev
->dev_cmd_regs
->data
));
442 memcpy_fromio(&ident
->dev
, &idev
->dev_cmd_regs
->data
, sz
);
445 mutex_unlock(&ionic
->dev_cmd_lock
);
450 ionic_debugfs_add_ident(ionic
);
458 int ionic_init(struct ionic
*ionic
)
460 struct ionic_dev
*idev
= &ionic
->idev
;
463 mutex_lock(&ionic
->dev_cmd_lock
);
464 ionic_dev_cmd_init(idev
);
465 err
= ionic_dev_cmd_wait(ionic
, DEVCMD_TIMEOUT
);
466 mutex_unlock(&ionic
->dev_cmd_lock
);
471 int ionic_reset(struct ionic
*ionic
)
473 struct ionic_dev
*idev
= &ionic
->idev
;
476 mutex_lock(&ionic
->dev_cmd_lock
);
477 ionic_dev_cmd_reset(idev
);
478 err
= ionic_dev_cmd_wait(ionic
, DEVCMD_TIMEOUT
);
479 mutex_unlock(&ionic
->dev_cmd_lock
);
484 int ionic_port_identify(struct ionic
*ionic
)
486 struct ionic_identity
*ident
= &ionic
->ident
;
487 struct ionic_dev
*idev
= &ionic
->idev
;
491 mutex_lock(&ionic
->dev_cmd_lock
);
493 ionic_dev_cmd_port_identify(idev
);
494 err
= ionic_dev_cmd_wait(ionic
, DEVCMD_TIMEOUT
);
496 sz
= min(sizeof(ident
->port
), sizeof(idev
->dev_cmd_regs
->data
));
497 memcpy_fromio(&ident
->port
, &idev
->dev_cmd_regs
->data
, sz
);
500 mutex_unlock(&ionic
->dev_cmd_lock
);
505 int ionic_port_init(struct ionic
*ionic
)
507 struct ionic_identity
*ident
= &ionic
->ident
;
508 struct ionic_dev
*idev
= &ionic
->idev
;
512 if (!idev
->port_info
) {
513 idev
->port_info_sz
= ALIGN(sizeof(*idev
->port_info
), PAGE_SIZE
);
514 idev
->port_info
= dma_alloc_coherent(ionic
->dev
,
518 if (!idev
->port_info
) {
519 dev_err(ionic
->dev
, "Failed to allocate port info\n");
524 sz
= min(sizeof(ident
->port
.config
), sizeof(idev
->dev_cmd_regs
->data
));
526 mutex_lock(&ionic
->dev_cmd_lock
);
528 memcpy_toio(&idev
->dev_cmd_regs
->data
, &ident
->port
.config
, sz
);
529 ionic_dev_cmd_port_init(idev
);
530 err
= ionic_dev_cmd_wait(ionic
, DEVCMD_TIMEOUT
);
532 ionic_dev_cmd_port_state(&ionic
->idev
, IONIC_PORT_ADMIN_STATE_UP
);
533 (void)ionic_dev_cmd_wait(ionic
, DEVCMD_TIMEOUT
);
535 mutex_unlock(&ionic
->dev_cmd_lock
);
537 dev_err(ionic
->dev
, "Failed to init port\n");
538 dma_free_coherent(ionic
->dev
, idev
->port_info_sz
,
539 idev
->port_info
, idev
->port_info_pa
);
540 idev
->port_info
= NULL
;
541 idev
->port_info_pa
= 0;
547 int ionic_port_reset(struct ionic
*ionic
)
549 struct ionic_dev
*idev
= &ionic
->idev
;
552 if (!idev
->port_info
)
555 mutex_lock(&ionic
->dev_cmd_lock
);
556 ionic_dev_cmd_port_reset(idev
);
557 err
= ionic_dev_cmd_wait(ionic
, DEVCMD_TIMEOUT
);
558 mutex_unlock(&ionic
->dev_cmd_lock
);
560 dma_free_coherent(ionic
->dev
, idev
->port_info_sz
,
561 idev
->port_info
, idev
->port_info_pa
);
563 idev
->port_info
= NULL
;
564 idev
->port_info_pa
= 0;
567 dev_err(ionic
->dev
, "Failed to reset port\n");
572 static int __init
ionic_init_module(void)
574 ionic_debugfs_create();
575 return ionic_bus_register_driver();
578 static void __exit
ionic_cleanup_module(void)
580 ionic_bus_unregister_driver();
581 ionic_debugfs_destroy();
583 pr_info("%s removed\n", IONIC_DRV_NAME
);
586 module_init(ionic_init_module
);
587 module_exit(ionic_cleanup_module
);