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