workbench/devs/networks/rtl8139/rtl8139.c

   1 /*
   2  * $Id$
   3  */
   4
   5 /*
   6         This program is free software; you can redistribute it and/or modify
   7         it under the terms of the GNU General Public License as published by
   8         the Free Software Foundation; either version 2 of the License, or
   9         (at your option) any later version.
  10
  11         This program is distributed in the hope that it will be useful, but
  12         WITHOUT ANY WARRANTY; without even the implied warranty of
  13         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14         General Public License for more details.
  15
  16         You should have received a copy of the GNU General Public License
  17         along with this program; if not, write to the Free Software
  18         Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  19         MA 02111-1307, USA.
  20 */
  21
  22 #include "rtl8139.h"
  23
  24 #include <exec/types.h>
  25 #include <exec/resident.h>
  26 #include <exec/io.h>
  27 #include <exec/ports.h>
  28
  29 #include <aros/libcall.h>
  30 #include <aros/macros.h>
  31 #include <aros/io.h>
  32
  33 #include <oop/oop.h>
  34
  35 #include <devices/sana2.h>
  36 #include <devices/sana2specialstats.h>
  37
  38 #include <utility/utility.h>
  39 #include <utility/tagitem.h>
  40 #include <utility/hooks.h>
  41
  42 #include <hidd/pci.h>
  43 #include <hidd/irq.h>
  44
  45 #include <proto/oop.h>
  46 #include <proto/exec.h>
  47 #include <proto/dos.h>
  48 #include <proto/battclock.h>
  49
  50 #include <stdlib.h>
  51
  52 #include "unit.h"
  53 #include LC_LIBDEFS_FILE
  54
  55 /* A bit fixed linux stuff here :) */
  56
  57 #undef LIBBASE
  58 #define LIBBASE (unit->rtl8139u_device)
  59
  60 #define TIMER_RPROK 3599597124UL
  61
  62 static ULONG usec2tick(ULONG usec)
  63 {
  64         ULONG ret, timer_rpr = TIMER_RPROK;
  65         asm volatile("movl $0,%%eax; divl %2":"=a"(ret):"d"(usec),"m"(timer_rpr));
  66         return ret;
  67 }
  68
  69 void udelay(LONG usec)
  70 {
  71         int oldtick, tick;
  72         usec = usec2tick(usec);
  73
  74         BYTEOUT(0x43, 0x80);
  75         oldtick = BYTEIN(0x42);
  76         oldtick += BYTEIN(0x42) << 8;
  77
  78         while (usec > 0)
  79         {
  80                 BYTEOUT(0x43, 0x80);
  81                 tick = BYTEIN(0x42);
  82                 tick += BYTEIN(0x42) << 8;
  83
  84                 usec -= (oldtick - tick);
  85                 if (tick > oldtick) usec -= 0x10000;
  86                 oldtick = tick;
  87         }
  88 }
  89
  90 static inline struct fe_priv *get_pcnpriv(struct net_device *unit)
  91 {
  92         return unit->rtl8139u_fe_priv;
  93 }
  94
  95 static inline UBYTE *get_hwbase(struct net_device *unit)
  96 {
  97         return (UBYTE *)unit->rtl8139u_BaseMem;
  98 }
  99
 100 static int read_eeprom(long base, int location, int addr_len)
 101 {
 102   int i;
 103   unsigned retval = 0;
 104   long rtlprom_addr = base + RTLr_Cfg9346;
 105   int read_cmd = location | (EE_READ_CMD << addr_len);
 106
 107   BYTEOUT(rtlprom_addr, EE_ENB & ~EE_CS);
 108   BYTEOUT(rtlprom_addr, EE_ENB);
 109
 110   // Shift the read command bits out
 111   for (i = 4 + addr_len; i >= 0; i--)
 112   {
 113         int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
 114         BYTEOUT(rtlprom_addr, EE_ENB | dataval);
 115         eeprom_delay(rtlprom_addr);
 116         BYTEOUT(rtlprom_addr, EE_ENB | dataval | EE_SHIFT_CLK);
 117         eeprom_delay(rtlprom_addr);
 118   }
 119   BYTEOUT(rtlprom_addr, EE_ENB);
 120   eeprom_delay(rtlprom_addr);
 121
 122   for (i = 16; i > 0; i--)
 123   {
 124         BYTEOUT(rtlprom_addr, EE_ENB | EE_SHIFT_CLK);
 125         eeprom_delay(rtlprom_addr);
 126         retval = (retval << 1) | ((BYTEIN(rtlprom_addr) & EE_DATA_READ) ? 1 : 0);
 127         BYTEOUT(rtlprom_addr, EE_ENB);
 128         eeprom_delay(rtlprom_addr);
 129   }
 130
 131   // Terminate EEPROM access
 132   BYTEOUT(rtlprom_addr, ~EE_CS);
 133   return retval;
 134 }
 135
 136 // Syncronize the MII management interface by shifting 32 one bits out
 137 static char mii_2_8139_map[8] =
 138 {
 139   RTLr_MII_BMCR, RTLr_MII_BMSR, 0, 0, RTLr_NWayAdvert, RTLr_NWayLPAR, RTLr_NWayExpansion, 0
 140 };
 141
 142 static void mdio_sync(long base)
 143 {
 144         int i;
 145
 146         for (i = 32; i >= 0; i--)
 147         {
 148                 BYTEOUT(base, MDIO_WRITE1);
 149                 mdio_delay(base);
 150                 BYTEOUT(base, MDIO_WRITE1 | MDIO_CLK);
 151                 mdio_delay(base);
 152         }
 153 }
 154
 155 static int mdio_read(struct net_device *unit, int phy_id, int location)
 156 {
 157         struct fe_priv *np = get_pcnpriv(unit);
 158         UBYTE *base = get_hwbase(unit);
 159         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
 160         int retval = 0;
 161         int i;
 162
 163         if (phy_id > 31)
 164         {
 165                 // Really a 8139.  Use internal registers
 166                 return location < 8 && mii_2_8139_map[location] ? WORDIN(base + mii_2_8139_map[location]) : 0;
 167         }
 168
 169         mdio_sync(base + RTLr_MII_SMI);
 170
 171         // Shift the read command bits out
 172         for (i = 15; i >= 0; i--)
 173         {
 174                 int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
 175
 176                 BYTEOUT(base + RTLr_MII_SMI, MDIO_DIR | dataval);
 177                 mdio_delay(base + RTLr_MII_SMI);
 178                 BYTEOUT(base + RTLr_MII_SMI, MDIO_DIR | dataval | MDIO_CLK);
 179                 mdio_delay(base + RTLr_MII_SMI);
 180         }
 181
 182         // Read the two transition, 16 data, and wire-idle bits
 183         for (i = 19; i > 0; i--)
 184         {
 185                 BYTEOUT(base + RTLr_MII_SMI, 0);
 186                 mdio_delay(base + RTLr_MII_SMI);
 187                 retval = (retval << 1) | ((BYTEIN(base + RTLr_MII_SMI) & MDIO_DATA_IN) ? 1 : 0);
 188                 BYTEOUT(base + RTLr_MII_SMI, MDIO_CLK);
 189                 mdio_delay(base + RTLr_MII_SMI);
 190         }
 191
 192         return (retval >> 1) & 0xffff;
 193 }
 194
 195 static void rtl8139nic_start_rx(struct net_device *unit)
 196 {
 197         struct fe_priv *np = get_pcnpriv(unit);
 198         UBYTE *base = get_hwbase(unit);
 199
 200 RTLD(bug("[%s] rtl8139nic_start_rx\n", unit->rtl8139u_name))
 201         // Already running? Stop it.
 202 #warning "TODO: Handle starting/stopping Rx"
 203 }
 204
 205 static void rtl8139nic_stop_rx(struct net_device *unit)
 206 {
 207         UBYTE *base = get_hwbase(unit);
 208
 209 RTLD(bug("[%s] rtl8139nic_stop_rx\n", unit->rtl8139u_name))
 210 #warning "TODO: Handle starting/stopping Rx"
 211 }
 212
 213 static void rtl8139nic_start_tx(struct net_device *unit)
 214 {
 215         UBYTE *base = get_hwbase(unit);
 216
 217 RTLD(bug("[%s] rtl8139nic_start_tx()\n", unit->rtl8139u_name))
 218 #warning "TODO: Handle starting/stopping Tx"
 219 }
 220
 221 static void rtl8139nic_stop_tx(struct net_device *unit)
 222 {
 223         UBYTE *base = get_hwbase(unit);
 224
 225 RTLD(bug("[%s] rtl8139nic_stop_tx()\n", unit->rtl8139u_name))
 226 #warning "TODO: Handle starting/stopping Tx"
 227 }
 228
 229 static void rtl8139nic_txrx_reset(struct net_device *unit)
 230 {
 231         struct fe_priv *np = get_pcnpriv(unit);
 232         UBYTE *base = get_hwbase(unit);
 233
 234 RTLD(bug("[%s] rtl8139nic_txrx_reset()\n", unit->rtl8139u_name))
 235 }
 236
 237 /*
 238  * rtl8139nic_set_multicast: unit->set_multicast function
 239  * Called with unit->xmit_lock held.
 240  */
 241 static void rtl8139nic_set_multicast(struct net_device *unit)
 242 {
 243         struct fe_priv *np = get_pcnpriv(unit);
 244         UBYTE *base = get_hwbase(unit);
 245         ULONG addr[2];
 246         ULONG mask[2];
 247         ULONG pff;
 248
 249 RTLD(bug("[%s] rtl8139nic_set_multicast()\n", unit->rtl8139u_name))
 250
 251         memset(addr, 0, sizeof(addr));
 252         memset(mask, 0, sizeof(mask));
 253 }
 254
 255 static void rtl8139nic_deinitialize(struct net_device *unit)
 256 {
 257
 258 }
 259
 260 static void rtl8139nic_get_mac(struct net_device *unit, char * addr, BOOL fromROM)
 261 {
 262         UBYTE *base = get_hwbase(unit);
 263         int i;
 264
 265 RTLD(bug("[%s] rtl8139nic_get_mac()\n",unit->rtl8139u_name))
 266         if (fromROM)
 267         {
 268                 int addr_len = read_eeprom(base, 0, 8) == 0x8129 ? 8 : 6;
 269                 int mac_add = 0;
 270                 for (i = 0; i < 3; i++)
 271                 {
 272                         UWORD mac_curr = read_eeprom(base, i + 7, addr_len);
 273                         addr[mac_add++] = mac_curr & 0xff;
 274                         addr[mac_add++] = (mac_curr >> 8) & 0xff;
 275                 }
 276         }
 277         else
 278         {
 279                 ULONG mac_cur = 0;
 280                 mac_cur = LONGIN(base + RTLr_MAC0 + 0);
 281                 addr[0] = mac_cur & 0xFF;
 282                 addr[1] = (mac_cur >> 8) & 0xFF;
 283                 addr[2] = (mac_cur >> 16) & 0xFF;
 284                 addr[3] = (mac_cur >> 24) & 0xFF;
 285                 mac_cur = LONGIN(base + RTLr_MAC0 + 4);
 286                 addr[4] = mac_cur & 0xFF;
 287                 addr[5] = (mac_cur >> 8) & 0xFF;
 288         }
 289 }
 290
 291 static void rtl8139nic_set_mac(struct net_device *unit)
 292 {
 293         UBYTE *base = get_hwbase(unit);
 294         int i,j;
 295
 296 RTLD(bug("[%s] rtl8139nic_set_mac()\n",unit->rtl8139u_name))
 297
 298         BYTEOUT(base + RTLr_Cfg9346, 0xc0);
 299
 300         LONGOUT(base + RTLr_MAC0 + 0,
 301                 unit->rtl8139u_dev_addr[0] |
 302                 (unit->rtl8139u_dev_addr[1] << 8) |
 303                 (unit->rtl8139u_dev_addr[2] << 16) |
 304                 (unit->rtl8139u_dev_addr[3] << 24));
 305         LONGOUT(base + RTLr_MAC0 + 4,
 306                 unit->rtl8139u_dev_addr[4] |
 307                 (unit->rtl8139u_dev_addr[5] << 8));
 308
 309         BYTEOUT(base + RTLr_Cfg9346, 0x00);
 310
 311 RTLD(
 312         /* Read it back to be certain! */
 313         TEXT    newmac[6];
 314         rtl8139nic_get_mac(unit, newmac, FALSE);
 315
 316         bug("[%s] rtl8139nic_set_mac: New MAC Address %02x:%02x:%02x:%02x:%02x:%02x\n", unit->rtl8139u_name,
 317                         newmac[0], newmac[1], newmac[2],
 318                         newmac[3], newmac[4], newmac[5]))
 319 }
 320
 321 static void rtl8139nic_initialize(struct net_device *unit)
 322 {
 323         struct fe_priv *np = unit->rtl8139u_fe_priv;
 324         UBYTE *base = get_hwbase(unit);
 325         int i, config1;
 326
 327         config1 = BYTEIN(base + RTLr_Config1);
 328         if (unit->rtl8139u_rtl_chipcapabilities & RTLc_HAS_MII_XCVR)
 329         {
 330                 BYTEOUT(base + RTLr_Config1, config1 & ~0x03);
 331         }
 332 RTLD(bug("[%s] Chipset brought out of low power mode.\n", unit->rtl8139u_name))
 333
 334         rtl8139nic_get_mac(unit, np->orig_mac, TRUE);
 335
 336         int phy, phy_idx = 0;
 337         if (unit->rtl8139u_rtl_chipcapabilities & RTLc_HAS_MII_XCVR)
 338         {
 339                 for (phy = 0; phy < 32 && phy_idx < sizeof(np->mii_phys); phy++)
 340                 {
 341                         int mii_status = mdio_read(unit, phy, 1);
 342                         if (mii_status != 0xffff && mii_status != 0x0000)
 343                         {
 344                                 np->mii_phys[phy_idx++] = phy;
 345                                 np->advertising = mdio_read(unit, phy, 4);
 346 RTLD(bug("[%s] MII transceiver %d status 0x%4.4x advertising %4.4x\n", unit->rtl8139u_name,
 347                                                                                                                                                 phy, mii_status, np->advertising))
 348                         }
 349                 }
 350         }
 351
 352         if (phy_idx == 0)
 353         {
 354 RTLD(bug("[%s] No MII transceiver found, Assuming SYM transceiver\n", unit->rtl8139u_name))
 355                 np->mii_phys[0] = 32;
 356         }
 357
 358         unit->rtl8139u_dev_addr[0] = unit->rtl8139u_org_addr[0] = np->orig_mac[0];
 359         unit->rtl8139u_dev_addr[1] = unit->rtl8139u_org_addr[1] = np->orig_mac[1];
 360         unit->rtl8139u_dev_addr[2] = unit->rtl8139u_org_addr[2] = np->orig_mac[2];
 361         unit->rtl8139u_dev_addr[3] = unit->rtl8139u_org_addr[3] = np->orig_mac[3];
 362         unit->rtl8139u_dev_addr[4] = unit->rtl8139u_org_addr[4] = np->orig_mac[4];
 363         unit->rtl8139u_dev_addr[5] = unit->rtl8139u_org_addr[5] = np->orig_mac[5];
 364
 365 RTLD(bug("[%s] MAC Address %02x:%02x:%02x:%02x:%02x:%02x\n", unit->rtl8139u_name,
 366                         unit->rtl8139u_dev_addr[0], unit->rtl8139u_dev_addr[1], unit->rtl8139u_dev_addr[2],
 367                         unit->rtl8139u_dev_addr[3], unit->rtl8139u_dev_addr[4], unit->rtl8139u_dev_addr[5]))
 368
 369         BYTEOUT(base + RTLr_Cfg9346, 0xc0);
 370         if (unit->rtl8139u_rtl_chipcapabilities & RTLc_HAS_MII_XCVR)
 371         {
 372                 BYTEOUT(base + RTLr_Config1, 0x03);
 373         }
 374         BYTEOUT(base + RTLr_HltClk, 'H'); //Disable the chips clock ('R' enables)
 375 RTLD(bug("[%s] Chipset put into low power mode.\n", unit->rtl8139u_name))
 376 }
 377
 378 static void rtl8139nic_drain_tx(struct net_device *unit)
 379 {
 380         struct fe_priv *np = get_pcnpriv(unit);
 381         int i;
 382         for (i = 0; i < NUM_TX_DESC; i++) {
 383 #warning "TODO: rtl8139nic_drain_tx does nothing atm."
 384         }
 385 }
 386
 387 static void rtl8139nic_drain_rx(struct net_device *unit)
 388 {
 389         struct fe_priv *np = get_pcnpriv(unit);
 390         int i;
 391 //      for (i = 0; i < RX_RING_SIZE; i++) {
 392 #warning "TODO: rtl8139nic_drain_rx does nothing atm."
 393 //      }
 394 }
 395
 396
 397 static void drain_ring(struct net_device *unit)
 398 {
 399         rtl8139nic_drain_tx(unit);
 400         rtl8139nic_drain_rx(unit);
 401 }
 402
 403 static int request_irq(struct net_device *unit)
 404 {
 405         OOP_Object *irq = OOP_NewObject(NULL, CLID_Hidd_IRQ, NULL);
 406         BOOL ret;
 407
 408 RTLD(bug("[%s] request_irq()\n", unit->rtl8139u_name))
 409
 410         if (irq)
 411         {
 412                 ret = HIDD_IRQ_AddHandler(irq, unit->rtl8139u_irqhandler, unit->rtl8139u_IRQ);
 413                 HIDD_IRQ_AddHandler(irq, unit->rtl8139u_touthandler, vHidd_IRQ_Timer);
 414
 415 RTLD(bug("[%s] request_irq: IRQ Handlers configured\n", unit->rtl8139u_name))
 416
 417                 OOP_DisposeObject(irq);
 418
 419                 if (ret)
 420                 {
 421                         return 0;
 422                 }
 423         }
 424         return 1;
 425 }
 426
 427 static void free_irq(struct net_device *unit)
 428 {
 429         OOP_Object *irq = OOP_NewObject(NULL, CLID_Hidd_IRQ, NULL);
 430         if (irq)
 431         {
 432                 HIDD_IRQ_RemHandler(irq, unit->rtl8139u_irqhandler);
 433                 HIDD_IRQ_RemHandler(irq, unit->rtl8139u_touthandler);
 434                 OOP_DisposeObject(irq);
 435         }
 436 }
 437
 438 int rtl8139nic_set_rxmode(struct net_device *unit)
 439 {
 440         struct fe_priv *np = get_pcnpriv(unit);
 441         UBYTE *base = get_hwbase(unit);
 442         ULONG mc_filter[2];         //Multicast hash filter.
 443         ULONG rx_mode;
 444
 445 RTLD(bug("[%s] rtl8139nic_set_rxmode(flags %x)\n", unit->rtl8139u_name, unit->rtl8139u_flags))
 446
 447 #warning "TODO: Fix set_rxmode.. doesnt load multicast list atm .."
 448         if (unit->rtl8139u_flags & IFF_PROMISC)
 449         {
 450 RTLD(bug("[%s] rtl8139nic_set_rxmode: Mode: PROMISC\n",unit->rtl8139u_name))
 451                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys | AcceptAllPhys;
 452                 mc_filter[1] = mc_filter[0] = 0xffffffff;
 453         }
 454         else if (unit->rtl8139u_flags & IFF_ALLMULTI)
 455         {
 456 RTLD(bug("[%s] rtl8139nic_set_rxmode: Mode: ALLMULTI\n",unit->rtl8139u_name))
 457                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
 458                 mc_filter[1] = mc_filter[0] = 0xffffffff;
 459         }
 460         else
 461         {
 462 //              struct mclist *mclist;
 463 //              int i;
 464 RTLD(bug("[%s] rtl8139nic_set_rxmode: Mode: DEFAULT\n",unit->rtl8139u_name))
 465
 466                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
 467                 /*if (unit->mc_count < multicast_filter_limit)
 468                 {*/
 469                         mc_filter[1] = mc_filter[0] = 0;
 470                         /*for (i = 0, mclist = dev->netif->mclist; mclist && i < dev->netif->mccount; i++, mclist = mclist->next)
 471                         {
 472                                 set_bit(mc_filter, ether_crc(6, (unsigned char *) &mclist->hwaddr) >> 26);
 473                         }
 474                 }
 475                 else
 476                 {
 477                         mc_filter[1] = mc_filter[0] = 0xffffffff;
 478                 }*/
 479         }
 480
 481         LONGOUT(base + RTLr_RxConfig, np->rx_config | rx_mode);
 482         LONGOUT(base + RTLr_MAR0 + 0, mc_filter[0]);
 483         LONGOUT(base + RTLr_MAR0 + 4, mc_filter[1]);
 484
 485         return 0;
 486 }
 487
 488 static int rtl8139nic_open(struct net_device *unit)
 489 {
 490         struct fe_priv *np = get_pcnpriv(unit);
 491         UBYTE *base = get_hwbase(unit);
 492         int ret, i, rx_buf_len_idx;
 493
 494         rx_buf_len_idx = RX_BUF_LEN_IDX;
 495
 496         ret = request_irq(unit);
 497         if (ret)
 498                 goto out_drain;
 499
 500         do
 501         {
 502                 np->rx_buf_len = 8192 << rx_buf_len_idx;
 503
 504                 np->rx_buffer = HIDD_PCIDriver_AllocPCIMem(
 505                                                 unit->rtl8139u_PCIDriver,
 506                                                 (np->rx_buf_len + 16 + (TX_BUF_SIZE * NUM_TX_DESC)));
 507
 508                 if (np->rx_buffer != NULL)
 509                 {
 510                         np->tx_buffer = (struct eth_frame *) (np->rx_buffer + np->rx_buf_len + 16);
 511                 }
 512         } while (np->rx_buffer == NULL && (--rx_buf_len_idx >= 0));
 513
 514         if ((np->rx_buffer != NULL) && (np->tx_buffer != NULL))
 515         {
 516 RTLD(bug("[%s] rtl8139nic_open: Allocated IO Buffers [ %d x Tx @ %x] [ Rx @ %x, %d bytes]\n",unit->rtl8139u_name,
 517                                                 NUM_TX_DESC, np->tx_buffer,
 518                                                 np->rx_buffer,  np->rx_buf_len))
 519
 520                 np->tx_dirty = np->tx_current = 0;
 521
 522                 for (i = 0; i < NUM_TX_DESC; i++)
 523                 {
 524                         np->tx_pbuf[i] = NULL;
 525                         np->tx_buf[i]  = np->tx_buffer + (i * TX_BUF_SIZE);
 526                 }
 527 RTLD(bug("[%s] rtl8139nic_open: TX Buffers initialised\n",unit->rtl8139u_name))
 528
 529                 np->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000;
 530                 np->rx_config = (RX_FIFO_THRESH << 13) | (rx_buf_len_idx << 11) | (RX_DMA_BURST << 8);
 531
 532                 BYTEOUT(base + RTLr_ChipCmd, CmdReset);
 533                 for (i = 1000; i > 0; i--)
 534                 {
 535                         if ((BYTEIN(base + RTLr_ChipCmd) & CmdReset) ==0) break;
 536                 }
 537 RTLD(bug("[%s] rtl8139nic_open: NIC Reset\n",unit->rtl8139u_name))
 538
 539                 rtl8139nic_set_mac(unit);
 540 RTLD(bug("[%s] rtl8139nic_open: copied MAC address\n",unit->rtl8139u_name))
 541
 542                 np->rx_current = 0;
 543
 544                 BYTEOUT(base + RTLr_Cfg9346, 0xc0);
 545
 546                 //Enable Tx/Rx so we can set the config(s)
 547                 BYTEOUT(base + RTLr_ChipCmd, CmdRxEnb | CmdTxEnb);
 548                 LONGOUT(base + RTLr_RxConfig, np->rx_config);
 549                 LONGOUT(base + RTLr_TxConfig, TX_DMA_BURST << 8);
 550
 551 RTLD(bug("[%s] rtl8139nic_open: Enabled Tx/Rx\n",unit->rtl8139u_name))
 552
 553                 /* check_duplex */
 554                 if (np->mii_phys[0] >= 0 || (unit->rtl8139u_rtl_chipcapabilities & RTLc_HAS_MII_XCVR))
 555                 {
 556                         UBYTE mii_reg5 = mdio_read(unit, np->mii_phys[0], 5);
 557                         if (mii_reg5 != 0xffff)
 558                         {
 559                                 if (((mii_reg5 & 0x0100) == 0x0100) || ((mii_reg5 & 0x00c0) == 0x0040))
 560                                 {
 561                                         np->full_duplex = 1;
 562                                 }
 563                         }
 564
 565                         if ((mii_reg5 == 0 ) || !(mii_reg5 & 0x0180))
 566                         {
 567                            unit->rtl8139u_rtl_LinkSpeed = 10000000;
 568                         }
 569                         else
 570                         {
 571                            unit->rtl8139u_rtl_LinkSpeed = 100000000;
 572                         }
 573
 574 RTLD(bug("[%s] rtl8139nic_open: Setting %s%s-duplex based on auto-neg partner ability %4.4x\n",unit->rtl8139u_name,
 575                                                                                                                                                                                          mii_reg5 == 0 ? "" : (mii_reg5 & 0x0180) ? "100mbps " : "10mbps ",
 576                                                                                                                                                                                          np->full_duplex ? "full" : "half", mii_reg5))
 577                 }
 578
 579                 if (unit->rtl8139u_rtl_chipcapabilities & RTLc_HAS_MII_XCVR)
 580                 {
 581                         BYTEOUT(base + RTLr_Config1, np->full_duplex ? 0x60 : 0x20);
 582                 }
 583                 BYTEOUT(base + RTLr_Cfg9346, 0x00);
 584                 LONGOUT(base + RTLr_RxBuf, np->rx_buffer);
 585
 586                 //Start the chips Tx/Rx processes
 587                 LONGOUT(base + RTLr_RxMissed, 0);
 588
 589                 rtl8139nic_set_rxmode(unit);
 590                 BYTEOUT(base + RTLr_ChipCmd, CmdRxEnb | CmdTxEnb);
 591
 592                 //Enable all known interrupts by setting the interrupt mask ..
 593                 WORDOUT(base + RTLr_IntrMask, PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver | TxErr | TxOK | RxErr | RxOK);
 594
 595            unit->rtl8139u_flags |= IFF_UP;
 596            ReportEvents(LIBBASE, unit, S2EVENT_ONLINE);
 597 RTLD(bug("[%s] rtl8139nic_open: Device set as ONLINE\n",unit->rtl8139u_name))
 598         }
 599         return 0;
 600
 601 out_drain:
 602         drain_ring(unit);
 603         return ret;
 604 }
 605
 606 static int rtl8139nic_close(struct net_device *unit)
 607 {
 608         struct fe_priv *np = get_pcnpriv(unit);
 609         UBYTE *base;
 610
 611         unit->rtl8139u_flags &= ~IFF_UP;
 612
 613         ObtainSemaphore(&np->lock);
 614         np->in_shutdown = 1;
 615         ReleaseSemaphore(&np->lock);
 616
 617         unit->rtl8139u_toutNEED = FALSE;
 618
 619         netif_stop_queue(unit);
 620         ObtainSemaphore(&np->lock);
 621
 622         rtl8139nic_deinitialize(unit);    // Stop the chipset and set it in 16bit-mode
 623
 624         base = get_hwbase(unit);
 625
 626         ReleaseSemaphore(&np->lock);
 627
 628         free_irq(unit);
 629
 630         drain_ring(unit);
 631
 632         HIDD_PCIDriver_FreePCIMem(unit->rtl8139u_PCIDriver, np->rx_buffer);
 633         HIDD_PCIDriver_FreePCIMem(unit->rtl8139u_PCIDriver, np->tx_buffer);
 634
 635         ReportEvents(LIBBASE, unit, S2EVENT_OFFLINE);
 636
 637         return 0;
 638 }
 639
 640
 641 void rtl8139nic_get_functions(struct net_device *Unit)
 642 {
 643         Unit->initialize = rtl8139nic_initialize;
 644         Unit->deinitialize = rtl8139nic_deinitialize;
 645         Unit->start = rtl8139nic_open;
 646         Unit->stop = rtl8139nic_close;
 647         Unit->set_mac_address = rtl8139nic_set_mac;
 648         Unit->set_multicast = rtl8139nic_set_multicast;
 649 }