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