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