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
 40void 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
 73void 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
111void 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
126void 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
139void 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
172void 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