ti_usb_3410_5052.c 47.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/* vi: ts=8 sw=8
 *
 * TI 3410/5052 USB Serial Driver
 *
 * Copyright (C) 2004 Texas Instruments
 *
 * This driver is based on the Linux io_ti driver, which is
 *   Copyright (C) 2000-2002 Inside Out Networks
 *   Copyright (C) 2001-2002 Greg Kroah-Hartman
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * For questions or problems with this driver, contact Texas Instruments
 * technical support, or Al Borchers <alborchers@steinerpoint.com>, or
 * Peter Berger <pberger@brimson.com>.
A
Alan Cox 已提交
19
 *
L
Linus Torvalds 已提交
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
 * This driver needs this hotplug script in /etc/hotplug/usb/ti_usb_3410_5052
 * or in /etc/hotplug.d/usb/ti_usb_3410_5052.hotplug to set the device
 * configuration.
 *
 * #!/bin/bash
 *
 * BOOT_CONFIG=1
 * ACTIVE_CONFIG=2
 *
 * if [[ "$ACTION" != "add" ]]
 * then
 * 	exit
 * fi
 *
 * CONFIG_PATH=/sys${DEVPATH%/?*}/bConfigurationValue
 *
 * if [[ 0`cat $CONFIG_PATH` -ne $BOOT_CONFIG ]]
 * then
 * 	exit
 * fi
 *
 * PRODUCT=${PRODUCT%/?*}		# delete version
 * VENDOR_ID=`printf "%d" 0x${PRODUCT%/?*}`
 * PRODUCT_ID=`printf "%d" 0x${PRODUCT#*?/}`
 *
 * PARAM_PATH=/sys/module/ti_usb_3410_5052/parameters
 *
 * function scan() {
 * 	s=$1
 * 	shift
 * 	for i
 * 	do
 * 		if [[ $s -eq $i ]]
 * 		then
 * 			return 0
 * 		fi
 * 	done
 * 	return 1
 * }
 *
 * IFS=$IFS,
 *
 * if (scan $VENDOR_ID 1105 `cat $PARAM_PATH/vendor_3410` &&
 * scan $PRODUCT_ID 13328 `cat $PARAM_PATH/product_3410`) ||
 * (scan $VENDOR_ID 1105 `cat $PARAM_PATH/vendor_5052` &&
 * scan $PRODUCT_ID 20562 20818 20570 20575 `cat $PARAM_PATH/product_5052`)
 * then
 * 	echo $ACTIVE_CONFIG > $CONFIG_PATH
 * fi
 */

#include <linux/kernel.h>
#include <linux/errno.h>
A
Alan Cox 已提交
73
#include <linux/firmware.h>
L
Linus Torvalds 已提交
74 75 76 77 78 79 80 81 82 83
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/ioctl.h>
#include <linux/serial.h>
#include <linux/circ_buf.h>
84
#include <linux/mutex.h>
A
Alan Cox 已提交
85
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
86
#include <linux/usb.h>
87
#include <linux/usb/serial.h>
88
#include <linux/firmware.h>
L
Linus Torvalds 已提交
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140

#include "ti_usb_3410_5052.h"

/* Defines */

#define TI_DRIVER_VERSION	"v0.9"
#define TI_DRIVER_AUTHOR	"Al Borchers <alborchers@steinerpoint.com>"
#define TI_DRIVER_DESC		"TI USB 3410/5052 Serial Driver"

#define TI_FIRMWARE_BUF_SIZE	16284

#define TI_WRITE_BUF_SIZE	1024

#define TI_TRANSFER_TIMEOUT	2

#define TI_DEFAULT_LOW_LATENCY	0
#define TI_DEFAULT_CLOSING_WAIT	4000		/* in .01 secs */

/* supported setserial flags */
#define TI_SET_SERIAL_FLAGS	(ASYNC_LOW_LATENCY)

/* read urb states */
#define TI_READ_URB_RUNNING	0
#define TI_READ_URB_STOPPING	1
#define TI_READ_URB_STOPPED	2

#define TI_EXTRA_VID_PID_COUNT	5


/* Structures */

struct ti_port {
	int			tp_is_open;
	__u8			tp_msr;
	__u8			tp_lsr;
	__u8			tp_shadow_mcr;
	__u8			tp_uart_mode;	/* 232 or 485 modes */
	unsigned int		tp_uart_base_addr;
	int			tp_flags;
	int			tp_closing_wait;/* in .01 secs */
	struct async_icount	tp_icount;
	wait_queue_head_t	tp_msr_wait;	/* wait for msr change */
	wait_queue_head_t	tp_write_wait;
	struct ti_device	*tp_tdev;
	struct usb_serial_port	*tp_port;
	spinlock_t		tp_lock;
	int			tp_read_urb_state;
	int			tp_write_urb_in_use;
	struct circ_buf		*tp_write_buf;
};

struct ti_device {
141
	struct mutex		td_open_close_lock;
L
Linus Torvalds 已提交
142 143 144 145 146 147 148 149 150 151 152
	int			td_open_port_count;
	struct usb_serial	*td_serial;
	int			td_is_3410;
	int			td_urb_error;
};


/* Function Declarations */

static int ti_startup(struct usb_serial *serial);
static void ti_shutdown(struct usb_serial *serial);
A
Alan Cox 已提交
153
static int ti_open(struct tty_struct *tty, struct usb_serial_port *port,
A
Alan Cox 已提交
154
		struct file *file);
A
Alan Cox 已提交
155
static void ti_close(struct tty_struct *tty, struct usb_serial_port *port,
A
Alan Cox 已提交
156
		struct file *file);
A
Alan Cox 已提交
157
static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
A
Alan Cox 已提交
158
		const unsigned char *data, int count);
A
Alan Cox 已提交
159 160 161 162
static int ti_write_room(struct tty_struct *tty);
static int ti_chars_in_buffer(struct tty_struct *tty);
static void ti_throttle(struct tty_struct *tty);
static void ti_unthrottle(struct tty_struct *tty);
A
Alan Cox 已提交
163 164 165 166
static int ti_ioctl(struct tty_struct *tty, struct file *file,
		unsigned int cmd, unsigned long arg);
static void ti_set_termios(struct tty_struct *tty,
		struct usb_serial_port *port, struct ktermios *old_termios);
A
Alan Cox 已提交
167 168
static int ti_tiocmget(struct tty_struct *tty, struct file *file);
static int ti_tiocmset(struct tty_struct *tty, struct file *file,
A
Alan Cox 已提交
169
		unsigned int set, unsigned int clear);
A
Alan Cox 已提交
170
static void ti_break(struct tty_struct *tty, int break_state);
171 172 173
static void ti_interrupt_callback(struct urb *urb);
static void ti_bulk_in_callback(struct urb *urb);
static void ti_bulk_out_callback(struct urb *urb);
L
Linus Torvalds 已提交
174 175 176 177 178 179 180 181

static void ti_recv(struct device *dev, struct tty_struct *tty,
	unsigned char *data, int length);
static void ti_send(struct ti_port *tport);
static int ti_set_mcr(struct ti_port *tport, unsigned int mcr);
static int ti_get_lsr(struct ti_port *tport);
static int ti_get_serial_info(struct ti_port *tport,
	struct serial_struct __user *ret_arg);
A
Alan Cox 已提交
182
static int ti_set_serial_info(struct tty_struct *tty, struct ti_port *tport,
L
Linus Torvalds 已提交
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
	struct serial_struct __user *new_arg);
static void ti_handle_new_msr(struct ti_port *tport, __u8 msr);

static void ti_drain(struct ti_port *tport, unsigned long timeout, int flush);

static void ti_stop_read(struct ti_port *tport, struct tty_struct *tty);
static int ti_restart_read(struct ti_port *tport, struct tty_struct *tty);

static int ti_command_out_sync(struct ti_device *tdev, __u8 command,
	__u16 moduleid, __u16 value, __u8 *data, int size);
static int ti_command_in_sync(struct ti_device *tdev, __u8 command,
	__u16 moduleid, __u16 value, __u8 *data, int size);

static int ti_write_byte(struct ti_device *tdev, unsigned long addr,
	__u8 mask, __u8 byte);

A
Alan Cox 已提交
199
static int ti_download_firmware(struct ti_device *tdev, int type);
L
Linus Torvalds 已提交
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217

/* circular buffer */
static struct circ_buf *ti_buf_alloc(void);
static void ti_buf_free(struct circ_buf *cb);
static void ti_buf_clear(struct circ_buf *cb);
static int ti_buf_data_avail(struct circ_buf *cb);
static int ti_buf_space_avail(struct circ_buf *cb);
static int ti_buf_put(struct circ_buf *cb, const char *buf, int count);
static int ti_buf_get(struct circ_buf *cb, char *buf, int count);


/* Data */

/* module parameters */
static int debug;
static int low_latency = TI_DEFAULT_LOW_LATENCY;
static int closing_wait = TI_DEFAULT_CLOSING_WAIT;
static ushort vendor_3410[TI_EXTRA_VID_PID_COUNT];
218
static unsigned int vendor_3410_count;
L
Linus Torvalds 已提交
219
static ushort product_3410[TI_EXTRA_VID_PID_COUNT];
220
static unsigned int product_3410_count;
L
Linus Torvalds 已提交
221
static ushort vendor_5052[TI_EXTRA_VID_PID_COUNT];
222
static unsigned int vendor_5052_count;
L
Linus Torvalds 已提交
223
static ushort product_5052[TI_EXTRA_VID_PID_COUNT];
224
static unsigned int product_5052_count;
L
Linus Torvalds 已提交
225 226 227 228 229 230 231

/* supported devices */
/* the array dimension is the number of default entries plus */
/* TI_EXTRA_VID_PID_COUNT user defined entries plus 1 terminating */
/* null entry */
static struct usb_device_id ti_id_table_3410[1+TI_EXTRA_VID_PID_COUNT+1] = {
	{ USB_DEVICE(TI_VENDOR_ID, TI_3410_PRODUCT_ID) },
232
	{ USB_DEVICE(TI_VENDOR_ID, TI_3410_EZ430_ID) },
L
Linus Torvalds 已提交
233 234 235 236 237 238 239 240 241 242 243
};

