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