[mirror_ubuntu-bionic-kernel.git] / drivers / usb / serial / ipw.c

/*
 * IPWireless 3G UMTS TDD Modem driver (USB connected)
 *
 *   Copyright (C) 2004 Roelf Diedericks <roelfd@inet.co.za>
 *   Copyright (C) 2004 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.
 *
 * All information about the device was acquired using SnoopyPro
 * on MSFT's O/S, and examing the MSFT drivers' debug output
 * (insanely left _on_ in the enduser version)
 *
 * It was written out of frustration with the IPWireless USB modem
 * supplied by Axity3G/Sentech South Africa not supporting
 * Linux whatsoever.
 *
 * Nobody provided any proprietary information that was not already
 * available for this device.
 *
 * The modem adheres to the "3GPP TS  27.007 AT command set for 3G
 * User Equipment (UE)" standard, available from
 * http://www.3gpp.org/ftp/Specs/html-info/27007.htm
 *
 * The code was only tested the IPWireless handheld modem distributed
 * in South Africa by Sentech.
 *
 * It may work for Woosh Inc in .nz too, as it appears they use the
 * same kit.
 *
 * There is still some work to be done in terms of handling
 * DCD, DTR, RTS, CTS which are currently faked.
 * It's good enough for PPP at this point. It's based off all kinds of
 * code found in usb/serial and usb/class
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>
#include <linux/uaccess.h>
#include "usb-wwan.h"

/*
 * Version Information
 */
#define DRIVER_VERSION	"v0.4"
#define DRIVER_AUTHOR	"Roelf Diedericks"
#define DRIVER_DESC	"IPWireless tty driver"

#define IPW_TTY_MAJOR	240	/* real device node major id, experimental range */
#define IPW_TTY_MINORS	256	/* we support 256 devices, dunno why, it'd be insane :) */

#define USB_IPW_MAGIC	0x6d02	/* magic number for ipw struct */


/* Message sizes */
#define EVENT_BUFFER_SIZE	0xFF
#define CHAR2INT16(c1, c0)	(((u32)((c1) & 0xff) << 8) + (u32)((c0) & 0xff))

/* vendor/product pairs that are known work with this driver*/
#define IPW_VID		0x0bc3
#define IPW_PID		0x0001


/* Vendor commands: */

/* baud rates */
enum {
	ipw_sio_b256000 = 0x000e,
	ipw_sio_b128000 = 0x001d,
	ipw_sio_b115200 = 0x0020,
	ipw_sio_b57600  = 0x0040,
	ipw_sio_b56000  = 0x0042,
	ipw_sio_b38400  = 0x0060,
	ipw_sio_b19200  = 0x00c0,
	ipw_sio_b14400  = 0x0100,
	ipw_sio_b9600   = 0x0180,
	ipw_sio_b4800   = 0x0300,
	ipw_sio_b2400   = 0x0600,
	ipw_sio_b1200   = 0x0c00,
	ipw_sio_b600    = 0x1800
};

/* data bits */
#define ipw_dtb_7		0x700
#define ipw_dtb_8		0x810	/* ok so the define is misleading, I know, but forces 8,n,1 */
					/* I mean, is there a point to any other setting these days? :) */

/* usb control request types : */
#define IPW_SIO_RXCTL		0x00	/* control bulk rx channel transmissions, value=1/0 (on/off) */
#define IPW_SIO_SET_BAUD	0x01	/* set baud, value=requested ipw_sio_bxxxx */
#define IPW_SIO_SET_LINE	0x03	/* set databits, parity. value=ipw_dtb_x */
#define IPW_SIO_SET_PIN		0x03	/* set/clear dtr/rts value=ipw_pin_xxx */
#define IPW_SIO_POLL		0x08	/* get serial port status byte, call with value=0 */
#define IPW_SIO_INIT		0x11	/* initializes ? value=0 (appears as first thing todo on open) */
#define IPW_SIO_PURGE		0x12	/* purge all transmissions?, call with value=numchar_to_purge */
#define IPW_SIO_HANDFLOW	0x13	/* set xon/xoff limits value=0, and a buffer of 0x10 bytes */
#define IPW_SIO_SETCHARS	0x13	/* set the flowcontrol special chars, value=0, buf=6 bytes, */
					/* last 2 bytes contain flowcontrol chars e.g. 00 00 00 00 11 13 */

