include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-2.6.git] / drivers / infiniband / hw / cxgb3 / cxio_dbg.c
1 /*
2  * Copyright (c) 2006 Chelsio, Inc. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  */
32 #ifdef DEBUG
33 #include <linux/types.h>
34 #include <linux/slab.h>
35 #include "common.h"
36 #include "cxgb3_ioctl.h"
37 #include "cxio_hal.h"
38 #include "cxio_wr.h"
39
40 void cxio_dump_tpt(struct cxio_rdev *rdev, u32 stag)
41 {
42         struct ch_mem_range *m;
43         u64 *data;
44         int rc;
45         int size = 32;
46
47         m = kmalloc(sizeof(*m) + size, GFP_ATOMIC);
48         if (!m) {
49                 PDBG("%s couldn't allocate memory.\n", __func__);
50                 return;
51         }
52         m->mem_id = MEM_PMRX;
53         m->addr = (stag>>8) * 32 + rdev->rnic_info.tpt_base;
54         m->len = size;
55         PDBG("%s TPT addr 0x%x len %d\n", __func__, m->addr, m->len);
56         rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m);
57         if (rc) {
58                 PDBG("%s toectl returned error %d\n", __func__, rc);
59                 kfree(m);
60                 return;
61         }
62
63         data = (u64 *)m->buf;
64         while (size > 0) {
65                 PDBG("TPT %08x: %016llx\n", m->addr, (unsigned long long) *data);
66                 size -= 8;
67                 data++;
68                 m->addr += 8;
69         }
70         kfree(m);
71 }
72
73 void cxio_dump_pbl(struct cxio_rdev *rdev, u32 pbl_addr, uint len, u8 shift)
74 {
75         struct ch_mem_range *m;
76         u64 *data;
77         int rc;
78         int size, npages;
79
80         shift += 12;
81         npages = (len + (1ULL << shift) - 1) >> shift;
82         size = npages * sizeof(u64);
83
84         m = kmalloc(sizeof(*m) + size, GFP_ATOMIC);
85         if (!m) {
86                 PDBG("%s couldn't allocate memory.\n", __func__);
87                 return;
88         }
89         m->mem_id = MEM_PMRX;
90         m->addr = pbl_addr;
91         m->len = size;
92         PDBG("%s PBL addr 0x%x len %d depth %d\n",
93                 __func__, m->addr, m->len, npages);
94         rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m);
95         if (rc) {
96                 PDBG("%s toectl returned error %d\n", __func__, rc);
97                 kfree(m);
98                 return;
99         }
100
101         data = (u64 *)m->buf;
102         while (size > 0) {
103                 PDBG("PBL %08x: %016llx\n", m->addr, (unsigned long long) *data);
104                 size -= 8;
105                 data++;
106                 m->addr += 8;
107         }
108         kfree(m);
109 }
110
111 void cxio_dump_wqe(union t3_wr *wqe)
112 {
113         __be64 *data = (__be64 *)wqe;
114         uint size = (uint)(be64_to_cpu(*data) & 0xff);
115
116         if (size == 0)
117                 size = 8;
118         while (size > 0) {
119                 PDBG("WQE %p: %016llx\n", data,
120                      (unsigned long long) be64_to_cpu(*data));
121                 size--;
122                 data++;
123         }
124 }
125
126 void cxio_dump_wce(struct t3_cqe *wce)
127 {
128         __be64 *data = (__be64 *)wce;
129         int size = sizeof(*wce);
130
131         while (size > 0) {
132                 PDBG("WCE %p: %016llx\n", data,
133                      (unsigned long long) be64_to_cpu(*data));
134                 size -= 8;
135                 data++;
136         }
137 }
138
139 void cxio_dump_rqt(struct cxio_rdev *rdev, u32 hwtid, int nents)
140 {
141         struct ch_mem_range *m;
142         int size = nents * 64;
143         u64 *data;
144         int rc;
145
146         m = kmalloc(sizeof(*m) + size, GFP_ATOMIC);
147         if (!m) {
148                 PDBG("%s couldn't allocate memory.\n", __func__);
149                 return;
150         }
151         m->mem_id = MEM_PMRX;
152         m->addr = ((hwtid)<<10) + rdev->rnic_info.rqt_base;
153         m->len = size;
154         PDBG("%s RQT addr 0x%x len %d\n", __func__, m->addr, m->len);
155         rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m);
156         if (rc) {
157                 PDBG("%s toectl returned error %d\n", __func__, rc);
158                 kfree(m);
159                 return;
160         }
161
162         data = (u64 *)m->buf;
163         while (size > 0) {
164                 PDBG("RQT %08x: %016llx\n", m->addr, (unsigned long long) *data);
165                 size -= 8;
166                 data++;
167                 m->addr += 8;
168         }
169         kfree(m);
170 }
171
172 void cxio_dump_tcb(struct cxio_rdev *rdev, u32 hwtid)
173 {
174         struct ch_mem_range *m;
175         int size = TCB_SIZE;
176         u32 *data;
177         int rc;
178
179         m = kmalloc(sizeof(*m) + size, GFP_ATOMIC);
180         if (!m) {
181                 PDBG("%s couldn't allocate memory.\n", __func__);
182                 return;
183         }
184         m->mem_id = MEM_CM;
185         m->addr = hwtid * size;
186         m->len = size;
187         PDBG("%s TCB %d len %d\n", __func__, m->addr, m->len);
188         rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m);
189         if (rc) {
190                 PDBG("%s toectl returned error %d\n", __func__, rc);
191                 kfree(m);
192                 return;
193         }
194
195         data = (u32 *)m->buf;
196         while (size > 0) {
197                 printk("%2u: %08x %08x %08x %08x %08x %08x %08x %08x\n",
198                         m->addr,
199                         *(data+2), *(data+3), *(data),*(data+1),
200                         *(data+6), *(data+7), *(data+4), *(data+5));
201                 size -= 32;
202                 data += 8;
203                 m->addr += 32;
204         }
205         kfree(m);
206 }
207 #endif