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 "st5481.h" 17 18static int st5481_isoc_flatten(struct urb *urb); 19 20/* ====================================================================== 21 * control pipe 22 */ 23 24/* 25 * Send the next endpoint 0 request stored in the FIFO. 26 * Called either by the completion or by usb_ctrl_msg. 27 */ 28static void usb_next_ctrl_msg(struct urb *urb, 29 struct st5481_adapter *adapter) 30{ 31 struct st5481_ctrl *ctrl = &adapter->ctrl; 32 int r_index; 33 34 if (test_and_set_bit(0, &ctrl->busy)) { 35 return; 36 } 37 38 if ((r_index = fifo_remove(&ctrl->msg_fifo.f)) < 0) { 39 test_and_clear_bit(0,&ctrl->busy); 40 return; 41 } 42 urb->setup_packet = 43 (unsigned char *)&ctrl->msg_fifo.data[r_index]; 44 45 DBG(1,"request=0x%02x,value=0x%04x,index=%x", 46 ((struct ctrl_msg *)urb->setup_packet)->dr.bRequest, 47 ((struct ctrl_msg *)urb->setup_packet)->dr.wValue, 48 ((struct ctrl_msg *)urb->setup_packet)->dr.wIndex); 49 50 // Prepare the URB 51 urb->dev = adapter->usb_dev; 52 53 SUBMIT_URB(urb, GFP_ATOMIC); 54} 55 56/* 57 * Asynchronous endpoint 0 request (async version of usb_control_msg). 58 * The request will be queued up in a FIFO if the endpoint is busy. 59 */ 60static void usb_ctrl_msg(struct st5481_adapter *adapter, 61 u8 request, u8 requesttype, u16 value, u16 index, 62 ctrl_complete_t complete, void *context) 63{ 64 struct st5481_ctrl *ctrl = &adapter->ctrl; 65 int w_index; 66 struct ctrl_msg *ctrl_msg; 67 68 if ((w_index = fifo_add(&ctrl->msg_fifo.f)) < 0) { 69 WARN("control msg FIFO full"); 70 return; 71 } 72 ctrl_msg = &ctrl->msg_fifo.data[w_index]; 73 74 ctrl_msg->dr.bRequestType = requesttype; 75 ctrl_msg->dr.bRequest = request; 76 ctrl_msg->dr.wValue = cpu_to_le16p(&value); 77 ctrl_msg->dr.wIndex = cpu_to_le16p(&index); 78 ctrl_msg->dr.wLength = 0; 79 ctrl_msg->complete = complete; 80 ctrl_msg->context = context; 81 82 usb_next_ctrl_msg(ctrl->urb, adapter); 83} 84 85/* 86 * Asynchronous endpoint 0 device request. 87 */ 88void st5481_usb_device_ctrl_msg(struct st5481_adapter *adapter, 89 u8 request, u16 value, 90 ctrl_complete_t complete, void *context) 91{ 92 usb_ctrl_msg(adapter, request, 93 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 94 value, 0, complete, context); 95} 96 97/* 98 * Asynchronous pipe reset (async version of usb_clear_halt). 99 */ 100void st5481_usb_pipe_reset(struct st5481_adapter *adapter, 101 u_char pipe, 102 ctrl_complete_t complete, void *context) 103{ 104 DBG(1,"pipe=%02x",pipe); 105 106 usb_ctrl_msg(adapter, 107 USB_REQ_CLEAR_FEATURE, USB_DIR_OUT | USB_RECIP_ENDPOINT, 108 0, pipe, complete, context); 109} 110 111 112/* 113 Physical level functions 114*/ 115 116void st5481_ph_command(struct st5481_adapter *adapter, unsigned int command) 117{ 118 DBG(8,"command=%s", ST5481_CMD_string(command)); 119 120 st5481_usb_device_ctrl_msg(adapter, TXCI, command, NULL, NULL); 121} 122 123/* 124 * The request on endpoint 0 has completed. 125 * Call the user provided completion routine and try 126 * to send the next request. 127 */ 128static void usb_ctrl_complete(struct urb *urb) 129{ 130 struct st5481_adapter *adapter = urb->context; 131 struct st5481_ctrl *ctrl = &adapter->ctrl; 132 struct ctrl_msg *ctrl_msg; 133 134 if (unlikely(urb->status < 0)) { 135 switch (urb->status) { 136 case -ENOENT: 137 case -ESHUTDOWN: 138 case -ECONNRESET: 139 DBG(1,"urb killed status %d", urb->status); 140 return; // Give up 141 default: 142 WARN("urb status %d",urb->status); 143 break; 144 } 145 } 146 147 ctrl_msg = (struct ctrl_msg *)urb->setup_packet; 148 149 if (ctrl_msg->dr.bRequest == USB_REQ_CLEAR_FEATURE) { 150 /* Special case handling for pipe reset */ 151 le16_to_cpus(&ctrl_msg->dr.wIndex); 152 153 /* toggle is reset on clear */ 154 usb_settoggle(adapter->usb_dev, 155 ctrl_msg->dr.wIndex & ~USB_DIR_IN, 156 (ctrl_msg->dr.wIndex & USB_DIR_IN) == 0, 157 0); 158 159 160 } 161 162 if (ctrl_msg->complete) 163 ctrl_msg->complete(ctrl_msg->context); 164 165 clear_bit(0, &ctrl->busy); 166 167 // Try to send next control message 168 usb_next_ctrl_msg(urb, adapter); 169 return; 170} 171 172/* ====================================================================== 173 * interrupt pipe 174 */ 175 176/* 177 * The interrupt endpoint will be called when any 178 * of the 6 registers changes state (depending on masks). 179 * Decode the register values and schedule a private event. 180 * Called at interrupt. 181 */ 182static void usb_int_complete(struct urb *urb) 183{ 184 u8 *data = urb->transfer_buffer; 185 u8 irqbyte; 186 struct st5481_adapter *adapter = urb->context; 187 int j; 188 int status; 189 190 switch (urb->status) { 191 case 0: 192 /* success */ 193 break; 194 case -ECONNRESET: 195 case -ENOENT: 196 case -ESHUTDOWN: 197 /* this urb is terminated, clean up */ 198 DBG(2, "urb shutting down with status: %d", urb->status); 199 return; 200 default: 201 WARN("nonzero urb status received: %d", urb->status); 202 goto exit; 203 } 204 205 206 DBG_PACKET(2, data, INT_PKT_SIZE); 207 208 if (urb->actual_length == 0) { 209 goto exit; 210 } 211 212 irqbyte = data[MPINT]; 213 if (irqbyte & DEN_INT) 214 FsmEvent(&adapter->d_out.fsm, EV_DOUT_DEN, NULL); 215 216 if (irqbyte & DCOLL_INT) 217 FsmEvent(&adapter->d_out.fsm, EV_DOUT_COLL, NULL); 218 219 irqbyte = data[FFINT_D]; 220 if (irqbyte & OUT_UNDERRUN) 221 FsmEvent(&adapter->d_out.fsm, EV_DOUT_UNDERRUN, NULL); 222 223 if (irqbyte & OUT_DOWN) 224;// printk("OUT_DOWN\n"); 225 226 irqbyte = data[MPINT]; 227 if (irqbyte & RXCI_INT) 228 FsmEvent(&adapter->l1m, data[CCIST] & 0x0f, NULL); 229 230 for (j = 0; j < 2; j++) 231 adapter->bcs[j].b_out.flow_event |= data[FFINT_B1 + j]; 232 233 urb->actual_length = 0; 234 235exit: 236 status = usb_submit_urb (urb, GFP_ATOMIC); 237 if (status) 238 WARN("usb_submit_urb failed with result %d", status); 239} 240 241/* ====================================================================== 242 * initialization 243 */ 244 245int st5481_setup_usb(struct st5481_adapter *adapter) 246{ 247 struct usb_device *dev = adapter->usb_dev; 248 struct st5481_ctrl *ctrl = &adapter->ctrl; 249 struct st5481_intr *intr = &adapter->intr; 250 struct usb_interface *intf; 251 struct usb_host_interface *altsetting = NULL; 252 struct usb_host_endpoint *endpoint; 253 int status; 254 struct urb *urb; 255 u8 *buf; 256 257 DBG(2,""); 258 259 if ((status = usb_reset_configuration (dev)) < 0) { 260 WARN("reset_configuration failed,status=%d",status); 261 return status; 262 } 263 264 intf = usb_ifnum_to_if(dev, 0); 265 if (intf) 266 altsetting = usb_altnum_to_altsetting(intf, 3); 267 if (!altsetting) 268 return -ENXIO; 269 270 // Check if the config is sane 271 if ( altsetting->desc.bNumEndpoints != 7 ) { 272 WARN("expecting 7 got %d endpoints!", altsetting->desc.bNumEndpoints); 273 return -EINVAL; 274 } 275 276 // The descriptor is wrong for some early samples of the ST5481 chip 277 altsetting->endpoint[3].desc.wMaxPacketSize = __constant_cpu_to_le16(32); 278 altsetting->endpoint[4].desc.wMaxPacketSize = __constant_cpu_to_le16(32); 279 280 // Use alternative setting 3 on interface 0 to have 2B+D 281 if ((status = usb_set_interface (dev, 0, 3)) < 0) { 282 WARN("usb_set_interface failed,status=%d",status); 283 return status; 284 } 285 286 // Allocate URB for control endpoint 287 urb = usb_alloc_urb(0, GFP_KERNEL); 288 if (!urb) { 289 return -ENOMEM; 290 } 291 ctrl->urb = urb; 292 293 // Fill the control URB 294 usb_fill_control_urb (urb, dev, 295 usb_sndctrlpipe(dev, 0), 296 NULL, NULL, 0, usb_ctrl_complete, adapter); 297 298 299 fifo_init(&ctrl->msg_fifo.f, ARRAY_SIZE(ctrl->msg_fifo.data)); 300 301 // Allocate URBs and buffers for interrupt endpoint 302 urb = usb_alloc_urb(0, GFP_KERNEL); 303 if (!urb) { 304 return -ENOMEM; 305 } 306 intr->urb = urb; 307 308 buf = kmalloc(INT_PKT_SIZE, GFP_KERNEL); 309 if (!buf) { 310 return -ENOMEM; 311 } 312 313 endpoint = &altsetting->endpoint[EP_INT-1]; 314 315 // Fill the interrupt URB 316 usb_fill_int_urb(urb, dev, 317 usb_rcvintpipe(dev, endpoint->desc.bEndpointAddress), 318 buf, INT_PKT_SIZE, 319 usb_int_complete, adapter, 320 endpoint->desc.bInterval); 321 322 return 0; 323} 324 325/* 326 * Release buffers and URBs for the interrupt and control 327 * endpoint. 328 */ 329void st5481_release_usb(struct st5481_adapter *adapter) 330{ 331 struct st5481_intr *intr = &adapter->intr; 332 struct st5481_ctrl *ctrl = &adapter->ctrl; 333 334 DBG(1,""); 335 336 // Stop and free Control and Interrupt URBs 337 usb_kill_urb(ctrl->urb); 338 kfree(ctrl->urb->transfer_buffer); 339 usb_free_urb(ctrl->urb); 340 ctrl->urb = NULL; 341 342 usb_kill_urb(intr->urb); 343 kfree(intr->urb->transfer_buffer); 344 usb_free_urb(intr->urb); 345 ctrl->urb = NULL; 346} 347 348/* 349 * Initialize the adapter. 350 */ 351void st5481_start(struct st5481_adapter *adapter) 352{ 353 static const u8 init_cmd_table[]={ 354 SET_DEFAULT,0, 355 STT,0, 356 SDA_MIN,0x0d, 357 SDA_MAX,0x29, 358 SDELAY_VALUE,0x14, 359 GPIO_DIR,0x01, 360 GPIO_OUT,RED_LED, 361// FFCTRL_OUT_D,4, 362// FFCTRH_OUT_D,12, 363 FFCTRL_OUT_B1,6, 364 FFCTRH_OUT_B1,20, 365 FFCTRL_OUT_B2,6, 366 FFCTRH_OUT_B2,20, 367 MPMSK,RXCI_INT+DEN_INT+DCOLL_INT, 368 0 369 }; 370 struct st5481_intr *intr = &adapter->intr; 371 int i = 0; 372 u8 request,value; 373 374 DBG(8,""); 375 376 adapter->leds = RED_LED; 377 378 // Start receiving on the interrupt endpoint 379 SUBMIT_URB(intr->urb, GFP_KERNEL); 380 381 while ((request = init_cmd_table[i++])) { 382 value = init_cmd_table[i++]; 383 st5481_usb_device_ctrl_msg(adapter, request, value, NULL, NULL); 384 } 385 st5481_ph_command(adapter, ST5481_CMD_PUP); 386} 387 388/* 389 * Reset the adapter to default values. 390 */ 391void st5481_stop(struct st5481_adapter *adapter) 392{ 393 DBG(8,""); 394 395 st5481_usb_device_ctrl_msg(adapter, SET_DEFAULT, 0, NULL, NULL); 396} 397 398/* ====================================================================== 399 * isochronous USB helpers 400 */ 401 402static void 403fill_isoc_urb(struct urb *urb, struct usb_device *dev, 404 unsigned int pipe, void *buf, int num_packets, 405 int packet_size, usb_complete_t complete, 406 void *context) 407{ 408 int k; 409 410 urb->dev=dev; 411 urb->pipe=pipe; 412 urb->interval = 1; 413 urb->transfer_buffer=buf; 414 urb->number_of_packets = num_packets; 415 urb->transfer_buffer_length=num_packets*packet_size; 416 urb->actual_length = 0; 417 urb->complete=complete; 418 urb->context=context; 419 urb->transfer_flags=URB_ISO_ASAP; 420 for (k = 0; k < num_packets; k++) { 421 urb->iso_frame_desc[k].offset = packet_size * k; 422 urb->iso_frame_desc[k].length = packet_size; 423 urb->iso_frame_desc[k].actual_length = 0; 424 } 425} 426 427int 428st5481_setup_isocpipes(struct urb* urb[2], struct usb_device *dev, 429 unsigned int pipe, int num_packets, 430 int packet_size, int buf_size, 431 usb_complete_t complete, void *context) 432{ 433 int j, retval; 434 unsigned char *buf; 435 436 for (j = 0; j < 2; j++) { 437 retval = -ENOMEM; 438 urb[j] = usb_alloc_urb(num_packets, GFP_KERNEL); 439 if (!urb[j]) 440 goto err; 441 442 // Allocate memory for 2000bytes/sec (16Kb/s) 443 buf = kmalloc(buf_size, GFP_KERNEL); 444 if (!buf) 445 goto err; 446 447 // Fill the isochronous URB 448 fill_isoc_urb(urb[j], dev, pipe, buf, 449 num_packets, packet_size, complete, 450 context); 451 } 452 return 0; 453 454 err: 455 for (j = 0; j < 2; j++) { 456 if (urb[j]) { 457 kfree(urb[j]->transfer_buffer); 458 urb[j]->transfer_buffer = NULL; 459 usb_free_urb(urb[j]); 460 urb[j] = NULL; 461 } 462 } 463 return retval; 464} 465 466void st5481_release_isocpipes(struct urb* urb[2]) 467{ 468 int j; 469 470 for (j = 0; j < 2; j++) { 471 usb_kill_urb(urb[j]); 472 kfree(urb[j]->transfer_buffer); 473 usb_free_urb(urb[j]); 474 urb[j] = NULL; 475 } 476} 477 478/* 479 * Decode frames received on the B/D channel. 480 * Note that this function will be called continously 481 * with 64Kbit/s / 16Kbit/s of data and hence it will be 482 * called 50 times per second with 20 ISOC descriptors. 483 * Called at interrupt. 484 */ 485static void usb_in_complete(struct urb *urb) 486{ 487 struct st5481_in *in = urb->context; 488 unsigned char *ptr; 489 struct sk_buff *skb; 490 int len, count, status; 491 492 if (unlikely(urb->status < 0)) { 493 switch (urb->status) { 494 case -ENOENT: 495 case -ESHUTDOWN: 496 case -ECONNRESET: 497 DBG(1,"urb killed status %d", urb->status); 498 return; // Give up 499 default: 500 WARN("urb status %d",urb->status); 501 break; 502 } 503 } 504 505 DBG_ISO_PACKET(0x80,urb); 506 507 len = st5481_isoc_flatten(urb); 508 ptr = urb->transfer_buffer; 509 while (len > 0) { 510 if (in->mode == L1_MODE_TRANS) { 511 memcpy(in->rcvbuf, ptr, len); 512 status = len; 513 len = 0; 514 } else { 515 status = isdnhdlc_decode(&in->hdlc_state, ptr, len, &count, 516 in->rcvbuf, in->bufsize); 517 ptr += count; 518 len -= count; 519 } 520 521 if (status > 0) { 522 // Good frame received 523 DBG(4,"count=%d",status); 524 DBG_PACKET(0x400, in->rcvbuf, status); 525 if (!(skb = dev_alloc_skb(status))) { 526 WARN("receive out of memory\n"); 527 break; 528 } 529 memcpy(skb_put(skb, status), in->rcvbuf, status); 530 in->hisax_if->l1l2(in->hisax_if, PH_DATA | INDICATION, skb); 531 } else if (status == -HDLC_CRC_ERROR) { 532 INFO("CRC error"); 533 } else if (status == -HDLC_FRAMING_ERROR) { 534 INFO("framing error"); 535 } else if (status == -HDLC_LENGTH_ERROR) { 536 INFO("length error"); 537 } 538 } 539 540 // Prepare URB for next transfer 541 urb->dev = in->adapter->usb_dev; 542 urb->actual_length = 0; 543 544 SUBMIT_URB(urb, GFP_ATOMIC); 545} 546 547int st5481_setup_in(struct st5481_in *in) 548{ 549 struct usb_device *dev = in->adapter->usb_dev; 550 int retval; 551 552 DBG(4,""); 553 554 in->rcvbuf = kmalloc(in->bufsize, GFP_KERNEL); 555 retval = -ENOMEM; 556 if (!in->rcvbuf) 557 goto err; 558 559 retval = st5481_setup_isocpipes(in->urb, dev, 560 usb_rcvisocpipe(dev, in->ep), 561 in->num_packets, in->packet_size, 562 in->num_packets * in->packet_size, 563 usb_in_complete, in); 564 if (retval) 565 goto err_free; 566 return 0; 567 568 err_free: 569 kfree(in->rcvbuf); 570 err: 571 return retval; 572} 573 574void st5481_release_in(struct st5481_in *in) 575{ 576 DBG(2,""); 577 578 st5481_release_isocpipes(in->urb); 579} 580 581/* 582 * Make the transfer_buffer contiguous by 583 * copying from the iso descriptors if necessary. 584 */ 585static int st5481_isoc_flatten(struct urb *urb) 586{ 587 struct usb_iso_packet_descriptor *pipd,*pend; 588 unsigned char *src,*dst; 589 unsigned int len; 590 591 if (urb->status < 0) { 592 return urb->status; 593 } 594 for (pipd = &urb->iso_frame_desc[0], 595 pend = &urb->iso_frame_desc[urb->number_of_packets], 596 dst = urb->transfer_buffer; 597 pipd < pend; 598 pipd++) { 599 600 if (pipd->status < 0) { 601 return (pipd->status); 602 } 603 604 len = pipd->actual_length; 605 pipd->actual_length = 0; 606 src = urb->transfer_buffer+pipd->offset; 607 608 if (src != dst) { 609 // Need to copy since isoc buffers not full 610 while (len--) { 611 *dst++ = *src++; 612 } 613 } else { 614 // No need to copy, just update destination buffer 615 dst += len; 616 } 617 } 618 // Return size of flattened buffer 619 return (dst - (unsigned char *)urb->transfer_buffer); 620} 621 622static void st5481_start_rcv(void *context) 623{ 624 struct st5481_in *in = context; 625 struct st5481_adapter *adapter = in->adapter; 626 627 DBG(4,""); 628 629 in->urb[0]->dev = adapter->usb_dev; 630 SUBMIT_URB(in->urb[0], GFP_KERNEL); 631 632 in->urb[1]->dev = adapter->usb_dev; 633 SUBMIT_URB(in->urb[1], GFP_KERNEL); 634} 635 636void st5481_in_mode(struct st5481_in *in, int mode) 637{ 638 if (in->mode == mode) 639 return; 640 641 in->mode = mode; 642 643 usb_unlink_urb(in->urb[0]); 644 usb_unlink_urb(in->urb[1]); 645 646 if (in->mode != L1_MODE_NULL) { 647 if (in->mode != L1_MODE_TRANS) 648 isdnhdlc_rcv_init(&in->hdlc_state, 649 in->mode == L1_MODE_HDLC_56K); 650 651 st5481_usb_pipe_reset(in->adapter, in->ep, NULL, NULL); 652 st5481_usb_device_ctrl_msg(in->adapter, in->counter, 653 in->packet_size, 654 NULL, NULL); 655 st5481_start_rcv(in); 656 } else { 657 st5481_usb_device_ctrl_msg(in->adapter, in->counter, 658 0, NULL, NULL); 659 } 660} 661