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