Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Linux ARCnet driver - COM20020 PCI support |
| 3 | * Contemporary Controls PCI20 and SOHARD SH-ARC PCI |
Joe Perches | cb33464 | 2015-05-05 10:05:47 -0700 | [diff] [blame] | 4 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Joe Perches | 05a24b2 | 2015-05-05 10:05:56 -0700 | [diff] [blame] | 29 | |
| 30 | #define pr_fmt(fmt) "arcnet:" KBUILD_MODNAME ": " fmt |
| 31 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | #include <linux/errno.h> |
| 38 | #include <linux/netdevice.h> |
| 39 | #include <linux/init.h> |
Alexey Dobriyan | a6b7a40 | 2011-06-06 10:43:46 +0000 | [diff] [blame] | 40 | #include <linux/interrupt.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | #include <linux/pci.h> |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 42 | #include <linux/list.h> |
Joe Perches | 5e7ef91 | 2015-05-05 10:05:51 -0700 | [diff] [blame] | 43 | #include <linux/io.h> |
Michael Grzeschik | 8890624 | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 44 | #include <linux/leds.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | |
Joe Perches | 26c6d28 | 2015-05-05 10:06:03 -0700 | [diff] [blame] | 46 | #include "arcdevice.h" |
| 47 | #include "com20020.h" |
| 48 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Michael Grzeschik | 8890624 | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 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 | |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 96 | static void com20020pci_remove(struct pci_dev *pdev); |
| 97 | |
Joe Perches | d6d7d3e | 2015-05-05 10:06:02 -0700 | [diff] [blame] | 98 | static int com20020pci_probe(struct pci_dev *pdev, |
| 99 | const struct pci_device_id *id) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | { |
Michael Grzeschik | 8c14f9c | 2014-09-29 11:55:36 +0200 | [diff] [blame] | 101 | struct com20020_pci_card_info *ci; |
Michael Grzeschik | 5ef216c | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 102 | struct com20020_pci_channel_map *mm; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | struct net_device *dev; |
| 104 | struct arcnet_local *lp; |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 105 | struct com20020_priv *priv; |
| 106 | int i, ioaddr, ret; |
| 107 | struct resource *r; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 108 | |
| 109 | if (pci_enable_device(pdev)) |
| 110 | return -EIO; |
Stephen Hemminger | a1799af | 2009-01-09 13:01:10 +0000 | [diff] [blame] | 111 | |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 112 | priv = devm_kzalloc(&pdev->dev, sizeof(struct com20020_priv), |
| 113 | GFP_KERNEL); |
Kiran Padwal | e8a308a | 2015-02-05 17:01:37 +0530 | [diff] [blame] | 114 | if (!priv) |
| 115 | return -ENOMEM; |
| 116 | |
Michael Grzeschik | 8c14f9c | 2014-09-29 11:55:36 +0200 | [diff] [blame] | 117 | ci = (struct com20020_pci_card_info *)id->driver_data; |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 118 | priv->ci = ci; |
Michael Grzeschik | 5ef216c | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 119 | mm = &ci->misc_map; |
Michael Grzeschik | 8c14f9c | 2014-09-29 11:55:36 +0200 | [diff] [blame] | 120 | |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 121 | INIT_LIST_HEAD(&priv->list_dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 122 | |
Michael Grzeschik | 5ef216c | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 123 | if (mm->size) { |
| 124 | ioaddr = pci_resource_start(pdev, mm->bar) + mm->offset; |
| 125 | r = devm_request_region(&pdev->dev, ioaddr, mm->size, |
| 126 | "com20020-pci"); |
| 127 | if (!r) { |
| 128 | pr_err("IO region %xh-%xh already allocated.\n", |
| 129 | ioaddr, ioaddr + mm->size - 1); |
| 130 | return -EBUSY; |
| 131 | } |
| 132 | priv->misc = ioaddr; |
| 133 | } |
| 134 | |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 135 | for (i = 0; i < ci->devcount; i++) { |
| 136 | struct com20020_pci_channel_map *cm = &ci->chan_map_tbl[i]; |
| 137 | struct com20020_dev *card; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 139 | dev = alloc_arcdev(device); |
| 140 | if (!dev) { |
| 141 | ret = -ENOMEM; |
| 142 | goto out_port; |
| 143 | } |
Michael Grzeschik | ae8ede6 | 2015-03-20 15:22:24 +0100 | [diff] [blame] | 144 | dev->dev_port = i; |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 145 | |
| 146 | dev->netdev_ops = &com20020_netdev_ops; |
| 147 | |
| 148 | lp = netdev_priv(dev); |
| 149 | |
Joe Perches | a34c093 | 2015-05-05 10:05:55 -0700 | [diff] [blame] | 150 | arc_printk(D_NORMAL, dev, "%s Controls\n", ci->name); |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 151 | ioaddr = pci_resource_start(pdev, cm->bar) + cm->offset; |
| 152 | |
| 153 | r = devm_request_region(&pdev->dev, ioaddr, cm->size, |
| 154 | "com20020-pci"); |
| 155 | if (!r) { |
Joe Perches | 05a24b2 | 2015-05-05 10:05:56 -0700 | [diff] [blame] | 156 | pr_err("IO region %xh-%xh already allocated\n", |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 157 | ioaddr, ioaddr + cm->size - 1); |
| 158 | ret = -EBUSY; |
| 159 | goto out_port; |
| 160 | } |
| 161 | |
| 162 | /* Dummy access after Reset |
| 163 | * ARCNET controller needs |
| 164 | * this access to detect bustype |
| 165 | */ |
Joe Perches | 0fec651 | 2015-05-05 10:06:06 -0700 | [diff] [blame] | 166 | arcnet_outb(0x00, ioaddr, COM20020_REG_W_COMMAND); |
| 167 | arcnet_inb(ioaddr, COM20020_REG_R_DIAGSTAT); |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 168 | |
| 169 | dev->base_addr = ioaddr; |
| 170 | dev->dev_addr[0] = node; |
| 171 | dev->irq = pdev->irq; |
| 172 | lp->card_name = "PCI COM20020"; |
| 173 | lp->card_flags = ci->flags; |
| 174 | lp->backplane = backplane; |
| 175 | lp->clockp = clockp & 7; |
| 176 | lp->clockm = clockm & 3; |
| 177 | lp->timeout = timeout; |
| 178 | lp->hw.owner = THIS_MODULE; |
| 179 | |
Michael Grzeschik | 5ef216c | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 180 | /* Get the dev_id from the PLX rotary coder */ |
| 181 | if (!strncmp(ci->name, "EAE PLX-PCI MA1", 15)) |
| 182 | dev->dev_id = 0xc; |
| 183 | dev->dev_id ^= inb(priv->misc + ci->rotary) >> 4; |
| 184 | |
| 185 | snprintf(dev->name, sizeof(dev->name), "arc%d-%d", dev->dev_id, i); |
| 186 | |
Joe Perches | 0fec651 | 2015-05-05 10:06:06 -0700 | [diff] [blame] | 187 | if (arcnet_inb(ioaddr, COM20020_REG_R_STATUS) == 0xFF) { |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 188 | pr_err("IO address %Xh is empty!\n", ioaddr); |
| 189 | ret = -EIO; |
| 190 | goto out_port; |
| 191 | } |
| 192 | if (com20020_check(dev)) { |
| 193 | ret = -EIO; |
| 194 | goto out_port; |
| 195 | } |
| 196 | |
| 197 | card = devm_kzalloc(&pdev->dev, sizeof(struct com20020_dev), |
| 198 | GFP_KERNEL); |
Joe Perches | 5628d98 | 2015-05-05 10:05:58 -0700 | [diff] [blame] | 199 | if (!card) |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 200 | return -ENOMEM; |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 201 | |
| 202 | card->index = i; |
| 203 | card->pci_priv = priv; |
Michael Grzeschik | 8890624 | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 204 | card->tx_led.brightness_set = led_tx_set; |
| 205 | card->tx_led.default_trigger = devm_kasprintf(&pdev->dev, |
| 206 | GFP_KERNEL, "arc%d-%d-tx", |
| 207 | dev->dev_id, i); |
| 208 | card->tx_led.name = devm_kasprintf(&pdev->dev, GFP_KERNEL, |
| 209 | "pci:green:tx:%d-%d", |
| 210 | dev->dev_id, i); |
| 211 | |
| 212 | card->tx_led.dev = &dev->dev; |
| 213 | card->recon_led.brightness_set = led_recon_set; |
| 214 | card->recon_led.default_trigger = devm_kasprintf(&pdev->dev, |
| 215 | GFP_KERNEL, "arc%d-%d-recon", |
| 216 | dev->dev_id, i); |
| 217 | card->recon_led.name = devm_kasprintf(&pdev->dev, GFP_KERNEL, |
| 218 | "pci:red:recon:%d-%d", |
| 219 | dev->dev_id, i); |
| 220 | card->recon_led.dev = &dev->dev; |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 221 | card->dev = dev; |
| 222 | |
Michael Grzeschik | 8890624 | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 223 | ret = devm_led_classdev_register(&pdev->dev, &card->tx_led); |
| 224 | if (ret) |
| 225 | goto out_port; |
| 226 | |
| 227 | ret = devm_led_classdev_register(&pdev->dev, &card->recon_led); |
| 228 | if (ret) |
| 229 | goto out_port; |
| 230 | |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 231 | dev_set_drvdata(&dev->dev, card); |
| 232 | |
| 233 | ret = com20020_found(dev, IRQF_SHARED); |
| 234 | if (ret) |
| 235 | goto out_port; |
| 236 | |
Michael Grzeschik | 8890624 | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 237 | devm_arcnet_led_init(dev, dev->dev_id, i); |
| 238 | |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 239 | list_add(&card->list, &priv->list_dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 240 | } |
| 241 | |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 242 | pci_set_drvdata(pdev, priv); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | |
| 244 | return 0; |
| 245 | |
| 246 | out_port: |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 247 | com20020pci_remove(pdev); |
| 248 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | } |
| 250 | |
Bill Pemberton | 7c47bab | 2012-12-03 09:22:43 -0500 | [diff] [blame] | 251 | static void com20020pci_remove(struct pci_dev *pdev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | { |
Michael Grzeschik | c51da42 | 2014-09-29 11:55:37 +0200 | [diff] [blame] | 253 | struct com20020_dev *card, *tmpcard; |
| 254 | struct com20020_priv *priv; |
| 255 | |
| 256 | priv = pci_get_drvdata(pdev); |
| 257 | |
| 258 | list_for_each_entry_safe(card, tmpcard, &priv->list_dev, list) { |
| 259 | struct net_device *dev = card->dev; |
| 260 | |
| 261 | unregister_netdev(dev); |
| 262 | free_irq(dev->irq, dev); |
| 263 | free_netdev(dev); |
| 264 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 265 | } |
| 266 | |
Michael Grzeschik | 8c14f9c | 2014-09-29 11:55:36 +0200 | [diff] [blame] | 267 | static struct com20020_pci_card_info card_info_10mbit = { |
| 268 | .name = "ARC-PCI", |
| 269 | .devcount = 1, |
| 270 | .chan_map_tbl = { |
Michael Grzeschik | 54a84c6 | 2015-03-20 15:22:02 +0100 | [diff] [blame] | 271 | { |
| 272 | .bar = 2, |
| 273 | .offset = 0x00, |
| 274 | .size = 0x08, |
| 275 | }, |
Michael Grzeschik | 8c14f9c | 2014-09-29 11:55:36 +0200 | [diff] [blame] | 276 | }, |
| 277 | .flags = ARC_CAN_10MBIT, |
| 278 | }; |
| 279 | |
| 280 | static struct com20020_pci_card_info card_info_5mbit = { |
| 281 | .name = "ARC-PCI", |
| 282 | .devcount = 1, |
| 283 | .chan_map_tbl = { |
Michael Grzeschik | 54a84c6 | 2015-03-20 15:22:02 +0100 | [diff] [blame] | 284 | { |
| 285 | .bar = 2, |
| 286 | .offset = 0x00, |
| 287 | .size = 0x08, |
| 288 | }, |
Michael Grzeschik | 8c14f9c | 2014-09-29 11:55:36 +0200 | [diff] [blame] | 289 | }, |
| 290 | .flags = ARC_IS_5MBIT, |
| 291 | }; |
| 292 | |
| 293 | static struct com20020_pci_card_info card_info_sohard = { |
| 294 | .name = "PLX-PCI", |
| 295 | .devcount = 1, |
| 296 | /* SOHARD needs PCI base addr 4 */ |
| 297 | .chan_map_tbl = { |
Michael Grzeschik | 54a84c6 | 2015-03-20 15:22:02 +0100 | [diff] [blame] | 298 | { |
| 299 | .bar = 4, |
| 300 | .offset = 0x00, |
| 301 | .size = 0x08 |
| 302 | }, |
Michael Grzeschik | 8c14f9c | 2014-09-29 11:55:36 +0200 | [diff] [blame] | 303 | }, |
| 304 | .flags = ARC_CAN_10MBIT, |
| 305 | }; |
| 306 | |
Michael Grzeschik | d95e2fe | 2015-02-13 13:03:50 +0100 | [diff] [blame] | 307 | static struct com20020_pci_card_info card_info_eae_arc1 = { |
| 308 | .name = "EAE PLX-PCI ARC1", |
| 309 | .devcount = 1, |
| 310 | .chan_map_tbl = { |
Michael Grzeschik | 54a84c6 | 2015-03-20 15:22:02 +0100 | [diff] [blame] | 311 | { |
| 312 | .bar = 2, |
| 313 | .offset = 0x00, |
| 314 | .size = 0x08, |
| 315 | }, |
Michael Grzeschik | d95e2fe | 2015-02-13 13:03:50 +0100 | [diff] [blame] | 316 | }, |
Michael Grzeschik | 5ef216c | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 317 | .misc_map = { |
| 318 | .bar = 2, |
| 319 | .offset = 0x10, |
| 320 | .size = 0x04, |
| 321 | }, |
Michael Grzeschik | 8890624 | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 322 | .leds = { |
| 323 | { |
| 324 | .green = 0x0, |
| 325 | .red = 0x1, |
| 326 | }, |
| 327 | }, |
Michael Grzeschik | 5ef216c | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 328 | .rotary = 0x0, |
Michael Grzeschik | d95e2fe | 2015-02-13 13:03:50 +0100 | [diff] [blame] | 329 | .flags = ARC_CAN_10MBIT, |
| 330 | }; |
| 331 | |
| 332 | static struct com20020_pci_card_info card_info_eae_ma1 = { |
| 333 | .name = "EAE PLX-PCI MA1", |
Michael Grzeschik | 5b85bad | 2014-09-29 11:55:38 +0200 | [diff] [blame] | 334 | .devcount = 2, |
| 335 | .chan_map_tbl = { |
Michael Grzeschik | 54a84c6 | 2015-03-20 15:22:02 +0100 | [diff] [blame] | 336 | { |
| 337 | .bar = 2, |
| 338 | .offset = 0x00, |
| 339 | .size = 0x08, |
| 340 | }, { |
| 341 | .bar = 2, |
| 342 | .offset = 0x08, |
| 343 | .size = 0x08, |
| 344 | } |
Michael Grzeschik | 5b85bad | 2014-09-29 11:55:38 +0200 | [diff] [blame] | 345 | }, |
Michael Grzeschik | 5ef216c | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 346 | .misc_map = { |
| 347 | .bar = 2, |
| 348 | .offset = 0x10, |
| 349 | .size = 0x04, |
| 350 | }, |
Michael Grzeschik | 8890624 | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 351 | .leds = { |
| 352 | { |
| 353 | .green = 0x0, |
| 354 | .red = 0x1, |
| 355 | }, { |
| 356 | .green = 0x2, |
| 357 | .red = 0x3, |
| 358 | }, |
| 359 | }, |
Michael Grzeschik | 5ef216c | 2014-09-18 00:12:50 +0200 | [diff] [blame] | 360 | .rotary = 0x0, |
Michael Grzeschik | 5b85bad | 2014-09-29 11:55:38 +0200 | [diff] [blame] | 361 | .flags = ARC_CAN_10MBIT, |
| 362 | }; |
| 363 | |
Benoit Taine | 9baa3c3 | 2014-08-08 15:56:03 +0200 | [diff] [blame] | 364 | static const struct pci_device_id com20020pci_id_table[] = { |
Michael Grzeschik | 8c14f9c | 2014-09-29 11:55:36 +0200 | [diff] [blame] | 365 | { |
| 366 | 0x1571, 0xa001, |
| 367 | PCI_ANY_ID, PCI_ANY_ID, |
| 368 | 0, 0, |
| 369 | 0, |
| 370 | }, |
| 371 | { |
| 372 | 0x1571, 0xa002, |
| 373 | PCI_ANY_ID, PCI_ANY_ID, |
| 374 | 0, 0, |
| 375 | 0, |
| 376 | }, |
| 377 | { |
| 378 | 0x1571, 0xa003, |
| 379 | PCI_ANY_ID, PCI_ANY_ID, |
| 380 | 0, 0, |
| 381 | 0 |
| 382 | }, |
| 383 | { |
| 384 | 0x1571, 0xa004, |
| 385 | PCI_ANY_ID, PCI_ANY_ID, |
| 386 | 0, 0, |
| 387 | 0, |
| 388 | }, |
| 389 | { |
| 390 | 0x1571, 0xa005, |
| 391 | PCI_ANY_ID, PCI_ANY_ID, |
| 392 | 0, 0, |
| 393 | 0 |
| 394 | }, |
| 395 | { |
| 396 | 0x1571, 0xa006, |
| 397 | PCI_ANY_ID, PCI_ANY_ID, |
| 398 | 0, 0, |
| 399 | 0 |
| 400 | }, |
| 401 | { |
| 402 | 0x1571, 0xa007, |
| 403 | PCI_ANY_ID, PCI_ANY_ID, |
| 404 | 0, 0, |
| 405 | 0 |
| 406 | }, |
| 407 | { |
| 408 | 0x1571, 0xa008, |
| 409 | PCI_ANY_ID, PCI_ANY_ID, |
| 410 | 0, 0, |
| 411 | 0 |
| 412 | }, |
| 413 | { |
| 414 | 0x1571, 0xa009, |
| 415 | PCI_ANY_ID, PCI_ANY_ID, |
| 416 | 0, 0, |
| 417 | (kernel_ulong_t)&card_info_5mbit |
| 418 | }, |
| 419 | { |
| 420 | 0x1571, 0xa00a, |
| 421 | PCI_ANY_ID, PCI_ANY_ID, |
| 422 | 0, 0, |
| 423 | (kernel_ulong_t)&card_info_5mbit |
| 424 | }, |
| 425 | { |
| 426 | 0x1571, 0xa00b, |
| 427 | PCI_ANY_ID, PCI_ANY_ID, |
| 428 | 0, 0, |
| 429 | (kernel_ulong_t)&card_info_5mbit |
| 430 | }, |
| 431 | { |
| 432 | 0x1571, 0xa00c, |
| 433 | PCI_ANY_ID, PCI_ANY_ID, |
| 434 | 0, 0, |
| 435 | (kernel_ulong_t)&card_info_5mbit |
| 436 | }, |
| 437 | { |
| 438 | 0x1571, 0xa00d, |
| 439 | PCI_ANY_ID, PCI_ANY_ID, |
| 440 | 0, 0, |
| 441 | (kernel_ulong_t)&card_info_5mbit |
| 442 | }, |
| 443 | { |
| 444 | 0x1571, 0xa00e, |
| 445 | PCI_ANY_ID, PCI_ANY_ID, |
| 446 | 0, 0, |
| 447 | (kernel_ulong_t)&card_info_5mbit |
| 448 | }, |
| 449 | { |
| 450 | 0x1571, 0xa201, |
| 451 | PCI_ANY_ID, PCI_ANY_ID, |
| 452 | 0, 0, |
| 453 | (kernel_ulong_t)&card_info_10mbit |
| 454 | }, |
| 455 | { |
| 456 | 0x1571, 0xa202, |
| 457 | PCI_ANY_ID, PCI_ANY_ID, |
| 458 | 0, 0, |
| 459 | (kernel_ulong_t)&card_info_10mbit |
| 460 | }, |
| 461 | { |
| 462 | 0x1571, 0xa203, |
| 463 | PCI_ANY_ID, PCI_ANY_ID, |
| 464 | 0, 0, |
| 465 | (kernel_ulong_t)&card_info_10mbit |
| 466 | }, |
| 467 | { |
| 468 | 0x1571, 0xa204, |
| 469 | PCI_ANY_ID, PCI_ANY_ID, |
| 470 | 0, 0, |
| 471 | (kernel_ulong_t)&card_info_10mbit |
| 472 | }, |
| 473 | { |
| 474 | 0x1571, 0xa205, |
| 475 | PCI_ANY_ID, PCI_ANY_ID, |
| 476 | 0, 0, |
| 477 | (kernel_ulong_t)&card_info_10mbit |
| 478 | }, |
| 479 | { |
| 480 | 0x1571, 0xa206, |
| 481 | PCI_ANY_ID, PCI_ANY_ID, |
| 482 | 0, 0, |
| 483 | (kernel_ulong_t)&card_info_10mbit |
| 484 | }, |
| 485 | { |
| 486 | 0x10B5, 0x9030, |
| 487 | 0x10B5, 0x2978, |
| 488 | 0, 0, |
| 489 | (kernel_ulong_t)&card_info_sohard |
| 490 | }, |
| 491 | { |
| 492 | 0x10B5, 0x9050, |
| 493 | 0x10B5, 0x2273, |
| 494 | 0, 0, |
| 495 | (kernel_ulong_t)&card_info_sohard |
| 496 | }, |
| 497 | { |
Michael Grzeschik | 5b85bad | 2014-09-29 11:55:38 +0200 | [diff] [blame] | 498 | 0x10B5, 0x9050, |
Michael Grzeschik | d95e2fe | 2015-02-13 13:03:50 +0100 | [diff] [blame] | 499 | 0x10B5, 0x3263, |
| 500 | 0, 0, |
| 501 | (kernel_ulong_t)&card_info_eae_arc1 |
| 502 | }, |
| 503 | { |
| 504 | 0x10B5, 0x9050, |
Michael Grzeschik | 5b85bad | 2014-09-29 11:55:38 +0200 | [diff] [blame] | 505 | 0x10B5, 0x3292, |
| 506 | 0, 0, |
Michael Grzeschik | d95e2fe | 2015-02-13 13:03:50 +0100 | [diff] [blame] | 507 | (kernel_ulong_t)&card_info_eae_ma1 |
Michael Grzeschik | 5b85bad | 2014-09-29 11:55:38 +0200 | [diff] [blame] | 508 | }, |
| 509 | { |
Michael Grzeschik | 8c14f9c | 2014-09-29 11:55:36 +0200 | [diff] [blame] | 510 | 0x14BA, 0x6000, |
| 511 | PCI_ANY_ID, PCI_ANY_ID, |
| 512 | 0, 0, |
| 513 | (kernel_ulong_t)&card_info_10mbit |
| 514 | }, |
| 515 | { |
| 516 | 0x10B5, 0x2200, |
| 517 | PCI_ANY_ID, PCI_ANY_ID, |
| 518 | 0, 0, |
| 519 | (kernel_ulong_t)&card_info_10mbit |
| 520 | }, |
| 521 | { 0, } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 522 | }; |
| 523 | |
| 524 | MODULE_DEVICE_TABLE(pci, com20020pci_id_table); |
| 525 | |
| 526 | static struct pci_driver com20020pci_driver = { |
| 527 | .name = "com20020", |
| 528 | .id_table = com20020pci_id_table, |
| 529 | .probe = com20020pci_probe, |
Bill Pemberton | 7c47bab | 2012-12-03 09:22:43 -0500 | [diff] [blame] | 530 | .remove = com20020pci_remove, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 531 | }; |
| 532 | |
| 533 | static int __init com20020pci_init(void) |
| 534 | { |
Joe Perches | 72aeea4 | 2015-05-05 10:05:54 -0700 | [diff] [blame] | 535 | if (BUGLVL(D_NORMAL)) |
Joe Perches | 05a24b2 | 2015-05-05 10:05:56 -0700 | [diff] [blame] | 536 | pr_info("%s\n", "COM20020 PCI support"); |
Jeff Garzik | 2991762 | 2006-08-19 17:48:59 -0400 | [diff] [blame] | 537 | return pci_register_driver(&com20020pci_driver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 538 | } |
| 539 | |
| 540 | static void __exit com20020pci_cleanup(void) |
| 541 | { |
| 542 | pci_unregister_driver(&com20020pci_driver); |
| 543 | } |
| 544 | |
| 545 | module_init(com20020pci_init) |
| 546 | module_exit(com20020pci_cleanup) |