/* values used for request IPW_SIO_SET_PIN */
#define IPW_PIN_SETDTR		0x101
#define IPW_PIN_SETRTS		0x202
#define IPW_PIN_CLRDTR		0x100
#define IPW_PIN_CLRRTS		0x200 /* unconfirmed */

/* values used for request IPW_SIO_RXCTL */
#define IPW_RXBULK_ON		1
#define IPW_RXBULK_OFF		0

/* various 16 byte hardcoded transferbuffers used by flow control */
#define IPW_BYTES_FLOWINIT	{ 0x01, 0, 0, 0, 0x40, 0, 0, 0, \
					0, 0, 0, 0, 0, 0, 0, 0 }

/* Interpretation of modem status lines */
/* These need sorting out by individually connecting pins and checking
 * results. FIXME!
 * When data is being sent we see 0x30 in the lower byte; this must
 * contain DSR and CTS ...
 */
#define IPW_DSR			((1<<4) | (1<<5))
#define IPW_CTS			((1<<5) | (1<<4))

#define IPW_WANTS_TO_SEND	0x30

static const struct usb_device_id id_table[] = {
	{ USB_DEVICE(IPW_VID, IPW_PID) },
	{ },
};
MODULE_DEVICE_TABLE(usb, id_table);

static bool debug;

static int ipw_open(struct tty_struct *tty, struct usb_serial_port *port)
{
	struct usb_device *dev = port->serial->dev;
	u8 buf_flow_static[16] = IPW_BYTES_FLOWINIT;
	u8 *buf_flow_init;
	int result;

	buf_flow_init = kmemdup(buf_flow_static, 16, GFP_KERNEL);
	if (!buf_flow_init)
		return -ENOMEM;

	/* --1: Tell the modem to initialize (we think) From sniffs this is
	 *	always the first thing that gets sent to the modem during
	 *	opening of the device */
	dbg("%s: Sending SIO_INIT (we guess)", __func__);
	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
			 IPW_SIO_INIT,
			 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
			 0,
			 0, /* index */
			 NULL,
			 0,
			 100000);
	if (result < 0)
		dev_err(&port->dev,
			"Init of modem failed (error = %d)\n", result);

	/* reset the bulk pipes */
	usb_clear_halt(dev,
			usb_rcvbulkpipe(dev, port->bulk_in_endpointAddress));
	usb_clear_halt(dev,
			usb_sndbulkpipe(dev, port->bulk_out_endpointAddress));

	/*--2: Start reading from the device */
	dbg("%s: setting up bulk read callback", __func__);
	usb_wwan_open(tty, port);

	/*--3: Tell the modem to open the floodgates on the rx bulk channel */
	dbg("%s:asking modem for RxRead (RXBULK_ON)", __func__);
	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
			 IPW_SIO_RXCTL,
			 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
			 IPW_RXBULK_ON,
			 0, /* index */
			 NULL,
			 0,
			 100000);
	if (result < 0)
		dev_err(&port->dev,
			"Enabling bulk RxRead failed (error = %d)\n", result);

	/*--4: setup the initial flowcontrol */
	dbg("%s:setting init flowcontrol (%s)", __func__, buf_flow_init);
	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
			 IPW_SIO_HANDFLOW,
			 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
			 0,
			 0,
			 buf_flow_init,
			 0x10,
			 200000);
	if (result < 0)
		dev_err(&port->dev,
			"initial flowcontrol failed (error = %d)\n", result);

	kfree(buf_flow_init);
	return 0;
}

/* fake probe - only to allocate data structures */
static int ipw_probe(struct usb_serial *serial, const struct usb_device_id *id)
{
	struct usb_wwan_intf_private *data;

	data = kzalloc(sizeof(struct usb_wwan_intf_private), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	spin_lock_init(&data->susp_lock);
	usb_set_serial_data(serial, data);
	return 0;
}

static void ipw_release(struct usb_serial *serial)
{
	struct usb_wwan_intf_private *data = usb_get_serial_data(serial);

	usb_set_serial_data(serial, NULL);
	kfree(data);
}

static void ipw_dtr_rts(struct usb_serial_port *port, int on)
{
	struct usb_device *dev = port->serial->dev;
	int result;

	dbg("%s: on = %d", __func__, on);

	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
			 IPW_SIO_SET_PIN,
			 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
			 on ? IPW_PIN_SETDTR : IPW_PIN_CLRDTR,
			 0,
			 NULL,
			 0,
			 200000);
	if (result < 0)
		dev_err(&port->dev, "setting dtr failed (error = %d)\n",
								result);

	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
			 IPW_SIO_SET_PIN, USB_TYPE_VENDOR |
					USB_RECIP_INTERFACE | USB_DIR_OUT,
			 on ? IPW_PIN_SETRTS : IPW_PIN_CLRRTS,
			 0,
			 NULL,
			 0,
			 200000);
	if (result < 0)
		dev_err(&port->dev, "setting rts failed (error = %d)\n",
								result);
}