static struct usb_device_id ti_id_table_5052[4+TI_EXTRA_VID_PID_COUNT+1] = {
	{ USB_DEVICE(TI_VENDOR_ID, TI_5052_BOOT_PRODUCT_ID) },
	{ USB_DEVICE(TI_VENDOR_ID, TI_5152_BOOT_PRODUCT_ID) },
	{ USB_DEVICE(TI_VENDOR_ID, TI_5052_EEPROM_PRODUCT_ID) },
	{ USB_DEVICE(TI_VENDOR_ID, TI_5052_FIRMWARE_PRODUCT_ID) },
};

static struct usb_device_id ti_id_table_combined[] = {
	{ USB_DEVICE(TI_VENDOR_ID, TI_3410_PRODUCT_ID) },
244
	{ USB_DEVICE(TI_VENDOR_ID, TI_3410_EZ430_ID) },
L
Linus Torvalds 已提交
245 246 247 248 249 250 251 252 253 254 255 256
	{ USB_DEVICE(TI_VENDOR_ID, TI_5052_BOOT_PRODUCT_ID) },
	{ USB_DEVICE(TI_VENDOR_ID, TI_5152_BOOT_PRODUCT_ID) },
	{ USB_DEVICE(TI_VENDOR_ID, TI_5052_EEPROM_PRODUCT_ID) },
	{ USB_DEVICE(TI_VENDOR_ID, TI_5052_FIRMWARE_PRODUCT_ID) },
	{ }
};

static struct usb_driver ti_usb_driver = {
	.name			= "ti_usb_3410_5052",
	.probe			= usb_serial_probe,
	.disconnect		= usb_serial_disconnect,
	.id_table		= ti_id_table_combined,
257
	.no_dynamic_id = 	1,
L
Linus Torvalds 已提交
258 259
};

260
static struct usb_serial_driver ti_1port_device = {
261
	.driver = {
262 263
		.owner		= THIS_MODULE,
		.name		= "ti_usb_3410_5052_1",
264
	},
265
	.description		= "TI USB 3410 1 port adapter",
266
	.usb_driver		= &ti_usb_driver,
L
Linus Torvalds 已提交
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
	.id_table		= ti_id_table_3410,
	.num_ports		= 1,
	.attach			= ti_startup,
	.shutdown		= ti_shutdown,
	.open			= ti_open,
	.close			= ti_close,
	.write			= ti_write,
	.write_room		= ti_write_room,
	.chars_in_buffer	= ti_chars_in_buffer,
	.throttle		= ti_throttle,
	.unthrottle		= ti_unthrottle,
	.ioctl			= ti_ioctl,
	.set_termios		= ti_set_termios,
	.tiocmget		= ti_tiocmget,
	.tiocmset		= ti_tiocmset,
	.break_ctl		= ti_break,
	.read_int_callback	= ti_interrupt_callback,
	.read_bulk_callback	= ti_bulk_in_callback,
	.write_bulk_callback	= ti_bulk_out_callback,
};

288
static struct usb_serial_driver ti_2port_device = {
289
	.driver = {
290 291
		.owner		= THIS_MODULE,
		.name		= "ti_usb_3410_5052_2",
292
	},
293
	.description		= "TI USB 5052 2 port adapter",
294
	.usb_driver		= &ti_usb_driver,
L
Linus Torvalds 已提交
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
	.id_table		= ti_id_table_5052,
	.num_ports		= 2,
	.attach			= ti_startup,
	.shutdown		= ti_shutdown,
	.open			= ti_open,
	.close			= ti_close,
	.write			= ti_write,
	.write_room		= ti_write_room,
	.chars_in_buffer	= ti_chars_in_buffer,
	.throttle		= ti_throttle,
	.unthrottle		= ti_unthrottle,
	.ioctl			= ti_ioctl,
	.set_termios		= ti_set_termios,
	.tiocmget		= ti_tiocmget,
	.tiocmset		= ti_tiocmset,
	.break_ctl		= ti_break,
	.read_int_callback	= ti_interrupt_callback,
	.read_bulk_callback	= ti_bulk_in_callback,
	.write_bulk_callback	= ti_bulk_out_callback,
};


/* Module */

MODULE_AUTHOR(TI_DRIVER_AUTHOR);
MODULE_DESCRIPTION(TI_DRIVER_DESC);
MODULE_VERSION(TI_DRIVER_VERSION);
MODULE_LICENSE("GPL");

324 325 326
MODULE_FIRMWARE("ti_3410.fw");
MODULE_FIRMWARE("ti_5052.fw");

