LXR linux/drivers/usb/serial/io

   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/*
  55 * Version Information
  56 */
  57#define DRIVER_VERSION "v2.7"
  58#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com> and David Iacovelli"
  59#define DRIVER_DESC "Edgeport USB Serial Driver"
  60
  61#define MAX_NAME_LEN            64
  62
  63#define CHASE_TIMEOUT           (5*HZ)          /* 5 seconds */
  64#define OPEN_TIMEOUT            (5*HZ)          /* 5 seconds */
  65#define COMMAND_TIMEOUT         (5*HZ)          /* 5 seconds */
  66
  67/* receive port state */
  68enum RXSTATE {
  69        EXPECT_HDR1 = 0,    /* Expect header byte 1 */
  70        EXPECT_HDR2 = 1,    /* Expect header byte 2 */
  71        EXPECT_DATA = 2,    /* Expect 'RxBytesRemaining' data */
  72        EXPECT_HDR3 = 3,    /* Expect header byte 3 (for status hdrs only) */
  73};
  74
  75
  76/* Transmit Fifo
  77 * This Transmit queue is an extension of the edgeport Rx buffer.
  78 * The maximum amount of data buffered in both the edgeport
  79 * Rx buffer (maxTxCredits) and this buffer will never exceed maxTxCredits.
  80 */
  81struct TxFifo {
  82        unsigned int    head;   /* index to head pointer (write) */
  83        unsigned int    tail;   /* index to tail pointer (read)  */
  84        unsigned int    count;  /* Bytes in queue */
  85        unsigned int    size;   /* Max size of queue (equal to Max number of TxCredits) */
  86        unsigned char   *fifo;  /* allocated Buffer */
  87};
  88
  89/* This structure holds all of the local port information */
  90struct edgeport_port {
  91        __u16                   txCredits;              /* our current credits for this port */
  92        __u16                   maxTxCredits;           /* the max size of the port */
  93
  94        struct TxFifo           txfifo;                 /* transmit fifo -- size will be maxTxCredits */
  95        struct urb              *write_urb;             /* write URB for this port */
  96        bool                    write_in_progress;      /* 'true' while a write URB is outstanding */
  97        spinlock_t              ep_lock;
  98
  99        __u8                    shadowLCR;              /* last LCR value received */
 100        __u8                    shadowMCR;              /* last MCR value received */
 101        __u8                    shadowMSR;              /* last MSR value received */
 102        __u8                    shadowLSR;              /* last LSR value received */
 103        __u8                    shadowXonChar;          /* last value set as XON char in Edgeport */
 104        __u8                    shadowXoffChar;         /* last value set as XOFF char in Edgeport */
 105        __u8                    validDataMask;
 106        __u32                   baudRate;
 107
 108        bool                    open;
 109        bool                    openPending;
 110        bool                    commandPending;
 111        bool                    closePending;
 112        bool                    chaseResponsePending;
 113
 114        wait_queue_head_t       wait_chase;             /* for handling sleeping while waiting for chase to finish */
 115        wait_queue_head_t       wait_open;              /* for handling sleeping while waiting for open to finish */
 116        wait_queue_head_t       wait_command;           /* for handling sleeping while waiting for command to finish */
 117        wait_queue_head_t       delta_msr_wait;         /* for handling sleeping while waiting for msr change to happen */
 118
 119        struct async_icount     icount;
 120        struct usb_serial_port  *port;                  /* loop back to the owner of this object */
 121};
 122
 123
 124/* This structure holds all of the individual device information */
 125struct edgeport_serial {
 126        char                    name[MAX_NAME_LEN+2];           /* string name of this device */
 127
 128        struct edge_manuf_descriptor    manuf_descriptor;       /* the manufacturer descriptor */
 129        struct edge_boot_descriptor     boot_descriptor;        /* the boot firmware descriptor */
 130        struct edgeport_product_info    product_info;           /* Product Info */
 131        struct edge_compatibility_descriptor epic_descriptor;   /* Edgeport compatible descriptor */
 132        int                     is_epic;                        /* flag if EPiC device or not */
 133
 134        __u8                    interrupt_in_endpoint;          /* the interrupt endpoint handle */
 135        unsigned char           *interrupt_in_buffer;           /* the buffer we use for the interrupt endpoint */
 136        struct urb              *interrupt_read_urb;            /* our interrupt urb */
 137
 138        __u8                    bulk_in_endpoint;               /* the bulk in endpoint handle */
 139        unsigned char           *bulk_in_buffer;                /* the buffer we use for the bulk in endpoint */
 140        struct urb              *read_urb;                      /* our bulk read urb */
 141        bool                    read_in_progress;
 142        spinlock_t              es_lock;
 143
 144        __u8                    bulk_out_endpoint;              /* the bulk out endpoint handle */
 145
 146        __s16                   rxBytesAvail;                   /* the number of bytes that we need to read from this device */
 147
 148        enum RXSTATE            rxState;                        /* the current state of the bulk receive processor */
 149        __u8                    rxHeader1;                      /* receive header byte 1 */
 150        __u8                    rxHeader2;                      /* receive header byte 2 */
 151        __u8                    rxHeader3;                      /* receive header byte 3 */
 152        __u8                    rxPort;                         /* the port that we are currently receiving data for */
 153        __u8                    rxStatusCode;                   /* the receive status code */
 154        __u8                    rxStatusParam;                  /* the receive status paramater */
 155        __s16                   rxBytesRemaining;               /* the number of port bytes left to read */
 156        struct usb_serial       *serial;                        /* loop back to the owner of this object */
 157};
 158
 159/* baud rate information */
 160struct divisor_table_entry {
 161        __u32   BaudRate;
 162        __u16  Divisor;
 163};
 164
 165/*
 166 * Define table of divisors for Rev A EdgePort/4 hardware
 167 * These assume a 3.6864MHz crystal, the standard /16, and
 168 * MCR.7 = 0.
 169 */
 170
 171static const struct divisor_table_entry divisor_table[] = {
 172        {   50,         4608},
 173        {   75,         3072},
 174        {   110,        2095},  /* 2094.545455 => 230450   => .0217 % over */
 175        {   134,        1713},  /* 1713.011152 => 230398.5 => .00065% under */
 176        {   150,        1536},
 177        {   300,        768},
 178        {   600,        384},
 179        {   1200,       192},
 180        {   1800,       128},
 181        {   2400,       96},
 182        {   4800,       48},
 183        {   7200,       32},
 184        {   9600,       24},
 185        {   14400,      16},
 186        {   19200,      12},
 187        {   38400,      6},
 188        {   57600,      4},
 189        {   115200,     2},
 190        {   230400,     1},
 191};
 192
 193/* local variables */
 194static int debug;
 195
 196static atomic_t CmdUrbs;        /* Number of outstanding Command Write Urbs */
 197
 198
 199/* local function prototypes */
 200
 201/* function prototypes for all URB callbacks */
 202static void edge_interrupt_callback(struct urb *urb);
 203static void edge_bulk_in_callback(struct urb *urb);
 204static void edge_bulk_out_data_callback(struct urb *urb);
 205static void edge_bulk_out_cmd_callback(struct urb *urb);
 206
 207/* function prototypes for the usbserial callbacks */
 208static int edge_open(struct tty_struct *tty, struct usb_serial_port *port);
 209static void edge_close(struct usb_serial_port *port);
 210static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
 211                                        const unsigned char *buf, int count);
 212static int edge_write_room(struct tty_struct *tty);
 213static int edge_chars_in_buffer(struct tty_struct *tty);
 214static void edge_throttle(struct tty_struct *tty);
 215static void edge_unthrottle(struct tty_struct *tty);
 216static void edge_set_termios(struct tty_struct *tty,
 217                                        struct usb_serial_port *port,
 218                                        struct ktermios *old_termios);
 219static int  edge_ioctl(struct tty_struct *tty, struct file *file,
 220                                        unsigned int cmd, unsigned long arg);
 221static void edge_break(struct tty_struct *tty, int break_state);
 222static int  edge_tiocmget(struct tty_struct *tty, struct file *file);
 223static int  edge_tiocmset(struct tty_struct *tty, struct file *file,
 224                                        unsigned int set, unsigned int clear);
 225static int  edge_startup(struct usb_serial *serial);
 226static void edge_disconnect(struct usb_serial *serial);
 227static void edge_release(struct usb_serial *serial);
 228
 229#include "io_tables.h"  /* all of the devices that this driver supports */
 230
 231/* function prototypes for all of our local functions */
 232
 233static void  process_rcvd_data(struct edgeport_serial *edge_serial,
 234                                unsigned char *buffer, __u16 bufferLength);
 235static void process_rcvd_status(struct edgeport_serial *edge_serial,
 236                                __u8 byte2, __u8 byte3);
 237static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
 238                                unsigned char *data, int length);
 239static void handle_new_msr(struct edgeport_port *edge_port, __u8 newMsr);
 240static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData,
 241                                __u8 lsr, __u8 data);
 242static int  send_iosp_ext_cmd(struct edgeport_port *edge_port, __u8 command,
 243                                __u8 param);
 244static int  calc_baud_rate_divisor(int baud_rate, int *divisor);
 245static int  send_cmd_write_baud_rate(struct edgeport_port *edge_port,
 246                                int baudRate);
 247static void change_port_settings(struct tty_struct *tty,
 248                                struct edgeport_port *edge_port,
 249                                struct ktermios *old_termios);
 250static int  send_cmd_write_uart_register(struct edgeport_port *edge_port,
 251                                __u8 regNum, __u8 regValue);
 252static int  write_cmd_usb(struct edgeport_port *edge_port,
 253                                unsigned char *buffer, int writeLength);
 254static void send_more_port_data(struct edgeport_serial *edge_serial,
 255                                struct edgeport_port *edge_port);
 256
 257static int sram_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
 258                                        __u16 length, const __u8 *data);
 259static int rom_read(struct usb_serial *serial, __u16 extAddr, __u16 addr,
 260                                                __u16 length, __u8 *data);
 261static int rom_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
 262                                        __u16 length, const __u8 *data);
 263static void get_manufacturing_desc(struct edgeport_serial *edge_serial);
 264static void get_boot_desc(struct edgeport_serial *edge_serial);
 265static void load_application_firmware(struct edgeport_serial *edge_serial);
 266
 267static void unicode_to_ascii(char *string, int buflen,
 268                                __le16 *unicode, int unicode_size);
 269
 270
 271/* ************************************************************************ */
 272/* ************************************************************************ */
 273/* ************************************************************************ */
 274/* ************************************************************************ */
 275
 276/************************************************************************
 277 *                                                                      *
 278 * update_edgeport_E2PROM()     Compare current versions of             *
 279 *                              Boot ROM and Manufacture                *
 280 *                              Descriptors with versions               *
 281 *                              embedded in this driver                 *
 282 *                                                                      *
 283 ************************************************************************/
 284static void update_edgeport_E2PROM(struct edgeport_serial *edge_serial)
 285{
 286        __u32 BootCurVer;
 287        __u32 BootNewVer;
 288        __u8 BootMajorVersion;
 289        __u8 BootMinorVersion;
 290        __u16 BootBuildNumber;
 291        __u32 Bootaddr;
 292        const struct ihex_binrec *rec;
 293        const struct firmware *fw;
 294        const char *fw_name;
 295        int response;
 296
 297        switch (edge_serial->product_info.iDownloadFile) {
 298        case EDGE_DOWNLOAD_FILE_I930:
 299                fw_name = "edgeport/boot.fw";
 300                break;
 301        case EDGE_DOWNLOAD_FILE_80251:
 302                fw_name = "edgeport/boot2.fw";
 303                break;
 304        default:
 305                return;
 306        }
 307
 308        response = request_ihex_firmware(&fw, fw_name,
 309                                         &edge_serial->serial->dev->dev);
 310        if (response) {
 311                printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
 312                       fw_name, response);
 313                return;
 314        }
 315
 316        rec = (const struct ihex_binrec *)fw->data;
 317        BootMajorVersion = rec->data[0];
 318        BootMinorVersion = rec->data[1];
 319        BootBuildNumber = (rec->data[2] << 8) | rec->data[3];
 320
 321        /* Check Boot Image Version */
 322        BootCurVer = (edge_serial->boot_descriptor.MajorVersion << 24) +
 323                     (edge_serial->boot_descriptor.MinorVersion << 16) +
 324                      le16_to_cpu(edge_serial->boot_descriptor.BuildNumber);
 325
 326        BootNewVer = (BootMajorVersion << 24) +
 327                     (BootMinorVersion << 16) +
 328                      BootBuildNumber;
 329
 330        dbg("Current Boot Image version %d.%d.%d",
 331            edge_serial->boot_descriptor.MajorVersion,
 332            edge_serial->boot_descriptor.MinorVersion,
 333            le16_to_cpu(edge_serial->boot_descriptor.BuildNumber));
 334
 335
 336        if (BootNewVer > BootCurVer) {
 337                dbg("**Update Boot Image from %d.%d.%d to %d.%d.%d",
 338                    edge_serial->boot_descriptor.MajorVersion,
 339                    edge_serial->boot_descriptor.MinorVersion,
 340                    le16_to_cpu(edge_serial->boot_descriptor.BuildNumber),
 341                    BootMajorVersion, BootMinorVersion, BootBuildNumber);
 342
 343                dbg("Downloading new Boot Image");
 344
 345                for (rec = ihex_next_binrec(rec); rec;
 346                     rec = ihex_next_binrec(rec)) {
 347                        Bootaddr = be32_to_cpu(rec->addr);
 348                        response = rom_write(edge_serial->serial,
 349                                             Bootaddr >> 16,
 350                                             Bootaddr & 0xFFFF,
 351                                             be16_to_cpu(rec->len),
 352                                             &rec->data[0]);
 353                        if (response < 0) {
 354                                dev_err(&edge_serial->serial->dev->dev,
 355                                        "rom_write failed (%x, %x, %d)\n",
 356                                        Bootaddr >> 16, Bootaddr & 0xFFFF,
 357                                        be16_to_cpu(rec->len));
 358                                break;
 359                        }
 360                }
 361        } else {
 362                dbg("Boot Image -- already up to date");
 363        }
 364        release_firmware(fw);
 365}
 366
 367
 368/************************************************************************
 369 *                                                                      *
 370 *  Get string descriptor from device                                   *
 371 *                                                                      *
 372 ************************************************************************/
 373static int get_string(struct usb_device *dev, int Id, char *string, int buflen)
 374{
 375        struct usb_string_descriptor StringDesc;
 376        struct usb_string_descriptor *pStringDesc;
 377
 378        dbg("%s - USB String ID = %d", __func__, Id);
 379
 380        if (!usb_get_descriptor(dev, USB_DT_STRING, Id,
 381                                        &StringDesc, sizeof(StringDesc)))
 382                return 0;
 383
 384        pStringDesc = kmalloc(StringDesc.bLength, GFP_KERNEL);
 385        if (!pStringDesc)
 386                return 0;
 387
 388        if (!usb_get_descriptor(dev, USB_DT_STRING, Id,
 389                                        pStringDesc, StringDesc.bLength)) {
 390                kfree(pStringDesc);
 391                return 0;
 392        }
 393
 394        unicode_to_ascii(string, buflen,
 395                                pStringDesc->wData, pStringDesc->bLength/2);
 396
 397        kfree(pStringDesc);
 398        dbg("%s - USB String %s", __func__, string);
 399        return strlen(string);
 400}
 401
 402
 403#if 0
 404/************************************************************************
 405 *
 406 *  Get string descriptor from device
 407 *
 408 ************************************************************************/
 409static int get_string_desc(struct usb_device *dev, int Id,
 410                                struct usb_string_descriptor **pRetDesc)
 411{
 412        struct usb_string_descriptor StringDesc;
 413        struct usb_string_descriptor *pStringDesc;
 414
 415        dbg("%s - USB String ID = %d", __func__, Id);
 416
 417        if (!usb_get_descriptor(dev, USB_DT_STRING, Id, &StringDesc,
 418                                                sizeof(StringDesc)))
 419                return 0;
 420
 421        pStringDesc = kmalloc(StringDesc.bLength, GFP_KERNEL);
 422        if (!pStringDesc)
 423                return -1;
 424
 425        if (!usb_get_descriptor(dev, USB_DT_STRING, Id, pStringDesc,
 426                                                        StringDesc.bLength)) {
 427                kfree(pStringDesc);
 428                return -1;
 429        }
 430
 431        *pRetDesc = pStringDesc;
 432        return 0;
 433}
 434#endif
 435
 436static void dump_product_info(struct edgeport_product_info *product_info)
 437{
 438        /* Dump Product Info structure */
 439        dbg("**Product Information:");
 440        dbg("  ProductId             %x", product_info->ProductId);
 441        dbg("  NumPorts              %d", product_info->NumPorts);
 442        dbg("  ProdInfoVer           %d", product_info->ProdInfoVer);
 443        dbg("  IsServer              %d", product_info->IsServer);
 444        dbg("  IsRS232               %d", product_info->IsRS232);
 445        dbg("  IsRS422               %d", product_info->IsRS422);
 446        dbg("  IsRS485               %d", product_info->IsRS485);
 447        dbg("  RomSize               %d", product_info->RomSize);
 448        dbg("  RamSize               %d", product_info->RamSize);
 449        dbg("  CpuRev                %x", product_info->CpuRev);
 450        dbg("  BoardRev              %x", product_info->BoardRev);
 451        dbg("  BootMajorVersion      %d.%d.%d", product_info->BootMajorVersion,
 452            product_info->BootMinorVersion,
 453            le16_to_cpu(product_info->BootBuildNumber));
 454        dbg("  FirmwareMajorVersion  %d.%d.%d",
 455                        product_info->FirmwareMajorVersion,
 456                        product_info->FirmwareMinorVersion,
 457                        le16_to_cpu(product_info->FirmwareBuildNumber));
 458        dbg("  ManufactureDescDate   %d/%d/%d",
 459                        product_info->ManufactureDescDate[0],
 460                        product_info->ManufactureDescDate[1],
 461                        product_info->ManufactureDescDate[2]+1900);
 462        dbg("  iDownloadFile         0x%x", product_info->iDownloadFile);
 463        dbg("  EpicVer               %d", product_info->EpicVer);
 464}
 465
 466static void get_product_info(struct edgeport_serial *edge_serial)
 467{
 468        struct edgeport_product_info *product_info = &edge_serial->product_info;
 469
 470        memset(product_info, 0, sizeof(struct edgeport_product_info));
 471
 472        product_info->ProductId = (__u16)(le16_to_cpu(edge_serial->serial->dev->descriptor.idProduct) & ~ION_DEVICE_ID_80251_NETCHIP);
 473        product_info->NumPorts = edge_serial->manuf_descriptor.NumPorts;
 474        product_info->ProdInfoVer = 0;
 475
 476        product_info->RomSize = edge_serial->manuf_descriptor.RomSize;
 477        product_info->RamSize = edge_serial->manuf_descriptor.RamSize;
 478        product_info->CpuRev = edge_serial->manuf_descriptor.CpuRev;
 479        product_info->BoardRev = edge_serial->manuf_descriptor.BoardRev;
 480
 481        product_info->BootMajorVersion =
 482                                edge_serial->boot_descriptor.MajorVersion;
 483        product_info->BootMinorVersion =
 484                                edge_serial->boot_descriptor.MinorVersion;
 485        product_info->BootBuildNumber =
 486                                edge_serial->boot_descriptor.BuildNumber;
 487
 488        memcpy(product_info->ManufactureDescDate,
 489                        edge_serial->manuf_descriptor.DescDate,
 490                        sizeof(edge_serial->manuf_descriptor.DescDate));
 491
 492        /* check if this is 2nd generation hardware */
 493        if (le16_to_cpu(edge_serial->serial->dev->descriptor.idProduct)
 494                                            & ION_DEVICE_ID_80251_NETCHIP)
 495                product_info->iDownloadFile = EDGE_DOWNLOAD_FILE_80251;
 496        else
 497                product_info->iDownloadFile = EDGE_DOWNLOAD_FILE_I930;
 498 
 499        /* Determine Product type and set appropriate flags */
 500        switch (DEVICE_ID_FROM_USB_PRODUCT_ID(product_info->ProductId)) {
 501        case ION_DEVICE_ID_EDGEPORT_COMPATIBLE:
 502        case ION_DEVICE_ID_EDGEPORT_4T:
 503        case ION_DEVICE_ID_EDGEPORT_4:
 504        case ION_DEVICE_ID_EDGEPORT_2:
 505        case ION_DEVICE_ID_EDGEPORT_8_DUAL_CPU:
 506        case ION_DEVICE_ID_EDGEPORT_8:
 507        case ION_DEVICE_ID_EDGEPORT_421:
 508        case ION_DEVICE_ID_EDGEPORT_21:
 509        case ION_DEVICE_ID_EDGEPORT_2_DIN:
 510        case ION_DEVICE_ID_EDGEPORT_4_DIN:
 511        case ION_DEVICE_ID_EDGEPORT_16_DUAL_CPU:
 512                product_info->IsRS232 = 1;
 513                break;
 514
 515        case ION_DEVICE_ID_EDGEPORT_2I: /* Edgeport/2 RS422/RS485 */
 516                product_info->IsRS422 = 1;
 517                product_info->IsRS485 = 1;
 518                break;
 519
 520        case ION_DEVICE_ID_EDGEPORT_8I: /* Edgeport/4 RS422 */
 521        case ION_DEVICE_ID_EDGEPORT_4I: /* Edgeport/4 RS422 */
 522                product_info->IsRS422 = 1;
 523                break;
 524        }
 525
 526        dump_product_info(product_info);
 527}
 528
 529static int get_epic_descriptor(struct edgeport_serial *ep)
 530{
 531        int result;
 532        struct usb_serial *serial = ep->serial;
 533        struct edgeport_product_info *product_info = &ep->product_info;
 534        struct edge_compatibility_descriptor *epic = &ep->epic_descriptor;
 535        struct edge_compatibility_bits *bits;
 536
 537        ep->is_epic = 0;
 538        result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 539                                 USB_REQUEST_ION_GET_EPIC_DESC,
 540                                 0xC0, 0x00, 0x00,
 541                                 &ep->epic_descriptor,
 542                                 sizeof(struct edge_compatibility_descriptor),
 543                                 300);
 544
 545        dbg("%s result = %d", __func__, result);
 546
 547        if (result > 0) {
 548                ep->is_epic = 1;
 549                memset(product_info, 0, sizeof(struct edgeport_product_info));
 550
 551                product_info->NumPorts = epic->NumPorts;
 552                product_info->ProdInfoVer = 0;
 553                product_info->FirmwareMajorVersion = epic->MajorVersion;
 554                product_info->FirmwareMinorVersion = epic->MinorVersion;
 555                product_info->FirmwareBuildNumber = epic->BuildNumber;
 556                product_info->iDownloadFile = epic->iDownloadFile;
 557                product_info->EpicVer = epic->EpicVer;
 558                product_info->Epic = epic->Supports;
 559                product_info->ProductId = ION_DEVICE_ID_EDGEPORT_COMPATIBLE;
 560                dump_product_info(product_info);
 561
 562                bits = &ep->epic_descriptor.Supports;
 563                dbg("**EPIC descriptor:");
 564                dbg("  VendEnableSuspend: %s", bits->VendEnableSuspend  ? "TRUE": "FALSE");
 565                dbg("  IOSPOpen         : %s", bits->IOSPOpen           ? "TRUE": "FALSE");
 566                dbg("  IOSPClose        : %s", bits->IOSPClose          ? "TRUE": "FALSE");
 567                dbg("  IOSPChase        : %s", bits->IOSPChase          ? "TRUE": "FALSE");
 568                dbg("  IOSPSetRxFlow    : %s", bits->IOSPSetRxFlow      ? "TRUE": "FALSE");
 569                dbg("  IOSPSetTxFlow    : %s", bits->IOSPSetTxFlow      ? "TRUE": "FALSE");
 570                dbg("  IOSPSetXChar     : %s", bits->IOSPSetXChar       ? "TRUE": "FALSE");
 571                dbg("  IOSPRxCheck      : %s", bits->IOSPRxCheck        ? "TRUE": "FALSE");
 572                dbg("  IOSPSetClrBreak  : %s", bits->IOSPSetClrBreak    ? "TRUE": "FALSE");
 573                dbg("  IOSPWriteMCR     : %s", bits->IOSPWriteMCR       ? "TRUE": "FALSE");
 574                dbg("  IOSPWriteLCR     : %s", bits->IOSPWriteLCR       ? "TRUE": "FALSE");
 575                dbg("  IOSPSetBaudRate  : %s", bits->IOSPSetBaudRate    ? "TRUE": "FALSE");
 576                dbg("  TrueEdgeport     : %s", bits->TrueEdgeport       ? "TRUE": "FALSE");
 577        }
 578
 579        return result;
 580}
 581
 582
 583/************************************************************************/
 584/************************************************************************/
 585/*            U S B  C A L L B A C K   F U N C T I O N S                */
 586/*            U S B  C A L L B A C K   F U N C T I O N S                */
 587/************************************************************************/
 588/************************************************************************/
 589
 590/*****************************************************************************
 591 * edge_interrupt_callback
 592 *      this is the callback function for when we have received data on the
 593 *      interrupt endpoint.
 594 *****************************************************************************/
 595static void edge_interrupt_callback(struct urb *urb)
 596{
 597        struct edgeport_serial  *edge_serial = urb->context;
 598        struct edgeport_port *edge_port;
 599        struct usb_serial_port *port;
 600        struct tty_struct *tty;
 601        unsigned char *data = urb->transfer_buffer;
 602        int length = urb->actual_length;
 603        int bytes_avail;
 604        int position;
 605        int txCredits;
 606        int portNumber;
 607        int result;
 608        int status = urb->status;
 609
 610        dbg("%s", __func__);
 611
 612        switch (status) {
 613        case 0:
 614                /* success */
 615                break;
 616        case -ECONNRESET:
 617        case -ENOENT:
 618        case -ESHUTDOWN:
 619                /* this urb is terminated, clean up */
 620                dbg("%s - urb shutting down with status: %d",
 621                                                __func__, status);
 622                return;
 623        default:
 624                dbg("%s - nonzero urb status received: %d", __func__, status);
 625                goto exit;
 626        }
 627
 628        /* process this interrupt-read even if there are no ports open */
 629        if (length) {
 630                usb_serial_debug_data(debug, &edge_serial->serial->dev->dev,
 631                                                __func__, length, data);
 632
 633                if (length > 1) {
 634                        bytes_avail = data[0] | (data[1] << 8);
 635                        if (bytes_avail) {
 636                                spin_lock(&edge_serial->es_lock);
 637                                edge_serial->rxBytesAvail += bytes_avail;
 638                                dbg("%s - bytes_avail=%d, rxBytesAvail=%d, read_in_progress=%d", __func__, bytes_avail, edge_serial->rxBytesAvail, edge_serial->read_in_progress);
 639
 640                                if (edge_serial->rxBytesAvail > 0 &&
 641                                    !edge_serial->read_in_progress) {
 642                                        dbg("%s - posting a read", __func__);
 643                                        edge_serial->read_in_progress = true;
 644
 645                                        /* we have pending bytes on the
 646                                           bulk in pipe, send a request */
 647                                        edge_serial->read_urb->dev = edge_serial->serial->dev;
 648                                        result = usb_submit_urb(edge_serial->read_urb, GFP_ATOMIC);
 649                                        if (result) {
 650                                                dev_err(&edge_serial->serial->dev->dev, "%s - usb_submit_urb(read bulk) failed with result = %d\n", __func__, result);
 651                                                edge_serial->read_in_progress = false;
 652                                        }
 653                                }
 654                                spin_unlock(&edge_serial->es_lock);
 655                        }
 656                }
 657                /* grab the txcredits for the ports if available */
 658                position = 2;
 659                portNumber = 0;
 660                while ((position < length) &&
 661                                (portNumber < edge_serial->serial->num_ports)) {
 662                        txCredits = data[position] | (data[position+1] << 8);
 663                        if (txCredits) {
 664                                port = edge_serial->serial->port[portNumber];
 665                                edge_port = usb_get_serial_port_data(port);
 666                                if (edge_port->open) {
 667                                        spin_lock(&edge_port->ep_lock);
 668                                        edge_port->txCredits += txCredits;
 669                                        spin_unlock(&edge_port->ep_lock);
 670                                        dbg("%s - txcredits for port%d = %d",
 671                                                        __func__, portNumber,
 672                                                        edge_port->txCredits);
 673
 674                                        /* tell the tty driver that something
 675                                           has changed */
 676                                        tty = tty_port_tty_get(
 677                                                &edge_port->port->port);
 678                                        if (tty) {
 679                                                tty_wakeup(tty);
 680                                                tty_kref_put(tty);
 681                                        }
 682                                        /* Since we have more credit, check
 683                                           if more data can be sent */
 684                                        send_more_port_data(edge_serial,
 685                                                                edge_port);
 686                                }
 687                        }
 688                        position += 2;
 689                        ++portNumber;
 690                }
 691        }
 692
 693exit:
 694        result = usb_submit_urb(urb, GFP_ATOMIC);
 695        if (result)
 696                dev_err(&urb->dev->dev,
 697                        "%s - Error %d submitting control urb\n",
 698                                                __func__, result);
 699}
 700
 701
 702/*****************************************************************************
 703 * edge_bulk_in_callback
 704 *      this is the callback function for when we have received data on the
 705 *      bulk in endpoint.
 706 *****************************************************************************/
 707static void edge_bulk_in_callback(struct urb *urb)
 708{
 709        struct edgeport_serial  *edge_serial = urb->context;
 710        unsigned char           *data = urb->transfer_buffer;
 711        int                     retval;
 712        __u16                   raw_data_length;
 713        int status = urb->status;
 714
 715        dbg("%s", __func__);
 716
 717        if (status) {
 718                dbg("%s - nonzero read bulk status received: %d",
 719                    __func__, status);
 720                edge_serial->read_in_progress = false;
 721                return;
 722        }
 723
 724        if (urb->actual_length == 0) {
 725                dbg("%s - read bulk callback with no data", __func__);
 726                edge_serial->read_in_progress = false;
 727                return;
 728        }
 729
 730        raw_data_length = urb->actual_length;
 731
 732        usb_serial_debug_data(debug, &edge_serial->serial->dev->dev,
 733                                        __func__, raw_data_length, data);
 734
 735        spin_lock(&edge_serial->es_lock);
 736
 737        /* decrement our rxBytes available by the number that we just got */
 738        edge_serial->rxBytesAvail -= raw_data_length;
 739
 740        dbg("%s - Received = %d, rxBytesAvail %d", __func__,
 741                                raw_data_length, edge_serial->rxBytesAvail);
 742
 743        process_rcvd_data(edge_serial, data, urb->actual_length);
 744
 745        /* check to see if there's any more data for us to read */
 746        if (edge_serial->rxBytesAvail > 0) {
 747                dbg("%s - posting a read", __func__);
 748                edge_serial->read_urb->dev = edge_serial->serial->dev;
 749                retval = usb_submit_urb(edge_serial->read_urb, GFP_ATOMIC);
 750                if (retval) {
 751                        dev_err(&urb->dev->dev,
 752                                "%s - usb_submit_urb(read bulk) failed, "
 753                                "retval = %d\n", __func__, retval);
 754                        edge_serial->read_in_progress = false;
 755                }
 756        } else {
 757                edge_serial->read_in_progress = false;
 758        }
 759
 760        spin_unlock(&edge_serial->es_lock);
 761}
 762
 763
 764/*****************************************************************************
 765 * edge_bulk_out_data_callback
 766 *      this is the callback function for when we have finished sending
 767 *      serial data on the bulk out endpoint.
 768 *****************************************************************************/
 769static void edge_bulk_out_data_callback(struct urb *urb)
 770{
 771        struct edgeport_port *edge_port = urb->context;
 772        struct tty_struct *tty;
 773        int status = urb->status;
 774
 775        dbg("%s", __func__);
 776
 777        if (status) {
 778                dbg("%s - nonzero write bulk status received: %d",
 779                    __func__, status);
 780        }
 781
 782        tty = tty_port_tty_get(&edge_port->port->port);
 783
 784        if (tty && edge_port->open) {
 785                /* let the tty driver wakeup if it has a special
 786                   write_wakeup function */
 787                tty_wakeup(tty);
 788        }
 789        tty_kref_put(tty);
 790
 791        /* Release the Write URB */
 792        edge_port->write_in_progress = false;
 793
 794        /* Check if more data needs to be sent */
 795        send_more_port_data((struct edgeport_serial *)
 796                (usb_get_serial_data(edge_port->port->serial)), edge_port);
 797}
 798
 799
 800/*****************************************************************************
 801 * BulkOutCmdCallback
 802 *      this is the callback function for when we have finished sending a
 803 *      command on the bulk out endpoint.
 804 *****************************************************************************/
 805static void edge_bulk_out_cmd_callback(struct urb *urb)
 806{
 807        struct edgeport_port *edge_port = urb->context;
 808        struct tty_struct *tty;
 809        int status = urb->status;
 810
 811        dbg("%s", __func__);
 812
 813        atomic_dec(&CmdUrbs);
 814        dbg("%s - FREE URB %p (outstanding %d)", __func__,
 815                                        urb, atomic_read(&CmdUrbs));
 816
 817
 818        /* clean up the transfer buffer */
 819        kfree(urb->transfer_buffer);
 820
 821        /* Free the command urb */
 822        usb_free_urb(urb);
 823
 824        if (status) {
 825                dbg("%s - nonzero write bulk status received: %d",
 826                                                        __func__, status);
 827                return;
 828        }
 829
 830        /* Get pointer to tty */
 831        tty = tty_port_tty_get(&edge_port->port->port);
 832
 833        /* tell the tty driver that something has changed */
 834        if (tty && edge_port->open)
 835                tty_wakeup(tty);
 836        tty_kref_put(tty);
 837
 838        /* we have completed the command */
 839        edge_port->commandPending = false;
 840        wake_up(&edge_port->wait_command);
 841}
 842
 843
 844/*****************************************************************************
 845 * Driver tty interface functions
 846 *****************************************************************************/
 847
 848/*****************************************************************************
 849 * SerialOpen
 850 *      this function is called by the tty driver when a port is opened
 851 *      If successful, we return 0
 852 *      Otherwise we return a negative error number.
 853 *****************************************************************************/
 854static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
 855{
 856        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
 857        struct usb_serial *serial;
 858        struct edgeport_serial *edge_serial;
 859        int response;
 860
 861        dbg("%s - port %d", __func__, port->number);
 862
 863        if (edge_port == NULL)
 864                return -ENODEV;
 865
 866        /* see if we've set up our endpoint info yet (can't set it up
 867           in edge_startup as the structures were not set up at that time.) */
 868        serial = port->serial;
 869        edge_serial = usb_get_serial_data(serial);
 870        if (edge_serial == NULL)
 871                return -ENODEV;
 872        if (edge_serial->interrupt_in_buffer == NULL) {
 873                struct usb_serial_port *port0 = serial->port[0];
 874
 875                /* not set up yet, so do it now */
 876                edge_serial->interrupt_in_buffer =
 877                                        port0->interrupt_in_buffer;
 878                edge_serial->interrupt_in_endpoint =
 879                                        port0->interrupt_in_endpointAddress;
 880                edge_serial->interrupt_read_urb = port0->interrupt_in_urb;
 881                edge_serial->bulk_in_buffer = port0->bulk_in_buffer;
 882                edge_serial->bulk_in_endpoint =
 883                                        port0->bulk_in_endpointAddress;
 884                edge_serial->read_urb = port0->read_urb;
 885                edge_serial->bulk_out_endpoint =
 886                                        port0->bulk_out_endpointAddress;
 887
 888                /* set up our interrupt urb */
 889                usb_fill_int_urb(edge_serial->interrupt_read_urb,
 890                      serial->dev,
 891                      usb_rcvintpipe(serial->dev,
 892                                port0->interrupt_in_endpointAddress),
 893                      port0->interrupt_in_buffer,
 894                      edge_serial->interrupt_read_urb->transfer_buffer_length,
 895                      edge_interrupt_callback, edge_serial,
 896                      edge_serial->interrupt_read_urb->interval);
 897
 898                /* set up our bulk in urb */
 899                usb_fill_bulk_urb(edge_serial->read_urb, serial->dev,
 900                        usb_rcvbulkpipe(serial->dev,
 901                                port0->bulk_in_endpointAddress),
 902                        port0->bulk_in_buffer,
 903                        edge_serial->read_urb->transfer_buffer_length,
 904                        edge_bulk_in_callback, edge_serial);
 905                edge_serial->read_in_progress = false;
 906
 907                /* start interrupt read for this edgeport
 908                 * this interrupt will continue as long
 909                 * as the edgeport is connected */
 910                response = usb_submit_urb(edge_serial->interrupt_read_urb,
 911                                                                GFP_KERNEL);
 912                if (response) {
 913                        dev_err(&port->dev,
 914                                "%s - Error %d submitting control urb\n",
 915                                                        __func__, response);
 916                }
 917        }
 918
 919        /* initialize our wait queues */
 920        init_waitqueue_head(&edge_port->wait_open);
 921        init_waitqueue_head(&edge_port->wait_chase);
 922        init_waitqueue_head(&edge_port->delta_msr_wait);
 923        init_waitqueue_head(&edge_port->wait_command);
 924
 925        /* initialize our icount structure */
 926        memset(&(edge_port->icount), 0x00, sizeof(edge_port->icount));
 927
 928        /* initialize our port settings */
 929        edge_port->txCredits = 0;       /* Can't send any data yet */
 930        /* Must always set this bit to enable ints! */
 931        edge_port->shadowMCR = MCR_MASTER_IE;
 932        edge_port->chaseResponsePending = false;
 933
 934        /* send a open port command */
 935        edge_port->openPending = true;
 936        edge_port->open        = false;
 937        response = send_iosp_ext_cmd(edge_port, IOSP_CMD_OPEN_PORT, 0);
 938
 939        if (response < 0) {
 940                dev_err(&port->dev, "%s - error sending open port command\n",
 941                                                                __func__);
 942                edge_port->openPending = false;
 943                return -ENODEV;
 944        }
 945
 946        /* now wait for the port to be completely opened */
 947        wait_event_timeout(edge_port->wait_open, !edge_port->openPending,
 948                                                                OPEN_TIMEOUT);
 949
 950        if (!edge_port->open) {
 951                /* open timed out */
 952                dbg("%s - open timedout", __func__);
 953                edge_port->openPending = false;
 954                return -ENODEV;
 955        }
 956
 957        /* create the txfifo */
 958        edge_port->txfifo.head  = 0;
 959        edge_port->txfifo.tail  = 0;
 960        edge_port->txfifo.count = 0;
 961        edge_port->txfifo.size  = edge_port->maxTxCredits;
 962        edge_port->txfifo.fifo  = kmalloc(edge_port->maxTxCredits, GFP_KERNEL);
 963
 964        if (!edge_port->txfifo.fifo) {
 965                dbg("%s - no memory", __func__);
 966                edge_close(port);
 967                return -ENOMEM;
 968        }
 969
 970        /* Allocate a URB for the write */
 971        edge_port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
 972        edge_port->write_in_progress = false;
 973
 974        if (!edge_port->write_urb) {
 975                dbg("%s - no memory", __func__);
 976                edge_close(port);
 977                return -ENOMEM;
 978        }
 979
 980        dbg("%s(%d) - Initialize TX fifo to %d bytes",
 981                        __func__, port->number, edge_port->maxTxCredits);
 982
 983        dbg("%s exited", __func__);
 984
 985        return 0;
 986}
 987
 988
 989/************************************************************************
 990 *
 991 * block_until_chase_response
 992 *
 993 *      This function will block the close until one of the following:
 994 *              1. Response to our Chase comes from Edgeport
 995 *              2. A timeout of 10 seconds without activity has expired
 996 *                 (1K of Edgeport data @ 2400 baud ==> 4 sec to empty)
 997 *
 998 ************************************************************************/
 999static void block_until_chase_response(struct edgeport_port *edge_port)