static void ipw_close(struct usb_serial_port *port)
{
	struct usb_device *dev = port->serial->dev;
	int result;

	/*--3: purge */
	dbg("%s:sending purge", __func__);
	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
			 IPW_SIO_PURGE, USB_TYPE_VENDOR |
			 		USB_RECIP_INTERFACE | USB_DIR_OUT,
			 0x03,
			 0,
			 NULL,
			 0,
			 200000);
	if (result < 0)
		dev_err(&port->dev, "purge failed (error = %d)\n", result);


	/* send RXBULK_off (tell modem to stop transmitting bulk data on
	   rx chan) */
	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
			 IPW_SIO_RXCTL,
			 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
			 IPW_RXBULK_OFF,
			 0, /* index */
			 NULL,
			 0,
			 100000);

	if (result < 0)
		dev_err(&port->dev,
			"Disabling bulk RxRead failed (error = %d)\n", result);

	usb_wwan_close(port);
}

static struct usb_serial_driver ipw_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"ipw",
	},
	.description =		"IPWireless converter",
	.id_table =		id_table,
	.num_ports =		1,
	.open =			ipw_open,
	.close =		ipw_close,
	.probe =		ipw_probe,
	.attach =		usb_wwan_startup,
	.release =		ipw_release,
	.port_remove =		usb_wwan_port_remove,
	.dtr_rts =		ipw_dtr_rts,
	.write =		usb_wwan_write,
};

static struct usb_serial_driver * const serial_drivers[] = {
	&ipw_device, NULL
};

module_usb_serial_driver(serial_drivers, id_table);

/* Module information */
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");

