mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-08-27 19:29:37 +00:00
Code Issues Releases Wiki Activity

Staging: gdm72xx: Remove gdm72xx driver

Browse source 
Remove support for gdm72xx driver from the kernel since Wimax is dead.
[1] http://www.networkworld.com/article/2220370/4g/wimax-is-dead.html
[2] http://www.androidcentral.com/sprint-confirms-wimax-shutdown-november-6-2015

Chrome OS can distribute this driver alongside their library.

Signed-off-by: Shraddha Barke <shraddha.6596@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Shraddha Barke 2016-03-06 00:55:31 +05:30 committed by Greg Kroah-Hartman
parent e0a2d503a9
commit 3765dc92cb
22 changed files with 0 additions and 4214 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
drivers/staging/Kconfig
View file

@ -72,8 +72,6 @@ source "drivers/staging/android/Kconfig"
source "drivers/staging/board/Kconfig"
source "drivers/staging/gdm72xx/Kconfig"
source "drivers/staging/gdm724x/Kconfig"
source "drivers/staging/fwserial/Kconfig"

1
drivers/staging/Makefile
View file

@ -26,7 +26,6 @@ obj-$(CONFIG_MFD_NVEC) += nvec/
obj-$(CONFIG_STAGING_RDMA) += rdma/
obj-$(CONFIG_ANDROID) += android/
obj-$(CONFIG_STAGING_BOARD) += board/
obj-$(CONFIG_WIMAX_GDM72XX) += gdm72xx/
obj-$(CONFIG_LTE_GDM724X) += gdm724x/
obj-$(CONFIG_FIREWIRE_SERIAL) += fwserial/
obj-$(CONFIG_GOLDFISH) += goldfish/

63
drivers/staging/gdm72xx/Kconfig
View file

@ -1,63 +0,0 @@
#
# GCT GDM72xx WiMAX driver configuration
#
menuconfig WIMAX_GDM72XX
tristate "GCT GDM72xx WiMAX support"
depends on NET && (USB || MMC)
help
Support a WiMAX module based on the GCT GDM72xx WiMAX chip.
if WIMAX_GDM72XX
config WIMAX_GDM72XX_QOS
bool "Enable QoS support"
default n
help
Enable Quality of Service support based on the data protocol of
transmitting packets.
config WIMAX_GDM72XX_K_MODE
bool "Enable K mode"
default n
help
Enable support for proprietary functions for KT (Korea Telecom).
config WIMAX_GDM72XX_WIMAX2
bool "Enable WiMAX2 support"
default n
help
Enable support for transmitting multiple packets (packet
aggregation) from the WiMAX module to the host processor.
choice
prompt "Select interface"
config WIMAX_GDM72XX_USB
bool "USB interface"
depends on (USB = y || USB = WIMAX_GDM72XX)
help
Select this option if the WiMAX module interfaces with the host
processor via USB.
config WIMAX_GDM72XX_SDIO
bool "SDIO interface"
depends on (MMC = y || MMC = WIMAX_GDM72XX)
help
Select this option if the WiMAX module interfaces with the host
processor via SDIO.
endchoice
if WIMAX_GDM72XX_USB
config WIMAX_GDM72XX_USB_PM
bool "Enable power management support"
depends on PM
help
Enable USB power management in order to reduce power consumption
while the interface is not in use.
endif # WIMAX_GDM72XX_USB
endif # WIMAX_GDM72XX

6
drivers/staging/gdm72xx/Makefile
View file

@ -1,6 +0,0 @@
obj-$(CONFIG_WIMAX_GDM72XX) := gdmwm.o
gdmwm-y += gdm_wimax.o netlink_k.o
gdmwm-$(CONFIG_WIMAX_GDM72XX_QOS) += gdm_qos.o
gdmwm-$(CONFIG_WIMAX_GDM72XX_SDIO) += gdm_sdio.o sdio_boot.o
gdmwm-$(CONFIG_WIMAX_GDM72XX_USB) += gdm_usb.o usb_boot.o

2
drivers/staging/gdm72xx/TODO
View file

@ -1,2 +0,0 @@
TODO:
- Clean up coding style to meet kernel standard.

438
drivers/staging/gdm72xx/gdm_qos.c
View file

@ -1,438 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/etherdevice.h>
#include <asm/byteorder.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <linux/if_ether.h>
#include "gdm_wimax.h"
#include "hci.h"
#include "gdm_qos.h"
#define MAX_FREE_LIST_CNT 32
static struct {
struct list_head head;
int cnt;
spinlock_t lock; /* protect structure fields */
} qos_free_list;
static void init_qos_entry_list(void)
{
qos_free_list.cnt = 0;
INIT_LIST_HEAD(&qos_free_list.head);
spin_lock_init(&qos_free_list.lock);
}
static void *alloc_qos_entry(void)
{
struct qos_entry_s *entry;
unsigned long flags;
spin_lock_irqsave(&qos_free_list.lock, flags);
if (qos_free_list.cnt) {
entry = list_entry(qos_free_list.head.prev, struct qos_entry_s,
list);
list_del(&entry->list);
qos_free_list.cnt--;
spin_unlock_irqrestore(&qos_free_list.lock, flags);
return entry;
}
spin_unlock_irqrestore(&qos_free_list.lock, flags);
return kmalloc(sizeof(*entry), GFP_ATOMIC);
}
static void free_qos_entry(void *entry)
{
struct qos_entry_s *qentry = entry;
unsigned long flags;
spin_lock_irqsave(&qos_free_list.lock, flags);
if (qos_free_list.cnt < MAX_FREE_LIST_CNT) {
list_add(&qentry->list, &qos_free_list.head);
qos_free_list.cnt++;
spin_unlock_irqrestore(&qos_free_list.lock, flags);
return;
}
spin_unlock_irqrestore(&qos_free_list.lock, flags);
kfree(entry);
}
static void free_qos_entry_list(struct list_head *free_list)
{
struct qos_entry_s *entry, *n;
int total_free = 0;
list_for_each_entry_safe(entry, n, free_list, list) {
list_del(&entry->list);
kfree(entry);
total_free++;
}
pr_debug("%s: total_free_cnt=%d\n", __func__, total_free);
}
void gdm_qos_init(void *nic_ptr)
{
struct nic *nic = nic_ptr;
struct qos_cb_s *qcb = &nic->qos;
int i;
for (i = 0; i < QOS_MAX; i++) {
INIT_LIST_HEAD(&qcb->qos_list[i]);
qcb->csr[i].qos_buf_count = 0;
qcb->csr[i].enabled = false;
}
qcb->qos_list_cnt = 0;
qcb->qos_null_idx = QOS_MAX - 1;
qcb->qos_limit_size = 255;
spin_lock_init(&qcb->qos_lock);
init_qos_entry_list();
}
void gdm_qos_release_list(void *nic_ptr)
{
struct nic *nic = nic_ptr;
struct qos_cb_s *qcb = &nic->qos;
unsigned long flags;
struct qos_entry_s *entry, *n;
struct list_head free_list;
int i;
INIT_LIST_HEAD(&free_list);
spin_lock_irqsave(&qcb->qos_lock, flags);
for (i = 0; i < QOS_MAX; i++) {
qcb->csr[i].qos_buf_count = 0;
qcb->csr[i].enabled = false;
}
qcb->qos_list_cnt = 0;
qcb->qos_null_idx = QOS_MAX - 1;
for (i = 0; i < QOS_MAX; i++) {
list_for_each_entry_safe(entry, n, &qcb->qos_list[i], list) {
list_move_tail(&entry->list, &free_list);
}
}
spin_unlock_irqrestore(&qcb->qos_lock, flags);
free_qos_entry_list(&free_list);
}
static int chk_ipv4_rule(struct gdm_wimax_csr_s *csr, u8 *stream, u8 *port)
{
int i;
if (csr->classifier_rule_en & IPTYPEOFSERVICE) {
if (((stream[1] & csr->ip2s_mask) < csr->ip2s_lo) ||
((stream[1] & csr->ip2s_mask) > csr->ip2s_hi))
return 1;
}
if (csr->classifier_rule_en & PROTOCOL) {
if (stream[9] != csr->protocol)
return 1;
}
if (csr->classifier_rule_en & IPMASKEDSRCADDRESS) {
for (i = 0; i < 4; i++) {
if ((stream[12 + i] & csr->ipsrc_addrmask[i]) !=
(csr->ipsrc_addr[i] & csr->ipsrc_addrmask[i]))
return 1;
}
}
if (csr->classifier_rule_en & IPMASKEDDSTADDRESS) {
for (i = 0; i < 4; i++) {
if ((stream[16 + i] & csr->ipdst_addrmask[i]) !=
(csr->ipdst_addr[i] & csr->ipdst_addrmask[i]))
return 1;
}
}
if (csr->classifier_rule_en & PROTOCOLSRCPORTRANGE) {
i = ((port[0] << 8) & 0xff00) + port[1];
if ((i < csr->srcport_lo) || (i > csr->srcport_hi))
return 1;
}
if (csr->classifier_rule_en & PROTOCOLDSTPORTRANGE) {
i = ((port[2] << 8) & 0xff00) + port[3];
if ((i < csr->dstport_lo) || (i > csr->dstport_hi))
return 1;
}
return 0;
}
static int get_qos_index(struct nic *nic, u8 *iph, u8 *tcpudph)
{
int ip_ver, i;
struct qos_cb_s *qcb = &nic->qos;
if (!iph || !tcpudph)
return -1;
ip_ver = (iph[0] >> 4) & 0xf;
if (ip_ver != 4)
return -1;
for (i = 0; i < QOS_MAX; i++) {
if (!qcb->csr[i].enabled)
continue;
if (!qcb->csr[i].classifier_rule_en)
continue;
if (chk_ipv4_rule(&qcb->csr[i], iph, tcpudph) == 0)
return i;
}
return -1;
}
static void extract_qos_list(struct nic *nic, struct list_head *head)
{
struct qos_cb_s *qcb = &nic->qos;
struct qos_entry_s *entry;
int i;
INIT_LIST_HEAD(head);
for (i = 0; i < QOS_MAX; i++) {
if (!qcb->csr[i].enabled)
continue;
if (qcb->csr[i].qos_buf_count >= qcb->qos_limit_size)
continue;
if (list_empty(&qcb->qos_list[i]))
continue;
entry = list_entry(qcb->qos_list[i].prev, struct qos_entry_s,
list);
list_move_tail(&entry->list, head);
qcb->csr[i].qos_buf_count++;
if (!list_empty(&qcb->qos_list[i]))
netdev_warn(nic->netdev, "Index(%d) is piled!!\n", i);
}
}
static void send_qos_list(struct nic *nic, struct list_head *head)
{
struct qos_entry_s *entry, *n;
list_for_each_entry_safe(entry, n, head, list) {
list_del(&entry->list);
gdm_wimax_send_tx(entry->skb, entry->dev);
free_qos_entry(entry);
}
}
int gdm_qos_send_hci_pkt(struct sk_buff *skb, struct net_device *dev)
{
struct nic *nic = netdev_priv(dev);
int index;
struct qos_cb_s *qcb = &nic->qos;
unsigned long flags;
struct ethhdr *ethh = (struct ethhdr *)(skb->data + HCI_HEADER_SIZE);
struct iphdr *iph = (struct iphdr *)((char *)ethh + ETH_HLEN);
struct tcphdr *tcph;
struct qos_entry_s *entry = NULL;
struct list_head send_list;
int ret = 0;
tcph = (struct tcphdr *)iph + iph->ihl * 4;
if (ethh->h_proto == cpu_to_be16(ETH_P_IP)) {
if (qcb->qos_list_cnt && !qos_free_list.cnt) {
entry = alloc_qos_entry();
entry->skb = skb;
entry->dev = dev;
netdev_dbg(dev, "qcb->qos_list_cnt=%d\n",
qcb->qos_list_cnt);
}
spin_lock_irqsave(&qcb->qos_lock, flags);
if (qcb->qos_list_cnt) {
index = get_qos_index(nic, (u8 *)iph, (u8 *)tcph);
if (index == -1)
index = qcb->qos_null_idx;
if (!entry) {
entry = alloc_qos_entry();
entry->skb = skb;
entry->dev = dev;
}
list_add_tail(&entry->list, &qcb->qos_list[index]);
extract_qos_list(nic, &send_list);
spin_unlock_irqrestore(&qcb->qos_lock, flags);
send_qos_list(nic, &send_list);
goto out;
}
spin_unlock_irqrestore(&qcb->qos_lock, flags);
if (entry)
free_qos_entry(entry);
}
ret = gdm_wimax_send_tx(skb, dev);
out:
return ret;
}
static int get_csr(struct qos_cb_s *qcb, u32 sfid, int mode)
{
int i;
for (i = 0; i < qcb->qos_list_cnt; i++) {
if (qcb->csr[i].sfid == sfid)
return i;
}
if (mode) {
for (i = 0; i < QOS_MAX; i++) {
if (!qcb->csr[i].enabled) {
qcb->csr[i].enabled = true;
qcb->qos_list_cnt++;
return i;
}
}
}
return -1;
}
#define QOS_CHANGE_DEL 0xFC
#define QOS_ADD 0xFD
#define QOS_REPORT 0xFE
void gdm_recv_qos_hci_packet(void *nic_ptr, u8 *buf, int size)
{
struct nic *nic = nic_ptr;
int i, index, pos;
u32 sfid;
u8 sub_cmd_evt;
struct qos_cb_s *qcb = &nic->qos;
struct qos_entry_s *entry, *n;
struct list_head send_list;
struct list_head free_list;
unsigned long flags;
sub_cmd_evt = (u8)buf[4];
if (sub_cmd_evt == QOS_REPORT) {
spin_lock_irqsave(&qcb->qos_lock, flags);
for (i = 0; i < qcb->qos_list_cnt; i++) {
sfid = ((buf[(i * 5) + 6] << 24) & 0xff000000);
sfid += ((buf[(i * 5) + 7] << 16) & 0xff0000);
sfid += ((buf[(i * 5) + 8] << 8) & 0xff00);
sfid += (buf[(i * 5) + 9]);
index = get_csr(qcb, sfid, 0);
if (index == -1) {
spin_unlock_irqrestore(&qcb->qos_lock, flags);
netdev_err(nic->netdev, "QoS ERROR: No SF\n");
return;
}
qcb->csr[index].qos_buf_count = buf[(i * 5) + 10];
}
extract_qos_list(nic, &send_list);
spin_unlock_irqrestore(&qcb->qos_lock, flags);
send_qos_list(nic, &send_list);
return;
}
/* sub_cmd_evt == QOS_ADD || sub_cmd_evt == QOS_CHANG_DEL */
pos = 6;
sfid = ((buf[pos++] << 24) & 0xff000000);
sfid += ((buf[pos++] << 16) & 0xff0000);
sfid += ((buf[pos++] << 8) & 0xff00);
sfid += (buf[pos++]);
index = get_csr(qcb, sfid, 1);
if (index == -1) {
netdev_err(nic->netdev,
"QoS ERROR: csr Update Error / Wrong index (%d)\n",
index);
return;
}
if (sub_cmd_evt == QOS_ADD) {
netdev_dbg(nic->netdev, "QOS_ADD SFID = 0x%x, index=%d\n",
sfid, index);
spin_lock_irqsave(&qcb->qos_lock, flags);
qcb->csr[index].sfid = sfid;
qcb->csr[index].classifier_rule_en = ((buf[pos++] << 8) & 0xff00);
qcb->csr[index].classifier_rule_en += buf[pos++];
if (qcb->csr[index].classifier_rule_en == 0)
qcb->qos_null_idx = index;
qcb->csr[index].ip2s_mask = buf[pos++];
qcb->csr[index].ip2s_lo = buf[pos++];
qcb->csr[index].ip2s_hi = buf[pos++];
qcb->csr[index].protocol = buf[pos++];
qcb->csr[index].ipsrc_addrmask[0] = buf[pos++];
qcb->csr[index].ipsrc_addrmask[1] = buf[pos++];
qcb->csr[index].ipsrc_addrmask[2] = buf[pos++];
qcb->csr[index].ipsrc_addrmask[3] = buf[pos++];
qcb->csr[index].ipsrc_addr[0] = buf[pos++];
qcb->csr[index].ipsrc_addr[1] = buf[pos++];
qcb->csr[index].ipsrc_addr[2] = buf[pos++];
qcb->csr[index].ipsrc_addr[3] = buf[pos++];
qcb->csr[index].ipdst_addrmask[0] = buf[pos++];
qcb->csr[index].ipdst_addrmask[1] = buf[pos++];
qcb->csr[index].ipdst_addrmask[2] = buf[pos++];
qcb->csr[index].ipdst_addrmask[3] = buf[pos++];
qcb->csr[index].ipdst_addr[0] = buf[pos++];
qcb->csr[index].ipdst_addr[1] = buf[pos++];
qcb->csr[index].ipdst_addr[2] = buf[pos++];
qcb->csr[index].ipdst_addr[3] = buf[pos++];
qcb->csr[index].srcport_lo = ((buf[pos++] << 8) & 0xff00);
qcb->csr[index].srcport_lo += buf[pos++];
qcb->csr[index].srcport_hi = ((buf[pos++] << 8) & 0xff00);
qcb->csr[index].srcport_hi += buf[pos++];
qcb->csr[index].dstport_lo = ((buf[pos++] << 8) & 0xff00);
qcb->csr[index].dstport_lo += buf[pos++];
qcb->csr[index].dstport_hi = ((buf[pos++] << 8) & 0xff00);
qcb->csr[index].dstport_hi += buf[pos++];
qcb->qos_limit_size = 254 / qcb->qos_list_cnt;
spin_unlock_irqrestore(&qcb->qos_lock, flags);
} else if (sub_cmd_evt == QOS_CHANGE_DEL) {
netdev_dbg(nic->netdev, "QOS_CHANGE_DEL SFID = 0x%x, index=%d\n",
sfid, index);
INIT_LIST_HEAD(&free_list);
spin_lock_irqsave(&qcb->qos_lock, flags);
qcb->csr[index].enabled = false;
qcb->qos_list_cnt--;
qcb->qos_limit_size = 254 / qcb->qos_list_cnt;
list_for_each_entry_safe(entry, n, &qcb->qos_list[index],
list) {
list_move_tail(&entry->list, &free_list);
}
spin_unlock_irqrestore(&qcb->qos_lock, flags);
free_qos_entry_list(&free_list);
}
}

