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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
saa9730.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：29k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

saa9730.c：源码内容
  1. /*
  2.  * Carsten Langgaard, carstenl@mips.com
  3.  * Copyright (C) 2000 MIPS Technologies, Inc.  All rights reserved.
  4.  *
  5.  * ########################################################################
  6.  *
  7.  *  This program is free software; you can distribute it and/or modify it
  8.  *  under the terms of the GNU General Public License (Version 2) as
  9.  *  published by the Free Software Foundation.
  10.  *
  11.  *  This program is distributed in the hope it will be useful, but WITHOUT
  12.  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13.  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14.  *  for more details.
  15.  *
  16.  *  You should have received a copy of the GNU General Public License along
  17.  *  with this program; if not, write to the Free Software Foundation, Inc.,
  18.  *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
  19.  *
  20.  * ########################################################################
  21.  *
  22.  * SAA9730 ethernet driver.
  23.  *
  24.  */
  26. #include <linux/init.h>
  27. #include <linux/netdevice.h>
  28. #include <linux/delay.h>
  29. #include <linux/etherdevice.h>
  30. #include <linux/module.h>
  31. #include <linux/skbuff.h>
  32. #include <linux/pci.h>
  34. #include <asm/addrspace.h>
  35. #include <asm/mips-boards/prom.h>
  37. #include "saa9730.h"
  39. #ifdef LAN_SAA9730_DEBUG
  40. int lan_saa9730_debug = LAN_SAA9730_DEBUG;
  41. #else
  42. int lan_saa9730_debug;
  43. #endif
  46. /* Non-zero only if the current card is a PCI with BIOS-set IRQ. */
  47. static unsigned int pci_irq_line;
  49. #define INL(a)     inl((unsigned long)a)
  50. #define OUTL(x,a)  outl(x,(unsigned long)a)
  52. static void evm_saa9730_enable_lan_int(struct lan_saa9730_private *lp)
  53. {
  54. OUTL(INL(&lp->evm_saa9730_regs->InterruptBlock1) | EVM_LAN_INT,
  55.      &lp->evm_saa9730_regs->InterruptBlock1);
  56. OUTL(INL(&lp->evm_saa9730_regs->InterruptStatus1) | EVM_LAN_INT,
  57.      &lp->evm_saa9730_regs->InterruptStatus1);
  58. OUTL(INL(&lp->evm_saa9730_regs->InterruptEnable1) | EVM_LAN_INT |
  59.      EVM_MASTER_EN, &lp->evm_saa9730_regs->InterruptEnable1);
  60. }
  61. static void evm_saa9730_disable_lan_int(struct lan_saa9730_private *lp)
  62. {
  63. OUTL(INL(&lp->evm_saa9730_regs->InterruptBlock1) & ~EVM_LAN_INT,
  64.      &lp->evm_saa9730_regs->InterruptBlock1);
  65. OUTL(INL(&lp->evm_saa9730_regs->InterruptEnable1) & ~EVM_LAN_INT,
  66.      &lp->evm_saa9730_regs->InterruptEnable1);
  67. }
  69. static void evm_saa9730_clear_lan_int(struct lan_saa9730_private *lp)
  70. {
  71. OUTL(EVM_LAN_INT, &lp->evm_saa9730_regs->InterruptStatus1);
  72. }
  74. static void evm_saa9730_block_lan_int(struct lan_saa9730_private *lp)
  75. {
  76. OUTL(INL(&lp->evm_saa9730_regs->InterruptBlock1) & ~EVM_LAN_INT,
  77.      &lp->evm_saa9730_regs->InterruptBlock1);
  78. }
  80. static void evm_saa9730_unblock_lan_int(struct lan_saa9730_private *lp)
  81. {
  82. OUTL(INL(&lp->evm_saa9730_regs->InterruptBlock1) | EVM_LAN_INT,
  83.      &lp->evm_saa9730_regs->InterruptBlock1);
  84. }
  86. static void show_saa9730_regs(struct lan_saa9730_private *lp)
  87. {
  88. int i, j;
  89. printk("TxmBufferA = %xn", lp->TxmBuffer[0][0]);
  90. printk("TxmBufferB = %xn", lp->TxmBuffer[1][0]);
  91. printk("RcvBufferA = %xn", lp->RcvBuffer[0][0]);
  92. printk("RcvBufferB = %xn", lp->RcvBuffer[1][0]);
  93. for (i = 0; i < LAN_SAA9730_BUFFERS; i++) {
  94. for (j = 0; j < LAN_SAA9730_TXM_Q_SIZE; j++) {
  95. printk("TxmBuffer[%d][%d] = %xn", i, j,
  96.        le32_to_cpu(*(unsigned int *)
  97.    lp->TxmBuffer[i][j]));
  98. }
  99. }
  100. for (i = 0; i < LAN_SAA9730_BUFFERS; i++) {
  101. for (j = 0; j < LAN_SAA9730_RCV_Q_SIZE; j++) {
  102. printk("RcvBuffer[%d][%d] = %xn", i, j,
  103.        le32_to_cpu(*(unsigned int *)
  104.    lp->RcvBuffer[i][j]));
  105. }
  106. }
  107. printk("lp->evm_saa9730_regs->InterruptBlock1 = %xn",
  108.        INL(&lp->evm_saa9730_regs->InterruptBlock1));
  109. printk("lp->evm_saa9730_regs->InterruptStatus1 = %xn",
  110.        INL(&lp->evm_saa9730_regs->InterruptStatus1));
  111. printk("lp->evm_saa9730_regs->InterruptEnable1 = %xn",
  112.        INL(&lp->evm_saa9730_regs->InterruptEnable1));
  113. printk("lp->lan_saa9730_regs->Ok2Use = %xn",
  114.        INL(&lp->lan_saa9730_regs->Ok2Use));
  115. printk("lp->NextTxmBufferIndex = %xn", lp->NextTxmBufferIndex);
  116. printk("lp->NextTxmPacketIndex = %xn", lp->NextTxmPacketIndex);
  117. printk("lp->PendingTxmBufferIndex = %xn",
  118.        lp->PendingTxmBufferIndex);
  119. printk("lp->PendingTxmPacketIndex = %xn",
  120.        lp->PendingTxmPacketIndex);
  121. printk("lp->lan_saa9730_regs->LanDmaCtl = %xn",
  122.        INL(&lp->lan_saa9730_regs->LanDmaCtl));
  123. printk("lp->lan_saa9730_regs->DmaStatus = %xn",
  124.        INL(&lp->lan_saa9730_regs->DmaStatus));
  125. printk("lp->lan_saa9730_regs->CamCtl = %xn",
  126.        INL(&lp->lan_saa9730_regs->CamCtl));
  127. printk("lp->lan_saa9730_regs->TxCtl = %xn",
  128.        INL(&lp->lan_saa9730_regs->TxCtl));
  129. printk("lp->lan_saa9730_regs->TxStatus = %xn",
  130.        INL(&lp->lan_saa9730_regs->TxStatus));
  131. printk("lp->lan_saa9730_regs->RxCtl = %xn",
  132.        INL(&lp->lan_saa9730_regs->RxCtl));
  133. printk("lp->lan_saa9730_regs->RxStatus = %xn",
  134.        INL(&lp->lan_saa9730_regs->RxStatus));
  135. for (i = 0; i < LAN_SAA9730_CAM_DWORDS; i++) {
  136. OUTL(i, &lp->lan_saa9730_regs->CamAddress);
  137. printk("lp->lan_saa9730_regs->CamData = %xn",
  138.        INL(&lp->lan_saa9730_regs->CamData));
  139. }
  140. printk("lp->stats.tx_packets = %lxn", lp->stats.tx_packets);
  141. printk("lp->stats.tx_errors = %lxn", lp->stats.tx_errors);
  142. printk("lp->stats.tx_aborted_errors = %lxn",
  143.        lp->stats.tx_aborted_errors);
  144. printk("lp->stats.tx_window_errors = %lxn",
  145.        lp->stats.tx_window_errors);
  146. printk("lp->stats.tx_carrier_errors = %lxn",
  147.        lp->stats.tx_carrier_errors);
  148. printk("lp->stats.tx_fifo_errors = %lxn",
  149.        lp->stats.tx_fifo_errors);
  150. printk("lp->stats.tx_heartbeat_errors = %lxn",
  151.        lp->stats.tx_heartbeat_errors);
  152. printk("lp->stats.collisions = %lxn", lp->stats.collisions);
  154. printk("lp->stats.rx_packets = %lxn", lp->stats.rx_packets);
  155. printk("lp->stats.rx_errors = %lxn", lp->stats.rx_errors);
  156. printk("lp->stats.rx_dropped = %lxn", lp->stats.rx_dropped);
  157. printk("lp->stats.rx_crc_errors = %lxn", lp->stats.rx_crc_errors);
  158. printk("lp->stats.rx_frame_errors = %lxn",
  159.        lp->stats.rx_frame_errors);
  160. printk("lp->stats.rx_fifo_errors = %lxn",
  161.        lp->stats.rx_fifo_errors);
  162. printk("lp->stats.rx_length_errors = %lxn",
  163.        lp->stats.rx_length_errors);
  165. printk("lp->lan_saa9730_regs->DebugPCIMasterAddr = %xn",
  166.        INL(&lp->lan_saa9730_regs->DebugPCIMasterAddr));
  167. printk("lp->lan_saa9730_regs->DebugLanTxStateMachine = %xn",
  168.        INL(&lp->lan_saa9730_regs->DebugLanTxStateMachine));
  169. printk("lp->lan_saa9730_regs->DebugLanRxStateMachine = %xn",
  170.        INL(&lp->lan_saa9730_regs->DebugLanRxStateMachine));
  171. printk("lp->lan_saa9730_regs->DebugLanTxFifoPointers = %xn",
  172.        INL(&lp->lan_saa9730_regs->DebugLanTxFifoPointers));
  173. printk("lp->lan_saa9730_regs->DebugLanRxFifoPointers = %xn",
  174.        INL(&lp->lan_saa9730_regs->DebugLanRxFifoPointers));
  175. printk("lp->lan_saa9730_regs->DebugLanCtlStateMachine = %xn",
  176.        INL(&lp->lan_saa9730_regs->DebugLanCtlStateMachine));
  177. }
  179. static void lan_saa9730_buffer_init(struct lan_saa9730_private *lp)
  180. {
  181. int i, j;
  183. /* Init RX buffers */
  184. for (i = 0; i < LAN_SAA9730_BUFFERS; i++) {
  185. for (j = 0; j < LAN_SAA9730_RCV_Q_SIZE; j++) {
  186. *(unsigned int *) lp->RcvBuffer[i][j] =
  187.     cpu_to_le32(RXSF_READY <<
  188. RX_STAT_CTL_OWNER_SHF);
  189. }
  190. }
  192. /* Init TX buffers */
  193. for (i = 0; i < LAN_SAA9730_BUFFERS; i++) {
  194. for (j = 0; j < LAN_SAA9730_TXM_Q_SIZE; j++) {
  195. *(unsigned int *) lp->TxmBuffer[i][j] =
  196.     cpu_to_le32(TXSF_EMPTY <<
  197. TX_STAT_CTL_OWNER_SHF);
  198. }
  199. }
  200. }
  202. static int lan_saa9730_allocate_buffers(struct lan_saa9730_private *lp)
  203. {
  204. unsigned int mem_size;
  205. void *Pa;
  206. unsigned int i, j, RcvBufferSize, TxmBufferSize;
  207. unsigned int buffer_start;
  209. /* 
  210.  * Allocate all RX and TX packets in one chunk. 
  211.  * The Rx and Tx packets must be PACKET_SIZE aligned.
  212.  */
  213. mem_size = ((LAN_SAA9730_RCV_Q_SIZE + LAN_SAA9730_TXM_Q_SIZE) *
  214.     LAN_SAA9730_PACKET_SIZE * LAN_SAA9730_BUFFERS) +
  215.     LAN_SAA9730_PACKET_SIZE;
  216. buffer_start =
  217.     (unsigned int) kmalloc(mem_size, GFP_DMA | GFP_KERNEL);
  219. /* 
  220.  * Set DMA buffer to kseg1 (uncached).
  221.  * Make sure to flush before using it uncached.
  222.  */
  223. Pa = (void *) KSEG1ADDR((buffer_start + LAN_SAA9730_PACKET_SIZE) &
  224. ~(LAN_SAA9730_PACKET_SIZE - 1));
  225. dma_cache_wback_inv((unsigned long) Pa, mem_size);
  227. /* Initialize buffer space */
  228. RcvBufferSize = LAN_SAA9730_PACKET_SIZE;
  229. TxmBufferSize = LAN_SAA9730_PACKET_SIZE;
  230. lp->DmaRcvPackets = LAN_SAA9730_RCV_Q_SIZE;
  231. lp->DmaTxmPackets = LAN_SAA9730_TXM_Q_SIZE;
  233. /* Init RX buffers */
  234. for (i = 0; i < LAN_SAA9730_BUFFERS; i++) {
  235. for (j = 0; j < LAN_SAA9730_RCV_Q_SIZE; j++) {
  236. *(unsigned int *) Pa =
  237.     cpu_to_le32(RXSF_READY <<
  238. RX_STAT_CTL_OWNER_SHF);
  239. lp->RcvBuffer[i][j] = (unsigned int) Pa;
  240. Pa += RcvBufferSize;
  241. }
  242. }
  244. /* Init TX buffers */
  245. for (i = 0; i < LAN_SAA9730_BUFFERS; i++) {
  246. for (j = 0; j < LAN_SAA9730_TXM_Q_SIZE; j++) {
  247. *(unsigned int *) Pa =
  248.     cpu_to_le32(TXSF_EMPTY <<
  249. TX_STAT_CTL_OWNER_SHF);
  250. lp->TxmBuffer[i][j] = (unsigned int) Pa;
  251. Pa += TxmBufferSize;
  252. }
  253. }
  255. /* 
  256.  * Set rx buffer A and rx buffer B to point to the first two buffer 
  257.  * spaces.
  258.  */
  259. OUTL(PHYSADDR(lp->RcvBuffer[0][0]),
  260.      &lp->lan_saa9730_regs->RxBuffA);
  261. OUTL(PHYSADDR(lp->RcvBuffer[1][0]),
  262.      &lp->lan_saa9730_regs->RxBuffB);
  264. /* Initialize Buffer Index */
  265. lp->NextRcvPacketIndex = 0;
  266. lp->NextRcvToUseIsA = 1;
  268. /* Set current buffer index & next availble packet index */
  269. lp->NextTxmPacketIndex = 0;
  270. lp->NextTxmBufferIndex = 0;
  271. lp->PendingTxmPacketIndex = 0;
  272. lp->PendingTxmBufferIndex = 0;
  274. /* 
  275.  * Set txm_buf_a and txm_buf_b to point to the first two buffer
  276.  * space 
  277.  */
  278. OUTL(PHYSADDR(lp->TxmBuffer[0][0]),
  279.      &lp->lan_saa9730_regs->TxBuffA);
  280. OUTL(PHYSADDR(lp->TxmBuffer[1][0]),
  281.      &lp->lan_saa9730_regs->TxBuffB);
  283. /* Set packet number */
  284. OUTL((lp->DmaRcvPackets << PK_COUNT_RX_A_SHF) |
  285.      (lp->DmaRcvPackets << PK_COUNT_RX_B_SHF) |
  286.      (lp->DmaTxmPackets << PK_COUNT_TX_A_SHF) |
  287.      (lp->DmaTxmPackets << PK_COUNT_TX_B_SHF),
  288.      &lp->lan_saa9730_regs->PacketCount);
  290. return 0;
  291. }
  293. static int lan_saa9730_cam_load(struct lan_saa9730_private *lp)
  294. {
  295. unsigned int i;
  296. unsigned char *NetworkAddress;
  298. NetworkAddress = (unsigned char *) &lp->PhysicalAddress[0][0];
  300. for (i = 0; i < LAN_SAA9730_CAM_DWORDS; i++) {
  301. /* First set address to where data is written */
  302. OUTL(i, &lp->lan_saa9730_regs->CamAddress);
  303. OUTL((NetworkAddress[0] << 24) | (NetworkAddress[1] << 16)
  304.      | (NetworkAddress[2] << 8) | NetworkAddress[3],
  305.      &lp->lan_saa9730_regs->CamData);
  306. NetworkAddress += 4;
  307. }
  308. return 0;
  309. }
  311. static int lan_saa9730_cam_init(struct net_device *dev)
  312. {
  313. struct lan_saa9730_private *lp =
  314.     (struct lan_saa9730_private *) dev->priv;
  315. unsigned int i;
  317. /* Copy MAC-address into all entries. */
  318. for (i = 0; i < LAN_SAA9730_CAM_ENTRIES; i++) {
  319. memcpy((unsigned char *) lp->PhysicalAddress[i],
  320.        (unsigned char *) dev->dev_addr, 6);
  321. }
  323. return 0;
  324. }
  326. static int lan_saa9730_mii_init(struct lan_saa9730_private *lp)
  327. {
  328. int i, l;
  330. /* Check link status, spin here till station is not busy. */
  331. i = 0;
  332. while (INL(&lp->lan_saa9730_regs->StationMgmtCtl) & MD_CA_BUSY) {
  333. i++;
  334. if (i > 100) {
  335. printk("Error: lan_saa9730_mii_init: timeoutn");
  336. return -1;
  337. }
  338. mdelay(1); /* wait 1 ms. */
  339. }
  341. /* Now set the control and address register. */
  342. OUTL(MD_CA_BUSY | PHY_STATUS | PHY_ADDRESS << MD_CA_PHY_SHF,
  343.      &lp->lan_saa9730_regs->StationMgmtCtl);
  345. /* check link status, spin here till station is not busy */
  346. i = 0;
  347. while (INL(&lp->lan_saa9730_regs->StationMgmtCtl) & MD_CA_BUSY) {
  348. i++;
  349. if (i > 100) {
  350. printk("Error: lan_saa9730_mii_init: timeoutn");
  351. return -1;
  352. }
  353. mdelay(1); /* wait 1 ms. */
  354. }
  356. /* Wait for 1 ms. */
  357. mdelay(1);
  359. /* Check the link status. */
  360. if (INL(&lp->lan_saa9730_regs->StationMgmtData) &
  361.     PHY_STATUS_LINK_UP) {
  362. /* Link is up. */
  363. return 0;
  364. } else {
  365. /* Link is down, reset the PHY first. */
  367. /* set PHY address = 'CONTROL' */
  368. OUTL(PHY_ADDRESS << MD_CA_PHY_SHF | MD_CA_WR | PHY_CONTROL,
  369.      &lp->lan_saa9730_regs->StationMgmtCtl);
  371. /* Wait for 1 ms. */
  372. mdelay(1);
  374. /* set 'CONTROL' = force reset and renegotiate */
  375. OUTL(PHY_CONTROL_RESET | PHY_CONTROL_AUTO_NEG |
  376.      PHY_CONTROL_RESTART_AUTO_NEG,
  377.      &lp->lan_saa9730_regs->StationMgmtData);
  379. /* Wait for 50 ms. */
  380. mdelay(50);
  382. /* set 'BUSY' to start operation */
  383. OUTL(MD_CA_BUSY | PHY_ADDRESS << MD_CA_PHY_SHF | MD_CA_WR |
  384.      PHY_CONTROL, &lp->lan_saa9730_regs->StationMgmtCtl);
  386. /* await completion */
  387. i = 0;
  388. while (INL(&lp->lan_saa9730_regs->StationMgmtCtl) &
  389.        MD_CA_BUSY) {
  390. i++;
  391. if (i > 100) {
  392. printk
  393.     ("Error: lan_saa9730_mii_init: timeoutn");
  394. return -1;
  395. }
  396. mdelay(1); /* wait 1 ms. */
  397. }
  399. /* Wait for 1 ms. */
  400. mdelay(1);
  402. for (l = 0; l < 2; l++) {
  403. /* set PHY address = 'STATUS' */
  404. OUTL(MD_CA_BUSY | PHY_ADDRESS << MD_CA_PHY_SHF |
  405.      PHY_STATUS,
  406.      &lp->lan_saa9730_regs->StationMgmtCtl);
  408. /* await completion */
  409. i = 0;
  410. while (INL(&lp->lan_saa9730_regs->StationMgmtCtl) &
  411.        MD_CA_BUSY) {
  412. i++;
  413. if (i > 100) {
  414. printk
  415.     ("Error: lan_saa9730_mii_init: timeoutn");
  416. return -1;
  417. }
  418. mdelay(1); /* wait 1 ms. */
  419. }
  421. /* wait for 3 sec. */
  422. mdelay(3000);
  424. /* check the link status */
  425. if (INL(&lp->lan_saa9730_regs->StationMgmtData) &
  426.     PHY_STATUS_LINK_UP) {
  427. /* link is up */
  428. break;
  429. }
  430. }
  431. }
  433. return 0;
  434. }
  436. static int lan_saa9730_control_init(struct lan_saa9730_private *lp)
  437. {
  438. /* Initialize DMA control register. */
  439. OUTL((LANMB_ANY << DMA_CTL_MAX_XFER_SHF) |
  440.      (LANEND_LITTLE << DMA_CTL_ENDIAN_SHF) |
  441.      (LAN_SAA9730_RCV_Q_INT_THRESHOLD << DMA_CTL_RX_INT_COUNT_SHF)
  442.      | DMA_CTL_RX_INT_TO_EN | DMA_CTL_RX_INT_EN |
  443.      DMA_CTL_MAC_RX_INT_EN | DMA_CTL_MAC_TX_INT_EN,
  444.      &lp->lan_saa9730_regs->LanDmaCtl);
  446. /* Initial MAC control register. */
  447. OUTL((MACCM_MII << MAC_CONTROL_CONN_SHF) | MAC_CONTROL_FULL_DUP,
  448.      &lp->lan_saa9730_regs->MacCtl);
  450. /* Initialize CAM control register. */
  451. OUTL(CAM_CONTROL_COMP_EN | CAM_CONTROL_BROAD_ACC,
  452.      &lp->lan_saa9730_regs->CamCtl);
  454. /* 
  455.  * Initialize CAM enable register, only turn on first entry, should
  456.  * contain own addr. 
  457.  */
  458. OUTL(0x0001, &lp->lan_saa9730_regs->CamEnable);
  460. /* Initialize Tx control register */
  461. OUTL(TX_CTL_EN_COMP, &lp->lan_saa9730_regs->TxCtl);
  463. /* Initialize Rcv control register */
  464. OUTL(RX_CTL_STRIP_CRC, &lp->lan_saa9730_regs->RxCtl);
  466. /* Reset DMA engine */
  467. OUTL(DMA_TEST_SW_RESET, &lp->lan_saa9730_regs->DmaTest);
  469. return 0;
  470. }
  472. static int lan_saa9730_stop(struct lan_saa9730_private *lp)
  473. {
  474. int i;
  476. /* Stop DMA first */
  477. OUTL(INL(&lp->lan_saa9730_regs->LanDmaCtl) &
  478.      ~(DMA_CTL_EN_TX_DMA | DMA_CTL_EN_RX_DMA),
  479.      &lp->lan_saa9730_regs->LanDmaCtl);
  481. /* Set the SW Reset bits in DMA and MAC control registers */
  482. OUTL(DMA_TEST_SW_RESET, &lp->lan_saa9730_regs->DmaTest);
  483. OUTL(INL(&lp->lan_saa9730_regs->MacCtl) | MAC_CONTROL_RESET,
  484.      &lp->lan_saa9730_regs->MacCtl);
  486. /* 
  487.  * Wait for MAC reset to have finished. The reset bit is auto cleared
  488.  * when the reset is done.
  489.  */
  490. i = 0;
  491. while (INL(&lp->lan_saa9730_regs->MacCtl) & MAC_CONTROL_RESET) {
  492. i++;
  493. if (i > 100) {
  494. printk
  495.     ("Error: lan_sa9730_stop: MAC reset timeoutn");
  496. return -1;
  497. }
  498. mdelay(1); /* wait 1 ms. */
  499. }
  501. return 0;
  502. }
  504. static int lan_saa9730_dma_init(struct lan_saa9730_private *lp)
  505. {
  506. /* Stop lan controller. */
  507. lan_saa9730_stop(lp);
  509. OUTL(LAN_SAA9730_DEFAULT_TIME_OUT_CNT,
  510.      &lp->lan_saa9730_regs->Timeout);
  512. return 0;
  513. }
  515. static int lan_saa9730_start(struct lan_saa9730_private *lp)
  516. {
  517. lan_saa9730_buffer_init(lp);
  519. /* Initialize Rx Buffer Index */
  520. lp->NextRcvPacketIndex = 0;
  521. lp->NextRcvToUseIsA = 1;
  523. /* Set current buffer index & next availble packet index */
  524. lp->NextTxmPacketIndex = 0;
  525. lp->NextTxmBufferIndex = 0;
  526. lp->PendingTxmPacketIndex = 0;
  527. lp->PendingTxmBufferIndex = 0;
  529. OUTL(INL(&lp->lan_saa9730_regs->LanDmaCtl) | DMA_CTL_EN_TX_DMA |
  530.      DMA_CTL_EN_RX_DMA, &lp->lan_saa9730_regs->LanDmaCtl);
  532. /* For Tx, turn on MAC then DMA */
  533. OUTL(INL(&lp->lan_saa9730_regs->TxCtl) | TX_CTL_TX_EN,
  534.      &lp->lan_saa9730_regs->TxCtl);
  536. /* For Rx, turn on DMA then MAC */
  537. OUTL(INL(&lp->lan_saa9730_regs->RxCtl) | RX_CTL_RX_EN,
  538.      &lp->lan_saa9730_regs->RxCtl);
  540. /* Set Ok2Use to let hardware owns the buffers */
  541. OUTL(OK2USE_RX_A | OK2USE_RX_B | OK2USE_TX_A | OK2USE_TX_B,
  542.      &lp->lan_saa9730_regs->Ok2Use);
  544. return 0;
  545. }
  547. static int lan_saa9730_restart(struct lan_saa9730_private *lp)
  548. {
  549. lan_saa9730_stop(lp);
  550. lan_saa9730_start(lp);
  552. return 0;
  553. }
  555. static int lan_saa9730_tx(struct net_device *dev)
  556. {
  557. struct lan_saa9730_private *lp =
  558.     (struct lan_saa9730_private *) dev->priv;
  559. unsigned int *pPacket;
  560. unsigned int tx_status;
  562. if (lan_saa9730_debug > 5)
  563. printk("lan_saa9730_tx interruptn");
  565. /* Clear interrupt. */
  566. OUTL(DMA_STATUS_MAC_TX_INT, &lp->lan_saa9730_regs->DmaStatus);
  568. while (1) {
  569. pPacket =
  570.     (unsigned int *) lp->TxmBuffer[lp->
  571.    PendingTxmBufferIndex]
  572.     [lp->PendingTxmPacketIndex];
  574. /* Get status of first packet transmitted. */
  575. tx_status = le32_to_cpu(*pPacket);
  577. /* Check ownership. */
  578. if ((tx_status & TX_STAT_CTL_OWNER_MSK) !=
  579.     (TXSF_HWDONE << TX_STAT_CTL_OWNER_SHF)) break;
  581. /* Check for error. */
  582. if (tx_status & TX_STAT_CTL_ERROR_MSK) {
  583. if (lan_saa9730_debug > 1)
  584. printk("lan_saa9730_tx: tx error = %xn",
  585.        tx_status);
  587. lp->stats.tx_errors++;
  588. if (tx_status &
  589.     (TX_STATUS_EX_COLL << TX_STAT_CTL_STATUS_SHF))
  590.     lp->stats.tx_aborted_errors++;
  591. if (tx_status &
  592.     (TX_STATUS_LATE_COLL <<
  593.      TX_STAT_CTL_STATUS_SHF)) lp->stats.
  594.      tx_window_errors++;
  595. if (tx_status &
  596.     (TX_STATUS_L_CARR << TX_STAT_CTL_STATUS_SHF))
  597.     lp->stats.tx_carrier_errors++;
  598. if (tx_status &
  599.     (TX_STATUS_UNDER << TX_STAT_CTL_STATUS_SHF))
  600.     lp->stats.tx_fifo_errors++;
  601. if (tx_status &
  602.     (TX_STATUS_SQ_ERR << TX_STAT_CTL_STATUS_SHF))
  603.     lp->stats.tx_heartbeat_errors++;
  605. lp->stats.collisions +=
  606.     tx_status & TX_STATUS_TX_COLL_MSK;
  607. }
  609. /* Free buffer. */
  610. *pPacket =
  611.     cpu_to_le32(TXSF_EMPTY << TX_STAT_CTL_OWNER_SHF);
  613. /* Update pending index pointer. */
  614. lp->PendingTxmPacketIndex++;
  615. if (lp->PendingTxmPacketIndex >= LAN_SAA9730_TXM_Q_SIZE) {
  616. lp->PendingTxmPacketIndex = 0;
  617. lp->PendingTxmBufferIndex ^= 1;
  618. }
  619. }
  621. /* Make sure A and B are available to hardware. */
  622. OUTL(OK2USE_TX_A | OK2USE_TX_B, &lp->lan_saa9730_regs->Ok2Use);
  624. if (netif_queue_stopped(dev)) {
  625. /* The tx buffer is no longer full. */
  626. netif_wake_queue(dev);
  627. }
  629. return 0;
  630. }
  632. static int lan_saa9730_rx(struct net_device *dev)
  633. {
  634. struct lan_saa9730_private *lp =
  635.     (struct lan_saa9730_private *) dev->priv;
  636. int len = 0;
  637. struct sk_buff *skb = 0;
  638. unsigned int rx_status;
  639. int BufferIndex;
  640. int PacketIndex;
  641. unsigned int *pPacket;
  642. unsigned char *pData;
  644. if (lan_saa9730_debug > 5)
  645. printk("lan_saa9730_rx interruptn");
  647. /* Clear receive interrupts. */
  648. OUTL(DMA_STATUS_MAC_RX_INT | DMA_STATUS_RX_INT |
  649.      DMA_STATUS_RX_TO_INT, &lp->lan_saa9730_regs->DmaStatus);
  651. /* Address next packet */
  652. if (lp->NextRcvToUseIsA)
  653. BufferIndex = 0;
  654. else
  655. BufferIndex = 1;
  656. PacketIndex = lp->NextRcvPacketIndex;
  657. pPacket = (unsigned int *) lp->RcvBuffer[BufferIndex][PacketIndex];
  658. rx_status = le32_to_cpu(*pPacket);
  660. /* Process each packet. */
  661. while ((rx_status & RX_STAT_CTL_OWNER_MSK) ==
  662.        (RXSF_HWDONE << RX_STAT_CTL_OWNER_SHF)) {
  663. /* Check the rx status. */
  664. if (rx_status & (RX_STATUS_GOOD << RX_STAT_CTL_STATUS_SHF)) {
  665. /* Received packet is good. */
  666. len = (rx_status & RX_STAT_CTL_LENGTH_MSK) >>
  667.     RX_STAT_CTL_LENGTH_SHF;
  669. pData = (unsigned char *) pPacket;
  670. pData += 4;
  671. skb = dev_alloc_skb(len + 2);
  672. if (skb == 0) {
  673. printk
  674.     ("%s: Memory squeeze, deferring packet.n",
  675.      dev->name);
  676. lp->stats.rx_dropped++;
  677. } else {
  678. lp->stats.rx_bytes += len;
  679. lp->stats.rx_packets++;
  680. skb->dev = dev;
  681. skb_reserve(skb, 2); /* 16 byte align */
  682. skb_put(skb, len); /* make room */
  683. eth_copy_and_sum(skb,
  684.  (unsigned char *) pData,
  685.  len, 0);
  686. skb->protocol = eth_type_trans(skb, dev);
  687. netif_rx(skb);
  688. }
  689. } else {
  690. /* We got an error packet. */
  691. if (lan_saa9730_debug > 2)
  692. printk
  693.     ("lan_saa9730_rx: We got an error packet = %xn",
  694.      rx_status);
  696. lp->stats.rx_errors++;
  697. if (rx_status &
  698.     (RX_STATUS_CRC_ERR << RX_STAT_CTL_STATUS_SHF))
  699.     lp->stats.rx_crc_errors++;
  700. if (rx_status &
  701.     (RX_STATUS_ALIGN_ERR <<
  702.      RX_STAT_CTL_STATUS_SHF)) lp->stats.
  703.      rx_frame_errors++;
  704. if (rx_status &
  705.     (RX_STATUS_OVERFLOW << RX_STAT_CTL_STATUS_SHF))
  706.     lp->stats.rx_fifo_errors++;
  707. if (rx_status &
  708.     (RX_STATUS_LONG_ERR << RX_STAT_CTL_STATUS_SHF))
  709.     lp->stats.rx_length_errors++;
  710. }
  712. /* Indicate we have processed the buffer. */
  713. *pPacket =
  714.     cpu_to_le32(RXSF_READY << RX_STAT_CTL_OWNER_SHF);
  716. /* Go to next packet in sequence. */
  717. lp->NextRcvPacketIndex++;
  718. if (lp->NextRcvPacketIndex >= LAN_SAA9730_RCV_Q_SIZE) {
  719. lp->NextRcvPacketIndex = 0;
  720. if (BufferIndex) {
  721. lp->NextRcvToUseIsA = 1;
  722. } else {
  723. lp->NextRcvToUseIsA = 0;
  724. }
  725. }
  726. OUTL(OK2USE_RX_A | OK2USE_RX_B,
  727.      &lp->lan_saa9730_regs->Ok2Use);
  729. /* Address next packet */
  730. if (lp->NextRcvToUseIsA)
  731. BufferIndex = 0;
  732. else
  733. BufferIndex = 1;
  734. PacketIndex = lp->NextRcvPacketIndex;
  735. pPacket =
  736.     (unsigned int *) lp->
  737.     RcvBuffer[BufferIndex][PacketIndex];
  738. rx_status = le32_to_cpu(*pPacket);
  739. }
  741. /* Make sure A and B are available to hardware. */
  742. OUTL(OK2USE_RX_A | OK2USE_RX_B, &lp->lan_saa9730_regs->Ok2Use);
  744. return 0;
  745. }
  747. static void lan_saa9730_interrupt(const int irq, void *dev_id,
  748.   struct pt_regs *regs)
  749. {
  750. struct net_device *dev = (struct net_device *) dev_id;
  751. struct lan_saa9730_private *lp =
  752.     (struct lan_saa9730_private *) dev->priv;
  754. if (lan_saa9730_debug > 5)
  755. printk("lan_saa9730_interruptn");
  757. /* Disable the EVM LAN interrupt. */
  758. evm_saa9730_block_lan_int(lp);
  760. /* Clear the EVM LAN interrupt. */
  761. evm_saa9730_clear_lan_int(lp);
  763. /* Service pending transmit interrupts. */
  764. if (INL(&lp->lan_saa9730_regs->DmaStatus) & DMA_STATUS_MAC_TX_INT)
  765. lan_saa9730_tx(dev);
  767. /* Service pending receive interrupts. */
  768. if (INL(&lp->lan_saa9730_regs->DmaStatus) &
  769.     (DMA_STATUS_MAC_RX_INT | DMA_STATUS_RX_INT |
  770.      DMA_STATUS_RX_TO_INT)) lan_saa9730_rx(dev);
  772. /* Enable the EVM LAN interrupt. */
  773. evm_saa9730_unblock_lan_int(lp);
  775. return;
  776. }
  778. static int lan_saa9730_open_fail(struct net_device *dev)
  779. {
  780. return -ENODEV;
  781. }
  783. static int lan_saa9730_open(struct net_device *dev)
  784. {
  785. struct lan_saa9730_private *lp =
  786.     (struct lan_saa9730_private *) dev->priv;
  788. /* Associate IRQ with lan_saa9730_interrupt */
  789. if (request_irq(dev->irq, &lan_saa9730_interrupt, 0, "SAA9730 Eth",
  790. dev)) {
  791. printk("lan_saa9730_open: Can't get irq %dn", dev->irq);
  792. return -EAGAIN;
  793. }
  795. /* Enable the Lan interrupt in the event manager. */
  796. evm_saa9730_enable_lan_int(lp);
  798. /* Start the LAN controller */
  799. if (lan_saa9730_start(lp))
  800. return -1;
  802. netif_start_queue(dev);
  804. return 0;
  805. }
  807. static int lan_saa9730_write(struct lan_saa9730_private *lp,
  808.      struct sk_buff *skb, int skblen)
  809. {
  810. unsigned char *pbData = skb->data;
  811. unsigned int len = skblen;
  812. unsigned char *pbPacketData;
  813. unsigned int tx_status;
  814. int BufferIndex;
  815. int PacketIndex;
  817. if (lan_saa9730_debug > 5)
  818. printk("lan_saa9730_write: skb=%08xn",
  819.        (unsigned int) skb);
  821. BufferIndex = lp->NextTxmBufferIndex;
  822. PacketIndex = lp->NextTxmPacketIndex;
  824. tx_status =
  825.     le32_to_cpu(*(unsigned int *) lp->
  826. TxmBuffer[BufferIndex][PacketIndex]);
  827. if ((tx_status & TX_STAT_CTL_OWNER_MSK) !=
  828.     (TXSF_EMPTY << TX_STAT_CTL_OWNER_SHF)) {
  829. if (lan_saa9730_debug > 4)
  830. printk
  831.     ("lan_saa9730_write: Tx buffer not available: tx_status = %xn",
  832.      tx_status);
  833. return -1;
  834. }
  836. lp->NextTxmPacketIndex++;
  837. if (lp->NextTxmPacketIndex >= LAN_SAA9730_TXM_Q_SIZE) {
  838. lp->NextTxmPacketIndex = 0;
  839. lp->NextTxmBufferIndex ^= 1;
  840. }
  842. pbPacketData =
  843.     (unsigned char *) lp->TxmBuffer[BufferIndex][PacketIndex];
  844. pbPacketData += 4;
  846. /* copy the bits */
  847. memcpy(pbPacketData, pbData, len);
  849. /* Set transmit status for hardware */
  850. *(unsigned int *) lp->TxmBuffer[BufferIndex][PacketIndex] =
  851.     cpu_to_le32((TXSF_READY << TX_STAT_CTL_OWNER_SHF) |
  852. (TX_STAT_CTL_INT_AFTER_TX << TX_STAT_CTL_FRAME_SHF)
  853. | (len << TX_STAT_CTL_LENGTH_SHF));
  855. /* Set hardware tx buffer. */
  856. OUTL(OK2USE_TX_A | OK2USE_TX_B, &lp->lan_saa9730_regs->Ok2Use);
  858. return 0;
  859. }
  861. static void lan_saa9730_tx_timeout(struct net_device *dev)
  862. {
  863. struct lan_saa9730_private *lp =
  864.     (struct lan_saa9730_private *) dev->priv;
  866. /* Transmitter timeout, serious problems */
  867. lp->stats.tx_errors++;
  868. printk("%s: transmit timed out, resetn", dev->name);
  869. /*show_saa9730_regs(lp); */
  870. lan_saa9730_restart(lp);
  872. dev->trans_start = jiffies;
  873. netif_start_queue(dev);
  874. }
  876. static int lan_saa9730_start_xmit(struct sk_buff *skb,
  877.   struct net_device *dev)
  878. {
  879. struct lan_saa9730_private *lp =
  880.     (struct lan_saa9730_private *) dev->priv;
  881. unsigned long flags;
  882. int skblen;
  883. int len;
  885. if (lan_saa9730_debug > 4)
  886. printk("Send packet: skb=%08xn", (unsigned int) skb);
  888. skblen = skb->len;
  889. save_and_cli(flags);
  890. len = (skblen <= ETH_ZLEN) ? ETH_ZLEN : skblen;
  892. if (lan_saa9730_write(lp, skb, skblen)) {
  893. restore_flags(flags);
  894. printk
  895.     ("Error when writing packet to controller: skb=%08xn",
  896.      (unsigned int) skb);
  897. netif_stop_queue(dev);
  898. return -1;
  899. }
  901. lp->stats.tx_bytes += len;
  902. lp->stats.tx_packets++;
  904. dev->trans_start = jiffies;
  905. netif_start_queue(dev);
  906. dev_kfree_skb(skb);
  908. restore_flags(flags);
  910. return 0;
  911. }
  913. static int lan_saa9730_close(struct net_device *dev)
  914. {
  915. struct lan_saa9730_private *lp =
  916.     (struct lan_saa9730_private *) dev->priv;
  918. if (lan_saa9730_debug > 1)
  919. printk("lan_saa9730_close:n");
  921. netif_stop_queue(dev);
  923. /* Disable the Lan interrupt in the event manager. */
  924. evm_saa9730_disable_lan_int(lp);
  926. /* Stop the controller */
  927. if (lan_saa9730_stop(lp))
  928. return -1;
  930. free_irq(dev->irq, (void *) dev);
  932. return 0;
  933. }
  935. static struct net_device_stats *lan_saa9730_get_stats(struct net_device
  936.       *dev)
  937. {
  938. struct lan_saa9730_private *lp =
  939.     (struct lan_saa9730_private *) dev->priv;
  941. return &lp->stats;
  942. }
  944. static void lan_saa9730_set_multicast(struct net_device *dev)
  945. {
  946. struct lan_saa9730_private *lp =
  947.     (struct lan_saa9730_private *) dev->priv;
  949. /* Stop the controller */
  950. lan_saa9730_stop(lp);
  952. if (dev->flags & IFF_PROMISC) {
  953. /* accept all packets */
  954. OUTL(CAM_CONTROL_COMP_EN | CAM_CONTROL_STATION_ACC |
  955.      CAM_CONTROL_GROUP_ACC | CAM_CONTROL_BROAD_ACC,
  956.      &lp->lan_saa9730_regs->CamCtl);
  957. } else {
  958. if (dev->flags & IFF_ALLMULTI) {
  959. /* accept all multicast packets */
  960. OUTL(CAM_CONTROL_COMP_EN | CAM_CONTROL_GROUP_ACC |
  961.      CAM_CONTROL_BROAD_ACC,
  962.      &lp->lan_saa9730_regs->CamCtl);
  963. } else {
  964. /* 
  965.  * Will handle the multicast stuff later. -carstenl
  966.  */
  967. }
  968. }
  970. lan_saa9730_restart(lp);
  971. }
  973. static int lan_saa9730_init(struct net_device *dev, int ioaddr, int irq)
  974. {
  975. struct lan_saa9730_private *lp;
  976. unsigned char ethernet_addr[6];
  978. dev = init_etherdev(dev, 0);
  980. dev->open = lan_saa9730_open_fail;
  981. if (get_ethernet_addr(ethernet_addr))
  982. return -1;
  984. memcpy(dev->dev_addr, ethernet_addr, 6);
  985. dev->base_addr = ioaddr;
  986. dev->irq = irq;
  988. /* 
  989.  * Make certain the data structures used by the controller are aligned 
  990.  * and DMAble. 
  991.  */
  992. lp = (struct lan_saa9730_private *) (((unsigned long)
  993.       kmalloc(sizeof(*lp) + 7,
  994.       GFP_DMA | GFP_KERNEL)
  995.       + 7) & ~7);
  997. dev->priv = lp;
  998. memset(lp, 0, sizeof(*lp));
  1000. /* Set SAA9730 LAN base address. */
  1001. lp->lan_saa9730_regs = (t_lan_saa9730_regmap *) (ioaddr +
  1002.  SAA9730_LAN_REGS_ADDR);
  1004. /* Set SAA9730 EVM base address. */
  1005. lp->evm_saa9730_regs = (t_evm_saa9730_regmap *) (ioaddr +
  1006.  SAA9730_EVM_REGS_ADDR);
  1008. /* Allocate LAN RX/TX frame buffer space. */
  1009. if (lan_saa9730_allocate_buffers(lp))
  1010. return -1;
  1012. /* Stop LAN controller. */
  1013. if (lan_saa9730_stop(lp))
  1014. return -1;
  1016. /* Initialize CAM registers. */
  1017. if (lan_saa9730_cam_init(dev))
  1018. return -1;
  1020. /* Initialize MII registers. */
  1021. if (lan_saa9730_mii_init(lp))
  1022. return -1;
  1024. /* Initialize control registers. */
  1025. if (lan_saa9730_control_init(lp))
  1026. return -1;
  1028. /* Load CAM registers. */
  1029. if (lan_saa9730_cam_load(lp))
  1030. return -1;
  1032. /* Initialize DMA context registers. */
  1033. if (lan_saa9730_dma_init(lp))
  1034. return -1;
  1036. dev->open = lan_saa9730_open;
  1037. dev->hard_start_xmit = lan_saa9730_start_xmit;
  1038. dev->stop = lan_saa9730_close;
  1039. dev->get_stats = lan_saa9730_get_stats;
  1040. dev->set_multicast_list = lan_saa9730_set_multicast;
  1041. dev->tx_timeout = lan_saa9730_tx_timeout;
  1042. dev->watchdog_timeo = (HZ >> 1);
  1043. dev->dma = 0;
  1045. return 0;
  1046. }
  1049. static int __init saa9730_probe(void)
  1050. {
  1051. struct net_device *dev = NULL;
  1053. if (pci_present()) {
  1054. struct pci_dev *pdev = NULL;
  1055. if (lan_saa9730_debug > 1)
  1056. printk
  1057.     ("saa9730.c: PCI bios is present, checking for devices...n");
  1059. while ((pdev = pci_find_device(PCI_VENDOR_ID_PHILIPS,
  1060.        PCI_DEVICE_ID_PHILIPS_SAA9730,
  1061.        pdev))) {
  1062. unsigned int pci_ioaddr;
  1064. pci_irq_line = pdev->irq;
  1065. /* LAN base address in located at BAR 1. */
  1067. pci_ioaddr = pci_resource_start(pdev, 1);
  1068. pci_set_master(pdev);
  1070. printk("Found SAA9730 (PCI) at %#x, irq %d.n",
  1071.        pci_ioaddr, pci_irq_line);
  1072. if (!lan_saa9730_init
  1073.     (dev, pci_ioaddr, pci_irq_line)) return 0;
  1074. else
  1075. printk("Lan init failed.n");
  1076. }
  1077. }
  1079. return -ENODEV;
  1080. }
  1082. module_init(saa9730_probe);
  1083. MODULE_LICENSE("GPL");