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 static void smc911x_handle_mac_address(struct eth_device *dev) 39 { 40 unsigned long addrh, addrl; 41 uchar *m = dev->enetaddr; 42 43 addrl = m[0] | (m[1] << 8) | (m[2] << 16) | (m[3] << 24); 44 addrh = m[4] | (m[5] << 8); 45 smc911x_set_mac_csr(dev, ADDRL, addrl); 46 smc911x_set_mac_csr(dev, ADDRH, addrh); 47 48 printf(DRIVERNAME ": MAC %pM\n", m); 49 } 50 51 static int smc911x_eth_phy_read(struct eth_device *dev, 52 u8 phy, u8 reg, u16 *val) 53 { 54 while (smc911x_get_mac_csr(dev, MII_ACC) & MII_ACC_MII_BUSY) 55 ; 56 57 smc911x_set_mac_csr(dev, MII_ACC, phy << 11 | reg << 6 | 58 MII_ACC_MII_BUSY); 59 60 while (smc911x_get_mac_csr(dev, MII_ACC) & MII_ACC_MII_BUSY) 61 ; 62 63 *val = smc911x_get_mac_csr(dev, MII_DATA); 64 65 return 0; 66 } 67 68 static int smc911x_eth_phy_write(struct eth_device *dev, 69 u8 phy, u8 reg, u16 val) 70 { 71 while (smc911x_get_mac_csr(dev, MII_ACC) & MII_ACC_MII_BUSY) 72 ; 73 74 smc911x_set_mac_csr(dev, MII_DATA, val); 75 smc911x_set_mac_csr(dev, MII_ACC, 76 phy << 11 | reg << 6 | MII_ACC_MII_BUSY | MII_ACC_MII_WRITE); 77 78 while (smc911x_get_mac_csr(dev, MII_ACC) & MII_ACC_MII_BUSY) 79 ; 80 return 0; 81 } 82 83 static int smc911x_phy_reset(struct eth_device *dev) 84 { 85 u32 reg; 86 87 reg = smc911x_reg_read(dev, PMT_CTRL); 88 reg &= ~0xfffff030; 89 reg |= PMT_CTRL_PHY_RST; 90 smc911x_reg_write(dev, PMT_CTRL, reg); 91 92 mdelay(100); 93 94 return 0; 95 } 96 97 static void smc911x_phy_configure(struct eth_device *dev) 98 { 99 int timeout; 100 u16 status; 101 102 smc911x_phy_reset(dev); 103 104 smc911x_eth_phy_write(dev, 1, MII_BMCR, BMCR_RESET); 105 mdelay(1); 106 smc911x_eth_phy_write(dev, 1, MII_ADVERTISE, 0x01e1); 107 smc911x_eth_phy_write(dev, 1, MII_BMCR, BMCR_ANENABLE | 108 BMCR_ANRESTART); 109 110 timeout = 5000; 111 do { 112 mdelay(1); 113 if ((timeout--) == 0) 114 goto err_out; 115 116 if (smc911x_eth_phy_read(dev, 1, MII_BMSR, &status) != 0) 117 goto err_out; 118 } while (!(status & BMSR_LSTATUS)); 119 120 printf(DRIVERNAME ": phy initialized\n"); 121 122 return; 123 124 err_out: 125 printf(DRIVERNAME ": autonegotiation timed out\n"); 126 } 127 128 static void smc911x_enable(struct eth_device *dev) 129 { 130 /* Enable TX */ 131 smc911x_reg_write(dev, HW_CFG, 8 << 16 | HW_CFG_SF); 132 133 smc911x_reg_write(dev, GPT_CFG, GPT_CFG_TIMER_EN | 10000); 134 135 smc911x_reg_write(dev, TX_CFG, TX_CFG_TX_ON); 136 137 /* no padding to start of packets */ 138 smc911x_reg_write(dev, RX_CFG, 0); 139 140 smc911x_set_mac_csr(dev, MAC_CR, MAC_CR_TXEN | MAC_CR_RXEN | 141 MAC_CR_HBDIS); 142 143 } 144 145 static int smc911x_init(struct eth_device *dev, bd_t * bd) 146 { 147 struct chip_id *id = dev->priv; 148 149 printf(DRIVERNAME ": detected %s controller\n", id->name); 150 151 smc911x_reset(dev); 152 153 /* Configure the PHY, initialize the link state */ 154 smc911x_phy_configure(dev); 155 156 smc911x_handle_mac_address(dev); 157 158 /* Turn on Tx + Rx */ 159 smc911x_enable(dev); 160 161 return 0; 162 } 163 164 static int smc911x_send(struct eth_device *dev, 165 volatile void *packet, int length) 166 { 167 u32 *data = (u32*)packet; 168 u32 tmplen; 169 u32 status; 170 171 smc911x_reg_write(dev, TX_DATA_FIFO, TX_CMD_A_INT_FIRST_SEG | 172 TX_CMD_A_INT_LAST_SEG | length); 173 smc911x_reg_write(dev, TX_DATA_FIFO, length); 174 175 tmplen = (length + 3) / 4; 176 177 while (tmplen--) 178 pkt_data_push(dev, TX_DATA_FIFO, *data++); 179 180 /* wait for transmission */ 181 while (!((smc911x_reg_read(dev, TX_FIFO_INF) & 182 TX_FIFO_INF_TSUSED) >> 16)); 183 184 /* get status. Ignore 'no carrier' error, it has no meaning for 185 * full duplex operation 186 */ 187 status = smc911x_reg_read(dev, TX_STATUS_FIFO) & 188 (TX_STS_LOC | TX_STS_LATE_COLL | TX_STS_MANY_COLL | 189 TX_STS_MANY_DEFER | TX_STS_UNDERRUN); 190 191 if (!status) 192 return 0; 193 194 printf(DRIVERNAME ": failed to send packet: %s%s%s%s%s\n", 195 status & TX_STS_LOC ? "TX_STS_LOC " : "", 196 status & TX_STS_LATE_COLL ? "TX_STS_LATE_COLL " : "", 197 status & TX_STS_MANY_COLL ? "TX_STS_MANY_COLL " : "", 198 status & TX_STS_MANY_DEFER ? "TX_STS_MANY_DEFER " : "", 199 status & TX_STS_UNDERRUN ? "TX_STS_UNDERRUN" : ""); 200 201 return -1; 202 } 203 204 static void smc911x_halt(struct eth_device *dev) 205 { 206 smc911x_reset(dev); 207 } 208 209 static int smc911x_rx(struct eth_device *dev) 210 { 211 u32 *data = (u32 *)NetRxPackets[0]; 212 u32 pktlen, tmplen; 213 u32 status; 214 215 if ((smc911x_reg_read(dev, RX_FIFO_INF) & RX_FIFO_INF_RXSUSED) >> 16) { 216 status = smc911x_reg_read(dev, RX_STATUS_FIFO); 217 pktlen = (status & RX_STS_PKT_LEN) >> 16; 218 219 smc911x_reg_write(dev, RX_CFG, 0); 220 221 tmplen = (pktlen + 3) / 4; 222 while (tmplen--) 223 *data++ = pkt_data_pull(dev, RX_DATA_FIFO); 224 225 if (status & RX_STS_ES) 226 printf(DRIVERNAME 227 ": dropped bad packet. Status: 0x%08x\n", 228 status); 229 else 230 NetReceive(NetRxPackets[0], pktlen); 231 } 232 233 return 0; 234 } 235 236 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) 237 /* wrapper for smc911x_eth_phy_read */ 238 static int smc911x_miiphy_read(const char *devname, u8 phy, u8 reg, u16 *val) 239 { 240 struct eth_device *dev = eth_get_dev_by_name(devname); 241 if (dev) 242 return smc911x_eth_phy_read(dev, phy, reg, val); 243 return -1; 244 } 245 /* wrapper for smc911x_eth_phy_write */ 246 static int smc911x_miiphy_write(const char *devname, u8 phy, u8 reg, u16 val) 247 { 248 struct eth_device *dev = eth_get_dev_by_name(devname); 249 if (dev) 250 return smc911x_eth_phy_write(dev, phy, reg, val); 251 return -1; 252 } 253 #endif 254 255 int smc911x_initialize(u8 dev_num, int base_addr) 256 { 257 unsigned long addrl, addrh; 258 struct eth_device *dev; 259 260 dev = malloc(sizeof(*dev)); 261 if (!dev) { 262 return -1; 263 } 264 memset(dev, 0, sizeof(*dev)); 265 266 dev->iobase = base_addr; 267 268 /* Try to detect chip. Will fail if not present. */ 269 if (smc911x_detect_chip(dev)) { 270 free(dev); 271 return 0; 272 } 273 274 addrh = smc911x_get_mac_csr(dev, ADDRH); 275 addrl = smc911x_get_mac_csr(dev, ADDRL); 276 if (!(addrl == 0xffffffff && addrh == 0x0000ffff)) { 277 /* address is obtained from optional eeprom */ 278 dev->enetaddr[0] = addrl; 279 dev->enetaddr[1] = addrl >> 8; 280 dev->enetaddr[2] = addrl >> 16; 281 dev->enetaddr[3] = addrl >> 24; 282 dev->enetaddr[4] = addrh; 283 dev->enetaddr[5] = addrh >> 8; 284 } 285 286 dev->init = smc911x_init; 287 dev->halt = smc911x_halt; 288 dev->send = smc911x_send; 289 dev->recv = smc911x_rx; 290 sprintf(dev->name, "%s-%hu", DRIVERNAME, dev_num); 291 292 eth_register(dev); 293 294 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) 295 miiphy_register(dev->name, smc911x_miiphy_read, smc911x_miiphy_write); 296 #endif 297 298 return 1; 299 } 300