Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

Linux/drivers/net/arcnet/com20020-pci.c

  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 void com20020pci_remove(struct pci_dev *pdev);
 97 
 98 static int com20020pci_probe(struct pci_dev *pdev,
 99                              const struct pci_device_id *id)
100 {
101         struct com20020_pci_card_info *ci;
102         struct com20020_pci_channel_map *mm;
103         struct net_device *dev;
104         struct arcnet_local *lp;
105         struct com20020_priv *priv;
106         int i, ioaddr, ret;
107         struct resource *r;
108 
109         if (pci_enable_device(pdev))
110                 return -EIO;
111 
112         priv = devm_kzalloc(&pdev->dev, sizeof(struct com20020_priv),
113                             GFP_KERNEL);
114         if (!priv)
115                 return -ENOMEM;
116 
117         ci = (struct com20020_pci_card_info *)id->driver_data;
118         priv->ci = ci;
119         mm = &ci->misc_map;
120 
121         INIT_LIST_HEAD(&priv->list_dev);
122 
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 
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;
138 
139                 dev = alloc_arcdev(device);
140                 if (!dev) {
141                         ret = -ENOMEM;
142                         goto out_port;
143                 }
144                 dev->dev_port = i;
145 
146                 dev->netdev_ops = &com20020_netdev_ops;
147 
148                 lp = netdev_priv(dev);
149 
150                 arc_printk(D_NORMAL, dev, "%s Controls\n", ci->name);
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) {
156                         pr_err("IO region %xh-%xh already allocated\n",
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                  */
166                 arcnet_outb(0x00, ioaddr, COM20020_REG_W_COMMAND);
167                 arcnet_inb(ioaddr, COM20020_REG_R_DIAGSTAT);
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 
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 
187                 if (arcnet_inb(ioaddr, COM20020_REG_R_STATUS) == 0xFF) {
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);
199                 if (!card)
200                         return -ENOMEM;
201 
202                 card->index = i;
203                 card->pci_priv = priv;
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;
221                 card->dev = dev;
222 
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 
231                 dev_set_drvdata(&dev->dev, card);
232 
233                 ret = com20020_found(dev, IRQF_SHARED);
234                 if (ret)
235                         goto out_port;
236 
237                 devm_arcnet_led_init(dev, dev->dev_id, i);
238 
239                 list_add(&card->list, &priv->list_dev);
240         }
241 
242         pci_set_drvdata(pdev, priv);
243 
244         return 0;
245 
246 out_port:
247         com20020pci_remove(pdev);
248         return ret;
249 }
250 
251 static void com20020pci_remove(struct pci_dev *pdev)
252 {
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         }
265 }
266 
267 static struct com20020_pci_card_info card_info_10mbit = {
268         .name = "ARC-PCI",
269         .devcount = 1,
270         .chan_map_tbl = {
271                 {
272                         .bar = 2,
273                         .offset = 0x00,
274                         .size = 0x08,
275                 },
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 = {
284                 {
285                         .bar = 2,
286                         .offset = 0x00,
287                         .size = 0x08,
288                 },
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 = {
298                 {
299                         .bar = 4,
300                         .offset = 0x00,
301                         .size = 0x08
302                 },
303         },
304         .flags = ARC_CAN_10MBIT,
305 };
306 
307 static struct com20020_pci_card_info card_info_eae_arc1 = {
308         .name = "EAE PLX-PCI ARC1",
309         .devcount = 1,
310         .chan_map_tbl = {
311                 {
312                         .bar = 2,
313                         .offset = 0x00,
314                         .size = 0x08,
315                 },
316         },
317         .misc_map = {
318                 .bar = 2,
319                 .offset = 0x10,
320                 .size = 0x04,
321         },
322         .leds = {
323                 {
324                         .green = 0x0,
325                         .red = 0x1,
326                 },
327         },
328         .rotary = 0x0,
329         .flags = ARC_CAN_10MBIT,
330 };
331 
332 static struct com20020_pci_card_info card_info_eae_ma1 = {
333         .name = "EAE PLX-PCI MA1",
334         .devcount = 2,
335         .chan_map_tbl = {
336                 {
337                         .bar = 2,
338                         .offset = 0x00,
339                         .size = 0x08,
340                 }, {
341                         .bar = 2,
342                         .offset = 0x08,
343                         .size = 0x08,
344                 }
345         },
346         .misc_map = {
347                 .bar = 2,
348                 .offset = 0x10,
349                 .size = 0x04,
350         },
351         .leds = {
352                 {
353                         .green = 0x0,
354                         .red = 0x1,
355                 }, {
356                         .green = 0x2,
357                         .red = 0x3,
358                 },
359         },
360         .rotary = 0x0,
361         .flags = ARC_CAN_10MBIT,
362 };
363 
364 static const struct pci_device_id com20020pci_id_table[] = {
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         {
498                 0x10B5, 0x9050,
499                 0x10B5, 0x3263,
500                 0, 0,
501                 (kernel_ulong_t)&card_info_eae_arc1
502         },
503         {
504                 0x10B5, 0x9050,
505                 0x10B5, 0x3292,
506                 0, 0,
507                 (kernel_ulong_t)&card_info_eae_ma1
508         },
509         {
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, }
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,
530         .remove         = com20020pci_remove,
531 };
532 
533 static int __init com20020pci_init(void)
534 {
535         if (BUGLVL(D_NORMAL))
536                 pr_info("%s\n", "COM20020 PCI support");
537         return pci_register_driver(&com20020pci_driver);
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)
547 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us