[net-next-2.6.git] / drivers / isdn / hisax / st5481_d.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/gfp.h>
#include <linux/usb.h>
#include <linux/netdevice.h>
#include "st5481.h"

static void ph_connect(struct st5481_adapter *adapter);
static void ph_disconnect(struct st5481_adapter *adapter);

static struct Fsm l1fsm;

static char *strL1State[] =
{
	"ST_L1_F3",
	"ST_L1_F4",
	"ST_L1_F6",
	"ST_L1_F7",
	"ST_L1_F8",
};

static char *strL1Event[] =
{
	"EV_IND_DP",  
	"EV_IND_1",   
	"EV_IND_2",   
	"EV_IND_3",   
	"EV_IND_RSY", 
	"EV_IND_5",   
	"EV_IND_6",   
	"EV_IND_7",   
	"EV_IND_AP",  
	"EV_IND_9",   
	"EV_IND_10",  
	"EV_IND_11",  
	"EV_IND_AI8",
	"EV_IND_AI10",
	"EV_IND_AIL",
	"EV_IND_DI",  
	"EV_PH_ACTIVATE_REQ",
	"EV_PH_DEACTIVATE_REQ",
	"EV_TIMER3",
};

static inline void D_L1L2(struct st5481_adapter *adapter, int pr, void *arg)
{
	struct hisax_if *ifc = (struct hisax_if *) &adapter->hisax_d_if;

	ifc->l1l2(ifc, pr, arg);
}

static void
l1_go_f3(struct FsmInst *fi, int event, void *arg)
{
	struct st5481_adapter *adapter = fi->userdata;

	if (fi->state == ST_L1_F7)
		ph_disconnect(adapter);
	
	FsmChangeState(fi, ST_L1_F3);
	D_L1L2(adapter, PH_DEACTIVATE | INDICATION, NULL);
}

static void
l1_go_f6(struct FsmInst *fi, int event, void *arg)
{
	struct st5481_adapter *adapter = fi->userdata;

	if (fi->state == ST_L1_F7)
		ph_disconnect(adapter);

	FsmChangeState(fi, ST_L1_F6);
}

static void
l1_go_f7(struct FsmInst *fi, int event, void *arg)
{
	struct st5481_adapter *adapter = fi->userdata;

	FsmDelTimer(&adapter->timer, 0);
	ph_connect(adapter);
	FsmChangeState(fi, ST_L1_F7);
	D_L1L2(adapter, PH_ACTIVATE | INDICATION, NULL);
}

static void
l1_go_f8(struct FsmInst *fi, int event, void *arg)
{
	struct st5481_adapter *adapter = fi->userdata;

	if (fi->state == ST_L1_F7)
		ph_disconnect(adapter);

	FsmChangeState(fi, ST_L1_F8);
}

static void
l1_timer3(struct FsmInst *fi, int event, void *arg)
{
	struct st5481_adapter *adapter = fi->userdata;

	st5481_ph_command(adapter, ST5481_CMD_DR);
	FsmChangeState(fi, ST_L1_F3);
	D_L1L2(adapter, PH_DEACTIVATE | INDICATION, NULL);
}

static void
l1_ignore(struct FsmInst *fi, int event, void *arg)
{
}

static void
l1_activate(struct FsmInst *fi, int event, void *arg)
{
	struct st5481_adapter *adapter = fi->userdata;

	st5481_ph_command(adapter, ST5481_CMD_DR);
	st5481_ph_command(adapter, ST5481_CMD_PUP);
	FsmRestartTimer(&adapter->timer, TIMER3_VALUE, EV_TIMER3, NULL, 2);
	st5481_ph_command(adapter, ST5481_CMD_AR8);
	FsmChangeState(fi, ST_L1_F4);
}

static struct FsmNode L1FnList[] __initdata =
{
	{ST_L1_F3, EV_IND_DP,            l1_ignore},
	{ST_L1_F3, EV_IND_AP,            l1_go_f6},
	{ST_L1_F3, EV_IND_AI8,           l1_go_f7},
	{ST_L1_F3, EV_IND_AI10,          l1_go_f7},
	{ST_L1_F3, EV_PH_ACTIVATE_REQ,   l1_activate},

	{ST_L1_F4, EV_TIMER3,            l1_timer3},
	{ST_L1_F4, EV_IND_DP,            l1_go_f3},
	{ST_L1_F4, EV_IND_AP,            l1_go_f6},
	{ST_L1_F4, EV_IND_AI8,           l1_go_f7},
	{ST_L1_F4, EV_IND_AI10,          l1_go_f7},

	{ST_L1_F6, EV_TIMER3,            l1_timer3},
	{ST_L1_F6, EV_IND_DP,            l1_go_f3},
	{ST_L1_F6, EV_IND_AP,            l1_ignore},
	{ST_L1_F6, EV_IND_AI8,           l1_go_f7},
	{ST_L1_F6, EV_IND_AI10,          l1_go_f7},
	{ST_L1_F7, EV_IND_RSY,           l1_go_f8},

	{ST_L1_F7, EV_IND_DP,            l1_go_f3},
	{ST_L1_F7, EV_IND_AP,            l1_go_f6},
	{ST_L1_F7, EV_IND_AI8,           l1_ignore},
	{ST_L1_F7, EV_IND_AI10,          l1_ignore},
	{ST_L1_F7, EV_IND_RSY,           l1_go_f8},

	{ST_L1_F8, EV_TIMER3,            l1_timer3},
	{ST_L1_F8, EV_IND_DP,            l1_go_f3},
	{ST_L1_F8, EV_IND_AP,            l1_go_f6},
	{ST_L1_F8, EV_IND_AI8,           l1_go_f8},
	{ST_L1_F8, EV_IND_AI10,          l1_go_f8},
	{ST_L1_F8, EV_IND_RSY,           l1_ignore},
};

static __attribute__((format(printf, 2, 3)))
void l1m_debug(struct FsmInst *fi, char *fmt, ...)
{
	va_list args;
	char buf[256];
	
	va_start(args, fmt);
	vsnprintf(buf, sizeof(buf), fmt, args);
	DBG(8, "%s", buf);
	va_end(args);
}

/* ======================================================================
 * D-Channel out
 */

/*
  D OUT state machine:
  ====================

  Transmit short frame (< 16 bytes of encoded data):

  L1 FRAME    D_OUT_STATE           USB                  D CHANNEL
  --------    -----------           ---                  ---------
 
              FIXME

 -> [xx..xx]  SHORT_INIT            -> [7Exx..xxC1C27EFF]
              SHORT_WAIT_DEN        <> OUT_D_COUNTER=16 
                                                 
              END_OF_SHORT          <- DEN_EVENT         -> 7Exx
                                                          xxxx 
                                                          xxxx
							  xxxx 
							  xxxx
							  xxxx
							  C1C1 
							  7EFF 
              WAIT_FOR_RESET_IDLE   <- D_UNDERRUN        <- (8ms)                        
              IDLE                  <> Reset pipe

              

  Transmit long frame (>= 16 bytes of encoded data):

  L1 FRAME    D_OUT_STATE           USB                  D CHANNEL
  --------    -----------           ---                  ---------

 -> [xx...xx] IDLE
              WAIT_FOR_STOP         <> OUT_D_COUNTER=0
              WAIT_FOR_RESET        <> Reset pipe
	      STOP
	      INIT_LONG_FRAME       -> [7Exx..xx]
              WAIT_DEN              <> OUT_D_COUNTER=16 
              OUT_NORMAL            <- DEN_EVENT       -> 7Exx
              END_OF_FRAME_BUSY     -> [xxxx]             xxxx 
              END_OF_FRAME_NOT_BUSY -> [xxxx]             xxxx
				    -> [xxxx]		  xxxx 
				    -> [C1C2]		  xxxx
				    -> [7EFF]		  xxxx
							  xxxx 
							  xxxx 
                                                          ....
							  xxxx
							  C1C2
							  7EFF
	                 	    <- D_UNDERRUN      <- (> 8ms)                        
              WAIT_FOR_STOP         <> OUT_D_COUNTER=0
              WAIT_FOR_RESET        <> Reset pipe
	      STOP

*/          

