X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=src%2Fpatches%2Fsuse-2.6.27.25%2Fpatches.drivers%2F0019-Staging-SLICOSS-lots-of-checkpatch-fixes.patch;fp=src%2Fpatches%2Fsuse-2.6.27.25%2Fpatches.drivers%2F0019-Staging-SLICOSS-lots-of-checkpatch-fixes.patch;h=00a3dba93a4f9f078b7ae363930430e023d5d2da;hb=2e4178199a697105e827d68d66ab7101acd1dd8c;hp=0000000000000000000000000000000000000000;hpb=df2a9a46c7db6362520343d6ec70fbcfe40b2795;p=people%2Fteissler%2Fipfire-2.x.git diff --git a/src/patches/suse-2.6.27.25/patches.drivers/0019-Staging-SLICOSS-lots-of-checkpatch-fixes.patch b/src/patches/suse-2.6.27.25/patches.drivers/0019-Staging-SLICOSS-lots-of-checkpatch-fixes.patch new file mode 100644 index 000000000..00a3dba93 --- /dev/null +++ b/src/patches/suse-2.6.27.25/patches.drivers/0019-Staging-SLICOSS-lots-of-checkpatch-fixes.patch @@ -0,0 +1,5348 @@ +From e9eff9d6a0d14fa2e85953ce4115d243ff575e78 Mon Sep 17 00:00:00 2001 +From: Lior Dotan +Date: Sat, 4 Oct 2008 07:10:28 +0300 +Subject: [PATCH 19/23] Staging: SLICOSS: lots of checkpatch fixes +Patch-mainline: 2.6.28 + +Major cleanups of checkpatch warnings from the slicoss driver. + +From: Lior Dotan +Signed-off-by: Greg Kroah-Hartman +--- + drivers/staging/slicoss/gbdownload.h | 10 +- + drivers/staging/slicoss/gbrcvucode.h | 7 +- + drivers/staging/slicoss/oasisdbgdownload.h | 10 +- + drivers/staging/slicoss/oasisdownload.h | 10 +- + drivers/staging/slicoss/oasisrcvucode.h | 6 +- + drivers/staging/slicoss/slic.h | 485 +++++----- + drivers/staging/slicoss/slic_os.h | 85 +-- + drivers/staging/slicoss/slicbuild.h | 1 - + drivers/staging/slicoss/slicdbg.h | 3 +- + drivers/staging/slicoss/slicdump.h | 89 +- + drivers/staging/slicoss/slichw.h | 653 +++++++------- + drivers/staging/slicoss/slicinc.h | 262 +++--- + drivers/staging/slicoss/slicoss.c | 1351 +++++++++++++--------------- + 13 files changed, 1353 insertions(+), 1619 deletions(-) + +diff --git a/drivers/staging/slicoss/gbdownload.h b/drivers/staging/slicoss/gbdownload.h +index 0350fb9..794432b 100644 +--- a/drivers/staging/slicoss/gbdownload.h ++++ b/drivers/staging/slicoss/gbdownload.h +@@ -1,14 +1,14 @@ +-#define MOJAVE_UCODE_VERS_STRING "$Revision: 1.2 $" +-#define MOJAVE_UCODE_VERS_DATE "$Date: 2006/03/27 15:12:22 $" ++#define MOJAVE_UCODE_VERS_STRING "1.2" ++#define MOJAVE_UCODE_VERS_DATE "2006/03/27 15:12:22" + #define MOJAVE_UCODE_HOSTIF_ID 3 + +-static LONG MNumSections = 0x2; +-static ULONG MSectionSize[] = ++static s32 MNumSections = 0x2; ++static u32 MSectionSize[] = + { + 0x00008000, 0x00010000, + }; + +-static ULONG MSectionStart[] = ++static u32 MSectionStart[] = + { + 0x00000000, 0x00008000, + }; +diff --git a/drivers/staging/slicoss/gbrcvucode.h b/drivers/staging/slicoss/gbrcvucode.h +index dc00834..4fa5a4c 100644 +--- a/drivers/staging/slicoss/gbrcvucode.h ++++ b/drivers/staging/slicoss/gbrcvucode.h +@@ -1,7 +1,6 @@ + /* + * Copyright (c) 1997-2002 Alacritech, Inc. All rights reserved + * +- * $Id: gbrcvucode.h,v 1.2 2006/03/27 15:12:15 mook Exp $ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions +@@ -32,10 +31,10 @@ + * official policies, either expressed or implied, of Alacritech, Inc. + * + **************************************************************************/ +-#define GB_RCVUCODE_VERS_STRING "$Revision: 1.2 $" +-#define GB_RCVUCODE_VERS_DATE "$Date: 2006/03/27 15:12:15 $" ++#define GB_RCVUCODE_VERS_STRING "1.2" ++#define GB_RCVUCODE_VERS_DATE "2006/03/27 15:12:15" + +-static ULONG GBRcvUCodeLen = 512; ++static u32 GBRcvUCodeLen = 512; + + static u8 GBRcvUCode[2560] = + { +diff --git a/drivers/staging/slicoss/oasisdbgdownload.h b/drivers/staging/slicoss/oasisdbgdownload.h +index cae5d55..519e007 100644 +--- a/drivers/staging/slicoss/oasisdbgdownload.h ++++ b/drivers/staging/slicoss/oasisdbgdownload.h +@@ -1,14 +1,14 @@ +-#define OASIS_UCODE_VERS_STRING "$Revision: 1.2 $" +-#define OASIS_UCODE_VERS_DATE "$Date: 2006/03/27 15:11:22 $" ++#define OASIS_UCODE_VERS_STRING "1.2" ++#define OASIS_UCODE_VERS_DATE "2006/03/27 15:11:22" + #define OASIS_UCODE_HOSTIF_ID 3 + +-static LONG ONumSections = 0x2; +-static ULONG OSectionSize[] = ++static s32 ONumSections = 0x2; ++static u32 OSectionSize[] = + { + 0x00004000, 0x00010000, + }; + +-static ULONG OSectionStart[] = ++static u32 OSectionStart[] = + { + 0x00000000, 0x00008000, + }; +diff --git a/drivers/staging/slicoss/oasisdownload.h b/drivers/staging/slicoss/oasisdownload.h +index 89a440c..6438c23 100644 +--- a/drivers/staging/slicoss/oasisdownload.h ++++ b/drivers/staging/slicoss/oasisdownload.h +@@ -1,13 +1,13 @@ +-#define OASIS_UCODE_VERS_STRING "$Revision: 1.2 $" +-#define OASIS_UCODE_VERS_DATE "$Date: 2006/03/27 15:10:37 $" ++#define OASIS_UCODE_VERS_STRING "1.2" ++#define OASIS_UCODE_VERS_DATE "2006/03/27 15:10:37" + #define OASIS_UCODE_HOSTIF_ID 3 + +-static LONG ONumSections = 0x2; +-static ULONG OSectionSize[] = { ++static s32 ONumSections = 0x2; ++static u32 OSectionSize[] = { + 0x00004000, 0x00010000, + }; + +-static ULONG OSectionStart[] = { ++static u32 OSectionStart[] = { + 0x00000000, 0x00008000, + }; + +diff --git a/drivers/staging/slicoss/oasisrcvucode.h b/drivers/staging/slicoss/oasisrcvucode.h +index ef91632..5b3531f 100644 +--- a/drivers/staging/slicoss/oasisrcvucode.h ++++ b/drivers/staging/slicoss/oasisrcvucode.h +@@ -1,7 +1,7 @@ +-#define OASIS_RCVUCODE_VERS_STRING "$Revision: 1.2 $" +-#define OASIS_RCVUCODE_VERS_DATE "$Date: 2006/03/27 15:10:28 $" ++#define OASIS_RCVUCODE_VERS_STRING "1.2" ++#define OASIS_RCVUCODE_VERS_DATE "2006/03/27 15:10:28" + +-static ULONG OasisRcvUCodeLen = 512; ++static u32 OasisRcvUCodeLen = 512; + + static u8 OasisRcvUCode[2560] = + { +diff --git a/drivers/staging/slicoss/slic.h b/drivers/staging/slicoss/slic.h +index 9707e5a..0d5dc24 100644 +--- a/drivers/staging/slicoss/slic.h ++++ b/drivers/staging/slicoss/slic.h +@@ -2,7 +2,6 @@ + * + * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved. + * +- * $Id: slic.h,v 1.3 2006/07/14 16:43:02 mook Exp $ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions +@@ -51,14 +50,14 @@ struct slic_spinlock { + #define SLIC_RSPQ_PAGES_GB 10 + #define SLIC_RSPQ_BUFSINPAGE (PAGE_SIZE / SLIC_RSPBUF_SIZE) + +-typedef struct _slic_rspqueue_t { +- ulong32 offset; +- ulong32 pageindex; +- ulong32 num_pages; +- p_slic_rspbuf_t rspbuf; +- pulong32 vaddr[SLIC_RSPQ_PAGES_GB]; ++struct slic_rspqueue { ++ u32 offset; ++ u32 pageindex; ++ u32 num_pages; ++ struct slic_rspbuf *rspbuf; ++ u32 *vaddr[SLIC_RSPQ_PAGES_GB]; + dma_addr_t paddr[SLIC_RSPQ_PAGES_GB]; +-} slic_rspqueue_t, *p_slic_rspqueue_t; ++}; + + #define SLIC_RCVQ_EXPANSION 1 + #define SLIC_RCVQ_ENTRIES (256 * SLIC_RCVQ_EXPANSION) +@@ -68,45 +67,45 @@ typedef struct _slic_rspqueue_t { + #define SLIC_RCVQ_FILLENTRIES (16 * SLIC_RCVQ_EXPANSION) + #define SLIC_RCVQ_FILLTHRESH (SLIC_RCVQ_ENTRIES - SLIC_RCVQ_FILLENTRIES) + +-typedef struct _slic_rcvqueue_t { ++struct slic_rcvqueue { + struct sk_buff *head; + struct sk_buff *tail; +- ulong32 count; +- ulong32 size; +- ulong32 errors; +-} slic_rcvqueue_t, *p_slic_rcvqueue_t; +- +-typedef struct _slic_rcvbuf_info_t { +- ulong32 id; +- ulong32 starttime; +- ulong32 stoptime; +- ulong32 slicworld; +- ulong32 lasttime; +- ulong32 lastid; +-} slic_rcvbuf_info_t, *pslic_rcvbuf_info_t; ++ u32 count; ++ u32 size; ++ u32 errors; ++}; ++ ++struct slic_rcvbuf_info { ++ u32 id; ++ u32 starttime; ++ u32 stoptime; ++ u32 slicworld; ++ u32 lasttime; ++ u32 lastid; ++}; + /* + SLIC Handle structure. Used to restrict handle values to + 32 bits by using an index rather than an address. + Simplifies ucode in 64-bit systems + */ +-typedef struct _slic_handle_word_t { ++struct slic_handle_word { + union { + struct { + ushort index; + ushort bottombits; /* to denote num bufs to card */ + } parts; +- ulong32 whole; ++ u32 whole; + } handle; +-} slic_handle_word_t, *pslic_handle_word_t; ++}; + +-typedef struct _slic_handle_t { +- slic_handle_word_t token; /* token passed between host and card*/ ++struct slic_handle { ++ struct slic_handle_word token; /* token passed between host and card*/ + ushort type; +- pvoid address; /* actual address of the object*/ ++ void *address; /* actual address of the object*/ + ushort offset; +- struct _slic_handle_t *other_handle; +- struct _slic_handle_t *next; +-} slic_handle_t, *pslic_handle_t; ++ struct slic_handle *other_handle; ++ struct slic_handle *next; ++}; + + #define SLIC_HANDLE_FREE 0x0000 + #define SLIC_HANDLE_DATA 0x0001 +@@ -120,19 +119,19 @@ typedef struct _slic_handle_t { + + #define SLIC_HOSTCMD_SIZE 512 + +-typedef struct _slic_hostcmd_t { +- slic_host64_cmd_t cmd64; +- ulong32 type; ++struct slic_hostcmd { ++ struct slic_host64_cmd cmd64; ++ u32 type; + struct sk_buff *skb; +- ulong32 paddrl; +- ulong32 paddrh; +- ulong32 busy; +- ulong32 cmdsize; ++ u32 paddrl; ++ u32 paddrh; ++ u32 busy; ++ u32 cmdsize; + ushort numbufs; +- pslic_handle_t pslic_handle;/* handle associated with command */ +- struct _slic_hostcmd_t *next; +- struct _slic_hostcmd_t *next_all; +-} slic_hostcmd_t, *p_slic_hostcmd_t; ++ struct slic_handle *pslic_handle;/* handle associated with command */ ++ struct slic_hostcmd *next; ++ struct slic_hostcmd *next_all; ++}; + + #define SLIC_CMDQ_CMDSINPAGE (PAGE_SIZE / SLIC_HOSTCMD_SIZE) + #define SLIC_CMD_DUMB 3 +@@ -142,18 +141,18 @@ typedef struct _slic_hostcmd_t { + #define SLIC_CMDQ_MAXPAGES (SLIC_CMDQ_MAXCMDS / SLIC_CMDQ_CMDSINPAGE) + #define SLIC_CMDQ_INITPAGES (SLIC_CMDQ_INITCMDS / SLIC_CMDQ_CMDSINPAGE) + +-typedef struct _slic_cmdqmem_t { +- int pagecnt; +- pulong32 pages[SLIC_CMDQ_MAXPAGES]; +- dma_addr_t dma_pages[SLIC_CMDQ_MAXPAGES]; +-} slic_cmdqmem_t, *p_slic_cmdqmem_t; ++struct slic_cmdqmem { ++ int pagecnt; ++ u32 *pages[SLIC_CMDQ_MAXPAGES]; ++ dma_addr_t dma_pages[SLIC_CMDQ_MAXPAGES]; ++}; + +-typedef struct _slic_cmdqueue_t { +- p_slic_hostcmd_t head; +- p_slic_hostcmd_t tail; +- int count; +- struct slic_spinlock lock; +-} slic_cmdqueue_t, *p_slic_cmdqueue_t; ++struct slic_cmdqueue { ++ struct slic_hostcmd *head; ++ struct slic_hostcmd *tail; ++ int count; ++ struct slic_spinlock lock; ++}; + + #ifdef STATUS_SUCCESS + #undef STATUS_SUCCESS +@@ -181,10 +180,10 @@ just set this at 15K, shouldnt make that much of a diff. + #endif + + +-typedef struct _mcast_address_t { +- uchar address[6]; +- struct _mcast_address_t *next; +-} mcast_address_t, *p_mcast_address_t; ++struct mcast_address { ++ unsigned char address[6]; ++ struct mcast_address *next; ++}; + + #define CARD_DOWN 0x00000000 + #define CARD_UP 0x00000001 +@@ -236,38 +235,37 @@ typedef struct _mcast_address_t { + #define SLIC_ADAPTER_STATE(x) ((x == ADAPT_UP) ? "UP" : "Down") + #define SLIC_CARD_STATE(x) ((x == CARD_UP) ? "UP" : "Down") + +-typedef struct _slic_iface_stats { ++struct slic_iface_stats { + /* + * Stats + */ +- ulong64 xmt_bytes; +- ulong64 xmt_ucast; +- ulong64 xmt_mcast; +- ulong64 xmt_bcast; +- ulong64 xmt_errors; +- ulong64 xmt_discards; +- ulong64 xmit_collisions; +- ulong64 xmit_excess_xmit_collisions; +- ulong64 rcv_bytes; +- ulong64 rcv_ucast; +- ulong64 rcv_mcast; +- ulong64 rcv_bcast; +- ulong64 rcv_errors; +- ulong64 rcv_discards; +-} slic_iface_stats_t, *p_slic_iface_stats_t; +- +-typedef struct _slic_tcp_stats { +- ulong64 xmit_tcp_segs; +- ulong64 xmit_tcp_bytes; +- ulong64 rcv_tcp_segs; +- ulong64 rcv_tcp_bytes; +-} slic_tcp_stats_t, *p_slic_tcp_stats_t; +- +-typedef struct _slicnet_stats { +- slic_tcp_stats_t tcp; +- slic_iface_stats_t iface; +- +-} slicnet_stats_t, *p_slicnet_stats_t; ++ u64 xmt_bytes; ++ u64 xmt_ucast; ++ u64 xmt_mcast; ++ u64 xmt_bcast; ++ u64 xmt_errors; ++ u64 xmt_discards; ++ u64 xmit_collisions; ++ u64 xmit_excess_xmit_collisions; ++ u64 rcv_bytes; ++ u64 rcv_ucast; ++ u64 rcv_mcast; ++ u64 rcv_bcast; ++ u64 rcv_errors; ++ u64 rcv_discards; ++}; ++ ++struct sliccp_stats { ++ u64 xmit_tcp_segs; ++ u64 xmit_tcp_bytes; ++ u64 rcv_tcp_segs; ++ u64 rcv_tcp_bytes; ++}; ++ ++struct slicnet_stats { ++ struct sliccp_stats tcp; ++ struct slic_iface_stats iface; ++}; + + #define SLIC_LOADTIMER_PERIOD 1 + #define SLIC_INTAGG_DEFAULT 200 +@@ -294,13 +292,13 @@ typedef struct _slicnet_stats { + #define SLIC_INTAGG_4GB 100 + #define SLIC_INTAGG_5GB 100 + +-typedef struct _ether_header { +- uchar ether_dhost[6]; +- uchar ether_shost[6]; ++struct ether_header { ++ unsigned char ether_dhost[6]; ++ unsigned char ether_shost[6]; + ushort ether_type; +-} ether_header, *p_ether_header; ++}; + +-typedef struct _sliccard_t { ++struct sliccard { + uint busnumber; + uint slotnumber; + uint state; +@@ -310,114 +308,111 @@ typedef struct _sliccard_t { + uint adapters_allocated; + uint adapters_sleeping; + uint gennumber; +- ulong32 events; +- ulong32 loadlevel_current; +- ulong32 load; ++ u32 events; ++ u32 loadlevel_current; ++ u32 load; + uint reset_in_progress; +- ulong32 pingstatus; +- ulong32 bad_pingstatus; ++ u32 pingstatus; ++ u32 bad_pingstatus; + struct timer_list loadtimer; +- ulong32 loadtimerset; ++ u32 loadtimerset; + uint config_set; +- slic_config_t config; ++ struct slic_config config; + struct dentry *debugfs_dir; + struct dentry *debugfs_cardinfo; +- struct _adapter_t *master; +- struct _adapter_t *adapter[SLIC_MAX_PORTS]; +- struct _sliccard_t *next; +- ulong32 error_interrupts; +- ulong32 error_rmiss_interrupts; +- ulong32 rcv_interrupts; +- ulong32 xmit_interrupts; +- ulong32 num_isrs; +- ulong32 false_interrupts; +- ulong32 max_isr_rcvs; +- ulong32 max_isr_xmits; +- ulong32 rcv_interrupt_yields; +- ulong32 tx_packets; ++ struct adapter *master; ++ struct adapter *adapter[SLIC_MAX_PORTS]; ++ struct sliccard *next; ++ u32 error_interrupts; ++ u32 error_rmiss_interrupts; ++ u32 rcv_interrupts; ++ u32 xmit_interrupts; ++ u32 num_isrs; ++ u32 false_interrupts; ++ u32 max_isr_rcvs; ++ u32 max_isr_xmits; ++ u32 rcv_interrupt_yields; ++ u32 tx_packets; + #if SLIC_DUMP_ENABLED +- ulong32 dumpstatus; /* Result of dump UPR */ +- pvoid cmdbuffer; ++ u32 dumpstatus; /* Result of dump UPR */ ++ void *cmdbuffer; + + ulong cmdbuffer_phys; +- ulong32 cmdbuffer_physl; +- ulong32 cmdbuffer_physh; ++ u32 cmdbuffer_physl; ++ u32 cmdbuffer_physh; + +- ulong32 dump_count; ++ u32 dump_count; + struct task_struct *dump_task_id; +- ulong32 dump_wait_count; ++ u32 dump_wait_count; + uint dumpthread_running; /* has a dump thread been init'd */ + uint dump_requested; /* 0 no, 1 = reqstd 2=curr 3=done */ +- ulong32 dumptime_start; +- ulong32 dumptime_complete; +- ulong32 dumptime_delta; +- pvoid dumpbuffer; ++ u32 dumptime_start; ++ u32 dumptime_complete; ++ u32 dumptime_delta; ++ void *dumpbuffer; + ulong dumpbuffer_phys; +- ulong32 dumpbuffer_physl; +- ulong32 dumpbuffer_physh; ++ u32 dumpbuffer_physl; ++ u32 dumpbuffer_physh; + wait_queue_head_t dump_wq; + struct file *dumphandle; + mm_segment_t dumpfile_fs; + #endif +- ulong32 debug_ix; ++ u32 debug_ix; + ushort reg_type[32]; + ushort reg_offset[32]; +- ulong32 reg_value[32]; +- ulong32 reg_valueh[32]; +-} sliccard_t, *p_sliccard_t; ++ u32 reg_value[32]; ++ u32 reg_valueh[32]; ++}; + + #define NUM_CFG_SPACES 2 + #define NUM_CFG_REGS 64 +-#define NUM_CFG_REG_ULONGS (NUM_CFG_REGS / sizeof(ulong32)) ++#define NUM_CFG_REG_ULONGS (NUM_CFG_REGS / sizeof(u32)) + +-typedef struct _physcard_t { +- struct _adapter_t *adapter[SLIC_MAX_PORTS]; +- struct _physcard_t *next; ++struct physcard { ++ struct adapter *adapter[SLIC_MAX_PORTS]; ++ struct physcard *next; + uint adapters_allocd; + + /* the following is not currently needed +- ulong32 bridge_busnum; +- ulong32 bridge_cfg[NUM_CFG_SPACES][NUM_CFG_REG_ULONGS]; ++ u32 bridge_busnum; ++ u32 bridge_cfg[NUM_CFG_SPACES][NUM_CFG_REG_ULONGS]; + */ +-} physcard_t, *p_physcard_t; ++}; + +-typedef struct _base_driver { ++struct base_driver { + struct slic_spinlock driver_lock; +- ulong32 num_slic_cards; +- ulong32 num_slic_ports; +- ulong32 num_slic_ports_active; +- ulong32 dynamic_intagg; +- p_sliccard_t slic_card; +- p_physcard_t phys_card; ++ u32 num_slic_cards; ++ u32 num_slic_ports; ++ u32 num_slic_ports_active; ++ u32 dynamic_intagg; ++ struct sliccard *slic_card; ++ struct physcard *phys_card; + uint cardnuminuse[SLIC_MAX_CARDS]; +-} base_driver_t, *p_base_driver_t; +- +-extern base_driver_t slic_global; +- +-typedef struct _slic_shmem_t { +- volatile ulong32 isr; +- volatile ulong32 linkstatus; +- volatile slic_stats_t inicstats; +-} slic_shmem_t, *p_slic_shmem_t; +- +-typedef struct _slic_reg_params_t { +- ulong32 linkspeed; +- ulong32 linkduplex; +- ulong32 fail_on_bad_eeprom; +-} slic_reg_params_t, *p_reg_params_t; +- +-typedef struct _slic_upr_t { +- uint adapter; +- ulong32 upr_request; +- ulong32 upr_data; +- ulong32 upr_data_h; +- ulong32 upr_buffer; +- ulong32 upr_buffer_h; +- struct _slic_upr_t *next; +- +-} slic_upr_t, *p_slic_upr_t; +- +-typedef struct _slic_ifevents_ti { ++}; ++ ++struct slic_shmem { ++ volatile u32 isr; ++ volatile u32 linkstatus; ++ volatile struct slic_stats inicstats; ++}; ++ ++struct slic_reg_params { ++ u32 linkspeed; ++ u32 linkduplex; ++ u32 fail_on_bad_eeprom; ++}; ++ ++struct slic_upr { ++ uint adapter; ++ u32 upr_request; ++ u32 upr_data; ++ u32 upr_data_h; ++ u32 upr_buffer; ++ u32 upr_buffer_h; ++ struct slic_upr *next; ++}; ++ ++struct slic_ifevents { + uint oflow802; + uint uflow802; + uint Tprtoflow; +@@ -434,19 +429,19 @@ typedef struct _slic_ifevents_ti { + uint IpCsum; + uint TpCsum; + uint TpHlen; +-} slic_ifevents_t; ++}; + +-typedef struct _adapter_t { +- pvoid ifp; +- p_sliccard_t card; ++struct adapter { ++ void *ifp; ++ struct sliccard *card; + uint port; +- p_physcard_t physcard; ++ struct physcard *physcard; + uint physport; + uint cardindex; + uint card_size; + uint chipid; +- struct net_device *netdev; +- struct net_device *next_netdevice; ++ struct net_device *netdev; ++ struct net_device *next_netdevice; + struct slic_spinlock adapter_lock; + struct slic_spinlock reset_lock; + struct pci_dev *pcidev; +@@ -456,90 +451,90 @@ typedef struct _adapter_t { + ushort vendid; + ushort devid; + ushort subsysid; +- ulong32 irq; ++ u32 irq; + void __iomem *memorybase; +- ulong32 memorylength; +- ulong32 drambase; +- ulong32 dramlength; ++ u32 memorylength; ++ u32 drambase; ++ u32 dramlength; + uint queues_initialized; + uint allocated; + uint activated; +- ulong32 intrregistered; ++ u32 intrregistered; + uint isp_initialized; + uint gennumber; +- ulong32 curaddrupper; +- p_slic_shmem_t pshmem; ++ u32 curaddrupper; ++ struct slic_shmem *pshmem; + dma_addr_t phys_shmem; +- ulong32 isrcopy; +- p_slic_regs_t slic_regs; +- uchar state; +- uchar linkstate; +- uchar linkspeed; +- uchar linkduplex; ++ u32 isrcopy; ++ __iomem struct slic_regs *slic_regs; ++ unsigned char state; ++ unsigned char linkstate; ++ unsigned char linkspeed; ++ unsigned char linkduplex; + uint flags; +- uchar macaddr[6]; +- uchar currmacaddr[6]; +- ulong32 macopts; ++ unsigned char macaddr[6]; ++ unsigned char currmacaddr[6]; ++ u32 macopts; + ushort devflags_prev; +- ulong64 mcastmask; +- p_mcast_address_t mcastaddrs; +- p_slic_upr_t upr_list; ++ u64 mcastmask; ++ struct mcast_address *mcastaddrs; ++ struct slic_upr *upr_list; + uint upr_busy; + struct timer_list pingtimer; +- ulong32 pingtimerset; ++ u32 pingtimerset; + struct timer_list statstimer; +- ulong32 statstimerset; ++ u32 statstimerset; + struct timer_list loadtimer; +- ulong32 loadtimerset; ++ u32 loadtimerset; + struct dentry *debugfs_entry; + struct slic_spinlock upr_lock; + struct slic_spinlock bit64reglock; +- slic_rspqueue_t rspqueue; +- slic_rcvqueue_t rcvqueue; +- slic_cmdqueue_t cmdq_free; +- slic_cmdqueue_t cmdq_done; +- slic_cmdqueue_t cmdq_all; +- slic_cmdqmem_t cmdqmem; ++ struct slic_rspqueue rspqueue; ++ struct slic_rcvqueue rcvqueue; ++ struct slic_cmdqueue cmdq_free; ++ struct slic_cmdqueue cmdq_done; ++ struct slic_cmdqueue cmdq_all; ++ struct slic_cmdqmem cmdqmem; + /* + * SLIC Handles + */ +- slic_handle_t slic_handles[SLIC_CMDQ_MAXCMDS+1]; /* Object handles*/ +- pslic_handle_t pfree_slic_handles; /* Free object handles*/ ++ struct slic_handle slic_handles[SLIC_CMDQ_MAXCMDS+1]; /* Object handles*/ ++ struct slic_handle *pfree_slic_handles; /* Free object handles*/ + struct slic_spinlock handle_lock; /* Object handle list lock*/ + ushort slic_handle_ix; + +- ulong32 xmitq_full; +- ulong32 all_reg_writes; +- ulong32 icr_reg_writes; +- ulong32 isr_reg_writes; +- ulong32 error_interrupts; +- ulong32 error_rmiss_interrupts; +- ulong32 rx_errors; +- ulong32 rcv_drops; +- ulong32 rcv_interrupts; +- ulong32 xmit_interrupts; +- ulong32 linkevent_interrupts; +- ulong32 upr_interrupts; +- ulong32 num_isrs; +- ulong32 false_interrupts; +- ulong32 tx_packets; +- ulong32 xmit_completes; +- ulong32 tx_drops; +- ulong32 rcv_broadcasts; +- ulong32 rcv_multicasts; +- ulong32 rcv_unicasts; +- ulong32 max_isr_rcvs; +- ulong32 max_isr_xmits; +- ulong32 rcv_interrupt_yields; +- ulong32 intagg_period; +- p_inicpm_state_t inicpm_info; +- pvoid pinicpm_info; +- slic_reg_params_t reg_params; +- slic_ifevents_t if_events; +- slic_stats_t inicstats_prev; +- slicnet_stats_t slic_stats; ++ u32 xmitq_full; ++ u32 all_reg_writes; ++ u32 icr_reg_writes; ++ u32 isr_reg_writes; ++ u32 error_interrupts; ++ u32 error_rmiss_interrupts; ++ u32 rx_errors; ++ u32 rcv_drops; ++ u32 rcv_interrupts; ++ u32 xmit_interrupts; ++ u32 linkevent_interrupts; ++ u32 upr_interrupts; ++ u32 num_isrs; ++ u32 false_interrupts; ++ u32 tx_packets; ++ u32 xmit_completes; ++ u32 tx_drops; ++ u32 rcv_broadcasts; ++ u32 rcv_multicasts; ++ u32 rcv_unicasts; ++ u32 max_isr_rcvs; ++ u32 max_isr_xmits; ++ u32 rcv_interrupt_yields; ++ u32 intagg_period; ++ struct inicpm_state *inicpm_info; ++ void *pinicpm_info; ++ struct slic_reg_params reg_params; ++ struct slic_ifevents if_events; ++ struct slic_stats inicstats_prev; ++ struct slicnet_stats slic_stats; + struct net_device_stats stats; +-} adapter_t, *p_adapter_t; ++}; + + #if SLIC_DUMP_ENABLED + #define SLIC_DUMP_REQUESTED 1 +@@ -552,10 +547,10 @@ typedef struct _adapter_t { + * structure is written out to the card's SRAM when the microcode panic's. + * + ****************************************************************************/ +-typedef struct _slic_crash_info { ++struct slic_crash_info { + ushort cpu_id; + ushort crash_pc; +-} slic_crash_info, *p_slic_crash_info; ++}; + + #define CRASH_INFO_OFFSET 0x155C + +@@ -577,20 +572,20 @@ typedef struct _slic_crash_info { + #define ETHER_EQ_ADDR(_AddrA, _AddrB, _Result) \ + { \ + _Result = TRUE; \ +- if (*(pulong32)(_AddrA) != *(pulong32)(_AddrB)) \ ++ if (*(u32 *)(_AddrA) != *(u32 *)(_AddrB)) \ + _Result = FALSE; \ +- if (*(pushort)(&((_AddrA)[4])) != *(pushort)(&((_AddrB)[4]))) \ ++ if (*(u16 *)(&((_AddrA)[4])) != *(u16 *)(&((_AddrB)[4]))) \ + _Result = FALSE; \ + } + + #if defined(CONFIG_X86_64) || defined(CONFIG_IA64) +-#define SLIC_GET_ADDR_LOW(_addr) (ulong32)((ulong64)(_addr) & \ ++#define SLIC_GET_ADDR_LOW(_addr) (u32)((u64)(_addr) & \ + 0x00000000FFFFFFFF) +-#define SLIC_GET_ADDR_HIGH(_addr) (ulong32)(((ulong64)(_addr) >> 32) & \ ++#define SLIC_GET_ADDR_HIGH(_addr) (u32)(((u64)(_addr) >> 32) & \ + 0x00000000FFFFFFFF) + #else +-#define SLIC_GET_ADDR_LOW(_addr) (ulong32)_addr +-#define SLIC_GET_ADDR_HIGH(_addr) (ulong32)0 ++#define SLIC_GET_ADDR_LOW(_addr) (u32)_addr ++#define SLIC_GET_ADDR_HIGH(_addr) (u32)0 + #endif + + #define FLUSH TRUE +diff --git a/drivers/staging/slicoss/slic_os.h b/drivers/staging/slicoss/slic_os.h +index 2064673..b0d2883 100644 +--- a/drivers/staging/slicoss/slic_os.h ++++ b/drivers/staging/slicoss/slic_os.h +@@ -2,7 +2,6 @@ + * + * Copyright (c)2000-2002 Alacritech, Inc. All rights reserved. + * +- * $Id: slic_os.h,v 1.2 2006/03/27 15:10:15 mook Exp $ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions +@@ -43,87 +42,9 @@ + #ifndef _SLIC_OS_SPECIFIC_H_ + #define _SLIC_OS_SPECIFIC_H_ + +-typedef unsigned char uchar; +-typedef u64 ulong64; +-typedef char *pchar; +-typedef unsigned char *puchar; +-typedef u16 *pushort; +-typedef u32 ulong32; +-typedef u32 *pulong32; +-typedef int *plong32; +-typedef unsigned int *puint; +-typedef void *pvoid; +-typedef unsigned long *pulong; +-typedef unsigned int boolean; +-typedef unsigned int wchar; +-typedef unsigned int *pwchar; +-typedef unsigned char UCHAR; +-typedef u32 ULONG; +-typedef s32 LONG; + #define FALSE (0) + #define TRUE (1) + +-#define SLIC_INIT_SPINLOCK(x) \ +- { \ +- spin_lock_init(&((x).lock)); \ +- } +-#define SLIC_ACQUIRE_SPINLOCK(x) \ +- { \ +- spin_lock(&((x).lock)); \ +- } +- +-#define SLIC_RELEASE_SPINLOCK(x) \ +- { \ +- spin_unlock(&((x).lock)); \ +- } +- +-#define SLIC_ACQUIRE_IRQ_SPINLOCK(x) \ +- { \ +- spin_lock_irqsave(&((x).lock), (x).flags); \ +- } +- +-#define SLIC_RELEASE_IRQ_SPINLOCK(x) \ +- { \ +- spin_unlock_irqrestore(&((x).lock), (x).flags); \ +- } +- +-#define ATK_DEBUG 1 +- +-#if ATK_DEBUG +-#define SLIC_TIMESTAMP(value) { \ +- struct timeval timev; \ +- do_gettimeofday(&timev); \ +- value = timev.tv_sec*1000000 + timev.tv_usec; \ +-} +-#else +-#define SLIC_TIMESTAMP(value) +-#endif +- +-#define SLIC_ALLOCATE_MEM(len, flag) kmalloc(len, flag) +-#define SLIC_DEALLOCATE_MEM(mem) kfree(mem) +-#define SLIC_DEALLOCATE_IRQ_MEM(mem) free(mem) +-#define SLIC_ALLOCATE_PAGE(x) (pulong32)get_free_page(GFP_KERNEL) +-#define SLIC_DEALLOCATE_PAGE(addr) free_page((ulong32)addr) +-#define SLIC_ALLOCATE_PCIMEM(a, sz, physp) \ +- pci_alloc_consistent((a)->pcidev, (sz), &(physp)) +-#define SLIC_DEALLOCATE_PCIMEM(a, sz, vp, pp) \ +- pci_free_consistent((a)->pcidev, (sz), (vp), (pp)) +-#define SLIC_GET_PHYSICAL_ADDRESS(addr) virt_to_bus((addr)) +-#define SLIC_GET_PHYSICAL_ADDRESS_HIGH(addr) 0 +- +-#define SLIC_GET_DMA_ADDRESS_WRITE(a, ptr, sz) \ +- pci_map_single((a)->pcidev, (ptr), (sz), PCI_DMA_TODEVICE) +-#define SLIC_GET_DMA_ADDRESS_READ(a, ptr, sz) \ +- pci_map_single((a)->pcidev, (ptr), (sz), PCI_DMA_FROMDEVICE) +-#define SLIC_UNGET_DMA_ADDRESS_WRITE(a, pa, sz) \ +- pci_unmap_single((a)->pcidev, (pa), (sz), PCI_DMA_TODEVICE) +-#define SLIC_UNGET_DMA_ADDRESS_READ(a, pa, sz) \ +- pci_unmap_single((a)->pcidev, (pa), (sz), PCI_DMA_FROMDEVICE) +- +-#define SLIC_ZERO_MEMORY(p, sz) memset((p), 0, (sz)) +-#define SLIC_EQUAL_MEMORY(src1, src2, len) (!memcmp(src1, src2, len)) +-#define SLIC_MOVE_MEMORY(dst, src, len) memcpy((dst), (src), (len)) +- + #define SLIC_SECS_TO_JIFFS(x) ((x) * HZ) + #define SLIC_MS_TO_JIFFIES(x) (SLIC_SECS_TO_JIFFS((x)) / 1000) + +@@ -132,7 +53,7 @@ typedef s32 LONG; + { \ + adapter->card->reg_type[adapter->card->debug_ix] = 0; \ + adapter->card->reg_offset[adapter->card->debug_ix] = \ +- ((puchar)(®)) - ((puchar)adapter->slic_regs); \ ++ ((unsigned char *)(®)) - ((unsigned char *)adapter->slic_regs); \ + adapter->card->reg_value[adapter->card->debug_ix++] = value; \ + if (adapter->card->debug_ix == 32) \ + adapter->card->debug_ix = 0; \ +@@ -142,7 +63,7 @@ typedef s32 LONG; + { \ + adapter->card->reg_type[adapter->card->debug_ix] = 1; \ + adapter->card->reg_offset[adapter->card->debug_ix] = \ +- ((puchar)(®)) - ((puchar)adapter->slic_regs); \ ++ ((unsigned char *)(®)) - ((unsigned char *)adapter->slic_regs); \ + adapter->card->reg_value[adapter->card->debug_ix] = value; \ + adapter->card->reg_valueh[adapter->card->debug_ix++] = valh; \ + if (adapter->card->debug_ix == 32) \ +@@ -156,8 +77,6 @@ typedef s32 LONG; + #define WRITE_REG64(a, reg, value, regh, valh, flush) \ + slic_reg64_write((a), (®), (value), (®h), (valh), (flush)) + #endif +-#define READ_REG(reg, flush) slic_reg32_read((®), (flush)) +-#define READ_REGP16(reg, flush) slic_reg16_read((®), (flush)) + + #endif /* _SLIC_OS_SPECIFIC_H_ */ + +diff --git a/drivers/staging/slicoss/slicbuild.h b/drivers/staging/slicoss/slicbuild.h +index ddf1665..ae05e04 100644 +--- a/drivers/staging/slicoss/slicbuild.h ++++ b/drivers/staging/slicoss/slicbuild.h +@@ -2,7 +2,6 @@ + * + * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved. + * +- * $Id: slicbuild.h,v 1.2 2006/03/27 15:10:10 mook Exp $ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions +diff --git a/drivers/staging/slicoss/slicdbg.h b/drivers/staging/slicoss/slicdbg.h +index c1be56f..c54e44f 100644 +--- a/drivers/staging/slicoss/slicdbg.h ++++ b/drivers/staging/slicoss/slicdbg.h +@@ -2,7 +2,6 @@ + * + * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved. + * +- * $Id: slicdbg.h,v 1.2 2006/03/27 15:10:04 mook Exp $ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions +@@ -66,7 +65,7 @@ + #ifdef CONFIG_X86_64 + #define VALID_ADDRESS(p) (1) + #else +-#define VALID_ADDRESS(p) (((ulong32)(p) & 0x80000000) || ((ulong32)(p) == 0)) ++#define VALID_ADDRESS(p) (((u32)(p) & 0x80000000) || ((u32)(p) == 0)) + #endif + #ifndef ASSERT + #define ASSERT(a) \ +diff --git a/drivers/staging/slicoss/slicdump.h b/drivers/staging/slicoss/slicdump.h +index 3c46094..ca0a221 100644 +--- a/drivers/staging/slicoss/slicdump.h ++++ b/drivers/staging/slicoss/slicdump.h +@@ -1,5 +1,4 @@ + /* +- * $Id: slicdump.h,v 1.2 2006/03/27 15:09:57 mook Exp $ + * + * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved. + * +@@ -148,32 +147,32 @@ + /* + * Break and Reset Break command structure + */ +-typedef struct _BREAK { +- uchar command; /* Command word defined above */ +- uchar resvd; ++struct BREAK { ++ unsigned char command; /* Command word defined above */ ++ unsigned char resvd; + ushort count; /* Number of executions before break */ +- ulong32 addr; /* Address of break point */ +-} BREAK, *PBREAK; ++ u32 addr; /* Address of break point */ ++}; + + /* + * Dump and Load command structure + */ +-typedef struct _dump_cmd { +- uchar cmd; /* Command word defined above */ +- uchar desc; /* Descriptor values - defined below */ ++struct dump_cmd { ++ unsigned char cmd; /* Command word defined above */ ++ unsigned char desc; /* Descriptor values - defined below */ + ushort count; /* number of 4 byte words to be transferred */ +- ulong32 addr; /* start address of dump or load */ +-} dump_cmd_t, *pdump_cmd_t; ++ u32 addr; /* start address of dump or load */ ++}; + + /* + * Receive or Transmit a frame. + */ +-typedef struct _RCV_OR_XMT_FRAME { +- uchar command; /* Command word defined above */ +- uchar MacId; /* Mac ID of interface - transmit only */ ++struct RCV_OR_XMT_FRAME { ++ unsigned char command; /* Command word defined above */ ++ unsigned char MacId; /* Mac ID of interface - transmit only */ + ushort count; /* Length of frame in bytes */ +- ulong32 pad; /* not used */ +-} RCV_OR_XMT_FRAME, *PRCV_OR_XMT_FRAME; ++ u32 pad; /* not used */ ++}; + + /* + * Values of desc field in DUMP_OR_LOAD structure +@@ -196,12 +195,12 @@ typedef struct _RCV_OR_XMT_FRAME { + /* + * Map command to replace a command in ROM with a command in WCS + */ +-typedef struct _MAP { +- uchar command; /* Command word defined above */ +- uchar not_used[3]; ++struct MAP { ++ unsigned char command; /* Command word defined above */ ++ unsigned char not_used[3]; + ushort map_to; /* Instruction address in WCS */ + ushort map_out; /* Instruction address in ROM */ +-} MAP, *PMAP; ++}; + + /* + * Misc definitions +@@ -221,35 +220,35 @@ typedef struct _MAP { + /* + * Coredump header structure + */ +-typedef struct _CORE_Q { +- ulong32 queueOff; /* Offset of queue */ +- ulong32 queuesize; /* size of queue */ +-} CORE_Q; ++struct CORE_Q { ++ u32 queueOff; /* Offset of queue */ ++ u32 queuesize; /* size of queue */ ++}; + + #define DRIVER_NAME_SIZE 32 + +-typedef struct _sliccore_hdr_t { +- uchar driver_version[DRIVER_NAME_SIZE]; /* Driver version string */ +- ulong32 RcvRegOff; /* Offset of receive registers */ +- ulong32 RcvRegsize; /* size of receive registers */ +- ulong32 XmtRegOff; /* Offset of transmit registers */ +- ulong32 XmtRegsize; /* size of transmit registers */ +- ulong32 FileRegOff; /* Offset of register file */ +- ulong32 FileRegsize; /* size of register file */ +- ulong32 SramOff; /* Offset of Sram */ +- ulong32 Sramsize; /* size of Sram */ +- ulong32 DramOff; /* Offset of Dram */ +- ulong32 Dramsize; /* size of Dram */ ++struct sliccore_hdr { ++ unsigned char driver_version[DRIVER_NAME_SIZE]; /* Driver version string */ ++ u32 RcvRegOff; /* Offset of receive registers */ ++ u32 RcvRegsize; /* size of receive registers */ ++ u32 XmtRegOff; /* Offset of transmit registers */ ++ u32 XmtRegsize; /* size of transmit registers */ ++ u32 FileRegOff; /* Offset of register file */ ++ u32 FileRegsize; /* size of register file */ ++ u32 SramOff; /* Offset of Sram */ ++ u32 Sramsize; /* size of Sram */ ++ u32 DramOff; /* Offset of Dram */ ++ u32 Dramsize; /* size of Dram */ + CORE_Q queues[SLIC_MAX_QUEUE]; /* size and offsets of queues */ +- ulong32 CamAMOff; /* Offset of CAM A contents */ +- ulong32 CamASize; /* Size of Cam A */ +- ulong32 CamBMOff; /* Offset of CAM B contents */ +- ulong32 CamBSize; /* Size of Cam B */ +- ulong32 CamCMOff; /* Offset of CAM C contents */ +- ulong32 CamCSize; /* Size of Cam C */ +- ulong32 CamDMOff; /* Offset of CAM D contents */ +- ulong32 CamDSize; /* Size of Cam D */ +-} sliccore_hdr_t, *p_sliccore_hdr_t; ++ u32 CamAMOff; /* Offset of CAM A contents */ ++ u32 CamASize; /* Size of Cam A */ ++ u32 CamBMOff; /* Offset of CAM B contents */ ++ u32 CamBSize; /* Size of Cam B */ ++ u32 CamCMOff; /* Offset of CAM C contents */ ++ u32 CamCSize; /* Size of Cam C */ ++ u32 CamDMOff; /* Offset of CAM D contents */ ++ u32 CamDSize; /* Size of Cam D */ ++}; + + /* + * definitions needed for our kernel-mode gdb stub. +diff --git a/drivers/staging/slicoss/slichw.h b/drivers/staging/slicoss/slichw.h +index d5765c4..4c5c15d 100644 +--- a/drivers/staging/slicoss/slichw.h ++++ b/drivers/staging/slicoss/slichw.h +@@ -2,7 +2,6 @@ + * + * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved. + * +- * $Id: slichw.h,v 1.3 2008/03/17 19:27:26 chris Exp $ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions +@@ -236,110 +235,106 @@ + #define TRUE 1 + #endif + +-typedef struct _slic_rcvbuf_t { +- uchar pad1[6]; ++struct slic_rcvbuf { ++ unsigned char pad1[6]; + ushort pad2; +- ulong32 pad3; +- ulong32 pad4; +- ulong32 buffer; +- ulong32 length; +- ulong32 status; +- ulong32 pad5; ++ u32 pad3; ++ u32 pad4; ++ u32 buffer; ++ u32 length; ++ u32 status; ++ u32 pad5; + ushort pad6; +- uchar data[SLIC_RCVBUF_DATASIZE]; +-} slic_rcvbuf_t, *p_slic_rcvbuf_t; ++ unsigned char data[SLIC_RCVBUF_DATASIZE]; ++}; + +-typedef struct _slic_hddr_wds { ++ struct slic_hddr_wds { + union { + struct { +- ulong32 frame_status; +- ulong32 frame_status_b; +- ulong32 time_stamp; +- ulong32 checksum; ++ u32 frame_status; ++ u32 frame_status_b; ++ u32 time_stamp; ++ u32 checksum; + } hdrs_14port; + struct { +- ulong32 frame_status; ++ u32 frame_status; + ushort ByteCnt; + ushort TpChksum; + ushort CtxHash; + ushort MacHash; +- ulong32 BufLnk; ++ u32 BufLnk; + } hdrs_gbit; + } u0; +-} slic_hddr_wds_t, *p_slic_hddr_wds; ++}; + + #define frame_status14 u0.hdrs_14port.frame_status + #define frame_status_b14 u0.hdrs_14port.frame_status_b + #define frame_statusGB u0.hdrs_gbit.frame_status + +-typedef struct _slic_host64sg_t { +- ulong32 paddrl; +- ulong32 paddrh; +- ulong32 length; +-} slic_host64sg_t, *p_slic_host64sg_t; +- +-typedef struct _slic_host64_cmd_t { +- ulong32 hosthandle; +- ulong32 RSVD; +- uchar command; +- uchar flags; ++struct slic_host64sg { ++ u32 paddrl; ++ u32 paddrh; ++ u32 length; ++}; ++ ++struct slic_host64_cmd { ++ u32 hosthandle; ++ u32 RSVD; ++ unsigned char command; ++ unsigned char flags; + union { + ushort rsv1; + ushort rsv2; + } u0; + union { + struct { +- ulong32 totlen; +- slic_host64sg_t bufs[SLIC_MAX64_BCNT]; ++ u32 totlen; ++ struct slic_host64sg bufs[SLIC_MAX64_BCNT]; + } slic_buffers; + } u; ++}; + +-} slic_host64_cmd_t, *p_slic_host64_cmd_t; ++struct slic_rspbuf { ++ u32 hosthandle; ++ u32 pad0; ++ u32 pad1; ++ u32 status; ++ u32 pad2[4]; + +-typedef struct _slic_rspbuf_t { +- ulong32 hosthandle; +- ulong32 pad0; +- ulong32 pad1; +- ulong32 status; +- ulong32 pad2[4]; ++}; + +-} slic_rspbuf_t, *p_slic_rspbuf_t; ++struct slic_regs { ++ u32 slic_reset; /* Reset Register */ ++ u32 pad0; + +-typedef ulong32 SLIC_REG; +- +- +-typedef struct _slic_regs_t { +- ULONG slic_reset; /* Reset Register */ +- ULONG pad0; +- +- ULONG slic_icr; /* Interrupt Control Register */ +- ULONG pad2; ++ u32 slic_icr; /* Interrupt Control Register */ ++ u32 pad2; + #define SLIC_ICR 0x0008 + +- ULONG slic_isp; /* Interrupt status pointer */ +- ULONG pad1; ++ u32 slic_isp; /* Interrupt status pointer */ ++ u32 pad1; + #define SLIC_ISP 0x0010 + +- ULONG slic_isr; /* Interrupt status */ +- ULONG pad3; ++ u32 slic_isr; /* Interrupt status */ ++ u32 pad3; + #define SLIC_ISR 0x0018 + +- SLIC_REG slic_hbar; /* Header buffer address reg */ +- ULONG pad4; ++ u32 slic_hbar; /* Header buffer address reg */ ++ u32 pad4; + /* 31-8 - phy addr of set of contiguous hdr buffers + 7-0 - number of buffers passed + Buffers are 256 bytes long on 256-byte boundaries. */ + #define SLIC_HBAR 0x0020 + #define SLIC_HBAR_CNT_MSK 0x000000FF + +- SLIC_REG slic_dbar; /* Data buffer handle & address reg */ +- ULONG pad5; ++ u32 slic_dbar; /* Data buffer handle & address reg */ ++ u32 pad5; + + /* 4 sets of registers; Buffers are 2K bytes long 2 per 4K page. */ + #define SLIC_DBAR 0x0028 + #define SLIC_DBAR_SIZE 2048 + +- SLIC_REG slic_cbar; /* Xmt Cmd buf addr regs.*/ ++ u32 slic_cbar; /* Xmt Cmd buf addr regs.*/ + /* 1 per XMT interface + 31-5 - phy addr of host command buffer + 4-0 - length of cmd in multiples of 32 bytes +@@ -348,13 +343,13 @@ typedef struct _slic_regs_t { + #define SLIC_CBAR_LEN_MSK 0x0000001F + #define SLIC_CBAR_ALIGN 0x00000020 + +- SLIC_REG slic_wcs; /* write control store*/ ++ u32 slic_wcs; /* write control store*/ + #define SLIC_WCS 0x0034 + #define SLIC_WCS_START 0x80000000 /*Start the SLIC (Jump to WCS)*/ + #define SLIC_WCS_COMPARE 0x40000000 /* Compare with value in WCS*/ + +- SLIC_REG slic_rbar; /* Response buffer address reg.*/ +- ULONG pad7; ++ u32 slic_rbar; /* Response buffer address reg.*/ ++ u32 pad7; + /*31-8 - phy addr of set of contiguous response buffers + 7-0 - number of buffers passed + Buffers are 32 bytes long on 32-byte boundaries.*/ +@@ -362,166 +357,166 @@ typedef struct _slic_regs_t { + #define SLIC_RBAR_CNT_MSK 0x000000FF + #define SLIC_RBAR_SIZE 32 + +- SLIC_REG slic_stats; /* read statistics (UPR) */ +- ULONG pad8; ++ u32 slic_stats; /* read statistics (UPR) */ ++ u32 pad8; + #define SLIC_RSTAT 0x0040 + +- SLIC_REG slic_rlsr; /* read link status */ +- ULONG pad9; ++ u32 slic_rlsr; /* read link status */ ++ u32 pad9; + #define SLIC_LSTAT 0x0048 + +- SLIC_REG slic_wmcfg; /* Write Mac Config */ +- ULONG pad10; ++ u32 slic_wmcfg; /* Write Mac Config */ ++ u32 pad10; + #define SLIC_WMCFG 0x0050 + +- SLIC_REG slic_wphy; /* Write phy register */ +- ULONG pad11; ++ u32 slic_wphy; /* Write phy register */ ++ u32 pad11; + #define SLIC_WPHY 0x0058 + +- SLIC_REG slic_rcbar; /*Rcv Cmd buf addr reg*/ +- ULONG pad12; ++ u32 slic_rcbar; /*Rcv Cmd buf addr reg*/ ++ u32 pad12; + #define SLIC_RCBAR 0x0060 + +- SLIC_REG slic_rconfig; /* Read SLIC Config*/ +- ULONG pad13; ++ u32 slic_rconfig; /* Read SLIC Config*/ ++ u32 pad13; + #define SLIC_RCONFIG 0x0068 + +- SLIC_REG slic_intagg; /* Interrupt aggregation time*/ +- ULONG pad14; ++ u32 slic_intagg; /* Interrupt aggregation time*/ ++ u32 pad14; + #define SLIC_INTAGG 0x0070 + +- SLIC_REG slic_wxcfg; /* Write XMIT config reg*/ +- ULONG pad16; ++ u32 slic_wxcfg; /* Write XMIT config reg*/ ++ u32 pad16; + #define SLIC_WXCFG 0x0078 + +- SLIC_REG slic_wrcfg; /* Write RCV config reg*/ +- ULONG pad17; ++ u32 slic_wrcfg; /* Write RCV config reg*/ ++ u32 pad17; + #define SLIC_WRCFG 0x0080 + +- SLIC_REG slic_wraddral; /* Write rcv addr a low*/ +- ULONG pad18; ++ u32 slic_wraddral; /* Write rcv addr a low*/ ++ u32 pad18; + #define SLIC_WRADDRAL 0x0088 + +- SLIC_REG slic_wraddrah; /* Write rcv addr a high*/ +- ULONG pad19; ++ u32 slic_wraddrah; /* Write rcv addr a high*/ ++ u32 pad19; + #define SLIC_WRADDRAH 0x0090 + +- SLIC_REG slic_wraddrbl; /* Write rcv addr b low*/ +- ULONG pad20; ++ u32 slic_wraddrbl; /* Write rcv addr b low*/ ++ u32 pad20; + #define SLIC_WRADDRBL 0x0098 + +- SLIC_REG slic_wraddrbh; /* Write rcv addr b high*/ +- ULONG pad21; ++ u32 slic_wraddrbh; /* Write rcv addr b high*/ ++ u32 pad21; + #define SLIC_WRADDRBH 0x00a0 + +- SLIC_REG slic_mcastlow; /* Low bits of mcast mask*/ +- ULONG pad22; ++ u32 slic_mcastlow; /* Low bits of mcast mask*/ ++ u32 pad22; + #define SLIC_MCASTLOW 0x00a8 + +- SLIC_REG slic_mcasthigh; /* High bits of mcast mask*/ +- ULONG pad23; ++ u32 slic_mcasthigh; /* High bits of mcast mask*/ ++ u32 pad23; + #define SLIC_MCASTHIGH 0x00b0 + +- SLIC_REG slic_ping; /* Ping the card*/ +- ULONG pad24; ++ u32 slic_ping; /* Ping the card*/ ++ u32 pad24; + #define SLIC_PING 0x00b8 + +- SLIC_REG slic_dump_cmd; /* Dump command */ +- ULONG pad25; ++ u32 slic_dump_cmd; /* Dump command */ ++ u32 pad25; + #define SLIC_DUMP_CMD 0x00c0 + +- SLIC_REG slic_dump_data; /* Dump data pointer */ +- ULONG pad26; ++ u32 slic_dump_data; /* Dump data pointer */ ++ u32 pad26; + #define SLIC_DUMP_DATA 0x00c8 + +- SLIC_REG slic_pcistatus; /* Read card's pci_status register */ +- ULONG pad27; ++ u32 slic_pcistatus; /* Read card's pci_status register */ ++ u32 pad27; + #define SLIC_PCISTATUS 0x00d0 + +- SLIC_REG slic_wrhostid; /* Write hostid field */ +- ULONG pad28; ++ u32 slic_wrhostid; /* Write hostid field */ ++ u32 pad28; + #define SLIC_WRHOSTID 0x00d8 + #define SLIC_RDHOSTID_1GB 0x1554 + #define SLIC_RDHOSTID_2GB 0x1554 + +- SLIC_REG slic_low_power; /* Put card in a low power state */ +- ULONG pad29; ++ u32 slic_low_power; /* Put card in a low power state */ ++ u32 pad29; + #define SLIC_LOW_POWER 0x00e0 + +- SLIC_REG slic_quiesce; /* force slic into quiescent state ++ u32 slic_quiesce; /* force slic into quiescent state + before soft reset */ +- ULONG pad30; ++ u32 pad30; + #define SLIC_QUIESCE 0x00e8 + +- SLIC_REG slic_reset_iface; /* reset interface queues */ +- ULONG pad31; ++ u32 slic_reset_iface; /* reset interface queues */ ++ u32 pad31; + #define SLIC_RESET_IFACE 0x00f0 + +- SLIC_REG slic_addr_upper; /* Bits 63-32 for host i/f addrs */ +- ULONG pad32; ++ u32 slic_addr_upper; /* Bits 63-32 for host i/f addrs */ ++ u32 pad32; + #define SLIC_ADDR_UPPER 0x00f8 /*Register is only written when it has changed*/ + +- SLIC_REG slic_hbar64; /* 64 bit Header buffer address reg */ +- ULONG pad33; ++ u32 slic_hbar64; /* 64 bit Header buffer address reg */ ++ u32 pad33; + #define SLIC_HBAR64 0x0100 + +- SLIC_REG slic_dbar64; /* 64 bit Data buffer handle & address reg */ +- ULONG pad34; ++ u32 slic_dbar64; /* 64 bit Data buffer handle & address reg */ ++ u32 pad34; + #define SLIC_DBAR64 0x0108 + +- SLIC_REG slic_cbar64; /* 64 bit Xmt Cmd buf addr regs. */ +- ULONG pad35; ++ u32 slic_cbar64; /* 64 bit Xmt Cmd buf addr regs. */ ++ u32 pad35; + #define SLIC_CBAR64 0x0110 + +- SLIC_REG slic_rbar64; /* 64 bit Response buffer address reg.*/ +- ULONG pad36; ++ u32 slic_rbar64; /* 64 bit Response buffer address reg.*/ ++ u32 pad36; + #define SLIC_RBAR64 0x0118 + +- SLIC_REG slic_rcbar64; /* 64 bit Rcv Cmd buf addr reg*/ +- ULONG pad37; ++ u32 slic_rcbar64; /* 64 bit Rcv Cmd buf addr reg*/ ++ u32 pad37; + #define SLIC_RCBAR64 0x0120 + +- SLIC_REG slic_stats64; /*read statistics (64 bit UPR)*/ +- ULONG pad38; ++ u32 slic_stats64; /*read statistics (64 bit UPR)*/ ++ u32 pad38; + #define SLIC_RSTAT64 0x0128 + +- SLIC_REG slic_rcv_wcs; /*Download Gigabit RCV sequencer ucode*/ +- ULONG pad39; ++ u32 slic_rcv_wcs; /*Download Gigabit RCV sequencer ucode*/ ++ u32 pad39; + #define SLIC_RCV_WCS 0x0130 + #define SLIC_RCVWCS_BEGIN 0x40000000 + #define SLIC_RCVWCS_FINISH 0x80000000 + +- SLIC_REG slic_wrvlanid; /* Write VlanId field */ +- ULONG pad40; ++ u32 slic_wrvlanid; /* Write VlanId field */ ++ u32 pad40; + #define SLIC_WRVLANID 0x0138 + +- SLIC_REG slic_read_xf_info; /* Read Transformer info */ +- ULONG pad41; ++ u32 slic_read_xf_info; /* Read Transformer info */ ++ u32 pad41; + #define SLIC_READ_XF_INFO 0x0140 + +- SLIC_REG slic_write_xf_info; /* Write Transformer info */ +- ULONG pad42; ++ u32 slic_write_xf_info; /* Write Transformer info */ ++ u32 pad42; + #define SLIC_WRITE_XF_INFO 0x0148 + +- SLIC_REG RSVD1; /* TOE Only */ +- ULONG pad43; ++ u32 RSVD1; /* TOE Only */ ++ u32 pad43; + +- SLIC_REG RSVD2; /* TOE Only */ +- ULONG pad44; ++ u32 RSVD2; /* TOE Only */ ++ u32 pad44; + +- SLIC_REG RSVD3; /* TOE Only */ +- ULONG pad45; ++ u32 RSVD3; /* TOE Only */ ++ u32 pad45; + +- SLIC_REG RSVD4; /* TOE Only */ +- ULONG pad46; ++ u32 RSVD4; /* TOE Only */ ++ u32 pad46; + +- SLIC_REG slic_ticks_per_sec; /* Write card ticks per second */ +- ULONG pad47; ++ u32 slic_ticks_per_sec; /* Write card ticks per second */ ++ u32 pad47; + #define SLIC_TICKS_PER_SEC 0x0170 + +-} __iomem slic_regs_t, *p_slic_regs_t, SLIC_REGS, *PSLIC_REGS; ++}; + +-typedef enum _UPR_REQUEST { ++enum UPR_REQUEST { + SLIC_UPR_STATS, + SLIC_UPR_RLSR, + SLIC_UPR_WCFG, +@@ -532,103 +527,102 @@ typedef enum _UPR_REQUEST { + SLIC_UPR_PDWN, + SLIC_UPR_PING, + SLIC_UPR_DUMP, +-} UPR_REQUEST; +- +-typedef struct _inicpm_wakepattern { +- ulong32 patternlength; +- uchar pattern[SLIC_PM_PATTERNSIZE]; +- uchar mask[SLIC_PM_PATTERNSIZE]; +-} inicpm_wakepattern_t, *p_inicpm_wakepattern_t; +- +-typedef struct _inicpm_state { +- ulong32 powercaps; +- ulong32 powerstate; +- ulong32 wake_linkstatus; +- ulong32 wake_magicpacket; +- ulong32 wake_framepattern; +- inicpm_wakepattern_t wakepattern[SLIC_PM_MAXPATTERNS]; +-} inicpm_state_t, *p_inicpm_state_t; +- +-typedef struct _slicpm_packet_pattern { +- ulong32 priority; +- ulong32 reserved; +- ulong32 masksize; +- ulong32 patternoffset; +- ulong32 patternsize; +- ulong32 patternflags; +-} slicpm_packet_pattern_t, *p_slicpm_packet_pattern_t; +- +-typedef enum _slicpm_power_state { ++}; ++ ++struct inicpm_wakepattern { ++ u32 patternlength; ++ unsigned char pattern[SLIC_PM_PATTERNSIZE]; ++ unsigned char mask[SLIC_PM_PATTERNSIZE]; ++}; ++ ++struct inicpm_state { ++ u32 powercaps; ++ u32 powerstate; ++ u32 wake_linkstatus; ++ u32 wake_magicpacket; ++ u32 wake_framepattern; ++ struct inicpm_wakepattern wakepattern[SLIC_PM_MAXPATTERNS]; ++}; ++ ++struct slicpm_packet_pattern { ++ u32 priority; ++ u32 reserved; ++ u32 masksize; ++ u32 patternoffset; ++ u32 patternsize; ++ u32 patternflags; ++}; ++ ++enum slicpm_power_state { + slicpm_state_unspecified = 0, + slicpm_state_d0, + slicpm_state_d1, + slicpm_state_d2, + slicpm_state_d3, + slicpm_state_maximum +-} slicpm_state_t, *p_slicpm_state_t; +- +-typedef struct _slicpm_wakeup_capabilities { +- slicpm_state_t min_magic_packet_wakeup; +- slicpm_state_t min_pattern_wakeup; +- slicpm_state_t min_link_change_wakeup; +-} slicpm_wakeup_capabilities_t, *p_slicpm_wakeup_capabilities_t; +- +- +-typedef struct _slic_pnp_capabilities { +- ulong32 flags; +- slicpm_wakeup_capabilities_t wakeup_capabilities; +-} slic_pnp_capabilities_t, *p_slic_pnp_capabilities_t; +- +-typedef struct _xmt_stats_t { +- ulong32 xmit_tcp_bytes; +- ulong32 xmit_tcp_segs; +- ulong32 xmit_bytes; +- ulong32 xmit_collisions; +- ulong32 xmit_unicasts; +- ulong32 xmit_other_error; +- ulong32 xmit_excess_collisions; +-} xmt_stats100_t; +- +-typedef struct _rcv_stats_t { +- ulong32 rcv_tcp_bytes; +- ulong32 rcv_tcp_segs; +- ulong32 rcv_bytes; +- ulong32 rcv_unicasts; +- ulong32 rcv_other_error; +- ulong32 rcv_drops; +-} rcv_stats100_t; +- +-typedef struct _xmt_statsgb_t { +- ulong64 xmit_tcp_bytes; +- ulong64 xmit_tcp_segs; +- ulong64 xmit_bytes; +- ulong64 xmit_collisions; +- ulong64 xmit_unicasts; +- ulong64 xmit_other_error; +- ulong64 xmit_excess_collisions; +-} xmt_statsGB_t; +- +-typedef struct _rcv_statsgb_t { +- ulong64 rcv_tcp_bytes; +- ulong64 rcv_tcp_segs; +- ulong64 rcv_bytes; +- ulong64 rcv_unicasts; +- u64 rcv_other_error; +- ulong64 rcv_drops; +-} rcv_statsGB_t; +- +-typedef struct _slic_stats { ++}; ++ ++struct slicpm_wakeup_capabilities { ++ enum slicpm_power_state min_magic_packet_wakeup; ++ enum slicpm_power_state min_pattern_wakeup; ++ enum slicpm_power_state min_link_change_wakeup; ++}; ++ ++struct slic_pnp_capabilities { ++ u32 flags; ++ struct slicpm_wakeup_capabilities wakeup_capabilities; ++}; ++ ++struct xmt_stats { ++ u32 xmit_tcp_bytes; ++ u32 xmit_tcp_segs; ++ u32 xmit_bytes; ++ u32 xmit_collisions; ++ u32 xmit_unicasts; ++ u32 xmit_other_error; ++ u32 xmit_excess_collisions; ++}; ++ ++struct rcv_stats { ++ u32 rcv_tcp_bytes; ++ u32 rcv_tcp_segs; ++ u32 rcv_bytes; ++ u32 rcv_unicasts; ++ u32 rcv_other_error; ++ u32 rcv_drops; ++}; ++ ++struct xmt_statsgb { ++ u64 xmit_tcp_bytes; ++ u64 xmit_tcp_segs; ++ u64 xmit_bytes; ++ u64 xmit_collisions; ++ u64 xmit_unicasts; ++ u64 xmit_other_error; ++ u64 xmit_excess_collisions; ++}; ++ ++struct rcv_statsgb { ++ u64 rcv_tcp_bytes; ++ u64 rcv_tcp_segs; ++ u64 rcv_bytes; ++ u64 rcv_unicasts; ++ u64 rcv_other_error; ++ u64 rcv_drops; ++}; ++ ++struct slic_stats { + union { + struct { +- xmt_stats100_t xmt100; +- rcv_stats100_t rcv100; ++ struct xmt_stats xmt100; ++ struct rcv_stats rcv100; + } stats_100; + struct { +- xmt_statsGB_t xmtGB; +- rcv_statsGB_t rcvGB; ++ struct xmt_statsgb xmtGB; ++ struct rcv_statsgb rcvGB; + } stats_GB; + } u; +-} slic_stats_t, *p_slic_stats_t; ++}; + + #define xmit_tcp_segs100 u.stats_100.xmt100.xmit_tcp_segs + #define xmit_tcp_bytes100 u.stats_100.xmt100.xmit_tcp_bytes +@@ -658,10 +652,9 @@ typedef struct _slic_stats { + #define rcv_other_error_gb u.stats_GB.rcvGB.rcv_other_error + #define rcv_drops_gb u.stats_GB.rcvGB.rcv_drops + +-typedef struct _slic_config_mac_t { +- uchar macaddrA[6]; +- +-} slic_config_mac_t, *pslic_config_mac_t; ++struct slic_config_mac { ++ unsigned char macaddrA[6]; ++}; + + #define ATK_FRU_FORMAT 0x00 + #define VENDOR1_FRU_FORMAT 0x01 +@@ -670,68 +663,68 @@ typedef struct _slic_config_mac_t { + #define VENDOR4_FRU_FORMAT 0x04 + #define NO_FRU_FORMAT 0xFF + +-typedef struct _atk_fru_t { +- uchar assembly[6]; +- uchar revision[2]; +- uchar serial[14]; +- uchar pad[3]; +-} atk_fru_t, *patk_fru_t; +- +-typedef struct _vendor1_fru_t { +- uchar commodity; +- uchar assembly[4]; +- uchar revision[2]; +- uchar supplier[2]; +- uchar date[2]; +- uchar sequence[3]; +- uchar pad[13]; +-} vendor1_fru_t, *pvendor1_fru_t; +- +-typedef struct _vendor2_fru_t { +- uchar part[8]; +- uchar supplier[5]; +- uchar date[3]; +- uchar sequence[4]; +- uchar pad[7]; +-} vendor2_fru_t, *pvendor2_fru_t; +- +-typedef struct _vendor3_fru_t { +- uchar assembly[6]; +- uchar revision[2]; +- uchar serial[14]; +- uchar pad[3]; +-} vendor3_fru_t, *pvendor3_fru_t; +- +-typedef struct _vendor4_fru_t { +- uchar number[8]; +- uchar part[8]; +- uchar version[8]; +- uchar pad[3]; +-} vendor4_fru_t, *pvendor4_fru_t; +- +-typedef union _oemfru_t { +- vendor1_fru_t vendor1_fru; +- vendor2_fru_t vendor2_fru; +- vendor3_fru_t vendor3_fru; +- vendor4_fru_t vendor4_fru; +-} oemfru_t, *poemfru_t; ++struct atk_fru { ++ unsigned char assembly[6]; ++ unsigned char revision[2]; ++ unsigned char serial[14]; ++ unsigned char pad[3]; ++}; ++ ++struct vendor1_fru { ++ unsigned char commodity; ++ unsigned char assembly[4]; ++ unsigned char revision[2]; ++ unsigned char supplier[2]; ++ unsigned char date[2]; ++ unsigned char sequence[3]; ++ unsigned char pad[13]; ++}; ++ ++struct vendor2_fru { ++ unsigned char part[8]; ++ unsigned char supplier[5]; ++ unsigned char date[3]; ++ unsigned char sequence[4]; ++ unsigned char pad[7]; ++}; ++ ++struct vendor3_fru { ++ unsigned char assembly[6]; ++ unsigned char revision[2]; ++ unsigned char serial[14]; ++ unsigned char pad[3]; ++}; ++ ++struct vendor4_fru { ++ unsigned char number[8]; ++ unsigned char part[8]; ++ unsigned char version[8]; ++ unsigned char pad[3]; ++}; ++ ++union oemfru_t { ++ struct vendor1_fru vendor1_fru; ++ struct vendor2_fru vendor2_fru; ++ struct vendor3_fru vendor3_fru; ++ struct vendor4_fru vendor4_fru; ++}; + + /* + SLIC EEPROM structure for Mojave + */ +-typedef struct _slic_eeprom { ++struct slic_eeprom { + ushort Id; /* 00 EEPROM/FLASH Magic code 'A5A5'*/ + ushort EecodeSize; /* 01 Size of EEPROM Codes (bytes * 4)*/ + ushort FlashSize; /* 02 Flash size */ + ushort EepromSize; /* 03 EEPROM Size */ + ushort VendorId; /* 04 Vendor ID */ + ushort DeviceId; /* 05 Device ID */ +- uchar RevisionId; /* 06 Revision ID */ +- uchar ClassCode[3]; /* 07 Class Code */ +- uchar DbgIntPin; /* 08 Debug Interrupt pin */ +- uchar NetIntPin0; /* Network Interrupt Pin */ +- uchar MinGrant; /* 09 Minimum grant */ +- uchar MaxLat; /* Maximum Latency */ ++ unsigned char RevisionId; /* 06 Revision ID */ ++ unsigned char ClassCode[3]; /* 07 Class Code */ ++ unsigned char DbgIntPin; /* 08 Debug Interrupt pin */ ++ unsigned char NetIntPin0; /* Network Interrupt Pin */ ++ unsigned char MinGrant; /* 09 Minimum grant */ ++ unsigned char MaxLat; /* Maximum Latency */ + ushort PciStatus; /* 10 PCI Status */ + ushort SubSysVId; /* 11 Subsystem Vendor Id */ + ushort SubSysId; /* 12 Subsystem ID */ +@@ -739,58 +732,60 @@ typedef struct _slic_eeprom { + ushort DramRomFn; /* 14 Dram/Rom function */ + ushort DSize2Pci; /* 15 DRAM size to PCI (bytes * 64K) */ + ushort RSize2Pci; /* 16 ROM extension size to PCI (bytes * 4k) */ +- uchar NetIntPin1; /* 17 Network Interface Pin 1 (simba/leone only) */ +- uchar NetIntPin2; /* Network Interface Pin 2 (simba/leone only) */ ++ unsigned char NetIntPin1;/* 17 Network Interface Pin 1 ++ (simba/leone only) */ ++ unsigned char NetIntPin2; /*Network Interface Pin 2 (simba/leone only)*/ + union { +- uchar NetIntPin3;/* 18 Network Interface Pin 3 (simba only) */ +- uchar FreeTime;/* FreeTime setting (leone/mojave only) */ ++ unsigned char NetIntPin3;/*18 Network Interface Pin 3 ++ (simba only)*/ ++ unsigned char FreeTime;/*FreeTime setting (leone/mojave only) */ + } u1; +- uchar TBIctl; /* 10-bit interface control (Mojave only) */ ++ unsigned char TBIctl; /* 10-bit interface control (Mojave only) */ + ushort DramSize; /* 19 DRAM size (bytes * 64k) */ + union { + struct { + /* Mac Interface Specific portions */ +- slic_config_mac_t MacInfo[SLIC_NBR_MACS]; ++ struct slic_config_mac MacInfo[SLIC_NBR_MACS]; + } mac; /* MAC access for all boards */ + struct { + /* use above struct for MAC access */ +- slic_config_mac_t pad[SLIC_NBR_MACS - 1]; ++ struct slic_config_mac pad[SLIC_NBR_MACS - 1]; + ushort DeviceId2; /* Device ID for 2nd + PCI function */ +- uchar IntPin2; /* Interrupt pin for ++ unsigned char IntPin2; /* Interrupt pin for + 2nd PCI function */ +- uchar ClassCode2[3]; /* Class Code for 2nd ++ unsigned char ClassCode2[3]; /* Class Code for 2nd + PCI function */ + } mojave; /* 2nd function access for gigabit board */ + } u2; + ushort CfgByte6; /* Config Byte 6 */ + ushort PMECapab; /* Power Mgment capabilities */ + ushort NwClkCtrls; /* NetworkClockControls */ +- uchar FruFormat; /* Alacritech FRU format type */ +- atk_fru_t AtkFru; /* Alacritech FRU information */ +- uchar OemFruFormat; /* optional OEM FRU format type */ +- oemfru_t OemFru; /* optional OEM FRU information */ +- uchar Pad[4]; /* Pad to 128 bytes - includes 2 cksum bytes ++ unsigned char FruFormat; /* Alacritech FRU format type */ ++ struct atk_fru AtkFru; /* Alacritech FRU information */ ++ unsigned char OemFruFormat; /* optional OEM FRU format type */ ++ union oemfru_t OemFru; /* optional OEM FRU information */ ++ unsigned char Pad[4]; /* Pad to 128 bytes - includes 2 cksum bytes + *(if OEM FRU info exists) and two unusable + * bytes at the end */ +-} slic_eeprom_t, *pslic_eeprom_t; ++}; + + /* SLIC EEPROM structure for Oasis */ +-typedef struct _oslic_eeprom_t { ++struct oslic_eeprom { + ushort Id; /* 00 EEPROM/FLASH Magic code 'A5A5' */ + ushort EecodeSize; /* 01 Size of EEPROM Codes (bytes * 4)*/ + ushort FlashConfig0; /* 02 Flash Config for SPI device 0 */ + ushort FlashConfig1; /* 03 Flash Config for SPI device 1 */ + ushort VendorId; /* 04 Vendor ID */ + ushort DeviceId; /* 05 Device ID (function 0) */ +- uchar RevisionId; /* 06 Revision ID */ +- uchar ClassCode[3]; /* 07 Class Code for PCI function 0 */ +- uchar IntPin1; /* 08 Interrupt pin for PCI function 1*/ +- uchar ClassCode2[3]; /* 09 Class Code for PCI function 1 */ +- uchar IntPin2; /* 10 Interrupt pin for PCI function 2*/ +- uchar IntPin0; /* Interrupt pin for PCI function 0*/ +- uchar MinGrant; /* 11 Minimum grant */ +- uchar MaxLat; /* Maximum Latency */ ++ unsigned char RevisionId; /* 06 Revision ID */ ++ unsigned char ClassCode[3]; /* 07 Class Code for PCI function 0 */ ++ unsigned char IntPin1; /* 08 Interrupt pin for PCI function 1*/ ++ unsigned char ClassCode2[3]; /* 09 Class Code for PCI function 1 */ ++ unsigned char IntPin2; /* 10 Interrupt pin for PCI function 2*/ ++ unsigned char IntPin0; /* Interrupt pin for PCI function 0*/ ++ unsigned char MinGrant; /* 11 Minimum grant */ ++ unsigned char MaxLat; /* Maximum Latency */ + ushort SubSysVId; /* 12 Subsystem Vendor Id */ + ushort SubSysId; /* 13 Subsystem ID */ + ushort FlashSize; /* 14 Flash size (bytes / 4K) */ +@@ -801,8 +796,8 @@ typedef struct _oslic_eeprom_t { + ushort DeviceId2; /* 18 Device Id (function 2) */ + ushort CfgByte6; /* 19 Device Status Config Bytes 6-7 */ + ushort PMECapab; /* 20 Power Mgment capabilities */ +- uchar MSICapab; /* 21 MSI capabilities */ +- uchar ClockDivider; /* Clock divider */ ++ unsigned char MSICapab; /* 21 MSI capabilities */ ++ unsigned char ClockDivider; /* Clock divider */ + ushort PciStatusLow; /* 22 PCI Status bits 15:0 */ + ushort PciStatusHigh; /* 23 PCI Status bits 31:16 */ + ushort DramConfigLow; /* 24 DRAM Configuration bits 15:0 */ +@@ -810,18 +805,18 @@ typedef struct _oslic_eeprom_t { + ushort DramSize; /* 26 DRAM size (bytes / 64K) */ + ushort GpioTbiCtl;/* 27 GPIO/TBI controls for functions 1/0 */ + ushort EepromSize; /* 28 EEPROM Size */ +- slic_config_mac_t MacInfo[2]; /* 29 MAC addresses (2 ports) */ +- uchar FruFormat; /* 35 Alacritech FRU format type */ +- atk_fru_t AtkFru; /* Alacritech FRU information */ +- uchar OemFruFormat; /* optional OEM FRU format type */ +- oemfru_t OemFru; /* optional OEM FRU information */ +- uchar Pad[4]; /* Pad to 128 bytes - includes 2 checksum bytes ++ struct slic_config_mac MacInfo[2]; /* 29 MAC addresses (2 ports) */ ++ unsigned char FruFormat; /* 35 Alacritech FRU format type */ ++ struct atk_fru AtkFru; /* Alacritech FRU information */ ++ unsigned char OemFruFormat; /* optional OEM FRU format type */ ++ union oemfru_t OemFru; /* optional OEM FRU information */ ++ unsigned char Pad[4]; /* Pad to 128 bytes - includes 2 checksum bytes + * (if OEM FRU info exists) and two unusable + * bytes at the end + */ +-} oslic_eeprom_t, *poslic_eeprom_t; ++}; + +-#define MAX_EECODE_SIZE sizeof(slic_eeprom_t) ++#define MAX_EECODE_SIZE sizeof(struct slic_eeprom) + #define MIN_EECODE_SIZE 0x62 /* code size without optional OEM FRU stuff */ + + /* SLIC CONFIG structure +@@ -830,20 +825,20 @@ typedef struct _oslic_eeprom_t { + board types. It is filled in from the appropriate EEPROM structure + by SlicGetConfigData(). + */ +-typedef struct _slic_config_t { +- boolean EepromValid; /* Valid EEPROM flag (checksum good?) */ ++struct slic_config { ++ bool EepromValid; /* Valid EEPROM flag (checksum good?) */ + ushort DramSize; /* DRAM size (bytes / 64K) */ +- slic_config_mac_t MacInfo[SLIC_NBR_MACS]; /* MAC addresses */ +- uchar FruFormat; /* Alacritech FRU format type */ +- atk_fru_t AtkFru; /* Alacritech FRU information */ +- uchar OemFruFormat; /* optional OEM FRU format type */ +- union { +- vendor1_fru_t vendor1_fru; +- vendor2_fru_t vendor2_fru; +- vendor3_fru_t vendor3_fru; +- vendor4_fru_t vendor4_fru; +- } OemFru; +-} slic_config_t, *pslic_config_t; ++ struct slic_config_mac MacInfo[SLIC_NBR_MACS]; /* MAC addresses */ ++ unsigned char FruFormat; /* Alacritech FRU format type */ ++ struct atk_fru AtkFru; /* Alacritech FRU information */ ++ unsigned char OemFruFormat; /* optional OEM FRU format type */ ++ union { ++ struct vendor1_fru vendor1_fru; ++ struct vendor2_fru vendor2_fru; ++ struct vendor3_fru vendor3_fru; ++ struct vendor4_fru vendor4_fru; ++ } OemFru; ++}; + + #pragma pack() + +diff --git a/drivers/staging/slicoss/slicinc.h b/drivers/staging/slicoss/slicinc.h +index 9910306..610c1ab 100644 +--- a/drivers/staging/slicoss/slicinc.h ++++ b/drivers/staging/slicoss/slicinc.h +@@ -2,7 +2,6 @@ + * + * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved. + * +- * $Id: slicinc.h,v 1.4 2006/07/14 16:42:56 mook Exp $ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions +@@ -48,164 +47,135 @@ + #include "slichw.h" + #include "slic.h" + +-int slic_entry_probe(struct pci_dev *pcidev, ++static int slic_entry_probe(struct pci_dev *pcidev, + const struct pci_device_id *ent); +-int slic_init(struct pci_dev *pcidev, +- const struct pci_device_id *pci_tbl_entry, +- long memaddr, +- int chip_idx, +- int acpi_idle_state); +-void slic_entry_remove(struct pci_dev *pcidev); ++static void slic_entry_remove(struct pci_dev *pcidev); + +-void slic_init_driver(void); +-int slic_entry_open(struct net_device *dev); +-int slic_entry_halt(struct net_device *dev); +-int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); +-int slic_xmit_start(struct sk_buff *skb, struct net_device *dev); +-void slic_xmit_fail(p_adapter_t adapter, ++static void slic_init_driver(void); ++static int slic_entry_open(struct net_device *dev); ++static int slic_entry_halt(struct net_device *dev); ++static int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); ++static int slic_xmit_start(struct sk_buff *skb, struct net_device *dev); ++static void slic_xmit_fail(struct adapter *adapter, + struct sk_buff *skb, +- pvoid cmd, +- ulong32 skbtype, +- ulong32 status); +-void slic_xmit_timeout(struct net_device *dev); +-void slic_config_pci(struct pci_dev *pcidev); +-struct sk_buff *slic_rcvqueue_getnext(p_adapter_t adapter); ++ void *cmd, ++ u32 skbtype, ++ u32 status); ++static void slic_xmit_timeout(struct net_device *dev); ++static void slic_config_pci(struct pci_dev *pcidev); ++static struct sk_buff *slic_rcvqueue_getnext(struct adapter *adapter); + +-inline void slic_reg32_write(void __iomem *reg, ulong32 value, uint flush); +-inline void slic_reg64_write(p_adapter_t adapter, void __iomem *reg, +- ulong32 value, void __iomem *regh, ulong32 paddrh, uint flush); +-inline ulong32 slic_reg32_read(pulong32 reg, uint flush); +-inline ulong32 slic_reg16_read(pulong32 reg, uint flush); ++static inline void slic_reg32_write(void __iomem *reg, u32 value, uint flush); ++static inline void slic_reg64_write(struct adapter *adapter, void __iomem *reg, ++ u32 value, void __iomem *regh, u32 paddrh, uint flush); + + #if SLIC_GET_STATS_ENABLED +-struct net_device_stats *slic_get_stats(struct net_device *dev); ++static struct net_device_stats *slic_get_stats(struct net_device *dev); + #endif + +-int slic_mac_set_address(struct net_device *dev, pvoid ptr); ++static int slic_mac_set_address(struct net_device *dev, void *ptr); ++static void slic_rcv_handler(struct adapter *adapter); ++static void slic_link_event_handler(struct adapter *adapter); ++static void slic_xmit_complete(struct adapter *adapter); ++static void slic_upr_request_complete(struct adapter *adapter, u32 isr); ++static int slic_rspqueue_init(struct adapter *adapter); ++static int slic_rspqueue_reset(struct adapter *adapter); ++static void slic_rspqueue_free(struct adapter *adapter); ++static struct slic_rspbuf *slic_rspqueue_getnext(struct adapter *adapter); ++static void slic_cmdqmem_init(struct adapter *adapter); ++static void slic_cmdqmem_free(struct adapter *adapter); ++static u32 *slic_cmdqmem_addpage(struct adapter *adapter); ++static int slic_cmdq_init(struct adapter *adapter); ++static void slic_cmdq_free(struct adapter *adapter); ++static void slic_cmdq_reset(struct adapter *adapter); ++static void slic_cmdq_addcmdpage(struct adapter *adapter, u32 *page); ++static void slic_cmdq_getdone(struct adapter *adapter); ++static void slic_cmdq_putdone(struct adapter *adapter, ++ struct slic_hostcmd *cmd); ++static void slic_cmdq_putdone_irq(struct adapter *adapter, ++ struct slic_hostcmd *cmd); ++static struct slic_hostcmd *slic_cmdq_getfree(struct adapter *adapter); ++static int slic_rcvqueue_init(struct adapter *adapter); ++static int slic_rcvqueue_reset(struct adapter *adapter); ++static int slic_rcvqueue_fill(struct adapter *adapter); ++static u32 slic_rcvqueue_reinsert(struct adapter *adapter, struct sk_buff *skb); ++static void slic_rcvqueue_free(struct adapter *adapter); ++static void slic_rcv_handle_error(struct adapter *adapter, ++ struct slic_rcvbuf *rcvbuf); ++static void slic_adapter_set_hwaddr(struct adapter *adapter); ++static void slic_card_halt(struct sliccard *card, struct adapter *adapter); ++static int slic_card_init(struct sliccard *card, struct adapter *adapter); ++static void slic_intagg_set(struct adapter *adapter, u32 value); ++static int slic_card_download(struct adapter *adapter); ++static u32 slic_card_locate(struct adapter *adapter); + +-int slicproc_card_read(char *page, char **start, off_t off, int count, +- int *eof, void *data); +-int slicproc_card_write(struct file *file, const char __user *buffer, +- ulong count, void *data); +-void slicproc_card_create(p_sliccard_t card); +-void slicproc_card_destroy(p_sliccard_t card); +-int slicproc_adapter_read(char *page, char **start, off_t off, int count, +- int *eof, void *data); +-int slicproc_adapter_write(struct file *file, const char __user *buffer, +- ulong count, void *data); +-void slicproc_adapter_create(p_adapter_t adapter); +-void slicproc_adapter_destroy(p_adapter_t adapter); +-void slicproc_create(void); +-void slicproc_destroy(void); +- +-void slic_interrupt_process(p_adapter_t adapter, ulong32 isr); +-void slic_rcv_handler(p_adapter_t adapter); +-void slic_upr_handler(p_adapter_t adapter); +-void slic_link_event_handler(p_adapter_t adapter); +-void slic_xmit_complete(p_adapter_t adapter); +-void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr); +-int slic_rspqueue_init(p_adapter_t adapter); +-int slic_rspqueue_reset(p_adapter_t adapter); +-void slic_rspqueue_free(p_adapter_t adapter); +-p_slic_rspbuf_t slic_rspqueue_getnext(p_adapter_t adapter); +-void slic_cmdqmem_init(p_adapter_t adapter); +-void slic_cmdqmem_free(p_adapter_t adapter); +-pulong32 slic_cmdqmem_addpage(p_adapter_t adapter); +-int slic_cmdq_init(p_adapter_t adapter); +-void slic_cmdq_free(p_adapter_t adapter); +-void slic_cmdq_reset(p_adapter_t adapter); +-void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page); +-void slic_cmdq_getdone(p_adapter_t adapter); +-void slic_cmdq_putdone(p_adapter_t adapter, p_slic_hostcmd_t cmd); +-void slic_cmdq_putdone_irq(p_adapter_t adapter, p_slic_hostcmd_t cmd); +-p_slic_hostcmd_t slic_cmdq_getfree(p_adapter_t adapter); +-int slic_rcvqueue_init(p_adapter_t adapter); +-int slic_rcvqueue_reset(p_adapter_t adapter); +-int slic_rcvqueue_fill(p_adapter_t adapter); +-ulong32 slic_rcvqueue_reinsert(p_adapter_t adapter, struct sk_buff *skb); +-void slic_rcvqueue_free(p_adapter_t adapter); +-void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf); +-void slic_adapter_set_hwaddr(p_adapter_t adapter); +-void slic_card_halt(p_sliccard_t card, p_adapter_t adapter); +-int slic_card_init(p_sliccard_t card, p_adapter_t adapter); +-void slic_intagg_set(p_adapter_t adapter, ulong32 value); +-int slic_card_download(p_adapter_t adapter); +-ulong32 slic_card_locate(p_adapter_t adapter); +-int slic_card_removeadapter(p_adapter_t adapter); +-void slic_card_remaster(p_adapter_t adapter); +-void slic_card_softreset(p_adapter_t adapter); +-void slic_card_up(p_adapter_t adapter); +-void slic_card_down(p_adapter_t adapter); +- +-void slic_if_stop_queue(p_adapter_t adapter); +-void slic_if_start_queue(p_adapter_t adapter); +-int slic_if_init(p_adapter_t adapter); +-void slic_adapter_close(p_adapter_t adapter); +-int slic_adapter_allocresources(p_adapter_t adapter); +-void slic_adapter_freeresources(p_adapter_t adapter); +-void slic_link_config(p_adapter_t adapter, ulong32 linkspeed, +- ulong32 linkduplex); +-void slic_unmap_mmio_space(p_adapter_t adapter); +-void slic_card_cleanup(p_sliccard_t card); +-void slic_init_cleanup(p_adapter_t adapter); +-void slic_card_reclaim_buffers(p_adapter_t adapter); +-void slic_soft_reset(p_adapter_t adapter); +-void slic_card_reset(p_adapter_t adapter); +-boolean slic_mac_filter(p_adapter_t adapter, p_ether_header ether_frame); +-void slic_mac_address_config(p_adapter_t adapter); +-void slic_mac_config(p_adapter_t adapter); +-void slic_mcast_set_mask(p_adapter_t adapter); +-void slic_mac_setmcastaddrs(p_adapter_t adapter); +-int slic_mcast_add_list(p_adapter_t adapter, pchar address); +-uchar slic_mcast_get_mac_hash(pchar macaddr); +-void slic_mcast_set_bit(p_adapter_t adapter, pchar address); +-void slic_config_set(p_adapter_t adapter, boolean linkchange); +-void slic_config_clear(p_adapter_t adapter); +-void slic_config_get(p_adapter_t adapter, ulong32 config, ulong32 configh); +-void slic_timer_get_stats(ulong device); +-void slic_timer_load_check(ulong context); +-void slic_timer_ping(ulong dev); +-void slic_stall_msec(int stall); +-void slic_stall_usec(int stall); +-void slic_assert_fail(void); +-ushort slic_eeprom_cksum(pchar m, int len); ++static void slic_if_stop_queue(struct adapter *adapter); ++static void slic_if_start_queue(struct adapter *adapter); ++static int slic_if_init(struct adapter *adapter); ++static int slic_adapter_allocresources(struct adapter *adapter); ++static void slic_adapter_freeresources(struct adapter *adapter); ++static void slic_link_config(struct adapter *adapter, u32 linkspeed, ++ u32 linkduplex); ++static void slic_unmap_mmio_space(struct adapter *adapter); ++static void slic_card_cleanup(struct sliccard *card); ++static void slic_init_cleanup(struct adapter *adapter); ++static void slic_soft_reset(struct adapter *adapter); ++static void slic_card_reset(struct adapter *adapter); ++static bool slic_mac_filter(struct adapter *adapter, ++ struct ether_header *ether_frame); ++static void slic_mac_address_config(struct adapter *adapter); ++static void slic_mac_config(struct adapter *adapter); ++static void slic_mcast_set_mask(struct adapter *adapter); ++static int slic_mcast_add_list(struct adapter *adapter, char *address); ++static unsigned char slic_mcast_get_mac_hash(char *macaddr); ++static void slic_mcast_set_bit(struct adapter *adapter, char *address); ++static void slic_config_set(struct adapter *adapter, bool linkchange); ++static void slic_config_clear(struct adapter *adapter); ++static void slic_config_get(struct adapter *adapter, u32 config, ++ u32 configh); ++static void slic_timer_get_stats(ulong device); ++static void slic_timer_load_check(ulong context); ++static void slic_timer_ping(ulong dev); ++static void slic_assert_fail(void); ++static ushort slic_eeprom_cksum(char *m, int len); + /* upr */ +-void slic_upr_start(p_adapter_t adapter); +-void slic_link_upr_complete(p_adapter_t adapter, ulong32 Isr); +-int slic_upr_request(p_adapter_t adapter, +- ulong32 upr_request, +- ulong32 upr_data, +- ulong32 upr_data_h, +- ulong32 upr_buffer, +- ulong32 upr_buffer_h); +-int slic_upr_queue_request(p_adapter_t adapter, +- ulong32 upr_request, +- ulong32 upr_data, +- ulong32 upr_data_h, +- ulong32 upr_buffer, +- ulong32 upr_buffer_h); +-void slic_mcast_set_list(struct net_device *dev); +-void slic_mcast_init_crc32(void); ++static void slic_upr_start(struct adapter *adapter); ++static void slic_link_upr_complete(struct adapter *adapter, u32 Isr); ++static int slic_upr_request(struct adapter *adapter, ++ u32 upr_request, ++ u32 upr_data, ++ u32 upr_data_h, ++ u32 upr_buffer, ++ u32 upr_buffer_h); ++static int slic_upr_queue_request(struct adapter *adapter, ++ u32 upr_request, ++ u32 upr_data, ++ u32 upr_data_h, ++ u32 upr_buffer, ++ u32 upr_buffer_h); ++static void slic_mcast_set_list(struct net_device *dev); ++static void slic_mcast_init_crc32(void); + + #if SLIC_DUMP_ENABLED +-int slic_dump_thread(void *context); +-uint slic_init_dump_thread(p_sliccard_t card); +-uchar slic_get_dump_index(pchar path); +-ulong32 slic_dump_card(p_sliccard_t card, boolean resume); +-ulong32 slic_dump_halt(p_sliccard_t card, uchar proc); +-ulong32 slic_dump_reg(p_sliccard_t card, uchar proc); +-ulong32 slic_dump_data(p_sliccard_t card, ulong32 addr, +- ushort count, uchar desc); +-ulong32 slic_dump_queue(p_sliccard_t card, ulong32 buf_phys, +- ulong32 buf_physh, ulong32 queue); +-ulong32 slic_dump_load_queue(p_sliccard_t card, ulong32 data, ulong32 queue); +-ulong32 slic_dump_cam(p_sliccard_t card, ulong32 addr, +- ulong32 count, uchar desc); ++static int slic_dump_thread(void *context); ++static uint slic_init_dump_thread(struct sliccard *card); ++static unsigned char slic_get_dump_index(char *path); ++static u32 slic_dump_card(struct sliccard *card, bool resume); ++static u32 slic_dump_halt(struct sliccard *card, unsigned char proc); ++static u32 slic_dump_reg(struct sliccard *card, unsigned char proc); ++static u32 slic_dump_data(struct sliccard *card, u32 addr, ++ ushort count, unsigned char desc); ++static u32 slic_dump_queue(struct sliccard *card, u32 buf_phys, ++ u32 buf_physh, u32 queue); ++static u32 slic_dump_load_queue(struct sliccard *card, u32 data, ++ u32 queue); ++static u32 slic_dump_cam(struct sliccard *card, u32 addr, ++ u32 count, unsigned char desc); + +-ulong32 slic_dump_resume(p_sliccard_t card, uchar proc); +-ulong32 slic_dump_send_cmd(p_sliccard_t card, ulong32 cmd_phys, +- ulong32 cmd_physh, ulong32 buf_phys, +- ulong32 buf_physh); ++static u32 slic_dump_resume(struct sliccard *card, unsigned char proc); ++static u32 slic_dump_send_cmd(struct sliccard *card, u32 cmd_phys, ++ u32 cmd_physh, u32 buf_phys, ++ u32 buf_physh); + + #define create_file(x) STATUS_SUCCESS + #define write_file(w, x, y, z) STATUS_SUCCESS +diff --git a/drivers/staging/slicoss/slicoss.c b/drivers/staging/slicoss/slicoss.c +index a8c2648..eb61565 100644 +--- a/drivers/staging/slicoss/slicoss.c ++++ b/drivers/staging/slicoss/slicoss.c +@@ -143,7 +143,7 @@ static int slic_debug = 1; + static int debug = -1; + static struct net_device *head_netdevice; + +-base_driver_t slic_global = { {}, 0, 0, 0, 1, NULL, NULL }; ++static struct base_driver slic_global = { {}, 0, 0, 0, 1, NULL, NULL }; + static int intagg_delay = 100; + static u32 dynamic_intagg; + static int errormsg; +@@ -183,44 +183,49 @@ MODULE_DEVICE_TABLE(pci, slic_pci_tbl); + + #define SLIC_GET_SLIC_HANDLE(_adapter, _pslic_handle) \ + { \ +- SLIC_ACQUIRE_IRQ_SPINLOCK(_adapter->handle_lock); \ ++ spin_lock_irqsave(&_adapter->handle_lock.lock, \ ++ _adapter->handle_lock.flags); \ + _pslic_handle = _adapter->pfree_slic_handles; \ + if (_pslic_handle) { \ + ASSERT(_pslic_handle->type == SLIC_HANDLE_FREE); \ + _adapter->pfree_slic_handles = _pslic_handle->next; \ + } \ +- SLIC_RELEASE_IRQ_SPINLOCK(_adapter->handle_lock); \ ++ spin_unlock_irqrestore(&_adapter->handle_lock.lock, \ ++ _adapter->handle_lock.flags); \ + } + + #define SLIC_FREE_SLIC_HANDLE(_adapter, _pslic_handle) \ + { \ + _pslic_handle->type = SLIC_HANDLE_FREE; \ +- SLIC_ACQUIRE_IRQ_SPINLOCK(_adapter->handle_lock); \ ++ spin_lock_irqsave(&_adapter->handle_lock.lock, \ ++ _adapter->handle_lock.flags); \ + _pslic_handle->next = _adapter->pfree_slic_handles; \ + _adapter->pfree_slic_handles = _pslic_handle; \ +- SLIC_RELEASE_IRQ_SPINLOCK(_adapter->handle_lock); \ ++ spin_unlock_irqrestore(&_adapter->handle_lock.lock, \ ++ _adapter->handle_lock.flags); \ + } + + static void slic_debug_init(void); + static void slic_debug_cleanup(void); +-static void slic_debug_adapter_create(p_adapter_t adapter); +-static void slic_debug_adapter_destroy(p_adapter_t adapter); +-static void slic_debug_card_create(p_sliccard_t card); +-static void slic_debug_card_destroy(p_sliccard_t card); ++static void slic_debug_adapter_create(struct adapter *adapter); ++static void slic_debug_adapter_destroy(struct adapter *adapter); ++static void slic_debug_card_create(struct sliccard *card); ++static void slic_debug_card_destroy(struct sliccard *card); + +-inline void slic_reg32_write(void __iomem *reg, ulong32 value, uint flush) ++static inline void slic_reg32_write(void __iomem *reg, u32 value, uint flush) + { + writel(value, reg); + if (flush) + mb(); + } + +-inline void slic_reg64_write(p_adapter_t adapter, ++static inline void slic_reg64_write(struct adapter *adapter, + void __iomem *reg, +- ulong32 value, +- void __iomem *regh, ulong32 paddrh, uint flush) ++ u32 value, ++ void __iomem *regh, u32 paddrh, uint flush) + { +- SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->bit64reglock); ++ spin_lock_irqsave(&adapter->bit64reglock.lock, ++ adapter->bit64reglock.flags); + if (paddrh != adapter->curaddrupper) { + adapter->curaddrupper = paddrh; + writel(paddrh, regh); +@@ -228,31 +233,22 @@ inline void slic_reg64_write(p_adapter_t adapter, + writel(value, reg); + if (flush) + mb(); +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->bit64reglock); ++ spin_unlock_irqrestore(&adapter->bit64reglock.lock, ++ adapter->bit64reglock.flags); + } + +-inline ulong32 slic_reg32_read(u32 __iomem *reg, uint flush) +-{ +- return readl(reg); +-} +- +-inline ulong32 slic_reg16_read(pulong32 reg, uint flush) +-{ +- return (ushort) readw(reg); +-} +- +-void slic_init_driver(void) ++static void slic_init_driver(void) + { + if (slic_first_init) { + DBG_MSG("slicoss: %s slic_first_init set jiffies[%lx]\n", + __func__, jiffies); + slic_first_init = 0; +- SLIC_INIT_SPINLOCK(slic_global.driver_lock); ++ spin_lock_init(&slic_global.driver_lock.lock); + slic_debug_init(); + } + } + +-static void slic_dbg_macaddrs(p_adapter_t adapter) ++static void slic_dbg_macaddrs(struct adapter *adapter) + { + DBG_MSG(" (%s) curr %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", + adapter->netdev->name, adapter->currmacaddr[0], +@@ -267,7 +263,8 @@ static void slic_dbg_macaddrs(p_adapter_t adapter) + } + + #ifdef DEBUG_REGISTER_TRACE +-static void slic_dbg_register_trace(p_adapter_t adapter, p_sliccard_t card) ++static void slic_dbg_register_trace(struct adapter *adapter, ++ struct sliccard *card) + { + uint i; + +@@ -287,9 +284,8 @@ static void slic_init_adapter(struct net_device *netdev, + void __iomem *memaddr, int chip_idx) + { + ushort index; +- pslic_handle_t pslic_handle; +- p_adapter_t adapter = (p_adapter_t) netdev_priv(netdev); +- ++ struct slic_handle *pslic_handle; ++ struct adapter *adapter = (struct adapter *)netdev_priv(netdev); + /* + DBG_MSG("slicoss: %s (%s)\n netdev [%p]\n adapter[%p]\n " + "pcidev [%p]\n", __func__, netdev->name, netdev, adapter, pcidev);*/ +@@ -301,7 +297,7 @@ static void slic_init_adapter(struct net_device *netdev, + adapter->slotnumber = ((pcidev->devfn >> 3) & 0x1F); + adapter->functionnumber = (pcidev->devfn & 0x7); + adapter->memorylength = pci_resource_len(pcidev, 0); +- adapter->slic_regs = (p_slic_regs_t) memaddr; ++ adapter->slic_regs = (__iomem struct slic_regs *)memaddr; + adapter->irq = pcidev->irq; + /* adapter->netdev = netdev;*/ + adapter->next_netdevice = head_netdevice; +@@ -310,11 +306,11 @@ static void slic_init_adapter(struct net_device *netdev, + adapter->port = 0; /*adapter->functionnumber;*/ + adapter->cardindex = adapter->port; + adapter->memorybase = memaddr; +- SLIC_INIT_SPINLOCK(adapter->upr_lock); +- SLIC_INIT_SPINLOCK(adapter->bit64reglock); +- SLIC_INIT_SPINLOCK(adapter->adapter_lock); +- SLIC_INIT_SPINLOCK(adapter->reset_lock); +- SLIC_INIT_SPINLOCK(adapter->handle_lock); ++ spin_lock_init(&adapter->upr_lock.lock); ++ spin_lock_init(&adapter->bit64reglock.lock); ++ spin_lock_init(&adapter->adapter_lock.lock); ++ spin_lock_init(&adapter->reset_lock.lock); ++ spin_lock_init(&adapter->handle_lock.lock); + + adapter->card_size = 1; + /* +@@ -335,36 +331,36 @@ static void slic_init_adapter(struct net_device *netdev, + /* + DBG_MSG(".........\nix[%d] phandle[%p] pfree[%p] next[%p]\n", + index, pslic_handle, adapter->pfree_slic_handles, pslic_handle->next);*/ +- adapter->pshmem = (p_slic_shmem_t) pci_alloc_consistent(adapter->pcidev, +- sizeof +- (slic_shmem_t), +- &adapter-> +- phys_shmem); ++ adapter->pshmem = (struct slic_shmem *) ++ pci_alloc_consistent(adapter->pcidev, ++ sizeof(struct slic_shmem *), ++ &adapter-> ++ phys_shmem); + /* + DBG_MSG("slicoss: %s (%s)\n pshmem [%p]\n phys_shmem[%p]\n"\ + "slic_regs [%p]\n", __func__, netdev->name, adapter->pshmem, +- (pvoid)adapter->phys_shmem, adapter->slic_regs); ++ (void *)adapter->phys_shmem, adapter->slic_regs); + */ + ASSERT(adapter->pshmem); + +- SLIC_ZERO_MEMORY(adapter->pshmem, sizeof(slic_shmem_t)); ++ memset(adapter->pshmem, 0, sizeof(struct slic_shmem)); + + return; + } + +-int __devinit slic_entry_probe(struct pci_dev *pcidev, ++static int __devinit slic_entry_probe(struct pci_dev *pcidev, + const struct pci_device_id *pci_tbl_entry) + { + static int cards_found; + static int did_version; + int err; + struct net_device *netdev; +- p_adapter_t adapter; ++ struct adapter *adapter; + void __iomem *memmapped_ioaddr = NULL; +- ulong32 status = 0; ++ u32 status = 0; + ulong mmio_start = 0; + ulong mmio_len = 0; +- p_sliccard_t card = NULL; ++ struct sliccard *card = NULL; + + DBG_MSG("slicoss: %s 2.6 VERSION ENTER jiffies[%lx] cpu %d\n", + __func__, jiffies, smp_processor_id()); +@@ -408,7 +404,7 @@ int __devinit slic_entry_probe(struct pci_dev *pcidev, + pci_set_master(pcidev); + + DBG_MSG("call alloc_etherdev\n"); +- netdev = alloc_etherdev(sizeof(adapter_t)); ++ netdev = alloc_etherdev(sizeof(struct adapter)); + if (!netdev) { + err = -ENOMEM; + goto err_out_exit_slic_probe; +@@ -428,7 +424,7 @@ int __devinit slic_entry_probe(struct pci_dev *pcidev, + DBG_MSG("slicoss: call ioremap(mmio_start[%lx], mmio_len[%lx])\n", + mmio_start, mmio_len); + +-/* memmapped_ioaddr = (ulong32)ioremap_nocache(mmio_start, mmio_len);*/ ++/* memmapped_ioaddr = (u32)ioremap_nocache(mmio_start, mmio_len);*/ + memmapped_ioaddr = ioremap(mmio_start, mmio_len); + DBG_MSG("slicoss: %s MEMMAPPED_IOADDR [%p]\n", __func__, + memmapped_ioaddr); +@@ -530,11 +526,11 @@ err_out_exit_slic_probe: + return -ENODEV; + } + +-int slic_entry_open(struct net_device *dev) ++static int slic_entry_open(struct net_device *dev) + { +- p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); +- p_sliccard_t card = adapter->card; +- ulong32 locked = 0; ++ struct adapter *adapter = (struct adapter *) netdev_priv(dev); ++ struct sliccard *card = adapter->card; ++ u32 locked = 0; + int status; + + ASSERT(adapter); +@@ -552,7 +548,8 @@ int slic_entry_open(struct net_device *dev) + + netif_stop_queue(adapter->netdev); + +- SLIC_ACQUIRE_IRQ_SPINLOCK(slic_global.driver_lock); ++ spin_lock_irqsave(&slic_global.driver_lock.lock, ++ slic_global.driver_lock.flags); + locked = 1; + if (!adapter->activated) { + card->adapters_activated++; +@@ -568,7 +565,8 @@ int slic_entry_open(struct net_device *dev) + adapter->activated = 0; + } + if (locked) { +- SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock); ++ spin_unlock_irqrestore(&slic_global.driver_lock.lock, ++ slic_global.driver_lock.flags); + locked = 0; + } + return status; +@@ -583,7 +581,8 @@ int slic_entry_open(struct net_device *dev) + #endif + + if (locked) { +- SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock); ++ spin_unlock_irqrestore(&slic_global.driver_lock.lock, ++ slic_global.driver_lock.flags); + locked = 0; + } + #if SLIC_DUMP_ENABLED +@@ -599,13 +598,13 @@ int slic_entry_open(struct net_device *dev) + return STATUS_SUCCESS; + } + +-void __devexit slic_entry_remove(struct pci_dev *pcidev) ++static void __devexit slic_entry_remove(struct pci_dev *pcidev) + { + struct net_device *dev = pci_get_drvdata(pcidev); +- ulong32 mmio_start = 0; ++ u32 mmio_start = 0; + uint mmio_len = 0; +- p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); +- p_sliccard_t card; ++ struct adapter *adapter = (struct adapter *) netdev_priv(dev); ++ struct sliccard *card; + + ASSERT(adapter); + DBG_MSG("slicoss: %s ENTER dev[%p] adapter[%p]\n", __func__, dev, +@@ -635,7 +634,7 @@ void __devexit slic_entry_remove(struct pci_dev *pcidev) + __func__, card->adapters_activated, card->adapters_allocated, + card, adapter); + if (!card->adapters_allocated) { +- p_sliccard_t curr_card = slic_global.slic_card; ++ struct sliccard *curr_card = slic_global.slic_card; + if (curr_card == card) { + slic_global.slic_card = card->next; + } else { +@@ -649,17 +648,18 @@ void __devexit slic_entry_remove(struct pci_dev *pcidev) + slic_card_cleanup(card); + } + DBG_MSG("slicoss: %s deallocate device\n", __func__); +- SLIC_DEALLOCATE_MEM(dev); ++ kfree(dev); + DBG_MSG("slicoss: %s EXIT\n", __func__); + } + +-int slic_entry_halt(struct net_device *dev) ++static int slic_entry_halt(struct net_device *dev) + { +- p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); +- p_sliccard_t card = adapter->card; +- p_slic_regs_t slic_regs = adapter->slic_regs; ++ struct adapter *adapter = (struct adapter *)netdev_priv(dev); ++ struct sliccard *card = adapter->card; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; + +- SLIC_ACQUIRE_IRQ_SPINLOCK(slic_global.driver_lock); ++ spin_lock_irqsave(&slic_global.driver_lock.lock, ++ slic_global.driver_lock.flags); + ASSERT(card); + DBG_MSG("slicoss: %s (%s) ENTER\n", __func__, dev->name); + DBG_MSG("slicoss: %s (%s) actvtd[%d] alloc[%d] state[%x] adapt[%p]\n", +@@ -730,11 +730,12 @@ int slic_entry_halt(struct net_device *dev) + + DBG_MSG("slicoss: %s (%s) EXIT\n", __func__, dev->name); + DBG_MSG("slicoss: %s EXIT\n", __func__); +- SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock); ++ spin_unlock_irqrestore(&slic_global.driver_lock.lock, ++ slic_global.driver_lock.flags); + return STATUS_SUCCESS; + } + +-int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) ++static int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) + { + ASSERT(rq); + /* +@@ -743,9 +744,10 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) + switch (cmd) { + case SIOCSLICSETINTAGG: + { +- p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); +- ulong32 data[7]; +- ulong32 intagg; ++ struct adapter *adapter = (struct adapter *) ++ netdev_priv(dev); ++ u32 data[7]; ++ u32 intagg; + + if (copy_from_user(data, rq->ifr_data, 28)) { + DBG_ERROR +@@ -763,8 +765,9 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) + #ifdef SLIC_USER_REQUEST_DUMP_ENABLED + case SIOCSLICDUMPCARD: + { +- p_adapter_t adapter = (p_adapter_t) dev->priv; +- p_sliccard_t card; ++ struct adapter *adapter = (struct adapter *) ++ dev->priv; ++ struct sliccard *card; + + ASSERT(adapter); + ASSERT(adapter->card) +@@ -833,7 +836,8 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) + #if SLIC_ETHTOOL_SUPPORT + case SIOCETHTOOL: + { +- p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); ++ struct adapter *adapter = (struct adapter *) ++ netdev_priv(dev); + struct ethtool_cmd data; + struct ethtool_cmd ecmd; + +@@ -892,8 +896,8 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) + data.maxrxpkt = 1; + if ((ecmd.speed != data.speed) || + (ecmd.duplex != data.duplex)) { +- ulong32 speed; +- ulong32 duplex; ++ u32 speed; ++ u32 duplex; + + if (ecmd.speed == SPEED_10) { + speed = 0; +@@ -935,10 +939,10 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) + #define XMIT_FAIL_ZERO_LENGTH 2 + #define XMIT_FAIL_HOSTCMD_FAIL 3 + +-static void slic_xmit_build_request(p_adapter_t adapter, +- p_slic_hostcmd_t hcmd, struct sk_buff *skb) ++static void slic_xmit_build_request(struct adapter *adapter, ++ struct slic_hostcmd *hcmd, struct sk_buff *skb) + { +- p_slic_host64_cmd_t ihcmd; ++ struct slic_host64_cmd *ihcmd; + ulong phys_addr; + + ihcmd = &hcmd->cmd64; +@@ -946,16 +950,17 @@ static void slic_xmit_build_request(p_adapter_t adapter, + ihcmd->flags = (adapter->port << IHFLG_IFSHFT); + ihcmd->command = IHCMD_XMT_REQ; + ihcmd->u.slic_buffers.totlen = skb->len; +- phys_addr = SLIC_GET_DMA_ADDRESS_WRITE(adapter, skb->data, skb->len); ++ phys_addr = pci_map_single(adapter->pcidev, skb->data, skb->len, ++ PCI_DMA_TODEVICE); + ihcmd->u.slic_buffers.bufs[0].paddrl = SLIC_GET_ADDR_LOW(phys_addr); + ihcmd->u.slic_buffers.bufs[0].paddrh = SLIC_GET_ADDR_HIGH(phys_addr); + ihcmd->u.slic_buffers.bufs[0].length = skb->len; + #if defined(CONFIG_X86_64) +- hcmd->cmdsize = (ulong32) ((((ulong64)&ihcmd->u.slic_buffers.bufs[1] - +- (ulong64) hcmd) + 31) >> 5); ++ hcmd->cmdsize = (u32) ((((u64)&ihcmd->u.slic_buffers.bufs[1] - ++ (u64) hcmd) + 31) >> 5); + #elif defined(CONFIG_X86) +- hcmd->cmdsize = ((((ulong32) &ihcmd->u.slic_buffers.bufs[1] - +- (ulong32) hcmd) + 31) >> 5); ++ hcmd->cmdsize = ((((u32) &ihcmd->u.slic_buffers.bufs[1] - ++ (u32) hcmd) + 31) >> 5); + #else + Stop Compilation; + #endif +@@ -963,14 +968,14 @@ static void slic_xmit_build_request(p_adapter_t adapter, + + #define NORMAL_ETHFRAME 0 + +-int slic_xmit_start(struct sk_buff *skb, struct net_device *dev) ++static int slic_xmit_start(struct sk_buff *skb, struct net_device *dev) + { +- p_sliccard_t card; +- p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); +- p_slic_hostcmd_t hcmd = NULL; +- ulong32 status = 0; +- ulong32 skbtype = NORMAL_ETHFRAME; +- pvoid offloadcmd = NULL; ++ struct sliccard *card; ++ struct adapter *adapter = (struct adapter *)netdev_priv(dev); ++ struct slic_hostcmd *hcmd = NULL; ++ u32 status = 0; ++ u32 skbtype = NORMAL_ETHFRAME; ++ void *offloadcmd = NULL; + + card = adapter->card; + ASSERT(card); +@@ -1035,9 +1040,9 @@ xmit_fail: + goto xmit_done; + } + +-void slic_xmit_fail(p_adapter_t adapter, ++static void slic_xmit_fail(struct adapter *adapter, + struct sk_buff *skb, +- pvoid cmd, ulong32 skbtype, ulong32 status) ++ void *cmd, u32 skbtype, u32 status) + { + if (adapter->xmitq_full) + slic_if_stop_queue(adapter); +@@ -1072,31 +1077,10 @@ void slic_xmit_fail(p_adapter_t adapter, + adapter->stats.tx_dropped++; + } + +-void slic_xmit_timeout(struct net_device *dev) +-{ +- p_sliccard_t card; +- p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); +- ulong32 i; +- +- ASSERT(adapter); +- card = adapter->card; +- ASSERT(card); +- for (i = 0; i < card->card_size; i++) { +- if (card->adapter[i]) +- slic_if_stop_queue(card->adapter[i]); +- } +- if (!card->reset_in_progress) { +- DBG_ERROR +- ("%s card[%p] state[%x] adapter[%p] port[%d] state[%x]\n", +- __func__, card, card->state, adapter, adapter->port, +- adapter->state); +- slic_card_reset(adapter); +- } +-} +- +-void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf) ++static void slic_rcv_handle_error(struct adapter *adapter, ++ struct slic_rcvbuf *rcvbuf) + { +- p_slic_hddr_wds hdr = (p_slic_hddr_wds) rcvbuf->data; ++ struct slic_hddr_wds *hdr = (struct slic_hddr_wds *)rcvbuf->data; + + if (adapter->devid != SLIC_1GB_DEVICE_ID) { + if (hdr->frame_status14 & VRHSTAT_802OE) +@@ -1141,7 +1125,7 @@ void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf) + adapter->if_events.IpHlen++; + } else { + if (hdr->frame_statusGB & VGBSTAT_XPERR) { +- ulong32 xerr = hdr->frame_statusGB >> VGBSTAT_XERRSHFT; ++ u32 xerr = hdr->frame_statusGB >> VGBSTAT_XERRSHFT; + + if (xerr == VGBSTAT_XCSERR) + adapter->if_events.TpCsum++; +@@ -1151,7 +1135,7 @@ void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf) + adapter->if_events.TpHlen++; + } + if (hdr->frame_statusGB & VGBSTAT_NETERR) { +- ulong32 nerr = ++ u32 nerr = + (hdr-> + frame_statusGB >> VGBSTAT_NERRSHFT) & + VGBSTAT_NERRMSK; +@@ -1163,7 +1147,7 @@ void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf) + adapter->if_events.IpHlen++; + } + if (hdr->frame_statusGB & VGBSTAT_LNKERR) { +- ulong32 lerr = hdr->frame_statusGB & VGBSTAT_LERRMSK; ++ u32 lerr = hdr->frame_statusGB & VGBSTAT_LERRMSK; + + if (lerr == VGBSTAT_LDEARLY) + adapter->if_events.rcvearly++; +@@ -1187,17 +1171,17 @@ void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf) + #define TCP_OFFLOAD_FRAME_PUSHFLAG 0x10000000 + #define M_FAST_PATH 0x0040 + +-void slic_rcv_handler(p_adapter_t adapter) ++static void slic_rcv_handler(struct adapter *adapter) + { + struct sk_buff *skb; +- p_slic_rcvbuf_t rcvbuf; +- ulong32 frames = 0; ++ struct slic_rcvbuf *rcvbuf; ++ u32 frames = 0; + + while ((skb = slic_rcvqueue_getnext(adapter))) { +- ulong32 rx_bytes; ++ u32 rx_bytes; + + ASSERT(skb->head); +- rcvbuf = (p_slic_rcvbuf_t) skb->head; ++ rcvbuf = (struct slic_rcvbuf *)skb->head; + adapter->card->events++; + if (rcvbuf->status & IRHDDR_ERR) { + adapter->rx_errors++; +@@ -1206,7 +1190,8 @@ void slic_rcv_handler(p_adapter_t adapter) + continue; + } + +- if (!slic_mac_filter(adapter, (p_ether_header) rcvbuf->data)) { ++ if (!slic_mac_filter(adapter, (struct ether_header *) ++ rcvbuf->data)) { + #if 0 + DBG_MSG + ("slicoss: %s (%s) drop frame due to mac filter\n", +@@ -1239,12 +1224,12 @@ void slic_rcv_handler(p_adapter_t adapter) + adapter->max_isr_rcvs = max(adapter->max_isr_rcvs, frames); + } + +-void slic_xmit_complete(p_adapter_t adapter) ++static void slic_xmit_complete(struct adapter *adapter) + { +- p_slic_hostcmd_t hcmd; +- p_slic_rspbuf_t rspbuf; +- ulong32 frames = 0; +- slic_handle_word_t slic_handle_word; ++ struct slic_hostcmd *hcmd; ++ struct slic_rspbuf *rspbuf; ++ u32 frames = 0; ++ struct slic_handle_word slic_handle_word; + + do { + rspbuf = slic_rspqueue_getnext(adapter); +@@ -1259,10 +1244,10 @@ void slic_xmit_complete(p_adapter_t adapter) + ASSERT(slic_handle_word.handle_index); + ASSERT(slic_handle_word.handle_index <= SLIC_CMDQ_MAXCMDS); + hcmd = +- (p_slic_hostcmd_t) adapter->slic_handles[slic_handle_word. +- handle_index]. +- address; +-/* hcmd = (p_slic_hostcmd_t) rspbuf->hosthandle; */ ++ (struct slic_hostcmd *) ++ adapter->slic_handles[slic_handle_word.handle_index]. ++ address; ++/* hcmd = (struct slic_hostcmd *) rspbuf->hosthandle; */ + ASSERT(hcmd); + ASSERT(hcmd->pslic_handle == + &adapter->slic_handles[slic_handle_word.handle_index]); +@@ -1286,9 +1271,9 @@ void slic_xmit_complete(p_adapter_t adapter) + + static irqreturn_t slic_interrupt(int irq, void *dev_id) + { +- struct net_device *dev = (struct net_device *) dev_id; +- p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); +- ulong32 isr; ++ struct net_device *dev = (struct net_device *)dev_id; ++ struct adapter *adapter = (struct adapter *)netdev_priv(dev); ++ u32 isr; + + if ((adapter->pshmem) && (adapter->pshmem->isr)) { + WRITE_REG(adapter->slic_regs->slic_icr, ICR_INT_MASK, FLUSH); +@@ -1305,7 +1290,7 @@ static irqreturn_t slic_interrupt(int irq, void *dev_id) + int pre_count; + int errors; + +- p_slic_rcvqueue_t rcvq = ++ struct slic_rcvqueue *rcvq = + &adapter->rcvqueue; + + adapter-> +@@ -1400,17 +1385,17 @@ static irqreturn_t slic_interrupt(int irq, void *dev_id) + * will also complete asynchronously. + * + */ +-void slic_link_event_handler(p_adapter_t adapter) ++static void slic_link_event_handler(struct adapter *adapter) + { + int status; +- p_slic_shmem_t pshmem; ++ struct slic_shmem *pshmem; + + if (adapter->state != ADAPT_UP) { + /* Adapter is not operational. Ignore. */ + return; + } + +- pshmem = (p_slic_shmem_t) adapter->phys_shmem; ++ pshmem = (struct slic_shmem *)adapter->phys_shmem; + + #if defined(CONFIG_X86_64) + /* +@@ -1425,7 +1410,7 @@ void slic_link_event_handler(p_adapter_t adapter) + 0, 0); + #elif defined(CONFIG_X86) + status = slic_upr_request(adapter, SLIC_UPR_RLSR, +- (ulong32) &pshmem->linkstatus, /* no 4GB wrap guaranteed */ ++ (u32) &pshmem->linkstatus, /* no 4GB wrap guaranteed */ + 0, 0, 0); + #else + Stop compilation; +@@ -1433,7 +1418,7 @@ void slic_link_event_handler(p_adapter_t adapter) + ASSERT((status == STATUS_SUCCESS) || (status == STATUS_PENDING)); + } + +-void slic_init_cleanup(p_adapter_t adapter) ++static void slic_init_cleanup(struct adapter *adapter) + { + DBG_MSG("slicoss: %s ENTER adapter[%p] ", __func__, adapter); + if (adapter->intrregistered) { +@@ -1445,9 +1430,9 @@ void slic_init_cleanup(p_adapter_t adapter) + if (adapter->pshmem) { + DBG_MSG("FREE_SHMEM "); + DBG_MSG("adapter[%p] port %d pshmem[%p] FreeShmem ", +- adapter, adapter->port, (pvoid) adapter->pshmem); ++ adapter, adapter->port, (void *) adapter->pshmem); + pci_free_consistent(adapter->pcidev, +- sizeof(slic_shmem_t), ++ sizeof(struct slic_shmem *), + adapter->pshmem, adapter->phys_shmem); + adapter->pshmem = NULL; + adapter->phys_shmem = (dma_addr_t) NULL; +@@ -1475,9 +1460,9 @@ void slic_init_cleanup(p_adapter_t adapter) + } + + #if SLIC_GET_STATS_ENABLED +-struct net_device_stats *slic_get_stats(struct net_device *dev) ++static struct net_device_stats *slic_get_stats(struct net_device *dev) + { +- p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); ++ struct adapter *adapter = (struct adapter *)netdev_priv(dev); + struct net_device_stats *stats; + + ASSERT(adapter); +@@ -1500,10 +1485,10 @@ struct net_device_stats *slic_get_stats(struct net_device *dev) + * Allocate a mcast_address structure to hold the multicast address. + * Link it in. + */ +-int slic_mcast_add_list(p_adapter_t adapter, pchar address) ++static int slic_mcast_add_list(struct adapter *adapter, char *address) + { +- p_mcast_address_t mcaddr, mlist; +- boolean equaladdr; ++ struct mcast_address *mcaddr, *mlist; ++ bool equaladdr; + + /* Check to see if it already exists */ + mlist = adapter->mcastaddrs; +@@ -1515,7 +1500,7 @@ int slic_mcast_add_list(p_adapter_t adapter, pchar address) + } + + /* Doesn't already exist. Allocate a structure to hold it */ +- mcaddr = SLIC_ALLOCATE_MEM(sizeof(mcast_address_t), GFP_ATOMIC); ++ mcaddr = kmalloc(sizeof(struct mcast_address), GFP_ATOMIC); + if (mcaddr == NULL) + return 1; + +@@ -1545,10 +1530,10 @@ static u32 slic_crc_init; /* Is table initialized */ + /* + * Contruct the CRC32 table + */ +-void slic_mcast_init_crc32(void) ++static void slic_mcast_init_crc32(void) + { +- ulong32 c; /* CRC shit reg */ +- ulong32 e = 0; /* Poly X-or pattern */ ++ u32 c; /* CRC shit reg */ ++ u32 e = 0; /* Poly X-or pattern */ + int i; /* counter */ + int k; /* byte being shifted into crc */ + +@@ -1568,12 +1553,12 @@ void slic_mcast_init_crc32(void) + /* + * Return the MAC hast as described above. + */ +-uchar slic_mcast_get_mac_hash(pchar macaddr) ++static unsigned char slic_mcast_get_mac_hash(char *macaddr) + { +- ulong32 crc; +- pchar p; ++ u32 crc; ++ char *p; + int i; +- uchar machash = 0; ++ unsigned char machash = 0; + + if (!slic_crc_init) { + slic_mcast_init_crc32(); +@@ -1591,9 +1576,9 @@ uchar slic_mcast_get_mac_hash(pchar macaddr) + return machash; + } + +-void slic_mcast_set_bit(p_adapter_t adapter, pchar address) ++static void slic_mcast_set_bit(struct adapter *adapter, char *address) + { +- uchar crcpoly; ++ unsigned char crcpoly; + + /* Get the CRC polynomial for the mac address */ + crcpoly = slic_mcast_get_mac_hash(address); +@@ -1604,22 +1589,22 @@ void slic_mcast_set_bit(p_adapter_t adapter, pchar address) + crcpoly &= 0x3F; + + /* OR in the new bit into our 64 bit mask. */ +- adapter->mcastmask |= (ulong64) 1 << crcpoly; ++ adapter->mcastmask |= (u64) 1 << crcpoly; + } + +-void slic_mcast_set_list(struct net_device *dev) ++static void slic_mcast_set_list(struct net_device *dev) + { +- p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); ++ struct adapter *adapter = (struct adapter *)netdev_priv(dev); + int status = STATUS_SUCCESS; + int i; +- pchar addresses; ++ char *addresses; + struct dev_mc_list *mc_list = dev->mc_list; + int mc_count = dev->mc_count; + + ASSERT(adapter); + + for (i = 1; i <= mc_count; i++) { +- addresses = (pchar) &mc_list->dmi_addr; ++ addresses = (char *) &mc_list->dmi_addr; + if (mc_list->dmi_addrlen == 6) { + status = slic_mcast_add_list(adapter, addresses); + if (status != STATUS_SUCCESS) +@@ -1657,9 +1642,9 @@ void slic_mcast_set_list(struct net_device *dev) + return; + } + +-void slic_mcast_set_mask(p_adapter_t adapter) ++static void slic_mcast_set_mask(struct adapter *adapter) + { +- p_slic_regs_t slic_regs = adapter->slic_regs; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; + + DBG_MSG("%s ENTER (%s) macopts[%x] mask[%llx]\n", __func__, + adapter->netdev->name, (uint) adapter->macopts, +@@ -1687,20 +1672,20 @@ void slic_mcast_set_mask(p_adapter_t adapter) + ((ulong) ((adapter->mcastmask >> 32) & 0xFFFFFFFF))); + + WRITE_REG(slic_regs->slic_mcastlow, +- (ulong32) (adapter->mcastmask & 0xFFFFFFFF), FLUSH); ++ (u32) (adapter->mcastmask & 0xFFFFFFFF), FLUSH); + WRITE_REG(slic_regs->slic_mcasthigh, +- (ulong32) ((adapter->mcastmask >> 32) & 0xFFFFFFFF), ++ (u32) ((adapter->mcastmask >> 32) & 0xFFFFFFFF), + FLUSH); + } + } + +-void slic_timer_ping(ulong dev) ++static void slic_timer_ping(ulong dev) + { +- p_adapter_t adapter; +- p_sliccard_t card; ++ struct adapter *adapter; ++ struct sliccard *card; + + ASSERT(dev); +- adapter = (p_adapter_t) ((struct net_device *) dev)->priv; ++ adapter = (struct adapter *)((struct net_device *) dev)->priv; + ASSERT(adapter); + card = adapter->card; + ASSERT(card); +@@ -1741,12 +1726,12 @@ void slic_timer_ping(ulong dev) + add_timer(&adapter->pingtimer); + } + +-void slic_if_stop_queue(p_adapter_t adapter) ++static void slic_if_stop_queue(struct adapter *adapter) + { + netif_stop_queue(adapter->netdev); + } + +-void slic_if_start_queue(p_adapter_t adapter) ++static void slic_if_start_queue(struct adapter *adapter) + { + netif_start_queue(adapter->netdev); + } +@@ -1757,12 +1742,12 @@ void slic_if_start_queue(p_adapter_t adapter) + * Perform initialization of our slic interface. + * + */ +-int slic_if_init(p_adapter_t adapter) ++static int slic_if_init(struct adapter *adapter) + { +- p_sliccard_t card = adapter->card; ++ struct sliccard *card = adapter->card; + struct net_device *dev = adapter->netdev; +- p_slic_regs_t slic_regs = adapter->slic_regs; +- p_slic_shmem_t pshmem; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; ++ struct slic_shmem *pshmem; + int status = 0; + + ASSERT(card); +@@ -1829,12 +1814,13 @@ int slic_if_init(p_adapter_t adapter) + DBG_MSG("slicoss: %s disable interrupts(slic)\n", __func__); + + WRITE_REG(slic_regs->slic_icr, ICR_INT_OFF, FLUSH); +- slic_stall_msec(1); ++ mdelay(1); + + if (!adapter->isp_initialized) { +- pshmem = (p_slic_shmem_t) adapter->phys_shmem; ++ pshmem = (struct slic_shmem *)adapter->phys_shmem; + +- SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->bit64reglock); ++ spin_lock_irqsave(&adapter->bit64reglock.lock, ++ adapter->bit64reglock.flags); + + #if defined(CONFIG_X86_64) + WRITE_REG(slic_regs->slic_addr_upper, +@@ -1842,12 +1828,13 @@ int slic_if_init(p_adapter_t adapter) + WRITE_REG(slic_regs->slic_isp, + SLIC_GET_ADDR_LOW(&pshmem->isr), FLUSH); + #elif defined(CONFIG_X86) +- WRITE_REG(slic_regs->slic_addr_upper, (ulong32) 0, DONT_FLUSH); +- WRITE_REG(slic_regs->slic_isp, (ulong32) &pshmem->isr, FLUSH); ++ WRITE_REG(slic_regs->slic_addr_upper, (u32) 0, DONT_FLUSH); ++ WRITE_REG(slic_regs->slic_isp, (u32) &pshmem->isr, FLUSH); + #else + Stop Compilations + #endif +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->bit64reglock); ++ spin_unlock_irqrestore(&adapter->bit64reglock.lock, ++ adapter->bit64reglock.flags); + adapter->isp_initialized = 1; + } + +@@ -1908,7 +1895,7 @@ int slic_if_init(p_adapter_t adapter) + return STATUS_SUCCESS; + } + +-void slic_unmap_mmio_space(p_adapter_t adapter) ++static void slic_unmap_mmio_space(struct adapter *adapter) + { + #if LINUX_FREES_ADAPTER_RESOURCES + if (adapter->slic_regs) +@@ -1917,7 +1904,7 @@ void slic_unmap_mmio_space(p_adapter_t adapter) + #endif + } + +-int slic_adapter_allocresources(p_adapter_t adapter) ++static int slic_adapter_allocresources(struct adapter *adapter) + { + if (!adapter->intrregistered) { + int retval; +@@ -1929,14 +1916,16 @@ int slic_adapter_allocresources(p_adapter_t adapter) + (void *)adapter->phys_shmem, adapter->netdev->irq, + NR_IRQS); + +- SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock); ++ spin_unlock_irqrestore(&slic_global.driver_lock.lock, ++ slic_global.driver_lock.flags); + + retval = request_irq(adapter->netdev->irq, + &slic_interrupt, + IRQF_SHARED, + adapter->netdev->name, adapter->netdev); + +- SLIC_ACQUIRE_IRQ_SPINLOCK(slic_global.driver_lock); ++ spin_lock_irqsave(&slic_global.driver_lock.lock, ++ slic_global.driver_lock.flags); + + if (retval) { + DBG_ERROR("slicoss: request_irq (%s) FAILED [%x]\n", +@@ -1953,7 +1942,7 @@ int slic_adapter_allocresources(p_adapter_t adapter) + return STATUS_SUCCESS; + } + +-void slic_config_pci(struct pci_dev *pcidev) ++static void slic_config_pci(struct pci_dev *pcidev) + { + u16 pci_command; + u16 new_command; +@@ -1972,11 +1961,11 @@ void slic_config_pci(struct pci_dev *pcidev) + } + } + +-void slic_adapter_freeresources(p_adapter_t adapter) ++static void slic_adapter_freeresources(struct adapter *adapter) + { + DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter); + slic_init_cleanup(adapter); +- SLIC_ZERO_MEMORY(&adapter->stats, sizeof(struct net_device_stats)); ++ memset(&adapter->stats, 0, sizeof(struct net_device_stats)); + adapter->error_interrupts = 0; + adapter->rcv_interrupts = 0; + adapter->xmit_interrupts = 0; +@@ -1996,14 +1985,14 @@ void slic_adapter_freeresources(p_adapter_t adapter) + * Write phy control to configure link duplex/speed + * + */ +-void slic_link_config(p_adapter_t adapter, +- ulong32 linkspeed, ulong32 linkduplex) ++static void slic_link_config(struct adapter *adapter, ++ u32 linkspeed, u32 linkduplex) + { +- ulong32 speed; +- ulong32 duplex; +- ulong32 phy_config; +- ulong32 phy_advreg; +- ulong32 phy_gctlreg; ++ u32 speed; ++ u32 duplex; ++ u32 phy_config; ++ u32 phy_advreg; ++ u32 phy_gctlreg; + + if (adapter->state != ADAPT_UP) { + DBG_MSG +@@ -2052,7 +2041,7 @@ void slic_link_config(p_adapter_t adapter, + phy_config, FLUSH); + /* wait, Marvell says 1 sec, + try to get away with 10 ms */ +- slic_stall_msec(10); ++ mdelay(10); + + /* disable auto-neg, set speed/duplex, + soft reset phy, powerup */ +@@ -2140,7 +2129,7 @@ void slic_link_config(p_adapter_t adapter, + WRITE_REG(adapter->slic_regs->slic_wphy, phy_config, FLUSH); + + /* wait, Marvell says 1 sec, try to get away with 10 ms */ +- slic_stall_msec(10); ++ mdelay(10); + + if (adapter->subsysid != SLIC_1GB_CICADA_SUBSYS_ID) { + /* if a Marvell PHY +@@ -2164,24 +2153,24 @@ void slic_link_config(p_adapter_t adapter, + phy_config); + } + +-void slic_card_cleanup(p_sliccard_t card) ++static void slic_card_cleanup(struct sliccard *card) + { + DBG_MSG("slicoss: %s ENTER\n", __func__); + + #if SLIC_DUMP_ENABLED + if (card->dumpbuffer) { +- SLIC_DEALLOCATE_MEM(card->dumpbuffer); +- card->dumpbuffer = NULL; + card->dumpbuffer_phys = 0; + card->dumpbuffer_physl = 0; + card->dumpbuffer_physh = 0; ++ kfree(card->dumpbuffer); ++ card->dumpbuffer = NULL; + } + if (card->cmdbuffer) { +- SLIC_DEALLOCATE_MEM(card->cmdbuffer); +- card->cmdbuffer = NULL; + card->cmdbuffer_phys = 0; + card->cmdbuffer_physl = 0; + card->cmdbuffer_physh = 0; ++ kfree(card->cmdbuffer); ++ card->cmdbuffer = NULL; + } + #endif + +@@ -2192,24 +2181,24 @@ void slic_card_cleanup(p_sliccard_t card) + + slic_debug_card_destroy(card); + +- SLIC_DEALLOCATE_MEM(card); ++ kfree(card); + DBG_MSG("slicoss: %s EXIT\n", __func__); + } + +-static int slic_card_download_gbrcv(p_adapter_t adapter) ++static int slic_card_download_gbrcv(struct adapter *adapter) + { +- p_slic_regs_t slic_regs = adapter->slic_regs; +- ulong32 codeaddr; +- puchar instruction = NULL; +- ulong32 rcvucodelen = 0; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; ++ u32 codeaddr; ++ unsigned char *instruction = NULL; ++ u32 rcvucodelen = 0; + + switch (adapter->devid) { + case SLIC_2GB_DEVICE_ID: +- instruction = (puchar) &OasisRcvUCode[0]; ++ instruction = (unsigned char *)&OasisRcvUCode[0]; + rcvucodelen = OasisRcvUCodeLen; + break; + case SLIC_1GB_DEVICE_ID: +- instruction = (puchar) &GBRcvUCode[0]; ++ instruction = (unsigned char *)&GBRcvUCode[0]; + rcvucodelen = GBRcvUCodeLen; + break; + default: +@@ -2227,11 +2216,11 @@ static int slic_card_download_gbrcv(p_adapter_t adapter) + + /* write out the instruction data low addr */ + WRITE_REG(slic_regs->slic_rcv_wcs, +- (ulong32) *(pulong32) instruction, FLUSH); ++ (u32) *(u32 *) instruction, FLUSH); + instruction += 4; + + /* write out the instruction data high addr */ +- WRITE_REG(slic_regs->slic_rcv_wcs, (ulong32) *instruction, ++ WRITE_REG(slic_regs->slic_rcv_wcs, (u32) *instruction, + FLUSH); + instruction += 1; + } +@@ -2242,22 +2231,22 @@ static int slic_card_download_gbrcv(p_adapter_t adapter) + return 0; + } + +-int slic_card_download(p_adapter_t adapter) ++static int slic_card_download(struct adapter *adapter) + { +- ulong32 section; ++ u32 section; + int thissectionsize; + int codeaddr; +- p_slic_regs_t slic_regs = adapter->slic_regs; +- ulong32 *instruction = NULL; +- ulong32 *lastinstruct = NULL; +- ulong32 *startinstruct = NULL; +- puchar nextinstruct; +- ulong32 baseaddress; +- ulong32 failure; +- ulong32 i; +- ulong32 numsects = 0; +- ulong32 sectsize[3]; +- ulong32 sectstart[3]; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; ++ u32 *instruction = NULL; ++ u32 *lastinstruct = NULL; ++ u32 *startinstruct = NULL; ++ unsigned char *nextinstruct; ++ u32 baseaddress; ++ u32 failure; ++ u32 i; ++ u32 numsects = 0; ++ u32 sectsize[3]; ++ u32 sectstart[3]; + + /* DBG_MSG ("slicoss: %s (%s) adapter[%p] card[%p] devid[%x] \ + jiffies[%lx] cpu %d\n", __func__, adapter->netdev->name, adapter, +@@ -2292,19 +2281,19 @@ int slic_card_download(p_adapter_t adapter) + for (section = 0; section < numsects; section++) { + switch (adapter->devid) { + case SLIC_2GB_DEVICE_ID: +- instruction = (pulong32) &OasisUCode[section][0]; ++ instruction = (u32 *) &OasisUCode[section][0]; + baseaddress = sectstart[section]; + thissectionsize = sectsize[section] >> 3; + lastinstruct = +- (pulong32) &OasisUCode[section][sectsize[section] - ++ (u32 *) &OasisUCode[section][sectsize[section] - + 8]; + break; + case SLIC_1GB_DEVICE_ID: +- instruction = (pulong32) &MojaveUCode[section][0]; ++ instruction = (u32 *) &MojaveUCode[section][0]; + baseaddress = sectstart[section]; + thissectionsize = sectsize[section] >> 3; + lastinstruct = +- (pulong32) &MojaveUCode[section][sectsize[section] ++ (u32 *) &MojaveUCode[section][sectsize[section] + - 8]; + break; + default: +@@ -2317,21 +2306,21 @@ int slic_card_download(p_adapter_t adapter) + + for (codeaddr = 0; codeaddr < thissectionsize; codeaddr++) { + startinstruct = instruction; +- nextinstruct = ((puchar) instruction) + 8; ++ nextinstruct = ((unsigned char *)instruction) + 8; + /* Write out instruction address */ + WRITE_REG(slic_regs->slic_wcs, baseaddress + codeaddr, + FLUSH); + /* Write out instruction to low addr */ + WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH); + #ifdef CONFIG_X86_64 +- instruction = (pulong32) ((puchar) instruction + 4); ++ instruction = (u32 *)((unsigned char *)instruction + 4); + #else + instruction++; + #endif + /* Write out instruction to high addr */ + WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH); + #ifdef CONFIG_X86_64 +- instruction = (pulong32) ((puchar) instruction + 4); ++ instruction = (u32 *)((unsigned char *)instruction + 4); + #else + instruction++; + #endif +@@ -2341,10 +2330,10 @@ int slic_card_download(p_adapter_t adapter) + for (section = 0; section < numsects; section++) { + switch (adapter->devid) { + case SLIC_2GB_DEVICE_ID: +- instruction = (pulong32) &OasisUCode[section][0]; ++ instruction = (u32 *)&OasisUCode[section][0]; + break; + case SLIC_1GB_DEVICE_ID: +- instruction = (pulong32) &MojaveUCode[section][0]; ++ instruction = (u32 *)&MojaveUCode[section][0]; + break; + default: + ASSERT(0); +@@ -2367,19 +2356,19 @@ int slic_card_download(p_adapter_t adapter) + /* Write out instruction to low addr */ + WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH); + #ifdef CONFIG_X86_64 +- instruction = (pulong32) ((puchar) instruction + 4); ++ instruction = (u32 *)((unsigned char *)instruction + 4); + #else + instruction++; + #endif + /* Write out instruction to high addr */ + WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH); + #ifdef CONFIG_X86_64 +- instruction = (pulong32) ((puchar) instruction + 4); ++ instruction = (u32 *)((unsigned char *)instruction + 4); + #else + instruction++; + #endif + /* Check SRAM location zero. If it is non-zero. Abort.*/ +- failure = READ_REG(slic_regs->slic_reset, 0); ++ failure = readl((u32 __iomem *)&slic_regs->slic_reset); + if (failure) { + DBG_MSG + ("slicoss: %s FAILURE EXIT codeaddr[%x] \ +@@ -2394,12 +2383,12 @@ int slic_card_download(p_adapter_t adapter) + /* DBG_MSG ("slicoss: Compare done\n");*/ + + /* Everything OK, kick off the card */ +- slic_stall_msec(10); ++ mdelay(10); + WRITE_REG(slic_regs->slic_wcs, SLIC_WCS_START, FLUSH); + + /* stall for 20 ms, long enough for ucode to init card + and reach mainloop */ +- slic_stall_msec(20); ++ mdelay(20); + + DBG_MSG("slicoss: %s (%s) EXIT adapter[%p] card[%p]\n", + __func__, adapter->netdev->name, adapter, adapter->card); +@@ -2407,9 +2396,9 @@ int slic_card_download(p_adapter_t adapter) + return STATUS_SUCCESS; + } + +-void slic_adapter_set_hwaddr(p_adapter_t adapter) ++static void slic_adapter_set_hwaddr(struct adapter *adapter) + { +- p_sliccard_t card = adapter->card; ++ struct sliccard *card = adapter->card; + + /* DBG_MSG ("%s ENTER card->config_set[%x] port[%d] physport[%d] funct#[%d]\n", + __func__, card->config_set, adapter->port, adapter->physport, +@@ -2420,7 +2409,7 @@ void slic_adapter_set_hwaddr(p_adapter_t adapter) + if ((adapter->card) && (card->config_set)) { + memcpy(adapter->macaddr, + card->config.MacInfo[adapter->functionnumber].macaddrA, +- sizeof(slic_config_mac_t)); ++ sizeof(struct slic_config_mac)); + /* DBG_MSG ("%s AFTER copying from config.macinfo into currmacaddr\n", + __func__); + slic_dbg_macaddrs(adapter);*/ +@@ -2438,53 +2427,35 @@ void slic_adapter_set_hwaddr(p_adapter_t adapter) + slic_dbg_macaddrs(adapter); */ + } + +-void slic_card_halt(p_sliccard_t card, p_adapter_t adapter) ++static void slic_intagg_set(struct adapter *adapter, u32 value) + { +- p_slic_regs_t slic_regs = adapter->slic_regs; +- +- DBG_MSG("slicoss: %s ENTER card[%p] adapter[%p] card->state[%x]\n", +- __func__, card, adapter, card->state); +- WRITE_REG(slic_regs->slic_icr, ICR_INT_OFF, FLUSH); +- adapter->all_reg_writes++; +- adapter->icr_reg_writes++; +- slic_config_clear(adapter); +- WRITE_REG(slic_regs->slic_reset_iface, 0, FLUSH); +- slic_soft_reset(adapter); +- DBG_MSG("slicoss: %s EXIT card[%p] adapter[%p] card->state[%x]\n", +- __func__, card, adapter, card->state); +- return; +- +-} +- +-void slic_intagg_set(p_adapter_t adapter, ulong32 value) +-{ +- p_slic_regs_t slic_regs = adapter->slic_regs; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; + + WRITE_REG(slic_regs->slic_intagg, value, FLUSH); + adapter->card->loadlevel_current = value; + } + +-int slic_card_init(p_sliccard_t card, p_adapter_t adapter) ++static int slic_card_init(struct sliccard *card, struct adapter *adapter) + { +- p_slic_regs_t slic_regs = adapter->slic_regs; +- pslic_eeprom_t peeprom; +- poslic_eeprom_t pOeeprom; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; ++ struct slic_eeprom *peeprom; ++ struct oslic_eeprom *pOeeprom; + dma_addr_t phys_config; +- ulong32 phys_configh; +- ulong32 phys_configl; +- ulong32 i = 0; +- p_slic_shmem_t pshmem; ++ u32 phys_configh; ++ u32 phys_configl; ++ u32 i = 0; ++ struct slic_shmem *pshmem; + int status; + uint macaddrs = card->card_size; + ushort eecodesize; + ushort dramsize; + ushort ee_chksum; + ushort calc_chksum; +- pslic_config_mac_t pmac; +- uchar fruformat; +- uchar oemfruformat; +- patk_fru_t patkfru; +- poemfru_t poemfru; ++ struct slic_config_mac *pmac; ++ unsigned char fruformat; ++ unsigned char oemfruformat; ++ struct atk_fru *patkfru; ++ union oemfru_t *poemfru; + + DBG_MSG + ("slicoss: %s ENTER card[%p] adapter[%p] card->state[%x] \ +@@ -2505,7 +2476,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter) + + if (!card->config_set) { + peeprom = pci_alloc_consistent(adapter->pcidev, +- sizeof(slic_eeprom_t), ++ sizeof(struct slic_eeprom), + &phys_config); + + phys_configl = SLIC_GET_ADDR_LOW(phys_config); +@@ -2515,8 +2486,9 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter) + "size [%x]\n peeprom [%p]\n " + "phys_config [%p]\n phys_configl[%x]\n " + "phys_configh[%x]\n", +- __func__, adapter, (ulong32) sizeof(slic_eeprom_t), +- peeprom, (pvoid) phys_config, phys_configl, ++ __func__, adapter, ++ (u32)sizeof(struct slic_eeprom), ++ peeprom, (void *) phys_config, phys_configl, + phys_configh); + if (!peeprom) { + DBG_ERROR +@@ -2526,17 +2498,19 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter) + (uint) adapter->slotnumber); + return -ENOMEM; + } else { +- SLIC_ZERO_MEMORY(peeprom, sizeof(slic_eeprom_t)); ++ memset(peeprom, 0, sizeof(struct slic_eeprom)); + } + WRITE_REG(slic_regs->slic_icr, ICR_INT_OFF, FLUSH); +- slic_stall_msec(1); +- pshmem = (p_slic_shmem_t) adapter->phys_shmem; ++ mdelay(1); ++ pshmem = (struct slic_shmem *)adapter->phys_shmem; + +- SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->bit64reglock); ++ spin_lock_irqsave(&adapter->bit64reglock.lock, ++ adapter->bit64reglock.flags); + WRITE_REG(slic_regs->slic_addr_upper, 0, DONT_FLUSH); + WRITE_REG(slic_regs->slic_isp, + SLIC_GET_ADDR_LOW(&pshmem->isr), FLUSH); +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->bit64reglock); ++ spin_unlock_irqrestore(&adapter->bit64reglock.lock, ++ adapter->bit64reglock.flags); + + slic_config_get(adapter, phys_configl, phys_configh); + +@@ -2564,7 +2538,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter) + FLUSH); + } + } else { +- slic_stall_msec(1); ++ mdelay(1); + i++; + if (i > 5000) { + DBG_ERROR +@@ -2586,7 +2560,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter) + /* Oasis card */ + case SLIC_2GB_DEVICE_ID: + /* extract EEPROM data and pointers to EEPROM data */ +- pOeeprom = (poslic_eeprom_t) peeprom; ++ pOeeprom = (struct oslic_eeprom *) peeprom; + eecodesize = pOeeprom->EecodeSize; + dramsize = pOeeprom->DramSize; + pmac = pOeeprom->MacInfo; +@@ -2619,12 +2593,12 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter) + (eecodesize >= MIN_EECODE_SIZE)) { + + ee_chksum = +- *(pushort) ((pchar) peeprom + (eecodesize - 2)); ++ *(u16 *) ((char *) peeprom + (eecodesize - 2)); + /* + calculate the EEPROM checksum + */ + calc_chksum = +- ~slic_eeprom_cksum((pchar) peeprom, ++ ~slic_eeprom_cksum((char *) peeprom, + (eecodesize - 2)); + /* + if the ucdoe chksum flag bit worked, +@@ -2639,24 +2613,25 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter) + /* copy in the MAC address(es) */ + for (i = 0; i < macaddrs; i++) { + memcpy(&card->config.MacInfo[i], +- &pmac[i], sizeof(slic_config_mac_t)); ++ &pmac[i], sizeof(struct slic_config_mac)); + } + /* DBG_MSG ("%s EEPROM Checksum Good? %d MacAddress\n",__func__, + card->config.EepromValid); */ + + /* copy the Alacritech FRU information */ + card->config.FruFormat = fruformat; +- memcpy(&card->config.AtkFru, patkfru, sizeof(atk_fru_t)); ++ memcpy(&card->config.AtkFru, patkfru, ++ sizeof(struct atk_fru)); + + pci_free_consistent(adapter->pcidev, +- sizeof(slic_eeprom_t), ++ sizeof(struct slic_eeprom), + peeprom, phys_config); + DBG_MSG + ("slicoss: %s adapter%d [%p] size[%x] FREE peeprom[%p] \ + phys_config[%p]\n", + __func__, adapter->port, adapter, +- (ulong32) sizeof(slic_eeprom_t), peeprom, +- (pvoid) phys_config); ++ (u32) sizeof(struct slic_eeprom), peeprom, ++ (void *) phys_config); + + if ((!card->config.EepromValid) && + (adapter->reg_params.fail_on_bad_eeprom)) { +@@ -2698,8 +2673,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter) + + #if SLIC_DUMP_ENABLED + if (!card->dumpbuffer) { +- card->dumpbuffer = +- SLIC_ALLOCATE_MEM(DUMP_PAGE_SIZE, GFP_ATOMIC); ++ card->dumpbuffer = kmalloc(DUMP_PAGE_SIZE, GFP_ATOMIC); + + ASSERT(card->dumpbuffer); + if (card->dumpbuffer == NULL) +@@ -2709,8 +2683,8 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter) + * Smear the shared memory structure and then obtain + * the PHYSICAL address of this structure + */ +- SLIC_ZERO_MEMORY(card->dumpbuffer, DUMP_PAGE_SIZE); +- card->dumpbuffer_phys = SLIC_GET_PHYSICAL_ADDRESS(card->dumpbuffer); ++ memset(card->dumpbuffer, 0, DUMP_PAGE_SIZE); ++ card->dumpbuffer_phys = virt_to_bus(card->dumpbuffer); + card->dumpbuffer_physh = SLIC_GET_ADDR_HIGH(card->dumpbuffer_phys); + card->dumpbuffer_physl = SLIC_GET_ADDR_LOW(card->dumpbuffer_phys); + +@@ -2718,8 +2692,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter) + * Allocate COMMAND BUFFER + */ + if (!card->cmdbuffer) { +- card->cmdbuffer = +- SLIC_ALLOCATE_MEM(sizeof(dump_cmd_t), GFP_ATOMIC); ++ card->cmdbuffer = kmalloc(sizeof(dump_cmd_t), GFP_ATOMIC); + + ASSERT(card->cmdbuffer); + if (card->cmdbuffer == NULL) +@@ -2729,8 +2702,8 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter) + * Smear the shared memory structure and then obtain + * the PHYSICAL address of this structure + */ +- SLIC_ZERO_MEMORY(card->cmdbuffer, sizeof(dump_cmd_t)); +- card->cmdbuffer_phys = SLIC_GET_PHYSICAL_ADDRESS(card->cmdbuffer); ++ memset(card->cmdbuffer, 0, sizeof(dump_cmd_t)); ++ card->cmdbuffer_phys = virt_to_bus(card->cmdbuffer); + card->cmdbuffer_physh = SLIC_GET_ADDR_HIGH(card->cmdbuffer_phys); + card->cmdbuffer_physl = SLIC_GET_ADDR_LOW(card->cmdbuffer_phys); + #endif +@@ -2746,10 +2719,10 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter) + return STATUS_SUCCESS; + } + +-ulong32 slic_card_locate(p_adapter_t adapter) ++static u32 slic_card_locate(struct adapter *adapter) + { +- p_sliccard_t card = slic_global.slic_card; +- p_physcard_t physcard = slic_global.phys_card; ++ struct sliccard *card = slic_global.slic_card; ++ struct physcard *physcard = slic_global.phys_card; + ushort card_hostid; + u16 __iomem *hostid_reg; + uint i; +@@ -2777,13 +2750,12 @@ ulong32 slic_card_locate(p_adapter_t adapter) + DBG_MSG("slicoss: %s *hostid_reg[%p] == ", __func__, hostid_reg); + + /* read the 16 bit hostid from SRAM */ +-/* card_hostid = READ_REGP16(hostid_reg, 0);*/ + card_hostid = (ushort) readw(hostid_reg); + DBG_MSG(" card_hostid[%x]\n", card_hostid); + + /* Initialize a new card structure if need be */ + if (card_hostid == SLIC_HOSTID_DEFAULT) { +- card = kzalloc(sizeof(sliccard_t), GFP_KERNEL); ++ card = kzalloc(sizeof(struct sliccard), GFP_KERNEL); + if (card == NULL) + return -ENOMEM; + +@@ -2861,11 +2833,9 @@ ulong32 slic_card_locate(p_adapter_t adapter) + } + if (!physcard) { + /* no structure allocated for this physical card yet */ +- physcard = +- (p_physcard_t) SLIC_ALLOCATE_MEM(sizeof(physcard_t), +- GFP_ATOMIC); ++ physcard = kmalloc(sizeof(struct physcard *), GFP_ATOMIC); + ASSERT(physcard); +- SLIC_ZERO_MEMORY(physcard, sizeof(physcard_t)); ++ memset(physcard, 0, sizeof(struct physcard *)); + + DBG_MSG + ("\n%s Allocate a PHYSICALcard:\n PHYSICAL_Card[%p]\n\ +@@ -2890,130 +2860,27 @@ ulong32 slic_card_locate(p_adapter_t adapter) + return 0; + } + +-void slic_card_remaster(p_adapter_t adapter) +-{ +- p_sliccard_t card = adapter->card; +- int i; +- +- DBG_MSG("slicoss: %s card->master[%p] == adapter[%p]??\n", +- __func__, card->master, adapter); +- if (card->master != adapter) +- return; +- card->master = NULL; +- for (i = 0; i < SLIC_MAX_PORTS; i++) { +- if (card->adapter[i] && (card->adapter[i] != adapter)) { +- card->master = card->adapter[i]; +- DBG_MSG("slicoss: %s NEW MASTER SET card->master[%p]" +- " == card->adapter[%d]\n", __func__, +- card->master, i); +- break; +- } +- } +-} +- +-void slic_soft_reset(p_adapter_t adapter) ++static void slic_soft_reset(struct adapter *adapter) + { + if (adapter->card->state == CARD_UP) { + DBG_MSG("slicoss: %s QUIESCE adapter[%p] card[%p] devid[%x]\n", + __func__, adapter, adapter->card, adapter->devid); + WRITE_REG(adapter->slic_regs->slic_quiesce, 0, FLUSH); +- slic_stall_msec(1); ++ mdelay(1); + } + /* DBG_MSG ("slicoss: %s (%s) adapter[%p] card[%p] devid[%x]\n", + __func__, adapter->netdev->name, adapter, adapter->card, + adapter->devid); */ + + WRITE_REG(adapter->slic_regs->slic_reset, SLIC_RESET_MAGIC, FLUSH); +- slic_stall_msec(1); +-} +- +-void slic_card_reset(p_adapter_t adapter) +-{ +- p_sliccard_t card = adapter->card; +- p_slic_upr_t upr = adapter->upr_list; +- p_slic_upr_t upr_next = NULL; +- ulong32 i; +-#if SLIC_FAILURE_RESET +- ulong32 status = 0; +-#endif +- DBG_MSG +- ("slicoss: %s adapter[%p] port[%d] state[%x] card[%p] state[%x]\n", +- __func__, adapter, adapter->port, adapter->state, card, +- card->state); +- SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->adapter_lock); +- SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->reset_lock); +- if (card->state == CARD_DIAG) { +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->reset_lock); +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->adapter_lock); +- return; +- } +- SLIC_ACQUIRE_IRQ_SPINLOCK(slic_global.driver_lock); +- card->reset_in_progress = 1; +-#if SLIC_FAILURE_RESET +- if (adapter->state != ADAPT_RESET) { +- SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock); +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->reset_lock); +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->adapter_lock); +- return; +- } +- +- adapter->state = ADAPT_DOWN; +- adapter->linkstate = LINK_DOWN; +-#endif +- if (adapter->gennumber == card->gennumber) { +- for (i = 0; i < card->card_size; i++) { +- if (card->adapter[i]) { +- if (card->adapter[i] == adapter) +- continue; +- if (card->adapter[i]->state == ADAPT_UP) { +- card->adapter[i]->state = ADAPT_RESET; +- adapter->linkstate = LINK_DOWN; +- } +- } +- } +-#if SLIC_FAILURE_RESET +- slic_soft_reset(adapter); +- card->state = CARD_DOWN; +- card->master = NULL; +- card->adapters_activated = 0; +-#endif +- card->gennumber++; +- } +- adapter->gennumber = card->gennumber; +- adapter->pshmem->isr = 0; +- adapter->isrcopy = 0; +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->reset_lock); +- for (i = 0; i < card->card_size; i++) { +- if (card->adapter[i]) +- slic_cmdq_reset(card->adapter[i]); +- } +- while (upr) { +- upr_next = upr->next; +- SLIC_DEALLOCATE_MEM(upr); +- upr = upr_next; +- } +- adapter->upr_list = NULL; +- adapter->upr_busy = 0; +-#if SLIC_FAILURE_RESET +- status = slic_if_init(adapter); +- if ((status == 0) && (!card->master)) +- card->master = adapter; +- slic_mcast_set_mask(adapter); +-#endif +- SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock); +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->adapter_lock); +- DBG_MSG +- ("slicoss: %s EXIT adapter[%p] port[%d] state[%x] card[%p] \ +- state[%x]\n", __func__, adapter, adapter->port, adapter->state, +- card, card->state); +- return; ++ mdelay(1); + } + +-void slic_config_set(p_adapter_t adapter, boolean linkchange) ++static void slic_config_set(struct adapter *adapter, bool linkchange) + { +- ulong32 value; +- ulong32 RcrReset; +- p_slic_regs_t slic_regs = adapter->slic_regs; ++ u32 value; ++ u32 RcrReset; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; + + DBG_MSG("slicoss: %s (%s) slic_interface_enable[%p](%d)\n", + __func__, adapter->netdev->name, adapter, +@@ -3075,11 +2942,11 @@ void slic_config_set(p_adapter_t adapter, boolean linkchange) + /* + * Turn off RCV and XMT, power down PHY + */ +-void slic_config_clear(p_adapter_t adapter) ++static void slic_config_clear(struct adapter *adapter) + { +- ulong32 value; +- ulong32 phy_config; +- p_slic_regs_t slic_regs = adapter->slic_regs; ++ u32 value; ++ u32 phy_config; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; + + /* Setup xmtcfg */ + value = (GXCR_RESET | /* Always reset */ +@@ -3099,28 +2966,29 @@ void slic_config_clear(p_adapter_t adapter) + WRITE_REG(slic_regs->slic_wphy, phy_config, FLUSH); + } + +-void slic_config_get(p_adapter_t adapter, ulong32 config, ulong32 config_h) ++static void slic_config_get(struct adapter *adapter, u32 config, ++ u32 config_h) + { + int status; + + status = slic_upr_request(adapter, + SLIC_UPR_RCONFIG, +- (ulong32) config, (ulong32) config_h, 0, 0); ++ (u32) config, (u32) config_h, 0, 0); + ASSERT(status == 0); + } + +-void slic_mac_address_config(p_adapter_t adapter) ++static void slic_mac_address_config(struct adapter *adapter) + { +- ulong32 value; +- ulong32 value2; +- p_slic_regs_t slic_regs = adapter->slic_regs; ++ u32 value; ++ u32 value2; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; + +- value = *(pulong32) &adapter->currmacaddr[2]; ++ value = *(u32 *) &adapter->currmacaddr[2]; + value = ntohl(value); + WRITE_REG(slic_regs->slic_wraddral, value, FLUSH); + WRITE_REG(slic_regs->slic_wraddrbl, value, FLUSH); + +- value2 = (ulong32) ((adapter->currmacaddr[0] << 8 | ++ value2 = (u32) ((adapter->currmacaddr[0] << 8 | + adapter->currmacaddr[1]) & 0xFFFF); + + WRITE_REG(slic_regs->slic_wraddrah, value2, FLUSH); +@@ -3136,10 +3004,10 @@ void slic_mac_address_config(p_adapter_t adapter) + slic_mcast_set_mask(adapter); + } + +-void slic_mac_config(p_adapter_t adapter) ++static void slic_mac_config(struct adapter *adapter) + { +- ulong32 value; +- p_slic_regs_t slic_regs = adapter->slic_regs; ++ u32 value; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; + + /* Setup GMAC gaps */ + if (adapter->linkspeed == LINK_1000MB) { +@@ -3169,12 +3037,13 @@ void slic_mac_config(p_adapter_t adapter) + slic_mac_address_config(adapter); + } + +-boolean slic_mac_filter(p_adapter_t adapter, p_ether_header ether_frame) ++static bool slic_mac_filter(struct adapter *adapter, ++ struct ether_header *ether_frame) + { +- ulong32 opts = adapter->macopts; +- pulong32 dhost4 = (pulong32) ðer_frame->ether_dhost[0]; +- pushort dhost2 = (pushort) ðer_frame->ether_dhost[4]; +- boolean equaladdr; ++ u32 opts = adapter->macopts; ++ u32 *dhost4 = (u32 *)ðer_frame->ether_dhost[0]; ++ u16 *dhost2 = (u16 *)ðer_frame->ether_dhost[4]; ++ bool equaladdr; + + if (opts & MAC_PROMISC) { + DBG_MSG("slicoss: %s (%s) PROMISCUOUS. Accept frame\n", +@@ -3198,7 +3067,7 @@ boolean slic_mac_filter(p_adapter_t adapter, p_ether_header ether_frame) + return TRUE; + } + if (opts & MAC_MCAST) { +- p_mcast_address_t mcaddr = adapter->mcastaddrs; ++ struct mcast_address *mcaddr = adapter->mcastaddrs; + + while (mcaddr) { + ETHER_EQ_ADDR(mcaddr->address, +@@ -3224,9 +3093,9 @@ boolean slic_mac_filter(p_adapter_t adapter, p_ether_header ether_frame) + + } + +-int slic_mac_set_address(struct net_device *dev, pvoid ptr) ++static int slic_mac_set_address(struct net_device *dev, void *ptr) + { +- p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); ++ struct adapter *adapter = (struct adapter *)netdev_priv(dev); + struct sockaddr *addr = ptr; + + DBG_MSG("%s ENTER (%s)\n", __func__, adapter->netdev->name); +@@ -3259,21 +3128,21 @@ int slic_mac_set_address(struct net_device *dev, pvoid ptr) + * 50 seconds or whatever STATS_TIMER_INTERVAL is set to. + * + */ +-void slic_timer_get_stats(ulong dev) ++static void slic_timer_get_stats(ulong dev) + { +- p_adapter_t adapter; +- p_sliccard_t card; +- p_slic_shmem_t pshmem; ++ struct adapter *adapter; ++ struct sliccard *card; ++ struct slic_shmem *pshmem; + + ASSERT(dev); +- adapter = (p_adapter_t) ((struct net_device *)dev)->priv; ++ adapter = (struct adapter *)((struct net_device *)dev)->priv; + ASSERT(adapter); + card = adapter->card; + ASSERT(card); + + if ((card->state == CARD_UP) && + (adapter->state == ADAPT_UP) && (adapter->linkstate == LINK_UP)) { +- pshmem = (p_slic_shmem_t) adapter->phys_shmem; ++ pshmem = (struct slic_shmem *)adapter->phys_shmem; + #ifdef CONFIG_X86_64 + slic_upr_request(adapter, + SLIC_UPR_STATS, +@@ -3282,7 +3151,7 @@ void slic_timer_get_stats(ulong dev) + #elif defined(CONFIG_X86) + slic_upr_request(adapter, + SLIC_UPR_STATS, +- (ulong32) &pshmem->inicstats, 0, 0, 0); ++ (u32) &pshmem->inicstats, 0, 0, 0); + #else + Stop compilation; + #endif +@@ -3295,12 +3164,12 @@ void slic_timer_get_stats(ulong dev) + add_timer(&adapter->statstimer); + } + +-void slic_timer_load_check(ulong cardaddr) ++static void slic_timer_load_check(ulong cardaddr) + { +- p_sliccard_t card = (p_sliccard_t) cardaddr; +- p_adapter_t adapter = card->master; +- ulong32 load = card->events; +- ulong32 level = 0; ++ struct sliccard *card = (struct sliccard *)cardaddr; ++ struct adapter *adapter = card->master; ++ u32 load = card->events; ++ u32 level = 0; + + if ((adapter) && (adapter->state == ADAPT_UP) && + (card->state == CARD_UP) && (slic_global.dynamic_intagg)) { +@@ -3352,36 +3221,26 @@ void slic_timer_load_check(ulong cardaddr) + add_timer(&card->loadtimer); + } + +-void slic_stall_msec(int stall) +-{ +- mdelay(stall); +-} +- +-void slic_stall_usec(int stall) +-{ +- udelay(stall); +-} +- +-void slic_assert_fail(void) ++static void slic_assert_fail(void) + { +- ulong32 cpuid; +- ulong32 curr_pid; ++ u32 cpuid; ++ u32 curr_pid; + cpuid = smp_processor_id(); + curr_pid = current->pid; + + DBG_ERROR("%s CPU # %d ---- PID # %d\n", __func__, cpuid, curr_pid); + } + +-int slic_upr_queue_request(p_adapter_t adapter, +- ulong32 upr_request, +- ulong32 upr_data, +- ulong32 upr_data_h, +- ulong32 upr_buffer, ulong32 upr_buffer_h) ++static int slic_upr_queue_request(struct adapter *adapter, ++ u32 upr_request, ++ u32 upr_data, ++ u32 upr_data_h, ++ u32 upr_buffer, u32 upr_buffer_h) + { +- p_slic_upr_t upr; +- p_slic_upr_t uprqueue; ++ struct slic_upr *upr; ++ struct slic_upr *uprqueue; + +- upr = SLIC_ALLOCATE_MEM(sizeof(slic_upr_t), GFP_ATOMIC); ++ upr = kmalloc(sizeof(struct slic_upr), GFP_ATOMIC); + if (!upr) { + DBG_MSG("%s COULD NOT ALLOCATE UPR MEM\n", __func__); + +@@ -3406,42 +3265,45 @@ int slic_upr_queue_request(p_adapter_t adapter, + return STATUS_SUCCESS; + } + +-int slic_upr_request(p_adapter_t adapter, +- ulong32 upr_request, +- ulong32 upr_data, +- ulong32 upr_data_h, +- ulong32 upr_buffer, ulong32 upr_buffer_h) ++static int slic_upr_request(struct adapter *adapter, ++ u32 upr_request, ++ u32 upr_data, ++ u32 upr_data_h, ++ u32 upr_buffer, u32 upr_buffer_h) + { + int status; + +- SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->upr_lock); ++ spin_lock_irqsave(&adapter->upr_lock.lock, adapter->upr_lock.flags); + status = slic_upr_queue_request(adapter, + upr_request, + upr_data, + upr_data_h, upr_buffer, upr_buffer_h); + if (status != STATUS_SUCCESS) { +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->upr_lock); ++ spin_unlock_irqrestore(&adapter->upr_lock.lock, ++ adapter->upr_lock.flags); + return status; + } + slic_upr_start(adapter); +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->upr_lock); ++ spin_unlock_irqrestore(&adapter->upr_lock.lock, ++ adapter->upr_lock.flags); + return STATUS_PENDING; + } + +-void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr) ++static void slic_upr_request_complete(struct adapter *adapter, u32 isr) + { +- p_sliccard_t card = adapter->card; +- p_slic_upr_t upr; ++ struct sliccard *card = adapter->card; ++ struct slic_upr *upr; + + /* if (card->dump_requested) { + DBG_MSG("ENTER slic_upr_request_complete Dump in progress ISR[%x]\n", + isr); + } */ +- SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->upr_lock); ++ spin_lock_irqsave(&adapter->upr_lock.lock, adapter->upr_lock.flags); + upr = adapter->upr_list; + if (!upr) { + ASSERT(0); +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->upr_lock); ++ spin_unlock_irqrestore(&adapter->upr_lock.lock, ++ adapter->upr_lock.flags); + return; + } + adapter->upr_list = upr->next; +@@ -3452,11 +3314,11 @@ void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr) + case SLIC_UPR_STATS: + { + #if SLIC_GET_STATS_ENABLED +- p_slic_stats_t slicstats = +- (p_slic_stats_t) &adapter->pshmem->inicstats; +- p_slic_stats_t newstats = slicstats; +- p_slic_stats_t old = &adapter->inicstats_prev; +- p_slicnet_stats_t stst = &adapter->slic_stats; ++ struct slic_stats *slicstats = ++ (struct slic_stats *) &adapter->pshmem->inicstats; ++ struct slic_stats *newstats = slicstats; ++ struct slic_stats *old = &adapter->inicstats_prev; ++ struct slicnet_stats *stst = &adapter->slic_stats; + #endif + if (isr & ISR_UPCERR) { + DBG_ERROR +@@ -3540,7 +3402,7 @@ void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr) + (newstats->rcv_drops_gb - + old->rcv_drops_gb); + } +- memcpy(old, newstats, sizeof(slic_stats_t)); ++ memcpy(old, newstats, sizeof(struct slic_stats)); + #endif + break; + } +@@ -3572,15 +3434,16 @@ void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr) + default: + ASSERT(0); + } +- SLIC_DEALLOCATE_MEM(upr); ++ kfree(upr); + slic_upr_start(adapter); +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->upr_lock); ++ spin_unlock_irqrestore(&adapter->upr_lock.lock, ++ adapter->upr_lock.flags); + } + +-void slic_upr_start(p_adapter_t adapter) ++static void slic_upr_start(struct adapter *adapter) + { +- p_slic_upr_t upr; +- p_slic_regs_t slic_regs = adapter->slic_regs; ++ struct slic_upr *upr; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; + /* + char * ptr1; + char * ptr2; +@@ -3670,21 +3533,21 @@ void slic_upr_start(p_adapter_t adapter) + } + } + +-void slic_link_upr_complete(p_adapter_t adapter, ulong32 isr) ++static void slic_link_upr_complete(struct adapter *adapter, u32 isr) + { +- ulong32 linkstatus = adapter->pshmem->linkstatus; ++ u32 linkstatus = adapter->pshmem->linkstatus; + uint linkup; +- uchar linkspeed; +- uchar linkduplex; ++ unsigned char linkspeed; ++ unsigned char linkduplex; + + DBG_MSG("%s: %s ISR[%x] linkstatus[%x]\n adapter[%p](%d)\n", + __func__, adapter->netdev->name, isr, linkstatus, adapter, + adapter->cardindex); + + if ((isr & ISR_UPCERR) || (isr & ISR_UPCBSY)) { +- p_slic_shmem_t pshmem; ++ struct slic_shmem *pshmem; + +- pshmem = (p_slic_shmem_t) adapter->phys_shmem; ++ pshmem = (struct slic_shmem *)adapter->phys_shmem; + #if defined(CONFIG_X86_64) + slic_upr_queue_request(adapter, + SLIC_UPR_RLSR, +@@ -3694,7 +3557,7 @@ void slic_link_upr_complete(p_adapter_t adapter, ulong32 isr) + #elif defined(CONFIG_X86) + slic_upr_queue_request(adapter, + SLIC_UPR_RLSR, +- (ulong32) &pshmem->linkstatus, ++ (u32) &pshmem->linkstatus, + SLIC_GET_ADDR_HIGH(pshmem), 0, 0); + #else + Stop Compilation; +@@ -3792,16 +3655,16 @@ void slic_link_upr_complete(p_adapter_t adapter, ulong32 isr) + * which prevens us from using the ucode result. + * remove this once ucode is fixed. + */ +-ushort slic_eeprom_cksum(pchar m, int len) ++static ushort slic_eeprom_cksum(char *m, int len) + { + #define ADDCARRY(x) (x > 65535 ? x -= 65535 : x) + #define REDUCE {l_util.l = sum; sum = l_util.s[0] + l_util.s[1]; ADDCARRY(sum);\ + } + +- pushort w; +- ulong32 sum = 0; +- ulong32 byte_swapped = 0; +- ulong32 w_int; ++ u16 *w; ++ u32 sum = 0; ++ u32 byte_swapped = 0; ++ u32 w_int; + + union { + char c[2]; +@@ -3816,17 +3679,17 @@ ushort slic_eeprom_cksum(pchar m, int len) + l_util.l = 0; + s_util.s = 0; + +- w = (pushort) m; ++ w = (u16 *)m; + #ifdef CONFIG_X86_64 +- w_int = (ulong32) ((ulong) w & 0x00000000FFFFFFFF); ++ w_int = (u32) ((ulong) w & 0x00000000FFFFFFFF); + #else +- w_int = (ulong32) (w); ++ w_int = (u32) (w); + #endif + if ((1 & w_int) && (len > 0)) { + REDUCE; + sum <<= 8; +- s_util.c[0] = *(puchar) w; +- w = (pushort) ((char *)w + 1); ++ s_util.c[0] = *(unsigned char *)w; ++ w = (u16 *)((char *)w + 1); + len--; + byte_swapped = 1; + } +@@ -3849,7 +3712,7 @@ ushort slic_eeprom_cksum(pchar m, int len) + sum += w[13]; + sum += w[14]; + sum += w[15]; +- w = (pushort) ((ulong) w + 16); /* verify */ ++ w = (u16 *)((ulong) w + 16); /* verify */ + } + len += 32; + while ((len -= 8) >= 0) { +@@ -3857,7 +3720,7 @@ ushort slic_eeprom_cksum(pchar m, int len) + sum += w[1]; + sum += w[2]; + sum += w[3]; +- w = (pushort) ((ulong) w + 4); /* verify */ ++ w = (u16 *)((ulong) w + 4); /* verify */ + } + len += 8; + if (len != 0 || byte_swapped != 0) { +@@ -3869,7 +3732,7 @@ ushort slic_eeprom_cksum(pchar m, int len) + sum <<= 8; + byte_swapped = 0; + if (len == -1) { +- s_util.c[1] = *(pchar) w; ++ s_util.c[1] = *(char *) w; + sum += s_util.s; + len = 0; + } else { +@@ -3877,7 +3740,7 @@ ushort slic_eeprom_cksum(pchar m, int len) + } + + } else if (len == -1) { +- s_util.c[0] = *(pchar) w; ++ s_util.c[0] = *(char *) w; + } + + if (len == -1) { +@@ -3889,17 +3752,17 @@ ushort slic_eeprom_cksum(pchar m, int len) + return (ushort) sum; + } + +-int slic_rspqueue_init(p_adapter_t adapter) ++static int slic_rspqueue_init(struct adapter *adapter) + { + int i; +- p_slic_rspqueue_t rspq = &adapter->rspqueue; +- p_slic_regs_t slic_regs = adapter->slic_regs; +- ulong32 paddrh = 0; ++ struct slic_rspqueue *rspq = &adapter->rspqueue; ++ __iomem struct slic_regs *slic_regs = adapter->slic_regs; ++ u32 paddrh = 0; + + DBG_MSG("slicoss: %s (%s) ENTER adapter[%p]\n", __func__, + adapter->netdev->name, adapter); + ASSERT(adapter->state == ADAPT_DOWN); +- SLIC_ZERO_MEMORY(rspq, sizeof(slic_rspqueue_t)); ++ memset(rspq, 0, sizeof(struct slic_rspqueue)); + + rspq->num_pages = SLIC_RSPQ_PAGES_GB; + +@@ -3914,12 +3777,12 @@ int slic_rspqueue_init(p_adapter_t adapter) + return STATUS_FAILURE; + } + #ifndef CONFIG_X86_64 +- ASSERT(((ulong32) rspq->vaddr[i] & 0xFFFFF000) == +- (ulong32) rspq->vaddr[i]); +- ASSERT(((ulong32) rspq->paddr[i] & 0xFFFFF000) == +- (ulong32) rspq->paddr[i]); ++ ASSERT(((u32) rspq->vaddr[i] & 0xFFFFF000) == ++ (u32) rspq->vaddr[i]); ++ ASSERT(((u32) rspq->paddr[i] & 0xFFFFF000) == ++ (u32) rspq->paddr[i]); + #endif +- SLIC_ZERO_MEMORY(rspq->vaddr[i], PAGE_SIZE); ++ memset(rspq->vaddr[i], 0, PAGE_SIZE); + /* DBG_MSG("slicoss: %s UPLOAD RSPBUFF Page pageix[%x] paddr[%p] " + "vaddr[%p]\n", + __func__, i, (void *)rspq->paddr[i], rspq->vaddr[i]); */ +@@ -3938,15 +3801,15 @@ int slic_rspqueue_init(p_adapter_t adapter) + } + rspq->offset = 0; + rspq->pageindex = 0; +- rspq->rspbuf = (p_slic_rspbuf_t) rspq->vaddr[0]; ++ rspq->rspbuf = (struct slic_rspbuf *)rspq->vaddr[0]; + DBG_MSG("slicoss: %s (%s) EXIT adapter[%p]\n", __func__, + adapter->netdev->name, adapter); + return STATUS_SUCCESS; + } + +-int slic_rspqueue_reset(p_adapter_t adapter) ++static int slic_rspqueue_reset(struct adapter *adapter) + { +- p_slic_rspqueue_t rspq = &adapter->rspqueue; ++ struct slic_rspqueue *rspq = &adapter->rspqueue; + + DBG_MSG("slicoss: %s (%s) ENTER adapter[%p]\n", __func__, + adapter->netdev->name, adapter); +@@ -3964,10 +3827,10 @@ int slic_rspqueue_reset(p_adapter_t adapter) + return STATUS_SUCCESS; + } + +-void slic_rspqueue_free(p_adapter_t adapter) ++static void slic_rspqueue_free(struct adapter *adapter) + { + int i; +- slic_rspqueue_t *rspq = &adapter->rspqueue; ++ struct slic_rspqueue *rspq = &adapter->rspqueue; + + DBG_MSG("slicoss: %s adapter[%p] port %d rspq[%p] FreeRSPQ\n", + __func__, adapter, adapter->physport, rspq); +@@ -3976,7 +3839,7 @@ void slic_rspqueue_free(p_adapter_t adapter) + DBG_MSG + ("slicoss: pci_free_consistent rspq->vaddr[%p] \ + paddr[%p]\n", +- rspq->vaddr[i], (pvoid) rspq->paddr[i]); ++ rspq->vaddr[i], (void *) rspq->paddr[i]); + pci_free_consistent(adapter->pcidev, PAGE_SIZE, + rspq->vaddr[i], rspq->paddr[i]); + } +@@ -3988,10 +3851,10 @@ void slic_rspqueue_free(p_adapter_t adapter) + rspq->rspbuf = NULL; + } + +-p_slic_rspbuf_t slic_rspqueue_getnext(p_adapter_t adapter) ++static struct slic_rspbuf *slic_rspqueue_getnext(struct adapter *adapter) + { +- p_slic_rspqueue_t rspq = &adapter->rspqueue; +- p_slic_rspbuf_t buf; ++ struct slic_rspqueue *rspq = &adapter->rspqueue; ++ struct slic_rspbuf *buf; + + if (!(rspq->rspbuf->status)) + return NULL; +@@ -4004,8 +3867,8 @@ p_slic_rspbuf_t slic_rspqueue_getnext(p_adapter_t adapter) + if (++rspq->offset < SLIC_RSPQ_BUFSINPAGE) { + rspq->rspbuf++; + #ifndef CONFIG_X86_64 +- ASSERT(((ulong32) rspq->rspbuf & 0xFFFFFFE0) == +- (ulong32) rspq->rspbuf); ++ ASSERT(((u32) rspq->rspbuf & 0xFFFFFFE0) == ++ (u32) rspq->rspbuf); + #endif + } else { + ASSERT(rspq->offset == SLIC_RSPQ_BUFSINPAGE); +@@ -4016,28 +3879,29 @@ p_slic_rspbuf_t slic_rspqueue_getnext(p_adapter_t adapter) + adapter->slic_regs->slic_addr_upper, 0, DONT_FLUSH); + rspq->pageindex = (++rspq->pageindex) % rspq->num_pages; + rspq->offset = 0; +- rspq->rspbuf = (p_slic_rspbuf_t) rspq->vaddr[rspq->pageindex]; ++ rspq->rspbuf = (struct slic_rspbuf *) ++ rspq->vaddr[rspq->pageindex]; + #ifndef CONFIG_X86_64 +- ASSERT(((ulong32) rspq->rspbuf & 0xFFFFF000) == +- (ulong32) rspq->rspbuf); ++ ASSERT(((u32) rspq->rspbuf & 0xFFFFF000) == ++ (u32) rspq->rspbuf); + #endif + } + #ifndef CONFIG_X86_64 +- ASSERT(((ulong32) buf & 0xFFFFFFE0) == (ulong32) buf); ++ ASSERT(((u32) buf & 0xFFFFFFE0) == (u32) buf); + #endif + return buf; + } + +-void slic_cmdqmem_init(p_adapter_t adapter) ++static void slic_cmdqmem_init(struct adapter *adapter) + { +- slic_cmdqmem_t *cmdqmem = &adapter->cmdqmem; ++ struct slic_cmdqmem *cmdqmem = &adapter->cmdqmem; + +- SLIC_ZERO_MEMORY(cmdqmem, sizeof(slic_cmdqmem_t)); ++ memset(cmdqmem, 0, sizeof(struct slic_cmdqmem)); + } + +-void slic_cmdqmem_free(p_adapter_t adapter) ++static void slic_cmdqmem_free(struct adapter *adapter) + { +- slic_cmdqmem_t *cmdqmem = &adapter->cmdqmem; ++ struct slic_cmdqmem *cmdqmem = &adapter->cmdqmem; + int i; + + DBG_MSG("slicoss: (%s) adapter[%p] port %d rspq[%p] Free CMDQ Memory\n", +@@ -4045,20 +3909,20 @@ void slic_cmdqmem_free(p_adapter_t adapter) + for (i = 0; i < SLIC_CMDQ_MAXPAGES; i++) { + if (cmdqmem->pages[i]) { + DBG_MSG("slicoss: %s Deallocate page CmdQPage[%p]\n", +- __func__, (pvoid) cmdqmem->pages[i]); ++ __func__, (void *) cmdqmem->pages[i]); + pci_free_consistent(adapter->pcidev, + PAGE_SIZE, +- (pvoid) cmdqmem->pages[i], ++ (void *) cmdqmem->pages[i], + cmdqmem->dma_pages[i]); + } + } +- SLIC_ZERO_MEMORY(cmdqmem, sizeof(slic_cmdqmem_t)); ++ memset(cmdqmem, 0, sizeof(struct slic_cmdqmem)); + } + +-pulong32 slic_cmdqmem_addpage(p_adapter_t adapter) ++static u32 *slic_cmdqmem_addpage(struct adapter *adapter) + { +- p_slic_cmdqmem_t cmdqmem = &adapter->cmdqmem; +- pulong32 pageaddr; ++ struct slic_cmdqmem *cmdqmem = &adapter->cmdqmem; ++ u32 *pageaddr; + + if (cmdqmem->pagecnt >= SLIC_CMDQ_MAXPAGES) + return NULL; +@@ -4068,32 +3932,32 @@ pulong32 slic_cmdqmem_addpage(p_adapter_t adapter) + if (!pageaddr) + return NULL; + #ifndef CONFIG_X86_64 +- ASSERT(((ulong32) pageaddr & 0xFFFFF000) == (ulong32) pageaddr); ++ ASSERT(((u32) pageaddr & 0xFFFFF000) == (u32) pageaddr); + #endif + cmdqmem->pages[cmdqmem->pagecnt] = pageaddr; + cmdqmem->pagecnt++; + return pageaddr; + } + +-int slic_cmdq_init(p_adapter_t adapter) ++static int slic_cmdq_init(struct adapter *adapter) + { + int i; +- pulong32 pageaddr; ++ u32 *pageaddr; + + DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter); + ASSERT(adapter->state == ADAPT_DOWN); +- SLIC_ZERO_MEMORY(&adapter->cmdq_all, sizeof(slic_cmdqueue_t)); +- SLIC_ZERO_MEMORY(&adapter->cmdq_free, sizeof(slic_cmdqueue_t)); +- SLIC_ZERO_MEMORY(&adapter->cmdq_done, sizeof(slic_cmdqueue_t)); +- SLIC_INIT_SPINLOCK(adapter->cmdq_all.lock); +- SLIC_INIT_SPINLOCK(adapter->cmdq_free.lock); +- SLIC_INIT_SPINLOCK(adapter->cmdq_done.lock); ++ memset(&adapter->cmdq_all, 0, sizeof(struct slic_cmdqueue)); ++ memset(&adapter->cmdq_free, 0, sizeof(struct slic_cmdqueue)); ++ memset(&adapter->cmdq_done, 0, sizeof(struct slic_cmdqueue)); ++ spin_lock_init(&adapter->cmdq_all.lock.lock); ++ spin_lock_init(&adapter->cmdq_free.lock.lock); ++ spin_lock_init(&adapter->cmdq_done.lock.lock); + slic_cmdqmem_init(adapter); + adapter->slic_handle_ix = 1; + for (i = 0; i < SLIC_CMDQ_INITPAGES; i++) { + pageaddr = slic_cmdqmem_addpage(adapter); + #ifndef CONFIG_X86_64 +- ASSERT(((ulong32) pageaddr & 0xFFFFF000) == (ulong32) pageaddr); ++ ASSERT(((u32) pageaddr & 0xFFFFF000) == (u32) pageaddr); + #endif + if (!pageaddr) { + slic_cmdq_free(adapter); +@@ -4107,9 +3971,9 @@ int slic_cmdq_init(p_adapter_t adapter) + return STATUS_SUCCESS; + } + +-void slic_cmdq_free(p_adapter_t adapter) ++static void slic_cmdq_free(struct adapter *adapter) + { +- p_slic_hostcmd_t cmd; ++ struct slic_hostcmd *cmd; + + DBG_MSG("slicoss: %s adapter[%p] port %d FreeCommandsFrom CMDQ\n", + __func__, adapter, adapter->physport); +@@ -4126,21 +3990,23 @@ void slic_cmdq_free(p_adapter_t adapter) + } + cmd = cmd->next_all; + } +- SLIC_ZERO_MEMORY(&adapter->cmdq_all, sizeof(slic_cmdqueue_t)); +- SLIC_ZERO_MEMORY(&adapter->cmdq_free, sizeof(slic_cmdqueue_t)); +- SLIC_ZERO_MEMORY(&adapter->cmdq_done, sizeof(slic_cmdqueue_t)); ++ memset(&adapter->cmdq_all, 0, sizeof(struct slic_cmdqueue)); ++ memset(&adapter->cmdq_free, 0, sizeof(struct slic_cmdqueue)); ++ memset(&adapter->cmdq_done, 0, sizeof(struct slic_cmdqueue)); + slic_cmdqmem_free(adapter); + } + +-void slic_cmdq_reset(p_adapter_t adapter) ++static void slic_cmdq_reset(struct adapter *adapter) + { +- p_slic_hostcmd_t hcmd; ++ struct slic_hostcmd *hcmd; + struct sk_buff *skb; +- ulong32 outstanding; ++ u32 outstanding; + + DBG_MSG("%s ENTER adapter[%p]\n", __func__, adapter); +- SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->cmdq_free.lock); +- SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->cmdq_done.lock); ++ spin_lock_irqsave(&adapter->cmdq_free.lock.lock, ++ adapter->cmdq_free.lock.flags); ++ spin_lock_irqsave(&adapter->cmdq_done.lock.lock, ++ adapter->cmdq_done.lock.flags); + outstanding = adapter->cmdq_all.count - adapter->cmdq_done.count; + outstanding -= adapter->cmdq_free.count; + hcmd = adapter->cmdq_all.head; +@@ -4174,31 +4040,33 @@ void slic_cmdq_reset(p_adapter_t adapter) + DBG_ERROR("%s free_count %d != all count %d\n", __func__, + adapter->cmdq_free.count, adapter->cmdq_all.count); + } +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->cmdq_done.lock); +- SLIC_RELEASE_IRQ_SPINLOCK(adapter->cmdq_free.lock); ++ spin_unlock_irqrestore(&adapter->cmdq_done.lock.lock, ++ adapter->cmdq_done.lock.flags); ++ spin_unlock_irqrestore(&adapter->cmdq_free.lock.lock, ++ adapter->cmdq_free.lock.flags); + DBG_MSG("%s EXIT adapter[%p]\n", __func__, adapter); + } + +-void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page) ++static void slic_cmdq_addcmdpage(struct adapter *adapter, u32 *page) + { +- p_slic_hostcmd_t cmd; +- p_slic_hostcmd_t prev; +- p_slic_hostcmd_t tail; +- p_slic_cmdqueue_t cmdq; ++ struct slic_hostcmd *cmd; ++ struct slic_hostcmd *prev; ++ struct slic_hostcmd *tail; ++ struct slic_cmdqueue *cmdq; + int cmdcnt; +- pvoid cmdaddr; ++ void *cmdaddr; + ulong phys_addr; +- ulong32 phys_addrl; +- ulong32 phys_addrh; +- pslic_handle_t pslic_handle; ++ u32 phys_addrl; ++ u32 phys_addrh; ++ struct slic_handle *pslic_handle; + + cmdaddr = page; +- cmd = (p_slic_hostcmd_t) cmdaddr; ++ cmd = (struct slic_hostcmd *)cmdaddr; + /* DBG_MSG("CMDQ Page addr[%p] ix[%d] pfree[%p]\n", cmdaddr, slic_handle_ix, + adapter->pfree_slic_handles); */ + cmdcnt = 0; + +- phys_addr = SLIC_GET_PHYSICAL_ADDRESS((void *)page); ++ phys_addr = virt_to_bus((void *)page); + phys_addrl = SLIC_GET_ADDR_LOW(phys_addr); + phys_addrh = SLIC_GET_ADDR_HIGH(phys_addr); + +@@ -4214,7 +4082,7 @@ void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page) + &adapter->slic_handles[pslic_handle->token. + handle_index]); + pslic_handle->type = SLIC_HANDLE_CMD; +- pslic_handle->address = (pvoid) cmd; ++ pslic_handle->address = (void *) cmd; + pslic_handle->offset = (ushort) adapter->slic_handle_ix++; + pslic_handle->other_handle = NULL; + pslic_handle->next = NULL; +@@ -4230,7 +4098,7 @@ void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page) + phys_addrl += SLIC_HOSTCMD_SIZE; + cmdaddr += SLIC_HOSTCMD_SIZE; + +- cmd = (p_slic_hostcmd_t) cmdaddr; ++ cmd = (struct slic_hostcmd *)cmdaddr; + cmdcnt++; + } + +@@ -4240,36 +4108,37 @@ void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page) + ASSERT(VALID_ADDRESS(prev)); + cmdq->head = prev; + cmdq = &adapter->cmdq_free; +- SLIC_ACQUIRE_IRQ_SPINLOCK(cmdq->lock); ++ spin_lock_irqsave(&cmdq->lock.lock, cmdq->lock.flags); + cmdq->count += cmdcnt; /* SLIC_CMDQ_CMDSINPAGE; mooktodo */ + tail->next = cmdq->head; + ASSERT(VALID_ADDRESS(prev)); + cmdq->head = prev; +- SLIC_RELEASE_IRQ_SPINLOCK(cmdq->lock); ++ spin_unlock_irqrestore(&cmdq->lock.lock, cmdq->lock.flags); + } + +-p_slic_hostcmd_t slic_cmdq_getfree(p_adapter_t adapter) ++static struct slic_hostcmd *slic_cmdq_getfree(struct adapter *adapter) + { +- p_slic_cmdqueue_t cmdq = &adapter->cmdq_free; +- p_slic_hostcmd_t cmd = NULL; ++ struct slic_cmdqueue *cmdq = &adapter->cmdq_free; ++ struct slic_hostcmd *cmd = NULL; + + lock_and_retry: +- SLIC_ACQUIRE_IRQ_SPINLOCK(cmdq->lock); ++ spin_lock_irqsave(&cmdq->lock.lock, cmdq->lock.flags); + retry: + cmd = cmdq->head; + if (cmd) { + cmdq->head = cmd->next; + cmdq->count--; +- SLIC_RELEASE_IRQ_SPINLOCK(cmdq->lock); ++ spin_unlock_irqrestore(&cmdq->lock.lock, cmdq->lock.flags); + } else { + slic_cmdq_getdone(adapter); + cmd = cmdq->head; + if (cmd) { + goto retry; + } else { +- pulong32 pageaddr; ++ u32 *pageaddr; + +- SLIC_RELEASE_IRQ_SPINLOCK(cmdq->lock); ++ spin_unlock_irqrestore(&cmdq->lock.lock, ++ cmdq->lock.flags); + pageaddr = slic_cmdqmem_addpage(adapter); + if (pageaddr) { + slic_cmdq_addcmdpage(adapter, pageaddr); +@@ -4280,13 +4149,13 @@ retry: + return cmd; + } + +-void slic_cmdq_getdone(p_adapter_t adapter) ++static void slic_cmdq_getdone(struct adapter *adapter) + { +- p_slic_cmdqueue_t done_cmdq = &adapter->cmdq_done; +- p_slic_cmdqueue_t free_cmdq = &adapter->cmdq_free; ++ struct slic_cmdqueue *done_cmdq = &adapter->cmdq_done; ++ struct slic_cmdqueue *free_cmdq = &adapter->cmdq_free; + + ASSERT(free_cmdq->head == NULL); +- SLIC_ACQUIRE_IRQ_SPINLOCK(done_cmdq->lock); ++ spin_lock_irqsave(&done_cmdq->lock.lock, done_cmdq->lock.flags); + ASSERT(VALID_ADDRESS(done_cmdq->head)); + + free_cmdq->head = done_cmdq->head; +@@ -4294,28 +4163,15 @@ void slic_cmdq_getdone(p_adapter_t adapter) + done_cmdq->head = NULL; + done_cmdq->tail = NULL; + done_cmdq->count = 0; +- SLIC_RELEASE_IRQ_SPINLOCK(done_cmdq->lock); ++ spin_unlock_irqrestore(&done_cmdq->lock.lock, done_cmdq->lock.flags); + } + +-void slic_cmdq_putdone(p_adapter_t adapter, p_slic_hostcmd_t cmd) ++static void slic_cmdq_putdone_irq(struct adapter *adapter, ++ struct slic_hostcmd *cmd) + { +- p_slic_cmdqueue_t cmdq = &adapter->cmdq_done; ++ struct slic_cmdqueue *cmdq = &adapter->cmdq_done; + +- SLIC_ACQUIRE_IRQ_SPINLOCK(cmdq->lock); +- cmd->busy = 0; +- ASSERT(VALID_ADDRESS(cmdq->head)); +- cmd->next = cmdq->head; +- ASSERT(VALID_ADDRESS(cmd)); +- cmdq->head = cmd; +- cmdq->count++; +- SLIC_RELEASE_IRQ_SPINLOCK(cmdq->lock); +-} +- +-void slic_cmdq_putdone_irq(p_adapter_t adapter, p_slic_hostcmd_t cmd) +-{ +- p_slic_cmdqueue_t cmdq = &adapter->cmdq_done; +- +- SLIC_ACQUIRE_SPINLOCK(cmdq->lock); ++ spin_lock(&cmdq->lock.lock); + cmd->busy = 0; + ASSERT(VALID_ADDRESS(cmdq->head)); + cmd->next = cmdq->head; +@@ -4324,13 +4180,13 @@ void slic_cmdq_putdone_irq(p_adapter_t adapter, p_slic_hostcmd_t cmd) + cmdq->count++; + if ((adapter->xmitq_full) && (cmdq->count > 10)) + netif_wake_queue(adapter->netdev); +- SLIC_RELEASE_SPINLOCK(cmdq->lock); ++ spin_unlock(&cmdq->lock.lock); + } + +-int slic_rcvqueue_init(p_adapter_t adapter) ++static int slic_rcvqueue_init(struct adapter *adapter) + { + int i, count; +- p_slic_rcvqueue_t rcvq = &adapter->rcvqueue; ++ struct slic_rcvqueue *rcvq = &adapter->rcvqueue; + + DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter); + ASSERT(adapter->state == ADAPT_DOWN); +@@ -4353,9 +4209,9 @@ int slic_rcvqueue_init(p_adapter_t adapter) + return STATUS_SUCCESS; + } + +-int slic_rcvqueue_reset(p_adapter_t adapter) ++static int slic_rcvqueue_reset(struct adapter *adapter) + { +- p_slic_rcvqueue_t rcvq = &adapter->rcvqueue; ++ struct slic_rcvqueue *rcvq = &adapter->rcvqueue; + + DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter); + ASSERT(adapter->state == ADAPT_DOWN); +@@ -4371,9 +4227,9 @@ int slic_rcvqueue_reset(p_adapter_t adapter) + return STATUS_SUCCESS; + } + +-void slic_rcvqueue_free(p_adapter_t adapter) ++static void slic_rcvqueue_free(struct adapter *adapter) + { +- slic_rcvqueue_t *rcvq = &adapter->rcvqueue; ++ struct slic_rcvqueue *rcvq = &adapter->rcvqueue; + struct sk_buff *skb; + + while (rcvq->head) { +@@ -4386,16 +4242,16 @@ void slic_rcvqueue_free(p_adapter_t adapter) + rcvq->count = 0; + } + +-struct sk_buff *slic_rcvqueue_getnext(p_adapter_t adapter) ++static struct sk_buff *slic_rcvqueue_getnext(struct adapter *adapter) + { +- p_slic_rcvqueue_t rcvq = &adapter->rcvqueue; ++ struct slic_rcvqueue *rcvq = &adapter->rcvqueue; + struct sk_buff *skb; +- p_slic_rcvbuf_t rcvbuf; ++ struct slic_rcvbuf *rcvbuf; + int count; + + if (rcvq->count) { + skb = rcvq->head; +- rcvbuf = (p_slic_rcvbuf_t) skb->head; ++ rcvbuf = (struct slic_rcvbuf *)skb->head; + ASSERT(rcvbuf); + + if (rcvbuf->status & IRHDDR_SVALID) { +@@ -4420,30 +4276,31 @@ struct sk_buff *slic_rcvqueue_getnext(p_adapter_t adapter) + return skb; + } + +-int slic_rcvqueue_fill(p_adapter_t adapter) ++static int slic_rcvqueue_fill(struct adapter *adapter) + { +- pvoid paddr; +- ulong32 paddrl; +- ulong32 paddrh; +- p_slic_rcvqueue_t rcvq = &adapter->rcvqueue; ++ void *paddr; ++ u32 paddrl; ++ u32 paddrh; ++ struct slic_rcvqueue *rcvq = &adapter->rcvqueue; + int i = 0; + + while (i < SLIC_RCVQ_FILLENTRIES) { +- p_slic_rcvbuf_t rcvbuf; ++ struct slic_rcvbuf *rcvbuf; + struct sk_buff *skb; + #ifdef KLUDGE_FOR_4GB_BOUNDARY + retry_rcvqfill: + #endif + skb = alloc_skb(SLIC_RCVQ_RCVBUFSIZE, GFP_ATOMIC); + if (skb) { +- paddr = (void *)SLIC_GET_DMA_ADDRESS_READ(adapter, ++ paddr = (void *)pci_map_single(adapter->pcidev, + skb->data, +- SLIC_RCVQ_RCVBUFSIZE); ++ SLIC_RCVQ_RCVBUFSIZE, ++ PCI_DMA_FROMDEVICE); + paddrl = SLIC_GET_ADDR_LOW(paddr); + paddrh = SLIC_GET_ADDR_HIGH(paddr); + + skb->len = SLIC_RCVBUF_HEADSIZE; +- rcvbuf = (p_slic_rcvbuf_t) skb->head; ++ rcvbuf = (struct slic_rcvbuf *)skb->head; + rcvbuf->status = 0; + skb->next = NULL; + #ifdef KLUDGE_FOR_4GB_BOUNDARY +@@ -4479,13 +4336,13 @@ retry_rcvqfill: + #endif + if (paddrh == 0) { + WRITE_REG(adapter->slic_regs->slic_hbar, +- (ulong32) paddrl, DONT_FLUSH); ++ (u32) paddrl, DONT_FLUSH); + } else { + WRITE_REG64(adapter, + adapter->slic_regs->slic_hbar64, +- (ulong32) paddrl, ++ (u32) paddrl, + adapter->slic_regs->slic_addr_upper, +- (ulong32) paddrh, DONT_FLUSH); ++ (u32) paddrh, DONT_FLUSH); + } + if (rcvq->head) + rcvq->tail->next = skb; +@@ -4505,18 +4362,18 @@ retry_rcvqfill: + return i; + } + +-ulong32 slic_rcvqueue_reinsert(p_adapter_t adapter, struct sk_buff *skb) ++static u32 slic_rcvqueue_reinsert(struct adapter *adapter, struct sk_buff *skb) + { +- p_slic_rcvqueue_t rcvq = &adapter->rcvqueue; +- pvoid paddr; +- ulong32 paddrl; +- ulong32 paddrh; +- p_slic_rcvbuf_t rcvbuf = (p_slic_rcvbuf_t) skb->head; ++ struct slic_rcvqueue *rcvq = &adapter->rcvqueue; ++ void *paddr; ++ u32 paddrl; ++ u32 paddrh; ++ struct slic_rcvbuf *rcvbuf = (struct slic_rcvbuf *)skb->head; + + ASSERT(skb->len == SLIC_RCVBUF_HEADSIZE); +- paddr = (void *)SLIC_GET_DMA_ADDRESS_READ(adapter, +- skb->head, +- SLIC_RCVQ_RCVBUFSIZE); ++ ++ paddr = (void *)pci_map_single(adapter->pcidev, skb->head, ++ SLIC_RCVQ_RCVBUFSIZE, PCI_DMA_FROMDEVICE); + rcvbuf->status = 0; + skb->next = NULL; + +@@ -4536,7 +4393,7 @@ ulong32 slic_rcvqueue_reinsert(p_adapter_t adapter, struct sk_buff *skb) + rcvq->count); + } + if (paddrh == 0) { +- WRITE_REG(adapter->slic_regs->slic_hbar, (ulong32) paddrl, ++ WRITE_REG(adapter->slic_regs->slic_hbar, (u32) paddrl, + DONT_FLUSH); + } else { + WRITE_REG64(adapter, +@@ -4558,10 +4415,10 @@ static int slic_debug_card_show(struct seq_file *seq, void *v) + { + #ifdef MOOKTODO + int i; +- p_sliccard_t card = seq->private; ++ struct sliccard *card = seq->private; + pslic_config_t config = &card->config; +- puchar fru = (puchar) (&card->config.atk_fru); +- puchar oemfru = (puchar) (&card->config.OemFru); ++ unsigned char *fru = (unsigned char *)(&card->config.atk_fru); ++ unsigned char *oemfru = (unsigned char *)(&card->config.OemFru); + #endif + + seq_printf(seq, "driver_version : %s", slic_proc_version); +@@ -4600,7 +4457,7 @@ static int slic_debug_card_show(struct seq_file *seq, void *v) + seq_printf(seq, " IF Init State Duplex/Speed irq\n"); + seq_printf(seq, " -------------------------------\n"); + for (i = 0; i < card->adapters_allocated; i++) { +- p_adapter_t adapter; ++ struct adapter *adapter; + + adapter = card->adapter[i]; + if (adapter) { +@@ -4768,7 +4625,7 @@ static int slic_debug_card_show(struct seq_file *seq, void *v) + + static int slic_debug_adapter_show(struct seq_file *seq, void *v) + { +- p_adapter_t adapter = seq->private; ++ struct adapter *adapter = seq->private; + + if ((adapter->netdev) && (adapter->netdev->name)) { + seq_printf(seq, "info: interface : %s\n", +@@ -4801,21 +4658,21 @@ static int slic_debug_adapter_show(struct seq_file *seq, void *v) + seq_printf(seq, "rx stats: unicasts : %8.8X\n", + adapter->rcv_unicasts); + seq_printf(seq, "rx stats: errors : %8.8X\n", +- (ulong32) adapter->slic_stats.iface.rcv_errors); ++ (u32) adapter->slic_stats.iface.rcv_errors); + seq_printf(seq, "rx stats: Missed errors : %8.8X\n", +- (ulong32) adapter->slic_stats.iface.rcv_discards); ++ (u32) adapter->slic_stats.iface.rcv_discards); + seq_printf(seq, "rx stats: drops : %8.8X\n", +- (ulong32) adapter->rcv_drops); ++ (u32) adapter->rcv_drops); + seq_printf(seq, "tx stats: packets : %8.8lX\n", + adapter->stats.tx_packets); + seq_printf(seq, "tx stats: bytes : %8.8lX\n", + adapter->stats.tx_bytes); + seq_printf(seq, "tx stats: errors : %8.8X\n", +- (ulong32) adapter->slic_stats.iface.xmt_errors); ++ (u32) adapter->slic_stats.iface.xmt_errors); + seq_printf(seq, "rx stats: multicasts : %8.8lX\n", + adapter->stats.multicast); + seq_printf(seq, "tx stats: collision errors : %8.8X\n", +- (ulong32) adapter->slic_stats.iface.xmit_collisions); ++ (u32) adapter->slic_stats.iface.xmit_collisions); + seq_printf(seq, "perf: Max rcv frames/isr : %8.8X\n", + adapter->max_isr_rcvs); + seq_printf(seq, "perf: Rcv interrupt yields : %8.8X\n", +@@ -4905,11 +4762,11 @@ static const struct file_operations slic_debug_card_fops = { + .release = single_release, + }; + +-static void slic_debug_adapter_create(p_adapter_t adapter) ++static void slic_debug_adapter_create(struct adapter *adapter) + { + struct dentry *d; + char name[7]; +- p_sliccard_t card = adapter->card; ++ struct sliccard *card = adapter->card; + + if (!card->debugfs_dir) + return; +@@ -4924,7 +4781,7 @@ static void slic_debug_adapter_create(p_adapter_t adapter) + adapter->debugfs_entry = d; + } + +-static void slic_debug_adapter_destroy(p_adapter_t adapter) ++static void slic_debug_adapter_destroy(struct adapter *adapter) + { + if (adapter->debugfs_entry) { + debugfs_remove(adapter->debugfs_entry); +@@ -4932,7 +4789,7 @@ static void slic_debug_adapter_destroy(p_adapter_t adapter) + } + } + +-static void slic_debug_card_create(p_sliccard_t card) ++static void slic_debug_card_create(struct sliccard *card) + { + struct dentry *d; + char name[IFNAMSIZ]; +@@ -4955,12 +4812,12 @@ static void slic_debug_card_create(p_sliccard_t card) + } + } + +-static void slic_debug_card_destroy(p_sliccard_t card) ++static void slic_debug_card_destroy(struct sliccard *card) + { + int i; + + for (i = 0; i < card->card_size; i++) { +- p_adapter_t adapter; ++ struct adapter *adapter; + + adapter = card->adapter[i]; + if (adapter) +@@ -5013,17 +4870,17 @@ static void slic_debug_cleanup(void) + + #include + +-pvoid slic_dump_handle; /* thread handle */ ++void *slic_dump_handle; /* thread handle */ + + /* + * These are the only things you should do on a core-file: use only these + * functions to write out all the necessary info. + */ +-static int slic_dump_seek(struct file *SLIChandle, ulong32 file_offset) ++static int slic_dump_seek(struct file *SLIChandle, u32 file_offset) + { + if (SLIChandle->f_pos != file_offset) { + /*DBG_MSG("slic_dump_seek now needed [%x : %x]\n", +- (ulong32)SLIChandle->f_pos, (ulong32)file_offset); */ ++ (u32)SLIChandle->f_pos, (u32)file_offset); */ + if (SLIChandle->f_op->llseek) { + if (SLIChandle->f_op-> + llseek(SLIChandle, file_offset, 0) != file_offset) +@@ -5035,11 +4892,11 @@ static int slic_dump_seek(struct file *SLIChandle, ulong32 file_offset) + return 1; + } + +-static int slic_dump_write(p_sliccard_t card, +- const void *addr, int size, ulong32 file_offset) ++static int slic_dump_write(struct sliccard *card, ++ const void *addr, int size, u32 file_offset) + { + int r = 1; +- ulong32 result = 0; ++ u32 result = 0; + struct file *SLIChandle = card->dumphandle; + + #ifdef HISTORICAL /* legacy */ +@@ -5069,7 +4926,7 @@ static int slic_dump_write(p_sliccard_t card, + return r; + } + +-uint slic_init_dump_thread(p_sliccard_t card) ++static uint slic_init_dump_thread(struct sliccard *card) + { + card->dump_task_id = kthread_run(slic_dump_thread, (void *)card, 0); + +@@ -5082,17 +4939,17 @@ uint slic_init_dump_thread(p_sliccard_t card) + return STATUS_SUCCESS; + } + +-int slic_dump_thread(void *context) ++static int slic_dump_thread(void *context) + { +- p_sliccard_t card = (p_sliccard_t) context; +- p_adapter_t adapter; +- p_adapter_t dump_adapter = NULL; +- ulong32 dump_complete = 0; +- ulong32 delay = SLIC_SECS_TO_JIFFS(PING_TIMER_INTERVAL); +- p_slic_regs_t pregs; +- ulong32 i; +- p_slic_upr_t upr, uprnext; +- ulong32 dump_card; ++ struct sliccard *card = (struct sliccard *)context; ++ struct adapter *adapter; ++ struct adapter *dump_adapter = NULL; ++ u32 dump_complete = 0; ++ u32 delay = SLIC_SECS_TO_JIFFS(PING_TIMER_INTERVAL); ++ struct slic_regs *pregs; ++ u32 i; ++ struct slic_upr *upr, *uprnext; ++ u32 dump_card; + + ASSERT(card); + +@@ -5248,19 +5105,20 @@ int slic_dump_thread(void *context) + * now. + */ + if (!card->pingstatus) { +- SLIC_ACQUIRE_IRQ_SPINLOCK +- (adapter->upr_lock); ++ spin_lock_irqsave( ++ &adapter->upr_lock.lock, ++ adapter->upr_lock.flags); + upr = adapter->upr_list; + while (upr) { + uprnext = upr->next; +- SLIC_DEALLOCATE_MEM +- (upr); ++ kfree(upr); + upr = uprnext; + } + adapter->upr_list = 0; + adapter->upr_busy = 0; +- SLIC_RELEASE_IRQ_SPINLOCK +- (adapter->upr_lock); ++ spin_unlock_irqrestore( ++ &adapter->upr_lock.lock, ++ adapter->upr_lock.flags); + } + + slic_dump_card(card, FALSE); +@@ -5340,13 +5198,13 @@ end_thread: + * value is used as our suffix for our dump path. The + * value is incremented and written back to the file + */ +-uchar slic_get_dump_index(pchar path) ++static unsigned char slic_get_dump_index(char *path) + { +- uchar index = 0; ++ unsigned char index = 0; + #ifdef SLIC_DUMP_INDEX_SUPPORT +- ulong32 status; +- pvoid FileHandle; +- ulong32 offset; ++ u32 status; ++ void *FileHandle; ++ u32 offset; + + offset = 0; + +@@ -5356,7 +5214,7 @@ uchar slic_get_dump_index(pchar path) + status = create_file(&FileHandle); + + if (status != STATUS_SUCCESS) +- return (uchar) 0; ++ return (unsigned char) 0; + + status = read_file(FileHandle, &index, 1, &offset); + +@@ -5371,7 +5229,7 @@ uchar slic_get_dump_index(pchar path) + return index; + } + +-struct file *slic_dump_open_file(p_sliccard_t card) ++static struct file *slic_dump_open_file(struct sliccard *card) + { + struct file *SLIChandle = NULL; + struct dentry *dentry = NULL; +@@ -5434,7 +5292,7 @@ end_slicdump: + return NULL; + } + +-void slic_dump_close_file(p_sliccard_t card) ++static void slic_dump_close_file(struct sliccard *card) + { + + /* DBG_MSG("[slicmon] slic_dump_CLOSE_file close SLIChandle[%p]\n", +@@ -5445,19 +5303,19 @@ void slic_dump_close_file(p_sliccard_t card) + set_fs(card->dumpfile_fs); + } + +-ulong32 slic_dump_card(p_sliccard_t card, boolean resume) ++static u32 slic_dump_card(struct sliccard *card, bool resume) + { +- p_adapter_t adapter = card->master; +- ulong32 status; +- ulong32 queue; +- ulong32 len, offset; +- ulong32 sram_size, dram_size, regs; ++ struct adapter *adapter = card->master; ++ u32 status; ++ u32 queue; ++ u32 len, offset; ++ u32 sram_size, dram_size, regs; + sliccore_hdr_t corehdr; +- ulong32 file_offset; +- pchar namestr; +- ulong32 i; +- ulong32 max_queues = 0; +- ulong32 result; ++ u32 file_offset; ++ char *namestr; ++ u32 i; ++ u32 max_queues = 0; ++ u32 result; + + card->dumphandle = slic_dump_open_file(card); + +@@ -5672,12 +5530,12 @@ ulong32 slic_dump_card(p_sliccard_t card, boolean resume) + max_queues = SLIC_MAX_QUEUE; + + for (queue = 0; queue < max_queues; queue++) { +- pulong32 qarray = (pulong32) card->dumpbuffer; +- ulong32 qarray_physl = card->dumpbuffer_physl; +- ulong32 qarray_physh = card->dumpbuffer_physh; +- ulong32 qstart; +- ulong32 qdelta; +- ulong32 qtotal = 0; ++ u32 *qarray = (u32 *) card->dumpbuffer; ++ u32 qarray_physl = card->dumpbuffer_physl; ++ u32 qarray_physh = card->dumpbuffer_physh; ++ u32 qstart; ++ u32 qdelta; ++ u32 qtotal = 0; + + DBG_MSG("[slicmon] Start Dump of QUEUE #0x%x\n", (uint) queue); + +@@ -5823,9 +5681,9 @@ done: + return status; + } + +-ulong32 slic_dump_halt(p_sliccard_t card, uchar proc) ++static u32 slic_dump_halt(struct sliccard *card, unsigned char proc) + { +- puchar cmd = card->cmdbuffer; ++ unsigned char *cmd = card->cmdbuffer; + + *cmd = COMMAND_BYTE(CMD_HALT, 0, proc); + +@@ -5834,9 +5692,9 @@ ulong32 slic_dump_halt(p_sliccard_t card, uchar proc) + card->cmdbuffer_physh, 0, 0); + } + +-ulong32 slic_dump_resume(p_sliccard_t card, uchar proc) ++static u32 slic_dump_resume(struct sliccard *card, unsigned char proc) + { +- puchar cmd = card->cmdbuffer; ++ unsigned char *cmd = card->cmdbuffer; + + *cmd = COMMAND_BYTE(CMD_RUN, 0, proc); + +@@ -5845,7 +5703,7 @@ ulong32 slic_dump_resume(p_sliccard_t card, uchar proc) + card->cmdbuffer_physh, 0, 0); + } + +-ulong32 slic_dump_reg(p_sliccard_t card, uchar proc) ++static u32 slic_dump_reg(struct sliccard *card, unsigned char proc) + { + pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer; + +@@ -5861,8 +5719,8 @@ ulong32 slic_dump_reg(p_sliccard_t card, uchar proc) + card->dumpbuffer_physh); + } + +-ulong32 slic_dump_data(p_sliccard_t card, +- ulong32 addr, ushort count, uchar desc) ++static u32 slic_dump_data(struct sliccard *card, ++ u32 addr, ushort count, unsigned char desc) + { + pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer; + +@@ -5878,8 +5736,8 @@ ulong32 slic_dump_data(p_sliccard_t card, + card->dumpbuffer_physh); + } + +-ulong32 slic_dump_queue(p_sliccard_t card, +- ulong32 addr, ulong32 buf_physh, ulong32 queue) ++static u32 slic_dump_queue(struct sliccard *card, ++ u32 addr, u32 buf_physh, u32 queue) + { + pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer; + +@@ -5894,7 +5752,8 @@ ulong32 slic_dump_queue(p_sliccard_t card, + addr, card->dumpbuffer_physh); + } + +-ulong32 slic_dump_load_queue(p_sliccard_t card, ulong32 data, ulong32 queue) ++static u32 slic_dump_load_queue(struct sliccard *card, u32 data, ++ u32 queue) + { + pdump_cmd_t load = (pdump_cmd_t) card->cmdbuffer; + +@@ -5908,8 +5767,8 @@ ulong32 slic_dump_load_queue(p_sliccard_t card, ulong32 data, ulong32 queue) + card->cmdbuffer_physh, 0, 0); + } + +-ulong32 slic_dump_cam(p_sliccard_t card, +- ulong32 addr, ulong32 count, uchar desc) ++static u32 slic_dump_cam(struct sliccard *card, ++ u32 addr, u32 count, unsigned char desc) + { + pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer; + +@@ -5924,15 +5783,15 @@ ulong32 slic_dump_cam(p_sliccard_t card, + addr, card->dumpbuffer_physh); + } + +-ulong32 slic_dump_send_cmd(p_sliccard_t card, +- ulong32 cmd_physl, +- ulong32 cmd_physh, +- ulong32 buf_physl, ulong32 buf_physh) ++static u32 slic_dump_send_cmd(struct sliccard *card, ++ u32 cmd_physl, ++ u32 cmd_physh, ++ u32 buf_physl, u32 buf_physh) + { + ulong timeout = SLIC_MS_TO_JIFFIES(500); /* 500 msec */ +- ulong32 attempts = 5; +- ulong32 delay = SLIC_MS_TO_JIFFIES(10); /* 10 msec */ +- p_adapter_t adapter = card->master; ++ u32 attempts = 5; ++ u32 delay = SLIC_MS_TO_JIFFIES(10); /* 10 msec */ ++ struct adapter *adapter = card->master; + + ASSERT(adapter); + do { +-- +1.6.0.2 +