blob: 2470b1ee33c03b2243f9ed40aa4b0071a321d949 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Jeff Garzikf3b197a2006-05-26 21:39:03 -04002 * xircom_cb: A driver for the (tulip-like) Xircom Cardbus ethernet cards
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * This software is (C) by the respective authors, and licensed under the GPL
5 * License.
6 *
7 * Written by Arjan van de Ven for Red Hat, Inc.
Jeff Garzikf3b197a2006-05-26 21:39:03 -04008 * Based on work by Jeff Garzik, Doug Ledford and Donald Becker
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
10 * This software may be used and distributed according to the terms
11 * of the GNU General Public License, incorporated herein by reference.
12 *
13 *
14 * $Id: xircom_cb.c,v 1.33 2001/03/19 14:02:07 arjanv Exp $
15 */
16
17#include <linux/module.h>
18#include <linux/kernel.h>
19#include <linux/string.h>
20#include <linux/errno.h>
21#include <linux/ioport.h>
22#include <linux/slab.h>
23#include <linux/interrupt.h>
24#include <linux/pci.h>
25#include <linux/netdevice.h>
26#include <linux/etherdevice.h>
27#include <linux/skbuff.h>
28#include <linux/delay.h>
29#include <linux/init.h>
30#include <linux/ethtool.h>
31#include <linux/bitops.h>
32
33#include <asm/uaccess.h>
34#include <asm/io.h>
Al Viro82729972005-12-06 05:53:04 -050035#ifdef CONFIG_NET_POLL_CONTROLLER
36#include <asm/irq.h>
37#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39#ifdef DEBUG
40#define enter(x) printk("Enter: %s, %s line %i\n",x,__FILE__,__LINE__)
41#define leave(x) printk("Leave: %s, %s line %i\n",x,__FILE__,__LINE__)
42#else
43#define enter(x) do {} while (0)
44#define leave(x) do {} while (0)
45#endif
46
47
48MODULE_DESCRIPTION("Xircom Cardbus ethernet driver");
49MODULE_AUTHOR("Arjan van de Ven <arjanv@redhat.com>");
50MODULE_LICENSE("GPL");
51
52
53
54/* IO registers on the card, offsets */
55#define CSR0 0x00
56#define CSR1 0x08
57#define CSR2 0x10
58#define CSR3 0x18
59#define CSR4 0x20
60#define CSR5 0x28
61#define CSR6 0x30
62#define CSR7 0x38
63#define CSR8 0x40
64#define CSR9 0x48
65#define CSR10 0x50
66#define CSR11 0x58
67#define CSR12 0x60
68#define CSR13 0x68
69#define CSR14 0x70
70#define CSR15 0x78
71#define CSR16 0x80
72
73/* PCI registers */
74#define PCI_POWERMGMT 0x40
75
76/* Offsets of the buffers within the descriptor pages, in bytes */
77
78#define NUMDESCRIPTORS 4
79
80static int bufferoffsets[NUMDESCRIPTORS] = {128,2048,4096,6144};
81
82
83struct xircom_private {
84 /* Send and receive buffers, kernel-addressable and dma addressable forms */
85
86 unsigned int *rx_buffer;
87 unsigned int *tx_buffer;
88
89 dma_addr_t rx_dma_handle;
90 dma_addr_t tx_dma_handle;
91
92 struct sk_buff *tx_skb[4];
93
94 unsigned long io_port;
95 int open;
Jeff Garzikf3b197a2006-05-26 21:39:03 -040096
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 /* transmit_used is the rotating counter that indicates which transmit
98 descriptor has to be used next */
99 int transmit_used;
100
101 /* Spinlock to serialize register operations.
102 It must be helt while manipulating the following registers:
103 CSR0, CSR6, CSR7, CSR9, CSR10, CSR15
104 */
105 spinlock_t lock;
106
107
108 struct pci_dev *pdev;
109 struct net_device *dev;
110 struct net_device_stats stats;
111};
112
113
114/* Function prototypes */
115static int xircom_probe(struct pci_dev *pdev, const struct pci_device_id *id);
116static void xircom_remove(struct pci_dev *pdev);
David Howells7d12e782006-10-05 14:55:46 +0100117static irqreturn_t xircom_interrupt(int irq, void *dev_instance);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev);
119static int xircom_open(struct net_device *dev);
120static int xircom_close(struct net_device *dev);
121static void xircom_up(struct xircom_private *card);
122static struct net_device_stats *xircom_get_stats(struct net_device *dev);
Keith Owens3be034b2005-09-13 15:05:13 +1000123#ifdef CONFIG_NET_POLL_CONTROLLER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124static void xircom_poll_controller(struct net_device *dev);
125#endif
126
127static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset);
128static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset);
129static void read_mac_address(struct xircom_private *card);
130static void transceiver_voodoo(struct xircom_private *card);
131static void initialize_card(struct xircom_private *card);
132static void trigger_transmit(struct xircom_private *card);
133static void trigger_receive(struct xircom_private *card);
134static void setup_descriptors(struct xircom_private *card);
135static void remove_descriptors(struct xircom_private *card);
136static int link_status_changed(struct xircom_private *card);
137static void activate_receiver(struct xircom_private *card);
138static void deactivate_receiver(struct xircom_private *card);
139static void activate_transmitter(struct xircom_private *card);
140static void deactivate_transmitter(struct xircom_private *card);
141static void enable_transmit_interrupt(struct xircom_private *card);
142static void enable_receive_interrupt(struct xircom_private *card);
143static void enable_link_interrupt(struct xircom_private *card);
144static void disable_all_interrupts(struct xircom_private *card);
145static int link_status(struct xircom_private *card);
146
147
148
149static struct pci_device_id xircom_pci_table[] = {
150 {0x115D, 0x0003, PCI_ANY_ID, PCI_ANY_ID,},
151 {0,},
152};
153MODULE_DEVICE_TABLE(pci, xircom_pci_table);
154
155static struct pci_driver xircom_ops = {
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400156 .name = "xircom_cb",
157 .id_table = xircom_pci_table,
158 .probe = xircom_probe,
159 .remove = xircom_remove,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 .suspend =NULL,
161 .resume =NULL
162};
163
164
165#ifdef DEBUG
166static void print_binary(unsigned int number)
167{
168 int i,i2;
169 char buffer[64];
170 memset(buffer,0,64);
171 i2=0;
172 for (i=31;i>=0;i--) {
173 if (number & (1<<i))
174 buffer[i2++]='1';
175 else
176 buffer[i2++]='0';
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400177 if ((i&3)==0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 buffer[i2++]=' ';
179 }
180 printk("%s\n",buffer);
181}
182#endif
183
184static void netdev_get_drvinfo(struct net_device *dev,
185 struct ethtool_drvinfo *info)
186{
187 struct xircom_private *private = netdev_priv(dev);
188
189 strcpy(info->driver, "xircom_cb");
190 strcpy(info->bus_info, pci_name(private->pdev));
191}
192
Jeff Garzik7282d492006-09-13 14:30:00 -0400193static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 .get_drvinfo = netdev_get_drvinfo,
195};
196
197/* xircom_probe is the code that gets called on device insertion.
198 it sets up the hardware and registers the device to the networklayer.
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 TODO: Send 1 or 2 "dummy" packets here as the card seems to discard the
201 first two packets that get send, and pump hates that.
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400202
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 */
204static int __devinit xircom_probe(struct pci_dev *pdev, const struct pci_device_id *id)
205{
206 struct net_device *dev = NULL;
207 struct xircom_private *private;
208 unsigned char chip_rev;
209 unsigned long flags;
210 unsigned short tmp16;
211 enter("xircom_probe");
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400212
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 /* First do the PCI initialisation */
214
215 if (pci_enable_device(pdev))
216 return -ENODEV;
217
218 /* disable all powermanagement */
219 pci_write_config_dword(pdev, PCI_POWERMGMT, 0x0000);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400220
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 pci_set_master(pdev); /* Why isn't this done by pci_enable_device ?*/
222
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400223 /* clear PCI status, if any */
224 pci_read_config_word (pdev,PCI_STATUS, &tmp16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 pci_write_config_word (pdev, PCI_STATUS,tmp16);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400226
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 pci_read_config_byte(pdev, PCI_REVISION_ID, &chip_rev);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400228
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 if (!request_region(pci_resource_start(pdev, 0), 128, "xircom_cb")) {
230 printk(KERN_ERR "xircom_probe: failed to allocate io-region\n");
231 return -ENODEV;
232 }
233
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400234 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 Before changing the hardware, allocate the memory.
236 This way, we can fail gracefully if not enough memory
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400237 is available.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 */
239 dev = alloc_etherdev(sizeof(struct xircom_private));
240 if (!dev) {
241 printk(KERN_ERR "xircom_probe: failed to allocate etherdev\n");
242 goto device_fail;
243 }
244 private = netdev_priv(dev);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 /* Allocate the send/receive buffers */
247 private->rx_buffer = pci_alloc_consistent(pdev,8192,&private->rx_dma_handle);
248 if (private->rx_buffer == NULL) {
249 printk(KERN_ERR "xircom_probe: no memory for rx buffer \n");
250 goto rx_buf_fail;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400251 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 private->tx_buffer = pci_alloc_consistent(pdev,8192,&private->tx_dma_handle);
253 if (private->tx_buffer == NULL) {
254 printk(KERN_ERR "xircom_probe: no memory for tx buffer \n");
255 goto tx_buf_fail;
256 }
257
258 SET_MODULE_OWNER(dev);
259 SET_NETDEV_DEV(dev, &pdev->dev);
260
261
262 private->dev = dev;
263 private->pdev = pdev;
264 private->io_port = pci_resource_start(pdev, 0);
265 spin_lock_init(&private->lock);
266 dev->irq = pdev->irq;
267 dev->base_addr = private->io_port;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 initialize_card(private);
270 read_mac_address(private);
271 setup_descriptors(private);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 dev->open = &xircom_open;
274 dev->hard_start_xmit = &xircom_start_xmit;
275 dev->stop = &xircom_close;
276 dev->get_stats = &xircom_get_stats;
277 dev->priv = private;
278#ifdef CONFIG_NET_POLL_CONTROLLER
279 dev->poll_controller = &xircom_poll_controller;
280#endif
281 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
282 pci_set_drvdata(pdev, dev);
283
284 if (register_netdev(dev)) {
285 printk(KERN_ERR "xircom_probe: netdevice registration failed.\n");
286 goto reg_fail;
287 }
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400288
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 printk(KERN_INFO "%s: Xircom cardbus revision %i at irq %i \n", dev->name, chip_rev, pdev->irq);
290 /* start the transmitter to get a heartbeat */
291 /* TODO: send 2 dummy packets here */
292 transceiver_voodoo(private);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 spin_lock_irqsave(&private->lock,flags);
295 activate_transmitter(private);
296 activate_receiver(private);
297 spin_unlock_irqrestore(&private->lock,flags);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400298
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 trigger_receive(private);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400300
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 leave("xircom_probe");
302 return 0;
303
304reg_fail:
305 kfree(private->tx_buffer);
306tx_buf_fail:
307 kfree(private->rx_buffer);
308rx_buf_fail:
309 free_netdev(dev);
310device_fail:
311 return -ENODEV;
312}
313
314
315/*
316 xircom_remove is called on module-unload or on device-eject.
317 it unregisters the irq, io-region and network device.
318 Interrupts and such are already stopped in the "ifconfig ethX down"
319 code.
320 */
321static void __devexit xircom_remove(struct pci_dev *pdev)
322{
323 struct net_device *dev = pci_get_drvdata(pdev);
324 struct xircom_private *card = netdev_priv(dev);
325
326 enter("xircom_remove");
327 pci_free_consistent(pdev,8192,card->rx_buffer,card->rx_dma_handle);
328 pci_free_consistent(pdev,8192,card->tx_buffer,card->tx_dma_handle);
329
330 release_region(dev->base_addr, 128);
331 unregister_netdev(dev);
332 free_netdev(dev);
333 pci_set_drvdata(pdev, NULL);
334 leave("xircom_remove");
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400335}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
David Howells7d12e782006-10-05 14:55:46 +0100337static irqreturn_t xircom_interrupt(int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338{
339 struct net_device *dev = (struct net_device *) dev_instance;
340 struct xircom_private *card = netdev_priv(dev);
341 unsigned int status;
342 int i;
343
344 enter("xircom_interrupt\n");
345
346 spin_lock(&card->lock);
347 status = inl(card->io_port+CSR5);
348
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400349#ifdef DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 print_binary(status);
351 printk("tx status 0x%08x 0x%08x \n",card->tx_buffer[0],card->tx_buffer[4]);
352 printk("rx status 0x%08x 0x%08x \n",card->rx_buffer[0],card->rx_buffer[4]);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400353#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 /* Handle shared irq and hotplug */
355 if (status == 0 || status == 0xffffffff) {
356 spin_unlock(&card->lock);
357 return IRQ_NONE;
358 }
359
360 if (link_status_changed(card)) {
361 int newlink;
362 printk(KERN_DEBUG "xircom_cb: Link status has changed \n");
363 newlink = link_status(card);
364 printk(KERN_INFO "xircom_cb: Link is %i mbit \n",newlink);
365 if (newlink)
366 netif_carrier_on(dev);
367 else
368 netif_carrier_off(dev);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400369
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 }
371
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400372 /* Clear all remaining interrupts */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 status |= 0xffffffff; /* FIXME: make this clear only the
374 real existing bits */
375 outl(status,card->io_port+CSR5);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400377
378 for (i=0;i<NUMDESCRIPTORS;i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 investigate_write_descriptor(dev,card,i,bufferoffsets[i]);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400380 for (i=0;i<NUMDESCRIPTORS;i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 investigate_read_descriptor(dev,card,i,bufferoffsets[i]);
382
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400383
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 spin_unlock(&card->lock);
385 leave("xircom_interrupt");
386 return IRQ_HANDLED;
387}
388
389static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev)
390{
391 struct xircom_private *card;
392 unsigned long flags;
393 int nextdescriptor;
394 int desc;
395 enter("xircom_start_xmit");
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400396
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 card = netdev_priv(dev);
398 spin_lock_irqsave(&card->lock,flags);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 /* First see if we can free some descriptors */
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400401 for (desc=0;desc<NUMDESCRIPTORS;desc++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 investigate_write_descriptor(dev,card,desc,bufferoffsets[desc]);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400403
404
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 nextdescriptor = (card->transmit_used +1) % (NUMDESCRIPTORS);
406 desc = card->transmit_used;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400407
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 /* only send the packet if the descriptor is free */
409 if (card->tx_buffer[4*desc]==0) {
410 /* Copy the packet data; zero the memory first as the card
411 sometimes sends more than you ask it to. */
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400412
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 memset(&card->tx_buffer[bufferoffsets[desc]/4],0,1536);
Arnaldo Carvalho de Melod626f622007-03-27 18:55:52 -0300414 skb_copy_from_linear_data(skb,
415 &(card->tx_buffer[bufferoffsets[desc] / 4]),
416 skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 /* FIXME: The specification tells us that the length we send HAS to be a multiple of
418 4 bytes. */
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 card->tx_buffer[4*desc+1] = skb->len;
421 if (desc == NUMDESCRIPTORS-1)
422 card->tx_buffer[4*desc+1] |= (1<<25); /* bit 25: last descriptor of the ring */
423
424 card->tx_buffer[4*desc+1] |= 0xF0000000;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400425 /* 0xF0... means want interrupts*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 card->tx_skb[desc] = skb;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400427
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 wmb();
429 /* This gives the descriptor to the card */
430 card->tx_buffer[4*desc] = 0x80000000;
431 trigger_transmit(card);
432 if (((int)card->tx_buffer[nextdescriptor*4])<0) { /* next descriptor is occupied... */
433 netif_stop_queue(dev);
434 }
435 card->transmit_used = nextdescriptor;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400436 leave("xircom-start_xmit - sent");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 spin_unlock_irqrestore(&card->lock,flags);
438 return 0;
439 }
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
442
443 /* Uh oh... no free descriptor... drop the packet */
444 netif_stop_queue(dev);
445 spin_unlock_irqrestore(&card->lock,flags);
446 trigger_transmit(card);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400447
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 return -EIO;
449}
450
451
452
453
454static int xircom_open(struct net_device *dev)
455{
456 struct xircom_private *xp = netdev_priv(dev);
457 int retval;
458 enter("xircom_open");
459 printk(KERN_INFO "xircom cardbus adaptor found, registering as %s, using irq %i \n",dev->name,dev->irq);
Thomas Gleixner1fb9df52006-07-01 19:29:39 -0700460 retval = request_irq(dev->irq, &xircom_interrupt, IRQF_SHARED, dev->name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 if (retval) {
462 leave("xircom_open - No IRQ");
463 return retval;
464 }
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400465
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 xircom_up(xp);
467 xp->open = 1;
468 leave("xircom_open");
469 return 0;
470}
471
472static int xircom_close(struct net_device *dev)
473{
474 struct xircom_private *card;
475 unsigned long flags;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 enter("xircom_close");
478 card = netdev_priv(dev);
479 netif_stop_queue(dev); /* we don't want new packets */
480
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400481
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 spin_lock_irqsave(&card->lock,flags);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 disable_all_interrupts(card);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400485#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 /* We can enable this again once we send dummy packets on ifconfig ethX up */
487 deactivate_receiver(card);
488 deactivate_transmitter(card);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400489#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 remove_descriptors(card);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400491
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 spin_unlock_irqrestore(&card->lock,flags);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400493
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 card->open = 0;
495 free_irq(dev->irq,dev);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400496
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 leave("xircom_close");
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400498
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 return 0;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400500
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501}
502
503
504
505static struct net_device_stats *xircom_get_stats(struct net_device *dev)
506{
507 struct xircom_private *card = netdev_priv(dev);
508 return &card->stats;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400509}
510
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511
512#ifdef CONFIG_NET_POLL_CONTROLLER
513static void xircom_poll_controller(struct net_device *dev)
514{
515 disable_irq(dev->irq);
David Howells7d12e782006-10-05 14:55:46 +0100516 xircom_interrupt(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 enable_irq(dev->irq);
518}
519#endif
520
521
522static void initialize_card(struct xircom_private *card)
523{
524 unsigned int val;
525 unsigned long flags;
526 enter("initialize_card");
527
528
529 spin_lock_irqsave(&card->lock, flags);
530
531 /* First: reset the card */
532 val = inl(card->io_port + CSR0);
533 val |= 0x01; /* Software reset */
534 outl(val, card->io_port + CSR0);
535
536 udelay(100); /* give the card some time to reset */
537
538 val = inl(card->io_port + CSR0);
539 val &= ~0x01; /* disable Software reset */
540 outl(val, card->io_port + CSR0);
541
542
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400543 val = 0; /* Value 0x00 is a safe and conservative value
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 for the PCI configuration settings */
545 outl(val, card->io_port + CSR0);
546
547
548 disable_all_interrupts(card);
549 deactivate_receiver(card);
550 deactivate_transmitter(card);
551
552 spin_unlock_irqrestore(&card->lock, flags);
553
554 leave("initialize_card");
555}
556
557/*
558trigger_transmit causes the card to check for frames to be transmitted.
559This is accomplished by writing to the CSR1 port. The documentation
560claims that the act of writing is sufficient and that the value is
561ignored; I chose zero.
562*/
563static void trigger_transmit(struct xircom_private *card)
564{
565 unsigned int val;
566 enter("trigger_transmit");
567
568 val = 0;
569 outl(val, card->io_port + CSR1);
570
571 leave("trigger_transmit");
572}
573
574/*
575trigger_receive causes the card to check for empty frames in the
576descriptor list in which packets can be received.
577This is accomplished by writing to the CSR2 port. The documentation
578claims that the act of writing is sufficient and that the value is
579ignored; I chose zero.
580*/
581static void trigger_receive(struct xircom_private *card)
582{
583 unsigned int val;
584 enter("trigger_receive");
585
586 val = 0;
587 outl(val, card->io_port + CSR2);
588
589 leave("trigger_receive");
590}
591
592/*
593setup_descriptors initializes the send and receive buffers to be valid
594descriptors and programs the addresses into the card.
595*/
596static void setup_descriptors(struct xircom_private *card)
597{
598 unsigned int val;
599 unsigned int address;
600 int i;
601 enter("setup_descriptors");
602
603
Eric Sesterhenn / snakebytea707cd62006-01-26 22:02:51 +0100604 BUG_ON(card->rx_buffer == NULL);
605 BUG_ON(card->tx_buffer == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
607 /* Receive descriptors */
608 memset(card->rx_buffer, 0, 128); /* clear the descriptors */
609 for (i=0;i<NUMDESCRIPTORS;i++ ) {
610
611 /* Rx Descr0: It's empty, let the card own it, no errors -> 0x80000000 */
612 card->rx_buffer[i*4 + 0] = 0x80000000;
613 /* Rx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
614 card->rx_buffer[i*4 + 1] = 1536;
615 if (i==NUMDESCRIPTORS-1)
616 card->rx_buffer[i*4 + 1] |= (1 << 25); /* bit 25 is "last descriptor" */
617
618 /* Rx Descr2: address of the buffer
619 we store the buffer at the 2nd half of the page */
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400620
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 address = (unsigned long) card->rx_dma_handle;
622 card->rx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
623 /* Rx Desc3: address of 2nd buffer -> 0 */
624 card->rx_buffer[i*4 + 3] = 0;
625 }
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400626
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 wmb();
628 /* Write the receive descriptor ring address to the card */
629 address = (unsigned long) card->rx_dma_handle;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400630 val = cpu_to_le32(address);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 outl(val, card->io_port + CSR3); /* Receive descr list address */
632
633
634 /* transmit descriptors */
635 memset(card->tx_buffer, 0, 128); /* clear the descriptors */
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400636
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 for (i=0;i<NUMDESCRIPTORS;i++ ) {
638 /* Tx Descr0: Empty, we own it, no errors -> 0x00000000 */
639 card->tx_buffer[i*4 + 0] = 0x00000000;
640 /* Tx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
641 card->tx_buffer[i*4 + 1] = 1536;
642 if (i==NUMDESCRIPTORS-1)
643 card->tx_buffer[i*4 + 1] |= (1 << 25); /* bit 25 is "last descriptor" */
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400644
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 /* Tx Descr2: address of the buffer
646 we store the buffer at the 2nd half of the page */
647 address = (unsigned long) card->tx_dma_handle;
648 card->tx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
649 /* Tx Desc3: address of 2nd buffer -> 0 */
650 card->tx_buffer[i*4 + 3] = 0;
651 }
652
653 wmb();
654 /* wite the transmit descriptor ring to the card */
655 address = (unsigned long) card->tx_dma_handle;
656 val =cpu_to_le32(address);
657 outl(val, card->io_port + CSR4); /* xmit descr list address */
658
659 leave("setup_descriptors");
660}
661
662/*
663remove_descriptors informs the card the descriptors are no longer
664valid by setting the address in the card to 0x00.
665*/
666static void remove_descriptors(struct xircom_private *card)
667{
668 unsigned int val;
669 enter("remove_descriptors");
670
671 val = 0;
672 outl(val, card->io_port + CSR3); /* Receive descriptor address */
673 outl(val, card->io_port + CSR4); /* Send descriptor address */
674
675 leave("remove_descriptors");
676}
677
678/*
679link_status_changed returns 1 if the card has indicated that
680the link status has changed. The new link status has to be read from CSR12.
681
682This function also clears the status-bit.
683*/
684static int link_status_changed(struct xircom_private *card)
685{
686 unsigned int val;
687 enter("link_status_changed");
688
689 val = inl(card->io_port + CSR5); /* Status register */
690
691 if ((val & (1 << 27)) == 0) { /* no change */
692 leave("link_status_changed - nochange");
693 return 0;
694 }
695
696 /* clear the event by writing a 1 to the bit in the
697 status register. */
698 val = (1 << 27);
699 outl(val, card->io_port + CSR5);
700
701 leave("link_status_changed - changed");
702 return 1;
703}
704
705
706/*
707transmit_active returns 1 if the transmitter on the card is
708in a non-stopped state.
709*/
710static int transmit_active(struct xircom_private *card)
711{
712 unsigned int val;
713 enter("transmit_active");
714
715 val = inl(card->io_port + CSR5); /* Status register */
716
717 if ((val & (7 << 20)) == 0) { /* transmitter disabled */
718 leave("transmit_active - inactive");
719 return 0;
720 }
721
722 leave("transmit_active - active");
723 return 1;
724}
725
726/*
727receive_active returns 1 if the receiver on the card is
728in a non-stopped state.
729*/
730static int receive_active(struct xircom_private *card)
731{
732 unsigned int val;
733 enter("receive_active");
734
735
736 val = inl(card->io_port + CSR5); /* Status register */
737
738 if ((val & (7 << 17)) == 0) { /* receiver disabled */
739 leave("receive_active - inactive");
740 return 0;
741 }
742
743 leave("receive_active - active");
744 return 1;
745}
746
747/*
748activate_receiver enables the receiver on the card.
749Before being allowed to active the receiver, the receiver
750must be completely de-activated. To achieve this,
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400751this code actually disables the receiver first; then it waits for the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752receiver to become inactive, then it activates the receiver and then
753it waits for the receiver to be active.
754
755must be called with the lock held and interrupts disabled.
756*/
757static void activate_receiver(struct xircom_private *card)
758{
759 unsigned int val;
760 int counter;
761 enter("activate_receiver");
762
763
764 val = inl(card->io_port + CSR6); /* Operation mode */
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400765
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 /* If the "active" bit is set and the receiver is already
767 active, no need to do the expensive thing */
768 if ((val&2) && (receive_active(card)))
769 return;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400770
771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 val = val & ~2; /* disable the receiver */
773 outl(val, card->io_port + CSR6);
774
775 counter = 10;
776 while (counter > 0) {
777 if (!receive_active(card))
778 break;
779 /* wait a while */
780 udelay(50);
781 counter--;
782 if (counter <= 0)
783 printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
784 }
785
786 /* enable the receiver */
787 val = inl(card->io_port + CSR6); /* Operation mode */
788 val = val | 2; /* enable the receiver */
789 outl(val, card->io_port + CSR6);
790
791 /* now wait for the card to activate again */
792 counter = 10;
793 while (counter > 0) {
794 if (receive_active(card))
795 break;
796 /* wait a while */
797 udelay(50);
798 counter--;
799 if (counter <= 0)
800 printk(KERN_ERR "xircom_cb: Receiver failed to re-activate\n");
801 }
802
803 leave("activate_receiver");
804}
805
806/*
807deactivate_receiver disables the receiver on the card.
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400808To achieve this this code disables the receiver first;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809then it waits for the receiver to become inactive.
810
811must be called with the lock held and interrupts disabled.
812*/
813static void deactivate_receiver(struct xircom_private *card)
814{
815 unsigned int val;
816 int counter;
817 enter("deactivate_receiver");
818
819 val = inl(card->io_port + CSR6); /* Operation mode */
820 val = val & ~2; /* disable the receiver */
821 outl(val, card->io_port + CSR6);
822
823 counter = 10;
824 while (counter > 0) {
825 if (!receive_active(card))
826 break;
827 /* wait a while */
828 udelay(50);
829 counter--;
830 if (counter <= 0)
831 printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
832 }
833
834
835 leave("deactivate_receiver");
836}
837
838
839/*
840activate_transmitter enables the transmitter on the card.
841Before being allowed to active the transmitter, the transmitter
842must be completely de-activated. To achieve this,
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400843this code actually disables the transmitter first; then it waits for the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844transmitter to become inactive, then it activates the transmitter and then
845it waits for the transmitter to be active again.
846
847must be called with the lock held and interrupts disabled.
848*/
849static void activate_transmitter(struct xircom_private *card)
850{
851 unsigned int val;
852 int counter;
853 enter("activate_transmitter");
854
855
856 val = inl(card->io_port + CSR6); /* Operation mode */
857
858 /* If the "active" bit is set and the receiver is already
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400859 active, no need to do the expensive thing */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 if ((val&(1<<13)) && (transmit_active(card)))
861 return;
862
863 val = val & ~(1 << 13); /* disable the transmitter */
864 outl(val, card->io_port + CSR6);
865
866 counter = 10;
867 while (counter > 0) {
868 if (!transmit_active(card))
869 break;
870 /* wait a while */
871 udelay(50);
872 counter--;
873 if (counter <= 0)
874 printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
875 }
876
877 /* enable the transmitter */
878 val = inl(card->io_port + CSR6); /* Operation mode */
879 val = val | (1 << 13); /* enable the transmitter */
880 outl(val, card->io_port + CSR6);
881
882 /* now wait for the card to activate again */
883 counter = 10;
884 while (counter > 0) {
885 if (transmit_active(card))
886 break;
887 /* wait a while */
888 udelay(50);
889 counter--;
890 if (counter <= 0)
891 printk(KERN_ERR "xircom_cb: Transmitter failed to re-activate\n");
892 }
893
894 leave("activate_transmitter");
895}
896
897/*
898deactivate_transmitter disables the transmitter on the card.
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400899To achieve this this code disables the transmitter first;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900then it waits for the transmitter to become inactive.
901
902must be called with the lock held and interrupts disabled.
903*/
904static void deactivate_transmitter(struct xircom_private *card)
905{
906 unsigned int val;
907 int counter;
908 enter("deactivate_transmitter");
909
910 val = inl(card->io_port + CSR6); /* Operation mode */
911 val = val & ~2; /* disable the transmitter */
912 outl(val, card->io_port + CSR6);
913
914 counter = 20;
915 while (counter > 0) {
916 if (!transmit_active(card))
917 break;
918 /* wait a while */
919 udelay(50);
920 counter--;
921 if (counter <= 0)
922 printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
923 }
924
925
926 leave("deactivate_transmitter");
927}
928
929
930/*
931enable_transmit_interrupt enables the transmit interrupt
932
933must be called with the lock held and interrupts disabled.
934*/
935static void enable_transmit_interrupt(struct xircom_private *card)
936{
937 unsigned int val;
938 enter("enable_transmit_interrupt");
939
940 val = inl(card->io_port + CSR7); /* Interrupt enable register */
941 val |= 1; /* enable the transmit interrupt */
942 outl(val, card->io_port + CSR7);
943
944 leave("enable_transmit_interrupt");
945}
946
947
948/*
949enable_receive_interrupt enables the receive interrupt
950
951must be called with the lock held and interrupts disabled.
952*/
953static void enable_receive_interrupt(struct xircom_private *card)
954{
955 unsigned int val;
956 enter("enable_receive_interrupt");
957
958 val = inl(card->io_port + CSR7); /* Interrupt enable register */
959 val = val | (1 << 6); /* enable the receive interrupt */
960 outl(val, card->io_port + CSR7);
961
962 leave("enable_receive_interrupt");
963}
964
965/*
966enable_link_interrupt enables the link status change interrupt
967
968must be called with the lock held and interrupts disabled.
969*/
970static void enable_link_interrupt(struct xircom_private *card)
971{
972 unsigned int val;
973 enter("enable_link_interrupt");
974
975 val = inl(card->io_port + CSR7); /* Interrupt enable register */
976 val = val | (1 << 27); /* enable the link status chage interrupt */
977 outl(val, card->io_port + CSR7);
978
979 leave("enable_link_interrupt");
980}
981
982
983
984/*
985disable_all_interrupts disables all interrupts
986
987must be called with the lock held and interrupts disabled.
988*/
989static void disable_all_interrupts(struct xircom_private *card)
990{
991 unsigned int val;
992 enter("enable_all_interrupts");
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400993
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 val = 0; /* disable all interrupts */
995 outl(val, card->io_port + CSR7);
996
997 leave("disable_all_interrupts");
998}
999
1000/*
1001enable_common_interrupts enables several weird interrupts
1002
1003must be called with the lock held and interrupts disabled.
1004*/
1005static void enable_common_interrupts(struct xircom_private *card)
1006{
1007 unsigned int val;
1008 enter("enable_link_interrupt");
1009
1010 val = inl(card->io_port + CSR7); /* Interrupt enable register */
1011 val |= (1<<16); /* Normal Interrupt Summary */
1012 val |= (1<<15); /* Abnormal Interrupt Summary */
1013 val |= (1<<13); /* Fatal bus error */
1014 val |= (1<<8); /* Receive Process Stopped */
1015 val |= (1<<7); /* Receive Buffer Unavailable */
1016 val |= (1<<5); /* Transmit Underflow */
1017 val |= (1<<2); /* Transmit Buffer Unavailable */
1018 val |= (1<<1); /* Transmit Process Stopped */
1019 outl(val, card->io_port + CSR7);
1020
1021 leave("enable_link_interrupt");
1022}
1023
1024/*
1025enable_promisc starts promisc mode
1026
1027must be called with the lock held and interrupts disabled.
1028*/
1029static int enable_promisc(struct xircom_private *card)
1030{
1031 unsigned int val;
1032 enter("enable_promisc");
1033
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001034 val = inl(card->io_port + CSR6);
1035 val = val | (1 << 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 outl(val, card->io_port + CSR6);
1037
1038 leave("enable_promisc");
1039 return 1;
1040}
1041
1042
1043
1044
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001045/*
Michael Opdenacker59c51592007-05-09 08:57:56 +02001046link_status() checks the links status and will return 0 for no link, 10 for 10mbit link and 100 for.. guess what.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047
1048Must be called in locked state with interrupts disabled
1049*/
1050static int link_status(struct xircom_private *card)
1051{
1052 unsigned int val;
1053 enter("link_status");
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001054
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 val = inb(card->io_port + CSR12);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001056
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 if (!(val&(1<<2))) /* bit 2 is 0 for 10mbit link, 1 for not an 10mbit link */
1058 return 10;
1059 if (!(val&(1<<1))) /* bit 1 is 0 for 100mbit link, 1 for not an 100mbit link */
1060 return 100;
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001061
1062 /* If we get here -> no link at all */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
1064 leave("link_status");
1065 return 0;
1066}
1067
1068
1069
1070
1071
1072/*
1073 read_mac_address() reads the MAC address from the NIC and stores it in the "dev" structure.
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001074
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 This function will take the spinlock itself and can, as a result, not be called with the lock helt.
1076 */
1077static void read_mac_address(struct xircom_private *card)
1078{
1079 unsigned char j, tuple, link, data_id, data_count;
1080 unsigned long flags;
1081 int i;
1082
1083 enter("read_mac_address");
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001084
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 spin_lock_irqsave(&card->lock, flags);
1086
1087 outl(1 << 12, card->io_port + CSR9); /* enable boot rom access */
1088 for (i = 0x100; i < 0x1f7; i += link + 2) {
1089 outl(i, card->io_port + CSR10);
1090 tuple = inl(card->io_port + CSR9) & 0xff;
1091 outl(i + 1, card->io_port + CSR10);
1092 link = inl(card->io_port + CSR9) & 0xff;
1093 outl(i + 2, card->io_port + CSR10);
1094 data_id = inl(card->io_port + CSR9) & 0xff;
1095 outl(i + 3, card->io_port + CSR10);
1096 data_count = inl(card->io_port + CSR9) & 0xff;
1097 if ((tuple == 0x22) && (data_id == 0x04) && (data_count == 0x06)) {
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001098 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 * This is it. We have the data we want.
1100 */
1101 for (j = 0; j < 6; j++) {
1102 outl(i + j + 4, card->io_port + CSR10);
1103 card->dev->dev_addr[j] = inl(card->io_port + CSR9) & 0xff;
1104 }
1105 break;
1106 } else if (link == 0) {
1107 break;
1108 }
1109 }
1110 spin_unlock_irqrestore(&card->lock, flags);
1111#ifdef DEBUG
1112 for (i = 0; i < 6; i++)
1113 printk("%c%2.2X", i ? ':' : ' ', card->dev->dev_addr[i]);
1114 printk("\n");
1115#endif
1116 leave("read_mac_address");
1117}
1118
1119
1120/*
1121 transceiver_voodoo() enables the external UTP plug thingy.
1122 it's called voodoo as I stole this code and cannot cross-reference
1123 it with the specification.
1124 */
1125static void transceiver_voodoo(struct xircom_private *card)
1126{
1127 unsigned long flags;
1128
1129 enter("transceiver_voodoo");
1130
1131 /* disable all powermanagement */
1132 pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
1133
1134 setup_descriptors(card);
1135
1136 spin_lock_irqsave(&card->lock, flags);
1137
1138 outl(0x0008, card->io_port + CSR15);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001139 udelay(25);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 outl(0xa8050000, card->io_port + CSR15);
1141 udelay(25);
1142 outl(0xa00f0000, card->io_port + CSR15);
1143 udelay(25);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001144
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 spin_unlock_irqrestore(&card->lock, flags);
1146
1147 netif_start_queue(card->dev);
1148 leave("transceiver_voodoo");
1149}
1150
1151
1152static void xircom_up(struct xircom_private *card)
1153{
1154 unsigned long flags;
1155 int i;
1156
1157 enter("xircom_up");
1158
1159 /* disable all powermanagement */
1160 pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
1161
1162 setup_descriptors(card);
1163
1164 spin_lock_irqsave(&card->lock, flags);
1165
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001166
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 enable_link_interrupt(card);
1168 enable_transmit_interrupt(card);
1169 enable_receive_interrupt(card);
1170 enable_common_interrupts(card);
1171 enable_promisc(card);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001172
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 /* The card can have received packets already, read them away now */
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001174 for (i=0;i<NUMDESCRIPTORS;i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 investigate_read_descriptor(card->dev,card,i,bufferoffsets[i]);
1176
1177
1178 spin_unlock_irqrestore(&card->lock, flags);
1179 trigger_receive(card);
1180 trigger_transmit(card);
1181 netif_start_queue(card->dev);
1182 leave("xircom_up");
1183}
1184
1185/* Bufferoffset is in BYTES */
1186static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset)
1187{
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001188 int status;
1189
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 enter("investigate_read_descriptor");
1191 status = card->rx_buffer[4*descnr];
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001192
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 if ((status > 0)) { /* packet received */
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 /* TODO: discard error packets */
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001196
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 short pkt_len = ((status >> 16) & 0x7ff) - 4; /* minus 4, we don't want the CRC */
1198 struct sk_buff *skb;
1199
1200 if (pkt_len > 1518) {
1201 printk(KERN_ERR "xircom_cb: Packet length %i is bogus \n",pkt_len);
1202 pkt_len = 1518;
1203 }
1204
1205 skb = dev_alloc_skb(pkt_len + 2);
1206 if (skb == NULL) {
1207 card->stats.rx_dropped++;
1208 goto out;
1209 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 skb_reserve(skb, 2);
1211 eth_copy_and_sum(skb, (unsigned char*)&card->rx_buffer[bufferoffset / 4], pkt_len, 0);
1212 skb_put(skb, pkt_len);
1213 skb->protocol = eth_type_trans(skb, dev);
1214 netif_rx(skb);
1215 dev->last_rx = jiffies;
1216 card->stats.rx_packets++;
1217 card->stats.rx_bytes += pkt_len;
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001218
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 out:
1220 /* give the buffer back to the card */
1221 card->rx_buffer[4*descnr] = 0x80000000;
1222 trigger_receive(card);
1223 }
1224
1225 leave("investigate_read_descriptor");
1226
1227}
1228
1229
1230/* Bufferoffset is in BYTES */
1231static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset)
1232{
1233 int status;
1234
1235 enter("investigate_write_descriptor");
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001236
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 status = card->tx_buffer[4*descnr];
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001238#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 if (status & 0x8000) { /* Major error */
1240 printk(KERN_ERR "Major transmit error status %x \n", status);
1241 card->tx_buffer[4*descnr] = 0;
1242 netif_wake_queue (dev);
1243 }
1244#endif
1245 if (status > 0) { /* bit 31 is 0 when done */
1246 if (card->tx_skb[descnr]!=NULL) {
1247 card->stats.tx_bytes += card->tx_skb[descnr]->len;
1248 dev_kfree_skb_irq(card->tx_skb[descnr]);
1249 }
1250 card->tx_skb[descnr] = NULL;
1251 /* Bit 8 in the status field is 1 if there was a collision */
1252 if (status&(1<<8))
1253 card->stats.collisions++;
1254 card->tx_buffer[4*descnr] = 0; /* descriptor is free again */
1255 netif_wake_queue (dev);
1256 card->stats.tx_packets++;
1257 }
1258
1259 leave("investigate_write_descriptor");
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001260
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261}
1262
1263
1264static int __init xircom_init(void)
1265{
Alexey Dobriyanec42cdb2006-08-14 23:00:28 -07001266 return pci_register_driver(&xircom_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267}
1268
1269static void __exit xircom_exit(void)
1270{
1271 pci_unregister_driver(&xircom_ops);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001272}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001274module_init(xircom_init)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275module_exit(xircom_exit)
1276