static struct Fsm dout_fsm;

static char *strDoutState[] =
{
	"ST_DOUT_NONE",

	"ST_DOUT_SHORT_INIT",
	"ST_DOUT_SHORT_WAIT_DEN",

	"ST_DOUT_LONG_INIT",
	"ST_DOUT_LONG_WAIT_DEN",
	"ST_DOUT_NORMAL",

	"ST_DOUT_WAIT_FOR_UNDERRUN",
        "ST_DOUT_WAIT_FOR_NOT_BUSY",
	"ST_DOUT_WAIT_FOR_STOP",
	"ST_DOUT_WAIT_FOR_RESET",
};

static char *strDoutEvent[] =
{
	"EV_DOUT_START_XMIT",
	"EV_DOUT_COMPLETE",
	"EV_DOUT_DEN",
	"EV_DOUT_RESETED",
	"EV_DOUT_STOPPED",
	"EV_DOUT_COLL",
	"EV_DOUT_UNDERRUN",
};

static __attribute__((format(printf, 2, 3)))
void dout_debug(struct FsmInst *fi, char *fmt, ...)
{
	va_list args;
	char buf[256];
	
	va_start(args, fmt);
	vsnprintf(buf, sizeof(buf), fmt, args);
	DBG(0x2, "%s", buf);
	va_end(args);
}

static void dout_stop_event(void *context)
{
	struct st5481_adapter *adapter = context;

	FsmEvent(&adapter->d_out.fsm, EV_DOUT_STOPPED, NULL);
}

/*
 * Start the transfer of a D channel frame.
 */
static void usb_d_out(struct st5481_adapter *adapter, int buf_nr)
{
	struct st5481_d_out *d_out = &adapter->d_out;
	struct urb *urb;
	unsigned int num_packets, packet_offset;
	int len, buf_size, bytes_sent;
	struct sk_buff *skb;
	struct usb_iso_packet_descriptor *desc;

	if (d_out->fsm.state != ST_DOUT_NORMAL)
		return;

	if (test_and_set_bit(buf_nr, &d_out->busy)) {
		DBG(2, "ep %d urb %d busy %#lx", EP_D_OUT, buf_nr, d_out->busy);
		return;
	}
	urb = d_out->urb[buf_nr];

	skb = d_out->tx_skb;

	buf_size = NUM_ISO_PACKETS_D * SIZE_ISO_PACKETS_D_OUT;
	
	if (skb) {
		len = isdnhdlc_encode(&d_out->hdlc_state,
				      skb->data, skb->len, &bytes_sent,
				      urb->transfer_buffer, buf_size);
		skb_pull(skb,bytes_sent);
	} else {
		// Send flags or idle
		len = isdnhdlc_encode(&d_out->hdlc_state,
				      NULL, 0, &bytes_sent,
				      urb->transfer_buffer, buf_size);
	}
	
	if (len < buf_size) {
		FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_UNDERRUN);
	}
	if (skb && !skb->len) {
		d_out->tx_skb = NULL;
		D_L1L2(adapter, PH_DATA | CONFIRM, NULL);
		dev_kfree_skb_any(skb);
	}

	// Prepare the URB
	urb->transfer_buffer_length = len;
	num_packets = 0;
	packet_offset = 0;
	while (packet_offset < len) {
		desc = &urb->iso_frame_desc[num_packets];
		desc->offset = packet_offset;
		desc->length = SIZE_ISO_PACKETS_D_OUT;
		if (len - packet_offset < desc->length)
			desc->length = len - packet_offset;
		num_packets++;
		packet_offset += desc->length;
	}
	urb->number_of_packets = num_packets;

	// Prepare the URB
	urb->dev = adapter->usb_dev;
	// Need to transmit the next buffer 2ms after the DEN_EVENT
	urb->transfer_flags = 0;
	urb->start_frame = usb_get_current_frame_number(adapter->usb_dev)+2;

	DBG_ISO_PACKET(0x20,urb);

	if (usb_submit_urb(urb, GFP_KERNEL) < 0) {
		// There is another URB queued up
		urb->transfer_flags = URB_ISO_ASAP;
		SUBMIT_URB(urb, GFP_KERNEL);
	}	
}

static void fifo_reseted(void *context)
{
	struct st5481_adapter *adapter = context;

	FsmEvent(&adapter->d_out.fsm, EV_DOUT_RESETED, NULL);
}

static void usb_d_out_complete(struct urb *urb)
{
	struct st5481_adapter *adapter = urb->context;
	struct st5481_d_out *d_out = &adapter->d_out;
	long buf_nr;
	
	DBG(2, "");

	buf_nr = get_buf_nr(d_out->urb, urb);
	test_and_clear_bit(buf_nr, &d_out->busy);

	if (unlikely(urb->status < 0)) {
		switch (urb->status) {
			case -ENOENT:
			case -ESHUTDOWN:
			case -ECONNRESET:
				DBG(1,"urb killed status %d", urb->status);
				break;
			default: 
				WARNING("urb status %d",urb->status);
				if (d_out->busy == 0) {
					st5481_usb_pipe_reset(adapter, EP_D_OUT | USB_DIR_OUT, fifo_reseted, adapter);
				}
				break;
		}
		return; // Give up
	}

	FsmEvent(&adapter->d_out.fsm, EV_DOUT_COMPLETE, (void *) buf_nr);
}

/* ====================================================================== */

static void dout_start_xmit(struct FsmInst *fsm, int event, void *arg)
{
	// FIXME unify?
	struct st5481_adapter *adapter = fsm->userdata;
	struct st5481_d_out *d_out = &adapter->d_out;
	struct urb *urb;
	int len, bytes_sent;
	struct sk_buff *skb;
	int buf_nr = 0;

	skb = d_out->tx_skb;

	DBG(2,"len=%d",skb->len);

	isdnhdlc_out_init(&d_out->hdlc_state, HDLC_DCHANNEL | HDLC_BITREVERSE);

	if (test_and_set_bit(buf_nr, &d_out->busy)) {
		WARNING("ep %d urb %d busy %#lx", EP_D_OUT, buf_nr, d_out->busy);
		return;
	}
	urb = d_out->urb[buf_nr];

	DBG_SKB(0x10, skb);
	len = isdnhdlc_encode(&d_out->hdlc_state,
			      skb->data, skb->len, &bytes_sent,
			      urb->transfer_buffer, 16);
	skb_pull(skb, bytes_sent);

	if(len < 16)
		FsmChangeState(&d_out->fsm, ST_DOUT_SHORT_INIT);
	else
		FsmChangeState(&d_out->fsm, ST_DOUT_LONG_INIT);

	if (skb->len == 0) {
		d_out->tx_skb = NULL;
		D_L1L2(adapter, PH_DATA | CONFIRM, NULL);
		dev_kfree_skb_any(skb);
	}

// Prepare the URB
	urb->transfer_buffer_length = len;

	urb->iso_frame_desc[0].offset = 0;
	urb->iso_frame_desc[0].length = len;
	urb->number_of_packets = 1;

	// Prepare the URB
	urb->dev = adapter->usb_dev;
	urb->transfer_flags = URB_ISO_ASAP;

	DBG_ISO_PACKET(0x20,urb);
	SUBMIT_URB(urb, GFP_KERNEL);
}

