Line data Source code
1 : /* SPDX-License-Identifier: Apache-2.0
2 : * Copyright(c) 2021 Cisco Systems, Inc.
3 : */
4 :
5 : #include <vlib/vlib.h>
6 : #include <vlib/unix/unix.h>
7 : #include <vlib/pci/pci.h>
8 : #include <vnet/ethernet/ethernet.h>
9 :
10 : #include <avf/avf.h>
11 :
12 : static uword *register_name_by_addr = 0;
13 :
14 : void
15 0 : avf_elog_aq_enq_req (avf_device_t *ad, avf_aq_desc_t *d)
16 : {
17 0 : if (d->opcode == 0x801) /* send_to_pf */
18 : {
19 : ELOG_TYPE_DECLARE (el) = {
20 : .format = "avf[%d] aq_enq_req: send_to_pf flags 0x%x datalen %d "
21 : "v_opcode %s (%d)",
22 : .format_args = "i4i2i2t2i2",
23 : .n_enum_strings = VIRTCHNL_N_OPS,
24 : .enum_strings = {
25 : #define _(v, n) [v] = #n,
26 : foreach_virtchnl_op
27 : #undef _
28 : },
29 : };
30 :
31 : struct
32 : {
33 : u32 dev_instance;
34 : u16 flags;
35 : u16 datalen;
36 : u16 v_opcode;
37 : u16 v_opcode_val;
38 : } * ed;
39 :
40 0 : ed = ELOG_DATA (&vlib_global_main.elog_main, el);
41 0 : ed->dev_instance = ad->dev_instance;
42 0 : ed->flags = d->flags;
43 0 : ed->datalen = d->datalen;
44 0 : ed->v_opcode = ed->v_opcode_val = d->v_opcode;
45 : }
46 : else
47 : {
48 : ELOG_TYPE_DECLARE (el) = {
49 : .format = "avf[%d] aq_enq_req: opcode 0x%x flags 0x%x datalen %d",
50 : .format_args = "i4i2i2i2"
51 : };
52 :
53 : struct
54 : {
55 : u32 dev_instance;
56 : u16 opcode;
57 : u16 flags;
58 : u16 datalen;
59 : } * ed;
60 :
61 0 : ed = ELOG_DATA (&vlib_global_main.elog_main, el);
62 0 : ed->dev_instance = ad->dev_instance;
63 0 : ed->opcode = d->opcode;
64 0 : ed->flags = d->flags;
65 0 : ed->datalen = d->datalen;
66 : }
67 0 : }
68 :
69 : void
70 0 : avf_elog_aq_enq_resp (avf_device_t *ad, avf_aq_desc_t *d)
71 : {
72 : ELOG_TYPE_DECLARE (el) = { .format =
73 : "avf[%d] aq_enq_resp: flags 0x%x retval %d",
74 : .format_args = "i4i2i2" };
75 :
76 : struct
77 : {
78 : u32 dev_instance;
79 : u16 flags;
80 : u16 retval;
81 : } * ed;
82 :
83 0 : ed = ELOG_DATA (&vlib_global_main.elog_main, el);
84 0 : ed->dev_instance = ad->dev_instance;
85 0 : ed->flags = d->flags;
86 0 : ed->retval = d->retval;
87 0 : }
88 :
89 : void
90 0 : avf_elog_arq_desc (avf_device_t *ad, avf_aq_desc_t *d)
91 : {
92 0 : if (d->opcode == 0x802)
93 : {
94 : ELOG_TYPE_DECLARE (el) = {
95 : .format = "avf[%d] arq_desc: msg_from_pf flags 0x%x retval %d "
96 : "v_opcode %s (%d) v_retval %d",
97 : .format_args = "i4i2i2t2i2i2",
98 : .n_enum_strings = VIRTCHNL_N_OPS,
99 : .enum_strings = {
100 : #define _(v, n) [v] = #n,
101 : foreach_virtchnl_op
102 : #undef _
103 : },
104 : };
105 :
106 : struct
107 : {
108 : u32 dev_instance;
109 : u16 flags;
110 : u16 retval;
111 : u16 v_opcode;
112 : u16 v_opcode_val;
113 : u16 v_retval;
114 : } * ed;
115 :
116 0 : ed = ELOG_DATA (&vlib_global_main.elog_main, el);
117 0 : ed->dev_instance = ad->dev_instance;
118 0 : ed->flags = d->flags;
119 0 : ed->retval = d->retval;
120 0 : ed->v_opcode = ed->v_opcode_val = d->v_opcode;
121 0 : ed->v_retval = d->v_retval;
122 : }
123 : else
124 : {
125 : ELOG_TYPE_DECLARE (
126 : el) = { .format = "avf[%d] arq_desc: flags 0x%x retval %d opcode 0x%x",
127 : .format_args = "i4i2i2i2" };
128 :
129 : struct
130 : {
131 : u32 dev_instance;
132 : u16 flags;
133 : u16 retval;
134 : u16 opcode;
135 : } * ed;
136 :
137 0 : ed = ELOG_DATA (&vlib_global_main.elog_main, el);
138 0 : ed->dev_instance = ad->dev_instance;
139 0 : ed->flags = d->flags;
140 0 : ed->retval = d->retval;
141 0 : ed->opcode = d->opcode;
142 : }
143 0 : }
144 :
145 : void
146 0 : avf_elog_reg (avf_device_t *ad, u32 addr, u32 val, int is_read)
147 : {
148 : uword *p;
149 : ELOG_TYPE_DECLARE (el) = {
150 : .format = "avf[%d] reg: %s %s [0x%04x] val 0x%08x",
151 : .format_args = "i4s4s4i4i4",
152 : };
153 :
154 : struct
155 : {
156 : u32 dev_instance;
157 : char rw[4];
158 : char reg_name[24];
159 : u32 addr;
160 : u32 val;
161 : } * ed;
162 :
163 0 : ed = ELOG_DATA (&vlib_global_main.elog_main, el);
164 0 : ed->dev_instance = ad->dev_instance;
165 0 : ed->addr = addr;
166 0 : ed->val = val;
167 0 : ed->rw[0] = is_read ? 'r' : 'w';
168 0 : ed->rw[1] = 0;
169 :
170 0 : p = hash_get (register_name_by_addr, addr);
171 0 : strncpy (ed->reg_name, p ? (char *) p[0] : "unknown", 24);
172 0 : ed->reg_name[23] = 0;
173 0 : }
174 :
175 : void
176 0 : avf_elog_init (void)
177 : {
178 0 : if (register_name_by_addr)
179 0 : return;
180 :
181 0 : register_name_by_addr = hash_create (0, sizeof (uword));
182 :
183 0 : hash_set (register_name_by_addr, AVFINT_ICR0, "AVFINT_ICR0");
184 0 : hash_set (register_name_by_addr, AVFINT_ICR0_ENA1, "INT_ICR0_ENA1");
185 0 : hash_set (register_name_by_addr, AVFINT_DYN_CTL0, "INT_DYN_CTL0");
186 0 : hash_set (register_name_by_addr, AVF_ARQBAH, "ARQBAH");
187 0 : hash_set (register_name_by_addr, AVF_ATQH, "ATQH");
188 0 : hash_set (register_name_by_addr, AVF_ATQLEN, "ATQLEN");
189 0 : hash_set (register_name_by_addr, AVF_ARQBAL, "ARQBAL");
190 0 : hash_set (register_name_by_addr, AVF_ARQT, "ARQT");
191 0 : hash_set (register_name_by_addr, AVF_ARQH, "ARQH");
192 0 : hash_set (register_name_by_addr, AVF_ATQBAH, "ATQBAH");
193 0 : hash_set (register_name_by_addr, AVF_ATQBAL, "ATQBAL");
194 0 : hash_set (register_name_by_addr, AVF_ARQLEN, "ARQLEN");
195 0 : hash_set (register_name_by_addr, AVF_ATQT, "ATQT");
196 0 : hash_set (register_name_by_addr, AVFGEN_RSTAT, "GEN_RSTAT");
197 :
198 0 : for (int i = 0; i < 16; i++)
199 : {
200 0 : hash_set (register_name_by_addr, AVFINT_DYN_CTLN (i),
201 : format (0, "INT_DYN_CTLN(%u)%c", i, 0));
202 0 : hash_set (register_name_by_addr, AVF_QTX_TAIL (i),
203 : format (0, "QTX_TAIL(%u)%c", i, 0));
204 0 : hash_set (register_name_by_addr, AVF_QRX_TAIL (i),
205 : format (0, "QRX_TAIL(%u)%c", i, 0));
206 : }
207 : }
|
