1/* 2 * drivers/net/netx-eth.c 3 * 4 * Copyright (c) 2005 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 8 * as published by the Free Software Foundation. 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 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 */ 19 20#include <linux/init.h> 21#include <linux/module.h> 22#include <linux/kernel.h> 23#include <linux/delay.h> 24 25#include <linux/netdevice.h> 26#include <linux/platform_device.h> 27#include <linux/etherdevice.h> 28#include <linux/skbuff.h> 29#include <linux/mii.h> 30 31#include <asm/io.h> 32#include <asm/hardware.h> 33#include <asm/arch/hardware.h> 34#include <asm/arch/netx-regs.h> 35#include <asm/arch/pfifo.h> 36#include <asm/arch/xc.h> 37#include <asm/arch/eth.h> 38 39/* XC Fifo Offsets */ 40#define EMPTY_PTR_FIFO(xcno) (0 + ((xcno) << 3)) /* Index of the empty pointer FIFO */ 41#define IND_FIFO_PORT_HI(xcno) (1 + ((xcno) << 3)) /* Index of the FIFO where received */ 42 /* Data packages are indicated by XC */ 43#define IND_FIFO_PORT_LO(xcno) (2 + ((xcno) << 3)) /* Index of the FIFO where received */ 44 /* Data packages are indicated by XC */ 45#define REQ_FIFO_PORT_HI(xcno) (3 + ((xcno) << 3)) /* Index of the FIFO where Data packages */ 46 /* have to be indicated by ARM which */ 47 /* shall be sent */ 48#define REQ_FIFO_PORT_LO(xcno) (4 + ((xcno) << 3)) /* Index of the FIFO where Data packages */ 49 /* have to be indicated by ARM which shall */ 50 /* be sent */ 51#define CON_FIFO_PORT_HI(xcno) (5 + ((xcno) << 3)) /* Index of the FIFO where sent Data packages */ 52 /* are confirmed */ 53#define CON_FIFO_PORT_LO(xcno) (6 + ((xcno) << 3)) /* Index of the FIFO where sent Data */ 54 /* packages are confirmed */ 55#define PFIFO_MASK(xcno) (0x7f << (xcno*8)) 56 57#define FIFO_PTR_FRAMELEN_SHIFT 0 58#define FIFO_PTR_FRAMELEN_MASK (0x7ff << 0) 59#define FIFO_PTR_FRAMELEN(len) (((len) << 0) & FIFO_PTR_FRAMELEN_MASK) 60#define FIFO_PTR_TIMETRIG (1<<11) 61#define FIFO_PTR_MULTI_REQ 62#define FIFO_PTR_ORIGIN (1<<14) 63#define FIFO_PTR_VLAN (1<<15) 64#define FIFO_PTR_FRAMENO_SHIFT 16 65#define FIFO_PTR_FRAMENO_MASK (0x3f << 16) 66#define FIFO_PTR_FRAMENO(no) (((no) << 16) & FIFO_PTR_FRAMENO_MASK) 67#define FIFO_PTR_SEGMENT_SHIFT 22 68#define FIFO_PTR_SEGMENT_MASK (0xf << 22) 69#define FIFO_PTR_SEGMENT(seg) (((seg) & 0xf) << 22) 70#define FIFO_PTR_ERROR_SHIFT 28 71#define FIFO_PTR_ERROR_MASK (0xf << 28) 72 73#define ISR_LINK_STATUS_CHANGE (1<<4) 74#define ISR_IND_LO (1<<3) 75#define ISR_CON_LO (1<<2) 76#define ISR_IND_HI (1<<1) 77#define ISR_CON_HI (1<<0) 78 79#define ETH_MAC_LOCAL_CONFIG 0x1560 80#define ETH_MAC_4321 0x1564 81#define ETH_MAC_65 0x1568 82 83#define MAC_TRAFFIC_CLASS_ARRANGEMENT_SHIFT 16 84#define MAC_TRAFFIC_CLASS_ARRANGEMENT_MASK (0xf<<MAC_TRAFFIC_CLASS_ARRANGEMENT_SHIFT) 85#define MAC_TRAFFIC_CLASS_ARRANGEMENT(x) (((x)<<MAC_TRAFFIC_CLASS_ARRANGEMENT_SHIFT) & MAC_TRAFFIC_CLASS_ARRANGEMENT_MASK) 86#define LOCAL_CONFIG_LINK_STATUS_IRQ_EN (1<<24) 87#define LOCAL_CONFIG_CON_LO_IRQ_EN (1<<23) 88#define LOCAL_CONFIG_CON_HI_IRQ_EN (1<<22) 89#define LOCAL_CONFIG_IND_LO_IRQ_EN (1<<21) 90#define LOCAL_CONFIG_IND_HI_IRQ_EN (1<<20) 91 92#define CARDNAME "netx-eth" 93 94/* LSB must be zero */ 95#define INTERNAL_PHY_ADR 0x1c 96 97struct netx_eth_priv { 98 void __iomem *sram_base, *xpec_base, *xmac_base; 99 int id; 100 struct net_device_stats stats; 101 struct mii_if_info mii; 102 u32 msg_enable; 103 struct xc *xc; 104 spinlock_t lock; 105}; 106 107static void netx_eth_set_multicast_list(struct net_device *ndev) 108{ 109 /* implement me */ 110} 111 112static int 113netx_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *ndev) 114{ 115 struct netx_eth_priv *priv = netdev_priv(ndev); 116 unsigned char *buf = skb->data; 117 unsigned int len = skb->len; 118 119 spin_lock_irq(&priv->lock); 120 memcpy_toio(priv->sram_base + 1560, (void *)buf, len); 121 if (len < 60) { 122 memset_io(priv->sram_base + 1560 + len, 0, 60 - len); 123 len = 60; 124 } 125 126 pfifo_push(REQ_FIFO_PORT_LO(priv->id), 127 FIFO_PTR_SEGMENT(priv->id) | 128 FIFO_PTR_FRAMENO(1) | 129 FIFO_PTR_FRAMELEN(len)); 130 131 ndev->trans_start = jiffies; 132 priv->stats.tx_packets++; 133 priv->stats.tx_bytes += skb->len; 134 135 netif_stop_queue(ndev); 136 spin_unlock_irq(&priv->lock); 137 dev_kfree_skb(skb); 138 139 return 0; 140} 141 142static void netx_eth_receive(struct net_device *ndev) 143{ 144 struct netx_eth_priv *priv = netdev_priv(ndev); 145 unsigned int val, frameno, seg, len; 146 unsigned char *data; 147 struct sk_buff *skb; 148 149 val = pfifo_pop(IND_FIFO_PORT_LO(priv->id)); 150 151 frameno = (val & FIFO_PTR_FRAMENO_MASK) >> FIFO_PTR_FRAMENO_SHIFT; 152 seg = (val & FIFO_PTR_SEGMENT_MASK) >> FIFO_PTR_SEGMENT_SHIFT; 153 len = (val & FIFO_PTR_FRAMELEN_MASK) >> FIFO_PTR_FRAMELEN_SHIFT; 154 155 skb = dev_alloc_skb(len); 156 if (unlikely(skb == NULL)) { 157 printk(KERN_NOTICE "%s: Low memory, packet dropped.\n", 158 ndev->name); 159 priv->stats.rx_dropped++; 160 return; 161 } 162 163 data = skb_put(skb, len); 164 165 memcpy_fromio(data, priv->sram_base + frameno * 1560, len); 166 167 pfifo_push(EMPTY_PTR_FIFO(priv->id), 168 FIFO_PTR_SEGMENT(seg) | FIFO_PTR_FRAMENO(frameno)); 169 170 ndev->last_rx = jiffies; 171 skb->protocol = eth_type_trans(skb, ndev); 172 netif_rx(skb); 173 priv->stats.rx_packets++; 174 priv->stats.rx_bytes += len; 175} 176 177static irqreturn_t 178netx_eth_interrupt(int irq, void *dev_id) 179{ 180 struct net_device *ndev = dev_id; 181 struct netx_eth_priv *priv = netdev_priv(ndev); 182 int status; 183 unsigned long flags; 184 185 spin_lock_irqsave(&priv->lock, flags); 186 187 status = readl(NETX_PFIFO_XPEC_ISR(priv->id)); 188 while (status) { 189 int fill_level; 190 writel(status, NETX_PFIFO_XPEC_ISR(priv->id)); 191 192 if ((status & ISR_CON_HI) || (status & ISR_IND_HI)) 193 printk("%s: unexpected status: 0x%08x\n", 194 __FUNCTION__, status); 195 196 fill_level = 197 readl(NETX_PFIFO_FILL_LEVEL(IND_FIFO_PORT_LO(priv->id))); 198 while (fill_level--) 199 netx_eth_receive(ndev); 200 201 if (status & ISR_CON_LO) 202 netif_wake_queue(ndev); 203 204 if (status & ISR_LINK_STATUS_CHANGE) 205 mii_check_media(&priv->mii, netif_msg_link(priv), 1); 206 207 status = readl(NETX_PFIFO_XPEC_ISR(priv->id)); 208 } 209 spin_unlock_irqrestore(&priv->lock, flags); 210 return IRQ_HANDLED; 211} 212 213static struct net_device_stats *netx_eth_query_statistics(struct net_device *ndev) 214{ 215 struct netx_eth_priv *priv = netdev_priv(ndev); 216 return &priv->stats; 217} 218 219static int netx_eth_open(struct net_device *ndev) 220{ 221 struct netx_eth_priv *priv = netdev_priv(ndev); 222 223 if (request_irq 224 (ndev->irq, &netx_eth_interrupt, IRQF_SHARED, ndev->name, ndev)) 225 return -EAGAIN; 226 227 writel(ndev->dev_addr[0] | 228 ndev->dev_addr[1]<<8 | 229 ndev->dev_addr[2]<<16 | 230 ndev->dev_addr[3]<<24, 231 priv->xpec_base + NETX_XPEC_RAM_START_OFS + ETH_MAC_4321); 232 writel(ndev->dev_addr[4] | 233 ndev->dev_addr[5]<<8, 234 priv->xpec_base + NETX_XPEC_RAM_START_OFS + ETH_MAC_65); 235 236 writel(LOCAL_CONFIG_LINK_STATUS_IRQ_EN | 237 LOCAL_CONFIG_CON_LO_IRQ_EN | 238 LOCAL_CONFIG_CON_HI_IRQ_EN | 239 LOCAL_CONFIG_IND_LO_IRQ_EN | 240 LOCAL_CONFIG_IND_HI_IRQ_EN, 241 priv->xpec_base + NETX_XPEC_RAM_START_OFS + 242 ETH_MAC_LOCAL_CONFIG); 243 244 mii_check_media(&priv->mii, netif_msg_link(priv), 1); 245 netif_start_queue(ndev); 246 247 return 0; 248} 249 250static int netx_eth_close(struct net_device *ndev) 251{ 252 struct netx_eth_priv *priv = netdev_priv(ndev); 253 254 netif_stop_queue(ndev); 255 256 writel(0, 257 priv->xpec_base + NETX_XPEC_RAM_START_OFS + ETH_MAC_LOCAL_CONFIG); 258 259 free_irq(ndev->irq, ndev); 260 261 return 0; 262} 263 264static void netx_eth_timeout(struct net_device *ndev) 265{ 266 struct netx_eth_priv *priv = netdev_priv(ndev); 267 int i; 268 269 printk(KERN_ERR "%s: transmit timed out, resetting\n", ndev->name); 270 271 spin_lock_irq(&priv->lock); 272 273 xc_reset(priv->xc); 274 xc_start(priv->xc); 275 276 for (i=2; i<=18; i++) 277 pfifo_push(EMPTY_PTR_FIFO(priv->id), 278 FIFO_PTR_FRAMENO(i) | FIFO_PTR_SEGMENT(priv->id)); 279 280 spin_unlock_irq(&priv->lock); 281 282 netif_wake_queue(ndev); 283} 284 285static int 286netx_eth_phy_read(struct net_device *ndev, int phy_id, int reg) 287{ 288 unsigned int val; 289 290 val = MIIMU_SNRDY | MIIMU_PREAMBLE | MIIMU_PHYADDR(phy_id) | 291 MIIMU_REGADDR(reg) | MIIMU_PHY_NRES; 292 293 writel(val, NETX_MIIMU); 294 while (readl(NETX_MIIMU) & MIIMU_SNRDY); 295 296 return readl(NETX_MIIMU) >> 16; 297 298} 299 300static void 301netx_eth_phy_write(struct net_device *ndev, int phy_id, int reg, int value) 302{ 303 unsigned int val; 304 305 val = MIIMU_SNRDY | MIIMU_PREAMBLE | MIIMU_PHYADDR(phy_id) | 306 MIIMU_REGADDR(reg) | MIIMU_PHY_NRES | MIIMU_OPMODE_WRITE | 307 MIIMU_DATA(value); 308 309 writel(val, NETX_MIIMU); 310 while (readl(NETX_MIIMU) & MIIMU_SNRDY); 311} 312 313static int netx_eth_enable(struct net_device *ndev) 314{ 315 struct netx_eth_priv *priv = netdev_priv(ndev); 316 unsigned int mac4321, mac65; 317 int running, i; 318 319 ether_setup(ndev); 320 321 ndev->open = netx_eth_open; 322 ndev->stop = netx_eth_close; 323 ndev->hard_start_xmit = netx_eth_hard_start_xmit; 324 ndev->tx_timeout = netx_eth_timeout; 325 ndev->watchdog_timeo = msecs_to_jiffies(5000); 326 ndev->get_stats = netx_eth_query_statistics; 327 ndev->set_multicast_list = netx_eth_set_multicast_list; 328 329 priv->msg_enable = NETIF_MSG_LINK; 330 priv->mii.phy_id_mask = 0x1f; 331 priv->mii.reg_num_mask = 0x1f; 332 priv->mii.force_media = 0; 333 priv->mii.full_duplex = 0; 334 priv->mii.dev = ndev; 335 priv->mii.mdio_read = netx_eth_phy_read; 336 priv->mii.mdio_write = netx_eth_phy_write; 337 priv->mii.phy_id = INTERNAL_PHY_ADR + priv->id; 338 339 running = xc_running(priv->xc); 340 xc_stop(priv->xc); 341 342 /* if the xc engine is already running, assume the bootloader has 343 * loaded the firmware for us 344 */ 345 if (running) { 346 /* get Node Address from hardware */ 347 mac4321 = readl(priv->xpec_base + 348 NETX_XPEC_RAM_START_OFS + ETH_MAC_4321); 349 mac65 = readl(priv->xpec_base + 350 NETX_XPEC_RAM_START_OFS + ETH_MAC_65); 351 352 ndev->dev_addr[0] = mac4321 & 0xff; 353 ndev->dev_addr[1] = (mac4321 >> 8) & 0xff; 354 ndev->dev_addr[2] = (mac4321 >> 16) & 0xff; 355 ndev->dev_addr[3] = (mac4321 >> 24) & 0xff; 356 ndev->dev_addr[4] = mac65 & 0xff; 357 ndev->dev_addr[5] = (mac65 >> 8) & 0xff; 358 } else { 359 if (xc_request_firmware(priv->xc)) { 360 printk(CARDNAME ": requesting firmware failed\n"); 361 return -ENODEV; 362 } 363 } 364 365 xc_reset(priv->xc); 366 xc_start(priv->xc); 367 368 if (!is_valid_ether_addr(ndev->dev_addr)) 369 printk("%s: Invalid ethernet MAC address. Please " 370 "set using ifconfig\n", ndev->name); 371 372 for (i=2; i<=18; i++) 373 pfifo_push(EMPTY_PTR_FIFO(priv->id), 374 FIFO_PTR_FRAMENO(i) | FIFO_PTR_SEGMENT(priv->id)); 375 376 return register_netdev(ndev); 377 378} 379 380static int netx_eth_drv_probe(struct platform_device *pdev) 381{ 382 struct netx_eth_priv *priv; 383 struct net_device *ndev; 384 struct netxeth_platform_data *pdata; 385 int ret; 386 387 ndev = alloc_etherdev(sizeof (struct netx_eth_priv)); 388 if (!ndev) { 389 printk("%s: could not allocate device.\n", CARDNAME); 390 ret = -ENOMEM; 391 goto exit; 392 } 393 SET_MODULE_OWNER(ndev); 394 SET_NETDEV_DEV(ndev, &pdev->dev); 395 396 platform_set_drvdata(pdev, ndev); 397 398 priv = netdev_priv(ndev); 399 400 pdata = (struct netxeth_platform_data *)pdev->dev.platform_data; 401 priv->xc = request_xc(pdata->xcno, &pdev->dev); 402 if (!priv->xc) { 403 dev_err(&pdev->dev, "unable to request xc engine\n"); 404 ret = -ENODEV; 405 goto exit_free_netdev; 406 } 407 408 ndev->irq = priv->xc->irq; 409 priv->id = pdev->id; 410 priv->xpec_base = priv->xc->xpec_base; 411 priv->xmac_base = priv->xc->xmac_base; 412 priv->sram_base = priv->xc->sram_base; 413 414 ret = pfifo_request(PFIFO_MASK(priv->id)); 415 if (ret) { 416 printk("unable to request PFIFO\n"); 417 goto exit_free_xc; 418 } 419 420 ret = netx_eth_enable(ndev); 421 if (ret) 422 goto exit_free_pfifo; 423 424 return 0; 425exit_free_pfifo: 426 pfifo_free(PFIFO_MASK(priv->id)); 427exit_free_xc: 428 free_xc(priv->xc); 429exit_free_netdev: 430 platform_set_drvdata(pdev, NULL); 431 free_netdev(ndev); 432exit: 433 return ret; 434} 435 436static int netx_eth_drv_remove(struct platform_device *pdev) 437{ 438 struct net_device *ndev = dev_get_drvdata(&pdev->dev); 439 struct netx_eth_priv *priv = netdev_priv(ndev); 440 441 platform_set_drvdata(pdev, NULL); 442 443 unregister_netdev(ndev); 444 xc_stop(priv->xc); 445 free_xc(priv->xc); 446 free_netdev(ndev); 447 pfifo_free(PFIFO_MASK(priv->id)); 448 449 return 0; 450} 451 452static int netx_eth_drv_suspend(struct platform_device *pdev, pm_message_t state) 453{ 454 dev_err(&pdev->dev, "suspend not implemented\n"); 455 return 0; 456} 457 458static int netx_eth_drv_resume(struct platform_device *pdev) 459{ 460 dev_err(&pdev->dev, "resume not implemented\n"); 461 return 0; 462} 463 464static struct platform_driver netx_eth_driver = { 465 .probe = netx_eth_drv_probe, 466 .remove = netx_eth_drv_remove, 467 .suspend = netx_eth_drv_suspend, 468 .resume = netx_eth_drv_resume, 469 .driver = { 470 .name = CARDNAME, 471 .owner = THIS_MODULE, 472 }, 473}; 474 475static int __init netx_eth_init(void) 476{ 477 unsigned int phy_control, val; 478 479 printk("NetX Ethernet driver\n"); 480 481 phy_control = PHY_CONTROL_PHY_ADDRESS(INTERNAL_PHY_ADR>>1) | 482 PHY_CONTROL_PHY1_MODE(PHY_MODE_ALL) | 483 PHY_CONTROL_PHY1_AUTOMDIX | 484 PHY_CONTROL_PHY1_EN | 485 PHY_CONTROL_PHY0_MODE(PHY_MODE_ALL) | 486 PHY_CONTROL_PHY0_AUTOMDIX | 487 PHY_CONTROL_PHY0_EN | 488 PHY_CONTROL_CLK_XLATIN; 489 490 val = readl(NETX_SYSTEM_IOC_ACCESS_KEY); 491 writel(val, NETX_SYSTEM_IOC_ACCESS_KEY); 492 493 writel(phy_control | PHY_CONTROL_RESET, NETX_SYSTEM_PHY_CONTROL); 494 udelay(100); 495 496 val = readl(NETX_SYSTEM_IOC_ACCESS_KEY); 497 writel(val, NETX_SYSTEM_IOC_ACCESS_KEY); 498 499 writel(phy_control, NETX_SYSTEM_PHY_CONTROL); 500 501 return platform_driver_register(&netx_eth_driver); 502} 503 504static void __exit netx_eth_cleanup(void) 505{ 506 platform_driver_unregister(&netx_eth_driver); 507} 508 509module_init(netx_eth_init); 510module_exit(netx_eth_cleanup); 511 512MODULE_AUTHOR("Sascha Hauer, Pengutronix"); 513MODULE_LICENSE("GPL"); 514