Staging: SLICOSS: lots of checkpatch fixes

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

@@ -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,
 };

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] =
 {

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,
 };

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,
 };
 

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] =
 {

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

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)(&reg)) - ((puchar)adapter->slic_regs); \
+			((unsigned char *)(&reg)) - ((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)(&reg)) - ((puchar)adapter->slic_regs); \
+			((unsigned char *)(&reg)) - ((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), (&reg), (value), (&regh), (valh), (flush))
 #endif
-#define READ_REG(reg, flush)                    slic_reg32_read((&reg), (flush))
-#define READ_REGP16(reg, flush)                 slic_reg16_read((&reg), (flush))
 
 #endif  /* _SLIC_OS_SPECIFIC_H_  */
 

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

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)                                                             \

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.

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()
 

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

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) &ether_frame->ether_dhost[0];
-	pushort dhost2 = (pushort) &ether_frame->ether_dhost[4];
-	boolean equaladdr;
+	u32 opts = adapter->macopts;
+	u32 *dhost4 = (u32 *)&ether_frame->ether_dhost[0];
+	u16 *dhost2 = (u16 *)&ether_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 {