static void dout_short_fifo(struct FsmInst *fsm, int event, void *arg)
{
	struct st5481_adapter *adapter = fsm->userdata;
	struct st5481_d_out *d_out = &adapter->d_out;

	FsmChangeState(&d_out->fsm, ST_DOUT_SHORT_WAIT_DEN);
	st5481_usb_device_ctrl_msg(adapter, OUT_D_COUNTER, 16, NULL, NULL);
}

static void dout_end_short_frame(struct FsmInst *fsm, int event, void *arg)
{
	struct st5481_adapter *adapter = fsm->userdata;
	struct st5481_d_out *d_out = &adapter->d_out;

	FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_UNDERRUN);
}

static void dout_long_enable_fifo(struct FsmInst *fsm, int event, void *arg)
{
	struct st5481_adapter *adapter = fsm->userdata;
	struct st5481_d_out *d_out = &adapter->d_out;
    
	st5481_usb_device_ctrl_msg(adapter, OUT_D_COUNTER, 16, NULL, NULL);
	FsmChangeState(&d_out->fsm, ST_DOUT_LONG_WAIT_DEN);
}

static void dout_long_den(struct FsmInst *fsm, int event, void *arg)
{
	struct st5481_adapter *adapter = fsm->userdata;
	struct st5481_d_out *d_out = &adapter->d_out;

	FsmChangeState(&d_out->fsm, ST_DOUT_NORMAL);
	usb_d_out(adapter, 0);
	usb_d_out(adapter, 1);
}

static void dout_reset(struct FsmInst *fsm, int event, void *arg)
{
	struct st5481_adapter *adapter = fsm->userdata;
	struct st5481_d_out *d_out = &adapter->d_out;

	FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_RESET);
	st5481_usb_pipe_reset(adapter, EP_D_OUT | USB_DIR_OUT, fifo_reseted, adapter);
}

static void dout_stop(struct FsmInst *fsm, int event, void *arg)
{
	struct st5481_adapter *adapter = fsm->userdata;
	struct st5481_d_out *d_out = &adapter->d_out;

	FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_STOP);
	st5481_usb_device_ctrl_msg(adapter, OUT_D_COUNTER, 0, dout_stop_event, adapter);
}

static void dout_underrun(struct FsmInst *fsm, int event, void *arg)
{
	struct st5481_adapter *adapter = fsm->userdata;
	struct st5481_d_out *d_out = &adapter->d_out;

	if (test_bit(0, &d_out->busy) || test_bit(1, &d_out->busy)) {
		FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_NOT_BUSY);
	}  else {
		dout_stop(fsm, event, arg);
	}
}

static void dout_check_busy(struct FsmInst *fsm, int event, void *arg)
{
	struct st5481_adapter *adapter = fsm->userdata;
	struct st5481_d_out *d_out = &adapter->d_out;

	if (!test_bit(0, &d_out->busy) && !test_bit(1, &d_out->busy))
		dout_stop(fsm, event, arg);
}

static void dout_reseted(struct FsmInst *fsm, int event, void *arg)
{
	struct st5481_adapter *adapter = fsm->userdata;
	struct st5481_d_out *d_out = &adapter->d_out;

	FsmChangeState(&d_out->fsm, ST_DOUT_NONE);
	// FIXME locking
	if (d_out->tx_skb)
		FsmEvent(&d_out->fsm, EV_DOUT_START_XMIT, NULL);
}

static void dout_complete(struct FsmInst *fsm, int event, void *arg)
{
	struct st5481_adapter *adapter = fsm->userdata;
	long buf_nr = (long) arg;

	usb_d_out(adapter, buf_nr);
}

static void dout_ignore(struct FsmInst *fsm, int event, void *arg)
{
}

static struct FsmNode DoutFnList[] __initdata =
{
	{ST_DOUT_NONE,                   EV_DOUT_START_XMIT,   dout_start_xmit},

	{ST_DOUT_SHORT_INIT,             EV_DOUT_COMPLETE,     dout_short_fifo},

	{ST_DOUT_SHORT_WAIT_DEN,         EV_DOUT_DEN,          dout_end_short_frame},
	{ST_DOUT_SHORT_WAIT_DEN,         EV_DOUT_UNDERRUN,     dout_underrun},

	{ST_DOUT_LONG_INIT,              EV_DOUT_COMPLETE,     dout_long_enable_fifo},

	{ST_DOUT_LONG_WAIT_DEN,          EV_DOUT_DEN,          dout_long_den},
	{ST_DOUT_LONG_WAIT_DEN,          EV_DOUT_UNDERRUN,     dout_underrun},

	{ST_DOUT_NORMAL,                 EV_DOUT_UNDERRUN,     dout_underrun},
	{ST_DOUT_NORMAL,                 EV_DOUT_COMPLETE,     dout_complete},

	{ST_DOUT_WAIT_FOR_UNDERRUN,      EV_DOUT_UNDERRUN,     dout_underrun},
	{ST_DOUT_WAIT_FOR_UNDERRUN,      EV_DOUT_COMPLETE,     dout_ignore},

	{ST_DOUT_WAIT_FOR_NOT_BUSY,      EV_DOUT_COMPLETE,     dout_check_busy},

	{ST_DOUT_WAIT_FOR_STOP,          EV_DOUT_STOPPED,      dout_reset},

	{ST_DOUT_WAIT_FOR_RESET,         EV_DOUT_RESETED,      dout_reseted},
};

void st5481_d_l2l1(struct hisax_if *hisax_d_if, int pr, void *arg)
{
	struct st5481_adapter *adapter = hisax_d_if->priv;
	struct sk_buff *skb = arg;

	switch (pr) {
	case PH_ACTIVATE | REQUEST:
		FsmEvent(&adapter->l1m, EV_PH_ACTIVATE_REQ, NULL);
		break;
	case PH_DEACTIVATE | REQUEST:
		FsmEvent(&adapter->l1m, EV_PH_DEACTIVATE_REQ, NULL);
		break;
	case PH_DATA | REQUEST:
		DBG(2, "PH_DATA REQUEST len %d", skb->len);
		BUG_ON(adapter->d_out.tx_skb);
		adapter->d_out.tx_skb = skb;
		FsmEvent(&adapter->d_out.fsm, EV_DOUT_START_XMIT, NULL);
		break;
	default:
		WARNING("pr %#x\n", pr);
		break;
	}
}

/* ======================================================================
 */

/*
 * Start receiving on the D channel since entered state F7.
 */
