1 /* 2 * Edgeport USB Serial Converter driver 3 * 4 * Copyright (C) 2000 Inside Out Networks, All rights reserved. 5 * Copyright (C) 2001-2002 Greg Kroah-Hartman <greg@kroah.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * Supports the following devices: 13 * Edgeport/4 14 * Edgeport/4t 15 * Edgeport/2 16 * Edgeport/4i 17 * Edgeport/2i 18 * Edgeport/421 19 * Edgeport/21 20 * Rapidport/4 21 * Edgeport/8 22 * Edgeport/2D8 23 * Edgeport/4D8 24 * Edgeport/8i 25 * 26 * For questions or problems with this driver, contact Inside Out 27 * Networks technical support, or Peter Berger <pberger@brimson.com>, 28 * or Al Borchers <alborchers@steinerpoint.com>. 29 * 30 */ 31 32 #include <linux/kernel.h> 33 #include <linux/jiffies.h> 34 #include <linux/errno.h> 35 #include <linux/init.h> 36 #include <linux/slab.h> 37 #include <linux/tty.h> 38 #include <linux/tty_driver.h> 39 #include <linux/tty_flip.h> 40 #include <linux/module.h> 41 #include <linux/spinlock.h> 42 #include <linux/serial.h> 43 #include <linux/ioctl.h> 44 #include <linux/wait.h> 45 #include <linux/firmware.h> 46 #include <linux/ihex.h> 47 #include <linux/uaccess.h> 48 #include <linux/usb.h> 49 #include <linux/usb/serial.h> 50 #include "io_edgeport.h" 51 #include "io_ionsp.h" /* info for the iosp messages */ 52 #include "io_16654.h" /* 16654 UART defines */ 53 54 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com> and David Iacovelli" 55 #define DRIVER_DESC "Edgeport USB Serial Driver" 56 57 #define MAX_NAME_LEN 64 58 59 #define CHASE_TIMEOUT (5*HZ) /* 5 seconds */ 60 #define OPEN_TIMEOUT (5*HZ) /* 5 seconds */ 61 #define COMMAND_TIMEOUT (5*HZ) /* 5 seconds */ 62 63 /* receive port state */ 64 enum RXSTATE { 65 EXPECT_HDR1 = 0, /* Expect header byte 1 */ 66 EXPECT_HDR2 = 1, /* Expect header byte 2 */ 67 EXPECT_DATA = 2, /* Expect 'RxBytesRemaining' data */ 68 EXPECT_HDR3 = 3, /* Expect header byte 3 (for status hdrs only) */ 69 }; 70 71 72 /* Transmit Fifo 73 * This Transmit queue is an extension of the edgeport Rx buffer. 74 * The maximum amount of data buffered in both the edgeport 75 * Rx buffer (maxTxCredits) and this buffer will never exceed maxTxCredits. 76 */ 77 struct TxFifo { 78 unsigned int head; /* index to head pointer (write) */ 79 unsigned int tail; /* index to tail pointer (read) */ 80 unsigned int count; /* Bytes in queue */ 81 unsigned int size; /* Max size of queue (equal to Max number of TxCredits) */ 82 unsigned char *fifo; /* allocated Buffer */ 83 }; 84 85 /* This structure holds all of the local port information */ 86 struct edgeport_port { 87 __u16 txCredits; /* our current credits for this port */ 88 __u16 maxTxCredits; /* the max size of the port */ 89 90 struct TxFifo txfifo; /* transmit fifo -- size will be maxTxCredits */ 91 struct urb *write_urb; /* write URB for this port */ 92 bool write_in_progress; /* 'true' while a write URB is outstanding */ 93 spinlock_t ep_lock; 94 95 __u8 shadowLCR; /* last LCR value received */ 96 __u8 shadowMCR; /* last MCR value received */ 97 __u8 shadowMSR; /* last MSR value received */ 98 __u8 shadowLSR; /* last LSR value received */ 99 __u8 shadowXonChar; /* last value set as XON char in Edgeport */ 100 __u8 shadowXoffChar; /* last value set as XOFF char in Edgeport */ 101 __u8 validDataMask; 102 __u32 baudRate; 103 104 bool open; 105 bool openPending; 106 bool commandPending; 107 bool closePending; 108 bool chaseResponsePending; 109 110 wait_queue_head_t wait_chase; /* for handling sleeping while waiting for chase to finish */ 111 wait_queue_head_t wait_open; /* for handling sleeping while waiting for open to finish */ 112 wait_queue_head_t wait_command; /* for handling sleeping while waiting for command to finish */ 113 114 struct usb_serial_port *port; /* loop back to the owner of this object */ 115 }; 116 117 118 /* This structure holds all of the individual device information */ 119 struct edgeport_serial { 120 char name[MAX_NAME_LEN+2]; /* string name of this device */ 121 122 struct edge_manuf_descriptor manuf_descriptor; /* the manufacturer descriptor */ 123 struct edge_boot_descriptor boot_descriptor; /* the boot firmware descriptor */ 124 struct edgeport_product_info product_info; /* Product Info */ 125 struct edge_compatibility_descriptor epic_descriptor; /* Edgeport compatible descriptor */ 126 int is_epic; /* flag if EPiC device or not */ 127 128 __u8 interrupt_in_endpoint; /* the interrupt endpoint handle */ 129 unsigned char *interrupt_in_buffer; /* the buffer we use for the interrupt endpoint */ 130 struct urb *interrupt_read_urb; /* our interrupt urb */ 131 132 __u8 bulk_in_endpoint; /* the bulk in endpoint handle */ 133 unsigned char *bulk_in_buffer; /* the buffer we use for the bulk in endpoint */ 134 struct urb *read_urb; /* our bulk read urb */ 135 bool read_in_progress; 136 spinlock_t es_lock; 137 138 __u8 bulk_out_endpoint; /* the bulk out endpoint handle */ 139 140 __s16 rxBytesAvail; /* the number of bytes that we need to read from this device */ 141 142 enum RXSTATE rxState; /* the current state of the bulk receive processor */ 143 __u8 rxHeader1; /* receive header byte 1 */ 144 __u8 rxHeader2; /* receive header byte 2 */ 145 __u8 rxHeader3; /* receive header byte 3 */ 146 __u8 rxPort; /* the port that we are currently receiving data for */ 147 __u8 rxStatusCode; /* the receive status code */ 148 __u8 rxStatusParam; /* the receive status paramater */ 149 __s16 rxBytesRemaining; /* the number of port bytes left to read */ 150 struct usb_serial *serial; /* loop back to the owner of this object */ 151 }; 152 153 /* baud rate information */ 154 struct divisor_table_entry { 155 __u32 BaudRate; 156 __u16 Divisor; 157 }; 158 159 /* 160 * Define table of divisors for Rev A EdgePort/4 hardware 161 * These assume a 3.6864MHz crystal, the standard /16, and 162 * MCR.7 = 0. 163 */ 164 165 static const struct divisor_table_entry divisor_table[] = { 166 { 50, 4608}, 167 { 75, 3072}, 168 { 110, 2095}, /* 2094.545455 => 230450 => .0217 % over */ 169 { 134, 1713}, /* 1713.011152 => 230398.5 => .00065% under */ 170 { 150, 1536}, 171 { 300, 768}, 172 { 600, 384}, 173 { 1200, 192}, 174 { 1800, 128}, 175 { 2400, 96}, 176 { 4800, 48}, 177 { 7200, 32}, 178 { 9600, 24}, 179 { 14400, 16}, 180 { 19200, 12}, 181 { 38400, 6}, 182 { 57600, 4}, 183 { 115200, 2}, 184 { 230400, 1}, 185 }; 186 187 /* Number of outstanding Command Write Urbs */ 188 static atomic_t CmdUrbs = ATOMIC_INIT(0); 189 190 191 /* local function prototypes */ 192 193 /* function prototypes for all URB callbacks */ 194 static void edge_interrupt_callback(struct urb *urb); 195 static void edge_bulk_in_callback(struct urb *urb); 196 static void edge_bulk_out_data_callback(struct urb *urb); 197 static void edge_bulk_out_cmd_callback(struct urb *urb); 198 199 /* function prototypes for the usbserial callbacks */ 200 static int edge_open(struct tty_struct *tty, struct usb_serial_port *port); 201 static void edge_close(struct usb_serial_port *port); 202 static int edge_write(struct tty_struct *tty, struct usb_serial_port *port, 203 const unsigned char *buf, int count); 204 static int edge_write_room(struct tty_struct *tty); 205 static int edge_chars_in_buffer(struct tty_struct *tty); 206 static void edge_throttle(struct tty_struct *tty); 207 static void edge_unthrottle(struct tty_struct *tty); 208 static void edge_set_termios(struct tty_struct *tty, 209 struct usb_serial_port *port, 210 struct ktermios *old_termios); 211 static int edge_ioctl(struct tty_struct *tty, 212 unsigned int cmd, unsigned long arg); 213 static void edge_break(struct tty_struct *tty, int break_state); 214 static int edge_tiocmget(struct tty_struct *tty); 215 static int edge_tiocmset(struct tty_struct *tty, 216 unsigned int set, unsigned int clear); 217 static int edge_startup(struct usb_serial *serial); 218 static void edge_disconnect(struct usb_serial *serial); 219 static void edge_release(struct usb_serial *serial); 220 static int edge_port_probe(struct usb_serial_port *port); 221 static int edge_port_remove(struct usb_serial_port *port); 222 223 #include "io_tables.h" /* all of the devices that this driver supports */ 224 225 /* function prototypes for all of our local functions */ 226 227 static void process_rcvd_data(struct edgeport_serial *edge_serial, 228 unsigned char *buffer, __u16 bufferLength); 229 static void process_rcvd_status(struct edgeport_serial *edge_serial, 230 __u8 byte2, __u8 byte3); 231 static void edge_tty_recv(struct usb_serial_port *port, unsigned char *data, 232 int length); 233 static void handle_new_msr(struct edgeport_port *edge_port, __u8 newMsr); 234 static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData, 235 __u8 lsr, __u8 data); 236 static int send_iosp_ext_cmd(struct edgeport_port *edge_port, __u8 command, 237 __u8 param); 238 static int calc_baud_rate_divisor(struct device *dev, int baud_rate, int *divisor); 239 static int send_cmd_write_baud_rate(struct edgeport_port *edge_port, 240 int baudRate); 241 static void change_port_settings(struct tty_struct *tty, 242 struct edgeport_port *edge_port, 243 struct ktermios *old_termios); 244 static int send_cmd_write_uart_register(struct edgeport_port *edge_port, 245 __u8 regNum, __u8 regValue); 246 static int write_cmd_usb(struct edgeport_port *edge_port, 247 unsigned char *buffer, int writeLength); 248 static void send_more_port_data(struct edgeport_serial *edge_serial, 249 struct edgeport_port *edge_port); 250 251 static int sram_write(struct usb_serial *serial, __u16 extAddr, __u16 addr, 252 __u16 length, const __u8 *data); 253 static int rom_read(struct usb_serial *serial, __u16 extAddr, __u16 addr, 254 __u16 length, __u8 *data); 255 static int rom_write(struct usb_serial *serial, __u16 extAddr, __u16 addr, 256 __u16 length, const __u8 *data); 257 static void get_manufacturing_desc(struct edgeport_serial *edge_serial); 258 static void get_boot_desc(struct edgeport_serial *edge_serial); 259 static void load_application_firmware(struct edgeport_serial *edge_serial); 260 261 static void unicode_to_ascii(char *string, int buflen, 262 __le16 *unicode, int unicode_size); 263 264 265 /* ************************************************************************ */ 266 /* ************************************************************************ */ 267 /* ************************************************************************ */ 268 /* ************************************************************************ */ 269 270 /************************************************************************ 271 * * 272 * update_edgeport_E2PROM() Compare current versions of * 273 * Boot ROM and Manufacture * 274 * Descriptors with versions * 275 * embedded in this driver * 276 * * 277 ************************************************************************/ 278 static void update_edgeport_E2PROM(struct edgeport_serial *edge_serial) 279 { 280 struct device *dev = &edge_serial->serial->dev->dev; 281 __u32 BootCurVer; 282 __u32 BootNewVer; 283 __u8 BootMajorVersion; 284 __u8 BootMinorVersion; 285 __u16 BootBuildNumber; 286 __u32 Bootaddr; 287 const struct ihex_binrec *rec; 288 const struct firmware *fw; 289 const char *fw_name; 290 int response; 291 292 switch (edge_serial->product_info.iDownloadFile) { 293 case EDGE_DOWNLOAD_FILE_I930: 294 fw_name = "edgeport/boot.fw"; 295 break; 296 case EDGE_DOWNLOAD_FILE_80251: 297 fw_name = "edgeport/boot2.fw"; 298 break; 299 default: 300 return; 301 } 302 303 response = request_ihex_firmware(&fw, fw_name, 304 &edge_serial->serial->dev->dev); 305 if (response) { 306 dev_err(dev, "Failed to load image \"%s\" err %d\n", 307 fw_name, response); 308 return; 309 } 310 311 rec = (const struct ihex_binrec *)fw->data; 312 BootMajorVersion = rec->data[0]; 313 BootMinorVersion = rec->data[1]; 314 BootBuildNumber = (rec->data[2] << 8) | rec->data[3]; 315 316 /* Check Boot Image Version */ 317 BootCurVer = (edge_serial->boot_descriptor.MajorVersion << 24) + 318 (edge_serial->boot_descriptor.MinorVersion << 16) + 319 le16_to_cpu(edge_serial->boot_descriptor.BuildNumber); 320 321 BootNewVer = (BootMajorVersion << 24) + 322 (BootMinorVersion << 16) + 323 BootBuildNumber; 324 325 dev_dbg(dev, "Current Boot Image version %d.%d.%d\n", 326 edge_serial->boot_descriptor.MajorVersion, 327 edge_serial->boot_descriptor.MinorVersion, 328 le16_to_cpu(edge_serial->boot_descriptor.BuildNumber)); 329 330 331 if (BootNewVer > BootCurVer) { 332 dev_dbg(dev, "**Update Boot Image from %d.%d.%d to %d.%d.%d\n", 333 edge_serial->boot_descriptor.MajorVersion, 334 edge_serial->boot_descriptor.MinorVersion, 335 le16_to_cpu(edge_serial->boot_descriptor.BuildNumber), 336 BootMajorVersion, BootMinorVersion, BootBuildNumber); 337 338 dev_dbg(dev, "Downloading new Boot Image\n"); 339 340 for (rec = ihex_next_binrec(rec); rec; 341 rec = ihex_next_binrec(rec)) { 342 Bootaddr = be32_to_cpu(rec->addr); 343 response = rom_write(edge_serial->serial, 344 Bootaddr >> 16, 345 Bootaddr & 0xFFFF, 346 be16_to_cpu(rec->len), 347 &rec->data[0]); 348 if (response < 0) { 349 dev_err(&edge_serial->serial->dev->dev, 350 "rom_write failed (%x, %x, %d)\n", 351 Bootaddr >> 16, Bootaddr & 0xFFFF, 352 be16_to_cpu(rec->len)); 353 break; 354 } 355 } 356 } else { 357 dev_dbg(dev, "Boot Image -- already up to date\n"); 358 } 359 release_firmware(fw); 360 } 361 362 #if 0 363 /************************************************************************ 364 * 365 * Get string descriptor from device 366 * 367 ************************************************************************/ 368 static int get_string_desc(struct usb_device *dev, int Id, 369 struct usb_string_descriptor **pRetDesc) 370 { 371 struct usb_string_descriptor StringDesc; 372 struct usb_string_descriptor *pStringDesc; 373 374 dev_dbg(&dev->dev, "%s - USB String ID = %d\n", __func__, Id); 375 376 if (!usb_get_descriptor(dev, USB_DT_STRING, Id, &StringDesc, 377 sizeof(StringDesc))) 378 return 0; 379 380 pStringDesc = kmalloc(StringDesc.bLength, GFP_KERNEL); 381 if (!pStringDesc) 382 return -1; 383 384 if (!usb_get_descriptor(dev, USB_DT_STRING, Id, pStringDesc, 385 StringDesc.bLength)) { 386 kfree(pStringDesc); 387 return -1; 388 } 389 390 *pRetDesc = pStringDesc; 391 return 0; 392 } 393 #endif 394 395 static void dump_product_info(struct edgeport_serial *edge_serial, 396 struct edgeport_product_info *product_info) 397 { 398 struct device *dev = &edge_serial->serial->dev->dev; 399 400 /* Dump Product Info structure */ 401 dev_dbg(dev, "**Product Information:\n"); 402 dev_dbg(dev, " ProductId %x\n", product_info->ProductId); 403 dev_dbg(dev, " NumPorts %d\n", product_info->NumPorts); 404 dev_dbg(dev, " ProdInfoVer %d\n", product_info->ProdInfoVer); 405 dev_dbg(dev, " IsServer %d\n", product_info->IsServer); 406 dev_dbg(dev, " IsRS232 %d\n", product_info->IsRS232); 407 dev_dbg(dev, " IsRS422 %d\n", product_info->IsRS422); 408 dev_dbg(dev, " IsRS485 %d\n", product_info->IsRS485); 409 dev_dbg(dev, " RomSize %d\n", product_info->RomSize); 410 dev_dbg(dev, " RamSize %d\n", product_info->RamSize); 411 dev_dbg(dev, " CpuRev %x\n", product_info->CpuRev); 412 dev_dbg(dev, " BoardRev %x\n", product_info->BoardRev); 413 dev_dbg(dev, " BootMajorVersion %d.%d.%d\n", 414 product_info->BootMajorVersion, 415 product_info->BootMinorVersion, 416 le16_to_cpu(product_info->BootBuildNumber)); 417 dev_dbg(dev, " FirmwareMajorVersion %d.%d.%d\n", 418 product_info->FirmwareMajorVersion, 419 product_info->FirmwareMinorVersion, 420 le16_to_cpu(product_info->FirmwareBuildNumber)); 421 dev_dbg(dev, " ManufactureDescDate %d/%d/%d\n", 422 product_info->ManufactureDescDate[0], 423 product_info->ManufactureDescDate[1], 424 product_info->ManufactureDescDate[2]+1900); 425 dev_dbg(dev, " iDownloadFile 0x%x\n", 426 product_info->iDownloadFile); 427 dev_dbg(dev, " EpicVer %d\n", product_info->EpicVer); 428 } 429 430 static void get_product_info(struct edgeport_serial *edge_serial) 431 { 432 struct edgeport_product_info *product_info = &edge_serial->product_info; 433 434 memset(product_info, 0, sizeof(struct edgeport_product_info)); 435 436 product_info->ProductId = (__u16)(le16_to_cpu(edge_serial->serial->dev->descriptor.idProduct) & ~ION_DEVICE_ID_80251_NETCHIP); 437 product_info->NumPorts = edge_serial->manuf_descriptor.NumPorts; 438 product_info->ProdInfoVer = 0; 439 440 product_info->RomSize = edge_serial->manuf_descriptor.RomSize; 441 product_info->RamSize = edge_serial->manuf_descriptor.RamSize; 442 product_info->CpuRev = edge_serial->manuf_descriptor.CpuRev; 443 product_info->BoardRev = edge_serial->manuf_descriptor.BoardRev; 444 445 product_info->BootMajorVersion = 446 edge_serial->boot_descriptor.MajorVersion; 447 product_info->BootMinorVersion = 448 edge_serial->boot_descriptor.MinorVersion; 449 product_info->BootBuildNumber = 450 edge_serial->boot_descriptor.BuildNumber; 451 452 memcpy(product_info->ManufactureDescDate, 453 edge_serial->manuf_descriptor.DescDate, 454 sizeof(edge_serial->manuf_descriptor.DescDate)); 455 456 /* check if this is 2nd generation hardware */ 457 if (le16_to_cpu(edge_serial->serial->dev->descriptor.idProduct) 458 & ION_DEVICE_ID_80251_NETCHIP) 459 product_info->iDownloadFile = EDGE_DOWNLOAD_FILE_80251; 460 else 461 product_info->iDownloadFile = EDGE_DOWNLOAD_FILE_I930; 462 463 /* Determine Product type and set appropriate flags */ 464 switch (DEVICE_ID_FROM_USB_PRODUCT_ID(product_info->ProductId)) { 465 case ION_DEVICE_ID_EDGEPORT_COMPATIBLE: 466 case ION_DEVICE_ID_EDGEPORT_4T: 467 case ION_DEVICE_ID_EDGEPORT_4: 468 case ION_DEVICE_ID_EDGEPORT_2: 469 case ION_DEVICE_ID_EDGEPORT_8_DUAL_CPU: 470 case ION_DEVICE_ID_EDGEPORT_8: 471 case ION_DEVICE_ID_EDGEPORT_421: 472 case ION_DEVICE_ID_EDGEPORT_21: 473 case ION_DEVICE_ID_EDGEPORT_2_DIN: 474 case ION_DEVICE_ID_EDGEPORT_4_DIN: 475 case ION_DEVICE_ID_EDGEPORT_16_DUAL_CPU: 476 product_info->IsRS232 = 1; 477 break; 478 479 case ION_DEVICE_ID_EDGEPORT_2I: /* Edgeport/2 RS422/RS485 */ 480 product_info->IsRS422 = 1; 481 product_info->IsRS485 = 1; 482 break; 483 484 case ION_DEVICE_ID_EDGEPORT_8I: /* Edgeport/4 RS422 */ 485 case ION_DEVICE_ID_EDGEPORT_4I: /* Edgeport/4 RS422 */ 486 product_info->IsRS422 = 1; 487 break; 488 } 489 490 dump_product_info(edge_serial, product_info); 491 } 492 493 static int get_epic_descriptor(struct edgeport_serial *ep) 494 { 495 int result; 496 struct usb_serial *serial = ep->serial; 497 struct edgeport_product_info *product_info = &ep->product_info; 498 struct edge_compatibility_descriptor *epic = &ep->epic_descriptor; 499 struct edge_compatibility_bits *bits; 500 struct device *dev = &serial->dev->dev; 501 502 ep->is_epic = 0; 503 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 504 USB_REQUEST_ION_GET_EPIC_DESC, 505 0xC0, 0x00, 0x00, 506 &ep->epic_descriptor, 507 sizeof(struct edge_compatibility_descriptor), 508 300); 509 510 if (result > 0) { 511 ep->is_epic = 1; 512 memset(product_info, 0, sizeof(struct edgeport_product_info)); 513 514 product_info->NumPorts = epic->NumPorts; 515 product_info->ProdInfoVer = 0; 516 product_info->FirmwareMajorVersion = epic->MajorVersion; 517 product_info->FirmwareMinorVersion = epic->MinorVersion; 518 product_info->FirmwareBuildNumber = epic->BuildNumber; 519 product_info->iDownloadFile = epic->iDownloadFile; 520 product_info->EpicVer = epic->EpicVer; 521 product_info->Epic = epic->Supports; 522 product_info->ProductId = ION_DEVICE_ID_EDGEPORT_COMPATIBLE; 523 dump_product_info(ep, product_info); 524 525 bits = &ep->epic_descriptor.Supports; 526 dev_dbg(dev, "**EPIC descriptor:\n"); 527 dev_dbg(dev, " VendEnableSuspend: %s\n", bits->VendEnableSuspend ? "TRUE": "FALSE"); 528 dev_dbg(dev, " IOSPOpen : %s\n", bits->IOSPOpen ? "TRUE": "FALSE"); 529 dev_dbg(dev, " IOSPClose : %s\n", bits->IOSPClose ? "TRUE": "FALSE"); 530 dev_dbg(dev, " IOSPChase : %s\n", bits->IOSPChase ? "TRUE": "FALSE"); 531 dev_dbg(dev, " IOSPSetRxFlow : %s\n", bits->IOSPSetRxFlow ? "TRUE": "FALSE"); 532 dev_dbg(dev, " IOSPSetTxFlow : %s\n", bits->IOSPSetTxFlow ? "TRUE": "FALSE"); 533 dev_dbg(dev, " IOSPSetXChar : %s\n", bits->IOSPSetXChar ? "TRUE": "FALSE"); 534 dev_dbg(dev, " IOSPRxCheck : %s\n", bits->IOSPRxCheck ? "TRUE": "FALSE"); 535 dev_dbg(dev, " IOSPSetClrBreak : %s\n", bits->IOSPSetClrBreak ? "TRUE": "FALSE"); 536 dev_dbg(dev, " IOSPWriteMCR : %s\n", bits->IOSPWriteMCR ? "TRUE": "FALSE"); 537 dev_dbg(dev, " IOSPWriteLCR : %s\n", bits->IOSPWriteLCR ? "TRUE": "FALSE"); 538 dev_dbg(dev, " IOSPSetBaudRate : %s\n", bits->IOSPSetBaudRate ? "TRUE": "FALSE"); 539 dev_dbg(dev, " TrueEdgeport : %s\n", bits->TrueEdgeport ? "TRUE": "FALSE"); 540 } 541 542 return result; 543 } 544 545 546 /************************************************************************/ 547 /************************************************************************/ 548 /* U S B C A L L B A C K F U N C T I O N S */ 549 /* U S B C A L L B A C K F U N C T I O N S */ 550 /************************************************************************/ 551 /************************************************************************/ 552 553 /***************************************************************************** 554 * edge_interrupt_callback 555 * this is the callback function for when we have received data on the 556 * interrupt endpoint. 557 *****************************************************************************/ 558 static void edge_interrupt_callback(struct urb *urb) 559 { 560 struct edgeport_serial *edge_serial = urb->context; 561 struct device *dev; 562 struct edgeport_port *edge_port; 563 struct usb_serial_port *port; 564 unsigned char *data = urb->transfer_buffer; 565 int length = urb->actual_length; 566 int bytes_avail; 567 int position; 568 int txCredits; 569 int portNumber; 570 int result; 571 int status = urb->status; 572 573 switch (status) { 574 case 0: 575 /* success */ 576 break; 577 case -ECONNRESET: 578 case -ENOENT: 579 case -ESHUTDOWN: 580 /* this urb is terminated, clean up */ 581 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status); 582 return; 583 default: 584 dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status); 585 goto exit; 586 } 587 588 dev = &edge_serial->serial->dev->dev; 589 590 /* process this interrupt-read even if there are no ports open */ 591 if (length) { 592 usb_serial_debug_data(dev, __func__, length, data); 593 594 if (length > 1) { 595 bytes_avail = data[0] | (data[1] << 8); 596 if (bytes_avail) { 597 spin_lock(&edge_serial->es_lock); 598 edge_serial->rxBytesAvail += bytes_avail; 599 dev_dbg(dev, 600 "%s - bytes_avail=%d, rxBytesAvail=%d, read_in_progress=%d\n", 601 __func__, bytes_avail, 602 edge_serial->rxBytesAvail, 603 edge_serial->read_in_progress); 604 605 if (edge_serial->rxBytesAvail > 0 && 606 !edge_serial->read_in_progress) { 607 dev_dbg(dev, "%s - posting a read\n", __func__); 608 edge_serial->read_in_progress = true; 609 610 /* we have pending bytes on the 611 bulk in pipe, send a request */ 612 result = usb_submit_urb(edge_serial->read_urb, GFP_ATOMIC); 613 if (result) { 614 dev_err(dev, 615 "%s - usb_submit_urb(read bulk) failed with result = %d\n", 616 __func__, result); 617 edge_serial->read_in_progress = false; 618 } 619 } 620 spin_unlock(&edge_serial->es_lock); 621 } 622 } 623 /* grab the txcredits for the ports if available */ 624 position = 2; 625 portNumber = 0; 626 while ((position < length) && 627 (portNumber < edge_serial->serial->num_ports)) { 628 txCredits = data[position] | (data[position+1] << 8); 629 if (txCredits) { 630 port = edge_serial->serial->port[portNumber]; 631 edge_port = usb_get_serial_port_data(port); 632 if (edge_port->open) { 633 spin_lock(&edge_port->ep_lock); 634 edge_port->txCredits += txCredits; 635 spin_unlock(&edge_port->ep_lock); 636 dev_dbg(dev, "%s - txcredits for port%d = %d\n", 637 __func__, portNumber, 638 edge_port->txCredits); 639 640 /* tell the tty driver that something 641 has changed */ 642 tty_port_tty_wakeup(&edge_port->port->port); 643 /* Since we have more credit, check 644 if more data can be sent */ 645 send_more_port_data(edge_serial, 646 edge_port); 647 } 648 } 649 position += 2; 650 ++portNumber; 651 } 652 } 653 654 exit: 655 result = usb_submit_urb(urb, GFP_ATOMIC); 656 if (result) 657 dev_err(&urb->dev->dev, 658 "%s - Error %d submitting control urb\n", 659 __func__, result); 660 } 661 662 663 /***************************************************************************** 664 * edge_bulk_in_callback 665 * this is the callback function for when we have received data on the 666 * bulk in endpoint. 667 *****************************************************************************/ 668 static void edge_bulk_in_callback(struct urb *urb) 669 { 670 struct edgeport_serial *edge_serial = urb->context; 671 struct device *dev; 672 unsigned char *data = urb->transfer_buffer; 673 int retval; 674 __u16 raw_data_length; 675 int status = urb->status; 676 677 if (status) { 678 dev_dbg(&urb->dev->dev, "%s - nonzero read bulk status received: %d\n", 679 __func__, status); 680 edge_serial->read_in_progress = false; 681 return; 682 } 683 684 if (urb->actual_length == 0) { 685 dev_dbg(&urb->dev->dev, "%s - read bulk callback with no data\n", __func__); 686 edge_serial->read_in_progress = false; 687 return; 688 } 689 690 dev = &edge_serial->serial->dev->dev; 691 raw_data_length = urb->actual_length; 692 693 usb_serial_debug_data(dev, __func__, raw_data_length, data); 694 695 spin_lock(&edge_serial->es_lock); 696 697 /* decrement our rxBytes available by the number that we just got */ 698 edge_serial->rxBytesAvail -= raw_data_length; 699 700 dev_dbg(dev, "%s - Received = %d, rxBytesAvail %d\n", __func__, 701 raw_data_length, edge_serial->rxBytesAvail); 702 703 process_rcvd_data(edge_serial, data, urb->actual_length); 704 705 /* check to see if there's any more data for us to read */ 706 if (edge_serial->rxBytesAvail > 0) { 707 dev_dbg(dev, "%s - posting a read\n", __func__); 708 retval = usb_submit_urb(edge_serial->read_urb, GFP_ATOMIC); 709 if (retval) { 710 dev_err(dev, 711 "%s - usb_submit_urb(read bulk) failed, retval = %d\n", 712 __func__, retval); 713 edge_serial->read_in_progress = false; 714 } 715 } else { 716 edge_serial->read_in_progress = false; 717 } 718 719 spin_unlock(&edge_serial->es_lock); 720 } 721 722 723 /***************************************************************************** 724 * edge_bulk_out_data_callback 725 * this is the callback function for when we have finished sending 726 * serial data on the bulk out endpoint. 727 *****************************************************************************/ 728 static void edge_bulk_out_data_callback(struct urb *urb) 729 { 730 struct edgeport_port *edge_port = urb->context; 731 int status = urb->status; 732 733 if (status) { 734 dev_dbg(&urb->dev->dev, 735 "%s - nonzero write bulk status received: %d\n", 736 __func__, status); 737 } 738 739 if (edge_port->open) 740 tty_port_tty_wakeup(&edge_port->port->port); 741 742 /* Release the Write URB */ 743 edge_port->write_in_progress = false; 744 745 /* Check if more data needs to be sent */ 746 send_more_port_data((struct edgeport_serial *) 747 (usb_get_serial_data(edge_port->port->serial)), edge_port); 748 } 749 750 751 /***************************************************************************** 752 * BulkOutCmdCallback 753 * this is the callback function for when we have finished sending a 754 * command on the bulk out endpoint. 755 *****************************************************************************/ 756 static void edge_bulk_out_cmd_callback(struct urb *urb) 757 { 758 struct edgeport_port *edge_port = urb->context; 759 int status = urb->status; 760 761 atomic_dec(&CmdUrbs); 762 dev_dbg(&urb->dev->dev, "%s - FREE URB %p (outstanding %d)\n", 763 __func__, urb, atomic_read(&CmdUrbs)); 764 765 766 /* clean up the transfer buffer */ 767 kfree(urb->transfer_buffer); 768 769 /* Free the command urb */ 770 usb_free_urb(urb); 771 772 if (status) { 773 dev_dbg(&urb->dev->dev, 774 "%s - nonzero write bulk status received: %d\n", 775 __func__, status); 776 return; 777 } 778 779 /* tell the tty driver that something has changed */ 780 if (edge_port->open) 781 tty_port_tty_wakeup(&edge_port->port->port); 782 783 /* we have completed the command */ 784 edge_port->commandPending = false; 785 wake_up(&edge_port->wait_command); 786 } 787 788 789 /***************************************************************************** 790 * Driver tty interface functions 791 *****************************************************************************/ 792 793 /***************************************************************************** 794 * SerialOpen 795 * this function is called by the tty driver when a port is opened 796 * If successful, we return 0 797 * Otherwise we return a negative error number. 798 *****************************************************************************/ 799 static int edge_open(struct tty_struct *tty, struct usb_serial_port *port) 800 { 801 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 802 struct device *dev = &port->dev; 803 struct usb_serial *serial; 804 struct edgeport_serial *edge_serial; 805 int response; 806 807 if (edge_port == NULL) 808 return -ENODEV; 809 810 /* see if we've set up our endpoint info yet (can't set it up 811 in edge_startup as the structures were not set up at that time.) */ 812 serial = port->serial; 813 edge_serial = usb_get_serial_data(serial); 814 if (edge_serial == NULL) 815 return -ENODEV; 816 if (edge_serial->interrupt_in_buffer == NULL) { 817 struct usb_serial_port *port0 = serial->port[0]; 818 819 /* not set up yet, so do it now */ 820 edge_serial->interrupt_in_buffer = 821 port0->interrupt_in_buffer; 822 edge_serial->interrupt_in_endpoint = 823 port0->interrupt_in_endpointAddress; 824 edge_serial->interrupt_read_urb = port0->interrupt_in_urb; 825 edge_serial->bulk_in_buffer = port0->bulk_in_buffer; 826 edge_serial->bulk_in_endpoint = 827 port0->bulk_in_endpointAddress; 828 edge_serial->read_urb = port0->read_urb; 829 edge_serial->bulk_out_endpoint = 830 port0->bulk_out_endpointAddress; 831 832 /* set up our interrupt urb */ 833 usb_fill_int_urb(edge_serial->interrupt_read_urb, 834 serial->dev, 835 usb_rcvintpipe(serial->dev, 836 port0->interrupt_in_endpointAddress), 837 port0->interrupt_in_buffer, 838 edge_serial->interrupt_read_urb->transfer_buffer_length, 839 edge_interrupt_callback, edge_serial, 840 edge_serial->interrupt_read_urb->interval); 841 842 /* set up our bulk in urb */ 843 usb_fill_bulk_urb(edge_serial->read_urb, serial->dev, 844 usb_rcvbulkpipe(serial->dev, 845 port0->bulk_in_endpointAddress), 846 port0->bulk_in_buffer, 847 edge_serial->read_urb->transfer_buffer_length, 848 edge_bulk_in_callback, edge_serial); 849 edge_serial->read_in_progress = false; 850 851 /* start interrupt read for this edgeport 852 * this interrupt will continue as long 853 * as the edgeport is connected */ 854 response = usb_submit_urb(edge_serial->interrupt_read_urb, 855 GFP_KERNEL); 856 if (response) { 857 dev_err(dev, "%s - Error %d submitting control urb\n", 858 __func__, response); 859 } 860 } 861 862 /* initialize our wait queues */ 863 init_waitqueue_head(&edge_port->wait_open); 864 init_waitqueue_head(&edge_port->wait_chase); 865 init_waitqueue_head(&edge_port->wait_command); 866 867 /* initialize our port settings */ 868 edge_port->txCredits = 0; /* Can't send any data yet */ 869 /* Must always set this bit to enable ints! */ 870 edge_port->shadowMCR = MCR_MASTER_IE; 871 edge_port->chaseResponsePending = false; 872 873 /* send a open port command */ 874 edge_port->openPending = true; 875 edge_port->open = false; 876 response = send_iosp_ext_cmd(edge_port, IOSP_CMD_OPEN_PORT, 0); 877 878 if (response < 0) { 879 dev_err(dev, "%s - error sending open port command\n", __func__); 880 edge_port->openPending = false; 881 return -ENODEV; 882 } 883 884 /* now wait for the port to be completely opened */ 885 wait_event_timeout(edge_port->wait_open, !edge_port->openPending, 886 OPEN_TIMEOUT); 887 888 if (!edge_port->open) { 889 /* open timed out */ 890 dev_dbg(dev, "%s - open timedout\n", __func__); 891 edge_port->openPending = false; 892 return -ENODEV; 893 } 894 895 /* create the txfifo */ 896 edge_port->txfifo.head = 0; 897 edge_port->txfifo.tail = 0; 898 edge_port->txfifo.count = 0; 899 edge_port->txfifo.size = edge_port->maxTxCredits; 900 edge_port->txfifo.fifo = kmalloc(edge_port->maxTxCredits, GFP_KERNEL); 901 902 if (!edge_port->txfifo.fifo) { 903 dev_dbg(dev, "%s - no memory\n", __func__); 904 edge_close(port); 905 return -ENOMEM; 906 } 907 908 /* Allocate a URB for the write */ 909 edge_port->write_urb = usb_alloc_urb(0, GFP_KERNEL); 910 edge_port->write_in_progress = false; 911 912 if (!edge_port->write_urb) { 913 dev_dbg(dev, "%s - no memory\n", __func__); 914 edge_close(port); 915 return -ENOMEM; 916 } 917 918 dev_dbg(dev, "%s - Initialize TX fifo to %d bytes\n", 919 __func__, edge_port->maxTxCredits); 920 921 return 0; 922 } 923 924 925 /************************************************************************ 926 * 927 * block_until_chase_response 928 * 929 * This function will block the close until one of the following: 930 * 1. Response to our Chase comes from Edgeport 931 * 2. A timeout of 10 seconds without activity has expired 932 * (1K of Edgeport data @ 2400 baud ==> 4 sec to empty) 933 * 934 ************************************************************************/ 935 static void block_until_chase_response(struct edgeport_port *edge_port) 936 { 937 struct device *dev = &edge_port->port->dev; 938 DEFINE_WAIT(wait); 939 __u16 lastCredits; 940 int timeout = 1*HZ; 941 int loop = 10; 942 943 while (1) { 944 /* Save Last credits */ 945 lastCredits = edge_port->txCredits; 946 947 /* Did we get our Chase response */ 948 if (!edge_port->chaseResponsePending) { 949 dev_dbg(dev, "%s - Got Chase Response\n", __func__); 950 951 /* did we get all of our credit back? */ 952 if (edge_port->txCredits == edge_port->maxTxCredits) { 953 dev_dbg(dev, "%s - Got all credits\n", __func__); 954 return; 955 } 956 } 957 958 /* Block the thread for a while */ 959 prepare_to_wait(&edge_port->wait_chase, &wait, 960 TASK_UNINTERRUPTIBLE); 961 schedule_timeout(timeout); 962 finish_wait(&edge_port->wait_chase, &wait); 963 964 if (lastCredits == edge_port->txCredits) { 965 /* No activity.. count down. */ 966 loop--; 967 if (loop == 0) { 968 edge_port->chaseResponsePending = false; 969 dev_dbg(dev, "%s - Chase TIMEOUT\n", __func__); 970 return; 971 } 972 } else { 973 /* Reset timeout value back to 10 seconds */ 974 dev_dbg(dev, "%s - Last %d, Current %d\n", __func__, 975 lastCredits, edge_port->txCredits); 976 loop = 10; 977 } 978 } 979 } 980 981 982 /************************************************************************ 983 * 984 * block_until_tx_empty 985 * 986 * This function will block the close until one of the following: 987 * 1. TX count are 0 988 * 2. The edgeport has stopped 989 * 3. A timeout of 3 seconds without activity has expired 990 * 991 ************************************************************************/ 992 static void block_until_tx_empty(struct edgeport_port *edge_port) 993 { 994 struct device *dev = &edge_port->port->dev; 995 DEFINE_WAIT(wait); 996 struct TxFifo *fifo = &edge_port->txfifo; 997 __u32 lastCount; 998 int timeout = HZ/10; 999 int loop = 30; 1000 1001 while (1) { 1002 /* Save Last count */ 1003 lastCount = fifo->count; 1004 1005 /* Is the Edgeport Buffer empty? */ 1006 if (lastCount == 0) { 1007 dev_dbg(dev, "%s - TX Buffer Empty\n", __func__); 1008 return; 1009 } 1010 1011 /* Block the thread for a while */ 1012 prepare_to_wait(&edge_port->wait_chase, &wait, 1013 TASK_UNINTERRUPTIBLE); 1014 schedule_timeout(timeout); 1015 finish_wait(&edge_port->wait_chase, &wait); 1016 1017 dev_dbg(dev, "%s wait\n", __func__); 1018 1019 if (lastCount == fifo->count) { 1020 /* No activity.. count down. */ 1021 loop--; 1022 if (loop == 0) { 1023 dev_dbg(dev, "%s - TIMEOUT\n", __func__); 1024 return; 1025 } 1026 } else { 1027 /* Reset timeout value back to seconds */ 1028 loop = 30; 1029 } 1030 } 1031 } 1032 1033 1034 /***************************************************************************** 1035 * edge_close 1036 * this function is called by the tty driver when a port is closed 1037 *****************************************************************************/ 1038 static void edge_close(struct usb_serial_port *port) 1039 { 1040 struct edgeport_serial *edge_serial; 1041 struct edgeport_port *edge_port; 1042 int status; 1043 1044 edge_serial = usb_get_serial_data(port->serial); 1045 edge_port = usb_get_serial_port_data(port); 1046 if (edge_serial == NULL || edge_port == NULL) 1047 return; 1048 1049 /* block until tx is empty */ 1050 block_until_tx_empty(edge_port); 1051 1052 edge_port->closePending = true; 1053 1054 if ((!edge_serial->is_epic) || 1055 ((edge_serial->is_epic) && 1056 (edge_serial->epic_descriptor.Supports.IOSPChase))) { 1057 /* flush and chase */ 1058 edge_port->chaseResponsePending = true; 1059 1060 dev_dbg(&port->dev, "%s - Sending IOSP_CMD_CHASE_PORT\n", __func__); 1061 status = send_iosp_ext_cmd(edge_port, IOSP_CMD_CHASE_PORT, 0); 1062 if (status == 0) 1063 /* block until chase finished */ 1064 block_until_chase_response(edge_port); 1065 else 1066 edge_port->chaseResponsePending = false; 1067 } 1068 1069 if ((!edge_serial->is_epic) || 1070 ((edge_serial->is_epic) && 1071 (edge_serial->epic_descriptor.Supports.IOSPClose))) { 1072 /* close the port */ 1073 dev_dbg(&port->dev, "%s - Sending IOSP_CMD_CLOSE_PORT\n", __func__); 1074 send_iosp_ext_cmd(edge_port, IOSP_CMD_CLOSE_PORT, 0); 1075 } 1076 1077 /* port->close = true; */ 1078 edge_port->closePending = false; 1079 edge_port->open = false; 1080 edge_port->openPending = false; 1081 1082 usb_kill_urb(edge_port->write_urb); 1083 1084 if (edge_port->write_urb) { 1085 /* if this urb had a transfer buffer already 1086 (old transfer) free it */ 1087 kfree(edge_port->write_urb->transfer_buffer); 1088 usb_free_urb(edge_port->write_urb); 1089 edge_port->write_urb = NULL; 1090 } 1091 kfree(edge_port->txfifo.fifo); 1092 edge_port->txfifo.fifo = NULL; 1093 } 1094 1095 /***************************************************************************** 1096 * SerialWrite 1097 * this function is called by the tty driver when data should be written 1098 * to the port. 1099 * If successful, we return the number of bytes written, otherwise we 1100 * return a negative error number. 1101 *****************************************************************************/ 1102 static int edge_write(struct tty_struct *tty, struct usb_serial_port *port, 1103 const unsigned char *data, int count) 1104 { 1105 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 1106 struct TxFifo *fifo; 1107 int copySize; 1108 int bytesleft; 1109 int firsthalf; 1110 int secondhalf; 1111 unsigned long flags; 1112 1113 if (edge_port == NULL) 1114 return -ENODEV; 1115 1116 /* get a pointer to the Tx fifo */ 1117 fifo = &edge_port->txfifo; 1118 1119 spin_lock_irqsave(&edge_port->ep_lock, flags); 1120 1121 /* calculate number of bytes to put in fifo */ 1122 copySize = min((unsigned int)count, 1123 (edge_port->txCredits - fifo->count)); 1124 1125 dev_dbg(&port->dev, "%s of %d byte(s) Fifo room %d -- will copy %d bytes\n", 1126 __func__, count, edge_port->txCredits - fifo->count, copySize); 1127 1128 /* catch writes of 0 bytes which the tty driver likes to give us, 1129 and when txCredits is empty */ 1130 if (copySize == 0) { 1131 dev_dbg(&port->dev, "%s - copySize = Zero\n", __func__); 1132 goto finish_write; 1133 } 1134 1135 /* queue the data 1136 * since we can never overflow the buffer we do not have to check for a 1137 * full condition 1138 * 1139 * the copy is done is two parts -- first fill to the end of the buffer 1140 * then copy the reset from the start of the buffer 1141 */ 1142 bytesleft = fifo->size - fifo->head; 1143 firsthalf = min(bytesleft, copySize); 1144 dev_dbg(&port->dev, "%s - copy %d bytes of %d into fifo \n", __func__, 1145 firsthalf, bytesleft); 1146 1147 /* now copy our data */ 1148 memcpy(&fifo->fifo[fifo->head], data, firsthalf); 1149 usb_serial_debug_data(&port->dev, __func__, firsthalf, &fifo->fifo[fifo->head]); 1150 1151 /* update the index and size */ 1152 fifo->head += firsthalf; 1153 fifo->count += firsthalf; 1154 1155 /* wrap the index */ 1156 if (fifo->head == fifo->size) 1157 fifo->head = 0; 1158 1159 secondhalf = copySize-firsthalf; 1160 1161 if (secondhalf) { 1162 dev_dbg(&port->dev, "%s - copy rest of data %d\n", __func__, secondhalf); 1163 memcpy(&fifo->fifo[fifo->head], &data[firsthalf], secondhalf); 1164 usb_serial_debug_data(&port->dev, __func__, secondhalf, &fifo->fifo[fifo->head]); 1165 /* update the index and size */ 1166 fifo->count += secondhalf; 1167 fifo->head += secondhalf; 1168 /* No need to check for wrap since we can not get to end of 1169 * the fifo in this part 1170 */ 1171 } 1172 1173 finish_write: 1174 spin_unlock_irqrestore(&edge_port->ep_lock, flags); 1175 1176 send_more_port_data((struct edgeport_serial *) 1177 usb_get_serial_data(port->serial), edge_port); 1178 1179 dev_dbg(&port->dev, "%s wrote %d byte(s) TxCredits %d, Fifo %d\n", 1180 __func__, copySize, edge_port->txCredits, fifo->count); 1181 1182 return copySize; 1183 } 1184 1185 1186 /************************************************************************ 1187 * 1188 * send_more_port_data() 1189 * 1190 * This routine attempts to write additional UART transmit data 1191 * to a port over the USB bulk pipe. It is called (1) when new 1192 * data has been written to a port's TxBuffer from higher layers 1193 * (2) when the peripheral sends us additional TxCredits indicating 1194 * that it can accept more Tx data for a given port; and (3) when 1195 * a bulk write completes successfully and we want to see if we 1196 * can transmit more. 1197 * 1198 ************************************************************************/ 1199 static void send_more_port_data(struct edgeport_serial *edge_serial, 1200 struct edgeport_port *edge_port) 1201 { 1202 struct TxFifo *fifo = &edge_port->txfifo; 1203 struct device *dev = &edge_port->port->dev; 1204 struct urb *urb; 1205 unsigned char *buffer; 1206 int status; 1207 int count; 1208 int bytesleft; 1209 int firsthalf; 1210 int secondhalf; 1211 unsigned long flags; 1212 1213 spin_lock_irqsave(&edge_port->ep_lock, flags); 1214 1215 if (edge_port->write_in_progress || 1216 !edge_port->open || 1217 (fifo->count == 0)) { 1218 dev_dbg(dev, "%s EXIT - fifo %d, PendingWrite = %d\n", 1219 __func__, fifo->count, edge_port->write_in_progress); 1220 goto exit_send; 1221 } 1222 1223 /* since the amount of data in the fifo will always fit into the 1224 * edgeport buffer we do not need to check the write length 1225 * 1226 * Do we have enough credits for this port to make it worthwhile 1227 * to bother queueing a write. If it's too small, say a few bytes, 1228 * it's better to wait for more credits so we can do a larger write. 1229 */ 1230 if (edge_port->txCredits < EDGE_FW_GET_TX_CREDITS_SEND_THRESHOLD(edge_port->maxTxCredits, EDGE_FW_BULK_MAX_PACKET_SIZE)) { 1231 dev_dbg(dev, "%s Not enough credit - fifo %d TxCredit %d\n", 1232 __func__, fifo->count, edge_port->txCredits); 1233 goto exit_send; 1234 } 1235 1236 /* lock this write */ 1237 edge_port->write_in_progress = true; 1238 1239 /* get a pointer to the write_urb */ 1240 urb = edge_port->write_urb; 1241 1242 /* make sure transfer buffer is freed */ 1243 kfree(urb->transfer_buffer); 1244 urb->transfer_buffer = NULL; 1245 1246 /* build the data header for the buffer and port that we are about 1247 to send out */ 1248 count = fifo->count; 1249 buffer = kmalloc(count+2, GFP_ATOMIC); 1250 if (buffer == NULL) { 1251 dev_err_console(edge_port->port, 1252 "%s - no more kernel memory...\n", __func__); 1253 edge_port->write_in_progress = false; 1254 goto exit_send; 1255 } 1256 buffer[0] = IOSP_BUILD_DATA_HDR1(edge_port->port->port_number, count); 1257 buffer[1] = IOSP_BUILD_DATA_HDR2(edge_port->port->port_number, count); 1258 1259 /* now copy our data */ 1260 bytesleft = fifo->size - fifo->tail; 1261 firsthalf = min(bytesleft, count); 1262 memcpy(&buffer[2], &fifo->fifo[fifo->tail], firsthalf); 1263 fifo->tail += firsthalf; 1264 fifo->count -= firsthalf; 1265 if (fifo->tail == fifo->size) 1266 fifo->tail = 0; 1267 1268 secondhalf = count-firsthalf; 1269 if (secondhalf) { 1270 memcpy(&buffer[2+firsthalf], &fifo->fifo[fifo->tail], 1271 secondhalf); 1272 fifo->tail += secondhalf; 1273 fifo->count -= secondhalf; 1274 } 1275 1276 if (count) 1277 usb_serial_debug_data(&edge_port->port->dev, __func__, count, &buffer[2]); 1278 1279 /* fill up the urb with all of our data and submit it */ 1280 usb_fill_bulk_urb(urb, edge_serial->serial->dev, 1281 usb_sndbulkpipe(edge_serial->serial->dev, 1282 edge_serial->bulk_out_endpoint), 1283 buffer, count+2, 1284 edge_bulk_out_data_callback, edge_port); 1285 1286 /* decrement the number of credits we have by the number we just sent */ 1287 edge_port->txCredits -= count; 1288 edge_port->port->icount.tx += count; 1289 1290 status = usb_submit_urb(urb, GFP_ATOMIC); 1291 if (status) { 1292 /* something went wrong */ 1293 dev_err_console(edge_port->port, 1294 "%s - usb_submit_urb(write bulk) failed, status = %d, data lost\n", 1295 __func__, status); 1296 edge_port->write_in_progress = false; 1297 1298 /* revert the credits as something bad happened. */ 1299 edge_port->txCredits += count; 1300 edge_port->port->icount.tx -= count; 1301 } 1302 dev_dbg(dev, "%s wrote %d byte(s) TxCredit %d, Fifo %d\n", 1303 __func__, count, edge_port->txCredits, fifo->count); 1304 1305 exit_send: 1306 spin_unlock_irqrestore(&edge_port->ep_lock, flags); 1307 } 1308 1309 1310 /***************************************************************************** 1311 * edge_write_room 1312 * this function is called by the tty driver when it wants to know how 1313 * many bytes of data we can accept for a specific port. If successful, 1314 * we return the amount of room that we have for this port (the txCredits) 1315 * otherwise we return a negative error number. 1316 *****************************************************************************/ 1317 static int edge_write_room(struct tty_struct *tty) 1318 { 1319 struct usb_serial_port *port = tty->driver_data; 1320 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 1321 int room; 1322 unsigned long flags; 1323 1324 if (edge_port == NULL) 1325 return 0; 1326 if (edge_port->closePending) 1327 return 0; 1328 1329 if (!edge_port->open) { 1330 dev_dbg(&port->dev, "%s - port not opened\n", __func__); 1331 return 0; 1332 } 1333 1334 /* total of both buffers is still txCredit */ 1335 spin_lock_irqsave(&edge_port->ep_lock, flags); 1336 room = edge_port->txCredits - edge_port->txfifo.count; 1337 spin_unlock_irqrestore(&edge_port->ep_lock, flags); 1338 1339 dev_dbg(&port->dev, "%s - returns %d\n", __func__, room); 1340 return room; 1341 } 1342 1343 1344 /***************************************************************************** 1345 * edge_chars_in_buffer 1346 * this function is called by the tty driver when it wants to know how 1347 * many bytes of data we currently have outstanding in the port (data that 1348 * has been written, but hasn't made it out the port yet) 1349 * If successful, we return the number of bytes left to be written in the 1350 * system, 1351 * Otherwise we return a negative error number. 1352 *****************************************************************************/ 1353 static int edge_chars_in_buffer(struct tty_struct *tty) 1354 { 1355 struct usb_serial_port *port = tty->driver_data; 1356 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 1357 int num_chars; 1358 unsigned long flags; 1359 1360 if (edge_port == NULL) 1361 return 0; 1362 if (edge_port->closePending) 1363 return 0; 1364 1365 if (!edge_port->open) { 1366 dev_dbg(&port->dev, "%s - port not opened\n", __func__); 1367 return 0; 1368 } 1369 1370 spin_lock_irqsave(&edge_port->ep_lock, flags); 1371 num_chars = edge_port->maxTxCredits - edge_port->txCredits + 1372 edge_port->txfifo.count; 1373 spin_unlock_irqrestore(&edge_port->ep_lock, flags); 1374 if (num_chars) { 1375 dev_dbg(&port->dev, "%s - returns %d\n", __func__, num_chars); 1376 } 1377 1378 return num_chars; 1379 } 1380 1381 1382 /***************************************************************************** 1383 * SerialThrottle 1384 * this function is called by the tty driver when it wants to stop the data 1385 * being read from the port. 1386 *****************************************************************************/ 1387 static void edge_throttle(struct tty_struct *tty) 1388 { 1389 struct usb_serial_port *port = tty->driver_data; 1390 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 1391 int status; 1392 1393 if (edge_port == NULL) 1394 return; 1395 1396 if (!edge_port->open) { 1397 dev_dbg(&port->dev, "%s - port not opened\n", __func__); 1398 return; 1399 } 1400 1401 /* if we are implementing XON/XOFF, send the stop character */ 1402 if (I_IXOFF(tty)) { 1403 unsigned char stop_char = STOP_CHAR(tty); 1404 status = edge_write(tty, port, &stop_char, 1); 1405 if (status <= 0) 1406 return; 1407 } 1408 1409 /* if we are implementing RTS/CTS, toggle that line */ 1410 if (tty->termios.c_cflag & CRTSCTS) { 1411 edge_port->shadowMCR &= ~MCR_RTS; 1412 status = send_cmd_write_uart_register(edge_port, MCR, 1413 edge_port->shadowMCR); 1414 if (status != 0) 1415 return; 1416 } 1417 } 1418 1419 1420 /***************************************************************************** 1421 * edge_unthrottle 1422 * this function is called by the tty driver when it wants to resume the 1423 * data being read from the port (called after SerialThrottle is called) 1424 *****************************************************************************/ 1425 static void edge_unthrottle(struct tty_struct *tty) 1426 { 1427 struct usb_serial_port *port = tty->driver_data; 1428 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 1429 int status; 1430 1431 if (edge_port == NULL) 1432 return; 1433 1434 if (!edge_port->open) { 1435 dev_dbg(&port->dev, "%s - port not opened\n", __func__); 1436 return; 1437 } 1438 1439 /* if we are implementing XON/XOFF, send the start character */ 1440 if (I_IXOFF(tty)) { 1441 unsigned char start_char = START_CHAR(tty); 1442 status = edge_write(tty, port, &start_char, 1); 1443 if (status <= 0) 1444 return; 1445 } 1446 /* if we are implementing RTS/CTS, toggle that line */ 1447 if (tty->termios.c_cflag & CRTSCTS) { 1448 edge_port->shadowMCR |= MCR_RTS; 1449 send_cmd_write_uart_register(edge_port, MCR, 1450 edge_port->shadowMCR); 1451 } 1452 } 1453 1454 1455 /***************************************************************************** 1456 * SerialSetTermios 1457 * this function is called by the tty driver when it wants to change 1458 * the termios structure 1459 *****************************************************************************/ 1460 static void edge_set_termios(struct tty_struct *tty, 1461 struct usb_serial_port *port, struct ktermios *old_termios) 1462 { 1463 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 1464 unsigned int cflag; 1465 1466 cflag = tty->termios.c_cflag; 1467 dev_dbg(&port->dev, "%s - clfag %08x iflag %08x\n", __func__, tty->termios.c_cflag, tty->termios.c_iflag); 1468 dev_dbg(&port->dev, "%s - old clfag %08x old iflag %08x\n", __func__, old_termios->c_cflag, old_termios->c_iflag); 1469 1470 if (edge_port == NULL) 1471 return; 1472 1473 if (!edge_port->open) { 1474 dev_dbg(&port->dev, "%s - port not opened\n", __func__); 1475 return; 1476 } 1477 1478 /* change the port settings to the new ones specified */ 1479 change_port_settings(tty, edge_port, old_termios); 1480 } 1481 1482 1483 /***************************************************************************** 1484 * get_lsr_info - get line status register info 1485 * 1486 * Purpose: Let user call ioctl() to get info when the UART physically 1487 * is emptied. On bus types like RS485, the transmitter must 1488 * release the bus after transmitting. This must be done when 1489 * the transmit shift register is empty, not be done when the 1490 * transmit holding register is empty. This functionality 1491 * allows an RS485 driver to be written in user space. 1492 *****************************************************************************/ 1493 static int get_lsr_info(struct edgeport_port *edge_port, 1494 unsigned int __user *value) 1495 { 1496 unsigned int result = 0; 1497 unsigned long flags; 1498 1499 spin_lock_irqsave(&edge_port->ep_lock, flags); 1500 if (edge_port->maxTxCredits == edge_port->txCredits && 1501 edge_port->txfifo.count == 0) { 1502 dev_dbg(&edge_port->port->dev, "%s -- Empty\n", __func__); 1503 result = TIOCSER_TEMT; 1504 } 1505 spin_unlock_irqrestore(&edge_port->ep_lock, flags); 1506 1507 if (copy_to_user(value, &result, sizeof(int))) 1508 return -EFAULT; 1509 return 0; 1510 } 1511 1512 static int edge_tiocmset(struct tty_struct *tty, 1513 unsigned int set, unsigned int clear) 1514 { 1515 struct usb_serial_port *port = tty->driver_data; 1516 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 1517 unsigned int mcr; 1518 1519 mcr = edge_port->shadowMCR; 1520 if (set & TIOCM_RTS) 1521 mcr |= MCR_RTS; 1522 if (set & TIOCM_DTR) 1523 mcr |= MCR_DTR; 1524 if (set & TIOCM_LOOP) 1525 mcr |= MCR_LOOPBACK; 1526 1527 if (clear & TIOCM_RTS) 1528 mcr &= ~MCR_RTS; 1529 if (clear & TIOCM_DTR) 1530 mcr &= ~MCR_DTR; 1531 if (clear & TIOCM_LOOP) 1532 mcr &= ~MCR_LOOPBACK; 1533 1534 edge_port->shadowMCR = mcr; 1535 1536 send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR); 1537 1538 return 0; 1539 } 1540 1541 static int edge_tiocmget(struct tty_struct *tty) 1542 { 1543 struct usb_serial_port *port = tty->driver_data; 1544 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 1545 unsigned int result = 0; 1546 unsigned int msr; 1547 unsigned int mcr; 1548 1549 msr = edge_port->shadowMSR; 1550 mcr = edge_port->shadowMCR; 1551 result = ((mcr & MCR_DTR) ? TIOCM_DTR: 0) /* 0x002 */ 1552 | ((mcr & MCR_RTS) ? TIOCM_RTS: 0) /* 0x004 */ 1553 | ((msr & EDGEPORT_MSR_CTS) ? TIOCM_CTS: 0) /* 0x020 */ 1554 | ((msr & EDGEPORT_MSR_CD) ? TIOCM_CAR: 0) /* 0x040 */ 1555 | ((msr & EDGEPORT_MSR_RI) ? TIOCM_RI: 0) /* 0x080 */ 1556 | ((msr & EDGEPORT_MSR_DSR) ? TIOCM_DSR: 0); /* 0x100 */ 1557 1558 return result; 1559 } 1560 1561 static int get_serial_info(struct edgeport_port *edge_port, 1562 struct serial_struct __user *retinfo) 1563 { 1564 struct serial_struct tmp; 1565 1566 if (!retinfo) 1567 return -EFAULT; 1568 1569 memset(&tmp, 0, sizeof(tmp)); 1570 1571 tmp.type = PORT_16550A; 1572 tmp.line = edge_port->port->minor; 1573 tmp.port = edge_port->port->port_number; 1574 tmp.irq = 0; 1575 tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ; 1576 tmp.xmit_fifo_size = edge_port->maxTxCredits; 1577 tmp.baud_base = 9600; 1578 tmp.close_delay = 5*HZ; 1579 tmp.closing_wait = 30*HZ; 1580 1581 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) 1582 return -EFAULT; 1583 return 0; 1584 } 1585 1586 1587 /***************************************************************************** 1588 * SerialIoctl 1589 * this function handles any ioctl calls to the driver 1590 *****************************************************************************/ 1591 static int edge_ioctl(struct tty_struct *tty, 1592 unsigned int cmd, unsigned long arg) 1593 { 1594 struct usb_serial_port *port = tty->driver_data; 1595 DEFINE_WAIT(wait); 1596 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 1597 1598 dev_dbg(&port->dev, "%s - cmd = 0x%x\n", __func__, cmd); 1599 1600 switch (cmd) { 1601 case TIOCSERGETLSR: 1602 dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__); 1603 return get_lsr_info(edge_port, (unsigned int __user *) arg); 1604 1605 case TIOCGSERIAL: 1606 dev_dbg(&port->dev, "%s TIOCGSERIAL\n", __func__); 1607 return get_serial_info(edge_port, (struct serial_struct __user *) arg); 1608 } 1609 return -ENOIOCTLCMD; 1610 } 1611 1612 1613 /***************************************************************************** 1614 * SerialBreak 1615 * this function sends a break to the port 1616 *****************************************************************************/ 1617 static void edge_break(struct tty_struct *tty, int break_state) 1618 { 1619 struct usb_serial_port *port = tty->driver_data; 1620 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 1621 struct edgeport_serial *edge_serial = usb_get_serial_data(port->serial); 1622 int status; 1623 1624 if ((!edge_serial->is_epic) || 1625 ((edge_serial->is_epic) && 1626 (edge_serial->epic_descriptor.Supports.IOSPChase))) { 1627 /* flush and chase */ 1628 edge_port->chaseResponsePending = true; 1629 1630 dev_dbg(&port->dev, "%s - Sending IOSP_CMD_CHASE_PORT\n", __func__); 1631 status = send_iosp_ext_cmd(edge_port, IOSP_CMD_CHASE_PORT, 0); 1632 if (status == 0) { 1633 /* block until chase finished */ 1634 block_until_chase_response(edge_port); 1635 } else { 1636 edge_port->chaseResponsePending = false; 1637 } 1638 } 1639 1640 if ((!edge_serial->is_epic) || 1641 ((edge_serial->is_epic) && 1642 (edge_serial->epic_descriptor.Supports.IOSPSetClrBreak))) { 1643 if (break_state == -1) { 1644 dev_dbg(&port->dev, "%s - Sending IOSP_CMD_SET_BREAK\n", __func__); 1645 status = send_iosp_ext_cmd(edge_port, 1646 IOSP_CMD_SET_BREAK, 0); 1647 } else { 1648 dev_dbg(&port->dev, "%s - Sending IOSP_CMD_CLEAR_BREAK\n", __func__); 1649 status = send_iosp_ext_cmd(edge_port, 1650 IOSP_CMD_CLEAR_BREAK, 0); 1651 } 1652 if (status) 1653 dev_dbg(&port->dev, "%s - error sending break set/clear command.\n", 1654 __func__); 1655 } 1656 } 1657 1658 1659 /***************************************************************************** 1660 * process_rcvd_data 1661 * this function handles the data received on the bulk in pipe. 1662 *****************************************************************************/ 1663 static void process_rcvd_data(struct edgeport_serial *edge_serial, 1664 unsigned char *buffer, __u16 bufferLength) 1665 { 1666 struct device *dev = &edge_serial->serial->dev->dev; 1667 struct usb_serial_port *port; 1668 struct edgeport_port *edge_port; 1669 __u16 lastBufferLength; 1670 __u16 rxLen; 1671 1672 lastBufferLength = bufferLength + 1; 1673 1674 while (bufferLength > 0) { 1675 /* failsafe incase we get a message that we don't understand */ 1676 if (lastBufferLength == bufferLength) { 1677 dev_dbg(dev, "%s - stuck in loop, exiting it.\n", __func__); 1678 break; 1679 } 1680 lastBufferLength = bufferLength; 1681 1682 switch (edge_serial->rxState) { 1683 case EXPECT_HDR1: 1684 edge_serial->rxHeader1 = *buffer; 1685 ++buffer; 1686 --bufferLength; 1687 1688 if (bufferLength == 0) { 1689 edge_serial->rxState = EXPECT_HDR2; 1690 break; 1691 } 1692 /* otherwise, drop on through */ 1693 case EXPECT_HDR2: 1694 edge_serial->rxHeader2 = *buffer; 1695 ++buffer; 1696 --bufferLength; 1697 1698 dev_dbg(dev, "%s - Hdr1=%02X Hdr2=%02X\n", __func__, 1699 edge_serial->rxHeader1, edge_serial->rxHeader2); 1700 /* Process depending on whether this header is 1701 * data or status */ 1702 1703 if (IS_CMD_STAT_HDR(edge_serial->rxHeader1)) { 1704 /* Decode this status header and go to 1705 * EXPECT_HDR1 (if we can process the status 1706 * with only 2 bytes), or go to EXPECT_HDR3 to 1707 * get the third byte. */ 1708 edge_serial->rxPort = 1709 IOSP_GET_HDR_PORT(edge_serial->rxHeader1); 1710 edge_serial->rxStatusCode = 1711 IOSP_GET_STATUS_CODE( 1712 edge_serial->rxHeader1); 1713 1714 if (!IOSP_STATUS_IS_2BYTE( 1715 edge_serial->rxStatusCode)) { 1716 /* This status needs additional bytes. 1717 * Save what we have and then wait for 1718 * more data. 1719 */ 1720 edge_serial->rxStatusParam 1721 = edge_serial->rxHeader2; 1722 edge_serial->rxState = EXPECT_HDR3; 1723 break; 1724 } 1725 /* We have all the header bytes, process the 1726 status now */ 1727 process_rcvd_status(edge_serial, 1728 edge_serial->rxHeader2, 0); 1729 edge_serial->rxState = EXPECT_HDR1; 1730 break; 1731 } else { 1732 edge_serial->rxPort = 1733 IOSP_GET_HDR_PORT(edge_serial->rxHeader1); 1734 edge_serial->rxBytesRemaining = 1735 IOSP_GET_HDR_DATA_LEN( 1736 edge_serial->rxHeader1, 1737 edge_serial->rxHeader2); 1738 dev_dbg(dev, "%s - Data for Port %u Len %u\n", 1739 __func__, 1740 edge_serial->rxPort, 1741 edge_serial->rxBytesRemaining); 1742 1743 /* ASSERT(DevExt->RxPort < DevExt->NumPorts); 1744 * ASSERT(DevExt->RxBytesRemaining < 1745 * IOSP_MAX_DATA_LENGTH); 1746 */ 1747 1748 if (bufferLength == 0) { 1749 edge_serial->rxState = EXPECT_DATA; 1750 break; 1751 } 1752 /* Else, drop through */ 1753 } 1754 case EXPECT_DATA: /* Expect data */ 1755 if (bufferLength < edge_serial->rxBytesRemaining) { 1756 rxLen = bufferLength; 1757 /* Expect data to start next buffer */ 1758 edge_serial->rxState = EXPECT_DATA; 1759 } else { 1760 /* BufLen >= RxBytesRemaining */ 1761 rxLen = edge_serial->rxBytesRemaining; 1762 /* Start another header next time */ 1763 edge_serial->rxState = EXPECT_HDR1; 1764 } 1765 1766 bufferLength -= rxLen; 1767 edge_serial->rxBytesRemaining -= rxLen; 1768 1769 /* spit this data back into the tty driver if this 1770 port is open */ 1771 if (rxLen) { 1772 port = edge_serial->serial->port[ 1773 edge_serial->rxPort]; 1774 edge_port = usb_get_serial_port_data(port); 1775 if (edge_port->open) { 1776 dev_dbg(dev, "%s - Sending %d bytes to TTY for port %d\n", 1777 __func__, rxLen, 1778 edge_serial->rxPort); 1779 edge_tty_recv(edge_port->port, buffer, 1780 rxLen); 1781 edge_port->port->icount.rx += rxLen; 1782 } 1783 buffer += rxLen; 1784 } 1785 break; 1786 1787 case EXPECT_HDR3: /* Expect 3rd byte of status header */ 1788 edge_serial->rxHeader3 = *buffer; 1789 ++buffer; 1790 --bufferLength; 1791 1792 /* We have all the header bytes, process the 1793 status now */ 1794 process_rcvd_status(edge_serial, 1795 edge_serial->rxStatusParam, 1796 edge_serial->rxHeader3); 1797 edge_serial->rxState = EXPECT_HDR1; 1798 break; 1799 } 1800 } 1801 } 1802 1803 1804 /***************************************************************************** 1805 * process_rcvd_status 1806 * this function handles the any status messages received on the 1807 * bulk in pipe. 1808 *****************************************************************************/ 1809 static void process_rcvd_status(struct edgeport_serial *edge_serial, 1810 __u8 byte2, __u8 byte3) 1811 { 1812 struct usb_serial_port *port; 1813 struct edgeport_port *edge_port; 1814 struct tty_struct *tty; 1815 struct device *dev; 1816 __u8 code = edge_serial->rxStatusCode; 1817 1818 /* switch the port pointer to the one being currently talked about */ 1819 port = edge_serial->serial->port[edge_serial->rxPort]; 1820 edge_port = usb_get_serial_port_data(port); 1821 if (edge_port == NULL) { 1822 dev_err(&edge_serial->serial->dev->dev, 1823 "%s - edge_port == NULL for port %d\n", 1824 __func__, edge_serial->rxPort); 1825 return; 1826 } 1827 dev = &port->dev; 1828 1829 if (code == IOSP_EXT_STATUS) { 1830 switch (byte2) { 1831 case IOSP_EXT_STATUS_CHASE_RSP: 1832 /* we want to do EXT status regardless of port 1833 * open/closed */ 1834 dev_dbg(dev, "%s - Port %u EXT CHASE_RSP Data = %02x\n", 1835 __func__, edge_serial->rxPort, byte3); 1836 /* Currently, the only EXT_STATUS is Chase, so process 1837 * here instead of one more call to one more subroutine 1838 * If/when more EXT_STATUS, there'll be more work to do 1839 * Also, we currently clear flag and close the port 1840 * regardless of content of above's Byte3. 1841 * We could choose to do something else when Byte3 says 1842 * Timeout on Chase from Edgeport, like wait longer in 1843 * block_until_chase_response, but for now we don't. 1844 */ 1845 edge_port->chaseResponsePending = false; 1846 wake_up(&edge_port->wait_chase); 1847 return; 1848 1849 case IOSP_EXT_STATUS_RX_CHECK_RSP: 1850 dev_dbg(dev, "%s ========== Port %u CHECK_RSP Sequence = %02x =============\n", 1851 __func__, edge_serial->rxPort, byte3); 1852 /* Port->RxCheckRsp = true; */ 1853 return; 1854 } 1855 } 1856 1857 if (code == IOSP_STATUS_OPEN_RSP) { 1858 edge_port->txCredits = GET_TX_BUFFER_SIZE(byte3); 1859 edge_port->maxTxCredits = edge_port->txCredits; 1860 dev_dbg(dev, "%s - Port %u Open Response Initial MSR = %02x TxBufferSize = %d\n", 1861 __func__, edge_serial->rxPort, byte2, edge_port->txCredits); 1862 handle_new_msr(edge_port, byte2); 1863 1864 /* send the current line settings to the port so we are 1865 in sync with any further termios calls */ 1866 tty = tty_port_tty_get(&edge_port->port->port); 1867 if (tty) { 1868 change_port_settings(tty, 1869 edge_port, &tty->termios); 1870 tty_kref_put(tty); 1871 } 1872 1873 /* we have completed the open */ 1874 edge_port->openPending = false; 1875 edge_port->open = true; 1876 wake_up(&edge_port->wait_open); 1877 return; 1878 } 1879 1880 /* If port is closed, silently discard all rcvd status. We can 1881 * have cases where buffered status is received AFTER the close 1882 * port command is sent to the Edgeport. 1883 */ 1884 if (!edge_port->open || edge_port->closePending) 1885 return; 1886 1887 switch (code) { 1888 /* Not currently sent by Edgeport */ 1889 case IOSP_STATUS_LSR: 1890 dev_dbg(dev, "%s - Port %u LSR Status = %02x\n", 1891 __func__, edge_serial->rxPort, byte2); 1892 handle_new_lsr(edge_port, false, byte2, 0); 1893 break; 1894 1895 case IOSP_STATUS_LSR_DATA: 1896 dev_dbg(dev, "%s - Port %u LSR Status = %02x, Data = %02x\n", 1897 __func__, edge_serial->rxPort, byte2, byte3); 1898 /* byte2 is LSR Register */ 1899 /* byte3 is broken data byte */ 1900 handle_new_lsr(edge_port, true, byte2, byte3); 1901 break; 1902 /* 1903 * case IOSP_EXT_4_STATUS: 1904 * dev_dbg(dev, "%s - Port %u LSR Status = %02x Data = %02x\n", 1905 * __func__, edge_serial->rxPort, byte2, byte3); 1906 * break; 1907 */ 1908 case IOSP_STATUS_MSR: 1909 dev_dbg(dev, "%s - Port %u MSR Status = %02x\n", 1910 __func__, edge_serial->rxPort, byte2); 1911 /* 1912 * Process this new modem status and generate appropriate 1913 * events, etc, based on the new status. This routine 1914 * also saves the MSR in Port->ShadowMsr. 1915 */ 1916 handle_new_msr(edge_port, byte2); 1917 break; 1918 1919 default: 1920 dev_dbg(dev, "%s - Unrecognized IOSP status code %u\n", __func__, code); 1921 break; 1922 } 1923 } 1924 1925 1926 /***************************************************************************** 1927 * edge_tty_recv 1928 * this function passes data on to the tty flip buffer 1929 *****************************************************************************/ 1930 static void edge_tty_recv(struct usb_serial_port *port, unsigned char *data, 1931 int length) 1932 { 1933 int cnt; 1934 1935 cnt = tty_insert_flip_string(&port->port, data, length); 1936 if (cnt < length) { 1937 dev_err(&port->dev, "%s - dropping data, %d bytes lost\n", 1938 __func__, length - cnt); 1939 } 1940 data += cnt; 1941 length -= cnt; 1942 1943 tty_flip_buffer_push(&port->port); 1944 } 1945 1946 1947 /***************************************************************************** 1948 * handle_new_msr 1949 * this function handles any change to the msr register for a port. 1950 *****************************************************************************/ 1951 static void handle_new_msr(struct edgeport_port *edge_port, __u8 newMsr) 1952 { 1953 struct async_icount *icount; 1954 1955 if (newMsr & (EDGEPORT_MSR_DELTA_CTS | EDGEPORT_MSR_DELTA_DSR | 1956 EDGEPORT_MSR_DELTA_RI | EDGEPORT_MSR_DELTA_CD)) { 1957 icount = &edge_port->port->icount; 1958 1959 /* update input line counters */ 1960 if (newMsr & EDGEPORT_MSR_DELTA_CTS) 1961 icount->cts++; 1962 if (newMsr & EDGEPORT_MSR_DELTA_DSR) 1963 icount->dsr++; 1964 if (newMsr & EDGEPORT_MSR_DELTA_CD) 1965 icount->dcd++; 1966 if (newMsr & EDGEPORT_MSR_DELTA_RI) 1967 icount->rng++; 1968 wake_up_interruptible(&edge_port->port->port.delta_msr_wait); 1969 } 1970 1971 /* Save the new modem status */ 1972 edge_port->shadowMSR = newMsr & 0xf0; 1973 } 1974 1975 1976 /***************************************************************************** 1977 * handle_new_lsr 1978 * this function handles any change to the lsr register for a port. 1979 *****************************************************************************/ 1980 static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData, 1981 __u8 lsr, __u8 data) 1982 { 1983 __u8 newLsr = (__u8) (lsr & (__u8) 1984 (LSR_OVER_ERR | LSR_PAR_ERR | LSR_FRM_ERR | LSR_BREAK)); 1985 struct async_icount *icount; 1986 1987 edge_port->shadowLSR = lsr; 1988 1989 if (newLsr & LSR_BREAK) { 1990 /* 1991 * Parity and Framing errors only count if they 1992 * occur exclusive of a break being 1993 * received. 1994 */ 1995 newLsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK); 1996 } 1997 1998 /* Place LSR data byte into Rx buffer */ 1999 if (lsrData) 2000 edge_tty_recv(edge_port->port, &data, 1); 2001 2002 /* update input line counters */ 2003 icount = &edge_port->port->icount; 2004 if (newLsr & LSR_BREAK) 2005 icount->brk++; 2006 if (newLsr & LSR_OVER_ERR) 2007 icount->overrun++; 2008 if (newLsr & LSR_PAR_ERR) 2009 icount->parity++; 2010 if (newLsr & LSR_FRM_ERR) 2011 icount->frame++; 2012 } 2013 2014 2015 /**************************************************************************** 2016 * sram_write 2017 * writes a number of bytes to the Edgeport device's sram starting at the 2018 * given address. 2019 * If successful returns the number of bytes written, otherwise it returns 2020 * a negative error number of the problem. 2021 ****************************************************************************/ 2022 static int sram_write(struct usb_serial *serial, __u16 extAddr, __u16 addr, 2023 __u16 length, const __u8 *data) 2024 { 2025 int result; 2026 __u16 current_length; 2027 unsigned char *transfer_buffer; 2028 2029 dev_dbg(&serial->dev->dev, "%s - %x, %x, %d\n", __func__, extAddr, addr, length); 2030 2031 transfer_buffer = kmalloc(64, GFP_KERNEL); 2032 if (!transfer_buffer) { 2033 dev_err(&serial->dev->dev, "%s - kmalloc(%d) failed.\n", 2034 __func__, 64); 2035 return -ENOMEM; 2036 } 2037 2038 /* need to split these writes up into 64 byte chunks */ 2039 result = 0; 2040 while (length > 0) { 2041 if (length > 64) 2042 current_length = 64; 2043 else 2044 current_length = length; 2045 2046 /* dev_dbg(&serial->dev->dev, "%s - writing %x, %x, %d\n", __func__, extAddr, addr, current_length); */ 2047 memcpy(transfer_buffer, data, current_length); 2048 result = usb_control_msg(serial->dev, 2049 usb_sndctrlpipe(serial->dev, 0), 2050 USB_REQUEST_ION_WRITE_RAM, 2051 0x40, addr, extAddr, transfer_buffer, 2052 current_length, 300); 2053 if (result < 0) 2054 break; 2055 length -= current_length; 2056 addr += current_length; 2057 data += current_length; 2058 } 2059 2060 kfree(transfer_buffer); 2061 return result; 2062 } 2063 2064 2065 /**************************************************************************** 2066 * rom_write 2067 * writes a number of bytes to the Edgeport device's ROM starting at the 2068 * given address. 2069 * If successful returns the number of bytes written, otherwise it returns 2070 * a negative error number of the problem. 2071 ****************************************************************************/ 2072 static int rom_write(struct usb_serial *serial, __u16 extAddr, __u16 addr, 2073 __u16 length, const __u8 *data) 2074 { 2075 int result; 2076 __u16 current_length; 2077 unsigned char *transfer_buffer; 2078 2079 transfer_buffer = kmalloc(64, GFP_KERNEL); 2080 if (!transfer_buffer) { 2081 dev_err(&serial->dev->dev, "%s - kmalloc(%d) failed.\n", 2082 __func__, 64); 2083 return -ENOMEM; 2084 } 2085 2086 /* need to split these writes up into 64 byte chunks */ 2087 result = 0; 2088 while (length > 0) { 2089 if (length > 64) 2090 current_length = 64; 2091 else 2092 current_length = length; 2093 memcpy(transfer_buffer, data, current_length); 2094 result = usb_control_msg(serial->dev, 2095 usb_sndctrlpipe(serial->dev, 0), 2096 USB_REQUEST_ION_WRITE_ROM, 0x40, 2097 addr, extAddr, 2098 transfer_buffer, current_length, 300); 2099 if (result < 0) 2100 break; 2101 length -= current_length; 2102 addr += current_length; 2103 data += current_length; 2104 } 2105 2106 kfree(transfer_buffer); 2107 return result; 2108 } 2109 2110 2111 /**************************************************************************** 2112 * rom_read 2113 * reads a number of bytes from the Edgeport device starting at the given 2114 * address. 2115 * If successful returns the number of bytes read, otherwise it returns 2116 * a negative error number of the problem. 2117 ****************************************************************************/ 2118 static int rom_read(struct usb_serial *serial, __u16 extAddr, 2119 __u16 addr, __u16 length, __u8 *data) 2120 { 2121 int result; 2122 __u16 current_length; 2123 unsigned char *transfer_buffer; 2124 2125 transfer_buffer = kmalloc(64, GFP_KERNEL); 2126 if (!transfer_buffer) { 2127 dev_err(&serial->dev->dev, 2128 "%s - kmalloc(%d) failed.\n", __func__, 64); 2129 return -ENOMEM; 2130 } 2131 2132 /* need to split these reads up into 64 byte chunks */ 2133 result = 0; 2134 while (length > 0) { 2135 if (length > 64) 2136 current_length = 64; 2137 else 2138 current_length = length; 2139 result = usb_control_msg(serial->dev, 2140 usb_rcvctrlpipe(serial->dev, 0), 2141 USB_REQUEST_ION_READ_ROM, 2142 0xC0, addr, extAddr, transfer_buffer, 2143 current_length, 300); 2144 if (result < 0) 2145 break; 2146 memcpy(data, transfer_buffer, current_length); 2147 length -= current_length; 2148 addr += current_length; 2149 data += current_length; 2150 } 2151 2152 kfree(transfer_buffer); 2153 return result; 2154 } 2155 2156 2157 /**************************************************************************** 2158 * send_iosp_ext_cmd 2159 * Is used to send a IOSP message to the Edgeport device 2160 ****************************************************************************/ 2161 static int send_iosp_ext_cmd(struct edgeport_port *edge_port, 2162 __u8 command, __u8 param) 2163 { 2164 unsigned char *buffer; 2165 unsigned char *currentCommand; 2166 int length = 0; 2167 int status = 0; 2168 2169 buffer = kmalloc(10, GFP_ATOMIC); 2170 if (!buffer) { 2171 dev_err(&edge_port->port->dev, 2172 "%s - kmalloc(%d) failed.\n", __func__, 10); 2173 return -ENOMEM; 2174 } 2175 2176 currentCommand = buffer; 2177 2178 MAKE_CMD_EXT_CMD(¤tCommand, &length, edge_port->port->port_number, 2179 command, param); 2180 2181 status = write_cmd_usb(edge_port, buffer, length); 2182 if (status) { 2183 /* something bad happened, let's free up the memory */ 2184 kfree(buffer); 2185 } 2186 2187 return status; 2188 } 2189 2190 2191 /***************************************************************************** 2192 * write_cmd_usb 2193 * this function writes the given buffer out to the bulk write endpoint. 2194 *****************************************************************************/ 2195 static int write_cmd_usb(struct edgeport_port *edge_port, 2196 unsigned char *buffer, int length) 2197 { 2198 struct edgeport_serial *edge_serial = 2199 usb_get_serial_data(edge_port->port->serial); 2200 struct device *dev = &edge_port->port->dev; 2201 int status = 0; 2202 struct urb *urb; 2203 2204 usb_serial_debug_data(dev, __func__, length, buffer); 2205 2206 /* Allocate our next urb */ 2207 urb = usb_alloc_urb(0, GFP_ATOMIC); 2208 if (!urb) 2209 return -ENOMEM; 2210 2211 atomic_inc(&CmdUrbs); 2212 dev_dbg(dev, "%s - ALLOCATE URB %p (outstanding %d)\n", 2213 __func__, urb, atomic_read(&CmdUrbs)); 2214 2215 usb_fill_bulk_urb(urb, edge_serial->serial->dev, 2216 usb_sndbulkpipe(edge_serial->serial->dev, 2217 edge_serial->bulk_out_endpoint), 2218 buffer, length, edge_bulk_out_cmd_callback, edge_port); 2219 2220 edge_port->commandPending = true; 2221 status = usb_submit_urb(urb, GFP_ATOMIC); 2222 2223 if (status) { 2224 /* something went wrong */ 2225 dev_err(dev, "%s - usb_submit_urb(write command) failed, status = %d\n", 2226 __func__, status); 2227 usb_kill_urb(urb); 2228 usb_free_urb(urb); 2229 atomic_dec(&CmdUrbs); 2230 return status; 2231 } 2232 2233 #if 0 2234 wait_event(&edge_port->wait_command, !edge_port->commandPending); 2235 2236 if (edge_port->commandPending) { 2237 /* command timed out */ 2238 dev_dbg(dev, "%s - command timed out\n", __func__); 2239 status = -EINVAL; 2240 } 2241 #endif 2242 return status; 2243 } 2244 2245 2246 /***************************************************************************** 2247 * send_cmd_write_baud_rate 2248 * this function sends the proper command to change the baud rate of the 2249 * specified port. 2250 *****************************************************************************/ 2251 static int send_cmd_write_baud_rate(struct edgeport_port *edge_port, 2252 int baudRate) 2253 { 2254 struct edgeport_serial *edge_serial = 2255 usb_get_serial_data(edge_port->port->serial); 2256 struct device *dev = &edge_port->port->dev; 2257 unsigned char *cmdBuffer; 2258 unsigned char *currCmd; 2259 int cmdLen = 0; 2260 int divisor; 2261 int status; 2262 u32 number = edge_port->port->port_number; 2263 2264 if (edge_serial->is_epic && 2265 !edge_serial->epic_descriptor.Supports.IOSPSetBaudRate) { 2266 dev_dbg(dev, "SendCmdWriteBaudRate - NOT Setting baud rate for port, baud = %d\n", 2267 baudRate); 2268 return 0; 2269 } 2270 2271 dev_dbg(dev, "%s - baud = %d\n", __func__, baudRate); 2272 2273 status = calc_baud_rate_divisor(dev, baudRate, &divisor); 2274 if (status) { 2275 dev_err(dev, "%s - bad baud rate\n", __func__); 2276 return status; 2277 } 2278 2279 /* Alloc memory for the string of commands. */ 2280 cmdBuffer = kmalloc(0x100, GFP_ATOMIC); 2281 if (!cmdBuffer) { 2282 dev_err(dev, "%s - kmalloc(%d) failed.\n", __func__, 0x100); 2283 return -ENOMEM; 2284 } 2285 currCmd = cmdBuffer; 2286 2287 /* Enable access to divisor latch */ 2288 MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, number, LCR, LCR_DL_ENABLE); 2289 2290 /* Write the divisor itself */ 2291 MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, number, DLL, LOW8(divisor)); 2292 MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, number, DLM, HIGH8(divisor)); 2293 2294 /* Restore original value to disable access to divisor latch */ 2295 MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, number, LCR, 2296 edge_port->shadowLCR); 2297 2298 status = write_cmd_usb(edge_port, cmdBuffer, cmdLen); 2299 if (status) { 2300 /* something bad happened, let's free up the memory */ 2301 kfree(cmdBuffer); 2302 } 2303 2304 return status; 2305 } 2306 2307 2308 /***************************************************************************** 2309 * calc_baud_rate_divisor 2310 * this function calculates the proper baud rate divisor for the specified 2311 * baud rate. 2312 *****************************************************************************/ 2313 static int calc_baud_rate_divisor(struct device *dev, int baudrate, int *divisor) 2314 { 2315 int i; 2316 __u16 custom; 2317 2318 for (i = 0; i < ARRAY_SIZE(divisor_table); i++) { 2319 if (divisor_table[i].BaudRate == baudrate) { 2320 *divisor = divisor_table[i].Divisor; 2321 return 0; 2322 } 2323 } 2324 2325 /* We have tried all of the standard baud rates 2326 * lets try to calculate the divisor for this baud rate 2327 * Make sure the baud rate is reasonable */ 2328 if (baudrate > 50 && baudrate < 230400) { 2329 /* get divisor */ 2330 custom = (__u16)((230400L + baudrate/2) / baudrate); 2331 2332 *divisor = custom; 2333 2334 dev_dbg(dev, "%s - Baud %d = %d\n", __func__, baudrate, custom); 2335 return 0; 2336 } 2337 2338 return -1; 2339 } 2340 2341 2342 /***************************************************************************** 2343 * send_cmd_write_uart_register 2344 * this function builds up a uart register message and sends to the device. 2345 *****************************************************************************/ 2346 static int send_cmd_write_uart_register(struct edgeport_port *edge_port, 2347 __u8 regNum, __u8 regValue) 2348 { 2349 struct edgeport_serial *edge_serial = 2350 usb_get_serial_data(edge_port->port->serial); 2351 struct device *dev = &edge_port->port->dev; 2352 unsigned char *cmdBuffer; 2353 unsigned char *currCmd; 2354 unsigned long cmdLen = 0; 2355 int status; 2356 2357 dev_dbg(dev, "%s - write to %s register 0x%02x\n", 2358 (regNum == MCR) ? "MCR" : "LCR", __func__, regValue); 2359 2360 if (edge_serial->is_epic && 2361 !edge_serial->epic_descriptor.Supports.IOSPWriteMCR && 2362 regNum == MCR) { 2363 dev_dbg(dev, "SendCmdWriteUartReg - Not writing to MCR Register\n"); 2364 return 0; 2365 } 2366 2367 if (edge_serial->is_epic && 2368 !edge_serial->epic_descriptor.Supports.IOSPWriteLCR && 2369 regNum == LCR) { 2370 dev_dbg(dev, "SendCmdWriteUartReg - Not writing to LCR Register\n"); 2371 return 0; 2372 } 2373 2374 /* Alloc memory for the string of commands. */ 2375 cmdBuffer = kmalloc(0x10, GFP_ATOMIC); 2376 if (cmdBuffer == NULL) 2377 return -ENOMEM; 2378 2379 currCmd = cmdBuffer; 2380 2381 /* Build a cmd in the buffer to write the given register */ 2382 MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, edge_port->port->port_number, 2383 regNum, regValue); 2384 2385 status = write_cmd_usb(edge_port, cmdBuffer, cmdLen); 2386 if (status) { 2387 /* something bad happened, let's free up the memory */ 2388 kfree(cmdBuffer); 2389 } 2390 2391 return status; 2392 } 2393 2394 2395 /***************************************************************************** 2396 * change_port_settings 2397 * This routine is called to set the UART on the device to match the 2398 * specified new settings. 2399 *****************************************************************************/ 2400 2401 static void change_port_settings(struct tty_struct *tty, 2402 struct edgeport_port *edge_port, struct ktermios *old_termios) 2403 { 2404 struct device *dev = &edge_port->port->dev; 2405 struct edgeport_serial *edge_serial = 2406 usb_get_serial_data(edge_port->port->serial); 2407 int baud; 2408 unsigned cflag; 2409 __u8 mask = 0xff; 2410 __u8 lData; 2411 __u8 lParity; 2412 __u8 lStop; 2413 __u8 rxFlow; 2414 __u8 txFlow; 2415 int status; 2416 2417 if (!edge_port->open && 2418 !edge_port->openPending) { 2419 dev_dbg(dev, "%s - port not opened\n", __func__); 2420 return; 2421 } 2422 2423 cflag = tty->termios.c_cflag; 2424 2425 switch (cflag & CSIZE) { 2426 case CS5: 2427 lData = LCR_BITS_5; mask = 0x1f; 2428 dev_dbg(dev, "%s - data bits = 5\n", __func__); 2429 break; 2430 case CS6: 2431 lData = LCR_BITS_6; mask = 0x3f; 2432 dev_dbg(dev, "%s - data bits = 6\n", __func__); 2433 break; 2434 case CS7: 2435 lData = LCR_BITS_7; mask = 0x7f; 2436 dev_dbg(dev, "%s - data bits = 7\n", __func__); 2437 break; 2438 default: 2439 case CS8: 2440 lData = LCR_BITS_8; 2441 dev_dbg(dev, "%s - data bits = 8\n", __func__); 2442 break; 2443 } 2444 2445 lParity = LCR_PAR_NONE; 2446 if (cflag & PARENB) { 2447 if (cflag & CMSPAR) { 2448 if (cflag & PARODD) { 2449 lParity = LCR_PAR_MARK; 2450 dev_dbg(dev, "%s - parity = mark\n", __func__); 2451 } else { 2452 lParity = LCR_PAR_SPACE; 2453 dev_dbg(dev, "%s - parity = space\n", __func__); 2454 } 2455 } else if (cflag & PARODD) { 2456 lParity = LCR_PAR_ODD; 2457 dev_dbg(dev, "%s - parity = odd\n", __func__); 2458 } else { 2459 lParity = LCR_PAR_EVEN; 2460 dev_dbg(dev, "%s - parity = even\n", __func__); 2461 } 2462 } else { 2463 dev_dbg(dev, "%s - parity = none\n", __func__); 2464 } 2465 2466 if (cflag & CSTOPB) { 2467 lStop = LCR_STOP_2; 2468 dev_dbg(dev, "%s - stop bits = 2\n", __func__); 2469 } else { 2470 lStop = LCR_STOP_1; 2471 dev_dbg(dev, "%s - stop bits = 1\n", __func__); 2472 } 2473 2474 /* figure out the flow control settings */ 2475 rxFlow = txFlow = 0x00; 2476 if (cflag & CRTSCTS) { 2477 rxFlow |= IOSP_RX_FLOW_RTS; 2478 txFlow |= IOSP_TX_FLOW_CTS; 2479 dev_dbg(dev, "%s - RTS/CTS is enabled\n", __func__); 2480 } else { 2481 dev_dbg(dev, "%s - RTS/CTS is disabled\n", __func__); 2482 } 2483 2484 /* if we are implementing XON/XOFF, set the start and stop character 2485 in the device */ 2486 if (I_IXOFF(tty) || I_IXON(tty)) { 2487 unsigned char stop_char = STOP_CHAR(tty); 2488 unsigned char start_char = START_CHAR(tty); 2489 2490 if ((!edge_serial->is_epic) || 2491 ((edge_serial->is_epic) && 2492 (edge_serial->epic_descriptor.Supports.IOSPSetXChar))) { 2493 send_iosp_ext_cmd(edge_port, 2494 IOSP_CMD_SET_XON_CHAR, start_char); 2495 send_iosp_ext_cmd(edge_port, 2496 IOSP_CMD_SET_XOFF_CHAR, stop_char); 2497 } 2498 2499 /* if we are implementing INBOUND XON/XOFF */ 2500 if (I_IXOFF(tty)) { 2501 rxFlow |= IOSP_RX_FLOW_XON_XOFF; 2502 dev_dbg(dev, "%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n", 2503 __func__, start_char, stop_char); 2504 } else { 2505 dev_dbg(dev, "%s - INBOUND XON/XOFF is disabled\n", __func__); 2506 } 2507 2508 /* if we are implementing OUTBOUND XON/XOFF */ 2509 if (I_IXON(tty)) { 2510 txFlow |= IOSP_TX_FLOW_XON_XOFF; 2511 dev_dbg(dev, "%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n", 2512 __func__, start_char, stop_char); 2513 } else { 2514 dev_dbg(dev, "%s - OUTBOUND XON/XOFF is disabled\n", __func__); 2515 } 2516 } 2517 2518 /* Set flow control to the configured value */ 2519 if ((!edge_serial->is_epic) || 2520 ((edge_serial->is_epic) && 2521 (edge_serial->epic_descriptor.Supports.IOSPSetRxFlow))) 2522 send_iosp_ext_cmd(edge_port, IOSP_CMD_SET_RX_FLOW, rxFlow); 2523 if ((!edge_serial->is_epic) || 2524 ((edge_serial->is_epic) && 2525 (edge_serial->epic_descriptor.Supports.IOSPSetTxFlow))) 2526 send_iosp_ext_cmd(edge_port, IOSP_CMD_SET_TX_FLOW, txFlow); 2527 2528 2529 edge_port->shadowLCR &= ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK); 2530 edge_port->shadowLCR |= (lData | lParity | lStop); 2531 2532 edge_port->validDataMask = mask; 2533 2534 /* Send the updated LCR value to the EdgePort */ 2535 status = send_cmd_write_uart_register(edge_port, LCR, 2536 edge_port->shadowLCR); 2537 if (status != 0) 2538 return; 2539 2540 /* set up the MCR register and send it to the EdgePort */ 2541 edge_port->shadowMCR = MCR_MASTER_IE; 2542 if (cflag & CBAUD) 2543 edge_port->shadowMCR |= (MCR_DTR | MCR_RTS); 2544 2545 status = send_cmd_write_uart_register(edge_port, MCR, 2546 edge_port->shadowMCR); 2547 if (status != 0) 2548 return; 2549 2550 /* Determine divisor based on baud rate */ 2551 baud = tty_get_baud_rate(tty); 2552 if (!baud) { 2553 /* pick a default, any default... */ 2554 baud = 9600; 2555 } 2556 2557 dev_dbg(dev, "%s - baud rate = %d\n", __func__, baud); 2558 status = send_cmd_write_baud_rate(edge_port, baud); 2559 if (status == -1) { 2560 /* Speed change was not possible - put back the old speed */ 2561 baud = tty_termios_baud_rate(old_termios); 2562 tty_encode_baud_rate(tty, baud, baud); 2563 } 2564 } 2565 2566 2567 /**************************************************************************** 2568 * unicode_to_ascii 2569 * Turns a string from Unicode into ASCII. 2570 * Doesn't do a good job with any characters that are outside the normal 2571 * ASCII range, but it's only for debugging... 2572 * NOTE: expects the unicode in LE format 2573 ****************************************************************************/ 2574 static void unicode_to_ascii(char *string, int buflen, 2575 __le16 *unicode, int unicode_size) 2576 { 2577 int i; 2578 2579 if (buflen <= 0) /* never happens, but... */ 2580 return; 2581 --buflen; /* space for nul */ 2582 2583 for (i = 0; i < unicode_size; i++) { 2584 if (i >= buflen) 2585 break; 2586 string[i] = (char)(le16_to_cpu(unicode[i])); 2587 } 2588 string[i] = 0x00; 2589 } 2590 2591 2592 /**************************************************************************** 2593 * get_manufacturing_desc 2594 * reads in the manufacturing descriptor and stores it into the serial 2595 * structure. 2596 ****************************************************************************/ 2597 static void get_manufacturing_desc(struct edgeport_serial *edge_serial) 2598 { 2599 struct device *dev = &edge_serial->serial->dev->dev; 2600 int response; 2601 2602 dev_dbg(dev, "getting manufacturer descriptor\n"); 2603 2604 response = rom_read(edge_serial->serial, 2605 (EDGE_MANUF_DESC_ADDR & 0xffff0000) >> 16, 2606 (__u16)(EDGE_MANUF_DESC_ADDR & 0x0000ffff), 2607 EDGE_MANUF_DESC_LEN, 2608 (__u8 *)(&edge_serial->manuf_descriptor)); 2609 2610 if (response < 1) 2611 dev_err(dev, "error in getting manufacturer descriptor\n"); 2612 else { 2613 char string[30]; 2614 dev_dbg(dev, "**Manufacturer Descriptor\n"); 2615 dev_dbg(dev, " RomSize: %dK\n", 2616 edge_serial->manuf_descriptor.RomSize); 2617 dev_dbg(dev, " RamSize: %dK\n", 2618 edge_serial->manuf_descriptor.RamSize); 2619 dev_dbg(dev, " CpuRev: %d\n", 2620 edge_serial->manuf_descriptor.CpuRev); 2621 dev_dbg(dev, " BoardRev: %d\n", 2622 edge_serial->manuf_descriptor.BoardRev); 2623 dev_dbg(dev, " NumPorts: %d\n", 2624 edge_serial->manuf_descriptor.NumPorts); 2625 dev_dbg(dev, " DescDate: %d/%d/%d\n", 2626 edge_serial->manuf_descriptor.DescDate[0], 2627 edge_serial->manuf_descriptor.DescDate[1], 2628 edge_serial->manuf_descriptor.DescDate[2]+1900); 2629 unicode_to_ascii(string, sizeof(string), 2630 edge_serial->manuf_descriptor.SerialNumber, 2631 edge_serial->manuf_descriptor.SerNumLength/2); 2632 dev_dbg(dev, " SerialNumber: %s\n", string); 2633 unicode_to_ascii(string, sizeof(string), 2634 edge_serial->manuf_descriptor.AssemblyNumber, 2635 edge_serial->manuf_descriptor.AssemblyNumLength/2); 2636 dev_dbg(dev, " AssemblyNumber: %s\n", string); 2637 unicode_to_ascii(string, sizeof(string), 2638 edge_serial->manuf_descriptor.OemAssyNumber, 2639 edge_serial->manuf_descriptor.OemAssyNumLength/2); 2640 dev_dbg(dev, " OemAssyNumber: %s\n", string); 2641 dev_dbg(dev, " UartType: %d\n", 2642 edge_serial->manuf_descriptor.UartType); 2643 dev_dbg(dev, " IonPid: %d\n", 2644 edge_serial->manuf_descriptor.IonPid); 2645 dev_dbg(dev, " IonConfig: %d\n", 2646 edge_serial->manuf_descriptor.IonConfig); 2647 } 2648 } 2649 2650 2651 /**************************************************************************** 2652 * get_boot_desc 2653 * reads in the bootloader descriptor and stores it into the serial 2654 * structure. 2655 ****************************************************************************/ 2656 static void get_boot_desc(struct edgeport_serial *edge_serial) 2657 { 2658 struct device *dev = &edge_serial->serial->dev->dev; 2659 int response; 2660 2661 dev_dbg(dev, "getting boot descriptor\n"); 2662 2663 response = rom_read(edge_serial->serial, 2664 (EDGE_BOOT_DESC_ADDR & 0xffff0000) >> 16, 2665 (__u16)(EDGE_BOOT_DESC_ADDR & 0x0000ffff), 2666 EDGE_BOOT_DESC_LEN, 2667 (__u8 *)(&edge_serial->boot_descriptor)); 2668 2669 if (response < 1) 2670 dev_err(dev, "error in getting boot descriptor\n"); 2671 else { 2672 dev_dbg(dev, "**Boot Descriptor:\n"); 2673 dev_dbg(dev, " BootCodeLength: %d\n", 2674 le16_to_cpu(edge_serial->boot_descriptor.BootCodeLength)); 2675 dev_dbg(dev, " MajorVersion: %d\n", 2676 edge_serial->boot_descriptor.MajorVersion); 2677 dev_dbg(dev, " MinorVersion: %d\n", 2678 edge_serial->boot_descriptor.MinorVersion); 2679 dev_dbg(dev, " BuildNumber: %d\n", 2680 le16_to_cpu(edge_serial->boot_descriptor.BuildNumber)); 2681 dev_dbg(dev, " Capabilities: 0x%x\n", 2682 le16_to_cpu(edge_serial->boot_descriptor.Capabilities)); 2683 dev_dbg(dev, " UConfig0: %d\n", 2684 edge_serial->boot_descriptor.UConfig0); 2685 dev_dbg(dev, " UConfig1: %d\n", 2686 edge_serial->boot_descriptor.UConfig1); 2687 } 2688 } 2689 2690 2691 /**************************************************************************** 2692 * load_application_firmware 2693 * This is called to load the application firmware to the device 2694 ****************************************************************************/ 2695 static void load_application_firmware(struct edgeport_serial *edge_serial) 2696 { 2697 struct device *dev = &edge_serial->serial->dev->dev; 2698 const struct ihex_binrec *rec; 2699 const struct firmware *fw; 2700 const char *fw_name; 2701 const char *fw_info; 2702 int response; 2703 __u32 Operaddr; 2704 __u16 build; 2705 2706 switch (edge_serial->product_info.iDownloadFile) { 2707 case EDGE_DOWNLOAD_FILE_I930: 2708 fw_info = "downloading firmware version (930)"; 2709 fw_name = "edgeport/down.fw"; 2710 break; 2711 2712 case EDGE_DOWNLOAD_FILE_80251: 2713 fw_info = "downloading firmware version (80251)"; 2714 fw_name = "edgeport/down2.fw"; 2715 break; 2716 2717 case EDGE_DOWNLOAD_FILE_NONE: 2718 dev_dbg(dev, "No download file specified, skipping download\n"); 2719 return; 2720 2721 default: 2722 return; 2723 } 2724 2725 response = request_ihex_firmware(&fw, fw_name, 2726 &edge_serial->serial->dev->dev); 2727 if (response) { 2728 dev_err(dev, "Failed to load image \"%s\" err %d\n", 2729 fw_name, response); 2730 return; 2731 } 2732 2733 rec = (const struct ihex_binrec *)fw->data; 2734 build = (rec->data[2] << 8) | rec->data[3]; 2735 2736 dev_dbg(dev, "%s %d.%d.%d\n", fw_info, rec->data[0], rec->data[1], build); 2737 2738 edge_serial->product_info.FirmwareMajorVersion = rec->data[0]; 2739 edge_serial->product_info.FirmwareMinorVersion = rec->data[1]; 2740 edge_serial->product_info.FirmwareBuildNumber = cpu_to_le16(build); 2741 2742 for (rec = ihex_next_binrec(rec); rec; 2743 rec = ihex_next_binrec(rec)) { 2744 Operaddr = be32_to_cpu(rec->addr); 2745 response = sram_write(edge_serial->serial, 2746 Operaddr >> 16, 2747 Operaddr & 0xFFFF, 2748 be16_to_cpu(rec->len), 2749 &rec->data[0]); 2750 if (response < 0) { 2751 dev_err(&edge_serial->serial->dev->dev, 2752 "sram_write failed (%x, %x, %d)\n", 2753 Operaddr >> 16, Operaddr & 0xFFFF, 2754 be16_to_cpu(rec->len)); 2755 break; 2756 } 2757 } 2758 2759 dev_dbg(dev, "sending exec_dl_code\n"); 2760 response = usb_control_msg (edge_serial->serial->dev, 2761 usb_sndctrlpipe(edge_serial->serial->dev, 0), 2762 USB_REQUEST_ION_EXEC_DL_CODE, 2763 0x40, 0x4000, 0x0001, NULL, 0, 3000); 2764 2765 release_firmware(fw); 2766 } 2767 2768 2769 /**************************************************************************** 2770 * edge_startup 2771 ****************************************************************************/ 2772 static int edge_startup(struct usb_serial *serial) 2773 { 2774 struct edgeport_serial *edge_serial; 2775 struct usb_device *dev; 2776 struct device *ddev = &serial->dev->dev; 2777 int i; 2778 int response; 2779 bool interrupt_in_found; 2780 bool bulk_in_found; 2781 bool bulk_out_found; 2782 static __u32 descriptor[3] = { EDGE_COMPATIBILITY_MASK0, 2783 EDGE_COMPATIBILITY_MASK1, 2784 EDGE_COMPATIBILITY_MASK2 }; 2785 2786 dev = serial->dev; 2787 2788 /* create our private serial structure */ 2789 edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL); 2790 if (edge_serial == NULL) { 2791 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__); 2792 return -ENOMEM; 2793 } 2794 spin_lock_init(&edge_serial->es_lock); 2795 edge_serial->serial = serial; 2796 usb_set_serial_data(serial, edge_serial); 2797 2798 /* get the name for the device from the device */ 2799 i = usb_string(dev, dev->descriptor.iManufacturer, 2800 &edge_serial->name[0], MAX_NAME_LEN+1); 2801 if (i < 0) 2802 i = 0; 2803 edge_serial->name[i++] = ' '; 2804 usb_string(dev, dev->descriptor.iProduct, 2805 &edge_serial->name[i], MAX_NAME_LEN+2 - i); 2806 2807 dev_info(&serial->dev->dev, "%s detected\n", edge_serial->name); 2808 2809 /* Read the epic descriptor */ 2810 if (get_epic_descriptor(edge_serial) <= 0) { 2811 /* memcpy descriptor to Supports structures */ 2812 memcpy(&edge_serial->epic_descriptor.Supports, descriptor, 2813 sizeof(struct edge_compatibility_bits)); 2814 2815 /* get the manufacturing descriptor for this device */ 2816 get_manufacturing_desc(edge_serial); 2817 2818 /* get the boot descriptor */ 2819 get_boot_desc(edge_serial); 2820 2821 get_product_info(edge_serial); 2822 } 2823 2824 /* set the number of ports from the manufacturing description */ 2825 /* serial->num_ports = serial->product_info.NumPorts; */ 2826 if ((!edge_serial->is_epic) && 2827 (edge_serial->product_info.NumPorts != serial->num_ports)) { 2828 dev_warn(ddev, 2829 "Device Reported %d serial ports vs. core thinking we have %d ports, email greg@kroah.com this information.\n", 2830 edge_serial->product_info.NumPorts, 2831 serial->num_ports); 2832 } 2833 2834 dev_dbg(ddev, "%s - time 1 %ld\n", __func__, jiffies); 2835 2836 /* If not an EPiC device */ 2837 if (!edge_serial->is_epic) { 2838 /* now load the application firmware into this device */ 2839 load_application_firmware(edge_serial); 2840 2841 dev_dbg(ddev, "%s - time 2 %ld\n", __func__, jiffies); 2842 2843 /* Check current Edgeport EEPROM and update if necessary */ 2844 update_edgeport_E2PROM(edge_serial); 2845 2846 dev_dbg(ddev, "%s - time 3 %ld\n", __func__, jiffies); 2847 2848 /* set the configuration to use #1 */ 2849 /* dev_dbg(ddev, "set_configuration 1\n"); */ 2850 /* usb_set_configuration (dev, 1); */ 2851 } 2852 dev_dbg(ddev, " FirmwareMajorVersion %d.%d.%d\n", 2853 edge_serial->product_info.FirmwareMajorVersion, 2854 edge_serial->product_info.FirmwareMinorVersion, 2855 le16_to_cpu(edge_serial->product_info.FirmwareBuildNumber)); 2856 2857 /* we set up the pointers to the endpoints in the edge_open function, 2858 * as the structures aren't created yet. */ 2859 2860 response = 0; 2861 2862 if (edge_serial->is_epic) { 2863 /* EPIC thing, set up our interrupt polling now and our read 2864 * urb, so that the device knows it really is connected. */ 2865 interrupt_in_found = bulk_in_found = bulk_out_found = false; 2866 for (i = 0; i < serial->interface->altsetting[0] 2867 .desc.bNumEndpoints; ++i) { 2868 struct usb_endpoint_descriptor *endpoint; 2869 int buffer_size; 2870 2871 endpoint = &serial->interface->altsetting[0]. 2872 endpoint[i].desc; 2873 buffer_size = usb_endpoint_maxp(endpoint); 2874 if (!interrupt_in_found && 2875 (usb_endpoint_is_int_in(endpoint))) { 2876 /* we found a interrupt in endpoint */ 2877 dev_dbg(ddev, "found interrupt in\n"); 2878 2879 /* not set up yet, so do it now */ 2880 edge_serial->interrupt_read_urb = 2881 usb_alloc_urb(0, GFP_KERNEL); 2882 if (!edge_serial->interrupt_read_urb) { 2883 dev_err(ddev, "out of memory\n"); 2884 return -ENOMEM; 2885 } 2886 edge_serial->interrupt_in_buffer = 2887 kmalloc(buffer_size, GFP_KERNEL); 2888 if (!edge_serial->interrupt_in_buffer) { 2889 dev_err(ddev, "out of memory\n"); 2890 usb_free_urb(edge_serial->interrupt_read_urb); 2891 return -ENOMEM; 2892 } 2893 edge_serial->interrupt_in_endpoint = 2894 endpoint->bEndpointAddress; 2895 2896 /* set up our interrupt urb */ 2897 usb_fill_int_urb( 2898 edge_serial->interrupt_read_urb, 2899 dev, 2900 usb_rcvintpipe(dev, 2901 endpoint->bEndpointAddress), 2902 edge_serial->interrupt_in_buffer, 2903 buffer_size, 2904 edge_interrupt_callback, 2905 edge_serial, 2906 endpoint->bInterval); 2907 2908 interrupt_in_found = true; 2909 } 2910 2911 if (!bulk_in_found && 2912 (usb_endpoint_is_bulk_in(endpoint))) { 2913 /* we found a bulk in endpoint */ 2914 dev_dbg(ddev, "found bulk in\n"); 2915 2916 /* not set up yet, so do it now */ 2917 edge_serial->read_urb = 2918 usb_alloc_urb(0, GFP_KERNEL); 2919 if (!edge_serial->read_urb) { 2920 dev_err(ddev, "out of memory\n"); 2921 return -ENOMEM; 2922 } 2923 edge_serial->bulk_in_buffer = 2924 kmalloc(buffer_size, GFP_KERNEL); 2925 if (!edge_serial->bulk_in_buffer) { 2926 dev_err(&dev->dev, "out of memory\n"); 2927 usb_free_urb(edge_serial->read_urb); 2928 return -ENOMEM; 2929 } 2930 edge_serial->bulk_in_endpoint = 2931 endpoint->bEndpointAddress; 2932 2933 /* set up our bulk in urb */ 2934 usb_fill_bulk_urb(edge_serial->read_urb, dev, 2935 usb_rcvbulkpipe(dev, 2936 endpoint->bEndpointAddress), 2937 edge_serial->bulk_in_buffer, 2938 usb_endpoint_maxp(endpoint), 2939 edge_bulk_in_callback, 2940 edge_serial); 2941 bulk_in_found = true; 2942 } 2943 2944 if (!bulk_out_found && 2945 (usb_endpoint_is_bulk_out(endpoint))) { 2946 /* we found a bulk out endpoint */ 2947 dev_dbg(ddev, "found bulk out\n"); 2948 edge_serial->bulk_out_endpoint = 2949 endpoint->bEndpointAddress; 2950 bulk_out_found = true; 2951 } 2952 } 2953 2954 if (!interrupt_in_found || !bulk_in_found || !bulk_out_found) { 2955 dev_err(ddev, "Error - the proper endpoints were not found!\n"); 2956 return -ENODEV; 2957 } 2958 2959 /* start interrupt read for this edgeport this interrupt will 2960 * continue as long as the edgeport is connected */ 2961 response = usb_submit_urb(edge_serial->interrupt_read_urb, 2962 GFP_KERNEL); 2963 if (response) 2964 dev_err(ddev, "%s - Error %d submitting control urb\n", 2965 __func__, response); 2966 } 2967 return response; 2968 } 2969 2970 2971 /**************************************************************************** 2972 * edge_disconnect 2973 * This function is called whenever the device is removed from the usb bus. 2974 ****************************************************************************/ 2975 static void edge_disconnect(struct usb_serial *serial) 2976 { 2977 struct edgeport_serial *edge_serial = usb_get_serial_data(serial); 2978 2979 /* stop reads and writes on all ports */ 2980 /* free up our endpoint stuff */ 2981 if (edge_serial->is_epic) { 2982 usb_kill_urb(edge_serial->interrupt_read_urb); 2983 usb_free_urb(edge_serial->interrupt_read_urb); 2984 kfree(edge_serial->interrupt_in_buffer); 2985 2986 usb_kill_urb(edge_serial->read_urb); 2987 usb_free_urb(edge_serial->read_urb); 2988 kfree(edge_serial->bulk_in_buffer); 2989 } 2990 } 2991 2992 2993 /**************************************************************************** 2994 * edge_release 2995 * This function is called when the device structure is deallocated. 2996 ****************************************************************************/ 2997 static void edge_release(struct usb_serial *serial) 2998 { 2999 struct edgeport_serial *edge_serial = usb_get_serial_data(serial); 3000 3001 kfree(edge_serial); 3002 } 3003 3004 static int edge_port_probe(struct usb_serial_port *port) 3005 { 3006 struct edgeport_port *edge_port; 3007 3008 edge_port = kzalloc(sizeof(*edge_port), GFP_KERNEL); 3009 if (!edge_port) 3010 return -ENOMEM; 3011 3012 spin_lock_init(&edge_port->ep_lock); 3013 edge_port->port = port; 3014 3015 usb_set_serial_port_data(port, edge_port); 3016 3017 return 0; 3018 } 3019 3020 static int edge_port_remove(struct usb_serial_port *port) 3021 { 3022 struct edgeport_port *edge_port; 3023 3024 edge_port = usb_get_serial_port_data(port); 3025 kfree(edge_port); 3026 3027 return 0; 3028 } 3029 3030 module_usb_serial_driver(serial_drivers, id_table_combined); 3031 3032 MODULE_AUTHOR(DRIVER_AUTHOR); 3033 MODULE_DESCRIPTION(DRIVER_DESC); 3034 MODULE_LICENSE("GPL"); 3035 MODULE_FIRMWARE("edgeport/boot.fw"); 3036 MODULE_FIRMWARE("edgeport/boot2.fw"); 3037 MODULE_FIRMWARE("edgeport/down.fw"); 3038 MODULE_FIRMWARE("edgeport/down2.fw"); 3039