2 * Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
4 * This software is licensed under the terms of the GNU General Public
5 * License version 2, as published by the Free Software Foundation, and
6 * may be copied, distributed, and modified under those terms.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 #include <linux/etherdevice.h>
17 #include <asm/byteorder.h>
19 #include <linux/ipv6.h>
20 #include <linux/udp.h>
23 #include "gdm_wimax.h"
26 #include "netlink_k.h"
28 #define gdm_wimax_send(n, d, l) \
29 (n->phy_dev->send_func)(n->phy_dev->priv_dev, d, l, NULL, NULL)
30 #define gdm_wimax_send_with_cb(n, d, l, c, b) \
31 (n->phy_dev->send_func)(n->phy_dev->priv_dev, d, l, c, b)
32 #define gdm_wimax_rcv_with_cb(n, c, b) \
33 (n->phy_dev->rcv_func)(n->phy_dev->priv_dev, c, b)
35 #define EVT_MAX_SIZE 2048
38 struct list_head list;
39 struct net_device *dev;
40 char evt_data[EVT_MAX_SIZE];
44 static void __gdm_wimax_event_send(struct work_struct *work);
45 static inline struct evt_entry *alloc_event_entry(void);
46 static inline void free_event_entry(struct evt_entry *e);
47 static struct evt_entry *get_event_entry(void);
48 static void put_event_entry(struct evt_entry *e);
53 struct list_head evtq;
55 struct list_head freeq;
56 struct work_struct ws;
59 static u8 gdm_wimax_macaddr[6] = {0x00, 0x0a, 0x3b, 0xf0, 0x01, 0x30};
61 static void gdm_wimax_ind_fsm_update(struct net_device *dev, struct fsm_s *fsm);
62 static void gdm_wimax_ind_if_updown(struct net_device *dev, int if_up);
64 static const char *get_protocol_name(u16 protocol)
67 const char *name = "-";
81 sprintf(buf, "0x%04x(%s)", protocol, name);
85 static const char *get_ip_protocol_name(u8 ip_protocol)
88 const char *name = "-";
90 switch (ip_protocol) {
102 sprintf(buf, "%u(%s)", ip_protocol, name);
106 static const char *get_port_name(u16 port)
109 const char *name = "-";
113 name = "DHCP-Server";
116 name = "DHCP-Client";
123 sprintf(buf, "%u(%s)", port, name);
127 static void dump_eth_packet(struct net_device *dev, const char *title,
130 struct iphdr *ih = NULL;
131 struct udphdr *uh = NULL;
136 protocol = (data[12]<<8) | data[13];
137 ih = (struct iphdr *)(data+ETH_HLEN);
139 if (protocol == ETH_P_IP) {
140 uh = (struct udphdr *)((char *)ih + sizeof(struct iphdr));
141 ip_protocol = ih->protocol;
142 port = ntohs(uh->dest);
143 } else if (protocol == ETH_P_IPV6) {
144 struct ipv6hdr *i6h = (struct ipv6hdr *)data;
146 uh = (struct udphdr *)((char *)i6h + sizeof(struct ipv6hdr));
147 ip_protocol = i6h->nexthdr;
148 port = ntohs(uh->dest);
151 netdev_dbg(dev, "[%s] len=%d, %s, %s, %s\n", title, len,
152 get_protocol_name(protocol),
153 get_ip_protocol_name(ip_protocol),
154 get_port_name(port));
156 if (!(data[0] == 0xff && data[1] == 0xff)) {
157 if (protocol == ETH_P_IP)
158 netdev_dbg(dev, " src=%pI4\n", &ih->saddr);
159 else if (protocol == ETH_P_IPV6)
160 netdev_dbg(dev, " src=%pI6\n", &ih->saddr);
163 print_hex_dump_debug("", DUMP_PREFIX_NONE, 16, 1, data, len, false);
166 static inline int gdm_wimax_header(struct sk_buff **pskb)
168 u16 buf[HCI_HEADER_SIZE / sizeof(u16)];
169 struct sk_buff *skb = *pskb;
171 if (unlikely(skb_headroom(skb) < HCI_HEADER_SIZE)) {
172 struct sk_buff *skb2;
174 skb2 = skb_realloc_headroom(skb, HCI_HEADER_SIZE);
178 skb_set_owner_w(skb2, skb->sk);
183 skb_push(skb, HCI_HEADER_SIZE);
184 buf[0] = H2B(WIMAX_TX_SDU);
185 buf[1] = H2B(skb->len - HCI_HEADER_SIZE);
186 memcpy(skb->data, buf, HCI_HEADER_SIZE);
192 static void gdm_wimax_event_rcv(struct net_device *dev, u16 type, void *msg,
195 struct nic *nic = netdev_priv(dev);
198 u16 hci_cmd = (buf[0]<<8) | buf[1];
199 u16 hci_len = (buf[2]<<8) | buf[3];
201 netdev_dbg(dev, "H=>D: 0x%04x(%d)\n", hci_cmd, hci_len);
203 gdm_wimax_send(nic, msg, len);
206 static int gdm_wimax_event_init(void)
208 if (!wm_event.ref_cnt) {
209 wm_event.sock = netlink_init(NETLINK_WIMAX,
210 gdm_wimax_event_rcv);
212 INIT_LIST_HEAD(&wm_event.evtq);
213 INIT_LIST_HEAD(&wm_event.freeq);
214 INIT_WORK(&wm_event.ws, __gdm_wimax_event_send);
215 spin_lock_init(&wm_event.evt_lock);
224 pr_err("Creating WiMax Event netlink is failed\n");
228 static void gdm_wimax_event_exit(void)
230 if (wm_event.sock && --wm_event.ref_cnt == 0) {
231 struct evt_entry *e, *temp;
234 spin_lock_irqsave(&wm_event.evt_lock, flags);
236 list_for_each_entry_safe(e, temp, &wm_event.evtq, list) {
240 list_for_each_entry_safe(e, temp, &wm_event.freeq, list) {
245 spin_unlock_irqrestore(&wm_event.evt_lock, flags);
246 netlink_exit(wm_event.sock);
247 wm_event.sock = NULL;
251 static inline struct evt_entry *alloc_event_entry(void)
253 return kmalloc(sizeof(struct evt_entry), GFP_ATOMIC);
256 static inline void free_event_entry(struct evt_entry *e)
261 static struct evt_entry *get_event_entry(void)
265 if (list_empty(&wm_event.freeq)) {
266 e = alloc_event_entry();
268 e = list_entry(wm_event.freeq.next, struct evt_entry, list);
275 static void put_event_entry(struct evt_entry *e)
279 list_add_tail(&e->list, &wm_event.freeq);
282 static void __gdm_wimax_event_send(struct work_struct *work)
288 spin_lock_irqsave(&wm_event.evt_lock, flags);
290 while (!list_empty(&wm_event.evtq)) {
291 e = list_entry(wm_event.evtq.next, struct evt_entry, list);
292 spin_unlock_irqrestore(&wm_event.evt_lock, flags);
294 sscanf(e->dev->name, "wm%d", &idx);
295 netlink_send(wm_event.sock, idx, 0, e->evt_data, e->size);
297 spin_lock_irqsave(&wm_event.evt_lock, flags);
302 spin_unlock_irqrestore(&wm_event.evt_lock, flags);
305 static int gdm_wimax_event_send(struct net_device *dev, char *buf, int size)
310 u16 hci_cmd = ((u8)buf[0]<<8) | (u8)buf[1];
311 u16 hci_len = ((u8)buf[2]<<8) | (u8)buf[3];
313 netdev_dbg(dev, "D=>H: 0x%04x(%d)\n", hci_cmd, hci_len);
315 spin_lock_irqsave(&wm_event.evt_lock, flags);
317 e = get_event_entry();
319 netdev_err(dev, "%s: No memory for event\n", __func__);
320 spin_unlock_irqrestore(&wm_event.evt_lock, flags);
326 memcpy(e->evt_data, buf, size);
328 list_add_tail(&e->list, &wm_event.evtq);
329 spin_unlock_irqrestore(&wm_event.evt_lock, flags);
331 schedule_work(&wm_event.ws);
336 static void tx_complete(void *arg)
338 struct nic *nic = arg;
340 if (netif_queue_stopped(nic->netdev))
341 netif_wake_queue(nic->netdev);
344 int gdm_wimax_send_tx(struct sk_buff *skb, struct net_device *dev)
347 struct nic *nic = netdev_priv(dev);
349 ret = gdm_wimax_send_with_cb(nic, skb->data, skb->len, tx_complete,
351 if (ret == -ENOSPC) {
352 netif_stop_queue(dev);
357 skb_pull(skb, HCI_HEADER_SIZE);
361 nic->stats.tx_packets++;
362 nic->stats.tx_bytes += skb->len - HCI_HEADER_SIZE;
367 static int gdm_wimax_tx(struct sk_buff *skb, struct net_device *dev)
370 struct nic *nic = netdev_priv(dev);
371 struct fsm_s *fsm = (struct fsm_s *)nic->sdk_data[SIOC_DATA_FSM].buf;
373 dump_eth_packet(dev, "TX", skb->data, skb->len);
375 ret = gdm_wimax_header(&skb);
377 skb_pull(skb, HCI_HEADER_SIZE);
381 #if !defined(LOOPBACK_TEST)
383 netdev_err(dev, "ASSERTION ERROR: fsm is NULL!!\n");
384 } else if (fsm->m_status != M_CONNECTED) {
385 netdev_emerg(dev, "ASSERTION ERROR: Device is NOT ready. status=%d\n",
392 #if defined(CONFIG_WIMAX_GDM72XX_QOS)
393 ret = gdm_qos_send_hci_pkt(skb, dev);
395 ret = gdm_wimax_send_tx(skb, dev);
400 static int gdm_wimax_set_config(struct net_device *dev, struct ifmap *map)
402 if (dev->flags & IFF_UP)
408 static void __gdm_wimax_set_mac_addr(struct net_device *dev, char *mac_addr)
410 u16 hci_pkt_buf[32 / sizeof(u16)];
411 u8 *pkt = (u8 *)&hci_pkt_buf[0];
412 struct nic *nic = netdev_priv(dev);
414 /* Since dev is registered as a ethernet device,
415 * ether_setup has made dev->addr_len to be ETH_ALEN
417 memcpy(dev->dev_addr, mac_addr, dev->addr_len);
419 /* Let lower layer know of this change by sending
420 * SetInformation(MAC Address)
422 hci_pkt_buf[0] = H2B(WIMAX_SET_INFO); /* cmd_evt */
423 hci_pkt_buf[1] = H2B(8); /* size */
426 memcpy(pkt + 6, mac_addr, dev->addr_len); /* V */
428 gdm_wimax_send(nic, pkt, HCI_HEADER_SIZE + 8);
431 /* A driver function */
432 static int gdm_wimax_set_mac_addr(struct net_device *dev, void *p)
434 struct sockaddr *addr = p;
436 if (netif_running(dev))
439 if (!is_valid_ether_addr(addr->sa_data))
440 return -EADDRNOTAVAIL;
442 __gdm_wimax_set_mac_addr(dev, addr->sa_data);
447 static struct net_device_stats *gdm_wimax_stats(struct net_device *dev)
449 struct nic *nic = netdev_priv(dev);
454 static int gdm_wimax_open(struct net_device *dev)
456 struct nic *nic = netdev_priv(dev);
457 struct fsm_s *fsm = (struct fsm_s *)nic->sdk_data[SIOC_DATA_FSM].buf;
459 netif_start_queue(dev);
461 if (fsm && fsm->m_status != M_INIT)
462 gdm_wimax_ind_if_updown(dev, 1);
466 static int gdm_wimax_close(struct net_device *dev)
468 struct nic *nic = netdev_priv(dev);
469 struct fsm_s *fsm = (struct fsm_s *)nic->sdk_data[SIOC_DATA_FSM].buf;
471 netif_stop_queue(dev);
473 if (fsm && fsm->m_status != M_INIT)
474 gdm_wimax_ind_if_updown(dev, 0);
478 static void kdelete(void **buf)
486 static int gdm_wimax_ioctl_get_data(struct data_s *dst, struct data_s *src)
490 size = dst->size < src->size ? dst->size : src->size;
496 if (copy_to_user((void __user *)dst->buf, src->buf, size))
502 static int gdm_wimax_ioctl_set_data(struct data_s *dst, struct data_s *src)
512 if (!(dst->buf && dst->size == src->size)) {
514 dst->buf = kmalloc(src->size, GFP_KERNEL);
515 if (dst->buf == NULL)
519 if (copy_from_user(dst->buf, (void __user *)src->buf, src->size)) {
523 dst->size = src->size;
527 static void gdm_wimax_cleanup_ioctl(struct net_device *dev)
529 struct nic *nic = netdev_priv(dev);
532 for (i = 0; i < SIOC_DATA_MAX; i++)
533 kdelete(&nic->sdk_data[i].buf);
536 static void gdm_update_fsm(struct net_device *dev, struct fsm_s *new_fsm)
538 struct nic *nic = netdev_priv(dev);
539 struct fsm_s *cur_fsm = (struct fsm_s *)
540 nic->sdk_data[SIOC_DATA_FSM].buf;
545 if (cur_fsm->m_status != new_fsm->m_status ||
546 cur_fsm->c_status != new_fsm->c_status) {
547 if (new_fsm->m_status == M_CONNECTED) {
548 netif_carrier_on(dev);
549 } else if (cur_fsm->m_status == M_CONNECTED) {
550 netif_carrier_off(dev);
551 #if defined(CONFIG_WIMAX_GDM72XX_QOS)
552 gdm_qos_release_list(nic);
555 gdm_wimax_ind_fsm_update(dev, new_fsm);
559 static int gdm_wimax_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
561 struct wm_req_s *req = (struct wm_req_s *)ifr;
562 struct nic *nic = netdev_priv(dev);
565 if (cmd != SIOCWMIOCTL)
571 if (req->data_id >= SIOC_DATA_MAX) {
572 netdev_err(dev, "%s error: data-index(%d) is invalid!!\n",
573 __func__, req->data_id);
576 if (req->cmd == SIOCG_DATA) {
577 ret = gdm_wimax_ioctl_get_data(
578 &req->data, &nic->sdk_data[req->data_id]);
581 } else if (req->cmd == SIOCS_DATA) {
582 if (req->data_id == SIOC_DATA_FSM) {
583 /*NOTE: gdm_update_fsm should be called
584 before gdm_wimax_ioctl_set_data is called*/
586 (struct fsm_s *)req->data.buf);
588 ret = gdm_wimax_ioctl_set_data(
589 &nic->sdk_data[req->data_id], &req->data);
595 netdev_err(dev, "%s: %x unknown ioctl\n", __func__, cmd);
602 static void gdm_wimax_prepare_device(struct net_device *dev)
604 struct nic *nic = netdev_priv(dev);
605 u16 buf[32 / sizeof(u16)];
606 struct hci_s *hci = (struct hci_s *)buf;
610 #define BIT_MULTI_CS 0
613 #define BIT_AGGREGATION 3
615 /* GetInformation mac address */
617 hci->cmd_evt = H2B(WIMAX_GET_INFO);
618 hci->data[len++] = TLV_T(T_MAC_ADDRESS);
619 hci->length = H2B(len);
620 gdm_wimax_send(nic, hci, HCI_HEADER_SIZE+len);
622 val = (1<<BIT_WIMAX) | (1<<BIT_MULTI_CS);
623 #if defined(CONFIG_WIMAX_GDM72XX_QOS)
626 #if defined(CONFIG_WIMAX_GDM72XX_WIMAX2)
627 val |= (1<<BIT_AGGREGATION);
632 hci->cmd_evt = H2B(WIMAX_SET_INFO);
633 hci->data[len++] = TLV_T(T_CAPABILITY);
634 hci->data[len++] = TLV_L(T_CAPABILITY);
636 memcpy(&hci->data[len], &val, TLV_L(T_CAPABILITY));
637 len += TLV_L(T_CAPABILITY);
638 hci->length = H2B(len);
639 gdm_wimax_send(nic, hci, HCI_HEADER_SIZE+len);
641 netdev_info(dev, "GDM WiMax Set CAPABILITY: 0x%08X\n", DB2H(val));
644 static int gdm_wimax_hci_get_tlv(u8 *buf, u8 *T, u16 *L, u8 **V)
646 #define __U82U16(b) ((u16)((u8 *)(b))[0] | ((u16)((u8 *)(b))[1] << 8))
650 if (buf[1] == 0x82) {
651 *L = B2H(__U82U16(&buf[2]));
652 next_pos = 1/*type*/+3/*len*/;
655 next_pos = 1/*type*/+1/*len*/;
659 next_pos += *L/*length of val*/;
663 static int gdm_wimax_get_prepared_info(struct net_device *dev, char *buf,
668 u16 cmd_evt, cmd_len;
669 int pos = HCI_HEADER_SIZE;
671 cmd_evt = B2H(*(u16 *)&buf[0]);
672 cmd_len = B2H(*(u16 *)&buf[2]);
674 if (len < cmd_len + HCI_HEADER_SIZE) {
675 netdev_err(dev, "%s: invalid length [%d/%d]\n", __func__,
676 cmd_len + HCI_HEADER_SIZE, len);
680 if (cmd_evt == WIMAX_GET_INFO_RESULT) {
682 netdev_err(dev, "%s: len is too short [%x/%d]\n",
683 __func__, cmd_evt, len);
687 pos += gdm_wimax_hci_get_tlv(&buf[pos], &T, &L, &V);
688 if (T == TLV_T(T_MAC_ADDRESS)) {
689 if (L != dev->addr_len) {
691 "%s Invalid inofrmation result T/L [%x/%d]\n",
695 netdev_info(dev, "MAC change [%pM]->[%pM]\n",
697 memcpy(dev->dev_addr, V, dev->addr_len);
702 gdm_wimax_event_send(dev, buf, len);
706 static void gdm_wimax_netif_rx(struct net_device *dev, char *buf, int len)
708 struct nic *nic = netdev_priv(dev);
712 dump_eth_packet(dev, "RX", buf, len);
714 skb = dev_alloc_skb(len + 2);
716 netdev_err(dev, "%s: dev_alloc_skb failed!\n", __func__);
721 nic->stats.rx_packets++;
722 nic->stats.rx_bytes += len;
724 memcpy(skb_put(skb, len), buf, len);
727 skb->protocol = eth_type_trans(skb, dev); /* what will happen? */
729 ret = in_interrupt() ? netif_rx(skb) : netif_rx_ni(skb);
730 if (ret == NET_RX_DROP)
731 netdev_err(dev, "%s skb dropped\n", __func__);
734 static void gdm_wimax_transmit_aggr_pkt(struct net_device *dev, char *buf,
737 #define HCI_PADDING_BYTE 4
738 #define HCI_RESERVED_BYTE 4
743 hci = (struct hci_s *)buf;
745 if (B2H(hci->cmd_evt) != WIMAX_RX_SDU) {
746 netdev_err(dev, "Wrong cmd_evt(0x%04X)\n",
751 length = B2H(hci->length);
752 gdm_wimax_netif_rx(dev, hci->data, length);
755 /* Add padding size */
756 length += HCI_PADDING_BYTE - (length & 0x3);
759 length += HCI_HEADER_SIZE + HCI_RESERVED_BYTE;
765 static void gdm_wimax_transmit_pkt(struct net_device *dev, char *buf, int len)
767 #if defined(CONFIG_WIMAX_GDM72XX_QOS)
768 struct nic *nic = netdev_priv(dev);
770 u16 cmd_evt, cmd_len;
772 /* This code is added for certain rx packet to be ignored. */
776 cmd_evt = B2H(*(u16 *)&buf[0]);
777 cmd_len = B2H(*(u16 *)&buf[2]);
779 if (len < cmd_len + HCI_HEADER_SIZE) {
781 netdev_err(dev, "%s: invalid length [%d/%d]\n",
782 __func__, cmd_len + HCI_HEADER_SIZE, len);
787 case WIMAX_RX_SDU_AGGR:
788 gdm_wimax_transmit_aggr_pkt(dev, &buf[HCI_HEADER_SIZE],
792 gdm_wimax_netif_rx(dev, &buf[HCI_HEADER_SIZE], cmd_len);
794 #if defined(CONFIG_WIMAX_GDM72XX_QOS)
795 case WIMAX_EVT_MODEM_REPORT:
796 gdm_recv_qos_hci_packet(nic, buf, len);
799 case WIMAX_SDU_TX_FLOW:
801 if (!netif_queue_stopped(dev))
802 netif_stop_queue(dev);
803 } else if (buf[4] == 1) {
804 if (netif_queue_stopped(dev))
805 netif_wake_queue(dev);
809 gdm_wimax_event_send(dev, buf, len);
814 static void gdm_wimax_ind_fsm_update(struct net_device *dev, struct fsm_s *fsm)
816 u16 buf[32 / sizeof(u16)];
817 u8 *hci_pkt_buf = (u8 *)&buf[0];
819 /* Indicate updating fsm */
820 buf[0] = H2B(WIMAX_FSM_UPDATE);
821 buf[1] = H2B(sizeof(struct fsm_s));
822 memcpy(&hci_pkt_buf[HCI_HEADER_SIZE], fsm, sizeof(struct fsm_s));
824 gdm_wimax_event_send(dev, hci_pkt_buf,
825 HCI_HEADER_SIZE + sizeof(struct fsm_s));
828 static void gdm_wimax_ind_if_updown(struct net_device *dev, int if_up)
830 u16 buf[32 / sizeof(u16)];
831 struct hci_s *hci = (struct hci_s *)buf;
832 unsigned char up_down;
834 up_down = if_up ? WIMAX_IF_UP : WIMAX_IF_DOWN;
836 /* Indicate updating fsm */
837 hci->cmd_evt = H2B(WIMAX_IF_UPDOWN);
838 hci->length = H2B(sizeof(up_down));
839 hci->data[0] = up_down;
841 gdm_wimax_event_send(dev, (char *)hci, HCI_HEADER_SIZE+sizeof(up_down));
844 static void rx_complete(void *arg, void *data, int len)
846 struct nic *nic = arg;
848 gdm_wimax_transmit_pkt(nic->netdev, data, len);
849 gdm_wimax_rcv_with_cb(nic, rx_complete, nic);
852 static void prepare_rx_complete(void *arg, void *data, int len)
854 struct nic *nic = arg;
857 ret = gdm_wimax_get_prepared_info(nic->netdev, data, len);
859 gdm_wimax_rcv_with_cb(nic, rx_complete, nic);
862 netdev_err(nic->netdev,
863 "get_prepared_info failed(%d)\n", ret);
864 gdm_wimax_rcv_with_cb(nic, prepare_rx_complete, nic);
868 static void start_rx_proc(struct nic *nic)
870 gdm_wimax_rcv_with_cb(nic, prepare_rx_complete, nic);
873 static struct net_device_ops gdm_netdev_ops = {
874 .ndo_open = gdm_wimax_open,
875 .ndo_stop = gdm_wimax_close,
876 .ndo_set_config = gdm_wimax_set_config,
877 .ndo_start_xmit = gdm_wimax_tx,
878 .ndo_get_stats = gdm_wimax_stats,
879 .ndo_set_mac_address = gdm_wimax_set_mac_addr,
880 .ndo_do_ioctl = gdm_wimax_ioctl,
883 int register_wimax_device(struct phy_dev *phy_dev, struct device *pdev)
885 struct nic *nic = NULL;
886 struct net_device *dev;
889 dev = alloc_netdev(sizeof(*nic), "wm%d", ether_setup);
892 pr_err("alloc_etherdev failed\n");
896 SET_NETDEV_DEV(dev, pdev);
898 dev->netdev_ops = &gdm_netdev_ops;
899 dev->flags &= ~IFF_MULTICAST;
900 memcpy(dev->dev_addr, gdm_wimax_macaddr, sizeof(gdm_wimax_macaddr));
902 nic = netdev_priv(dev);
903 memset(nic, 0, sizeof(*nic));
906 nic->phy_dev = phy_dev;
907 phy_dev->netdev = dev;
909 /* event socket init */
910 ret = gdm_wimax_event_init();
912 pr_err("Cannot create event.\n");
916 ret = register_netdev(dev);
920 #if defined(LOOPBACK_TEST)
921 netif_start_queue(dev);
922 netif_carrier_on(dev);
924 netif_carrier_off(dev);
927 #ifdef CONFIG_WIMAX_GDM72XX_QOS
933 /* Prepare WiMax device */
934 gdm_wimax_prepare_device(dev);
939 pr_err("register_netdev failed\n");
944 void unregister_wimax_device(struct phy_dev *phy_dev)
946 struct nic *nic = netdev_priv(phy_dev->netdev);
947 struct fsm_s *fsm = (struct fsm_s *)nic->sdk_data[SIOC_DATA_FSM].buf;
950 fsm->m_status = M_INIT;
951 unregister_netdev(nic->netdev);
953 gdm_wimax_event_exit();
955 #if defined(CONFIG_WIMAX_GDM72XX_QOS)
956 gdm_qos_release_list(nic);
959 gdm_wimax_cleanup_ioctl(phy_dev->netdev);
961 free_netdev(nic->netdev);