module_param(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Debug enabled or not");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* IPWireless 3G UMTS TDD Modem driver (USB connected)
	3	*
	4	* Copyright (C) 2004 Roelf Diedericks <roelfd@inet.co.za>
	5	* Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* All information about the device was acquired using SnoopyPro
6d1d1698	13	* on MSFT's O/S, and examing the MSFT drivers' debug output
1da177e4 LT	14	* (insanely left _on_ in the enduser version)
	15	*
	16	* It was written out of frustration with the IPWireless USB modem
	17	* supplied by Axity3G/Sentech South Africa not supporting
	18	* Linux whatsoever.
	19	*
6d1d1698	20	* Nobody provided any proprietary information that was not already
1da177e4	21	* available for this device.
6d1d1698 AC	22	*
	23	* The modem adheres to the "3GPP TS 27.007 AT command set for 3G
	24	* User Equipment (UE)" standard, available from
1da177e4 LT	25	* http://www.3gpp.org/ftp/Specs/html-info/27007.htm
	26	*
	27	* The code was only tested the IPWireless handheld modem distributed
	28	* in South Africa by Sentech.
6d1d1698	29	*
1da177e4 LT	30	* It may work for Woosh Inc in .nz too, as it appears they use the
	31	* same kit.
	32	*
6d1d1698	33	* There is still some work to be done in terms of handling
1da177e4 LT	34	* DCD, DTR, RTS, CTS which are currently faked.
	35	* It's good enough for PPP at this point. It's based off all kinds of
	36	* code found in usb/serial and usb/class
1da177e4 LT	37	*/
	38
	39	#include <linux/kernel.h>
	40	#include <linux/errno.h>
	41	#include <linux/init.h>
	42	#include <linux/slab.h>
	43	#include <linux/tty.h>
	44	#include <linux/tty_flip.h>
	45	#include <linux/module.h>
	46	#include <linux/spinlock.h>
	47	#include <linux/usb.h>
a969888c	48	#include <linux/usb/serial.h>
6d1d1698	49	#include <linux/uaccess.h>
53e77df2	50	#include "usb-wwan.h"
1da177e4 LT	51
	52	/*
	53	* Version Information
	54	*/
b2c57379	55	#define DRIVER_VERSION "v0.4"
1da177e4 LT	56	#define DRIVER_AUTHOR "Roelf Diedericks"
	57	#define DRIVER_DESC "IPWireless tty driver"
	58
	59	#define IPW_TTY_MAJOR 240 /* real device node major id, experimental range */
	60	#define IPW_TTY_MINORS 256 /* we support 256 devices, dunno why, it'd be insane :) */
	61
	62	#define USB_IPW_MAGIC 0x6d02 /* magic number for ipw struct */
	63
	64
	65	/* Message sizes */
	66	#define EVENT_BUFFER_SIZE 0xFF
6d1d1698	67	#define CHAR2INT16(c1, c0) (((u32)((c1) & 0xff) << 8) + (u32)((c0) & 0xff))
1da177e4 LT	68
	69	/* vendor/product pairs that are known work with this driver*/
	70	#define IPW_VID 0x0bc3
	71	#define IPW_PID 0x0001
	72
	73
	74	/* Vendor commands: */
	75
	76	/* baud rates */
	77	enum {
	78	ipw_sio_b256000 = 0x000e,
	79	ipw_sio_b128000 = 0x001d,
	80	ipw_sio_b115200 = 0x0020,
	81	ipw_sio_b57600 = 0x0040,
	82	ipw_sio_b56000 = 0x0042,
	83	ipw_sio_b38400 = 0x0060,
	84	ipw_sio_b19200 = 0x00c0,
	85	ipw_sio_b14400 = 0x0100,
	86	ipw_sio_b9600 = 0x0180,
	87	ipw_sio_b4800 = 0x0300,
	88	ipw_sio_b2400 = 0x0600,
	89	ipw_sio_b1200 = 0x0c00,
	90	ipw_sio_b600 = 0x1800
	91	};
	92
	93	/* data bits */
	94	#define ipw_dtb_7 0x700
6d1d1698 AC	95	#define ipw_dtb_8 0x810 /* ok so the define is misleading, I know, but forces 8,n,1 */
6d1d1698 AC	96	/* I mean, is there a point to any other setting these days? :) */
1da177e4 LT	97
1da177e4 LT	98	/* usb control request types : */
6d1d1698 AC	99	#define IPW_SIO_RXCTL 0x00 /* control bulk rx channel transmissions, value=1/0 (on/off) */
	100	#define IPW_SIO_SET_BAUD 0x01 /* set baud, value=requested ipw_sio_bxxxx */
	101	#define IPW_SIO_SET_LINE 0x03 /* set databits, parity. value=ipw_dtb_x */
	102	#define IPW_SIO_SET_PIN 0x03 /* set/clear dtr/rts value=ipw_pin_xxx */
	103	#define IPW_SIO_POLL 0x08 /* get serial port status byte, call with value=0 */
	104	#define IPW_SIO_INIT 0x11 /* initializes ? value=0 (appears as first thing todo on open) */
	105	#define IPW_SIO_PURGE 0x12 /* purge all transmissions?, call with value=numchar_to_purge */
	106	#define IPW_SIO_HANDFLOW 0x13 /* set xon/xoff limits value=0, and a buffer of 0x10 bytes */
	107	#define IPW_SIO_SETCHARS 0x13 /* set the flowcontrol special chars, value=0, buf=6 bytes, */
	108	/* last 2 bytes contain flowcontrol chars e.g. 00 00 00 00 11 13 */
1da177e4 LT	109
	110	/* values used for request IPW_SIO_SET_PIN */
	111	#define IPW_PIN_SETDTR 0x101
	112	#define IPW_PIN_SETRTS 0x202
	113	#define IPW_PIN_CLRDTR 0x100
6d1d1698	114	#define IPW_PIN_CLRRTS 0x200 /* unconfirmed */
1da177e4 LT	115
	116	/* values used for request IPW_SIO_RXCTL */
	117	#define IPW_RXBULK_ON 1
	118	#define IPW_RXBULK_OFF 0
	119
	120	/* various 16 byte hardcoded transferbuffers used by flow control */
6d1d1698 AC	121	#define IPW_BYTES_FLOWINIT { 0x01, 0, 0, 0, 0x40, 0, 0, 0, \
6d1d1698 AC	122	0, 0, 0, 0, 0, 0, 0, 0 }
1da177e4 LT	123
	124	/* Interpretation of modem status lines */
	125	/* These need sorting out by individually connecting pins and checking
	126	* results. FIXME!
	127	* When data is being sent we see 0x30 in the lower byte; this must
	128	* contain DSR and CTS ...
	129	*/
	130	#define IPW_DSR ((1<<4) \| (1<<5))
	131	#define IPW_CTS ((1<<5) \| (1<<4))
	132
	133	#define IPW_WANTS_TO_SEND 0x30
