projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
net: convert print_mac to %pM
[deliverable/linux.git] / drivers / net / tulip / xircom_cb.c
1 /*
2 * xircom_cb: A driver for the (tulip-like) Xircom Cardbus ethernet cards
3 *
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.
8 * Based on work by Jeff Garzik, Doug Ledford and Donald Becker
9 *
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>
35 #ifdef CONFIG_NET_POLL_CONTROLLER
36 #include <asm/irq.h>
37 #endif
38
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
48 MODULE_DESCRIPTION("Xircom Cardbus ethernet driver");
49 MODULE_AUTHOR("Arjan van de Ven <arjanv@redhat.com>");
50 MODULE_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
80 static int bufferoffsets[NUMDESCRIPTORS] = {128,2048,4096,6144};
81
82
83 struct xircom_private {
84 /* Send and receive buffers, kernel-addressable and dma addressable forms */
85
86 __le32 *rx_buffer;
87 __le32 *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;
96
97 /* 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 */
115 static int xircom_probe(struct pci_dev *pdev, const struct pci_device_id *id);
116 static void xircom_remove(struct pci_dev *pdev);
117 static irqreturn_t xircom_interrupt(int irq, void *dev_instance);
118 static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev);
119 static int xircom_open(struct net_device *dev);
120 static int xircom_close(struct net_device *dev);
121 static void xircom_up(struct xircom_private *card);
122 static struct net_device_stats *xircom_get_stats(struct net_device *dev);
123 #ifdef CONFIG_NET_POLL_CONTROLLER
124 static void xircom_poll_controller(struct net_device *dev);
125 #endif
126
127 static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset);
128 static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset);
129 static void read_mac_address(struct xircom_private *card);
130 static void transceiver_voodoo(struct xircom_private *card);
131 static void initialize_card(struct xircom_private *card);
132 static void trigger_transmit(struct xircom_private *card);
133 static void trigger_receive(struct xircom_private *card);
134 static void setup_descriptors(struct xircom_private *card);
135 static void remove_descriptors(struct xircom_private *card);
136 static int link_status_changed(struct xircom_private *card);
137 static void activate_receiver(struct xircom_private *card);
138 static void deactivate_receiver(struct xircom_private *card);
139 static void activate_transmitter(struct xircom_private *card);
140 static void deactivate_transmitter(struct xircom_private *card);
141 static void enable_transmit_interrupt(struct xircom_private *card);
142 static void enable_receive_interrupt(struct xircom_private *card);
143 static void enable_link_interrupt(struct xircom_private *card);
144 static void disable_all_interrupts(struct xircom_private *card);
145 static int link_status(struct xircom_private *card);
146
147
148
149 static struct pci_device_id xircom_pci_table[] = {
150 {0x115D, 0x0003, PCI_ANY_ID, PCI_ANY_ID,},
151 {0,},
152 };
153 MODULE_DEVICE_TABLE(pci, xircom_pci_table);
154
155 static struct pci_driver xircom_ops = {
156 .name = "xircom_cb",
157 .id_table = xircom_pci_table,
158 .probe = xircom_probe,
159 .remove = xircom_remove,
160 .suspend =NULL,
161 .resume =NULL
162 };
163
164
165 #ifdef DEBUG
166 static 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';
177 if ((i&3)==0)
178 buffer[i2++]=' ';
179 }
180 printk("%s\n",buffer);
181 }
182 #endif
183
184 static 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
193 static const struct ethtool_ops netdev_ethtool_ops = {
194 .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.
199
200 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.
202
203 */
204 static 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 long flags;
209 unsigned short tmp16;
210 enter("xircom_probe");
211
212 /* First do the PCI initialisation */
213
214 if (pci_enable_device(pdev))
215 return -ENODEV;
216
217 /* disable all powermanagement */
218 pci_write_config_dword(pdev, PCI_POWERMGMT, 0x0000);
219
220 pci_set_master(pdev); /* Why isn't this done by pci_enable_device ?*/
221
222 /* clear PCI status, if any */
223 pci_read_config_word (pdev,PCI_STATUS, &tmp16);
224 pci_write_config_word (pdev, PCI_STATUS,tmp16);
225
226 if (!request_region(pci_resource_start(pdev, 0), 128, "xircom_cb")) {
227 printk(KERN_ERR "xircom_probe: failed to allocate io-region\n");
228 return -ENODEV;
229 }
230
231 /*
232 Before changing the hardware, allocate the memory.
233 This way, we can fail gracefully if not enough memory
234 is available.
235 */
236 dev = alloc_etherdev(sizeof(struct xircom_private));
237 if (!dev) {
238 printk(KERN_ERR "xircom_probe: failed to allocate etherdev\n");
239 goto device_fail;
240 }
241 private = netdev_priv(dev);
242
243 /* Allocate the send/receive buffers */
244 private->rx_buffer = pci_alloc_consistent(pdev,8192,&private->rx_dma_handle);
245 if (private->rx_buffer == NULL) {
246 printk(KERN_ERR "xircom_probe: no memory for rx buffer \n");
247 goto rx_buf_fail;
248 }
249 private->tx_buffer = pci_alloc_consistent(pdev,8192,&private->tx_dma_handle);
250 if (private->tx_buffer == NULL) {
251 printk(KERN_ERR "xircom_probe: no memory for tx buffer \n");
252 goto tx_buf_fail;
253 }
254
255 SET_NETDEV_DEV(dev, &pdev->dev);
256
257
258 private->dev = dev;
259 private->pdev = pdev;
260 private->io_port = pci_resource_start(pdev, 0);
261 spin_lock_init(&private->lock);
262 dev->irq = pdev->irq;
263 dev->base_addr = private->io_port;
264
265 initialize_card(private);
266 read_mac_address(private);
267 setup_descriptors(private);
268
269 dev->open = &xircom_open;
270 dev->hard_start_xmit = &xircom_start_xmit;
271 dev->stop = &xircom_close;
272 dev->get_stats = &xircom_get_stats;
273 #ifdef CONFIG_NET_POLL_CONTROLLER
274 dev->poll_controller = &xircom_poll_controller;
275 #endif
276 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
277 pci_set_drvdata(pdev, dev);
278
279 if (register_netdev(dev)) {
280 printk(KERN_ERR "xircom_probe: netdevice registration failed.\n");
281 goto reg_fail;
282 }
283
284 printk(KERN_INFO "%s: Xircom cardbus revision %i at irq %i \n", dev->name, pdev->revision, pdev->irq);
285 /* start the transmitter to get a heartbeat */
286 /* TODO: send 2 dummy packets here */
287 transceiver_voodoo(private);
288
289 spin_lock_irqsave(&private->lock,flags);
290 activate_transmitter(private);
291 activate_receiver(private);
292 spin_unlock_irqrestore(&private->lock,flags);
293
294 trigger_receive(private);
295
296 leave("xircom_probe");
297 return 0;
298
299 reg_fail:
300 kfree(private->tx_buffer);
301 tx_buf_fail:
302 kfree(private->rx_buffer);
303 rx_buf_fail:
304 free_netdev(dev);
305 device_fail:
306 return -ENODEV;
307 }
308
309
310 /*
311 xircom_remove is called on module-unload or on device-eject.
312 it unregisters the irq, io-region and network device.
313 Interrupts and such are already stopped in the "ifconfig ethX down"
314 code.
315 */
316 static void __devexit xircom_remove(struct pci_dev *pdev)
317 {
318 struct net_device *dev = pci_get_drvdata(pdev);
319 struct xircom_private *card = netdev_priv(dev);
320
321 enter("xircom_remove");
322 pci_free_consistent(pdev,8192,card->rx_buffer,card->rx_dma_handle);
323 pci_free_consistent(pdev,8192,card->tx_buffer,card->tx_dma_handle);
324
325 release_region(dev->base_addr, 128);
326 unregister_netdev(dev);
327 free_netdev(dev);
328 pci_set_drvdata(pdev, NULL);
329 leave("xircom_remove");
330 }
331
332 static irqreturn_t xircom_interrupt(int irq, void *dev_instance)
333 {
334 struct net_device *dev = (struct net_device *) dev_instance;
335 struct xircom_private *card = netdev_priv(dev);
336 unsigned int status;
337 int i;
338
339 enter("xircom_interrupt\n");
340
341 spin_lock(&card->lock);
342 status = inl(card->io_port+CSR5);
343
344 #ifdef DEBUG
345 print_binary(status);
346 printk("tx status 0x%08x 0x%08x \n",card->tx_buffer[0],card->tx_buffer[4]);
347 printk("rx status 0x%08x 0x%08x \n",card->rx_buffer[0],card->rx_buffer[4]);
348 #endif
349 /* Handle shared irq and hotplug */
350 if (status == 0 || status == 0xffffffff) {
351 spin_unlock(&card->lock);
352 return IRQ_NONE;
353 }
354
355 if (link_status_changed(card)) {
356 int newlink;
357 printk(KERN_DEBUG "xircom_cb: Link status has changed \n");
358 newlink = link_status(card);
359 printk(KERN_INFO "xircom_cb: Link is %i mbit \n",newlink);
360 if (newlink)
361 netif_carrier_on(dev);
362 else
363 netif_carrier_off(dev);
364
365 }
366
367 /* Clear all remaining interrupts */
368 status |= 0xffffffff; /* FIXME: make this clear only the
369 real existing bits */
370 outl(status,card->io_port+CSR5);
371
372
373 for (i=0;i<NUMDESCRIPTORS;i++)
374 investigate_write_descriptor(dev,card,i,bufferoffsets[i]);
375 for (i=0;i<NUMDESCRIPTORS;i++)
376 investigate_read_descriptor(dev,card,i,bufferoffsets[i]);
377
378
379 spin_unlock(&card->lock);
380 leave("xircom_interrupt");
381 return IRQ_HANDLED;
382 }
383
384 static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev)
385 {
386 struct xircom_private *card;
387 unsigned long flags;
388 int nextdescriptor;
389 int desc;
390 enter("xircom_start_xmit");
391
392 card = netdev_priv(dev);
393 spin_lock_irqsave(&card->lock,flags);
394
395 /* First see if we can free some descriptors */
396 for (desc=0;desc<NUMDESCRIPTORS;desc++)
397 investigate_write_descriptor(dev,card,desc,bufferoffsets[desc]);
398
399
400 nextdescriptor = (card->transmit_used +1) % (NUMDESCRIPTORS);
401 desc = card->transmit_used;
402
403 /* only send the packet if the descriptor is free */
404 if (card->tx_buffer[4*desc]==0) {
405 /* Copy the packet data; zero the memory first as the card
406 sometimes sends more than you ask it to. */
407
408 memset(&card->tx_buffer[bufferoffsets[desc]/4],0,1536);
409 skb_copy_from_linear_data(skb,
410 &(card->tx_buffer[bufferoffsets[desc] / 4]),
411 skb->len);
412 /* FIXME: The specification tells us that the length we send HAS to be a multiple of
413 4 bytes. */
414
415 card->tx_buffer[4*desc+1] = cpu_to_le32(skb->len);
416 if (desc == NUMDESCRIPTORS - 1) /* bit 25: last descriptor of the ring */
417 card->tx_buffer[4*desc+1] |= cpu_to_le32(1<<25);
418
419 card->tx_buffer[4*desc+1] |= cpu_to_le32(0xF0000000);
420 /* 0xF0... means want interrupts*/
421 card->tx_skb[desc] = skb;
422
423 wmb();
424 /* This gives the descriptor to the card */
425 card->tx_buffer[4*desc] = cpu_to_le32(0x80000000);
426 trigger_transmit(card);
427 if (card->tx_buffer[nextdescriptor*4] & cpu_to_le32(0x8000000)) {
428 /* next descriptor is occupied... */
429 netif_stop_queue(dev);
430 }
431 card->transmit_used = nextdescriptor;
432 leave("xircom-start_xmit - sent");
433 spin_unlock_irqrestore(&card->lock,flags);
434 return 0;
435 }
436
437
438
439 /* Uh oh... no free descriptor... drop the packet */
440 netif_stop_queue(dev);
441 spin_unlock_irqrestore(&card->lock,flags);
442 trigger_transmit(card);
443
444 return NETDEV_TX_BUSY;
445 }
446
447
448
449
450 static int xircom_open(struct net_device *dev)
451 {
452 struct xircom_private *xp = netdev_priv(dev);
453 int retval;
454 enter("xircom_open");
455 printk(KERN_INFO "xircom cardbus adaptor found, registering as %s, using irq %i \n",dev->name,dev->irq);
456 retval = request_irq(dev->irq, &xircom_interrupt, IRQF_SHARED, dev->name, dev);
457 if (retval) {
458 leave("xircom_open - No IRQ");
459 return retval;
460 }
461
462 xircom_up(xp);
463 xp->open = 1;
464 leave("xircom_open");
465 return 0;
466 }
467
468 static int xircom_close(struct net_device *dev)
469 {
470 struct xircom_private *card;
471 unsigned long flags;
472
473 enter("xircom_close");
474 card = netdev_priv(dev);
475 netif_stop_queue(dev); /* we don't want new packets */
476
477
478 spin_lock_irqsave(&card->lock,flags);
479
480 disable_all_interrupts(card);
481 #if 0
482 /* We can enable this again once we send dummy packets on ifconfig ethX up */
483 deactivate_receiver(card);
484 deactivate_transmitter(card);
485 #endif
486 remove_descriptors(card);
487
488 spin_unlock_irqrestore(&card->lock,flags);
489
490 card->open = 0;
491 free_irq(dev->irq,dev);
492
493 leave("xircom_close");
494
495 return 0;
496
497 }
498
499
500
501 static struct net_device_stats *xircom_get_stats(struct net_device *dev)
502 {
503 struct xircom_private *card = netdev_priv(dev);
504 return &card->stats;
505 }
506
507
508 #ifdef CONFIG_NET_POLL_CONTROLLER
509 static void xircom_poll_controller(struct net_device *dev)
510 {
511 disable_irq(dev->irq);
512 xircom_interrupt(dev->irq, dev);
513 enable_irq(dev->irq);
514 }
515 #endif
516
517
518 static void initialize_card(struct xircom_private *card)
519 {
520 unsigned int val;
521 unsigned long flags;
522 enter("initialize_card");
523
524
525 spin_lock_irqsave(&card->lock, flags);
526
527 /* First: reset the card */
528 val = inl(card->io_port + CSR0);
529 val |= 0x01; /* Software reset */
530 outl(val, card->io_port + CSR0);
531
532 udelay(100); /* give the card some time to reset */
533
534 val = inl(card->io_port + CSR0);
535 val &= ~0x01; /* disable Software reset */
536 outl(val, card->io_port + CSR0);
537
538
539 val = 0; /* Value 0x00 is a safe and conservative value
540 for the PCI configuration settings */
541 outl(val, card->io_port + CSR0);
542
543
544 disable_all_interrupts(card);
545 deactivate_receiver(card);
546 deactivate_transmitter(card);
547
548 spin_unlock_irqrestore(&card->lock, flags);
549
550 leave("initialize_card");
551 }
552
553 /*
554 trigger_transmit causes the card to check for frames to be transmitted.
555 This is accomplished by writing to the CSR1 port. The documentation
556 claims that the act of writing is sufficient and that the value is
557 ignored; I chose zero.
558 */
559 static void trigger_transmit(struct xircom_private *card)
560 {
561 unsigned int val;
562 enter("trigger_transmit");
563
564 val = 0;
565 outl(val, card->io_port + CSR1);
566
567 leave("trigger_transmit");
568 }
569
570 /*
571 trigger_receive causes the card to check for empty frames in the
572 descriptor list in which packets can be received.
573 This is accomplished by writing to the CSR2 port. The documentation
574 claims that the act of writing is sufficient and that the value is
575 ignored; I chose zero.
576 */
577 static void trigger_receive(struct xircom_private *card)
578 {
579 unsigned int val;
580 enter("trigger_receive");
581
582 val = 0;
583 outl(val, card->io_port + CSR2);
584
585 leave("trigger_receive");
586 }
587
588 /*
589 setup_descriptors initializes the send and receive buffers to be valid
590 descriptors and programs the addresses into the card.
591 */
592 static void setup_descriptors(struct xircom_private *card)
593 {
594 u32 address;
595 int i;
596 enter("setup_descriptors");
597
598
599 BUG_ON(card->rx_buffer == NULL);
600 BUG_ON(card->tx_buffer == NULL);
601
602 /* Receive descriptors */
603 memset(card->rx_buffer, 0, 128); /* clear the descriptors */
604 for (i=0;i<NUMDESCRIPTORS;i++ ) {
605
606 /* Rx Descr0: It's empty, let the card own it, no errors -> 0x80000000 */
607 card->rx_buffer[i*4 + 0] = cpu_to_le32(0x80000000);
608 /* Rx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
609 card->rx_buffer[i*4 + 1] = cpu_to_le32(1536);
610 if (i == NUMDESCRIPTORS - 1) /* bit 25 is "last descriptor" */
611 card->rx_buffer[i*4 + 1] |= cpu_to_le32(1 << 25);
612
613 /* Rx Descr2: address of the buffer
614 we store the buffer at the 2nd half of the page */
615
616 address = card->rx_dma_handle;
617 card->rx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
618 /* Rx Desc3: address of 2nd buffer -> 0 */
619 card->rx_buffer[i*4 + 3] = 0;
620 }
621
622 wmb();
623 /* Write the receive descriptor ring address to the card */
624 address = card->rx_dma_handle;
625 outl(address, card->io_port + CSR3); /* Receive descr list address */
626
627
628 /* transmit descriptors */
629 memset(card->tx_buffer, 0, 128); /* clear the descriptors */
630
631 for (i=0;i<NUMDESCRIPTORS;i++ ) {
632 /* Tx Descr0: Empty, we own it, no errors -> 0x00000000 */
633 card->tx_buffer[i*4 + 0] = 0x00000000;
634 /* Tx Descr1: buffer 1 is 1536 bytes, buffer 2 is 0 bytes */
635 card->tx_buffer[i*4 + 1] = cpu_to_le32(1536);
636 if (i == NUMDESCRIPTORS - 1) /* bit 25 is "last descriptor" */
637 card->tx_buffer[i*4 + 1] |= cpu_to_le32(1 << 25);
638
639 /* Tx Descr2: address of the buffer
640 we store the buffer at the 2nd half of the page */
641 address = card->tx_dma_handle;
642 card->tx_buffer[i*4 + 2] = cpu_to_le32(address + bufferoffsets[i]);
643 /* Tx Desc3: address of 2nd buffer -> 0 */
644 card->tx_buffer[i*4 + 3] = 0;
645 }
646
647 wmb();
648 /* wite the transmit descriptor ring to the card */
649 address = card->tx_dma_handle;
650 outl(address, card->io_port + CSR4); /* xmit descr list address */
651
652 leave("setup_descriptors");
653 }
654
655 /*
656 remove_descriptors informs the card the descriptors are no longer
657 valid by setting the address in the card to 0x00.
658 */
659 static void remove_descriptors(struct xircom_private *card)
660 {
661 unsigned int val;
662 enter("remove_descriptors");
663
664 val = 0;
665 outl(val, card->io_port + CSR3); /* Receive descriptor address */
666 outl(val, card->io_port + CSR4); /* Send descriptor address */
667
668 leave("remove_descriptors");
669 }
670
671 /*
672 link_status_changed returns 1 if the card has indicated that
673 the link status has changed. The new link status has to be read from CSR12.
674
675 This function also clears the status-bit.
676 */
677 static int link_status_changed(struct xircom_private *card)
678 {
679 unsigned int val;
680 enter("link_status_changed");
681
682 val = inl(card->io_port + CSR5); /* Status register */
683
684 if ((val & (1 << 27)) == 0) { /* no change */
685 leave("link_status_changed - nochange");
686 return 0;
687 }
688
689 /* clear the event by writing a 1 to the bit in the
690 status register. */
691 val = (1 << 27);
692 outl(val, card->io_port + CSR5);
693
694 leave("link_status_changed - changed");
695 return 1;
696 }
697
698
699 /*
700 transmit_active returns 1 if the transmitter on the card is
701 in a non-stopped state.
702 */
703 static int transmit_active(struct xircom_private *card)
704 {
705 unsigned int val;
706 enter("transmit_active");
707
708 val = inl(card->io_port + CSR5); /* Status register */
709
710 if ((val & (7 << 20)) == 0) { /* transmitter disabled */
711 leave("transmit_active - inactive");
712 return 0;
713 }
714
715 leave("transmit_active - active");
716 return 1;
717 }
718
719 /*
720 receive_active returns 1 if the receiver on the card is
721 in a non-stopped state.
722 */
723 static int receive_active(struct xircom_private *card)
724 {
725 unsigned int val;
726 enter("receive_active");
727
728
729 val = inl(card->io_port + CSR5); /* Status register */
730
731 if ((val & (7 << 17)) == 0) { /* receiver disabled */
732 leave("receive_active - inactive");
733 return 0;
734 }
735
736 leave("receive_active - active");
737 return 1;
738 }
739
740 /*
741 activate_receiver enables the receiver on the card.
742 Before being allowed to active the receiver, the receiver
743 must be completely de-activated. To achieve this,
744 this code actually disables the receiver first; then it waits for the
745 receiver to become inactive, then it activates the receiver and then
746 it waits for the receiver to be active.
747
748 must be called with the lock held and interrupts disabled.
749 */
750 static void activate_receiver(struct xircom_private *card)
751 {
752 unsigned int val;
753 int counter;
754 enter("activate_receiver");
755
756
757 val = inl(card->io_port + CSR6); /* Operation mode */
758
759 /* If the "active" bit is set and the receiver is already
760 active, no need to do the expensive thing */
761 if ((val&2) && (receive_active(card)))
762 return;
763
764
765 val = val & ~2; /* disable the receiver */
766 outl(val, card->io_port + CSR6);
767
768 counter = 10;
769 while (counter > 0) {
770 if (!receive_active(card))
771 break;
772 /* wait a while */
773 udelay(50);
774 counter--;
775 if (counter <= 0)
776 printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
777 }
778
779 /* enable the receiver */
780 val = inl(card->io_port + CSR6); /* Operation mode */
781 val = val | 2; /* enable the receiver */
782 outl(val, card->io_port + CSR6);
783
784 /* now wait for the card to activate again */
785 counter = 10;
786 while (counter > 0) {
787 if (receive_active(card))
788 break;
789 /* wait a while */
790 udelay(50);
791 counter--;
792 if (counter <= 0)
793 printk(KERN_ERR "xircom_cb: Receiver failed to re-activate\n");
794 }
795
796 leave("activate_receiver");
797 }
798
799 /*
800 deactivate_receiver disables the receiver on the card.
801 To achieve this this code disables the receiver first;
802 then it waits for the receiver to become inactive.
803
804 must be called with the lock held and interrupts disabled.
805 */
806 static void deactivate_receiver(struct xircom_private *card)
807 {
808 unsigned int val;
809 int counter;
810 enter("deactivate_receiver");
811
812 val = inl(card->io_port + CSR6); /* Operation mode */
813 val = val & ~2; /* disable the receiver */
814 outl(val, card->io_port + CSR6);
815
816 counter = 10;
817 while (counter > 0) {
818 if (!receive_active(card))
819 break;
820 /* wait a while */
821 udelay(50);
822 counter--;
823 if (counter <= 0)
824 printk(KERN_ERR "xircom_cb: Receiver failed to deactivate\n");
825 }
826
827
828 leave("deactivate_receiver");
829 }
830
831
832 /*
833 activate_transmitter enables the transmitter on the card.
834 Before being allowed to active the transmitter, the transmitter
835 must be completely de-activated. To achieve this,
836 this code actually disables the transmitter first; then it waits for the
837 transmitter to become inactive, then it activates the transmitter and then
838 it waits for the transmitter to be active again.
839
840 must be called with the lock held and interrupts disabled.
841 */
842 static void activate_transmitter(struct xircom_private *card)
843 {
844 unsigned int val;
845 int counter;
846 enter("activate_transmitter");
847
848
849 val = inl(card->io_port + CSR6); /* Operation mode */
850
851 /* If the "active" bit is set and the receiver is already
852 active, no need to do the expensive thing */
853 if ((val&(1<<13)) && (transmit_active(card)))
854 return;
855
856 val = val & ~(1 << 13); /* disable the transmitter */
857 outl(val, card->io_port + CSR6);
858
859 counter = 10;
860 while (counter > 0) {
861 if (!transmit_active(card))
862 break;
863 /* wait a while */
864 udelay(50);
865 counter--;
866 if (counter <= 0)
867 printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
868 }
869
870 /* enable the transmitter */
871 val = inl(card->io_port + CSR6); /* Operation mode */
872 val = val | (1 << 13); /* enable the transmitter */
873 outl(val, card->io_port + CSR6);
874
875 /* now wait for the card to activate again */
876 counter = 10;
877 while (counter > 0) {
878 if (transmit_active(card))
879 break;
880 /* wait a while */
881 udelay(50);
882 counter--;
883 if (counter <= 0)
884 printk(KERN_ERR "xircom_cb: Transmitter failed to re-activate\n");
885 }
886
887 leave("activate_transmitter");
888 }
889
890 /*
891 deactivate_transmitter disables the transmitter on the card.
892 To achieve this this code disables the transmitter first;
893 then it waits for the transmitter to become inactive.
894
895 must be called with the lock held and interrupts disabled.
896 */
897 static void deactivate_transmitter(struct xircom_private *card)
898 {
899 unsigned int val;
900 int counter;
901 enter("deactivate_transmitter");
902
903 val = inl(card->io_port + CSR6); /* Operation mode */
904 val = val & ~2; /* disable the transmitter */
905 outl(val, card->io_port + CSR6);
906
907 counter = 20;
908 while (counter > 0) {
909 if (!transmit_active(card))
910 break;
911 /* wait a while */
912 udelay(50);
913 counter--;
914 if (counter <= 0)
915 printk(KERN_ERR "xircom_cb: Transmitter failed to deactivate\n");
916 }
917
918
919 leave("deactivate_transmitter");
920 }
921
922
923 /*
924 enable_transmit_interrupt enables the transmit interrupt
925
926 must be called with the lock held and interrupts disabled.
927 */
928 static void enable_transmit_interrupt(struct xircom_private *card)
929 {
930 unsigned int val;
931 enter("enable_transmit_interrupt");
932
933 val = inl(card->io_port + CSR7); /* Interrupt enable register */
934 val |= 1; /* enable the transmit interrupt */
935 outl(val, card->io_port + CSR7);
936
937 leave("enable_transmit_interrupt");
938 }
939
940
941 /*
942 enable_receive_interrupt enables the receive interrupt
943
944 must be called with the lock held and interrupts disabled.
945 */
946 static void enable_receive_interrupt(struct xircom_private *card)
947 {
948 unsigned int val;
949 enter("enable_receive_interrupt");
950
951 val = inl(card->io_port + CSR7); /* Interrupt enable register */
952 val = val | (1 << 6); /* enable the receive interrupt */
953 outl(val, card->io_port + CSR7);
954
955 leave("enable_receive_interrupt");
956 }
957
958 /*
959 enable_link_interrupt enables the link status change interrupt
960
961 must be called with the lock held and interrupts disabled.
962 */
963 static void enable_link_interrupt(struct xircom_private *card)
964 {
965 unsigned int val;
966 enter("enable_link_interrupt");
967
968 val = inl(card->io_port + CSR7); /* Interrupt enable register */
969 val = val | (1 << 27); /* enable the link status chage interrupt */
970 outl(val, card->io_port + CSR7);
971
972 leave("enable_link_interrupt");
973 }
974
975
976
977 /*
978 disable_all_interrupts disables all interrupts
979
980 must be called with the lock held and interrupts disabled.
981 */
982 static void disable_all_interrupts(struct xircom_private *card)
983 {
984 unsigned int val;
985 enter("enable_all_interrupts");
986
987 val = 0; /* disable all interrupts */
988 outl(val, card->io_port + CSR7);
989
990 leave("disable_all_interrupts");
991 }
992
993 /*
994 enable_common_interrupts enables several weird interrupts
995
996 must be called with the lock held and interrupts disabled.
997 */
998 static void enable_common_interrupts(struct xircom_private *card)
999 {
1000 unsigned int val;
1001 enter("enable_link_interrupt");
1002
1003 val = inl(card->io_port + CSR7); /* Interrupt enable register */
1004 val |= (1<<16); /* Normal Interrupt Summary */
1005 val |= (1<<15); /* Abnormal Interrupt Summary */
1006 val |= (1<<13); /* Fatal bus error */
1007 val |= (1<<8); /* Receive Process Stopped */
1008 val |= (1<<7); /* Receive Buffer Unavailable */
1009 val |= (1<<5); /* Transmit Underflow */
1010 val |= (1<<2); /* Transmit Buffer Unavailable */
1011 val |= (1<<1); /* Transmit Process Stopped */
1012 outl(val, card->io_port + CSR7);
1013
1014 leave("enable_link_interrupt");
1015 }
1016
1017 /*
1018 enable_promisc starts promisc mode
1019
1020 must be called with the lock held and interrupts disabled.
1021 */
1022 static int enable_promisc(struct xircom_private *card)
1023 {
1024 unsigned int val;
1025 enter("enable_promisc");
1026
1027 val = inl(card->io_port + CSR6);
1028 val = val | (1 << 6);
1029 outl(val, card->io_port + CSR6);
1030
1031 leave("enable_promisc");
1032 return 1;
1033 }
1034
1035
1036
1037
1038 /*
1039 link_status() checks the links status and will return 0 for no link, 10 for 10mbit link and 100 for.. guess what.
1040
1041 Must be called in locked state with interrupts disabled
1042 */
1043 static int link_status(struct xircom_private *card)
1044 {
1045 unsigned int val;
1046 enter("link_status");
1047
1048 val = inb(card->io_port + CSR12);
1049
1050 if (!(val&(1<<2))) /* bit 2 is 0 for 10mbit link, 1 for not an 10mbit link */
1051 return 10;
1052 if (!(val&(1<<1))) /* bit 1 is 0 for 100mbit link, 1 for not an 100mbit link */
1053 return 100;
1054
1055 /* If we get here -> no link at all */
1056
1057 leave("link_status");
1058 return 0;
1059 }
1060
1061
1062
1063
1064
1065 /*
1066 read_mac_address() reads the MAC address from the NIC and stores it in the "dev" structure.
1067
1068 This function will take the spinlock itself and can, as a result, not be called with the lock helt.
1069 */
1070 static void read_mac_address(struct xircom_private *card)
1071 {
1072 unsigned char j, tuple, link, data_id, data_count;
1073 unsigned long flags;
1074 int i;
1075
1076 enter("read_mac_address");
1077
1078 spin_lock_irqsave(&card->lock, flags);
1079
1080 outl(1 << 12, card->io_port + CSR9); /* enable boot rom access */
1081 for (i = 0x100; i < 0x1f7; i += link + 2) {
1082 outl(i, card->io_port + CSR10);
1083 tuple = inl(card->io_port + CSR9) & 0xff;
1084 outl(i + 1, card->io_port + CSR10);
1085 link = inl(card->io_port + CSR9) & 0xff;
1086 outl(i + 2, card->io_port + CSR10);
1087 data_id = inl(card->io_port + CSR9) & 0xff;
1088 outl(i + 3, card->io_port + CSR10);
1089 data_count = inl(card->io_port + CSR9) & 0xff;
1090 if ((tuple == 0x22) && (data_id == 0x04) && (data_count == 0x06)) {
1091 /*
1092 * This is it. We have the data we want.
1093 */
1094 for (j = 0; j < 6; j++) {
1095 outl(i + j + 4, card->io_port + CSR10);
1096 card->dev->dev_addr[j] = inl(card->io_port + CSR9) & 0xff;
1097 }
1098 break;
1099 } else if (link == 0) {
1100 break;
1101 }
1102 }
1103 spin_unlock_irqrestore(&card->lock, flags);
1104 pr_debug(" %pM\n", card->dev->dev_addr);
1105 leave("read_mac_address");
1106 }
1107
1108
1109 /*
1110 transceiver_voodoo() enables the external UTP plug thingy.
1111 it's called voodoo as I stole this code and cannot cross-reference
1112 it with the specification.
1113 */
1114 static void transceiver_voodoo(struct xircom_private *card)
1115 {
1116 unsigned long flags;
1117
1118 enter("transceiver_voodoo");
1119
1120 /* disable all powermanagement */
1121 pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
1122
1123 setup_descriptors(card);
1124
1125 spin_lock_irqsave(&card->lock, flags);
1126
1127 outl(0x0008, card->io_port + CSR15);
1128 udelay(25);
1129 outl(0xa8050000, card->io_port + CSR15);
1130 udelay(25);
1131 outl(0xa00f0000, card->io_port + CSR15);
1132 udelay(25);
1133
1134 spin_unlock_irqrestore(&card->lock, flags);
1135
1136 netif_start_queue(card->dev);
1137 leave("transceiver_voodoo");
1138 }
1139
1140
1141 static void xircom_up(struct xircom_private *card)
1142 {
1143 unsigned long flags;
1144 int i;
1145
1146 enter("xircom_up");
1147
1148 /* disable all powermanagement */
1149 pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000);
1150
1151 setup_descriptors(card);
1152
1153 spin_lock_irqsave(&card->lock, flags);
1154
1155
1156 enable_link_interrupt(card);
1157 enable_transmit_interrupt(card);
1158 enable_receive_interrupt(card);
1159 enable_common_interrupts(card);
1160 enable_promisc(card);
1161
1162 /* The card can have received packets already, read them away now */
1163 for (i=0;i<NUMDESCRIPTORS;i++)
1164 investigate_read_descriptor(card->dev,card,i,bufferoffsets[i]);
1165
1166
1167 spin_unlock_irqrestore(&card->lock, flags);
1168 trigger_receive(card);
1169 trigger_transmit(card);
1170 netif_start_queue(card->dev);
1171 leave("xircom_up");
1172 }
1173
1174 /* Bufferoffset is in BYTES */
1175 static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset)
1176 {
1177 int status;
1178
1179 enter("investigate_read_descriptor");
1180 status = le32_to_cpu(card->rx_buffer[4*descnr]);
1181
1182 if ((status > 0)) { /* packet received */
1183
1184 /* TODO: discard error packets */
1185
1186 short pkt_len = ((status >> 16) & 0x7ff) - 4; /* minus 4, we don't want the CRC */
1187 struct sk_buff *skb;
1188
1189 if (pkt_len > 1518) {
1190 printk(KERN_ERR "xircom_cb: Packet length %i is bogus \n",pkt_len);
1191 pkt_len = 1518;
1192 }
1193
1194 skb = dev_alloc_skb(pkt_len + 2);
1195 if (skb == NULL) {
1196 card->stats.rx_dropped++;
1197 goto out;
1198 }
1199 skb_reserve(skb, 2);
1200 skb_copy_to_linear_data(skb, (unsigned char*)&card->rx_buffer[bufferoffset / 4], pkt_len);
1201 skb_put(skb, pkt_len);
1202 skb->protocol = eth_type_trans(skb, dev);
1203 netif_rx(skb);
1204 dev->last_rx = jiffies;
1205 card->stats.rx_packets++;
1206 card->stats.rx_bytes += pkt_len;
1207
1208 out:
1209 /* give the buffer back to the card */
1210 card->rx_buffer[4*descnr] = cpu_to_le32(0x80000000);
1211 trigger_receive(card);
1212 }
1213
1214 leave("investigate_read_descriptor");
1215
1216 }
1217
1218
1219 /* Bufferoffset is in BYTES */
1220 static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset)
1221 {
1222 int status;
1223
1224 enter("investigate_write_descriptor");
1225
1226 status = le32_to_cpu(card->tx_buffer[4*descnr]);
1227 #if 0
1228 if (status & 0x8000) { /* Major error */
1229 printk(KERN_ERR "Major transmit error status %x \n", status);
1230 card->tx_buffer[4*descnr] = 0;
1231 netif_wake_queue (dev);
1232 }
1233 #endif
1234 if (status > 0) { /* bit 31 is 0 when done */
1235 if (card->tx_skb[descnr]!=NULL) {
1236 card->stats.tx_bytes += card->tx_skb[descnr]->len;
1237 dev_kfree_skb_irq(card->tx_skb[descnr]);
1238 }
1239 card->tx_skb[descnr] = NULL;
1240 /* Bit 8 in the status field is 1 if there was a collision */
1241 if (status&(1<<8))
1242 card->stats.collisions++;
1243 card->tx_buffer[4*descnr] = 0; /* descriptor is free again */
1244 netif_wake_queue (dev);
1245 card->stats.tx_packets++;
1246 }
1247
1248 leave("investigate_write_descriptor");
1249
1250 }
1251
1252
1253 static int __init xircom_init(void)
1254 {
1255 return pci_register_driver(&xircom_ops);
1256 }
1257
1258 static void __exit xircom_exit(void)
1259 {
1260 pci_unregister_driver(&xircom_ops);
1261 }
1262
1263 module_init(xircom_init)
1264 module_exit(xircom_exit)
1265
Linux kernel - Deliverables
This page took 0.057013 seconds and 5 git commands to generate.