]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blob - src/patches/suse-2.6.27.25/patches.drivers/0019-Staging-SLICOSS-lots-of-checkpatch-fixes.patch
projects / people / pmueller / ipfire-2.x.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Disable build of xen kernel.
[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.25 / patches.drivers / 0019-Staging-SLICOSS-lots-of-checkpatch-fixes.patch
1 From e9eff9d6a0d14fa2e85953ce4115d243ff575e78 Mon Sep 17 00:00:00 2001
2 From: Lior Dotan <liodot@gmail.com>
3 Date: Sat, 4 Oct 2008 07:10:28 +0300
4 Subject: [PATCH 19/23] Staging: SLICOSS: lots of checkpatch fixes
5 Patch-mainline: 2.6.28
6
7 Major cleanups of checkpatch warnings from the slicoss driver.
8
9 From: Lior Dotan <liodot@gmail.com>
10 Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
11 ---
12 drivers/staging/slicoss/gbdownload.h | 10 +-
13 drivers/staging/slicoss/gbrcvucode.h | 7 +-
14 drivers/staging/slicoss/oasisdbgdownload.h | 10 +-
15 drivers/staging/slicoss/oasisdownload.h | 10 +-
16 drivers/staging/slicoss/oasisrcvucode.h | 6 +-
17 drivers/staging/slicoss/slic.h | 485 +++++-----
18 drivers/staging/slicoss/slic_os.h | 85 +--
19 drivers/staging/slicoss/slicbuild.h | 1 -
20 drivers/staging/slicoss/slicdbg.h | 3 +-
21 drivers/staging/slicoss/slicdump.h | 89 +-
22 drivers/staging/slicoss/slichw.h | 653 +++++++-------
23 drivers/staging/slicoss/slicinc.h | 262 +++---
24 drivers/staging/slicoss/slicoss.c | 1351 +++++++++++++---------------
25 13 files changed, 1353 insertions(+), 1619 deletions(-)
26
27 diff --git a/drivers/staging/slicoss/gbdownload.h b/drivers/staging/slicoss/gbdownload.h
28 index 0350fb9..794432b 100644
29 --- a/drivers/staging/slicoss/gbdownload.h
30 +++ b/drivers/staging/slicoss/gbdownload.h
31 @@ -1,14 +1,14 @@
32 -#define MOJAVE_UCODE_VERS_STRING "$Revision: 1.2 $"
33 -#define MOJAVE_UCODE_VERS_DATE "$Date: 2006/03/27 15:12:22 $"
34 +#define MOJAVE_UCODE_VERS_STRING "1.2"
35 +#define MOJAVE_UCODE_VERS_DATE "2006/03/27 15:12:22"
36 #define MOJAVE_UCODE_HOSTIF_ID 3
37
38 -static LONG MNumSections = 0x2;
39 -static ULONG MSectionSize[] =
40 +static s32 MNumSections = 0x2;
41 +static u32 MSectionSize[] =
42 {
43 0x00008000, 0x00010000,
44 };
45
46 -static ULONG MSectionStart[] =
47 +static u32 MSectionStart[] =
48 {
49 0x00000000, 0x00008000,
50 };
51 diff --git a/drivers/staging/slicoss/gbrcvucode.h b/drivers/staging/slicoss/gbrcvucode.h
52 index dc00834..4fa5a4c 100644
53 --- a/drivers/staging/slicoss/gbrcvucode.h
54 +++ b/drivers/staging/slicoss/gbrcvucode.h
55 @@ -1,7 +1,6 @@
56 /*
57 * Copyright (c) 1997-2002 Alacritech, Inc. All rights reserved
58 *
59 - * $Id: gbrcvucode.h,v 1.2 2006/03/27 15:12:15 mook Exp $
60 *
61 * Redistribution and use in source and binary forms, with or without
62 * modification, are permitted provided that the following conditions
63 @@ -32,10 +31,10 @@
64 * official policies, either expressed or implied, of Alacritech, Inc.
65 *
66 **************************************************************************/
67 -#define GB_RCVUCODE_VERS_STRING "$Revision: 1.2 $"
68 -#define GB_RCVUCODE_VERS_DATE "$Date: 2006/03/27 15:12:15 $"
69 +#define GB_RCVUCODE_VERS_STRING "1.2"
70 +#define GB_RCVUCODE_VERS_DATE "2006/03/27 15:12:15"
71
72 -static ULONG GBRcvUCodeLen = 512;
73 +static u32 GBRcvUCodeLen = 512;
74
75 static u8 GBRcvUCode[2560] =
76 {
77 diff --git a/drivers/staging/slicoss/oasisdbgdownload.h b/drivers/staging/slicoss/oasisdbgdownload.h
78 index cae5d55..519e007 100644
79 --- a/drivers/staging/slicoss/oasisdbgdownload.h
80 +++ b/drivers/staging/slicoss/oasisdbgdownload.h
81 @@ -1,14 +1,14 @@
82 -#define OASIS_UCODE_VERS_STRING "$Revision: 1.2 $"
83 -#define OASIS_UCODE_VERS_DATE "$Date: 2006/03/27 15:11:22 $"
84 +#define OASIS_UCODE_VERS_STRING "1.2"
85 +#define OASIS_UCODE_VERS_DATE "2006/03/27 15:11:22"
86 #define OASIS_UCODE_HOSTIF_ID 3
87
88 -static LONG ONumSections = 0x2;
89 -static ULONG OSectionSize[] =
90 +static s32 ONumSections = 0x2;
91 +static u32 OSectionSize[] =
92 {
93 0x00004000, 0x00010000,
94 };
95
96 -static ULONG OSectionStart[] =
97 +static u32 OSectionStart[] =
98 {
99 0x00000000, 0x00008000,
100 };
101 diff --git a/drivers/staging/slicoss/oasisdownload.h b/drivers/staging/slicoss/oasisdownload.h
102 index 89a440c..6438c23 100644
103 --- a/drivers/staging/slicoss/oasisdownload.h
104 +++ b/drivers/staging/slicoss/oasisdownload.h
105 @@ -1,13 +1,13 @@
106 -#define OASIS_UCODE_VERS_STRING "$Revision: 1.2 $"
107 -#define OASIS_UCODE_VERS_DATE "$Date: 2006/03/27 15:10:37 $"
108 +#define OASIS_UCODE_VERS_STRING "1.2"
109 +#define OASIS_UCODE_VERS_DATE "2006/03/27 15:10:37"
110 #define OASIS_UCODE_HOSTIF_ID 3
111
112 -static LONG ONumSections = 0x2;
113 -static ULONG OSectionSize[] = {
114 +static s32 ONumSections = 0x2;
115 +static u32 OSectionSize[] = {
116 0x00004000, 0x00010000,
117 };
118
119 -static ULONG OSectionStart[] = {
120 +static u32 OSectionStart[] = {
121 0x00000000, 0x00008000,
122 };
123
124 diff --git a/drivers/staging/slicoss/oasisrcvucode.h b/drivers/staging/slicoss/oasisrcvucode.h
125 index ef91632..5b3531f 100644
126 --- a/drivers/staging/slicoss/oasisrcvucode.h
127 +++ b/drivers/staging/slicoss/oasisrcvucode.h
128 @@ -1,7 +1,7 @@
129 -#define OASIS_RCVUCODE_VERS_STRING "$Revision: 1.2 $"
130 -#define OASIS_RCVUCODE_VERS_DATE "$Date: 2006/03/27 15:10:28 $"
131 +#define OASIS_RCVUCODE_VERS_STRING "1.2"
132 +#define OASIS_RCVUCODE_VERS_DATE "2006/03/27 15:10:28"
133
134 -static ULONG OasisRcvUCodeLen = 512;
135 +static u32 OasisRcvUCodeLen = 512;
136
137 static u8 OasisRcvUCode[2560] =
138 {
139 diff --git a/drivers/staging/slicoss/slic.h b/drivers/staging/slicoss/slic.h
140 index 9707e5a..0d5dc24 100644
141 --- a/drivers/staging/slicoss/slic.h
142 +++ b/drivers/staging/slicoss/slic.h
143 @@ -2,7 +2,6 @@
144 *
145 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved.
146 *
147 - * $Id: slic.h,v 1.3 2006/07/14 16:43:02 mook Exp $
148 *
149 * Redistribution and use in source and binary forms, with or without
150 * modification, are permitted provided that the following conditions
151 @@ -51,14 +50,14 @@ struct slic_spinlock {
152 #define SLIC_RSPQ_PAGES_GB 10
153 #define SLIC_RSPQ_BUFSINPAGE (PAGE_SIZE / SLIC_RSPBUF_SIZE)
154
155 -typedef struct _slic_rspqueue_t {
156 - ulong32 offset;
157 - ulong32 pageindex;
158 - ulong32 num_pages;
159 - p_slic_rspbuf_t rspbuf;
160 - pulong32 vaddr[SLIC_RSPQ_PAGES_GB];
161 +struct slic_rspqueue {
162 + u32 offset;
163 + u32 pageindex;
164 + u32 num_pages;
165 + struct slic_rspbuf *rspbuf;
166 + u32 *vaddr[SLIC_RSPQ_PAGES_GB];
167 dma_addr_t paddr[SLIC_RSPQ_PAGES_GB];
168 -} slic_rspqueue_t, *p_slic_rspqueue_t;
169 +};
170
171 #define SLIC_RCVQ_EXPANSION 1
172 #define SLIC_RCVQ_ENTRIES (256 * SLIC_RCVQ_EXPANSION)
173 @@ -68,45 +67,45 @@ typedef struct _slic_rspqueue_t {
174 #define SLIC_RCVQ_FILLENTRIES (16 * SLIC_RCVQ_EXPANSION)
175 #define SLIC_RCVQ_FILLTHRESH (SLIC_RCVQ_ENTRIES - SLIC_RCVQ_FILLENTRIES)
176
177 -typedef struct _slic_rcvqueue_t {
178 +struct slic_rcvqueue {
179 struct sk_buff *head;
180 struct sk_buff *tail;
181 - ulong32 count;
182 - ulong32 size;
183 - ulong32 errors;
184 -} slic_rcvqueue_t, *p_slic_rcvqueue_t;
185 -
186 -typedef struct _slic_rcvbuf_info_t {
187 - ulong32 id;
188 - ulong32 starttime;
189 - ulong32 stoptime;
190 - ulong32 slicworld;
191 - ulong32 lasttime;
192 - ulong32 lastid;
193 -} slic_rcvbuf_info_t, *pslic_rcvbuf_info_t;
194 + u32 count;
195 + u32 size;
196 + u32 errors;
197 +};
198 +
199 +struct slic_rcvbuf_info {
200 + u32 id;
201 + u32 starttime;
202 + u32 stoptime;
203 + u32 slicworld;
204 + u32 lasttime;
205 + u32 lastid;
206 +};
207 /*
208 SLIC Handle structure. Used to restrict handle values to
209 32 bits by using an index rather than an address.
210 Simplifies ucode in 64-bit systems
211 */
212 -typedef struct _slic_handle_word_t {
213 +struct slic_handle_word {
214 union {
215 struct {
216 ushort index;
217 ushort bottombits; /* to denote num bufs to card */
218 } parts;
219 - ulong32 whole;
220 + u32 whole;
221 } handle;
222 -} slic_handle_word_t, *pslic_handle_word_t;
223 +};
224
225 -typedef struct _slic_handle_t {
226 - slic_handle_word_t token; /* token passed between host and card*/
227 +struct slic_handle {
228 + struct slic_handle_word token; /* token passed between host and card*/
229 ushort type;
230 - pvoid address; /* actual address of the object*/
231 + void *address; /* actual address of the object*/
232 ushort offset;
233 - struct _slic_handle_t *other_handle;
234 - struct _slic_handle_t *next;
235 -} slic_handle_t, *pslic_handle_t;
236 + struct slic_handle *other_handle;
237 + struct slic_handle *next;
238 +};
239
240 #define SLIC_HANDLE_FREE 0x0000
241 #define SLIC_HANDLE_DATA 0x0001
242 @@ -120,19 +119,19 @@ typedef struct _slic_handle_t {
243
244 #define SLIC_HOSTCMD_SIZE 512
245
246 -typedef struct _slic_hostcmd_t {
247 - slic_host64_cmd_t cmd64;
248 - ulong32 type;
249 +struct slic_hostcmd {
250 + struct slic_host64_cmd cmd64;
251 + u32 type;
252 struct sk_buff *skb;
253 - ulong32 paddrl;
254 - ulong32 paddrh;
255 - ulong32 busy;
256 - ulong32 cmdsize;
257 + u32 paddrl;
258 + u32 paddrh;
259 + u32 busy;
260 + u32 cmdsize;
261 ushort numbufs;
262 - pslic_handle_t pslic_handle;/* handle associated with command */
263 - struct _slic_hostcmd_t *next;
264 - struct _slic_hostcmd_t *next_all;
265 -} slic_hostcmd_t, *p_slic_hostcmd_t;
266 + struct slic_handle *pslic_handle;/* handle associated with command */
267 + struct slic_hostcmd *next;
268 + struct slic_hostcmd *next_all;
269 +};
270
271 #define SLIC_CMDQ_CMDSINPAGE (PAGE_SIZE / SLIC_HOSTCMD_SIZE)
272 #define SLIC_CMD_DUMB 3
273 @@ -142,18 +141,18 @@ typedef struct _slic_hostcmd_t {
274 #define SLIC_CMDQ_MAXPAGES (SLIC_CMDQ_MAXCMDS / SLIC_CMDQ_CMDSINPAGE)
275 #define SLIC_CMDQ_INITPAGES (SLIC_CMDQ_INITCMDS / SLIC_CMDQ_CMDSINPAGE)
276
277 -typedef struct _slic_cmdqmem_t {
278 - int pagecnt;
279 - pulong32 pages[SLIC_CMDQ_MAXPAGES];
280 - dma_addr_t dma_pages[SLIC_CMDQ_MAXPAGES];
281 -} slic_cmdqmem_t, *p_slic_cmdqmem_t;
282 +struct slic_cmdqmem {
283 + int pagecnt;
284 + u32 *pages[SLIC_CMDQ_MAXPAGES];
285 + dma_addr_t dma_pages[SLIC_CMDQ_MAXPAGES];
286 +};
287
288 -typedef struct _slic_cmdqueue_t {
289 - p_slic_hostcmd_t head;
290 - p_slic_hostcmd_t tail;
291 - int count;
292 - struct slic_spinlock lock;
293 -} slic_cmdqueue_t, *p_slic_cmdqueue_t;
294 +struct slic_cmdqueue {
295 + struct slic_hostcmd *head;
296 + struct slic_hostcmd *tail;
297 + int count;
298 + struct slic_spinlock lock;
299 +};
300
301 #ifdef STATUS_SUCCESS
302 #undef STATUS_SUCCESS
303 @@ -181,10 +180,10 @@ just set this at 15K, shouldnt make that much of a diff.
304 #endif
305
306
307 -typedef struct _mcast_address_t {
308 - uchar address[6];
309 - struct _mcast_address_t *next;
310 -} mcast_address_t, *p_mcast_address_t;
311 +struct mcast_address {
312 + unsigned char address[6];
313 + struct mcast_address *next;
314 +};
315
316 #define CARD_DOWN 0x00000000
317 #define CARD_UP 0x00000001
318 @@ -236,38 +235,37 @@ typedef struct _mcast_address_t {
319 #define SLIC_ADAPTER_STATE(x) ((x == ADAPT_UP) ? "UP" : "Down")
320 #define SLIC_CARD_STATE(x) ((x == CARD_UP) ? "UP" : "Down")
321
322 -typedef struct _slic_iface_stats {
323 +struct slic_iface_stats {
324 /*
325 * Stats
326 */
327 - ulong64 xmt_bytes;
328 - ulong64 xmt_ucast;
329 - ulong64 xmt_mcast;
330 - ulong64 xmt_bcast;
331 - ulong64 xmt_errors;
332 - ulong64 xmt_discards;
333 - ulong64 xmit_collisions;
334 - ulong64 xmit_excess_xmit_collisions;
335 - ulong64 rcv_bytes;
336 - ulong64 rcv_ucast;
337 - ulong64 rcv_mcast;
338 - ulong64 rcv_bcast;
339 - ulong64 rcv_errors;
340 - ulong64 rcv_discards;
341 -} slic_iface_stats_t, *p_slic_iface_stats_t;
342 -
343 -typedef struct _slic_tcp_stats {
344 - ulong64 xmit_tcp_segs;
345 - ulong64 xmit_tcp_bytes;
346 - ulong64 rcv_tcp_segs;
347 - ulong64 rcv_tcp_bytes;
348 -} slic_tcp_stats_t, *p_slic_tcp_stats_t;
349 -
350 -typedef struct _slicnet_stats {
351 - slic_tcp_stats_t tcp;
352 - slic_iface_stats_t iface;
353 -
354 -} slicnet_stats_t, *p_slicnet_stats_t;
355 + u64 xmt_bytes;
356 + u64 xmt_ucast;
357 + u64 xmt_mcast;
358 + u64 xmt_bcast;
359 + u64 xmt_errors;
360 + u64 xmt_discards;
361 + u64 xmit_collisions;
362 + u64 xmit_excess_xmit_collisions;
363 + u64 rcv_bytes;
364 + u64 rcv_ucast;
365 + u64 rcv_mcast;
366 + u64 rcv_bcast;
367 + u64 rcv_errors;
368 + u64 rcv_discards;
369 +};
370 +
371 +struct sliccp_stats {
372 + u64 xmit_tcp_segs;
373 + u64 xmit_tcp_bytes;
374 + u64 rcv_tcp_segs;
375 + u64 rcv_tcp_bytes;
376 +};
377 +
378 +struct slicnet_stats {
379 + struct sliccp_stats tcp;
380 + struct slic_iface_stats iface;
381 +};
382
383 #define SLIC_LOADTIMER_PERIOD 1
384 #define SLIC_INTAGG_DEFAULT 200
385 @@ -294,13 +292,13 @@ typedef struct _slicnet_stats {
386 #define SLIC_INTAGG_4GB 100
387 #define SLIC_INTAGG_5GB 100
388
389 -typedef struct _ether_header {
390 - uchar ether_dhost[6];
391 - uchar ether_shost[6];
392 +struct ether_header {
393 + unsigned char ether_dhost[6];
394 + unsigned char ether_shost[6];
395 ushort ether_type;
396 -} ether_header, *p_ether_header;
397 +};
398
399 -typedef struct _sliccard_t {
400 +struct sliccard {
401 uint busnumber;
402 uint slotnumber;
403 uint state;
404 @@ -310,114 +308,111 @@ typedef struct _sliccard_t {
405 uint adapters_allocated;
406 uint adapters_sleeping;
407 uint gennumber;
408 - ulong32 events;
409 - ulong32 loadlevel_current;
410 - ulong32 load;
411 + u32 events;
412 + u32 loadlevel_current;
413 + u32 load;
414 uint reset_in_progress;
415 - ulong32 pingstatus;
416 - ulong32 bad_pingstatus;
417 + u32 pingstatus;
418 + u32 bad_pingstatus;
419 struct timer_list loadtimer;
420 - ulong32 loadtimerset;
421 + u32 loadtimerset;
422 uint config_set;
423 - slic_config_t config;
424 + struct slic_config config;
425 struct dentry *debugfs_dir;
426 struct dentry *debugfs_cardinfo;
427 - struct _adapter_t *master;
428 - struct _adapter_t *adapter[SLIC_MAX_PORTS];
429 - struct _sliccard_t *next;
430 - ulong32 error_interrupts;
431 - ulong32 error_rmiss_interrupts;
432 - ulong32 rcv_interrupts;
433 - ulong32 xmit_interrupts;
434 - ulong32 num_isrs;
435 - ulong32 false_interrupts;
436 - ulong32 max_isr_rcvs;
437 - ulong32 max_isr_xmits;
438 - ulong32 rcv_interrupt_yields;
439 - ulong32 tx_packets;
440 + struct adapter *master;
441 + struct adapter *adapter[SLIC_MAX_PORTS];
442 + struct sliccard *next;
443 + u32 error_interrupts;
444 + u32 error_rmiss_interrupts;
445 + u32 rcv_interrupts;
446 + u32 xmit_interrupts;
447 + u32 num_isrs;
448 + u32 false_interrupts;
449 + u32 max_isr_rcvs;
450 + u32 max_isr_xmits;
451 + u32 rcv_interrupt_yields;
452 + u32 tx_packets;
453 #if SLIC_DUMP_ENABLED
454 - ulong32 dumpstatus; /* Result of dump UPR */
455 - pvoid cmdbuffer;
456 + u32 dumpstatus; /* Result of dump UPR */
457 + void *cmdbuffer;
458
459 ulong cmdbuffer_phys;
460 - ulong32 cmdbuffer_physl;
461 - ulong32 cmdbuffer_physh;
462 + u32 cmdbuffer_physl;
463 + u32 cmdbuffer_physh;
464
465 - ulong32 dump_count;
466 + u32 dump_count;
467 struct task_struct *dump_task_id;
468 - ulong32 dump_wait_count;
469 + u32 dump_wait_count;
470 uint dumpthread_running; /* has a dump thread been init'd */
471 uint dump_requested; /* 0 no, 1 = reqstd 2=curr 3=done */
472 - ulong32 dumptime_start;
473 - ulong32 dumptime_complete;
474 - ulong32 dumptime_delta;
475 - pvoid dumpbuffer;
476 + u32 dumptime_start;
477 + u32 dumptime_complete;
478 + u32 dumptime_delta;
479 + void *dumpbuffer;
480 ulong dumpbuffer_phys;
481 - ulong32 dumpbuffer_physl;
482 - ulong32 dumpbuffer_physh;
483 + u32 dumpbuffer_physl;
484 + u32 dumpbuffer_physh;
485 wait_queue_head_t dump_wq;
486 struct file *dumphandle;
487 mm_segment_t dumpfile_fs;
488 #endif
489 - ulong32 debug_ix;
490 + u32 debug_ix;
491 ushort reg_type[32];
492 ushort reg_offset[32];
493 - ulong32 reg_value[32];
494 - ulong32 reg_valueh[32];
495 -} sliccard_t, *p_sliccard_t;
496 + u32 reg_value[32];
497 + u32 reg_valueh[32];
498 +};
499
500 #define NUM_CFG_SPACES 2
501 #define NUM_CFG_REGS 64
502 -#define NUM_CFG_REG_ULONGS (NUM_CFG_REGS / sizeof(ulong32))
503 +#define NUM_CFG_REG_ULONGS (NUM_CFG_REGS / sizeof(u32))
504
505 -typedef struct _physcard_t {
506 - struct _adapter_t *adapter[SLIC_MAX_PORTS];
507 - struct _physcard_t *next;
508 +struct physcard {
509 + struct adapter *adapter[SLIC_MAX_PORTS];
510 + struct physcard *next;
511 uint adapters_allocd;
512
513 /* the following is not currently needed
514 - ulong32 bridge_busnum;
515 - ulong32 bridge_cfg[NUM_CFG_SPACES][NUM_CFG_REG_ULONGS];
516 + u32 bridge_busnum;
517 + u32 bridge_cfg[NUM_CFG_SPACES][NUM_CFG_REG_ULONGS];
518 */
519 -} physcard_t, *p_physcard_t;
520 +};
521
522 -typedef struct _base_driver {
523 +struct base_driver {
524 struct slic_spinlock driver_lock;
525 - ulong32 num_slic_cards;
526 - ulong32 num_slic_ports;
527 - ulong32 num_slic_ports_active;
528 - ulong32 dynamic_intagg;
529 - p_sliccard_t slic_card;
530 - p_physcard_t phys_card;
531 + u32 num_slic_cards;
532 + u32 num_slic_ports;
533 + u32 num_slic_ports_active;
534 + u32 dynamic_intagg;
535 + struct sliccard *slic_card;
536 + struct physcard *phys_card;
537 uint cardnuminuse[SLIC_MAX_CARDS];
538 -} base_driver_t, *p_base_driver_t;
539 -
540 -extern base_driver_t slic_global;
541 -
542 -typedef struct _slic_shmem_t {
543 - volatile ulong32 isr;
544 - volatile ulong32 linkstatus;
545 - volatile slic_stats_t inicstats;
546 -} slic_shmem_t, *p_slic_shmem_t;
547 -
548 -typedef struct _slic_reg_params_t {
549 - ulong32 linkspeed;
550 - ulong32 linkduplex;
551 - ulong32 fail_on_bad_eeprom;
552 -} slic_reg_params_t, *p_reg_params_t;
553 -
554 -typedef struct _slic_upr_t {
555 - uint adapter;
556 - ulong32 upr_request;
557 - ulong32 upr_data;
558 - ulong32 upr_data_h;
559 - ulong32 upr_buffer;
560 - ulong32 upr_buffer_h;
561 - struct _slic_upr_t *next;
562 -
563 -} slic_upr_t, *p_slic_upr_t;
564 -
565 -typedef struct _slic_ifevents_ti {
566 +};
567 +
568 +struct slic_shmem {
569 + volatile u32 isr;
570 + volatile u32 linkstatus;
571 + volatile struct slic_stats inicstats;
572 +};
573 +
574 +struct slic_reg_params {
575 + u32 linkspeed;
576 + u32 linkduplex;
577 + u32 fail_on_bad_eeprom;
578 +};
579 +
580 +struct slic_upr {
581 + uint adapter;
582 + u32 upr_request;
583 + u32 upr_data;
584 + u32 upr_data_h;
585 + u32 upr_buffer;
586 + u32 upr_buffer_h;
587 + struct slic_upr *next;
588 +};
589 +
590 +struct slic_ifevents {
591 uint oflow802;
592 uint uflow802;
593 uint Tprtoflow;
594 @@ -434,19 +429,19 @@ typedef struct _slic_ifevents_ti {
595 uint IpCsum;
596 uint TpCsum;
597 uint TpHlen;
598 -} slic_ifevents_t;
599 +};
600
601 -typedef struct _adapter_t {
602 - pvoid ifp;
603 - p_sliccard_t card;
604 +struct adapter {
605 + void *ifp;
606 + struct sliccard *card;
607 uint port;
608 - p_physcard_t physcard;
609 + struct physcard *physcard;
610 uint physport;
611 uint cardindex;
612 uint card_size;
613 uint chipid;
614 - struct net_device *netdev;
615 - struct net_device *next_netdevice;
616 + struct net_device *netdev;
617 + struct net_device *next_netdevice;
618 struct slic_spinlock adapter_lock;
619 struct slic_spinlock reset_lock;
620 struct pci_dev *pcidev;
621 @@ -456,90 +451,90 @@ typedef struct _adapter_t {
622 ushort vendid;
623 ushort devid;
624 ushort subsysid;
625 - ulong32 irq;
626 + u32 irq;
627 void __iomem *memorybase;
628 - ulong32 memorylength;
629 - ulong32 drambase;
630 - ulong32 dramlength;
631 + u32 memorylength;
632 + u32 drambase;
633 + u32 dramlength;
634 uint queues_initialized;
635 uint allocated;
636 uint activated;
637 - ulong32 intrregistered;
638 + u32 intrregistered;
639 uint isp_initialized;
640 uint gennumber;
641 - ulong32 curaddrupper;
642 - p_slic_shmem_t pshmem;
643 + u32 curaddrupper;
644 + struct slic_shmem *pshmem;
645 dma_addr_t phys_shmem;
646 - ulong32 isrcopy;
647 - p_slic_regs_t slic_regs;
648 - uchar state;
649 - uchar linkstate;
650 - uchar linkspeed;
651 - uchar linkduplex;
652 + u32 isrcopy;
653 + __iomem struct slic_regs *slic_regs;
654 + unsigned char state;
655 + unsigned char linkstate;
656 + unsigned char linkspeed;
657 + unsigned char linkduplex;
658 uint flags;
659 - uchar macaddr[6];
660 - uchar currmacaddr[6];
661 - ulong32 macopts;
662 + unsigned char macaddr[6];
663 + unsigned char currmacaddr[6];
664 + u32 macopts;
665 ushort devflags_prev;
666 - ulong64 mcastmask;
667 - p_mcast_address_t mcastaddrs;
668 - p_slic_upr_t upr_list;
669 + u64 mcastmask;
670 + struct mcast_address *mcastaddrs;
671 + struct slic_upr *upr_list;
672 uint upr_busy;
673 struct timer_list pingtimer;
674 - ulong32 pingtimerset;
675 + u32 pingtimerset;
676 struct timer_list statstimer;
677 - ulong32 statstimerset;
678 + u32 statstimerset;
679 struct timer_list loadtimer;
680 - ulong32 loadtimerset;
681 + u32 loadtimerset;
682 struct dentry *debugfs_entry;
683 struct slic_spinlock upr_lock;
684 struct slic_spinlock bit64reglock;
685 - slic_rspqueue_t rspqueue;
686 - slic_rcvqueue_t rcvqueue;
687 - slic_cmdqueue_t cmdq_free;
688 - slic_cmdqueue_t cmdq_done;
689 - slic_cmdqueue_t cmdq_all;
690 - slic_cmdqmem_t cmdqmem;
691 + struct slic_rspqueue rspqueue;
692 + struct slic_rcvqueue rcvqueue;
693 + struct slic_cmdqueue cmdq_free;
694 + struct slic_cmdqueue cmdq_done;
695 + struct slic_cmdqueue cmdq_all;
696 + struct slic_cmdqmem cmdqmem;
697 /*
698 * SLIC Handles
699 */
700 - slic_handle_t slic_handles[SLIC_CMDQ_MAXCMDS+1]; /* Object handles*/
701 - pslic_handle_t pfree_slic_handles; /* Free object handles*/
702 + struct slic_handle slic_handles[SLIC_CMDQ_MAXCMDS+1]; /* Object handles*/
703 + struct slic_handle *pfree_slic_handles; /* Free object handles*/
704 struct slic_spinlock handle_lock; /* Object handle list lock*/
705 ushort slic_handle_ix;
706
707 - ulong32 xmitq_full;
708 - ulong32 all_reg_writes;
709 - ulong32 icr_reg_writes;
710 - ulong32 isr_reg_writes;
711 - ulong32 error_interrupts;
712 - ulong32 error_rmiss_interrupts;
713 - ulong32 rx_errors;
714 - ulong32 rcv_drops;
715 - ulong32 rcv_interrupts;
716 - ulong32 xmit_interrupts;
717 - ulong32 linkevent_interrupts;
718 - ulong32 upr_interrupts;
719 - ulong32 num_isrs;
720 - ulong32 false_interrupts;
721 - ulong32 tx_packets;
722 - ulong32 xmit_completes;
723 - ulong32 tx_drops;
724 - ulong32 rcv_broadcasts;
725 - ulong32 rcv_multicasts;
726 - ulong32 rcv_unicasts;
727 - ulong32 max_isr_rcvs;
728 - ulong32 max_isr_xmits;
729 - ulong32 rcv_interrupt_yields;
730 - ulong32 intagg_period;
731 - p_inicpm_state_t inicpm_info;
732 - pvoid pinicpm_info;
733 - slic_reg_params_t reg_params;
734 - slic_ifevents_t if_events;
735 - slic_stats_t inicstats_prev;
736 - slicnet_stats_t slic_stats;
737 + u32 xmitq_full;
738 + u32 all_reg_writes;
739 + u32 icr_reg_writes;
740 + u32 isr_reg_writes;
741 + u32 error_interrupts;
742 + u32 error_rmiss_interrupts;
743 + u32 rx_errors;
744 + u32 rcv_drops;
745 + u32 rcv_interrupts;
746 + u32 xmit_interrupts;
747 + u32 linkevent_interrupts;
748 + u32 upr_interrupts;
749 + u32 num_isrs;
750 + u32 false_interrupts;
751 + u32 tx_packets;
752 + u32 xmit_completes;
753 + u32 tx_drops;
754 + u32 rcv_broadcasts;
755 + u32 rcv_multicasts;
756 + u32 rcv_unicasts;
757 + u32 max_isr_rcvs;
758 + u32 max_isr_xmits;
759 + u32 rcv_interrupt_yields;
760 + u32 intagg_period;
761 + struct inicpm_state *inicpm_info;
762 + void *pinicpm_info;
763 + struct slic_reg_params reg_params;
764 + struct slic_ifevents if_events;
765 + struct slic_stats inicstats_prev;
766 + struct slicnet_stats slic_stats;
767 struct net_device_stats stats;
768 -} adapter_t, *p_adapter_t;
769 +};
770
771 #if SLIC_DUMP_ENABLED
772 #define SLIC_DUMP_REQUESTED 1
773 @@ -552,10 +547,10 @@ typedef struct _adapter_t {
774 * structure is written out to the card's SRAM when the microcode panic's.
775 *
776 ****************************************************************************/
777 -typedef struct _slic_crash_info {
778 +struct slic_crash_info {
779 ushort cpu_id;
780 ushort crash_pc;
781 -} slic_crash_info, *p_slic_crash_info;
782 +};
783
784 #define CRASH_INFO_OFFSET 0x155C
785
786 @@ -577,20 +572,20 @@ typedef struct _slic_crash_info {
787 #define ETHER_EQ_ADDR(_AddrA, _AddrB, _Result) \
788 { \
789 _Result = TRUE; \
790 - if (*(pulong32)(_AddrA) != *(pulong32)(_AddrB)) \
791 + if (*(u32 *)(_AddrA) != *(u32 *)(_AddrB)) \
792 _Result = FALSE; \
793 - if (*(pushort)(&((_AddrA)[4])) != *(pushort)(&((_AddrB)[4]))) \
794 + if (*(u16 *)(&((_AddrA)[4])) != *(u16 *)(&((_AddrB)[4]))) \
795 _Result = FALSE; \
796 }
797
798 #if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
799 -#define SLIC_GET_ADDR_LOW(_addr) (ulong32)((ulong64)(_addr) & \
800 +#define SLIC_GET_ADDR_LOW(_addr) (u32)((u64)(_addr) & \
801 0x00000000FFFFFFFF)
802 -#define SLIC_GET_ADDR_HIGH(_addr) (ulong32)(((ulong64)(_addr) >> 32) & \
803 +#define SLIC_GET_ADDR_HIGH(_addr) (u32)(((u64)(_addr) >> 32) & \
804 0x00000000FFFFFFFF)
805 #else
806 -#define SLIC_GET_ADDR_LOW(_addr) (ulong32)_addr
807 -#define SLIC_GET_ADDR_HIGH(_addr) (ulong32)0
808 +#define SLIC_GET_ADDR_LOW(_addr) (u32)_addr
809 +#define SLIC_GET_ADDR_HIGH(_addr) (u32)0
810 #endif
811
812 #define FLUSH TRUE
813 diff --git a/drivers/staging/slicoss/slic_os.h b/drivers/staging/slicoss/slic_os.h
814 index 2064673..b0d2883 100644
815 --- a/drivers/staging/slicoss/slic_os.h
816 +++ b/drivers/staging/slicoss/slic_os.h
817 @@ -2,7 +2,6 @@
818 *
819 * Copyright (c)2000-2002 Alacritech, Inc. All rights reserved.
820 *
821 - * $Id: slic_os.h,v 1.2 2006/03/27 15:10:15 mook Exp $
822 *
823 * Redistribution and use in source and binary forms, with or without
824 * modification, are permitted provided that the following conditions
825 @@ -43,87 +42,9 @@
826 #ifndef _SLIC_OS_SPECIFIC_H_
827 #define _SLIC_OS_SPECIFIC_H_
828
829 -typedef unsigned char uchar;
830 -typedef u64 ulong64;
831 -typedef char *pchar;
832 -typedef unsigned char *puchar;
833 -typedef u16 *pushort;
834 -typedef u32 ulong32;
835 -typedef u32 *pulong32;
836 -typedef int *plong32;
837 -typedef unsigned int *puint;
838 -typedef void *pvoid;
839 -typedef unsigned long *pulong;
840 -typedef unsigned int boolean;
841 -typedef unsigned int wchar;
842 -typedef unsigned int *pwchar;
843 -typedef unsigned char UCHAR;
844 -typedef u32 ULONG;
845 -typedef s32 LONG;
846 #define FALSE (0)
847 #define TRUE (1)
848
849 -#define SLIC_INIT_SPINLOCK(x) \
850 - { \
851 - spin_lock_init(&((x).lock)); \
852 - }
853 -#define SLIC_ACQUIRE_SPINLOCK(x) \
854 - { \
855 - spin_lock(&((x).lock)); \
856 - }
857 -
858 -#define SLIC_RELEASE_SPINLOCK(x) \
859 - { \
860 - spin_unlock(&((x).lock)); \
861 - }
862 -
863 -#define SLIC_ACQUIRE_IRQ_SPINLOCK(x) \
864 - { \
865 - spin_lock_irqsave(&((x).lock), (x).flags); \
866 - }
867 -
868 -#define SLIC_RELEASE_IRQ_SPINLOCK(x) \
869 - { \
870 - spin_unlock_irqrestore(&((x).lock), (x).flags); \
871 - }
872 -
873 -#define ATK_DEBUG 1
874 -
875 -#if ATK_DEBUG
876 -#define SLIC_TIMESTAMP(value) { \
877 - struct timeval timev; \
878 - do_gettimeofday(&timev); \
879 - value = timev.tv_sec*1000000 + timev.tv_usec; \
880 -}
881 -#else
882 -#define SLIC_TIMESTAMP(value)
883 -#endif
884 -
885 -#define SLIC_ALLOCATE_MEM(len, flag) kmalloc(len, flag)
886 -#define SLIC_DEALLOCATE_MEM(mem) kfree(mem)
887 -#define SLIC_DEALLOCATE_IRQ_MEM(mem) free(mem)
888 -#define SLIC_ALLOCATE_PAGE(x) (pulong32)get_free_page(GFP_KERNEL)
889 -#define SLIC_DEALLOCATE_PAGE(addr) free_page((ulong32)addr)
890 -#define SLIC_ALLOCATE_PCIMEM(a, sz, physp) \
891 - pci_alloc_consistent((a)->pcidev, (sz), &(physp))
892 -#define SLIC_DEALLOCATE_PCIMEM(a, sz, vp, pp) \
893 - pci_free_consistent((a)->pcidev, (sz), (vp), (pp))
894 -#define SLIC_GET_PHYSICAL_ADDRESS(addr) virt_to_bus((addr))
895 -#define SLIC_GET_PHYSICAL_ADDRESS_HIGH(addr) 0
896 -
897 -#define SLIC_GET_DMA_ADDRESS_WRITE(a, ptr, sz) \
898 - pci_map_single((a)->pcidev, (ptr), (sz), PCI_DMA_TODEVICE)
899 -#define SLIC_GET_DMA_ADDRESS_READ(a, ptr, sz) \
900 - pci_map_single((a)->pcidev, (ptr), (sz), PCI_DMA_FROMDEVICE)
901 -#define SLIC_UNGET_DMA_ADDRESS_WRITE(a, pa, sz) \
902 - pci_unmap_single((a)->pcidev, (pa), (sz), PCI_DMA_TODEVICE)
903 -#define SLIC_UNGET_DMA_ADDRESS_READ(a, pa, sz) \
904 - pci_unmap_single((a)->pcidev, (pa), (sz), PCI_DMA_FROMDEVICE)
905 -
906 -#define SLIC_ZERO_MEMORY(p, sz) memset((p), 0, (sz))
907 -#define SLIC_EQUAL_MEMORY(src1, src2, len) (!memcmp(src1, src2, len))
908 -#define SLIC_MOVE_MEMORY(dst, src, len) memcpy((dst), (src), (len))
909 -
910 #define SLIC_SECS_TO_JIFFS(x) ((x) * HZ)
911 #define SLIC_MS_TO_JIFFIES(x) (SLIC_SECS_TO_JIFFS((x)) / 1000)
912
913 @@ -132,7 +53,7 @@ typedef s32 LONG;
914 { \
915 adapter->card->reg_type[adapter->card->debug_ix] = 0; \
916 adapter->card->reg_offset[adapter->card->debug_ix] = \
917 - ((puchar)(&reg)) - ((puchar)adapter->slic_regs); \
918 + ((unsigned char *)(&reg)) - ((unsigned char *)adapter->slic_regs); \
919 adapter->card->reg_value[adapter->card->debug_ix++] = value; \
920 if (adapter->card->debug_ix == 32) \
921 adapter->card->debug_ix = 0; \
922 @@ -142,7 +63,7 @@ typedef s32 LONG;
923 { \
924 adapter->card->reg_type[adapter->card->debug_ix] = 1; \
925 adapter->card->reg_offset[adapter->card->debug_ix] = \
926 - ((puchar)(&reg)) - ((puchar)adapter->slic_regs); \
927 + ((unsigned char *)(&reg)) - ((unsigned char *)adapter->slic_regs); \
928 adapter->card->reg_value[adapter->card->debug_ix] = value; \
929 adapter->card->reg_valueh[adapter->card->debug_ix++] = valh; \
930 if (adapter->card->debug_ix == 32) \
931 @@ -156,8 +77,6 @@ typedef s32 LONG;
932 #define WRITE_REG64(a, reg, value, regh, valh, flush) \
933 slic_reg64_write((a), (&reg), (value), (&regh), (valh), (flush))
934 #endif
935 -#define READ_REG(reg, flush) slic_reg32_read((&reg), (flush))
936 -#define READ_REGP16(reg, flush) slic_reg16_read((&reg), (flush))
937
938 #endif /* _SLIC_OS_SPECIFIC_H_ */
939
940 diff --git a/drivers/staging/slicoss/slicbuild.h b/drivers/staging/slicoss/slicbuild.h
941 index ddf1665..ae05e04 100644
942 --- a/drivers/staging/slicoss/slicbuild.h
943 +++ b/drivers/staging/slicoss/slicbuild.h
944 @@ -2,7 +2,6 @@
945 *
946 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved.
947 *
948 - * $Id: slicbuild.h,v 1.2 2006/03/27 15:10:10 mook Exp $
949 *
950 * Redistribution and use in source and binary forms, with or without
951 * modification, are permitted provided that the following conditions
952 diff --git a/drivers/staging/slicoss/slicdbg.h b/drivers/staging/slicoss/slicdbg.h
953 index c1be56f..c54e44f 100644
954 --- a/drivers/staging/slicoss/slicdbg.h
955 +++ b/drivers/staging/slicoss/slicdbg.h
956 @@ -2,7 +2,6 @@
957 *
958 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved.
959 *
960 - * $Id: slicdbg.h,v 1.2 2006/03/27 15:10:04 mook Exp $
961 *
962 * Redistribution and use in source and binary forms, with or without
963 * modification, are permitted provided that the following conditions
964 @@ -66,7 +65,7 @@
965 #ifdef CONFIG_X86_64
966 #define VALID_ADDRESS(p) (1)
967 #else
968 -#define VALID_ADDRESS(p) (((ulong32)(p) & 0x80000000) || ((ulong32)(p) == 0))
969 +#define VALID_ADDRESS(p) (((u32)(p) & 0x80000000) || ((u32)(p) == 0))
970 #endif
971 #ifndef ASSERT
972 #define ASSERT(a) \
973 diff --git a/drivers/staging/slicoss/slicdump.h b/drivers/staging/slicoss/slicdump.h
974 index 3c46094..ca0a221 100644
975 --- a/drivers/staging/slicoss/slicdump.h
976 +++ b/drivers/staging/slicoss/slicdump.h
977 @@ -1,5 +1,4 @@
978 /*
979 - * $Id: slicdump.h,v 1.2 2006/03/27 15:09:57 mook Exp $
980 *
981 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved.
982 *
983 @@ -148,32 +147,32 @@
984 /*
985 * Break and Reset Break command structure
986 */
987 -typedef struct _BREAK {
988 - uchar command; /* Command word defined above */
989 - uchar resvd;
990 +struct BREAK {
991 + unsigned char command; /* Command word defined above */
992 + unsigned char resvd;
993 ushort count; /* Number of executions before break */
994 - ulong32 addr; /* Address of break point */
995 -} BREAK, *PBREAK;
996 + u32 addr; /* Address of break point */
997 +};
998
999 /*
1000 * Dump and Load command structure
1001 */
1002 -typedef struct _dump_cmd {
1003 - uchar cmd; /* Command word defined above */
1004 - uchar desc; /* Descriptor values - defined below */
1005 +struct dump_cmd {
1006 + unsigned char cmd; /* Command word defined above */
1007 + unsigned char desc; /* Descriptor values - defined below */
1008 ushort count; /* number of 4 byte words to be transferred */
1009 - ulong32 addr; /* start address of dump or load */
1010 -} dump_cmd_t, *pdump_cmd_t;
1011 + u32 addr; /* start address of dump or load */
1012 +};
1013
1014 /*
1015 * Receive or Transmit a frame.
1016 */
1017 -typedef struct _RCV_OR_XMT_FRAME {
1018 - uchar command; /* Command word defined above */
1019 - uchar MacId; /* Mac ID of interface - transmit only */
1020 +struct RCV_OR_XMT_FRAME {
1021 + unsigned char command; /* Command word defined above */
1022 + unsigned char MacId; /* Mac ID of interface - transmit only */
1023 ushort count; /* Length of frame in bytes */
1024 - ulong32 pad; /* not used */
1025 -} RCV_OR_XMT_FRAME, *PRCV_OR_XMT_FRAME;
1026 + u32 pad; /* not used */
1027 +};
1028
1029 /*
1030 * Values of desc field in DUMP_OR_LOAD structure
1031 @@ -196,12 +195,12 @@ typedef struct _RCV_OR_XMT_FRAME {
1032 /*
1033 * Map command to replace a command in ROM with a command in WCS
1034 */
1035 -typedef struct _MAP {
1036 - uchar command; /* Command word defined above */
1037 - uchar not_used[3];
1038 +struct MAP {
1039 + unsigned char command; /* Command word defined above */
1040 + unsigned char not_used[3];
1041 ushort map_to; /* Instruction address in WCS */
1042 ushort map_out; /* Instruction address in ROM */
1043 -} MAP, *PMAP;
1044 +};
1045
1046 /*
1047 * Misc definitions
1048 @@ -221,35 +220,35 @@ typedef struct _MAP {
1049 /*
1050 * Coredump header structure
1051 */
1052 -typedef struct _CORE_Q {
1053 - ulong32 queueOff; /* Offset of queue */
1054 - ulong32 queuesize; /* size of queue */
1055 -} CORE_Q;
1056 +struct CORE_Q {
1057 + u32 queueOff; /* Offset of queue */
1058 + u32 queuesize; /* size of queue */
1059 +};
1060
1061 #define DRIVER_NAME_SIZE 32
1062
1063 -typedef struct _sliccore_hdr_t {
1064 - uchar driver_version[DRIVER_NAME_SIZE]; /* Driver version string */
1065 - ulong32 RcvRegOff; /* Offset of receive registers */
1066 - ulong32 RcvRegsize; /* size of receive registers */
1067 - ulong32 XmtRegOff; /* Offset of transmit registers */
1068 - ulong32 XmtRegsize; /* size of transmit registers */
1069 - ulong32 FileRegOff; /* Offset of register file */
1070 - ulong32 FileRegsize; /* size of register file */
1071 - ulong32 SramOff; /* Offset of Sram */
1072 - ulong32 Sramsize; /* size of Sram */
1073 - ulong32 DramOff; /* Offset of Dram */
1074 - ulong32 Dramsize; /* size of Dram */
1075 +struct sliccore_hdr {
1076 + unsigned char driver_version[DRIVER_NAME_SIZE]; /* Driver version string */
1077 + u32 RcvRegOff; /* Offset of receive registers */
1078 + u32 RcvRegsize; /* size of receive registers */
1079 + u32 XmtRegOff; /* Offset of transmit registers */
1080 + u32 XmtRegsize; /* size of transmit registers */
1081 + u32 FileRegOff; /* Offset of register file */
1082 + u32 FileRegsize; /* size of register file */
1083 + u32 SramOff; /* Offset of Sram */
1084 + u32 Sramsize; /* size of Sram */
1085 + u32 DramOff; /* Offset of Dram */
1086 + u32 Dramsize; /* size of Dram */
1087 CORE_Q queues[SLIC_MAX_QUEUE]; /* size and offsets of queues */
1088 - ulong32 CamAMOff; /* Offset of CAM A contents */
1089 - ulong32 CamASize; /* Size of Cam A */
1090 - ulong32 CamBMOff; /* Offset of CAM B contents */
1091 - ulong32 CamBSize; /* Size of Cam B */
1092 - ulong32 CamCMOff; /* Offset of CAM C contents */
1093 - ulong32 CamCSize; /* Size of Cam C */
1094 - ulong32 CamDMOff; /* Offset of CAM D contents */
1095 - ulong32 CamDSize; /* Size of Cam D */
1096 -} sliccore_hdr_t, *p_sliccore_hdr_t;
1097 + u32 CamAMOff; /* Offset of CAM A contents */
1098 + u32 CamASize; /* Size of Cam A */
1099 + u32 CamBMOff; /* Offset of CAM B contents */
1100 + u32 CamBSize; /* Size of Cam B */
1101 + u32 CamCMOff; /* Offset of CAM C contents */
1102 + u32 CamCSize; /* Size of Cam C */
1103 + u32 CamDMOff; /* Offset of CAM D contents */
1104 + u32 CamDSize; /* Size of Cam D */
1105 +};
1106
1107 /*
1108 * definitions needed for our kernel-mode gdb stub.
1109 diff --git a/drivers/staging/slicoss/slichw.h b/drivers/staging/slicoss/slichw.h
1110 index d5765c4..4c5c15d 100644
1111 --- a/drivers/staging/slicoss/slichw.h
1112 +++ b/drivers/staging/slicoss/slichw.h
1113 @@ -2,7 +2,6 @@
1114 *
1115 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved.
1116 *
1117 - * $Id: slichw.h,v 1.3 2008/03/17 19:27:26 chris Exp $
1118 *
1119 * Redistribution and use in source and binary forms, with or without
1120 * modification, are permitted provided that the following conditions
1121 @@ -236,110 +235,106 @@
1122 #define TRUE 1
1123 #endif
1124
1125 -typedef struct _slic_rcvbuf_t {
1126 - uchar pad1[6];
1127 +struct slic_rcvbuf {
1128 + unsigned char pad1[6];
1129 ushort pad2;
1130 - ulong32 pad3;
1131 - ulong32 pad4;
1132 - ulong32 buffer;
1133 - ulong32 length;
1134 - ulong32 status;
1135 - ulong32 pad5;
1136 + u32 pad3;
1137 + u32 pad4;
1138 + u32 buffer;
1139 + u32 length;
1140 + u32 status;
1141 + u32 pad5;
1142 ushort pad6;
1143 - uchar data[SLIC_RCVBUF_DATASIZE];
1144 -} slic_rcvbuf_t, *p_slic_rcvbuf_t;
1145 + unsigned char data[SLIC_RCVBUF_DATASIZE];
1146 +};
1147
1148 -typedef struct _slic_hddr_wds {
1149 + struct slic_hddr_wds {
1150 union {
1151 struct {
1152 - ulong32 frame_status;
1153 - ulong32 frame_status_b;
1154 - ulong32 time_stamp;
1155 - ulong32 checksum;
1156 + u32 frame_status;
1157 + u32 frame_status_b;
1158 + u32 time_stamp;
1159 + u32 checksum;
1160 } hdrs_14port;
1161 struct {
1162 - ulong32 frame_status;
1163 + u32 frame_status;
1164 ushort ByteCnt;
1165 ushort TpChksum;
1166 ushort CtxHash;
1167 ushort MacHash;
1168 - ulong32 BufLnk;
1169 + u32 BufLnk;
1170 } hdrs_gbit;
1171 } u0;
1172 -} slic_hddr_wds_t, *p_slic_hddr_wds;
1173 +};
1174
1175 #define frame_status14 u0.hdrs_14port.frame_status
1176 #define frame_status_b14 u0.hdrs_14port.frame_status_b
1177 #define frame_statusGB u0.hdrs_gbit.frame_status
1178
1179 -typedef struct _slic_host64sg_t {
1180 - ulong32 paddrl;
1181 - ulong32 paddrh;
1182 - ulong32 length;
1183 -} slic_host64sg_t, *p_slic_host64sg_t;
1184 -
1185 -typedef struct _slic_host64_cmd_t {
1186 - ulong32 hosthandle;
1187 - ulong32 RSVD;
1188 - uchar command;
1189 - uchar flags;
1190 +struct slic_host64sg {
1191 + u32 paddrl;
1192 + u32 paddrh;
1193 + u32 length;
1194 +};
1195 +
1196 +struct slic_host64_cmd {
1197 + u32 hosthandle;
1198 + u32 RSVD;
1199 + unsigned char command;
1200 + unsigned char flags;
1201 union {
1202 ushort rsv1;
1203 ushort rsv2;
1204 } u0;
1205 union {
1206 struct {
1207 - ulong32 totlen;
1208 - slic_host64sg_t bufs[SLIC_MAX64_BCNT];
1209 + u32 totlen;
1210 + struct slic_host64sg bufs[SLIC_MAX64_BCNT];
1211 } slic_buffers;
1212 } u;
1213 +};
1214
1215 -} slic_host64_cmd_t, *p_slic_host64_cmd_t;
1216 +struct slic_rspbuf {
1217 + u32 hosthandle;
1218 + u32 pad0;
1219 + u32 pad1;
1220 + u32 status;
1221 + u32 pad2[4];
1222
1223 -typedef struct _slic_rspbuf_t {
1224 - ulong32 hosthandle;
1225 - ulong32 pad0;
1226 - ulong32 pad1;
1227 - ulong32 status;
1228 - ulong32 pad2[4];
1229 +};
1230
1231 -} slic_rspbuf_t, *p_slic_rspbuf_t;
1232 +struct slic_regs {
1233 + u32 slic_reset; /* Reset Register */
1234 + u32 pad0;
1235
1236 -typedef ulong32 SLIC_REG;
1237 -
1238 -
1239 -typedef struct _slic_regs_t {
1240 - ULONG slic_reset; /* Reset Register */
1241 - ULONG pad0;
1242 -
1243 - ULONG slic_icr; /* Interrupt Control Register */
1244 - ULONG pad2;
1245 + u32 slic_icr; /* Interrupt Control Register */
1246 + u32 pad2;
1247 #define SLIC_ICR 0x0008
1248
1249 - ULONG slic_isp; /* Interrupt status pointer */
1250 - ULONG pad1;
1251 + u32 slic_isp; /* Interrupt status pointer */
1252 + u32 pad1;
1253 #define SLIC_ISP 0x0010
1254
1255 - ULONG slic_isr; /* Interrupt status */
1256 - ULONG pad3;
1257 + u32 slic_isr; /* Interrupt status */
1258 + u32 pad3;
1259 #define SLIC_ISR 0x0018
1260
1261 - SLIC_REG slic_hbar; /* Header buffer address reg */
1262 - ULONG pad4;
1263 + u32 slic_hbar; /* Header buffer address reg */
1264 + u32 pad4;
1265 /* 31-8 - phy addr of set of contiguous hdr buffers
1266 7-0 - number of buffers passed
1267 Buffers are 256 bytes long on 256-byte boundaries. */
1268 #define SLIC_HBAR 0x0020
1269 #define SLIC_HBAR_CNT_MSK 0x000000FF
1270
1271 - SLIC_REG slic_dbar; /* Data buffer handle & address reg */
1272 - ULONG pad5;
1273 + u32 slic_dbar; /* Data buffer handle & address reg */
1274 + u32 pad5;
1275
1276 /* 4 sets of registers; Buffers are 2K bytes long 2 per 4K page. */
1277 #define SLIC_DBAR 0x0028
1278 #define SLIC_DBAR_SIZE 2048
1279
1280 - SLIC_REG slic_cbar; /* Xmt Cmd buf addr regs.*/
1281 + u32 slic_cbar; /* Xmt Cmd buf addr regs.*/
1282 /* 1 per XMT interface
1283 31-5 - phy addr of host command buffer
1284 4-0 - length of cmd in multiples of 32 bytes
1285 @@ -348,13 +343,13 @@ typedef struct _slic_regs_t {
1286 #define SLIC_CBAR_LEN_MSK 0x0000001F
1287 #define SLIC_CBAR_ALIGN 0x00000020
1288
1289 - SLIC_REG slic_wcs; /* write control store*/
1290 + u32 slic_wcs; /* write control store*/
1291 #define SLIC_WCS 0x0034
1292 #define SLIC_WCS_START 0x80000000 /*Start the SLIC (Jump to WCS)*/
1293 #define SLIC_WCS_COMPARE 0x40000000 /* Compare with value in WCS*/
1294
1295 - SLIC_REG slic_rbar; /* Response buffer address reg.*/
1296 - ULONG pad7;
1297 + u32 slic_rbar; /* Response buffer address reg.*/
1298 + u32 pad7;
1299 /*31-8 - phy addr of set of contiguous response buffers
1300 7-0 - number of buffers passed
1301 Buffers are 32 bytes long on 32-byte boundaries.*/
1302 @@ -362,166 +357,166 @@ typedef struct _slic_regs_t {
1303 #define SLIC_RBAR_CNT_MSK 0x000000FF
1304 #define SLIC_RBAR_SIZE 32
1305
1306 - SLIC_REG slic_stats; /* read statistics (UPR) */
1307 - ULONG pad8;
1308 + u32 slic_stats; /* read statistics (UPR) */
1309 + u32 pad8;
1310 #define SLIC_RSTAT 0x0040
1311
1312 - SLIC_REG slic_rlsr; /* read link status */
1313 - ULONG pad9;
1314 + u32 slic_rlsr; /* read link status */
1315 + u32 pad9;
1316 #define SLIC_LSTAT 0x0048
1317
1318 - SLIC_REG slic_wmcfg; /* Write Mac Config */
1319 - ULONG pad10;
1320 + u32 slic_wmcfg; /* Write Mac Config */
1321 + u32 pad10;
1322 #define SLIC_WMCFG 0x0050
1323
1324 - SLIC_REG slic_wphy; /* Write phy register */
1325 - ULONG pad11;
1326 + u32 slic_wphy; /* Write phy register */
1327 + u32 pad11;
1328 #define SLIC_WPHY 0x0058
1329
1330 - SLIC_REG slic_rcbar; /*Rcv Cmd buf addr reg*/
1331 - ULONG pad12;
1332 + u32 slic_rcbar; /*Rcv Cmd buf addr reg*/
1333 + u32 pad12;
1334 #define SLIC_RCBAR 0x0060
1335
1336 - SLIC_REG slic_rconfig; /* Read SLIC Config*/
1337 - ULONG pad13;
1338 + u32 slic_rconfig; /* Read SLIC Config*/
1339 + u32 pad13;
1340 #define SLIC_RCONFIG 0x0068
1341
1342 - SLIC_REG slic_intagg; /* Interrupt aggregation time*/
1343 - ULONG pad14;
1344 + u32 slic_intagg; /* Interrupt aggregation time*/
1345 + u32 pad14;
1346 #define SLIC_INTAGG 0x0070
1347
1348 - SLIC_REG slic_wxcfg; /* Write XMIT config reg*/
1349 - ULONG pad16;
1350 + u32 slic_wxcfg; /* Write XMIT config reg*/
1351 + u32 pad16;
1352 #define SLIC_WXCFG 0x0078
1353
1354 - SLIC_REG slic_wrcfg; /* Write RCV config reg*/
1355 - ULONG pad17;
1356 + u32 slic_wrcfg; /* Write RCV config reg*/
1357 + u32 pad17;
1358 #define SLIC_WRCFG 0x0080
1359
1360 - SLIC_REG slic_wraddral; /* Write rcv addr a low*/
1361 - ULONG pad18;
1362 + u32 slic_wraddral; /* Write rcv addr a low*/
1363 + u32 pad18;
1364 #define SLIC_WRADDRAL 0x0088
1365
1366 - SLIC_REG slic_wraddrah; /* Write rcv addr a high*/
1367 - ULONG pad19;
1368 + u32 slic_wraddrah; /* Write rcv addr a high*/
1369 + u32 pad19;
1370 #define SLIC_WRADDRAH 0x0090
1371
1372 - SLIC_REG slic_wraddrbl; /* Write rcv addr b low*/
1373 - ULONG pad20;
1374 + u32 slic_wraddrbl; /* Write rcv addr b low*/
1375 + u32 pad20;
1376 #define SLIC_WRADDRBL 0x0098
1377
1378 - SLIC_REG slic_wraddrbh; /* Write rcv addr b high*/
1379 - ULONG pad21;
1380 + u32 slic_wraddrbh; /* Write rcv addr b high*/
1381 + u32 pad21;
1382 #define SLIC_WRADDRBH 0x00a0
1383
1384 - SLIC_REG slic_mcastlow; /* Low bits of mcast mask*/
1385 - ULONG pad22;
1386 + u32 slic_mcastlow; /* Low bits of mcast mask*/
1387 + u32 pad22;
1388 #define SLIC_MCASTLOW 0x00a8
1389
1390 - SLIC_REG slic_mcasthigh; /* High bits of mcast mask*/
1391 - ULONG pad23;
1392 + u32 slic_mcasthigh; /* High bits of mcast mask*/
1393 + u32 pad23;
1394 #define SLIC_MCASTHIGH 0x00b0
1395
1396 - SLIC_REG slic_ping; /* Ping the card*/
1397 - ULONG pad24;
1398 + u32 slic_ping; /* Ping the card*/
1399 + u32 pad24;
1400 #define SLIC_PING 0x00b8
1401
1402 - SLIC_REG slic_dump_cmd; /* Dump command */
1403 - ULONG pad25;
1404 + u32 slic_dump_cmd; /* Dump command */
1405 + u32 pad25;
1406 #define SLIC_DUMP_CMD 0x00c0
1407
1408 - SLIC_REG slic_dump_data; /* Dump data pointer */
1409 - ULONG pad26;
1410 + u32 slic_dump_data; /* Dump data pointer */
1411 + u32 pad26;
1412 #define SLIC_DUMP_DATA 0x00c8
1413
1414 - SLIC_REG slic_pcistatus; /* Read card's pci_status register */
1415 - ULONG pad27;
1416 + u32 slic_pcistatus; /* Read card's pci_status register */
1417 + u32 pad27;
1418 #define SLIC_PCISTATUS 0x00d0
1419
1420 - SLIC_REG slic_wrhostid; /* Write hostid field */
1421 - ULONG pad28;
1422 + u32 slic_wrhostid; /* Write hostid field */
1423 + u32 pad28;
1424 #define SLIC_WRHOSTID 0x00d8
1425 #define SLIC_RDHOSTID_1GB 0x1554
1426 #define SLIC_RDHOSTID_2GB 0x1554
1427
1428 - SLIC_REG slic_low_power; /* Put card in a low power state */
1429 - ULONG pad29;
1430 + u32 slic_low_power; /* Put card in a low power state */
1431 + u32 pad29;
1432 #define SLIC_LOW_POWER 0x00e0
1433
1434 - SLIC_REG slic_quiesce; /* force slic into quiescent state
1435 + u32 slic_quiesce; /* force slic into quiescent state
1436 before soft reset */
1437 - ULONG pad30;
1438 + u32 pad30;
1439 #define SLIC_QUIESCE 0x00e8
1440
1441 - SLIC_REG slic_reset_iface; /* reset interface queues */
1442 - ULONG pad31;
1443 + u32 slic_reset_iface; /* reset interface queues */
1444 + u32 pad31;
1445 #define SLIC_RESET_IFACE 0x00f0
1446
1447 - SLIC_REG slic_addr_upper; /* Bits 63-32 for host i/f addrs */
1448 - ULONG pad32;
1449 + u32 slic_addr_upper; /* Bits 63-32 for host i/f addrs */
1450 + u32 pad32;
1451 #define SLIC_ADDR_UPPER 0x00f8 /*Register is only written when it has changed*/
1452
1453 - SLIC_REG slic_hbar64; /* 64 bit Header buffer address reg */
1454 - ULONG pad33;
1455 + u32 slic_hbar64; /* 64 bit Header buffer address reg */
1456 + u32 pad33;
1457 #define SLIC_HBAR64 0x0100
1458
1459 - SLIC_REG slic_dbar64; /* 64 bit Data buffer handle & address reg */
1460 - ULONG pad34;
1461 + u32 slic_dbar64; /* 64 bit Data buffer handle & address reg */
1462 + u32 pad34;
1463 #define SLIC_DBAR64 0x0108
1464
1465 - SLIC_REG slic_cbar64; /* 64 bit Xmt Cmd buf addr regs. */
1466 - ULONG pad35;
1467 + u32 slic_cbar64; /* 64 bit Xmt Cmd buf addr regs. */
1468 + u32 pad35;
1469 #define SLIC_CBAR64 0x0110
1470
1471 - SLIC_REG slic_rbar64; /* 64 bit Response buffer address reg.*/
1472 - ULONG pad36;
1473 + u32 slic_rbar64; /* 64 bit Response buffer address reg.*/
1474 + u32 pad36;
1475 #define SLIC_RBAR64 0x0118
1476
1477 - SLIC_REG slic_rcbar64; /* 64 bit Rcv Cmd buf addr reg*/
1478 - ULONG pad37;
1479 + u32 slic_rcbar64; /* 64 bit Rcv Cmd buf addr reg*/
1480 + u32 pad37;
1481 #define SLIC_RCBAR64 0x0120
1482
1483 - SLIC_REG slic_stats64; /*read statistics (64 bit UPR)*/
1484 - ULONG pad38;
1485 + u32 slic_stats64; /*read statistics (64 bit UPR)*/
1486 + u32 pad38;
1487 #define SLIC_RSTAT64 0x0128
1488
1489 - SLIC_REG slic_rcv_wcs; /*Download Gigabit RCV sequencer ucode*/
1490 - ULONG pad39;
1491 + u32 slic_rcv_wcs; /*Download Gigabit RCV sequencer ucode*/
1492 + u32 pad39;
1493 #define SLIC_RCV_WCS 0x0130
1494 #define SLIC_RCVWCS_BEGIN 0x40000000
1495 #define SLIC_RCVWCS_FINISH 0x80000000
1496
1497 - SLIC_REG slic_wrvlanid; /* Write VlanId field */
1498 - ULONG pad40;
1499 + u32 slic_wrvlanid; /* Write VlanId field */
1500 + u32 pad40;
1501 #define SLIC_WRVLANID 0x0138
1502
1503 - SLIC_REG slic_read_xf_info; /* Read Transformer info */
1504 - ULONG pad41;
1505 + u32 slic_read_xf_info; /* Read Transformer info */
1506 + u32 pad41;
1507 #define SLIC_READ_XF_INFO 0x0140
1508
1509 - SLIC_REG slic_write_xf_info; /* Write Transformer info */
1510 - ULONG pad42;
1511 + u32 slic_write_xf_info; /* Write Transformer info */
1512 + u32 pad42;
1513 #define SLIC_WRITE_XF_INFO 0x0148
1514
1515 - SLIC_REG RSVD1; /* TOE Only */
1516 - ULONG pad43;
1517 + u32 RSVD1; /* TOE Only */
1518 + u32 pad43;
1519
1520 - SLIC_REG RSVD2; /* TOE Only */
1521 - ULONG pad44;
1522 + u32 RSVD2; /* TOE Only */
1523 + u32 pad44;
1524
1525 - SLIC_REG RSVD3; /* TOE Only */
1526 - ULONG pad45;
1527 + u32 RSVD3; /* TOE Only */
1528 + u32 pad45;
1529
1530 - SLIC_REG RSVD4; /* TOE Only */
1531 - ULONG pad46;
1532 + u32 RSVD4; /* TOE Only */
1533 + u32 pad46;
1534
1535 - SLIC_REG slic_ticks_per_sec; /* Write card ticks per second */
1536 - ULONG pad47;
1537 + u32 slic_ticks_per_sec; /* Write card ticks per second */
1538 + u32 pad47;
1539 #define SLIC_TICKS_PER_SEC 0x0170
1540
1541 -} __iomem slic_regs_t, *p_slic_regs_t, SLIC_REGS, *PSLIC_REGS;
1542 +};
1543
1544 -typedef enum _UPR_REQUEST {
1545 +enum UPR_REQUEST {
1546 SLIC_UPR_STATS,
1547 SLIC_UPR_RLSR,
1548 SLIC_UPR_WCFG,
1549 @@ -532,103 +527,102 @@ typedef enum _UPR_REQUEST {
1550 SLIC_UPR_PDWN,
1551 SLIC_UPR_PING,
1552 SLIC_UPR_DUMP,
1553 -} UPR_REQUEST;
1554 -
1555 -typedef struct _inicpm_wakepattern {
1556 - ulong32 patternlength;
1557 - uchar pattern[SLIC_PM_PATTERNSIZE];
1558 - uchar mask[SLIC_PM_PATTERNSIZE];
1559 -} inicpm_wakepattern_t, *p_inicpm_wakepattern_t;
1560 -
1561 -typedef struct _inicpm_state {
1562 - ulong32 powercaps;
1563 - ulong32 powerstate;
1564 - ulong32 wake_linkstatus;
1565 - ulong32 wake_magicpacket;
1566 - ulong32 wake_framepattern;
1567 - inicpm_wakepattern_t wakepattern[SLIC_PM_MAXPATTERNS];
1568 -} inicpm_state_t, *p_inicpm_state_t;
1569 -
1570 -typedef struct _slicpm_packet_pattern {
1571 - ulong32 priority;
1572 - ulong32 reserved;
1573 - ulong32 masksize;
1574 - ulong32 patternoffset;
1575 - ulong32 patternsize;
1576 - ulong32 patternflags;
1577 -} slicpm_packet_pattern_t, *p_slicpm_packet_pattern_t;
1578 -
1579 -typedef enum _slicpm_power_state {
1580 +};
1581 +
1582 +struct inicpm_wakepattern {
1583 + u32 patternlength;
1584 + unsigned char pattern[SLIC_PM_PATTERNSIZE];
1585 + unsigned char mask[SLIC_PM_PATTERNSIZE];
1586 +};
1587 +
1588 +struct inicpm_state {
1589 + u32 powercaps;
1590 + u32 powerstate;
1591 + u32 wake_linkstatus;
1592 + u32 wake_magicpacket;
1593 + u32 wake_framepattern;
1594 + struct inicpm_wakepattern wakepattern[SLIC_PM_MAXPATTERNS];
1595 +};
1596 +
1597 +struct slicpm_packet_pattern {
1598 + u32 priority;
1599 + u32 reserved;
1600 + u32 masksize;
1601 + u32 patternoffset;
1602 + u32 patternsize;
1603 + u32 patternflags;
1604 +};
1605 +
1606 +enum slicpm_power_state {
1607 slicpm_state_unspecified = 0,
1608 slicpm_state_d0,
1609 slicpm_state_d1,
1610 slicpm_state_d2,
1611 slicpm_state_d3,
1612 slicpm_state_maximum
1613 -} slicpm_state_t, *p_slicpm_state_t;
1614 -
1615 -typedef struct _slicpm_wakeup_capabilities {
1616 - slicpm_state_t min_magic_packet_wakeup;
1617 - slicpm_state_t min_pattern_wakeup;
1618 - slicpm_state_t min_link_change_wakeup;
1619 -} slicpm_wakeup_capabilities_t, *p_slicpm_wakeup_capabilities_t;
1620 -
1621 -
1622 -typedef struct _slic_pnp_capabilities {
1623 - ulong32 flags;
1624 - slicpm_wakeup_capabilities_t wakeup_capabilities;
1625 -} slic_pnp_capabilities_t, *p_slic_pnp_capabilities_t;
1626 -
1627 -typedef struct _xmt_stats_t {
1628 - ulong32 xmit_tcp_bytes;
1629 - ulong32 xmit_tcp_segs;
1630 - ulong32 xmit_bytes;
1631 - ulong32 xmit_collisions;
1632 - ulong32 xmit_unicasts;
1633 - ulong32 xmit_other_error;
1634 - ulong32 xmit_excess_collisions;
1635 -} xmt_stats100_t;
1636 -
1637 -typedef struct _rcv_stats_t {
1638 - ulong32 rcv_tcp_bytes;
1639 - ulong32 rcv_tcp_segs;
1640 - ulong32 rcv_bytes;
1641 - ulong32 rcv_unicasts;
1642 - ulong32 rcv_other_error;
1643 - ulong32 rcv_drops;
1644 -} rcv_stats100_t;
1645 -
1646 -typedef struct _xmt_statsgb_t {
1647 - ulong64 xmit_tcp_bytes;
1648 - ulong64 xmit_tcp_segs;
1649 - ulong64 xmit_bytes;
1650 - ulong64 xmit_collisions;
1651 - ulong64 xmit_unicasts;
1652 - ulong64 xmit_other_error;
1653 - ulong64 xmit_excess_collisions;
1654 -} xmt_statsGB_t;
1655 -
1656 -typedef struct _rcv_statsgb_t {
1657 - ulong64 rcv_tcp_bytes;
1658 - ulong64 rcv_tcp_segs;
1659 - ulong64 rcv_bytes;
1660 - ulong64 rcv_unicasts;
1661 - u64 rcv_other_error;
1662 - ulong64 rcv_drops;
1663 -} rcv_statsGB_t;
1664 -
1665 -typedef struct _slic_stats {
1666 +};
1667 +
1668 +struct slicpm_wakeup_capabilities {
1669 + enum slicpm_power_state min_magic_packet_wakeup;
1670 + enum slicpm_power_state min_pattern_wakeup;
1671 + enum slicpm_power_state min_link_change_wakeup;
1672 +};
1673 +
1674 +struct slic_pnp_capabilities {
1675 + u32 flags;
1676 + struct slicpm_wakeup_capabilities wakeup_capabilities;
1677 +};
1678 +
1679 +struct xmt_stats {
1680 + u32 xmit_tcp_bytes;
1681 + u32 xmit_tcp_segs;
1682 + u32 xmit_bytes;
1683 + u32 xmit_collisions;
1684 + u32 xmit_unicasts;
1685 + u32 xmit_other_error;
1686 + u32 xmit_excess_collisions;
1687 +};
1688 +
1689 +struct rcv_stats {
1690 + u32 rcv_tcp_bytes;
1691 + u32 rcv_tcp_segs;
1692 + u32 rcv_bytes;
1693 + u32 rcv_unicasts;
1694 + u32 rcv_other_error;
1695 + u32 rcv_drops;
1696 +};
1697 +
1698 +struct xmt_statsgb {
1699 + u64 xmit_tcp_bytes;
1700 + u64 xmit_tcp_segs;
1701 + u64 xmit_bytes;
1702 + u64 xmit_collisions;
1703 + u64 xmit_unicasts;
1704 + u64 xmit_other_error;
1705 + u64 xmit_excess_collisions;
1706 +};
1707 +
1708 +struct rcv_statsgb {
1709 + u64 rcv_tcp_bytes;
1710 + u64 rcv_tcp_segs;
1711 + u64 rcv_bytes;
1712 + u64 rcv_unicasts;
1713 + u64 rcv_other_error;
1714 + u64 rcv_drops;
1715 +};
1716 +
1717 +struct slic_stats {
1718 union {
1719 struct {
1720 - xmt_stats100_t xmt100;
1721 - rcv_stats100_t rcv100;
1722 + struct xmt_stats xmt100;
1723 + struct rcv_stats rcv100;
1724 } stats_100;
1725 struct {
1726 - xmt_statsGB_t xmtGB;
1727 - rcv_statsGB_t rcvGB;
1728 + struct xmt_statsgb xmtGB;
1729 + struct rcv_statsgb rcvGB;
1730 } stats_GB;
1731 } u;
1732 -} slic_stats_t, *p_slic_stats_t;
1733 +};
1734
1735 #define xmit_tcp_segs100 u.stats_100.xmt100.xmit_tcp_segs
1736 #define xmit_tcp_bytes100 u.stats_100.xmt100.xmit_tcp_bytes
1737 @@ -658,10 +652,9 @@ typedef struct _slic_stats {
1738 #define rcv_other_error_gb u.stats_GB.rcvGB.rcv_other_error
1739 #define rcv_drops_gb u.stats_GB.rcvGB.rcv_drops
1740
1741 -typedef struct _slic_config_mac_t {
1742 - uchar macaddrA[6];
1743 -
1744 -} slic_config_mac_t, *pslic_config_mac_t;
1745 +struct slic_config_mac {
1746 + unsigned char macaddrA[6];
1747 +};
1748
1749 #define ATK_FRU_FORMAT 0x00
1750 #define VENDOR1_FRU_FORMAT 0x01
1751 @@ -670,68 +663,68 @@ typedef struct _slic_config_mac_t {
1752 #define VENDOR4_FRU_FORMAT 0x04
1753 #define NO_FRU_FORMAT 0xFF
1754
1755 -typedef struct _atk_fru_t {
1756 - uchar assembly[6];
1757 - uchar revision[2];
1758 - uchar serial[14];
1759 - uchar pad[3];
1760 -} atk_fru_t, *patk_fru_t;
1761 -
1762 -typedef struct _vendor1_fru_t {
1763 - uchar commodity;
1764 - uchar assembly[4];
1765 - uchar revision[2];
1766 - uchar supplier[2];
1767 - uchar date[2];
1768 - uchar sequence[3];
1769 - uchar pad[13];
1770 -} vendor1_fru_t, *pvendor1_fru_t;
1771 -
1772 -typedef struct _vendor2_fru_t {
1773 - uchar part[8];
1774 - uchar supplier[5];
1775 - uchar date[3];
1776 - uchar sequence[4];
1777 - uchar pad[7];
1778 -} vendor2_fru_t, *pvendor2_fru_t;
1779 -
1780 -typedef struct _vendor3_fru_t {
1781 - uchar assembly[6];
1782 - uchar revision[2];
1783 - uchar serial[14];
1784 - uchar pad[3];
1785 -} vendor3_fru_t, *pvendor3_fru_t;
1786 -
1787 -typedef struct _vendor4_fru_t {
1788 - uchar number[8];
1789 - uchar part[8];
1790 - uchar version[8];
1791 - uchar pad[3];
1792 -} vendor4_fru_t, *pvendor4_fru_t;
1793 -
1794 -typedef union _oemfru_t {
1795 - vendor1_fru_t vendor1_fru;
1796 - vendor2_fru_t vendor2_fru;
1797 - vendor3_fru_t vendor3_fru;
1798 - vendor4_fru_t vendor4_fru;
1799 -} oemfru_t, *poemfru_t;
1800 +struct atk_fru {
1801 + unsigned char assembly[6];
1802 + unsigned char revision[2];
1803 + unsigned char serial[14];
1804 + unsigned char pad[3];
1805 +};
1806 +
1807 +struct vendor1_fru {
1808 + unsigned char commodity;
1809 + unsigned char assembly[4];
1810 + unsigned char revision[2];
1811 + unsigned char supplier[2];
1812 + unsigned char date[2];
1813 + unsigned char sequence[3];
1814 + unsigned char pad[13];
1815 +};
1816 +
1817 +struct vendor2_fru {
1818 + unsigned char part[8];
1819 + unsigned char supplier[5];
1820 + unsigned char date[3];
1821 + unsigned char sequence[4];
1822 + unsigned char pad[7];
1823 +};
1824 +
1825 +struct vendor3_fru {
1826 + unsigned char assembly[6];
1827 + unsigned char revision[2];
1828 + unsigned char serial[14];
1829 + unsigned char pad[3];
1830 +};
1831 +
1832 +struct vendor4_fru {
1833 + unsigned char number[8];
1834 + unsigned char part[8];
1835 + unsigned char version[8];
1836 + unsigned char pad[3];
1837 +};
1838 +
1839 +union oemfru_t {
1840 + struct vendor1_fru vendor1_fru;
1841 + struct vendor2_fru vendor2_fru;
1842 + struct vendor3_fru vendor3_fru;
1843 + struct vendor4_fru vendor4_fru;
1844 +};
1845
1846 /*
1847 SLIC EEPROM structure for Mojave
1848 */
1849 -typedef struct _slic_eeprom {
1850 +struct slic_eeprom {
1851 ushort Id; /* 00 EEPROM/FLASH Magic code 'A5A5'*/
1852 ushort EecodeSize; /* 01 Size of EEPROM Codes (bytes * 4)*/
1853 ushort FlashSize; /* 02 Flash size */
1854 ushort EepromSize; /* 03 EEPROM Size */
1855 ushort VendorId; /* 04 Vendor ID */
1856 ushort DeviceId; /* 05 Device ID */
1857 - uchar RevisionId; /* 06 Revision ID */
1858 - uchar ClassCode[3]; /* 07 Class Code */
1859 - uchar DbgIntPin; /* 08 Debug Interrupt pin */
1860 - uchar NetIntPin0; /* Network Interrupt Pin */
1861 - uchar MinGrant; /* 09 Minimum grant */
1862 - uchar MaxLat; /* Maximum Latency */
1863 + unsigned char RevisionId; /* 06 Revision ID */
1864 + unsigned char ClassCode[3]; /* 07 Class Code */
1865 + unsigned char DbgIntPin; /* 08 Debug Interrupt pin */
1866 + unsigned char NetIntPin0; /* Network Interrupt Pin */
1867 + unsigned char MinGrant; /* 09 Minimum grant */
1868 + unsigned char MaxLat; /* Maximum Latency */
1869 ushort PciStatus; /* 10 PCI Status */
1870 ushort SubSysVId; /* 11 Subsystem Vendor Id */
1871 ushort SubSysId; /* 12 Subsystem ID */
1872 @@ -739,58 +732,60 @@ typedef struct _slic_eeprom {
1873 ushort DramRomFn; /* 14 Dram/Rom function */
1874 ushort DSize2Pci; /* 15 DRAM size to PCI (bytes * 64K) */
1875 ushort RSize2Pci; /* 16 ROM extension size to PCI (bytes * 4k) */
1876 - uchar NetIntPin1; /* 17 Network Interface Pin 1 (simba/leone only) */
1877 - uchar NetIntPin2; /* Network Interface Pin 2 (simba/leone only) */
1878 + unsigned char NetIntPin1;/* 17 Network Interface Pin 1
1879 + (simba/leone only) */
1880 + unsigned char NetIntPin2; /*Network Interface Pin 2 (simba/leone only)*/
1881 union {
1882 - uchar NetIntPin3;/* 18 Network Interface Pin 3 (simba only) */
1883 - uchar FreeTime;/* FreeTime setting (leone/mojave only) */
1884 + unsigned char NetIntPin3;/*18 Network Interface Pin 3
1885 + (simba only)*/
1886 + unsigned char FreeTime;/*FreeTime setting (leone/mojave only) */
1887 } u1;
1888 - uchar TBIctl; /* 10-bit interface control (Mojave only) */
1889 + unsigned char TBIctl; /* 10-bit interface control (Mojave only) */
1890 ushort DramSize; /* 19 DRAM size (bytes * 64k) */
1891 union {
1892 struct {
1893 /* Mac Interface Specific portions */
1894 - slic_config_mac_t MacInfo[SLIC_NBR_MACS];
1895 + struct slic_config_mac MacInfo[SLIC_NBR_MACS];
1896 } mac; /* MAC access for all boards */
1897 struct {
1898 /* use above struct for MAC access */
1899 - slic_config_mac_t pad[SLIC_NBR_MACS - 1];
1900 + struct slic_config_mac pad[SLIC_NBR_MACS - 1];
1901 ushort DeviceId2; /* Device ID for 2nd
1902 PCI function */
1903 - uchar IntPin2; /* Interrupt pin for
1904 + unsigned char IntPin2; /* Interrupt pin for
1905 2nd PCI function */
1906 - uchar ClassCode2[3]; /* Class Code for 2nd
1907 + unsigned char ClassCode2[3]; /* Class Code for 2nd
1908 PCI function */
1909 } mojave; /* 2nd function access for gigabit board */
1910 } u2;
1911 ushort CfgByte6; /* Config Byte 6 */
1912 ushort PMECapab; /* Power Mgment capabilities */
1913 ushort NwClkCtrls; /* NetworkClockControls */
1914 - uchar FruFormat; /* Alacritech FRU format type */
1915 - atk_fru_t AtkFru; /* Alacritech FRU information */
1916 - uchar OemFruFormat; /* optional OEM FRU format type */
1917 - oemfru_t OemFru; /* optional OEM FRU information */
1918 - uchar Pad[4]; /* Pad to 128 bytes - includes 2 cksum bytes
1919 + unsigned char FruFormat; /* Alacritech FRU format type */
1920 + struct atk_fru AtkFru; /* Alacritech FRU information */
1921 + unsigned char OemFruFormat; /* optional OEM FRU format type */
1922 + union oemfru_t OemFru; /* optional OEM FRU information */
1923 + unsigned char Pad[4]; /* Pad to 128 bytes - includes 2 cksum bytes
1924 *(if OEM FRU info exists) and two unusable
1925 * bytes at the end */
1926 -} slic_eeprom_t, *pslic_eeprom_t;
1927 +};
1928
1929 /* SLIC EEPROM structure for Oasis */
1930 -typedef struct _oslic_eeprom_t {
1931 +struct oslic_eeprom {
1932 ushort Id; /* 00 EEPROM/FLASH Magic code 'A5A5' */
1933 ushort EecodeSize; /* 01 Size of EEPROM Codes (bytes * 4)*/
1934 ushort FlashConfig0; /* 02 Flash Config for SPI device 0 */
1935 ushort FlashConfig1; /* 03 Flash Config for SPI device 1 */
1936 ushort VendorId; /* 04 Vendor ID */
1937 ushort DeviceId; /* 05 Device ID (function 0) */
1938 - uchar RevisionId; /* 06 Revision ID */
1939 - uchar ClassCode[3]; /* 07 Class Code for PCI function 0 */
1940 - uchar IntPin1; /* 08 Interrupt pin for PCI function 1*/
1941 - uchar ClassCode2[3]; /* 09 Class Code for PCI function 1 */
1942 - uchar IntPin2; /* 10 Interrupt pin for PCI function 2*/
1943 - uchar IntPin0; /* Interrupt pin for PCI function 0*/
1944 - uchar MinGrant; /* 11 Minimum grant */
1945 - uchar MaxLat; /* Maximum Latency */
1946 + unsigned char RevisionId; /* 06 Revision ID */
1947 + unsigned char ClassCode[3]; /* 07 Class Code for PCI function 0 */
1948 + unsigned char IntPin1; /* 08 Interrupt pin for PCI function 1*/
1949 + unsigned char ClassCode2[3]; /* 09 Class Code for PCI function 1 */
1950 + unsigned char IntPin2; /* 10 Interrupt pin for PCI function 2*/
1951 + unsigned char IntPin0; /* Interrupt pin for PCI function 0*/
1952 + unsigned char MinGrant; /* 11 Minimum grant */
1953 + unsigned char MaxLat; /* Maximum Latency */
1954 ushort SubSysVId; /* 12 Subsystem Vendor Id */
1955 ushort SubSysId; /* 13 Subsystem ID */
1956 ushort FlashSize; /* 14 Flash size (bytes / 4K) */
1957 @@ -801,8 +796,8 @@ typedef struct _oslic_eeprom_t {
1958 ushort DeviceId2; /* 18 Device Id (function 2) */
1959 ushort CfgByte6; /* 19 Device Status Config Bytes 6-7 */
1960 ushort PMECapab; /* 20 Power Mgment capabilities */
1961 - uchar MSICapab; /* 21 MSI capabilities */
1962 - uchar ClockDivider; /* Clock divider */
1963 + unsigned char MSICapab; /* 21 MSI capabilities */
1964 + unsigned char ClockDivider; /* Clock divider */
1965 ushort PciStatusLow; /* 22 PCI Status bits 15:0 */
1966 ushort PciStatusHigh; /* 23 PCI Status bits 31:16 */
1967 ushort DramConfigLow; /* 24 DRAM Configuration bits 15:0 */
1968 @@ -810,18 +805,18 @@ typedef struct _oslic_eeprom_t {
1969 ushort DramSize; /* 26 DRAM size (bytes / 64K) */
1970 ushort GpioTbiCtl;/* 27 GPIO/TBI controls for functions 1/0 */
1971 ushort EepromSize; /* 28 EEPROM Size */
1972 - slic_config_mac_t MacInfo[2]; /* 29 MAC addresses (2 ports) */
1973 - uchar FruFormat; /* 35 Alacritech FRU format type */
1974 - atk_fru_t AtkFru; /* Alacritech FRU information */
1975 - uchar OemFruFormat; /* optional OEM FRU format type */
1976 - oemfru_t OemFru; /* optional OEM FRU information */
1977 - uchar Pad[4]; /* Pad to 128 bytes - includes 2 checksum bytes
1978 + struct slic_config_mac MacInfo[2]; /* 29 MAC addresses (2 ports) */
1979 + unsigned char FruFormat; /* 35 Alacritech FRU format type */
1980 + struct atk_fru AtkFru; /* Alacritech FRU information */
1981 + unsigned char OemFruFormat; /* optional OEM FRU format type */
1982 + union oemfru_t OemFru; /* optional OEM FRU information */
1983 + unsigned char Pad[4]; /* Pad to 128 bytes - includes 2 checksum bytes
1984 * (if OEM FRU info exists) and two unusable
1985 * bytes at the end
1986 */
1987 -} oslic_eeprom_t, *poslic_eeprom_t;
1988 +};
1989
1990 -#define MAX_EECODE_SIZE sizeof(slic_eeprom_t)
1991 +#define MAX_EECODE_SIZE sizeof(struct slic_eeprom)
1992 #define MIN_EECODE_SIZE 0x62 /* code size without optional OEM FRU stuff */
1993
1994 /* SLIC CONFIG structure
1995 @@ -830,20 +825,20 @@ typedef struct _oslic_eeprom_t {
1996 board types. It is filled in from the appropriate EEPROM structure
1997 by SlicGetConfigData().
1998 */
1999 -typedef struct _slic_config_t {
2000 - boolean EepromValid; /* Valid EEPROM flag (checksum good?) */
2001 +struct slic_config {
2002 + bool EepromValid; /* Valid EEPROM flag (checksum good?) */
2003 ushort DramSize; /* DRAM size (bytes / 64K) */
2004 - slic_config_mac_t MacInfo[SLIC_NBR_MACS]; /* MAC addresses */
2005 - uchar FruFormat; /* Alacritech FRU format type */
2006 - atk_fru_t AtkFru; /* Alacritech FRU information */
2007 - uchar OemFruFormat; /* optional OEM FRU format type */
2008 - union {
2009 - vendor1_fru_t vendor1_fru;
2010 - vendor2_fru_t vendor2_fru;
2011 - vendor3_fru_t vendor3_fru;
2012 - vendor4_fru_t vendor4_fru;
2013 - } OemFru;
2014 -} slic_config_t, *pslic_config_t;
2015 + struct slic_config_mac MacInfo[SLIC_NBR_MACS]; /* MAC addresses */
2016 + unsigned char FruFormat; /* Alacritech FRU format type */
2017 + struct atk_fru AtkFru; /* Alacritech FRU information */
2018 + unsigned char OemFruFormat; /* optional OEM FRU format type */
2019 + union {
2020 + struct vendor1_fru vendor1_fru;
2021 + struct vendor2_fru vendor2_fru;
2022 + struct vendor3_fru vendor3_fru;
2023 + struct vendor4_fru vendor4_fru;
2024 + } OemFru;
2025 +};
2026
2027 #pragma pack()
2028
2029 diff --git a/drivers/staging/slicoss/slicinc.h b/drivers/staging/slicoss/slicinc.h
2030 index 9910306..610c1ab 100644
2031 --- a/drivers/staging/slicoss/slicinc.h
2032 +++ b/drivers/staging/slicoss/slicinc.h
2033 @@ -2,7 +2,6 @@
2034 *
2035 * Copyright (c) 2000-2002 Alacritech, Inc. All rights reserved.
2036 *
2037 - * $Id: slicinc.h,v 1.4 2006/07/14 16:42:56 mook Exp $
2038 *
2039 * Redistribution and use in source and binary forms, with or without
2040 * modification, are permitted provided that the following conditions
2041 @@ -48,164 +47,135 @@
2042 #include "slichw.h"
2043 #include "slic.h"
2044
2045 -int slic_entry_probe(struct pci_dev *pcidev,
2046 +static int slic_entry_probe(struct pci_dev *pcidev,
2047 const struct pci_device_id *ent);
2048 -int slic_init(struct pci_dev *pcidev,
2049 - const struct pci_device_id *pci_tbl_entry,
2050 - long memaddr,
2051 - int chip_idx,
2052 - int acpi_idle_state);
2053 -void slic_entry_remove(struct pci_dev *pcidev);
2054 +static void slic_entry_remove(struct pci_dev *pcidev);
2055
2056 -void slic_init_driver(void);
2057 -int slic_entry_open(struct net_device *dev);
2058 -int slic_entry_halt(struct net_device *dev);
2059 -int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
2060 -int slic_xmit_start(struct sk_buff *skb, struct net_device *dev);
2061 -void slic_xmit_fail(p_adapter_t adapter,
2062 +static void slic_init_driver(void);
2063 +static int slic_entry_open(struct net_device *dev);
2064 +static int slic_entry_halt(struct net_device *dev);
2065 +static int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
2066 +static int slic_xmit_start(struct sk_buff *skb, struct net_device *dev);
2067 +static void slic_xmit_fail(struct adapter *adapter,
2068 struct sk_buff *skb,
2069 - pvoid cmd,
2070 - ulong32 skbtype,
2071 - ulong32 status);
2072 -void slic_xmit_timeout(struct net_device *dev);
2073 -void slic_config_pci(struct pci_dev *pcidev);
2074 -struct sk_buff *slic_rcvqueue_getnext(p_adapter_t adapter);
2075 + void *cmd,
2076 + u32 skbtype,
2077 + u32 status);
2078 +static void slic_xmit_timeout(struct net_device *dev);
2079 +static void slic_config_pci(struct pci_dev *pcidev);
2080 +static struct sk_buff *slic_rcvqueue_getnext(struct adapter *adapter);
2081
2082 -inline void slic_reg32_write(void __iomem *reg, ulong32 value, uint flush);
2083 -inline void slic_reg64_write(p_adapter_t adapter, void __iomem *reg,
2084 - ulong32 value, void __iomem *regh, ulong32 paddrh, uint flush);
2085 -inline ulong32 slic_reg32_read(pulong32 reg, uint flush);
2086 -inline ulong32 slic_reg16_read(pulong32 reg, uint flush);
2087 +static inline void slic_reg32_write(void __iomem *reg, u32 value, uint flush);
2088 +static inline void slic_reg64_write(struct adapter *adapter, void __iomem *reg,
2089 + u32 value, void __iomem *regh, u32 paddrh, uint flush);
2090
2091 #if SLIC_GET_STATS_ENABLED
2092 -struct net_device_stats *slic_get_stats(struct net_device *dev);
2093 +static struct net_device_stats *slic_get_stats(struct net_device *dev);
2094 #endif
2095
2096 -int slic_mac_set_address(struct net_device *dev, pvoid ptr);
2097 +static int slic_mac_set_address(struct net_device *dev, void *ptr);
2098 +static void slic_rcv_handler(struct adapter *adapter);
2099 +static void slic_link_event_handler(struct adapter *adapter);
2100 +static void slic_xmit_complete(struct adapter *adapter);
2101 +static void slic_upr_request_complete(struct adapter *adapter, u32 isr);
2102 +static int slic_rspqueue_init(struct adapter *adapter);
2103 +static int slic_rspqueue_reset(struct adapter *adapter);
2104 +static void slic_rspqueue_free(struct adapter *adapter);
2105 +static struct slic_rspbuf *slic_rspqueue_getnext(struct adapter *adapter);
2106 +static void slic_cmdqmem_init(struct adapter *adapter);
2107 +static void slic_cmdqmem_free(struct adapter *adapter);
2108 +static u32 *slic_cmdqmem_addpage(struct adapter *adapter);
2109 +static int slic_cmdq_init(struct adapter *adapter);
2110 +static void slic_cmdq_free(struct adapter *adapter);
2111 +static void slic_cmdq_reset(struct adapter *adapter);
2112 +static void slic_cmdq_addcmdpage(struct adapter *adapter, u32 *page);
2113 +static void slic_cmdq_getdone(struct adapter *adapter);
2114 +static void slic_cmdq_putdone(struct adapter *adapter,
2115 + struct slic_hostcmd *cmd);
2116 +static void slic_cmdq_putdone_irq(struct adapter *adapter,
2117 + struct slic_hostcmd *cmd);
2118 +static struct slic_hostcmd *slic_cmdq_getfree(struct adapter *adapter);
2119 +static int slic_rcvqueue_init(struct adapter *adapter);
2120 +static int slic_rcvqueue_reset(struct adapter *adapter);
2121 +static int slic_rcvqueue_fill(struct adapter *adapter);
2122 +static u32 slic_rcvqueue_reinsert(struct adapter *adapter, struct sk_buff *skb);
2123 +static void slic_rcvqueue_free(struct adapter *adapter);
2124 +static void slic_rcv_handle_error(struct adapter *adapter,
2125 + struct slic_rcvbuf *rcvbuf);
2126 +static void slic_adapter_set_hwaddr(struct adapter *adapter);
2127 +static void slic_card_halt(struct sliccard *card, struct adapter *adapter);
2128 +static int slic_card_init(struct sliccard *card, struct adapter *adapter);
2129 +static void slic_intagg_set(struct adapter *adapter, u32 value);
2130 +static int slic_card_download(struct adapter *adapter);
2131 +static u32 slic_card_locate(struct adapter *adapter);
2132
2133 -int slicproc_card_read(char *page, char **start, off_t off, int count,
2134 - int *eof, void *data);
2135 -int slicproc_card_write(struct file *file, const char __user *buffer,
2136 - ulong count, void *data);
2137 -void slicproc_card_create(p_sliccard_t card);
2138 -void slicproc_card_destroy(p_sliccard_t card);
2139 -int slicproc_adapter_read(char *page, char **start, off_t off, int count,
2140 - int *eof, void *data);
2141 -int slicproc_adapter_write(struct file *file, const char __user *buffer,
2142 - ulong count, void *data);
2143 -void slicproc_adapter_create(p_adapter_t adapter);
2144 -void slicproc_adapter_destroy(p_adapter_t adapter);
2145 -void slicproc_create(void);
2146 -void slicproc_destroy(void);
2147 -
2148 -void slic_interrupt_process(p_adapter_t adapter, ulong32 isr);
2149 -void slic_rcv_handler(p_adapter_t adapter);
2150 -void slic_upr_handler(p_adapter_t adapter);
2151 -void slic_link_event_handler(p_adapter_t adapter);
2152 -void slic_xmit_complete(p_adapter_t adapter);
2153 -void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr);
2154 -int slic_rspqueue_init(p_adapter_t adapter);
2155 -int slic_rspqueue_reset(p_adapter_t adapter);
2156 -void slic_rspqueue_free(p_adapter_t adapter);
2157 -p_slic_rspbuf_t slic_rspqueue_getnext(p_adapter_t adapter);
2158 -void slic_cmdqmem_init(p_adapter_t adapter);
2159 -void slic_cmdqmem_free(p_adapter_t adapter);
2160 -pulong32 slic_cmdqmem_addpage(p_adapter_t adapter);
2161 -int slic_cmdq_init(p_adapter_t adapter);
2162 -void slic_cmdq_free(p_adapter_t adapter);
2163 -void slic_cmdq_reset(p_adapter_t adapter);
2164 -void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page);
2165 -void slic_cmdq_getdone(p_adapter_t adapter);
2166 -void slic_cmdq_putdone(p_adapter_t adapter, p_slic_hostcmd_t cmd);
2167 -void slic_cmdq_putdone_irq(p_adapter_t adapter, p_slic_hostcmd_t cmd);
2168 -p_slic_hostcmd_t slic_cmdq_getfree(p_adapter_t adapter);
2169 -int slic_rcvqueue_init(p_adapter_t adapter);
2170 -int slic_rcvqueue_reset(p_adapter_t adapter);
2171 -int slic_rcvqueue_fill(p_adapter_t adapter);
2172 -ulong32 slic_rcvqueue_reinsert(p_adapter_t adapter, struct sk_buff *skb);
2173 -void slic_rcvqueue_free(p_adapter_t adapter);
2174 -void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf);
2175 -void slic_adapter_set_hwaddr(p_adapter_t adapter);
2176 -void slic_card_halt(p_sliccard_t card, p_adapter_t adapter);
2177 -int slic_card_init(p_sliccard_t card, p_adapter_t adapter);
2178 -void slic_intagg_set(p_adapter_t adapter, ulong32 value);
2179 -int slic_card_download(p_adapter_t adapter);
2180 -ulong32 slic_card_locate(p_adapter_t adapter);
2181 -int slic_card_removeadapter(p_adapter_t adapter);
2182 -void slic_card_remaster(p_adapter_t adapter);
2183 -void slic_card_softreset(p_adapter_t adapter);
2184 -void slic_card_up(p_adapter_t adapter);
2185 -void slic_card_down(p_adapter_t adapter);
2186 -
2187 -void slic_if_stop_queue(p_adapter_t adapter);
2188 -void slic_if_start_queue(p_adapter_t adapter);
2189 -int slic_if_init(p_adapter_t adapter);
2190 -void slic_adapter_close(p_adapter_t adapter);
2191 -int slic_adapter_allocresources(p_adapter_t adapter);
2192 -void slic_adapter_freeresources(p_adapter_t adapter);
2193 -void slic_link_config(p_adapter_t adapter, ulong32 linkspeed,
2194 - ulong32 linkduplex);
2195 -void slic_unmap_mmio_space(p_adapter_t adapter);
2196 -void slic_card_cleanup(p_sliccard_t card);
2197 -void slic_init_cleanup(p_adapter_t adapter);
2198 -void slic_card_reclaim_buffers(p_adapter_t adapter);
2199 -void slic_soft_reset(p_adapter_t adapter);
2200 -void slic_card_reset(p_adapter_t adapter);
2201 -boolean slic_mac_filter(p_adapter_t adapter, p_ether_header ether_frame);
2202 -void slic_mac_address_config(p_adapter_t adapter);
2203 -void slic_mac_config(p_adapter_t adapter);
2204 -void slic_mcast_set_mask(p_adapter_t adapter);
2205 -void slic_mac_setmcastaddrs(p_adapter_t adapter);
2206 -int slic_mcast_add_list(p_adapter_t adapter, pchar address);
2207 -uchar slic_mcast_get_mac_hash(pchar macaddr);
2208 -void slic_mcast_set_bit(p_adapter_t adapter, pchar address);
2209 -void slic_config_set(p_adapter_t adapter, boolean linkchange);
2210 -void slic_config_clear(p_adapter_t adapter);
2211 -void slic_config_get(p_adapter_t adapter, ulong32 config, ulong32 configh);
2212 -void slic_timer_get_stats(ulong device);
2213 -void slic_timer_load_check(ulong context);
2214 -void slic_timer_ping(ulong dev);
2215 -void slic_stall_msec(int stall);
2216 -void slic_stall_usec(int stall);
2217 -void slic_assert_fail(void);
2218 -ushort slic_eeprom_cksum(pchar m, int len);
2219 +static void slic_if_stop_queue(struct adapter *adapter);
2220 +static void slic_if_start_queue(struct adapter *adapter);
2221 +static int slic_if_init(struct adapter *adapter);
2222 +static int slic_adapter_allocresources(struct adapter *adapter);
2223 +static void slic_adapter_freeresources(struct adapter *adapter);
2224 +static void slic_link_config(struct adapter *adapter, u32 linkspeed,
2225 + u32 linkduplex);
2226 +static void slic_unmap_mmio_space(struct adapter *adapter);
2227 +static void slic_card_cleanup(struct sliccard *card);
2228 +static void slic_init_cleanup(struct adapter *adapter);
2229 +static void slic_soft_reset(struct adapter *adapter);
2230 +static void slic_card_reset(struct adapter *adapter);
2231 +static bool slic_mac_filter(struct adapter *adapter,
2232 + struct ether_header *ether_frame);
2233 +static void slic_mac_address_config(struct adapter *adapter);
2234 +static void slic_mac_config(struct adapter *adapter);
2235 +static void slic_mcast_set_mask(struct adapter *adapter);
2236 +static int slic_mcast_add_list(struct adapter *adapter, char *address);
2237 +static unsigned char slic_mcast_get_mac_hash(char *macaddr);
2238 +static void slic_mcast_set_bit(struct adapter *adapter, char *address);
2239 +static void slic_config_set(struct adapter *adapter, bool linkchange);
2240 +static void slic_config_clear(struct adapter *adapter);
2241 +static void slic_config_get(struct adapter *adapter, u32 config,
2242 + u32 configh);
2243 +static void slic_timer_get_stats(ulong device);
2244 +static void slic_timer_load_check(ulong context);
2245 +static void slic_timer_ping(ulong dev);
2246 +static void slic_assert_fail(void);
2247 +static ushort slic_eeprom_cksum(char *m, int len);
2248 /* upr */
2249 -void slic_upr_start(p_adapter_t adapter);
2250 -void slic_link_upr_complete(p_adapter_t adapter, ulong32 Isr);
2251 -int slic_upr_request(p_adapter_t adapter,
2252 - ulong32 upr_request,
2253 - ulong32 upr_data,
2254 - ulong32 upr_data_h,
2255 - ulong32 upr_buffer,
2256 - ulong32 upr_buffer_h);
2257 -int slic_upr_queue_request(p_adapter_t adapter,
2258 - ulong32 upr_request,
2259 - ulong32 upr_data,
2260 - ulong32 upr_data_h,
2261 - ulong32 upr_buffer,
2262 - ulong32 upr_buffer_h);
2263 -void slic_mcast_set_list(struct net_device *dev);
2264 -void slic_mcast_init_crc32(void);
2265 +static void slic_upr_start(struct adapter *adapter);
2266 +static void slic_link_upr_complete(struct adapter *adapter, u32 Isr);
2267 +static int slic_upr_request(struct adapter *adapter,
2268 + u32 upr_request,
2269 + u32 upr_data,
2270 + u32 upr_data_h,
2271 + u32 upr_buffer,
2272 + u32 upr_buffer_h);
2273 +static int slic_upr_queue_request(struct adapter *adapter,
2274 + u32 upr_request,
2275 + u32 upr_data,
2276 + u32 upr_data_h,
2277 + u32 upr_buffer,
2278 + u32 upr_buffer_h);
2279 +static void slic_mcast_set_list(struct net_device *dev);
2280 +static void slic_mcast_init_crc32(void);
2281
2282 #if SLIC_DUMP_ENABLED
2283 -int slic_dump_thread(void *context);
2284 -uint slic_init_dump_thread(p_sliccard_t card);
2285 -uchar slic_get_dump_index(pchar path);
2286 -ulong32 slic_dump_card(p_sliccard_t card, boolean resume);
2287 -ulong32 slic_dump_halt(p_sliccard_t card, uchar proc);
2288 -ulong32 slic_dump_reg(p_sliccard_t card, uchar proc);
2289 -ulong32 slic_dump_data(p_sliccard_t card, ulong32 addr,
2290 - ushort count, uchar desc);
2291 -ulong32 slic_dump_queue(p_sliccard_t card, ulong32 buf_phys,
2292 - ulong32 buf_physh, ulong32 queue);
2293 -ulong32 slic_dump_load_queue(p_sliccard_t card, ulong32 data, ulong32 queue);
2294 -ulong32 slic_dump_cam(p_sliccard_t card, ulong32 addr,
2295 - ulong32 count, uchar desc);
2296 +static int slic_dump_thread(void *context);
2297 +static uint slic_init_dump_thread(struct sliccard *card);
2298 +static unsigned char slic_get_dump_index(char *path);
2299 +static u32 slic_dump_card(struct sliccard *card, bool resume);
2300 +static u32 slic_dump_halt(struct sliccard *card, unsigned char proc);
2301 +static u32 slic_dump_reg(struct sliccard *card, unsigned char proc);
2302 +static u32 slic_dump_data(struct sliccard *card, u32 addr,
2303 + ushort count, unsigned char desc);
2304 +static u32 slic_dump_queue(struct sliccard *card, u32 buf_phys,
2305 + u32 buf_physh, u32 queue);
2306 +static u32 slic_dump_load_queue(struct sliccard *card, u32 data,
2307 + u32 queue);
2308 +static u32 slic_dump_cam(struct sliccard *card, u32 addr,
2309 + u32 count, unsigned char desc);
2310
2311 -ulong32 slic_dump_resume(p_sliccard_t card, uchar proc);
2312 -ulong32 slic_dump_send_cmd(p_sliccard_t card, ulong32 cmd_phys,
2313 - ulong32 cmd_physh, ulong32 buf_phys,
2314 - ulong32 buf_physh);
2315 +static u32 slic_dump_resume(struct sliccard *card, unsigned char proc);
2316 +static u32 slic_dump_send_cmd(struct sliccard *card, u32 cmd_phys,
2317 + u32 cmd_physh, u32 buf_phys,
2318 + u32 buf_physh);
2319
2320 #define create_file(x) STATUS_SUCCESS
2321 #define write_file(w, x, y, z) STATUS_SUCCESS
2322 diff --git a/drivers/staging/slicoss/slicoss.c b/drivers/staging/slicoss/slicoss.c
2323 index a8c2648..eb61565 100644
2324 --- a/drivers/staging/slicoss/slicoss.c
2325 +++ b/drivers/staging/slicoss/slicoss.c
2326 @@ -143,7 +143,7 @@ static int slic_debug = 1;
2327 static int debug = -1;
2328 static struct net_device *head_netdevice;
2329
2330 -base_driver_t slic_global = { {}, 0, 0, 0, 1, NULL, NULL };
2331 +static struct base_driver slic_global = { {}, 0, 0, 0, 1, NULL, NULL };
2332 static int intagg_delay = 100;
2333 static u32 dynamic_intagg;
2334 static int errormsg;
2335 @@ -183,44 +183,49 @@ MODULE_DEVICE_TABLE(pci, slic_pci_tbl);
2336
2337 #define SLIC_GET_SLIC_HANDLE(_adapter, _pslic_handle) \
2338 { \
2339 - SLIC_ACQUIRE_IRQ_SPINLOCK(_adapter->handle_lock); \
2340 + spin_lock_irqsave(&_adapter->handle_lock.lock, \
2341 + _adapter->handle_lock.flags); \
2342 _pslic_handle = _adapter->pfree_slic_handles; \
2343 if (_pslic_handle) { \
2344 ASSERT(_pslic_handle->type == SLIC_HANDLE_FREE); \
2345 _adapter->pfree_slic_handles = _pslic_handle->next; \
2346 } \
2347 - SLIC_RELEASE_IRQ_SPINLOCK(_adapter->handle_lock); \
2348 + spin_unlock_irqrestore(&_adapter->handle_lock.lock, \
2349 + _adapter->handle_lock.flags); \
2350 }
2351
2352 #define SLIC_FREE_SLIC_HANDLE(_adapter, _pslic_handle) \
2353 { \
2354 _pslic_handle->type = SLIC_HANDLE_FREE; \
2355 - SLIC_ACQUIRE_IRQ_SPINLOCK(_adapter->handle_lock); \
2356 + spin_lock_irqsave(&_adapter->handle_lock.lock, \
2357 + _adapter->handle_lock.flags); \
2358 _pslic_handle->next = _adapter->pfree_slic_handles; \
2359 _adapter->pfree_slic_handles = _pslic_handle; \
2360 - SLIC_RELEASE_IRQ_SPINLOCK(_adapter->handle_lock); \
2361 + spin_unlock_irqrestore(&_adapter->handle_lock.lock, \
2362 + _adapter->handle_lock.flags); \
2363 }
2364
2365 static void slic_debug_init(void);
2366 static void slic_debug_cleanup(void);
2367 -static void slic_debug_adapter_create(p_adapter_t adapter);
2368 -static void slic_debug_adapter_destroy(p_adapter_t adapter);
2369 -static void slic_debug_card_create(p_sliccard_t card);
2370 -static void slic_debug_card_destroy(p_sliccard_t card);
2371 +static void slic_debug_adapter_create(struct adapter *adapter);
2372 +static void slic_debug_adapter_destroy(struct adapter *adapter);
2373 +static void slic_debug_card_create(struct sliccard *card);
2374 +static void slic_debug_card_destroy(struct sliccard *card);
2375
2376 -inline void slic_reg32_write(void __iomem *reg, ulong32 value, uint flush)
2377 +static inline void slic_reg32_write(void __iomem *reg, u32 value, uint flush)
2378 {
2379 writel(value, reg);
2380 if (flush)
2381 mb();
2382 }
2383
2384 -inline void slic_reg64_write(p_adapter_t adapter,
2385 +static inline void slic_reg64_write(struct adapter *adapter,
2386 void __iomem *reg,
2387 - ulong32 value,
2388 - void __iomem *regh, ulong32 paddrh, uint flush)
2389 + u32 value,
2390 + void __iomem *regh, u32 paddrh, uint flush)
2391 {
2392 - SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->bit64reglock);
2393 + spin_lock_irqsave(&adapter->bit64reglock.lock,
2394 + adapter->bit64reglock.flags);
2395 if (paddrh != adapter->curaddrupper) {
2396 adapter->curaddrupper = paddrh;
2397 writel(paddrh, regh);
2398 @@ -228,31 +233,22 @@ inline void slic_reg64_write(p_adapter_t adapter,
2399 writel(value, reg);
2400 if (flush)
2401 mb();
2402 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->bit64reglock);
2403 + spin_unlock_irqrestore(&adapter->bit64reglock.lock,
2404 + adapter->bit64reglock.flags);
2405 }
2406
2407 -inline ulong32 slic_reg32_read(u32 __iomem *reg, uint flush)
2408 -{
2409 - return readl(reg);
2410 -}
2411 -
2412 -inline ulong32 slic_reg16_read(pulong32 reg, uint flush)
2413 -{
2414 - return (ushort) readw(reg);
2415 -}
2416 -
2417 -void slic_init_driver(void)
2418 +static void slic_init_driver(void)
2419 {
2420 if (slic_first_init) {
2421 DBG_MSG("slicoss: %s slic_first_init set jiffies[%lx]\n",
2422 __func__, jiffies);
2423 slic_first_init = 0;
2424 - SLIC_INIT_SPINLOCK(slic_global.driver_lock);
2425 + spin_lock_init(&slic_global.driver_lock.lock);
2426 slic_debug_init();
2427 }
2428 }
2429
2430 -static void slic_dbg_macaddrs(p_adapter_t adapter)
2431 +static void slic_dbg_macaddrs(struct adapter *adapter)
2432 {
2433 DBG_MSG(" (%s) curr %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
2434 adapter->netdev->name, adapter->currmacaddr[0],
2435 @@ -267,7 +263,8 @@ static void slic_dbg_macaddrs(p_adapter_t adapter)
2436 }
2437
2438 #ifdef DEBUG_REGISTER_TRACE
2439 -static void slic_dbg_register_trace(p_adapter_t adapter, p_sliccard_t card)
2440 +static void slic_dbg_register_trace(struct adapter *adapter,
2441 + struct sliccard *card)
2442 {
2443 uint i;
2444
2445 @@ -287,9 +284,8 @@ static void slic_init_adapter(struct net_device *netdev,
2446 void __iomem *memaddr, int chip_idx)
2447 {
2448 ushort index;
2449 - pslic_handle_t pslic_handle;
2450 - p_adapter_t adapter = (p_adapter_t) netdev_priv(netdev);
2451 -
2452 + struct slic_handle *pslic_handle;
2453 + struct adapter *adapter = (struct adapter *)netdev_priv(netdev);
2454 /*
2455 DBG_MSG("slicoss: %s (%s)\n netdev [%p]\n adapter[%p]\n "
2456 "pcidev [%p]\n", __func__, netdev->name, netdev, adapter, pcidev);*/
2457 @@ -301,7 +297,7 @@ static void slic_init_adapter(struct net_device *netdev,
2458 adapter->slotnumber = ((pcidev->devfn >> 3) & 0x1F);
2459 adapter->functionnumber = (pcidev->devfn & 0x7);
2460 adapter->memorylength = pci_resource_len(pcidev, 0);
2461 - adapter->slic_regs = (p_slic_regs_t) memaddr;
2462 + adapter->slic_regs = (__iomem struct slic_regs *)memaddr;
2463 adapter->irq = pcidev->irq;
2464 /* adapter->netdev = netdev;*/
2465 adapter->next_netdevice = head_netdevice;
2466 @@ -310,11 +306,11 @@ static void slic_init_adapter(struct net_device *netdev,
2467 adapter->port = 0; /*adapter->functionnumber;*/
2468 adapter->cardindex = adapter->port;
2469 adapter->memorybase = memaddr;
2470 - SLIC_INIT_SPINLOCK(adapter->upr_lock);
2471 - SLIC_INIT_SPINLOCK(adapter->bit64reglock);
2472 - SLIC_INIT_SPINLOCK(adapter->adapter_lock);
2473 - SLIC_INIT_SPINLOCK(adapter->reset_lock);
2474 - SLIC_INIT_SPINLOCK(adapter->handle_lock);
2475 + spin_lock_init(&adapter->upr_lock.lock);
2476 + spin_lock_init(&adapter->bit64reglock.lock);
2477 + spin_lock_init(&adapter->adapter_lock.lock);
2478 + spin_lock_init(&adapter->reset_lock.lock);
2479 + spin_lock_init(&adapter->handle_lock.lock);
2480
2481 adapter->card_size = 1;
2482 /*
2483 @@ -335,36 +331,36 @@ static void slic_init_adapter(struct net_device *netdev,
2484 /*
2485 DBG_MSG(".........\nix[%d] phandle[%p] pfree[%p] next[%p]\n",
2486 index, pslic_handle, adapter->pfree_slic_handles, pslic_handle->next);*/
2487 - adapter->pshmem = (p_slic_shmem_t) pci_alloc_consistent(adapter->pcidev,
2488 - sizeof
2489 - (slic_shmem_t),
2490 - &adapter->
2491 - phys_shmem);
2492 + adapter->pshmem = (struct slic_shmem *)
2493 + pci_alloc_consistent(adapter->pcidev,
2494 + sizeof(struct slic_shmem *),
2495 + &adapter->
2496 + phys_shmem);
2497 /*
2498 DBG_MSG("slicoss: %s (%s)\n pshmem [%p]\n phys_shmem[%p]\n"\
2499 "slic_regs [%p]\n", __func__, netdev->name, adapter->pshmem,
2500 - (pvoid)adapter->phys_shmem, adapter->slic_regs);
2501 + (void *)adapter->phys_shmem, adapter->slic_regs);
2502 */
2503 ASSERT(adapter->pshmem);
2504
2505 - SLIC_ZERO_MEMORY(adapter->pshmem, sizeof(slic_shmem_t));
2506 + memset(adapter->pshmem, 0, sizeof(struct slic_shmem));
2507
2508 return;
2509 }
2510
2511 -int __devinit slic_entry_probe(struct pci_dev *pcidev,
2512 +static int __devinit slic_entry_probe(struct pci_dev *pcidev,
2513 const struct pci_device_id *pci_tbl_entry)
2514 {
2515 static int cards_found;
2516 static int did_version;
2517 int err;
2518 struct net_device *netdev;
2519 - p_adapter_t adapter;
2520 + struct adapter *adapter;
2521 void __iomem *memmapped_ioaddr = NULL;
2522 - ulong32 status = 0;
2523 + u32 status = 0;
2524 ulong mmio_start = 0;
2525 ulong mmio_len = 0;
2526 - p_sliccard_t card = NULL;
2527 + struct sliccard *card = NULL;
2528
2529 DBG_MSG("slicoss: %s 2.6 VERSION ENTER jiffies[%lx] cpu %d\n",
2530 __func__, jiffies, smp_processor_id());
2531 @@ -408,7 +404,7 @@ int __devinit slic_entry_probe(struct pci_dev *pcidev,
2532 pci_set_master(pcidev);
2533
2534 DBG_MSG("call alloc_etherdev\n");
2535 - netdev = alloc_etherdev(sizeof(adapter_t));
2536 + netdev = alloc_etherdev(sizeof(struct adapter));
2537 if (!netdev) {
2538 err = -ENOMEM;
2539 goto err_out_exit_slic_probe;
2540 @@ -428,7 +424,7 @@ int __devinit slic_entry_probe(struct pci_dev *pcidev,
2541 DBG_MSG("slicoss: call ioremap(mmio_start[%lx], mmio_len[%lx])\n",
2542 mmio_start, mmio_len);
2543
2544 -/* memmapped_ioaddr = (ulong32)ioremap_nocache(mmio_start, mmio_len);*/
2545 +/* memmapped_ioaddr = (u32)ioremap_nocache(mmio_start, mmio_len);*/
2546 memmapped_ioaddr = ioremap(mmio_start, mmio_len);
2547 DBG_MSG("slicoss: %s MEMMAPPED_IOADDR [%p]\n", __func__,
2548 memmapped_ioaddr);
2549 @@ -530,11 +526,11 @@ err_out_exit_slic_probe:
2550 return -ENODEV;
2551 }
2552
2553 -int slic_entry_open(struct net_device *dev)
2554 +static int slic_entry_open(struct net_device *dev)
2555 {
2556 - p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
2557 - p_sliccard_t card = adapter->card;
2558 - ulong32 locked = 0;
2559 + struct adapter *adapter = (struct adapter *) netdev_priv(dev);
2560 + struct sliccard *card = adapter->card;
2561 + u32 locked = 0;
2562 int status;
2563
2564 ASSERT(adapter);
2565 @@ -552,7 +548,8 @@ int slic_entry_open(struct net_device *dev)
2566
2567 netif_stop_queue(adapter->netdev);
2568
2569 - SLIC_ACQUIRE_IRQ_SPINLOCK(slic_global.driver_lock);
2570 + spin_lock_irqsave(&slic_global.driver_lock.lock,
2571 + slic_global.driver_lock.flags);
2572 locked = 1;
2573 if (!adapter->activated) {
2574 card->adapters_activated++;
2575 @@ -568,7 +565,8 @@ int slic_entry_open(struct net_device *dev)
2576 adapter->activated = 0;
2577 }
2578 if (locked) {
2579 - SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock);
2580 + spin_unlock_irqrestore(&slic_global.driver_lock.lock,
2581 + slic_global.driver_lock.flags);
2582 locked = 0;
2583 }
2584 return status;
2585 @@ -583,7 +581,8 @@ int slic_entry_open(struct net_device *dev)
2586 #endif
2587
2588 if (locked) {
2589 - SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock);
2590 + spin_unlock_irqrestore(&slic_global.driver_lock.lock,
2591 + slic_global.driver_lock.flags);
2592 locked = 0;
2593 }
2594 #if SLIC_DUMP_ENABLED
2595 @@ -599,13 +598,13 @@ int slic_entry_open(struct net_device *dev)
2596 return STATUS_SUCCESS;
2597 }
2598
2599 -void __devexit slic_entry_remove(struct pci_dev *pcidev)
2600 +static void __devexit slic_entry_remove(struct pci_dev *pcidev)
2601 {
2602 struct net_device *dev = pci_get_drvdata(pcidev);
2603 - ulong32 mmio_start = 0;
2604 + u32 mmio_start = 0;
2605 uint mmio_len = 0;
2606 - p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
2607 - p_sliccard_t card;
2608 + struct adapter *adapter = (struct adapter *) netdev_priv(dev);
2609 + struct sliccard *card;
2610
2611 ASSERT(adapter);
2612 DBG_MSG("slicoss: %s ENTER dev[%p] adapter[%p]\n", __func__, dev,
2613 @@ -635,7 +634,7 @@ void __devexit slic_entry_remove(struct pci_dev *pcidev)
2614 __func__, card->adapters_activated, card->adapters_allocated,
2615 card, adapter);
2616 if (!card->adapters_allocated) {
2617 - p_sliccard_t curr_card = slic_global.slic_card;
2618 + struct sliccard *curr_card = slic_global.slic_card;
2619 if (curr_card == card) {
2620 slic_global.slic_card = card->next;
2621 } else {
2622 @@ -649,17 +648,18 @@ void __devexit slic_entry_remove(struct pci_dev *pcidev)
2623 slic_card_cleanup(card);
2624 }
2625 DBG_MSG("slicoss: %s deallocate device\n", __func__);
2626 - SLIC_DEALLOCATE_MEM(dev);
2627 + kfree(dev);
2628 DBG_MSG("slicoss: %s EXIT\n", __func__);
2629 }
2630
2631 -int slic_entry_halt(struct net_device *dev)
2632 +static int slic_entry_halt(struct net_device *dev)
2633 {
2634 - p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
2635 - p_sliccard_t card = adapter->card;
2636 - p_slic_regs_t slic_regs = adapter->slic_regs;
2637 + struct adapter *adapter = (struct adapter *)netdev_priv(dev);
2638 + struct sliccard *card = adapter->card;
2639 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
2640
2641 - SLIC_ACQUIRE_IRQ_SPINLOCK(slic_global.driver_lock);
2642 + spin_lock_irqsave(&slic_global.driver_lock.lock,
2643 + slic_global.driver_lock.flags);
2644 ASSERT(card);
2645 DBG_MSG("slicoss: %s (%s) ENTER\n", __func__, dev->name);
2646 DBG_MSG("slicoss: %s (%s) actvtd[%d] alloc[%d] state[%x] adapt[%p]\n",
2647 @@ -730,11 +730,12 @@ int slic_entry_halt(struct net_device *dev)
2648
2649 DBG_MSG("slicoss: %s (%s) EXIT\n", __func__, dev->name);
2650 DBG_MSG("slicoss: %s EXIT\n", __func__);
2651 - SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock);
2652 + spin_unlock_irqrestore(&slic_global.driver_lock.lock,
2653 + slic_global.driver_lock.flags);
2654 return STATUS_SUCCESS;
2655 }
2656
2657 -int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2658 +static int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2659 {
2660 ASSERT(rq);
2661 /*
2662 @@ -743,9 +744,10 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2663 switch (cmd) {
2664 case SIOCSLICSETINTAGG:
2665 {
2666 - p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
2667 - ulong32 data[7];
2668 - ulong32 intagg;
2669 + struct adapter *adapter = (struct adapter *)
2670 + netdev_priv(dev);
2671 + u32 data[7];
2672 + u32 intagg;
2673
2674 if (copy_from_user(data, rq->ifr_data, 28)) {
2675 DBG_ERROR
2676 @@ -763,8 +765,9 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2677 #ifdef SLIC_USER_REQUEST_DUMP_ENABLED
2678 case SIOCSLICDUMPCARD:
2679 {
2680 - p_adapter_t adapter = (p_adapter_t) dev->priv;
2681 - p_sliccard_t card;
2682 + struct adapter *adapter = (struct adapter *)
2683 + dev->priv;
2684 + struct sliccard *card;
2685
2686 ASSERT(adapter);
2687 ASSERT(adapter->card)
2688 @@ -833,7 +836,8 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2689 #if SLIC_ETHTOOL_SUPPORT
2690 case SIOCETHTOOL:
2691 {
2692 - p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
2693 + struct adapter *adapter = (struct adapter *)
2694 + netdev_priv(dev);
2695 struct ethtool_cmd data;
2696 struct ethtool_cmd ecmd;
2697
2698 @@ -892,8 +896,8 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2699 data.maxrxpkt = 1;
2700 if ((ecmd.speed != data.speed) ||
2701 (ecmd.duplex != data.duplex)) {
2702 - ulong32 speed;
2703 - ulong32 duplex;
2704 + u32 speed;
2705 + u32 duplex;
2706
2707 if (ecmd.speed == SPEED_10) {
2708 speed = 0;
2709 @@ -935,10 +939,10 @@ int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2710 #define XMIT_FAIL_ZERO_LENGTH 2
2711 #define XMIT_FAIL_HOSTCMD_FAIL 3
2712
2713 -static void slic_xmit_build_request(p_adapter_t adapter,
2714 - p_slic_hostcmd_t hcmd, struct sk_buff *skb)
2715 +static void slic_xmit_build_request(struct adapter *adapter,
2716 + struct slic_hostcmd *hcmd, struct sk_buff *skb)
2717 {
2718 - p_slic_host64_cmd_t ihcmd;
2719 + struct slic_host64_cmd *ihcmd;
2720 ulong phys_addr;
2721
2722 ihcmd = &hcmd->cmd64;
2723 @@ -946,16 +950,17 @@ static void slic_xmit_build_request(p_adapter_t adapter,
2724 ihcmd->flags = (adapter->port << IHFLG_IFSHFT);
2725 ihcmd->command = IHCMD_XMT_REQ;
2726 ihcmd->u.slic_buffers.totlen = skb->len;
2727 - phys_addr = SLIC_GET_DMA_ADDRESS_WRITE(adapter, skb->data, skb->len);
2728 + phys_addr = pci_map_single(adapter->pcidev, skb->data, skb->len,
2729 + PCI_DMA_TODEVICE);
2730 ihcmd->u.slic_buffers.bufs[0].paddrl = SLIC_GET_ADDR_LOW(phys_addr);
2731 ihcmd->u.slic_buffers.bufs[0].paddrh = SLIC_GET_ADDR_HIGH(phys_addr);
2732 ihcmd->u.slic_buffers.bufs[0].length = skb->len;
2733 #if defined(CONFIG_X86_64)
2734 - hcmd->cmdsize = (ulong32) ((((ulong64)&ihcmd->u.slic_buffers.bufs[1] -
2735 - (ulong64) hcmd) + 31) >> 5);
2736 + hcmd->cmdsize = (u32) ((((u64)&ihcmd->u.slic_buffers.bufs[1] -
2737 + (u64) hcmd) + 31) >> 5);
2738 #elif defined(CONFIG_X86)
2739 - hcmd->cmdsize = ((((ulong32) &ihcmd->u.slic_buffers.bufs[1] -
2740 - (ulong32) hcmd) + 31) >> 5);
2741 + hcmd->cmdsize = ((((u32) &ihcmd->u.slic_buffers.bufs[1] -
2742 + (u32) hcmd) + 31) >> 5);
2743 #else
2744 Stop Compilation;
2745 #endif
2746 @@ -963,14 +968,14 @@ static void slic_xmit_build_request(p_adapter_t adapter,
2747
2748 #define NORMAL_ETHFRAME 0
2749
2750 -int slic_xmit_start(struct sk_buff *skb, struct net_device *dev)
2751 +static int slic_xmit_start(struct sk_buff *skb, struct net_device *dev)
2752 {
2753 - p_sliccard_t card;
2754 - p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
2755 - p_slic_hostcmd_t hcmd = NULL;
2756 - ulong32 status = 0;
2757 - ulong32 skbtype = NORMAL_ETHFRAME;
2758 - pvoid offloadcmd = NULL;
2759 + struct sliccard *card;
2760 + struct adapter *adapter = (struct adapter *)netdev_priv(dev);
2761 + struct slic_hostcmd *hcmd = NULL;
2762 + u32 status = 0;
2763 + u32 skbtype = NORMAL_ETHFRAME;
2764 + void *offloadcmd = NULL;
2765
2766 card = adapter->card;
2767 ASSERT(card);
2768 @@ -1035,9 +1040,9 @@ xmit_fail:
2769 goto xmit_done;
2770 }
2771
2772 -void slic_xmit_fail(p_adapter_t adapter,
2773 +static void slic_xmit_fail(struct adapter *adapter,
2774 struct sk_buff *skb,
2775 - pvoid cmd, ulong32 skbtype, ulong32 status)
2776 + void *cmd, u32 skbtype, u32 status)
2777 {
2778 if (adapter->xmitq_full)
2779 slic_if_stop_queue(adapter);
2780 @@ -1072,31 +1077,10 @@ void slic_xmit_fail(p_adapter_t adapter,
2781 adapter->stats.tx_dropped++;
2782 }
2783
2784 -void slic_xmit_timeout(struct net_device *dev)
2785 -{
2786 - p_sliccard_t card;
2787 - p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
2788 - ulong32 i;
2789 -
2790 - ASSERT(adapter);
2791 - card = adapter->card;
2792 - ASSERT(card);
2793 - for (i = 0; i < card->card_size; i++) {
2794 - if (card->adapter[i])
2795 - slic_if_stop_queue(card->adapter[i]);
2796 - }
2797 - if (!card->reset_in_progress) {
2798 - DBG_ERROR
2799 - ("%s card[%p] state[%x] adapter[%p] port[%d] state[%x]\n",
2800 - __func__, card, card->state, adapter, adapter->port,
2801 - adapter->state);
2802 - slic_card_reset(adapter);
2803 - }
2804 -}
2805 -
2806 -void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf)
2807 +static void slic_rcv_handle_error(struct adapter *adapter,
2808 + struct slic_rcvbuf *rcvbuf)
2809 {
2810 - p_slic_hddr_wds hdr = (p_slic_hddr_wds) rcvbuf->data;
2811 + struct slic_hddr_wds *hdr = (struct slic_hddr_wds *)rcvbuf->data;
2812
2813 if (adapter->devid != SLIC_1GB_DEVICE_ID) {
2814 if (hdr->frame_status14 & VRHSTAT_802OE)
2815 @@ -1141,7 +1125,7 @@ void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf)
2816 adapter->if_events.IpHlen++;
2817 } else {
2818 if (hdr->frame_statusGB & VGBSTAT_XPERR) {
2819 - ulong32 xerr = hdr->frame_statusGB >> VGBSTAT_XERRSHFT;
2820 + u32 xerr = hdr->frame_statusGB >> VGBSTAT_XERRSHFT;
2821
2822 if (xerr == VGBSTAT_XCSERR)
2823 adapter->if_events.TpCsum++;
2824 @@ -1151,7 +1135,7 @@ void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf)
2825 adapter->if_events.TpHlen++;
2826 }
2827 if (hdr->frame_statusGB & VGBSTAT_NETERR) {
2828 - ulong32 nerr =
2829 + u32 nerr =
2830 (hdr->
2831 frame_statusGB >> VGBSTAT_NERRSHFT) &
2832 VGBSTAT_NERRMSK;
2833 @@ -1163,7 +1147,7 @@ void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf)
2834 adapter->if_events.IpHlen++;
2835 }
2836 if (hdr->frame_statusGB & VGBSTAT_LNKERR) {
2837 - ulong32 lerr = hdr->frame_statusGB & VGBSTAT_LERRMSK;
2838 + u32 lerr = hdr->frame_statusGB & VGBSTAT_LERRMSK;
2839
2840 if (lerr == VGBSTAT_LDEARLY)
2841 adapter->if_events.rcvearly++;
2842 @@ -1187,17 +1171,17 @@ void slic_rcv_handle_error(p_adapter_t adapter, p_slic_rcvbuf_t rcvbuf)
2843 #define TCP_OFFLOAD_FRAME_PUSHFLAG 0x10000000
2844 #define M_FAST_PATH 0x0040
2845
2846 -void slic_rcv_handler(p_adapter_t adapter)
2847 +static void slic_rcv_handler(struct adapter *adapter)
2848 {
2849 struct sk_buff *skb;
2850 - p_slic_rcvbuf_t rcvbuf;
2851 - ulong32 frames = 0;
2852 + struct slic_rcvbuf *rcvbuf;
2853 + u32 frames = 0;
2854
2855 while ((skb = slic_rcvqueue_getnext(adapter))) {
2856 - ulong32 rx_bytes;
2857 + u32 rx_bytes;
2858
2859 ASSERT(skb->head);
2860 - rcvbuf = (p_slic_rcvbuf_t) skb->head;
2861 + rcvbuf = (struct slic_rcvbuf *)skb->head;
2862 adapter->card->events++;
2863 if (rcvbuf->status & IRHDDR_ERR) {
2864 adapter->rx_errors++;
2865 @@ -1206,7 +1190,8 @@ void slic_rcv_handler(p_adapter_t adapter)
2866 continue;
2867 }
2868
2869 - if (!slic_mac_filter(adapter, (p_ether_header) rcvbuf->data)) {
2870 + if (!slic_mac_filter(adapter, (struct ether_header *)
2871 + rcvbuf->data)) {
2872 #if 0
2873 DBG_MSG
2874 ("slicoss: %s (%s) drop frame due to mac filter\n",
2875 @@ -1239,12 +1224,12 @@ void slic_rcv_handler(p_adapter_t adapter)
2876 adapter->max_isr_rcvs = max(adapter->max_isr_rcvs, frames);
2877 }
2878
2879 -void slic_xmit_complete(p_adapter_t adapter)
2880 +static void slic_xmit_complete(struct adapter *adapter)
2881 {
2882 - p_slic_hostcmd_t hcmd;
2883 - p_slic_rspbuf_t rspbuf;
2884 - ulong32 frames = 0;
2885 - slic_handle_word_t slic_handle_word;
2886 + struct slic_hostcmd *hcmd;
2887 + struct slic_rspbuf *rspbuf;
2888 + u32 frames = 0;
2889 + struct slic_handle_word slic_handle_word;
2890
2891 do {
2892 rspbuf = slic_rspqueue_getnext(adapter);
2893 @@ -1259,10 +1244,10 @@ void slic_xmit_complete(p_adapter_t adapter)
2894 ASSERT(slic_handle_word.handle_index);
2895 ASSERT(slic_handle_word.handle_index <= SLIC_CMDQ_MAXCMDS);
2896 hcmd =
2897 - (p_slic_hostcmd_t) adapter->slic_handles[slic_handle_word.
2898 - handle_index].
2899 - address;
2900 -/* hcmd = (p_slic_hostcmd_t) rspbuf->hosthandle; */
2901 + (struct slic_hostcmd *)
2902 + adapter->slic_handles[slic_handle_word.handle_index].
2903 + address;
2904 +/* hcmd = (struct slic_hostcmd *) rspbuf->hosthandle; */
2905 ASSERT(hcmd);
2906 ASSERT(hcmd->pslic_handle ==
2907 &adapter->slic_handles[slic_handle_word.handle_index]);
2908 @@ -1286,9 +1271,9 @@ void slic_xmit_complete(p_adapter_t adapter)
2909
2910 static irqreturn_t slic_interrupt(int irq, void *dev_id)
2911 {
2912 - struct net_device *dev = (struct net_device *) dev_id;
2913 - p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
2914 - ulong32 isr;
2915 + struct net_device *dev = (struct net_device *)dev_id;
2916 + struct adapter *adapter = (struct adapter *)netdev_priv(dev);
2917 + u32 isr;
2918
2919 if ((adapter->pshmem) && (adapter->pshmem->isr)) {
2920 WRITE_REG(adapter->slic_regs->slic_icr, ICR_INT_MASK, FLUSH);
2921 @@ -1305,7 +1290,7 @@ static irqreturn_t slic_interrupt(int irq, void *dev_id)
2922 int pre_count;
2923 int errors;
2924
2925 - p_slic_rcvqueue_t rcvq =
2926 + struct slic_rcvqueue *rcvq =
2927 &adapter->rcvqueue;
2928
2929 adapter->
2930 @@ -1400,17 +1385,17 @@ static irqreturn_t slic_interrupt(int irq, void *dev_id)
2931 * will also complete asynchronously.
2932 *
2933 */
2934 -void slic_link_event_handler(p_adapter_t adapter)
2935 +static void slic_link_event_handler(struct adapter *adapter)
2936 {
2937 int status;
2938 - p_slic_shmem_t pshmem;
2939 + struct slic_shmem *pshmem;
2940
2941 if (adapter->state != ADAPT_UP) {
2942 /* Adapter is not operational. Ignore. */
2943 return;
2944 }
2945
2946 - pshmem = (p_slic_shmem_t) adapter->phys_shmem;
2947 + pshmem = (struct slic_shmem *)adapter->phys_shmem;
2948
2949 #if defined(CONFIG_X86_64)
2950 /*
2951 @@ -1425,7 +1410,7 @@ void slic_link_event_handler(p_adapter_t adapter)
2952 0, 0);
2953 #elif defined(CONFIG_X86)
2954 status = slic_upr_request(adapter, SLIC_UPR_RLSR,
2955 - (ulong32) &pshmem->linkstatus, /* no 4GB wrap guaranteed */
2956 + (u32) &pshmem->linkstatus, /* no 4GB wrap guaranteed */
2957 0, 0, 0);
2958 #else
2959 Stop compilation;
2960 @@ -1433,7 +1418,7 @@ void slic_link_event_handler(p_adapter_t adapter)
2961 ASSERT((status == STATUS_SUCCESS) || (status == STATUS_PENDING));
2962 }
2963
2964 -void slic_init_cleanup(p_adapter_t adapter)
2965 +static void slic_init_cleanup(struct adapter *adapter)
2966 {
2967 DBG_MSG("slicoss: %s ENTER adapter[%p] ", __func__, adapter);
2968 if (adapter->intrregistered) {
2969 @@ -1445,9 +1430,9 @@ void slic_init_cleanup(p_adapter_t adapter)
2970 if (adapter->pshmem) {
2971 DBG_MSG("FREE_SHMEM ");
2972 DBG_MSG("adapter[%p] port %d pshmem[%p] FreeShmem ",
2973 - adapter, adapter->port, (pvoid) adapter->pshmem);
2974 + adapter, adapter->port, (void *) adapter->pshmem);
2975 pci_free_consistent(adapter->pcidev,
2976 - sizeof(slic_shmem_t),
2977 + sizeof(struct slic_shmem *),
2978 adapter->pshmem, adapter->phys_shmem);
2979 adapter->pshmem = NULL;
2980 adapter->phys_shmem = (dma_addr_t) NULL;
2981 @@ -1475,9 +1460,9 @@ void slic_init_cleanup(p_adapter_t adapter)
2982 }
2983
2984 #if SLIC_GET_STATS_ENABLED
2985 -struct net_device_stats *slic_get_stats(struct net_device *dev)
2986 +static struct net_device_stats *slic_get_stats(struct net_device *dev)
2987 {
2988 - p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
2989 + struct adapter *adapter = (struct adapter *)netdev_priv(dev);
2990 struct net_device_stats *stats;
2991
2992 ASSERT(adapter);
2993 @@ -1500,10 +1485,10 @@ struct net_device_stats *slic_get_stats(struct net_device *dev)
2994 * Allocate a mcast_address structure to hold the multicast address.
2995 * Link it in.
2996 */
2997 -int slic_mcast_add_list(p_adapter_t adapter, pchar address)
2998 +static int slic_mcast_add_list(struct adapter *adapter, char *address)
2999 {
3000 - p_mcast_address_t mcaddr, mlist;
3001 - boolean equaladdr;
3002 + struct mcast_address *mcaddr, *mlist;
3003 + bool equaladdr;
3004
3005 /* Check to see if it already exists */
3006 mlist = adapter->mcastaddrs;
3007 @@ -1515,7 +1500,7 @@ int slic_mcast_add_list(p_adapter_t adapter, pchar address)
3008 }
3009
3010 /* Doesn't already exist. Allocate a structure to hold it */
3011 - mcaddr = SLIC_ALLOCATE_MEM(sizeof(mcast_address_t), GFP_ATOMIC);
3012 + mcaddr = kmalloc(sizeof(struct mcast_address), GFP_ATOMIC);
3013 if (mcaddr == NULL)
3014 return 1;
3015
3016 @@ -1545,10 +1530,10 @@ static u32 slic_crc_init; /* Is table initialized */
3017 /*
3018 * Contruct the CRC32 table
3019 */
3020 -void slic_mcast_init_crc32(void)
3021 +static void slic_mcast_init_crc32(void)
3022 {
3023 - ulong32 c; /* CRC shit reg */
3024 - ulong32 e = 0; /* Poly X-or pattern */
3025 + u32 c; /* CRC shit reg */
3026 + u32 e = 0; /* Poly X-or pattern */
3027 int i; /* counter */
3028 int k; /* byte being shifted into crc */
3029
3030 @@ -1568,12 +1553,12 @@ void slic_mcast_init_crc32(void)
3031 /*
3032 * Return the MAC hast as described above.
3033 */
3034 -uchar slic_mcast_get_mac_hash(pchar macaddr)
3035 +static unsigned char slic_mcast_get_mac_hash(char *macaddr)
3036 {
3037 - ulong32 crc;
3038 - pchar p;
3039 + u32 crc;
3040 + char *p;
3041 int i;
3042 - uchar machash = 0;
3043 + unsigned char machash = 0;
3044
3045 if (!slic_crc_init) {
3046 slic_mcast_init_crc32();
3047 @@ -1591,9 +1576,9 @@ uchar slic_mcast_get_mac_hash(pchar macaddr)
3048 return machash;
3049 }
3050
3051 -void slic_mcast_set_bit(p_adapter_t adapter, pchar address)
3052 +static void slic_mcast_set_bit(struct adapter *adapter, char *address)
3053 {
3054 - uchar crcpoly;
3055 + unsigned char crcpoly;
3056
3057 /* Get the CRC polynomial for the mac address */
3058 crcpoly = slic_mcast_get_mac_hash(address);
3059 @@ -1604,22 +1589,22 @@ void slic_mcast_set_bit(p_adapter_t adapter, pchar address)
3060 crcpoly &= 0x3F;
3061
3062 /* OR in the new bit into our 64 bit mask. */
3063 - adapter->mcastmask |= (ulong64) 1 << crcpoly;
3064 + adapter->mcastmask |= (u64) 1 << crcpoly;
3065 }
3066
3067 -void slic_mcast_set_list(struct net_device *dev)
3068 +static void slic_mcast_set_list(struct net_device *dev)
3069 {
3070 - p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
3071 + struct adapter *adapter = (struct adapter *)netdev_priv(dev);
3072 int status = STATUS_SUCCESS;
3073 int i;
3074 - pchar addresses;
3075 + char *addresses;
3076 struct dev_mc_list *mc_list = dev->mc_list;
3077 int mc_count = dev->mc_count;
3078
3079 ASSERT(adapter);
3080
3081 for (i = 1; i <= mc_count; i++) {
3082 - addresses = (pchar) &mc_list->dmi_addr;
3083 + addresses = (char *) &mc_list->dmi_addr;
3084 if (mc_list->dmi_addrlen == 6) {
3085 status = slic_mcast_add_list(adapter, addresses);
3086 if (status != STATUS_SUCCESS)
3087 @@ -1657,9 +1642,9 @@ void slic_mcast_set_list(struct net_device *dev)
3088 return;
3089 }
3090
3091 -void slic_mcast_set_mask(p_adapter_t adapter)
3092 +static void slic_mcast_set_mask(struct adapter *adapter)
3093 {
3094 - p_slic_regs_t slic_regs = adapter->slic_regs;
3095 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3096
3097 DBG_MSG("%s ENTER (%s) macopts[%x] mask[%llx]\n", __func__,
3098 adapter->netdev->name, (uint) adapter->macopts,
3099 @@ -1687,20 +1672,20 @@ void slic_mcast_set_mask(p_adapter_t adapter)
3100 ((ulong) ((adapter->mcastmask >> 32) & 0xFFFFFFFF)));
3101
3102 WRITE_REG(slic_regs->slic_mcastlow,
3103 - (ulong32) (adapter->mcastmask & 0xFFFFFFFF), FLUSH);
3104 + (u32) (adapter->mcastmask & 0xFFFFFFFF), FLUSH);
3105 WRITE_REG(slic_regs->slic_mcasthigh,
3106 - (ulong32) ((adapter->mcastmask >> 32) & 0xFFFFFFFF),
3107 + (u32) ((adapter->mcastmask >> 32) & 0xFFFFFFFF),
3108 FLUSH);
3109 }
3110 }
3111
3112 -void slic_timer_ping(ulong dev)
3113 +static void slic_timer_ping(ulong dev)
3114 {
3115 - p_adapter_t adapter;
3116 - p_sliccard_t card;
3117 + struct adapter *adapter;
3118 + struct sliccard *card;
3119
3120 ASSERT(dev);
3121 - adapter = (p_adapter_t) ((struct net_device *) dev)->priv;
3122 + adapter = (struct adapter *)((struct net_device *) dev)->priv;
3123 ASSERT(adapter);
3124 card = adapter->card;
3125 ASSERT(card);
3126 @@ -1741,12 +1726,12 @@ void slic_timer_ping(ulong dev)
3127 add_timer(&adapter->pingtimer);
3128 }
3129
3130 -void slic_if_stop_queue(p_adapter_t adapter)
3131 +static void slic_if_stop_queue(struct adapter *adapter)
3132 {
3133 netif_stop_queue(adapter->netdev);
3134 }
3135
3136 -void slic_if_start_queue(p_adapter_t adapter)
3137 +static void slic_if_start_queue(struct adapter *adapter)
3138 {
3139 netif_start_queue(adapter->netdev);
3140 }
3141 @@ -1757,12 +1742,12 @@ void slic_if_start_queue(p_adapter_t adapter)
3142 * Perform initialization of our slic interface.
3143 *
3144 */
3145 -int slic_if_init(p_adapter_t adapter)
3146 +static int slic_if_init(struct adapter *adapter)
3147 {
3148 - p_sliccard_t card = adapter->card;
3149 + struct sliccard *card = adapter->card;
3150 struct net_device *dev = adapter->netdev;
3151 - p_slic_regs_t slic_regs = adapter->slic_regs;
3152 - p_slic_shmem_t pshmem;
3153 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3154 + struct slic_shmem *pshmem;
3155 int status = 0;
3156
3157 ASSERT(card);
3158 @@ -1829,12 +1814,13 @@ int slic_if_init(p_adapter_t adapter)
3159 DBG_MSG("slicoss: %s disable interrupts(slic)\n", __func__);
3160
3161 WRITE_REG(slic_regs->slic_icr, ICR_INT_OFF, FLUSH);
3162 - slic_stall_msec(1);
3163 + mdelay(1);
3164
3165 if (!adapter->isp_initialized) {
3166 - pshmem = (p_slic_shmem_t) adapter->phys_shmem;
3167 + pshmem = (struct slic_shmem *)adapter->phys_shmem;
3168
3169 - SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->bit64reglock);
3170 + spin_lock_irqsave(&adapter->bit64reglock.lock,
3171 + adapter->bit64reglock.flags);
3172
3173 #if defined(CONFIG_X86_64)
3174 WRITE_REG(slic_regs->slic_addr_upper,
3175 @@ -1842,12 +1828,13 @@ int slic_if_init(p_adapter_t adapter)
3176 WRITE_REG(slic_regs->slic_isp,
3177 SLIC_GET_ADDR_LOW(&pshmem->isr), FLUSH);
3178 #elif defined(CONFIG_X86)
3179 - WRITE_REG(slic_regs->slic_addr_upper, (ulong32) 0, DONT_FLUSH);
3180 - WRITE_REG(slic_regs->slic_isp, (ulong32) &pshmem->isr, FLUSH);
3181 + WRITE_REG(slic_regs->slic_addr_upper, (u32) 0, DONT_FLUSH);
3182 + WRITE_REG(slic_regs->slic_isp, (u32) &pshmem->isr, FLUSH);
3183 #else
3184 Stop Compilations
3185 #endif
3186 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->bit64reglock);
3187 + spin_unlock_irqrestore(&adapter->bit64reglock.lock,
3188 + adapter->bit64reglock.flags);
3189 adapter->isp_initialized = 1;
3190 }
3191
3192 @@ -1908,7 +1895,7 @@ int slic_if_init(p_adapter_t adapter)
3193 return STATUS_SUCCESS;
3194 }
3195
3196 -void slic_unmap_mmio_space(p_adapter_t adapter)
3197 +static void slic_unmap_mmio_space(struct adapter *adapter)
3198 {
3199 #if LINUX_FREES_ADAPTER_RESOURCES
3200 if (adapter->slic_regs)
3201 @@ -1917,7 +1904,7 @@ void slic_unmap_mmio_space(p_adapter_t adapter)
3202 #endif
3203 }
3204
3205 -int slic_adapter_allocresources(p_adapter_t adapter)
3206 +static int slic_adapter_allocresources(struct adapter *adapter)
3207 {
3208 if (!adapter->intrregistered) {
3209 int retval;
3210 @@ -1929,14 +1916,16 @@ int slic_adapter_allocresources(p_adapter_t adapter)
3211 (void *)adapter->phys_shmem, adapter->netdev->irq,
3212 NR_IRQS);
3213
3214 - SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock);
3215 + spin_unlock_irqrestore(&slic_global.driver_lock.lock,
3216 + slic_global.driver_lock.flags);
3217
3218 retval = request_irq(adapter->netdev->irq,
3219 &slic_interrupt,
3220 IRQF_SHARED,
3221 adapter->netdev->name, adapter->netdev);
3222
3223 - SLIC_ACQUIRE_IRQ_SPINLOCK(slic_global.driver_lock);
3224 + spin_lock_irqsave(&slic_global.driver_lock.lock,
3225 + slic_global.driver_lock.flags);
3226
3227 if (retval) {
3228 DBG_ERROR("slicoss: request_irq (%s) FAILED [%x]\n",
3229 @@ -1953,7 +1942,7 @@ int slic_adapter_allocresources(p_adapter_t adapter)
3230 return STATUS_SUCCESS;
3231 }
3232
3233 -void slic_config_pci(struct pci_dev *pcidev)
3234 +static void slic_config_pci(struct pci_dev *pcidev)
3235 {
3236 u16 pci_command;
3237 u16 new_command;
3238 @@ -1972,11 +1961,11 @@ void slic_config_pci(struct pci_dev *pcidev)
3239 }
3240 }
3241
3242 -void slic_adapter_freeresources(p_adapter_t adapter)
3243 +static void slic_adapter_freeresources(struct adapter *adapter)
3244 {
3245 DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter);
3246 slic_init_cleanup(adapter);
3247 - SLIC_ZERO_MEMORY(&adapter->stats, sizeof(struct net_device_stats));
3248 + memset(&adapter->stats, 0, sizeof(struct net_device_stats));
3249 adapter->error_interrupts = 0;
3250 adapter->rcv_interrupts = 0;
3251 adapter->xmit_interrupts = 0;
3252 @@ -1996,14 +1985,14 @@ void slic_adapter_freeresources(p_adapter_t adapter)
3253 * Write phy control to configure link duplex/speed
3254 *
3255 */
3256 -void slic_link_config(p_adapter_t adapter,
3257 - ulong32 linkspeed, ulong32 linkduplex)
3258 +static void slic_link_config(struct adapter *adapter,
3259 + u32 linkspeed, u32 linkduplex)
3260 {
3261 - ulong32 speed;
3262 - ulong32 duplex;
3263 - ulong32 phy_config;
3264 - ulong32 phy_advreg;
3265 - ulong32 phy_gctlreg;
3266 + u32 speed;
3267 + u32 duplex;
3268 + u32 phy_config;
3269 + u32 phy_advreg;
3270 + u32 phy_gctlreg;
3271
3272 if (adapter->state != ADAPT_UP) {
3273 DBG_MSG
3274 @@ -2052,7 +2041,7 @@ void slic_link_config(p_adapter_t adapter,
3275 phy_config, FLUSH);
3276 /* wait, Marvell says 1 sec,
3277 try to get away with 10 ms */
3278 - slic_stall_msec(10);
3279 + mdelay(10);
3280
3281 /* disable auto-neg, set speed/duplex,
3282 soft reset phy, powerup */
3283 @@ -2140,7 +2129,7 @@ void slic_link_config(p_adapter_t adapter,
3284 WRITE_REG(adapter->slic_regs->slic_wphy, phy_config, FLUSH);
3285
3286 /* wait, Marvell says 1 sec, try to get away with 10 ms */
3287 - slic_stall_msec(10);
3288 + mdelay(10);
3289
3290 if (adapter->subsysid != SLIC_1GB_CICADA_SUBSYS_ID) {
3291 /* if a Marvell PHY
3292 @@ -2164,24 +2153,24 @@ void slic_link_config(p_adapter_t adapter,
3293 phy_config);
3294 }
3295
3296 -void slic_card_cleanup(p_sliccard_t card)
3297 +static void slic_card_cleanup(struct sliccard *card)
3298 {
3299 DBG_MSG("slicoss: %s ENTER\n", __func__);
3300
3301 #if SLIC_DUMP_ENABLED
3302 if (card->dumpbuffer) {
3303 - SLIC_DEALLOCATE_MEM(card->dumpbuffer);
3304 - card->dumpbuffer = NULL;
3305 card->dumpbuffer_phys = 0;
3306 card->dumpbuffer_physl = 0;
3307 card->dumpbuffer_physh = 0;
3308 + kfree(card->dumpbuffer);
3309 + card->dumpbuffer = NULL;
3310 }
3311 if (card->cmdbuffer) {
3312 - SLIC_DEALLOCATE_MEM(card->cmdbuffer);
3313 - card->cmdbuffer = NULL;
3314 card->cmdbuffer_phys = 0;
3315 card->cmdbuffer_physl = 0;
3316 card->cmdbuffer_physh = 0;
3317 + kfree(card->cmdbuffer);
3318 + card->cmdbuffer = NULL;
3319 }
3320 #endif
3321
3322 @@ -2192,24 +2181,24 @@ void slic_card_cleanup(p_sliccard_t card)
3323
3324 slic_debug_card_destroy(card);
3325
3326 - SLIC_DEALLOCATE_MEM(card);
3327 + kfree(card);
3328 DBG_MSG("slicoss: %s EXIT\n", __func__);
3329 }
3330
3331 -static int slic_card_download_gbrcv(p_adapter_t adapter)
3332 +static int slic_card_download_gbrcv(struct adapter *adapter)
3333 {
3334 - p_slic_regs_t slic_regs = adapter->slic_regs;
3335 - ulong32 codeaddr;
3336 - puchar instruction = NULL;
3337 - ulong32 rcvucodelen = 0;
3338 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3339 + u32 codeaddr;
3340 + unsigned char *instruction = NULL;
3341 + u32 rcvucodelen = 0;
3342
3343 switch (adapter->devid) {
3344 case SLIC_2GB_DEVICE_ID:
3345 - instruction = (puchar) &OasisRcvUCode[0];
3346 + instruction = (unsigned char *)&OasisRcvUCode[0];
3347 rcvucodelen = OasisRcvUCodeLen;
3348 break;
3349 case SLIC_1GB_DEVICE_ID:
3350 - instruction = (puchar) &GBRcvUCode[0];
3351 + instruction = (unsigned char *)&GBRcvUCode[0];
3352 rcvucodelen = GBRcvUCodeLen;
3353 break;
3354 default:
3355 @@ -2227,11 +2216,11 @@ static int slic_card_download_gbrcv(p_adapter_t adapter)
3356
3357 /* write out the instruction data low addr */
3358 WRITE_REG(slic_regs->slic_rcv_wcs,
3359 - (ulong32) *(pulong32) instruction, FLUSH);
3360 + (u32) *(u32 *) instruction, FLUSH);
3361 instruction += 4;
3362
3363 /* write out the instruction data high addr */
3364 - WRITE_REG(slic_regs->slic_rcv_wcs, (ulong32) *instruction,
3365 + WRITE_REG(slic_regs->slic_rcv_wcs, (u32) *instruction,
3366 FLUSH);
3367 instruction += 1;
3368 }
3369 @@ -2242,22 +2231,22 @@ static int slic_card_download_gbrcv(p_adapter_t adapter)
3370 return 0;
3371 }
3372
3373 -int slic_card_download(p_adapter_t adapter)
3374 +static int slic_card_download(struct adapter *adapter)
3375 {
3376 - ulong32 section;
3377 + u32 section;
3378 int thissectionsize;
3379 int codeaddr;
3380 - p_slic_regs_t slic_regs = adapter->slic_regs;
3381 - ulong32 *instruction = NULL;
3382 - ulong32 *lastinstruct = NULL;
3383 - ulong32 *startinstruct = NULL;
3384 - puchar nextinstruct;
3385 - ulong32 baseaddress;
3386 - ulong32 failure;
3387 - ulong32 i;
3388 - ulong32 numsects = 0;
3389 - ulong32 sectsize[3];
3390 - ulong32 sectstart[3];
3391 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3392 + u32 *instruction = NULL;
3393 + u32 *lastinstruct = NULL;
3394 + u32 *startinstruct = NULL;
3395 + unsigned char *nextinstruct;
3396 + u32 baseaddress;
3397 + u32 failure;
3398 + u32 i;
3399 + u32 numsects = 0;
3400 + u32 sectsize[3];
3401 + u32 sectstart[3];
3402
3403 /* DBG_MSG ("slicoss: %s (%s) adapter[%p] card[%p] devid[%x] \
3404 jiffies[%lx] cpu %d\n", __func__, adapter->netdev->name, adapter,
3405 @@ -2292,19 +2281,19 @@ int slic_card_download(p_adapter_t adapter)
3406 for (section = 0; section < numsects; section++) {
3407 switch (adapter->devid) {
3408 case SLIC_2GB_DEVICE_ID:
3409 - instruction = (pulong32) &OasisUCode[section][0];
3410 + instruction = (u32 *) &OasisUCode[section][0];
3411 baseaddress = sectstart[section];
3412 thissectionsize = sectsize[section] >> 3;
3413 lastinstruct =
3414 - (pulong32) &OasisUCode[section][sectsize[section] -
3415 + (u32 *) &OasisUCode[section][sectsize[section] -
3416 8];
3417 break;
3418 case SLIC_1GB_DEVICE_ID:
3419 - instruction = (pulong32) &MojaveUCode[section][0];
3420 + instruction = (u32 *) &MojaveUCode[section][0];
3421 baseaddress = sectstart[section];
3422 thissectionsize = sectsize[section] >> 3;
3423 lastinstruct =
3424 - (pulong32) &MojaveUCode[section][sectsize[section]
3425 + (u32 *) &MojaveUCode[section][sectsize[section]
3426 - 8];
3427 break;
3428 default:
3429 @@ -2317,21 +2306,21 @@ int slic_card_download(p_adapter_t adapter)
3430
3431 for (codeaddr = 0; codeaddr < thissectionsize; codeaddr++) {
3432 startinstruct = instruction;
3433 - nextinstruct = ((puchar) instruction) + 8;
3434 + nextinstruct = ((unsigned char *)instruction) + 8;
3435 /* Write out instruction address */
3436 WRITE_REG(slic_regs->slic_wcs, baseaddress + codeaddr,
3437 FLUSH);
3438 /* Write out instruction to low addr */
3439 WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH);
3440 #ifdef CONFIG_X86_64
3441 - instruction = (pulong32) ((puchar) instruction + 4);
3442 + instruction = (u32 *)((unsigned char *)instruction + 4);
3443 #else
3444 instruction++;
3445 #endif
3446 /* Write out instruction to high addr */
3447 WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH);
3448 #ifdef CONFIG_X86_64
3449 - instruction = (pulong32) ((puchar) instruction + 4);
3450 + instruction = (u32 *)((unsigned char *)instruction + 4);
3451 #else
3452 instruction++;
3453 #endif
3454 @@ -2341,10 +2330,10 @@ int slic_card_download(p_adapter_t adapter)
3455 for (section = 0; section < numsects; section++) {
3456 switch (adapter->devid) {
3457 case SLIC_2GB_DEVICE_ID:
3458 - instruction = (pulong32) &OasisUCode[section][0];
3459 + instruction = (u32 *)&OasisUCode[section][0];
3460 break;
3461 case SLIC_1GB_DEVICE_ID:
3462 - instruction = (pulong32) &MojaveUCode[section][0];
3463 + instruction = (u32 *)&MojaveUCode[section][0];
3464 break;
3465 default:
3466 ASSERT(0);
3467 @@ -2367,19 +2356,19 @@ int slic_card_download(p_adapter_t adapter)
3468 /* Write out instruction to low addr */
3469 WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH);
3470 #ifdef CONFIG_X86_64
3471 - instruction = (pulong32) ((puchar) instruction + 4);
3472 + instruction = (u32 *)((unsigned char *)instruction + 4);
3473 #else
3474 instruction++;
3475 #endif
3476 /* Write out instruction to high addr */
3477 WRITE_REG(slic_regs->slic_wcs, *instruction, FLUSH);
3478 #ifdef CONFIG_X86_64
3479 - instruction = (pulong32) ((puchar) instruction + 4);
3480 + instruction = (u32 *)((unsigned char *)instruction + 4);
3481 #else
3482 instruction++;
3483 #endif
3484 /* Check SRAM location zero. If it is non-zero. Abort.*/
3485 - failure = READ_REG(slic_regs->slic_reset, 0);
3486 + failure = readl((u32 __iomem *)&slic_regs->slic_reset);
3487 if (failure) {
3488 DBG_MSG
3489 ("slicoss: %s FAILURE EXIT codeaddr[%x] \
3490 @@ -2394,12 +2383,12 @@ int slic_card_download(p_adapter_t adapter)
3491 /* DBG_MSG ("slicoss: Compare done\n");*/
3492
3493 /* Everything OK, kick off the card */
3494 - slic_stall_msec(10);
3495 + mdelay(10);
3496 WRITE_REG(slic_regs->slic_wcs, SLIC_WCS_START, FLUSH);
3497
3498 /* stall for 20 ms, long enough for ucode to init card
3499 and reach mainloop */
3500 - slic_stall_msec(20);
3501 + mdelay(20);
3502
3503 DBG_MSG("slicoss: %s (%s) EXIT adapter[%p] card[%p]\n",
3504 __func__, adapter->netdev->name, adapter, adapter->card);
3505 @@ -2407,9 +2396,9 @@ int slic_card_download(p_adapter_t adapter)
3506 return STATUS_SUCCESS;
3507 }
3508
3509 -void slic_adapter_set_hwaddr(p_adapter_t adapter)
3510 +static void slic_adapter_set_hwaddr(struct adapter *adapter)
3511 {
3512 - p_sliccard_t card = adapter->card;
3513 + struct sliccard *card = adapter->card;
3514
3515 /* DBG_MSG ("%s ENTER card->config_set[%x] port[%d] physport[%d] funct#[%d]\n",
3516 __func__, card->config_set, adapter->port, adapter->physport,
3517 @@ -2420,7 +2409,7 @@ void slic_adapter_set_hwaddr(p_adapter_t adapter)
3518 if ((adapter->card) && (card->config_set)) {
3519 memcpy(adapter->macaddr,
3520 card->config.MacInfo[adapter->functionnumber].macaddrA,
3521 - sizeof(slic_config_mac_t));
3522 + sizeof(struct slic_config_mac));
3523 /* DBG_MSG ("%s AFTER copying from config.macinfo into currmacaddr\n",
3524 __func__);
3525 slic_dbg_macaddrs(adapter);*/
3526 @@ -2438,53 +2427,35 @@ void slic_adapter_set_hwaddr(p_adapter_t adapter)
3527 slic_dbg_macaddrs(adapter); */
3528 }
3529
3530 -void slic_card_halt(p_sliccard_t card, p_adapter_t adapter)
3531 +static void slic_intagg_set(struct adapter *adapter, u32 value)
3532 {
3533 - p_slic_regs_t slic_regs = adapter->slic_regs;
3534 -
3535 - DBG_MSG("slicoss: %s ENTER card[%p] adapter[%p] card->state[%x]\n",
3536 - __func__, card, adapter, card->state);
3537 - WRITE_REG(slic_regs->slic_icr, ICR_INT_OFF, FLUSH);
3538 - adapter->all_reg_writes++;
3539 - adapter->icr_reg_writes++;
3540 - slic_config_clear(adapter);
3541 - WRITE_REG(slic_regs->slic_reset_iface, 0, FLUSH);
3542 - slic_soft_reset(adapter);
3543 - DBG_MSG("slicoss: %s EXIT card[%p] adapter[%p] card->state[%x]\n",
3544 - __func__, card, adapter, card->state);
3545 - return;
3546 -
3547 -}
3548 -
3549 -void slic_intagg_set(p_adapter_t adapter, ulong32 value)
3550 -{
3551 - p_slic_regs_t slic_regs = adapter->slic_regs;
3552 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3553
3554 WRITE_REG(slic_regs->slic_intagg, value, FLUSH);
3555 adapter->card->loadlevel_current = value;
3556 }
3557
3558 -int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3559 +static int slic_card_init(struct sliccard *card, struct adapter *adapter)
3560 {
3561 - p_slic_regs_t slic_regs = adapter->slic_regs;
3562 - pslic_eeprom_t peeprom;
3563 - poslic_eeprom_t pOeeprom;
3564 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3565 + struct slic_eeprom *peeprom;
3566 + struct oslic_eeprom *pOeeprom;
3567 dma_addr_t phys_config;
3568 - ulong32 phys_configh;
3569 - ulong32 phys_configl;
3570 - ulong32 i = 0;
3571 - p_slic_shmem_t pshmem;
3572 + u32 phys_configh;
3573 + u32 phys_configl;
3574 + u32 i = 0;
3575 + struct slic_shmem *pshmem;
3576 int status;
3577 uint macaddrs = card->card_size;
3578 ushort eecodesize;
3579 ushort dramsize;
3580 ushort ee_chksum;
3581 ushort calc_chksum;
3582 - pslic_config_mac_t pmac;
3583 - uchar fruformat;
3584 - uchar oemfruformat;
3585 - patk_fru_t patkfru;
3586 - poemfru_t poemfru;
3587 + struct slic_config_mac *pmac;
3588 + unsigned char fruformat;
3589 + unsigned char oemfruformat;
3590 + struct atk_fru *patkfru;
3591 + union oemfru_t *poemfru;
3592
3593 DBG_MSG
3594 ("slicoss: %s ENTER card[%p] adapter[%p] card->state[%x] \
3595 @@ -2505,7 +2476,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3596
3597 if (!card->config_set) {
3598 peeprom = pci_alloc_consistent(adapter->pcidev,
3599 - sizeof(slic_eeprom_t),
3600 + sizeof(struct slic_eeprom),
3601 &phys_config);
3602
3603 phys_configl = SLIC_GET_ADDR_LOW(phys_config);
3604 @@ -2515,8 +2486,9 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3605 "size [%x]\n peeprom [%p]\n "
3606 "phys_config [%p]\n phys_configl[%x]\n "
3607 "phys_configh[%x]\n",
3608 - __func__, adapter, (ulong32) sizeof(slic_eeprom_t),
3609 - peeprom, (pvoid) phys_config, phys_configl,
3610 + __func__, adapter,
3611 + (u32)sizeof(struct slic_eeprom),
3612 + peeprom, (void *) phys_config, phys_configl,
3613 phys_configh);
3614 if (!peeprom) {
3615 DBG_ERROR
3616 @@ -2526,17 +2498,19 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3617 (uint) adapter->slotnumber);
3618 return -ENOMEM;
3619 } else {
3620 - SLIC_ZERO_MEMORY(peeprom, sizeof(slic_eeprom_t));
3621 + memset(peeprom, 0, sizeof(struct slic_eeprom));
3622 }
3623 WRITE_REG(slic_regs->slic_icr, ICR_INT_OFF, FLUSH);
3624 - slic_stall_msec(1);
3625 - pshmem = (p_slic_shmem_t) adapter->phys_shmem;
3626 + mdelay(1);
3627 + pshmem = (struct slic_shmem *)adapter->phys_shmem;
3628
3629 - SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->bit64reglock);
3630 + spin_lock_irqsave(&adapter->bit64reglock.lock,
3631 + adapter->bit64reglock.flags);
3632 WRITE_REG(slic_regs->slic_addr_upper, 0, DONT_FLUSH);
3633 WRITE_REG(slic_regs->slic_isp,
3634 SLIC_GET_ADDR_LOW(&pshmem->isr), FLUSH);
3635 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->bit64reglock);
3636 + spin_unlock_irqrestore(&adapter->bit64reglock.lock,
3637 + adapter->bit64reglock.flags);
3638
3639 slic_config_get(adapter, phys_configl, phys_configh);
3640
3641 @@ -2564,7 +2538,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3642 FLUSH);
3643 }
3644 } else {
3645 - slic_stall_msec(1);
3646 + mdelay(1);
3647 i++;
3648 if (i > 5000) {
3649 DBG_ERROR
3650 @@ -2586,7 +2560,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3651 /* Oasis card */
3652 case SLIC_2GB_DEVICE_ID:
3653 /* extract EEPROM data and pointers to EEPROM data */
3654 - pOeeprom = (poslic_eeprom_t) peeprom;
3655 + pOeeprom = (struct oslic_eeprom *) peeprom;
3656 eecodesize = pOeeprom->EecodeSize;
3657 dramsize = pOeeprom->DramSize;
3658 pmac = pOeeprom->MacInfo;
3659 @@ -2619,12 +2593,12 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3660 (eecodesize >= MIN_EECODE_SIZE)) {
3661
3662 ee_chksum =
3663 - *(pushort) ((pchar) peeprom + (eecodesize - 2));
3664 + *(u16 *) ((char *) peeprom + (eecodesize - 2));
3665 /*
3666 calculate the EEPROM checksum
3667 */
3668 calc_chksum =
3669 - ~slic_eeprom_cksum((pchar) peeprom,
3670 + ~slic_eeprom_cksum((char *) peeprom,
3671 (eecodesize - 2));
3672 /*
3673 if the ucdoe chksum flag bit worked,
3674 @@ -2639,24 +2613,25 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3675 /* copy in the MAC address(es) */
3676 for (i = 0; i < macaddrs; i++) {
3677 memcpy(&card->config.MacInfo[i],
3678 - &pmac[i], sizeof(slic_config_mac_t));
3679 + &pmac[i], sizeof(struct slic_config_mac));
3680 }
3681 /* DBG_MSG ("%s EEPROM Checksum Good? %d MacAddress\n",__func__,
3682 card->config.EepromValid); */
3683
3684 /* copy the Alacritech FRU information */
3685 card->config.FruFormat = fruformat;
3686 - memcpy(&card->config.AtkFru, patkfru, sizeof(atk_fru_t));
3687 + memcpy(&card->config.AtkFru, patkfru,
3688 + sizeof(struct atk_fru));
3689
3690 pci_free_consistent(adapter->pcidev,
3691 - sizeof(slic_eeprom_t),
3692 + sizeof(struct slic_eeprom),
3693 peeprom, phys_config);
3694 DBG_MSG
3695 ("slicoss: %s adapter%d [%p] size[%x] FREE peeprom[%p] \
3696 phys_config[%p]\n",
3697 __func__, adapter->port, adapter,
3698 - (ulong32) sizeof(slic_eeprom_t), peeprom,
3699 - (pvoid) phys_config);
3700 + (u32) sizeof(struct slic_eeprom), peeprom,
3701 + (void *) phys_config);
3702
3703 if ((!card->config.EepromValid) &&
3704 (adapter->reg_params.fail_on_bad_eeprom)) {
3705 @@ -2698,8 +2673,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3706
3707 #if SLIC_DUMP_ENABLED
3708 if (!card->dumpbuffer) {
3709 - card->dumpbuffer =
3710 - SLIC_ALLOCATE_MEM(DUMP_PAGE_SIZE, GFP_ATOMIC);
3711 + card->dumpbuffer = kmalloc(DUMP_PAGE_SIZE, GFP_ATOMIC);
3712
3713 ASSERT(card->dumpbuffer);
3714 if (card->dumpbuffer == NULL)
3715 @@ -2709,8 +2683,8 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3716 * Smear the shared memory structure and then obtain
3717 * the PHYSICAL address of this structure
3718 */
3719 - SLIC_ZERO_MEMORY(card->dumpbuffer, DUMP_PAGE_SIZE);
3720 - card->dumpbuffer_phys = SLIC_GET_PHYSICAL_ADDRESS(card->dumpbuffer);
3721 + memset(card->dumpbuffer, 0, DUMP_PAGE_SIZE);
3722 + card->dumpbuffer_phys = virt_to_bus(card->dumpbuffer);
3723 card->dumpbuffer_physh = SLIC_GET_ADDR_HIGH(card->dumpbuffer_phys);
3724 card->dumpbuffer_physl = SLIC_GET_ADDR_LOW(card->dumpbuffer_phys);
3725
3726 @@ -2718,8 +2692,7 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3727 * Allocate COMMAND BUFFER
3728 */
3729 if (!card->cmdbuffer) {
3730 - card->cmdbuffer =
3731 - SLIC_ALLOCATE_MEM(sizeof(dump_cmd_t), GFP_ATOMIC);
3732 + card->cmdbuffer = kmalloc(sizeof(dump_cmd_t), GFP_ATOMIC);
3733
3734 ASSERT(card->cmdbuffer);
3735 if (card->cmdbuffer == NULL)
3736 @@ -2729,8 +2702,8 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3737 * Smear the shared memory structure and then obtain
3738 * the PHYSICAL address of this structure
3739 */
3740 - SLIC_ZERO_MEMORY(card->cmdbuffer, sizeof(dump_cmd_t));
3741 - card->cmdbuffer_phys = SLIC_GET_PHYSICAL_ADDRESS(card->cmdbuffer);
3742 + memset(card->cmdbuffer, 0, sizeof(dump_cmd_t));
3743 + card->cmdbuffer_phys = virt_to_bus(card->cmdbuffer);
3744 card->cmdbuffer_physh = SLIC_GET_ADDR_HIGH(card->cmdbuffer_phys);
3745 card->cmdbuffer_physl = SLIC_GET_ADDR_LOW(card->cmdbuffer_phys);
3746 #endif
3747 @@ -2746,10 +2719,10 @@ int slic_card_init(p_sliccard_t card, p_adapter_t adapter)
3748 return STATUS_SUCCESS;
3749 }
3750
3751 -ulong32 slic_card_locate(p_adapter_t adapter)
3752 +static u32 slic_card_locate(struct adapter *adapter)
3753 {
3754 - p_sliccard_t card = slic_global.slic_card;
3755 - p_physcard_t physcard = slic_global.phys_card;
3756 + struct sliccard *card = slic_global.slic_card;
3757 + struct physcard *physcard = slic_global.phys_card;
3758 ushort card_hostid;
3759 u16 __iomem *hostid_reg;
3760 uint i;
3761 @@ -2777,13 +2750,12 @@ ulong32 slic_card_locate(p_adapter_t adapter)
3762 DBG_MSG("slicoss: %s *hostid_reg[%p] == ", __func__, hostid_reg);
3763
3764 /* read the 16 bit hostid from SRAM */
3765 -/* card_hostid = READ_REGP16(hostid_reg, 0);*/
3766 card_hostid = (ushort) readw(hostid_reg);
3767 DBG_MSG(" card_hostid[%x]\n", card_hostid);
3768
3769 /* Initialize a new card structure if need be */
3770 if (card_hostid == SLIC_HOSTID_DEFAULT) {
3771 - card = kzalloc(sizeof(sliccard_t), GFP_KERNEL);
3772 + card = kzalloc(sizeof(struct sliccard), GFP_KERNEL);
3773 if (card == NULL)
3774 return -ENOMEM;
3775
3776 @@ -2861,11 +2833,9 @@ ulong32 slic_card_locate(p_adapter_t adapter)
3777 }
3778 if (!physcard) {
3779 /* no structure allocated for this physical card yet */
3780 - physcard =
3781 - (p_physcard_t) SLIC_ALLOCATE_MEM(sizeof(physcard_t),
3782 - GFP_ATOMIC);
3783 + physcard = kmalloc(sizeof(struct physcard *), GFP_ATOMIC);
3784 ASSERT(physcard);
3785 - SLIC_ZERO_MEMORY(physcard, sizeof(physcard_t));
3786 + memset(physcard, 0, sizeof(struct physcard *));
3787
3788 DBG_MSG
3789 ("\n%s Allocate a PHYSICALcard:\n PHYSICAL_Card[%p]\n\
3790 @@ -2890,130 +2860,27 @@ ulong32 slic_card_locate(p_adapter_t adapter)
3791 return 0;
3792 }
3793
3794 -void slic_card_remaster(p_adapter_t adapter)
3795 -{
3796 - p_sliccard_t card = adapter->card;
3797 - int i;
3798 -
3799 - DBG_MSG("slicoss: %s card->master[%p] == adapter[%p]??\n",
3800 - __func__, card->master, adapter);
3801 - if (card->master != adapter)
3802 - return;
3803 - card->master = NULL;
3804 - for (i = 0; i < SLIC_MAX_PORTS; i++) {
3805 - if (card->adapter[i] && (card->adapter[i] != adapter)) {
3806 - card->master = card->adapter[i];
3807 - DBG_MSG("slicoss: %s NEW MASTER SET card->master[%p]"
3808 - " == card->adapter[%d]\n", __func__,
3809 - card->master, i);
3810 - break;
3811 - }
3812 - }
3813 -}
3814 -
3815 -void slic_soft_reset(p_adapter_t adapter)
3816 +static void slic_soft_reset(struct adapter *adapter)
3817 {
3818 if (adapter->card->state == CARD_UP) {
3819 DBG_MSG("slicoss: %s QUIESCE adapter[%p] card[%p] devid[%x]\n",
3820 __func__, adapter, adapter->card, adapter->devid);
3821 WRITE_REG(adapter->slic_regs->slic_quiesce, 0, FLUSH);
3822 - slic_stall_msec(1);
3823 + mdelay(1);
3824 }
3825 /* DBG_MSG ("slicoss: %s (%s) adapter[%p] card[%p] devid[%x]\n",
3826 __func__, adapter->netdev->name, adapter, adapter->card,
3827 adapter->devid); */
3828
3829 WRITE_REG(adapter->slic_regs->slic_reset, SLIC_RESET_MAGIC, FLUSH);
3830 - slic_stall_msec(1);
3831 -}
3832 -
3833 -void slic_card_reset(p_adapter_t adapter)
3834 -{
3835 - p_sliccard_t card = adapter->card;
3836 - p_slic_upr_t upr = adapter->upr_list;
3837 - p_slic_upr_t upr_next = NULL;
3838 - ulong32 i;
3839 -#if SLIC_FAILURE_RESET
3840 - ulong32 status = 0;
3841 -#endif
3842 - DBG_MSG
3843 - ("slicoss: %s adapter[%p] port[%d] state[%x] card[%p] state[%x]\n",
3844 - __func__, adapter, adapter->port, adapter->state, card,
3845 - card->state);
3846 - SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->adapter_lock);
3847 - SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->reset_lock);
3848 - if (card->state == CARD_DIAG) {
3849 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->reset_lock);
3850 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->adapter_lock);
3851 - return;
3852 - }
3853 - SLIC_ACQUIRE_IRQ_SPINLOCK(slic_global.driver_lock);
3854 - card->reset_in_progress = 1;
3855 -#if SLIC_FAILURE_RESET
3856 - if (adapter->state != ADAPT_RESET) {
3857 - SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock);
3858 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->reset_lock);
3859 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->adapter_lock);
3860 - return;
3861 - }
3862 -
3863 - adapter->state = ADAPT_DOWN;
3864 - adapter->linkstate = LINK_DOWN;
3865 -#endif
3866 - if (adapter->gennumber == card->gennumber) {
3867 - for (i = 0; i < card->card_size; i++) {
3868 - if (card->adapter[i]) {
3869 - if (card->adapter[i] == adapter)
3870 - continue;
3871 - if (card->adapter[i]->state == ADAPT_UP) {
3872 - card->adapter[i]->state = ADAPT_RESET;
3873 - adapter->linkstate = LINK_DOWN;
3874 - }
3875 - }
3876 - }
3877 -#if SLIC_FAILURE_RESET
3878 - slic_soft_reset(adapter);
3879 - card->state = CARD_DOWN;
3880 - card->master = NULL;
3881 - card->adapters_activated = 0;
3882 -#endif
3883 - card->gennumber++;
3884 - }
3885 - adapter->gennumber = card->gennumber;
3886 - adapter->pshmem->isr = 0;
3887 - adapter->isrcopy = 0;
3888 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->reset_lock);
3889 - for (i = 0; i < card->card_size; i++) {
3890 - if (card->adapter[i])
3891 - slic_cmdq_reset(card->adapter[i]);
3892 - }
3893 - while (upr) {
3894 - upr_next = upr->next;
3895 - SLIC_DEALLOCATE_MEM(upr);
3896 - upr = upr_next;
3897 - }
3898 - adapter->upr_list = NULL;
3899 - adapter->upr_busy = 0;
3900 -#if SLIC_FAILURE_RESET
3901 - status = slic_if_init(adapter);
3902 - if ((status == 0) && (!card->master))
3903 - card->master = adapter;
3904 - slic_mcast_set_mask(adapter);
3905 -#endif
3906 - SLIC_RELEASE_IRQ_SPINLOCK(slic_global.driver_lock);
3907 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->adapter_lock);
3908 - DBG_MSG
3909 - ("slicoss: %s EXIT adapter[%p] port[%d] state[%x] card[%p] \
3910 - state[%x]\n", __func__, adapter, adapter->port, adapter->state,
3911 - card, card->state);
3912 - return;
3913 + mdelay(1);
3914 }
3915
3916 -void slic_config_set(p_adapter_t adapter, boolean linkchange)
3917 +static void slic_config_set(struct adapter *adapter, bool linkchange)
3918 {
3919 - ulong32 value;
3920 - ulong32 RcrReset;
3921 - p_slic_regs_t slic_regs = adapter->slic_regs;
3922 + u32 value;
3923 + u32 RcrReset;
3924 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3925
3926 DBG_MSG("slicoss: %s (%s) slic_interface_enable[%p](%d)\n",
3927 __func__, adapter->netdev->name, adapter,
3928 @@ -3075,11 +2942,11 @@ void slic_config_set(p_adapter_t adapter, boolean linkchange)
3929 /*
3930 * Turn off RCV and XMT, power down PHY
3931 */
3932 -void slic_config_clear(p_adapter_t adapter)
3933 +static void slic_config_clear(struct adapter *adapter)
3934 {
3935 - ulong32 value;
3936 - ulong32 phy_config;
3937 - p_slic_regs_t slic_regs = adapter->slic_regs;
3938 + u32 value;
3939 + u32 phy_config;
3940 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3941
3942 /* Setup xmtcfg */
3943 value = (GXCR_RESET | /* Always reset */
3944 @@ -3099,28 +2966,29 @@ void slic_config_clear(p_adapter_t adapter)
3945 WRITE_REG(slic_regs->slic_wphy, phy_config, FLUSH);
3946 }
3947
3948 -void slic_config_get(p_adapter_t adapter, ulong32 config, ulong32 config_h)
3949 +static void slic_config_get(struct adapter *adapter, u32 config,
3950 + u32 config_h)
3951 {
3952 int status;
3953
3954 status = slic_upr_request(adapter,
3955 SLIC_UPR_RCONFIG,
3956 - (ulong32) config, (ulong32) config_h, 0, 0);
3957 + (u32) config, (u32) config_h, 0, 0);
3958 ASSERT(status == 0);
3959 }
3960
3961 -void slic_mac_address_config(p_adapter_t adapter)
3962 +static void slic_mac_address_config(struct adapter *adapter)
3963 {
3964 - ulong32 value;
3965 - ulong32 value2;
3966 - p_slic_regs_t slic_regs = adapter->slic_regs;
3967 + u32 value;
3968 + u32 value2;
3969 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3970
3971 - value = *(pulong32) &adapter->currmacaddr[2];
3972 + value = *(u32 *) &adapter->currmacaddr[2];
3973 value = ntohl(value);
3974 WRITE_REG(slic_regs->slic_wraddral, value, FLUSH);
3975 WRITE_REG(slic_regs->slic_wraddrbl, value, FLUSH);
3976
3977 - value2 = (ulong32) ((adapter->currmacaddr[0] << 8 |
3978 + value2 = (u32) ((adapter->currmacaddr[0] << 8 |
3979 adapter->currmacaddr[1]) & 0xFFFF);
3980
3981 WRITE_REG(slic_regs->slic_wraddrah, value2, FLUSH);
3982 @@ -3136,10 +3004,10 @@ void slic_mac_address_config(p_adapter_t adapter)
3983 slic_mcast_set_mask(adapter);
3984 }
3985
3986 -void slic_mac_config(p_adapter_t adapter)
3987 +static void slic_mac_config(struct adapter *adapter)
3988 {
3989 - ulong32 value;
3990 - p_slic_regs_t slic_regs = adapter->slic_regs;
3991 + u32 value;
3992 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
3993
3994 /* Setup GMAC gaps */
3995 if (adapter->linkspeed == LINK_1000MB) {
3996 @@ -3169,12 +3037,13 @@ void slic_mac_config(p_adapter_t adapter)
3997 slic_mac_address_config(adapter);
3998 }
3999
4000 -boolean slic_mac_filter(p_adapter_t adapter, p_ether_header ether_frame)
4001 +static bool slic_mac_filter(struct adapter *adapter,
4002 + struct ether_header *ether_frame)
4003 {
4004 - ulong32 opts = adapter->macopts;
4005 - pulong32 dhost4 = (pulong32) &ether_frame->ether_dhost[0];
4006 - pushort dhost2 = (pushort) &ether_frame->ether_dhost[4];
4007 - boolean equaladdr;
4008 + u32 opts = adapter->macopts;
4009 + u32 *dhost4 = (u32 *)&ether_frame->ether_dhost[0];
4010 + u16 *dhost2 = (u16 *)&ether_frame->ether_dhost[4];
4011 + bool equaladdr;
4012
4013 if (opts & MAC_PROMISC) {
4014 DBG_MSG("slicoss: %s (%s) PROMISCUOUS. Accept frame\n",
4015 @@ -3198,7 +3067,7 @@ boolean slic_mac_filter(p_adapter_t adapter, p_ether_header ether_frame)
4016 return TRUE;
4017 }
4018 if (opts & MAC_MCAST) {
4019 - p_mcast_address_t mcaddr = adapter->mcastaddrs;
4020 + struct mcast_address *mcaddr = adapter->mcastaddrs;
4021
4022 while (mcaddr) {
4023 ETHER_EQ_ADDR(mcaddr->address,
4024 @@ -3224,9 +3093,9 @@ boolean slic_mac_filter(p_adapter_t adapter, p_ether_header ether_frame)
4025
4026 }
4027
4028 -int slic_mac_set_address(struct net_device *dev, pvoid ptr)
4029 +static int slic_mac_set_address(struct net_device *dev, void *ptr)
4030 {
4031 - p_adapter_t adapter = (p_adapter_t) netdev_priv(dev);
4032 + struct adapter *adapter = (struct adapter *)netdev_priv(dev);
4033 struct sockaddr *addr = ptr;
4034
4035 DBG_MSG("%s ENTER (%s)\n", __func__, adapter->netdev->name);
4036 @@ -3259,21 +3128,21 @@ int slic_mac_set_address(struct net_device *dev, pvoid ptr)
4037 * 50 seconds or whatever STATS_TIMER_INTERVAL is set to.
4038 *
4039 */
4040 -void slic_timer_get_stats(ulong dev)
4041 +static void slic_timer_get_stats(ulong dev)
4042 {
4043 - p_adapter_t adapter;
4044 - p_sliccard_t card;
4045 - p_slic_shmem_t pshmem;
4046 + struct adapter *adapter;
4047 + struct sliccard *card;
4048 + struct slic_shmem *pshmem;
4049
4050 ASSERT(dev);
4051 - adapter = (p_adapter_t) ((struct net_device *)dev)->priv;
4052 + adapter = (struct adapter *)((struct net_device *)dev)->priv;
4053 ASSERT(adapter);
4054 card = adapter->card;
4055 ASSERT(card);
4056
4057 if ((card->state == CARD_UP) &&
4058 (adapter->state == ADAPT_UP) && (adapter->linkstate == LINK_UP)) {
4059 - pshmem = (p_slic_shmem_t) adapter->phys_shmem;
4060 + pshmem = (struct slic_shmem *)adapter->phys_shmem;
4061 #ifdef CONFIG_X86_64
4062 slic_upr_request(adapter,
4063 SLIC_UPR_STATS,
4064 @@ -3282,7 +3151,7 @@ void slic_timer_get_stats(ulong dev)
4065 #elif defined(CONFIG_X86)
4066 slic_upr_request(adapter,
4067 SLIC_UPR_STATS,
4068 - (ulong32) &pshmem->inicstats, 0, 0, 0);
4069 + (u32) &pshmem->inicstats, 0, 0, 0);
4070 #else
4071 Stop compilation;
4072 #endif
4073 @@ -3295,12 +3164,12 @@ void slic_timer_get_stats(ulong dev)
4074 add_timer(&adapter->statstimer);
4075 }
4076
4077 -void slic_timer_load_check(ulong cardaddr)
4078 +static void slic_timer_load_check(ulong cardaddr)
4079 {
4080 - p_sliccard_t card = (p_sliccard_t) cardaddr;
4081 - p_adapter_t adapter = card->master;
4082 - ulong32 load = card->events;
4083 - ulong32 level = 0;
4084 + struct sliccard *card = (struct sliccard *)cardaddr;
4085 + struct adapter *adapter = card->master;
4086 + u32 load = card->events;
4087 + u32 level = 0;
4088
4089 if ((adapter) && (adapter->state == ADAPT_UP) &&
4090 (card->state == CARD_UP) && (slic_global.dynamic_intagg)) {
4091 @@ -3352,36 +3221,26 @@ void slic_timer_load_check(ulong cardaddr)
4092 add_timer(&card->loadtimer);
4093 }
4094
4095 -void slic_stall_msec(int stall)
4096 -{
4097 - mdelay(stall);
4098 -}
4099 -
4100 -void slic_stall_usec(int stall)
4101 -{
4102 - udelay(stall);
4103 -}
4104 -
4105 -void slic_assert_fail(void)
4106 +static void slic_assert_fail(void)
4107 {
4108 - ulong32 cpuid;
4109 - ulong32 curr_pid;
4110 + u32 cpuid;
4111 + u32 curr_pid;
4112 cpuid = smp_processor_id();
4113 curr_pid = current->pid;
4114
4115 DBG_ERROR("%s CPU # %d ---- PID # %d\n", __func__, cpuid, curr_pid);
4116 }
4117
4118 -int slic_upr_queue_request(p_adapter_t adapter,
4119 - ulong32 upr_request,
4120 - ulong32 upr_data,
4121 - ulong32 upr_data_h,
4122 - ulong32 upr_buffer, ulong32 upr_buffer_h)
4123 +static int slic_upr_queue_request(struct adapter *adapter,
4124 + u32 upr_request,
4125 + u32 upr_data,
4126 + u32 upr_data_h,
4127 + u32 upr_buffer, u32 upr_buffer_h)
4128 {
4129 - p_slic_upr_t upr;
4130 - p_slic_upr_t uprqueue;
4131 + struct slic_upr *upr;
4132 + struct slic_upr *uprqueue;
4133
4134 - upr = SLIC_ALLOCATE_MEM(sizeof(slic_upr_t), GFP_ATOMIC);
4135 + upr = kmalloc(sizeof(struct slic_upr), GFP_ATOMIC);
4136 if (!upr) {
4137 DBG_MSG("%s COULD NOT ALLOCATE UPR MEM\n", __func__);
4138
4139 @@ -3406,42 +3265,45 @@ int slic_upr_queue_request(p_adapter_t adapter,
4140 return STATUS_SUCCESS;
4141 }
4142
4143 -int slic_upr_request(p_adapter_t adapter,
4144 - ulong32 upr_request,
4145 - ulong32 upr_data,
4146 - ulong32 upr_data_h,
4147 - ulong32 upr_buffer, ulong32 upr_buffer_h)
4148 +static int slic_upr_request(struct adapter *adapter,
4149 + u32 upr_request,
4150 + u32 upr_data,
4151 + u32 upr_data_h,
4152 + u32 upr_buffer, u32 upr_buffer_h)
4153 {
4154 int status;
4155
4156 - SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->upr_lock);
4157 + spin_lock_irqsave(&adapter->upr_lock.lock, adapter->upr_lock.flags);
4158 status = slic_upr_queue_request(adapter,
4159 upr_request,
4160 upr_data,
4161 upr_data_h, upr_buffer, upr_buffer_h);
4162 if (status != STATUS_SUCCESS) {
4163 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->upr_lock);
4164 + spin_unlock_irqrestore(&adapter->upr_lock.lock,
4165 + adapter->upr_lock.flags);
4166 return status;
4167 }
4168 slic_upr_start(adapter);
4169 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->upr_lock);
4170 + spin_unlock_irqrestore(&adapter->upr_lock.lock,
4171 + adapter->upr_lock.flags);
4172 return STATUS_PENDING;
4173 }
4174
4175 -void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr)
4176 +static void slic_upr_request_complete(struct adapter *adapter, u32 isr)
4177 {
4178 - p_sliccard_t card = adapter->card;
4179 - p_slic_upr_t upr;
4180 + struct sliccard *card = adapter->card;
4181 + struct slic_upr *upr;
4182
4183 /* if (card->dump_requested) {
4184 DBG_MSG("ENTER slic_upr_request_complete Dump in progress ISR[%x]\n",
4185 isr);
4186 } */
4187 - SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->upr_lock);
4188 + spin_lock_irqsave(&adapter->upr_lock.lock, adapter->upr_lock.flags);
4189 upr = adapter->upr_list;
4190 if (!upr) {
4191 ASSERT(0);
4192 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->upr_lock);
4193 + spin_unlock_irqrestore(&adapter->upr_lock.lock,
4194 + adapter->upr_lock.flags);
4195 return;
4196 }
4197 adapter->upr_list = upr->next;
4198 @@ -3452,11 +3314,11 @@ void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr)
4199 case SLIC_UPR_STATS:
4200 {
4201 #if SLIC_GET_STATS_ENABLED
4202 - p_slic_stats_t slicstats =
4203 - (p_slic_stats_t) &adapter->pshmem->inicstats;
4204 - p_slic_stats_t newstats = slicstats;
4205 - p_slic_stats_t old = &adapter->inicstats_prev;
4206 - p_slicnet_stats_t stst = &adapter->slic_stats;
4207 + struct slic_stats *slicstats =
4208 + (struct slic_stats *) &adapter->pshmem->inicstats;
4209 + struct slic_stats *newstats = slicstats;
4210 + struct slic_stats *old = &adapter->inicstats_prev;
4211 + struct slicnet_stats *stst = &adapter->slic_stats;
4212 #endif
4213 if (isr & ISR_UPCERR) {
4214 DBG_ERROR
4215 @@ -3540,7 +3402,7 @@ void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr)
4216 (newstats->rcv_drops_gb -
4217 old->rcv_drops_gb);
4218 }
4219 - memcpy(old, newstats, sizeof(slic_stats_t));
4220 + memcpy(old, newstats, sizeof(struct slic_stats));
4221 #endif
4222 break;
4223 }
4224 @@ -3572,15 +3434,16 @@ void slic_upr_request_complete(p_adapter_t adapter, ulong32 isr)
4225 default:
4226 ASSERT(0);
4227 }
4228 - SLIC_DEALLOCATE_MEM(upr);
4229 + kfree(upr);
4230 slic_upr_start(adapter);
4231 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->upr_lock);
4232 + spin_unlock_irqrestore(&adapter->upr_lock.lock,
4233 + adapter->upr_lock.flags);
4234 }
4235
4236 -void slic_upr_start(p_adapter_t adapter)
4237 +static void slic_upr_start(struct adapter *adapter)
4238 {
4239 - p_slic_upr_t upr;
4240 - p_slic_regs_t slic_regs = adapter->slic_regs;
4241 + struct slic_upr *upr;
4242 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
4243 /*
4244 char * ptr1;
4245 char * ptr2;
4246 @@ -3670,21 +3533,21 @@ void slic_upr_start(p_adapter_t adapter)
4247 }
4248 }
4249
4250 -void slic_link_upr_complete(p_adapter_t adapter, ulong32 isr)
4251 +static void slic_link_upr_complete(struct adapter *adapter, u32 isr)
4252 {
4253 - ulong32 linkstatus = adapter->pshmem->linkstatus;
4254 + u32 linkstatus = adapter->pshmem->linkstatus;
4255 uint linkup;
4256 - uchar linkspeed;
4257 - uchar linkduplex;
4258 + unsigned char linkspeed;
4259 + unsigned char linkduplex;
4260
4261 DBG_MSG("%s: %s ISR[%x] linkstatus[%x]\n adapter[%p](%d)\n",
4262 __func__, adapter->netdev->name, isr, linkstatus, adapter,
4263 adapter->cardindex);
4264
4265 if ((isr & ISR_UPCERR) || (isr & ISR_UPCBSY)) {
4266 - p_slic_shmem_t pshmem;
4267 + struct slic_shmem *pshmem;
4268
4269 - pshmem = (p_slic_shmem_t) adapter->phys_shmem;
4270 + pshmem = (struct slic_shmem *)adapter->phys_shmem;
4271 #if defined(CONFIG_X86_64)
4272 slic_upr_queue_request(adapter,
4273 SLIC_UPR_RLSR,
4274 @@ -3694,7 +3557,7 @@ void slic_link_upr_complete(p_adapter_t adapter, ulong32 isr)
4275 #elif defined(CONFIG_X86)
4276 slic_upr_queue_request(adapter,
4277 SLIC_UPR_RLSR,
4278 - (ulong32) &pshmem->linkstatus,
4279 + (u32) &pshmem->linkstatus,
4280 SLIC_GET_ADDR_HIGH(pshmem), 0, 0);
4281 #else
4282 Stop Compilation;
4283 @@ -3792,16 +3655,16 @@ void slic_link_upr_complete(p_adapter_t adapter, ulong32 isr)
4284 * which prevens us from using the ucode result.
4285 * remove this once ucode is fixed.
4286 */
4287 -ushort slic_eeprom_cksum(pchar m, int len)
4288 +static ushort slic_eeprom_cksum(char *m, int len)
4289 {
4290 #define ADDCARRY(x) (x > 65535 ? x -= 65535 : x)
4291 #define REDUCE {l_util.l = sum; sum = l_util.s[0] + l_util.s[1]; ADDCARRY(sum);\
4292 }
4293
4294 - pushort w;
4295 - ulong32 sum = 0;
4296 - ulong32 byte_swapped = 0;
4297 - ulong32 w_int;
4298 + u16 *w;
4299 + u32 sum = 0;
4300 + u32 byte_swapped = 0;
4301 + u32 w_int;
4302
4303 union {
4304 char c[2];
4305 @@ -3816,17 +3679,17 @@ ushort slic_eeprom_cksum(pchar m, int len)
4306 l_util.l = 0;
4307 s_util.s = 0;
4308
4309 - w = (pushort) m;
4310 + w = (u16 *)m;
4311 #ifdef CONFIG_X86_64
4312 - w_int = (ulong32) ((ulong) w & 0x00000000FFFFFFFF);
4313 + w_int = (u32) ((ulong) w & 0x00000000FFFFFFFF);
4314 #else
4315 - w_int = (ulong32) (w);
4316 + w_int = (u32) (w);
4317 #endif
4318 if ((1 & w_int) && (len > 0)) {
4319 REDUCE;
4320 sum <<= 8;
4321 - s_util.c[0] = *(puchar) w;
4322 - w = (pushort) ((char *)w + 1);
4323 + s_util.c[0] = *(unsigned char *)w;
4324 + w = (u16 *)((char *)w + 1);
4325 len--;
4326 byte_swapped = 1;
4327 }
4328 @@ -3849,7 +3712,7 @@ ushort slic_eeprom_cksum(pchar m, int len)
4329 sum += w[13];
4330 sum += w[14];
4331 sum += w[15];
4332 - w = (pushort) ((ulong) w + 16); /* verify */
4333 + w = (u16 *)((ulong) w + 16); /* verify */
4334 }
4335 len += 32;
4336 while ((len -= 8) >= 0) {
4337 @@ -3857,7 +3720,7 @@ ushort slic_eeprom_cksum(pchar m, int len)
4338 sum += w[1];
4339 sum += w[2];
4340 sum += w[3];
4341 - w = (pushort) ((ulong) w + 4); /* verify */
4342 + w = (u16 *)((ulong) w + 4); /* verify */
4343 }
4344 len += 8;
4345 if (len != 0 || byte_swapped != 0) {
4346 @@ -3869,7 +3732,7 @@ ushort slic_eeprom_cksum(pchar m, int len)
4347 sum <<= 8;
4348 byte_swapped = 0;
4349 if (len == -1) {
4350 - s_util.c[1] = *(pchar) w;
4351 + s_util.c[1] = *(char *) w;
4352 sum += s_util.s;
4353 len = 0;
4354 } else {
4355 @@ -3877,7 +3740,7 @@ ushort slic_eeprom_cksum(pchar m, int len)
4356 }
4357
4358 } else if (len == -1) {
4359 - s_util.c[0] = *(pchar) w;
4360 + s_util.c[0] = *(char *) w;
4361 }
4362
4363 if (len == -1) {
4364 @@ -3889,17 +3752,17 @@ ushort slic_eeprom_cksum(pchar m, int len)
4365 return (ushort) sum;
4366 }
4367
4368 -int slic_rspqueue_init(p_adapter_t adapter)
4369 +static int slic_rspqueue_init(struct adapter *adapter)
4370 {
4371 int i;
4372 - p_slic_rspqueue_t rspq = &adapter->rspqueue;
4373 - p_slic_regs_t slic_regs = adapter->slic_regs;
4374 - ulong32 paddrh = 0;
4375 + struct slic_rspqueue *rspq = &adapter->rspqueue;
4376 + __iomem struct slic_regs *slic_regs = adapter->slic_regs;
4377 + u32 paddrh = 0;
4378
4379 DBG_MSG("slicoss: %s (%s) ENTER adapter[%p]\n", __func__,
4380 adapter->netdev->name, adapter);
4381 ASSERT(adapter->state == ADAPT_DOWN);
4382 - SLIC_ZERO_MEMORY(rspq, sizeof(slic_rspqueue_t));
4383 + memset(rspq, 0, sizeof(struct slic_rspqueue));
4384
4385 rspq->num_pages = SLIC_RSPQ_PAGES_GB;
4386
4387 @@ -3914,12 +3777,12 @@ int slic_rspqueue_init(p_adapter_t adapter)
4388 return STATUS_FAILURE;
4389 }
4390 #ifndef CONFIG_X86_64
4391 - ASSERT(((ulong32) rspq->vaddr[i] & 0xFFFFF000) ==
4392 - (ulong32) rspq->vaddr[i]);
4393 - ASSERT(((ulong32) rspq->paddr[i] & 0xFFFFF000) ==
4394 - (ulong32) rspq->paddr[i]);
4395 + ASSERT(((u32) rspq->vaddr[i] & 0xFFFFF000) ==
4396 + (u32) rspq->vaddr[i]);
4397 + ASSERT(((u32) rspq->paddr[i] & 0xFFFFF000) ==
4398 + (u32) rspq->paddr[i]);
4399 #endif
4400 - SLIC_ZERO_MEMORY(rspq->vaddr[i], PAGE_SIZE);
4401 + memset(rspq->vaddr[i], 0, PAGE_SIZE);
4402 /* DBG_MSG("slicoss: %s UPLOAD RSPBUFF Page pageix[%x] paddr[%p] "
4403 "vaddr[%p]\n",
4404 __func__, i, (void *)rspq->paddr[i], rspq->vaddr[i]); */
4405 @@ -3938,15 +3801,15 @@ int slic_rspqueue_init(p_adapter_t adapter)
4406 }
4407 rspq->offset = 0;
4408 rspq->pageindex = 0;
4409 - rspq->rspbuf = (p_slic_rspbuf_t) rspq->vaddr[0];
4410 + rspq->rspbuf = (struct slic_rspbuf *)rspq->vaddr[0];
4411 DBG_MSG("slicoss: %s (%s) EXIT adapter[%p]\n", __func__,
4412 adapter->netdev->name, adapter);
4413 return STATUS_SUCCESS;
4414 }
4415
4416 -int slic_rspqueue_reset(p_adapter_t adapter)
4417 +static int slic_rspqueue_reset(struct adapter *adapter)
4418 {
4419 - p_slic_rspqueue_t rspq = &adapter->rspqueue;
4420 + struct slic_rspqueue *rspq = &adapter->rspqueue;
4421
4422 DBG_MSG("slicoss: %s (%s) ENTER adapter[%p]\n", __func__,
4423 adapter->netdev->name, adapter);
4424 @@ -3964,10 +3827,10 @@ int slic_rspqueue_reset(p_adapter_t adapter)
4425 return STATUS_SUCCESS;
4426 }
4427
4428 -void slic_rspqueue_free(p_adapter_t adapter)
4429 +static void slic_rspqueue_free(struct adapter *adapter)
4430 {
4431 int i;
4432 - slic_rspqueue_t *rspq = &adapter->rspqueue;
4433 + struct slic_rspqueue *rspq = &adapter->rspqueue;
4434
4435 DBG_MSG("slicoss: %s adapter[%p] port %d rspq[%p] FreeRSPQ\n",
4436 __func__, adapter, adapter->physport, rspq);
4437 @@ -3976,7 +3839,7 @@ void slic_rspqueue_free(p_adapter_t adapter)
4438 DBG_MSG
4439 ("slicoss: pci_free_consistent rspq->vaddr[%p] \
4440 paddr[%p]\n",
4441 - rspq->vaddr[i], (pvoid) rspq->paddr[i]);
4442 + rspq->vaddr[i], (void *) rspq->paddr[i]);
4443 pci_free_consistent(adapter->pcidev, PAGE_SIZE,
4444 rspq->vaddr[i], rspq->paddr[i]);
4445 }
4446 @@ -3988,10 +3851,10 @@ void slic_rspqueue_free(p_adapter_t adapter)
4447 rspq->rspbuf = NULL;
4448 }
4449
4450 -p_slic_rspbuf_t slic_rspqueue_getnext(p_adapter_t adapter)
4451 +static struct slic_rspbuf *slic_rspqueue_getnext(struct adapter *adapter)
4452 {
4453 - p_slic_rspqueue_t rspq = &adapter->rspqueue;
4454 - p_slic_rspbuf_t buf;
4455 + struct slic_rspqueue *rspq = &adapter->rspqueue;
4456 + struct slic_rspbuf *buf;
4457
4458 if (!(rspq->rspbuf->status))
4459 return NULL;
4460 @@ -4004,8 +3867,8 @@ p_slic_rspbuf_t slic_rspqueue_getnext(p_adapter_t adapter)
4461 if (++rspq->offset < SLIC_RSPQ_BUFSINPAGE) {
4462 rspq->rspbuf++;
4463 #ifndef CONFIG_X86_64
4464 - ASSERT(((ulong32) rspq->rspbuf & 0xFFFFFFE0) ==
4465 - (ulong32) rspq->rspbuf);
4466 + ASSERT(((u32) rspq->rspbuf & 0xFFFFFFE0) ==
4467 + (u32) rspq->rspbuf);
4468 #endif
4469 } else {
4470 ASSERT(rspq->offset == SLIC_RSPQ_BUFSINPAGE);
4471 @@ -4016,28 +3879,29 @@ p_slic_rspbuf_t slic_rspqueue_getnext(p_adapter_t adapter)
4472 adapter->slic_regs->slic_addr_upper, 0, DONT_FLUSH);
4473 rspq->pageindex = (++rspq->pageindex) % rspq->num_pages;
4474 rspq->offset = 0;
4475 - rspq->rspbuf = (p_slic_rspbuf_t) rspq->vaddr[rspq->pageindex];
4476 + rspq->rspbuf = (struct slic_rspbuf *)
4477 + rspq->vaddr[rspq->pageindex];
4478 #ifndef CONFIG_X86_64
4479 - ASSERT(((ulong32) rspq->rspbuf & 0xFFFFF000) ==
4480 - (ulong32) rspq->rspbuf);
4481 + ASSERT(((u32) rspq->rspbuf & 0xFFFFF000) ==
4482 + (u32) rspq->rspbuf);
4483 #endif
4484 }
4485 #ifndef CONFIG_X86_64
4486 - ASSERT(((ulong32) buf & 0xFFFFFFE0) == (ulong32) buf);
4487 + ASSERT(((u32) buf & 0xFFFFFFE0) == (u32) buf);
4488 #endif
4489 return buf;
4490 }
4491
4492 -void slic_cmdqmem_init(p_adapter_t adapter)
4493 +static void slic_cmdqmem_init(struct adapter *adapter)
4494 {
4495 - slic_cmdqmem_t *cmdqmem = &adapter->cmdqmem;
4496 + struct slic_cmdqmem *cmdqmem = &adapter->cmdqmem;
4497
4498 - SLIC_ZERO_MEMORY(cmdqmem, sizeof(slic_cmdqmem_t));
4499 + memset(cmdqmem, 0, sizeof(struct slic_cmdqmem));
4500 }
4501
4502 -void slic_cmdqmem_free(p_adapter_t adapter)
4503 +static void slic_cmdqmem_free(struct adapter *adapter)
4504 {
4505 - slic_cmdqmem_t *cmdqmem = &adapter->cmdqmem;
4506 + struct slic_cmdqmem *cmdqmem = &adapter->cmdqmem;
4507 int i;
4508
4509 DBG_MSG("slicoss: (%s) adapter[%p] port %d rspq[%p] Free CMDQ Memory\n",
4510 @@ -4045,20 +3909,20 @@ void slic_cmdqmem_free(p_adapter_t adapter)
4511 for (i = 0; i < SLIC_CMDQ_MAXPAGES; i++) {
4512 if (cmdqmem->pages[i]) {
4513 DBG_MSG("slicoss: %s Deallocate page CmdQPage[%p]\n",
4514 - __func__, (pvoid) cmdqmem->pages[i]);
4515 + __func__, (void *) cmdqmem->pages[i]);
4516 pci_free_consistent(adapter->pcidev,
4517 PAGE_SIZE,
4518 - (pvoid) cmdqmem->pages[i],
4519 + (void *) cmdqmem->pages[i],
4520 cmdqmem->dma_pages[i]);
4521 }
4522 }
4523 - SLIC_ZERO_MEMORY(cmdqmem, sizeof(slic_cmdqmem_t));
4524 + memset(cmdqmem, 0, sizeof(struct slic_cmdqmem));
4525 }
4526
4527 -pulong32 slic_cmdqmem_addpage(p_adapter_t adapter)
4528 +static u32 *slic_cmdqmem_addpage(struct adapter *adapter)
4529 {
4530 - p_slic_cmdqmem_t cmdqmem = &adapter->cmdqmem;
4531 - pulong32 pageaddr;
4532 + struct slic_cmdqmem *cmdqmem = &adapter->cmdqmem;
4533 + u32 *pageaddr;
4534
4535 if (cmdqmem->pagecnt >= SLIC_CMDQ_MAXPAGES)
4536 return NULL;
4537 @@ -4068,32 +3932,32 @@ pulong32 slic_cmdqmem_addpage(p_adapter_t adapter)
4538 if (!pageaddr)
4539 return NULL;
4540 #ifndef CONFIG_X86_64
4541 - ASSERT(((ulong32) pageaddr & 0xFFFFF000) == (ulong32) pageaddr);
4542 + ASSERT(((u32) pageaddr & 0xFFFFF000) == (u32) pageaddr);
4543 #endif
4544 cmdqmem->pages[cmdqmem->pagecnt] = pageaddr;
4545 cmdqmem->pagecnt++;
4546 return pageaddr;
4547 }
4548
4549 -int slic_cmdq_init(p_adapter_t adapter)
4550 +static int slic_cmdq_init(struct adapter *adapter)
4551 {
4552 int i;
4553 - pulong32 pageaddr;
4554 + u32 *pageaddr;
4555
4556 DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter);
4557 ASSERT(adapter->state == ADAPT_DOWN);
4558 - SLIC_ZERO_MEMORY(&adapter->cmdq_all, sizeof(slic_cmdqueue_t));
4559 - SLIC_ZERO_MEMORY(&adapter->cmdq_free, sizeof(slic_cmdqueue_t));
4560 - SLIC_ZERO_MEMORY(&adapter->cmdq_done, sizeof(slic_cmdqueue_t));
4561 - SLIC_INIT_SPINLOCK(adapter->cmdq_all.lock);
4562 - SLIC_INIT_SPINLOCK(adapter->cmdq_free.lock);
4563 - SLIC_INIT_SPINLOCK(adapter->cmdq_done.lock);
4564 + memset(&adapter->cmdq_all, 0, sizeof(struct slic_cmdqueue));
4565 + memset(&adapter->cmdq_free, 0, sizeof(struct slic_cmdqueue));
4566 + memset(&adapter->cmdq_done, 0, sizeof(struct slic_cmdqueue));
4567 + spin_lock_init(&adapter->cmdq_all.lock.lock);
4568 + spin_lock_init(&adapter->cmdq_free.lock.lock);
4569 + spin_lock_init(&adapter->cmdq_done.lock.lock);
4570 slic_cmdqmem_init(adapter);
4571 adapter->slic_handle_ix = 1;
4572 for (i = 0; i < SLIC_CMDQ_INITPAGES; i++) {
4573 pageaddr = slic_cmdqmem_addpage(adapter);
4574 #ifndef CONFIG_X86_64
4575 - ASSERT(((ulong32) pageaddr & 0xFFFFF000) == (ulong32) pageaddr);
4576 + ASSERT(((u32) pageaddr & 0xFFFFF000) == (u32) pageaddr);
4577 #endif
4578 if (!pageaddr) {
4579 slic_cmdq_free(adapter);
4580 @@ -4107,9 +3971,9 @@ int slic_cmdq_init(p_adapter_t adapter)
4581 return STATUS_SUCCESS;
4582 }
4583
4584 -void slic_cmdq_free(p_adapter_t adapter)
4585 +static void slic_cmdq_free(struct adapter *adapter)
4586 {
4587 - p_slic_hostcmd_t cmd;
4588 + struct slic_hostcmd *cmd;
4589
4590 DBG_MSG("slicoss: %s adapter[%p] port %d FreeCommandsFrom CMDQ\n",
4591 __func__, adapter, adapter->physport);
4592 @@ -4126,21 +3990,23 @@ void slic_cmdq_free(p_adapter_t adapter)
4593 }
4594 cmd = cmd->next_all;
4595 }
4596 - SLIC_ZERO_MEMORY(&adapter->cmdq_all, sizeof(slic_cmdqueue_t));
4597 - SLIC_ZERO_MEMORY(&adapter->cmdq_free, sizeof(slic_cmdqueue_t));
4598 - SLIC_ZERO_MEMORY(&adapter->cmdq_done, sizeof(slic_cmdqueue_t));
4599 + memset(&adapter->cmdq_all, 0, sizeof(struct slic_cmdqueue));
4600 + memset(&adapter->cmdq_free, 0, sizeof(struct slic_cmdqueue));
4601 + memset(&adapter->cmdq_done, 0, sizeof(struct slic_cmdqueue));
4602 slic_cmdqmem_free(adapter);
4603 }
4604
4605 -void slic_cmdq_reset(p_adapter_t adapter)
4606 +static void slic_cmdq_reset(struct adapter *adapter)
4607 {
4608 - p_slic_hostcmd_t hcmd;
4609 + struct slic_hostcmd *hcmd;
4610 struct sk_buff *skb;
4611 - ulong32 outstanding;
4612 + u32 outstanding;
4613
4614 DBG_MSG("%s ENTER adapter[%p]\n", __func__, adapter);
4615 - SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->cmdq_free.lock);
4616 - SLIC_ACQUIRE_IRQ_SPINLOCK(adapter->cmdq_done.lock);
4617 + spin_lock_irqsave(&adapter->cmdq_free.lock.lock,
4618 + adapter->cmdq_free.lock.flags);
4619 + spin_lock_irqsave(&adapter->cmdq_done.lock.lock,
4620 + adapter->cmdq_done.lock.flags);
4621 outstanding = adapter->cmdq_all.count - adapter->cmdq_done.count;
4622 outstanding -= adapter->cmdq_free.count;
4623 hcmd = adapter->cmdq_all.head;
4624 @@ -4174,31 +4040,33 @@ void slic_cmdq_reset(p_adapter_t adapter)
4625 DBG_ERROR("%s free_count %d != all count %d\n", __func__,
4626 adapter->cmdq_free.count, adapter->cmdq_all.count);
4627 }
4628 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->cmdq_done.lock);
4629 - SLIC_RELEASE_IRQ_SPINLOCK(adapter->cmdq_free.lock);
4630 + spin_unlock_irqrestore(&adapter->cmdq_done.lock.lock,
4631 + adapter->cmdq_done.lock.flags);
4632 + spin_unlock_irqrestore(&adapter->cmdq_free.lock.lock,
4633 + adapter->cmdq_free.lock.flags);
4634 DBG_MSG("%s EXIT adapter[%p]\n", __func__, adapter);
4635 }
4636
4637 -void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page)
4638 +static void slic_cmdq_addcmdpage(struct adapter *adapter, u32 *page)
4639 {
4640 - p_slic_hostcmd_t cmd;
4641 - p_slic_hostcmd_t prev;
4642 - p_slic_hostcmd_t tail;
4643 - p_slic_cmdqueue_t cmdq;
4644 + struct slic_hostcmd *cmd;
4645 + struct slic_hostcmd *prev;
4646 + struct slic_hostcmd *tail;
4647 + struct slic_cmdqueue *cmdq;
4648 int cmdcnt;
4649 - pvoid cmdaddr;
4650 + void *cmdaddr;
4651 ulong phys_addr;
4652 - ulong32 phys_addrl;
4653 - ulong32 phys_addrh;
4654 - pslic_handle_t pslic_handle;
4655 + u32 phys_addrl;
4656 + u32 phys_addrh;
4657 + struct slic_handle *pslic_handle;
4658
4659 cmdaddr = page;
4660 - cmd = (p_slic_hostcmd_t) cmdaddr;
4661 + cmd = (struct slic_hostcmd *)cmdaddr;
4662 /* DBG_MSG("CMDQ Page addr[%p] ix[%d] pfree[%p]\n", cmdaddr, slic_handle_ix,
4663 adapter->pfree_slic_handles); */
4664 cmdcnt = 0;
4665
4666 - phys_addr = SLIC_GET_PHYSICAL_ADDRESS((void *)page);
4667 + phys_addr = virt_to_bus((void *)page);
4668 phys_addrl = SLIC_GET_ADDR_LOW(phys_addr);
4669 phys_addrh = SLIC_GET_ADDR_HIGH(phys_addr);
4670
4671 @@ -4214,7 +4082,7 @@ void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page)
4672 &adapter->slic_handles[pslic_handle->token.
4673 handle_index]);
4674 pslic_handle->type = SLIC_HANDLE_CMD;
4675 - pslic_handle->address = (pvoid) cmd;
4676 + pslic_handle->address = (void *) cmd;
4677 pslic_handle->offset = (ushort) adapter->slic_handle_ix++;
4678 pslic_handle->other_handle = NULL;
4679 pslic_handle->next = NULL;
4680 @@ -4230,7 +4098,7 @@ void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page)
4681 phys_addrl += SLIC_HOSTCMD_SIZE;
4682 cmdaddr += SLIC_HOSTCMD_SIZE;
4683
4684 - cmd = (p_slic_hostcmd_t) cmdaddr;
4685 + cmd = (struct slic_hostcmd *)cmdaddr;
4686 cmdcnt++;
4687 }
4688
4689 @@ -4240,36 +4108,37 @@ void slic_cmdq_addcmdpage(p_adapter_t adapter, pulong32 page)
4690 ASSERT(VALID_ADDRESS(prev));
4691 cmdq->head = prev;
4692 cmdq = &adapter->cmdq_free;
4693 - SLIC_ACQUIRE_IRQ_SPINLOCK(cmdq->lock);
4694 + spin_lock_irqsave(&cmdq->lock.lock, cmdq->lock.flags);
4695 cmdq->count += cmdcnt; /* SLIC_CMDQ_CMDSINPAGE; mooktodo */
4696 tail->next = cmdq->head;
4697 ASSERT(VALID_ADDRESS(prev));
4698 cmdq->head = prev;
4699 - SLIC_RELEASE_IRQ_SPINLOCK(cmdq->lock);
4700 + spin_unlock_irqrestore(&cmdq->lock.lock, cmdq->lock.flags);
4701 }
4702
4703 -p_slic_hostcmd_t slic_cmdq_getfree(p_adapter_t adapter)
4704 +static struct slic_hostcmd *slic_cmdq_getfree(struct adapter *adapter)
4705 {
4706 - p_slic_cmdqueue_t cmdq = &adapter->cmdq_free;
4707 - p_slic_hostcmd_t cmd = NULL;
4708 + struct slic_cmdqueue *cmdq = &adapter->cmdq_free;
4709 + struct slic_hostcmd *cmd = NULL;
4710
4711 lock_and_retry:
4712 - SLIC_ACQUIRE_IRQ_SPINLOCK(cmdq->lock);
4713 + spin_lock_irqsave(&cmdq->lock.lock, cmdq->lock.flags);
4714 retry:
4715 cmd = cmdq->head;
4716 if (cmd) {
4717 cmdq->head = cmd->next;
4718 cmdq->count--;
4719 - SLIC_RELEASE_IRQ_SPINLOCK(cmdq->lock);
4720 + spin_unlock_irqrestore(&cmdq->lock.lock, cmdq->lock.flags);
4721 } else {
4722 slic_cmdq_getdone(adapter);
4723 cmd = cmdq->head;
4724 if (cmd) {
4725 goto retry;
4726 } else {
4727 - pulong32 pageaddr;
4728 + u32 *pageaddr;
4729
4730 - SLIC_RELEASE_IRQ_SPINLOCK(cmdq->lock);
4731 + spin_unlock_irqrestore(&cmdq->lock.lock,
4732 + cmdq->lock.flags);
4733 pageaddr = slic_cmdqmem_addpage(adapter);
4734 if (pageaddr) {
4735 slic_cmdq_addcmdpage(adapter, pageaddr);
4736 @@ -4280,13 +4149,13 @@ retry:
4737 return cmd;
4738 }
4739
4740 -void slic_cmdq_getdone(p_adapter_t adapter)
4741 +static void slic_cmdq_getdone(struct adapter *adapter)
4742 {
4743 - p_slic_cmdqueue_t done_cmdq = &adapter->cmdq_done;
4744 - p_slic_cmdqueue_t free_cmdq = &adapter->cmdq_free;
4745 + struct slic_cmdqueue *done_cmdq = &adapter->cmdq_done;
4746 + struct slic_cmdqueue *free_cmdq = &adapter->cmdq_free;
4747
4748 ASSERT(free_cmdq->head == NULL);
4749 - SLIC_ACQUIRE_IRQ_SPINLOCK(done_cmdq->lock);
4750 + spin_lock_irqsave(&done_cmdq->lock.lock, done_cmdq->lock.flags);
4751 ASSERT(VALID_ADDRESS(done_cmdq->head));
4752
4753 free_cmdq->head = done_cmdq->head;
4754 @@ -4294,28 +4163,15 @@ void slic_cmdq_getdone(p_adapter_t adapter)
4755 done_cmdq->head = NULL;
4756 done_cmdq->tail = NULL;
4757 done_cmdq->count = 0;
4758 - SLIC_RELEASE_IRQ_SPINLOCK(done_cmdq->lock);
4759 + spin_unlock_irqrestore(&done_cmdq->lock.lock, done_cmdq->lock.flags);
4760 }
4761
4762 -void slic_cmdq_putdone(p_adapter_t adapter, p_slic_hostcmd_t cmd)
4763 +static void slic_cmdq_putdone_irq(struct adapter *adapter,
4764 + struct slic_hostcmd *cmd)
4765 {
4766 - p_slic_cmdqueue_t cmdq = &adapter->cmdq_done;
4767 + struct slic_cmdqueue *cmdq = &adapter->cmdq_done;
4768
4769 - SLIC_ACQUIRE_IRQ_SPINLOCK(cmdq->lock);
4770 - cmd->busy = 0;
4771 - ASSERT(VALID_ADDRESS(cmdq->head));
4772 - cmd->next = cmdq->head;
4773 - ASSERT(VALID_ADDRESS(cmd));
4774 - cmdq->head = cmd;
4775 - cmdq->count++;
4776 - SLIC_RELEASE_IRQ_SPINLOCK(cmdq->lock);
4777 -}
4778 -
4779 -void slic_cmdq_putdone_irq(p_adapter_t adapter, p_slic_hostcmd_t cmd)
4780 -{
4781 - p_slic_cmdqueue_t cmdq = &adapter->cmdq_done;
4782 -
4783 - SLIC_ACQUIRE_SPINLOCK(cmdq->lock);
4784 + spin_lock(&cmdq->lock.lock);
4785 cmd->busy = 0;
4786 ASSERT(VALID_ADDRESS(cmdq->head));
4787 cmd->next = cmdq->head;
4788 @@ -4324,13 +4180,13 @@ void slic_cmdq_putdone_irq(p_adapter_t adapter, p_slic_hostcmd_t cmd)
4789 cmdq->count++;
4790 if ((adapter->xmitq_full) && (cmdq->count > 10))
4791 netif_wake_queue(adapter->netdev);
4792 - SLIC_RELEASE_SPINLOCK(cmdq->lock);
4793 + spin_unlock(&cmdq->lock.lock);
4794 }
4795
4796 -int slic_rcvqueue_init(p_adapter_t adapter)
4797 +static int slic_rcvqueue_init(struct adapter *adapter)
4798 {
4799 int i, count;
4800 - p_slic_rcvqueue_t rcvq = &adapter->rcvqueue;
4801 + struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
4802
4803 DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter);
4804 ASSERT(adapter->state == ADAPT_DOWN);
4805 @@ -4353,9 +4209,9 @@ int slic_rcvqueue_init(p_adapter_t adapter)
4806 return STATUS_SUCCESS;
4807 }
4808
4809 -int slic_rcvqueue_reset(p_adapter_t adapter)
4810 +static int slic_rcvqueue_reset(struct adapter *adapter)
4811 {
4812 - p_slic_rcvqueue_t rcvq = &adapter->rcvqueue;
4813 + struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
4814
4815 DBG_MSG("slicoss: %s ENTER adapter[%p]\n", __func__, adapter);
4816 ASSERT(adapter->state == ADAPT_DOWN);
4817 @@ -4371,9 +4227,9 @@ int slic_rcvqueue_reset(p_adapter_t adapter)
4818 return STATUS_SUCCESS;
4819 }
4820
4821 -void slic_rcvqueue_free(p_adapter_t adapter)
4822 +static void slic_rcvqueue_free(struct adapter *adapter)
4823 {
4824 - slic_rcvqueue_t *rcvq = &adapter->rcvqueue;
4825 + struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
4826 struct sk_buff *skb;
4827
4828 while (rcvq->head) {
4829 @@ -4386,16 +4242,16 @@ void slic_rcvqueue_free(p_adapter_t adapter)
4830 rcvq->count = 0;
4831 }
4832
4833 -struct sk_buff *slic_rcvqueue_getnext(p_adapter_t adapter)
4834 +static struct sk_buff *slic_rcvqueue_getnext(struct adapter *adapter)
4835 {
4836 - p_slic_rcvqueue_t rcvq = &adapter->rcvqueue;
4837 + struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
4838 struct sk_buff *skb;
4839 - p_slic_rcvbuf_t rcvbuf;
4840 + struct slic_rcvbuf *rcvbuf;
4841 int count;
4842
4843 if (rcvq->count) {
4844 skb = rcvq->head;
4845 - rcvbuf = (p_slic_rcvbuf_t) skb->head;
4846 + rcvbuf = (struct slic_rcvbuf *)skb->head;
4847 ASSERT(rcvbuf);
4848
4849 if (rcvbuf->status & IRHDDR_SVALID) {
4850 @@ -4420,30 +4276,31 @@ struct sk_buff *slic_rcvqueue_getnext(p_adapter_t adapter)
4851 return skb;
4852 }
4853
4854 -int slic_rcvqueue_fill(p_adapter_t adapter)
4855 +static int slic_rcvqueue_fill(struct adapter *adapter)
4856 {
4857 - pvoid paddr;
4858 - ulong32 paddrl;
4859 - ulong32 paddrh;
4860 - p_slic_rcvqueue_t rcvq = &adapter->rcvqueue;
4861 + void *paddr;
4862 + u32 paddrl;
4863 + u32 paddrh;
4864 + struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
4865 int i = 0;
4866
4867 while (i < SLIC_RCVQ_FILLENTRIES) {
4868 - p_slic_rcvbuf_t rcvbuf;
4869 + struct slic_rcvbuf *rcvbuf;
4870 struct sk_buff *skb;
4871 #ifdef KLUDGE_FOR_4GB_BOUNDARY
4872 retry_rcvqfill:
4873 #endif
4874 skb = alloc_skb(SLIC_RCVQ_RCVBUFSIZE, GFP_ATOMIC);
4875 if (skb) {
4876 - paddr = (void *)SLIC_GET_DMA_ADDRESS_READ(adapter,
4877 + paddr = (void *)pci_map_single(adapter->pcidev,
4878 skb->data,
4879 - SLIC_RCVQ_RCVBUFSIZE);
4880 + SLIC_RCVQ_RCVBUFSIZE,
4881 + PCI_DMA_FROMDEVICE);
4882 paddrl = SLIC_GET_ADDR_LOW(paddr);
4883 paddrh = SLIC_GET_ADDR_HIGH(paddr);
4884
4885 skb->len = SLIC_RCVBUF_HEADSIZE;
4886 - rcvbuf = (p_slic_rcvbuf_t) skb->head;
4887 + rcvbuf = (struct slic_rcvbuf *)skb->head;
4888 rcvbuf->status = 0;
4889 skb->next = NULL;
4890 #ifdef KLUDGE_FOR_4GB_BOUNDARY
4891 @@ -4479,13 +4336,13 @@ retry_rcvqfill:
4892 #endif
4893 if (paddrh == 0) {
4894 WRITE_REG(adapter->slic_regs->slic_hbar,
4895 - (ulong32) paddrl, DONT_FLUSH);
4896 + (u32) paddrl, DONT_FLUSH);
4897 } else {
4898 WRITE_REG64(adapter,
4899 adapter->slic_regs->slic_hbar64,
4900 - (ulong32) paddrl,
4901 + (u32) paddrl,
4902 adapter->slic_regs->slic_addr_upper,
4903 - (ulong32) paddrh, DONT_FLUSH);
4904 + (u32) paddrh, DONT_FLUSH);
4905 }
4906 if (rcvq->head)
4907 rcvq->tail->next = skb;
4908 @@ -4505,18 +4362,18 @@ retry_rcvqfill:
4909 return i;
4910 }
4911
4912 -ulong32 slic_rcvqueue_reinsert(p_adapter_t adapter, struct sk_buff *skb)
4913 +static u32 slic_rcvqueue_reinsert(struct adapter *adapter, struct sk_buff *skb)
4914 {
4915 - p_slic_rcvqueue_t rcvq = &adapter->rcvqueue;
4916 - pvoid paddr;
4917 - ulong32 paddrl;
4918 - ulong32 paddrh;
4919 - p_slic_rcvbuf_t rcvbuf = (p_slic_rcvbuf_t) skb->head;
4920 + struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
4921 + void *paddr;
4922 + u32 paddrl;
4923 + u32 paddrh;
4924 + struct slic_rcvbuf *rcvbuf = (struct slic_rcvbuf *)skb->head;
4925
4926 ASSERT(skb->len == SLIC_RCVBUF_HEADSIZE);
4927 - paddr = (void *)SLIC_GET_DMA_ADDRESS_READ(adapter,
4928 - skb->head,
4929 - SLIC_RCVQ_RCVBUFSIZE);
4930 +
4931 + paddr = (void *)pci_map_single(adapter->pcidev, skb->head,
4932 + SLIC_RCVQ_RCVBUFSIZE, PCI_DMA_FROMDEVICE);
4933 rcvbuf->status = 0;
4934 skb->next = NULL;
4935
4936 @@ -4536,7 +4393,7 @@ ulong32 slic_rcvqueue_reinsert(p_adapter_t adapter, struct sk_buff *skb)
4937 rcvq->count);
4938 }
4939 if (paddrh == 0) {
4940 - WRITE_REG(adapter->slic_regs->slic_hbar, (ulong32) paddrl,
4941 + WRITE_REG(adapter->slic_regs->slic_hbar, (u32) paddrl,
4942 DONT_FLUSH);
4943 } else {
4944 WRITE_REG64(adapter,
4945 @@ -4558,10 +4415,10 @@ static int slic_debug_card_show(struct seq_file *seq, void *v)
4946 {
4947 #ifdef MOOKTODO
4948 int i;
4949 - p_sliccard_t card = seq->private;
4950 + struct sliccard *card = seq->private;
4951 pslic_config_t config = &card->config;
4952 - puchar fru = (puchar) (&card->config.atk_fru);
4953 - puchar oemfru = (puchar) (&card->config.OemFru);
4954 + unsigned char *fru = (unsigned char *)(&card->config.atk_fru);
4955 + unsigned char *oemfru = (unsigned char *)(&card->config.OemFru);
4956 #endif
4957
4958 seq_printf(seq, "driver_version : %s", slic_proc_version);
4959 @@ -4600,7 +4457,7 @@ static int slic_debug_card_show(struct seq_file *seq, void *v)
4960 seq_printf(seq, " IF Init State Duplex/Speed irq\n");
4961 seq_printf(seq, " -------------------------------\n");
4962 for (i = 0; i < card->adapters_allocated; i++) {
4963 - p_adapter_t adapter;
4964 + struct adapter *adapter;
4965
4966 adapter = card->adapter[i];
4967 if (adapter) {
4968 @@ -4768,7 +4625,7 @@ static int slic_debug_card_show(struct seq_file *seq, void *v)
4969
4970 static int slic_debug_adapter_show(struct seq_file *seq, void *v)
4971 {
4972 - p_adapter_t adapter = seq->private;
4973 + struct adapter *adapter = seq->private;
4974
4975 if ((adapter->netdev) && (adapter->netdev->name)) {
4976 seq_printf(seq, "info: interface : %s\n",
4977 @@ -4801,21 +4658,21 @@ static int slic_debug_adapter_show(struct seq_file *seq, void *v)
4978 seq_printf(seq, "rx stats: unicasts : %8.8X\n",
4979 adapter->rcv_unicasts);
4980 seq_printf(seq, "rx stats: errors : %8.8X\n",
4981 - (ulong32) adapter->slic_stats.iface.rcv_errors);
4982 + (u32) adapter->slic_stats.iface.rcv_errors);
4983 seq_printf(seq, "rx stats: Missed errors : %8.8X\n",
4984 - (ulong32) adapter->slic_stats.iface.rcv_discards);
4985 + (u32) adapter->slic_stats.iface.rcv_discards);
4986 seq_printf(seq, "rx stats: drops : %8.8X\n",
4987 - (ulong32) adapter->rcv_drops);
4988 + (u32) adapter->rcv_drops);
4989 seq_printf(seq, "tx stats: packets : %8.8lX\n",
4990 adapter->stats.tx_packets);
4991 seq_printf(seq, "tx stats: bytes : %8.8lX\n",
4992 adapter->stats.tx_bytes);
4993 seq_printf(seq, "tx stats: errors : %8.8X\n",
4994 - (ulong32) adapter->slic_stats.iface.xmt_errors);
4995 + (u32) adapter->slic_stats.iface.xmt_errors);
4996 seq_printf(seq, "rx stats: multicasts : %8.8lX\n",
4997 adapter->stats.multicast);
4998 seq_printf(seq, "tx stats: collision errors : %8.8X\n",
4999 - (ulong32) adapter->slic_stats.iface.xmit_collisions);
5000 + (u32) adapter->slic_stats.iface.xmit_collisions);
5001 seq_printf(seq, "perf: Max rcv frames/isr : %8.8X\n",
5002 adapter->max_isr_rcvs);
5003 seq_printf(seq, "perf: Rcv interrupt yields : %8.8X\n",
5004 @@ -4905,11 +4762,11 @@ static const struct file_operations slic_debug_card_fops = {
5005 .release = single_release,
5006 };
5007
5008 -static void slic_debug_adapter_create(p_adapter_t adapter)
5009 +static void slic_debug_adapter_create(struct adapter *adapter)
5010 {
5011 struct dentry *d;
5012 char name[7];
5013 - p_sliccard_t card = adapter->card;
5014 + struct sliccard *card = adapter->card;
5015
5016 if (!card->debugfs_dir)
5017 return;
5018 @@ -4924,7 +4781,7 @@ static void slic_debug_adapter_create(p_adapter_t adapter)
5019 adapter->debugfs_entry = d;
5020 }
5021
5022 -static void slic_debug_adapter_destroy(p_adapter_t adapter)
5023 +static void slic_debug_adapter_destroy(struct adapter *adapter)
5024 {
5025 if (adapter->debugfs_entry) {
5026 debugfs_remove(adapter->debugfs_entry);
5027 @@ -4932,7 +4789,7 @@ static void slic_debug_adapter_destroy(p_adapter_t adapter)
5028 }
5029 }
5030
5031 -static void slic_debug_card_create(p_sliccard_t card)
5032 +static void slic_debug_card_create(struct sliccard *card)
5033 {
5034 struct dentry *d;
5035 char name[IFNAMSIZ];
5036 @@ -4955,12 +4812,12 @@ static void slic_debug_card_create(p_sliccard_t card)
5037 }
5038 }
5039
5040 -static void slic_debug_card_destroy(p_sliccard_t card)
5041 +static void slic_debug_card_destroy(struct sliccard *card)
5042 {
5043 int i;
5044
5045 for (i = 0; i < card->card_size; i++) {
5046 - p_adapter_t adapter;
5047 + struct adapter *adapter;
5048
5049 adapter = card->adapter[i];
5050 if (adapter)
5051 @@ -5013,17 +4870,17 @@ static void slic_debug_cleanup(void)
5052
5053 #include <stdarg.h>
5054
5055 -pvoid slic_dump_handle; /* thread handle */
5056 +void *slic_dump_handle; /* thread handle */
5057
5058 /*
5059 * These are the only things you should do on a core-file: use only these
5060 * functions to write out all the necessary info.
5061 */
5062 -static int slic_dump_seek(struct file *SLIChandle, ulong32 file_offset)
5063 +static int slic_dump_seek(struct file *SLIChandle, u32 file_offset)
5064 {
5065 if (SLIChandle->f_pos != file_offset) {
5066 /*DBG_MSG("slic_dump_seek now needed [%x : %x]\n",
5067 - (ulong32)SLIChandle->f_pos, (ulong32)file_offset); */
5068 + (u32)SLIChandle->f_pos, (u32)file_offset); */
5069 if (SLIChandle->f_op->llseek) {
5070 if (SLIChandle->f_op->
5071 llseek(SLIChandle, file_offset, 0) != file_offset)
5072 @@ -5035,11 +4892,11 @@ static int slic_dump_seek(struct file *SLIChandle, ulong32 file_offset)
5073 return 1;
5074 }
5075
5076 -static int slic_dump_write(p_sliccard_t card,
5077 - const void *addr, int size, ulong32 file_offset)
5078 +static int slic_dump_write(struct sliccard *card,
5079 + const void *addr, int size, u32 file_offset)
5080 {
5081 int r = 1;
5082 - ulong32 result = 0;
5083 + u32 result = 0;
5084 struct file *SLIChandle = card->dumphandle;
5085
5086 #ifdef HISTORICAL /* legacy */
5087 @@ -5069,7 +4926,7 @@ static int slic_dump_write(p_sliccard_t card,
5088 return r;
5089 }
5090
5091 -uint slic_init_dump_thread(p_sliccard_t card)
5092 +static uint slic_init_dump_thread(struct sliccard *card)
5093 {
5094 card->dump_task_id = kthread_run(slic_dump_thread, (void *)card, 0);
5095
5096 @@ -5082,17 +4939,17 @@ uint slic_init_dump_thread(p_sliccard_t card)
5097 return STATUS_SUCCESS;
5098 }
5099
5100 -int slic_dump_thread(void *context)
5101 +static int slic_dump_thread(void *context)
5102 {
5103 - p_sliccard_t card = (p_sliccard_t) context;
5104 - p_adapter_t adapter;
5105 - p_adapter_t dump_adapter = NULL;
5106 - ulong32 dump_complete = 0;
5107 - ulong32 delay = SLIC_SECS_TO_JIFFS(PING_TIMER_INTERVAL);
5108 - p_slic_regs_t pregs;
5109 - ulong32 i;
5110 - p_slic_upr_t upr, uprnext;
5111 - ulong32 dump_card;
5112 + struct sliccard *card = (struct sliccard *)context;
5113 + struct adapter *adapter;
5114 + struct adapter *dump_adapter = NULL;
5115 + u32 dump_complete = 0;
5116 + u32 delay = SLIC_SECS_TO_JIFFS(PING_TIMER_INTERVAL);
5117 + struct slic_regs *pregs;
5118 + u32 i;
5119 + struct slic_upr *upr, *uprnext;
5120 + u32 dump_card;
5121
5122 ASSERT(card);
5123
5124 @@ -5248,19 +5105,20 @@ int slic_dump_thread(void *context)
5125 * now.
5126 */
5127 if (!card->pingstatus) {
5128 - SLIC_ACQUIRE_IRQ_SPINLOCK
5129 - (adapter->upr_lock);
5130 + spin_lock_irqsave(
5131 + &adapter->upr_lock.lock,
5132 + adapter->upr_lock.flags);
5133 upr = adapter->upr_list;
5134 while (upr) {
5135 uprnext = upr->next;
5136 - SLIC_DEALLOCATE_MEM
5137 - (upr);
5138 + kfree(upr);
5139 upr = uprnext;
5140 }
5141 adapter->upr_list = 0;
5142 adapter->upr_busy = 0;
5143 - SLIC_RELEASE_IRQ_SPINLOCK
5144 - (adapter->upr_lock);
5145 + spin_unlock_irqrestore(
5146 + &adapter->upr_lock.lock,
5147 + adapter->upr_lock.flags);
5148 }
5149
5150 slic_dump_card(card, FALSE);
5151 @@ -5340,13 +5198,13 @@ end_thread:
5152 * value is used as our suffix for our dump path. The
5153 * value is incremented and written back to the file
5154 */
5155 -uchar slic_get_dump_index(pchar path)
5156 +static unsigned char slic_get_dump_index(char *path)
5157 {
5158 - uchar index = 0;
5159 + unsigned char index = 0;
5160 #ifdef SLIC_DUMP_INDEX_SUPPORT
5161 - ulong32 status;
5162 - pvoid FileHandle;
5163 - ulong32 offset;
5164 + u32 status;
5165 + void *FileHandle;
5166 + u32 offset;
5167
5168 offset = 0;
5169
5170 @@ -5356,7 +5214,7 @@ uchar slic_get_dump_index(pchar path)
5171 status = create_file(&FileHandle);
5172
5173 if (status != STATUS_SUCCESS)
5174 - return (uchar) 0;
5175 + return (unsigned char) 0;
5176
5177 status = read_file(FileHandle, &index, 1, &offset);
5178
5179 @@ -5371,7 +5229,7 @@ uchar slic_get_dump_index(pchar path)
5180 return index;
5181 }
5182
5183 -struct file *slic_dump_open_file(p_sliccard_t card)
5184 +static struct file *slic_dump_open_file(struct sliccard *card)
5185 {
5186 struct file *SLIChandle = NULL;
5187 struct dentry *dentry = NULL;
5188 @@ -5434,7 +5292,7 @@ end_slicdump:
5189 return NULL;
5190 }
5191
5192 -void slic_dump_close_file(p_sliccard_t card)
5193 +static void slic_dump_close_file(struct sliccard *card)
5194 {
5195
5196 /* DBG_MSG("[slicmon] slic_dump_CLOSE_file close SLIChandle[%p]\n",
5197 @@ -5445,19 +5303,19 @@ void slic_dump_close_file(p_sliccard_t card)
5198 set_fs(card->dumpfile_fs);
5199 }
5200
5201 -ulong32 slic_dump_card(p_sliccard_t card, boolean resume)
5202 +static u32 slic_dump_card(struct sliccard *card, bool resume)
5203 {
5204 - p_adapter_t adapter = card->master;
5205 - ulong32 status;
5206 - ulong32 queue;
5207 - ulong32 len, offset;
5208 - ulong32 sram_size, dram_size, regs;
5209 + struct adapter *adapter = card->master;
5210 + u32 status;
5211 + u32 queue;
5212 + u32 len, offset;
5213 + u32 sram_size, dram_size, regs;
5214 sliccore_hdr_t corehdr;
5215 - ulong32 file_offset;
5216 - pchar namestr;
5217 - ulong32 i;
5218 - ulong32 max_queues = 0;
5219 - ulong32 result;
5220 + u32 file_offset;
5221 + char *namestr;
5222 + u32 i;
5223 + u32 max_queues = 0;
5224 + u32 result;
5225
5226 card->dumphandle = slic_dump_open_file(card);
5227
5228 @@ -5672,12 +5530,12 @@ ulong32 slic_dump_card(p_sliccard_t card, boolean resume)
5229 max_queues = SLIC_MAX_QUEUE;
5230
5231 for (queue = 0; queue < max_queues; queue++) {
5232 - pulong32 qarray = (pulong32) card->dumpbuffer;
5233 - ulong32 qarray_physl = card->dumpbuffer_physl;
5234 - ulong32 qarray_physh = card->dumpbuffer_physh;
5235 - ulong32 qstart;
5236 - ulong32 qdelta;
5237 - ulong32 qtotal = 0;
5238 + u32 *qarray = (u32 *) card->dumpbuffer;
5239 + u32 qarray_physl = card->dumpbuffer_physl;
5240 + u32 qarray_physh = card->dumpbuffer_physh;
5241 + u32 qstart;
5242 + u32 qdelta;
5243 + u32 qtotal = 0;
5244
5245 DBG_MSG("[slicmon] Start Dump of QUEUE #0x%x\n", (uint) queue);
5246
5247 @@ -5823,9 +5681,9 @@ done:
5248 return status;
5249 }
5250
5251 -ulong32 slic_dump_halt(p_sliccard_t card, uchar proc)
5252 +static u32 slic_dump_halt(struct sliccard *card, unsigned char proc)
5253 {
5254 - puchar cmd = card->cmdbuffer;
5255 + unsigned char *cmd = card->cmdbuffer;
5256
5257 *cmd = COMMAND_BYTE(CMD_HALT, 0, proc);
5258
5259 @@ -5834,9 +5692,9 @@ ulong32 slic_dump_halt(p_sliccard_t card, uchar proc)
5260 card->cmdbuffer_physh, 0, 0);
5261 }
5262
5263 -ulong32 slic_dump_resume(p_sliccard_t card, uchar proc)
5264 +static u32 slic_dump_resume(struct sliccard *card, unsigned char proc)
5265 {
5266 - puchar cmd = card->cmdbuffer;
5267 + unsigned char *cmd = card->cmdbuffer;
5268
5269 *cmd = COMMAND_BYTE(CMD_RUN, 0, proc);
5270
5271 @@ -5845,7 +5703,7 @@ ulong32 slic_dump_resume(p_sliccard_t card, uchar proc)
5272 card->cmdbuffer_physh, 0, 0);
5273 }
5274
5275 -ulong32 slic_dump_reg(p_sliccard_t card, uchar proc)
5276 +static u32 slic_dump_reg(struct sliccard *card, unsigned char proc)
5277 {
5278 pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer;
5279
5280 @@ -5861,8 +5719,8 @@ ulong32 slic_dump_reg(p_sliccard_t card, uchar proc)
5281 card->dumpbuffer_physh);
5282 }
5283
5284 -ulong32 slic_dump_data(p_sliccard_t card,
5285 - ulong32 addr, ushort count, uchar desc)
5286 +static u32 slic_dump_data(struct sliccard *card,
5287 + u32 addr, ushort count, unsigned char desc)
5288 {
5289 pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer;
5290
5291 @@ -5878,8 +5736,8 @@ ulong32 slic_dump_data(p_sliccard_t card,
5292 card->dumpbuffer_physh);
5293 }
5294
5295 -ulong32 slic_dump_queue(p_sliccard_t card,
5296 - ulong32 addr, ulong32 buf_physh, ulong32 queue)
5297 +static u32 slic_dump_queue(struct sliccard *card,
5298 + u32 addr, u32 buf_physh, u32 queue)
5299 {
5300 pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer;
5301
5302 @@ -5894,7 +5752,8 @@ ulong32 slic_dump_queue(p_sliccard_t card,
5303 addr, card->dumpbuffer_physh);
5304 }
5305
5306 -ulong32 slic_dump_load_queue(p_sliccard_t card, ulong32 data, ulong32 queue)
5307 +static u32 slic_dump_load_queue(struct sliccard *card, u32 data,
5308 + u32 queue)
5309 {
5310 pdump_cmd_t load = (pdump_cmd_t) card->cmdbuffer;
5311
5312 @@ -5908,8 +5767,8 @@ ulong32 slic_dump_load_queue(p_sliccard_t card, ulong32 data, ulong32 queue)
5313 card->cmdbuffer_physh, 0, 0);
5314 }
5315
5316 -ulong32 slic_dump_cam(p_sliccard_t card,
5317 - ulong32 addr, ulong32 count, uchar desc)
5318 +static u32 slic_dump_cam(struct sliccard *card,
5319 + u32 addr, u32 count, unsigned char desc)
5320 {
5321 pdump_cmd_t dump = (pdump_cmd_t) card->cmdbuffer;
5322
5323 @@ -5924,15 +5783,15 @@ ulong32 slic_dump_cam(p_sliccard_t card,
5324 addr, card->dumpbuffer_physh);
5325 }
5326
5327 -ulong32 slic_dump_send_cmd(p_sliccard_t card,
5328 - ulong32 cmd_physl,
5329 - ulong32 cmd_physh,
5330 - ulong32 buf_physl, ulong32 buf_physh)
5331 +static u32 slic_dump_send_cmd(struct sliccard *card,
5332 + u32 cmd_physl,
5333 + u32 cmd_physh,
5334 + u32 buf_physl, u32 buf_physh)
5335 {
5336 ulong timeout = SLIC_MS_TO_JIFFIES(500); /* 500 msec */
5337 - ulong32 attempts = 5;
5338 - ulong32 delay = SLIC_MS_TO_JIFFIES(10); /* 10 msec */
5339 - p_adapter_t adapter = card->master;
5340 + u32 attempts = 5;
5341 + u32 delay = SLIC_MS_TO_JIFFIES(10); /* 10 msec */
5342 + struct adapter *adapter = card->master;
5343
5344 ASSERT(adapter);
5345 do {
5346 --
5347 1.6.0.2
5348
Peter's tree of IPFire 2.x