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