L
Linus Torvalds 已提交
327 328 329 330
module_param(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Enable debugging, 0=no, 1=yes");

module_param(low_latency, bool, S_IRUGO | S_IWUSR);
A
Alan Cox 已提交
331 332
MODULE_PARM_DESC(low_latency,
		"TTY low_latency flag, 0=off, 1=on, default is off");
L
Linus Torvalds 已提交
333 334

module_param(closing_wait, int, S_IRUGO | S_IWUSR);
A
Alan Cox 已提交
335 336
MODULE_PARM_DESC(closing_wait,
    "Maximum wait for data to drain in close, in .01 secs, default is 4000");
L
Linus Torvalds 已提交
337 338

module_param_array(vendor_3410, ushort, &vendor_3410_count, S_IRUGO);
A
Alan Cox 已提交
339 340
MODULE_PARM_DESC(vendor_3410,
		"Vendor ids for 3410 based devices, 1-5 short integers");
L
Linus Torvalds 已提交
341
module_param_array(product_3410, ushort, &product_3410_count, S_IRUGO);
A
Alan Cox 已提交
342 343
MODULE_PARM_DESC(product_3410,
		"Product ids for 3410 based devices, 1-5 short integers");
L
Linus Torvalds 已提交
344
module_param_array(vendor_5052, ushort, &vendor_5052_count, S_IRUGO);
A
Alan Cox 已提交
345 346
MODULE_PARM_DESC(vendor_5052,
		"Vendor ids for 5052 based devices, 1-5 short integers");
L
Linus Torvalds 已提交
347
module_param_array(product_5052, ushort, &product_5052_count, S_IRUGO);
A
Alan Cox 已提交
348 349
MODULE_PARM_DESC(product_5052,
		"Product ids for 5052 based devices, 1-5 short integers");
L
Linus Torvalds 已提交
350 351 352 353 354 355 356 357

MODULE_DEVICE_TABLE(usb, ti_id_table_combined);


/* Functions */

static int __init ti_init(void)
{
A
Alan Cox 已提交
358
	int i, j;
L
Linus Torvalds 已提交
359 360 361
	int ret;

	/* insert extra vendor and product ids */
362
	j = ARRAY_SIZE(ti_id_table_3410) - TI_EXTRA_VID_PID_COUNT - 1;
A
Alan Cox 已提交
363
	for (i = 0; i < min(vendor_3410_count, product_3410_count); i++, j++) {
L
Linus Torvalds 已提交
364 365 366 367
		ti_id_table_3410[j].idVendor = vendor_3410[i];
		ti_id_table_3410[j].idProduct = product_3410[i];
		ti_id_table_3410[j].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
	}
368
	j = ARRAY_SIZE(ti_id_table_5052) - TI_EXTRA_VID_PID_COUNT - 1;
A
Alan Cox 已提交
369
	for (i = 0; i < min(vendor_5052_count, product_5052_count); i++, j++) {
L
Linus Torvalds 已提交
370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
		ti_id_table_5052[j].idVendor = vendor_5052[i];
		ti_id_table_5052[j].idProduct = product_5052[i];
		ti_id_table_5052[j].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
	}

	ret = usb_serial_register(&ti_1port_device);
	if (ret)
		goto failed_1port;
	ret = usb_serial_register(&ti_2port_device);
	if (ret)
		goto failed_2port;

	ret = usb_register(&ti_usb_driver);
	if (ret)
		goto failed_usb;

	info(TI_DRIVER_DESC " " TI_DRIVER_VERSION);

	return 0;

failed_usb:
	usb_serial_deregister(&ti_2port_device);
failed_2port:
	usb_serial_deregister(&ti_1port_device);
failed_1port:
	return ret;
}


static void __exit ti_exit(void)
{
	usb_serial_deregister(&ti_1port_device);
	usb_serial_deregister(&ti_2port_device);
	usb_deregister(&ti_usb_driver);
}


module_init(ti_init);
module_exit(ti_exit);


static int ti_startup(struct usb_serial *serial)
{
	struct ti_device *tdev;
	struct ti_port *tport;
	struct usb_device *dev = serial->dev;
	int status;
	int i;


	dbg("%s - product 0x%4X, num configurations %d, configuration value %d",
421
	    __func__, le16_to_cpu(dev->descriptor.idProduct),
L
Linus Torvalds 已提交
422 423 424 425
	    dev->descriptor.bNumConfigurations,
	    dev->actconfig->desc.bConfigurationValue);

	/* create device structure */
426
	tdev = kzalloc(sizeof(struct ti_device), GFP_KERNEL);
L
Linus Torvalds 已提交
427
	if (tdev == NULL) {
428
		dev_err(&dev->dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
429 430
		return -ENOMEM;
	}
431
	mutex_init(&tdev->td_open_close_lock);
L
Linus Torvalds 已提交
432 433 434 435 436 437
	tdev->td_serial = serial;
	usb_set_serial_data(serial, tdev);

	/* determine device type */
	if (usb_match_id(serial->interface, ti_id_table_3410))
		tdev->td_is_3410 = 1;
A
Alan Cox 已提交
438 439
	dbg("%s - device type is %s", __func__,
				tdev->td_is_3410 ? "3410" : "5052");
L
Linus Torvalds 已提交
440 441 442 443

	/* if we have only 1 configuration, download firmware */
	if (dev->descriptor.bNumConfigurations == 1) {
		if (tdev->td_is_3410)
A
Alan Cox 已提交
444
			status = ti_download_firmware(tdev, 3410);
L
Linus Torvalds 已提交
445
		else
A
Alan Cox 已提交
446
			status = ti_download_firmware(tdev, 5052);
L
Linus Torvalds 已提交
447 448 449 450 451 452 453 454 455 456 457
		if (status)
			goto free_tdev;

		/* 3410 must be reset, 5052 resets itself */
		if (tdev->td_is_3410) {
			msleep_interruptible(100);
			usb_reset_device(dev);
		}

		status = -ENODEV;
		goto free_tdev;
A
Alan Cox 已提交
458
	}
L
Linus Torvalds 已提交
459 460 461 462 463 464 465 466 467

	/* the second configuration must be set (in sysfs by hotplug script) */
	if (dev->actconfig->desc.bConfigurationValue == TI_BOOT_CONFIG) {
		status = -ENODEV;
		goto free_tdev;
	}

	/* set up port structures */
	for (i = 0; i < serial->num_ports; ++i) {
468
		tport = kzalloc(sizeof(struct ti_port), GFP_KERNEL);
L
Linus Torvalds 已提交
469
		if (tport == NULL) {
470
			dev_err(&dev->dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
471 472 473 474
			status = -ENOMEM;
			goto free_tports;
		}
		spin_lock_init(&tport->tp_lock);
A
Alan Cox 已提交
475 476
		tport->tp_uart_base_addr = (i == 0 ?
				TI_UART1_BASE_ADDR : TI_UART2_BASE_ADDR);
L
Linus Torvalds 已提交
477 478 479 480 481 482
		tport->tp_flags = low_latency ? ASYNC_LOW_LATENCY : 0;
		tport->tp_closing_wait = closing_wait;
		init_waitqueue_head(&tport->tp_msr_wait);
		init_waitqueue_head(&tport->tp_write_wait);
		tport->tp_write_buf = ti_buf_alloc();
		if (tport->tp_write_buf == NULL) {
483
			dev_err(&dev->dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
484 485 486 487 488 489 490 491 492
			kfree(tport);
			status = -ENOMEM;
			goto free_tports;
		}
		tport->tp_port = serial->port[i];
		tport->tp_tdev = tdev;
		usb_set_serial_port_data(serial->port[i], tport);
		tport->tp_uart_mode = 0;	/* default is RS232 */
	}
A
Alan Cox 已提交
493

L
Linus Torvalds 已提交
494 495 496
	return 0;

free_tports:
A
Alan Cox 已提交
497
	for (--i; i >= 0; --i) {
L
Linus Torvalds 已提交
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
		tport = usb_get_serial_port_data(serial->port[i]);
		ti_buf_free(tport->tp_write_buf);
		kfree(tport);
		usb_set_serial_port_data(serial->port[i], NULL);
	}
free_tdev:
	kfree(tdev);
	usb_set_serial_data(serial, NULL);
	return status;
}


static void ti_shutdown(struct usb_serial *serial)
{
	int i;
	struct ti_device *tdev = usb_get_serial_data(serial);
	struct ti_port *tport;

516
	dbg("%s", __func__);
L
Linus Torvalds 已提交
517

A
Alan Cox 已提交
518
	for (i = 0; i < serial->num_ports; ++i) {
L
Linus Torvalds 已提交
519 520 521 522 523 524 525 526
		tport = usb_get_serial_port_data(serial->port[i]);
		if (tport) {
			ti_buf_free(tport->tp_write_buf);
			kfree(tport);
			usb_set_serial_port_data(serial->port[i], NULL);
		}
	}

527
	kfree(tdev);
L
Linus Torvalds 已提交
528 529 530 531
	usb_set_serial_data(serial, NULL);
}


A
Alan Cox 已提交
532 533
static int ti_open(struct tty_struct *tty,
			struct usb_serial_port *port, struct file *file)
L
Linus Torvalds 已提交
534 535 536 537 538 539 540
{
	struct ti_port *tport = usb_get_serial_port_data(port);
	struct ti_device *tdev;
	struct usb_device *dev;
	struct urb *urb;
	int port_number;
	int status;
A
Alan Cox 已提交
541 542
	__u16 open_settings = (__u8)(TI_PIPE_MODE_CONTINOUS |
			     TI_PIPE_TIMEOUT_ENABLE |
L
Linus Torvalds 已提交
543 544
			     (TI_TRANSFER_TIMEOUT << 2));

545
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
546 547 548 549 550 551 552 553

	if (tport == NULL)
		return -ENODEV;

	dev = port->serial->dev;
	tdev = tport->tp_tdev;

	/* only one open on any port on a device at a time */
554
	if (mutex_lock_interruptible(&tdev->td_open_close_lock))
L
Linus Torvalds 已提交
555 556
		return -ERESTARTSYS;

A
Alan Cox 已提交
557 558 559
	if (tty)
		tty->low_latency =
				(tport->tp_flags & ASYNC_LOW_LATENCY) ? 1 : 0;
L
Linus Torvalds 已提交
560 561 562 563 564 565 566 567 568 569

	port_number = port->number - port->serial->minor;

	memset(&(tport->tp_icount), 0x00, sizeof(tport->tp_icount));

	tport->tp_msr = 0;
	tport->tp_shadow_mcr |= (TI_MCR_RTS | TI_MCR_DTR);

	/* start interrupt urb the first time a port is opened on this device */
	if (tdev->td_open_port_count == 0) {
570
		dbg("%s - start interrupt in urb", __func__);
L
Linus Torvalds 已提交
571 572
		urb = tdev->td_serial->port[0]->interrupt_in_urb;
		if (!urb) {
A
Alan Cox 已提交
573 574
			dev_err(&port->dev, "%s - no interrupt urb\n",
								__func__);
L
Linus Torvalds 已提交
575
			status = -EINVAL;
576
			goto release_lock;
L
Linus Torvalds 已提交
577 578 579 580 581 582
		}
		urb->complete = ti_interrupt_callback;
		urb->context = tdev;
		urb->dev = dev;
		status = usb_submit_urb(urb, GFP_KERNEL);
		if (status) {
A
Alan Cox 已提交
583 584 585
			dev_err(&port->dev,
				"%s - submit interrupt urb failed, %d\n",
					__func__, status);
586
			goto release_lock;
L
Linus Torvalds 已提交
587 588 589
		}
	}

A
Alan Cox 已提交
590 591
	if (tty)
		ti_set_termios(tty, port, tty->termios);
L
Linus Torvalds 已提交
592

593
	dbg("%s - sending TI_OPEN_PORT", __func__);
L
Linus Torvalds 已提交
594 595 596
	status = ti_command_out_sync(tdev, TI_OPEN_PORT,
		(__u8)(TI_UART1_PORT + port_number), open_settings, NULL, 0);
	if (status) {
A
Alan Cox 已提交
597 598
		dev_err(&port->dev, "%s - cannot send open command, %d\n",
							__func__, status);
L
Linus Torvalds 已提交
599 600 601
		goto unlink_int_urb;
	}

602
	dbg("%s - sending TI_START_PORT", __func__);
L
Linus Torvalds 已提交
603 604 605
	status = ti_command_out_sync(tdev, TI_START_PORT,
		(__u8)(TI_UART1_PORT + port_number), 0, NULL, 0);
	if (status) {
A
Alan Cox 已提交
606 607
		dev_err(&port->dev, "%s - cannot send start command, %d\n",
							__func__, status);
L
Linus Torvalds 已提交
608 609 610
		goto unlink_int_urb;
	}

611
	dbg("%s - sending TI_PURGE_PORT", __func__);
L
Linus Torvalds 已提交
612 613 614
	status = ti_command_out_sync(tdev, TI_PURGE_PORT,
		(__u8)(TI_UART1_PORT + port_number), TI_PURGE_INPUT, NULL, 0);
	if (status) {
A
Alan Cox 已提交
615 616
		dev_err(&port->dev, "%s - cannot clear input buffers, %d\n",
							__func__, status);
L
Linus Torvalds 已提交
617 618 619 620 621
		goto unlink_int_urb;
	}
	status = ti_command_out_sync(tdev, TI_PURGE_PORT,
		(__u8)(TI_UART1_PORT + port_number), TI_PURGE_OUTPUT, NULL, 0);
	if (status) {
A
Alan Cox 已提交
622 623
		dev_err(&port->dev, "%s - cannot clear output buffers, %d\n",
							__func__, status);
L
Linus Torvalds 已提交
624 625 626 627 628 629 630 631
		goto unlink_int_urb;
	}

	/* reset the data toggle on the bulk endpoints to work around bug in
	 * host controllers where things get out of sync some times */
	usb_clear_halt(dev, port->write_urb->pipe);
	usb_clear_halt(dev, port->read_urb->pipe);

A
Alan Cox 已提交
632 633
	if (tty)
		ti_set_termios(tty, port, tty->termios);
L
Linus Torvalds 已提交
634

635
	dbg("%s - sending TI_OPEN_PORT (2)", __func__);
L
Linus Torvalds 已提交
636 637 638
	status = ti_command_out_sync(tdev, TI_OPEN_PORT,
		(__u8)(TI_UART1_PORT + port_number), open_settings, NULL, 0);
	if (status) {
A
Alan Cox 已提交
639 640
		dev_err(&port->dev, "%s - cannot send open command (2), %d\n",
							__func__, status);
L
Linus Torvalds 已提交
641 642 643
		goto unlink_int_urb;
	}

644
	dbg("%s - sending TI_START_PORT (2)", __func__);
L
Linus Torvalds 已提交
645 646 647
	status = ti_command_out_sync(tdev, TI_START_PORT,
		(__u8)(TI_UART1_PORT + port_number), 0, NULL, 0);
	if (status) {
A
Alan Cox 已提交
648 649
		dev_err(&port->dev, "%s - cannot send start command (2), %d\n",
							__func__, status);
L
Linus Torvalds 已提交
650 651 652 653
		goto unlink_int_urb;
	}

	/* start read urb */
654
	dbg("%s - start read urb", __func__);
L
Linus Torvalds 已提交
655 656
	urb = port->read_urb;
	if (!urb) {
657
		dev_err(&port->dev, "%s - no read urb\n", __func__);
L
Linus Torvalds 已提交
658 659 660 661 662 663 664 665 666
		status = -EINVAL;
		goto unlink_int_urb;
	}
	tport->tp_read_urb_state = TI_READ_URB_RUNNING;
	urb->complete = ti_bulk_in_callback;
	urb->context = tport;
	urb->dev = dev;
	status = usb_submit_urb(urb, GFP_KERNEL);
	if (status) {
A
Alan Cox 已提交
667 668
		dev_err(&port->dev, "%s - submit read urb failed, %d\n",
							__func__, status);
L
Linus Torvalds 已提交
669 670 671 672 673 674
		goto unlink_int_urb;
	}

	tport->tp_is_open = 1;
	++tdev->td_open_port_count;

675
	goto release_lock;
L
Linus Torvalds 已提交
676 677 678 679

unlink_int_urb:
	if (tdev->td_open_port_count == 0)
		usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
680 681
release_lock:
	mutex_unlock(&tdev->td_open_close_lock);
682
	dbg("%s - exit %d", __func__, status);
L
Linus Torvalds 已提交
683 684 685 686
	return status;
}


A
Alan Cox 已提交
687 688
static void ti_close(struct tty_struct *tty, struct usb_serial_port *port,
							struct file *file)
L
Linus Torvalds 已提交
689 690 691 692 693
{
	struct ti_device *tdev;
	struct ti_port *tport;
	int port_number;
	int status;
694
	int do_unlock;
L
Linus Torvalds 已提交
695

696
	dbg("%s - port %d", __func__, port->number);
A
Alan Cox 已提交
697

L
Linus Torvalds 已提交
698 699 700 701 702 703 704 705 706 707 708 709 710 711 712
	tdev = usb_get_serial_data(port->serial);
	tport = usb_get_serial_port_data(port);
	if (tdev == NULL || tport == NULL)
		return;

	tport->tp_is_open = 0;

	ti_drain(tport, (tport->tp_closing_wait*HZ)/100, 1);

	usb_kill_urb(port->read_urb);
	usb_kill_urb(port->write_urb);
	tport->tp_write_urb_in_use = 0;

	port_number = port->number - port->serial->minor;

713
	dbg("%s - sending TI_CLOSE_PORT", __func__);
L
Linus Torvalds 已提交
714 715 716
	status = ti_command_out_sync(tdev, TI_CLOSE_PORT,
		     (__u8)(TI_UART1_PORT + port_number), 0, NULL, 0);
	if (status)
A
Alan Cox 已提交
717 718 719
		dev_err(&port->dev,
			"%s - cannot send close port command, %d\n"
							, __func__, status);
L
Linus Torvalds 已提交
720

721 722
	/* if mutex_lock is interrupted, continue anyway */
	do_unlock = !mutex_lock_interruptible(&tdev->td_open_close_lock);
L
Linus Torvalds 已提交
723 724 725 726 727 728
	--tport->tp_tdev->td_open_port_count;
	if (tport->tp_tdev->td_open_port_count <= 0) {
		/* last port is closed, shut down interrupt urb */
		usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
		tport->tp_tdev->td_open_port_count = 0;
	}
729 730
	if (do_unlock)
		mutex_unlock(&tdev->td_open_close_lock);
L
Linus Torvalds 已提交
731

732
	dbg("%s - exit", __func__);
L
Linus Torvalds 已提交
733 734 735
}


A
Alan Cox 已提交
736 737
static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
			const unsigned char *data, int count)
L
Linus Torvalds 已提交
738 739 740 741
{
	struct ti_port *tport = usb_get_serial_port_data(port);
	unsigned long flags;

742
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
743 744

	if (count == 0) {
745
		dbg("%s - write request of 0 bytes", __func__);
L
Linus Torvalds 已提交
746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
		return 0;
	}

	if (tport == NULL || !tport->tp_is_open)
		return -ENODEV;

	spin_lock_irqsave(&tport->tp_lock, flags);
	count = ti_buf_put(tport->tp_write_buf, data, count);
	spin_unlock_irqrestore(&tport->tp_lock, flags);

	ti_send(tport);

	return count;
}


A
Alan Cox 已提交
762
static int ti_write_room(struct tty_struct *tty)
L
Linus Torvalds 已提交
763
{
A
Alan Cox 已提交
764
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
765 766 767 768
	struct ti_port *tport = usb_get_serial_port_data(port);
	int room = 0;
	unsigned long flags;

769
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
770 771 772

	if (tport == NULL)
		return -ENODEV;
A
Alan Cox 已提交
773

L
Linus Torvalds 已提交
774 775 776 777
	spin_lock_irqsave(&tport->tp_lock, flags);
	room = ti_buf_space_avail(tport->tp_write_buf);
	spin_unlock_irqrestore(&tport->tp_lock, flags);

778
	dbg("%s - returns %d", __func__, room);
L
Linus Torvalds 已提交
779 780 781 782
	return room;
}


A
Alan Cox 已提交
783
static int ti_chars_in_buffer(struct tty_struct *tty)
L
Linus Torvalds 已提交
784
{
A
Alan Cox 已提交
785
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
786 787 788 789
	struct ti_port *tport = usb_get_serial_port_data(port);
	int chars = 0;
	unsigned long flags;

790
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
791 792 793 794 795 796 797 798

	if (tport == NULL)
		return -ENODEV;

	spin_lock_irqsave(&tport->tp_lock, flags);
	chars = ti_buf_data_avail(tport->tp_write_buf);
	spin_unlock_irqrestore(&tport->tp_lock, flags);

799
	dbg("%s - returns %d", __func__, chars);
L
Linus Torvalds 已提交
800 801 802 803
	return chars;
}


A
Alan Cox 已提交
804
static void ti_throttle(struct tty_struct *tty)
L
Linus Torvalds 已提交
805
{
A
Alan Cox 已提交
806
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
807 808
	struct ti_port *tport = usb_get_serial_port_data(port);

809
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
810 811 812 813 814 815 816 817 818 819

	if (tport == NULL)
		return;

	if (I_IXOFF(tty) || C_CRTSCTS(tty))
		ti_stop_read(tport, tty);

}


A
Alan Cox 已提交
820
static void ti_unthrottle(struct tty_struct *tty)
L
Linus Torvalds 已提交
821
{
A
Alan Cox 已提交
822
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
823 824 825
	struct ti_port *tport = usb_get_serial_port_data(port);
	int status;

826
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
827 828 829 830 831 832 833

	if (tport == NULL)
		return;

	if (I_IXOFF(tty) || C_CRTSCTS(tty)) {
		status = ti_restart_read(tport, tty);
		if (status)
A
Alan Cox 已提交
834 835
			dev_err(&port->dev, "%s - cannot restart read, %d\n",
							__func__, status);
L
Linus Torvalds 已提交
836 837 838 839
	}
}


A
Alan Cox 已提交
840
static int ti_ioctl(struct tty_struct *tty, struct file *file,
L
Linus Torvalds 已提交
841 842
	unsigned int cmd, unsigned long arg)
{
A
Alan Cox 已提交
843
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
844 845 846 847
	struct ti_port *tport = usb_get_serial_port_data(port);
	struct async_icount cnow;
	struct async_icount cprev;

848
	dbg("%s - port %d, cmd = 0x%04X", __func__, port->number, cmd);
L
Linus Torvalds 已提交
849 850 851 852 853

	if (tport == NULL)
		return -ENODEV;

	switch (cmd) {
A
Alan Cox 已提交
854 855 856 857 858 859
	case TIOCGSERIAL:
		dbg("%s - (%d) TIOCGSERIAL", __func__, port->number);
		return ti_get_serial_info(tport,
				(struct serial_struct __user *)arg);
	case TIOCSSERIAL:
		dbg("%s - (%d) TIOCSSERIAL", __func__, port->number);
A
Alan Cox 已提交
860 861
		return ti_set_serial_info(tty, tport,
				(struct serial_struct __user *)arg);
A
Alan Cox 已提交
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888
	case TIOCMIWAIT:
		dbg("%s - (%d) TIOCMIWAIT", __func__, port->number);
		cprev = tport->tp_icount;
		while (1) {
			interruptible_sleep_on(&tport->tp_msr_wait);
			if (signal_pending(current))
				return -ERESTARTSYS;
			cnow = tport->tp_icount;
			if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
			    cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
				return -EIO; /* no change => error */
			if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
			    ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
			    ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
			    ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)))
				return 0;
			cprev = cnow;
		}
		break;
	case TIOCGICOUNT:
		dbg("%s - (%d) TIOCGICOUNT RX=%d, TX=%d",
				__func__, port->number,
				tport->tp_icount.rx, tport->tp_icount.tx);
		if (copy_to_user((void __user *)arg, &tport->tp_icount,
					sizeof(tport->tp_icount)))
			return -EFAULT;
		return 0;
L
Linus Torvalds 已提交
889 890 891 892 893
	}
	return -ENOIOCTLCMD;
}


