drivers/staging/vt6655/mac.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   4  * All rights reserved.
   5  *
   6  * Purpose:  MAC routines
   7  *
   8  * Author: Tevin Chen
   9  *
  10  * Date: May 21, 1996
  11  *
  12  * Functions:
  13  *      MACbIsRegBitsOff - Test if All test Bits Off
  14  *      MACbIsIntDisable - Test if MAC interrupt disable
  15  *      MACvSetShortRetryLimit - Set 802.11 Short Retry limit
  16  *      MACvSetLongRetryLimit - Set 802.11 Long Retry limit
  17  *      MACvSetLoopbackMode - Set MAC Loopback Mode
  18  *      MACvSaveContext - Save Context of MAC Registers
  19  *      MACvRestoreContext - Restore Context of MAC Registers
  20  *      MACbSoftwareReset - Software Reset MAC
  21  *      MACbSafeRxOff - Turn Off MAC Rx
  22  *      MACbSafeTxOff - Turn Off MAC Tx
  23  *      MACbSafeStop - Stop MAC function
  24  *      MACbShutdown - Shut down MAC
  25  *      MACvInitialize - Initialize MAC
  26  *      MACvSetCurrRxDescAddr - Set Rx Descriptors Address
  27  *      MACvSetCurrTx0DescAddr - Set Tx0 Descriptors Address
  28  *      MACvSetCurrTx1DescAddr - Set Tx1 Descriptors Address
  29  *      MACvTimer0MicroSDelay - Micro Second Delay Loop by MAC
  30  *
  31  * Revision History:
  32  *      08-22-2003 Kyle Hsu     :  Porting MAC functions from sim53
  33  *      09-03-2003 Bryan YC Fan :  Add MACvClearBusSusInd()&
  34  *                                 MACvEnableBusSusEn()
  35  *      09-18-2003 Jerry Chen   :  Add MACvSetKeyEntry & MACvDisableKeyEntry
  36  *
  37  */
  38
  39 #include "mac.h"
  40
  41 void vt6655_mac_reg_bits_on(void __iomem *iobase, const u8 reg_offset, const u8 bit_mask)
  42 {
  43         unsigned char reg_value;
  44
  45         reg_value = ioread8(iobase + reg_offset);
  46         iowrite8(reg_value | bit_mask, iobase + reg_offset);
  47 }
  48
  49 void vt6655_mac_word_reg_bits_on(void __iomem *iobase, const u8 reg_offset, const u16 bit_mask)
  50 {
  51         unsigned short reg_value;
  52
  53         reg_value = ioread16(iobase + reg_offset);
  54         iowrite16(reg_value | (bit_mask), iobase + reg_offset);
  55 }
  56
  57 void vt6655_mac_reg_bits_off(void __iomem *iobase, const u8 reg_offset, const u8 bit_mask)
  58 {
  59         unsigned char reg_value;
  60
  61         reg_value = ioread8(iobase + reg_offset);
  62         iowrite8(reg_value & ~(bit_mask), iobase + reg_offset);
  63 }
  64
  65 void vt6655_mac_word_reg_bits_off(void __iomem *iobase, const u8 reg_offset, const u16 bit_mask)
  66 {
  67         unsigned short reg_value;
  68
  69         reg_value = ioread16(iobase + reg_offset);
  70         iowrite16(reg_value & ~(bit_mask), iobase + reg_offset);
  71 }
  72
  73 static void vt6655_mac_clear_stck_ds(void __iomem *iobase)
  74 {
  75         u8 reg_value;
  76
  77         reg_value = ioread8(iobase + MAC_REG_STICKHW);
  78         reg_value = reg_value & 0xFC;
  79         iowrite8(reg_value, iobase + MAC_REG_STICKHW);
  80 }
  81
  82 /*
  83  * Description:
  84  *      Test if all test bits off
  85  *
  86  * Parameters:
  87  *  In:
  88  *      io_base    - Base Address for MAC
  89  *      byRegOfs    - Offset of MAC Register
  90  *      byTestBits  - Test bits
  91  *  Out:
  92  *      none
  93  *
  94  * Return Value: true if all test bits Off; otherwise false
  95  *
  96  */
  97 bool MACbIsRegBitsOff(struct vnt_private *priv, unsigned char byRegOfs,
  98                       unsigned char byTestBits)
  99 {
 100         void __iomem *io_base = priv->port_offset;
 101
 102         return !(ioread8(io_base + byRegOfs) & byTestBits);
 103 }
 104
 105 /*
 106  * Description:
 107  *      Test if MAC interrupt disable
 108  *
 109  * Parameters:
 110  *  In:
 111  *      io_base    - Base Address for MAC
 112  *  Out:
 113  *      none
 114  *
 115  * Return Value: true if interrupt is disable; otherwise false
 116  *
 117  */
 118 bool MACbIsIntDisable(struct vnt_private *priv)
 119 {
 120         void __iomem *io_base = priv->port_offset;
 121
 122         if (ioread32(io_base + MAC_REG_IMR))
 123                 return false;
 124
 125         return true;
 126 }
 127
 128 /*
 129  * Description:
 130  *      Set 802.11 Short Retry Limit
 131  *
 132  * Parameters:
 133  *  In:
 134  *      io_base    - Base Address for MAC
 135  *      byRetryLimit- Retry Limit
 136  *  Out:
 137  *      none
 138  *
 139  * Return Value: none
 140  *
 141  */
 142 void MACvSetShortRetryLimit(struct vnt_private *priv,
 143                             unsigned char byRetryLimit)
 144 {
 145         void __iomem *io_base = priv->port_offset;
 146         /* set SRT */
 147         iowrite8(byRetryLimit, io_base + MAC_REG_SRT);
 148 }
 149
 150 /*
 151  * Description:
 152  *      Set 802.11 Long Retry Limit
 153  *
 154  * Parameters:
 155  *  In:
 156  *      io_base    - Base Address for MAC
 157  *      byRetryLimit- Retry Limit
 158  *  Out:
 159  *      none
 160  *
 161  * Return Value: none
 162  *
 163  */
 164 void MACvSetLongRetryLimit(struct vnt_private *priv,
 165                            unsigned char byRetryLimit)
 166 {
 167         void __iomem *io_base = priv->port_offset;
 168         /* set LRT */
 169         iowrite8(byRetryLimit, io_base + MAC_REG_LRT);
 170 }
 171
 172 /*
 173  * Description:
 174  *      Set MAC Loopback mode
 175  *
 176  * Parameters:
 177  *  In:
 178  *      io_base        - Base Address for MAC
 179  *      byLoopbackMode  - Loopback Mode
 180  *  Out:
 181  *      none
 182  *
 183  * Return Value: none
 184  *
 185  */
 186 void MACvSetLoopbackMode(struct vnt_private *priv, unsigned char byLoopbackMode)
 187 {
 188         void __iomem *io_base = priv->port_offset;
 189
 190         byLoopbackMode <<= 6;
 191         /* set TCR */
 192         iowrite8((ioread8(io_base + MAC_REG_TEST) & 0x3f) | byLoopbackMode,
 193                  io_base + MAC_REG_TEST);
 194 }
 195
 196 /*
 197  * Description:
 198  *      Save MAC registers to context buffer
 199  *
 200  * Parameters:
 201  *  In:
 202  *      io_base    - Base Address for MAC
 203  *  Out:
 204  *      cxt_buf   - Context buffer
 205  *
 206  * Return Value: none
 207  *
 208  */
 209 void MACvSaveContext(struct vnt_private *priv, unsigned char *cxt_buf)
 210 {
 211         void __iomem *io_base = priv->port_offset;
 212
 213         /* read page0 register */
 214         memcpy_fromio(cxt_buf, io_base, MAC_MAX_CONTEXT_SIZE_PAGE0);
 215
 216         MACvSelectPage1(io_base);
 217
 218         /* read page1 register */
 219         memcpy_fromio(cxt_buf + MAC_MAX_CONTEXT_SIZE_PAGE0, io_base,
 220                       MAC_MAX_CONTEXT_SIZE_PAGE1);
 221
 222         MACvSelectPage0(io_base);
 223 }
 224
 225 /*
 226  * Description:
 227  *      Restore MAC registers from context buffer
 228  *
 229  * Parameters:
 230  *  In:
 231  *      io_base    - Base Address for MAC
 232  *      cxt_buf   - Context buffer
 233  *  Out:
 234  *      none
 235  *
 236  * Return Value: none
 237  *
 238  */
 239 void MACvRestoreContext(struct vnt_private *priv, unsigned char *cxt_buf)
 240 {
 241         void __iomem *io_base = priv->port_offset;
 242
 243         MACvSelectPage1(io_base);
 244         /* restore page1 */
 245         memcpy_toio(io_base, cxt_buf + MAC_MAX_CONTEXT_SIZE_PAGE0,
 246                     MAC_MAX_CONTEXT_SIZE_PAGE1);
 247
 248         MACvSelectPage0(io_base);
 249
 250         /* restore RCR,TCR,IMR... */
 251         memcpy_toio(io_base + MAC_REG_RCR, cxt_buf + MAC_REG_RCR,
 252                     MAC_REG_ISR - MAC_REG_RCR);
 253
 254         /* restore MAC Config. */
 255         memcpy_toio(io_base + MAC_REG_LRT, cxt_buf + MAC_REG_LRT,
 256                     MAC_REG_PAGE1SEL - MAC_REG_LRT);
 257
 258         iowrite8(*(cxt_buf + MAC_REG_CFG), io_base + MAC_REG_CFG);
 259
 260         /* restore PS Config. */
 261         memcpy_toio(io_base + MAC_REG_PSCFG, cxt_buf + MAC_REG_PSCFG,
 262                     MAC_REG_BBREGCTL - MAC_REG_PSCFG);
 263
 264         /* restore CURR_RX_DESC_ADDR, CURR_TX_DESC_ADDR */
 265         iowrite32(*(u32 *)(cxt_buf + MAC_REG_TXDMAPTR0),
 266                   io_base + MAC_REG_TXDMAPTR0);
 267         iowrite32(*(u32 *)(cxt_buf + MAC_REG_AC0DMAPTR),
 268                   io_base + MAC_REG_AC0DMAPTR);
 269         iowrite32(*(u32 *)(cxt_buf + MAC_REG_BCNDMAPTR),
 270                   io_base + MAC_REG_BCNDMAPTR);
 271         iowrite32(*(u32 *)(cxt_buf + MAC_REG_RXDMAPTR0),
 272                   io_base + MAC_REG_RXDMAPTR0);
 273         iowrite32(*(u32 *)(cxt_buf + MAC_REG_RXDMAPTR1),
 274                   io_base + MAC_REG_RXDMAPTR1);
 275 }
 276
 277 /*
 278  * Description:
 279  *      Software Reset MAC
 280  *
 281  * Parameters:
 282  *  In:
 283  *      io_base    - Base Address for MAC
 284  *  Out:
 285  *      none
 286  *
 287  * Return Value: true if Reset Success; otherwise false
 288  *
 289  */
 290 bool MACbSoftwareReset(struct vnt_private *priv)
 291 {
 292         void __iomem *io_base = priv->port_offset;
 293         unsigned short ww;
 294
 295         /* turn on HOSTCR_SOFTRST, just write 0x01 to reset */
 296         iowrite8(0x01, io_base + MAC_REG_HOSTCR);
 297
 298         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 299                 if (!(ioread8(io_base + MAC_REG_HOSTCR) & HOSTCR_SOFTRST))
 300                         break;
 301         }
 302         if (ww == W_MAX_TIMEOUT)
 303                 return false;
 304         return true;
 305 }
 306
 307 /*
 308  * Description:
 309  *      save some important register's value, then do reset, then restore
 310  *      register's value
 311  *
 312  * Parameters:
 313  *  In:
 314  *      io_base    - Base Address for MAC
 315  *  Out:
 316  *      none
 317  *
 318  * Return Value: true if success; otherwise false
 319  *
 320  */
 321 bool MACbSafeSoftwareReset(struct vnt_private *priv)
 322 {
 323         unsigned char abyTmpRegData[MAC_MAX_CONTEXT_SIZE_PAGE0 + MAC_MAX_CONTEXT_SIZE_PAGE1];
 324         bool bRetVal;
 325
 326         /* PATCH....
 327          * save some important register's value, then do
 328          * reset, then restore register's value
 329          */
 330         /* save MAC context */
 331         MACvSaveContext(priv, abyTmpRegData);
 332         /* do reset */
 333         bRetVal = MACbSoftwareReset(priv);
 334         /* restore MAC context, except CR0 */
 335         MACvRestoreContext(priv, abyTmpRegData);
 336
 337         return bRetVal;
 338 }
 339
 340 /*
 341  * Description:
 342  *      Turn Off MAC Rx
 343  *
 344  * Parameters:
 345  *  In:
 346  *      io_base    - Base Address for MAC
 347  *  Out:
 348  *      none
 349  *
 350  * Return Value: true if success; otherwise false
 351  *
 352  */
 353 bool MACbSafeRxOff(struct vnt_private *priv)
 354 {
 355         void __iomem *io_base = priv->port_offset;
 356         unsigned short ww;
 357
 358         /* turn off wow temp for turn off Rx safely */
 359
 360         /* Clear RX DMA0,1 */
 361         iowrite32(DMACTL_CLRRUN, io_base + MAC_REG_RXDMACTL0);
 362         iowrite32(DMACTL_CLRRUN, io_base + MAC_REG_RXDMACTL1);
 363         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 364                 if (!(ioread32(io_base + MAC_REG_RXDMACTL0) & DMACTL_RUN))
 365                         break;
 366         }
 367         if (ww == W_MAX_TIMEOUT) {
 368                 pr_debug(" DBG_PORT80(0x10)\n");
 369                 return false;
 370         }
 371         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 372                 if (!(ioread32(io_base + MAC_REG_RXDMACTL1) & DMACTL_RUN))
 373                         break;
 374         }
 375         if (ww == W_MAX_TIMEOUT) {
 376                 pr_debug(" DBG_PORT80(0x11)\n");
 377                 return false;
 378         }
 379
 380         /* try to safe shutdown RX */
 381         vt6655_mac_reg_bits_off(io_base, MAC_REG_HOSTCR, HOSTCR_RXON);
 382         /* W_MAX_TIMEOUT is the timeout period */
 383         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 384                 if (!(ioread8(io_base + MAC_REG_HOSTCR) & HOSTCR_RXONST))
 385                         break;
 386         }
 387         if (ww == W_MAX_TIMEOUT) {
 388                 pr_debug(" DBG_PORT80(0x12)\n");
 389                 return false;
 390         }
 391         return true;
 392 }
 393
 394 /*
 395  * Description:
 396  *      Turn Off MAC Tx
 397  *
 398  * Parameters:
 399  *  In:
 400  *      io_base    - Base Address for MAC
 401  *  Out:
 402  *      none
 403  *
 404  * Return Value: true if success; otherwise false
 405  *
 406  */
 407 bool MACbSafeTxOff(struct vnt_private *priv)
 408 {
 409         void __iomem *io_base = priv->port_offset;
 410         unsigned short ww;
 411
 412         /* Clear TX DMA */
 413         /* Tx0 */
 414         iowrite32(DMACTL_CLRRUN, io_base + MAC_REG_TXDMACTL0);
 415         /* AC0 */
 416         iowrite32(DMACTL_CLRRUN, io_base + MAC_REG_AC0DMACTL);
 417
 418         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 419                 if (!(ioread32(io_base + MAC_REG_TXDMACTL0) & DMACTL_RUN))
 420                         break;
 421         }
 422         if (ww == W_MAX_TIMEOUT) {
 423                 pr_debug(" DBG_PORT80(0x20)\n");
 424                 return false;
 425         }
 426         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 427                 if (!(ioread32(io_base + MAC_REG_AC0DMACTL) & DMACTL_RUN))
 428                         break;
 429         }
 430         if (ww == W_MAX_TIMEOUT) {
 431                 pr_debug(" DBG_PORT80(0x21)\n");
 432                 return false;
 433         }
 434
 435         /* try to safe shutdown TX */
 436         vt6655_mac_reg_bits_off(io_base, MAC_REG_HOSTCR, HOSTCR_TXON);
 437
 438         /* W_MAX_TIMEOUT is the timeout period */
 439         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 440                 if (!(ioread8(io_base + MAC_REG_HOSTCR) & HOSTCR_TXONST))
 441                         break;
 442         }
 443         if (ww == W_MAX_TIMEOUT) {
 444                 pr_debug(" DBG_PORT80(0x24)\n");
 445                 return false;
 446         }
 447         return true;
 448 }
 449
 450 /*
 451  * Description:
 452  *      Stop MAC function
 453  *
 454  * Parameters:
 455  *  In:
 456  *      io_base    - Base Address for MAC
 457  *  Out:
 458  *      none
 459  *
 460  * Return Value: true if success; otherwise false
 461  *
 462  */
 463 bool MACbSafeStop(struct vnt_private *priv)
 464 {
 465         void __iomem *io_base = priv->port_offset;
 466
 467         vt6655_mac_reg_bits_off(io_base, MAC_REG_TCR, TCR_AUTOBCNTX);
 468
 469         if (!MACbSafeRxOff(priv)) {
 470                 pr_debug(" MACbSafeRxOff == false)\n");
 471                 MACbSafeSoftwareReset(priv);
 472                 return false;
 473         }
 474         if (!MACbSafeTxOff(priv)) {
 475                 pr_debug(" MACbSafeTxOff == false)\n");
 476                 MACbSafeSoftwareReset(priv);
 477                 return false;
 478         }
 479
 480         vt6655_mac_reg_bits_off(io_base, MAC_REG_HOSTCR, HOSTCR_MACEN);
 481
 482         return true;
 483 }
 484
 485 /*
 486  * Description:
 487  *      Shut Down MAC
 488  *
 489  * Parameters:
 490  *  In:
 491  *      io_base    - Base Address for MAC
 492  *  Out:
 493  *      none
 494  *
 495  * Return Value: true if success; otherwise false
 496  *
 497  */
 498 bool MACbShutdown(struct vnt_private *priv)
 499 {
 500         void __iomem *io_base = priv->port_offset;
 501         /* disable MAC IMR */
 502         iowrite32(0, io_base + MAC_REG_IMR);
 503         MACvSetLoopbackMode(priv, MAC_LB_INTERNAL);
 504         /* stop the adapter */
 505         if (!MACbSafeStop(priv)) {
 506                 MACvSetLoopbackMode(priv, MAC_LB_NONE);
 507                 return false;
 508         }
 509         MACvSetLoopbackMode(priv, MAC_LB_NONE);
 510         return true;
 511 }
 512
 513 /*
 514  * Description:
 515  *      Initialize MAC
 516  *
 517  * Parameters:
 518  *  In:
 519  *      io_base    - Base Address for MAC
 520  *  Out:
 521  *      none
 522  *
 523  * Return Value: none
 524  *
 525  */
 526 void MACvInitialize(struct vnt_private *priv)
 527 {
 528         void __iomem *io_base = priv->port_offset;
 529         /* clear sticky bits */
 530         vt6655_mac_clear_stck_ds(io_base);
 531         /* disable force PME-enable */
 532         iowrite8(PME_OVR, io_base + MAC_REG_PMC1);
 533         /* only 3253 A */
 534
 535         /* do reset */
 536         MACbSoftwareReset(priv);
 537
 538         /* reset TSF counter */
 539         iowrite8(TFTCTL_TSFCNTRST, io_base + MAC_REG_TFTCTL);
 540         /* enable TSF counter */
 541         iowrite8(TFTCTL_TSFCNTREN, io_base + MAC_REG_TFTCTL);
 542 }
 543
 544 /*
 545  * Description:
 546  *      Set the chip with current rx descriptor address
 547  *
 548  * Parameters:
 549  *  In:
 550  *      io_base        - Base Address for MAC
 551  *      curr_desc_addr  - Descriptor Address
 552  *  Out:
 553  *      none
 554  *
 555  * Return Value: none
 556  *
 557  */
 558 void MACvSetCurrRx0DescAddr(struct vnt_private *priv, u32 curr_desc_addr)
 559 {
 560         void __iomem *io_base = priv->port_offset;
 561         unsigned short ww;
 562         unsigned char org_dma_ctl;
 563
 564         org_dma_ctl = ioread8(io_base + MAC_REG_RXDMACTL0);
 565         if (org_dma_ctl & DMACTL_RUN)
 566                 iowrite8(DMACTL_RUN, io_base + MAC_REG_RXDMACTL0 + 2);
 567
 568         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 569                 if (!(ioread8(io_base + MAC_REG_RXDMACTL0) & DMACTL_RUN))
 570                         break;
 571         }
 572
 573         iowrite32(curr_desc_addr, io_base + MAC_REG_RXDMAPTR0);
 574         if (org_dma_ctl & DMACTL_RUN)
 575                 iowrite8(DMACTL_RUN, io_base + MAC_REG_RXDMACTL0);
 576 }
 577
 578 /*
 579  * Description:
 580  *      Set the chip with current rx descriptor address
 581  *
 582  * Parameters:
 583  *  In:
 584  *      io_base        - Base Address for MAC
 585  *      curr_desc_addr  - Descriptor Address
 586  *  Out:
 587  *      none
 588  *
 589  * Return Value: none
 590  *
 591  */
 592 void MACvSetCurrRx1DescAddr(struct vnt_private *priv, u32 curr_desc_addr)
 593 {
 594         void __iomem *io_base = priv->port_offset;
 595         unsigned short ww;
 596         unsigned char org_dma_ctl;
 597
 598         org_dma_ctl = ioread8(io_base + MAC_REG_RXDMACTL1);
 599         if (org_dma_ctl & DMACTL_RUN)
 600                 iowrite8(DMACTL_RUN, io_base + MAC_REG_RXDMACTL1 + 2);
 601
 602         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 603                 if (!(ioread8(io_base + MAC_REG_RXDMACTL1) & DMACTL_RUN))
 604                         break;
 605         }
 606
 607         iowrite32(curr_desc_addr, io_base + MAC_REG_RXDMAPTR1);
 608         if (org_dma_ctl & DMACTL_RUN)
 609                 iowrite8(DMACTL_RUN, io_base + MAC_REG_RXDMACTL1);
 610 }
 611
 612 /*
 613  * Description:
 614  *      Set the chip with current tx0 descriptor address
 615  *
 616  * Parameters:
 617  *  In:
 618  *      io_base        - Base Address for MAC
 619  *      curr_desc_addr  - Descriptor Address
 620  *  Out:
 621  *      none
 622  *
 623  * Return Value: none
 624  *
 625  */
 626 void MACvSetCurrTx0DescAddrEx(struct vnt_private *priv,
 627                               u32 curr_desc_addr)
 628 {
 629         void __iomem *io_base = priv->port_offset;
 630         unsigned short ww;
 631         unsigned char org_dma_ctl;
 632
 633         org_dma_ctl = ioread8(io_base + MAC_REG_TXDMACTL0);
 634         if (org_dma_ctl & DMACTL_RUN)
 635                 iowrite8(DMACTL_RUN, io_base + MAC_REG_TXDMACTL0 + 2);
 636
 637         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 638                 if (!(ioread8(io_base + MAC_REG_TXDMACTL0) & DMACTL_RUN))
 639                         break;
 640         }
 641
 642         iowrite32(curr_desc_addr, io_base + MAC_REG_TXDMAPTR0);
 643         if (org_dma_ctl & DMACTL_RUN)
 644                 iowrite8(DMACTL_RUN, io_base + MAC_REG_TXDMACTL0);
 645 }
 646
 647 /*
 648  * Description:
 649  *      Set the chip with current AC0 descriptor address
 650  *
 651  * Parameters:
 652  *  In:
 653  *      io_base        - Base Address for MAC
 654  *      curr_desc_addr  - Descriptor Address
 655  *  Out:
 656  *      none
 657  *
 658  * Return Value: none
 659  *
 660  */
 661 /* TxDMA1 = AC0DMA */
 662 void MACvSetCurrAC0DescAddrEx(struct vnt_private *priv,
 663                               u32 curr_desc_addr)
 664 {
 665         void __iomem *io_base = priv->port_offset;
 666         unsigned short ww;
 667         unsigned char org_dma_ctl;
 668
 669         org_dma_ctl = ioread8(io_base + MAC_REG_AC0DMACTL);
 670         if (org_dma_ctl & DMACTL_RUN)
 671                 iowrite8(DMACTL_RUN, io_base + MAC_REG_AC0DMACTL + 2);
 672
 673         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 674                 if (!(ioread8(io_base + MAC_REG_AC0DMACTL) & DMACTL_RUN))
 675                         break;
 676         }
 677         if (ww == W_MAX_TIMEOUT)
 678                 pr_debug(" DBG_PORT80(0x26)\n");
 679         iowrite32(curr_desc_addr, io_base + MAC_REG_AC0DMAPTR);
 680         if (org_dma_ctl & DMACTL_RUN)
 681                 iowrite8(DMACTL_RUN, io_base + MAC_REG_AC0DMACTL);
 682 }
 683
 684 void MACvSetCurrTXDescAddr(int iTxType, struct vnt_private *priv,
 685                            u32 curr_desc_addr)
 686 {
 687         if (iTxType == TYPE_AC0DMA)
 688                 MACvSetCurrAC0DescAddrEx(priv, curr_desc_addr);
 689         else if (iTxType == TYPE_TXDMA0)
 690                 MACvSetCurrTx0DescAddrEx(priv, curr_desc_addr);
 691 }
 692
 693 /*
 694  * Description:
 695  *      Micro Second Delay via MAC
 696  *
 697  * Parameters:
 698  *  In:
 699  *      io_base    - Base Address for MAC
 700  *      uDelay      - Delay time (timer resolution is 4 us)
 701  *  Out:
 702  *      none
 703  *
 704  * Return Value: none
 705  *
 706  */
 707 void MACvTimer0MicroSDelay(struct vnt_private *priv, unsigned int uDelay)
 708 {
 709         void __iomem *io_base = priv->port_offset;
 710         unsigned char byValue;
 711         unsigned int uu, ii;
 712
 713         iowrite8(0, io_base + MAC_REG_TMCTL0);
 714         iowrite32(uDelay, io_base + MAC_REG_TMDATA0);
 715         iowrite8((TMCTL_TMD | TMCTL_TE), io_base + MAC_REG_TMCTL0);
 716         for (ii = 0; ii < 66; ii++) {  /* assume max PCI clock is 66Mhz */
 717                 for (uu = 0; uu < uDelay; uu++) {
 718                         byValue = ioread8(io_base + MAC_REG_TMCTL0);
 719                         if ((byValue == 0) ||
 720                             (byValue & TMCTL_TSUSP)) {
 721                                 iowrite8(0, io_base + MAC_REG_TMCTL0);
 722                                 return;
 723                         }
 724                 }
 725         }
 726         iowrite8(0, io_base + MAC_REG_TMCTL0);
 727 }
 728
 729 /*
 730  * Description:
 731  *      Micro Second One shot timer via MAC
 732  *
 733  * Parameters:
 734  *  In:
 735  *      io_base    - Base Address for MAC
 736  *      uDelay      - Delay time
 737  *  Out:
 738  *      none
 739  *
 740  * Return Value: none
 741  *
 742  */
 743 void MACvOneShotTimer1MicroSec(struct vnt_private *priv,
 744                                unsigned int uDelayTime)
 745 {
 746         void __iomem *io_base = priv->port_offset;
 747
 748         iowrite8(0, io_base + MAC_REG_TMCTL1);
 749         iowrite32(uDelayTime, io_base + MAC_REG_TMDATA1);
 750         iowrite8((TMCTL_TMD | TMCTL_TE), io_base + MAC_REG_TMCTL1);
 751 }
 752
 753 void MACvSetMISCFifo(struct vnt_private *priv, unsigned short offset,
 754                      u32 data)
 755 {
 756         void __iomem *io_base = priv->port_offset;
 757
 758         if (offset > 273)
 759                 return;
 760         iowrite16(offset, io_base + MAC_REG_MISCFFNDEX);
 761         iowrite32(data, io_base + MAC_REG_MISCFFDATA);
 762         iowrite16(MISCFFCTL_WRITE, io_base + MAC_REG_MISCFFCTL);
 763 }
 764
 765 bool MACbPSWakeup(struct vnt_private *priv)
 766 {
 767         void __iomem *io_base = priv->port_offset;
 768         unsigned int ww;
 769         /* Read PSCTL */
 770         if (MACbIsRegBitsOff(priv, MAC_REG_PSCTL, PSCTL_PS))
 771                 return true;
 772
 773         /* Disable PS */
 774         vt6655_mac_reg_bits_off(io_base, MAC_REG_PSCTL, PSCTL_PSEN);
 775
 776         /* Check if SyncFlushOK */
 777         for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
 778                 if (ioread8(io_base + MAC_REG_PSCTL) & PSCTL_WAKEDONE)
 779                         break;
 780         }
 781         if (ww == W_MAX_TIMEOUT) {
 782                 pr_debug(" DBG_PORT80(0x33)\n");
 783                 return false;
 784         }
 785         return true;
 786 }
 787
 788 /*
 789  * Description:
 790  *      Set the Key by MISCFIFO
 791  *
 792  * Parameters:
 793  *  In:
 794  *      io_base        - Base Address for MAC
 795  *
 796  *  Out:
 797  *      none
 798  *
 799  * Return Value: none
 800  *
 801  */
 802
 803 void MACvSetKeyEntry(struct vnt_private *priv, unsigned short wKeyCtl,
 804                      unsigned int uEntryIdx, unsigned int uKeyIdx,
 805                      unsigned char *pbyAddr, u32 *pdwKey,
 806                      unsigned char local_id)
 807 {
 808         void __iomem *io_base = priv->port_offset;
 809         unsigned short offset;
 810         u32 data;
 811         int     ii;
 812
 813         if (local_id <= 1)
 814                 return;
 815
 816         offset = MISCFIFO_KEYETRY0;
 817         offset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
 818
 819         data = 0;
 820         data |= wKeyCtl;
 821         data <<= 16;
 822         data |= MAKEWORD(*(pbyAddr + 4), *(pbyAddr + 5));
 823         pr_debug("1. offset: %d, Data: %X, KeyCtl:%X\n",
 824                  offset, data, wKeyCtl);
 825
 826         iowrite16(offset, io_base + MAC_REG_MISCFFNDEX);
 827         iowrite32(data, io_base + MAC_REG_MISCFFDATA);
 828         iowrite16(MISCFFCTL_WRITE, io_base + MAC_REG_MISCFFCTL);
 829         offset++;
 830
 831         data = 0;
 832         data |= *(pbyAddr + 3);
 833         data <<= 8;
 834         data |= *(pbyAddr + 2);
 835         data <<= 8;
 836         data |= *(pbyAddr + 1);
 837         data <<= 8;
 838         data |= *pbyAddr;
 839         pr_debug("2. offset: %d, Data: %X\n", offset, data);
 840
 841         iowrite16(offset, io_base + MAC_REG_MISCFFNDEX);
 842         iowrite32(data, io_base + MAC_REG_MISCFFDATA);
 843         iowrite16(MISCFFCTL_WRITE, io_base + MAC_REG_MISCFFCTL);
 844         offset++;
 845
 846         offset += (uKeyIdx * 4);
 847         for (ii = 0; ii < 4; ii++) {
 848                 /* always push 128 bits */
 849                 pr_debug("3.(%d) offset: %d, Data: %X\n",
 850                          ii, offset + ii, *pdwKey);
 851                 iowrite16(offset + ii, io_base + MAC_REG_MISCFFNDEX);
 852                 iowrite32(*pdwKey++, io_base + MAC_REG_MISCFFDATA);
 853                 iowrite16(MISCFFCTL_WRITE, io_base + MAC_REG_MISCFFCTL);
 854         }
 855 }
 856
 857 /*
 858  * Description:
 859  *      Disable the Key Entry by MISCFIFO
 860  *
 861  * Parameters:
 862  *  In:
 863  *      io_base        - Base Address for MAC
 864  *
 865  *  Out:
 866  *      none
 867  *
 868  * Return Value: none
 869  *
 870  */
 871 void MACvDisableKeyEntry(struct vnt_private *priv, unsigned int uEntryIdx)
 872 {
 873         void __iomem *io_base = priv->port_offset;
 874         unsigned short offset;
 875
 876         offset = MISCFIFO_KEYETRY0;
 877         offset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
 878
 879         iowrite16(offset, io_base + MAC_REG_MISCFFNDEX);
 880         iowrite32(0, io_base + MAC_REG_MISCFFDATA);
 881         iowrite16(MISCFFCTL_WRITE, io_base + MAC_REG_MISCFFCTL);
 882 }