74
drivers/staging/gdm72xx/gdm_qos.h
View file

@ -1,74 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __GDM72XX_GDM_QOS_H__
#define __GDM72XX_GDM_QOS_H__
#include <linux/types.h>
#include <linux/usb.h>
#include <linux/list.h>
#define QOS_MAX 16
#define IPTYPEOFSERVICE 0x8000
#define PROTOCOL 0x4000
#define IPMASKEDSRCADDRESS 0x2000
#define IPMASKEDDSTADDRESS 0x1000
#define PROTOCOLSRCPORTRANGE 0x800
#define PROTOCOLDSTPORTRANGE 0x400
#define DSTMACADDR 0x200
#define SRCMACADDR 0x100
#define ETHERTYPE 0x80
#define IEEE802_1DUSERPRIORITY 0x40
#define IEEE802_1QVLANID 0x10
struct gdm_wimax_csr_s {
bool enabled;
u32 sfid;
u8 qos_buf_count;
u16 classifier_rule_en;
u8 ip2s_lo;
u8 ip2s_hi;
u8 ip2s_mask;
u8 protocol;
u8 ipsrc_addr[16];
u8 ipsrc_addrmask[16];
u8 ipdst_addr[16];
u8 ipdst_addrmask[16];
u16 srcport_lo;
u16 srcport_hi;
u16 dstport_lo;
u16 dstport_hi;
};
struct qos_entry_s {
struct list_head list;
struct sk_buff *skb;
struct net_device *dev;
};
struct qos_cb_s {
struct list_head qos_list[QOS_MAX];
int qos_list_cnt;
int qos_null_idx;
struct gdm_wimax_csr_s csr[QOS_MAX];
spinlock_t qos_lock; /* Protect structure fields */
int qos_limit_size;
};
void gdm_qos_init(void *nic_ptr);
void gdm_qos_release_list(void *nic_ptr);
int gdm_qos_send_hci_pkt(struct sk_buff *skb, struct net_device *dev);
void gdm_recv_qos_hci_packet(void *nic_ptr, u8 *buf, int size);
#endif /* __GDM72XX_GDM_QOS_H__ */

700
drivers/staging/gdm72xx/gdm_sdio.c
View file

@ -1,700 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/mmc/core.h>
#include <linux/mmc/card.h>
#include <linux/mmc/sdio_func.h>
#include <linux/mmc/sdio_ids.h>
#include "gdm_sdio.h"
#include "gdm_wimax.h"
#include "sdio_boot.h"
#include "hci.h"
#define TYPE_A_HEADER_SIZE 4
#define TYPE_A_LOOKAHEAD_SIZE 16
#define MAX_NR_RX_BUF 4
#define SDU_TX_BUF_SIZE 2048
#define TX_BUF_SIZE 2048
#define TX_CHUNK_SIZE (2048 - TYPE_A_HEADER_SIZE)
#define RX_BUF_SIZE (25 * 1024)
#define TX_HZ 2000
#define TX_INTERVAL (NSEC_PER_SEC / TX_HZ)
static struct sdio_tx *alloc_tx_struct(struct tx_cxt *tx)
{
struct sdio_tx *t = kzalloc(sizeof(*t), GFP_ATOMIC);
if (!t)
return NULL;
t->buf = kmalloc(TX_BUF_SIZE, GFP_ATOMIC);
if (!t->buf) {
kfree(t);
return NULL;
}
t->tx_cxt = tx;
return t;
}
static void free_tx_struct(struct sdio_tx *t)
{
if (t) {
kfree(t->buf);
kfree(t);
}
}
static struct sdio_rx *alloc_rx_struct(struct rx_cxt *rx)
{
struct sdio_rx *r = kzalloc(sizeof(*r), GFP_ATOMIC);
if (r)
r->rx_cxt = rx;
return r;
}
static void free_rx_struct(struct sdio_rx *r)
{
kfree(r);
}
/* Before this function is called, spin lock should be locked. */
static struct sdio_tx *get_tx_struct(struct tx_cxt *tx, int *no_spc)
{
struct sdio_tx *t;
if (list_empty(&tx->free_list))
return NULL;
t = list_entry(tx->free_list.prev, struct sdio_tx, list);
list_del(&t->list);
*no_spc = list_empty(&tx->free_list) ? 1 : 0;
return t;
}
/* Before this function is called, spin lock should be locked. */
static void put_tx_struct(struct tx_cxt *tx, struct sdio_tx *t)
{
list_add_tail(&t->list, &tx->free_list);
}
/* Before this function is called, spin lock should be locked. */
static struct sdio_rx *get_rx_struct(struct rx_cxt *rx)
{
struct sdio_rx *r;
if (list_empty(&rx->free_list))
return NULL;
r = list_entry(rx->free_list.prev, struct sdio_rx, list);
list_del(&r->list);
return r;
}
/* Before this function is called, spin lock should be locked. */
static void put_rx_struct(struct rx_cxt *rx, struct sdio_rx *r)
{
list_add_tail(&r->list, &rx->free_list);
}
static void release_sdio(struct sdiowm_dev *sdev)
{
struct tx_cxt *tx = &sdev->tx;
struct rx_cxt *rx = &sdev->rx;
struct sdio_tx *t, *t_next;
struct sdio_rx *r, *r_next;
kfree(tx->sdu_buf);
list_for_each_entry_safe(t, t_next, &tx->free_list, list) {
list_del(&t->list);
free_tx_struct(t);
}
list_for_each_entry_safe(t, t_next, &tx->sdu_list, list) {
list_del(&t->list);
free_tx_struct(t);
}
list_for_each_entry_safe(t, t_next, &tx->hci_list, list) {
list_del(&t->list);
free_tx_struct(t);
}
kfree(rx->rx_buf);
list_for_each_entry_safe(r, r_next, &rx->free_list, list) {
list_del(&r->list);
free_rx_struct(r);
}
list_for_each_entry_safe(r, r_next, &rx->req_list, list) {
list_del(&r->list);
free_rx_struct(r);
}
}
static int init_sdio(struct sdiowm_dev *sdev)
{
int ret = 0, i;
struct tx_cxt *tx = &sdev->tx;
struct rx_cxt *rx = &sdev->rx;
struct sdio_tx *t;
struct sdio_rx *r;
INIT_LIST_HEAD(&tx->free_list);
INIT_LIST_HEAD(&tx->sdu_list);
INIT_LIST_HEAD(&tx->hci_list);
spin_lock_init(&tx->lock);
tx->sdu_buf = kmalloc(SDU_TX_BUF_SIZE, GFP_KERNEL);
if (!tx->sdu_buf)
goto fail;
for (i = 0; i < MAX_NR_SDU_BUF; i++) {
t = alloc_tx_struct(tx);
if (!t) {
ret = -ENOMEM;
goto fail;
}
list_add(&t->list, &tx->free_list);
}
INIT_LIST_HEAD(&rx->free_list);
INIT_LIST_HEAD(&rx->req_list);
spin_lock_init(&rx->lock);
for (i = 0; i < MAX_NR_RX_BUF; i++) {
r = alloc_rx_struct(rx);
if (!r) {
ret = -ENOMEM;
goto fail;
}
list_add(&r->list, &rx->free_list);
}
rx->rx_buf = kmalloc(RX_BUF_SIZE, GFP_KERNEL);
if (!rx->rx_buf)
goto fail;
return 0;
fail:
release_sdio(sdev);
return ret;
}
static void send_sdio_pkt(struct sdio_func *func, u8 *data, int len)
{
int n, blocks, ret, remain;
sdio_claim_host(func);
blocks = len / func->cur_blksize;
n = blocks * func->cur_blksize;
if (blocks) {
ret = sdio_memcpy_toio(func, 0, data, n);
if (ret < 0) {
if (ret != -ENOMEDIUM)
dev_err(&func->dev,
"gdmwms: error: ret = %d\n", ret);
goto end_io;
}
}
remain = len - n;
remain = (remain + 3) & ~3;
if (remain) {
ret = sdio_memcpy_toio(func, 0, data + n, remain);
if (ret < 0) {
if (ret != -ENOMEDIUM)
dev_err(&func->dev,
"gdmwms: error: ret = %d\n", ret);
goto end_io;
}
}
end_io:
sdio_release_host(func);
}
static void send_sdu(struct sdio_func *func, struct tx_cxt *tx)
{
struct list_head *l, *next;
struct hci_s *hci;
struct sdio_tx *t;
int pos, len, i, estlen, aggr_num = 0, aggr_len;
u8 *buf;
unsigned long flags;
spin_lock_irqsave(&tx->lock, flags);
pos = TYPE_A_HEADER_SIZE + HCI_HEADER_SIZE;
list_for_each_entry(t, &tx->sdu_list, list) {
estlen = ((t->len + 3) & ~3) + 4;
if ((pos + estlen) > SDU_TX_BUF_SIZE)
break;
aggr_num++;
memcpy(tx->sdu_buf + pos, t->buf, t->len);
memset(tx->sdu_buf + pos + t->len, 0, estlen - t->len);
pos += estlen;
}
aggr_len = pos;
hci = (struct hci_s *)(tx->sdu_buf + TYPE_A_HEADER_SIZE);
hci->cmd_evt = cpu_to_be16(WIMAX_TX_SDU_AGGR);
hci->length = cpu_to_be16(aggr_len - TYPE_A_HEADER_SIZE -
HCI_HEADER_SIZE);
spin_unlock_irqrestore(&tx->lock, flags);
dev_dbg(&func->dev, "sdio_send: %*ph\n", aggr_len - TYPE_A_HEADER_SIZE,
tx->sdu_buf + TYPE_A_HEADER_SIZE);
for (pos = TYPE_A_HEADER_SIZE; pos < aggr_len; pos += TX_CHUNK_SIZE) {
len = aggr_len - pos;
len = len > TX_CHUNK_SIZE ? TX_CHUNK_SIZE : len;
buf = tx->sdu_buf + pos - TYPE_A_HEADER_SIZE;
buf[0] = len & 0xff;
buf[1] = (len >> 8) & 0xff;
buf[2] = (len >> 16) & 0xff;
buf[3] = (pos + len) >= aggr_len ? 0 : 1;
send_sdio_pkt(func, buf, len + TYPE_A_HEADER_SIZE);
}
spin_lock_irqsave(&tx->lock, flags);
for (l = tx->sdu_list.next, i = 0; i < aggr_num; i++, l = next) {
next = l->next;
t = list_entry(l, struct sdio_tx, list);
if (t->callback)
t->callback(t->cb_data);
list_del(l);
put_tx_struct(t->tx_cxt, t);
}
tx->sdu_stamp = ktime_get();
spin_unlock_irqrestore(&tx->lock, flags);
}
static void send_hci(struct sdio_func *func, struct tx_cxt *tx,
struct sdio_tx *t)
{
unsigned long flags;
dev_dbg(&func->dev, "sdio_send: %*ph\n", t->len - TYPE_A_HEADER_SIZE,
t->buf + TYPE_A_HEADER_SIZE);
send_sdio_pkt(func, t->buf, t->len);
spin_lock_irqsave(&tx->lock, flags);
if (t->callback)
t->callback(t->cb_data);
free_tx_struct(t);
spin_unlock_irqrestore(&tx->lock, flags);
}
static void do_tx(struct work_struct *work)
{
struct sdiowm_dev *sdev = container_of(work, struct sdiowm_dev, ws);
struct sdio_func *func = sdev->func;
struct tx_cxt *tx = &sdev->tx;
struct sdio_tx *t = NULL;
ktime_t now, before;
int is_sdu = 0;
long diff;
unsigned long flags;
spin_lock_irqsave(&tx->lock, flags);
if (!tx->can_send) {
spin_unlock_irqrestore(&tx->lock, flags);
return;
}
if (!list_empty(&tx->hci_list)) {
t = list_entry(tx->hci_list.next, struct sdio_tx, list);
list_del(&t->list);
is_sdu = 0;
} else if (!tx->stop_sdu_tx && !list_empty(&tx->sdu_list)) {
now = ktime_get();
before = tx->sdu_stamp;
diff = ktime_to_ns(ktime_sub(now, before));
if (diff >= 0 && diff < TX_INTERVAL) {
schedule_work(&sdev->ws);
spin_unlock_irqrestore(&tx->lock, flags);
return;
}
is_sdu = 1;
}
if (!is_sdu && !t) {
spin_unlock_irqrestore(&tx->lock, flags);
return;
}
tx->can_send = 0;
spin_unlock_irqrestore(&tx->lock, flags);
if (is_sdu)
send_sdu(func, tx);
else
send_hci(func, tx, t);
}
static int gdm_sdio_send(void *priv_dev, void *data, int len,
void (*cb)(void *data), void *cb_data)
{
struct sdiowm_dev *sdev = priv_dev;
struct tx_cxt *tx = &sdev->tx;
struct sdio_tx *t;
u8 *pkt = data;
int no_spc = 0;
u16 cmd_evt;
unsigned long flags;
if (len > TX_BUF_SIZE - TYPE_A_HEADER_SIZE)
return -EINVAL;
spin_lock_irqsave(&tx->lock, flags);
cmd_evt = (pkt[0] << 8) | pkt[1];
if (cmd_evt == WIMAX_TX_SDU) {
t = get_tx_struct(tx, &no_spc);
if (!t) {
/* This case must not happen. */
spin_unlock_irqrestore(&tx->lock, flags);
return -ENOSPC;
}
list_add_tail(&t->list, &tx->sdu_list);
memcpy(t->buf, data, len);
t->len = len;
t->callback = cb;
t->cb_data = cb_data;
} else {
t = alloc_tx_struct(tx);
if (!t) {
spin_unlock_irqrestore(&tx->lock, flags);
return -ENOMEM;
}
list_add_tail(&t->list, &tx->hci_list);
t->buf[0] = len & 0xff;
t->buf[1] = (len >> 8) & 0xff;
t->buf[2] = (len >> 16) & 0xff;
t->buf[3] = 2;
memcpy(t->buf + TYPE_A_HEADER_SIZE, data, len);
t->len = len + TYPE_A_HEADER_SIZE;
t->callback = cb;
t->cb_data = cb_data;
}
if (tx->can_send)
schedule_work(&sdev->ws);
spin_unlock_irqrestore(&tx->lock, flags);
if (no_spc)
return -ENOSPC;
return 0;
}
/* Handle the HCI, WIMAX_SDU_TX_FLOW. */
static int control_sdu_tx_flow(struct sdiowm_dev *sdev, u8 *hci_data, int len)
{
struct tx_cxt *tx = &sdev->tx;
u16 cmd_evt;
unsigned long flags;
spin_lock_irqsave(&tx->lock, flags);
cmd_evt = (hci_data[0] << 8) | (hci_data[1]);
if (cmd_evt != WIMAX_SDU_TX_FLOW)
goto out;
if (hci_data[4] == 0) {
dev_dbg(&sdev->func->dev, "WIMAX ==> STOP SDU TX\n");
tx->stop_sdu_tx = 1;
} else if (hci_data[4] == 1) {
dev_dbg(&sdev->func->dev, "WIMAX ==> START SDU TX\n");
tx->stop_sdu_tx = 0;
if (tx->can_send)
schedule_work(&sdev->ws);
/* If free buffer for sdu tx doesn't exist, then tx queue
* should not be woken. For this reason, don't pass the command,
* START_SDU_TX.
*/
if (list_empty(&tx->free_list))
len = 0;
}
out:
spin_unlock_irqrestore(&tx->lock, flags);
return len;
}
static void gdm_sdio_irq(struct sdio_func *func)
{
struct phy_dev *phy_dev = sdio_get_drvdata(func);
struct sdiowm_dev *sdev = phy_dev->priv_dev;
struct tx_cxt *tx = &sdev->tx;
struct rx_cxt *rx = &sdev->rx;
struct sdio_rx *r;
unsigned long flags;
u8 val, hdr[TYPE_A_LOOKAHEAD_SIZE], *buf;
u32 len, blocks, n;
int ret, remain;
/* Check interrupt */
val = sdio_readb(func, 0x13, &ret);
if (val & 0x01)
sdio_writeb(func, 0x01, 0x13, &ret); /* clear interrupt */
else
return;
ret = sdio_memcpy_fromio(func, hdr, 0x0, TYPE_A_LOOKAHEAD_SIZE);
if (ret) {
dev_err(&func->dev,
"Cannot read from function %d\n", func->num);
goto done;
}
len = (hdr[2] << 16) | (hdr[1] << 8) | hdr[0];
if (len > (RX_BUF_SIZE - TYPE_A_HEADER_SIZE)) {
dev_err(&func->dev, "Too big Type-A size: %d\n", len);
goto done;
}
if (hdr[3] == 1) { /* Ack */
u32 *ack_seq = (u32 *)&hdr[4];
spin_lock_irqsave(&tx->lock, flags);
tx->can_send = 1;
if (!list_empty(&tx->sdu_list) || !list_empty(&tx->hci_list))
schedule_work(&sdev->ws);
spin_unlock_irqrestore(&tx->lock, flags);
dev_dbg(&func->dev, "Ack... %0x\n", ntohl(*ack_seq));
goto done;
}
memcpy(rx->rx_buf, hdr + TYPE_A_HEADER_SIZE,
TYPE_A_LOOKAHEAD_SIZE - TYPE_A_HEADER_SIZE);
buf = rx->rx_buf + TYPE_A_LOOKAHEAD_SIZE - TYPE_A_HEADER_SIZE;
remain = len - TYPE_A_LOOKAHEAD_SIZE + TYPE_A_HEADER_SIZE;
if (remain <= 0)
goto end_io;
blocks = remain / func->cur_blksize;
if (blocks) {
n = blocks * func->cur_blksize;
ret = sdio_memcpy_fromio(func, buf, 0x0, n);
if (ret) {
dev_err(&func->dev,
"Cannot read from function %d\n", func->num);
goto done;
}
buf += n;
remain -= n;
}
if (remain) {
ret = sdio_memcpy_fromio(func, buf, 0x0, remain);
if (ret) {
dev_err(&func->dev,
"Cannot read from function %d\n", func->num);
goto done;
}
}
end_io:
dev_dbg(&func->dev, "sdio_receive: %*ph\n", len, rx->rx_buf);
len = control_sdu_tx_flow(sdev, rx->rx_buf, len);
spin_lock_irqsave(&rx->lock, flags);
if (!list_empty(&rx->req_list)) {
r = list_entry(rx->req_list.next, struct sdio_rx, list);
spin_unlock_irqrestore(&rx->lock, flags);
if (r->callback)
r->callback(r->cb_data, rx->rx_buf, len);
spin_lock_irqsave(&rx->lock, flags);
list_del(&r->list);
put_rx_struct(rx, r);
}
spin_unlock_irqrestore(&rx->lock, flags);
done:
sdio_writeb(func, 0x00, 0x10, &ret); /* PCRRT */
if (!phy_dev->netdev)
register_wimax_device(phy_dev, &func->dev);
}
static int gdm_sdio_receive(void *priv_dev,
void (*cb)(void *cb_data, void *data, int len),
void *cb_data)
{
struct sdiowm_dev *sdev = priv_dev;
struct rx_cxt *rx = &sdev->rx;
struct sdio_rx *r;
unsigned long flags;
spin_lock_irqsave(&rx->lock, flags);
r = get_rx_struct(rx);
if (!r) {
spin_unlock_irqrestore(&rx->lock, flags);
return -ENOMEM;
}
r->callback = cb;
r->cb_data = cb_data;
list_add_tail(&r->list, &rx->req_list);
spin_unlock_irqrestore(&rx->lock, flags);
return 0;
}
static int sdio_wimax_probe(struct sdio_func *func,
const struct sdio_device_id *id)
{
int ret;
struct phy_dev *phy_dev = NULL;
struct sdiowm_dev *sdev = NULL;
dev_info(&func->dev, "Found GDM SDIO VID = 0x%04x PID = 0x%04x...\n",
func->vendor, func->device);
dev_info(&func->dev, "GCT WiMax driver version %s\n", DRIVER_VERSION);
sdio_claim_host(func);
sdio_enable_func(func);
sdio_claim_irq(func, gdm_sdio_irq);
ret = sdio_boot(func);
if (ret)
return ret;
phy_dev = kzalloc(sizeof(*phy_dev), GFP_KERNEL);
if (!phy_dev) {
ret = -ENOMEM;
goto out;
}
sdev = kzalloc(sizeof(*sdev), GFP_KERNEL);
if (!sdev) {
ret = -ENOMEM;
goto out;
}
phy_dev->priv_dev = (void *)sdev;
phy_dev->send_func = gdm_sdio_send;
phy_dev->rcv_func = gdm_sdio_receive;
ret = init_sdio(sdev);
if (ret < 0)
goto out;
sdev->func = func;
sdio_writeb(func, 1, 0x14, &ret); /* Enable interrupt */
sdio_release_host(func);
INIT_WORK(&sdev->ws, do_tx);
sdio_set_drvdata(func, phy_dev);
out:
if (ret) {
kfree(phy_dev);
kfree(sdev);
}
return ret;
}
static void sdio_wimax_remove(struct sdio_func *func)
{
struct phy_dev *phy_dev = sdio_get_drvdata(func);
struct sdiowm_dev *sdev = phy_dev->priv_dev;
cancel_work_sync(&sdev->ws);
if (phy_dev->netdev)
unregister_wimax_device(phy_dev);
sdio_claim_host(func);
sdio_release_irq(func);
sdio_disable_func(func);
sdio_release_host(func);
release_sdio(sdev);
kfree(sdev);
kfree(phy_dev);
}
static const struct sdio_device_id sdio_wimax_ids[] = {
{ SDIO_DEVICE(0x0296, 0x5347) },
{0}
};
MODULE_DEVICE_TABLE(sdio, sdio_wimax_ids);
static struct sdio_driver sdio_wimax_driver = {
.probe = sdio_wimax_probe,
.remove = sdio_wimax_remove,
.name = "sdio_wimax",
.id_table = sdio_wimax_ids,
};
static int __init sdio_gdm_wimax_init(void)
{
return sdio_register_driver(&sdio_wimax_driver);
}
static void __exit sdio_gdm_wimax_exit(void)
{
sdio_unregister_driver(&sdio_wimax_driver);
}
module_init(sdio_gdm_wimax_init);
module_exit(sdio_gdm_wimax_exit);
MODULE_VERSION(DRIVER_VERSION);
MODULE_DESCRIPTION("GCT WiMax SDIO Device Driver");
MODULE_AUTHOR("Ethan Park");
MODULE_LICENSE("GPL");

