BXE: bring in the bus_space_{read,write}
[akaros.git] / kern / drivers / net / bxe / bxe_debug.c
1 /*-
2  * Copyright (c) 2007-2014 QLogic Corporation. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS'
15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
24  * THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 //__FBSDID("$FreeBSD: head/sys/dev/bxe/bxe_debug.c 266979 2014-06-02 18:54:45Z marcel $");
28
29 #include "bxe.h"
30
31 #ifdef BXE_REG_NO_INLINE
32
33 /*
34  * Debug versions of the 8/16/32 bit OS register read/write functions to
35  * capture/display values read/written from/to the controller.
36  */
37
38 void
39 bxe_reg_write8(struct bxe_adapter *sc, bus_size_t offset, uint8_t val)
40 {
41     BLOGD(sc, DBG_REGS, "offset=0x%08lx val=0x%02x\n", offset, val);
42     bus_space_write_1(sc->bar[BAR0].tag,
43                       sc->bar[BAR0].handle,
44                       offset,
45                       val);
46 }
47
48 void
49 bxe_reg_write16(struct bxe_adapter *sc, bus_size_t offset, uint16_t val)
50 {
51     if ((offset % 2) != 0) {
52         BLOGD(sc, DBG_REGS, "Unaligned 16-bit write to 0x%08lx\n", offset);
53     }
54
55     BLOGD(sc, DBG_REGS, "offset=0x%08lx val=0x%04x\n", offset, val);
56     bus_space_write_2(sc->bar[BAR0].tag,
57                       sc->bar[BAR0].handle,
58                       offset,
59                       val);
60 }
61
62 void
63 bxe_reg_write32(struct bxe_adapter *sc, bus_size_t offset, uint32_t val)
64 {
65     if ((offset % 4) != 0) {
66         BLOGD(sc, DBG_REGS, "Unaligned 32-bit write to 0x%08lx\n", offset);
67     }
68
69     BLOGD(sc, DBG_REGS, "offset=0x%08lx val=0x%08x\n", offset, val);
70     bus_space_write_4(sc->bar[BAR0].tag,
71                       sc->bar[BAR0].handle,
72                       offset,
73                       val);
74 }
75
76 uint8_t
77 bxe_reg_read8(struct bxe_adapter *sc, bus_size_t offset)
78 {
79     uint8_t val;
80
81     val = bus_space_read_1(sc->bar[BAR0].tag,
82                            sc->bar[BAR0].handle,
83                            offset);
84     BLOGD(sc, DBG_REGS, "offset=0x%08lx val=0x%02x\n", offset, val);
85
86     return (val);
87 }
88
89 uint16_t
90 bxe_reg_read16(struct bxe_adapter *sc, bus_size_t offset)
91 {
92     uint16_t val;
93
94     if ((offset % 2) != 0) {
95         BLOGD(sc, DBG_REGS, "Unaligned 16-bit read from 0x%08lx\n", offset);
96     }
97
98     val = bus_space_read_2(sc->bar[BAR0].tag,
99                            sc->bar[BAR0].handle,
100                            offset);
101     BLOGD(sc, DBG_REGS, "offset=0x%08lx val=0x%08x\n", offset, val);
102
103     return (val);
104 }
105
106 uint32_t
107 bxe_reg_read32(struct bxe_adapter *sc, bus_size_t offset)
108 {
109     uint32_t val;
110
111     if ((offset % 4) != 0) {
112         BLOGD(sc, DBG_REGS, "Unaligned 32-bit read from 0x%08lx\n", offset);
113     }
114
115     val = bus_space_read_4(sc->bar[BAR0].tag,
116                            sc->bar[BAR0].handle,
117                            offset);
118     BLOGD(sc, DBG_REGS, "offset=0x%08lx val=0x%08x\n", offset, val);
119
120     return (val);
121 }
122
123 #endif /* BXE_REG_NO_INLINE */
124
125 #ifdef ELINK_DEBUG
126
127 void
128 elink_cb_dbg(struct bxe_adapter *sc,
129              char             *fmt)
130 {
131     char buf[128];
132     if (__predict_false(sc->debug & DBG_PHY)) {
133         snprintf(buf, sizeof(buf), "ELINK: %s", fmt);
134         device_printf(sc->dev, "%s", buf);
135     }
136 }
137
138 void
139 elink_cb_dbg1(struct bxe_adapter *sc,
140               char             *fmt,
141               uint32_t         arg1)
142 {
143     char tmp[128], buf[128];
144     if (__predict_false(sc->debug & DBG_PHY)) {
145         snprintf(tmp, sizeof(tmp), "ELINK: %s", fmt);
146         snprintf(buf, sizeof(buf), tmp, arg1);
147         device_printf(sc->dev, "%s", buf);
148     }
149 }
150
151 void
152 elink_cb_dbg2(struct bxe_adapter *sc,
153               char             *fmt,
154               uint32_t         arg1,
155               uint32_t         arg2)
156 {
157     char tmp[128], buf[128];
158     if (__predict_false(sc->debug & DBG_PHY)) {
159         snprintf(tmp, sizeof(tmp), "ELINK: %s", fmt);
160         snprintf(buf, sizeof(buf), tmp, arg1, arg2);
161         device_printf(sc->dev, "%s", buf);
162     }
163 }
164
165 void
166 elink_cb_dbg3(struct bxe_adapter *sc,
167               char             *fmt,
168               uint32_t         arg1,
169               uint32_t         arg2,
170               uint32_t         arg3)
171 {
172     char tmp[128], buf[128];
173     if (__predict_false(sc->debug & DBG_PHY)) {
174         snprintf(tmp, sizeof(tmp), "ELINK: %s", fmt);
175         snprintf(buf, sizeof(buf), tmp, arg1, arg2, arg3);
176         device_printf(sc->dev, "%s", buf);
177     }
178 }
179
180 #endif /* ELINK_DEBUG */
181
182 extern qlock_t bxe_prev_mtx;
183
184 #if 0
185 void
186 bxe_dump_mem(struct bxe_adapter *sc,
187              char             *tag,
188              uint8_t          *mem,
189              uint32_t         len)
190 {
191     char buf[256];
192     char c[32];
193     int  xx;
194
195     qlock(&bxe_prev_mtx);
196
197     BLOGI(sc, "++++++++++++ %s\n", tag);
198     strcpy(buf, "** 000: ");
199
200     for (xx = 0; xx < len; xx++)
201     {
202         if ((xx != 0) && (xx % 16 == 0))
203         {
204             BLOGI(sc, "%s\n", buf);
205             strcpy(buf, "** ");
206             snprintf(c, sizeof(c), "%03x", xx);
207             strcat(buf, c);
208             strcat(buf, ": ");
209         }
210
211         snprintf(c, sizeof(c), "%02x ", *mem);
212         strcat(buf, c);
213
214         mem++;
215     }
216
217     BLOGI(sc, "%s\n", buf);
218     BLOGI(sc, "------------ %s\n", tag);
219
220     qunlock(&bxe_prev_mtx);
221 }
222 #endif
223 #if 0
224 void
225 bxe_dump_mbuf_data(struct bxe_adapter *sc,
226                    char             *tag,
227                    struct mbuf      *m,
228                    uint8_t          contents)
229 {
230     char buf[256];
231     char c[32];
232     uint8_t *memp;
233     int i, xx = 0;
234
235     qlock(&bxe_prev_mtx);
236
237     BLOGI(sc, "++++++++++++ %s\n", tag);
238
239     while (m)
240     {
241         memp = m->m_data;
242         strcpy(buf, "** > ");
243         snprintf(c, sizeof(c), "%03x", xx);
244         strcat(buf, c);
245         strcat(buf, ": ");
246
247         if (contents)
248         {
249             for (i = 0; i < m->m_len; i++)
250             {
251                 if ((xx != 0) && (xx % 16 == 0))
252                 {
253                     BLOGI(sc, "%s\n", buf);
254                     strcpy(buf, "**   ");
255                     snprintf(c, sizeof(c), "%03x", xx);
256                     strcat(buf, c);
257                     strcat(buf, ": ");
258                 }
259
260                 snprintf(c, sizeof(c), "%02x ", *memp);
261                 strcat(buf, c);
262
263                 memp++;
264                 xx++;
265             }
266         }
267         else
268         {
269             snprintf(c, sizeof(c), "%d", m->m_len);
270             strcat(buf, c);
271             xx += m->m_len;
272         }
273
274         BLOGI(sc, "%s\n", buf);
275         m = m->m_next;
276     }
277
278     BLOGI(sc, "------------ %s\n", tag);
279
280     qunlock(&bxe_prev_mtx);
281 }
282 #endif
283
284 #ifdef DDB
285
286 static void bxe_ddb_usage()
287 {
288     db_printf("Usage: bxe[/hpv] <instance> [<address>]\n");
289 }
290
291 static db_cmdfcn_t bxe_ddb;
292 _DB_SET(_cmd, bxe, bxe_ddb, db_cmd_table, CS_OWN, NULL);
293
294 static void bxe_ddb(db_expr_t blah1,
295                     boolean_t blah2,
296                     db_expr_t blah3,
297                     char      *blah4)
298 {
299     char if_xname[IFNAMSIZ];
300     if_t ifp = NULL;
301     struct bxe_adapter *sc;
302     db_expr_t next_arg;
303     int index;
304     int tok;
305     int mod_phys_addr = FALSE;
306     int mod_virt_addr = FALSE;
307     db_addr_t addr;
308
309     tok = db_read_token();
310     if (tok == tSLASH) {
311         tok = db_read_token();
312         if (tok != tIDENT) {
313             db_printf("ERROR: bad modifier\n");
314             bxe_ddb_usage();
315             goto bxe_ddb_done;
316         }
317         if (strcmp(db_tok_string, "h") == 0) {
318             bxe_ddb_usage();
319             goto bxe_ddb_done;
320         } else if (strcmp(db_tok_string, "p") == 0) {
321             mod_phys_addr = TRUE;
322         } else if (strcmp(db_tok_string, "v") == 0) {
323             mod_virt_addr = TRUE;
324         }
325     } else {
326         db_unread_token(tok);
327     }
328
329     if (!db_expression((db_expr_t *)&index)) {
330         db_printf("ERROR: bxe index missing\n");
331         bxe_ddb_usage();
332         goto bxe_ddb_done;
333     }
334
335     snprintf(if_xname, sizeof(if_xname), "bxe%d", index);
336     if ((ifp = ifunit_ref(if_xname)) == NULL) /* XXX */
337     {
338         db_printf("ERROR: Invalid interface %s\n", if_xname);
339         goto bxe_ddb_done;
340     }
341
342     sc = (struct bxe_adapter *)if_getsoftc(ifp);
343     db_printf("ifnet=%p (%s)\n", ifp, if_xname);
344     db_printf("softc=%p\n", sc);
345     db_printf("  dev=%p\n", sc->dev);
346     db_printf("  BDF=%d:%d:%d\n",
347               sc->pcie_bus, sc->pcie_device, sc->pcie_func);
348
349     if (mod_phys_addr || mod_virt_addr) {
350         if (!db_expression((db_addr_t *)&addr)) {
351             db_printf("ERROR: Invalid address\n");
352             bxe_ddb_usage();
353             goto bxe_ddb_done;
354         }
355
356         db_printf("addr=%p", addr);
357     }
358
359 bxe_ddb_done:
360
361     db_flush_lex();
362     if (ifp) if_rele(ifp);
363 }
364
365 #endif /* DDB */
366