--- /dev/null
+From e9eff9d6a0d14fa2e85953ce4115d243ff575e78 Mon Sep 17 00:00:00 2001
+From: Lior Dotan <liodot@gmail.com>
+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 <liodot@gmail.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+---
+ 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 <stdarg.h>
+
+-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
+
projects / people / teissler / ipfire-2.x.git / blobdiff