63
drivers/staging/gdm72xx/gdm_sdio.h
View file

@ -1,63 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __GDM72XX_GDM_SDIO_H__
#define __GDM72XX_GDM_SDIO_H__
#include <linux/types.h>
#include <linux/ktime.h>
#define MAX_NR_SDU_BUF 64
struct sdio_tx {
struct list_head list;
struct tx_cxt *tx_cxt;
u8 *buf;
int len;
void (*callback)(void *cb_data);
void *cb_data;
};
struct tx_cxt {
struct list_head free_list;
struct list_head sdu_list;
struct list_head hci_list;
ktime_t sdu_stamp;
u8 *sdu_buf;
spinlock_t lock; /* protect structure fields */
int can_send;
int stop_sdu_tx;
};
struct sdio_rx {
struct list_head list;
struct rx_cxt *rx_cxt;
void (*callback)(void *cb_data, void *data, int len);
void *cb_data;
};
struct rx_cxt {
struct list_head free_list;
struct list_head req_list;
u8 *rx_buf;
spinlock_t lock; /* protect structure fields */
};
struct sdiowm_dev {
struct sdio_func *func;
struct tx_cxt tx;
struct rx_cxt rx;
struct work_struct ws;
};
#endif /* __GDM72XX_GDM_SDIO_H__ */

788
drivers/staging/gdm72xx/gdm_usb.c
View file

