1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Clean ups from Moschip version and a few ioctl implementations by: 4 * Paul B Schroeder <pschroeder "at" uplogix "dot" com> 5 * 6 * Originally based on drivers/usb/serial/io_edgeport.c which is: 7 * Copyright (C) 2000 Inside Out Networks, All rights reserved. 8 * Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com> 9 * 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/errno.h> 14 #include <linux/slab.h> 15 #include <linux/tty.h> 16 #include <linux/tty_driver.h> 17 #include <linux/tty_flip.h> 18 #include <linux/module.h> 19 #include <linux/serial.h> 20 #include <linux/usb.h> 21 #include <linux/usb/serial.h> 22 #include <linux/uaccess.h> 23 24 #define DRIVER_DESC "Moschip 7840/7820 USB Serial Driver" 25 26 /* 27 * 16C50 UART register defines 28 */ 29 30 #define LCR_BITS_5 0x00 /* 5 bits/char */ 31 #define LCR_BITS_6 0x01 /* 6 bits/char */ 32 #define LCR_BITS_7 0x02 /* 7 bits/char */ 33 #define LCR_BITS_8 0x03 /* 8 bits/char */ 34 #define LCR_BITS_MASK 0x03 /* Mask for bits/char field */ 35 36 #define LCR_STOP_1 0x00 /* 1 stop bit */ 37 #define LCR_STOP_1_5 0x04 /* 1.5 stop bits (if 5 bits/char) */ 38 #define LCR_STOP_2 0x04 /* 2 stop bits (if 6-8 bits/char) */ 39 #define LCR_STOP_MASK 0x04 /* Mask for stop bits field */ 40 41 #define LCR_PAR_NONE 0x00 /* No parity */ 42 #define LCR_PAR_ODD 0x08 /* Odd parity */ 43 #define LCR_PAR_EVEN 0x18 /* Even parity */ 44 #define LCR_PAR_MARK 0x28 /* Force parity bit to 1 */ 45 #define LCR_PAR_SPACE 0x38 /* Force parity bit to 0 */ 46 #define LCR_PAR_MASK 0x38 /* Mask for parity field */ 47 48 #define LCR_SET_BREAK 0x40 /* Set Break condition */ 49 #define LCR_DL_ENABLE 0x80 /* Enable access to divisor latch */ 50 51 #define MCR_DTR 0x01 /* Assert DTR */ 52 #define MCR_RTS 0x02 /* Assert RTS */ 53 #define MCR_OUT1 0x04 /* Loopback only: Sets state of RI */ 54 #define MCR_MASTER_IE 0x08 /* Enable interrupt outputs */ 55 #define MCR_LOOPBACK 0x10 /* Set internal (digital) loopback mode */ 56 #define MCR_XON_ANY 0x20 /* Enable any char to exit XOFF mode */ 57 58 #define MOS7840_MSR_CTS 0x10 /* Current state of CTS */ 59 #define MOS7840_MSR_DSR 0x20 /* Current state of DSR */ 60 #define MOS7840_MSR_RI 0x40 /* Current state of RI */ 61 #define MOS7840_MSR_CD 0x80 /* Current state of CD */ 62 63 /* 64 * Defines used for sending commands to port 65 */ 66 67 #define MOS_WDR_TIMEOUT 5000 /* default urb timeout */ 68 69 #define MOS_PORT1 0x0200 70 #define MOS_PORT2 0x0300 71 #define MOS_VENREG 0x0000 72 #define MOS_MAX_PORT 0x02 73 #define MOS_WRITE 0x0E 74 #define MOS_READ 0x0D 75 76 /* Requests */ 77 #define MCS_RD_RTYPE 0xC0 78 #define MCS_WR_RTYPE 0x40 79 #define MCS_RDREQ 0x0D 80 #define MCS_WRREQ 0x0E 81 #define MCS_CTRL_TIMEOUT 500 82 #define VENDOR_READ_LENGTH (0x01) 83 84 #define MAX_NAME_LEN 64 85 86 #define ZLP_REG1 0x3A /* Zero_Flag_Reg1 58 */ 87 #define ZLP_REG5 0x3E /* Zero_Flag_Reg5 62 */ 88 89 /* For higher baud Rates use TIOCEXBAUD */ 90 #define TIOCEXBAUD 0x5462 91 92 /* 93 * Vendor id and device id defines 94 * 95 * NOTE: Do not add new defines, add entries directly to the id_table instead. 96 */ 97 #define USB_VENDOR_ID_BANDB 0x0856 98 #define BANDB_DEVICE_ID_USO9ML2_2 0xAC22 99 #define BANDB_DEVICE_ID_USO9ML2_2P 0xBC00 100 #define BANDB_DEVICE_ID_USO9ML2_4 0xAC24 101 #define BANDB_DEVICE_ID_USO9ML2_4P 0xBC01 102 #define BANDB_DEVICE_ID_US9ML2_2 0xAC29 103 #define BANDB_DEVICE_ID_US9ML2_4 0xAC30 104 #define BANDB_DEVICE_ID_USPTL4_2 0xAC31 105 #define BANDB_DEVICE_ID_USPTL4_4 0xAC32 106 #define BANDB_DEVICE_ID_USOPTL4_2 0xAC42 107 #define BANDB_DEVICE_ID_USOPTL4_2P 0xBC02 108 #define BANDB_DEVICE_ID_USOPTL4_4 0xAC44 109 #define BANDB_DEVICE_ID_USOPTL4_4P 0xBC03 110 111 /* Interrupt Routine Defines */ 112 113 #define SERIAL_IIR_RLS 0x06 114 #define SERIAL_IIR_MS 0x00 115 116 /* 117 * Emulation of the bit mask on the LINE STATUS REGISTER. 118 */ 119 #define SERIAL_LSR_DR 0x0001 120 #define SERIAL_LSR_OE 0x0002 121 #define SERIAL_LSR_PE 0x0004 122 #define SERIAL_LSR_FE 0x0008 123 #define SERIAL_LSR_BI 0x0010 124 125 #define MOS_MSR_DELTA_CTS 0x10 126 #define MOS_MSR_DELTA_DSR 0x20 127 #define MOS_MSR_DELTA_RI 0x40 128 #define MOS_MSR_DELTA_CD 0x80 129 130 /* Serial Port register Address */ 131 #define INTERRUPT_ENABLE_REGISTER ((__u16)(0x01)) 132 #define FIFO_CONTROL_REGISTER ((__u16)(0x02)) 133 #define LINE_CONTROL_REGISTER ((__u16)(0x03)) 134 #define MODEM_CONTROL_REGISTER ((__u16)(0x04)) 135 #define LINE_STATUS_REGISTER ((__u16)(0x05)) 136 #define MODEM_STATUS_REGISTER ((__u16)(0x06)) 137 #define SCRATCH_PAD_REGISTER ((__u16)(0x07)) 138 #define DIVISOR_LATCH_LSB ((__u16)(0x00)) 139 #define DIVISOR_LATCH_MSB ((__u16)(0x01)) 140 141 #define CLK_MULTI_REGISTER ((__u16)(0x02)) 142 #define CLK_START_VALUE_REGISTER ((__u16)(0x03)) 143 #define GPIO_REGISTER ((__u16)(0x07)) 144 145 #define SERIAL_LCR_DLAB ((__u16)(0x0080)) 146 147 /* 148 * URB POOL related defines 149 */ 150 #define NUM_URBS 16 /* URB Count */ 151 #define URB_TRANSFER_BUFFER_SIZE 32 /* URB Size */ 152 153 /* LED on/off milliseconds*/ 154 #define LED_ON_MS 500 155 #define LED_OFF_MS 500 156 157 enum mos7840_flag { 158 MOS7840_FLAG_LED_BUSY, 159 }; 160 161 #define MCS_PORT_MASK GENMASK(2, 0) 162 #define MCS_PORTS(nr) ((nr) & MCS_PORT_MASK) 163 #define MCS_LED BIT(3) 164 165 #define MCS_DEVICE(vid, pid, flags) \ 166 USB_DEVICE((vid), (pid)), .driver_info = (flags) 167 168 static const struct usb_device_id id_table[] = { 169 { MCS_DEVICE(0x0557, 0x2011, MCS_PORTS(4)) }, /* ATEN UC2324 */ 170 { MCS_DEVICE(0x0557, 0x7820, MCS_PORTS(2)) }, /* ATEN UC2322 */ 171 { MCS_DEVICE(0x110a, 0x2210, MCS_PORTS(2)) }, /* Moxa UPort 2210 */ 172 { MCS_DEVICE(0x9710, 0x7810, MCS_PORTS(1) | MCS_LED) }, /* ASIX MCS7810 */ 173 { MCS_DEVICE(0x9710, 0x7820, MCS_PORTS(2)) }, /* MosChip MCS7820 */ 174 { MCS_DEVICE(0x9710, 0x7840, MCS_PORTS(4)) }, /* MosChip MCS7840 */ 175 { MCS_DEVICE(0x9710, 0x7843, MCS_PORTS(3)) }, /* ASIX MCS7840 3 port */ 176 { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2) }, 177 { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2P) }, 178 { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4) }, 179 { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4P) }, 180 { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_2) }, 181 { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_4) }, 182 { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_2) }, 183 { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_4) }, 184 { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2) }, 185 { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2P) }, 186 { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4) }, 187 { USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4P) }, 188 {} /* terminating entry */ 189 }; 190 MODULE_DEVICE_TABLE(usb, id_table); 191 192 /* This structure holds all of the local port information */ 193 194 struct moschip_port { 195 int port_num; /*Actual port number in the device(1,2,etc) */ 196 struct urb *read_urb; /* read URB for this port */ 197 __u8 shadowLCR; /* last LCR value received */ 198 __u8 shadowMCR; /* last MCR value received */ 199 struct usb_serial_port *port; /* loop back to the owner of this object */ 200 201 /* Offsets */ 202 __u8 SpRegOffset; 203 __u8 ControlRegOffset; 204 __u8 DcrRegOffset; 205 206 spinlock_t pool_lock; 207 struct urb *write_urb_pool[NUM_URBS]; 208 char busy[NUM_URBS]; 209 bool read_urb_busy; 210 211 /* For device(s) with LED indicator */ 212 bool has_led; 213 struct timer_list led_timer1; /* Timer for LED on */ 214 struct timer_list led_timer2; /* Timer for LED off */ 215 struct urb *led_urb; 216 struct usb_ctrlrequest *led_dr; 217 218 unsigned long flags; 219 }; 220 221 /* 222 * mos7840_set_reg_sync 223 * To set the Control register by calling usb_fill_control_urb function 224 * by passing usb_sndctrlpipe function as parameter. 225 */ 226 227 static int mos7840_set_reg_sync(struct usb_serial_port *port, __u16 reg, 228 __u16 val) 229 { 230 struct usb_device *dev = port->serial->dev; 231 val = val & 0x00ff; 232 dev_dbg(&port->dev, "mos7840_set_reg_sync offset is %x, value %x\n", reg, val); 233 234 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ, 235 MCS_WR_RTYPE, val, reg, NULL, 0, 236 MOS_WDR_TIMEOUT); 237 } 238 239 /* 240 * mos7840_get_reg_sync 241 * To set the Uart register by calling usb_fill_control_urb function by 242 * passing usb_rcvctrlpipe function as parameter. 243 */ 244 245 static int mos7840_get_reg_sync(struct usb_serial_port *port, __u16 reg, 246 __u16 *val) 247 { 248 struct usb_device *dev = port->serial->dev; 249 int ret = 0; 250 u8 *buf; 251 252 buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL); 253 if (!buf) 254 return -ENOMEM; 255 256 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ, 257 MCS_RD_RTYPE, 0, reg, buf, VENDOR_READ_LENGTH, 258 MOS_WDR_TIMEOUT); 259 if (ret < VENDOR_READ_LENGTH) { 260 if (ret >= 0) 261 ret = -EIO; 262 goto out; 263 } 264 265 *val = buf[0]; 266 dev_dbg(&port->dev, "%s offset is %x, return val %x\n", __func__, reg, *val); 267 out: 268 kfree(buf); 269 return ret; 270 } 271 272 /* 273 * mos7840_set_uart_reg 274 * To set the Uart register by calling usb_fill_control_urb function by 275 * passing usb_sndctrlpipe function as parameter. 276 */ 277 278 static int mos7840_set_uart_reg(struct usb_serial_port *port, __u16 reg, 279 __u16 val) 280 { 281 282 struct usb_device *dev = port->serial->dev; 283 val = val & 0x00ff; 284 /* For the UART control registers, the application number need 285 to be Or'ed */ 286 if (port->serial->num_ports == 2 && port->port_number != 0) 287 val |= ((__u16)port->port_number + 2) << 8; 288 else 289 val |= ((__u16)port->port_number + 1) << 8; 290 dev_dbg(&port->dev, "%s application number is %x\n", __func__, val); 291 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ, 292 MCS_WR_RTYPE, val, reg, NULL, 0, 293 MOS_WDR_TIMEOUT); 294 295 } 296 297 /* 298 * mos7840_get_uart_reg 299 * To set the Control register by calling usb_fill_control_urb function 300 * by passing usb_rcvctrlpipe function as parameter. 301 */ 302 static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg, 303 __u16 *val) 304 { 305 struct usb_device *dev = port->serial->dev; 306 int ret = 0; 307 __u16 Wval; 308 u8 *buf; 309 310 buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL); 311 if (!buf) 312 return -ENOMEM; 313 314 /* Wval is same as application number */ 315 if (port->serial->num_ports == 2 && port->port_number != 0) 316 Wval = ((__u16)port->port_number + 2) << 8; 317 else 318 Wval = ((__u16)port->port_number + 1) << 8; 319 dev_dbg(&port->dev, "%s application number is %x\n", __func__, Wval); 320 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ, 321 MCS_RD_RTYPE, Wval, reg, buf, VENDOR_READ_LENGTH, 322 MOS_WDR_TIMEOUT); 323 if (ret < VENDOR_READ_LENGTH) { 324 if (ret >= 0) 325 ret = -EIO; 326 goto out; 327 } 328 *val = buf[0]; 329 out: 330 kfree(buf); 331 return ret; 332 } 333 334 static void mos7840_dump_serial_port(struct usb_serial_port *port, 335 struct moschip_port *mos7840_port) 336 { 337 338 dev_dbg(&port->dev, "SpRegOffset is %2x\n", mos7840_port->SpRegOffset); 339 dev_dbg(&port->dev, "ControlRegOffset is %2x\n", mos7840_port->ControlRegOffset); 340 dev_dbg(&port->dev, "DCRRegOffset is %2x\n", mos7840_port->DcrRegOffset); 341 342 } 343 344 /************************************************************************/ 345 /************************************************************************/ 346 /* U S B C A L L B A C K F U N C T I O N S */ 347 /* U S B C A L L B A C K F U N C T I O N S */ 348 /************************************************************************/ 349 /************************************************************************/ 350 351 static void mos7840_set_led_callback(struct urb *urb) 352 { 353 switch (urb->status) { 354 case 0: 355 /* Success */ 356 break; 357 case -ECONNRESET: 358 case -ENOENT: 359 case -ESHUTDOWN: 360 /* This urb is terminated, clean up */ 361 dev_dbg(&urb->dev->dev, "%s - urb shutting down: %d\n", 362 __func__, urb->status); 363 break; 364 default: 365 dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n", 366 __func__, urb->status); 367 } 368 } 369 370 static void mos7840_set_led_async(struct moschip_port *mcs, __u16 wval, 371 __u16 reg) 372 { 373 struct usb_device *dev = mcs->port->serial->dev; 374 struct usb_ctrlrequest *dr = mcs->led_dr; 375 376 dr->bRequestType = MCS_WR_RTYPE; 377 dr->bRequest = MCS_WRREQ; 378 dr->wValue = cpu_to_le16(wval); 379 dr->wIndex = cpu_to_le16(reg); 380 dr->wLength = cpu_to_le16(0); 381 382 usb_fill_control_urb(mcs->led_urb, dev, usb_sndctrlpipe(dev, 0), 383 (unsigned char *)dr, NULL, 0, mos7840_set_led_callback, NULL); 384 385 usb_submit_urb(mcs->led_urb, GFP_ATOMIC); 386 } 387 388 static void mos7840_set_led_sync(struct usb_serial_port *port, __u16 reg, 389 __u16 val) 390 { 391 struct usb_device *dev = port->serial->dev; 392 393 usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ, MCS_WR_RTYPE, 394 val, reg, NULL, 0, MOS_WDR_TIMEOUT); 395 } 396 397 static void mos7840_led_off(struct timer_list *t) 398 { 399 struct moschip_port *mcs = from_timer(mcs, t, led_timer1); 400 401 /* Turn off LED */ 402 mos7840_set_led_async(mcs, 0x0300, MODEM_CONTROL_REGISTER); 403 mod_timer(&mcs->led_timer2, 404 jiffies + msecs_to_jiffies(LED_OFF_MS)); 405 } 406 407 static void mos7840_led_flag_off(struct timer_list *t) 408 { 409 struct moschip_port *mcs = from_timer(mcs, t, led_timer2); 410 411 clear_bit_unlock(MOS7840_FLAG_LED_BUSY, &mcs->flags); 412 } 413 414 static void mos7840_led_activity(struct usb_serial_port *port) 415 { 416 struct moschip_port *mos7840_port = usb_get_serial_port_data(port); 417 418 if (test_and_set_bit_lock(MOS7840_FLAG_LED_BUSY, &mos7840_port->flags)) 419 return; 420 421 mos7840_set_led_async(mos7840_port, 0x0301, MODEM_CONTROL_REGISTER); 422 mod_timer(&mos7840_port->led_timer1, 423 jiffies + msecs_to_jiffies(LED_ON_MS)); 424 } 425 426 /***************************************************************************** 427 * mos7840_bulk_in_callback 428 * this is the callback function for when we have received data on the 429 * bulk in endpoint. 430 *****************************************************************************/ 431 432 static void mos7840_bulk_in_callback(struct urb *urb) 433 { 434 struct moschip_port *mos7840_port = urb->context; 435 struct usb_serial_port *port = mos7840_port->port; 436 int retval; 437 unsigned char *data; 438 int status = urb->status; 439 440 if (status) { 441 dev_dbg(&urb->dev->dev, "nonzero read bulk status received: %d\n", status); 442 mos7840_port->read_urb_busy = false; 443 return; 444 } 445 446 data = urb->transfer_buffer; 447 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data); 448 449 if (urb->actual_length) { 450 struct tty_port *tport = &mos7840_port->port->port; 451 tty_insert_flip_string(tport, data, urb->actual_length); 452 tty_flip_buffer_push(tport); 453 port->icount.rx += urb->actual_length; 454 dev_dbg(&port->dev, "icount.rx is %d:\n", port->icount.rx); 455 } 456 457 if (mos7840_port->has_led) 458 mos7840_led_activity(port); 459 460 mos7840_port->read_urb_busy = true; 461 retval = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC); 462 463 if (retval) { 464 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, retval = %d\n", retval); 465 mos7840_port->read_urb_busy = false; 466 } 467 } 468 469 /***************************************************************************** 470 * mos7840_bulk_out_data_callback 471 * this is the callback function for when we have finished sending 472 * serial data on the bulk out endpoint. 473 *****************************************************************************/ 474 475 static void mos7840_bulk_out_data_callback(struct urb *urb) 476 { 477 struct moschip_port *mos7840_port = urb->context; 478 struct usb_serial_port *port = mos7840_port->port; 479 int status = urb->status; 480 unsigned long flags; 481 int i; 482 483 spin_lock_irqsave(&mos7840_port->pool_lock, flags); 484 for (i = 0; i < NUM_URBS; i++) { 485 if (urb == mos7840_port->write_urb_pool[i]) { 486 mos7840_port->busy[i] = 0; 487 break; 488 } 489 } 490 spin_unlock_irqrestore(&mos7840_port->pool_lock, flags); 491 492 if (status) { 493 dev_dbg(&port->dev, "nonzero write bulk status received:%d\n", status); 494 return; 495 } 496 497 tty_port_tty_wakeup(&port->port); 498 499 } 500 501 /************************************************************************/ 502 /* 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 */ 503 /************************************************************************/ 504 505 /***************************************************************************** 506 * mos7840_open 507 * this function is called by the tty driver when a port is opened 508 * If successful, we return 0 509 * Otherwise we return a negative error number. 510 *****************************************************************************/ 511 512 static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port) 513 { 514 struct moschip_port *mos7840_port = usb_get_serial_port_data(port); 515 struct usb_serial *serial = port->serial; 516 int response; 517 int j; 518 struct urb *urb; 519 __u16 Data; 520 int status; 521 522 usb_clear_halt(serial->dev, port->write_urb->pipe); 523 usb_clear_halt(serial->dev, port->read_urb->pipe); 524 525 /* Initialising the write urb pool */ 526 for (j = 0; j < NUM_URBS; ++j) { 527 urb = usb_alloc_urb(0, GFP_KERNEL); 528 mos7840_port->write_urb_pool[j] = urb; 529 if (!urb) 530 continue; 531 532 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE, 533 GFP_KERNEL); 534 if (!urb->transfer_buffer) { 535 usb_free_urb(urb); 536 mos7840_port->write_urb_pool[j] = NULL; 537 continue; 538 } 539 } 540 541 /***************************************************************************** 542 * Initialize MCS7840 -- Write Init values to corresponding Registers 543 * 544 * Register Index 545 * 1 : IER 546 * 2 : FCR 547 * 3 : LCR 548 * 4 : MCR 549 * 550 * 0x08 : SP1/2 Control Reg 551 *****************************************************************************/ 552 553 /* NEED to check the following Block */ 554 555 Data = 0x0; 556 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data); 557 if (status < 0) { 558 dev_dbg(&port->dev, "Reading Spreg failed\n"); 559 goto err; 560 } 561 Data |= 0x80; 562 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); 563 if (status < 0) { 564 dev_dbg(&port->dev, "writing Spreg failed\n"); 565 goto err; 566 } 567 568 Data &= ~0x80; 569 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); 570 if (status < 0) { 571 dev_dbg(&port->dev, "writing Spreg failed\n"); 572 goto err; 573 } 574 /* End of block to be checked */ 575 576 Data = 0x0; 577 status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset, 578 &Data); 579 if (status < 0) { 580 dev_dbg(&port->dev, "Reading Controlreg failed\n"); 581 goto err; 582 } 583 Data |= 0x08; /* Driver done bit */ 584 Data |= 0x20; /* rx_disable */ 585 status = mos7840_set_reg_sync(port, 586 mos7840_port->ControlRegOffset, Data); 587 if (status < 0) { 588 dev_dbg(&port->dev, "writing Controlreg failed\n"); 589 goto err; 590 } 591 /* do register settings here */ 592 /* Set all regs to the device default values. */ 593 /*********************************** 594 * First Disable all interrupts. 595 ***********************************/ 596 Data = 0x00; 597 status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); 598 if (status < 0) { 599 dev_dbg(&port->dev, "disabling interrupts failed\n"); 600 goto err; 601 } 602 /* Set FIFO_CONTROL_REGISTER to the default value */ 603 Data = 0x00; 604 status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); 605 if (status < 0) { 606 dev_dbg(&port->dev, "Writing FIFO_CONTROL_REGISTER failed\n"); 607 goto err; 608 } 609 610 Data = 0xcf; 611 status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); 612 if (status < 0) { 613 dev_dbg(&port->dev, "Writing FIFO_CONTROL_REGISTER failed\n"); 614 goto err; 615 } 616 617 Data = 0x03; 618 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 619 mos7840_port->shadowLCR = Data; 620 621 Data = 0x0b; 622 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 623 mos7840_port->shadowMCR = Data; 624 625 Data = 0x00; 626 status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data); 627 mos7840_port->shadowLCR = Data; 628 629 Data |= SERIAL_LCR_DLAB; /* data latch enable in LCR 0x80 */ 630 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 631 632 Data = 0x0c; 633 status = mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data); 634 635 Data = 0x0; 636 status = mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data); 637 638 Data = 0x00; 639 status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data); 640 641 Data = Data & ~SERIAL_LCR_DLAB; 642 status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 643 mos7840_port->shadowLCR = Data; 644 645 /* clearing Bulkin and Bulkout Fifo */ 646 Data = 0x0; 647 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data); 648 649 Data = Data | 0x0c; 650 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); 651 652 Data = Data & ~0x0c; 653 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data); 654 /* Finally enable all interrupts */ 655 Data = 0x0c; 656 status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); 657 658 /* clearing rx_disable */ 659 Data = 0x0; 660 status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset, 661 &Data); 662 Data = Data & ~0x20; 663 status = mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset, 664 Data); 665 666 /* rx_negate */ 667 Data = 0x0; 668 status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset, 669 &Data); 670 Data = Data | 0x10; 671 status = mos7840_set_reg_sync(port, mos7840_port->ControlRegOffset, 672 Data); 673 674 dev_dbg(&port->dev, "port number is %d\n", port->port_number); 675 dev_dbg(&port->dev, "minor number is %d\n", port->minor); 676 dev_dbg(&port->dev, "Bulkin endpoint is %d\n", port->bulk_in_endpointAddress); 677 dev_dbg(&port->dev, "BulkOut endpoint is %d\n", port->bulk_out_endpointAddress); 678 dev_dbg(&port->dev, "Interrupt endpoint is %d\n", port->interrupt_in_endpointAddress); 679 dev_dbg(&port->dev, "port's number in the device is %d\n", mos7840_port->port_num); 680 mos7840_port->read_urb = port->read_urb; 681 682 /* set up our bulk in urb */ 683 if ((serial->num_ports == 2) && (((__u16)port->port_number % 2) != 0)) { 684 usb_fill_bulk_urb(mos7840_port->read_urb, 685 serial->dev, 686 usb_rcvbulkpipe(serial->dev, 687 (port->bulk_in_endpointAddress) + 2), 688 port->bulk_in_buffer, 689 mos7840_port->read_urb->transfer_buffer_length, 690 mos7840_bulk_in_callback, mos7840_port); 691 } else { 692 usb_fill_bulk_urb(mos7840_port->read_urb, 693 serial->dev, 694 usb_rcvbulkpipe(serial->dev, 695 port->bulk_in_endpointAddress), 696 port->bulk_in_buffer, 697 mos7840_port->read_urb->transfer_buffer_length, 698 mos7840_bulk_in_callback, mos7840_port); 699 } 700 701 dev_dbg(&port->dev, "%s: bulkin endpoint is %d\n", __func__, port->bulk_in_endpointAddress); 702 mos7840_port->read_urb_busy = true; 703 response = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL); 704 if (response) { 705 dev_err(&port->dev, "%s - Error %d submitting control urb\n", 706 __func__, response); 707 mos7840_port->read_urb_busy = false; 708 } 709 710 /* initialize our port settings */ 711 /* Must set to enable ints! */ 712 mos7840_port->shadowMCR = MCR_MASTER_IE; 713 714 return 0; 715 err: 716 for (j = 0; j < NUM_URBS; ++j) { 717 urb = mos7840_port->write_urb_pool[j]; 718 if (!urb) 719 continue; 720 kfree(urb->transfer_buffer); 721 usb_free_urb(urb); 722 } 723 return status; 724 } 725 726 /***************************************************************************** 727 * mos7840_chars_in_buffer 728 * this function is called by the tty driver when it wants to know how many 729 * bytes of data we currently have outstanding in the port (data that has 730 * been written, but hasn't made it out the port yet) 731 *****************************************************************************/ 732 733 static unsigned int mos7840_chars_in_buffer(struct tty_struct *tty) 734 { 735 struct usb_serial_port *port = tty->driver_data; 736 struct moschip_port *mos7840_port = usb_get_serial_port_data(port); 737 int i; 738 unsigned int chars = 0; 739 unsigned long flags; 740 741 spin_lock_irqsave(&mos7840_port->pool_lock, flags); 742 for (i = 0; i < NUM_URBS; ++i) { 743 if (mos7840_port->busy[i]) { 744 struct urb *urb = mos7840_port->write_urb_pool[i]; 745 chars += urb->transfer_buffer_length; 746 } 747 } 748 spin_unlock_irqrestore(&mos7840_port->pool_lock, flags); 749 dev_dbg(&port->dev, "%s - returns %u\n", __func__, chars); 750 return chars; 751 752 } 753 754 /***************************************************************************** 755 * mos7840_close 756 * this function is called by the tty driver when a port is closed 757 *****************************************************************************/ 758 759 static void mos7840_close(struct usb_serial_port *port) 760 { 761 struct moschip_port *mos7840_port = usb_get_serial_port_data(port); 762 int j; 763 __u16 Data; 764 765 for (j = 0; j < NUM_URBS; ++j) 766 usb_kill_urb(mos7840_port->write_urb_pool[j]); 767 768 /* Freeing Write URBs */ 769 for (j = 0; j < NUM_URBS; ++j) { 770 if (mos7840_port->write_urb_pool[j]) { 771 kfree(mos7840_port->write_urb_pool[j]->transfer_buffer); 772 usb_free_urb(mos7840_port->write_urb_pool[j]); 773 } 774 } 775 776 usb_kill_urb(mos7840_port->read_urb); 777 mos7840_port->read_urb_busy = false; 778 779 Data = 0x0; 780 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 781 782 Data = 0x00; 783 mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); 784 } 785 786 /***************************************************************************** 787 * mos7840_break 788 * this function sends a break to the port 789 *****************************************************************************/ 790 static void mos7840_break(struct tty_struct *tty, int break_state) 791 { 792 struct usb_serial_port *port = tty->driver_data; 793 struct moschip_port *mos7840_port = usb_get_serial_port_data(port); 794 unsigned char data; 795 796 if (break_state == -1) 797 data = mos7840_port->shadowLCR | LCR_SET_BREAK; 798 else 799 data = mos7840_port->shadowLCR & ~LCR_SET_BREAK; 800 801 /* FIXME: no locking on shadowLCR anywhere in driver */ 802 mos7840_port->shadowLCR = data; 803 dev_dbg(&port->dev, "%s mos7840_port->shadowLCR is %x\n", __func__, mos7840_port->shadowLCR); 804 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, 805 mos7840_port->shadowLCR); 806 } 807 808 /***************************************************************************** 809 * mos7840_write_room 810 * this function is called by the tty driver when it wants to know how many 811 * bytes of data we can accept for a specific port. 812 *****************************************************************************/ 813 814 static unsigned int mos7840_write_room(struct tty_struct *tty) 815 { 816 struct usb_serial_port *port = tty->driver_data; 817 struct moschip_port *mos7840_port = usb_get_serial_port_data(port); 818 int i; 819 unsigned int room = 0; 820 unsigned long flags; 821 822 spin_lock_irqsave(&mos7840_port->pool_lock, flags); 823 for (i = 0; i < NUM_URBS; ++i) { 824 if (!mos7840_port->busy[i]) 825 room += URB_TRANSFER_BUFFER_SIZE; 826 } 827 spin_unlock_irqrestore(&mos7840_port->pool_lock, flags); 828 829 room = (room == 0) ? 0 : room - URB_TRANSFER_BUFFER_SIZE + 1; 830 dev_dbg(&mos7840_port->port->dev, "%s - returns %u\n", __func__, room); 831 return room; 832 833 } 834 835 /***************************************************************************** 836 * mos7840_write 837 * this function is called by the tty driver when data should be written to 838 * the port. 839 * If successful, we return the number of bytes written, otherwise we 840 * return a negative error number. 841 *****************************************************************************/ 842 843 static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port, 844 const unsigned char *data, int count) 845 { 846 struct moschip_port *mos7840_port = usb_get_serial_port_data(port); 847 struct usb_serial *serial = port->serial; 848 int status; 849 int i; 850 int bytes_sent = 0; 851 int transfer_size; 852 unsigned long flags; 853 struct urb *urb; 854 /* __u16 Data; */ 855 const unsigned char *current_position = data; 856 857 /* try to find a free urb in the list */ 858 urb = NULL; 859 860 spin_lock_irqsave(&mos7840_port->pool_lock, flags); 861 for (i = 0; i < NUM_URBS; ++i) { 862 if (!mos7840_port->busy[i]) { 863 mos7840_port->busy[i] = 1; 864 urb = mos7840_port->write_urb_pool[i]; 865 dev_dbg(&port->dev, "URB:%d\n", i); 866 break; 867 } 868 } 869 spin_unlock_irqrestore(&mos7840_port->pool_lock, flags); 870 871 if (urb == NULL) { 872 dev_dbg(&port->dev, "%s - no more free urbs\n", __func__); 873 goto exit; 874 } 875 876 if (urb->transfer_buffer == NULL) { 877 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE, 878 GFP_ATOMIC); 879 if (!urb->transfer_buffer) { 880 bytes_sent = -ENOMEM; 881 goto exit; 882 } 883 } 884 transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE); 885 886 memcpy(urb->transfer_buffer, current_position, transfer_size); 887 888 /* fill urb with data and submit */ 889 if ((serial->num_ports == 2) && (((__u16)port->port_number % 2) != 0)) { 890 usb_fill_bulk_urb(urb, 891 serial->dev, 892 usb_sndbulkpipe(serial->dev, 893 (port->bulk_out_endpointAddress) + 2), 894 urb->transfer_buffer, 895 transfer_size, 896 mos7840_bulk_out_data_callback, mos7840_port); 897 } else { 898 usb_fill_bulk_urb(urb, 899 serial->dev, 900 usb_sndbulkpipe(serial->dev, 901 port->bulk_out_endpointAddress), 902 urb->transfer_buffer, 903 transfer_size, 904 mos7840_bulk_out_data_callback, mos7840_port); 905 } 906 907 dev_dbg(&port->dev, "bulkout endpoint is %d\n", port->bulk_out_endpointAddress); 908 909 if (mos7840_port->has_led) 910 mos7840_led_activity(port); 911 912 /* send it down the pipe */ 913 status = usb_submit_urb(urb, GFP_ATOMIC); 914 915 if (status) { 916 mos7840_port->busy[i] = 0; 917 dev_err_console(port, "%s - usb_submit_urb(write bulk) failed " 918 "with status = %d\n", __func__, status); 919 bytes_sent = status; 920 goto exit; 921 } 922 bytes_sent = transfer_size; 923 port->icount.tx += transfer_size; 924 dev_dbg(&port->dev, "icount.tx is %d:\n", port->icount.tx); 925 exit: 926 return bytes_sent; 927 928 } 929 930 /***************************************************************************** 931 * mos7840_throttle 932 * this function is called by the tty driver when it wants to stop the data 933 * being read from the port. 934 *****************************************************************************/ 935 936 static void mos7840_throttle(struct tty_struct *tty) 937 { 938 struct usb_serial_port *port = tty->driver_data; 939 struct moschip_port *mos7840_port = usb_get_serial_port_data(port); 940 int status; 941 942 /* if we are implementing XON/XOFF, send the stop character */ 943 if (I_IXOFF(tty)) { 944 unsigned char stop_char = STOP_CHAR(tty); 945 status = mos7840_write(tty, port, &stop_char, 1); 946 if (status <= 0) 947 return; 948 } 949 /* if we are implementing RTS/CTS, toggle that line */ 950 if (C_CRTSCTS(tty)) { 951 mos7840_port->shadowMCR &= ~MCR_RTS; 952 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, 953 mos7840_port->shadowMCR); 954 if (status < 0) 955 return; 956 } 957 } 958 959 /***************************************************************************** 960 * mos7840_unthrottle 961 * this function is called by the tty driver when it wants to resume 962 * the data being read from the port (called after mos7840_throttle is 963 * called) 964 *****************************************************************************/ 965 static void mos7840_unthrottle(struct tty_struct *tty) 966 { 967 struct usb_serial_port *port = tty->driver_data; 968 struct moschip_port *mos7840_port = usb_get_serial_port_data(port); 969 int status; 970 971 /* if we are implementing XON/XOFF, send the start character */ 972 if (I_IXOFF(tty)) { 973 unsigned char start_char = START_CHAR(tty); 974 status = mos7840_write(tty, port, &start_char, 1); 975 if (status <= 0) 976 return; 977 } 978 979 /* if we are implementing RTS/CTS, toggle that line */ 980 if (C_CRTSCTS(tty)) { 981 mos7840_port->shadowMCR |= MCR_RTS; 982 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, 983 mos7840_port->shadowMCR); 984 if (status < 0) 985 return; 986 } 987 } 988 989 static int mos7840_tiocmget(struct tty_struct *tty) 990 { 991 struct usb_serial_port *port = tty->driver_data; 992 unsigned int result; 993 __u16 msr; 994 __u16 mcr; 995 int status; 996 997 status = mos7840_get_uart_reg(port, MODEM_STATUS_REGISTER, &msr); 998 if (status < 0) 999 return -EIO; 1000 status = mos7840_get_uart_reg(port, MODEM_CONTROL_REGISTER, &mcr); 1001 if (status < 0) 1002 return -EIO; 1003 result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0) 1004 | ((mcr & MCR_RTS) ? TIOCM_RTS : 0) 1005 | ((mcr & MCR_LOOPBACK) ? TIOCM_LOOP : 0) 1006 | ((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0) 1007 | ((msr & MOS7840_MSR_CD) ? TIOCM_CAR : 0) 1008 | ((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0) 1009 | ((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0); 1010 1011 dev_dbg(&port->dev, "%s - 0x%04X\n", __func__, result); 1012 1013 return result; 1014 } 1015 1016 static int mos7840_tiocmset(struct tty_struct *tty, 1017 unsigned int set, unsigned int clear) 1018 { 1019 struct usb_serial_port *port = tty->driver_data; 1020 struct moschip_port *mos7840_port = usb_get_serial_port_data(port); 1021 unsigned int mcr; 1022 int status; 1023 1024 /* FIXME: What locks the port registers ? */ 1025 mcr = mos7840_port->shadowMCR; 1026 if (clear & TIOCM_RTS) 1027 mcr &= ~MCR_RTS; 1028 if (clear & TIOCM_DTR) 1029 mcr &= ~MCR_DTR; 1030 if (clear & TIOCM_LOOP) 1031 mcr &= ~MCR_LOOPBACK; 1032 1033 if (set & TIOCM_RTS) 1034 mcr |= MCR_RTS; 1035 if (set & TIOCM_DTR) 1036 mcr |= MCR_DTR; 1037 if (set & TIOCM_LOOP) 1038 mcr |= MCR_LOOPBACK; 1039 1040 mos7840_port->shadowMCR = mcr; 1041 1042 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr); 1043 if (status < 0) { 1044 dev_dbg(&port->dev, "setting MODEM_CONTROL_REGISTER Failed\n"); 1045 return status; 1046 } 1047 1048 return 0; 1049 } 1050 1051 /***************************************************************************** 1052 * mos7840_calc_baud_rate_divisor 1053 * this function calculates the proper baud rate divisor for the specified 1054 * baud rate. 1055 *****************************************************************************/ 1056 static int mos7840_calc_baud_rate_divisor(struct usb_serial_port *port, 1057 int baudRate, int *divisor, 1058 __u16 *clk_sel_val) 1059 { 1060 dev_dbg(&port->dev, "%s - %d\n", __func__, baudRate); 1061 1062 if (baudRate <= 115200) { 1063 *divisor = 115200 / baudRate; 1064 *clk_sel_val = 0x0; 1065 } 1066 if ((baudRate > 115200) && (baudRate <= 230400)) { 1067 *divisor = 230400 / baudRate; 1068 *clk_sel_val = 0x10; 1069 } else if ((baudRate > 230400) && (baudRate <= 403200)) { 1070 *divisor = 403200 / baudRate; 1071 *clk_sel_val = 0x20; 1072 } else if ((baudRate > 403200) && (baudRate <= 460800)) { 1073 *divisor = 460800 / baudRate; 1074 *clk_sel_val = 0x30; 1075 } else if ((baudRate > 460800) && (baudRate <= 806400)) { 1076 *divisor = 806400 / baudRate; 1077 *clk_sel_val = 0x40; 1078 } else if ((baudRate > 806400) && (baudRate <= 921600)) { 1079 *divisor = 921600 / baudRate; 1080 *clk_sel_val = 0x50; 1081 } else if ((baudRate > 921600) && (baudRate <= 1572864)) { 1082 *divisor = 1572864 / baudRate; 1083 *clk_sel_val = 0x60; 1084 } else if ((baudRate > 1572864) && (baudRate <= 3145728)) { 1085 *divisor = 3145728 / baudRate; 1086 *clk_sel_val = 0x70; 1087 } 1088 return 0; 1089 } 1090 1091 /***************************************************************************** 1092 * mos7840_send_cmd_write_baud_rate 1093 * this function sends the proper command to change the baud rate of the 1094 * specified port. 1095 *****************************************************************************/ 1096 1097 static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port, 1098 int baudRate) 1099 { 1100 struct usb_serial_port *port = mos7840_port->port; 1101 int divisor = 0; 1102 int status; 1103 __u16 Data; 1104 __u16 clk_sel_val; 1105 1106 dev_dbg(&port->dev, "%s - baud = %d\n", __func__, baudRate); 1107 /* reset clk_uart_sel in spregOffset */ 1108 if (baudRate > 115200) { 1109 #ifdef HW_flow_control 1110 /* NOTE: need to see the pther register to modify */ 1111 /* setting h/w flow control bit to 1 */ 1112 Data = 0x2b; 1113 mos7840_port->shadowMCR = Data; 1114 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, 1115 Data); 1116 if (status < 0) { 1117 dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n"); 1118 return -1; 1119 } 1120 #endif 1121 1122 } else { 1123 #ifdef HW_flow_control 1124 /* setting h/w flow control bit to 0 */ 1125 Data = 0xb; 1126 mos7840_port->shadowMCR = Data; 1127 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, 1128 Data); 1129 if (status < 0) { 1130 dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n"); 1131 return -1; 1132 } 1133 #endif 1134 1135 } 1136 1137 if (1) { /* baudRate <= 115200) */ 1138 clk_sel_val = 0x0; 1139 Data = 0x0; 1140 status = mos7840_calc_baud_rate_divisor(port, baudRate, &divisor, 1141 &clk_sel_val); 1142 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, 1143 &Data); 1144 if (status < 0) { 1145 dev_dbg(&port->dev, "reading spreg failed in set_serial_baud\n"); 1146 return -1; 1147 } 1148 Data = (Data & 0x8f) | clk_sel_val; 1149 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, 1150 Data); 1151 if (status < 0) { 1152 dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n"); 1153 return -1; 1154 } 1155 /* Calculate the Divisor */ 1156 1157 if (status) { 1158 dev_err(&port->dev, "%s - bad baud rate\n", __func__); 1159 return status; 1160 } 1161 /* Enable access to divisor latch */ 1162 Data = mos7840_port->shadowLCR | SERIAL_LCR_DLAB; 1163 mos7840_port->shadowLCR = Data; 1164 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 1165 1166 /* Write the divisor */ 1167 Data = (unsigned char)(divisor & 0xff); 1168 dev_dbg(&port->dev, "set_serial_baud Value to write DLL is %x\n", Data); 1169 mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data); 1170 1171 Data = (unsigned char)((divisor & 0xff00) >> 8); 1172 dev_dbg(&port->dev, "set_serial_baud Value to write DLM is %x\n", Data); 1173 mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data); 1174 1175 /* Disable access to divisor latch */ 1176 Data = mos7840_port->shadowLCR & ~SERIAL_LCR_DLAB; 1177 mos7840_port->shadowLCR = Data; 1178 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 1179 1180 } 1181 return status; 1182 } 1183 1184 /***************************************************************************** 1185 * mos7840_change_port_settings 1186 * This routine is called to set the UART on the device to match 1187 * the specified new settings. 1188 *****************************************************************************/ 1189 1190 static void mos7840_change_port_settings(struct tty_struct *tty, 1191 struct moschip_port *mos7840_port, 1192 const struct ktermios *old_termios) 1193 { 1194 struct usb_serial_port *port = mos7840_port->port; 1195 int baud; 1196 unsigned cflag; 1197 __u8 lData; 1198 __u8 lParity; 1199 __u8 lStop; 1200 int status; 1201 __u16 Data; 1202 1203 lData = LCR_BITS_8; 1204 lStop = LCR_STOP_1; 1205 lParity = LCR_PAR_NONE; 1206 1207 cflag = tty->termios.c_cflag; 1208 1209 /* Change the number of bits */ 1210 switch (cflag & CSIZE) { 1211 case CS5: 1212 lData = LCR_BITS_5; 1213 break; 1214 1215 case CS6: 1216 lData = LCR_BITS_6; 1217 break; 1218 1219 case CS7: 1220 lData = LCR_BITS_7; 1221 break; 1222 1223 default: 1224 case CS8: 1225 lData = LCR_BITS_8; 1226 break; 1227 } 1228 1229 /* Change the Parity bit */ 1230 if (cflag & PARENB) { 1231 if (cflag & PARODD) { 1232 lParity = LCR_PAR_ODD; 1233 dev_dbg(&port->dev, "%s - parity = odd\n", __func__); 1234 } else { 1235 lParity = LCR_PAR_EVEN; 1236 dev_dbg(&port->dev, "%s - parity = even\n", __func__); 1237 } 1238 1239 } else { 1240 dev_dbg(&port->dev, "%s - parity = none\n", __func__); 1241 } 1242 1243 if (cflag & CMSPAR) 1244 lParity = lParity | 0x20; 1245 1246 /* Change the Stop bit */ 1247 if (cflag & CSTOPB) { 1248 lStop = LCR_STOP_2; 1249 dev_dbg(&port->dev, "%s - stop bits = 2\n", __func__); 1250 } else { 1251 lStop = LCR_STOP_1; 1252 dev_dbg(&port->dev, "%s - stop bits = 1\n", __func__); 1253 } 1254 1255 /* Update the LCR with the correct value */ 1256 mos7840_port->shadowLCR &= 1257 ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK); 1258 mos7840_port->shadowLCR |= (lData | lParity | lStop); 1259 1260 dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is %x\n", __func__, 1261 mos7840_port->shadowLCR); 1262 /* Disable Interrupts */ 1263 Data = 0x00; 1264 mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); 1265 1266 Data = 0x00; 1267 mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); 1268 1269 Data = 0xcf; 1270 mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data); 1271 1272 /* Send the updated LCR value to the mos7840 */ 1273 Data = mos7840_port->shadowLCR; 1274 1275 mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data); 1276 1277 Data = 0x00b; 1278 mos7840_port->shadowMCR = Data; 1279 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 1280 Data = 0x00b; 1281 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 1282 1283 /* set up the MCR register and send it to the mos7840 */ 1284 1285 mos7840_port->shadowMCR = MCR_MASTER_IE; 1286 if (cflag & CBAUD) 1287 mos7840_port->shadowMCR |= (MCR_DTR | MCR_RTS); 1288 1289 if (cflag & CRTSCTS) 1290 mos7840_port->shadowMCR |= (MCR_XON_ANY); 1291 else 1292 mos7840_port->shadowMCR &= ~(MCR_XON_ANY); 1293 1294 Data = mos7840_port->shadowMCR; 1295 mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data); 1296 1297 /* Determine divisor based on baud rate */ 1298 baud = tty_get_baud_rate(tty); 1299 1300 if (!baud) { 1301 /* pick a default, any default... */ 1302 dev_dbg(&port->dev, "%s", "Picked default baud...\n"); 1303 baud = 9600; 1304 } 1305 1306 dev_dbg(&port->dev, "%s - baud rate = %d\n", __func__, baud); 1307 status = mos7840_send_cmd_write_baud_rate(mos7840_port, baud); 1308 1309 /* Enable Interrupts */ 1310 Data = 0x0c; 1311 mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data); 1312 1313 if (!mos7840_port->read_urb_busy) { 1314 mos7840_port->read_urb_busy = true; 1315 status = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL); 1316 if (status) { 1317 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n", 1318 status); 1319 mos7840_port->read_urb_busy = false; 1320 } 1321 } 1322 dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is End %x\n", __func__, 1323 mos7840_port->shadowLCR); 1324 } 1325 1326 /***************************************************************************** 1327 * mos7840_set_termios 1328 * this function is called by the tty driver when it wants to change 1329 * the termios structure 1330 *****************************************************************************/ 1331 1332 static void mos7840_set_termios(struct tty_struct *tty, 1333 struct usb_serial_port *port, 1334 const struct ktermios *old_termios) 1335 { 1336 struct moschip_port *mos7840_port = usb_get_serial_port_data(port); 1337 int status; 1338 1339 /* change the port settings to the new ones specified */ 1340 1341 mos7840_change_port_settings(tty, mos7840_port, old_termios); 1342 1343 if (!mos7840_port->read_urb_busy) { 1344 mos7840_port->read_urb_busy = true; 1345 status = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL); 1346 if (status) { 1347 dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n", 1348 status); 1349 mos7840_port->read_urb_busy = false; 1350 } 1351 } 1352 } 1353 1354 /***************************************************************************** 1355 * mos7840_get_lsr_info - get line status register info 1356 * 1357 * Purpose: Let user call ioctl() to get info when the UART physically 1358 * is emptied. On bus types like RS485, the transmitter must 1359 * release the bus after transmitting. This must be done when 1360 * the transmit shift register is empty, not be done when the 1361 * transmit holding register is empty. This functionality 1362 * allows an RS485 driver to be written in user space. 1363 *****************************************************************************/ 1364 1365 static int mos7840_get_lsr_info(struct tty_struct *tty, 1366 unsigned int __user *value) 1367 { 1368 int count; 1369 unsigned int result = 0; 1370 1371 count = mos7840_chars_in_buffer(tty); 1372 if (count == 0) 1373 result = TIOCSER_TEMT; 1374 1375 if (copy_to_user(value, &result, sizeof(int))) 1376 return -EFAULT; 1377 return 0; 1378 } 1379 1380 /***************************************************************************** 1381 * SerialIoctl 1382 * this function handles any ioctl calls to the driver 1383 *****************************************************************************/ 1384 1385 static int mos7840_ioctl(struct tty_struct *tty, 1386 unsigned int cmd, unsigned long arg) 1387 { 1388 struct usb_serial_port *port = tty->driver_data; 1389 void __user *argp = (void __user *)arg; 1390 1391 switch (cmd) { 1392 /* return number of bytes available */ 1393 1394 case TIOCSERGETLSR: 1395 dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__); 1396 return mos7840_get_lsr_info(tty, argp); 1397 1398 default: 1399 break; 1400 } 1401 return -ENOIOCTLCMD; 1402 } 1403 1404 /* 1405 * Check if GPO (pin 42) is connected to GPI (pin 33) as recommended by ASIX 1406 * for MCS7810 by bit-banging a 16-bit word. 1407 * 1408 * Note that GPO is really RTS of the third port so this will toggle RTS of 1409 * port two or three on two- and four-port devices. 1410 */ 1411 static int mos7810_check(struct usb_serial *serial) 1412 { 1413 int i, pass_count = 0; 1414 u8 *buf; 1415 __u16 data = 0, mcr_data = 0; 1416 __u16 test_pattern = 0x55AA; 1417 int res; 1418 1419 buf = kmalloc(VENDOR_READ_LENGTH, GFP_KERNEL); 1420 if (!buf) 1421 return 0; /* failed to identify 7810 */ 1422 1423 /* Store MCR setting */ 1424 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 1425 MCS_RDREQ, MCS_RD_RTYPE, 0x0300, MODEM_CONTROL_REGISTER, 1426 buf, VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT); 1427 if (res == VENDOR_READ_LENGTH) 1428 mcr_data = *buf; 1429 1430 for (i = 0; i < 16; i++) { 1431 /* Send the 1-bit test pattern out to MCS7810 test pin */ 1432 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 1433 MCS_WRREQ, MCS_WR_RTYPE, 1434 (0x0300 | (((test_pattern >> i) & 0x0001) << 1)), 1435 MODEM_CONTROL_REGISTER, NULL, 0, MOS_WDR_TIMEOUT); 1436 1437 /* Read the test pattern back */ 1438 res = usb_control_msg(serial->dev, 1439 usb_rcvctrlpipe(serial->dev, 0), MCS_RDREQ, 1440 MCS_RD_RTYPE, 0, GPIO_REGISTER, buf, 1441 VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT); 1442 if (res == VENDOR_READ_LENGTH) 1443 data = *buf; 1444 1445 /* If this is a MCS7810 device, both test patterns must match */ 1446 if (((test_pattern >> i) ^ (~data >> 1)) & 0x0001) 1447 break; 1448 1449 pass_count++; 1450 } 1451 1452 /* Restore MCR setting */ 1453 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), MCS_WRREQ, 1454 MCS_WR_RTYPE, 0x0300 | mcr_data, MODEM_CONTROL_REGISTER, NULL, 1455 0, MOS_WDR_TIMEOUT); 1456 1457 kfree(buf); 1458 1459 if (pass_count == 16) 1460 return 1; 1461 1462 return 0; 1463 } 1464 1465 static int mos7840_probe(struct usb_serial *serial, 1466 const struct usb_device_id *id) 1467 { 1468 unsigned long device_flags = id->driver_info; 1469 u8 *buf; 1470 1471 /* Skip device-type detection if we already have device flags. */ 1472 if (device_flags) 1473 goto out; 1474 1475 buf = kzalloc(VENDOR_READ_LENGTH, GFP_KERNEL); 1476 if (!buf) 1477 return -ENOMEM; 1478 1479 usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 1480 MCS_RDREQ, MCS_RD_RTYPE, 0, GPIO_REGISTER, buf, 1481 VENDOR_READ_LENGTH, MOS_WDR_TIMEOUT); 1482 1483 /* For a MCS7840 device GPIO0 must be set to 1 */ 1484 if (buf[0] & 0x01) 1485 device_flags = MCS_PORTS(4); 1486 else if (mos7810_check(serial)) 1487 device_flags = MCS_PORTS(1) | MCS_LED; 1488 else 1489 device_flags = MCS_PORTS(2); 1490 1491 kfree(buf); 1492 out: 1493 usb_set_serial_data(serial, (void *)device_flags); 1494 1495 return 0; 1496 } 1497 1498 static int mos7840_calc_num_ports(struct usb_serial *serial, 1499 struct usb_serial_endpoints *epds) 1500 { 1501 unsigned long device_flags = (unsigned long)usb_get_serial_data(serial); 1502 int num_ports = MCS_PORTS(device_flags); 1503 1504 if (num_ports == 0 || num_ports > 4) 1505 return -ENODEV; 1506 1507 if (epds->num_bulk_in < num_ports || epds->num_bulk_out < num_ports) { 1508 dev_err(&serial->interface->dev, "missing endpoints\n"); 1509 return -ENODEV; 1510 } 1511 1512 return num_ports; 1513 } 1514 1515 static int mos7840_attach(struct usb_serial *serial) 1516 { 1517 struct device *dev = &serial->interface->dev; 1518 int status; 1519 u16 val; 1520 1521 /* Zero Length flag enable */ 1522 val = 0x0f; 1523 status = mos7840_set_reg_sync(serial->port[0], ZLP_REG5, val); 1524 if (status < 0) 1525 dev_dbg(dev, "Writing ZLP_REG5 failed status-0x%x\n", status); 1526 else 1527 dev_dbg(dev, "ZLP_REG5 Writing success status%d\n", status); 1528 1529 return status; 1530 } 1531 1532 static int mos7840_port_probe(struct usb_serial_port *port) 1533 { 1534 struct usb_serial *serial = port->serial; 1535 unsigned long device_flags = (unsigned long)usb_get_serial_data(serial); 1536 struct moschip_port *mos7840_port; 1537 int status; 1538 int pnum; 1539 __u16 Data; 1540 1541 /* we set up the pointers to the endpoints in the mos7840_open * 1542 * function, as the structures aren't created yet. */ 1543 1544 pnum = port->port_number; 1545 1546 dev_dbg(&port->dev, "mos7840_startup: configuring port %d\n", pnum); 1547 mos7840_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL); 1548 if (!mos7840_port) 1549 return -ENOMEM; 1550 1551 /* Initialize all port interrupt end point to port 0 int 1552 * endpoint. Our device has only one interrupt end point 1553 * common to all port */ 1554 1555 mos7840_port->port = port; 1556 spin_lock_init(&mos7840_port->pool_lock); 1557 1558 /* minor is not initialised until later by 1559 * usb-serial.c:get_free_serial() and cannot therefore be used 1560 * to index device instances */ 1561 mos7840_port->port_num = pnum + 1; 1562 dev_dbg(&port->dev, "port->minor = %d\n", port->minor); 1563 dev_dbg(&port->dev, "mos7840_port->port_num = %d\n", mos7840_port->port_num); 1564 1565 if (mos7840_port->port_num == 1) { 1566 mos7840_port->SpRegOffset = 0x0; 1567 mos7840_port->ControlRegOffset = 0x1; 1568 mos7840_port->DcrRegOffset = 0x4; 1569 } else { 1570 u8 phy_num = mos7840_port->port_num; 1571 1572 /* Port 2 in the 2-port case uses registers of port 3 */ 1573 if (serial->num_ports == 2) 1574 phy_num = 3; 1575 1576 mos7840_port->SpRegOffset = 0x8 + 2 * (phy_num - 2); 1577 mos7840_port->ControlRegOffset = 0x9 + 2 * (phy_num - 2); 1578 mos7840_port->DcrRegOffset = 0x16 + 3 * (phy_num - 2); 1579 } 1580 mos7840_dump_serial_port(port, mos7840_port); 1581 usb_set_serial_port_data(port, mos7840_port); 1582 1583 /* enable rx_disable bit in control register */ 1584 status = mos7840_get_reg_sync(port, 1585 mos7840_port->ControlRegOffset, &Data); 1586 if (status < 0) { 1587 dev_dbg(&port->dev, "Reading ControlReg failed status-0x%x\n", status); 1588 goto error; 1589 } else 1590 dev_dbg(&port->dev, "ControlReg Reading success val is %x, status%d\n", Data, status); 1591 Data |= 0x08; /* setting driver done bit */ 1592 Data |= 0x04; /* sp1_bit to have cts change reflect in 1593 modem status reg */ 1594 1595 /* Data |= 0x20; //rx_disable bit */ 1596 status = mos7840_set_reg_sync(port, 1597 mos7840_port->ControlRegOffset, Data); 1598 if (status < 0) { 1599 dev_dbg(&port->dev, "Writing ControlReg failed(rx_disable) status-0x%x\n", status); 1600 goto error; 1601 } else 1602 dev_dbg(&port->dev, "ControlReg Writing success(rx_disable) status%d\n", status); 1603 1604 /* Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2 1605 and 0x24 in DCR3 */ 1606 Data = 0x01; 1607 status = mos7840_set_reg_sync(port, 1608 (__u16) (mos7840_port->DcrRegOffset + 0), Data); 1609 if (status < 0) { 1610 dev_dbg(&port->dev, "Writing DCR0 failed status-0x%x\n", status); 1611 goto error; 1612 } else 1613 dev_dbg(&port->dev, "DCR0 Writing success status%d\n", status); 1614 1615 Data = 0x05; 1616 status = mos7840_set_reg_sync(port, 1617 (__u16) (mos7840_port->DcrRegOffset + 1), Data); 1618 if (status < 0) { 1619 dev_dbg(&port->dev, "Writing DCR1 failed status-0x%x\n", status); 1620 goto error; 1621 } else 1622 dev_dbg(&port->dev, "DCR1 Writing success status%d\n", status); 1623 1624 Data = 0x24; 1625 status = mos7840_set_reg_sync(port, 1626 (__u16) (mos7840_port->DcrRegOffset + 2), Data); 1627 if (status < 0) { 1628 dev_dbg(&port->dev, "Writing DCR2 failed status-0x%x\n", status); 1629 goto error; 1630 } else 1631 dev_dbg(&port->dev, "DCR2 Writing success status%d\n", status); 1632 1633 /* write values in clkstart0x0 and clkmulti 0x20 */ 1634 Data = 0x0; 1635 status = mos7840_set_reg_sync(port, CLK_START_VALUE_REGISTER, Data); 1636 if (status < 0) { 1637 dev_dbg(&port->dev, "Writing CLK_START_VALUE_REGISTER failed status-0x%x\n", status); 1638 goto error; 1639 } else 1640 dev_dbg(&port->dev, "CLK_START_VALUE_REGISTER Writing success status%d\n", status); 1641 1642 Data = 0x20; 1643 status = mos7840_set_reg_sync(port, CLK_MULTI_REGISTER, Data); 1644 if (status < 0) { 1645 dev_dbg(&port->dev, "Writing CLK_MULTI_REGISTER failed status-0x%x\n", status); 1646 goto error; 1647 } else 1648 dev_dbg(&port->dev, "CLK_MULTI_REGISTER Writing success status%d\n", status); 1649 1650 /* write value 0x0 to scratchpad register */ 1651 Data = 0x00; 1652 status = mos7840_set_uart_reg(port, SCRATCH_PAD_REGISTER, Data); 1653 if (status < 0) { 1654 dev_dbg(&port->dev, "Writing SCRATCH_PAD_REGISTER failed status-0x%x\n", status); 1655 goto error; 1656 } else 1657 dev_dbg(&port->dev, "SCRATCH_PAD_REGISTER Writing success status%d\n", status); 1658 1659 /* Zero Length flag register */ 1660 if ((mos7840_port->port_num != 1) && (serial->num_ports == 2)) { 1661 Data = 0xff; 1662 status = mos7840_set_reg_sync(port, 1663 (__u16) (ZLP_REG1 + 1664 ((__u16)mos7840_port->port_num)), Data); 1665 dev_dbg(&port->dev, "ZLIP offset %x\n", 1666 (__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num))); 1667 if (status < 0) { 1668 dev_dbg(&port->dev, "Writing ZLP_REG%d failed status-0x%x\n", pnum + 2, status); 1669 goto error; 1670 } else 1671 dev_dbg(&port->dev, "ZLP_REG%d Writing success status%d\n", pnum + 2, status); 1672 } else { 1673 Data = 0xff; 1674 status = mos7840_set_reg_sync(port, 1675 (__u16) (ZLP_REG1 + 1676 ((__u16)mos7840_port->port_num) - 0x1), Data); 1677 dev_dbg(&port->dev, "ZLIP offset %x\n", 1678 (__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num) - 0x1)); 1679 if (status < 0) { 1680 dev_dbg(&port->dev, "Writing ZLP_REG%d failed status-0x%x\n", pnum + 1, status); 1681 goto error; 1682 } else 1683 dev_dbg(&port->dev, "ZLP_REG%d Writing success status%d\n", pnum + 1, status); 1684 1685 } 1686 1687 mos7840_port->has_led = device_flags & MCS_LED; 1688 1689 /* Initialize LED timers */ 1690 if (mos7840_port->has_led) { 1691 mos7840_port->led_urb = usb_alloc_urb(0, GFP_KERNEL); 1692 mos7840_port->led_dr = kmalloc(sizeof(*mos7840_port->led_dr), 1693 GFP_KERNEL); 1694 if (!mos7840_port->led_urb || !mos7840_port->led_dr) { 1695 status = -ENOMEM; 1696 goto error; 1697 } 1698 1699 timer_setup(&mos7840_port->led_timer1, mos7840_led_off, 0); 1700 mos7840_port->led_timer1.expires = 1701 jiffies + msecs_to_jiffies(LED_ON_MS); 1702 timer_setup(&mos7840_port->led_timer2, mos7840_led_flag_off, 1703 0); 1704 mos7840_port->led_timer2.expires = 1705 jiffies + msecs_to_jiffies(LED_OFF_MS); 1706 1707 /* Turn off LED */ 1708 mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300); 1709 } 1710 1711 return 0; 1712 error: 1713 kfree(mos7840_port->led_dr); 1714 usb_free_urb(mos7840_port->led_urb); 1715 kfree(mos7840_port); 1716 1717 return status; 1718 } 1719 1720 static void mos7840_port_remove(struct usb_serial_port *port) 1721 { 1722 struct moschip_port *mos7840_port = usb_get_serial_port_data(port); 1723 1724 if (mos7840_port->has_led) { 1725 /* Turn off LED */ 1726 mos7840_set_led_sync(port, MODEM_CONTROL_REGISTER, 0x0300); 1727 1728 timer_shutdown_sync(&mos7840_port->led_timer1); 1729 timer_shutdown_sync(&mos7840_port->led_timer2); 1730 1731 usb_kill_urb(mos7840_port->led_urb); 1732 usb_free_urb(mos7840_port->led_urb); 1733 kfree(mos7840_port->led_dr); 1734 } 1735 1736 kfree(mos7840_port); 1737 } 1738 1739 static struct usb_serial_driver moschip7840_4port_device = { 1740 .driver = { 1741 .owner = THIS_MODULE, 1742 .name = "mos7840", 1743 }, 1744 .description = DRIVER_DESC, 1745 .id_table = id_table, 1746 .num_interrupt_in = 1, 1747 .open = mos7840_open, 1748 .close = mos7840_close, 1749 .write = mos7840_write, 1750 .write_room = mos7840_write_room, 1751 .chars_in_buffer = mos7840_chars_in_buffer, 1752 .throttle = mos7840_throttle, 1753 .unthrottle = mos7840_unthrottle, 1754 .calc_num_ports = mos7840_calc_num_ports, 1755 .probe = mos7840_probe, 1756 .attach = mos7840_attach, 1757 .ioctl = mos7840_ioctl, 1758 .set_termios = mos7840_set_termios, 1759 .break_ctl = mos7840_break, 1760 .tiocmget = mos7840_tiocmget, 1761 .tiocmset = mos7840_tiocmset, 1762 .get_icount = usb_serial_generic_get_icount, 1763 .port_probe = mos7840_port_probe, 1764 .port_remove = mos7840_port_remove, 1765 .read_bulk_callback = mos7840_bulk_in_callback, 1766 }; 1767 1768 static struct usb_serial_driver * const serial_drivers[] = { 1769 &moschip7840_4port_device, NULL 1770 }; 1771 1772 module_usb_serial_driver(serial_drivers, id_table); 1773 1774 MODULE_DESCRIPTION(DRIVER_DESC); 1775 MODULE_LICENSE("GPL"); 1776