1000{

1001        DEFINE_WAIT(wait);
1002        __u16 lastCredits;
1003        int timeout = 1*HZ;
1004        int loop = 10;
1005
1006        while (1) {
1007                /* Save Last credits */
1008                lastCredits = edge_port->txCredits;
1009
1010                /* Did we get our Chase response */
1011                if (!edge_port->chaseResponsePending) {
1012                        dbg("%s - Got Chase Response", __func__);
1013
1014                        /* did we get all of our credit back? */
1015                        if (edge_port->txCredits == edge_port->maxTxCredits) {
1016                                dbg("%s - Got all credits", __func__);
1017                                return;
1018                        }
1019                }
1020
1021                /* Block the thread for a while */
1022                prepare_to_wait(&edge_port->wait_chase, &wait,
1023                                                TASK_UNINTERRUPTIBLE);
1024                schedule_timeout(timeout);
1025                finish_wait(&edge_port->wait_chase, &wait);
1026
1027                if (lastCredits == edge_port->txCredits) {
1028                        /* No activity.. count down. */
1029                        loop--;
1030                        if (loop == 0) {
1031                                edge_port->chaseResponsePending = false;
1032                                dbg("%s - Chase TIMEOUT", __func__);
1033                                return;
1034                        }
1035                } else {
1036                        /* Reset timeout value back to 10 seconds */
1037                        dbg("%s - Last %d, Current %d", __func__,
1038                                        lastCredits, edge_port->txCredits);
1039                        loop = 10;
1040                }
1041        }
1042}
1043
1044
1045/************************************************************************
1046 *
1047 * block_until_tx_empty
1048 *
1049 *      This function will block the close until one of the following:
1050 *              1. TX count are 0
1051 *              2. The edgeport has stopped
1052 *              3. A timeout of 3 seconds without activity has expired
1053 *
1054 ************************************************************************/
1055static void block_until_tx_empty(struct edgeport_port *edge_port)
1056{
1057        DEFINE_WAIT(wait);
1058        struct TxFifo *fifo = &edge_port->txfifo;
1059        __u32 lastCount;
1060        int timeout = HZ/10;
1061        int loop = 30;
1062
1063        while (1) {
1064                /* Save Last count */
1065                lastCount = fifo->count;
1066
1067                /* Is the Edgeport Buffer empty? */
1068                if (lastCount == 0) {
1069                        dbg("%s - TX Buffer Empty", __func__);
1070                        return;
1071                }
1072
1073                /* Block the thread for a while */
1074                prepare_to_wait(&edge_port->wait_chase, &wait,
1075                                                TASK_UNINTERRUPTIBLE);
1076                schedule_timeout(timeout);
1077                finish_wait(&edge_port->wait_chase, &wait);
1078
1079                dbg("%s wait", __func__);
1080
1081                if (lastCount == fifo->count) {
1082                        /* No activity.. count down. */
1083                        loop--;
1084                        if (loop == 0) {
1085                                dbg("%s - TIMEOUT", __func__);
1086                                return;
1087                        }
1088                } else {
1089                        /* Reset timeout value back to seconds */
1090                        loop = 30;
1091                }
1092        }
1093}
1094
1095
1096/*****************************************************************************
1097 * edge_close
1098 *      this function is called by the tty driver when a port is closed
1099 *****************************************************************************/
1100static void edge_close(struct usb_serial_port *port)
1101{
1102        struct edgeport_serial *edge_serial;
1103        struct edgeport_port *edge_port;
1104        int status;
1105
1106        dbg("%s - port %d", __func__, port->number);
1107
1108        edge_serial = usb_get_serial_data(port->serial);
1109        edge_port = usb_get_serial_port_data(port);
1110        if (edge_serial == NULL || edge_port == NULL)
1111                return;
1112
1113        /* block until tx is empty */
1114        block_until_tx_empty(edge_port);
1115
1116        edge_port->closePending = true;
1117
1118        if ((!edge_serial->is_epic) ||
1119            ((edge_serial->is_epic) &&
1120             (edge_serial->epic_descriptor.Supports.IOSPChase))) {
1121                /* flush and chase */
1122                edge_port->chaseResponsePending = true;
1123
1124                dbg("%s - Sending IOSP_CMD_CHASE_PORT", __func__);
1125                status = send_iosp_ext_cmd(edge_port, IOSP_CMD_CHASE_PORT, 0);
1126                if (status == 0)
1127                        /* block until chase finished */
1128                        block_until_chase_response(edge_port);
1129                else
1130                        edge_port->chaseResponsePending = false;
1131        }
1132
1133        if ((!edge_serial->is_epic) ||
1134            ((edge_serial->is_epic) &&
1135             (edge_serial->epic_descriptor.Supports.IOSPClose))) {
1136               /* close the port */
1137                dbg("%s - Sending IOSP_CMD_CLOSE_PORT", __func__);
1138                send_iosp_ext_cmd(edge_port, IOSP_CMD_CLOSE_PORT, 0);
1139        }
1140
1141        /* port->close = true; */
1142        edge_port->closePending = false;
1143        edge_port->open = false;
1144        edge_port->openPending = false;
1145
1146        usb_kill_urb(edge_port->write_urb);
1147
1148        if (edge_port->write_urb) {
1149                /* if this urb had a transfer buffer already
1150                                (old transfer) free it */
1151                kfree(edge_port->write_urb->transfer_buffer);
1152                usb_free_urb(edge_port->write_urb);
1153                edge_port->write_urb = NULL;
1154        }
1155        kfree(edge_port->txfifo.fifo);
1156        edge_port->txfifo.fifo = NULL;
1157
1158        dbg("%s exited", __func__);
1159}
1160
1161/*****************************************************************************
1162 * SerialWrite
1163 *      this function is called by the tty driver when data should be written
1164 *      to the port.
1165 *      If successful, we return the number of bytes written, otherwise we
1166 *      return a negative error number.
1167 *****************************************************************************/
1168static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
1169                                        const unsigned char *data, int count)
1170{
1171        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1172        struct TxFifo *fifo;
1173        int copySize;
1174        int bytesleft;
1175        int firsthalf;
1176        int secondhalf;
1177        unsigned long flags;
1178
1179        dbg("%s - port %d", __func__, port->number);
1180
1181        if (edge_port == NULL)
1182                return -ENODEV;
1183
1184        /* get a pointer to the Tx fifo */
1185        fifo = &edge_port->txfifo;
1186
1187        spin_lock_irqsave(&edge_port->ep_lock, flags);
1188
1189        /* calculate number of bytes to put in fifo */
1190        copySize = min((unsigned int)count,
1191                                (edge_port->txCredits - fifo->count));
1192
1193        dbg("%s(%d) of %d byte(s) Fifo room  %d -- will copy %d bytes",
1194                        __func__, port->number, count,
1195                        edge_port->txCredits - fifo->count, copySize);
1196
1197        /* catch writes of 0 bytes which the tty driver likes to give us,
1198           and when txCredits is empty */
1199        if (copySize == 0) {
1200                dbg("%s - copySize = Zero", __func__);
1201                goto finish_write;
1202        }
1203
1204        /* queue the data
1205         * since we can never overflow the buffer we do not have to check for a
1206         * full condition
1207         *
1208         * the copy is done is two parts -- first fill to the end of the buffer
1209         * then copy the reset from the start of the buffer
1210         */
1211        bytesleft = fifo->size - fifo->head;
1212        firsthalf = min(bytesleft, copySize);
1213        dbg("%s - copy %d bytes of %d into fifo ", __func__,
1214                                        firsthalf, bytesleft);
1215
1216        /* now copy our data */
1217        memcpy(&fifo->fifo[fifo->head], data, firsthalf);
1218        usb_serial_debug_data(debug, &port->dev, __func__,
1219                                        firsthalf, &fifo->fifo[fifo->head]);
1220
1221        /* update the index and size */
1222        fifo->head  += firsthalf;
1223        fifo->count += firsthalf;
1224
1225        /* wrap the index */
1226        if (fifo->head == fifo->size)
1227                fifo->head = 0;
1228
1229        secondhalf = copySize-firsthalf;
1230
1231        if (secondhalf) {
1232                dbg("%s - copy rest of data %d", __func__, secondhalf);
1233                memcpy(&fifo->fifo[fifo->head], &data[firsthalf], secondhalf);
1234                usb_serial_debug_data(debug, &port->dev, __func__,
1235                                        secondhalf, &fifo->fifo[fifo->head]);
1236                /* update the index and size */
1237                fifo->count += secondhalf;
1238                fifo->head  += secondhalf;
1239                /* No need to check for wrap since we can not get to end of
1240                 * the fifo in this part
1241                 */
1242        }
1243
1244finish_write:
1245        spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1246
1247        send_more_port_data((struct edgeport_serial *)
1248                        usb_get_serial_data(port->serial), edge_port);
1249
1250        dbg("%s wrote %d byte(s) TxCredits %d, Fifo %d", __func__,
1251                                copySize, edge_port->txCredits, fifo->count);
1252
1253        return copySize;
1254}
1255
1256
1257/************************************************************************
1258 *
1259 * send_more_port_data()
1260 *
1261 *      This routine attempts to write additional UART transmit data
1262 *      to a port over the USB bulk pipe. It is called (1) when new
1263 *      data has been written to a port's TxBuffer from higher layers
1264 *      (2) when the peripheral sends us additional TxCredits indicating
1265 *      that it can accept more Tx data for a given port; and (3) when
1266 *      a bulk write completes successfully and we want to see if we
1267 *      can transmit more.
1268 *
1269 ************************************************************************/
1270static void send_more_port_data(struct edgeport_serial *edge_serial,
1271                                        struct edgeport_port *edge_port)
1272{
1273        struct TxFifo   *fifo = &edge_port->txfifo;
1274        struct urb      *urb;
1275        unsigned char   *buffer;
1276        int             status;
1277        int             count;
1278        int             bytesleft;
1279        int             firsthalf;
1280        int             secondhalf;
1281        unsigned long   flags;
1282
1283        dbg("%s(%d)", __func__, edge_port->port->number);
1284
1285        spin_lock_irqsave(&edge_port->ep_lock, flags);
1286
1287        if (edge_port->write_in_progress ||
1288            !edge_port->open             ||
1289            (fifo->count == 0)) {
1290                dbg("%s(%d) EXIT - fifo %d, PendingWrite = %d",
1291                                __func__, edge_port->port->number,
1292                                fifo->count, edge_port->write_in_progress);
1293                goto exit_send;
1294        }
1295
1296        /* since the amount of data in the fifo will always fit into the
1297         * edgeport buffer we do not need to check the write length
1298         *
1299         * Do we have enough credits for this port to make it worthwhile
1300         * to bother queueing a write. If it's too small, say a few bytes,
1301         * it's better to wait for more credits so we can do a larger write.
1302         */
1303        if (edge_port->txCredits < EDGE_FW_GET_TX_CREDITS_SEND_THRESHOLD(edge_port->maxTxCredits, EDGE_FW_BULK_MAX_PACKET_SIZE)) {
1304                dbg("%s(%d) Not enough credit - fifo %d TxCredit %d",
1305                        __func__, edge_port->port->number, fifo->count,
1306                        edge_port->txCredits);
1307                goto exit_send;
1308        }
1309
1310        /* lock this write */
1311        edge_port->write_in_progress = true;
1312
1313        /* get a pointer to the write_urb */
1314        urb = edge_port->write_urb;
1315
1316        /* make sure transfer buffer is freed */
1317        kfree(urb->transfer_buffer);
1318        urb->transfer_buffer = NULL;
1319
1320        /* build the data header for the buffer and port that we are about
1321           to send out */
1322        count = fifo->count;
1323        buffer = kmalloc(count+2, GFP_ATOMIC);
1324        if (buffer == NULL) {
1325                dev_err(&edge_port->port->dev,
1326                                "%s - no more kernel memory...\n", __func__);
1327                edge_port->write_in_progress = false;
1328                goto exit_send;
1329        }
1330        buffer[0] = IOSP_BUILD_DATA_HDR1(edge_port->port->number
1331                                - edge_port->port->serial->minor, count);
1332        buffer[1] = IOSP_BUILD_DATA_HDR2(edge_port->port->number
1333                                - edge_port->port->serial->minor, count);
1334
1335        /* now copy our data */
1336        bytesleft =  fifo->size - fifo->tail;
1337        firsthalf = min(bytesleft, count);
1338        memcpy(&buffer[2], &fifo->fifo[fifo->tail], firsthalf);
1339        fifo->tail  += firsthalf;
1340        fifo->count -= firsthalf;
1341        if (fifo->tail == fifo->size)
1342                fifo->tail = 0;
1343
1344        secondhalf = count-firsthalf;
1345        if (secondhalf) {
1346                memcpy(&buffer[2+firsthalf], &fifo->fifo[fifo->tail],
1347                                                                secondhalf);
1348                fifo->tail  += secondhalf;
1349                fifo->count -= secondhalf;
1350        }
1351
1352        if (count)
1353                usb_serial_debug_data(debug, &edge_port->port->dev,
1354                                                __func__, count, &buffer[2]);
1355
1356        /* fill up the urb with all of our data and submit it */
1357        usb_fill_bulk_urb(urb, edge_serial->serial->dev,
1358                        usb_sndbulkpipe(edge_serial->serial->dev,
1359                                        edge_serial->bulk_out_endpoint),
1360                        buffer, count+2,
1361                        edge_bulk_out_data_callback, edge_port);
1362
1363        /* decrement the number of credits we have by the number we just sent */
1364        edge_port->txCredits -= count;
1365        edge_port->icount.tx += count;
1366
1367        urb->dev = edge_serial->serial->dev;
1368        status = usb_submit_urb(urb, GFP_ATOMIC);
1369        if (status) {
1370                /* something went wrong */
1371                dev_err(&edge_port->port->dev,
1372                        "%s - usb_submit_urb(write bulk) failed, status = %d, data lost\n",
1373                                __func__, status);
1374                edge_port->write_in_progress = false;
1375
1376                /* revert the credits as something bad happened. */
1377                edge_port->txCredits += count;
1378                edge_port->icount.tx -= count;
1379        }
1380        dbg("%s wrote %d byte(s) TxCredit %d, Fifo %d",
1381                        __func__, count, edge_port->txCredits, fifo->count);
1382
1383exit_send:
1384        spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1385}
1386
1387
1388/*****************************************************************************
1389 * edge_write_room
1390 *      this function is called by the tty driver when it wants to know how
1391 *      many bytes of data we can accept for a specific port. If successful,
1392 *      we return the amount of room that we have for this port (the txCredits)
1393 *      otherwise we return a negative error number.
1394 *****************************************************************************/
1395static int edge_write_room(struct tty_struct *tty)
1396{
1397        struct usb_serial_port *port = tty->driver_data;
1398        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1399        int room;
1400        unsigned long flags;
1401
1402        dbg("%s", __func__);
1403
1404        if (edge_port == NULL)
1405                return 0;
1406        if (edge_port->closePending)
1407                return 0;
1408
1409        dbg("%s - port %d", __func__, port->number);
1410
1411        if (!edge_port->open) {
1412                dbg("%s - port not opened", __func__);
1413                return 0;
1414        }
1415
1416        /* total of both buffers is still txCredit */
1417        spin_lock_irqsave(&edge_port->ep_lock, flags);
1418        room = edge_port->txCredits - edge_port->txfifo.count;
1419        spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1420
1421        dbg("%s - returns %d", __func__, room);
1422        return room;
1423}
1424
1425
1426/*****************************************************************************
1427 * edge_chars_in_buffer
1428 *      this function is called by the tty driver when it wants to know how
1429 *      many bytes of data we currently have outstanding in the port (data that
1430 *      has been written, but hasn't made it out the port yet)
1431 *      If successful, we return the number of bytes left to be written in the
1432 *      system,
1433 *      Otherwise we return a negative error number.
1434 *****************************************************************************/
1435static int edge_chars_in_buffer(struct tty_struct *tty)
1436{
1437        struct usb_serial_port *port = tty->driver_data;
1438        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1439        int num_chars;
1440        unsigned long flags;
1441
1442        dbg("%s", __func__);
1443
1444        if (edge_port == NULL)
1445                return 0;
1446        if (edge_port->closePending)
1447                return 0;
1448
1449        if (!edge_port->open) {
1450                dbg("%s - port not opened", __func__);
1451                return 0;
1452        }
1453
1454        spin_lock_irqsave(&edge_port->ep_lock, flags);
1455        num_chars = edge_port->maxTxCredits - edge_port->txCredits +
1456                                                edge_port->txfifo.count;
1457        spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1458        if (num_chars) {
1459                dbg("%s(port %d) - returns %d", __func__,
1460                                                port->number, num_chars);
1461        }
1462
1463        return num_chars;
1464}
1465
1466
1467/*****************************************************************************
1468 * SerialThrottle
1469 *      this function is called by the tty driver when it wants to stop the data
1470 *      being read from the port.
1471 *****************************************************************************/
1472static void edge_throttle(struct tty_struct *tty)
1473{
1474        struct usb_serial_port *port = tty->driver_data;
1475        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1476        int status;
1477
1478        dbg("%s - port %d", __func__, port->number);
1479
1480        if (edge_port == NULL)
1481                return;
1482
1483        if (!edge_port->open) {
1484                dbg("%s - port not opened", __func__);
1485                return;
1486        }
1487
1488        /* if we are implementing XON/XOFF, send the stop character */
1489        if (I_IXOFF(tty)) {
1490                unsigned char stop_char = STOP_CHAR(tty);
1491                status = edge_write(tty, port, &stop_char, 1);
1492                if (status <= 0)
1493                        return;
1494        }
1495
1496        /* if we are implementing RTS/CTS, toggle that line */
1497        if (tty->termios->c_cflag & CRTSCTS) {
1498                edge_port->shadowMCR &= ~MCR_RTS;
1499                status = send_cmd_write_uart_register(edge_port, MCR,
1500                                                        edge_port->shadowMCR);
1501                if (status != 0)
1502                        return;
1503        }
1504
1505        return;
1506}
1507
1508
1509/*****************************************************************************
1510 * edge_unthrottle
1511 *      this function is called by the tty driver when it wants to resume the
1512 *      data being read from the port (called after SerialThrottle is called)
1513 *****************************************************************************/
1514static void edge_unthrottle(struct tty_struct *tty)
1515{
1516        struct usb_serial_port *port = tty->driver_data;
1517        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1518        int status;
1519
1520        dbg("%s - port %d", __func__, port->number);
1521
1522        if (edge_port == NULL)
1523                return;
1524
1525        if (!edge_port->open) {
1526                dbg("%s - port not opened", __func__);
1527                return;
1528        }
1529
1530        /* if we are implementing XON/XOFF, send the start character */
1531        if (I_IXOFF(tty)) {
1532                unsigned char start_char = START_CHAR(tty);
1533                status = edge_write(tty, port, &start_char, 1);
1534                if (status <= 0)
1535                        return;
1536        }
1537        /* if we are implementing RTS/CTS, toggle that line */
1538        if (tty->termios->c_cflag & CRTSCTS) {
1539                edge_port->shadowMCR |= MCR_RTS;
1540                send_cmd_write_uart_register(edge_port, MCR,
1541                                                edge_port->shadowMCR);
1542        }
1543}
1544
1545
1546/*****************************************************************************
1547 * SerialSetTermios
1548 *      this function is called by the tty driver when it wants to change
1549 * the termios structure
1550 *****************************************************************************/
1551static void edge_set_termios(struct tty_struct *tty,
1552        struct usb_serial_port *port, struct ktermios *old_termios)
1553{
1554        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1555        unsigned int cflag;
1556
1557        cflag = tty->termios->c_cflag;
1558        dbg("%s - clfag %08x iflag %08x", __func__,
1559            tty->termios->c_cflag, tty->termios->c_iflag);
1560        dbg("%s - old clfag %08x old iflag %08x", __func__,
1561            old_termios->c_cflag, old_termios->c_iflag);
1562
1563        dbg("%s - port %d", __func__, port->number);
1564
1565        if (edge_port == NULL)
1566                return;
1567
1568        if (!edge_port->open) {
1569                dbg("%s - port not opened", __func__);
1570                return;
1571        }
1572
1573        /* change the port settings to the new ones specified */
1574        change_port_settings(tty, edge_port, old_termios);
1575}
1576
1577
1578/*****************************************************************************
1579 * get_lsr_info - get line status register info
1580 *
1581 * Purpose: Let user call ioctl() to get info when the UART physically
1582 *          is emptied.  On bus types like RS485, the transmitter must
1583 *          release the bus after transmitting. This must be done when
1584 *          the transmit shift register is empty, not be done when the
1585 *          transmit holding register is empty.  This functionality
1586 *          allows an RS485 driver to be written in user space.
1587 *****************************************************************************/
1588static int get_lsr_info(struct edgeport_port *edge_port,
1589                                                unsigned int __user *value)
1590{
1591        unsigned int result = 0;
1592        unsigned long flags;
1593
1594        spin_lock_irqsave(&edge_port->ep_lock, flags);
1595        if (edge_port->maxTxCredits == edge_port->txCredits &&
1596            edge_port->txfifo.count == 0) {
1597                dbg("%s -- Empty", __func__);
1598                result = TIOCSER_TEMT;
1599        }
1600        spin_unlock_irqrestore(&edge_port->ep_lock, flags);
1601
1602        if (copy_to_user(value, &result, sizeof(int)))
1603                return -EFAULT;
1604        return 0;
1605}
1606
1607static int edge_tiocmset(struct tty_struct *tty, struct file *file,
1608                                        unsigned int set, unsigned int clear)
1609{
1610        struct usb_serial_port *port = tty->driver_data;
1611        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1612        unsigned int mcr;
1613
1614        dbg("%s - port %d", __func__, port->number);
1615
1616        mcr = edge_port->shadowMCR;
1617        if (set & TIOCM_RTS)
1618                mcr |= MCR_RTS;
1619        if (set & TIOCM_DTR)
1620                mcr |= MCR_DTR;
1621        if (set & TIOCM_LOOP)
1622                mcr |= MCR_LOOPBACK;
1623
1624        if (clear & TIOCM_RTS)
1625                mcr &= ~MCR_RTS;
1626        if (clear & TIOCM_DTR)
1627                mcr &= ~MCR_DTR;
1628        if (clear & TIOCM_LOOP)
1629                mcr &= ~MCR_LOOPBACK;
1630
1631        edge_port->shadowMCR = mcr;
1632
1633        send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
1634
1635        return 0;
1636}
1637
1638static int edge_tiocmget(struct tty_struct *tty, struct file *file)
1639{
1640        struct usb_serial_port *port = tty->driver_data;
1641        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1642        unsigned int result = 0;
1643        unsigned int msr;
1644        unsigned int mcr;
1645
1646        dbg("%s - port %d", __func__, port->number);
1647
1648        msr = edge_port->shadowMSR;
1649        mcr = edge_port->shadowMCR;
1650        result = ((mcr & MCR_DTR)       ? TIOCM_DTR: 0)   /* 0x002 */
1651                  | ((mcr & MCR_RTS)    ? TIOCM_RTS: 0)   /* 0x004 */
1652                  | ((msr & EDGEPORT_MSR_CTS)   ? TIOCM_CTS: 0)   /* 0x020 */
1653                  | ((msr & EDGEPORT_MSR_CD)    ? TIOCM_CAR: 0)   /* 0x040 */
1654                  | ((msr & EDGEPORT_MSR_RI)    ? TIOCM_RI:  0)   /* 0x080 */
1655                  | ((msr & EDGEPORT_MSR_DSR)   ? TIOCM_DSR: 0);  /* 0x100 */
1656
1657
1658        dbg("%s -- %x", __func__, result);
1659
1660        return result;
1661}
1662
1663static int get_serial_info(struct edgeport_port *edge_port,
1664                                struct serial_struct __user *retinfo)
1665{
1666        struct serial_struct tmp;
1667
1668        if (!retinfo)
1669                return -EFAULT;
1670
1671        memset(&tmp, 0, sizeof(tmp));
1672
1673        tmp.type                = PORT_16550A;
1674        tmp.line                = edge_port->port->serial->minor;
1675        tmp.port                = edge_port->port->number;
1676        tmp.irq                 = 0;
1677        tmp.flags               = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
1678        tmp.xmit_fifo_size      = edge_port->maxTxCredits;
1679        tmp.baud_base           = 9600;
1680        tmp.close_delay         = 5*HZ;
1681        tmp.closing_wait        = 30*HZ;
1682
1683        if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
1684                return -EFAULT;
1685        return 0;
1686}
1687
1688
1689
1690/*****************************************************************************
1691 * SerialIoctl
1692 *      this function handles any ioctl calls to the driver
1693 *****************************************************************************/
1694static int edge_ioctl(struct tty_struct *tty, struct file *file,
1695                                        unsigned int cmd, unsigned long arg)
1696{
1697        struct usb_serial_port *port = tty->driver_data;
1698        DEFINE_WAIT(wait);
1699        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1700        struct async_icount cnow;
1701        struct async_icount cprev;
1702        struct serial_icounter_struct icount;
1703
1704        dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
1705
1706        switch (cmd) {
1707        case TIOCSERGETLSR:
1708                dbg("%s (%d) TIOCSERGETLSR", __func__,  port->number);
1709                return get_lsr_info(edge_port, (unsigned int __user *) arg);
1710
1711        case TIOCGSERIAL:
1712                dbg("%s (%d) TIOCGSERIAL", __func__,  port->number);
1713                return get_serial_info(edge_port, (struct serial_struct __user *) arg);
1714
1715        case TIOCMIWAIT:
1716                dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
1717                cprev = edge_port->icount;
1718                while (1) {
1719                        prepare_to_wait(&edge_port->delta_msr_wait,
1720                                                &wait, TASK_INTERRUPTIBLE);
1721                        schedule();
1722                        finish_wait(&edge_port->delta_msr_wait, &wait);
1723                        /* see if a signal did it */
1724                        if (signal_pending(current))
1725                                return -ERESTARTSYS;
1726                        cnow = edge_port->icount;
1727                        if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
1728                            cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
1729                                return -EIO; /* no change => error */
1730                        if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
1731                            ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
1732                            ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
1733                            ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
1734                                return 0;
1735                        }
1736                        cprev = cnow;
1737                }
1738                /* NOTREACHED */
1739                break;
1740
1741        case TIOCGICOUNT:
1742                cnow = edge_port->icount;
1743                memset(&icount, 0, sizeof(icount));
1744                icount.cts = cnow.cts;
1745                icount.dsr = cnow.dsr;
1746                icount.rng = cnow.rng;
1747                icount.dcd = cnow.dcd;
1748                icount.rx = cnow.rx;
1749                icount.tx = cnow.tx;
1750                icount.frame = cnow.frame;
1751                icount.overrun = cnow.overrun;
1752                icount.parity = cnow.parity;
1753                icount.brk = cnow.brk;
1754                icount.buf_overrun = cnow.buf_overrun;
1755
1756                dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d",
1757                                __func__,  port->number, icount.rx, icount.tx);
1758                if (copy_to_user((void __user *)arg, &icount, sizeof(icount)))
1759                        return -EFAULT;
1760                return 0;
1761        }
1762        return -ENOIOCTLCMD;
1763}
1764
1765
1766/*****************************************************************************
1767 * SerialBreak
1768 *      this function sends a break to the port
1769 *****************************************************************************/
1770static void edge_break(struct tty_struct *tty, int break_state)
1771{
1772        struct usb_serial_port *port = tty->driver_data;
1773        struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1774        struct edgeport_serial *edge_serial = usb_get_serial_data(port->serial);
1775        int status;
1776
1777        if ((!edge_serial->is_epic) ||
1778            ((edge_serial->is_epic) &&
1779             (edge_serial->epic_descriptor.Supports.IOSPChase))) {
1780                /* flush and chase */
1781                edge_port->chaseResponsePending = true;
1782
1783                dbg("%s - Sending IOSP_CMD_CHASE_PORT", __func__);
1784                status = send_iosp_ext_cmd(edge_port, IOSP_CMD_CHASE_PORT, 0);
1785                if (status == 0) {
1786                        /* block until chase finished */
1787                        block_until_chase_response(edge_port);
1788                } else {
1789                        edge_port->chaseResponsePending = false;
1790                }
1791        }
1792
1793        if ((!edge_serial->is_epic) ||
1794            ((edge_serial->is_epic) &&
1795             (edge_serial->epic_descriptor.Supports.IOSPSetClrBreak))) {
1796                if (break_state == -1) {
1797                        dbg("%s - Sending IOSP_CMD_SET_BREAK", __func__);
1798                        status = send_iosp_ext_cmd(edge_port,
1799                                                IOSP_CMD_SET_BREAK, 0);
1800                } else {
1801                        dbg("%s - Sending IOSP_CMD_CLEAR_BREAK", __func__);
1802                        status = send_iosp_ext_cmd(edge_port,
1803                                                IOSP_CMD_CLEAR_BREAK, 0);
1804                }
1805                if (status)
1806                        dbg("%s - error sending break set/clear command.",
1807                                __func__);
1808        }
1809
1810        return;
1811}
1812
1813
1814/*****************************************************************************
1815 * process_rcvd_data
1816 *      this function handles the data received on the bulk in pipe.
1817 *****************************************************************************/
1818static void process_rcvd_data(struct edgeport_serial *edge_serial,
1819                                unsigned char *buffer, __u16 bufferLength)
1820{
1821        struct usb_serial_port *port;
1822        struct edgeport_port *edge_port;
1823        struct tty_struct *tty;
1824        __u16 lastBufferLength;
1825        __u16 rxLen;
1826
1827        dbg("%s", __func__);
1828
1829        lastBufferLength = bufferLength + 1;
1830
1831        while (bufferLength > 0) {
1832                /* failsafe incase we get a message that we don't understand */
1833                if (lastBufferLength == bufferLength) {
1834                        dbg("%s - stuck in loop, exiting it.", __func__);
1835                        break;
1836                }
1837                lastBufferLength = bufferLength;
1838
1839                switch (edge_serial->rxState) {
1840                case EXPECT_HDR1:
1841                        edge_serial->rxHeader1 = *buffer;
1842                        ++buffer;
1843                        --bufferLength;
1844
1845                        if (bufferLength == 0) {
1846                                edge_serial->rxState = EXPECT_HDR2;
1847                                break;
1848                        }
1849                        /* otherwise, drop on through */
1850                case EXPECT_HDR2:
1851                        edge_serial->rxHeader2 = *buffer;
1852                        ++buffer;
1853                        --bufferLength;
1854
1855                        dbg("%s - Hdr1=%02X Hdr2=%02X", __func__,
1856                            edge_serial->rxHeader1, edge_serial->rxHeader2);
1857                        /* Process depending on whether this header is
1858                         * data or status */
1859
1860                        if (IS_CMD_STAT_HDR(edge_serial->rxHeader1)) {
1861                                /* Decode this status header and go to
1862                                 * EXPECT_HDR1 (if we can process the status
1863                                 * with only 2 bytes), or go to EXPECT_HDR3 to
1864                                 * get the third byte. */
1865                                edge_serial->rxPort =
1866                                    IOSP_GET_HDR_PORT(edge_serial->rxHeader1);
1867                                edge_serial->rxStatusCode =
1868                                    IOSP_GET_STATUS_CODE(
1869                                                edge_serial->rxHeader1);
1870
1871                                if (!IOSP_STATUS_IS_2BYTE(
1872                                                edge_serial->rxStatusCode)) {
1873                                        /* This status needs additional bytes.
1874                                         * Save what we have and then wait for
1875                                         * more data.
1876                                         */
1877                                        edge_serial->rxStatusParam
1878                                                = edge_serial->rxHeader2;
1879                                        edge_serial->rxState = EXPECT_HDR3;
1880                                        break;
1881                                }
1882                                /* We have all the header bytes, process the
1883                                   status now */
1884                                process_rcvd_status(edge_serial,
1885                                                edge_serial->rxHeader2, 0);
1886                                edge_serial->rxState = EXPECT_HDR1;
1887                                break;
1888                        } else {
1889                                edge_serial->rxPort =
1890                                    IOSP_GET_HDR_PORT(edge_serial->rxHeader1);
1891                                edge_serial->rxBytesRemaining =
1892                                    IOSP_GET_HDR_DATA_LEN(
1893                                                edge_serial->rxHeader1,
1894                                                edge_serial->rxHeader2);
1895                                dbg("%s - Data for Port %u Len %u",
1896                                                __func__,
1897                                                edge_serial->rxPort,
1898                                                edge_serial->rxBytesRemaining);
1899
1900                                /* ASSERT(DevExt->RxPort < DevExt->NumPorts);
1901                                 * ASSERT(DevExt->RxBytesRemaining <
1902                                 *              IOSP_MAX_DATA_LENGTH);
1903                                 */
1904
1905                                if (bufferLength == 0) {
1906                                        edge_serial->rxState = EXPECT_DATA;
1907                                        break;
1908                                }
1909                                /* Else, drop through */
1910                        }
1911                case EXPECT_DATA: /* Expect data */
1912                        if (bufferLength < edge_serial->rxBytesRemaining) {
1913                                rxLen = bufferLength;
1914                                /* Expect data to start next buffer */
1915                                edge_serial->rxState = EXPECT_DATA;
1916                        } else {
1917                                /* BufLen >= RxBytesRemaining */
1918                                rxLen = edge_serial->rxBytesRemaining;
1919                                /* Start another header next time */
1920                                edge_serial->rxState = EXPECT_HDR1;
1921                        }
1922
1923                        bufferLength -= rxLen;
1924                        edge_serial->rxBytesRemaining -= rxLen;
1925
1926                        /* spit this data back into the tty driver if this
1927                           port is open */
1928                        if (rxLen) {
1929                                port = edge_serial->serial->port[
1930                                                        edge_serial->rxPort];
1931                                edge_port = usb_get_serial_port_data(port);
1932                                if (edge_port->open) {
1933                                        tty = tty_port_tty_get(
1934                                                &edge_port->port->port);
1935                                        if (tty) {
1936                                                dbg("%s - Sending %d bytes to TTY for port %d",
1937                                                        __func__, rxLen, edge_serial->rxPort);
1938                                                edge_tty_recv(&edge_serial->serial->dev->dev, tty, buffer, rxLen);
1939                                                tty_kref_put(tty);
1940                                        }
1941                                        edge_port->icount.rx += rxLen;
1942                                }
1943                                buffer += rxLen;
1944                        }
1945                        break;
1946
1947                case EXPECT_HDR3:       /* Expect 3rd byte of status header */
1948                        edge_serial->rxHeader3 = *buffer;
1949                        ++buffer;
1950                        --bufferLength;
1951
1952                        /* We have all the header bytes, process the
1953                           status now */
1954                        process_rcvd_status(edge_serial,
1955                                edge_serial->rxStatusParam,
1956                                edge_serial->rxHeader3);
1957                        edge_serial->rxState = EXPECT_HDR1;
1958                        break;
1959                }
1960        }
1961}
1962
1963
1964/*****************************************************************************
1965 * process_rcvd_status
1966 *      this function handles the any status messages received on the
1967 *      bulk in pipe.
1968 *****************************************************************************/
1969static void process_rcvd_status(struct edgeport_serial *edge_serial,
1970                                                __u8 byte2, __u8 byte3)
1971{
1972        struct usb_serial_port *port;
1973        struct edgeport_port *edge_port;
1974        struct tty_struct *tty;
1975        __u8 code = edge_serial->rxStatusCode;
1976
1977        /* switch the port pointer to the one being currently talked about */
1978        port = edge_serial->serial->port[edge_serial->rxPort];
1979        edge_port = usb_get_serial_port_data(port);
1980        if (edge_port == NULL) {
1981                dev_err(&edge_serial->serial->dev->dev,
1982                        "%s - edge_port == NULL for port %d\n",
1983                                        __func__, edge_serial->rxPort);
1984                return;
1985        }
1986
1987        dbg("%s - port %d", __func__, edge_serial->rxPort);
1988
1989        if (code == IOSP_EXT_STATUS) {
1990                switch (byte2) {
1991                case IOSP_EXT_STATUS_CHASE_RSP:
1992                        /* we want to do EXT status regardless of port
1993                         * open/closed */
1994                        dbg("%s - Port %u EXT CHASE_RSP Data = %02x",
1995                                        __func__, edge_serial->rxPort, byte3);
1996                        /* Currently, the only EXT_STATUS is Chase, so process
1997                         * here instead of one more call to one more subroutine
1998                         * If/when more EXT_STATUS, there'll be more work to do
1999                         * Also, we currently clear flag and close the port
2000                         * regardless of content of above's Byte3.

2001                         * We could choose to do something else when Byte3 says
2002                         * Timeout on Chase from Edgeport, like wait longer in
2003                         * block_until_chase_response, but for now we don't.
2004                         */
2005                        edge_port->chaseResponsePending = false;
2006                        wake_up(&edge_port->wait_chase);
2007                        return;
2008
2009                case IOSP_EXT_STATUS_RX_CHECK_RSP:
2010                        dbg("%s ========== Port %u CHECK_RSP Sequence = %02x =============\n", __func__, edge_serial->rxPort, byte3);
2011                        /* Port->RxCheckRsp = true; */
2012                        return;
2013                }
2014        }
2015
2016        if (code == IOSP_STATUS_OPEN_RSP) {
2017                edge_port->txCredits = GET_TX_BUFFER_SIZE(byte3);
2018                edge_port->maxTxCredits = edge_port->txCredits;
2019                dbg("%s - Port %u Open Response Inital MSR = %02x TxBufferSize = %d", __func__, edge_serial->rxPort, byte2, edge_port->txCredits);
2020                handle_new_msr(edge_port, byte2);
2021
2022                /* send the current line settings to the port so we are
2023                   in sync with any further termios calls */
2024                tty = tty_port_tty_get(&edge_port->port->port);
2025                if (tty) {
2026                        change_port_settings(tty,
2027                                edge_port, tty->termios);
2028                        tty_kref_put(tty);
2029                }
2030
2031                /* we have completed the open */
2032                edge_port->openPending = false;
2033                edge_port->open = true;
2034                wake_up(&edge_port->wait_open);
2035                return;
2036        }
2037
2038        /* If port is closed, silently discard all rcvd status. We can
2039         * have cases where buffered status is received AFTER the close
2040         * port command is sent to the Edgeport.
2041         */
2042        if (!edge_port->open || edge_port->closePending)
2043                return;
2044
2045        switch (code) {
2046        /* Not currently sent by Edgeport */
2047        case IOSP_STATUS_LSR:
2048                dbg("%s - Port %u LSR Status = %02x",
2049                                        __func__, edge_serial->rxPort, byte2);
2050                handle_new_lsr(edge_port, false, byte2, 0);
2051                break;
2052
2053        case IOSP_STATUS_LSR_DATA:
2054                dbg("%s - Port %u LSR Status = %02x, Data = %02x",
2055                                __func__, edge_serial->rxPort, byte2, byte3);
2056                /* byte2 is LSR Register */
2057                /* byte3 is broken data byte */
2058                handle_new_lsr(edge_port, true, byte2, byte3);
2059                break;
2060        /*
2061         *      case IOSP_EXT_4_STATUS:
2062         *              dbg("%s - Port %u LSR Status = %02x Data = %02x",
2063         *                      __func__, edge_serial->rxPort, byte2, byte3);
2064         *              break;
2065         */
2066        case IOSP_STATUS_MSR:
2067                dbg("%s - Port %u MSR Status = %02x",
2068                                        __func__, edge_serial->rxPort, byte2);
2069                /*
2070                 * Process this new modem status and generate appropriate
2071                 * events, etc, based on the new status. This routine
2072                 * also saves the MSR in Port->ShadowMsr.
2073                 */
2074                handle_new_msr(edge_port, byte2);
2075                break;
2076
2077        default:
2078                dbg("%s - Unrecognized IOSP status code %u\n", __func__, code);
2079                break;
2080        }
2081        return;
2082}
2083
2084
2085/*****************************************************************************
2086 * edge_tty_recv
2087 *      this function passes data on to the tty flip buffer
2088 *****************************************************************************/
2089static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
2090                                        unsigned char *data, int length)
2091{
2092        int cnt;
2093
2094        do {
2095                cnt = tty_buffer_request_room(tty, length);
2096                if (cnt < length) {
2097                        dev_err(dev, "%s - dropping data, %d bytes lost\n",
2098                                        __func__, length - cnt);
2099                        if (cnt == 0)
2100                                break;
2101                }
2102                tty_insert_flip_string(tty, data, cnt);
2103                data += cnt;
2104                length -= cnt;
2105        } while (length > 0);
2106
2107        tty_flip_buffer_push(tty);
2108}
2109
2110
2111/*****************************************************************************
2112 * handle_new_msr
2113 *      this function handles any change to the msr register for a port.
2114 *****************************************************************************/
2115static void handle_new_msr(struct edgeport_port *edge_port, __u8 newMsr)
2116{
2117        struct  async_icount *icount;
2118
2119        dbg("%s %02x", __func__, newMsr);
2120
2121        if (newMsr & (EDGEPORT_MSR_DELTA_CTS | EDGEPORT_MSR_DELTA_DSR |
2122                        EDGEPORT_MSR_DELTA_RI | EDGEPORT_MSR_DELTA_CD)) {
2123                icount = &edge_port->icount;
2124
2125                /* update input line counters */
2126                if (newMsr & EDGEPORT_MSR_DELTA_CTS)
2127                        icount->cts++;
2128                if (newMsr & EDGEPORT_MSR_DELTA_DSR)
2129                        icount->dsr++;
2130                if (newMsr & EDGEPORT_MSR_DELTA_CD)
2131                        icount->dcd++;
2132                if (newMsr & EDGEPORT_MSR_DELTA_RI)
2133                        icount->rng++;
2134                wake_up_interruptible(&edge_port->delta_msr_wait);
2135        }
2136
2137        /* Save the new modem status */
2138        edge_port->shadowMSR = newMsr & 0xf0;
2139
2140        return;
2141}
2142
2143
2144/*****************************************************************************
2145 * handle_new_lsr
2146 *      this function handles any change to the lsr register for a port.
2147 *****************************************************************************/
2148static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData,
2149                                                        __u8 lsr, __u8 data)
2150{
2151        __u8 newLsr = (__u8) (lsr & (__u8)
2152                (LSR_OVER_ERR | LSR_PAR_ERR | LSR_FRM_ERR | LSR_BREAK));
2153        struct async_icount *icount;
2154
2155        dbg("%s - %02x", __func__, newLsr);
2156
2157        edge_port->shadowLSR = lsr;
2158
2159        if (newLsr & LSR_BREAK) {
2160                /*
2161                 * Parity and Framing errors only count if they
2162                 * occur exclusive of a break being
2163                 * received.
2164                 */
2165                newLsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK);
2166        }
2167
2168        /* Place LSR data byte into Rx buffer */
2169        if (lsrData) {
2170                struct tty_struct *tty =
2171                                tty_port_tty_get(&edge_port->port->port);
2172                if (tty) {
2173                        edge_tty_recv(&edge_port->port->dev, tty, &data, 1);
2174                        tty_kref_put(tty);
2175                }
2176        }
2177        /* update input line counters */
2178        icount = &edge_port->icount;
2179        if (newLsr & LSR_BREAK)
2180                icount->brk++;
2181        if (newLsr & LSR_OVER_ERR)
2182                icount->overrun++;
2183        if (newLsr & LSR_PAR_ERR)
2184                icount->parity++;
2185        if (newLsr & LSR_FRM_ERR)
2186                icount->frame++;
2187
2188        return;
2189}
2190
2191
2192/****************************************************************************
2193 * sram_write
2194 *      writes a number of bytes to the Edgeport device's sram starting at the
2195 *      given address.
2196 *      If successful returns the number of bytes written, otherwise it returns
2197 *      a negative error number of the problem.
2198 ****************************************************************************/
2199static int sram_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
2200                                        __u16 length, const __u8 *data)
2201{
2202        int result;
2203        __u16 current_length;
2204        unsigned char *transfer_buffer;
2205
2206        dbg("%s - %x, %x, %d", __func__, extAddr, addr, length);
2207
2208        transfer_buffer =  kmalloc(64, GFP_KERNEL);
2209        if (!transfer_buffer) {
2210                dev_err(&serial->dev->dev, "%s - kmalloc(%d) failed.\n",
2211                                                        __func__, 64);
2212                return -ENOMEM;
2213        }
2214
2215        /* need to split these writes up into 64 byte chunks */
2216        result = 0;
2217        while (length > 0) {
2218                if (length > 64)
2219                        current_length = 64;
2220                else
2221                        current_length = length;
2222
2223/*              dbg("%s - writing %x, %x, %d", __func__,
2224                                        extAddr, addr, current_length); */
2225                memcpy(transfer_buffer, data, current_length);
2226                result = usb_control_msg(serial->dev,
2227                                        usb_sndctrlpipe(serial->dev, 0),
2228                                        USB_REQUEST_ION_WRITE_RAM,
2229                                        0x40, addr, extAddr, transfer_buffer,
2230                                        current_length, 300);
2231                if (result < 0)
2232                        break;
2233                length -= current_length;
2234                addr += current_length;
2235                data += current_length;
2236        }
2237
2238        kfree(transfer_buffer);
2239        return result;
2240}
2241
2242
2243/****************************************************************************
2244 * rom_write
2245 *      writes a number of bytes to the Edgeport device's ROM starting at the
2246 *      given address.
2247 *      If successful returns the number of bytes written, otherwise it returns
2248 *      a negative error number of the problem.
2249 ****************************************************************************/
2250static int rom_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
2251                                        __u16 length, const __u8 *data)
2252{
2253        int result;
2254        __u16 current_length;
2255        unsigned char *transfer_buffer;
2256
2257/*      dbg("%s - %x, %x, %d", __func__, extAddr, addr, length); */
2258
2259        transfer_buffer =  kmalloc(64, GFP_KERNEL);
2260        if (!transfer_buffer) {
2261                dev_err(&serial->dev->dev, "%s - kmalloc(%d) failed.\n",
2262                                                                __func__, 64);
2263                return -ENOMEM;
2264        }
2265
2266        /* need to split these writes up into 64 byte chunks */
2267        result = 0;
2268        while (length > 0) {
2269                if (length > 64)
2270                        current_length = 64;
2271                else
2272                        current_length = length;
2273/*              dbg("%s - writing %x, %x, %d", __func__,
2274                                        extAddr, addr, current_length); */
2275                memcpy(transfer_buffer, data, current_length);
2276                result = usb_control_msg(serial->dev,
2277                                        usb_sndctrlpipe(serial->dev, 0),
2278                                        USB_REQUEST_ION_WRITE_ROM, 0x40,
2279                                        addr, extAddr,
2280                                        transfer_buffer, current_length, 300);
2281                if (result < 0)
2282                        break;
2283                length -= current_length;
2284                addr += current_length;
2285                data += current_length;
2286        }
2287
2288        kfree(transfer_buffer);
2289        return result;
2290}
2291
2292
2293/****************************************************************************
2294 * rom_read
2295 *      reads a number of bytes from the Edgeport device starting at the given
2296 *      address.
2297 *      If successful returns the number of bytes read, otherwise it returns
2298 *      a negative error number of the problem.
2299 ****************************************************************************/
2300static int rom_read(struct usb_serial *serial, __u16 extAddr,
2301                                        __u16 addr, __u16 length, __u8 *data)
2302{
2303        int result;
2304        __u16 current_length;
2305        unsigned char *transfer_buffer;
2306
2307        dbg("%s - %x, %x, %d", __func__, extAddr, addr, length);
2308
2309        transfer_buffer =  kmalloc(64, GFP_KERNEL);
2310        if (!transfer_buffer) {
2311                dev_err(&serial->dev->dev,
2312                        "%s - kmalloc(%d) failed.\n", __func__, 64);
2313                return -ENOMEM;
2314        }
2315
2316        /* need to split these reads up into 64 byte chunks */
2317        result = 0;
2318        while (length > 0) {
2319                if (length > 64)
2320                        current_length = 64;
2321                else
2322                        current_length = length;
2323/*              dbg("%s - %x, %x, %d", __func__,
2324                                extAddr, addr, current_length); */
2325                result = usb_control_msg(serial->dev,
2326                                        usb_rcvctrlpipe(serial->dev, 0),
2327                                        USB_REQUEST_ION_READ_ROM,
2328                                        0xC0, addr, extAddr, transfer_buffer,
2329                                        current_length, 300);
2330                if (result < 0)
2331                        break;
2332                memcpy(data, transfer_buffer, current_length);
2333                length -= current_length;
2334                addr += current_length;
2335                data += current_length;
2336        }
2337
2338        kfree(transfer_buffer);
2339        return result;
2340}
2341
2342
2343/****************************************************************************
2344 * send_iosp_ext_cmd
2345 *      Is used to send a IOSP message to the Edgeport device
2346 ****************************************************************************/
2347static int send_iosp_ext_cmd(struct edgeport_port *edge_port,
2348                                                __u8 command, __u8 param)
2349{
2350        unsigned char   *buffer;
2351        unsigned char   *currentCommand;
2352        int             length = 0;
2353        int             status = 0;
2354
2355        dbg("%s - %d, %d", __func__, command, param);
2356
2357        buffer = kmalloc(10, GFP_ATOMIC);
2358        if (!buffer) {
2359                dev_err(&edge_port->port->dev,
2360                                "%s - kmalloc(%d) failed.\n", __func__, 10);
2361                return -ENOMEM;
2362        }
2363
2364        currentCommand = buffer;
2365
2366        MAKE_CMD_EXT_CMD(&currentCommand, &length,
2367                edge_port->port->number - edge_port->port->serial->minor,
2368                command, param);
2369
2370        status = write_cmd_usb(edge_port, buffer, length);
2371        if (status) {
2372                /* something bad happened, let's free up the memory */
2373                kfree(buffer);
2374        }
2375
2376        return status;
2377}
2378
2379
2380/*****************************************************************************
2381 * write_cmd_usb
2382 *      this function writes the given buffer out to the bulk write endpoint.
2383 *****************************************************************************/
2384static int write_cmd_usb(struct edgeport_port *edge_port,
2385                                        unsigned char *buffer, int length)
2386{
2387        struct edgeport_serial *edge_serial =
2388                                usb_get_serial_data(edge_port->port->serial);
2389        int status = 0;
2390        struct urb *urb;
2391        int timeout;
2392
2393        usb_serial_debug_data(debug, &edge_port->port->dev,
2394                                                __func__, length, buffer);
2395
2396        /* Allocate our next urb */
2397        urb = usb_alloc_urb(0, GFP_ATOMIC);
2398        if (!urb)
2399                return -ENOMEM;
2400
2401        atomic_inc(&CmdUrbs);
2402        dbg("%s - ALLOCATE URB %p (outstanding %d)",
2403                                __func__, urb, atomic_read(&CmdUrbs));
2404
2405        usb_fill_bulk_urb(urb, edge_serial->serial->dev,
2406                        usb_sndbulkpipe(edge_serial->serial->dev,
2407                                        edge_serial->bulk_out_endpoint),
2408                        buffer, length, edge_bulk_out_cmd_callback, edge_port);
2409
2410        edge_port->commandPending = true;
2411        status = usb_submit_urb(urb, GFP_ATOMIC);
2412
2413        if (status) {
2414                /* something went wrong */
2415                dev_err(&edge_port->port->dev,
2416                    "%s - usb_submit_urb(write command) failed, status = %d\n",
2417                                                        __func__, status);
2418                usb_kill_urb(urb);
2419                usb_free_urb(urb);
2420                atomic_dec(&CmdUrbs);
2421                return status;
2422        }
2423
2424        /* wait for command to finish */
2425        timeout = COMMAND_TIMEOUT;
2426#if 0
2427        wait_event(&edge_port->wait_command, !edge_port->commandPending);
2428
2429        if (edge_port->commandPending) {
2430                /* command timed out */
2431                dbg("%s - command timed out", __func__);
2432                status = -EINVAL;
2433        }
2434#endif
2435        return status;
2436}
2437
2438
2439/*****************************************************************************
2440 * send_cmd_write_baud_rate
2441 *      this function sends the proper command to change the baud rate of the
2442 *      specified port.
2443 *****************************************************************************/
2444static int send_cmd_write_baud_rate(struct edgeport_port *edge_port,
2445                                                                int baudRate)
2446{
2447        struct edgeport_serial *edge_serial =
2448                                usb_get_serial_data(edge_port->port->serial);
2449        unsigned char *cmdBuffer;
2450        unsigned char *currCmd;
2451        int cmdLen = 0;
2452        int divisor;
2453        int status;
2454        unsigned char number =
2455                edge_port->port->number - edge_port->port->serial->minor;
2456
2457        if (edge_serial->is_epic &&
2458            !edge_serial->epic_descriptor.Supports.IOSPSetBaudRate) {
2459                dbg("SendCmdWriteBaudRate - NOT Setting baud rate for port = %d, baud = %d",
2460                    edge_port->port->number, baudRate);
2461                return 0;
2462        }
2463
2464        dbg("%s - port = %d, baud = %d", __func__,
2465                                        edge_port->port->number, baudRate);
2466
2467        status = calc_baud_rate_divisor(baudRate, &divisor);
2468        if (status) {
2469                dev_err(&edge_port->port->dev, "%s - bad baud rate\n",
2470                                                                __func__);
2471                return status;
2472        }
2473
2474        /* Alloc memory for the string of commands. */
2475        cmdBuffer =  kmalloc(0x100, GFP_ATOMIC);
2476        if (!cmdBuffer) {
2477                dev_err(&edge_port->port->dev,
2478                        "%s - kmalloc(%d) failed.\n", __func__, 0x100);
2479                return -ENOMEM;
2480        }
2481        currCmd = cmdBuffer;
2482
2483        /* Enable access to divisor latch */
2484        MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, number, LCR, LCR_DL_ENABLE);
2485
2486        /* Write the divisor itself */
2487        MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, number, DLL, LOW8(divisor));
2488        MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, number, DLM, HIGH8(divisor));
2489
2490        /* Restore original value to disable access to divisor latch */
2491        MAKE_CMD_WRITE_REG(&currCmd, &cmdLen, number, LCR,
2492                                                edge_port->shadowLCR);
2493
2494        status = write_cmd_usb(edge_port, cmdBuffer, cmdLen);
2495        if (status) {
2496                /* something bad happened, let's free up the memory */
2497                kfree(cmdBuffer);
2498        }
2499
2500        return status;
2501}
2502
2503
2504/*****************************************************************************
2505 * calc_baud_rate_divisor
2506 *      this function calculates the proper baud rate divisor for the specified
2507 *      baud rate.
2508 *****************************************************************************/
2509static int calc_baud_rate_divisor(int baudrate, int *divisor)
2510{
2511        int i;
2512        __u16 custom;
2513
2514
2515        dbg("%s - %d", __func__, baudrate);
2516
2517        for (i = 0; i < ARRAY_SIZE(divisor_table); i++) {
2518                if (divisor_table[i].BaudRate == baudrate) {
2519                        *divisor = divisor_table[i].Divisor;
2520                        return 0;
2521                }
2522        }
2523
2524        /* We have tried all of the standard baud rates
2525         * lets try to calculate the divisor for this baud rate
2526         * Make sure the baud rate is reasonable */
2527        if (baudrate > 50 && baudrate < 230400) {
2528                /* get divisor */
2529                custom = (__u16)((230400L + baudrate/2) / baudrate);
2530
2531                *divisor = custom;
2532
2533                dbg("%s - Baud %d = %d\n", __func__, baudrate, custom);
2534                return 0;
2535        }
2536
2537        return -1;
2538}
2539
2540
2541/*****************************************************************************
2542 * send_cmd_write_uart_register
2543 *  this function builds up a uart register message and sends to the device.
2544 *****************************************************************************/
2545static int send_cmd_write_uart_register(struct edgeport_port *edge_port,
2546                                                __u8 regNum, __u8 regValue)
2547{
2548        struct edgeport_serial *edge_serial =
2549                                usb_get_serial_data(edge_port->port->serial);
2550        unsigned char *cmdBuffer;
2551        unsigned char *currCmd;
2552        unsigned long cmdLen = 0;
2553        int status;
2554
2555        dbg("%s - write to %s register 0x%02x",
2556                        (regNum == MCR) ? "MCR" : "LCR", __func__, regValue);
2557
2558        if (edge_serial->is_epic &&
2559            !edge_serial->epic_descriptor.Supports.IOSPWriteMCR &&
2560            regNum == MCR) {
2561                dbg("SendCmdWriteUartReg - Not writing to MCR Register");
2562                return 0;
2563        }
2564
2565        if (edge_serial->is_epic &&
2566            !edge_serial->epic_descriptor.Supports.IOSPWriteLCR &&
2567            regNum == LCR) {
2568                dbg("SendCmdWriteUartReg - Not writing to LCR Register");
2569                return 0;
2570        }
2571
2572        /* Alloc memory for the string of commands. */
2573        cmdBuffer = kmalloc(0x10, GFP_ATOMIC);
2574        if (cmdBuffer == NULL)
2575                return -ENOMEM;
2576
2577        currCmd = cmdBuffer;
2578
2579        /* Build a cmd in the buffer to write the given register */
2580        MAKE_CMD_WRITE_REG(&currCmd, &cmdLen,
2581                edge_port->port->number - edge_port->port->serial->minor,
2582                regNum, regValue);
2583
2584        status = write_cmd_usb(edge_port, cmdBuffer, cmdLen);
2585        if (status) {
2586                /* something bad happened, let's free up the memory */
2587                kfree(cmdBuffer);
2588        }
2589
2590        return status;
2591}
2592
2593
2594/*****************************************************************************
2595 * change_port_settings
2596 *      This routine is called to set the UART on the device to match the
2597 *      specified new settings.
2598 *****************************************************************************/
2599
2600static void change_port_settings(struct tty_struct *tty,
2601        struct edgeport_port *edge_port, struct ktermios *old_termios)
2602{
2603        struct edgeport_serial *edge_serial =
2604                        usb_get_serial_data(edge_port->port->serial);
2605        int baud;
2606        unsigned cflag;
2607        __u8 mask = 0xff;
2608        __u8 lData;
2609        __u8 lParity;
2610        __u8 lStop;
2611        __u8 rxFlow;
2612        __u8 txFlow;
2613        int status;
2614
2615        dbg("%s - port %d", __func__, edge_port->port->number);
2616
2617        if (!edge_port->open &&
2618            !edge_port->openPending) {
2619                dbg("%s - port not opened", __func__);
2620                return;
2621        }
2622
2623        cflag = tty->termios->c_cflag;
2624
2625        switch (cflag & CSIZE) {
2626        case CS5:
2627                lData = LCR_BITS_5; mask = 0x1f;
2628                dbg("%s - data bits = 5", __func__);
2629                break;
2630        case CS6:
2631                lData = LCR_BITS_6; mask = 0x3f;
2632                dbg("%s - data bits = 6", __func__);
2633                break;
2634        case CS7:
2635                lData = LCR_BITS_7; mask = 0x7f;
2636                dbg("%s - data bits = 7", __func__);
2637                break;
2638        default:
2639        case CS8:
2640                lData = LCR_BITS_8;
2641                dbg("%s - data bits = 8", __func__);
2642                break;
2643        }
2644
2645        lParity = LCR_PAR_NONE;
2646        if (cflag & PARENB) {
2647                if (cflag & CMSPAR) {
2648                        if (cflag & PARODD) {
2649                                lParity = LCR_PAR_MARK;
2650                                dbg("%s - parity = mark", __func__);
2651                        } else {
2652                                lParity = LCR_PAR_SPACE;
2653                                dbg("%s - parity = space", __func__);
2654                        }
2655                } else if (cflag & PARODD) {
2656                        lParity = LCR_PAR_ODD;
2657                        dbg("%s - parity = odd", __func__);
2658                } else {
2659                        lParity = LCR_PAR_EVEN;
2660                        dbg("%s - parity = even", __func__);
2661                }
2662        } else {
2663                dbg("%s - parity = none", __func__);
2664        }
2665
2666        if (cflag & CSTOPB) {
2667                lStop = LCR_STOP_2;
2668                dbg("%s - stop bits = 2", __func__);
2669        } else {
2670                lStop = LCR_STOP_1;
2671                dbg("%s - stop bits = 1", __func__);
2672        }
2673
2674        /* figure out the flow control settings */
2675        rxFlow = txFlow = 0x00;
2676        if (cflag & CRTSCTS) {
2677                rxFlow |= IOSP_RX_FLOW_RTS;
2678                txFlow |= IOSP_TX_FLOW_CTS;
2679                dbg("%s - RTS/CTS is enabled", __func__);
2680        } else {
2681                dbg("%s - RTS/CTS is disabled", __func__);
2682        }
2683
2684        /* if we are implementing XON/XOFF, set the start and stop character
2685           in the device */
2686        if (I_IXOFF(tty) || I_IXON(tty)) {
2687                unsigned char stop_char  = STOP_CHAR(tty);
2688                unsigned char start_char = START_CHAR(tty);
2689
2690                if ((!edge_serial->is_epic) ||
2691                    ((edge_serial->is_epic) &&
2692                     (edge_serial->epic_descriptor.Supports.IOSPSetXChar))) {
2693                        send_iosp_ext_cmd(edge_port,
2694                                        IOSP_CMD_SET_XON_CHAR, start_char);
2695                        send_iosp_ext_cmd(edge_port,
2696                                        IOSP_CMD_SET_XOFF_CHAR, stop_char);
2697                }
2698
2699                /* if we are implementing INBOUND XON/XOFF */
2700                if (I_IXOFF(tty)) {
2701                        rxFlow |= IOSP_RX_FLOW_XON_XOFF;
2702                        dbg("%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
2703                                        __func__, start_char, stop_char);
2704                } else {
2705                        dbg("%s - INBOUND XON/XOFF is disabled", __func__);
2706                }
2707
2708                /* if we are implementing OUTBOUND XON/XOFF */
2709                if (I_IXON(tty)) {
2710                        txFlow |= IOSP_TX_FLOW_XON_XOFF;
2711                        dbg("%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
2712                                        __func__, start_char, stop_char);
2713                } else {
2714                        dbg("%s - OUTBOUND XON/XOFF is disabled", __func__);
2715                }
2716        }
2717
2718        /* Set flow control to the configured value */
2719        if ((!edge_serial->is_epic) ||
2720            ((edge_serial->is_epic) &&
2721             (edge_serial->epic_descriptor.Supports.IOSPSetRxFlow)))
2722                send_iosp_ext_cmd(edge_port, IOSP_CMD_SET_RX_FLOW, rxFlow);
2723        if ((!edge_serial->is_epic) ||
2724            ((edge_serial->is_epic) &&
2725             (edge_serial->epic_descriptor.Supports.IOSPSetTxFlow)))
2726                send_iosp_ext_cmd(edge_port, IOSP_CMD_SET_TX_FLOW, txFlow);
2727
2728
2729        edge_port->shadowLCR &= ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
2730        edge_port->shadowLCR |= (lData | lParity | lStop);
2731
2732        edge_port->validDataMask = mask;
2733
2734        /* Send the updated LCR value to the EdgePort */
2735        status = send_cmd_write_uart_register(edge_port, LCR,
2736                                                        edge_port->shadowLCR);
2737        if (status != 0)
2738                return;
2739
2740        /* set up the MCR register and send it to the EdgePort */
2741        edge_port->shadowMCR = MCR_MASTER_IE;
2742        if (cflag & CBAUD)
2743                edge_port->shadowMCR |= (MCR_DTR | MCR_RTS);
2744
2745        status = send_cmd_write_uart_register(edge_port, MCR,
2746                                                edge_port->shadowMCR);
2747        if (status != 0)
2748                return;
2749
2750        /* Determine divisor based on baud rate */
2751        baud = tty_get_baud_rate(tty);
2752        if (!baud) {
2753                /* pick a default, any default... */
2754                baud = 9600;
2755        }
2756
2757        dbg("%s - baud rate = %d", __func__, baud);
2758        status = send_cmd_write_baud_rate(edge_port, baud);
2759        if (status == -1) {
2760                /* Speed change was not possible - put back the old speed */
2761                baud = tty_termios_baud_rate(old_termios);
2762                tty_encode_baud_rate(tty, baud, baud);
2763        }
2764        return;
2765}
2766
2767
2768/****************************************************************************
2769 * unicode_to_ascii
2770 *      Turns a string from Unicode into ASCII.
2771 *      Doesn't do a good job with any characters that are outside the normal
2772 *      ASCII range, but it's only for debugging...
2773 *      NOTE: expects the unicode in LE format
2774 ****************************************************************************/
2775static void unicode_to_ascii(char *string, int buflen,
2776                                        __le16 *unicode, int unicode_size)
2777{
2778        int i;
2779
2780        if (buflen <= 0)        /* never happens, but... */
2781                return;
2782        --buflen;               /* space for nul */
2783
2784        for (i = 0; i < unicode_size; i++) {
2785                if (i >= buflen)
2786                        break;
2787                string[i] = (char)(le16_to_cpu(unicode[i]));
2788        }
2789        string[i] = 0x00;
2790}
2791
2792
2793/****************************************************************************
2794 * get_manufacturing_desc
2795 *      reads in the manufacturing descriptor and stores it into the serial
2796 *      structure.
2797 ****************************************************************************/
2798static void get_manufacturing_desc(struct edgeport_serial *edge_serial)
2799{
2800        int response;
2801
2802        dbg("getting manufacturer descriptor");
2803
2804        response = rom_read(edge_serial->serial,
2805                                (EDGE_MANUF_DESC_ADDR & 0xffff0000) >> 16,
2806                                (__u16)(EDGE_MANUF_DESC_ADDR & 0x0000ffff),
2807                                EDGE_MANUF_DESC_LEN,
2808                                (__u8 *)(&edge_serial->manuf_descriptor));
2809
2810        if (response < 1)
2811                dev_err(&edge_serial->serial->dev->dev,
2812                        "error in getting manufacturer descriptor\n");
2813        else {
2814                char string[30];
2815                dbg("**Manufacturer Descriptor");
2816                dbg("  RomSize:        %dK",
2817                        edge_serial->manuf_descriptor.RomSize);
2818                dbg("  RamSize:        %dK",
2819                        edge_serial->manuf_descriptor.RamSize);
2820                dbg("  CpuRev:         %d",
2821                        edge_serial->manuf_descriptor.CpuRev);
2822                dbg("  BoardRev:       %d",
2823                        edge_serial->manuf_descriptor.BoardRev);
2824                dbg("  NumPorts:       %d",
2825                        edge_serial->manuf_descriptor.NumPorts);
2826                dbg("  DescDate:       %d/%d/%d",
2827                        edge_serial->manuf_descriptor.DescDate[0],
2828                        edge_serial->manuf_descriptor.DescDate[1],
2829                        edge_serial->manuf_descriptor.DescDate[2]+1900);
2830                unicode_to_ascii(string, sizeof(string),
2831                        edge_serial->manuf_descriptor.SerialNumber,
2832                        edge_serial->manuf_descriptor.SerNumLength/2);
2833                dbg("  SerialNumber: %s", string);
2834                unicode_to_ascii(string, sizeof(string),
2835                        edge_serial->manuf_descriptor.AssemblyNumber,
2836                        edge_serial->manuf_descriptor.AssemblyNumLength/2);
2837                dbg("  AssemblyNumber: %s", string);
2838                unicode_to_ascii(string, sizeof(string),
2839                    edge_serial->manuf_descriptor.OemAssyNumber,
2840                    edge_serial->manuf_descriptor.OemAssyNumLength/2);
2841                dbg("  OemAssyNumber:  %s", string);
2842                dbg("  UartType:       %d",
2843                        edge_serial->manuf_descriptor.UartType);
2844                dbg("  IonPid:         %d",
2845                        edge_serial->manuf_descriptor.IonPid);
2846                dbg("  IonConfig:      %d",
2847                        edge_serial->manuf_descriptor.IonConfig);
2848        }
2849}
2850
2851
2852/****************************************************************************
2853 * get_boot_desc
2854 *      reads in the bootloader descriptor and stores it into the serial
2855 *      structure.
2856 ****************************************************************************/
2857static void get_boot_desc(struct edgeport_serial *edge_serial)
2858{
2859        int response;
2860
2861        dbg("getting boot descriptor");
2862
2863        response = rom_read(edge_serial->serial,
2864                                (EDGE_BOOT_DESC_ADDR & 0xffff0000) >> 16,
2865                                (__u16)(EDGE_BOOT_DESC_ADDR & 0x0000ffff),
2866                                EDGE_BOOT_DESC_LEN,
2867                                (__u8 *)(&edge_serial->boot_descriptor));
2868
2869        if (response < 1)
2870                dev_err(&edge_serial->serial->dev->dev,
2871                                "error in getting boot descriptor\n");
2872        else {
2873                dbg("**Boot Descriptor:");
2874                dbg("  BootCodeLength: %d",
2875                    le16_to_cpu(edge_serial->boot_descriptor.BootCodeLength));
2876                dbg("  MajorVersion:   %d",
2877                        edge_serial->boot_descriptor.MajorVersion);
2878                dbg("  MinorVersion:   %d",
2879                        edge_serial->boot_descriptor.MinorVersion);
2880                dbg("  BuildNumber:    %d",
2881                        le16_to_cpu(edge_serial->boot_descriptor.BuildNumber));
2882                dbg("  Capabilities:   0x%x",
2883                      le16_to_cpu(edge_serial->boot_descriptor.Capabilities));
2884                dbg("  UConfig0:       %d",
2885                        edge_serial->boot_descriptor.UConfig0);
2886                dbg("  UConfig1:       %d",
2887                        edge_serial->boot_descriptor.UConfig1);
2888        }
2889}
2890
2891
2892/****************************************************************************
2893 * load_application_firmware
2894 *      This is called to load the application firmware to the device
2895 ****************************************************************************/
2896static void load_application_firmware(struct edgeport_serial *edge_serial)
2897{
2898        const struct ihex_binrec *rec;
2899        const struct firmware *fw;
2900        const char *fw_name;
2901        const char *fw_info;
2902        int response;
2903        __u32 Operaddr;
2904        __u16 build;
2905
2906        switch (edge_serial->product_info.iDownloadFile) {
2907                case EDGE_DOWNLOAD_FILE_I930:
2908                        fw_info = "downloading firmware version (930)";
2909                        fw_name = "edgeport/down.fw";
2910                        break;
2911
2912                case EDGE_DOWNLOAD_FILE_80251:
2913                        fw_info = "downloading firmware version (80251)";
2914                        fw_name = "edgeport/down2.fw";
2915                        break;
2916
2917                case EDGE_DOWNLOAD_FILE_NONE:
2918                        dbg     ("No download file specified, skipping download\n");
2919                        return;
2920
2921                default:
2922                        return;
2923        }
2924
2925        response = request_ihex_firmware(&fw, fw_name,
2926                                    &edge_serial->serial->dev->dev);
2927        if (response) {
2928                printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
2929                       fw_name, response);
2930                return;
2931        }
2932
2933        rec = (const struct ihex_binrec *)fw->data;
2934        build = (rec->data[2] << 8) | rec->data[3];
2935
2936        dbg("%s %d.%d.%d", fw_info, rec->data[0], rec->data[1], build);
2937
2938        edge_serial->product_info.FirmwareMajorVersion = fw->data[0];
2939        edge_serial->product_info.FirmwareMinorVersion = fw->data[1];
2940        edge_serial->product_info.FirmwareBuildNumber = cpu_to_le16(build);
2941
2942        for (rec = ihex_next_binrec(rec); rec;
2943             rec = ihex_next_binrec(rec)) {
2944                Operaddr = be32_to_cpu(rec->addr);
2945                response = sram_write(edge_serial->serial,
2946                                     Operaddr >> 16,
2947                                     Operaddr & 0xFFFF,
2948                                     be16_to_cpu(rec->len),
2949                                     &rec->data[0]);
2950                if (response < 0) {
2951                        dev_err(&edge_serial->serial->dev->dev,
2952                                "sram_write failed (%x, %x, %d)\n",
2953                                Operaddr >> 16, Operaddr & 0xFFFF,
2954                                be16_to_cpu(rec->len));
2955                        break;
2956                }
2957        }
2958
2959        dbg("sending exec_dl_code");
2960        response = usb_control_msg (edge_serial->serial->dev, 
2961                                    usb_sndctrlpipe(edge_serial->serial->dev, 0), 
2962                                    USB_REQUEST_ION_EXEC_DL_CODE, 
2963                                    0x40, 0x4000, 0x0001, NULL, 0, 3000);
2964
2965        release_firmware(fw);
2966        return;
2967}
2968
2969
2970/****************************************************************************
2971 * edge_startup
2972 ****************************************************************************/
2973static int edge_startup(struct usb_serial *serial)
2974{
2975        struct edgeport_serial *edge_serial;
2976        struct edgeport_port *edge_port;
2977        struct usb_device *dev;
2978        int i, j;
2979        int response;
2980        bool interrupt_in_found;
2981        bool bulk_in_found;
2982        bool bulk_out_found;
2983        static __u32 descriptor[3] = {  EDGE_COMPATIBILITY_MASK0,
2984                                        EDGE_COMPATIBILITY_MASK1,
2985                                        EDGE_COMPATIBILITY_MASK2 };
2986
2987        dev = serial->dev;
2988
2989        /* create our private serial structure */
2990        edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
2991        if (edge_serial == NULL) {
2992                dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
2993                return -ENOMEM;
2994        }
2995        spin_lock_init(&edge_serial->es_lock);
2996        edge_serial->serial = serial;
2997        usb_set_serial_data(serial, edge_serial);
2998
2999        /* get the name for the device from the device */
3000        i = get_string(dev, dev->descriptor.iManufacturer,

3001            &edge_serial->name[0], MAX_NAME_LEN+1);
3002        edge_serial->name[i++] = ' ';
3003        get_string(dev, dev->descriptor.iProduct,
3004            &edge_serial->name[i], MAX_NAME_LEN+2 - i);
3005
3006        dev_info(&serial->dev->dev, "%s detected\n", edge_serial->name);
3007
3008        /* Read the epic descriptor */
3009        if (get_epic_descriptor(edge_serial) <= 0) {
3010                /* memcpy descriptor to Supports structures */
3011                memcpy(&edge_serial->epic_descriptor.Supports, descriptor,
3012                       sizeof(struct edge_compatibility_bits));
3013
3014                /* get the manufacturing descriptor for this device */
3015                get_manufacturing_desc(edge_serial);
3016
3017                /* get the boot descriptor */
3018                get_boot_desc(edge_serial);
3019
3020                get_product_info(edge_serial);
3021        }
3022
3023        /* set the number of ports from the manufacturing description */
3024        /* serial->num_ports = serial->product_info.NumPorts; */
3025        if ((!edge_serial->is_epic) &&
3026            (edge_serial->product_info.NumPorts != serial->num_ports)) {
3027                dev_warn(&serial->dev->dev, "Device Reported %d serial ports "
3028                         "vs. core thinking we have %d ports, email "
3029                         "greg@kroah.com this information.\n",
3030                         edge_serial->product_info.NumPorts,
3031                         serial->num_ports);
3032        }
3033
3034        dbg("%s - time 1 %ld", __func__, jiffies);
3035
3036        /* If not an EPiC device */
3037        if (!edge_serial->is_epic) {
3038                /* now load the application firmware into this device */
3039                load_application_firmware(edge_serial);
3040
3041                dbg("%s - time 2 %ld", __func__, jiffies);
3042
3043                /* Check current Edgeport EEPROM and update if necessary */
3044                update_edgeport_E2PROM(edge_serial);
3045
3046                dbg("%s - time 3 %ld", __func__, jiffies);
3047
3048                /* set the configuration to use #1 */
3049/*              dbg("set_configuration 1"); */
3050/*              usb_set_configuration (dev, 1); */
3051        }
3052        dbg("  FirmwareMajorVersion  %d.%d.%d",
3053            edge_serial->product_info.FirmwareMajorVersion,
3054            edge_serial->product_info.FirmwareMinorVersion,
3055            le16_to_cpu(edge_serial->product_info.FirmwareBuildNumber));
3056
3057        /* we set up the pointers to the endpoints in the edge_open function,
3058         * as the structures aren't created yet. */
3059
3060        /* set up our port private structures */
3061        for (i = 0; i < serial->num_ports; ++i) {
3062                edge_port = kmalloc(sizeof(struct edgeport_port), GFP_KERNEL);
3063                if (edge_port == NULL) {
3064                        dev_err(&serial->dev->dev, "%s - Out of memory\n",
3065                                                                   __func__);
3066                        for (j = 0; j < i; ++j) {
3067                                kfree(usb_get_serial_port_data(serial->port[j]));
3068                                usb_set_serial_port_data(serial->port[j],
3069                                                                        NULL);
3070                        }
3071                        usb_set_serial_data(serial, NULL);
3072                        kfree(edge_serial);
3073                        return -ENOMEM;
3074                }
3075                memset(edge_port, 0, sizeof(struct edgeport_port));
3076                spin_lock_init(&edge_port->ep_lock);
3077                edge_port->port = serial->port[i];
3078                usb_set_serial_port_data(serial->port[i], edge_port);
3079        }
3080
3081        response = 0;
3082
3083        if (edge_serial->is_epic) {
3084                /* EPIC thing, set up our interrupt polling now and our read
3085                 * urb, so that the device knows it really is connected. */
3086                interrupt_in_found = bulk_in_found = bulk_out_found = false;
3087                for (i = 0; i < serial->interface->altsetting[0]
3088                                                .desc.bNumEndpoints; ++i) {
3089                        struct usb_endpoint_descriptor *endpoint;
3090                        int buffer_size;
3091
3092                        endpoint = &serial->interface->altsetting[0].
3093                                                        endpoint[i].desc;
3094                        buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
3095                        if (!interrupt_in_found &&
3096                            (usb_endpoint_is_int_in(endpoint))) {
3097                                /* we found a interrupt in endpoint */
3098                                dbg("found interrupt in");
3099
3100                                /* not set up yet, so do it now */
3101                                edge_serial->interrupt_read_urb =
3102                                                usb_alloc_urb(0, GFP_KERNEL);
3103                                if (!edge_serial->interrupt_read_urb) {
3104                                        dev_err(&dev->dev, "out of memory\n");
3105                                        return -ENOMEM;
3106                                }
3107                                edge_serial->interrupt_in_buffer =
3108                                        kmalloc(buffer_size, GFP_KERNEL);
3109                                if (!edge_serial->interrupt_in_buffer) {
3110                                        dev_err(&dev->dev, "out of memory\n");
3111                                        usb_free_urb(edge_serial->interrupt_read_urb);
3112                                        return -ENOMEM;
3113                                }
3114                                edge_serial->interrupt_in_endpoint =
3115                                                endpoint->bEndpointAddress;
3116
3117                                /* set up our interrupt urb */
3118                                usb_fill_int_urb(
3119                                        edge_serial->interrupt_read_urb,
3120                                        dev,
3121                                        usb_rcvintpipe(dev,
3122                                                endpoint->bEndpointAddress),
3123                                        edge_serial->interrupt_in_buffer,
3124                                        buffer_size,
3125                                        edge_interrupt_callback,
3126                                        edge_serial,
3127                                        endpoint->bInterval);
3128
3129                                interrupt_in_found = true;
3130                        }
3131
3132                        if (!bulk_in_found &&
3133                                (usb_endpoint_is_bulk_in(endpoint))) {
3134                                /* we found a bulk in endpoint */
3135                                dbg("found bulk in");
3136
3137                                /* not set up yet, so do it now */
3138                                edge_serial->read_urb =
3139                                                usb_alloc_urb(0, GFP_KERNEL);
3140                                if (!edge_serial->read_urb) {
3141                                        dev_err(&dev->dev, "out of memory\n");
3142                                        return -ENOMEM;
3143                                }
3144                                edge_serial->bulk_in_buffer =
3145                                        kmalloc(buffer_size, GFP_KERNEL);
3146                                if (!edge_serial->bulk_in_buffer) {
3147                                        dev_err(&dev->dev, "out of memory\n");
3148                                        usb_free_urb(edge_serial->read_urb);
3149                                        return -ENOMEM;
3150                                }
3151                                edge_serial->bulk_in_endpoint =
3152                                                endpoint->bEndpointAddress;
3153
3154                                /* set up our bulk in urb */
3155                                usb_fill_bulk_urb(edge_serial->read_urb, dev,
3156                                        usb_rcvbulkpipe(dev,
3157                                                endpoint->bEndpointAddress),
3158                                        edge_serial->bulk_in_buffer,
3159                                        le16_to_cpu(endpoint->wMaxPacketSize),
3160                                        edge_bulk_in_callback,
3161                                        edge_serial);
3162                                bulk_in_found = true;
3163                        }
3164
3165                        if (!bulk_out_found &&
3166                            (usb_endpoint_is_bulk_out(endpoint))) {
3167                                /* we found a bulk out endpoint */
3168                                dbg("found bulk out");
3169                                edge_serial->bulk_out_endpoint =
3170                                                endpoint->bEndpointAddress;
3171                                bulk_out_found = true;
3172                        }
3173                }
3174
3175                if (!interrupt_in_found || !bulk_in_found || !bulk_out_found) {
3176                        dev_err(&dev->dev, "Error - the proper endpoints "
3177                                "were not found!\n");
3178                        return -ENODEV;
3179                }
3180
3181                /* start interrupt read for this edgeport this interrupt will
3182                 * continue as long as the edgeport is connected */
3183                response = usb_submit_urb(edge_serial->interrupt_read_urb,
3184                                                                GFP_KERNEL);
3185                if (response)
3186                        dev_err(&dev->dev,
3187                                "%s - Error %d submitting control urb\n",
3188                                __func__, response);
3189        }
3190        return response;
3191}
3192
3193
3194/****************************************************************************
3195 * edge_disconnect
3196 *      This function is called whenever the device is removed from the usb bus.
3197 ****************************************************************************/
3198static void edge_disconnect(struct usb_serial *serial)
3199{
3200        struct edgeport_serial *edge_serial = usb_get_serial_data(serial);
3201
3202        dbg("%s", __func__);
3203
3204        /* stop reads and writes on all ports */
3205        /* free up our endpoint stuff */
3206        if (edge_serial->is_epic) {
3207                usb_kill_urb(edge_serial->interrupt_read_urb);
3208                usb_free_urb(edge_serial->interrupt_read_urb);
3209                kfree(edge_serial->interrupt_in_buffer);
3210
3211                usb_kill_urb(edge_serial->read_urb);
3212                usb_free_urb(edge_serial->read_urb);
3213                kfree(edge_serial->bulk_in_buffer);
3214        }
3215}
3216
3217
3218/****************************************************************************
3219 * edge_release
3220 *      This function is called when the device structure is deallocated.
3221 ****************************************************************************/
3222static void edge_release(struct usb_serial *serial)
3223{
3224        struct edgeport_serial *edge_serial = usb_get_serial_data(serial);
3225        int i;
3226
3227        dbg("%s", __func__);
3228
3229        for (i = 0; i < serial->num_ports; ++i)
3230                kfree(usb_get_serial_port_data(serial->port[i]));
3231
3232        kfree(edge_serial);
3233}
3234
3235
3236/****************************************************************************
3237 * edgeport_init
3238 *      This is called by the module subsystem, or on startup to initialize us
3239 ****************************************************************************/
3240static int __init edgeport_init(void)
3241{
3242        int retval;
3243
3244        retval = usb_serial_register(&edgeport_2port_device);
3245        if (retval)
3246                goto failed_2port_device_register;
3247        retval = usb_serial_register(&edgeport_4port_device);
3248        if (retval)
3249                goto failed_4port_device_register;
3250        retval = usb_serial_register(&edgeport_8port_device);
3251        if (retval)
3252                goto failed_8port_device_register;
3253        retval = usb_serial_register(&epic_device);
3254        if (retval)
3255                goto failed_epic_device_register;
3256        retval = usb_register(&io_driver);
3257        if (retval)
3258                goto failed_usb_register;
3259        atomic_set(&CmdUrbs, 0);
3260        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
3261               DRIVER_DESC "\n");
3262        return 0;
3263
3264failed_usb_register:
3265        usb_serial_deregister(&epic_device);
3266failed_epic_device_register:
3267        usb_serial_deregister(&edgeport_8port_device);
3268failed_8port_device_register:
3269        usb_serial_deregister(&edgeport_4port_device);
3270failed_4port_device_register:
3271        usb_serial_deregister(&edgeport_2port_device);
3272failed_2port_device_register:
3273        return retval;
3274}
3275
3276
3277/****************************************************************************
3278 * edgeport_exit
3279 *      Called when the driver is about to be unloaded.
3280 ****************************************************************************/
3281static void __exit edgeport_exit (void)
3282{
3283        usb_deregister(&io_driver);
3284        usb_serial_deregister(&edgeport_2port_device);
3285        usb_serial_deregister(&edgeport_4port_device);
3286        usb_serial_deregister(&edgeport_8port_device);
3287        usb_serial_deregister(&epic_device);
3288}
3289
3290module_init(edgeport_init);
3291module_exit(edgeport_exit);
3292
3293/* Module information */
3294MODULE_AUTHOR(DRIVER_AUTHOR);
3295MODULE_DESCRIPTION(DRIVER_DESC);
3296MODULE_LICENSE("GPL");
3297MODULE_FIRMWARE("edgeport/boot.fw");
3298MODULE_FIRMWARE("edgeport/boot2.fw");
3299MODULE_FIRMWARE("edgeport/down.fw");
3300MODULE_FIRMWARE("edgeport/down2.fw");
3301
3302module_param(debug, bool, S_IRUGO | S_IWUSR);
3303MODULE_PARM_DESC(debug, "Debug enabled or not");
3304