1da177e4	134
68e24113	135	static const struct usb_device_id id_table[] = {
1da177e4 LT	136	{ USB_DEVICE(IPW_VID, IPW_PID) },
	137	{ },
	138	};
68e24113	139	MODULE_DEVICE_TABLE(usb, id_table);
1da177e4	140
90ab5ee9	141	static bool debug;
1da177e4	142
a509a7e4	143	static int ipw_open(struct tty_struct tty, struct usb_serial_port port)
1da177e4 LT	144	{
	145	struct usb_device *dev = port->serial->dev;
	146	u8 buf_flow_static[16] = IPW_BYTES_FLOWINIT;
	147	u8 *buf_flow_init;
	148	int result;
	149
5d7efe5b	150	buf_flow_init = kmemdup(buf_flow_static, 16, GFP_KERNEL);
1da177e4 LT	151	if (!buf_flow_init)
1da177e4 LT	152	return -ENOMEM;
1da177e4	153
6d1d1698 AC	154	/* --1: Tell the modem to initialize (we think) From sniffs this is
	155	* always the first thing that gets sent to the modem during
	156	* opening of the device */
	157	dbg("%s: Sending SIO_INIT (we guess)", __func__);
	158	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
	159	IPW_SIO_INIT,
	160	USB_TYPE_VENDOR \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
	161	0,
	162	0, /* index */
	163	NULL,
	164	0,
	165	100000);
1da177e4	166	if (result < 0)
6d1d1698 AC	167	dev_err(&port->dev,
6d1d1698 AC	168	"Init of modem failed (error = %d)\n", result);
1da177e4 LT	169
1da177e4 LT	170	/* reset the bulk pipes */
6d1d1698 AC	171	usb_clear_halt(dev,
	172	usb_rcvbulkpipe(dev, port->bulk_in_endpointAddress));
	173	usb_clear_halt(dev,
	174	usb_sndbulkpipe(dev, port->bulk_out_endpointAddress));
1da177e4	175
6d1d1698 AC	176	/--2: Start reading from the device /
6d1d1698 AC	177	dbg("%s: setting up bulk read callback", __func__);
53e77df2	178	usb_wwan_open(tty, port);
1da177e4 LT	179
1da177e4 LT	180	/--3: Tell the modem to open the floodgates on the rx bulk channel /
6d1d1698	181	dbg("%s:asking modem for RxRead (RXBULK_ON)", __func__);
1da177e4	182	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
6d1d1698 AC	183	IPW_SIO_RXCTL,
	184	USB_TYPE_VENDOR \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
	185	IPW_RXBULK_ON,
	186	0, /* index */
	187	NULL,
	188	0,
	189	100000);
	190	if (result < 0)
	191	dev_err(&port->dev,
	192	"Enabling bulk RxRead failed (error = %d)\n", result);
1da177e4 LT	193
1da177e4 LT	194	/--4: setup the initial flowcontrol /
6d1d1698	195	dbg("%s:setting init flowcontrol (%s)", __func__, buf_flow_init);
1da177e4	196	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
6d1d1698 AC	197	IPW_SIO_HANDFLOW,
	198	USB_TYPE_VENDOR \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
	199	0,
	200	0,
	201	buf_flow_init,
	202	0x10,
	203	200000);
1da177e4	204	if (result < 0)
6d1d1698 AC	205	dev_err(&port->dev,
6d1d1698 AC	206	"initial flowcontrol failed (error = %d)\n", result);
1da177e4	207
1da177e4 LT	208	kfree(buf_flow_init);
	209	return 0;
	210	}
	211
53e77df2 ON	212	/* fake probe - only to allocate data structures */
	213	static int ipw_probe(struct usb_serial serial, const struct usb_device_id id)
	214	{
	215	struct usb_wwan_intf_private *data;
	216
	217	data = kzalloc(sizeof(struct usb_wwan_intf_private), GFP_KERNEL);
	218	if (!data)
	219	return -ENOMEM;
	220
	221	spin_lock_init(&data->susp_lock);
	222	usb_set_serial_data(serial, data);
	223	return 0;
	224	}
	225
	226	static void ipw_release(struct usb_serial *serial)
	227	{
	228	struct usb_wwan_intf_private *data = usb_get_serial_data(serial);
	229
53e77df2 ON	230	usb_set_serial_data(serial, NULL);
	231	kfree(data);
	232	}
	233
