1 /* 2 * Linux ARCnet driver - COM20020 PCI support 3 * Contemporary Controls PCI20 and SOHARD SH-ARC PCI 4 * 5 * Written 1994-1999 by Avery Pennarun, 6 * based on an ISA version by David Woodhouse. 7 * Written 1999-2000 by Martin Mares <mj@ucw.cz>. 8 * Derived from skeleton.c by Donald Becker. 9 * 10 * Special thanks to Contemporary Controls, Inc. (www.ccontrols.com) 11 * for sponsoring the further development of this driver. 12 * 13 * ********************** 14 * 15 * The original copyright of skeleton.c was as follows: 16 * 17 * skeleton.c Written 1993 by Donald Becker. 18 * Copyright 1993 United States Government as represented by the 19 * Director, National Security Agency. This software may only be used 20 * and distributed according to the terms of the GNU General Public License as 21 * modified by SRC, incorporated herein by reference. 22 * 23 * ********************** 24 * 25 * For more details, see drivers/net/arcnet.c 26 * 27 * ********************** 28 */ 29 30 #define pr_fmt(fmt) "arcnet:" KBUILD_MODNAME ": " fmt 31 32 #include <linux/module.h> 33 #include <linux/moduleparam.h> 34 #include <linux/kernel.h> 35 #include <linux/types.h> 36 #include <linux/ioport.h> 37 #include <linux/errno.h> 38 #include <linux/netdevice.h> 39 #include <linux/init.h> 40 #include <linux/interrupt.h> 41 #include <linux/pci.h> 42 #include <linux/list.h> 43 #include <linux/io.h> 44 #include <linux/leds.h> 45 46 #include "arcdevice.h" 47 #include "com20020.h" 48 49 /* Module parameters */ 50 51 static int node; 52 static char device[9]; /* use eg. device="arc1" to change name */ 53 static int timeout = 3; 54 static int backplane; 55 static int clockp; 56 static int clockm; 57 58 module_param(node, int, 0); 59 module_param_string(device, device, sizeof(device), 0); 60 module_param(timeout, int, 0); 61 module_param(backplane, int, 0); 62 module_param(clockp, int, 0); 63 module_param(clockm, int, 0); 64 MODULE_LICENSE("GPL"); 65 66 static void led_tx_set(struct led_classdev *led_cdev, 67 enum led_brightness value) 68 { 69 struct com20020_dev *card; 70 struct com20020_priv *priv; 71 struct com20020_pci_card_info *ci; 72 73 card = container_of(led_cdev, struct com20020_dev, tx_led); 74 75 priv = card->pci_priv; 76 ci = priv->ci; 77 78 outb(!!value, priv->misc + ci->leds[card->index].green); 79 } 80 81 static void led_recon_set(struct led_classdev *led_cdev, 82 enum led_brightness value) 83 { 84 struct com20020_dev *card; 85 struct com20020_priv *priv; 86 struct com20020_pci_card_info *ci; 87 88 card = container_of(led_cdev, struct com20020_dev, recon_led); 89 90 priv = card->pci_priv; 91 ci = priv->ci; 92 93 outb(!!value, priv->misc + ci->leds[card->index].red); 94 } 95 96 static ssize_t backplane_mode_show(struct device *dev, 97 struct device_attribute *attr, 98 char *buf) 99 { 100 struct net_device *net_dev = to_net_dev(dev); 101 struct arcnet_local *lp = netdev_priv(net_dev); 102 103 return sprintf(buf, "%s\n", lp->backplane ? "true" : "false"); 104 } 105 static DEVICE_ATTR_RO(backplane_mode); 106 107 static struct attribute *com20020_state_attrs[] = { 108 &dev_attr_backplane_mode.attr, 109 NULL, 110 }; 111 112 static const struct attribute_group com20020_state_group = { 113 .name = NULL, 114 .attrs = com20020_state_attrs, 115 }; 116 117 static void com20020pci_remove(struct pci_dev *pdev); 118 119 static int com20020pci_probe(struct pci_dev *pdev, 120 const struct pci_device_id *id) 121 { 122 struct com20020_pci_card_info *ci; 123 struct com20020_pci_channel_map *mm; 124 struct net_device *dev; 125 struct arcnet_local *lp; 126 struct com20020_priv *priv; 127 int i, ioaddr, ret; 128 struct resource *r; 129 130 ret = 0; 131 132 if (pci_enable_device(pdev)) 133 return -EIO; 134 135 priv = devm_kzalloc(&pdev->dev, sizeof(struct com20020_priv), 136 GFP_KERNEL); 137 if (!priv) 138 return -ENOMEM; 139 140 ci = (struct com20020_pci_card_info *)id->driver_data; 141 if (!ci) 142 return -EINVAL; 143 144 priv->ci = ci; 145 mm = &ci->misc_map; 146 147 pci_set_drvdata(pdev, priv); 148 149 INIT_LIST_HEAD(&priv->list_dev); 150 151 if (mm->size) { 152 ioaddr = pci_resource_start(pdev, mm->bar) + mm->offset; 153 r = devm_request_region(&pdev->dev, ioaddr, mm->size, 154 "com20020-pci"); 155 if (!r) { 156 pr_err("IO region %xh-%xh already allocated.\n", 157 ioaddr, ioaddr + mm->size - 1); 158 return -EBUSY; 159 } 160 priv->misc = ioaddr; 161 } 162 163 for (i = 0; i < ci->devcount; i++) { 164 struct com20020_pci_channel_map *cm = &ci->chan_map_tbl[i]; 165 struct com20020_dev *card; 166 int dev_id_mask = 0xf; 167 168 dev = alloc_arcdev(device); 169 if (!dev) { 170 ret = -ENOMEM; 171 break; 172 } 173 dev->dev_port = i; 174 175 dev->netdev_ops = &com20020_netdev_ops; 176 177 lp = netdev_priv(dev); 178 179 arc_printk(D_NORMAL, dev, "%s Controls\n", ci->name); 180 ioaddr = pci_resource_start(pdev, cm->bar) + cm->offset; 181 182 r = devm_request_region(&pdev->dev, ioaddr, cm->size, 183 "com20020-pci"); 184 if (!r) { 185 pr_err("IO region %xh-%xh already allocated\n", 186 ioaddr, ioaddr + cm->size - 1); 187 ret = -EBUSY; 188 goto err_free_arcdev; 189 } 190 191 /* Dummy access after Reset 192 * ARCNET controller needs 193 * this access to detect bustype 194 */ 195 arcnet_outb(0x00, ioaddr, COM20020_REG_W_COMMAND); 196 arcnet_inb(ioaddr, COM20020_REG_R_DIAGSTAT); 197 198 SET_NETDEV_DEV(dev, &pdev->dev); 199 dev->base_addr = ioaddr; 200 arcnet_set_addr(dev, node); 201 dev->sysfs_groups[0] = &com20020_state_group; 202 dev->irq = pdev->irq; 203 lp->card_name = "PCI COM20020"; 204 lp->card_flags = ci->flags; 205 lp->backplane = backplane; 206 lp->clockp = clockp & 7; 207 lp->clockm = clockm & 3; 208 lp->timeout = timeout; 209 lp->hw.owner = THIS_MODULE; 210 211 lp->backplane = (inb(priv->misc) >> (2 + i)) & 0x1; 212 213 if (!strncmp(ci->name, "EAE PLX-PCI FB2", 15)) 214 lp->backplane = 1; 215 216 if (ci->flags & ARC_HAS_ROTARY) { 217 /* Get the dev_id from the PLX rotary coder */ 218 if (!strncmp(ci->name, "EAE PLX-PCI MA1", 15)) 219 dev_id_mask = 0x3; 220 dev->dev_id = (inb(priv->misc + ci->rotary) >> 4) & dev_id_mask; 221 snprintf(dev->name, sizeof(dev->name), "arc%d-%d", dev->dev_id, i); 222 } 223 224 if (arcnet_inb(ioaddr, COM20020_REG_R_STATUS) == 0xFF) { 225 pr_err("IO address %Xh is empty!\n", ioaddr); 226 ret = -EIO; 227 goto err_free_arcdev; 228 } 229 if (com20020_check(dev)) { 230 ret = -EIO; 231 goto err_free_arcdev; 232 } 233 234 ret = com20020_found(dev, IRQF_SHARED); 235 if (ret) 236 goto err_free_arcdev; 237 238 card = devm_kzalloc(&pdev->dev, sizeof(struct com20020_dev), 239 GFP_KERNEL); 240 if (!card) { 241 ret = -ENOMEM; 242 goto err_free_arcdev; 243 } 244 245 card->index = i; 246 card->pci_priv = priv; 247 248 if (ci->flags & ARC_HAS_LED) { 249 card->tx_led.brightness_set = led_tx_set; 250 card->tx_led.default_trigger = devm_kasprintf(&pdev->dev, 251 GFP_KERNEL, "arc%d-%d-tx", 252 dev->dev_id, i); 253 if (!card->tx_led.default_trigger) { 254 ret = -ENOMEM; 255 goto err_free_arcdev; 256 } 257 card->tx_led.name = devm_kasprintf(&pdev->dev, GFP_KERNEL, 258 "pci:green:tx:%d-%d", 259 dev->dev_id, i); 260 if (!card->tx_led.name) { 261 ret = -ENOMEM; 262 goto err_free_arcdev; 263 } 264 card->tx_led.dev = &dev->dev; 265 card->recon_led.brightness_set = led_recon_set; 266 card->recon_led.default_trigger = devm_kasprintf(&pdev->dev, 267 GFP_KERNEL, "arc%d-%d-recon", 268 dev->dev_id, i); 269 if (!card->recon_led.default_trigger) { 270 ret = -ENOMEM; 271 goto err_free_arcdev; 272 } 273 card->recon_led.name = devm_kasprintf(&pdev->dev, GFP_KERNEL, 274 "pci:red:recon:%d-%d", 275 dev->dev_id, i); 276 if (!card->recon_led.name) { 277 ret = -ENOMEM; 278 goto err_free_arcdev; 279 } 280 card->recon_led.dev = &dev->dev; 281 282 ret = devm_led_classdev_register(&pdev->dev, &card->tx_led); 283 if (ret) 284 goto err_free_arcdev; 285 286 ret = devm_led_classdev_register(&pdev->dev, &card->recon_led); 287 if (ret) 288 goto err_free_arcdev; 289 290 dev_set_drvdata(&dev->dev, card); 291 devm_arcnet_led_init(dev, dev->dev_id, i); 292 } 293 294 card->dev = dev; 295 list_add(&card->list, &priv->list_dev); 296 continue; 297 298 err_free_arcdev: 299 free_arcdev(dev); 300 break; 301 } 302 if (ret) 303 com20020pci_remove(pdev); 304 return ret; 305 } 306 307 static void com20020pci_remove(struct pci_dev *pdev) 308 { 309 struct com20020_dev *card, *tmpcard; 310 struct com20020_priv *priv; 311 312 priv = pci_get_drvdata(pdev); 313 314 list_for_each_entry_safe(card, tmpcard, &priv->list_dev, list) { 315 struct net_device *dev = card->dev; 316 317 unregister_netdev(dev); 318 free_irq(dev->irq, dev); 319 free_arcdev(dev); 320 } 321 } 322 323 static struct com20020_pci_card_info card_info_10mbit = { 324 .name = "ARC-PCI", 325 .devcount = 1, 326 .chan_map_tbl = { 327 { 328 .bar = 2, 329 .offset = 0x00, 330 .size = 0x08, 331 }, 332 }, 333 .flags = ARC_CAN_10MBIT, 334 }; 335 336 static struct com20020_pci_card_info card_info_5mbit = { 337 .name = "ARC-PCI", 338 .devcount = 1, 339 .chan_map_tbl = { 340 { 341 .bar = 2, 342 .offset = 0x00, 343 .size = 0x08, 344 }, 345 }, 346 .flags = ARC_IS_5MBIT, 347 }; 348 349 static struct com20020_pci_card_info card_info_sohard = { 350 .name = "SOHARD SH ARC-PCI", 351 .devcount = 1, 352 /* SOHARD needs PCI base addr 4 */ 353 .chan_map_tbl = { 354 { 355 .bar = 4, 356 .offset = 0x00, 357 .size = 0x08 358 }, 359 }, 360 .flags = ARC_CAN_10MBIT, 361 }; 362 363 static struct com20020_pci_card_info card_info_eae_arc1 = { 364 .name = "EAE PLX-PCI ARC1", 365 .devcount = 1, 366 .chan_map_tbl = { 367 { 368 .bar = 2, 369 .offset = 0x00, 370 .size = 0x08, 371 }, 372 }, 373 .misc_map = { 374 .bar = 2, 375 .offset = 0x10, 376 .size = 0x04, 377 }, 378 .leds = { 379 { 380 .green = 0x0, 381 .red = 0x1, 382 }, 383 }, 384 .rotary = 0x0, 385 .flags = ARC_HAS_ROTARY | ARC_HAS_LED | ARC_CAN_10MBIT, 386 }; 387 388 static struct com20020_pci_card_info card_info_eae_ma1 = { 389 .name = "EAE PLX-PCI MA1", 390 .devcount = 2, 391 .chan_map_tbl = { 392 { 393 .bar = 2, 394 .offset = 0x00, 395 .size = 0x08, 396 }, { 397 .bar = 2, 398 .offset = 0x08, 399 .size = 0x08, 400 } 401 }, 402 .misc_map = { 403 .bar = 2, 404 .offset = 0x10, 405 .size = 0x04, 406 }, 407 .leds = { 408 { 409 .green = 0x0, 410 .red = 0x1, 411 }, { 412 .green = 0x2, 413 .red = 0x3, 414 }, 415 }, 416 .rotary = 0x0, 417 .flags = ARC_HAS_ROTARY | ARC_HAS_LED | ARC_CAN_10MBIT, 418 }; 419 420 static struct com20020_pci_card_info card_info_eae_fb2 = { 421 .name = "EAE PLX-PCI FB2", 422 .devcount = 1, 423 .chan_map_tbl = { 424 { 425 .bar = 2, 426 .offset = 0x00, 427 .size = 0x08, 428 }, 429 }, 430 .misc_map = { 431 .bar = 2, 432 .offset = 0x10, 433 .size = 0x04, 434 }, 435 .leds = { 436 { 437 .green = 0x0, 438 .red = 0x1, 439 }, 440 }, 441 .rotary = 0x0, 442 .flags = ARC_HAS_ROTARY | ARC_HAS_LED | ARC_CAN_10MBIT, 443 }; 444 445 static const struct pci_device_id com20020pci_id_table[] = { 446 { 447 0x1571, 0xa001, 448 PCI_ANY_ID, PCI_ANY_ID, 449 0, 0, 450 0, 451 }, 452 { 453 0x1571, 0xa002, 454 PCI_ANY_ID, PCI_ANY_ID, 455 0, 0, 456 0, 457 }, 458 { 459 0x1571, 0xa003, 460 PCI_ANY_ID, PCI_ANY_ID, 461 0, 0, 462 0 463 }, 464 { 465 0x1571, 0xa004, 466 PCI_ANY_ID, PCI_ANY_ID, 467 0, 0, 468 0, 469 }, 470 { 471 0x1571, 0xa005, 472 PCI_ANY_ID, PCI_ANY_ID, 473 0, 0, 474 0 475 }, 476 { 477 0x1571, 0xa006, 478 PCI_ANY_ID, PCI_ANY_ID, 479 0, 0, 480 0 481 }, 482 { 483 0x1571, 0xa007, 484 PCI_ANY_ID, PCI_ANY_ID, 485 0, 0, 486 0 487 }, 488 { 489 0x1571, 0xa008, 490 PCI_ANY_ID, PCI_ANY_ID, 491 0, 0, 492 0 493 }, 494 { 495 0x1571, 0xa009, 496 PCI_ANY_ID, PCI_ANY_ID, 497 0, 0, 498 (kernel_ulong_t)&card_info_5mbit 499 }, 500 { 501 0x1571, 0xa00a, 502 PCI_ANY_ID, PCI_ANY_ID, 503 0, 0, 504 (kernel_ulong_t)&card_info_5mbit 505 }, 506 { 507 0x1571, 0xa00b, 508 PCI_ANY_ID, PCI_ANY_ID, 509 0, 0, 510 (kernel_ulong_t)&card_info_5mbit 511 }, 512 { 513 0x1571, 0xa00c, 514 PCI_ANY_ID, PCI_ANY_ID, 515 0, 0, 516 (kernel_ulong_t)&card_info_5mbit 517 }, 518 { 519 0x1571, 0xa00d, 520 PCI_ANY_ID, PCI_ANY_ID, 521 0, 0, 522 (kernel_ulong_t)&card_info_5mbit 523 }, 524 { 525 0x1571, 0xa00e, 526 PCI_ANY_ID, PCI_ANY_ID, 527 0, 0, 528 (kernel_ulong_t)&card_info_5mbit 529 }, 530 { 531 0x1571, 0xa201, 532 PCI_ANY_ID, PCI_ANY_ID, 533 0, 0, 534 (kernel_ulong_t)&card_info_10mbit 535 }, 536 { 537 0x1571, 0xa202, 538 PCI_ANY_ID, PCI_ANY_ID, 539 0, 0, 540 (kernel_ulong_t)&card_info_10mbit 541 }, 542 { 543 0x1571, 0xa203, 544 PCI_ANY_ID, PCI_ANY_ID, 545 0, 0, 546 (kernel_ulong_t)&card_info_10mbit 547 }, 548 { 549 0x1571, 0xa204, 550 PCI_ANY_ID, PCI_ANY_ID, 551 0, 0, 552 (kernel_ulong_t)&card_info_10mbit 553 }, 554 { 555 0x1571, 0xa205, 556 PCI_ANY_ID, PCI_ANY_ID, 557 0, 0, 558 (kernel_ulong_t)&card_info_10mbit 559 }, 560 { 561 0x1571, 0xa206, 562 PCI_ANY_ID, PCI_ANY_ID, 563 0, 0, 564 (kernel_ulong_t)&card_info_10mbit 565 }, 566 { 567 0x10B5, 0x9030, 568 0x10B5, 0x2978, 569 0, 0, 570 (kernel_ulong_t)&card_info_sohard 571 }, 572 { 573 0x10B5, 0x9050, 574 0x10B5, 0x2273, 575 0, 0, 576 (kernel_ulong_t)&card_info_sohard 577 }, 578 { 579 0x10B5, 0x9050, 580 0x10B5, 0x3263, 581 0, 0, 582 (kernel_ulong_t)&card_info_eae_arc1 583 }, 584 { 585 0x10B5, 0x9050, 586 0x10B5, 0x3292, 587 0, 0, 588 (kernel_ulong_t)&card_info_eae_ma1 589 }, 590 { 591 0x10B5, 0x9050, 592 0x10B5, 0x3294, 593 0, 0, 594 (kernel_ulong_t)&card_info_eae_fb2 595 }, 596 { 597 0x14BA, 0x6000, 598 PCI_ANY_ID, PCI_ANY_ID, 599 0, 0, 600 (kernel_ulong_t)&card_info_10mbit 601 }, 602 { 603 0x10B5, 0x2200, 604 PCI_ANY_ID, PCI_ANY_ID, 605 0, 0, 606 (kernel_ulong_t)&card_info_10mbit 607 }, 608 { 0, } 609 }; 610 611 MODULE_DEVICE_TABLE(pci, com20020pci_id_table); 612 613 static struct pci_driver com20020pci_driver = { 614 .name = "com20020", 615 .id_table = com20020pci_id_table, 616 .probe = com20020pci_probe, 617 .remove = com20020pci_remove, 618 }; 619 620 static int __init com20020pci_init(void) 621 { 622 if (BUGLVL(D_NORMAL)) 623 pr_info("%s\n", "COM20020 PCI support"); 624 return pci_register_driver(&com20020pci_driver); 625 } 626 627 static void __exit com20020pci_cleanup(void) 628 { 629 pci_unregister_driver(&com20020pci_driver); 630 } 631 632 module_init(com20020pci_init) 633 module_exit(com20020pci_cleanup) 634