[deliverable/linux.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 usb_ipw_ids[] = {
	{ USB_DEVICE(IPW_VID, IPW_PID) },
	{ },
};

MODULE_DEVICE_TABLE(usb, usb_ipw_ids);

static struct usb_driver usb_ipw_driver = {
	.name =		"ipwtty",
	.probe =	usb_serial_probe,
	.disconnect =	usb_serial_disconnect,
	.id_table =	usb_ipw_ids,
	.no_dynamic_id = 	1,
};

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;

	dbg("%s", __func__);

	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_wwan_release(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",
	.usb_driver =		&usb_ipw_driver,
	.id_table =		usb_ipw_ids,
	.num_ports =		1,
	.disconnect =		usb_wwan_disconnect,
	.open =			ipw_open,
	.close =		ipw_close,
	.probe =		ipw_probe,
	.attach =		usb_wwan_startup,
	.release =		ipw_release,
	.dtr_rts =		ipw_dtr_rts,
	.write =		usb_wwan_write,
};


static int __init usb_ipw_init(void)
{
	int retval;

	retval = usb_serial_register(&ipw_device);
	if (retval)
		return retval;
	retval = usb_register(&usb_ipw_driver);
	if (retval) {
		usb_serial_deregister(&ipw_device);
		return retval;
	}
	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
	       DRIVER_DESC "\n");
	return 0;
}

static void __exit usb_ipw_exit(void)
{
	usb_deregister(&usb_ipw_driver);
	usb_serial_deregister(&ipw_device);
}

module_init(usb_ipw_init);
module_exit(usb_ipw_exit);

/* 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
7d40d7e8	135	static const struct usb_device_id usb_ipw_ids[] = {
1da177e4 LT	136	{ USB_DEVICE(IPW_VID, IPW_PID) },
	137	{ },
	138	};
	139
	140	MODULE_DEVICE_TABLE(usb, usb_ipw_ids);
	141
	142	static struct usb_driver usb_ipw_driver = {
1da177e4 LT	143	.name = "ipwtty",
	144	.probe = usb_serial_probe,
	145	.disconnect = usb_serial_disconnect,
	146	.id_table = usb_ipw_ids,
ba9dc657	147	.no_dynamic_id = 1,
1da177e4 LT	148	};
1da177e4 LT	149
90ab5ee9	150	static bool debug;
1da177e4	151
a509a7e4	152	static int ipw_open(struct tty_struct tty, struct usb_serial_port port)
1da177e4 LT	153	{
	154	struct usb_device *dev = port->serial->dev;
	155	u8 buf_flow_static[16] = IPW_BYTES_FLOWINIT;
	156	u8 *buf_flow_init;
	157	int result;
	158
441b62c1	159	dbg("%s", __func__);
1da177e4	160
5d7efe5b	161	buf_flow_init = kmemdup(buf_flow_static, 16, GFP_KERNEL);
1da177e4 LT	162	if (!buf_flow_init)
1da177e4 LT	163	return -ENOMEM;
1da177e4	164
6d1d1698 AC	165	/* --1: Tell the modem to initialize (we think) From sniffs this is
	166	* always the first thing that gets sent to the modem during
	167	* opening of the device */
	168	dbg("%s: Sending SIO_INIT (we guess)", __func__);
	169	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
	170	IPW_SIO_INIT,
	171	USB_TYPE_VENDOR \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
	172	0,
	173	0, /* index */
	174	NULL,
	175	0,
	176	100000);
1da177e4	177	if (result < 0)
6d1d1698 AC	178	dev_err(&port->dev,
6d1d1698 AC	179	"Init of modem failed (error = %d)\n", result);
1da177e4 LT	180
1da177e4 LT	181	/* reset the bulk pipes */
6d1d1698 AC	182	usb_clear_halt(dev,
	183	usb_rcvbulkpipe(dev, port->bulk_in_endpointAddress));
	184	usb_clear_halt(dev,
	185	usb_sndbulkpipe(dev, port->bulk_out_endpointAddress));