@ -1,788 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/usb.h>
#include <asm/byteorder.h>
#include <linux/kthread.h>
#include "gdm_usb.h"
#include "gdm_wimax.h"
#include "usb_boot.h"
#include "hci.h"
#include "usb_ids.h"
MODULE_DEVICE_TABLE(usb, id_table);
#define TX_BUF_SIZE 2048
#if defined(CONFIG_WIMAX_GDM72XX_WIMAX2)
#define RX_BUF_SIZE (128 * 1024) /* For packet aggregation */
#else
#define RX_BUF_SIZE 2048
#endif
#define GDM7205_PADDING 256
#define DOWNLOAD_CONF_VALUE 0x21
#ifdef CONFIG_WIMAX_GDM72XX_K_MODE
static DECLARE_WAIT_QUEUE_HEAD(k_wait);
static LIST_HEAD(k_list);
static DEFINE_SPINLOCK(k_lock);
static int k_mode_stop;
#define K_WAIT_TIME (2 * HZ / 100)
#endif /* CONFIG_WIMAX_GDM72XX_K_MODE */
static struct usb_tx *alloc_tx_struct(struct tx_cxt *tx)
{
struct usb_tx *t = kzalloc(sizeof(*t), GFP_ATOMIC);
if (!t)
return NULL;
t->urb = usb_alloc_urb(0, GFP_ATOMIC);
t->buf = kmalloc(TX_BUF_SIZE, GFP_ATOMIC);
if (!t->urb || !t->buf) {
usb_free_urb(t->urb);
kfree(t->buf);
kfree(t);
return NULL;
}
t->tx_cxt = tx;
return t;
}
static void free_tx_struct(struct usb_tx *t)
{
if (t) {
usb_free_urb(t->urb);
kfree(t->buf);
kfree(t);
}
}
static struct usb_rx *alloc_rx_struct(struct rx_cxt *rx)
{
struct usb_rx *r = kzalloc(sizeof(*r), GFP_ATOMIC);
if (!r)
return NULL;
r->urb = usb_alloc_urb(0, GFP_ATOMIC);
r->buf = kmalloc(RX_BUF_SIZE, GFP_ATOMIC);
if (!r->urb || !r->buf) {
usb_free_urb(r->urb);
kfree(r->buf);
kfree(r);
return NULL;
}
r->rx_cxt = rx;
return r;
}
static void free_rx_struct(struct usb_rx *r)
{
if (r) {
usb_free_urb(r->urb);
kfree(r->buf);
kfree(r);
}
}
/* Before this function is called, spin lock should be locked. */
static struct usb_tx *get_tx_struct(struct tx_cxt *tx, int *no_spc)
{
struct usb_tx *t;
if (list_empty(&tx->free_list)) {
*no_spc = 1;
return NULL;
}
t = list_entry(tx->free_list.next, struct usb_tx, list);
list_del(&t->list);
*no_spc = list_empty(&tx->free_list) ? 1 : 0;
return t;
}
/* Before this function is called, spin lock should be locked. */
static void put_tx_struct(struct tx_cxt *tx, struct usb_tx *t)
{
list_add_tail(&t->list, &tx->free_list);
}
/* Before this function is called, spin lock should be locked. */
static struct usb_rx *get_rx_struct(struct rx_cxt *rx)
{
struct usb_rx *r;
if (list_empty(&rx->free_list)) {
r = alloc_rx_struct(rx);
if (!r)
return NULL;
list_add(&r->list, &rx->free_list);
}
r = list_entry(rx->free_list.next, struct usb_rx, list);
list_move_tail(&r->list, &rx->used_list);
return r;
}
/* Before this function is called, spin lock should be locked. */
static void put_rx_struct(struct rx_cxt *rx, struct usb_rx *r)
{
list_move(&r->list, &rx->free_list);
}
static void release_usb(struct usbwm_dev *udev)
{
struct tx_cxt *tx = &udev->tx;
struct rx_cxt *rx = &udev->rx;
struct usb_tx *t, *t_next;
struct usb_rx *r, *r_next;
unsigned long flags;
spin_lock_irqsave(&tx->lock, flags);
list_for_each_entry_safe(t, t_next, &tx->sdu_list, list) {
list_del(&t->list);
free_tx_struct(t);
}
list_for_each_entry_safe(t, t_next, &tx->hci_list, list) {
list_del(&t->list);
free_tx_struct(t);
}
list_for_each_entry_safe(t, t_next, &tx->free_list, list) {
list_del(&t->list);
free_tx_struct(t);
}
spin_unlock_irqrestore(&tx->lock, flags);
spin_lock_irqsave(&rx->lock, flags);
list_for_each_entry_safe(r, r_next, &rx->free_list, list) {
list_del(&r->list);
free_rx_struct(r);
}
list_for_each_entry_safe(r, r_next, &rx->used_list, list) {
list_del(&r->list);
free_rx_struct(r);
}
spin_unlock_irqrestore(&rx->lock, flags);
}
static int init_usb(struct usbwm_dev *udev)
{
int ret = 0, i;
struct tx_cxt *tx = &udev->tx;
struct rx_cxt *rx = &udev->rx;
struct usb_tx *t;
struct usb_rx *r;
unsigned long flags;
INIT_LIST_HEAD(&tx->free_list);
INIT_LIST_HEAD(&tx->sdu_list);
INIT_LIST_HEAD(&tx->hci_list);
#if defined(CONFIG_WIMAX_GDM72XX_USB_PM) || defined(CONFIG_WIMAX_GDM72XX_K_MODE)
INIT_LIST_HEAD(&tx->pending_list);
#endif
INIT_LIST_HEAD(&rx->free_list);
INIT_LIST_HEAD(&rx->used_list);
spin_lock_init(&tx->lock);
spin_lock_init(&rx->lock);
spin_lock_irqsave(&tx->lock, flags);
for (i = 0; i < MAX_NR_SDU_BUF; i++) {
t = alloc_tx_struct(tx);
if (!t) {
spin_unlock_irqrestore(&tx->lock, flags);
ret = -ENOMEM;
goto fail;
}
list_add(&t->list, &tx->free_list);
}
spin_unlock_irqrestore(&tx->lock, flags);
r = alloc_rx_struct(rx);
if (!r) {
ret = -ENOMEM;
goto fail;
}
spin_lock_irqsave(&rx->lock, flags);
list_add(&r->list, &rx->free_list);
spin_unlock_irqrestore(&rx->lock, flags);
return ret;
fail:
release_usb(udev);
return ret;
}
static void __gdm_usb_send_complete(struct urb *urb)
{
struct usb_tx *t = urb->context;
struct tx_cxt *tx = t->tx_cxt;
u8 *pkt = t->buf;
u16 cmd_evt;
/* Completion by usb_unlink_urb */
if (urb->status == -ECONNRESET)
return;
if (t->callback)
t->callback(t->cb_data);
/* Delete from sdu list or hci list. */
list_del(&t->list);
cmd_evt = (pkt[0] << 8) | pkt[1];
if (cmd_evt == WIMAX_TX_SDU)
put_tx_struct(tx, t);
else
free_tx_struct(t);
}
static void gdm_usb_send_complete(struct urb *urb)
{
struct usb_tx *t = urb->context;
struct tx_cxt *tx = t->tx_cxt;
unsigned long flags;
spin_lock_irqsave(&tx->lock, flags);
__gdm_usb_send_complete(urb);
spin_unlock_irqrestore(&tx->lock, flags);
}
static int gdm_usb_send(void *priv_dev, void *data, size_t len,
void (*cb)(void *data), void *cb_data)
{
struct usbwm_dev *udev = priv_dev;
struct usb_device *usbdev = udev->usbdev;
struct tx_cxt *tx = &udev->tx;
struct usb_tx *t;
int padding = udev->padding;
int no_spc = 0, ret;
u8 *pkt = data;
u16 cmd_evt;
unsigned long flags;
#ifdef CONFIG_WIMAX_GDM72XX_K_MODE
unsigned long flags2;
#endif /* CONFIG_WIMAX_GDM72XX_K_MODE */
if (!udev->usbdev) {
dev_err(&usbdev->dev, "%s: No such device\n", __func__);
return -ENODEV;
}
if (len > TX_BUF_SIZE - padding - 1)
return -EINVAL;
spin_lock_irqsave(&tx->lock, flags);
cmd_evt = (pkt[0] << 8) | pkt[1];
if (cmd_evt == WIMAX_TX_SDU) {
t = get_tx_struct(tx, &no_spc);
if (!t) {
/* This case must not happen. */
spin_unlock_irqrestore(&tx->lock, flags);
return -ENOSPC;
}
list_add_tail(&t->list, &tx->sdu_list);
} else {
t = alloc_tx_struct(tx);
if (!t) {
spin_unlock_irqrestore(&tx->lock, flags);
return -ENOMEM;
}
list_add_tail(&t->list, &tx->hci_list);
}
memcpy(t->buf + padding, data, len);
t->callback = cb;
t->cb_data = cb_data;
/* In some cases, USB Module of WiMax is blocked when data size is
* the multiple of 512. So, increment length by one in that case.
*/
if ((len % 512) == 0)
len++;
usb_fill_bulk_urb(t->urb, usbdev, usb_sndbulkpipe(usbdev, 1), t->buf,
len + padding, gdm_usb_send_complete, t);
dev_dbg(&usbdev->dev, "usb_send: %*ph\n", (int)len + padding, t->buf);
#ifdef CONFIG_WIMAX_GDM72XX_USB_PM
if (usbdev->state & USB_STATE_SUSPENDED) {
list_add_tail(&t->p_list, &tx->pending_list);
schedule_work(&udev->pm_ws);
goto out;
}
#endif /* CONFIG_WIMAX_GDM72XX_USB_PM */
#ifdef CONFIG_WIMAX_GDM72XX_K_MODE
if (udev->bw_switch) {
list_add_tail(&t->p_list, &tx->pending_list);
goto out;
} else if (cmd_evt == WIMAX_SCAN) {
struct rx_cxt *rx;
struct usb_rx *r;
rx = &udev->rx;
spin_lock_irqsave(&rx->lock, flags2);
list_for_each_entry(r, &rx->used_list, list)
usb_unlink_urb(r->urb);
spin_unlock_irqrestore(&rx->lock, flags2);
udev->bw_switch = 1;
spin_lock_irqsave(&k_lock, flags2);
list_add_tail(&udev->list, &k_list);
spin_unlock_irqrestore(&k_lock, flags2);
wake_up(&k_wait);
}
#endif /* CONFIG_WIMAX_GDM72XX_K_MODE */
ret = usb_submit_urb(t->urb, GFP_ATOMIC);
if (ret)
goto send_fail;
#ifdef CONFIG_WIMAX_GDM72XX_USB_PM
usb_mark_last_busy(usbdev);
#endif /* CONFIG_WIMAX_GDM72XX_USB_PM */
#if defined(CONFIG_WIMAX_GDM72XX_USB_PM) || defined(CONFIG_WIMAX_GDM72XX_K_MODE)
out:
#endif
spin_unlock_irqrestore(&tx->lock, flags);
if (no_spc)
return -ENOSPC;
return 0;
send_fail:
t->callback = NULL;
__gdm_usb_send_complete(t->urb);
spin_unlock_irqrestore(&tx->lock, flags);
return ret;
}
static void gdm_usb_rcv_complete(struct urb *urb)
{
struct usb_rx *r = urb->context;
struct rx_cxt *rx = r->rx_cxt;
struct usbwm_dev *udev = container_of(r->rx_cxt, struct usbwm_dev, rx);
struct tx_cxt *tx = &udev->tx;
struct usb_tx *t;
u16 cmd_evt;
unsigned long flags, flags2;
struct usb_device *dev = urb->dev;
/* Completion by usb_unlink_urb */
if (urb->status == -ECONNRESET)
return;
spin_lock_irqsave(&tx->lock, flags);
if (!urb->status) {
cmd_evt = (r->buf[0] << 8) | (r->buf[1]);
dev_dbg(&dev->dev, "usb_receive: %*ph\n", urb->actual_length,
r->buf);
if (cmd_evt == WIMAX_SDU_TX_FLOW) {
if (r->buf[4] == 0) {
dev_dbg(&dev->dev, "WIMAX ==> STOP SDU TX\n");
list_for_each_entry(t, &tx->sdu_list, list)
usb_unlink_urb(t->urb);
} else if (r->buf[4] == 1) {
dev_dbg(&dev->dev, "WIMAX ==> START SDU TX\n");
list_for_each_entry(t, &tx->sdu_list, list) {
usb_submit_urb(t->urb, GFP_ATOMIC);
}
/* If free buffer for sdu tx doesn't
* exist, then tx queue should not be
* woken. For this reason, don't pass
* the command, START_SDU_TX.
*/
if (list_empty(&tx->free_list))
urb->actual_length = 0;
}
}
}
if (!urb->status && r->callback)
r->callback(r->cb_data, r->buf, urb->actual_length);
spin_lock_irqsave(&rx->lock, flags2);
put_rx_struct(rx, r);
spin_unlock_irqrestore(&rx->lock, flags2);
spin_unlock_irqrestore(&tx->lock, flags);
#ifdef CONFIG_WIMAX_GDM72XX_USB_PM
usb_mark_last_busy(dev);
#endif
}
static int gdm_usb_receive(void *priv_dev,
void (*cb)(void *cb_data, void *data, size_t len),
void *cb_data)
{
struct usbwm_dev *udev = priv_dev;
struct usb_device *usbdev = udev->usbdev;
struct rx_cxt *rx = &udev->rx;
struct usb_rx *r;
unsigned long flags;
if (!udev->usbdev) {
dev_err(&usbdev->dev, "%s: No such device\n", __func__);
return -ENODEV;
}
spin_lock_irqsave(&rx->lock, flags);
r = get_rx_struct(rx);
spin_unlock_irqrestore(&rx->lock, flags);
if (!r)
return -ENOMEM;
r->callback = cb;
r->cb_data = cb_data;
usb_fill_bulk_urb(r->urb, usbdev, usb_rcvbulkpipe(usbdev, 0x82), r->buf,
RX_BUF_SIZE, gdm_usb_rcv_complete, r);
return usb_submit_urb(r->urb, GFP_ATOMIC);
}
#ifdef CONFIG_WIMAX_GDM72XX_USB_PM
static void do_pm_control(struct work_struct *work)
{
struct usbwm_dev *udev = container_of(work, struct usbwm_dev, pm_ws);
struct tx_cxt *tx = &udev->tx;
int ret;
unsigned long flags;
ret = usb_autopm_get_interface(udev->intf);
if (!ret)
usb_autopm_put_interface(udev->intf);
spin_lock_irqsave(&tx->lock, flags);
if (!(udev->usbdev->state & USB_STATE_SUSPENDED) &&
(!list_empty(&tx->hci_list) || !list_empty(&tx->sdu_list))) {
struct usb_tx *t, *temp;
list_for_each_entry_safe(t, temp, &tx->pending_list, p_list) {
list_del(&t->p_list);
ret = usb_submit_urb(t->urb, GFP_ATOMIC);
if (ret) {
t->callback = NULL;
__gdm_usb_send_complete(t->urb);
}
}
}
spin_unlock_irqrestore(&tx->lock, flags);
}
#endif /* CONFIG_WIMAX_GDM72XX_USB_PM */
static int gdm_usb_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
int ret = 0;
u8 bConfigurationValue;
struct phy_dev *phy_dev = NULL;
struct usbwm_dev *udev = NULL;
u16 idVendor, idProduct, bcdDevice;
struct usb_device *usbdev = interface_to_usbdev(intf);
usb_get_dev(usbdev);
bConfigurationValue = usbdev->actconfig->desc.bConfigurationValue;
/*USB description is set up with Little-Endian*/
idVendor = le16_to_cpu(usbdev->descriptor.idVendor);
idProduct = le16_to_cpu(usbdev->descriptor.idProduct);
bcdDevice = le16_to_cpu(usbdev->descriptor.bcdDevice);
dev_info(&intf->dev, "Found GDM USB VID = 0x%04x PID = 0x%04x...\n",
idVendor, idProduct);
dev_info(&intf->dev, "GCT WiMax driver version %s\n", DRIVER_VERSION);
if (idProduct == EMERGENCY_PID) {
ret = usb_emergency(usbdev);
goto out;
}
/* Support for EEPROM bootloader */
if (bConfigurationValue == DOWNLOAD_CONF_VALUE ||
idProduct & B_DOWNLOAD) {
ret = usb_boot(usbdev, bcdDevice);
goto out;
}
phy_dev = kzalloc(sizeof(*phy_dev), GFP_KERNEL);
if (!phy_dev) {
ret = -ENOMEM;
goto out;
}
udev = kzalloc(sizeof(*udev), GFP_KERNEL);
if (!udev) {
ret = -ENOMEM;
goto out;
}
if (idProduct == 0x7205 || idProduct == 0x7206)
udev->padding = GDM7205_PADDING;
else
udev->padding = 0;
phy_dev->priv_dev = (void *)udev;
phy_dev->send_func = gdm_usb_send;
phy_dev->rcv_func = gdm_usb_receive;
ret = init_usb(udev);
if (ret < 0)
goto out;
udev->usbdev = usbdev;
#ifdef CONFIG_WIMAX_GDM72XX_USB_PM
udev->intf = intf;
intf->needs_remote_wakeup = 1;
device_init_wakeup(&intf->dev, 1);
pm_runtime_set_autosuspend_delay(&usbdev->dev, 10 * 1000); /* msec */
INIT_WORK(&udev->pm_ws, do_pm_control);
#endif /* CONFIG_WIMAX_GDM72XX_USB_PM */
ret = register_wimax_device(phy_dev, &intf->dev);
if (ret)
release_usb(udev);
out:
if (ret) {
kfree(phy_dev);
kfree(udev);
usb_put_dev(usbdev);
} else {
usb_set_intfdata(intf, phy_dev);
}
return ret;
}
static void gdm_usb_disconnect(struct usb_interface *intf)
{
u8 bConfigurationValue;
struct phy_dev *phy_dev;
struct usbwm_dev *udev;
u16 idProduct;
struct usb_device *usbdev = interface_to_usbdev(intf);
bConfigurationValue = usbdev->actconfig->desc.bConfigurationValue;
phy_dev = usb_get_intfdata(intf);
/*USB description is set up with Little-Endian*/
idProduct = le16_to_cpu(usbdev->descriptor.idProduct);
if (idProduct != EMERGENCY_PID &&
bConfigurationValue != DOWNLOAD_CONF_VALUE &&
(idProduct & B_DOWNLOAD) == 0) {
udev = phy_dev->priv_dev;
udev->usbdev = NULL;
unregister_wimax_device(phy_dev);
release_usb(udev);
kfree(udev);
kfree(phy_dev);
}
usb_put_dev(usbdev);
}
#ifdef CONFIG_WIMAX_GDM72XX_USB_PM
static int gdm_suspend(struct usb_interface *intf, pm_message_t pm_msg)
{
struct phy_dev *phy_dev;
struct usbwm_dev *udev;
struct rx_cxt *rx;
struct usb_rx *r;
unsigned long flags;
phy_dev = usb_get_intfdata(intf);
if (!phy_dev)
return 0;
udev = phy_dev->priv_dev;
rx = &udev->rx;
spin_lock_irqsave(&rx->lock, flags);
list_for_each_entry(r, &rx->used_list, list)
usb_unlink_urb(r->urb);
spin_unlock_irqrestore(&rx->lock, flags);
return 0;
}
static int gdm_resume(struct usb_interface *intf)
{
struct phy_dev *phy_dev;
struct usbwm_dev *udev;
struct rx_cxt *rx;
struct usb_rx *r;
unsigned long flags;
phy_dev = usb_get_intfdata(intf);
if (!phy_dev)
return 0;
udev = phy_dev->priv_dev;
rx = &udev->rx;
spin_lock_irqsave(&rx->lock, flags);
list_for_each_entry(r, &rx->used_list, list)
usb_submit_urb(r->urb, GFP_ATOMIC);
spin_unlock_irqrestore(&rx->lock, flags);
return 0;
}
#endif /* CONFIG_WIMAX_GDM72XX_USB_PM */
#ifdef CONFIG_WIMAX_GDM72XX_K_MODE
static int k_mode_thread(void *arg)
{
struct usbwm_dev *udev;
struct tx_cxt *tx;
struct rx_cxt *rx;
struct usb_tx *t, *temp;
struct usb_rx *r;
unsigned long flags, flags2, expire;
int ret;
while (!k_mode_stop) {
spin_lock_irqsave(&k_lock, flags2);
while (!list_empty(&k_list)) {
udev = list_entry(k_list.next, struct usbwm_dev, list);
tx = &udev->tx;
rx = &udev->rx;
list_del(&udev->list);
spin_unlock_irqrestore(&k_lock, flags2);
expire = jiffies + K_WAIT_TIME;
while (time_before(jiffies, expire))
schedule_timeout(K_WAIT_TIME);
spin_lock_irqsave(&rx->lock, flags);
list_for_each_entry(r, &rx->used_list, list)
usb_submit_urb(r->urb, GFP_ATOMIC);
spin_unlock_irqrestore(&rx->lock, flags);
spin_lock_irqsave(&tx->lock, flags);
list_for_each_entry_safe(t, temp, &tx->pending_list,
p_list) {
list_del(&t->p_list);
ret = usb_submit_urb(t->urb, GFP_ATOMIC);
if (ret) {
t->callback = NULL;
__gdm_usb_send_complete(t->urb);
}
}
udev->bw_switch = 0;
spin_unlock_irqrestore(&tx->lock, flags);
spin_lock_irqsave(&k_lock, flags2);
}
wait_event_interruptible_lock_irq(k_wait,
!list_empty(&k_list) ||
k_mode_stop, k_lock);
spin_unlock_irqrestore(&k_lock, flags2);
}
return 0;
}
#endif /* CONFIG_WIMAX_GDM72XX_K_MODE */
static struct usb_driver gdm_usb_driver = {
.name = "gdm_wimax",
.probe = gdm_usb_probe,
.disconnect = gdm_usb_disconnect,
.id_table = id_table,
#ifdef CONFIG_WIMAX_GDM72XX_USB_PM
.supports_autosuspend = 1,
.suspend = gdm_suspend,
.resume = gdm_resume,
.reset_resume = gdm_resume,
#endif
};
static int __init usb_gdm_wimax_init(void)
{
#ifdef CONFIG_WIMAX_GDM72XX_K_MODE
kthread_run(k_mode_thread, NULL, "k_mode_wimax");
#endif /* CONFIG_WIMAX_GDM72XX_K_MODE */
return usb_register(&gdm_usb_driver);
}
static void __exit usb_gdm_wimax_exit(void)
{
#ifdef CONFIG_WIMAX_GDM72XX_K_MODE
k_mode_stop = 1;
wake_up(&k_wait);
#endif
usb_deregister(&gdm_usb_driver);
}
module_init(usb_gdm_wimax_init);
module_exit(usb_gdm_wimax_exit);
MODULE_VERSION(DRIVER_VERSION);
MODULE_DESCRIPTION("GCT WiMax Device Driver");
MODULE_AUTHOR("Ethan Park");
MODULE_LICENSE("GPL");

