Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

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 #include <linux/module.h>
 30 #include <linux/moduleparam.h>
 31 #include <linux/kernel.h>
 32 #include <linux/types.h>
 33 #include <linux/ioport.h>
 34 #include <linux/errno.h>
 35 #include <linux/netdevice.h>
 36 #include <linux/init.h>
 37 #include <linux/interrupt.h>
 38 #include <linux/pci.h>
 39 #include <linux/arcdevice.h>
 40 #include <linux/com20020.h>
 41 #include <linux/list.h>
 42 
 43 #include <asm/io.h>
 44 
 45 
 46 #define VERSION "arcnet: COM20020 PCI support\n"
 47 
 48 /* Module parameters */
 49 
 50 static int node;
 51 static char device[9];          /* use eg. device="arc1" to change name */
 52 static int timeout = 3;
 53 static int backplane;
 54 static int clockp;
 55 static int clockm;
 56 
 57 module_param(node, int, 0);
 58 module_param_string(device, device, sizeof(device), 0);
 59 module_param(timeout, int, 0);
 60 module_param(backplane, int, 0);
 61 module_param(clockp, int, 0);
 62 module_param(clockm, int, 0);
 63 MODULE_LICENSE("GPL");
 64 
 65 static void com20020pci_remove(struct pci_dev *pdev);
 66 
 67 static int com20020pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 68 {
 69         struct com20020_pci_card_info *ci;
 70         struct net_device *dev;
 71         struct arcnet_local *lp;
 72         struct com20020_priv *priv;
 73         int i, ioaddr, ret;
 74         struct resource *r;
 75 
 76         if (pci_enable_device(pdev))
 77                 return -EIO;
 78 
 79         priv = devm_kzalloc(&pdev->dev, sizeof(struct com20020_priv),
 80                             GFP_KERNEL);
 81         ci = (struct com20020_pci_card_info *)id->driver_data;
 82         priv->ci = ci;
 83 
 84         INIT_LIST_HEAD(&priv->list_dev);
 85 
 86 
 87         for (i = 0; i < ci->devcount; i++) {
 88                 struct com20020_pci_channel_map *cm = &ci->chan_map_tbl[i];
 89                 struct com20020_dev *card;
 90 
 91                 dev = alloc_arcdev(device);
 92                 if (!dev) {
 93                         ret = -ENOMEM;
 94                         goto out_port;
 95                 }
 96 
 97                 dev->netdev_ops = &com20020_netdev_ops;
 98 
 99                 lp = netdev_priv(dev);
100 
101                 BUGMSG(D_NORMAL, "%s Controls\n", ci->name);
102                 ioaddr = pci_resource_start(pdev, cm->bar) + cm->offset;
103 
104                 r = devm_request_region(&pdev->dev, ioaddr, cm->size,
105                                         "com20020-pci");
106                 if (!r) {
107                         pr_err("IO region %xh-%xh already allocated.\n",
108                                ioaddr, ioaddr + cm->size - 1);
109                         ret = -EBUSY;
110                         goto out_port;
111                 }
112 
113                 /* Dummy access after Reset
114                  * ARCNET controller needs
115                  * this access to detect bustype
116                  */
117                 outb(0x00, ioaddr + 1);
118                 inb(ioaddr + 1);
119 
120                 dev->base_addr = ioaddr;
121                 dev->dev_addr[0] = node;
122                 dev->irq = pdev->irq;
123                 lp->card_name = "PCI COM20020";
124                 lp->card_flags = ci->flags;
125                 lp->backplane = backplane;
126                 lp->clockp = clockp & 7;
127                 lp->clockm = clockm & 3;
128                 lp->timeout = timeout;
129                 lp->hw.owner = THIS_MODULE;
130 
131                 if (ASTATUS() == 0xFF) {
132                         pr_err("IO address %Xh is empty!\n", ioaddr);
133                         ret = -EIO;
134                         goto out_port;
135                 }
136                 if (com20020_check(dev)) {
137                         ret = -EIO;
138                         goto out_port;
139                 }
140 
141                 card = devm_kzalloc(&pdev->dev, sizeof(struct com20020_dev),
142                                     GFP_KERNEL);
143                 if (!card) {
144                         pr_err("%s out of memory!\n", __func__);
145                         return -ENOMEM;
146                 }
147 
148                 card->index = i;
149                 card->pci_priv = priv;
150                 card->dev = dev;
151 
152                 dev_set_drvdata(&dev->dev, card);
153 
154                 ret = com20020_found(dev, IRQF_SHARED);
155                 if (ret)
156                         goto out_port;
157 
158                 list_add(&card->list, &priv->list_dev);
159         }
160 
161         pci_set_drvdata(pdev, priv);
162 
163         return 0;
164 
165 out_port:
166         com20020pci_remove(pdev);
167         return ret;
168 }
169 
170 static void com20020pci_remove(struct pci_dev *pdev)
171 {
172         struct com20020_dev *card, *tmpcard;
173         struct com20020_priv *priv;
174 
175         priv = pci_get_drvdata(pdev);
176 
177         list_for_each_entry_safe(card, tmpcard, &priv->list_dev, list) {
178                 struct net_device *dev = card->dev;
179 
180                 unregister_netdev(dev);
181                 free_irq(dev->irq, dev);
182                 free_netdev(dev);
183         }
184 }
185 
186 static struct com20020_pci_card_info card_info_10mbit = {
187         .name = "ARC-PCI",
188         .devcount = 1,
189         .chan_map_tbl = {
190                 { 2, 0x00, 0x08 },
191         },
192         .flags = ARC_CAN_10MBIT,
193 };
194 
195 static struct com20020_pci_card_info card_info_5mbit = {
196         .name = "ARC-PCI",
197         .devcount = 1,
198         .chan_map_tbl = {
199                 { 2, 0x00, 0x08 },
200         },
201         .flags = ARC_IS_5MBIT,
202 };
203 
204 static struct com20020_pci_card_info card_info_sohard = {
205         .name = "PLX-PCI",
206         .devcount = 1,
207         /* SOHARD needs PCI base addr 4 */
208         .chan_map_tbl = {
209                 {4, 0x00, 0x08},
210         },
211         .flags = ARC_CAN_10MBIT,
212 };
213 
214 static struct com20020_pci_card_info card_info_eae = {
215         .name = "EAE PLX-PCI",
216         .devcount = 2,
217         .chan_map_tbl = {
218                 { 2, 0x00, 0x08 },
219                 { 2, 0x08, 0x08 }
220         },
221         .flags = ARC_CAN_10MBIT,
222 };
223 
224 static const struct pci_device_id com20020pci_id_table[] = {
225         {
226                 0x1571, 0xa001,
227                 PCI_ANY_ID, PCI_ANY_ID,
228                 0, 0,
229                 0,
230         },
231         {
232                 0x1571, 0xa002,
233                 PCI_ANY_ID, PCI_ANY_ID,
234                 0, 0,
235                 0,
236         },
237         {
238                 0x1571, 0xa003,
239                 PCI_ANY_ID, PCI_ANY_ID,
240                 0, 0,
241                 0
242         },
243         {
244                 0x1571, 0xa004,
245                 PCI_ANY_ID, PCI_ANY_ID,
246                 0, 0,
247                 0,
248         },
249         {
250                 0x1571, 0xa005,
251                 PCI_ANY_ID, PCI_ANY_ID,
252                 0, 0,
253                 0
254         },
255         {
256                 0x1571, 0xa006,
257                 PCI_ANY_ID, PCI_ANY_ID,
258                 0, 0,
259                 0
260         },
261         {
262                 0x1571, 0xa007,
263                 PCI_ANY_ID, PCI_ANY_ID,
264                 0, 0,
265                 0
266         },
267         {
268                 0x1571, 0xa008,
269                 PCI_ANY_ID, PCI_ANY_ID,
270                 0, 0,
271                 0
272         },
273         {
274                 0x1571, 0xa009,
275                 PCI_ANY_ID, PCI_ANY_ID,
276                 0, 0,
277                 (kernel_ulong_t)&card_info_5mbit
278         },
279         {
280                 0x1571, 0xa00a,
281                 PCI_ANY_ID, PCI_ANY_ID,
282                 0, 0,
283                 (kernel_ulong_t)&card_info_5mbit
284         },
285         {
286                 0x1571, 0xa00b,
287                 PCI_ANY_ID, PCI_ANY_ID,
288                 0, 0,
289                 (kernel_ulong_t)&card_info_5mbit
290         },
291         {
292                 0x1571, 0xa00c,
293                 PCI_ANY_ID, PCI_ANY_ID,
294                 0, 0,
295                 (kernel_ulong_t)&card_info_5mbit
296         },
297         {
298                 0x1571, 0xa00d,
299                 PCI_ANY_ID, PCI_ANY_ID,
300                 0, 0,
301                 (kernel_ulong_t)&card_info_5mbit
302         },
303         {
304                 0x1571, 0xa00e,
305                 PCI_ANY_ID, PCI_ANY_ID,
306                 0, 0,
307                 (kernel_ulong_t)&card_info_5mbit
308         },
309         {
310                 0x1571, 0xa201,
311                 PCI_ANY_ID, PCI_ANY_ID,
312                 0, 0,
313                 (kernel_ulong_t)&card_info_10mbit
314         },
315         {
316                 0x1571, 0xa202,
317                 PCI_ANY_ID, PCI_ANY_ID,
318                 0, 0,
319                 (kernel_ulong_t)&card_info_10mbit
320         },
321         {
322                 0x1571, 0xa203,
323                 PCI_ANY_ID, PCI_ANY_ID,
324                 0, 0,
325                 (kernel_ulong_t)&card_info_10mbit
326         },
327         {
328                 0x1571, 0xa204,
329                 PCI_ANY_ID, PCI_ANY_ID,
330                 0, 0,
331                 (kernel_ulong_t)&card_info_10mbit
332         },
333         {
334                 0x1571, 0xa205,
335                 PCI_ANY_ID, PCI_ANY_ID,
336                 0, 0,
337                 (kernel_ulong_t)&card_info_10mbit
338         },
339         {
340                 0x1571, 0xa206,
341                 PCI_ANY_ID, PCI_ANY_ID,
342                 0, 0,
343                 (kernel_ulong_t)&card_info_10mbit
344         },
345         {
346                 0x10B5, 0x9030,
347                 0x10B5, 0x2978,
348                 0, 0,
349                 (kernel_ulong_t)&card_info_sohard
350         },
351         {
352                 0x10B5, 0x9050,
353                 0x10B5, 0x2273,
354                 0, 0,
355                 (kernel_ulong_t)&card_info_sohard
356         },
357         {
358                 0x10B5, 0x9050,
359                 0x10B5, 0x3292,
360                 0, 0,
361                 (kernel_ulong_t)&card_info_eae
362         },
363         {
364                 0x14BA, 0x6000,
365                 PCI_ANY_ID, PCI_ANY_ID,
366                 0, 0,
367                 (kernel_ulong_t)&card_info_10mbit
368         },
369         {
370                 0x10B5, 0x2200,
371                 PCI_ANY_ID, PCI_ANY_ID,
372                 0, 0,
373                 (kernel_ulong_t)&card_info_10mbit
374         },
375         { 0, }
376 };
377 
378 MODULE_DEVICE_TABLE(pci, com20020pci_id_table);
379 
380 static struct pci_driver com20020pci_driver = {
381         .name           = "com20020",
382         .id_table       = com20020pci_id_table,
383         .probe          = com20020pci_probe,
384         .remove         = com20020pci_remove,
385 };
386 
387 static int __init com20020pci_init(void)
388 {
389         BUGLVL(D_NORMAL) printk(VERSION);
390         return pci_register_driver(&com20020pci_driver);
391 }
392 
393 static void __exit com20020pci_cleanup(void)
394 {
395         pci_unregister_driver(&com20020pci_driver);
396 }
397 
398 module_init(com20020pci_init)
399 module_exit(com20020pci_cleanup)
400 

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