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 <[EMAIL PROTECTED]> --- 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 : [EMAIL PROTECTED] -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 ([EMAIL PROTECTED]) and Mark Adler - ([EMAIL PROTECTED]) 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); + } } - _______________________________________________ ewg mailing list ewg@lists.openfabrics.org http://lists.openfabrics.org/cgi-bin/mailman/listinfo/ewg