78
drivers/staging/gdm72xx/gdm_usb.h
View file

@ -1,78 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __GDM72XX_GDM_USB_H__
#define __GDM72XX_GDM_USB_H__
#include <linux/types.h>
#include <linux/usb.h>
#include <linux/list.h>
#define B_DIFF_DL_DRV BIT(4)
#define B_DOWNLOAD BIT(5)
#define MAX_NR_SDU_BUF 64
struct usb_tx {
struct list_head list;
#if defined(CONFIG_WIMAX_GDM72XX_USB_PM) || defined(CONFIG_WIMAX_GDM72XX_K_MODE)
struct list_head p_list;
#endif
struct tx_cxt *tx_cxt;
struct urb *urb;
u8 *buf;
void (*callback)(void *cb_data);
void *cb_data;
};
struct tx_cxt {
struct list_head free_list;
struct list_head sdu_list;
struct list_head hci_list;
#if defined(CONFIG_WIMAX_GDM72XX_USB_PM) || defined(CONFIG_WIMAX_GDM72XX_K_MODE)
struct list_head pending_list;
#endif
spinlock_t lock; /* Protect structure fields */
};
struct usb_rx {
struct list_head list;
struct rx_cxt *rx_cxt;
struct urb *urb;
u8 *buf;
void (*callback)(void *cb_data, void *data, size_t len);
void *cb_data;
};
struct rx_cxt {
struct list_head free_list;
struct list_head used_list;
spinlock_t lock; /* Protect structure fields */
};
struct usbwm_dev {
struct usb_device *usbdev;
#ifdef CONFIG_WIMAX_GDM72XX_USB_PM
struct work_struct pm_ws;
struct usb_interface *intf;
#endif
#ifdef CONFIG_WIMAX_GDM72XX_K_MODE
int bw_switch;
struct list_head list;
#endif
struct tx_cxt tx;
struct rx_cxt rx;
int padding;
};
#endif /* __GDM72XX_GDM_USB_H__ */

808
drivers/staging/gdm72xx/gdm_wimax.c
View file

