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 39void 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", __FUNCTION__); 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", __FUNCTION__, 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", __FUNCTION__, 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 72void 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", __FUNCTION__); 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 __FUNCTION__, 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", __FUNCTION__, 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 110void 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 125void 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 138void 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", __FUNCTION__); 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", __FUNCTION__, 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", __FUNCTION__, 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 171void 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", __FUNCTION__); 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", __FUNCTION__, 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", __FUNCTION__, 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 207