mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-23 14:32:56 +07:00
270d73c1c3
In the file au1k_ir.c & via-ircc.h, there were two unused definitions of the timeval type members, this commit therefore removes this unneeded code. In other three files, the same problem is the rx_time member is only ever written, never read, so removed it entirely. Signed-off-by: Chunyan Zhang <zhang.chunyan@linaro.org> Reviewed-by: Arnd Bergmann <arnd@arndb.de> Signed-off-by: David S. Miller <davem@davemloft.net>
635 lines
17 KiB
C
635 lines
17 KiB
C
/*****************************************************************************
|
|
*
|
|
* Filename: kingsun-sir.c
|
|
* Version: 0.1.1
|
|
* Description: Irda KingSun/DonShine USB Dongle
|
|
* Status: Experimental
|
|
* Author: Alex Villacís Lasso <a_villacis@palosanto.com>
|
|
*
|
|
* Based on stir4200 and mcs7780 drivers, with (strange?) differences
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License.
|
|
*
|
|
* 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.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
* This is my current (2007-04-25) understanding of how this dongle is supposed
|
|
* to work. This is based on reverse-engineering and examination of the packet
|
|
* data sent and received by the WinXP driver using USBSnoopy. Feel free to
|
|
* update here as more of this dongle is known:
|
|
*
|
|
* General: Unlike the other USB IrDA dongles, this particular dongle exposes,
|
|
* not two bulk (in and out) endpoints, but two *interrupt* ones. This dongle,
|
|
* like the bulk based ones (stir4200.c and mcs7780.c), requires polling in
|
|
* order to receive data.
|
|
* Transmission: Just like stir4200, this dongle uses a raw stream of data,
|
|
* which needs to be wrapped and escaped in a similar way as in stir4200.c.
|
|
* Reception: Poll-based, as in stir4200. Each read returns the contents of a
|
|
* 8-byte buffer, of which the first byte (LSB) indicates the number of bytes
|
|
* (1-7) of valid data contained within the remaining 7 bytes. For example, if
|
|
* the buffer had the following contents:
|
|
* 06 ff ff ff c0 01 04 aa
|
|
* This means that (06) there are 6 bytes of valid data. The byte 0xaa at the
|
|
* end is garbage (left over from a previous reception) and is discarded.
|
|
* If a read returns an "impossible" value as the length of valid data (such as
|
|
* 0x36) in the first byte, then the buffer is uninitialized (as is the case of
|
|
* first plug-in) and its contents should be discarded. There is currently no
|
|
* evidence that the top 5 bits of the 1st byte of the buffer can have values
|
|
* other than 0 once reception begins.
|
|
* Once valid bytes are collected, the assembled stream is a sequence of
|
|
* wrapped IrDA frames that is unwrapped and unescaped as in stir4200.c.
|
|
* BIG FAT WARNING: the dongle does *not* reset the RX buffer in any way after
|
|
* a successful read from the host, which means that in absence of further
|
|
* reception, repeated reads from the dongle will return the exact same
|
|
* contents repeatedly. Attempts to be smart and cache a previous read seem
|
|
* to result in corrupted packets, so this driver depends on the unwrap logic
|
|
* to sort out any repeated reads.
|
|
* Speed change: no commands observed so far to change speed, assumed fixed
|
|
* 9600bps (SIR).
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/moduleparam.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/types.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/usb.h>
|
|
#include <linux/device.h>
|
|
#include <linux/crc32.h>
|
|
|
|
#include <asm/unaligned.h>
|
|
#include <asm/byteorder.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <net/irda/irda.h>
|
|
#include <net/irda/wrapper.h>
|
|
#include <net/irda/crc.h>
|
|
|
|
/*
|
|
* According to lsusb, 0x07c0 is assigned to
|
|
* "Code Mercenaries Hard- und Software GmbH"
|
|
*/
|
|
#define KING_VENDOR_ID 0x07c0
|
|
#define KING_PRODUCT_ID 0x4200
|
|
|
|
/* These are the currently known USB ids */
|
|
static struct usb_device_id dongles[] = {
|
|
/* KingSun Co,Ltd IrDA/USB Bridge */
|
|
{ USB_DEVICE(KING_VENDOR_ID, KING_PRODUCT_ID) },
|
|
{ }
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(usb, dongles);
|
|
|
|
#define KINGSUN_MTT 0x07
|
|
|
|
#define KINGSUN_FIFO_SIZE 4096
|
|
#define KINGSUN_EP_IN 0
|
|
#define KINGSUN_EP_OUT 1
|
|
|
|
struct kingsun_cb {
|
|
struct usb_device *usbdev; /* init: probe_irda */
|
|
struct net_device *netdev; /* network layer */
|
|
struct irlap_cb *irlap; /* The link layer we are binded to */
|
|
|
|
struct qos_info qos;
|
|
|
|
__u8 *in_buf; /* receive buffer */
|
|
__u8 *out_buf; /* transmit buffer */
|
|
__u8 max_rx; /* max. atomic read from dongle
|
|
(usually 8), also size of in_buf */
|
|
__u8 max_tx; /* max. atomic write to dongle
|
|
(usually 8) */
|
|
|
|
iobuff_t rx_buff; /* receive unwrap state machine */
|
|
spinlock_t lock;
|
|
int receiving;
|
|
|
|
__u8 ep_in;
|
|
__u8 ep_out;
|
|
|
|
struct urb *tx_urb;
|
|
struct urb *rx_urb;
|
|
};
|
|
|
|
/* Callback transmission routine */
|
|
static void kingsun_send_irq(struct urb *urb)
|
|
{
|
|
struct kingsun_cb *kingsun = urb->context;
|
|
struct net_device *netdev = kingsun->netdev;
|
|
|
|
/* in process of stopping, just drop data */
|
|
if (!netif_running(kingsun->netdev)) {
|
|
dev_err(&kingsun->usbdev->dev,
|
|
"kingsun_send_irq: Network not running!\n");
|
|
return;
|
|
}
|
|
|
|
/* unlink, shutdown, unplug, other nasties */
|
|
if (urb->status != 0) {
|
|
dev_err(&kingsun->usbdev->dev,
|
|
"kingsun_send_irq: urb asynchronously failed - %d\n",
|
|
urb->status);
|
|
}
|
|
netif_wake_queue(netdev);
|
|
}
|
|
|
|
/*
|
|
* Called from net/core when new frame is available.
|
|
*/
|
|
static netdev_tx_t kingsun_hard_xmit(struct sk_buff *skb,
|
|
struct net_device *netdev)
|
|
{
|
|
struct kingsun_cb *kingsun;
|
|
int wraplen;
|
|
int ret = 0;
|
|
|
|
netif_stop_queue(netdev);
|
|
|
|
/* the IRDA wrapping routines don't deal with non linear skb */
|
|
SKB_LINEAR_ASSERT(skb);
|
|
|
|
kingsun = netdev_priv(netdev);
|
|
|
|
spin_lock(&kingsun->lock);
|
|
|
|
/* Append data to the end of whatever data remains to be transmitted */
|
|
wraplen = async_wrap_skb(skb,
|
|
kingsun->out_buf,
|
|
KINGSUN_FIFO_SIZE);
|
|
|
|
/* Calculate how much data can be transmitted in this urb */
|
|
usb_fill_int_urb(kingsun->tx_urb, kingsun->usbdev,
|
|
usb_sndintpipe(kingsun->usbdev, kingsun->ep_out),
|
|
kingsun->out_buf, wraplen, kingsun_send_irq,
|
|
kingsun, 1);
|
|
|
|
if ((ret = usb_submit_urb(kingsun->tx_urb, GFP_ATOMIC))) {
|
|
dev_err(&kingsun->usbdev->dev,
|
|
"kingsun_hard_xmit: failed tx_urb submit: %d\n", ret);
|
|
switch (ret) {
|
|
case -ENODEV:
|
|
case -EPIPE:
|
|
break;
|
|
default:
|
|
netdev->stats.tx_errors++;
|
|
netif_start_queue(netdev);
|
|
}
|
|
} else {
|
|
netdev->stats.tx_packets++;
|
|
netdev->stats.tx_bytes += skb->len;
|
|
}
|
|
|
|
dev_kfree_skb(skb);
|
|
spin_unlock(&kingsun->lock);
|
|
|
|
return NETDEV_TX_OK;
|
|
}
|
|
|
|
/* Receive callback function */
|
|
static void kingsun_rcv_irq(struct urb *urb)
|
|
{
|
|
struct kingsun_cb *kingsun = urb->context;
|
|
int ret;
|
|
|
|
/* in process of stopping, just drop data */
|
|
if (!netif_running(kingsun->netdev)) {
|
|
kingsun->receiving = 0;
|
|
return;
|
|
}
|
|
|
|
/* unlink, shutdown, unplug, other nasties */
|
|
if (urb->status != 0) {
|
|
dev_err(&kingsun->usbdev->dev,
|
|
"kingsun_rcv_irq: urb asynchronously failed - %d\n",
|
|
urb->status);
|
|
kingsun->receiving = 0;
|
|
return;
|
|
}
|
|
|
|
if (urb->actual_length == kingsun->max_rx) {
|
|
__u8 *bytes = urb->transfer_buffer;
|
|
int i;
|
|
|
|
/* The very first byte in the buffer indicates the length of
|
|
valid data in the read. This byte must be in the range
|
|
1..kingsun->max_rx -1 . Values outside this range indicate
|
|
an uninitialized Rx buffer when the dongle has just been
|
|
plugged in. */
|
|
if (bytes[0] >= 1 && bytes[0] < kingsun->max_rx) {
|
|
for (i = 1; i <= bytes[0]; i++) {
|
|
async_unwrap_char(kingsun->netdev,
|
|
&kingsun->netdev->stats,
|
|
&kingsun->rx_buff, bytes[i]);
|
|
}
|
|
kingsun->receiving =
|
|
(kingsun->rx_buff.state != OUTSIDE_FRAME)
|
|
? 1 : 0;
|
|
}
|
|
} else if (urb->actual_length > 0) {
|
|
dev_err(&kingsun->usbdev->dev,
|
|
"%s(): Unexpected response length, expected %d got %d\n",
|
|
__func__, kingsun->max_rx, urb->actual_length);
|
|
}
|
|
/* This urb has already been filled in kingsun_net_open */
|
|
ret = usb_submit_urb(urb, GFP_ATOMIC);
|
|
}
|
|
|
|
/*
|
|
* Function kingsun_net_open (dev)
|
|
*
|
|
* Network device is taken up. Usually this is done by "ifconfig irda0 up"
|
|
*/
|
|
static int kingsun_net_open(struct net_device *netdev)
|
|
{
|
|
struct kingsun_cb *kingsun = netdev_priv(netdev);
|
|
int err = -ENOMEM;
|
|
char hwname[16];
|
|
|
|
/* At this point, urbs are NULL, and skb is NULL (see kingsun_probe) */
|
|
kingsun->receiving = 0;
|
|
|
|
/* Initialize for SIR to copy data directly into skb. */
|
|
kingsun->rx_buff.in_frame = FALSE;
|
|
kingsun->rx_buff.state = OUTSIDE_FRAME;
|
|
kingsun->rx_buff.truesize = IRDA_SKB_MAX_MTU;
|
|
kingsun->rx_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);
|
|
if (!kingsun->rx_buff.skb)
|
|
goto free_mem;
|
|
|
|
skb_reserve(kingsun->rx_buff.skb, 1);
|
|
kingsun->rx_buff.head = kingsun->rx_buff.skb->data;
|
|
|
|
kingsun->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
|
|
if (!kingsun->rx_urb)
|
|
goto free_mem;
|
|
|
|
kingsun->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
|
|
if (!kingsun->tx_urb)
|
|
goto free_mem;
|
|
|
|
/*
|
|
* Now that everything should be initialized properly,
|
|
* Open new IrLAP layer instance to take care of us...
|
|
*/
|
|
sprintf(hwname, "usb#%d", kingsun->usbdev->devnum);
|
|
kingsun->irlap = irlap_open(netdev, &kingsun->qos, hwname);
|
|
if (!kingsun->irlap) {
|
|
dev_err(&kingsun->usbdev->dev, "irlap_open failed\n");
|
|
goto free_mem;
|
|
}
|
|
|
|
/* Start first reception */
|
|
usb_fill_int_urb(kingsun->rx_urb, kingsun->usbdev,
|
|
usb_rcvintpipe(kingsun->usbdev, kingsun->ep_in),
|
|
kingsun->in_buf, kingsun->max_rx,
|
|
kingsun_rcv_irq, kingsun, 1);
|
|
kingsun->rx_urb->status = 0;
|
|
err = usb_submit_urb(kingsun->rx_urb, GFP_KERNEL);
|
|
if (err) {
|
|
dev_err(&kingsun->usbdev->dev,
|
|
"first urb-submit failed: %d\n", err);
|
|
goto close_irlap;
|
|
}
|
|
|
|
netif_start_queue(netdev);
|
|
|
|
/* Situation at this point:
|
|
- all work buffers allocated
|
|
- urbs allocated and ready to fill
|
|
- max rx packet known (in max_rx)
|
|
- unwrap state machine initialized, in state outside of any frame
|
|
- receive request in progress
|
|
- IrLAP layer started, about to hand over packets to send
|
|
*/
|
|
|
|
return 0;
|
|
|
|
close_irlap:
|
|
irlap_close(kingsun->irlap);
|
|
free_mem:
|
|
if (kingsun->tx_urb) {
|
|
usb_free_urb(kingsun->tx_urb);
|
|
kingsun->tx_urb = NULL;
|
|
}
|
|
if (kingsun->rx_urb) {
|
|
usb_free_urb(kingsun->rx_urb);
|
|
kingsun->rx_urb = NULL;
|
|
}
|
|
if (kingsun->rx_buff.skb) {
|
|
kfree_skb(kingsun->rx_buff.skb);
|
|
kingsun->rx_buff.skb = NULL;
|
|
kingsun->rx_buff.head = NULL;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* Function kingsun_net_close (kingsun)
|
|
*
|
|
* Network device is taken down. Usually this is done by
|
|
* "ifconfig irda0 down"
|
|
*/
|
|
static int kingsun_net_close(struct net_device *netdev)
|
|
{
|
|
struct kingsun_cb *kingsun = netdev_priv(netdev);
|
|
|
|
/* Stop transmit processing */
|
|
netif_stop_queue(netdev);
|
|
|
|
/* Mop up receive && transmit urb's */
|
|
usb_kill_urb(kingsun->tx_urb);
|
|
usb_kill_urb(kingsun->rx_urb);
|
|
|
|
usb_free_urb(kingsun->tx_urb);
|
|
usb_free_urb(kingsun->rx_urb);
|
|
|
|
kingsun->tx_urb = NULL;
|
|
kingsun->rx_urb = NULL;
|
|
|
|
kfree_skb(kingsun->rx_buff.skb);
|
|
kingsun->rx_buff.skb = NULL;
|
|
kingsun->rx_buff.head = NULL;
|
|
kingsun->rx_buff.in_frame = FALSE;
|
|
kingsun->rx_buff.state = OUTSIDE_FRAME;
|
|
kingsun->receiving = 0;
|
|
|
|
/* Stop and remove instance of IrLAP */
|
|
if (kingsun->irlap)
|
|
irlap_close(kingsun->irlap);
|
|
|
|
kingsun->irlap = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* IOCTLs : Extra out-of-band network commands...
|
|
*/
|
|
static int kingsun_net_ioctl(struct net_device *netdev, struct ifreq *rq,
|
|
int cmd)
|
|
{
|
|
struct if_irda_req *irq = (struct if_irda_req *) rq;
|
|
struct kingsun_cb *kingsun = netdev_priv(netdev);
|
|
int ret = 0;
|
|
|
|
switch (cmd) {
|
|
case SIOCSBANDWIDTH: /* Set bandwidth */
|
|
if (!capable(CAP_NET_ADMIN))
|
|
return -EPERM;
|
|
|
|
/* Check if the device is still there */
|
|
if (netif_device_present(kingsun->netdev))
|
|
/* No observed commands for speed change */
|
|
ret = -EOPNOTSUPP;
|
|
break;
|
|
|
|
case SIOCSMEDIABUSY: /* Set media busy */
|
|
if (!capable(CAP_NET_ADMIN))
|
|
return -EPERM;
|
|
|
|
/* Check if the IrDA stack is still there */
|
|
if (netif_running(kingsun->netdev))
|
|
irda_device_set_media_busy(kingsun->netdev, TRUE);
|
|
break;
|
|
|
|
case SIOCGRECEIVING:
|
|
/* Only approximately true */
|
|
irq->ifr_receiving = kingsun->receiving;
|
|
break;
|
|
|
|
default:
|
|
ret = -EOPNOTSUPP;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static const struct net_device_ops kingsun_ops = {
|
|
.ndo_start_xmit = kingsun_hard_xmit,
|
|
.ndo_open = kingsun_net_open,
|
|
.ndo_stop = kingsun_net_close,
|
|
.ndo_do_ioctl = kingsun_net_ioctl,
|
|
};
|
|
|
|
/*
|
|
* This routine is called by the USB subsystem for each new device
|
|
* in the system. We need to check if the device is ours, and in
|
|
* this case start handling it.
|
|
*/
|
|
static int kingsun_probe(struct usb_interface *intf,
|
|
const struct usb_device_id *id)
|
|
{
|
|
struct usb_host_interface *interface;
|
|
struct usb_endpoint_descriptor *endpoint;
|
|
|
|
struct usb_device *dev = interface_to_usbdev(intf);
|
|
struct kingsun_cb *kingsun = NULL;
|
|
struct net_device *net = NULL;
|
|
int ret = -ENOMEM;
|
|
int pipe, maxp_in, maxp_out;
|
|
__u8 ep_in;
|
|
__u8 ep_out;
|
|
|
|
/* Check that there really are two interrupt endpoints.
|
|
Check based on the one in drivers/usb/input/usbmouse.c
|
|
*/
|
|
interface = intf->cur_altsetting;
|
|
if (interface->desc.bNumEndpoints != 2) {
|
|
dev_err(&intf->dev,
|
|
"kingsun-sir: expected 2 endpoints, found %d\n",
|
|
interface->desc.bNumEndpoints);
|
|
return -ENODEV;
|
|
}
|
|
endpoint = &interface->endpoint[KINGSUN_EP_IN].desc;
|
|
if (!usb_endpoint_is_int_in(endpoint)) {
|
|
dev_err(&intf->dev,
|
|
"kingsun-sir: endpoint 0 is not interrupt IN\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
ep_in = endpoint->bEndpointAddress;
|
|
pipe = usb_rcvintpipe(dev, ep_in);
|
|
maxp_in = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
|
|
if (maxp_in > 255 || maxp_in <= 1) {
|
|
dev_err(&intf->dev,
|
|
"endpoint 0 has max packet size %d not in range\n",
|
|
maxp_in);
|
|
return -ENODEV;
|
|
}
|
|
|
|
endpoint = &interface->endpoint[KINGSUN_EP_OUT].desc;
|
|
if (!usb_endpoint_is_int_out(endpoint)) {
|
|
dev_err(&intf->dev,
|
|
"kingsun-sir: endpoint 1 is not interrupt OUT\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
ep_out = endpoint->bEndpointAddress;
|
|
pipe = usb_sndintpipe(dev, ep_out);
|
|
maxp_out = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
|
|
|
|
/* Allocate network device container. */
|
|
net = alloc_irdadev(sizeof(*kingsun));
|
|
if(!net)
|
|
goto err_out1;
|
|
|
|
SET_NETDEV_DEV(net, &intf->dev);
|
|
kingsun = netdev_priv(net);
|
|
kingsun->irlap = NULL;
|
|
kingsun->tx_urb = NULL;
|
|
kingsun->rx_urb = NULL;
|
|
kingsun->ep_in = ep_in;
|
|
kingsun->ep_out = ep_out;
|
|
kingsun->in_buf = NULL;
|
|
kingsun->out_buf = NULL;
|
|
kingsun->max_rx = (__u8)maxp_in;
|
|
kingsun->max_tx = (__u8)maxp_out;
|
|
kingsun->netdev = net;
|
|
kingsun->usbdev = dev;
|
|
kingsun->rx_buff.in_frame = FALSE;
|
|
kingsun->rx_buff.state = OUTSIDE_FRAME;
|
|
kingsun->rx_buff.skb = NULL;
|
|
kingsun->receiving = 0;
|
|
spin_lock_init(&kingsun->lock);
|
|
|
|
/* Allocate input buffer */
|
|
kingsun->in_buf = kmalloc(kingsun->max_rx, GFP_KERNEL);
|
|
if (!kingsun->in_buf)
|
|
goto free_mem;
|
|
|
|
/* Allocate output buffer */
|
|
kingsun->out_buf = kmalloc(KINGSUN_FIFO_SIZE, GFP_KERNEL);
|
|
if (!kingsun->out_buf)
|
|
goto free_mem;
|
|
|
|
printk(KERN_INFO "KingSun/DonShine IRDA/USB found at address %d, "
|
|
"Vendor: %x, Product: %x\n",
|
|
dev->devnum, le16_to_cpu(dev->descriptor.idVendor),
|
|
le16_to_cpu(dev->descriptor.idProduct));
|
|
|
|
/* Initialize QoS for this device */
|
|
irda_init_max_qos_capabilies(&kingsun->qos);
|
|
|
|
/* That's the Rx capability. */
|
|
kingsun->qos.baud_rate.bits &= IR_9600;
|
|
kingsun->qos.min_turn_time.bits &= KINGSUN_MTT;
|
|
irda_qos_bits_to_value(&kingsun->qos);
|
|
|
|
/* Override the network functions we need to use */
|
|
net->netdev_ops = &kingsun_ops;
|
|
|
|
ret = register_netdev(net);
|
|
if (ret != 0)
|
|
goto free_mem;
|
|
|
|
dev_info(&net->dev, "IrDA: Registered KingSun/DonShine device %s\n",
|
|
net->name);
|
|
|
|
usb_set_intfdata(intf, kingsun);
|
|
|
|
/* Situation at this point:
|
|
- all work buffers allocated
|
|
- urbs not allocated, set to NULL
|
|
- max rx packet known (in max_rx)
|
|
- unwrap state machine (partially) initialized, but skb == NULL
|
|
*/
|
|
|
|
return 0;
|
|
|
|
free_mem:
|
|
kfree(kingsun->out_buf);
|
|
kfree(kingsun->in_buf);
|
|
free_netdev(net);
|
|
err_out1:
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* The current device is removed, the USB layer tell us to shut it down...
|
|
*/
|
|
static void kingsun_disconnect(struct usb_interface *intf)
|
|
{
|
|
struct kingsun_cb *kingsun = usb_get_intfdata(intf);
|
|
|
|
if (!kingsun)
|
|
return;
|
|
|
|
unregister_netdev(kingsun->netdev);
|
|
|
|
/* Mop up receive && transmit urb's */
|
|
if (kingsun->tx_urb != NULL) {
|
|
usb_kill_urb(kingsun->tx_urb);
|
|
usb_free_urb(kingsun->tx_urb);
|
|
kingsun->tx_urb = NULL;
|
|
}
|
|
if (kingsun->rx_urb != NULL) {
|
|
usb_kill_urb(kingsun->rx_urb);
|
|
usb_free_urb(kingsun->rx_urb);
|
|
kingsun->rx_urb = NULL;
|
|
}
|
|
|
|
kfree(kingsun->out_buf);
|
|
kfree(kingsun->in_buf);
|
|
free_netdev(kingsun->netdev);
|
|
|
|
usb_set_intfdata(intf, NULL);
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
/* USB suspend, so power off the transmitter/receiver */
|
|
static int kingsun_suspend(struct usb_interface *intf, pm_message_t message)
|
|
{
|
|
struct kingsun_cb *kingsun = usb_get_intfdata(intf);
|
|
|
|
netif_device_detach(kingsun->netdev);
|
|
if (kingsun->tx_urb != NULL) usb_kill_urb(kingsun->tx_urb);
|
|
if (kingsun->rx_urb != NULL) usb_kill_urb(kingsun->rx_urb);
|
|
return 0;
|
|
}
|
|
|
|
/* Coming out of suspend, so reset hardware */
|
|
static int kingsun_resume(struct usb_interface *intf)
|
|
{
|
|
struct kingsun_cb *kingsun = usb_get_intfdata(intf);
|
|
|
|
if (kingsun->rx_urb != NULL)
|
|
usb_submit_urb(kingsun->rx_urb, GFP_KERNEL);
|
|
netif_device_attach(kingsun->netdev);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* USB device callbacks
|
|
*/
|
|
static struct usb_driver irda_driver = {
|
|
.name = "kingsun-sir",
|
|
.probe = kingsun_probe,
|
|
.disconnect = kingsun_disconnect,
|
|
.id_table = dongles,
|
|
#ifdef CONFIG_PM
|
|
.suspend = kingsun_suspend,
|
|
.resume = kingsun_resume,
|
|
#endif
|
|
};
|
|
|
|
module_usb_driver(irda_driver);
|
|
|
|
MODULE_AUTHOR("Alex Villacís Lasso <a_villacis@palosanto.com>");
|
|
MODULE_DESCRIPTION("IrDA-USB Dongle Driver for KingSun/DonShine");
|
|
MODULE_LICENSE("GPL");
|