@ -1,808 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/etherdevice.h>
#include <asm/byteorder.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <linux/udp.h>
#include <linux/in.h>
#include "gdm_wimax.h"
#include "hci.h"
#include "wm_ioctl.h"
#include "netlink_k.h"
#define gdm_wimax_send(n, d, l) \
n->phy_dev->send_func(n->phy_dev->priv_dev, d, l, NULL, NULL)
#define gdm_wimax_send_with_cb(n, d, l, c, b) \
n->phy_dev->send_func(n->phy_dev->priv_dev, d, l, c, b)
#define gdm_wimax_rcv_with_cb(n, c, b) \
n->phy_dev->rcv_func(n->phy_dev->priv_dev, c, b)
#define EVT_MAX_SIZE 2048
struct evt_entry {
struct list_head list;
struct net_device *dev;
char evt_data[EVT_MAX_SIZE];
int size;
};
static struct {
int ref_cnt;
struct sock *sock;
struct list_head evtq;
spinlock_t evt_lock; /*protect structure fields */
struct list_head freeq;
struct work_struct ws;
} wm_event;
static u8 gdm_wimax_macaddr[6] = {0x00, 0x0a, 0x3b, 0xf0, 0x01, 0x30};
static inline int gdm_wimax_header(struct sk_buff **pskb)
{
u16 buf[HCI_HEADER_SIZE / sizeof(u16)];
struct hci_s *hci = (struct hci_s *)buf;
struct sk_buff *skb = *pskb;
if (unlikely(skb_headroom(skb) < HCI_HEADER_SIZE)) {
struct sk_buff *skb2;
skb2 = skb_realloc_headroom(skb, HCI_HEADER_SIZE);
if (!skb2)
return -ENOMEM;
if (skb->sk)
skb_set_owner_w(skb2, skb->sk);
kfree_skb(skb);
skb = skb2;
}
skb_push(skb, HCI_HEADER_SIZE);
hci->cmd_evt = cpu_to_be16(WIMAX_TX_SDU);
hci->length = cpu_to_be16(skb->len - HCI_HEADER_SIZE);
memcpy(skb->data, buf, HCI_HEADER_SIZE);
*pskb = skb;
return 0;
}
static inline struct evt_entry *alloc_event_entry(void)
{
return kmalloc(sizeof(struct evt_entry), GFP_ATOMIC);
}
static struct evt_entry *get_event_entry(void)
{
struct evt_entry *e;
if (list_empty(&wm_event.freeq)) {
e = alloc_event_entry();
} else {
e = list_entry(wm_event.freeq.next, struct evt_entry, list);
list_del(&e->list);
}
return e;
}
static void gdm_wimax_event_rcv(struct net_device *dev, u16 type, void *msg,
int len)
{
struct nic *nic = netdev_priv(dev);
u8 *buf = msg;
u16 hci_cmd = (buf[0] << 8) | buf[1];
u16 hci_len = (buf[2] << 8) | buf[3];
netdev_dbg(dev, "H=>D: 0x%04x(%d)\n", hci_cmd, hci_len);
gdm_wimax_send(nic, msg, len);
}
static void __gdm_wimax_event_send(struct work_struct *work)
{
int idx;
unsigned long flags;
struct evt_entry *e;
struct evt_entry *tmp;
spin_lock_irqsave(&wm_event.evt_lock, flags);
list_for_each_entry_safe(e, tmp, &wm_event.evtq, list) {
spin_unlock_irqrestore(&wm_event.evt_lock, flags);
if (sscanf(e->dev->name, "wm%d", &idx) == 1)
netlink_send(wm_event.sock, idx, 0, e->evt_data,
e->size);
spin_lock_irqsave(&wm_event.evt_lock, flags);
list_del(&e->list);
list_add_tail(&e->list, &wm_event.freeq);
}
spin_unlock_irqrestore(&wm_event.evt_lock, flags);
}
static int gdm_wimax_event_init(void)
{
if (!wm_event.ref_cnt) {
wm_event.sock = netlink_init(NETLINK_WIMAX,
gdm_wimax_event_rcv);
if (wm_event.sock) {
INIT_LIST_HEAD(&wm_event.evtq);
INIT_LIST_HEAD(&wm_event.freeq);
INIT_WORK(&wm_event.ws, __gdm_wimax_event_send);
spin_lock_init(&wm_event.evt_lock);
}
}
if (wm_event.sock) {
wm_event.ref_cnt++;
return 0;
}
pr_err("Creating WiMax Event netlink is failed\n");
return -1;
}
static void gdm_wimax_event_exit(void)
{
if (wm_event.sock && --wm_event.ref_cnt == 0) {
struct evt_entry *e, *temp;
unsigned long flags;
spin_lock_irqsave(&wm_event.evt_lock, flags);
list_for_each_entry_safe(e, temp, &wm_event.evtq, list) {
list_del(&e->list);
kfree(e);
}
list_for_each_entry_safe(e, temp, &wm_event.freeq, list) {
list_del(&e->list);
kfree(e);
}
spin_unlock_irqrestore(&wm_event.evt_lock, flags);
netlink_exit(wm_event.sock);
wm_event.sock = NULL;
}
}
static int gdm_wimax_event_send(struct net_device *dev, char *buf, int size)
{
struct evt_entry *e;
unsigned long flags;
u16 hci_cmd = ((u8)buf[0] << 8) | (u8)buf[1];
u16 hci_len = ((u8)buf[2] << 8) | (u8)buf[3];
netdev_dbg(dev, "D=>H: 0x%04x(%d)\n", hci_cmd, hci_len);
spin_lock_irqsave(&wm_event.evt_lock, flags);
e = get_event_entry();
if (!e) {
netdev_err(dev, "%s: No memory for event\n", __func__);
spin_unlock_irqrestore(&wm_event.evt_lock, flags);
return -ENOMEM;
}
e->dev = dev;
e->size = size;
memcpy(e->evt_data, buf, size);
list_add_tail(&e->list, &wm_event.evtq);
spin_unlock_irqrestore(&wm_event.evt_lock, flags);
schedule_work(&wm_event.ws);
return 0;
}
static void tx_complete(void *arg)
{
struct nic *nic = arg;
if (netif_queue_stopped(nic->netdev))
netif_wake_queue(nic->netdev);
}
int gdm_wimax_send_tx(struct sk_buff *skb, struct net_device *dev)
{
int ret = 0;
struct nic *nic = netdev_priv(dev);
ret = gdm_wimax_send_with_cb(nic, skb->data, skb->len, tx_complete,
nic);
if (ret == -ENOSPC) {
netif_stop_queue(dev);
ret = 0;
}
if (ret) {
skb_pull(skb, HCI_HEADER_SIZE);
return ret;
}
dev->stats.tx_packets++;
dev->stats.tx_bytes += skb->len - HCI_HEADER_SIZE;
kfree_skb(skb);
return ret;
}
static int gdm_wimax_tx(struct sk_buff *skb, struct net_device *dev)
{
int ret = 0;
ret = gdm_wimax_header(&skb);
if (ret < 0) {
skb_pull(skb, HCI_HEADER_SIZE);
return ret;
}
#if defined(CONFIG_WIMAX_GDM72XX_QOS)
ret = gdm_qos_send_hci_pkt(skb, dev);
#else
ret = gdm_wimax_send_tx(skb, dev);
#endif
return ret;
}
static int gdm_wimax_set_config(struct net_device *dev, struct ifmap *map)
{
if (dev->flags & IFF_UP)
return -EBUSY;
return 0;
}
static void __gdm_wimax_set_mac_addr(struct net_device *dev, char *mac_addr)
{
u16 hci_pkt_buf[32 / sizeof(u16)];
struct hci_s *hci = (struct hci_s *)hci_pkt_buf;
struct nic *nic = netdev_priv(dev);
/* Since dev is registered as a ethernet device,
* ether_setup has made dev->addr_len to be ETH_ALEN
*/
memcpy(dev->dev_addr, mac_addr, dev->addr_len);
/* Let lower layer know of this change by sending
* SetInformation(MAC Address)
*/
hci->cmd_evt = cpu_to_be16(WIMAX_SET_INFO);
hci->length = cpu_to_be16(8);
hci->data[0] = 0; /* T */
hci->data[1] = 6; /* L */
memcpy(&hci->data[2], mac_addr, dev->addr_len); /* V */
gdm_wimax_send(nic, hci, HCI_HEADER_SIZE + 8);
}
/* A driver function */
static int gdm_wimax_set_mac_addr(struct net_device *dev, void *p)
{
struct sockaddr *addr = p;
if (netif_running(dev))
return -EBUSY;
if (!is_valid_ether_addr(addr->sa_data))
return -EADDRNOTAVAIL;
__gdm_wimax_set_mac_addr(dev, addr->sa_data);
return 0;
}
static void gdm_wimax_ind_if_updown(struct net_device *dev, int if_up)
{
u16 buf[32 / sizeof(u16)];
struct hci_s *hci = (struct hci_s *)buf;
unsigned char up_down;
up_down = if_up ? WIMAX_IF_UP : WIMAX_IF_DOWN;
/* Indicate updating fsm */
hci->cmd_evt = cpu_to_be16(WIMAX_IF_UPDOWN);
hci->length = cpu_to_be16(sizeof(up_down));
hci->data[0] = up_down;
gdm_wimax_event_send(dev, (char *)hci, HCI_HEADER_SIZE +
sizeof(up_down));
}
static int gdm_wimax_open(struct net_device *dev)
{
struct nic *nic = netdev_priv(dev);
struct fsm_s *fsm = nic->sdk_data[SIOC_DATA_FSM].buf;
netif_start_queue(dev);
if (fsm && fsm->m_status != M_INIT)
gdm_wimax_ind_if_updown(dev, 1);
return 0;
}
static int gdm_wimax_close(struct net_device *dev)
{
struct nic *nic = netdev_priv(dev);
struct fsm_s *fsm = nic->sdk_data[SIOC_DATA_FSM].buf;
netif_stop_queue(dev);
if (fsm && fsm->m_status != M_INIT)
gdm_wimax_ind_if_updown(dev, 0);
return 0;
}
static void kdelete(void **buf)
{
if (buf && *buf) {
kfree(*buf);
*buf = NULL;
}
}
static int gdm_wimax_ioctl_get_data(struct udata_s *dst, struct data_s *src)
{
int size;
size = dst->size < src->size ? dst->size : src->size;
dst->size = size;
if (src->size) {
if (!dst->buf)
return -EINVAL;
if (copy_to_user(dst->buf, src->buf, size))
return -EFAULT;
}
return 0;
}
static int gdm_wimax_ioctl_set_data(struct data_s *dst, struct udata_s *src)
{
if (!src->size) {
dst->size = 0;
return 0;
}
if (!src->buf)
return -EINVAL;
if (!(dst->buf && dst->size == src->size)) {
kdelete(&dst->buf);
dst->buf = kmalloc(src->size, GFP_KERNEL);
if (!dst->buf)
return -ENOMEM;
}
if (copy_from_user(dst->buf, src->buf, src->size)) {
kdelete(&dst->buf);
return -EFAULT;
}
dst->size = src->size;
return 0;
}
static void gdm_wimax_cleanup_ioctl(struct net_device *dev)
{
struct nic *nic = netdev_priv(dev);
int i;
for (i = 0; i < SIOC_DATA_MAX; i++)
kdelete(&nic->sdk_data[i].buf);
}
static void gdm_wimax_ind_fsm_update(struct net_device *dev, struct fsm_s *fsm)
{
u16 buf[32 / sizeof(u16)];
struct hci_s *hci = (struct hci_s *)buf;
/* Indicate updating fsm */
hci->cmd_evt = cpu_to_be16(WIMAX_FSM_UPDATE);
hci->length = cpu_to_be16(sizeof(struct fsm_s));
memcpy(&hci->data[0], fsm, sizeof(struct fsm_s));
gdm_wimax_event_send(dev, (char *)hci,
HCI_HEADER_SIZE + sizeof(struct fsm_s));
}
static void gdm_update_fsm(struct net_device *dev, struct fsm_s *new_fsm)
{
struct nic *nic = netdev_priv(dev);
struct fsm_s *cur_fsm =
nic->sdk_data[SIOC_DATA_FSM].buf;
if (!cur_fsm)
return;
if (cur_fsm->m_status != new_fsm->m_status ||
cur_fsm->c_status != new_fsm->c_status) {
if (new_fsm->m_status == M_CONNECTED) {
netif_carrier_on(dev);
} else if (cur_fsm->m_status == M_CONNECTED) {
netif_carrier_off(dev);
#if defined(CONFIG_WIMAX_GDM72XX_QOS)
gdm_qos_release_list(nic);
#endif
}
gdm_wimax_ind_fsm_update(dev, new_fsm);
}
}
static int gdm_wimax_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
struct wm_req_s *req = (struct wm_req_s *)ifr;
struct nic *nic = netdev_priv(dev);
int ret;
struct fsm_s fsm_buf;
if (cmd != SIOCWMIOCTL)
return -EOPNOTSUPP;
switch (req->cmd) {
case SIOCG_DATA:
case SIOCS_DATA:
if (req->data_id >= SIOC_DATA_MAX) {
netdev_err(dev, "%s error: data-index(%d) is invalid!!\n",
__func__, req->data_id);
return -EOPNOTSUPP;
}
if (req->cmd == SIOCG_DATA) {
ret = gdm_wimax_ioctl_get_data(
&req->data, &nic->sdk_data[req->data_id]);
if (ret < 0)
return ret;
} else if (req->cmd == SIOCS_DATA) {
if (req->data_id == SIOC_DATA_FSM) {
/* NOTE: gdm_update_fsm should be called
* before gdm_wimax_ioctl_set_data is called.
*/
if (copy_from_user(&fsm_buf, req->data.buf,
sizeof(struct fsm_s)))
return -EFAULT;
gdm_update_fsm(dev, &fsm_buf);
}
ret = gdm_wimax_ioctl_set_data(
&nic->sdk_data[req->data_id], &req->data);
if (ret < 0)
return ret;
}
break;
default:
netdev_err(dev, "%s: %x unknown ioctl\n", __func__, cmd);
return -EOPNOTSUPP;
}
return 0;
}
static void gdm_wimax_prepare_device(struct net_device *dev)
{
struct nic *nic = netdev_priv(dev);
u16 buf[32 / sizeof(u16)];
struct hci_s *hci = (struct hci_s *)buf;
u16 len = 0;
u32 val = 0;
__be32 val_be32;
/* GetInformation mac address */
len = 0;
hci->cmd_evt = cpu_to_be16(WIMAX_GET_INFO);
hci->data[len++] = TLV_T(T_MAC_ADDRESS);
hci->length = cpu_to_be16(len);
gdm_wimax_send(nic, hci, HCI_HEADER_SIZE + len);
val = T_CAPABILITY_WIMAX | T_CAPABILITY_MULTI_CS;
#if defined(CONFIG_WIMAX_GDM72XX_QOS)
val |= T_CAPABILITY_QOS;
#endif
#if defined(CONFIG_WIMAX_GDM72XX_WIMAX2)
val |= T_CAPABILITY_AGGREGATION;
#endif
/* Set capability */
len = 0;
hci->cmd_evt = cpu_to_be16(WIMAX_SET_INFO);
hci->data[len++] = TLV_T(T_CAPABILITY);
hci->data[len++] = TLV_L(T_CAPABILITY);
val_be32 = cpu_to_be32(val);
memcpy(&hci->data[len], &val_be32, TLV_L(T_CAPABILITY));
len += TLV_L(T_CAPABILITY);
hci->length = cpu_to_be16(len);
gdm_wimax_send(nic, hci, HCI_HEADER_SIZE + len);
netdev_info(dev, "GDM WiMax Set CAPABILITY: 0x%08X\n", val);
}
static int gdm_wimax_hci_get_tlv(u8 *buf, u8 *T, u16 *L, u8 **V)
{
#define __U82U16(b) ((u16)((u8 *)(b))[0] | ((u16)((u8 *)(b))[1] << 8))
int next_pos;
*T = buf[0];
if (buf[1] == 0x82) {
*L = be16_to_cpu(__U82U16(&buf[2]));
next_pos = 1/*type*/ + 3/*len*/;
} else {
*L = buf[1];
next_pos = 1/*type*/ + 1/*len*/;
}
*V = &buf[next_pos];
next_pos += *L/*length of val*/;
return next_pos;
}
static int gdm_wimax_get_prepared_info(struct net_device *dev, char *buf,
int len)
{
u8 T, *V;
u16 L;
u16 cmd_evt, cmd_len;
int pos = HCI_HEADER_SIZE;
cmd_evt = be16_to_cpup((const __be16 *)&buf[0]);
cmd_len = be16_to_cpup((const __be16 *)&buf[2]);
if (len < cmd_len + HCI_HEADER_SIZE) {
netdev_err(dev, "%s: invalid length [%d/%d]\n", __func__,
cmd_len + HCI_HEADER_SIZE, len);
return -1;
}
if (cmd_evt == WIMAX_GET_INFO_RESULT) {
if (cmd_len < 2) {
netdev_err(dev, "%s: len is too short [%x/%d]\n",
__func__, cmd_evt, len);
return -1;
}
pos += gdm_wimax_hci_get_tlv(&buf[pos], &T, &L, &V);
if (TLV_T(T_MAC_ADDRESS) == T) {
if (dev->addr_len != L) {
netdev_err(dev,
"%s Invalid information result T/L [%x/%d]\n",
__func__, T, L);
return -1;
}
netdev_info(dev, "MAC change [%pM]->[%pM]\n",
dev->dev_addr, V);
memcpy(dev->dev_addr, V, dev->addr_len);
return 1;
}
}
gdm_wimax_event_send(dev, buf, len);
return 0;
}
static void gdm_wimax_netif_rx(struct net_device *dev, char *buf, int len)
{
struct sk_buff *skb;
int ret;
skb = dev_alloc_skb(len + 2);
if (!skb)
return;
skb_reserve(skb, 2);
dev->stats.rx_packets++;
dev->stats.rx_bytes += len;
memcpy(skb_put(skb, len), buf, len);
skb->dev = dev;
skb->protocol = eth_type_trans(skb, dev); /* what will happen? */
ret = in_interrupt() ? netif_rx(skb) : netif_rx_ni(skb);
if (ret == NET_RX_DROP)
netdev_err(dev, "%s skb dropped\n", __func__);
}
static void gdm_wimax_transmit_aggr_pkt(struct net_device *dev, char *buf,
int len)
{
#define HCI_PADDING_BYTE 4
#define HCI_RESERVED_BYTE 4
struct hci_s *hci;
int length;
while (len > 0) {
hci = (struct hci_s *)buf;
if (hci->cmd_evt != cpu_to_be16(WIMAX_RX_SDU)) {
netdev_err(dev, "Wrong cmd_evt(0x%04X)\n",
be16_to_cpu(hci->cmd_evt));
break;
}
length = be16_to_cpu(hci->length);
gdm_wimax_netif_rx(dev, hci->data, length);
if (length & 0x3) {
/* Add padding size */
length += HCI_PADDING_BYTE - (length & 0x3);
}
length += HCI_HEADER_SIZE + HCI_RESERVED_BYTE;
len -= length;
buf += length;
}
}
static void gdm_wimax_transmit_pkt(struct net_device *dev, char *buf, int len)
{
#if defined(CONFIG_WIMAX_GDM72XX_QOS)
struct nic *nic = netdev_priv(dev);
#endif
u16 cmd_evt, cmd_len;
/* This code is added for certain rx packet to be ignored. */
if (len == 0)
return;
cmd_evt = be16_to_cpup((const __be16 *)&buf[0]);
cmd_len = be16_to_cpup((const __be16 *)&buf[2]);
if (len < cmd_len + HCI_HEADER_SIZE) {
netdev_err(dev, "%s: invalid length [%d/%d]\n",
__func__, cmd_len + HCI_HEADER_SIZE, len);
return;
}
switch (cmd_evt) {
case WIMAX_RX_SDU_AGGR:
gdm_wimax_transmit_aggr_pkt(dev, &buf[HCI_HEADER_SIZE],
cmd_len);
break;
case WIMAX_RX_SDU:
gdm_wimax_netif_rx(dev, &buf[HCI_HEADER_SIZE], cmd_len);
break;
#if defined(CONFIG_WIMAX_GDM72XX_QOS)
case WIMAX_EVT_MODEM_REPORT:
gdm_recv_qos_hci_packet(nic, buf, len);
break;
#endif
case WIMAX_SDU_TX_FLOW:
if (buf[4] == 0) {
if (!netif_queue_stopped(dev))
netif_stop_queue(dev);
} else if (buf[4] == 1) {
if (netif_queue_stopped(dev))
netif_wake_queue(dev);
}
break;
default:
gdm_wimax_event_send(dev, buf, len);
break;
}
}
static void rx_complete(void *arg, void *data, size_t len)
{
struct nic *nic = arg;
gdm_wimax_transmit_pkt(nic->netdev, data, len);
gdm_wimax_rcv_with_cb(nic, rx_complete, nic);
}
static void prepare_rx_complete(void *arg, void *data, size_t len)
{
struct nic *nic = arg;
int ret;
ret = gdm_wimax_get_prepared_info(nic->netdev, data, len);
if (ret == 1) {
gdm_wimax_rcv_with_cb(nic, rx_complete, nic);
} else {
if (ret < 0)
netdev_err(nic->netdev,
"get_prepared_info failed(%d)\n", ret);
gdm_wimax_rcv_with_cb(nic, prepare_rx_complete, nic);
}
}
static void start_rx_proc(struct nic *nic)
{
gdm_wimax_rcv_with_cb(nic, prepare_rx_complete, nic);
}
static struct net_device_ops gdm_netdev_ops = {
.ndo_open = gdm_wimax_open,
.ndo_stop = gdm_wimax_close,
.ndo_set_config = gdm_wimax_set_config,
.ndo_start_xmit = gdm_wimax_tx,
.ndo_set_mac_address = gdm_wimax_set_mac_addr,
.ndo_do_ioctl = gdm_wimax_ioctl,
};
int register_wimax_device(struct phy_dev *phy_dev, struct device *pdev)
{
struct nic *nic = NULL;
struct net_device *dev;
int ret;
dev = alloc_netdev(sizeof(*nic), "wm%d", NET_NAME_UNKNOWN,
ether_setup);
if (!dev) {
pr_err("alloc_etherdev failed\n");
return -ENOMEM;
}
SET_NETDEV_DEV(dev, pdev);
dev->mtu = 1400;
dev->netdev_ops = &gdm_netdev_ops;
dev->flags &= ~IFF_MULTICAST;
memcpy(dev->dev_addr, gdm_wimax_macaddr, sizeof(gdm_wimax_macaddr));
nic = netdev_priv(dev);
nic->netdev = dev;
nic->phy_dev = phy_dev;
phy_dev->netdev = dev;
/* event socket init */
ret = gdm_wimax_event_init();
if (ret < 0) {
pr_err("Cannot create event.\n");
goto cleanup;
}
ret = register_netdev(dev);
if (ret)
goto cleanup;
netif_carrier_off(dev);
#ifdef CONFIG_WIMAX_GDM72XX_QOS
gdm_qos_init(nic);
#endif
start_rx_proc(nic);
/* Prepare WiMax device */
gdm_wimax_prepare_device(dev);
return 0;
cleanup:
pr_err("register_netdev failed\n");
free_netdev(dev);
return ret;
}
void unregister_wimax_device(struct phy_dev *phy_dev)
{
struct nic *nic = netdev_priv(phy_dev->netdev);
struct fsm_s *fsm = nic->sdk_data[SIOC_DATA_FSM].buf;
if (fsm)
fsm->m_status = M_INIT;
unregister_netdev(nic->netdev);
gdm_wimax_event_exit();
#if defined(CONFIG_WIMAX_GDM72XX_QOS)
gdm_qos_release_list(nic);
#endif
gdm_wimax_cleanup_ioctl(phy_dev->netdev);
free_netdev(nic->netdev);
}

49
drivers/staging/gdm72xx/gdm_wimax.h
View file

@ -1,49 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __GDM72XX_GDM_WIMAX_H__
#define __GDM72XX_GDM_WIMAX_H__
#include <linux/netdevice.h>
#include <linux/types.h>
#include "wm_ioctl.h"
#if defined(CONFIG_WIMAX_GDM72XX_QOS)
#include "gdm_qos.h"
#endif
#define DRIVER_VERSION "3.2.3"
struct phy_dev {
void *priv_dev;
struct net_device *netdev;
int (*send_func)(void *priv_dev, void *data, size_t len,
void (*cb)(void *cb_data), void *cb_data);
int (*rcv_func)(void *priv_dev,
void (*cb)(void *cb_data, void *data, size_t len),
void *cb_data);
};
struct nic {
struct net_device *netdev;
struct phy_dev *phy_dev;
struct data_s sdk_data[SIOC_DATA_MAX];
#if defined(CONFIG_WIMAX_GDM72XX_QOS)
struct qos_cb_s qos;
#endif
};
int register_wimax_device(struct phy_dev *phy_dev, struct device *pdev);
int gdm_wimax_send_tx(struct sk_buff *skb, struct net_device *dev);
void unregister_wimax_device(struct phy_dev *phy_dev);
#endif /* __GDM72XX_GDM_WIMAX_H__ */

212
drivers/staging/gdm72xx/hci.h
View file

