1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Lantiq / Intel PMAC driver for XRX200 SoCs 4 * 5 * Copyright (C) 2010 Lantiq Deutschland 6 * Copyright (C) 2012 John Crispin <john@phrozen.org> 7 * Copyright (C) 2017 - 2018 Hauke Mehrtens <hauke@hauke-m.de> 8 */ 9 10 #include <linux/etherdevice.h> 11 #include <linux/module.h> 12 #include <linux/platform_device.h> 13 #include <linux/interrupt.h> 14 #include <linux/clk.h> 15 #include <linux/delay.h> 16 17 #include <linux/if_vlan.h> 18 19 #include <linux/of_net.h> 20 #include <linux/of_platform.h> 21 22 #include <xway_dma.h> 23 24 /* DMA */ 25 #define XRX200_DMA_DATA_LEN (SZ_64K - 1) 26 #define XRX200_DMA_RX 0 27 #define XRX200_DMA_TX 1 28 #define XRX200_DMA_BURST_LEN 8 29 30 #define XRX200_DMA_PACKET_COMPLETE 0 31 #define XRX200_DMA_PACKET_IN_PROGRESS 1 32 33 /* cpu port mac */ 34 #define PMAC_RX_IPG 0x0024 35 #define PMAC_RX_IPG_MASK 0xf 36 37 #define PMAC_HD_CTL 0x0000 38 /* Add Ethernet header to packets from DMA to PMAC */ 39 #define PMAC_HD_CTL_ADD BIT(0) 40 /* Add VLAN tag to Packets from DMA to PMAC */ 41 #define PMAC_HD_CTL_TAG BIT(1) 42 /* Add CRC to packets from DMA to PMAC */ 43 #define PMAC_HD_CTL_AC BIT(2) 44 /* Add status header to packets from PMAC to DMA */ 45 #define PMAC_HD_CTL_AS BIT(3) 46 /* Remove CRC from packets from PMAC to DMA */ 47 #define PMAC_HD_CTL_RC BIT(4) 48 /* Remove Layer-2 header from packets from PMAC to DMA */ 49 #define PMAC_HD_CTL_RL2 BIT(5) 50 /* Status header is present from DMA to PMAC */ 51 #define PMAC_HD_CTL_RXSH BIT(6) 52 /* Add special tag from PMAC to switch */ 53 #define PMAC_HD_CTL_AST BIT(7) 54 /* Remove specail Tag from PMAC to DMA */ 55 #define PMAC_HD_CTL_RST BIT(8) 56 /* Check CRC from DMA to PMAC */ 57 #define PMAC_HD_CTL_CCRC BIT(9) 58 /* Enable reaction to Pause frames in the PMAC */ 59 #define PMAC_HD_CTL_FC BIT(10) 60 61 struct xrx200_chan { 62 int tx_free; 63 64 struct napi_struct napi; 65 struct ltq_dma_channel dma; 66 67 union { 68 struct sk_buff *skb[LTQ_DESC_NUM]; 69 void *rx_buff[LTQ_DESC_NUM]; 70 }; 71 72 struct sk_buff *skb_head; 73 struct sk_buff *skb_tail; 74 75 struct xrx200_priv *priv; 76 }; 77 78 struct xrx200_priv { 79 struct clk *clk; 80 81 struct xrx200_chan chan_tx; 82 struct xrx200_chan chan_rx; 83 84 u16 rx_buf_size; 85 u16 rx_skb_size; 86 87 struct net_device *net_dev; 88 struct device *dev; 89 90 __iomem void *pmac_reg; 91 }; 92 93 static u32 xrx200_pmac_r32(struct xrx200_priv *priv, u32 offset) 94 { 95 return __raw_readl(priv->pmac_reg + offset); 96 } 97 98 static void xrx200_pmac_w32(struct xrx200_priv *priv, u32 val, u32 offset) 99 { 100 __raw_writel(val, priv->pmac_reg + offset); 101 } 102 103 static void xrx200_pmac_mask(struct xrx200_priv *priv, u32 clear, u32 set, 104 u32 offset) 105 { 106 u32 val = xrx200_pmac_r32(priv, offset); 107 108 val &= ~(clear); 109 val |= set; 110 xrx200_pmac_w32(priv, val, offset); 111 } 112 113 static int xrx200_max_frame_len(int mtu) 114 { 115 return VLAN_ETH_HLEN + mtu; 116 } 117 118 static int xrx200_buffer_size(int mtu) 119 { 120 return round_up(xrx200_max_frame_len(mtu), 4 * XRX200_DMA_BURST_LEN); 121 } 122 123 static int xrx200_skb_size(u16 buf_size) 124 { 125 return SKB_DATA_ALIGN(buf_size + NET_SKB_PAD + NET_IP_ALIGN) + 126 SKB_DATA_ALIGN(sizeof(struct skb_shared_info)); 127 } 128 129 /* drop all the packets from the DMA ring */ 130 static void xrx200_flush_dma(struct xrx200_chan *ch) 131 { 132 int i; 133 134 for (i = 0; i < LTQ_DESC_NUM; i++) { 135 struct ltq_dma_desc *desc = &ch->dma.desc_base[ch->dma.desc]; 136 137 if ((desc->ctl & (LTQ_DMA_OWN | LTQ_DMA_C)) != LTQ_DMA_C) 138 break; 139 140 desc->ctl = LTQ_DMA_OWN | LTQ_DMA_RX_OFFSET(NET_IP_ALIGN) | 141 ch->priv->rx_buf_size; 142 ch->dma.desc++; 143 ch->dma.desc %= LTQ_DESC_NUM; 144 } 145 } 146 147 static int xrx200_open(struct net_device *net_dev) 148 { 149 struct xrx200_priv *priv = netdev_priv(net_dev); 150 151 napi_enable(&priv->chan_tx.napi); 152 ltq_dma_open(&priv->chan_tx.dma); 153 ltq_dma_enable_irq(&priv->chan_tx.dma); 154 155 napi_enable(&priv->chan_rx.napi); 156 ltq_dma_open(&priv->chan_rx.dma); 157 /* The boot loader does not always deactivate the receiving of frames 158 * on the ports and then some packets queue up in the PPE buffers. 159 * They already passed the PMAC so they do not have the tags 160 * configured here. Read the these packets here and drop them. 161 * The HW should have written them into memory after 10us 162 */ 163 usleep_range(20, 40); 164 xrx200_flush_dma(&priv->chan_rx); 165 ltq_dma_enable_irq(&priv->chan_rx.dma); 166 167 netif_wake_queue(net_dev); 168 169 return 0; 170 } 171 172 static int xrx200_close(struct net_device *net_dev) 173 { 174 struct xrx200_priv *priv = netdev_priv(net_dev); 175 176 netif_stop_queue(net_dev); 177 178 napi_disable(&priv->chan_rx.napi); 179 ltq_dma_close(&priv->chan_rx.dma); 180 181 napi_disable(&priv->chan_tx.napi); 182 ltq_dma_close(&priv->chan_tx.dma); 183 184 return 0; 185 } 186 187 static int xrx200_alloc_buf(struct xrx200_chan *ch, void *(*alloc)(unsigned int size)) 188 { 189 void *buf = ch->rx_buff[ch->dma.desc]; 190 struct xrx200_priv *priv = ch->priv; 191 dma_addr_t mapping; 192 int ret = 0; 193 194 ch->rx_buff[ch->dma.desc] = alloc(priv->rx_skb_size); 195 if (!ch->rx_buff[ch->dma.desc]) { 196 ret = -ENOMEM; 197 goto skip; 198 } 199 200 mapping = dma_map_single(priv->dev, ch->rx_buff[ch->dma.desc], 201 priv->rx_buf_size, DMA_FROM_DEVICE); 202 if (unlikely(dma_mapping_error(priv->dev, mapping))) { 203 skb_free_frag(ch->rx_buff[ch->dma.desc]); 204 ch->rx_buff[ch->dma.desc] = buf; 205 ret = -ENOMEM; 206 goto skip; 207 } 208 209 ch->dma.desc_base[ch->dma.desc].addr = mapping + NET_SKB_PAD + NET_IP_ALIGN; 210 /* Make sure the address is written before we give it to HW */ 211 wmb(); 212 skip: 213 ch->dma.desc_base[ch->dma.desc].ctl = 214 LTQ_DMA_OWN | LTQ_DMA_RX_OFFSET(NET_IP_ALIGN) | priv->rx_buf_size; 215 216 return ret; 217 } 218 219 static int xrx200_hw_receive(struct xrx200_chan *ch) 220 { 221 struct xrx200_priv *priv = ch->priv; 222 struct ltq_dma_desc *desc = &ch->dma.desc_base[ch->dma.desc]; 223 void *buf = ch->rx_buff[ch->dma.desc]; 224 u32 ctl = desc->ctl; 225 int len = (ctl & LTQ_DMA_SIZE_MASK); 226 struct net_device *net_dev = priv->net_dev; 227 struct sk_buff *skb; 228 int ret; 229 230 ret = xrx200_alloc_buf(ch, napi_alloc_frag); 231 232 ch->dma.desc++; 233 ch->dma.desc %= LTQ_DESC_NUM; 234 235 if (ret) { 236 net_dev->stats.rx_dropped++; 237 netdev_err(net_dev, "failed to allocate new rx buffer\n"); 238 return ret; 239 } 240 241 skb = build_skb(buf, priv->rx_skb_size); 242 skb_reserve(skb, NET_SKB_PAD); 243 skb_put(skb, len); 244 245 /* add buffers to skb via skb->frag_list */ 246 if (ctl & LTQ_DMA_SOP) { 247 ch->skb_head = skb; 248 ch->skb_tail = skb; 249 skb_reserve(skb, NET_IP_ALIGN); 250 } else if (ch->skb_head) { 251 if (ch->skb_head == ch->skb_tail) 252 skb_shinfo(ch->skb_tail)->frag_list = skb; 253 else 254 ch->skb_tail->next = skb; 255 ch->skb_tail = skb; 256 ch->skb_head->len += skb->len; 257 ch->skb_head->data_len += skb->len; 258 ch->skb_head->truesize += skb->truesize; 259 } 260 261 if (ctl & LTQ_DMA_EOP) { 262 ch->skb_head->protocol = eth_type_trans(ch->skb_head, net_dev); 263 net_dev->stats.rx_packets++; 264 net_dev->stats.rx_bytes += ch->skb_head->len; 265 netif_receive_skb(ch->skb_head); 266 ch->skb_head = NULL; 267 ch->skb_tail = NULL; 268 ret = XRX200_DMA_PACKET_COMPLETE; 269 } else { 270 ret = XRX200_DMA_PACKET_IN_PROGRESS; 271 } 272 273 return ret; 274 } 275 276 static int xrx200_poll_rx(struct napi_struct *napi, int budget) 277 { 278 struct xrx200_chan *ch = container_of(napi, 279 struct xrx200_chan, napi); 280 int rx = 0; 281 int ret; 282 283 while (rx < budget) { 284 struct ltq_dma_desc *desc = &ch->dma.desc_base[ch->dma.desc]; 285 286 if ((desc->ctl & (LTQ_DMA_OWN | LTQ_DMA_C)) == LTQ_DMA_C) { 287 ret = xrx200_hw_receive(ch); 288 if (ret == XRX200_DMA_PACKET_IN_PROGRESS) 289 continue; 290 if (ret != XRX200_DMA_PACKET_COMPLETE) 291 return ret; 292 rx++; 293 } else { 294 break; 295 } 296 } 297 298 if (rx < budget) { 299 if (napi_complete_done(&ch->napi, rx)) 300 ltq_dma_enable_irq(&ch->dma); 301 } 302 303 return rx; 304 } 305 306 static int xrx200_tx_housekeeping(struct napi_struct *napi, int budget) 307 { 308 struct xrx200_chan *ch = container_of(napi, 309 struct xrx200_chan, napi); 310 struct net_device *net_dev = ch->priv->net_dev; 311 int pkts = 0; 312 int bytes = 0; 313 314 netif_tx_lock(net_dev); 315 while (pkts < budget) { 316 struct ltq_dma_desc *desc = &ch->dma.desc_base[ch->tx_free]; 317 318 if ((desc->ctl & (LTQ_DMA_OWN | LTQ_DMA_C)) == LTQ_DMA_C) { 319 struct sk_buff *skb = ch->skb[ch->tx_free]; 320 321 pkts++; 322 bytes += skb->len; 323 ch->skb[ch->tx_free] = NULL; 324 consume_skb(skb); 325 memset(&ch->dma.desc_base[ch->tx_free], 0, 326 sizeof(struct ltq_dma_desc)); 327 ch->tx_free++; 328 ch->tx_free %= LTQ_DESC_NUM; 329 } else { 330 break; 331 } 332 } 333 334 net_dev->stats.tx_packets += pkts; 335 net_dev->stats.tx_bytes += bytes; 336 netdev_completed_queue(ch->priv->net_dev, pkts, bytes); 337 338 netif_tx_unlock(net_dev); 339 if (netif_queue_stopped(net_dev)) 340 netif_wake_queue(net_dev); 341 342 if (pkts < budget) { 343 if (napi_complete_done(&ch->napi, pkts)) 344 ltq_dma_enable_irq(&ch->dma); 345 } 346 347 return pkts; 348 } 349 350 static netdev_tx_t xrx200_start_xmit(struct sk_buff *skb, 351 struct net_device *net_dev) 352 { 353 struct xrx200_priv *priv = netdev_priv(net_dev); 354 struct xrx200_chan *ch = &priv->chan_tx; 355 struct ltq_dma_desc *desc = &ch->dma.desc_base[ch->dma.desc]; 356 u32 byte_offset; 357 dma_addr_t mapping; 358 int len; 359 360 skb->dev = net_dev; 361 if (skb_put_padto(skb, ETH_ZLEN)) { 362 net_dev->stats.tx_dropped++; 363 return NETDEV_TX_OK; 364 } 365 366 len = skb->len; 367 368 if ((desc->ctl & (LTQ_DMA_OWN | LTQ_DMA_C)) || ch->skb[ch->dma.desc]) { 369 netdev_err(net_dev, "tx ring full\n"); 370 netif_stop_queue(net_dev); 371 return NETDEV_TX_BUSY; 372 } 373 374 ch->skb[ch->dma.desc] = skb; 375 376 mapping = dma_map_single(priv->dev, skb->data, len, DMA_TO_DEVICE); 377 if (unlikely(dma_mapping_error(priv->dev, mapping))) 378 goto err_drop; 379 380 /* dma needs to start on a burst length value aligned address */ 381 byte_offset = mapping % (XRX200_DMA_BURST_LEN * 4); 382 383 desc->addr = mapping - byte_offset; 384 /* Make sure the address is written before we give it to HW */ 385 wmb(); 386 desc->ctl = LTQ_DMA_OWN | LTQ_DMA_SOP | LTQ_DMA_EOP | 387 LTQ_DMA_TX_OFFSET(byte_offset) | (len & LTQ_DMA_SIZE_MASK); 388 ch->dma.desc++; 389 ch->dma.desc %= LTQ_DESC_NUM; 390 if (ch->dma.desc == ch->tx_free) 391 netif_stop_queue(net_dev); 392 393 netdev_sent_queue(net_dev, len); 394 395 return NETDEV_TX_OK; 396 397 err_drop: 398 dev_kfree_skb(skb); 399 net_dev->stats.tx_dropped++; 400 net_dev->stats.tx_errors++; 401 return NETDEV_TX_OK; 402 } 403 404 static int 405 xrx200_change_mtu(struct net_device *net_dev, int new_mtu) 406 { 407 struct xrx200_priv *priv = netdev_priv(net_dev); 408 struct xrx200_chan *ch_rx = &priv->chan_rx; 409 int old_mtu = net_dev->mtu; 410 bool running = false; 411 void *buff; 412 int curr_desc; 413 int ret = 0; 414 415 net_dev->mtu = new_mtu; 416 priv->rx_buf_size = xrx200_buffer_size(new_mtu); 417 priv->rx_skb_size = xrx200_skb_size(priv->rx_buf_size); 418 419 if (new_mtu <= old_mtu) 420 return ret; 421 422 running = netif_running(net_dev); 423 if (running) { 424 napi_disable(&ch_rx->napi); 425 ltq_dma_close(&ch_rx->dma); 426 } 427 428 xrx200_poll_rx(&ch_rx->napi, LTQ_DESC_NUM); 429 curr_desc = ch_rx->dma.desc; 430 431 for (ch_rx->dma.desc = 0; ch_rx->dma.desc < LTQ_DESC_NUM; 432 ch_rx->dma.desc++) { 433 buff = ch_rx->rx_buff[ch_rx->dma.desc]; 434 ret = xrx200_alloc_buf(ch_rx, netdev_alloc_frag); 435 if (ret) { 436 net_dev->mtu = old_mtu; 437 priv->rx_buf_size = xrx200_buffer_size(old_mtu); 438 priv->rx_skb_size = xrx200_skb_size(priv->rx_buf_size); 439 break; 440 } 441 skb_free_frag(buff); 442 } 443 444 ch_rx->dma.desc = curr_desc; 445 if (running) { 446 napi_enable(&ch_rx->napi); 447 ltq_dma_open(&ch_rx->dma); 448 ltq_dma_enable_irq(&ch_rx->dma); 449 } 450 451 return ret; 452 } 453 454 static const struct net_device_ops xrx200_netdev_ops = { 455 .ndo_open = xrx200_open, 456 .ndo_stop = xrx200_close, 457 .ndo_start_xmit = xrx200_start_xmit, 458 .ndo_change_mtu = xrx200_change_mtu, 459 .ndo_set_mac_address = eth_mac_addr, 460 .ndo_validate_addr = eth_validate_addr, 461 }; 462 463 static irqreturn_t xrx200_dma_irq(int irq, void *ptr) 464 { 465 struct xrx200_chan *ch = ptr; 466 467 if (napi_schedule_prep(&ch->napi)) { 468 ltq_dma_disable_irq(&ch->dma); 469 __napi_schedule(&ch->napi); 470 } 471 472 ltq_dma_ack_irq(&ch->dma); 473 474 return IRQ_HANDLED; 475 } 476 477 static int xrx200_dma_init(struct xrx200_priv *priv) 478 { 479 struct xrx200_chan *ch_rx = &priv->chan_rx; 480 struct xrx200_chan *ch_tx = &priv->chan_tx; 481 int ret = 0; 482 int i; 483 484 ltq_dma_init_port(DMA_PORT_ETOP, XRX200_DMA_BURST_LEN, 485 XRX200_DMA_BURST_LEN); 486 487 ch_rx->dma.nr = XRX200_DMA_RX; 488 ch_rx->dma.dev = priv->dev; 489 ch_rx->priv = priv; 490 491 ltq_dma_alloc_rx(&ch_rx->dma); 492 for (ch_rx->dma.desc = 0; ch_rx->dma.desc < LTQ_DESC_NUM; 493 ch_rx->dma.desc++) { 494 ret = xrx200_alloc_buf(ch_rx, netdev_alloc_frag); 495 if (ret) 496 goto rx_free; 497 } 498 ch_rx->dma.desc = 0; 499 ret = devm_request_irq(priv->dev, ch_rx->dma.irq, xrx200_dma_irq, 0, 500 "xrx200_net_rx", &priv->chan_rx); 501 if (ret) { 502 dev_err(priv->dev, "failed to request RX irq %d\n", 503 ch_rx->dma.irq); 504 goto rx_ring_free; 505 } 506 507 ch_tx->dma.nr = XRX200_DMA_TX; 508 ch_tx->dma.dev = priv->dev; 509 ch_tx->priv = priv; 510 511 ltq_dma_alloc_tx(&ch_tx->dma); 512 ret = devm_request_irq(priv->dev, ch_tx->dma.irq, xrx200_dma_irq, 0, 513 "xrx200_net_tx", &priv->chan_tx); 514 if (ret) { 515 dev_err(priv->dev, "failed to request TX irq %d\n", 516 ch_tx->dma.irq); 517 goto tx_free; 518 } 519 520 return ret; 521 522 tx_free: 523 ltq_dma_free(&ch_tx->dma); 524 525 rx_ring_free: 526 /* free the allocated RX ring */ 527 for (i = 0; i < LTQ_DESC_NUM; i++) { 528 if (priv->chan_rx.skb[i]) 529 skb_free_frag(priv->chan_rx.rx_buff[i]); 530 } 531 532 rx_free: 533 ltq_dma_free(&ch_rx->dma); 534 return ret; 535 } 536 537 static void xrx200_hw_cleanup(struct xrx200_priv *priv) 538 { 539 int i; 540 541 ltq_dma_free(&priv->chan_tx.dma); 542 ltq_dma_free(&priv->chan_rx.dma); 543 544 /* free the allocated RX ring */ 545 for (i = 0; i < LTQ_DESC_NUM; i++) 546 skb_free_frag(priv->chan_rx.rx_buff[i]); 547 } 548 549 static int xrx200_probe(struct platform_device *pdev) 550 { 551 struct device *dev = &pdev->dev; 552 struct device_node *np = dev->of_node; 553 struct xrx200_priv *priv; 554 struct net_device *net_dev; 555 int err; 556 557 /* alloc the network device */ 558 net_dev = devm_alloc_etherdev(dev, sizeof(struct xrx200_priv)); 559 if (!net_dev) 560 return -ENOMEM; 561 562 priv = netdev_priv(net_dev); 563 priv->net_dev = net_dev; 564 priv->dev = dev; 565 566 net_dev->netdev_ops = &xrx200_netdev_ops; 567 SET_NETDEV_DEV(net_dev, dev); 568 net_dev->min_mtu = ETH_ZLEN; 569 net_dev->max_mtu = XRX200_DMA_DATA_LEN - xrx200_max_frame_len(0); 570 priv->rx_buf_size = xrx200_buffer_size(ETH_DATA_LEN); 571 priv->rx_skb_size = xrx200_skb_size(priv->rx_buf_size); 572 573 /* load the memory ranges */ 574 priv->pmac_reg = devm_platform_get_and_ioremap_resource(pdev, 0, NULL); 575 if (IS_ERR(priv->pmac_reg)) 576 return PTR_ERR(priv->pmac_reg); 577 578 priv->chan_rx.dma.irq = platform_get_irq_byname(pdev, "rx"); 579 if (priv->chan_rx.dma.irq < 0) 580 return -ENOENT; 581 priv->chan_tx.dma.irq = platform_get_irq_byname(pdev, "tx"); 582 if (priv->chan_tx.dma.irq < 0) 583 return -ENOENT; 584 585 /* get the clock */ 586 priv->clk = devm_clk_get(dev, NULL); 587 if (IS_ERR(priv->clk)) { 588 dev_err(dev, "failed to get clock\n"); 589 return PTR_ERR(priv->clk); 590 } 591 592 err = of_get_ethdev_address(np, net_dev); 593 if (err) 594 eth_hw_addr_random(net_dev); 595 596 /* bring up the dma engine and IP core */ 597 err = xrx200_dma_init(priv); 598 if (err) 599 return err; 600 601 /* enable clock gate */ 602 err = clk_prepare_enable(priv->clk); 603 if (err) 604 goto err_uninit_dma; 605 606 /* set IPG to 12 */ 607 xrx200_pmac_mask(priv, PMAC_RX_IPG_MASK, 0xb, PMAC_RX_IPG); 608 609 /* enable status header, enable CRC */ 610 xrx200_pmac_mask(priv, 0, 611 PMAC_HD_CTL_RST | PMAC_HD_CTL_AST | PMAC_HD_CTL_RXSH | 612 PMAC_HD_CTL_AS | PMAC_HD_CTL_AC | PMAC_HD_CTL_RC, 613 PMAC_HD_CTL); 614 615 /* setup NAPI */ 616 netif_napi_add(net_dev, &priv->chan_rx.napi, xrx200_poll_rx, 617 NAPI_POLL_WEIGHT); 618 netif_napi_add_tx(net_dev, &priv->chan_tx.napi, 619 xrx200_tx_housekeeping); 620 621 platform_set_drvdata(pdev, priv); 622 623 err = register_netdev(net_dev); 624 if (err) 625 goto err_unprepare_clk; 626 627 return 0; 628 629 err_unprepare_clk: 630 clk_disable_unprepare(priv->clk); 631 632 err_uninit_dma: 633 xrx200_hw_cleanup(priv); 634 635 return err; 636 } 637 638 static int xrx200_remove(struct platform_device *pdev) 639 { 640 struct xrx200_priv *priv = platform_get_drvdata(pdev); 641 struct net_device *net_dev = priv->net_dev; 642 643 /* free stack related instances */ 644 netif_stop_queue(net_dev); 645 netif_napi_del(&priv->chan_tx.napi); 646 netif_napi_del(&priv->chan_rx.napi); 647 648 /* remove the actual device */ 649 unregister_netdev(net_dev); 650 651 /* release the clock */ 652 clk_disable_unprepare(priv->clk); 653 654 /* shut down hardware */ 655 xrx200_hw_cleanup(priv); 656 657 return 0; 658 } 659 660 static const struct of_device_id xrx200_match[] = { 661 { .compatible = "lantiq,xrx200-net" }, 662 {}, 663 }; 664 MODULE_DEVICE_TABLE(of, xrx200_match); 665 666 static struct platform_driver xrx200_driver = { 667 .probe = xrx200_probe, 668 .remove = xrx200_remove, 669 .driver = { 670 .name = "lantiq,xrx200-net", 671 .of_match_table = xrx200_match, 672 }, 673 }; 674 675 module_platform_driver(xrx200_driver); 676 677 MODULE_AUTHOR("John Crispin <john@phrozen.org>"); 678 MODULE_DESCRIPTION("Lantiq SoC XRX200 ethernet"); 679 MODULE_LICENSE("GPL"); 680