/drivers/staging/vt6655/mac.c

https://bitbucket.org/wisechild/galaxy-nexus · C · 1750 lines · 755 code · 189 blank · 806 comment · 132 complexity · 23b71bbbd0798e6aff8640050df977bf MD5 · raw file

  1. /*
  2. * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
  3. * All rights reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation; either version 2 of the License, or
  8. * (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License along
  16. * with this program; if not, write to the Free Software Foundation, Inc.,
  17. * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18. *
  19. *
  20. * File: mac.c
  21. *
  22. * Purpose: MAC routines
  23. *
  24. * Author: Tevin Chen
  25. *
  26. * Date: May 21, 1996
  27. *
  28. * Functions:
  29. * MACvReadAllRegs - Read All MAC Registers to buffer
  30. * MACbIsRegBitsOn - Test if All test Bits On
  31. * MACbIsRegBitsOff - Test if All test Bits Off
  32. * MACbIsIntDisable - Test if MAC interrupt disable
  33. * MACbyReadMultiAddr - Read Multicast Address Mask Pattern
  34. * MACvWriteMultiAddr - Write Multicast Address Mask Pattern
  35. * MACvSetMultiAddrByHash - Set Multicast Address Mask by Hash value
  36. * MACvResetMultiAddrByHash - Clear Multicast Address Mask by Hash value
  37. * MACvSetRxThreshold - Set Rx Threshold value
  38. * MACvGetRxThreshold - Get Rx Threshold value
  39. * MACvSetTxThreshold - Set Tx Threshold value
  40. * MACvGetTxThreshold - Get Tx Threshold value
  41. * MACvSetDmaLength - Set Dma Length value
  42. * MACvGetDmaLength - Get Dma Length value
  43. * MACvSetShortRetryLimit - Set 802.11 Short Retry limit
  44. * MACvGetShortRetryLimit - Get 802.11 Short Retry limit
  45. * MACvSetLongRetryLimit - Set 802.11 Long Retry limit
  46. * MACvGetLongRetryLimit - Get 802.11 Long Retry limit
  47. * MACvSetLoopbackMode - Set MAC Loopback Mode
  48. * MACbIsInLoopbackMode - Test if MAC in Loopback mode
  49. * MACvSetPacketFilter - Set MAC Address Filter
  50. * MACvSaveContext - Save Context of MAC Registers
  51. * MACvRestoreContext - Restore Context of MAC Registers
  52. * MACbCompareContext - Compare if values of MAC Registers same as Context
  53. * MACbSoftwareReset - Software Reset MAC
  54. * MACbSafeRxOff - Turn Off MAC Rx
  55. * MACbSafeTxOff - Turn Off MAC Tx
  56. * MACbSafeStop - Stop MAC function
  57. * MACbShutdown - Shut down MAC
  58. * MACvInitialize - Initialize MAC
  59. * MACvSetCurrRxDescAddr - Set Rx Descriptos Address
  60. * MACvSetCurrTx0DescAddr - Set Tx0 Descriptos Address
  61. * MACvSetCurrTx1DescAddr - Set Tx1 Descriptos Address
  62. * MACvTimer0MicroSDelay - Micro Second Delay Loop by MAC
  63. *
  64. * Revision History:
  65. * 08-22-2003 Kyle Hsu : Porting MAC functions from sim53
  66. * 09-03-2003 Bryan YC Fan : Add MACvClearBusSusInd()& MACvEnableBusSusEn()
  67. * 09-18-2003 Jerry Chen : Add MACvSetKeyEntry & MACvDisableKeyEntry
  68. *
  69. */
  70. #include "tmacro.h"
  71. #include "tether.h"
  72. #include "mac.h"
  73. unsigned short TxRate_iwconfig;//2008-5-8 <add> by chester
  74. /*--------------------- Static Definitions -------------------------*/
  75. //static int msglevel =MSG_LEVEL_DEBUG;
  76. static int msglevel =MSG_LEVEL_INFO;
  77. /*--------------------- Static Classes ----------------------------*/
  78. /*--------------------- Static Variables --------------------------*/
  79. /*--------------------- Static Functions --------------------------*/
  80. /*--------------------- Export Variables --------------------------*/
  81. /*--------------------- Export Functions --------------------------*/
  82. /*
  83. * Description:
  84. * Read All MAC Registers to buffer
  85. *
  86. * Parameters:
  87. * In:
  88. * dwIoBase - Base Address for MAC
  89. * Out:
  90. * pbyMacRegs - buffer to read
  91. *
  92. * Return Value: none
  93. *
  94. */
  95. void MACvReadAllRegs (unsigned long dwIoBase, unsigned char *pbyMacRegs)
  96. {
  97. int ii;
  98. // read page0 register
  99. for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE0; ii++) {
  100. VNSvInPortB(dwIoBase + ii, pbyMacRegs);
  101. pbyMacRegs++;
  102. }
  103. MACvSelectPage1(dwIoBase);
  104. // read page1 register
  105. for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE1; ii++) {
  106. VNSvInPortB(dwIoBase + ii, pbyMacRegs);
  107. pbyMacRegs++;
  108. }
  109. MACvSelectPage0(dwIoBase);
  110. }
  111. /*
  112. * Description:
  113. * Test if all test bits on
  114. *
  115. * Parameters:
  116. * In:
  117. * dwIoBase - Base Address for MAC
  118. * byRegOfs - Offset of MAC Register
  119. * byTestBits - Test bits
  120. * Out:
  121. * none
  122. *
  123. * Return Value: true if all test bits On; otherwise false
  124. *
  125. */
  126. bool MACbIsRegBitsOn (unsigned long dwIoBase, unsigned char byRegOfs, unsigned char byTestBits)
  127. {
  128. unsigned char byData;
  129. VNSvInPortB(dwIoBase + byRegOfs, &byData);
  130. return (byData & byTestBits) == byTestBits;
  131. }
  132. /*
  133. * Description:
  134. * Test if all test bits off
  135. *
  136. * Parameters:
  137. * In:
  138. * dwIoBase - Base Address for MAC
  139. * byRegOfs - Offset of MAC Register
  140. * byTestBits - Test bits
  141. * Out:
  142. * none
  143. *
  144. * Return Value: true if all test bits Off; otherwise false
  145. *
  146. */
  147. bool MACbIsRegBitsOff (unsigned long dwIoBase, unsigned char byRegOfs, unsigned char byTestBits)
  148. {
  149. unsigned char byData;
  150. VNSvInPortB(dwIoBase + byRegOfs, &byData);
  151. return !(byData & byTestBits);
  152. }
  153. /*
  154. * Description:
  155. * Test if MAC interrupt disable
  156. *
  157. * Parameters:
  158. * In:
  159. * dwIoBase - Base Address for MAC
  160. * Out:
  161. * none
  162. *
  163. * Return Value: true if interrupt is disable; otherwise false
  164. *
  165. */
  166. bool MACbIsIntDisable (unsigned long dwIoBase)
  167. {
  168. unsigned long dwData;
  169. VNSvInPortD(dwIoBase + MAC_REG_IMR, &dwData);
  170. if (dwData != 0)
  171. return false;
  172. return true;
  173. }
  174. /*
  175. * Description:
  176. * Read MAC Multicast Address Mask
  177. *
  178. * Parameters:
  179. * In:
  180. * dwIoBase - Base Address for MAC
  181. * uByteidx - Index of Mask
  182. * Out:
  183. * none
  184. *
  185. * Return Value: Mask Value read
  186. *
  187. */
  188. unsigned char MACbyReadMultiAddr (unsigned long dwIoBase, unsigned int uByteIdx)
  189. {
  190. unsigned char byData;
  191. MACvSelectPage1(dwIoBase);
  192. VNSvInPortB(dwIoBase + MAC_REG_MAR0 + uByteIdx, &byData);
  193. MACvSelectPage0(dwIoBase);
  194. return byData;
  195. }
  196. /*
  197. * Description:
  198. * Write MAC Multicast Address Mask
  199. *
  200. * Parameters:
  201. * In:
  202. * dwIoBase - Base Address for MAC
  203. * uByteidx - Index of Mask
  204. * byData - Mask Value to write
  205. * Out:
  206. * none
  207. *
  208. * Return Value: none
  209. *
  210. */
  211. void MACvWriteMultiAddr (unsigned long dwIoBase, unsigned int uByteIdx, unsigned char byData)
  212. {
  213. MACvSelectPage1(dwIoBase);
  214. VNSvOutPortB(dwIoBase + MAC_REG_MAR0 + uByteIdx, byData);
  215. MACvSelectPage0(dwIoBase);
  216. }
  217. /*
  218. * Description:
  219. * Set this hash index into multicast address register bit
  220. *
  221. * Parameters:
  222. * In:
  223. * dwIoBase - Base Address for MAC
  224. * byHashIdx - Hash index to set
  225. * Out:
  226. * none
  227. *
  228. * Return Value: none
  229. *
  230. */
  231. void MACvSetMultiAddrByHash (unsigned long dwIoBase, unsigned char byHashIdx)
  232. {
  233. unsigned int uByteIdx;
  234. unsigned char byBitMask;
  235. unsigned char byOrgValue;
  236. // calculate byte position
  237. uByteIdx = byHashIdx / 8;
  238. ASSERT(uByteIdx < 8);
  239. // calculate bit position
  240. byBitMask = 1;
  241. byBitMask <<= (byHashIdx % 8);
  242. // turn on the bit
  243. byOrgValue = MACbyReadMultiAddr(dwIoBase, uByteIdx);
  244. MACvWriteMultiAddr(dwIoBase, uByteIdx, (unsigned char)(byOrgValue | byBitMask));
  245. }
  246. /*
  247. * Description:
  248. * Reset this hash index into multicast address register bit
  249. *
  250. * Parameters:
  251. * In:
  252. * dwIoBase - Base Address for MAC
  253. * byHashIdx - Hash index to clear
  254. * Out:
  255. * none
  256. *
  257. * Return Value: none
  258. *
  259. */
  260. void MACvResetMultiAddrByHash (unsigned long dwIoBase, unsigned char byHashIdx)
  261. {
  262. unsigned int uByteIdx;
  263. unsigned char byBitMask;
  264. unsigned char byOrgValue;
  265. // calculate byte position
  266. uByteIdx = byHashIdx / 8;
  267. ASSERT(uByteIdx < 8);
  268. // calculate bit position
  269. byBitMask = 1;
  270. byBitMask <<= (byHashIdx % 8);
  271. // turn off the bit
  272. byOrgValue = MACbyReadMultiAddr(dwIoBase, uByteIdx);
  273. MACvWriteMultiAddr(dwIoBase, uByteIdx, (unsigned char)(byOrgValue & (~byBitMask)));
  274. }
  275. /*
  276. * Description:
  277. * Set Rx Threshold
  278. *
  279. * Parameters:
  280. * In:
  281. * dwIoBase - Base Address for MAC
  282. * byThreshold - Threshold Value
  283. * Out:
  284. * none
  285. *
  286. * Return Value: none
  287. *
  288. */
  289. void MACvSetRxThreshold (unsigned long dwIoBase, unsigned char byThreshold)
  290. {
  291. unsigned char byOrgValue;
  292. ASSERT(byThreshold < 4);
  293. // set FCR0
  294. VNSvInPortB(dwIoBase + MAC_REG_FCR0, &byOrgValue);
  295. byOrgValue = (byOrgValue & 0xCF) | (byThreshold << 4);
  296. VNSvOutPortB(dwIoBase + MAC_REG_FCR0, byOrgValue);
  297. }
  298. /*
  299. * Description:
  300. * Get Rx Threshold
  301. *
  302. * Parameters:
  303. * In:
  304. * dwIoBase - Base Address for MAC
  305. * Out:
  306. * pbyThreshold- Threshold Value Get
  307. *
  308. * Return Value: none
  309. *
  310. */
  311. void MACvGetRxThreshold (unsigned long dwIoBase, unsigned char *pbyThreshold)
  312. {
  313. // get FCR0
  314. VNSvInPortB(dwIoBase + MAC_REG_FCR0, pbyThreshold);
  315. *pbyThreshold = (*pbyThreshold >> 4) & 0x03;
  316. }
  317. /*
  318. * Description:
  319. * Set Tx Threshold
  320. *
  321. * Parameters:
  322. * In:
  323. * dwIoBase - Base Address for MAC
  324. * byThreshold - Threshold Value
  325. * Out:
  326. * none
  327. *
  328. * Return Value: none
  329. *
  330. */
  331. void MACvSetTxThreshold (unsigned long dwIoBase, unsigned char byThreshold)
  332. {
  333. unsigned char byOrgValue;
  334. ASSERT(byThreshold < 4);
  335. // set FCR0
  336. VNSvInPortB(dwIoBase + MAC_REG_FCR0, &byOrgValue);
  337. byOrgValue = (byOrgValue & 0xF3) | (byThreshold << 2);
  338. VNSvOutPortB(dwIoBase + MAC_REG_FCR0, byOrgValue);
  339. }
  340. /*
  341. * Description:
  342. * Get Tx Threshold
  343. *
  344. * Parameters:
  345. * In:
  346. * dwIoBase - Base Address for MAC
  347. * Out:
  348. * pbyThreshold- Threshold Value Get
  349. *
  350. * Return Value: none
  351. *
  352. */
  353. void MACvGetTxThreshold (unsigned long dwIoBase, unsigned char *pbyThreshold)
  354. {
  355. // get FCR0
  356. VNSvInPortB(dwIoBase + MAC_REG_FCR0, pbyThreshold);
  357. *pbyThreshold = (*pbyThreshold >> 2) & 0x03;
  358. }
  359. /*
  360. * Description:
  361. * Set Dma Length
  362. *
  363. * Parameters:
  364. * In:
  365. * dwIoBase - Base Address for MAC
  366. * byDmaLength - Dma Length Value
  367. * Out:
  368. * none
  369. *
  370. * Return Value: none
  371. *
  372. */
  373. void MACvSetDmaLength (unsigned long dwIoBase, unsigned char byDmaLength)
  374. {
  375. unsigned char byOrgValue;
  376. ASSERT(byDmaLength < 4);
  377. // set FCR0
  378. VNSvInPortB(dwIoBase + MAC_REG_FCR0, &byOrgValue);
  379. byOrgValue = (byOrgValue & 0xFC) | byDmaLength;
  380. VNSvOutPortB(dwIoBase + MAC_REG_FCR0, byOrgValue);
  381. }
  382. /*
  383. * Description:
  384. * Get Dma Length
  385. *
  386. * Parameters:
  387. * In:
  388. * dwIoBase - Base Address for MAC
  389. * Out:
  390. * pbyDmaLength- Dma Length Value Get
  391. *
  392. * Return Value: none
  393. *
  394. */
  395. void MACvGetDmaLength (unsigned long dwIoBase, unsigned char *pbyDmaLength)
  396. {
  397. // get FCR0
  398. VNSvInPortB(dwIoBase + MAC_REG_FCR0, pbyDmaLength);
  399. *pbyDmaLength &= 0x03;
  400. }
  401. /*
  402. * Description:
  403. * Set 802.11 Short Retry Limit
  404. *
  405. * Parameters:
  406. * In:
  407. * dwIoBase - Base Address for MAC
  408. * byRetryLimit- Retry Limit
  409. * Out:
  410. * none
  411. *
  412. * Return Value: none
  413. *
  414. */
  415. void MACvSetShortRetryLimit (unsigned long dwIoBase, unsigned char byRetryLimit)
  416. {
  417. // set SRT
  418. VNSvOutPortB(dwIoBase + MAC_REG_SRT, byRetryLimit);
  419. }
  420. /*
  421. * Description:
  422. * Get 802.11 Short Retry Limit
  423. *
  424. * Parameters:
  425. * In:
  426. * dwIoBase - Base Address for MAC
  427. * Out:
  428. * pbyRetryLimit - Retry Limit Get
  429. *
  430. * Return Value: none
  431. *
  432. */
  433. void MACvGetShortRetryLimit (unsigned long dwIoBase, unsigned char *pbyRetryLimit)
  434. {
  435. // get SRT
  436. VNSvInPortB(dwIoBase + MAC_REG_SRT, pbyRetryLimit);
  437. }
  438. /*
  439. * Description:
  440. * Set 802.11 Long Retry Limit
  441. *
  442. * Parameters:
  443. * In:
  444. * dwIoBase - Base Address for MAC
  445. * byRetryLimit- Retry Limit
  446. * Out:
  447. * none
  448. *
  449. * Return Value: none
  450. *
  451. */
  452. void MACvSetLongRetryLimit (unsigned long dwIoBase, unsigned char byRetryLimit)
  453. {
  454. // set LRT
  455. VNSvOutPortB(dwIoBase + MAC_REG_LRT, byRetryLimit);
  456. }
  457. /*
  458. * Description:
  459. * Get 802.11 Long Retry Limit
  460. *
  461. * Parameters:
  462. * In:
  463. * dwIoBase - Base Address for MAC
  464. * Out:
  465. * pbyRetryLimit - Retry Limit Get
  466. *
  467. * Return Value: none
  468. *
  469. */
  470. void MACvGetLongRetryLimit (unsigned long dwIoBase, unsigned char *pbyRetryLimit)
  471. {
  472. // get LRT
  473. VNSvInPortB(dwIoBase + MAC_REG_LRT, pbyRetryLimit);
  474. }
  475. /*
  476. * Description:
  477. * Set MAC Loopback mode
  478. *
  479. * Parameters:
  480. * In:
  481. * dwIoBase - Base Address for MAC
  482. * byLoopbackMode - Loopback Mode
  483. * Out:
  484. * none
  485. *
  486. * Return Value: none
  487. *
  488. */
  489. void MACvSetLoopbackMode (unsigned long dwIoBase, unsigned char byLoopbackMode)
  490. {
  491. unsigned char byOrgValue;
  492. ASSERT(byLoopbackMode < 3);
  493. byLoopbackMode <<= 6;
  494. // set TCR
  495. VNSvInPortB(dwIoBase + MAC_REG_TEST, &byOrgValue);
  496. byOrgValue = byOrgValue & 0x3F;
  497. byOrgValue = byOrgValue | byLoopbackMode;
  498. VNSvOutPortB(dwIoBase + MAC_REG_TEST, byOrgValue);
  499. }
  500. /*
  501. * Description:
  502. * Test if MAC in Loopback mode
  503. *
  504. * Parameters:
  505. * In:
  506. * dwIoBase - Base Address for MAC
  507. * Out:
  508. * none
  509. *
  510. * Return Value: true if in Loopback mode; otherwise false
  511. *
  512. */
  513. bool MACbIsInLoopbackMode (unsigned long dwIoBase)
  514. {
  515. unsigned char byOrgValue;
  516. VNSvInPortB(dwIoBase + MAC_REG_TEST, &byOrgValue);
  517. if (byOrgValue & (TEST_LBINT | TEST_LBEXT))
  518. return true;
  519. return false;
  520. }
  521. /*
  522. * Description:
  523. * Set MAC Address filter
  524. *
  525. * Parameters:
  526. * In:
  527. * dwIoBase - Base Address for MAC
  528. * wFilterType - Filter Type
  529. * Out:
  530. * none
  531. *
  532. * Return Value: none
  533. *
  534. */
  535. void MACvSetPacketFilter (unsigned long dwIoBase, unsigned short wFilterType)
  536. {
  537. unsigned char byOldRCR;
  538. unsigned char byNewRCR = 0;
  539. // if only in DIRECTED mode, multicast-address will set to zero,
  540. // but if other mode exist (e.g. PROMISCUOUS), multicast-address
  541. // will be open
  542. if (wFilterType & PKT_TYPE_DIRECTED) {
  543. // set multicast address to accept none
  544. MACvSelectPage1(dwIoBase);
  545. VNSvOutPortD(dwIoBase + MAC_REG_MAR0, 0L);
  546. VNSvOutPortD(dwIoBase + MAC_REG_MAR0 + sizeof(unsigned long), 0L);
  547. MACvSelectPage0(dwIoBase);
  548. }
  549. if (wFilterType & (PKT_TYPE_PROMISCUOUS | PKT_TYPE_ALL_MULTICAST)) {
  550. // set multicast address to accept all
  551. MACvSelectPage1(dwIoBase);
  552. VNSvOutPortD(dwIoBase + MAC_REG_MAR0, 0xFFFFFFFFL);
  553. VNSvOutPortD(dwIoBase + MAC_REG_MAR0 + sizeof(unsigned long), 0xFFFFFFFFL);
  554. MACvSelectPage0(dwIoBase);
  555. }
  556. if (wFilterType & PKT_TYPE_PROMISCUOUS) {
  557. byNewRCR |= (RCR_RXALLTYPE | RCR_UNICAST | RCR_MULTICAST | RCR_BROADCAST);
  558. byNewRCR &= ~RCR_BSSID;
  559. }
  560. if (wFilterType & (PKT_TYPE_ALL_MULTICAST | PKT_TYPE_MULTICAST))
  561. byNewRCR |= RCR_MULTICAST;
  562. if (wFilterType & PKT_TYPE_BROADCAST)
  563. byNewRCR |= RCR_BROADCAST;
  564. if (wFilterType & PKT_TYPE_ERROR_CRC)
  565. byNewRCR |= RCR_ERRCRC;
  566. VNSvInPortB(dwIoBase + MAC_REG_RCR, &byOldRCR);
  567. if (byNewRCR != byOldRCR) {
  568. // Modify the Receive Command Register
  569. VNSvOutPortB(dwIoBase + MAC_REG_RCR, byNewRCR);
  570. }
  571. }
  572. /*
  573. * Description:
  574. * Save MAC registers to context buffer
  575. *
  576. * Parameters:
  577. * In:
  578. * dwIoBase - Base Address for MAC
  579. * Out:
  580. * pbyCxtBuf - Context buffer
  581. *
  582. * Return Value: none
  583. *
  584. */
  585. void MACvSaveContext (unsigned long dwIoBase, unsigned char *pbyCxtBuf)
  586. {
  587. int ii;
  588. // read page0 register
  589. for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE0; ii++) {
  590. VNSvInPortB((dwIoBase + ii), (pbyCxtBuf + ii));
  591. }
  592. MACvSelectPage1(dwIoBase);
  593. // read page1 register
  594. for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE1; ii++) {
  595. VNSvInPortB((dwIoBase + ii), (pbyCxtBuf + MAC_MAX_CONTEXT_SIZE_PAGE0 + ii));
  596. }
  597. MACvSelectPage0(dwIoBase);
  598. }
  599. /*
  600. * Description:
  601. * Restore MAC registers from context buffer
  602. *
  603. * Parameters:
  604. * In:
  605. * dwIoBase - Base Address for MAC
  606. * pbyCxtBuf - Context buffer
  607. * Out:
  608. * none
  609. *
  610. * Return Value: none
  611. *
  612. */
  613. void MACvRestoreContext (unsigned long dwIoBase, unsigned char *pbyCxtBuf)
  614. {
  615. int ii;
  616. MACvSelectPage1(dwIoBase);
  617. // restore page1
  618. for (ii = 0; ii < MAC_MAX_CONTEXT_SIZE_PAGE1; ii++) {
  619. VNSvOutPortB((dwIoBase + ii), *(pbyCxtBuf + MAC_MAX_CONTEXT_SIZE_PAGE0 + ii));
  620. }
  621. MACvSelectPage0(dwIoBase);
  622. // restore RCR,TCR,IMR...
  623. for (ii = MAC_REG_RCR; ii < MAC_REG_ISR; ii++) {
  624. VNSvOutPortB(dwIoBase + ii, *(pbyCxtBuf + ii));
  625. }
  626. // restore MAC Config.
  627. for (ii = MAC_REG_LRT; ii < MAC_REG_PAGE1SEL; ii++) {
  628. VNSvOutPortB(dwIoBase + ii, *(pbyCxtBuf + ii));
  629. }
  630. VNSvOutPortB(dwIoBase + MAC_REG_CFG, *(pbyCxtBuf + MAC_REG_CFG));
  631. // restore PS Config.
  632. for (ii = MAC_REG_PSCFG; ii < MAC_REG_BBREGCTL; ii++) {
  633. VNSvOutPortB(dwIoBase + ii, *(pbyCxtBuf + ii));
  634. }
  635. // restore CURR_RX_DESC_ADDR, CURR_TX_DESC_ADDR
  636. VNSvOutPortD(dwIoBase + MAC_REG_TXDMAPTR0, *(unsigned long *)(pbyCxtBuf + MAC_REG_TXDMAPTR0));
  637. VNSvOutPortD(dwIoBase + MAC_REG_AC0DMAPTR, *(unsigned long *)(pbyCxtBuf + MAC_REG_AC0DMAPTR));
  638. VNSvOutPortD(dwIoBase + MAC_REG_BCNDMAPTR, *(unsigned long *)(pbyCxtBuf + MAC_REG_BCNDMAPTR));
  639. VNSvOutPortD(dwIoBase + MAC_REG_RXDMAPTR0, *(unsigned long *)(pbyCxtBuf + MAC_REG_RXDMAPTR0));
  640. VNSvOutPortD(dwIoBase + MAC_REG_RXDMAPTR1, *(unsigned long *)(pbyCxtBuf + MAC_REG_RXDMAPTR1));
  641. }
  642. /*
  643. * Description:
  644. * Compare if MAC registers same as context buffer
  645. *
  646. * Parameters:
  647. * In:
  648. * dwIoBase - Base Address for MAC
  649. * pbyCxtBuf - Context buffer
  650. * Out:
  651. * none
  652. *
  653. * Return Value: true if all values are the same; otherwise false
  654. *
  655. */
  656. bool MACbCompareContext (unsigned long dwIoBase, unsigned char *pbyCxtBuf)
  657. {
  658. unsigned long dwData;
  659. // compare MAC context to determine if this is a power lost init,
  660. // return true for power remaining init, return false for power lost init
  661. // compare CURR_RX_DESC_ADDR, CURR_TX_DESC_ADDR
  662. VNSvInPortD(dwIoBase + MAC_REG_TXDMAPTR0, &dwData);
  663. if (dwData != *(unsigned long *)(pbyCxtBuf + MAC_REG_TXDMAPTR0)) {
  664. return false;
  665. }
  666. VNSvInPortD(dwIoBase + MAC_REG_AC0DMAPTR, &dwData);
  667. if (dwData != *(unsigned long *)(pbyCxtBuf + MAC_REG_AC0DMAPTR)) {
  668. return false;
  669. }
  670. VNSvInPortD(dwIoBase + MAC_REG_RXDMAPTR0, &dwData);
  671. if (dwData != *(unsigned long *)(pbyCxtBuf + MAC_REG_RXDMAPTR0)) {
  672. return false;
  673. }
  674. VNSvInPortD(dwIoBase + MAC_REG_RXDMAPTR1, &dwData);
  675. if (dwData != *(unsigned long *)(pbyCxtBuf + MAC_REG_RXDMAPTR1)) {
  676. return false;
  677. }
  678. return true;
  679. }
  680. /*
  681. * Description:
  682. * Software Reset MAC
  683. *
  684. * Parameters:
  685. * In:
  686. * dwIoBase - Base Address for MAC
  687. * Out:
  688. * none
  689. *
  690. * Return Value: true if Reset Success; otherwise false
  691. *
  692. */
  693. bool MACbSoftwareReset (unsigned long dwIoBase)
  694. {
  695. unsigned char byData;
  696. unsigned short ww;
  697. // turn on HOSTCR_SOFTRST, just write 0x01 to reset
  698. //MACvRegBitsOn(dwIoBase, MAC_REG_HOSTCR, HOSTCR_SOFTRST);
  699. VNSvOutPortB(dwIoBase+ MAC_REG_HOSTCR, 0x01);
  700. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  701. VNSvInPortB(dwIoBase + MAC_REG_HOSTCR, &byData);
  702. if ( !(byData & HOSTCR_SOFTRST))
  703. break;
  704. }
  705. if (ww == W_MAX_TIMEOUT)
  706. return false;
  707. return true;
  708. }
  709. /*
  710. * Description:
  711. * save some important register's value, then do reset, then restore register's value
  712. *
  713. * Parameters:
  714. * In:
  715. * dwIoBase - Base Address for MAC
  716. * Out:
  717. * none
  718. *
  719. * Return Value: true if success; otherwise false
  720. *
  721. */
  722. bool MACbSafeSoftwareReset (unsigned long dwIoBase)
  723. {
  724. unsigned char abyTmpRegData[MAC_MAX_CONTEXT_SIZE_PAGE0+MAC_MAX_CONTEXT_SIZE_PAGE1];
  725. bool bRetVal;
  726. // PATCH....
  727. // save some important register's value, then do
  728. // reset, then restore register's value
  729. // save MAC context
  730. MACvSaveContext(dwIoBase, abyTmpRegData);
  731. // do reset
  732. bRetVal = MACbSoftwareReset(dwIoBase);
  733. //BBvSoftwareReset(pDevice->PortOffset);
  734. // restore MAC context, except CR0
  735. MACvRestoreContext(dwIoBase, abyTmpRegData);
  736. return bRetVal;
  737. }
  738. /*
  739. * Description:
  740. * Trun Off MAC Rx
  741. *
  742. * Parameters:
  743. * In:
  744. * dwIoBase - Base Address for MAC
  745. * Out:
  746. * none
  747. *
  748. * Return Value: true if success; otherwise false
  749. *
  750. */
  751. bool MACbSafeRxOff (unsigned long dwIoBase)
  752. {
  753. unsigned short ww;
  754. unsigned long dwData;
  755. unsigned char byData;
  756. // turn off wow temp for turn off Rx safely
  757. // Clear RX DMA0,1
  758. VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL0, DMACTL_CLRRUN);
  759. VNSvOutPortD(dwIoBase + MAC_REG_RXDMACTL1, DMACTL_CLRRUN);
  760. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  761. VNSvInPortD(dwIoBase + MAC_REG_RXDMACTL0, &dwData);
  762. if (!(dwData & DMACTL_RUN))
  763. break;
  764. }
  765. if (ww == W_MAX_TIMEOUT) {
  766. DBG_PORT80(0x10);
  767. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x10)\n");
  768. return(false);
  769. }
  770. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  771. VNSvInPortD(dwIoBase + MAC_REG_RXDMACTL1, &dwData);
  772. if ( !(dwData & DMACTL_RUN))
  773. break;
  774. }
  775. if (ww == W_MAX_TIMEOUT) {
  776. DBG_PORT80(0x11);
  777. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x11)\n");
  778. return(false);
  779. }
  780. // try to safe shutdown RX
  781. MACvRegBitsOff(dwIoBase, MAC_REG_HOSTCR, HOSTCR_RXON);
  782. // W_MAX_TIMEOUT is the timeout period
  783. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  784. VNSvInPortB(dwIoBase + MAC_REG_HOSTCR, &byData);
  785. if ( !(byData & HOSTCR_RXONST))
  786. break;
  787. }
  788. if (ww == W_MAX_TIMEOUT) {
  789. DBG_PORT80(0x12);
  790. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x12)\n");
  791. return(false);
  792. }
  793. return true;
  794. }
  795. /*
  796. * Description:
  797. * Trun Off MAC Tx
  798. *
  799. * Parameters:
  800. * In:
  801. * dwIoBase - Base Address for MAC
  802. * Out:
  803. * none
  804. *
  805. * Return Value: true if success; otherwise false
  806. *
  807. */
  808. bool MACbSafeTxOff (unsigned long dwIoBase)
  809. {
  810. unsigned short ww;
  811. unsigned long dwData;
  812. unsigned char byData;
  813. // Clear TX DMA
  814. //Tx0
  815. VNSvOutPortD(dwIoBase + MAC_REG_TXDMACTL0, DMACTL_CLRRUN);
  816. //AC0
  817. VNSvOutPortD(dwIoBase + MAC_REG_AC0DMACTL, DMACTL_CLRRUN);
  818. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  819. VNSvInPortD(dwIoBase + MAC_REG_TXDMACTL0, &dwData);
  820. if ( !(dwData & DMACTL_RUN))
  821. break;
  822. }
  823. if (ww == W_MAX_TIMEOUT) {
  824. DBG_PORT80(0x20);
  825. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x20)\n");
  826. return(false);
  827. }
  828. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  829. VNSvInPortD(dwIoBase + MAC_REG_AC0DMACTL, &dwData);
  830. if ( !(dwData & DMACTL_RUN))
  831. break;
  832. }
  833. if (ww == W_MAX_TIMEOUT) {
  834. DBG_PORT80(0x21);
  835. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x21)\n");
  836. return(false);
  837. }
  838. // try to safe shutdown TX
  839. MACvRegBitsOff(dwIoBase, MAC_REG_HOSTCR, HOSTCR_TXON);
  840. // W_MAX_TIMEOUT is the timeout period
  841. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  842. VNSvInPortB(dwIoBase + MAC_REG_HOSTCR, &byData);
  843. if ( !(byData & HOSTCR_TXONST))
  844. break;
  845. }
  846. if (ww == W_MAX_TIMEOUT) {
  847. DBG_PORT80(0x24);
  848. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x24)\n");
  849. return(false);
  850. }
  851. return true;
  852. }
  853. /*
  854. * Description:
  855. * Stop MAC function
  856. *
  857. * Parameters:
  858. * In:
  859. * dwIoBase - Base Address for MAC
  860. * Out:
  861. * none
  862. *
  863. * Return Value: true if success; otherwise false
  864. *
  865. */
  866. bool MACbSafeStop (unsigned long dwIoBase)
  867. {
  868. MACvRegBitsOff(dwIoBase, MAC_REG_TCR, TCR_AUTOBCNTX);
  869. if (MACbSafeRxOff(dwIoBase) == false) {
  870. DBG_PORT80(0xA1);
  871. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" MACbSafeRxOff == false)\n");
  872. MACbSafeSoftwareReset(dwIoBase);
  873. return false;
  874. }
  875. if (MACbSafeTxOff(dwIoBase) == false) {
  876. DBG_PORT80(0xA2);
  877. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" MACbSafeTxOff == false)\n");
  878. MACbSafeSoftwareReset(dwIoBase);
  879. return false;
  880. }
  881. MACvRegBitsOff(dwIoBase, MAC_REG_HOSTCR, HOSTCR_MACEN);
  882. return true;
  883. }
  884. /*
  885. * Description:
  886. * Shut Down MAC
  887. *
  888. * Parameters:
  889. * In:
  890. * dwIoBase - Base Address for MAC
  891. * Out:
  892. * none
  893. *
  894. * Return Value: true if success; otherwise false
  895. *
  896. */
  897. bool MACbShutdown (unsigned long dwIoBase)
  898. {
  899. // disable MAC IMR
  900. MACvIntDisable(dwIoBase);
  901. MACvSetLoopbackMode(dwIoBase, MAC_LB_INTERNAL);
  902. // stop the adapter
  903. if (!MACbSafeStop(dwIoBase)) {
  904. MACvSetLoopbackMode(dwIoBase, MAC_LB_NONE);
  905. return false;
  906. }
  907. MACvSetLoopbackMode(dwIoBase, MAC_LB_NONE);
  908. return true;
  909. }
  910. /*
  911. * Description:
  912. * Initialize MAC
  913. *
  914. * Parameters:
  915. * In:
  916. * dwIoBase - Base Address for MAC
  917. * Out:
  918. * none
  919. *
  920. * Return Value: none
  921. *
  922. */
  923. void MACvInitialize (unsigned long dwIoBase)
  924. {
  925. // clear sticky bits
  926. MACvClearStckDS(dwIoBase);
  927. // disable force PME-enable
  928. VNSvOutPortB(dwIoBase + MAC_REG_PMC1, PME_OVR);
  929. // only 3253 A
  930. /*
  931. MACvPwrEvntDisable(dwIoBase);
  932. // clear power status
  933. VNSvOutPortW(dwIoBase + MAC_REG_WAKEUPSR0, 0x0F0F);
  934. */
  935. // do reset
  936. MACbSoftwareReset(dwIoBase);
  937. // issue AUTOLD in EECSR to reload eeprom
  938. //MACvRegBitsOn(dwIoBase, MAC_REG_I2MCSR, I2MCSR_AUTOLD);
  939. // wait until EEPROM loading complete
  940. //while (true) {
  941. // u8 u8Data;
  942. // VNSvInPortB(dwIoBase + MAC_REG_I2MCSR, &u8Data);
  943. // if ( !(u8Data & I2MCSR_AUTOLD))
  944. // break;
  945. //}
  946. // reset TSF counter
  947. VNSvOutPortB(dwIoBase + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
  948. // enable TSF counter
  949. VNSvOutPortB(dwIoBase + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
  950. // set packet filter
  951. // receive directed and broadcast address
  952. MACvSetPacketFilter(dwIoBase, PKT_TYPE_DIRECTED | PKT_TYPE_BROADCAST);
  953. }
  954. /*
  955. * Description:
  956. * Set the chip with current rx descriptor address
  957. *
  958. * Parameters:
  959. * In:
  960. * dwIoBase - Base Address for MAC
  961. * dwCurrDescAddr - Descriptor Address
  962. * Out:
  963. * none
  964. *
  965. * Return Value: none
  966. *
  967. */
  968. void MACvSetCurrRx0DescAddr (unsigned long dwIoBase, unsigned long dwCurrDescAddr)
  969. {
  970. unsigned short ww;
  971. unsigned char byData;
  972. unsigned char byOrgDMACtl;
  973. VNSvInPortB(dwIoBase + MAC_REG_RXDMACTL0, &byOrgDMACtl);
  974. if (byOrgDMACtl & DMACTL_RUN) {
  975. VNSvOutPortB(dwIoBase + MAC_REG_RXDMACTL0+2, DMACTL_RUN);
  976. }
  977. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  978. VNSvInPortB(dwIoBase + MAC_REG_RXDMACTL0, &byData);
  979. if ( !(byData & DMACTL_RUN))
  980. break;
  981. }
  982. if (ww == W_MAX_TIMEOUT) {
  983. DBG_PORT80(0x13);
  984. }
  985. VNSvOutPortD(dwIoBase + MAC_REG_RXDMAPTR0, dwCurrDescAddr);
  986. if (byOrgDMACtl & DMACTL_RUN) {
  987. VNSvOutPortB(dwIoBase + MAC_REG_RXDMACTL0, DMACTL_RUN);
  988. }
  989. }
  990. /*
  991. * Description:
  992. * Set the chip with current rx descriptor address
  993. *
  994. * Parameters:
  995. * In:
  996. * dwIoBase - Base Address for MAC
  997. * dwCurrDescAddr - Descriptor Address
  998. * Out:
  999. * none
  1000. *
  1001. * Return Value: none
  1002. *
  1003. */
  1004. void MACvSetCurrRx1DescAddr (unsigned long dwIoBase, unsigned long dwCurrDescAddr)
  1005. {
  1006. unsigned short ww;
  1007. unsigned char byData;
  1008. unsigned char byOrgDMACtl;
  1009. VNSvInPortB(dwIoBase + MAC_REG_RXDMACTL1, &byOrgDMACtl);
  1010. if (byOrgDMACtl & DMACTL_RUN) {
  1011. VNSvOutPortB(dwIoBase + MAC_REG_RXDMACTL1+2, DMACTL_RUN);
  1012. }
  1013. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  1014. VNSvInPortB(dwIoBase + MAC_REG_RXDMACTL1, &byData);
  1015. if ( !(byData & DMACTL_RUN))
  1016. break;
  1017. }
  1018. if (ww == W_MAX_TIMEOUT) {
  1019. DBG_PORT80(0x14);
  1020. }
  1021. VNSvOutPortD(dwIoBase + MAC_REG_RXDMAPTR1, dwCurrDescAddr);
  1022. if (byOrgDMACtl & DMACTL_RUN) {
  1023. VNSvOutPortB(dwIoBase + MAC_REG_RXDMACTL1, DMACTL_RUN);
  1024. }
  1025. }
  1026. /*
  1027. * Description:
  1028. * Set the chip with current tx0 descriptor address
  1029. *
  1030. * Parameters:
  1031. * In:
  1032. * dwIoBase - Base Address for MAC
  1033. * dwCurrDescAddr - Descriptor Address
  1034. * Out:
  1035. * none
  1036. *
  1037. * Return Value: none
  1038. *
  1039. */
  1040. void MACvSetCurrTx0DescAddrEx (unsigned long dwIoBase, unsigned long dwCurrDescAddr)
  1041. {
  1042. unsigned short ww;
  1043. unsigned char byData;
  1044. unsigned char byOrgDMACtl;
  1045. VNSvInPortB(dwIoBase + MAC_REG_TXDMACTL0, &byOrgDMACtl);
  1046. if (byOrgDMACtl & DMACTL_RUN) {
  1047. VNSvOutPortB(dwIoBase + MAC_REG_TXDMACTL0+2, DMACTL_RUN);
  1048. }
  1049. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  1050. VNSvInPortB(dwIoBase + MAC_REG_TXDMACTL0, &byData);
  1051. if ( !(byData & DMACTL_RUN))
  1052. break;
  1053. }
  1054. if (ww == W_MAX_TIMEOUT) {
  1055. DBG_PORT80(0x25);
  1056. }
  1057. VNSvOutPortD(dwIoBase + MAC_REG_TXDMAPTR0, dwCurrDescAddr);
  1058. if (byOrgDMACtl & DMACTL_RUN) {
  1059. VNSvOutPortB(dwIoBase + MAC_REG_TXDMACTL0, DMACTL_RUN);
  1060. }
  1061. }
  1062. /*
  1063. * Description:
  1064. * Set the chip with current AC0 descriptor address
  1065. *
  1066. * Parameters:
  1067. * In:
  1068. * dwIoBase - Base Address for MAC
  1069. * dwCurrDescAddr - Descriptor Address
  1070. * Out:
  1071. * none
  1072. *
  1073. * Return Value: none
  1074. *
  1075. */
  1076. //TxDMA1 = AC0DMA
  1077. void MACvSetCurrAC0DescAddrEx (unsigned long dwIoBase, unsigned long dwCurrDescAddr)
  1078. {
  1079. unsigned short ww;
  1080. unsigned char byData;
  1081. unsigned char byOrgDMACtl;
  1082. VNSvInPortB(dwIoBase + MAC_REG_AC0DMACTL, &byOrgDMACtl);
  1083. if (byOrgDMACtl & DMACTL_RUN) {
  1084. VNSvOutPortB(dwIoBase + MAC_REG_AC0DMACTL+2, DMACTL_RUN);
  1085. }
  1086. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  1087. VNSvInPortB(dwIoBase + MAC_REG_AC0DMACTL, &byData);
  1088. if (!(byData & DMACTL_RUN))
  1089. break;
  1090. }
  1091. if (ww == W_MAX_TIMEOUT) {
  1092. DBG_PORT80(0x26);
  1093. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x26)\n");
  1094. }
  1095. VNSvOutPortD(dwIoBase + MAC_REG_AC0DMAPTR, dwCurrDescAddr);
  1096. if (byOrgDMACtl & DMACTL_RUN) {
  1097. VNSvOutPortB(dwIoBase + MAC_REG_AC0DMACTL, DMACTL_RUN);
  1098. }
  1099. }
  1100. void MACvSetCurrTXDescAddr (int iTxType, unsigned long dwIoBase, unsigned long dwCurrDescAddr)
  1101. {
  1102. if(iTxType == TYPE_AC0DMA){
  1103. MACvSetCurrAC0DescAddrEx(dwIoBase, dwCurrDescAddr);
  1104. }else if(iTxType == TYPE_TXDMA0){
  1105. MACvSetCurrTx0DescAddrEx(dwIoBase, dwCurrDescAddr);
  1106. }
  1107. }
  1108. /*
  1109. * Description:
  1110. * Micro Second Delay via MAC
  1111. *
  1112. * Parameters:
  1113. * In:
  1114. * dwIoBase - Base Address for MAC
  1115. * uDelay - Delay time (timer resolution is 4 us)
  1116. * Out:
  1117. * none
  1118. *
  1119. * Return Value: none
  1120. *
  1121. */
  1122. void MACvTimer0MicroSDelay (unsigned long dwIoBase, unsigned int uDelay)
  1123. {
  1124. unsigned char byValue;
  1125. unsigned int uu,ii;
  1126. VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, 0);
  1127. VNSvOutPortD(dwIoBase + MAC_REG_TMDATA0, uDelay);
  1128. VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, (TMCTL_TMD | TMCTL_TE));
  1129. for(ii=0;ii<66;ii++) { // assume max PCI clock is 66Mhz
  1130. for (uu = 0; uu < uDelay; uu++) {
  1131. VNSvInPortB(dwIoBase + MAC_REG_TMCTL0, &byValue);
  1132. if ((byValue == 0) ||
  1133. (byValue & TMCTL_TSUSP)) {
  1134. VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, 0);
  1135. return;
  1136. }
  1137. }
  1138. }
  1139. VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, 0);
  1140. }
  1141. /*
  1142. * Description:
  1143. * Micro Second One shot timer via MAC
  1144. *
  1145. * Parameters:
  1146. * In:
  1147. * dwIoBase - Base Address for MAC
  1148. * uDelay - Delay time
  1149. * Out:
  1150. * none
  1151. *
  1152. * Return Value: none
  1153. *
  1154. */
  1155. void MACvOneShotTimer0MicroSec (unsigned long dwIoBase, unsigned int uDelayTime)
  1156. {
  1157. VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, 0);
  1158. VNSvOutPortD(dwIoBase + MAC_REG_TMDATA0, uDelayTime);
  1159. VNSvOutPortB(dwIoBase + MAC_REG_TMCTL0, (TMCTL_TMD | TMCTL_TE));
  1160. }
  1161. /*
  1162. * Description:
  1163. * Micro Second One shot timer via MAC
  1164. *
  1165. * Parameters:
  1166. * In:
  1167. * dwIoBase - Base Address for MAC
  1168. * uDelay - Delay time
  1169. * Out:
  1170. * none
  1171. *
  1172. * Return Value: none
  1173. *
  1174. */
  1175. void MACvOneShotTimer1MicroSec (unsigned long dwIoBase, unsigned int uDelayTime)
  1176. {
  1177. VNSvOutPortB(dwIoBase + MAC_REG_TMCTL1, 0);
  1178. VNSvOutPortD(dwIoBase + MAC_REG_TMDATA1, uDelayTime);
  1179. VNSvOutPortB(dwIoBase + MAC_REG_TMCTL1, (TMCTL_TMD | TMCTL_TE));
  1180. }
  1181. void MACvSetMISCFifo (unsigned long dwIoBase, unsigned short wOffset, unsigned long dwData)
  1182. {
  1183. if (wOffset > 273)
  1184. return;
  1185. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
  1186. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
  1187. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1188. }
  1189. bool MACbTxDMAOff (unsigned long dwIoBase, unsigned int idx)
  1190. {
  1191. unsigned char byData;
  1192. unsigned int ww = 0;
  1193. if (idx == TYPE_TXDMA0) {
  1194. VNSvOutPortB(dwIoBase + MAC_REG_TXDMACTL0+2, DMACTL_RUN);
  1195. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  1196. VNSvInPortB(dwIoBase + MAC_REG_TXDMACTL0, &byData);
  1197. if ( !(byData & DMACTL_RUN))
  1198. break;
  1199. }
  1200. } else if (idx == TYPE_AC0DMA) {
  1201. VNSvOutPortB(dwIoBase + MAC_REG_AC0DMACTL+2, DMACTL_RUN);
  1202. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  1203. VNSvInPortB(dwIoBase + MAC_REG_AC0DMACTL, &byData);
  1204. if ( !(byData & DMACTL_RUN))
  1205. break;
  1206. }
  1207. }
  1208. if (ww == W_MAX_TIMEOUT) {
  1209. DBG_PORT80(0x29);
  1210. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x29)\n");
  1211. return false;
  1212. }
  1213. return true;
  1214. }
  1215. void MACvClearBusSusInd (unsigned long dwIoBase)
  1216. {
  1217. unsigned long dwOrgValue;
  1218. unsigned int ww;
  1219. // check if BcnSusInd enabled
  1220. VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue);
  1221. if( !(dwOrgValue & EnCFG_BcnSusInd))
  1222. return;
  1223. //Set BcnSusClr
  1224. dwOrgValue = dwOrgValue | EnCFG_BcnSusClr;
  1225. VNSvOutPortD(dwIoBase + MAC_REG_ENCFG, dwOrgValue);
  1226. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  1227. VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue);
  1228. if( !(dwOrgValue & EnCFG_BcnSusInd))
  1229. break;
  1230. }
  1231. if (ww == W_MAX_TIMEOUT) {
  1232. DBG_PORT80(0x33);
  1233. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x33)\n");
  1234. }
  1235. }
  1236. void MACvEnableBusSusEn (unsigned long dwIoBase)
  1237. {
  1238. unsigned char byOrgValue;
  1239. unsigned long dwOrgValue;
  1240. unsigned int ww;
  1241. // check if BcnSusInd enabled
  1242. VNSvInPortB(dwIoBase + MAC_REG_CFG , &byOrgValue);
  1243. //Set BcnSusEn
  1244. byOrgValue = byOrgValue | CFG_BCNSUSEN;
  1245. VNSvOutPortB(dwIoBase + MAC_REG_ENCFG, byOrgValue);
  1246. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  1247. VNSvInPortD(dwIoBase + MAC_REG_ENCFG , &dwOrgValue);
  1248. if(dwOrgValue & EnCFG_BcnSusInd)
  1249. break;
  1250. }
  1251. if (ww == W_MAX_TIMEOUT) {
  1252. DBG_PORT80(0x34);
  1253. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x34)\n");
  1254. }
  1255. }
  1256. bool MACbFlushSYNCFifo (unsigned long dwIoBase)
  1257. {
  1258. unsigned char byOrgValue;
  1259. unsigned int ww;
  1260. // Read MACCR
  1261. VNSvInPortB(dwIoBase + MAC_REG_MACCR , &byOrgValue);
  1262. // Set SYNCFLUSH
  1263. byOrgValue = byOrgValue | MACCR_SYNCFLUSH;
  1264. VNSvOutPortB(dwIoBase + MAC_REG_MACCR, byOrgValue);
  1265. // Check if SyncFlushOK
  1266. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  1267. VNSvInPortB(dwIoBase + MAC_REG_MACCR , &byOrgValue);
  1268. if(byOrgValue & MACCR_SYNCFLUSHOK)
  1269. break;
  1270. }
  1271. if (ww == W_MAX_TIMEOUT) {
  1272. DBG_PORT80(0x35);
  1273. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x33)\n");
  1274. }
  1275. return true;
  1276. }
  1277. bool MACbPSWakeup (unsigned long dwIoBase)
  1278. {
  1279. unsigned char byOrgValue;
  1280. unsigned int ww;
  1281. // Read PSCTL
  1282. if (MACbIsRegBitsOff(dwIoBase, MAC_REG_PSCTL, PSCTL_PS)) {
  1283. return true;
  1284. }
  1285. // Disable PS
  1286. MACvRegBitsOff(dwIoBase, MAC_REG_PSCTL, PSCTL_PSEN);
  1287. // Check if SyncFlushOK
  1288. for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
  1289. VNSvInPortB(dwIoBase + MAC_REG_PSCTL , &byOrgValue);
  1290. if(byOrgValue & PSCTL_WAKEDONE)
  1291. break;
  1292. }
  1293. if (ww == W_MAX_TIMEOUT) {
  1294. DBG_PORT80(0x36);
  1295. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" DBG_PORT80(0x33)\n");
  1296. return false;
  1297. }
  1298. return true;
  1299. }
  1300. /*
  1301. * Description:
  1302. * Set the Key by MISCFIFO
  1303. *
  1304. * Parameters:
  1305. * In:
  1306. * dwIoBase - Base Address for MAC
  1307. *
  1308. * Out:
  1309. * none
  1310. *
  1311. * Return Value: none
  1312. *
  1313. */
  1314. void MACvSetKeyEntry (unsigned long dwIoBase, unsigned short wKeyCtl, unsigned int uEntryIdx,
  1315. unsigned int uKeyIdx, unsigned char *pbyAddr, unsigned long *pdwKey, unsigned char byLocalID)
  1316. {
  1317. unsigned short wOffset;
  1318. unsigned long dwData;
  1319. int ii;
  1320. if (byLocalID <= 1)
  1321. return;
  1322. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MACvSetKeyEntry\n");
  1323. wOffset = MISCFIFO_KEYETRY0;
  1324. wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
  1325. dwData = 0;
  1326. dwData |= wKeyCtl;
  1327. dwData <<= 16;
  1328. dwData |= MAKEWORD(*(pbyAddr+4), *(pbyAddr+5));
  1329. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"1. wOffset: %d, Data: %lX, KeyCtl:%X\n", wOffset, dwData, wKeyCtl);
  1330. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
  1331. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
  1332. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1333. wOffset++;
  1334. dwData = 0;
  1335. dwData |= *(pbyAddr+3);
  1336. dwData <<= 8;
  1337. dwData |= *(pbyAddr+2);
  1338. dwData <<= 8;
  1339. dwData |= *(pbyAddr+1);
  1340. dwData <<= 8;
  1341. dwData |= *(pbyAddr+0);
  1342. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"2. wOffset: %d, Data: %lX\n", wOffset, dwData);
  1343. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
  1344. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
  1345. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1346. wOffset++;
  1347. wOffset += (uKeyIdx * 4);
  1348. for (ii=0;ii<4;ii++) {
  1349. // alway push 128 bits
  1350. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"3.(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey);
  1351. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii);
  1352. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++);
  1353. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1354. }
  1355. }
  1356. /*
  1357. * Description:
  1358. * Disable the Key Entry by MISCFIFO
  1359. *
  1360. * Parameters:
  1361. * In:
  1362. * dwIoBase - Base Address for MAC
  1363. *
  1364. * Out:
  1365. * none
  1366. *
  1367. * Return Value: none
  1368. *
  1369. */
  1370. void MACvDisableKeyEntry (unsigned long dwIoBase, unsigned int uEntryIdx)
  1371. {
  1372. unsigned short wOffset;
  1373. wOffset = MISCFIFO_KEYETRY0;
  1374. wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
  1375. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
  1376. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, 0);
  1377. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1378. }
  1379. /*
  1380. * Description:
  1381. * Set the default Key (KeyEntry[10]) by MISCFIFO
  1382. *
  1383. * Parameters:
  1384. * In:
  1385. * dwIoBase - Base Address for MAC
  1386. *
  1387. * Out:
  1388. * none
  1389. *
  1390. * Return Value: none
  1391. *
  1392. */
  1393. void MACvSetDefaultKeyEntry (unsigned long dwIoBase, unsigned int uKeyLen,
  1394. unsigned int uKeyIdx, unsigned long *pdwKey, unsigned char byLocalID)
  1395. {
  1396. unsigned short wOffset;
  1397. unsigned long dwData;
  1398. int ii;
  1399. if (byLocalID <= 1)
  1400. return;
  1401. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MACvSetDefaultKeyEntry\n");
  1402. wOffset = MISCFIFO_KEYETRY0;
  1403. wOffset += (10 * MISCFIFO_KEYENTRYSIZE);
  1404. wOffset++;
  1405. wOffset++;
  1406. wOffset += (uKeyIdx * 4);
  1407. // alway push 128 bits
  1408. for (ii=0; ii<3; ii++) {
  1409. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey);
  1410. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii);
  1411. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++);
  1412. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1413. }
  1414. dwData = *pdwKey;
  1415. if (uKeyLen == WLAN_WEP104_KEYLEN) {
  1416. dwData |= 0x80000000;
  1417. }
  1418. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+3);
  1419. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
  1420. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1421. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"End. wOffset: %d, Data: %lX\n", wOffset+3, dwData);
  1422. }
  1423. /*
  1424. * Description:
  1425. * Enable default Key (KeyEntry[10]) by MISCFIFO
  1426. *
  1427. * Parameters:
  1428. * In:
  1429. * dwIoBase - Base Address for MAC
  1430. *
  1431. * Out:
  1432. * none
  1433. *
  1434. * Return Value: none
  1435. *
  1436. */
  1437. /*
  1438. void MACvEnableDefaultKey (unsigned long dwIoBase, unsigned char byLocalID)
  1439. {
  1440. unsigned short wOffset;
  1441. unsigned long dwData;
  1442. if (byLocalID <= 1)
  1443. return;
  1444. wOffset = MISCFIFO_KEYETRY0;
  1445. wOffset += (10 * MISCFIFO_KEYENTRYSIZE);
  1446. dwData = 0xC0440000;
  1447. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
  1448. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
  1449. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1450. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MACvEnableDefaultKey: wOffset: %d, Data: %lX\n", wOffset, dwData);
  1451. }
  1452. */
  1453. /*
  1454. * Description:
  1455. * Disable default Key (KeyEntry[10]) by MISCFIFO
  1456. *
  1457. * Parameters:
  1458. * In:
  1459. * dwIoBase - Base Address for MAC
  1460. *
  1461. * Out:
  1462. * none
  1463. *
  1464. * Return Value: none
  1465. *
  1466. */
  1467. void MACvDisableDefaultKey (unsigned long dwIoBase)
  1468. {
  1469. unsigned short wOffset;
  1470. unsigned long dwData;
  1471. wOffset = MISCFIFO_KEYETRY0;
  1472. wOffset += (10 * MISCFIFO_KEYENTRYSIZE);
  1473. dwData = 0x0;
  1474. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
  1475. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
  1476. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1477. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MACvDisableDefaultKey: wOffset: %d, Data: %lX\n", wOffset, dwData);
  1478. }
  1479. /*
  1480. * Description:
  1481. * Set the default TKIP Group Key (KeyEntry[10]) by MISCFIFO
  1482. *
  1483. * Parameters:
  1484. * In:
  1485. * dwIoBase - Base Address for MAC
  1486. *
  1487. * Out:
  1488. * none
  1489. *
  1490. * Return Value: none
  1491. *
  1492. */
  1493. void MACvSetDefaultTKIPKeyEntry (unsigned long dwIoBase, unsigned int uKeyLen,
  1494. unsigned int uKeyIdx, unsigned long *pdwKey, unsigned char byLocalID)
  1495. {
  1496. unsigned short wOffset;
  1497. unsigned long dwData;
  1498. int ii;
  1499. if (byLocalID <= 1)
  1500. return;
  1501. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MACvSetDefaultTKIPKeyEntry\n");
  1502. wOffset = MISCFIFO_KEYETRY0;
  1503. // Kyle test : change offset from 10 -> 0
  1504. wOffset += (10 * MISCFIFO_KEYENTRYSIZE);
  1505. dwData = 0xC0660000;
  1506. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
  1507. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
  1508. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1509. wOffset++;
  1510. dwData = 0;
  1511. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
  1512. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
  1513. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1514. wOffset++;
  1515. wOffset += (uKeyIdx * 4);
  1516. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"1. wOffset: %d, Data: %lX, idx:%d\n", wOffset, *pdwKey, uKeyIdx);
  1517. // alway push 128 bits
  1518. for (ii=0; ii<4; ii++) {
  1519. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"2.(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey);
  1520. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii);
  1521. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++);
  1522. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1523. }
  1524. }
  1525. /*
  1526. * Description:
  1527. * Set the Key Control by MISCFIFO
  1528. *
  1529. * Parameters:
  1530. * In:
  1531. * dwIoBase - Base Address for MAC
  1532. *
  1533. * Out:
  1534. * none
  1535. *
  1536. * Return Value: none
  1537. *
  1538. */
  1539. void MACvSetDefaultKeyCtl (unsigned long dwIoBase, unsigned short wKeyCtl, unsigned int uEntryIdx, unsigned char byLocalID)
  1540. {
  1541. unsigned short wOffset;
  1542. unsigned long dwData;
  1543. if (byLocalID <= 1)
  1544. return;
  1545. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MACvSetKeyEntry\n");
  1546. wOffset = MISCFIFO_KEYETRY0;
  1547. wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
  1548. dwData = 0;
  1549. dwData |= wKeyCtl;
  1550. dwData <<= 16;
  1551. dwData |= 0xffff;
  1552. DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"1. wOffset: %d, Data: %lX, KeyCtl:%X\n", wOffset, dwData, wKeyCtl);
  1553. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
  1554. VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
  1555. VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
  1556. }