A
Alan Cox 已提交
894 895
static void ti_set_termios(struct tty_struct *tty,
		struct usb_serial_port *port, struct ktermios *old_termios)
L
Linus Torvalds 已提交
896 897 898
{
	struct ti_port *tport = usb_get_serial_port_data(port);
	struct ti_uart_config *config;
A
Alan Cox 已提交
899
	tcflag_t cflag, iflag;
L
Linus Torvalds 已提交
900 901 902 903 904
	int baud;
	int status;
	int port_number = port->number - port->serial->minor;
	unsigned int mcr;

905
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
906 907 908 909

	cflag = tty->termios->c_cflag;
	iflag = tty->termios->c_iflag;

910
	dbg("%s - cflag %08x, iflag %08x", __func__, cflag, iflag);
A
Alan Cox 已提交
911 912
	dbg("%s - old clfag %08x, old iflag %08x", __func__,
				old_termios->c_cflag, old_termios->c_iflag);
L
Linus Torvalds 已提交
913 914 915 916 917 918

	if (tport == NULL)
		return;

	config = kmalloc(sizeof(*config), GFP_KERNEL);
	if (!config) {
919
		dev_err(&port->dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
920 921 922 923 924 925 926 927 928 929 930
		return;
	}

	config->wFlags = 0;

	/* these flags must be set */
	config->wFlags |= TI_UART_ENABLE_MS_INTS;
	config->wFlags |= TI_UART_ENABLE_AUTO_START_DMA;
	config->bUartMode = (__u8)(tport->tp_uart_mode);

	switch (cflag & CSIZE) {
A
Alan Cox 已提交
931 932 933 934 935 936 937 938 939 940 941 942 943
	case CS5:
		    config->bDataBits = TI_UART_5_DATA_BITS;
		    break;
	case CS6:
		    config->bDataBits = TI_UART_6_DATA_BITS;
		    break;
	case CS7:
		    config->bDataBits = TI_UART_7_DATA_BITS;
		    break;
	default:
	case CS8:
		    config->bDataBits = TI_UART_8_DATA_BITS;
		    break;
L
Linus Torvalds 已提交
944 945
	}

A
Alan Cox 已提交
946 947 948
	/* CMSPAR isn't supported by this driver */
	tty->termios->c_cflag &= ~CMSPAR;

L
Linus Torvalds 已提交
949 950 951 952 953 954 955 956 957 958
	if (cflag & PARENB) {
		if (cflag & PARODD) {
			config->wFlags |= TI_UART_ENABLE_PARITY_CHECKING;
			config->bParity = TI_UART_ODD_PARITY;
		} else {
			config->wFlags |= TI_UART_ENABLE_PARITY_CHECKING;
			config->bParity = TI_UART_EVEN_PARITY;
		}
	} else {
		config->wFlags &= ~TI_UART_ENABLE_PARITY_CHECKING;
A
Alan Cox 已提交
959
		config->bParity = TI_UART_NO_PARITY;
L
Linus Torvalds 已提交
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990
	}

	if (cflag & CSTOPB)
		config->bStopBits = TI_UART_2_STOP_BITS;
	else
		config->bStopBits = TI_UART_1_STOP_BITS;

	if (cflag & CRTSCTS) {
		/* RTS flow control must be off to drop RTS for baud rate B0 */
		if ((cflag & CBAUD) != B0)
			config->wFlags |= TI_UART_ENABLE_RTS_IN;
		config->wFlags |= TI_UART_ENABLE_CTS_OUT;
	} else {
		tty->hw_stopped = 0;
		ti_restart_read(tport, tty);
	}

	if (I_IXOFF(tty) || I_IXON(tty)) {
		config->cXon  = START_CHAR(tty);
		config->cXoff = STOP_CHAR(tty);

		if (I_IXOFF(tty))
			config->wFlags |= TI_UART_ENABLE_X_IN;
		else
			ti_restart_read(tport, tty);

		if (I_IXON(tty))
			config->wFlags |= TI_UART_ENABLE_X_OUT;
	}

	baud = tty_get_baud_rate(tty);
A
Alan Cox 已提交
991 992
	if (!baud)
		baud = 9600;
L
Linus Torvalds 已提交
993 994 995 996 997
	if (tport->tp_tdev->td_is_3410)
		config->wBaudRate = (__u16)((923077 + baud/2) / baud);
	else
		config->wBaudRate = (__u16)((461538 + baud/2) / baud);

A
Alan Cox 已提交
998 999 1000 1001
	/* FIXME: Should calculate resulting baud here and report it back */
	if ((cflag & CBAUD) != B0)
		tty_encode_baud_rate(tty, baud, baud);

L
Linus Torvalds 已提交
1002
	dbg("%s - BaudRate=%d, wBaudRate=%d, wFlags=0x%04X, bDataBits=%d, bParity=%d, bStopBits=%d, cXon=%d, cXoff=%d, bUartMode=%d",
1003
	__func__, baud, config->wBaudRate, config->wFlags, config->bDataBits, config->bParity, config->bStopBits, config->cXon, config->cXoff, config->bUartMode);
L
Linus Torvalds 已提交
1004 1005 1006 1007 1008 1009 1010 1011

	cpu_to_be16s(&config->wBaudRate);
	cpu_to_be16s(&config->wFlags);

	status = ti_command_out_sync(tport->tp_tdev, TI_SET_CONFIG,
		(__u8)(TI_UART1_PORT + port_number), 0, (__u8 *)config,
		sizeof(*config));
	if (status)
A
Alan Cox 已提交
1012 1013
		dev_err(&port->dev, "%s - cannot set config on port %d, %d\n",
					__func__, port_number, status);
L
Linus Torvalds 已提交
1014 1015 1016 1017 1018 1019 1020 1021

	/* SET_CONFIG asserts RTS and DTR, reset them correctly */
	mcr = tport->tp_shadow_mcr;
	/* if baud rate is B0, clear RTS and DTR */
	if ((cflag & CBAUD) == B0)
		mcr &= ~(TI_MCR_DTR | TI_MCR_RTS);
	status = ti_set_mcr(tport, mcr);
	if (status)
A
Alan Cox 已提交
1022 1023 1024
		dev_err(&port->dev,
			"%s - cannot set modem control on port %d, %d\n",
						__func__, port_number, status);
L
Linus Torvalds 已提交
1025 1026 1027 1028 1029

	kfree(config);
}


A
Alan Cox 已提交
1030
static int ti_tiocmget(struct tty_struct *tty, struct file *file)
L
Linus Torvalds 已提交
1031
{
A
Alan Cox 已提交
1032
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
1033 1034 1035 1036
	struct ti_port *tport = usb_get_serial_port_data(port);
	unsigned int result;
	unsigned int msr;
	unsigned int mcr;
1037
	unsigned long flags;
L
Linus Torvalds 已提交
1038

1039
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
1040 1041 1042 1043

	if (tport == NULL)
		return -ENODEV;

1044
	spin_lock_irqsave(&tport->tp_lock, flags);
L
Linus Torvalds 已提交
1045 1046
	msr = tport->tp_msr;
	mcr = tport->tp_shadow_mcr;
1047
	spin_unlock_irqrestore(&tport->tp_lock, flags);
L
Linus Torvalds 已提交
1048 1049 1050 1051 1052 1053 1054 1055 1056

	result = ((mcr & TI_MCR_DTR) ? TIOCM_DTR : 0)
		| ((mcr & TI_MCR_RTS) ? TIOCM_RTS : 0)
		| ((mcr & TI_MCR_LOOP) ? TIOCM_LOOP : 0)
		| ((msr & TI_MSR_CTS) ? TIOCM_CTS : 0)
		| ((msr & TI_MSR_CD) ? TIOCM_CAR : 0)
		| ((msr & TI_MSR_RI) ? TIOCM_RI : 0)
		| ((msr & TI_MSR_DSR) ? TIOCM_DSR : 0);

1057
	dbg("%s - 0x%04X", __func__, result);
L
Linus Torvalds 已提交
1058 1059 1060 1061 1062

	return result;
}


A
Alan Cox 已提交
1063
static int ti_tiocmset(struct tty_struct *tty, struct file *file,
L
Linus Torvalds 已提交
1064 1065
	unsigned int set, unsigned int clear)
{
A
Alan Cox 已提交
1066
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
1067 1068
	struct ti_port *tport = usb_get_serial_port_data(port);
	unsigned int mcr;
1069
	unsigned long flags;
L
Linus Torvalds 已提交
1070

1071
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
1072 1073 1074 1075

	if (tport == NULL)
		return -ENODEV;

1076
	spin_lock_irqsave(&tport->tp_lock, flags);
L
Linus Torvalds 已提交
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
	mcr = tport->tp_shadow_mcr;

	if (set & TIOCM_RTS)
		mcr |= TI_MCR_RTS;
	if (set & TIOCM_DTR)
		mcr |= TI_MCR_DTR;
	if (set & TIOCM_LOOP)
		mcr |= TI_MCR_LOOP;

	if (clear & TIOCM_RTS)
		mcr &= ~TI_MCR_RTS;
	if (clear & TIOCM_DTR)
		mcr &= ~TI_MCR_DTR;
	if (clear & TIOCM_LOOP)
		mcr &= ~TI_MCR_LOOP;
1092
	spin_unlock_irqrestore(&tport->tp_lock, flags);
L
Linus Torvalds 已提交
1093 1094 1095 1096 1097

	return ti_set_mcr(tport, mcr);
}


A
Alan Cox 已提交
1098
static void ti_break(struct tty_struct *tty, int break_state)
L
Linus Torvalds 已提交
1099
{
A
Alan Cox 已提交
1100
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
1101 1102 1103
	struct ti_port *tport = usb_get_serial_port_data(port);
	int status;

1104
	dbg("%s - state = %d", __func__, break_state);
L
Linus Torvalds 已提交
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115

	if (tport == NULL)
		return;

	ti_drain(tport, (tport->tp_closing_wait*HZ)/100, 0);

	status = ti_write_byte(tport->tp_tdev,
		tport->tp_uart_base_addr + TI_UART_OFFSET_LCR,
		TI_LCR_BREAK, break_state == -1 ? TI_LCR_BREAK : 0);

	if (status)
1116
		dbg("%s - error setting break, %d", __func__, status);
L
Linus Torvalds 已提交
1117 1118 1119
}


1120
static void ti_interrupt_callback(struct urb *urb)
L
Linus Torvalds 已提交
1121
{
1122
	struct ti_device *tdev = urb->context;
L
Linus Torvalds 已提交
1123 1124 1125 1126 1127 1128 1129 1130
	struct usb_serial_port *port;
	struct usb_serial *serial = tdev->td_serial;
	struct ti_port *tport;
	struct device *dev = &urb->dev->dev;
	unsigned char *data = urb->transfer_buffer;
	int length = urb->actual_length;
	int port_number;
	int function;
1131 1132
	int status = urb->status;
	int retval;
L
Linus Torvalds 已提交
1133 1134
	__u8 msr;

1135
	dbg("%s", __func__);
L
Linus Torvalds 已提交
1136

1137
	switch (status) {
L
Linus Torvalds 已提交
1138 1139 1140 1141 1142
	case 0:
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
1143
		dbg("%s - urb shutting down, %d", __func__, status);
L
Linus Torvalds 已提交
1144 1145 1146
		tdev->td_urb_error = 1;
		return;
	default:
1147
		dev_err(dev, "%s - nonzero urb status, %d\n",
1148
			__func__, status);
L
Linus Torvalds 已提交
1149 1150 1151 1152 1153
		tdev->td_urb_error = 1;
		goto exit;
	}

	if (length != 2) {
1154
		dbg("%s - bad packet size, %d", __func__, length);
L
Linus Torvalds 已提交
1155 1156 1157 1158
		goto exit;
	}

	if (data[0] == TI_CODE_HARDWARE_ERROR) {
1159
		dev_err(dev, "%s - hardware error, %d\n", __func__, data[1]);
L
Linus Torvalds 已提交
1160 1161 1162 1163 1164 1165
		goto exit;
	}

	port_number = TI_GET_PORT_FROM_CODE(data[0]);
	function = TI_GET_FUNC_FROM_CODE(data[0]);

A
Alan Cox 已提交
1166 1167
	dbg("%s - port_number %d, function %d, data 0x%02X",
				__func__, port_number, function, data[1]);
L
Linus Torvalds 已提交
1168 1169

	if (port_number >= serial->num_ports) {
A
Alan Cox 已提交
1170 1171
		dev_err(dev, "%s - bad port number, %d\n",
						__func__, port_number);
L
Linus Torvalds 已提交
1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182
		goto exit;
	}

	port = serial->port[port_number];

	tport = usb_get_serial_port_data(port);
	if (!tport)
		goto exit;

	switch (function) {
	case TI_CODE_DATA_ERROR:
A
Alan Cox 已提交
1183 1184
		dev_err(dev, "%s - DATA ERROR, port %d, data 0x%02X\n",
					__func__, port_number, data[1]);
L
Linus Torvalds 已提交
1185 1186 1187 1188
		break;

	case TI_CODE_MODEM_STATUS:
		msr = data[1];
1189
		dbg("%s - port %d, msr 0x%02X", __func__, port_number, msr);
L
Linus Torvalds 已提交
1190 1191 1192 1193
		ti_handle_new_msr(tport, msr);
		break;

	default:
A
Alan Cox 已提交
1194 1195
		dev_err(dev, "%s - unknown interrupt code, 0x%02X\n",
							__func__, data[1]);
L
Linus Torvalds 已提交
1196 1197 1198 1199
		break;
	}

exit:
1200 1201 1202
	retval = usb_submit_urb(urb, GFP_ATOMIC);
	if (retval)
		dev_err(dev, "%s - resubmit interrupt urb failed, %d\n",
1203
			__func__, retval);
L
Linus Torvalds 已提交
1204 1205 1206
}


1207
static void ti_bulk_in_callback(struct urb *urb)
L
Linus Torvalds 已提交
1208
{
1209
	struct ti_port *tport = urb->context;
L
Linus Torvalds 已提交
1210 1211
	struct usb_serial_port *port = tport->tp_port;
	struct device *dev = &urb->dev->dev;
1212 1213
	int status = urb->status;
	int retval = 0;
A
Alan Cox 已提交
1214
	struct tty_struct *tty;
L
Linus Torvalds 已提交
1215

1216
	dbg("%s", __func__);
L
Linus Torvalds 已提交
1217

1218
	switch (status) {
L
Linus Torvalds 已提交
1219 1220 1221 1222 1223
	case 0:
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
1224
		dbg("%s - urb shutting down, %d", __func__, status);
L
Linus Torvalds 已提交
1225 1226 1227 1228
		tport->tp_tdev->td_urb_error = 1;
		wake_up_interruptible(&tport->tp_write_wait);
		return;
	default:
1229
		dev_err(dev, "%s - nonzero urb status, %d\n",
A
Alan Cox 已提交
1230
			__func__, status);
L
Linus Torvalds 已提交
1231 1232 1233 1234
		tport->tp_tdev->td_urb_error = 1;
		wake_up_interruptible(&tport->tp_write_wait);
	}

1235
	if (status == -EPIPE)
L
Linus Torvalds 已提交
1236 1237
		goto exit;

1238
	if (status) {
1239
		dev_err(dev, "%s - stopping read!\n", __func__);
L
Linus Torvalds 已提交
1240 1241 1242
		return;
	}

A
Alan Cox 已提交
1243 1244
	tty = tty_port_tty_get(&port->port);
	if (tty && urb->actual_length) {
1245
		usb_serial_debug_data(debug, dev, __func__,
L
Linus Torvalds 已提交
1246 1247 1248
			urb->actual_length, urb->transfer_buffer);

		if (!tport->tp_is_open)
1249
			dbg("%s - port closed, dropping data", __func__);
L
Linus Torvalds 已提交
1250
		else
A
Alan Cox 已提交
1251
			ti_recv(&urb->dev->dev, tty,
A
Alan Cox 已提交
1252 1253
						urb->transfer_buffer,
						urb->actual_length);
L
Linus Torvalds 已提交
1254 1255 1256 1257

		spin_lock(&tport->tp_lock);
		tport->tp_icount.rx += urb->actual_length;
		spin_unlock(&tport->tp_lock);
A
Alan Cox 已提交
1258
		tty_kref_put(tty);
L
Linus Torvalds 已提交
1259 1260 1261 1262 1263 1264 1265
	}

exit:
	/* continue to read unless stopping */
	spin_lock(&tport->tp_lock);
	if (tport->tp_read_urb_state == TI_READ_URB_RUNNING) {
		urb->dev = port->serial->dev;
1266
		retval = usb_submit_urb(urb, GFP_ATOMIC);
L
Linus Torvalds 已提交
1267 1268 1269 1270
	} else if (tport->tp_read_urb_state == TI_READ_URB_STOPPING) {
		tport->tp_read_urb_state = TI_READ_URB_STOPPED;
	}
	spin_unlock(&tport->tp_lock);
1271 1272
	if (retval)
		dev_err(dev, "%s - resubmit read urb failed, %d\n",
1273
			__func__, retval);
L
Linus Torvalds 已提交
1274 1275 1276
}


1277
static void ti_bulk_out_callback(struct urb *urb)
L
Linus Torvalds 已提交
1278
{
1279
	struct ti_port *tport = urb->context;
L
Linus Torvalds 已提交
1280 1281
	struct usb_serial_port *port = tport->tp_port;
	struct device *dev = &urb->dev->dev;
1282
	int status = urb->status;
L
Linus Torvalds 已提交
1283

1284
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
1285 1286 1287

	tport->tp_write_urb_in_use = 0;

1288
	switch (status) {
L
Linus Torvalds 已提交
1289 1290 1291 1292 1293
	case 0:
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
1294
		dbg("%s - urb shutting down, %d", __func__, status);
L
Linus Torvalds 已提交
1295 1296 1297 1298
		tport->tp_tdev->td_urb_error = 1;
		wake_up_interruptible(&tport->tp_write_wait);
		return;
	default:
1299
		dev_err(dev, "%s - nonzero urb status, %d\n",
1300
			__func__, status);
L
Linus Torvalds 已提交
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
		tport->tp_tdev->td_urb_error = 1;
		wake_up_interruptible(&tport->tp_write_wait);
	}

	/* send any buffered data */
	ti_send(tport);
}


static void ti_recv(struct device *dev, struct tty_struct *tty,
	unsigned char *data, int length)
{
	int cnt;

	do {
A
Alan Cox 已提交
1316 1317
		cnt = tty_buffer_request_room(tty, length);
		if (cnt < length) {
A
Alan Cox 已提交
1318 1319 1320
			dev_err(dev, "%s - dropping data, %d bytes lost\n",
						__func__, length - cnt);
			if (cnt == 0)
A
Alan Cox 已提交
1321
				break;
L
Linus Torvalds 已提交
1322
		}
A
Alan Cox 已提交
1323 1324
		tty_insert_flip_string(tty, data, cnt);
		tty_flip_buffer_push(tty);
L
Linus Torvalds 已提交
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335
		data += cnt;
		length -= cnt;
	} while (length > 0);

}


static void ti_send(struct ti_port *tport)
{
	int count, result;
	struct usb_serial_port *port = tport->tp_port;
A
Alan Cox 已提交
1336
	struct tty_struct *tty = tty_port_tty_get(&port->port);	/* FIXME */
L
Linus Torvalds 已提交
1337 1338 1339
	unsigned long flags;


1340
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
1341 1342 1343

	spin_lock_irqsave(&tport->tp_lock, flags);

A
Alan Cox 已提交
1344 1345
	if (tport->tp_write_urb_in_use)
		goto unlock;
L
Linus Torvalds 已提交
1346 1347 1348 1349 1350

	count = ti_buf_get(tport->tp_write_buf,
				port->write_urb->transfer_buffer,
				port->bulk_out_size);

A
Alan Cox 已提交
1351 1352
	if (count == 0)
		goto unlock;
L
Linus Torvalds 已提交
1353 1354 1355 1356 1357

	tport->tp_write_urb_in_use = 1;

	spin_unlock_irqrestore(&tport->tp_lock, flags);

A
Alan Cox 已提交
1358 1359
	usb_serial_debug_data(debug, &port->dev, __func__, count,
					port->write_urb->transfer_buffer);
L
Linus Torvalds 已提交
1360 1361 1362 1363 1364 1365 1366 1367 1368

	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
			   usb_sndbulkpipe(port->serial->dev,
					    port->bulk_out_endpointAddress),
			   port->write_urb->transfer_buffer, count,
			   ti_bulk_out_callback, tport);

	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
	if (result) {
A
Alan Cox 已提交
1369 1370 1371
		dev_err(&port->dev, "%s - submit write urb failed, %d\n",
							__func__, result);
		tport->tp_write_urb_in_use = 0;
L
Linus Torvalds 已提交
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
		/* TODO: reschedule ti_send */
	} else {
		spin_lock_irqsave(&tport->tp_lock, flags);
		tport->tp_icount.tx += count;
		spin_unlock_irqrestore(&tport->tp_lock, flags);
	}

	/* more room in the buffer for new writes, wakeup */
	if (tty)
		tty_wakeup(tty);
A
Alan Cox 已提交
1382
	tty_kref_put(tty);
L
Linus Torvalds 已提交
1383
	wake_up_interruptible(&tport->tp_write_wait);
A
Alan Cox 已提交
1384 1385 1386 1387 1388
	return;
unlock:
	spin_unlock_irqrestore(&tport->tp_lock, flags);
	tty_kref_put(tty);
	return;
L
Linus Torvalds 已提交
1389 1390 1391 1392 1393
}


