1 /* 2 * SMSC LAN9[12]1[567] Network driver 3 * 4 * (c) 2007 Pengutronix, Sascha Hauer <s.hauer@pengutronix.de> 5 * 6 * See file CREDITS for list of people who contributed to this 7 * project. 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation; either version 2 of 12 * the License, or (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 22 * MA 02111-1307 USA 23 */ 24 25 #include <common.h> 26 #include <command.h> 27 #include <malloc.h> 28 #include <net.h> 29 #include <miiphy.h> 30 31 #include "smc911x.h" 32 33 u32 pkt_data_pull(struct eth_device *dev, u32 addr) \ 34 __attribute__ ((weak, alias ("smc911x_reg_read"))); 35 void pkt_data_push(struct eth_device *dev, u32 addr, u32 val) \ 36 __attribute__ ((weak, alias ("smc911x_reg_write"))); 37 38 #define mdelay(n) udelay((n)*1000) 39 40 static void smx911x_handle_mac_address(struct eth_device *dev) 41 { 42 unsigned long addrh, addrl; 43 uchar *m = dev->enetaddr; 44 45 addrl = m[0] | (m[1] << 8) | (m[2] << 16) | (m[3] << 24); 46 addrh = m[4] | (m[5] << 8); 47 smc911x_set_mac_csr(dev, ADDRL, addrl); 48 smc911x_set_mac_csr(dev, ADDRH, addrh); 49 50 printf(DRIVERNAME ": MAC %pM\n", m); 51 } 52 53 static int smc911x_miiphy_read(struct eth_device *dev, 54 u8 phy, u8 reg, u16 *val) 55 { 56 while (smc911x_get_mac_csr(dev, MII_ACC) & MII_ACC_MII_BUSY) 57 ; 58 59 smc911x_set_mac_csr(dev, MII_ACC, phy << 11 | reg << 6 | 60 MII_ACC_MII_BUSY); 61 62 while (smc911x_get_mac_csr(dev, MII_ACC) & MII_ACC_MII_BUSY) 63 ; 64 65 *val = smc911x_get_mac_csr(dev, MII_DATA); 66 67 return 0; 68 } 69 70 static int smc911x_miiphy_write(struct eth_device *dev, 71 u8 phy, u8 reg, u16 val) 72 { 73 while (smc911x_get_mac_csr(dev, MII_ACC) & MII_ACC_MII_BUSY) 74 ; 75 76 smc911x_set_mac_csr(dev, MII_DATA, val); 77 smc911x_set_mac_csr(dev, MII_ACC, 78 phy << 11 | reg << 6 | MII_ACC_MII_BUSY | MII_ACC_MII_WRITE); 79 80 while (smc911x_get_mac_csr(dev, MII_ACC) & MII_ACC_MII_BUSY) 81 ; 82 return 0; 83 } 84 85 static int smc911x_phy_reset(struct eth_device *dev) 86 { 87 u32 reg; 88 89 reg = smc911x_reg_read(dev, PMT_CTRL); 90 reg &= ~0xfffff030; 91 reg |= PMT_CTRL_PHY_RST; 92 smc911x_reg_write(dev, PMT_CTRL, reg); 93 94 mdelay(100); 95 96 return 0; 97 } 98 99 static void smc911x_phy_configure(struct eth_device *dev) 100 { 101 int timeout; 102 u16 status; 103 104 smc911x_phy_reset(dev); 105 106 smc911x_miiphy_write(dev, 1, PHY_BMCR, PHY_BMCR_RESET); 107 mdelay(1); 108 smc911x_miiphy_write(dev, 1, PHY_ANAR, 0x01e1); 109 smc911x_miiphy_write(dev, 1, PHY_BMCR, PHY_BMCR_AUTON | 110 PHY_BMCR_RST_NEG); 111 112 timeout = 5000; 113 do { 114 mdelay(1); 115 if ((timeout--) == 0) 116 goto err_out; 117 118 if (smc911x_miiphy_read(dev, 1, PHY_BMSR, &status) != 0) 119 goto err_out; 120 } while (!(status & PHY_BMSR_LS)); 121 122 printf(DRIVERNAME ": phy initialized\n"); 123 124 return; 125 126 err_out: 127 printf(DRIVERNAME ": autonegotiation timed out\n"); 128 } 129 130 static void smc911x_enable(struct eth_device *dev) 131 { 132 /* Enable TX */ 133 smc911x_reg_write(dev, HW_CFG, 8 << 16 | HW_CFG_SF); 134 135 smc911x_reg_write(dev, GPT_CFG, GPT_CFG_TIMER_EN | 10000); 136 137 smc911x_reg_write(dev, TX_CFG, TX_CFG_TX_ON); 138 139 /* no padding to start of packets */ 140 smc911x_reg_write(dev, RX_CFG, 0); 141 142 smc911x_set_mac_csr(dev, MAC_CR, MAC_CR_TXEN | MAC_CR_RXEN | 143 MAC_CR_HBDIS); 144 145 } 146 147 static int smc911x_init(struct eth_device *dev, bd_t * bd) 148 { 149 printf(DRIVERNAME ": initializing\n"); 150 151 if (smc911x_detect_chip(dev)) 152 goto err_out; 153 154 smc911x_reset(dev); 155 156 /* Configure the PHY, initialize the link state */ 157 smc911x_phy_configure(dev); 158 159 smx911x_handle_mac_address(dev); 160 161 /* Turn on Tx + Rx */ 162 smc911x_enable(dev); 163 164 return 0; 165 166 err_out: 167 return -1; 168 } 169 170 static int smc911x_send(struct eth_device *dev, 171 volatile void *packet, int length) 172 { 173 u32 *data = (u32*)packet; 174 u32 tmplen; 175 u32 status; 176 177 smc911x_reg_write(dev, TX_DATA_FIFO, TX_CMD_A_INT_FIRST_SEG | 178 TX_CMD_A_INT_LAST_SEG | length); 179 smc911x_reg_write(dev, TX_DATA_FIFO, length); 180 181 tmplen = (length + 3) / 4; 182 183 while (tmplen--) 184 pkt_data_push(dev, TX_DATA_FIFO, *data++); 185 186 /* wait for transmission */ 187 while (!((smc911x_reg_read(dev, TX_FIFO_INF) & 188 TX_FIFO_INF_TSUSED) >> 16)); 189 190 /* get status. Ignore 'no carrier' error, it has no meaning for 191 * full duplex operation 192 */ 193 status = smc911x_reg_read(dev, TX_STATUS_FIFO) & 194 (TX_STS_LOC | TX_STS_LATE_COLL | TX_STS_MANY_COLL | 195 TX_STS_MANY_DEFER | TX_STS_UNDERRUN); 196 197 if (!status) 198 return 0; 199 200 printf(DRIVERNAME ": failed to send packet: %s%s%s%s%s\n", 201 status & TX_STS_LOC ? "TX_STS_LOC " : "", 202 status & TX_STS_LATE_COLL ? "TX_STS_LATE_COLL " : "", 203 status & TX_STS_MANY_COLL ? "TX_STS_MANY_COLL " : "", 204 status & TX_STS_MANY_DEFER ? "TX_STS_MANY_DEFER " : "", 205 status & TX_STS_UNDERRUN ? "TX_STS_UNDERRUN" : ""); 206 207 return -1; 208 } 209 210 static void smc911x_halt(struct eth_device *dev) 211 { 212 smc911x_reset(dev); 213 } 214 215 static int smc911x_rx(struct eth_device *dev) 216 { 217 u32 *data = (u32 *)NetRxPackets[0]; 218 u32 pktlen, tmplen; 219 u32 status; 220 221 if ((smc911x_reg_read(dev, RX_FIFO_INF) & RX_FIFO_INF_RXSUSED) >> 16) { 222 status = smc911x_reg_read(dev, RX_STATUS_FIFO); 223 pktlen = (status & RX_STS_PKT_LEN) >> 16; 224 225 smc911x_reg_write(dev, RX_CFG, 0); 226 227 tmplen = (pktlen + 2+ 3) / 4; 228 while (tmplen--) 229 *data++ = pkt_data_pull(dev, RX_DATA_FIFO); 230 231 if (status & RX_STS_ES) 232 printf(DRIVERNAME 233 ": dropped bad packet. Status: 0x%08x\n", 234 status); 235 else 236 NetReceive(NetRxPackets[0], pktlen); 237 } 238 239 return 0; 240 } 241 242 int smc911x_initialize(u8 dev_num, int base_addr) 243 { 244 unsigned long addrl, addrh; 245 struct eth_device *dev; 246 247 dev = malloc(sizeof(*dev)); 248 if (!dev) { 249 free(dev); 250 return 0; 251 } 252 memset(dev, 0, sizeof(*dev)); 253 254 dev->iobase = base_addr; 255 256 addrh = smc911x_get_mac_csr(dev, ADDRH); 257 addrl = smc911x_get_mac_csr(dev, ADDRL); 258 dev->enetaddr[0] = addrl; 259 dev->enetaddr[1] = addrl >> 8; 260 dev->enetaddr[2] = addrl >> 16; 261 dev->enetaddr[3] = addrl >> 24; 262 dev->enetaddr[4] = addrh; 263 dev->enetaddr[5] = addrh >> 8; 264 265 dev->init = smc911x_init; 266 dev->halt = smc911x_halt; 267 dev->send = smc911x_send; 268 dev->recv = smc911x_rx; 269 sprintf(dev->name, "%s-%hu", DRIVERNAME, dev_num); 270 271 eth_register(dev); 272 return 0; 273 } 274