aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorDave Jones <davej@redhat.com>2009-07-23 21:11:12 -0400
committerDavid S. Miller <davem@davemloft.net>2009-07-23 21:11:12 -0400
commit2cf71d2e388cb0076b03f40f2fadfc590c228461 (patch)
tree472f6569c6b7a7abf34bffe3af2a3004d189b238
parentc40674001b162f9218ba2a6f26188177c6a4e763 (diff)
Remove unnecessary forward declarations from velocity NIC driver.
By moving functions to before their first call, we eliminate the need to define forward references. Signed-off-by: Dave Jones <davej@redhat.com> Signed-off-by: David S. Miller <davem@davemloft.net>
Diffstat
-rw-r--r--drivers/net/via-velocity.c3261
1 files changed, 1580 insertions, 1681 deletions
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index d6a92b794f35..47be41a39d35 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -92,7 +92,6 @@ static int msglevel = MSG_LEVEL_INFO;
92 * Fetch the mask bits of the selected CAM and store them into the 92 * Fetch the mask bits of the selected CAM and store them into the
93 * provided mask buffer. 93 * provided mask buffer.
94 */ 94 */
95
96static void mac_get_cam_mask(struct mac_regs __iomem *regs, u8 *mask) 95static void mac_get_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
97{ 96{
98 int i; 97 int i;
@@ -121,7 +120,6 @@ static void mac_get_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
121 * 120 *
122 * Store a new mask into a CAM 121 * Store a new mask into a CAM
123 */ 122 */
124
125static void mac_set_cam_mask(struct mac_regs __iomem *regs, u8 *mask) 123static void mac_set_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
126{ 124{
127 int i; 125 int i;
@@ -166,7 +164,6 @@ static void mac_set_vlan_cam_mask(struct mac_regs __iomem *regs, u8 *mask)
166 * 164 *
167 * Load an address or vlan tag into a CAM 165 * Load an address or vlan tag into a CAM
168 */ 166 */
169
170static void mac_set_cam(struct mac_regs __iomem *regs, int idx, const u8 *addr) 167static void mac_set_cam(struct mac_regs __iomem *regs, int idx, const u8 *addr)
171{ 168{
172 int i; 169 int i;
@@ -222,7 +219,6 @@ static void mac_set_vlan_cam(struct mac_regs __iomem *regs, int idx,
222 * reset the Wake on lan features. This function doesn't restore 219 * reset the Wake on lan features. This function doesn't restore
223 * the rest of the logic from the result of sleep/wakeup 220 * the rest of the logic from the result of sleep/wakeup
224 */ 221 */
225
226static void mac_wol_reset(struct mac_regs __iomem *regs) 222static void mac_wol_reset(struct mac_regs __iomem *regs)
227{ 223{
228 224
@@ -241,7 +237,6 @@ static void mac_wol_reset(struct mac_regs __iomem *regs)
241 writew(0xFFFF, &regs->WOLSRClr); 237 writew(0xFFFF, &regs->WOLSRClr);
242} 238}
243 239
244static int velocity_mii_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
245static const struct ethtool_ops velocity_ethtool_ops; 240static const struct ethtool_ops velocity_ethtool_ops;
246 241
247/* 242/*
@@ -369,76 +364,14 @@ static int rx_copybreak = 200;
369module_param(rx_copybreak, int, 0644); 364module_param(rx_copybreak, int, 0644);
370MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames"); 365MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");
371 366
372static void velocity_init_info(struct pci_dev *pdev, struct velocity_info *vptr,
373 const struct velocity_info_tbl *info);
374static int velocity_get_pci_info(struct velocity_info *, struct pci_dev *pdev);
375static void velocity_print_info(struct velocity_info *vptr);
376static int velocity_open(struct net_device *dev);
377static int velocity_change_mtu(struct net_device *dev, int mtu);
378static int velocity_xmit(struct sk_buff *skb, struct net_device *dev);
379static irqreturn_t velocity_intr(int irq, void *dev_instance);
380static void velocity_set_multi(struct net_device *dev);
381static struct net_device_stats *velocity_get_stats(struct net_device *dev);
382static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
383static int velocity_close(struct net_device *dev);
384static int velocity_receive_frame(struct velocity_info *, int idx);
385static int velocity_alloc_rx_buf(struct velocity_info *, int idx);
386static void velocity_free_rd_ring(struct velocity_info *vptr);
387static void velocity_free_tx_buf(struct velocity_info *vptr, struct velocity_td_info *);
388static int velocity_soft_reset(struct velocity_info *vptr);
389static void mii_init(struct velocity_info *vptr, u32 mii_status);
390static u32 velocity_get_link(struct net_device *dev);
391static u32 velocity_get_opt_media_mode(struct velocity_info *vptr);
392static void velocity_print_link_status(struct velocity_info *vptr);
393static void safe_disable_mii_autopoll(struct mac_regs __iomem *regs);
394static void velocity_shutdown(struct velocity_info *vptr);
395static void enable_flow_control_ability(struct velocity_info *vptr);
396static void enable_mii_autopoll(struct mac_regs __iomem *regs);
397static int velocity_mii_read(struct mac_regs __iomem *, u8 byIdx, u16 *pdata);
398static int velocity_mii_write(struct mac_regs __iomem *, u8 byMiiAddr, u16 data);
399static u32 mii_check_media_mode(struct mac_regs __iomem *regs);
400static u32 check_connection_type(struct mac_regs __iomem *regs);
401static int velocity_set_media_mode(struct velocity_info *vptr, u32 mii_status);
402
403#ifdef CONFIG_PM 367#ifdef CONFIG_PM
404
405static int velocity_suspend(struct pci_dev *pdev, pm_message_t state);
406static int velocity_resume(struct pci_dev *pdev);
407
408static DEFINE_SPINLOCK(velocity_dev_list_lock); 368static DEFINE_SPINLOCK(velocity_dev_list_lock);
409static LIST_HEAD(velocity_dev_list); 369static LIST_HEAD(velocity_dev_list);
410
411#endif
412
413#if defined(CONFIG_PM) && defined(CONFIG_INET)
414
415static int velocity_netdev_event(struct notifier_block *nb, unsigned long notification, void *ptr);
416
417static struct notifier_block velocity_inetaddr_notifier = {
418 .notifier_call = velocity_netdev_event,
419};
420
421static void velocity_register_notifier(void)
422{
423 register_inetaddr_notifier(&velocity_inetaddr_notifier);
424}
425
426static void velocity_unregister_notifier(void)
427{
428 unregister_inetaddr_notifier(&velocity_inetaddr_notifier);
429}
430
431#else
432
433#define velocity_register_notifier() do {} while (0)
434#define velocity_unregister_notifier() do {} while (0)
435
436#endif 370#endif
437 371
438/* 372/*
439 * Internal board variants. At the moment we have only one 373 * Internal board variants. At the moment we have only one
440 */ 374 */
441
442static struct velocity_info_tbl chip_info_table[] = { 375static struct velocity_info_tbl chip_info_table[] = {
443 {CHIP_TYPE_VT6110, "VIA Networking Velocity Family Gigabit Ethernet Adapter", 1, 0x00FFFFFFUL}, 376 {CHIP_TYPE_VT6110, "VIA Networking Velocity Family Gigabit Ethernet Adapter", 1, 0x00FFFFFFUL},
444 { } 377 { }
@@ -448,7 +381,6 @@ static struct velocity_info_tbl chip_info_table[] = {
448 * Describe the PCI device identifiers that we support in this 381 * Describe the PCI device identifiers that we support in this
449 * device driver. Used for hotplug autoloading. 382 * device driver. Used for hotplug autoloading.
450 */ 383 */
451
452static const struct pci_device_id velocity_id_table[] __devinitdata = { 384static const struct pci_device_id velocity_id_table[] __devinitdata = {
453 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_612X) }, 385 { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_612X) },
454 { } 386 { }
@@ -463,7 +395,6 @@ MODULE_DEVICE_TABLE(pci, velocity_id_table);
463 * Given a chip identifier return a suitable description. Returns 395 * Given a chip identifier return a suitable description. Returns
464 * a pointer a static string valid while the driver is loaded. 396 * a pointer a static string valid while the driver is loaded.
465 */ 397 */
466
467static const char __devinit *get_chip_name(enum chip_type chip_id) 398static const char __devinit *get_chip_name(enum chip_type chip_id)
468{ 399{
469 int i; 400 int i;
@@ -481,7 +412,6 @@ static const char __devinit *get_chip_name(enum chip_type chip_id)
481 * unload for each active device that is present. Disconnects 412 * unload for each active device that is present. Disconnects
482 * the device from the network layer and frees all the resources 413 * the device from the network layer and frees all the resources
483 */ 414 */
484
485static void __devexit velocity_remove1(struct pci_dev *pdev) 415static void __devexit velocity_remove1(struct pci_dev *pdev)
486{ 416{
487 struct net_device *dev = pci_get_drvdata(pdev); 417 struct net_device *dev = pci_get_drvdata(pdev);
@@ -519,7 +449,6 @@ static void __devexit velocity_remove1(struct pci_dev *pdev)
519 * all the verification and checking as well as reporting so that 449 * all the verification and checking as well as reporting so that
520 * we don't duplicate code for each option. 450 * we don't duplicate code for each option.
521 */ 451 */
522
523static void __devinit velocity_set_int_opt(int *opt, int val, int min, int max, int def, char *name, const char *devname) 452static void __devinit velocity_set_int_opt(int *opt, int val, int min, int max, int def, char *name, const char *devname)
524{ 453{
525 if (val == -1) 454 if (val == -1)
@@ -548,7 +477,6 @@ static void __devinit velocity_set_int_opt(int *opt, int val, int min, int max,
548 * all the verification and checking as well as reporting so that 477 * all the verification and checking as well as reporting so that
549 * we don't duplicate code for each option. 478 * we don't duplicate code for each option.
550 */ 479 */
551
552static void __devinit velocity_set_bool_opt(u32 *opt, int val, int def, u32 flag, char *name, const char *devname) 480static void __devinit velocity_set_bool_opt(u32 *opt, int val, int def, u32 flag, char *name, const char *devname)
553{ 481{
554 (*opt) &= (~flag); 482 (*opt) &= (~flag);
@@ -574,7 +502,6 @@ static void __devinit velocity_set_bool_opt(u32 *opt, int val, int def, u32 flag
574 * Turn the module and command options into a single structure 502 * Turn the module and command options into a single structure
575 * for the current device 503 * for the current device
576 */ 504 */
577
578static void __devinit velocity_get_options(struct velocity_opt *opts, int index, const char *devname) 505static void __devinit velocity_get_options(struct velocity_opt *opts, int index, const char *devname)
579{ 506{
580 507
@@ -600,7 +527,6 @@ static void __devinit velocity_get_options(struct velocity_opt *opts, int index,
600 * Initialize the content addressable memory used for filters. Load 527 * Initialize the content addressable memory used for filters. Load
601 * appropriately according to the presence of VLAN 528 * appropriately according to the presence of VLAN
602 */ 529 */
603
604static void velocity_init_cam_filter(struct velocity_info *vptr) 530static void velocity_init_cam_filter(struct velocity_info *vptr)
605{ 531{
606 struct mac_regs __iomem *regs = vptr->mac_regs; 532 struct mac_regs __iomem *regs = vptr->mac_regs;
@@ -673,7 +599,6 @@ static void velocity_init_rx_ring_indexes(struct velocity_info *vptr)
673 * Reset the ownership and status for the receive ring side. 599 * Reset the ownership and status for the receive ring side.
674 * Hand all the receive queue to the NIC. 600 * Hand all the receive queue to the NIC.
675 */ 601 */
676
677static void velocity_rx_reset(struct velocity_info *vptr) 602static void velocity_rx_reset(struct velocity_info *vptr)
678{ 603{
679 604
@@ -695,6 +620,647 @@ static void velocity_rx_reset(struct velocity_info *vptr)
695} 620}
696 621
697/** 622/**
623 * velocity_get_opt_media_mode - get media selection
624 * @vptr: velocity adapter
625 *
626 * Get the media mode stored in EEPROM or module options and load
627 * mii_status accordingly. The requested link state information
628 * is also returned.
629 */
630static u32 velocity_get_opt_media_mode(struct velocity_info *vptr)
631{
632 u32 status = 0;
633
634 switch (vptr->options.spd_dpx) {
635 case SPD_DPX_AUTO:
636 status = VELOCITY_AUTONEG_ENABLE;
637 break;
638 case SPD_DPX_100_FULL:
639 status = VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL;
640 break;
641 case SPD_DPX_10_FULL:
642 status = VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL;
643 break;
644 case SPD_DPX_100_HALF:
645 status = VELOCITY_SPEED_100;
646 break;
647 case SPD_DPX_10_HALF:
648 status = VELOCITY_SPEED_10;
649 break;
650 }
651 vptr->mii_status = status;
652 return status;
653}
654
655/**
656 * safe_disable_mii_autopoll - autopoll off
657 * @regs: velocity registers
658 *
659 * Turn off the autopoll and wait for it to disable on the chip
660 */
661static void safe_disable_mii_autopoll(struct mac_regs __iomem *regs)
662{
663 u16 ww;
664
665 /* turn off MAUTO */
666 writeb(0, &regs->MIICR);
667 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
668 udelay(1);
669 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
670 break;
671 }
672}
673
674/**
675 * enable_mii_autopoll - turn on autopolling
676 * @regs: velocity registers
677 *
678 * Enable the MII link status autopoll feature on the Velocity
679 * hardware. Wait for it to enable.
680 */
681static void enable_mii_autopoll(struct mac_regs __iomem *regs)
682{
683 int ii;
684
685 writeb(0, &(regs->MIICR));
686 writeb(MIIADR_SWMPL, &regs->MIIADR);
687
688 for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
689 udelay(1);
690 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
691 break;
692 }
693
694 writeb(MIICR_MAUTO, &regs->MIICR);
695
696 for (ii = 0; ii < W_MAX_TIMEOUT; ii++) {
697 udelay(1);
698 if (!BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
699 break;
700 }
701
702}
703
704/**
705 * velocity_mii_read - read MII data
706 * @regs: velocity registers
707 * @index: MII register index
708 * @data: buffer for received data
709 *
710 * Perform a single read of an MII 16bit register. Returns zero
711 * on success or -ETIMEDOUT if the PHY did not respond.
712 */
713static int velocity_mii_read(struct mac_regs __iomem *regs, u8 index, u16 *data)
714{
715 u16 ww;
716
717 /*
718 * Disable MIICR_MAUTO, so that mii addr can be set normally
719 */
720 safe_disable_mii_autopoll(regs);
721
722 writeb(index, &regs->MIIADR);
723
724 BYTE_REG_BITS_ON(MIICR_RCMD, &regs->MIICR);
725
726 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
727 if (!(readb(&regs->MIICR) & MIICR_RCMD))
728 break;
729 }
730
731 *data = readw(&regs->MIIDATA);
732
733 enable_mii_autopoll(regs);
734 if (ww == W_MAX_TIMEOUT)
735 return -ETIMEDOUT;
736 return 0;
737}
738
739
740/**
741 * mii_check_media_mode - check media state
742 * @regs: velocity registers
743 *
744 * Check the current MII status and determine the link status
745 * accordingly
746 */
747static u32 mii_check_media_mode(struct mac_regs __iomem *regs)
748{
749 u32 status = 0;
750 u16 ANAR;
751
752 if (!MII_REG_BITS_IS_ON(BMSR_LNK, MII_REG_BMSR, regs))
753 status |= VELOCITY_LINK_FAIL;
754
755 if (MII_REG_BITS_IS_ON(G1000CR_1000FD, MII_REG_G1000CR, regs))
756 status |= VELOCITY_SPEED_1000 | VELOCITY_DUPLEX_FULL;
757 else if (MII_REG_BITS_IS_ON(G1000CR_1000, MII_REG_G1000CR, regs))
758 status |= (VELOCITY_SPEED_1000);
759 else {
760 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
761 if (ANAR & ANAR_TXFD)
762 status |= (VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL);
763 else if (ANAR & ANAR_TX)
764 status |= VELOCITY_SPEED_100;
765 else if (ANAR & ANAR_10FD)
766 status |= (VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL);
767 else
768 status |= (VELOCITY_SPEED_10);
769 }
770
771 if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, regs)) {
772 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
773 if ((ANAR & (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10))
774 == (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) {
775 if (MII_REG_BITS_IS_ON(G1000CR_1000 | G1000CR_1000FD, MII_REG_G1000CR, regs))
776 status |= VELOCITY_AUTONEG_ENABLE;
777 }
778 }
779
780 return status;
781}
782
783/**
784 * velocity_mii_write - write MII data
785 * @regs: velocity registers
786 * @index: MII register index
787 * @data: 16bit data for the MII register
788 *
789 * Perform a single write to an MII 16bit register. Returns zero
790 * on success or -ETIMEDOUT if the PHY did not respond.
791 */
792static int velocity_mii_write(struct mac_regs __iomem *regs, u8 mii_addr, u16 data)
793{
794 u16 ww;
795
796 /*
797 * Disable MIICR_MAUTO, so that mii addr can be set normally
798 */
799 safe_disable_mii_autopoll(regs);
800
801 /* MII reg offset */
802 writeb(mii_addr, &regs->MIIADR);
803 /* set MII data */
804 writew(data, &regs->MIIDATA);
805
806 /* turn on MIICR_WCMD */
807 BYTE_REG_BITS_ON(MIICR_WCMD, &regs->MIICR);
808
809 /* W_MAX_TIMEOUT is the timeout period */
810 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
811 udelay(5);
812 if (!(readb(&regs->MIICR) & MIICR_WCMD))
813 break;
814 }
815 enable_mii_autopoll(regs);
816
817 if (ww == W_MAX_TIMEOUT)
818 return -ETIMEDOUT;
819 return 0;
820}
821
822/**
823 * set_mii_flow_control - flow control setup
824 * @vptr: velocity interface
825 *
826 * Set up the flow control on this interface according to
827 * the supplied user/eeprom options.
828 */
829static void set_mii_flow_control(struct velocity_info *vptr)
830{
831 /*Enable or Disable PAUSE in ANAR */
832 switch (vptr->options.flow_cntl) {
833 case FLOW_CNTL_TX:
834 MII_REG_BITS_OFF(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
835 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
836 break;
837
838 case FLOW_CNTL_RX:
839 MII_REG_BITS_ON(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
840 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
841 break;
842
843 case FLOW_CNTL_TX_RX:
844 MII_REG_BITS_ON(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
845 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
846 break;
847
848 case FLOW_CNTL_DISABLE:
849 MII_REG_BITS_OFF(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
850 MII_REG_BITS_OFF(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
851 break;
852 default:
853 break;
854 }
855}
856
857/**
858 * mii_set_auto_on - autonegotiate on
859 * @vptr: velocity
860 *
861 * Enable autonegotation on this interface
862 */
863static void mii_set_auto_on(struct velocity_info *vptr)
864{
865 if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs))
866 MII_REG_BITS_ON(BMCR_REAUTO, MII_REG_BMCR, vptr->mac_regs);
867 else
868 MII_REG_BITS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs);
869}
870
871static u32 check_connection_type(struct mac_regs __iomem *regs)
872{
873 u32 status = 0;
874 u8 PHYSR0;
875 u16 ANAR;
876 PHYSR0 = readb(&regs->PHYSR0);
877
878 /*
879 if (!(PHYSR0 & PHYSR0_LINKGD))
880 status|=VELOCITY_LINK_FAIL;
881 */
882
883 if (PHYSR0 & PHYSR0_FDPX)
884 status |= VELOCITY_DUPLEX_FULL;
885
886 if (PHYSR0 & PHYSR0_SPDG)
887 status |= VELOCITY_SPEED_1000;
888 else if (PHYSR0 & PHYSR0_SPD10)
889 status |= VELOCITY_SPEED_10;
890 else
891 status |= VELOCITY_SPEED_100;
892
893 if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, regs)) {
894 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
895 if ((ANAR & (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10))
896 == (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) {
897 if (MII_REG_BITS_IS_ON(G1000CR_1000 | G1000CR_1000FD, MII_REG_G1000CR, regs))
898 status |= VELOCITY_AUTONEG_ENABLE;
899 }
900 }
901
902 return status;
903}
904
905
906
907/**
908 * velocity_set_media_mode - set media mode
909 * @mii_status: old MII link state
910 *
911 * Check the media link state and configure the flow control
912 * PHY and also velocity hardware setup accordingly. In particular
913 * we need to set up CD polling and frame bursting.
914 */
915static int velocity_set_media_mode(struct velocity_info *vptr, u32 mii_status)
916{
917 u32 curr_status;
918 struct mac_regs __iomem *regs = vptr->mac_regs;
919
920 vptr->mii_status = mii_check_media_mode(vptr->mac_regs);
921 curr_status = vptr->mii_status & (~VELOCITY_LINK_FAIL);
922
923 /* Set mii link status */
924 set_mii_flow_control(vptr);
925
926 /*
927 Check if new status is consisent with current status
928 if (((mii_status & curr_status) & VELOCITY_AUTONEG_ENABLE)
929 || (mii_status==curr_status)) {
930 vptr->mii_status=mii_check_media_mode(vptr->mac_regs);
931 vptr->mii_status=check_connection_type(vptr->mac_regs);
932 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity link no change\n");
933 return 0;
934 }
935 */
936
937 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201)
938 MII_REG_BITS_ON(AUXCR_MDPPS, MII_REG_AUXCR, vptr->mac_regs);
939
940 /*
941 * If connection type is AUTO
942 */
943 if (mii_status & VELOCITY_AUTONEG_ENABLE) {
944 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity is AUTO mode\n");
945 /* clear force MAC mode bit */
946 BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
947 /* set duplex mode of MAC according to duplex mode of MII */
948 MII_REG_BITS_ON(ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10, MII_REG_ANAR, vptr->mac_regs);
949 MII_REG_BITS_ON(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
950 MII_REG_BITS_ON(BMCR_SPEED1G, MII_REG_BMCR, vptr->mac_regs);
951
952 /* enable AUTO-NEGO mode */
953 mii_set_auto_on(vptr);
954 } else {
955 u16 ANAR;
956 u8 CHIPGCR;
957
958 /*
959 * 1. if it's 3119, disable frame bursting in halfduplex mode
960 * and enable it in fullduplex mode
961 * 2. set correct MII/GMII and half/full duplex mode in CHIPGCR
962 * 3. only enable CD heart beat counter in 10HD mode
963 */
964
965 /* set force MAC mode bit */
966 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
967
968 CHIPGCR = readb(&regs->CHIPGCR);
969 CHIPGCR &= ~CHIPGCR_FCGMII;
970
971 if (mii_status & VELOCITY_DUPLEX_FULL) {
972 CHIPGCR |= CHIPGCR_FCFDX;
973 writeb(CHIPGCR, &regs->CHIPGCR);
974 VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced full mode\n");
975 if (vptr->rev_id < REV_ID_VT3216_A0)
976 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
977 } else {
978 CHIPGCR &= ~CHIPGCR_FCFDX;
979 VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced half mode\n");
980 writeb(CHIPGCR, &regs->CHIPGCR);
981 if (vptr->rev_id < REV_ID_VT3216_A0)
982 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
983 }
984
985 MII_REG_BITS_OFF(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
986
987 if (!(mii_status & VELOCITY_DUPLEX_FULL) && (mii_status & VELOCITY_SPEED_10))
988 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
989 else
990 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
991
992 /* MII_REG_BITS_OFF(BMCR_SPEED1G, MII_REG_BMCR, vptr->mac_regs); */
993 velocity_mii_read(vptr->mac_regs, MII_REG_ANAR, &ANAR);
994 ANAR &= (~(ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10));
995 if (mii_status & VELOCITY_SPEED_100) {
996 if (mii_status & VELOCITY_DUPLEX_FULL)
997 ANAR |= ANAR_TXFD;
998 else
999 ANAR |= ANAR_TX;
1000 } else {
1001 if (mii_status & VELOCITY_DUPLEX_FULL)
1002 ANAR |= ANAR_10FD;
1003 else
1004 ANAR |= ANAR_10;
1005 }
1006 velocity_mii_write(vptr->mac_regs, MII_REG_ANAR, ANAR);
1007 /* enable AUTO-NEGO mode */
1008 mii_set_auto_on(vptr);
1009 /* MII_REG_BITS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs); */
1010 }
1011 /* vptr->mii_status=mii_check_media_mode(vptr->mac_regs); */
1012 /* vptr->mii_status=check_connection_type(vptr->mac_regs); */
1013 return VELOCITY_LINK_CHANGE;
1014}
1015
1016/**
1017 * velocity_print_link_status - link status reporting
1018 * @vptr: velocity to report on
1019 *
1020 * Turn the link status of the velocity card into a kernel log
1021 * description of the new link state, detailing speed and duplex
1022 * status
1023 */
1024static void velocity_print_link_status(struct velocity_info *vptr)
1025{
1026
1027 if (vptr->mii_status & VELOCITY_LINK_FAIL) {
1028 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: failed to detect cable link\n", vptr->dev->name);
1029 } else if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1030 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link auto-negotiation", vptr->dev->name);
1031
1032 if (vptr->mii_status & VELOCITY_SPEED_1000)
1033 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps");
1034 else if (vptr->mii_status & VELOCITY_SPEED_100)
1035 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps");
1036 else
1037 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps");
1038
1039 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1040 VELOCITY_PRT(MSG_LEVEL_INFO, " full duplex\n");
1041 else
1042 VELOCITY_PRT(MSG_LEVEL_INFO, " half duplex\n");
1043 } else {
1044 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link forced", vptr->dev->name);
1045 switch (vptr->options.spd_dpx) {
1046 case SPD_DPX_100_HALF:
1047 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps half duplex\n");
1048 break;
1049 case SPD_DPX_100_FULL:
1050 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps full duplex\n");
1051 break;
1052 case SPD_DPX_10_HALF:
1053 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps half duplex\n");
1054 break;
1055 case SPD_DPX_10_FULL:
1056 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps full duplex\n");
1057 break;
1058 default:
1059 break;
1060 }
1061 }
1062}
1063
1064/**
1065 * enable_flow_control_ability - flow control
1066 * @vptr: veloity to configure
1067 *
1068 * Set up flow control according to the flow control options
1069 * determined by the eeprom/configuration.
1070 */
1071static void enable_flow_control_ability(struct velocity_info *vptr)
1072{
1073
1074 struct mac_regs __iomem *regs = vptr->mac_regs;
1075
1076 switch (vptr->options.flow_cntl) {
1077
1078 case FLOW_CNTL_DEFAULT:
1079 if (BYTE_REG_BITS_IS_ON(PHYSR0_RXFLC, &regs->PHYSR0))
1080 writel(CR0_FDXRFCEN, &regs->CR0Set);
1081 else
1082 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1083
1084 if (BYTE_REG_BITS_IS_ON(PHYSR0_TXFLC, &regs->PHYSR0))
1085 writel(CR0_FDXTFCEN, &regs->CR0Set);
1086 else
1087 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1088 break;
1089
1090 case FLOW_CNTL_TX:
1091 writel(CR0_FDXTFCEN, &regs->CR0Set);
1092 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1093 break;
1094
1095 case FLOW_CNTL_RX:
1096 writel(CR0_FDXRFCEN, &regs->CR0Set);
1097 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1098 break;
1099
1100 case FLOW_CNTL_TX_RX:
1101 writel(CR0_FDXTFCEN, &regs->CR0Set);
1102 writel(CR0_FDXRFCEN, &regs->CR0Set);
1103 break;
1104
1105 case FLOW_CNTL_DISABLE:
1106 writel(CR0_FDXRFCEN, &regs->CR0Clr);
1107 writel(CR0_FDXTFCEN, &regs->CR0Clr);
1108 break;
1109
1110 default:
1111 break;
1112 }
1113
1114}
1115
1116/**
1117 * velocity_soft_reset - soft reset
1118 * @vptr: velocity to reset
1119 *
1120 * Kick off a soft reset of the velocity adapter and then poll
1121 * until the reset sequence has completed before returning.
1122 */
1123static int velocity_soft_reset(struct velocity_info *vptr)
1124{
1125 struct mac_regs __iomem *regs = vptr->mac_regs;
1126 int i = 0;
1127
1128 writel(CR0_SFRST, &regs->CR0Set);
1129
1130 for (i = 0; i < W_MAX_TIMEOUT; i++) {
1131 udelay(5);
1132 if (!DWORD_REG_BITS_IS_ON(CR0_SFRST, &regs->CR0Set))
1133 break;
1134 }
1135
1136 if (i == W_MAX_TIMEOUT) {
1137 writel(CR0_FORSRST, &regs->CR0Set);
1138 /* FIXME: PCI POSTING */
1139 /* delay 2ms */
1140 mdelay(2);
1141 }
1142 return 0;
1143}
1144
1145/**
1146 * velocity_set_multi - filter list change callback
1147 * @dev: network device
1148 *
1149 * Called by the network layer when the filter lists need to change
1150 * for a velocity adapter. Reload the CAMs with the new address
1151 * filter ruleset.
1152 */
1153static void velocity_set_multi(struct net_device *dev)
1154{
1155 struct velocity_info *vptr = netdev_priv(dev);
1156 struct mac_regs __iomem *regs = vptr->mac_regs;
1157 u8 rx_mode;
1158 int i;
1159 struct dev_mc_list *mclist;
1160
1161 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
1162 writel(0xffffffff, &regs->MARCAM[0]);
1163 writel(0xffffffff, &regs->MARCAM[4]);
1164 rx_mode = (RCR_AM | RCR_AB | RCR_PROM);
1165 } else if ((dev->mc_count > vptr->multicast_limit)
1166 || (dev->flags & IFF_ALLMULTI)) {
1167 writel(0xffffffff, &regs->MARCAM[0]);
1168 writel(0xffffffff, &regs->MARCAM[4]);
1169 rx_mode = (RCR_AM | RCR_AB);
1170 } else {
1171 int offset = MCAM_SIZE - vptr->multicast_limit;
1172 mac_get_cam_mask(regs, vptr->mCAMmask);
1173
1174 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count; i++, mclist = mclist->next) {
1175 mac_set_cam(regs, i + offset, mclist->dmi_addr);
1176 vptr->mCAMmask[(offset + i) / 8] |= 1 << ((offset + i) & 7);
1177 }
1178
1179 mac_set_cam_mask(regs, vptr->mCAMmask);
1180 rx_mode = RCR_AM | RCR_AB | RCR_AP;
1181 }
1182 if (dev->mtu > 1500)
1183 rx_mode |= RCR_AL;
1184
1185 BYTE_REG_BITS_ON(rx_mode, &regs->RCR);
1186
1187}
1188
1189/*
1190 * MII access , media link mode setting functions
1191 */
1192
1193/**
1194 * mii_init - set up MII
1195 * @vptr: velocity adapter
1196 * @mii_status: links tatus
1197 *
1198 * Set up the PHY for the current link state.
1199 */
1200static void mii_init(struct velocity_info *vptr, u32 mii_status)
1201{
1202 u16 BMCR;
1203
1204 switch (PHYID_GET_PHY_ID(vptr->phy_id)) {
1205 case PHYID_CICADA_CS8201:
1206 /*
1207 * Reset to hardware default
1208 */
1209 MII_REG_BITS_OFF((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
1210 /*
1211 * Turn on ECHODIS bit in NWay-forced full mode and turn it
1212 * off it in NWay-forced half mode for NWay-forced v.s.
1213 * legacy-forced issue.
1214 */
1215 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1216 MII_REG_BITS_ON(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
1217 else
1218 MII_REG_BITS_OFF(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
1219 /*
1220 * Turn on Link/Activity LED enable bit for CIS8201
1221 */
1222 MII_REG_BITS_ON(PLED_LALBE, MII_REG_PLED, vptr->mac_regs);
1223 break;
1224 case PHYID_VT3216_32BIT:
1225 case PHYID_VT3216_64BIT:
1226 /*
1227 * Reset to hardware default
1228 */
1229 MII_REG_BITS_ON((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
1230 /*
1231 * Turn on ECHODIS bit in NWay-forced full mode and turn it
1232 * off it in NWay-forced half mode for NWay-forced v.s.
1233 * legacy-forced issue
1234 */
1235 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1236 MII_REG_BITS_ON(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
1237 else
1238 MII_REG_BITS_OFF(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
1239 break;
1240
1241 case PHYID_MARVELL_1000:
1242 case PHYID_MARVELL_1000S:
1243 /*
1244 * Assert CRS on Transmit
1245 */
1246 MII_REG_BITS_ON(PSCR_ACRSTX, MII_REG_PSCR, vptr->mac_regs);
1247 /*
1248 * Reset to hardware default
1249 */
1250 MII_REG_BITS_ON((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
1251 break;
1252 default:
1253 ;
1254 }
1255 velocity_mii_read(vptr->mac_regs, MII_REG_BMCR, &BMCR);
1256 if (BMCR & BMCR_ISO) {
1257 BMCR &= ~BMCR_ISO;
1258 velocity_mii_write(vptr->mac_regs, MII_REG_BMCR, BMCR);
1259 }
1260}
1261
1262
1263/**
698 * velocity_init_registers - initialise MAC registers 1264 * velocity_init_registers - initialise MAC registers
699 * @vptr: velocity to init 1265 * @vptr: velocity to init
700 * @type: type of initialisation (hot or cold) 1266 * @type: type of initialisation (hot or cold)
@@ -702,7 +1268,6 @@ static void velocity_rx_reset(struct velocity_info *vptr)
702 * Initialise the MAC on a reset or on first set up on the 1268 * Initialise the MAC on a reset or on first set up on the
703 * hardware. 1269 * hardware.
704 */ 1270 */
705
706static void velocity_init_registers(struct velocity_info *vptr, 1271static void velocity_init_registers(struct velocity_info *vptr,
707 enum velocity_init_type type) 1272 enum velocity_init_type type)
708{ 1273{
@@ -818,288 +1383,29 @@ static void velocity_init_registers(struct velocity_info *vptr,
818 } 1383 }
819} 1384}
820 1385
821/** 1386static void velocity_give_many_rx_descs(struct velocity_info *vptr)
822 * velocity_soft_reset - soft reset
823 * @vptr: velocity to reset
824 *
825 * Kick off a soft reset of the velocity adapter and then poll
826 * until the reset sequence has completed before returning.
827 */
828
829static int velocity_soft_reset(struct velocity_info *vptr)
830{ 1387{
831 struct mac_regs __iomem *regs = vptr->mac_regs; 1388 struct mac_regs __iomem *regs = vptr->mac_regs;
832 int i = 0; 1389 int avail, dirty, unusable;
833
834 writel(CR0_SFRST, &regs->CR0Set);
835
836 for (i = 0; i < W_MAX_TIMEOUT; i++) {
837 udelay(5);
838 if (!DWORD_REG_BITS_IS_ON(CR0_SFRST, &regs->CR0Set))
839 break;
840 }
841
842 if (i == W_MAX_TIMEOUT) {
843 writel(CR0_FORSRST, &regs->CR0Set);
844 /* FIXME: PCI POSTING */
845 /* delay 2ms */
846 mdelay(2);
847 }
848 return 0;
849}
850
851static const struct net_device_ops velocity_netdev_ops = {
852 .ndo_open = velocity_open,
853 .ndo_stop = velocity_close,
854 .ndo_start_xmit = velocity_xmit,
855 .ndo_get_stats = velocity_get_stats,
856 .ndo_validate_addr = eth_validate_addr,
857 .ndo_set_mac_address = eth_mac_addr,
858 .ndo_set_multicast_list = velocity_set_multi,
859 .ndo_change_mtu = velocity_change_mtu,
860 .ndo_do_ioctl = velocity_ioctl,
861 .ndo_vlan_rx_add_vid = velocity_vlan_rx_add_vid,
862 .ndo_vlan_rx_kill_vid = velocity_vlan_rx_kill_vid,
863 .ndo_vlan_rx_register = velocity_vlan_rx_register,
864};
865
866/**
867 * velocity_found1 - set up discovered velocity card
868 * @pdev: PCI device
869 * @ent: PCI device table entry that matched
870 *
871 * Configure a discovered adapter from scratch. Return a negative
872 * errno error code on failure paths.
873 */
874
875static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_device_id *ent)
876{
877 static int first = 1;
878 struct net_device *dev;
879 int i;
880 const char *drv_string;
881 const struct velocity_info_tbl *info = &chip_info_table[ent->driver_data];
882 struct velocity_info *vptr;
883 struct mac_regs __iomem *regs;
884 int ret = -ENOMEM;
885
886 /* FIXME: this driver, like almost all other ethernet drivers,
887 * can support more than MAX_UNITS.
888 */
889 if (velocity_nics >= MAX_UNITS) {
890 dev_notice(&pdev->dev, "already found %d NICs.\n",
891 velocity_nics);
892 return -ENODEV;
893 }
894
895 dev = alloc_etherdev(sizeof(struct velocity_info));
896 if (!dev) {
897 dev_err(&pdev->dev, "allocate net device failed.\n");
898 goto out;
899 }
900
901 /* Chain it all together */
902
903 SET_NETDEV_DEV(dev, &pdev->dev);
904 vptr = netdev_priv(dev);
905
906
907 if (first) {
908 printk(KERN_INFO "%s Ver. %s\n",
909 VELOCITY_FULL_DRV_NAM, VELOCITY_VERSION);
910 printk(KERN_INFO "Copyright (c) 2002, 2003 VIA Networking Technologies, Inc.\n");
911 printk(KERN_INFO "Copyright (c) 2004 Red Hat Inc.\n");
912 first = 0;
913 }
914
915 velocity_init_info(pdev, vptr, info);
916
917 vptr->dev = dev;
918
919 dev->irq = pdev->irq;
920
921 ret = pci_enable_device(pdev);
922 if (ret < 0)
923 goto err_free_dev;
924
925 ret = velocity_get_pci_info(vptr, pdev);
926 if (ret < 0) {
927 /* error message already printed */
928 goto err_disable;
929 }
930
931 ret = pci_request_regions(pdev, VELOCITY_NAME);
932 if (ret < 0) {
933 dev_err(&pdev->dev, "No PCI resources.\n");
934 goto err_disable;
935 }
936
937 regs = ioremap(vptr->memaddr, VELOCITY_IO_SIZE);
938 if (regs == NULL) {
939 ret = -EIO;
940 goto err_release_res;
941 }
942
943 vptr->mac_regs = regs;
944
945 mac_wol_reset(regs);
946
947 dev->base_addr = vptr->ioaddr;
948
949 for (i = 0; i < 6; i++)
950 dev->dev_addr[i] = readb(&regs->PAR[i]);
951
952
953 drv_string = dev_driver_string(&pdev->dev);
954
955 velocity_get_options(&vptr->options, velocity_nics, drv_string);
956
957 /*
958 * Mask out the options cannot be set to the chip
959 */
960
961 vptr->options.flags &= info->flags;
962 1390
963 /* 1391 /*
964 * Enable the chip specified capbilities 1392 * RD number must be equal to 4X per hardware spec
1393 * (programming guide rev 1.20, p.13)
965 */ 1394 */
1395 if (vptr->rx.filled < 4)
1396 return;
966 1397
967 vptr->flags = vptr->options.flags | (info->flags & 0xFF000000UL); 1398 wmb();
968
969 vptr->wol_opts = vptr->options.wol_opts;
970 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
971
972 vptr->phy_id = MII_GET_PHY_ID(vptr->mac_regs);
973
974 dev->irq = pdev->irq;
975 dev->netdev_ops = &velocity_netdev_ops;
976 dev->ethtool_ops = &velocity_ethtool_ops;
977
978 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER |
979 NETIF_F_HW_VLAN_RX;
980
981 if (vptr->flags & VELOCITY_FLAGS_TX_CSUM)
982 dev->features |= NETIF_F_IP_CSUM;
983
984 ret = register_netdev(dev);
985 if (ret < 0)
986 goto err_iounmap;
987
988 if (!velocity_get_link(dev)) {
989 netif_carrier_off(dev);
990 vptr->mii_status |= VELOCITY_LINK_FAIL;
991 }
992
993 velocity_print_info(vptr);
994 pci_set_drvdata(pdev, dev);
995
996 /* and leave the chip powered down */
997
998 pci_set_power_state(pdev, PCI_D3hot);
999#ifdef CONFIG_PM
1000 {
1001 unsigned long flags;
1002
1003 spin_lock_irqsave(&velocity_dev_list_lock, flags);
1004 list_add(&vptr->list, &velocity_dev_list);
1005 spin_unlock_irqrestore(&velocity_dev_list_lock, flags);
1006 }
1007#endif
1008 velocity_nics++;
1009out:
1010 return ret;
1011
1012err_iounmap:
1013 iounmap(regs);
1014err_release_res:
1015 pci_release_regions(pdev);
1016err_disable:
1017 pci_disable_device(pdev);
1018err_free_dev:
1019 free_netdev(dev);
1020 goto out;
1021}
1022
1023/**
1024 * velocity_print_info - per driver data
1025 * @vptr: velocity
1026 *
1027 * Print per driver data as the kernel driver finds Velocity
1028 * hardware
1029 */
1030
1031static void __devinit velocity_print_info(struct velocity_info *vptr)
1032{
1033 struct net_device *dev = vptr->dev;
1034
1035 printk(KERN_INFO "%s: %s\n", dev->name, get_chip_name(vptr->chip_id));
1036 printk(KERN_INFO "%s: Ethernet Address: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1037 dev->name,
1038 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
1039 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
1040}
1041
1042/**
1043 * velocity_init_info - init private data
1044 * @pdev: PCI device
1045 * @vptr: Velocity info
1046 * @info: Board type
1047 *
1048 * Set up the initial velocity_info struct for the device that has been
1049 * discovered.
1050 */
1051
1052static void __devinit velocity_init_info(struct pci_dev *pdev,
1053 struct velocity_info *vptr,
1054 const struct velocity_info_tbl *info)
1055{
1056 memset(vptr, 0, sizeof(struct velocity_info));
1057
1058 vptr->pdev = pdev;
1059 vptr->chip_id = info->chip_id;
1060 vptr->tx.numq = info->txqueue;
1061 vptr->multicast_limit = MCAM_SIZE;
1062 spin_lock_init(&vptr->lock);
1063 INIT_LIST_HEAD(&vptr->list);
1064}
1065
1066/**
1067 * velocity_get_pci_info - retrieve PCI info for device
1068 * @vptr: velocity device
1069 * @pdev: PCI device it matches
1070 *
1071 * Retrieve the PCI configuration space data that interests us from
1072 * the kernel PCI layer
1073 */
1074
1075static int __devinit velocity_get_pci_info(struct velocity_info *vptr, struct pci_dev *pdev)
1076{
1077 vptr->rev_id = pdev->revision;
1078
1079 pci_set_master(pdev);
1080
1081 vptr->ioaddr = pci_resource_start(pdev, 0);
1082 vptr->memaddr = pci_resource_start(pdev, 1);
1083
1084 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_IO)) {
1085 dev_err(&pdev->dev,
1086 "region #0 is not an I/O resource, aborting.\n");
1087 return -EINVAL;
1088 }
1089
1090 if ((pci_resource_flags(pdev, 1) & IORESOURCE_IO)) {
1091 dev_err(&pdev->dev,
1092 "region #1 is an I/O resource, aborting.\n");
1093 return -EINVAL;
1094 }
1095 1399
1096 if (pci_resource_len(pdev, 1) < VELOCITY_IO_SIZE) { 1400 unusable = vptr->rx.filled & 0x0003;
1097 dev_err(&pdev->dev, "region #1 is too small.\n"); 1401 dirty = vptr->rx.dirty - unusable;
1098 return -EINVAL; 1402 for (avail = vptr->rx.filled & 0xfffc; avail; avail--) {
1403 dirty = (dirty > 0) ? dirty - 1 : vptr->options.numrx - 1;
1404 vptr->rx.ring[dirty].rdesc0.len |= OWNED_BY_NIC;
1099 } 1405 }
1100 vptr->pdev = pdev;
1101 1406
1102 return 0; 1407 writew(vptr->rx.filled & 0xfffc, &regs->RBRDU);
1408 vptr->rx.filled = unusable;
1103} 1409}
1104 1410
1105/** 1411/**
@@ -1109,7 +1415,6 @@ static int __devinit velocity_get_pci_info(struct velocity_info *vptr, struct pc
1109 * Allocate PCI mapped DMA rings for the receive and transmit layer 1415 * Allocate PCI mapped DMA rings for the receive and transmit layer
1110 * to use. 1416 * to use.
1111 */ 1417 */
1112
1113static int velocity_init_dma_rings(struct velocity_info *vptr) 1418static int velocity_init_dma_rings(struct velocity_info *vptr)
1114{ 1419{
1115 struct velocity_opt *opt = &vptr->options; 1420 struct velocity_opt *opt = &vptr->options;
@@ -1150,46 +1455,50 @@ static int velocity_init_dma_rings(struct velocity_info *vptr)
1150 return 0; 1455 return 0;
1151} 1456}
1152 1457
1458static void velocity_set_rxbufsize(struct velocity_info *vptr, int mtu)
1459{
1460 vptr->rx.buf_sz = (mtu <= ETH_DATA_LEN) ? PKT_BUF_SZ : mtu + 32;
1461}
1462
1153/** 1463/**
1154 * velocity_free_dma_rings - free PCI ring pointers 1464 * velocity_alloc_rx_buf - allocate aligned receive buffer
1155 * @vptr: Velocity to free from 1465 * @vptr: velocity
1466 * @idx: ring index
1156 * 1467 *
1157 * Clean up the PCI ring buffers allocated to this velocity. 1468 * Allocate a new full sized buffer for the reception of a frame and
1469 * map it into PCI space for the hardware to use. The hardware
1470 * requires *64* byte alignment of the buffer which makes life
1471 * less fun than would be ideal.
1158 */ 1472 */
1159 1473static int velocity_alloc_rx_buf(struct velocity_info *vptr, int idx)
1160static void velocity_free_dma_rings(struct velocity_info *vptr)
1161{ 1474{
1162 const int size = vptr->options.numrx * sizeof(struct rx_desc) + 1475 struct rx_desc *rd = &(vptr->rx.ring[idx]);
1163 vptr->options.numtx * sizeof(struct tx_desc) * vptr->tx.numq; 1476 struct velocity_rd_info *rd_info = &(vptr->rx.info[idx]);
1164
1165 pci_free_consistent(vptr->pdev, size, vptr->rx.ring, vptr->rx.pool_dma);
1166}
1167 1477
1168static void velocity_give_many_rx_descs(struct velocity_info *vptr) 1478 rd_info->skb = dev_alloc_skb(vptr->rx.buf_sz + 64);
1169{ 1479 if (rd_info->skb == NULL)
1170 struct mac_regs __iomem *regs = vptr->mac_regs; 1480 return -ENOMEM;
1171 int avail, dirty, unusable;
1172 1481
1173 /* 1482 /*
1174 * RD number must be equal to 4X per hardware spec 1483 * Do the gymnastics to get the buffer head for data at
1175 * (programming guide rev 1.20, p.13) 1484 * 64byte alignment.
1176 */ 1485 */
1177 if (vptr->rx.filled < 4) 1486 skb_reserve(rd_info->skb, (unsigned long) rd_info->skb->data & 63);
1178 return; 1487 rd_info->skb_dma = pci_map_single(vptr->pdev, rd_info->skb->data,
1179 1488 vptr->rx.buf_sz, PCI_DMA_FROMDEVICE);
1180 wmb();
1181 1489
1182 unusable = vptr->rx.filled & 0x0003; 1490 /*
1183 dirty = vptr->rx.dirty - unusable; 1491 * Fill in the descriptor to match
1184 for (avail = vptr->rx.filled & 0xfffc; avail; avail--) { 1492 */
1185 dirty = (dirty > 0) ? dirty - 1 : vptr->options.numrx - 1;
1186 vptr->rx.ring[dirty].rdesc0.len |= OWNED_BY_NIC;
1187 }
1188 1493
1189 writew(vptr->rx.filled & 0xfffc, &regs->RBRDU); 1494 *((u32 *) & (rd->rdesc0)) = 0;
1190 vptr->rx.filled = unusable; 1495 rd->size = cpu_to_le16(vptr->rx.buf_sz) | RX_INTEN;
1496 rd->pa_low = cpu_to_le32(rd_info->skb_dma);
1497 rd->pa_high = 0;
1498 return 0;
1191} 1499}
1192 1500
1501
1193static int velocity_rx_refill(struct velocity_info *vptr) 1502static int velocity_rx_refill(struct velocity_info *vptr)
1194{ 1503{
1195 int dirty = vptr->rx.dirty, done = 0; 1504 int dirty = vptr->rx.dirty, done = 0;
@@ -1217,42 +1526,6 @@ static int velocity_rx_refill(struct velocity_info *vptr)
1217 return done; 1526 return done;
1218} 1527}
1219 1528
1220static void velocity_set_rxbufsize(struct velocity_info *vptr, int mtu)
1221{
1222 vptr->rx.buf_sz = (mtu <= ETH_DATA_LEN) ? PKT_BUF_SZ : mtu + 32;
1223}
1224
1225/**
1226 * velocity_init_rd_ring - set up receive ring
1227 * @vptr: velocity to configure
1228 *
1229 * Allocate and set up the receive buffers for each ring slot and
1230 * assign them to the network adapter.
1231 */
1232
1233static int velocity_init_rd_ring(struct velocity_info *vptr)
1234{
1235 int ret = -ENOMEM;
1236
1237 vptr->rx.info = kcalloc(vptr->options.numrx,
1238 sizeof(struct velocity_rd_info), GFP_KERNEL);
1239 if (!vptr->rx.info)
1240 goto out;
1241
1242 velocity_init_rx_ring_indexes(vptr);
1243
1244 if (velocity_rx_refill(vptr) != vptr->options.numrx) {
1245 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_ERR
1246 "%s: failed to allocate RX buffer.\n", vptr->dev->name);
1247 velocity_free_rd_ring(vptr);
1248 goto out;
1249 }
1250
1251 ret = 0;
1252out:
1253 return ret;
1254}
1255
1256/** 1529/**
1257 * velocity_free_rd_ring - free receive ring 1530 * velocity_free_rd_ring - free receive ring
1258 * @vptr: velocity to clean up 1531 * @vptr: velocity to clean up
@@ -1260,7 +1533,6 @@ out:
1260 * Free the receive buffers for each ring slot and any 1533 * Free the receive buffers for each ring slot and any
1261 * attached socket buffers that need to go away. 1534 * attached socket buffers that need to go away.
1262 */ 1535 */
1263
1264static void velocity_free_rd_ring(struct velocity_info *vptr) 1536static void velocity_free_rd_ring(struct velocity_info *vptr)
1265{ 1537{
1266 int i; 1538 int i;
@@ -1288,6 +1560,38 @@ static void velocity_free_rd_ring(struct velocity_info *vptr)
1288 vptr->rx.info = NULL; 1560 vptr->rx.info = NULL;
1289} 1561}
1290 1562
1563
1564
1565/**
1566 * velocity_init_rd_ring - set up receive ring
1567 * @vptr: velocity to configure
1568 *
1569 * Allocate and set up the receive buffers for each ring slot and
1570 * assign them to the network adapter.
1571 */
1572static int velocity_init_rd_ring(struct velocity_info *vptr)
1573{
1574 int ret = -ENOMEM;
1575
1576 vptr->rx.info = kcalloc(vptr->options.numrx,
1577 sizeof(struct velocity_rd_info), GFP_KERNEL);
1578 if (!vptr->rx.info)
1579 goto out;
1580
1581 velocity_init_rx_ring_indexes(vptr);
1582
1583 if (velocity_rx_refill(vptr) != vptr->options.numrx) {
1584 VELOCITY_PRT(MSG_LEVEL_ERR, KERN_ERR
1585 "%s: failed to allocate RX buffer.\n", vptr->dev->name);
1586 velocity_free_rd_ring(vptr);
1587 goto out;
1588 }
1589
1590 ret = 0;
1591out:
1592 return ret;
1593}
1594
1291/** 1595/**
1292 * velocity_init_td_ring - set up transmit ring 1596 * velocity_init_td_ring - set up transmit ring
1293 * @vptr: velocity 1597 * @vptr: velocity
@@ -1296,7 +1600,6 @@ static void velocity_free_rd_ring(struct velocity_info *vptr)
1296 * Returns zero on success or a negative posix errno code for 1600 * Returns zero on success or a negative posix errno code for
1297 * failure. 1601 * failure.
1298 */ 1602 */
1299
1300static int velocity_init_td_ring(struct velocity_info *vptr) 1603static int velocity_init_td_ring(struct velocity_info *vptr)
1301{ 1604{
1302 dma_addr_t curr; 1605 dma_addr_t curr;
@@ -1320,10 +1623,81 @@ static int velocity_init_td_ring(struct velocity_info *vptr)
1320 return 0; 1623 return 0;
1321} 1624}
1322 1625
1626/**
1627 * velocity_free_dma_rings - free PCI ring pointers
1628 * @vptr: Velocity to free from
1629 *
1630 * Clean up the PCI ring buffers allocated to this velocity.
1631 */
1632static void velocity_free_dma_rings(struct velocity_info *vptr)
1633{
1634 const int size = vptr->options.numrx * sizeof(struct rx_desc) +
1635 vptr->options.numtx * sizeof(struct tx_desc) * vptr->tx.numq;
1636
1637 pci_free_consistent(vptr->pdev, size, vptr->rx.ring, vptr->rx.pool_dma);
1638}
1639
1640
1641static int velocity_init_rings(struct velocity_info *vptr, int mtu)
1642{
1643 int ret;
1644
1645 velocity_set_rxbufsize(vptr, mtu);
1646
1647 ret = velocity_init_dma_rings(vptr);
1648 if (ret < 0)
1649 goto out;
1650
1651 ret = velocity_init_rd_ring(vptr);
1652 if (ret < 0)
1653 goto err_free_dma_rings_0;
1654
1655 ret = velocity_init_td_ring(vptr);
1656 if (ret < 0)
1657 goto err_free_rd_ring_1;
1658out:
1659 return ret;
1660
1661err_free_rd_ring_1:
1662 velocity_free_rd_ring(vptr);
1663err_free_dma_rings_0:
1664 velocity_free_dma_rings(vptr);
1665 goto out;
1666}
1667
1668/**
1669 * velocity_free_tx_buf - free transmit buffer
1670 * @vptr: velocity
1671 * @tdinfo: buffer
1672 *
1673 * Release an transmit buffer. If the buffer was preallocated then
1674 * recycle it, if not then unmap the buffer.
1675 */
1676static void velocity_free_tx_buf(struct velocity_info *vptr, struct velocity_td_info *tdinfo)
1677{
1678 struct sk_buff *skb = tdinfo->skb;
1679 int i;
1680 int pktlen;
1681
1682 /*
1683 * Don't unmap the pre-allocated tx_bufs
1684 */
1685 if (tdinfo->skb_dma) {
1686
1687 pktlen = max_t(unsigned int, skb->len, ETH_ZLEN);
1688 for (i = 0; i < tdinfo->nskb_dma; i++) {
1689 pci_unmap_single(vptr->pdev, tdinfo->skb_dma[i], pktlen, PCI_DMA_TODEVICE);
1690 tdinfo->skb_dma[i] = 0;
1691 }
1692 }
1693 dev_kfree_skb_irq(skb);
1694 tdinfo->skb = NULL;
1695}
1696
1697
1323/* 1698/*
1324 * FIXME: could we merge this with velocity_free_tx_buf ? 1699 * FIXME: could we merge this with velocity_free_tx_buf ?
1325 */ 1700 */
1326
1327static void velocity_free_td_ring_entry(struct velocity_info *vptr, 1701static void velocity_free_td_ring_entry(struct velocity_info *vptr,
1328 int q, int n) 1702 int q, int n)
1329{ 1703{
@@ -1353,7 +1727,6 @@ static void velocity_free_td_ring_entry(struct velocity_info *vptr,
1353 * Free up the transmit ring for this particular velocity adapter. 1727 * Free up the transmit ring for this particular velocity adapter.
1354 * We free the ring contents but not the ring itself. 1728 * We free the ring contents but not the ring itself.
1355 */ 1729 */
1356
1357static void velocity_free_td_ring(struct velocity_info *vptr) 1730static void velocity_free_td_ring(struct velocity_info *vptr)
1358{ 1731{
1359 int i, j; 1732 int i, j;
@@ -1369,61 +1742,167 @@ static void velocity_free_td_ring(struct velocity_info *vptr)
1369 } 1742 }
1370} 1743}
1371 1744
1745
1746static void velocity_free_rings(struct velocity_info *vptr)
1747{
1748 velocity_free_td_ring(vptr);
1749 velocity_free_rd_ring(vptr);
1750 velocity_free_dma_rings(vptr);
1751}
1752
1372/** 1753/**
1373 * velocity_rx_srv - service RX interrupt 1754 * velocity_error - handle error from controller
1374 * @vptr: velocity 1755 * @vptr: velocity
1375 * @status: adapter status (unused) 1756 * @status: card status
1757 *
1758 * Process an error report from the hardware and attempt to recover
1759 * the card itself. At the moment we cannot recover from some
1760 * theoretically impossible errors but this could be fixed using
1761 * the pci_device_failed logic to bounce the hardware
1376 * 1762 *
1377 * Walk the receive ring of the velocity adapter and remove
1378 * any received packets from the receive queue. Hand the ring
1379 * slots back to the adapter for reuse.
1380 */ 1763 */
1381 1764static void velocity_error(struct velocity_info *vptr, int status)
1382static int velocity_rx_srv(struct velocity_info *vptr, int status)
1383{ 1765{
1384 struct net_device_stats *stats = &vptr->dev->stats;
1385 int rd_curr = vptr->rx.curr;
1386 int works = 0;
1387 1766
1388 do { 1767 if (status & ISR_TXSTLI) {
1389 struct rx_desc *rd = vptr->rx.ring + rd_curr; 1768 struct mac_regs __iomem *regs = vptr->mac_regs;
1390 1769
1391 if (!vptr->rx.info[rd_curr].skb) 1770 printk(KERN_ERR "TD structure error TDindex=%hx\n", readw(&regs->TDIdx[0]));
1392 break; 1771 BYTE_REG_BITS_ON(TXESR_TDSTR, &regs->TXESR);
1772 writew(TRDCSR_RUN, &regs->TDCSRClr);
1773 netif_stop_queue(vptr->dev);
1393 1774
1394 if (rd->rdesc0.len & OWNED_BY_NIC) 1775 /* FIXME: port over the pci_device_failed code and use it
1395 break; 1776 here */
1777 }
1396 1778
1397 rmb(); 1779 if (status & ISR_SRCI) {
1780 struct mac_regs __iomem *regs = vptr->mac_regs;
1781 int linked;
1782
1783 if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1784 vptr->mii_status = check_connection_type(regs);
1398 1785
1786 /*
1787 * If it is a 3119, disable frame bursting in
1788 * halfduplex mode and enable it in fullduplex
1789 * mode
1790 */
1791 if (vptr->rev_id < REV_ID_VT3216_A0) {
1792 if (vptr->mii_status | VELOCITY_DUPLEX_FULL)
1793 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
1794 else
1795 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
1796 }
1797 /*
1798 * Only enable CD heart beat counter in 10HD mode
1799 */
1800 if (!(vptr->mii_status & VELOCITY_DUPLEX_FULL) && (vptr->mii_status & VELOCITY_SPEED_10))
1801 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
1802 else
1803 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
1804 }
1399 /* 1805 /*
1400 * Don't drop CE or RL error frame although RXOK is off 1806 * Get link status from PHYSR0
1401 */ 1807 */
1402 if (rd->rdesc0.RSR & (RSR_RXOK | RSR_CE | RSR_RL)) { 1808 linked = readb(&regs->PHYSR0) & PHYSR0_LINKGD;
1403 if (velocity_receive_frame(vptr, rd_curr) < 0)
1404 stats->rx_dropped++;
1405 } else {
1406 if (rd->rdesc0.RSR & RSR_CRC)
1407 stats->rx_crc_errors++;
1408 if (rd->rdesc0.RSR & RSR_FAE)
1409 stats->rx_frame_errors++;
1410 1809
1411 stats->rx_dropped++; 1810 if (linked) {
1811 vptr->mii_status &= ~VELOCITY_LINK_FAIL;
1812 netif_carrier_on(vptr->dev);
1813 } else {
1814 vptr->mii_status |= VELOCITY_LINK_FAIL;
1815 netif_carrier_off(vptr->dev);
1412 } 1816 }
1413 1817
1414 rd->size |= RX_INTEN; 1818 velocity_print_link_status(vptr);
1819 enable_flow_control_ability(vptr);
1415 1820
1416 rd_curr++; 1821 /*
1417 if (rd_curr >= vptr->options.numrx) 1822 * Re-enable auto-polling because SRCI will disable
1418 rd_curr = 0; 1823 * auto-polling
1419 } while (++works <= 15); 1824 */
1420 1825
1421 vptr->rx.curr = rd_curr; 1826 enable_mii_autopoll(regs);
1422 1827
1423 if ((works > 0) && (velocity_rx_refill(vptr) > 0)) 1828 if (vptr->mii_status & VELOCITY_LINK_FAIL)
1424 velocity_give_many_rx_descs(vptr); 1829 netif_stop_queue(vptr->dev);
1830 else
1831 netif_wake_queue(vptr->dev);
1425 1832
1426 VAR_USED(stats); 1833 };
1834 if (status & ISR_MIBFI)
1835 velocity_update_hw_mibs(vptr);
1836 if (status & ISR_LSTEI)
1837 mac_rx_queue_wake(vptr->mac_regs);
1838}
1839
1840/**
1841 * tx_srv - transmit interrupt service
1842 * @vptr; Velocity
1843 * @status:
1844 *
1845 * Scan the queues looking for transmitted packets that
1846 * we can complete and clean up. Update any statistics as
1847 * necessary/
1848 */
1849static int velocity_tx_srv(struct velocity_info *vptr, u32 status)
1850{
1851 struct tx_desc *td;
1852 int qnum;
1853 int full = 0;
1854 int idx;
1855 int works = 0;
1856 struct velocity_td_info *tdinfo;
1857 struct net_device_stats *stats = &vptr->dev->stats;
1858
1859 for (qnum = 0; qnum < vptr->tx.numq; qnum++) {
1860 for (idx = vptr->tx.tail[qnum]; vptr->tx.used[qnum] > 0;
1861 idx = (idx + 1) % vptr->options.numtx) {
1862
1863 /*
1864 * Get Tx Descriptor
1865 */
1866 td = &(vptr->tx.rings[qnum][idx]);
1867 tdinfo = &(vptr->tx.infos[qnum][idx]);
1868
1869 if (td->tdesc0.len & OWNED_BY_NIC)
1870 break;
1871
1872 if ((works++ > 15))
1873 break;
1874
1875 if (td->tdesc0.TSR & TSR0_TERR) {
1876 stats->tx_errors++;
1877 stats->tx_dropped++;
1878 if (td->tdesc0.TSR & TSR0_CDH)
1879 stats->tx_heartbeat_errors++;
1880 if (td->tdesc0.TSR & TSR0_CRS)
1881 stats->tx_carrier_errors++;
1882 if (td->tdesc0.TSR & TSR0_ABT)
1883 stats->tx_aborted_errors++;
1884 if (td->tdesc0.TSR & TSR0_OWC)
1885 stats->tx_window_errors++;
1886 } else {
1887 stats->tx_packets++;
1888 stats->tx_bytes += tdinfo->skb->len;
1889 }
1890 velocity_free_tx_buf(vptr, tdinfo);
1891 vptr->tx.used[qnum]--;
1892 }
1893 vptr->tx.tail[qnum] = idx;
1894
1895 if (AVAIL_TD(vptr, qnum) < 1)
1896 full = 1;
1897 }
1898 /*
1899 * Look to see if we should kick the transmit network
1900 * layer for more work.
1901 */
1902 if (netif_queue_stopped(vptr->dev) && (full == 0)
1903 && (!(vptr->mii_status & VELOCITY_LINK_FAIL))) {
1904 netif_wake_queue(vptr->dev);
1905 }
1427 return works; 1906 return works;
1428} 1907}
1429 1908
@@ -1435,7 +1914,6 @@ static int velocity_rx_srv(struct velocity_info *vptr, int status)
1435 * Process the status bits for the received packet and determine 1914 * Process the status bits for the received packet and determine
1436 * if the checksum was computed and verified by the hardware 1915 * if the checksum was computed and verified by the hardware
1437 */ 1916 */
1438
1439static inline void velocity_rx_csum(struct rx_desc *rd, struct sk_buff *skb) 1917static inline void velocity_rx_csum(struct rx_desc *rd, struct sk_buff *skb)
1440{ 1918{
1441 skb->ip_summed = CHECKSUM_NONE; 1919 skb->ip_summed = CHECKSUM_NONE;
@@ -1502,6 +1980,7 @@ static inline void velocity_iph_realign(struct velocity_info *vptr,
1502 } 1980 }
1503} 1981}
1504 1982
1983
1505/** 1984/**
1506 * velocity_receive_frame - received packet processor 1985 * velocity_receive_frame - received packet processor
1507 * @vptr: velocity we are handling 1986 * @vptr: velocity we are handling
@@ -1510,7 +1989,6 @@ static inline void velocity_iph_realign(struct velocity_info *vptr,
1510 * A packet has arrived. We process the packet and if appropriate 1989 * A packet has arrived. We process the packet and if appropriate
1511 * pass the frame up the network stack 1990 * pass the frame up the network stack
1512 */ 1991 */
1513
1514static int velocity_receive_frame(struct velocity_info *vptr, int idx) 1992static int velocity_receive_frame(struct velocity_info *vptr, int idx)
1515{ 1993{
1516 void (*pci_action)(struct pci_dev *, dma_addr_t, size_t, int); 1994 void (*pci_action)(struct pci_dev *, dma_addr_t, size_t, int);
@@ -1572,314 +2050,118 @@ static int velocity_receive_frame(struct velocity_info *vptr, int idx)
1572 return 0; 2050 return 0;
1573} 2051}
1574 2052
2053
1575/** 2054/**
1576 * velocity_alloc_rx_buf - allocate aligned receive buffer 2055 * velocity_rx_srv - service RX interrupt
1577 * @vptr: velocity 2056 * @vptr: velocity
1578 * @idx: ring index 2057 * @status: adapter status (unused)
1579 * 2058 *
1580 * Allocate a new full sized buffer for the reception of a frame and 2059 * Walk the receive ring of the velocity adapter and remove
1581 * map it into PCI space for the hardware to use. The hardware 2060 * any received packets from the receive queue. Hand the ring
1582 * requires *64* byte alignment of the buffer which makes life 2061 * slots back to the adapter for reuse.
1583 * less fun than would be ideal.
1584 */ 2062 */
1585 2063static int velocity_rx_srv(struct velocity_info *vptr, int status)
1586static int velocity_alloc_rx_buf(struct velocity_info *vptr, int idx)
1587{ 2064{
1588 struct rx_desc *rd = &(vptr->rx.ring[idx]); 2065 struct net_device_stats *stats = &vptr->dev->stats;
1589 struct velocity_rd_info *rd_info = &(vptr->rx.info[idx]); 2066 int rd_curr = vptr->rx.curr;
1590 2067 int works = 0;
1591 rd_info->skb = dev_alloc_skb(vptr->rx.buf_sz + 64);
1592 if (rd_info->skb == NULL)
1593 return -ENOMEM;
1594 2068
1595 /* 2069 do {
1596 * Do the gymnastics to get the buffer head for data at 2070 struct rx_desc *rd = vptr->rx.ring + rd_curr;
1597 * 64byte alignment.
1598 */
1599 skb_reserve(rd_info->skb, (unsigned long) rd_info->skb->data & 63);
1600 rd_info->skb_dma = pci_map_single(vptr->pdev, rd_info->skb->data,
1601 vptr->rx.buf_sz, PCI_DMA_FROMDEVICE);
1602 2071
1603 /* 2072 if (!vptr->rx.info[rd_curr].skb)
1604 * Fill in the descriptor to match 2073 break;
1605 */
1606 2074
1607 *((u32 *) & (rd->rdesc0)) = 0; 2075 if (rd->rdesc0.len & OWNED_BY_NIC)
1608 rd->size = cpu_to_le16(vptr->rx.buf_sz) | RX_INTEN; 2076 break;
1609 rd->pa_low = cpu_to_le32(rd_info->skb_dma);
1610 rd->pa_high = 0;
1611 return 0;
1612}
1613 2077
1614/** 2078 rmb();
1615 * tx_srv - transmit interrupt service
1616 * @vptr; Velocity
1617 * @status:
1618 *
1619 * Scan the queues looking for transmitted packets that
1620 * we can complete and clean up. Update any statistics as
1621 * necessary/
1622 */
1623 2079
1624static int velocity_tx_srv(struct velocity_info *vptr, u32 status) 2080 /*
1625{ 2081 * Don't drop CE or RL error frame although RXOK is off
1626 struct tx_desc *td; 2082 */
1627 int qnum; 2083 if (rd->rdesc0.RSR & (RSR_RXOK | RSR_CE | RSR_RL)) {
1628 int full = 0; 2084 if (velocity_receive_frame(vptr, rd_curr) < 0)
1629 int idx; 2085 stats->rx_dropped++;
1630 int works = 0; 2086 } else {
1631 struct velocity_td_info *tdinfo; 2087 if (rd->rdesc0.RSR & RSR_CRC)
1632 struct net_device_stats *stats = &vptr->dev->stats; 2088 stats->rx_crc_errors++;
2089 if (rd->rdesc0.RSR & RSR_FAE)
2090 stats->rx_frame_errors++;
1633 2091
1634 for (qnum = 0; qnum < vptr->tx.numq; qnum++) { 2092 stats->rx_dropped++;
1635 for (idx = vptr->tx.tail[qnum]; vptr->tx.used[qnum] > 0; 2093 }
1636 idx = (idx + 1) % vptr->options.numtx) {
1637 2094
1638 /* 2095 rd->size |= RX_INTEN;
1639 * Get Tx Descriptor
1640 */
1641 td = &(vptr->tx.rings[qnum][idx]);
1642 tdinfo = &(vptr->tx.infos[qnum][idx]);
1643 2096
1644 if (td->tdesc0.len & OWNED_BY_NIC) 2097 rd_curr++;
1645 break; 2098 if (rd_curr >= vptr->options.numrx)
2099 rd_curr = 0;
2100 } while (++works <= 15);
1646 2101
1647 if ((works++ > 15)) 2102 vptr->rx.curr = rd_curr;
1648 break;
1649 2103
1650 if (td->tdesc0.TSR & TSR0_TERR) { 2104 if ((works > 0) && (velocity_rx_refill(vptr) > 0))
1651 stats->tx_errors++; 2105 velocity_give_many_rx_descs(vptr);
1652 stats->tx_dropped++;
1653 if (td->tdesc0.TSR & TSR0_CDH)
1654 stats->tx_heartbeat_errors++;
1655 if (td->tdesc0.TSR & TSR0_CRS)
1656 stats->tx_carrier_errors++;
1657 if (td->tdesc0.TSR & TSR0_ABT)
1658 stats->tx_aborted_errors++;
1659 if (td->tdesc0.TSR & TSR0_OWC)
1660 stats->tx_window_errors++;
1661 } else {
1662 stats->tx_packets++;
1663 stats->tx_bytes += tdinfo->skb->len;
1664 }
1665 velocity_free_tx_buf(vptr, tdinfo);
1666 vptr->tx.used[qnum]--;
1667 }
1668 vptr->tx.tail[qnum] = idx;
1669 2106
1670 if (AVAIL_TD(vptr, qnum) < 1) 2107 VAR_USED(stats);
1671 full = 1;
1672 }
1673 /*
1674 * Look to see if we should kick the transmit network
1675 * layer for more work.
1676 */
1677 if (netif_queue_stopped(vptr->dev) && (full == 0)
1678 && (!(vptr->mii_status & VELOCITY_LINK_FAIL))) {
1679 netif_wake_queue(vptr->dev);
1680 }
1681 return works; 2108 return works;
1682} 2109}
1683 2110
1684/**
1685 * velocity_print_link_status - link status reporting
1686 * @vptr: velocity to report on
1687 *
1688 * Turn the link status of the velocity card into a kernel log
1689 * description of the new link state, detailing speed and duplex
1690 * status
1691 */
1692
1693static void velocity_print_link_status(struct velocity_info *vptr)
1694{
1695
1696 if (vptr->mii_status & VELOCITY_LINK_FAIL) {
1697 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: failed to detect cable link\n", vptr->dev->name);
1698 } else if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1699 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link auto-negotiation", vptr->dev->name);
1700
1701 if (vptr->mii_status & VELOCITY_SPEED_1000)
1702 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps");
1703 else if (vptr->mii_status & VELOCITY_SPEED_100)
1704 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps");
1705 else
1706 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps");
1707
1708 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
1709 VELOCITY_PRT(MSG_LEVEL_INFO, " full duplex\n");
1710 else
1711 VELOCITY_PRT(MSG_LEVEL_INFO, " half duplex\n");
1712 } else {
1713 VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link forced", vptr->dev->name);
1714 switch (vptr->options.spd_dpx) {
1715 case SPD_DPX_100_HALF:
1716 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps half duplex\n");
1717 break;
1718 case SPD_DPX_100_FULL:
1719 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 100M bps full duplex\n");
1720 break;
1721 case SPD_DPX_10_HALF:
1722 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps half duplex\n");
1723 break;
1724 case SPD_DPX_10_FULL:
1725 VELOCITY_PRT(MSG_LEVEL_INFO, " speed 10M bps full duplex\n");
1726 break;
1727 default:
1728 break;
1729 }
1730 }
1731}
1732 2111
1733/** 2112/**
1734 * velocity_error - handle error from controller 2113 * velocity_intr - interrupt callback
1735 * @vptr: velocity 2114 * @irq: interrupt number
1736 * @status: card status 2115 * @dev_instance: interrupting device
1737 *
1738 * Process an error report from the hardware and attempt to recover
1739 * the card itself. At the moment we cannot recover from some
1740 * theoretically impossible errors but this could be fixed using
1741 * the pci_device_failed logic to bounce the hardware
1742 * 2116 *
2117 * Called whenever an interrupt is generated by the velocity
2118 * adapter IRQ line. We may not be the source of the interrupt
2119 * and need to identify initially if we are, and if not exit as
2120 * efficiently as possible.
1743 */ 2121 */
1744 2122static irqreturn_t velocity_intr(int irq, void *dev_instance)
1745static void velocity_error(struct velocity_info *vptr, int status)
1746{ 2123{
2124 struct net_device *dev = dev_instance;
2125 struct velocity_info *vptr = netdev_priv(dev);
2126 u32 isr_status;
2127 int max_count = 0;
1747 2128
1748 if (status & ISR_TXSTLI) {
1749 struct mac_regs __iomem *regs = vptr->mac_regs;
1750 2129
1751 printk(KERN_ERR "TD structure error TDindex=%hx\n", readw(&regs->TDIdx[0])); 2130 spin_lock(&vptr->lock);
1752 BYTE_REG_BITS_ON(TXESR_TDSTR, &regs->TXESR); 2131 isr_status = mac_read_isr(vptr->mac_regs);
1753 writew(TRDCSR_RUN, &regs->TDCSRClr);
1754 netif_stop_queue(vptr->dev);
1755 2132
1756 /* FIXME: port over the pci_device_failed code and use it 2133 /* Not us ? */
1757 here */ 2134 if (isr_status == 0) {
2135 spin_unlock(&vptr->lock);
2136 return IRQ_NONE;
1758 } 2137 }
1759 2138
1760 if (status & ISR_SRCI) { 2139 mac_disable_int(vptr->mac_regs);
1761 struct mac_regs __iomem *regs = vptr->mac_regs;
1762 int linked;
1763
1764 if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
1765 vptr->mii_status = check_connection_type(regs);
1766
1767 /*
1768 * If it is a 3119, disable frame bursting in
1769 * halfduplex mode and enable it in fullduplex
1770 * mode
1771 */
1772 if (vptr->rev_id < REV_ID_VT3216_A0) {
1773 if (vptr->mii_status | VELOCITY_DUPLEX_FULL)
1774 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR);
1775 else
1776 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR);
1777 }
1778 /*
1779 * Only enable CD heart beat counter in 10HD mode
1780 */
1781 if (!(vptr->mii_status & VELOCITY_DUPLEX_FULL) && (vptr->mii_status & VELOCITY_SPEED_10))
1782 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG);
1783 else
1784 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
1785 }
1786 /*
1787 * Get link status from PHYSR0
1788 */
1789 linked = readb(&regs->PHYSR0) & PHYSR0_LINKGD;
1790
1791 if (linked) {
1792 vptr->mii_status &= ~VELOCITY_LINK_FAIL;
1793 netif_carrier_on(vptr->dev);
1794 } else {
1795 vptr->mii_status |= VELOCITY_LINK_FAIL;
1796 netif_carrier_off(vptr->dev);
1797 }
1798
1799 velocity_print_link_status(vptr);
1800 enable_flow_control_ability(vptr);
1801
1802 /*
1803 * Re-enable auto-polling because SRCI will disable
1804 * auto-polling
1805 */
1806
1807 enable_mii_autopoll(regs);
1808
1809 if (vptr->mii_status & VELOCITY_LINK_FAIL)
1810 netif_stop_queue(vptr->dev);
1811 else
1812 netif_wake_queue(vptr->dev);
1813
1814 };
1815 if (status & ISR_MIBFI)
1816 velocity_update_hw_mibs(vptr);
1817 if (status & ISR_LSTEI)
1818 mac_rx_queue_wake(vptr->mac_regs);
1819}
1820
1821/**
1822 * velocity_free_tx_buf - free transmit buffer
1823 * @vptr: velocity
1824 * @tdinfo: buffer
1825 *
1826 * Release an transmit buffer. If the buffer was preallocated then
1827 * recycle it, if not then unmap the buffer.
1828 */
1829
1830static void velocity_free_tx_buf(struct velocity_info *vptr, struct velocity_td_info *tdinfo)
1831{
1832 struct sk_buff *skb = tdinfo->skb;
1833 int i;
1834 int pktlen;
1835 2140
1836 /* 2141 /*
1837 * Don't unmap the pre-allocated tx_bufs 2142 * Keep processing the ISR until we have completed
2143 * processing and the isr_status becomes zero
1838 */ 2144 */
1839 if (tdinfo->skb_dma) {
1840 2145
1841 pktlen = max_t(unsigned int, skb->len, ETH_ZLEN); 2146 while (isr_status != 0) {
1842 for (i = 0; i < tdinfo->nskb_dma; i++) { 2147 mac_write_isr(vptr->mac_regs, isr_status);
1843 pci_unmap_single(vptr->pdev, tdinfo->skb_dma[i], pktlen, PCI_DMA_TODEVICE); 2148 if (isr_status & (~(ISR_PRXI | ISR_PPRXI | ISR_PTXI | ISR_PPTXI)))
1844 tdinfo->skb_dma[i] = 0; 2149 velocity_error(vptr, isr_status);
2150 if (isr_status & (ISR_PRXI | ISR_PPRXI))
2151 max_count += velocity_rx_srv(vptr, isr_status);
2152 if (isr_status & (ISR_PTXI | ISR_PPTXI))
2153 max_count += velocity_tx_srv(vptr, isr_status);
2154 isr_status = mac_read_isr(vptr->mac_regs);
2155 if (max_count > vptr->options.int_works) {
2156 printk(KERN_WARNING "%s: excessive work at interrupt.\n",
2157 dev->name);
2158 max_count = 0;
1845 } 2159 }
1846 } 2160 }
1847 dev_kfree_skb_irq(skb); 2161 spin_unlock(&vptr->lock);
1848 tdinfo->skb = NULL; 2162 mac_enable_int(vptr->mac_regs);
1849} 2163 return IRQ_HANDLED;
1850
1851static int velocity_init_rings(struct velocity_info *vptr, int mtu)
1852{
1853 int ret;
1854
1855 velocity_set_rxbufsize(vptr, mtu);
1856
1857 ret = velocity_init_dma_rings(vptr);
1858 if (ret < 0)
1859 goto out;
1860
1861 ret = velocity_init_rd_ring(vptr);
1862 if (ret < 0)
1863 goto err_free_dma_rings_0;
1864
1865 ret = velocity_init_td_ring(vptr);
1866 if (ret < 0)
1867 goto err_free_rd_ring_1;
1868out:
1869 return ret;
1870 2164
1871err_free_rd_ring_1:
1872 velocity_free_rd_ring(vptr);
1873err_free_dma_rings_0:
1874 velocity_free_dma_rings(vptr);
1875 goto out;
1876}
1877
1878static void velocity_free_rings(struct velocity_info *vptr)
1879{
1880 velocity_free_td_ring(vptr);
1881 velocity_free_rd_ring(vptr);
1882 velocity_free_dma_rings(vptr);
1883} 2165}
1884 2166
1885/** 2167/**
@@ -1892,7 +2174,6 @@ static void velocity_free_rings(struct velocity_info *vptr)
1892 * All the ring allocation and set up is done on open for this 2174 * All the ring allocation and set up is done on open for this
1893 * adapter to minimise memory usage when inactive 2175 * adapter to minimise memory usage when inactive
1894 */ 2176 */
1895
1896static int velocity_open(struct net_device *dev) 2177static int velocity_open(struct net_device *dev)
1897{ 2178{
1898 struct velocity_info *vptr = netdev_priv(dev); 2179 struct velocity_info *vptr = netdev_priv(dev);
@@ -1926,6 +2207,24 @@ out:
1926} 2207}
1927 2208
1928/** 2209/**
2210 * velocity_shutdown - shut down the chip
2211 * @vptr: velocity to deactivate
2212 *
2213 * Shuts down the internal operations of the velocity and
2214 * disables interrupts, autopolling, transmit and receive
2215 */
2216static void velocity_shutdown(struct velocity_info *vptr)
2217{
2218 struct mac_regs __iomem *regs = vptr->mac_regs;
2219 mac_disable_int(regs);
2220 writel(CR0_STOP, &regs->CR0Set);
2221 writew(0xFFFF, &regs->TDCSRClr);
2222 writeb(0xFF, &regs->RDCSRClr);
2223 safe_disable_mii_autopoll(regs);
2224 mac_clear_isr(regs);
2225}
2226
2227/**
1929 * velocity_change_mtu - MTU change callback 2228 * velocity_change_mtu - MTU change callback
1930 * @dev: network device 2229 * @dev: network device
1931 * @new_mtu: desired MTU 2230 * @new_mtu: desired MTU
@@ -1934,7 +2233,6 @@ out:
1934 * this interface. It gets called on a change by the network layer. 2233 * this interface. It gets called on a change by the network layer.
1935 * Return zero for success or negative posix error code. 2234 * Return zero for success or negative posix error code.
1936 */ 2235 */
1937
1938static int velocity_change_mtu(struct net_device *dev, int new_mtu) 2236static int velocity_change_mtu(struct net_device *dev, int new_mtu)
1939{ 2237{
1940 struct velocity_info *vptr = netdev_priv(dev); 2238 struct velocity_info *vptr = netdev_priv(dev);
@@ -2008,22 +2306,127 @@ out_0:
2008} 2306}
2009 2307
2010/** 2308/**
2011 * velocity_shutdown - shut down the chip 2309 * velocity_mii_ioctl - MII ioctl handler
2012 * @vptr: velocity to deactivate 2310 * @dev: network device
2311 * @ifr: the ifreq block for the ioctl
2312 * @cmd: the command
2013 * 2313 *
2014 * Shuts down the internal operations of the velocity and 2314 * Process MII requests made via ioctl from the network layer. These
2015 * disables interrupts, autopolling, transmit and receive 2315 * are used by tools like kudzu to interrogate the link state of the
2316 * hardware
2016 */ 2317 */
2017 2318static int velocity_mii_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2018static void velocity_shutdown(struct velocity_info *vptr)
2019{ 2319{
2320 struct velocity_info *vptr = netdev_priv(dev);
2020 struct mac_regs __iomem *regs = vptr->mac_regs; 2321 struct mac_regs __iomem *regs = vptr->mac_regs;
2021 mac_disable_int(regs); 2322 unsigned long flags;
2022 writel(CR0_STOP, &regs->CR0Set); 2323 struct mii_ioctl_data *miidata = if_mii(ifr);
2023 writew(0xFFFF, &regs->TDCSRClr); 2324 int err;
2024 writeb(0xFF, &regs->RDCSRClr); 2325
2025 safe_disable_mii_autopoll(regs); 2326 switch (cmd) {
2026 mac_clear_isr(regs); 2327 case SIOCGMIIPHY:
2328 miidata->phy_id = readb(&regs->MIIADR) & 0x1f;
2329 break;
2330 case SIOCGMIIREG:
2331 if (!capable(CAP_NET_ADMIN))
2332 return -EPERM;
2333 if (velocity_mii_read(vptr->mac_regs, miidata->reg_num & 0x1f, &(miidata->val_out)) < 0)
2334 return -ETIMEDOUT;
2335 break;
2336 case SIOCSMIIREG:
2337 if (!capable(CAP_NET_ADMIN))
2338 return -EPERM;
2339 spin_lock_irqsave(&vptr->lock, flags);
2340 err = velocity_mii_write(vptr->mac_regs, miidata->reg_num & 0x1f, miidata->val_in);
2341 spin_unlock_irqrestore(&vptr->lock, flags);
2342 check_connection_type(vptr->mac_regs);
2343 if (err)
2344 return err;
2345 break;
2346 default:
2347 return -EOPNOTSUPP;
2348 }
2349 return 0;
2350}
2351
2352
2353/**
2354 * velocity_ioctl - ioctl entry point
2355 * @dev: network device
2356 * @rq: interface request ioctl
2357 * @cmd: command code
2358 *
2359 * Called when the user issues an ioctl request to the network
2360 * device in question. The velocity interface supports MII.
2361 */
2362static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2363{
2364 struct velocity_info *vptr = netdev_priv(dev);
2365 int ret;
2366
2367 /* If we are asked for information and the device is power
2368 saving then we need to bring the device back up to talk to it */
2369
2370 if (!netif_running(dev))
2371 pci_set_power_state(vptr->pdev, PCI_D0);
2372
2373 switch (cmd) {
2374 case SIOCGMIIPHY: /* Get address of MII PHY in use. */
2375 case SIOCGMIIREG: /* Read MII PHY register. */
2376 case SIOCSMIIREG: /* Write to MII PHY register. */
2377 ret = velocity_mii_ioctl(dev, rq, cmd);
2378 break;
2379
2380 default:
2381 ret = -EOPNOTSUPP;
2382 }
2383 if (!netif_running(dev))
2384 pci_set_power_state(vptr->pdev, PCI_D3hot);
2385
2386
2387 return ret;
2388}
2389
2390/**
2391 * velocity_get_status - statistics callback
2392 * @dev: network device
2393 *
2394 * Callback from the network layer to allow driver statistics
2395 * to be resynchronized with hardware collected state. In the
2396 * case of the velocity we need to pull the MIB counters from
2397 * the hardware into the counters before letting the network
2398 * layer display them.
2399 */
2400static struct net_device_stats *velocity_get_stats(struct net_device *dev)
2401{
2402 struct velocity_info *vptr = netdev_priv(dev);
2403
2404 /* If the hardware is down, don't touch MII */
2405 if (!netif_running(dev))
2406 return &dev->stats;
2407
2408 spin_lock_irq(&vptr->lock);
2409 velocity_update_hw_mibs(vptr);
2410 spin_unlock_irq(&vptr->lock);
2411
2412 dev->stats.rx_packets = vptr->mib_counter[HW_MIB_ifRxAllPkts];
2413 dev->stats.rx_errors = vptr->mib_counter[HW_MIB_ifRxErrorPkts];
2414 dev->stats.rx_length_errors = vptr->mib_counter[HW_MIB_ifInRangeLengthErrors];
2415
2416// unsigned long rx_dropped; /* no space in linux buffers */
2417 dev->stats.collisions = vptr->mib_counter[HW_MIB_ifTxEtherCollisions];
2418 /* detailed rx_errors: */
2419// unsigned long rx_length_errors;
2420// unsigned long rx_over_errors; /* receiver ring buff overflow */
2421 dev->stats.rx_crc_errors = vptr->mib_counter[HW_MIB_ifRxPktCRCE];
2422// unsigned long rx_frame_errors; /* recv'd frame alignment error */
2423// unsigned long rx_fifo_errors; /* recv'r fifo overrun */
2424// unsigned long rx_missed_errors; /* receiver missed packet */
2425
2426 /* detailed tx_errors */
2427// unsigned long tx_fifo_errors;
2428
2429 return &dev->stats;
2027} 2430}
2028 2431
2029/** 2432/**
@@ -2033,7 +2436,6 @@ static void velocity_shutdown(struct velocity_info *vptr)
2033 * Callback from the network layer when the velocity is being 2436 * Callback from the network layer when the velocity is being
2034 * deactivated by the network layer 2437 * deactivated by the network layer
2035 */ 2438 */
2036
2037static int velocity_close(struct net_device *dev) 2439static int velocity_close(struct net_device *dev)
2038{ 2440{
2039 struct velocity_info *vptr = netdev_priv(dev); 2441 struct velocity_info *vptr = netdev_priv(dev);
@@ -2063,7 +2465,6 @@ static int velocity_close(struct net_device *dev)
2063 * Called by the networ layer to request a packet is queued to 2465 * Called by the networ layer to request a packet is queued to
2064 * the velocity. Returns zero on success. 2466 * the velocity. Returns zero on success.
2065 */ 2467 */
2066
2067static int velocity_xmit(struct sk_buff *skb, struct net_device *dev) 2468static int velocity_xmit(struct sk_buff *skb, struct net_device *dev)
2068{ 2469{
2069 struct velocity_info *vptr = netdev_priv(dev); 2470 struct velocity_info *vptr = netdev_priv(dev);
@@ -2075,7 +2476,6 @@ static int velocity_xmit(struct sk_buff *skb, struct net_device *dev)
2075 __le16 len; 2476 __le16 len;
2076 int index; 2477 int index;
2077 2478
2078
2079 if (skb_padto(skb, ETH_ZLEN)) 2479 if (skb_padto(skb, ETH_ZLEN))
2080 goto out; 2480 goto out;
2081 pktlen = max_t(unsigned int, skb->len, ETH_ZLEN); 2481 pktlen = max_t(unsigned int, skb->len, ETH_ZLEN);
@@ -2145,780 +2545,533 @@ out:
2145 return NETDEV_TX_OK; 2545 return NETDEV_TX_OK;
2146} 2546}
2147 2547
2548
2549static const struct net_device_ops velocity_netdev_ops = {
2550 .ndo_open = velocity_open,
2551 .ndo_stop = velocity_close,
2552 .ndo_start_xmit = velocity_xmit,
2553 .ndo_get_stats = velocity_get_stats,
2554 .ndo_validate_addr = eth_validate_addr,
2555 .ndo_set_mac_address = eth_mac_addr,
2556 .ndo_set_multicast_list = velocity_set_multi,
2557 .ndo_change_mtu = velocity_change_mtu,
2558 .ndo_do_ioctl = velocity_ioctl,
2559 .ndo_vlan_rx_add_vid = velocity_vlan_rx_add_vid,
2560 .ndo_vlan_rx_kill_vid = velocity_vlan_rx_kill_vid,
2561 .ndo_vlan_rx_register = velocity_vlan_rx_register,
2562};
2563
2148/** 2564/**
2149 * velocity_intr - interrupt callback 2565 * velocity_init_info - init private data
2150 * @irq: interrupt number 2566 * @pdev: PCI device
2151 * @dev_instance: interrupting device 2567 * @vptr: Velocity info
2568 * @info: Board type
2152 * 2569 *
2153 * Called whenever an interrupt is generated by the velocity 2570 * Set up the initial velocity_info struct for the device that has been
2154 * adapter IRQ line. We may not be the source of the interrupt 2571 * discovered.
2155 * and need to identify initially if we are, and if not exit as
2156 * efficiently as possible.
2157 */ 2572 */
2158 2573static void __devinit velocity_init_info(struct pci_dev *pdev,
2159static irqreturn_t velocity_intr(int irq, void *dev_instance) 2574 struct velocity_info *vptr,
2575 const struct velocity_info_tbl *info)
2160{ 2576{
2161 struct net_device *dev = dev_instance; 2577 memset(vptr, 0, sizeof(struct velocity_info));
2162 struct velocity_info *vptr = netdev_priv(dev);
2163 u32 isr_status;
2164 int max_count = 0;
2165
2166
2167 spin_lock(&vptr->lock);
2168 isr_status = mac_read_isr(vptr->mac_regs);
2169
2170 /* Not us ? */
2171 if (isr_status == 0) {
2172 spin_unlock(&vptr->lock);
2173 return IRQ_NONE;
2174 }
2175
2176 mac_disable_int(vptr->mac_regs);
2177
2178 /*
2179 * Keep processing the ISR until we have completed
2180 * processing and the isr_status becomes zero
2181 */
2182
2183 while (isr_status != 0) {
2184 mac_write_isr(vptr->mac_regs, isr_status);
2185 if (isr_status & (~(ISR_PRXI | ISR_PPRXI | ISR_PTXI | ISR_PPTXI)))
2186 velocity_error(vptr, isr_status);
2187 if (isr_status & (ISR_PRXI | ISR_PPRXI))
2188 max_count += velocity_rx_srv(vptr, isr_status);
2189 if (isr_status & (ISR_PTXI | ISR_PPTXI))
2190 max_count += velocity_tx_srv(vptr, isr_status);
2191 isr_status = mac_read_isr(vptr->mac_regs);
2192 if (max_count > vptr->options.int_works) {
2193 printk(KERN_WARNING "%s: excessive work at interrupt.\n",
2194 dev->name);
2195 max_count = 0;
2196 }
2197 }
2198 spin_unlock(&vptr->lock);
2199 mac_enable_int(vptr->mac_regs);
2200 return IRQ_HANDLED;
2201 2578
2579 vptr->pdev = pdev;
2580 vptr->chip_id = info->chip_id;
2581 vptr->tx.numq = info->txqueue;
2582 vptr->multicast_limit = MCAM_SIZE;
2583 spin_lock_init(&vptr->lock);
2584 INIT_LIST_HEAD(&vptr->list);
2202} 2585}
2203 2586
2204
2205/** 2587/**
2206 * velocity_set_multi - filter list change callback 2588 * velocity_get_pci_info - retrieve PCI info for device
2207 * @dev: network device 2589 * @vptr: velocity device
2590 * @pdev: PCI device it matches
2208 * 2591 *
2209 * Called by the network layer when the filter lists need to change 2592 * Retrieve the PCI configuration space data that interests us from
2210 * for a velocity adapter. Reload the CAMs with the new address 2593 * the kernel PCI layer
2211 * filter ruleset.
2212 */ 2594 */
2213 2595static int __devinit velocity_get_pci_info(struct velocity_info *vptr, struct pci_dev *pdev)
2214static void velocity_set_multi(struct net_device *dev)
2215{ 2596{
2216 struct velocity_info *vptr = netdev_priv(dev); 2597 vptr->rev_id = pdev->revision;
2217 struct mac_regs __iomem *regs = vptr->mac_regs;
2218 u8 rx_mode;
2219 int i;
2220 struct dev_mc_list *mclist;
2221 2598
2222 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */ 2599 pci_set_master(pdev);
2223 writel(0xffffffff, &regs->MARCAM[0]);
2224 writel(0xffffffff, &regs->MARCAM[4]);
2225 rx_mode = (RCR_AM | RCR_AB | RCR_PROM);
2226 } else if ((dev->mc_count > vptr->multicast_limit)
2227 || (dev->flags & IFF_ALLMULTI)) {
2228 writel(0xffffffff, &regs->MARCAM[0]);
2229 writel(0xffffffff, &regs->MARCAM[4]);
2230 rx_mode = (RCR_AM | RCR_AB);
2231 } else {
2232 int offset = MCAM_SIZE - vptr->multicast_limit;
2233 mac_get_cam_mask(regs, vptr->mCAMmask);
2234 2600
2235 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count; i++, mclist = mclist->next) { 2601 vptr->ioaddr = pci_resource_start(pdev, 0);
2236 mac_set_cam(regs, i + offset, mclist->dmi_addr); 2602 vptr->memaddr = pci_resource_start(pdev, 1);
2237 vptr->mCAMmask[(offset + i) / 8] |= 1 << ((offset + i) & 7);
2238 }
2239 2603
2240 mac_set_cam_mask(regs, vptr->mCAMmask); 2604 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_IO)) {
2241 rx_mode = RCR_AM | RCR_AB | RCR_AP; 2605 dev_err(&pdev->dev,
2606 "region #0 is not an I/O resource, aborting.\n");
2607 return -EINVAL;
2242 } 2608 }
2243 if (dev->mtu > 1500)
2244 rx_mode |= RCR_AL;
2245 2609
2246 BYTE_REG_BITS_ON(rx_mode, &regs->RCR); 2610 if ((pci_resource_flags(pdev, 1) & IORESOURCE_IO)) {
2611 dev_err(&pdev->dev,
2612 "region #1 is an I/O resource, aborting.\n");
2613 return -EINVAL;
2614 }
2615
2616 if (pci_resource_len(pdev, 1) < VELOCITY_IO_SIZE) {
2617 dev_err(&pdev->dev, "region #1 is too small.\n");
2618 return -EINVAL;
2619 }
2620 vptr->pdev = pdev;
2247 2621
2622 return 0;
2248} 2623}
2249 2624
2250/** 2625/**
2251 * velocity_get_status - statistics callback 2626 * velocity_print_info - per driver data
2252 * @dev: network device 2627 * @vptr: velocity
2253 * 2628 *
2254 * Callback from the network layer to allow driver statistics 2629 * Print per driver data as the kernel driver finds Velocity
2255 * to be resynchronized with hardware collected state. In the 2630 * hardware
2256 * case of the velocity we need to pull the MIB counters from
2257 * the hardware into the counters before letting the network
2258 * layer display them.
2259 */ 2631 */
2260 2632static void __devinit velocity_print_info(struct velocity_info *vptr)
2261static struct net_device_stats *velocity_get_stats(struct net_device *dev)
2262{ 2633{
2263 struct velocity_info *vptr = netdev_priv(dev); 2634 struct net_device *dev = vptr->dev;
2264
2265 /* If the hardware is down, don't touch MII */
2266 if (!netif_running(dev))
2267 return &dev->stats;
2268
2269 spin_lock_irq(&vptr->lock);
2270 velocity_update_hw_mibs(vptr);
2271 spin_unlock_irq(&vptr->lock);
2272
2273 dev->stats.rx_packets = vptr->mib_counter[HW_MIB_ifRxAllPkts];
2274 dev->stats.rx_errors = vptr->mib_counter[HW_MIB_ifRxErrorPkts];
2275 dev->stats.rx_length_errors = vptr->mib_counter[HW_MIB_ifInRangeLengthErrors];
2276
2277// unsigned long rx_dropped; /* no space in linux buffers */
2278 dev->stats.collisions = vptr->mib_counter[HW_MIB_ifTxEtherCollisions];
2279 /* detailed rx_errors: */
2280// unsigned long rx_length_errors;
2281// unsigned long rx_over_errors; /* receiver ring buff overflow */
2282 dev->stats.rx_crc_errors = vptr->mib_counter[HW_MIB_ifRxPktCRCE];
2283// unsigned long rx_frame_errors; /* recv'd frame alignment error */
2284// unsigned long rx_fifo_errors; /* recv'r fifo overrun */
2285// unsigned long rx_missed_errors; /* receiver missed packet */
2286
2287 /* detailed tx_errors */
2288// unsigned long tx_fifo_errors;
2289 2635
2290 return &dev->stats; 2636 printk(KERN_INFO "%s: %s\n", dev->name, get_chip_name(vptr->chip_id));
2637 printk(KERN_INFO "%s: Ethernet Address: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
2638 dev->name,
2639 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
2640 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
2291} 2641}
2292 2642
2293 2643static u32 velocity_get_link(struct net_device *dev)
2294/**
2295 * velocity_ioctl - ioctl entry point
2296 * @dev: network device
2297 * @rq: interface request ioctl
2298 * @cmd: command code
2299 *
2300 * Called when the user issues an ioctl request to the network
2301 * device in question. The velocity interface supports MII.
2302 */
2303
2304static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2305{ 2644{
2306 struct velocity_info *vptr = netdev_priv(dev); 2645 struct velocity_info *vptr = netdev_priv(dev);
2307 int ret; 2646 struct mac_regs __iomem *regs = vptr->mac_regs;
2308 2647 return BYTE_REG_BITS_IS_ON(PHYSR0_LINKGD, &regs->PHYSR0) ? 1 : 0;
2309 /* If we are asked for information and the device is power
2310 saving then we need to bring the device back up to talk to it */
2311
2312 if (!netif_running(dev))
2313 pci_set_power_state(vptr->pdev, PCI_D0);
2314
2315 switch (cmd) {
2316 case SIOCGMIIPHY: /* Get address of MII PHY in use. */
2317 case SIOCGMIIREG: /* Read MII PHY register. */
2318 case SIOCSMIIREG: /* Write to MII PHY register. */
2319 ret = velocity_mii_ioctl(dev, rq, cmd);
2320 break;
2321
2322 default:
2323 ret = -EOPNOTSUPP;
2324 }
2325 if (!netif_running(dev))
2326 pci_set_power_state(vptr->pdev, PCI_D3hot);
2327
2328
2329 return ret;
2330} 2648}
2331 2649
2332/*
2333 * Definition for our device driver. The PCI layer interface
2334 * uses this to handle all our card discover and plugging
2335 */
2336
2337static struct pci_driver velocity_driver = {
2338 .name = VELOCITY_NAME,
2339 .id_table = velocity_id_table,
2340 .probe = velocity_found1,
2341 .remove = __devexit_p(velocity_remove1),
2342#ifdef CONFIG_PM
2343 .suspend = velocity_suspend,
2344 .resume = velocity_resume,
2345#endif
2346};
2347 2650
2348/** 2651/**
2349 * velocity_init_module - load time function 2652 * velocity_found1 - set up discovered velocity card
2653 * @pdev: PCI device
2654 * @ent: PCI device table entry that matched
2350 * 2655 *
2351 * Called when the velocity module is loaded. The PCI driver 2656 * Configure a discovered adapter from scratch. Return a negative
2352 * is registered with the PCI layer, and in turn will call 2657 * errno error code on failure paths.
2353 * the probe functions for each velocity adapter installed
2354 * in the system.
2355 */ 2658 */
2356 2659static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_device_id *ent)
2357static int __init velocity_init_module(void)
2358{ 2660{
2359 int ret; 2661 static int first = 1;
2662 struct net_device *dev;
2663 int i;
2664 const char *drv_string;
2665 const struct velocity_info_tbl *info = &chip_info_table[ent->driver_data];
2666 struct velocity_info *vptr;
2667 struct mac_regs __iomem *regs;
2668 int ret = -ENOMEM;
2360 2669
2361 velocity_register_notifier(); 2670 /* FIXME: this driver, like almost all other ethernet drivers,
2362 ret = pci_register_driver(&velocity_driver); 2671 * can support more than MAX_UNITS.
2363 if (ret < 0) 2672 */
2364 velocity_unregister_notifier(); 2673 if (velocity_nics >= MAX_UNITS) {
2365 return ret; 2674 dev_notice(&pdev->dev, "already found %d NICs.\n",
2366} 2675 velocity_nics);
2676 return -ENODEV;
2677 }
2367 2678
2368/** 2679 dev = alloc_etherdev(sizeof(struct velocity_info));
2369 * velocity_cleanup - module unload 2680 if (!dev) {
2370 * 2681 dev_err(&pdev->dev, "allocate net device failed.\n");
2371 * When the velocity hardware is unloaded this function is called. 2682 goto out;
2372 * It will clean up the notifiers and the unregister the PCI 2683 }
2373 * driver interface for this hardware. This in turn cleans up
2374 * all discovered interfaces before returning from the function
2375 */
2376 2684
2377static void __exit velocity_cleanup_module(void) 2685 /* Chain it all together */
2378{
2379 velocity_unregister_notifier();
2380 pci_unregister_driver(&velocity_driver);
2381}
2382 2686
2383module_init(velocity_init_module); 2687 SET_NETDEV_DEV(dev, &pdev->dev);
2384module_exit(velocity_cleanup_module); 2688 vptr = netdev_priv(dev);
2385 2689
2386 2690
2387/* 2691 if (first) {
2388 * MII access , media link mode setting functions 2692 printk(KERN_INFO "%s Ver. %s\n",
2389 */ 2693 VELOCITY_FULL_DRV_NAM, VELOCITY_VERSION);
2694 printk(KERN_INFO "Copyright (c) 2002, 2003 VIA Networking Technologies, Inc.\n");
2695 printk(KERN_INFO "Copyright (c) 2004 Red Hat Inc.\n");
2696 first = 0;
2697 }
2390 2698
2699 velocity_init_info(pdev, vptr, info);
2391 2700
2392/** 2701 vptr->dev = dev;
2393 * mii_init - set up MII
2394 * @vptr: velocity adapter
2395 * @mii_status: links tatus
2396 *
2397 * Set up the PHY for the current link state.
2398 */
2399 2702
2400static void mii_init(struct velocity_info *vptr, u32 mii_status) 2703 dev->irq = pdev->irq;
2401{
2402 u16 BMCR;
2403 2704
2404 switch (PHYID_GET_PHY_ID(vptr->phy_id)) { 2705 ret = pci_enable_device(pdev);
2405 case PHYID_CICADA_CS8201: 2706 if (ret < 0)
2406 /* 2707 goto err_free_dev;
2407 * Reset to hardware default
2408 */
2409 MII_REG_BITS_OFF((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
2410 /*
2411 * Turn on ECHODIS bit in NWay-forced full mode and turn it
2412 * off it in NWay-forced half mode for NWay-forced v.s.
2413 * legacy-forced issue.
2414 */
2415 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
2416 MII_REG_BITS_ON(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
2417 else
2418 MII_REG_BITS_OFF(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
2419 /*
2420 * Turn on Link/Activity LED enable bit for CIS8201
2421 */
2422 MII_REG_BITS_ON(PLED_LALBE, MII_REG_PLED, vptr->mac_regs);
2423 break;
2424 case PHYID_VT3216_32BIT:
2425 case PHYID_VT3216_64BIT:
2426 /*
2427 * Reset to hardware default
2428 */
2429 MII_REG_BITS_ON((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
2430 /*
2431 * Turn on ECHODIS bit in NWay-forced full mode and turn it
2432 * off it in NWay-forced half mode for NWay-forced v.s.
2433 * legacy-forced issue
2434 */
2435 if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
2436 MII_REG_BITS_ON(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
2437 else
2438 MII_REG_BITS_OFF(TCSR_ECHODIS, MII_REG_TCSR, vptr->mac_regs);
2439 break;
2440 2708
2441 case PHYID_MARVELL_1000: 2709 ret = velocity_get_pci_info(vptr, pdev);
2442 case PHYID_MARVELL_1000S: 2710 if (ret < 0) {
2443 /* 2711 /* error message already printed */
2444 * Assert CRS on Transmit 2712 goto err_disable;
2445 */
2446 MII_REG_BITS_ON(PSCR_ACRSTX, MII_REG_PSCR, vptr->mac_regs);
2447 /*
2448 * Reset to hardware default
2449 */
2450 MII_REG_BITS_ON((ANAR_ASMDIR | ANAR_PAUSE), MII_REG_ANAR, vptr->mac_regs);
2451 break;
2452 default:
2453 ;
2454 }
2455 velocity_mii_read(vptr->mac_regs, MII_REG_BMCR, &BMCR);
2456 if (BMCR & BMCR_ISO) {
2457 BMCR &= ~BMCR_ISO;
2458 velocity_mii_write(vptr->mac_regs, MII_REG_BMCR, BMCR);
2459 } 2713 }
2460}
2461 2714
2462/** 2715 ret = pci_request_regions(pdev, VELOCITY_NAME);
2463 * safe_disable_mii_autopoll - autopoll off 2716 if (ret < 0) {
2464 * @regs: velocity registers 2717 dev_err(&pdev->dev, "No PCI resources.\n");
2465 * 2718 goto err_disable;
2466 * Turn off the autopoll and wait for it to disable on the chip
2467 */
2468
2469static void safe_disable_mii_autopoll(struct mac_regs __iomem *regs)
2470{
2471 u16 ww;
2472
2473 /* turn off MAUTO */
2474 writeb(0, &regs->MIICR);
2475 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) {
2476 udelay(1);
2477 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
2478 break;
2479 } 2719 }
2480}
2481 2720
2482/** 2721 regs = ioremap(vptr->memaddr, VELOCITY_IO_SIZE);
2483 * enable_mii_autopoll - turn on autopolling 2722 if (regs == NULL) {
2484 * @regs: velocity registers 2723 ret = -EIO;
2485 * 2724 goto err_release_res;
2486 * Enable the MII link status autopoll feature on the Velocity 2725 }
2487 * hardware. Wait for it to enable.
2488 */
2489
2490static void enable_mii_autopoll(struct mac_regs __iomem *regs)
2491{
2492 int ii;
2493 2726
2494 writeb(0, &(regs->MIICR)); 2727 vptr->mac_regs = regs;
2495 writeb(MIIADR_SWMPL, &regs->MIIADR);
2496 2728
2497 for (ii = 0; ii < W_MAX_TIMEOUT; ii++) { 2729 mac_wol_reset(regs);
2498 udelay(1);
2499 if (BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
2500 break;
2501 }
2502 2730
2503 writeb(MIICR_MAUTO, &regs->MIICR); 2731 dev->base_addr = vptr->ioaddr;
2504 2732
2505 for (ii = 0; ii < W_MAX_TIMEOUT; ii++) { 2733 for (i = 0; i < 6; i++)
2506 udelay(1); 2734 dev->dev_addr[i] = readb(&regs->PAR[i]);
2507 if (!BYTE_REG_BITS_IS_ON(MIISR_MIDLE, &regs->MIISR))
2508 break;
2509 }
2510 2735
2511}
2512 2736
2513/** 2737 drv_string = dev_driver_string(&pdev->dev);
2514 * velocity_mii_read - read MII data
2515 * @regs: velocity registers
2516 * @index: MII register index
2517 * @data: buffer for received data
2518 *
2519 * Perform a single read of an MII 16bit register. Returns zero
2520 * on success or -ETIMEDOUT if the PHY did not respond.
2521 */
2522 2738
2523static int velocity_mii_read(struct mac_regs __iomem *regs, u8 index, u16 *data) 2739 velocity_get_options(&vptr->options, velocity_nics, drv_string);
2524{
2525 u16 ww;
2526 2740
2527 /* 2741 /*
2528 * Disable MIICR_MAUTO, so that mii addr can be set normally 2742 * Mask out the options cannot be set to the chip
2529 */ 2743 */
2530 safe_disable_mii_autopoll(regs);
2531
2532 writeb(index, &regs->MIIADR);
2533 2744
2534 BYTE_REG_BITS_ON(MIICR_RCMD, &regs->MIICR); 2745 vptr->options.flags &= info->flags;
2535 2746
2536 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) { 2747 /*
2537 if (!(readb(&regs->MIICR) & MIICR_RCMD)) 2748 * Enable the chip specified capbilities
2538 break; 2749 */
2539 }
2540 2750
2541 *data = readw(&regs->MIIDATA); 2751 vptr->flags = vptr->options.flags | (info->flags & 0xFF000000UL);
2542 2752
2543 enable_mii_autopoll(regs); 2753 vptr->wol_opts = vptr->options.wol_opts;
2544 if (ww == W_MAX_TIMEOUT) 2754 vptr->flags |= VELOCITY_FLAGS_WOL_ENABLED;
2545 return -ETIMEDOUT;
2546 return 0;
2547}
2548 2755
2549/** 2756 vptr->phy_id = MII_GET_PHY_ID(vptr->mac_regs);
2550 * velocity_mii_write - write MII data
2551 * @regs: velocity registers
2552 * @index: MII register index
2553 * @data: 16bit data for the MII register
2554 *
2555 * Perform a single write to an MII 16bit register. Returns zero
2556 * on success or -ETIMEDOUT if the PHY did not respond.
2557 */
2558 2757
2559static int velocity_mii_write(struct mac_regs __iomem *regs, u8 mii_addr, u16 data) 2758 dev->irq = pdev->irq;
2560{ 2759 dev->netdev_ops = &velocity_netdev_ops;
2561 u16 ww; 2760 dev->ethtool_ops = &velocity_ethtool_ops;
2562 2761
2563 /* 2762 dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER |
2564 * Disable MIICR_MAUTO, so that mii addr can be set normally 2763 NETIF_F_HW_VLAN_RX;
2565 */
2566 safe_disable_mii_autopoll(regs);
2567 2764
2568 /* MII reg offset */ 2765 if (vptr->flags & VELOCITY_FLAGS_TX_CSUM)
2569 writeb(mii_addr, &regs->MIIADR); 2766 dev->features |= NETIF_F_IP_CSUM;
2570 /* set MII data */
2571 writew(data, &regs->MIIDATA);
2572 2767
2573 /* turn on MIICR_WCMD */ 2768 ret = register_netdev(dev);
2574 BYTE_REG_BITS_ON(MIICR_WCMD, &regs->MIICR); 2769 if (ret < 0)
2770 goto err_iounmap;
2575 2771
2576 /* W_MAX_TIMEOUT is the timeout period */ 2772 if (!velocity_get_link(dev)) {
2577 for (ww = 0; ww < W_MAX_TIMEOUT; ww++) { 2773 netif_carrier_off(dev);
2578 udelay(5); 2774 vptr->mii_status |= VELOCITY_LINK_FAIL;
2579 if (!(readb(&regs->MIICR) & MIICR_WCMD))
2580 break;
2581 } 2775 }
2582 enable_mii_autopoll(regs);
2583 2776
2584 if (ww == W_MAX_TIMEOUT) 2777 velocity_print_info(vptr);
2585 return -ETIMEDOUT; 2778 pci_set_drvdata(pdev, dev);
2586 return 0;
2587}
2588 2779
2589/** 2780 /* and leave the chip powered down */
2590 * velocity_get_opt_media_mode - get media selection
2591 * @vptr: velocity adapter
2592 *
2593 * Get the media mode stored in EEPROM or module options and load
2594 * mii_status accordingly. The requested link state information
2595 * is also returned.
2596 */
2597 2781
2598static u32 velocity_get_opt_media_mode(struct velocity_info *vptr) 2782 pci_set_power_state(pdev, PCI_D3hot);
2599{ 2783#ifdef CONFIG_PM
2600 u32 status = 0; 2784 {
2785 unsigned long flags;
2601 2786
2602 switch (vptr->options.spd_dpx) { 2787 spin_lock_irqsave(&velocity_dev_list_lock, flags);
2603 case SPD_DPX_AUTO: 2788 list_add(&vptr->list, &velocity_dev_list);
2604 status = VELOCITY_AUTONEG_ENABLE; 2789 spin_unlock_irqrestore(&velocity_dev_list_lock, flags);
2605 break;
2606 case SPD_DPX_100_FULL:
2607 status = VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL;
2608 break;
2609 case SPD_DPX_10_FULL:
2610 status = VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL;
2611 break;
2612 case SPD_DPX_100_HALF:
2613 status = VELOCITY_SPEED_100;
2614 break;
2615 case SPD_DPX_10_HALF:
2616 status = VELOCITY_SPEED_10;
2617 break;
2618 } 2790 }
2619 vptr->mii_status = status; 2791#endif
2620 return status; 2792 velocity_nics++;
2621} 2793out:
2622 2794 return ret;
2623/**
2624 * mii_set_auto_on - autonegotiate on
2625 * @vptr: velocity
2626 *
2627 * Enable autonegotation on this interface
2628 */
2629 2795
2630static void mii_set_auto_on(struct velocity_info *vptr) 2796err_iounmap:
2631{ 2797 iounmap(regs);
2632 if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs)) 2798err_release_res:
2633 MII_REG_BITS_ON(BMCR_REAUTO, MII_REG_BMCR, vptr->mac_regs); 2799 pci_release_regions(pdev);
2634 else 2800err_disable:
2635 MII_REG_BITS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs); 2801 pci_disable_device(pdev);
2802err_free_dev:
2803 free_netdev(dev);
2804 goto out;
2636} 2805}
2637 2806
2638 2807
2639/* 2808#ifdef CONFIG_PM
2640static void mii_set_auto_off(struct velocity_info *vptr)
2641{
2642 MII_REG_BITS_OFF(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs);
2643}
2644*/
2645
2646/** 2809/**
2647 * set_mii_flow_control - flow control setup 2810 * wol_calc_crc - WOL CRC
2648 * @vptr: velocity interface 2811 * @pattern: data pattern
2812 * @mask_pattern: mask
2649 * 2813 *
2650 * Set up the flow control on this interface according to 2814 * Compute the wake on lan crc hashes for the packet header
2651 * the supplied user/eeprom options. 2815 * we are interested in.
2652 */ 2816 */
2653 2817static u16 wol_calc_crc(int size, u8 *pattern, u8 *mask_pattern)
2654static void set_mii_flow_control(struct velocity_info *vptr)
2655{ 2818{
2656 /*Enable or Disable PAUSE in ANAR */ 2819 u16 crc = 0xFFFF;
2657 switch (vptr->options.flow_cntl) { 2820 u8 mask;
2658 case FLOW_CNTL_TX: 2821 int i, j;
2659 MII_REG_BITS_OFF(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs);
2660 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
2661 break;
2662 2822
2663 case FLOW_CNTL_RX: 2823 for (i = 0; i < size; i++) {
2664 MII_REG_BITS_ON(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs); 2824 mask = mask_pattern[i];
2665 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs);
2666 break;
2667 2825
2668 case FLOW_CNTL_TX_RX: 2826 /* Skip this loop if the mask equals to zero */
2669 MII_REG_BITS_ON(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs); 2827 if (mask == 0x00)
2670 MII_REG_BITS_ON(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs); 2828 continue;
2671 break;
2672 2829
2673 case FLOW_CNTL_DISABLE: 2830 for (j = 0; j < 8; j++) {
2674 MII_REG_BITS_OFF(ANAR_PAUSE, MII_REG_ANAR, vptr->mac_regs); 2831 if ((mask & 0x01) == 0) {
2675 MII_REG_BITS_OFF(ANAR_ASMDIR, MII_REG_ANAR, vptr->mac_regs); 2832 mask >>= 1;
2676 break; 2833 continue;
2677 default: 2834 }
2678 break; 2835 mask >>= 1;
2836 crc = crc_ccitt(crc, &(pattern[i * 8 + j]), 1);
2837 }
2679 } 2838 }
2839 /* Finally, invert the result once to get the correct data */
2840 crc = ~crc;
2841 return bitrev32(crc) >> 16;
2680} 2842}
2681 2843
2682/** 2844/**
2683 * velocity_set_media_mode - set media mode 2845 * velocity_set_wol - set up for wake on lan
2684 * @mii_status: old MII link state 2846 * @vptr: velocity to set WOL status on
2685 * 2847 *
2686 * Check the media link state and configure the flow control 2848 * Set a card up for wake on lan either by unicast or by
2687 * PHY and also velocity hardware setup accordingly. In particular 2849 * ARP packet.
2688 * we need to set up CD polling and frame bursting. 2850 *
2851 * FIXME: check static buffer is safe here
2689 */ 2852 */
2690 2853static int velocity_set_wol(struct velocity_info *vptr)
2691static int velocity_set_media_mode(struct velocity_info *vptr, u32 mii_status)
2692{ 2854{
2693 u32 curr_status;
2694 struct mac_regs __iomem *regs = vptr->mac_regs; 2855 struct mac_regs __iomem *regs = vptr->mac_regs;
2856 static u8 buf[256];
2857 int i;
2695 2858
2696 vptr->mii_status = mii_check_media_mode(vptr->mac_regs); 2859 static u32 mask_pattern[2][4] = {
2697 curr_status = vptr->mii_status & (~VELOCITY_LINK_FAIL); 2860 {0x00203000, 0x000003C0, 0x00000000, 0x0000000}, /* ARP */
2861 {0xfffff000, 0xffffffff, 0xffffffff, 0x000ffff} /* Magic Packet */
2862 };
2698 2863
2699 /* Set mii link status */ 2864 writew(0xFFFF, &regs->WOLCRClr);
2700 set_mii_flow_control(vptr); 2865 writeb(WOLCFG_SAB | WOLCFG_SAM, &regs->WOLCFGSet);
2866 writew(WOLCR_MAGIC_EN, &regs->WOLCRSet);
2701 2867
2702 /* 2868 /*
2703 Check if new status is consisent with current status 2869 if (vptr->wol_opts & VELOCITY_WOL_PHY)
2704 if (((mii_status & curr_status) & VELOCITY_AUTONEG_ENABLE) 2870 writew((WOLCR_LINKON_EN|WOLCR_LINKOFF_EN), &regs->WOLCRSet);
2705 || (mii_status==curr_status)) {
2706 vptr->mii_status=mii_check_media_mode(vptr->mac_regs);
2707 vptr->mii_status=check_connection_type(vptr->mac_regs);
2708 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity link no change\n");
2709 return 0;
2710 }
2711 */ 2871 */
2712 2872
2713 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201) 2873 if (vptr->wol_opts & VELOCITY_WOL_UCAST)
2714 MII_REG_BITS_ON(AUXCR_MDPPS, MII_REG_AUXCR, vptr->mac_regs); 2874 writew(WOLCR_UNICAST_EN, &regs->WOLCRSet);
2715 2875
2716 /* 2876 if (vptr->wol_opts & VELOCITY_WOL_ARP) {
2717 * If connection type is AUTO 2877 struct arp_packet *arp = (struct arp_packet *) buf;
2718 */ 2878 u16 crc;
2719 if (mii_status & VELOCITY_AUTONEG_ENABLE) { 2879 memset(buf, 0, sizeof(struct arp_packet) + 7);
2720 VELOCITY_PRT(MSG_LEVEL_INFO, "Velocity is AUTO mode\n");
2721 /* clear force MAC mode bit */
2722 BYTE_REG_BITS_OFF(CHIPGCR_FCMODE, &regs->CHIPGCR);
2723 /* set duplex mode of MAC according to duplex mode of MII */
2724 MII_REG_BITS_ON(ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10, MII_REG_ANAR, vptr->mac_regs);
2725 MII_REG_BITS_ON(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
2726 MII_REG_BITS_ON(BMCR_SPEED1G, MII_REG_BMCR, vptr->mac_regs);
2727 2880
2728 /* enable AUTO-NEGO mode */ 2881 for (i = 0; i < 4; i++)
2729 mii_set_auto_on(vptr); 2882 writel(mask_pattern[0][i], &regs->ByteMask[0][i]);
2730 } else {
2731 u16 ANAR;
2732 u8 CHIPGCR;
2733 2883
2734 /* 2884 arp->type = htons(ETH_P_ARP);
2735 * 1. if it's 3119, disable frame bursting in halfduplex mode 2885 arp->ar_op = htons(1);
2736 * and enable it in fullduplex mode
2737 * 2. set correct MII/GMII and half/full duplex mode in CHIPGCR
2738 * 3. only enable CD heart beat counter in 10HD mode
2739 */
2740 2886
2741 /* set force MAC mode bit */ 2887 memcpy(arp->ar_tip, vptr->ip_addr, 4);
2742 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
2743 2888
2744 CHIPGCR = readb(&regs->CHIPGCR); 2889 crc = wol_calc_crc((sizeof(struct arp_packet) + 7) / 8, buf,
2745 CHIPGCR &= ~CHIPGCR_FCGMII; 2890 (u8 *) & mask_pattern[0][0]);
2746 2891
2747 if (mii_status & VELOCITY_DUPLEX_FULL) { 2892 writew(crc, &regs->PatternCRC[0]);
2748 CHIPGCR |= CHIPGCR_FCFDX; 2893 writew(WOLCR_ARP_EN, &regs->WOLCRSet);
2749 writeb(CHIPGCR, &regs->CHIPGCR); 2894 }
2750 VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced full mode\n"); 2895
2751 if (vptr->rev_id < REV_ID_VT3216_A0) 2896 BYTE_REG_BITS_ON(PWCFG_WOLTYPE, &regs->PWCFGSet);
2752 BYTE_REG_BITS_OFF(TCR_TB2BDIS, &regs->TCR); 2897 BYTE_REG_BITS_ON(PWCFG_LEGACY_WOLEN, &regs->PWCFGSet);
2753 } else { 2898
2754 CHIPGCR &= ~CHIPGCR_FCFDX; 2899 writew(0x0FFF, &regs->WOLSRClr);
2755 VELOCITY_PRT(MSG_LEVEL_INFO, "set Velocity to forced half mode\n"); 2900
2756 writeb(CHIPGCR, &regs->CHIPGCR); 2901 if (vptr->mii_status & VELOCITY_AUTONEG_ENABLE) {
2757 if (vptr->rev_id < REV_ID_VT3216_A0) 2902 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201)
2758 BYTE_REG_BITS_ON(TCR_TB2BDIS, &regs->TCR); 2903 MII_REG_BITS_ON(AUXCR_MDPPS, MII_REG_AUXCR, vptr->mac_regs);
2759 }
2760 2904
2761 MII_REG_BITS_OFF(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs); 2905 MII_REG_BITS_OFF(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
2906 }
2762 2907
2763 if (!(mii_status & VELOCITY_DUPLEX_FULL) && (mii_status & VELOCITY_SPEED_10)) 2908 if (vptr->mii_status & VELOCITY_SPEED_1000)
2764 BYTE_REG_BITS_OFF(TESTCFG_HBDIS, &regs->TESTCFG); 2909 MII_REG_BITS_ON(BMCR_REAUTO, MII_REG_BMCR, vptr->mac_regs);
2765 else
2766 BYTE_REG_BITS_ON(TESTCFG_HBDIS, &regs->TESTCFG);
2767 2910
2768 /* MII_REG_BITS_OFF(BMCR_SPEED1G, MII_REG_BMCR, vptr->mac_regs); */ 2911 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
2769 velocity_mii_read(vptr->mac_regs, MII_REG_ANAR, &ANAR); 2912
2770 ANAR &= (~(ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)); 2913 {
2771 if (mii_status & VELOCITY_SPEED_100) { 2914 u8 GCR;
2772 if (mii_status & VELOCITY_DUPLEX_FULL) 2915 GCR = readb(&regs->CHIPGCR);
2773 ANAR |= ANAR_TXFD; 2916 GCR = (GCR & ~CHIPGCR_FCGMII) | CHIPGCR_FCFDX;
2774 else 2917 writeb(GCR, &regs->CHIPGCR);
2775 ANAR |= ANAR_TX;
2776 } else {
2777 if (mii_status & VELOCITY_DUPLEX_FULL)
2778 ANAR |= ANAR_10FD;
2779 else
2780 ANAR |= ANAR_10;
2781 }
2782 velocity_mii_write(vptr->mac_regs, MII_REG_ANAR, ANAR);
2783 /* enable AUTO-NEGO mode */
2784 mii_set_auto_on(vptr);
2785 /* MII_REG_BITS_ON(BMCR_AUTO, MII_REG_BMCR, vptr->mac_regs); */
2786 } 2918 }
2787 /* vptr->mii_status=mii_check_media_mode(vptr->mac_regs); */ 2919
2788 /* vptr->mii_status=check_connection_type(vptr->mac_regs); */ 2920 BYTE_REG_BITS_OFF(ISR_PWEI, &regs->ISR);
2789 return VELOCITY_LINK_CHANGE; 2921 /* Turn on SWPTAG just before entering power mode */
2922 BYTE_REG_BITS_ON(STICKHW_SWPTAG, &regs->STICKHW);
2923 /* Go to bed ..... */
2924 BYTE_REG_BITS_ON((STICKHW_DS1 | STICKHW_DS0), &regs->STICKHW);
2925
2926 return 0;
2790} 2927}
2791 2928
2792/** 2929/**
2793 * mii_check_media_mode - check media state 2930 * velocity_save_context - save registers
2794 * @regs: velocity registers 2931 * @vptr: velocity
2932 * @context: buffer for stored context
2795 * 2933 *
2796 * Check the current MII status and determine the link status 2934 * Retrieve the current configuration from the velocity hardware
2797 * accordingly 2935 * and stash it in the context structure, for use by the context
2936 * restore functions. This allows us to save things we need across
2937 * power down states
2798 */ 2938 */
2799 2939static void velocity_save_context(struct velocity_info *vptr, struct velocity_context *context)
2800static u32 mii_check_media_mode(struct mac_regs __iomem *regs)
2801{ 2940{
2802 u32 status = 0; 2941 struct mac_regs __iomem *regs = vptr->mac_regs;
2803 u16 ANAR; 2942 u16 i;
2943 u8 __iomem *ptr = (u8 __iomem *)regs;
2804 2944
2805 if (!MII_REG_BITS_IS_ON(BMSR_LNK, MII_REG_BMSR, regs)) 2945 for (i = MAC_REG_PAR; i < MAC_REG_CR0_CLR; i += 4)
2806 status |= VELOCITY_LINK_FAIL; 2946 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
2807 2947
2808 if (MII_REG_BITS_IS_ON(G1000CR_1000FD, MII_REG_G1000CR, regs)) 2948 for (i = MAC_REG_MAR; i < MAC_REG_TDCSR_CLR; i += 4)
2809 status |= VELOCITY_SPEED_1000 | VELOCITY_DUPLEX_FULL; 2949 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
2810 else if (MII_REG_BITS_IS_ON(G1000CR_1000, MII_REG_G1000CR, regs))
2811 status |= (VELOCITY_SPEED_1000);
2812 else {
2813 velocity_mii_read(regs, MII_REG_ANAR, &ANAR);
2814 if (ANAR & ANAR_TXFD)
2815 status |= (VELOCITY_SPEED_100 | VELOCITY_DUPLEX_FULL);
2816 else if (ANAR & ANAR_TX)
2817 status |= VELOCITY_SPEED_100;
2818 else if (ANAR & ANAR_10FD)
2819 status |= (VELOCITY_SPEED_10 | VELOCITY_DUPLEX_FULL);
2820 else
2821 status |= (VELOCITY_SPEED_10);
2822 }
2823 2950
2824 if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, regs)) { 2951 for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4)
2825 velocity_mii_read(regs, MII_REG_ANAR, &ANAR); 2952 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
2826 if ((ANAR & (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10))
2827 == (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) {
2828 if (MII_REG_BITS_IS_ON(G1000CR_1000 | G1000CR_1000FD, MII_REG_G1000CR, regs))
2829 status |= VELOCITY_AUTONEG_ENABLE;
2830 }
2831 }
2832 2953
2833 return status;
2834} 2954}
2835 2955
2836static u32 check_connection_type(struct mac_regs __iomem *regs) 2956static int velocity_suspend(struct pci_dev *pdev, pm_message_t state)
2837{ 2957{
2838 u32 status = 0; 2958 struct net_device *dev = pci_get_drvdata(pdev);
2839 u8 PHYSR0; 2959 struct velocity_info *vptr = netdev_priv(dev);
2840 u16 ANAR; 2960 unsigned long flags;
2841 PHYSR0 = readb(&regs->PHYSR0);
2842
2843 /*
2844 if (!(PHYSR0 & PHYSR0_LINKGD))
2845 status|=VELOCITY_LINK_FAIL;
2846 */
2847 2961
2848 if (PHYSR0 & PHYSR0_FDPX) 2962 if (!netif_running(vptr->dev))
2849 status |= VELOCITY_DUPLEX_FULL; 2963 return 0;
2850 2964
2851 if (PHYSR0 & PHYSR0_SPDG) 2965 netif_device_detach(vptr->dev);
2852 status |= VELOCITY_SPEED_1000;
2853 else if (PHYSR0 & PHYSR0_SPD10)
2854 status |= VELOCITY_SPEED_10;
2855 else
2856 status |= VELOCITY_SPEED_100;
2857 2966
2858 if (MII_REG_BITS_IS_ON(BMCR_AUTO, MII_REG_BMCR, regs)) { 2967 spin_lock_irqsave(&vptr->lock, flags);
2859 velocity_mii_read(regs, MII_REG_ANAR, &ANAR); 2968 pci_save_state(pdev);
2860 if ((ANAR & (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) 2969#ifdef ETHTOOL_GWOL
2861 == (ANAR_TXFD | ANAR_TX | ANAR_10FD | ANAR_10)) { 2970 if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED) {
2862 if (MII_REG_BITS_IS_ON(G1000CR_1000 | G1000CR_1000FD, MII_REG_G1000CR, regs)) 2971 velocity_get_ip(vptr);
2863 status |= VELOCITY_AUTONEG_ENABLE; 2972 velocity_save_context(vptr, &vptr->context);
2864 } 2973 velocity_shutdown(vptr);
2974 velocity_set_wol(vptr);
2975 pci_enable_wake(pdev, PCI_D3hot, 1);
2976 pci_set_power_state(pdev, PCI_D3hot);
2977 } else {
2978 velocity_save_context(vptr, &vptr->context);
2979 velocity_shutdown(vptr);
2980 pci_disable_device(pdev);
2981 pci_set_power_state(pdev, pci_choose_state(pdev, state));
2865 } 2982 }
2866 2983#else
2867 return status; 2984 pci_set_power_state(pdev, pci_choose_state(pdev, state));
2985#endif
2986 spin_unlock_irqrestore(&vptr->lock, flags);
2987 return 0;
2868} 2988}
2869 2989
2870/** 2990/**
2871 * enable_flow_control_ability - flow control 2991 * velocity_restore_context - restore registers
2872 * @vptr: veloity to configure 2992 * @vptr: velocity
2993 * @context: buffer for stored context
2873 * 2994 *
2874 * Set up flow control according to the flow control options 2995 * Reload the register configuration from the velocity context
2875 * determined by the eeprom/configuration. 2996 * created by velocity_save_context.
2876 */ 2997 */
2877 2998static void velocity_restore_context(struct velocity_info *vptr, struct velocity_context *context)
2878static void enable_flow_control_ability(struct velocity_info *vptr)
2879{ 2999{
2880
2881 struct mac_regs __iomem *regs = vptr->mac_regs; 3000 struct mac_regs __iomem *regs = vptr->mac_regs;
3001 int i;
3002 u8 __iomem *ptr = (u8 __iomem *)regs;
2882 3003
2883 switch (vptr->options.flow_cntl) { 3004 for (i = MAC_REG_PAR; i < MAC_REG_CR0_SET; i += 4)
3005 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
2884 3006
2885 case FLOW_CNTL_DEFAULT: 3007 /* Just skip cr0 */
2886 if (BYTE_REG_BITS_IS_ON(PHYSR0_RXFLC, &regs->PHYSR0)) 3008 for (i = MAC_REG_CR1_SET; i < MAC_REG_CR0_CLR; i++) {
2887 writel(CR0_FDXRFCEN, &regs->CR0Set); 3009 /* Clear */
2888 else 3010 writeb(~(*((u8 *) (context->mac_reg + i))), ptr + i + 4);
2889 writel(CR0_FDXRFCEN, &regs->CR0Clr); 3011 /* Set */
3012 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
3013 }
2890 3014
2891 if (BYTE_REG_BITS_IS_ON(PHYSR0_TXFLC, &regs->PHYSR0)) 3015 for (i = MAC_REG_MAR; i < MAC_REG_IMR; i += 4)
2892 writel(CR0_FDXTFCEN, &regs->CR0Set); 3016 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
2893 else
2894 writel(CR0_FDXTFCEN, &regs->CR0Clr);
2895 break;
2896 3017
2897 case FLOW_CNTL_TX: 3018 for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4)
2898 writel(CR0_FDXTFCEN, &regs->CR0Set); 3019 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
2899 writel(CR0_FDXRFCEN, &regs->CR0Clr);
2900 break;
2901 3020
2902 case FLOW_CNTL_RX: 3021 for (i = MAC_REG_TDCSR_SET; i <= MAC_REG_RDCSR_SET; i++)
2903 writel(CR0_FDXRFCEN, &regs->CR0Set); 3022 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
2904 writel(CR0_FDXTFCEN, &regs->CR0Clr); 3023}
2905 break;
2906 3024
2907 case FLOW_CNTL_TX_RX: 3025static int velocity_resume(struct pci_dev *pdev)
2908 writel(CR0_FDXTFCEN, &regs->CR0Set); 3026{
2909 writel(CR0_FDXRFCEN, &regs->CR0Set); 3027 struct net_device *dev = pci_get_drvdata(pdev);
2910 break; 3028 struct velocity_info *vptr = netdev_priv(dev);
3029 unsigned long flags;
3030 int i;
2911 3031
2912 case FLOW_CNTL_DISABLE: 3032 if (!netif_running(vptr->dev))
2913 writel(CR0_FDXRFCEN, &regs->CR0Clr); 3033 return 0;
2914 writel(CR0_FDXTFCEN, &regs->CR0Clr);
2915 break;
2916 3034
2917 default: 3035 pci_set_power_state(pdev, PCI_D0);
2918 break; 3036 pci_enable_wake(pdev, 0, 0);
3037 pci_restore_state(pdev);
3038
3039 mac_wol_reset(vptr->mac_regs);
3040
3041 spin_lock_irqsave(&vptr->lock, flags);
3042 velocity_restore_context(vptr, &vptr->context);
3043 velocity_init_registers(vptr, VELOCITY_INIT_WOL);
3044 mac_disable_int(vptr->mac_regs);
3045
3046 velocity_tx_srv(vptr, 0);
3047
3048 for (i = 0; i < vptr->tx.numq; i++) {
3049 if (vptr->tx.used[i])
3050 mac_tx_queue_wake(vptr->mac_regs, i);
2919 } 3051 }
2920 3052
3053 mac_enable_int(vptr->mac_regs);
3054 spin_unlock_irqrestore(&vptr->lock, flags);
3055 netif_device_attach(vptr->dev);
3056
3057 return 0;
2921} 3058}
3059#endif
3060
3061/*
3062 * Definition for our device driver. The PCI layer interface
3063 * uses this to handle all our card discover and plugging
3064 */
3065static struct pci_driver velocity_driver = {
3066 .name = VELOCITY_NAME,
3067 .id_table = velocity_id_table,
3068 .probe = velocity_found1,
3069 .remove = __devexit_p(velocity_remove1),
3070#ifdef CONFIG_PM
3071 .suspend = velocity_suspend,
3072 .resume = velocity_resume,
3073#endif
3074};
2922 3075
2923 3076
2924/** 3077/**
@@ -2928,7 +3081,6 @@ static void enable_flow_control_ability(struct velocity_info *vptr)
2928 * Called before an ethtool operation. We need to make sure the 3081 * Called before an ethtool operation. We need to make sure the
2929 * chip is out of D3 state before we poke at it. 3082 * chip is out of D3 state before we poke at it.
2930 */ 3083 */
2931
2932static int velocity_ethtool_up(struct net_device *dev) 3084static int velocity_ethtool_up(struct net_device *dev)
2933{ 3085{
2934 struct velocity_info *vptr = netdev_priv(dev); 3086 struct velocity_info *vptr = netdev_priv(dev);
@@ -2944,7 +3096,6 @@ static int velocity_ethtool_up(struct net_device *dev)
2944 * Called after an ethtool operation. Restore the chip back to D3 3096 * Called after an ethtool operation. Restore the chip back to D3
2945 * state if it isn't running. 3097 * state if it isn't running.
2946 */ 3098 */
2947
2948static void velocity_ethtool_down(struct net_device *dev) 3099static void velocity_ethtool_down(struct net_device *dev)
2949{ 3100{
2950 struct velocity_info *vptr = netdev_priv(dev); 3101 struct velocity_info *vptr = netdev_priv(dev);
@@ -3009,13 +3160,6 @@ static int velocity_set_settings(struct net_device *dev, struct ethtool_cmd *cmd
3009 return ret; 3160 return ret;
3010} 3161}
3011 3162
3012static u32 velocity_get_link(struct net_device *dev)
3013{
3014 struct velocity_info *vptr = netdev_priv(dev);
3015 struct mac_regs __iomem *regs = vptr->mac_regs;
3016 return BYTE_REG_BITS_IS_ON(PHYSR0_LINKGD, &regs->PHYSR0) ? 1 : 0;
3017}
3018
3019static void velocity_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 3163static void velocity_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
3020{ 3164{
3021 struct velocity_info *vptr = netdev_priv(dev); 3165 struct velocity_info *vptr = netdev_priv(dev);
@@ -3094,331 +3238,86 @@ static const struct ethtool_ops velocity_ethtool_ops = {
3094 .complete = velocity_ethtool_down 3238 .complete = velocity_ethtool_down
3095}; 3239};
3096 3240
3097/** 3241#ifdef CONFIG_PM
3098 * velocity_mii_ioctl - MII ioctl handler 3242#ifdef CONFIG_INET
3099 * @dev: network device 3243static int velocity_netdev_event(struct notifier_block *nb, unsigned long notification, void *ptr)
3100 * @ifr: the ifreq block for the ioctl
3101 * @cmd: the command
3102 *
3103 * Process MII requests made via ioctl from the network layer. These
3104 * are used by tools like kudzu to interrogate the link state of the
3105 * hardware
3106 */
3107
3108static int velocity_mii_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
3109{ 3244{
3110 struct velocity_info *vptr = netdev_priv(dev); 3245 struct in_ifaddr *ifa = (struct in_ifaddr *) ptr;
3111 struct mac_regs __iomem *regs = vptr->mac_regs; 3246 struct net_device *dev = ifa->ifa_dev->dev;
3247 struct velocity_info *vptr;
3112 unsigned long flags; 3248 unsigned long flags;
3113 struct mii_ioctl_data *miidata = if_mii(ifr);
3114 int err;
3115 3249
3116 switch (cmd) { 3250 if (dev_net(dev) != &init_net)
3117 case SIOCGMIIPHY: 3251 return NOTIFY_DONE;
3118 miidata->phy_id = readb(&regs->MIIADR) & 0x1f; 3252
3119 break; 3253 spin_lock_irqsave(&velocity_dev_list_lock, flags);
3120 case SIOCGMIIREG: 3254 list_for_each_entry(vptr, &velocity_dev_list, list) {
3121 if (!capable(CAP_NET_ADMIN)) 3255 if (vptr->dev == dev) {
3122 return -EPERM; 3256 velocity_get_ip(vptr);
3123 if (velocity_mii_read(vptr->mac_regs, miidata->reg_num & 0x1f, &(miidata->val_out)) < 0) 3257 break;
3124 return -ETIMEDOUT; 3258 }
3125 break;
3126 case SIOCSMIIREG:
3127 if (!capable(CAP_NET_ADMIN))
3128 return -EPERM;
3129 spin_lock_irqsave(&vptr->lock, flags);
3130 err = velocity_mii_write(vptr->mac_regs, miidata->reg_num & 0x1f, miidata->val_in);
3131 spin_unlock_irqrestore(&vptr->lock, flags);
3132 check_connection_type(vptr->mac_regs);
3133 if (err)
3134 return err;
3135 break;
3136 default:
3137 return -EOPNOTSUPP;
3138 } 3259 }
3139 return 0; 3260 spin_unlock_irqrestore(&velocity_dev_list_lock, flags);
3140}
3141 3261
3142#ifdef CONFIG_PM 3262 return NOTIFY_DONE;
3263}
3264#endif /* CONFIG_INET */
3265#endif /* CONFIG_PM */
3143 3266
3144/** 3267#if defined(CONFIG_PM) && defined(CONFIG_INET)
3145 * velocity_save_context - save registers 3268static struct notifier_block velocity_inetaddr_notifier = {
3146 * @vptr: velocity 3269 .notifier_call = velocity_netdev_event,
3147 * @context: buffer for stored context 3270};
3148 *
3149 * Retrieve the current configuration from the velocity hardware
3150 * and stash it in the context structure, for use by the context
3151 * restore functions. This allows us to save things we need across
3152 * power down states
3153 */
3154 3271
3155static void velocity_save_context(struct velocity_info *vptr, struct velocity_context *context) 3272static void velocity_register_notifier(void)
3156{ 3273{
3157 struct mac_regs __iomem *regs = vptr->mac_regs; 3274 register_inetaddr_notifier(&velocity_inetaddr_notifier);
3158 u16 i;
3159 u8 __iomem *ptr = (u8 __iomem *)regs;
3160
3161 for (i = MAC_REG_PAR; i < MAC_REG_CR0_CLR; i += 4)
3162 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3163
3164 for (i = MAC_REG_MAR; i < MAC_REG_TDCSR_CLR; i += 4)
3165 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3166
3167 for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4)
3168 *((u32 *) (context->mac_reg + i)) = readl(ptr + i);
3169
3170} 3275}
3171 3276
3172/** 3277static void velocity_unregister_notifier(void)
3173 * velocity_restore_context - restore registers
3174 * @vptr: velocity
3175 * @context: buffer for stored context
3176 *
3177 * Reload the register configuration from the velocity context
3178 * created by velocity_save_context.
3179 */
3180
3181static void velocity_restore_context(struct velocity_info *vptr, struct velocity_context *context)
3182{ 3278{
3183 struct mac_regs __iomem *regs = vptr->mac_regs; 3279 unregister_inetaddr_notifier(&velocity_inetaddr_notifier);
3184 int i; 3280}
3185 u8 __iomem *ptr = (u8 __iomem *)regs;
3186
3187 for (i = MAC_REG_PAR; i < MAC_REG_CR0_SET; i += 4)
3188 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3189
3190 /* Just skip cr0 */
3191 for (i = MAC_REG_CR1_SET; i < MAC_REG_CR0_CLR; i++) {
3192 /* Clear */
3193 writeb(~(*((u8 *) (context->mac_reg + i))), ptr + i + 4);
3194 /* Set */
3195 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
3196 }
3197 3281
3198 for (i = MAC_REG_MAR; i < MAC_REG_IMR; i += 4) 3282#else
3199 writel(*((u32 *) (context->mac_reg + i)), ptr + i);
3200 3283
3201 for (i = MAC_REG_RDBASE_LO; i < MAC_REG_FIFO_TEST0; i += 4) 3284#define velocity_register_notifier() do {} while (0)
3202 writel(*((u32 *) (context->mac_reg + i)), ptr + i); 3285#define velocity_unregister_notifier() do {} while (0)
3203 3286
3204 for (i = MAC_REG_TDCSR_SET; i <= MAC_REG_RDCSR_SET; i++) 3287#endif /* defined(CONFIG_PM) && defined(CONFIG_INET) */
3205 writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
3206}
3207 3288
3208/** 3289/**
3209 * wol_calc_crc - WOL CRC 3290 * velocity_init_module - load time function
3210 * @pattern: data pattern
3211 * @mask_pattern: mask
3212 * 3291 *
3213 * Compute the wake on lan crc hashes for the packet header 3292 * Called when the velocity module is loaded. The PCI driver
3214 * we are interested in. 3293 * is registered with the PCI layer, and in turn will call
3294 * the probe functions for each velocity adapter installed
3295 * in the system.
3215 */ 3296 */
3216 3297static int __init velocity_init_module(void)
3217static u16 wol_calc_crc(int size, u8 *pattern, u8 *mask_pattern)
3218{ 3298{
3219 u16 crc = 0xFFFF; 3299 int ret;
3220 u8 mask;
3221 int i, j;
3222
3223 for (i = 0; i < size; i++) {
3224 mask = mask_pattern[i];
3225
3226 /* Skip this loop if the mask equals to zero */
3227 if (mask == 0x00)
3228 continue;
3229 3300
3230 for (j = 0; j < 8; j++) { 3301 velocity_register_notifier();
3231 if ((mask & 0x01) == 0) { 3302 ret = pci_register_driver(&velocity_driver);
3232 mask >>= 1; 3303 if (ret < 0)
3233 continue; 3304 velocity_unregister_notifier();
3234 } 3305 return ret;
3235 mask >>= 1;
3236 crc = crc_ccitt(crc, &(pattern[i * 8 + j]), 1);
3237 }
3238 }
3239 /* Finally, invert the result once to get the correct data */
3240 crc = ~crc;
3241 return bitrev32(crc) >> 16;
3242} 3306}
3243 3307
3244/** 3308/**
3245 * velocity_set_wol - set up for wake on lan 3309 * velocity_cleanup - module unload
3246 * @vptr: velocity to set WOL status on
3247 *
3248 * Set a card up for wake on lan either by unicast or by
3249 * ARP packet.
3250 * 3310 *
3251 * FIXME: check static buffer is safe here 3311 * When the velocity hardware is unloaded this function is called.
3312 * It will clean up the notifiers and the unregister the PCI
3313 * driver interface for this hardware. This in turn cleans up
3314 * all discovered interfaces before returning from the function
3252 */ 3315 */
3253 3316static void __exit velocity_cleanup_module(void)
3254static int velocity_set_wol(struct velocity_info *vptr)
3255{
3256 struct mac_regs __iomem *regs = vptr->mac_regs;
3257 static u8 buf[256];
3258 int i;
3259
3260 static u32 mask_pattern[2][4] = {
3261 {0x00203000, 0x000003C0, 0x00000000, 0x0000000}, /* ARP */
3262 {0xfffff000, 0xffffffff, 0xffffffff, 0x000ffff} /* Magic Packet */
3263 };
3264
3265 writew(0xFFFF, &regs->WOLCRClr);
3266 writeb(WOLCFG_SAB | WOLCFG_SAM, &regs->WOLCFGSet);
3267 writew(WOLCR_MAGIC_EN, &regs->WOLCRSet);
3268
3269 /*
3270 if (vptr->wol_opts & VELOCITY_WOL_PHY)
3271 writew((WOLCR_LINKON_EN|WOLCR_LINKOFF_EN), &regs->WOLCRSet);
3272 */
3273
3274 if (vptr->wol_opts & VELOCITY_WOL_UCAST)
3275 writew(WOLCR_UNICAST_EN, &regs->WOLCRSet);
3276
3277 if (vptr->wol_opts & VELOCITY_WOL_ARP) {
3278 struct arp_packet *arp = (struct arp_packet *) buf;
3279 u16 crc;
3280 memset(buf, 0, sizeof(struct arp_packet) + 7);
3281
3282 for (i = 0; i < 4; i++)
3283 writel(mask_pattern[0][i], &regs->ByteMask[0][i]);
3284
3285 arp->type = htons(ETH_P_ARP);
3286 arp->ar_op = htons(1);
3287
3288 memcpy(arp->ar_tip, vptr->ip_addr, 4);
3289
3290 crc = wol_calc_crc((sizeof(struct arp_packet) + 7) / 8, buf,
3291 (u8 *) & mask_pattern[0][0]);
3292
3293 writew(crc, &regs->PatternCRC[0]);
3294 writew(WOLCR_ARP_EN, &regs->WOLCRSet);
3295 }
3296
3297 BYTE_REG_BITS_ON(PWCFG_WOLTYPE, &regs->PWCFGSet);
3298 BYTE_REG_BITS_ON(PWCFG_LEGACY_WOLEN, &regs->PWCFGSet);
3299
3300 writew(0x0FFF, &regs->WOLSRClr);
3301
3302 if (vptr->mii_status & VELOCITY_AUTONEG_ENABLE) {
3303 if (PHYID_GET_PHY_ID(vptr->phy_id) == PHYID_CICADA_CS8201)
3304 MII_REG_BITS_ON(AUXCR_MDPPS, MII_REG_AUXCR, vptr->mac_regs);
3305
3306 MII_REG_BITS_OFF(G1000CR_1000FD | G1000CR_1000, MII_REG_G1000CR, vptr->mac_regs);
3307 }
3308
3309 if (vptr->mii_status & VELOCITY_SPEED_1000)
3310 MII_REG_BITS_ON(BMCR_REAUTO, MII_REG_BMCR, vptr->mac_regs);
3311
3312 BYTE_REG_BITS_ON(CHIPGCR_FCMODE, &regs->CHIPGCR);
3313
3314 {
3315 u8 GCR;
3316 GCR = readb(&regs->CHIPGCR);
3317 GCR = (GCR & ~CHIPGCR_FCGMII) | CHIPGCR_FCFDX;
3318 writeb(GCR, &regs->CHIPGCR);
3319 }
3320
3321 BYTE_REG_BITS_OFF(ISR_PWEI, &regs->ISR);
3322 /* Turn on SWPTAG just before entering power mode */
3323 BYTE_REG_BITS_ON(STICKHW_SWPTAG, &regs->STICKHW);
3324 /* Go to bed ..... */
3325 BYTE_REG_BITS_ON((STICKHW_DS1 | STICKHW_DS0), &regs->STICKHW);
3326
3327 return 0;
3328}
3329
3330static int velocity_suspend(struct pci_dev *pdev, pm_message_t state)
3331{
3332 struct net_device *dev = pci_get_drvdata(pdev);
3333 struct velocity_info *vptr = netdev_priv(dev);
3334 unsigned long flags;
3335
3336 if (!netif_running(vptr->dev))
3337 return 0;
3338
3339 netif_device_detach(vptr->dev);
3340
3341 spin_lock_irqsave(&vptr->lock, flags);
3342 pci_save_state(pdev);
3343#ifdef ETHTOOL_GWOL
3344 if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED) {
3345 velocity_get_ip(vptr);
3346 velocity_save_context(vptr, &vptr->context);
3347 velocity_shutdown(vptr);
3348 velocity_set_wol(vptr);
3349 pci_enable_wake(pdev, PCI_D3hot, 1);
3350 pci_set_power_state(pdev, PCI_D3hot);
3351 } else {
3352 velocity_save_context(vptr, &vptr->context);
3353 velocity_shutdown(vptr);
3354 pci_disable_device(pdev);
3355 pci_set_power_state(pdev, pci_choose_state(pdev, state));
3356 }
3357#else
3358 pci_set_power_state(pdev, pci_choose_state(pdev, state));
3359#endif
3360 spin_unlock_irqrestore(&vptr->lock, flags);
3361 return 0;
3362}
3363
3364static int velocity_resume(struct pci_dev *pdev)
3365{
3366 struct net_device *dev = pci_get_drvdata(pdev);
3367 struct velocity_info *vptr = netdev_priv(dev);
3368 unsigned long flags;
3369 int i;
3370
3371 if (!netif_running(vptr->dev))
3372 return 0;
3373
3374 pci_set_power_state(pdev, PCI_D0);
3375 pci_enable_wake(pdev, 0, 0);
3376 pci_restore_state(pdev);
3377
3378 mac_wol_reset(vptr->mac_regs);
3379
3380 spin_lock_irqsave(&vptr->lock, flags);
3381 velocity_restore_context(vptr, &vptr->context);
3382 velocity_init_registers(vptr, VELOCITY_INIT_WOL);
3383 mac_disable_int(vptr->mac_regs);
3384
3385 velocity_tx_srv(vptr, 0);
3386
3387 for (i = 0; i < vptr->tx.numq; i++) {
3388 if (vptr->tx.used[i])
3389 mac_tx_queue_wake(vptr->mac_regs, i);
3390 }
3391
3392 mac_enable_int(vptr->mac_regs);
3393 spin_unlock_irqrestore(&vptr->lock, flags);
3394 netif_device_attach(vptr->dev);
3395
3396 return 0;
3397}
3398
3399#ifdef CONFIG_INET
3400
3401static int velocity_netdev_event(struct notifier_block *nb, unsigned long notification, void *ptr)
3402{ 3317{
3403 struct in_ifaddr *ifa = (struct in_ifaddr *) ptr; 3318 velocity_unregister_notifier();
3404 struct net_device *dev = ifa->ifa_dev->dev; 3319 pci_unregister_driver(&velocity_driver);
3405 struct velocity_info *vptr;
3406 unsigned long flags;
3407
3408 if (dev_net(dev) != &init_net)
3409 return NOTIFY_DONE;
3410
3411 spin_lock_irqsave(&velocity_dev_list_lock, flags);
3412 list_for_each_entry(vptr, &velocity_dev_list, list) {
3413 if (vptr->dev == dev) {
3414 velocity_get_ip(vptr);
3415 break;
3416 }
3417 }
3418 spin_unlock_irqrestore(&velocity_dev_list_lock, flags);
3419
3420 return NOTIFY_DONE;
3421} 3320}
3422 3321
3423#endif 3322module_init(velocity_init_module);
3424#endif 3323module_exit(velocity_cleanup_module);
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-24 03:37:46 -0500