335f8514	234	static void ipw_dtr_rts(struct usb_serial_port *port, int on)
1da177e4 LT	235	{
	236	struct usb_device *dev = port->serial->dev;
	237	int result;
	238
605204bf JH	239	dbg("%s: on = %d", __func__, on);
605204bf JH	240
1da177e4	241	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
6d1d1698 AC	242	IPW_SIO_SET_PIN,
6d1d1698 AC	243	USB_TYPE_VENDOR \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
335f8514	244	on ? IPW_PIN_SETDTR : IPW_PIN_CLRDTR,
6d1d1698 AC	245	0,
	246	NULL,
	247	0,
	248	200000);
1da177e4	249	if (result < 0)
605204bf	250	dev_err(&port->dev, "setting dtr failed (error = %d)\n",
6d1d1698	251	result);
1da177e4	252
1da177e4	253	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
6d1d1698	254	IPW_SIO_SET_PIN, USB_TYPE_VENDOR \|
605204bf	255	USB_RECIP_INTERFACE \| USB_DIR_OUT,
335f8514	256	on ? IPW_PIN_SETRTS : IPW_PIN_CLRRTS,
6d1d1698 AC	257	0,
	258	NULL,
	259	0,
	260	200000);
1da177e4	261	if (result < 0)
605204bf JH	262	dev_err(&port->dev, "setting rts failed (error = %d)\n",
605204bf JH	263	result);
335f8514	264	}
1da177e4	265
335f8514 AC	266	static void ipw_close(struct usb_serial_port *port)
	267	{
	268	struct usb_device *dev = port->serial->dev;
	269	int result;
1da177e4 LT	270
1da177e4 LT	271	/--3: purge /
6d1d1698	272	dbg("%s:sending purge", __func__);
1da177e4	273	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
6d1d1698 AC	274	IPW_SIO_PURGE, USB_TYPE_VENDOR \|
	275	USB_RECIP_INTERFACE \| USB_DIR_OUT,
	276	0x03,
	277	0,
	278	NULL,
	279	0,
	280	200000);
1da177e4	281	if (result < 0)
898eb71c	282	dev_err(&port->dev, "purge failed (error = %d)\n", result);
1da177e4 LT	283
1da177e4 LT	284
6d1d1698 AC	285	/* send RXBULK_off (tell modem to stop transmitting bulk data on
6d1d1698 AC	286	rx chan) */
1da177e4	287	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
6d1d1698 AC	288	IPW_SIO_RXCTL,
	289	USB_TYPE_VENDOR \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
	290	IPW_RXBULK_OFF,
	291	0, /* index */
	292	NULL,
	293	0,
	294	100000);
1da177e4 LT	295
1da177e4 LT	296	if (result < 0)
6d1d1698 AC	297	dev_err(&port->dev,
6d1d1698 AC	298	"Disabling bulk RxRead failed (error = %d)\n", result);
1da177e4	299
53e77df2	300	usb_wwan_close(port);
6d1d1698	301	}
1da177e4	302
ea65370d	303	static struct usb_serial_driver ipw_device = {
18fcac35 GKH	304	.driver = {
18fcac35 GKH	305	.owner = THIS_MODULE,
269bda1c	306	.name = "ipw",
18fcac35	307	},
269bda1c	308	.description = "IPWireless converter",
68e24113	309	.id_table = id_table,
1da177e4 LT	310	.num_ports = 1,
	311	.open = ipw_open,
	312	.close = ipw_close,
53e77df2 ON	313	.probe = ipw_probe,
	314	.attach = usb_wwan_startup,
	315	.release = ipw_release,
a1028f0a	316	.port_remove = usb_wwan_port_remove,
335f8514	317	.dtr_rts = ipw_dtr_rts,
53e77df2	318	.write = usb_wwan_write,
1da177e4 LT	319	};
1da177e4 LT	320
7dbe2460 AS	321	static struct usb_serial_driver * const serial_drivers[] = {
	322	&ipw_device, NULL
	323	};
1da177e4	324
68e24113	325	module_usb_serial_driver(serial_drivers, id_table);
1da177e4 LT	326
1da177e4 LT	327	/* Module information */
6d1d1698 AC	328	MODULE_AUTHOR(DRIVER_AUTHOR);
6d1d1698 AC	329	MODULE_DESCRIPTION(DRIVER_DESC);
1da177e4 LT	330	MODULE_LICENSE("GPL");
	331
	332	module_param(debug, bool, S_IRUGO \| S_IWUSR);
	333	MODULE_PARM_DESC(debug, "Debug enabled or not");