drivers/net/altera_tse.c

   1 /*
   2  * Altera 10/100/1000 triple speed ethernet mac driver
   3  *
   4  * Copyright (C) 2008 Altera Corporation.
   5  * Copyright (C) 2010 Thomas Chou <thomas@wytron.com.tw>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11 #include <common.h>
  12 #include <cpu_func.h>
  13 #include <dm.h>
  14 #include <errno.h>
  15 #include <fdt_support.h>
  16 #include <log.h>
  17 #include <memalign.h>
  18 #include <miiphy.h>
  19 #include <net.h>
  20 #include <asm/cache.h>
  21 #include <linux/dma-mapping.h>
  22 #include <asm/io.h>
  23 #include "altera_tse.h"
  24
  25 DECLARE_GLOBAL_DATA_PTR;
  26
  27 static inline void alt_sgdma_construct_descriptor(
  28         struct alt_sgdma_descriptor *desc,
  29         struct alt_sgdma_descriptor *next,
  30         void *read_addr,
  31         void *write_addr,
  32         u16 length_or_eop,
  33         int generate_eop,
  34         int read_fixed,
  35         int write_fixed_or_sop)
  36 {
  37         u8 val;
  38
  39         /*
  40          * Mark the "next" descriptor as "not" owned by hardware. This prevents
  41          * The SGDMA controller from continuing to process the chain.
  42          */
  43         next->descriptor_control = next->descriptor_control &
  44                 ~ALT_SGDMA_DESCRIPTOR_CONTROL_OWNED_BY_HW_MSK;
  45
  46         memset(desc, 0, sizeof(struct alt_sgdma_descriptor));
  47         desc->source = virt_to_phys(read_addr);
  48         desc->destination = virt_to_phys(write_addr);
  49         desc->next = virt_to_phys(next);
  50         desc->bytes_to_transfer = length_or_eop;
  51
  52         /*
  53          * Set the descriptor control block as follows:
  54          * - Set "owned by hardware" bit
  55          * - Optionally set "generate EOP" bit
  56          * - Optionally set the "read from fixed address" bit
  57          * - Optionally set the "write to fixed address bit (which serves
  58          *   serves as a "generate SOP" control bit in memory-to-stream mode).
  59          * - Set the 4-bit atlantic channel, if specified
  60          *
  61          * Note this step is performed after all other descriptor information
  62          * has been filled out so that, if the controller already happens to be
  63          * pointing at this descriptor, it will not run (via the "owned by
  64          * hardware" bit) until all other descriptor has been set up.
  65          */
  66         val = ALT_SGDMA_DESCRIPTOR_CONTROL_OWNED_BY_HW_MSK;
  67         if (generate_eop)
  68                 val |= ALT_SGDMA_DESCRIPTOR_CONTROL_GENERATE_EOP_MSK;
  69         if (read_fixed)
  70                 val |= ALT_SGDMA_DESCRIPTOR_CONTROL_READ_FIXED_ADDRESS_MSK;
  71         if (write_fixed_or_sop)
  72                 val |= ALT_SGDMA_DESCRIPTOR_CONTROL_WRITE_FIXED_ADDRESS_MSK;
  73         desc->descriptor_control = val;
  74 }
  75
  76 static int alt_sgdma_wait_transfer(struct alt_sgdma_registers *regs)
  77 {
  78         int status;
  79         ulong ctime;
  80
  81         /* Wait for the descriptor (chain) to complete */
  82         ctime = get_timer(0);
  83         while (1) {
  84                 status = readl(&regs->status);
  85                 if (!(status & ALT_SGDMA_STATUS_BUSY_MSK))
  86                         break;
  87                 if (get_timer(ctime) > ALT_TSE_SGDMA_BUSY_TIMEOUT) {
  88                         status = -ETIMEDOUT;
  89                         debug("sgdma timeout\n");
  90                         break;
  91                 }
  92         }
  93
  94         /* Clear Run */
  95         writel(0, &regs->control);
  96         /* Clear status */
  97         writel(0xff, &regs->status);
  98
  99         return status;
 100 }
 101
 102 static int alt_sgdma_start_transfer(struct alt_sgdma_registers *regs,
 103                                     struct alt_sgdma_descriptor *desc)
 104 {
 105         u32 val;
 106
 107         /* Point the controller at the descriptor */
 108         writel(virt_to_phys(desc), &regs->next_descriptor_pointer);
 109
 110         /*
 111          * Set up SGDMA controller to:
 112          * - Disable interrupt generation
 113          * - Run once a valid descriptor is written to controller
 114          * - Stop on an error with any particular descriptor
 115          */
 116         val = ALT_SGDMA_CONTROL_RUN_MSK | ALT_SGDMA_CONTROL_STOP_DMA_ER_MSK;
 117         writel(val, &regs->control);
 118
 119         return 0;
 120 }
 121
 122 static void tse_adjust_link(struct altera_tse_priv *priv,
 123                             struct phy_device *phydev)
 124 {
 125         struct alt_tse_mac *mac_dev = priv->mac_dev;
 126         u32 refvar;
 127
 128         if (!phydev->link) {
 129                 debug("%s: No link.\n", phydev->dev->name);
 130                 return;
 131         }
 132
 133         refvar = readl(&mac_dev->command_config);
 134
 135         if (phydev->duplex)
 136                 refvar |= ALTERA_TSE_CMD_HD_ENA_MSK;
 137         else
 138                 refvar &= ~ALTERA_TSE_CMD_HD_ENA_MSK;
 139
 140         switch (phydev->speed) {
 141         case 1000:
 142                 refvar |= ALTERA_TSE_CMD_ETH_SPEED_MSK;
 143                 refvar &= ~ALTERA_TSE_CMD_ENA_10_MSK;
 144                 break;
 145         case 100:
 146                 refvar &= ~ALTERA_TSE_CMD_ETH_SPEED_MSK;
 147                 refvar &= ~ALTERA_TSE_CMD_ENA_10_MSK;
 148                 break;
 149         case 10:
 150                 refvar &= ~ALTERA_TSE_CMD_ETH_SPEED_MSK;
 151                 refvar |= ALTERA_TSE_CMD_ENA_10_MSK;
 152                 break;
 153         }
 154         writel(refvar, &mac_dev->command_config);
 155 }
 156
 157 static int altera_tse_send_sgdma(struct udevice *dev, void *packet, int length)
 158 {
 159         struct altera_tse_priv *priv = dev_get_priv(dev);
 160         struct alt_sgdma_descriptor *tx_desc = priv->tx_desc;
 161
 162         alt_sgdma_construct_descriptor(
 163                 tx_desc,
 164                 tx_desc + 1,
 165                 packet, /* read addr */
 166                 NULL,   /* write addr */
 167                 length, /* length or EOP ,will change for each tx */
 168                 1,      /* gen eop */
 169                 0,      /* read fixed */
 170                 1       /* write fixed or sop */
 171                 );
 172
 173         /* send the packet */
 174         alt_sgdma_start_transfer(priv->sgdma_tx, tx_desc);
 175         alt_sgdma_wait_transfer(priv->sgdma_tx);
 176         debug("sent %d bytes\n", tx_desc->actual_bytes_transferred);
 177
 178         return tx_desc->actual_bytes_transferred;
 179 }
 180
 181 static int altera_tse_recv_sgdma(struct udevice *dev, int flags,
 182                                  uchar **packetp)
 183 {
 184         struct altera_tse_priv *priv = dev_get_priv(dev);
 185         struct alt_sgdma_descriptor *rx_desc = priv->rx_desc;
 186         int packet_length;
 187
 188         if (rx_desc->descriptor_status &
 189             ALT_SGDMA_DESCRIPTOR_STATUS_TERMINATED_BY_EOP_MSK) {
 190                 alt_sgdma_wait_transfer(priv->sgdma_rx);
 191                 packet_length = rx_desc->actual_bytes_transferred;
 192                 debug("recv %d bytes\n", packet_length);
 193                 *packetp = priv->rx_buf;
 194
 195                 return packet_length;
 196         }
 197
 198         return -EAGAIN;
 199 }
 200
 201 static int altera_tse_free_pkt_sgdma(struct udevice *dev, uchar *packet,
 202                                      int length)
 203 {
 204         struct altera_tse_priv *priv = dev_get_priv(dev);
 205         struct alt_sgdma_descriptor *rx_desc = priv->rx_desc;
 206
 207         alt_sgdma_construct_descriptor(
 208                 rx_desc,
 209                 rx_desc + 1,
 210                 NULL,   /* read addr */
 211                 priv->rx_buf, /* write addr */
 212                 0,      /* length or EOP */
 213                 0,      /* gen eop */
 214                 0,      /* read fixed */
 215                 0       /* write fixed or sop */
 216                 );
 217
 218         /* setup the sgdma */
 219         alt_sgdma_start_transfer(priv->sgdma_rx, rx_desc);
 220         debug("recv setup\n");
 221
 222         return 0;
 223 }
 224
 225 static void altera_tse_stop_mac(struct altera_tse_priv *priv)
 226 {
 227         struct alt_tse_mac *mac_dev = priv->mac_dev;
 228         u32 status;
 229         ulong ctime;
 230
 231         /* reset the mac */
 232         writel(ALTERA_TSE_CMD_SW_RESET_MSK, &mac_dev->command_config);
 233         ctime = get_timer(0);
 234         while (1) {
 235                 status = readl(&mac_dev->command_config);
 236                 if (!(status & ALTERA_TSE_CMD_SW_RESET_MSK))
 237                         break;
 238                 if (get_timer(ctime) > ALT_TSE_SW_RESET_TIMEOUT) {
 239                         debug("Reset mac timeout\n");
 240                         break;
 241                 }
 242         }
 243 }
 244
 245 static void altera_tse_stop_sgdma(struct udevice *dev)
 246 {
 247         struct altera_tse_priv *priv = dev_get_priv(dev);
 248         struct alt_sgdma_registers *rx_sgdma = priv->sgdma_rx;
 249         struct alt_sgdma_registers *tx_sgdma = priv->sgdma_tx;
 250         struct alt_sgdma_descriptor *rx_desc = priv->rx_desc;
 251         int ret;
 252
 253         /* clear rx desc & wait for sgdma to complete */
 254         rx_desc->descriptor_control = 0;
 255         writel(0, &rx_sgdma->control);
 256         ret = alt_sgdma_wait_transfer(rx_sgdma);
 257         if (ret == -ETIMEDOUT)
 258                 writel(ALT_SGDMA_CONTROL_SOFTWARERESET_MSK,
 259                        &rx_sgdma->control);
 260
 261         writel(0, &tx_sgdma->control);
 262         ret = alt_sgdma_wait_transfer(tx_sgdma);
 263         if (ret == -ETIMEDOUT)
 264                 writel(ALT_SGDMA_CONTROL_SOFTWARERESET_MSK,
 265                        &tx_sgdma->control);
 266 }
 267
 268 static void msgdma_reset(struct msgdma_csr *csr)
 269 {
 270         u32 status;
 271         ulong ctime;
 272
 273         /* Reset mSGDMA */
 274         writel(MSGDMA_CSR_STAT_MASK, &csr->status);
 275         writel(MSGDMA_CSR_CTL_RESET, &csr->control);
 276         ctime = get_timer(0);
 277         while (1) {
 278                 status = readl(&csr->status);
 279                 if (!(status & MSGDMA_CSR_STAT_RESETTING))
 280                         break;
 281                 if (get_timer(ctime) > ALT_TSE_SW_RESET_TIMEOUT) {
 282                         debug("Reset msgdma timeout\n");
 283                         break;
 284                 }
 285         }
 286         /* Clear status */
 287         writel(MSGDMA_CSR_STAT_MASK, &csr->status);
 288 }
 289
 290 static u32 msgdma_wait(struct msgdma_csr *csr)
 291 {
 292         u32 status;
 293         ulong ctime;
 294
 295         /* Wait for the descriptor to complete */
 296         ctime = get_timer(0);
 297         while (1) {
 298                 status = readl(&csr->status);
 299                 if (!(status & MSGDMA_CSR_STAT_BUSY))
 300                         break;
 301                 if (get_timer(ctime) > ALT_TSE_SGDMA_BUSY_TIMEOUT) {
 302                         debug("sgdma timeout\n");
 303                         break;
 304                 }
 305         }
 306         /* Clear status */
 307         writel(MSGDMA_CSR_STAT_MASK, &csr->status);
 308
 309         return status;
 310 }
 311
 312 static int altera_tse_send_msgdma(struct udevice *dev, void *packet,
 313                                   int length)
 314 {
 315         struct altera_tse_priv *priv = dev_get_priv(dev);
 316         struct msgdma_extended_desc *desc = priv->tx_desc;
 317         u32 tx_buf = virt_to_phys(packet);
 318         u32 status;
 319
 320         writel(tx_buf, &desc->read_addr_lo);
 321         writel(0, &desc->read_addr_hi);
 322         writel(0, &desc->write_addr_lo);
 323         writel(0, &desc->write_addr_hi);
 324         writel(length, &desc->len);
 325         writel(0, &desc->burst_seq_num);
 326         writel(MSGDMA_DESC_TX_STRIDE, &desc->stride);
 327         writel(MSGDMA_DESC_CTL_TX_SINGLE, &desc->control);
 328         status = msgdma_wait(priv->sgdma_tx);
 329         debug("sent %d bytes, status %08x\n", length, status);
 330
 331         return 0;
 332 }
 333
 334 static int altera_tse_recv_msgdma(struct udevice *dev, int flags,
 335                                   uchar **packetp)
 336 {
 337         struct altera_tse_priv *priv = dev_get_priv(dev);
 338         struct msgdma_csr *csr = priv->sgdma_rx;
 339         struct msgdma_response *resp = priv->rx_resp;
 340         u32 level, length, status;
 341
 342         level = readl(&csr->resp_fill_level);
 343         if (level & 0xffff) {
 344                 length = readl(&resp->bytes_transferred);
 345                 status = readl(&resp->status);
 346                 debug("recv %d bytes, status %08x\n", length, status);
 347                 *packetp = priv->rx_buf;
 348
 349                 return length;
 350         }
 351
 352         return -EAGAIN;
 353 }
 354
 355 static int altera_tse_free_pkt_msgdma(struct udevice *dev, uchar *packet,
 356                                       int length)
 357 {
 358         struct altera_tse_priv *priv = dev_get_priv(dev);
 359         struct msgdma_extended_desc *desc = priv->rx_desc;
 360         u32 rx_buf = virt_to_phys(priv->rx_buf);
 361
 362         writel(0, &desc->read_addr_lo);
 363         writel(0, &desc->read_addr_hi);
 364         writel(rx_buf, &desc->write_addr_lo);
 365         writel(0, &desc->write_addr_hi);
 366         writel(PKTSIZE_ALIGN, &desc->len);
 367         writel(0, &desc->burst_seq_num);
 368         writel(MSGDMA_DESC_RX_STRIDE, &desc->stride);
 369         writel(MSGDMA_DESC_CTL_RX_SINGLE, &desc->control);
 370         debug("recv setup\n");
 371
 372         return 0;
 373 }
 374
 375 static void altera_tse_stop_msgdma(struct udevice *dev)
 376 {
 377         struct altera_tse_priv *priv = dev_get_priv(dev);
 378
 379         msgdma_reset(priv->sgdma_rx);
 380         msgdma_reset(priv->sgdma_tx);
 381 }
 382
 383 static int tse_mdio_read(struct mii_dev *bus, int addr, int devad, int reg)
 384 {
 385         struct altera_tse_priv *priv = bus->priv;
 386         struct alt_tse_mac *mac_dev = priv->mac_dev;
 387         u32 value;
 388
 389         /* set mdio address */
 390         writel(addr, &mac_dev->mdio_phy1_addr);
 391         /* get the data */
 392         value = readl(&mac_dev->mdio_phy1[reg]);
 393
 394         return value & 0xffff;
 395 }
 396
 397 static int tse_mdio_write(struct mii_dev *bus, int addr, int devad, int reg,
 398                           u16 val)
 399 {
 400         struct altera_tse_priv *priv = bus->priv;
 401         struct alt_tse_mac *mac_dev = priv->mac_dev;
 402
 403         /* set mdio address */
 404         writel(addr, &mac_dev->mdio_phy1_addr);
 405         /* set the data */
 406         writel(val, &mac_dev->mdio_phy1[reg]);
 407
 408         return 0;
 409 }
 410
 411 static int tse_mdio_init(const char *name, struct altera_tse_priv *priv)
 412 {
 413         struct mii_dev *bus = mdio_alloc();
 414
 415         if (!bus) {
 416                 printf("Failed to allocate MDIO bus\n");
 417                 return -ENOMEM;
 418         }
 419
 420         bus->read = tse_mdio_read;
 421         bus->write = tse_mdio_write;
 422         snprintf(bus->name, sizeof(bus->name), "%s", name);
 423
 424         bus->priv = (void *)priv;
 425
 426         return mdio_register(bus);
 427 }
 428
 429 static int tse_phy_init(struct altera_tse_priv *priv, void *dev)
 430 {
 431         struct phy_device *phydev;
 432         unsigned int mask = 0xffffffff;
 433
 434         if (priv->phyaddr)
 435                 mask = 1 << priv->phyaddr;
 436
 437         phydev = phy_find_by_mask(priv->bus, mask, priv->interface);
 438         if (!phydev)
 439                 return -ENODEV;
 440
 441         phy_connect_dev(phydev, dev);
 442
 443         phydev->supported &= PHY_GBIT_FEATURES;
 444         phydev->advertising = phydev->supported;
 445
 446         priv->phydev = phydev;
 447         phy_config(phydev);
 448
 449         return 0;
 450 }
 451
 452 static int altera_tse_write_hwaddr(struct udevice *dev)
 453 {
 454         struct altera_tse_priv *priv = dev_get_priv(dev);
 455         struct alt_tse_mac *mac_dev = priv->mac_dev;
 456         struct eth_pdata *pdata = dev_get_platdata(dev);
 457         u8 *hwaddr = pdata->enetaddr;
 458         u32 mac_lo, mac_hi;
 459
 460         mac_lo = (hwaddr[3] << 24) | (hwaddr[2] << 16) |
 461                 (hwaddr[1] << 8) | hwaddr[0];
 462         mac_hi = (hwaddr[5] << 8) | hwaddr[4];
 463         debug("Set MAC address to 0x%04x%08x\n", mac_hi, mac_lo);
 464
 465         writel(mac_lo, &mac_dev->mac_addr_0);
 466         writel(mac_hi, &mac_dev->mac_addr_1);
 467         writel(mac_lo, &mac_dev->supp_mac_addr_0_0);
 468         writel(mac_hi, &mac_dev->supp_mac_addr_0_1);
 469         writel(mac_lo, &mac_dev->supp_mac_addr_1_0);
 470         writel(mac_hi, &mac_dev->supp_mac_addr_1_1);
 471         writel(mac_lo, &mac_dev->supp_mac_addr_2_0);
 472         writel(mac_hi, &mac_dev->supp_mac_addr_2_1);
 473         writel(mac_lo, &mac_dev->supp_mac_addr_3_0);
 474         writel(mac_hi, &mac_dev->supp_mac_addr_3_1);
 475
 476         return 0;
 477 }
 478
 479 static int altera_tse_send(struct udevice *dev, void *packet, int length)
 480 {
 481         struct altera_tse_priv *priv = dev_get_priv(dev);
 482         unsigned long tx_buf = (unsigned long)packet;
 483
 484         flush_dcache_range(tx_buf, tx_buf + length);
 485
 486         return priv->ops->send(dev, packet, length);
 487 }
 488
 489 static int altera_tse_recv(struct udevice *dev, int flags, uchar **packetp)
 490 {
 491         struct altera_tse_priv *priv = dev_get_priv(dev);
 492
 493         return priv->ops->recv(dev, flags, packetp);
 494 }
 495
 496 static int altera_tse_free_pkt(struct udevice *dev, uchar *packet,
 497                                int length)
 498 {
 499         struct altera_tse_priv *priv = dev_get_priv(dev);
 500         unsigned long rx_buf = (unsigned long)priv->rx_buf;
 501
 502         invalidate_dcache_range(rx_buf, rx_buf + PKTSIZE_ALIGN);
 503
 504         return priv->ops->free_pkt(dev, packet, length);
 505 }
 506
 507 static void altera_tse_stop(struct udevice *dev)
 508 {
 509         struct altera_tse_priv *priv = dev_get_priv(dev);
 510
 511         priv->ops->stop(dev);
 512         altera_tse_stop_mac(priv);
 513 }
 514
 515 static int altera_tse_start(struct udevice *dev)
 516 {
 517         struct altera_tse_priv *priv = dev_get_priv(dev);
 518         struct alt_tse_mac *mac_dev = priv->mac_dev;
 519         u32 val;
 520         int ret;
 521
 522         /* need to create sgdma */
 523         debug("Configuring rx desc\n");
 524         altera_tse_free_pkt(dev, priv->rx_buf, PKTSIZE_ALIGN);
 525         /* start TSE */
 526         debug("Configuring TSE Mac\n");
 527         /* Initialize MAC registers */
 528         writel(PKTSIZE_ALIGN, &mac_dev->max_frame_length);
 529         writel(priv->rx_fifo_depth - 16, &mac_dev->rx_sel_empty_threshold);
 530         writel(0, &mac_dev->rx_sel_full_threshold);
 531         writel(priv->tx_fifo_depth - 16, &mac_dev->tx_sel_empty_threshold);
 532         writel(0, &mac_dev->tx_sel_full_threshold);
 533         writel(8, &mac_dev->rx_almost_empty_threshold);
 534         writel(8, &mac_dev->rx_almost_full_threshold);
 535         writel(8, &mac_dev->tx_almost_empty_threshold);
 536         writel(3, &mac_dev->tx_almost_full_threshold);
 537
 538         /* NO Shift */
 539         writel(0, &mac_dev->rx_cmd_stat);
 540         writel(0, &mac_dev->tx_cmd_stat);
 541
 542         /* enable MAC */
 543         val = ALTERA_TSE_CMD_TX_ENA_MSK | ALTERA_TSE_CMD_RX_ENA_MSK;
 544         writel(val, &mac_dev->command_config);
 545
 546         /* Start up the PHY */
 547         ret = phy_startup(priv->phydev);
 548         if (ret) {
 549                 debug("Could not initialize PHY %s\n",
 550                       priv->phydev->dev->name);
 551                 return ret;
 552         }
 553
 554         tse_adjust_link(priv, priv->phydev);
 555
 556         if (!priv->phydev->link)
 557                 return -EIO;
 558
 559         return 0;
 560 }
 561
 562 static const struct tse_ops tse_sgdma_ops = {
 563         .send           = altera_tse_send_sgdma,
 564         .recv           = altera_tse_recv_sgdma,
 565         .free_pkt       = altera_tse_free_pkt_sgdma,
 566         .stop           = altera_tse_stop_sgdma,
 567 };
 568
 569 static const struct tse_ops tse_msgdma_ops = {
 570         .send           = altera_tse_send_msgdma,
 571         .recv           = altera_tse_recv_msgdma,
 572         .free_pkt       = altera_tse_free_pkt_msgdma,
 573         .stop           = altera_tse_stop_msgdma,
 574 };
 575
 576 static int altera_tse_probe(struct udevice *dev)
 577 {
 578         struct eth_pdata *pdata = dev_get_platdata(dev);
 579         struct altera_tse_priv *priv = dev_get_priv(dev);
 580         void *blob = (void *)gd->fdt_blob;
 581         int node = dev_of_offset(dev);
 582         const char *list, *end;
 583         const fdt32_t *cell;
 584         void *base, *desc_mem = NULL;
 585         unsigned long addr, size;
 586         int parent, addrc, sizec;
 587         int len, idx;
 588         int ret;
 589
 590         priv->dma_type = dev_get_driver_data(dev);
 591         if (priv->dma_type == ALT_SGDMA)
 592                 priv->ops = &tse_sgdma_ops;
 593         else
 594                 priv->ops = &tse_msgdma_ops;
 595         /*
 596          * decode regs. there are multiple reg tuples, and they need to
 597          * match with reg-names.
 598          */
 599         parent = fdt_parent_offset(blob, node);
 600         fdt_support_default_count_cells(blob, parent, &addrc, &sizec);
 601         list = fdt_getprop(blob, node, "reg-names", &len);
 602         if (!list)
 603                 return -ENOENT;
 604         end = list + len;
 605         cell = fdt_getprop(blob, node, "reg", &len);
 606         if (!cell)
 607                 return -ENOENT;
 608         idx = 0;
 609         while (list < end) {
 610                 addr = fdt_translate_address((void *)blob,
 611                                              node, cell + idx);
 612                 size = fdt_addr_to_cpu(cell[idx + addrc]);
 613                 base = map_physmem(addr, size, MAP_NOCACHE);
 614                 len = strlen(list);
 615                 if (strcmp(list, "control_port") == 0)
 616                         priv->mac_dev = base;
 617                 else if (strcmp(list, "rx_csr") == 0)
 618                         priv->sgdma_rx = base;
 619                 else if (strcmp(list, "rx_desc") == 0)
 620                         priv->rx_desc = base;
 621                 else if (strcmp(list, "rx_resp") == 0)
 622                         priv->rx_resp = base;
 623                 else if (strcmp(list, "tx_csr") == 0)
 624                         priv->sgdma_tx = base;
 625                 else if (strcmp(list, "tx_desc") == 0)
 626                         priv->tx_desc = base;
 627                 else if (strcmp(list, "s1") == 0)
 628                         desc_mem = base;
 629                 idx += addrc + sizec;
 630                 list += (len + 1);
 631         }
 632         /* decode fifo depth */
 633         priv->rx_fifo_depth = fdtdec_get_int(blob, node,
 634                 "rx-fifo-depth", 0);
 635         priv->tx_fifo_depth = fdtdec_get_int(blob, node,
 636                 "tx-fifo-depth", 0);
 637         /* decode phy */
 638         addr = fdtdec_get_int(blob, node,
 639                               "phy-handle", 0);
 640         addr = fdt_node_offset_by_phandle(blob, addr);
 641         priv->phyaddr = fdtdec_get_int(blob, addr,
 642                 "reg", 0);
 643         /* init desc */
 644         if (priv->dma_type == ALT_SGDMA) {
 645                 len = sizeof(struct alt_sgdma_descriptor) * 4;
 646                 if (!desc_mem) {
 647                         desc_mem = dma_alloc_coherent(len, &addr);
 648                         if (!desc_mem)
 649                                 return -ENOMEM;
 650                 }
 651                 memset(desc_mem, 0, len);
 652                 priv->tx_desc = desc_mem;
 653                 priv->rx_desc = priv->tx_desc +
 654                         2 * sizeof(struct alt_sgdma_descriptor);
 655         }
 656         /* allocate recv packet buffer */
 657         priv->rx_buf = malloc_cache_aligned(PKTSIZE_ALIGN);
 658         if (!priv->rx_buf)
 659                 return -ENOMEM;
 660
 661         /* stop controller */
 662         debug("Reset TSE & SGDMAs\n");
 663         altera_tse_stop(dev);
 664
 665         /* start the phy */
 666         priv->interface = pdata->phy_interface;
 667         tse_mdio_init(dev->name, priv);
 668         priv->bus = miiphy_get_dev_by_name(dev->name);
 669
 670         ret = tse_phy_init(priv, dev);
 671
 672         return ret;
 673 }
 674
 675 static int altera_tse_ofdata_to_platdata(struct udevice *dev)
 676 {
 677         struct eth_pdata *pdata = dev_get_platdata(dev);
 678         const char *phy_mode;
 679
 680         pdata->phy_interface = -1;
 681         phy_mode = fdt_getprop(gd->fdt_blob, dev_of_offset(dev), "phy-mode",
 682                                NULL);
 683         if (phy_mode)
 684                 pdata->phy_interface = phy_get_interface_by_name(phy_mode);
 685         if (pdata->phy_interface == -1) {
 686                 debug("%s: Invalid PHY interface '%s'\n", __func__, phy_mode);
 687                 return -EINVAL;
 688         }
 689
 690         return 0;
 691 }
 692
 693 static const struct eth_ops altera_tse_ops = {
 694         .start          = altera_tse_start,
 695         .send           = altera_tse_send,
 696         .recv           = altera_tse_recv,
 697         .free_pkt       = altera_tse_free_pkt,
 698         .stop           = altera_tse_stop,
 699         .write_hwaddr   = altera_tse_write_hwaddr,
 700 };
 701
 702 static const struct udevice_id altera_tse_ids[] = {
 703         { .compatible = "altr,tse-msgdma-1.0", .data = ALT_MSGDMA },
 704         { .compatible = "altr,tse-1.0", .data = ALT_SGDMA },
 705         {}
 706 };
 707
 708 U_BOOT_DRIVER(altera_tse) = {
 709         .name   = "altera_tse",
 710         .id     = UCLASS_ETH,
 711         .of_match = altera_tse_ids,
 712         .ops    = &altera_tse_ops,
 713         .ofdata_to_platdata = altera_tse_ofdata_to_platdata,
 714         .platdata_auto_alloc_size = sizeof(struct eth_pdata),
 715         .priv_auto_alloc_size = sizeof(struct altera_tse_priv),
 716         .probe  = altera_tse_probe,
 717 };