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, void *packet, int length) 165 { 166 u32 *data = (u32*)packet; 167 u32 tmplen; 168 u32 status; 169 170 smc911x_reg_write(dev, TX_DATA_FIFO, TX_CMD_A_INT_FIRST_SEG | 171 TX_CMD_A_INT_LAST_SEG | length); 172 smc911x_reg_write(dev, TX_DATA_FIFO, length); 173 174 tmplen = (length + 3) / 4; 175 176 while (tmplen--) 177 pkt_data_push(dev, TX_DATA_FIFO, *data++); 178 179 /* wait for transmission */ 180 while (!((smc911x_reg_read(dev, TX_FIFO_INF) & 181 TX_FIFO_INF_TSUSED) >> 16)); 182 183 /* get status. Ignore 'no carrier' error, it has no meaning for 184 * full duplex operation 185 */ 186 status = smc911x_reg_read(dev, TX_STATUS_FIFO) & 187 (TX_STS_LOC | TX_STS_LATE_COLL | TX_STS_MANY_COLL | 188 TX_STS_MANY_DEFER | TX_STS_UNDERRUN); 189 190 if (!status) 191 return 0; 192 193 printf(DRIVERNAME ": failed to send packet: %s%s%s%s%s\n", 194 status & TX_STS_LOC ? "TX_STS_LOC " : "", 195 status & TX_STS_LATE_COLL ? "TX_STS_LATE_COLL " : "", 196 status & TX_STS_MANY_COLL ? "TX_STS_MANY_COLL " : "", 197 status & TX_STS_MANY_DEFER ? "TX_STS_MANY_DEFER " : "", 198 status & TX_STS_UNDERRUN ? "TX_STS_UNDERRUN" : ""); 199 200 return -1; 201 } 202 203 static void smc911x_halt(struct eth_device *dev) 204 { 205 smc911x_reset(dev); 206 } 207 208 static int smc911x_rx(struct eth_device *dev) 209 { 210 u32 *data = (u32 *)NetRxPackets[0]; 211 u32 pktlen, tmplen; 212 u32 status; 213 214 if ((smc911x_reg_read(dev, RX_FIFO_INF) & RX_FIFO_INF_RXSUSED) >> 16) { 215 status = smc911x_reg_read(dev, RX_STATUS_FIFO); 216 pktlen = (status & RX_STS_PKT_LEN) >> 16; 217 218 smc911x_reg_write(dev, RX_CFG, 0); 219 220 tmplen = (pktlen + 3) / 4; 221 while (tmplen--) 222 *data++ = pkt_data_pull(dev, RX_DATA_FIFO); 223 224 if (status & RX_STS_ES) 225 printf(DRIVERNAME 226 ": dropped bad packet. Status: 0x%08x\n", 227 status); 228 else 229 NetReceive(NetRxPackets[0], pktlen); 230 } 231 232 return 0; 233 } 234 235 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) 236 /* wrapper for smc911x_eth_phy_read */ 237 static int smc911x_miiphy_read(const char *devname, u8 phy, u8 reg, u16 *val) 238 { 239 struct eth_device *dev = eth_get_dev_by_name(devname); 240 if (dev) 241 return smc911x_eth_phy_read(dev, phy, reg, val); 242 return -1; 243 } 244 /* wrapper for smc911x_eth_phy_write */ 245 static int smc911x_miiphy_write(const char *devname, u8 phy, u8 reg, u16 val) 246 { 247 struct eth_device *dev = eth_get_dev_by_name(devname); 248 if (dev) 249 return smc911x_eth_phy_write(dev, phy, reg, val); 250 return -1; 251 } 252 #endif 253 254 int smc911x_initialize(u8 dev_num, int base_addr) 255 { 256 unsigned long addrl, addrh; 257 struct eth_device *dev; 258 259 dev = malloc(sizeof(*dev)); 260 if (!dev) { 261 return -1; 262 } 263 memset(dev, 0, sizeof(*dev)); 264 265 dev->iobase = base_addr; 266 267 /* Try to detect chip. Will fail if not present. */ 268 if (smc911x_detect_chip(dev)) { 269 free(dev); 270 return 0; 271 } 272 273 addrh = smc911x_get_mac_csr(dev, ADDRH); 274 addrl = smc911x_get_mac_csr(dev, ADDRL); 275 if (!(addrl == 0xffffffff && addrh == 0x0000ffff)) { 276 /* address is obtained from optional eeprom */ 277 dev->enetaddr[0] = addrl; 278 dev->enetaddr[1] = addrl >> 8; 279 dev->enetaddr[2] = addrl >> 16; 280 dev->enetaddr[3] = addrl >> 24; 281 dev->enetaddr[4] = addrh; 282 dev->enetaddr[5] = addrh >> 8; 283 } 284 285 dev->init = smc911x_init; 286 dev->halt = smc911x_halt; 287 dev->send = smc911x_send; 288 dev->recv = smc911x_rx; 289 sprintf(dev->name, "%s-%hu", DRIVERNAME, dev_num); 290 291 eth_register(dev); 292 293 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) 294 miiphy_register(dev->name, smc911x_miiphy_read, smc911x_miiphy_write); 295 #endif 296 297 return 1; 298 } 299