aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/tlan.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/tlan.c')
-rw-r--r--drivers/net/tlan.c3848
1 files changed, 1893 insertions, 1955 deletions
diff --git a/drivers/net/tlan.c b/drivers/net/tlan.c
index ccee3eddc5f4..ace6404e2fac 100644
--- a/drivers/net/tlan.c
+++ b/drivers/net/tlan.c
@@ -25,150 +25,9 @@
25 * Microchip Technology, 24C01A/02A/04A Data Sheet 25 * Microchip Technology, 24C01A/02A/04A Data Sheet
26 * available in PDF format from www.microchip.com 26 * available in PDF format from www.microchip.com
27 * 27 *
28 * Change History 28 ******************************************************************************/
29 * 29
30 * Tigran Aivazian <tigran@sco.com>: TLan_PciProbe() now uses 30#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
31 * new PCI BIOS interface.
32 * Alan Cox <alan@lxorguk.ukuu.org.uk>:
33 * Fixed the out of memory
34 * handling.
35 *
36 * Torben Mathiasen <torben.mathiasen@compaq.com> New Maintainer!
37 *
38 * v1.1 Dec 20, 1999 - Removed linux version checking
39 * Patch from Tigran Aivazian.
40 * - v1.1 includes Alan's SMP updates.
41 * - We still have problems on SMP though,
42 * but I'm looking into that.
43 *
44 * v1.2 Jan 02, 2000 - Hopefully fixed the SMP deadlock.
45 * - Removed dependency of HZ being 100.
46 * - We now allow higher priority timers to
47 * overwrite timers like TLAN_TIMER_ACTIVITY
48 * Patch from John Cagle <john.cagle@compaq.com>.
49 * - Fixed a few compiler warnings.
50 *
51 * v1.3 Feb 04, 2000 - Fixed the remaining HZ issues.
52 * - Removed call to pci_present().
53 * - Removed SA_INTERRUPT flag from irq handler.
54 * - Added __init and __initdata to reduce resisdent
55 * code size.
56 * - Driver now uses module_init/module_exit.
57 * - Rewrote init_module and tlan_probe to
58 * share a lot more code. We now use tlan_probe
59 * with builtin and module driver.
60 * - Driver ported to new net API.
61 * - tlan.txt has been reworked to reflect current
62 * driver (almost)
63 * - Other minor stuff
64 *
65 * v1.4 Feb 10, 2000 - Updated with more changes required after Dave's
66 * network cleanup in 2.3.43pre7 (Tigran & myself)
67 * - Minor stuff.
68 *
69 * v1.5 March 22, 2000 - Fixed another timer bug that would hang the driver
70 * if no cable/link were present.
71 * - Cosmetic changes.
72 * - TODO: Port completely to new PCI/DMA API
73 * Auto-Neg fallback.
74 *
75 * v1.6 April 04, 2000 - Fixed driver support for kernel-parameters. Haven't
76 * tested it though, as the kernel support is currently
77 * broken (2.3.99p4p3).
78 * - Updated tlan.txt accordingly.
79 * - Adjusted minimum/maximum frame length.
80 * - There is now a TLAN website up at
81 * http://tlan.kernel.dk
82 *
83 * v1.7 April 07, 2000 - Started to implement custom ioctls. Driver now
84 * reports PHY information when used with Donald
85 * Beckers userspace MII diagnostics utility.
86 *
87 * v1.8 April 23, 2000 - Fixed support for forced speed/duplex settings.
88 * - Added link information to Auto-Neg and forced
89 * modes. When NIC operates with auto-neg the driver
90 * will report Link speed & duplex modes as well as
91 * link partner abilities. When forced link is used,
92 * the driver will report status of the established
93 * link.
94 * Please read tlan.txt for additional information.
95 * - Removed call to check_region(), and used
96 * return value of request_region() instead.
97 *
98 * v1.8a May 28, 2000 - Minor updates.
99 *
100 * v1.9 July 25, 2000 - Fixed a few remaining Full-Duplex issues.
101 * - Updated with timer fixes from Andrew Morton.
102 * - Fixed module race in TLan_Open.
103 * - Added routine to monitor PHY status.
104 * - Added activity led support for Proliant devices.
105 *
106 * v1.10 Aug 30, 2000 - Added support for EISA based tlan controllers
107 * like the Compaq NetFlex3/E.
108 * - Rewrote tlan_probe to better handle multiple
109 * bus probes. Probing and device setup is now
110 * done through TLan_Probe and TLan_init_one. Actual
111 * hardware probe is done with kernel API and
112 * TLan_EisaProbe.
113 * - Adjusted debug information for probing.
114 * - Fixed bug that would cause general debug information
115 * to be printed after driver removal.
116 * - Added transmit timeout handling.
117 * - Fixed OOM return values in tlan_probe.
118 * - Fixed possible mem leak in tlan_exit
119 * (now tlan_remove_one).
120 * - Fixed timer bug in TLan_phyMonitor.
121 * - This driver version is alpha quality, please
122 * send me any bug issues you may encounter.
123 *
124 * v1.11 Aug 31, 2000 - Do not try to register irq 0 if no irq line was
125 * set for EISA cards.
126 * - Added support for NetFlex3/E with nibble-rate
127 * 10Base-T PHY. This is untestet as I haven't got
128 * one of these cards.
129 * - Fixed timer being added twice.
130 * - Disabled PhyMonitoring by default as this is
131 * work in progress. Define MONITOR to enable it.
132 * - Now we don't display link info with PHYs that
133 * doesn't support it (level1).
134 * - Incresed tx_timeout beacuse of auto-neg.
135 * - Adjusted timers for forced speeds.
136 *
137 * v1.12 Oct 12, 2000 - Minor fixes (memleak, init, etc.)
138 *
139 * v1.13 Nov 28, 2000 - Stop flooding console with auto-neg issues
140 * when link can't be established.
141 * - Added the bbuf option as a kernel parameter.
142 * - Fixed ioaddr probe bug.
143 * - Fixed stupid deadlock with MII interrupts.
144 * - Added support for speed/duplex selection with
145 * multiple nics.
146 * - Added partly fix for TX Channel lockup with
147 * TLAN v1.0 silicon. This needs to be investigated
148 * further.
149 *
150 * v1.14 Dec 16, 2000 - Added support for servicing multiple frames per.
151 * interrupt. Thanks goes to
152 * Adam Keys <adam@ti.com>
153 * Denis Beaudoin <dbeaudoin@ti.com>
154 * for providing the patch.
155 * - Fixed auto-neg output when using multiple
156 * adapters.
157 * - Converted to use new taskq interface.
158 *
159 * v1.14a Jan 6, 2001 - Minor adjustments (spinlocks, etc.)
160 *
161 * Samuel Chessman <chessman@tux.org> New Maintainer!
162 *
163 * v1.15 Apr 4, 2002 - Correct operation when aui=1 to be
164 * 10T half duplex no loopback
165 * Thanks to Gunnar Eikman
166 *
167 * Sakari Ailus <sakari.ailus@iki.fi>:
168 *
169 * v1.15a Dec 15 2008 - Remove bbuf support, it doesn't work anyway.
170 *
171 *******************************************************************************/
172 31
173#include <linux/module.h> 32#include <linux/module.h>
174#include <linux/init.h> 33#include <linux/init.h>
@@ -185,13 +44,11 @@
185 44
186#include "tlan.h" 45#include "tlan.h"
187 46
188typedef u32 (TLanIntVectorFunc)( struct net_device *, u16 );
189
190 47
191/* For removing EISA devices */ 48/* For removing EISA devices */
192static struct net_device *TLan_Eisa_Devices; 49static struct net_device *tlan_eisa_devices;
193 50
194static int TLanDevicesInstalled; 51static int tlan_devices_installed;
195 52
196/* Set speed, duplex and aui settings */ 53/* Set speed, duplex and aui settings */
197static int aui[MAX_TLAN_BOARDS]; 54static int aui[MAX_TLAN_BOARDS];
@@ -202,8 +59,9 @@ module_param_array(aui, int, NULL, 0);
202module_param_array(duplex, int, NULL, 0); 59module_param_array(duplex, int, NULL, 0);
203module_param_array(speed, int, NULL, 0); 60module_param_array(speed, int, NULL, 0);
204MODULE_PARM_DESC(aui, "ThunderLAN use AUI port(s) (0-1)"); 61MODULE_PARM_DESC(aui, "ThunderLAN use AUI port(s) (0-1)");
205MODULE_PARM_DESC(duplex, "ThunderLAN duplex setting(s) (0-default, 1-half, 2-full)"); 62MODULE_PARM_DESC(duplex,
206MODULE_PARM_DESC(speed, "ThunderLAN port speen setting(s) (0,10,100)"); 63 "ThunderLAN duplex setting(s) (0-default, 1-half, 2-full)");
64MODULE_PARM_DESC(speed, "ThunderLAN port speed setting(s) (0,10,100)");
207 65
208MODULE_AUTHOR("Maintainer: Samuel Chessman <chessman@tux.org>"); 66MODULE_AUTHOR("Maintainer: Samuel Chessman <chessman@tux.org>");
209MODULE_DESCRIPTION("Driver for TI ThunderLAN based ethernet PCI adapters"); 67MODULE_DESCRIPTION("Driver for TI ThunderLAN based ethernet PCI adapters");
@@ -218,139 +76,144 @@ static int debug;
218module_param(debug, int, 0); 76module_param(debug, int, 0);
219MODULE_PARM_DESC(debug, "ThunderLAN debug mask"); 77MODULE_PARM_DESC(debug, "ThunderLAN debug mask");
220 78
221static const char TLanSignature[] = "TLAN"; 79static const char tlan_signature[] = "TLAN";
222static const char tlan_banner[] = "ThunderLAN driver v1.15a\n"; 80static const char tlan_banner[] = "ThunderLAN driver v1.17\n";
223static int tlan_have_pci; 81static int tlan_have_pci;
224static int tlan_have_eisa; 82static int tlan_have_eisa;
225 83
226static const char *media[] = { 84static const char * const media[] = {
227 "10BaseT-HD ", "10BaseT-FD ","100baseTx-HD ", 85 "10BaseT-HD", "10BaseT-FD", "100baseTx-HD",
228 "100baseTx-FD", "100baseT4", NULL 86 "100BaseTx-FD", "100BaseT4", NULL
229}; 87};
230 88
231static struct board { 89static struct board {
232 const char *deviceLabel; 90 const char *device_label;
233 u32 flags; 91 u32 flags;
234 u16 addrOfs; 92 u16 addr_ofs;
235} board_info[] = { 93} board_info[] = {
236 { "Compaq Netelligent 10 T PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 }, 94 { "Compaq Netelligent 10 T PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
237 { "Compaq Netelligent 10/100 TX PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 }, 95 { "Compaq Netelligent 10/100 TX PCI UTP",
96 TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
238 { "Compaq Integrated NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 }, 97 { "Compaq Integrated NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
239 { "Compaq NetFlex-3/P", 98 { "Compaq NetFlex-3/P",
240 TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 }, 99 TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
241 { "Compaq NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 }, 100 { "Compaq NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
242 { "Compaq Netelligent Integrated 10/100 TX UTP", 101 { "Compaq Netelligent Integrated 10/100 TX UTP",
243 TLAN_ADAPTER_ACTIVITY_LED, 0x83 }, 102 TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
244 { "Compaq Netelligent Dual 10/100 TX PCI UTP", TLAN_ADAPTER_NONE, 0x83 }, 103 { "Compaq Netelligent Dual 10/100 TX PCI UTP",
245 { "Compaq Netelligent 10/100 TX Embedded UTP", TLAN_ADAPTER_NONE, 0x83 }, 104 TLAN_ADAPTER_NONE, 0x83 },
105 { "Compaq Netelligent 10/100 TX Embedded UTP",
106 TLAN_ADAPTER_NONE, 0x83 },
246 { "Olicom OC-2183/2185", TLAN_ADAPTER_USE_INTERN_10, 0x83 }, 107 { "Olicom OC-2183/2185", TLAN_ADAPTER_USE_INTERN_10, 0x83 },
247 { "Olicom OC-2325", TLAN_ADAPTER_UNMANAGED_PHY, 0xF8 }, 108 { "Olicom OC-2325", TLAN_ADAPTER_UNMANAGED_PHY, 0xf8 },
248 { "Olicom OC-2326", TLAN_ADAPTER_USE_INTERN_10, 0xF8 }, 109 { "Olicom OC-2326", TLAN_ADAPTER_USE_INTERN_10, 0xf8 },
249 { "Compaq Netelligent 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 }, 110 { "Compaq Netelligent 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
250 { "Compaq Netelligent 10 T/2 PCI UTP/Coax", TLAN_ADAPTER_NONE, 0x83 }, 111 { "Compaq Netelligent 10 T/2 PCI UTP/coax", TLAN_ADAPTER_NONE, 0x83 },
251 { "Compaq NetFlex-3/E", 112 { "Compaq NetFlex-3/E",
252 TLAN_ADAPTER_ACTIVITY_LED | /* EISA card */ 113 TLAN_ADAPTER_ACTIVITY_LED | /* EISA card */
253 TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 }, 114 TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
254 { "Compaq NetFlex-3/E", TLAN_ADAPTER_ACTIVITY_LED, 0x83 }, /* EISA card */ 115 { "Compaq NetFlex-3/E",
116 TLAN_ADAPTER_ACTIVITY_LED, 0x83 }, /* EISA card */
255}; 117};
256 118
257static DEFINE_PCI_DEVICE_TABLE(tlan_pci_tbl) = { 119static DEFINE_PCI_DEVICE_TABLE(tlan_pci_tbl) = {
258 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL10, 120 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL10,
259 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, 121 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
260 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100, 122 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100,
261 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 }, 123 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
262 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3I, 124 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3I,
263 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 }, 125 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
264 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_THUNDER, 126 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_THUNDER,
265 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 }, 127 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 },
266 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3B, 128 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3B,
267 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 }, 129 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
268 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100PI, 130 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100PI,
269 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 }, 131 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
270 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100D, 132 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100D,
271 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 }, 133 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
272 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100I, 134 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100I,
273 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 7 }, 135 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 7 },
274 { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2183, 136 { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2183,
275 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 }, 137 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
276 { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2325, 138 { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2325,
277 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 9 }, 139 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 9 },
278 { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2326, 140 { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2326,
279 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 10 }, 141 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 10 },
280 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_100_WS_5100, 142 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_100_WS_5100,
281 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 11 }, 143 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 11 },
282 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_T2, 144 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_T2,
283 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 12 }, 145 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 12 },
284 { 0,} 146 { 0,}
285}; 147};
286MODULE_DEVICE_TABLE(pci, tlan_pci_tbl); 148MODULE_DEVICE_TABLE(pci, tlan_pci_tbl);
287 149
288static void TLan_EisaProbe( void ); 150static void tlan_eisa_probe(void);
289static void TLan_Eisa_Cleanup( void ); 151static void tlan_eisa_cleanup(void);
290static int TLan_Init( struct net_device * ); 152static int tlan_init(struct net_device *);
291static int TLan_Open( struct net_device *dev ); 153static int tlan_open(struct net_device *dev);
292static netdev_tx_t TLan_StartTx( struct sk_buff *, struct net_device *); 154static netdev_tx_t tlan_start_tx(struct sk_buff *, struct net_device *);
293static irqreturn_t TLan_HandleInterrupt( int, void *); 155static irqreturn_t tlan_handle_interrupt(int, void *);
294static int TLan_Close( struct net_device *); 156static int tlan_close(struct net_device *);
295static struct net_device_stats *TLan_GetStats( struct net_device *); 157static struct net_device_stats *tlan_get_stats(struct net_device *);
296static void TLan_SetMulticastList( struct net_device *); 158static void tlan_set_multicast_list(struct net_device *);
297static int TLan_ioctl( struct net_device *dev, struct ifreq *rq, int cmd); 159static int tlan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
298static int TLan_probe1( struct pci_dev *pdev, long ioaddr, 160static int tlan_probe1(struct pci_dev *pdev, long ioaddr,
299 int irq, int rev, const struct pci_device_id *ent); 161 int irq, int rev, const struct pci_device_id *ent);
300static void TLan_tx_timeout( struct net_device *dev); 162static void tlan_tx_timeout(struct net_device *dev);
301static void TLan_tx_timeout_work(struct work_struct *work); 163static void tlan_tx_timeout_work(struct work_struct *work);
302static int tlan_init_one( struct pci_dev *pdev, const struct pci_device_id *ent); 164static int tlan_init_one(struct pci_dev *pdev,
303 165 const struct pci_device_id *ent);
304static u32 TLan_HandleTxEOF( struct net_device *, u16 ); 166
305static u32 TLan_HandleStatOverflow( struct net_device *, u16 ); 167static u32 tlan_handle_tx_eof(struct net_device *, u16);
306static u32 TLan_HandleRxEOF( struct net_device *, u16 ); 168static u32 tlan_handle_stat_overflow(struct net_device *, u16);
307static u32 TLan_HandleDummy( struct net_device *, u16 ); 169static u32 tlan_handle_rx_eof(struct net_device *, u16);
308static u32 TLan_HandleTxEOC( struct net_device *, u16 ); 170static u32 tlan_handle_dummy(struct net_device *, u16);
309static u32 TLan_HandleStatusCheck( struct net_device *, u16 ); 171static u32 tlan_handle_tx_eoc(struct net_device *, u16);
310static u32 TLan_HandleRxEOC( struct net_device *, u16 ); 172static u32 tlan_handle_status_check(struct net_device *, u16);
311 173static u32 tlan_handle_rx_eoc(struct net_device *, u16);
312static void TLan_Timer( unsigned long ); 174
313 175static void tlan_timer(unsigned long);
314static void TLan_ResetLists( struct net_device * ); 176
315static void TLan_FreeLists( struct net_device * ); 177static void tlan_reset_lists(struct net_device *);
316static void TLan_PrintDio( u16 ); 178static void tlan_free_lists(struct net_device *);
317static void TLan_PrintList( TLanList *, char *, int ); 179static void tlan_print_dio(u16);
318static void TLan_ReadAndClearStats( struct net_device *, int ); 180static void tlan_print_list(struct tlan_list *, char *, int);
319static void TLan_ResetAdapter( struct net_device * ); 181static void tlan_read_and_clear_stats(struct net_device *, int);
320static void TLan_FinishReset( struct net_device * ); 182static void tlan_reset_adapter(struct net_device *);
321static void TLan_SetMac( struct net_device *, int areg, char *mac ); 183static void tlan_finish_reset(struct net_device *);
322 184static void tlan_set_mac(struct net_device *, int areg, char *mac);
323static void TLan_PhyPrint( struct net_device * ); 185
324static void TLan_PhyDetect( struct net_device * ); 186static void tlan_phy_print(struct net_device *);
325static void TLan_PhyPowerDown( struct net_device * ); 187static void tlan_phy_detect(struct net_device *);
326static void TLan_PhyPowerUp( struct net_device * ); 188static void tlan_phy_power_down(struct net_device *);
327static void TLan_PhyReset( struct net_device * ); 189static void tlan_phy_power_up(struct net_device *);
328static void TLan_PhyStartLink( struct net_device * ); 190static void tlan_phy_reset(struct net_device *);
329static void TLan_PhyFinishAutoNeg( struct net_device * ); 191static void tlan_phy_start_link(struct net_device *);
192static void tlan_phy_finish_auto_neg(struct net_device *);
330#ifdef MONITOR 193#ifdef MONITOR
331static void TLan_PhyMonitor( struct net_device * ); 194static void tlan_phy_monitor(struct net_device *);
332#endif 195#endif
333 196
334/* 197/*
335static int TLan_PhyNop( struct net_device * ); 198 static int tlan_phy_nop(struct net_device *);
336static int TLan_PhyInternalCheck( struct net_device * ); 199 static int tlan_phy_internal_check(struct net_device *);
337static int TLan_PhyInternalService( struct net_device * ); 200 static int tlan_phy_internal_service(struct net_device *);
338static int TLan_PhyDp83840aCheck( struct net_device * ); 201 static int tlan_phy_dp83840a_check(struct net_device *);
339*/ 202*/
340 203
341static bool TLan_MiiReadReg( struct net_device *, u16, u16, u16 * ); 204static bool tlan_mii_read_reg(struct net_device *, u16, u16, u16 *);
342static void TLan_MiiSendData( u16, u32, unsigned ); 205static void tlan_mii_send_data(u16, u32, unsigned);
343static void TLan_MiiSync( u16 ); 206static void tlan_mii_sync(u16);
344static void TLan_MiiWriteReg( struct net_device *, u16, u16, u16 ); 207static void tlan_mii_write_reg(struct net_device *, u16, u16, u16);
345 208
346static void TLan_EeSendStart( u16 ); 209static void tlan_ee_send_start(u16);
347static int TLan_EeSendByte( u16, u8, int ); 210static int tlan_ee_send_byte(u16, u8, int);
348static void TLan_EeReceiveByte( u16, u8 *, int ); 211static void tlan_ee_receive_byte(u16, u8 *, int);
349static int TLan_EeReadByte( struct net_device *, u8, u8 * ); 212static int tlan_ee_read_byte(struct net_device *, u8, u8 *);
350 213
351 214
352static inline void 215static inline void
353TLan_StoreSKB( struct tlan_list_tag *tag, struct sk_buff *skb) 216tlan_store_skb(struct tlan_list *tag, struct sk_buff *skb)
354{ 217{
355 unsigned long addr = (unsigned long)skb; 218 unsigned long addr = (unsigned long)skb;
356 tag->buffer[9].address = addr; 219 tag->buffer[9].address = addr;
@@ -358,7 +221,7 @@ TLan_StoreSKB( struct tlan_list_tag *tag, struct sk_buff *skb)
358} 221}
359 222
360static inline struct sk_buff * 223static inline struct sk_buff *
361TLan_GetSKB( const struct tlan_list_tag *tag) 224tlan_get_skb(const struct tlan_list *tag)
362{ 225{
363 unsigned long addr; 226 unsigned long addr;
364 227
@@ -367,50 +230,50 @@ TLan_GetSKB( const struct tlan_list_tag *tag)
367 return (struct sk_buff *) addr; 230 return (struct sk_buff *) addr;
368} 231}
369 232
370 233static u32
371static TLanIntVectorFunc *TLanIntVector[TLAN_INT_NUMBER_OF_INTS] = { 234(*tlan_int_vector[TLAN_INT_NUMBER_OF_INTS])(struct net_device *, u16) = {
372 NULL, 235 NULL,
373 TLan_HandleTxEOF, 236 tlan_handle_tx_eof,
374 TLan_HandleStatOverflow, 237 tlan_handle_stat_overflow,
375 TLan_HandleRxEOF, 238 tlan_handle_rx_eof,
376 TLan_HandleDummy, 239 tlan_handle_dummy,
377 TLan_HandleTxEOC, 240 tlan_handle_tx_eoc,
378 TLan_HandleStatusCheck, 241 tlan_handle_status_check,
379 TLan_HandleRxEOC 242 tlan_handle_rx_eoc
380}; 243};
381 244
382static inline void 245static inline void
383TLan_SetTimer( struct net_device *dev, u32 ticks, u32 type ) 246tlan_set_timer(struct net_device *dev, u32 ticks, u32 type)
384{ 247{
385 TLanPrivateInfo *priv = netdev_priv(dev); 248 struct tlan_priv *priv = netdev_priv(dev);
386 unsigned long flags = 0; 249 unsigned long flags = 0;
387 250
388 if (!in_irq()) 251 if (!in_irq())
389 spin_lock_irqsave(&priv->lock, flags); 252 spin_lock_irqsave(&priv->lock, flags);
390 if ( priv->timer.function != NULL && 253 if (priv->timer.function != NULL &&
391 priv->timerType != TLAN_TIMER_ACTIVITY ) { 254 priv->timer_type != TLAN_TIMER_ACTIVITY) {
392 if (!in_irq()) 255 if (!in_irq())
393 spin_unlock_irqrestore(&priv->lock, flags); 256 spin_unlock_irqrestore(&priv->lock, flags);
394 return; 257 return;
395 } 258 }
396 priv->timer.function = &TLan_Timer; 259 priv->timer.function = tlan_timer;
397 if (!in_irq()) 260 if (!in_irq())
398 spin_unlock_irqrestore(&priv->lock, flags); 261 spin_unlock_irqrestore(&priv->lock, flags);
399 262
400 priv->timer.data = (unsigned long) dev; 263 priv->timer.data = (unsigned long) dev;
401 priv->timerSetAt = jiffies; 264 priv->timer_set_at = jiffies;
402 priv->timerType = type; 265 priv->timer_type = type;
403 mod_timer(&priv->timer, jiffies + ticks); 266 mod_timer(&priv->timer, jiffies + ticks);
404 267
405} /* TLan_SetTimer */ 268}
406 269
407 270
408/***************************************************************************** 271/*****************************************************************************
409****************************************************************************** 272******************************************************************************
410 273
411 ThunderLAN Driver Primary Functions 274ThunderLAN driver primary functions
412 275
413 These functions are more or less common to all Linux network drivers. 276these functions are more or less common to all linux network drivers.
414 277
415****************************************************************************** 278******************************************************************************
416*****************************************************************************/ 279*****************************************************************************/
@@ -419,56 +282,124 @@ TLan_SetTimer( struct net_device *dev, u32 ticks, u32 type )
419 282
420 283
421 284
422 /*************************************************************** 285/***************************************************************
423 * tlan_remove_one 286 * tlan_remove_one
424 * 287 *
425 * Returns: 288 * Returns:
426 * Nothing 289 * Nothing
427 * Parms: 290 * Parms:
428 * None 291 * None
429 * 292 *
430 * Goes through the TLanDevices list and frees the device 293 * Goes through the TLanDevices list and frees the device
431 * structs and memory associated with each device (lists 294 * structs and memory associated with each device (lists
432 * and buffers). It also ureserves the IO port regions 295 * and buffers). It also ureserves the IO port regions
433 * associated with this device. 296 * associated with this device.
434 * 297 *
435 **************************************************************/ 298 **************************************************************/
436 299
437 300
438static void __devexit tlan_remove_one( struct pci_dev *pdev) 301static void __devexit tlan_remove_one(struct pci_dev *pdev)
439{ 302{
440 struct net_device *dev = pci_get_drvdata( pdev ); 303 struct net_device *dev = pci_get_drvdata(pdev);
441 TLanPrivateInfo *priv = netdev_priv(dev); 304 struct tlan_priv *priv = netdev_priv(dev);
442 305
443 unregister_netdev( dev ); 306 unregister_netdev(dev);
444 307
445 if ( priv->dmaStorage ) { 308 if (priv->dma_storage) {
446 pci_free_consistent(priv->pciDev, 309 pci_free_consistent(priv->pci_dev,
447 priv->dmaSize, priv->dmaStorage, 310 priv->dma_size, priv->dma_storage,
448 priv->dmaStorageDMA ); 311 priv->dma_storage_dma);
449 } 312 }
450 313
451#ifdef CONFIG_PCI 314#ifdef CONFIG_PCI
452 pci_release_regions(pdev); 315 pci_release_regions(pdev);
453#endif 316#endif
454 317
455 free_netdev( dev ); 318 free_netdev(dev);
319
320 pci_set_drvdata(pdev, NULL);
321}
322
323static void tlan_start(struct net_device *dev)
324{
325 tlan_reset_lists(dev);
326 /* NOTE: It might not be necessary to read the stats before a
327 reset if you don't care what the values are.
328 */
329 tlan_read_and_clear_stats(dev, TLAN_IGNORE);
330 tlan_reset_adapter(dev);
331 netif_wake_queue(dev);
332}
333
334static void tlan_stop(struct net_device *dev)
335{
336 struct tlan_priv *priv = netdev_priv(dev);
337
338 tlan_read_and_clear_stats(dev, TLAN_RECORD);
339 outl(TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD);
340 /* Reset and power down phy */
341 tlan_reset_adapter(dev);
342 if (priv->timer.function != NULL) {
343 del_timer_sync(&priv->timer);
344 priv->timer.function = NULL;
345 }
346}
347
348#ifdef CONFIG_PM
349
350static int tlan_suspend(struct pci_dev *pdev, pm_message_t state)
351{
352 struct net_device *dev = pci_get_drvdata(pdev);
353
354 if (netif_running(dev))
355 tlan_stop(dev);
356
357 netif_device_detach(dev);
358 pci_save_state(pdev);
359 pci_disable_device(pdev);
360 pci_wake_from_d3(pdev, false);
361 pci_set_power_state(pdev, PCI_D3hot);
456 362
457 pci_set_drvdata( pdev, NULL ); 363 return 0;
458} 364}
459 365
366static int tlan_resume(struct pci_dev *pdev)
367{
368 struct net_device *dev = pci_get_drvdata(pdev);
369
370 pci_set_power_state(pdev, PCI_D0);
371 pci_restore_state(pdev);
372 pci_enable_wake(pdev, 0, 0);
373 netif_device_attach(dev);
374
375 if (netif_running(dev))
376 tlan_start(dev);
377
378 return 0;
379}
380
381#else /* CONFIG_PM */
382
383#define tlan_suspend NULL
384#define tlan_resume NULL
385
386#endif /* CONFIG_PM */
387
388
460static struct pci_driver tlan_driver = { 389static struct pci_driver tlan_driver = {
461 .name = "tlan", 390 .name = "tlan",
462 .id_table = tlan_pci_tbl, 391 .id_table = tlan_pci_tbl,
463 .probe = tlan_init_one, 392 .probe = tlan_init_one,
464 .remove = __devexit_p(tlan_remove_one), 393 .remove = __devexit_p(tlan_remove_one),
394 .suspend = tlan_suspend,
395 .resume = tlan_resume,
465}; 396};
466 397
467static int __init tlan_probe(void) 398static int __init tlan_probe(void)
468{ 399{
469 int rc = -ENODEV; 400 int rc = -ENODEV;
470 401
471 printk(KERN_INFO "%s", tlan_banner); 402 pr_info("%s", tlan_banner);
472 403
473 TLAN_DBG(TLAN_DEBUG_PROBE, "Starting PCI Probe....\n"); 404 TLAN_DBG(TLAN_DEBUG_PROBE, "Starting PCI Probe....\n");
474 405
@@ -477,18 +408,18 @@ static int __init tlan_probe(void)
477 rc = pci_register_driver(&tlan_driver); 408 rc = pci_register_driver(&tlan_driver);
478 409
479 if (rc != 0) { 410 if (rc != 0) {
480 printk(KERN_ERR "TLAN: Could not register pci driver.\n"); 411 pr_err("Could not register pci driver\n");
481 goto err_out_pci_free; 412 goto err_out_pci_free;
482 } 413 }
483 414
484 TLAN_DBG(TLAN_DEBUG_PROBE, "Starting EISA Probe....\n"); 415 TLAN_DBG(TLAN_DEBUG_PROBE, "Starting EISA Probe....\n");
485 TLan_EisaProbe(); 416 tlan_eisa_probe();
486 417
487 printk(KERN_INFO "TLAN: %d device%s installed, PCI: %d EISA: %d\n", 418 pr_info("%d device%s installed, PCI: %d EISA: %d\n",
488 TLanDevicesInstalled, TLanDevicesInstalled == 1 ? "" : "s", 419 tlan_devices_installed, tlan_devices_installed == 1 ? "" : "s",
489 tlan_have_pci, tlan_have_eisa); 420 tlan_have_pci, tlan_have_eisa);
490 421
491 if (TLanDevicesInstalled == 0) { 422 if (tlan_devices_installed == 0) {
492 rc = -ENODEV; 423 rc = -ENODEV;
493 goto err_out_pci_unreg; 424 goto err_out_pci_unreg;
494 } 425 }
@@ -501,39 +432,39 @@ err_out_pci_free:
501} 432}
502 433
503 434
504static int __devinit tlan_init_one( struct pci_dev *pdev, 435static int __devinit tlan_init_one(struct pci_dev *pdev,
505 const struct pci_device_id *ent) 436 const struct pci_device_id *ent)
506{ 437{
507 return TLan_probe1( pdev, -1, -1, 0, ent); 438 return tlan_probe1(pdev, -1, -1, 0, ent);
508} 439}
509 440
510 441
511/* 442/*
512 *************************************************************** 443***************************************************************
513 * tlan_probe1 444* tlan_probe1
514 * 445*
515 * Returns: 446* Returns:
516 * 0 on success, error code on error 447* 0 on success, error code on error
517 * Parms: 448* Parms:
518 * none 449* none
519 * 450*
520 * The name is lower case to fit in with all the rest of 451* The name is lower case to fit in with all the rest of
521 * the netcard_probe names. This function looks for 452* the netcard_probe names. This function looks for
522 * another TLan based adapter, setting it up with the 453* another TLan based adapter, setting it up with the
523 * allocated device struct if one is found. 454* allocated device struct if one is found.
524 * tlan_probe has been ported to the new net API and 455* tlan_probe has been ported to the new net API and
525 * now allocates its own device structure. This function 456* now allocates its own device structure. This function
526 * is also used by modules. 457* is also used by modules.
527 * 458*
528 **************************************************************/ 459**************************************************************/
529 460
530static int __devinit TLan_probe1(struct pci_dev *pdev, 461static int __devinit tlan_probe1(struct pci_dev *pdev,
531 long ioaddr, int irq, int rev, 462 long ioaddr, int irq, int rev,
532 const struct pci_device_id *ent ) 463 const struct pci_device_id *ent)
533{ 464{
534 465
535 struct net_device *dev; 466 struct net_device *dev;
536 TLanPrivateInfo *priv; 467 struct tlan_priv *priv;
537 u16 device_id; 468 u16 device_id;
538 int reg, rc = -ENODEV; 469 int reg, rc = -ENODEV;
539 470
@@ -543,17 +474,17 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
543 if (rc) 474 if (rc)
544 return rc; 475 return rc;
545 476
546 rc = pci_request_regions(pdev, TLanSignature); 477 rc = pci_request_regions(pdev, tlan_signature);
547 if (rc) { 478 if (rc) {
548 printk(KERN_ERR "TLAN: Could not reserve IO regions\n"); 479 pr_err("Could not reserve IO regions\n");
549 goto err_out; 480 goto err_out;
550 } 481 }
551 } 482 }
552#endif /* CONFIG_PCI */ 483#endif /* CONFIG_PCI */
553 484
554 dev = alloc_etherdev(sizeof(TLanPrivateInfo)); 485 dev = alloc_etherdev(sizeof(struct tlan_priv));
555 if (dev == NULL) { 486 if (dev == NULL) {
556 printk(KERN_ERR "TLAN: Could not allocate memory for device.\n"); 487 pr_err("Could not allocate memory for device\n");
557 rc = -ENOMEM; 488 rc = -ENOMEM;
558 goto err_out_regions; 489 goto err_out_regions;
559 } 490 }
@@ -561,38 +492,39 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
561 492
562 priv = netdev_priv(dev); 493 priv = netdev_priv(dev);
563 494
564 priv->pciDev = pdev; 495 priv->pci_dev = pdev;
565 priv->dev = dev; 496 priv->dev = dev;
566 497
567 /* Is this a PCI device? */ 498 /* Is this a PCI device? */
568 if (pdev) { 499 if (pdev) {
569 u32 pci_io_base = 0; 500 u32 pci_io_base = 0;
570 501
571 priv->adapter = &board_info[ent->driver_data]; 502 priv->adapter = &board_info[ent->driver_data];
572 503
573 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 504 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
574 if (rc) { 505 if (rc) {
575 printk(KERN_ERR "TLAN: No suitable PCI mapping available.\n"); 506 pr_err("No suitable PCI mapping available\n");
576 goto err_out_free_dev; 507 goto err_out_free_dev;
577 } 508 }
578 509
579 for ( reg= 0; reg <= 5; reg ++ ) { 510 for (reg = 0; reg <= 5; reg++) {
580 if (pci_resource_flags(pdev, reg) & IORESOURCE_IO) { 511 if (pci_resource_flags(pdev, reg) & IORESOURCE_IO) {
581 pci_io_base = pci_resource_start(pdev, reg); 512 pci_io_base = pci_resource_start(pdev, reg);
582 TLAN_DBG( TLAN_DEBUG_GNRL, "IO mapping is available at %x.\n", 513 TLAN_DBG(TLAN_DEBUG_GNRL,
583 pci_io_base); 514 "IO mapping is available at %x.\n",
515 pci_io_base);
584 break; 516 break;
585 } 517 }
586 } 518 }
587 if (!pci_io_base) { 519 if (!pci_io_base) {
588 printk(KERN_ERR "TLAN: No IO mappings available\n"); 520 pr_err("No IO mappings available\n");
589 rc = -EIO; 521 rc = -EIO;
590 goto err_out_free_dev; 522 goto err_out_free_dev;
591 } 523 }
592 524
593 dev->base_addr = pci_io_base; 525 dev->base_addr = pci_io_base;
594 dev->irq = pdev->irq; 526 dev->irq = pdev->irq;
595 priv->adapterRev = pdev->revision; 527 priv->adapter_rev = pdev->revision;
596 pci_set_master(pdev); 528 pci_set_master(pdev);
597 pci_set_drvdata(pdev, dev); 529 pci_set_drvdata(pdev, dev);
598 530
@@ -602,11 +534,11 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
602 device_id = inw(ioaddr + EISA_ID2); 534 device_id = inw(ioaddr + EISA_ID2);
603 priv->is_eisa = 1; 535 priv->is_eisa = 1;
604 if (device_id == 0x20F1) { 536 if (device_id == 0x20F1) {
605 priv->adapter = &board_info[13]; /* NetFlex-3/E */ 537 priv->adapter = &board_info[13]; /* NetFlex-3/E */
606 priv->adapterRev = 23; /* TLAN 2.3 */ 538 priv->adapter_rev = 23; /* TLAN 2.3 */
607 } else { 539 } else {
608 priv->adapter = &board_info[14]; 540 priv->adapter = &board_info[14];
609 priv->adapterRev = 10; /* TLAN 1.0 */ 541 priv->adapter_rev = 10; /* TLAN 1.0 */
610 } 542 }
611 dev->base_addr = ioaddr; 543 dev->base_addr = ioaddr;
612 dev->irq = irq; 544 dev->irq = irq;
@@ -620,11 +552,11 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
620 priv->speed = ((dev->mem_start & 0x18) == 0x18) ? 0 552 priv->speed = ((dev->mem_start & 0x18) == 0x18) ? 0
621 : (dev->mem_start & 0x18) >> 3; 553 : (dev->mem_start & 0x18) >> 3;
622 554
623 if (priv->speed == 0x1) { 555 if (priv->speed == 0x1)
624 priv->speed = TLAN_SPEED_10; 556 priv->speed = TLAN_SPEED_10;
625 } else if (priv->speed == 0x2) { 557 else if (priv->speed == 0x2)
626 priv->speed = TLAN_SPEED_100; 558 priv->speed = TLAN_SPEED_100;
627 } 559
628 debug = priv->debug = dev->mem_end; 560 debug = priv->debug = dev->mem_end;
629 } else { 561 } else {
630 priv->aui = aui[boards_found]; 562 priv->aui = aui[boards_found];
@@ -635,46 +567,45 @@ static int __devinit TLan_probe1(struct pci_dev *pdev,
635 567
636 /* This will be used when we get an adapter error from 568 /* This will be used when we get an adapter error from
637 * within our irq handler */ 569 * within our irq handler */
638 INIT_WORK(&priv->tlan_tqueue, TLan_tx_timeout_work); 570 INIT_WORK(&priv->tlan_tqueue, tlan_tx_timeout_work);
639 571
640 spin_lock_init(&priv->lock); 572 spin_lock_init(&priv->lock);
641 573
642 rc = TLan_Init(dev); 574 rc = tlan_init(dev);
643 if (rc) { 575 if (rc) {
644 printk(KERN_ERR "TLAN: Could not set up device.\n"); 576 pr_err("Could not set up device\n");
645 goto err_out_free_dev; 577 goto err_out_free_dev;
646 } 578 }
647 579
648 rc = register_netdev(dev); 580 rc = register_netdev(dev);
649 if (rc) { 581 if (rc) {
650 printk(KERN_ERR "TLAN: Could not register device.\n"); 582 pr_err("Could not register device\n");
651 goto err_out_uninit; 583 goto err_out_uninit;
652 } 584 }
653 585
654 586
655 TLanDevicesInstalled++; 587 tlan_devices_installed++;
656 boards_found++; 588 boards_found++;
657 589
658 /* pdev is NULL if this is an EISA device */ 590 /* pdev is NULL if this is an EISA device */
659 if (pdev) 591 if (pdev)
660 tlan_have_pci++; 592 tlan_have_pci++;
661 else { 593 else {
662 priv->nextDevice = TLan_Eisa_Devices; 594 priv->next_device = tlan_eisa_devices;
663 TLan_Eisa_Devices = dev; 595 tlan_eisa_devices = dev;
664 tlan_have_eisa++; 596 tlan_have_eisa++;
665 } 597 }
666 598
667 printk(KERN_INFO "TLAN: %s irq=%2d, io=%04x, %s, Rev. %d\n", 599 netdev_info(dev, "irq=%2d, io=%04x, %s, Rev. %d\n",
668 dev->name, 600 (int)dev->irq,
669 (int) dev->irq, 601 (int)dev->base_addr,
670 (int) dev->base_addr, 602 priv->adapter->device_label,
671 priv->adapter->deviceLabel, 603 priv->adapter_rev);
672 priv->adapterRev);
673 return 0; 604 return 0;
674 605
675err_out_uninit: 606err_out_uninit:
676 pci_free_consistent(priv->pciDev, priv->dmaSize, priv->dmaStorage, 607 pci_free_consistent(priv->pci_dev, priv->dma_size, priv->dma_storage,
677 priv->dmaStorageDMA ); 608 priv->dma_storage_dma);
678err_out_free_dev: 609err_out_free_dev:
679 free_netdev(dev); 610 free_netdev(dev);
680err_out_regions: 611err_out_regions:
@@ -689,22 +620,23 @@ err_out:
689} 620}
690 621
691 622
692static void TLan_Eisa_Cleanup(void) 623static void tlan_eisa_cleanup(void)
693{ 624{
694 struct net_device *dev; 625 struct net_device *dev;
695 TLanPrivateInfo *priv; 626 struct tlan_priv *priv;
696 627
697 while( tlan_have_eisa ) { 628 while (tlan_have_eisa) {
698 dev = TLan_Eisa_Devices; 629 dev = tlan_eisa_devices;
699 priv = netdev_priv(dev); 630 priv = netdev_priv(dev);
700 if (priv->dmaStorage) { 631 if (priv->dma_storage) {
701 pci_free_consistent(priv->pciDev, priv->dmaSize, 632 pci_free_consistent(priv->pci_dev, priv->dma_size,
702 priv->dmaStorage, priv->dmaStorageDMA ); 633 priv->dma_storage,
634 priv->dma_storage_dma);
703 } 635 }
704 release_region( dev->base_addr, 0x10); 636 release_region(dev->base_addr, 0x10);
705 unregister_netdev( dev ); 637 unregister_netdev(dev);
706 TLan_Eisa_Devices = priv->nextDevice; 638 tlan_eisa_devices = priv->next_device;
707 free_netdev( dev ); 639 free_netdev(dev);
708 tlan_have_eisa--; 640 tlan_have_eisa--;
709 } 641 }
710} 642}
@@ -715,7 +647,7 @@ static void __exit tlan_exit(void)
715 pci_unregister_driver(&tlan_driver); 647 pci_unregister_driver(&tlan_driver);
716 648
717 if (tlan_have_eisa) 649 if (tlan_have_eisa)
718 TLan_Eisa_Cleanup(); 650 tlan_eisa_cleanup();
719 651
720} 652}
721 653
@@ -726,24 +658,24 @@ module_exit(tlan_exit);
726 658
727 659
728 660
729 /************************************************************** 661/**************************************************************
730 * TLan_EisaProbe 662 * tlan_eisa_probe
731 * 663 *
732 * Returns: 0 on success, 1 otherwise 664 * Returns: 0 on success, 1 otherwise
733 * 665 *
734 * Parms: None 666 * Parms: None
735 * 667 *
736 * 668 *
737 * This functions probes for EISA devices and calls 669 * This functions probes for EISA devices and calls
738 * TLan_probe1 when one is found. 670 * TLan_probe1 when one is found.
739 * 671 *
740 *************************************************************/ 672 *************************************************************/
741 673
742static void __init TLan_EisaProbe (void) 674static void __init tlan_eisa_probe(void)
743{ 675{
744 long ioaddr; 676 long ioaddr;
745 int rc = -ENODEV; 677 int rc = -ENODEV;
746 int irq; 678 int irq;
747 u16 device_id; 679 u16 device_id;
748 680
749 if (!EISA_bus) { 681 if (!EISA_bus) {
@@ -754,15 +686,16 @@ static void __init TLan_EisaProbe (void)
754 /* Loop through all slots of the EISA bus */ 686 /* Loop through all slots of the EISA bus */
755 for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) { 687 for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
756 688
757 TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n", 689 TLAN_DBG(TLAN_DEBUG_PROBE, "EISA_ID 0x%4x: 0x%4x\n",
758 (int) ioaddr + 0xC80, inw(ioaddr + EISA_ID)); 690 (int) ioaddr + 0xc80, inw(ioaddr + EISA_ID));
759 TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4x\n", 691 TLAN_DBG(TLAN_DEBUG_PROBE, "EISA_ID 0x%4x: 0x%4x\n",
760 (int) ioaddr + 0xC82, inw(ioaddr + EISA_ID2)); 692 (int) ioaddr + 0xc82, inw(ioaddr + EISA_ID2));
761 693
762 694
763 TLAN_DBG(TLAN_DEBUG_PROBE, "Probing for EISA adapter at IO: 0x%4x : ", 695 TLAN_DBG(TLAN_DEBUG_PROBE,
764 (int) ioaddr); 696 "Probing for EISA adapter at IO: 0x%4x : ",
765 if (request_region(ioaddr, 0x10, TLanSignature) == NULL) 697 (int) ioaddr);
698 if (request_region(ioaddr, 0x10, tlan_signature) == NULL)
766 goto out; 699 goto out;
767 700
768 if (inw(ioaddr + EISA_ID) != 0x110E) { 701 if (inw(ioaddr + EISA_ID) != 0x110E) {
@@ -772,326 +705,324 @@ static void __init TLan_EisaProbe (void)
772 705
773 device_id = inw(ioaddr + EISA_ID2); 706 device_id = inw(ioaddr + EISA_ID2);
774 if (device_id != 0x20F1 && device_id != 0x40F1) { 707 if (device_id != 0x20F1 && device_id != 0x40F1) {
775 release_region (ioaddr, 0x10); 708 release_region(ioaddr, 0x10);
776 goto out; 709 goto out;
777 } 710 }
778 711
779 if (inb(ioaddr + EISA_CR) != 0x1) { /* Check if adapter is enabled */ 712 /* check if adapter is enabled */
780 release_region (ioaddr, 0x10); 713 if (inb(ioaddr + EISA_CR) != 0x1) {
714 release_region(ioaddr, 0x10);
781 goto out2; 715 goto out2;
782 } 716 }
783 717
784 if (debug == 0x10) 718 if (debug == 0x10)
785 printk("Found one\n"); 719 pr_info("Found one\n");
786 720
787 721
788 /* Get irq from board */ 722 /* Get irq from board */
789 switch (inb(ioaddr + 0xCC0)) { 723 switch (inb(ioaddr + 0xcc0)) {
790 case(0x10): 724 case(0x10):
791 irq=5; 725 irq = 5;
792 break; 726 break;
793 case(0x20): 727 case(0x20):
794 irq=9; 728 irq = 9;
795 break; 729 break;
796 case(0x40): 730 case(0x40):
797 irq=10; 731 irq = 10;
798 break; 732 break;
799 case(0x80): 733 case(0x80):
800 irq=11; 734 irq = 11;
801 break; 735 break;
802 default: 736 default:
803 goto out; 737 goto out;
804 } 738 }
805 739
806 740
807 /* Setup the newly found eisa adapter */ 741 /* Setup the newly found eisa adapter */
808 rc = TLan_probe1( NULL, ioaddr, irq, 742 rc = tlan_probe1(NULL, ioaddr, irq,
809 12, NULL); 743 12, NULL);
810 continue; 744 continue;
811 745
812 out: 746out:
813 if (debug == 0x10) 747 if (debug == 0x10)
814 printk("None found\n"); 748 pr_info("None found\n");
815 continue; 749 continue;
816 750
817 out2: if (debug == 0x10) 751out2:
818 printk("Card found but it is not enabled, skipping\n"); 752 if (debug == 0x10)
819 continue; 753 pr_info("Card found but it is not enabled, skipping\n");
754 continue;
820 755
821 } 756 }
822 757
823} /* TLan_EisaProbe */ 758}
824 759
825#ifdef CONFIG_NET_POLL_CONTROLLER 760#ifdef CONFIG_NET_POLL_CONTROLLER
826static void TLan_Poll(struct net_device *dev) 761static void tlan_poll(struct net_device *dev)
827{ 762{
828 disable_irq(dev->irq); 763 disable_irq(dev->irq);
829 TLan_HandleInterrupt(dev->irq, dev); 764 tlan_handle_interrupt(dev->irq, dev);
830 enable_irq(dev->irq); 765 enable_irq(dev->irq);
831} 766}
832#endif 767#endif
833 768
834static const struct net_device_ops TLan_netdev_ops = { 769static const struct net_device_ops tlan_netdev_ops = {
835 .ndo_open = TLan_Open, 770 .ndo_open = tlan_open,
836 .ndo_stop = TLan_Close, 771 .ndo_stop = tlan_close,
837 .ndo_start_xmit = TLan_StartTx, 772 .ndo_start_xmit = tlan_start_tx,
838 .ndo_tx_timeout = TLan_tx_timeout, 773 .ndo_tx_timeout = tlan_tx_timeout,
839 .ndo_get_stats = TLan_GetStats, 774 .ndo_get_stats = tlan_get_stats,
840 .ndo_set_multicast_list = TLan_SetMulticastList, 775 .ndo_set_multicast_list = tlan_set_multicast_list,
841 .ndo_do_ioctl = TLan_ioctl, 776 .ndo_do_ioctl = tlan_ioctl,
842 .ndo_change_mtu = eth_change_mtu, 777 .ndo_change_mtu = eth_change_mtu,
843 .ndo_set_mac_address = eth_mac_addr, 778 .ndo_set_mac_address = eth_mac_addr,
844 .ndo_validate_addr = eth_validate_addr, 779 .ndo_validate_addr = eth_validate_addr,
845#ifdef CONFIG_NET_POLL_CONTROLLER 780#ifdef CONFIG_NET_POLL_CONTROLLER
846 .ndo_poll_controller = TLan_Poll, 781 .ndo_poll_controller = tlan_poll,
847#endif 782#endif
848}; 783};
849 784
850 785
851 786
852 /*************************************************************** 787/***************************************************************
853 * TLan_Init 788 * tlan_init
854 * 789 *
855 * Returns: 790 * Returns:
856 * 0 on success, error code otherwise. 791 * 0 on success, error code otherwise.
857 * Parms: 792 * Parms:
858 * dev The structure of the device to be 793 * dev The structure of the device to be
859 * init'ed. 794 * init'ed.
860 * 795 *
861 * This function completes the initialization of the 796 * This function completes the initialization of the
862 * device structure and driver. It reserves the IO 797 * device structure and driver. It reserves the IO
863 * addresses, allocates memory for the lists and bounce 798 * addresses, allocates memory for the lists and bounce
864 * buffers, retrieves the MAC address from the eeprom 799 * buffers, retrieves the MAC address from the eeprom
865 * and assignes the device's methods. 800 * and assignes the device's methods.
866 * 801 *
867 **************************************************************/ 802 **************************************************************/
868 803
869static int TLan_Init( struct net_device *dev ) 804static int tlan_init(struct net_device *dev)
870{ 805{
871 int dma_size; 806 int dma_size;
872 int err; 807 int err;
873 int i; 808 int i;
874 TLanPrivateInfo *priv; 809 struct tlan_priv *priv;
875 810
876 priv = netdev_priv(dev); 811 priv = netdev_priv(dev);
877 812
878 dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS ) 813 dma_size = (TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS)
879 * ( sizeof(TLanList) ); 814 * (sizeof(struct tlan_list));
880 priv->dmaStorage = pci_alloc_consistent(priv->pciDev, 815 priv->dma_storage = pci_alloc_consistent(priv->pci_dev,
881 dma_size, &priv->dmaStorageDMA); 816 dma_size,
882 priv->dmaSize = dma_size; 817 &priv->dma_storage_dma);
818 priv->dma_size = dma_size;
883 819
884 if ( priv->dmaStorage == NULL ) { 820 if (priv->dma_storage == NULL) {
885 printk(KERN_ERR "TLAN: Could not allocate lists and buffers for %s.\n", 821 pr_err("Could not allocate lists and buffers for %s\n",
886 dev->name ); 822 dev->name);
887 return -ENOMEM; 823 return -ENOMEM;
888 } 824 }
889 memset( priv->dmaStorage, 0, dma_size ); 825 memset(priv->dma_storage, 0, dma_size);
890 priv->rxList = (TLanList *) ALIGN((unsigned long)priv->dmaStorage, 8); 826 priv->rx_list = (struct tlan_list *)
891 priv->rxListDMA = ALIGN(priv->dmaStorageDMA, 8); 827 ALIGN((unsigned long)priv->dma_storage, 8);
892 priv->txList = priv->rxList + TLAN_NUM_RX_LISTS; 828 priv->rx_list_dma = ALIGN(priv->dma_storage_dma, 8);
893 priv->txListDMA = priv->rxListDMA + sizeof(TLanList) * TLAN_NUM_RX_LISTS; 829 priv->tx_list = priv->rx_list + TLAN_NUM_RX_LISTS;
830 priv->tx_list_dma =
831 priv->rx_list_dma + sizeof(struct tlan_list)*TLAN_NUM_RX_LISTS;
894 832
895 err = 0; 833 err = 0;
896 for ( i = 0; i < 6 ; i++ ) 834 for (i = 0; i < 6 ; i++)
897 err |= TLan_EeReadByte( dev, 835 err |= tlan_ee_read_byte(dev,
898 (u8) priv->adapter->addrOfs + i, 836 (u8) priv->adapter->addr_ofs + i,
899 (u8 *) &dev->dev_addr[i] ); 837 (u8 *) &dev->dev_addr[i]);
900 if ( err ) { 838 if (err) {
901 printk(KERN_ERR "TLAN: %s: Error reading MAC from eeprom: %d\n", 839 pr_err("%s: Error reading MAC from eeprom: %d\n",
902 dev->name, 840 dev->name, err);
903 err );
904 } 841 }
905 dev->addr_len = 6; 842 dev->addr_len = 6;
906 843
907 netif_carrier_off(dev); 844 netif_carrier_off(dev);
908 845
909 /* Device methods */ 846 /* Device methods */
910 dev->netdev_ops = &TLan_netdev_ops; 847 dev->netdev_ops = &tlan_netdev_ops;
911 dev->watchdog_timeo = TX_TIMEOUT; 848 dev->watchdog_timeo = TX_TIMEOUT;
912 849
913 return 0; 850 return 0;
914 851
915} /* TLan_Init */ 852}
916 853
917 854
918 855
919 856
920 /*************************************************************** 857/***************************************************************
921 * TLan_Open 858 * tlan_open
922 * 859 *
923 * Returns: 860 * Returns:
924 * 0 on success, error code otherwise. 861 * 0 on success, error code otherwise.
925 * Parms: 862 * Parms:
926 * dev Structure of device to be opened. 863 * dev Structure of device to be opened.
927 * 864 *
928 * This routine puts the driver and TLAN adapter in a 865 * This routine puts the driver and TLAN adapter in a
929 * state where it is ready to send and receive packets. 866 * state where it is ready to send and receive packets.
930 * It allocates the IRQ, resets and brings the adapter 867 * It allocates the IRQ, resets and brings the adapter
931 * out of reset, and allows interrupts. It also delays 868 * out of reset, and allows interrupts. It also delays
932 * the startup for autonegotiation or sends a Rx GO 869 * the startup for autonegotiation or sends a Rx GO
933 * command to the adapter, as appropriate. 870 * command to the adapter, as appropriate.
934 * 871 *
935 **************************************************************/ 872 **************************************************************/
936 873
937static int TLan_Open( struct net_device *dev ) 874static int tlan_open(struct net_device *dev)
938{ 875{
939 TLanPrivateInfo *priv = netdev_priv(dev); 876 struct tlan_priv *priv = netdev_priv(dev);
940 int err; 877 int err;
941 878
942 priv->tlanRev = TLan_DioRead8( dev->base_addr, TLAN_DEF_REVISION ); 879 priv->tlan_rev = tlan_dio_read8(dev->base_addr, TLAN_DEF_REVISION);
943 err = request_irq( dev->irq, TLan_HandleInterrupt, IRQF_SHARED, 880 err = request_irq(dev->irq, tlan_handle_interrupt, IRQF_SHARED,
944 dev->name, dev ); 881 dev->name, dev);
945 882
946 if ( err ) { 883 if (err) {
947 pr_err("TLAN: Cannot open %s because IRQ %d is already in use.\n", 884 netdev_err(dev, "Cannot open because IRQ %d is already in use\n",
948 dev->name, dev->irq ); 885 dev->irq);
949 return err; 886 return err;
950 } 887 }
951 888
952 init_timer(&priv->timer); 889 init_timer(&priv->timer);
953 netif_start_queue(dev);
954 890
955 /* NOTE: It might not be necessary to read the stats before a 891 tlan_start(dev);
956 reset if you don't care what the values are.
957 */
958 TLan_ResetLists( dev );
959 TLan_ReadAndClearStats( dev, TLAN_IGNORE );
960 TLan_ResetAdapter( dev );
961 892
962 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Opened. TLAN Chip Rev: %x\n", 893 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Opened. TLAN Chip Rev: %x\n",
963 dev->name, priv->tlanRev ); 894 dev->name, priv->tlan_rev);
964 895
965 return 0; 896 return 0;
966 897
967} /* TLan_Open */ 898}
968 899
969 900
970 901
971 /************************************************************** 902/**************************************************************
972 * TLan_ioctl 903 * tlan_ioctl
973 * 904 *
974 * Returns: 905 * Returns:
975 * 0 on success, error code otherwise 906 * 0 on success, error code otherwise
976 * Params: 907 * Params:
977 * dev structure of device to receive ioctl. 908 * dev structure of device to receive ioctl.
978 * 909 *
979 * rq ifreq structure to hold userspace data. 910 * rq ifreq structure to hold userspace data.
980 * 911 *
981 * cmd ioctl command. 912 * cmd ioctl command.
982 * 913 *
983 * 914 *
984 *************************************************************/ 915 *************************************************************/
985 916
986static int TLan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 917static int tlan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
987{ 918{
988 TLanPrivateInfo *priv = netdev_priv(dev); 919 struct tlan_priv *priv = netdev_priv(dev);
989 struct mii_ioctl_data *data = if_mii(rq); 920 struct mii_ioctl_data *data = if_mii(rq);
990 u32 phy = priv->phy[priv->phyNum]; 921 u32 phy = priv->phy[priv->phy_num];
991 922
992 if (!priv->phyOnline) 923 if (!priv->phy_online)
993 return -EAGAIN; 924 return -EAGAIN;
994 925
995 switch(cmd) { 926 switch (cmd) {
996 case SIOCGMIIPHY: /* Get address of MII PHY in use. */ 927 case SIOCGMIIPHY: /* get address of MII PHY in use. */
997 data->phy_id = phy; 928 data->phy_id = phy;
998 929
999 930
1000 case SIOCGMIIREG: /* Read MII PHY register. */ 931 case SIOCGMIIREG: /* read MII PHY register. */
1001 TLan_MiiReadReg(dev, data->phy_id & 0x1f, 932 tlan_mii_read_reg(dev, data->phy_id & 0x1f,
1002 data->reg_num & 0x1f, &data->val_out); 933 data->reg_num & 0x1f, &data->val_out);
1003 return 0; 934 return 0;
1004 935
1005 936
1006 case SIOCSMIIREG: /* Write MII PHY register. */ 937 case SIOCSMIIREG: /* write MII PHY register. */
1007 TLan_MiiWriteReg(dev, data->phy_id & 0x1f, 938 tlan_mii_write_reg(dev, data->phy_id & 0x1f,
1008 data->reg_num & 0x1f, data->val_in); 939 data->reg_num & 0x1f, data->val_in);
1009 return 0; 940 return 0;
1010 default: 941 default:
1011 return -EOPNOTSUPP; 942 return -EOPNOTSUPP;
1012 } 943 }
1013} /* tlan_ioctl */ 944}
1014 945
1015 946
1016 /*************************************************************** 947/***************************************************************
1017 * TLan_tx_timeout 948 * tlan_tx_timeout
1018 * 949 *
1019 * Returns: nothing 950 * Returns: nothing
1020 * 951 *
1021 * Params: 952 * Params:
1022 * dev structure of device which timed out 953 * dev structure of device which timed out
1023 * during transmit. 954 * during transmit.
1024 * 955 *
1025 **************************************************************/ 956 **************************************************************/
1026 957
1027static void TLan_tx_timeout(struct net_device *dev) 958static void tlan_tx_timeout(struct net_device *dev)
1028{ 959{
1029 960
1030 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Transmit timed out.\n", dev->name); 961 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Transmit timed out.\n", dev->name);
1031 962
1032 /* Ok so we timed out, lets see what we can do about it...*/ 963 /* Ok so we timed out, lets see what we can do about it...*/
1033 TLan_FreeLists( dev ); 964 tlan_free_lists(dev);
1034 TLan_ResetLists( dev ); 965 tlan_reset_lists(dev);
1035 TLan_ReadAndClearStats( dev, TLAN_IGNORE ); 966 tlan_read_and_clear_stats(dev, TLAN_IGNORE);
1036 TLan_ResetAdapter( dev ); 967 tlan_reset_adapter(dev);
1037 dev->trans_start = jiffies; /* prevent tx timeout */ 968 dev->trans_start = jiffies; /* prevent tx timeout */
1038 netif_wake_queue( dev ); 969 netif_wake_queue(dev);
1039 970
1040} 971}
1041 972
1042 973
1043 /*************************************************************** 974/***************************************************************
1044 * TLan_tx_timeout_work 975 * tlan_tx_timeout_work
1045 * 976 *
1046 * Returns: nothing 977 * Returns: nothing
1047 * 978 *
1048 * Params: 979 * Params:
1049 * work work item of device which timed out 980 * work work item of device which timed out
1050 * 981 *
1051 **************************************************************/ 982 **************************************************************/
1052 983
1053static void TLan_tx_timeout_work(struct work_struct *work) 984static void tlan_tx_timeout_work(struct work_struct *work)
1054{ 985{
1055 TLanPrivateInfo *priv = 986 struct tlan_priv *priv =
1056 container_of(work, TLanPrivateInfo, tlan_tqueue); 987 container_of(work, struct tlan_priv, tlan_tqueue);
1057 988
1058 TLan_tx_timeout(priv->dev); 989 tlan_tx_timeout(priv->dev);
1059} 990}
1060 991
1061 992
1062 993
1063 /*************************************************************** 994/***************************************************************
1064 * TLan_StartTx 995 * tlan_start_tx
1065 * 996 *
1066 * Returns: 997 * Returns:
1067 * 0 on success, non-zero on failure. 998 * 0 on success, non-zero on failure.
1068 * Parms: 999 * Parms:
1069 * skb A pointer to the sk_buff containing the 1000 * skb A pointer to the sk_buff containing the
1070 * frame to be sent. 1001 * frame to be sent.
1071 * dev The device to send the data on. 1002 * dev The device to send the data on.
1072 * 1003 *
1073 * This function adds a frame to the Tx list to be sent 1004 * This function adds a frame to the Tx list to be sent
1074 * ASAP. First it verifies that the adapter is ready and 1005 * ASAP. First it verifies that the adapter is ready and
1075 * there is room in the queue. Then it sets up the next 1006 * there is room in the queue. Then it sets up the next
1076 * available list, copies the frame to the corresponding 1007 * available list, copies the frame to the corresponding
1077 * buffer. If the adapter Tx channel is idle, it gives 1008 * buffer. If the adapter Tx channel is idle, it gives
1078 * the adapter a Tx Go command on the list, otherwise it 1009 * the adapter a Tx Go command on the list, otherwise it
1079 * sets the forward address of the previous list to point 1010 * sets the forward address of the previous list to point
1080 * to this one. Then it frees the sk_buff. 1011 * to this one. Then it frees the sk_buff.
1081 * 1012 *
1082 **************************************************************/ 1013 **************************************************************/
1083 1014
1084static netdev_tx_t TLan_StartTx( struct sk_buff *skb, struct net_device *dev ) 1015static netdev_tx_t tlan_start_tx(struct sk_buff *skb, struct net_device *dev)
1085{ 1016{
1086 TLanPrivateInfo *priv = netdev_priv(dev); 1017 struct tlan_priv *priv = netdev_priv(dev);
1087 dma_addr_t tail_list_phys; 1018 dma_addr_t tail_list_phys;
1088 TLanList *tail_list; 1019 struct tlan_list *tail_list;
1089 unsigned long flags; 1020 unsigned long flags;
1090 unsigned int txlen; 1021 unsigned int txlen;
1091 1022
1092 if ( ! priv->phyOnline ) { 1023 if (!priv->phy_online) {
1093 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: %s PHY is not ready\n", 1024 TLAN_DBG(TLAN_DEBUG_TX, "TRANSMIT: %s PHY is not ready\n",
1094 dev->name ); 1025 dev->name);
1095 dev_kfree_skb_any(skb); 1026 dev_kfree_skb_any(skb);
1096 return NETDEV_TX_OK; 1027 return NETDEV_TX_OK;
1097 } 1028 }
@@ -1100,218 +1031,214 @@ static netdev_tx_t TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
1100 return NETDEV_TX_OK; 1031 return NETDEV_TX_OK;
1101 txlen = max(skb->len, (unsigned int)TLAN_MIN_FRAME_SIZE); 1032 txlen = max(skb->len, (unsigned int)TLAN_MIN_FRAME_SIZE);
1102 1033
1103 tail_list = priv->txList + priv->txTail; 1034 tail_list = priv->tx_list + priv->tx_tail;
1104 tail_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txTail; 1035 tail_list_phys =
1036 priv->tx_list_dma + sizeof(struct tlan_list)*priv->tx_tail;
1105 1037
1106 if ( tail_list->cStat != TLAN_CSTAT_UNUSED ) { 1038 if (tail_list->c_stat != TLAN_CSTAT_UNUSED) {
1107 TLAN_DBG( TLAN_DEBUG_TX, 1039 TLAN_DBG(TLAN_DEBUG_TX,
1108 "TRANSMIT: %s is busy (Head=%d Tail=%d)\n", 1040 "TRANSMIT: %s is busy (Head=%d Tail=%d)\n",
1109 dev->name, priv->txHead, priv->txTail ); 1041 dev->name, priv->tx_head, priv->tx_tail);
1110 netif_stop_queue(dev); 1042 netif_stop_queue(dev);
1111 priv->txBusyCount++; 1043 priv->tx_busy_count++;
1112 return NETDEV_TX_BUSY; 1044 return NETDEV_TX_BUSY;
1113 } 1045 }
1114 1046
1115 tail_list->forward = 0; 1047 tail_list->forward = 0;
1116 1048
1117 tail_list->buffer[0].address = pci_map_single(priv->pciDev, 1049 tail_list->buffer[0].address = pci_map_single(priv->pci_dev,
1118 skb->data, txlen, 1050 skb->data, txlen,
1119 PCI_DMA_TODEVICE); 1051 PCI_DMA_TODEVICE);
1120 TLan_StoreSKB(tail_list, skb); 1052 tlan_store_skb(tail_list, skb);
1121 1053
1122 tail_list->frameSize = (u16) txlen; 1054 tail_list->frame_size = (u16) txlen;
1123 tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) txlen; 1055 tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) txlen;
1124 tail_list->buffer[1].count = 0; 1056 tail_list->buffer[1].count = 0;
1125 tail_list->buffer[1].address = 0; 1057 tail_list->buffer[1].address = 0;
1126 1058
1127 spin_lock_irqsave(&priv->lock, flags); 1059 spin_lock_irqsave(&priv->lock, flags);
1128 tail_list->cStat = TLAN_CSTAT_READY; 1060 tail_list->c_stat = TLAN_CSTAT_READY;
1129 if ( ! priv->txInProgress ) { 1061 if (!priv->tx_in_progress) {
1130 priv->txInProgress = 1; 1062 priv->tx_in_progress = 1;
1131 TLAN_DBG( TLAN_DEBUG_TX, 1063 TLAN_DBG(TLAN_DEBUG_TX,
1132 "TRANSMIT: Starting TX on buffer %d\n", priv->txTail ); 1064 "TRANSMIT: Starting TX on buffer %d\n",
1133 outl( tail_list_phys, dev->base_addr + TLAN_CH_PARM ); 1065 priv->tx_tail);
1134 outl( TLAN_HC_GO, dev->base_addr + TLAN_HOST_CMD ); 1066 outl(tail_list_phys, dev->base_addr + TLAN_CH_PARM);
1067 outl(TLAN_HC_GO, dev->base_addr + TLAN_HOST_CMD);
1135 } else { 1068 } else {
1136 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: Adding buffer %d to TX channel\n", 1069 TLAN_DBG(TLAN_DEBUG_TX,
1137 priv->txTail ); 1070 "TRANSMIT: Adding buffer %d to TX channel\n",
1138 if ( priv->txTail == 0 ) { 1071 priv->tx_tail);
1139 ( priv->txList + ( TLAN_NUM_TX_LISTS - 1 ) )->forward 1072 if (priv->tx_tail == 0) {
1073 (priv->tx_list + (TLAN_NUM_TX_LISTS - 1))->forward
1140 = tail_list_phys; 1074 = tail_list_phys;
1141 } else { 1075 } else {
1142 ( priv->txList + ( priv->txTail - 1 ) )->forward 1076 (priv->tx_list + (priv->tx_tail - 1))->forward
1143 = tail_list_phys; 1077 = tail_list_phys;
1144 } 1078 }
1145 } 1079 }
1146 spin_unlock_irqrestore(&priv->lock, flags); 1080 spin_unlock_irqrestore(&priv->lock, flags);
1147 1081
1148 CIRC_INC( priv->txTail, TLAN_NUM_TX_LISTS ); 1082 CIRC_INC(priv->tx_tail, TLAN_NUM_TX_LISTS);
1149 1083
1150 return NETDEV_TX_OK; 1084 return NETDEV_TX_OK;
1151 1085
1152} /* TLan_StartTx */ 1086}
1153 1087
1154 1088
1155 1089
1156 1090
1157 /*************************************************************** 1091/***************************************************************
1158 * TLan_HandleInterrupt 1092 * tlan_handle_interrupt
1159 * 1093 *
1160 * Returns: 1094 * Returns:
1161 * Nothing 1095 * Nothing
1162 * Parms: 1096 * Parms:
1163 * irq The line on which the interrupt 1097 * irq The line on which the interrupt
1164 * occurred. 1098 * occurred.
1165 * dev_id A pointer to the device assigned to 1099 * dev_id A pointer to the device assigned to
1166 * this irq line. 1100 * this irq line.
1167 * 1101 *
1168 * This function handles an interrupt generated by its 1102 * This function handles an interrupt generated by its
1169 * assigned TLAN adapter. The function deactivates 1103 * assigned TLAN adapter. The function deactivates
1170 * interrupts on its adapter, records the type of 1104 * interrupts on its adapter, records the type of
1171 * interrupt, executes the appropriate subhandler, and 1105 * interrupt, executes the appropriate subhandler, and
1172 * acknowdges the interrupt to the adapter (thus 1106 * acknowdges the interrupt to the adapter (thus
1173 * re-enabling adapter interrupts. 1107 * re-enabling adapter interrupts.
1174 * 1108 *
1175 **************************************************************/ 1109 **************************************************************/
1176 1110
1177static irqreturn_t TLan_HandleInterrupt(int irq, void *dev_id) 1111static irqreturn_t tlan_handle_interrupt(int irq, void *dev_id)
1178{ 1112{
1179 struct net_device *dev = dev_id; 1113 struct net_device *dev = dev_id;
1180 TLanPrivateInfo *priv = netdev_priv(dev); 1114 struct tlan_priv *priv = netdev_priv(dev);
1181 u16 host_int; 1115 u16 host_int;
1182 u16 type; 1116 u16 type;
1183 1117
1184 spin_lock(&priv->lock); 1118 spin_lock(&priv->lock);
1185 1119
1186 host_int = inw( dev->base_addr + TLAN_HOST_INT ); 1120 host_int = inw(dev->base_addr + TLAN_HOST_INT);
1187 type = ( host_int & TLAN_HI_IT_MASK ) >> 2; 1121 type = (host_int & TLAN_HI_IT_MASK) >> 2;
1188 if ( type ) { 1122 if (type) {
1189 u32 ack; 1123 u32 ack;
1190 u32 host_cmd; 1124 u32 host_cmd;
1191 1125
1192 outw( host_int, dev->base_addr + TLAN_HOST_INT ); 1126 outw(host_int, dev->base_addr + TLAN_HOST_INT);
1193 ack = TLanIntVector[type]( dev, host_int ); 1127 ack = tlan_int_vector[type](dev, host_int);
1194 1128
1195 if ( ack ) { 1129 if (ack) {
1196 host_cmd = TLAN_HC_ACK | ack | ( type << 18 ); 1130 host_cmd = TLAN_HC_ACK | ack | (type << 18);
1197 outl( host_cmd, dev->base_addr + TLAN_HOST_CMD ); 1131 outl(host_cmd, dev->base_addr + TLAN_HOST_CMD);
1198 } 1132 }
1199 } 1133 }
1200 1134
1201 spin_unlock(&priv->lock); 1135 spin_unlock(&priv->lock);
1202 1136
1203 return IRQ_RETVAL(type); 1137 return IRQ_RETVAL(type);
1204} /* TLan_HandleInterrupts */ 1138}
1205 1139
1206 1140
1207 1141
1208 1142
1209 /*************************************************************** 1143/***************************************************************
1210 * TLan_Close 1144 * tlan_close
1211 * 1145 *
1212 * Returns: 1146 * Returns:
1213 * An error code. 1147 * An error code.
1214 * Parms: 1148 * Parms:
1215 * dev The device structure of the device to 1149 * dev The device structure of the device to
1216 * close. 1150 * close.
1217 * 1151 *
1218 * This function shuts down the adapter. It records any 1152 * This function shuts down the adapter. It records any
1219 * stats, puts the adapter into reset state, deactivates 1153 * stats, puts the adapter into reset state, deactivates
1220 * its time as needed, and frees the irq it is using. 1154 * its time as needed, and frees the irq it is using.
1221 * 1155 *
1222 **************************************************************/ 1156 **************************************************************/
1223 1157
1224static int TLan_Close(struct net_device *dev) 1158static int tlan_close(struct net_device *dev)
1225{ 1159{
1226 TLanPrivateInfo *priv = netdev_priv(dev); 1160 struct tlan_priv *priv = netdev_priv(dev);
1227 1161
1228 netif_stop_queue(dev);
1229 priv->neg_be_verbose = 0; 1162 priv->neg_be_verbose = 0;
1163 tlan_stop(dev);
1230 1164
1231 TLan_ReadAndClearStats( dev, TLAN_RECORD ); 1165 free_irq(dev->irq, dev);
1232 outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD ); 1166 tlan_free_lists(dev);
1233 if ( priv->timer.function != NULL ) { 1167 TLAN_DBG(TLAN_DEBUG_GNRL, "Device %s closed.\n", dev->name);
1234 del_timer_sync( &priv->timer );
1235 priv->timer.function = NULL;
1236 }
1237
1238 free_irq( dev->irq, dev );
1239 TLan_FreeLists( dev );
1240 TLAN_DBG( TLAN_DEBUG_GNRL, "Device %s closed.\n", dev->name );
1241 1168
1242 return 0; 1169 return 0;
1243 1170
1244} /* TLan_Close */ 1171}
1245 1172
1246 1173
1247 1174
1248 1175
1249 /*************************************************************** 1176/***************************************************************
1250 * TLan_GetStats 1177 * tlan_get_stats
1251 * 1178 *
1252 * Returns: 1179 * Returns:
1253 * A pointer to the device's statistics structure. 1180 * A pointer to the device's statistics structure.
1254 * Parms: 1181 * Parms:
1255 * dev The device structure to return the 1182 * dev The device structure to return the
1256 * stats for. 1183 * stats for.
1257 * 1184 *
1258 * This function updates the devices statistics by reading 1185 * This function updates the devices statistics by reading
1259 * the TLAN chip's onboard registers. Then it returns the 1186 * the TLAN chip's onboard registers. Then it returns the
1260 * address of the statistics structure. 1187 * address of the statistics structure.
1261 * 1188 *
1262 **************************************************************/ 1189 **************************************************************/
1263 1190
1264static struct net_device_stats *TLan_GetStats( struct net_device *dev ) 1191static struct net_device_stats *tlan_get_stats(struct net_device *dev)
1265{ 1192{
1266 TLanPrivateInfo *priv = netdev_priv(dev); 1193 struct tlan_priv *priv = netdev_priv(dev);
1267 int i; 1194 int i;
1268 1195
1269 /* Should only read stats if open ? */ 1196 /* Should only read stats if open ? */
1270 TLan_ReadAndClearStats( dev, TLAN_RECORD ); 1197 tlan_read_and_clear_stats(dev, TLAN_RECORD);
1271 1198
1272 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE: %s EOC count = %d\n", dev->name, 1199 TLAN_DBG(TLAN_DEBUG_RX, "RECEIVE: %s EOC count = %d\n", dev->name,
1273 priv->rxEocCount ); 1200 priv->rx_eoc_count);
1274 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: %s Busy count = %d\n", dev->name, 1201 TLAN_DBG(TLAN_DEBUG_TX, "TRANSMIT: %s Busy count = %d\n", dev->name,
1275 priv->txBusyCount ); 1202 priv->tx_busy_count);
1276 if ( debug & TLAN_DEBUG_GNRL ) { 1203 if (debug & TLAN_DEBUG_GNRL) {
1277 TLan_PrintDio( dev->base_addr ); 1204 tlan_print_dio(dev->base_addr);
1278 TLan_PhyPrint( dev ); 1205 tlan_phy_print(dev);
1279 } 1206 }
1280 if ( debug & TLAN_DEBUG_LIST ) { 1207 if (debug & TLAN_DEBUG_LIST) {
1281 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) 1208 for (i = 0; i < TLAN_NUM_RX_LISTS; i++)
1282 TLan_PrintList( priv->rxList + i, "RX", i ); 1209 tlan_print_list(priv->rx_list + i, "RX", i);
1283 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) 1210 for (i = 0; i < TLAN_NUM_TX_LISTS; i++)
1284 TLan_PrintList( priv->txList + i, "TX", i ); 1211 tlan_print_list(priv->tx_list + i, "TX", i);
1285 } 1212 }
1286 1213
1287 return &dev->stats; 1214 return &dev->stats;
1288 1215
1289} /* TLan_GetStats */ 1216}
1290 1217
1291 1218
1292 1219
1293 1220
1294 /*************************************************************** 1221/***************************************************************
1295 * TLan_SetMulticastList 1222 * tlan_set_multicast_list
1296 * 1223 *
1297 * Returns: 1224 * Returns:
1298 * Nothing 1225 * Nothing
1299 * Parms: 1226 * Parms:
1300 * dev The device structure to set the 1227 * dev The device structure to set the
1301 * multicast list for. 1228 * multicast list for.
1302 * 1229 *
1303 * This function sets the TLAN adaptor to various receive 1230 * This function sets the TLAN adaptor to various receive
1304 * modes. If the IFF_PROMISC flag is set, promiscuous 1231 * modes. If the IFF_PROMISC flag is set, promiscuous
1305 * mode is acitviated. Otherwise, promiscuous mode is 1232 * mode is acitviated. Otherwise, promiscuous mode is
1306 * turned off. If the IFF_ALLMULTI flag is set, then 1233 * turned off. If the IFF_ALLMULTI flag is set, then
1307 * the hash table is set to receive all group addresses. 1234 * the hash table is set to receive all group addresses.
1308 * Otherwise, the first three multicast addresses are 1235 * Otherwise, the first three multicast addresses are
1309 * stored in AREG_1-3, and the rest are selected via the 1236 * stored in AREG_1-3, and the rest are selected via the
1310 * hash table, as necessary. 1237 * hash table, as necessary.
1311 * 1238 *
1312 **************************************************************/ 1239 **************************************************************/
1313 1240
1314static void TLan_SetMulticastList( struct net_device *dev ) 1241static void tlan_set_multicast_list(struct net_device *dev)
1315{ 1242{
1316 struct netdev_hw_addr *ha; 1243 struct netdev_hw_addr *ha;
1317 u32 hash1 = 0; 1244 u32 hash1 = 0;
@@ -1320,53 +1247,56 @@ static void TLan_SetMulticastList( struct net_device *dev )
1320 u32 offset; 1247 u32 offset;
1321 u8 tmp; 1248 u8 tmp;
1322 1249
1323 if ( dev->flags & IFF_PROMISC ) { 1250 if (dev->flags & IFF_PROMISC) {
1324 tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD ); 1251 tmp = tlan_dio_read8(dev->base_addr, TLAN_NET_CMD);
1325 TLan_DioWrite8( dev->base_addr, 1252 tlan_dio_write8(dev->base_addr,
1326 TLAN_NET_CMD, tmp | TLAN_NET_CMD_CAF ); 1253 TLAN_NET_CMD, tmp | TLAN_NET_CMD_CAF);
1327 } else { 1254 } else {
1328 tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD ); 1255 tmp = tlan_dio_read8(dev->base_addr, TLAN_NET_CMD);
1329 TLan_DioWrite8( dev->base_addr, 1256 tlan_dio_write8(dev->base_addr,
1330 TLAN_NET_CMD, tmp & ~TLAN_NET_CMD_CAF ); 1257 TLAN_NET_CMD, tmp & ~TLAN_NET_CMD_CAF);
1331 if ( dev->flags & IFF_ALLMULTI ) { 1258 if (dev->flags & IFF_ALLMULTI) {
1332 for ( i = 0; i < 3; i++ ) 1259 for (i = 0; i < 3; i++)
1333 TLan_SetMac( dev, i + 1, NULL ); 1260 tlan_set_mac(dev, i + 1, NULL);
1334 TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, 0xFFFFFFFF ); 1261 tlan_dio_write32(dev->base_addr, TLAN_HASH_1,
1335 TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, 0xFFFFFFFF ); 1262 0xffffffff);
1263 tlan_dio_write32(dev->base_addr, TLAN_HASH_2,
1264 0xffffffff);
1336 } else { 1265 } else {
1337 i = 0; 1266 i = 0;
1338 netdev_for_each_mc_addr(ha, dev) { 1267 netdev_for_each_mc_addr(ha, dev) {
1339 if ( i < 3 ) { 1268 if (i < 3) {
1340 TLan_SetMac( dev, i + 1, 1269 tlan_set_mac(dev, i + 1,
1341 (char *) &ha->addr); 1270 (char *) &ha->addr);
1342 } else { 1271 } else {
1343 offset = TLan_HashFunc((u8 *)&ha->addr); 1272 offset =
1344 if ( offset < 32 ) 1273 tlan_hash_func((u8 *)&ha->addr);
1345 hash1 |= ( 1 << offset ); 1274 if (offset < 32)
1275 hash1 |= (1 << offset);
1346 else 1276 else
1347 hash2 |= ( 1 << ( offset - 32 ) ); 1277 hash2 |= (1 << (offset - 32));
1348 } 1278 }
1349 i++; 1279 i++;
1350 } 1280 }
1351 for ( ; i < 3; i++ ) 1281 for ( ; i < 3; i++)
1352 TLan_SetMac( dev, i + 1, NULL ); 1282 tlan_set_mac(dev, i + 1, NULL);
1353 TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, hash1 ); 1283 tlan_dio_write32(dev->base_addr, TLAN_HASH_1, hash1);
1354 TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, hash2 ); 1284 tlan_dio_write32(dev->base_addr, TLAN_HASH_2, hash2);
1355 } 1285 }
1356 } 1286 }
1357 1287
1358} /* TLan_SetMulticastList */ 1288}
1359 1289
1360 1290
1361 1291
1362/***************************************************************************** 1292/*****************************************************************************
1363****************************************************************************** 1293******************************************************************************
1364 1294
1365 ThunderLAN Driver Interrupt Vectors and Table 1295ThunderLAN driver interrupt vectors and table
1366 1296
1367 Please see Chap. 4, "Interrupt Handling" of the "ThunderLAN 1297please see chap. 4, "Interrupt Handling" of the "ThunderLAN
1368 Programmer's Guide" for more informations on handling interrupts 1298Programmer's Guide" for more informations on handling interrupts
1369 generated by TLAN based adapters. 1299generated by TLAN based adapters.
1370 1300
1371****************************************************************************** 1301******************************************************************************
1372*****************************************************************************/ 1302*****************************************************************************/
@@ -1374,46 +1304,48 @@ static void TLan_SetMulticastList( struct net_device *dev )
1374 1304
1375 1305
1376 1306
1377 /*************************************************************** 1307/***************************************************************
1378 * TLan_HandleTxEOF 1308 * tlan_handle_tx_eof
1379 * 1309 *
1380 * Returns: 1310 * Returns:
1381 * 1 1311 * 1
1382 * Parms: 1312 * Parms:
1383 * dev Device assigned the IRQ that was 1313 * dev Device assigned the IRQ that was
1384 * raised. 1314 * raised.
1385 * host_int The contents of the HOST_INT 1315 * host_int The contents of the HOST_INT
1386 * port. 1316 * port.
1387 * 1317 *
1388 * This function handles Tx EOF interrupts which are raised 1318 * This function handles Tx EOF interrupts which are raised
1389 * by the adapter when it has completed sending the 1319 * by the adapter when it has completed sending the
1390 * contents of a buffer. If detemines which list/buffer 1320 * contents of a buffer. If detemines which list/buffer
1391 * was completed and resets it. If the buffer was the last 1321 * was completed and resets it. If the buffer was the last
1392 * in the channel (EOC), then the function checks to see if 1322 * in the channel (EOC), then the function checks to see if
1393 * another buffer is ready to send, and if so, sends a Tx 1323 * another buffer is ready to send, and if so, sends a Tx
1394 * Go command. Finally, the driver activates/continues the 1324 * Go command. Finally, the driver activates/continues the
1395 * activity LED. 1325 * activity LED.
1396 * 1326 *
1397 **************************************************************/ 1327 **************************************************************/
1398 1328
1399static u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int ) 1329static u32 tlan_handle_tx_eof(struct net_device *dev, u16 host_int)
1400{ 1330{
1401 TLanPrivateInfo *priv = netdev_priv(dev); 1331 struct tlan_priv *priv = netdev_priv(dev);
1402 int eoc = 0; 1332 int eoc = 0;
1403 TLanList *head_list; 1333 struct tlan_list *head_list;
1404 dma_addr_t head_list_phys; 1334 dma_addr_t head_list_phys;
1405 u32 ack = 0; 1335 u32 ack = 0;
1406 u16 tmpCStat; 1336 u16 tmp_c_stat;
1407 1337
1408 TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT: Handling TX EOF (Head=%d Tail=%d)\n", 1338 TLAN_DBG(TLAN_DEBUG_TX,
1409 priv->txHead, priv->txTail ); 1339 "TRANSMIT: Handling TX EOF (Head=%d Tail=%d)\n",
1410 head_list = priv->txList + priv->txHead; 1340 priv->tx_head, priv->tx_tail);
1341 head_list = priv->tx_list + priv->tx_head;
1411 1342
1412 while (((tmpCStat = head_list->cStat ) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) { 1343 while (((tmp_c_stat = head_list->c_stat) & TLAN_CSTAT_FRM_CMP)
1413 struct sk_buff *skb = TLan_GetSKB(head_list); 1344 && (ack < 255)) {
1345 struct sk_buff *skb = tlan_get_skb(head_list);
1414 1346
1415 ack++; 1347 ack++;
1416 pci_unmap_single(priv->pciDev, head_list->buffer[0].address, 1348 pci_unmap_single(priv->pci_dev, head_list->buffer[0].address,
1417 max(skb->len, 1349 max(skb->len,
1418 (unsigned int)TLAN_MIN_FRAME_SIZE), 1350 (unsigned int)TLAN_MIN_FRAME_SIZE),
1419 PCI_DMA_TODEVICE); 1351 PCI_DMA_TODEVICE);
@@ -1421,304 +1353,313 @@ static u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
1421 head_list->buffer[8].address = 0; 1353 head_list->buffer[8].address = 0;
1422 head_list->buffer[9].address = 0; 1354 head_list->buffer[9].address = 0;
1423 1355
1424 if ( tmpCStat & TLAN_CSTAT_EOC ) 1356 if (tmp_c_stat & TLAN_CSTAT_EOC)
1425 eoc = 1; 1357 eoc = 1;
1426 1358
1427 dev->stats.tx_bytes += head_list->frameSize; 1359 dev->stats.tx_bytes += head_list->frame_size;
1428 1360
1429 head_list->cStat = TLAN_CSTAT_UNUSED; 1361 head_list->c_stat = TLAN_CSTAT_UNUSED;
1430 netif_start_queue(dev); 1362 netif_start_queue(dev);
1431 CIRC_INC( priv->txHead, TLAN_NUM_TX_LISTS ); 1363 CIRC_INC(priv->tx_head, TLAN_NUM_TX_LISTS);
1432 head_list = priv->txList + priv->txHead; 1364 head_list = priv->tx_list + priv->tx_head;
1433 } 1365 }
1434 1366
1435 if (!ack) 1367 if (!ack)
1436 printk(KERN_INFO "TLAN: Received interrupt for uncompleted TX frame.\n"); 1368 netdev_info(dev,
1437 1369 "Received interrupt for uncompleted TX frame\n");
1438 if ( eoc ) { 1370
1439 TLAN_DBG( TLAN_DEBUG_TX, 1371 if (eoc) {
1440 "TRANSMIT: Handling TX EOC (Head=%d Tail=%d)\n", 1372 TLAN_DBG(TLAN_DEBUG_TX,
1441 priv->txHead, priv->txTail ); 1373 "TRANSMIT: handling TX EOC (Head=%d Tail=%d)\n",
1442 head_list = priv->txList + priv->txHead; 1374 priv->tx_head, priv->tx_tail);
1443 head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead; 1375 head_list = priv->tx_list + priv->tx_head;
1444 if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) { 1376 head_list_phys = priv->tx_list_dma
1445 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM ); 1377 + sizeof(struct tlan_list)*priv->tx_head;
1378 if ((head_list->c_stat & TLAN_CSTAT_READY)
1379 == TLAN_CSTAT_READY) {
1380 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM);
1446 ack |= TLAN_HC_GO; 1381 ack |= TLAN_HC_GO;
1447 } else { 1382 } else {
1448 priv->txInProgress = 0; 1383 priv->tx_in_progress = 0;
1449 } 1384 }
1450 } 1385 }
1451 1386
1452 if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) { 1387 if (priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED) {
1453 TLan_DioWrite8( dev->base_addr, 1388 tlan_dio_write8(dev->base_addr,
1454 TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT ); 1389 TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT);
1455 if ( priv->timer.function == NULL ) { 1390 if (priv->timer.function == NULL) {
1456 priv->timer.function = &TLan_Timer; 1391 priv->timer.function = tlan_timer;
1457 priv->timer.data = (unsigned long) dev; 1392 priv->timer.data = (unsigned long) dev;
1458 priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY; 1393 priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
1459 priv->timerSetAt = jiffies; 1394 priv->timer_set_at = jiffies;
1460 priv->timerType = TLAN_TIMER_ACTIVITY; 1395 priv->timer_type = TLAN_TIMER_ACTIVITY;
1461 add_timer(&priv->timer); 1396 add_timer(&priv->timer);
1462 } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) { 1397 } else if (priv->timer_type == TLAN_TIMER_ACTIVITY) {
1463 priv->timerSetAt = jiffies; 1398 priv->timer_set_at = jiffies;
1464 } 1399 }
1465 } 1400 }
1466 1401
1467 return ack; 1402 return ack;
1468 1403
1469} /* TLan_HandleTxEOF */ 1404}
1470 1405
1471 1406
1472 1407
1473 1408
1474 /*************************************************************** 1409/***************************************************************
1475 * TLan_HandleStatOverflow 1410 * TLan_HandleStatOverflow
1476 * 1411 *
1477 * Returns: 1412 * Returns:
1478 * 1 1413 * 1
1479 * Parms: 1414 * Parms:
1480 * dev Device assigned the IRQ that was 1415 * dev Device assigned the IRQ that was
1481 * raised. 1416 * raised.
1482 * host_int The contents of the HOST_INT 1417 * host_int The contents of the HOST_INT
1483 * port. 1418 * port.
1484 * 1419 *
1485 * This function handles the Statistics Overflow interrupt 1420 * This function handles the Statistics Overflow interrupt
1486 * which means that one or more of the TLAN statistics 1421 * which means that one or more of the TLAN statistics
1487 * registers has reached 1/2 capacity and needs to be read. 1422 * registers has reached 1/2 capacity and needs to be read.
1488 * 1423 *
1489 **************************************************************/ 1424 **************************************************************/
1490 1425
1491static u32 TLan_HandleStatOverflow( struct net_device *dev, u16 host_int ) 1426static u32 tlan_handle_stat_overflow(struct net_device *dev, u16 host_int)
1492{ 1427{
1493 TLan_ReadAndClearStats( dev, TLAN_RECORD ); 1428 tlan_read_and_clear_stats(dev, TLAN_RECORD);
1494 1429
1495 return 1; 1430 return 1;
1496 1431
1497} /* TLan_HandleStatOverflow */ 1432}
1498 1433
1499 1434
1500 1435
1501 1436
1502 /*************************************************************** 1437/***************************************************************
1503 * TLan_HandleRxEOF 1438 * TLan_HandleRxEOF
1504 * 1439 *
1505 * Returns: 1440 * Returns:
1506 * 1 1441 * 1
1507 * Parms: 1442 * Parms:
1508 * dev Device assigned the IRQ that was 1443 * dev Device assigned the IRQ that was
1509 * raised. 1444 * raised.
1510 * host_int The contents of the HOST_INT 1445 * host_int The contents of the HOST_INT
1511 * port. 1446 * port.
1512 * 1447 *
1513 * This function handles the Rx EOF interrupt which 1448 * This function handles the Rx EOF interrupt which
1514 * indicates a frame has been received by the adapter from 1449 * indicates a frame has been received by the adapter from
1515 * the net and the frame has been transferred to memory. 1450 * the net and the frame has been transferred to memory.
1516 * The function determines the bounce buffer the frame has 1451 * The function determines the bounce buffer the frame has
1517 * been loaded into, creates a new sk_buff big enough to 1452 * been loaded into, creates a new sk_buff big enough to
1518 * hold the frame, and sends it to protocol stack. It 1453 * hold the frame, and sends it to protocol stack. It
1519 * then resets the used buffer and appends it to the end 1454 * then resets the used buffer and appends it to the end
1520 * of the list. If the frame was the last in the Rx 1455 * of the list. If the frame was the last in the Rx
1521 * channel (EOC), the function restarts the receive channel 1456 * channel (EOC), the function restarts the receive channel
1522 * by sending an Rx Go command to the adapter. Then it 1457 * by sending an Rx Go command to the adapter. Then it
1523 * activates/continues the activity LED. 1458 * activates/continues the activity LED.
1524 * 1459 *
1525 **************************************************************/ 1460 **************************************************************/
1526 1461
1527static u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int ) 1462static u32 tlan_handle_rx_eof(struct net_device *dev, u16 host_int)
1528{ 1463{
1529 TLanPrivateInfo *priv = netdev_priv(dev); 1464 struct tlan_priv *priv = netdev_priv(dev);
1530 u32 ack = 0; 1465 u32 ack = 0;
1531 int eoc = 0; 1466 int eoc = 0;
1532 TLanList *head_list; 1467 struct tlan_list *head_list;
1533 struct sk_buff *skb; 1468 struct sk_buff *skb;
1534 TLanList *tail_list; 1469 struct tlan_list *tail_list;
1535 u16 tmpCStat; 1470 u16 tmp_c_stat;
1536 dma_addr_t head_list_phys; 1471 dma_addr_t head_list_phys;
1537 1472
1538 TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE: Handling RX EOF (Head=%d Tail=%d)\n", 1473 TLAN_DBG(TLAN_DEBUG_RX, "RECEIVE: handling RX EOF (Head=%d Tail=%d)\n",
1539 priv->rxHead, priv->rxTail ); 1474 priv->rx_head, priv->rx_tail);
1540 head_list = priv->rxList + priv->rxHead; 1475 head_list = priv->rx_list + priv->rx_head;
1541 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead; 1476 head_list_phys =
1477 priv->rx_list_dma + sizeof(struct tlan_list)*priv->rx_head;
1542 1478
1543 while (((tmpCStat = head_list->cStat) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) { 1479 while (((tmp_c_stat = head_list->c_stat) & TLAN_CSTAT_FRM_CMP)
1544 dma_addr_t frameDma = head_list->buffer[0].address; 1480 && (ack < 255)) {
1545 u32 frameSize = head_list->frameSize; 1481 dma_addr_t frame_dma = head_list->buffer[0].address;
1482 u32 frame_size = head_list->frame_size;
1546 struct sk_buff *new_skb; 1483 struct sk_buff *new_skb;
1547 1484
1548 ack++; 1485 ack++;
1549 if (tmpCStat & TLAN_CSTAT_EOC) 1486 if (tmp_c_stat & TLAN_CSTAT_EOC)
1550 eoc = 1; 1487 eoc = 1;
1551 1488
1552 new_skb = netdev_alloc_skb_ip_align(dev, 1489 new_skb = netdev_alloc_skb_ip_align(dev,
1553 TLAN_MAX_FRAME_SIZE + 5); 1490 TLAN_MAX_FRAME_SIZE + 5);
1554 if ( !new_skb ) 1491 if (!new_skb)
1555 goto drop_and_reuse; 1492 goto drop_and_reuse;
1556 1493
1557 skb = TLan_GetSKB(head_list); 1494 skb = tlan_get_skb(head_list);
1558 pci_unmap_single(priv->pciDev, frameDma, 1495 pci_unmap_single(priv->pci_dev, frame_dma,
1559 TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE); 1496 TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
1560 skb_put( skb, frameSize ); 1497 skb_put(skb, frame_size);
1561 1498
1562 dev->stats.rx_bytes += frameSize; 1499 dev->stats.rx_bytes += frame_size;
1563 1500
1564 skb->protocol = eth_type_trans( skb, dev ); 1501 skb->protocol = eth_type_trans(skb, dev);
1565 netif_rx( skb ); 1502 netif_rx(skb);
1566 1503
1567 head_list->buffer[0].address = pci_map_single(priv->pciDev, 1504 head_list->buffer[0].address =
1568 new_skb->data, 1505 pci_map_single(priv->pci_dev, new_skb->data,
1569 TLAN_MAX_FRAME_SIZE, 1506 TLAN_MAX_FRAME_SIZE, PCI_DMA_FROMDEVICE);
1570 PCI_DMA_FROMDEVICE);
1571 1507
1572 TLan_StoreSKB(head_list, new_skb); 1508 tlan_store_skb(head_list, new_skb);
1573drop_and_reuse: 1509drop_and_reuse:
1574 head_list->forward = 0; 1510 head_list->forward = 0;
1575 head_list->cStat = 0; 1511 head_list->c_stat = 0;
1576 tail_list = priv->rxList + priv->rxTail; 1512 tail_list = priv->rx_list + priv->rx_tail;
1577 tail_list->forward = head_list_phys; 1513 tail_list->forward = head_list_phys;
1578 1514
1579 CIRC_INC( priv->rxHead, TLAN_NUM_RX_LISTS ); 1515 CIRC_INC(priv->rx_head, TLAN_NUM_RX_LISTS);
1580 CIRC_INC( priv->rxTail, TLAN_NUM_RX_LISTS ); 1516 CIRC_INC(priv->rx_tail, TLAN_NUM_RX_LISTS);
1581 head_list = priv->rxList + priv->rxHead; 1517 head_list = priv->rx_list + priv->rx_head;
1582 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead; 1518 head_list_phys = priv->rx_list_dma
1519 + sizeof(struct tlan_list)*priv->rx_head;
1583 } 1520 }
1584 1521
1585 if (!ack) 1522 if (!ack)
1586 printk(KERN_INFO "TLAN: Received interrupt for uncompleted RX frame.\n"); 1523 netdev_info(dev,
1587 1524 "Received interrupt for uncompleted RX frame\n");
1588 1525
1589 if ( eoc ) { 1526
1590 TLAN_DBG( TLAN_DEBUG_RX, 1527 if (eoc) {
1591 "RECEIVE: Handling RX EOC (Head=%d Tail=%d)\n", 1528 TLAN_DBG(TLAN_DEBUG_RX,
1592 priv->rxHead, priv->rxTail ); 1529 "RECEIVE: handling RX EOC (Head=%d Tail=%d)\n",
1593 head_list = priv->rxList + priv->rxHead; 1530 priv->rx_head, priv->rx_tail);
1594 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead; 1531 head_list = priv->rx_list + priv->rx_head;
1595 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM ); 1532 head_list_phys = priv->rx_list_dma
1533 + sizeof(struct tlan_list)*priv->rx_head;
1534 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM);
1596 ack |= TLAN_HC_GO | TLAN_HC_RT; 1535 ack |= TLAN_HC_GO | TLAN_HC_RT;
1597 priv->rxEocCount++; 1536 priv->rx_eoc_count++;
1598 } 1537 }
1599 1538
1600 if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) { 1539 if (priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED) {
1601 TLan_DioWrite8( dev->base_addr, 1540 tlan_dio_write8(dev->base_addr,
1602 TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT ); 1541 TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT);
1603 if ( priv->timer.function == NULL ) { 1542 if (priv->timer.function == NULL) {
1604 priv->timer.function = &TLan_Timer; 1543 priv->timer.function = tlan_timer;
1605 priv->timer.data = (unsigned long) dev; 1544 priv->timer.data = (unsigned long) dev;
1606 priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY; 1545 priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
1607 priv->timerSetAt = jiffies; 1546 priv->timer_set_at = jiffies;
1608 priv->timerType = TLAN_TIMER_ACTIVITY; 1547 priv->timer_type = TLAN_TIMER_ACTIVITY;
1609 add_timer(&priv->timer); 1548 add_timer(&priv->timer);
1610 } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) { 1549 } else if (priv->timer_type == TLAN_TIMER_ACTIVITY) {
1611 priv->timerSetAt = jiffies; 1550 priv->timer_set_at = jiffies;
1612 } 1551 }
1613 } 1552 }
1614 1553
1615 return ack; 1554 return ack;
1616 1555
1617} /* TLan_HandleRxEOF */ 1556}
1618 1557
1619 1558
1620 1559
1621 1560
1622 /*************************************************************** 1561/***************************************************************
1623 * TLan_HandleDummy 1562 * tlan_handle_dummy
1624 * 1563 *
1625 * Returns: 1564 * Returns:
1626 * 1 1565 * 1
1627 * Parms: 1566 * Parms:
1628 * dev Device assigned the IRQ that was 1567 * dev Device assigned the IRQ that was
1629 * raised. 1568 * raised.
1630 * host_int The contents of the HOST_INT 1569 * host_int The contents of the HOST_INT
1631 * port. 1570 * port.
1632 * 1571 *
1633 * This function handles the Dummy interrupt, which is 1572 * This function handles the Dummy interrupt, which is
1634 * raised whenever a test interrupt is generated by setting 1573 * raised whenever a test interrupt is generated by setting
1635 * the Req_Int bit of HOST_CMD to 1. 1574 * the Req_Int bit of HOST_CMD to 1.
1636 * 1575 *
1637 **************************************************************/ 1576 **************************************************************/
1638 1577
1639static u32 TLan_HandleDummy( struct net_device *dev, u16 host_int ) 1578static u32 tlan_handle_dummy(struct net_device *dev, u16 host_int)
1640{ 1579{
1641 printk( "TLAN: Test interrupt on %s.\n", dev->name ); 1580 netdev_info(dev, "Test interrupt\n");
1642 return 1; 1581 return 1;
1643 1582
1644} /* TLan_HandleDummy */ 1583}
1645 1584
1646 1585
1647 1586
1648 1587
1649 /*************************************************************** 1588/***************************************************************
1650 * TLan_HandleTxEOC 1589 * tlan_handle_tx_eoc
1651 * 1590 *
1652 * Returns: 1591 * Returns:
1653 * 1 1592 * 1
1654 * Parms: 1593 * Parms:
1655 * dev Device assigned the IRQ that was 1594 * dev Device assigned the IRQ that was
1656 * raised. 1595 * raised.
1657 * host_int The contents of the HOST_INT 1596 * host_int The contents of the HOST_INT
1658 * port. 1597 * port.
1659 * 1598 *
1660 * This driver is structured to determine EOC occurrences by 1599 * This driver is structured to determine EOC occurrences by
1661 * reading the CSTAT member of the list structure. Tx EOC 1600 * reading the CSTAT member of the list structure. Tx EOC
1662 * interrupts are disabled via the DIO INTDIS register. 1601 * interrupts are disabled via the DIO INTDIS register.
1663 * However, TLAN chips before revision 3.0 didn't have this 1602 * However, TLAN chips before revision 3.0 didn't have this
1664 * functionality, so process EOC events if this is the 1603 * functionality, so process EOC events if this is the
1665 * case. 1604 * case.
1666 * 1605 *
1667 **************************************************************/ 1606 **************************************************************/
1668 1607
1669static u32 TLan_HandleTxEOC( struct net_device *dev, u16 host_int ) 1608static u32 tlan_handle_tx_eoc(struct net_device *dev, u16 host_int)
1670{ 1609{
1671 TLanPrivateInfo *priv = netdev_priv(dev); 1610 struct tlan_priv *priv = netdev_priv(dev);
1672 TLanList *head_list; 1611 struct tlan_list *head_list;
1673 dma_addr_t head_list_phys; 1612 dma_addr_t head_list_phys;
1674 u32 ack = 1; 1613 u32 ack = 1;
1675 1614
1676 host_int = 0; 1615 host_int = 0;
1677 if ( priv->tlanRev < 0x30 ) { 1616 if (priv->tlan_rev < 0x30) {
1678 TLAN_DBG( TLAN_DEBUG_TX, 1617 TLAN_DBG(TLAN_DEBUG_TX,
1679 "TRANSMIT: Handling TX EOC (Head=%d Tail=%d) -- IRQ\n", 1618 "TRANSMIT: handling TX EOC (Head=%d Tail=%d) -- IRQ\n",
1680 priv->txHead, priv->txTail ); 1619 priv->tx_head, priv->tx_tail);
1681 head_list = priv->txList + priv->txHead; 1620 head_list = priv->tx_list + priv->tx_head;
1682 head_list_phys = priv->txListDMA + sizeof(TLanList) * priv->txHead; 1621 head_list_phys = priv->tx_list_dma
1683 if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) { 1622 + sizeof(struct tlan_list)*priv->tx_head;
1623 if ((head_list->c_stat & TLAN_CSTAT_READY)
1624 == TLAN_CSTAT_READY) {
1684 netif_stop_queue(dev); 1625 netif_stop_queue(dev);
1685 outl( head_list_phys, dev->base_addr + TLAN_CH_PARM ); 1626 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM);
1686 ack |= TLAN_HC_GO; 1627 ack |= TLAN_HC_GO;
1687 } else { 1628 } else {
1688 priv->txInProgress = 0; 1629 priv->tx_in_progress = 0;
1689 } 1630 }
1690 } 1631 }
1691 1632
1692 return ack; 1633 return ack;
1693 1634
1694} /* TLan_HandleTxEOC */ 1635}
1695 1636
1696 1637
1697 1638
1698 1639
1699 /*************************************************************** 1640/***************************************************************
1700 * TLan_HandleStatusCheck 1641 * tlan_handle_status_check
1701 * 1642 *
1702 * Returns: 1643 * Returns:
1703 * 0 if Adapter check, 1 if Network Status check. 1644 * 0 if Adapter check, 1 if Network Status check.
1704 * Parms: 1645 * Parms:
1705 * dev Device assigned the IRQ that was 1646 * dev Device assigned the IRQ that was
1706 * raised. 1647 * raised.
1707 * host_int The contents of the HOST_INT 1648 * host_int The contents of the HOST_INT
1708 * port. 1649 * port.
1709 * 1650 *
1710 * This function handles Adapter Check/Network Status 1651 * This function handles Adapter Check/Network Status
1711 * interrupts generated by the adapter. It checks the 1652 * interrupts generated by the adapter. It checks the
1712 * vector in the HOST_INT register to determine if it is 1653 * vector in the HOST_INT register to determine if it is
1713 * an Adapter Check interrupt. If so, it resets the 1654 * an Adapter Check interrupt. If so, it resets the
1714 * adapter. Otherwise it clears the status registers 1655 * adapter. Otherwise it clears the status registers
1715 * and services the PHY. 1656 * and services the PHY.
1716 * 1657 *
1717 **************************************************************/ 1658 **************************************************************/
1718 1659
1719static u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int ) 1660static u32 tlan_handle_status_check(struct net_device *dev, u16 host_int)
1720{ 1661{
1721 TLanPrivateInfo *priv = netdev_priv(dev); 1662 struct tlan_priv *priv = netdev_priv(dev);
1722 u32 ack; 1663 u32 ack;
1723 u32 error; 1664 u32 error;
1724 u8 net_sts; 1665 u8 net_sts;
@@ -1727,92 +1668,94 @@ static u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int )
1727 u16 tlphy_sts; 1668 u16 tlphy_sts;
1728 1669
1729 ack = 1; 1670 ack = 1;
1730 if ( host_int & TLAN_HI_IV_MASK ) { 1671 if (host_int & TLAN_HI_IV_MASK) {
1731 netif_stop_queue( dev ); 1672 netif_stop_queue(dev);
1732 error = inl( dev->base_addr + TLAN_CH_PARM ); 1673 error = inl(dev->base_addr + TLAN_CH_PARM);
1733 printk( "TLAN: %s: Adaptor Error = 0x%x\n", dev->name, error ); 1674 netdev_info(dev, "Adaptor Error = 0x%x\n", error);
1734 TLan_ReadAndClearStats( dev, TLAN_RECORD ); 1675 tlan_read_and_clear_stats(dev, TLAN_RECORD);
1735 outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD ); 1676 outl(TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD);
1736 1677
1737 schedule_work(&priv->tlan_tqueue); 1678 schedule_work(&priv->tlan_tqueue);
1738 1679
1739 netif_wake_queue(dev); 1680 netif_wake_queue(dev);
1740 ack = 0; 1681 ack = 0;
1741 } else { 1682 } else {
1742 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Status Check\n", dev->name ); 1683 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Status Check\n", dev->name);
1743 phy = priv->phy[priv->phyNum]; 1684 phy = priv->phy[priv->phy_num];
1744 1685
1745 net_sts = TLan_DioRead8( dev->base_addr, TLAN_NET_STS ); 1686 net_sts = tlan_dio_read8(dev->base_addr, TLAN_NET_STS);
1746 if ( net_sts ) { 1687 if (net_sts) {
1747 TLan_DioWrite8( dev->base_addr, TLAN_NET_STS, net_sts ); 1688 tlan_dio_write8(dev->base_addr, TLAN_NET_STS, net_sts);
1748 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Net_Sts = %x\n", 1689 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Net_Sts = %x\n",
1749 dev->name, (unsigned) net_sts ); 1690 dev->name, (unsigned) net_sts);
1750 } 1691 }
1751 if ( ( net_sts & TLAN_NET_STS_MIRQ ) && ( priv->phyNum == 0 ) ) { 1692 if ((net_sts & TLAN_NET_STS_MIRQ) && (priv->phy_num == 0)) {
1752 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_STS, &tlphy_sts ); 1693 tlan_mii_read_reg(dev, phy, TLAN_TLPHY_STS, &tlphy_sts);
1753 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl ); 1694 tlan_mii_read_reg(dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl);
1754 if ( ! ( tlphy_sts & TLAN_TS_POLOK ) && 1695 if (!(tlphy_sts & TLAN_TS_POLOK) &&
1755 ! ( tlphy_ctl & TLAN_TC_SWAPOL ) ) { 1696 !(tlphy_ctl & TLAN_TC_SWAPOL)) {
1756 tlphy_ctl |= TLAN_TC_SWAPOL; 1697 tlphy_ctl |= TLAN_TC_SWAPOL;
1757 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl); 1698 tlan_mii_write_reg(dev, phy, TLAN_TLPHY_CTL,
1758 } else if ( ( tlphy_sts & TLAN_TS_POLOK ) && 1699 tlphy_ctl);
1759 ( tlphy_ctl & TLAN_TC_SWAPOL ) ) { 1700 } else if ((tlphy_sts & TLAN_TS_POLOK) &&
1760 tlphy_ctl &= ~TLAN_TC_SWAPOL; 1701 (tlphy_ctl & TLAN_TC_SWAPOL)) {
1761 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl); 1702 tlphy_ctl &= ~TLAN_TC_SWAPOL;
1762 } 1703 tlan_mii_write_reg(dev, phy, TLAN_TLPHY_CTL,
1763 1704 tlphy_ctl);
1764 if (debug) {
1765 TLan_PhyPrint( dev );
1766 } 1705 }
1706
1707 if (debug)
1708 tlan_phy_print(dev);
1767 } 1709 }
1768 } 1710 }
1769 1711
1770 return ack; 1712 return ack;
1771 1713
1772} /* TLan_HandleStatusCheck */ 1714}
1773 1715
1774 1716
1775 1717
1776 1718
1777 /*************************************************************** 1719/***************************************************************
1778 * TLan_HandleRxEOC 1720 * tlan_handle_rx_eoc
1779 * 1721 *
1780 * Returns: 1722 * Returns:
1781 * 1 1723 * 1
1782 * Parms: 1724 * Parms:
1783 * dev Device assigned the IRQ that was 1725 * dev Device assigned the IRQ that was
1784 * raised. 1726 * raised.
1785 * host_int The contents of the HOST_INT 1727 * host_int The contents of the HOST_INT
1786 * port. 1728 * port.
1787 * 1729 *
1788 * This driver is structured to determine EOC occurrences by 1730 * This driver is structured to determine EOC occurrences by
1789 * reading the CSTAT member of the list structure. Rx EOC 1731 * reading the CSTAT member of the list structure. Rx EOC
1790 * interrupts are disabled via the DIO INTDIS register. 1732 * interrupts are disabled via the DIO INTDIS register.
1791 * However, TLAN chips before revision 3.0 didn't have this 1733 * However, TLAN chips before revision 3.0 didn't have this
1792 * CSTAT member or a INTDIS register, so if this chip is 1734 * CSTAT member or a INTDIS register, so if this chip is
1793 * pre-3.0, process EOC interrupts normally. 1735 * pre-3.0, process EOC interrupts normally.
1794 * 1736 *
1795 **************************************************************/ 1737 **************************************************************/
1796 1738
1797static u32 TLan_HandleRxEOC( struct net_device *dev, u16 host_int ) 1739static u32 tlan_handle_rx_eoc(struct net_device *dev, u16 host_int)
1798{ 1740{
1799 TLanPrivateInfo *priv = netdev_priv(dev); 1741 struct tlan_priv *priv = netdev_priv(dev);
1800 dma_addr_t head_list_phys; 1742 dma_addr_t head_list_phys;
1801 u32 ack = 1; 1743 u32 ack = 1;
1802 1744
1803 if ( priv->tlanRev < 0x30 ) { 1745 if (priv->tlan_rev < 0x30) {
1804 TLAN_DBG( TLAN_DEBUG_RX, 1746 TLAN_DBG(TLAN_DEBUG_RX,
1805 "RECEIVE: Handling RX EOC (Head=%d Tail=%d) -- IRQ\n", 1747 "RECEIVE: Handling RX EOC (head=%d tail=%d) -- IRQ\n",
1806 priv->rxHead, priv->rxTail ); 1748 priv->rx_head, priv->rx_tail);
1807 head_list_phys = priv->rxListDMA + sizeof(TLanList) * priv->rxHead; 1749 head_list_phys = priv->rx_list_dma
1808 outl( head_list_phys, dev->base_addr + TLAN_CH_PARM ); 1750 + sizeof(struct tlan_list)*priv->rx_head;
1751 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM);
1809 ack |= TLAN_HC_GO | TLAN_HC_RT; 1752 ack |= TLAN_HC_GO | TLAN_HC_RT;
1810 priv->rxEocCount++; 1753 priv->rx_eoc_count++;
1811 } 1754 }
1812 1755
1813 return ack; 1756 return ack;
1814 1757
1815} /* TLan_HandleRxEOC */ 1758}
1816 1759
1817 1760
1818 1761
@@ -1820,98 +1763,98 @@ static u32 TLan_HandleRxEOC( struct net_device *dev, u16 host_int )
1820/***************************************************************************** 1763/*****************************************************************************
1821****************************************************************************** 1764******************************************************************************
1822 1765
1823 ThunderLAN Driver Timer Function 1766ThunderLAN driver timer function
1824 1767
1825****************************************************************************** 1768******************************************************************************
1826*****************************************************************************/ 1769*****************************************************************************/
1827 1770
1828 1771
1829 /*************************************************************** 1772/***************************************************************
1830 * TLan_Timer 1773 * tlan_timer
1831 * 1774 *
1832 * Returns: 1775 * Returns:
1833 * Nothing 1776 * Nothing
1834 * Parms: 1777 * Parms:
1835 * data A value given to add timer when 1778 * data A value given to add timer when
1836 * add_timer was called. 1779 * add_timer was called.
1837 * 1780 *
1838 * This function handles timed functionality for the 1781 * This function handles timed functionality for the
1839 * TLAN driver. The two current timer uses are for 1782 * TLAN driver. The two current timer uses are for
1840 * delaying for autonegotionation and driving the ACT LED. 1783 * delaying for autonegotionation and driving the ACT LED.
1841 * - Autonegotiation requires being allowed about 1784 * - Autonegotiation requires being allowed about
1842 * 2 1/2 seconds before attempting to transmit a 1785 * 2 1/2 seconds before attempting to transmit a
1843 * packet. It would be a very bad thing to hang 1786 * packet. It would be a very bad thing to hang
1844 * the kernel this long, so the driver doesn't 1787 * the kernel this long, so the driver doesn't
1845 * allow transmission 'til after this time, for 1788 * allow transmission 'til after this time, for
1846 * certain PHYs. It would be much nicer if all 1789 * certain PHYs. It would be much nicer if all
1847 * PHYs were interrupt-capable like the internal 1790 * PHYs were interrupt-capable like the internal
1848 * PHY. 1791 * PHY.
1849 * - The ACT LED, which shows adapter activity, is 1792 * - The ACT LED, which shows adapter activity, is
1850 * driven by the driver, and so must be left on 1793 * driven by the driver, and so must be left on
1851 * for a short period to power up the LED so it 1794 * for a short period to power up the LED so it
1852 * can be seen. This delay can be changed by 1795 * can be seen. This delay can be changed by
1853 * changing the TLAN_TIMER_ACT_DELAY in tlan.h, 1796 * changing the TLAN_TIMER_ACT_DELAY in tlan.h,
1854 * if desired. 100 ms produces a slightly 1797 * if desired. 100 ms produces a slightly
1855 * sluggish response. 1798 * sluggish response.
1856 * 1799 *
1857 **************************************************************/ 1800 **************************************************************/
1858 1801
1859static void TLan_Timer( unsigned long data ) 1802static void tlan_timer(unsigned long data)
1860{ 1803{
1861 struct net_device *dev = (struct net_device *) data; 1804 struct net_device *dev = (struct net_device *) data;
1862 TLanPrivateInfo *priv = netdev_priv(dev); 1805 struct tlan_priv *priv = netdev_priv(dev);
1863 u32 elapsed; 1806 u32 elapsed;
1864 unsigned long flags = 0; 1807 unsigned long flags = 0;
1865 1808
1866 priv->timer.function = NULL; 1809 priv->timer.function = NULL;
1867 1810
1868 switch ( priv->timerType ) { 1811 switch (priv->timer_type) {
1869#ifdef MONITOR 1812#ifdef MONITOR
1870 case TLAN_TIMER_LINK_BEAT: 1813 case TLAN_TIMER_LINK_BEAT:
1871 TLan_PhyMonitor( dev ); 1814 tlan_phy_monitor(dev);
1872 break; 1815 break;
1873#endif 1816#endif
1874 case TLAN_TIMER_PHY_PDOWN: 1817 case TLAN_TIMER_PHY_PDOWN:
1875 TLan_PhyPowerDown( dev ); 1818 tlan_phy_power_down(dev);
1876 break; 1819 break;
1877 case TLAN_TIMER_PHY_PUP: 1820 case TLAN_TIMER_PHY_PUP:
1878 TLan_PhyPowerUp( dev ); 1821 tlan_phy_power_up(dev);
1879 break; 1822 break;
1880 case TLAN_TIMER_PHY_RESET: 1823 case TLAN_TIMER_PHY_RESET:
1881 TLan_PhyReset( dev ); 1824 tlan_phy_reset(dev);
1882 break; 1825 break;
1883 case TLAN_TIMER_PHY_START_LINK: 1826 case TLAN_TIMER_PHY_START_LINK:
1884 TLan_PhyStartLink( dev ); 1827 tlan_phy_start_link(dev);
1885 break; 1828 break;
1886 case TLAN_TIMER_PHY_FINISH_AN: 1829 case TLAN_TIMER_PHY_FINISH_AN:
1887 TLan_PhyFinishAutoNeg( dev ); 1830 tlan_phy_finish_auto_neg(dev);
1888 break; 1831 break;
1889 case TLAN_TIMER_FINISH_RESET: 1832 case TLAN_TIMER_FINISH_RESET:
1890 TLan_FinishReset( dev ); 1833 tlan_finish_reset(dev);
1891 break; 1834 break;
1892 case TLAN_TIMER_ACTIVITY: 1835 case TLAN_TIMER_ACTIVITY:
1893 spin_lock_irqsave(&priv->lock, flags); 1836 spin_lock_irqsave(&priv->lock, flags);
1894 if ( priv->timer.function == NULL ) { 1837 if (priv->timer.function == NULL) {
1895 elapsed = jiffies - priv->timerSetAt; 1838 elapsed = jiffies - priv->timer_set_at;
1896 if ( elapsed >= TLAN_TIMER_ACT_DELAY ) { 1839 if (elapsed >= TLAN_TIMER_ACT_DELAY) {
1897 TLan_DioWrite8( dev->base_addr, 1840 tlan_dio_write8(dev->base_addr,
1898 TLAN_LED_REG, TLAN_LED_LINK ); 1841 TLAN_LED_REG, TLAN_LED_LINK);
1899 } else { 1842 } else {
1900 priv->timer.function = &TLan_Timer; 1843 priv->timer.function = tlan_timer;
1901 priv->timer.expires = priv->timerSetAt 1844 priv->timer.expires = priv->timer_set_at
1902 + TLAN_TIMER_ACT_DELAY; 1845 + TLAN_TIMER_ACT_DELAY;
1903 spin_unlock_irqrestore(&priv->lock, flags); 1846 spin_unlock_irqrestore(&priv->lock, flags);
1904 add_timer( &priv->timer ); 1847 add_timer(&priv->timer);
1905 break; 1848 break;
1906 }
1907 } 1849 }
1908 spin_unlock_irqrestore(&priv->lock, flags); 1850 }
1909 break; 1851 spin_unlock_irqrestore(&priv->lock, flags);
1910 default: 1852 break;
1911 break; 1853 default:
1854 break;
1912 } 1855 }
1913 1856
1914} /* TLan_Timer */ 1857}
1915 1858
1916 1859
1917 1860
@@ -1919,39 +1862,39 @@ static void TLan_Timer( unsigned long data )
1919/***************************************************************************** 1862/*****************************************************************************
1920****************************************************************************** 1863******************************************************************************
1921 1864
1922 ThunderLAN Driver Adapter Related Routines 1865ThunderLAN driver adapter related routines
1923 1866
1924****************************************************************************** 1867******************************************************************************
1925*****************************************************************************/ 1868*****************************************************************************/
1926 1869
1927 1870
1928 /*************************************************************** 1871/***************************************************************
1929 * TLan_ResetLists 1872 * tlan_reset_lists
1930 * 1873 *
1931 * Returns: 1874 * Returns:
1932 * Nothing 1875 * Nothing
1933 * Parms: 1876 * Parms:
1934 * dev The device structure with the list 1877 * dev The device structure with the list
1935 * stuctures to be reset. 1878 * stuctures to be reset.
1936 * 1879 *
1937 * This routine sets the variables associated with managing 1880 * This routine sets the variables associated with managing
1938 * the TLAN lists to their initial values. 1881 * the TLAN lists to their initial values.
1939 * 1882 *
1940 **************************************************************/ 1883 **************************************************************/
1941 1884
1942static void TLan_ResetLists( struct net_device *dev ) 1885static void tlan_reset_lists(struct net_device *dev)
1943{ 1886{
1944 TLanPrivateInfo *priv = netdev_priv(dev); 1887 struct tlan_priv *priv = netdev_priv(dev);
1945 int i; 1888 int i;
1946 TLanList *list; 1889 struct tlan_list *list;
1947 dma_addr_t list_phys; 1890 dma_addr_t list_phys;
1948 struct sk_buff *skb; 1891 struct sk_buff *skb;
1949 1892
1950 priv->txHead = 0; 1893 priv->tx_head = 0;
1951 priv->txTail = 0; 1894 priv->tx_tail = 0;
1952 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) { 1895 for (i = 0; i < TLAN_NUM_TX_LISTS; i++) {
1953 list = priv->txList + i; 1896 list = priv->tx_list + i;
1954 list->cStat = TLAN_CSTAT_UNUSED; 1897 list->c_stat = TLAN_CSTAT_UNUSED;
1955 list->buffer[0].address = 0; 1898 list->buffer[0].address = 0;
1956 list->buffer[2].count = 0; 1899 list->buffer[2].count = 0;
1957 list->buffer[2].address = 0; 1900 list->buffer[2].address = 0;
@@ -1959,169 +1902,169 @@ static void TLan_ResetLists( struct net_device *dev )
1959 list->buffer[9].address = 0; 1902 list->buffer[9].address = 0;
1960 } 1903 }
1961 1904
1962 priv->rxHead = 0; 1905 priv->rx_head = 0;
1963 priv->rxTail = TLAN_NUM_RX_LISTS - 1; 1906 priv->rx_tail = TLAN_NUM_RX_LISTS - 1;
1964 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) { 1907 for (i = 0; i < TLAN_NUM_RX_LISTS; i++) {
1965 list = priv->rxList + i; 1908 list = priv->rx_list + i;
1966 list_phys = priv->rxListDMA + sizeof(TLanList) * i; 1909 list_phys = priv->rx_list_dma + sizeof(struct tlan_list)*i;
1967 list->cStat = TLAN_CSTAT_READY; 1910 list->c_stat = TLAN_CSTAT_READY;
1968 list->frameSize = TLAN_MAX_FRAME_SIZE; 1911 list->frame_size = TLAN_MAX_FRAME_SIZE;
1969 list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER; 1912 list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER;
1970 skb = netdev_alloc_skb_ip_align(dev, TLAN_MAX_FRAME_SIZE + 5); 1913 skb = netdev_alloc_skb_ip_align(dev, TLAN_MAX_FRAME_SIZE + 5);
1971 if ( !skb ) { 1914 if (!skb) {
1972 pr_err("TLAN: out of memory for received data.\n" ); 1915 netdev_err(dev, "Out of memory for received data\n");
1973 break; 1916 break;
1974 } 1917 }
1975 1918
1976 list->buffer[0].address = pci_map_single(priv->pciDev, 1919 list->buffer[0].address = pci_map_single(priv->pci_dev,
1977 skb->data, 1920 skb->data,
1978 TLAN_MAX_FRAME_SIZE, 1921 TLAN_MAX_FRAME_SIZE,
1979 PCI_DMA_FROMDEVICE); 1922 PCI_DMA_FROMDEVICE);
1980 TLan_StoreSKB(list, skb); 1923 tlan_store_skb(list, skb);
1981 list->buffer[1].count = 0; 1924 list->buffer[1].count = 0;
1982 list->buffer[1].address = 0; 1925 list->buffer[1].address = 0;
1983 list->forward = list_phys + sizeof(TLanList); 1926 list->forward = list_phys + sizeof(struct tlan_list);
1984 } 1927 }
1985 1928
1986 /* in case ran out of memory early, clear bits */ 1929 /* in case ran out of memory early, clear bits */
1987 while (i < TLAN_NUM_RX_LISTS) { 1930 while (i < TLAN_NUM_RX_LISTS) {
1988 TLan_StoreSKB(priv->rxList + i, NULL); 1931 tlan_store_skb(priv->rx_list + i, NULL);
1989 ++i; 1932 ++i;
1990 } 1933 }
1991 list->forward = 0; 1934 list->forward = 0;
1992 1935
1993} /* TLan_ResetLists */ 1936}
1994 1937
1995 1938
1996static void TLan_FreeLists( struct net_device *dev ) 1939static void tlan_free_lists(struct net_device *dev)
1997{ 1940{
1998 TLanPrivateInfo *priv = netdev_priv(dev); 1941 struct tlan_priv *priv = netdev_priv(dev);
1999 int i; 1942 int i;
2000 TLanList *list; 1943 struct tlan_list *list;
2001 struct sk_buff *skb; 1944 struct sk_buff *skb;
2002 1945
2003 for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) { 1946 for (i = 0; i < TLAN_NUM_TX_LISTS; i++) {
2004 list = priv->txList + i; 1947 list = priv->tx_list + i;
2005 skb = TLan_GetSKB(list); 1948 skb = tlan_get_skb(list);
2006 if ( skb ) { 1949 if (skb) {
2007 pci_unmap_single( 1950 pci_unmap_single(
2008 priv->pciDev, 1951 priv->pci_dev,
2009 list->buffer[0].address, 1952 list->buffer[0].address,
2010 max(skb->len, 1953 max(skb->len,
2011 (unsigned int)TLAN_MIN_FRAME_SIZE), 1954 (unsigned int)TLAN_MIN_FRAME_SIZE),
2012 PCI_DMA_TODEVICE); 1955 PCI_DMA_TODEVICE);
2013 dev_kfree_skb_any( skb ); 1956 dev_kfree_skb_any(skb);
2014 list->buffer[8].address = 0; 1957 list->buffer[8].address = 0;
2015 list->buffer[9].address = 0; 1958 list->buffer[9].address = 0;
2016 } 1959 }
2017 } 1960 }
2018 1961
2019 for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) { 1962 for (i = 0; i < TLAN_NUM_RX_LISTS; i++) {
2020 list = priv->rxList + i; 1963 list = priv->rx_list + i;
2021 skb = TLan_GetSKB(list); 1964 skb = tlan_get_skb(list);
2022 if ( skb ) { 1965 if (skb) {
2023 pci_unmap_single(priv->pciDev, 1966 pci_unmap_single(priv->pci_dev,
2024 list->buffer[0].address, 1967 list->buffer[0].address,
2025 TLAN_MAX_FRAME_SIZE, 1968 TLAN_MAX_FRAME_SIZE,
2026 PCI_DMA_FROMDEVICE); 1969 PCI_DMA_FROMDEVICE);
2027 dev_kfree_skb_any( skb ); 1970 dev_kfree_skb_any(skb);
2028 list->buffer[8].address = 0; 1971 list->buffer[8].address = 0;
2029 list->buffer[9].address = 0; 1972 list->buffer[9].address = 0;
2030 } 1973 }
2031 } 1974 }
2032} /* TLan_FreeLists */ 1975}
2033 1976
2034 1977
2035 1978
2036 1979
2037 /*************************************************************** 1980/***************************************************************
2038 * TLan_PrintDio 1981 * tlan_print_dio
2039 * 1982 *
2040 * Returns: 1983 * Returns:
2041 * Nothing 1984 * Nothing
2042 * Parms: 1985 * Parms:
2043 * io_base Base IO port of the device of 1986 * io_base Base IO port of the device of
2044 * which to print DIO registers. 1987 * which to print DIO registers.
2045 * 1988 *
2046 * This function prints out all the internal (DIO) 1989 * This function prints out all the internal (DIO)
2047 * registers of a TLAN chip. 1990 * registers of a TLAN chip.
2048 * 1991 *
2049 **************************************************************/ 1992 **************************************************************/
2050 1993
2051static void TLan_PrintDio( u16 io_base ) 1994static void tlan_print_dio(u16 io_base)
2052{ 1995{
2053 u32 data0, data1; 1996 u32 data0, data1;
2054 int i; 1997 int i;
2055 1998
2056 printk( "TLAN: Contents of internal registers for io base 0x%04hx.\n", 1999 pr_info("Contents of internal registers for io base 0x%04hx\n",
2057 io_base ); 2000 io_base);
2058 printk( "TLAN: Off. +0 +4\n" ); 2001 pr_info("Off. +0 +4\n");
2059 for ( i = 0; i < 0x4C; i+= 8 ) { 2002 for (i = 0; i < 0x4C; i += 8) {
2060 data0 = TLan_DioRead32( io_base, i ); 2003 data0 = tlan_dio_read32(io_base, i);
2061 data1 = TLan_DioRead32( io_base, i + 0x4 ); 2004 data1 = tlan_dio_read32(io_base, i + 0x4);
2062 printk( "TLAN: 0x%02x 0x%08x 0x%08x\n", i, data0, data1 ); 2005 pr_info("0x%02x 0x%08x 0x%08x\n", i, data0, data1);
2063 } 2006 }
2064 2007
2065} /* TLan_PrintDio */ 2008}
2066 2009
2067 2010
2068 2011
2069 2012
2070 /*************************************************************** 2013/***************************************************************
2071 * TLan_PrintList 2014 * TLan_PrintList
2072 * 2015 *
2073 * Returns: 2016 * Returns:
2074 * Nothing 2017 * Nothing
2075 * Parms: 2018 * Parms:
2076 * list A pointer to the TLanList structure to 2019 * list A pointer to the struct tlan_list structure to
2077 * be printed. 2020 * be printed.
2078 * type A string to designate type of list, 2021 * type A string to designate type of list,
2079 * "Rx" or "Tx". 2022 * "Rx" or "Tx".
2080 * num The index of the list. 2023 * num The index of the list.
2081 * 2024 *
2082 * This function prints out the contents of the list 2025 * This function prints out the contents of the list
2083 * pointed to by the list parameter. 2026 * pointed to by the list parameter.
2084 * 2027 *
2085 **************************************************************/ 2028 **************************************************************/
2086 2029
2087static void TLan_PrintList( TLanList *list, char *type, int num) 2030static void tlan_print_list(struct tlan_list *list, char *type, int num)
2088{ 2031{
2089 int i; 2032 int i;
2090 2033
2091 printk( "TLAN: %s List %d at %p\n", type, num, list ); 2034 pr_info("%s List %d at %p\n", type, num, list);
2092 printk( "TLAN: Forward = 0x%08x\n", list->forward ); 2035 pr_info(" Forward = 0x%08x\n", list->forward);
2093 printk( "TLAN: CSTAT = 0x%04hx\n", list->cStat ); 2036 pr_info(" CSTAT = 0x%04hx\n", list->c_stat);
2094 printk( "TLAN: Frame Size = 0x%04hx\n", list->frameSize ); 2037 pr_info(" Frame Size = 0x%04hx\n", list->frame_size);
2095 /* for ( i = 0; i < 10; i++ ) { */ 2038 /* for (i = 0; i < 10; i++) { */
2096 for ( i = 0; i < 2; i++ ) { 2039 for (i = 0; i < 2; i++) {
2097 printk( "TLAN: Buffer[%d].count, addr = 0x%08x, 0x%08x\n", 2040 pr_info(" Buffer[%d].count, addr = 0x%08x, 0x%08x\n",
2098 i, list->buffer[i].count, list->buffer[i].address ); 2041 i, list->buffer[i].count, list->buffer[i].address);
2099 } 2042 }
2100 2043
2101} /* TLan_PrintList */ 2044}
2102 2045
2103 2046
2104 2047
2105 2048
2106 /*************************************************************** 2049/***************************************************************
2107 * TLan_ReadAndClearStats 2050 * tlan_read_and_clear_stats
2108 * 2051 *
2109 * Returns: 2052 * Returns:
2110 * Nothing 2053 * Nothing
2111 * Parms: 2054 * Parms:
2112 * dev Pointer to device structure of adapter 2055 * dev Pointer to device structure of adapter
2113 * to which to read stats. 2056 * to which to read stats.
2114 * record Flag indicating whether to add 2057 * record Flag indicating whether to add
2115 * 2058 *
2116 * This functions reads all the internal status registers 2059 * This functions reads all the internal status registers
2117 * of the TLAN chip, which clears them as a side effect. 2060 * of the TLAN chip, which clears them as a side effect.
2118 * It then either adds the values to the device's status 2061 * It then either adds the values to the device's status
2119 * struct, or discards them, depending on whether record 2062 * struct, or discards them, depending on whether record
2120 * is TLAN_RECORD (!=0) or TLAN_IGNORE (==0). 2063 * is TLAN_RECORD (!=0) or TLAN_IGNORE (==0).
2121 * 2064 *
2122 **************************************************************/ 2065 **************************************************************/
2123 2066
2124static void TLan_ReadAndClearStats( struct net_device *dev, int record ) 2067static void tlan_read_and_clear_stats(struct net_device *dev, int record)
2125{ 2068{
2126 u32 tx_good, tx_under; 2069 u32 tx_good, tx_under;
2127 u32 rx_good, rx_over; 2070 u32 rx_good, rx_over;
@@ -2129,41 +2072,42 @@ static void TLan_ReadAndClearStats( struct net_device *dev, int record )
2129 u32 multi_col, single_col; 2072 u32 multi_col, single_col;
2130 u32 excess_col, late_col, loss; 2073 u32 excess_col, late_col, loss;
2131 2074
2132 outw( TLAN_GOOD_TX_FRMS, dev->base_addr + TLAN_DIO_ADR ); 2075 outw(TLAN_GOOD_TX_FRMS, dev->base_addr + TLAN_DIO_ADR);
2133 tx_good = inb( dev->base_addr + TLAN_DIO_DATA ); 2076 tx_good = inb(dev->base_addr + TLAN_DIO_DATA);
2134 tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8; 2077 tx_good += inb(dev->base_addr + TLAN_DIO_DATA + 1) << 8;
2135 tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16; 2078 tx_good += inb(dev->base_addr + TLAN_DIO_DATA + 2) << 16;
2136 tx_under = inb( dev->base_addr + TLAN_DIO_DATA + 3 ); 2079 tx_under = inb(dev->base_addr + TLAN_DIO_DATA + 3);
2137 2080
2138 outw( TLAN_GOOD_RX_FRMS, dev->base_addr + TLAN_DIO_ADR ); 2081 outw(TLAN_GOOD_RX_FRMS, dev->base_addr + TLAN_DIO_ADR);
2139 rx_good = inb( dev->base_addr + TLAN_DIO_DATA ); 2082 rx_good = inb(dev->base_addr + TLAN_DIO_DATA);
2140 rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8; 2083 rx_good += inb(dev->base_addr + TLAN_DIO_DATA + 1) << 8;
2141 rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16; 2084 rx_good += inb(dev->base_addr + TLAN_DIO_DATA + 2) << 16;
2142 rx_over = inb( dev->base_addr + TLAN_DIO_DATA + 3 ); 2085 rx_over = inb(dev->base_addr + TLAN_DIO_DATA + 3);
2143 2086
2144 outw( TLAN_DEFERRED_TX, dev->base_addr + TLAN_DIO_ADR ); 2087 outw(TLAN_DEFERRED_TX, dev->base_addr + TLAN_DIO_ADR);
2145 def_tx = inb( dev->base_addr + TLAN_DIO_DATA ); 2088 def_tx = inb(dev->base_addr + TLAN_DIO_DATA);
2146 def_tx += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8; 2089 def_tx += inb(dev->base_addr + TLAN_DIO_DATA + 1) << 8;
2147 crc = inb( dev->base_addr + TLAN_DIO_DATA + 2 ); 2090 crc = inb(dev->base_addr + TLAN_DIO_DATA + 2);
2148 code = inb( dev->base_addr + TLAN_DIO_DATA + 3 ); 2091 code = inb(dev->base_addr + TLAN_DIO_DATA + 3);
2149 2092
2150 outw( TLAN_MULTICOL_FRMS, dev->base_addr + TLAN_DIO_ADR ); 2093 outw(TLAN_MULTICOL_FRMS, dev->base_addr + TLAN_DIO_ADR);
2151 multi_col = inb( dev->base_addr + TLAN_DIO_DATA ); 2094 multi_col = inb(dev->base_addr + TLAN_DIO_DATA);
2152 multi_col += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8; 2095 multi_col += inb(dev->base_addr + TLAN_DIO_DATA + 1) << 8;
2153 single_col = inb( dev->base_addr + TLAN_DIO_DATA + 2 ); 2096 single_col = inb(dev->base_addr + TLAN_DIO_DATA + 2);
2154 single_col += inb( dev->base_addr + TLAN_DIO_DATA + 3 ) << 8; 2097 single_col += inb(dev->base_addr + TLAN_DIO_DATA + 3) << 8;
2155 2098
2156 outw( TLAN_EXCESSCOL_FRMS, dev->base_addr + TLAN_DIO_ADR ); 2099 outw(TLAN_EXCESSCOL_FRMS, dev->base_addr + TLAN_DIO_ADR);
2157 excess_col = inb( dev->base_addr + TLAN_DIO_DATA ); 2100 excess_col = inb(dev->base_addr + TLAN_DIO_DATA);
2158 late_col = inb( dev->base_addr + TLAN_DIO_DATA + 1 ); 2101 late_col = inb(dev->base_addr + TLAN_DIO_DATA + 1);
2159 loss = inb( dev->base_addr + TLAN_DIO_DATA + 2 ); 2102 loss = inb(dev->base_addr + TLAN_DIO_DATA + 2);
2160 2103
2161 if ( record ) { 2104 if (record) {
2162 dev->stats.rx_packets += rx_good; 2105 dev->stats.rx_packets += rx_good;
2163 dev->stats.rx_errors += rx_over + crc + code; 2106 dev->stats.rx_errors += rx_over + crc + code;
2164 dev->stats.tx_packets += tx_good; 2107 dev->stats.tx_packets += tx_good;
2165 dev->stats.tx_errors += tx_under + loss; 2108 dev->stats.tx_errors += tx_under + loss;
2166 dev->stats.collisions += multi_col + single_col + excess_col + late_col; 2109 dev->stats.collisions += multi_col
2110 + single_col + excess_col + late_col;
2167 2111
2168 dev->stats.rx_over_errors += rx_over; 2112 dev->stats.rx_over_errors += rx_over;
2169 dev->stats.rx_crc_errors += crc; 2113 dev->stats.rx_crc_errors += crc;
@@ -2173,39 +2117,39 @@ static void TLan_ReadAndClearStats( struct net_device *dev, int record )
2173 dev->stats.tx_carrier_errors += loss; 2117 dev->stats.tx_carrier_errors += loss;
2174 } 2118 }
2175 2119
2176} /* TLan_ReadAndClearStats */ 2120}
2177 2121
2178 2122
2179 2123
2180 2124
2181 /*************************************************************** 2125/***************************************************************
2182 * TLan_Reset 2126 * TLan_Reset
2183 * 2127 *
2184 * Returns: 2128 * Returns:
2185 * 0 2129 * 0
2186 * Parms: 2130 * Parms:
2187 * dev Pointer to device structure of adapter 2131 * dev Pointer to device structure of adapter
2188 * to be reset. 2132 * to be reset.
2189 * 2133 *
2190 * This function resets the adapter and it's physical 2134 * This function resets the adapter and it's physical
2191 * device. See Chap. 3, pp. 9-10 of the "ThunderLAN 2135 * device. See Chap. 3, pp. 9-10 of the "ThunderLAN
2192 * Programmer's Guide" for details. The routine tries to 2136 * Programmer's Guide" for details. The routine tries to
2193 * implement what is detailed there, though adjustments 2137 * implement what is detailed there, though adjustments
2194 * have been made. 2138 * have been made.
2195 * 2139 *
2196 **************************************************************/ 2140 **************************************************************/
2197 2141
2198static void 2142static void
2199TLan_ResetAdapter( struct net_device *dev ) 2143tlan_reset_adapter(struct net_device *dev)
2200{ 2144{
2201 TLanPrivateInfo *priv = netdev_priv(dev); 2145 struct tlan_priv *priv = netdev_priv(dev);
2202 int i; 2146 int i;
2203 u32 addr; 2147 u32 addr;
2204 u32 data; 2148 u32 data;
2205 u8 data8; 2149 u8 data8;
2206 2150
2207 priv->tlanFullDuplex = false; 2151 priv->tlan_full_duplex = false;
2208 priv->phyOnline=0; 2152 priv->phy_online = 0;
2209 netif_carrier_off(dev); 2153 netif_carrier_off(dev);
2210 2154
2211/* 1. Assert reset bit. */ 2155/* 1. Assert reset bit. */
@@ -2216,7 +2160,7 @@ TLan_ResetAdapter( struct net_device *dev )
2216 2160
2217 udelay(1000); 2161 udelay(1000);
2218 2162
2219/* 2. Turn off interrupts. ( Probably isn't necessary ) */ 2163/* 2. Turn off interrupts. (Probably isn't necessary) */
2220 2164
2221 data = inl(dev->base_addr + TLAN_HOST_CMD); 2165 data = inl(dev->base_addr + TLAN_HOST_CMD);
2222 data |= TLAN_HC_INT_OFF; 2166 data |= TLAN_HC_INT_OFF;
@@ -2224,207 +2168,204 @@ TLan_ResetAdapter( struct net_device *dev )
2224 2168
2225/* 3. Clear AREGs and HASHs. */ 2169/* 3. Clear AREGs and HASHs. */
2226 2170
2227 for ( i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4 ) { 2171 for (i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4)
2228 TLan_DioWrite32( dev->base_addr, (u16) i, 0 ); 2172 tlan_dio_write32(dev->base_addr, (u16) i, 0);
2229 }
2230 2173
2231/* 4. Setup NetConfig register. */ 2174/* 4. Setup NetConfig register. */
2232 2175
2233 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN; 2176 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
2234 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data ); 2177 tlan_dio_write16(dev->base_addr, TLAN_NET_CONFIG, (u16) data);
2235 2178
2236/* 5. Load Ld_Tmr and Ld_Thr in HOST_CMD. */ 2179/* 5. Load Ld_Tmr and Ld_Thr in HOST_CMD. */
2237 2180
2238 outl( TLAN_HC_LD_TMR | 0x3f, dev->base_addr + TLAN_HOST_CMD ); 2181 outl(TLAN_HC_LD_TMR | 0x3f, dev->base_addr + TLAN_HOST_CMD);
2239 outl( TLAN_HC_LD_THR | 0x9, dev->base_addr + TLAN_HOST_CMD ); 2182 outl(TLAN_HC_LD_THR | 0x9, dev->base_addr + TLAN_HOST_CMD);
2240 2183
2241/* 6. Unreset the MII by setting NMRST (in NetSio) to 1. */ 2184/* 6. Unreset the MII by setting NMRST (in NetSio) to 1. */
2242 2185
2243 outw( TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR ); 2186 outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
2244 addr = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO; 2187 addr = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
2245 TLan_SetBit( TLAN_NET_SIO_NMRST, addr ); 2188 tlan_set_bit(TLAN_NET_SIO_NMRST, addr);
2246 2189
2247/* 7. Setup the remaining registers. */ 2190/* 7. Setup the remaining registers. */
2248 2191
2249 if ( priv->tlanRev >= 0x30 ) { 2192 if (priv->tlan_rev >= 0x30) {
2250 data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC; 2193 data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC;
2251 TLan_DioWrite8( dev->base_addr, TLAN_INT_DIS, data8 ); 2194 tlan_dio_write8(dev->base_addr, TLAN_INT_DIS, data8);
2252 } 2195 }
2253 TLan_PhyDetect( dev ); 2196 tlan_phy_detect(dev);
2254 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN; 2197 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN;
2255 2198
2256 if ( priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY ) { 2199 if (priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY) {
2257 data |= TLAN_NET_CFG_BIT; 2200 data |= TLAN_NET_CFG_BIT;
2258 if ( priv->aui == 1 ) { 2201 if (priv->aui == 1) {
2259 TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x0a ); 2202 tlan_dio_write8(dev->base_addr, TLAN_ACOMMIT, 0x0a);
2260 } else if ( priv->duplex == TLAN_DUPLEX_FULL ) { 2203 } else if (priv->duplex == TLAN_DUPLEX_FULL) {
2261 TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x00 ); 2204 tlan_dio_write8(dev->base_addr, TLAN_ACOMMIT, 0x00);
2262 priv->tlanFullDuplex = true; 2205 priv->tlan_full_duplex = true;
2263 } else { 2206 } else {
2264 TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x08 ); 2207 tlan_dio_write8(dev->base_addr, TLAN_ACOMMIT, 0x08);
2265 } 2208 }
2266 } 2209 }
2267 2210
2268 if ( priv->phyNum == 0 ) { 2211 if (priv->phy_num == 0)
2269 data |= TLAN_NET_CFG_PHY_EN; 2212 data |= TLAN_NET_CFG_PHY_EN;
2270 } 2213 tlan_dio_write16(dev->base_addr, TLAN_NET_CONFIG, (u16) data);
2271 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
2272 2214
2273 if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) { 2215 if (priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY)
2274 TLan_FinishReset( dev ); 2216 tlan_finish_reset(dev);
2275 } else { 2217 else
2276 TLan_PhyPowerDown( dev ); 2218 tlan_phy_power_down(dev);
2277 }
2278 2219
2279} /* TLan_ResetAdapter */ 2220}
2280 2221
2281 2222
2282 2223
2283 2224
2284static void 2225static void
2285TLan_FinishReset( struct net_device *dev ) 2226tlan_finish_reset(struct net_device *dev)
2286{ 2227{
2287 TLanPrivateInfo *priv = netdev_priv(dev); 2228 struct tlan_priv *priv = netdev_priv(dev);
2288 u8 data; 2229 u8 data;
2289 u32 phy; 2230 u32 phy;
2290 u8 sio; 2231 u8 sio;
2291 u16 status; 2232 u16 status;
2292 u16 partner; 2233 u16 partner;
2293 u16 tlphy_ctl; 2234 u16 tlphy_ctl;
2294 u16 tlphy_par; 2235 u16 tlphy_par;
2295 u16 tlphy_id1, tlphy_id2; 2236 u16 tlphy_id1, tlphy_id2;
2296 int i; 2237 int i;
2297 2238
2298 phy = priv->phy[priv->phyNum]; 2239 phy = priv->phy[priv->phy_num];
2299 2240
2300 data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP; 2241 data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP;
2301 if ( priv->tlanFullDuplex ) { 2242 if (priv->tlan_full_duplex)
2302 data |= TLAN_NET_CMD_DUPLEX; 2243 data |= TLAN_NET_CMD_DUPLEX;
2303 } 2244 tlan_dio_write8(dev->base_addr, TLAN_NET_CMD, data);
2304 TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, data );
2305 data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5; 2245 data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5;
2306 if ( priv->phyNum == 0 ) { 2246 if (priv->phy_num == 0)
2307 data |= TLAN_NET_MASK_MASK7; 2247 data |= TLAN_NET_MASK_MASK7;
2308 } 2248 tlan_dio_write8(dev->base_addr, TLAN_NET_MASK, data);
2309 TLan_DioWrite8( dev->base_addr, TLAN_NET_MASK, data ); 2249 tlan_dio_write16(dev->base_addr, TLAN_MAX_RX, ((1536)+7)&~7);
2310 TLan_DioWrite16( dev->base_addr, TLAN_MAX_RX, ((1536)+7)&~7 ); 2250 tlan_mii_read_reg(dev, phy, MII_GEN_ID_HI, &tlphy_id1);
2311 TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &tlphy_id1 ); 2251 tlan_mii_read_reg(dev, phy, MII_GEN_ID_LO, &tlphy_id2);
2312 TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &tlphy_id2 );
2313 2252
2314 if ( ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) || 2253 if ((priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY) ||
2315 ( priv->aui ) ) { 2254 (priv->aui)) {
2316 status = MII_GS_LINK; 2255 status = MII_GS_LINK;
2317 printk( "TLAN: %s: Link forced.\n", dev->name ); 2256 netdev_info(dev, "Link forced\n");
2318 } else { 2257 } else {
2319 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status ); 2258 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
2320 udelay( 1000 ); 2259 udelay(1000);
2321 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status ); 2260 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
2322 if ( (status & MII_GS_LINK) && 2261 if ((status & MII_GS_LINK) &&
2323 /* We only support link info on Nat.Sem. PHY's */ 2262 /* We only support link info on Nat.Sem. PHY's */
2324 (tlphy_id1 == NAT_SEM_ID1) && 2263 (tlphy_id1 == NAT_SEM_ID1) &&
2325 (tlphy_id2 == NAT_SEM_ID2) ) { 2264 (tlphy_id2 == NAT_SEM_ID2)) {
2326 TLan_MiiReadReg( dev, phy, MII_AN_LPA, &partner ); 2265 tlan_mii_read_reg(dev, phy, MII_AN_LPA, &partner);
2327 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_PAR, &tlphy_par ); 2266 tlan_mii_read_reg(dev, phy, TLAN_TLPHY_PAR, &tlphy_par);
2328 2267
2329 printk( "TLAN: %s: Link active with ", dev->name ); 2268 netdev_info(dev,
2330 if (!(tlphy_par & TLAN_PHY_AN_EN_STAT)) { 2269 "Link active with %s %uMbps %s-Duplex\n",
2331 printk( "forced 10%sMbps %s-Duplex\n", 2270 !(tlphy_par & TLAN_PHY_AN_EN_STAT)
2332 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0", 2271 ? "forced" : "Autonegotiation enabled,",
2333 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half"); 2272 tlphy_par & TLAN_PHY_SPEED_100
2334 } else { 2273 ? 100 : 10,
2335 printk( "AutoNegotiation enabled, at 10%sMbps %s-Duplex\n", 2274 tlphy_par & TLAN_PHY_DUPLEX_FULL
2336 tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0", 2275 ? "Full" : "Half");
2337 tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half"); 2276
2338 printk("TLAN: Partner capability: "); 2277 if (tlphy_par & TLAN_PHY_AN_EN_STAT) {
2339 for (i = 5; i <= 10; i++) 2278 netdev_info(dev, "Partner capability:");
2340 if (partner & (1<<i)) 2279 for (i = 5; i < 10; i++)
2341 printk("%s",media[i-5]); 2280 if (partner & (1 << i))
2342 printk("\n"); 2281 pr_cont(" %s", media[i-5]);
2282 pr_cont("\n");
2343 } 2283 }
2344 2284
2345 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK ); 2285 tlan_dio_write8(dev->base_addr, TLAN_LED_REG,
2286 TLAN_LED_LINK);
2346#ifdef MONITOR 2287#ifdef MONITOR
2347 /* We have link beat..for now anyway */ 2288 /* We have link beat..for now anyway */
2348 priv->link = 1; 2289 priv->link = 1;
2349 /*Enabling link beat monitoring */ 2290 /*Enabling link beat monitoring */
2350 TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_LINK_BEAT ); 2291 tlan_set_timer(dev, (10*HZ), TLAN_TIMER_LINK_BEAT);
2351#endif 2292#endif
2352 } else if (status & MII_GS_LINK) { 2293 } else if (status & MII_GS_LINK) {
2353 printk( "TLAN: %s: Link active\n", dev->name ); 2294 netdev_info(dev, "Link active\n");
2354 TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK ); 2295 tlan_dio_write8(dev->base_addr, TLAN_LED_REG,
2296 TLAN_LED_LINK);
2355 } 2297 }
2356 } 2298 }
2357 2299
2358 if ( priv->phyNum == 0 ) { 2300 if (priv->phy_num == 0) {
2359 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl ); 2301 tlan_mii_read_reg(dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl);
2360 tlphy_ctl |= TLAN_TC_INTEN; 2302 tlphy_ctl |= TLAN_TC_INTEN;
2361 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl ); 2303 tlan_mii_write_reg(dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
2362 sio = TLan_DioRead8( dev->base_addr, TLAN_NET_SIO ); 2304 sio = tlan_dio_read8(dev->base_addr, TLAN_NET_SIO);
2363 sio |= TLAN_NET_SIO_MINTEN; 2305 sio |= TLAN_NET_SIO_MINTEN;
2364 TLan_DioWrite8( dev->base_addr, TLAN_NET_SIO, sio ); 2306 tlan_dio_write8(dev->base_addr, TLAN_NET_SIO, sio);
2365 } 2307 }
2366 2308
2367 if ( status & MII_GS_LINK ) { 2309 if (status & MII_GS_LINK) {
2368 TLan_SetMac( dev, 0, dev->dev_addr ); 2310 tlan_set_mac(dev, 0, dev->dev_addr);
2369 priv->phyOnline = 1; 2311 priv->phy_online = 1;
2370 outb( ( TLAN_HC_INT_ON >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 ); 2312 outb((TLAN_HC_INT_ON >> 8), dev->base_addr + TLAN_HOST_CMD + 1);
2371 if ( debug >= 1 && debug != TLAN_DEBUG_PROBE ) { 2313 if (debug >= 1 && debug != TLAN_DEBUG_PROBE)
2372 outb( ( TLAN_HC_REQ_INT >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 ); 2314 outb((TLAN_HC_REQ_INT >> 8),
2373 } 2315 dev->base_addr + TLAN_HOST_CMD + 1);
2374 outl( priv->rxListDMA, dev->base_addr + TLAN_CH_PARM ); 2316 outl(priv->rx_list_dma, dev->base_addr + TLAN_CH_PARM);
2375 outl( TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD ); 2317 outl(TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD);
2376 netif_carrier_on(dev); 2318 netif_carrier_on(dev);
2377 } else { 2319 } else {
2378 printk( "TLAN: %s: Link inactive, will retry in 10 secs...\n", 2320 netdev_info(dev, "Link inactive, will retry in 10 secs...\n");
2379 dev->name ); 2321 tlan_set_timer(dev, (10*HZ), TLAN_TIMER_FINISH_RESET);
2380 TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_FINISH_RESET );
2381 return; 2322 return;
2382 } 2323 }
2383 TLan_SetMulticastList(dev); 2324 tlan_set_multicast_list(dev);
2384 2325
2385} /* TLan_FinishReset */ 2326}
2386 2327
2387 2328
2388 2329
2389 2330
2390 /*************************************************************** 2331/***************************************************************
2391 * TLan_SetMac 2332 * tlan_set_mac
2392 * 2333 *
2393 * Returns: 2334 * Returns:
2394 * Nothing 2335 * Nothing
2395 * Parms: 2336 * Parms:
2396 * dev Pointer to device structure of adapter 2337 * dev Pointer to device structure of adapter
2397 * on which to change the AREG. 2338 * on which to change the AREG.
2398 * areg The AREG to set the address in (0 - 3). 2339 * areg The AREG to set the address in (0 - 3).
2399 * mac A pointer to an array of chars. Each 2340 * mac A pointer to an array of chars. Each
2400 * element stores one byte of the address. 2341 * element stores one byte of the address.
2401 * IE, it isn't in ascii. 2342 * IE, it isn't in ascii.
2402 * 2343 *
2403 * This function transfers a MAC address to one of the 2344 * This function transfers a MAC address to one of the
2404 * TLAN AREGs (address registers). The TLAN chip locks 2345 * TLAN AREGs (address registers). The TLAN chip locks
2405 * the register on writing to offset 0 and unlocks the 2346 * the register on writing to offset 0 and unlocks the
2406 * register after writing to offset 5. If NULL is passed 2347 * register after writing to offset 5. If NULL is passed
2407 * in mac, then the AREG is filled with 0's. 2348 * in mac, then the AREG is filled with 0's.
2408 * 2349 *
2409 **************************************************************/ 2350 **************************************************************/
2410 2351
2411static void TLan_SetMac( struct net_device *dev, int areg, char *mac ) 2352static void tlan_set_mac(struct net_device *dev, int areg, char *mac)
2412{ 2353{
2413 int i; 2354 int i;
2414 2355
2415 areg *= 6; 2356 areg *= 6;
2416 2357
2417 if ( mac != NULL ) { 2358 if (mac != NULL) {
2418 for ( i = 0; i < 6; i++ ) 2359 for (i = 0; i < 6; i++)
2419 TLan_DioWrite8( dev->base_addr, 2360 tlan_dio_write8(dev->base_addr,
2420 TLAN_AREG_0 + areg + i, mac[i] ); 2361 TLAN_AREG_0 + areg + i, mac[i]);
2421 } else { 2362 } else {
2422 for ( i = 0; i < 6; i++ ) 2363 for (i = 0; i < 6; i++)
2423 TLan_DioWrite8( dev->base_addr, 2364 tlan_dio_write8(dev->base_addr,
2424 TLAN_AREG_0 + areg + i, 0 ); 2365 TLAN_AREG_0 + areg + i, 0);
2425 } 2366 }
2426 2367
2427} /* TLan_SetMac */ 2368}
2428 2369
2429 2370
2430 2371
@@ -2432,205 +2373,199 @@ static void TLan_SetMac( struct net_device *dev, int areg, char *mac )
2432/***************************************************************************** 2373/*****************************************************************************
2433****************************************************************************** 2374******************************************************************************
2434 2375
2435 ThunderLAN Driver PHY Layer Routines 2376ThunderLAN driver PHY layer routines
2436 2377
2437****************************************************************************** 2378******************************************************************************
2438*****************************************************************************/ 2379*****************************************************************************/
2439 2380
2440 2381
2441 2382
2442 /********************************************************************* 2383/*********************************************************************
2443 * TLan_PhyPrint 2384 * tlan_phy_print
2444 * 2385 *
2445 * Returns: 2386 * Returns:
2446 * Nothing 2387 * Nothing
2447 * Parms: 2388 * Parms:
2448 * dev A pointer to the device structure of the 2389 * dev A pointer to the device structure of the
2449 * TLAN device having the PHYs to be detailed. 2390 * TLAN device having the PHYs to be detailed.
2450 * 2391 *
2451 * This function prints the registers a PHY (aka transceiver). 2392 * This function prints the registers a PHY (aka transceiver).
2452 * 2393 *
2453 ********************************************************************/ 2394 ********************************************************************/
2454 2395
2455static void TLan_PhyPrint( struct net_device *dev ) 2396static void tlan_phy_print(struct net_device *dev)
2456{ 2397{
2457 TLanPrivateInfo *priv = netdev_priv(dev); 2398 struct tlan_priv *priv = netdev_priv(dev);
2458 u16 i, data0, data1, data2, data3, phy; 2399 u16 i, data0, data1, data2, data3, phy;
2459 2400
2460 phy = priv->phy[priv->phyNum]; 2401 phy = priv->phy[priv->phy_num];
2461 2402
2462 if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) { 2403 if (priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY) {
2463 printk( "TLAN: Device %s, Unmanaged PHY.\n", dev->name ); 2404 netdev_info(dev, "Unmanaged PHY\n");
2464 } else if ( phy <= TLAN_PHY_MAX_ADDR ) { 2405 } else if (phy <= TLAN_PHY_MAX_ADDR) {
2465 printk( "TLAN: Device %s, PHY 0x%02x.\n", dev->name, phy ); 2406 netdev_info(dev, "PHY 0x%02x\n", phy);
2466 printk( "TLAN: Off. +0 +1 +2 +3\n" ); 2407 pr_info(" Off. +0 +1 +2 +3\n");
2467 for ( i = 0; i < 0x20; i+= 4 ) { 2408 for (i = 0; i < 0x20; i += 4) {
2468 printk( "TLAN: 0x%02x", i ); 2409 tlan_mii_read_reg(dev, phy, i, &data0);
2469 TLan_MiiReadReg( dev, phy, i, &data0 ); 2410 tlan_mii_read_reg(dev, phy, i + 1, &data1);
2470 printk( " 0x%04hx", data0 ); 2411 tlan_mii_read_reg(dev, phy, i + 2, &data2);
2471 TLan_MiiReadReg( dev, phy, i + 1, &data1 ); 2412 tlan_mii_read_reg(dev, phy, i + 3, &data3);
2472 printk( " 0x%04hx", data1 ); 2413 pr_info(" 0x%02x 0x%04hx 0x%04hx 0x%04hx 0x%04hx\n",
2473 TLan_MiiReadReg( dev, phy, i + 2, &data2 ); 2414 i, data0, data1, data2, data3);
2474 printk( " 0x%04hx", data2 );
2475 TLan_MiiReadReg( dev, phy, i + 3, &data3 );
2476 printk( " 0x%04hx\n", data3 );
2477 } 2415 }
2478 } else { 2416 } else {
2479 printk( "TLAN: Device %s, Invalid PHY.\n", dev->name ); 2417 netdev_info(dev, "Invalid PHY\n");
2480 } 2418 }
2481 2419
2482} /* TLan_PhyPrint */ 2420}
2483 2421
2484 2422
2485 2423
2486 2424
2487 /********************************************************************* 2425/*********************************************************************
2488 * TLan_PhyDetect 2426 * tlan_phy_detect
2489 * 2427 *
2490 * Returns: 2428 * Returns:
2491 * Nothing 2429 * Nothing
2492 * Parms: 2430 * Parms:
2493 * dev A pointer to the device structure of the adapter 2431 * dev A pointer to the device structure of the adapter
2494 * for which the PHY needs determined. 2432 * for which the PHY needs determined.
2495 * 2433 *
2496 * So far I've found that adapters which have external PHYs 2434 * So far I've found that adapters which have external PHYs
2497 * may also use the internal PHY for part of the functionality. 2435 * may also use the internal PHY for part of the functionality.
2498 * (eg, AUI/Thinnet). This function finds out if this TLAN 2436 * (eg, AUI/Thinnet). This function finds out if this TLAN
2499 * chip has an internal PHY, and then finds the first external 2437 * chip has an internal PHY, and then finds the first external
2500 * PHY (starting from address 0) if it exists). 2438 * PHY (starting from address 0) if it exists).
2501 * 2439 *
2502 ********************************************************************/ 2440 ********************************************************************/
2503 2441
2504static void TLan_PhyDetect( struct net_device *dev ) 2442static void tlan_phy_detect(struct net_device *dev)
2505{ 2443{
2506 TLanPrivateInfo *priv = netdev_priv(dev); 2444 struct tlan_priv *priv = netdev_priv(dev);
2507 u16 control; 2445 u16 control;
2508 u16 hi; 2446 u16 hi;
2509 u16 lo; 2447 u16 lo;
2510 u32 phy; 2448 u32 phy;
2511 2449
2512 if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) { 2450 if (priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY) {
2513 priv->phyNum = 0xFFFF; 2451 priv->phy_num = 0xffff;
2514 return; 2452 return;
2515 } 2453 }
2516 2454
2517 TLan_MiiReadReg( dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi ); 2455 tlan_mii_read_reg(dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi);
2518 2456
2519 if ( hi != 0xFFFF ) { 2457 if (hi != 0xffff)
2520 priv->phy[0] = TLAN_PHY_MAX_ADDR; 2458 priv->phy[0] = TLAN_PHY_MAX_ADDR;
2521 } else { 2459 else
2522 priv->phy[0] = TLAN_PHY_NONE; 2460 priv->phy[0] = TLAN_PHY_NONE;
2523 }
2524 2461
2525 priv->phy[1] = TLAN_PHY_NONE; 2462 priv->phy[1] = TLAN_PHY_NONE;
2526 for ( phy = 0; phy <= TLAN_PHY_MAX_ADDR; phy++ ) { 2463 for (phy = 0; phy <= TLAN_PHY_MAX_ADDR; phy++) {
2527 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &control ); 2464 tlan_mii_read_reg(dev, phy, MII_GEN_CTL, &control);
2528 TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &hi ); 2465 tlan_mii_read_reg(dev, phy, MII_GEN_ID_HI, &hi);
2529 TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &lo ); 2466 tlan_mii_read_reg(dev, phy, MII_GEN_ID_LO, &lo);
2530 if ( ( control != 0xFFFF ) || 2467 if ((control != 0xffff) ||
2531 ( hi != 0xFFFF ) || ( lo != 0xFFFF ) ) { 2468 (hi != 0xffff) || (lo != 0xffff)) {
2532 TLAN_DBG( TLAN_DEBUG_GNRL, 2469 TLAN_DBG(TLAN_DEBUG_GNRL,
2533 "PHY found at %02x %04x %04x %04x\n", 2470 "PHY found at %02x %04x %04x %04x\n",
2534 phy, control, hi, lo ); 2471 phy, control, hi, lo);
2535 if ( ( priv->phy[1] == TLAN_PHY_NONE ) && 2472 if ((priv->phy[1] == TLAN_PHY_NONE) &&
2536 ( phy != TLAN_PHY_MAX_ADDR ) ) { 2473 (phy != TLAN_PHY_MAX_ADDR)) {
2537 priv->phy[1] = phy; 2474 priv->phy[1] = phy;
2538 } 2475 }
2539 } 2476 }
2540 } 2477 }
2541 2478
2542 if ( priv->phy[1] != TLAN_PHY_NONE ) { 2479 if (priv->phy[1] != TLAN_PHY_NONE)
2543 priv->phyNum = 1; 2480 priv->phy_num = 1;
2544 } else if ( priv->phy[0] != TLAN_PHY_NONE ) { 2481 else if (priv->phy[0] != TLAN_PHY_NONE)
2545 priv->phyNum = 0; 2482 priv->phy_num = 0;
2546 } else { 2483 else
2547 printk( "TLAN: Cannot initialize device, no PHY was found!\n" ); 2484 netdev_info(dev, "Cannot initialize device, no PHY was found!\n");
2548 }
2549 2485
2550} /* TLan_PhyDetect */ 2486}
2551 2487
2552 2488
2553 2489
2554 2490
2555static void TLan_PhyPowerDown( struct net_device *dev ) 2491static void tlan_phy_power_down(struct net_device *dev)
2556{ 2492{
2557 TLanPrivateInfo *priv = netdev_priv(dev); 2493 struct tlan_priv *priv = netdev_priv(dev);
2558 u16 value; 2494 u16 value;
2559 2495
2560 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering down PHY(s).\n", dev->name ); 2496 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Powering down PHY(s).\n", dev->name);
2561 value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE; 2497 value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE;
2562 TLan_MiiSync( dev->base_addr ); 2498 tlan_mii_sync(dev->base_addr);
2563 TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value ); 2499 tlan_mii_write_reg(dev, priv->phy[priv->phy_num], MII_GEN_CTL, value);
2564 if ( ( priv->phyNum == 0 ) && 2500 if ((priv->phy_num == 0) &&
2565 ( priv->phy[1] != TLAN_PHY_NONE ) && 2501 (priv->phy[1] != TLAN_PHY_NONE) &&
2566 ( ! ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) ) ) { 2502 (!(priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10))) {
2567 TLan_MiiSync( dev->base_addr ); 2503 tlan_mii_sync(dev->base_addr);
2568 TLan_MiiWriteReg( dev, priv->phy[1], MII_GEN_CTL, value ); 2504 tlan_mii_write_reg(dev, priv->phy[1], MII_GEN_CTL, value);
2569 } 2505 }
2570 2506
2571 /* Wait for 50 ms and powerup 2507 /* Wait for 50 ms and powerup
2572 * This is abitrary. It is intended to make sure the 2508 * This is abitrary. It is intended to make sure the
2573 * transceiver settles. 2509 * transceiver settles.
2574 */ 2510 */
2575 TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_PUP ); 2511 tlan_set_timer(dev, (HZ/20), TLAN_TIMER_PHY_PUP);
2576 2512
2577} /* TLan_PhyPowerDown */ 2513}
2578 2514
2579 2515
2580 2516
2581 2517
2582static void TLan_PhyPowerUp( struct net_device *dev ) 2518static void tlan_phy_power_up(struct net_device *dev)
2583{ 2519{
2584 TLanPrivateInfo *priv = netdev_priv(dev); 2520 struct tlan_priv *priv = netdev_priv(dev);
2585 u16 value; 2521 u16 value;
2586 2522
2587 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering up PHY.\n", dev->name ); 2523 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Powering up PHY.\n", dev->name);
2588 TLan_MiiSync( dev->base_addr ); 2524 tlan_mii_sync(dev->base_addr);
2589 value = MII_GC_LOOPBK; 2525 value = MII_GC_LOOPBK;
2590 TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value ); 2526 tlan_mii_write_reg(dev, priv->phy[priv->phy_num], MII_GEN_CTL, value);
2591 TLan_MiiSync(dev->base_addr); 2527 tlan_mii_sync(dev->base_addr);
2592 /* Wait for 500 ms and reset the 2528 /* Wait for 500 ms and reset the
2593 * transceiver. The TLAN docs say both 50 ms and 2529 * transceiver. The TLAN docs say both 50 ms and
2594 * 500 ms, so do the longer, just in case. 2530 * 500 ms, so do the longer, just in case.
2595 */ 2531 */
2596 TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_RESET ); 2532 tlan_set_timer(dev, (HZ/20), TLAN_TIMER_PHY_RESET);
2597 2533
2598} /* TLan_PhyPowerUp */ 2534}
2599 2535
2600 2536
2601 2537
2602 2538
2603static void TLan_PhyReset( struct net_device *dev ) 2539static void tlan_phy_reset(struct net_device *dev)
2604{ 2540{
2605 TLanPrivateInfo *priv = netdev_priv(dev); 2541 struct tlan_priv *priv = netdev_priv(dev);
2606 u16 phy; 2542 u16 phy;
2607 u16 value; 2543 u16 value;
2608 2544
2609 phy = priv->phy[priv->phyNum]; 2545 phy = priv->phy[priv->phy_num];
2610 2546
2611 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Reseting PHY.\n", dev->name ); 2547 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Reseting PHY.\n", dev->name);
2612 TLan_MiiSync( dev->base_addr ); 2548 tlan_mii_sync(dev->base_addr);
2613 value = MII_GC_LOOPBK | MII_GC_RESET; 2549 value = MII_GC_LOOPBK | MII_GC_RESET;
2614 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, value ); 2550 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, value);
2615 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value ); 2551 tlan_mii_read_reg(dev, phy, MII_GEN_CTL, &value);
2616 while ( value & MII_GC_RESET ) { 2552 while (value & MII_GC_RESET)
2617 TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value ); 2553 tlan_mii_read_reg(dev, phy, MII_GEN_CTL, &value);
2618 }
2619 2554
2620 /* Wait for 500 ms and initialize. 2555 /* Wait for 500 ms and initialize.
2621 * I don't remember why I wait this long. 2556 * I don't remember why I wait this long.
2622 * I've changed this to 50ms, as it seems long enough. 2557 * I've changed this to 50ms, as it seems long enough.
2623 */ 2558 */
2624 TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_START_LINK ); 2559 tlan_set_timer(dev, (HZ/20), TLAN_TIMER_PHY_START_LINK);
2625 2560
2626} /* TLan_PhyReset */ 2561}
2627 2562
2628 2563
2629 2564
2630 2565
2631static void TLan_PhyStartLink( struct net_device *dev ) 2566static void tlan_phy_start_link(struct net_device *dev)
2632{ 2567{
2633 TLanPrivateInfo *priv = netdev_priv(dev); 2568 struct tlan_priv *priv = netdev_priv(dev);
2634 u16 ability; 2569 u16 ability;
2635 u16 control; 2570 u16 control;
2636 u16 data; 2571 u16 data;
@@ -2638,86 +2573,87 @@ static void TLan_PhyStartLink( struct net_device *dev )
2638 u16 status; 2573 u16 status;
2639 u16 tctl; 2574 u16 tctl;
2640 2575
2641 phy = priv->phy[priv->phyNum]; 2576 phy = priv->phy[priv->phy_num];
2642 TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Trying to activate link.\n", dev->name ); 2577 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Trying to activate link.\n", dev->name);
2643 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status ); 2578 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
2644 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &ability ); 2579 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &ability);
2645 2580
2646 if ( ( status & MII_GS_AUTONEG ) && 2581 if ((status & MII_GS_AUTONEG) &&
2647 ( ! priv->aui ) ) { 2582 (!priv->aui)) {
2648 ability = status >> 11; 2583 ability = status >> 11;
2649 if ( priv->speed == TLAN_SPEED_10 && 2584 if (priv->speed == TLAN_SPEED_10 &&
2650 priv->duplex == TLAN_DUPLEX_HALF) { 2585 priv->duplex == TLAN_DUPLEX_HALF) {
2651 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0000); 2586 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x0000);
2652 } else if ( priv->speed == TLAN_SPEED_10 && 2587 } else if (priv->speed == TLAN_SPEED_10 &&
2653 priv->duplex == TLAN_DUPLEX_FULL) { 2588 priv->duplex == TLAN_DUPLEX_FULL) {
2654 priv->tlanFullDuplex = true; 2589 priv->tlan_full_duplex = true;
2655 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0100); 2590 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x0100);
2656 } else if ( priv->speed == TLAN_SPEED_100 && 2591 } else if (priv->speed == TLAN_SPEED_100 &&
2657 priv->duplex == TLAN_DUPLEX_HALF) { 2592 priv->duplex == TLAN_DUPLEX_HALF) {
2658 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2000); 2593 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x2000);
2659 } else if ( priv->speed == TLAN_SPEED_100 && 2594 } else if (priv->speed == TLAN_SPEED_100 &&
2660 priv->duplex == TLAN_DUPLEX_FULL) { 2595 priv->duplex == TLAN_DUPLEX_FULL) {
2661 priv->tlanFullDuplex = true; 2596 priv->tlan_full_duplex = true;
2662 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2100); 2597 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x2100);
2663 } else { 2598 } else {
2664 2599
2665 /* Set Auto-Neg advertisement */ 2600 /* Set Auto-Neg advertisement */
2666 TLan_MiiWriteReg( dev, phy, MII_AN_ADV, (ability << 5) | 1); 2601 tlan_mii_write_reg(dev, phy, MII_AN_ADV,
2602 (ability << 5) | 1);
2667 /* Enablee Auto-Neg */ 2603 /* Enablee Auto-Neg */
2668 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1000 ); 2604 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x1000);
2669 /* Restart Auto-Neg */ 2605 /* Restart Auto-Neg */
2670 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1200 ); 2606 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x1200);
2671 /* Wait for 4 sec for autonegotiation 2607 /* Wait for 4 sec for autonegotiation
2672 * to complete. The max spec time is less than this 2608 * to complete. The max spec time is less than this
2673 * but the card need additional time to start AN. 2609 * but the card need additional time to start AN.
2674 * .5 sec should be plenty extra. 2610 * .5 sec should be plenty extra.
2675 */ 2611 */
2676 printk( "TLAN: %s: Starting autonegotiation.\n", dev->name ); 2612 netdev_info(dev, "Starting autonegotiation\n");
2677 TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN ); 2613 tlan_set_timer(dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN);
2678 return; 2614 return;
2679 } 2615 }
2680 2616
2681 } 2617 }
2682 2618
2683 if ( ( priv->aui ) && ( priv->phyNum != 0 ) ) { 2619 if ((priv->aui) && (priv->phy_num != 0)) {
2684 priv->phyNum = 0; 2620 priv->phy_num = 0;
2685 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN; 2621 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN
2686 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data ); 2622 | TLAN_NET_CFG_PHY_EN;
2687 TLan_SetTimer( dev, (40*HZ/1000), TLAN_TIMER_PHY_PDOWN ); 2623 tlan_dio_write16(dev->base_addr, TLAN_NET_CONFIG, data);
2624 tlan_set_timer(dev, (40*HZ/1000), TLAN_TIMER_PHY_PDOWN);
2688 return; 2625 return;
2689 } else if ( priv->phyNum == 0 ) { 2626 } else if (priv->phy_num == 0) {
2690 control = 0; 2627 control = 0;
2691 TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tctl ); 2628 tlan_mii_read_reg(dev, phy, TLAN_TLPHY_CTL, &tctl);
2692 if ( priv->aui ) { 2629 if (priv->aui) {
2693 tctl |= TLAN_TC_AUISEL; 2630 tctl |= TLAN_TC_AUISEL;
2694 } else { 2631 } else {
2695 tctl &= ~TLAN_TC_AUISEL; 2632 tctl &= ~TLAN_TC_AUISEL;
2696 if ( priv->duplex == TLAN_DUPLEX_FULL ) { 2633 if (priv->duplex == TLAN_DUPLEX_FULL) {
2697 control |= MII_GC_DUPLEX; 2634 control |= MII_GC_DUPLEX;
2698 priv->tlanFullDuplex = true; 2635 priv->tlan_full_duplex = true;
2699 } 2636 }
2700 if ( priv->speed == TLAN_SPEED_100 ) { 2637 if (priv->speed == TLAN_SPEED_100)
2701 control |= MII_GC_SPEEDSEL; 2638 control |= MII_GC_SPEEDSEL;
2702 }
2703 } 2639 }
2704 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, control ); 2640 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, control);
2705 TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tctl ); 2641 tlan_mii_write_reg(dev, phy, TLAN_TLPHY_CTL, tctl);
2706 } 2642 }
2707 2643
2708 /* Wait for 2 sec to give the transceiver time 2644 /* Wait for 2 sec to give the transceiver time
2709 * to establish link. 2645 * to establish link.
2710 */ 2646 */
2711 TLan_SetTimer( dev, (4*HZ), TLAN_TIMER_FINISH_RESET ); 2647 tlan_set_timer(dev, (4*HZ), TLAN_TIMER_FINISH_RESET);
2712 2648
2713} /* TLan_PhyStartLink */ 2649}
2714 2650
2715 2651
2716 2652
2717 2653
2718static void TLan_PhyFinishAutoNeg( struct net_device *dev ) 2654static void tlan_phy_finish_auto_neg(struct net_device *dev)
2719{ 2655{
2720 TLanPrivateInfo *priv = netdev_priv(dev); 2656 struct tlan_priv *priv = netdev_priv(dev);
2721 u16 an_adv; 2657 u16 an_adv;
2722 u16 an_lpa; 2658 u16 an_lpa;
2723 u16 data; 2659 u16 data;
@@ -2725,115 +2661,118 @@ static void TLan_PhyFinishAutoNeg( struct net_device *dev )
2725 u16 phy; 2661 u16 phy;
2726 u16 status; 2662 u16 status;
2727 2663
2728 phy = priv->phy[priv->phyNum]; 2664 phy = priv->phy[priv->phy_num];
2729 2665
2730 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status ); 2666 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
2731 udelay( 1000 ); 2667 udelay(1000);
2732 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status ); 2668 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
2733 2669
2734 if ( ! ( status & MII_GS_AUTOCMPLT ) ) { 2670 if (!(status & MII_GS_AUTOCMPLT)) {
2735 /* Wait for 8 sec to give the process 2671 /* Wait for 8 sec to give the process
2736 * more time. Perhaps we should fail after a while. 2672 * more time. Perhaps we should fail after a while.
2737 */ 2673 */
2738 if (!priv->neg_be_verbose++) { 2674 if (!priv->neg_be_verbose++) {
2739 pr_info("TLAN: Giving autonegotiation more time.\n"); 2675 pr_info("Giving autonegotiation more time.\n");
2740 pr_info("TLAN: Please check that your adapter has\n"); 2676 pr_info("Please check that your adapter has\n");
2741 pr_info("TLAN: been properly connected to a HUB or Switch.\n"); 2677 pr_info("been properly connected to a HUB or Switch.\n");
2742 pr_info("TLAN: Trying to establish link in the background...\n"); 2678 pr_info("Trying to establish link in the background...\n");
2743 } 2679 }
2744 TLan_SetTimer( dev, (8*HZ), TLAN_TIMER_PHY_FINISH_AN ); 2680 tlan_set_timer(dev, (8*HZ), TLAN_TIMER_PHY_FINISH_AN);
2745 return; 2681 return;
2746 } 2682 }
2747 2683
2748 printk( "TLAN: %s: Autonegotiation complete.\n", dev->name ); 2684 netdev_info(dev, "Autonegotiation complete\n");
2749 TLan_MiiReadReg( dev, phy, MII_AN_ADV, &an_adv ); 2685 tlan_mii_read_reg(dev, phy, MII_AN_ADV, &an_adv);
2750 TLan_MiiReadReg( dev, phy, MII_AN_LPA, &an_lpa ); 2686 tlan_mii_read_reg(dev, phy, MII_AN_LPA, &an_lpa);
2751 mode = an_adv & an_lpa & 0x03E0; 2687 mode = an_adv & an_lpa & 0x03E0;
2752 if ( mode & 0x0100 ) { 2688 if (mode & 0x0100)
2753 priv->tlanFullDuplex = true; 2689 priv->tlan_full_duplex = true;
2754 } else if ( ! ( mode & 0x0080 ) && ( mode & 0x0040 ) ) { 2690 else if (!(mode & 0x0080) && (mode & 0x0040))
2755 priv->tlanFullDuplex = true; 2691 priv->tlan_full_duplex = true;
2756 } 2692
2757 2693 if ((!(mode & 0x0180)) &&
2758 if ( ( ! ( mode & 0x0180 ) ) && 2694 (priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10) &&
2759 ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) && 2695 (priv->phy_num != 0)) {
2760 ( priv->phyNum != 0 ) ) { 2696 priv->phy_num = 0;
2761 priv->phyNum = 0; 2697 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN
2762 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN; 2698 | TLAN_NET_CFG_PHY_EN;
2763 TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data ); 2699 tlan_dio_write16(dev->base_addr, TLAN_NET_CONFIG, data);
2764 TLan_SetTimer( dev, (400*HZ/1000), TLAN_TIMER_PHY_PDOWN ); 2700 tlan_set_timer(dev, (400*HZ/1000), TLAN_TIMER_PHY_PDOWN);
2765 return; 2701 return;
2766 } 2702 }
2767 2703
2768 if ( priv->phyNum == 0 ) { 2704 if (priv->phy_num == 0) {
2769 if ( ( priv->duplex == TLAN_DUPLEX_FULL ) || 2705 if ((priv->duplex == TLAN_DUPLEX_FULL) ||
2770 ( an_adv & an_lpa & 0x0040 ) ) { 2706 (an_adv & an_lpa & 0x0040)) {
2771 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 2707 tlan_mii_write_reg(dev, phy, MII_GEN_CTL,
2772 MII_GC_AUTOENB | MII_GC_DUPLEX ); 2708 MII_GC_AUTOENB | MII_GC_DUPLEX);
2773 pr_info("TLAN: Starting internal PHY with FULL-DUPLEX\n" ); 2709 netdev_info(dev, "Starting internal PHY with FULL-DUPLEX\n");
2774 } else { 2710 } else {
2775 TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB ); 2711 tlan_mii_write_reg(dev, phy, MII_GEN_CTL,
2776 pr_info( "TLAN: Starting internal PHY with HALF-DUPLEX\n" ); 2712 MII_GC_AUTOENB);
2713 netdev_info(dev, "Starting internal PHY with HALF-DUPLEX\n");
2777 } 2714 }
2778 } 2715 }
2779 2716
2780 /* Wait for 100 ms. No reason in partiticular. 2717 /* Wait for 100 ms. No reason in partiticular.
2781 */ 2718 */
2782 TLan_SetTimer( dev, (HZ/10), TLAN_TIMER_FINISH_RESET ); 2719 tlan_set_timer(dev, (HZ/10), TLAN_TIMER_FINISH_RESET);
2783 2720
2784} /* TLan_PhyFinishAutoNeg */ 2721}
2785 2722
2786#ifdef MONITOR 2723#ifdef MONITOR
2787 2724
2788 /********************************************************************* 2725/*********************************************************************
2789 * 2726 *
2790 * TLan_phyMonitor 2727 * tlan_phy_monitor
2791 * 2728 *
2792 * Returns: 2729 * Returns:
2793 * None 2730 * None
2794 * 2731 *
2795 * Params: 2732 * Params:
2796 * dev The device structure of this device. 2733 * dev The device structure of this device.
2797 * 2734 *
2798 * 2735 *
2799 * This function monitors PHY condition by reading the status 2736 * This function monitors PHY condition by reading the status
2800 * register via the MII bus. This can be used to give info 2737 * register via the MII bus. This can be used to give info
2801 * about link changes (up/down), and possible switch to alternate 2738 * about link changes (up/down), and possible switch to alternate
2802 * media. 2739 * media.
2803 * 2740 *
2804 * ******************************************************************/ 2741 *******************************************************************/
2805 2742
2806void TLan_PhyMonitor( struct net_device *dev ) 2743void tlan_phy_monitor(struct net_device *dev)
2807{ 2744{
2808 TLanPrivateInfo *priv = netdev_priv(dev); 2745 struct tlan_priv *priv = netdev_priv(dev);
2809 u16 phy; 2746 u16 phy;
2810 u16 phy_status; 2747 u16 phy_status;
2811 2748
2812 phy = priv->phy[priv->phyNum]; 2749 phy = priv->phy[priv->phy_num];
2813 2750
2814 /* Get PHY status register */ 2751 /* Get PHY status register */
2815 TLan_MiiReadReg( dev, phy, MII_GEN_STS, &phy_status ); 2752 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &phy_status);
2816 2753
2817 /* Check if link has been lost */ 2754 /* Check if link has been lost */
2818 if (!(phy_status & MII_GS_LINK)) { 2755 if (!(phy_status & MII_GS_LINK)) {
2819 if (priv->link) { 2756 if (priv->link) {
2820 priv->link = 0; 2757 priv->link = 0;
2821 printk(KERN_DEBUG "TLAN: %s has lost link\n", dev->name); 2758 printk(KERN_DEBUG "TLAN: %s has lost link\n",
2822 netif_carrier_off(dev); 2759 dev->name);
2823 TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT ); 2760 netif_carrier_off(dev);
2824 return; 2761 tlan_set_timer(dev, (2*HZ), TLAN_TIMER_LINK_BEAT);
2762 return;
2825 } 2763 }
2826 } 2764 }
2827 2765
2828 /* Link restablished? */ 2766 /* Link restablished? */
2829 if ((phy_status & MII_GS_LINK) && !priv->link) { 2767 if ((phy_status & MII_GS_LINK) && !priv->link) {
2830 priv->link = 1; 2768 priv->link = 1;
2831 printk(KERN_DEBUG "TLAN: %s has reestablished link\n", dev->name); 2769 printk(KERN_DEBUG "TLAN: %s has reestablished link\n",
2770 dev->name);
2832 netif_carrier_on(dev); 2771 netif_carrier_on(dev);
2833 } 2772 }
2834 2773
2835 /* Setup a new monitor */ 2774 /* Setup a new monitor */
2836 TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT ); 2775 tlan_set_timer(dev, (2*HZ), TLAN_TIMER_LINK_BEAT);
2837} 2776}
2838 2777
2839#endif /* MONITOR */ 2778#endif /* MONITOR */
@@ -2842,47 +2781,48 @@ void TLan_PhyMonitor( struct net_device *dev )
2842/***************************************************************************** 2781/*****************************************************************************
2843****************************************************************************** 2782******************************************************************************
2844 2783
2845 ThunderLAN Driver MII Routines 2784ThunderLAN driver MII routines
2846 2785
2847 These routines are based on the information in Chap. 2 of the 2786these routines are based on the information in chap. 2 of the
2848 "ThunderLAN Programmer's Guide", pp. 15-24. 2787"ThunderLAN Programmer's Guide", pp. 15-24.
2849 2788
2850****************************************************************************** 2789******************************************************************************
2851*****************************************************************************/ 2790*****************************************************************************/
2852 2791
2853 2792
2854 /*************************************************************** 2793/***************************************************************
2855 * TLan_MiiReadReg 2794 * tlan_mii_read_reg
2856 * 2795 *
2857 * Returns: 2796 * Returns:
2858 * false if ack received ok 2797 * false if ack received ok
2859 * true if no ack received or other error 2798 * true if no ack received or other error
2860 * 2799 *
2861 * Parms: 2800 * Parms:
2862 * dev The device structure containing 2801 * dev The device structure containing
2863 * The io address and interrupt count 2802 * The io address and interrupt count
2864 * for this device. 2803 * for this device.
2865 * phy The address of the PHY to be queried. 2804 * phy The address of the PHY to be queried.
2866 * reg The register whose contents are to be 2805 * reg The register whose contents are to be
2867 * retrieved. 2806 * retrieved.
2868 * val A pointer to a variable to store the 2807 * val A pointer to a variable to store the
2869 * retrieved value. 2808 * retrieved value.
2870 * 2809 *
2871 * This function uses the TLAN's MII bus to retrieve the contents 2810 * This function uses the TLAN's MII bus to retrieve the contents
2872 * of a given register on a PHY. It sends the appropriate info 2811 * of a given register on a PHY. It sends the appropriate info
2873 * and then reads the 16-bit register value from the MII bus via 2812 * and then reads the 16-bit register value from the MII bus via
2874 * the TLAN SIO register. 2813 * the TLAN SIO register.
2875 * 2814 *
2876 **************************************************************/ 2815 **************************************************************/
2877 2816
2878static bool TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val ) 2817static bool
2818tlan_mii_read_reg(struct net_device *dev, u16 phy, u16 reg, u16 *val)
2879{ 2819{
2880 u8 nack; 2820 u8 nack;
2881 u16 sio, tmp; 2821 u16 sio, tmp;
2882 u32 i; 2822 u32 i;
2883 bool err; 2823 bool err;
2884 int minten; 2824 int minten;
2885 TLanPrivateInfo *priv = netdev_priv(dev); 2825 struct tlan_priv *priv = netdev_priv(dev);
2886 unsigned long flags = 0; 2826 unsigned long flags = 0;
2887 2827
2888 err = false; 2828 err = false;
@@ -2892,48 +2832,48 @@ static bool TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val
2892 if (!in_irq()) 2832 if (!in_irq())
2893 spin_lock_irqsave(&priv->lock, flags); 2833 spin_lock_irqsave(&priv->lock, flags);
2894 2834
2895 TLan_MiiSync(dev->base_addr); 2835 tlan_mii_sync(dev->base_addr);
2896 2836
2897 minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio ); 2837 minten = tlan_get_bit(TLAN_NET_SIO_MINTEN, sio);
2898 if ( minten ) 2838 if (minten)
2899 TLan_ClearBit(TLAN_NET_SIO_MINTEN, sio); 2839 tlan_clear_bit(TLAN_NET_SIO_MINTEN, sio);
2900 2840
2901 TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Start ( 01b ) */ 2841 tlan_mii_send_data(dev->base_addr, 0x1, 2); /* start (01b) */
2902 TLan_MiiSendData( dev->base_addr, 0x2, 2 ); /* Read ( 10b ) */ 2842 tlan_mii_send_data(dev->base_addr, 0x2, 2); /* read (10b) */
2903 TLan_MiiSendData( dev->base_addr, phy, 5 ); /* Device # */ 2843 tlan_mii_send_data(dev->base_addr, phy, 5); /* device # */
2904 TLan_MiiSendData( dev->base_addr, reg, 5 ); /* Register # */ 2844 tlan_mii_send_data(dev->base_addr, reg, 5); /* register # */
2905 2845
2906 2846
2907 TLan_ClearBit(TLAN_NET_SIO_MTXEN, sio); /* Change direction */ 2847 tlan_clear_bit(TLAN_NET_SIO_MTXEN, sio); /* change direction */
2908 2848
2909 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Clock Idle bit */ 2849 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio); /* clock idle bit */
2910 TLan_SetBit(TLAN_NET_SIO_MCLK, sio); 2850 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
2911 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Wait 300ns */ 2851 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio); /* wait 300ns */
2912 2852
2913 nack = TLan_GetBit(TLAN_NET_SIO_MDATA, sio); /* Check for ACK */ 2853 nack = tlan_get_bit(TLAN_NET_SIO_MDATA, sio); /* check for ACK */
2914 TLan_SetBit(TLAN_NET_SIO_MCLK, sio); /* Finish ACK */ 2854 tlan_set_bit(TLAN_NET_SIO_MCLK, sio); /* finish ACK */
2915 if (nack) { /* No ACK, so fake it */ 2855 if (nack) { /* no ACK, so fake it */
2916 for (i = 0; i < 16; i++) { 2856 for (i = 0; i < 16; i++) {
2917 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); 2857 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);
2918 TLan_SetBit(TLAN_NET_SIO_MCLK, sio); 2858 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
2919 } 2859 }
2920 tmp = 0xffff; 2860 tmp = 0xffff;
2921 err = true; 2861 err = true;
2922 } else { /* ACK, so read data */ 2862 } else { /* ACK, so read data */
2923 for (tmp = 0, i = 0x8000; i; i >>= 1) { 2863 for (tmp = 0, i = 0x8000; i; i >>= 1) {
2924 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); 2864 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);
2925 if (TLan_GetBit(TLAN_NET_SIO_MDATA, sio)) 2865 if (tlan_get_bit(TLAN_NET_SIO_MDATA, sio))
2926 tmp |= i; 2866 tmp |= i;
2927 TLan_SetBit(TLAN_NET_SIO_MCLK, sio); 2867 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
2928 } 2868 }
2929 } 2869 }
2930 2870
2931 2871
2932 TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Idle cycle */ 2872 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio); /* idle cycle */
2933 TLan_SetBit(TLAN_NET_SIO_MCLK, sio); 2873 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
2934 2874
2935 if ( minten ) 2875 if (minten)
2936 TLan_SetBit(TLAN_NET_SIO_MINTEN, sio); 2876 tlan_set_bit(TLAN_NET_SIO_MINTEN, sio);
2937 2877
2938 *val = tmp; 2878 *val = tmp;
2939 2879
@@ -2942,116 +2882,117 @@ static bool TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val
2942 2882
2943 return err; 2883 return err;
2944 2884
2945} /* TLan_MiiReadReg */ 2885}
2946 2886
2947 2887
2948 2888
2949 2889
2950 /*************************************************************** 2890/***************************************************************
2951 * TLan_MiiSendData 2891 * tlan_mii_send_data
2952 * 2892 *
2953 * Returns: 2893 * Returns:
2954 * Nothing 2894 * Nothing
2955 * Parms: 2895 * Parms:
2956 * base_port The base IO port of the adapter in 2896 * base_port The base IO port of the adapter in
2957 * question. 2897 * question.
2958 * dev The address of the PHY to be queried. 2898 * dev The address of the PHY to be queried.
2959 * data The value to be placed on the MII bus. 2899 * data The value to be placed on the MII bus.
2960 * num_bits The number of bits in data that are to 2900 * num_bits The number of bits in data that are to
2961 * be placed on the MII bus. 2901 * be placed on the MII bus.
2962 * 2902 *
2963 * This function sends on sequence of bits on the MII 2903 * This function sends on sequence of bits on the MII
2964 * configuration bus. 2904 * configuration bus.
2965 * 2905 *
2966 **************************************************************/ 2906 **************************************************************/
2967 2907
2968static void TLan_MiiSendData( u16 base_port, u32 data, unsigned num_bits ) 2908static void tlan_mii_send_data(u16 base_port, u32 data, unsigned num_bits)
2969{ 2909{
2970 u16 sio; 2910 u16 sio;
2971 u32 i; 2911 u32 i;
2972 2912
2973 if ( num_bits == 0 ) 2913 if (num_bits == 0)
2974 return; 2914 return;
2975 2915
2976 outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR ); 2916 outw(TLAN_NET_SIO, base_port + TLAN_DIO_ADR);
2977 sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO; 2917 sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
2978 TLan_SetBit( TLAN_NET_SIO_MTXEN, sio ); 2918 tlan_set_bit(TLAN_NET_SIO_MTXEN, sio);
2979 2919
2980 for ( i = ( 0x1 << ( num_bits - 1 ) ); i; i >>= 1 ) { 2920 for (i = (0x1 << (num_bits - 1)); i; i >>= 1) {
2981 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio ); 2921 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);
2982 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio ); 2922 (void) tlan_get_bit(TLAN_NET_SIO_MCLK, sio);
2983 if ( data & i ) 2923 if (data & i)
2984 TLan_SetBit( TLAN_NET_SIO_MDATA, sio ); 2924 tlan_set_bit(TLAN_NET_SIO_MDATA, sio);
2985 else 2925 else
2986 TLan_ClearBit( TLAN_NET_SIO_MDATA, sio ); 2926 tlan_clear_bit(TLAN_NET_SIO_MDATA, sio);
2987 TLan_SetBit( TLAN_NET_SIO_MCLK, sio ); 2927 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
2988 (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio ); 2928 (void) tlan_get_bit(TLAN_NET_SIO_MCLK, sio);
2989 } 2929 }
2990 2930
2991} /* TLan_MiiSendData */ 2931}
2992 2932
2993 2933
2994 2934
2995 2935
2996 /*************************************************************** 2936/***************************************************************
2997 * TLan_MiiSync 2937 * TLan_MiiSync
2998 * 2938 *
2999 * Returns: 2939 * Returns:
3000 * Nothing 2940 * Nothing
3001 * Parms: 2941 * Parms:
3002 * base_port The base IO port of the adapter in 2942 * base_port The base IO port of the adapter in
3003 * question. 2943 * question.
3004 * 2944 *
3005 * This functions syncs all PHYs in terms of the MII configuration 2945 * This functions syncs all PHYs in terms of the MII configuration
3006 * bus. 2946 * bus.
3007 * 2947 *
3008 **************************************************************/ 2948 **************************************************************/
3009 2949
3010static void TLan_MiiSync( u16 base_port ) 2950static void tlan_mii_sync(u16 base_port)
3011{ 2951{
3012 int i; 2952 int i;
3013 u16 sio; 2953 u16 sio;
3014 2954
3015 outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR ); 2955 outw(TLAN_NET_SIO, base_port + TLAN_DIO_ADR);
3016 sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO; 2956 sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
3017 2957
3018 TLan_ClearBit( TLAN_NET_SIO_MTXEN, sio ); 2958 tlan_clear_bit(TLAN_NET_SIO_MTXEN, sio);
3019 for ( i = 0; i < 32; i++ ) { 2959 for (i = 0; i < 32; i++) {
3020 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio ); 2960 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);
3021 TLan_SetBit( TLAN_NET_SIO_MCLK, sio ); 2961 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
3022 } 2962 }
3023 2963
3024} /* TLan_MiiSync */ 2964}
3025 2965
3026 2966
3027 2967
3028 2968
3029 /*************************************************************** 2969/***************************************************************
3030 * TLan_MiiWriteReg 2970 * tlan_mii_write_reg
3031 * 2971 *
3032 * Returns: 2972 * Returns:
3033 * Nothing 2973 * Nothing
3034 * Parms: 2974 * Parms:
3035 * dev The device structure for the device 2975 * dev The device structure for the device
3036 * to write to. 2976 * to write to.
3037 * phy The address of the PHY to be written to. 2977 * phy The address of the PHY to be written to.
3038 * reg The register whose contents are to be 2978 * reg The register whose contents are to be
3039 * written. 2979 * written.
3040 * val The value to be written to the register. 2980 * val The value to be written to the register.
3041 * 2981 *
3042 * This function uses the TLAN's MII bus to write the contents of a 2982 * This function uses the TLAN's MII bus to write the contents of a
3043 * given register on a PHY. It sends the appropriate info and then 2983 * given register on a PHY. It sends the appropriate info and then
3044 * writes the 16-bit register value from the MII configuration bus 2984 * writes the 16-bit register value from the MII configuration bus
3045 * via the TLAN SIO register. 2985 * via the TLAN SIO register.
3046 * 2986 *
3047 **************************************************************/ 2987 **************************************************************/
3048 2988
3049static void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val ) 2989static void
2990tlan_mii_write_reg(struct net_device *dev, u16 phy, u16 reg, u16 val)
3050{ 2991{
3051 u16 sio; 2992 u16 sio;
3052 int minten; 2993 int minten;
3053 unsigned long flags = 0; 2994 unsigned long flags = 0;
3054 TLanPrivateInfo *priv = netdev_priv(dev); 2995 struct tlan_priv *priv = netdev_priv(dev);
3055 2996
3056 outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR); 2997 outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
3057 sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO; 2998 sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
@@ -3059,30 +3000,30 @@ static void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val
3059 if (!in_irq()) 3000 if (!in_irq())
3060 spin_lock_irqsave(&priv->lock, flags); 3001 spin_lock_irqsave(&priv->lock, flags);
3061 3002
3062 TLan_MiiSync( dev->base_addr ); 3003 tlan_mii_sync(dev->base_addr);
3063 3004
3064 minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio ); 3005 minten = tlan_get_bit(TLAN_NET_SIO_MINTEN, sio);
3065 if ( minten ) 3006 if (minten)
3066 TLan_ClearBit( TLAN_NET_SIO_MINTEN, sio ); 3007 tlan_clear_bit(TLAN_NET_SIO_MINTEN, sio);
3067 3008
3068 TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Start ( 01b ) */ 3009 tlan_mii_send_data(dev->base_addr, 0x1, 2); /* start (01b) */
3069 TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Write ( 01b ) */ 3010 tlan_mii_send_data(dev->base_addr, 0x1, 2); /* write (01b) */
3070 TLan_MiiSendData( dev->base_addr, phy, 5 ); /* Device # */ 3011 tlan_mii_send_data(dev->base_addr, phy, 5); /* device # */
3071 TLan_MiiSendData( dev->base_addr, reg, 5 ); /* Register # */ 3012 tlan_mii_send_data(dev->base_addr, reg, 5); /* register # */
3072 3013
3073 TLan_MiiSendData( dev->base_addr, 0x2, 2 ); /* Send ACK */ 3014 tlan_mii_send_data(dev->base_addr, 0x2, 2); /* send ACK */
3074 TLan_MiiSendData( dev->base_addr, val, 16 ); /* Send Data */ 3015 tlan_mii_send_data(dev->base_addr, val, 16); /* send data */
3075 3016
3076 TLan_ClearBit( TLAN_NET_SIO_MCLK, sio ); /* Idle cycle */ 3017 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio); /* idle cycle */
3077 TLan_SetBit( TLAN_NET_SIO_MCLK, sio ); 3018 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
3078 3019
3079 if ( minten ) 3020 if (minten)
3080 TLan_SetBit( TLAN_NET_SIO_MINTEN, sio ); 3021 tlan_set_bit(TLAN_NET_SIO_MINTEN, sio);
3081 3022
3082 if (!in_irq()) 3023 if (!in_irq())
3083 spin_unlock_irqrestore(&priv->lock, flags); 3024 spin_unlock_irqrestore(&priv->lock, flags);
3084 3025
3085} /* TLan_MiiWriteReg */ 3026}
3086 3027
3087 3028
3088 3029
@@ -3090,229 +3031,226 @@ static void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val
3090/***************************************************************************** 3031/*****************************************************************************
3091****************************************************************************** 3032******************************************************************************
3092 3033
3093 ThunderLAN Driver Eeprom routines 3034ThunderLAN driver eeprom routines
3094 3035
3095 The Compaq Netelligent 10 and 10/100 cards use a Microchip 24C02A 3036the Compaq netelligent 10 and 10/100 cards use a microchip 24C02A
3096 EEPROM. These functions are based on information in Microchip's 3037EEPROM. these functions are based on information in microchip's
3097 data sheet. I don't know how well this functions will work with 3038data sheet. I don't know how well this functions will work with
3098 other EEPROMs. 3039other Eeproms.
3099 3040
3100****************************************************************************** 3041******************************************************************************
3101*****************************************************************************/ 3042*****************************************************************************/
3102 3043
3103 3044
3104 /*************************************************************** 3045/***************************************************************
3105 * TLan_EeSendStart 3046 * tlan_ee_send_start
3106 * 3047 *
3107 * Returns: 3048 * Returns:
3108 * Nothing 3049 * Nothing
3109 * Parms: 3050 * Parms:
3110 * io_base The IO port base address for the 3051 * io_base The IO port base address for the
3111 * TLAN device with the EEPROM to 3052 * TLAN device with the EEPROM to
3112 * use. 3053 * use.
3113 * 3054 *
3114 * This function sends a start cycle to an EEPROM attached 3055 * This function sends a start cycle to an EEPROM attached
3115 * to a TLAN chip. 3056 * to a TLAN chip.
3116 * 3057 *
3117 **************************************************************/ 3058 **************************************************************/
3118 3059
3119static void TLan_EeSendStart( u16 io_base ) 3060static void tlan_ee_send_start(u16 io_base)
3120{ 3061{
3121 u16 sio; 3062 u16 sio;
3122 3063
3123 outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR ); 3064 outw(TLAN_NET_SIO, io_base + TLAN_DIO_ADR);
3124 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO; 3065 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3125 3066
3126 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); 3067 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3127 TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); 3068 tlan_set_bit(TLAN_NET_SIO_EDATA, sio);
3128 TLan_SetBit( TLAN_NET_SIO_ETXEN, sio ); 3069 tlan_set_bit(TLAN_NET_SIO_ETXEN, sio);
3129 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); 3070 tlan_clear_bit(TLAN_NET_SIO_EDATA, sio);
3130 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio ); 3071 tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
3131 3072
3132} /* TLan_EeSendStart */ 3073}
3133 3074
3134 3075
3135 3076
3136 3077
3137 /*************************************************************** 3078/***************************************************************
3138 * TLan_EeSendByte 3079 * tlan_ee_send_byte
3139 * 3080 *
3140 * Returns: 3081 * Returns:
3141 * If the correct ack was received, 0, otherwise 1 3082 * If the correct ack was received, 0, otherwise 1
3142 * Parms: io_base The IO port base address for the 3083 * Parms: io_base The IO port base address for the
3143 * TLAN device with the EEPROM to 3084 * TLAN device with the EEPROM to
3144 * use. 3085 * use.
3145 * data The 8 bits of information to 3086 * data The 8 bits of information to
3146 * send to the EEPROM. 3087 * send to the EEPROM.
3147 * stop If TLAN_EEPROM_STOP is passed, a 3088 * stop If TLAN_EEPROM_STOP is passed, a
3148 * stop cycle is sent after the 3089 * stop cycle is sent after the
3149 * byte is sent after the ack is 3090 * byte is sent after the ack is
3150 * read. 3091 * read.
3151 * 3092 *
3152 * This function sends a byte on the serial EEPROM line, 3093 * This function sends a byte on the serial EEPROM line,
3153 * driving the clock to send each bit. The function then 3094 * driving the clock to send each bit. The function then
3154 * reverses transmission direction and reads an acknowledge 3095 * reverses transmission direction and reads an acknowledge
3155 * bit. 3096 * bit.
3156 * 3097 *
3157 **************************************************************/ 3098 **************************************************************/
3158 3099
3159static int TLan_EeSendByte( u16 io_base, u8 data, int stop ) 3100static int tlan_ee_send_byte(u16 io_base, u8 data, int stop)
3160{ 3101{
3161 int err; 3102 int err;
3162 u8 place; 3103 u8 place;
3163 u16 sio; 3104 u16 sio;
3164 3105
3165 outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR ); 3106 outw(TLAN_NET_SIO, io_base + TLAN_DIO_ADR);
3166 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO; 3107 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3167 3108
3168 /* Assume clock is low, tx is enabled; */ 3109 /* Assume clock is low, tx is enabled; */
3169 for ( place = 0x80; place != 0; place >>= 1 ) { 3110 for (place = 0x80; place != 0; place >>= 1) {
3170 if ( place & data ) 3111 if (place & data)
3171 TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); 3112 tlan_set_bit(TLAN_NET_SIO_EDATA, sio);
3172 else 3113 else
3173 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); 3114 tlan_clear_bit(TLAN_NET_SIO_EDATA, sio);
3174 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); 3115 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3175 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio ); 3116 tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
3176 } 3117 }
3177 TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio ); 3118 tlan_clear_bit(TLAN_NET_SIO_ETXEN, sio);
3178 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); 3119 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3179 err = TLan_GetBit( TLAN_NET_SIO_EDATA, sio ); 3120 err = tlan_get_bit(TLAN_NET_SIO_EDATA, sio);
3180 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio ); 3121 tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
3181 TLan_SetBit( TLAN_NET_SIO_ETXEN, sio ); 3122 tlan_set_bit(TLAN_NET_SIO_ETXEN, sio);
3182 3123
3183 if ( ( ! err ) && stop ) { 3124 if ((!err) && stop) {
3184 /* STOP, raise data while clock is high */ 3125 /* STOP, raise data while clock is high */
3185 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); 3126 tlan_clear_bit(TLAN_NET_SIO_EDATA, sio);
3186 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); 3127 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3187 TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); 3128 tlan_set_bit(TLAN_NET_SIO_EDATA, sio);
3188 } 3129 }
3189 3130
3190 return ( err ); 3131 return err;
3191 3132
3192} /* TLan_EeSendByte */ 3133}
3193 3134
3194 3135
3195 3136
3196 3137
3197 /*************************************************************** 3138/***************************************************************
3198 * TLan_EeReceiveByte 3139 * tlan_ee_receive_byte
3199 * 3140 *
3200 * Returns: 3141 * Returns:
3201 * Nothing 3142 * Nothing
3202 * Parms: 3143 * Parms:
3203 * io_base The IO port base address for the 3144 * io_base The IO port base address for the
3204 * TLAN device with the EEPROM to 3145 * TLAN device with the EEPROM to
3205 * use. 3146 * use.
3206 * data An address to a char to hold the 3147 * data An address to a char to hold the
3207 * data sent from the EEPROM. 3148 * data sent from the EEPROM.
3208 * stop If TLAN_EEPROM_STOP is passed, a 3149 * stop If TLAN_EEPROM_STOP is passed, a
3209 * stop cycle is sent after the 3150 * stop cycle is sent after the
3210 * byte is received, and no ack is 3151 * byte is received, and no ack is
3211 * sent. 3152 * sent.
3212 * 3153 *
3213 * This function receives 8 bits of data from the EEPROM 3154 * This function receives 8 bits of data from the EEPROM
3214 * over the serial link. It then sends and ack bit, or no 3155 * over the serial link. It then sends and ack bit, or no
3215 * ack and a stop bit. This function is used to retrieve 3156 * ack and a stop bit. This function is used to retrieve
3216 * data after the address of a byte in the EEPROM has been 3157 * data after the address of a byte in the EEPROM has been
3217 * sent. 3158 * sent.
3218 * 3159 *
3219 **************************************************************/ 3160 **************************************************************/
3220 3161
3221static void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop ) 3162static void tlan_ee_receive_byte(u16 io_base, u8 *data, int stop)
3222{ 3163{
3223 u8 place; 3164 u8 place;
3224 u16 sio; 3165 u16 sio;
3225 3166
3226 outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR ); 3167 outw(TLAN_NET_SIO, io_base + TLAN_DIO_ADR);
3227 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO; 3168 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3228 *data = 0; 3169 *data = 0;
3229 3170
3230 /* Assume clock is low, tx is enabled; */ 3171 /* Assume clock is low, tx is enabled; */
3231 TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio ); 3172 tlan_clear_bit(TLAN_NET_SIO_ETXEN, sio);
3232 for ( place = 0x80; place; place >>= 1 ) { 3173 for (place = 0x80; place; place >>= 1) {
3233 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); 3174 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3234 if ( TLan_GetBit( TLAN_NET_SIO_EDATA, sio ) ) 3175 if (tlan_get_bit(TLAN_NET_SIO_EDATA, sio))
3235 *data |= place; 3176 *data |= place;
3236 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio ); 3177 tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
3237 } 3178 }
3238 3179
3239 TLan_SetBit( TLAN_NET_SIO_ETXEN, sio ); 3180 tlan_set_bit(TLAN_NET_SIO_ETXEN, sio);
3240 if ( ! stop ) { 3181 if (!stop) {
3241 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); /* Ack = 0 */ 3182 tlan_clear_bit(TLAN_NET_SIO_EDATA, sio); /* ack = 0 */
3242 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); 3183 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3243 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio ); 3184 tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
3244 } else { 3185 } else {
3245 TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); /* No ack = 1 (?) */ 3186 tlan_set_bit(TLAN_NET_SIO_EDATA, sio); /* no ack = 1 (?) */
3246 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); 3187 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3247 TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio ); 3188 tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
3248 /* STOP, raise data while clock is high */ 3189 /* STOP, raise data while clock is high */
3249 TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); 3190 tlan_clear_bit(TLAN_NET_SIO_EDATA, sio);
3250 TLan_SetBit( TLAN_NET_SIO_ECLOK, sio ); 3191 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3251 TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); 3192 tlan_set_bit(TLAN_NET_SIO_EDATA, sio);
3252 } 3193 }
3253 3194
3254} /* TLan_EeReceiveByte */ 3195}
3255 3196
3256 3197
3257 3198
3258 3199
3259 /*************************************************************** 3200/***************************************************************
3260 * TLan_EeReadByte 3201 * tlan_ee_read_byte
3261 * 3202 *
3262 * Returns: 3203 * Returns:
3263 * No error = 0, else, the stage at which the error 3204 * No error = 0, else, the stage at which the error
3264 * occurred. 3205 * occurred.
3265 * Parms: 3206 * Parms:
3266 * io_base The IO port base address for the 3207 * io_base The IO port base address for the
3267 * TLAN device with the EEPROM to 3208 * TLAN device with the EEPROM to
3268 * use. 3209 * use.
3269 * ee_addr The address of the byte in the 3210 * ee_addr The address of the byte in the
3270 * EEPROM whose contents are to be 3211 * EEPROM whose contents are to be
3271 * retrieved. 3212 * retrieved.
3272 * data An address to a char to hold the 3213 * data An address to a char to hold the
3273 * data obtained from the EEPROM. 3214 * data obtained from the EEPROM.
3274 * 3215 *
3275 * This function reads a byte of information from an byte 3216 * This function reads a byte of information from an byte
3276 * cell in the EEPROM. 3217 * cell in the EEPROM.
3277 * 3218 *
3278 **************************************************************/ 3219 **************************************************************/
3279 3220
3280static int TLan_EeReadByte( struct net_device *dev, u8 ee_addr, u8 *data ) 3221static int tlan_ee_read_byte(struct net_device *dev, u8 ee_addr, u8 *data)
3281{ 3222{
3282 int err; 3223 int err;
3283 TLanPrivateInfo *priv = netdev_priv(dev); 3224 struct tlan_priv *priv = netdev_priv(dev);
3284 unsigned long flags = 0; 3225 unsigned long flags = 0;
3285 int ret=0; 3226 int ret = 0;
3286 3227
3287 spin_lock_irqsave(&priv->lock, flags); 3228 spin_lock_irqsave(&priv->lock, flags);
3288 3229
3289 TLan_EeSendStart( dev->base_addr ); 3230 tlan_ee_send_start(dev->base_addr);
3290 err = TLan_EeSendByte( dev->base_addr, 0xA0, TLAN_EEPROM_ACK ); 3231 err = tlan_ee_send_byte(dev->base_addr, 0xa0, TLAN_EEPROM_ACK);
3291 if (err) 3232 if (err) {
3292 { 3233 ret = 1;
3293 ret=1;
3294 goto fail; 3234 goto fail;
3295 } 3235 }
3296 err = TLan_EeSendByte( dev->base_addr, ee_addr, TLAN_EEPROM_ACK ); 3236 err = tlan_ee_send_byte(dev->base_addr, ee_addr, TLAN_EEPROM_ACK);
3297 if (err) 3237 if (err) {
3298 { 3238 ret = 2;
3299 ret=2;
3300 goto fail; 3239 goto fail;
3301 } 3240 }
3302 TLan_EeSendStart( dev->base_addr ); 3241 tlan_ee_send_start(dev->base_addr);
3303 err = TLan_EeSendByte( dev->base_addr, 0xA1, TLAN_EEPROM_ACK ); 3242 err = tlan_ee_send_byte(dev->base_addr, 0xa1, TLAN_EEPROM_ACK);
3304 if (err) 3243 if (err) {
3305 { 3244 ret = 3;
3306 ret=3;
3307 goto fail; 3245 goto fail;
3308 } 3246 }
3309 TLan_EeReceiveByte( dev->base_addr, data, TLAN_EEPROM_STOP ); 3247 tlan_ee_receive_byte(dev->base_addr, data, TLAN_EEPROM_STOP);
3310fail: 3248fail:
3311 spin_unlock_irqrestore(&priv->lock, flags); 3249 spin_unlock_irqrestore(&priv->lock, flags);
3312 3250
3313 return ret; 3251 return ret;
3314 3252
3315} /* TLan_EeReadByte */ 3253}
3316 3254
3317 3255
3318 3256
generated by cgit v1.2.2 (git 2.25.0) at 2025-09-15 06:25:03 -0400