projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'linux-can-next-for-4.8-20160617' of git://git.kernel.org/pub/scm/linux...
[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);
860e9538 1010 netif_trans_update(dev); /* 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
c659c38b
SA		 1654 if (priv->tlan_rev < 0x30) {
1655 TLAN_DBG(TLAN_DEBUG_TX,
1656 "TRANSMIT: handling TX EOC (Head=%d Tail=%d) -- IRQ\n",
1657 priv->tx_head, priv->tx_tail);
1658 head_list = priv->tx_list + priv->tx_head;
1659 head_list_phys = priv->tx_list_dma
1660 + sizeof(struct tlan_list)*priv->tx_head;
f45437ef
SA		 1661 if ((head_list->c_stat & TLAN_CSTAT_READY)
1662 == TLAN_CSTAT_READY) {
1da177e4 1663 netif_stop_queue(dev);
c659c38b 1664 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM);
1da177e4
LT		 1665 ack |= TLAN_HC_GO;
1666 } else {
c659c38b 1667 priv->tx_in_progress = 0;
1da177e4
LT		 1668 }
1669 }
1670
1671 return ack;
1672
c659c38b 1673}
1da177e4
LT		 1674
1675
1676
1677
c659c38b
SA		 1678/***************************************************************
1679 * tlan_handle_status_check
1680 *
1681 * Returns:
1682 * 0 if Adapter check, 1 if Network Status check.
1683 * Parms:
1684 * dev Device assigned the IRQ that was
1685 * raised.
1686 * host_int The contents of the HOST_INT
1687 * port.
1688 *
1689 * This function handles Adapter Check/Network Status
1690 * interrupts generated by the adapter. It checks the
1691 * vector in the HOST_INT register to determine if it is
1692 * an Adapter Check interrupt. If so, it resets the
1693 * adapter. Otherwise it clears the status registers
1694 * and services the PHY.
1695 *
1696 **************************************************************/
1da177e4 1697
c659c38b 1698static u32 tlan_handle_status_check(struct net_device *dev, u16 host_int)
6aa20a22 1699{
c659c38b 1700 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 1701 u32 ack;
1702 u32 error;
1703 u8 net_sts;
1704 u32 phy;
1705 u16 tlphy_ctl;
1706 u16 tlphy_sts;
6aa20a22 1707
1da177e4 1708 ack = 1;
c659c38b
SA		 1709 if (host_int & TLAN_HI_IV_MASK) {
1710 netif_stop_queue(dev);
1711 error = inl(dev->base_addr + TLAN_CH_PARM);
50624aab 1712 netdev_info(dev, "Adaptor Error = 0x%x\n", error);
c659c38b
SA		 1713 tlan_read_and_clear_stats(dev, TLAN_RECORD);
1714 outl(TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD);
1da177e4
LT		 1715
1716 schedule_work(&priv->tlan_tqueue);
1717
1718 netif_wake_queue(dev);
1719 ack = 0;
1720 } else {
c659c38b
SA		 1721 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Status Check\n", dev->name);
1722 phy = priv->phy[priv->phy_num];
1723
1724 net_sts = tlan_dio_read8(dev->base_addr, TLAN_NET_STS);
1725 if (net_sts) {
1726 tlan_dio_write8(dev->base_addr, TLAN_NET_STS, net_sts);
1727 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Net_Sts = %x\n",
1728 dev->name, (unsigned) net_sts);
1da177e4 1729 }
c659c38b
SA		 1730 if ((net_sts & TLAN_NET_STS_MIRQ) && (priv->phy_num == 0)) {
1731 tlan_mii_read_reg(dev, phy, TLAN_TLPHY_STS, &tlphy_sts);
1732 tlan_mii_read_reg(dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl);
1733 if (!(tlphy_sts & TLAN_TS_POLOK) &&
1734 !(tlphy_ctl & TLAN_TC_SWAPOL)) {
1735 tlphy_ctl |= TLAN_TC_SWAPOL;
1736 tlan_mii_write_reg(dev, phy, TLAN_TLPHY_CTL,
1737 tlphy_ctl);
1738 } else if ((tlphy_sts & TLAN_TS_POLOK) &&
1739 (tlphy_ctl & TLAN_TC_SWAPOL)) {
1740 tlphy_ctl &= ~TLAN_TC_SWAPOL;
1741 tlan_mii_write_reg(dev, phy, TLAN_TLPHY_CTL,
1742 tlphy_ctl);
1da177e4 1743 }
c659c38b
SA		 1744
1745 if (debug)
1746 tlan_phy_print(dev);
1da177e4
LT		 1747 }
1748 }
1749
1750 return ack;
1751
c659c38b 1752}
1da177e4
LT		 1753
1754
1755
1756
c659c38b
SA		 1757/***************************************************************
1758 * tlan_handle_rx_eoc
1759 *
1760 * Returns:
1761 * 1
1762 * Parms:
1763 * dev Device assigned the IRQ that was
1764 * raised.
1765 * host_int The contents of the HOST_INT
1766 * port.
1767 *
1768 * This driver is structured to determine EOC occurrences by
1769 * reading the CSTAT member of the list structure. Rx EOC
1770 * interrupts are disabled via the DIO INTDIS register.
1771 * However, TLAN chips before revision 3.0 didn't have this
1772 * CSTAT member or a INTDIS register, so if this chip is
1773 * pre-3.0, process EOC interrupts normally.
1774 *
1775 **************************************************************/
1da177e4 1776
c659c38b 1777static u32 tlan_handle_rx_eoc(struct net_device *dev, u16 host_int)
1da177e4 1778{
c659c38b 1779 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 1780 dma_addr_t head_list_phys;
1781 u32 ack = 1;
1782
c659c38b
SA		 1783 if (priv->tlan_rev < 0x30) {
1784 TLAN_DBG(TLAN_DEBUG_RX,
1785 "RECEIVE: Handling RX EOC (head=%d tail=%d) -- IRQ\n",
1786 priv->rx_head, priv->rx_tail);
1787 head_list_phys = priv->rx_list_dma
1788 + sizeof(struct tlan_list)*priv->rx_head;
1789 outl(head_list_phys, dev->base_addr + TLAN_CH_PARM);
1da177e4 1790 ack |= TLAN_HC_GO | TLAN_HC_RT;
c659c38b 1791 priv->rx_eoc_count++;
1da177e4
LT		 1792 }
1793
1794 return ack;
1795
c659c38b 1796}
1da177e4
LT		 1797
1798
1799
1800
1801/*****************************************************************************
1802******************************************************************************
1803
c659c38b 1804ThunderLAN driver timer function
1da177e4
LT		 1805
1806******************************************************************************
1807*****************************************************************************/
1808
1809
c659c38b
SA		 1810/***************************************************************
1811 * tlan_timer
1812 *
1813 * Returns:
1814 * Nothing
1815 * Parms:
1816 * data A value given to add timer when
1817 * add_timer was called.
1818 *
1819 * This function handles timed functionality for the
1820 * TLAN driver. The two current timer uses are for
1821 * delaying for autonegotionation and driving the ACT LED.
1822 * - Autonegotiation requires being allowed about
1823 * 2 1/2 seconds before attempting to transmit a
1824 * packet. It would be a very bad thing to hang
1825 * the kernel this long, so the driver doesn't
1826 * allow transmission 'til after this time, for
1827 * certain PHYs. It would be much nicer if all
1828 * PHYs were interrupt-capable like the internal
1829 * PHY.
1830 * - The ACT LED, which shows adapter activity, is
1831 * driven by the driver, and so must be left on
1832 * for a short period to power up the LED so it
1833 * can be seen. This delay can be changed by
1834 * changing the TLAN_TIMER_ACT_DELAY in tlan.h,
1835 * if desired. 100 ms produces a slightly
1836 * sluggish response.
1837 *
1838 **************************************************************/
1839
1840static void tlan_timer(unsigned long data)
1da177e4
LT		 1841{
1842 struct net_device *dev = (struct net_device *) data;
c659c38b 1843 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 1844 u32 elapsed;
1845 unsigned long flags = 0;
1846
1847 priv->timer.function = NULL;
1848
c659c38b 1849 switch (priv->timer_type) {
c659c38b
SA		 1850 case TLAN_TIMER_PHY_PDOWN:
1851 tlan_phy_power_down(dev);
1852 break;
1853 case TLAN_TIMER_PHY_PUP:
1854 tlan_phy_power_up(dev);
1855 break;
1856 case TLAN_TIMER_PHY_RESET:
1857 tlan_phy_reset(dev);
1858 break;
1859 case TLAN_TIMER_PHY_START_LINK:
1860 tlan_phy_start_link(dev);
1861 break;
1862 case TLAN_TIMER_PHY_FINISH_AN:
1863 tlan_phy_finish_auto_neg(dev);
1864 break;
1865 case TLAN_TIMER_FINISH_RESET:
1866 tlan_finish_reset(dev);
1867 break;
1868 case TLAN_TIMER_ACTIVITY:
1869 spin_lock_irqsave(&priv->lock, flags);
1870 if (priv->timer.function == NULL) {
1871 elapsed = jiffies - priv->timer_set_at;
1872 if (elapsed >= TLAN_TIMER_ACT_DELAY) {
1873 tlan_dio_write8(dev->base_addr,
1874 TLAN_LED_REG, TLAN_LED_LINK);
1875 } else {
1876 priv->timer.function = tlan_timer;
1877 priv->timer.expires = priv->timer_set_at
1878 + TLAN_TIMER_ACT_DELAY;
1879 spin_unlock_irqrestore(&priv->lock, flags);
1880 add_timer(&priv->timer);
1881 break;
1da177e4 1882 }
c659c38b
SA		 1883 }
1884 spin_unlock_irqrestore(&priv->lock, flags);
1885 break;
1886 default:
1887 break;
1da177e4
LT		 1888 }
1889
c659c38b 1890}
1da177e4
LT		 1891
1892
1da177e4
LT		 1893/*****************************************************************************
1894******************************************************************************
1895
c659c38b 1896ThunderLAN driver adapter related routines
1da177e4
LT		 1897
1898******************************************************************************
1899*****************************************************************************/
1900
1901
c659c38b
SA		 1902/***************************************************************
1903 * tlan_reset_lists
1904 *
1905 * Returns:
1906 * Nothing
1907 * Parms:
1908 * dev The device structure with the list
1909 * stuctures to be reset.
1910 *
1911 * This routine sets the variables associated with managing
1912 * the TLAN lists to their initial values.
1913 *
1914 **************************************************************/
1915
1916static void tlan_reset_lists(struct net_device *dev)
1da177e4 1917{
c659c38b 1918 struct tlan_priv *priv = netdev_priv(dev);
1da177e4 1919 int i;
c659c38b 1920 struct tlan_list *list;
1da177e4
LT		 1921 dma_addr_t list_phys;
1922 struct sk_buff *skb;
1da177e4 1923
c659c38b
SA		 1924 priv->tx_head = 0;
1925 priv->tx_tail = 0;
1926 for (i = 0; i < TLAN_NUM_TX_LISTS; i++) {
1927 list = priv->tx_list + i;
1928 list->c_stat = TLAN_CSTAT_UNUSED;
5eeabf51 1929 list->buffer[0].address = 0;
1da177e4
LT		 1930 list->buffer[2].count = 0;
1931 list->buffer[2].address = 0;
1932 list->buffer[8].address = 0;
1933 list->buffer[9].address = 0;
1934 }
1935
c659c38b
SA		 1936 priv->rx_head = 0;
1937 priv->rx_tail = TLAN_NUM_RX_LISTS - 1;
1938 for (i = 0; i < TLAN_NUM_RX_LISTS; i++) {
1939 list = priv->rx_list + i;
1940 list_phys = priv->rx_list_dma + sizeof(struct tlan_list)*i;
1941 list->c_stat = TLAN_CSTAT_READY;
1942 list->frame_size = TLAN_MAX_FRAME_SIZE;
1da177e4 1943 list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER;
89d71a66 1944 skb = netdev_alloc_skb_ip_align(dev, TLAN_MAX_FRAME_SIZE + 5);
720a43ef 1945 if (!skb)
5eeabf51 1946 break;
5eeabf51 1947
c659c38b 1948 list->buffer[0].address = pci_map_single(priv->pci_dev,
5eeabf51
SA		 1949 skb->data,
1950 TLAN_MAX_FRAME_SIZE,
1951 PCI_DMA_FROMDEVICE);
c659c38b 1952 tlan_store_skb(list, skb);
1da177e4
LT		 1953 list->buffer[1].count = 0;
1954 list->buffer[1].address = 0;
c659c38b 1955 list->forward = list_phys + sizeof(struct tlan_list);
9ded65a1
SH		 1956 }
1957
1958 /* in case ran out of memory early, clear bits */
1959 while (i < TLAN_NUM_RX_LISTS) {
c659c38b 1960 tlan_store_skb(priv->rx_list + i, NULL);
9ded65a1 1961 ++i;
1da177e4 1962 }
9ded65a1 1963 list->forward = 0;
1da177e4 1964
c659c38b 1965}
1da177e4
LT		 1966
1967
c659c38b 1968static void tlan_free_lists(struct net_device *dev)
1da177e4 1969{
c659c38b 1970 struct tlan_priv *priv = netdev_priv(dev);
1da177e4 1971 int i;
c659c38b 1972 struct tlan_list *list;
1da177e4
LT		 1973 struct sk_buff *skb;
1974
c659c38b
SA		 1975 for (i = 0; i < TLAN_NUM_TX_LISTS; i++) {
1976 list = priv->tx_list + i;
1977 skb = tlan_get_skb(list);
1978 if (skb) {
5eeabf51 1979 pci_unmap_single(
c659c38b 1980 priv->pci_dev,
5eeabf51
SA		 1981 list->buffer[0].address,
1982 max(skb->len,
1983 (unsigned int)TLAN_MIN_FRAME_SIZE),
1984 PCI_DMA_TODEVICE);
c659c38b 1985 dev_kfree_skb_any(skb);
5eeabf51
SA		 1986 list->buffer[8].address = 0;
1987 list->buffer[9].address = 0;
1da177e4 1988 }
5eeabf51 1989 }
1da177e4 1990
c659c38b
SA		 1991 for (i = 0; i < TLAN_NUM_RX_LISTS; i++) {
1992 list = priv->rx_list + i;
1993 skb = tlan_get_skb(list);
1994 if (skb) {
1995 pci_unmap_single(priv->pci_dev,
5eeabf51
SA		 1996 list->buffer[0].address,
1997 TLAN_MAX_FRAME_SIZE,
1998 PCI_DMA_FROMDEVICE);
c659c38b 1999 dev_kfree_skb_any(skb);
5eeabf51
SA		 2000 list->buffer[8].address = 0;
2001 list->buffer[9].address = 0;
1da177e4
LT		 2002 }
2003 }
c659c38b 2004}
1da177e4
LT		 2005
2006
2007
2008
c659c38b
SA		 2009/***************************************************************
2010 * tlan_print_dio
2011 *
2012 * Returns:
2013 * Nothing
2014 * Parms:
2015 * io_base Base IO port of the device of
2016 * which to print DIO registers.
2017 *
2018 * This function prints out all the internal (DIO)
2019 * registers of a TLAN chip.
2020 *
2021 **************************************************************/
1da177e4 2022
c659c38b 2023static void tlan_print_dio(u16 io_base)
1da177e4
LT		 2024{
2025 u32 data0, data1;
2026 int i;
2027
50624aab
JP		 2028 pr_info("Contents of internal registers for io base 0x%04hx\n",
2029 io_base);
2030 pr_info("Off. +0 +4\n");
c659c38b
SA		 2031 for (i = 0; i < 0x4C; i += 8) {
2032 data0 = tlan_dio_read32(io_base, i);
2033 data1 = tlan_dio_read32(io_base, i + 0x4);
50624aab 2034 pr_info("0x%02x 0x%08x 0x%08x\n", i, data0, data1);
1da177e4
LT		 2035 }
2036
c659c38b 2037}
1da177e4
LT		 2038
2039
2040
2041
c659c38b
SA		 2042/***************************************************************
2043 * TLan_PrintList
2044 *
2045 * Returns:
2046 * Nothing
2047 * Parms:
2048 * list A pointer to the struct tlan_list structure to
2049 * be printed.
2050 * type A string to designate type of list,
2051 * "Rx" or "Tx".
2052 * num The index of the list.
2053 *
2054 * This function prints out the contents of the list
2055 * pointed to by the list parameter.
2056 *
2057 **************************************************************/
1da177e4 2058
c659c38b 2059static void tlan_print_list(struct tlan_list *list, char *type, int num)
1da177e4
LT		 2060{
2061 int i;
2062
50624aab
JP		 2063 pr_info("%s List %d at %p\n", type, num, list);
2064 pr_info(" Forward = 0x%08x\n", list->forward);
2065 pr_info(" CSTAT = 0x%04hx\n", list->c_stat);
2066 pr_info(" Frame Size = 0x%04hx\n", list->frame_size);
c659c38b
SA		 2067 /* for (i = 0; i < 10; i++) { */
2068 for (i = 0; i < 2; i++) {
50624aab
JP		 2069 pr_info(" Buffer[%d].count, addr = 0x%08x, 0x%08x\n",
2070 i, list->buffer[i].count, list->buffer[i].address);
1da177e4
LT		 2071 }
2072
c659c38b 2073}
1da177e4
LT		 2074
2075
2076
2077
c659c38b
SA		 2078/***************************************************************
2079 * tlan_read_and_clear_stats
2080 *
2081 * Returns:
2082 * Nothing
2083 * Parms:
2084 * dev Pointer to device structure of adapter
2085 * to which to read stats.
2086 * record Flag indicating whether to add
2087 *
2088 * This functions reads all the internal status registers
2089 * of the TLAN chip, which clears them as a side effect.
2090 * It then either adds the values to the device's status
2091 * struct, or discards them, depending on whether record
2092 * is TLAN_RECORD (!=0) or TLAN_IGNORE (==0).
2093 *
2094 **************************************************************/
1da177e4 2095
c659c38b 2096static void tlan_read_and_clear_stats(struct net_device *dev, int record)
1da177e4 2097{
1da177e4
LT		 2098 u32 tx_good, tx_under;
2099 u32 rx_good, rx_over;
2100 u32 def_tx, crc, code;
2101 u32 multi_col, single_col;
2102 u32 excess_col, late_col, loss;
2103
c659c38b
SA		 2104 outw(TLAN_GOOD_TX_FRMS, dev->base_addr + TLAN_DIO_ADR);
2105 tx_good = inb(dev->base_addr + TLAN_DIO_DATA);
2106 tx_good += inb(dev->base_addr + TLAN_DIO_DATA + 1) << 8;
2107 tx_good += inb(dev->base_addr + TLAN_DIO_DATA + 2) << 16;
2108 tx_under = inb(dev->base_addr + TLAN_DIO_DATA + 3);
2109
2110 outw(TLAN_GOOD_RX_FRMS, dev->base_addr + TLAN_DIO_ADR);
2111 rx_good = inb(dev->base_addr + TLAN_DIO_DATA);
2112 rx_good += inb(dev->base_addr + TLAN_DIO_DATA + 1) << 8;
2113 rx_good += inb(dev->base_addr + TLAN_DIO_DATA + 2) << 16;
2114 rx_over = inb(dev->base_addr + TLAN_DIO_DATA + 3);
2115
2116 outw(TLAN_DEFERRED_TX, dev->base_addr + TLAN_DIO_ADR);
2117 def_tx = inb(dev->base_addr + TLAN_DIO_DATA);
2118 def_tx += inb(dev->base_addr + TLAN_DIO_DATA + 1) << 8;
2119 crc = inb(dev->base_addr + TLAN_DIO_DATA + 2);
2120 code = inb(dev->base_addr + TLAN_DIO_DATA + 3);
2121
2122 outw(TLAN_MULTICOL_FRMS, dev->base_addr + TLAN_DIO_ADR);
2123 multi_col = inb(dev->base_addr + TLAN_DIO_DATA);
2124 multi_col += inb(dev->base_addr + TLAN_DIO_DATA + 1) << 8;
2125 single_col = inb(dev->base_addr + TLAN_DIO_DATA + 2);
2126 single_col += inb(dev->base_addr + TLAN_DIO_DATA + 3) << 8;
2127
2128 outw(TLAN_EXCESSCOL_FRMS, dev->base_addr + TLAN_DIO_ADR);
2129 excess_col = inb(dev->base_addr + TLAN_DIO_DATA);
2130 late_col = inb(dev->base_addr + TLAN_DIO_DATA + 1);
2131 loss = inb(dev->base_addr + TLAN_DIO_DATA + 2);
2132
2133 if (record) {
f8f31544
SH		 2134 dev->stats.rx_packets += rx_good;
2135 dev->stats.rx_errors += rx_over + crc + code;
2136 dev->stats.tx_packets += tx_good;
2137 dev->stats.tx_errors += tx_under + loss;
c659c38b
SA		 2138 dev->stats.collisions += multi_col
2139 + single_col + excess_col + late_col;
f8f31544
SH		 2140
2141 dev->stats.rx_over_errors += rx_over;
2142 dev->stats.rx_crc_errors += crc;
2143 dev->stats.rx_frame_errors += code;
2144
2145 dev->stats.tx_aborted_errors += tx_under;
2146 dev->stats.tx_carrier_errors += loss;
1da177e4 2147 }
6aa20a22 2148
c659c38b 2149}
1da177e4
LT		 2150
2151
2152
2153
c659c38b
SA		 2154/***************************************************************
2155 * TLan_Reset
2156 *
2157 * Returns:
2158 * 0
2159 * Parms:
2160 * dev Pointer to device structure of adapter
2161 * to be reset.
2162 *
2163 * This function resets the adapter and it's physical
2164 * device. See Chap. 3, pp. 9-10 of the "ThunderLAN
2165 * Programmer's Guide" for details. The routine tries to
2166 * implement what is detailed there, though adjustments
2167 * have been made.
2168 *
2169 **************************************************************/
1da177e4 2170
98e0f521 2171static void
c659c38b 2172tlan_reset_adapter(struct net_device *dev)
1da177e4 2173{
c659c38b 2174 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 2175 int i;
2176 u32 addr;
2177 u32 data;
2178 u8 data8;
2179
c659c38b
SA		 2180 priv->tlan_full_duplex = false;
2181 priv->phy_online = 0;
1da177e4
LT		 2182 netif_carrier_off(dev);
2183
2184/* 1. Assert reset bit. */
2185
2186 data = inl(dev->base_addr + TLAN_HOST_CMD);
2187 data |= TLAN_HC_AD_RST;
2188 outl(data, dev->base_addr + TLAN_HOST_CMD);
6aa20a22 2189
1da177e4
LT		 2190 udelay(1000);
2191
c659c38b 2192/* 2. Turn off interrupts. (Probably isn't necessary) */
1da177e4
LT		 2193
2194 data = inl(dev->base_addr + TLAN_HOST_CMD);
2195 data |= TLAN_HC_INT_OFF;
2196 outl(data, dev->base_addr + TLAN_HOST_CMD);
2197
2198/* 3. Clear AREGs and HASHs. */
2199
c659c38b
SA		 2200 for (i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4)
2201 tlan_dio_write32(dev->base_addr, (u16) i, 0);
1da177e4
LT		 2202
2203/* 4. Setup NetConfig register. */
2204
2205 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
c659c38b 2206 tlan_dio_write16(dev->base_addr, TLAN_NET_CONFIG, (u16) data);
1da177e4
LT		 2207
2208/* 5. Load Ld_Tmr and Ld_Thr in HOST_CMD. */
2209
c659c38b
SA		 2210 outl(TLAN_HC_LD_TMR | 0x3f, dev->base_addr + TLAN_HOST_CMD);
2211 outl(TLAN_HC_LD_THR | 0x9, dev->base_addr + TLAN_HOST_CMD);
1da177e4
LT		 2212
2213/* 6. Unreset the MII by setting NMRST (in NetSio) to 1. */
2214
c659c38b 2215 outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
1da177e4 2216 addr = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
c659c38b 2217 tlan_set_bit(TLAN_NET_SIO_NMRST, addr);
1da177e4
LT		 2218
2219/* 7. Setup the remaining registers. */
2220
c659c38b 2221 if (priv->tlan_rev >= 0x30) {
1da177e4 2222 data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC;
c659c38b 2223 tlan_dio_write8(dev->base_addr, TLAN_INT_DIS, data8);
1da177e4 2224 }
c659c38b 2225 tlan_phy_detect(dev);
1da177e4 2226 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN;
6aa20a22 2227
c659c38b 2228 if (priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY) {
1da177e4 2229 data |= TLAN_NET_CFG_BIT;
c659c38b
SA		 2230 if (priv->aui == 1) {
2231 tlan_dio_write8(dev->base_addr, TLAN_ACOMMIT, 0x0a);
2232 } else if (priv->duplex == TLAN_DUPLEX_FULL) {
2233 tlan_dio_write8(dev->base_addr, TLAN_ACOMMIT, 0x00);
2234 priv->tlan_full_duplex = true;
1da177e4 2235 } else {
c659c38b 2236 tlan_dio_write8(dev->base_addr, TLAN_ACOMMIT, 0x08);
1da177e4
LT		 2237 }
2238 }
2239
7a72eddc
OZ		 2240 /* don't power down internal PHY if we're going to use it */
2241 if (priv->phy_num == 0 ||
2242 (priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10))
1da177e4 2243 data |= TLAN_NET_CFG_PHY_EN;
c659c38b 2244 tlan_dio_write16(dev->base_addr, TLAN_NET_CONFIG, (u16) data);
1da177e4 2245
c659c38b
SA		 2246 if (priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY)
2247 tlan_finish_reset(dev);
2248 else
2249 tlan_phy_power_down(dev);
1da177e4 2250
c659c38b 2251}
1da177e4
LT		 2252
2253
2254
2255
98e0f521 2256static void
c659c38b 2257tlan_finish_reset(struct net_device *dev)
1da177e4 2258{
c659c38b 2259 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 2260 u8 data;
2261 u32 phy;
2262 u8 sio;
2263 u16 status;
2264 u16 partner;
2265 u16 tlphy_ctl;
c659c38b 2266 u16 tlphy_par;
1da177e4 2267 u16 tlphy_id1, tlphy_id2;
c659c38b 2268 int i;
1da177e4 2269
c659c38b 2270 phy = priv->phy[priv->phy_num];
1da177e4
LT		 2271
2272 data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP;
c659c38b 2273 if (priv->tlan_full_duplex)
1da177e4 2274 data |= TLAN_NET_CMD_DUPLEX;
c659c38b 2275 tlan_dio_write8(dev->base_addr, TLAN_NET_CMD, data);
6aa20a22 2276 data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5;
c659c38b 2277 if (priv->phy_num == 0)
6aa20a22 2278 data |= TLAN_NET_MASK_MASK7;
c659c38b
SA		 2279 tlan_dio_write8(dev->base_addr, TLAN_NET_MASK, data);
2280 tlan_dio_write16(dev->base_addr, TLAN_MAX_RX, ((1536)+7)&~7);
2281 tlan_mii_read_reg(dev, phy, MII_GEN_ID_HI, &tlphy_id1);
2282 tlan_mii_read_reg(dev, phy, MII_GEN_ID_LO, &tlphy_id2);
6aa20a22 2283
c659c38b
SA		 2284 if ((priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY) ||
2285 (priv->aui)) {
1da177e4 2286 status = MII_GS_LINK;
50624aab 2287 netdev_info(dev, "Link forced\n");
1da177e4 2288 } else {
c659c38b
SA		 2289 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
2290 udelay(1000);
2291 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
c0a87c22
OZ		 2292 if (status & MII_GS_LINK) {
2293 /* We only support link info on Nat.Sem. PHY's */
2294 if ((tlphy_id1 == NAT_SEM_ID1) &&
2295 (tlphy_id2 == NAT_SEM_ID2)) {
2296 tlan_mii_read_reg(dev, phy, MII_AN_LPA,
2297 &partner);
2298 tlan_mii_read_reg(dev, phy, TLAN_TLPHY_PAR,
2299 &tlphy_par);
2300
2301 netdev_info(dev,
2302 "Link active, %s %uMbps %s-Duplex\n",
2303 !(tlphy_par & TLAN_PHY_AN_EN_STAT)
2304 ? "forced" : "Autonegotiation enabled,",
2305 tlphy_par & TLAN_PHY_SPEED_100
2306 ? 100 : 10,
2307 tlphy_par & TLAN_PHY_DUPLEX_FULL
2308 ? "Full" : "Half");
2309
2310 if (tlphy_par & TLAN_PHY_AN_EN_STAT) {
2311 netdev_info(dev, "Partner capability:");
2312 for (i = 5; i < 10; i++)
2313 if (partner & (1 << i))
2314 pr_cont(" %s",
2315 media[i-5]);
2316 pr_cont("\n");
2317 }
2318 } else
2319 netdev_info(dev, "Link active\n");
2320 /* Enabling link beat monitoring */
2321 priv->media_timer.function = tlan_phy_monitor;
2322 priv->media_timer.data = (unsigned long) dev;
2323 priv->media_timer.expires = jiffies + HZ;
2324 add_timer(&priv->media_timer);
1da177e4
LT		 2325 }
2326 }
2327
c659c38b
SA		 2328 if (priv->phy_num == 0) {
2329 tlan_mii_read_reg(dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl);
2330 tlphy_ctl |= TLAN_TC_INTEN;
2331 tlan_mii_write_reg(dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
2332 sio = tlan_dio_read8(dev->base_addr, TLAN_NET_SIO);
2333 sio |= TLAN_NET_SIO_MINTEN;
2334 tlan_dio_write8(dev->base_addr, TLAN_NET_SIO, sio);
2335 }
2336
2337 if (status & MII_GS_LINK) {
2338 tlan_set_mac(dev, 0, dev->dev_addr);
2339 priv->phy_online = 1;
2340 outb((TLAN_HC_INT_ON >> 8), dev->base_addr + TLAN_HOST_CMD + 1);
2341 if (debug >= 1 && debug != TLAN_DEBUG_PROBE)
2342 outb((TLAN_HC_REQ_INT >> 8),
2343 dev->base_addr + TLAN_HOST_CMD + 1);
2344 outl(priv->rx_list_dma, dev->base_addr + TLAN_CH_PARM);
2345 outl(TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD);
c0a87c22 2346 tlan_dio_write8(dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK);
1da177e4
LT		 2347 netif_carrier_on(dev);
2348 } else {
50624aab 2349 netdev_info(dev, "Link inactive, will retry in 10 secs...\n");
c659c38b 2350 tlan_set_timer(dev, (10*HZ), TLAN_TIMER_FINISH_RESET);
1da177e4
LT		 2351 return;
2352 }
c659c38b 2353 tlan_set_multicast_list(dev);
1da177e4 2354
c659c38b 2355}
1da177e4
LT		 2356
2357
2358
2359
c659c38b
SA		 2360/***************************************************************
2361 * tlan_set_mac
2362 *
2363 * Returns:
2364 * Nothing
2365 * Parms:
2366 * dev Pointer to device structure of adapter
2367 * on which to change the AREG.
2368 * areg The AREG to set the address in (0 - 3).
2369 * mac A pointer to an array of chars. Each
2370 * element stores one byte of the address.
2371 * IE, it isn't in ascii.
2372 *
2373 * This function transfers a MAC address to one of the
2374 * TLAN AREGs (address registers). The TLAN chip locks
2375 * the register on writing to offset 0 and unlocks the
2376 * register after writing to offset 5. If NULL is passed
2377 * in mac, then the AREG is filled with 0's.
2378 *
2379 **************************************************************/
1da177e4 2380
c659c38b 2381static void tlan_set_mac(struct net_device *dev, int areg, char *mac)
1da177e4
LT		 2382{
2383 int i;
6aa20a22 2384
1da177e4
LT		 2385 areg *= 6;
2386
c659c38b
SA		 2387 if (mac != NULL) {
2388 for (i = 0; i < 6; i++)
2389 tlan_dio_write8(dev->base_addr,
2390 TLAN_AREG_0 + areg + i, mac[i]);
1da177e4 2391 } else {
c659c38b
SA		 2392 for (i = 0; i < 6; i++)
2393 tlan_dio_write8(dev->base_addr,
2394 TLAN_AREG_0 + areg + i, 0);
1da177e4
LT		 2395 }
2396
c659c38b 2397}
1da177e4
LT		 2398
2399
2400
2401
2402/*****************************************************************************
2403******************************************************************************
2404
c659c38b 2405ThunderLAN driver PHY layer routines
1da177e4
LT		 2406
2407******************************************************************************
2408*****************************************************************************/
2409
2410
2411
c659c38b
SA		 2412/*********************************************************************
2413 * tlan_phy_print
2414 *
2415 * Returns:
2416 * Nothing
2417 * Parms:
2418 * dev A pointer to the device structure of the
2419 * TLAN device having the PHYs to be detailed.
2420 *
2421 * This function prints the registers a PHY (aka transceiver).
2422 *
2423 ********************************************************************/
1da177e4 2424
c659c38b 2425static void tlan_phy_print(struct net_device *dev)
1da177e4 2426{
c659c38b 2427 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 2428 u16 i, data0, data1, data2, data3, phy;
2429
c659c38b
SA		 2430 phy = priv->phy[priv->phy_num];
2431
2432 if (priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY) {
50624aab 2433 netdev_info(dev, "Unmanaged PHY\n");
c659c38b 2434 } else if (phy <= TLAN_PHY_MAX_ADDR) {
50624aab
JP		 2435 netdev_info(dev, "PHY 0x%02x\n", phy);
2436 pr_info(" Off. +0 +1 +2 +3\n");
c659c38b 2437 for (i = 0; i < 0x20; i += 4) {
c659c38b 2438 tlan_mii_read_reg(dev, phy, i, &data0);
c659c38b 2439 tlan_mii_read_reg(dev, phy, i + 1, &data1);
c659c38b 2440 tlan_mii_read_reg(dev, phy, i + 2, &data2);
c659c38b 2441 tlan_mii_read_reg(dev, phy, i + 3, &data3);
50624aab
JP		 2442 pr_info(" 0x%02x 0x%04hx 0x%04hx 0x%04hx 0x%04hx\n",
2443 i, data0, data1, data2, data3);
1da177e4
LT		 2444 }
2445 } else {
50624aab 2446 netdev_info(dev, "Invalid PHY\n");
1da177e4
LT		 2447 }
2448
c659c38b 2449}
1da177e4
LT		 2450
2451
2452
2453
c659c38b
SA		 2454/*********************************************************************
2455 * tlan_phy_detect
2456 *
2457 * Returns:
2458 * Nothing
2459 * Parms:
2460 * dev A pointer to the device structure of the adapter
2461 * for which the PHY needs determined.
2462 *
2463 * So far I've found that adapters which have external PHYs
2464 * may also use the internal PHY for part of the functionality.
2465 * (eg, AUI/Thinnet). This function finds out if this TLAN
2466 * chip has an internal PHY, and then finds the first external
2467 * PHY (starting from address 0) if it exists).
2468 *
2469 ********************************************************************/
1da177e4 2470
c659c38b 2471static void tlan_phy_detect(struct net_device *dev)
1da177e4 2472{
c659c38b 2473 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 2474 u16 control;
2475 u16 hi;
2476 u16 lo;
2477 u32 phy;
2478
c659c38b
SA		 2479 if (priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY) {
2480 priv->phy_num = 0xffff;
1da177e4
LT		 2481 return;
2482 }
2483
c659c38b 2484 tlan_mii_read_reg(dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi);
6aa20a22 2485
c659c38b 2486 if (hi != 0xffff)
1da177e4 2487 priv->phy[0] = TLAN_PHY_MAX_ADDR;
c659c38b 2488 else
1da177e4 2489 priv->phy[0] = TLAN_PHY_NONE;
1da177e4
LT		 2490
2491 priv->phy[1] = TLAN_PHY_NONE;
c659c38b
SA		 2492 for (phy = 0; phy <= TLAN_PHY_MAX_ADDR; phy++) {
2493 tlan_mii_read_reg(dev, phy, MII_GEN_CTL, &control);
2494 tlan_mii_read_reg(dev, phy, MII_GEN_ID_HI, &hi);
2495 tlan_mii_read_reg(dev, phy, MII_GEN_ID_LO, &lo);
2496 if ((control != 0xffff) ||
2497 (hi != 0xffff) || (lo != 0xffff)) {
2498 TLAN_DBG(TLAN_DEBUG_GNRL,
2499 "PHY found at %02x %04x %04x %04x\n",
2500 phy, control, hi, lo);
2501 if ((priv->phy[1] == TLAN_PHY_NONE) &&
2502 (phy != TLAN_PHY_MAX_ADDR)) {
1da177e4
LT		 2503 priv->phy[1] = phy;
2504 }
2505 }
2506 }
2507
c659c38b
SA		 2508 if (priv->phy[1] != TLAN_PHY_NONE)
2509 priv->phy_num = 1;
2510 else if (priv->phy[0] != TLAN_PHY_NONE)
2511 priv->phy_num = 0;
2512 else
50624aab 2513 netdev_info(dev, "Cannot initialize device, no PHY was found!\n");
1da177e4 2514
c659c38b 2515}
1da177e4
LT		 2516
2517
2518
2519
c659c38b 2520static void tlan_phy_power_down(struct net_device *dev)
1da177e4 2521{
c659c38b 2522 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 2523 u16 value;
2524
c659c38b 2525 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Powering down PHY(s).\n", dev->name);
1da177e4 2526 value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE;
c659c38b
SA		 2527 tlan_mii_sync(dev->base_addr);
2528 tlan_mii_write_reg(dev, priv->phy[priv->phy_num], MII_GEN_CTL, value);
9162e7e5
OZ		 2529 if ((priv->phy_num == 0) && (priv->phy[1] != TLAN_PHY_NONE)) {
2530 /* if using internal PHY, the external PHY must be powered on */
2531 if (priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10)
2532 value = MII_GC_ISOLATE; /* just isolate it from MII */
c659c38b
SA		 2533 tlan_mii_sync(dev->base_addr);
2534 tlan_mii_write_reg(dev, priv->phy[1], MII_GEN_CTL, value);
1da177e4
LT		 2535 }
2536
2537 /* Wait for 50 ms and powerup
2538 * This is abitrary. It is intended to make sure the
2539 * transceiver settles.
2540 */
51fd9471 2541 tlan_set_timer(dev, msecs_to_jiffies(50), TLAN_TIMER_PHY_PUP);
1da177e4 2542
c659c38b 2543}
1da177e4
LT		 2544
2545
2546
2547
c659c38b 2548static void tlan_phy_power_up(struct net_device *dev)
1da177e4 2549{
c659c38b 2550 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 2551 u16 value;
2552
c659c38b
SA		 2553 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Powering up PHY.\n", dev->name);
2554 tlan_mii_sync(dev->base_addr);
1da177e4 2555 value = MII_GC_LOOPBK;
c659c38b
SA		 2556 tlan_mii_write_reg(dev, priv->phy[priv->phy_num], MII_GEN_CTL, value);
2557 tlan_mii_sync(dev->base_addr);
1da177e4
LT		 2558 /* Wait for 500 ms and reset the
2559 * transceiver. The TLAN docs say both 50 ms and
2560 * 500 ms, so do the longer, just in case.
2561 */
b5057dd7 2562 tlan_set_timer(dev, msecs_to_jiffies(500), TLAN_TIMER_PHY_RESET);
1da177e4 2563
c659c38b 2564}
1da177e4
LT		 2565
2566
2567
2568
c659c38b 2569static void tlan_phy_reset(struct net_device *dev)
1da177e4 2570{
c659c38b 2571 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 2572 u16 phy;
2573 u16 value;
9cff441e 2574 unsigned long timeout = jiffies + HZ;
1da177e4 2575
c659c38b 2576 phy = priv->phy[priv->phy_num];
1da177e4 2577
fd9071ec 2578 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Resetting PHY.\n", dev->name);
c659c38b 2579 tlan_mii_sync(dev->base_addr);
1da177e4 2580 value = MII_GC_LOOPBK | MII_GC_RESET;
c659c38b 2581 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, value);
9cff441e 2582 do {
c659c38b 2583 tlan_mii_read_reg(dev, phy, MII_GEN_CTL, &value);
9cff441e
OZ		 2584 if (time_after(jiffies, timeout)) {
2585 netdev_err(dev, "PHY reset timeout\n");
2586 return;
2587 }
2588 } while (value & MII_GC_RESET);
1da177e4
LT		 2589
2590 /* Wait for 500 ms and initialize.
2591 * I don't remember why I wait this long.
2592 * I've changed this to 50ms, as it seems long enough.
2593 */
51fd9471 2594 tlan_set_timer(dev, msecs_to_jiffies(50), TLAN_TIMER_PHY_START_LINK);
1da177e4 2595
c659c38b 2596}
1da177e4
LT		 2597
2598
2599
2600
c659c38b 2601static void tlan_phy_start_link(struct net_device *dev)
1da177e4 2602{
c659c38b 2603 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 2604 u16 ability;
2605 u16 control;
2606 u16 data;
2607 u16 phy;
2608 u16 status;
2609 u16 tctl;
2610
c659c38b
SA		 2611 phy = priv->phy[priv->phy_num];
2612 TLAN_DBG(TLAN_DEBUG_GNRL, "%s: Trying to activate link.\n", dev->name);
2613 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
2614 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &ability);
1da177e4 2615
c659c38b
SA		 2616 if ((status & MII_GS_AUTONEG) &&
2617 (!priv->aui)) {
1da177e4 2618 ability = status >> 11;
c659c38b
SA		 2619 if (priv->speed == TLAN_SPEED_10 &&
2620 priv->duplex == TLAN_DUPLEX_HALF) {
2621 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x0000);
2622 } else if (priv->speed == TLAN_SPEED_10 &&
2623 priv->duplex == TLAN_DUPLEX_FULL) {
2624 priv->tlan_full_duplex = true;
2625 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x0100);
2626 } else if (priv->speed == TLAN_SPEED_100 &&
2627 priv->duplex == TLAN_DUPLEX_HALF) {
2628 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x2000);
2629 } else if (priv->speed == TLAN_SPEED_100 &&
2630 priv->duplex == TLAN_DUPLEX_FULL) {
2631 priv->tlan_full_duplex = true;
2632 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x2100);
1da177e4 2633 } else {
6aa20a22 2634
1da177e4 2635 /* Set Auto-Neg advertisement */
c659c38b
SA		 2636 tlan_mii_write_reg(dev, phy, MII_AN_ADV,
2637 (ability << 5) | 1);
1da177e4 2638 /* Enablee Auto-Neg */
c659c38b 2639 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x1000);
1da177e4 2640 /* Restart Auto-Neg */
c659c38b 2641 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, 0x1200);
1da177e4 2642 /* Wait for 4 sec for autonegotiation
c659c38b
SA		 2643 * to complete. The max spec time is less than this
2644 * but the card need additional time to start AN.
2645 * .5 sec should be plenty extra.
2646 */
50624aab 2647 netdev_info(dev, "Starting autonegotiation\n");
c659c38b 2648 tlan_set_timer(dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN);
1da177e4
LT		 2649 return;
2650 }
6aa20a22
JG		 2651
2652 }
2653
c659c38b
SA		 2654 if ((priv->aui) && (priv->phy_num != 0)) {
2655 priv->phy_num = 0;
2656 data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN
2657 | TLAN_NET_CFG_PHY_EN;
2658 tlan_dio_write16(dev->base_addr, TLAN_NET_CONFIG, data);
51fd9471 2659 tlan_set_timer(dev, msecs_to_jiffies(40), TLAN_TIMER_PHY_PDOWN);
1da177e4 2660 return;
c659c38b 2661 } else if (priv->phy_num == 0) {
1da177e4 2662 control = 0;
c659c38b
SA		 2663 tlan_mii_read_reg(dev, phy, TLAN_TLPHY_CTL, &tctl);
2664 if (priv->aui) {
2665 tctl |= TLAN_TC_AUISEL;
6aa20a22 2666 } else {
c659c38b
SA		 2667 tctl &= ~TLAN_TC_AUISEL;
2668 if (priv->duplex == TLAN_DUPLEX_FULL) {
1da177e4 2669 control |= MII_GC_DUPLEX;
c659c38b 2670 priv->tlan_full_duplex = true;
1da177e4 2671 }
c659c38b 2672 if (priv->speed == TLAN_SPEED_100)
1da177e4 2673 control |= MII_GC_SPEEDSEL;
1da177e4 2674 }
c659c38b
SA		 2675 tlan_mii_write_reg(dev, phy, MII_GEN_CTL, control);
2676 tlan_mii_write_reg(dev, phy, TLAN_TLPHY_CTL, tctl);
1da177e4
LT		 2677 }
2678
2679 /* Wait for 2 sec to give the transceiver time
2680 * to establish link.
2681 */
c659c38b 2682 tlan_set_timer(dev, (4*HZ), TLAN_TIMER_FINISH_RESET);
1da177e4 2683
c659c38b 2684}
1da177e4
LT		 2685
2686
2687
2688
c659c38b 2689static void tlan_phy_finish_auto_neg(struct net_device *dev)
1da177e4 2690{
c659c38b 2691 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 2692 u16 an_adv;
2693 u16 an_lpa;
1da177e4
LT		 2694 u16 mode;
2695 u16 phy;
2696 u16 status;
6aa20a22 2697
c659c38b 2698 phy = priv->phy[priv->phy_num];
1da177e4 2699
c659c38b
SA		 2700 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
2701 udelay(1000);
2702 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &status);
1da177e4 2703
c659c38b 2704 if (!(status & MII_GS_AUTOCMPLT)) {
1da177e4
LT		 2705 /* Wait for 8 sec to give the process
2706 * more time. Perhaps we should fail after a while.
2707 */
278e48b0 2708 tlan_set_timer(dev, 2 * HZ, TLAN_TIMER_PHY_FINISH_AN);
1da177e4
LT		 2709 return;
2710 }
2711
50624aab 2712 netdev_info(dev, "Autonegotiation complete\n");
c659c38b
SA		 2713 tlan_mii_read_reg(dev, phy, MII_AN_ADV, &an_adv);
2714 tlan_mii_read_reg(dev, phy, MII_AN_LPA, &an_lpa);
1da177e4 2715 mode = an_adv & an_lpa & 0x03E0;
c659c38b
SA		 2716 if (mode & 0x0100)
2717 priv->tlan_full_duplex = true;
2718 else if (!(mode & 0x0080) && (mode & 0x0040))
2719 priv->tlan_full_duplex = true;
2720
36bbe2f4 2721 /* switch to internal PHY for 10 Mbps */
c659c38b
SA		 2722 if ((!(mode & 0x0180)) &&
2723 (priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10) &&
2724 (priv->phy_num != 0)) {
2725 priv->phy_num = 0;
51fd9471 2726 tlan_set_timer(dev, msecs_to_jiffies(400), TLAN_TIMER_PHY_PDOWN);
1da177e4
LT		 2727 return;
2728 }
2729
c659c38b
SA		 2730 if (priv->phy_num == 0) {
2731 if ((priv->duplex == TLAN_DUPLEX_FULL) ||
2732 (an_adv & an_lpa & 0x0040)) {
2733 tlan_mii_write_reg(dev, phy, MII_GEN_CTL,
2734 MII_GC_AUTOENB | MII_GC_DUPLEX);
50624aab 2735 netdev_info(dev, "Starting internal PHY with FULL-DUPLEX\n");
1da177e4 2736 } else {
c659c38b
SA		 2737 tlan_mii_write_reg(dev, phy, MII_GEN_CTL,
2738 MII_GC_AUTOENB);
50624aab 2739 netdev_info(dev, "Starting internal PHY with HALF-DUPLEX\n");
1da177e4
LT		 2740 }
2741 }
2742
2743 /* Wait for 100 ms. No reason in partiticular.
2744 */
51fd9471 2745 tlan_set_timer(dev, msecs_to_jiffies(100), TLAN_TIMER_FINISH_RESET);
6aa20a22 2746
c659c38b 2747}
1da177e4 2748
1da177e4 2749
c659c38b
SA		 2750/*********************************************************************
2751 *
2752 * tlan_phy_monitor
2753 *
2754 * Returns:
2755 * None
2756 *
2757 * Params:
c0a87c22 2758 * data The device structure of this device.
c659c38b
SA		 2759 *
2760 *
2761 * This function monitors PHY condition by reading the status
c0a87c22
OZ		 2762 * register via the MII bus, controls LINK LED and notifies the
2763 * kernel about link state.
c659c38b
SA		 2764 *
2765 *******************************************************************/
2766
c0a87c22 2767static void tlan_phy_monitor(unsigned long data)
1da177e4 2768{
c0a87c22 2769 struct net_device *dev = (struct net_device *) data;
c659c38b 2770 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 2771 u16 phy;
2772 u16 phy_status;
2773
c659c38b 2774 phy = priv->phy[priv->phy_num];
1da177e4 2775
c659c38b
SA		 2776 /* Get PHY status register */
2777 tlan_mii_read_reg(dev, phy, MII_GEN_STS, &phy_status);
1da177e4 2778
c659c38b
SA		 2779 /* Check if link has been lost */
2780 if (!(phy_status & MII_GS_LINK)) {
c0a87c22 2781 if (netif_carrier_ok(dev)) {
c659c38b
SA		 2782 printk(KERN_DEBUG "TLAN: %s has lost link\n",
2783 dev->name);
c0a87c22 2784 tlan_dio_write8(dev->base_addr, TLAN_LED_REG, 0);
c659c38b 2785 netif_carrier_off(dev);
36bbe2f4
OZ		 2786 if (priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10) {
2787 /* power down internal PHY */
2788 u16 data = MII_GC_PDOWN | MII_GC_LOOPBK |
2789 MII_GC_ISOLATE;
2790
2791 tlan_mii_sync(dev->base_addr);
2792 tlan_mii_write_reg(dev, priv->phy[0],
2793 MII_GEN_CTL, data);
2794 /* set to external PHY */
2795 priv->phy_num = 1;
2796 /* restart autonegotiation */
51fd9471 2797 tlan_set_timer(dev, msecs_to_jiffies(400),
36bbe2f4
OZ		 2798 TLAN_TIMER_PHY_PDOWN);
2799 return;
2800 }
1da177e4
LT		 2801 }
2802 }
2803
c659c38b 2804 /* Link restablished? */
c0a87c22
OZ		 2805 if ((phy_status & MII_GS_LINK) && !netif_carrier_ok(dev)) {
2806 tlan_dio_write8(dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK);
c659c38b
SA		 2807 printk(KERN_DEBUG "TLAN: %s has reestablished link\n",
2808 dev->name);
7d17c1d6 2809 netif_carrier_on(dev);
c659c38b 2810 }
c0a87c22
OZ		 2811 priv->media_timer.expires = jiffies + HZ;
2812 add_timer(&priv->media_timer);
6aa20a22 2813}
1da177e4 2814
1da177e4
LT		 2815
2816/*****************************************************************************
2817******************************************************************************
2818
c659c38b 2819ThunderLAN driver MII routines
1da177e4 2820
c659c38b
SA		 2821these routines are based on the information in chap. 2 of the
2822"ThunderLAN Programmer's Guide", pp. 15-24.
1da177e4
LT		 2823
2824******************************************************************************
2825*****************************************************************************/
2826
2827
c659c38b
SA		 2828/***************************************************************
2829 * tlan_mii_read_reg
2830 *
2831 * Returns:
2832 * false if ack received ok
2833 * true if no ack received or other error
2834 *
2835 * Parms:
2836 * dev The device structure containing
2837 * The io address and interrupt count
2838 * for this device.
2839 * phy The address of the PHY to be queried.
2840 * reg The register whose contents are to be
2841 * retrieved.
2842 * val A pointer to a variable to store the
2843 * retrieved value.
2844 *
2845 * This function uses the TLAN's MII bus to retrieve the contents
2846 * of a given register on a PHY. It sends the appropriate info
2847 * and then reads the 16-bit register value from the MII bus via
2848 * the TLAN SIO register.
2849 *
2850 **************************************************************/
2851
2852static bool
2853tlan_mii_read_reg(struct net_device *dev, u16 phy, u16 reg, u16 *val)
1da177e4
LT		 2854{
2855 u8 nack;
2856 u16 sio, tmp;
c659c38b 2857 u32 i;
37fce430 2858 bool err;
1da177e4 2859 int minten;
c659c38b 2860 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 2861 unsigned long flags = 0;
2862
37fce430 2863 err = false;
1da177e4
LT		 2864 outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
2865 sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
6aa20a22 2866
1da177e4
LT		 2867 if (!in_irq())
2868 spin_lock_irqsave(&priv->lock, flags);
2869
c659c38b 2870 tlan_mii_sync(dev->base_addr);
1da177e4 2871
c659c38b
SA		 2872 minten = tlan_get_bit(TLAN_NET_SIO_MINTEN, sio);
2873 if (minten)
2874 tlan_clear_bit(TLAN_NET_SIO_MINTEN, sio);
1da177e4 2875
c659c38b
SA		 2876 tlan_mii_send_data(dev->base_addr, 0x1, 2); /* start (01b) */
2877 tlan_mii_send_data(dev->base_addr, 0x2, 2); /* read (10b) */
2878 tlan_mii_send_data(dev->base_addr, phy, 5); /* device # */
2879 tlan_mii_send_data(dev->base_addr, reg, 5); /* register # */
1da177e4
LT		 2880
2881
c659c38b 2882 tlan_clear_bit(TLAN_NET_SIO_MTXEN, sio); /* change direction */
1da177e4 2883
c659c38b
SA		 2884 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio); /* clock idle bit */
2885 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
2886 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio); /* wait 300ns */
1da177e4 2887
c659c38b
SA		 2888 nack = tlan_get_bit(TLAN_NET_SIO_MDATA, sio); /* check for ACK */
2889 tlan_set_bit(TLAN_NET_SIO_MCLK, sio); /* finish ACK */
2890 if (nack) { /* no ACK, so fake it */
1da177e4 2891 for (i = 0; i < 16; i++) {
c659c38b
SA		 2892 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);
2893 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
1da177e4
LT		 2894 }
2895 tmp = 0xffff;
37fce430 2896 err = true;
1da177e4
LT		 2897 } else { /* ACK, so read data */
2898 for (tmp = 0, i = 0x8000; i; i >>= 1) {
c659c38b
SA		 2899 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);
2900 if (tlan_get_bit(TLAN_NET_SIO_MDATA, sio))
1da177e4 2901 tmp |= i;
c659c38b 2902 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
1da177e4
LT		 2903 }
2904 }
2905
2906
c659c38b
SA		 2907 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio); /* idle cycle */
2908 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
1da177e4 2909
c659c38b
SA		 2910 if (minten)
2911 tlan_set_bit(TLAN_NET_SIO_MINTEN, sio);
1da177e4
LT		 2912
2913 *val = tmp;
6aa20a22 2914
1da177e4
LT		 2915 if (!in_irq())
2916 spin_unlock_irqrestore(&priv->lock, flags);
2917
2918 return err;
2919
c659c38b 2920}
1da177e4
LT		 2921
2922
2923
2924
c659c38b
SA		 2925/***************************************************************
2926 * tlan_mii_send_data
2927 *
2928 * Returns:
2929 * Nothing
2930 * Parms:
2931 * base_port The base IO port of the adapter in
2932 * question.
2933 * dev The address of the PHY to be queried.
2934 * data The value to be placed on the MII bus.
2935 * num_bits The number of bits in data that are to
2936 * be placed on the MII bus.
2937 *
2938 * This function sends on sequence of bits on the MII
2939 * configuration bus.
2940 *
2941 **************************************************************/
1da177e4 2942
c659c38b 2943static void tlan_mii_send_data(u16 base_port, u32 data, unsigned num_bits)
1da177e4
LT		 2944{
2945 u16 sio;
2946 u32 i;
2947
c659c38b 2948 if (num_bits == 0)
1da177e4
LT		 2949 return;
2950
c659c38b 2951 outw(TLAN_NET_SIO, base_port + TLAN_DIO_ADR);
1da177e4 2952 sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
c659c38b 2953 tlan_set_bit(TLAN_NET_SIO_MTXEN, sio);
1da177e4 2954
c659c38b
SA		 2955 for (i = (0x1 << (num_bits - 1)); i; i >>= 1) {
2956 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);
2957 (void) tlan_get_bit(TLAN_NET_SIO_MCLK, sio);
2958 if (data & i)
2959 tlan_set_bit(TLAN_NET_SIO_MDATA, sio);
1da177e4 2960 else
c659c38b
SA		 2961 tlan_clear_bit(TLAN_NET_SIO_MDATA, sio);
2962 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
2963 (void) tlan_get_bit(TLAN_NET_SIO_MCLK, sio);
1da177e4
LT		 2964 }
2965
c659c38b 2966}
1da177e4
LT		 2967
2968
2969
2970
c659c38b
SA		 2971/***************************************************************
2972 * TLan_MiiSync
2973 *
2974 * Returns:
2975 * Nothing
2976 * Parms:
2977 * base_port The base IO port of the adapter in
2978 * question.
2979 *
2980 * This functions syncs all PHYs in terms of the MII configuration
2981 * bus.
2982 *
2983 **************************************************************/
1da177e4 2984
c659c38b 2985static void tlan_mii_sync(u16 base_port)
1da177e4
LT		 2986{
2987 int i;
2988 u16 sio;
2989
c659c38b 2990 outw(TLAN_NET_SIO, base_port + TLAN_DIO_ADR);
1da177e4
LT		 2991 sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
2992
c659c38b
SA		 2993 tlan_clear_bit(TLAN_NET_SIO_MTXEN, sio);
2994 for (i = 0; i < 32; i++) {
2995 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio);
2996 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
1da177e4
LT		 2997 }
2998
c659c38b 2999}
1da177e4
LT		 3000
3001
3002
3003
c659c38b
SA		 3004/***************************************************************
3005 * tlan_mii_write_reg
3006 *
3007 * Returns:
3008 * Nothing
3009 * Parms:
3010 * dev The device structure for the device
3011 * to write to.
3012 * phy The address of the PHY to be written to.
3013 * reg The register whose contents are to be
3014 * written.
3015 * val The value to be written to the register.
3016 *
3017 * This function uses the TLAN's MII bus to write the contents of a
3018 * given register on a PHY. It sends the appropriate info and then
3019 * writes the 16-bit register value from the MII configuration bus
3020 * via the TLAN SIO register.
3021 *
3022 **************************************************************/
1da177e4 3023
c659c38b
SA		 3024static void
3025tlan_mii_write_reg(struct net_device *dev, u16 phy, u16 reg, u16 val)
1da177e4
LT		 3026{
3027 u16 sio;
3028 int minten;
3029 unsigned long flags = 0;
c659c38b 3030 struct tlan_priv *priv = netdev_priv(dev);
1da177e4
LT		 3031
3032 outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
3033 sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
6aa20a22 3034
1da177e4
LT		 3035 if (!in_irq())
3036 spin_lock_irqsave(&priv->lock, flags);
3037
c659c38b 3038 tlan_mii_sync(dev->base_addr);
1da177e4 3039
c659c38b
SA		 3040 minten = tlan_get_bit(TLAN_NET_SIO_MINTEN, sio);
3041 if (minten)
3042 tlan_clear_bit(TLAN_NET_SIO_MINTEN, sio);
1da177e4 3043
c659c38b
SA		 3044 tlan_mii_send_data(dev->base_addr, 0x1, 2); /* start (01b) */
3045 tlan_mii_send_data(dev->base_addr, 0x1, 2); /* write (01b) */
3046 tlan_mii_send_data(dev->base_addr, phy, 5); /* device # */
3047 tlan_mii_send_data(dev->base_addr, reg, 5); /* register # */
1da177e4 3048
c659c38b
SA		 3049 tlan_mii_send_data(dev->base_addr, 0x2, 2); /* send ACK */
3050 tlan_mii_send_data(dev->base_addr, val, 16); /* send data */
1da177e4 3051
c659c38b
SA		 3052 tlan_clear_bit(TLAN_NET_SIO_MCLK, sio); /* idle cycle */
3053 tlan_set_bit(TLAN_NET_SIO_MCLK, sio);
1da177e4 3054
c659c38b
SA		 3055 if (minten)
3056 tlan_set_bit(TLAN_NET_SIO_MINTEN, sio);
6aa20a22 3057
1da177e4
LT		 3058 if (!in_irq())
3059 spin_unlock_irqrestore(&priv->lock, flags);
3060
c659c38b 3061}
1da177e4
LT		 3062
3063
3064
3065
3066/*****************************************************************************
3067******************************************************************************
3068
c659c38b 3069ThunderLAN driver eeprom routines
1da177e4 3070
c659c38b
SA		 3071the Compaq netelligent 10 and 10/100 cards use a microchip 24C02A
3072EEPROM. these functions are based on information in microchip's
3073data sheet. I don't know how well this functions will work with
3074other Eeproms.
1da177e4
LT		 3075
3076******************************************************************************
3077*****************************************************************************/
3078
3079
c659c38b
SA		 3080/***************************************************************
3081 * tlan_ee_send_start
3082 *
3083 * Returns:
3084 * Nothing
3085 * Parms:
3086 * io_base The IO port base address for the
3087 * TLAN device with the EEPROM to
3088 * use.
3089 *
3090 * This function sends a start cycle to an EEPROM attached
3091 * to a TLAN chip.
3092 *
3093 **************************************************************/
3094
3095static void tlan_ee_send_start(u16 io_base)
1da177e4
LT		 3096{
3097 u16 sio;
3098
c659c38b 3099 outw(TLAN_NET_SIO, io_base + TLAN_DIO_ADR);
1da177e4
LT		 3100 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3101
c659c38b
SA		 3102 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3103 tlan_set_bit(TLAN_NET_SIO_EDATA, sio);
3104 tlan_set_bit(TLAN_NET_SIO_ETXEN, sio);
3105 tlan_clear_bit(TLAN_NET_SIO_EDATA, sio);
3106 tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
3107
3108}
3109
3110
3111
3112
3113/***************************************************************
3114 * tlan_ee_send_byte
3115 *
3116 * Returns:
3117 * If the correct ack was received, 0, otherwise 1
3118 * Parms: io_base The IO port base address for the
3119 * TLAN device with the EEPROM to
3120 * use.
3121 * data The 8 bits of information to
3122 * send to the EEPROM.
3123 * stop If TLAN_EEPROM_STOP is passed, a
3124 * stop cycle is sent after the
3125 * byte is sent after the ack is
3126 * read.
3127 *
3128 * This function sends a byte on the serial EEPROM line,
3129 * driving the clock to send each bit. The function then
3130 * reverses transmission direction and reads an acknowledge
3131 * bit.
3132 *
3133 **************************************************************/
3134
3135static int tlan_ee_send_byte(u16 io_base, u8 data, int stop)
1da177e4
LT		 3136{
3137 int err;
3138 u8 place;
3139 u16 sio;
3140
c659c38b 3141 outw(TLAN_NET_SIO, io_base + TLAN_DIO_ADR);
1da177e4
LT		 3142 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3143
3144 /* Assume clock is low, tx is enabled; */
c659c38b
SA		 3145 for (place = 0x80; place != 0; place >>= 1) {
3146 if (place & data)
3147 tlan_set_bit(TLAN_NET_SIO_EDATA, sio);
1da177e4 3148 else
c659c38b
SA		 3149 tlan_clear_bit(TLAN_NET_SIO_EDATA, sio);
3150 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3151 tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
1da177e4 3152 }
c659c38b
SA		 3153 tlan_clear_bit(TLAN_NET_SIO_ETXEN, sio);
3154 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3155 err = tlan_get_bit(TLAN_NET_SIO_EDATA, sio);
3156 tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
3157 tlan_set_bit(TLAN_NET_SIO_ETXEN, sio);
1da177e4 3158
c659c38b 3159 if ((!err) && stop) {
dfc2c0a6 3160 /* STOP, raise data while clock is high */
c659c38b
SA		 3161 tlan_clear_bit(TLAN_NET_SIO_EDATA, sio);
3162 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3163 tlan_set_bit(TLAN_NET_SIO_EDATA, sio);
1da177e4
LT		 3164 }
3165
807540ba 3166 return err;
1da177e4 3167
c659c38b
SA		 3168}
3169
3170
3171
3172
3173/***************************************************************
3174 * tlan_ee_receive_byte
3175 *
3176 * Returns:
3177 * Nothing
3178 * Parms:
3179 * io_base The IO port base address for the
3180 * TLAN device with the EEPROM to
3181 * use.
3182 * data An address to a char to hold the
3183 * data sent from the EEPROM.
3184 * stop If TLAN_EEPROM_STOP is passed, a
3185 * stop cycle is sent after the
3186 * byte is received, and no ack is
3187 * sent.
3188 *
3189 * This function receives 8 bits of data from the EEPROM
3190 * over the serial link. It then sends and ack bit, or no
3191 * ack and a stop bit. This function is used to retrieve
3192 * data after the address of a byte in the EEPROM has been
3193 * sent.
3194 *
3195 **************************************************************/
3196
3197static void tlan_ee_receive_byte(u16 io_base, u8 *data, int stop)
1da177e4
LT		 3198{
3199 u8 place;
3200 u16 sio;
3201
c659c38b 3202 outw(TLAN_NET_SIO, io_base + TLAN_DIO_ADR);
1da177e4
LT		 3203 sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
3204 *data = 0;
3205
3206 /* Assume clock is low, tx is enabled; */
c659c38b
SA		 3207 tlan_clear_bit(TLAN_NET_SIO_ETXEN, sio);
3208 for (place = 0x80; place; place >>= 1) {
3209 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3210 if (tlan_get_bit(TLAN_NET_SIO_EDATA, sio))
1da177e4 3211 *data |= place;
c659c38b 3212 tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
1da177e4
LT		 3213 }
3214
c659c38b
SA		 3215 tlan_set_bit(TLAN_NET_SIO_ETXEN, sio);
3216 if (!stop) {
3217 tlan_clear_bit(TLAN_NET_SIO_EDATA, sio); /* ack = 0 */
3218 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3219 tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
1da177e4 3220 } else {
c659c38b
SA		 3221 tlan_set_bit(TLAN_NET_SIO_EDATA, sio); /* no ack = 1 (?) */
3222 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3223 tlan_clear_bit(TLAN_NET_SIO_ECLOK, sio);
dfc2c0a6 3224 /* STOP, raise data while clock is high */
c659c38b
SA		 3225 tlan_clear_bit(TLAN_NET_SIO_EDATA, sio);
3226 tlan_set_bit(TLAN_NET_SIO_ECLOK, sio);
3227 tlan_set_bit(TLAN_NET_SIO_EDATA, sio);
3228 }
3229
3230}
3231
3232
3233
3234
3235/***************************************************************
3236 * tlan_ee_read_byte
3237 *
3238 * Returns:
3239 * No error = 0, else, the stage at which the error
3240 * occurred.
3241 * Parms:
3242 * io_base The IO port base address for the
3243 * TLAN device with the EEPROM to
3244 * use.
3245 * ee_addr The address of the byte in the
3246 * EEPROM whose contents are to be
3247 * retrieved.
3248 * data An address to a char to hold the
3249 * data obtained from the EEPROM.
3250 *
3251 * This function reads a byte of information from an byte
3252 * cell in the EEPROM.
3253 *
3254 **************************************************************/
3255
3256static int tlan_ee_read_byte(struct net_device *dev, u8 ee_addr, u8 *data)
1da177e4
LT		 3257{
3258 int err;
c659c38b 3259 struct tlan_priv *priv = netdev_priv(dev);
1da177e4 3260 unsigned long flags = 0;
c659c38b 3261 int ret = 0;
1da177e4
LT		 3262
3263 spin_lock_irqsave(&priv->lock, flags);
3264
c659c38b
SA		 3265 tlan_ee_send_start(dev->base_addr);
3266 err = tlan_ee_send_byte(dev->base_addr, 0xa0, TLAN_EEPROM_ACK);
3267 if (err) {
3268 ret = 1;
1da177e4
LT		 3269 goto fail;
3270 }
c659c38b
SA		 3271 err = tlan_ee_send_byte(dev->base_addr, ee_addr, TLAN_EEPROM_ACK);
3272 if (err) {
3273 ret = 2;
1da177e4
LT		 3274 goto fail;
3275 }
c659c38b
SA		 3276 tlan_ee_send_start(dev->base_addr);
3277 err = tlan_ee_send_byte(dev->base_addr, 0xa1, TLAN_EEPROM_ACK);
3278 if (err) {
3279 ret = 3;
1da177e4
LT		 3280 goto fail;
3281 }
c659c38b 3282 tlan_ee_receive_byte(dev->base_addr, data, TLAN_EEPROM_STOP);
1da177e4
LT		 3283fail:
3284 spin_unlock_irqrestore(&priv->lock, flags);
3285
3286 return ret;
3287
c659c38b 3288}
1da177e4
LT		 3289
3290
3291
Linux kernel - Deliverables
This page took 2.177774 seconds and 5 git commands to generate.