]>
Commit | Line | Data |
---|---|---|
b038ced7 SW |
1 | /* |
2 | * Copyright (c) 2006 Chelsio, Inc. All rights reserved. | |
b038ced7 SW |
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) { | |
33718363 | 48 | PDBG("%s couldn't allocate memory.\n", __func__); |
b038ced7 SW |
49 | return; |
50 | } | |
51 | m->mem_id = MEM_PMRX; | |
52 | m->addr = (stag>>8) * 32 + rdev->rnic_info.tpt_base; | |
53 | m->len = size; | |
33718363 | 54 | PDBG("%s TPT addr 0x%x len %d\n", __func__, m->addr, m->len); |
b038ced7 SW |
55 | rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m); |
56 | if (rc) { | |
33718363 | 57 | PDBG("%s toectl returned error %d\n", __func__, rc); |
b038ced7 SW |
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) { | |
33718363 | 85 | PDBG("%s couldn't allocate memory.\n", __func__); |
b038ced7 SW |
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", | |
33718363 | 92 | __func__, m->addr, m->len, npages); |
b038ced7 SW |
93 | rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m); |
94 | if (rc) { | |
33718363 | 95 | PDBG("%s toectl returned error %d\n", __func__, rc); |
b038ced7 SW |
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) { | |
33718363 | 147 | PDBG("%s couldn't allocate memory.\n", __func__); |
b038ced7 SW |
148 | return; |
149 | } | |
150 | m->mem_id = MEM_PMRX; | |
151 | m->addr = ((hwtid)<<10) + rdev->rnic_info.rqt_base; | |
152 | m->len = size; | |
33718363 | 153 | PDBG("%s RQT addr 0x%x len %d\n", __func__, m->addr, m->len); |
b038ced7 SW |
154 | rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m); |
155 | if (rc) { | |
33718363 | 156 | PDBG("%s toectl returned error %d\n", __func__, rc); |
b038ced7 SW |
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) { | |
33718363 | 180 | PDBG("%s couldn't allocate memory.\n", __func__); |
b038ced7 SW |
181 | return; |
182 | } | |
183 | m->mem_id = MEM_CM; | |
184 | m->addr = hwtid * size; | |
185 | m->len = size; | |
33718363 | 186 | PDBG("%s TCB %d len %d\n", __func__, m->addr, m->len); |
b038ced7 SW |
187 | rc = rdev->t3cdev_p->ctl(rdev->t3cdev_p, RDMA_GET_MEM, m); |
188 | if (rc) { | |
33718363 | 189 | PDBG("%s toectl returned error %d\n", __func__, rc); |
b038ced7 SW |
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 |