drivers/usb/serial/io_ti.c

   1 /*
   2  * Edgeport USB Serial Converter driver
   3  *
   4  * Copyright (C) 2000-2002 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  *      EP/1 EP/2 EP/4 EP/21 EP/22 EP/221 EP/42 EP/421 WATCHPORT
  14  *
  15  * For questions or problems with this driver, contact Inside Out
  16  * Networks technical support, or Peter Berger <pberger@brimson.com>,
  17  * or Al Borchers <alborchers@steinerpoint.com>.
  18  */
  19
  20 #include <linux/kernel.h>
  21 #include <linux/jiffies.h>
  22 #include <linux/errno.h>
  23 #include <linux/init.h>
  24 #include <linux/slab.h>
  25 #include <linux/tty.h>
  26 #include <linux/tty_driver.h>
  27 #include <linux/tty_flip.h>
  28 #include <linux/module.h>
  29 #include <linux/spinlock.h>
  30 #include <linux/mutex.h>
  31 #include <linux/serial.h>
  32 #include <linux/kfifo.h>
  33 #include <linux/ioctl.h>
  34 #include <linux/firmware.h>
  35 #include <linux/uaccess.h>
  36 #include <linux/usb.h>
  37 #include <linux/usb/serial.h>
  38
  39 #include "io_16654.h"
  40 #include "io_usbvend.h"
  41 #include "io_ti.h"
  42
  43 /*
  44  * Version Information
  45  */
  46 #define DRIVER_VERSION "v0.7mode043006"
  47 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com> and David Iacovelli"
  48 #define DRIVER_DESC "Edgeport USB Serial Driver"
  49
  50 #define EPROM_PAGE_SIZE         64
  51
  52
  53 /* different hardware types */
  54 #define HARDWARE_TYPE_930       0
  55 #define HARDWARE_TYPE_TIUMP     1
  56
  57 /* IOCTL_PRIVATE_TI_GET_MODE Definitions */
  58 #define TI_MODE_CONFIGURING     0   /* Device has not entered start device */
  59 #define TI_MODE_BOOT            1   /* Staying in boot mode                */
  60 #define TI_MODE_DOWNLOAD        2   /* Made it to download mode            */
  61 #define TI_MODE_TRANSITIONING   3   /* Currently in boot mode but
  62                                        transitioning to download mode      */
  63
  64 /* read urb state */
  65 #define EDGE_READ_URB_RUNNING   0
  66 #define EDGE_READ_URB_STOPPING  1
  67 #define EDGE_READ_URB_STOPPED   2
  68
  69 #define EDGE_CLOSING_WAIT       4000    /* in .01 sec */
  70
  71 #define EDGE_OUT_BUF_SIZE       1024
  72
  73
  74 /* Product information read from the Edgeport */
  75 struct product_info {
  76         int     TiMode;                 /* Current TI Mode  */
  77         __u8    hardware_type;          /* Type of hardware */
  78 } __attribute__((packed));
  79
  80 struct edgeport_port {
  81         __u16 uart_base;
  82         __u16 dma_address;
  83         __u8 shadow_msr;
  84         __u8 shadow_mcr;
  85         __u8 shadow_lsr;
  86         __u8 lsr_mask;
  87         __u32 ump_read_timeout;         /* Number of milliseconds the UMP will
  88                                            wait without data before completing
  89                                            a read short */
  90         int baud_rate;
  91         int close_pending;
  92         int lsr_event;
  93         struct async_icount     icount;
  94         wait_queue_head_t       delta_msr_wait; /* for handling sleeping while
  95                                                    waiting for msr change to
  96                                                    happen */
  97         struct edgeport_serial  *edge_serial;
  98         struct usb_serial_port  *port;
  99         __u8 bUartMode;         /* Port type, 0: RS232, etc. */
 100         spinlock_t ep_lock;
 101         int ep_read_urb_state;
 102         int ep_write_urb_in_use;
 103         struct kfifo write_fifo;
 104 };
 105
 106 struct edgeport_serial {
 107         struct product_info product_info;
 108         u8 TI_I2C_Type;                 /* Type of I2C in UMP */
 109         u8 TiReadI2C;                   /* Set to TRUE if we have read the
 110                                            I2c in Boot Mode */
 111         struct mutex es_lock;
 112         int num_ports_open;
 113         struct usb_serial *serial;
 114 };
 115
 116
 117 /* Devices that this driver supports */
 118 static const struct usb_device_id edgeport_1port_id_table[] = {
 119         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_1) },
 120         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1) },
 121         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1I) },
 122         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROXIMITY) },
 123         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOTION) },
 124         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOISTURE) },
 125         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_TEMPERATURE) },
 126         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_HUMIDITY) },
 127         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_POWER) },
 128         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_LIGHT) },
 129         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_RADIATION) },
 130         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_DISTANCE) },
 131         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_ACCELERATION) },
 132         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROX_DIST) },
 133         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_HP4CD) },
 134         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_PCI) },
 135         { }
 136 };
 137
 138 static const struct usb_device_id edgeport_2port_id_table[] = {
 139         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2) },
 140         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2C) },
 141         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2I) },
 142         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421) },
 143         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21) },
 144         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_42) },
 145         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4) },
 146         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4I) },
 147         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22I) },
 148         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_221C) },
 149         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22C) },
 150         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21C) },
 151         /* The 4, 8 and 16 port devices show up as multiple 2 port devices */
 152         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4S) },
 153         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8) },
 154         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8S) },
 155         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416) },
 156         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416B) },
 157         { }
 158 };
 159
 160 /* Devices that this driver supports */
 161 static const struct usb_device_id id_table_combined[] = {
 162         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_1) },
 163         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1) },
 164         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_TI3410_EDGEPORT_1I) },
 165         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROXIMITY) },
 166         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOTION) },
 167         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_MOISTURE) },
 168         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_TEMPERATURE) },
 169         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_HUMIDITY) },
 170         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_POWER) },
 171         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_LIGHT) },
 172         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_RADIATION) },
 173         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_DISTANCE) },
 174         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_ACCELERATION) },
 175         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_WP_PROX_DIST) },
 176         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_HP4CD) },
 177         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_PLUS_PWR_PCI) },
 178         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2) },
 179         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2C) },
 180         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_2I) },
 181         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_421) },
 182         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21) },
 183         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_42) },
 184         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4) },
 185         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4I) },
 186         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22I) },
 187         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_221C) },
 188         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_22C) },
 189         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_21C) },
 190         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_4S) },
 191         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8) },
 192         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_8S) },
 193         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416) },
 194         { USB_DEVICE(USB_VENDOR_ID_ION, ION_DEVICE_ID_TI_EDGEPORT_416B) },
 195         { }
 196 };
 197
 198 MODULE_DEVICE_TABLE(usb, id_table_combined);
 199
 200 static unsigned char OperationalMajorVersion;
 201 static unsigned char OperationalMinorVersion;
 202 static unsigned short OperationalBuildNumber;
 203
 204 static int closing_wait = EDGE_CLOSING_WAIT;
 205 static bool ignore_cpu_rev;
 206 static int default_uart_mode;           /* RS232 */
 207
 208 static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
 209                           unsigned char *data, int length);
 210
 211 static void stop_read(struct edgeport_port *edge_port);
 212 static int restart_read(struct edgeport_port *edge_port);
 213
 214 static void edge_set_termios(struct tty_struct *tty,
 215                 struct usb_serial_port *port, struct ktermios *old_termios);
 216 static void edge_send(struct tty_struct *tty);
 217
 218 /* sysfs attributes */
 219 static int edge_create_sysfs_attrs(struct usb_serial_port *port);
 220 static int edge_remove_sysfs_attrs(struct usb_serial_port *port);
 221
 222
 223 static int ti_vread_sync(struct usb_device *dev, __u8 request,
 224                                 __u16 value, __u16 index, u8 *data, int size)
 225 {
 226         int status;
 227
 228         status = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
 229                         (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN),
 230                         value, index, data, size, 1000);
 231         if (status < 0)
 232                 return status;
 233         if (status != size) {
 234                 dev_dbg(&dev->dev, "%s - wanted to write %d, but only wrote %d\n",
 235                         __func__, size, status);
 236                 return -ECOMM;
 237         }
 238         return 0;
 239 }
 240
 241 static int ti_vsend_sync(struct usb_device *dev, __u8 request,
 242                                 __u16 value, __u16 index, u8 *data, int size)
 243 {
 244         int status;
 245
 246         status = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
 247                         (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT),
 248                         value, index, data, size, 1000);
 249         if (status < 0)
 250                 return status;
 251         if (status != size) {
 252                 dev_dbg(&dev->dev, "%s - wanted to write %d, but only wrote %d\n",
 253                         __func__, size, status);
 254                 return -ECOMM;
 255         }
 256         return 0;
 257 }
 258
 259 static int send_cmd(struct usb_device *dev, __u8 command,
 260                                 __u8 moduleid, __u16 value, u8 *data,
 261                                 int size)
 262 {
 263         return ti_vsend_sync(dev, command, value, moduleid, data, size);
 264 }
 265
 266 /* clear tx/rx buffers and fifo in TI UMP */
 267 static int purge_port(struct usb_serial_port *port, __u16 mask)
 268 {
 269         int port_number = port->number - port->serial->minor;
 270
 271         dev_dbg(&port->dev, "%s - port %d, mask %x\n", __func__, port_number, mask);
 272
 273         return send_cmd(port->serial->dev,
 274                                         UMPC_PURGE_PORT,
 275                                         (__u8)(UMPM_UART1_PORT + port_number),
 276                                         mask,
 277                                         NULL,
 278                                         0);
 279 }
 280
 281 /**
 282  * read_download_mem - Read edgeport memory from TI chip
 283  * @dev: usb device pointer
 284  * @start_address: Device CPU address at which to read
 285  * @length: Length of above data
 286  * @address_type: Can read both XDATA and I2C
 287  * @buffer: pointer to input data buffer
 288  */
 289 static int read_download_mem(struct usb_device *dev, int start_address,
 290                                 int length, __u8 address_type, __u8 *buffer)
 291 {
 292         int status = 0;
 293         __u8 read_length;
 294         __be16 be_start_address;
 295
 296         dev_dbg(&dev->dev, "%s - @ %x for %d\n", __func__, start_address, length);
 297
 298         /* Read in blocks of 64 bytes
 299          * (TI firmware can't handle more than 64 byte reads)
 300          */
 301         while (length) {
 302                 if (length > 64)
 303                         read_length = 64;
 304                 else
 305                         read_length = (__u8)length;
 306
 307                 if (read_length > 1) {
 308                         dev_dbg(&dev->dev, "%s - @ %x for %d\n", __func__, start_address, read_length);
 309                 }
 310                 be_start_address = cpu_to_be16(start_address);
 311                 status = ti_vread_sync(dev, UMPC_MEMORY_READ,
 312                                         (__u16)address_type,
 313                                         (__force __u16)be_start_address,
 314                                         buffer, read_length);
 315
 316                 if (status) {
 317                         dev_dbg(&dev->dev, "%s - ERROR %x\n", __func__, status);
 318                         return status;
 319                 }
 320
 321                 if (read_length > 1)
 322                         usb_serial_debug_data(&dev->dev, __func__, read_length, buffer);
 323
 324                 /* Update pointers/length */
 325                 start_address += read_length;
 326                 buffer += read_length;
 327                 length -= read_length;
 328         }
 329
 330         return status;
 331 }
 332
 333 static int read_ram(struct usb_device *dev, int start_address,
 334                                                 int length, __u8 *buffer)
 335 {
 336         return read_download_mem(dev, start_address, length,
 337                                         DTK_ADDR_SPACE_XDATA, buffer);
 338 }
 339
 340 /* Read edgeport memory to a given block */
 341 static int read_boot_mem(struct edgeport_serial *serial,
 342                                 int start_address, int length, __u8 *buffer)
 343 {
 344         int status = 0;
 345         int i;
 346
 347         for (i = 0; i < length; i++) {
 348                 status = ti_vread_sync(serial->serial->dev,
 349                                 UMPC_MEMORY_READ, serial->TI_I2C_Type,
 350                                 (__u16)(start_address+i), &buffer[i], 0x01);
 351                 if (status) {
 352                         dev_dbg(&serial->serial->dev->dev, "%s - ERROR %x\n", __func__, status);
 353                         return status;
 354                 }
 355         }
 356
 357         dev_dbg(&serial->serial->dev->dev, "%s - start_address = %x, length = %d\n",
 358                 __func__, start_address, length);
 359         usb_serial_debug_data(&serial->serial->dev->dev, __func__, length, buffer);
 360
 361         serial->TiReadI2C = 1;
 362
 363         return status;
 364 }
 365
 366 /* Write given block to TI EPROM memory */
 367 static int write_boot_mem(struct edgeport_serial *serial,
 368                                 int start_address, int length, __u8 *buffer)
 369 {
 370         int status = 0;
 371         int i;
 372         u8 *temp;
 373
 374         /* Must do a read before write */
 375         if (!serial->TiReadI2C) {
 376                 temp = kmalloc(1, GFP_KERNEL);
 377                 if (!temp) {
 378                         dev_err(&serial->serial->dev->dev,
 379                                         "%s - out of memory\n", __func__);
 380                         return -ENOMEM;
 381                 }
 382                 status = read_boot_mem(serial, 0, 1, temp);
 383                 kfree(temp);
 384                 if (status)
 385                         return status;
 386         }
 387
 388         for (i = 0; i < length; ++i) {
 389                 status = ti_vsend_sync(serial->serial->dev,
 390                                 UMPC_MEMORY_WRITE, buffer[i],
 391                                 (__u16)(i + start_address), NULL, 0);
 392                 if (status)
 393                         return status;
 394         }
 395
 396         dev_dbg(&serial->serial->dev->dev, "%s - start_sddr = %x, length = %d\n", __func__, start_address, length);
 397         usb_serial_debug_data(&serial->serial->dev->dev, __func__, length, buffer);
 398
 399         return status;
 400 }
 401
 402
 403 /* Write edgeport I2C memory to TI chip */
 404 static int write_i2c_mem(struct edgeport_serial *serial,
 405                 int start_address, int length, __u8 address_type, __u8 *buffer)
 406 {
 407         struct device *dev = &serial->serial->dev->dev;
 408         int status = 0;
 409         int write_length;
 410         __be16 be_start_address;
 411
 412         /* We can only send a maximum of 1 aligned byte page at a time */
 413
 414         /* calculate the number of bytes left in the first page */
 415         write_length = EPROM_PAGE_SIZE -
 416                                 (start_address & (EPROM_PAGE_SIZE - 1));
 417
 418         if (write_length > length)
 419                 write_length = length;
 420
 421         dev_dbg(dev, "%s - BytesInFirstPage Addr = %x, length = %d\n",
 422                 __func__, start_address, write_length);
 423         usb_serial_debug_data(dev, __func__, write_length, buffer);
 424
 425         /* Write first page */
 426         be_start_address = cpu_to_be16(start_address);
 427         status = ti_vsend_sync(serial->serial->dev,
 428                                 UMPC_MEMORY_WRITE, (__u16)address_type,
 429                                 (__force __u16)be_start_address,
 430                                 buffer, write_length);
 431         if (status) {
 432                 dev_dbg(dev, "%s - ERROR %d\n", __func__, status);
 433                 return status;
 434         }
 435
 436         length          -= write_length;
 437         start_address   += write_length;
 438         buffer          += write_length;
 439
 440         /* We should be aligned now -- can write
 441            max page size bytes at a time */
 442         while (length) {
 443                 if (length > EPROM_PAGE_SIZE)
 444                         write_length = EPROM_PAGE_SIZE;
 445                 else
 446                         write_length = length;
 447
 448                 dev_dbg(dev, "%s - Page Write Addr = %x, length = %d\n",
 449                         __func__, start_address, write_length);
 450                 usb_serial_debug_data(dev, __func__, write_length, buffer);
 451
 452                 /* Write next page */
 453                 be_start_address = cpu_to_be16(start_address);
 454                 status = ti_vsend_sync(serial->serial->dev, UMPC_MEMORY_WRITE,
 455                                 (__u16)address_type,
 456                                 (__force __u16)be_start_address,
 457                                 buffer, write_length);
 458                 if (status) {
 459                         dev_err(dev, "%s - ERROR %d\n", __func__, status);
 460                         return status;
 461                 }
 462
 463                 length          -= write_length;
 464                 start_address   += write_length;
 465                 buffer          += write_length;
 466         }
 467         return status;
 468 }
 469
 470 /* Examine the UMP DMA registers and LSR
 471  *
 472  * Check the MSBit of the X and Y DMA byte count registers.
 473  * A zero in this bit indicates that the TX DMA buffers are empty
 474  * then check the TX Empty bit in the UART.
 475  */
 476 static int tx_active(struct edgeport_port *port)
 477 {
 478         int status;
 479         struct out_endpoint_desc_block *oedb;
 480         __u8 *lsr;
 481         int bytes_left = 0;
 482
 483         oedb = kmalloc(sizeof(*oedb), GFP_KERNEL);
 484         if (!oedb) {
 485                 dev_err(&port->port->dev, "%s - out of memory\n", __func__);
 486                 return -ENOMEM;
 487         }
 488
 489         lsr = kmalloc(1, GFP_KERNEL);   /* Sigh, that's right, just one byte,
 490                                            as not all platforms can do DMA
 491                                            from stack */
 492         if (!lsr) {
 493                 kfree(oedb);
 494                 return -ENOMEM;
 495         }
 496         /* Read the DMA Count Registers */
 497         status = read_ram(port->port->serial->dev, port->dma_address,
 498                                                 sizeof(*oedb), (void *)oedb);
 499         if (status)
 500                 goto exit_is_tx_active;
 501
 502         dev_dbg(&port->port->dev, "%s - XByteCount    0x%X\n", __func__, oedb->XByteCount);
 503
 504         /* and the LSR */
 505         status = read_ram(port->port->serial->dev,
 506                         port->uart_base + UMPMEM_OFFS_UART_LSR, 1, lsr);
 507
 508         if (status)
 509                 goto exit_is_tx_active;
 510         dev_dbg(&port->port->dev, "%s - LSR = 0x%X\n", __func__, *lsr);
 511
 512         /* If either buffer has data or we are transmitting then return TRUE */
 513         if ((oedb->XByteCount & 0x80) != 0)
 514                 bytes_left += 64;
 515
 516         if ((*lsr & UMP_UART_LSR_TX_MASK) == 0)
 517                 bytes_left += 1;
 518
 519         /* We return Not Active if we get any kind of error */
 520 exit_is_tx_active:
 521         dev_dbg(&port->port->dev, "%s - return %d\n", __func__, bytes_left);
 522
 523         kfree(lsr);
 524         kfree(oedb);
 525         return bytes_left;
 526 }
 527
 528 static void chase_port(struct edgeport_port *port, unsigned long timeout,
 529                                                                 int flush)
 530 {
 531         int baud_rate;
 532         struct tty_struct *tty = tty_port_tty_get(&port->port->port);
 533         struct usb_serial *serial = port->port->serial;
 534         wait_queue_t wait;
 535         unsigned long flags;
 536
 537         if (!timeout)
 538                 timeout = (HZ * EDGE_CLOSING_WAIT)/100;
 539
 540         /* wait for data to drain from the buffer */
 541         spin_lock_irqsave(&port->ep_lock, flags);
 542         init_waitqueue_entry(&wait, current);
 543         add_wait_queue(&tty->write_wait, &wait);
 544         for (;;) {
 545                 set_current_state(TASK_INTERRUPTIBLE);
 546                 if (kfifo_len(&port->write_fifo) == 0
 547                 || timeout == 0 || signal_pending(current)
 548                 || serial->disconnected)
 549                         /* disconnect */
 550                         break;
 551                 spin_unlock_irqrestore(&port->ep_lock, flags);
 552                 timeout = schedule_timeout(timeout);
 553                 spin_lock_irqsave(&port->ep_lock, flags);
 554         }
 555         set_current_state(TASK_RUNNING);
 556         remove_wait_queue(&tty->write_wait, &wait);
 557         if (flush)
 558                 kfifo_reset_out(&port->write_fifo);
 559         spin_unlock_irqrestore(&port->ep_lock, flags);
 560         tty_kref_put(tty);
 561
 562         /* wait for data to drain from the device */
 563         timeout += jiffies;
 564         while ((long)(jiffies - timeout) < 0 && !signal_pending(current)
 565                                                 && !serial->disconnected) {
 566                 /* not disconnected */
 567                 if (!tx_active(port))
 568                         break;
 569                 msleep(10);
 570         }
 571
 572         /* disconnected */
 573         if (serial->disconnected)
 574                 return;
 575
 576         /* wait one more character time, based on baud rate */
 577         /* (tx_active doesn't seem to wait for the last byte) */
 578         baud_rate = port->baud_rate;
 579         if (baud_rate == 0)
 580                 baud_rate = 50;
 581         msleep(max(1, DIV_ROUND_UP(10000, baud_rate)));
 582 }
 583
 584 static int choose_config(struct usb_device *dev)
 585 {
 586         /*
 587          * There may be multiple configurations on this device, in which case
 588          * we would need to read and parse all of them to find out which one
 589          * we want. However, we just support one config at this point,
 590          * configuration # 1, which is Config Descriptor 0.
 591          */
 592
 593         dev_dbg(&dev->dev, "%s - Number of Interfaces = %d\n",
 594                 __func__, dev->config->desc.bNumInterfaces);
 595         dev_dbg(&dev->dev, "%s - MAX Power            = %d\n",
 596                 __func__, dev->config->desc.bMaxPower * 2);
 597
 598         if (dev->config->desc.bNumInterfaces != 1) {
 599                 dev_err(&dev->dev, "%s - bNumInterfaces is not 1, ERROR!\n", __func__);
 600                 return -ENODEV;
 601         }
 602
 603         return 0;
 604 }
 605
 606 static int read_rom(struct edgeport_serial *serial,
 607                                 int start_address, int length, __u8 *buffer)
 608 {
 609         int status;
 610
 611         if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {
 612                 status = read_download_mem(serial->serial->dev,
 613                                                start_address,
 614                                                length,
 615                                                serial->TI_I2C_Type,
 616                                                buffer);
 617         } else {
 618                 status = read_boot_mem(serial, start_address, length,
 619                                                                 buffer);
 620         }
 621         return status;
 622 }
 623
 624 static int write_rom(struct edgeport_serial *serial, int start_address,
 625                                                 int length, __u8 *buffer)
 626 {
 627         if (serial->product_info.TiMode == TI_MODE_BOOT)
 628                 return write_boot_mem(serial, start_address, length,
 629                                                                 buffer);
 630
 631         if (serial->product_info.TiMode == TI_MODE_DOWNLOAD)
 632                 return write_i2c_mem(serial, start_address, length,
 633                                                 serial->TI_I2C_Type, buffer);
 634         return -EINVAL;
 635 }
 636
 637
 638
 639 /* Read a descriptor header from I2C based on type */
 640 static int get_descriptor_addr(struct edgeport_serial *serial,
 641                                 int desc_type, struct ti_i2c_desc *rom_desc)
 642 {
 643         int start_address;
 644         int status;
 645
 646         /* Search for requested descriptor in I2C */
 647         start_address = 2;
 648         do {
 649                 status = read_rom(serial,
 650                                    start_address,
 651                                    sizeof(struct ti_i2c_desc),
 652                                    (__u8 *)rom_desc);
 653                 if (status)
 654                         return 0;
 655
 656                 if (rom_desc->Type == desc_type)
 657                         return start_address;
 658
 659                 start_address = start_address + sizeof(struct ti_i2c_desc)
 660                                                         + rom_desc->Size;
 661
 662         } while ((start_address < TI_MAX_I2C_SIZE) && rom_desc->Type);
 663
 664         return 0;
 665 }
 666
 667 /* Validate descriptor checksum */
 668 static int valid_csum(struct ti_i2c_desc *rom_desc, __u8 *buffer)
 669 {
 670         __u16 i;
 671         __u8 cs = 0;
 672
 673         for (i = 0; i < rom_desc->Size; i++)
 674                 cs = (__u8)(cs + buffer[i]);
 675
 676         if (cs != rom_desc->CheckSum) {
 677                 pr_debug("%s - Mismatch %x - %x", __func__, rom_desc->CheckSum, cs);
 678                 return -EINVAL;
 679         }
 680         return 0;
 681 }
 682
 683 /* Make sure that the I2C image is good */
 684 static int check_i2c_image(struct edgeport_serial *serial)
 685 {
 686         struct device *dev = &serial->serial->dev->dev;
 687         int status = 0;
 688         struct ti_i2c_desc *rom_desc;
 689         int start_address = 2;
 690         __u8 *buffer;
 691         __u16 ttype;
 692
 693         rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
 694         if (!rom_desc) {
 695                 dev_err(dev, "%s - out of memory\n", __func__);
 696                 return -ENOMEM;
 697         }
 698         buffer = kmalloc(TI_MAX_I2C_SIZE, GFP_KERNEL);
 699         if (!buffer) {
 700                 dev_err(dev, "%s - out of memory when allocating buffer\n",
 701                                                                 __func__);
 702                 kfree(rom_desc);
 703                 return -ENOMEM;
 704         }
 705
 706         /* Read the first byte (Signature0) must be 0x52 or 0x10 */
 707         status = read_rom(serial, 0, 1, buffer);
 708         if (status)
 709                 goto out;
 710
 711         if (*buffer != UMP5152 && *buffer != UMP3410) {
 712                 dev_err(dev, "%s - invalid buffer signature\n", __func__);
 713                 status = -ENODEV;
 714                 goto out;
 715         }
 716
 717         do {
 718                 /* Validate the I2C */
 719                 status = read_rom(serial,
 720                                 start_address,
 721                                 sizeof(struct ti_i2c_desc),
 722                                 (__u8 *)rom_desc);
 723                 if (status)
 724                         break;
 725
 726                 if ((start_address + sizeof(struct ti_i2c_desc) +
 727                                         rom_desc->Size) > TI_MAX_I2C_SIZE) {
 728                         status = -ENODEV;
 729                         dev_dbg(dev, "%s - structure too big, erroring out.\n", __func__);
 730                         break;
 731                 }
 732
 733                 dev_dbg(dev, "%s Type = 0x%x\n", __func__, rom_desc->Type);
 734
 735                 /* Skip type 2 record */
 736                 ttype = rom_desc->Type & 0x0f;
 737                 if (ttype != I2C_DESC_TYPE_FIRMWARE_BASIC
 738                         && ttype != I2C_DESC_TYPE_FIRMWARE_AUTO) {
 739                         /* Read the descriptor data */
 740                         status = read_rom(serial, start_address +
 741                                                 sizeof(struct ti_i2c_desc),
 742                                                 rom_desc->Size, buffer);
 743                         if (status)
 744                                 break;
 745
 746                         status = valid_csum(rom_desc, buffer);
 747                         if (status)
 748                                 break;
 749                 }
 750                 start_address = start_address + sizeof(struct ti_i2c_desc) +
 751                                                                 rom_desc->Size;
 752
 753         } while ((rom_desc->Type != I2C_DESC_TYPE_ION) &&
 754                                 (start_address < TI_MAX_I2C_SIZE));
 755
 756         if ((rom_desc->Type != I2C_DESC_TYPE_ION) ||
 757                                 (start_address > TI_MAX_I2C_SIZE))
 758                 status = -ENODEV;
 759
 760 out:
 761         kfree(buffer);
 762         kfree(rom_desc);
 763         return status;
 764 }
 765
 766 static int get_manuf_info(struct edgeport_serial *serial, __u8 *buffer)
 767 {
 768         int status;
 769         int start_address;
 770         struct ti_i2c_desc *rom_desc;
 771         struct edge_ti_manuf_descriptor *desc;
 772         struct device *dev = &serial->serial->dev->dev;
 773
 774         rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
 775         if (!rom_desc) {
 776                 dev_err(dev, "%s - out of memory\n", __func__);
 777                 return -ENOMEM;
 778         }
 779         start_address = get_descriptor_addr(serial, I2C_DESC_TYPE_ION,
 780                                                                 rom_desc);
 781
 782         if (!start_address) {
 783                 dev_dbg(dev, "%s - Edge Descriptor not found in I2C\n", __func__);
 784                 status = -ENODEV;
 785                 goto exit;
 786         }
 787
 788         /* Read the descriptor data */
 789         status = read_rom(serial, start_address+sizeof(struct ti_i2c_desc),
 790                                                 rom_desc->Size, buffer);
 791         if (status)
 792                 goto exit;
 793
 794         status = valid_csum(rom_desc, buffer);
 795
 796         desc = (struct edge_ti_manuf_descriptor *)buffer;
 797         dev_dbg(dev, "%s - IonConfig      0x%x\n", __func__, desc->IonConfig);
 798         dev_dbg(dev, "%s - Version          %d\n", __func__, desc->Version);
 799         dev_dbg(dev, "%s - Cpu/Board      0x%x\n", __func__, desc->CpuRev_BoardRev);
 800         dev_dbg(dev, "%s - NumPorts         %d\n", __func__, desc->NumPorts);
 801         dev_dbg(dev, "%s - NumVirtualPorts  %d\n", __func__, desc->NumVirtualPorts);
 802         dev_dbg(dev, "%s - TotalPorts       %d\n", __func__, desc->TotalPorts);
 803
 804 exit:
 805         kfree(rom_desc);
 806         return status;
 807 }
 808
 809 /* Build firmware header used for firmware update */
 810 static int build_i2c_fw_hdr(__u8 *header, struct device *dev)
 811 {
 812         __u8 *buffer;
 813         int buffer_size;
 814         int i;
 815         int err;
 816         __u8 cs = 0;
 817         struct ti_i2c_desc *i2c_header;
 818         struct ti_i2c_image_header *img_header;
 819         struct ti_i2c_firmware_rec *firmware_rec;
 820         const struct firmware *fw;
 821         const char *fw_name = "edgeport/down3.bin";
 822
 823         /* In order to update the I2C firmware we must change the type 2 record
 824          * to type 0xF2.  This will force the UMP to come up in Boot Mode.
 825          * Then while in boot mode, the driver will download the latest
 826          * firmware (padded to 15.5k) into the UMP ram.  And finally when the
 827          * device comes back up in download mode the driver will cause the new
 828          * firmware to be copied from the UMP Ram to I2C and the firmware will
 829          * update the record type from 0xf2 to 0x02.
 830          */
 831
 832         /* Allocate a 15.5k buffer + 2 bytes for version number
 833          * (Firmware Record) */
 834         buffer_size = (((1024 * 16) - 512 ) +
 835                         sizeof(struct ti_i2c_firmware_rec));
 836
 837         buffer = kmalloc(buffer_size, GFP_KERNEL);
 838         if (!buffer) {
 839                 dev_err(dev, "%s - out of memory\n", __func__);
 840                 return -ENOMEM;
 841         }
 842
 843         // Set entire image of 0xffs
 844         memset(buffer, 0xff, buffer_size);
 845
 846         err = request_firmware(&fw, fw_name, dev);
 847         if (err) {
 848                 dev_err(dev, "Failed to load image \"%s\" err %d\n",
 849                         fw_name, err);
 850                 kfree(buffer);
 851                 return err;
 852         }
 853
 854         /* Save Download Version Number */
 855         OperationalMajorVersion = fw->data[0];
 856         OperationalMinorVersion = fw->data[1];
 857         OperationalBuildNumber = fw->data[2] | (fw->data[3] << 8);
 858
 859         /* Copy version number into firmware record */
 860         firmware_rec = (struct ti_i2c_firmware_rec *)buffer;
 861
 862         firmware_rec->Ver_Major = OperationalMajorVersion;
 863         firmware_rec->Ver_Minor = OperationalMinorVersion;
 864
 865         /* Pointer to fw_down memory image */
 866         img_header = (struct ti_i2c_image_header *)&fw->data[4];
 867
 868         memcpy(buffer + sizeof(struct ti_i2c_firmware_rec),
 869                 &fw->data[4 + sizeof(struct ti_i2c_image_header)],
 870                 le16_to_cpu(img_header->Length));
 871
 872         release_firmware(fw);
 873
 874         for (i=0; i < buffer_size; i++) {
 875                 cs = (__u8)(cs + buffer[i]);
 876         }
 877
 878         kfree(buffer);
 879
 880         /* Build new header */
 881         i2c_header =  (struct ti_i2c_desc *)header;
 882         firmware_rec =  (struct ti_i2c_firmware_rec*)i2c_header->Data;
 883
 884         i2c_header->Type        = I2C_DESC_TYPE_FIRMWARE_BLANK;
 885         i2c_header->Size        = (__u16)buffer_size;
 886         i2c_header->CheckSum    = cs;
 887         firmware_rec->Ver_Major = OperationalMajorVersion;
 888         firmware_rec->Ver_Minor = OperationalMinorVersion;
 889
 890         return 0;
 891 }
 892
 893 /* Try to figure out what type of I2c we have */
 894 static int i2c_type_bootmode(struct edgeport_serial *serial)
 895 {
 896         struct device *dev = &serial->serial->dev->dev;
 897         int status;
 898         u8 *data;
 899
 900         data = kmalloc(1, GFP_KERNEL);
 901         if (!data) {
 902                 dev_err(dev, "%s - out of memory\n", __func__);
 903                 return -ENOMEM;
 904         }
 905
 906         /* Try to read type 2 */
 907         status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
 908                                 DTK_ADDR_SPACE_I2C_TYPE_II, 0, data, 0x01);
 909         if (status)
 910                 dev_dbg(dev, "%s - read 2 status error = %d\n", __func__, status);
 911         else
 912                 dev_dbg(dev, "%s - read 2 data = 0x%x\n", __func__, *data);
 913         if ((!status) && (*data == UMP5152 || *data == UMP3410)) {
 914                 dev_dbg(dev, "%s - ROM_TYPE_II\n", __func__);
 915                 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
 916                 goto out;
 917         }
 918
 919         /* Try to read type 3 */
 920         status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
 921                                 DTK_ADDR_SPACE_I2C_TYPE_III, 0, data, 0x01);
 922         if (status)
 923                 dev_dbg(dev, "%s - read 3 status error = %d\n", __func__, status);
 924         else
 925                 dev_dbg(dev, "%s - read 2 data = 0x%x\n", __func__, *data);
 926         if ((!status) && (*data == UMP5152 || *data == UMP3410)) {
 927                 dev_dbg(dev, "%s - ROM_TYPE_III\n", __func__);
 928                 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_III;
 929                 goto out;
 930         }
 931
 932         dev_dbg(dev, "%s - Unknown\n", __func__);
 933         serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
 934         status = -ENODEV;
 935 out:
 936         kfree(data);
 937         return status;
 938 }
 939
 940 static int bulk_xfer(struct usb_serial *serial, void *buffer,
 941                                                 int length, int *num_sent)
 942 {
 943         int status;
 944
 945         status = usb_bulk_msg(serial->dev,
 946                         usb_sndbulkpipe(serial->dev,
 947                                 serial->port[0]->bulk_out_endpointAddress),
 948                         buffer, length, num_sent, 1000);
 949         return status;
 950 }
 951
 952 /* Download given firmware image to the device (IN BOOT MODE) */
 953 static int download_code(struct edgeport_serial *serial, __u8 *image,
 954                                                         int image_length)
 955 {
 956         int status = 0;
 957         int pos;
 958         int transfer;
 959         int done;
 960
 961         /* Transfer firmware image */
 962         for (pos = 0; pos < image_length; ) {
 963                 /* Read the next buffer from file */
 964                 transfer = image_length - pos;
 965                 if (transfer > EDGE_FW_BULK_MAX_PACKET_SIZE)
 966                         transfer = EDGE_FW_BULK_MAX_PACKET_SIZE;
 967
 968                 /* Transfer data */
 969                 status = bulk_xfer(serial->serial, &image[pos],
 970                                                         transfer, &done);
 971                 if (status)
 972                         break;
 973                 /* Advance buffer pointer */
 974                 pos += done;
 975         }
 976
 977         return status;
 978 }
 979
 980 /* FIXME!!! */
 981 static int config_boot_dev(struct usb_device *dev)
 982 {
 983         return 0;
 984 }
 985
 986 static int ti_cpu_rev(struct edge_ti_manuf_descriptor *desc)
 987 {
 988         return TI_GET_CPU_REVISION(desc->CpuRev_BoardRev);
 989 }
 990
 991 /**
 992  * DownloadTIFirmware - Download run-time operating firmware to the TI5052
 993  *
 994  * This routine downloads the main operating code into the TI5052, using the
 995  * boot code already burned into E2PROM or ROM.
 996  */
 997 static int download_fw(struct edgeport_serial *serial)
 998 {
 999         struct device *dev = &serial->serial->dev->dev;
1000         int status = 0;
1001         int start_address;
1002         struct edge_ti_manuf_descriptor *ti_manuf_desc;
1003         struct usb_interface_descriptor *interface;
1004         int download_cur_ver;
1005         int download_new_ver;
1006
1007         /* This routine is entered by both the BOOT mode and the Download mode
1008          * We can determine which code is running by the reading the config
1009          * descriptor and if we have only one bulk pipe it is in boot mode
1010          */
1011         serial->product_info.hardware_type = HARDWARE_TYPE_TIUMP;
1012
1013         /* Default to type 2 i2c */
1014         serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
1015
1016         status = choose_config(serial->serial->dev);
1017         if (status)
1018                 return status;
1019
1020         interface = &serial->serial->interface->cur_altsetting->desc;
1021         if (!interface) {
1022                 dev_err(dev, "%s - no interface set, error!\n", __func__);
1023                 return -ENODEV;
1024         }
1025
1026         /*
1027          * Setup initial mode -- the default mode 0 is TI_MODE_CONFIGURING
1028          * if we have more than one endpoint we are definitely in download
1029          * mode
1030          */
1031         if (interface->bNumEndpoints > 1)
1032                 serial->product_info.TiMode = TI_MODE_DOWNLOAD;
1033         else
1034                 /* Otherwise we will remain in configuring mode */
1035                 serial->product_info.TiMode = TI_MODE_CONFIGURING;
1036
1037         /********************************************************************/
1038         /* Download Mode */
1039         /********************************************************************/
1040         if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {
1041                 struct ti_i2c_desc *rom_desc;
1042
1043                 dev_dbg(dev, "%s - RUNNING IN DOWNLOAD MODE\n", __func__);
1044
1045                 status = check_i2c_image(serial);
1046                 if (status) {
1047                         dev_dbg(dev, "%s - DOWNLOAD MODE -- BAD I2C\n", __func__);
1048                         return status;
1049                 }
1050
1051                 /* Validate Hardware version number
1052                  * Read Manufacturing Descriptor from TI Based Edgeport
1053                  */
1054                 ti_manuf_desc = kmalloc(sizeof(*ti_manuf_desc), GFP_KERNEL);
1055                 if (!ti_manuf_desc) {
1056                         dev_err(dev, "%s - out of memory.\n", __func__);
1057                         return -ENOMEM;
1058                 }
1059                 status = get_manuf_info(serial, (__u8 *)ti_manuf_desc);
1060                 if (status) {
1061                         kfree(ti_manuf_desc);
1062                         return status;
1063                 }
1064
1065                 /* Check version number of ION descriptor */
1066                 if (!ignore_cpu_rev && ti_cpu_rev(ti_manuf_desc) < 2) {
1067                         dev_dbg(dev, "%s - Wrong CPU Rev %d (Must be 2)\n",
1068                                 __func__, ti_cpu_rev(ti_manuf_desc));
1069                         kfree(ti_manuf_desc);
1070                         return -EINVAL;
1071                 }
1072
1073                 rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
1074                 if (!rom_desc) {
1075                         dev_err(dev, "%s - out of memory.\n", __func__);
1076                         kfree(ti_manuf_desc);
1077                         return -ENOMEM;
1078                 }
1079
1080                 /* Search for type 2 record (firmware record) */
1081                 start_address = get_descriptor_addr(serial,
1082                                 I2C_DESC_TYPE_FIRMWARE_BASIC, rom_desc);
1083                 if (start_address != 0) {
1084                         struct ti_i2c_firmware_rec *firmware_version;
1085                         u8 *record;
1086
1087                         dev_dbg(dev, "%s - Found Type FIRMWARE (Type 2) record\n", __func__);
1088
1089                         firmware_version = kmalloc(sizeof(*firmware_version),
1090                                                                 GFP_KERNEL);
1091                         if (!firmware_version) {
1092                                 dev_err(dev, "%s - out of memory.\n", __func__);
1093                                 kfree(rom_desc);
1094                                 kfree(ti_manuf_desc);
1095                                 return -ENOMEM;
1096                         }
1097
1098                         /* Validate version number
1099                          * Read the descriptor data
1100                          */
1101                         status = read_rom(serial, start_address +
1102                                         sizeof(struct ti_i2c_desc),
1103                                         sizeof(struct ti_i2c_firmware_rec),
1104                                         (__u8 *)firmware_version);
1105                         if (status) {
1106                                 kfree(firmware_version);
1107                                 kfree(rom_desc);
1108                                 kfree(ti_manuf_desc);
1109                                 return status;
1110                         }
1111
1112                         /* Check version number of download with current
1113                            version in I2c */
1114                         download_cur_ver = (firmware_version->Ver_Major << 8) +
1115                                            (firmware_version->Ver_Minor);
1116                         download_new_ver = (OperationalMajorVersion << 8) +
1117                                            (OperationalMinorVersion);
1118
1119                         dev_dbg(dev, "%s - >> FW Versions Device %d.%d  Driver %d.%d\n",
1120                                 __func__, firmware_version->Ver_Major,
1121                                 firmware_version->Ver_Minor,
1122                                 OperationalMajorVersion,
1123                                 OperationalMinorVersion);
1124
1125                         /* Check if we have an old version in the I2C and
1126                            update if necessary */
1127                         if (download_cur_ver < download_new_ver) {
1128                                 dev_dbg(dev, "%s - Update I2C dld from %d.%d to %d.%d\n",
1129                                         __func__,
1130                                         firmware_version->Ver_Major,
1131                                         firmware_version->Ver_Minor,
1132                                         OperationalMajorVersion,
1133                                         OperationalMinorVersion);
1134
1135                                 record = kmalloc(1, GFP_KERNEL);
1136                                 if (!record) {
1137                                         dev_err(dev, "%s - out of memory.\n",
1138                                                         __func__);
1139                                         kfree(firmware_version);
1140                                         kfree(rom_desc);
1141                                         kfree(ti_manuf_desc);
1142                                         return -ENOMEM;
1143                                 }
1144                                 /* In order to update the I2C firmware we must
1145                                  * change the type 2 record to type 0xF2. This
1146                                  * will force the UMP to come up in Boot Mode.
1147                                  * Then while in boot mode, the driver will
1148                                  * download the latest firmware (padded to
1149                                  * 15.5k) into the UMP ram. Finally when the
1150                                  * device comes back up in download mode the
1151                                  * driver will cause the new firmware to be
1152                                  * copied from the UMP Ram to I2C and the
1153                                  * firmware will update the record type from
1154                                  * 0xf2 to 0x02.
1155                                  */
1156                                 *record = I2C_DESC_TYPE_FIRMWARE_BLANK;
1157
1158                                 /* Change the I2C Firmware record type to
1159                                    0xf2 to trigger an update */
1160                                 status = write_rom(serial, start_address,
1161                                                 sizeof(*record), record);
1162                                 if (status) {
1163                                         kfree(record);
1164                                         kfree(firmware_version);
1165                                         kfree(rom_desc);
1166                                         kfree(ti_manuf_desc);
1167                                         return status;
1168                                 }
1169
1170                                 /* verify the write -- must do this in order
1171                                  * for write to complete before we do the
1172                                  * hardware reset
1173                                  */
1174                                 status = read_rom(serial,
1175                                                         start_address,
1176                                                         sizeof(*record),
1177                                                         record);
1178                                 if (status) {
1179                                         kfree(record);
1180                                         kfree(firmware_version);
1181                                         kfree(rom_desc);
1182                                         kfree(ti_manuf_desc);
1183                                         return status;
1184                                 }
1185
1186                                 if (*record != I2C_DESC_TYPE_FIRMWARE_BLANK) {
1187                                         dev_err(dev, "%s - error resetting device\n", __func__);
1188                                         kfree(record);
1189                                         kfree(firmware_version);
1190                                         kfree(rom_desc);
1191                                         kfree(ti_manuf_desc);
1192                                         return -ENODEV;
1193                                 }
1194
1195                                 dev_dbg(dev, "%s - HARDWARE RESET\n", __func__);
1196
1197                                 /* Reset UMP -- Back to BOOT MODE */
1198                                 status = ti_vsend_sync(serial->serial->dev,
1199                                                 UMPC_HARDWARE_RESET,
1200                                                 0, 0, NULL, 0);
1201
1202                                 dev_dbg(dev, "%s - HARDWARE RESET return %d\n", __func__, status);
1203
1204                                 /* return an error on purpose. */
1205                                 kfree(record);
1206                                 kfree(firmware_version);
1207                                 kfree(rom_desc);
1208                                 kfree(ti_manuf_desc);
1209                                 return -ENODEV;
1210                         }
1211                         kfree(firmware_version);
1212                 }
1213                 /* Search for type 0xF2 record (firmware blank record) */
1214                 else if ((start_address = get_descriptor_addr(serial, I2C_DESC_TYPE_FIRMWARE_BLANK, rom_desc)) != 0) {
1215 #define HEADER_SIZE     (sizeof(struct ti_i2c_desc) + \
1216                                         sizeof(struct ti_i2c_firmware_rec))
1217                         __u8 *header;
1218                         __u8 *vheader;
1219
1220                         header = kmalloc(HEADER_SIZE, GFP_KERNEL);
1221                         if (!header) {
1222                                 dev_err(dev, "%s - out of memory.\n", __func__);
1223                                 kfree(rom_desc);
1224                                 kfree(ti_manuf_desc);
1225                                 return -ENOMEM;
1226                         }
1227
1228                         vheader = kmalloc(HEADER_SIZE, GFP_KERNEL);
1229                         if (!vheader) {
1230                                 dev_err(dev, "%s - out of memory.\n", __func__);
1231                                 kfree(header);
1232                                 kfree(rom_desc);
1233                                 kfree(ti_manuf_desc);
1234                                 return -ENOMEM;
1235                         }
1236
1237                         dev_dbg(dev, "%s - Found Type BLANK FIRMWARE (Type F2) record\n", __func__);
1238
1239                         /*
1240                          * In order to update the I2C firmware we must change
1241                          * the type 2 record to type 0xF2. This will force the
1242                          * UMP to come up in Boot Mode.  Then while in boot
1243                          * mode, the driver will download the latest firmware
1244                          * (padded to 15.5k) into the UMP ram. Finally when the
1245                          * device comes back up in download mode the driver
1246                          * will cause the new firmware to be copied from the
1247                          * UMP Ram to I2C and the firmware will update the
1248                          * record type from 0xf2 to 0x02.
1249                          */
1250                         status = build_i2c_fw_hdr(header, dev);
1251                         if (status) {
1252                                 kfree(vheader);
1253                                 kfree(header);
1254                                 kfree(rom_desc);
1255                                 kfree(ti_manuf_desc);
1256                                 return -EINVAL;
1257                         }
1258
1259                         /* Update I2C with type 0xf2 record with correct
1260                            size and checksum */
1261                         status = write_rom(serial,
1262                                                 start_address,
1263                                                 HEADER_SIZE,
1264                                                 header);
1265                         if (status) {
1266                                 kfree(vheader);
1267                                 kfree(header);
1268                                 kfree(rom_desc);
1269                                 kfree(ti_manuf_desc);
1270                                 return -EINVAL;
1271                         }
1272
1273                         /* verify the write -- must do this in order for
1274                            write to complete before we do the hardware reset */
1275                         status = read_rom(serial, start_address,
1276                                                         HEADER_SIZE, vheader);
1277
1278                         if (status) {
1279                                 dev_dbg(dev, "%s - can't read header back\n", __func__);
1280                                 kfree(vheader);
1281                                 kfree(header);
1282                                 kfree(rom_desc);
1283                                 kfree(ti_manuf_desc);
1284                                 return status;
1285                         }
1286                         if (memcmp(vheader, header, HEADER_SIZE)) {
1287                                 dev_dbg(dev, "%s - write download record failed\n", __func__);
1288                                 kfree(vheader);
1289                                 kfree(header);
1290                                 kfree(rom_desc);
1291                                 kfree(ti_manuf_desc);
1292                                 return -EINVAL;
1293                         }
1294
1295                         kfree(vheader);
1296                         kfree(header);
1297
1298                         dev_dbg(dev, "%s - Start firmware update\n", __func__);
1299
1300                         /* Tell firmware to copy download image into I2C */
1301                         status = ti_vsend_sync(serial->serial->dev,
1302                                         UMPC_COPY_DNLD_TO_I2C, 0, 0, NULL, 0);
1303
1304                         dev_dbg(dev, "%s - Update complete 0x%x\n", __func__, status);
1305                         if (status) {
1306                                 dev_err(dev,
1307                                         "%s - UMPC_COPY_DNLD_TO_I2C failed\n",
1308                                                                 __func__);
1309                                 kfree(rom_desc);
1310                                 kfree(ti_manuf_desc);
1311                                 return status;
1312                         }
1313                 }
1314
1315                 // The device is running the download code
1316                 kfree(rom_desc);
1317                 kfree(ti_manuf_desc);
1318                 return 0;
1319         }
1320
1321         /********************************************************************/
1322         /* Boot Mode */
1323         /********************************************************************/
1324         dev_dbg(dev, "%s - RUNNING IN BOOT MODE\n", __func__);
1325
1326         /* Configure the TI device so we can use the BULK pipes for download */
1327         status = config_boot_dev(serial->serial->dev);
1328         if (status)
1329                 return status;
1330
1331         if (le16_to_cpu(serial->serial->dev->descriptor.idVendor)
1332                                                         != USB_VENDOR_ID_ION) {
1333                 dev_dbg(dev, "%s - VID = 0x%x\n", __func__,
1334                         le16_to_cpu(serial->serial->dev->descriptor.idVendor));
1335                 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
1336                 goto stayinbootmode;
1337         }
1338
1339         /* We have an ION device (I2c Must be programmed)
1340            Determine I2C image type */
1341         if (i2c_type_bootmode(serial))
1342                 goto stayinbootmode;
1343
1344         /* Check for ION Vendor ID and that the I2C is valid */
1345         if (!check_i2c_image(serial)) {
1346                 struct ti_i2c_image_header *header;
1347                 int i;
1348                 __u8 cs = 0;
1349                 __u8 *buffer;
1350                 int buffer_size;
1351                 int err;
1352                 const struct firmware *fw;
1353                 const char *fw_name = "edgeport/down3.bin";
1354
1355                 /* Validate Hardware version number
1356                  * Read Manufacturing Descriptor from TI Based Edgeport
1357                  */
1358                 ti_manuf_desc = kmalloc(sizeof(*ti_manuf_desc), GFP_KERNEL);
1359                 if (!ti_manuf_desc) {
1360                         dev_err(dev, "%s - out of memory.\n", __func__);
1361                         return -ENOMEM;
1362                 }
1363                 status = get_manuf_info(serial, (__u8 *)ti_manuf_desc);
1364                 if (status) {
1365                         kfree(ti_manuf_desc);
1366                         goto stayinbootmode;
1367                 }
1368
1369                 /* Check for version 2 */
1370                 if (!ignore_cpu_rev && ti_cpu_rev(ti_manuf_desc) < 2) {
1371                         dev_dbg(dev, "%s - Wrong CPU Rev %d (Must be 2)\n",
1372                                 __func__, ti_cpu_rev(ti_manuf_desc));
1373                         kfree(ti_manuf_desc);
1374                         goto stayinbootmode;
1375                 }
1376
1377                 kfree(ti_manuf_desc);
1378
1379                 /*
1380                  * In order to update the I2C firmware we must change the type
1381                  * 2 record to type 0xF2. This will force the UMP to come up
1382                  * in Boot Mode.  Then while in boot mode, the driver will
1383                  * download the latest firmware (padded to 15.5k) into the
1384                  * UMP ram. Finally when the device comes back up in download
1385                  * mode the driver will cause the new firmware to be copied
1386                  * from the UMP Ram to I2C and the firmware will update the
1387                  * record type from 0xf2 to 0x02.
1388                  *
1389                  * Do we really have to copy the whole firmware image,
1390                  * or could we do this in place!
1391                  */
1392
1393                 /* Allocate a 15.5k buffer + 3 byte header */
1394                 buffer_size = (((1024 * 16) - 512) +
1395                                         sizeof(struct ti_i2c_image_header));
1396                 buffer = kmalloc(buffer_size, GFP_KERNEL);
1397                 if (!buffer) {
1398                         dev_err(dev, "%s - out of memory\n", __func__);
1399                         return -ENOMEM;
1400                 }
1401
1402                 /* Initialize the buffer to 0xff (pad the buffer) */
1403                 memset(buffer, 0xff, buffer_size);
1404
1405                 err = request_firmware(&fw, fw_name, dev);
1406                 if (err) {
1407                         dev_err(dev, "Failed to load image \"%s\" err %d\n",
1408                                 fw_name, err);
1409                         kfree(buffer);
1410                         return err;
1411                 }
1412                 memcpy(buffer, &fw->data[4], fw->size - 4);
1413                 release_firmware(fw);
1414
1415                 for (i = sizeof(struct ti_i2c_image_header);
1416                                 i < buffer_size; i++) {
1417                         cs = (__u8)(cs + buffer[i]);
1418                 }
1419
1420                 header = (struct ti_i2c_image_header *)buffer;
1421
1422                 /* update length and checksum after padding */
1423                 header->Length   = cpu_to_le16((__u16)(buffer_size -
1424                                         sizeof(struct ti_i2c_image_header)));
1425                 header->CheckSum = cs;
1426
1427                 /* Download the operational code  */
1428                 dev_dbg(dev, "%s - Downloading operational code image (TI UMP)\n", __func__);
1429                 status = download_code(serial, buffer, buffer_size);
1430
1431                 kfree(buffer);
1432
1433                 if (status) {
1434                         dev_dbg(dev, "%s - Error downloading operational code image\n", __func__);
1435                         return status;
1436                 }
1437
1438                 /* Device will reboot */
1439                 serial->product_info.TiMode = TI_MODE_TRANSITIONING;
1440
1441                 dev_dbg(dev, "%s - Download successful -- Device rebooting...\n", __func__);
1442
1443                 /* return an error on purpose */
1444                 return -ENODEV;
1445         }
1446
1447 stayinbootmode:
1448         /* Eprom is invalid or blank stay in boot mode */
1449         dev_dbg(dev, "%s - STAYING IN BOOT MODE\n", __func__);
1450         serial->product_info.TiMode = TI_MODE_BOOT;
1451
1452         return 0;
1453 }
1454
1455
1456 static int ti_do_config(struct edgeport_port *port, int feature, int on)
1457 {
1458         int port_number = port->port->number - port->port->serial->minor;
1459         on = !!on;      /* 1 or 0 not bitmask */
1460         return send_cmd(port->port->serial->dev,
1461                         feature, (__u8)(UMPM_UART1_PORT + port_number),
1462                         on, NULL, 0);
1463 }
1464
1465
1466 static int restore_mcr(struct edgeport_port *port, __u8 mcr)
1467 {
1468         int status = 0;
1469
1470         dev_dbg(&port->port->dev, "%s - %x\n", __func__, mcr);
1471
1472         status = ti_do_config(port, UMPC_SET_CLR_DTR, mcr & MCR_DTR);
1473         if (status)
1474                 return status;
1475         status = ti_do_config(port, UMPC_SET_CLR_RTS, mcr & MCR_RTS);
1476         if (status)
1477                 return status;
1478         return ti_do_config(port, UMPC_SET_CLR_LOOPBACK, mcr & MCR_LOOPBACK);
1479 }
1480
1481 /* Convert TI LSR to standard UART flags */
1482 static __u8 map_line_status(__u8 ti_lsr)
1483 {
1484         __u8 lsr = 0;
1485
1486 #define MAP_FLAG(flagUmp, flagUart)    \
1487         if (ti_lsr & flagUmp) \
1488                 lsr |= flagUart;
1489
1490         MAP_FLAG(UMP_UART_LSR_OV_MASK, LSR_OVER_ERR)    /* overrun */
1491         MAP_FLAG(UMP_UART_LSR_PE_MASK, LSR_PAR_ERR)     /* parity error */
1492         MAP_FLAG(UMP_UART_LSR_FE_MASK, LSR_FRM_ERR)     /* framing error */
1493         MAP_FLAG(UMP_UART_LSR_BR_MASK, LSR_BREAK)       /* break detected */
1494         MAP_FLAG(UMP_UART_LSR_RX_MASK, LSR_RX_AVAIL)    /* rx data available */
1495         MAP_FLAG(UMP_UART_LSR_TX_MASK, LSR_TX_EMPTY)    /* tx hold reg empty */
1496
1497 #undef MAP_FLAG
1498
1499         return lsr;
1500 }
1501
1502 static void handle_new_msr(struct edgeport_port *edge_port, __u8 msr)
1503 {
1504         struct async_icount *icount;
1505         struct tty_struct *tty;
1506
1507         dev_dbg(&edge_port->port->dev, "%s - %02x\n", __func__, msr);
1508
1509         if (msr & (EDGEPORT_MSR_DELTA_CTS | EDGEPORT_MSR_DELTA_DSR |
1510                         EDGEPORT_MSR_DELTA_RI | EDGEPORT_MSR_DELTA_CD)) {
1511                 icount = &edge_port->icount;
1512
1513                 /* update input line counters */
1514                 if (msr & EDGEPORT_MSR_DELTA_CTS)
1515                         icount->cts++;
1516                 if (msr & EDGEPORT_MSR_DELTA_DSR)
1517                         icount->dsr++;
1518                 if (msr & EDGEPORT_MSR_DELTA_CD)
1519                         icount->dcd++;
1520                 if (msr & EDGEPORT_MSR_DELTA_RI)
1521                         icount->rng++;
1522                 wake_up_interruptible(&edge_port->delta_msr_wait);
1523         }
1524
1525         /* Save the new modem status */
1526         edge_port->shadow_msr = msr & 0xf0;
1527
1528         tty = tty_port_tty_get(&edge_port->port->port);
1529         /* handle CTS flow control */
1530         if (tty && C_CRTSCTS(tty)) {
1531                 if (msr & EDGEPORT_MSR_CTS) {
1532                         tty->hw_stopped = 0;
1533                         tty_wakeup(tty);
1534                 } else {
1535                         tty->hw_stopped = 1;
1536                 }
1537         }
1538         tty_kref_put(tty);
1539 }
1540
1541 static void handle_new_lsr(struct edgeport_port *edge_port, int lsr_data,
1542                                                         __u8 lsr, __u8 data)
1543 {
1544         struct async_icount *icount;
1545         __u8 new_lsr = (__u8)(lsr & (__u8)(LSR_OVER_ERR | LSR_PAR_ERR |
1546                                                 LSR_FRM_ERR | LSR_BREAK));
1547         struct tty_struct *tty;
1548
1549         dev_dbg(&edge_port->port->dev, "%s - %02x\n", __func__, new_lsr);
1550
1551         edge_port->shadow_lsr = lsr;
1552
1553         if (new_lsr & LSR_BREAK)
1554                 /*
1555                  * Parity and Framing errors only count if they
1556                  * occur exclusive of a break being received.
1557                  */
1558                 new_lsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK);
1559
1560         /* Place LSR data byte into Rx buffer */
1561         if (lsr_data) {
1562                 tty = tty_port_tty_get(&edge_port->port->port);
1563                 if (tty) {
1564                         edge_tty_recv(&edge_port->port->dev, tty, &data, 1);
1565                         tty_kref_put(tty);
1566                 }
1567         }
1568
1569         /* update input line counters */
1570         icount = &edge_port->icount;
1571         if (new_lsr & LSR_BREAK)
1572                 icount->brk++;
1573         if (new_lsr & LSR_OVER_ERR)
1574                 icount->overrun++;
1575         if (new_lsr & LSR_PAR_ERR)
1576                 icount->parity++;
1577         if (new_lsr & LSR_FRM_ERR)
1578                 icount->frame++;
1579 }
1580
1581
1582 static void edge_interrupt_callback(struct urb *urb)
1583 {
1584         struct edgeport_serial *edge_serial = urb->context;
1585         struct usb_serial_port *port;
1586         struct edgeport_port *edge_port;
1587         struct device *dev;
1588         unsigned char *data = urb->transfer_buffer;
1589         int length = urb->actual_length;
1590         int port_number;
1591         int function;
1592         int retval;
1593         __u8 lsr;
1594         __u8 msr;
1595         int status = urb->status;
1596
1597         switch (status) {
1598         case 0:
1599                 /* success */
1600                 break;
1601         case -ECONNRESET:
1602         case -ENOENT:
1603         case -ESHUTDOWN:
1604                 /* this urb is terminated, clean up */
1605                 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
1606                     __func__, status);
1607                 return;
1608         default:
1609                 dev_err(&urb->dev->dev, "%s - nonzero urb status received: "
1610                         "%d\n", __func__, status);
1611                 goto exit;
1612         }
1613
1614         if (!length) {
1615                 dev_dbg(&urb->dev->dev, "%s - no data in urb\n", __func__);
1616                 goto exit;
1617         }
1618
1619         dev = &edge_serial->serial->dev->dev;
1620         usb_serial_debug_data(dev, __func__, length, data);
1621
1622         if (length != 2) {
1623                 dev_dbg(dev, "%s - expecting packet of size 2, got %d\n", __func__, length);
1624                 goto exit;
1625         }
1626
1627         port_number = TIUMP_GET_PORT_FROM_CODE(data[0]);
1628         function    = TIUMP_GET_FUNC_FROM_CODE(data[0]);
1629         dev_dbg(dev, "%s - port_number %d, function %d, info 0x%x\n", __func__,
1630                 port_number, function, data[1]);
1631         port = edge_serial->serial->port[port_number];
1632         edge_port = usb_get_serial_port_data(port);
1633         if (!edge_port) {
1634                 dev_dbg(dev, "%s - edge_port not found\n", __func__);
1635                 return;
1636         }
1637         switch (function) {
1638         case TIUMP_INTERRUPT_CODE_LSR:
1639                 lsr = map_line_status(data[1]);
1640                 if (lsr & UMP_UART_LSR_DATA_MASK) {
1641                         /* Save the LSR event for bulk read
1642                            completion routine */
1643                         dev_dbg(dev, "%s - LSR Event Port %u LSR Status = %02x\n",
1644                                 __func__, port_number, lsr);
1645                         edge_port->lsr_event = 1;
1646                         edge_port->lsr_mask = lsr;
1647                 } else {
1648                         dev_dbg(dev, "%s - ===== Port %d LSR Status = %02x ======\n",
1649                                 __func__, port_number, lsr);
1650                         handle_new_lsr(edge_port, 0, lsr, 0);
1651                 }
1652                 break;
1653
1654         case TIUMP_INTERRUPT_CODE_MSR:  /* MSR */
1655                 /* Copy MSR from UMP */
1656                 msr = data[1];
1657                 dev_dbg(dev, "%s - ===== Port %u MSR Status = %02x ======\n",
1658                         __func__, port_number, msr);
1659                 handle_new_msr(edge_port, msr);
1660                 break;
1661
1662         default:
1663                 dev_err(&urb->dev->dev,
1664                         "%s - Unknown Interrupt code from UMP %x\n",
1665                         __func__, data[1]);
1666                 break;
1667
1668         }
1669
1670 exit:
1671         retval = usb_submit_urb(urb, GFP_ATOMIC);
1672         if (retval)
1673                 dev_err(&urb->dev->dev,
1674                         "%s - usb_submit_urb failed with result %d\n",
1675                          __func__, retval);
1676 }
1677
1678 static void edge_bulk_in_callback(struct urb *urb)
1679 {
1680         struct edgeport_port *edge_port = urb->context;
1681         struct device *dev = &edge_port->port->dev;
1682         unsigned char *data = urb->transfer_buffer;
1683         struct tty_struct *tty;
1684         int retval = 0;
1685         int port_number;
1686         int status = urb->status;
1687
1688         switch (status) {
1689         case 0:
1690                 /* success */
1691                 break;
1692         case -ECONNRESET:
1693         case -ENOENT:
1694         case -ESHUTDOWN:
1695                 /* this urb is terminated, clean up */
1696                 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
1697                 return;
1698         default:
1699                 dev_err(&urb->dev->dev, "%s - nonzero read bulk status received: %d\n", __func__, status);
1700         }
1701
1702         if (status == -EPIPE)
1703                 goto exit;
1704
1705         if (status) {
1706                 dev_err(&urb->dev->dev, "%s - stopping read!\n", __func__);
1707                 return;
1708         }
1709
1710         port_number = edge_port->port->number - edge_port->port->serial->minor;
1711
1712         if (edge_port->lsr_event) {
1713                 edge_port->lsr_event = 0;
1714                 dev_dbg(dev, "%s ===== Port %u LSR Status = %02x, Data = %02x ======\n",
1715                         __func__, port_number, edge_port->lsr_mask, *data);
1716                 handle_new_lsr(edge_port, 1, edge_port->lsr_mask, *data);
1717                 /* Adjust buffer length/pointer */
1718                 --urb->actual_length;
1719                 ++data;
1720         }
1721
1722         tty = tty_port_tty_get(&edge_port->port->port);
1723         if (tty && urb->actual_length) {
1724                 usb_serial_debug_data(dev, __func__, urb->actual_length, data);
1725                 if (edge_port->close_pending)
1726                         dev_dbg(dev, "%s - close pending, dropping data on the floor\n",
1727                                                                 __func__);
1728                 else
1729                         edge_tty_recv(dev, tty, data, urb->actual_length);
1730                 edge_port->icount.rx += urb->actual_length;
1731         }
1732         tty_kref_put(tty);
1733
1734 exit:
1735         /* continue read unless stopped */
1736         spin_lock(&edge_port->ep_lock);
1737         if (edge_port->ep_read_urb_state == EDGE_READ_URB_RUNNING)
1738                 retval = usb_submit_urb(urb, GFP_ATOMIC);
1739         else if (edge_port->ep_read_urb_state == EDGE_READ_URB_STOPPING)
1740                 edge_port->ep_read_urb_state = EDGE_READ_URB_STOPPED;
1741
1742         spin_unlock(&edge_port->ep_lock);
1743         if (retval)
1744                 dev_err(dev, "%s - usb_submit_urb failed with result %d\n", __func__, retval);
1745 }
1746
1747 static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
1748                                         unsigned char *data, int length)
1749 {
1750         int queued;
1751
1752         queued = tty_insert_flip_string(tty, data, length);
1753         if (queued < length)
1754                 dev_err(dev, "%s - dropping data, %d bytes lost\n",
1755                         __func__, length - queued);
1756         tty_flip_buffer_push(tty);
1757 }
1758
1759 static void edge_bulk_out_callback(struct urb *urb)
1760 {
1761         struct usb_serial_port *port = urb->context;
1762         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1763         int status = urb->status;
1764         struct tty_struct *tty;
1765
1766         edge_port->ep_write_urb_in_use = 0;
1767
1768         switch (status) {
1769         case 0:
1770                 /* success */
1771                 break;
1772         case -ECONNRESET:
1773         case -ENOENT:
1774         case -ESHUTDOWN:
1775                 /* this urb is terminated, clean up */
1776                 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
1777                     __func__, status);
1778                 return;
1779         default:
1780                 dev_err_console(port, "%s - nonzero write bulk status "
1781                         "received: %d\n", __func__, status);
1782         }
1783
1784         /* send any buffered data */
1785         tty = tty_port_tty_get(&port->port);
1786         edge_send(tty);
1787         tty_kref_put(tty);
1788 }
1789
1790 static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
1791 {
1792         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1793         struct edgeport_serial *edge_serial;
1794         struct usb_device *dev;
1795         struct urb *urb;
1796         int port_number;
1797         int status;
1798         u16 open_settings;
1799         u8 transaction_timeout;
1800
1801         if (edge_port == NULL)
1802                 return -ENODEV;
1803
1804         port_number = port->number - port->serial->minor;
1805         switch (port_number) {
1806         case 0:
1807                 edge_port->uart_base = UMPMEM_BASE_UART1;
1808                 edge_port->dma_address = UMPD_OEDB1_ADDRESS;
1809                 break;
1810         case 1:
1811                 edge_port->uart_base = UMPMEM_BASE_UART2;
1812                 edge_port->dma_address = UMPD_OEDB2_ADDRESS;
1813                 break;
1814         default:
1815                 dev_err(&port->dev, "Unknown port number!!!\n");
1816                 return -ENODEV;
1817         }
1818
1819         dev_dbg(&port->dev, "%s - port_number = %d, uart_base = %04x, dma_address = %04x\n",
1820                 __func__, port_number, edge_port->uart_base, edge_port->dma_address);
1821
1822         dev = port->serial->dev;
1823
1824         memset(&(edge_port->icount), 0x00, sizeof(edge_port->icount));
1825         init_waitqueue_head(&edge_port->delta_msr_wait);
1826
1827         /* turn off loopback */
1828         status = ti_do_config(edge_port, UMPC_SET_CLR_LOOPBACK, 0);
1829         if (status) {
1830                 dev_err(&port->dev,
1831                                 "%s - cannot send clear loopback command, %d\n",
1832                         __func__, status);
1833                 return status;
1834         }
1835
1836         /* set up the port settings */
1837         if (tty)
1838                 edge_set_termios(tty, port, &tty->termios);
1839
1840         /* open up the port */
1841
1842         /* milliseconds to timeout for DMA transfer */
1843         transaction_timeout = 2;
1844
1845         edge_port->ump_read_timeout =
1846                                 max(20, ((transaction_timeout * 3) / 2));
1847
1848         /* milliseconds to timeout for DMA transfer */
1849         open_settings = (u8)(UMP_DMA_MODE_CONTINOUS |
1850                              UMP_PIPE_TRANS_TIMEOUT_ENA |
1851                              (transaction_timeout << 2));
1852
1853         dev_dbg(&port->dev, "%s - Sending UMPC_OPEN_PORT\n", __func__);
1854
1855         /* Tell TI to open and start the port */
1856         status = send_cmd(dev, UMPC_OPEN_PORT,
1857                 (u8)(UMPM_UART1_PORT + port_number), open_settings, NULL, 0);
1858         if (status) {
1859                 dev_err(&port->dev, "%s - cannot send open command, %d\n",
1860                                                         __func__, status);
1861                 return status;
1862         }
1863
1864         /* Start the DMA? */
1865         status = send_cmd(dev, UMPC_START_PORT,
1866                 (u8)(UMPM_UART1_PORT + port_number), 0, NULL, 0);
1867         if (status) {
1868                 dev_err(&port->dev, "%s - cannot send start DMA command, %d\n",
1869                                                         __func__, status);
1870                 return status;
1871         }
1872
1873         /* Clear TX and RX buffers in UMP */
1874         status = purge_port(port, UMP_PORT_DIR_OUT | UMP_PORT_DIR_IN);
1875         if (status) {
1876                 dev_err(&port->dev,
1877                         "%s - cannot send clear buffers command, %d\n",
1878                         __func__, status);
1879                 return status;
1880         }
1881
1882         /* Read Initial MSR */
1883         status = ti_vread_sync(dev, UMPC_READ_MSR, 0,
1884                                 (__u16)(UMPM_UART1_PORT + port_number),
1885                                 &edge_port->shadow_msr, 1);
1886         if (status) {
1887                 dev_err(&port->dev, "%s - cannot send read MSR command, %d\n",
1888                                                         __func__, status);
1889                 return status;
1890         }
1891
1892         dev_dbg(&port->dev, "ShadowMSR 0x%X\n", edge_port->shadow_msr);
1893
1894         /* Set Initial MCR */
1895         edge_port->shadow_mcr = MCR_RTS | MCR_DTR;
1896         dev_dbg(&port->dev, "ShadowMCR 0x%X\n", edge_port->shadow_mcr);
1897
1898         edge_serial = edge_port->edge_serial;
1899         if (mutex_lock_interruptible(&edge_serial->es_lock))
1900                 return -ERESTARTSYS;
1901         if (edge_serial->num_ports_open == 0) {
1902                 /* we are the first port to open, post the interrupt urb */
1903                 urb = edge_serial->serial->port[0]->interrupt_in_urb;
1904                 if (!urb) {
1905                         dev_err(&port->dev,
1906                                 "%s - no interrupt urb present, exiting\n",
1907                                 __func__);
1908                         status = -EINVAL;
1909                         goto release_es_lock;
1910                 }
1911                 urb->context = edge_serial;
1912                 status = usb_submit_urb(urb, GFP_KERNEL);
1913                 if (status) {
1914                         dev_err(&port->dev,
1915                                 "%s - usb_submit_urb failed with value %d\n",
1916                                         __func__, status);
1917                         goto release_es_lock;
1918                 }
1919         }
1920
1921         /*
1922          * reset the data toggle on the bulk endpoints to work around bug in
1923          * host controllers where things get out of sync some times
1924          */
1925         usb_clear_halt(dev, port->write_urb->pipe);
1926         usb_clear_halt(dev, port->read_urb->pipe);
1927
1928         /* start up our bulk read urb */
1929         urb = port->read_urb;
1930         if (!urb) {
1931                 dev_err(&port->dev, "%s - no read urb present, exiting\n",
1932                                                                 __func__);
1933                 status = -EINVAL;
1934                 goto unlink_int_urb;
1935         }
1936         edge_port->ep_read_urb_state = EDGE_READ_URB_RUNNING;
1937         urb->context = edge_port;
1938         status = usb_submit_urb(urb, GFP_KERNEL);
1939         if (status) {
1940                 dev_err(&port->dev,
1941                         "%s - read bulk usb_submit_urb failed with value %d\n",
1942                                 __func__, status);
1943                 goto unlink_int_urb;
1944         }
1945
1946         ++edge_serial->num_ports_open;
1947
1948         goto release_es_lock;
1949
1950 unlink_int_urb:
1951         if (edge_port->edge_serial->num_ports_open == 0)
1952                 usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
1953 release_es_lock:
1954         mutex_unlock(&edge_serial->es_lock);
1955         return status;
1956 }
1957
1958 static void edge_close(struct usb_serial_port *port)
1959 {
1960         struct edgeport_serial *edge_serial;
1961         struct edgeport_port *edge_port;
1962         struct usb_serial *serial = port->serial;
1963         int port_number;
1964
1965         edge_serial = usb_get_serial_data(port->serial);
1966         edge_port = usb_get_serial_port_data(port);
1967         if (edge_serial == NULL || edge_port == NULL)
1968                 return;
1969
1970         /* The bulkreadcompletion routine will check
1971          * this flag and dump add read data */
1972         edge_port->close_pending = 1;
1973
1974         /* chase the port close and flush */
1975         chase_port(edge_port, (HZ * closing_wait) / 100, 1);
1976
1977         usb_kill_urb(port->read_urb);
1978         usb_kill_urb(port->write_urb);
1979         edge_port->ep_write_urb_in_use = 0;
1980
1981         /* assuming we can still talk to the device,
1982          * send a close port command to it */
1983         dev_dbg(&port->dev, "%s - send umpc_close_port\n", __func__);
1984         port_number = port->number - port->serial->minor;
1985
1986         mutex_lock(&serial->disc_mutex);
1987         if (!serial->disconnected) {
1988                 send_cmd(serial->dev,
1989                                      UMPC_CLOSE_PORT,
1990                                      (__u8)(UMPM_UART1_PORT + port_number),
1991                                      0,
1992                                      NULL,
1993                                      0);
1994         }
1995         mutex_unlock(&serial->disc_mutex);
1996
1997         mutex_lock(&edge_serial->es_lock);
1998         --edge_port->edge_serial->num_ports_open;
1999         if (edge_port->edge_serial->num_ports_open <= 0) {
2000                 /* last port is now closed, let's shut down our interrupt urb */
2001                 usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
2002                 edge_port->edge_serial->num_ports_open = 0;
2003         }
2004         mutex_unlock(&edge_serial->es_lock);
2005         edge_port->close_pending = 0;
2006 }
2007
2008 static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
2009                                 const unsigned char *data, int count)
2010 {
2011         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2012
2013         if (count == 0) {
2014                 dev_dbg(&port->dev, "%s - write request of 0 bytes\n", __func__);
2015                 return 0;
2016         }
2017
2018         if (edge_port == NULL)
2019                 return -ENODEV;
2020         if (edge_port->close_pending == 1)
2021                 return -ENODEV;
2022
2023         count = kfifo_in_locked(&edge_port->write_fifo, data, count,
2024                                                         &edge_port->ep_lock);
2025         edge_send(tty);
2026
2027         return count;
2028 }
2029
2030 static void edge_send(struct tty_struct *tty)
2031 {
2032         struct usb_serial_port *port = tty->driver_data;
2033         int count, result;
2034         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2035         unsigned long flags;
2036
2037         spin_lock_irqsave(&edge_port->ep_lock, flags);
2038
2039         if (edge_port->ep_write_urb_in_use) {
2040                 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2041                 return;
2042         }
2043
2044         count = kfifo_out(&edge_port->write_fifo,
2045                                 port->write_urb->transfer_buffer,
2046                                 port->bulk_out_size);
2047
2048         if (count == 0) {
2049                 spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2050                 return;
2051         }
2052
2053         edge_port->ep_write_urb_in_use = 1;
2054
2055         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2056
2057         usb_serial_debug_data(&port->dev, __func__, count, port->write_urb->transfer_buffer);
2058
2059         /* set up our urb */
2060         port->write_urb->transfer_buffer_length = count;
2061
2062         /* send the data out the bulk port */
2063         result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
2064         if (result) {
2065                 dev_err_console(port,
2066                         "%s - failed submitting write urb, error %d\n",
2067                                 __func__, result);
2068                 edge_port->ep_write_urb_in_use = 0;
2069                 /* TODO: reschedule edge_send */
2070         } else
2071                 edge_port->icount.tx += count;
2072
2073         /* wakeup any process waiting for writes to complete */
2074         /* there is now more room in the buffer for new writes */
2075         if (tty)
2076                 tty_wakeup(tty);
2077 }
2078
2079 static int edge_write_room(struct tty_struct *tty)
2080 {
2081         struct usb_serial_port *port = tty->driver_data;
2082         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2083         int room = 0;
2084         unsigned long flags;
2085
2086         if (edge_port == NULL)
2087                 return 0;
2088         if (edge_port->close_pending == 1)
2089                 return 0;
2090
2091         spin_lock_irqsave(&edge_port->ep_lock, flags);
2092         room = kfifo_avail(&edge_port->write_fifo);
2093         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2094
2095         dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
2096         return room;
2097 }
2098
2099 static int edge_chars_in_buffer(struct tty_struct *tty)
2100 {
2101         struct usb_serial_port *port = tty->driver_data;
2102         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2103         int chars = 0;
2104         unsigned long flags;
2105
2106         if (edge_port == NULL)
2107                 return 0;
2108         if (edge_port->close_pending == 1)
2109                 return 0;
2110
2111         spin_lock_irqsave(&edge_port->ep_lock, flags);
2112         chars = kfifo_len(&edge_port->write_fifo);
2113         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2114
2115         dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
2116         return chars;
2117 }
2118
2119 static void edge_throttle(struct tty_struct *tty)
2120 {
2121         struct usb_serial_port *port = tty->driver_data;
2122         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2123         int status;
2124
2125         if (edge_port == NULL)
2126                 return;
2127
2128         /* if we are implementing XON/XOFF, send the stop character */
2129         if (I_IXOFF(tty)) {
2130                 unsigned char stop_char = STOP_CHAR(tty);
2131                 status = edge_write(tty, port, &stop_char, 1);
2132                 if (status <= 0) {
2133                         dev_err(&port->dev, "%s - failed to write stop character, %d\n", __func__, status);
2134                 }
2135         }
2136
2137         /* if we are implementing RTS/CTS, stop reads */
2138         /* and the Edgeport will clear the RTS line */
2139         if (C_CRTSCTS(tty))
2140                 stop_read(edge_port);
2141
2142 }
2143
2144 static void edge_unthrottle(struct tty_struct *tty)
2145 {
2146         struct usb_serial_port *port = tty->driver_data;
2147         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2148         int status;
2149
2150         if (edge_port == NULL)
2151                 return;
2152
2153         /* if we are implementing XON/XOFF, send the start character */
2154         if (I_IXOFF(tty)) {
2155                 unsigned char start_char = START_CHAR(tty);
2156                 status = edge_write(tty, port, &start_char, 1);
2157                 if (status <= 0) {
2158                         dev_err(&port->dev, "%s - failed to write start character, %d\n", __func__, status);
2159                 }
2160         }
2161         /* if we are implementing RTS/CTS, restart reads */
2162         /* are the Edgeport will assert the RTS line */
2163         if (C_CRTSCTS(tty)) {
2164                 status = restart_read(edge_port);
2165                 if (status)
2166                         dev_err(&port->dev,
2167                                 "%s - read bulk usb_submit_urb failed: %d\n",
2168                                                         __func__, status);
2169         }
2170
2171 }
2172
2173 static void stop_read(struct edgeport_port *edge_port)
2174 {
2175         unsigned long flags;
2176
2177         spin_lock_irqsave(&edge_port->ep_lock, flags);
2178
2179         if (edge_port->ep_read_urb_state == EDGE_READ_URB_RUNNING)
2180                 edge_port->ep_read_urb_state = EDGE_READ_URB_STOPPING;
2181         edge_port->shadow_mcr &= ~MCR_RTS;
2182
2183         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2184 }
2185
2186 static int restart_read(struct edgeport_port *edge_port)
2187 {
2188         struct urb *urb;
2189         int status = 0;
2190         unsigned long flags;
2191
2192         spin_lock_irqsave(&edge_port->ep_lock, flags);
2193
2194         if (edge_port->ep_read_urb_state == EDGE_READ_URB_STOPPED) {
2195                 urb = edge_port->port->read_urb;
2196                 status = usb_submit_urb(urb, GFP_ATOMIC);
2197         }
2198         edge_port->ep_read_urb_state = EDGE_READ_URB_RUNNING;
2199         edge_port->shadow_mcr |= MCR_RTS;
2200
2201         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2202
2203         return status;
2204 }
2205
2206 static void change_port_settings(struct tty_struct *tty,
2207                 struct edgeport_port *edge_port, struct ktermios *old_termios)
2208 {
2209         struct device *dev = &edge_port->port->dev;
2210         struct ump_uart_config *config;
2211         int baud;
2212         unsigned cflag;
2213         int status;
2214         int port_number = edge_port->port->number -
2215                                         edge_port->port->serial->minor;
2216
2217         dev_dbg(dev, "%s - port %d\n", __func__, edge_port->port->number);
2218
2219         config = kmalloc (sizeof (*config), GFP_KERNEL);
2220         if (!config) {
2221                 tty->termios = *old_termios;
2222                 dev_err(dev, "%s - out of memory\n", __func__);
2223                 return;
2224         }
2225
2226         cflag = tty->termios.c_cflag;
2227
2228         config->wFlags = 0;
2229
2230         /* These flags must be set */
2231         config->wFlags |= UMP_MASK_UART_FLAGS_RECEIVE_MS_INT;
2232         config->wFlags |= UMP_MASK_UART_FLAGS_AUTO_START_ON_ERR;
2233         config->bUartMode = (__u8)(edge_port->bUartMode);
2234
2235         switch (cflag & CSIZE) {
2236         case CS5:
2237                     config->bDataBits = UMP_UART_CHAR5BITS;
2238                     dev_dbg(dev, "%s - data bits = 5\n", __func__);
2239                     break;
2240         case CS6:
2241                     config->bDataBits = UMP_UART_CHAR6BITS;
2242                     dev_dbg(dev, "%s - data bits = 6\n", __func__);
2243                     break;
2244         case CS7:
2245                     config->bDataBits = UMP_UART_CHAR7BITS;
2246                     dev_dbg(dev, "%s - data bits = 7\n", __func__);
2247                     break;
2248         default:
2249         case CS8:
2250                     config->bDataBits = UMP_UART_CHAR8BITS;
2251                     dev_dbg(dev, "%s - data bits = 8\n", __func__);
2252                             break;
2253         }
2254
2255         if (cflag & PARENB) {
2256                 if (cflag & PARODD) {
2257                         config->wFlags |= UMP_MASK_UART_FLAGS_PARITY;
2258                         config->bParity = UMP_UART_ODDPARITY;
2259                         dev_dbg(dev, "%s - parity = odd\n", __func__);
2260                 } else {
2261                         config->wFlags |= UMP_MASK_UART_FLAGS_PARITY;
2262                         config->bParity = UMP_UART_EVENPARITY;
2263                         dev_dbg(dev, "%s - parity = even\n", __func__);
2264                 }
2265         } else {
2266                 config->bParity = UMP_UART_NOPARITY;
2267                 dev_dbg(dev, "%s - parity = none\n", __func__);
2268         }
2269
2270         if (cflag & CSTOPB) {
2271                 config->bStopBits = UMP_UART_STOPBIT2;
2272                 dev_dbg(dev, "%s - stop bits = 2\n", __func__);
2273         } else {
2274                 config->bStopBits = UMP_UART_STOPBIT1;
2275                 dev_dbg(dev, "%s - stop bits = 1\n", __func__);
2276         }
2277
2278         /* figure out the flow control settings */
2279         if (cflag & CRTSCTS) {
2280                 config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X_CTS_FLOW;
2281                 config->wFlags |= UMP_MASK_UART_FLAGS_RTS_FLOW;
2282                 dev_dbg(dev, "%s - RTS/CTS is enabled\n", __func__);
2283         } else {
2284                 dev_dbg(dev, "%s - RTS/CTS is disabled\n", __func__);
2285                 tty->hw_stopped = 0;
2286                 restart_read(edge_port);
2287         }
2288
2289         /* if we are implementing XON/XOFF, set the start and stop
2290            character in the device */
2291         config->cXon  = START_CHAR(tty);
2292         config->cXoff = STOP_CHAR(tty);
2293
2294         /* if we are implementing INBOUND XON/XOFF */
2295         if (I_IXOFF(tty)) {
2296                 config->wFlags |= UMP_MASK_UART_FLAGS_IN_X;
2297                 dev_dbg(dev, "%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n",
2298                         __func__, config->cXon, config->cXoff);
2299         } else
2300                 dev_dbg(dev, "%s - INBOUND XON/XOFF is disabled\n", __func__);
2301
2302         /* if we are implementing OUTBOUND XON/XOFF */
2303         if (I_IXON(tty)) {
2304                 config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X;
2305                 dev_dbg(dev, "%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n",
2306                         __func__, config->cXon, config->cXoff);
2307         } else
2308                 dev_dbg(dev, "%s - OUTBOUND XON/XOFF is disabled\n", __func__);
2309
2310         tty->termios.c_cflag &= ~CMSPAR;
2311
2312         /* Round the baud rate */
2313         baud = tty_get_baud_rate(tty);
2314         if (!baud) {
2315                 /* pick a default, any default... */
2316                 baud = 9600;
2317         } else
2318                 tty_encode_baud_rate(tty, baud, baud);
2319
2320         edge_port->baud_rate = baud;
2321         config->wBaudRate = (__u16)((461550L + baud/2) / baud);
2322
2323         /* FIXME: Recompute actual baud from divisor here */
2324
2325         dev_dbg(dev, "%s - baud rate = %d, wBaudRate = %d\n", __func__, baud, config->wBaudRate);
2326
2327         dev_dbg(dev, "wBaudRate:   %d\n", (int)(461550L / config->wBaudRate));
2328         dev_dbg(dev, "wFlags:    0x%x\n", config->wFlags);
2329         dev_dbg(dev, "bDataBits:   %d\n", config->bDataBits);
2330         dev_dbg(dev, "bParity:     %d\n", config->bParity);
2331         dev_dbg(dev, "bStopBits:   %d\n", config->bStopBits);
2332         dev_dbg(dev, "cXon:        %d\n", config->cXon);
2333         dev_dbg(dev, "cXoff:       %d\n", config->cXoff);
2334         dev_dbg(dev, "bUartMode:   %d\n", config->bUartMode);
2335
2336         /* move the word values into big endian mode */
2337         cpu_to_be16s(&config->wFlags);
2338         cpu_to_be16s(&config->wBaudRate);
2339
2340         status = send_cmd(edge_port->port->serial->dev, UMPC_SET_CONFIG,
2341                                 (__u8)(UMPM_UART1_PORT + port_number),
2342                                 0, (__u8 *)config, sizeof(*config));
2343         if (status)
2344                 dev_dbg(dev, "%s - error %d when trying to write config to device\n",
2345                         __func__, status);
2346         kfree(config);
2347 }
2348
2349 static void edge_set_termios(struct tty_struct *tty,
2350                 struct usb_serial_port *port, struct ktermios *old_termios)
2351 {
2352         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2353         unsigned int cflag;
2354
2355         cflag = tty->termios.c_cflag;
2356
2357         dev_dbg(&port->dev, "%s - clfag %08x iflag %08x\n", __func__,
2358                 tty->termios.c_cflag, tty->termios.c_iflag);
2359         dev_dbg(&port->dev, "%s - old clfag %08x old iflag %08x\n", __func__,
2360                 old_termios->c_cflag, old_termios->c_iflag);
2361         dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number);
2362
2363         if (edge_port == NULL)
2364                 return;
2365         /* change the port settings to the new ones specified */
2366         change_port_settings(tty, edge_port, old_termios);
2367 }
2368
2369 static int edge_tiocmset(struct tty_struct *tty,
2370                                         unsigned int set, unsigned int clear)
2371 {
2372         struct usb_serial_port *port = tty->driver_data;
2373         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2374         unsigned int mcr;
2375         unsigned long flags;
2376
2377         spin_lock_irqsave(&edge_port->ep_lock, flags);
2378         mcr = edge_port->shadow_mcr;
2379         if (set & TIOCM_RTS)
2380                 mcr |= MCR_RTS;
2381         if (set & TIOCM_DTR)
2382                 mcr |= MCR_DTR;
2383         if (set & TIOCM_LOOP)
2384                 mcr |= MCR_LOOPBACK;
2385
2386         if (clear & TIOCM_RTS)
2387                 mcr &= ~MCR_RTS;
2388         if (clear & TIOCM_DTR)
2389                 mcr &= ~MCR_DTR;
2390         if (clear & TIOCM_LOOP)
2391                 mcr &= ~MCR_LOOPBACK;
2392
2393         edge_port->shadow_mcr = mcr;
2394         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2395
2396         restore_mcr(edge_port, mcr);
2397         return 0;
2398 }
2399
2400 static int edge_tiocmget(struct tty_struct *tty)
2401 {
2402         struct usb_serial_port *port = tty->driver_data;
2403         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2404         unsigned int result = 0;
2405         unsigned int msr;
2406         unsigned int mcr;
2407         unsigned long flags;
2408
2409         spin_lock_irqsave(&edge_port->ep_lock, flags);
2410
2411         msr = edge_port->shadow_msr;
2412         mcr = edge_port->shadow_mcr;
2413         result = ((mcr & MCR_DTR)       ? TIOCM_DTR: 0)   /* 0x002 */
2414                   | ((mcr & MCR_RTS)    ? TIOCM_RTS: 0)   /* 0x004 */
2415                   | ((msr & EDGEPORT_MSR_CTS)   ? TIOCM_CTS: 0)   /* 0x020 */
2416                   | ((msr & EDGEPORT_MSR_CD)    ? TIOCM_CAR: 0)   /* 0x040 */
2417                   | ((msr & EDGEPORT_MSR_RI)    ? TIOCM_RI:  0)   /* 0x080 */
2418                   | ((msr & EDGEPORT_MSR_DSR)   ? TIOCM_DSR: 0);  /* 0x100 */
2419
2420
2421         dev_dbg(&port->dev, "%s -- %x\n", __func__, result);
2422         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
2423
2424         return result;
2425 }
2426
2427 static int edge_get_icount(struct tty_struct *tty,
2428                                 struct serial_icounter_struct *icount)
2429 {
2430         struct usb_serial_port *port = tty->driver_data;
2431         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2432         struct async_icount *ic = &edge_port->icount;
2433
2434         icount->cts = ic->cts;
2435         icount->dsr = ic->dsr;
2436         icount->rng = ic->rng;
2437         icount->dcd = ic->dcd;
2438         icount->tx = ic->tx;
2439         icount->rx = ic->rx;
2440         icount->frame = ic->frame;
2441         icount->parity = ic->parity;
2442         icount->overrun = ic->overrun;
2443         icount->brk = ic->brk;
2444         icount->buf_overrun = ic->buf_overrun;
2445         return 0;
2446 }
2447
2448 static int get_serial_info(struct edgeport_port *edge_port,
2449                                 struct serial_struct __user *retinfo)
2450 {
2451         struct serial_struct tmp;
2452
2453         if (!retinfo)
2454                 return -EFAULT;
2455
2456         memset(&tmp, 0, sizeof(tmp));
2457
2458         tmp.type                = PORT_16550A;
2459         tmp.line                = edge_port->port->serial->minor;
2460         tmp.port                = edge_port->port->number;
2461         tmp.irq                 = 0;
2462         tmp.flags               = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
2463         tmp.xmit_fifo_size      = edge_port->port->bulk_out_size;
2464         tmp.baud_base           = 9600;
2465         tmp.close_delay         = 5*HZ;
2466         tmp.closing_wait        = closing_wait;
2467
2468         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
2469                 return -EFAULT;
2470         return 0;
2471 }
2472
2473 static int edge_ioctl(struct tty_struct *tty,
2474                                         unsigned int cmd, unsigned long arg)
2475 {
2476         struct usb_serial_port *port = tty->driver_data;
2477         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2478         struct async_icount cnow;
2479         struct async_icount cprev;
2480
2481         dev_dbg(&port->dev, "%s - port %d, cmd = 0x%x\n", __func__, port->number, cmd);
2482
2483         switch (cmd) {
2484         case TIOCGSERIAL:
2485                 dev_dbg(&port->dev, "%s - TIOCGSERIAL\n", __func__);
2486                 return get_serial_info(edge_port,
2487                                 (struct serial_struct __user *) arg);
2488         case TIOCMIWAIT:
2489                 dev_dbg(&port->dev, "%s - TIOCMIWAIT\n", __func__);
2490                 cprev = edge_port->icount;
2491                 while (1) {
2492                         interruptible_sleep_on(&edge_port->delta_msr_wait);
2493                         /* see if a signal did it */
2494                         if (signal_pending(current))
2495                                 return -ERESTARTSYS;
2496                         cnow = edge_port->icount;
2497                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
2498                             cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
2499                                 return -EIO; /* no change => error */
2500                         if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
2501                             ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
2502                             ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
2503                             ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
2504                                 return 0;
2505                         }
2506                         cprev = cnow;
2507                 }
2508                 /* not reached */
2509                 break;
2510         }
2511         return -ENOIOCTLCMD;
2512 }
2513
2514 static void edge_break(struct tty_struct *tty, int break_state)
2515 {
2516         struct usb_serial_port *port = tty->driver_data;
2517         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2518         int status;
2519         int bv = 0;     /* Off */
2520
2521         /* chase the port close */
2522         chase_port(edge_port, 0, 0);
2523
2524         if (break_state == -1)
2525                 bv = 1; /* On */
2526         status = ti_do_config(edge_port, UMPC_SET_CLR_BREAK, bv);
2527         if (status)
2528                 dev_dbg(&port->dev, "%s - error %d sending break set/clear command.\n",
2529                         __func__, status);
2530 }
2531
2532 static int edge_startup(struct usb_serial *serial)
2533 {
2534         struct edgeport_serial *edge_serial;
2535         struct edgeport_port *edge_port;
2536         struct usb_device *dev;
2537         int status;
2538         int i;
2539
2540         dev = serial->dev;
2541
2542         /* create our private serial structure */
2543         edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
2544         if (edge_serial == NULL) {
2545                 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
2546                 return -ENOMEM;
2547         }
2548         mutex_init(&edge_serial->es_lock);
2549         edge_serial->serial = serial;
2550         usb_set_serial_data(serial, edge_serial);
2551
2552         status = download_fw(edge_serial);
2553         if (status) {
2554                 kfree(edge_serial);
2555                 return status;
2556         }
2557
2558         /* set up our port private structures */
2559         for (i = 0; i < serial->num_ports; ++i) {
2560                 edge_port = kzalloc(sizeof(struct edgeport_port), GFP_KERNEL);
2561                 if (edge_port == NULL) {
2562                         dev_err(&serial->dev->dev, "%s - Out of memory\n",
2563                                                                 __func__);
2564                         goto cleanup;
2565                 }
2566                 spin_lock_init(&edge_port->ep_lock);
2567                 if (kfifo_alloc(&edge_port->write_fifo, EDGE_OUT_BUF_SIZE,
2568                                                                 GFP_KERNEL)) {
2569                         dev_err(&serial->dev->dev, "%s - Out of memory\n",
2570                                                                 __func__);
2571                         kfree(edge_port);
2572                         goto cleanup;
2573                 }
2574                 edge_port->port = serial->port[i];
2575                 edge_port->edge_serial = edge_serial;
2576                 usb_set_serial_port_data(serial->port[i], edge_port);
2577                 edge_port->bUartMode = default_uart_mode;
2578         }
2579
2580         return 0;
2581
2582 cleanup:
2583         for (--i; i >= 0; --i) {
2584                 edge_port = usb_get_serial_port_data(serial->port[i]);
2585                 kfifo_free(&edge_port->write_fifo);
2586                 kfree(edge_port);
2587                 usb_set_serial_port_data(serial->port[i], NULL);
2588         }
2589         kfree(edge_serial);
2590         usb_set_serial_data(serial, NULL);
2591         return -ENOMEM;
2592 }
2593
2594 static void edge_disconnect(struct usb_serial *serial)
2595 {
2596 }
2597
2598 static void edge_release(struct usb_serial *serial)
2599 {
2600         int i;
2601         struct edgeport_port *edge_port;
2602
2603         for (i = 0; i < serial->num_ports; ++i) {
2604                 edge_port = usb_get_serial_port_data(serial->port[i]);
2605                 kfifo_free(&edge_port->write_fifo);
2606                 kfree(edge_port);
2607         }
2608         kfree(usb_get_serial_data(serial));
2609 }
2610
2611
2612 /* Sysfs Attributes */
2613
2614 static ssize_t show_uart_mode(struct device *dev,
2615         struct device_attribute *attr, char *buf)
2616 {
2617         struct usb_serial_port *port = to_usb_serial_port(dev);
2618         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2619
2620         return sprintf(buf, "%d\n", edge_port->bUartMode);
2621 }
2622
2623 static ssize_t store_uart_mode(struct device *dev,
2624         struct device_attribute *attr, const char *valbuf, size_t count)
2625 {
2626         struct usb_serial_port *port = to_usb_serial_port(dev);
2627         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
2628         unsigned int v = simple_strtoul(valbuf, NULL, 0);
2629
2630         dev_dbg(dev, "%s: setting uart_mode = %d\n", __func__, v);
2631
2632         if (v < 256)
2633                 edge_port->bUartMode = v;
2634         else
2635                 dev_err(dev, "%s - uart_mode %d is invalid\n", __func__, v);
2636
2637         return count;
2638 }
2639
2640 static DEVICE_ATTR(uart_mode, S_IWUSR | S_IRUGO, show_uart_mode,
2641                                                         store_uart_mode);
2642
2643 static int edge_create_sysfs_attrs(struct usb_serial_port *port)
2644 {
2645         return device_create_file(&port->dev, &dev_attr_uart_mode);
2646 }
2647
2648 static int edge_remove_sysfs_attrs(struct usb_serial_port *port)
2649 {
2650         device_remove_file(&port->dev, &dev_attr_uart_mode);
2651         return 0;
2652 }
2653
2654
2655 static struct usb_serial_driver edgeport_1port_device = {
2656         .driver = {
2657                 .owner          = THIS_MODULE,
2658                 .name           = "edgeport_ti_1",
2659         },
2660         .description            = "Edgeport TI 1 port adapter",
2661         .id_table               = edgeport_1port_id_table,
2662         .num_ports              = 1,
2663         .open                   = edge_open,
2664         .close                  = edge_close,
2665         .throttle               = edge_throttle,
2666         .unthrottle             = edge_unthrottle,
2667         .attach                 = edge_startup,
2668         .disconnect             = edge_disconnect,
2669         .release                = edge_release,
2670         .port_probe             = edge_create_sysfs_attrs,
2671         .port_remove            = edge_remove_sysfs_attrs,
2672         .ioctl                  = edge_ioctl,
2673         .set_termios            = edge_set_termios,
2674         .tiocmget               = edge_tiocmget,
2675         .tiocmset               = edge_tiocmset,
2676         .get_icount             = edge_get_icount,
2677         .write                  = edge_write,
2678         .write_room             = edge_write_room,
2679         .chars_in_buffer        = edge_chars_in_buffer,
2680         .break_ctl              = edge_break,
2681         .read_int_callback      = edge_interrupt_callback,
2682         .read_bulk_callback     = edge_bulk_in_callback,
2683         .write_bulk_callback    = edge_bulk_out_callback,
2684 };
2685
2686 static struct usb_serial_driver edgeport_2port_device = {
2687         .driver = {
2688                 .owner          = THIS_MODULE,
2689                 .name           = "edgeport_ti_2",
2690         },
2691         .description            = "Edgeport TI 2 port adapter",
2692         .id_table               = edgeport_2port_id_table,
2693         .num_ports              = 2,
2694         .open                   = edge_open,
2695         .close                  = edge_close,
2696         .throttle               = edge_throttle,
2697         .unthrottle             = edge_unthrottle,
2698         .attach                 = edge_startup,
2699         .disconnect             = edge_disconnect,
2700         .release                = edge_release,
2701         .port_probe             = edge_create_sysfs_attrs,
2702         .port_remove            = edge_remove_sysfs_attrs,
2703         .ioctl                  = edge_ioctl,
2704         .set_termios            = edge_set_termios,
2705         .tiocmget               = edge_tiocmget,
2706         .tiocmset               = edge_tiocmset,
2707         .write                  = edge_write,
2708         .write_room             = edge_write_room,
2709         .chars_in_buffer        = edge_chars_in_buffer,
2710         .break_ctl              = edge_break,
2711         .read_int_callback      = edge_interrupt_callback,
2712         .read_bulk_callback     = edge_bulk_in_callback,
2713         .write_bulk_callback    = edge_bulk_out_callback,
2714 };
2715
2716 static struct usb_serial_driver * const serial_drivers[] = {
2717         &edgeport_1port_device, &edgeport_2port_device, NULL
2718 };
2719
2720 module_usb_serial_driver(serial_drivers, id_table_combined);
2721
2722 MODULE_AUTHOR(DRIVER_AUTHOR);
2723 MODULE_DESCRIPTION(DRIVER_DESC);
2724 MODULE_LICENSE("GPL");
2725 MODULE_FIRMWARE("edgeport/down3.bin");
2726
2727 module_param(closing_wait, int, S_IRUGO | S_IWUSR);
2728 MODULE_PARM_DESC(closing_wait, "Maximum wait for data to drain, in .01 secs");
2729
2730 module_param(ignore_cpu_rev, bool, S_IRUGO | S_IWUSR);
2731 MODULE_PARM_DESC(ignore_cpu_rev,
2732                         "Ignore the cpu revision when connecting to a device");
2733
2734 module_param(default_uart_mode, int, S_IRUGO | S_IWUSR);
2735 MODULE_PARM_DESC(default_uart_mode, "Default uart_mode, 0=RS232, ...");