1 /* 2 * mos7720.c 3 * Controls the Moschip 7720 usb to dual port serial convertor 4 * 5 * Copyright 2006 Moschip Semiconductor Tech. Ltd. 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation, version 2 of the License. 10 * 11 * Developed by: 12 * Vijaya Kumar <vijaykumar.gn@gmail.com> 13 * Ajay Kumar <naanuajay@yahoo.com> 14 * Gurudeva <ngurudeva@yahoo.com> 15 * 16 * Cleaned up from the original by: 17 * Greg Kroah-Hartman <gregkh@suse.de> 18 * 19 * Originally based on drivers/usb/serial/io_edgeport.c which is: 20 * Copyright (C) 2000 Inside Out Networks, All rights reserved. 21 * Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com> 22 */ 23 #include <linux/kernel.h> 24 #include <linux/errno.h> 25 #include <linux/init.h> 26 #include <linux/slab.h> 27 #include <linux/tty.h> 28 #include <linux/tty_driver.h> 29 #include <linux/tty_flip.h> 30 #include <linux/module.h> 31 #include <linux/spinlock.h> 32 #include <linux/serial.h> 33 #include <linux/serial_reg.h> 34 #include <linux/usb.h> 35 #include <linux/usb/serial.h> 36 #include <linux/uaccess.h> 37 38 39 /* 40 * Version Information 41 */ 42 #define DRIVER_VERSION "1.0.0.4F" 43 #define DRIVER_AUTHOR "Aspire Communications pvt Ltd." 44 #define DRIVER_DESC "Moschip USB Serial Driver" 45 46 /* default urb timeout */ 47 #define MOS_WDR_TIMEOUT (HZ * 5) 48 49 #define MOS_PORT1 0x0200 50 #define MOS_PORT2 0x0300 51 #define MOS_VENREG 0x0000 52 #define MOS_MAX_PORT 0x02 53 #define MOS_WRITE 0x0E 54 #define MOS_READ 0x0D 55 56 /* Interrupt Rotinue Defines */ 57 #define SERIAL_IIR_RLS 0x06 58 #define SERIAL_IIR_RDA 0x04 59 #define SERIAL_IIR_CTI 0x0c 60 #define SERIAL_IIR_THR 0x02 61 #define SERIAL_IIR_MS 0x00 62 63 #define NUM_URBS 16 /* URB Count */ 64 #define URB_TRANSFER_BUFFER_SIZE 32 /* URB Size */ 65 66 /* This structure holds all of the local port information */ 67 struct moschip_port { 68 __u8 shadowLCR; /* last LCR value received */ 69 __u8 shadowMCR; /* last MCR value received */ 70 __u8 shadowMSR; /* last MSR value received */ 71 char open; 72 struct async_icount icount; 73 struct usb_serial_port *port; /* loop back to the owner */ 74 struct urb *write_urb_pool[NUM_URBS]; 75 }; 76 77 /* This structure holds all of the individual serial device information */ 78 struct moschip_serial { 79 int interrupt_started; 80 }; 81 82 static int debug; 83 84 #define USB_VENDOR_ID_MOSCHIP 0x9710 85 #define MOSCHIP_DEVICE_ID_7720 0x7720 86 #define MOSCHIP_DEVICE_ID_7715 0x7715 87 88 static struct usb_device_id moschip_port_id_table [] = { 89 { USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7720) }, 90 { } /* terminating entry */ 91 }; 92 MODULE_DEVICE_TABLE(usb, moschip_port_id_table); 93 94 95 /* 96 * mos7720_interrupt_callback 97 * this is the callback function for when we have received data on the 98 * interrupt endpoint. 99 */ 100 static void mos7720_interrupt_callback(struct urb *urb) 101 { 102 int result; 103 int length; 104 int status = urb->status; 105 __u8 *data; 106 __u8 sp1; 107 __u8 sp2; 108 109 dbg("%s", " : Entering\n"); 110 111 switch (status) { 112 case 0: 113 /* success */ 114 break; 115 case -ECONNRESET: 116 case -ENOENT: 117 case -ESHUTDOWN: 118 /* this urb is terminated, clean up */ 119 dbg("%s - urb shutting down with status: %d", __func__, 120 status); 121 return; 122 default: 123 dbg("%s - nonzero urb status received: %d", __func__, 124 status); 125 goto exit; 126 } 127 128 length = urb->actual_length; 129 data = urb->transfer_buffer; 130 131 /* Moschip get 4 bytes 132 * Byte 1 IIR Port 1 (port.number is 0) 133 * Byte 2 IIR Port 2 (port.number is 1) 134 * Byte 3 -------------- 135 * Byte 4 FIFO status for both */ 136 137 /* the above description is inverted 138 * oneukum 2007-03-14 */ 139 140 if (unlikely(length != 4)) { 141 dbg("Wrong data !!!"); 142 return; 143 } 144 145 sp1 = data[3]; 146 sp2 = data[2]; 147 148 if ((sp1 | sp2) & 0x01) { 149 /* No Interrupt Pending in both the ports */ 150 dbg("No Interrupt !!!"); 151 } else { 152 switch (sp1 & 0x0f) { 153 case SERIAL_IIR_RLS: 154 dbg("Serial Port 1: Receiver status error or address " 155 "bit detected in 9-bit mode\n"); 156 break; 157 case SERIAL_IIR_CTI: 158 dbg("Serial Port 1: Receiver time out"); 159 break; 160 case SERIAL_IIR_MS: 161 dbg("Serial Port 1: Modem status change"); 162 break; 163 } 164 165 switch (sp2 & 0x0f) { 166 case SERIAL_IIR_RLS: 167 dbg("Serial Port 2: Receiver status error or address " 168 "bit detected in 9-bit mode"); 169 break; 170 case SERIAL_IIR_CTI: 171 dbg("Serial Port 2: Receiver time out"); 172 break; 173 case SERIAL_IIR_MS: 174 dbg("Serial Port 2: Modem status change"); 175 break; 176 } 177 } 178 179 exit: 180 result = usb_submit_urb(urb, GFP_ATOMIC); 181 if (result) 182 dev_err(&urb->dev->dev, 183 "%s - Error %d submitting control urb\n", 184 __func__, result); 185 return; 186 } 187 188 /* 189 * mos7720_bulk_in_callback 190 * this is the callback function for when we have received data on the 191 * bulk in endpoint. 192 */ 193 static void mos7720_bulk_in_callback(struct urb *urb) 194 { 195 int retval; 196 unsigned char *data ; 197 struct usb_serial_port *port; 198 struct moschip_port *mos7720_port; 199 struct tty_struct *tty; 200 int status = urb->status; 201 202 if (status) { 203 dbg("nonzero read bulk status received: %d", status); 204 return; 205 } 206 207 mos7720_port = urb->context; 208 if (!mos7720_port) { 209 dbg("%s", "NULL mos7720_port pointer \n"); 210 return ; 211 } 212 213 port = mos7720_port->port; 214 215 dbg("Entering...%s", __func__); 216 217 data = urb->transfer_buffer; 218 219 tty = port->port.tty; 220 if (tty && urb->actual_length) { 221 tty_buffer_request_room(tty, urb->actual_length); 222 tty_insert_flip_string(tty, data, urb->actual_length); 223 tty_flip_buffer_push(tty); 224 } 225 226 if (!port->read_urb) { 227 dbg("URB KILLED !!!"); 228 return; 229 } 230 231 if (port->read_urb->status != -EINPROGRESS) { 232 port->read_urb->dev = port->serial->dev; 233 234 retval = usb_submit_urb(port->read_urb, GFP_ATOMIC); 235 if (retval) 236 dbg("usb_submit_urb(read bulk) failed, retval = %d", 237 retval); 238 } 239 } 240 241 /* 242 * mos7720_bulk_out_data_callback 243 * this is the callback function for when we have finished sending serial 244 * data on the bulk out endpoint. 245 */ 246 static void mos7720_bulk_out_data_callback(struct urb *urb) 247 { 248 struct moschip_port *mos7720_port; 249 struct tty_struct *tty; 250 int status = urb->status; 251 252 if (status) { 253 dbg("nonzero write bulk status received:%d", status); 254 return; 255 } 256 257 mos7720_port = urb->context; 258 if (!mos7720_port) { 259 dbg("NULL mos7720_port pointer"); 260 return ; 261 } 262 263 dbg("Entering ........."); 264 265 tty = mos7720_port->port->port.tty; 266 267 if (tty && mos7720_port->open) 268 tty_wakeup(tty); 269 } 270 271 /* 272 * send_mos_cmd 273 * this function will be used for sending command to device 274 */ 275 static int send_mos_cmd(struct usb_serial *serial, __u8 request, __u16 value, 276 __u16 index, void *data) 277 { 278 int status; 279 unsigned int pipe; 280 u16 product = le16_to_cpu(serial->dev->descriptor.idProduct); 281 __u8 requesttype; 282 __u16 size = 0x0000; 283 284 if (value < MOS_MAX_PORT) { 285 if (product == MOSCHIP_DEVICE_ID_7715) 286 value = value*0x100+0x100; 287 else 288 value = value*0x100+0x200; 289 } else { 290 value = 0x0000; 291 if ((product == MOSCHIP_DEVICE_ID_7715) && 292 (index != 0x08)) { 293 dbg("serial->product== MOSCHIP_DEVICE_ID_7715"); 294 /* index = 0x01 ; */ 295 } 296 } 297 298 if (request == MOS_WRITE) { 299 request = (__u8)MOS_WRITE; 300 requesttype = (__u8)0x40; 301 value = value + (__u16)*((unsigned char *)data); 302 data = NULL; 303 pipe = usb_sndctrlpipe(serial->dev, 0); 304 } else { 305 request = (__u8)MOS_READ; 306 requesttype = (__u8)0xC0; 307 size = 0x01; 308 pipe = usb_rcvctrlpipe(serial->dev, 0); 309 } 310 311 status = usb_control_msg(serial->dev, pipe, request, requesttype, 312 value, index, data, size, MOS_WDR_TIMEOUT); 313 314 if (status < 0) 315 dbg("Command Write failed Value %x index %x\n", value, index); 316 317 return status; 318 } 319 320 static int mos7720_open(struct tty_struct *tty, 321 struct usb_serial_port *port, struct file *filp) 322 { 323 struct usb_serial *serial; 324 struct usb_serial_port *port0; 325 struct urb *urb; 326 struct moschip_serial *mos7720_serial; 327 struct moschip_port *mos7720_port; 328 int response; 329 int port_number; 330 char data; 331 int allocated_urbs = 0; 332 int j; 333 334 serial = port->serial; 335 336 mos7720_port = usb_get_serial_port_data(port); 337 if (mos7720_port == NULL) 338 return -ENODEV; 339 340 port0 = serial->port[0]; 341 342 mos7720_serial = usb_get_serial_data(serial); 343 344 if (mos7720_serial == NULL || port0 == NULL) 345 return -ENODEV; 346 347 usb_clear_halt(serial->dev, port->write_urb->pipe); 348 usb_clear_halt(serial->dev, port->read_urb->pipe); 349 350 /* Initialising the write urb pool */ 351 for (j = 0; j < NUM_URBS; ++j) { 352 urb = usb_alloc_urb(0, GFP_KERNEL); 353 mos7720_port->write_urb_pool[j] = urb; 354 355 if (urb == NULL) { 356 err("No more urbs???"); 357 continue; 358 } 359 360 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE, 361 GFP_KERNEL); 362 if (!urb->transfer_buffer) { 363 err("%s-out of memory for urb buffers.", __func__); 364 usb_free_urb(mos7720_port->write_urb_pool[j]); 365 mos7720_port->write_urb_pool[j] = NULL; 366 continue; 367 } 368 allocated_urbs++; 369 } 370 371 if (!allocated_urbs) 372 return -ENOMEM; 373 374 /* Initialize MCS7720 -- Write Init values to corresponding Registers 375 * 376 * Register Index 377 * 1 : IER 378 * 2 : FCR 379 * 3 : LCR 380 * 4 : MCR 381 * 382 * 0x08 : SP1/2 Control Reg 383 */ 384 port_number = port->number - port->serial->minor; 385 send_mos_cmd(port->serial, MOS_READ, port_number, UART_LSR, &data); 386 dbg("SS::%p LSR:%x\n", mos7720_port, data); 387 388 dbg("Check:Sending Command .........."); 389 390 data = 0x02; 391 send_mos_cmd(serial, MOS_WRITE, MOS_MAX_PORT, 0x01, &data); 392 data = 0x02; 393 send_mos_cmd(serial, MOS_WRITE, MOS_MAX_PORT, 0x02, &data); 394 395 data = 0x00; 396 send_mos_cmd(serial, MOS_WRITE, port_number, 0x01, &data); 397 data = 0x00; 398 send_mos_cmd(serial, MOS_WRITE, port_number, 0x02, &data); 399 400 data = 0xCF; 401 send_mos_cmd(serial, MOS_WRITE, port_number, 0x02, &data); 402 data = 0x03; 403 mos7720_port->shadowLCR = data; 404 send_mos_cmd(serial, MOS_WRITE, port_number, 0x03, &data); 405 data = 0x0b; 406 mos7720_port->shadowMCR = data; 407 send_mos_cmd(serial, MOS_WRITE, port_number, 0x04, &data); 408 data = 0x0b; 409 send_mos_cmd(serial, MOS_WRITE, port_number, 0x04, &data); 410 411 data = 0x00; 412 send_mos_cmd(serial, MOS_READ, MOS_MAX_PORT, 0x08, &data); 413 data = 0x00; 414 send_mos_cmd(serial, MOS_WRITE, MOS_MAX_PORT, 0x08, &data); 415 416 /* data = 0x00; 417 send_mos_cmd(serial, MOS_READ, MOS_MAX_PORT, port_number + 1, &data); 418 data = 0x03; 419 send_mos_cmd(serial, MOS_WRITE, MOS_MAX_PORT, port_number + 1, &data); 420 data = 0x00; 421 send_mos_cmd(port->serial, MOS_WRITE, MOS_MAX_PORT, 422 port_number + 1, &data); 423 */ 424 data = 0x00; 425 send_mos_cmd(serial, MOS_READ, MOS_MAX_PORT, 0x08, &data); 426 427 data = data | (port->number - port->serial->minor + 1); 428 send_mos_cmd(serial, MOS_WRITE, MOS_MAX_PORT, 0x08, &data); 429 430 data = 0x83; 431 mos7720_port->shadowLCR = data; 432 send_mos_cmd(serial, MOS_WRITE, port_number, 0x03, &data); 433 data = 0x0c; 434 send_mos_cmd(serial, MOS_WRITE, port_number, 0x00, &data); 435 data = 0x00; 436 send_mos_cmd(serial, MOS_WRITE, port_number, 0x01, &data); 437 data = 0x03; 438 mos7720_port->shadowLCR = data; 439 send_mos_cmd(serial, MOS_WRITE, port_number, 0x03, &data); 440 data = 0x0c; 441 send_mos_cmd(serial, MOS_WRITE, port_number, 0x01, &data); 442 data = 0x0c; 443 send_mos_cmd(serial, MOS_WRITE, port_number, 0x01, &data); 444 445 /* force low_latency on so that our tty_push actually forces * 446 * the data through,otherwise it is scheduled, and with * 447 * high data rates (like with OHCI) data can get lost. */ 448 449 if (tty) 450 tty->low_latency = 1; 451 452 /* see if we've set up our endpoint info yet * 453 * (can't set it up in mos7720_startup as the * 454 * structures were not set up at that time.) */ 455 if (!mos7720_serial->interrupt_started) { 456 dbg("Interrupt buffer NULL !!!"); 457 458 /* not set up yet, so do it now */ 459 mos7720_serial->interrupt_started = 1; 460 461 dbg("To Submit URB !!!"); 462 463 /* set up our interrupt urb */ 464 usb_fill_int_urb(port0->interrupt_in_urb, serial->dev, 465 usb_rcvintpipe(serial->dev, 466 port->interrupt_in_endpointAddress), 467 port0->interrupt_in_buffer, 468 port0->interrupt_in_urb->transfer_buffer_length, 469 mos7720_interrupt_callback, mos7720_port, 470 port0->interrupt_in_urb->interval); 471 472 /* start interrupt read for this mos7720 this interrupt * 473 * will continue as long as the mos7720 is connected */ 474 dbg("Submit URB over !!!"); 475 response = usb_submit_urb(port0->interrupt_in_urb, GFP_KERNEL); 476 if (response) 477 dev_err(&port->dev, 478 "%s - Error %d submitting control urb\n", 479 __func__, response); 480 } 481 482 /* set up our bulk in urb */ 483 usb_fill_bulk_urb(port->read_urb, serial->dev, 484 usb_rcvbulkpipe(serial->dev, 485 port->bulk_in_endpointAddress), 486 port->bulk_in_buffer, 487 port->read_urb->transfer_buffer_length, 488 mos7720_bulk_in_callback, mos7720_port); 489 response = usb_submit_urb(port->read_urb, GFP_KERNEL); 490 if (response) 491 dev_err(&port->dev, "%s - Error %d submitting read urb\n", 492 __func__, response); 493 494 /* initialize our icount structure */ 495 memset(&(mos7720_port->icount), 0x00, sizeof(mos7720_port->icount)); 496 497 /* initialize our port settings */ 498 mos7720_port->shadowMCR = UART_MCR_OUT2; /* Must set to enable ints! */ 499 500 /* send a open port command */ 501 mos7720_port->open = 1; 502 503 return 0; 504 } 505 506 /* 507 * mos7720_chars_in_buffer 508 * this function is called by the tty driver when it wants to know how many 509 * bytes of data we currently have outstanding in the port (data that has 510 * been written, but hasn't made it out the port yet) 511 * If successful, we return the number of bytes left to be written in the 512 * system, 513 * Otherwise we return a negative error number. 514 */ 515 static int mos7720_chars_in_buffer(struct tty_struct *tty) 516 { 517 struct usb_serial_port *port = tty->driver_data; 518 int i; 519 int chars = 0; 520 struct moschip_port *mos7720_port; 521 522 dbg("%s:entering ...........", __func__); 523 524 mos7720_port = usb_get_serial_port_data(port); 525 if (mos7720_port == NULL) { 526 dbg("%s:leaving ...........", __func__); 527 return -ENODEV; 528 } 529 530 for (i = 0; i < NUM_URBS; ++i) { 531 if (mos7720_port->write_urb_pool[i] && 532 mos7720_port->write_urb_pool[i]->status == -EINPROGRESS) 533 chars += URB_TRANSFER_BUFFER_SIZE; 534 } 535 dbg("%s - returns %d", __func__, chars); 536 return chars; 537 } 538 539 static void mos7720_close(struct tty_struct *tty, 540 struct usb_serial_port *port, struct file *filp) 541 { 542 struct usb_serial *serial; 543 struct moschip_port *mos7720_port; 544 char data; 545 int j; 546 547 dbg("mos7720_close:entering..."); 548 549 serial = port->serial; 550 551 mos7720_port = usb_get_serial_port_data(port); 552 if (mos7720_port == NULL) 553 return; 554 555 for (j = 0; j < NUM_URBS; ++j) 556 usb_kill_urb(mos7720_port->write_urb_pool[j]); 557 558 /* Freeing Write URBs */ 559 for (j = 0; j < NUM_URBS; ++j) { 560 if (mos7720_port->write_urb_pool[j]) { 561 kfree(mos7720_port->write_urb_pool[j]->transfer_buffer); 562 usb_free_urb(mos7720_port->write_urb_pool[j]); 563 } 564 } 565 566 /* While closing port, shutdown all bulk read, write * 567 * and interrupt read if they exists, otherwise nop */ 568 dbg("Shutdown bulk write"); 569 usb_kill_urb(port->write_urb); 570 dbg("Shutdown bulk read"); 571 usb_kill_urb(port->read_urb); 572 573 mutex_lock(&serial->disc_mutex); 574 /* these commands must not be issued if the device has 575 * been disconnected */ 576 if (!serial->disconnected) { 577 data = 0x00; 578 send_mos_cmd(serial, MOS_WRITE, 579 port->number - port->serial->minor, 0x04, &data); 580 581 data = 0x00; 582 send_mos_cmd(serial, MOS_WRITE, 583 port->number - port->serial->minor, 0x01, &data); 584 } 585 mutex_unlock(&serial->disc_mutex); 586 mos7720_port->open = 0; 587 588 dbg("Leaving %s", __func__); 589 } 590 591 static void mos7720_break(struct tty_struct *tty, int break_state) 592 { 593 struct usb_serial_port *port = tty->driver_data; 594 unsigned char data; 595 struct usb_serial *serial; 596 struct moschip_port *mos7720_port; 597 598 dbg("Entering %s", __func__); 599 600 serial = port->serial; 601 602 mos7720_port = usb_get_serial_port_data(port); 603 if (mos7720_port == NULL) 604 return; 605 606 if (break_state == -1) 607 data = mos7720_port->shadowLCR | UART_LCR_SBC; 608 else 609 data = mos7720_port->shadowLCR & ~UART_LCR_SBC; 610 611 mos7720_port->shadowLCR = data; 612 send_mos_cmd(serial, MOS_WRITE, port->number - port->serial->minor, 613 0x03, &data); 614 615 return; 616 } 617 618 /* 619 * mos7720_write_room 620 * this function is called by the tty driver when it wants to know how many 621 * bytes of data we can accept for a specific port. 622 * If successful, we return the amount of room that we have for this port 623 * Otherwise we return a negative error number. 624 */ 625 static int mos7720_write_room(struct tty_struct *tty) 626 { 627 struct usb_serial_port *port = tty->driver_data; 628 struct moschip_port *mos7720_port; 629 int room = 0; 630 int i; 631 632 dbg("%s:entering ...........", __func__); 633 634 mos7720_port = usb_get_serial_port_data(port); 635 if (mos7720_port == NULL) { 636 dbg("%s:leaving ...........", __func__); 637 return -ENODEV; 638 } 639 640 /* FIXME: Locking */ 641 for (i = 0; i < NUM_URBS; ++i) { 642 if (mos7720_port->write_urb_pool[i] && 643 mos7720_port->write_urb_pool[i]->status != -EINPROGRESS) 644 room += URB_TRANSFER_BUFFER_SIZE; 645 } 646 647 dbg("%s - returns %d", __func__, room); 648 return room; 649 } 650 651 static int mos7720_write(struct tty_struct *tty, struct usb_serial_port *port, 652 const unsigned char *data, int count) 653 { 654 int status; 655 int i; 656 int bytes_sent = 0; 657 int transfer_size; 658 659 struct moschip_port *mos7720_port; 660 struct usb_serial *serial; 661 struct urb *urb; 662 const unsigned char *current_position = data; 663 664 dbg("%s:entering ...........", __func__); 665 666 serial = port->serial; 667 668 mos7720_port = usb_get_serial_port_data(port); 669 if (mos7720_port == NULL) { 670 dbg("mos7720_port is NULL"); 671 return -ENODEV; 672 } 673 674 /* try to find a free urb in the list */ 675 urb = NULL; 676 677 for (i = 0; i < NUM_URBS; ++i) { 678 if (mos7720_port->write_urb_pool[i] && 679 mos7720_port->write_urb_pool[i]->status != -EINPROGRESS) { 680 urb = mos7720_port->write_urb_pool[i]; 681 dbg("URB:%d", i); 682 break; 683 } 684 } 685 686 if (urb == NULL) { 687 dbg("%s - no more free urbs", __func__); 688 goto exit; 689 } 690 691 if (urb->transfer_buffer == NULL) { 692 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE, 693 GFP_KERNEL); 694 if (urb->transfer_buffer == NULL) { 695 err("%s no more kernel memory...", __func__); 696 goto exit; 697 } 698 } 699 transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE); 700 701 memcpy(urb->transfer_buffer, current_position, transfer_size); 702 usb_serial_debug_data(debug, &port->dev, __func__, transfer_size, 703 urb->transfer_buffer); 704 705 /* fill urb with data and submit */ 706 usb_fill_bulk_urb(urb, serial->dev, 707 usb_sndbulkpipe(serial->dev, 708 port->bulk_out_endpointAddress), 709 urb->transfer_buffer, transfer_size, 710 mos7720_bulk_out_data_callback, mos7720_port); 711 712 /* send it down the pipe */ 713 status = usb_submit_urb(urb, GFP_ATOMIC); 714 if (status) { 715 err("%s - usb_submit_urb(write bulk) failed with status = %d", 716 __func__, status); 717 bytes_sent = status; 718 goto exit; 719 } 720 bytes_sent = transfer_size; 721 722 exit: 723 return bytes_sent; 724 } 725 726 static void mos7720_throttle(struct tty_struct *tty) 727 { 728 struct usb_serial_port *port = tty->driver_data; 729 struct moschip_port *mos7720_port; 730 int status; 731 732 dbg("%s- port %d\n", __func__, port->number); 733 734 mos7720_port = usb_get_serial_port_data(port); 735 736 if (mos7720_port == NULL) 737 return; 738 739 if (!mos7720_port->open) { 740 dbg("port not opened"); 741 return; 742 } 743 744 dbg("%s: Entering ..........", __func__); 745 746 /* if we are implementing XON/XOFF, send the stop character */ 747 if (I_IXOFF(tty)) { 748 unsigned char stop_char = STOP_CHAR(tty); 749 status = mos7720_write(tty, port, &stop_char, 1); 750 if (status <= 0) 751 return; 752 } 753 754 /* if we are implementing RTS/CTS, toggle that line */ 755 if (tty->termios->c_cflag & CRTSCTS) { 756 mos7720_port->shadowMCR &= ~UART_MCR_RTS; 757 status = send_mos_cmd(port->serial, MOS_WRITE, 758 port->number - port->serial->minor, 759 UART_MCR, &mos7720_port->shadowMCR); 760 if (status != 0) 761 return; 762 } 763 } 764 765 static void mos7720_unthrottle(struct tty_struct *tty) 766 { 767 struct usb_serial_port *port = tty->driver_data; 768 struct moschip_port *mos7720_port = usb_get_serial_port_data(port); 769 int status; 770 771 if (mos7720_port == NULL) 772 return; 773 774 if (!mos7720_port->open) { 775 dbg("%s - port not opened", __func__); 776 return; 777 } 778 779 dbg("%s: Entering ..........", __func__); 780 781 /* if we are implementing XON/XOFF, send the start character */ 782 if (I_IXOFF(tty)) { 783 unsigned char start_char = START_CHAR(tty); 784 status = mos7720_write(tty, port, &start_char, 1); 785 if (status <= 0) 786 return; 787 } 788 789 /* if we are implementing RTS/CTS, toggle that line */ 790 if (tty->termios->c_cflag & CRTSCTS) { 791 mos7720_port->shadowMCR |= UART_MCR_RTS; 792 status = send_mos_cmd(port->serial, MOS_WRITE, 793 port->number - port->serial->minor, 794 UART_MCR, &mos7720_port->shadowMCR); 795 if (status != 0) 796 return; 797 } 798 } 799 800 static int set_higher_rates(struct moschip_port *mos7720_port, 801 unsigned int baud) 802 { 803 unsigned char data; 804 struct usb_serial_port *port; 805 struct usb_serial *serial; 806 int port_number; 807 808 if (mos7720_port == NULL) 809 return -EINVAL; 810 811 port = mos7720_port->port; 812 serial = port->serial; 813 814 /*********************************************** 815 * Init Sequence for higher rates 816 ***********************************************/ 817 dbg("Sending Setting Commands .........."); 818 port_number = port->number - port->serial->minor; 819 820 data = 0x000; 821 send_mos_cmd(serial, MOS_WRITE, port_number, 0x01, &data); 822 data = 0x000; 823 send_mos_cmd(serial, MOS_WRITE, port_number, 0x02, &data); 824 data = 0x0CF; 825 send_mos_cmd(serial, MOS_WRITE, port->number, 0x02, &data); 826 data = 0x00b; 827 mos7720_port->shadowMCR = data; 828 send_mos_cmd(serial, MOS_WRITE, port_number, 0x04, &data); 829 data = 0x00b; 830 send_mos_cmd(serial, MOS_WRITE, port_number, 0x04, &data); 831 832 data = 0x000; 833 send_mos_cmd(serial, MOS_READ, MOS_MAX_PORT, 0x08, &data); 834 data = 0x000; 835 send_mos_cmd(serial, MOS_WRITE, MOS_MAX_PORT, 0x08, &data); 836 837 838 /*********************************************** 839 * Set for higher rates * 840 ***********************************************/ 841 842 data = baud * 0x10; 843 send_mos_cmd(serial, MOS_WRITE, MOS_MAX_PORT, port_number + 1, &data); 844 845 data = 0x003; 846 send_mos_cmd(serial, MOS_READ, MOS_MAX_PORT, 0x08, &data); 847 data = 0x003; 848 send_mos_cmd(serial, MOS_WRITE, MOS_MAX_PORT, 0x08, &data); 849 850 data = 0x02b; 851 mos7720_port->shadowMCR = data; 852 send_mos_cmd(serial, MOS_WRITE, port_number, 0x04, &data); 853 data = 0x02b; 854 send_mos_cmd(serial, MOS_WRITE, port_number, 0x04, &data); 855 856 /*********************************************** 857 * Set DLL/DLM 858 ***********************************************/ 859 860 data = mos7720_port->shadowLCR | UART_LCR_DLAB; 861 mos7720_port->shadowLCR = data; 862 send_mos_cmd(serial, MOS_WRITE, port_number, 0x03, &data); 863 864 data = 0x001; /* DLL */ 865 send_mos_cmd(serial, MOS_WRITE, port_number, 0x00, &data); 866 data = 0x000; /* DLM */ 867 send_mos_cmd(serial, MOS_WRITE, port_number, 0x01, &data); 868 869 data = mos7720_port->shadowLCR & ~UART_LCR_DLAB; 870 mos7720_port->shadowLCR = data; 871 send_mos_cmd(serial, MOS_WRITE, port_number, 0x03, &data); 872 873 return 0; 874 } 875 876 /* baud rate information */ 877 struct divisor_table_entry { 878 __u32 baudrate; 879 __u16 divisor; 880 }; 881 882 /* Define table of divisors for moschip 7720 hardware * 883 * These assume a 3.6864MHz crystal, the standard /16, and * 884 * MCR.7 = 0. */ 885 static struct divisor_table_entry divisor_table[] = { 886 { 50, 2304}, 887 { 110, 1047}, /* 2094.545455 => 230450 => .0217 % over */ 888 { 134, 857}, /* 1713.011152 => 230398.5 => .00065% under */ 889 { 150, 768}, 890 { 300, 384}, 891 { 600, 192}, 892 { 1200, 96}, 893 { 1800, 64}, 894 { 2400, 48}, 895 { 4800, 24}, 896 { 7200, 16}, 897 { 9600, 12}, 898 { 19200, 6}, 899 { 38400, 3}, 900 { 57600, 2}, 901 { 115200, 1}, 902 }; 903 904 /***************************************************************************** 905 * calc_baud_rate_divisor 906 * this function calculates the proper baud rate divisor for the specified 907 * baud rate. 908 *****************************************************************************/ 909 static int calc_baud_rate_divisor(int baudrate, int *divisor) 910 { 911 int i; 912 __u16 custom; 913 __u16 round1; 914 __u16 round; 915 916 917 dbg("%s - %d", __func__, baudrate); 918 919 for (i = 0; i < ARRAY_SIZE(divisor_table); i++) { 920 if (divisor_table[i].baudrate == baudrate) { 921 *divisor = divisor_table[i].divisor; 922 return 0; 923 } 924 } 925 926 /* After trying for all the standard baud rates * 927 * Try calculating the divisor for this baud rate */ 928 if (baudrate > 75 && baudrate < 230400) { 929 /* get the divisor */ 930 custom = (__u16)(230400L / baudrate); 931 932 /* Check for round off */ 933 round1 = (__u16)(2304000L / baudrate); 934 round = (__u16)(round1 - (custom * 10)); 935 if (round > 4) 936 custom++; 937 *divisor = custom; 938 939 dbg("Baud %d = %d", baudrate, custom); 940 return 0; 941 } 942 943 dbg("Baud calculation Failed..."); 944 return -EINVAL; 945 } 946 947 /* 948 * send_cmd_write_baud_rate 949 * this function sends the proper command to change the baud rate of the 950 * specified port. 951 */ 952 static int send_cmd_write_baud_rate(struct moschip_port *mos7720_port, 953 int baudrate) 954 { 955 struct usb_serial_port *port; 956 struct usb_serial *serial; 957 int divisor; 958 int status; 959 unsigned char data; 960 unsigned char number; 961 962 if (mos7720_port == NULL) 963 return -1; 964 965 port = mos7720_port->port; 966 serial = port->serial; 967 968 dbg("%s: Entering ..........", __func__); 969 970 number = port->number - port->serial->minor; 971 dbg("%s - port = %d, baud = %d", __func__, port->number, baudrate); 972 973 /* Calculate the Divisor */ 974 status = calc_baud_rate_divisor(baudrate, &divisor); 975 if (status) { 976 err("%s - bad baud rate", __func__); 977 return status; 978 } 979 980 /* Enable access to divisor latch */ 981 data = mos7720_port->shadowLCR | UART_LCR_DLAB; 982 mos7720_port->shadowLCR = data; 983 send_mos_cmd(serial, MOS_WRITE, number, UART_LCR, &data); 984 985 /* Write the divisor */ 986 data = ((unsigned char)(divisor & 0xff)); 987 send_mos_cmd(serial, MOS_WRITE, number, 0x00, &data); 988 989 data = ((unsigned char)((divisor & 0xff00) >> 8)); 990 send_mos_cmd(serial, MOS_WRITE, number, 0x01, &data); 991 992 /* Disable access to divisor latch */ 993 data = mos7720_port->shadowLCR & ~UART_LCR_DLAB; 994 mos7720_port->shadowLCR = data; 995 send_mos_cmd(serial, MOS_WRITE, number, 0x03, &data); 996 997 return status; 998 } 999 1000 /* 1001 * change_port_settings 1002 * This routine is called to set the UART on the device to match 1003 * the specified new settings. 1004 */ 1005 static void change_port_settings(struct tty_struct *tty, 1006 struct moschip_port *mos7720_port, 1007 struct ktermios *old_termios) 1008 { 1009 struct usb_serial_port *port; 1010 struct usb_serial *serial; 1011 int baud; 1012 unsigned cflag; 1013 unsigned iflag; 1014 __u8 mask = 0xff; 1015 __u8 lData; 1016 __u8 lParity; 1017 __u8 lStop; 1018 int status; 1019 int port_number; 1020 char data; 1021 1022 if (mos7720_port == NULL) 1023 return ; 1024 1025 port = mos7720_port->port; 1026 serial = port->serial; 1027 port_number = port->number - port->serial->minor; 1028 1029 dbg("%s - port %d", __func__, port->number); 1030 1031 if (!mos7720_port->open) { 1032 dbg("%s - port not opened", __func__); 1033 return; 1034 } 1035 1036 dbg("%s: Entering ..........", __func__); 1037 1038 lData = UART_LCR_WLEN8; 1039 lStop = 0x00; /* 1 stop bit */ 1040 lParity = 0x00; /* No parity */ 1041 1042 cflag = tty->termios->c_cflag; 1043 iflag = tty->termios->c_iflag; 1044 1045 /* Change the number of bits */ 1046 switch (cflag & CSIZE) { 1047 case CS5: 1048 lData = UART_LCR_WLEN5; 1049 mask = 0x1f; 1050 break; 1051 1052 case CS6: 1053 lData = UART_LCR_WLEN6; 1054 mask = 0x3f; 1055 break; 1056 1057 case CS7: 1058 lData = UART_LCR_WLEN7; 1059 mask = 0x7f; 1060 break; 1061 default: 1062 case CS8: 1063 lData = UART_LCR_WLEN8; 1064 break; 1065 } 1066 1067 /* Change the Parity bit */ 1068 if (cflag & PARENB) { 1069 if (cflag & PARODD) { 1070 lParity = UART_LCR_PARITY; 1071 dbg("%s - parity = odd", __func__); 1072 } else { 1073 lParity = (UART_LCR_EPAR | UART_LCR_PARITY); 1074 dbg("%s - parity = even", __func__); 1075 } 1076 1077 } else { 1078 dbg("%s - parity = none", __func__); 1079 } 1080 1081 if (cflag & CMSPAR) 1082 lParity = lParity | 0x20; 1083 1084 /* Change the Stop bit */ 1085 if (cflag & CSTOPB) { 1086 lStop = UART_LCR_STOP; 1087 dbg("%s - stop bits = 2", __func__); 1088 } else { 1089 lStop = 0x00; 1090 dbg("%s - stop bits = 1", __func__); 1091 } 1092 1093 #define LCR_BITS_MASK 0x03 /* Mask for bits/char field */ 1094 #define LCR_STOP_MASK 0x04 /* Mask for stop bits field */ 1095 #define LCR_PAR_MASK 0x38 /* Mask for parity field */ 1096 1097 /* Update the LCR with the correct value */ 1098 mos7720_port->shadowLCR &= 1099 ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK); 1100 mos7720_port->shadowLCR |= (lData | lParity | lStop); 1101 1102 1103 /* Disable Interrupts */ 1104 data = 0x00; 1105 send_mos_cmd(serial, MOS_WRITE, port->number - port->serial->minor, 1106 UART_IER, &data); 1107 1108 data = 0x00; 1109 send_mos_cmd(serial, MOS_WRITE, port_number, UART_FCR, &data); 1110 1111 data = 0xcf; 1112 send_mos_cmd(serial, MOS_WRITE, port_number, UART_FCR, &data); 1113 1114 /* Send the updated LCR value to the mos7720 */ 1115 data = mos7720_port->shadowLCR; 1116 send_mos_cmd(serial, MOS_WRITE, port_number, UART_LCR, &data); 1117 1118 data = 0x00b; 1119 mos7720_port->shadowMCR = data; 1120 send_mos_cmd(serial, MOS_WRITE, port_number, 0x04, &data); 1121 data = 0x00b; 1122 send_mos_cmd(serial, MOS_WRITE, port_number, 0x04, &data); 1123 1124 /* set up the MCR register and send it to the mos7720 */ 1125 mos7720_port->shadowMCR = UART_MCR_OUT2; 1126 if (cflag & CBAUD) 1127 mos7720_port->shadowMCR |= (UART_MCR_DTR | UART_MCR_RTS); 1128 1129 if (cflag & CRTSCTS) { 1130 mos7720_port->shadowMCR |= (UART_MCR_XONANY); 1131 /* To set hardware flow control to the specified * 1132 * serial port, in SP1/2_CONTROL_REG */ 1133 if (port->number) { 1134 data = 0x001; 1135 send_mos_cmd(serial, MOS_WRITE, MOS_MAX_PORT, 1136 0x08, &data); 1137 } else { 1138 data = 0x002; 1139 send_mos_cmd(serial, MOS_WRITE, MOS_MAX_PORT, 1140 0x08, &data); 1141 } 1142 } else { 1143 mos7720_port->shadowMCR &= ~(UART_MCR_XONANY); 1144 } 1145 1146 data = mos7720_port->shadowMCR; 1147 send_mos_cmd(serial, MOS_WRITE, port_number, UART_MCR, &data); 1148 1149 /* Determine divisor based on baud rate */ 1150 baud = tty_get_baud_rate(tty); 1151 if (!baud) { 1152 /* pick a default, any default... */ 1153 dbg("Picked default baud..."); 1154 baud = 9600; 1155 } 1156 1157 if (baud >= 230400) { 1158 set_higher_rates(mos7720_port, baud); 1159 /* Enable Interrupts */ 1160 data = 0x0c; 1161 send_mos_cmd(serial, MOS_WRITE, port_number, UART_IER, &data); 1162 return; 1163 } 1164 1165 dbg("%s - baud rate = %d", __func__, baud); 1166 status = send_cmd_write_baud_rate(mos7720_port, baud); 1167 /* FIXME: needs to write actual resulting baud back not just 1168 blindly do so */ 1169 if (cflag & CBAUD) 1170 tty_encode_baud_rate(tty, baud, baud); 1171 /* Enable Interrupts */ 1172 data = 0x0c; 1173 send_mos_cmd(serial, MOS_WRITE, port_number, UART_IER, &data); 1174 1175 if (port->read_urb->status != -EINPROGRESS) { 1176 port->read_urb->dev = serial->dev; 1177 1178 status = usb_submit_urb(port->read_urb, GFP_ATOMIC); 1179 if (status) 1180 dbg("usb_submit_urb(read bulk) failed, status = %d", 1181 status); 1182 } 1183 return; 1184 } 1185 1186 /* 1187 * mos7720_set_termios 1188 * this function is called by the tty driver when it wants to change the 1189 * termios structure. 1190 */ 1191 static void mos7720_set_termios(struct tty_struct *tty, 1192 struct usb_serial_port *port, struct ktermios *old_termios) 1193 { 1194 int status; 1195 unsigned int cflag; 1196 struct usb_serial *serial; 1197 struct moschip_port *mos7720_port; 1198 1199 serial = port->serial; 1200 1201 mos7720_port = usb_get_serial_port_data(port); 1202 1203 if (mos7720_port == NULL) 1204 return; 1205 1206 if (!mos7720_port->open) { 1207 dbg("%s - port not opened", __func__); 1208 return; 1209 } 1210 1211 dbg("%s\n", "setting termios - ASPIRE"); 1212 1213 cflag = tty->termios->c_cflag; 1214 1215 dbg("%s - cflag %08x iflag %08x", __func__, 1216 tty->termios->c_cflag, 1217 RELEVANT_IFLAG(tty->termios->c_iflag)); 1218 1219 dbg("%s - old cflag %08x old iflag %08x", __func__, 1220 old_termios->c_cflag, 1221 RELEVANT_IFLAG(old_termios->c_iflag)); 1222 1223 dbg("%s - port %d", __func__, port->number); 1224 1225 /* change the port settings to the new ones specified */ 1226 change_port_settings(tty, mos7720_port, old_termios); 1227 1228 if (!port->read_urb) { 1229 dbg("%s", "URB KILLED !!!!!\n"); 1230 return; 1231 } 1232 1233 if (port->read_urb->status != -EINPROGRESS) { 1234 port->read_urb->dev = serial->dev; 1235 status = usb_submit_urb(port->read_urb, GFP_ATOMIC); 1236 if (status) 1237 dbg("usb_submit_urb(read bulk) failed, status = %d", 1238 status); 1239 } 1240 return; 1241 } 1242 1243 /* 1244 * get_lsr_info - get line status register info 1245 * 1246 * Purpose: Let user call ioctl() to get info when the UART physically 1247 * is emptied. On bus types like RS485, the transmitter must 1248 * release the bus after transmitting. This must be done when 1249 * the transmit shift register is empty, not be done when the 1250 * transmit holding register is empty. This functionality 1251 * allows an RS485 driver to be written in user space. 1252 */ 1253 static int get_lsr_info(struct tty_struct *tty, 1254 struct moschip_port *mos7720_port, unsigned int __user *value) 1255 { 1256 int count; 1257 unsigned int result = 0; 1258 1259 count = mos7720_chars_in_buffer(tty); 1260 if (count == 0) { 1261 dbg("%s -- Empty", __func__); 1262 result = TIOCSER_TEMT; 1263 } 1264 1265 if (copy_to_user(value, &result, sizeof(int))) 1266 return -EFAULT; 1267 return 0; 1268 } 1269 1270 /* 1271 * get_number_bytes_avail - get number of bytes available 1272 * 1273 * Purpose: Let user call ioctl to get the count of number of bytes available. 1274 */ 1275 static int get_number_bytes_avail(struct moschip_port *mos7720_port, 1276 unsigned int __user *value) 1277 { 1278 unsigned int result = 0; 1279 struct tty_struct *tty = mos7720_port->port->port.tty; 1280 1281 if (!tty) 1282 return -ENOIOCTLCMD; 1283 1284 result = tty->read_cnt; 1285 1286 dbg("%s(%d) = %d", __func__, mos7720_port->port->number, result); 1287 if (copy_to_user(value, &result, sizeof(int))) 1288 return -EFAULT; 1289 1290 return -ENOIOCTLCMD; 1291 } 1292 1293 static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd, 1294 unsigned int __user *value) 1295 { 1296 unsigned int mcr ; 1297 unsigned int arg; 1298 unsigned char data; 1299 1300 struct usb_serial_port *port; 1301 1302 if (mos7720_port == NULL) 1303 return -1; 1304 1305 port = (struct usb_serial_port *)mos7720_port->port; 1306 mcr = mos7720_port->shadowMCR; 1307 1308 if (copy_from_user(&arg, value, sizeof(int))) 1309 return -EFAULT; 1310 1311 switch (cmd) { 1312 case TIOCMBIS: 1313 if (arg & TIOCM_RTS) 1314 mcr |= UART_MCR_RTS; 1315 if (arg & TIOCM_DTR) 1316 mcr |= UART_MCR_RTS; 1317 if (arg & TIOCM_LOOP) 1318 mcr |= UART_MCR_LOOP; 1319 break; 1320 1321 case TIOCMBIC: 1322 if (arg & TIOCM_RTS) 1323 mcr &= ~UART_MCR_RTS; 1324 if (arg & TIOCM_DTR) 1325 mcr &= ~UART_MCR_RTS; 1326 if (arg & TIOCM_LOOP) 1327 mcr &= ~UART_MCR_LOOP; 1328 break; 1329 1330 case TIOCMSET: 1331 /* turn off the RTS and DTR and LOOPBACK 1332 * and then only turn on what was asked to */ 1333 mcr &= ~(UART_MCR_RTS | UART_MCR_DTR | UART_MCR_LOOP); 1334 mcr |= ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0); 1335 mcr |= ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0); 1336 mcr |= ((arg & TIOCM_LOOP) ? UART_MCR_LOOP : 0); 1337 break; 1338 } 1339 1340 mos7720_port->shadowMCR = mcr; 1341 1342 data = mos7720_port->shadowMCR; 1343 send_mos_cmd(port->serial, MOS_WRITE, 1344 port->number - port->serial->minor, UART_MCR, &data); 1345 1346 return 0; 1347 } 1348 1349 static int get_modem_info(struct moschip_port *mos7720_port, 1350 unsigned int __user *value) 1351 { 1352 unsigned int result = 0; 1353 unsigned int msr = mos7720_port->shadowMSR; 1354 unsigned int mcr = mos7720_port->shadowMCR; 1355 1356 result = ((mcr & UART_MCR_DTR) ? TIOCM_DTR: 0) /* 0x002 */ 1357 | ((mcr & UART_MCR_RTS) ? TIOCM_RTS: 0) /* 0x004 */ 1358 | ((msr & UART_MSR_CTS) ? TIOCM_CTS: 0) /* 0x020 */ 1359 | ((msr & UART_MSR_DCD) ? TIOCM_CAR: 0) /* 0x040 */ 1360 | ((msr & UART_MSR_RI) ? TIOCM_RI: 0) /* 0x080 */ 1361 | ((msr & UART_MSR_DSR) ? TIOCM_DSR: 0); /* 0x100 */ 1362 1363 1364 dbg("%s -- %x", __func__, result); 1365 1366 if (copy_to_user(value, &result, sizeof(int))) 1367 return -EFAULT; 1368 return 0; 1369 } 1370 1371 static int get_serial_info(struct moschip_port *mos7720_port, 1372 struct serial_struct __user *retinfo) 1373 { 1374 struct serial_struct tmp; 1375 1376 if (!retinfo) 1377 return -EFAULT; 1378 1379 memset(&tmp, 0, sizeof(tmp)); 1380 1381 tmp.type = PORT_16550A; 1382 tmp.line = mos7720_port->port->serial->minor; 1383 tmp.port = mos7720_port->port->number; 1384 tmp.irq = 0; 1385 tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ; 1386 tmp.xmit_fifo_size = NUM_URBS * URB_TRANSFER_BUFFER_SIZE; 1387 tmp.baud_base = 9600; 1388 tmp.close_delay = 5*HZ; 1389 tmp.closing_wait = 30*HZ; 1390 1391 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) 1392 return -EFAULT; 1393 return 0; 1394 } 1395 1396 static int mos7720_ioctl(struct tty_struct *tty, struct file *file, 1397 unsigned int cmd, unsigned long arg) 1398 { 1399 struct usb_serial_port *port = tty->driver_data; 1400 struct moschip_port *mos7720_port; 1401 struct async_icount cnow; 1402 struct async_icount cprev; 1403 struct serial_icounter_struct icount; 1404 1405 mos7720_port = usb_get_serial_port_data(port); 1406 if (mos7720_port == NULL) 1407 return -ENODEV; 1408 1409 dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd); 1410 1411 switch (cmd) { 1412 case TIOCINQ: 1413 /* return number of bytes available */ 1414 dbg("%s (%d) TIOCINQ", __func__, port->number); 1415 return get_number_bytes_avail(mos7720_port, 1416 (unsigned int __user *)arg); 1417 break; 1418 1419 case TIOCSERGETLSR: 1420 dbg("%s (%d) TIOCSERGETLSR", __func__, port->number); 1421 return get_lsr_info(tty, mos7720_port, 1422 (unsigned int __user *)arg); 1423 return 0; 1424 1425 /* FIXME: These should be using the mode methods */ 1426 case TIOCMBIS: 1427 case TIOCMBIC: 1428 case TIOCMSET: 1429 dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET", 1430 __func__, port->number); 1431 return set_modem_info(mos7720_port, cmd, 1432 (unsigned int __user *)arg); 1433 1434 case TIOCMGET: 1435 dbg("%s (%d) TIOCMGET", __func__, port->number); 1436 return get_modem_info(mos7720_port, 1437 (unsigned int __user *)arg); 1438 1439 case TIOCGSERIAL: 1440 dbg("%s (%d) TIOCGSERIAL", __func__, port->number); 1441 return get_serial_info(mos7720_port, 1442 (struct serial_struct __user *)arg); 1443 1444 case TIOCMIWAIT: 1445 dbg("%s (%d) TIOCMIWAIT", __func__, port->number); 1446 cprev = mos7720_port->icount; 1447 while (1) { 1448 if (signal_pending(current)) 1449 return -ERESTARTSYS; 1450 cnow = mos7720_port->icount; 1451 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && 1452 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) 1453 return -EIO; /* no change => error */ 1454 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || 1455 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || 1456 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) || 1457 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) { 1458 return 0; 1459 } 1460 cprev = cnow; 1461 } 1462 /* NOTREACHED */ 1463 break; 1464 1465 case TIOCGICOUNT: 1466 cnow = mos7720_port->icount; 1467 icount.cts = cnow.cts; 1468 icount.dsr = cnow.dsr; 1469 icount.rng = cnow.rng; 1470 icount.dcd = cnow.dcd; 1471 icount.rx = cnow.rx; 1472 icount.tx = cnow.tx; 1473 icount.frame = cnow.frame; 1474 icount.overrun = cnow.overrun; 1475 icount.parity = cnow.parity; 1476 icount.brk = cnow.brk; 1477 icount.buf_overrun = cnow.buf_overrun; 1478 1479 dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __func__, 1480 port->number, icount.rx, icount.tx); 1481 if (copy_to_user((void __user *)arg, &icount, sizeof(icount))) 1482 return -EFAULT; 1483 return 0; 1484 } 1485 1486 return -ENOIOCTLCMD; 1487 } 1488 1489 static int mos7720_startup(struct usb_serial *serial) 1490 { 1491 struct moschip_serial *mos7720_serial; 1492 struct moschip_port *mos7720_port; 1493 struct usb_device *dev; 1494 int i; 1495 char data; 1496 1497 dbg("%s: Entering ..........", __func__); 1498 1499 if (!serial) { 1500 dbg("Invalid Handler"); 1501 return -ENODEV; 1502 } 1503 1504 dev = serial->dev; 1505 1506 /* create our private serial structure */ 1507 mos7720_serial = kzalloc(sizeof(struct moschip_serial), GFP_KERNEL); 1508 if (mos7720_serial == NULL) { 1509 err("%s - Out of memory", __func__); 1510 return -ENOMEM; 1511 } 1512 1513 usb_set_serial_data(serial, mos7720_serial); 1514 1515 /* we set up the pointers to the endpoints in the mos7720_open * 1516 * function, as the structures aren't created yet. */ 1517 1518 /* set up port private structures */ 1519 for (i = 0; i < serial->num_ports; ++i) { 1520 mos7720_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL); 1521 if (mos7720_port == NULL) { 1522 err("%s - Out of memory", __func__); 1523 usb_set_serial_data(serial, NULL); 1524 kfree(mos7720_serial); 1525 return -ENOMEM; 1526 } 1527 1528 /* Initialize all port interrupt end point to port 0 int 1529 * endpoint. Our device has only one interrupt endpoint 1530 * comman to all ports */ 1531 serial->port[i]->interrupt_in_endpointAddress = 1532 serial->port[0]->interrupt_in_endpointAddress; 1533 1534 mos7720_port->port = serial->port[i]; 1535 usb_set_serial_port_data(serial->port[i], mos7720_port); 1536 1537 dbg("port number is %d", serial->port[i]->number); 1538 dbg("serial number is %d", serial->minor); 1539 } 1540 1541 1542 /* setting configuration feature to one */ 1543 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 1544 (__u8)0x03, 0x00, 0x01, 0x00, NULL, 0x00, 5*HZ); 1545 1546 /* LSR For Port 1 */ 1547 send_mos_cmd(serial, MOS_READ, 0x00, UART_LSR, &data); 1548 dbg("LSR:%x", data); 1549 1550 /* LSR For Port 2 */ 1551 send_mos_cmd(serial, MOS_READ, 0x01, UART_LSR, &data); 1552 dbg("LSR:%x", data); 1553 1554 return 0; 1555 } 1556 1557 static void mos7720_shutdown(struct usb_serial *serial) 1558 { 1559 int i; 1560 1561 /* free private structure allocated for serial port */ 1562 for (i = 0; i < serial->num_ports; ++i) { 1563 kfree(usb_get_serial_port_data(serial->port[i])); 1564 usb_set_serial_port_data(serial->port[i], NULL); 1565 } 1566 1567 /* free private structure allocated for serial device */ 1568 kfree(usb_get_serial_data(serial)); 1569 usb_set_serial_data(serial, NULL); 1570 } 1571 1572 static struct usb_driver usb_driver = { 1573 .name = "moschip7720", 1574 .probe = usb_serial_probe, 1575 .disconnect = usb_serial_disconnect, 1576 .id_table = moschip_port_id_table, 1577 .no_dynamic_id = 1, 1578 }; 1579 1580 static struct usb_serial_driver moschip7720_2port_driver = { 1581 .driver = { 1582 .owner = THIS_MODULE, 1583 .name = "moschip7720", 1584 }, 1585 .description = "Moschip 2 port adapter", 1586 .usb_driver = &usb_driver, 1587 .id_table = moschip_port_id_table, 1588 .num_ports = 2, 1589 .open = mos7720_open, 1590 .close = mos7720_close, 1591 .throttle = mos7720_throttle, 1592 .unthrottle = mos7720_unthrottle, 1593 .attach = mos7720_startup, 1594 .shutdown = mos7720_shutdown, 1595 .ioctl = mos7720_ioctl, 1596 .set_termios = mos7720_set_termios, 1597 .write = mos7720_write, 1598 .write_room = mos7720_write_room, 1599 .chars_in_buffer = mos7720_chars_in_buffer, 1600 .break_ctl = mos7720_break, 1601 .read_bulk_callback = mos7720_bulk_in_callback, 1602 .read_int_callback = mos7720_interrupt_callback, 1603 }; 1604 1605 static int __init moschip7720_init(void) 1606 { 1607 int retval; 1608 1609 dbg("%s: Entering ..........", __func__); 1610 1611 /* Register with the usb serial */ 1612 retval = usb_serial_register(&moschip7720_2port_driver); 1613 if (retval) 1614 goto failed_port_device_register; 1615 1616 info(DRIVER_DESC " " DRIVER_VERSION); 1617 1618 /* Register with the usb */ 1619 retval = usb_register(&usb_driver); 1620 if (retval) 1621 goto failed_usb_register; 1622 1623 return 0; 1624 1625 failed_usb_register: 1626 usb_serial_deregister(&moschip7720_2port_driver); 1627 1628 failed_port_device_register: 1629 return retval; 1630 } 1631 1632 static void __exit moschip7720_exit(void) 1633 { 1634 usb_deregister(&usb_driver); 1635 usb_serial_deregister(&moschip7720_2port_driver); 1636 } 1637 1638 module_init(moschip7720_init); 1639 module_exit(moschip7720_exit); 1640 1641 /* Module information */ 1642 MODULE_AUTHOR(DRIVER_AUTHOR); 1643 MODULE_DESCRIPTION(DRIVER_DESC); 1644 MODULE_LICENSE("GPL"); 1645 1646 module_param(debug, bool, S_IRUGO | S_IWUSR); 1647 MODULE_PARM_DESC(debug, "Debug enabled or not"); 1648