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