378 lines
9.6 KiB
C
378 lines
9.6 KiB
C
/*
|
|
* Driver for ST5481 USB ISDN modem
|
|
*
|
|
* Author Frode Isaksen
|
|
* Copyright 2001 by Frode Isaksen <fisaksen@bewan.com>
|
|
* 2001 by Kai Germaschewski <kai.germaschewski@gmx.de>
|
|
*
|
|
* This software may be used and distributed according to the terms
|
|
* of the GNU General Public License, incorporated herein by reference.
|
|
*
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/usb.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/bitrev.h>
|
|
#include "st5481.h"
|
|
|
|
static inline void B_L1L2(struct st5481_bcs *bcs, int pr, void *arg)
|
|
{
|
|
struct hisax_if *ifc = (struct hisax_if *) &bcs->b_if;
|
|
|
|
ifc->l1l2(ifc, pr, arg);
|
|
}
|
|
|
|
/*
|
|
* Encode and transmit next frame.
|
|
*/
|
|
static void usb_b_out(struct st5481_bcs *bcs,int buf_nr)
|
|
{
|
|
struct st5481_b_out *b_out = &bcs->b_out;
|
|
struct st5481_adapter *adapter = bcs->adapter;
|
|
struct urb *urb;
|
|
unsigned int packet_size,offset;
|
|
int len,buf_size,bytes_sent;
|
|
int i;
|
|
struct sk_buff *skb;
|
|
|
|
if (test_and_set_bit(buf_nr, &b_out->busy)) {
|
|
DBG(4,"ep %d urb %d busy",(bcs->channel+1)*2,buf_nr);
|
|
return;
|
|
}
|
|
urb = b_out->urb[buf_nr];
|
|
|
|
// Adjust isoc buffer size according to flow state
|
|
if(b_out->flow_event & (OUT_DOWN | OUT_UNDERRUN)) {
|
|
buf_size = NUM_ISO_PACKETS_B*SIZE_ISO_PACKETS_B_OUT + B_FLOW_ADJUST;
|
|
packet_size = SIZE_ISO_PACKETS_B_OUT + B_FLOW_ADJUST;
|
|
DBG(4,"B%d,adjust flow,add %d bytes",bcs->channel+1,B_FLOW_ADJUST);
|
|
} else if(b_out->flow_event & OUT_UP){
|
|
buf_size = NUM_ISO_PACKETS_B*SIZE_ISO_PACKETS_B_OUT - B_FLOW_ADJUST;
|
|
packet_size = SIZE_ISO_PACKETS_B_OUT - B_FLOW_ADJUST;
|
|
DBG(4,"B%d,adjust flow,remove %d bytes",bcs->channel+1,B_FLOW_ADJUST);
|
|
} else {
|
|
buf_size = NUM_ISO_PACKETS_B*SIZE_ISO_PACKETS_B_OUT;
|
|
packet_size = 8;
|
|
}
|
|
b_out->flow_event = 0;
|
|
|
|
len = 0;
|
|
while (len < buf_size) {
|
|
if ((skb = b_out->tx_skb)) {
|
|
DBG_SKB(0x100, skb);
|
|
DBG(4,"B%d,len=%d",bcs->channel+1,skb->len);
|
|
|
|
if (bcs->mode == L1_MODE_TRANS) {
|
|
bytes_sent = buf_size - len;
|
|
if (skb->len < bytes_sent)
|
|
bytes_sent = skb->len;
|
|
{ /* swap tx bytes to get hearable audio data */
|
|
register unsigned char *src = skb->data;
|
|
register unsigned char *dest = urb->transfer_buffer+len;
|
|
register unsigned int count;
|
|
for (count = 0; count < bytes_sent; count++)
|
|
*dest++ = bitrev8(*src++);
|
|
}
|
|
len += bytes_sent;
|
|
} else {
|
|
len += isdnhdlc_encode(&b_out->hdlc_state,
|
|
skb->data, skb->len, &bytes_sent,
|
|
urb->transfer_buffer+len, buf_size-len);
|
|
}
|
|
|
|
skb_pull(skb, bytes_sent);
|
|
|
|
if (!skb->len) {
|
|
// Frame sent
|
|
b_out->tx_skb = NULL;
|
|
B_L1L2(bcs, PH_DATA | CONFIRM, (void *)(unsigned long) skb->truesize);
|
|
dev_kfree_skb_any(skb);
|
|
|
|
/* if (!(bcs->tx_skb = skb_dequeue(&bcs->sq))) { */
|
|
/* st5481B_sched_event(bcs, B_XMTBUFREADY); */
|
|
/* } */
|
|
}
|
|
} else {
|
|
if (bcs->mode == L1_MODE_TRANS) {
|
|
memset(urb->transfer_buffer+len, 0xff, buf_size-len);
|
|
len = buf_size;
|
|
} else {
|
|
// Send flags
|
|
len += isdnhdlc_encode(&b_out->hdlc_state,
|
|
NULL, 0, &bytes_sent,
|
|
urb->transfer_buffer+len, buf_size-len);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Prepare the URB
|
|
for (i = 0, offset = 0; offset < len; i++) {
|
|
urb->iso_frame_desc[i].offset = offset;
|
|
urb->iso_frame_desc[i].length = packet_size;
|
|
offset += packet_size;
|
|
packet_size = SIZE_ISO_PACKETS_B_OUT;
|
|
}
|
|
urb->transfer_buffer_length = len;
|
|
urb->number_of_packets = i;
|
|
urb->dev = adapter->usb_dev;
|
|
|
|
DBG_ISO_PACKET(0x200,urb);
|
|
|
|
SUBMIT_URB(urb, GFP_NOIO);
|
|
}
|
|
|
|
/*
|
|
* Start transfering (flags or data) on the B channel, since
|
|
* FIFO counters has been set to a non-zero value.
|
|
*/
|
|
static void st5481B_start_xfer(void *context)
|
|
{
|
|
struct st5481_bcs *bcs = context;
|
|
|
|
DBG(4,"B%d",bcs->channel+1);
|
|
|
|
// Start transmitting (flags or data) on B channel
|
|
|
|
usb_b_out(bcs,0);
|
|
usb_b_out(bcs,1);
|
|
}
|
|
|
|
/*
|
|
* If the adapter has only 2 LEDs, the green
|
|
* LED will blink with a rate depending
|
|
* on the number of channels opened.
|
|
*/
|
|
static void led_blink(struct st5481_adapter *adapter)
|
|
{
|
|
u_char leds = adapter->leds;
|
|
|
|
// 50 frames/sec for each channel
|
|
if (++adapter->led_counter % 50) {
|
|
return;
|
|
}
|
|
|
|
if (adapter->led_counter % 100) {
|
|
leds |= GREEN_LED;
|
|
} else {
|
|
leds &= ~GREEN_LED;
|
|
}
|
|
|
|
st5481_usb_device_ctrl_msg(adapter, GPIO_OUT, leds, NULL, NULL);
|
|
}
|
|
|
|
static void usb_b_out_complete(struct urb *urb)
|
|
{
|
|
struct st5481_bcs *bcs = urb->context;
|
|
struct st5481_b_out *b_out = &bcs->b_out;
|
|
struct st5481_adapter *adapter = bcs->adapter;
|
|
int buf_nr;
|
|
|
|
buf_nr = get_buf_nr(b_out->urb, urb);
|
|
test_and_clear_bit(buf_nr, &b_out->busy);
|
|
|
|
if (unlikely(urb->status < 0)) {
|
|
switch (urb->status) {
|
|
case -ENOENT:
|
|
case -ESHUTDOWN:
|
|
case -ECONNRESET:
|
|
DBG(4,"urb killed status %d", urb->status);
|
|
return; // Give up
|
|
default:
|
|
WARNING("urb status %d",urb->status);
|
|
if (b_out->busy == 0) {
|
|
st5481_usb_pipe_reset(adapter, (bcs->channel+1)*2 | USB_DIR_OUT, NULL, NULL);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
usb_b_out(bcs,buf_nr);
|
|
|
|
if (adapter->number_of_leds == 2)
|
|
led_blink(adapter);
|
|
}
|
|
|
|
/*
|
|
* Start or stop the transfer on the B channel.
|
|
*/
|
|
static void st5481B_mode(struct st5481_bcs *bcs, int mode)
|
|
{
|
|
struct st5481_b_out *b_out = &bcs->b_out;
|
|
struct st5481_adapter *adapter = bcs->adapter;
|
|
|
|
DBG(4,"B%d,mode=%d", bcs->channel + 1, mode);
|
|
|
|
if (bcs->mode == mode)
|
|
return;
|
|
|
|
bcs->mode = mode;
|
|
|
|
// Cancel all USB transfers on this B channel
|
|
usb_unlink_urb(b_out->urb[0]);
|
|
usb_unlink_urb(b_out->urb[1]);
|
|
b_out->busy = 0;
|
|
|
|
st5481_in_mode(&bcs->b_in, mode);
|
|
if (bcs->mode != L1_MODE_NULL) {
|
|
// Open the B channel
|
|
if (bcs->mode != L1_MODE_TRANS) {
|
|
isdnhdlc_out_init(&b_out->hdlc_state, 0, bcs->mode == L1_MODE_HDLC_56K);
|
|
}
|
|
st5481_usb_pipe_reset(adapter, (bcs->channel+1)*2, NULL, NULL);
|
|
|
|
// Enable B channel interrupts
|
|
st5481_usb_device_ctrl_msg(adapter, FFMSK_B1+(bcs->channel*2),
|
|
OUT_UP+OUT_DOWN+OUT_UNDERRUN, NULL, NULL);
|
|
|
|
// Enable B channel FIFOs
|
|
st5481_usb_device_ctrl_msg(adapter, OUT_B1_COUNTER+(bcs->channel*2), 32, st5481B_start_xfer, bcs);
|
|
if (adapter->number_of_leds == 4) {
|
|
if (bcs->channel == 0) {
|
|
adapter->leds |= B1_LED;
|
|
} else {
|
|
adapter->leds |= B2_LED;
|
|
}
|
|
}
|
|
} else {
|
|
// Disble B channel interrupts
|
|
st5481_usb_device_ctrl_msg(adapter, FFMSK_B1+(bcs->channel*2), 0, NULL, NULL);
|
|
|
|
// Disable B channel FIFOs
|
|
st5481_usb_device_ctrl_msg(adapter, OUT_B1_COUNTER+(bcs->channel*2), 0, NULL, NULL);
|
|
|
|
if (adapter->number_of_leds == 4) {
|
|
if (bcs->channel == 0) {
|
|
adapter->leds &= ~B1_LED;
|
|
} else {
|
|
adapter->leds &= ~B2_LED;
|
|
}
|
|
} else {
|
|
st5481_usb_device_ctrl_msg(adapter, GPIO_OUT, adapter->leds, NULL, NULL);
|
|
}
|
|
if (b_out->tx_skb) {
|
|
dev_kfree_skb_any(b_out->tx_skb);
|
|
b_out->tx_skb = NULL;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
static int st5481_setup_b_out(struct st5481_bcs *bcs)
|
|
{
|
|
struct usb_device *dev = bcs->adapter->usb_dev;
|
|
struct usb_interface *intf;
|
|
struct usb_host_interface *altsetting = NULL;
|
|
struct usb_host_endpoint *endpoint;
|
|
struct st5481_b_out *b_out = &bcs->b_out;
|
|
|
|
DBG(4,"");
|
|
|
|
intf = usb_ifnum_to_if(dev, 0);
|
|
if (intf)
|
|
altsetting = usb_altnum_to_altsetting(intf, 3);
|
|
if (!altsetting)
|
|
return -ENXIO;
|
|
|
|
// Allocate URBs and buffers for the B channel out
|
|
endpoint = &altsetting->endpoint[EP_B1_OUT - 1 + bcs->channel * 2];
|
|
|
|
DBG(4,"endpoint address=%02x,packet size=%d",
|
|
endpoint->desc.bEndpointAddress, le16_to_cpu(endpoint->desc.wMaxPacketSize));
|
|
|
|
// Allocate memory for 8000bytes/sec + extra bytes if underrun
|
|
return st5481_setup_isocpipes(b_out->urb, dev,
|
|
usb_sndisocpipe(dev, endpoint->desc.bEndpointAddress),
|
|
NUM_ISO_PACKETS_B, SIZE_ISO_PACKETS_B_OUT,
|
|
NUM_ISO_PACKETS_B * SIZE_ISO_PACKETS_B_OUT + B_FLOW_ADJUST,
|
|
usb_b_out_complete, bcs);
|
|
}
|
|
|
|
static void st5481_release_b_out(struct st5481_bcs *bcs)
|
|
{
|
|
struct st5481_b_out *b_out = &bcs->b_out;
|
|
|
|
DBG(4,"");
|
|
|
|
st5481_release_isocpipes(b_out->urb);
|
|
}
|
|
|
|
int st5481_setup_b(struct st5481_bcs *bcs)
|
|
{
|
|
int retval;
|
|
|
|
DBG(4,"");
|
|
|
|
retval = st5481_setup_b_out(bcs);
|
|
if (retval)
|
|
goto err;
|
|
bcs->b_in.bufsize = HSCX_BUFMAX;
|
|
bcs->b_in.num_packets = NUM_ISO_PACKETS_B;
|
|
bcs->b_in.packet_size = SIZE_ISO_PACKETS_B_IN;
|
|
bcs->b_in.ep = (bcs->channel ? EP_B2_IN : EP_B1_IN) | USB_DIR_IN;
|
|
bcs->b_in.counter = bcs->channel ? IN_B2_COUNTER : IN_B1_COUNTER;
|
|
bcs->b_in.adapter = bcs->adapter;
|
|
bcs->b_in.hisax_if = &bcs->b_if.ifc;
|
|
retval = st5481_setup_in(&bcs->b_in);
|
|
if (retval)
|
|
goto err_b_out;
|
|
|
|
|
|
return 0;
|
|
|
|
err_b_out:
|
|
st5481_release_b_out(bcs);
|
|
err:
|
|
return retval;
|
|
}
|
|
|
|
/*
|
|
* Release buffers and URBs for the B channels
|
|
*/
|
|
void st5481_release_b(struct st5481_bcs *bcs)
|
|
{
|
|
DBG(4,"");
|
|
|
|
st5481_release_in(&bcs->b_in);
|
|
st5481_release_b_out(bcs);
|
|
}
|
|
|
|
/*
|
|
* st5481_b_l2l1 is the entry point for upper layer routines that want to
|
|
* transmit on the B channel. PH_DATA | REQUEST is a normal packet that
|
|
* we either start transmitting (if idle) or queue (if busy).
|
|
* PH_PULL | REQUEST can be called to request a callback message
|
|
* (PH_PULL | CONFIRM)
|
|
* once the link is idle. After a "pull" callback, the upper layer
|
|
* routines can use PH_PULL | INDICATION to send data.
|
|
*/
|
|
void st5481_b_l2l1(struct hisax_if *ifc, int pr, void *arg)
|
|
{
|
|
struct st5481_bcs *bcs = ifc->priv;
|
|
struct sk_buff *skb = arg;
|
|
long mode;
|
|
|
|
DBG(4, "");
|
|
|
|
switch (pr) {
|
|
case PH_DATA | REQUEST:
|
|
BUG_ON(bcs->b_out.tx_skb);
|
|
bcs->b_out.tx_skb = skb;
|
|
break;
|
|
case PH_ACTIVATE | REQUEST:
|
|
mode = (long) arg;
|
|
DBG(4,"B%d,PH_ACTIVATE_REQUEST %ld", bcs->channel + 1, mode);
|
|
st5481B_mode(bcs, mode);
|
|
B_L1L2(bcs, PH_ACTIVATE | INDICATION, NULL);
|
|
break;
|
|
case PH_DEACTIVATE | REQUEST:
|
|
DBG(4,"B%d,PH_DEACTIVATE_REQUEST", bcs->channel + 1);
|
|
st5481B_mode(bcs, L1_MODE_NULL);
|
|
B_L1L2(bcs, PH_DEACTIVATE | INDICATION, NULL);
|
|
break;
|
|
default:
|
|
WARNING("pr %#x\n", pr);
|
|
}
|
|
}
|