static void ph_connect(struct st5481_adapter *adapter)
{
	struct st5481_d_out *d_out = &adapter->d_out;
	struct st5481_in *d_in = &adapter->d_in;

	DBG(8,"");
		
	FsmChangeState(&d_out->fsm, ST_DOUT_NONE);

	//	st5481_usb_device_ctrl_msg(adapter, FFMSK_D, OUT_UNDERRUN, NULL, NULL);
	st5481_usb_device_ctrl_msg(adapter, FFMSK_D, 0xfc, NULL, NULL);
	st5481_in_mode(d_in, L1_MODE_HDLC);

#ifdef LOOPBACK
	// Turn loopback on (data sent on B and D looped back)
	st5481_usb_device_ctrl_msg(cs, LBB, 0x04, NULL, NULL);
#endif

	st5481_usb_pipe_reset(adapter, EP_D_OUT | USB_DIR_OUT, NULL, NULL);

	// Turn on the green LED to tell that we are in state F7
	adapter->leds |= GREEN_LED;
	st5481_usb_device_ctrl_msg(adapter, GPIO_OUT, adapter->leds, NULL, NULL);
}

/*
 * Stop receiving on the D channel since not in state F7.
 */
static void ph_disconnect(struct st5481_adapter *adapter)
{
	DBG(8,"");

	st5481_in_mode(&adapter->d_in, L1_MODE_NULL);

	// Turn off the green LED to tell that we left state F7
	adapter->leds &= ~GREEN_LED;
	st5481_usb_device_ctrl_msg(adapter, GPIO_OUT, adapter->leds, NULL, NULL);
}

static int st5481_setup_d_out(struct st5481_adapter *adapter)
{
	struct usb_device *dev = adapter->usb_dev;
	struct usb_interface *intf;
	struct usb_host_interface *altsetting = NULL;
	struct usb_host_endpoint *endpoint;
	struct st5481_d_out *d_out = &adapter->d_out;

	DBG(2,"");

	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 D channel out
	endpoint = &altsetting->endpoint[EP_D_OUT-1];

	DBG(2,"endpoint address=%02x,packet size=%d",
	    endpoint->desc.bEndpointAddress, le16_to_cpu(endpoint->desc.wMaxPacketSize));

	return st5481_setup_isocpipes(d_out->urb, dev, 
				      usb_sndisocpipe(dev, endpoint->desc.bEndpointAddress),
				      NUM_ISO_PACKETS_D, SIZE_ISO_PACKETS_D_OUT,
				      NUM_ISO_PACKETS_D * SIZE_ISO_PACKETS_D_OUT,
				      usb_d_out_complete, adapter);
}

static void st5481_release_d_out(struct st5481_adapter *adapter)
{
	struct st5481_d_out *d_out = &adapter->d_out;

	DBG(2,"");

	st5481_release_isocpipes(d_out->urb);
}

int st5481_setup_d(struct st5481_adapter *adapter)
{
	int retval;

	DBG(2,"");

	retval = st5481_setup_d_out(adapter);
	if (retval)
		goto err;
	adapter->d_in.bufsize = MAX_DFRAME_LEN_L1;
	adapter->d_in.num_packets = NUM_ISO_PACKETS_D;
	adapter->d_in.packet_size = SIZE_ISO_PACKETS_D_IN;
	adapter->d_in.ep = EP_D_IN | USB_DIR_IN;
	adapter->d_in.counter = IN_D_COUNTER;
	adapter->d_in.adapter = adapter;
	adapter->d_in.hisax_if = &adapter->hisax_d_if.ifc;
	retval = st5481_setup_in(&adapter->d_in);
	if (retval)
		goto err_d_out;

	adapter->l1m.fsm = &l1fsm;
	adapter->l1m.state = ST_L1_F3;
	adapter->l1m.debug = st5481_debug & 0x100;
	adapter->l1m.userdata = adapter;
	adapter->l1m.printdebug = l1m_debug;
	FsmInitTimer(&adapter->l1m, &adapter->timer);

	adapter->d_out.fsm.fsm = &dout_fsm;
	adapter->d_out.fsm.state = ST_DOUT_NONE;
	adapter->d_out.fsm.debug = st5481_debug & 0x100;
	adapter->d_out.fsm.userdata = adapter;
	adapter->d_out.fsm.printdebug = dout_debug;

	return 0;

 err_d_out:
	st5481_release_d_out(adapter);
 err:
	return retval;
}

void st5481_release_d(struct st5481_adapter *adapter)
{
	DBG(2,"");

	st5481_release_in(&adapter->d_in);
	st5481_release_d_out(adapter);
}

/* ======================================================================
 * init / exit
 */

int __init st5481_d_init(void)
{
	int retval;

	l1fsm.state_count = L1_STATE_COUNT;
	l1fsm.event_count = L1_EVENT_COUNT;
	l1fsm.strEvent = strL1Event;
	l1fsm.strState = strL1State;
	retval = FsmNew(&l1fsm, L1FnList, ARRAY_SIZE(L1FnList));
	if (retval)
		goto err;

	dout_fsm.state_count = DOUT_STATE_COUNT;
	dout_fsm.event_count = DOUT_EVENT_COUNT;
	dout_fsm.strEvent = strDoutEvent;
	dout_fsm.strState = strDoutState;
	retval = FsmNew(&dout_fsm, DoutFnList, ARRAY_SIZE(DoutFnList));
	if (retval)
		goto err_l1;

	return 0;

 err_l1:
	FsmFree(&l1fsm);
 err:
	return retval;
}

