1 /* 2 * AMD 10Gb Ethernet driver 3 * 4 * This file is available to you under your choice of the following two 5 * licenses: 6 * 7 * License 1: GPLv2 8 * 9 * Copyright (c) 2016 Advanced Micro Devices, Inc. 10 * 11 * This file is free software; you may copy, redistribute and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation, either version 2 of the License, or (at 14 * your option) any later version. 15 * 16 * This file is distributed in the hope that it will be useful, but 17 * WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program. If not, see <http://www.gnu.org/licenses/>. 23 * 24 * This file incorporates work covered by the following copyright and 25 * permission notice: 26 * The Synopsys DWC ETHER XGMAC Software Driver and documentation 27 * (hereinafter "Software") is an unsupported proprietary work of Synopsys, 28 * Inc. unless otherwise expressly agreed to in writing between Synopsys 29 * and you. 30 * 31 * The Software IS NOT an item of Licensed Software or Licensed Product 32 * under any End User Software License Agreement or Agreement for Licensed 33 * Product with Synopsys or any supplement thereto. Permission is hereby 34 * granted, free of charge, to any person obtaining a copy of this software 35 * annotated with this license and the Software, to deal in the Software 36 * without restriction, including without limitation the rights to use, 37 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies 38 * of the Software, and to permit persons to whom the Software is furnished 39 * to do so, subject to the following conditions: 40 * 41 * The above copyright notice and this permission notice shall be included 42 * in all copies or substantial portions of the Software. 43 * 44 * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" 45 * BASIS AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 46 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 47 * PARTICULAR PURPOSE ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS 48 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 49 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 50 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 51 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 52 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 53 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 54 * THE POSSIBILITY OF SUCH DAMAGE. 55 * 56 * 57 * License 2: Modified BSD 58 * 59 * Copyright (c) 2016 Advanced Micro Devices, Inc. 60 * All rights reserved. 61 * 62 * Redistribution and use in source and binary forms, with or without 63 * modification, are permitted provided that the following conditions are met: 64 * * Redistributions of source code must retain the above copyright 65 * notice, this list of conditions and the following disclaimer. 66 * * Redistributions in binary form must reproduce the above copyright 67 * notice, this list of conditions and the following disclaimer in the 68 * documentation and/or other materials provided with the distribution. 69 * * Neither the name of Advanced Micro Devices, Inc. nor the 70 * names of its contributors may be used to endorse or promote products 71 * derived from this software without specific prior written permission. 72 * 73 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 74 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 75 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 76 * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY 77 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 78 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 79 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 80 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 81 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 82 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 83 * 84 * This file incorporates work covered by the following copyright and 85 * permission notice: 86 * The Synopsys DWC ETHER XGMAC Software Driver and documentation 87 * (hereinafter "Software") is an unsupported proprietary work of Synopsys, 88 * Inc. unless otherwise expressly agreed to in writing between Synopsys 89 * and you. 90 * 91 * The Software IS NOT an item of Licensed Software or Licensed Product 92 * under any End User Software License Agreement or Agreement for Licensed 93 * Product with Synopsys or any supplement thereto. Permission is hereby 94 * granted, free of charge, to any person obtaining a copy of this software 95 * annotated with this license and the Software, to deal in the Software 96 * without restriction, including without limitation the rights to use, 97 * copy, modify, merge, publish, distribute, sublicense, and/or sell copies 98 * of the Software, and to permit persons to whom the Software is furnished 99 * to do so, subject to the following conditions: 100 * 101 * The above copyright notice and this permission notice shall be included 102 * in all copies or substantial portions of the Software. 103 * 104 * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" 105 * BASIS AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 106 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 107 * PARTICULAR PURPOSE ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS 108 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 109 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 110 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 111 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 112 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 113 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 114 * THE POSSIBILITY OF SUCH DAMAGE. 115 */ 116 117 #include <linux/module.h> 118 #include <linux/device.h> 119 #include <linux/pci.h> 120 #include <linux/log2.h> 121 122 #include "xgbe.h" 123 #include "xgbe-common.h" 124 125 static int xgbe_config_msi(struct xgbe_prv_data *pdata) 126 { 127 unsigned int msi_count; 128 unsigned int i, j; 129 int ret; 130 131 msi_count = XGBE_MSIX_BASE_COUNT; 132 msi_count += max(pdata->rx_ring_count, 133 pdata->tx_ring_count); 134 msi_count = roundup_pow_of_two(msi_count); 135 136 ret = pci_enable_msi_exact(pdata->pcidev, msi_count); 137 if (ret < 0) { 138 dev_info(pdata->dev, "MSI request for %u interrupts failed\n", 139 msi_count); 140 141 ret = pci_enable_msi(pdata->pcidev); 142 if (ret < 0) { 143 dev_info(pdata->dev, "MSI enablement failed\n"); 144 return ret; 145 } 146 147 msi_count = 1; 148 } 149 150 pdata->irq_count = msi_count; 151 152 pdata->dev_irq = pdata->pcidev->irq; 153 154 if (msi_count > 1) { 155 pdata->ecc_irq = pdata->pcidev->irq + 1; 156 pdata->i2c_irq = pdata->pcidev->irq + 2; 157 pdata->an_irq = pdata->pcidev->irq + 3; 158 159 for (i = XGBE_MSIX_BASE_COUNT, j = 0; 160 (i < msi_count) && (j < XGBE_MAX_DMA_CHANNELS); 161 i++, j++) 162 pdata->channel_irq[j] = pdata->pcidev->irq + i; 163 pdata->channel_irq_count = j; 164 165 pdata->per_channel_irq = 1; 166 pdata->channel_irq_mode = XGBE_IRQ_MODE_LEVEL; 167 } else { 168 pdata->ecc_irq = pdata->pcidev->irq; 169 pdata->i2c_irq = pdata->pcidev->irq; 170 pdata->an_irq = pdata->pcidev->irq; 171 } 172 173 if (netif_msg_probe(pdata)) 174 dev_dbg(pdata->dev, "MSI interrupts enabled\n"); 175 176 return 0; 177 } 178 179 static int xgbe_config_msix(struct xgbe_prv_data *pdata) 180 { 181 unsigned int msix_count; 182 unsigned int i, j; 183 int ret; 184 185 msix_count = XGBE_MSIX_BASE_COUNT; 186 msix_count += max(pdata->rx_ring_count, 187 pdata->tx_ring_count); 188 189 pdata->msix_entries = devm_kcalloc(pdata->dev, msix_count, 190 sizeof(struct msix_entry), 191 GFP_KERNEL); 192 if (!pdata->msix_entries) 193 return -ENOMEM; 194 195 for (i = 0; i < msix_count; i++) 196 pdata->msix_entries[i].entry = i; 197 198 ret = pci_enable_msix_range(pdata->pcidev, pdata->msix_entries, 199 XGBE_MSIX_MIN_COUNT, msix_count); 200 if (ret < 0) { 201 dev_info(pdata->dev, "MSI-X enablement failed\n"); 202 devm_kfree(pdata->dev, pdata->msix_entries); 203 pdata->msix_entries = NULL; 204 return ret; 205 } 206 207 pdata->irq_count = ret; 208 209 pdata->dev_irq = pdata->msix_entries[0].vector; 210 pdata->ecc_irq = pdata->msix_entries[1].vector; 211 pdata->i2c_irq = pdata->msix_entries[2].vector; 212 pdata->an_irq = pdata->msix_entries[3].vector; 213 214 for (i = XGBE_MSIX_BASE_COUNT, j = 0; i < ret; i++, j++) 215 pdata->channel_irq[j] = pdata->msix_entries[i].vector; 216 pdata->channel_irq_count = j; 217 218 pdata->per_channel_irq = 1; 219 pdata->channel_irq_mode = XGBE_IRQ_MODE_LEVEL; 220 221 if (netif_msg_probe(pdata)) 222 dev_dbg(pdata->dev, "MSI-X interrupts enabled\n"); 223 224 return 0; 225 } 226 227 static int xgbe_config_irqs(struct xgbe_prv_data *pdata) 228 { 229 int ret; 230 231 ret = xgbe_config_msix(pdata); 232 if (!ret) 233 goto out; 234 235 ret = xgbe_config_msi(pdata); 236 if (!ret) 237 goto out; 238 239 pdata->irq_count = 1; 240 pdata->irq_shared = 1; 241 242 pdata->dev_irq = pdata->pcidev->irq; 243 pdata->ecc_irq = pdata->pcidev->irq; 244 pdata->i2c_irq = pdata->pcidev->irq; 245 pdata->an_irq = pdata->pcidev->irq; 246 247 out: 248 if (netif_msg_probe(pdata)) { 249 unsigned int i; 250 251 dev_dbg(pdata->dev, " dev irq=%d\n", pdata->dev_irq); 252 dev_dbg(pdata->dev, " ecc irq=%d\n", pdata->ecc_irq); 253 dev_dbg(pdata->dev, " i2c irq=%d\n", pdata->i2c_irq); 254 dev_dbg(pdata->dev, " an irq=%d\n", pdata->an_irq); 255 for (i = 0; i < pdata->channel_irq_count; i++) 256 dev_dbg(pdata->dev, " dma%u irq=%d\n", 257 i, pdata->channel_irq[i]); 258 } 259 260 return 0; 261 } 262 263 static int xgbe_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) 264 { 265 struct xgbe_prv_data *pdata; 266 struct device *dev = &pdev->dev; 267 void __iomem * const *iomap_table; 268 unsigned int ma_lo, ma_hi; 269 unsigned int reg; 270 int bar_mask; 271 int ret; 272 273 pdata = xgbe_alloc_pdata(dev); 274 if (IS_ERR(pdata)) { 275 ret = PTR_ERR(pdata); 276 goto err_alloc; 277 } 278 279 pdata->pcidev = pdev; 280 pci_set_drvdata(pdev, pdata); 281 282 /* Get the version data */ 283 pdata->vdata = (struct xgbe_version_data *)id->driver_data; 284 285 ret = pcim_enable_device(pdev); 286 if (ret) { 287 dev_err(dev, "pcim_enable_device failed\n"); 288 goto err_pci_enable; 289 } 290 291 /* Obtain the mmio areas for the device */ 292 bar_mask = pci_select_bars(pdev, IORESOURCE_MEM); 293 ret = pcim_iomap_regions(pdev, bar_mask, XGBE_DRV_NAME); 294 if (ret) { 295 dev_err(dev, "pcim_iomap_regions failed\n"); 296 goto err_pci_enable; 297 } 298 299 iomap_table = pcim_iomap_table(pdev); 300 if (!iomap_table) { 301 dev_err(dev, "pcim_iomap_table failed\n"); 302 ret = -ENOMEM; 303 goto err_pci_enable; 304 } 305 306 pdata->xgmac_regs = iomap_table[XGBE_XGMAC_BAR]; 307 if (!pdata->xgmac_regs) { 308 dev_err(dev, "xgmac ioremap failed\n"); 309 ret = -ENOMEM; 310 goto err_pci_enable; 311 } 312 pdata->xprop_regs = pdata->xgmac_regs + XGBE_MAC_PROP_OFFSET; 313 pdata->xi2c_regs = pdata->xgmac_regs + XGBE_I2C_CTRL_OFFSET; 314 if (netif_msg_probe(pdata)) { 315 dev_dbg(dev, "xgmac_regs = %p\n", pdata->xgmac_regs); 316 dev_dbg(dev, "xprop_regs = %p\n", pdata->xprop_regs); 317 dev_dbg(dev, "xi2c_regs = %p\n", pdata->xi2c_regs); 318 } 319 320 pdata->xpcs_regs = iomap_table[XGBE_XPCS_BAR]; 321 if (!pdata->xpcs_regs) { 322 dev_err(dev, "xpcs ioremap failed\n"); 323 ret = -ENOMEM; 324 goto err_pci_enable; 325 } 326 if (netif_msg_probe(pdata)) 327 dev_dbg(dev, "xpcs_regs = %p\n", pdata->xpcs_regs); 328 329 /* Configure the PCS indirect addressing support */ 330 reg = XPCS32_IOREAD(pdata, PCS_V2_WINDOW_DEF); 331 pdata->xpcs_window = XPCS_GET_BITS(reg, PCS_V2_WINDOW_DEF, OFFSET); 332 pdata->xpcs_window <<= 6; 333 pdata->xpcs_window_size = XPCS_GET_BITS(reg, PCS_V2_WINDOW_DEF, SIZE); 334 pdata->xpcs_window_size = 1 << (pdata->xpcs_window_size + 7); 335 pdata->xpcs_window_mask = pdata->xpcs_window_size - 1; 336 if (netif_msg_probe(pdata)) { 337 dev_dbg(dev, "xpcs window = %#010x\n", 338 pdata->xpcs_window); 339 dev_dbg(dev, "xpcs window size = %#010x\n", 340 pdata->xpcs_window_size); 341 dev_dbg(dev, "xpcs window mask = %#010x\n", 342 pdata->xpcs_window_mask); 343 } 344 345 pci_set_master(pdev); 346 347 /* Enable all interrupts in the hardware */ 348 XP_IOWRITE(pdata, XP_INT_EN, 0x1fffff); 349 350 /* Retrieve the MAC address */ 351 ma_lo = XP_IOREAD(pdata, XP_MAC_ADDR_LO); 352 ma_hi = XP_IOREAD(pdata, XP_MAC_ADDR_HI); 353 pdata->mac_addr[0] = ma_lo & 0xff; 354 pdata->mac_addr[1] = (ma_lo >> 8) & 0xff; 355 pdata->mac_addr[2] = (ma_lo >> 16) & 0xff; 356 pdata->mac_addr[3] = (ma_lo >> 24) & 0xff; 357 pdata->mac_addr[4] = ma_hi & 0xff; 358 pdata->mac_addr[5] = (ma_hi >> 8) & 0xff; 359 if (!XP_GET_BITS(ma_hi, XP_MAC_ADDR_HI, VALID) || 360 !is_valid_ether_addr(pdata->mac_addr)) { 361 dev_err(dev, "invalid mac address\n"); 362 ret = -EINVAL; 363 goto err_pci_enable; 364 } 365 366 /* Clock settings */ 367 pdata->sysclk_rate = XGBE_V2_DMA_CLOCK_FREQ; 368 pdata->ptpclk_rate = XGBE_V2_PTP_CLOCK_FREQ; 369 370 /* Set the DMA coherency values */ 371 pdata->coherent = 1; 372 pdata->axdomain = XGBE_DMA_OS_AXDOMAIN; 373 pdata->arcache = XGBE_DMA_OS_ARCACHE; 374 pdata->awcache = XGBE_DMA_OS_AWCACHE; 375 376 /* Set the maximum channels and queues */ 377 reg = XP_IOREAD(pdata, XP_PROP_1); 378 pdata->tx_max_channel_count = XP_GET_BITS(reg, XP_PROP_1, MAX_TX_DMA); 379 pdata->rx_max_channel_count = XP_GET_BITS(reg, XP_PROP_1, MAX_RX_DMA); 380 pdata->tx_max_q_count = XP_GET_BITS(reg, XP_PROP_1, MAX_TX_QUEUES); 381 pdata->rx_max_q_count = XP_GET_BITS(reg, XP_PROP_1, MAX_RX_QUEUES); 382 if (netif_msg_probe(pdata)) { 383 dev_dbg(dev, "max tx/rx channel count = %u/%u\n", 384 pdata->tx_max_channel_count, 385 pdata->tx_max_channel_count); 386 dev_dbg(dev, "max tx/rx hw queue count = %u/%u\n", 387 pdata->tx_max_q_count, pdata->rx_max_q_count); 388 } 389 390 /* Set the hardware channel and queue counts */ 391 xgbe_set_counts(pdata); 392 393 /* Set the maximum fifo amounts */ 394 reg = XP_IOREAD(pdata, XP_PROP_2); 395 pdata->tx_max_fifo_size = XP_GET_BITS(reg, XP_PROP_2, TX_FIFO_SIZE); 396 pdata->tx_max_fifo_size *= 16384; 397 pdata->tx_max_fifo_size = min(pdata->tx_max_fifo_size, 398 pdata->vdata->tx_max_fifo_size); 399 pdata->rx_max_fifo_size = XP_GET_BITS(reg, XP_PROP_2, RX_FIFO_SIZE); 400 pdata->rx_max_fifo_size *= 16384; 401 pdata->rx_max_fifo_size = min(pdata->rx_max_fifo_size, 402 pdata->vdata->rx_max_fifo_size); 403 if (netif_msg_probe(pdata)) 404 dev_dbg(dev, "max tx/rx max fifo size = %u/%u\n", 405 pdata->tx_max_fifo_size, pdata->rx_max_fifo_size); 406 407 /* Configure interrupt support */ 408 ret = xgbe_config_irqs(pdata); 409 if (ret) 410 goto err_pci_enable; 411 412 /* Configure the netdev resource */ 413 ret = xgbe_config_netdev(pdata); 414 if (ret) 415 goto err_pci_enable; 416 417 netdev_notice(pdata->netdev, "net device enabled\n"); 418 419 return 0; 420 421 err_pci_enable: 422 xgbe_free_pdata(pdata); 423 424 err_alloc: 425 dev_notice(dev, "net device not enabled\n"); 426 427 return ret; 428 } 429 430 static void xgbe_pci_remove(struct pci_dev *pdev) 431 { 432 struct xgbe_prv_data *pdata = pci_get_drvdata(pdev); 433 434 xgbe_deconfig_netdev(pdata); 435 436 xgbe_free_pdata(pdata); 437 } 438 439 #ifdef CONFIG_PM 440 static int xgbe_pci_suspend(struct pci_dev *pdev, pm_message_t state) 441 { 442 struct xgbe_prv_data *pdata = pci_get_drvdata(pdev); 443 struct net_device *netdev = pdata->netdev; 444 int ret = 0; 445 446 if (netif_running(netdev)) 447 ret = xgbe_powerdown(netdev, XGMAC_DRIVER_CONTEXT); 448 449 pdata->lpm_ctrl = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_CTRL1); 450 pdata->lpm_ctrl |= MDIO_CTRL1_LPOWER; 451 XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_CTRL1, pdata->lpm_ctrl); 452 453 return ret; 454 } 455 456 static int xgbe_pci_resume(struct pci_dev *pdev) 457 { 458 struct xgbe_prv_data *pdata = pci_get_drvdata(pdev); 459 struct net_device *netdev = pdata->netdev; 460 int ret = 0; 461 462 pdata->lpm_ctrl &= ~MDIO_CTRL1_LPOWER; 463 XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_CTRL1, pdata->lpm_ctrl); 464 465 if (netif_running(netdev)) { 466 ret = xgbe_powerup(netdev, XGMAC_DRIVER_CONTEXT); 467 468 /* Schedule a restart in case the link or phy state changed 469 * while we were powered down. 470 */ 471 schedule_work(&pdata->restart_work); 472 } 473 474 return ret; 475 } 476 #endif /* CONFIG_PM */ 477 478 static const struct xgbe_version_data xgbe_v2a = { 479 .init_function_ptrs_phy_impl = xgbe_init_function_ptrs_phy_v2, 480 .xpcs_access = XGBE_XPCS_ACCESS_V2, 481 .mmc_64bit = 1, 482 .tx_max_fifo_size = 229376, 483 .rx_max_fifo_size = 229376, 484 .tx_tstamp_workaround = 1, 485 .ecc_support = 1, 486 .i2c_support = 1, 487 }; 488 489 static const struct xgbe_version_data xgbe_v2b = { 490 .init_function_ptrs_phy_impl = xgbe_init_function_ptrs_phy_v2, 491 .xpcs_access = XGBE_XPCS_ACCESS_V2, 492 .mmc_64bit = 1, 493 .tx_max_fifo_size = 65536, 494 .rx_max_fifo_size = 65536, 495 .tx_tstamp_workaround = 1, 496 .ecc_support = 1, 497 .i2c_support = 1, 498 }; 499 500 static const struct pci_device_id xgbe_pci_table[] = { 501 { PCI_VDEVICE(AMD, 0x1458), 502 .driver_data = (kernel_ulong_t)&xgbe_v2a }, 503 { PCI_VDEVICE(AMD, 0x1459), 504 .driver_data = (kernel_ulong_t)&xgbe_v2b }, 505 /* Last entry must be zero */ 506 { 0, } 507 }; 508 MODULE_DEVICE_TABLE(pci, xgbe_pci_table); 509 510 static struct pci_driver xgbe_driver = { 511 .name = XGBE_DRV_NAME, 512 .id_table = xgbe_pci_table, 513 .probe = xgbe_pci_probe, 514 .remove = xgbe_pci_remove, 515 #ifdef CONFIG_PM 516 .suspend = xgbe_pci_suspend, 517 .resume = xgbe_pci_resume, 518 #endif 519 }; 520 521 int xgbe_pci_init(void) 522 { 523 return pci_register_driver(&xgbe_driver); 524 } 525 526 void xgbe_pci_exit(void) 527 { 528 pci_unregister_driver(&xgbe_driver); 529 } 530