Lines Matching refs:pegasus
19 #include "pegasus.h"
27 static const char driver_name[] = "pegasus";
43 #include "pegasus.h"
55 * IDs as the Belkin F5D5050, so we need to teach the pegasus driver to
57 * case anyway, seeing as the pegasus is for "Wired" adaptors.
62 #include "pegasus.h"
100 static int get_registers(pegasus_t *pegasus, __u16 indx, __u16 size, void *data)
102 return usb_control_msg_recv(pegasus->usb, 0, PEGASUS_REQ_GET_REGS,
107 static int set_registers(pegasus_t *pegasus, __u16 indx, __u16 size,
112 ret = usb_control_msg_send(pegasus->usb, 0, PEGASUS_REQ_SET_REGS,
116 netif_dbg(pegasus, drv, pegasus->net, "%s failed with %d\n", __func__, ret);
126 static int set_register(pegasus_t *pegasus, __u16 indx, __u8 data)
131 ret = usb_control_msg_send(pegasus->usb, 0, PEGASUS_REQ_SET_REG,
135 netif_dbg(pegasus, drv, pegasus->net, "%s failed with %d\n", __func__, ret);
140 static int update_eth_regs_async(pegasus_t *pegasus)
161 usb_fill_control_urb(async_urb, pegasus->usb,
162 usb_sndctrlpipe(pegasus->usb, 0), (void *)req,
163 pegasus->eth_regs, 3, async_ctrl_callback, req);
168 netif_device_detach(pegasus->net);
169 netif_err(pegasus, drv, pegasus->net,
212 static int read_mii_word(pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 *regd)
214 return __mii_op(pegasus, phy, indx, regd, PHY_READ);
218 static int write_mii_word(pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 *regd)
220 return __mii_op(pegasus, phy, indx, regd, PHY_WRITE);
225 pegasus_t *pegasus = netdev_priv(dev);
229 ret = read_mii_word(pegasus, phy_id, loc, &res);
238 pegasus_t *pegasus = netdev_priv(dev);
241 write_mii_word(pegasus, phy_id, loc, &data);
244 static int read_eprom_word(pegasus_t *pegasus, __u8 index, __u16 *retdata)
250 set_register(pegasus, EpromCtrl, 0);
251 set_register(pegasus, EpromOffset, index);
252 set_register(pegasus, EpromCtrl, EPROM_READ);
255 ret = get_registers(pegasus, EpromCtrl, 1, &tmp);
266 ret = get_registers(pegasus, EpromData, 2, &retdatai);
273 netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
278 static inline void enable_eprom_write(pegasus_t *pegasus)
282 get_registers(pegasus, EthCtrl2, 1, &tmp);
283 set_register(pegasus, EthCtrl2, tmp | EPROM_WR_ENABLE);
286 static inline void disable_eprom_write(pegasus_t *pegasus)
290 get_registers(pegasus, EthCtrl2, 1, &tmp);
291 set_register(pegasus, EpromCtrl, 0);
292 set_register(pegasus, EthCtrl2, tmp & ~EPROM_WR_ENABLE);
295 static int write_eprom_word(pegasus_t *pegasus, __u8 index, __u16 data)
302 set_registers(pegasus, EpromOffset, 4, d);
303 enable_eprom_write(pegasus);
304 set_register(pegasus, EpromOffset, index);
305 set_registers(pegasus, EpromData, 2, &le_data);
306 set_register(pegasus, EpromCtrl, EPROM_WRITE);
309 ret = get_registers(pegasus, EpromCtrl, 1, &tmp);
315 disable_eprom_write(pegasus);
322 netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
327 static inline int get_node_id(pegasus_t *pegasus, u8 *id)
333 ret = read_eprom_word(pegasus, i, &w16);
342 static void set_ethernet_addr(pegasus_t *pegasus)
347 if (pegasus->features & PEGASUS_II) {
348 ret = get_registers(pegasus, 0x10, sizeof(node_id), node_id);
352 ret = get_node_id(pegasus, node_id);
355 ret = set_registers(pegasus, EthID, sizeof(node_id), node_id);
360 eth_hw_addr_set(pegasus->net, node_id);
364 eth_hw_addr_random(pegasus->net);
365 netif_dbg(pegasus, drv, pegasus->net, "software assigned MAC address.\n");
370 static inline int reset_mac(pegasus_t *pegasus)
375 set_register(pegasus, EthCtrl1, data);
377 ret = get_registers(pegasus, EthCtrl1, 1, &data);
383 if (mii_mode && (pegasus->features & HAS_HOME_PNA))
384 set_register(pegasus, Gpio1, 0x34);
386 set_register(pegasus, Gpio1, 0x26);
387 set_register(pegasus, Gpio0, pegasus->features);
388 set_register(pegasus, Gpio0, DEFAULT_GPIO_SET);
395 if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
396 usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
397 set_register(pegasus, Gpio0, 0x24);
398 set_register(pegasus, Gpio0, 0x26);
400 if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_ELCON) {
402 ret = read_mii_word(pegasus, 3, 0x1b, &auxmode);
406 write_mii_word(pegasus, 3, 0x1b, &auxmode);
411 netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
417 pegasus_t *pegasus = netdev_priv(dev);
422 ret = read_mii_word(pegasus, pegasus->phy, MII_LPA, &linkpart);
435 memcpy(pegasus->eth_regs, data, sizeof(data));
436 ret = set_registers(pegasus, EthCtrl0, 3, data);
438 if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
439 usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS2 ||
440 usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
442 ret = read_mii_word(pegasus, 0, 0x1b, &auxmode);
446 write_mii_word(pegasus, 0, 0x1b, &auxmode);
451 netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
457 pegasus_t *pegasus = urb->context;
464 if (!pegasus)
467 net = pegasus->net;
475 netif_dbg(pegasus, rx_err, net, "reset MAC\n");
476 pegasus->flags &= ~PEGASUS_RX_BUSY;
480 netif_warn(pegasus, rx_err, net, "no rx stall recovery\n");
485 netif_dbg(pegasus, ifdown, net, "rx unlink, %d\n", status);
488 netif_dbg(pegasus, rx_err, net, "RX status %d\n", status);
497 netif_dbg(pegasus, rx_err, net,
508 if (pegasus->chip == 0x8513) {
511 pegasus->rx_skb->data += 2;
527 * at this point we are sure pegasus->rx_skb != NULL
530 skb_put(pegasus->rx_skb, pkt_len);
531 pegasus->rx_skb->protocol = eth_type_trans(pegasus->rx_skb, net);
532 netif_rx(pegasus->rx_skb);
536 if (pegasus->flags & PEGASUS_UNPLUG)
539 pegasus->rx_skb = __netdev_alloc_skb_ip_align(pegasus->net, PEGASUS_MTU,
542 if (pegasus->rx_skb == NULL)
545 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
546 usb_rcvbulkpipe(pegasus->usb, 1),
547 pegasus->rx_skb->data, PEGASUS_MTU,
548 read_bulk_callback, pegasus);
549 rx_status = usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC);
551 netif_device_detach(pegasus->net);
553 pegasus->flags |= PEGASUS_RX_URB_FAIL;
556 pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
562 tasklet_schedule(&pegasus->rx_tl);
567 pegasus_t *pegasus = from_tasklet(pegasus, t, rx_tl);
570 if (pegasus->flags & PEGASUS_UNPLUG)
573 if (pegasus->flags & PEGASUS_RX_URB_FAIL)
574 if (pegasus->rx_skb)
576 if (pegasus->rx_skb == NULL)
577 pegasus->rx_skb = __netdev_alloc_skb_ip_align(pegasus->net,
580 if (pegasus->rx_skb == NULL) {
581 netif_warn(pegasus, rx_err, pegasus->net, "low on memory\n");
582 tasklet_schedule(&pegasus->rx_tl);
585 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
586 usb_rcvbulkpipe(pegasus->usb, 1),
587 pegasus->rx_skb->data, PEGASUS_MTU,
588 read_bulk_callback, pegasus);
590 status = usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC);
592 netif_device_detach(pegasus->net);
594 pegasus->flags |= PEGASUS_RX_URB_FAIL;
595 tasklet_schedule(&pegasus->rx_tl);
597 pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
603 pegasus_t *pegasus = urb->context;
607 if (!pegasus)
610 net = pegasus->net;
619 netif_warn(pegasus, tx_err, net, "no tx stall recovery\n");
624 netif_dbg(pegasus, ifdown, net, "tx unlink, %d\n", status);
627 netif_info(pegasus, tx_err, net, "TX status %d\n", status);
639 pegasus_t *pegasus = urb->context;
643 if (!pegasus)
645 net = pegasus->net;
658 netif_dbg(pegasus, timer, net, "intr status %d\n", status);
687 netif_device_detach(pegasus->net);
689 netif_err(pegasus, timer, net,
695 pegasus_t *pegasus = netdev_priv(net);
696 netif_warn(pegasus, timer, net, "tx timeout\n");
697 usb_unlink_urb(pegasus->tx_urb);
704 pegasus_t *pegasus = netdev_priv(net);
711 ((__le16 *) pegasus->tx_buff)[0] = cpu_to_le16(l16);
712 skb_copy_from_linear_data(skb, pegasus->tx_buff + 2, skb->len);
713 usb_fill_bulk_urb(pegasus->tx_urb, pegasus->usb,
714 usb_sndbulkpipe(pegasus->usb, 2),
715 pegasus->tx_buff, count,
716 write_bulk_callback, pegasus);
717 if ((res = usb_submit_urb(pegasus->tx_urb, GFP_ATOMIC))) {
718 netif_warn(pegasus, tx_err, net, "fail tx, %d\n", res);
725 netif_device_detach(pegasus->net);
740 static inline void disable_net_traffic(pegasus_t *pegasus)
744 set_registers(pegasus, EthCtrl0, sizeof(tmp), &tmp);
747 static inline int get_interrupt_interval(pegasus_t *pegasus)
753 ret = read_eprom_word(pegasus, 4, &data);
758 if (pegasus->usb->speed != USB_SPEED_HIGH) {
760 netif_info(pegasus, timer, pegasus->net,
766 write_eprom_word(pegasus, 4, data);
770 pegasus->intr_interval = interval;
777 pegasus_t *pegasus = netdev_priv(net);
780 if (read_mii_word(pegasus, pegasus->phy, MII_BMSR, &tmp))
789 static void free_all_urbs(pegasus_t *pegasus)
791 usb_free_urb(pegasus->intr_urb);
792 usb_free_urb(pegasus->tx_urb);
793 usb_free_urb(pegasus->rx_urb);
796 static void unlink_all_urbs(pegasus_t *pegasus)
798 usb_kill_urb(pegasus->intr_urb);
799 usb_kill_urb(pegasus->tx_urb);
800 usb_kill_urb(pegasus->rx_urb);
803 static int alloc_urbs(pegasus_t *pegasus)
807 pegasus->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
808 if (!pegasus->rx_urb) {
811 pegasus->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
812 if (!pegasus->tx_urb) {
813 usb_free_urb(pegasus->rx_urb);
816 pegasus->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
817 if (!pegasus->intr_urb) {
818 usb_free_urb(pegasus->tx_urb);
819 usb_free_urb(pegasus->rx_urb);
828 pegasus_t *pegasus = netdev_priv(net);
831 if (pegasus->rx_skb == NULL)
832 pegasus->rx_skb = __netdev_alloc_skb_ip_align(pegasus->net,
835 if (!pegasus->rx_skb)
838 set_registers(pegasus, EthID, 6, net->dev_addr);
840 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
841 usb_rcvbulkpipe(pegasus->usb, 1),
842 pegasus->rx_skb->data, PEGASUS_MTU,
843 read_bulk_callback, pegasus);
844 if ((res = usb_submit_urb(pegasus->rx_urb, GFP_KERNEL))) {
846 netif_device_detach(pegasus->net);
847 netif_dbg(pegasus, ifup, net, "failed rx_urb, %d\n", res);
851 usb_fill_int_urb(pegasus->intr_urb, pegasus->usb,
852 usb_rcvintpipe(pegasus->usb, 3),
853 pegasus->intr_buff, sizeof(pegasus->intr_buff),
854 intr_callback, pegasus, pegasus->intr_interval);
855 if ((res = usb_submit_urb(pegasus->intr_urb, GFP_KERNEL))) {
857 netif_device_detach(pegasus->net);
858 netif_dbg(pegasus, ifup, net, "failed intr_urb, %d\n", res);
859 usb_kill_urb(pegasus->rx_urb);
862 res = enable_net_traffic(net, pegasus->usb);
864 netif_dbg(pegasus, ifup, net,
867 usb_kill_urb(pegasus->rx_urb);
868 usb_kill_urb(pegasus->intr_urb);
873 netif_dbg(pegasus, ifup, net, "open\n");
881 pegasus_t *pegasus = netdev_priv(net);
884 if (!(pegasus->flags & PEGASUS_UNPLUG))
885 disable_net_traffic(pegasus);
886 tasklet_kill(&pegasus->rx_tl);
887 unlink_all_urbs(pegasus);
895 pegasus_t *pegasus = netdev_priv(dev);
898 usb_make_path(pegasus->usb, info->bus_info, sizeof(info->bus_info));
907 pegasus_t *pegasus = netdev_priv(dev);
910 wol->wolopts = pegasus->wolopts;
916 pegasus_t *pegasus = netdev_priv(dev);
929 pegasus->eth_regs[0] |= 0x10;
931 pegasus->eth_regs[0] &= ~0x10;
932 pegasus->wolopts = wol->wolopts;
934 ret = set_register(pegasus, WakeupControl, reg78);
936 ret = device_set_wakeup_enable(&pegasus->usb->dev,
953 pegasus_t *pegasus;
955 pegasus = netdev_priv(dev);
956 mii_ethtool_get_link_ksettings(&pegasus->mii, ecmd);
964 pegasus_t *pegasus = netdev_priv(dev);
965 return mii_ethtool_set_link_ksettings(&pegasus->mii, ecmd);
970 pegasus_t *pegasus = netdev_priv(dev);
971 return mii_nway_restart(&pegasus->mii);
976 pegasus_t *pegasus = netdev_priv(dev);
977 return mii_link_ok(&pegasus->mii);
982 pegasus_t *pegasus = netdev_priv(dev);
983 return pegasus->msg_enable;
988 pegasus_t *pegasus = netdev_priv(dev);
989 pegasus->msg_enable = v;
1008 pegasus_t *pegasus = netdev_priv(net);
1013 data[0] = pegasus->phy;
1016 res = read_mii_word(pegasus, data[0], data[1] & 0x1f, &data[3]);
1021 write_mii_word(pegasus, pegasus->phy, data[1] & 0x1f, &data[2]);
1032 pegasus_t *pegasus = netdev_priv(net);
1035 pegasus->eth_regs[EthCtrl2] |= RX_PROMISCUOUS;
1036 netif_info(pegasus, link, net, "Promiscuous mode enabled\n");
1038 pegasus->eth_regs[EthCtrl0] |= RX_MULTICAST;
1039 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
1040 netif_dbg(pegasus, link, net, "set allmulti\n");
1042 pegasus->eth_regs[EthCtrl0] &= ~RX_MULTICAST;
1043 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
1045 update_eth_regs_async(pegasus);
1048 static __u8 mii_phy_probe(pegasus_t *pegasus)
1054 ret = read_mii_word(pegasus, i, MII_BMSR, &tmp);
1066 static inline void setup_pegasus_II(pegasus_t *pegasus)
1071 set_register(pegasus, Reg1d, 0);
1072 set_register(pegasus, Reg7b, 1);
1074 if ((pegasus->features & HAS_HOME_PNA) && mii_mode)
1075 set_register(pegasus, Reg7b, 0);
1077 set_register(pegasus, Reg7b, 2);
1079 set_register(pegasus, 0x83, data);
1080 ret = get_registers(pegasus, 0x83, 1, &data);
1085 pegasus->chip = 0x8513;
1087 pegasus->chip = 0;
1089 set_register(pegasus, 0x80, 0xc0);
1090 set_register(pegasus, 0x83, 0xff);
1091 set_register(pegasus, 0x84, 0x01);
1093 if (pegasus->features & HAS_HOME_PNA && mii_mode)
1094 set_register(pegasus, Reg81, 6);
1096 set_register(pegasus, Reg81, 2);
1100 netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
1105 pegasus_t *pegasus = container_of(work, pegasus_t, carrier_check.work);
1106 set_carrier(pegasus->net);
1107 if (!(pegasus->flags & PEGASUS_UNPLUG)) {
1108 queue_delayed_work(system_long_wq, &pegasus->carrier_check,
1134 pegasus_t *pegasus;
1141 net = alloc_etherdev(sizeof(struct pegasus));
1145 pegasus = netdev_priv(net);
1146 pegasus->dev_index = dev_index;
1148 res = alloc_urbs(pegasus);
1154 tasklet_setup(&pegasus->rx_tl, rx_fixup);
1156 INIT_DELAYED_WORK(&pegasus->carrier_check, check_carrier);
1158 pegasus->intf = intf;
1159 pegasus->usb = dev;
1160 pegasus->net = net;
1166 pegasus->mii.dev = net;
1167 pegasus->mii.mdio_read = mdio_read;
1168 pegasus->mii.mdio_write = mdio_write;
1169 pegasus->mii.phy_id_mask = 0x1f;
1170 pegasus->mii.reg_num_mask = 0x1f;
1171 pegasus->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
1174 pegasus->features = usb_dev_id[dev_index].private;
1175 res = get_interrupt_interval(pegasus);
1178 if (reset_mac(pegasus)) {
1183 set_ethernet_addr(pegasus);
1184 if (pegasus->features & PEGASUS_II) {
1186 setup_pegasus_II(pegasus);
1188 pegasus->phy = mii_phy_probe(pegasus);
1189 if (pegasus->phy == 0xff) {
1191 pegasus->phy = 1;
1193 pegasus->mii.phy_id = pegasus->phy;
1194 usb_set_intfdata(intf, pegasus);
1200 queue_delayed_work(system_long_wq, &pegasus->carrier_check,
1209 free_all_urbs(pegasus);
1218 struct pegasus *pegasus = usb_get_intfdata(intf);
1221 if (!pegasus) {
1226 pegasus->flags |= PEGASUS_UNPLUG;
1227 cancel_delayed_work_sync(&pegasus->carrier_check);
1228 unregister_netdev(pegasus->net);
1229 unlink_all_urbs(pegasus);
1230 free_all_urbs(pegasus);
1231 if (pegasus->rx_skb != NULL) {
1232 dev_kfree_skb(pegasus->rx_skb);
1233 pegasus->rx_skb = NULL;
1235 free_netdev(pegasus->net);
1240 struct pegasus *pegasus = usb_get_intfdata(intf);
1242 netif_device_detach(pegasus->net);
1243 cancel_delayed_work_sync(&pegasus->carrier_check);
1244 if (netif_running(pegasus->net)) {
1245 usb_kill_urb(pegasus->rx_urb);
1246 usb_kill_urb(pegasus->intr_urb);
1253 struct pegasus *pegasus = usb_get_intfdata(intf);
1255 netif_device_attach(pegasus->net);
1256 if (netif_running(pegasus->net)) {
1257 pegasus->rx_urb->status = 0;
1258 pegasus->rx_urb->actual_length = 0;
1259 read_bulk_callback(pegasus->rx_urb);
1261 pegasus->intr_urb->status = 0;
1262 pegasus->intr_urb->actual_length = 0;
1263 intr_callback(pegasus->intr_urb);
1265 queue_delayed_work(system_long_wq, &pegasus->carrier_check,