@ -1,212 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __GDM72XX_HCI_H__
#define __GDM72XX_HCI_H__
#define HCI_HEADER_SIZE 4
#define HCI_VALUE_OFFS (HCI_HEADER_SIZE)
#define HCI_MAX_PACKET 2048
#define HCI_MAX_PARAM (HCI_MAX_PACKET - HCI_HEADER_SIZE)
#define HCI_MAX_TLV 32
/* CMD-EVT */
/* Category 0 */
#define WIMAX_RESET 0x0000
#define WIMAX_SET_INFO 0x0001
#define WIMAX_GET_INFO 0x0002
#define WIMAX_GET_INFO_RESULT 0x8003
#define WIMAX_RADIO_OFF 0x0004
#define WIMAX_RADIO_ON 0x0006
#define WIMAX_WIMAX_RESET 0x0007 /* Is this still here */
/* Category 1 */
#define WIMAX_NET_ENTRY 0x0100
#define WIMAX_NET_DISCONN 0x0102
#define WIMAX_ENTER_SLEEP 0x0103
#define WIMAX_EXIT_SLEEP 0x0104
#define WIMAX_ENTER_IDLE 0x0105
#define WIMAX_EXIT_IDLE 0x0106
#define WIMAX_MODE_CHANGE 0x8108
#define WIMAX_HANDOVER 0x8109 /* obsolete */
#define WIMAX_SCAN 0x010d
#define WIMAX_SCAN_COMPLETE 0x810e
#define WIMAX_SCAN_RESULT 0x810f
#define WIMAX_CONNECT 0x0110
#define WIMAX_CONNECT_START 0x8111
#define WIMAX_CONNECT_COMPLETE 0x8112
#define WIMAX_ASSOC_START 0x8113
#define WIMAX_ASSOC_COMPLETE 0x8114
#define WIMAX_DISCONN_IND 0x8115
#define WIMAX_ENTRY_IND 0x8116
#define WIMAX_HO_START 0x8117
#define WIMAX_HO_COMPLETE 0x8118
#define WIMAX_RADIO_STATE_IND 0x8119
#define WIMAX_IP_RENEW_IND 0x811a
#define WIMAX_DISCOVER_NSP 0x011d
#define WIMAX_DISCOVER_NSP_RESULT 0x811e
#define WIMAX_SDU_TX_FLOW 0x8125
/* Category 2 */
#define WIMAX_TX_EAP 0x0200
#define WIMAX_RX_EAP 0x8201
#define WIMAX_TX_SDU 0x0202
#define WIMAX_RX_SDU 0x8203
#define WIMAX_RX_SDU_AGGR 0x8204
#define WIMAX_TX_SDU_AGGR 0x0205
/* Category 3 */
#define WIMAX_DM_CMD 0x030a
#define WIMAX_DM_RSP 0x830b
#define WIMAX_CLI_CMD 0x030c
#define WIMAX_CLI_RSP 0x830d
#define WIMAX_DL_IMAGE 0x0310
#define WIMAX_DL_IMAGE_STATUS 0x8311
#define WIMAX_UL_IMAGE 0x0312
#define WIMAX_UL_IMAGE_RESULT 0x8313
#define WIMAX_UL_IMAGE_STATUS 0x0314
#define WIMAX_EVT_MODEM_REPORT 0x8325
/* Category 0xF */
#define WIMAX_FSM_UPDATE 0x8F01
#define WIMAX_IF_UPDOWN 0x8F02
#define WIMAX_IF_UP 1
#define WIMAX_IF_DOWN 2
/* WIMAX mode */
#define W_NULL 0
#define W_STANDBY 1
#define W_OOZ 2
#define W_AWAKE 3
#define W_IDLE 4
#define W_SLEEP 5
#define W_WAIT 6
#define W_NET_ENTRY_RNG 0x80
#define W_NET_ENTRY_SBC 0x81
#define W_NET_ENTRY_PKM 0x82
#define W_NET_ENTRY_REG 0x83
#define W_NET_ENTRY_DSX 0x84
#define W_NET_ENTRY_RNG_FAIL 0x1100100
#define W_NET_ENTRY_SBC_FAIL 0x1100200
#define W_NET_ENTRY_PKM_FAIL 0x1102000
#define W_NET_ENTRY_REG_FAIL 0x1103000
#define W_NET_ENTRY_DSX_FAIL 0x1104000
/* Scan Type */
#define W_SCAN_ALL_CHANNEL 0
#define W_SCAN_ALL_SUBSCRIPTION 1
#define W_SCAN_SPECIFIED_SUBSCRIPTION 2
/* TLV
*
* [31:31] indicates the type is composite.
* [30:16] is the length of the type. 0 length means length is variable.
* [15:0] is the actual type.
*/
#define TLV_L(x) (((x) >> 16) & 0xff)
#define TLV_T(x) ((x) & 0xff)
#define TLV_COMPOSITE(x) ((x) >> 31)
/* GENERAL */
#define T_MAC_ADDRESS (0x00 | (6 << 16))
#define T_BSID (0x01 | (6 << 16))
#define T_MSK (0x02 | (64 << 16))
#define T_RSSI_THRSHLD (0x03 | (1 << 16))
#define T_FREQUENCY (0x04 | (4 << 16))
#define T_CONN_CS_TYPE (0x05 | (1 << 16))
#define T_HOST_IP_VER (0x06 | (1 << 16))
#define T_STBY_SCAN_INTERVAL (0x07 | (4 << 16))
#define T_OOZ_SCAN_INTERVAL (0x08 | (4 << 16))
#define T_IMEI (0x09 | (8 << 16))
#define T_PID (0x0a | (12 << 16))
#define T_CAPABILITY (0x1a | (4 << 16))
#define T_RELEASE_NUMBER (0x1b | (4 << 16))
#define T_DRIVER_REVISION (0x1c | (4 << 16))
#define T_FW_REVISION (0x1d | (4 << 16))
#define T_MAC_HW_REVISION (0x1e | (4 << 16))
#define T_PHY_HW_REVISION (0x1f | (4 << 16))
/* HANDOVER */
#define T_SCAN_INTERVAL (0x20 | (1 << 16))
#define T_RSC_RETAIN_TIME (0x2f | (2 << 16))
/* SLEEP */
#define T_TYPE1_ISW (0x40 | (1 << 16))
#define T_SLP_START_TO (0x4a | (2 << 16))
/* IDLE */
#define T_IDLE_MODE_TO (0x50 | (2 << 16))
#define T_IDLE_START_TO (0x54 | (2 << 16))
/* MONITOR */
#define T_RSSI (0x60 | (1 << 16))
#define T_CINR (0x61 | (1 << 16))
#define T_TX_POWER (0x6a | (1 << 16))
#define T_CUR_FREQ (0x7f | (4 << 16))
/* WIMAX */
#define T_MAX_SUBSCRIPTION (0xa1 | (1 << 16))
#define T_MAX_SF (0xa2 | (1 << 16))
#define T_PHY_TYPE (0xa3 | (1 << 16))
#define T_PKM (0xa4 | (1 << 16))
#define T_AUTH_POLICY (0xa5 | (1 << 16))
#define T_CS_TYPE (0xa6 | (2 << 16))
#define T_VENDOR_NAME (0xa7 | (0 << 16))
#define T_MOD_NAME (0xa8 | (0 << 16))
#define T_PACKET_FILTER (0xa9 | (1 << 16))
#define T_NSP_CHANGE_COUNT (0xaa | (4 << 16))
#define T_RADIO_STATE (0xab | (1 << 16))
#define T_URI_CONTACT_TYPE (0xac | (1 << 16))
#define T_URI_TEXT (0xad | (0 << 16))
#define T_URI (0xae | (0 << 16))
#define T_ENABLE_AUTH (0xaf | (1 << 16))
#define T_TIMEOUT (0xb0 | (2 << 16))
#define T_RUN_MODE (0xb1 | (1 << 16))
#define T_OMADMT_VER (0xb2 | (4 << 16))
/* This is measured in seconds from 00:00:00 GMT January 1, 1970. */
#define T_RTC_TIME (0xb3 | (4 << 16))
#define T_CERT_STATUS (0xb4 | (4 << 16))
#define T_CERT_MASK (0xb5 | (4 << 16))
#define T_EMSK (0xb6 | (64 << 16))
/* Subscription TLV */
#define T_SUBSCRIPTION_LIST (0xd1 | (0 << 16) | (1 << 31))
#define T_H_NSPID (0xd2 | (3 << 16))
#define T_NSP_NAME (0xd3 | (0 << 16))
#define T_SUBSCRIPTION_NAME (0xd4 | (0 << 16))
#define T_SUBSCRIPTION_FLAG (0xd5 | (2 << 16))
#define T_V_NSPID (0xd6 | (3 << 16))
#define T_NAP_ID (0xd7 | (3 << 16))
#define T_PREAMBLES (0xd8 | (15 << 16))
#define T_BW (0xd9 | (4 << 16))
#define T_FFTSIZE (0xda | (4 << 16))
#define T_DUPLEX_MODE (0xdb | (4 << 16))
/* T_CAPABILITY */
#define T_CAPABILITY_MULTI_CS BIT(0)
#define T_CAPABILITY_WIMAX BIT(1)
#define T_CAPABILITY_QOS BIT(2)
#define T_CAPABILITY_AGGREGATION BIT(3)
struct hci_s {
__be16 cmd_evt;
__be16 length;
u8 data[0];
} __packed;
#endif /* __GDM72XX_HCI_H__ */

156
drivers/staging/gdm72xx/netlink_k.c
View file

@ -1,156 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/module.h>
#include <linux/etherdevice.h>
#include <net/netlink.h>
#include <asm/byteorder.h>
#include <net/sock.h>
#include "netlink_k.h"
#if !defined(NLMSG_HDRLEN)
#define NLMSG_HDRLEN ((int)NLMSG_ALIGN(sizeof(struct nlmsghdr)))
#endif
#define ND_MAX_GROUP 30
#define ND_IFINDEX_LEN sizeof(int)
#define ND_NLMSG_SPACE(len) (nlmsg_total_size(len) + ND_IFINDEX_LEN)
#define ND_NLMSG_DATA(nlh) \
((void *)((char *)nlmsg_data(nlh) + ND_IFINDEX_LEN))
#define ND_NLMSG_S_LEN(len) (len + ND_IFINDEX_LEN)
#define ND_NLMSG_R_LEN(nlh) (nlh->nlmsg_len - ND_IFINDEX_LEN)
#define ND_NLMSG_IFIDX(nlh) nlmsg_data(nlh)
#define ND_MAX_MSG_LEN 8096
#if defined(DEFINE_MUTEX)
static DEFINE_MUTEX(netlink_mutex);
#else
static struct semaphore netlink_mutex;
#define mutex_lock(x) down(x)
#define mutex_unlock(x) up(x)
#endif
static void (*rcv_cb)(struct net_device *dev, u16 type, void *msg, int len);
static void netlink_rcv_cb(struct sk_buff *skb)
{
struct nlmsghdr *nlh;
struct net_device *dev;
u32 mlen;
void *msg;
int ifindex;
if (skb->len >= NLMSG_HDRLEN) {
nlh = (struct nlmsghdr *)skb->data;
if (nlh->nlmsg_len < ND_IFINDEX_LEN ||
nlh->nlmsg_len > skb->len ||
nlh->nlmsg_len > ND_MAX_MSG_LEN) {
netdev_err(skb->dev, "Invalid length (%d,%d)\n",
skb->len, nlh->nlmsg_len);
return;
}
memcpy(&ifindex, ND_NLMSG_IFIDX(nlh), ND_IFINDEX_LEN);
msg = ND_NLMSG_DATA(nlh);
mlen = ND_NLMSG_R_LEN(nlh);
if (rcv_cb) {
dev = dev_get_by_index(&init_net, ifindex);
if (dev) {
rcv_cb(dev, nlh->nlmsg_type, msg, mlen);
dev_put(dev);
} else
netdev_err(skb->dev,
"dev_get_by_index(%d) is not found.\n",
ifindex);
} else {
netdev_err(skb->dev, "Unregistered Callback\n");
}
}
}
static void netlink_rcv(struct sk_buff *skb)
{
mutex_lock(&netlink_mutex);
netlink_rcv_cb(skb);
mutex_unlock(&netlink_mutex);
}
struct sock *netlink_init(int unit, void (*cb)(struct net_device *dev, u16 type,
void *msg, int len))
{
struct sock *sock;
struct netlink_kernel_cfg cfg = {
.input = netlink_rcv,
};
#if !defined(DEFINE_MUTEX)
init_MUTEX(&netlink_mutex);
#endif
sock = netlink_kernel_create(&init_net, unit, &cfg);
if (sock)
rcv_cb = cb;
return sock;
}
void netlink_exit(struct sock *sock)
{
netlink_kernel_release(sock);
}
int netlink_send(struct sock *sock, u16 group, u16 type, void *msg, int len)
{
static u32 seq;
struct sk_buff *skb = NULL;
struct nlmsghdr *nlh;
int ret = 0;
if (group > ND_MAX_GROUP) {
pr_err("Group %d is invalid.\n", group);
pr_err("Valid group is 0 ~ %d.\n", ND_MAX_GROUP);
return -EINVAL;
}
skb = nlmsg_new(len, GFP_ATOMIC);
if (!skb) {
pr_err("netlink_broadcast ret=%d\n", ret);
return -ENOMEM;
}
seq++;
nlh = nlmsg_put(skb, 0, seq, type, len, 0);
if (!nlh) {
kfree_skb(skb);
return -EMSGSIZE;
}
memcpy(nlmsg_data(nlh), msg, len);
NETLINK_CB(skb).portid = 0;
NETLINK_CB(skb).dst_group = 0;
ret = netlink_broadcast(sock, skb, 0, group + 1, GFP_ATOMIC);
if (!ret)
return len;
if (ret != -ESRCH) {
pr_err("netlink_broadcast g=%d, t=%d, l=%d, r=%d\n",
group, type, len, ret);
}
return 0;
}

25
drivers/staging/gdm72xx/netlink_k.h
View file

@ -1,25 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __GDM72XX_NETLINK_K_H__
#define __GDM72XX_NETLINK_K_H__
#include <linux/netdevice.h>
#include <net/sock.h>
struct sock *netlink_init(int unit, void (*cb)(struct net_device *dev, u16 type,
void *msg, int len));
void netlink_exit(struct sock *sock);
int netlink_send(struct sock *sock, u16 group, u16 type, void *msg, int len);
#endif /* __GDM72XX_NETLINK_K_H__ */

158
drivers/staging/gdm72xx/sdio_boot.c
View file

@ -1,158 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/mmc/core.h>
#include <linux/mmc/card.h>
#include <linux/mmc/sdio_func.h>
#include <linux/firmware.h>
#include "gdm_sdio.h"
#include "sdio_boot.h"
#define TYPE_A_HEADER_SIZE 4
#define TYPE_A_LOOKAHEAD_SIZE 16
#define YMEM0_SIZE 0x8000 /* 32kbytes */
#define DOWNLOAD_SIZE (YMEM0_SIZE - TYPE_A_HEADER_SIZE)
#define FW_DIR "gdm72xx/"
#define FW_KRN "gdmskrn.bin"
#define FW_RFS "gdmsrfs.bin"
static u8 *tx_buf;
static int ack_ready(struct sdio_func *func)
{
unsigned long wait = jiffies + HZ;
u8 val;
int ret;
while (time_before(jiffies, wait)) {
val = sdio_readb(func, 0x13, &ret);
if (val & 0x01)
return 1;
schedule();
}
return 0;
}
static int download_image(struct sdio_func *func, const char *img_name)
{
int ret = 0, len, pno;
u8 *buf = tx_buf;
loff_t pos = 0;
int img_len;
const struct firmware *firm;
ret = request_firmware(&firm, img_name, &func->dev);
if (ret < 0) {
dev_err(&func->dev,
"requesting firmware %s failed with error %d\n",
img_name, ret);
return ret;
}
buf = kmalloc(DOWNLOAD_SIZE + TYPE_A_HEADER_SIZE, GFP_KERNEL);
if (!buf)
return -ENOMEM;
img_len = firm->size;
if (img_len <= 0) {
ret = -1;
goto out;
}
pno = 0;
while (img_len > 0) {
if (img_len > DOWNLOAD_SIZE) {
len = DOWNLOAD_SIZE;
buf[3] = 0;
} else {
len = img_len; /* the last packet */
buf[3] = 2;
}
buf[0] = len & 0xff;
buf[1] = (len >> 8) & 0xff;
buf[2] = (len >> 16) & 0xff;
memcpy(buf + TYPE_A_HEADER_SIZE, firm->data + pos, len);
ret = sdio_memcpy_toio(func, 0, buf, len + TYPE_A_HEADER_SIZE);
if (ret < 0) {
dev_err(&func->dev,
"send image error: packet number = %d ret = %d\n",
pno, ret);
goto out;
}
if (buf[3] == 2) /* The last packet */
break;
if (!ack_ready(func)) {
ret = -EIO;
dev_err(&func->dev, "Ack is not ready.\n");
goto out;
}
ret = sdio_memcpy_fromio(func, buf, 0, TYPE_A_LOOKAHEAD_SIZE);
if (ret < 0) {
dev_err(&func->dev,
"receive ack error: packet number = %d ret = %d\n",
pno, ret);
goto out;
}
sdio_writeb(func, 0x01, 0x13, &ret);
sdio_writeb(func, 0x00, 0x10, &ret); /* PCRRT */
img_len -= DOWNLOAD_SIZE;
pos += DOWNLOAD_SIZE;
pno++;
}
out:
kfree(buf);
return ret;
}
int sdio_boot(struct sdio_func *func)
{
int ret;
const char *krn_name = FW_DIR FW_KRN;
const char *rfs_name = FW_DIR FW_RFS;
tx_buf = kmalloc(YMEM0_SIZE, GFP_KERNEL);
if (!tx_buf)
return -ENOMEM;
ret = download_image(func, krn_name);
if (ret)
goto restore_fs;
dev_info(&func->dev, "GCT: Kernel download success.\n");
ret = download_image(func, rfs_name);
if (ret)
goto restore_fs;
dev_info(&func->dev, "GCT: Filesystem download success.\n");
restore_fs:
kfree(tx_buf);
return ret;
}

