1 /* 2 * This program is free software; you can redistribute it and/or modify 3 * it under the terms of the GNU General Public License as published by 4 * the Free Software Foundation; either version 2 of the License, or 5 * (at your option) any later version. 6 * 7 * This program is distributed in the hope that it will be useful, 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 * GNU General Public License for more details. 11 * 12 * You should have received a copy of the GNU General Public License 13 * along with this program; if not, write to the Free Software 14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 15 * 16 * Clean ups from Moschip version and a few ioctl implementations by: 17 * Paul B Schroeder <pschroeder "at" uplogix "dot" com> 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 */ 24 25 #include <linux/kernel.h> 26 #include <linux/errno.h> 27 #include <linux/init.h> 28 #include <linux/slab.h> 29 #include <linux/tty.h> 30 #include <linux/tty_driver.h> 31 #include <linux/tty_flip.h> 32 #include <linux/module.h> 33 #include <linux/serial.h> 34 #include <linux/usb.h> 35 #include <linux/usb/serial.h> 36 #include <asm/uaccess.h> 37 38 /* 39 * Version Information 40 */ 41 #define DRIVER_VERSION "1.3.1" 42 #define DRIVER_DESC "Moschip 7840/7820 USB Serial Driver" 43 44 /* 45 * 16C50 UART register defines 46 */ 47 48 #define LCR_BITS_5 0x00 /* 5 bits/char */ 49 #define LCR_BITS_6 0x01 /* 6 bits/char */ 50 #define LCR_BITS_7 0x02 /* 7 bits/char */ 51 #define LCR_BITS_8 0x03 /* 8 bits/char */ 52 #define LCR_BITS_MASK 0x03 /* Mask for bits/char field */ 53 54 #define LCR_STOP_1 0x00 /* 1 stop bit */ 55 #define LCR_STOP_1_5 0x04 /* 1.5 stop bits (if 5 bits/char) */ 56 #define LCR_STOP_2 0x04 /* 2 stop bits (if 6-8 bits/char) */ 57 #define LCR_STOP_MASK 0x04 /* Mask for stop bits field */ 58 59 #define LCR_PAR_NONE 0x00 /* No parity */ 60 #define LCR_PAR_ODD 0x08 /* Odd parity */ 61 #define LCR_PAR_EVEN 0x18 /* Even parity */ 62 #define LCR_PAR_MARK 0x28 /* Force parity bit to 1 */ 63 #define LCR_PAR_SPACE 0x38 /* Force parity bit to 0 */ 64 #define LCR_PAR_MASK 0x38 /* Mask for parity field */ 65 66 #define LCR_SET_BREAK 0x40 /* Set Break condition */ 67 #define LCR_DL_ENABLE 0x80 /* Enable access to divisor latch */ 68 69 #define MCR_DTR 0x01 /* Assert DTR */ 70 #define MCR_RTS 0x02 /* Assert RTS */ 71 #define MCR_OUT1 0x04 /* Loopback only: Sets state of RI */ 72 #define MCR_MASTER_IE 0x08 /* Enable interrupt outputs */ 73 #define MCR_LOOPBACK 0x10 /* Set internal (digital) loopback mode */ 74 #define MCR_XON_ANY 0x20 /* Enable any char to exit XOFF mode */ 75 76 #define MOS7840_MSR_CTS 0x10 /* Current state of CTS */ 77 #define MOS7840_MSR_DSR 0x20 /* Current state of DSR */ 78 #define MOS7840_MSR_RI 0x40 /* Current state of RI */ 79 #define MOS7840_MSR_CD 0x80 /* Current state of CD */ 80 81 /* 82 * Defines used for sending commands to port 83 */ 84 85 #define WAIT_FOR_EVER (HZ * 0 ) /* timeout urb is wait for ever */ 86 #define MOS_WDR_TIMEOUT (HZ * 5 ) /* default urb timeout */ 87 88 #define MOS_PORT1 0x0200 89 #define MOS_PORT2 0x0300 90 #define MOS_VENREG 0x0000 91 #define MOS_MAX_PORT 0x02 92 #define MOS_WRITE 0x0E 93 #define MOS_READ 0x0D 94 95 /* Requests */ 96 #define MCS_RD_RTYPE 0xC0 97 #define MCS_WR_RTYPE 0x40 98 #define MCS_RDREQ 0x0D 99 #define MCS_WRREQ 0x0E 100 #define MCS_CTRL_TIMEOUT 500 101 #define VENDOR_READ_LENGTH (0x01) 102 103 #define MAX_NAME_LEN 64 104 105 #define ZLP_REG1 0x3A //Zero_Flag_Reg1 58 106 #define ZLP_REG5 0x3E //Zero_Flag_Reg5 62 107 108 /* For higher baud Rates use TIOCEXBAUD */ 109 #define TIOCEXBAUD 0x5462 110 111 /* vendor id and device id defines */ 112 113 #define USB_VENDOR_ID_MOSCHIP 0x9710 114 #define MOSCHIP_DEVICE_ID_7840 0x7840 115 #define MOSCHIP_DEVICE_ID_7820 0x7820 116 117 /* Interrupt Rotinue Defines */ 118 119 #define SERIAL_IIR_RLS 0x06 120 #define SERIAL_IIR_MS 0x00 121 122 /* 123 * Emulation of the bit mask on the LINE STATUS REGISTER. 124 */ 125 #define SERIAL_LSR_DR 0x0001 126 #define SERIAL_LSR_OE 0x0002 127 #define SERIAL_LSR_PE 0x0004 128 #define SERIAL_LSR_FE 0x0008 129 #define SERIAL_LSR_BI 0x0010 130 131 #define MOS_MSR_DELTA_CTS 0x10 132 #define MOS_MSR_DELTA_DSR 0x20 133 #define MOS_MSR_DELTA_RI 0x40 134 #define MOS_MSR_DELTA_CD 0x80 135 136 // Serial Port register Address 137 #define INTERRUPT_ENABLE_REGISTER ((__u16)(0x01)) 138 #define FIFO_CONTROL_REGISTER ((__u16)(0x02)) 139 #define LINE_CONTROL_REGISTER ((__u16)(0x03)) 140 #define MODEM_CONTROL_REGISTER ((__u16)(0x04)) 141 #define LINE_STATUS_REGISTER ((__u16)(0x05)) 142 #define MODEM_STATUS_REGISTER ((__u16)(0x06)) 143 #define SCRATCH_PAD_REGISTER ((__u16)(0x07)) 144 #define DIVISOR_LATCH_LSB ((__u16)(0x00)) 145 #define DIVISOR_LATCH_MSB ((__u16)(0x01)) 146 147 #define CLK_MULTI_REGISTER ((__u16)(0x02)) 148 #define CLK_START_VALUE_REGISTER ((__u16)(0x03)) 149 150 #define SERIAL_LCR_DLAB ((__u16)(0x0080)) 151 152 /* 153 * URB POOL related defines 154 */ 155 #define NUM_URBS 16 /* URB Count */ 156 #define URB_TRANSFER_BUFFER_SIZE 32 /* URB Size */ 157 158 159 static struct usb_device_id moschip_port_id_table[] = { 160 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7840)}, 161 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7820)}, 162 {} /* terminating entry */ 163 }; 164 165 static __devinitdata struct usb_device_id moschip_id_table_combined[] = { 166 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7840)}, 167 {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7820)}, 168 {} /* terminating entry */ 169 }; 170 171 MODULE_DEVICE_TABLE(usb, moschip_id_table_combined); 172 173 /* This structure holds all of the local port information */ 174 175 struct moschip_port { 176 int port_num; /*Actual port number in the device(1,2,etc) */ 177 struct urb *write_urb; /* write URB for this port */ 178 struct urb *read_urb; /* read URB for this port */ 179 __u8 shadowLCR; /* last LCR value received */ 180 __u8 shadowMCR; /* last MCR value received */ 181 char open; 182 wait_queue_head_t wait_chase; /* for handling sleeping while waiting for chase to finish */ 183 wait_queue_head_t delta_msr_wait; /* for handling sleeping while waiting for msr change to happen */ 184 int delta_msr_cond; 185 struct async_icount icount; 186 struct usb_serial_port *port; /* loop back to the owner of this object */ 187 188 /*Offsets */ 189 __u8 SpRegOffset; 190 __u8 ControlRegOffset; 191 __u8 DcrRegOffset; 192 //for processing control URBS in interrupt context 193 struct urb *control_urb; 194 char *ctrl_buf; 195 int MsrLsr; 196 197 struct urb *write_urb_pool[NUM_URBS]; 198 }; 199 200 201 static int debug; 202 static int mos7840_num_ports; //this says the number of ports in the device 203 static int mos7840_num_open_ports; 204 205 206 /* 207 * mos7840_set_reg_sync 208 * To set the Control register by calling usb_fill_control_urb function 209 * by passing usb_sndctrlpipe function as parameter. 210 */ 211 212 static int mos7840_set_reg_sync(struct usb_serial_port *port, __u16 reg, 213 __u16 val) 214 { 215 struct usb_device *dev = port->serial->dev; 216 val = val & 0x00ff; 217 dbg("mos7840_set_reg_sync offset is %x, value %x\n", reg, val); 218 219 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ, 220 MCS_WR_RTYPE, val, reg, NULL, 0, 221 MOS_WDR_TIMEOUT); 222 } 223 224 /* 225 * mos7840_get_reg_sync 226 * To set the Uart register by calling usb_fill_control_urb function by 227 * passing usb_rcvctrlpipe function as parameter. 228 */ 229 230 static int mos7840_get_reg_sync(struct usb_serial_port *port, __u16 reg, 231 __u16 * val) 232 { 233 struct usb_device *dev = port->serial->dev; 234 int ret = 0; 235 236 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ, 237 MCS_RD_RTYPE, 0, reg, val, VENDOR_READ_LENGTH, 238 MOS_WDR_TIMEOUT); 239 dbg("mos7840_get_reg_sync offset is %x, return val %x\n", reg, *val); 240 *val = (*val) & 0x00ff; 241 return ret; 242 } 243 244 /* 245 * mos7840_set_uart_reg 246 * To set the Uart register by calling usb_fill_control_urb function by 247 * passing usb_sndctrlpipe function as parameter. 248 */ 249 250 static int mos7840_set_uart_reg(struct usb_serial_port *port, __u16 reg, 251 __u16 val) 252 { 253 254 struct usb_device *dev = port->serial->dev; 255 val = val & 0x00ff; 256 // For the UART control registers, the application number need to be Or'ed 257 if (mos7840_num_ports == 4) { 258 val |= 259 (((__u16) port->number - (__u16) (port->serial->minor)) + 260 1) << 8; 261 dbg("mos7840_set_uart_reg application number is %x\n", val); 262 } else { 263 if (((__u16) port->number - (__u16) (port->serial->minor)) == 0) { 264 val |= 265 (((__u16) port->number - 266 (__u16) (port->serial->minor)) + 1) << 8; 267 dbg("mos7840_set_uart_reg application number is %x\n", 268 val); 269 } else { 270 val |= 271 (((__u16) port->number - 272 (__u16) (port->serial->minor)) + 2) << 8; 273 dbg("mos7840_set_uart_reg application number is %x\n", 274 val); 275 } 276 } 277 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ, 278 MCS_WR_RTYPE, val, reg, NULL, 0, 279 MOS_WDR_TIMEOUT); 280 281 } 282 283 /* 284 * mos7840_get_uart_reg 285 * To set the Control register by calling usb_fill_control_urb function 286 * by passing usb_rcvctrlpipe function as parameter. 287 */ 288 static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg, 289 __u16 * val) 290 { 291 struct usb_device *dev = port->serial->dev; 292 int ret = 0; 293 __u16 Wval; 294 295 //dbg("application number is %4x \n",(((__u16)port->number - (__u16)(port->serial->minor))+1)<<8); 296 /*Wval is same as application number */ 297 if (mos7840_num_ports == 4) { 298 Wval = 299 (((__u16) port->number - (__u16) (port->serial->minor)) + 300 1) << 8; 301 dbg("mos7840_get_uart_reg application number is %x\n", Wval); 302 } else { 303 if (((__u16) port->number - (__u16) (port->serial->minor)) == 0) { 304 Wval = 305 (((__u16) port->number - 306 (__u16) (port->serial->minor)) + 1) << 8; 307 dbg("mos7840_get_uart_reg application number is %x\n", 308 Wval); 309 } else { 310 Wval = 311 (((__u16) port->number - 312 (__u16) (port->serial->minor)) + 2) << 8; 313 dbg("mos7840_get_uart_reg application number is %x\n", 314 Wval); 315 } 316 } 317 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ, 318 MCS_RD_RTYPE, Wval, reg, val, VENDOR_READ_LENGTH, 319 MOS_WDR_TIMEOUT); 320 *val = (*val) & 0x00ff; 321 return ret; 322 } 323 324 static void mos7840_dump_serial_port(struct moschip_port *mos7840_port) 325 { 326 327 dbg("***************************************\n"); 328 dbg("SpRegOffset is %2x\n", mos7840_port->SpRegOffset); 329 dbg("ControlRegOffset is %2x \n", mos7840_port->ControlRegOffset); 330 dbg("DCRRegOffset is %2x \n", mos7840_port->DcrRegOffset); 331 dbg("***************************************\n"); 332 333 } 334 335 /************************************************************************/ 336 /************************************************************************/ 337 /* I N T E R F A C E F U N C T I O N S */ 338 /* I N T E R F A C E F U N C T I O N S */ 339 /************************************************************************/ 340 /************************************************************************/ 341 342 static inline void mos7840_set_port_private(struct usb_serial_port *port, 343 struct moschip_port *data) 344 { 345 usb_set_serial_port_data(port, (void *)data); 346 } 347 348 static inline struct moschip_port *mos7840_get_port_private(struct 349 usb_serial_port 350 *port) 351 { 352 return (struct moschip_port *)usb_get_serial_port_data(port); 353 } 354 355 static int mos7840_handle_new_msr(struct moschip_port *port, __u8 new_msr) 356 { 357 struct moschip_port *mos7840_port; 358 struct async_icount *icount; 359 mos7840_port = port; 360 icount = &mos7840_port->icount; 361 if (new_msr & 362 (MOS_MSR_DELTA_CTS | MOS_MSR_DELTA_DSR | MOS_MSR_DELTA_RI | 363 MOS_MSR_DELTA_CD)) { 364 icount = &mos7840_port->icount; 365 366 /* update input line counters */ 367 if (new_msr & MOS_MSR_DELTA_CTS) { 368 icount->cts++; 369 } 370 if (new_msr & MOS_MSR_DELTA_DSR) { 371 icount->dsr++; 372 } 373 if (new_msr & MOS_MSR_DELTA_CD) { 374 icount->dcd++; 375 } 376 if (new_msr & MOS_MSR_DELTA_RI) { 377 icount->rng++; 378 } 379 } 380 381 return 0; 382 } 383 384 static int mos7840_handle_new_lsr(struct moschip_port *port, __u8 new_lsr) 385 { 386 struct async_icount *icount; 387 388 dbg("%s - %02x", __FUNCTION__, new_lsr); 389 390 if (new_lsr & SERIAL_LSR_BI) { 391 // 392 // Parity and Framing errors only count if they 393 // occur exclusive of a break being 394 // received. 395 // 396 new_lsr &= (__u8) (SERIAL_LSR_OE | SERIAL_LSR_BI); 397 } 398 399 /* update input line counters */ 400 icount = &port->icount; 401 if (new_lsr & SERIAL_LSR_BI) { 402 icount->brk++; 403 } 404 if (new_lsr & SERIAL_LSR_OE) { 405 icount->overrun++; 406 } 407 if (new_lsr & SERIAL_LSR_PE) { 408 icount->parity++; 409 } 410 if (new_lsr & SERIAL_LSR_FE) { 411 icount->frame++; 412 } 413 414 return 0; 415 } 416 417 /************************************************************************/ 418 /************************************************************************/ 419 /* U S B C A L L B A C K F U N C T I O N S */ 420 /* U S B C A L L B A C K F U N C T I O N S */ 421 /************************************************************************/ 422 /************************************************************************/ 423 424 static void mos7840_control_callback(struct urb *urb) 425 { 426 unsigned char *data; 427 struct moschip_port *mos7840_port; 428 __u8 regval = 0x0; 429 430 if (!urb) { 431 dbg("%s", "Invalid Pointer !!!!:\n"); 432 return; 433 } 434 435 switch (urb->status) { 436 case 0: 437 /* success */ 438 break; 439 case -ECONNRESET: 440 case -ENOENT: 441 case -ESHUTDOWN: 442 /* this urb is terminated, clean up */ 443 dbg("%s - urb shutting down with status: %d", __FUNCTION__, 444 urb->status); 445 return; 446 default: 447 dbg("%s - nonzero urb status received: %d", __FUNCTION__, 448 urb->status); 449 goto exit; 450 } 451 452 mos7840_port = (struct moschip_port *)urb->context; 453 454 dbg("%s urb buffer size is %d\n", __FUNCTION__, urb->actual_length); 455 dbg("%s mos7840_port->MsrLsr is %d port %d\n", __FUNCTION__, 456 mos7840_port->MsrLsr, mos7840_port->port_num); 457 data = urb->transfer_buffer; 458 regval = (__u8) data[0]; 459 dbg("%s data is %x\n", __FUNCTION__, regval); 460 if (mos7840_port->MsrLsr == 0) 461 mos7840_handle_new_msr(mos7840_port, regval); 462 else if (mos7840_port->MsrLsr == 1) 463 mos7840_handle_new_lsr(mos7840_port, regval); 464 465 exit: 466 return; 467 } 468 469 static int mos7840_get_reg(struct moschip_port *mcs, __u16 Wval, __u16 reg, 470 __u16 * val) 471 { 472 struct usb_device *dev = mcs->port->serial->dev; 473 struct usb_ctrlrequest *dr = NULL; 474 unsigned char *buffer = NULL; 475 int ret = 0; 476 buffer = (__u8 *) mcs->ctrl_buf; 477 478 // dr=(struct usb_ctrlrequest *)(buffer); 479 dr = (void *)(buffer + 2); 480 dr->bRequestType = MCS_RD_RTYPE; 481 dr->bRequest = MCS_RDREQ; 482 dr->wValue = cpu_to_le16(Wval); //0; 483 dr->wIndex = cpu_to_le16(reg); 484 dr->wLength = cpu_to_le16(2); 485 486 usb_fill_control_urb(mcs->control_urb, dev, usb_rcvctrlpipe(dev, 0), 487 (unsigned char *)dr, buffer, 2, 488 mos7840_control_callback, mcs); 489 mcs->control_urb->transfer_buffer_length = 2; 490 ret = usb_submit_urb(mcs->control_urb, GFP_ATOMIC); 491 return ret; 492 } 493 494 /***************************************************************************** 495 * mos7840_interrupt_callback 496 * this is the callback function for when we have received data on the 497 * interrupt endpoint. 498 *****************************************************************************/ 499 500 static void mos7840_interrupt_callback(struct urb *urb) 501 { 502 int result; 503 int length; 504 struct moschip_port *mos7840_port; 505 struct usb_serial *serial; 506 __u16 Data; 507 unsigned char *data; 508 __u8 sp[5], st; 509 int i; 510 __u16 wval; 511 512 dbg("%s", " : Entering\n"); 513 if (!urb) { 514 dbg("%s", "Invalid Pointer !!!!:\n"); 515 return; 516 } 517 518 switch (urb->status) { 519 case 0: 520 /* success */ 521 break; 522 case -ECONNRESET: 523 case -ENOENT: 524 case -ESHUTDOWN: 525 /* this urb is terminated, clean up */ 526 dbg("%s - urb shutting down with status: %d", __FUNCTION__, 527 urb->status); 528 return; 529 default: 530 dbg("%s - nonzero urb status received: %d", __FUNCTION__, 531 urb->status); 532 goto exit; 533 } 534 535 length = urb->actual_length; 536 data = urb->transfer_buffer; 537 538 serial = (struct usb_serial *)urb->context; 539 540 /* Moschip get 5 bytes 541 * Byte 1 IIR Port 1 (port.number is 0) 542 * Byte 2 IIR Port 2 (port.number is 1) 543 * Byte 3 IIR Port 3 (port.number is 2) 544 * Byte 4 IIR Port 4 (port.number is 3) 545 * Byte 5 FIFO status for both */ 546 547 if (length && length > 5) { 548 dbg("%s \n", "Wrong data !!!"); 549 return; 550 } 551 552 sp[0] = (__u8) data[0]; 553 sp[1] = (__u8) data[1]; 554 sp[2] = (__u8) data[2]; 555 sp[3] = (__u8) data[3]; 556 st = (__u8) data[4]; 557 558 for (i = 0; i < serial->num_ports; i++) { 559 mos7840_port = mos7840_get_port_private(serial->port[i]); 560 wval = 561 (((__u16) serial->port[i]->number - 562 (__u16) (serial->minor)) + 1) << 8; 563 if (mos7840_port->open) { 564 if (sp[i] & 0x01) { 565 dbg("SP%d No Interrupt !!!\n", i); 566 } else { 567 switch (sp[i] & 0x0f) { 568 case SERIAL_IIR_RLS: 569 dbg("Serial Port %d: Receiver status error or ", i); 570 dbg("address bit detected in 9-bit mode\n"); 571 mos7840_port->MsrLsr = 1; 572 mos7840_get_reg(mos7840_port, wval, 573 LINE_STATUS_REGISTER, 574 &Data); 575 break; 576 case SERIAL_IIR_MS: 577 dbg("Serial Port %d: Modem status change\n", i); 578 mos7840_port->MsrLsr = 0; 579 mos7840_get_reg(mos7840_port, wval, 580 MODEM_STATUS_REGISTER, 581 &Data); 582 break; 583 } 584 } 585 } 586 } 587 exit: 588 result = usb_submit_urb(urb, GFP_ATOMIC); 589 if (result) { 590 dev_err(&urb->dev->dev, 591 "%s - Error %d submitting interrupt urb\n", 592 __FUNCTION__, result); 593 } 594 595 return; 596 597 } 598 599 static int mos7840_port_paranoia_check(struct usb_serial_port *port, 600 const char *function) 601 { 602 if (!port) { 603 dbg("%s - port == NULL", function); 604 return -1; 605 } 606 if (!port->serial) { 607 dbg("%s - port->serial == NULL", function); 608 return -1; 609 } 610 611 return 0; 612 } 613 614 /* Inline functions to check the sanity of a pointer that is passed to us */ 615 static int mos7840_serial_paranoia_check(struct usb_serial *serial, 616 const char *function) 617 { 618 if (!serial) { 619 dbg("%s - serial == NULL", function); 620 return -1; 621 } 622 if (!serial->type) { 623 dbg("%s - serial->type == NULL!", function); 624 return -1; 625 } 626 627 return 0; 628 } 629 630 static struct usb_serial *mos7840_get_usb_serial(struct usb_serial_port *port, 631 const char *function) 632 { 633 /* if no port was specified, or it fails a paranoia check */ 634 if (!port || 635 mos7840_port_paranoia_check(port, function) || 636 mos7840_serial_paranoia_check(port->serial, function)) { 637 /* then say that we don't have a valid usb_serial thing, which will * end up genrating -ENODEV return values */ 638 return NULL; 639 } 640 641 return port->serial; 642 } 643 644 /***************************************************************************** 645 * mos7840_bulk_in_callback 646 * this is the callback function for when we have received data on the 647 * bulk in endpoint. 648 *****************************************************************************/ 649 650 static void mos7840_bulk_in_callback(struct urb *urb) 651 { 652 int status; 653 unsigned char *data; 654 struct usb_serial *serial; 655 struct usb_serial_port *port; 656 struct moschip_port *mos7840_port; 657 struct tty_struct *tty; 658 659 if (!urb) { 660 dbg("%s", "Invalid Pointer !!!!:\n"); 661 return; 662 } 663 664 if (urb->status) { 665 dbg("nonzero read bulk status received: %d", urb->status); 666 return; 667 } 668 669 mos7840_port = (struct moschip_port *)urb->context; 670 if (!mos7840_port) { 671 dbg("%s", "NULL mos7840_port pointer \n"); 672 return; 673 } 674 675 port = (struct usb_serial_port *)mos7840_port->port; 676 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 677 dbg("%s", "Port Paranoia failed \n"); 678 return; 679 } 680 681 serial = mos7840_get_usb_serial(port, __FUNCTION__); 682 if (!serial) { 683 dbg("%s\n", "Bad serial pointer "); 684 return; 685 } 686 687 dbg("%s\n", "Entering... \n"); 688 689 data = urb->transfer_buffer; 690 691 dbg("%s", "Entering ........... \n"); 692 693 if (urb->actual_length) { 694 tty = mos7840_port->port->tty; 695 if (tty) { 696 tty_buffer_request_room(tty, urb->actual_length); 697 tty_insert_flip_string(tty, data, urb->actual_length); 698 dbg(" %s \n", data); 699 tty_flip_buffer_push(tty); 700 } 701 mos7840_port->icount.rx += urb->actual_length; 702 dbg("mos7840_port->icount.rx is %d:\n", 703 mos7840_port->icount.rx); 704 } 705 706 if (!mos7840_port->read_urb) { 707 dbg("%s", "URB KILLED !!!\n"); 708 return; 709 } 710 711 if (mos7840_port->read_urb->status != -EINPROGRESS) { 712 mos7840_port->read_urb->dev = serial->dev; 713 714 status = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC); 715 716 if (status) { 717 dbg(" usb_submit_urb(read bulk) failed, status = %d", 718 status); 719 } 720 } 721 } 722 723 /***************************************************************************** 724 * mos7840_bulk_out_data_callback 725 * this is the callback function for when we have finished sending serial data 726 * on the bulk out endpoint. 727 *****************************************************************************/ 728 729 static void mos7840_bulk_out_data_callback(struct urb *urb) 730 { 731 struct moschip_port *mos7840_port; 732 struct tty_struct *tty; 733 if (!urb) { 734 dbg("%s", "Invalid Pointer !!!!:\n"); 735 return; 736 } 737 738 if (urb->status) { 739 dbg("nonzero write bulk status received:%d\n", urb->status); 740 return; 741 } 742 743 mos7840_port = (struct moschip_port *)urb->context; 744 if (!mos7840_port) { 745 dbg("%s", "NULL mos7840_port pointer \n"); 746 return; 747 } 748 749 if (mos7840_port_paranoia_check(mos7840_port->port, __FUNCTION__)) { 750 dbg("%s", "Port Paranoia failed \n"); 751 return; 752 } 753 754 dbg("%s \n", "Entering ........."); 755 756 tty = mos7840_port->port->tty; 757 758 if (tty && mos7840_port->open) { 759 /* let the tty driver wakeup if it has a special * 760 * write_wakeup function */ 761 762 if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) 763 && tty->ldisc.write_wakeup) { 764 (tty->ldisc.write_wakeup) (tty); 765 } 766 767 /* tell the tty driver that something has changed */ 768 wake_up_interruptible(&tty->write_wait); 769 } 770 771 } 772 773 /************************************************************************/ 774 /* D R I V E R T T Y I N T E R F A C E F U N C T I O N S */ 775 /************************************************************************/ 776 #ifdef MCSSerialProbe 777 static int mos7840_serial_probe(struct usb_serial *serial, 778 const struct usb_device_id *id) 779 { 780 781 /*need to implement the mode_reg reading and updating\ 782 structures usb_serial_ device_type\ 783 (i.e num_ports, num_bulkin,bulkout etc) */ 784 /* Also we can update the changes attach */ 785 return 1; 786 } 787 #endif 788 789 /***************************************************************************** 790 * mos7840_open 791 * this function is called by the tty driver when a port is opened 792 * If successful, we return 0 793 * Otherwise we return a negative error number. 794 *****************************************************************************/ 795 796 static int mos7840_open(struct usb_serial_port *port, struct file *filp) 797 { 798 int response; 799 int j; 800 struct usb_serial *serial; 801 struct urb *urb; 802 __u16 Data; 803 int status; 804 struct moschip_port *mos7840_port; 805 806 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 807 dbg("%s", "Port Paranoia failed \n"); 808 return -ENODEV; 809 } 810 811 mos7840_num_open_ports++; 812 serial = port->serial; 813 814 if (mos7840_serial_paranoia_check(serial, __FUNCTION__)) { 815 dbg("%s", "Serial Paranoia failed \n"); 816 return -ENODEV; 817 } 818 819 mos7840_port = mos7840_get_port_private(port); 820 821 if (mos7840_port == NULL) 822 return -ENODEV; 823 824 usb_clear_halt(serial->dev, port->write_urb->pipe); 825 usb_clear_halt(serial->dev, port->read_urb->pipe); 826 827 /* Initialising the write urb pool */ 828 for (j = 0; j < NUM_URBS; ++j) { 829 urb = usb_alloc_urb(0, GFP_ATOMIC); 830 mos7840_port->write_urb_pool[j] = urb; 831 832 if (urb == NULL) { 833 err("No more urbs???"); 834 continue; 835 } 836 837 urb->transfer_buffer = NULL; 838 urb->transfer_buffer = 839 kmalloc(URB_TRANSFER_BUFFER_SIZE, GFP_KERNEL); 840 if (!urb->transfer_buffer) { 841 err("%s-out of memory for urb buffers.", __FUNCTION__); 842 continue; 843 } 844 } 845 846 /***************************************************************************** 847 * Initialize MCS7840 -- Write Init values to corresponding Registers 848 * 849 * Register Index 850 * 1 : IER 851 * 2 : FCR 852 * 3 : LCR 853 * 4 : MCR 854 * 855 * 0x08 : SP1/2 Control Reg 856 *****************************************************************************/ 857 858 //NEED to check the following Block 859 860 status = 0; 861 Data = 0x0; 862 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data); 863 if (status < 0) { 864 dbg("Reading Spreg failed\n"); 865 return -1; 866 } 867 Data |= 0x80; 868 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); 869 if (status < 0) { 870 dbg("writing Spreg failed\n"); 871 return -1; 872 } 873 874 Data &= ~0x80; 875 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); 876 if (status < 0) { 877 dbg("writing Spreg failed\n"); 878 return -1; 879 } 880 //End of block to be checked 881 882 status = 0; 883 Data = 0x0; 884 status = 885 mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset, &Data); 886 if (status < 0) { 887 dbg("Reading Controlreg failed\n"); 888 return -1; 889 } 890 Data |= 0x08; //Driver done bit 891 Data |= 0x20; //rx_disable 892 status = 0; 893 status = 894 mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset, Data); 895 if (status < 0) { 896 dbg("writing Controlreg failed\n"); 897 return -1; 898 } 899 //do register settings here 900 // Set all regs to the device default values. 901 //////////////////////////////////// 902 // First Disable all interrupts. 903 //////////////////////////////////// 904 905 Data = 0x00; 906 status = 0; 907 status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); 908 if (status < 0) { 909 dbg("disableing interrupts failed\n"); 910 return -1; 911 } 912 // Set FIFO_CONTROL_REGISTER to the default value 913 Data = 0x00; 914 status = 0; 915 status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); 916 if (status < 0) { 917 dbg("Writing FIFO_CONTROL_REGISTER failed\n"); 918 return -1; 919 } 920 921 Data = 0xcf; 922 status = 0; 923 status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); 924 if (status < 0) { 925 dbg("Writing FIFO_CONTROL_REGISTER failed\n"); 926 return -1; 927 } 928 929 Data = 0x03; 930 status = 0; 931 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 932 mos7840_port->shadowLCR = Data; 933 934 Data = 0x0b; 935 status = 0; 936 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 937 mos7840_port->shadowMCR = Data; 938 939 Data = 0x00; 940 status = 0; 941 status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data); 942 mos7840_port->shadowLCR = Data; 943 944 Data |= SERIAL_LCR_DLAB; //data latch enable in LCR 0x80 945 status = 0; 946 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 947 948 Data = 0x0c; 949 status = 0; 950 status = mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data); 951 952 Data = 0x0; 953 status = 0; 954 status = mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data); 955 956 Data = 0x00; 957 status = 0; 958 status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data); 959 960 Data = Data & ~SERIAL_LCR_DLAB; 961 status = 0; 962 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 963 mos7840_port->shadowLCR = Data; 964 965 //clearing Bulkin and Bulkout Fifo 966 Data = 0x0; 967 status = 0; 968 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data); 969 970 Data = Data | 0x0c; 971 status = 0; 972 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); 973 974 Data = Data & ~0x0c; 975 status = 0; 976 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); 977 //Finally enable all interrupts 978 Data = 0x0; 979 Data = 0x0c; 980 status = 0; 981 status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); 982 983 //clearing rx_disable 984 Data = 0x0; 985 status = 0; 986 status = 987 mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset, &Data); 988 Data = Data & ~0x20; 989 status = 0; 990 status = 991 mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset, Data); 992 993 // rx_negate 994 Data = 0x0; 995 status = 0; 996 status = 997 mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset, &Data); 998 Data = Data | 0x10; 999 status = 0; 1000 status = 1001 mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset, Data); 1002 1003 /* force low_latency on so that our tty_push actually forces * 1004 * the data through,otherwise it is scheduled, and with * 1005 * high data rates (like with OHCI) data can get lost. */ 1006 1007 if (port->tty) 1008 port->tty->low_latency = 1; 1009 /* Check to see if we've set up our endpoint info yet * 1010 * (can't set it up in mos7840_startup as the structures * 1011 * were not set up at that time.) */ 1012 if (mos7840_num_open_ports == 1) { 1013 if (serial->port[0]->interrupt_in_buffer == NULL) { 1014 1015 /* set up interrupt urb */ 1016 1017 usb_fill_int_urb(serial->port[0]->interrupt_in_urb, 1018 serial->dev, 1019 usb_rcvintpipe(serial->dev, 1020 serial->port[0]-> 1021 interrupt_in_endpointAddress), 1022 serial->port[0]->interrupt_in_buffer, 1023 serial->port[0]->interrupt_in_urb-> 1024 transfer_buffer_length, 1025 mos7840_interrupt_callback, 1026 serial, 1027 serial->port[0]->interrupt_in_urb-> 1028 interval); 1029 1030 /* start interrupt read for mos7840 * 1031 * will continue as long as mos7840 is connected */ 1032 1033 response = 1034 usb_submit_urb(serial->port[0]->interrupt_in_urb, 1035 GFP_KERNEL); 1036 if (response) { 1037 err("%s - Error %d submitting interrupt urb", 1038 __FUNCTION__, response); 1039 } 1040 1041 } 1042 1043 } 1044 1045 /* see if we've set up our endpoint info yet * 1046 * (can't set it up in mos7840_startup as the * 1047 * structures were not set up at that time.) */ 1048 1049 dbg("port number is %d \n", port->number); 1050 dbg("serial number is %d \n", port->serial->minor); 1051 dbg("Bulkin endpoint is %d \n", port->bulk_in_endpointAddress); 1052 dbg("BulkOut endpoint is %d \n", port->bulk_out_endpointAddress); 1053 dbg("Interrupt endpoint is %d \n", port->interrupt_in_endpointAddress); 1054 dbg("port's number in the device is %d\n", mos7840_port->port_num); 1055 mos7840_port->read_urb = port->read_urb; 1056 1057 /* set up our bulk in urb */ 1058 1059 usb_fill_bulk_urb(mos7840_port->read_urb, 1060 serial->dev, 1061 usb_rcvbulkpipe(serial->dev, 1062 port->bulk_in_endpointAddress), 1063 port->bulk_in_buffer, 1064 mos7840_port->read_urb->transfer_buffer_length, 1065 mos7840_bulk_in_callback, mos7840_port); 1066 1067 dbg("mos7840_open: bulkin endpoint is %d\n", 1068 port->bulk_in_endpointAddress); 1069 response = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL); 1070 if (response) { 1071 err("%s - Error %d submitting control urb", __FUNCTION__, 1072 response); 1073 } 1074 1075 /* initialize our wait queues */ 1076 init_waitqueue_head(&mos7840_port->wait_chase); 1077 init_waitqueue_head(&mos7840_port->delta_msr_wait); 1078 1079 /* initialize our icount structure */ 1080 memset(&(mos7840_port->icount), 0x00, sizeof(mos7840_port->icount)); 1081 1082 /* initialize our port settings */ 1083 mos7840_port->shadowMCR = MCR_MASTER_IE; /* Must set to enable ints! */ 1084 /* send a open port command */ 1085 mos7840_port->open = 1; 1086 //mos7840_change_port_settings(mos7840_port,old_termios); 1087 mos7840_port->icount.tx = 0; 1088 mos7840_port->icount.rx = 0; 1089 1090 dbg("\n\nusb_serial serial:%p mos7840_port:%p\n usb_serial_port port:%p\n\n", serial, mos7840_port, port); 1091 1092 return 0; 1093 1094 } 1095 1096 /***************************************************************************** 1097 * mos7840_chars_in_buffer 1098 * this function is called by the tty driver when it wants to know how many 1099 * bytes of data we currently have outstanding in the port (data that has 1100 * been written, but hasn't made it out the port yet) 1101 * If successful, we return the number of bytes left to be written in the 1102 * system, 1103 * Otherwise we return a negative error number. 1104 *****************************************************************************/ 1105 1106 static int mos7840_chars_in_buffer(struct usb_serial_port *port) 1107 { 1108 int i; 1109 int chars = 0; 1110 struct moschip_port *mos7840_port; 1111 1112 dbg("%s \n", " mos7840_chars_in_buffer:entering ..........."); 1113 1114 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 1115 dbg("%s", "Invalid port \n"); 1116 return -1; 1117 } 1118 1119 mos7840_port = mos7840_get_port_private(port); 1120 if (mos7840_port == NULL) { 1121 dbg("%s \n", "mos7840_break:leaving ..........."); 1122 return -1; 1123 } 1124 1125 for (i = 0; i < NUM_URBS; ++i) { 1126 if (mos7840_port->write_urb_pool[i]->status == -EINPROGRESS) { 1127 chars += URB_TRANSFER_BUFFER_SIZE; 1128 } 1129 } 1130 dbg("%s - returns %d", __FUNCTION__, chars); 1131 return (chars); 1132 1133 } 1134 1135 /************************************************************************ 1136 * 1137 * mos7840_block_until_tx_empty 1138 * 1139 * This function will block the close until one of the following: 1140 * 1. TX count are 0 1141 * 2. The mos7840 has stopped 1142 * 3. A timout of 3 seconds without activity has expired 1143 * 1144 ************************************************************************/ 1145 static void mos7840_block_until_tx_empty(struct moschip_port *mos7840_port) 1146 { 1147 int timeout = HZ / 10; 1148 int wait = 30; 1149 int count; 1150 1151 while (1) { 1152 1153 count = mos7840_chars_in_buffer(mos7840_port->port); 1154 1155 /* Check for Buffer status */ 1156 if (count <= 0) { 1157 return; 1158 } 1159 1160 /* Block the thread for a while */ 1161 interruptible_sleep_on_timeout(&mos7840_port->wait_chase, 1162 timeout); 1163 1164 /* No activity.. count down section */ 1165 wait--; 1166 if (wait == 0) { 1167 dbg("%s - TIMEOUT", __FUNCTION__); 1168 return; 1169 } else { 1170 /* Reset timout value back to seconds */ 1171 wait = 30; 1172 } 1173 } 1174 } 1175 1176 /***************************************************************************** 1177 * mos7840_close 1178 * this function is called by the tty driver when a port is closed 1179 *****************************************************************************/ 1180 1181 static void mos7840_close(struct usb_serial_port *port, struct file *filp) 1182 { 1183 struct usb_serial *serial; 1184 struct moschip_port *mos7840_port; 1185 int j; 1186 __u16 Data; 1187 1188 dbg("%s\n", "mos7840_close:entering..."); 1189 1190 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 1191 dbg("%s", "Port Paranoia failed \n"); 1192 return; 1193 } 1194 1195 serial = mos7840_get_usb_serial(port, __FUNCTION__); 1196 if (!serial) { 1197 dbg("%s", "Serial Paranoia failed \n"); 1198 return; 1199 } 1200 1201 mos7840_port = mos7840_get_port_private(port); 1202 1203 if (mos7840_port == NULL) { 1204 return; 1205 } 1206 1207 for (j = 0; j < NUM_URBS; ++j) 1208 usb_kill_urb(mos7840_port->write_urb_pool[j]); 1209 1210 /* Freeing Write URBs */ 1211 for (j = 0; j < NUM_URBS; ++j) { 1212 if (mos7840_port->write_urb_pool[j]) { 1213 if (mos7840_port->write_urb_pool[j]->transfer_buffer) 1214 kfree(mos7840_port->write_urb_pool[j]-> 1215 transfer_buffer); 1216 1217 usb_free_urb(mos7840_port->write_urb_pool[j]); 1218 } 1219 } 1220 1221 if (serial->dev) { 1222 /* flush and block until tx is empty */ 1223 mos7840_block_until_tx_empty(mos7840_port); 1224 } 1225 1226 /* While closing port, shutdown all bulk read, write * 1227 * and interrupt read if they exists */ 1228 if (serial->dev) { 1229 1230 if (mos7840_port->write_urb) { 1231 dbg("%s", "Shutdown bulk write\n"); 1232 usb_kill_urb(mos7840_port->write_urb); 1233 } 1234 1235 if (mos7840_port->read_urb) { 1236 dbg("%s", "Shutdown bulk read\n"); 1237 usb_kill_urb(mos7840_port->read_urb); 1238 } 1239 if ((&mos7840_port->control_urb)) { 1240 dbg("%s", "Shutdown control read\n"); 1241 // usb_kill_urb (mos7840_port->control_urb); 1242 1243 } 1244 } 1245 // if(mos7840_port->ctrl_buf != NULL) 1246 // kfree(mos7840_port->ctrl_buf); 1247 mos7840_num_open_ports--; 1248 dbg("mos7840_num_open_ports in close%d:in port%d\n", 1249 mos7840_num_open_ports, port->number); 1250 if (mos7840_num_open_ports == 0) { 1251 if (serial->port[0]->interrupt_in_urb) { 1252 dbg("%s", "Shutdown interrupt_in_urb\n"); 1253 } 1254 } 1255 1256 if (mos7840_port->write_urb) { 1257 /* if this urb had a transfer buffer already (old tx) free it */ 1258 1259 if (mos7840_port->write_urb->transfer_buffer != NULL) { 1260 kfree(mos7840_port->write_urb->transfer_buffer); 1261 } 1262 usb_free_urb(mos7840_port->write_urb); 1263 } 1264 1265 Data = 0x0; 1266 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 1267 1268 Data = 0x00; 1269 mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); 1270 1271 mos7840_port->open = 0; 1272 1273 dbg("%s \n", "Leaving ............"); 1274 } 1275 1276 /************************************************************************ 1277 * 1278 * mos7840_block_until_chase_response 1279 * 1280 * This function will block the close until one of the following: 1281 * 1. Response to our Chase comes from mos7840 1282 * 2. A timout of 10 seconds without activity has expired 1283 * (1K of mos7840 data @ 2400 baud ==> 4 sec to empty) 1284 * 1285 ************************************************************************/ 1286 1287 static void mos7840_block_until_chase_response(struct moschip_port 1288 *mos7840_port) 1289 { 1290 int timeout = 1 * HZ; 1291 int wait = 10; 1292 int count; 1293 1294 while (1) { 1295 count = mos7840_chars_in_buffer(mos7840_port->port); 1296 1297 /* Check for Buffer status */ 1298 if (count <= 0) { 1299 return; 1300 } 1301 1302 /* Block the thread for a while */ 1303 interruptible_sleep_on_timeout(&mos7840_port->wait_chase, 1304 timeout); 1305 /* No activity.. count down section */ 1306 wait--; 1307 if (wait == 0) { 1308 dbg("%s - TIMEOUT", __FUNCTION__); 1309 return; 1310 } else { 1311 /* Reset timout value back to seconds */ 1312 wait = 10; 1313 } 1314 } 1315 1316 } 1317 1318 /***************************************************************************** 1319 * mos7840_break 1320 * this function sends a break to the port 1321 *****************************************************************************/ 1322 static void mos7840_break(struct usb_serial_port *port, int break_state) 1323 { 1324 unsigned char data; 1325 struct usb_serial *serial; 1326 struct moschip_port *mos7840_port; 1327 1328 dbg("%s \n", "Entering ..........."); 1329 dbg("mos7840_break: Start\n"); 1330 1331 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 1332 dbg("%s", "Port Paranoia failed \n"); 1333 return; 1334 } 1335 1336 serial = mos7840_get_usb_serial(port, __FUNCTION__); 1337 if (!serial) { 1338 dbg("%s", "Serial Paranoia failed \n"); 1339 return; 1340 } 1341 1342 mos7840_port = mos7840_get_port_private(port); 1343 1344 if (mos7840_port == NULL) { 1345 return; 1346 } 1347 1348 if (serial->dev) { 1349 1350 /* flush and block until tx is empty */ 1351 mos7840_block_until_chase_response(mos7840_port); 1352 } 1353 1354 if (break_state == -1) { 1355 data = mos7840_port->shadowLCR | LCR_SET_BREAK; 1356 } else { 1357 data = mos7840_port->shadowLCR & ~LCR_SET_BREAK; 1358 } 1359 1360 mos7840_port->shadowLCR = data; 1361 dbg("mcs7840_break mos7840_port->shadowLCR is %x\n", 1362 mos7840_port->shadowLCR); 1363 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, 1364 mos7840_port->shadowLCR); 1365 1366 return; 1367 } 1368 1369 /***************************************************************************** 1370 * mos7840_write_room 1371 * this function is called by the tty driver when it wants to know how many 1372 * bytes of data we can accept for a specific port. 1373 * If successful, we return the amount of room that we have for this port 1374 * Otherwise we return a negative error number. 1375 *****************************************************************************/ 1376 1377 static int mos7840_write_room(struct usb_serial_port *port) 1378 { 1379 int i; 1380 int room = 0; 1381 struct moschip_port *mos7840_port; 1382 1383 dbg("%s \n", " mos7840_write_room:entering ..........."); 1384 1385 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 1386 dbg("%s", "Invalid port \n"); 1387 dbg("%s \n", " mos7840_write_room:leaving ..........."); 1388 return -1; 1389 } 1390 1391 mos7840_port = mos7840_get_port_private(port); 1392 if (mos7840_port == NULL) { 1393 dbg("%s \n", "mos7840_break:leaving ..........."); 1394 return -1; 1395 } 1396 1397 for (i = 0; i < NUM_URBS; ++i) { 1398 if (mos7840_port->write_urb_pool[i]->status != -EINPROGRESS) { 1399 room += URB_TRANSFER_BUFFER_SIZE; 1400 } 1401 } 1402 1403 dbg("%s - returns %d", __FUNCTION__, room); 1404 return (room); 1405 1406 } 1407 1408 /***************************************************************************** 1409 * mos7840_write 1410 * this function is called by the tty driver when data should be written to 1411 * the port. 1412 * If successful, we return the number of bytes written, otherwise we 1413 * return a negative error number. 1414 *****************************************************************************/ 1415 1416 static int mos7840_write(struct usb_serial_port *port, 1417 const unsigned char *data, int count) 1418 { 1419 int status; 1420 int i; 1421 int bytes_sent = 0; 1422 int transfer_size; 1423 1424 struct moschip_port *mos7840_port; 1425 struct usb_serial *serial; 1426 struct urb *urb; 1427 //__u16 Data; 1428 const unsigned char *current_position = data; 1429 unsigned char *data1; 1430 dbg("%s \n", "entering ..........."); 1431 //dbg("mos7840_write: mos7840_port->shadowLCR is %x\n",mos7840_port->shadowLCR); 1432 1433 #ifdef NOTMOS7840 1434 Data = 0x00; 1435 status = 0; 1436 status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data); 1437 mos7840_port->shadowLCR = Data; 1438 dbg("mos7840_write: LINE_CONTROL_REGISTER is %x\n", Data); 1439 dbg("mos7840_write: mos7840_port->shadowLCR is %x\n", 1440 mos7840_port->shadowLCR); 1441 1442 //Data = 0x03; 1443 //status = mos7840_set_uart_reg(port,LINE_CONTROL_REGISTER,Data); 1444 //mos7840_port->shadowLCR=Data;//Need to add later 1445 1446 Data |= SERIAL_LCR_DLAB; //data latch enable in LCR 0x80 1447 status = 0; 1448 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 1449 1450 //Data = 0x0c; 1451 //status = mos7840_set_uart_reg(port,DIVISOR_LATCH_LSB,Data); 1452 Data = 0x00; 1453 status = 0; 1454 status = mos7840_get_uart_reg(port, DIVISOR_LATCH_LSB, &Data); 1455 dbg("mos7840_write:DLL value is %x\n", Data); 1456 1457 Data = 0x0; 1458 status = 0; 1459 status = mos7840_get_uart_reg(port, DIVISOR_LATCH_MSB, &Data); 1460 dbg("mos7840_write:DLM value is %x\n", Data); 1461 1462 Data = Data & ~SERIAL_LCR_DLAB; 1463 dbg("mos7840_write: mos7840_port->shadowLCR is %x\n", 1464 mos7840_port->shadowLCR); 1465 status = 0; 1466 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 1467 #endif 1468 1469 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 1470 dbg("%s", "Port Paranoia failed \n"); 1471 return -1; 1472 } 1473 1474 serial = port->serial; 1475 if (mos7840_serial_paranoia_check(serial, __FUNCTION__)) { 1476 dbg("%s", "Serial Paranoia failed \n"); 1477 return -1; 1478 } 1479 1480 mos7840_port = mos7840_get_port_private(port); 1481 if (mos7840_port == NULL) { 1482 dbg("%s", "mos7840_port is NULL\n"); 1483 return -1; 1484 } 1485 1486 /* try to find a free urb in the list */ 1487 urb = NULL; 1488 1489 for (i = 0; i < NUM_URBS; ++i) { 1490 if (mos7840_port->write_urb_pool[i]->status != -EINPROGRESS) { 1491 urb = mos7840_port->write_urb_pool[i]; 1492 dbg("\nURB:%d", i); 1493 break; 1494 } 1495 } 1496 1497 if (urb == NULL) { 1498 dbg("%s - no more free urbs", __FUNCTION__); 1499 goto exit; 1500 } 1501 1502 if (urb->transfer_buffer == NULL) { 1503 urb->transfer_buffer = 1504 kmalloc(URB_TRANSFER_BUFFER_SIZE, GFP_KERNEL); 1505 1506 if (urb->transfer_buffer == NULL) { 1507 err("%s no more kernel memory...", __FUNCTION__); 1508 goto exit; 1509 } 1510 } 1511 transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE); 1512 1513 memcpy(urb->transfer_buffer, current_position, transfer_size); 1514 1515 /* fill urb with data and submit */ 1516 usb_fill_bulk_urb(urb, 1517 serial->dev, 1518 usb_sndbulkpipe(serial->dev, 1519 port->bulk_out_endpointAddress), 1520 urb->transfer_buffer, 1521 transfer_size, 1522 mos7840_bulk_out_data_callback, mos7840_port); 1523 1524 data1 = urb->transfer_buffer; 1525 dbg("\nbulkout endpoint is %d", port->bulk_out_endpointAddress); 1526 1527 /* send it down the pipe */ 1528 status = usb_submit_urb(urb, GFP_ATOMIC); 1529 1530 if (status) { 1531 err("%s - usb_submit_urb(write bulk) failed with status = %d", 1532 __FUNCTION__, status); 1533 bytes_sent = status; 1534 goto exit; 1535 } 1536 bytes_sent = transfer_size; 1537 mos7840_port->icount.tx += transfer_size; 1538 dbg("mos7840_port->icount.tx is %d:\n", mos7840_port->icount.tx); 1539 exit: 1540 1541 return bytes_sent; 1542 1543 } 1544 1545 /***************************************************************************** 1546 * mos7840_throttle 1547 * this function is called by the tty driver when it wants to stop the data 1548 * being read from the port. 1549 *****************************************************************************/ 1550 1551 static void mos7840_throttle(struct usb_serial_port *port) 1552 { 1553 struct moschip_port *mos7840_port; 1554 struct tty_struct *tty; 1555 int status; 1556 1557 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 1558 dbg("%s", "Invalid port \n"); 1559 return; 1560 } 1561 1562 dbg("- port %d\n", port->number); 1563 1564 mos7840_port = mos7840_get_port_private(port); 1565 1566 if (mos7840_port == NULL) 1567 return; 1568 1569 if (!mos7840_port->open) { 1570 dbg("%s\n", "port not opened"); 1571 return; 1572 } 1573 1574 dbg("%s", "Entering .......... \n"); 1575 1576 tty = port->tty; 1577 if (!tty) { 1578 dbg("%s - no tty available", __FUNCTION__); 1579 return; 1580 } 1581 1582 /* if we are implementing XON/XOFF, send the stop character */ 1583 if (I_IXOFF(tty)) { 1584 unsigned char stop_char = STOP_CHAR(tty); 1585 status = mos7840_write(port, &stop_char, 1); 1586 if (status <= 0) { 1587 return; 1588 } 1589 } 1590 1591 /* if we are implementing RTS/CTS, toggle that line */ 1592 if (tty->termios->c_cflag & CRTSCTS) { 1593 mos7840_port->shadowMCR &= ~MCR_RTS; 1594 status = 0; 1595 status = 1596 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, 1597 mos7840_port->shadowMCR); 1598 1599 if (status < 0) { 1600 return; 1601 } 1602 } 1603 1604 return; 1605 } 1606 1607 /***************************************************************************** 1608 * mos7840_unthrottle 1609 * this function is called by the tty driver when it wants to resume the data 1610 * being read from the port (called after SerialThrottle is called) 1611 *****************************************************************************/ 1612 static void mos7840_unthrottle(struct usb_serial_port *port) 1613 { 1614 struct tty_struct *tty; 1615 int status; 1616 struct moschip_port *mos7840_port = mos7840_get_port_private(port); 1617 1618 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 1619 dbg("%s", "Invalid port \n"); 1620 return; 1621 } 1622 1623 if (mos7840_port == NULL) 1624 return; 1625 1626 if (!mos7840_port->open) { 1627 dbg("%s - port not opened", __FUNCTION__); 1628 return; 1629 } 1630 1631 dbg("%s", "Entering .......... \n"); 1632 1633 tty = port->tty; 1634 if (!tty) { 1635 dbg("%s - no tty available", __FUNCTION__); 1636 return; 1637 } 1638 1639 /* if we are implementing XON/XOFF, send the start character */ 1640 if (I_IXOFF(tty)) { 1641 unsigned char start_char = START_CHAR(tty); 1642 status = mos7840_write(port, &start_char, 1); 1643 if (status <= 0) { 1644 return; 1645 } 1646 } 1647 1648 /* if we are implementing RTS/CTS, toggle that line */ 1649 if (tty->termios->c_cflag & CRTSCTS) { 1650 mos7840_port->shadowMCR |= MCR_RTS; 1651 status = 0; 1652 status = 1653 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, 1654 mos7840_port->shadowMCR); 1655 if (status < 0) { 1656 return; 1657 } 1658 } 1659 1660 return; 1661 } 1662 1663 static int mos7840_tiocmget(struct usb_serial_port *port, struct file *file) 1664 { 1665 struct moschip_port *mos7840_port; 1666 unsigned int result; 1667 __u16 msr; 1668 __u16 mcr; 1669 int status = 0; 1670 mos7840_port = mos7840_get_port_private(port); 1671 1672 dbg("%s - port %d", __FUNCTION__, port->number); 1673 1674 if (mos7840_port == NULL) 1675 return -ENODEV; 1676 1677 status = mos7840_get_uart_reg(port, MODEM_STATUS_REGISTER, &msr); 1678 status = mos7840_get_uart_reg(port, MODEM_CONTROL_REGISTER, &mcr); 1679 result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0) 1680 | ((mcr & MCR_RTS) ? TIOCM_RTS : 0) 1681 | ((mcr & MCR_LOOPBACK) ? TIOCM_LOOP : 0) 1682 | ((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0) 1683 | ((msr & MOS7840_MSR_CD) ? TIOCM_CAR : 0) 1684 | ((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0) 1685 | ((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0); 1686 1687 dbg("%s - 0x%04X", __FUNCTION__, result); 1688 1689 return result; 1690 } 1691 1692 static int mos7840_tiocmset(struct usb_serial_port *port, struct file *file, 1693 unsigned int set, unsigned int clear) 1694 { 1695 struct moschip_port *mos7840_port; 1696 unsigned int mcr; 1697 unsigned int status; 1698 1699 dbg("%s - port %d", __FUNCTION__, port->number); 1700 1701 mos7840_port = mos7840_get_port_private(port); 1702 1703 if (mos7840_port == NULL) 1704 return -ENODEV; 1705 1706 mcr = mos7840_port->shadowMCR; 1707 if (clear & TIOCM_RTS) 1708 mcr &= ~MCR_RTS; 1709 if (clear & TIOCM_DTR) 1710 mcr &= ~MCR_DTR; 1711 if (clear & TIOCM_LOOP) 1712 mcr &= ~MCR_LOOPBACK; 1713 1714 if (set & TIOCM_RTS) 1715 mcr |= MCR_RTS; 1716 if (set & TIOCM_DTR) 1717 mcr |= MCR_DTR; 1718 if (set & TIOCM_LOOP) 1719 mcr |= MCR_LOOPBACK; 1720 1721 mos7840_port->shadowMCR = mcr; 1722 1723 status = 0; 1724 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr); 1725 if (status < 0) { 1726 dbg("setting MODEM_CONTROL_REGISTER Failed\n"); 1727 return -1; 1728 } 1729 1730 return 0; 1731 } 1732 1733 /***************************************************************************** 1734 * mos7840_calc_baud_rate_divisor 1735 * this function calculates the proper baud rate divisor for the specified 1736 * baud rate. 1737 *****************************************************************************/ 1738 static int mos7840_calc_baud_rate_divisor(int baudRate, int *divisor, 1739 __u16 * clk_sel_val) 1740 { 1741 1742 dbg("%s - %d", __FUNCTION__, baudRate); 1743 1744 if (baudRate <= 115200) { 1745 *divisor = 115200 / baudRate; 1746 *clk_sel_val = 0x0; 1747 } 1748 if ((baudRate > 115200) && (baudRate <= 230400)) { 1749 *divisor = 230400 / baudRate; 1750 *clk_sel_val = 0x10; 1751 } else if ((baudRate > 230400) && (baudRate <= 403200)) { 1752 *divisor = 403200 / baudRate; 1753 *clk_sel_val = 0x20; 1754 } else if ((baudRate > 403200) && (baudRate <= 460800)) { 1755 *divisor = 460800 / baudRate; 1756 *clk_sel_val = 0x30; 1757 } else if ((baudRate > 460800) && (baudRate <= 806400)) { 1758 *divisor = 806400 / baudRate; 1759 *clk_sel_val = 0x40; 1760 } else if ((baudRate > 806400) && (baudRate <= 921600)) { 1761 *divisor = 921600 / baudRate; 1762 *clk_sel_val = 0x50; 1763 } else if ((baudRate > 921600) && (baudRate <= 1572864)) { 1764 *divisor = 1572864 / baudRate; 1765 *clk_sel_val = 0x60; 1766 } else if ((baudRate > 1572864) && (baudRate <= 3145728)) { 1767 *divisor = 3145728 / baudRate; 1768 *clk_sel_val = 0x70; 1769 } 1770 return 0; 1771 1772 #ifdef NOTMCS7840 1773 1774 for (i = 0; i < ARRAY_SIZE(mos7840_divisor_table); i++) { 1775 if (mos7840_divisor_table[i].BaudRate == baudrate) { 1776 *divisor = mos7840_divisor_table[i].Divisor; 1777 return 0; 1778 } 1779 } 1780 1781 /* After trying for all the standard baud rates * 1782 * Try calculating the divisor for this baud rate */ 1783 1784 if (baudrate > 75 && baudrate < 230400) { 1785 /* get the divisor */ 1786 custom = (__u16) (230400L / baudrate); 1787 1788 /* Check for round off */ 1789 round1 = (__u16) (2304000L / baudrate); 1790 round = (__u16) (round1 - (custom * 10)); 1791 if (round > 4) { 1792 custom++; 1793 } 1794 *divisor = custom; 1795 1796 dbg(" Baud %d = %d\n", baudrate, custom); 1797 return 0; 1798 } 1799 1800 dbg("%s\n", " Baud calculation Failed..."); 1801 return -1; 1802 #endif 1803 } 1804 1805 /***************************************************************************** 1806 * mos7840_send_cmd_write_baud_rate 1807 * this function sends the proper command to change the baud rate of the 1808 * specified port. 1809 *****************************************************************************/ 1810 1811 static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port, 1812 int baudRate) 1813 { 1814 int divisor = 0; 1815 int status; 1816 __u16 Data; 1817 unsigned char number; 1818 __u16 clk_sel_val; 1819 struct usb_serial_port *port; 1820 1821 if (mos7840_port == NULL) 1822 return -1; 1823 1824 port = (struct usb_serial_port *)mos7840_port->port; 1825 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 1826 dbg("%s", "Invalid port \n"); 1827 return -1; 1828 } 1829 1830 if (mos7840_serial_paranoia_check(port->serial, __FUNCTION__)) { 1831 dbg("%s", "Invalid Serial \n"); 1832 return -1; 1833 } 1834 1835 dbg("%s", "Entering .......... \n"); 1836 1837 number = mos7840_port->port->number - mos7840_port->port->serial->minor; 1838 1839 dbg("%s - port = %d, baud = %d", __FUNCTION__, 1840 mos7840_port->port->number, baudRate); 1841 //reset clk_uart_sel in spregOffset 1842 if (baudRate > 115200) { 1843 #ifdef HW_flow_control 1844 //NOTE: need to see the pther register to modify 1845 //setting h/w flow control bit to 1; 1846 status = 0; 1847 Data = 0x2b; 1848 mos7840_port->shadowMCR = Data; 1849 status = 1850 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 1851 if (status < 0) { 1852 dbg("Writing spreg failed in set_serial_baud\n"); 1853 return -1; 1854 } 1855 #endif 1856 1857 } else { 1858 #ifdef HW_flow_control 1859 //setting h/w flow control bit to 0; 1860 status = 0; 1861 Data = 0xb; 1862 mos7840_port->shadowMCR = Data; 1863 status = 1864 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 1865 if (status < 0) { 1866 dbg("Writing spreg failed in set_serial_baud\n"); 1867 return -1; 1868 } 1869 #endif 1870 1871 } 1872 1873 if (1) //baudRate <= 115200) 1874 { 1875 clk_sel_val = 0x0; 1876 Data = 0x0; 1877 status = 0; 1878 status = 1879 mos7840_calc_baud_rate_divisor(baudRate, &divisor, 1880 &clk_sel_val); 1881 status = 1882 mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, 1883 &Data); 1884 if (status < 0) { 1885 dbg("reading spreg failed in set_serial_baud\n"); 1886 return -1; 1887 } 1888 Data = (Data & 0x8f) | clk_sel_val; 1889 status = 0; 1890 status = 1891 mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); 1892 if (status < 0) { 1893 dbg("Writing spreg failed in set_serial_baud\n"); 1894 return -1; 1895 } 1896 /* Calculate the Divisor */ 1897 1898 if (status) { 1899 err("%s - bad baud rate", __FUNCTION__); 1900 dbg("%s\n", "bad baud rate"); 1901 return status; 1902 } 1903 /* Enable access to divisor latch */ 1904 Data = mos7840_port->shadowLCR | SERIAL_LCR_DLAB; 1905 mos7840_port->shadowLCR = Data; 1906 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 1907 1908 /* Write the divisor */ 1909 Data = (unsigned char)(divisor & 0xff); 1910 dbg("set_serial_baud Value to write DLL is %x\n", Data); 1911 mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data); 1912 1913 Data = (unsigned char)((divisor & 0xff00) >> 8); 1914 dbg("set_serial_baud Value to write DLM is %x\n", Data); 1915 mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data); 1916 1917 /* Disable access to divisor latch */ 1918 Data = mos7840_port->shadowLCR & ~SERIAL_LCR_DLAB; 1919 mos7840_port->shadowLCR = Data; 1920 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 1921 1922 } 1923 1924 return status; 1925 } 1926 1927 /***************************************************************************** 1928 * mos7840_change_port_settings 1929 * This routine is called to set the UART on the device to match 1930 * the specified new settings. 1931 *****************************************************************************/ 1932 1933 static void mos7840_change_port_settings(struct moschip_port *mos7840_port, 1934 struct ktermios *old_termios) 1935 { 1936 struct tty_struct *tty; 1937 int baud; 1938 unsigned cflag; 1939 unsigned iflag; 1940 __u8 lData; 1941 __u8 lParity; 1942 __u8 lStop; 1943 int status; 1944 __u16 Data; 1945 struct usb_serial_port *port; 1946 struct usb_serial *serial; 1947 1948 if (mos7840_port == NULL) 1949 return; 1950 1951 port = (struct usb_serial_port *)mos7840_port->port; 1952 1953 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 1954 dbg("%s", "Invalid port \n"); 1955 return; 1956 } 1957 1958 if (mos7840_serial_paranoia_check(port->serial, __FUNCTION__)) { 1959 dbg("%s", "Invalid Serial \n"); 1960 return; 1961 } 1962 1963 serial = port->serial; 1964 1965 dbg("%s - port %d", __FUNCTION__, mos7840_port->port->number); 1966 1967 if (!mos7840_port->open) { 1968 dbg("%s - port not opened", __FUNCTION__); 1969 return; 1970 } 1971 1972 tty = mos7840_port->port->tty; 1973 1974 if ((!tty) || (!tty->termios)) { 1975 dbg("%s - no tty structures", __FUNCTION__); 1976 return; 1977 } 1978 1979 dbg("%s", "Entering .......... \n"); 1980 1981 lData = LCR_BITS_8; 1982 lStop = LCR_STOP_1; 1983 lParity = LCR_PAR_NONE; 1984 1985 cflag = tty->termios->c_cflag; 1986 iflag = tty->termios->c_iflag; 1987 1988 /* Change the number of bits */ 1989 if (cflag & CSIZE) { 1990 switch (cflag & CSIZE) { 1991 case CS5: 1992 lData = LCR_BITS_5; 1993 break; 1994 1995 case CS6: 1996 lData = LCR_BITS_6; 1997 break; 1998 1999 case CS7: 2000 lData = LCR_BITS_7; 2001 break; 2002 default: 2003 case CS8: 2004 lData = LCR_BITS_8; 2005 break; 2006 } 2007 } 2008 /* Change the Parity bit */ 2009 if (cflag & PARENB) { 2010 if (cflag & PARODD) { 2011 lParity = LCR_PAR_ODD; 2012 dbg("%s - parity = odd", __FUNCTION__); 2013 } else { 2014 lParity = LCR_PAR_EVEN; 2015 dbg("%s - parity = even", __FUNCTION__); 2016 } 2017 2018 } else { 2019 dbg("%s - parity = none", __FUNCTION__); 2020 } 2021 2022 if (cflag & CMSPAR) { 2023 lParity = lParity | 0x20; 2024 } 2025 2026 /* Change the Stop bit */ 2027 if (cflag & CSTOPB) { 2028 lStop = LCR_STOP_2; 2029 dbg("%s - stop bits = 2", __FUNCTION__); 2030 } else { 2031 lStop = LCR_STOP_1; 2032 dbg("%s - stop bits = 1", __FUNCTION__); 2033 } 2034 2035 /* Update the LCR with the correct value */ 2036 mos7840_port->shadowLCR &= 2037 ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK); 2038 mos7840_port->shadowLCR |= (lData | lParity | lStop); 2039 2040 dbg("mos7840_change_port_settings mos7840_port->shadowLCR is %x\n", 2041 mos7840_port->shadowLCR); 2042 /* Disable Interrupts */ 2043 Data = 0x00; 2044 mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); 2045 2046 Data = 0x00; 2047 mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); 2048 2049 Data = 0xcf; 2050 mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); 2051 2052 /* Send the updated LCR value to the mos7840 */ 2053 Data = mos7840_port->shadowLCR; 2054 2055 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 2056 2057 Data = 0x00b; 2058 mos7840_port->shadowMCR = Data; 2059 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 2060 Data = 0x00b; 2061 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 2062 2063 /* set up the MCR register and send it to the mos7840 */ 2064 2065 mos7840_port->shadowMCR = MCR_MASTER_IE; 2066 if (cflag & CBAUD) { 2067 mos7840_port->shadowMCR |= (MCR_DTR | MCR_RTS); 2068 } 2069 2070 if (cflag & CRTSCTS) { 2071 mos7840_port->shadowMCR |= (MCR_XON_ANY); 2072 2073 } else { 2074 mos7840_port->shadowMCR &= ~(MCR_XON_ANY); 2075 } 2076 2077 Data = mos7840_port->shadowMCR; 2078 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 2079 2080 /* Determine divisor based on baud rate */ 2081 baud = tty_get_baud_rate(tty); 2082 2083 if (!baud) { 2084 /* pick a default, any default... */ 2085 dbg("%s\n", "Picked default baud..."); 2086 baud = 9600; 2087 } 2088 2089 dbg("%s - baud rate = %d", __FUNCTION__, baud); 2090 status = mos7840_send_cmd_write_baud_rate(mos7840_port, baud); 2091 2092 /* Enable Interrupts */ 2093 Data = 0x0c; 2094 mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); 2095 2096 if (mos7840_port->read_urb->status != -EINPROGRESS) { 2097 mos7840_port->read_urb->dev = serial->dev; 2098 2099 status = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC); 2100 2101 if (status) { 2102 dbg(" usb_submit_urb(read bulk) failed, status = %d", 2103 status); 2104 } 2105 } 2106 wake_up(&mos7840_port->delta_msr_wait); 2107 mos7840_port->delta_msr_cond = 1; 2108 dbg("mos7840_change_port_settings mos7840_port->shadowLCR is End %x\n", 2109 mos7840_port->shadowLCR); 2110 2111 return; 2112 } 2113 2114 /***************************************************************************** 2115 * mos7840_set_termios 2116 * this function is called by the tty driver when it wants to change 2117 * the termios structure 2118 *****************************************************************************/ 2119 2120 static void mos7840_set_termios(struct usb_serial_port *port, 2121 struct ktermios *old_termios) 2122 { 2123 int status; 2124 unsigned int cflag; 2125 struct usb_serial *serial; 2126 struct moschip_port *mos7840_port; 2127 struct tty_struct *tty; 2128 dbg("mos7840_set_termios: START\n"); 2129 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 2130 dbg("%s", "Invalid port \n"); 2131 return; 2132 } 2133 2134 serial = port->serial; 2135 2136 if (mos7840_serial_paranoia_check(serial, __FUNCTION__)) { 2137 dbg("%s", "Invalid Serial \n"); 2138 return; 2139 } 2140 2141 mos7840_port = mos7840_get_port_private(port); 2142 2143 if (mos7840_port == NULL) 2144 return; 2145 2146 tty = port->tty; 2147 2148 if (!port->tty || !port->tty->termios) { 2149 dbg("%s - no tty or termios", __FUNCTION__); 2150 return; 2151 } 2152 2153 if (!mos7840_port->open) { 2154 dbg("%s - port not opened", __FUNCTION__); 2155 return; 2156 } 2157 2158 dbg("%s\n", "setting termios - "); 2159 2160 cflag = tty->termios->c_cflag; 2161 2162 if (!cflag) { 2163 dbg("%s %s\n", __FUNCTION__, "cflag is NULL"); 2164 return; 2165 } 2166 2167 /* check that they really want us to change something */ 2168 if (old_termios) { 2169 if ((cflag == old_termios->c_cflag) && 2170 (RELEVANT_IFLAG(tty->termios->c_iflag) == 2171 RELEVANT_IFLAG(old_termios->c_iflag))) { 2172 dbg("%s\n", "Nothing to change"); 2173 return; 2174 } 2175 } 2176 2177 dbg("%s - clfag %08x iflag %08x", __FUNCTION__, 2178 tty->termios->c_cflag, RELEVANT_IFLAG(tty->termios->c_iflag)); 2179 2180 if (old_termios) { 2181 dbg("%s - old clfag %08x old iflag %08x", __FUNCTION__, 2182 old_termios->c_cflag, RELEVANT_IFLAG(old_termios->c_iflag)); 2183 } 2184 2185 dbg("%s - port %d", __FUNCTION__, port->number); 2186 2187 /* change the port settings to the new ones specified */ 2188 2189 mos7840_change_port_settings(mos7840_port, old_termios); 2190 2191 if (!mos7840_port->read_urb) { 2192 dbg("%s", "URB KILLED !!!!!\n"); 2193 return; 2194 } 2195 2196 if (mos7840_port->read_urb->status != -EINPROGRESS) { 2197 mos7840_port->read_urb->dev = serial->dev; 2198 status = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC); 2199 if (status) { 2200 dbg(" usb_submit_urb(read bulk) failed, status = %d", 2201 status); 2202 } 2203 } 2204 return; 2205 } 2206 2207 /***************************************************************************** 2208 * mos7840_get_lsr_info - get line status register info 2209 * 2210 * Purpose: Let user call ioctl() to get info when the UART physically 2211 * is emptied. On bus types like RS485, the transmitter must 2212 * release the bus after transmitting. This must be done when 2213 * the transmit shift register is empty, not be done when the 2214 * transmit holding register is empty. This functionality 2215 * allows an RS485 driver to be written in user space. 2216 *****************************************************************************/ 2217 2218 static int mos7840_get_lsr_info(struct moschip_port *mos7840_port, 2219 unsigned int __user *value) 2220 { 2221 int count; 2222 unsigned int result = 0; 2223 2224 count = mos7840_chars_in_buffer(mos7840_port->port); 2225 if (count == 0) { 2226 dbg("%s -- Empty", __FUNCTION__); 2227 result = TIOCSER_TEMT; 2228 } 2229 2230 if (copy_to_user(value, &result, sizeof(int))) 2231 return -EFAULT; 2232 return 0; 2233 } 2234 2235 /***************************************************************************** 2236 * mos7840_get_bytes_avail - get number of bytes available 2237 * 2238 * Purpose: Let user call ioctl to get the count of number of bytes available. 2239 *****************************************************************************/ 2240 2241 static int mos7840_get_bytes_avail(struct moschip_port *mos7840_port, 2242 unsigned int __user *value) 2243 { 2244 unsigned int result = 0; 2245 struct tty_struct *tty = mos7840_port->port->tty; 2246 2247 if (!tty) 2248 return -ENOIOCTLCMD; 2249 2250 result = tty->read_cnt; 2251 2252 dbg("%s(%d) = %d", __FUNCTION__, mos7840_port->port->number, result); 2253 if (copy_to_user(value, &result, sizeof(int))) 2254 return -EFAULT; 2255 2256 return -ENOIOCTLCMD; 2257 } 2258 2259 /***************************************************************************** 2260 * mos7840_set_modem_info 2261 * function to set modem info 2262 *****************************************************************************/ 2263 2264 static int mos7840_set_modem_info(struct moschip_port *mos7840_port, 2265 unsigned int cmd, unsigned int __user *value) 2266 { 2267 unsigned int mcr; 2268 unsigned int arg; 2269 __u16 Data; 2270 int status; 2271 struct usb_serial_port *port; 2272 2273 if (mos7840_port == NULL) 2274 return -1; 2275 2276 port = (struct usb_serial_port *)mos7840_port->port; 2277 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 2278 dbg("%s", "Invalid port \n"); 2279 return -1; 2280 } 2281 2282 mcr = mos7840_port->shadowMCR; 2283 2284 if (copy_from_user(&arg, value, sizeof(int))) 2285 return -EFAULT; 2286 2287 switch (cmd) { 2288 case TIOCMBIS: 2289 if (arg & TIOCM_RTS) 2290 mcr |= MCR_RTS; 2291 if (arg & TIOCM_DTR) 2292 mcr |= MCR_RTS; 2293 if (arg & TIOCM_LOOP) 2294 mcr |= MCR_LOOPBACK; 2295 break; 2296 2297 case TIOCMBIC: 2298 if (arg & TIOCM_RTS) 2299 mcr &= ~MCR_RTS; 2300 if (arg & TIOCM_DTR) 2301 mcr &= ~MCR_RTS; 2302 if (arg & TIOCM_LOOP) 2303 mcr &= ~MCR_LOOPBACK; 2304 break; 2305 2306 case TIOCMSET: 2307 /* turn off the RTS and DTR and LOOPBACK 2308 * and then only turn on what was asked to */ 2309 mcr &= ~(MCR_RTS | MCR_DTR | MCR_LOOPBACK); 2310 mcr |= ((arg & TIOCM_RTS) ? MCR_RTS : 0); 2311 mcr |= ((arg & TIOCM_DTR) ? MCR_DTR : 0); 2312 mcr |= ((arg & TIOCM_LOOP) ? MCR_LOOPBACK : 0); 2313 break; 2314 } 2315 2316 mos7840_port->shadowMCR = mcr; 2317 2318 Data = mos7840_port->shadowMCR; 2319 status = 0; 2320 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 2321 if (status < 0) { 2322 dbg("setting MODEM_CONTROL_REGISTER Failed\n"); 2323 return -1; 2324 } 2325 2326 return 0; 2327 } 2328 2329 /***************************************************************************** 2330 * mos7840_get_modem_info 2331 * function to get modem info 2332 *****************************************************************************/ 2333 2334 static int mos7840_get_modem_info(struct moschip_port *mos7840_port, 2335 unsigned int __user *value) 2336 { 2337 unsigned int result = 0; 2338 __u16 msr; 2339 unsigned int mcr = mos7840_port->shadowMCR; 2340 int status = 0; 2341 status = 2342 mos7840_get_uart_reg(mos7840_port->port, MODEM_STATUS_REGISTER, 2343 &msr); 2344 result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0) /* 0x002 */ 2345 |((mcr & MCR_RTS) ? TIOCM_RTS : 0) /* 0x004 */ 2346 |((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0) /* 0x020 */ 2347 |((msr & MOS7840_MSR_CD) ? TIOCM_CAR : 0) /* 0x040 */ 2348 |((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0) /* 0x080 */ 2349 |((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0); /* 0x100 */ 2350 2351 dbg("%s -- %x", __FUNCTION__, result); 2352 2353 if (copy_to_user(value, &result, sizeof(int))) 2354 return -EFAULT; 2355 return 0; 2356 } 2357 2358 /***************************************************************************** 2359 * mos7840_get_serial_info 2360 * function to get information about serial port 2361 *****************************************************************************/ 2362 2363 static int mos7840_get_serial_info(struct moschip_port *mos7840_port, 2364 struct serial_struct __user *retinfo) 2365 { 2366 struct serial_struct tmp; 2367 2368 if (mos7840_port == NULL) 2369 return -1; 2370 2371 if (!retinfo) 2372 return -EFAULT; 2373 2374 memset(&tmp, 0, sizeof(tmp)); 2375 2376 tmp.type = PORT_16550A; 2377 tmp.line = mos7840_port->port->serial->minor; 2378 tmp.port = mos7840_port->port->number; 2379 tmp.irq = 0; 2380 tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ; 2381 tmp.xmit_fifo_size = NUM_URBS * URB_TRANSFER_BUFFER_SIZE; 2382 tmp.baud_base = 9600; 2383 tmp.close_delay = 5 * HZ; 2384 tmp.closing_wait = 30 * HZ; 2385 2386 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) 2387 return -EFAULT; 2388 return 0; 2389 } 2390 2391 /***************************************************************************** 2392 * SerialIoctl 2393 * this function handles any ioctl calls to the driver 2394 *****************************************************************************/ 2395 2396 static int mos7840_ioctl(struct usb_serial_port *port, struct file *file, 2397 unsigned int cmd, unsigned long arg) 2398 { 2399 void __user *argp = (void __user *)arg; 2400 struct moschip_port *mos7840_port; 2401 struct tty_struct *tty; 2402 2403 struct async_icount cnow; 2404 struct async_icount cprev; 2405 struct serial_icounter_struct icount; 2406 int mosret = 0; 2407 int retval; 2408 struct tty_ldisc *ld; 2409 2410 if (mos7840_port_paranoia_check(port, __FUNCTION__)) { 2411 dbg("%s", "Invalid port \n"); 2412 return -1; 2413 } 2414 2415 mos7840_port = mos7840_get_port_private(port); 2416 2417 if (mos7840_port == NULL) 2418 return -1; 2419 2420 tty = mos7840_port->port->tty; 2421 2422 dbg("%s - port %d, cmd = 0x%x", __FUNCTION__, port->number, cmd); 2423 2424 switch (cmd) { 2425 /* return number of bytes available */ 2426 2427 case TIOCINQ: 2428 dbg("%s (%d) TIOCINQ", __FUNCTION__, port->number); 2429 return mos7840_get_bytes_avail(mos7840_port, argp); 2430 2431 case TIOCOUTQ: 2432 dbg("%s (%d) TIOCOUTQ", __FUNCTION__, port->number); 2433 return put_user(tty->driver->chars_in_buffer ? 2434 tty->driver->chars_in_buffer(tty) : 0, 2435 (int __user *)arg); 2436 2437 case TCFLSH: 2438 retval = tty_check_change(tty); 2439 if (retval) 2440 return retval; 2441 2442 ld = tty_ldisc_ref(tty); 2443 switch (arg) { 2444 case TCIFLUSH: 2445 if (ld && ld->flush_buffer) 2446 ld->flush_buffer(tty); 2447 break; 2448 case TCIOFLUSH: 2449 if (ld && ld->flush_buffer) 2450 ld->flush_buffer(tty); 2451 /* fall through */ 2452 case TCOFLUSH: 2453 if (tty->driver->flush_buffer) 2454 tty->driver->flush_buffer(tty); 2455 break; 2456 default: 2457 tty_ldisc_deref(ld); 2458 return -EINVAL; 2459 } 2460 tty_ldisc_deref(ld); 2461 return 0; 2462 2463 case TIOCSERGETLSR: 2464 dbg("%s (%d) TIOCSERGETLSR", __FUNCTION__, port->number); 2465 return mos7840_get_lsr_info(mos7840_port, argp); 2466 return 0; 2467 2468 case TIOCMBIS: 2469 case TIOCMBIC: 2470 case TIOCMSET: 2471 dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET", __FUNCTION__, 2472 port->number); 2473 mosret = 2474 mos7840_set_modem_info(mos7840_port, cmd, argp); 2475 return mosret; 2476 2477 case TIOCMGET: 2478 dbg("%s (%d) TIOCMGET", __FUNCTION__, port->number); 2479 return mos7840_get_modem_info(mos7840_port, argp); 2480 2481 case TIOCGSERIAL: 2482 dbg("%s (%d) TIOCGSERIAL", __FUNCTION__, port->number); 2483 return mos7840_get_serial_info(mos7840_port, argp); 2484 2485 case TIOCSSERIAL: 2486 dbg("%s (%d) TIOCSSERIAL", __FUNCTION__, port->number); 2487 break; 2488 2489 case TIOCMIWAIT: 2490 dbg("%s (%d) TIOCMIWAIT", __FUNCTION__, port->number); 2491 cprev = mos7840_port->icount; 2492 while (1) { 2493 //interruptible_sleep_on(&mos7840_port->delta_msr_wait); 2494 mos7840_port->delta_msr_cond = 0; 2495 wait_event_interruptible(mos7840_port->delta_msr_wait, 2496 (mos7840_port-> 2497 delta_msr_cond == 1)); 2498 2499 /* see if a signal did it */ 2500 if (signal_pending(current)) 2501 return -ERESTARTSYS; 2502 cnow = mos7840_port->icount; 2503 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && 2504 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) 2505 return -EIO; /* no change => error */ 2506 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || 2507 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || 2508 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) || 2509 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) { 2510 return 0; 2511 } 2512 cprev = cnow; 2513 } 2514 /* NOTREACHED */ 2515 break; 2516 2517 case TIOCGICOUNT: 2518 cnow = mos7840_port->icount; 2519 icount.cts = cnow.cts; 2520 icount.dsr = cnow.dsr; 2521 icount.rng = cnow.rng; 2522 icount.dcd = cnow.dcd; 2523 icount.rx = cnow.rx; 2524 icount.tx = cnow.tx; 2525 icount.frame = cnow.frame; 2526 icount.overrun = cnow.overrun; 2527 icount.parity = cnow.parity; 2528 icount.brk = cnow.brk; 2529 icount.buf_overrun = cnow.buf_overrun; 2530 2531 dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __FUNCTION__, 2532 port->number, icount.rx, icount.tx); 2533 if (copy_to_user(argp, &icount, sizeof(icount))) 2534 return -EFAULT; 2535 return 0; 2536 2537 case TIOCEXBAUD: 2538 return 0; 2539 default: 2540 break; 2541 } 2542 2543 return -ENOIOCTLCMD; 2544 } 2545 2546 static int mos7840_calc_num_ports(struct usb_serial *serial) 2547 { 2548 2549 dbg("numberofendpoints: %d \n", 2550 (int)serial->interface->cur_altsetting->desc.bNumEndpoints); 2551 dbg("numberofendpoints: %d \n", 2552 (int)serial->interface->altsetting->desc.bNumEndpoints); 2553 if (serial->interface->cur_altsetting->desc.bNumEndpoints == 5) { 2554 mos7840_num_ports = 2; 2555 serial->type->num_ports = 2; 2556 } else if (serial->interface->cur_altsetting->desc.bNumEndpoints == 9) { 2557 mos7840_num_ports = 4; 2558 serial->type->num_bulk_in = 4; 2559 serial->type->num_bulk_out = 4; 2560 serial->type->num_ports = 4; 2561 } 2562 2563 return mos7840_num_ports; 2564 } 2565 2566 /**************************************************************************** 2567 * mos7840_startup 2568 ****************************************************************************/ 2569 2570 static int mos7840_startup(struct usb_serial *serial) 2571 { 2572 struct moschip_port *mos7840_port; 2573 struct usb_device *dev; 2574 int i, status; 2575 2576 __u16 Data; 2577 dbg("%s \n", " mos7840_startup :entering.........."); 2578 2579 if (!serial) { 2580 dbg("%s\n", "Invalid Handler"); 2581 return -1; 2582 } 2583 2584 dev = serial->dev; 2585 2586 dbg("%s\n", "Entering..."); 2587 2588 /* we set up the pointers to the endpoints in the mos7840_open * 2589 * function, as the structures aren't created yet. */ 2590 2591 /* set up port private structures */ 2592 for (i = 0; i < serial->num_ports; ++i) { 2593 mos7840_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL); 2594 if (mos7840_port == NULL) { 2595 err("%s - Out of memory", __FUNCTION__); 2596 return -ENOMEM; 2597 } 2598 2599 /* Initialize all port interrupt end point to port 0 int endpoint * 2600 * Our device has only one interrupt end point comman to all port */ 2601 2602 mos7840_port->port = serial->port[i]; 2603 mos7840_set_port_private(serial->port[i], mos7840_port); 2604 2605 mos7840_port->port_num = ((serial->port[i]->number - 2606 (serial->port[i]->serial->minor)) + 2607 1); 2608 2609 if (mos7840_port->port_num == 1) { 2610 mos7840_port->SpRegOffset = 0x0; 2611 mos7840_port->ControlRegOffset = 0x1; 2612 mos7840_port->DcrRegOffset = 0x4; 2613 } else if ((mos7840_port->port_num == 2) 2614 && (mos7840_num_ports == 4)) { 2615 mos7840_port->SpRegOffset = 0x8; 2616 mos7840_port->ControlRegOffset = 0x9; 2617 mos7840_port->DcrRegOffset = 0x16; 2618 } else if ((mos7840_port->port_num == 2) 2619 && (mos7840_num_ports == 2)) { 2620 mos7840_port->SpRegOffset = 0xa; 2621 mos7840_port->ControlRegOffset = 0xb; 2622 mos7840_port->DcrRegOffset = 0x19; 2623 } else if ((mos7840_port->port_num == 3) 2624 && (mos7840_num_ports == 4)) { 2625 mos7840_port->SpRegOffset = 0xa; 2626 mos7840_port->ControlRegOffset = 0xb; 2627 mos7840_port->DcrRegOffset = 0x19; 2628 } else if ((mos7840_port->port_num == 4) 2629 && (mos7840_num_ports == 4)) { 2630 mos7840_port->SpRegOffset = 0xc; 2631 mos7840_port->ControlRegOffset = 0xd; 2632 mos7840_port->DcrRegOffset = 0x1c; 2633 } 2634 mos7840_dump_serial_port(mos7840_port); 2635 2636 mos7840_set_port_private(serial->port[i], mos7840_port); 2637 2638 //enable rx_disable bit in control register 2639 2640 status = 2641 mos7840_get_reg_sync(serial->port[i], 2642 mos7840_port->ControlRegOffset, &Data); 2643 if (status < 0) { 2644 dbg("Reading ControlReg failed status-0x%x\n", status); 2645 break; 2646 } else 2647 dbg("ControlReg Reading success val is %x, status%d\n", 2648 Data, status); 2649 Data |= 0x08; //setting driver done bit 2650 Data |= 0x04; //sp1_bit to have cts change reflect in modem status reg 2651 2652 //Data |= 0x20; //rx_disable bit 2653 status = 0; 2654 status = 2655 mos7840_set_reg_sync(serial->port[i], 2656 mos7840_port->ControlRegOffset, Data); 2657 if (status < 0) { 2658 dbg("Writing ControlReg failed(rx_disable) status-0x%x\n", status); 2659 break; 2660 } else 2661 dbg("ControlReg Writing success(rx_disable) status%d\n", 2662 status); 2663 2664 //Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2 and 0x24 in DCR3 2665 Data = 0x01; 2666 status = 0; 2667 status = 2668 mos7840_set_reg_sync(serial->port[i], 2669 (__u16) (mos7840_port->DcrRegOffset + 2670 0), Data); 2671 if (status < 0) { 2672 dbg("Writing DCR0 failed status-0x%x\n", status); 2673 break; 2674 } else 2675 dbg("DCR0 Writing success status%d\n", status); 2676 2677 Data = 0x05; 2678 status = 0; 2679 status = 2680 mos7840_set_reg_sync(serial->port[i], 2681 (__u16) (mos7840_port->DcrRegOffset + 2682 1), Data); 2683 if (status < 0) { 2684 dbg("Writing DCR1 failed status-0x%x\n", status); 2685 break; 2686 } else 2687 dbg("DCR1 Writing success status%d\n", status); 2688 2689 Data = 0x24; 2690 status = 0; 2691 status = 2692 mos7840_set_reg_sync(serial->port[i], 2693 (__u16) (mos7840_port->DcrRegOffset + 2694 2), Data); 2695 if (status < 0) { 2696 dbg("Writing DCR2 failed status-0x%x\n", status); 2697 break; 2698 } else 2699 dbg("DCR2 Writing success status%d\n", status); 2700 2701 // write values in clkstart0x0 and clkmulti 0x20 2702 Data = 0x0; 2703 status = 0; 2704 status = 2705 mos7840_set_reg_sync(serial->port[i], 2706 CLK_START_VALUE_REGISTER, Data); 2707 if (status < 0) { 2708 dbg("Writing CLK_START_VALUE_REGISTER failed status-0x%x\n", status); 2709 break; 2710 } else 2711 dbg("CLK_START_VALUE_REGISTER Writing success status%d\n", status); 2712 2713 Data = 0x20; 2714 status = 0; 2715 status = 2716 mos7840_set_reg_sync(serial->port[i], CLK_MULTI_REGISTER, 2717 Data); 2718 if (status < 0) { 2719 dbg("Writing CLK_MULTI_REGISTER failed status-0x%x\n", 2720 status); 2721 break; 2722 } else 2723 dbg("CLK_MULTI_REGISTER Writing success status%d\n", 2724 status); 2725 2726 //write value 0x0 to scratchpad register 2727 Data = 0x00; 2728 status = 0; 2729 status = 2730 mos7840_set_uart_reg(serial->port[i], SCRATCH_PAD_REGISTER, 2731 Data); 2732 if (status < 0) { 2733 dbg("Writing SCRATCH_PAD_REGISTER failed status-0x%x\n", 2734 status); 2735 break; 2736 } else 2737 dbg("SCRATCH_PAD_REGISTER Writing success status%d\n", 2738 status); 2739 2740 //Zero Length flag register 2741 if ((mos7840_port->port_num != 1) 2742 && (mos7840_num_ports == 2)) { 2743 2744 Data = 0xff; 2745 status = 0; 2746 status = mos7840_set_reg_sync(serial->port[i], 2747 (__u16) (ZLP_REG1 + 2748 ((__u16) 2749 mos7840_port-> 2750 port_num)), 2751 Data); 2752 dbg("ZLIP offset%x\n", 2753 (__u16) (ZLP_REG1 + 2754 ((__u16) mos7840_port->port_num))); 2755 if (status < 0) { 2756 dbg("Writing ZLP_REG%d failed status-0x%x\n", 2757 i + 2, status); 2758 break; 2759 } else 2760 dbg("ZLP_REG%d Writing success status%d\n", 2761 i + 2, status); 2762 } else { 2763 Data = 0xff; 2764 status = 0; 2765 status = mos7840_set_reg_sync(serial->port[i], 2766 (__u16) (ZLP_REG1 + 2767 ((__u16) 2768 mos7840_port-> 2769 port_num) - 2770 0x1), Data); 2771 dbg("ZLIP offset%x\n", 2772 (__u16) (ZLP_REG1 + 2773 ((__u16) mos7840_port->port_num) - 0x1)); 2774 if (status < 0) { 2775 dbg("Writing ZLP_REG%d failed status-0x%x\n", 2776 i + 1, status); 2777 break; 2778 } else 2779 dbg("ZLP_REG%d Writing success status%d\n", 2780 i + 1, status); 2781 2782 } 2783 mos7840_port->control_urb = usb_alloc_urb(0, GFP_ATOMIC); 2784 mos7840_port->ctrl_buf = kmalloc(16, GFP_KERNEL); 2785 2786 } 2787 2788 //Zero Length flag enable 2789 Data = 0x0f; 2790 status = 0; 2791 status = mos7840_set_reg_sync(serial->port[0], ZLP_REG5, Data); 2792 if (status < 0) { 2793 dbg("Writing ZLP_REG5 failed status-0x%x\n", status); 2794 return -1; 2795 } else 2796 dbg("ZLP_REG5 Writing success status%d\n", status); 2797 2798 /* setting configuration feature to one */ 2799 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 2800 (__u8) 0x03, 0x00, 0x01, 0x00, NULL, 0x00, 5 * HZ); 2801 return 0; 2802 } 2803 2804 /**************************************************************************** 2805 * mos7840_shutdown 2806 * This function is called whenever the device is removed from the usb bus. 2807 ****************************************************************************/ 2808 2809 static void mos7840_shutdown(struct usb_serial *serial) 2810 { 2811 int i; 2812 struct moschip_port *mos7840_port; 2813 dbg("%s \n", " shutdown :entering.........."); 2814 2815 if (!serial) { 2816 dbg("%s", "Invalid Handler \n"); 2817 return; 2818 } 2819 2820 /* check for the ports to be closed,close the ports and disconnect */ 2821 2822 /* free private structure allocated for serial port * 2823 * stop reads and writes on all ports */ 2824 2825 for (i = 0; i < serial->num_ports; ++i) { 2826 mos7840_port = mos7840_get_port_private(serial->port[i]); 2827 kfree(mos7840_port->ctrl_buf); 2828 usb_kill_urb(mos7840_port->control_urb); 2829 kfree(mos7840_port); 2830 mos7840_set_port_private(serial->port[i], NULL); 2831 } 2832 2833 dbg("%s\n", "Thank u :: "); 2834 2835 } 2836 2837 static struct usb_driver io_driver = { 2838 .name = "mos7840", 2839 .probe = usb_serial_probe, 2840 .disconnect = usb_serial_disconnect, 2841 .id_table = moschip_id_table_combined, 2842 .no_dynamic_id = 1, 2843 }; 2844 2845 static struct usb_serial_driver moschip7840_4port_device = { 2846 .driver = { 2847 .owner = THIS_MODULE, 2848 .name = "mos7840", 2849 }, 2850 .description = DRIVER_DESC, 2851 .usb_driver = &io_driver, 2852 .id_table = moschip_port_id_table, 2853 .num_interrupt_in = 1, //NUM_DONT_CARE,//1, 2854 #ifdef check 2855 .num_bulk_in = 4, 2856 .num_bulk_out = 4, 2857 .num_ports = 4, 2858 #endif 2859 .open = mos7840_open, 2860 .close = mos7840_close, 2861 .write = mos7840_write, 2862 .write_room = mos7840_write_room, 2863 .chars_in_buffer = mos7840_chars_in_buffer, 2864 .throttle = mos7840_throttle, 2865 .unthrottle = mos7840_unthrottle, 2866 .calc_num_ports = mos7840_calc_num_ports, 2867 #ifdef MCSSerialProbe 2868 .probe = mos7840_serial_probe, 2869 #endif 2870 .ioctl = mos7840_ioctl, 2871 .set_termios = mos7840_set_termios, 2872 .break_ctl = mos7840_break, 2873 .tiocmget = mos7840_tiocmget, 2874 .tiocmset = mos7840_tiocmset, 2875 .attach = mos7840_startup, 2876 .shutdown = mos7840_shutdown, 2877 .read_bulk_callback = mos7840_bulk_in_callback, 2878 .read_int_callback = mos7840_interrupt_callback, 2879 }; 2880 2881 /**************************************************************************** 2882 * moschip7840_init 2883 * This is called by the module subsystem, or on startup to initialize us 2884 ****************************************************************************/ 2885 static int __init moschip7840_init(void) 2886 { 2887 int retval; 2888 2889 dbg("%s \n", " mos7840_init :entering.........."); 2890 2891 /* Register with the usb serial */ 2892 retval = usb_serial_register(&moschip7840_4port_device); 2893 2894 if (retval) 2895 goto failed_port_device_register; 2896 2897 dbg("%s\n", "Entring..."); 2898 info(DRIVER_DESC " " DRIVER_VERSION); 2899 2900 /* Register with the usb */ 2901 retval = usb_register(&io_driver); 2902 2903 if (retval) 2904 goto failed_usb_register; 2905 2906 if (retval == 0) { 2907 dbg("%s\n", "Leaving..."); 2908 return 0; 2909 } 2910 2911 failed_usb_register: 2912 usb_serial_deregister(&moschip7840_4port_device); 2913 2914 failed_port_device_register: 2915 2916 return retval; 2917 } 2918 2919 /**************************************************************************** 2920 * moschip7840_exit 2921 * Called when the driver is about to be unloaded. 2922 ****************************************************************************/ 2923 static void __exit moschip7840_exit(void) 2924 { 2925 2926 dbg("%s \n", " mos7840_exit :entering.........."); 2927 2928 usb_deregister(&io_driver); 2929 2930 usb_serial_deregister(&moschip7840_4port_device); 2931 2932 dbg("%s\n", "Entring..."); 2933 } 2934 2935 module_init(moschip7840_init); 2936 module_exit(moschip7840_exit); 2937 2938 /* Module information */ 2939 MODULE_DESCRIPTION(DRIVER_DESC); 2940 MODULE_LICENSE("GPL"); 2941 2942 module_param(debug, bool, S_IRUGO | S_IWUSR); 2943 MODULE_PARM_DESC(debug, "Debug enabled or not"); 2944