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