[ewg] [PATCH 5/6] nes: Cosmetic changes; support virtual WQs and PPC
Glenn Grundstrom NetEffect
glenn at lists.openfabrics.org
Wed Nov 14 14:38:48 PST 2007
Updated code for the NetEffect NE020 adapter.
Updates include:
- Support for userspace/virtual WQs.
- PowerPC
- Support for multiple debugging levels
- Many, many cosmetic changes inline with kernel.org standards
Diffs for nes_user.h and nes_utils.c
Signed-off-by: Glenn Grundstrom <ggrundstrom at neteffect.com>
---
diff --git a/drivers/infiniband/hw/nes/nes_user.h b/drivers/infiniband/hw/nes/nes_user.h
index a170399..6ab2357 100644
--- a/drivers/infiniband/hw/nes/nes_user.h
+++ b/drivers/infiniband/hw/nes/nes_user.h
@@ -39,6 +39,9 @@
#include <linux/types.h>
+#define NES_ABI_USERSPACE_VER 1
+#define NES_ABI_KERNEL_VER 1
+
/*
* Make sure that all structs defined in this file remain laid out so
* that they pack the same way on 32-bit and 64-bit architectures (to
@@ -47,11 +50,19 @@
* instead.
*/
+struct nes_alloc_ucontext_req {
+ __u32 reserved32;
+ __u8 userspace_ver;
+ __u8 reserved8[3];
+};
+
struct nes_alloc_ucontext_resp {
__u32 max_pds; /* maximum pds allowed for this user process */
__u32 max_qps; /* maximum qps allowed for this user process */
__u32 wq_size; /* size of the WQs (sq+rq) allocated to the mmaped area */
- __u32 reserved;
+ __u8 virtwq; /* flag to indicate if virtual WQ are to be used or not */
+ __u8 kernel_ver;
+ __u8 reserved[2];
};
struct nes_alloc_pd_resp {
@@ -63,6 +74,10 @@ struct nes_create_cq_req {
__u64 user_cq_buffer;
};
+struct nes_create_qp_req {
+ __u64 user_wqe_buffers;
+};
+
enum iwnes_memreg_type {
IWNES_MEMREG_TYPE_MEM = 0x0000,
IWNES_MEMREG_TYPE_QP = 0x0001,
diff --git a/drivers/infiniband/hw/nes/nes_utils.c b/drivers/infiniband/hw/nes/nes_utils.c
index 1d478e0..b6aa6d3 100644
--- a/drivers/infiniband/hw/nes/nes_utils.c
+++ b/drivers/infiniband/hw/nes/nes_utils.c
@@ -50,19 +50,8 @@
#include "nes.h"
-#define BITMASK(X) (1L << (X))
-#define NES_CRC_WID 32
-
static u16 nes_read16_eeprom(void __iomem *addr, u16 offset);
-static u32 nesCRCTable[256];
-static u32 nesCRCInitialized = 0;
-
-static u32 nesCRCWidMask(u32);
-static u32 nes_crc_table_gen(u32 *, u32, u32, u32);
-static u32 reflect(u32, u32);
-static u32 byte_swap(u32, u32);
-
u32 mh_detected;
u32 mh_pauses_sent;
@@ -76,7 +65,9 @@ int nes_read_eeprom_values(struct nes_device *nesdev, struct nes_adapter *nesada
u16 eeprom_data;
u16 eeprom_offset;
u16 next_section_address;
- u32 index;
+ u16 sw_section_ver;
+ u8 major_ver = 0;
+ u8 minor_ver = 0;
/* TODO: deal with EEPROM endian issues */
if (nesadapter->firmware_eeprom_offset == 0) {
@@ -104,6 +95,9 @@ int nes_read_eeprom_values(struct nes_device *nesdev, struct nes_adapter *nesada
printk("Not a valid Software Image = 0x%04X\n", eeprom_data);
return -1;
}
+ sw_section_ver = nes_read16_eeprom(nesdev->regs, nesadapter->software_eeprom_offset + 6);
+ nes_debug(NES_DBG_HW, "Software section version number = 0x%04X\n",
+ sw_section_ver);
eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset + 2);
nes_debug(NES_DBG_HW, "EEPROM Offset %u (next section) = 0x%04X\n",
@@ -179,7 +173,14 @@ int nes_read_eeprom_values(struct nes_device *nesdev, struct nes_adapter *nesada
}
eeprom_data = nes_read16_eeprom(nesdev->regs, next_section_address + 8);
printk(PFX "Firmware version %u.%u\n", (u8)(eeprom_data>>8), (u8)eeprom_data);
+ major_ver = (u8)(eeprom_data >> 8);
+ minor_ver = (u8)(eeprom_data);
+ if (nes_drv_opt & NES_DRV_OPT_DISABLE_VIRT_WQ) {
+ nes_debug(NES_DBG_HW, "Virtual WQs have been disabled\n");
+ } else if (((major_ver == 2) && (minor_ver > 21)) || (major_ver > 2)) {
+ nesadapter->virtwq = 1;
+ }
nesadapter->firmware_version = (((u32)(u8)(eeprom_data>>8)) << 16) +
(u32)((u8)eeprom_data);
@@ -205,22 +206,60 @@ no_fw_rev:
/* Read the Phy Type array */
eeprom_offset += 10;
eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
- nes_debug(NES_DBG_HW, "PhyType: 0x%04x\n", eeprom_data);
+ nesadapter->phy_type[0] = (u8)(eeprom_data >> 8);
+ nesadapter->phy_type[1] = (u8)eeprom_data;
/* Read the port array */
eeprom_offset += 2;
eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
+ nesadapter->phy_type[2] = (u8)(eeprom_data >> 8);
+ nesadapter->phy_type[3] = (u8)eeprom_data;
/* port_count is set by soft reset reg */
- for (index = 0; index < 4; index++) {
- nesadapter->ports[index] = eeprom_data & 0x000f;
- eeprom_data >>= 4;
- }
- nes_debug(NES_DBG_HW, "port_count = %u, port 0 -> %u, port 1 -> %u, port 2 -> %u, port 3 -> %u\n",
+ nes_debug(NES_DBG_HW, "port_count = %u, port 0 -> %u, port 1 -> %u,"
+ " port 2 -> %u, port 3 -> %u\n",
nesadapter->port_count,
- nesadapter->ports[0], nesadapter->ports[1],
- nesadapter->ports[2], nesadapter->ports[3]);
+ nesadapter->phy_type[0], nesadapter->phy_type[1],
+ nesadapter->phy_type[2], nesadapter->phy_type[3]);
+
+ /* Read PD config array */
+ eeprom_offset += 10;
+ eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
+ nesadapter->pd_config_size[0] = eeprom_data;
+ eeprom_offset += 2;
+ eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
+ nesadapter->pd_config_base[0] = eeprom_data;
+ nes_debug(NES_DBG_HW, "PD0 config, size=0x%04x, base=0x%04x\n",
+ nesadapter->pd_config_size[0], nesadapter->pd_config_base[0]);
- eeprom_offset += 46;
+ eeprom_offset += 2;
+ eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
+ nesadapter->pd_config_size[1] = eeprom_data;
+ eeprom_offset += 2;
+ eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
+ nesadapter->pd_config_base[1] = eeprom_data;
+ nes_debug(NES_DBG_HW, "PD1 config, size=0x%04x, base=0x%04x\n",
+ nesadapter->pd_config_size[1], nesadapter->pd_config_base[1]);
+
+ eeprom_offset += 2;
+ eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
+ nesadapter->pd_config_size[2] = eeprom_data;
+ eeprom_offset += 2;
+ eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
+ nesadapter->pd_config_base[2] = eeprom_data;
+ nes_debug(NES_DBG_HW, "PD2 config, size=0x%04x, base=0x%04x\n",
+ nesadapter->pd_config_size[2], nesadapter->pd_config_base[2]);
+
+ eeprom_offset += 2;
+ eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
+ nesadapter->pd_config_size[3] = eeprom_data;
+ eeprom_offset += 2;
+ eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
+ nesadapter->pd_config_base[3] = eeprom_data;
+ nes_debug(NES_DBG_HW, "PD3 config, size=0x%04x, base=0x%04x\n",
+ nesadapter->pd_config_size[3], nesadapter->pd_config_base[3]);
+
+ /* Read Rx Pool Size */
+ eeprom_offset += 22; /* 46 */
eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
eeprom_offset += 2;
nesadapter->rx_pool_size = (((u32)eeprom_data) << 16) +
@@ -290,15 +329,26 @@ no_fw_rev:
nesadapter->core_clock = (((u32)eeprom_data) << 16) +
nes_read16_eeprom(nesdev->regs, eeprom_offset);
nes_debug(NES_DBG_HW, "core_clock = 0x%08X\n", nesadapter->core_clock);
- }
-
- nesadapter->phy_index[0] = 4;
- nesadapter->phy_index[1] = 5;
- nesadapter->phy_index[2] = 6;
- nesadapter->phy_index[3] = 7;
- /* TODO: get this from EEPROM */
- nesdev->base_doorbell_index = 1;
+ if ((sw_section_ver) && (nesadapter->hw_rev != NE020_REV)) {
+ eeprom_offset += 2;
+ eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
+ nesadapter->phy_index[0] = (eeprom_data & 0xff00)>>8;
+ nesadapter->phy_index[1] = eeprom_data & 0x00ff;
+ eeprom_offset += 2;
+ eeprom_data = nes_read16_eeprom(nesdev->regs, eeprom_offset);
+ nesadapter->phy_index[2] = (eeprom_data & 0xff00)>>8;
+ nesadapter->phy_index[3] = eeprom_data & 0x00ff;
+ } else {
+ nesadapter->phy_index[0] = 4;
+ nesadapter->phy_index[1] = 5;
+ nesadapter->phy_index[2] = 6;
+ nesadapter->phy_index[3] = 7;
+ }
+ nes_debug(NES_DBG_HW, "Phy address map = 0 > %u, 1 > %u, 2 > %u, 3 > %u\n",
+ nesadapter->phy_index[0],nesadapter->phy_index[1],
+ nesadapter->phy_index[2],nesadapter->phy_index[3]);
+ }
return 0;
}
@@ -316,7 +366,7 @@ static u16 nes_read16_eeprom(void __iomem *addr, u16 offset)
} while (readl((void __iomem *)addr + NES_EEPROM_COMMAND) &
NES_EEPROM_READ_REQUEST);
- return(readw((void __iomem *)addr + NES_EEPROM_DATA));
+ return readw((void __iomem *)addr + NES_EEPROM_DATA);
}
@@ -363,8 +413,8 @@ void nes_read_1G_phy_reg(struct nes_device *nesdev, u8 phy_reg, u8 phy_addr, u16
u32 counter;
unsigned long flags;
- /* nes_debug(NES_DBG_PHY, "%s: phy addr = %d, mac_index = %d\n",
- __FUNCTION__, phy_addr, nesdev->mac_index); */
+ /* nes_debug(NES_DBG_PHY, "phy addr = %d, mac_index = %d\n",
+ phy_addr, nesdev->mac_index); */
spin_lock_irqsave(&nesadapter->phy_lock, flags);
nes_write_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL,
@@ -400,12 +450,12 @@ void nes_write_10G_phy_reg(struct nes_device *nesdev, u16 phy_reg,
u32 u32temp;
u32 counter;
- dev_addr = 5;
- port_addr = 0;
+ dev_addr = 1;
+ port_addr = phy_addr;
/* set address */
nes_write_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL,
- 0x00020000 | phy_reg | (dev_addr << 18) | (port_addr << 23));
+ 0x00020000 | (u32)phy_reg | (((u32)dev_addr) << 18) | (((u32)port_addr) << 23));
for (counter = 0; counter < 100 ; counter++) {
udelay(30);
u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS);
@@ -420,7 +470,7 @@ void nes_write_10G_phy_reg(struct nes_device *nesdev, u16 phy_reg,
/* set data */
nes_write_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL,
- 0x10020000 | data | (dev_addr << 18) | (port_addr << 23));
+ 0x10020000 | (u32)data | (((u32)dev_addr) << 18) | (((u32)port_addr) << 23));
for (counter = 0; counter < 100 ; counter++) {
udelay(30);
u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS);
@@ -447,12 +497,12 @@ void nes_read_10G_phy_reg(struct nes_device *nesdev, u16 phy_reg, u8 phy_addr)
u32 u32temp;
u32 counter;
- dev_addr = 5;
- port_addr = 0;
+ dev_addr = 1;
+ port_addr = phy_addr;
/* set address */
nes_write_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL,
- 0x00020000 | phy_reg | (dev_addr << 18) | (port_addr << 23));
+ 0x00020000 | (u32)phy_reg | (((u32)dev_addr) << 18) | (((u32)port_addr) << 23));
for (counter = 0; counter < 100 ; counter++) {
udelay(30);
u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS);
@@ -467,7 +517,7 @@ void nes_read_10G_phy_reg(struct nes_device *nesdev, u16 phy_reg, u8 phy_addr)
/* issue read */
nes_write_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL,
- 0x30020000 | (dev_addr << 18) | (port_addr << 23));
+ 0x30020000 | (((u32)dev_addr) << 18) | (((u32)port_addr) << 23));
for (counter = 0; counter < 100 ; counter++) {
udelay(30);
u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS);
@@ -483,6 +533,96 @@ void nes_read_10G_phy_reg(struct nes_device *nesdev, u16 phy_reg, u8 phy_addr)
/**
+ * nes_get_cqp_request
+ */
+struct nes_cqp_request *nes_get_cqp_request(struct nes_device *nesdev)
+{
+ unsigned long flags;
+ struct nes_cqp_request *cqp_request = NULL;
+
+ if (!list_empty(&nesdev->cqp_avail_reqs)) {
+ spin_lock_irqsave(&nesdev->cqp.lock, flags);
+ cqp_request = list_entry(nesdev->cqp_avail_reqs.next,
+ struct nes_cqp_request, list);
+ list_del_init(&cqp_request->list);
+ spin_unlock_irqrestore(&nesdev->cqp.lock, flags);
+ } else {
+ cqp_request = kzalloc(sizeof(struct nes_cqp_request), GFP_KERNEL);
+ if (cqp_request) {
+ cqp_request->dynamic = 1;
+ INIT_LIST_HEAD(&cqp_request->list);
+ }
+ }
+
+ if (cqp_request) {
+ init_waitqueue_head(&cqp_request->waitq);
+ cqp_request->waiting = 0;
+ cqp_request->request_done = 0;
+ init_waitqueue_head(&cqp_request->waitq);
+ nes_debug(NES_DBG_CQP, "Got cqp request %p from the available list \n",
+ cqp_request);
+ } else
+ printk(KERN_ERR PFX "%s: Could not allocated a CQP request.\n",
+ __FUNCTION__);
+
+ return cqp_request;
+}
+
+
+/**
+ * nes_post_cqp_request
+ */
+void nes_post_cqp_request(struct nes_device *nesdev,
+ struct nes_cqp_request *cqp_request, int ring_doorbell)
+{
+ struct nes_hw_cqp_wqe *cqp_wqe;
+ unsigned long flags;
+ u32 cqp_head;
+
+ spin_lock_irqsave(&nesdev->cqp.lock, flags);
+
+ if (((((nesdev->cqp.sq_tail+(nesdev->cqp.sq_size*2))-nesdev->cqp.sq_head) &
+ (nesdev->cqp.sq_size - 1)) != 1)
+ && (list_empty(&nesdev->cqp_pending_reqs))) {
+ cqp_head = nesdev->cqp.sq_head++;
+ nesdev->cqp.sq_head &= nesdev->cqp.sq_size-1;
+ cqp_wqe = &nesdev->cqp.sq_vbase[cqp_head];
+ memcpy(cqp_wqe, &cqp_request->cqp_wqe, sizeof(*cqp_wqe));
+ barrier();
+ cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_LOW_IDX] = cpu_to_le32((u32)((u64)(cqp_request)));
+ cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_HIGH_IDX] = cpu_to_le32((u32)(((u64)(cqp_request))>>32));
+ nes_debug(NES_DBG_CQP, "CQP request (opcode 0x%02X), line 1 = 0x%08X put on CQPs SQ,"
+ " request = %p, cqp_head = %u, cqp_tail = %u, cqp_size = %u,"
+ " waiting = %d, refcount = %d.\n",
+ le32_to_cpu(cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX])&0x3f,
+ le32_to_cpu(cqp_wqe->wqe_words[NES_CQP_WQE_ID_IDX]), cqp_request,
+ nesdev->cqp.sq_head, nesdev->cqp.sq_tail, nesdev->cqp.sq_size,
+ cqp_request->waiting, atomic_read(&cqp_request->refcount));
+ barrier();
+ if (ring_doorbell) {
+ /* Ring doorbell (1 WQEs) */
+ nes_write32(nesdev->regs+NES_WQE_ALLOC, 0x01800000 | nesdev->cqp.qp_id);
+ }
+
+ barrier();
+ } else {
+ nes_debug(NES_DBG_CQP, "CQP request %p (opcode 0x%02X), line 1 = 0x%08X"
+ " put on the pending queue.\n",
+ cqp_request,
+ cqp_request->cqp_wqe.wqe_words[NES_CQP_WQE_OPCODE_IDX]&0x3f,
+ cqp_request->cqp_wqe.wqe_words[NES_CQP_WQE_ID_IDX]);
+ list_add_tail(&cqp_request->list, &nesdev->cqp_pending_reqs);
+ }
+
+ spin_unlock_irqrestore(&nesdev->cqp.lock, flags);
+
+ return;
+}
+
+
+
+
+/**
* nes_arp_table
*/
int nes_arp_table(struct nes_device *nesdev, u32 ip_addr, u8 *mac_addr, u32 action)
@@ -503,7 +643,7 @@ int nes_arp_table(struct nes_device *nesdev, u32 ip_addr, u8 *mac_addr, u32 acti
arp_index = 0;
err = nes_alloc_resource(nesadapter, nesadapter->allocated_arps,
- nesadapter->arp_table_size, &arp_index, &nesadapter->next_arp_index);
+ nesadapter->arp_table_size, (u32 *)&arp_index, &nesadapter->next_arp_index);
if (err) {
nes_debug(NES_DBG_NETDEV, "nes_alloc_resource returned error = %u\n", err);
return err;
@@ -680,194 +820,75 @@ no_mh_work:
}
-/*
-"Everything you wanted to know about CRC algorithms, but were afraid to ask
- for fear that errors in your understanding might be detected." Version : 3.
-Date : 19 August 1993.
-Author : Ross N. Williams.
-Net : ross at guest.adelaide.edu.au.
-FTP : ftp.adelaide.edu.au/pub/rocksoft/crc_v3.txt
-Company : Rocksoft™ Pty Ltd.
-Snail : 16 Lerwick Avenue, Hazelwood Park 5066, Australia.
-Fax : +61 8 373-4911 (c/- Internode Systems Pty Ltd).
-Phone : +61 8 379-9217 (10am to 10pm Adelaide Australia time).
-Note : "Rocksoft" is a trademark of Rocksoft Pty Ltd, Australia.
-Status : Copyright (C) Ross Williams, 1993. However, permission is granted to
- make and distribute verbatim copies of this document provided that this information
- block and copyright notice is included. Also, the C code modules included in this
- document are fully public domain.
-
-Thanks : Thanks to Jean-loup Gailly (jloup at chorus.fr) and Mark Adler
- (me at quest.jpl.nasa.gov) who both proof read this document and picked
- out lots of nits as well as some big fat bugs.
-
-The current web page for this seems to be http://www.ross.net/crc/crcpaper.html.
-
-*/
-
-/****************************************************************************/
-/* Generate width mask */
-/****************************************************************************/
-/* */
-/* Returns a longword whose value is (2^p_cm->cm_width)-1. */
-/* The trick is to do this portably (e.g. without doing <<32). */
-/* */
-/* Author: Tristan Gross */
-/* Source: "A PAINLESS GUIDE TO CRC ERROR DETECTION ALGORITHMS" */
-/* Ross N. Williams */
-/* http://www.rocksoft.com */
-/* */
-/****************************************************************************/
-
-static u32 nesCRCWidMask (u32 width)
-{
- return(((1L<<(((u32)width)-1))-1L)<<1)|1L;
-}
-
-
-/****************************************************************************/
-/* Generate CRC table */
-/****************************************************************************/
-/* */
-/* Source: "A PAINLESS GUIDE TO CRC ERROR DETECTION ALGORITHMS" */
-/* Ross N. Williams */
-/* http://www.rocksoft.com */
-/* */
-/****************************************************************************/
-static u32 nes_crc_table_gen ( u32 *pCRCTable,
- u32 poly,
- u32 order,
- u32 reflectIn)
-{
- u32 i;
- u32 reg;
- u32 byte;
- u32 topbit = BITMASK(NES_CRC_WID-1);
- u32 tmp;
-
- for (byte=0;byte<256;byte++) {
-
- // If we need to creat a reflected table we must reflect the index (byte) and
- // reflect the final reg
- tmp = (reflectIn) ? reflect(byte,8): byte;
-
- reg = tmp << (NES_CRC_WID-8);
-
- for (i=0; i<8; i++) {
- if (reg & topbit) {
- reg = (reg << 1) ^ poly;
- } else {
- reg <<= 1;
- }
- }
-
- reg = (reflectIn) ? reflect(reg,order): reg;
- pCRCTable[byte] = reg & nesCRCWidMask(NES_CRC_WID);
- }
-
- return 0;
-}
-
-
-/****************************************************************************/
-/* Perform 32 bit based CRC calculation */
-/****************************************************************************/
-/* */
-/* Source: "A PAINLESS GUIDE TO CRC ERROR DETECTION ALGORITHMS" */
-/* Ross N. Williams */
-/* http://www.rocksoft.com */
-/* */
-/* This performs a standard 32 bit crc on an array of arbitrary length */
-/* with an arbitrary initial value and passed generator polynomial */
-/* in the form of a crc table. */
-/* */
-/****************************************************************************/
-static u32 reflect (u32 data, u32 num)
-{
- /* Reflects the lower num bits in 'data' around their center point. */
- u32 i;
- u32 j = 1;
- u32 result = 0;
-
- for (i=(u32)1<<(num-1); i; i>>=1) {
- if (data & i) result|=j;
- j <<= 1;
- }
- return result;
-}
-
-
/**
- * byte_swap
+ * nes_dump_mem
*/
-static u32 byte_swap (u32 data, u32 num)
+void nes_dump_mem(unsigned int dump_debug_level, void *addr, int length)
{
- u32 i;
- u32 result = 0;
-
- if (num%16) {
- dprintk("\nbyte_swap: ERROR: num is not an even number of bytes\n");
- /* ASSERT(0); */
+ char xlate[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'a', 'b', 'c', 'd', 'e', 'f'};
+ char *ptr;
+ char hex_buf[80];
+ char ascii_buf[20];
+ int num_char;
+ int num_ascii;
+ int num_hex;
+
+ if (!(nes_debug_level & dump_debug_level)) {
+ return;
}
- for (i = 0; i < num; i += 8) {
- result |= (0xFF & (data >> i)) << (num-8-i);
- }
-
- return result;
-}
-
-
-/**
- * nes_crc32 -
- * This is a reflected table algorithm. ReflectIn basically
- * means to reflect each incomming byte of the data. But to make
- * things more complicated, we can instead reflect the initial
- * value, the final crc, and shift data to the right using a
- * reflected pCRCTable. CRC is FUN!!
- */
-u32 nes_crc32 ( u32 reverse,
- u32 initialValue,
- u32 finalXOR,
- u32 messageLength,
- u8 *pMessage,
- u32 order,
- u32 reflectIn,
- u32 reflectOut)
-
-{
- u8 *pBlockAddr = pMessage;
- u32 mlen = messageLength;
- u32 crc;
-
- if (0 == nesCRCInitialized) {
- nes_crc_table_gen( &nesCRCTable[0], CRC32C_POLY, ORDER, REFIN);
- nesCRCInitialized = 1;
+ ptr = addr;
+ if (length > 0x100) {
+ nes_debug(dump_debug_level, "Length truncated from %x to %x\n", length, 0x100);
+ length = 0x100;
}
+ nes_debug(dump_debug_level, "Address=0x%p, length=0x%x (%d)\n", ptr, length, length);
+
+ memset(ascii_buf, 0, 20);
+ memset(hex_buf, 0, 80);
+
+ num_ascii = 0;
+ num_hex = 0;
+ for (num_char = 0; num_char < length; num_char++) {
+ if (num_ascii == 8) {
+ ascii_buf[num_ascii++] = ' ';
+ hex_buf[num_hex++] = '-';
+ hex_buf[num_hex++] = ' ';
+ }
- crc = (reflectIn) ? reflect(initialValue,order): initialValue;
-
- while (mlen--) {
- /* printf("byte = %x, index = %u, crctable[index] = %x\n",
- *pBlockAddr, (crc & 0xffL) ^ *pBlockAddr,
- nesCRCTable[(crc & 0xffL) ^ *pBlockAddr]);
- */
- if (reflectIn) {
- crc = nesCRCTable[(crc & 0xffL ) ^ *pBlockAddr++] ^ (crc >> 8);
- } else {
- crc = nesCRCTable[((crc>>24) ^ *pBlockAddr++) & 0xFFL] ^ (crc << 8);
+ if (*ptr < 0x20 || *ptr > 0x7e)
+ ascii_buf[num_ascii++] = '.';
+ else
+ ascii_buf[num_ascii++] = *ptr;
+ hex_buf[num_hex++] = xlate[((*ptr & 0xf0) >> 4)];
+ hex_buf[num_hex++] = xlate[*ptr & 0x0f];
+ hex_buf[num_hex++] = ' ';
+ ptr++;
+
+ if (num_ascii >= 17) {
+ /* output line and reset */
+ nes_debug(dump_debug_level, " %s | %s\n", hex_buf, ascii_buf);
+ memset(ascii_buf, 0, 20);
+ memset(hex_buf, 0, 80);
+ num_ascii = 0;
+ num_hex = 0;
}
}
- /* if reflectOut and reflectIn are both set, we don't */
- /* do anything since reflecting twice effectively does nothing. */
- crc = ((reflectIn)^(reflectOut)) ? reflect(crc,order): crc;
-
- crc = crc^finalXOR;
-
- /* We don't really use this, but it is here for completeness */
- crc = (reverse) ? byte_swap(crc,32): crc;
+ /* output the rest */
+ if (num_ascii) {
+ while (num_ascii < 17) {
+ if (num_ascii == 8) {
+ hex_buf[num_hex++] = ' ';
+ hex_buf[num_hex++] = ' ';
+ }
+ hex_buf[num_hex++] = ' ';
+ hex_buf[num_hex++] = ' ';
+ hex_buf[num_hex++] = ' ';
+ num_ascii++;
+ }
- return crc;
+ nes_debug(dump_debug_level, " %s | %s\n", hex_buf, ascii_buf);
+ }
}
-
More information about the ewg
mailing list