1da177e4	186
6d1d1698 AC	187	/--2: Start reading from the device /
6d1d1698 AC	188	dbg("%s: setting up bulk read callback", __func__);
53e77df2	189	usb_wwan_open(tty, port);
1da177e4 LT	190
1da177e4 LT	191	/--3: Tell the modem to open the floodgates on the rx bulk channel /
6d1d1698	192	dbg("%s:asking modem for RxRead (RXBULK_ON)", __func__);
1da177e4	193	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
6d1d1698 AC	194	IPW_SIO_RXCTL,
	195	USB_TYPE_VENDOR \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
	196	IPW_RXBULK_ON,
	197	0, /* index */
	198	NULL,
	199	0,
	200	100000);
	201	if (result < 0)
	202	dev_err(&port->dev,
	203	"Enabling bulk RxRead failed (error = %d)\n", result);
1da177e4 LT	204
1da177e4 LT	205	/--4: setup the initial flowcontrol /
6d1d1698	206	dbg("%s:setting init flowcontrol (%s)", __func__, buf_flow_init);
1da177e4	207	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
6d1d1698 AC	208	IPW_SIO_HANDFLOW,
	209	USB_TYPE_VENDOR \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
	210	0,
	211	0,
	212	buf_flow_init,
	213	0x10,
	214	200000);
1da177e4	215	if (result < 0)
6d1d1698 AC	216	dev_err(&port->dev,
6d1d1698 AC	217	"initial flowcontrol failed (error = %d)\n", result);
1da177e4	218
1da177e4 LT	219	kfree(buf_flow_init);
	220	return 0;
	221	}
	222
53e77df2 ON	223	/* fake probe - only to allocate data structures */
	224	static int ipw_probe(struct usb_serial serial, const struct usb_device_id id)
	225	{
	226	struct usb_wwan_intf_private *data;
	227
	228	data = kzalloc(sizeof(struct usb_wwan_intf_private), GFP_KERNEL);
	229	if (!data)
	230	return -ENOMEM;
	231
	232	spin_lock_init(&data->susp_lock);
	233	usb_set_serial_data(serial, data);
	234	return 0;
	235	}
	236
	237	static void ipw_release(struct usb_serial *serial)
	238	{
	239	struct usb_wwan_intf_private *data = usb_get_serial_data(serial);
	240
	241	usb_wwan_release(serial);
	242	usb_set_serial_data(serial, NULL);
	243	kfree(data);
	244	}
	245
335f8514	246	static void ipw_dtr_rts(struct usb_serial_port *port, int on)
1da177e4 LT	247	{
	248	struct usb_device *dev = port->serial->dev;
	249	int result;
	250
605204bf JH	251	dbg("%s: on = %d", __func__, on);
605204bf JH	252
1da177e4	253	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
6d1d1698 AC	254	IPW_SIO_SET_PIN,
6d1d1698 AC	255	USB_TYPE_VENDOR \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
335f8514	256	on ? IPW_PIN_SETDTR : IPW_PIN_CLRDTR,
6d1d1698 AC	257	0,
	258	NULL,
	259	0,
	260	200000);
1da177e4	261	if (result < 0)
605204bf	262	dev_err(&port->dev, "setting dtr failed (error = %d)\n",
6d1d1698	263	result);
1da177e4	264
1da177e4	265	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
6d1d1698	266	IPW_SIO_SET_PIN, USB_TYPE_VENDOR \|
605204bf	267	USB_RECIP_INTERFACE \| USB_DIR_OUT,
335f8514	268	on ? IPW_PIN_SETRTS : IPW_PIN_CLRRTS,
6d1d1698 AC	269	0,
	270	NULL,
	271	0,
	272	200000);
