aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLior Dotan <liodot@gmail.com>2008-10-04 00:10:28 -0400
committerGreg Kroah-Hartman <gregkh@suse.de>2008-10-10 18:31:13 -0400
commite9eff9d6a0d14fa2e85953ce4115d243ff575e78 (patch)
treef18c27169b41dcc9826057e964e1dbc588c058da
parentdf20d69ec968b33526461457c219ad4ba8ba8ac8 (diff)
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>
Diffstat
-rw-r--r--drivers/staging/slicoss/gbdownload.h10
-rw-r--r--drivers/staging/slicoss/gbrcvucode.h7
-rw-r--r--drivers/staging/slicoss/oasisdbgdownload.h10
-rw-r--r--drivers/staging/slicoss/oasisdownload.h10
-rw-r--r--drivers/staging/slicoss/oasisrcvucode.h6
-rw-r--r--drivers/staging/slicoss/slic.h485
-rw-r--r--drivers/staging/slicoss/slic_os.h85
-rw-r--r--drivers/staging/slicoss/slicbuild.h1
-rw-r--r--drivers/staging/slicoss/slicdbg.h3
-rw-r--r--drivers/staging/slicoss/slicdump.h89
-rw-r--r--drivers/staging/slicoss/slichw.h653
-rw-r--r--drivers/staging/slicoss/slicinc.h262
-rw-r--r--drivers/staging/slicoss/slicoss.c1351
13 files changed, 1353 insertions, 1619 deletions
diff --git a/drivers/staging/slicoss/gbdownload.h b/drivers/staging/slicoss/gbdownload.h
index 0350fb96c23f..794432bd1d77 100644
--- a/drivers/staging/slicoss/gbdownload.h
+++ b/drivers/staging/slicoss/gbdownload.h
@@ -1,14 +1,14 @@
1#define MOJAVE_UCODE_VERS_STRING "$Revision: 1.2 $" 1#define MOJAVE_UCODE_VERS_STRING "1.2"
2#define MOJAVE_UCODE_VERS_DATE "$Date: 2006/03/27 15:12:22 $" 2#define MOJAVE_UCODE_VERS_DATE "2006/03/27 15:12:22"
3#define MOJAVE_UCODE_HOSTIF_ID 3 3#define MOJAVE_UCODE_HOSTIF_ID 3
4 4
5static LONG MNumSections = 0x2; 5static s32 MNumSections = 0x2;
6static ULONG MSectionSize[] = 6static u32 MSectionSize[] =
7{ 7{
8 0x00008000, 0x00010000, 8 0x00008000, 0x00010000,
9}; 9};
10 10
11static ULONG MSectionStart[] = 11static u32 MSectionStart[] =
12{ 12{
13 0x00000000, 0x00008000, 13 0x00000000, 0x00008000,
14}; 14};
diff --git a/drivers/staging/slicoss/gbrcvucode.h b/drivers/staging/slicoss/gbrcvucode.h
index dc008349ddd1..4fa5a4c23e57 100644
--- a/drivers/staging/slicoss/gbrcvucode.h
+++ b/drivers/staging/slicoss/gbrcvucode.h
@@ -1,7 +1,6 @@
1/* 1/*
2 * Copyright (c) 1997-2002 Alacritech, Inc. All rights reserved 2 * Copyright (c) 1997-2002 Alacritech, Inc. All rights reserved
3 * 3 *
4 * $Id: gbrcvucode.h,v 1.2 2006/03/27 15:12:15 mook Exp $
5 * 4 *
6 * Redistribution and use in source and binary forms, with or without 5 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions 6 * modification, are permitted provided that the following conditions
@@ -32,10 +31,10 @@
32 * official policies, either expressed or implied, of Alacritech, Inc. 31 * official policies, either expressed or implied, of Alacritech, Inc.
33 * 32 *
34 **************************************************************************/ 33 **************************************************************************/
35#define GB_RCVUCODE_VERS_STRING "$Revision: 1.2 $" 34#define GB_RCVUCODE_VERS_STRING "1.2"
36#define GB_RCVUCODE_VERS_DATE "$Date: 2006/03/27 15:12:15 $" 35#define GB_RCVUCODE_VERS_DATE "2006/03/27 15:12:15"
37 36
38static ULONG GBRcvUCodeLen = 512; 37static u32 GBRcvUCodeLen = 512;
39 38
40static u8 GBRcvUCode[2560] = 39static u8 GBRcvUCode[2560] =
41{ 40{
diff --git a/drivers/staging/slicoss/oasisdbgdownload.h b/drivers/staging/slicoss/oasisdbgdownload.h
index cae5d55d2856..519e00797d44 100644
--- a/drivers/staging/slicoss/oasisdbgdownload.h
+++ b/drivers/staging/slicoss/oasisdbgdownload.h
@@ -1,14 +1,14 @@
1#define OASIS_UCODE_VERS_STRING "$Revision: 1.2 $" 1#define OASIS_UCODE_VERS_STRING "1.2"
2#define OASIS_UCODE_VERS_DATE "$Date: 2006/03/27 15:11:22 $" 2#define OASIS_UCODE_VERS_DATE "2006/03/27 15:11:22"
3#define OASIS_UCODE_HOSTIF_ID 3 3#define OASIS_UCODE_HOSTIF_ID 3
4 4
5static LONG ONumSections = 0x2; 5static s32 ONumSections = 0x2;
6static ULONG OSectionSize[] = 6static u32 OSectionSize[] =
7{ 7{
8 0x00004000, 0x00010000, 8 0x00004000, 0x00010000,
9}; 9};
10 10
11static ULONG OSectionStart[] = 11static u32 OSectionStart[] =
12{ 12{
13 0x00000000, 0x00008000, 13 0x00000000, 0x00008000,
14}; 14};
diff --git a/drivers/staging/slicoss/oasisdownload.h b/drivers/staging/slicoss/oasisdownload.h
index 89a440c4c3a7..6438c23d7548 100644
--- a/drivers/staging/slicoss/oasisdownload.h
+++ b/drivers/staging/slicoss/oasisdownload.h
@@ -1,13 +1,13 @@
1#define OASIS_UCODE_VERS_STRING "$Revision: 1.2 $" 1#define OASIS_UCODE_VERS_STRING "1.2"
2#define OASIS_UCODE_VERS_DATE "$Date: 2006/03/27 15:10:37 $" 2#define OASIS_UCODE_VERS_DATE "2006/03/27 15:10:37"
3#define OASIS_UCODE_HOSTIF_ID 3 3#define OASIS_UCODE_HOSTIF_ID 3
4 4
5static LONG ONumSections = 0x2; 5static s32 ONumSections = 0x2;
6static ULONG OSectionSize[] = { 6static u32 OSectionSize[] = {
7 0x00004000, 0x00010000, 7 0x00004000, 0x00010000,
8}; 8};
9 9
10static ULONG OSectionStart[] = { 10static u32 OSectionStart[] = {
11 0x00000000, 0x00008000, 11 0x00000000, 0x00008000,
12}; 12};
13 13
diff --git a/drivers/staging/slicoss/oasisrcvucode.h b/drivers/staging/slicoss/oasisrcvucode.h
index ef9163245b88..5b3531f04cb9 100644
--- a/drivers/staging/slicoss/oasisrcvucode.h
+++ b/drivers/staging/slicoss/oasisrcvucode.h
@@ -1,7 +1,7 @@
1#define OASIS_RCVUCODE_VERS_STRING "$Revision: 1.2 $" 1#define OASIS_RCVUCODE_VERS_STRING "1.2"
2#define OASIS_RCVUCODE_VERS_DATE "$Date: 2006/03/27 15:10:28 $" 2#define OASIS_RCVUCODE_VERS_DATE "2006/03/27 15:10:28"
3 3
4static ULONG OasisRcvUCodeLen = 512; 4static u32 OasisRcvUCodeLen = 512;
5 5
6static u8 OasisRcvUCode[2560] = 6static u8 OasisRcvUCode[2560] =
7{ 7{
diff --git a/drivers/staging/slicoss/slic.h b/drivers/staging/slicoss/slic.h
index 9707e5a7023a..0d5dc24c0b7d 100644
--- a/drivers/staging/slicoss/slic.h
+++ b/drivers/staging/slicoss/slic.h
@@ -2,7 +2,6 @@
2 * 2 *
3 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved. 3 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved.
4 * 4 *
5 * $Id: slic.h,v 1.3 2006/07/14 16:43:02 mook Exp $
6 * 5 *
7 * Redistribution and use in source and binary forms, with or without 6 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions 7 * modification, are permitted provided that the following conditions
@@ -51,14 +50,14 @@ struct slic_spinlock {
51#define SLIC_RSPQ_PAGES_GB 10 50#define SLIC_RSPQ_PAGES_GB 10
52#define SLIC_RSPQ_BUFSINPAGE (PAGE_SIZE / SLIC_RSPBUF_SIZE) 51#define SLIC_RSPQ_BUFSINPAGE (PAGE_SIZE / SLIC_RSPBUF_SIZE)
53 52
54typedef struct _slic_rspqueue_t { 53struct slic_rspqueue {
55 ulong32 offset; 54 u32 offset;
56 ulong32 pageindex; 55 u32 pageindex;
57 ulong32 num_pages; 56 u32 num_pages;
58 p_slic_rspbuf_t rspbuf; 57 struct slic_rspbuf *rspbuf;
59 pulong32 vaddr[SLIC_RSPQ_PAGES_GB]; 58 u32 *vaddr[SLIC_RSPQ_PAGES_GB];
60 dma_addr_t paddr[SLIC_RSPQ_PAGES_GB]; 59 dma_addr_t paddr[SLIC_RSPQ_PAGES_GB];
61} slic_rspqueue_t, *p_slic_rspqueue_t; 60};
62 61
63#define SLIC_RCVQ_EXPANSION 1 62#define SLIC_RCVQ_EXPANSION 1
64#define SLIC_RCVQ_ENTRIES (256 * SLIC_RCVQ_EXPANSION) 63#define SLIC_RCVQ_ENTRIES (256 * SLIC_RCVQ_EXPANSION)
@@ -68,45 +67,45 @@ typedef struct _slic_rspqueue_t {
68#define SLIC_RCVQ_FILLENTRIES (16 * SLIC_RCVQ_EXPANSION) 67#define SLIC_RCVQ_FILLENTRIES (16 * SLIC_RCVQ_EXPANSION)
69#define SLIC_RCVQ_FILLTHRESH (SLIC_RCVQ_ENTRIES - SLIC_RCVQ_FILLENTRIES) 68#define SLIC_RCVQ_FILLTHRESH (SLIC_RCVQ_ENTRIES - SLIC_RCVQ_FILLENTRIES)
70 69
71typedef struct _slic_rcvqueue_t { 70struct slic_rcvqueue {
72 struct sk_buff *head; 71 struct sk_buff *head;
73 struct sk_buff *tail; 72 struct sk_buff *tail;
74 ulong32 count; 73 u32 count;
75 ulong32 size; 74 u32 size;
76 ulong32 errors; 75 u32 errors;
77} slic_rcvqueue_t, *p_slic_rcvqueue_t; 76};
78 77
79typedef struct _slic_rcvbuf_info_t { 78struct slic_rcvbuf_info {
80 ulong32 id; 79 u32 id;
81 ulong32 starttime; 80 u32 starttime;
82 ulong32 stoptime; 81 u32 stoptime;
83 ulong32 slicworld; 82 u32 slicworld;
84 ulong32 lasttime; 83 u32 lasttime;
85 ulong32 lastid; 84 u32 lastid;
86} slic_rcvbuf_info_t, *pslic_rcvbuf_info_t; 85};
87/* 86/*
88 SLIC Handle structure. Used to restrict handle values to 87 SLIC Handle structure. Used to restrict handle values to
89 32 bits by using an index rather than an address. 88 32 bits by using an index rather than an address.
90 Simplifies ucode in 64-bit systems 89 Simplifies ucode in 64-bit systems
91*/ 90*/
92typedef struct _slic_handle_word_t { 91struct slic_handle_word {
93 union { 92 union {
94 struct { 93 struct {
95 ushort index; 94 ushort index;
96 ushort bottombits; /* to denote num bufs to card */ 95 ushort bottombits; /* to denote num bufs to card */
97 } parts; 96 } parts;
98 ulong32 whole; 97 u32 whole;
99 } handle; 98 } handle;
100} slic_handle_word_t, *pslic_handle_word_t; 99};
101 100
102typedef struct _slic_handle_t { 101struct slic_handle {
103 slic_handle_word_t token; /* token passed between host and card*/ 102 struct slic_handle_word token; /* token passed between host and card*/
104 ushort type; 103 ushort type;
105 pvoid address; /* actual address of the object*/ 104 void *address; /* actual address of the object*/
106 ushort offset; 105 ushort offset;
107 struct _slic_handle_t *other_handle; 106 struct slic_handle *other_handle;
108 struct _slic_handle_t *next; 107 struct slic_handle *next;
109} slic_handle_t, *pslic_handle_t; 108};
110 109
111#define SLIC_HANDLE_FREE 0x0000 110#define SLIC_HANDLE_FREE 0x0000
112#define SLIC_HANDLE_DATA 0x0001 111#define SLIC_HANDLE_DATA 0x0001
@@ -120,19 +119,19 @@ typedef struct _slic_handle_t {
120 119
121#define SLIC_HOSTCMD_SIZE 512 120#define SLIC_HOSTCMD_SIZE 512
122 121
123typedef struct _slic_hostcmd_t { 122struct slic_hostcmd {
124 slic_host64_cmd_t cmd64; 123 struct slic_host64_cmd cmd64;
125 ulong32 type; 124 u32 type;
126 struct sk_buff *skb; 125 struct sk_buff *skb;
127 ulong32 paddrl; 126 u32 paddrl;
128 ulong32 paddrh; 127 u32 paddrh;
129 ulong32 busy; 128 u32 busy;
130 ulong32 cmdsize; 129 u32 cmdsize;
131 ushort numbufs; 130 ushort numbufs;
132 pslic_handle_t pslic_handle;/* handle associated with command */ 131 struct slic_handle *pslic_handle;/* handle associated with command */
133 struct _slic_hostcmd_t *next; 132 struct slic_hostcmd *next;
134 struct _slic_hostcmd_t *next_all; 133 struct slic_hostcmd *next_all;
135} slic_hostcmd_t, *p_slic_hostcmd_t; 134};
136 135
137#define SLIC_CMDQ_CMDSINPAGE (PAGE_SIZE / SLIC_HOSTCMD_SIZE) 136#define SLIC_CMDQ_CMDSINPAGE (PAGE_SIZE / SLIC_HOSTCMD_SIZE)
138#define SLIC_CMD_DUMB 3 137#define SLIC_CMD_DUMB 3
@@ -142,18 +141,18 @@ typedef struct _slic_hostcmd_t {
142#define SLIC_CMDQ_MAXPAGES (SLIC_CMDQ_MAXCMDS / SLIC_CMDQ_CMDSINPAGE) 141#define SLIC_CMDQ_MAXPAGES (SLIC_CMDQ_MAXCMDS / SLIC_CMDQ_CMDSINPAGE)
143#define SLIC_CMDQ_INITPAGES (SLIC_CMDQ_INITCMDS / SLIC_CMDQ_CMDSINPAGE) 142#define SLIC_CMDQ_INITPAGES (SLIC_CMDQ_INITCMDS / SLIC_CMDQ_CMDSINPAGE)
144 143
145typedef struct _slic_cmdqmem_t { 144struct slic_cmdqmem {
146 int pagecnt; 145 int pagecnt;
147 pulong32 pages[SLIC_CMDQ_MAXPAGES]; 146 u32 *pages[SLIC_CMDQ_MAXPAGES];
148 dma_addr_t dma_pages[SLIC_CMDQ_MAXPAGES]; 147 dma_addr_t dma_pages[SLIC_CMDQ_MAXPAGES];
149} slic_cmdqmem_t, *p_slic_cmdqmem_t; 148};
150 149
151typedef struct _slic_cmdqueue_t { 150struct slic_cmdqueue {
152 p_slic_hostcmd_t head; 151 struct slic_hostcmd *head;
153 p_slic_hostcmd_t tail; 152 struct slic_hostcmd *tail;
154 int count; 153 int count;
155 struct slic_spinlock lock; 154 struct slic_spinlock lock;
156} slic_cmdqueue_t, *p_slic_cmdqueue_t; 155};
157 156
158#ifdef STATUS_SUCCESS 157#ifdef STATUS_SUCCESS
159#undef STATUS_SUCCESS 158#undef STATUS_SUCCESS
@@ -181,10 +180,10 @@ just set this at 15K, shouldnt make that much of a diff.
181#endif 180#endif
182 181
183 182
184typedef struct _mcast_address_t { 183struct mcast_address {
185 uchar address[6]; 184 unsigned char address[6];
186 struct _mcast_address_t *next; 185 struct mcast_address *next;
187} mcast_address_t, *p_mcast_address_t; 186};
188 187
189#define CARD_DOWN 0x00000000 188#define CARD_DOWN 0x00000000
190#define CARD_UP 0x00000001 189#define CARD_UP 0x00000001
@@ -236,38 +235,37 @@ typedef struct _mcast_address_t {
236#define SLIC_ADAPTER_STATE(x) ((x == ADAPT_UP) ? "UP" : "Down") 235#define SLIC_ADAPTER_STATE(x) ((x == ADAPT_UP) ? "UP" : "Down")
237#define SLIC_CARD_STATE(x) ((x == CARD_UP) ? "UP" : "Down") 236#define SLIC_CARD_STATE(x) ((x == CARD_UP) ? "UP" : "Down")
238 237
239typedef struct _slic_iface_stats { 238struct slic_iface_stats {
240 /* 239 /*
241 * Stats 240 * Stats
242 */ 241 */
243 ulong64 xmt_bytes; 242 u64 xmt_bytes;
244 ulong64 xmt_ucast; 243 u64 xmt_ucast;
245 ulong64 xmt_mcast; 244 u64 xmt_mcast;
246 ulong64 xmt_bcast; 245 u64 xmt_bcast;
247 ulong64 xmt_errors; 246 u64 xmt_errors;
248 ulong64 xmt_discards; 247 u64 xmt_discards;
249 ulong64 xmit_collisions; 248 u64 xmit_collisions;
250 ulong64 xmit_excess_xmit_collisions; 249 u64 xmit_excess_xmit_collisions;
251 ulong64 rcv_bytes; 250 u64 rcv_bytes;
252 ulong64 rcv_ucast; 251 u64 rcv_ucast;
253 ulong64 rcv_mcast; 252 u64 rcv_mcast;
254 ulong64 rcv_bcast; 253 u64 rcv_bcast;
255 ulong64 rcv_errors; 254 u64 rcv_errors;
256 ulong64 rcv_discards; 255 u64 rcv_discards;
257} slic_iface_stats_t, *p_slic_iface_stats_t; 256};
258 257
259typedef struct _slic_tcp_stats { 258struct sliccp_stats {
260 ulong64 xmit_tcp_segs; 259 u64 xmit_tcp_segs;
261 ulong64 xmit_tcp_bytes; 260 u64 xmit_tcp_bytes;
262 ulong64 rcv_tcp_segs; 261 u64 rcv_tcp_segs;
263 ulong64 rcv_tcp_bytes; 262 u64 rcv_tcp_bytes;
264} slic_tcp_stats_t, *p_slic_tcp_stats_t; 263};
265 264
266typedef struct _slicnet_stats { 265struct slicnet_stats {
267 slic_tcp_stats_t tcp; 266 struct sliccp_stats tcp;
268 slic_iface_stats_t iface; 267 struct slic_iface_stats iface;
269 268};
270} slicnet_stats_t, *p_slicnet_stats_t;
271 269
272#define SLIC_LOADTIMER_PERIOD 1 270#define SLIC_LOADTIMER_PERIOD 1
273#define SLIC_INTAGG_DEFAULT 200 271#define SLIC_INTAGG_DEFAULT 200
@@ -294,13 +292,13 @@ typedef struct _slicnet_stats {
294#define SLIC_INTAGG_4GB 100 292#define SLIC_INTAGG_4GB 100
295#define SLIC_INTAGG_5GB 100 293#define SLIC_INTAGG_5GB 100
296 294
297typedef struct _ether_header { 295struct ether_header {
298 uchar ether_dhost[6]; 296 unsigned char ether_dhost[6];
299 uchar ether_shost[6]; 297 unsigned char ether_shost[6];
300 ushort ether_type; 298 ushort ether_type;
301} ether_header, *p_ether_header; 299};
302 300
303typedef struct _sliccard_t { 301struct sliccard {
304 uint busnumber; 302 uint busnumber;
305 uint slotnumber; 303 uint slotnumber;
306 uint state; 304 uint state;
@@ -310,114 +308,111 @@ typedef struct _sliccard_t {
310 uint adapters_allocated; 308 uint adapters_allocated;
311 uint adapters_sleeping; 309 uint adapters_sleeping;
312 uint gennumber; 310 uint gennumber;
313 ulong32 events; 311 u32 events;
314 ulong32 loadlevel_current; 312 u32 loadlevel_current;
315 ulong32 load; 313 u32 load;
316 uint reset_in_progress; 314 uint reset_in_progress;
317 ulong32 pingstatus; 315 u32 pingstatus;
318 ulong32 bad_pingstatus; 316 u32 bad_pingstatus;
319 struct timer_list loadtimer; 317 struct timer_list loadtimer;
320 ulong32 loadtimerset; 318 u32 loadtimerset;
321 uint config_set; 319 uint config_set;
322 slic_config_t config; 320 struct slic_config config;
323 struct dentry *debugfs_dir; 321 struct dentry *debugfs_dir;
324 struct dentry *debugfs_cardinfo; 322 struct dentry *debugfs_cardinfo;
325 struct _adapter_t *master; 323 struct adapter *master;
326 struct _adapter_t *adapter[SLIC_MAX_PORTS]; 324 struct adapter *adapter[SLIC_MAX_PORTS];
327 struct _sliccard_t *next; 325 struct sliccard *next;
328 ulong32 error_interrupts; 326 u32 error_interrupts;
329 ulong32 error_rmiss_interrupts; 327 u32 error_rmiss_interrupts;
330 ulong32 rcv_interrupts; 328 u32 rcv_interrupts;
331 ulong32 xmit_interrupts; 329 u32 xmit_interrupts;
332 ulong32 num_isrs; 330 u32 num_isrs;
333 ulong32 false_interrupts; 331 u32 false_interrupts;
334 ulong32 max_isr_rcvs; 332 u32 max_isr_rcvs;
335 ulong32 max_isr_xmits; 333 u32 max_isr_xmits;
336 ulong32 rcv_interrupt_yields; 334 u32 rcv_interrupt_yields;
337 ulong32 tx_packets; 335 u32 tx_packets;
338#if SLIC_DUMP_ENABLED 336#if SLIC_DUMP_ENABLED
339 ulong32 dumpstatus; /* Result of dump UPR */ 337 u32 dumpstatus; /* Result of dump UPR */
340 pvoid cmdbuffer; 338 void *cmdbuffer;
341 339
342 ulong cmdbuffer_phys; 340 ulong cmdbuffer_phys;
343 ulong32 cmdbuffer_physl; 341 u32 cmdbuffer_physl;
344 ulong32 cmdbuffer_physh; 342 u32 cmdbuffer_physh;
345 343
346 ulong32 dump_count; 344 u32 dump_count;
347 struct task_struct *dump_task_id; 345 struct task_struct *dump_task_id;
348 ulong32 dump_wait_count; 346 u32 dump_wait_count;
349 uint dumpthread_running; /* has a dump thread been init'd */ 347 uint dumpthread_running; /* has a dump thread been init'd */
350 uint dump_requested; /* 0 no, 1 = reqstd 2=curr 3=done */ 348 uint dump_requested; /* 0 no, 1 = reqstd 2=curr 3=done */
351 ulong32 dumptime_start; 349 u32 dumptime_start;
352 ulong32 dumptime_complete; 350 u32 dumptime_complete;
353 ulong32 dumptime_delta; 351 u32 dumptime_delta;
354 pvoid dumpbuffer; 352 void *dumpbuffer;
355 ulong dumpbuffer_phys; 353 ulong dumpbuffer_phys;
356 ulong32 dumpbuffer_physl; 354 u32 dumpbuffer_physl;
357 ulong32 dumpbuffer_physh; 355 u32 dumpbuffer_physh;
358 wait_queue_head_t dump_wq; 356 wait_queue_head_t dump_wq;
359 struct file *dumphandle; 357 struct file *dumphandle;
360 mm_segment_t dumpfile_fs; 358 mm_segment_t dumpfile_fs;
361#endif 359#endif
362 ulong32 debug_ix; 360 u32 debug_ix;
363 ushort reg_type[32]; 361 ushort reg_type[32];
364 ushort reg_offset[32]; 362 ushort reg_offset[32];
365 ulong32 reg_value[32]; 363 u32 reg_value[32];
366 ulong32 reg_valueh[32]; 364 u32 reg_valueh[32];
367} sliccard_t, *p_sliccard_t; 365};
368 366
369#define NUM_CFG_SPACES 2 367#define NUM_CFG_SPACES 2
370#define NUM_CFG_REGS 64 368#define NUM_CFG_REGS 64
371#define NUM_CFG_REG_ULONGS (NUM_CFG_REGS / sizeof(ulong32)) 369#define NUM_CFG_REG_ULONGS (NUM_CFG_REGS / sizeof(u32))
372 370
373typedef struct _physcard_t { 371struct physcard {
374 struct _adapter_t *adapter[SLIC_MAX_PORTS]; 372 struct adapter *adapter[SLIC_MAX_PORTS];
375 struct _physcard_t *next; 373 struct physcard *next;
376 uint adapters_allocd; 374 uint adapters_allocd;
377 375
378 /* the following is not currently needed 376 /* the following is not currently needed
379 ulong32 bridge_busnum; 377 u32 bridge_busnum;
380 ulong32 bridge_cfg[NUM_CFG_SPACES][NUM_CFG_REG_ULONGS]; 378 u32 bridge_cfg[NUM_CFG_SPACES][NUM_CFG_REG_ULONGS];
381 */ 379 */
382} physcard_t, *p_physcard_t; 380};
383 381
384typedef struct _base_driver { 382struct base_driver {
385 struct slic_spinlock driver_lock; 383 struct slic_spinlock driver_lock;
386 ulong32 num_slic_cards; 384 u32 num_slic_cards;
387 ulong32 num_slic_ports; 385 u32 num_slic_ports;
388 ulong32 num_slic_ports_active; 386 u32 num_slic_ports_active;
389 ulong32 dynamic_intagg; 387 u32 dynamic_intagg;
390 p_sliccard_t slic_card; 388 struct sliccard *slic_card;
391 p_physcard_t phys_card; 389 struct physcard *phys_card;
392 uint cardnuminuse[SLIC_MAX_CARDS]; 390 uint cardnuminuse[SLIC_MAX_CARDS];
393} base_driver_t, *p_base_driver_t; 391};
394 392
395extern base_driver_t slic_global; 393struct slic_shmem {
396 394 volatile u32 isr;
397typedef struct _slic_shmem_t { 395 volatile u32 linkstatus;
398 volatile ulong32 isr; 396 volatile struct slic_stats inicstats;
399 volatile ulong32 linkstatus; 397};
400 volatile slic_stats_t inicstats; 398
401} slic_shmem_t, *p_slic_shmem_t; 399struct slic_reg_params {
402 400 u32 linkspeed;
403typedef struct _slic_reg_params_t { 401 u32 linkduplex;
404 ulong32 linkspeed; 402 u32 fail_on_bad_eeprom;
405 ulong32 linkduplex; 403};
406 ulong32 fail_on_bad_eeprom; 404
407} slic_reg_params_t, *p_reg_params_t; 405struct slic_upr {
408 406 uint adapter;
409typedef struct _slic_upr_t { 407 u32 upr_request;
410 uint adapter; 408 u32 upr_data;
411 ulong32 upr_request; 409 u32 upr_data_h;
412 ulong32 upr_data; 410 u32 upr_buffer;
413 ulong32 upr_data_h; 411 u32 upr_buffer_h;
414 ulong32 upr_buffer; 412 struct slic_upr *next;
415 ulong32 upr_buffer_h; 413};
416 struct _slic_upr_t *next; 414
417 415struct slic_ifevents {
418} slic_upr_t, *p_slic_upr_t;
419
420typedef struct _slic_ifevents_ti {
421 uint oflow802; 416 uint oflow802;
422 uint uflow802; 417 uint uflow802;
423 uint Tprtoflow; 418 uint Tprtoflow;
@@ -434,19 +429,19 @@ typedef struct _slic_ifevents_ti {
434 uint IpCsum; 429 uint IpCsum;
435 uint TpCsum; 430 uint TpCsum;
436 uint TpHlen; 431 uint TpHlen;
437} slic_ifevents_t; 432};
438 433
439typedef struct _adapter_t { 434struct adapter {
440 pvoid ifp; 435 void *ifp;
441 p_sliccard_t card; 436 struct sliccard *card;
442 uint port; 437 uint port;
443 p_physcard_t physcard; 438 struct physcard *physcard;
444 uint physport; 439 uint physport;
445 uint cardindex; 440 uint cardindex;
446 uint card_size; 441 uint card_size;
447 uint chipid; 442 uint chipid;
448 struct net_device *netdev; 443 struct net_device *netdev;
449 struct net_device *next_netdevice; 444 struct net_device *next_netdevice;
450 struct slic_spinlock adapter_lock; 445 struct slic_spinlock adapter_lock;
451 struct slic_spinlock reset_lock; 446 struct slic_spinlock reset_lock;
452 struct pci_dev *pcidev; 447 struct pci_dev *pcidev;
@@ -456,90 +451,90 @@ typedef struct _adapter_t {
456 ushort vendid; 451 ushort vendid;
457 ushort devid; 452 ushort devid;
458 ushort subsysid; 453 ushort subsysid;
459 ulong32 irq; 454 u32 irq;
460 void __iomem *memorybase; 455 void __iomem *memorybase;
461 ulong32 memorylength; 456 u32 memorylength;
462 ulong32 drambase; 457 u32 drambase;
463 ulong32 dramlength; 458 u32 dramlength;
464 uint queues_initialized; 459 uint queues_initialized;
465 uint allocated; 460 uint allocated;
466 uint activated; 461 uint activated;
467 ulong32 intrregistered; 462 u32 intrregistered;
468 uint isp_initialized; 463 uint isp_initialized;
469 uint gennumber; 464 uint gennumber;
470 ulong32 curaddrupper; 465 u32 curaddrupper;
471 p_slic_shmem_t pshmem; 466 struct slic_shmem *pshmem;
472 dma_addr_t phys_shmem; 467 dma_addr_t phys_shmem;
473 ulong32 isrcopy; 468 u32 isrcopy;
474 p_slic_regs_t slic_regs; 469 __iomem struct slic_regs *slic_regs;
475 uchar state; 470 unsigned char state;
476 uchar linkstate; 471 unsigned char linkstate;
477 uchar linkspeed; 472 unsigned char linkspeed;
478 uchar linkduplex; 473 unsigned char linkduplex;
479 uint flags; 474 uint flags;
480 uchar macaddr[6]; 475 unsigned char macaddr[6];
481 uchar currmacaddr[6]; 476 unsigned char currmacaddr[6];
482 ulong32 macopts; 477 u32 macopts;
483 ushort devflags_prev; 478 ushort devflags_prev;
484 ulong64 mcastmask; 479 u64 mcastmask;
485 p_mcast_address_t mcastaddrs; 480 struct mcast_address *mcastaddrs;
486 p_slic_upr_t upr_list; 481 struct slic_upr *upr_list;
487 uint upr_busy; 482 uint upr_busy;
488 struct timer_list pingtimer; 483 struct timer_list pingtimer;
489 ulong32 pingtimerset; 484 u32 pingtimerset;
490 struct timer_list statstimer; 485 struct timer_list statstimer;
491 ulong32 statstimerset; 486 u32 statstimerset;
492 struct timer_list loadtimer; 487 struct timer_list loadtimer;
493 ulong32 loadtimerset; 488 u32 loadtimerset;
494 struct dentry *debugfs_entry; 489 struct dentry *debugfs_entry;
495 struct slic_spinlock upr_lock; 490 struct slic_spinlock upr_lock;
496 struct slic_spinlock bit64reglock; 491 struct slic_spinlock bit64reglock;
497 slic_rspqueue_t rspqueue; 492 struct slic_rspqueue rspqueue;
498 slic_rcvqueue_t rcvqueue; 493 struct slic_rcvqueue rcvqueue;
499 slic_cmdqueue_t cmdq_free; 494 struct slic_cmdqueue cmdq_free;
500 slic_cmdqueue_t cmdq_done; 495 struct slic_cmdqueue cmdq_done;
501 slic_cmdqueue_t cmdq_all; 496 struct slic_cmdqueue cmdq_all;
502 slic_cmdqmem_t cmdqmem; 497 struct slic_cmdqmem cmdqmem;
503 /* 498 /*
504 * SLIC Handles 499 * SLIC Handles
505 */ 500 */
506 slic_handle_t slic_handles[SLIC_CMDQ_MAXCMDS+1]; /* Object handles*/ 501 struct slic_handle slic_handles[SLIC_CMDQ_MAXCMDS+1]; /* Object handles*/
507 pslic_handle_t pfree_slic_handles; /* Free object handles*/ 502 struct slic_handle *pfree_slic_handles; /* Free object handles*/
508 struct slic_spinlock handle_lock; /* Object handle list lock*/ 503 struct slic_spinlock handle_lock; /* Object handle list lock*/
509 ushort slic_handle_ix; 504 ushort slic_handle_ix;
510 505
511 ulong32 xmitq_full; 506 u32 xmitq_full;
512 ulong32 all_reg_writes; 507 u32 all_reg_writes;
513 ulong32 icr_reg_writes; 508 u32 icr_reg_writes;
514 ulong32 isr_reg_writes; 509 u32 isr_reg_writes;
515 ulong32 error_interrupts; 510 u32 error_interrupts;
516 ulong32 error_rmiss_interrupts; 511 u32 error_rmiss_interrupts;
517 ulong32 rx_errors; 512 u32 rx_errors;
518 ulong32 rcv_drops; 513 u32 rcv_drops;
519 ulong32 rcv_interrupts; 514 u32 rcv_interrupts;
520 ulong32 xmit_interrupts; 515 u32 xmit_interrupts;
521 ulong32 linkevent_interrupts; 516 u32 linkevent_interrupts;
522 ulong32 upr_interrupts; 517 u32 upr_interrupts;
523 ulong32 num_isrs; 518 u32 num_isrs;
524 ulong32 false_interrupts; 519 u32 false_interrupts;
525 ulong32 tx_packets; 520 u32 tx_packets;
526 ulong32 xmit_completes; 521 u32 xmit_completes;
527 ulong32 tx_drops; 522 u32 tx_drops;
528 ulong32 rcv_broadcasts; 523 u32 rcv_broadcasts;
529 ulong32 rcv_multicasts; 524 u32 rcv_multicasts;
530 ulong32 rcv_unicasts; 525 u32 rcv_unicasts;
531 ulong32 max_isr_rcvs; 526 u32 max_isr_rcvs;
532 ulong32 max_isr_xmits; 527 u32 max_isr_xmits;
533 ulong32 rcv_interrupt_yields; 528 u32 rcv_interrupt_yields;
534 ulong32 intagg_period; 529 u32 intagg_period;
535 p_inicpm_state_t inicpm_info; 530 struct inicpm_state *inicpm_info;
536 pvoid pinicpm_info; 531 void *pinicpm_info;
537 slic_reg_params_t reg_params; 532 struct slic_reg_params reg_params;
538 slic_ifevents_t if_events; 533 struct slic_ifevents if_events;
539 slic_stats_t inicstats_prev; 534 struct slic_stats inicstats_prev;
540 slicnet_stats_t slic_stats; 535 struct slicnet_stats slic_stats;
541 struct net_device_stats stats; 536 struct net_device_stats stats;
542} adapter_t, *p_adapter_t; 537};
543 538
544#if SLIC_DUMP_ENABLED 539#if SLIC_DUMP_ENABLED
545#define SLIC_DUMP_REQUESTED 1 540#define SLIC_DUMP_REQUESTED 1
@@ -552,10 +547,10 @@ typedef struct _adapter_t {
552 * structure is written out to the card's SRAM when the microcode panic's. 547 * structure is written out to the card's SRAM when the microcode panic's.
553 * 548 *
554 ****************************************************************************/ 549 ****************************************************************************/
555typedef struct _slic_crash_info { 550struct slic_crash_info {
556 ushort cpu_id; 551 ushort cpu_id;
557 ushort crash_pc; 552 ushort crash_pc;
558} slic_crash_info, *p_slic_crash_info; 553};
559 554
560#define CRASH_INFO_OFFSET 0x155C 555#define CRASH_INFO_OFFSET 0x155C
561 556
@@ -577,20 +572,20 @@ typedef struct _slic_crash_info {
577#define ETHER_EQ_ADDR(_AddrA, _AddrB, _Result) \ 572#define ETHER_EQ_ADDR(_AddrA, _AddrB, _Result) \
578{ \ 573{ \
579 _Result = TRUE; \ 574 _Result = TRUE; \
580 if (*(pulong32)(_AddrA) != *(pulong32)(_AddrB)) \ 575 if (*(u32 *)(_AddrA) != *(u32 *)(_AddrB)) \
581 _Result = FALSE; \ 576 _Result = FALSE; \
582 if (*(pushort)(&((_AddrA)[4])) != *(pushort)(&((_AddrB)[4]))) \ 577 if (*(u16 *)(&((_AddrA)[4])) != *(u16 *)(&((_AddrB)[4]))) \
583 _Result = FALSE; \ 578 _Result = FALSE; \
584} 579}
585 580
586#if defined(CONFIG_X86_64) || defined(CONFIG_IA64) 581#if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
587#define SLIC_GET_ADDR_LOW(_addr) (ulong32)((ulong64)(_addr) & \ 582#define SLIC_GET_ADDR_LOW(_addr) (u32)((u64)(_addr) & \
588 0x00000000FFFFFFFF) 583 0x00000000FFFFFFFF)
589#define SLIC_GET_ADDR_HIGH(_addr) (ulong32)(((ulong64)(_addr) >> 32) & \ 584#define SLIC_GET_ADDR_HIGH(_addr) (u32)(((u64)(_addr) >> 32) & \
590 0x00000000FFFFFFFF) 585 0x00000000FFFFFFFF)
591#else 586#else
592#define SLIC_GET_ADDR_LOW(_addr) (ulong32)_addr 587#define SLIC_GET_ADDR_LOW(_addr) (u32)_addr
593#define SLIC_GET_ADDR_HIGH(_addr) (ulong32)0 588#define SLIC_GET_ADDR_HIGH(_addr) (u32)0
594#endif 589#endif
595 590
596#define FLUSH TRUE 591#define FLUSH TRUE
diff --git a/drivers/staging/slicoss/slic_os.h b/drivers/staging/slicoss/slic_os.h
index 2064673f9149..b0d2883034ce 100644
--- a/drivers/staging/slicoss/slic_os.h
+++ b/drivers/staging/slicoss/slic_os.h
@@ -2,7 +2,6 @@
2 * 2 *
3 * Copyright (c)2000-2002 Alacritech, Inc. All rights reserved. 3 * Copyright (c)2000-2002 Alacritech, Inc. All rights reserved.
4 * 4 *
5 * $Id: slic_os.h,v 1.2 2006/03/27 15:10:15 mook Exp $
6 * 5 *
7 * Redistribution and use in source and binary forms, with or without 6 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions 7 * modification, are permitted provided that the following conditions
@@ -43,87 +42,9 @@
43#ifndef _SLIC_OS_SPECIFIC_H_ 42#ifndef _SLIC_OS_SPECIFIC_H_
44#define _SLIC_OS_SPECIFIC_H_ 43#define _SLIC_OS_SPECIFIC_H_
45 44
46typedef unsigned char uchar;
47typedef u64 ulong64;
48typedef char *pchar;
49typedef unsigned char *puchar;
50typedef u16 *pushort;
51typedef u32 ulong32;
52typedef u32 *pulong32;
53typedef int *plong32;
54typedef unsigned int *puint;
55typedef void *pvoid;
56typedef unsigned long *pulong;
57typedef unsigned int boolean;
58typedef unsigned int wchar;
59typedef unsigned int *pwchar;
60typedef unsigned char UCHAR;
61typedef u32 ULONG;
62typedef s32 LONG;
63#define FALSE (0) 45#define FALSE (0)
64#define TRUE (1) 46#define TRUE (1)
65 47
66#define SLIC_INIT_SPINLOCK(x) \
67 { \
68 spin_lock_init(&((x).lock)); \
69 }
70#define SLIC_ACQUIRE_SPINLOCK(x) \
71 { \
72 spin_lock(&((x).lock)); \
73 }
74
75#define SLIC_RELEASE_SPINLOCK(x) \
76 { \
77 spin_unlock(&((x).lock)); \
78 }
79
80#define SLIC_ACQUIRE_IRQ_SPINLOCK(x) \
81 { \
82 spin_lock_irqsave(&((x).lock), (x).flags); \
83 }
84
85#define SLIC_RELEASE_IRQ_SPINLOCK(x) \
86 { \
87 spin_unlock_irqrestore(&((x).lock), (x).flags); \
88 }
89
90#define ATK_DEBUG 1
91
92#if ATK_DEBUG
93#define SLIC_TIMESTAMP(value) { \
94 struct timeval timev; \
95 do_gettimeofday(&timev); \
96 value = timev.tv_sec*1000000 + timev.tv_usec; \
97}
98#else
99#define SLIC_TIMESTAMP(value)
100#endif
101
102#define SLIC_ALLOCATE_MEM(len, flag) kmalloc(len, flag)
103#define SLIC_DEALLOCATE_MEM(mem) kfree(mem)
104#define SLIC_DEALLOCATE_IRQ_MEM(mem) free(mem)
105#define SLIC_ALLOCATE_PAGE(x) (pulong32)get_free_page(GFP_KERNEL)
106#define SLIC_DEALLOCATE_PAGE(addr) free_page((ulong32)addr)
107#define SLIC_ALLOCATE_PCIMEM(a, sz, physp) \
108 pci_alloc_consistent((a)->pcidev, (sz), &(physp))
109#define SLIC_DEALLOCATE_PCIMEM(a, sz, vp, pp) \
110 pci_free_consistent((a)->pcidev, (sz), (vp), (pp))
111#define SLIC_GET_PHYSICAL_ADDRESS(addr) virt_to_bus((addr))
112#define SLIC_GET_PHYSICAL_ADDRESS_HIGH(addr) 0
113
114#define SLIC_GET_DMA_ADDRESS_WRITE(a, ptr, sz) \
115 pci_map_single((a)->pcidev, (ptr), (sz), PCI_DMA_TODEVICE)
116#define SLIC_GET_DMA_ADDRESS_READ(a, ptr, sz) \
117 pci_map_single((a)->pcidev, (ptr), (sz), PCI_DMA_FROMDEVICE)
118#define SLIC_UNGET_DMA_ADDRESS_WRITE(a, pa, sz) \
119 pci_unmap_single((a)->pcidev, (pa), (sz), PCI_DMA_TODEVICE)
120#define SLIC_UNGET_DMA_ADDRESS_READ(a, pa, sz) \
121 pci_unmap_single((a)->pcidev, (pa), (sz), PCI_DMA_FROMDEVICE)
122
123#define SLIC_ZERO_MEMORY(p, sz) memset((p), 0, (sz))
124#define SLIC_EQUAL_MEMORY(src1, src2, len) (!memcmp(src1, src2, len))
125#define SLIC_MOVE_MEMORY(dst, src, len) memcpy((dst), (src), (len))
126
127#define SLIC_SECS_TO_JIFFS(x) ((x) * HZ) 48#define SLIC_SECS_TO_JIFFS(x) ((x) * HZ)
128#define SLIC_MS_TO_JIFFIES(x) (SLIC_SECS_TO_JIFFS((x)) / 1000) 49#define SLIC_MS_TO_JIFFIES(x) (SLIC_SECS_TO_JIFFS((x)) / 1000)
129 50
@@ -132,7 +53,7 @@ typedef s32 LONG;
132 { \ 53 { \
133 adapter->card->reg_type[adapter->card->debug_ix] = 0; \ 54 adapter->card->reg_type[adapter->card->debug_ix] = 0; \
134 adapter->card->reg_offset[adapter->card->debug_ix] = \ 55 adapter->card->reg_offset[adapter->card->debug_ix] = \
135 ((puchar)(&reg)) - ((puchar)adapter->slic_regs); \ 56 ((unsigned char *)(&reg)) - ((unsigned char *)adapter->slic_regs); \
136 adapter->card->reg_value[adapter->card->debug_ix++] = value; \ 57 adapter->card->reg_value[adapter->card->debug_ix++] = value; \
137 if (adapter->card->debug_ix == 32) \ 58 if (adapter->card->debug_ix == 32) \
138 adapter->card->debug_ix = 0; \ 59 adapter->card->debug_ix = 0; \
@@ -142,7 +63,7 @@ typedef s32 LONG;
142 { \ 63 { \
143 adapter->card->reg_type[adapter->card->debug_ix] = 1; \ 64 adapter->card->reg_type[adapter->card->debug_ix] = 1; \
144 adapter->card->reg_offset[adapter->card->debug_ix] = \ 65 adapter->card->reg_offset[adapter->card->debug_ix] = \
145 ((puchar)(&reg)) - ((puchar)adapter->slic_regs); \ 66 ((unsigned char *)(&reg)) - ((unsigned char *)adapter->slic_regs); \
146 adapter->card->reg_value[adapter->card->debug_ix] = value; \ 67 adapter->card->reg_value[adapter->card->debug_ix] = value; \
147 adapter->card->reg_valueh[adapter->card->debug_ix++] = valh; \ 68 adapter->card->reg_valueh[adapter->card->debug_ix++] = valh; \
148 if (adapter->card->debug_ix == 32) \ 69 if (adapter->card->debug_ix == 32) \
@@ -156,8 +77,6 @@ typedef s32 LONG;
156#define WRITE_REG64(a, reg, value, regh, valh, flush) \ 77#define WRITE_REG64(a, reg, value, regh, valh, flush) \
157 slic_reg64_write((a), (&reg), (value), (&regh), (valh), (flush)) 78 slic_reg64_write((a), (&reg), (value), (&regh), (valh), (flush))
158#endif 79#endif
159#define READ_REG(reg, flush) slic_reg32_read((&reg), (flush))
160#define READ_REGP16(reg, flush) slic_reg16_read((&reg), (flush))
161 80
162#endif /* _SLIC_OS_SPECIFIC_H_ */ 81#endif /* _SLIC_OS_SPECIFIC_H_ */
163 82
diff --git a/drivers/staging/slicoss/slicbuild.h b/drivers/staging/slicoss/slicbuild.h
index ddf16650ad8d..ae05e043d07e 100644
--- a/drivers/staging/slicoss/slicbuild.h
+++ b/drivers/staging/slicoss/slicbuild.h
@@ -2,7 +2,6 @@
2 * 2 *
3 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved. 3 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved.
4 * 4 *
5 * $Id: slicbuild.h,v 1.2 2006/03/27 15:10:10 mook Exp $
6 * 5 *
7 * Redistribution and use in source and binary forms, with or without 6 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions 7 * modification, are permitted provided that the following conditions
diff --git a/drivers/staging/slicoss/slicdbg.h b/drivers/staging/slicoss/slicdbg.h
index c1be56f96279..c54e44fb1f63 100644
--- a/drivers/staging/slicoss/slicdbg.h
+++ b/drivers/staging/slicoss/slicdbg.h
@@ -2,7 +2,6 @@
2 * 2 *
3 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved. 3 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved.
4 * 4 *
5 * $Id: slicdbg.h,v 1.2 2006/03/27 15:10:04 mook Exp $
6 * 5 *
7 * Redistribution and use in source and binary forms, with or without 6 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions 7 * modification, are permitted provided that the following conditions
@@ -66,7 +65,7 @@
66#ifdef CONFIG_X86_64 65#ifdef CONFIG_X86_64
67#define VALID_ADDRESS(p) (1) 66#define VALID_ADDRESS(p) (1)
68#else 67#else
69#define VALID_ADDRESS(p) (((ulong32)(p) & 0x80000000) || ((ulong32)(p) == 0)) 68#define VALID_ADDRESS(p) (((u32)(p) & 0x80000000) || ((u32)(p) == 0))
70#endif 69#endif
71#ifndef ASSERT 70#ifndef ASSERT
72#define ASSERT(a) \ 71#define ASSERT(a) \
diff --git a/drivers/staging/slicoss/slicdump.h b/drivers/staging/slicoss/slicdump.h
index 3c46094eff5e..ca0a2216f707 100644
--- a/drivers/staging/slicoss/slicdump.h
+++ b/drivers/staging/slicoss/slicdump.h
@@ -1,5 +1,4 @@
1/* 1/*
2 * $Id: slicdump.h,v 1.2 2006/03/27 15:09:57 mook Exp $
3 * 2 *
4 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved. 3 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved.
5 * 4 *
@@ -148,32 +147,32 @@
148/* 147/*
149 * Break and Reset Break command structure 148 * Break and Reset Break command structure
150 */ 149 */
151typedef struct _BREAK { 150struct BREAK {
152 uchar command; /* Command word defined above */ 151 unsigned char command; /* Command word defined above */
153 uchar resvd; 152 unsigned char resvd;
154 ushort count; /* Number of executions before break */ 153 ushort count; /* Number of executions before break */
155 ulong32 addr; /* Address of break point */ 154 u32 addr; /* Address of break point */
156} BREAK, *PBREAK; 155};
157 156
158/* 157/*
159 * Dump and Load command structure 158 * Dump and Load command structure
160 */ 159 */
161typedef struct _dump_cmd { 160struct dump_cmd {
162 uchar cmd; /* Command word defined above */ 161 unsigned char cmd; /* Command word defined above */
163 uchar desc; /* Descriptor values - defined below */ 162 unsigned char desc; /* Descriptor values - defined below */
164 ushort count; /* number of 4 byte words to be transferred */ 163 ushort count; /* number of 4 byte words to be transferred */
165 ulong32 addr; /* start address of dump or load */ 164 u32 addr; /* start address of dump or load */
166} dump_cmd_t, *pdump_cmd_t; 165};
167 166
168/* 167/*
169 * Receive or Transmit a frame. 168 * Receive or Transmit a frame.
170 */ 169 */
171typedef struct _RCV_OR_XMT_FRAME { 170struct RCV_OR_XMT_FRAME {
172 uchar command; /* Command word defined above */ 171 unsigned char command; /* Command word defined above */
173 uchar MacId; /* Mac ID of interface - transmit only */ 172 unsigned char MacId; /* Mac ID of interface - transmit only */
174 ushort count; /* Length of frame in bytes */ 173 ushort count; /* Length of frame in bytes */
175 ulong32 pad; /* not used */ 174 u32 pad; /* not used */
176} RCV_OR_XMT_FRAME, *PRCV_OR_XMT_FRAME; 175};
177 176
178/* 177/*
179 * Values of desc field in DUMP_OR_LOAD structure 178 * Values of desc field in DUMP_OR_LOAD structure
@@ -196,12 +195,12 @@ typedef struct _RCV_OR_XMT_FRAME {
196/* 195/*
197 * Map command to replace a command in ROM with a command in WCS 196 * Map command to replace a command in ROM with a command in WCS
198 */ 197 */
199typedef struct _MAP { 198struct MAP {
200 uchar command; /* Command word defined above */ 199 unsigned char command; /* Command word defined above */
201 uchar not_used[3]; 200 unsigned char not_used[3];
202 ushort map_to; /* Instruction address in WCS */ 201 ushort map_to; /* Instruction address in WCS */
203 ushort map_out; /* Instruction address in ROM */ 202 ushort map_out; /* Instruction address in ROM */
204} MAP, *PMAP; 203};
205 204
206/* 205/*
207 * Misc definitions 206 * Misc definitions
@@ -221,35 +220,35 @@ typedef struct _MAP {
221/* 220/*
222 * Coredump header structure 221 * Coredump header structure
223 */ 222 */
224typedef struct _CORE_Q { 223struct CORE_Q {
225 ulong32 queueOff; /* Offset of queue */ 224 u32 queueOff; /* Offset of queue */
226 ulong32 queuesize; /* size of queue */ 225 u32 queuesize; /* size of queue */
227} CORE_Q; 226};
228 227
229#define DRIVER_NAME_SIZE 32 228#define DRIVER_NAME_SIZE 32
230 229
231typedef struct _sliccore_hdr_t { 230struct sliccore_hdr {
232 uchar driver_version[DRIVER_NAME_SIZE]; /* Driver version string */ 231 unsigned char driver_version[DRIVER_NAME_SIZE]; /* Driver version string */
233 ulong32 RcvRegOff; /* Offset of receive registers */ 232 u32 RcvRegOff; /* Offset of receive registers */
234 ulong32 RcvRegsize; /* size of receive registers */ 233 u32 RcvRegsize; /* size of receive registers */
235 ulong32 XmtRegOff; /* Offset of transmit registers */ 234 u32 XmtRegOff; /* Offset of transmit registers */
236 ulong32 XmtRegsize; /* size of transmit registers */ 235 u32 XmtRegsize; /* size of transmit registers */
237 ulong32 FileRegOff; /* Offset of register file */ 236 u32 FileRegOff; /* Offset of register file */
238 ulong32 FileRegsize; /* size of register file */ 237 u32 FileRegsize; /* size of register file */
239 ulong32 SramOff; /* Offset of Sram */ 238 u32 SramOff; /* Offset of Sram */
240 ulong32 Sramsize; /* size of Sram */ 239 u32 Sramsize; /* size of Sram */
241 ulong32 DramOff; /* Offset of Dram */ 240 u32 DramOff; /* Offset of Dram */
242 ulong32 Dramsize; /* size of Dram */ 241 u32 Dramsize; /* size of Dram */
243 CORE_Q queues[SLIC_MAX_QUEUE]; /* size and offsets of queues */ 242 CORE_Q queues[SLIC_MAX_QUEUE]; /* size and offsets of queues */
244 ulong32 CamAMOff; /* Offset of CAM A contents */ 243 u32 CamAMOff; /* Offset of CAM A contents */
245 ulong32 CamASize; /* Size of Cam A */ 244 u32 CamASize; /* Size of Cam A */
246 ulong32 CamBMOff; /* Offset of CAM B contents */ 245 u32 CamBMOff; /* Offset of CAM B contents */
247 ulong32 CamBSize; /* Size of Cam B */ 246 u32 CamBSize; /* Size of Cam B */
248 ulong32 CamCMOff; /* Offset of CAM C contents */ 247 u32 CamCMOff; /* Offset of CAM C contents */
249 ulong32 CamCSize; /* Size of Cam C */ 248 u32 CamCSize; /* Size of Cam C */
250 ulong32 CamDMOff; /* Offset of CAM D contents */ 249 u32 CamDMOff; /* Offset of CAM D contents */
251 ulong32 CamDSize; /* Size of Cam D */ 250 u32 CamDSize; /* Size of Cam D */
252} sliccore_hdr_t, *p_sliccore_hdr_t; 251};
253 252
254/* 253/*
255 * definitions needed for our kernel-mode gdb stub. 254 * definitions needed for our kernel-mode gdb stub.
diff --git a/drivers/staging/slicoss/slichw.h b/drivers/staging/slicoss/slichw.h
index d5765c4dc665..4c5c15d49e67 100644
--- a/drivers/staging/slicoss/slichw.h
+++ b/drivers/staging/slicoss/slichw.h
@@ -2,7 +2,6 @@
2 * 2 *
3 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved. 3 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved.
4 * 4 *
5 * $Id: slichw.h,v 1.3 2008/03/17 19:27:26 chris Exp $
6 * 5 *
7 * Redistribution and use in source and binary forms, with or without 6 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions 7 * modification, are permitted provided that the following conditions
@@ -236,110 +235,106 @@
236#define TRUE 1 235#define TRUE 1
237#endif 236#endif
238 237
239typedef struct _slic_rcvbuf_t { 238struct slic_rcvbuf {
240 uchar pad1[6]; 239 unsigned char pad1[6];
241 ushort pad2; 240 ushort pad2;
242 ulong32 pad3; 241 u32 pad3;
243 ulong32 pad4; 242 u32 pad4;
244 ulong32 buffer; 243 u32 buffer;
245 ulong32 length; 244 u32 length;
246 ulong32 status; 245 u32 status;
247 ulong32 pad5; 246 u32 pad5;
248 ushort pad6; 247 ushort pad6;
249 uchar data[SLIC_RCVBUF_DATASIZE]; 248 unsigned char data[SLIC_RCVBUF_DATASIZE];
250} slic_rcvbuf_t, *p_slic_rcvbuf_t; 249};
251 250
252typedef struct _slic_hddr_wds { 251 struct slic_hddr_wds {
253 union { 252 union {
254 struct { 253 struct {
255 ulong32 frame_status; 254 u32 frame_status;
256 ulong32 frame_status_b; 255 u32 frame_status_b;
257 ulong32 time_stamp; 256 u32 time_stamp;
258 ulong32 checksum; 257 u32 checksum;
259 } hdrs_14port; 258 } hdrs_14port;
260 struct { 259 struct {
261 ulong32 frame_status; 260 u32 frame_status;
262 ushort ByteCnt; 261 ushort ByteCnt;
263 ushort TpChksum; 262 ushort TpChksum;
264 ushort CtxHash; 263 ushort CtxHash;
265 ushort MacHash; 264 ushort MacHash;
266 ulong32 BufLnk; 265 u32 BufLnk;
267 } hdrs_gbit; 266 } hdrs_gbit;
268 } u0; 267 } u0;
269} slic_hddr_wds_t, *p_slic_hddr_wds; 268};
270 269
271#define frame_status14 u0.hdrs_14port.frame_status 270#define frame_status14 u0.hdrs_14port.frame_status
272#define frame_status_b14 u0.hdrs_14port.frame_status_b 271#define frame_status_b14 u0.hdrs_14port.frame_status_b
273#define frame_statusGB u0.hdrs_gbit.frame_status 272#define frame_statusGB u0.hdrs_gbit.frame_status
274 273
275typedef struct _slic_host64sg_t { 274struct slic_host64sg {
276 ulong32 paddrl; 275 u32 paddrl;
277 ulong32 paddrh; 276 u32 paddrh;
278 ulong32 length; 277 u32 length;
279} slic_host64sg_t, *p_slic_host64sg_t; 278};
280 279
281typedef struct _slic_host64_cmd_t { 280struct slic_host64_cmd {
282 ulong32 hosthandle; 281 u32 hosthandle;
283 ulong32 RSVD; 282 u32 RSVD;
284 uchar command; 283 unsigned char command;
285 uchar flags; 284 unsigned char flags;
286 union { 285 union {
287 ushort rsv1; 286 ushort rsv1;
288 ushort rsv2; 287 ushort rsv2;
289 } u0; 288 } u0;
290 union { 289 union {
291 struct { 290 struct {
292 ulong32 totlen; 291 u32 totlen;
293 slic_host64sg_t bufs[SLIC_MAX64_BCNT]; 292 struct slic_host64sg bufs[SLIC_MAX64_BCNT];
294 } slic_buffers; 293 } slic_buffers;
295 } u; 294 } u;
295};
296 296
297} slic_host64_cmd_t, *p_slic_host64_cmd_t; 297struct slic_rspbuf {
298 u32 hosthandle;
299 u32 pad0;
300 u32 pad1;
301 u32 status;
302 u32 pad2[4];
298 303
299typedef struct _slic_rspbuf_t { 304};
300 ulong32 hosthandle;
301 ulong32 pad0;
302 ulong32 pad1;
303 ulong32 status;
304 ulong32 pad2[4];
305 305
306} slic_rspbuf_t, *p_slic_rspbuf_t; 306struct slic_regs {
307 u32 slic_reset; /* Reset Register */
308 u32 pad0;
307 309
308typedef ulong32 SLIC_REG; 310 u32 slic_icr; /* Interrupt Control Register */
309 311 u32 pad2;
310
311typedef struct _slic_regs_t {
312 ULONG slic_reset; /* Reset Register */
313 ULONG pad0;
314
315 ULONG slic_icr; /* Interrupt Control Register */
316 ULONG pad2;
317#define SLIC_ICR 0x0008 312#define SLIC_ICR 0x0008
318 313
319 ULONG slic_isp; /* Interrupt status pointer */ 314 u32 slic_isp; /* Interrupt status pointer */
320 ULONG pad1; 315 u32 pad1;
321#define SLIC_ISP 0x0010 316#define SLIC_ISP 0x0010
322 317
323 ULONG slic_isr; /* Interrupt status */ 318 u32 slic_isr; /* Interrupt status */
324 ULONG pad3; 319 u32 pad3;
325#define SLIC_ISR 0x0018 320#define SLIC_ISR 0x0018
326 321
327 SLIC_REG slic_hbar; /* Header buffer address reg */ 322 u32 slic_hbar; /* Header buffer address reg */
328 ULONG pad4; 323 u32 pad4;
329 /* 31-8 - phy addr of set of contiguous hdr buffers 324 /* 31-8 - phy addr of set of contiguous hdr buffers
330 7-0 - number of buffers passed 325 7-0 - number of buffers passed
331 Buffers are 256 bytes long on 256-byte boundaries. */ 326 Buffers are 256 bytes long on 256-byte boundaries. */
332#define SLIC_HBAR 0x0020 327#define SLIC_HBAR 0x0020
333#define SLIC_HBAR_CNT_MSK 0x000000FF 328#define SLIC_HBAR_CNT_MSK 0x000000FF
334 329
335 SLIC_REG slic_dbar; /* Data buffer handle & address reg */ 330 u32 slic_dbar; /* Data buffer handle & address reg */
336 ULONG pad5; 331 u32 pad5;
337 332
338 /* 4 sets of registers; Buffers are 2K bytes long 2 per 4K page. */ 333 /* 4 sets of registers; Buffers are 2K bytes long 2 per 4K page. */
339#define SLIC_DBAR 0x0028 334#define SLIC_DBAR 0x0028
340#define SLIC_DBAR_SIZE 2048 335#define SLIC_DBAR_SIZE 2048
341 336
342 SLIC_REG slic_cbar; /* Xmt Cmd buf addr regs.*/ 337 u32 slic_cbar; /* Xmt Cmd buf addr regs.*/
343 /* 1 per XMT interface 338 /* 1 per XMT interface
344 31-5 - phy addr of host command buffer 339 31-5 - phy addr of host command buffer
345 4-0 - length of cmd in multiples of 32 bytes 340 4-0 - length of cmd in multiples of 32 bytes
@@ -348,13 +343,13 @@ typedef struct _slic_regs_t {
348#define SLIC_CBAR_LEN_MSK 0x0000001F 343#define SLIC_CBAR_LEN_MSK 0x0000001F
349#define SLIC_CBAR_ALIGN 0x00000020 344#define SLIC_CBAR_ALIGN 0x00000020
350 345
351 SLIC_REG slic_wcs; /* write control store*/ 346 u32 slic_wcs; /* write control store*/
352#define SLIC_WCS 0x0034 347#define SLIC_WCS 0x0034
353#define SLIC_WCS_START 0x80000000 /*Start the SLIC (Jump to WCS)*/ 348#define SLIC_WCS_START 0x80000000 /*Start the SLIC (Jump to WCS)*/
354#define SLIC_WCS_COMPARE 0x40000000 /* Compare with value in WCS*/ 349#define SLIC_WCS_COMPARE 0x40000000 /* Compare with value in WCS*/
355 350
356 SLIC_REG slic_rbar; /* Response buffer address reg.*/ 351 u32 slic_rbar; /* Response buffer address reg.*/
357 ULONG pad7; 352 u32 pad7;
358 /*31-8 - phy addr of set of contiguous response buffers 353 /*31-8 - phy addr of set of contiguous response buffers
359 7-0 - number of buffers passed 354 7-0 - number of buffers passed
360 Buffers are 32 bytes long on 32-byte boundaries.*/ 355 Buffers are 32 bytes long on 32-byte boundaries.*/
@@ -362,166 +357,166 @@ typedef struct _slic_regs_t {
362#define SLIC_RBAR_CNT_MSK 0x000000FF 357#define SLIC_RBAR_CNT_MSK 0x000000FF
363#define SLIC_RBAR_SIZE 32 358#define SLIC_RBAR_SIZE 32
364 359
365 SLIC_REG slic_stats; /* read statistics (UPR) */ 360 u32 slic_stats; /* read statistics (UPR) */
366 ULONG pad8; 361 u32 pad8;
367#define SLIC_RSTAT 0x0040 362#define SLIC_RSTAT 0x0040
368 363
369 SLIC_REG slic_rlsr; /* read link status */ 364 u32 slic_rlsr; /* read link status */
370 ULONG pad9; 365 u32 pad9;
371#define SLIC_LSTAT 0x0048 366#define SLIC_LSTAT 0x0048
372 367
373 SLIC_REG slic_wmcfg; /* Write Mac Config */ 368 u32 slic_wmcfg; /* Write Mac Config */
374 ULONG pad10; 369 u32 pad10;
375#define SLIC_WMCFG 0x0050 370#define SLIC_WMCFG 0x0050
376 371
377 SLIC_REG slic_wphy; /* Write phy register */ 372 u32 slic_wphy; /* Write phy register */
378 ULONG pad11; 373 u32 pad11;
379#define SLIC_WPHY 0x0058 374#define SLIC_WPHY 0x0058
380 375
381 SLIC_REG slic_rcbar; /*Rcv Cmd buf addr reg*/ 376 u32 slic_rcbar; /*Rcv Cmd buf addr reg*/
382 ULONG pad12; 377 u32 pad12;
383#define SLIC_RCBAR 0x0060 378#define SLIC_RCBAR 0x0060
384 379
385 SLIC_REG slic_rconfig; /* Read SLIC Config*/ 380 u32 slic_rconfig; /* Read SLIC Config*/
386 ULONG pad13; 381 u32 pad13;
387#define SLIC_RCONFIG 0x0068 382#define SLIC_RCONFIG 0x0068
388 383
389 SLIC_REG slic_intagg; /* Interrupt aggregation time*/ 384 u32 slic_intagg; /* Interrupt aggregation time*/
390 ULONG pad14; 385 u32 pad14;
391#define SLIC_INTAGG 0x0070 386#define SLIC_INTAGG 0x0070
392 387
393 SLIC_REG slic_wxcfg; /* Write XMIT config reg*/ 388 u32 slic_wxcfg; /* Write XMIT config reg*/
394 ULONG pad16; 389 u32 pad16;
395#define SLIC_WXCFG 0x0078 390#define SLIC_WXCFG 0x0078
396 391
397 SLIC_REG slic_wrcfg; /* Write RCV config reg*/ 392 u32 slic_wrcfg; /* Write RCV config reg*/
398 ULONG pad17; 393 u32 pad17;
399#define SLIC_WRCFG 0x0080 394#define SLIC_WRCFG 0x0080
400 395
401 SLIC_REG slic_wraddral; /* Write rcv addr a low*/ 396 u32 slic_wraddral; /* Write rcv addr a low*/
402 ULONG pad18; 397 u32 pad18;
403#define SLIC_WRADDRAL 0x0088 398#define SLIC_WRADDRAL 0x0088
404 399
405 SLIC_REG slic_wraddrah; /* Write rcv addr a high*/ 400 u32 slic_wraddrah; /* Write rcv addr a high*/
406 ULONG pad19; 401 u32 pad19;
407#define SLIC_WRADDRAH 0x0090 402#define SLIC_WRADDRAH 0x0090
408 403
409 SLIC_REG slic_wraddrbl; /* Write rcv addr b low*/ 404 u32 slic_wraddrbl; /* Write rcv addr b low*/
410 ULONG pad20; 405 u32 pad20;
411#define SLIC_WRADDRBL 0x0098 406#define SLIC_WRADDRBL 0x0098
412 407
413 SLIC_REG slic_wraddrbh; /* Write rcv addr b high*/ 408 u32 slic_wraddrbh; /* Write rcv addr b high*/
414 ULONG pad21; 409 u32 pad21;
415#define SLIC_WRADDRBH 0x00a0 410#define SLIC_WRADDRBH 0x00a0
416 411
417 SLIC_REG slic_mcastlow; /* Low bits of mcast mask*/ 412 u32 slic_mcastlow; /* Low bits of mcast mask*/
418 ULONG pad22; 413 u32 pad22;
419#define SLIC_MCASTLOW 0x00a8 414#define SLIC_MCASTLOW 0x00a8
420 415
421 SLIC_REG slic_mcasthigh; /* High bits of mcast mask*/ 416 u32 slic_mcasthigh; /* High bits of mcast mask*/
422 ULONG pad23; 417 u32 pad23;
423#define SLIC_MCASTHIGH 0x00b0 418#define SLIC_MCASTHIGH 0x00b0
424 419
425 SLIC_REG slic_ping; /* Ping the card*/ 420 u32 slic_ping; /* Ping the card*/
426 ULONG pad24; 421 u32 pad24;
427#define SLIC_PING 0x00b8 422#define SLIC_PING 0x00b8
428 423
429 SLIC_REG slic_dump_cmd; /* Dump command */ 424 u32 slic_dump_cmd; /* Dump command */
430 ULONG pad25; 425 u32 pad25;
431#define SLIC_DUMP_CMD 0x00c0 426#define SLIC_DUMP_CMD 0x00c0
432 427
433 SLIC_REG slic_dump_data; /* Dump data pointer */ 428 u32 slic_dump_data; /* Dump data pointer */
434 ULONG pad26; 429 u32 pad26;
435#define SLIC_DUMP_DATA 0x00c8 430#define SLIC_DUMP_DATA 0x00c8
436 431
437 SLIC_REG slic_pcistatus; /* Read card's pci_status register */ 432 u32 slic_pcistatus; /* Read card's pci_status register */
438 ULONG pad27; 433 u32 pad27;
439#define SLIC_PCISTATUS 0x00d0 434#define SLIC_PCISTATUS 0x00d0
440 435
441 SLIC_REG slic_wrhostid; /* Write hostid field */ 436 u32 slic_wrhostid; /* Write hostid field */
442 ULONG pad28; 437 u32 pad28;
443#define SLIC_WRHOSTID 0x00d8 438#define SLIC_WRHOSTID 0x00d8
444#define SLIC_RDHOSTID_1GB 0x1554 439#define SLIC_RDHOSTID_1GB 0x1554
445#define SLIC_RDHOSTID_2GB 0x1554 440#define SLIC_RDHOSTID_2GB 0x1554
446 441
447 SLIC_REG slic_low_power; /* Put card in a low power state */ 442 u32 slic_low_power; /* Put card in a low power state */
448 ULONG pad29; 443 u32 pad29;
449#define SLIC_LOW_POWER 0x00e0 444#define SLIC_LOW_POWER 0x00e0
450 445
451 SLIC_REG slic_quiesce; /* force slic into quiescent state 446 u32 slic_quiesce; /* force slic into quiescent state
452 before soft reset */ 447 before soft reset */
453 ULONG pad30; 448 u32 pad30;
454#define SLIC_QUIESCE 0x00e8 449#define SLIC_QUIESCE 0x00e8
455 450
456 SLIC_REG slic_reset_iface; /* reset interface queues */ 451 u32 slic_reset_iface; /* reset interface queues */
457 ULONG pad31; 452 u32 pad31;
458#define SLIC_RESET_IFACE 0x00f0 453#define SLIC_RESET_IFACE 0x00f0
459 454
460 SLIC_REG slic_addr_upper; /* Bits 63-32 for host i/f addrs */ 455 u32 slic_addr_upper; /* Bits 63-32 for host i/f addrs */
461 ULONG pad32; 456 u32 pad32;
462#define SLIC_ADDR_UPPER 0x00f8 /*Register is only written when it has changed*/ 457#define SLIC_ADDR_UPPER 0x00f8 /*Register is only written when it has changed*/
463 458
464 SLIC_REG slic_hbar64; /* 64 bit Header buffer address reg */ 459 u32 slic_hbar64; /* 64 bit Header buffer address reg */
465 ULONG pad33; 460 u32 pad33;
466#define SLIC_HBAR64 0x0100 461#define SLIC_HBAR64 0x0100
467 462
468 SLIC_REG slic_dbar64; /* 64 bit Data buffer handle & address reg */ 463 u32 slic_dbar64; /* 64 bit Data buffer handle & address reg */
469 ULONG pad34; 464 u32 pad34;
470#define SLIC_DBAR64 0x0108 465#define SLIC_DBAR64 0x0108
471 466
472 SLIC_REG slic_cbar64; /* 64 bit Xmt Cmd buf addr regs. */ 467 u32 slic_cbar64; /* 64 bit Xmt Cmd buf addr regs. */
473 ULONG pad35; 468 u32 pad35;
474#define SLIC_CBAR64 0x0110 469#define SLIC_CBAR64 0x0110
475 470
476 SLIC_REG slic_rbar64; /* 64 bit Response buffer address reg.*/ 471 u32 slic_rbar64; /* 64 bit Response buffer address reg.*/
477 ULONG pad36; 472 u32 pad36;
478#define SLIC_RBAR64 0x0118 473#define SLIC_RBAR64 0x0118
479 474
480 SLIC_REG slic_rcbar64; /* 64 bit Rcv Cmd buf addr reg*/ 475 u32 slic_rcbar64; /* 64 bit Rcv Cmd buf addr reg*/
481 ULONG pad37; 476 u32 pad37;
482#define SLIC_RCBAR64 0x0120 477#define SLIC_RCBAR64 0x0120
483 478
484 SLIC_REG slic_stats64; /*read statistics (64 bit UPR)*/ 479 u32 slic_stats64; /*read statistics (64 bit UPR)*/
485 ULONG pad38; 480 u32 pad38;
486#define SLIC_RSTAT64 0x0128 481#define SLIC_RSTAT64 0x0128
487 482
488 SLIC_REG slic_rcv_wcs; /*Download Gigabit RCV sequencer ucode*/ 483 u32 slic_rcv_wcs; /*Download Gigabit RCV sequencer ucode*/
489 ULONG pad39; 484 u32 pad39;
490#define SLIC_RCV_WCS 0x0130 485#define SLIC_RCV_WCS 0x0130
491#define SLIC_RCVWCS_BEGIN 0x40000000 486#define SLIC_RCVWCS_BEGIN 0x40000000
492#define SLIC_RCVWCS_FINISH 0x80000000 487#define SLIC_RCVWCS_FINISH 0x80000000
493 488
494 SLIC_REG slic_wrvlanid; /* Write VlanId field */ 489 u32 slic_wrvlanid; /* Write VlanId field */
495 ULONG pad40; 490 u32 pad40;
496#define SLIC_WRVLANID 0x0138 491#define SLIC_WRVLANID 0x0138
497 492
498 SLIC_REG slic_read_xf_info; /* Read Transformer info */ 493 u32 slic_read_xf_info; /* Read Transformer info */
499 ULONG pad41; 494 u32 pad41;
500#define SLIC_READ_XF_INFO 0x0140 495#define SLIC_READ_XF_INFO 0x0140
501 496
502 SLIC_REG slic_write_xf_info; /* Write Transformer info */ 497 u32 slic_write_xf_info; /* Write Transformer info */
503 ULONG pad42; 498 u32 pad42;
504#define SLIC_WRITE_XF_INFO 0x0148 499#define SLIC_WRITE_XF_INFO 0x0148
505 500
506 SLIC_REG RSVD1; /* TOE Only */ 501 u32 RSVD1; /* TOE Only */
507 ULONG pad43; 502 u32 pad43;
508 503
509 SLIC_REG RSVD2; /* TOE Only */ 504 u32 RSVD2; /* TOE Only */
510 ULONG pad44; 505 u32 pad44;
511 506
512 SLIC_REG RSVD3; /* TOE Only */ 507 u32 RSVD3; /* TOE Only */
513 ULONG pad45; 508 u32 pad45;
514 509
515 SLIC_REG RSVD4; /* TOE Only */ 510 u32 RSVD4; /* TOE Only */
516 ULONG pad46; 511 u32 pad46;
517 512
518 SLIC_REG slic_ticks_per_sec; /* Write card ticks per second */ 513 u32 slic_ticks_per_sec; /* Write card ticks per second */
519 ULONG pad47; 514 u32 pad47;
520#define SLIC_TICKS_PER_SEC 0x0170 515#define SLIC_TICKS_PER_SEC 0x0170
521 516
522} __iomem slic_regs_t, *p_slic_regs_t, SLIC_REGS, *PSLIC_REGS; 517};
523 518
524typedef enum _UPR_REQUEST { 519enum UPR_REQUEST {
525 SLIC_UPR_STATS, 520 SLIC_UPR_STATS,
526 SLIC_UPR_RLSR, 521 SLIC_UPR_RLSR,
527 SLIC_UPR_WCFG, 522 SLIC_UPR_WCFG,
@@ -532,103 +527,102 @@ typedef enum _UPR_REQUEST {
532 SLIC_UPR_PDWN, 527 SLIC_UPR_PDWN,
533 SLIC_UPR_PING, 528 SLIC_UPR_PING,
534 SLIC_UPR_DUMP, 529 SLIC_UPR_DUMP,
535} UPR_REQUEST; 530};
536 531
537typedef struct _inicpm_wakepattern { 532struct inicpm_wakepattern {
538 ulong32 patternlength; 533 u32 patternlength;
539 uchar pattern[SLIC_PM_PATTERNSIZE]; 534 unsigned char pattern[SLIC_PM_PATTERNSIZE];
540 uchar mask[SLIC_PM_PATTERNSIZE]; 535 unsigned char mask[SLIC_PM_PATTERNSIZE];
541} inicpm_wakepattern_t, *p_inicpm_wakepattern_t; 536};
542 537
543typedef struct _inicpm_state { 538struct inicpm_state {
544 ulong32 powercaps; 539 u32 powercaps;
545 ulong32 powerstate; 540 u32 powerstate;
546 ulong32 wake_linkstatus; 541 u32 wake_linkstatus;
547 ulong32 wake_magicpacket; 542 u32 wake_magicpacket;
548 ulong32 wake_framepattern; 543 u32 wake_framepattern;
549 inicpm_wakepattern_t wakepattern[SLIC_PM_MAXPATTERNS]; 544 struct inicpm_wakepattern wakepattern[SLIC_PM_MAXPATTERNS];
550} inicpm_state_t, *p_inicpm_state_t; 545};
551 546
552typedef struct _slicpm_packet_pattern { 547struct slicpm_packet_pattern {
553 ulong32 priority; 548 u32 priority;
554 ulong32 reserved; 549 u32 reserved;
555 ulong32 masksize; 550 u32 masksize;
556 ulong32 patternoffset; 551 u32 patternoffset;
557 ulong32 patternsize; 552 u32 patternsize;
558 ulong32 patternflags; 553 u32 patternflags;
559} slicpm_packet_pattern_t, *p_slicpm_packet_pattern_t; 554};
560 555
561typedef enum _slicpm_power_state { 556enum slicpm_power_state {
562 slicpm_state_unspecified = 0, 557 slicpm_state_unspecified = 0,
563 slicpm_state_d0, 558 slicpm_state_d0,
564 slicpm_state_d1, 559 slicpm_state_d1,
565 slicpm_state_d2, 560 slicpm_state_d2,
566 slicpm_state_d3, 561 slicpm_state_d3,
567 slicpm_state_maximum 562 slicpm_state_maximum
568} slicpm_state_t, *p_slicpm_state_t; 563};
569 564
570typedef struct _slicpm_wakeup_capabilities { 565struct slicpm_wakeup_capabilities {
571 slicpm_state_t min_magic_packet_wakeup; 566 enum slicpm_power_state min_magic_packet_wakeup;
572 slicpm_state_t min_pattern_wakeup; 567 enum slicpm_power_state min_pattern_wakeup;
573 slicpm_state_t min_link_change_wakeup; 568 enum slicpm_power_state min_link_change_wakeup;
574} slicpm_wakeup_capabilities_t, *p_slicpm_wakeup_capabilities_t; 569};
575 570
576 571struct slic_pnp_capabilities {
577typedef struct _slic_pnp_capabilities { 572 u32 flags;
578 ulong32 flags; 573 struct slicpm_wakeup_capabilities wakeup_capabilities;
579 slicpm_wakeup_capabilities_t wakeup_capabilities; 574};
580} slic_pnp_capabilities_t, *p_slic_pnp_capabilities_t; 575
581 576struct xmt_stats {
582typedef struct _xmt_stats_t { 577 u32 xmit_tcp_bytes;
583 ulong32 xmit_tcp_bytes; 578 u32 xmit_tcp_segs;
584 ulong32 xmit_tcp_segs; 579 u32 xmit_bytes;
585 ulong32 xmit_bytes; 580 u32 xmit_collisions;
586 ulong32 xmit_collisions; 581 u32 xmit_unicasts;
587 ulong32 xmit_unicasts; 582 u32 xmit_other_error;
588 ulong32 xmit_other_error; 583 u32 xmit_excess_collisions;
589 ulong32 xmit_excess_collisions; 584};
590} xmt_stats100_t; 585
591 586struct rcv_stats {
592typedef struct _rcv_stats_t { 587 u32 rcv_tcp_bytes;
593 ulong32 rcv_tcp_bytes; 588 u32 rcv_tcp_segs;
594 ulong32 rcv_tcp_segs; 589 u32 rcv_bytes;
595 ulong32 rcv_bytes; 590 u32 rcv_unicasts;
596 ulong32 rcv_unicasts; 591 u32 rcv_other_error;
597 ulong32 rcv_other_error; 592 u32 rcv_drops;
598 ulong32 rcv_drops; 593};
599} rcv_stats100_t; 594
600 595struct xmt_statsgb {
601typedef struct _xmt_statsgb_t { 596 u64 xmit_tcp_bytes;
602 ulong64 xmit_tcp_bytes; 597 u64 xmit_tcp_segs;
603 ulong64 xmit_tcp_segs; 598 u64 xmit_bytes;
604 ulong64 xmit_bytes; 599 u64 xmit_collisions;
605 ulong64 xmit_collisions; 600 u64 xmit_unicasts;
606 ulong64 xmit_unicasts; 601 u64 xmit_other_error;
607 ulong64 xmit_other_error; 602 u64 xmit_excess_collisions;
608 ulong64 xmit_excess_collisions; 603};
609} xmt_statsGB_t; 604
610 605struct rcv_statsgb {
611typedef struct _rcv_statsgb_t { 606 u64 rcv_tcp_bytes;
612 ulong64 rcv_tcp_bytes; 607 u64 rcv_tcp_segs;
613 ulong64 rcv_tcp_segs; 608 u64 rcv_bytes;
614 ulong64 rcv_bytes; 609 u64 rcv_unicasts;
615 ulong64 rcv_unicasts; 610 u64 rcv_other_error;
616 u64 rcv_other_error; 611 u64 rcv_drops;
617 ulong64 rcv_drops; 612};
618} rcv_statsGB_t; 613
619 614struct slic_stats {
620typedef struct _slic_stats {
621 union { 615 union {
622 struct { 616 struct {
623 xmt_stats100_t xmt100; 617 struct xmt_stats xmt100;
624 rcv_stats100_t rcv100; 618 struct rcv_stats rcv100;
625 } stats_100; 619 } stats_100;
626 struct { 620 struct {
627 xmt_statsGB_t xmtGB; 621 struct xmt_statsgb xmtGB;
628 rcv_statsGB_t rcvGB; 622 struct rcv_statsgb rcvGB;
629 } stats_GB; 623 } stats_GB;
630 } u; 624 } u;
631} slic_stats_t, *p_slic_stats_t; 625};
632 626
633#define xmit_tcp_segs100 u.stats_100.xmt100.xmit_tcp_segs 627#define xmit_tcp_segs100 u.stats_100.xmt100.xmit_tcp_segs
634#define xmit_tcp_bytes100 u.stats_100.xmt100.xmit_tcp_bytes 628#define xmit_tcp_bytes100 u.stats_100.xmt100.xmit_tcp_bytes
@@ -658,10 +652,9 @@ typedef struct _slic_stats {
658#define rcv_other_error_gb u.stats_GB.rcvGB.rcv_other_error 652#define rcv_other_error_gb u.stats_GB.rcvGB.rcv_other_error
659#define rcv_drops_gb u.stats_GB.rcvGB.rcv_drops 653#define rcv_drops_gb u.stats_GB.rcvGB.rcv_drops
660 654
661typedef struct _slic_config_mac_t { 655struct slic_config_mac {
662 uchar macaddrA[6]; 656 unsigned char macaddrA[6];
663 657};
664} slic_config_mac_t, *pslic_config_mac_t;
665 658
666#define ATK_FRU_FORMAT 0x00 659#define ATK_FRU_FORMAT 0x00
667#define VENDOR1_FRU_FORMAT 0x01 660#define VENDOR1_FRU_FORMAT 0x01
@@ -670,68 +663,68 @@ typedef struct _slic_config_mac_t {
670#define VENDOR4_FRU_FORMAT 0x04 663#define VENDOR4_FRU_FORMAT 0x04
671#define NO_FRU_FORMAT 0xFF 664#define NO_FRU_FORMAT 0xFF
672 665
673typedef struct _atk_fru_t { 666struct atk_fru {
674 uchar assembly[6]; 667 unsigned char assembly[6];
675 uchar revision[2]; 668 unsigned char revision[2];
676 uchar serial[14]; 669 unsigned char serial[14];
677 uchar pad[3]; 670 unsigned char pad[3];
678} atk_fru_t, *patk_fru_t; 671};
679 672
680typedef struct _vendor1_fru_t { 673struct vendor1_fru {
681 uchar commodity; 674 unsigned char commodity;
682 uchar assembly[4]; 675 unsigned char assembly[4];
683 uchar revision[2]; 676 unsigned char revision[2];
684 uchar supplier[2]; 677 unsigned char supplier[2];
685 uchar date[2]; 678 unsigned char date[2];
686 uchar sequence[3]; 679 unsigned char sequence[3];
687 uchar pad[13]; 680 unsigned char pad[13];
688} vendor1_fru_t, *pvendor1_fru_t; 681};
689 682
690typedef struct _vendor2_fru_t { 683struct vendor2_fru {
691 uchar part[8]; 684 unsigned char part[8];
692 uchar supplier[5]; 685 unsigned char supplier[5];
693 uchar date[3]; 686 unsigned char date[3];
694 uchar sequence[4]; 687 unsigned char sequence[4];
695 uchar pad[7]; 688 unsigned char pad[7];
696} vendor2_fru_t, *pvendor2_fru_t; 689};
697 690
698typedef struct _vendor3_fru_t { 691struct vendor3_fru {
699 uchar assembly[6]; 692 unsigned char assembly[6];
700 uchar revision[2]; 693 unsigned char revision[2];
701 uchar serial[14]; 694 unsigned char serial[14];
702 uchar pad[3]; 695 unsigned char pad[3];
703} vendor3_fru_t, *pvendor3_fru_t; 696};
704 697
705typedef struct _vendor4_fru_t { 698struct vendor4_fru {
706 uchar number[8]; 699 unsigned char number[8];
707 uchar part[8]; 700 unsigned char part[8];
708 uchar version[8]; 701 unsigned char version[8];
709 uchar pad[3]; 702 unsigned char pad[3];
710} vendor4_fru_t, *pvendor4_fru_t; 703};
711 704
712typedef union _oemfru_t { 705union oemfru_t {
713 vendor1_fru_t vendor1_fru; 706 struct vendor1_fru vendor1_fru;
714 vendor2_fru_t vendor2_fru; 707 struct vendor2_fru vendor2_fru;
715 vendor3_fru_t vendor3_fru; 708 struct vendor3_fru vendor3_fru;
716 vendor4_fru_t vendor4_fru; 709 struct vendor4_fru vendor4_fru;
717} oemfru_t, *poemfru_t; 710};
718 711
719/* 712/*
720 SLIC EEPROM structure for Mojave 713 SLIC EEPROM structure for Mojave
721*/ 714*/
722typedef struct _slic_eeprom { 715struct slic_eeprom {
723 ushort Id; /* 00 EEPROM/FLASH Magic code 'A5A5'*/ 716 ushort Id; /* 00 EEPROM/FLASH Magic code 'A5A5'*/
724 ushort EecodeSize; /* 01 Size of EEPROM Codes (bytes * 4)*/ 717 ushort EecodeSize; /* 01 Size of EEPROM Codes (bytes * 4)*/
725 ushort FlashSize; /* 02 Flash size */ 718 ushort FlashSize; /* 02 Flash size */
726 ushort EepromSize; /* 03 EEPROM Size */ 719 ushort EepromSize; /* 03 EEPROM Size */
727 ushort VendorId; /* 04 Vendor ID */ 720 ushort VendorId; /* 04 Vendor ID */
728 ushort DeviceId; /* 05 Device ID */ 721 ushort DeviceId; /* 05 Device ID */
729 uchar RevisionId; /* 06 Revision ID */ 722 unsigned char RevisionId; /* 06 Revision ID */
730 uchar ClassCode[3]; /* 07 Class Code */ 723 unsigned char ClassCode[3]; /* 07 Class Code */
731 uchar DbgIntPin; /* 08 Debug Interrupt pin */ 724 unsigned char DbgIntPin; /* 08 Debug Interrupt pin */
732 uchar NetIntPin0; /* Network Interrupt Pin */ 725 unsigned char NetIntPin0; /* Network Interrupt Pin */
733 uchar MinGrant; /* 09 Minimum grant */ 726 unsigned char MinGrant; /* 09 Minimum grant */
734 uchar MaxLat; /* Maximum Latency */ 727 unsigned char MaxLat; /* Maximum Latency */
735 ushort PciStatus; /* 10 PCI Status */ 728 ushort PciStatus; /* 10 PCI Status */
736 ushort SubSysVId; /* 11 Subsystem Vendor Id */ 729 ushort SubSysVId; /* 11 Subsystem Vendor Id */
737 ushort SubSysId; /* 12 Subsystem ID */ 730 ushort SubSysId; /* 12 Subsystem ID */
@@ -739,58 +732,60 @@ typedef struct _slic_eeprom {
739 ushort DramRomFn; /* 14 Dram/Rom function */ 732 ushort DramRomFn; /* 14 Dram/Rom function */
740 ushort DSize2Pci; /* 15 DRAM size to PCI (bytes * 64K) */ 733 ushort DSize2Pci; /* 15 DRAM size to PCI (bytes * 64K) */
741 ushort RSize2Pci; /* 16 ROM extension size to PCI (bytes * 4k) */ 734 ushort RSize2Pci; /* 16 ROM extension size to PCI (bytes * 4k) */
742 uchar NetIntPin1; /* 17 Network Interface Pin 1 (simba/leone only) */ 735 unsigned char NetIntPin1;/* 17 Network Interface Pin 1
743 uchar NetIntPin2; /* Network Interface Pin 2 (simba/leone only) */ 736 (simba/leone only) */
737 unsigned char NetIntPin2; /*Network Interface Pin 2 (simba/leone only)*/
744 union { 738 union {
745 uchar NetIntPin3;/* 18 Network Interface Pin 3 (simba only) */ 739 unsigned char NetIntPin3;/*18 Network Interface Pin 3
746 uchar FreeTime;/* FreeTime setting (leone/mojave only) */ 740 (simba only)*/
741 unsigned char FreeTime;/*FreeTime setting (leone/mojave only) */
747 } u1; 742 } u1;
748 uchar TBIctl; /* 10-bit interface control (Mojave only) */ 743 unsigned char TBIctl; /* 10-bit interface control (Mojave only) */
749 ushort DramSize; /* 19 DRAM size (bytes * 64k) */ 744 ushort DramSize; /* 19 DRAM size (bytes * 64k) */
750 union { 745 union {
751 struct { 746 struct {
752 /* Mac Interface Specific portions */ 747 /* Mac Interface Specific portions */
753 slic_config_mac_t MacInfo[SLIC_NBR_MACS]; 748 struct slic_config_mac MacInfo[SLIC_NBR_MACS];
754 } mac; /* MAC access for all boards */ 749 } mac; /* MAC access for all boards */
755 struct { 750 struct {
756 /* use above struct for MAC access */ 751 /* use above struct for MAC access */
757 slic_config_mac_t pad[SLIC_NBR_MACS - 1]; 752 struct slic_config_mac pad[SLIC_NBR_MACS - 1];
758 ushort DeviceId2; /* Device ID for 2nd 753 ushort DeviceId2; /* Device ID for 2nd
759 PCI function */ 754 PCI function */
760 uchar IntPin2; /* Interrupt pin for 755 unsigned char IntPin2; /* Interrupt pin for
761 2nd PCI function */ 756 2nd PCI function */
762 uchar ClassCode2[3]; /* Class Code for 2nd 757 unsigned char ClassCode2[3]; /* Class Code for 2nd
763 PCI function */ 758 PCI function */
764 } mojave; /* 2nd function access for gigabit board */ 759 } mojave; /* 2nd function access for gigabit board */
765 } u2; 760 } u2;
766 ushort CfgByte6; /* Config Byte 6 */ 761 ushort CfgByte6; /* Config Byte 6 */
767 ushort PMECapab; /* Power Mgment capabilities */ 762 ushort PMECapab; /* Power Mgment capabilities */
768 ushort NwClkCtrls; /* NetworkClockControls */ 763 ushort NwClkCtrls; /* NetworkClockControls */
769 uchar FruFormat; /* Alacritech FRU format type */ 764 unsigned char FruFormat; /* Alacritech FRU format type */
770 atk_fru_t AtkFru; /* Alacritech FRU information */ 765 struct atk_fru AtkFru; /* Alacritech FRU information */
771 uchar OemFruFormat; /* optional OEM FRU format type */ 766 unsigned char OemFruFormat; /* optional OEM FRU format type */
772 oemfru_t OemFru; /* optional OEM FRU information */ 767 union oemfru_t OemFru; /* optional OEM FRU information */
773 uchar Pad[4]; /* Pad to 128 bytes - includes 2 cksum bytes 768 unsigned char Pad[4]; /* Pad to 128 bytes - includes 2 cksum bytes
774 *(if OEM FRU info exists) and two unusable 769 *(if OEM FRU info exists) and two unusable
775 * bytes at the end */ 770 * bytes at the end */
776} slic_eeprom_t, *pslic_eeprom_t; 771};
777 772
778/* SLIC EEPROM structure for Oasis */ 773/* SLIC EEPROM structure for Oasis */
779typedef struct _oslic_eeprom_t { 774struct oslic_eeprom {
780 ushort Id; /* 00 EEPROM/FLASH Magic code 'A5A5' */ 775 ushort Id; /* 00 EEPROM/FLASH Magic code 'A5A5' */
781 ushort EecodeSize; /* 01 Size of EEPROM Codes (bytes * 4)*/ 776 ushort EecodeSize; /* 01 Size of EEPROM Codes (bytes * 4)*/
782 ushort FlashConfig0; /* 02 Flash Config for SPI device 0 */ 777 ushort FlashConfig0; /* 02 Flash Config for SPI device 0 */
783 ushort FlashConfig1; /* 03 Flash Config for SPI device 1 */ 778 ushort FlashConfig1; /* 03 Flash Config for SPI device 1 */
784 ushort VendorId; /* 04 Vendor ID */ 779 ushort VendorId; /* 04 Vendor ID */
785 ushort DeviceId; /* 05 Device ID (function 0) */ 780 ushort DeviceId; /* 05 Device ID (function 0) */
786 uchar RevisionId; /* 06 Revision ID */ 781 unsigned char RevisionId; /* 06 Revision ID */
787 uchar ClassCode[3]; /* 07 Class Code for PCI function 0 */ 782 unsigned char ClassCode[3]; /* 07 Class Code for PCI function 0 */
788 uchar IntPin1; /* 08 Interrupt pin for PCI function 1*/ 783 unsigned char IntPin1; /* 08 Interrupt pin for PCI function 1*/
789 uchar ClassCode2[3]; /* 09 Class Code for PCI function 1 */ 784 unsigned char ClassCode2[3]; /* 09 Class Code for PCI function 1 */
790 uchar IntPin2; /* 10 Interrupt pin for PCI function 2*/ 785 unsigned char IntPin2; /* 10 Interrupt pin for PCI function 2*/
791 uchar IntPin0; /* Interrupt pin for PCI function 0*/ 786 unsigned char IntPin0; /* Interrupt pin for PCI function 0*/
792 uchar MinGrant; /* 11 Minimum grant */ 787 unsigned char MinGrant; /* 11 Minimum grant */
793 uchar MaxLat; /* Maximum Latency */ 788 unsigned char MaxLat; /* Maximum Latency */
794 ushort SubSysVId; /* 12 Subsystem Vendor Id */ 789 ushort SubSysVId; /* 12 Subsystem Vendor Id */
795 ushort SubSysId; /* 13 Subsystem ID */ 790 ushort SubSysId; /* 13 Subsystem ID */
796 ushort FlashSize; /* 14 Flash size (bytes / 4K) */ 791 ushort FlashSize; /* 14 Flash size (bytes / 4K) */
@@ -801,8 +796,8 @@ typedef struct _oslic_eeprom_t {
801 ushort DeviceId2; /* 18 Device Id (function 2) */ 796 ushort DeviceId2; /* 18 Device Id (function 2) */
802 ushort CfgByte6; /* 19 Device Status Config Bytes 6-7 */ 797 ushort CfgByte6; /* 19 Device Status Config Bytes 6-7 */
803 ushort PMECapab; /* 20 Power Mgment capabilities */ 798 ushort PMECapab; /* 20 Power Mgment capabilities */
804 uchar MSICapab; /* 21 MSI capabilities */ 799 unsigned char MSICapab; /* 21 MSI capabilities */
805 uchar ClockDivider; /* Clock divider */ 800 unsigned char ClockDivider; /* Clock divider */
806 ushort PciStatusLow; /* 22 PCI Status bits 15:0 */ 801 ushort PciStatusLow; /* 22 PCI Status bits 15:0 */
807 ushort PciStatusHigh; /* 23 PCI Status bits 31:16 */ 802 ushort PciStatusHigh; /* 23 PCI Status bits 31:16 */
808 ushort DramConfigLow; /* 24 DRAM Configuration bits 15:0 */ 803 ushort DramConfigLow; /* 24 DRAM Configuration bits 15:0 */
@@ -810,18 +805,18 @@ typedef struct _oslic_eeprom_t {
810 ushort DramSize; /* 26 DRAM size (bytes / 64K) */ 805 ushort DramSize; /* 26 DRAM size (bytes / 64K) */
811 ushort GpioTbiCtl;/* 27 GPIO/TBI controls for functions 1/0 */ 806 ushort GpioTbiCtl;/* 27 GPIO/TBI controls for functions 1/0 */
812 ushort EepromSize; /* 28 EEPROM Size */ 807 ushort EepromSize; /* 28 EEPROM Size */
813 slic_config_mac_t MacInfo[2]; /* 29 MAC addresses (2 ports) */ 808 struct slic_config_mac MacInfo[2]; /* 29 MAC addresses (2 ports) */
814 uchar FruFormat; /* 35 Alacritech FRU format type */ 809 unsigned char FruFormat; /* 35 Alacritech FRU format type */
815 atk_fru_t AtkFru; /* Alacritech FRU information */ 810 struct atk_fru AtkFru; /* Alacritech FRU information */
816 uchar OemFruFormat; /* optional OEM FRU format type */ 811 unsigned char OemFruFormat; /* optional OEM FRU format type */
817 oemfru_t OemFru; /* optional OEM FRU information */ 812 union oemfru_t OemFru; /* optional OEM FRU information */
818 uchar Pad[4]; /* Pad to 128 bytes - includes 2 checksum bytes 813 unsigned char Pad[4]; /* Pad to 128 bytes - includes 2 checksum bytes
819 * (if OEM FRU info exists) and two unusable 814 * (if OEM FRU info exists) and two unusable
820 * bytes at the end 815 * bytes at the end
821 */ 816 */
822} oslic_eeprom_t, *poslic_eeprom_t; 817};
823 818
824#define MAX_EECODE_SIZE sizeof(slic_eeprom_t) 819#define MAX_EECODE_SIZE sizeof(struct slic_eeprom)
825#define MIN_EECODE_SIZE 0x62 /* code size without optional OEM FRU stuff */ 820#define MIN_EECODE_SIZE 0x62 /* code size without optional OEM FRU stuff */
826 821
827/* SLIC CONFIG structure 822/* SLIC CONFIG structure
@@ -830,20 +825,20 @@ typedef struct _oslic_eeprom_t {
830 board types. It is filled in from the appropriate EEPROM structure 825 board types. It is filled in from the appropriate EEPROM structure
831 by SlicGetConfigData(). 826 by SlicGetConfigData().
832*/ 827*/
833typedef struct _slic_config_t { 828struct slic_config {
834 boolean EepromValid; /* Valid EEPROM flag (checksum good?) */ 829 bool EepromValid; /* Valid EEPROM flag (checksum good?) */
835 ushort DramSize; /* DRAM size (bytes / 64K) */ 830 ushort DramSize; /* DRAM size (bytes / 64K) */
836 slic_config_mac_t MacInfo[SLIC_NBR_MACS]; /* MAC addresses */ 831 struct slic_config_mac MacInfo[SLIC_NBR_MACS]; /* MAC addresses */
837 uchar FruFormat; /* Alacritech FRU format type */ 832 unsigned char FruFormat; /* Alacritech FRU format type */
838 atk_fru_t AtkFru; /* Alacritech FRU information */ 833 struct atk_fru AtkFru; /* Alacritech FRU information */
839 uchar OemFruFormat; /* optional OEM FRU format type */ 834 unsigned char OemFruFormat; /* optional OEM FRU format type */
840 union { 835 union {
841 vendor1_fru_t vendor1_fru; 836 struct vendor1_fru vendor1_fru;
842 vendor2_fru_t vendor2_fru; 837 struct vendor2_fru vendor2_fru;
843 vendor3_fru_t vendor3_fru; 838 struct vendor3_fru vendor3_fru;
844 vendor4_fru_t vendor4_fru; 839 struct vendor4_fru vendor4_fru;
845 } OemFru; 840 } OemFru;
846} slic_config_t, *pslic_config_t; 841};
847 842
848#pragma pack() 843#pragma pack()
849 844
diff --git a/drivers/staging/slicoss/slicinc.h b/drivers/staging/slicoss/slicinc.h
index 9910306ac33b..610c1abd988b 100644
--- a/drivers/staging/slicoss/slicinc.h
+++ b/drivers/staging/slicoss/slicinc.h
@@ -2,7 +2,6 @@
2 * 2 *
3 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved. 3 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved.
4 * 4 *
5 * $Id: slicinc.h,v 1.4 2006/07/14 16:42:56 mook Exp $
6 * 5 *
7 * Redistribution and use in source and binary forms, with or without 6 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions 7 * modification, are permitted provided that the following conditions
@@ -48,164 +47,135 @@
48#include "slichw.h" 47#include "slichw.h"
49#include "slic.h" 48#include "slic.h"
50 49
51int slic_entry_probe(struct pci_dev *pcidev, 50static int slic_entry_probe(struct pci_dev *pcidev,
52 const struct pci_device_id *ent); 51 const struct pci_device_id *ent);
53int slic_init(struct pci_dev *pcidev, 52static void slic_entry_remove(struct pci_dev *pcidev);
54 const struct pci_device_id *pci_tbl_entry,
55 long memaddr,
56 int chip_idx,
57 int acpi_idle_state);
58void slic_entry_remove(struct pci_dev *pcidev);
59 53
60void slic_init_driver(void); 54static void slic_init_driver(void);
61int slic_entry_open(struct net_device *dev); 55static int slic_entry_open(struct net_device *dev);
62int slic_entry_halt(struct net_device *dev); 56static int slic_entry_halt(struct net_device *dev);
63int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); 57static int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
64int slic_xmit_start(struct sk_buff *skb, struct net_device *dev); 58static int slic_xmit_start(struct sk_buff *skb, struct net_device *dev);
65void slic_xmit_fail(p_adapter_t adapter, 59static void slic_xmit_fail(struct adapter *adapter,
66 struct sk_buff *skb, 60 struct sk_buff *skb,
67 pvoid cmd, 61 void *cmd,
68 ulong32 skbtype, 62 u32 skbtype,
69 ulong32 status); 63 u32 status);
70void slic_xmit_timeout(struct net_device *dev); 64static void slic_xmit_timeout(struct net_device *dev);
71void slic_config_pci(struct pci_dev *pcidev); 65static void slic_config_pci(struct pci_dev *pcidev);
72struct sk_buff *slic_rcvqueue_getnext(p_adapter_t adapter); 66static struct sk_buff *slic_rcvqueue_getnext(struct adapter *adapter);
73 67
74inline void slic_reg32_write(void __iomem *reg, ulong32 value, uint flush); 68static inline void slic_reg32_write(void __iomem *reg, u32 value, uint flush);
75inline void slic_reg64_write(p_adapter_t adapter, void __iomem *reg, 69static inline void slic_reg64_write(struct adapter *adapter, void __iomem *reg,
76 ulong32 value, void __iomem *regh, ulong32 paddrh, uint flush); 70 u32 value, void __iomem *regh, u32 paddrh, uint flush);
77inline ulong32 slic_reg32_read(pulong32 reg, uint flush);
78inline ulong32 slic_reg16_read(pulong32 reg, uint flush);
79 71
80#if SLIC_GET_STATS_ENABLED 72#if SLIC_GET_STATS_ENABLED
81struct net_device_stats *slic_get_stats(struct net_device *dev); 73static struct net_device_stats *slic_get_stats(struct net_device *dev);
82#endif 74#endif
83 75
84int slic_mac_set_address(struct net_device *dev, pvoid ptr); 76static int slic_mac_set_address(struct net_device *dev, void *ptr);
77static void slic_rcv_handler(struct adapter *adapter);
78static void slic_link_event_handler(struct adapter *adapter);
79static void slic_xmit_complete(struct adapter *adapter);
80static void slic_upr_request_complete(struct adapter *adapter, u32 isr);
81static int slic_rspqueue_init(struct adapter *adapter);
82static int slic_rspqueue_reset(struct adapter *adapter);
83static void slic_rspqueue_free(struct adapter *adapter);
84static struct slic_rspbuf *slic_rspqueue_getnext(struct adapter *adapter);
85static void slic_cmdqmem_init(struct adapter *adapter);
86static void slic_cmdqmem_free(struct adapter *adapter);
87static u32 *slic_cmdqmem_addpage(struct adapter *adapter);
88static int slic_cmdq_init(struct adapter *adapter);
89static void slic_cmdq_free(struct adapter *adapter);
90static void slic_cmdq_reset(struct adapter *adapter);
91static void slic_cmdq_addcmdpage(struct adapter *adapter, u32 *page);
92static void slic_cmdq_getdone(struct adapter *adapter);
93static void slic_cmdq_putdone(struct adapter *adapter,
94 struct slic_hostcmd *cmd);
95static void slic_cmdq_putdone_irq(struct adapter *adapter,
96 struct slic_hostcmd *cmd);
97static struct slic_hostcmd *slic_cmdq_getfree(struct adapter *adapter);
98static int slic_rcvqueue_init(struct adapter *adapter);
99static int slic_rcvqueue_reset(struct adapter *adapter);
100static int slic_rcvqueue_fill(struct adapter *adapter);
101static u32 slic_rcvqueue_reinsert(struct adapter *adapter, struct sk_buff *skb);
102static void slic_rcvqueue_free(struct adapter *adapter);
103static void slic_rcv_handle_error(struct adapter *adapter,
104 struct slic_rcvbuf *rcvbuf);
105static void slic_adapter_set_hwaddr(struct adapter *adapter);
106static void slic_card_halt(struct sliccard *card, struct adapter *adapter);
107static int slic_card_init(struct sliccard *card, struct adapter *adapter);
108static void slic_intagg_set(struct adapter *adapter, u32 value);
109static int slic_card_download(struct adapter *adapter);
110static u32 slic_card_locate(struct adapter *adapter);
85 111
86int slicproc_card_read(char *page, char **start, off_t off, int count, 112static void slic_if_stop_queue(struct adapter *adapter);
87 int *eof, void *data); 113static void slic_if_start_queue(struct adapter *adapter);
88int slicproc_card_write(struct file *file, const char __user *buffer, 114static int slic_if_init(struct adapter *adapter);
89 ulong count, void *data); 115static int slic_adapter_allocresources(struct adapter *adapter);
90void slicproc_card_create(p_sliccard_t card); 116static void slic_adapter_freeresources(struct adapter *adapter);
91void slicproc_card_destroy(p_sliccard_t card); 117static void slic_link_config(struct adapter *adapter, u32 linkspeed,
92int slicproc_adapter_read(char *page, char **start, off_t off, int count, 118 u32 linkduplex);
93 int *eof, void *data); 119static void slic_unmap_mmio_space(struct adapter *adapter);
94int slicproc_adapter_write(struct file *file, const char __user *buffer, 120static void slic_card_cleanup(struct sliccard *card);
95 ulong count, void *data); 121static void slic_init_cleanup(struct adapter *adapter);
96void slicproc_adapter_create(p_adapter_t adapter); 122static void slic_soft_reset(struct adapter *adapter);
97void slicproc_adapter_destroy(p_adapter_t adapter); 123static void slic_card_reset(struct adapter *adapter);
98void slicproc_create(void); 124static bool slic_mac_filter(struct adapter *adapter,
99void slicproc_destroy(void); 125 struct ether_header *ether_frame);
100 126static void slic_mac_address_config(struct adapter *adapter);
101void slic_interrupt_process(p_adapter_t adapter, ulong32 isr); 127static void slic_mac_config(struct adapter *adapter);
102void slic_rcv_handler(p_adapter_t adapter); 128static void slic_mcast_set_mask(struct adapter *adapter);
103void slic_upr_handler(p_adapter_t adapter); 129static int slic_mcast_add_list(struct adapter *adapter, char *address);
104void slic_link_event_handler(p_adapter_t adapter); 130static unsigned char slic_mcast_get_mac_hash(char *macaddr);
105void slic_xmit_complete(p_adapter_t adapter); 131static void slic_mcast_set_bit(struct adapter *adapter, char *address);
106void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr); 132static void slic_config_set(struct adapter *adapter, bool linkchange);
107int slic_rspqueue_init(p_adapter_t adapter); 133static void slic_config_clear(struct adapter *adapter);
108int slic_rspqueue_reset(p_adapter_t adapter); 134static void slic_config_get(struct adapter *adapter, u32 config,
109void slic_rspqueue_free(p_adapter_t adapter); 135 u32 configh);
110p_slic_rspbuf_t slic_rspqueue_getnext(p_adapter_t adapter); 136static void slic_timer_get_stats(ulong device);
111void slic_cmdqmem_init(p_adapter_t adapter); 137static void slic_timer_load_check(ulong context);
112void slic_cmdqmem_free(p_adapter_t adapter); 138static void slic_timer_ping(ulong dev);
113pulong32 slic_cmdqmem_addpage(p_adapter_t adapter); 139static void slic_assert_fail(void);
114int slic_cmdq_init(p_adapter_t adapter); 140static ushort slic_eeprom_cksum(char *m, int len);
115void slic_cmdq_free(p_adapter_t adapter);
116void slic_cmdq_reset(p_adapter_t adapter);
117void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page);
118void slic_cmdq_getdone(p_adapter_t adapter);
119void slic_cmdq_putdone(p_adapter_t adapter, p_slic_hostcmd_t cmd);
120void slic_cmdq_putdone_irq(p_adapter_t adapter, p_slic_hostcmd_t cmd);
121p_slic_hostcmd_t slic_cmdq_getfree(p_adapter_t adapter);
122int slic_rcvqueue_init(p_adapter_t adapter);
123int slic_rcvqueue_reset(p_adapter_t adapter);
124int slic_rcvqueue_fill(p_adapter_t adapter);
125ulong32 slic_rcvqueue_reinsert(p_adapter_t adapter, struct sk_buff *skb);
126void slic_rcvqueue_free(p_adapter_t adapter);
127void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf);
128void slic_adapter_set_hwaddr(p_adapter_t adapter);
129void slic_card_halt(p_sliccard_t card, p_adapter_t adapter);
130int slic_card_init(p_sliccard_t card, p_adapter_t adapter);
131void slic_intagg_set(p_adapter_t adapter, ulong32 value);
132int slic_card_download(p_adapter_t adapter);
133ulong32 slic_card_locate(p_adapter_t adapter);
134int slic_card_removeadapter(p_adapter_t adapter);
135void slic_card_remaster(p_adapter_t adapter);
136void slic_card_softreset(p_adapter_t adapter);
137void slic_card_up(p_adapter_t adapter);
138void slic_card_down(p_adapter_t adapter);
139
140void slic_if_stop_queue(p_adapter_t adapter);
141void slic_if_start_queue(p_adapter_t adapter);
142int slic_if_init(p_adapter_t adapter);
143void slic_adapter_close(p_adapter_t adapter);
144int slic_adapter_allocresources(p_adapter_t adapter);
145void slic_adapter_freeresources(p_adapter_t adapter);
146void slic_link_config(p_adapter_t adapter, ulong32 linkspeed,
147 ulong32 linkduplex);
148void slic_unmap_mmio_space(p_adapter_t adapter);
149void slic_card_cleanup(p_sliccard_t card);
150void slic_init_cleanup(p_adapter_t adapter);
151void slic_card_reclaim_buffers(p_adapter_t adapter);
152void slic_soft_reset(p_adapter_t adapter);
153void slic_card_reset(p_adapter_t adapter);
154boolean slic_mac_filter(p_adapter_t adapter, p_ether_header ether_frame);
155void slic_mac_address_config(p_adapter_t adapter);
156void slic_mac_config(p_adapter_t adapter);
157void slic_mcast_set_mask(p_adapter_t adapter);
158void slic_mac_setmcastaddrs(p_adapter_t adapter);
159int slic_mcast_add_list(p_adapter_t adapter, pchar address);
160uchar slic_mcast_get_mac_hash(pchar macaddr);
161void slic_mcast_set_bit(p_adapter_t adapter, pchar address);
162void slic_config_set(p_adapter_t adapter, boolean linkchange);
163void slic_config_clear(p_adapter_t adapter);
164void slic_config_get(p_adapter_t adapter, ulong32 config, ulong32 configh);
165void slic_timer_get_stats(ulong device);
166void slic_timer_load_check(ulong context);
167void slic_timer_ping(ulong dev);
168void slic_stall_msec(int stall);
169void slic_stall_usec(int stall);
170void slic_assert_fail(void);
171ushort slic_eeprom_cksum(pchar m, int len);
172/* upr */ 141/* upr */
173void slic_upr_start(p_adapter_t adapter); 142static void slic_upr_start(struct adapter *adapter);
174void slic_link_upr_complete(p_adapter_t adapter, ulong32 Isr); 143static void slic_link_upr_complete(struct adapter *adapter, u32 Isr);
175int slic_upr_request(p_adapter_t adapter, 144static int slic_upr_request(struct adapter *adapter,
176 ulong32 upr_request, 145 u32 upr_request,
177 ulong32 upr_data, 146 u32 upr_data,
178 ulong32 upr_data_h, 147 u32 upr_data_h,
179 ulong32 upr_buffer, 148 u32 upr_buffer,
180 ulong32 upr_buffer_h); 149 u32 upr_buffer_h);
181int slic_upr_queue_request(p_adapter_t adapter, 150static int slic_upr_queue_request(struct adapter *adapter,
182 ulong32 upr_request, 151 u32 upr_request,
183 ulong32 upr_data, 152 u32 upr_data,
184 ulong32 upr_data_h, 153 u32 upr_data_h,
185 ulong32 upr_buffer, 154 u32 upr_buffer,
186 ulong32 upr_buffer_h); 155 u32 upr_buffer_h);
187void slic_mcast_set_list(struct net_device *dev); 156static void slic_mcast_set_list(struct net_device *dev);
188void slic_mcast_init_crc32(void); 157static void slic_mcast_init_crc32(void);
189 158
190#if SLIC_DUMP_ENABLED 159#if SLIC_DUMP_ENABLED
191int slic_dump_thread(void *context); 160static int slic_dump_thread(void *context);
192uint slic_init_dump_thread(p_sliccard_t card); 161static uint slic_init_dump_thread(struct sliccard *card);
193uchar slic_get_dump_index(pchar path); 162static unsigned char slic_get_dump_index(char *path);
194ulong32 slic_dump_card(p_sliccard_t card, boolean resume); 163static u32 slic_dump_card(struct sliccard *card, bool resume);
195ulong32 slic_dump_halt(p_sliccard_t card, uchar proc); 164static u32 slic_dump_halt(struct sliccard *card, unsigned char proc);
196ulong32 slic_dump_reg(p_sliccard_t card, uchar proc); 165static u32 slic_dump_reg(struct sliccard *card, unsigned char proc);
197ulong32 slic_dump_data(p_sliccard_t card, ulong32 addr, 166static u32 slic_dump_data(struct sliccard *card, u32 addr,
198 ushort count, uchar desc); 167 ushort count, unsigned char desc);
199ulong32 slic_dump_queue(p_sliccard_t card, ulong32 buf_phys, 168static u32 slic_dump_queue(struct sliccard *card, u32 buf_phys,
200 ulong32 buf_physh, ulong32 queue); 169 u32 buf_physh, u32 queue);
201ulong32 slic_dump_load_queue(p_sliccard_t card, ulong32 data, ulong32 queue); 170static u32 slic_dump_load_queue(struct sliccard *card, u32 data,
202ulong32 slic_dump_cam(p_sliccard_t card, ulong32 addr, 171 u32 queue);
203 ulong32 count, uchar desc); 172static u32 slic_dump_cam(struct sliccard *card, u32 addr,
173 u32 count, unsigned char desc);
204 174
205ulong32 slic_dump_resume(p_sliccard_t card, uchar proc); 175static u32 slic_dump_resume(struct sliccard *card, unsigned char proc);
206ulong32 slic_dump_send_cmd(p_sliccard_t card, ulong32 cmd_phys, 176static u32 slic_dump_send_cmd(struct sliccard *card, u32 cmd_phys,
207 ulong32 cmd_physh, ulong32 buf_phys, 177 u32 cmd_physh, u32 buf_phys,
208 ulong32 buf_physh); 178 u32 buf_physh);
209 179
210#define create_file(x) STATUS_SUCCESS 180#define create_file(x) STATUS_SUCCESS
211#define write_file(w, x, y, z) STATUS_SUCCESS 181#define write_file(w, x, y, z) STATUS_SUCCESS
diff --git a/drivers/staging/slicoss/slicoss.c b/drivers/staging/slicoss/slicoss.c
index a8c264822deb..eb615652a08a 100644
--- a/drivers/staging/slicoss/slicoss.c
+++ b/drivers/staging/slicoss/slicoss.c
@@ -143,7 +143,7 @@ static int slic_debug = 1;
143static int debug = -1; 143static int debug = -1;
144static struct net_device *head_netdevice; 144static struct net_device *head_netdevice;
145 145
146base_driver_t slic_global = { {}, 0, 0, 0, 1, NULL, NULL }; 146static struct base_driver slic_global = { {}, 0, 0, 0, 1, NULL, NULL };
147static int intagg_delay = 100; 147static int intagg_delay = 100;
148static u32 dynamic_intagg; 148static u32 dynamic_intagg;
149static int errormsg; 149static int errormsg;
@@ -183,44 +183,49 @@ MODULE_DEVICE_TABLE(pci, slic_pci_tbl);
183 183
184#define SLIC_GET_SLIC_HANDLE(_adapter, _pslic_handle) \ 184#define SLIC_GET_SLIC_HANDLE(_adapter, _pslic_handle) \
185{ \ 185{ \
186 SLIC_ACQUIRE_IRQ_SPINLOCK(_adapter->handle_lock); \ 186 spin_lock_irqsave(&_adapter->handle_lock.lock, \
187 _adapter->handle_lock.flags); \
187 _pslic_handle = _adapter->pfree_slic_handles; \ 188 _pslic_handle = _adapter->pfree_slic_handles; \
188 if (_pslic_handle) { \ 189 if (_pslic_handle) { \
189 ASSERT(_pslic_handle->type == SLIC_HANDLE_FREE); \ 190 ASSERT(_pslic_handle->type == SLIC_HANDLE_FREE); \
190 _adapter->pfree_slic_handles = _pslic_handle->next; \ 191 _adapter->pfree_slic_handles = _pslic_handle->next; \
191 } \ 192 } \
192 SLIC_RELEASE_IRQ_SPINLOCK(_adapter->handle_lock); \ 193 spin_unlock_irqrestore(&_adapter->handle_lock.lock, \
194 _adapter->handle_lock.flags); \
193} 195}
194 196
195#define SLIC_FREE_SLIC_HANDLE(_adapter, _pslic_handle) \ 197#define SLIC_FREE_SLIC_HANDLE(_adapter, _pslic_handle) \
196{ \ 198{ \
197 _pslic_handle->type = SLIC_HANDLE_FREE; \ 199 _pslic_handle->type = SLIC_HANDLE_FREE; \
198 SLIC_ACQUIRE_IRQ_SPINLOCK(_adapter->handle_lock); \ 200 spin_lock_irqsave(&_adapter->handle_lock.lock, \
201 _adapter->handle_lock.flags); \
199 _pslic_handle->next = _adapter->pfree_slic_handles; \ 202 _pslic_handle->next = _adapter->pfree_slic_handles; \
200 _adapter->pfree_slic_handles = _pslic_handle; \ 203 _adapter->pfree_slic_handles = _pslic_handle; \
201 SLIC_RELEASE_IRQ_SPINLOCK(_adapter->handle_lock); \ 204 spin_unlock_irqrestore(&_adapter->handle_lock.lock, \
205 _adapter->handle_lock.flags); \
202} 206}
203 207
204static void slic_debug_init(void); 208static void slic_debug_init(void);
205static void slic_debug_cleanup(void); 209static void slic_debug_cleanup(void);
206static void slic_debug_adapter_create(p_adapter_t adapter); 210static void slic_debug_adapter_create(struct adapter *adapter);
207static void slic_debug_adapter_destroy(p_adapter_t adapter); 211static void slic_debug_adapter_destroy(struct adapter *adapter);
208static void slic_debug_card_create(p_sliccard_t card); 212static void slic_debug_card_create(struct sliccard *card);
209static void slic_debug_card_destroy(p_sliccard_t card); 213static void slic_debug_card_destroy(struct sliccard *card);
210 214
211inline void slic_reg32_write(void __iomem *reg, ulong32 value, uint flush) 215static inline void slic_reg32_write(void __iomem *reg, u32 value, uint flush)
212{ 216{
213 writel(value, reg); 217 writel(value, reg);
214 if (flush) 218 if (flush)
215 mb(); 219 mb();
216} 220}
217 221
218inline void slic_reg64_write(p_adapter_t adapter, 222static inline void slic_reg64_write(struct adapter *adapter,
219 void __iomem *reg, 223 void __iomem *reg,
220 ulong32 value, 224 u32 value,
221 void __iomem *regh, ulong32 paddrh, uint flush) 225 void __iomem *regh, u32 paddrh, uint flush)
222{ 226{
223 SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->bit64reglock); 227 spin_lock_irqsave(&adapter->bit64reglock.lock,
228 adapter->bit64reglock.flags);
224 if (paddrh != adapter->curaddrupper) { 229 if (paddrh != adapter->curaddrupper) {
225 adapter->curaddrupper = paddrh; 230 adapter->curaddrupper = paddrh;
226 writel(paddrh, regh); 231 writel(paddrh, regh);
@@ -228,31 +233,22 @@ inline void slic_reg64_write(p_adapter_t adapter,
228 writel(value, reg); 233 writel(value, reg);
229 if (flush) 234 if (flush)
230 mb(); 235 mb();
231 SLIC_RELEASE_IRQ_SPINLOCK(adapter->bit64reglock); 236 spin_unlock_irqrestore(&adapter->bit64reglock.lock,
237 adapter->bit64reglock.flags);
232} 238}
233 239
234inline ulong32 slic_reg32_read(u32 __iomem *reg, uint flush) 240static void slic_init_driver(void)
235{
236 return readl(reg);
237}
238
239inline ulong32 slic_reg16_read(pulong32 reg, uint flush)
240{
241 return (ushort) readw(reg);
242}
243
244void slic_init_driver(void)
245{ 241{
246 if (slic_first_init) { 242 if (slic_first_init) {
247 DBG_MSG("slicoss: %s slic_first_init set jiffies[%lx]\n", 243 DBG_MSG("slicoss: %s slic_first_init set jiffies[%lx]\n",
248 __func__, jiffies); 244 __func__, jiffies);
249 slic_first_init = 0; 245 slic_first_init = 0;
250 SLIC_INIT_SPINLOCK(slic_global.driver_lock); 246 spin_lock_init(&slic_global.driver_lock.lock);
251 slic_debug_init(); 247 slic_debug_init();
252 } 248 }
253} 249}
254 250
255static void slic_dbg_macaddrs(p_adapter_t adapter) 251static void slic_dbg_macaddrs(struct adapter *adapter)
256{ 252{
257 DBG_MSG(" (%s) curr %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", 253 DBG_MSG(" (%s) curr %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
258 adapter->netdev->name, adapter->currmacaddr[0], 254 adapter->netdev->name, adapter->currmacaddr[0],
@@ -267,7 +263,8 @@ static void slic_dbg_macaddrs(p_adapter_t adapter)
267} 263}
268 264
269#ifdef DEBUG_REGISTER_TRACE 265#ifdef DEBUG_REGISTER_TRACE
270static void slic_dbg_register_trace(p_adapter_t adapter, p_sliccard_t card) 266static void slic_dbg_register_trace(struct adapter *adapter,
267 struct sliccard *card)
271{ 268{
272 uint i; 269 uint i;
273 270
@@ -287,9 +284,8 @@ static void slic_init_adapter(struct net_device *netdev,
287 void __iomem *memaddr, int chip_idx) 284 void __iomem *memaddr, int chip_idx)
288{ 285{
289 ushort index; 286 ushort index;
290 pslic_handle_t pslic_handle; 287 struct slic_handle *pslic_handle;
291 p_adapter_t adapter = (p_adapter_t) netdev_priv(netdev); 288 struct adapter *adapter = (struct adapter *)netdev_priv(netdev);
292
293/* 289/*
294 DBG_MSG("slicoss: %s (%s)\n netdev [%p]\n adapter[%p]\n " 290 DBG_MSG("slicoss: %s (%s)\n netdev [%p]\n adapter[%p]\n "
295 "pcidev [%p]\n", __func__, netdev->name, netdev, adapter, pcidev);*/ 291 "pcidev [%p]\n", __func__, netdev->name, netdev, adapter, pcidev);*/
@@ -301,7 +297,7 @@ static void slic_init_adapter(struct net_device *netdev,
301 adapter->slotnumber = ((pcidev->devfn >> 3) & 0x1F); 297 adapter->slotnumber = ((pcidev->devfn >> 3) & 0x1F);
302 adapter->functionnumber = (pcidev->devfn & 0x7); 298 adapter->functionnumber = (pcidev->devfn & 0x7);
303 adapter->memorylength = pci_resource_len(pcidev, 0); 299 adapter->memorylength = pci_resource_len(pcidev, 0);
304 adapter->slic_regs = (p_slic_regs_t) memaddr; 300 adapter->slic_regs = (__iomem struct slic_regs *)memaddr;
305 adapter->irq = pcidev->irq; 301 adapter->irq = pcidev->irq;
306/* adapter->netdev = netdev;*/ 302/* adapter->netdev = netdev;*/
307 adapter->next_netdevice = head_netdevice; 303 adapter->next_netdevice = head_netdevice;
@@ -310,11 +306,11 @@ static void slic_init_adapter(struct net_device *netdev,
310 adapter->port = 0; /*adapter->functionnumber;*/ 306 adapter->port = 0; /*adapter->functionnumber;*/
311 adapter->cardindex = adapter->port; 307 adapter->cardindex = adapter->port;
312 adapter->memorybase = memaddr; 308 adapter->memorybase = memaddr;
313 SLIC_INIT_SPINLOCK(adapter->upr_lock); 309 spin_lock_init(&adapter->upr_lock.lock);
314 SLIC_INIT_SPINLOCK(adapter->bit64reglock); 310 spin_lock_init(&adapter->bit64reglock.lock);
315 SLIC_INIT_SPINLOCK(adapter->adapter_lock); 311 spin_lock_init(&adapter->adapter_lock.lock);
316 SLIC_INIT_SPINLOCK(adapter->reset_lock); 312 spin_lock_init(&adapter->reset_lock.lock);
317 SLIC_INIT_SPINLOCK(adapter->handle_lock); 313 spin_lock_init(&adapter->handle_lock.lock);
318 314
319 adapter->card_size = 1; 315 adapter->card_size = 1;
320 /* 316 /*
@@ -335,36 +331,36 @@ static void slic_init_adapter(struct net_device *netdev,
335/* 331/*
336 DBG_MSG(".........\nix[%d] phandle[%p] pfree[%p] next[%p]\n", 332 DBG_MSG(".........\nix[%d] phandle[%p] pfree[%p] next[%p]\n",
337 index, pslic_handle, adapter->pfree_slic_handles, pslic_handle->next);*/ 333 index, pslic_handle, adapter->pfree_slic_handles, pslic_handle->next);*/
338 adapter->pshmem = (p_slic_shmem_t) pci_alloc_consistent(adapter->pcidev, 334 adapter->pshmem = (struct slic_shmem *)
339 sizeof 335 pci_alloc_consistent(adapter->pcidev,
340 (slic_shmem_t), 336 sizeof(struct slic_shmem *),
341 &adapter-> 337 &adapter->
342 phys_shmem); 338 phys_shmem);
343/* 339/*
344 DBG_MSG("slicoss: %s (%s)\n pshmem [%p]\n phys_shmem[%p]\n"\ 340 DBG_MSG("slicoss: %s (%s)\n pshmem [%p]\n phys_shmem[%p]\n"\
345 "slic_regs [%p]\n", __func__, netdev->name, adapter->pshmem, 341 "slic_regs [%p]\n", __func__, netdev->name, adapter->pshmem,
346 (pvoid)adapter->phys_shmem, adapter->slic_regs); 342 (void *)adapter->phys_shmem, adapter->slic_regs);
347*/ 343*/
348 ASSERT(adapter->pshmem); 344 ASSERT(adapter->pshmem);
349 345
350 SLIC_ZERO_MEMORY(adapter->pshmem, sizeof(slic_shmem_t)); 346 memset(adapter->pshmem, 0, sizeof(struct slic_shmem));
351 347
352 return; 348 return;
353} 349}
354 350
355int __devinit slic_entry_probe(struct pci_dev *pcidev, 351static int __devinit slic_entry_probe(struct pci_dev *pcidev,
356 const struct pci_device_id *pci_tbl_entry) 352 const struct pci_device_id *pci_tbl_entry)
357{ 353{
358 static int cards_found; 354 static int cards_found;
359 static int did_version; 355 static int did_version;
360 int err; 356 int err;
361 struct net_device *netdev; 357 struct net_device *netdev;
362 p_adapter_t adapter; 358 struct adapter *adapter;
363 void __iomem *memmapped_ioaddr = NULL; 359 void __iomem *memmapped_ioaddr = NULL;
364 ulong32 status = 0; 360 u32 status = 0;
365 ulong mmio_start = 0; 361 ulong mmio_start = 0;
366 ulong mmio_len = 0; 362 ulong mmio_len = 0;
367 p_sliccard_t card = NULL; 363 struct sliccard *card = NULL;
368 364
369 DBG_MSG("slicoss: %s 2.6 VERSION ENTER jiffies[%lx] cpu %d\n", 365 DBG_MSG("slicoss: %s 2.6 VERSION ENTER jiffies[%lx] cpu %d\n",
370 __func__, jiffies, smp_processor_id()); 366 __func__, jiffies, smp_processor_id());
@@ -408,7 +404,7 @@ int __devinit slic_entry_probe(struct pci_dev *pcidev,
408 pci_set_master(pcidev); 404 pci_set_master(pcidev);
409 405
410 DBG_MSG("call alloc_etherdev\n"); 406 DBG_MSG("call alloc_etherdev\n");
411 netdev = alloc_etherdev(sizeof(adapter_t)); 407 netdev = alloc_etherdev(sizeof(struct adapter));
412 if (!netdev) { 408 if (!netdev) {
413 err = -ENOMEM; 409 err = -ENOMEM;
414 goto err_out_exit_slic_probe; 410 goto err_out_exit_slic_probe;
@@ -428,7 +424,7 @@ int __devinit slic_entry_probe(struct pci_dev *pcidev,
428 DBG_MSG("slicoss: call ioremap(mmio_start[%lx], mmio_len[%lx])\n", 424 DBG_MSG("slicoss: call ioremap(mmio_start[%lx], mmio_len[%lx])\n",
429 mmio_start, mmio_len); 425 mmio_start, mmio_len);
430 426
431/* memmapped_ioaddr = (ulong32)ioremap_nocache(mmio_start, mmio_len);*/ 427/* memmapped_ioaddr = (u32)ioremap_nocache(mmio_start, mmio_len);*/
432 memmapped_ioaddr = ioremap(mmio_start, mmio_len); 428 memmapped_ioaddr = ioremap(mmio_start, mmio_len);
433 DBG_MSG("slicoss: %s MEMMAPPED_IOADDR [%p]\n", __func__, 429 DBG_MSG("slicoss: %s MEMMAPPED_IOADDR [%p]\n", __func__,
434 memmapped_ioaddr); 430 memmapped_ioaddr);
@@ -530,11 +526,11 @@ err_out_exit_slic_probe:
530 return -ENODEV; 526 return -ENODEV;
531} 527}
532 528
533int slic_entry_open(struct net_device *dev) 529static int slic_entry_open(struct net_device *dev)
534{ 530{
535 p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); 531 struct adapter *adapter = (struct adapter *) netdev_priv(dev);
536 p_sliccard_t card = adapter->card; 532 struct sliccard *card = adapter->card;
537 ulong32 locked = 0; 533 u32 locked = 0;
538 int status; 534 int status;
539 535
540 ASSERT(adapter); 536 ASSERT(adapter);
@@ -552,7 +548,8 @@ int slic_entry_open(struct net_device *dev)
552 548
553 netif_stop_queue(adapter->netdev); 549 netif_stop_queue(adapter->netdev);
554 550
555 SLIC_ACQUIRE_IRQ_SPINLOCK(slic_global.driver_lock); 551 spin_lock_irqsave(&slic_global.driver_lock.lock,
552 slic_global.driver_lock.flags);
556 locked = 1; 553 locked = 1;
557 if (!adapter->activated) { 554 if (!adapter->activated) {
558 card->adapters_activated++; 555 card->adapters_activated++;
@@ -568,7 +565,8 @@ int slic_entry_open(struct net_device *dev)
568 adapter->activated = 0; 565 adapter->activated = 0;
569 } 566 }
570 if (locked) { 567 if (locked) {
571 SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock); 568 spin_unlock_irqrestore(&slic_global.driver_lock.lock,
569 slic_global.driver_lock.flags);
572 locked = 0; 570 locked = 0;
573 } 571 }
574 return status; 572 return status;
@@ -583,7 +581,8 @@ int slic_entry_open(struct net_device *dev)
583#endif 581#endif
584 582
585 if (locked) { 583 if (locked) {
586 SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock); 584 spin_unlock_irqrestore(&slic_global.driver_lock.lock,
585 slic_global.driver_lock.flags);
587 locked = 0; 586 locked = 0;
588 } 587 }
589#if SLIC_DUMP_ENABLED 588#if SLIC_DUMP_ENABLED
@@ -599,13 +598,13 @@ int slic_entry_open(struct net_device *dev)
599 return STATUS_SUCCESS; 598 return STATUS_SUCCESS;
600} 599}
601 600
602void __devexit slic_entry_remove(struct pci_dev *pcidev) 601static void __devexit slic_entry_remove(struct pci_dev *pcidev)
603{ 602{
604 struct net_device *dev = pci_get_drvdata(pcidev); 603 struct net_device *dev = pci_get_drvdata(pcidev);
605 ulong32 mmio_start = 0; 604 u32 mmio_start = 0;
606 uint mmio_len = 0; 605 uint mmio_len = 0;
607 p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); 606 struct adapter *adapter = (struct adapter *) netdev_priv(dev);
608 p_sliccard_t card; 607 struct sliccard *card;
609 608
610 ASSERT(adapter); 609 ASSERT(adapter);
611 DBG_MSG("slicoss: %s ENTER dev[%p] adapter[%p]\n", __func__, dev, 610 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)
635 __func__, card->adapters_activated, card->adapters_allocated, 634 __func__, card->adapters_activated, card->adapters_allocated,
636 card, adapter); 635 card, adapter);
637 if (!card->adapters_allocated) { 636 if (!card->adapters_allocated) {
638 p_sliccard_t curr_card = slic_global.slic_card; 637 struct sliccard *curr_card = slic_global.slic_card;
639 if (curr_card == card) { 638 if (curr_card == card) {
640 slic_global.slic_card = card->next; 639 slic_global.slic_card = card->next;
641 } else { 640 } else {
@@ -649,17 +648,18 @@ void __devexit slic_entry_remove(struct pci_dev *pcidev)
649 slic_card_cleanup(card); 648 slic_card_cleanup(card);
650 } 649 }
651 DBG_MSG("slicoss: %s deallocate device\n", __func__); 650 DBG_MSG("slicoss: %s deallocate device\n", __func__);
652 SLIC_DEALLOCATE_MEM(dev); 651 kfree(dev);
653 DBG_MSG("slicoss: %s EXIT\n", __func__); 652 DBG_MSG("slicoss: %s EXIT\n", __func__);
654} 653}
655 654
656int slic_entry_halt(struct net_device *dev) 655static int slic_entry_halt(struct net_device *dev)
657{ 656{
658 p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); 657 struct adapter *adapter = (struct adapter *)netdev_priv(dev);
659 p_sliccard_t card = adapter->card; 658 struct sliccard *card = adapter->card;
660 p_slic_regs_t slic_regs = adapter->slic_regs; 659 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
661 660
662 SLIC_ACQUIRE_IRQ_SPINLOCK(slic_global.driver_lock); 661 spin_lock_irqsave(&slic_global.driver_lock.lock,
662 slic_global.driver_lock.flags);
663 ASSERT(card); 663 ASSERT(card);
664 DBG_MSG("slicoss: %s (%s) ENTER\n", __func__, dev->name); 664 DBG_MSG("slicoss: %s (%s) ENTER\n", __func__, dev->name);
665 DBG_MSG("slicoss: %s (%s) actvtd[%d] alloc[%d] state[%x] adapt[%p]\n", 665 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)
730 730
731 DBG_MSG("slicoss: %s (%s) EXIT\n", __func__, dev->name); 731 DBG_MSG("slicoss: %s (%s) EXIT\n", __func__, dev->name);
732 DBG_MSG("slicoss: %s EXIT\n", __func__); 732 DBG_MSG("slicoss: %s EXIT\n", __func__);
733 SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock); 733 spin_unlock_irqrestore(&slic_global.driver_lock.lock,
734 slic_global.driver_lock.flags);
734 return STATUS_SUCCESS; 735 return STATUS_SUCCESS;
735} 736}
736 737
737int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 738static int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
738{ 739{
739 ASSERT(rq); 740 ASSERT(rq);
740/* 741/*
@@ -743,9 +744,10 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
743 switch (cmd) { 744 switch (cmd) {
744 case SIOCSLICSETINTAGG: 745 case SIOCSLICSETINTAGG:
745 { 746 {
746 p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); 747 struct adapter *adapter = (struct adapter *)
747 ulong32 data[7]; 748 netdev_priv(dev);
748 ulong32 intagg; 749 u32 data[7];
750 u32 intagg;
749 751
750 if (copy_from_user(data, rq->ifr_data, 28)) { 752 if (copy_from_user(data, rq->ifr_data, 28)) {
751 DBG_ERROR 753 DBG_ERROR
@@ -763,8 +765,9 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
763#ifdef SLIC_USER_REQUEST_DUMP_ENABLED 765#ifdef SLIC_USER_REQUEST_DUMP_ENABLED
764 case SIOCSLICDUMPCARD: 766 case SIOCSLICDUMPCARD:
765 { 767 {
766 p_adapter_t adapter = (p_adapter_t) dev->priv; 768 struct adapter *adapter = (struct adapter *)
767 p_sliccard_t card; 769 dev->priv;
770 struct sliccard *card;
768 771
769 ASSERT(adapter); 772 ASSERT(adapter);
770 ASSERT(adapter->card) 773 ASSERT(adapter->card)
@@ -833,7 +836,8 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
833#if SLIC_ETHTOOL_SUPPORT 836#if SLIC_ETHTOOL_SUPPORT
834 case SIOCETHTOOL: 837 case SIOCETHTOOL:
835 { 838 {
836 p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); 839 struct adapter *adapter = (struct adapter *)
840 netdev_priv(dev);
837 struct ethtool_cmd data; 841 struct ethtool_cmd data;
838 struct ethtool_cmd ecmd; 842 struct ethtool_cmd ecmd;
839 843
@@ -892,8 +896,8 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
892 data.maxrxpkt = 1; 896 data.maxrxpkt = 1;
893 if ((ecmd.speed != data.speed) || 897 if ((ecmd.speed != data.speed) ||
894 (ecmd.duplex != data.duplex)) { 898 (ecmd.duplex != data.duplex)) {
895 ulong32 speed; 899 u32 speed;
896 ulong32 duplex; 900 u32 duplex;
897 901
898 if (ecmd.speed == SPEED_10) { 902 if (ecmd.speed == SPEED_10) {
899 speed = 0; 903 speed = 0;
@@ -935,10 +939,10 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
935#define XMIT_FAIL_ZERO_LENGTH 2 939#define XMIT_FAIL_ZERO_LENGTH 2
936#define XMIT_FAIL_HOSTCMD_FAIL 3 940#define XMIT_FAIL_HOSTCMD_FAIL 3
937 941
938static void slic_xmit_build_request(p_adapter_t adapter, 942static void slic_xmit_build_request(struct adapter *adapter,
939 p_slic_hostcmd_t hcmd, struct sk_buff *skb) 943 struct slic_hostcmd *hcmd, struct sk_buff *skb)
940{ 944{
941 p_slic_host64_cmd_t ihcmd; 945 struct slic_host64_cmd *ihcmd;
942 ulong phys_addr; 946 ulong phys_addr;
943 947
944 ihcmd = &hcmd->cmd64; 948 ihcmd = &hcmd->cmd64;
@@ -946,16 +950,17 @@ static void slic_xmit_build_request(p_adapter_t adapter,
946 ihcmd->flags = (adapter->port << IHFLG_IFSHFT); 950 ihcmd->flags = (adapter->port << IHFLG_IFSHFT);
947 ihcmd->command = IHCMD_XMT_REQ; 951 ihcmd->command = IHCMD_XMT_REQ;
948 ihcmd->u.slic_buffers.totlen = skb->len; 952 ihcmd->u.slic_buffers.totlen = skb->len;
949 phys_addr = SLIC_GET_DMA_ADDRESS_WRITE(adapter, skb->data, skb->len); 953 phys_addr = pci_map_single(adapter->pcidev, skb->data, skb->len,
954 PCI_DMA_TODEVICE);
950 ihcmd->u.slic_buffers.bufs[0].paddrl = SLIC_GET_ADDR_LOW(phys_addr); 955 ihcmd->u.slic_buffers.bufs[0].paddrl = SLIC_GET_ADDR_LOW(phys_addr);
951 ihcmd->u.slic_buffers.bufs[0].paddrh = SLIC_GET_ADDR_HIGH(phys_addr); 956 ihcmd->u.slic_buffers.bufs[0].paddrh = SLIC_GET_ADDR_HIGH(phys_addr);
952 ihcmd->u.slic_buffers.bufs[0].length = skb->len; 957 ihcmd->u.slic_buffers.bufs[0].length = skb->len;
953#if defined(CONFIG_X86_64) 958#if defined(CONFIG_X86_64)
954 hcmd->cmdsize = (ulong32) ((((ulong64)&ihcmd->u.slic_buffers.bufs[1] - 959 hcmd->cmdsize = (u32) ((((u64)&ihcmd->u.slic_buffers.bufs[1] -
955 (ulong64) hcmd) + 31) >> 5); 960 (u64) hcmd) + 31) >> 5);
956#elif defined(CONFIG_X86) 961#elif defined(CONFIG_X86)
957 hcmd->cmdsize = ((((ulong32) &ihcmd->u.slic_buffers.bufs[1] - 962 hcmd->cmdsize = ((((u32) &ihcmd->u.slic_buffers.bufs[1] -
958 (ulong32) hcmd) + 31) >> 5); 963 (u32) hcmd) + 31) >> 5);
959#else 964#else
960 Stop Compilation; 965 Stop Compilation;
961#endif 966#endif
@@ -963,14 +968,14 @@ static void slic_xmit_build_request(p_adapter_t adapter,
963 968
964#define NORMAL_ETHFRAME 0 969#define NORMAL_ETHFRAME 0
965 970
966int slic_xmit_start(struct sk_buff *skb, struct net_device *dev) 971static int slic_xmit_start(struct sk_buff *skb, struct net_device *dev)
967{ 972{
968 p_sliccard_t card; 973 struct sliccard *card;
969 p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); 974 struct adapter *adapter = (struct adapter *)netdev_priv(dev);
970 p_slic_hostcmd_t hcmd = NULL; 975 struct slic_hostcmd *hcmd = NULL;
971 ulong32 status = 0; 976 u32 status = 0;
972 ulong32 skbtype = NORMAL_ETHFRAME; 977 u32 skbtype = NORMAL_ETHFRAME;
973 pvoid offloadcmd = NULL; 978 void *offloadcmd = NULL;
974 979
975 card = adapter->card; 980 card = adapter->card;
976 ASSERT(card); 981 ASSERT(card);
@@ -1035,9 +1040,9 @@ xmit_fail:
1035 goto xmit_done; 1040 goto xmit_done;
1036} 1041}
1037 1042
1038void slic_xmit_fail(p_adapter_t adapter, 1043static void slic_xmit_fail(struct adapter *adapter,
1039 struct sk_buff *skb, 1044 struct sk_buff *skb,
1040 pvoid cmd, ulong32 skbtype, ulong32 status) 1045 void *cmd, u32 skbtype, u32 status)
1041{ 1046{
1042 if (adapter->xmitq_full) 1047 if (adapter->xmitq_full)
1043 slic_if_stop_queue(adapter); 1048 slic_if_stop_queue(adapter);
@@ -1072,31 +1077,10 @@ void slic_xmit_fail(p_adapter_t adapter,
1072 adapter->stats.tx_dropped++; 1077 adapter->stats.tx_dropped++;
1073} 1078}
1074 1079
1075void slic_xmit_timeout(struct net_device *dev) 1080static void slic_rcv_handle_error(struct adapter *adapter,
1076{ 1081 struct slic_rcvbuf *rcvbuf)
1077 p_sliccard_t card;
1078 p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
1079 ulong32 i;
1080
1081 ASSERT(adapter);
1082 card = adapter->card;
1083 ASSERT(card);
1084 for (i = 0; i < card->card_size; i++) {
1085 if (card->adapter[i])
1086 slic_if_stop_queue(card->adapter[i]);
1087 }
1088 if (!card->reset_in_progress) {
1089 DBG_ERROR
1090 ("%s card[%p] state[%x] adapter[%p] port[%d] state[%x]\n",
1091 __func__, card, card->state, adapter, adapter->port,
1092 adapter->state);
1093 slic_card_reset(adapter);
1094 }
1095}
1096
1097void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf)
1098{ 1082{
1099 p_slic_hddr_wds hdr = (p_slic_hddr_wds) rcvbuf->data; 1083 struct slic_hddr_wds *hdr = (struct slic_hddr_wds *)rcvbuf->data;
1100 1084
1101 if (adapter->devid != SLIC_1GB_DEVICE_ID) { 1085 if (adapter->devid != SLIC_1GB_DEVICE_ID) {
1102 if (hdr->frame_status14 & VRHSTAT_802OE) 1086 if (hdr->frame_status14 & VRHSTAT_802OE)
@@ -1141,7 +1125,7 @@ void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf)
1141 adapter->if_events.IpHlen++; 1125 adapter->if_events.IpHlen++;
1142 } else { 1126 } else {
1143 if (hdr->frame_statusGB & VGBSTAT_XPERR) { 1127 if (hdr->frame_statusGB & VGBSTAT_XPERR) {
1144 ulong32 xerr = hdr->frame_statusGB >> VGBSTAT_XERRSHFT; 1128 u32 xerr = hdr->frame_statusGB >> VGBSTAT_XERRSHFT;
1145 1129
1146 if (xerr == VGBSTAT_XCSERR) 1130 if (xerr == VGBSTAT_XCSERR)
1147 adapter->if_events.TpCsum++; 1131 adapter->if_events.TpCsum++;
@@ -1151,7 +1135,7 @@ void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf)
1151 adapter->if_events.TpHlen++; 1135 adapter->if_events.TpHlen++;
1152 } 1136 }
1153 if (hdr->frame_statusGB & VGBSTAT_NETERR) { 1137 if (hdr->frame_statusGB & VGBSTAT_NETERR) {
1154 ulong32 nerr = 1138 u32 nerr =
1155 (hdr-> 1139 (hdr->
1156 frame_statusGB >> VGBSTAT_NERRSHFT) & 1140 frame_statusGB >> VGBSTAT_NERRSHFT) &
1157 VGBSTAT_NERRMSK; 1141 VGBSTAT_NERRMSK;
@@ -1163,7 +1147,7 @@ void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf)
1163 adapter->if_events.IpHlen++; 1147 adapter->if_events.IpHlen++;
1164 } 1148 }
1165 if (hdr->frame_statusGB & VGBSTAT_LNKERR) { 1149 if (hdr->frame_statusGB & VGBSTAT_LNKERR) {
1166 ulong32 lerr = hdr->frame_statusGB & VGBSTAT_LERRMSK; 1150 u32 lerr = hdr->frame_statusGB & VGBSTAT_LERRMSK;
1167 1151
1168 if (lerr == VGBSTAT_LDEARLY) 1152 if (lerr == VGBSTAT_LDEARLY)
1169 adapter->if_events.rcvearly++; 1153 adapter->if_events.rcvearly++;
@@ -1187,17 +1171,17 @@ void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf)
1187#define TCP_OFFLOAD_FRAME_PUSHFLAG 0x10000000 1171#define TCP_OFFLOAD_FRAME_PUSHFLAG 0x10000000
1188#define M_FAST_PATH 0x0040 1172#define M_FAST_PATH 0x0040
1189 1173
1190void slic_rcv_handler(p_adapter_t adapter) 1174static void slic_rcv_handler(struct adapter *adapter)
1191{ 1175{
1192 struct sk_buff *skb; 1176 struct sk_buff *skb;
1193 p_slic_rcvbuf_t rcvbuf; 1177 struct slic_rcvbuf *rcvbuf;
1194 ulong32 frames = 0; 1178 u32 frames = 0;
1195 1179
1196 while ((skb = slic_rcvqueue_getnext(adapter))) { 1180 while ((skb = slic_rcvqueue_getnext(adapter))) {
1197 ulong32 rx_bytes; 1181 u32 rx_bytes;
1198 1182
1199 ASSERT(skb->head); 1183 ASSERT(skb->head);
1200 rcvbuf = (p_slic_rcvbuf_t) skb->head; 1184 rcvbuf = (struct slic_rcvbuf *)skb->head;
1201 adapter->card->events++; 1185 adapter->card->events++;
1202 if (rcvbuf->status & IRHDDR_ERR) { 1186 if (rcvbuf->status & IRHDDR_ERR) {
1203 adapter->rx_errors++; 1187 adapter->rx_errors++;
@@ -1206,7 +1190,8 @@ void slic_rcv_handler(p_adapter_t adapter)
1206 continue; 1190 continue;
1207 } 1191 }
1208 1192
1209 if (!slic_mac_filter(adapter, (p_ether_header) rcvbuf->data)) { 1193 if (!slic_mac_filter(adapter, (struct ether_header *)
1194 rcvbuf->data)) {
1210#if 0 1195#if 0
1211 DBG_MSG 1196 DBG_MSG
1212 ("slicoss: %s (%s) drop frame due to mac filter\n", 1197 ("slicoss: %s (%s) drop frame due to mac filter\n",
@@ -1239,12 +1224,12 @@ void slic_rcv_handler(p_adapter_t adapter)
1239 adapter->max_isr_rcvs = max(adapter->max_isr_rcvs, frames); 1224 adapter->max_isr_rcvs = max(adapter->max_isr_rcvs, frames);
1240} 1225}
1241 1226
1242void slic_xmit_complete(p_adapter_t adapter) 1227static void slic_xmit_complete(struct adapter *adapter)
1243{ 1228{
1244 p_slic_hostcmd_t hcmd; 1229 struct slic_hostcmd *hcmd;
1245 p_slic_rspbuf_t rspbuf; 1230 struct slic_rspbuf *rspbuf;
1246 ulong32 frames = 0; 1231 u32 frames = 0;
1247 slic_handle_word_t slic_handle_word; 1232 struct slic_handle_word slic_handle_word;
1248 1233
1249 do { 1234 do {
1250 rspbuf = slic_rspqueue_getnext(adapter); 1235 rspbuf = slic_rspqueue_getnext(adapter);
@@ -1259,10 +1244,10 @@ void slic_xmit_complete(p_adapter_t adapter)
1259 ASSERT(slic_handle_word.handle_index); 1244 ASSERT(slic_handle_word.handle_index);
1260 ASSERT(slic_handle_word.handle_index <= SLIC_CMDQ_MAXCMDS); 1245 ASSERT(slic_handle_word.handle_index <= SLIC_CMDQ_MAXCMDS);
1261 hcmd = 1246 hcmd =
1262 (p_slic_hostcmd_t) adapter->slic_handles[slic_handle_word. 1247 (struct slic_hostcmd *)
1263 handle_index]. 1248 adapter->slic_handles[slic_handle_word.handle_index].
1264 address; 1249 address;
1265/* hcmd = (p_slic_hostcmd_t) rspbuf->hosthandle; */ 1250/* hcmd = (struct slic_hostcmd *) rspbuf->hosthandle; */
1266 ASSERT(hcmd); 1251 ASSERT(hcmd);
1267 ASSERT(hcmd->pslic_handle == 1252 ASSERT(hcmd->pslic_handle ==
1268 &adapter->slic_handles[slic_handle_word.handle_index]); 1253 &adapter->slic_handles[slic_handle_word.handle_index]);
@@ -1286,9 +1271,9 @@ void slic_xmit_complete(p_adapter_t adapter)
1286 1271
1287static irqreturn_t slic_interrupt(int irq, void *dev_id) 1272static irqreturn_t slic_interrupt(int irq, void *dev_id)
1288{ 1273{
1289 struct net_device *dev = (struct net_device *) dev_id; 1274 struct net_device *dev = (struct net_device *)dev_id;
1290 p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); 1275 struct adapter *adapter = (struct adapter *)netdev_priv(dev);
1291 ulong32 isr; 1276 u32 isr;
1292 1277
1293 if ((adapter->pshmem) && (adapter->pshmem->isr)) { 1278 if ((adapter->pshmem) && (adapter->pshmem->isr)) {
1294 WRITE_REG(adapter->slic_regs->slic_icr, ICR_INT_MASK, FLUSH); 1279 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)
1305 int pre_count; 1290 int pre_count;
1306 int errors; 1291 int errors;
1307 1292
1308 p_slic_rcvqueue_t rcvq = 1293 struct slic_rcvqueue *rcvq =
1309 &adapter->rcvqueue; 1294 &adapter->rcvqueue;
1310 1295
1311 adapter-> 1296 adapter->
@@ -1400,17 +1385,17 @@ static irqreturn_t slic_interrupt(int irq, void *dev_id)
1400 * will also complete asynchronously. 1385 * will also complete asynchronously.
1401 * 1386 *
1402 */ 1387 */
1403void slic_link_event_handler(p_adapter_t adapter) 1388static void slic_link_event_handler(struct adapter *adapter)
1404{ 1389{
1405 int status; 1390 int status;
1406 p_slic_shmem_t pshmem; 1391 struct slic_shmem *pshmem;
1407 1392
1408 if (adapter->state != ADAPT_UP) { 1393 if (adapter->state != ADAPT_UP) {
1409 /* Adapter is not operational. Ignore. */ 1394 /* Adapter is not operational. Ignore. */
1410 return; 1395 return;
1411 } 1396 }
1412 1397
1413 pshmem = (p_slic_shmem_t) adapter->phys_shmem; 1398 pshmem = (struct slic_shmem *)adapter->phys_shmem;
1414 1399
1415#if defined(CONFIG_X86_64) 1400#if defined(CONFIG_X86_64)
1416/* 1401/*
@@ -1425,7 +1410,7 @@ void slic_link_event_handler(p_adapter_t adapter)
1425 0, 0); 1410 0, 0);
1426#elif defined(CONFIG_X86) 1411#elif defined(CONFIG_X86)
1427 status = slic_upr_request(adapter, SLIC_UPR_RLSR, 1412 status = slic_upr_request(adapter, SLIC_UPR_RLSR,
1428 (ulong32) &pshmem->linkstatus, /* no 4GB wrap guaranteed */ 1413 (u32) &pshmem->linkstatus, /* no 4GB wrap guaranteed */
1429 0, 0, 0); 1414 0, 0, 0);
1430#else 1415#else
1431 Stop compilation; 1416 Stop compilation;
@@ -1433,7 +1418,7 @@ void slic_link_event_handler(p_adapter_t adapter)
1433 ASSERT((status == STATUS_SUCCESS) || (status == STATUS_PENDING)); 1418 ASSERT((status == STATUS_SUCCESS) || (status == STATUS_PENDING));
1434} 1419}
1435 1420
1436void slic_init_cleanup(p_adapter_t adapter) 1421static void slic_init_cleanup(struct adapter *adapter)
1437{ 1422{
1438 DBG_MSG("slicoss: %s ENTER adapter[%p] ", __func__, adapter); 1423 DBG_MSG("slicoss: %s ENTER adapter[%p] ", __func__, adapter);
1439 if (adapter->intrregistered) { 1424 if (adapter->intrregistered) {
@@ -1445,9 +1430,9 @@ void slic_init_cleanup(p_adapter_t adapter)
1445 if (adapter->pshmem) { 1430 if (adapter->pshmem) {
1446 DBG_MSG("FREE_SHMEM "); 1431 DBG_MSG("FREE_SHMEM ");
1447 DBG_MSG("adapter[%p] port %d pshmem[%p] FreeShmem ", 1432 DBG_MSG("adapter[%p] port %d pshmem[%p] FreeShmem ",
1448 adapter, adapter->port, (pvoid) adapter->pshmem); 1433 adapter, adapter->port, (void *) adapter->pshmem);
1449 pci_free_consistent(adapter->pcidev, 1434 pci_free_consistent(adapter->pcidev,
1450 sizeof(slic_shmem_t), 1435 sizeof(struct slic_shmem *),
1451 adapter->pshmem, adapter->phys_shmem); 1436 adapter->pshmem, adapter->phys_shmem);
1452 adapter->pshmem = NULL; 1437 adapter->pshmem = NULL;
1453 adapter->phys_shmem = (dma_addr_t) NULL; 1438 adapter->phys_shmem = (dma_addr_t) NULL;
@@ -1475,9 +1460,9 @@ void slic_init_cleanup(p_adapter_t adapter)
1475} 1460}
1476 1461
1477#if SLIC_GET_STATS_ENABLED 1462#if SLIC_GET_STATS_ENABLED
1478struct net_device_stats *slic_get_stats(struct net_device *dev) 1463static struct net_device_stats *slic_get_stats(struct net_device *dev)
1479{ 1464{
1480 p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); 1465 struct adapter *adapter = (struct adapter *)netdev_priv(dev);
1481 struct net_device_stats *stats; 1466 struct net_device_stats *stats;
1482 1467
1483 ASSERT(adapter); 1468 ASSERT(adapter);
@@ -1500,10 +1485,10 @@ struct net_device_stats *slic_get_stats(struct net_device *dev)
1500 * Allocate a mcast_address structure to hold the multicast address. 1485 * Allocate a mcast_address structure to hold the multicast address.
1501 * Link it in. 1486 * Link it in.
1502 */ 1487 */
1503int slic_mcast_add_list(p_adapter_t adapter, pchar address) 1488static int slic_mcast_add_list(struct adapter *adapter, char *address)
1504{ 1489{
1505 p_mcast_address_t mcaddr, mlist; 1490 struct mcast_address *mcaddr, *mlist;
1506 boolean equaladdr; 1491 bool equaladdr;
1507 1492
1508 /* Check to see if it already exists */ 1493 /* Check to see if it already exists */
1509 mlist = adapter->mcastaddrs; 1494 mlist = adapter->mcastaddrs;
@@ -1515,7 +1500,7 @@ int slic_mcast_add_list(p_adapter_t adapter, pchar address)
1515 } 1500 }
1516 1501
1517 /* Doesn't already exist. Allocate a structure to hold it */ 1502 /* Doesn't already exist. Allocate a structure to hold it */
1518 mcaddr = SLIC_ALLOCATE_MEM(sizeof(mcast_address_t), GFP_ATOMIC); 1503 mcaddr = kmalloc(sizeof(struct mcast_address), GFP_ATOMIC);
1519 if (mcaddr == NULL) 1504 if (mcaddr == NULL)
1520 return 1; 1505 return 1;
1521 1506
@@ -1545,10 +1530,10 @@ static u32 slic_crc_init; /* Is table initialized */
1545/* 1530/*
1546 * Contruct the CRC32 table 1531 * Contruct the CRC32 table
1547 */ 1532 */
1548void slic_mcast_init_crc32(void) 1533static void slic_mcast_init_crc32(void)
1549{ 1534{
1550 ulong32 c; /* CRC shit reg */ 1535 u32 c; /* CRC shit reg */
1551 ulong32 e = 0; /* Poly X-or pattern */ 1536 u32 e = 0; /* Poly X-or pattern */
1552 int i; /* counter */ 1537 int i; /* counter */
1553 int k; /* byte being shifted into crc */ 1538 int k; /* byte being shifted into crc */
1554 1539
@@ -1568,12 +1553,12 @@ void slic_mcast_init_crc32(void)
1568/* 1553/*
1569 * Return the MAC hast as described above. 1554 * Return the MAC hast as described above.
1570 */ 1555 */
1571uchar slic_mcast_get_mac_hash(pchar macaddr) 1556static unsigned char slic_mcast_get_mac_hash(char *macaddr)
1572{ 1557{
1573 ulong32 crc; 1558 u32 crc;
1574 pchar p; 1559 char *p;
1575 int i; 1560 int i;
1576 uchar machash = 0; 1561 unsigned char machash = 0;
1577 1562
1578 if (!slic_crc_init) { 1563 if (!slic_crc_init) {
1579 slic_mcast_init_crc32(); 1564 slic_mcast_init_crc32();
@@ -1591,9 +1576,9 @@ uchar slic_mcast_get_mac_hash(pchar macaddr)
1591 return machash; 1576 return machash;
1592} 1577}
1593 1578
1594void slic_mcast_set_bit(p_adapter_t adapter, pchar address) 1579static void slic_mcast_set_bit(struct adapter *adapter, char *address)
1595{ 1580{
1596 uchar crcpoly; 1581 unsigned char crcpoly;
1597 1582
1598 /* Get the CRC polynomial for the mac address */ 1583 /* Get the CRC polynomial for the mac address */
1599 crcpoly = slic_mcast_get_mac_hash(address); 1584 crcpoly = slic_mcast_get_mac_hash(address);
@@ -1604,22 +1589,22 @@ void slic_mcast_set_bit(p_adapter_t adapter, pchar address)
1604 crcpoly &= 0x3F; 1589 crcpoly &= 0x3F;
1605 1590
1606 /* OR in the new bit into our 64 bit mask. */ 1591 /* OR in the new bit into our 64 bit mask. */
1607 adapter->mcastmask |= (ulong64) 1 << crcpoly; 1592 adapter->mcastmask |= (u64) 1 << crcpoly;
1608} 1593}
1609 1594
1610void slic_mcast_set_list(struct net_device *dev) 1595static void slic_mcast_set_list(struct net_device *dev)
1611{ 1596{
1612 p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); 1597 struct adapter *adapter = (struct adapter *)netdev_priv(dev);
1613 int status = STATUS_SUCCESS; 1598 int status = STATUS_SUCCESS;
1614 int i; 1599 int i;
1615 pchar addresses; 1600 char *addresses;
1616 struct dev_mc_list *mc_list = dev->mc_list; 1601 struct dev_mc_list *mc_list = dev->mc_list;
1617 int mc_count = dev->mc_count; 1602 int mc_count = dev->mc_count;
1618 1603
1619 ASSERT(adapter); 1604 ASSERT(adapter);
1620 1605
1621 for (i = 1; i <= mc_count; i++) { 1606 for (i = 1; i <= mc_count; i++) {
1622 addresses = (pchar) &mc_list->dmi_addr; 1607 addresses = (char *) &mc_list->dmi_addr;
1623 if (mc_list->dmi_addrlen == 6) { 1608 if (mc_list->dmi_addrlen == 6) {
1624 status = slic_mcast_add_list(adapter, addresses); 1609 status = slic_mcast_add_list(adapter, addresses);
1625 if (status != STATUS_SUCCESS) 1610 if (status != STATUS_SUCCESS)
@@ -1657,9 +1642,9 @@ void slic_mcast_set_list(struct net_device *dev)
1657 return; 1642 return;
1658} 1643}
1659 1644
1660void slic_mcast_set_mask(p_adapter_t adapter) 1645static void slic_mcast_set_mask(struct adapter *adapter)
1661{ 1646{
1662 p_slic_regs_t slic_regs = adapter->slic_regs; 1647 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
1663 1648
1664 DBG_MSG("%s ENTER (%s) macopts[%x] mask[%llx]\n", __func__, 1649 DBG_MSG("%s ENTER (%s) macopts[%x] mask[%llx]\n", __func__,
1665 adapter->netdev->name, (uint) adapter->macopts, 1650 adapter->netdev->name, (uint) adapter->macopts,
@@ -1687,20 +1672,20 @@ void slic_mcast_set_mask(p_adapter_t adapter)
1687 ((ulong) ((adapter->mcastmask >> 32) & 0xFFFFFFFF))); 1672 ((ulong) ((adapter->mcastmask >> 32) & 0xFFFFFFFF)));
1688 1673
1689 WRITE_REG(slic_regs->slic_mcastlow, 1674 WRITE_REG(slic_regs->slic_mcastlow,
1690 (ulong32) (adapter->mcastmask & 0xFFFFFFFF), FLUSH); 1675 (u32) (adapter->mcastmask & 0xFFFFFFFF), FLUSH);
1691 WRITE_REG(slic_regs->slic_mcasthigh, 1676 WRITE_REG(slic_regs->slic_mcasthigh,
1692 (ulong32) ((adapter->mcastmask >> 32) & 0xFFFFFFFF), 1677 (u32) ((adapter->mcastmask >> 32) & 0xFFFFFFFF),
1693 FLUSH); 1678 FLUSH);
1694 } 1679 }
1695} 1680}
1696 1681
1697void slic_timer_ping(ulong dev) 1682static void slic_timer_ping(ulong dev)
1698{ 1683{
1699 p_adapter_t adapter; 1684 struct adapter *adapter;
1700 p_sliccard_t card; 1685 struct sliccard *card;
1701 1686
1702 ASSERT(dev); 1687 ASSERT(dev);
1703 adapter = (p_adapter_t) ((struct net_device *) dev)->priv; 1688 adapter = (struct adapter *)((struct net_device *) dev)->priv;
1704 ASSERT(adapter); 1689 ASSERT(adapter);
1705 card = adapter->card; 1690 card = adapter->card;
1706 ASSERT(card); 1691 ASSERT(card);
@@ -1741,12 +1726,12 @@ void slic_timer_ping(ulong dev)
1741 add_timer(&adapter->pingtimer); 1726 add_timer(&adapter->pingtimer);
1742} 1727}
1743 1728
1744void slic_if_stop_queue(p_adapter_t adapter) 1729static void slic_if_stop_queue(struct adapter *adapter)
1745{ 1730{
1746 netif_stop_queue(adapter->netdev); 1731 netif_stop_queue(adapter->netdev);
1747} 1732}
1748 1733
1749void slic_if_start_queue(p_adapter_t adapter) 1734static void slic_if_start_queue(struct adapter *adapter)
1750{ 1735{
1751 netif_start_queue(adapter->netdev); 1736 netif_start_queue(adapter->netdev);
1752} 1737}
@@ -1757,12 +1742,12 @@ void slic_if_start_queue(p_adapter_t adapter)
1757 * Perform initialization of our slic interface. 1742 * Perform initialization of our slic interface.
1758 * 1743 *
1759 */ 1744 */
1760int slic_if_init(p_adapter_t adapter) 1745static int slic_if_init(struct adapter *adapter)
1761{ 1746{
1762 p_sliccard_t card = adapter->card; 1747 struct sliccard *card = adapter->card;
1763 struct net_device *dev = adapter->netdev; 1748 struct net_device *dev = adapter->netdev;
1764 p_slic_regs_t slic_regs = adapter->slic_regs; 1749 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
1765 p_slic_shmem_t pshmem; 1750 struct slic_shmem *pshmem;
1766 int status = 0; 1751 int status = 0;
1767 1752
1768 ASSERT(card); 1753 ASSERT(card);
@@ -1829,12 +1814,13 @@ int slic_if_init(p_adapter_t adapter)
1829 DBG_MSG("slicoss: %s disable interrupts(slic)\n", __func__); 1814 DBG_MSG("slicoss: %s disable interrupts(slic)\n", __func__);
1830 1815
1831 WRITE_REG(slic_regs->slic_icr, ICR_INT_OFF, FLUSH); 1816 WRITE_REG(slic_regs->slic_icr, ICR_INT_OFF, FLUSH);
1832 slic_stall_msec(1); 1817 mdelay(1);
1833 1818
1834 if (!adapter->isp_initialized) { 1819 if (!adapter->isp_initialized) {
1835 pshmem = (p_slic_shmem_t) adapter->phys_shmem; 1820 pshmem = (struct slic_shmem *)adapter->phys_shmem;
1836 1821
1837 SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->bit64reglock); 1822 spin_lock_irqsave(&adapter->bit64reglock.lock,
1823 adapter->bit64reglock.flags);
1838 1824
1839#if defined(CONFIG_X86_64) 1825#if defined(CONFIG_X86_64)
1840 WRITE_REG(slic_regs->slic_addr_upper, 1826 WRITE_REG(slic_regs->slic_addr_upper,
@@ -1842,12 +1828,13 @@ int slic_if_init(p_adapter_t adapter)
1842 WRITE_REG(slic_regs->slic_isp, 1828 WRITE_REG(slic_regs->slic_isp,
1843 SLIC_GET_ADDR_LOW(&pshmem->isr), FLUSH); 1829 SLIC_GET_ADDR_LOW(&pshmem->isr), FLUSH);
1844#elif defined(CONFIG_X86) 1830#elif defined(CONFIG_X86)
1845 WRITE_REG(slic_regs->slic_addr_upper, (ulong32) 0, DONT_FLUSH); 1831 WRITE_REG(slic_regs->slic_addr_upper, (u32) 0, DONT_FLUSH);
1846 WRITE_REG(slic_regs->slic_isp, (ulong32) &pshmem->isr, FLUSH); 1832 WRITE_REG(slic_regs->slic_isp, (u32) &pshmem->isr, FLUSH);
1847#else 1833#else
1848 Stop Compilations 1834 Stop Compilations
1849#endif 1835#endif
1850 SLIC_RELEASE_IRQ_SPINLOCK(adapter->bit64reglock); 1836 spin_unlock_irqrestore(&adapter->bit64reglock.lock,
1837 adapter->bit64reglock.flags);
1851 adapter->isp_initialized = 1; 1838 adapter->isp_initialized = 1;
1852 } 1839 }
1853 1840
@@ -1908,7 +1895,7 @@ int slic_if_init(p_adapter_t adapter)
1908 return STATUS_SUCCESS; 1895 return STATUS_SUCCESS;
1909} 1896}
1910 1897
1911void slic_unmap_mmio_space(p_adapter_t adapter) 1898static void slic_unmap_mmio_space(struct adapter *adapter)
1912{ 1899{
1913#if LINUX_FREES_ADAPTER_RESOURCES 1900#if LINUX_FREES_ADAPTER_RESOURCES
1914 if (adapter->slic_regs) 1901 if (adapter->slic_regs)
@@ -1917,7 +1904,7 @@ void slic_unmap_mmio_space(p_adapter_t adapter)
1917#endif 1904#endif
1918} 1905}
1919 1906
1920int slic_adapter_allocresources(p_adapter_t adapter) 1907static int slic_adapter_allocresources(struct adapter *adapter)
1921{ 1908{
1922 if (!adapter->intrregistered) { 1909 if (!adapter->intrregistered) {
1923 int retval; 1910 int retval;
@@ -1929,14 +1916,16 @@ int slic_adapter_allocresources(p_adapter_t adapter)
1929 (void *)adapter->phys_shmem, adapter->netdev->irq, 1916 (void *)adapter->phys_shmem, adapter->netdev->irq,
1930 NR_IRQS); 1917 NR_IRQS);
1931 1918
1932 SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock); 1919 spin_unlock_irqrestore(&slic_global.driver_lock.lock,
1920 slic_global.driver_lock.flags);
1933 1921
1934 retval = request_irq(adapter->netdev->irq, 1922 retval = request_irq(adapter->netdev->irq,
1935 &slic_interrupt, 1923 &slic_interrupt,
1936 IRQF_SHARED, 1924 IRQF_SHARED,
1937 adapter->netdev->name, adapter->netdev); 1925 adapter->netdev->name, adapter->netdev);
1938 1926
1939 SLIC_ACQUIRE_IRQ_SPINLOCK(slic_global.driver_lock); 1927 spin_lock_irqsave(&slic_global.driver_lock.lock,
1928 slic_global.driver_lock.flags);
1940 1929
1941 if (retval) { 1930 if (retval) {
1942 DBG_ERROR("slicoss: request_irq (%s) FAILED [%x]\n", 1931 DBG_ERROR("slicoss: request_irq (%s) FAILED [%x]\n",
@@ -1953,7 +1942,7 @@ int slic_adapter_allocresources(p_adapter_t adapter)
1953 return STATUS_SUCCESS; 1942 return STATUS_SUCCESS;
1954} 1943}
1955 1944
1956void slic_config_pci(struct pci_dev *pcidev) 1945static void slic_config_pci(struct pci_dev *pcidev)
1957{ 1946{
1958 u16 pci_command; 1947 u16 pci_command;
1959 u16 new_command; 1948 u16 new_command;
@@ -1972,11 +1961,11 @@ void slic_config_pci(struct pci_dev *pcidev)
1972 } 1961 }
1973} 1962}
1974 1963
1975void slic_adapter_freeresources(p_adapter_t adapter) 1964static void slic_adapter_freeresources(struct adapter *adapter)
1976{ 1965{
1977 DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter); 1966 DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter);
1978 slic_init_cleanup(adapter); 1967 slic_init_cleanup(adapter);
1979 SLIC_ZERO_MEMORY(&adapter->stats, sizeof(struct net_device_stats)); 1968 memset(&adapter->stats, 0, sizeof(struct net_device_stats));
1980 adapter->error_interrupts = 0; 1969 adapter->error_interrupts = 0;
1981 adapter->rcv_interrupts = 0; 1970 adapter->rcv_interrupts = 0;
1982 adapter->xmit_interrupts = 0; 1971 adapter->xmit_interrupts = 0;
@@ -1996,14 +1985,14 @@ void slic_adapter_freeresources(p_adapter_t adapter)
1996 * Write phy control to configure link duplex/speed 1985 * Write phy control to configure link duplex/speed
1997 * 1986 *
1998 */ 1987 */
1999void slic_link_config(p_adapter_t adapter, 1988static void slic_link_config(struct adapter *adapter,
2000 ulong32 linkspeed, ulong32 linkduplex) 1989 u32 linkspeed, u32 linkduplex)
2001{ 1990{
2002 ulong32 speed; 1991 u32 speed;
2003 ulong32 duplex; 1992 u32 duplex;
2004 ulong32 phy_config; 1993 u32 phy_config;
2005 ulong32 phy_advreg; 1994 u32 phy_advreg;
2006 ulong32 phy_gctlreg; 1995 u32 phy_gctlreg;
2007 1996
2008 if (adapter->state != ADAPT_UP) { 1997 if (adapter->state != ADAPT_UP) {
2009 DBG_MSG 1998 DBG_MSG
@@ -2052,7 +2041,7 @@ void slic_link_config(p_adapter_t adapter,
2052 phy_config, FLUSH); 2041 phy_config, FLUSH);
2053 /* wait, Marvell says 1 sec, 2042 /* wait, Marvell says 1 sec,
2054 try to get away with 10 ms */ 2043 try to get away with 10 ms */
2055 slic_stall_msec(10); 2044 mdelay(10);
2056 2045
2057 /* disable auto-neg, set speed/duplex, 2046 /* disable auto-neg, set speed/duplex,
2058 soft reset phy, powerup */ 2047 soft reset phy, powerup */
@@ -2140,7 +2129,7 @@ void slic_link_config(p_adapter_t adapter,
2140 WRITE_REG(adapter->slic_regs->slic_wphy, phy_config, FLUSH); 2129 WRITE_REG(adapter->slic_regs->slic_wphy, phy_config, FLUSH);
2141 2130
2142 /* wait, Marvell says 1 sec, try to get away with 10 ms */ 2131 /* wait, Marvell says 1 sec, try to get away with 10 ms */
2143 slic_stall_msec(10); 2132 mdelay(10);
2144 2133
2145 if (adapter->subsysid != SLIC_1GB_CICADA_SUBSYS_ID) { 2134 if (adapter->subsysid != SLIC_1GB_CICADA_SUBSYS_ID) {
2146 /* if a Marvell PHY 2135 /* if a Marvell PHY
@@ -2164,24 +2153,24 @@ void slic_link_config(p_adapter_t adapter,
2164 phy_config); 2153 phy_config);
2165} 2154}
2166 2155
2167void slic_card_cleanup(p_sliccard_t card) 2156static void slic_card_cleanup(struct sliccard *card)
2168{ 2157{
2169 DBG_MSG("slicoss: %s ENTER\n", __func__); 2158 DBG_MSG("slicoss: %s ENTER\n", __func__);
2170 2159
2171#if SLIC_DUMP_ENABLED 2160#if SLIC_DUMP_ENABLED
2172 if (card->dumpbuffer) { 2161 if (card->dumpbuffer) {
2173 SLIC_DEALLOCATE_MEM(card->dumpbuffer);
2174 card->dumpbuffer = NULL;
2175 card->dumpbuffer_phys = 0; 2162 card->dumpbuffer_phys = 0;
2176 card->dumpbuffer_physl = 0; 2163 card->dumpbuffer_physl = 0;
2177 card->dumpbuffer_physh = 0; 2164 card->dumpbuffer_physh = 0;
2165 kfree(card->dumpbuffer);
2166 card->dumpbuffer = NULL;
2178 } 2167 }
2179 if (card->cmdbuffer) { 2168 if (card->cmdbuffer) {
2180 SLIC_DEALLOCATE_MEM(card->cmdbuffer);
2181 card->cmdbuffer = NULL;
2182 card->cmdbuffer_phys = 0; 2169 card->cmdbuffer_phys = 0;
2183 card->cmdbuffer_physl = 0; 2170 card->cmdbuffer_physl = 0;
2184 card->cmdbuffer_physh = 0; 2171 card->cmdbuffer_physh = 0;
2172 kfree(card->cmdbuffer);
2173 card->cmdbuffer = NULL;
2185 } 2174 }
2186#endif 2175#endif
2187 2176
@@ -2192,24 +2181,24 @@ void slic_card_cleanup(p_sliccard_t card)
2192 2181
2193 slic_debug_card_destroy(card); 2182 slic_debug_card_destroy(card);
2194 2183
2195 SLIC_DEALLOCATE_MEM(card); 2184 kfree(card);
2196 DBG_MSG("slicoss: %s EXIT\n", __func__); 2185 DBG_MSG("slicoss: %s EXIT\n", __func__);
2197} 2186}
2198 2187
2199static int slic_card_download_gbrcv(p_adapter_t adapter) 2188static int slic_card_download_gbrcv(struct adapter *adapter)
2200{ 2189{
2201 p_slic_regs_t slic_regs = adapter->slic_regs; 2190 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
2202 ulong32 codeaddr; 2191 u32 codeaddr;
2203 puchar instruction = NULL; 2192 unsigned char *instruction = NULL;
2204 ulong32 rcvucodelen = 0; 2193 u32 rcvucodelen = 0;
2205 2194
2206 switch (adapter->devid) { 2195 switch (adapter->devid) {
2207 case SLIC_2GB_DEVICE_ID: 2196 case SLIC_2GB_DEVICE_ID:
2208 instruction = (puchar) &OasisRcvUCode[0]; 2197 instruction = (unsigned char *)&OasisRcvUCode[0];
2209 rcvucodelen = OasisRcvUCodeLen; 2198 rcvucodelen = OasisRcvUCodeLen;
2210 break; 2199 break;
2211 case SLIC_1GB_DEVICE_ID: 2200 case SLIC_1GB_DEVICE_ID:
2212 instruction = (puchar) &GBRcvUCode[0]; 2201 instruction = (unsigned char *)&GBRcvUCode[0];
2213 rcvucodelen = GBRcvUCodeLen; 2202 rcvucodelen = GBRcvUCodeLen;
2214 break; 2203 break;
2215 default: 2204 default:
@@ -2227,11 +2216,11 @@ static int slic_card_download_gbrcv(p_adapter_t adapter)
2227 2216
2228 /* write out the instruction data low addr */ 2217 /* write out the instruction data low addr */
2229 WRITE_REG(slic_regs->slic_rcv_wcs, 2218 WRITE_REG(slic_regs->slic_rcv_wcs,
2230 (ulong32) *(pulong32) instruction, FLUSH); 2219 (u32) *(u32 *) instruction, FLUSH);
2231 instruction += 4; 2220 instruction += 4;
2232 2221
2233 /* write out the instruction data high addr */ 2222 /* write out the instruction data high addr */
2234 WRITE_REG(slic_regs->slic_rcv_wcs, (ulong32) *instruction, 2223 WRITE_REG(slic_regs->slic_rcv_wcs, (u32) *instruction,
2235 FLUSH); 2224 FLUSH);
2236 instruction += 1; 2225 instruction += 1;
2237 } 2226 }
@@ -2242,22 +2231,22 @@ static int slic_card_download_gbrcv(p_adapter_t adapter)
2242 return 0; 2231 return 0;
2243} 2232}
2244 2233
2245int slic_card_download(p_adapter_t adapter) 2234static int slic_card_download(struct adapter *adapter)
2246{ 2235{
2247 ulong32 section; 2236 u32 section;
2248 int thissectionsize; 2237 int thissectionsize;
2249 int codeaddr; 2238 int codeaddr;
2250 p_slic_regs_t slic_regs = adapter->slic_regs; 2239 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
2251 ulong32 *instruction = NULL; 2240 u32 *instruction = NULL;
2252 ulong32 *lastinstruct = NULL; 2241 u32 *lastinstruct = NULL;
2253 ulong32 *startinstruct = NULL; 2242 u32 *startinstruct = NULL;
2254 puchar nextinstruct; 2243 unsigned char *nextinstruct;
2255 ulong32 baseaddress; 2244 u32 baseaddress;
2256 ulong32 failure; 2245 u32 failure;
2257 ulong32 i; 2246 u32 i;
2258 ulong32 numsects = 0; 2247 u32 numsects = 0;
2259 ulong32 sectsize[3]; 2248 u32 sectsize[3];
2260 ulong32 sectstart[3]; 2249 u32 sectstart[3];
2261 2250
2262/* DBG_MSG ("slicoss: %s (%s) adapter[%p] card[%p] devid[%x] \ 2251/* DBG_MSG ("slicoss: %s (%s) adapter[%p] card[%p] devid[%x] \
2263 jiffies[%lx] cpu %d\n", __func__, adapter->netdev->name, adapter, 2252 jiffies[%lx] cpu %d\n", __func__, adapter->netdev->name, adapter,
@@ -2292,19 +2281,19 @@ int slic_card_download(p_adapter_t adapter)
2292 for (section = 0; section < numsects; section++) { 2281 for (section = 0; section < numsects; section++) {
2293 switch (adapter->devid) { 2282 switch (adapter->devid) {
2294 case SLIC_2GB_DEVICE_ID: 2283 case SLIC_2GB_DEVICE_ID:
2295 instruction = (pulong32) &OasisUCode[section][0]; 2284 instruction = (u32 *) &OasisUCode[section][0];
2296 baseaddress = sectstart[section]; 2285 baseaddress = sectstart[section];
2297 thissectionsize = sectsize[section] >> 3; 2286 thissectionsize = sectsize[section] >> 3;
2298 lastinstruct = 2287 lastinstruct =
2299 (pulong32) &OasisUCode[section][sectsize[section] - 2288 (u32 *) &OasisUCode[section][sectsize[section] -
2300 8]; 2289 8];
2301 break; 2290 break;
2302 case SLIC_1GB_DEVICE_ID: 2291 case SLIC_1GB_DEVICE_ID:
2303 instruction = (pulong32) &MojaveUCode[section][0]; 2292 instruction = (u32 *) &MojaveUCode[section][0];
2304 baseaddress = sectstart[section]; 2293 baseaddress = sectstart[section];
2305 thissectionsize = sectsize[section] >> 3; 2294 thissectionsize = sectsize[section] >> 3;
2306 lastinstruct = 2295 lastinstruct =
2307 (pulong32) &MojaveUCode[section][sectsize[section] 2296 (u32 *) &MojaveUCode[section][sectsize[section]
2308 - 8]; 2297 - 8];
2309 break; 2298 break;
2310 default: 2299 default:
@@ -2317,21 +2306,21 @@ int slic_card_download(p_adapter_t adapter)
2317 2306
2318 for (codeaddr = 0; codeaddr < thissectionsize; codeaddr++) { 2307 for (codeaddr = 0; codeaddr < thissectionsize; codeaddr++) {
2319 startinstruct = instruction; 2308 startinstruct = instruction;
2320 nextinstruct = ((puchar) instruction) + 8; 2309 nextinstruct = ((unsigned char *)instruction) + 8;
2321 /* Write out instruction address */ 2310 /* Write out instruction address */
2322 WRITE_REG(slic_regs->slic_wcs, baseaddress + codeaddr, 2311 WRITE_REG(slic_regs->slic_wcs, baseaddress + codeaddr,
2323 FLUSH); 2312 FLUSH);
2324 /* Write out instruction to low addr */ 2313 /* Write out instruction to low addr */
2325 WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH); 2314 WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH);
2326#ifdef CONFIG_X86_64 2315#ifdef CONFIG_X86_64
2327 instruction = (pulong32) ((puchar) instruction + 4); 2316 instruction = (u32 *)((unsigned char *)instruction + 4);
2328#else 2317#else
2329 instruction++; 2318 instruction++;
2330#endif 2319#endif
2331 /* Write out instruction to high addr */ 2320 /* Write out instruction to high addr */
2332 WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH); 2321 WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH);
2333#ifdef CONFIG_X86_64 2322#ifdef CONFIG_X86_64
2334 instruction = (pulong32) ((puchar) instruction + 4); 2323 instruction = (u32 *)((unsigned char *)instruction + 4);
2335#else 2324#else
2336 instruction++; 2325 instruction++;
2337#endif 2326#endif
@@ -2341,10 +2330,10 @@ int slic_card_download(p_adapter_t adapter)
2341 for (section = 0; section < numsects; section++) { 2330 for (section = 0; section < numsects; section++) {
2342 switch (adapter->devid) { 2331 switch (adapter->devid) {
2343 case SLIC_2GB_DEVICE_ID: 2332 case SLIC_2GB_DEVICE_ID:
2344 instruction = (pulong32) &OasisUCode[section][0]; 2333 instruction = (u32 *)&OasisUCode[section][0];
2345 break; 2334 break;
2346 case SLIC_1GB_DEVICE_ID: 2335 case SLIC_1GB_DEVICE_ID:
2347 instruction = (pulong32) &MojaveUCode[section][0]; 2336 instruction = (u32 *)&MojaveUCode[section][0];
2348 break; 2337 break;
2349 default: 2338 default:
2350 ASSERT(0); 2339 ASSERT(0);
@@ -2367,19 +2356,19 @@ int slic_card_download(p_adapter_t adapter)
2367 /* Write out instruction to low addr */ 2356 /* Write out instruction to low addr */
2368 WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH); 2357 WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH);
2369#ifdef CONFIG_X86_64 2358#ifdef CONFIG_X86_64
2370 instruction = (pulong32) ((puchar) instruction + 4); 2359 instruction = (u32 *)((unsigned char *)instruction + 4);
2371#else 2360#else
2372 instruction++; 2361 instruction++;
2373#endif 2362#endif
2374 /* Write out instruction to high addr */ 2363 /* Write out instruction to high addr */
2375 WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH); 2364 WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH);
2376#ifdef CONFIG_X86_64 2365#ifdef CONFIG_X86_64
2377 instruction = (pulong32) ((puchar) instruction + 4); 2366 instruction = (u32 *)((unsigned char *)instruction + 4);
2378#else 2367#else
2379 instruction++; 2368 instruction++;
2380#endif 2369#endif
2381 /* Check SRAM location zero. If it is non-zero. Abort.*/ 2370 /* Check SRAM location zero. If it is non-zero. Abort.*/
2382 failure = READ_REG(slic_regs->slic_reset, 0); 2371 failure = readl((u32 __iomem *)&slic_regs->slic_reset);
2383 if (failure) { 2372 if (failure) {
2384 DBG_MSG 2373 DBG_MSG
2385 ("slicoss: %s FAILURE EXIT codeaddr[%x] \ 2374 ("slicoss: %s FAILURE EXIT codeaddr[%x] \
@@ -2394,12 +2383,12 @@ int slic_card_download(p_adapter_t adapter)
2394/* DBG_MSG ("slicoss: Compare done\n");*/ 2383/* DBG_MSG ("slicoss: Compare done\n");*/
2395 2384
2396 /* Everything OK, kick off the card */ 2385 /* Everything OK, kick off the card */
2397 slic_stall_msec(10); 2386 mdelay(10);
2398 WRITE_REG(slic_regs->slic_wcs, SLIC_WCS_START, FLUSH); 2387 WRITE_REG(slic_regs->slic_wcs, SLIC_WCS_START, FLUSH);
2399 2388
2400 /* stall for 20 ms, long enough for ucode to init card 2389 /* stall for 20 ms, long enough for ucode to init card
2401 and reach mainloop */ 2390 and reach mainloop */
2402 slic_stall_msec(20); 2391 mdelay(20);
2403 2392
2404 DBG_MSG("slicoss: %s (%s) EXIT adapter[%p] card[%p]\n", 2393 DBG_MSG("slicoss: %s (%s) EXIT adapter[%p] card[%p]\n",
2405 __func__, adapter->netdev->name, adapter, adapter->card); 2394 __func__, adapter->netdev->name, adapter, adapter->card);
@@ -2407,9 +2396,9 @@ int slic_card_download(p_adapter_t adapter)
2407 return STATUS_SUCCESS; 2396 return STATUS_SUCCESS;
2408} 2397}
2409 2398
2410void slic_adapter_set_hwaddr(p_adapter_t adapter) 2399static void slic_adapter_set_hwaddr(struct adapter *adapter)
2411{ 2400{
2412 p_sliccard_t card = adapter->card; 2401 struct sliccard *card = adapter->card;
2413 2402
2414/* DBG_MSG ("%s ENTER card->config_set[%x] port[%d] physport[%d] funct#[%d]\n", 2403/* DBG_MSG ("%s ENTER card->config_set[%x] port[%d] physport[%d] funct#[%d]\n",
2415 __func__, card->config_set, adapter->port, adapter->physport, 2404 __func__, card->config_set, adapter->port, adapter->physport,
@@ -2420,7 +2409,7 @@ void slic_adapter_set_hwaddr(p_adapter_t adapter)
2420 if ((adapter->card) && (card->config_set)) { 2409 if ((adapter->card) && (card->config_set)) {
2421 memcpy(adapter->macaddr, 2410 memcpy(adapter->macaddr,
2422 card->config.MacInfo[adapter->functionnumber].macaddrA, 2411 card->config.MacInfo[adapter->functionnumber].macaddrA,
2423 sizeof(slic_config_mac_t)); 2412 sizeof(struct slic_config_mac));
2424/* DBG_MSG ("%s AFTER copying from config.macinfo into currmacaddr\n", 2413/* DBG_MSG ("%s AFTER copying from config.macinfo into currmacaddr\n",
2425 __func__); 2414 __func__);
2426 slic_dbg_macaddrs(adapter);*/ 2415 slic_dbg_macaddrs(adapter);*/
@@ -2438,53 +2427,35 @@ void slic_adapter_set_hwaddr(p_adapter_t adapter)
2438 slic_dbg_macaddrs(adapter); */ 2427 slic_dbg_macaddrs(adapter); */
2439} 2428}
2440 2429
2441void slic_card_halt(p_sliccard_t card, p_adapter_t adapter) 2430static void slic_intagg_set(struct adapter *adapter, u32 value)
2442{ 2431{
2443 p_slic_regs_t slic_regs = adapter->slic_regs; 2432 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
2444
2445 DBG_MSG("slicoss: %s ENTER card[%p] adapter[%p] card->state[%x]\n",
2446 __func__, card, adapter, card->state);
2447 WRITE_REG(slic_regs->slic_icr, ICR_INT_OFF, FLUSH);
2448 adapter->all_reg_writes++;
2449 adapter->icr_reg_writes++;
2450 slic_config_clear(adapter);
2451 WRITE_REG(slic_regs->slic_reset_iface, 0, FLUSH);
2452 slic_soft_reset(adapter);
2453 DBG_MSG("slicoss: %s EXIT card[%p] adapter[%p] card->state[%x]\n",
2454 __func__, card, adapter, card->state);
2455 return;
2456
2457}
2458
2459void slic_intagg_set(p_adapter_t adapter, ulong32 value)
2460{
2461 p_slic_regs_t slic_regs = adapter->slic_regs;
2462 2433
2463 WRITE_REG(slic_regs->slic_intagg, value, FLUSH); 2434 WRITE_REG(slic_regs->slic_intagg, value, FLUSH);
2464 adapter->card->loadlevel_current = value; 2435 adapter->card->loadlevel_current = value;
2465} 2436}
2466 2437
2467int slic_card_init(p_sliccard_t card, p_adapter_t adapter) 2438static int slic_card_init(struct sliccard *card, struct adapter *adapter)
2468{ 2439{
2469 p_slic_regs_t slic_regs = adapter->slic_regs; 2440 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
2470 pslic_eeprom_t peeprom; 2441 struct slic_eeprom *peeprom;
2471 poslic_eeprom_t pOeeprom; 2442 struct oslic_eeprom *pOeeprom;
2472 dma_addr_t phys_config; 2443 dma_addr_t phys_config;
2473 ulong32 phys_configh; 2444 u32 phys_configh;
2474 ulong32 phys_configl; 2445 u32 phys_configl;
2475 ulong32 i = 0; 2446 u32 i = 0;
2476 p_slic_shmem_t pshmem; 2447 struct slic_shmem *pshmem;
2477 int status; 2448 int status;
2478 uint macaddrs = card->card_size; 2449 uint macaddrs = card->card_size;
2479 ushort eecodesize; 2450 ushort eecodesize;
2480 ushort dramsize; 2451 ushort dramsize;
2481 ushort ee_chksum; 2452 ushort ee_chksum;
2482 ushort calc_chksum; 2453 ushort calc_chksum;
2483 pslic_config_mac_t pmac; 2454 struct slic_config_mac *pmac;
2484 uchar fruformat; 2455 unsigned char fruformat;
2485 uchar oemfruformat; 2456 unsigned char oemfruformat;
2486 patk_fru_t patkfru; 2457 struct atk_fru *patkfru;
2487 poemfru_t poemfru; 2458 union oemfru_t *poemfru;
2488 2459
2489 DBG_MSG 2460 DBG_MSG
2490 ("slicoss: %s ENTER card[%p] adapter[%p] card->state[%x] \ 2461 ("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)
2505 2476
2506 if (!card->config_set) { 2477 if (!card->config_set) {
2507 peeprom = pci_alloc_consistent(adapter->pcidev, 2478 peeprom = pci_alloc_consistent(adapter->pcidev,
2508 sizeof(slic_eeprom_t), 2479 sizeof(struct slic_eeprom),
2509 &phys_config); 2480 &phys_config);
2510 2481
2511 phys_configl = SLIC_GET_ADDR_LOW(phys_config); 2482 phys_configl = SLIC_GET_ADDR_LOW(phys_config);
@@ -2515,8 +2486,9 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
2515 "size [%x]\n peeprom [%p]\n " 2486 "size [%x]\n peeprom [%p]\n "
2516 "phys_config [%p]\n phys_configl[%x]\n " 2487 "phys_config [%p]\n phys_configl[%x]\n "
2517 "phys_configh[%x]\n", 2488 "phys_configh[%x]\n",
2518 __func__, adapter, (ulong32) sizeof(slic_eeprom_t), 2489 __func__, adapter,
2519 peeprom, (pvoid) phys_config, phys_configl, 2490 (u32)sizeof(struct slic_eeprom),
2491 peeprom, (void *) phys_config, phys_configl,
2520 phys_configh); 2492 phys_configh);
2521 if (!peeprom) { 2493 if (!peeprom) {
2522 DBG_ERROR 2494 DBG_ERROR
@@ -2526,17 +2498,19 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
2526 (uint) adapter->slotnumber); 2498 (uint) adapter->slotnumber);
2527 return -ENOMEM; 2499 return -ENOMEM;
2528 } else { 2500 } else {
2529 SLIC_ZERO_MEMORY(peeprom, sizeof(slic_eeprom_t)); 2501 memset(peeprom, 0, sizeof(struct slic_eeprom));
2530 } 2502 }
2531 WRITE_REG(slic_regs->slic_icr, ICR_INT_OFF, FLUSH); 2503 WRITE_REG(slic_regs->slic_icr, ICR_INT_OFF, FLUSH);
2532 slic_stall_msec(1); 2504 mdelay(1);
2533 pshmem = (p_slic_shmem_t) adapter->phys_shmem; 2505 pshmem = (struct slic_shmem *)adapter->phys_shmem;
2534 2506
2535 SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->bit64reglock); 2507 spin_lock_irqsave(&adapter->bit64reglock.lock,
2508 adapter->bit64reglock.flags);
2536 WRITE_REG(slic_regs->slic_addr_upper, 0, DONT_FLUSH); 2509 WRITE_REG(slic_regs->slic_addr_upper, 0, DONT_FLUSH);
2537 WRITE_REG(slic_regs->slic_isp, 2510 WRITE_REG(slic_regs->slic_isp,
2538 SLIC_GET_ADDR_LOW(&pshmem->isr), FLUSH); 2511 SLIC_GET_ADDR_LOW(&pshmem->isr), FLUSH);
2539 SLIC_RELEASE_IRQ_SPINLOCK(adapter->bit64reglock); 2512 spin_unlock_irqrestore(&adapter->bit64reglock.lock,
2513 adapter->bit64reglock.flags);
2540 2514
2541 slic_config_get(adapter, phys_configl, phys_configh); 2515 slic_config_get(adapter, phys_configl, phys_configh);
2542 2516
@@ -2564,7 +2538,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
2564 FLUSH); 2538 FLUSH);
2565 } 2539 }
2566 } else { 2540 } else {
2567 slic_stall_msec(1); 2541 mdelay(1);
2568 i++; 2542 i++;
2569 if (i > 5000) { 2543 if (i > 5000) {
2570 DBG_ERROR 2544 DBG_ERROR
@@ -2586,7 +2560,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
2586 /* Oasis card */ 2560 /* Oasis card */
2587 case SLIC_2GB_DEVICE_ID: 2561 case SLIC_2GB_DEVICE_ID:
2588 /* extract EEPROM data and pointers to EEPROM data */ 2562 /* extract EEPROM data and pointers to EEPROM data */
2589 pOeeprom = (poslic_eeprom_t) peeprom; 2563 pOeeprom = (struct oslic_eeprom *) peeprom;
2590 eecodesize = pOeeprom->EecodeSize; 2564 eecodesize = pOeeprom->EecodeSize;
2591 dramsize = pOeeprom->DramSize; 2565 dramsize = pOeeprom->DramSize;
2592 pmac = pOeeprom->MacInfo; 2566 pmac = pOeeprom->MacInfo;
@@ -2619,12 +2593,12 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
2619 (eecodesize >= MIN_EECODE_SIZE)) { 2593 (eecodesize >= MIN_EECODE_SIZE)) {
2620 2594
2621 ee_chksum = 2595 ee_chksum =
2622 *(pushort) ((pchar) peeprom + (eecodesize - 2)); 2596 *(u16 *) ((char *) peeprom + (eecodesize - 2));
2623 /* 2597 /*
2624 calculate the EEPROM checksum 2598 calculate the EEPROM checksum
2625 */ 2599 */
2626 calc_chksum = 2600 calc_chksum =
2627 ~slic_eeprom_cksum((pchar) peeprom, 2601 ~slic_eeprom_cksum((char *) peeprom,
2628 (eecodesize - 2)); 2602 (eecodesize - 2));
2629 /* 2603 /*
2630 if the ucdoe chksum flag bit worked, 2604 if the ucdoe chksum flag bit worked,
@@ -2639,24 +2613,25 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
2639 /* copy in the MAC address(es) */ 2613 /* copy in the MAC address(es) */
2640 for (i = 0; i < macaddrs; i++) { 2614 for (i = 0; i < macaddrs; i++) {
2641 memcpy(&card->config.MacInfo[i], 2615 memcpy(&card->config.MacInfo[i],
2642 &pmac[i], sizeof(slic_config_mac_t)); 2616 &pmac[i], sizeof(struct slic_config_mac));
2643 } 2617 }
2644/* DBG_MSG ("%s EEPROM Checksum Good? %d MacAddress\n",__func__, 2618/* DBG_MSG ("%s EEPROM Checksum Good? %d MacAddress\n",__func__,
2645 card->config.EepromValid); */ 2619 card->config.EepromValid); */
2646 2620
2647 /* copy the Alacritech FRU information */ 2621 /* copy the Alacritech FRU information */
2648 card->config.FruFormat = fruformat; 2622 card->config.FruFormat = fruformat;
2649 memcpy(&card->config.AtkFru, patkfru, sizeof(atk_fru_t)); 2623 memcpy(&card->config.AtkFru, patkfru,
2624 sizeof(struct atk_fru));
2650 2625
2651 pci_free_consistent(adapter->pcidev, 2626 pci_free_consistent(adapter->pcidev,
2652 sizeof(slic_eeprom_t), 2627 sizeof(struct slic_eeprom),
2653 peeprom, phys_config); 2628 peeprom, phys_config);
2654 DBG_MSG 2629 DBG_MSG
2655 ("slicoss: %s adapter%d [%p] size[%x] FREE peeprom[%p] \ 2630 ("slicoss: %s adapter%d [%p] size[%x] FREE peeprom[%p] \
2656 phys_config[%p]\n", 2631 phys_config[%p]\n",
2657 __func__, adapter->port, adapter, 2632 __func__, adapter->port, adapter,
2658 (ulong32) sizeof(slic_eeprom_t), peeprom, 2633 (u32) sizeof(struct slic_eeprom), peeprom,
2659 (pvoid) phys_config); 2634 (void *) phys_config);
2660 2635
2661 if ((!card->config.EepromValid) && 2636 if ((!card->config.EepromValid) &&
2662 (adapter->reg_params.fail_on_bad_eeprom)) { 2637 (adapter->reg_params.fail_on_bad_eeprom)) {
@@ -2698,8 +2673,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
2698 2673
2699#if SLIC_DUMP_ENABLED 2674#if SLIC_DUMP_ENABLED
2700 if (!card->dumpbuffer) { 2675 if (!card->dumpbuffer) {
2701 card->dumpbuffer = 2676 card->dumpbuffer = kmalloc(DUMP_PAGE_SIZE, GFP_ATOMIC);
2702 SLIC_ALLOCATE_MEM(DUMP_PAGE_SIZE, GFP_ATOMIC);
2703 2677
2704 ASSERT(card->dumpbuffer); 2678 ASSERT(card->dumpbuffer);
2705 if (card->dumpbuffer == NULL) 2679 if (card->dumpbuffer == NULL)
@@ -2709,8 +2683,8 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
2709 * Smear the shared memory structure and then obtain 2683 * Smear the shared memory structure and then obtain
2710 * the PHYSICAL address of this structure 2684 * the PHYSICAL address of this structure
2711 */ 2685 */
2712 SLIC_ZERO_MEMORY(card->dumpbuffer, DUMP_PAGE_SIZE); 2686 memset(card->dumpbuffer, 0, DUMP_PAGE_SIZE);
2713 card->dumpbuffer_phys = SLIC_GET_PHYSICAL_ADDRESS(card->dumpbuffer); 2687 card->dumpbuffer_phys = virt_to_bus(card->dumpbuffer);
2714 card->dumpbuffer_physh = SLIC_GET_ADDR_HIGH(card->dumpbuffer_phys); 2688 card->dumpbuffer_physh = SLIC_GET_ADDR_HIGH(card->dumpbuffer_phys);
2715 card->dumpbuffer_physl = SLIC_GET_ADDR_LOW(card->dumpbuffer_phys); 2689 card->dumpbuffer_physl = SLIC_GET_ADDR_LOW(card->dumpbuffer_phys);
2716 2690
@@ -2718,8 +2692,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
2718 * Allocate COMMAND BUFFER 2692 * Allocate COMMAND BUFFER
2719 */ 2693 */
2720 if (!card->cmdbuffer) { 2694 if (!card->cmdbuffer) {
2721 card->cmdbuffer = 2695 card->cmdbuffer = kmalloc(sizeof(dump_cmd_t), GFP_ATOMIC);
2722 SLIC_ALLOCATE_MEM(sizeof(dump_cmd_t), GFP_ATOMIC);
2723 2696
2724 ASSERT(card->cmdbuffer); 2697 ASSERT(card->cmdbuffer);
2725 if (card->cmdbuffer == NULL) 2698 if (card->cmdbuffer == NULL)
@@ -2729,8 +2702,8 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
2729 * Smear the shared memory structure and then obtain 2702 * Smear the shared memory structure and then obtain
2730 * the PHYSICAL address of this structure 2703 * the PHYSICAL address of this structure
2731 */ 2704 */
2732 SLIC_ZERO_MEMORY(card->cmdbuffer, sizeof(dump_cmd_t)); 2705 memset(card->cmdbuffer, 0, sizeof(dump_cmd_t));
2733 card->cmdbuffer_phys = SLIC_GET_PHYSICAL_ADDRESS(card->cmdbuffer); 2706 card->cmdbuffer_phys = virt_to_bus(card->cmdbuffer);
2734 card->cmdbuffer_physh = SLIC_GET_ADDR_HIGH(card->cmdbuffer_phys); 2707 card->cmdbuffer_physh = SLIC_GET_ADDR_HIGH(card->cmdbuffer_phys);
2735 card->cmdbuffer_physl = SLIC_GET_ADDR_LOW(card->cmdbuffer_phys); 2708 card->cmdbuffer_physl = SLIC_GET_ADDR_LOW(card->cmdbuffer_phys);
2736#endif 2709#endif
@@ -2746,10 +2719,10 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
2746 return STATUS_SUCCESS; 2719 return STATUS_SUCCESS;
2747} 2720}
2748 2721
2749ulong32 slic_card_locate(p_adapter_t adapter) 2722static u32 slic_card_locate(struct adapter *adapter)
2750{ 2723{
2751 p_sliccard_t card = slic_global.slic_card; 2724 struct sliccard *card = slic_global.slic_card;
2752 p_physcard_t physcard = slic_global.phys_card; 2725 struct physcard *physcard = slic_global.phys_card;
2753 ushort card_hostid; 2726 ushort card_hostid;
2754 u16 __iomem *hostid_reg; 2727 u16 __iomem *hostid_reg;
2755 uint i; 2728 uint i;
@@ -2777,13 +2750,12 @@ ulong32 slic_card_locate(p_adapter_t adapter)
2777 DBG_MSG("slicoss: %s *hostid_reg[%p] == ", __func__, hostid_reg); 2750 DBG_MSG("slicoss: %s *hostid_reg[%p] == ", __func__, hostid_reg);
2778 2751
2779 /* read the 16 bit hostid from SRAM */ 2752 /* read the 16 bit hostid from SRAM */
2780/* card_hostid = READ_REGP16(hostid_reg, 0);*/
2781 card_hostid = (ushort) readw(hostid_reg); 2753 card_hostid = (ushort) readw(hostid_reg);
2782 DBG_MSG(" card_hostid[%x]\n", card_hostid); 2754 DBG_MSG(" card_hostid[%x]\n", card_hostid);
2783 2755
2784 /* Initialize a new card structure if need be */ 2756 /* Initialize a new card structure if need be */
2785 if (card_hostid == SLIC_HOSTID_DEFAULT) { 2757 if (card_hostid == SLIC_HOSTID_DEFAULT) {
2786 card = kzalloc(sizeof(sliccard_t), GFP_KERNEL); 2758 card = kzalloc(sizeof(struct sliccard), GFP_KERNEL);
2787 if (card == NULL) 2759 if (card == NULL)
2788 return -ENOMEM; 2760 return -ENOMEM;
2789 2761
@@ -2861,11 +2833,9 @@ ulong32 slic_card_locate(p_adapter_t adapter)
2861 } 2833 }
2862 if (!physcard) { 2834 if (!physcard) {
2863 /* no structure allocated for this physical card yet */ 2835 /* no structure allocated for this physical card yet */
2864 physcard = 2836 physcard = kmalloc(sizeof(struct physcard *), GFP_ATOMIC);
2865 (p_physcard_t) SLIC_ALLOCATE_MEM(sizeof(physcard_t),
2866 GFP_ATOMIC);
2867 ASSERT(physcard); 2837 ASSERT(physcard);
2868 SLIC_ZERO_MEMORY(physcard, sizeof(physcard_t)); 2838 memset(physcard, 0, sizeof(struct physcard *));
2869 2839
2870 DBG_MSG 2840 DBG_MSG
2871 ("\n%s Allocate a PHYSICALcard:\n PHYSICAL_Card[%p]\n\ 2841 ("\n%s Allocate a PHYSICALcard:\n PHYSICAL_Card[%p]\n\
@@ -2890,130 +2860,27 @@ ulong32 slic_card_locate(p_adapter_t adapter)
2890 return 0; 2860 return 0;
2891} 2861}
2892 2862
2893void slic_card_remaster(p_adapter_t adapter) 2863static void slic_soft_reset(struct adapter *adapter)
2894{
2895 p_sliccard_t card = adapter->card;
2896 int i;
2897
2898 DBG_MSG("slicoss: %s card->master[%p] == adapter[%p]??\n",
2899 __func__, card->master, adapter);
2900 if (card->master != adapter)
2901 return;
2902 card->master = NULL;
2903 for (i = 0; i < SLIC_MAX_PORTS; i++) {
2904 if (card->adapter[i] && (card->adapter[i] != adapter)) {
2905 card->master = card->adapter[i];
2906 DBG_MSG("slicoss: %s NEW MASTER SET card->master[%p]"
2907 " == card->adapter[%d]\n", __func__,
2908 card->master, i);
2909 break;
2910 }
2911 }
2912}
2913
2914void slic_soft_reset(p_adapter_t adapter)
2915{ 2864{
2916 if (adapter->card->state == CARD_UP) { 2865 if (adapter->card->state == CARD_UP) {
2917 DBG_MSG("slicoss: %s QUIESCE adapter[%p] card[%p] devid[%x]\n", 2866 DBG_MSG("slicoss: %s QUIESCE adapter[%p] card[%p] devid[%x]\n",
2918 __func__, adapter, adapter->card, adapter->devid); 2867 __func__, adapter, adapter->card, adapter->devid);
2919 WRITE_REG(adapter->slic_regs->slic_quiesce, 0, FLUSH); 2868 WRITE_REG(adapter->slic_regs->slic_quiesce, 0, FLUSH);
2920 slic_stall_msec(1); 2869 mdelay(1);
2921 } 2870 }
2922/* DBG_MSG ("slicoss: %s (%s) adapter[%p] card[%p] devid[%x]\n", 2871/* DBG_MSG ("slicoss: %s (%s) adapter[%p] card[%p] devid[%x]\n",
2923 __func__, adapter->netdev->name, adapter, adapter->card, 2872 __func__, adapter->netdev->name, adapter, adapter->card,
2924 adapter->devid); */ 2873 adapter->devid); */
2925 2874
2926 WRITE_REG(adapter->slic_regs->slic_reset, SLIC_RESET_MAGIC, FLUSH); 2875 WRITE_REG(adapter->slic_regs->slic_reset, SLIC_RESET_MAGIC, FLUSH);
2927 slic_stall_msec(1); 2876 mdelay(1);
2928}
2929
2930void slic_card_reset(p_adapter_t adapter)
2931{
2932 p_sliccard_t card = adapter->card;
2933 p_slic_upr_t upr = adapter->upr_list;
2934 p_slic_upr_t upr_next = NULL;
2935 ulong32 i;
2936#if SLIC_FAILURE_RESET
2937 ulong32 status = 0;
2938#endif
2939 DBG_MSG
2940 ("slicoss: %s adapter[%p] port[%d] state[%x] card[%p] state[%x]\n",
2941 __func__, adapter, adapter->port, adapter->state, card,
2942 card->state);
2943 SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->adapter_lock);
2944 SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->reset_lock);
2945 if (card->state == CARD_DIAG) {
2946 SLIC_RELEASE_IRQ_SPINLOCK(adapter->reset_lock);
2947 SLIC_RELEASE_IRQ_SPINLOCK(adapter->adapter_lock);
2948 return;
2949 }
2950 SLIC_ACQUIRE_IRQ_SPINLOCK(slic_global.driver_lock);
2951 card->reset_in_progress = 1;
2952#if SLIC_FAILURE_RESET
2953 if (adapter->state != ADAPT_RESET) {
2954 SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock);
2955 SLIC_RELEASE_IRQ_SPINLOCK(adapter->reset_lock);
2956 SLIC_RELEASE_IRQ_SPINLOCK(adapter->adapter_lock);
2957 return;
2958 }
2959
2960 adapter->state = ADAPT_DOWN;
2961 adapter->linkstate = LINK_DOWN;
2962#endif
2963 if (adapter->gennumber == card->gennumber) {
2964 for (i = 0; i < card->card_size; i++) {
2965 if (card->adapter[i]) {
2966 if (card->adapter[i] == adapter)
2967 continue;
2968 if (card->adapter[i]->state == ADAPT_UP) {
2969 card->adapter[i]->state = ADAPT_RESET;
2970 adapter->linkstate = LINK_DOWN;
2971 }
2972 }
2973 }
2974#if SLIC_FAILURE_RESET
2975 slic_soft_reset(adapter);
2976 card->state = CARD_DOWN;
2977 card->master = NULL;
2978 card->adapters_activated = 0;
2979#endif
2980 card->gennumber++;
2981 }
2982 adapter->gennumber = card->gennumber;
2983 adapter->pshmem->isr = 0;
2984 adapter->isrcopy = 0;
2985 SLIC_RELEASE_IRQ_SPINLOCK(adapter->reset_lock);
2986 for (i = 0; i < card->card_size; i++) {
2987 if (card->adapter[i])
2988 slic_cmdq_reset(card->adapter[i]);
2989 }
2990 while (upr) {
2991 upr_next = upr->next;
2992 SLIC_DEALLOCATE_MEM(upr);
2993 upr = upr_next;
2994 }
2995 adapter->upr_list = NULL;
2996 adapter->upr_busy = 0;
2997#if SLIC_FAILURE_RESET
2998 status = slic_if_init(adapter);
2999 if ((status == 0) && (!card->master))
3000 card->master = adapter;
3001 slic_mcast_set_mask(adapter);
3002#endif
3003 SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock);
3004 SLIC_RELEASE_IRQ_SPINLOCK(adapter->adapter_lock);
3005 DBG_MSG
3006 ("slicoss: %s EXIT adapter[%p] port[%d] state[%x] card[%p] \
3007 state[%x]\n", __func__, adapter, adapter->port, adapter->state,
3008 card, card->state);
3009 return;
3010} 2877}
3011 2878
3012void slic_config_set(p_adapter_t adapter, boolean linkchange) 2879static void slic_config_set(struct adapter *adapter, bool linkchange)
3013{ 2880{
3014 ulong32 value; 2881 u32 value;
3015 ulong32 RcrReset; 2882 u32 RcrReset;
3016 p_slic_regs_t slic_regs = adapter->slic_regs; 2883 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3017 2884
3018 DBG_MSG("slicoss: %s (%s) slic_interface_enable[%p](%d)\n", 2885 DBG_MSG("slicoss: %s (%s) slic_interface_enable[%p](%d)\n",
3019 __func__, adapter->netdev->name, adapter, 2886 __func__, adapter->netdev->name, adapter,
@@ -3075,11 +2942,11 @@ void slic_config_set(p_adapter_t adapter, boolean linkchange)
3075/* 2942/*
3076 * Turn off RCV and XMT, power down PHY 2943 * Turn off RCV and XMT, power down PHY
3077 */ 2944 */
3078void slic_config_clear(p_adapter_t adapter) 2945static void slic_config_clear(struct adapter *adapter)
3079{ 2946{
3080 ulong32 value; 2947 u32 value;
3081 ulong32 phy_config; 2948 u32 phy_config;
3082 p_slic_regs_t slic_regs = adapter->slic_regs; 2949 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3083 2950
3084 /* Setup xmtcfg */ 2951 /* Setup xmtcfg */
3085 value = (GXCR_RESET | /* Always reset */ 2952 value = (GXCR_RESET | /* Always reset */
@@ -3099,28 +2966,29 @@ void slic_config_clear(p_adapter_t adapter)
3099 WRITE_REG(slic_regs->slic_wphy, phy_config, FLUSH); 2966 WRITE_REG(slic_regs->slic_wphy, phy_config, FLUSH);
3100} 2967}
3101 2968
3102void slic_config_get(p_adapter_t adapter, ulong32 config, ulong32 config_h) 2969static void slic_config_get(struct adapter *adapter, u32 config,
2970 u32 config_h)
3103{ 2971{
3104 int status; 2972 int status;
3105 2973
3106 status = slic_upr_request(adapter, 2974 status = slic_upr_request(adapter,
3107 SLIC_UPR_RCONFIG, 2975 SLIC_UPR_RCONFIG,
3108 (ulong32) config, (ulong32) config_h, 0, 0); 2976 (u32) config, (u32) config_h, 0, 0);
3109 ASSERT(status == 0); 2977 ASSERT(status == 0);
3110} 2978}
3111 2979
3112void slic_mac_address_config(p_adapter_t adapter) 2980static void slic_mac_address_config(struct adapter *adapter)
3113{ 2981{
3114 ulong32 value; 2982 u32 value;
3115 ulong32 value2; 2983 u32 value2;
3116 p_slic_regs_t slic_regs = adapter->slic_regs; 2984 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3117 2985
3118 value = *(pulong32) &adapter->currmacaddr[2]; 2986 value = *(u32 *) &adapter->currmacaddr[2];
3119 value = ntohl(value); 2987 value = ntohl(value);
3120 WRITE_REG(slic_regs->slic_wraddral, value, FLUSH); 2988 WRITE_REG(slic_regs->slic_wraddral, value, FLUSH);
3121 WRITE_REG(slic_regs->slic_wraddrbl, value, FLUSH); 2989 WRITE_REG(slic_regs->slic_wraddrbl, value, FLUSH);
3122 2990
3123 value2 = (ulong32) ((adapter->currmacaddr[0] << 8 | 2991 value2 = (u32) ((adapter->currmacaddr[0] << 8 |
3124 adapter->currmacaddr[1]) & 0xFFFF); 2992 adapter->currmacaddr[1]) & 0xFFFF);
3125 2993
3126 WRITE_REG(slic_regs->slic_wraddrah, value2, FLUSH); 2994 WRITE_REG(slic_regs->slic_wraddrah, value2, FLUSH);
@@ -3136,10 +3004,10 @@ void slic_mac_address_config(p_adapter_t adapter)
3136 slic_mcast_set_mask(adapter); 3004 slic_mcast_set_mask(adapter);
3137} 3005}
3138 3006
3139void slic_mac_config(p_adapter_t adapter) 3007static void slic_mac_config(struct adapter *adapter)
3140{ 3008{
3141 ulong32 value; 3009 u32 value;
3142 p_slic_regs_t slic_regs = adapter->slic_regs; 3010 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3143 3011
3144 /* Setup GMAC gaps */ 3012 /* Setup GMAC gaps */
3145 if (adapter->linkspeed == LINK_1000MB) { 3013 if (adapter->linkspeed == LINK_1000MB) {
@@ -3169,12 +3037,13 @@ void slic_mac_config(p_adapter_t adapter)
3169 slic_mac_address_config(adapter); 3037 slic_mac_address_config(adapter);
3170} 3038}
3171 3039
3172boolean slic_mac_filter(p_adapter_t adapter, p_ether_header ether_frame) 3040static bool slic_mac_filter(struct adapter *adapter,
3041 struct ether_header *ether_frame)
3173{ 3042{
3174 ulong32 opts = adapter->macopts; 3043 u32 opts = adapter->macopts;
3175 pulong32 dhost4 = (pulong32) &ether_frame->ether_dhost[0]; 3044 u32 *dhost4 = (u32 *)&ether_frame->ether_dhost[0];
3176 pushort dhost2 = (pushort) &ether_frame->ether_dhost[4]; 3045 u16 *dhost2 = (u16 *)&ether_frame->ether_dhost[4];
3177 boolean equaladdr; 3046 bool equaladdr;
3178 3047
3179 if (opts & MAC_PROMISC) { 3048 if (opts & MAC_PROMISC) {
3180 DBG_MSG("slicoss: %s (%s) PROMISCUOUS. Accept frame\n", 3049 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)
3198 return TRUE; 3067 return TRUE;
3199 } 3068 }
3200 if (opts & MAC_MCAST) { 3069 if (opts & MAC_MCAST) {
3201 p_mcast_address_t mcaddr = adapter->mcastaddrs; 3070 struct mcast_address *mcaddr = adapter->mcastaddrs;
3202 3071
3203 while (mcaddr) { 3072 while (mcaddr) {
3204 ETHER_EQ_ADDR(mcaddr->address, 3073 ETHER_EQ_ADDR(mcaddr->address,
@@ -3224,9 +3093,9 @@ boolean slic_mac_filter(p_adapter_t adapter, p_ether_header ether_frame)
3224 3093
3225} 3094}
3226 3095
3227int slic_mac_set_address(struct net_device *dev, pvoid ptr) 3096static int slic_mac_set_address(struct net_device *dev, void *ptr)
3228{ 3097{
3229 p_adapter_t adapter = (p_adapter_t) netdev_priv(dev); 3098 struct adapter *adapter = (struct adapter *)netdev_priv(dev);
3230 struct sockaddr *addr = ptr; 3099 struct sockaddr *addr = ptr;
3231 3100
3232 DBG_MSG("%s ENTER (%s)\n", __func__, adapter->netdev->name); 3101 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)
3259 * 50 seconds or whatever STATS_TIMER_INTERVAL is set to. 3128 * 50 seconds or whatever STATS_TIMER_INTERVAL is set to.
3260 * 3129 *
3261 */ 3130 */
3262void slic_timer_get_stats(ulong dev) 3131static void slic_timer_get_stats(ulong dev)
3263{ 3132{
3264 p_adapter_t adapter; 3133 struct adapter *adapter;
3265 p_sliccard_t card; 3134 struct sliccard *card;
3266 p_slic_shmem_t pshmem; 3135 struct slic_shmem *pshmem;
3267 3136
3268 ASSERT(dev); 3137 ASSERT(dev);
3269 adapter = (p_adapter_t) ((struct net_device *)dev)->priv; 3138 adapter = (struct adapter *)((struct net_device *)dev)->priv;
3270 ASSERT(adapter); 3139 ASSERT(adapter);
3271 card = adapter->card; 3140 card = adapter->card;
3272 ASSERT(card); 3141 ASSERT(card);
3273 3142
3274 if ((card->state == CARD_UP) && 3143 if ((card->state == CARD_UP) &&
3275 (adapter->state == ADAPT_UP) && (adapter->linkstate == LINK_UP)) { 3144 (adapter->state == ADAPT_UP) && (adapter->linkstate == LINK_UP)) {
3276 pshmem = (p_slic_shmem_t) adapter->phys_shmem; 3145 pshmem = (struct slic_shmem *)adapter->phys_shmem;
3277#ifdef CONFIG_X86_64 3146#ifdef CONFIG_X86_64
3278 slic_upr_request(adapter, 3147 slic_upr_request(adapter,
3279 SLIC_UPR_STATS, 3148 SLIC_UPR_STATS,
@@ -3282,7 +3151,7 @@ void slic_timer_get_stats(ulong dev)
3282#elif defined(CONFIG_X86) 3151#elif defined(CONFIG_X86)
3283 slic_upr_request(adapter, 3152 slic_upr_request(adapter,
3284 SLIC_UPR_STATS, 3153 SLIC_UPR_STATS,
3285 (ulong32) &pshmem->inicstats, 0, 0, 0); 3154 (u32) &pshmem->inicstats, 0, 0, 0);
3286#else 3155#else
3287 Stop compilation; 3156 Stop compilation;
3288#endif 3157#endif
@@ -3295,12 +3164,12 @@ void slic_timer_get_stats(ulong dev)
3295 add_timer(&adapter->statstimer); 3164 add_timer(&adapter->statstimer);
3296} 3165}
3297 3166
3298void slic_timer_load_check(ulong cardaddr) 3167static void slic_timer_load_check(ulong cardaddr)
3299{ 3168{
3300 p_sliccard_t card = (p_sliccard_t) cardaddr; 3169 struct sliccard *card = (struct sliccard *)cardaddr;
3301 p_adapter_t adapter = card->master; 3170 struct adapter *adapter = card->master;
3302 ulong32 load = card->events; 3171 u32 load = card->events;
3303 ulong32 level = 0; 3172 u32 level = 0;
3304 3173
3305 if ((adapter) && (adapter->state == ADAPT_UP) && 3174 if ((adapter) && (adapter->state == ADAPT_UP) &&
3306 (card->state == CARD_UP) && (slic_global.dynamic_intagg)) { 3175 (card->state == CARD_UP) && (slic_global.dynamic_intagg)) {
@@ -3352,36 +3221,26 @@ void slic_timer_load_check(ulong cardaddr)
3352 add_timer(&card->loadtimer); 3221 add_timer(&card->loadtimer);
3353} 3222}
3354 3223
3355void slic_stall_msec(int stall) 3224static void slic_assert_fail(void)
3356{
3357 mdelay(stall);
3358}
3359
3360void slic_stall_usec(int stall)
3361{
3362 udelay(stall);
3363}
3364
3365void slic_assert_fail(void)
3366{ 3225{
3367 ulong32 cpuid; 3226 u32 cpuid;
3368 ulong32 curr_pid; 3227 u32 curr_pid;
3369 cpuid = smp_processor_id(); 3228 cpuid = smp_processor_id();
3370 curr_pid = current->pid; 3229 curr_pid = current->pid;
3371 3230
3372 DBG_ERROR("%s CPU # %d ---- PID # %d\n", __func__, cpuid, curr_pid); 3231 DBG_ERROR("%s CPU # %d ---- PID # %d\n", __func__, cpuid, curr_pid);
3373} 3232}
3374 3233
3375int slic_upr_queue_request(p_adapter_t adapter, 3234static int slic_upr_queue_request(struct adapter *adapter,
3376 ulong32 upr_request, 3235 u32 upr_request,
3377 ulong32 upr_data, 3236 u32 upr_data,
3378 ulong32 upr_data_h, 3237 u32 upr_data_h,
3379 ulong32 upr_buffer, ulong32 upr_buffer_h) 3238 u32 upr_buffer, u32 upr_buffer_h)
3380{ 3239{
3381 p_slic_upr_t upr; 3240 struct slic_upr *upr;
3382 p_slic_upr_t uprqueue; 3241 struct slic_upr *uprqueue;
3383 3242
3384 upr = SLIC_ALLOCATE_MEM(sizeof(slic_upr_t), GFP_ATOMIC); 3243 upr = kmalloc(sizeof(struct slic_upr), GFP_ATOMIC);
3385 if (!upr) { 3244 if (!upr) {
3386 DBG_MSG("%s COULD NOT ALLOCATE UPR MEM\n", __func__); 3245 DBG_MSG("%s COULD NOT ALLOCATE UPR MEM\n", __func__);
3387 3246
@@ -3406,42 +3265,45 @@ int slic_upr_queue_request(p_adapter_t adapter,
3406 return STATUS_SUCCESS; 3265 return STATUS_SUCCESS;
3407} 3266}
3408 3267
3409int slic_upr_request(p_adapter_t adapter, 3268static int slic_upr_request(struct adapter *adapter,
3410 ulong32 upr_request, 3269 u32 upr_request,
3411 ulong32 upr_data, 3270 u32 upr_data,
3412 ulong32 upr_data_h, 3271 u32 upr_data_h,
3413 ulong32 upr_buffer, ulong32 upr_buffer_h) 3272 u32 upr_buffer, u32 upr_buffer_h)
3414{ 3273{
3415 int status; 3274 int status;
3416 3275
3417 SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->upr_lock); 3276 spin_lock_irqsave(&adapter->upr_lock.lock, adapter->upr_lock.flags);
3418 status = slic_upr_queue_request(adapter, 3277 status = slic_upr_queue_request(adapter,
3419 upr_request, 3278 upr_request,
3420 upr_data, 3279 upr_data,
3421 upr_data_h, upr_buffer, upr_buffer_h); 3280 upr_data_h, upr_buffer, upr_buffer_h);
3422 if (status != STATUS_SUCCESS) { 3281 if (status != STATUS_SUCCESS) {
3423 SLIC_RELEASE_IRQ_SPINLOCK(adapter->upr_lock); 3282 spin_unlock_irqrestore(&adapter->upr_lock.lock,
3283 adapter->upr_lock.flags);
3424 return status; 3284 return status;
3425 } 3285 }
3426 slic_upr_start(adapter); 3286 slic_upr_start(adapter);
3427 SLIC_RELEASE_IRQ_SPINLOCK(adapter->upr_lock); 3287 spin_unlock_irqrestore(&adapter->upr_lock.lock,
3288 adapter->upr_lock.flags);
3428 return STATUS_PENDING; 3289 return STATUS_PENDING;
3429} 3290}
3430 3291
3431void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr) 3292static void slic_upr_request_complete(struct adapter *adapter, u32 isr)
3432{ 3293{
3433 p_sliccard_t card = adapter->card; 3294 struct sliccard *card = adapter->card;
3434 p_slic_upr_t upr; 3295 struct slic_upr *upr;
3435 3296
3436/* if (card->dump_requested) { 3297/* if (card->dump_requested) {
3437 DBG_MSG("ENTER slic_upr_request_complete Dump in progress ISR[%x]\n", 3298 DBG_MSG("ENTER slic_upr_request_complete Dump in progress ISR[%x]\n",
3438 isr); 3299 isr);
3439 } */ 3300 } */
3440 SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->upr_lock); 3301 spin_lock_irqsave(&adapter->upr_lock.lock, adapter->upr_lock.flags);
3441 upr = adapter->upr_list; 3302 upr = adapter->upr_list;
3442 if (!upr) { 3303 if (!upr) {
3443 ASSERT(0); 3304 ASSERT(0);
3444 SLIC_RELEASE_IRQ_SPINLOCK(adapter->upr_lock); 3305 spin_unlock_irqrestore(&adapter->upr_lock.lock,
3306 adapter->upr_lock.flags);
3445 return; 3307 return;
3446 } 3308 }
3447 adapter->upr_list = upr->next; 3309 adapter->upr_list = upr->next;
@@ -3452,11 +3314,11 @@ void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr)
3452 case SLIC_UPR_STATS: 3314 case SLIC_UPR_STATS:
3453 { 3315 {
3454#if SLIC_GET_STATS_ENABLED 3316#if SLIC_GET_STATS_ENABLED
3455 p_slic_stats_t slicstats = 3317 struct slic_stats *slicstats =
3456 (p_slic_stats_t) &adapter->pshmem->inicstats; 3318 (struct slic_stats *) &adapter->pshmem->inicstats;
3457 p_slic_stats_t newstats = slicstats; 3319 struct slic_stats *newstats = slicstats;
3458 p_slic_stats_t old = &adapter->inicstats_prev; 3320 struct slic_stats *old = &adapter->inicstats_prev;
3459 p_slicnet_stats_t stst = &adapter->slic_stats; 3321 struct slicnet_stats *stst = &adapter->slic_stats;
3460#endif 3322#endif
3461 if (isr & ISR_UPCERR) { 3323 if (isr & ISR_UPCERR) {
3462 DBG_ERROR 3324 DBG_ERROR
@@ -3540,7 +3402,7 @@ void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr)
3540 (newstats->rcv_drops_gb - 3402 (newstats->rcv_drops_gb -
3541 old->rcv_drops_gb); 3403 old->rcv_drops_gb);
3542 } 3404 }
3543 memcpy(old, newstats, sizeof(slic_stats_t)); 3405 memcpy(old, newstats, sizeof(struct slic_stats));
3544#endif 3406#endif
3545 break; 3407 break;
3546 } 3408 }
@@ -3572,15 +3434,16 @@ void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr)
3572 default: 3434 default:
3573 ASSERT(0); 3435 ASSERT(0);
3574 } 3436 }
3575 SLIC_DEALLOCATE_MEM(upr); 3437 kfree(upr);
3576 slic_upr_start(adapter); 3438 slic_upr_start(adapter);
3577 SLIC_RELEASE_IRQ_SPINLOCK(adapter->upr_lock); 3439 spin_unlock_irqrestore(&adapter->upr_lock.lock,
3440 adapter->upr_lock.flags);
3578} 3441}
3579 3442
3580void slic_upr_start(p_adapter_t adapter) 3443static void slic_upr_start(struct adapter *adapter)
3581{ 3444{
3582 p_slic_upr_t upr; 3445 struct slic_upr *upr;
3583 p_slic_regs_t slic_regs = adapter->slic_regs; 3446 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3584/* 3447/*
3585 char * ptr1; 3448 char * ptr1;
3586 char * ptr2; 3449 char * ptr2;
@@ -3670,21 +3533,21 @@ void slic_upr_start(p_adapter_t adapter)
3670 } 3533 }
3671} 3534}
3672 3535
3673void slic_link_upr_complete(p_adapter_t adapter, ulong32 isr) 3536static void slic_link_upr_complete(struct adapter *adapter, u32 isr)
3674{ 3537{
3675 ulong32 linkstatus = adapter->pshmem->linkstatus; 3538 u32 linkstatus = adapter->pshmem->linkstatus;
3676 uint linkup; 3539 uint linkup;
3677 uchar linkspeed; 3540 unsigned char linkspeed;
3678 uchar linkduplex; 3541 unsigned char linkduplex;
3679 3542
3680 DBG_MSG("%s: %s ISR[%x] linkstatus[%x]\n adapter[%p](%d)\n", 3543 DBG_MSG("%s: %s ISR[%x] linkstatus[%x]\n adapter[%p](%d)\n",
3681 __func__, adapter->netdev->name, isr, linkstatus, adapter, 3544 __func__, adapter->netdev->name, isr, linkstatus, adapter,
3682 adapter->cardindex); 3545 adapter->cardindex);
3683 3546
3684 if ((isr & ISR_UPCERR) || (isr & ISR_UPCBSY)) { 3547 if ((isr & ISR_UPCERR) || (isr & ISR_UPCBSY)) {
3685 p_slic_shmem_t pshmem; 3548 struct slic_shmem *pshmem;
3686 3549
3687 pshmem = (p_slic_shmem_t) adapter->phys_shmem; 3550 pshmem = (struct slic_shmem *)adapter->phys_shmem;
3688#if defined(CONFIG_X86_64) 3551#if defined(CONFIG_X86_64)
3689 slic_upr_queue_request(adapter, 3552 slic_upr_queue_request(adapter,
3690 SLIC_UPR_RLSR, 3553 SLIC_UPR_RLSR,
@@ -3694,7 +3557,7 @@ void slic_link_upr_complete(p_adapter_t adapter, ulong32 isr)
3694#elif defined(CONFIG_X86) 3557#elif defined(CONFIG_X86)
3695 slic_upr_queue_request(adapter, 3558 slic_upr_queue_request(adapter,
3696 SLIC_UPR_RLSR, 3559 SLIC_UPR_RLSR,
3697 (ulong32) &pshmem->linkstatus, 3560 (u32) &pshmem->linkstatus,
3698 SLIC_GET_ADDR_HIGH(pshmem), 0, 0); 3561 SLIC_GET_ADDR_HIGH(pshmem), 0, 0);
3699#else 3562#else
3700 Stop Compilation; 3563 Stop Compilation;
@@ -3792,16 +3655,16 @@ void slic_link_upr_complete(p_adapter_t adapter, ulong32 isr)
3792 * which prevens us from using the ucode result. 3655 * which prevens us from using the ucode result.
3793 * remove this once ucode is fixed. 3656 * remove this once ucode is fixed.
3794 */ 3657 */
3795ushort slic_eeprom_cksum(pchar m, int len) 3658static ushort slic_eeprom_cksum(char *m, int len)
3796{ 3659{
3797#define ADDCARRY(x) (x > 65535 ? x -= 65535 : x) 3660#define ADDCARRY(x) (x > 65535 ? x -= 65535 : x)
3798#define REDUCE {l_util.l = sum; sum = l_util.s[0] + l_util.s[1]; ADDCARRY(sum);\ 3661#define REDUCE {l_util.l = sum; sum = l_util.s[0] + l_util.s[1]; ADDCARRY(sum);\
3799 } 3662 }
3800 3663
3801 pushort w; 3664 u16 *w;
3802 ulong32 sum = 0; 3665 u32 sum = 0;
3803 ulong32 byte_swapped = 0; 3666 u32 byte_swapped = 0;
3804 ulong32 w_int; 3667 u32 w_int;
3805 3668
3806 union { 3669 union {
3807 char c[2]; 3670 char c[2];
@@ -3816,17 +3679,17 @@ ushort slic_eeprom_cksum(pchar m, int len)
3816 l_util.l = 0; 3679 l_util.l = 0;
3817 s_util.s = 0; 3680 s_util.s = 0;
3818 3681
3819 w = (pushort) m; 3682 w = (u16 *)m;
3820#ifdef CONFIG_X86_64 3683#ifdef CONFIG_X86_64
3821 w_int = (ulong32) ((ulong) w & 0x00000000FFFFFFFF); 3684 w_int = (u32) ((ulong) w & 0x00000000FFFFFFFF);
3822#else 3685#else
3823 w_int = (ulong32) (w); 3686 w_int = (u32) (w);
3824#endif 3687#endif
3825 if ((1 & w_int) && (len > 0)) { 3688 if ((1 & w_int) && (len > 0)) {
3826 REDUCE; 3689 REDUCE;
3827 sum <<= 8; 3690 sum <<= 8;
3828 s_util.c[0] = *(puchar) w; 3691 s_util.c[0] = *(unsigned char *)w;
3829 w = (pushort) ((char *)w + 1); 3692 w = (u16 *)((char *)w + 1);
3830 len--; 3693 len--;
3831 byte_swapped = 1; 3694 byte_swapped = 1;
3832 } 3695 }
@@ -3849,7 +3712,7 @@ ushort slic_eeprom_cksum(pchar m, int len)
3849 sum += w[13]; 3712 sum += w[13];
3850 sum += w[14]; 3713 sum += w[14];
3851 sum += w[15]; 3714 sum += w[15];
3852 w = (pushort) ((ulong) w + 16); /* verify */ 3715 w = (u16 *)((ulong) w + 16); /* verify */
3853 } 3716 }
3854 len += 32; 3717 len += 32;
3855 while ((len -= 8) >= 0) { 3718 while ((len -= 8) >= 0) {
@@ -3857,7 +3720,7 @@ ushort slic_eeprom_cksum(pchar m, int len)
3857 sum += w[1]; 3720 sum += w[1];
3858 sum += w[2]; 3721 sum += w[2];
3859 sum += w[3]; 3722 sum += w[3];
3860 w = (pushort) ((ulong) w + 4); /* verify */ 3723 w = (u16 *)((ulong) w + 4); /* verify */
3861 } 3724 }
3862 len += 8; 3725 len += 8;
3863 if (len != 0 || byte_swapped != 0) { 3726 if (len != 0 || byte_swapped != 0) {
@@ -3869,7 +3732,7 @@ ushort slic_eeprom_cksum(pchar m, int len)
3869 sum <<= 8; 3732 sum <<= 8;
3870 byte_swapped = 0; 3733 byte_swapped = 0;
3871 if (len == -1) { 3734 if (len == -1) {
3872 s_util.c[1] = *(pchar) w; 3735 s_util.c[1] = *(char *) w;
3873 sum += s_util.s; 3736 sum += s_util.s;
3874 len = 0; 3737 len = 0;
3875 } else { 3738 } else {
@@ -3877,7 +3740,7 @@ ushort slic_eeprom_cksum(pchar m, int len)
3877 } 3740 }
3878 3741
3879 } else if (len == -1) { 3742 } else if (len == -1) {
3880 s_util.c[0] = *(pchar) w; 3743 s_util.c[0] = *(char *) w;
3881 } 3744 }
3882 3745
3883 if (len == -1) { 3746 if (len == -1) {
@@ -3889,17 +3752,17 @@ ushort slic_eeprom_cksum(pchar m, int len)
3889 return (ushort) sum; 3752 return (ushort) sum;
3890} 3753}
3891 3754
3892int slic_rspqueue_init(p_adapter_t adapter) 3755static int slic_rspqueue_init(struct adapter *adapter)
3893{ 3756{
3894 int i; 3757 int i;
3895 p_slic_rspqueue_t rspq = &adapter->rspqueue; 3758 struct slic_rspqueue *rspq = &adapter->rspqueue;
3896 p_slic_regs_t slic_regs = adapter->slic_regs; 3759 __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3897 ulong32 paddrh = 0; 3760 u32 paddrh = 0;
3898 3761
3899 DBG_MSG("slicoss: %s (%s) ENTER adapter[%p]\n", __func__, 3762 DBG_MSG("slicoss: %s (%s) ENTER adapter[%p]\n", __func__,
3900 adapter->netdev->name, adapter); 3763 adapter->netdev->name, adapter);
3901 ASSERT(adapter->state == ADAPT_DOWN); 3764 ASSERT(adapter->state == ADAPT_DOWN);
3902 SLIC_ZERO_MEMORY(rspq, sizeof(slic_rspqueue_t)); 3765 memset(rspq, 0, sizeof(struct slic_rspqueue));
3903 3766
3904 rspq->num_pages = SLIC_RSPQ_PAGES_GB; 3767 rspq->num_pages = SLIC_RSPQ_PAGES_GB;
3905 3768
@@ -3914,12 +3777,12 @@ int slic_rspqueue_init(p_adapter_t adapter)
3914 return STATUS_FAILURE; 3777 return STATUS_FAILURE;
3915 } 3778 }
3916#ifndef CONFIG_X86_64 3779#ifndef CONFIG_X86_64
3917 ASSERT(((ulong32) rspq->vaddr[i] & 0xFFFFF000) == 3780 ASSERT(((u32) rspq->vaddr[i] & 0xFFFFF000) ==
3918 (ulong32) rspq->vaddr[i]); 3781 (u32) rspq->vaddr[i]);
3919 ASSERT(((ulong32) rspq->paddr[i] & 0xFFFFF000) == 3782 ASSERT(((u32) rspq->paddr[i] & 0xFFFFF000) ==
3920 (ulong32) rspq->paddr[i]); 3783 (u32) rspq->paddr[i]);
3921#endif 3784#endif
3922 SLIC_ZERO_MEMORY(rspq->vaddr[i], PAGE_SIZE); 3785 memset(rspq->vaddr[i], 0, PAGE_SIZE);
3923/* DBG_MSG("slicoss: %s UPLOAD RSPBUFF Page pageix[%x] paddr[%p] " 3786/* DBG_MSG("slicoss: %s UPLOAD RSPBUFF Page pageix[%x] paddr[%p] "
3924 "vaddr[%p]\n", 3787 "vaddr[%p]\n",
3925 __func__, i, (void *)rspq->paddr[i], rspq->vaddr[i]); */ 3788 __func__, i, (void *)rspq->paddr[i], rspq->vaddr[i]); */
@@ -3938,15 +3801,15 @@ int slic_rspqueue_init(p_adapter_t adapter)
3938 } 3801 }
3939 rspq->offset = 0; 3802 rspq->offset = 0;
3940 rspq->pageindex = 0; 3803 rspq->pageindex = 0;
3941 rspq->rspbuf = (p_slic_rspbuf_t) rspq->vaddr[0]; 3804 rspq->rspbuf = (struct slic_rspbuf *)rspq->vaddr[0];
3942 DBG_MSG("slicoss: %s (%s) EXIT adapter[%p]\n", __func__, 3805 DBG_MSG("slicoss: %s (%s) EXIT adapter[%p]\n", __func__,
3943 adapter->netdev->name, adapter); 3806 adapter->netdev->name, adapter);
3944 return STATUS_SUCCESS; 3807 return STATUS_SUCCESS;
3945} 3808}
3946 3809
3947int slic_rspqueue_reset(p_adapter_t adapter) 3810static int slic_rspqueue_reset(struct adapter *adapter)
3948{ 3811{
3949 p_slic_rspqueue_t rspq = &adapter->rspqueue; 3812 struct slic_rspqueue *rspq = &adapter->rspqueue;
3950 3813
3951 DBG_MSG("slicoss: %s (%s) ENTER adapter[%p]\n", __func__, 3814 DBG_MSG("slicoss: %s (%s) ENTER adapter[%p]\n", __func__,
3952 adapter->netdev->name, adapter); 3815 adapter->netdev->name, adapter);
@@ -3964,10 +3827,10 @@ int slic_rspqueue_reset(p_adapter_t adapter)
3964 return STATUS_SUCCESS; 3827 return STATUS_SUCCESS;
3965} 3828}
3966 3829
3967void slic_rspqueue_free(p_adapter_t adapter) 3830static void slic_rspqueue_free(struct adapter *adapter)
3968{ 3831{
3969 int i; 3832 int i;
3970 slic_rspqueue_t *rspq = &adapter->rspqueue; 3833 struct slic_rspqueue *rspq = &adapter->rspqueue;
3971 3834
3972 DBG_MSG("slicoss: %s adapter[%p] port %d rspq[%p] FreeRSPQ\n", 3835 DBG_MSG("slicoss: %s adapter[%p] port %d rspq[%p] FreeRSPQ\n",
3973 __func__, adapter, adapter->physport, rspq); 3836 __func__, adapter, adapter->physport, rspq);
@@ -3976,7 +3839,7 @@ void slic_rspqueue_free(p_adapter_t adapter)
3976 DBG_MSG 3839 DBG_MSG
3977 ("slicoss: pci_free_consistent rspq->vaddr[%p] \ 3840 ("slicoss: pci_free_consistent rspq->vaddr[%p] \
3978 paddr[%p]\n", 3841 paddr[%p]\n",
3979 rspq->vaddr[i], (pvoid) rspq->paddr[i]); 3842 rspq->vaddr[i], (void *) rspq->paddr[i]);
3980 pci_free_consistent(adapter->pcidev, PAGE_SIZE, 3843 pci_free_consistent(adapter->pcidev, PAGE_SIZE,
3981 rspq->vaddr[i], rspq->paddr[i]); 3844 rspq->vaddr[i], rspq->paddr[i]);
3982 } 3845 }
@@ -3988,10 +3851,10 @@ void slic_rspqueue_free(p_adapter_t adapter)
3988 rspq->rspbuf = NULL; 3851 rspq->rspbuf = NULL;
3989} 3852}
3990 3853
3991p_slic_rspbuf_t slic_rspqueue_getnext(p_adapter_t adapter) 3854static struct slic_rspbuf *slic_rspqueue_getnext(struct adapter *adapter)
3992{ 3855{
3993 p_slic_rspqueue_t rspq = &adapter->rspqueue; 3856 struct slic_rspqueue *rspq = &adapter->rspqueue;
3994 p_slic_rspbuf_t buf; 3857 struct slic_rspbuf *buf;
3995 3858
3996 if (!(rspq->rspbuf->status)) 3859 if (!(rspq->rspbuf->status))
3997 return NULL; 3860 return NULL;
@@ -4004,8 +3867,8 @@ p_slic_rspbuf_t slic_rspqueue_getnext(p_adapter_t adapter)
4004 if (++rspq->offset < SLIC_RSPQ_BUFSINPAGE) { 3867 if (++rspq->offset < SLIC_RSPQ_BUFSINPAGE) {
4005 rspq->rspbuf++; 3868 rspq->rspbuf++;
4006#ifndef CONFIG_X86_64 3869#ifndef CONFIG_X86_64
4007 ASSERT(((ulong32) rspq->rspbuf & 0xFFFFFFE0) == 3870 ASSERT(((u32) rspq->rspbuf & 0xFFFFFFE0) ==
4008 (ulong32) rspq->rspbuf); 3871 (u32) rspq->rspbuf);
4009#endif 3872#endif
4010 } else { 3873 } else {
4011 ASSERT(rspq->offset == SLIC_RSPQ_BUFSINPAGE); 3874 ASSERT(rspq->offset == SLIC_RSPQ_BUFSINPAGE);
@@ -4016,28 +3879,29 @@ p_slic_rspbuf_t slic_rspqueue_getnext(p_adapter_t adapter)
4016 adapter->slic_regs->slic_addr_upper, 0, DONT_FLUSH); 3879 adapter->slic_regs->slic_addr_upper, 0, DONT_FLUSH);
4017 rspq->pageindex = (++rspq->pageindex) % rspq->num_pages; 3880 rspq->pageindex = (++rspq->pageindex) % rspq->num_pages;
4018 rspq->offset = 0; 3881 rspq->offset = 0;
4019 rspq->rspbuf = (p_slic_rspbuf_t) rspq->vaddr[rspq->pageindex]; 3882 rspq->rspbuf = (struct slic_rspbuf *)
3883 rspq->vaddr[rspq->pageindex];
4020#ifndef CONFIG_X86_64 3884#ifndef CONFIG_X86_64
4021 ASSERT(((ulong32) rspq->rspbuf & 0xFFFFF000) == 3885 ASSERT(((u32) rspq->rspbuf & 0xFFFFF000) ==
4022 (ulong32) rspq->rspbuf); 3886 (u32) rspq->rspbuf);
4023#endif 3887#endif
4024 } 3888 }
4025#ifndef CONFIG_X86_64 3889#ifndef CONFIG_X86_64
4026 ASSERT(((ulong32) buf & 0xFFFFFFE0) == (ulong32) buf); 3890 ASSERT(((u32) buf & 0xFFFFFFE0) == (u32) buf);
4027#endif 3891#endif
4028 return buf; 3892 return buf;
4029} 3893}
4030 3894
4031void slic_cmdqmem_init(p_adapter_t adapter) 3895static void slic_cmdqmem_init(struct adapter *adapter)
4032{ 3896{
4033 slic_cmdqmem_t *cmdqmem = &adapter->cmdqmem; 3897 struct slic_cmdqmem *cmdqmem = &adapter->cmdqmem;
4034 3898
4035 SLIC_ZERO_MEMORY(cmdqmem, sizeof(slic_cmdqmem_t)); 3899 memset(cmdqmem, 0, sizeof(struct slic_cmdqmem));
4036} 3900}
4037 3901
4038void slic_cmdqmem_free(p_adapter_t adapter) 3902static void slic_cmdqmem_free(struct adapter *adapter)
4039{ 3903{
4040 slic_cmdqmem_t *cmdqmem = &adapter->cmdqmem; 3904 struct slic_cmdqmem *cmdqmem = &adapter->cmdqmem;
4041 int i; 3905 int i;
4042 3906
4043 DBG_MSG("slicoss: (%s) adapter[%p] port %d rspq[%p] Free CMDQ Memory\n", 3907 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)
4045 for (i = 0; i < SLIC_CMDQ_MAXPAGES; i++) { 3909 for (i = 0; i < SLIC_CMDQ_MAXPAGES; i++) {
4046 if (cmdqmem->pages[i]) { 3910 if (cmdqmem->pages[i]) {
4047 DBG_MSG("slicoss: %s Deallocate page CmdQPage[%p]\n", 3911 DBG_MSG("slicoss: %s Deallocate page CmdQPage[%p]\n",
4048 __func__, (pvoid) cmdqmem->pages[i]); 3912 __func__, (void *) cmdqmem->pages[i]);
4049 pci_free_consistent(adapter->pcidev, 3913 pci_free_consistent(adapter->pcidev,
4050 PAGE_SIZE, 3914 PAGE_SIZE,
4051 (pvoid) cmdqmem->pages[i], 3915 (void *) cmdqmem->pages[i],
4052 cmdqmem->dma_pages[i]); 3916 cmdqmem->dma_pages[i]);
4053 } 3917 }
4054 } 3918 }
4055 SLIC_ZERO_MEMORY(cmdqmem, sizeof(slic_cmdqmem_t)); 3919 memset(cmdqmem, 0, sizeof(struct slic_cmdqmem));
4056} 3920}
4057 3921
4058pulong32 slic_cmdqmem_addpage(p_adapter_t adapter) 3922static u32 *slic_cmdqmem_addpage(struct adapter *adapter)
4059{ 3923{
4060 p_slic_cmdqmem_t cmdqmem = &adapter->cmdqmem; 3924 struct slic_cmdqmem *cmdqmem = &adapter->cmdqmem;
4061 pulong32 pageaddr; 3925 u32 *pageaddr;
4062 3926
4063 if (cmdqmem->pagecnt >= SLIC_CMDQ_MAXPAGES) 3927 if (cmdqmem->pagecnt >= SLIC_CMDQ_MAXPAGES)
4064 return NULL; 3928 return NULL;
@@ -4068,32 +3932,32 @@ pulong32 slic_cmdqmem_addpage(p_adapter_t adapter)
4068 if (!pageaddr) 3932 if (!pageaddr)
4069 return NULL; 3933 return NULL;
4070#ifndef CONFIG_X86_64 3934#ifndef CONFIG_X86_64
4071 ASSERT(((ulong32) pageaddr & 0xFFFFF000) == (ulong32) pageaddr); 3935 ASSERT(((u32) pageaddr & 0xFFFFF000) == (u32) pageaddr);
4072#endif 3936#endif
4073 cmdqmem->pages[cmdqmem->pagecnt] = pageaddr; 3937 cmdqmem->pages[cmdqmem->pagecnt] = pageaddr;
4074 cmdqmem->pagecnt++; 3938 cmdqmem->pagecnt++;
4075 return pageaddr; 3939 return pageaddr;
4076} 3940}
4077 3941
4078int slic_cmdq_init(p_adapter_t adapter) 3942static int slic_cmdq_init(struct adapter *adapter)
4079{ 3943{
4080 int i; 3944 int i;
4081 pulong32 pageaddr; 3945 u32 *pageaddr;
4082 3946
4083 DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter); 3947 DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter);
4084 ASSERT(adapter->state == ADAPT_DOWN); 3948 ASSERT(adapter->state == ADAPT_DOWN);
4085 SLIC_ZERO_MEMORY(&adapter->cmdq_all, sizeof(slic_cmdqueue_t)); 3949 memset(&adapter->cmdq_all, 0, sizeof(struct slic_cmdqueue));
4086 SLIC_ZERO_MEMORY(&adapter->cmdq_free, sizeof(slic_cmdqueue_t)); 3950 memset(&adapter->cmdq_free, 0, sizeof(struct slic_cmdqueue));
4087 SLIC_ZERO_MEMORY(&adapter->cmdq_done, sizeof(slic_cmdqueue_t)); 3951 memset(&adapter->cmdq_done, 0, sizeof(struct slic_cmdqueue));
4088 SLIC_INIT_SPINLOCK(adapter->cmdq_all.lock); 3952 spin_lock_init(&adapter->cmdq_all.lock.lock);
4089 SLIC_INIT_SPINLOCK(adapter->cmdq_free.lock); 3953 spin_lock_init(&adapter->cmdq_free.lock.lock);
4090 SLIC_INIT_SPINLOCK(adapter->cmdq_done.lock); 3954 spin_lock_init(&adapter->cmdq_done.lock.lock);
4091 slic_cmdqmem_init(adapter); 3955 slic_cmdqmem_init(adapter);
4092 adapter->slic_handle_ix = 1; 3956 adapter->slic_handle_ix = 1;
4093 for (i = 0; i < SLIC_CMDQ_INITPAGES; i++) { 3957 for (i = 0; i < SLIC_CMDQ_INITPAGES; i++) {
4094 pageaddr = slic_cmdqmem_addpage(adapter); 3958 pageaddr = slic_cmdqmem_addpage(adapter);
4095#ifndef CONFIG_X86_64 3959#ifndef CONFIG_X86_64
4096 ASSERT(((ulong32) pageaddr & 0xFFFFF000) == (ulong32) pageaddr); 3960 ASSERT(((u32) pageaddr & 0xFFFFF000) == (u32) pageaddr);
4097#endif 3961#endif
4098 if (!pageaddr) { 3962 if (!pageaddr) {
4099 slic_cmdq_free(adapter); 3963 slic_cmdq_free(adapter);
@@ -4107,9 +3971,9 @@ int slic_cmdq_init(p_adapter_t adapter)
4107 return STATUS_SUCCESS; 3971 return STATUS_SUCCESS;
4108} 3972}
4109 3973
4110void slic_cmdq_free(p_adapter_t adapter) 3974static void slic_cmdq_free(struct adapter *adapter)
4111{ 3975{
4112 p_slic_hostcmd_t cmd; 3976 struct slic_hostcmd *cmd;
4113 3977
4114 DBG_MSG("slicoss: %s adapter[%p] port %d FreeCommandsFrom CMDQ\n", 3978 DBG_MSG("slicoss: %s adapter[%p] port %d FreeCommandsFrom CMDQ\n",
4115 __func__, adapter, adapter->physport); 3979 __func__, adapter, adapter->physport);
@@ -4126,21 +3990,23 @@ void slic_cmdq_free(p_adapter_t adapter)
4126 } 3990 }
4127 cmd = cmd->next_all; 3991 cmd = cmd->next_all;
4128 } 3992 }
4129 SLIC_ZERO_MEMORY(&adapter->cmdq_all, sizeof(slic_cmdqueue_t)); 3993 memset(&adapter->cmdq_all, 0, sizeof(struct slic_cmdqueue));
4130 SLIC_ZERO_MEMORY(&adapter->cmdq_free, sizeof(slic_cmdqueue_t)); 3994 memset(&adapter->cmdq_free, 0, sizeof(struct slic_cmdqueue));
4131 SLIC_ZERO_MEMORY(&adapter->cmdq_done, sizeof(slic_cmdqueue_t)); 3995 memset(&adapter->cmdq_done, 0, sizeof(struct slic_cmdqueue));
4132 slic_cmdqmem_free(adapter); 3996 slic_cmdqmem_free(adapter);
4133} 3997}
4134 3998
4135void slic_cmdq_reset(p_adapter_t adapter) 3999static void slic_cmdq_reset(struct adapter *adapter)
4136{ 4000{
4137 p_slic_hostcmd_t hcmd; 4001 struct slic_hostcmd *hcmd;
4138 struct sk_buff *skb; 4002 struct sk_buff *skb;
4139 ulong32 outstanding; 4003 u32 outstanding;
4140 4004
4141 DBG_MSG("%s ENTER adapter[%p]\n", __func__, adapter); 4005 DBG_MSG("%s ENTER adapter[%p]\n", __func__, adapter);
4142 SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->cmdq_free.lock); 4006 spin_lock_irqsave(&adapter->cmdq_free.lock.lock,
4143 SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->cmdq_done.lock); 4007 adapter->cmdq_free.lock.flags);
4008 spin_lock_irqsave(&adapter->cmdq_done.lock.lock,
4009 adapter->cmdq_done.lock.flags);
4144 outstanding = adapter->cmdq_all.count - adapter->cmdq_done.count; 4010 outstanding = adapter->cmdq_all.count - adapter->cmdq_done.count;
4145 outstanding -= adapter->cmdq_free.count; 4011 outstanding -= adapter->cmdq_free.count;
4146 hcmd = adapter->cmdq_all.head; 4012 hcmd = adapter->cmdq_all.head;
@@ -4174,31 +4040,33 @@ void slic_cmdq_reset(p_adapter_t adapter)
4174 DBG_ERROR("%s free_count %d != all count %d\n", __func__, 4040 DBG_ERROR("%s free_count %d != all count %d\n", __func__,
4175 adapter->cmdq_free.count, adapter->cmdq_all.count); 4041 adapter->cmdq_free.count, adapter->cmdq_all.count);
4176 } 4042 }
4177 SLIC_RELEASE_IRQ_SPINLOCK(adapter->cmdq_done.lock); 4043 spin_unlock_irqrestore(&adapter->cmdq_done.lock.lock,
4178 SLIC_RELEASE_IRQ_SPINLOCK(adapter->cmdq_free.lock); 4044 adapter->cmdq_done.lock.flags);
4045 spin_unlock_irqrestore(&adapter->cmdq_free.lock.lock,
4046 adapter->cmdq_free.lock.flags);
4179 DBG_MSG("%s EXIT adapter[%p]\n", __func__, adapter); 4047 DBG_MSG("%s EXIT adapter[%p]\n", __func__, adapter);
4180} 4048}
4181 4049
4182void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page) 4050static void slic_cmdq_addcmdpage(struct adapter *adapter, u32 *page)
4183{ 4051{
4184 p_slic_hostcmd_t cmd; 4052 struct slic_hostcmd *cmd;
4185 p_slic_hostcmd_t prev; 4053 struct slic_hostcmd *prev;
4186 p_slic_hostcmd_t tail; 4054 struct slic_hostcmd *tail;
4187 p_slic_cmdqueue_t cmdq; 4055 struct slic_cmdqueue *cmdq;
4188 int cmdcnt; 4056 int cmdcnt;
4189 pvoid cmdaddr; 4057 void *cmdaddr;
4190 ulong phys_addr; 4058 ulong phys_addr;
4191 ulong32 phys_addrl; 4059 u32 phys_addrl;
4192 ulong32 phys_addrh; 4060 u32 phys_addrh;
4193 pslic_handle_t pslic_handle; 4061 struct slic_handle *pslic_handle;
4194 4062
4195 cmdaddr = page; 4063 cmdaddr = page;
4196 cmd = (p_slic_hostcmd_t) cmdaddr; 4064 cmd = (struct slic_hostcmd *)cmdaddr;
4197/* DBG_MSG("CMDQ Page addr[%p] ix[%d] pfree[%p]\n", cmdaddr, slic_handle_ix, 4065/* DBG_MSG("CMDQ Page addr[%p] ix[%d] pfree[%p]\n", cmdaddr, slic_handle_ix,
4198 adapter->pfree_slic_handles); */ 4066 adapter->pfree_slic_handles); */
4199 cmdcnt = 0; 4067 cmdcnt = 0;
4200 4068
4201 phys_addr = SLIC_GET_PHYSICAL_ADDRESS((void *)page); 4069 phys_addr = virt_to_bus((void *)page);
4202 phys_addrl = SLIC_GET_ADDR_LOW(phys_addr); 4070 phys_addrl = SLIC_GET_ADDR_LOW(phys_addr);
4203 phys_addrh = SLIC_GET_ADDR_HIGH(phys_addr); 4071 phys_addrh = SLIC_GET_ADDR_HIGH(phys_addr);
4204 4072
@@ -4214,7 +4082,7 @@ void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page)
4214 &adapter->slic_handles[pslic_handle->token. 4082 &adapter->slic_handles[pslic_handle->token.
4215 handle_index]); 4083 handle_index]);
4216 pslic_handle->type = SLIC_HANDLE_CMD; 4084 pslic_handle->type = SLIC_HANDLE_CMD;
4217 pslic_handle->address = (pvoid) cmd; 4085 pslic_handle->address = (void *) cmd;
4218 pslic_handle->offset = (ushort) adapter->slic_handle_ix++; 4086 pslic_handle->offset = (ushort) adapter->slic_handle_ix++;
4219 pslic_handle->other_handle = NULL; 4087 pslic_handle->other_handle = NULL;
4220 pslic_handle->next = NULL; 4088 pslic_handle->next = NULL;
@@ -4230,7 +4098,7 @@ void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page)
4230 phys_addrl += SLIC_HOSTCMD_SIZE; 4098 phys_addrl += SLIC_HOSTCMD_SIZE;
4231 cmdaddr += SLIC_HOSTCMD_SIZE; 4099 cmdaddr += SLIC_HOSTCMD_SIZE;
4232 4100
4233 cmd = (p_slic_hostcmd_t) cmdaddr; 4101 cmd = (struct slic_hostcmd *)cmdaddr;
4234 cmdcnt++; 4102 cmdcnt++;
4235 } 4103 }
4236 4104
@@ -4240,36 +4108,37 @@ void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page)
4240 ASSERT(VALID_ADDRESS(prev)); 4108 ASSERT(VALID_ADDRESS(prev));
4241 cmdq->head = prev; 4109 cmdq->head = prev;
4242 cmdq = &adapter->cmdq_free; 4110 cmdq = &adapter->cmdq_free;
4243 SLIC_ACQUIRE_IRQ_SPINLOCK(cmdq->lock); 4111 spin_lock_irqsave(&cmdq->lock.lock, cmdq->lock.flags);
4244 cmdq->count += cmdcnt; /* SLIC_CMDQ_CMDSINPAGE; mooktodo */ 4112 cmdq->count += cmdcnt; /* SLIC_CMDQ_CMDSINPAGE; mooktodo */
4245 tail->next = cmdq->head; 4113 tail->next = cmdq->head;
4246 ASSERT(VALID_ADDRESS(prev)); 4114 ASSERT(VALID_ADDRESS(prev));
4247 cmdq->head = prev; 4115 cmdq->head = prev;
4248 SLIC_RELEASE_IRQ_SPINLOCK(cmdq->lock); 4116 spin_unlock_irqrestore(&cmdq->lock.lock, cmdq->lock.flags);
4249} 4117}
4250 4118
4251p_slic_hostcmd_t slic_cmdq_getfree(p_adapter_t adapter) 4119static struct slic_hostcmd *slic_cmdq_getfree(struct adapter *adapter)
4252{ 4120{
4253 p_slic_cmdqueue_t cmdq = &adapter->cmdq_free; 4121 struct slic_cmdqueue *cmdq = &adapter->cmdq_free;
4254 p_slic_hostcmd_t cmd = NULL; 4122 struct slic_hostcmd *cmd = NULL;
4255 4123
4256lock_and_retry: 4124lock_and_retry:
4257 SLIC_ACQUIRE_IRQ_SPINLOCK(cmdq->lock); 4125 spin_lock_irqsave(&cmdq->lock.lock, cmdq->lock.flags);
4258retry: 4126retry:
4259 cmd = cmdq->head; 4127 cmd = cmdq->head;
4260 if (cmd) { 4128 if (cmd) {
4261 cmdq->head = cmd->next; 4129 cmdq->head = cmd->next;
4262 cmdq->count--; 4130 cmdq->count--;
4263 SLIC_RELEASE_IRQ_SPINLOCK(cmdq->lock); 4131 spin_unlock_irqrestore(&cmdq->lock.lock, cmdq->lock.flags);
4264 } else { 4132 } else {
4265 slic_cmdq_getdone(adapter); 4133 slic_cmdq_getdone(adapter);
4266 cmd = cmdq->head; 4134 cmd = cmdq->head;
4267 if (cmd) { 4135 if (cmd) {
4268 goto retry; 4136 goto retry;
4269 } else { 4137 } else {
4270 pulong32 pageaddr; 4138 u32 *pageaddr;
4271 4139
4272 SLIC_RELEASE_IRQ_SPINLOCK(cmdq->lock); 4140 spin_unlock_irqrestore(&cmdq->lock.lock,
4141 cmdq->lock.flags);
4273 pageaddr = slic_cmdqmem_addpage(adapter); 4142 pageaddr = slic_cmdqmem_addpage(adapter);
4274 if (pageaddr) { 4143 if (pageaddr) {
4275 slic_cmdq_addcmdpage(adapter, pageaddr); 4144 slic_cmdq_addcmdpage(adapter, pageaddr);
@@ -4280,13 +4149,13 @@ retry:
4280 return cmd; 4149 return cmd;
4281} 4150}
4282 4151
4283void slic_cmdq_getdone(p_adapter_t adapter) 4152static void slic_cmdq_getdone(struct adapter *adapter)
4284{ 4153{
4285 p_slic_cmdqueue_t done_cmdq = &adapter->cmdq_done; 4154 struct slic_cmdqueue *done_cmdq = &adapter->cmdq_done;
4286 p_slic_cmdqueue_t free_cmdq = &adapter->cmdq_free; 4155 struct slic_cmdqueue *free_cmdq = &adapter->cmdq_free;
4287 4156
4288 ASSERT(free_cmdq->head == NULL); 4157 ASSERT(free_cmdq->head == NULL);
4289 SLIC_ACQUIRE_IRQ_SPINLOCK(done_cmdq->lock); 4158 spin_lock_irqsave(&done_cmdq->lock.lock, done_cmdq->lock.flags);
4290 ASSERT(VALID_ADDRESS(done_cmdq->head)); 4159 ASSERT(VALID_ADDRESS(done_cmdq->head));
4291 4160
4292 free_cmdq->head = done_cmdq->head; 4161 free_cmdq->head = done_cmdq->head;
@@ -4294,28 +4163,15 @@ void slic_cmdq_getdone(p_adapter_t adapter)
4294 done_cmdq->head = NULL; 4163 done_cmdq->head = NULL;
4295 done_cmdq->tail = NULL; 4164 done_cmdq->tail = NULL;
4296 done_cmdq->count = 0; 4165 done_cmdq->count = 0;
4297 SLIC_RELEASE_IRQ_SPINLOCK(done_cmdq->lock); 4166 spin_unlock_irqrestore(&done_cmdq->lock.lock, done_cmdq->lock.flags);
4298} 4167}
4299 4168
4300void slic_cmdq_putdone(p_adapter_t adapter, p_slic_hostcmd_t cmd) 4169static void slic_cmdq_putdone_irq(struct adapter *adapter,
4170 struct slic_hostcmd *cmd)
4301{ 4171{
4302 p_slic_cmdqueue_t cmdq = &adapter->cmdq_done; 4172 struct slic_cmdqueue *cmdq = &adapter->cmdq_done;
4303 4173
4304 SLIC_ACQUIRE_IRQ_SPINLOCK(cmdq->lock); 4174 spin_lock(&cmdq->lock.lock);
4305 cmd->busy = 0;
4306 ASSERT(VALID_ADDRESS(cmdq->head));
4307 cmd->next = cmdq->head;
4308 ASSERT(VALID_ADDRESS(cmd));
4309 cmdq->head = cmd;
4310 cmdq->count++;
4311 SLIC_RELEASE_IRQ_SPINLOCK(cmdq->lock);
4312}
4313
4314void slic_cmdq_putdone_irq(p_adapter_t adapter, p_slic_hostcmd_t cmd)
4315{
4316 p_slic_cmdqueue_t cmdq = &adapter->cmdq_done;
4317
4318 SLIC_ACQUIRE_SPINLOCK(cmdq->lock);
4319 cmd->busy = 0; 4175 cmd->busy = 0;
4320 ASSERT(VALID_ADDRESS(cmdq->head)); 4176 ASSERT(VALID_ADDRESS(cmdq->head));
4321 cmd->next = cmdq->head; 4177 cmd->next = cmdq->head;
@@ -4324,13 +4180,13 @@ void slic_cmdq_putdone_irq(p_adapter_t adapter, p_slic_hostcmd_t cmd)
4324 cmdq->count++; 4180 cmdq->count++;
4325 if ((adapter->xmitq_full) && (cmdq->count > 10)) 4181 if ((adapter->xmitq_full) && (cmdq->count > 10))
4326 netif_wake_queue(adapter->netdev); 4182 netif_wake_queue(adapter->netdev);
4327 SLIC_RELEASE_SPINLOCK(cmdq->lock); 4183 spin_unlock(&cmdq->lock.lock);
4328} 4184}
4329 4185
4330int slic_rcvqueue_init(p_adapter_t adapter) 4186static int slic_rcvqueue_init(struct adapter *adapter)
4331{ 4187{
4332 int i, count; 4188 int i, count;
4333 p_slic_rcvqueue_t rcvq = &adapter->rcvqueue; 4189 struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
4334 4190
4335 DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter); 4191 DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter);
4336 ASSERT(adapter->state == ADAPT_DOWN); 4192 ASSERT(adapter->state == ADAPT_DOWN);
@@ -4353,9 +4209,9 @@ int slic_rcvqueue_init(p_adapter_t adapter)
4353 return STATUS_SUCCESS; 4209 return STATUS_SUCCESS;
4354} 4210}
4355 4211
4356int slic_rcvqueue_reset(p_adapter_t adapter) 4212static int slic_rcvqueue_reset(struct adapter *adapter)
4357{ 4213{
4358 p_slic_rcvqueue_t rcvq = &adapter->rcvqueue; 4214 struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
4359 4215
4360 DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter); 4216 DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter);
4361 ASSERT(adapter->state == ADAPT_DOWN); 4217 ASSERT(adapter->state == ADAPT_DOWN);
@@ -4371,9 +4227,9 @@ int slic_rcvqueue_reset(p_adapter_t adapter)
4371 return STATUS_SUCCESS; 4227 return STATUS_SUCCESS;
4372} 4228}
4373 4229
4374void slic_rcvqueue_free(p_adapter_t adapter) 4230static void slic_rcvqueue_free(struct adapter *adapter)
4375{ 4231{
4376 slic_rcvqueue_t *rcvq = &adapter->rcvqueue; 4232 struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
4377 struct sk_buff *skb; 4233 struct sk_buff *skb;
4378 4234
4379 while (rcvq->head) { 4235 while (rcvq->head) {
@@ -4386,16 +4242,16 @@ void slic_rcvqueue_free(p_adapter_t adapter)
4386 rcvq->count = 0; 4242 rcvq->count = 0;
4387} 4243}
4388 4244
4389struct sk_buff *slic_rcvqueue_getnext(p_adapter_t adapter) 4245static struct sk_buff *slic_rcvqueue_getnext(struct adapter *adapter)
4390{ 4246{
4391 p_slic_rcvqueue_t rcvq = &adapter->rcvqueue; 4247 struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
4392 struct sk_buff *skb; 4248 struct sk_buff *skb;
4393 p_slic_rcvbuf_t rcvbuf; 4249 struct slic_rcvbuf *rcvbuf;
4394 int count; 4250 int count;
4395 4251
4396 if (rcvq->count) { 4252 if (rcvq->count) {
4397 skb = rcvq->head; 4253 skb = rcvq->head;
4398 rcvbuf = (p_slic_rcvbuf_t) skb->head; 4254 rcvbuf = (struct slic_rcvbuf *)skb->head;
4399 ASSERT(rcvbuf); 4255 ASSERT(rcvbuf);
4400 4256
4401 if (rcvbuf->status & IRHDDR_SVALID) { 4257 if (rcvbuf->status & IRHDDR_SVALID) {
@@ -4420,30 +4276,31 @@ struct sk_buff *slic_rcvqueue_getnext(p_adapter_t adapter)
4420 return skb; 4276 return skb;
4421} 4277}
4422 4278
4423int slic_rcvqueue_fill(p_adapter_t adapter) 4279static int slic_rcvqueue_fill(struct adapter *adapter)
4424{ 4280{
4425 pvoid paddr; 4281 void *paddr;
4426 ulong32 paddrl; 4282 u32 paddrl;
4427 ulong32 paddrh; 4283 u32 paddrh;
4428 p_slic_rcvqueue_t rcvq = &adapter->rcvqueue; 4284 struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
4429 int i = 0; 4285 int i = 0;
4430 4286
4431 while (i < SLIC_RCVQ_FILLENTRIES) { 4287 while (i < SLIC_RCVQ_FILLENTRIES) {
4432 p_slic_rcvbuf_t rcvbuf; 4288 struct slic_rcvbuf *rcvbuf;
4433 struct sk_buff *skb; 4289 struct sk_buff *skb;
4434#ifdef KLUDGE_FOR_4GB_BOUNDARY 4290#ifdef KLUDGE_FOR_4GB_BOUNDARY
4435retry_rcvqfill: 4291retry_rcvqfill:
4436#endif 4292#endif
4437 skb = alloc_skb(SLIC_RCVQ_RCVBUFSIZE, GFP_ATOMIC); 4293 skb = alloc_skb(SLIC_RCVQ_RCVBUFSIZE, GFP_ATOMIC);
4438 if (skb) { 4294 if (skb) {
4439 paddr = (void *)SLIC_GET_DMA_ADDRESS_READ(adapter, 4295 paddr = (void *)pci_map_single(adapter->pcidev,
4440 skb->data, 4296 skb->data,
4441 SLIC_RCVQ_RCVBUFSIZE); 4297 SLIC_RCVQ_RCVBUFSIZE,
4298 PCI_DMA_FROMDEVICE);
4442 paddrl = SLIC_GET_ADDR_LOW(paddr); 4299 paddrl = SLIC_GET_ADDR_LOW(paddr);
4443 paddrh = SLIC_GET_ADDR_HIGH(paddr); 4300 paddrh = SLIC_GET_ADDR_HIGH(paddr);
4444 4301
4445 skb->len = SLIC_RCVBUF_HEADSIZE; 4302 skb->len = SLIC_RCVBUF_HEADSIZE;
4446 rcvbuf = (p_slic_rcvbuf_t) skb->head; 4303 rcvbuf = (struct slic_rcvbuf *)skb->head;
4447 rcvbuf->status = 0; 4304 rcvbuf->status = 0;
4448 skb->next = NULL; 4305 skb->next = NULL;
4449#ifdef KLUDGE_FOR_4GB_BOUNDARY 4306#ifdef KLUDGE_FOR_4GB_BOUNDARY
@@ -4479,13 +4336,13 @@ retry_rcvqfill:
4479#endif 4336#endif
4480 if (paddrh == 0) { 4337 if (paddrh == 0) {
4481 WRITE_REG(adapter->slic_regs->slic_hbar, 4338 WRITE_REG(adapter->slic_regs->slic_hbar,
4482 (ulong32) paddrl, DONT_FLUSH); 4339 (u32) paddrl, DONT_FLUSH);
4483 } else { 4340 } else {
4484 WRITE_REG64(adapter, 4341 WRITE_REG64(adapter,
4485 adapter->slic_regs->slic_hbar64, 4342 adapter->slic_regs->slic_hbar64,
4486 (ulong32) paddrl, 4343 (u32) paddrl,
4487 adapter->slic_regs->slic_addr_upper, 4344 adapter->slic_regs->slic_addr_upper,
4488 (ulong32) paddrh, DONT_FLUSH); 4345 (u32) paddrh, DONT_FLUSH);
4489 } 4346 }
4490 if (rcvq->head) 4347 if (rcvq->head)
4491 rcvq->tail->next = skb; 4348 rcvq->tail->next = skb;
@@ -4505,18 +4362,18 @@ retry_rcvqfill:
4505 return i; 4362 return i;
4506} 4363}
4507 4364
4508ulong32 slic_rcvqueue_reinsert(p_adapter_t adapter, struct sk_buff *skb) 4365static u32 slic_rcvqueue_reinsert(struct adapter *adapter, struct sk_buff *skb)
4509{ 4366{
4510 p_slic_rcvqueue_t rcvq = &adapter->rcvqueue; 4367 struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
4511 pvoid paddr; 4368 void *paddr;
4512 ulong32 paddrl; 4369 u32 paddrl;
4513 ulong32 paddrh; 4370 u32 paddrh;
4514 p_slic_rcvbuf_t rcvbuf = (p_slic_rcvbuf_t) skb->head; 4371 struct slic_rcvbuf *rcvbuf = (struct slic_rcvbuf *)skb->head;
4515 4372
4516 ASSERT(skb->len == SLIC_RCVBUF_HEADSIZE); 4373 ASSERT(skb->len == SLIC_RCVBUF_HEADSIZE);
4517 paddr = (void *)SLIC_GET_DMA_ADDRESS_READ(adapter, 4374
4518 skb->head, 4375 paddr = (void *)pci_map_single(adapter->pcidev, skb->head,
4519 SLIC_RCVQ_RCVBUFSIZE); 4376 SLIC_RCVQ_RCVBUFSIZE, PCI_DMA_FROMDEVICE);
4520 rcvbuf->status = 0; 4377 rcvbuf->status = 0;
4521 skb->next = NULL; 4378 skb->next = NULL;
4522 4379
@@ -4536,7 +4393,7 @@ ulong32 slic_rcvqueue_reinsert(p_adapter_t adapter, struct sk_buff *skb)
4536 rcvq->count); 4393 rcvq->count);
4537 } 4394 }
4538 if (paddrh == 0) { 4395 if (paddrh == 0) {
4539 WRITE_REG(adapter->slic_regs->slic_hbar, (ulong32) paddrl, 4396 WRITE_REG(adapter->slic_regs->slic_hbar, (u32) paddrl,
4540 DONT_FLUSH); 4397 DONT_FLUSH);
4541 } else { 4398 } else {
4542 WRITE_REG64(adapter, 4399 WRITE_REG64(adapter,
@@ -4558,10 +4415,10 @@ static int slic_debug_card_show(struct seq_file *seq, void *v)
4558{ 4415{
4559#ifdef MOOKTODO 4416#ifdef MOOKTODO
4560 int i; 4417 int i;
4561 p_sliccard_t card = seq->private; 4418 struct sliccard *card = seq->private;
4562 pslic_config_t config = &card->config; 4419 pslic_config_t config = &card->config;
4563 puchar fru = (puchar) (&card->config.atk_fru); 4420 unsigned char *fru = (unsigned char *)(&card->config.atk_fru);
4564 puchar oemfru = (puchar) (&card->config.OemFru); 4421 unsigned char *oemfru = (unsigned char *)(&card->config.OemFru);
4565#endif 4422#endif
4566 4423
4567 seq_printf(seq, "driver_version : %s", slic_proc_version); 4424 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)
4600 seq_printf(seq, " IF Init State Duplex/Speed irq\n"); 4457 seq_printf(seq, " IF Init State Duplex/Speed irq\n");
4601 seq_printf(seq, " -------------------------------\n"); 4458 seq_printf(seq, " -------------------------------\n");
4602 for (i = 0; i < card->adapters_allocated; i++) { 4459 for (i = 0; i < card->adapters_allocated; i++) {
4603 p_adapter_t adapter; 4460 struct adapter *adapter;
4604 4461
4605 adapter = card->adapter[i]; 4462 adapter = card->adapter[i];
4606 if (adapter) { 4463 if (adapter) {
@@ -4768,7 +4625,7 @@ static int slic_debug_card_show(struct seq_file *seq, void *v)
4768 4625
4769static int slic_debug_adapter_show(struct seq_file *seq, void *v) 4626static int slic_debug_adapter_show(struct seq_file *seq, void *v)
4770{ 4627{
4771 p_adapter_t adapter = seq->private; 4628 struct adapter *adapter = seq->private;
4772 4629
4773 if ((adapter->netdev) && (adapter->netdev->name)) { 4630 if ((adapter->netdev) && (adapter->netdev->name)) {
4774 seq_printf(seq, "info: interface : %s\n", 4631 seq_printf(seq, "info: interface : %s\n",
@@ -4801,21 +4658,21 @@ static int slic_debug_adapter_show(struct seq_file *seq, void *v)
4801 seq_printf(seq, "rx stats: unicasts : %8.8X\n", 4658 seq_printf(seq, "rx stats: unicasts : %8.8X\n",
4802 adapter->rcv_unicasts); 4659 adapter->rcv_unicasts);
4803 seq_printf(seq, "rx stats: errors : %8.8X\n", 4660 seq_printf(seq, "rx stats: errors : %8.8X\n",
4804 (ulong32) adapter->slic_stats.iface.rcv_errors); 4661 (u32) adapter->slic_stats.iface.rcv_errors);
4805 seq_printf(seq, "rx stats: Missed errors : %8.8X\n", 4662 seq_printf(seq, "rx stats: Missed errors : %8.8X\n",
4806 (ulong32) adapter->slic_stats.iface.rcv_discards); 4663 (u32) adapter->slic_stats.iface.rcv_discards);
4807 seq_printf(seq, "rx stats: drops : %8.8X\n", 4664 seq_printf(seq, "rx stats: drops : %8.8X\n",
4808 (ulong32) adapter->rcv_drops); 4665 (u32) adapter->rcv_drops);
4809 seq_printf(seq, "tx stats: packets : %8.8lX\n", 4666 seq_printf(seq, "tx stats: packets : %8.8lX\n",
4810 adapter->stats.tx_packets); 4667 adapter->stats.tx_packets);
4811 seq_printf(seq, "tx stats: bytes : %8.8lX\n", 4668 seq_printf(seq, "tx stats: bytes : %8.8lX\n",
4812 adapter->stats.tx_bytes); 4669 adapter->stats.tx_bytes);
4813 seq_printf(seq, "tx stats: errors : %8.8X\n", 4670 seq_printf(seq, "tx stats: errors : %8.8X\n",
4814 (ulong32) adapter->slic_stats.iface.xmt_errors); 4671 (u32) adapter->slic_stats.iface.xmt_errors);
4815 seq_printf(seq, "rx stats: multicasts : %8.8lX\n", 4672 seq_printf(seq, "rx stats: multicasts : %8.8lX\n",
4816 adapter->stats.multicast); 4673 adapter->stats.multicast);
4817 seq_printf(seq, "tx stats: collision errors : %8.8X\n", 4674 seq_printf(seq, "tx stats: collision errors : %8.8X\n",
4818 (ulong32) adapter->slic_stats.iface.xmit_collisions); 4675 (u32) adapter->slic_stats.iface.xmit_collisions);
4819 seq_printf(seq, "perf: Max rcv frames/isr : %8.8X\n", 4676 seq_printf(seq, "perf: Max rcv frames/isr : %8.8X\n",
4820 adapter->max_isr_rcvs); 4677 adapter->max_isr_rcvs);
4821 seq_printf(seq, "perf: Rcv interrupt yields : %8.8X\n", 4678 seq_printf(seq, "perf: Rcv interrupt yields : %8.8X\n",
@@ -4905,11 +4762,11 @@ static const struct file_operations slic_debug_card_fops = {
4905 .release = single_release, 4762 .release = single_release,
4906}; 4763};
4907 4764
4908static void slic_debug_adapter_create(p_adapter_t adapter) 4765static void slic_debug_adapter_create(struct adapter *adapter)
4909{ 4766{
4910 struct dentry *d; 4767 struct dentry *d;
4911 char name[7]; 4768 char name[7];
4912 p_sliccard_t card = adapter->card; 4769 struct sliccard *card = adapter->card;
4913 4770
4914 if (!card->debugfs_dir) 4771 if (!card->debugfs_dir)
4915 return; 4772 return;
@@ -4924,7 +4781,7 @@ static void slic_debug_adapter_create(p_adapter_t adapter)
4924 adapter->debugfs_entry = d; 4781 adapter->debugfs_entry = d;
4925} 4782}
4926 4783
4927static void slic_debug_adapter_destroy(p_adapter_t adapter) 4784static void slic_debug_adapter_destroy(struct adapter *adapter)
4928{ 4785{
4929 if (adapter->debugfs_entry) { 4786 if (adapter->debugfs_entry) {
4930 debugfs_remove(adapter->debugfs_entry); 4787 debugfs_remove(adapter->debugfs_entry);
@@ -4932,7 +4789,7 @@ static void slic_debug_adapter_destroy(p_adapter_t adapter)
4932 } 4789 }
4933} 4790}
4934 4791
4935static void slic_debug_card_create(p_sliccard_t card) 4792static void slic_debug_card_create(struct sliccard *card)
4936{ 4793{
4937 struct dentry *d; 4794 struct dentry *d;
4938 char name[IFNAMSIZ]; 4795 char name[IFNAMSIZ];
@@ -4955,12 +4812,12 @@ static void slic_debug_card_create(p_sliccard_t card)
4955 } 4812 }
4956} 4813}
4957 4814
4958static void slic_debug_card_destroy(p_sliccard_t card) 4815static void slic_debug_card_destroy(struct sliccard *card)
4959{ 4816{
4960 int i; 4817 int i;
4961 4818
4962 for (i = 0; i < card->card_size; i++) { 4819 for (i = 0; i < card->card_size; i++) {
4963 p_adapter_t adapter; 4820 struct adapter *adapter;
4964 4821
4965 adapter = card->adapter[i]; 4822 adapter = card->adapter[i];
4966 if (adapter) 4823 if (adapter)
@@ -5013,17 +4870,17 @@ static void slic_debug_cleanup(void)
5013 4870
5014#include <stdarg.h> 4871#include <stdarg.h>
5015 4872
5016pvoid slic_dump_handle; /* thread handle */ 4873void *slic_dump_handle; /* thread handle */
5017 4874
5018/* 4875/*
5019 * These are the only things you should do on a core-file: use only these 4876 * These are the only things you should do on a core-file: use only these
5020 * functions to write out all the necessary info. 4877 * functions to write out all the necessary info.
5021 */ 4878 */
5022static int slic_dump_seek(struct file *SLIChandle, ulong32 file_offset) 4879static int slic_dump_seek(struct file *SLIChandle, u32 file_offset)
5023{ 4880{
5024 if (SLIChandle->f_pos != file_offset) { 4881 if (SLIChandle->f_pos != file_offset) {
5025 /*DBG_MSG("slic_dump_seek now needed [%x : %x]\n", 4882 /*DBG_MSG("slic_dump_seek now needed [%x : %x]\n",
5026 (ulong32)SLIChandle->f_pos, (ulong32)file_offset); */ 4883 (u32)SLIChandle->f_pos, (u32)file_offset); */
5027 if (SLIChandle->f_op->llseek) { 4884 if (SLIChandle->f_op->llseek) {
5028 if (SLIChandle->f_op-> 4885 if (SLIChandle->f_op->
5029 llseek(SLIChandle, file_offset, 0) != file_offset) 4886 llseek(SLIChandle, file_offset, 0) != file_offset)
@@ -5035,11 +4892,11 @@ static int slic_dump_seek(struct file *SLIChandle, ulong32 file_offset)
5035 return 1; 4892 return 1;
5036} 4893}
5037 4894
5038static int slic_dump_write(p_sliccard_t card, 4895static int slic_dump_write(struct sliccard *card,
5039 const void *addr, int size, ulong32 file_offset) 4896 const void *addr, int size, u32 file_offset)
5040{ 4897{
5041 int r = 1; 4898 int r = 1;
5042 ulong32 result = 0; 4899 u32 result = 0;
5043 struct file *SLIChandle = card->dumphandle; 4900 struct file *SLIChandle = card->dumphandle;
5044 4901
5045#ifdef HISTORICAL /* legacy */ 4902#ifdef HISTORICAL /* legacy */
@@ -5069,7 +4926,7 @@ static int slic_dump_write(p_sliccard_t card,
5069 return r; 4926 return r;
5070} 4927}
5071 4928
5072uint slic_init_dump_thread(p_sliccard_t card) 4929static uint slic_init_dump_thread(struct sliccard *card)
5073{ 4930{
5074 card->dump_task_id = kthread_run(slic_dump_thread, (void *)card, 0); 4931 card->dump_task_id = kthread_run(slic_dump_thread, (void *)card, 0);
5075 4932
@@ -5082,17 +4939,17 @@ uint slic_init_dump_thread(p_sliccard_t card)
5082 return STATUS_SUCCESS; 4939 return STATUS_SUCCESS;
5083} 4940}
5084 4941
5085int slic_dump_thread(void *context) 4942static int slic_dump_thread(void *context)
5086{ 4943{
5087 p_sliccard_t card = (p_sliccard_t) context; 4944 struct sliccard *card = (struct sliccard *)context;
5088 p_adapter_t adapter; 4945 struct adapter *adapter;
5089 p_adapter_t dump_adapter = NULL; 4946 struct adapter *dump_adapter = NULL;
5090 ulong32 dump_complete = 0; 4947 u32 dump_complete = 0;
5091 ulong32 delay = SLIC_SECS_TO_JIFFS(PING_TIMER_INTERVAL); 4948 u32 delay = SLIC_SECS_TO_JIFFS(PING_TIMER_INTERVAL);
5092 p_slic_regs_t pregs; 4949 struct slic_regs *pregs;
5093 ulong32 i; 4950 u32 i;
5094 p_slic_upr_t upr, uprnext; 4951 struct slic_upr *upr, *uprnext;
5095 ulong32 dump_card; 4952 u32 dump_card;
5096 4953
5097 ASSERT(card); 4954 ASSERT(card);
5098 4955
@@ -5248,19 +5105,20 @@ int slic_dump_thread(void *context)
5248 * now. 5105 * now.
5249 */ 5106 */
5250 if (!card->pingstatus) { 5107 if (!card->pingstatus) {
5251 SLIC_ACQUIRE_IRQ_SPINLOCK 5108 spin_lock_irqsave(
5252 (adapter->upr_lock); 5109 &adapter->upr_lock.lock,
5110 adapter->upr_lock.flags);
5253 upr = adapter->upr_list; 5111 upr = adapter->upr_list;
5254 while (upr) { 5112 while (upr) {
5255 uprnext = upr->next; 5113 uprnext = upr->next;
5256 SLIC_DEALLOCATE_MEM 5114 kfree(upr);
5257 (upr);
5258 upr = uprnext; 5115 upr = uprnext;
5259 } 5116 }
5260 adapter->upr_list = 0; 5117 adapter->upr_list = 0;
5261 adapter->upr_busy = 0; 5118 adapter->upr_busy = 0;
5262 SLIC_RELEASE_IRQ_SPINLOCK 5119 spin_unlock_irqrestore(
5263 (adapter->upr_lock); 5120 &adapter->upr_lock.lock,
5121 adapter->upr_lock.flags);
5264 } 5122 }
5265 5123
5266 slic_dump_card(card, FALSE); 5124 slic_dump_card(card, FALSE);
@@ -5340,13 +5198,13 @@ end_thread:
5340 * value is used as our suffix for our dump path. The 5198 * value is used as our suffix for our dump path. The
5341 * value is incremented and written back to the file 5199 * value is incremented and written back to the file
5342 */ 5200 */
5343uchar slic_get_dump_index(pchar path) 5201static unsigned char slic_get_dump_index(char *path)
5344{ 5202{
5345 uchar index = 0; 5203 unsigned char index = 0;
5346#ifdef SLIC_DUMP_INDEX_SUPPORT 5204#ifdef SLIC_DUMP_INDEX_SUPPORT
5347 ulong32 status; 5205 u32 status;
5348 pvoid FileHandle; 5206 void *FileHandle;
5349 ulong32 offset; 5207 u32 offset;
5350 5208
5351 offset = 0; 5209 offset = 0;
5352 5210
@@ -5356,7 +5214,7 @@ uchar slic_get_dump_index(pchar path)
5356 status = create_file(&FileHandle); 5214 status = create_file(&FileHandle);
5357 5215
5358 if (status != STATUS_SUCCESS) 5216 if (status != STATUS_SUCCESS)
5359 return (uchar) 0; 5217 return (unsigned char) 0;
5360 5218
5361 status = read_file(FileHandle, &index, 1, &offset); 5219 status = read_file(FileHandle, &index, 1, &offset);
5362 5220
@@ -5371,7 +5229,7 @@ uchar slic_get_dump_index(pchar path)
5371 return index; 5229 return index;
5372} 5230}
5373 5231
5374struct file *slic_dump_open_file(p_sliccard_t card) 5232static struct file *slic_dump_open_file(struct sliccard *card)
5375{ 5233{
5376 struct file *SLIChandle = NULL; 5234 struct file *SLIChandle = NULL;
5377 struct dentry *dentry = NULL; 5235 struct dentry *dentry = NULL;
@@ -5434,7 +5292,7 @@ end_slicdump:
5434 return NULL; 5292 return NULL;
5435} 5293}
5436 5294
5437void slic_dump_close_file(p_sliccard_t card) 5295static void slic_dump_close_file(struct sliccard *card)
5438{ 5296{
5439 5297
5440/* DBG_MSG("[slicmon] slic_dump_CLOSE_file close SLIChandle[%p]\n", 5298/* DBG_MSG("[slicmon] slic_dump_CLOSE_file close SLIChandle[%p]\n",
@@ -5445,19 +5303,19 @@ void slic_dump_close_file(p_sliccard_t card)
5445 set_fs(card->dumpfile_fs); 5303 set_fs(card->dumpfile_fs);
5446} 5304}
5447 5305
5448ulong32 slic_dump_card(p_sliccard_t card, boolean resume) 5306static u32 slic_dump_card(struct sliccard *card, bool resume)
5449{ 5307{
5450 p_adapter_t adapter = card->master; 5308 struct adapter *adapter = card->master;
5451 ulong32 status; 5309 u32 status;
5452 ulong32 queue; 5310 u32 queue;
5453 ulong32 len, offset; 5311 u32 len, offset;
5454 ulong32 sram_size, dram_size, regs; 5312 u32 sram_size, dram_size, regs;
5455 sliccore_hdr_t corehdr; 5313 sliccore_hdr_t corehdr;
5456 ulong32 file_offset; 5314 u32 file_offset;
5457 pchar namestr; 5315 char *namestr;
5458 ulong32 i; 5316 u32 i;
5459 ulong32 max_queues = 0; 5317 u32 max_queues = 0;
5460 ulong32 result; 5318 u32 result;
5461 5319
5462 card->dumphandle = slic_dump_open_file(card); 5320 card->dumphandle = slic_dump_open_file(card);
5463 5321
@@ -5672,12 +5530,12 @@ ulong32 slic_dump_card(p_sliccard_t card, boolean resume)
5672 max_queues = SLIC_MAX_QUEUE; 5530 max_queues = SLIC_MAX_QUEUE;
5673 5531
5674 for (queue = 0; queue < max_queues; queue++) { 5532 for (queue = 0; queue < max_queues; queue++) {
5675 pulong32 qarray = (pulong32) card->dumpbuffer; 5533 u32 *qarray = (u32 *) card->dumpbuffer;
5676 ulong32 qarray_physl = card->dumpbuffer_physl; 5534 u32 qarray_physl = card->dumpbuffer_physl;
5677 ulong32 qarray_physh = card->dumpbuffer_physh; 5535 u32 qarray_physh = card->dumpbuffer_physh;
5678 ulong32 qstart; 5536 u32 qstart;
5679 ulong32 qdelta; 5537 u32 qdelta;
5680 ulong32 qtotal = 0; 5538 u32 qtotal = 0;
5681 5539
5682 DBG_MSG("[slicmon] Start Dump of QUEUE #0x%x\n", (uint) queue); 5540 DBG_MSG("[slicmon] Start Dump of QUEUE #0x%x\n", (uint) queue);
5683 5541
@@ -5823,9 +5681,9 @@ done:
5823 return status; 5681 return status;
5824} 5682}
5825 5683
5826ulong32 slic_dump_halt(p_sliccard_t card, uchar proc) 5684static u32 slic_dump_halt(struct sliccard *card, unsigned char proc)
5827{ 5685{
5828 puchar cmd = card->cmdbuffer; 5686 unsigned char *cmd = card->cmdbuffer;
5829 5687
5830 *cmd = COMMAND_BYTE(CMD_HALT, 0, proc); 5688 *cmd = COMMAND_BYTE(CMD_HALT, 0, proc);
5831 5689
@@ -5834,9 +5692,9 @@ ulong32 slic_dump_halt(p_sliccard_t card, uchar proc)
5834 card->cmdbuffer_physh, 0, 0); 5692 card->cmdbuffer_physh, 0, 0);
5835} 5693}
5836 5694
5837ulong32 slic_dump_resume(p_sliccard_t card, uchar proc) 5695static u32 slic_dump_resume(struct sliccard *card, unsigned char proc)
5838{ 5696{
5839 puchar cmd = card->cmdbuffer; 5697 unsigned char *cmd = card->cmdbuffer;
5840 5698
5841 *cmd = COMMAND_BYTE(CMD_RUN, 0, proc); 5699 *cmd = COMMAND_BYTE(CMD_RUN, 0, proc);
5842 5700
@@ -5845,7 +5703,7 @@ ulong32 slic_dump_resume(p_sliccard_t card, uchar proc)
5845 card->cmdbuffer_physh, 0, 0); 5703 card->cmdbuffer_physh, 0, 0);
5846} 5704}
5847 5705
5848ulong32 slic_dump_reg(p_sliccard_t card, uchar proc) 5706static u32 slic_dump_reg(struct sliccard *card, unsigned char proc)
5849{ 5707{
5850 pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer; 5708 pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer;
5851 5709
@@ -5861,8 +5719,8 @@ ulong32 slic_dump_reg(p_sliccard_t card, uchar proc)
5861 card->dumpbuffer_physh); 5719 card->dumpbuffer_physh);
5862} 5720}
5863 5721
5864ulong32 slic_dump_data(p_sliccard_t card, 5722static u32 slic_dump_data(struct sliccard *card,
5865 ulong32 addr, ushort count, uchar desc) 5723 u32 addr, ushort count, unsigned char desc)
5866{ 5724{
5867 pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer; 5725 pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer;
5868 5726
@@ -5878,8 +5736,8 @@ ulong32 slic_dump_data(p_sliccard_t card,
5878 card->dumpbuffer_physh); 5736 card->dumpbuffer_physh);
5879} 5737}
5880 5738
5881ulong32 slic_dump_queue(p_sliccard_t card, 5739static u32 slic_dump_queue(struct sliccard *card,
5882 ulong32 addr, ulong32 buf_physh, ulong32 queue) 5740 u32 addr, u32 buf_physh, u32 queue)
5883{ 5741{
5884 pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer; 5742 pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer;
5885 5743
@@ -5894,7 +5752,8 @@ ulong32 slic_dump_queue(p_sliccard_t card,
5894 addr, card->dumpbuffer_physh); 5752 addr, card->dumpbuffer_physh);
5895} 5753}
5896 5754
5897ulong32 slic_dump_load_queue(p_sliccard_t card, ulong32 data, ulong32 queue) 5755static u32 slic_dump_load_queue(struct sliccard *card, u32 data,
5756 u32 queue)
5898{ 5757{
5899 pdump_cmd_t load = (pdump_cmd_t) card->cmdbuffer; 5758 pdump_cmd_t load = (pdump_cmd_t) card->cmdbuffer;
5900 5759
@@ -5908,8 +5767,8 @@ ulong32 slic_dump_load_queue(p_sliccard_t card, ulong32 data, ulong32 queue)
5908 card->cmdbuffer_physh, 0, 0); 5767 card->cmdbuffer_physh, 0, 0);
5909} 5768}
5910 5769
5911ulong32 slic_dump_cam(p_sliccard_t card, 5770static u32 slic_dump_cam(struct sliccard *card,
5912 ulong32 addr, ulong32 count, uchar desc) 5771 u32 addr, u32 count, unsigned char desc)
5913{ 5772{
5914 pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer; 5773 pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer;
5915 5774
@@ -5924,15 +5783,15 @@ ulong32 slic_dump_cam(p_sliccard_t card,
5924 addr, card->dumpbuffer_physh); 5783 addr, card->dumpbuffer_physh);
5925} 5784}
5926 5785
5927ulong32 slic_dump_send_cmd(p_sliccard_t card, 5786static u32 slic_dump_send_cmd(struct sliccard *card,
5928 ulong32 cmd_physl, 5787 u32 cmd_physl,
5929 ulong32 cmd_physh, 5788 u32 cmd_physh,
5930 ulong32 buf_physl, ulong32 buf_physh) 5789 u32 buf_physl, u32 buf_physh)
5931{ 5790{
5932 ulong timeout = SLIC_MS_TO_JIFFIES(500); /* 500 msec */ 5791 ulong timeout = SLIC_MS_TO_JIFFIES(500); /* 500 msec */
5933 ulong32 attempts = 5; 5792 u32 attempts = 5;
5934 ulong32 delay = SLIC_MS_TO_JIFFIES(10); /* 10 msec */ 5793 u32 delay = SLIC_MS_TO_JIFFIES(10); /* 10 msec */
5935 p_adapter_t adapter = card->master; 5794 struct adapter *adapter = card->master;
5936 5795
5937 ASSERT(adapter); 5796 ASSERT(adapter);
5938 do { 5797 do {
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-12 18:40:25 -0400