2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* USB ConnectTech WhiteHEAT driver
|
|
|
|
*
|
|
|
|
* Copyright (C) 2002
|
|
|
|
* Connect Tech Inc.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1999 - 2001
|
|
|
|
* Greg Kroah-Hartman (greg@kroah.com)
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
2008-07-22 17:09:16 +07:00
|
|
|
* See Documentation/usb/usb-serial.txt for more information on using this
|
|
|
|
* driver
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#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>
|
2007-05-24 18:52:51 +07:00
|
|
|
#include <linux/mutex.h>
|
2008-07-22 17:09:16 +07:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/termbits.h>
|
|
|
|
#include <linux/usb.h>
|
|
|
|
#include <linux/serial_reg.h>
|
|
|
|
#include <linux/serial.h>
|
2006-07-12 11:22:58 +07:00
|
|
|
#include <linux/usb/serial.h>
|
2012-09-18 14:00:41 +07:00
|
|
|
#include <linux/usb/ezusb.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include "whiteheat.h" /* WhiteHEAT specific commands */
|
|
|
|
|
|
|
|
#ifndef CMSPAR
|
|
|
|
#define CMSPAR 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Version Information
|
|
|
|
*/
|
|
|
|
#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Stuart MacDonald <stuartm@connecttech.com>"
|
|
|
|
#define DRIVER_DESC "USB ConnectTech WhiteHEAT driver"
|
|
|
|
|
|
|
|
#define CONNECT_TECH_VENDOR_ID 0x0710
|
|
|
|
#define CONNECT_TECH_FAKE_WHITE_HEAT_ID 0x0001
|
|
|
|
#define CONNECT_TECH_WHITE_HEAT_ID 0x8001
|
|
|
|
|
|
|
|
/*
|
|
|
|
ID tables for whiteheat are unusual, because we want to different
|
|
|
|
things for different versions of the device. Eventually, this
|
|
|
|
will be doable from a single table. But, for now, we define two
|
|
|
|
separate ID tables, and then a third table that combines them
|
|
|
|
just for the purpose of exporting the autoloading information.
|
|
|
|
*/
|
2010-01-10 21:34:24 +07:00
|
|
|
static const struct usb_device_id id_table_std[] = {
|
2005-04-17 05:20:36 +07:00
|
|
|
{ USB_DEVICE(CONNECT_TECH_VENDOR_ID, CONNECT_TECH_WHITE_HEAT_ID) },
|
|
|
|
{ } /* Terminating entry */
|
|
|
|
};
|
|
|
|
|
2010-01-10 21:34:24 +07:00
|
|
|
static const struct usb_device_id id_table_prerenumeration[] = {
|
2005-04-17 05:20:36 +07:00
|
|
|
{ USB_DEVICE(CONNECT_TECH_VENDOR_ID, CONNECT_TECH_FAKE_WHITE_HEAT_ID) },
|
|
|
|
{ } /* Terminating entry */
|
|
|
|
};
|
|
|
|
|
2010-01-10 21:34:24 +07:00
|
|
|
static const struct usb_device_id id_table_combined[] = {
|
2005-04-17 05:20:36 +07:00
|
|
|
{ USB_DEVICE(CONNECT_TECH_VENDOR_ID, CONNECT_TECH_WHITE_HEAT_ID) },
|
|
|
|
{ USB_DEVICE(CONNECT_TECH_VENDOR_ID, CONNECT_TECH_FAKE_WHITE_HEAT_ID) },
|
|
|
|
{ } /* Terminating entry */
|
|
|
|
};
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
MODULE_DEVICE_TABLE(usb, id_table_combined);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
/* function prototypes for the Connect Tech WhiteHEAT prerenumeration device */
|
2008-07-22 17:09:16 +07:00
|
|
|
static int whiteheat_firmware_download(struct usb_serial *serial,
|
|
|
|
const struct usb_device_id *id);
|
|
|
|
static int whiteheat_firmware_attach(struct usb_serial *serial);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* function prototypes for the Connect Tech WhiteHEAT serial converter */
|
2008-07-22 17:09:16 +07:00
|
|
|
static int whiteheat_attach(struct usb_serial *serial);
|
2009-06-02 22:53:55 +07:00
|
|
|
static void whiteheat_release(struct usb_serial *serial);
|
2008-07-22 17:09:16 +07:00
|
|
|
static int whiteheat_open(struct tty_struct *tty,
|
2009-09-20 03:13:26 +07:00
|
|
|
struct usb_serial_port *port);
|
2009-06-11 18:26:29 +07:00
|
|
|
static void whiteheat_close(struct usb_serial_port *port);
|
2011-02-14 23:27:06 +07:00
|
|
|
static int whiteheat_ioctl(struct tty_struct *tty,
|
2008-07-22 17:09:16 +07:00
|
|
|
unsigned int cmd, unsigned long arg);
|
|
|
|
static void whiteheat_set_termios(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port, struct ktermios *old);
|
2011-02-14 23:26:14 +07:00
|
|
|
static int whiteheat_tiocmget(struct tty_struct *tty);
|
2011-02-14 23:26:50 +07:00
|
|
|
static int whiteheat_tiocmset(struct tty_struct *tty,
|
2008-07-22 17:09:16 +07:00
|
|
|
unsigned int set, unsigned int clear);
|
|
|
|
static void whiteheat_break_ctl(struct tty_struct *tty, int break_state);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-06-21 11:15:16 +07:00
|
|
|
static struct usb_serial_driver whiteheat_fake_device = {
|
2005-06-21 11:15:16 +07:00
|
|
|
.driver = {
|
|
|
|
.owner = THIS_MODULE,
|
2005-06-21 11:15:16 +07:00
|
|
|
.name = "whiteheatnofirm",
|
2005-06-21 11:15:16 +07:00
|
|
|
},
|
2005-06-21 11:15:16 +07:00
|
|
|
.description = "Connect Tech - WhiteHEAT - (prerenumeration)",
|
2005-04-17 05:20:36 +07:00
|
|
|
.id_table = id_table_prerenumeration,
|
|
|
|
.num_ports = 1,
|
|
|
|
.probe = whiteheat_firmware_download,
|
|
|
|
.attach = whiteheat_firmware_attach,
|
|
|
|
};
|
|
|
|
|
2005-06-21 11:15:16 +07:00
|
|
|
static struct usb_serial_driver whiteheat_device = {
|
2005-06-21 11:15:16 +07:00
|
|
|
.driver = {
|
|
|
|
.owner = THIS_MODULE,
|
2005-06-21 11:15:16 +07:00
|
|
|
.name = "whiteheat",
|
2005-06-21 11:15:16 +07:00
|
|
|
},
|
2005-06-21 11:15:16 +07:00
|
|
|
.description = "Connect Tech - WhiteHEAT",
|
2005-04-17 05:20:36 +07:00
|
|
|
.id_table = id_table_std,
|
|
|
|
.num_ports = 4,
|
|
|
|
.attach = whiteheat_attach,
|
2009-06-02 22:53:55 +07:00
|
|
|
.release = whiteheat_release,
|
2005-04-17 05:20:36 +07:00
|
|
|
.open = whiteheat_open,
|
|
|
|
.close = whiteheat_close,
|
|
|
|
.ioctl = whiteheat_ioctl,
|
|
|
|
.set_termios = whiteheat_set_termios,
|
|
|
|
.break_ctl = whiteheat_break_ctl,
|
|
|
|
.tiocmget = whiteheat_tiocmget,
|
|
|
|
.tiocmset = whiteheat_tiocmset,
|
2012-03-22 22:50:55 +07:00
|
|
|
.throttle = usb_serial_generic_throttle,
|
|
|
|
.unthrottle = usb_serial_generic_unthrottle,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2012-02-24 02:57:32 +07:00
|
|
|
static struct usb_serial_driver * const serial_drivers[] = {
|
|
|
|
&whiteheat_fake_device, &whiteheat_device, NULL
|
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
struct whiteheat_command_private {
|
2007-05-24 18:52:51 +07:00
|
|
|
struct mutex mutex;
|
2005-04-17 05:20:36 +07:00
|
|
|
__u8 port_running;
|
|
|
|
__u8 command_finished;
|
2008-07-22 17:09:16 +07:00
|
|
|
wait_queue_head_t wait_command; /* for handling sleeping whilst
|
|
|
|
waiting for a command to
|
|
|
|
finish */
|
2005-04-17 05:20:36 +07:00
|
|
|
__u8 result_buffer[64];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct whiteheat_private {
|
2008-04-08 23:16:06 +07:00
|
|
|
__u8 mcr; /* FIXME: no locking on mcr */
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* local function prototypes */
|
|
|
|
static int start_command_port(struct usb_serial *serial);
|
|
|
|
static void stop_command_port(struct usb_serial *serial);
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 20:55:46 +07:00
|
|
|
static void command_port_write_callback(struct urb *urb);
|
|
|
|
static void command_port_read_callback(struct urb *urb);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
static int firm_send_command(struct usb_serial_port *port, __u8 command,
|
|
|
|
__u8 *data, __u8 datasize);
|
2005-04-17 05:20:36 +07:00
|
|
|
static int firm_open(struct usb_serial_port *port);
|
|
|
|
static int firm_close(struct usb_serial_port *port);
|
2009-09-20 03:13:33 +07:00
|
|
|
static void firm_setup_port(struct tty_struct *tty);
|
2005-04-17 05:20:36 +07:00
|
|
|
static int firm_set_rts(struct usb_serial_port *port, __u8 onoff);
|
|
|
|
static int firm_set_dtr(struct usb_serial_port *port, __u8 onoff);
|
|
|
|
static int firm_set_break(struct usb_serial_port *port, __u8 onoff);
|
|
|
|
static int firm_purge(struct usb_serial_port *port, __u8 rxtx);
|
|
|
|
static int firm_get_dtr_rts(struct usb_serial_port *port);
|
|
|
|
static int firm_report_tx_done(struct usb_serial_port *port);
|
|
|
|
|
|
|
|
|
|
|
|
#define COMMAND_PORT 4
|
|
|
|
#define COMMAND_TIMEOUT (2*HZ) /* 2 second timeout for a command */
|
|
|
|
#define COMMAND_TIMEOUT_MS 2000
|
|
|
|
#define CLOSING_DELAY (30 * HZ)
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* Connect Tech's White Heat prerenumeration driver functions
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
/* steps to download the firmware to the WhiteHEAT device:
|
|
|
|
- hold the reset (by writing to the reset bit of the CPUCS register)
|
|
|
|
- download the VEND_AX.HEX file to the chip using VENDOR_REQUEST-ANCHOR_LOAD
|
|
|
|
- release the reset (by writing to the CPUCS register)
|
|
|
|
- download the WH.HEX file for all addresses greater than 0x1b3f using
|
|
|
|
VENDOR_REQUEST-ANCHOR_EXTERNAL_RAM_LOAD
|
|
|
|
- hold the reset
|
|
|
|
- download the WH.HEX file for all addresses less than 0x1b40 using
|
|
|
|
VENDOR_REQUEST_ANCHOR_LOAD
|
|
|
|
- release the reset
|
|
|
|
- device renumerated itself and comes up as new device id with all
|
|
|
|
firmware download completed.
|
|
|
|
*/
|
2008-07-22 17:09:16 +07:00
|
|
|
static int whiteheat_firmware_download(struct usb_serial *serial,
|
|
|
|
const struct usb_device_id *id)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2012-09-18 14:02:01 +07:00
|
|
|
int response;
|
2008-05-31 05:35:29 +07:00
|
|
|
|
2012-09-18 14:02:01 +07:00
|
|
|
response = ezusb_fx1_ihex_firmware_download(serial->dev, "whiteheat_loader.fw");
|
|
|
|
if (response >= 0) {
|
|
|
|
response = ezusb_fx1_ihex_firmware_download(serial->dev, "whiteheat.fw");
|
|
|
|
if (response >= 0)
|
|
|
|
return 0;
|
2008-05-31 05:35:29 +07:00
|
|
|
}
|
2012-09-18 14:02:01 +07:00
|
|
|
return -ENOENT;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
static int whiteheat_firmware_attach(struct usb_serial *serial)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
/* We want this device to fail to have a driver assigned to it */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* Connect Tech's White Heat serial driver functions
|
|
|
|
*****************************************************************************/
|
2008-07-22 17:09:16 +07:00
|
|
|
static int whiteheat_attach(struct usb_serial *serial)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct usb_serial_port *command_port;
|
|
|
|
struct whiteheat_command_private *command_info;
|
|
|
|
struct usb_serial_port *port;
|
|
|
|
struct whiteheat_private *info;
|
|
|
|
struct whiteheat_hw_info *hw_info;
|
|
|
|
int pipe;
|
|
|
|
int ret;
|
|
|
|
int alen;
|
|
|
|
__u8 *command;
|
|
|
|
__u8 *result;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
command_port = serial->port[COMMAND_PORT];
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
pipe = usb_sndbulkpipe(serial->dev,
|
|
|
|
command_port->bulk_out_endpointAddress);
|
2005-04-17 05:20:36 +07:00
|
|
|
command = kmalloc(2, GFP_KERNEL);
|
|
|
|
if (!command)
|
|
|
|
goto no_command_buffer;
|
|
|
|
command[0] = WHITEHEAT_GET_HW_INFO;
|
|
|
|
command[1] = 0;
|
2008-07-22 17:09:16 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
result = kmalloc(sizeof(*hw_info) + 1, GFP_KERNEL);
|
|
|
|
if (!result)
|
|
|
|
goto no_result_buffer;
|
|
|
|
/*
|
|
|
|
* When the module is reloaded the firmware is still there and
|
|
|
|
* the endpoints are still in the usb core unchanged. This is the
|
2008-07-22 17:09:16 +07:00
|
|
|
* unlinking bug in disguise. Same for the call below.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
usb_clear_halt(serial->dev, pipe);
|
2008-07-22 17:09:16 +07:00
|
|
|
ret = usb_bulk_msg(serial->dev, pipe, command, 2,
|
|
|
|
&alen, COMMAND_TIMEOUT_MS);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ret) {
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&serial->dev->dev, "%s: Couldn't send command [%d]\n",
|
|
|
|
serial->type->description, ret);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto no_firmware;
|
2006-06-01 00:28:40 +07:00
|
|
|
} else if (alen != 2) {
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&serial->dev->dev, "%s: Send command incomplete [%d]\n",
|
|
|
|
serial->type->description, alen);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto no_firmware;
|
|
|
|
}
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
pipe = usb_rcvbulkpipe(serial->dev,
|
|
|
|
command_port->bulk_in_endpointAddress);
|
2005-04-17 05:20:36 +07:00
|
|
|
/* See the comment on the usb_clear_halt() above */
|
|
|
|
usb_clear_halt(serial->dev, pipe);
|
2008-07-22 17:09:16 +07:00
|
|
|
ret = usb_bulk_msg(serial->dev, pipe, result,
|
|
|
|
sizeof(*hw_info) + 1, &alen, COMMAND_TIMEOUT_MS);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ret) {
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&serial->dev->dev, "%s: Couldn't get results [%d]\n",
|
|
|
|
serial->type->description, ret);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto no_firmware;
|
2006-06-01 00:28:40 +07:00
|
|
|
} else if (alen != sizeof(*hw_info) + 1) {
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&serial->dev->dev, "%s: Get results incomplete [%d]\n",
|
|
|
|
serial->type->description, alen);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto no_firmware;
|
|
|
|
} else if (result[0] != command[0]) {
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&serial->dev->dev, "%s: Command failed [%d]\n",
|
|
|
|
serial->type->description, result[0]);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto no_firmware;
|
|
|
|
}
|
|
|
|
|
|
|
|
hw_info = (struct whiteheat_hw_info *)&result[1];
|
|
|
|
|
2012-03-22 22:50:54 +07:00
|
|
|
dev_info(&serial->dev->dev, "%s: Firmware v%d.%02d\n",
|
|
|
|
serial->type->description,
|
2008-08-19 03:21:04 +07:00
|
|
|
hw_info->sw_major_rev, hw_info->sw_minor_rev);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
for (i = 0; i < serial->num_ports; i++) {
|
|
|
|
port = serial->port[i];
|
|
|
|
|
2006-12-13 15:35:56 +07:00
|
|
|
info = kmalloc(sizeof(struct whiteheat_private), GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (info == NULL) {
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&port->dev,
|
|
|
|
"%s: Out of memory for port structures\n",
|
|
|
|
serial->type->description);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto no_private;
|
|
|
|
}
|
|
|
|
|
|
|
|
info->mcr = 0;
|
|
|
|
|
|
|
|
usb_set_serial_port_data(port, info);
|
|
|
|
}
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
command_info = kmalloc(sizeof(struct whiteheat_command_private),
|
|
|
|
GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (command_info == NULL) {
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&serial->dev->dev,
|
|
|
|
"%s: Out of memory for port structures\n",
|
|
|
|
serial->type->description);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto no_command_private;
|
|
|
|
}
|
|
|
|
|
2007-05-24 18:52:51 +07:00
|
|
|
mutex_init(&command_info->mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
command_info->port_running = 0;
|
|
|
|
init_waitqueue_head(&command_info->wait_command);
|
|
|
|
usb_set_serial_port_data(command_port, command_info);
|
|
|
|
command_port->write_urb->complete = command_port_write_callback;
|
|
|
|
command_port->read_urb->complete = command_port_read_callback;
|
|
|
|
kfree(result);
|
|
|
|
kfree(command);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
no_firmware:
|
|
|
|
/* Firmware likely not running */
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&serial->dev->dev,
|
|
|
|
"%s: Unable to retrieve firmware version, try replugging\n",
|
|
|
|
serial->type->description);
|
|
|
|
dev_err(&serial->dev->dev,
|
|
|
|
"%s: If the firmware is not running (status led not blinking)\n",
|
|
|
|
serial->type->description);
|
|
|
|
dev_err(&serial->dev->dev,
|
|
|
|
"%s: please contact support@connecttech.com\n",
|
|
|
|
serial->type->description);
|
2006-04-24 00:59:23 +07:00
|
|
|
kfree(result);
|
2012-10-25 15:29:01 +07:00
|
|
|
kfree(command);
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
no_command_private:
|
|
|
|
for (i = serial->num_ports - 1; i >= 0; i--) {
|
|
|
|
port = serial->port[i];
|
|
|
|
info = usb_get_serial_port_data(port);
|
|
|
|
kfree(info);
|
|
|
|
no_private:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
kfree(result);
|
|
|
|
no_result_buffer:
|
|
|
|
kfree(command);
|
|
|
|
no_command_buffer:
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-06-02 22:53:55 +07:00
|
|
|
static void whiteheat_release(struct usb_serial *serial)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct usb_serial_port *command_port;
|
|
|
|
struct whiteheat_private *info;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* free up our private data for our command port */
|
|
|
|
command_port = serial->port[COMMAND_PORT];
|
2008-07-22 17:09:16 +07:00
|
|
|
kfree(usb_get_serial_port_data(command_port));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
for (i = 0; i < serial->num_ports; i++) {
|
2012-03-22 22:50:55 +07:00
|
|
|
info = usb_get_serial_port_data(serial->port[i]);
|
2005-04-17 05:20:36 +07:00
|
|
|
kfree(info);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-20 03:13:26 +07:00
|
|
|
static int whiteheat_open(struct tty_struct *tty, struct usb_serial_port *port)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2012-03-22 22:50:55 +07:00
|
|
|
int retval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
retval = start_command_port(port->serial);
|
|
|
|
if (retval)
|
|
|
|
goto exit;
|
|
|
|
|
|
|
|
/* send an open port command */
|
|
|
|
retval = firm_open(port);
|
|
|
|
if (retval) {
|
|
|
|
stop_command_port(port->serial);
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
retval = firm_purge(port, WHITEHEAT_PURGE_RX | WHITEHEAT_PURGE_TX);
|
|
|
|
if (retval) {
|
|
|
|
firm_close(port);
|
|
|
|
stop_command_port(port->serial);
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2008-07-22 17:09:29 +07:00
|
|
|
if (tty)
|
|
|
|
firm_setup_port(tty);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Work around HCD bugs */
|
|
|
|
usb_clear_halt(port->serial->dev, port->read_urb->pipe);
|
|
|
|
usb_clear_halt(port->serial->dev, port->write_urb->pipe);
|
|
|
|
|
2012-03-22 22:50:55 +07:00
|
|
|
retval = usb_serial_generic_open(tty, port);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (retval) {
|
|
|
|
firm_close(port);
|
|
|
|
stop_command_port(port->serial);
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
exit:
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-06-11 18:26:29 +07:00
|
|
|
static void whiteheat_close(struct usb_serial_port *port)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
firm_report_tx_done(port);
|
|
|
|
firm_close(port);
|
|
|
|
|
2012-03-22 22:50:55 +07:00
|
|
|
usb_serial_generic_close(port);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-03-22 22:50:55 +07:00
|
|
|
stop_command_port(port->serial);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2011-02-14 23:26:14 +07:00
|
|
|
static int whiteheat_tiocmget(struct tty_struct *tty)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct whiteheat_private *info = usb_get_serial_port_data(port);
|
|
|
|
unsigned int modem_signals = 0;
|
|
|
|
|
|
|
|
firm_get_dtr_rts(port);
|
|
|
|
if (info->mcr & UART_MCR_DTR)
|
|
|
|
modem_signals |= TIOCM_DTR;
|
|
|
|
if (info->mcr & UART_MCR_RTS)
|
|
|
|
modem_signals |= TIOCM_RTS;
|
|
|
|
|
|
|
|
return modem_signals;
|
|
|
|
}
|
|
|
|
|
2011-02-14 23:26:50 +07:00
|
|
|
static int whiteheat_tiocmset(struct tty_struct *tty,
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned int set, unsigned int clear)
|
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct whiteheat_private *info = usb_get_serial_port_data(port);
|
|
|
|
|
|
|
|
if (set & TIOCM_RTS)
|
|
|
|
info->mcr |= UART_MCR_RTS;
|
|
|
|
if (set & TIOCM_DTR)
|
|
|
|
info->mcr |= UART_MCR_DTR;
|
|
|
|
|
|
|
|
if (clear & TIOCM_RTS)
|
|
|
|
info->mcr &= ~UART_MCR_RTS;
|
|
|
|
if (clear & TIOCM_DTR)
|
|
|
|
info->mcr &= ~UART_MCR_DTR;
|
|
|
|
|
|
|
|
firm_set_dtr(port, info->mcr & UART_MCR_DTR);
|
|
|
|
firm_set_rts(port, info->mcr & UART_MCR_RTS);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-14 23:27:06 +07:00
|
|
|
static int whiteheat_ioctl(struct tty_struct *tty,
|
2008-07-22 17:09:16 +07:00
|
|
|
unsigned int cmd, unsigned long arg)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct serial_struct serstruct;
|
|
|
|
void __user *user_arg = (void __user *)arg;
|
|
|
|
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(&port->dev, "%s - cmd 0x%.4x\n", __func__, cmd);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
switch (cmd) {
|
2008-07-22 17:09:16 +07:00
|
|
|
case TIOCGSERIAL:
|
|
|
|
memset(&serstruct, 0, sizeof(serstruct));
|
|
|
|
serstruct.type = PORT_16654;
|
|
|
|
serstruct.line = port->serial->minor;
|
|
|
|
serstruct.port = port->number;
|
|
|
|
serstruct.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
|
2012-03-22 22:50:55 +07:00
|
|
|
serstruct.xmit_fifo_size = kfifo_size(&port->write_fifo);
|
2008-07-22 17:09:16 +07:00
|
|
|
serstruct.custom_divisor = 0;
|
|
|
|
serstruct.baud_base = 460800;
|
|
|
|
serstruct.close_delay = CLOSING_DELAY;
|
|
|
|
serstruct.closing_wait = CLOSING_DELAY;
|
|
|
|
|
|
|
|
if (copy_to_user(user_arg, &serstruct, sizeof(serstruct)))
|
|
|
|
return -EFAULT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOIOCTLCMD;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
static void whiteheat_set_termios(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port, struct ktermios *old_termios)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
firm_setup_port(tty);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
static void whiteheat_break_ctl(struct tty_struct *tty, int break_state)
|
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
firm_set_break(port, break_state);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* Connect Tech's White Heat callback routines
|
|
|
|
*****************************************************************************/
|
2007-05-24 18:52:51 +07:00
|
|
|
static void command_port_write_callback(struct urb *urb)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-06-16 05:44:13 +07:00
|
|
|
int status = urb->status;
|
|
|
|
|
|
|
|
if (status) {
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(&urb->dev->dev, "nonzero urb status: %d\n", status);
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-05-24 18:52:51 +07:00
|
|
|
static void command_port_read_callback(struct urb *urb)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-02-24 17:41:47 +07:00
|
|
|
struct usb_serial_port *command_port = urb->context;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct whiteheat_command_private *command_info;
|
2007-06-16 05:44:13 +07:00
|
|
|
int status = urb->status;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned char *data = urb->transfer_buffer;
|
|
|
|
int result;
|
|
|
|
|
2007-05-24 18:52:51 +07:00
|
|
|
command_info = usb_get_serial_port_data(command_port);
|
|
|
|
if (!command_info) {
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(&urb->dev->dev, "%s - command_info is NULL, exiting.\n", __func__);
|
2007-05-24 18:52:51 +07:00
|
|
|
return;
|
|
|
|
}
|
2007-06-16 05:44:13 +07:00
|
|
|
if (status) {
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n", __func__, status);
|
2007-06-16 05:44:13 +07:00
|
|
|
if (status != -ENOENT)
|
2007-05-24 18:52:51 +07:00
|
|
|
command_info->command_finished = WHITEHEAT_CMD_FAILURE;
|
|
|
|
wake_up(&command_info->wait_command);
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-09-18 15:58:57 +07:00
|
|
|
usb_serial_debug_data(&command_port->dev, __func__, urb->actual_length, data);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (data[0] == WHITEHEAT_CMD_COMPLETE) {
|
|
|
|
command_info->command_finished = WHITEHEAT_CMD_COMPLETE;
|
2007-05-24 18:52:51 +07:00
|
|
|
wake_up(&command_info->wait_command);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else if (data[0] == WHITEHEAT_CMD_FAILURE) {
|
|
|
|
command_info->command_finished = WHITEHEAT_CMD_FAILURE;
|
2007-05-24 18:52:51 +07:00
|
|
|
wake_up(&command_info->wait_command);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else if (data[0] == WHITEHEAT_EVENT) {
|
2008-07-22 17:09:16 +07:00
|
|
|
/* These are unsolicited reports from the firmware, hence no
|
|
|
|
waiting command to wakeup */
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(&urb->dev->dev, "%s - event received\n", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else if (data[0] == WHITEHEAT_GET_DTR_RTS) {
|
2008-07-22 17:09:16 +07:00
|
|
|
memcpy(command_info->result_buffer, &data[1],
|
|
|
|
urb->actual_length - 1);
|
2005-04-17 05:20:36 +07:00
|
|
|
command_info->command_finished = WHITEHEAT_CMD_COMPLETE;
|
2007-05-24 18:52:51 +07:00
|
|
|
wake_up(&command_info->wait_command);
|
2008-07-22 17:09:16 +07:00
|
|
|
} else
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(&urb->dev->dev, "%s - bad reply from firmware\n", __func__);
|
2008-07-22 17:09:16 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Continue trying to always read */
|
|
|
|
result = usb_submit_urb(command_port->read_urb, GFP_ATOMIC);
|
|
|
|
if (result)
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n",
|
2008-07-22 17:09:16 +07:00
|
|
|
__func__, result);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* Connect Tech's White Heat firmware interface
|
|
|
|
*****************************************************************************/
|
2008-07-22 17:09:16 +07:00
|
|
|
static int firm_send_command(struct usb_serial_port *port, __u8 command,
|
|
|
|
__u8 *data, __u8 datasize)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct usb_serial_port *command_port;
|
|
|
|
struct whiteheat_command_private *command_info;
|
|
|
|
struct whiteheat_private *info;
|
2012-09-15 01:50:35 +07:00
|
|
|
struct device *dev = &port->dev;
|
2005-04-17 05:20:36 +07:00
|
|
|
__u8 *transfer_buffer;
|
|
|
|
int retval = 0;
|
2007-05-24 18:52:51 +07:00
|
|
|
int t;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(dev, "%s - command %d\n", __func__, command);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
command_port = port->serial->port[COMMAND_PORT];
|
|
|
|
command_info = usb_get_serial_port_data(command_port);
|
2007-05-24 18:52:51 +07:00
|
|
|
mutex_lock(&command_info->mutex);
|
2007-03-27 13:00:28 +07:00
|
|
|
command_info->command_finished = false;
|
2008-07-22 17:09:16 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
transfer_buffer = (__u8 *)command_port->write_urb->transfer_buffer;
|
|
|
|
transfer_buffer[0] = command;
|
2008-07-22 17:09:16 +07:00
|
|
|
memcpy(&transfer_buffer[1], data, datasize);
|
2005-04-17 05:20:36 +07:00
|
|
|
command_port->write_urb->transfer_buffer_length = datasize + 1;
|
2008-07-22 17:09:16 +07:00
|
|
|
retval = usb_submit_urb(command_port->write_urb, GFP_NOIO);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (retval) {
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(dev, "%s - submit urb failed\n", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* wait for the command to complete */
|
2007-05-24 18:52:51 +07:00
|
|
|
t = wait_event_timeout(command_info->wait_command,
|
2007-03-27 13:00:28 +07:00
|
|
|
(bool)command_info->command_finished, COMMAND_TIMEOUT);
|
2007-05-24 18:52:51 +07:00
|
|
|
if (!t)
|
|
|
|
usb_kill_urb(command_port->write_urb);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-03-27 13:00:28 +07:00
|
|
|
if (command_info->command_finished == false) {
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(dev, "%s - command timed out.\n", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
retval = -ETIMEDOUT;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (command_info->command_finished == WHITEHEAT_CMD_FAILURE) {
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(dev, "%s - command failed.\n", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
retval = -EIO;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (command_info->command_finished == WHITEHEAT_CMD_COMPLETE) {
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(dev, "%s - command completed.\n", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
switch (command) {
|
2008-07-22 17:09:16 +07:00
|
|
|
case WHITEHEAT_GET_DTR_RTS:
|
|
|
|
info = usb_get_serial_port_data(port);
|
|
|
|
memcpy(&info->mcr, command_info->result_buffer,
|
|
|
|
sizeof(struct whiteheat_dr_info));
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
exit:
|
2007-05-24 18:52:51 +07:00
|
|
|
mutex_unlock(&command_info->mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
static int firm_open(struct usb_serial_port *port)
|
|
|
|
{
|
2005-04-17 05:20:36 +07:00
|
|
|
struct whiteheat_simple open_command;
|
|
|
|
|
|
|
|
open_command.port = port->number - port->serial->minor + 1;
|
2008-07-22 17:09:16 +07:00
|
|
|
return firm_send_command(port, WHITEHEAT_OPEN,
|
|
|
|
(__u8 *)&open_command, sizeof(open_command));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
static int firm_close(struct usb_serial_port *port)
|
|
|
|
{
|
2005-04-17 05:20:36 +07:00
|
|
|
struct whiteheat_simple close_command;
|
|
|
|
|
|
|
|
close_command.port = port->number - port->serial->minor + 1;
|
2008-07-22 17:09:16 +07:00
|
|
|
return firm_send_command(port, WHITEHEAT_CLOSE,
|
|
|
|
(__u8 *)&close_command, sizeof(close_command));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-09-20 03:13:33 +07:00
|
|
|
static void firm_setup_port(struct tty_struct *tty)
|
2008-07-22 17:09:16 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2012-09-15 01:50:35 +07:00
|
|
|
struct device *dev = &port->dev;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct whiteheat_port_settings port_settings;
|
2012-07-14 21:31:47 +07:00
|
|
|
unsigned int cflag = tty->termios.c_cflag;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
port_settings.port = port->number + 1;
|
|
|
|
|
|
|
|
/* get the byte size */
|
|
|
|
switch (cflag & CSIZE) {
|
2008-07-22 17:09:16 +07:00
|
|
|
case CS5: port_settings.bits = 5; break;
|
|
|
|
case CS6: port_settings.bits = 6; break;
|
|
|
|
case CS7: port_settings.bits = 7; break;
|
|
|
|
default:
|
|
|
|
case CS8: port_settings.bits = 8; break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(dev, "%s - data bits = %d\n", __func__, port_settings.bits);
|
2008-07-22 17:09:16 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* determine the parity */
|
|
|
|
if (cflag & PARENB)
|
|
|
|
if (cflag & CMSPAR)
|
|
|
|
if (cflag & PARODD)
|
|
|
|
port_settings.parity = WHITEHEAT_PAR_MARK;
|
|
|
|
else
|
|
|
|
port_settings.parity = WHITEHEAT_PAR_SPACE;
|
|
|
|
else
|
|
|
|
if (cflag & PARODD)
|
|
|
|
port_settings.parity = WHITEHEAT_PAR_ODD;
|
|
|
|
else
|
|
|
|
port_settings.parity = WHITEHEAT_PAR_EVEN;
|
|
|
|
else
|
|
|
|
port_settings.parity = WHITEHEAT_PAR_NONE;
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(dev, "%s - parity = %c\n", __func__, port_settings.parity);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* figure out the stop bits requested */
|
|
|
|
if (cflag & CSTOPB)
|
|
|
|
port_settings.stop = 2;
|
|
|
|
else
|
|
|
|
port_settings.stop = 1;
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(dev, "%s - stop bits = %d\n", __func__, port_settings.stop);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* figure out the flow control settings */
|
|
|
|
if (cflag & CRTSCTS)
|
2008-07-22 17:09:16 +07:00
|
|
|
port_settings.hflow = (WHITEHEAT_HFLOW_CTS |
|
|
|
|
WHITEHEAT_HFLOW_RTS);
|
2005-04-17 05:20:36 +07:00
|
|
|
else
|
|
|
|
port_settings.hflow = WHITEHEAT_HFLOW_NONE;
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(dev, "%s - hardware flow control = %s %s %s %s\n", __func__,
|
2005-04-17 05:20:36 +07:00
|
|
|
(port_settings.hflow & WHITEHEAT_HFLOW_CTS) ? "CTS" : "",
|
|
|
|
(port_settings.hflow & WHITEHEAT_HFLOW_RTS) ? "RTS" : "",
|
|
|
|
(port_settings.hflow & WHITEHEAT_HFLOW_DSR) ? "DSR" : "",
|
|
|
|
(port_settings.hflow & WHITEHEAT_HFLOW_DTR) ? "DTR" : "");
|
2008-07-22 17:09:16 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* determine software flow control */
|
2008-07-22 17:09:07 +07:00
|
|
|
if (I_IXOFF(tty))
|
2005-04-17 05:20:36 +07:00
|
|
|
port_settings.sflow = WHITEHEAT_SFLOW_RXTX;
|
|
|
|
else
|
|
|
|
port_settings.sflow = WHITEHEAT_SFLOW_NONE;
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(dev, "%s - software flow control = %c\n", __func__, port_settings.sflow);
|
2008-07-22 17:09:16 +07:00
|
|
|
|
2008-07-22 17:09:07 +07:00
|
|
|
port_settings.xon = START_CHAR(tty);
|
|
|
|
port_settings.xoff = STOP_CHAR(tty);
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(dev, "%s - XON = %2x, XOFF = %2x\n", __func__, port_settings.xon, port_settings.xoff);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* get the baud rate wanted */
|
2008-07-22 17:09:07 +07:00
|
|
|
port_settings.baud = tty_get_baud_rate(tty);
|
2012-09-15 01:50:35 +07:00
|
|
|
dev_dbg(dev, "%s - baud rate = %d\n", __func__, port_settings.baud);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-18 15:24:23 +07:00
|
|
|
/* fixme: should set validated settings */
|
2008-07-22 17:09:07 +07:00
|
|
|
tty_encode_baud_rate(tty, port_settings.baud, port_settings.baud);
|
2005-04-17 05:20:36 +07:00
|
|
|
/* handle any settings that aren't specified in the tty structure */
|
|
|
|
port_settings.lloop = 0;
|
2008-07-22 17:09:16 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* now send the message to the device */
|
2009-09-20 03:13:33 +07:00
|
|
|
firm_send_command(port, WHITEHEAT_SETUP_PORT,
|
2008-07-22 17:09:16 +07:00
|
|
|
(__u8 *)&port_settings, sizeof(port_settings));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
static int firm_set_rts(struct usb_serial_port *port, __u8 onoff)
|
|
|
|
{
|
2005-04-17 05:20:36 +07:00
|
|
|
struct whiteheat_set_rdb rts_command;
|
|
|
|
|
|
|
|
rts_command.port = port->number - port->serial->minor + 1;
|
|
|
|
rts_command.state = onoff;
|
2008-07-22 17:09:16 +07:00
|
|
|
return firm_send_command(port, WHITEHEAT_SET_RTS,
|
|
|
|
(__u8 *)&rts_command, sizeof(rts_command));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
static int firm_set_dtr(struct usb_serial_port *port, __u8 onoff)
|
|
|
|
{
|
2005-04-17 05:20:36 +07:00
|
|
|
struct whiteheat_set_rdb dtr_command;
|
|
|
|
|
|
|
|
dtr_command.port = port->number - port->serial->minor + 1;
|
|
|
|
dtr_command.state = onoff;
|
2008-07-22 17:09:29 +07:00
|
|
|
return firm_send_command(port, WHITEHEAT_SET_DTR,
|
2008-07-22 17:09:16 +07:00
|
|
|
(__u8 *)&dtr_command, sizeof(dtr_command));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
static int firm_set_break(struct usb_serial_port *port, __u8 onoff)
|
|
|
|
{
|
2005-04-17 05:20:36 +07:00
|
|
|
struct whiteheat_set_rdb break_command;
|
|
|
|
|
|
|
|
break_command.port = port->number - port->serial->minor + 1;
|
|
|
|
break_command.state = onoff;
|
2008-07-22 17:09:29 +07:00
|
|
|
return firm_send_command(port, WHITEHEAT_SET_BREAK,
|
2008-07-22 17:09:16 +07:00
|
|
|
(__u8 *)&break_command, sizeof(break_command));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
static int firm_purge(struct usb_serial_port *port, __u8 rxtx)
|
|
|
|
{
|
2005-04-17 05:20:36 +07:00
|
|
|
struct whiteheat_purge purge_command;
|
|
|
|
|
|
|
|
purge_command.port = port->number - port->serial->minor + 1;
|
|
|
|
purge_command.what = rxtx;
|
2008-07-22 17:09:16 +07:00
|
|
|
return firm_send_command(port, WHITEHEAT_PURGE,
|
|
|
|
(__u8 *)&purge_command, sizeof(purge_command));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
static int firm_get_dtr_rts(struct usb_serial_port *port)
|
|
|
|
{
|
2005-04-17 05:20:36 +07:00
|
|
|
struct whiteheat_simple get_dr_command;
|
|
|
|
|
|
|
|
get_dr_command.port = port->number - port->serial->minor + 1;
|
2008-07-22 17:09:16 +07:00
|
|
|
return firm_send_command(port, WHITEHEAT_GET_DTR_RTS,
|
|
|
|
(__u8 *)&get_dr_command, sizeof(get_dr_command));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
static int firm_report_tx_done(struct usb_serial_port *port)
|
|
|
|
{
|
2005-04-17 05:20:36 +07:00
|
|
|
struct whiteheat_simple close_command;
|
|
|
|
|
|
|
|
close_command.port = port->number - port->serial->minor + 1;
|
2008-07-22 17:09:16 +07:00
|
|
|
return firm_send_command(port, WHITEHEAT_REPORT_TX_DONE,
|
|
|
|
(__u8 *)&close_command, sizeof(close_command));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* Connect Tech's White Heat utility functions
|
|
|
|
*****************************************************************************/
|
|
|
|
static int start_command_port(struct usb_serial *serial)
|
|
|
|
{
|
|
|
|
struct usb_serial_port *command_port;
|
|
|
|
struct whiteheat_command_private *command_info;
|
|
|
|
int retval = 0;
|
2008-07-22 17:09:16 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
command_port = serial->port[COMMAND_PORT];
|
|
|
|
command_info = usb_get_serial_port_data(command_port);
|
2007-05-24 18:52:51 +07:00
|
|
|
mutex_lock(&command_info->mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!command_info->port_running) {
|
|
|
|
/* Work around HCD bugs */
|
|
|
|
usb_clear_halt(serial->dev, command_port->read_urb->pipe);
|
|
|
|
|
|
|
|
retval = usb_submit_urb(command_port->read_urb, GFP_KERNEL);
|
|
|
|
if (retval) {
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&serial->dev->dev,
|
|
|
|
"%s - failed submitting read urb, error %d\n",
|
|
|
|
__func__, retval);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
command_info->port_running++;
|
|
|
|
|
|
|
|
exit:
|
2007-05-24 18:52:51 +07:00
|
|
|
mutex_unlock(&command_info->mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void stop_command_port(struct usb_serial *serial)
|
|
|
|
{
|
|
|
|
struct usb_serial_port *command_port;
|
|
|
|
struct whiteheat_command_private *command_info;
|
|
|
|
|
|
|
|
command_port = serial->port[COMMAND_PORT];
|
|
|
|
command_info = usb_get_serial_port_data(command_port);
|
2007-05-24 18:52:51 +07:00
|
|
|
mutex_lock(&command_info->mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
command_info->port_running--;
|
|
|
|
if (!command_info->port_running)
|
|
|
|
usb_kill_urb(command_port->read_urb);
|
2007-05-24 18:52:51 +07:00
|
|
|
mutex_unlock(&command_info->mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2012-05-09 05:46:14 +07:00
|
|
|
module_usb_serial_driver(serial_drivers, id_table_combined);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-22 17:09:16 +07:00
|
|
|
MODULE_AUTHOR(DRIVER_AUTHOR);
|
|
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
2005-04-17 05:20:36 +07:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2008-05-31 05:35:29 +07:00
|
|
|
MODULE_FIRMWARE("whiteheat.fw");
|
|
|
|
MODULE_FIRMWARE("whiteheat_loader.fw");
|