21
drivers/staging/gdm72xx/sdio_boot.h
View file

@ -1,21 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __GDM72XX_SDIO_BOOT_H__
#define __GDM72XX_SDIO_BOOT_H__
struct sdio_func;
int sdio_boot(struct sdio_func *func);
#endif /* __GDM72XX_SDIO_BOOT_H__ */

361
drivers/staging/gdm72xx/usb_boot.c
View file

@ -1,361 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <linux/uaccess.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/usb.h>
#include <linux/unistd.h>
#include <linux/slab.h>
#include <linux/firmware.h>
#include <asm/byteorder.h>
#include "gdm_usb.h"
#include "usb_boot.h"
#define DN_KERNEL_MAGIC_NUMBER 0x10760001
#define DN_ROOTFS_MAGIC_NUMBER 0x10760002
#define DOWNLOAD_SIZE 1024
#define MAX_IMG_CNT 16
#define FW_DIR "gdm72xx/"
#define FW_UIMG "gdmuimg.bin"
#define FW_KERN "zImage"
#define FW_FS "ramdisk.jffs2"
struct dn_header {
__be32 magic_num;
__be32 file_size;
};
struct img_header {
u32 magic_code;
u32 count;
u32 len;
u32 offset[MAX_IMG_CNT];
char hostname[32];
char date[32];
};
struct fw_info {
u32 id;
u32 len;
u32 kernel_len;
u32 rootfs_len;
u32 kernel_offset;
u32 rootfs_offset;
u32 fw_ver;
u32 mac_ver;
char hostname[32];
char userid[16];
char date[32];
char user_desc[128];
};
static void array_le32_to_cpu(u32 *arr, int num)
{
int i;
for (i = 0; i < num; i++, arr++)
le32_to_cpus(arr);
}
static u8 *tx_buf;
static int gdm_wibro_send(struct usb_device *usbdev, void *data, int len)
{
int ret;
int actual;
ret = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), data, len,
&actual, 1000);
if (ret < 0) {
dev_err(&usbdev->dev, "Error : usb_bulk_msg ( result = %d )\n",
ret);
return ret;
}
return 0;
}
static int gdm_wibro_recv(struct usb_device *usbdev, void *data, int len)
{
int ret;
int actual;
ret = usb_bulk_msg(usbdev, usb_rcvbulkpipe(usbdev, 2), data, len,
&actual, 5000);
if (ret < 0) {
dev_err(&usbdev->dev,
"Error : usb_bulk_msg(recv) ( result = %d )\n", ret);
return ret;
}
return 0;
}
static int download_image(struct usb_device *usbdev,
const struct firmware *firm,
loff_t pos, u32 img_len, u32 magic_num)
{
struct dn_header h;
int ret = 0;
u32 size;
size = ALIGN(img_len, DOWNLOAD_SIZE);
h.magic_num = cpu_to_be32(magic_num);
h.file_size = cpu_to_be32(size);
ret = gdm_wibro_send(usbdev, &h, sizeof(h));
if (ret < 0)
return ret;
while (img_len > 0) {
if (img_len > DOWNLOAD_SIZE)
size = DOWNLOAD_SIZE;
else
size = img_len; /* the last chunk of data */
memcpy(tx_buf, firm->data + pos, size);
ret = gdm_wibro_send(usbdev, tx_buf, size);
if (ret < 0)
return ret;
img_len -= size;
pos += size;
}
return ret;
}
int usb_boot(struct usb_device *usbdev, u16 pid)
{
int i, ret = 0;
struct img_header hdr;
struct fw_info fw_info;
loff_t pos = 0;
char *img_name = FW_DIR FW_UIMG;
const struct firmware *firm;
ret = request_firmware(&firm, img_name, &usbdev->dev);
if (ret < 0) {
dev_err(&usbdev->dev,
"requesting firmware %s failed with error %d\n",
img_name, ret);
return ret;
}
tx_buf = kmalloc(DOWNLOAD_SIZE, GFP_KERNEL);
if (!tx_buf) {
release_firmware(firm);
return -ENOMEM;
}
if (firm->size < sizeof(hdr)) {
dev_err(&usbdev->dev, "Cannot read the image info.\n");
ret = -EIO;
goto out;
}
memcpy(&hdr, firm->data, sizeof(hdr));
array_le32_to_cpu((u32 *)&hdr, 19);
if (hdr.count > MAX_IMG_CNT) {
dev_err(&usbdev->dev, "Too many images. %d\n", hdr.count);
ret = -EINVAL;
goto out;
}
for (i = 0; i < hdr.count; i++) {
if (hdr.offset[i] > hdr.len) {
dev_err(&usbdev->dev,
"Invalid offset. Entry = %d Offset = 0x%08x Image length = 0x%08x\n",
i, hdr.offset[i], hdr.len);
ret = -EINVAL;
goto out;
}
pos = hdr.offset[i];
if (firm->size < sizeof(fw_info) + pos) {
dev_err(&usbdev->dev, "Cannot read the FW info.\n");
ret = -EIO;
goto out;
}
memcpy(&fw_info, firm->data + pos, sizeof(fw_info));
array_le32_to_cpu((u32 *)&fw_info, 8);
if ((fw_info.id & 0xffff) != pid)
continue;
pos = hdr.offset[i] + fw_info.kernel_offset;
if (firm->size < fw_info.kernel_len + pos) {
dev_err(&usbdev->dev, "Kernel FW is too small.\n");
goto out;
}
ret = download_image(usbdev, firm, pos, fw_info.kernel_len,
DN_KERNEL_MAGIC_NUMBER);
if (ret < 0)
goto out;
dev_info(&usbdev->dev, "GCT: Kernel download success.\n");
pos = hdr.offset[i] + fw_info.rootfs_offset;
if (firm->size < fw_info.rootfs_len + pos) {
dev_err(&usbdev->dev, "Filesystem FW is too small.\n");
goto out;
}
ret = download_image(usbdev, firm, pos, fw_info.rootfs_len,
DN_ROOTFS_MAGIC_NUMBER);
if (ret < 0)
goto out;
dev_info(&usbdev->dev, "GCT: Filesystem download success.\n");
break;
}
if (i == hdr.count) {
dev_err(&usbdev->dev, "Firmware for gsk%x is not installed.\n",
pid);
ret = -EINVAL;
}
out:
release_firmware(firm);
kfree(tx_buf);
return ret;
}
/*#define GDM7205_PADDING 256 */
#define DOWNLOAD_CHUCK 2048
#define KERNEL_TYPE_STRING "linux"
#define FS_TYPE_STRING "rootfs"
static int em_wait_ack(struct usb_device *usbdev, int send_zlp)
{
int ack;
int ret = -1;
if (send_zlp) {
/*Send ZLP*/
ret = gdm_wibro_send(usbdev, NULL, 0);
if (ret < 0)
goto out;
}
/*Wait for ACK*/
ret = gdm_wibro_recv(usbdev, &ack, sizeof(ack));
if (ret < 0)
goto out;
out:
return ret;
}
static int em_download_image(struct usb_device *usbdev, const char *img_name,
char *type_string)
{
char *buf = NULL;
loff_t pos = 0;
int ret = 0;
int len;
int img_len;
const struct firmware *firm;
#if defined(GDM7205_PADDING)
const int pad_size = GDM7205_PADDING;
#else
const int pad_size = 0;
#endif
ret = request_firmware(&firm, img_name, &usbdev->dev);
if (ret < 0) {
dev_err(&usbdev->dev,
"requesting firmware %s failed with error %d\n",
img_name, ret);
return ret;
}
buf = kzalloc(DOWNLOAD_CHUCK + pad_size, GFP_KERNEL);
if (!buf) {
release_firmware(firm);
return -ENOMEM;
}
strcpy(buf + pad_size, type_string);
ret = gdm_wibro_send(usbdev, buf, strlen(type_string) + pad_size);
if (ret < 0)
goto out;
img_len = firm->size;
if (img_len <= 0) {
ret = -1;
goto out;
}
while (img_len > 0) {
if (img_len > DOWNLOAD_CHUCK)
len = DOWNLOAD_CHUCK;
else
len = img_len; /* the last chunk of data */
memcpy(buf + pad_size, firm->data + pos, len);
ret = gdm_wibro_send(usbdev, buf, len + pad_size);
if (ret < 0)
goto out;
img_len -= DOWNLOAD_CHUCK;
pos += DOWNLOAD_CHUCK;
ret = em_wait_ack(usbdev, ((len + pad_size) % 512 == 0));
if (ret < 0)
goto out;
}
ret = em_wait_ack(usbdev, 1);
if (ret < 0)
goto out;
out:
release_firmware(firm);
kfree(buf);
return ret;
}
static int em_fw_reset(struct usb_device *usbdev)
{
/*Send ZLP*/
return gdm_wibro_send(usbdev, NULL, 0);
}
int usb_emergency(struct usb_device *usbdev)
{
int ret;
const char *kern_name = FW_DIR FW_KERN;
const char *fs_name = FW_DIR FW_FS;
ret = em_download_image(usbdev, kern_name, KERNEL_TYPE_STRING);
if (ret < 0)
return ret;
dev_err(&usbdev->dev, "GCT Emergency: Kernel download success.\n");
ret = em_download_image(usbdev, fs_name, FS_TYPE_STRING);
if (ret < 0)
return ret;
dev_info(&usbdev->dev, "GCT Emergency: Filesystem download success.\n");
return em_fw_reset(usbdev);
}

22
drivers/staging/gdm72xx/usb_boot.h
View file

@ -1,22 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __GDM72XX_USB_BOOT_H__
#define __GDM72XX_USB_BOOT_H__
struct usb_device;
int usb_boot(struct usb_device *usbdev, u16 pid);
int usb_emergency(struct usb_device *usbdev);
#endif /* __GDM72XX_USB_BOOT_H__ */

86
drivers/staging/gdm72xx/usb_ids.h
View file

@ -1,86 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __GDM72XX_USB_IDS_H__
#define __GDM72XX_USB_IDS_H__
/*You can replace vendor-ID as yours.*/
#define GCT_VID 0x1076
/*You can replace product-ID as yours.*/
#define GCT_PID1 0x7e00
#define GCT_PID2 0x7f00
#define USB_DEVICE_ID_MATCH_DEVICE_INTERFACE \
(USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_INT_CLASS)
#define USB_DEVICE_INTF(vend, prod, intf) \
.match_flags = USB_DEVICE_ID_MATCH_DEVICE_INTERFACE, \
.idVendor = (vend), .idProduct = (prod), .bInterfaceClass = (intf)
#define EMERGENCY_PID 0x720f
#define BL_PID_MASK 0xffc0
#define USB_DEVICE_BOOTLOADER(vid, pid) \
{USB_DEVICE((vid), ((pid) & BL_PID_MASK) | B_DOWNLOAD)}
#define USB_DEVICE_BOOTLOADER_DRV(vid, pid) \
{USB_DEVICE((vid), ((pid) & BL_PID_MASK) | B_DOWNLOAD | B_DIFF_DL_DRV)}
#define USB_DEVICE_CDC_DATA(vid, pid) \
{USB_DEVICE_INTF((vid), (pid), USB_CLASS_CDC_DATA)}
static const struct usb_device_id id_table[] = {
USB_DEVICE_BOOTLOADER(GCT_VID, GCT_PID1),
USB_DEVICE_BOOTLOADER_DRV(GCT_VID, GCT_PID1),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0x1),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0x2),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0x3),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0x4),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0x5),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0x6),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0x7),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0x8),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0x9),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0xa),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0xb),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0xc),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0xd),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0xe),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID1 + 0xf),
USB_DEVICE_BOOTLOADER(GCT_VID, GCT_PID2),
USB_DEVICE_BOOTLOADER_DRV(GCT_VID, GCT_PID2),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0x1),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0x2),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0x3),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0x4),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0x5),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0x6),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0x7),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0x8),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0x9),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0xa),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0xb),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0xc),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0xd),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0xe),
USB_DEVICE_CDC_DATA(GCT_VID, GCT_PID2 + 0xf),
{USB_DEVICE(GCT_VID, EMERGENCY_PID)},
{ }
};
#endif /* __GDM72XX_USB_IDS_H__ */

101
drivers/staging/gdm72xx/wm_ioctl.h
View file

@ -1,101 +0,0 @@
/*
* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
* may be copied, distributed, and modified under those terms.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#ifndef __GDM72XX_WM_IOCTL_H__
#define __GDM72XX_WM_IOCTL_H__
#if !defined(__KERNEL__)
#include <net/if.h>
#endif
#define NETLINK_WIMAX 31
#define SIOCWMIOCTL SIOCDEVPRIVATE
#define SIOCG_DATA 0x8D10
#define SIOCS_DATA 0x8D11
enum {
SIOC_DATA_FSM,
SIOC_DATA_NETLIST,
SIOC_DATA_CONNNSP,
SIOC_DATA_CONNCOMP,
SIOC_DATA_PROFILEID,
SIOC_DATA_END
};
#define SIOC_DATA_MAX 16
/* FSM */
enum {
M_INIT = 0,
M_OPEN_OFF,
M_OPEN_ON,
M_SCAN,
M_CONNECTING,
M_CONNECTED,
M_FSM_END,
C_INIT = 0,
C_CONNSTART,
C_ASSOCSTART,
C_RNG,
C_SBC,
C_AUTH,
C_REG,
C_DSX,
C_ASSOCCOMPLETE,
C_CONNCOMPLETE,
C_FSM_END,
D_INIT = 0,
D_READY,
D_LISTEN,
D_IPACQUISITION,
END_FSM
};
struct fsm_s {
int m_status; /*main status*/
int c_status; /*connection status*/
int d_status; /*oma-dm status*/
};
struct data_s {
unsigned int size;
void *buf;
};
struct udata_s {
unsigned int size;
void __user *buf;
};
struct wm_req_s {
union {
char ifrn_name[IFNAMSIZ];
} ifr_ifrn;
unsigned short cmd;
unsigned short data_id;
struct udata_s data;
/* NOTE: sizeof(struct wm_req_s) must be less than sizeof(struct ifreq). */
};
#ifndef ifr_name
#define ifr_name ifr_ifrn.ifrn_name
#endif
#endif /* __GDM72XX_WM_IOCTL_H__ */