drivers/isdn/hisax/st5481_b.c

   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>
  14 #include <linux/usb.h>
  15 #include <linux/slab.h>
  16 #include <linux/netdevice.h>
  17 #include "st5481.h"
  18
  19 static inline void B_L1L2(struct st5481_bcs *bcs, int pr, void *arg)
  20 {
  21         struct hisax_if *ifc = (struct hisax_if *) &bcs->b_if;
  22
  23         ifc->l1l2(ifc, pr, arg);
  24 }
  25
  26 /*
  27  * Encode and transmit next frame.
  28  */
  29 static void usb_b_out(struct st5481_bcs *bcs,int buf_nr)
  30 {
  31         struct st5481_b_out *b_out = &bcs->b_out;
  32         struct st5481_adapter *adapter = bcs->adapter;
  33         struct urb *urb;
  34         unsigned int packet_size,offset;
  35         int len,buf_size,bytes_sent;
  36         int i;
  37         struct sk_buff *skb;
  38
  39         if (test_and_set_bit(buf_nr, &b_out->busy)) {
  40                 DBG(4,"ep %d urb %d busy",(bcs->channel+1)*2,buf_nr);
  41                 return;
  42         }
  43         urb = b_out->urb[buf_nr];
  44
  45         // Adjust isoc buffer size according to flow state
  46         if(b_out->flow_event & (OUT_DOWN | OUT_UNDERRUN)) {
  47                 buf_size = NUM_ISO_PACKETS_B*SIZE_ISO_PACKETS_B_OUT + B_FLOW_ADJUST;
  48                 packet_size = SIZE_ISO_PACKETS_B_OUT + B_FLOW_ADJUST;
  49                 DBG(4,"B%d,adjust flow,add %d bytes",bcs->channel+1,B_FLOW_ADJUST);
  50         } else if(b_out->flow_event & OUT_UP){
  51                 buf_size = NUM_ISO_PACKETS_B*SIZE_ISO_PACKETS_B_OUT - B_FLOW_ADJUST;
  52                 packet_size = SIZE_ISO_PACKETS_B_OUT - B_FLOW_ADJUST;
  53                 DBG(4,"B%d,adjust flow,remove %d bytes",bcs->channel+1,B_FLOW_ADJUST);
  54         } else {
  55                 buf_size = NUM_ISO_PACKETS_B*SIZE_ISO_PACKETS_B_OUT;
  56                 packet_size = 8;
  57         }
  58         b_out->flow_event = 0;
  59
  60         len = 0;
  61         while (len < buf_size) {
  62                 if ((skb = b_out->tx_skb)) {
  63                         DBG_SKB(0x100, skb);
  64                         DBG(4,"B%d,len=%d",bcs->channel+1,skb->len);
  65
  66                         if (bcs->mode == L1_MODE_TRANS) {
  67                                 bytes_sent = buf_size - len;
  68                                 if (skb->len < bytes_sent)
  69                                         bytes_sent = skb->len;
  70                                 {       /* swap tx bytes to get hearable audio data */
  71                                         register unsigned char *src  = skb->data;
  72                                         register unsigned char *dest = urb->transfer_buffer+len;
  73                                         register unsigned int count;
  74                                         for (count = 0; count < bytes_sent; count++)
  75                                                 *dest++ = isdnhdlc_bit_rev_tab[*src++];
  76                                 }
  77                                 len += bytes_sent;
  78                         } else {
  79                                 len += isdnhdlc_encode(&b_out->hdlc_state,
  80                                                        skb->data, skb->len, &bytes_sent,
  81                                                        urb->transfer_buffer+len, buf_size-len);
  82                         }
  83
  84                         skb_pull(skb, bytes_sent);
  85
  86                         if (!skb->len) {
  87                                 // Frame sent
  88                                 b_out->tx_skb = NULL;
  89                                 B_L1L2(bcs, PH_DATA | CONFIRM, (void *) skb->truesize);
  90                                 dev_kfree_skb_any(skb);
  91
  92 /*                              if (!(bcs->tx_skb = skb_dequeue(&bcs->sq))) { */
  93 /*                                      st5481B_sched_event(bcs, B_XMTBUFREADY); */
  94 /*                              } */
  95                         }
  96                 } else {
  97                         if (bcs->mode == L1_MODE_TRANS) {
  98                                 memset(urb->transfer_buffer+len, 0xff, buf_size-len);
  99                                 len = buf_size;
 100                         } else {
 101                                 // Send flags
 102                                 len += isdnhdlc_encode(&b_out->hdlc_state,
 103                                                        NULL, 0, &bytes_sent,
 104                                                        urb->transfer_buffer+len, buf_size-len);
 105                         }
 106                 }
 107         }
 108
 109         // Prepare the URB
 110         for (i = 0, offset = 0; offset < len; i++) {
 111                 urb->iso_frame_desc[i].offset = offset;
 112                 urb->iso_frame_desc[i].length = packet_size;
 113                 offset += packet_size;
 114                 packet_size = SIZE_ISO_PACKETS_B_OUT;
 115         }
 116         urb->transfer_buffer_length = len;
 117         urb->number_of_packets = i;
 118         urb->dev = adapter->usb_dev;
 119
 120         DBG_ISO_PACKET(0x200,urb);
 121
 122         SUBMIT_URB(urb, GFP_NOIO);
 123 }
 124
 125 /*
 126  * Start transfering (flags or data) on the B channel, since
 127  * FIFO counters has been set to a non-zero value.
 128  */
 129 static void st5481B_start_xfer(void *context)
 130 {
 131         struct st5481_bcs *bcs = context;
 132
 133         DBG(4,"B%d",bcs->channel+1);
 134
 135         // Start transmitting (flags or data) on B channel
 136
 137         usb_b_out(bcs,0);
 138         usb_b_out(bcs,1);
 139 }
 140
 141 /*
 142  * If the adapter has only 2 LEDs, the green
 143  * LED will blink with a rate depending
 144  * on the number of channels opened.
 145  */
 146 static void led_blink(struct st5481_adapter *adapter)
 147 {
 148         u_char leds = adapter->leds;
 149
 150         // 50 frames/sec for each channel
 151         if (++adapter->led_counter % 50) {
 152                 return;
 153         }
 154
 155         if (adapter->led_counter % 100) {
 156                 leds |= GREEN_LED;
 157         } else {
 158                 leds &= ~GREEN_LED;
 159         }
 160
 161         st5481_usb_device_ctrl_msg(adapter, GPIO_OUT, leds, NULL, NULL);
 162 }
 163
 164 static void usb_b_out_complete(struct urb *urb, struct pt_regs *regs)
 165 {
 166         struct st5481_bcs *bcs = urb->context;
 167         struct st5481_b_out *b_out = &bcs->b_out;
 168         struct st5481_adapter *adapter = bcs->adapter;
 169         int buf_nr;
 170
 171         buf_nr = get_buf_nr(b_out->urb, urb);
 172         test_and_clear_bit(buf_nr, &b_out->busy);
 173
 174         if (unlikely(urb->status < 0)) {
 175                 switch (urb->status) {
 176                         case -ENOENT:
 177                         case -ESHUTDOWN:
 178                         case -ECONNRESET:
 179                                 DBG(4,"urb killed status %d", urb->status);
 180                                 return; // Give up
 181                         default:
 182                                 WARN("urb status %d",urb->status);
 183                                 if (b_out->busy == 0) {
 184                                         st5481_usb_pipe_reset(adapter, (bcs->channel+1)*2 | USB_DIR_OUT, NULL, NULL);
 185                                 }
 186                                 break;
 187                 }
 188         }
 189
 190         usb_b_out(bcs,buf_nr);
 191
 192         if (adapter->number_of_leds == 2)
 193                 led_blink(adapter);
 194 }
 195
 196 /*
 197  * Start or stop the transfer on the B channel.
 198  */
 199 static void st5481B_mode(struct st5481_bcs *bcs, int mode)
 200 {
 201         struct st5481_b_out *b_out = &bcs->b_out;
 202         struct st5481_adapter *adapter = bcs->adapter;
 203
 204         DBG(4,"B%d,mode=%d", bcs->channel + 1, mode);
 205
 206         if (bcs->mode == mode)
 207                 return;
 208
 209         bcs->mode = mode;
 210
 211         // Cancel all USB transfers on this B channel
 212         b_out->urb[0]->transfer_flags |= URB_ASYNC_UNLINK;
 213         usb_unlink_urb(b_out->urb[0]);
 214         b_out->urb[1]->transfer_flags |= URB_ASYNC_UNLINK;
 215         usb_unlink_urb(b_out->urb[1]);
 216         b_out->busy = 0;
 217
 218         st5481_in_mode(&bcs->b_in, mode);
 219         if (bcs->mode != L1_MODE_NULL) {
 220                 // Open the B channel
 221                 if (bcs->mode != L1_MODE_TRANS) {
 222                         isdnhdlc_out_init(&b_out->hdlc_state, 0, bcs->mode == L1_MODE_HDLC_56K);
 223                 }
 224                 st5481_usb_pipe_reset(adapter, (bcs->channel+1)*2, NULL, NULL);
 225
 226                 // Enable B channel interrupts
 227                 st5481_usb_device_ctrl_msg(adapter, FFMSK_B1+(bcs->channel*2),
 228                                     OUT_UP+OUT_DOWN+OUT_UNDERRUN, NULL, NULL);
 229
 230                 // Enable B channel FIFOs
 231                 st5481_usb_device_ctrl_msg(adapter, OUT_B1_COUNTER+(bcs->channel*2), 32, st5481B_start_xfer, bcs);
 232                 if (adapter->number_of_leds == 4) {
 233                         if (bcs->channel == 0) {
 234                                 adapter->leds |= B1_LED;
 235                         } else {
 236                                 adapter->leds |= B2_LED;
 237                         }
 238                 }
 239         } else {
 240                 // Disble B channel interrupts
 241                 st5481_usb_device_ctrl_msg(adapter, FFMSK_B1+(bcs->channel*2), 0, NULL, NULL);
 242
 243                 // Disable B channel FIFOs
 244                 st5481_usb_device_ctrl_msg(adapter, OUT_B1_COUNTER+(bcs->channel*2), 0, NULL, NULL);
 245
 246                 if (adapter->number_of_leds == 4) {
 247                         if (bcs->channel == 0) {
 248                                 adapter->leds &= ~B1_LED;
 249                         } else {
 250                                 adapter->leds &= ~B2_LED;
 251                         }
 252                 } else {
 253                         st5481_usb_device_ctrl_msg(adapter, GPIO_OUT, adapter->leds, NULL, NULL);
 254                 }
 255                 if (b_out->tx_skb) {
 256                         dev_kfree_skb_any(b_out->tx_skb);
 257                         b_out->tx_skb = NULL;
 258                 }
 259
 260         }
 261 }
 262
 263 static int st5481_setup_b_out(struct st5481_bcs *bcs)
 264 {
 265         struct usb_device *dev = bcs->adapter->usb_dev;
 266         struct usb_interface *intf;
 267         struct usb_host_interface *altsetting = NULL;
 268         struct usb_host_endpoint *endpoint;
 269         struct st5481_b_out *b_out = &bcs->b_out;
 270
 271         DBG(4,"");
 272
 273         intf = usb_ifnum_to_if(dev, 0);
 274         if (intf)
 275                 altsetting = usb_altnum_to_altsetting(intf, 3);
 276         if (!altsetting)
 277                 return -ENXIO;
 278
 279         // Allocate URBs and buffers for the B channel out
 280         endpoint = &altsetting->endpoint[EP_B1_OUT - 1 + bcs->channel * 2];
 281
 282         DBG(4,"endpoint address=%02x,packet size=%d",
 283             endpoint->desc.bEndpointAddress, le16_to_cpu(endpoint->desc.wMaxPacketSize));
 284
 285         // Allocate memory for 8000bytes/sec + extra bytes if underrun
 286         return st5481_setup_isocpipes(b_out->urb, dev,
 287                                       usb_sndisocpipe(dev, endpoint->desc.bEndpointAddress),
 288                                       NUM_ISO_PACKETS_B, SIZE_ISO_PACKETS_B_OUT,
 289                                       NUM_ISO_PACKETS_B * SIZE_ISO_PACKETS_B_OUT + B_FLOW_ADJUST,
 290                                       usb_b_out_complete, bcs);
 291 }
 292
 293 static void st5481_release_b_out(struct st5481_bcs *bcs)
 294 {
 295         struct st5481_b_out *b_out = &bcs->b_out;
 296
 297         DBG(4,"");
 298
 299         st5481_release_isocpipes(b_out->urb);
 300 }
 301
 302 int st5481_setup_b(struct st5481_bcs *bcs)
 303 {
 304         int retval;
 305
 306         DBG(4,"");
 307
 308         retval = st5481_setup_b_out(bcs);
 309         if (retval)
 310                 goto err;
 311         bcs->b_in.bufsize = HSCX_BUFMAX;
 312         bcs->b_in.num_packets = NUM_ISO_PACKETS_B;
 313         bcs->b_in.packet_size = SIZE_ISO_PACKETS_B_IN;
 314         bcs->b_in.ep = (bcs->channel ? EP_B2_IN : EP_B1_IN) | USB_DIR_IN;
 315         bcs->b_in.counter = bcs->channel ? IN_B2_COUNTER : IN_B1_COUNTER;
 316         bcs->b_in.adapter = bcs->adapter;
 317         bcs->b_in.hisax_if = &bcs->b_if.ifc;
 318         retval = st5481_setup_in(&bcs->b_in);
 319         if (retval)
 320                 goto err_b_out;
 321
 322
 323         return 0;
 324
 325  err_b_out:
 326         st5481_release_b_out(bcs);
 327  err:
 328         return retval;
 329 }
 330
 331 /*
 332  * Release buffers and URBs for the B channels
 333  */
 334 void st5481_release_b(struct st5481_bcs *bcs)
 335 {
 336         DBG(4,"");
 337
 338         st5481_release_in(&bcs->b_in);
 339         st5481_release_b_out(bcs);
 340 }
 341
 342 /*
 343  * st5481_b_l2l1 is the entry point for upper layer routines that want to
 344  * transmit on the B channel.  PH_DATA | REQUEST is a normal packet that
 345  * we either start transmitting (if idle) or queue (if busy).
 346  * PH_PULL | REQUEST can be called to request a callback message
 347  * (PH_PULL | CONFIRM)
 348  * once the link is idle.  After a "pull" callback, the upper layer
 349  * routines can use PH_PULL | INDICATION to send data.
 350  */
 351 void st5481_b_l2l1(struct hisax_if *ifc, int pr, void *arg)
 352 {
 353         struct st5481_bcs *bcs = ifc->priv;
 354         struct sk_buff *skb = arg;
 355         int mode;
 356
 357         DBG(4, "");
 358
 359         switch (pr) {
 360         case PH_DATA | REQUEST:
 361                 if (bcs->b_out.tx_skb)
 362                         BUG();
 363
 364                 bcs->b_out.tx_skb = skb;
 365                 break;
 366         case PH_ACTIVATE | REQUEST:
 367                 mode = (int) arg;
 368                 DBG(4,"B%d,PH_ACTIVATE_REQUEST %d", bcs->channel + 1, mode);
 369                 st5481B_mode(bcs, mode);
 370                 B_L1L2(bcs, PH_ACTIVATE | INDICATION, NULL);
 371                 break;
 372         case PH_DEACTIVATE | REQUEST:
 373                 DBG(4,"B%d,PH_DEACTIVATE_REQUEST", bcs->channel + 1);
 374                 st5481B_mode(bcs, L1_MODE_NULL);
 375                 B_L1L2(bcs, PH_DEACTIVATE | INDICATION, NULL);
 376                 break;
 377         default:
 378                 WARN("pr %#x\n", pr);
 379         }
 380 }