开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
tlan.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：92k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

tlan.c：源码内容
  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.  *
  12.  *  This software may be used and distributed according to the terms
  13.  *  of the GNU General Public License, incorporated herein by reference.
  14.  *
  15.  ** This file is best viewed/edited with columns>=132.
  16.  *
  17.  ** Useful (if not required) reading:
  18.  *
  19.  * Texas Instruments, ThunderLAN Programmer's Guide,
  20.  * TI Literature Number SPWU013A
  21.  * available in PDF format from www.ti.com
  22.  * Level One, LXT901 and LXT970 Data Sheets
  23.  * available in PDF format from www.level1.com
  24.  * National Semiconductor, DP83840A Data Sheet
  25.  * available in PDF format from www.national.com
  26.  * Microchip Technology, 24C01A/02A/04A Data Sheet
  27.  * available in PDF format from www.microchip.com
  28.  *
  29.  * Change History
  30.  *
  31.  * Tigran Aivazian <tigran@sco.com>: TLan_PciProbe() now uses
  32.  * new PCI BIOS interface.
  33.  * Alan Cox <alan@redhat.com>: Fixed the out of memory
  34.  * handling.
  35.  *      
  36.  * Torben Mathiasen <torben.mathiasen@compaq.com> New Maintainer!
  37.  *
  38.  * v1.1 Dec 20, 1999    - Removed linux version checking
  39.  *        Patch from Tigran Aivazian. 
  40.  *      - v1.1 includes Alan's SMP updates.
  41.  *      - We still have problems on SMP though,
  42.  *        but I'm looking into that. 
  43.  *
  44.  * v1.2 Jan 02, 2000    - Hopefully fixed the SMP deadlock.
  45.  *      - Removed dependency of HZ being 100.
  46.  *      - We now allow higher priority timers to 
  47.  *        overwrite timers like TLAN_TIMER_ACTIVITY
  48.  *        Patch from John Cagle <john.cagle@compaq.com>.
  49.  *      - Fixed a few compiler warnings.
  50.  *
  51.  * v1.3 Feb 04, 2000    - Fixed the remaining HZ issues.
  52.  *      - Removed call to pci_present(). 
  53.  *      - Removed SA_INTERRUPT flag from irq handler.
  54.  *      - Added __init and __initdata to reduce resisdent 
  55.  *        code size.
  56.  *      - Driver now uses module_init/module_exit.
  57.  *      - Rewrote init_module and tlan_probe to
  58.  *        share a lot more code. We now use tlan_probe
  59.  *        with builtin and module driver.
  60.  *      - Driver ported to new net API. 
  61.  *      - tlan.txt has been reworked to reflect current 
  62.  *        driver (almost)
  63.  *      - Other minor stuff
  64.  *
  65.  * v1.4 Feb 10, 2000    - Updated with more changes required after Dave's
  66.  *                        network cleanup in 2.3.43pre7 (Tigran & myself)
  67.  *                      - Minor stuff.
  68.  *
  69.  * v1.5 March 22, 2000  - Fixed another timer bug that would hang the driver
  70.  *        if no cable/link were present.
  71.  *      - Cosmetic changes.
  72.  *      - TODO: Port completely to new PCI/DMA API
  73.  *            Auto-Neg fallback.
  74.  *
  75.  *  v1.6 April 04, 2000  - Fixed driver support for kernel-parameters. Haven't
  76.  *         tested it though, as the kernel support is currently 
  77.  *         broken (2.3.99p4p3).
  78.  *       - Updated tlan.txt accordingly.
  79.  *       - Adjusted minimum/maximum frame length.
  80.  *       - There is now a TLAN website up at 
  81.  *         http://tlan.kernel.dk
  82.  *
  83.  *  v1.7 April 07, 2000  - Started to implement custom ioctls. Driver now
  84.  *         reports PHY information when used with Donald
  85.  *         Beckers userspace MII diagnostics utility.
  86.  *
  87.  *  v1.8 April 23, 2000  - Fixed support for forced speed/duplex settings.
  88.  *       - Added link information to Auto-Neg and forced
  89.  *         modes. When NIC operates with auto-neg the driver
  90.  *         will report Link speed & duplex modes as well as
  91.  *         link partner abilities. When forced link is used,
  92.  *         the driver will report status of the established
  93.  *         link.
  94.  *         Please read tlan.txt for additional information. 
  95.  *       - Removed call to check_region(), and used 
  96.  *         return value of request_region() instead.
  97.  *
  98.  * v1.8a May 28, 2000   - Minor updates.
  99.  *
  100.  * v1.9 July 25, 2000   - Fixed a few remaining Full-Duplex issues.
  101.  *                      - Updated with timer fixes from Andrew Morton.
  102.  *                      - Fixed module race in TLan_Open.
  103.  *                      - Added routine to monitor PHY status.
  104.  *                      - Added activity led support for Proliant devices.
  105.  *
  106.  * v1.10 Aug 30, 2000   - Added support for EISA based tlan controllers 
  107.  *        like the Compaq NetFlex3/E. 
  108.  *      - Rewrote tlan_probe to better handle multiple
  109.  *        bus probes. Probing and device setup is now
  110.  *        done through TLan_Probe and TLan_init_one. Actual
  111.  *        hardware probe is done with kernel API and 
  112.  *        TLan_EisaProbe.
  113.  *      - Adjusted debug information for probing.
  114.  *      - Fixed bug that would cause general debug information 
  115.  *        to be printed after driver removal. 
  116.  *      - Added transmit timeout handling.
  117.  *      - Fixed OOM return values in tlan_probe. 
  118.  *      - Fixed possible mem leak in tlan_exit 
  119.  *        (now tlan_remove_one).
  120.  *      - Fixed timer bug in TLan_phyMonitor.
  121.  *      - This driver version is alpha quality, please
  122.  *        send me any bug issues you may encounter.
  123.  *
  124.  * v1.11 Aug 31, 2000   - Do not try to register irq 0 if no irq line was 
  125.  *        set for EISA cards.
  126.  *      - Added support for NetFlex3/E with nibble-rate
  127.  *        10Base-T PHY. This is untestet as I haven't got
  128.  *        one of these cards.
  129.  *      - Fixed timer being added twice.
  130.  *      - Disabled PhyMonitoring by default as this is
  131.  *        work in progress. Define MONITOR to enable it.
  132.  *      - Now we don't display link info with PHYs that
  133.  *        doesn't support it (level1).
  134.  *      - Incresed tx_timeout beacuse of auto-neg.
  135.  *      - Adjusted timers for forced speeds.
  136.  *
  137.  * v1.12 Oct 12, 2000   - Minor fixes (memleak, init, etc.)
  138.  *
  139.  *  v1.13 Nov 28, 2000   - Stop flooding console with auto-neg issues
  140.  *         when link can't be established.
  141.  *      - Added the bbuf option as a kernel parameter.
  142.  *      - Fixed ioaddr probe bug.
  143.  *      - Fixed stupid deadlock with MII interrupts.
  144.  *      - Added support for speed/duplex selection with 
  145.  *        multiple nics.
  146.  *      - Added partly fix for TX Channel lockup with
  147.  *        TLAN v1.0 silicon. This needs to be investigated
  148.  *        further.
  149.  *
  150.  *  v1.14 Dec 16, 2000   - Added support for servicing multiple frames per.
  151.  *         interrupt. Thanks goes to
  152.  *         Adam Keys <adam@ti.com>
  153.  *         Denis Beaudoin <dbeaudoin@ti.com>
  154.  *         for providing the patch.
  155.  *       - Fixed auto-neg output when using multiple
  156.  *         adapters.
  157.  *       - Converted to use new taskq interface.
  158.  *
  159.  *  v1.14a Jan 6, 2001   - Minor adjustments (spinlocks, etc.)
  160.  *
  161.  *******************************************************************************/
  163.                                                                                 
  164. #include <linux/module.h>
  166. #include "tlan.h"
  168. #include <linux/init.h>
  169. #include <linux/ioport.h>
  170. #include <linux/pci.h>
  171. #include <linux/etherdevice.h>
  172. #include <linux/delay.h>
  173. #include <linux/spinlock.h>
  174. #include <linux/mii.h>
  177. typedef u32 (TLanIntVectorFunc)( struct net_device *, u16 );
  180. /* For removing EISA devices */
  181. static struct net_device *TLan_Eisa_Devices;
  183. static int TLanDevicesInstalled;
  185. /* Set speed, duplex and aui settings */
  186. static  int aui[MAX_TLAN_BOARDS];
  187. static  int duplex[MAX_TLAN_BOARDS];
  188. static  int speed[MAX_TLAN_BOARDS];
  189. static  int boards_found;
  191. MODULE_AUTHOR("Maintainer: Torben Mathiasen <torben.mathiasen@compaq.com>");
  192. MODULE_DESCRIPTION("Driver for TI ThunderLAN based ethernet PCI adapters");
  193. MODULE_LICENSE("GPL");
  195. MODULE_PARM(aui, "1-" __MODULE_STRING(MAX_TLAN_BOARDS) "i");
  196. MODULE_PARM(duplex, "1-" __MODULE_STRING(MAX_TLAN_BOARDS) "i");
  197. MODULE_PARM(speed, "1-" __MODULE_STRING(MAX_TLAN_BOARDS) "i");
  198. MODULE_PARM(debug, "i");
  199. MODULE_PARM(bbuf, "i");
  200. MODULE_PARM_DESC(aui, "ThunderLAN use AUI port(s) (0-1)");
  201. MODULE_PARM_DESC(duplex, "ThunderLAN duplex setting(s) (0-default, 1-half, 2-full)");
  202. MODULE_PARM_DESC(speed, "ThunderLAN port speen setting(s) (0,10,100)");
  203. MODULE_PARM_DESC(debug, "ThunderLAN debug mask");
  204. MODULE_PARM_DESC(bbuf, "ThunderLAN use big buffer (0-1)");
  205. EXPORT_NO_SYMBOLS;
  207. /* Define this to enable Link beat monitoring */
  208. #undef MONITOR
  210. /* Turn on debugging. See linux/Documentation/networking/tlan.txt for details */
  211. static  int debug;
  213. static int bbuf;
  214. static u8 *TLanPadBuffer;
  215. static char TLanSignature[] = "TLAN";
  216. static const char tlan_banner[] = "ThunderLAN driver v1.14an";
  217. static int tlan_have_pci;
  218. static int tlan_have_eisa;
  220. const char *media[] = {
  221. "10BaseT-HD ", "10BaseT-FD ","100baseTx-HD ", 
  222. "100baseTx-FD", "100baseT4", 0
  223. };
  225. int media_map[] = { 0x0020, 0x0040, 0x0080, 0x0100, 0x0200,};
  227. static struct board {
  228. const char *deviceLabel;
  229. u32     flags;
  230. u16     addrOfs;
  231. } board_info[] __devinitdata = {
  232. { "Compaq Netelligent 10 T PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
  233. { "Compaq Netelligent 10/100 TX PCI UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
  234. { "Compaq Integrated NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
  235. { "Compaq NetFlex-3/P", TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
  236. { "Compaq NetFlex-3/P", TLAN_ADAPTER_NONE, 0x83 },
  237. { "Compaq Netelligent Integrated 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
  238. { "Compaq Netelligent Dual 10/100 TX PCI UTP", TLAN_ADAPTER_NONE, 0x83 },
  239. { "Compaq Netelligent 10/100 TX Embedded UTP", TLAN_ADAPTER_NONE, 0x83 },
  240. { "Olicom OC-2183/2185", TLAN_ADAPTER_USE_INTERN_10, 0x83 },
  241. { "Olicom OC-2325", TLAN_ADAPTER_UNMANAGED_PHY, 0xF8 },
  242. { "Olicom OC-2326", TLAN_ADAPTER_USE_INTERN_10, 0xF8 },
  243. { "Compaq Netelligent 10/100 TX UTP", TLAN_ADAPTER_ACTIVITY_LED, 0x83 },
  244. { "Compaq Netelligent 10 T/2 PCI UTP/Coax", TLAN_ADAPTER_NONE, 0x83 },
  245. { "Compaq NetFlex-3/E", TLAN_ADAPTER_ACTIVITY_LED |  /* EISA card */
  246.                         TLAN_ADAPTER_UNMANAGED_PHY | TLAN_ADAPTER_BIT_RATE_PHY, 0x83 },
  247. { "Compaq NetFlex-3/E", TLAN_ADAPTER_ACTIVITY_LED, 0x83 }, /* EISA card */
  248. };
  250. static struct pci_device_id tlan_pci_tbl[] __devinitdata = {
  251. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL10,
  252. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
  253. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100,
  254. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
  255. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3I,
  256. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
  257. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_THUNDER,
  258. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 },
  259. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3B,
  260. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
  261. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100PI,
  262. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
  263. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100D,
  264. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
  265. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100I,
  266. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 7 },
  267. { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2183,
  268. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
  269. { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2325,
  270. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 9 },
  271. { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2326,
  272. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 10 },
  273. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_100_WS_5100,
  274. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 11 },
  275. { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_T2,
  276. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 12 },
  277. { 0,}
  278. };
  279. MODULE_DEVICE_TABLE(pci, tlan_pci_tbl);
  281. static void TLan_EisaProbe( void );
  282. static void TLan_Eisa_Cleanup( void );
  283. static int      TLan_Init( struct net_device * );
  284. static int TLan_Open( struct net_device *dev );
  285. static int TLan_StartTx( struct sk_buff *, struct net_device *);
  286. static void TLan_HandleInterrupt( int, void *, struct pt_regs *);
  287. static int TLan_Close( struct net_device *);
  288. static struct net_device_stats *TLan_GetStats( struct net_device *);
  289. static void TLan_SetMulticastList( struct net_device *);
  290. static int TLan_ioctl( struct net_device *dev, struct ifreq *rq, int cmd);
  291. static int      TLan_probe1( struct pci_dev *pdev, long ioaddr, int irq, int rev, const struct pci_device_id *ent);
  292. static void TLan_tx_timeout( struct net_device *dev);
  293. static int  tlan_init_one( struct pci_dev *pdev, const struct pci_device_id *ent);
  295. static u32 TLan_HandleInvalid( struct net_device *, u16 );
  296. static u32 TLan_HandleTxEOF( struct net_device *, u16 );
  297. static u32 TLan_HandleStatOverflow( struct net_device *, u16 );
  298. static u32 TLan_HandleRxEOF( struct net_device *, u16 );
  299. static u32 TLan_HandleDummy( struct net_device *, u16 );
  300. static u32 TLan_HandleTxEOC( struct net_device *, u16 );
  301. static u32 TLan_HandleStatusCheck( struct net_device *, u16 );
  302. static u32 TLan_HandleRxEOC( struct net_device *, u16 );
  304. static void TLan_Timer( unsigned long );
  306. static void TLan_ResetLists( struct net_device * );
  307. static void TLan_FreeLists( struct net_device * );
  308. static void TLan_PrintDio( u16 );
  309. static void TLan_PrintList( TLanList *, char *, int );
  310. static void TLan_ReadAndClearStats( struct net_device *, int );
  311. static void TLan_ResetAdapter( struct net_device * );
  312. static void TLan_FinishReset( struct net_device * );
  313. static void TLan_SetMac( struct net_device *, int areg, char *mac );
  315. static void TLan_PhyPrint( struct net_device * );
  316. static void TLan_PhyDetect( struct net_device * );
  317. static void TLan_PhyPowerDown( struct net_device * );
  318. static void TLan_PhyPowerUp( struct net_device * );
  319. static void TLan_PhyReset( struct net_device * );
  320. static void TLan_PhyStartLink( struct net_device * );
  321. static void TLan_PhyFinishAutoNeg( struct net_device * );
  322. #ifdef MONITOR
  323. static void     TLan_PhyMonitor( struct net_device * );
  324. #endif
  326. /*
  327. static int TLan_PhyNop( struct net_device * );
  328. static int TLan_PhyInternalCheck( struct net_device * );
  329. static int TLan_PhyInternalService( struct net_device * );
  330. static int TLan_PhyDp83840aCheck( struct net_device * );
  331. */
  333. static int TLan_MiiReadReg( struct net_device *, u16, u16, u16 * );
  334. static void TLan_MiiSendData( u16, u32, unsigned );
  335. static void TLan_MiiSync( u16 );
  336. static void TLan_MiiWriteReg( struct net_device *, u16, u16, u16 );
  338. static void TLan_EeSendStart( u16 );
  339. static int TLan_EeSendByte( u16, u8, int );
  340. static void TLan_EeReceiveByte( u16, u8 *, int );
  341. static int TLan_EeReadByte( struct net_device *, u8, u8 * );
  344. static TLanIntVectorFunc *TLanIntVector[TLAN_INT_NUMBER_OF_INTS] = {
  345. TLan_HandleInvalid,
  346. TLan_HandleTxEOF,
  347. TLan_HandleStatOverflow,
  348. TLan_HandleRxEOF,
  349. TLan_HandleDummy,
  350. TLan_HandleTxEOC,
  351. TLan_HandleStatusCheck,
  352. TLan_HandleRxEOC
  353. };
  355. static inline void
  356. TLan_SetTimer( struct net_device *dev, u32 ticks, u32 type )
  357. {
  358. TLanPrivateInfo *priv = dev->priv;
  359. unsigned long flags = 0;
  361. if (!in_irq())
  362. spin_lock_irqsave(&priv->lock, flags);
  363. if ( priv->timer.function != NULL &&
  364. priv->timerType != TLAN_TIMER_ACTIVITY ) { 
  365. if (!in_irq())
  366. spin_unlock_irqrestore(&priv->lock, flags);
  367. return;
  368. }
  369. priv->timer.function = &TLan_Timer;
  370. if (!in_irq())
  371. spin_unlock_irqrestore(&priv->lock, flags);
  373. priv->timer.data = (unsigned long) dev;
  374. priv->timerSetAt = jiffies;
  375. priv->timerType = type;
  376. mod_timer(&priv->timer, jiffies + ticks);
  378. } /* TLan_SetTimer */
  381. /*****************************************************************************
  382. ******************************************************************************
  384. ThunderLAN Driver Primary Functions
  386. These functions are more or less common to all Linux network drivers.
  388. ******************************************************************************
  389. *****************************************************************************/
  395. /***************************************************************
  396.  * tlan_remove_one
  397.  *
  398.  * Returns:
  399.  * Nothing
  400.  * Parms:
  401.  * None
  402.  *
  403.  * Goes through the TLanDevices list and frees the device
  404.  * structs and memory associated with each device (lists
  405.  * and buffers).  It also ureserves the IO port regions
  406.  * associated with this device.
  407.  *
  408.  **************************************************************/
  411. static void __devexit tlan_remove_one( struct pci_dev *pdev)
  412. {
  413. struct net_device *dev = pci_get_drvdata( pdev );
  414. TLanPrivateInfo *priv = dev->priv;
  416. unregister_netdev( dev );
  418. if ( priv->dmaStorage ) {
  419. kfree( priv->dmaStorage );
  420. }
  422. release_region( dev->base_addr, 0x10 );
  424. kfree( dev );
  426. pci_set_drvdata( pdev, NULL );
  427. } 
  429. static struct pci_driver tlan_driver = {
  430. name: "tlan",
  431. id_table: tlan_pci_tbl,
  432. probe: tlan_init_one,
  433. remove: __devexit_p(tlan_remove_one),
  434. };
  436. static int __init tlan_probe(void)
  437. {
  438. static int pad_allocated;
  440. printk(KERN_INFO "%s", tlan_banner);
  442. TLanPadBuffer = (u8 *) kmalloc(TLAN_MIN_FRAME_SIZE, 
  443. GFP_KERNEL);
  445. if (TLanPadBuffer == NULL) {
  446. printk(KERN_ERR "TLAN: Could not allocate memory for pad buffer.n");
  447. return -ENOMEM;
  448. }
  450. memset(TLanPadBuffer, 0, TLAN_MIN_FRAME_SIZE);
  451. pad_allocated = 1;
  453. TLAN_DBG(TLAN_DEBUG_PROBE, "Starting PCI Probe....n");
  455. /* Use new style PCI probing. Now the kernel will
  456.    do most of this for us */
  457. pci_register_driver(&tlan_driver);
  459. TLAN_DBG(TLAN_DEBUG_PROBE, "Starting EISA Probe....n");
  460. TLan_EisaProbe();
  462. printk(KERN_INFO "TLAN: %d device%s installed, PCI: %d  EISA: %dn", 
  463.  TLanDevicesInstalled, TLanDevicesInstalled == 1 ? "" : "s",
  464.  tlan_have_pci, tlan_have_eisa);
  466. if (TLanDevicesInstalled == 0) {
  467. pci_unregister_driver(&tlan_driver);
  468. kfree(TLanPadBuffer);
  469. return -ENODEV;
  470. }
  471. return 0;
  472. }
  475. static int __devinit tlan_init_one( struct pci_dev *pdev,
  476.     const struct pci_device_id *ent)
  477. {
  478. return TLan_probe1( pdev, -1, -1, 0, ent);
  479. }
  482. /*
  483. ***************************************************************
  484.  * tlan_probe1
  485.  *
  486.  * Returns:
  487.  * 0 on success, error code on error
  488.  * Parms: 
  489.  * none
  490.  *
  491.  * The name is lower case to fit in with all the rest of
  492.  * the netcard_probe names.  This function looks for 
  493.  * another TLan based adapter, setting it up with the
  494.  * allocated device struct if one is found.
  495.  * tlan_probe has been ported to the new net API and
  496.  * now allocates its own device structure. This function
  497.  * is also used by modules.
  498.  *
  499.  **************************************************************/
  501. static int __devinit TLan_probe1(struct pci_dev *pdev, 
  502. long ioaddr, int irq, int rev, const struct pci_device_id *ent )
  503. {
  505. struct net_device  *dev;
  506. TLanPrivateInfo    *priv;
  507. u8    pci_rev;
  508. u16    device_id;
  509. int    reg;
  511. if (pdev && pci_enable_device(pdev))
  512. return -EIO;
  514. dev = init_etherdev(NULL, sizeof(TLanPrivateInfo));
  515. if (dev == NULL) {
  516. printk(KERN_ERR "TLAN: Could not allocate memory for device.n");
  517. return -ENOMEM;
  518. }
  519. SET_MODULE_OWNER(dev);
  521. priv = dev->priv;
  523. /* Is this a PCI device? */
  524. if (pdev) {
  525. u32     pci_io_base = 0;
  527. priv->adapter = &board_info[ent->driver_data];
  529. pci_read_config_byte ( pdev, PCI_REVISION_ID, &pci_rev);
  531. for ( reg= 0; reg <= 5; reg ++ ) {
  532. if (pci_resource_flags(pdev, reg) & IORESOURCE_IO) {
  533. pci_io_base = pci_resource_start(pdev, reg);
  534. TLAN_DBG( TLAN_DEBUG_GNRL, "IO mapping is available at %x.n",
  535. pci_io_base);
  536. break;
  537. }
  538. }
  539. if (!pci_io_base) {
  540. printk(KERN_ERR "TLAN: No IO mappings availablen");
  541. unregister_netdev(dev);
  542. kfree(dev);
  543. return -ENODEV;
  544. }
  546. dev->base_addr = pci_io_base;
  547. dev->irq = pdev->irq;
  548. priv->adapterRev = pci_rev; 
  549. pci_set_master(pdev);
  550. pci_set_drvdata(pdev, dev);
  552. } else {     /* EISA card */
  553. /* This is a hack. We need to know which board structure
  554.  * is suited for this adapter */
  555. device_id = inw(ioaddr + EISA_ID2);
  556. priv->is_eisa = 1;
  557. if (device_id == 0x20F1) {
  558. priv->adapter = &board_info[13];  /* NetFlex-3/E */
  559. priv->adapterRev = 23; /* TLAN 2.3 */
  560. } else {
  561. priv->adapter = &board_info[14];
  562. priv->adapterRev = 10; /* TLAN 1.0 */
  563. }
  564. dev->base_addr = ioaddr;
  565. dev->irq = irq;
  566. }
  568. /* Kernel parameters */
  569. if (dev->mem_start) {
  570. priv->aui    = dev->mem_start & 0x01;
  571. priv->duplex = ((dev->mem_start & 0x06) == 0x06) ? 0 : (dev->mem_start & 0x06) >> 1;
  572. priv->speed  = ((dev->mem_start & 0x18) == 0x18) ? 0 : (dev->mem_start & 0x18) >> 3;
  574. if (priv->speed == 0x1) {
  575. priv->speed = TLAN_SPEED_10;
  576. } else if (priv->speed == 0x2) {
  577. priv->speed = TLAN_SPEED_100;
  578. }
  579. debug = priv->debug = dev->mem_end;
  580. } else {
  581. priv->aui    = aui[boards_found];
  582. priv->speed  = speed[boards_found];
  583. priv->duplex = duplex[boards_found];
  584. priv->debug = debug;
  585. }
  587. /* This will be used when we get an adapter error from
  588.  * within our irq handler */
  589. INIT_LIST_HEAD(&priv->tlan_tqueue.list);
  590. priv->tlan_tqueue.sync = 0;
  591. priv->tlan_tqueue.routine = (void *)(void*)TLan_tx_timeout;
  592. priv->tlan_tqueue.data = dev;
  594. spin_lock_init(&priv->lock);
  596. if (TLan_Init(dev)) {
  597. printk(KERN_ERR "TLAN: Could not register device.n");
  598. unregister_netdev(dev);
  599. kfree(dev);
  600. return -EAGAIN;
  601. } else {
  603. TLanDevicesInstalled++;
  604. boards_found++;
  606. /* pdev is NULL if this is an EISA device */
  607. if (pdev)
  608. tlan_have_pci++;
  609. else {
  610. priv->nextDevice = TLan_Eisa_Devices;
  611. TLan_Eisa_Devices = dev;
  612. tlan_have_eisa++;
  613. }
  615. printk(KERN_INFO "TLAN: %s irq=%2d, io=%04x, %s, Rev. %dn",
  616. dev->name,
  617. (int) dev->irq,
  618. (int) dev->base_addr,
  619. priv->adapter->deviceLabel,
  620. priv->adapterRev);
  621. return 0;
  622. }
  624. }
  627. static void TLan_Eisa_Cleanup(void)
  628. {
  629. struct net_device *dev;
  630. TLanPrivateInfo *priv;
  632. while( tlan_have_eisa ) {
  633. dev = TLan_Eisa_Devices;
  634. priv = dev->priv;
  635. if (priv->dmaStorage) {
  636. kfree(priv->dmaStorage);
  637. }
  638. release_region( dev->base_addr, 0x10);
  639. unregister_netdev( dev );
  640. TLan_Eisa_Devices = priv->nextDevice;
  641. kfree( dev );
  642. tlan_have_eisa--;
  643. }
  644. }
  647. static void __exit tlan_exit(void)
  648. {
  649. pci_unregister_driver(&tlan_driver);
  651. if (tlan_have_eisa)
  652. TLan_Eisa_Cleanup();
  654. kfree( TLanPadBuffer );
  656. }
  659. /* Module loading/unloading */
  660. module_init(tlan_probe);
  661. module_exit(tlan_exit);
  665. /**************************************************************
  666.  *  TLan_EisaProbe
  667.  *
  668.  *   Returns: 0 on success, 1 otherwise
  669.  *
  670.  *   Parms:  None
  671.  *
  672.  *
  673.  *   This functions probes for EISA devices and calls 
  674.  *   TLan_probe1 when one is found. 
  675.  *
  676.  *************************************************************/
  678. static void  __init TLan_EisaProbe (void) 
  679. {
  680. long  ioaddr;
  681. int  rc = -ENODEV;
  682. int  irq;
  683. u16 device_id;
  685. if (!EISA_bus) {
  686. TLAN_DBG(TLAN_DEBUG_PROBE, "No EISA bus presentn");
  687. return;
  688. }
  690. /* Loop through all slots of the EISA bus */
  691. for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
  693. TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4xn", (int) ioaddr + 0xC80, inw(ioaddr + EISA_ID));
  694. TLAN_DBG(TLAN_DEBUG_PROBE,"EISA_ID 0x%4x: 0x%4xn", (int) ioaddr + 0xC82, inw(ioaddr + EISA_ID2));
  697. TLAN_DBG(TLAN_DEBUG_PROBE, "Probing for EISA adapter at IO: 0x%4x : ",
  698.     (int) ioaddr);
  699. if (request_region(ioaddr, 0x10, TLanSignature) == NULL) 
  700. goto out;
  702. if (inw(ioaddr + EISA_ID) != 0x110E) {
  703. release_region(ioaddr, 0x10);
  704. goto out;
  705. }
  707. device_id = inw(ioaddr + EISA_ID2);
  708. if (device_id !=  0x20F1 && device_id != 0x40F1) { 
  709. release_region (ioaddr, 0x10);
  710. goto out;
  711. }
  713.   if (inb(ioaddr + EISA_CR) != 0x1) {  /* Check if adapter is enabled */
  714. release_region (ioaddr, 0x10);
  715. goto out2;
  716. }
  718. if (debug == 0x10)
  719. printk("Found onen");
  722. /* Get irq from board */
  723. switch (inb(ioaddr + 0xCC0)) {
  724. case(0x10):
  725. irq=5;
  726. break;
  727. case(0x20):
  728. irq=9;
  729. break;
  730. case(0x40):
  731. irq=10;
  732. break;
  733. case(0x80):
  734. irq=11;
  735. break;
  736. default:
  737. goto out;
  738. }               
  741. /* Setup the newly found eisa adapter */
  742. rc = TLan_probe1( NULL, ioaddr, irq,
  743. 12, NULL);
  744. continue;
  746. out:
  747. if (debug == 0x10)
  748. printk("None foundn");
  749. continue;
  751. out2: if (debug == 0x10)
  752. printk("Card found but it is not enabled, skippingn");
  753. continue;
  755. }
  757. } /* TLan_EisaProbe */
  763. /***************************************************************
  764.  * TLan_Init
  765.  *
  766.  * Returns:
  767.  * 0 on success, error code otherwise.
  768.  * Parms:
  769.  * dev The structure of the device to be
  770.  * init'ed.
  771.  *
  772.  * This function completes the initialization of the
  773.  * device structure and driver.  It reserves the IO
  774.  * addresses, allocates memory for the lists and bounce
  775.  * buffers, retrieves the MAC address from the eeprom
  776.  * and assignes the device's methods.
  777.  *
  778.  **************************************************************/
  780. static int TLan_Init( struct net_device *dev )
  781. {
  782. int dma_size;
  783. int  err;
  784. int i;
  785. TLanPrivateInfo *priv;
  787. priv = dev->priv;
  789. if (!priv->is_eisa) /* EISA devices have already requested IO */
  790. if (!request_region( dev->base_addr, 0x10, TLanSignature )) {
  791. printk(KERN_ERR "TLAN: %s: IO port region 0x%lx size 0x%x in use.n",
  792. dev->name,
  793. dev->base_addr,
  794. 0x10 );
  795. return -EIO;
  796. }
  798. if ( bbuf ) {
  799. dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS )
  800.            * ( sizeof(TLanList) + TLAN_MAX_FRAME_SIZE );
  801. } else {
  802. dma_size = ( TLAN_NUM_RX_LISTS + TLAN_NUM_TX_LISTS )
  803.            * ( sizeof(TLanList) );
  804. }
  805. priv->dmaStorage = kmalloc(dma_size, GFP_KERNEL | GFP_DMA);
  806. if ( priv->dmaStorage == NULL ) {
  807. printk(KERN_ERR "TLAN:  Could not allocate lists and buffers for %s.n",
  808. dev->name );
  809. release_region( dev->base_addr, 0x10 );
  810. return -ENOMEM;
  811. }
  812. memset( priv->dmaStorage, 0, dma_size );
  813. priv->rxList = (TLanList *) 
  814.        ( ( ( (u32) priv->dmaStorage ) + 7 ) & 0xFFFFFFF8 );
  815. priv->txList = priv->rxList + TLAN_NUM_RX_LISTS;
  816. if ( bbuf ) {
  817. priv->rxBuffer = (u8 *) ( priv->txList + TLAN_NUM_TX_LISTS );
  818. priv->txBuffer = priv->rxBuffer
  819.  + ( TLAN_NUM_RX_LISTS * TLAN_MAX_FRAME_SIZE );
  820. }
  822. err = 0;
  823. for ( i = 0;  i < 6 ; i++ )
  824. err |= TLan_EeReadByte( dev,
  825. (u8) priv->adapter->addrOfs + i,
  826. (u8 *) &dev->dev_addr[i] );
  827. if ( err ) {
  828. printk(KERN_ERR "TLAN: %s: Error reading MAC from eeprom: %dn",
  829. dev->name,
  830. err );
  831. }
  832. dev->addr_len = 6;
  834. /* Device methods */
  835. dev->open = &TLan_Open;
  836. dev->hard_start_xmit = &TLan_StartTx;
  837. dev->stop = &TLan_Close;
  838. dev->get_stats = &TLan_GetStats;
  839. dev->set_multicast_list = &TLan_SetMulticastList;
  840. dev->do_ioctl = &TLan_ioctl;
  841. dev->tx_timeout = &TLan_tx_timeout;
  842. dev->watchdog_timeo = TX_TIMEOUT;
  844. return 0;
  846. } /* TLan_Init */
  851. /***************************************************************
  852.  * TLan_Open
  853.  *
  854.  * Returns:
  855.  * 0 on success, error code otherwise.
  856.  * Parms:
  857.  * dev Structure of device to be opened.
  858.  *
  859.  * This routine puts the driver and TLAN adapter in a
  860.  * state where it is ready to send and receive packets.
  861.  * It allocates the IRQ, resets and brings the adapter
  862.  * out of reset, and allows interrupts.  It also delays
  863.  * the startup for autonegotiation or sends a Rx GO
  864.  * command to the adapter, as appropriate.
  865.  *
  866.  **************************************************************/
  868. static int TLan_Open( struct net_device *dev )
  869. {
  870. TLanPrivateInfo *priv = dev->priv;
  871. int err;
  873. priv->tlanRev = TLan_DioRead8( dev->base_addr, TLAN_DEF_REVISION );
  874. err = request_irq( dev->irq, TLan_HandleInterrupt, SA_SHIRQ, TLanSignature, dev );
  876. if ( err ) {
  877. printk(KERN_ERR "TLAN:  Cannot open %s because IRQ %d is already in use.n", dev->name, dev->irq );
  878. return err;
  879. }
  881. init_timer(&priv->timer);
  882. netif_start_queue(dev);
  884. /* NOTE: It might not be necessary to read the stats before a
  885.  reset if you don't care what the values are.
  886. */
  887. TLan_ResetLists( dev );
  888. TLan_ReadAndClearStats( dev, TLAN_IGNORE );
  889. TLan_ResetAdapter( dev );
  891. TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Opened.  TLAN Chip Rev: %xn", dev->name, priv->tlanRev );
  893. return 0;
  895. } /* TLan_Open */
  899. /**************************************************************
  900.  * TLan_ioctl
  901.  *
  902.  * Returns:
  903.  * 0 on success, error code otherwise
  904.  * Params:
  905.  * dev structure of device to receive ioctl.
  906.  *
  907.  * rq ifreq structure to hold userspace data.
  908.  *
  909.  * cmd ioctl command.
  910.  *
  911.  *
  912.  *************************************************************/
  914. static int TLan_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  915. {
  916. TLanPrivateInfo *priv = dev->priv;
  917. struct mii_ioctl_data *data = (struct mii_ioctl_data *)&rq->ifr_data;
  918. u32 phy   = priv->phy[priv->phyNum];
  920. if (!priv->phyOnline)
  921. return -EAGAIN;
  923. switch(cmd) {
  924. case SIOCGMIIPHY: /* Get address of MII PHY in use. */
  925. case SIOCDEVPRIVATE: /* for binary compat, remove in 2.5 */
  926. data->phy_id = phy;
  929. case SIOCGMIIREG: /* Read MII PHY register. */
  930. case SIOCDEVPRIVATE+1: /* for binary compat, remove in 2.5 */
  931. TLan_MiiReadReg(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, &data->val_out);
  932. return 0;
  935. case SIOCSMIIREG: /* Write MII PHY register. */
  936. case SIOCDEVPRIVATE+2: /* for binary compat, remove in 2.5 */
  937. if (!capable(CAP_NET_ADMIN))
  938. return -EPERM;
  939. TLan_MiiWriteReg(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
  940. return 0;
  941. default:
  942. return -EOPNOTSUPP;
  943. }
  944. } /* tlan_ioctl */
  947. /***************************************************************
  948.  *  TLan_tx_timeout
  949.  *
  950.  *  Returns: nothing
  951.  *
  952.  *  Params:
  953.  *  dev structure of device which timed out 
  954.  *  during transmit.
  955.  *
  956.  **************************************************************/
  958. static void TLan_tx_timeout(struct net_device *dev)
  959. {
  961. TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Transmit timed out.n", dev->name);
  963. /* Ok so we timed out, lets see what we can do about it...*/
  964. TLan_FreeLists( dev );
  965. TLan_ResetLists( dev );
  966. TLan_ReadAndClearStats( dev, TLAN_IGNORE );
  967. TLan_ResetAdapter( dev );
  968. dev->trans_start = jiffies;
  969. netif_wake_queue( dev );
  971. }
  975. /***************************************************************
  976.  * TLan_StartTx
  977.  *  
  978.  * Returns:
  979.  * 0 on success, non-zero on failure.
  980.  * Parms:
  981.  * skb A pointer to the sk_buff containing the
  982.  * frame to be sent.
  983.  * dev The device to send the data on.
  984.  *
  985.  * This function adds a frame to the Tx list to be sent
  986.  * ASAP.  First it verifies that the adapter is ready and
  987.  * there is room in the queue.  Then it sets up the next
  988.  * available list, copies the frame to the corresponding
  989.  * buffer.  If the adapter Tx channel is idle, it gives
  990.  * the adapter a Tx Go command on the list, otherwise it
  991.  * sets the forward address of the previous list to point
  992.  * to this one.  Then it frees the sk_buff.
  993.  *
  994.  **************************************************************/
  996. static int TLan_StartTx( struct sk_buff *skb, struct net_device *dev )
  997. {
  998. TLanPrivateInfo *priv = dev->priv;
  999. TLanList *tail_list;
  1000. u8 *tail_buffer;
  1001. int pad;
  1002. unsigned long flags;
  1004. if ( ! priv->phyOnline ) {
  1005. TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s PHY is not readyn", dev->name );
  1006. dev_kfree_skb_any(skb);
  1007. return 0;
  1008. }
  1010. tail_list = priv->txList + priv->txTail;
  1012. if ( tail_list->cStat != TLAN_CSTAT_UNUSED ) {
  1013. TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s is busy (Head=%d Tail=%d)n", dev->name, priv->txHead, priv->txTail );
  1014. netif_stop_queue(dev);
  1015. priv->txBusyCount++;
  1016. return 1;
  1017. }
  1019. tail_list->forward = 0;
  1021. if ( bbuf ) {
  1022. tail_buffer = priv->txBuffer + ( priv->txTail * TLAN_MAX_FRAME_SIZE );
  1023. memcpy( tail_buffer, skb->data, skb->len );
  1024. } else {
  1025. tail_list->buffer[0].address = virt_to_bus( skb->data );
  1026. tail_list->buffer[9].address = (u32) skb;
  1027. }
  1029. pad = TLAN_MIN_FRAME_SIZE - skb->len;
  1031. if ( pad > 0 ) {
  1032. tail_list->frameSize = (u16) skb->len + pad;
  1033. tail_list->buffer[0].count = (u32) skb->len;
  1034. tail_list->buffer[1].count = TLAN_LAST_BUFFER | (u32) pad;
  1035. tail_list->buffer[1].address = virt_to_bus( TLanPadBuffer );
  1036. } else {
  1037. tail_list->frameSize = (u16) skb->len;
  1038. tail_list->buffer[0].count = TLAN_LAST_BUFFER | (u32) skb->len;
  1039. tail_list->buffer[1].count = 0;
  1040. tail_list->buffer[1].address = 0;
  1041. }
  1043. spin_lock_irqsave(&priv->lock, flags);
  1044. tail_list->cStat = TLAN_CSTAT_READY;
  1045. if ( ! priv->txInProgress ) {
  1046. priv->txInProgress = 1;
  1047. TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Starting TX on buffer %dn", priv->txTail );
  1048. outl( virt_to_bus( tail_list ), dev->base_addr + TLAN_CH_PARM );
  1049. outl( TLAN_HC_GO, dev->base_addr + TLAN_HOST_CMD );
  1050. } else {
  1051. TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Adding buffer %d to TX channeln", priv->txTail );
  1052. if ( priv->txTail == 0 ) {
  1053. ( priv->txList + ( TLAN_NUM_TX_LISTS - 1 ) )->forward = virt_to_bus( tail_list );
  1054. } else {
  1055. ( priv->txList + ( priv->txTail - 1 ) )->forward = virt_to_bus( tail_list );
  1056. }
  1057. }
  1058. spin_unlock_irqrestore(&priv->lock, flags);
  1060. CIRC_INC( priv->txTail, TLAN_NUM_TX_LISTS );
  1062. if ( bbuf )
  1063. dev_kfree_skb_any(skb);
  1065. dev->trans_start = jiffies;
  1066. return 0;
  1068. } /* TLan_StartTx */
  1073. /***************************************************************
  1074.  * TLan_HandleInterrupt
  1075.  *  
  1076.  * Returns:
  1077.  * Nothing
  1078.  * Parms:
  1079.  * irq The line on which the interrupt
  1080.  * occurred.
  1081.  * dev_id A pointer to the device assigned to
  1082.  * this irq line.
  1083.  * regs ???
  1084.  *
  1085.  * This function handles an interrupt generated by its
  1086.  * assigned TLAN adapter.  The function deactivates
  1087.  * interrupts on its adapter, records the type of
  1088.  * interrupt, executes the appropriate subhandler, and
  1089.  * acknowdges the interrupt to the adapter (thus
  1090.  * re-enabling adapter interrupts.
  1091.  *
  1092.  **************************************************************/
  1094. static void TLan_HandleInterrupt(int irq, void *dev_id, struct pt_regs *regs)
  1095. {
  1096. u32 ack;
  1097. struct net_device *dev;
  1098. u32 host_cmd;
  1099. u16 host_int;
  1100. int type;
  1101. TLanPrivateInfo *priv;
  1103. dev = dev_id;
  1104. priv = dev->priv;
  1106. spin_lock(&priv->lock);
  1108. host_int = inw( dev->base_addr + TLAN_HOST_INT );
  1109. outw( host_int, dev->base_addr + TLAN_HOST_INT );
  1111. type = ( host_int & TLAN_HI_IT_MASK ) >> 2;
  1113. ack = TLanIntVector[type]( dev, host_int );
  1115. if ( ack ) {
  1116. host_cmd = TLAN_HC_ACK | ack | ( type << 18 );
  1117. outl( host_cmd, dev->base_addr + TLAN_HOST_CMD );
  1118. }
  1120. spin_unlock(&priv->lock);
  1122. } /* TLan_HandleInterrupts */
  1127. /***************************************************************
  1128.  * TLan_Close
  1129.  *  
  1130.  *  Returns:
  1131.  * An error code.
  1132.  * Parms:
  1133.  * dev The device structure of the device to
  1134.  * close.
  1135.  *
  1136.  * This function shuts down the adapter.  It records any
  1137.  * stats, puts the adapter into reset state, deactivates
  1138.  * its time as needed, and frees the irq it is using.
  1139.  *
  1140.  **************************************************************/
  1142. static int TLan_Close(struct net_device *dev)
  1143. {
  1144. TLanPrivateInfo *priv = dev->priv;
  1146. netif_stop_queue(dev);
  1147. priv->neg_be_verbose = 0;
  1149. TLan_ReadAndClearStats( dev, TLAN_RECORD );
  1150. outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD );
  1151. if ( priv->timer.function != NULL ) {
  1152. del_timer_sync( &priv->timer );
  1153. priv->timer.function = NULL;
  1154. }
  1156. free_irq( dev->irq, dev );
  1157. TLan_FreeLists( dev );
  1158. TLAN_DBG( TLAN_DEBUG_GNRL, "Device %s closed.n", dev->name );
  1160. return 0;
  1162. } /* TLan_Close */
  1167. /***************************************************************
  1168.  * TLan_GetStats
  1169.  *  
  1170.  * Returns:
  1171.  * A pointer to the device's statistics structure.
  1172.  * Parms:
  1173.  * dev The device structure to return the
  1174.  * stats for.
  1175.  *
  1176.  * This function updates the devices statistics by reading
  1177.  * the TLAN chip's onboard registers.  Then it returns the
  1178.  * address of the statistics structure.
  1179.  *
  1180.  **************************************************************/
  1182. static struct net_device_stats *TLan_GetStats( struct net_device *dev )
  1183. {
  1184. TLanPrivateInfo *priv = dev->priv;
  1185. int i;
  1187. /* Should only read stats if open ? */
  1188. TLan_ReadAndClearStats( dev, TLAN_RECORD );
  1190. TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  %s EOC count = %dn", dev->name, priv->rxEocCount );
  1191. TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  %s Busy count = %dn", dev->name, priv->txBusyCount );
  1192. if ( debug & TLAN_DEBUG_GNRL ) {
  1193. TLan_PrintDio( dev->base_addr );
  1194. TLan_PhyPrint( dev );
  1195. }
  1196. if ( debug & TLAN_DEBUG_LIST ) {
  1197. for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ )
  1198. TLan_PrintList( priv->rxList + i, "RX", i );
  1199. for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ )
  1200. TLan_PrintList( priv->txList + i, "TX", i );
  1201. }
  1203. return ( &( (TLanPrivateInfo *) dev->priv )->stats );
  1205. } /* TLan_GetStats */
  1210. /***************************************************************
  1211.  * TLan_SetMulticastList
  1212.  *  
  1213.  * Returns:
  1214.  * Nothing
  1215.  * Parms:
  1216.  * dev The device structure to set the
  1217.  * multicast list for.
  1218.  *
  1219.  * This function sets the TLAN adaptor to various receive
  1220.  * modes.  If the IFF_PROMISC flag is set, promiscuous
  1221.  * mode is acitviated.  Otherwise, promiscuous mode is
  1222.  * turned off.  If the IFF_ALLMULTI flag is set, then
  1223.  * the hash table is set to receive all group addresses.
  1224.  * Otherwise, the first three multicast addresses are
  1225.  * stored in AREG_1-3, and the rest are selected via the
  1226.  * hash table, as necessary.
  1227.  *
  1228.  **************************************************************/
  1230. static void TLan_SetMulticastList( struct net_device *dev )
  1231. {
  1232. struct dev_mc_list *dmi = dev->mc_list;
  1233. u32 hash1 = 0;
  1234. u32 hash2 = 0;
  1235. int i;
  1236. u32 offset;
  1237. u8 tmp;
  1239. if ( dev->flags & IFF_PROMISC ) {
  1240. tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD );
  1241. TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, tmp | TLAN_NET_CMD_CAF );
  1242. } else {
  1243. tmp = TLan_DioRead8( dev->base_addr, TLAN_NET_CMD );
  1244. TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, tmp & ~TLAN_NET_CMD_CAF );
  1245. if ( dev->flags & IFF_ALLMULTI ) {
  1246. for ( i = 0; i < 3; i++ ) 
  1247. TLan_SetMac( dev, i + 1, NULL );
  1248. TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, 0xFFFFFFFF );
  1249. TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, 0xFFFFFFFF );
  1250. } else {
  1251. for ( i = 0; i < dev->mc_count; i++ ) {
  1252. if ( i < 3 ) {
  1253. TLan_SetMac( dev, i + 1, (char *) &dmi->dmi_addr );
  1254. } else {
  1255. offset = TLan_HashFunc( (u8 *) &dmi->dmi_addr );
  1256. if ( offset < 32 ) 
  1257. hash1 |= ( 1 << offset );
  1258. else
  1259. hash2 |= ( 1 << ( offset - 32 ) );
  1260. }
  1261. dmi = dmi->next;
  1262. }
  1263. for ( ; i < 3; i++ ) 
  1264. TLan_SetMac( dev, i + 1, NULL );
  1265. TLan_DioWrite32( dev->base_addr, TLAN_HASH_1, hash1 );
  1266. TLan_DioWrite32( dev->base_addr, TLAN_HASH_2, hash2 );
  1267. }
  1268. }
  1270. } /* TLan_SetMulticastList */
  1274. /*****************************************************************************
  1275. ******************************************************************************
  1277.         ThunderLAN Driver Interrupt Vectors and Table
  1279. Please see Chap. 4, "Interrupt Handling" of the "ThunderLAN
  1280. Programmer's Guide" for more informations on handling interrupts
  1281. generated by TLAN based adapters.  
  1283. ******************************************************************************
  1284. *****************************************************************************/
  1287. /***************************************************************
  1288.  * TLan_HandleInvalid
  1289.  *
  1290.  * Returns:
  1291.  * 0
  1292.  * Parms:
  1293.  * dev Device assigned the IRQ that was
  1294.  * raised.
  1295.  * host_int The contents of the HOST_INT
  1296.  * port.
  1297.  *
  1298.  * This function handles invalid interrupts.  This should
  1299.  * never happen unless some other adapter is trying to use
  1300.  * the IRQ line assigned to the device.
  1301.  *
  1302.  **************************************************************/
  1304. u32 TLan_HandleInvalid( struct net_device *dev, u16 host_int )
  1305. {
  1306. /* printk( "TLAN:  Invalid interrupt on %s.n", dev->name ); */
  1307. return 0;
  1309. } /* TLan_HandleInvalid */
  1314. /***************************************************************
  1315.  * TLan_HandleTxEOF
  1316.  *
  1317.  * Returns:
  1318.  * 1
  1319.  * Parms:
  1320.  * dev Device assigned the IRQ that was
  1321.  * raised.
  1322.  * host_int The contents of the HOST_INT
  1323.  * port.
  1324.  *
  1325.  * This function handles Tx EOF interrupts which are raised
  1326.  * by the adapter when it has completed sending the
  1327.  * contents of a buffer.  If detemines which list/buffer
  1328.  * was completed and resets it.  If the buffer was the last
  1329.  * in the channel (EOC), then the function checks to see if
  1330.  * another buffer is ready to send, and if so, sends a Tx
  1331.  * Go command.  Finally, the driver activates/continues the
  1332.  * activity LED.
  1333.  *
  1334.  **************************************************************/
  1336. u32 TLan_HandleTxEOF( struct net_device *dev, u16 host_int )
  1337. {
  1338. TLanPrivateInfo *priv = dev->priv;
  1339. int eoc = 0;
  1340. TLanList *head_list;
  1341. u32 ack = 0;
  1342. u16 tmpCStat;
  1344. TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOF (Head=%d Tail=%d)n", priv->txHead, priv->txTail );
  1345. head_list = priv->txList + priv->txHead;
  1347. while (((tmpCStat = head_list->cStat ) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) {
  1348. ack++;
  1349. if ( ! bbuf ) {
  1350. dev_kfree_skb_any( (struct sk_buff *) head_list->buffer[9].address );
  1351. head_list->buffer[9].address = 0;
  1352. }
  1354. if ( tmpCStat & TLAN_CSTAT_EOC )
  1355. eoc = 1;
  1357. priv->stats.tx_bytes += head_list->frameSize;
  1359. head_list->cStat = TLAN_CSTAT_UNUSED;
  1360. netif_start_queue(dev);
  1361. CIRC_INC( priv->txHead, TLAN_NUM_TX_LISTS ); 
  1362. head_list = priv->txList + priv->txHead;
  1363. }
  1365. if (!ack)
  1366. printk(KERN_INFO "TLAN: Received interrupt for uncompleted TX frame.n");
  1368. if ( eoc ) {
  1369. TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOC (Head=%d Tail=%d)n", priv->txHead, priv->txTail );
  1370. head_list = priv->txList + priv->txHead;
  1371. if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
  1372. outl( virt_to_bus( head_list ), dev->base_addr + TLAN_CH_PARM );
  1373. ack |= TLAN_HC_GO;
  1374. } else {
  1375. priv->txInProgress = 0;
  1376. }
  1377. }
  1379. if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
  1380. TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
  1381. if ( priv->timer.function == NULL ) {
  1382.  priv->timer.function = &TLan_Timer;
  1383.  priv->timer.data = (unsigned long) dev;
  1384.  priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
  1385.  priv->timerSetAt = jiffies;
  1386.  priv->timerType = TLAN_TIMER_ACTIVITY;
  1387.  add_timer(&priv->timer);
  1388. } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) {
  1389. priv->timerSetAt = jiffies;
  1390. }
  1391. }
  1393. return ack;
  1395. } /* TLan_HandleTxEOF */
  1400. /***************************************************************
  1401.  * TLan_HandleStatOverflow
  1402.  *
  1403.  * Returns:
  1404.  * 1
  1405.  * Parms:
  1406.  * dev Device assigned the IRQ that was
  1407.  * raised.
  1408.  * host_int The contents of the HOST_INT
  1409.  * port.
  1410.  *
  1411.  * This function handles the Statistics Overflow interrupt
  1412.  * which means that one or more of the TLAN statistics
  1413.  * registers has reached 1/2 capacity and needs to be read.
  1414.  *
  1415.  **************************************************************/
  1417. u32 TLan_HandleStatOverflow( struct net_device *dev, u16 host_int )
  1418. {
  1419. TLan_ReadAndClearStats( dev, TLAN_RECORD );
  1421. return 1;
  1423. } /* TLan_HandleStatOverflow */
  1428. /***************************************************************
  1429.  * TLan_HandleRxEOF
  1430.  *
  1431.  * Returns:
  1432.  * 1
  1433.  * Parms:
  1434.  * dev Device assigned the IRQ that was
  1435.  * raised.
  1436.  * host_int The contents of the HOST_INT
  1437.  * port.
  1438.  *
  1439.  * This function handles the Rx EOF interrupt which
  1440.  * indicates a frame has been received by the adapter from
  1441.  * the net and the frame has been transferred to memory.
  1442.  * The function determines the bounce buffer the frame has
  1443.  * been loaded into, creates a new sk_buff big enough to
  1444.  * hold the frame, and sends it to protocol stack.  It
  1445.  * then resets the used buffer and appends it to the end
  1446.  * of the list.  If the frame was the last in the Rx
  1447.  * channel (EOC), the function restarts the receive channel
  1448.  * by sending an Rx Go command to the adapter.  Then it
  1449.  * activates/continues the activity LED.
  1450.  *
  1451.  **************************************************************/
  1453. u32 TLan_HandleRxEOF( struct net_device *dev, u16 host_int )
  1454. {
  1455. TLanPrivateInfo *priv = dev->priv;
  1456. u32 ack = 0;
  1457. int eoc = 0;
  1458. u8 *head_buffer;
  1459. TLanList *head_list;
  1460. struct sk_buff *skb;
  1461. TLanList *tail_list;
  1462. void *t;
  1463. u32 frameSize;
  1464. u16 tmpCStat;
  1466. TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOF (Head=%d Tail=%d)n", priv->rxHead, priv->rxTail );
  1467. head_list = priv->rxList + priv->rxHead;
  1469. while (((tmpCStat = head_list->cStat) & TLAN_CSTAT_FRM_CMP) && (ack < 255)) {
  1470. frameSize = head_list->frameSize;
  1471. ack++;
  1472. if (tmpCStat & TLAN_CSTAT_EOC)
  1473. eoc = 1;
  1475. if (bbuf) {
  1476. skb = dev_alloc_skb(frameSize + 7);
  1477. if (skb == NULL)
  1478. printk(KERN_INFO "TLAN: Couldn't allocate memory for received data.n");
  1479. else {
  1480. head_buffer = priv->rxBuffer + (priv->rxHead * TLAN_MAX_FRAME_SIZE);
  1481. skb->dev = dev;
  1482. skb_reserve(skb, 2);
  1483. t = (void *) skb_put(skb, frameSize);
  1485. priv->stats.rx_bytes += head_list->frameSize;
  1487. memcpy( t, head_buffer, frameSize );
  1488. skb->protocol = eth_type_trans( skb, dev );
  1489. netif_rx( skb );
  1490. }
  1491. } else {
  1492. struct sk_buff *new_skb;
  1494. /*
  1495.   * I changed the algorithm here. What we now do
  1496.   * is allocate the new frame. If this fails we
  1497.   * simply recycle the frame.
  1498.   */
  1500. new_skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
  1502. if ( new_skb != NULL ) {
  1503. /* If this ever happened it would be a problem */
  1504. /* not any more - ac */
  1505. skb = (struct sk_buff *) head_list->buffer[9].address;
  1506. skb_trim( skb, frameSize );
  1508. priv->stats.rx_bytes += frameSize;
  1510. skb->protocol = eth_type_trans( skb, dev );
  1511. netif_rx( skb );
  1513. new_skb->dev = dev;
  1514. skb_reserve( new_skb, 2 );
  1515. t = (void *) skb_put( new_skb, TLAN_MAX_FRAME_SIZE );
  1516. head_list->buffer[0].address = virt_to_bus( t );
  1517. head_list->buffer[8].address = (u32) t;
  1518. head_list->buffer[9].address = (u32) new_skb;
  1519. } else 
  1520. printk(KERN_WARNING "TLAN:  Couldn't allocate memory for received data.n" );
  1521. }
  1523. head_list->forward = 0;
  1524. head_list->cStat = 0;
  1525. tail_list = priv->rxList + priv->rxTail;
  1526. tail_list->forward = virt_to_bus( head_list );
  1528. CIRC_INC( priv->rxHead, TLAN_NUM_RX_LISTS );
  1529. CIRC_INC( priv->rxTail, TLAN_NUM_RX_LISTS );
  1530. head_list = priv->rxList + priv->rxHead;
  1531. }
  1533. if (!ack)
  1534. printk(KERN_INFO "TLAN: Received interrupt for uncompleted RX frame.n");
  1539. if ( eoc ) { 
  1540. TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOC (Head=%d Tail=%d)n", priv->rxHead, priv->rxTail );
  1541. head_list = priv->rxList + priv->rxHead;
  1542. outl( virt_to_bus( head_list ), dev->base_addr + TLAN_CH_PARM );
  1543. ack |= TLAN_HC_GO | TLAN_HC_RT;
  1544. priv->rxEocCount++;
  1545. }
  1547. if ( priv->adapter->flags & TLAN_ADAPTER_ACTIVITY_LED ) {
  1548. TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT );
  1549. if ( priv->timer.function == NULL )  {
  1550. priv->timer.function = &TLan_Timer;
  1551. priv->timer.data = (unsigned long) dev;
  1552. priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
  1553. priv->timerSetAt = jiffies;
  1554. priv->timerType = TLAN_TIMER_ACTIVITY;
  1555. add_timer(&priv->timer);
  1556. } else if ( priv->timerType == TLAN_TIMER_ACTIVITY ) {
  1557. priv->timerSetAt = jiffies;
  1558. }
  1559. }
  1561. dev->last_rx = jiffies;
  1563. return ack;
  1565. } /* TLan_HandleRxEOF */
  1570. /***************************************************************
  1571.  * TLan_HandleDummy
  1572.  *
  1573.  * Returns:
  1574.  * 1
  1575.  * Parms:
  1576.  * dev Device assigned the IRQ that was
  1577.  * raised.
  1578.  * host_int The contents of the HOST_INT
  1579.  * port.
  1580.  *
  1581.  * This function handles the Dummy interrupt, which is
  1582.  * raised whenever a test interrupt is generated by setting
  1583.  * the Req_Int bit of HOST_CMD to 1.
  1584.  *
  1585.  **************************************************************/
  1587. u32 TLan_HandleDummy( struct net_device *dev, u16 host_int )
  1588. {
  1589. printk( "TLAN:  Test interrupt on %s.n", dev->name );
  1590. return 1;
  1592. } /* TLan_HandleDummy */
  1597. /***************************************************************
  1598.  * TLan_HandleTxEOC
  1599.  *
  1600.  * Returns:
  1601.  * 1
  1602.  * Parms:
  1603.  * dev Device assigned the IRQ that was
  1604.  * raised.
  1605.  * host_int The contents of the HOST_INT
  1606.  * port.
  1607.  *
  1608.  * This driver is structured to determine EOC occurances by
  1609.  * reading the CSTAT member of the list structure.  Tx EOC
  1610.  * interrupts are disabled via the DIO INTDIS register.
  1611.  * However, TLAN chips before revision 3.0 didn't have this
  1612.  * functionality, so process EOC events if this is the
  1613.  * case.
  1614.  *
  1615.  **************************************************************/
  1617. u32 TLan_HandleTxEOC( struct net_device *dev, u16 host_int )
  1618. {
  1619. TLanPrivateInfo *priv = dev->priv;
  1620. TLanList *head_list;
  1621. u32 ack = 1;
  1623. host_int = 0;
  1624. if ( priv->tlanRev < 0x30 ) {
  1625. TLAN_DBG( TLAN_DEBUG_TX, "TRANSMIT:  Handling TX EOC (Head=%d Tail=%d) -- IRQn", priv->txHead, priv->txTail );
  1626. head_list = priv->txList + priv->txHead;
  1627. if ( ( head_list->cStat & TLAN_CSTAT_READY ) == TLAN_CSTAT_READY ) {
  1628. netif_stop_queue(dev);
  1629. outl( virt_to_bus( head_list ), dev->base_addr + TLAN_CH_PARM );
  1630. ack |= TLAN_HC_GO;
  1631. } else {
  1632. priv->txInProgress = 0;
  1633. }
  1634. }
  1636. return ack;
  1638. } /* TLan_HandleTxEOC */
  1643. /***************************************************************
  1644.  * TLan_HandleStatusCheck
  1645.  *
  1646.  * Returns:
  1647.  * 0 if Adapter check, 1 if Network Status check.
  1648.  * Parms:
  1649.  * dev Device assigned the IRQ that was
  1650.  * raised.
  1651.  * host_int The contents of the HOST_INT
  1652.  * port.
  1653.  *
  1654.  * This function handles Adapter Check/Network Status
  1655.  * interrupts generated by the adapter.  It checks the
  1656.  * vector in the HOST_INT register to determine if it is
  1657.  * an Adapter Check interrupt.  If so, it resets the
  1658.  * adapter.  Otherwise it clears the status registers
  1659.  * and services the PHY.
  1660.  *
  1661.  **************************************************************/
  1663. u32 TLan_HandleStatusCheck( struct net_device *dev, u16 host_int )
  1664. {
  1665. TLanPrivateInfo *priv = dev->priv;
  1666. u32 ack;
  1667. u32 error;
  1668. u8 net_sts;
  1669. u32 phy;
  1670. u16 tlphy_ctl;
  1671. u16 tlphy_sts;
  1673. ack = 1;
  1674. if ( host_int & TLAN_HI_IV_MASK ) {
  1675. netif_stop_queue( dev );
  1676. error = inl( dev->base_addr + TLAN_CH_PARM );
  1677. printk( "TLAN:  %s: Adaptor Error = 0x%xn", dev->name, error );
  1678. TLan_ReadAndClearStats( dev, TLAN_RECORD );
  1679. outl( TLAN_HC_AD_RST, dev->base_addr + TLAN_HOST_CMD );
  1681. queue_task(&priv->tlan_tqueue, &tq_immediate);
  1682. mark_bh(IMMEDIATE_BH);
  1684. netif_wake_queue(dev);
  1685. ack = 0;
  1686. } else {
  1687. TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Status Checkn", dev->name );
  1688. phy = priv->phy[priv->phyNum];
  1690. net_sts = TLan_DioRead8( dev->base_addr, TLAN_NET_STS );
  1691. if ( net_sts ) {
  1692. TLan_DioWrite8( dev->base_addr, TLAN_NET_STS, net_sts );
  1693. TLAN_DBG( TLAN_DEBUG_GNRL, "%s:    Net_Sts = %xn", dev->name, (unsigned) net_sts );
  1694. }
  1695. if ( ( net_sts & TLAN_NET_STS_MIRQ ) &&  ( priv->phyNum == 0 ) ) {
  1696. TLan_MiiReadReg( dev, phy, TLAN_TLPHY_STS, &tlphy_sts );
  1697. TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
  1698.          if ( ! ( tlphy_sts & TLAN_TS_POLOK ) && ! ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
  1699.                  tlphy_ctl |= TLAN_TC_SWAPOL;
  1700.                  TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
  1701.          } else if ( ( tlphy_sts & TLAN_TS_POLOK ) && ( tlphy_ctl & TLAN_TC_SWAPOL ) ) {
  1702.                  tlphy_ctl &= ~TLAN_TC_SWAPOL;
  1703.                  TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl);
  1704.          }
  1706. if (debug) {
  1707. TLan_PhyPrint( dev );
  1708. }
  1709. }
  1710. }
  1712. return ack;
  1714. } /* TLan_HandleStatusCheck */
  1719. /***************************************************************
  1720.  * TLan_HandleRxEOC
  1721.  *
  1722.  * Returns:
  1723.  * 1
  1724.  * Parms:
  1725.  * dev Device assigned the IRQ that was
  1726.  * raised.
  1727.  * host_int The contents of the HOST_INT
  1728.  * port.
  1729.  *
  1730.  * This driver is structured to determine EOC occurances by
  1731.  * reading the CSTAT member of the list structure.  Rx EOC
  1732.  * interrupts are disabled via the DIO INTDIS register.
  1733.  * However, TLAN chips before revision 3.0 didn't have this
  1734.  * CSTAT member or a INTDIS register, so if this chip is
  1735.  * pre-3.0, process EOC interrupts normally.
  1736.  *
  1737.  **************************************************************/
  1739. u32 TLan_HandleRxEOC( struct net_device *dev, u16 host_int )
  1740. {
  1741. TLanPrivateInfo *priv = dev->priv;
  1742. TLanList *head_list;
  1743. u32 ack = 1;
  1745. if (  priv->tlanRev < 0x30 ) {
  1746. TLAN_DBG( TLAN_DEBUG_RX, "RECEIVE:  Handling RX EOC (Head=%d Tail=%d) -- IRQn", priv->rxHead, priv->rxTail );
  1747. head_list = priv->rxList + priv->rxHead;
  1748. outl( virt_to_bus( head_list ), dev->base_addr + TLAN_CH_PARM );
  1749. ack |= TLAN_HC_GO | TLAN_HC_RT;
  1750. priv->rxEocCount++;
  1751. }
  1753. return ack;
  1755. } /* TLan_HandleRxEOC */
  1760. /*****************************************************************************
  1761. ******************************************************************************
  1763. ThunderLAN Driver Timer Function
  1765. ******************************************************************************
  1766. *****************************************************************************/
  1769. /***************************************************************
  1770.  * TLan_Timer
  1771.  *
  1772.  * Returns:
  1773.  * Nothing
  1774.  * Parms:
  1775.  * data A value given to add timer when
  1776.  * add_timer was called.
  1777.  *
  1778.  * This function handles timed functionality for the
  1779.  * TLAN driver.  The two current timer uses are for
  1780.  * delaying for autonegotionation and driving the ACT LED.
  1781.  * - Autonegotiation requires being allowed about
  1782.  * 2 1/2 seconds before attempting to transmit a
  1783.  * packet.  It would be a very bad thing to hang
  1784.  * the kernel this long, so the driver doesn't
  1785.  * allow transmission 'til after this time, for
  1786.  * certain PHYs.  It would be much nicer if all
  1787.  * PHYs were interrupt-capable like the internal
  1788.  * PHY.
  1789.  * - The ACT LED, which shows adapter activity, is
  1790.  * driven by the driver, and so must be left on
  1791.  * for a short period to power up the LED so it
  1792.  * can be seen.  This delay can be changed by
  1793.  * changing the TLAN_TIMER_ACT_DELAY in tlan.h,
  1794.  * if desired.  100 ms  produces a slightly
  1795.  * sluggish response.
  1796.  *
  1797.  **************************************************************/
  1799. void TLan_Timer( unsigned long data )
  1800. {
  1801. struct net_device *dev = (struct net_device *) data;
  1802. TLanPrivateInfo *priv = dev->priv;
  1803. u32 elapsed;
  1804. unsigned long flags = 0;
  1806. priv->timer.function = NULL;
  1808. switch ( priv->timerType ) {
  1809. #ifdef MONITOR
  1810. case TLAN_TIMER_LINK_BEAT:
  1811. TLan_PhyMonitor( dev );
  1812. break;
  1813. #endif
  1814. case TLAN_TIMER_PHY_PDOWN:
  1815. TLan_PhyPowerDown( dev );
  1816. break;
  1817. case TLAN_TIMER_PHY_PUP:
  1818. TLan_PhyPowerUp( dev );
  1819. break;
  1820. case TLAN_TIMER_PHY_RESET:
  1821. TLan_PhyReset( dev );
  1822. break;
  1823. case TLAN_TIMER_PHY_START_LINK:
  1824. TLan_PhyStartLink( dev );
  1825. break;
  1826. case TLAN_TIMER_PHY_FINISH_AN:
  1827. TLan_PhyFinishAutoNeg( dev );
  1828. break;
  1829. case TLAN_TIMER_FINISH_RESET:
  1830. TLan_FinishReset( dev );
  1831. break;
  1832. case TLAN_TIMER_ACTIVITY:
  1833. spin_lock_irqsave(&priv->lock, flags);
  1834. if ( priv->timer.function == NULL ) {
  1835. elapsed = jiffies - priv->timerSetAt;
  1836. if ( elapsed >= TLAN_TIMER_ACT_DELAY ) {
  1837. TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
  1838. } else  {
  1839. priv->timer.function = &TLan_Timer;
  1840. priv->timer.expires = priv->timerSetAt + TLAN_TIMER_ACT_DELAY;
  1841. spin_unlock_irqrestore(&priv->lock, flags);
  1842. add_timer( &priv->timer );
  1843. break;
  1844. }
  1845. }
  1846. spin_unlock_irqrestore(&priv->lock, flags);
  1847. break;
  1848. default:
  1849. break;
  1850. }
  1852. } /* TLan_Timer */
  1857. /*****************************************************************************
  1858. ******************************************************************************
  1860. ThunderLAN Driver Adapter Related Routines
  1862. ******************************************************************************
  1863. *****************************************************************************/
  1866. /***************************************************************
  1867.  * TLan_ResetLists
  1868.  *  
  1869.  * Returns:
  1870.  * Nothing
  1871.  * Parms:
  1872.  * dev The device structure with the list
  1873.  * stuctures to be reset.
  1874.  *
  1875.  * This routine sets the variables associated with managing
  1876.  * the TLAN lists to their initial values.
  1877.  *
  1878.  **************************************************************/
  1880. void TLan_ResetLists( struct net_device *dev )
  1881. {
  1882. TLanPrivateInfo *priv = dev->priv;
  1883. int i;
  1884. TLanList *list;
  1885. struct sk_buff *skb;
  1886. void *t = NULL;
  1888. priv->txHead = 0;
  1889. priv->txTail = 0;
  1890. for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) {
  1891. list = priv->txList + i;
  1892. list->cStat = TLAN_CSTAT_UNUSED;
  1893. if ( bbuf ) {
  1894. list->buffer[0].address = virt_to_bus( priv->txBuffer + ( i * TLAN_MAX_FRAME_SIZE ) );
  1895. } else {
  1896. list->buffer[0].address = 0;
  1897. }
  1898. list->buffer[2].count = 0;
  1899. list->buffer[2].address = 0;
  1900. list->buffer[9].address = 0;
  1901. }
  1903. priv->rxHead = 0;
  1904. priv->rxTail = TLAN_NUM_RX_LISTS - 1;
  1905. for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) {
  1906. list = priv->rxList + i;
  1907. list->cStat = TLAN_CSTAT_READY;
  1908. list->frameSize = TLAN_MAX_FRAME_SIZE;
  1909. list->buffer[0].count = TLAN_MAX_FRAME_SIZE | TLAN_LAST_BUFFER;
  1910. if ( bbuf ) {
  1911. list->buffer[0].address = virt_to_bus( priv->rxBuffer + ( i * TLAN_MAX_FRAME_SIZE ) );
  1912. } else {
  1913. skb = dev_alloc_skb( TLAN_MAX_FRAME_SIZE + 7 );
  1914. if ( skb == NULL ) {
  1915. printk( "TLAN:  Couldn't allocate memory for received data.n" );
  1916. /* If this ever happened it would be a problem */
  1917. } else {
  1918. skb->dev = dev;
  1919. skb_reserve( skb, 2 );
  1920. t = (void *) skb_put( skb, TLAN_MAX_FRAME_SIZE );
  1921. }
  1922. list->buffer[0].address = virt_to_bus( t );
  1923. list->buffer[8].address = (u32) t;
  1924. list->buffer[9].address = (u32) skb;
  1925. }
  1926. list->buffer[1].count = 0;
  1927. list->buffer[1].address = 0;
  1928. if ( i < TLAN_NUM_RX_LISTS - 1 )
  1929. list->forward = virt_to_bus( list + 1 );
  1930. else
  1931. list->forward = 0;
  1932. }
  1934. } /* TLan_ResetLists */
  1937. void TLan_FreeLists( struct net_device *dev )
  1938. {
  1939. TLanPrivateInfo *priv = dev->priv;
  1940. int i;
  1941. TLanList *list;
  1942. struct sk_buff *skb;
  1944. if ( ! bbuf ) {
  1945. for ( i = 0; i < TLAN_NUM_TX_LISTS; i++ ) {
  1946. list = priv->txList + i;
  1947. skb = (struct sk_buff *) list->buffer[9].address;
  1948. if ( skb ) {
  1949. dev_kfree_skb_any( skb );
  1950. list->buffer[9].address = 0;
  1951. }
  1952. }
  1954. for ( i = 0; i < TLAN_NUM_RX_LISTS; i++ ) {
  1955. list = priv->rxList + i;
  1956. skb = (struct sk_buff *) list->buffer[9].address;
  1957. if ( skb ) {
  1958. dev_kfree_skb_any( skb );
  1959. list->buffer[9].address = 0;
  1960. }
  1961. }
  1962. }
  1964. } /* TLan_FreeLists */
  1969. /***************************************************************
  1970.  * TLan_PrintDio
  1971.  *  
  1972.  * Returns:
  1973.  * Nothing
  1974.  * Parms:
  1975.  * io_base Base IO port of the device of
  1976.  * which to print DIO registers.
  1977.  *
  1978.  * This function prints out all the internal (DIO)
  1979.  * registers of a TLAN chip.
  1980.  *
  1981.  **************************************************************/
  1983. void TLan_PrintDio( u16 io_base )
  1984. {
  1985. u32 data0, data1;
  1986. int i;
  1988. printk( "TLAN:   Contents of internal registers for io base 0x%04hx.n", io_base );
  1989. printk( "TLAN:      Off.  +0         +4n" );
  1990. for ( i = 0; i < 0x4C; i+= 8 ) {
  1991. data0 = TLan_DioRead32( io_base, i );
  1992. data1 = TLan_DioRead32( io_base, i + 0x4 );
  1993. printk( "TLAN:      0x%02x  0x%08x 0x%08xn", i, data0, data1 );
  1994. }
  1996. } /* TLan_PrintDio */
  2001. /***************************************************************
  2002.  * TLan_PrintList
  2003.  *  
  2004.  * Returns:
  2005.  * Nothing
  2006.  * Parms:
  2007.  * list A pointer to the TLanList structure to
  2008.  * be printed.
  2009.  * type A string to designate type of list,
  2010.  * "Rx" or "Tx".
  2011.  * num The index of the list.
  2012.  *
  2013.  * This function prints out the contents of the list
  2014.  * pointed to by the list parameter.
  2015.  *
  2016.  **************************************************************/
  2018. void TLan_PrintList( TLanList *list, char *type, int num)
  2019. {
  2020. int i;
  2022. printk( "TLAN:   %s List %d at 0x%08xn", type, num, (u32) list );
  2023. printk( "TLAN:      Forward    = 0x%08xn",  list->forward );
  2024. printk( "TLAN:      CSTAT      = 0x%04hxn", list->cStat );
  2025. printk( "TLAN:      Frame Size = 0x%04hxn", list->frameSize );
  2026. /* for ( i = 0; i < 10; i++ ) { */
  2027. for ( i = 0; i < 2; i++ ) {
  2028. printk( "TLAN:      Buffer[%d].count, addr = 0x%08x, 0x%08xn", i, list->buffer[i].count, list->buffer[i].address );
  2029. }
  2031. } /* TLan_PrintList */
  2036. /***************************************************************
  2037.  * TLan_ReadAndClearStats
  2038.  *
  2039.  * Returns:
  2040.  * Nothing
  2041.  * Parms:
  2042.  * dev Pointer to device structure of adapter
  2043.  * to which to read stats.
  2044.  * record Flag indicating whether to add 
  2045.  *
  2046.  * This functions reads all the internal status registers
  2047.  * of the TLAN chip, which clears them as a side effect.
  2048.  * It then either adds the values to the device's status
  2049.  * struct, or discards them, depending on whether record
  2050.  * is TLAN_RECORD (!=0)  or TLAN_IGNORE (==0).
  2051.  *
  2052.  **************************************************************/
  2054. void TLan_ReadAndClearStats( struct net_device *dev, int record )
  2055. {
  2056. TLanPrivateInfo *priv = dev->priv;
  2057. u32 tx_good, tx_under;
  2058. u32 rx_good, rx_over;
  2059. u32 def_tx, crc, code;
  2060. u32 multi_col, single_col;
  2061. u32 excess_col, late_col, loss;
  2063. outw( TLAN_GOOD_TX_FRMS, dev->base_addr + TLAN_DIO_ADR );
  2064. tx_good  = inb( dev->base_addr + TLAN_DIO_DATA );
  2065. tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
  2066. tx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
  2067. tx_under = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
  2069. outw( TLAN_GOOD_RX_FRMS, dev->base_addr + TLAN_DIO_ADR );
  2070. rx_good  = inb( dev->base_addr + TLAN_DIO_DATA );
  2071. rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
  2072. rx_good += inb( dev->base_addr + TLAN_DIO_DATA + 2 ) << 16;
  2073. rx_over  = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
  2075. outw( TLAN_DEFERRED_TX, dev->base_addr + TLAN_DIO_ADR );
  2076. def_tx  = inb( dev->base_addr + TLAN_DIO_DATA );
  2077. def_tx += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
  2078. crc     = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
  2079. code    = inb( dev->base_addr + TLAN_DIO_DATA + 3 );
  2081. outw( TLAN_MULTICOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
  2082. multi_col   = inb( dev->base_addr + TLAN_DIO_DATA );
  2083. multi_col  += inb( dev->base_addr + TLAN_DIO_DATA + 1 ) << 8;
  2084. single_col  = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
  2085. single_col += inb( dev->base_addr + TLAN_DIO_DATA + 3 ) << 8;
  2087. outw( TLAN_EXCESSCOL_FRMS, dev->base_addr + TLAN_DIO_ADR );
  2088. excess_col = inb( dev->base_addr + TLAN_DIO_DATA );
  2089. late_col   = inb( dev->base_addr + TLAN_DIO_DATA + 1 );
  2090. loss       = inb( dev->base_addr + TLAN_DIO_DATA + 2 );
  2092. if ( record ) {
  2093. priv->stats.rx_packets += rx_good;
  2094. priv->stats.rx_errors  += rx_over + crc + code;
  2095. priv->stats.tx_packets += tx_good;
  2096. priv->stats.tx_errors  += tx_under + loss;
  2097. priv->stats.collisions += multi_col + single_col + excess_col + late_col;
  2099. priv->stats.rx_over_errors    += rx_over;
  2100. priv->stats.rx_crc_errors     += crc;
  2101. priv->stats.rx_frame_errors   += code;
  2103. priv->stats.tx_aborted_errors += tx_under;
  2104. priv->stats.tx_carrier_errors += loss;
  2105. }
  2107. } /* TLan_ReadAndClearStats */
  2112. /***************************************************************
  2113.  * TLan_Reset
  2114.  *
  2115.  * Returns:
  2116.  * 0
  2117.  * Parms:
  2118.  * dev Pointer to device structure of adapter
  2119.  * to be reset.
  2120.  *
  2121.  * This function resets the adapter and it's physical
  2122.  * device.  See Chap. 3, pp. 9-10 of the "ThunderLAN
  2123.  * Programmer's Guide" for details.  The routine tries to
  2124.  * implement what is detailed there, though adjustments
  2125.  * have been made.
  2126.  *
  2127.  **************************************************************/
  2129. void
  2130. TLan_ResetAdapter( struct net_device *dev )
  2131. {
  2132. TLanPrivateInfo *priv = dev->priv;
  2133. int i;
  2134. u32 addr;
  2135. u32 data;
  2136. u8 data8;
  2138. priv->tlanFullDuplex = FALSE;
  2139. priv->phyOnline=0;
  2140. /*  1. Assert reset bit. */
  2142. data = inl(dev->base_addr + TLAN_HOST_CMD);
  2143. data |= TLAN_HC_AD_RST;
  2144. outl(data, dev->base_addr + TLAN_HOST_CMD);
  2146. udelay(1000);
  2148. /*  2. Turn off interrupts. ( Probably isn't necessary ) */
  2150. data = inl(dev->base_addr + TLAN_HOST_CMD);
  2151. data |= TLAN_HC_INT_OFF;
  2152. outl(data, dev->base_addr + TLAN_HOST_CMD);
  2154. /*  3. Clear AREGs and HASHs. */
  2156.   for ( i = TLAN_AREG_0; i <= TLAN_HASH_2; i += 4 ) {
  2157. TLan_DioWrite32( dev->base_addr, (u16) i, 0 );
  2158. }
  2160. /*  4. Setup NetConfig register. */
  2162. data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
  2163. TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
  2165. /*  5. Load Ld_Tmr and Ld_Thr in HOST_CMD. */
  2167.   outl( TLAN_HC_LD_TMR | 0x3f, dev->base_addr + TLAN_HOST_CMD );
  2168.   outl( TLAN_HC_LD_THR | 0x9, dev->base_addr + TLAN_HOST_CMD );
  2170. /*  6. Unreset the MII by setting NMRST (in NetSio) to 1. */
  2172. outw( TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR );
  2173. addr = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
  2174. TLan_SetBit( TLAN_NET_SIO_NMRST, addr );
  2176. /*  7. Setup the remaining registers. */
  2178. if ( priv->tlanRev >= 0x30 ) {
  2179. data8 = TLAN_ID_TX_EOC | TLAN_ID_RX_EOC;
  2180. TLan_DioWrite8( dev->base_addr, TLAN_INT_DIS, data8 );
  2181. }
  2182. TLan_PhyDetect( dev );
  2183. data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN;
  2185. if ( priv->adapter->flags & TLAN_ADAPTER_BIT_RATE_PHY ) {
  2186. data |= TLAN_NET_CFG_BIT;
  2187. if ( priv->aui == 1 ) {
  2188. TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x0a );
  2189. } else if ( priv->duplex == TLAN_DUPLEX_FULL ) {
  2190. TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x00 );
  2191. priv->tlanFullDuplex = TRUE;
  2192. } else {
  2193. TLan_DioWrite8( dev->base_addr, TLAN_ACOMMIT, 0x08 );
  2194. }
  2195. }
  2197. if ( priv->phyNum == 0 ) {
  2198. data |= TLAN_NET_CFG_PHY_EN;
  2199. }
  2200. TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, (u16) data );
  2202. if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
  2203. TLan_FinishReset( dev );
  2204. } else {
  2205. TLan_PhyPowerDown( dev );
  2206. }
  2208. } /* TLan_ResetAdapter */
  2213. void
  2214. TLan_FinishReset( struct net_device *dev )
  2215. {
  2216. TLanPrivateInfo *priv = dev->priv;
  2217. u8 data;
  2218. u32 phy;
  2219. u8 sio;
  2220. u16 status;
  2221. u16 partner;
  2222. u16 tlphy_ctl;
  2223. u16  tlphy_par;
  2224. u16 tlphy_id1, tlphy_id2;
  2225. int  i;
  2227. phy = priv->phy[priv->phyNum];
  2229. data = TLAN_NET_CMD_NRESET | TLAN_NET_CMD_NWRAP;
  2230. if ( priv->tlanFullDuplex ) {
  2231. data |= TLAN_NET_CMD_DUPLEX;
  2232. }
  2233. TLan_DioWrite8( dev->base_addr, TLAN_NET_CMD, data );
  2234. data = TLAN_NET_MASK_MASK4 | TLAN_NET_MASK_MASK5; 
  2235. if ( priv->phyNum == 0 ) {
  2236. data |= TLAN_NET_MASK_MASK7; 
  2237. }
  2238. TLan_DioWrite8( dev->base_addr, TLAN_NET_MASK, data );
  2239. TLan_DioWrite16( dev->base_addr, TLAN_MAX_RX, ((1536)+7)&~7 );
  2240. TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &tlphy_id1 );
  2241. TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &tlphy_id2 );
  2243. if ( ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) || ( priv->aui ) ) {
  2244. status = MII_GS_LINK;
  2245. printk( "TLAN:  %s: Link forced.n", dev->name );
  2246. } else {
  2247. TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
  2248. udelay( 1000 );
  2249. TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
  2250. if ( (status & MII_GS_LINK) &&  /* We only support link info on Nat.Sem. PHY's */ 
  2251. (tlphy_id1 == NAT_SEM_ID1) &&
  2252. (tlphy_id2 == NAT_SEM_ID2) ) {
  2253. TLan_MiiReadReg( dev, phy, MII_AN_LPA, &partner );
  2254. TLan_MiiReadReg( dev, phy, TLAN_TLPHY_PAR, &tlphy_par );
  2256. printk( "TLAN: %s: Link active with ", dev->name );
  2257. if (!(tlphy_par & TLAN_PHY_AN_EN_STAT)) {
  2258.         printk( "forced 10%sMbps %s-Duplexn", 
  2259. tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
  2260. tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
  2261. } else {
  2262. printk( "AutoNegotiation enabled, at 10%sMbps %s-Duplexn",
  2263. tlphy_par & TLAN_PHY_SPEED_100 ? "" : "0",
  2264. tlphy_par & TLAN_PHY_DUPLEX_FULL ? "Full" : "Half");
  2265. printk("TLAN: Partner capability: ");
  2266. for (i = 5; i <= 10; i++)
  2267. if (partner & (1<<i))
  2268. printk("%s", media[i-5]);
  2269. printk("n");
  2270. }
  2272. TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
  2273. #ifdef MONITOR
  2274. /* We have link beat..for now anyway */
  2275.          priv->link = 1;
  2276.          /*Enabling link beat monitoring */
  2277. TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_LINK_BEAT );
  2278. #endif 
  2279. } else if (status & MII_GS_LINK)  {
  2280. printk( "TLAN: %s: Link activen", dev->name );
  2281. TLan_DioWrite8( dev->base_addr, TLAN_LED_REG, TLAN_LED_LINK );
  2282. }
  2283. }
  2285. if ( priv->phyNum == 0 ) {
  2286.          TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tlphy_ctl );
  2287.          tlphy_ctl |= TLAN_TC_INTEN;
  2288.          TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tlphy_ctl );
  2289.          sio = TLan_DioRead8( dev->base_addr, TLAN_NET_SIO );
  2290.          sio |= TLAN_NET_SIO_MINTEN;
  2291.          TLan_DioWrite8( dev->base_addr, TLAN_NET_SIO, sio );
  2292. }
  2294. if ( status & MII_GS_LINK ) {
  2295. TLan_SetMac( dev, 0, dev->dev_addr );
  2296. priv->phyOnline = 1;
  2297. outb( ( TLAN_HC_INT_ON >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
  2298. if ( debug >= 1 && debug != TLAN_DEBUG_PROBE ) {
  2299. outb( ( TLAN_HC_REQ_INT >> 8 ), dev->base_addr + TLAN_HOST_CMD + 1 );
  2300. }
  2301. outl( virt_to_bus( priv->rxList ), dev->base_addr + TLAN_CH_PARM );
  2302. outl( TLAN_HC_GO | TLAN_HC_RT, dev->base_addr + TLAN_HOST_CMD );
  2303. } else {
  2304. printk( "TLAN: %s: Link inactive, will retry in 10 secs...n", dev->name );
  2305. TLan_SetTimer( dev, (10*HZ), TLAN_TIMER_FINISH_RESET );
  2306. return;
  2307. }
  2309. } /* TLan_FinishReset */
  2314. /***************************************************************
  2315.  * TLan_SetMac
  2316.  *
  2317.  * Returns:
  2318.  * Nothing
  2319.  * Parms:
  2320.  * dev Pointer to device structure of adapter
  2321.  * on which to change the AREG.
  2322.  * areg The AREG to set the address in (0 - 3).
  2323.  * mac A pointer to an array of chars.  Each
  2324.  * element stores one byte of the address.
  2325.  * IE, it isn't in ascii.
  2326.  *
  2327.  * This function transfers a MAC address to one of the
  2328.  * TLAN AREGs (address registers).  The TLAN chip locks
  2329.  * the register on writing to offset 0 and unlocks the
  2330.  * register after writing to offset 5.  If NULL is passed
  2331.  * in mac, then the AREG is filled with 0's.
  2332.  *
  2333.  **************************************************************/
  2335. void TLan_SetMac( struct net_device *dev, int areg, char *mac )
  2336. {
  2337. int i;
  2339. areg *= 6;
  2341. if ( mac != NULL ) {
  2342. for ( i = 0; i < 6; i++ )
  2343. TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, mac[i] );
  2344. } else {
  2345. for ( i = 0; i < 6; i++ )
  2346. TLan_DioWrite8( dev->base_addr, TLAN_AREG_0 + areg + i, 0 );
  2347. }
  2349. } /* TLan_SetMac */
  2354. /*****************************************************************************
  2355. ******************************************************************************
  2357. ThunderLAN Driver PHY Layer Routines
  2359. ******************************************************************************
  2360. *****************************************************************************/
  2364. /*********************************************************************
  2365.  * TLan_PhyPrint
  2366.  *
  2367.  * Returns:
  2368.  * Nothing
  2369.  * Parms:
  2370.  * dev A pointer to the device structure of the
  2371.  * TLAN device having the PHYs to be detailed.
  2372.  *
  2373.  * This function prints the registers a PHY (aka tranceiver).
  2374.  *
  2375.  ********************************************************************/
  2377. void TLan_PhyPrint( struct net_device *dev )
  2378. {
  2379. TLanPrivateInfo *priv = dev->priv;
  2380. u16 i, data0, data1, data2, data3, phy;
  2382. phy = priv->phy[priv->phyNum];
  2384. if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
  2385. printk( "TLAN:   Device %s, Unmanaged PHY.n", dev->name );
  2386. } else if ( phy <= TLAN_PHY_MAX_ADDR ) {
  2387. printk( "TLAN:   Device %s, PHY 0x%02x.n", dev->name, phy );
  2388. printk( "TLAN:      Off.  +0     +1     +2     +3 n" );
  2389.                 for ( i = 0; i < 0x20; i+= 4 ) {
  2390. printk( "TLAN:      0x%02x", i );
  2391. TLan_MiiReadReg( dev, phy, i, &data0 );
  2392. printk( " 0x%04hx", data0 );
  2393. TLan_MiiReadReg( dev, phy, i + 1, &data1 );
  2394. printk( " 0x%04hx", data1 );
  2395. TLan_MiiReadReg( dev, phy, i + 2, &data2 );
  2396. printk( " 0x%04hx", data2 );
  2397. TLan_MiiReadReg( dev, phy, i + 3, &data3 );
  2398. printk( " 0x%04hxn", data3 );
  2399. }
  2400. } else {
  2401. printk( "TLAN:   Device %s, Invalid PHY.n", dev->name );
  2402. }
  2404. } /* TLan_PhyPrint */
  2409. /*********************************************************************
  2410.  * TLan_PhyDetect
  2411.  *
  2412.  * Returns:
  2413.  * Nothing
  2414.  * Parms:
  2415.  * dev A pointer to the device structure of the adapter
  2416.  * for which the PHY needs determined.
  2417.  *
  2418.  * So far I've found that adapters which have external PHYs
  2419.  * may also use the internal PHY for part of the functionality.
  2420.  * (eg, AUI/Thinnet).  This function finds out if this TLAN
  2421.  * chip has an internal PHY, and then finds the first external
  2422.  * PHY (starting from address 0) if it exists).
  2423.  *
  2424.  ********************************************************************/
  2426. void TLan_PhyDetect( struct net_device *dev )
  2427. {
  2428. TLanPrivateInfo *priv = dev->priv;
  2429. u16 control;
  2430. u16 hi;
  2431. u16 lo;
  2432. u32 phy;
  2434. if ( priv->adapter->flags & TLAN_ADAPTER_UNMANAGED_PHY ) {
  2435. priv->phyNum = 0xFFFF;
  2436. return;
  2437. }
  2439. TLan_MiiReadReg( dev, TLAN_PHY_MAX_ADDR, MII_GEN_ID_HI, &hi );
  2441. if ( hi != 0xFFFF ) {
  2442. priv->phy[0] = TLAN_PHY_MAX_ADDR;
  2443. } else {
  2444. priv->phy[0] = TLAN_PHY_NONE;
  2445. }
  2447. priv->phy[1] = TLAN_PHY_NONE;
  2448. for ( phy = 0; phy <= TLAN_PHY_MAX_ADDR; phy++ ) {
  2449. TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &control );
  2450. TLan_MiiReadReg( dev, phy, MII_GEN_ID_HI, &hi );
  2451. TLan_MiiReadReg( dev, phy, MII_GEN_ID_LO, &lo );
  2452. if ( ( control != 0xFFFF ) || ( hi != 0xFFFF ) || ( lo != 0xFFFF ) ) {
  2453. TLAN_DBG( TLAN_DEBUG_GNRL, "PHY found at %02x %04x %04x %04xn", phy, control, hi, lo );
  2454. if ( ( priv->phy[1] == TLAN_PHY_NONE ) && ( phy != TLAN_PHY_MAX_ADDR ) ) {
  2455. priv->phy[1] = phy;
  2456. }
  2457. }
  2458. }
  2460. if ( priv->phy[1] != TLAN_PHY_NONE ) {
  2461. priv->phyNum = 1;
  2462. } else if ( priv->phy[0] != TLAN_PHY_NONE ) {
  2463. priv->phyNum = 0;
  2464. } else {
  2465. printk( "TLAN:  Cannot initialize device, no PHY was found!n" );
  2466. }
  2468. } /* TLan_PhyDetect */
  2473. void TLan_PhyPowerDown( struct net_device *dev )
  2474. {
  2475. TLanPrivateInfo *priv = dev->priv;
  2476. u16 value;
  2478. TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering down PHY(s).n", dev->name );
  2479. value = MII_GC_PDOWN | MII_GC_LOOPBK | MII_GC_ISOLATE;
  2480. TLan_MiiSync( dev->base_addr );
  2481. TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
  2482. if ( ( priv->phyNum == 0 ) && ( priv->phy[1] != TLAN_PHY_NONE ) && ( ! ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) ) ) {
  2483. TLan_MiiSync( dev->base_addr );
  2484. TLan_MiiWriteReg( dev, priv->phy[1], MII_GEN_CTL, value );
  2485. }
  2487. /* Wait for 50 ms and powerup
  2488.  * This is abitrary.  It is intended to make sure the
  2489.  * tranceiver settles.
  2490.  */
  2491. TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_PUP );
  2493. } /* TLan_PhyPowerDown */
  2498. void TLan_PhyPowerUp( struct net_device *dev )
  2499. {
  2500. TLanPrivateInfo *priv = dev->priv;
  2501. u16 value;
  2503. TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Powering up PHY.n", dev->name );
  2504. TLan_MiiSync( dev->base_addr );
  2505. value = MII_GC_LOOPBK;
  2506. TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value );
  2507. TLan_MiiSync(dev->base_addr);
  2508. /* Wait for 500 ms and reset the
  2509.  * tranceiver.  The TLAN docs say both 50 ms and
  2510.  * 500 ms, so do the longer, just in case.
  2511.  */
  2512. TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_RESET );
  2514. } /* TLan_PhyPowerUp */
  2519. void TLan_PhyReset( struct net_device *dev )
  2520. {
  2521. TLanPrivateInfo *priv = dev->priv;
  2522. u16 phy;
  2523. u16 value;
  2525. phy = priv->phy[priv->phyNum];
  2527. TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Reseting PHY.n", dev->name );
  2528. TLan_MiiSync( dev->base_addr );
  2529. value = MII_GC_LOOPBK | MII_GC_RESET;
  2530. TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, value );
  2531. TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
  2532. while ( value & MII_GC_RESET ) {
  2533. TLan_MiiReadReg( dev, phy, MII_GEN_CTL, &value );
  2534. }
  2536. /* Wait for 500 ms and initialize.
  2537.  * I don't remember why I wait this long.
  2538.  * I've changed this to 50ms, as it seems long enough.
  2539.  */
  2540. TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_START_LINK );
  2542. } /* TLan_PhyReset */
  2547. void TLan_PhyStartLink( struct net_device *dev )
  2548. {
  2549. TLanPrivateInfo *priv = dev->priv;
  2550. u16 ability;
  2551. u16 control;
  2552. u16 data;
  2553. u16 phy;
  2554. u16 status;
  2555. u16 tctl;
  2557. phy = priv->phy[priv->phyNum];
  2558. TLAN_DBG( TLAN_DEBUG_GNRL, "%s: Trying to activate link.n", dev->name );
  2559. TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
  2560. TLan_MiiReadReg( dev, phy, MII_GEN_STS, &ability );
  2562. if ( ( status & MII_GS_AUTONEG ) && 
  2563.      ( ! priv->aui ) ) {
  2564. ability = status >> 11;
  2565. if ( priv->speed  == TLAN_SPEED_10 && 
  2566.      priv->duplex == TLAN_DUPLEX_HALF) {
  2567. TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0000);
  2568. } else if ( priv->speed == TLAN_SPEED_10 &&
  2569.     priv->duplex == TLAN_DUPLEX_FULL) {
  2570. priv->tlanFullDuplex = TRUE;
  2571. TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x0100);
  2572. } else if ( priv->speed == TLAN_SPEED_100 &&
  2573.     priv->duplex == TLAN_DUPLEX_HALF) {
  2574. TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2000);
  2575. } else if ( priv->speed == TLAN_SPEED_100 &&
  2576.     priv->duplex == TLAN_DUPLEX_FULL) {
  2577. priv->tlanFullDuplex = TRUE;
  2578. TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x2100);
  2579. } else {
  2581. /* Set Auto-Neg advertisement */
  2582. TLan_MiiWriteReg( dev, phy, MII_AN_ADV, (ability << 5) | 1);
  2583. /* Enablee Auto-Neg */
  2584. TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1000 );
  2585. /* Restart Auto-Neg */
  2586. TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, 0x1200 );
  2587. /* Wait for 4 sec for autonegotiation
  2588.   * to complete.  The max spec time is less than this
  2589.   * but the card need additional time to start AN.
  2590.   * .5 sec should be plenty extra.
  2591.   */
  2592. printk( "TLAN: %s: Starting autonegotiation.n", dev->name );
  2593. TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_PHY_FINISH_AN );
  2594. return;
  2595. }
  2597. }
  2599. if ( ( priv->aui ) && ( priv->phyNum != 0 ) ) {
  2600. priv->phyNum = 0;
  2601. data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
  2602. TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
  2603. TLan_SetTimer( dev, (40*HZ/1000), TLAN_TIMER_PHY_PDOWN );
  2604. return;
  2605. }  else if ( priv->phyNum == 0 ) {
  2606.          TLan_MiiReadReg( dev, phy, TLAN_TLPHY_CTL, &tctl );
  2607. if ( priv->aui ) {
  2608.                  tctl |= TLAN_TC_AUISEL;
  2609. } else { 
  2610.                  tctl &= ~TLAN_TC_AUISEL;
  2611. control = 0;
  2612. if ( priv->duplex == TLAN_DUPLEX_FULL ) {
  2613. control |= MII_GC_DUPLEX;
  2614. priv->tlanFullDuplex = TRUE;
  2615. }
  2616. if ( priv->speed == TLAN_SPEED_100 ) {
  2617. control |= MII_GC_SPEEDSEL;
  2618. }
  2619.         TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, control );
  2620. }
  2621.          TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tctl );
  2622. }
  2624. /* Wait for 2 sec to give the tranceiver time
  2625.  * to establish link.
  2626.  */
  2627. TLan_SetTimer( dev, (4*HZ), TLAN_TIMER_FINISH_RESET );
  2629. } /* TLan_PhyStartLink */
  2634. void TLan_PhyFinishAutoNeg( struct net_device *dev )
  2635. {
  2636. TLanPrivateInfo *priv = dev->priv;
  2637. u16 an_adv;
  2638. u16 an_lpa;
  2639. u16 data;
  2640. u16 mode;
  2641. u16 phy;
  2642. u16 status;
  2644. phy = priv->phy[priv->phyNum];
  2646. TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
  2647. udelay( 1000 );
  2648. TLan_MiiReadReg( dev, phy, MII_GEN_STS, &status );
  2650. if ( ! ( status & MII_GS_AUTOCMPLT ) ) {
  2651. /* Wait for 8 sec to give the process
  2652.  * more time.  Perhaps we should fail after a while.
  2653.  */
  2654.  if (!priv->neg_be_verbose++) {
  2655.  printk(KERN_INFO "TLAN:  Giving autonegotiation more time.n");
  2656.    printk(KERN_INFO "TLAN:  Please check that your adapter hasn");
  2657.    printk(KERN_INFO "TLAN:  been properly connected to a HUB or Switch.n");
  2658.  printk(KERN_INFO "TLAN:  Trying to establish link in the background...n");
  2659.  }
  2660. TLan_SetTimer( dev, (8*HZ), TLAN_TIMER_PHY_FINISH_AN );
  2661. return;
  2662. }
  2664. printk( "TLAN: %s: Autonegotiation complete.n", dev->name );
  2665. TLan_MiiReadReg( dev, phy, MII_AN_ADV, &an_adv );
  2666. TLan_MiiReadReg( dev, phy, MII_AN_LPA, &an_lpa );
  2667. mode = an_adv & an_lpa & 0x03E0;
  2668. if ( mode & 0x0100 ) {
  2669. priv->tlanFullDuplex = TRUE;
  2670. } else if ( ! ( mode & 0x0080 ) && ( mode & 0x0040 ) ) {
  2671. priv->tlanFullDuplex = TRUE;
  2672. }
  2674. if ( ( ! ( mode & 0x0180 ) ) && ( priv->adapter->flags & TLAN_ADAPTER_USE_INTERN_10 ) && ( priv->phyNum != 0 ) ) {
  2675. priv->phyNum = 0;
  2676. data = TLAN_NET_CFG_1FRAG | TLAN_NET_CFG_1CHAN | TLAN_NET_CFG_PHY_EN;
  2677. TLan_DioWrite16( dev->base_addr, TLAN_NET_CONFIG, data );
  2678. TLan_SetTimer( dev, (400*HZ/1000), TLAN_TIMER_PHY_PDOWN );
  2679. return;
  2680. }
  2682. if ( priv->phyNum == 0 ) {
  2683. if ( ( priv->duplex == TLAN_DUPLEX_FULL ) || ( an_adv & an_lpa & 0x0040 ) ) {
  2684. TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB | MII_GC_DUPLEX );
  2685. printk( "TLAN:  Starting internal PHY with FULL-DUPLEXn" );
  2686. } else {
  2687. TLan_MiiWriteReg( dev, phy, MII_GEN_CTL, MII_GC_AUTOENB );
  2688. printk( "TLAN:  Starting internal PHY with HALF-DUPLEXn" );
  2689. }
  2690. }
  2692. /* Wait for 100 ms.  No reason in partiticular.
  2693.  */
  2694. TLan_SetTimer( dev, (HZ/10), TLAN_TIMER_FINISH_RESET );
  2696. } /* TLan_PhyFinishAutoNeg */
  2698. #ifdef MONITOR
  2700.         /*********************************************************************
  2701.         *
  2702.         *      TLan_phyMonitor
  2703.         *
  2704.         *      Returns: 
  2705.         *              None
  2706.         *
  2707.         *      Params:
  2708.         *              dev             The device structure of this device.
  2709.         *
  2710.         *      
  2711.         *      This function monitors PHY condition by reading the status
  2712.         *      register via the MII bus. This can be used to give info
  2713.         *      about link changes (up/down), and possible switch to alternate
  2714.         *      media.
  2715.         *
  2716.         * ******************************************************************/
  2718. void TLan_PhyMonitor( struct net_device *dev )
  2719. {
  2720. TLanPrivateInfo *priv = dev->priv;
  2721. u16     phy;
  2722. u16     phy_status;
  2724. phy = priv->phy[priv->phyNum];
  2726.         /* Get PHY status register */
  2727.         TLan_MiiReadReg( dev, phy, MII_GEN_STS, &phy_status );
  2729.         /* Check if link has been lost */
  2730.         if (!(phy_status & MII_GS_LINK)) { 
  2731.          if (priv->link) {
  2732.       priv->link = 0;
  2733.               printk(KERN_DEBUG "TLAN: %s has lost linkn", dev->name);
  2734.               dev->flags &= ~IFF_RUNNING;
  2735.       TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
  2736.       return;
  2737. }
  2738. }
  2740.         /* Link restablished? */
  2741.         if ((phy_status & MII_GS_LINK) && !priv->link) {
  2742.   priv->link = 1;
  2743.          printk(KERN_DEBUG "TLAN: %s has reestablished linkn", dev->name);
  2744.          dev->flags |= IFF_RUNNING;
  2745.         }
  2747. /* Setup a new monitor */
  2748. TLan_SetTimer( dev, (2*HZ), TLAN_TIMER_LINK_BEAT );
  2749. }
  2751. #endif /* MONITOR */
  2754. /*****************************************************************************
  2755. ******************************************************************************
  2757. ThunderLAN Driver MII Routines
  2759. These routines are based on the information in Chap. 2 of the
  2760. "ThunderLAN Programmer's Guide", pp. 15-24.
  2762. ******************************************************************************
  2763. *****************************************************************************/
  2766. /***************************************************************
  2767.  * TLan_MiiReadReg
  2768.  *
  2769.  * Returns:
  2770.  * 0 if ack received ok
  2771.  * 1 otherwise.
  2772.  *
  2773.  * Parms:
  2774.  * dev The device structure containing
  2775.  * The io address and interrupt count
  2776.  * for this device.
  2777.  * phy The address of the PHY to be queried.
  2778.  * reg The register whose contents are to be
  2779.  * retreived.
  2780.  * val A pointer to a variable to store the
  2781.  * retrieved value.
  2782.  *
  2783.  * This function uses the TLAN's MII bus to retreive the contents
  2784.  * of a given register on a PHY.  It sends the appropriate info
  2785.  * and then reads the 16-bit register value from the MII bus via
  2786.  * the TLAN SIO register.
  2787.  *
  2788.  **************************************************************/
  2790. int TLan_MiiReadReg( struct net_device *dev, u16 phy, u16 reg, u16 *val )
  2791. {
  2792. u8 nack;
  2793. u16 sio, tmp;
  2794.   u32 i;
  2795. int err;
  2796. int minten;
  2797. TLanPrivateInfo *priv = dev->priv;
  2798. unsigned long flags = 0;
  2800. err = FALSE;
  2801. outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
  2802. sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
  2804. if (!in_irq())
  2805. spin_lock_irqsave(&priv->lock, flags);
  2807. TLan_MiiSync(dev->base_addr);
  2809. minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
  2810. if ( minten )
  2811. TLan_ClearBit(TLAN_NET_SIO_MINTEN, sio);
  2813. TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Start ( 01b ) */
  2814. TLan_MiiSendData( dev->base_addr, 0x2, 2 ); /* Read  ( 10b ) */
  2815. TLan_MiiSendData( dev->base_addr, phy, 5 ); /* Device #      */
  2816. TLan_MiiSendData( dev->base_addr, reg, 5 ); /* Register #    */
  2819. TLan_ClearBit(TLAN_NET_SIO_MTXEN, sio); /* Change direction */
  2821. TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Clock Idle bit */
  2822. TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
  2823. TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Wait 300ns */
  2825. nack = TLan_GetBit(TLAN_NET_SIO_MDATA, sio); /* Check for ACK */
  2826. TLan_SetBit(TLAN_NET_SIO_MCLK, sio); /* Finish ACK */
  2827. if (nack) { /* No ACK, so fake it */
  2828. for (i = 0; i < 16; i++) {
  2829. TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
  2830. TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
  2831. }
  2832. tmp = 0xffff;
  2833. err = TRUE;
  2834. } else { /* ACK, so read data */
  2835. for (tmp = 0, i = 0x8000; i; i >>= 1) {
  2836. TLan_ClearBit(TLAN_NET_SIO_MCLK, sio);
  2837. if (TLan_GetBit(TLAN_NET_SIO_MDATA, sio))
  2838. tmp |= i;
  2839. TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
  2840. }
  2841. }
  2844. TLan_ClearBit(TLAN_NET_SIO_MCLK, sio); /* Idle cycle */
  2845. TLan_SetBit(TLAN_NET_SIO_MCLK, sio);
  2847. if ( minten )
  2848. TLan_SetBit(TLAN_NET_SIO_MINTEN, sio);
  2850. *val = tmp;
  2852. if (!in_irq())
  2853. spin_unlock_irqrestore(&priv->lock, flags);
  2855. return err;
  2857. } /* TLan_MiiReadReg */
  2862. /***************************************************************
  2863.  * TLan_MiiSendData
  2864.  *
  2865.  * Returns:
  2866.  * Nothing
  2867.  * Parms:
  2868.  * base_port The base IO port of the adapter in
  2869.  * question.
  2870.  * dev The address of the PHY to be queried.
  2871.  * data The value to be placed on the MII bus.
  2872.  * num_bits The number of bits in data that are to
  2873.  * be placed on the MII bus.
  2874.  *
  2875.  * This function sends on sequence of bits on the MII
  2876.  * configuration bus.
  2877.  *
  2878.  **************************************************************/
  2880. void TLan_MiiSendData( u16 base_port, u32 data, unsigned num_bits )
  2881. {
  2882. u16 sio;
  2883. u32 i;
  2885. if ( num_bits == 0 )
  2886. return;
  2888. outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
  2889. sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
  2890. TLan_SetBit( TLAN_NET_SIO_MTXEN, sio );
  2892. for ( i = ( 0x1 << ( num_bits - 1 ) ); i; i >>= 1 ) {
  2893. TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
  2894. (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
  2895. if ( data & i )
  2896. TLan_SetBit( TLAN_NET_SIO_MDATA, sio );
  2897. else
  2898. TLan_ClearBit( TLAN_NET_SIO_MDATA, sio );
  2899. TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
  2900. (void) TLan_GetBit( TLAN_NET_SIO_MCLK, sio );
  2901. }
  2903. } /* TLan_MiiSendData */
  2908. /***************************************************************
  2909.  * TLan_MiiSync
  2910.  *
  2911.  * Returns:
  2912.  * Nothing
  2913.  * Parms:
  2914.  * base_port The base IO port of the adapter in
  2915.  * question.
  2916.  *
  2917.  * This functions syncs all PHYs in terms of the MII configuration
  2918.  * bus.
  2919.  *
  2920.  **************************************************************/
  2922. void TLan_MiiSync( u16 base_port )
  2923. {
  2924. int i;
  2925. u16 sio;
  2927. outw( TLAN_NET_SIO, base_port + TLAN_DIO_ADR );
  2928. sio = base_port + TLAN_DIO_DATA + TLAN_NET_SIO;
  2930. TLan_ClearBit( TLAN_NET_SIO_MTXEN, sio );
  2931. for ( i = 0; i < 32; i++ ) {
  2932. TLan_ClearBit( TLAN_NET_SIO_MCLK, sio );
  2933. TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
  2934. }
  2936. } /* TLan_MiiSync */
  2941. /***************************************************************
  2942.  * TLan_MiiWriteReg
  2943.  *
  2944.  * Returns:
  2945.  * Nothing
  2946.  * Parms:
  2947.  * dev The device structure for the device
  2948.  * to write to.
  2949.  * phy The address of the PHY to be written to.
  2950.  * reg The register whose contents are to be
  2951.  * written.
  2952.  * val The value to be written to the register.
  2953.  *
  2954.  * This function uses the TLAN's MII bus to write the contents of a
  2955.  * given register on a PHY.  It sends the appropriate info and then
  2956.  * writes the 16-bit register value from the MII configuration bus
  2957.  * via the TLAN SIO register.
  2958.  *
  2959.  **************************************************************/
  2961. void TLan_MiiWriteReg( struct net_device *dev, u16 phy, u16 reg, u16 val )
  2962. {
  2963. u16 sio;
  2964. int minten;
  2965. unsigned long flags = 0;
  2966. TLanPrivateInfo *priv = dev->priv;
  2968. outw(TLAN_NET_SIO, dev->base_addr + TLAN_DIO_ADR);
  2969. sio = dev->base_addr + TLAN_DIO_DATA + TLAN_NET_SIO;
  2971. if (!in_irq())
  2972. spin_lock_irqsave(&priv->lock, flags);
  2974. TLan_MiiSync( dev->base_addr );
  2976. minten = TLan_GetBit( TLAN_NET_SIO_MINTEN, sio );
  2977. if ( minten )
  2978. TLan_ClearBit( TLAN_NET_SIO_MINTEN, sio );
  2980. TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Start ( 01b ) */
  2981. TLan_MiiSendData( dev->base_addr, 0x1, 2 ); /* Write ( 01b ) */
  2982. TLan_MiiSendData( dev->base_addr, phy, 5 ); /* Device #      */
  2983. TLan_MiiSendData( dev->base_addr, reg, 5 ); /* Register #    */
  2985. TLan_MiiSendData( dev->base_addr, 0x2, 2 ); /* Send ACK */
  2986. TLan_MiiSendData( dev->base_addr, val, 16 ); /* Send Data */
  2988. TLan_ClearBit( TLAN_NET_SIO_MCLK, sio ); /* Idle cycle */
  2989. TLan_SetBit( TLAN_NET_SIO_MCLK, sio );
  2991. if ( minten )
  2992. TLan_SetBit( TLAN_NET_SIO_MINTEN, sio );
  2994. if (!in_irq())
  2995. spin_unlock_irqrestore(&priv->lock, flags);
  2997. } /* TLan_MiiWriteReg */
  3002. /*****************************************************************************
  3003. ******************************************************************************
  3005. ThunderLAN Driver Eeprom routines
  3007. The Compaq Netelligent 10 and 10/100 cards use a Microchip 24C02A
  3008. EEPROM.  These functions are based on information in Microchip's
  3009. data sheet.  I don't know how well this functions will work with
  3010. other EEPROMs.
  3012. ******************************************************************************
  3013. *****************************************************************************/
  3016. /***************************************************************
  3017.  * TLan_EeSendStart
  3018.  *
  3019.  * Returns:
  3020.  * Nothing
  3021.  * Parms:
  3022.  * io_base The IO port base address for the
  3023.  * TLAN device with the EEPROM to
  3024.  * use.
  3025.  *
  3026.  * This function sends a start cycle to an EEPROM attached
  3027.  * to a TLAN chip.
  3028.  *
  3029.  **************************************************************/
  3031. void TLan_EeSendStart( u16 io_base )
  3032. {
  3033. u16 sio;
  3035. outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
  3036. sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
  3038. TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
  3039. TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
  3040. TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
  3041. TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
  3042. TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
  3044. } /* TLan_EeSendStart */
  3049. /***************************************************************
  3050.  * TLan_EeSendByte
  3051.  *
  3052.  * Returns:
  3053.  * If the correct ack was received, 0, otherwise 1
  3054.  * Parms: io_base The IO port base address for the
  3055.  * TLAN device with the EEPROM to
  3056.  * use.
  3057.  * data The 8 bits of information to
  3058.  * send to the EEPROM.
  3059.  * stop If TLAN_EEPROM_STOP is passed, a
  3060.  * stop cycle is sent after the
  3061.  * byte is sent after the ack is
  3062.  * read.
  3063.  *
  3064.  * This function sends a byte on the serial EEPROM line,
  3065.  * driving the clock to send each bit. The function then
  3066.  * reverses transmission direction and reads an acknowledge
  3067.  * bit.
  3068.  *
  3069.  **************************************************************/
  3071. int TLan_EeSendByte( u16 io_base, u8 data, int stop )
  3072. {
  3073. int err;
  3074. u8 place;
  3075. u16 sio;
  3077. outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
  3078. sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
  3080. /* Assume clock is low, tx is enabled; */
  3081. for ( place = 0x80; place != 0; place >>= 1 ) {
  3082. if ( place & data )
  3083. TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
  3084. else
  3085. TLan_ClearBit( TLAN_NET_SIO_EDATA, sio );
  3086. TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
  3087. TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
  3088. }
  3089. TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
  3090. TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
  3091. err = TLan_GetBit( TLAN_NET_SIO_EDATA, sio );
  3092. TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
  3093. TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
  3095. if ( ( ! err ) && stop ) {
  3096. TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); /* STOP, raise data while clock is high */
  3097. TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
  3098. TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
  3099. }
  3101. return ( err );
  3103. } /* TLan_EeSendByte */
  3108. /***************************************************************
  3109.  * TLan_EeReceiveByte
  3110.  *
  3111.  * Returns:
  3112.  * Nothing
  3113.  * Parms:
  3114.  * io_base The IO port base address for the
  3115.  * TLAN device with the EEPROM to
  3116.  * use.
  3117.  * data An address to a char to hold the
  3118.  * data sent from the EEPROM.
  3119.  * stop If TLAN_EEPROM_STOP is passed, a
  3120.  * stop cycle is sent after the
  3121.  * byte is received, and no ack is
  3122.  * sent.
  3123.  *
  3124.  * This function receives 8 bits of data from the EEPROM
  3125.  * over the serial link.  It then sends and ack bit, or no
  3126.  * ack and a stop bit.  This function is used to retrieve
  3127.  * data after the address of a byte in the EEPROM has been
  3128.  * sent.
  3129.  *
  3130.  **************************************************************/
  3132. void TLan_EeReceiveByte( u16 io_base, u8 *data, int stop )
  3133. {
  3134. u8  place;
  3135. u16 sio;
  3137. outw( TLAN_NET_SIO, io_base + TLAN_DIO_ADR );
  3138. sio = io_base + TLAN_DIO_DATA + TLAN_NET_SIO;
  3139. *data = 0;
  3141. /* Assume clock is low, tx is enabled; */
  3142. TLan_ClearBit( TLAN_NET_SIO_ETXEN, sio );
  3143. for ( place = 0x80; place; place >>= 1 ) {
  3144. TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
  3145. if ( TLan_GetBit( TLAN_NET_SIO_EDATA, sio ) )
  3146. *data |= place;
  3147. TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
  3148. }
  3150. TLan_SetBit( TLAN_NET_SIO_ETXEN, sio );
  3151. if ( ! stop ) {
  3152. TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); /* Ack = 0 */
  3153. TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
  3154. TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
  3155. } else {
  3156. TLan_SetBit( TLAN_NET_SIO_EDATA, sio ); /* No ack = 1 (?) */
  3157. TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
  3158. TLan_ClearBit( TLAN_NET_SIO_ECLOK, sio );
  3159. TLan_ClearBit( TLAN_NET_SIO_EDATA, sio ); /* STOP, raise data while clock is high */
  3160. TLan_SetBit( TLAN_NET_SIO_ECLOK, sio );
  3161. TLan_SetBit( TLAN_NET_SIO_EDATA, sio );
  3162. }
  3164. } /* TLan_EeReceiveByte */
  3169. /***************************************************************
  3170.  * TLan_EeReadByte
  3171.  *
  3172.  * Returns:
  3173.  * No error = 0, else, the stage at which the error
  3174.  * occurred.
  3175.  * Parms:
  3176.  * io_base The IO port base address for the
  3177.  * TLAN device with the EEPROM to
  3178.  * use.
  3179.  * ee_addr The address of the byte in the
  3180.  * EEPROM whose contents are to be
  3181.  * retrieved.
  3182.  * data An address to a char to hold the
  3183.  * data obtained from the EEPROM.
  3184.  *
  3185.  * This function reads a byte of information from an byte
  3186.  * cell in the EEPROM.
  3187.  *
  3188.  **************************************************************/
  3190. int TLan_EeReadByte( struct net_device *dev, u8 ee_addr, u8 *data )
  3191. {
  3192. int err;
  3193. TLanPrivateInfo *priv = dev->priv;
  3194. unsigned long flags = 0;
  3195. int ret=0;
  3197. spin_lock_irqsave(&priv->lock, flags);
  3199. TLan_EeSendStart( dev->base_addr );
  3200. err = TLan_EeSendByte( dev->base_addr, 0xA0, TLAN_EEPROM_ACK );
  3201. if (err)
  3202. {
  3203. ret=1;
  3204. goto fail;
  3205. }
  3206. err = TLan_EeSendByte( dev->base_addr, ee_addr, TLAN_EEPROM_ACK );
  3207. if (err)
  3208. {
  3209. ret=2;
  3210. goto fail;
  3211. }
  3212. TLan_EeSendStart( dev->base_addr );
  3213. err = TLan_EeSendByte( dev->base_addr, 0xA1, TLAN_EEPROM_ACK );
  3214. if (err)
  3215. {
  3216. ret=3;
  3217. goto fail;
  3218. }
  3219. TLan_EeReceiveByte( dev->base_addr, data, TLAN_EEPROM_STOP );
  3220. fail:
  3221. spin_unlock_irqrestore(&priv->lock, flags);
  3223. return ret;
  3225. } /* TLan_EeReadByte */