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