// can't be __exit
void st5481_d_exit(void)
{
	FsmFree(&l1fsm);
	FsmFree(&dout_fsm);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Driver for ST5481 USB ISDN modem
	3	*
	4	* Author Frode Isaksen
	5	* Copyright 2001 by Frode Isaksen <fisaksen@bewan.com>
	6	* 2001 by Kai Germaschewski <kai.germaschewski@gmx.de>
	7	*
	8	* This software may be used and distributed according to the terms
	9	* of the GNU General Public License, incorporated herein by reference.
	10	*
	11	*/
	12
	13	#include <linux/init.h>
5a0e3ad6	14	#include <linux/gfp.h>
1da177e4	15	#include <linux/usb.h>
1da177e4 LT	16	#include <linux/netdevice.h>
	17	#include "st5481.h"
	18
	19	static void ph_connect(struct st5481_adapter *adapter);
	20	static void ph_disconnect(struct st5481_adapter *adapter);
	21
	22	static struct Fsm l1fsm;
	23
	24	static char *strL1State[] =
	25	{
	26	"ST_L1_F3",
	27	"ST_L1_F4",
	28	"ST_L1_F6",
	29	"ST_L1_F7",
	30	"ST_L1_F8",
	31	};
	32
	33	static char *strL1Event[] =
	34	{
	35	"EV_IND_DP",
	36	"EV_IND_1",
	37	"EV_IND_2",
	38	"EV_IND_3",
	39	"EV_IND_RSY",
	40	"EV_IND_5",
	41	"EV_IND_6",
	42	"EV_IND_7",
	43	"EV_IND_AP",
	44	"EV_IND_9",
	45	"EV_IND_10",
	46	"EV_IND_11",
	47	"EV_IND_AI8",
	48	"EV_IND_AI10",
	49	"EV_IND_AIL",
	50	"EV_IND_DI",
	51	"EV_PH_ACTIVATE_REQ",
	52	"EV_PH_DEACTIVATE_REQ",
	53	"EV_TIMER3",
	54	};
	55
	56	static inline void D_L1L2(struct st5481_adapter adapter, int pr, void arg)
	57	{
	58	struct hisax_if ifc = (struct hisax_if ) &adapter->hisax_d_if;
	59
	60	ifc->l1l2(ifc, pr, arg);
	61	}
	62
	63	static void
	64	l1_go_f3(struct FsmInst fi, int event, void arg)
	65	{
	66	struct st5481_adapter *adapter = fi->userdata;
	67
	68	if (fi->state == ST_L1_F7)
	69	ph_disconnect(adapter);
	70
	71	FsmChangeState(fi, ST_L1_F3);
	72	D_L1L2(adapter, PH_DEACTIVATE \| INDICATION, NULL);
	73	}
	74
	75	static void
	76	l1_go_f6(struct FsmInst fi, int event, void arg)
	77	{
	78	struct st5481_adapter *adapter = fi->userdata;
	79
80	if (fi->state == ST_L1_F7)
81	ph_disconnect(adapter);
82
83	FsmChangeState(fi, ST_L1_F6);
84	}
85
86	static void
87	l1_go_f7(struct FsmInst fi, int event, void arg)
88	{
89	struct st5481_adapter *adapter = fi->userdata;
90
91	FsmDelTimer(&adapter->timer, 0);
92	ph_connect(adapter);
93	FsmChangeState(fi, ST_L1_F7);
94	D_L1L2(adapter, PH_ACTIVATE \| INDICATION, NULL);
95	}
96
97	static void
98	l1_go_f8(struct FsmInst fi, int event, void arg)
99	{
100	struct st5481_adapter *adapter = fi->userdata;
101
102	if (fi->state == ST_L1_F7)
103	ph_disconnect(adapter);
104
105	FsmChangeState(fi, ST_L1_F8);
106	}
107
108	static void
109	l1_timer3(struct FsmInst fi, int event, void arg)
110	{
111	struct st5481_adapter *adapter = fi->userdata;
112
113	st5481_ph_command(adapter, ST5481_CMD_DR);
114	FsmChangeState(fi, ST_L1_F3);
115	D_L1L2(adapter, PH_DEACTIVATE \| INDICATION, NULL);
116	}
117
118	static void
119	l1_ignore(struct FsmInst fi, int event, void arg)
120	{
121	}
122
123	static void
124	l1_activate(struct FsmInst fi, int event, void arg)
125	{
126	struct st5481_adapter *adapter = fi->userdata;
127
128	st5481_ph_command(adapter, ST5481_CMD_DR);
129	st5481_ph_command(adapter, ST5481_CMD_PUP);
130	FsmRestartTimer(&adapter->timer, TIMER3_VALUE, EV_TIMER3, NULL, 2);
131	st5481_ph_command(adapter, ST5481_CMD_AR8);
132	FsmChangeState(fi, ST_L1_F4);
133	}
134
135	static struct FsmNode L1FnList[] __initdata =
136	{
137	{ST_L1_F3, EV_IND_DP, l1_ignore},
138	{ST_L1_F3, EV_IND_AP, l1_go_f6},
139	{ST_L1_F3, EV_IND_AI8, l1_go_f7},
140	{ST_L1_F3, EV_IND_AI10, l1_go_f7},
141	{ST_L1_F3, EV_PH_ACTIVATE_REQ, l1_activate},
142
143	{ST_L1_F4, EV_TIMER3, l1_timer3},
144	{ST_L1_F4, EV_IND_DP, l1_go_f3},
145	{ST_L1_F4, EV_IND_AP, l1_go_f6},
146	{ST_L1_F4, EV_IND_AI8, l1_go_f7},
147	{ST_L1_F4, EV_IND_AI10, l1_go_f7},
148
149	{ST_L1_F6, EV_TIMER3, l1_timer3},
150	{ST_L1_F6, EV_IND_DP, l1_go_f3},
151	{ST_L1_F6, EV_IND_AP, l1_ignore},
152	{ST_L1_F6, EV_IND_AI8, l1_go_f7},
153	{ST_L1_F6, EV_IND_AI10, l1_go_f7},
154	{ST_L1_F7, EV_IND_RSY, l1_go_f8},
155
156	{ST_L1_F7, EV_IND_DP, l1_go_f3},
157	{ST_L1_F7, EV_IND_AP, l1_go_f6},
158	{ST_L1_F7, EV_IND_AI8, l1_ignore},
159	{ST_L1_F7, EV_IND_AI10, l1_ignore},
160	{ST_L1_F7, EV_IND_RSY, l1_go_f8},
161
162	{ST_L1_F8, EV_TIMER3, l1_timer3},
163	{ST_L1_F8, EV_IND_DP, l1_go_f3},
164	{ST_L1_F8, EV_IND_AP, l1_go_f6},
165	{ST_L1_F8, EV_IND_AI8, l1_go_f8},
166	{ST_L1_F8, EV_IND_AI10, l1_go_f8},
167	{ST_L1_F8, EV_IND_RSY, l1_ignore},
168	};
169
9920239c JP	170	static __attribute__((format(printf, 2, 3)))
9920239c JP	171	void l1m_debug(struct FsmInst fi, char fmt, ...)
1da177e4 LT	172	{
	173	va_list args;
	174	char buf[256];
	175
	176	va_start(args, fmt);
0b2dd130	177	vsnprintf(buf, sizeof(buf), fmt, args);
1da177e4 LT	178	DBG(8, "%s", buf);
	179	va_end(args);
	180	}
	181
	182	/* ======================================================================
	183	* D-Channel out
	184	*/
	185
	186	/*
	187	D OUT state machine:
	188	====================
	189
	190	Transmit short frame (< 16 bytes of encoded data):
	191
	192	L1 FRAME D_OUT_STATE USB D CHANNEL
	193	-------- ----------- --- ---------
	194
	195	FIXME
	196
	197	-> [xx..xx] SHORT_INIT -> [7Exx..xxC1C27EFF]
	198	SHORT_WAIT_DEN <> OUT_D_COUNTER=16
	199
	200	END_OF_SHORT <- DEN_EVENT -> 7Exx
	201	xxxx
	202	xxxx
	203	xxxx
	204	xxxx
	205	xxxx
	206	C1C1
	207	7EFF
	208	WAIT_FOR_RESET_IDLE <- D_UNDERRUN <- (8ms)
	209	IDLE <> Reset pipe
	210
	211
	212
	213	Transmit long frame (>= 16 bytes of encoded data):
	214
	215	L1 FRAME D_OUT_STATE USB D CHANNEL
	216	-------- ----------- --- ---------
	217
	218	-> [xx...xx] IDLE
	219	WAIT_FOR_STOP <> OUT_D_COUNTER=0
	220	WAIT_FOR_RESET <> Reset pipe
	221	STOP
	222	INIT_LONG_FRAME -> [7Exx..xx]
	223	WAIT_DEN <> OUT_D_COUNTER=16
	224	OUT_NORMAL <- DEN_EVENT -> 7Exx
	225	END_OF_FRAME_BUSY -> [xxxx] xxxx
	226	END_OF_FRAME_NOT_BUSY -> [xxxx] xxxx
	227	-> [xxxx] xxxx
	228	-> [C1C2] xxxx
	229	-> [7EFF] xxxx
	230	xxxx
	231	xxxx
	232	....
	233	xxxx
	234	C1C2
	235	7EFF
	236	<- D_UNDERRUN <- (> 8ms)
	237	WAIT_FOR_STOP <> OUT_D_COUNTER=0
	238	WAIT_FOR_RESET <> Reset pipe
	239	STOP
	240
	241	*/
242
243	static struct Fsm dout_fsm;
244
245	static char *strDoutState[] =
246	{
247	"ST_DOUT_NONE",
248
249	"ST_DOUT_SHORT_INIT",
250	"ST_DOUT_SHORT_WAIT_DEN",
251
252	"ST_DOUT_LONG_INIT",
253	"ST_DOUT_LONG_WAIT_DEN",
254	"ST_DOUT_NORMAL",
255
256	"ST_DOUT_WAIT_FOR_UNDERRUN",
257	"ST_DOUT_WAIT_FOR_NOT_BUSY",
258	"ST_DOUT_WAIT_FOR_STOP",
259	"ST_DOUT_WAIT_FOR_RESET",
260	};
261
262	static char *strDoutEvent[] =
263	{
264	"EV_DOUT_START_XMIT",
265	"EV_DOUT_COMPLETE",
266	"EV_DOUT_DEN",
267	"EV_DOUT_RESETED",
268	"EV_DOUT_STOPPED",
269	"EV_DOUT_COLL",
270	"EV_DOUT_UNDERRUN",
271	};
272
9920239c JP	273	static __attribute__((format(printf, 2, 3)))
9920239c JP	274	void dout_debug(struct FsmInst fi, char fmt, ...)
1da177e4 LT	275	{
	276	va_list args;
	277	char buf[256];
	278
	279	va_start(args, fmt);
0b2dd130	280	vsnprintf(buf, sizeof(buf), fmt, args);
1da177e4 LT	281	DBG(0x2, "%s", buf);
	282	va_end(args);
	283	}
	284
	285	static void dout_stop_event(void *context)
	286	{
	287	struct st5481_adapter *adapter = context;
	288
	289	FsmEvent(&adapter->d_out.fsm, EV_DOUT_STOPPED, NULL);
	290	}
	291
	292	/*
	293	* Start the transfer of a D channel frame.
	294	*/
	295	static void usb_d_out(struct st5481_adapter *adapter, int buf_nr)
	296	{
	297	struct st5481_d_out *d_out = &adapter->d_out;
	298	struct urb *urb;
	299	unsigned int num_packets, packet_offset;
	300	int len, buf_size, bytes_sent;
	301	struct sk_buff *skb;
	302	struct usb_iso_packet_descriptor *desc;
	303
	304	if (d_out->fsm.state != ST_DOUT_NORMAL)
	305	return;
	306
	307	if (test_and_set_bit(buf_nr, &d_out->busy)) {
	308	DBG(2, "ep %d urb %d busy %#lx", EP_D_OUT, buf_nr, d_out->busy);
	309	return;
	310	}
	311	urb = d_out->urb[buf_nr];
	312
	313	skb = d_out->tx_skb;
	314
	315	buf_size = NUM_ISO_PACKETS_D * SIZE_ISO_PACKETS_D_OUT;
	316
	317	if (skb) {
	318	len = isdnhdlc_encode(&d_out->hdlc_state,
	319	skb->data, skb->len, &bytes_sent,
	320	urb->transfer_buffer, buf_size);
	321	skb_pull(skb,bytes_sent);
	322	} else {
	323	// Send flags or idle
	324	len = isdnhdlc_encode(&d_out->hdlc_state,
	325	NULL, 0, &bytes_sent,
	326	urb->transfer_buffer, buf_size);
	327	}
	328
	329	if (len < buf_size) {
	330	FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_UNDERRUN);
	331	}
	332	if (skb && !skb->len) {
	333	d_out->tx_skb = NULL;
	334	D_L1L2(adapter, PH_DATA \| CONFIRM, NULL);
	335	dev_kfree_skb_any(skb);
	336	}
	337
	338	// Prepare the URB
	339	urb->transfer_buffer_length = len;
	340	num_packets = 0;
	341	packet_offset = 0;
	342	while (packet_offset < len) {
	343	desc = &urb->iso_frame_desc[num_packets];
	344	desc->offset = packet_offset;
345	desc->length = SIZE_ISO_PACKETS_D_OUT;
346	if (len - packet_offset < desc->length)
347	desc->length = len - packet_offset;
348	num_packets++;
349	packet_offset += desc->length;
350	}
351	urb->number_of_packets = num_packets;
352
353	// Prepare the URB
354	urb->dev = adapter->usb_dev;
355	// Need to transmit the next buffer 2ms after the DEN_EVENT
356	urb->transfer_flags = 0;
357	urb->start_frame = usb_get_current_frame_number(adapter->usb_dev)+2;
358
359	DBG_ISO_PACKET(0x20,urb);
360
361	if (usb_submit_urb(urb, GFP_KERNEL) < 0) {
362	// There is another URB queued up
363	urb->transfer_flags = URB_ISO_ASAP;
364	SUBMIT_URB(urb, GFP_KERNEL);
365	}
366	}
367
368	static void fifo_reseted(void *context)
369	{
370	struct st5481_adapter *adapter = context;
371
372	FsmEvent(&adapter->d_out.fsm, EV_DOUT_RESETED, NULL);
373	}
374
7d12e780	375	static void usb_d_out_complete(struct urb *urb)
1da177e4 LT	376	{
	377	struct st5481_adapter *adapter = urb->context;
	378	struct st5481_d_out *d_out = &adapter->d_out;
17a4506d	379	long buf_nr;
1da177e4 LT	380
	381	DBG(2, "");
	382
	383	buf_nr = get_buf_nr(d_out->urb, urb);
	384	test_and_clear_bit(buf_nr, &d_out->busy);
	385
	386	if (unlikely(urb->status < 0)) {
61ffcafa KK	387	switch (urb->status) {
	388	case -ENOENT:
	389	case -ESHUTDOWN:
	390	case -ECONNRESET:
	391	DBG(1,"urb killed status %d", urb->status);
	392	break;
	393	default:
b6c63937	394	WARNING("urb status %d",urb->status);
61ffcafa KK	395	if (d_out->busy == 0) {
	396	st5481_usb_pipe_reset(adapter, EP_D_OUT \| USB_DIR_OUT, fifo_reseted, adapter);
	397	}
	398	break;
1da177e4	399	}
61ffcafa	400	return; // Give up
1da177e4 LT	401	}
	402
	403	FsmEvent(&adapter->d_out.fsm, EV_DOUT_COMPLETE, (void *) buf_nr);
	404	}
	405
	406	/* ====================================================================== */
	407
	408	static void dout_start_xmit(struct FsmInst fsm, int event, void arg)
	409	{
	410	// FIXME unify?
	411	struct st5481_adapter *adapter = fsm->userdata;
	412	struct st5481_d_out *d_out = &adapter->d_out;
	413	struct urb *urb;
	414	int len, bytes_sent;
	415	struct sk_buff *skb;
	416	int buf_nr = 0;
	417
	418	skb = d_out->tx_skb;
	419
	420	DBG(2,"len=%d",skb->len);
	421
c38fc3bc	422	isdnhdlc_out_init(&d_out->hdlc_state, HDLC_DCHANNEL \| HDLC_BITREVERSE);
1da177e4 LT	423
1da177e4 LT	424	if (test_and_set_bit(buf_nr, &d_out->busy)) {
b6c63937	425	WARNING("ep %d urb %d busy %#lx", EP_D_OUT, buf_nr, d_out->busy);
1da177e4 LT	426	return;
	427	}
	428	urb = d_out->urb[buf_nr];
	429
	430	DBG_SKB(0x10, skb);
	431	len = isdnhdlc_encode(&d_out->hdlc_state,
	432	skb->data, skb->len, &bytes_sent,
	433	urb->transfer_buffer, 16);
	434	skb_pull(skb, bytes_sent);
	435
	436	if(len < 16)
	437	FsmChangeState(&d_out->fsm, ST_DOUT_SHORT_INIT);
	438	else
	439	FsmChangeState(&d_out->fsm, ST_DOUT_LONG_INIT);
	440
	441	if (skb->len == 0) {
	442	d_out->tx_skb = NULL;
	443	D_L1L2(adapter, PH_DATA \| CONFIRM, NULL);
	444	dev_kfree_skb_any(skb);
	445	}
	446
	447	// Prepare the URB
	448	urb->transfer_buffer_length = len;
	449
	450	urb->iso_frame_desc[0].offset = 0;
	451	urb->iso_frame_desc[0].length = len;
	452	urb->number_of_packets = 1;
	453
	454	// Prepare the URB
	455	urb->dev = adapter->usb_dev;
	456	urb->transfer_flags = URB_ISO_ASAP;
	457
	458	DBG_ISO_PACKET(0x20,urb);
	459	SUBMIT_URB(urb, GFP_KERNEL);
	460	}
	461
	462	static void dout_short_fifo(struct FsmInst fsm, int event, void arg)
	463	{
	464	struct st5481_adapter *adapter = fsm->userdata;
	465	struct st5481_d_out *d_out = &adapter->d_out;
	466
	467	FsmChangeState(&d_out->fsm, ST_DOUT_SHORT_WAIT_DEN);
	468	st5481_usb_device_ctrl_msg(adapter, OUT_D_COUNTER, 16, NULL, NULL);
	469	}
	470
	471	static void dout_end_short_frame(struct FsmInst fsm, int event, void arg)
	472	{
	473	struct st5481_adapter *adapter = fsm->userdata;
	474	struct st5481_d_out *d_out = &adapter->d_out;
	475
	476	FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_UNDERRUN);
	477	}
	478
	479	static void dout_long_enable_fifo(struct FsmInst fsm, int event, void arg)
	480	{
	481	struct st5481_adapter *adapter = fsm->userdata;
	482	struct st5481_d_out *d_out = &adapter->d_out;
	483
	484	st5481_usb_device_ctrl_msg(adapter, OUT_D_COUNTER, 16, NULL, NULL);
	485	FsmChangeState(&d_out->fsm, ST_DOUT_LONG_WAIT_DEN);
	486	}
	487
	488	static void dout_long_den(struct FsmInst fsm, int event, void arg)
	489	{
490	struct st5481_adapter *adapter = fsm->userdata;
491	struct st5481_d_out *d_out = &adapter->d_out;
492
493	FsmChangeState(&d_out->fsm, ST_DOUT_NORMAL);
494	usb_d_out(adapter, 0);
495	usb_d_out(adapter, 1);
496	}
497
498	static void dout_reset(struct FsmInst fsm, int event, void arg)
499	{
500	struct st5481_adapter *adapter = fsm->userdata;
501	struct st5481_d_out *d_out = &adapter->d_out;
502
503	FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_RESET);
504	st5481_usb_pipe_reset(adapter, EP_D_OUT \| USB_DIR_OUT, fifo_reseted, adapter);
505	}
506
507	static void dout_stop(struct FsmInst fsm, int event, void arg)
508	{
509	struct st5481_adapter *adapter = fsm->userdata;
510	struct st5481_d_out *d_out = &adapter->d_out;
511
512	FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_STOP);
513	st5481_usb_device_ctrl_msg(adapter, OUT_D_COUNTER, 0, dout_stop_event, adapter);
514	}
515
516	static void dout_underrun(struct FsmInst fsm, int event, void arg)
517	{
518	struct st5481_adapter *adapter = fsm->userdata;
519	struct st5481_d_out *d_out = &adapter->d_out;
520
521	if (test_bit(0, &d_out->busy) \|\| test_bit(1, &d_out->busy)) {
522	FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_NOT_BUSY);
523	} else {
524	dout_stop(fsm, event, arg);
525	}
526	}
527
528	static void dout_check_busy(struct FsmInst fsm, int event, void arg)
529	{
530	struct st5481_adapter *adapter = fsm->userdata;
531	struct st5481_d_out *d_out = &adapter->d_out;
532
533	if (!test_bit(0, &d_out->busy) && !test_bit(1, &d_out->busy))
534	dout_stop(fsm, event, arg);
535	}
536
537	static void dout_reseted(struct FsmInst fsm, int event, void arg)
538	{
539	struct st5481_adapter *adapter = fsm->userdata;
540	struct st5481_d_out *d_out = &adapter->d_out;
541
542	FsmChangeState(&d_out->fsm, ST_DOUT_NONE);
543	// FIXME locking
544	if (d_out->tx_skb)
545	FsmEvent(&d_out->fsm, EV_DOUT_START_XMIT, NULL);
546	}
547
548	static void dout_complete(struct FsmInst fsm, int event, void arg)
549	{
550	struct st5481_adapter *adapter = fsm->userdata;
17a4506d	551	long buf_nr = (long) arg;
1da177e4 LT	552
	553	usb_d_out(adapter, buf_nr);
	554	}
	555
	556	static void dout_ignore(struct FsmInst fsm, int event, void arg)
	557	{
	558	}
	559
	560	static struct FsmNode DoutFnList[] __initdata =
	561	{
	562	{ST_DOUT_NONE, EV_DOUT_START_XMIT, dout_start_xmit},
	563
	564	{ST_DOUT_SHORT_INIT, EV_DOUT_COMPLETE, dout_short_fifo},
	565
	566	{ST_DOUT_SHORT_WAIT_DEN, EV_DOUT_DEN, dout_end_short_frame},
	567	{ST_DOUT_SHORT_WAIT_DEN, EV_DOUT_UNDERRUN, dout_underrun},
	568
	569	{ST_DOUT_LONG_INIT, EV_DOUT_COMPLETE, dout_long_enable_fifo},
	570
	571	{ST_DOUT_LONG_WAIT_DEN, EV_DOUT_DEN, dout_long_den},
	572	{ST_DOUT_LONG_WAIT_DEN, EV_DOUT_UNDERRUN, dout_underrun},
	573
	574	{ST_DOUT_NORMAL, EV_DOUT_UNDERRUN, dout_underrun},
	575	{ST_DOUT_NORMAL, EV_DOUT_COMPLETE, dout_complete},
	576
	577	{ST_DOUT_WAIT_FOR_UNDERRUN, EV_DOUT_UNDERRUN, dout_underrun},
	578	{ST_DOUT_WAIT_FOR_UNDERRUN, EV_DOUT_COMPLETE, dout_ignore},
	579
	580	{ST_DOUT_WAIT_FOR_NOT_BUSY, EV_DOUT_COMPLETE, dout_check_busy},
	581
	582	{ST_DOUT_WAIT_FOR_STOP, EV_DOUT_STOPPED, dout_reset},
	583
	584	{ST_DOUT_WAIT_FOR_RESET, EV_DOUT_RESETED, dout_reseted},
	585	};
	586
	587	void st5481_d_l2l1(struct hisax_if hisax_d_if, int pr, void arg)
	588	{
	589	struct st5481_adapter *adapter = hisax_d_if->priv;
	590	struct sk_buff *skb = arg;
	591
	592	switch (pr) {
	593	case PH_ACTIVATE \| REQUEST:
	594	FsmEvent(&adapter->l1m, EV_PH_ACTIVATE_REQ, NULL);
	595	break;
	596	case PH_DEACTIVATE \| REQUEST:
	597	FsmEvent(&adapter->l1m, EV_PH_DEACTIVATE_REQ, NULL);
	598	break;
	599	case PH_DATA \| REQUEST:
	600	DBG(2, "PH_DATA REQUEST len %d", skb->len);
6dd44a74	601	BUG_ON(adapter->d_out.tx_skb);
1da177e4 LT	602	adapter->d_out.tx_skb = skb;
	603	FsmEvent(&adapter->d_out.fsm, EV_DOUT_START_XMIT, NULL);
	604	break;
	605	default:
b6c63937	606	WARNING("pr %#x\n", pr);
1da177e4 LT	607	break;
	608	}
	609	}
	610
	611	/* ======================================================================
	612	*/
	613
	614	/*
	615	* Start receiving on the D channel since entered state F7.
	616	*/
	617	static void ph_connect(struct st5481_adapter *adapter)
	618	{
	619	struct st5481_d_out *d_out = &adapter->d_out;
	620	struct st5481_in *d_in = &adapter->d_in;
	621
	622	DBG(8,"");
	623
	624	FsmChangeState(&d_out->fsm, ST_DOUT_NONE);
	625
	626	// st5481_usb_device_ctrl_msg(adapter, FFMSK_D, OUT_UNDERRUN, NULL, NULL);
	627	st5481_usb_device_ctrl_msg(adapter, FFMSK_D, 0xfc, NULL, NULL);
	628	st5481_in_mode(d_in, L1_MODE_HDLC);
	629
	630	#ifdef LOOPBACK
	631	// Turn loopback on (data sent on B and D looped back)
	632	st5481_usb_device_ctrl_msg(cs, LBB, 0x04, NULL, NULL);
	633	#endif
	634
	635	st5481_usb_pipe_reset(adapter, EP_D_OUT \| USB_DIR_OUT, NULL, NULL);
	636
	637	// Turn on the green LED to tell that we are in state F7
	638	adapter->leds \|= GREEN_LED;
	639	st5481_usb_device_ctrl_msg(adapter, GPIO_OUT, adapter->leds, NULL, NULL);
	640	}
	641
	642	/*
	643	* Stop receiving on the D channel since not in state F7.
	644	*/
	645	static void ph_disconnect(struct st5481_adapter *adapter)
	646	{
	647	DBG(8,"");
	648
	649	st5481_in_mode(&adapter->d_in, L1_MODE_NULL);
	650
	651	// Turn off the green LED to tell that we left state F7
	652	adapter->leds &= ~GREEN_LED;
	653	st5481_usb_device_ctrl_msg(adapter, GPIO_OUT, adapter->leds, NULL, NULL);
	654	}
	655
	656	static int st5481_setup_d_out(struct st5481_adapter *adapter)
	657	{
	658	struct usb_device *dev = adapter->usb_dev;
	659	struct usb_interface *intf;
	660	struct usb_host_interface *altsetting = NULL;
	661	struct usb_host_endpoint *endpoint;
	662	struct st5481_d_out *d_out = &adapter->d_out;
	663
	664	DBG(2,"");
	665
	666	intf = usb_ifnum_to_if(dev, 0);
	667	if (intf)
	668	altsetting = usb_altnum_to_altsetting(intf, 3);
	669	if (!altsetting)
	670	return -ENXIO;
671
672	// Allocate URBs and buffers for the D channel out
673	endpoint = &altsetting->endpoint[EP_D_OUT-1];
674
675	DBG(2,"endpoint address=%02x,packet size=%d",
676	endpoint->desc.bEndpointAddress, le16_to_cpu(endpoint->desc.wMaxPacketSize));
677
678	return st5481_setup_isocpipes(d_out->urb, dev,
679	usb_sndisocpipe(dev, endpoint->desc.bEndpointAddress),
680	NUM_ISO_PACKETS_D, SIZE_ISO_PACKETS_D_OUT,
681	NUM_ISO_PACKETS_D * SIZE_ISO_PACKETS_D_OUT,
682	usb_d_out_complete, adapter);
683	}
684
685	static void st5481_release_d_out(struct st5481_adapter *adapter)
686	{
687	struct st5481_d_out *d_out = &adapter->d_out;
688
689	DBG(2,"");
690
691	st5481_release_isocpipes(d_out->urb);
692	}
693
694	int st5481_setup_d(struct st5481_adapter *adapter)
695	{
696	int retval;
697
698	DBG(2,"");
699
700	retval = st5481_setup_d_out(adapter);
701	if (retval)
702	goto err;
703	adapter->d_in.bufsize = MAX_DFRAME_LEN_L1;
704	adapter->d_in.num_packets = NUM_ISO_PACKETS_D;
705	adapter->d_in.packet_size = SIZE_ISO_PACKETS_D_IN;
706	adapter->d_in.ep = EP_D_IN \| USB_DIR_IN;
707	adapter->d_in.counter = IN_D_COUNTER;
708	adapter->d_in.adapter = adapter;
709	adapter->d_in.hisax_if = &adapter->hisax_d_if.ifc;
710	retval = st5481_setup_in(&adapter->d_in);
711	if (retval)
712	goto err_d_out;
713
714	adapter->l1m.fsm = &l1fsm;
715	adapter->l1m.state = ST_L1_F3;
61ffcafa	716	adapter->l1m.debug = st5481_debug & 0x100;
1da177e4 LT	717	adapter->l1m.userdata = adapter;
	718	adapter->l1m.printdebug = l1m_debug;
	719	FsmInitTimer(&adapter->l1m, &adapter->timer);
	720
	721	adapter->d_out.fsm.fsm = &dout_fsm;
	722	adapter->d_out.fsm.state = ST_DOUT_NONE;
61ffcafa	723	adapter->d_out.fsm.debug = st5481_debug & 0x100;
1da177e4 LT	724	adapter->d_out.fsm.userdata = adapter;
	725	adapter->d_out.fsm.printdebug = dout_debug;
	726
	727	return 0;
	728
	729	err_d_out:
	730	st5481_release_d_out(adapter);
	731	err:
	732	return retval;
	733	}
	734
	735	void st5481_release_d(struct st5481_adapter *adapter)
	736	{
	737	DBG(2,"");
	738
	739	st5481_release_in(&adapter->d_in);
	740	st5481_release_d_out(adapter);
	741	}
	742
	743	/* ======================================================================
	744	* init / exit
	745	*/
	746
	747	int __init st5481_d_init(void)
	748	{
	749	int retval;
	750
	751	l1fsm.state_count = L1_STATE_COUNT;
	752	l1fsm.event_count = L1_EVENT_COUNT;
	753	l1fsm.strEvent = strL1Event;
	754	l1fsm.strState = strL1State;
	755	retval = FsmNew(&l1fsm, L1FnList, ARRAY_SIZE(L1FnList));
	756	if (retval)
	757	goto err;
	758
	759	dout_fsm.state_count = DOUT_STATE_COUNT;
	760	dout_fsm.event_count = DOUT_EVENT_COUNT;
	761	dout_fsm.strEvent = strDoutEvent;
	762	dout_fsm.strState = strDoutState;
	763	retval = FsmNew(&dout_fsm, DoutFnList, ARRAY_SIZE(DoutFnList));
	764	if (retval)
	765	goto err_l1;
	766
	767	return 0;
	768
	769	err_l1:
	770	FsmFree(&l1fsm);
	771	err:
	772	return retval;
	773	}
	774
	775	// can't be __exit
	776	void st5481_d_exit(void)
	777	{
	778	FsmFree(&l1fsm);
	779	FsmFree(&dout_fsm);
	780	}