static int ti_set_mcr(struct ti_port *tport, unsigned int mcr)
{
1394
	unsigned long flags;
L
Linus Torvalds 已提交
1395 1396 1397 1398 1399 1400
	int status;

	status = ti_write_byte(tport->tp_tdev,
		tport->tp_uart_base_addr + TI_UART_OFFSET_MCR,
		TI_MCR_RTS | TI_MCR_DTR | TI_MCR_LOOP, mcr);

1401
	spin_lock_irqsave(&tport->tp_lock, flags);
L
Linus Torvalds 已提交
1402 1403
	if (!status)
		tport->tp_shadow_mcr = mcr;
1404
	spin_unlock_irqrestore(&tport->tp_lock, flags);
L
Linus Torvalds 已提交
1405 1406 1407 1408 1409 1410 1411

	return status;
}


static int ti_get_lsr(struct ti_port *tport)
{
A
Alan Cox 已提交
1412
	int size, status;
L
Linus Torvalds 已提交
1413 1414 1415 1416 1417
	struct ti_device *tdev = tport->tp_tdev;
	struct usb_serial_port *port = tport->tp_port;
	int port_number = port->number - port->serial->minor;
	struct ti_port_status *data;

1418
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
1419 1420 1421 1422

	size = sizeof(struct ti_port_status);
	data = kmalloc(size, GFP_KERNEL);
	if (!data) {
1423
		dev_err(&port->dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
1424 1425 1426 1427 1428 1429
		return -ENOMEM;
	}

	status = ti_command_in_sync(tdev, TI_GET_PORT_STATUS,
		(__u8)(TI_UART1_PORT+port_number), 0, (__u8 *)data, size);
	if (status) {
A
Alan Cox 已提交
1430 1431 1432
		dev_err(&port->dev,
			"%s - get port status command failed, %d\n",
							__func__, status);
L
Linus Torvalds 已提交
1433 1434 1435
		goto free_data;
	}

1436
	dbg("%s - lsr 0x%02X", __func__, data->bLSR);
L
Linus Torvalds 已提交
1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471

	tport->tp_lsr = data->bLSR;

free_data:
	kfree(data);
	return status;
}


static int ti_get_serial_info(struct ti_port *tport,
	struct serial_struct __user *ret_arg)
{
	struct usb_serial_port *port = tport->tp_port;
	struct serial_struct ret_serial;

	if (!ret_arg)
		return -EFAULT;

	memset(&ret_serial, 0, sizeof(ret_serial));

	ret_serial.type = PORT_16550A;
	ret_serial.line = port->serial->minor;
	ret_serial.port = port->number - port->serial->minor;
	ret_serial.flags = tport->tp_flags;
	ret_serial.xmit_fifo_size = TI_WRITE_BUF_SIZE;
	ret_serial.baud_base = tport->tp_tdev->td_is_3410 ? 921600 : 460800;
	ret_serial.closing_wait = tport->tp_closing_wait;

	if (copy_to_user(ret_arg, &ret_serial, sizeof(*ret_arg)))
		return -EFAULT;

	return 0;
}


A
Alan Cox 已提交
1472
static int ti_set_serial_info(struct tty_struct *tty, struct ti_port *tport,
L
Linus Torvalds 已提交
1473 1474 1475 1476 1477 1478 1479 1480
	struct serial_struct __user *new_arg)
{
	struct serial_struct new_serial;

	if (copy_from_user(&new_serial, new_arg, sizeof(new_serial)))
		return -EFAULT;

	tport->tp_flags = new_serial.flags & TI_SET_SERIAL_FLAGS;
A
Alan Cox 已提交
1481
	tty->low_latency = (tport->tp_flags & ASYNC_LOW_LATENCY) ? 1 : 0;
L
Linus Torvalds 已提交
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493
	tport->tp_closing_wait = new_serial.closing_wait;

	return 0;
}


static void ti_handle_new_msr(struct ti_port *tport, __u8 msr)
{
	struct async_icount *icount;
	struct tty_struct *tty;
	unsigned long flags;

1494
	dbg("%s - msr 0x%02X", __func__, msr);
L
Linus Torvalds 已提交
1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513

	if (msr & TI_MSR_DELTA_MASK) {
		spin_lock_irqsave(&tport->tp_lock, flags);
		icount = &tport->tp_icount;
		if (msr & TI_MSR_DELTA_CTS)
			icount->cts++;
		if (msr & TI_MSR_DELTA_DSR)
			icount->dsr++;
		if (msr & TI_MSR_DELTA_CD)
			icount->dcd++;
		if (msr & TI_MSR_DELTA_RI)
			icount->rng++;
		wake_up_interruptible(&tport->tp_msr_wait);
		spin_unlock_irqrestore(&tport->tp_lock, flags);
	}

	tport->tp_msr = msr & TI_MSR_MASK;

	/* handle CTS flow control */
A
Alan Cox 已提交
1514
	tty = tty_port_tty_get(&tport->tp_port->port);
L
Linus Torvalds 已提交
1515 1516 1517 1518 1519 1520 1521 1522
	if (tty && C_CRTSCTS(tty)) {
		if (msr & TI_MSR_CTS) {
			tty->hw_stopped = 0;
			tty_wakeup(tty);
		} else {
			tty->hw_stopped = 1;
		}
	}
A
Alan Cox 已提交
1523
	tty_kref_put(tty);
L
Linus Torvalds 已提交
1524 1525 1526 1527 1528 1529 1530 1531 1532
}


static void ti_drain(struct ti_port *tport, unsigned long timeout, int flush)
{
	struct ti_device *tdev = tport->tp_tdev;
	struct usb_serial_port *port = tport->tp_port;
	wait_queue_t wait;

1533
	dbg("%s - port %d", __func__, port->number);
L
Linus Torvalds 已提交
1534

1535
	spin_lock_irq(&tport->tp_lock);
L
Linus Torvalds 已提交
1536 1537 1538 1539 1540 1541 1542 1543 1544 1545

	/* wait for data to drain from the buffer */
	tdev->td_urb_error = 0;
	init_waitqueue_entry(&wait, current);
	add_wait_queue(&tport->tp_write_wait, &wait);
	for (;;) {
		set_current_state(TASK_INTERRUPTIBLE);
		if (ti_buf_data_avail(tport->tp_write_buf) == 0
		|| timeout == 0 || signal_pending(current)
		|| tdev->td_urb_error
1546
		|| port->serial->disconnected)  /* disconnect */
L
Linus Torvalds 已提交
1547
			break;
1548
		spin_unlock_irq(&tport->tp_lock);
L
Linus Torvalds 已提交
1549
		timeout = schedule_timeout(timeout);
1550
		spin_lock_irq(&tport->tp_lock);
L
Linus Torvalds 已提交
1551 1552 1553 1554 1555 1556 1557 1558
	}
	set_current_state(TASK_RUNNING);
	remove_wait_queue(&tport->tp_write_wait, &wait);

	/* flush any remaining data in the buffer */
	if (flush)
		ti_buf_clear(tport->tp_write_buf);

1559
	spin_unlock_irq(&tport->tp_lock);
L
Linus Torvalds 已提交
1560

1561
	mutex_lock(&port->serial->disc_mutex);
L
Linus Torvalds 已提交
1562 1563 1564 1565 1566 1567
	/* wait for data to drain from the device */
	/* wait for empty tx register, plus 20 ms */
	timeout += jiffies;
	tport->tp_lsr &= ~TI_LSR_TX_EMPTY;
	while ((long)(jiffies - timeout) < 0 && !signal_pending(current)
	&& !(tport->tp_lsr&TI_LSR_TX_EMPTY) && !tdev->td_urb_error
1568
	&& !port->serial->disconnected) {
L
Linus Torvalds 已提交
1569 1570
		if (ti_get_lsr(tport))
			break;
1571
		mutex_unlock(&port->serial->disc_mutex);
L
Linus Torvalds 已提交
1572
		msleep_interruptible(20);
1573
		mutex_lock(&port->serial->disc_mutex);
L
Linus Torvalds 已提交
1574
	}
1575
	mutex_unlock(&port->serial->disc_mutex);
L
Linus Torvalds 已提交
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600
}


static void ti_stop_read(struct ti_port *tport, struct tty_struct *tty)
{
	unsigned long flags;

	spin_lock_irqsave(&tport->tp_lock, flags);

	if (tport->tp_read_urb_state == TI_READ_URB_RUNNING)
		tport->tp_read_urb_state = TI_READ_URB_STOPPING;

	spin_unlock_irqrestore(&tport->tp_lock, flags);
}


static int ti_restart_read(struct ti_port *tport, struct tty_struct *tty)
{
	struct urb *urb;
	int status = 0;
	unsigned long flags;

	spin_lock_irqsave(&tport->tp_lock, flags);

	if (tport->tp_read_urb_state == TI_READ_URB_STOPPED) {
1601
		tport->tp_read_urb_state = TI_READ_URB_RUNNING;
L
Linus Torvalds 已提交
1602
		urb = tport->tp_port->read_urb;
1603
		spin_unlock_irqrestore(&tport->tp_lock, flags);
L
Linus Torvalds 已提交
1604 1605 1606 1607
		urb->complete = ti_bulk_in_callback;
		urb->context = tport;
		urb->dev = tport->tp_port->serial->dev;
		status = usb_submit_urb(urb, GFP_KERNEL);
1608 1609 1610
	} else  {
		tport->tp_read_urb_state = TI_READ_URB_RUNNING;
		spin_unlock_irqrestore(&tport->tp_lock, flags);
L
Linus Torvalds 已提交
1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664
	}

	return status;
}


static int ti_command_out_sync(struct ti_device *tdev, __u8 command,
	__u16 moduleid, __u16 value, __u8 *data, int size)
{
	int status;

	status = usb_control_msg(tdev->td_serial->dev,
		usb_sndctrlpipe(tdev->td_serial->dev, 0), command,
		(USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT),
		value, moduleid, data, size, 1000);

	if (status == size)
		status = 0;

	if (status > 0)
		status = -ECOMM;

	return status;
}


static int ti_command_in_sync(struct ti_device *tdev, __u8 command,
	__u16 moduleid, __u16 value, __u8 *data, int size)
{
	int status;

	status = usb_control_msg(tdev->td_serial->dev,
		usb_rcvctrlpipe(tdev->td_serial->dev, 0), command,
		(USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN),
		value, moduleid, data, size, 1000);

	if (status == size)
		status = 0;

	if (status > 0)
		status = -ECOMM;

	return status;
}


static int ti_write_byte(struct ti_device *tdev, unsigned long addr,
	__u8 mask, __u8 byte)
{
	int status;
	unsigned int size;
	struct ti_write_data_bytes *data;
	struct device *dev = &tdev->td_serial->dev->dev;

A
Alan Cox 已提交
1665 1666
	dbg("%s - addr 0x%08lX, mask 0x%02X, byte 0x%02X",
					__func__, addr, mask, byte);
L
Linus Torvalds 已提交
1667 1668 1669 1670

	size = sizeof(struct ti_write_data_bytes) + 2;
	data = kmalloc(size, GFP_KERNEL);
	if (!data) {
1671
		dev_err(dev, "%s - out of memory\n", __func__);
L
Linus Torvalds 已提交
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686
		return -ENOMEM;
	}

	data->bAddrType = TI_RW_DATA_ADDR_XDATA;
	data->bDataType = TI_RW_DATA_BYTE;
	data->bDataCounter = 1;
	data->wBaseAddrHi = cpu_to_be16(addr>>16);
	data->wBaseAddrLo = cpu_to_be16(addr);
	data->bData[0] = mask;
	data->bData[1] = byte;

	status = ti_command_out_sync(tdev, TI_WRITE_DATA, TI_RAM_PORT, 0,
		(__u8 *)data, size);

	if (status < 0)
1687
		dev_err(dev, "%s - failed, %d\n", __func__, status);
L
Linus Torvalds 已提交
1688 1689 1690 1691 1692 1693

	kfree(data);

	return status;
}

A
Alan Cox 已提交
1694 1695
static int ti_do_download(struct usb_device *dev, int pipe,
						u8 *buffer, int size)
L
Linus Torvalds 已提交
1696 1697
{
	int pos;
A
Alan Cox 已提交
1698
	u8 cs = 0;
L
Linus Torvalds 已提交
1699 1700
	int done;
	struct ti_firmware_header *header;
A
Alan Cox 已提交
1701 1702
	int status;
	int len;
A
Alan Cox 已提交
1703 1704

	for (pos = sizeof(struct ti_firmware_header); pos < size; pos++)
L
Linus Torvalds 已提交
1705 1706 1707
		cs = (__u8)(cs + buffer[pos]);

	header = (struct ti_firmware_header *)buffer;
A
Alan Cox 已提交
1708
	header->wLength = cpu_to_le16((__u16)(size
A
Alan Cox 已提交
1709
					- sizeof(struct ti_firmware_header)));
L
Linus Torvalds 已提交
1710 1711
	header->bCheckSum = cs;

1712
	dbg("%s - downloading firmware", __func__);
A
Alan Cox 已提交
1713 1714 1715 1716
	for (pos = 0; pos < size; pos += done) {
		len = min(size - pos, TI_DOWNLOAD_MAX_PACKET_SIZE);
		status = usb_bulk_msg(dev, pipe, buffer + pos, len,
								&done, 1000);
L
Linus Torvalds 已提交
1717 1718 1719
		if (status)
			break;
	}
A
Alan Cox 已提交
1720 1721
	return status;
}
L
Linus Torvalds 已提交
1722

A
Alan Cox 已提交
1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733
static int ti_download_firmware(struct ti_device *tdev, int type)
{
	int status = -ENOMEM;
	int buffer_size;
	__u8 *buffer;
	struct usb_device *dev = tdev->td_serial->dev;
	unsigned int pipe = usb_sndbulkpipe(dev,
		tdev->td_serial->port[0]->bulk_out_endpointAddress);
	const struct firmware *fw_p;
	char buf[32];
	sprintf(buf, "ti_usb-%d.bin", type);
L
Linus Torvalds 已提交
1734

A
Alan Cox 已提交
1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748
	if (request_firmware(&fw_p, buf, &dev->dev)) {
		dev_err(&dev->dev, "%s - firmware not found\n", __func__);
		return -ENOENT;
	}
	if (fw_p->size > TI_FIRMWARE_BUF_SIZE) {
		dev_err(&dev->dev, "%s - firmware too large\n", __func__);
		return -ENOENT;
	}

	buffer_size = TI_FIRMWARE_BUF_SIZE + sizeof(struct ti_firmware_header);
	buffer = kmalloc(buffer_size, GFP_KERNEL);
	if (buffer) {
		memcpy(buffer, fw_p->data, fw_p->size);
		memset(buffer + fw_p->size, 0xff, buffer_size - fw_p->size);
1749
		status = ti_do_download(dev, pipe, buffer, fw_p->size);
A
Alan Cox 已提交
1750 1751 1752
		kfree(buffer);
	}
	release_firmware(fw_p);
L
Linus Torvalds 已提交
1753
	if (status) {
A
Alan Cox 已提交
1754 1755
		dev_err(&dev->dev, "%s - error downloading firmware, %d\n",
							__func__, status);
L
Linus Torvalds 已提交
1756 1757 1758
		return status;
	}

1759
	dbg("%s - download successful", __func__);
L
Linus Torvalds 已提交
1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776

	return 0;
}


/* Circular Buffer Functions */

/*
 * ti_buf_alloc
 *
 * Allocate a circular buffer and all associated memory.
 */

static struct circ_buf *ti_buf_alloc(void)
{
	struct circ_buf *cb;

1777
	cb = kmalloc(sizeof(struct circ_buf), GFP_KERNEL);
L
Linus Torvalds 已提交
1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
	if (cb == NULL)
		return NULL;

	cb->buf = kmalloc(TI_WRITE_BUF_SIZE, GFP_KERNEL);
	if (cb->buf == NULL) {
		kfree(cb);
		return NULL;
	}

	ti_buf_clear(cb);

	return cb;
}


/*
 * ti_buf_free
 *
 * Free the buffer and all associated memory.
 */

static void ti_buf_free(struct circ_buf *cb)
{
	kfree(cb->buf);
	kfree(cb);
}


/*
 * ti_buf_clear
 *
 * Clear out all data in the circular buffer.
 */

static void ti_buf_clear(struct circ_buf *cb)
{
	cb->head = cb->tail = 0;
}


/*
 * ti_buf_data_avail
 *
 * Return the number of bytes of data available in the circular
 * buffer.
 */

static int ti_buf_data_avail(struct circ_buf *cb)
{
A
Alan Cox 已提交
1827
	return CIRC_CNT(cb->head, cb->tail, TI_WRITE_BUF_SIZE);
L
Linus Torvalds 已提交
1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839
}


/*
 * ti_buf_space_avail
 *
 * Return the number of bytes of space available in the circular
 * buffer.
 */

static int ti_buf_space_avail(struct circ_buf *cb)
{
A
Alan Cox 已提交
1840
	return CIRC_SPACE(cb->head, cb->tail, TI_WRITE_BUF_SIZE);
L
Linus Torvalds 已提交
1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901
}


/*
 * ti_buf_put
 *
 * Copy data data from a user buffer and put it into the circular buffer.
 * Restrict to the amount of space available.
 *
 * Return the number of bytes copied.
 */

static int ti_buf_put(struct circ_buf *cb, const char *buf, int count)
{
	int c, ret = 0;

	while (1) {
		c = CIRC_SPACE_TO_END(cb->head, cb->tail, TI_WRITE_BUF_SIZE);
		if (count < c)
			c = count;
		if (c <= 0)
			break;
		memcpy(cb->buf + cb->head, buf, c);
		cb->head = (cb->head + c) & (TI_WRITE_BUF_SIZE-1);
		buf += c;
		count -= c;
		ret += c;
	}

	return ret;
}


/*
 * ti_buf_get
 *
 * Get data from the circular buffer and copy to the given buffer.
 * Restrict to the amount of data available.
 *
 * Return the number of bytes copied.
 */

static int ti_buf_get(struct circ_buf *cb, char *buf, int count)
{
	int c, ret = 0;

	while (1) {
		c = CIRC_CNT_TO_END(cb->head, cb->tail, TI_WRITE_BUF_SIZE);
		if (count < c)
			c = count;
		if (c <= 0)
			break;
		memcpy(buf, cb->buf + cb->tail, c);
		cb->tail = (cb->tail + c) & (TI_WRITE_BUF_SIZE-1);
		buf += c;
		count -= c;
		ret += c;
	}

	return ret;
}