Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[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 "common.h"
35 #include "cxgb3_ioctl.h"
36 #include "cxio_hal.h"
37 #include "cxio_wr.h"
38
39 void cxio_dump_tpt(struct cxio_rdev *rdev, u32 stag)
40 {
41         struct ch_mem_range *m;
42         u64 *data;
43         int rc;
44         int size = 32;
45
46         m = kmalloc(sizeof(*m) + size, GFP_ATOMIC);
47         if (!m) {
48                 PDBG("%s couldn't allocate memory.\n", __func__);
49                 return;
50         }
51         m->mem_id = MEM_PMRX;
52         m->addr = (stag>>8) * 32 + rdev->rnic_info.tpt_base;
53         m->len = size;
54         PDBG("%s TPT addr 0x%x len %d\n", __func__, m->addr, m->len);
55         rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m);
56         if (rc) {
57                 PDBG("%s toectl returned error %d\n", __func__, rc);
58                 kfree(m);
59                 return;
60         }
61
62         data = (u64 *)m->buf;
63         while (size > 0) {
64                 PDBG("TPT %08x: %016llx\n", m->addr, (unsigned long long) *data);
65                 size -= 8;
66                 data++;
67                 m->addr += 8;
68         }
69         kfree(m);
70 }
71
72 void cxio_dump_pbl(struct cxio_rdev *rdev, u32 pbl_addr, uint len, u8 shift)
73 {
74         struct ch_mem_range *m;
75         u64 *data;
76         int rc;
77         int size, npages;
78
79         shift += 12;
80         npages = (len + (1ULL << shift) - 1) >> shift;
81         size = npages * sizeof(u64);
82
83         m = kmalloc(sizeof(*m) + size, GFP_ATOMIC);
84         if (!m) {
85                 PDBG("%s couldn't allocate memory.\n", __func__);
86                 return;
87         }
88         m->mem_id = MEM_PMRX;
89         m->addr = pbl_addr;
90         m->len = size;
91         PDBG("%s PBL addr 0x%x len %d depth %d\n",
92                 __func__, m->addr, m->len, npages);
93         rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m);
94         if (rc) {
95                 PDBG("%s toectl returned error %d\n", __func__, rc);
96                 kfree(m);
97                 return;
98         }
99
100         data = (u64 *)m->buf;
101         while (size > 0) {
102                 PDBG("PBL %08x: %016llx\n", m->addr, (unsigned long long) *data);
103                 size -= 8;
104                 data++;
105                 m->addr += 8;
106         }
107         kfree(m);
108 }
109
110 void cxio_dump_wqe(union t3_wr *wqe)
111 {
112         __be64 *data = (__be64 *)wqe;
113         uint size = (uint)(be64_to_cpu(*data) & 0xff);
114
115         if (size == 0)
116                 size = 8;
117         while (size > 0) {
118                 PDBG("WQE %p: %016llx\n", data,
119                      (unsigned long long) be64_to_cpu(*data));
120                 size--;
121                 data++;
122         }
123 }
124
125 void cxio_dump_wce(struct t3_cqe *wce)
126 {
127         __be64 *data = (__be64 *)wce;
128         int size = sizeof(*wce);
129
130         while (size > 0) {
131                 PDBG("WCE %p: %016llx\n", data,
132                      (unsigned long long) be64_to_cpu(*data));
133                 size -= 8;
134                 data++;
135         }
136 }
137
138 void cxio_dump_rqt(struct cxio_rdev *rdev, u32 hwtid, int nents)
139 {
140         struct ch_mem_range *m;
141         int size = nents * 64;
142         u64 *data;
143         int rc;
144
145         m = kmalloc(sizeof(*m) + size, GFP_ATOMIC);
146         if (!m) {
147                 PDBG("%s couldn't allocate memory.\n", __func__);
148                 return;
149         }
150         m->mem_id = MEM_PMRX;
151         m->addr = ((hwtid)<<10) + rdev->rnic_info.rqt_base;
152         m->len = size;
153         PDBG("%s RQT addr 0x%x len %d\n", __func__, m->addr, m->len);
154         rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m);
155         if (rc) {
156                 PDBG("%s toectl returned error %d\n", __func__, rc);
157                 kfree(m);
158                 return;
159         }
160
161         data = (u64 *)m->buf;
162         while (size > 0) {
163                 PDBG("RQT %08x: %016llx\n", m->addr, (unsigned long long) *data);
164                 size -= 8;
165                 data++;
166                 m->addr += 8;
167         }
168         kfree(m);
169 }
170
171 void cxio_dump_tcb(struct cxio_rdev *rdev, u32 hwtid)
172 {
173         struct ch_mem_range *m;
174         int size = TCB_SIZE;
175         u32 *data;
176         int rc;
177
178         m = kmalloc(sizeof(*m) + size, GFP_ATOMIC);
179         if (!m) {
180                 PDBG("%s couldn't allocate memory.\n", __func__);
181                 return;
182         }
183         m->mem_id = MEM_CM;
184         m->addr = hwtid * size;
185         m->len = size;
186         PDBG("%s TCB %d len %d\n", __func__, m->addr, m->len);
187         rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m);
188         if (rc) {
189                 PDBG("%s toectl returned error %d\n", __func__, rc);
190                 kfree(m);
191                 return;
192         }
193
194         data = (u32 *)m->buf;
195         while (size > 0) {
196                 printk("%2u: %08x %08x %08x %08x %08x %08x %08x %08x\n",
197                         m->addr,
198                         *(data+2), *(data+3), *(data),*(data+1),
199                         *(data+6), *(data+7), *(data+4), *(data+5));
200                 size -= 32;
201                 data += 8;
202                 m->addr += 32;
203         }
204         kfree(m);
205 }
206 #endif