1da177e4	273	if (result < 0)
605204bf JH	274	dev_err(&port->dev, "setting rts failed (error = %d)\n",
605204bf JH	275	result);
335f8514	276	}
1da177e4	277
335f8514 AC	278	static void ipw_close(struct usb_serial_port *port)
	279	{
	280	struct usb_device *dev = port->serial->dev;
	281	int result;
1da177e4 LT	282
1da177e4 LT	283	/--3: purge /
6d1d1698	284	dbg("%s:sending purge", __func__);
1da177e4	285	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
6d1d1698 AC	286	IPW_SIO_PURGE, USB_TYPE_VENDOR \|
	287	USB_RECIP_INTERFACE \| USB_DIR_OUT,
	288	0x03,
	289	0,
	290	NULL,
	291	0,
	292	200000);
1da177e4	293	if (result < 0)
898eb71c	294	dev_err(&port->dev, "purge failed (error = %d)\n", result);
1da177e4 LT	295
1da177e4 LT	296
6d1d1698 AC	297	/* send RXBULK_off (tell modem to stop transmitting bulk data on
6d1d1698 AC	298	rx chan) */
1da177e4	299	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
6d1d1698 AC	300	IPW_SIO_RXCTL,
	301	USB_TYPE_VENDOR \| USB_RECIP_INTERFACE \| USB_DIR_OUT,
	302	IPW_RXBULK_OFF,
	303	0, /* index */
	304	NULL,
	305	0,
	306	100000);
1da177e4 LT	307
1da177e4 LT	308	if (result < 0)
6d1d1698 AC	309	dev_err(&port->dev,
6d1d1698 AC	310	"Disabling bulk RxRead failed (error = %d)\n", result);
1da177e4	311
53e77df2	312	usb_wwan_close(port);
6d1d1698	313	}
1da177e4	314
ea65370d	315	static struct usb_serial_driver ipw_device = {
18fcac35 GKH	316	.driver = {
18fcac35 GKH	317	.owner = THIS_MODULE,
269bda1c	318	.name = "ipw",
18fcac35	319	},
269bda1c	320	.description = "IPWireless converter",
b2c57379	321	.usb_driver = &usb_ipw_driver,
1da177e4	322	.id_table = usb_ipw_ids,
1da177e4	323	.num_ports = 1,
53e77df2	324	.disconnect = usb_wwan_disconnect,
1da177e4 LT	325	.open = ipw_open,
1da177e4 LT	326	.close = ipw_close,
53e77df2 ON	327	.probe = ipw_probe,
	328	.attach = usb_wwan_startup,
	329	.release = ipw_release,
335f8514	330	.dtr_rts = ipw_dtr_rts,
53e77df2	331	.write = usb_wwan_write,
1da177e4 LT	332	};
	333
	334
	335
5e5b0e5d	336	static int __init usb_ipw_init(void)
1da177e4 LT	337	{
	338	int retval;
	339
	340	retval = usb_serial_register(&ipw_device);
	341	if (retval)
	342	return retval;
	343	retval = usb_register(&usb_ipw_driver);
	344	if (retval) {
	345	usb_serial_deregister(&ipw_device);
	346	return retval;
	347	}
c197a8db GKH	348	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
c197a8db GKH	349	DRIVER_DESC "\n");
1da177e4 LT	350	return 0;
	351	}
	352
5e5b0e5d	353	static void __exit usb_ipw_exit(void)
1da177e4 LT	354	{
	355	usb_deregister(&usb_ipw_driver);
	356	usb_serial_deregister(&ipw_device);
	357	}
	358
	359	module_init(usb_ipw_init);
	360	module_exit(usb_ipw_exit);
	361
	362	/* Module information */
6d1d1698 AC	363	MODULE_AUTHOR(DRIVER_AUTHOR);
6d1d1698 AC	364	MODULE_DESCRIPTION(DRIVER_DESC);
1da177e4 LT	365	MODULE_LICENSE("GPL");
	366
	367	module_param(debug, bool, S_IRUGO \| S_IWUSR);
	368	MODULE_PARM_DESC(debug, "Debug enabled or not");