2006-03-26 02:38:37 -07:00
|
|
|
/*
|
|
|
|
* USB driver for Gigaset 307x directly or using M105 Data.
|
|
|
|
*
|
2006-04-10 23:55:14 -06:00
|
|
|
* Copyright (c) 2001 by Stefan Eilers
|
2006-03-26 02:38:37 -07:00
|
|
|
* and Hansjoerg Lipp <hjlipp@web.de>.
|
|
|
|
*
|
|
|
|
* This driver was derived from the USB skeleton driver by
|
|
|
|
* 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.
|
|
|
|
* =====================================================================
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "gigaset.h"
|
|
|
|
#include <linux/usb.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
|
|
|
|
/* Version Information */
|
2006-04-10 23:55:14 -06:00
|
|
|
#define DRIVER_AUTHOR "Hansjoerg Lipp <hjlipp@web.de>, Stefan Eilers"
|
2006-03-26 02:38:37 -07:00
|
|
|
#define DRIVER_DESC "USB Driver for Gigaset 307x using M105"
|
|
|
|
|
|
|
|
/* Module parameters */
|
|
|
|
|
|
|
|
static int startmode = SM_ISDN;
|
|
|
|
static int cidmode = 1;
|
|
|
|
|
|
|
|
module_param(startmode, int, S_IRUGO);
|
|
|
|
module_param(cidmode, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(startmode, "start in isdn4linux mode");
|
|
|
|
MODULE_PARM_DESC(cidmode, "Call-ID mode");
|
|
|
|
|
|
|
|
#define GIGASET_MINORS 1
|
|
|
|
#define GIGASET_MINOR 8
|
|
|
|
#define GIGASET_MODULENAME "usb_gigaset"
|
|
|
|
#define GIGASET_DEVNAME "ttyGU"
|
|
|
|
|
2010-07-05 08:18:37 -06:00
|
|
|
/* length limit according to Siemens 3070usb-protokoll.doc ch. 2.1 */
|
|
|
|
#define IF_WRITEBUF 264
|
2006-03-26 02:38:37 -07:00
|
|
|
|
|
|
|
/* Values for the Gigaset M105 Data */
|
|
|
|
#define USB_M105_VENDOR_ID 0x0681
|
|
|
|
#define USB_M105_PRODUCT_ID 0x0009
|
|
|
|
|
|
|
|
/* table of devices that work with this driver */
|
2009-10-25 03:30:07 -06:00
|
|
|
static const struct usb_device_id gigaset_table[] = {
|
2006-03-26 02:38:37 -07:00
|
|
|
{ USB_DEVICE(USB_M105_VENDOR_ID, USB_M105_PRODUCT_ID) },
|
|
|
|
{ } /* Terminating entry */
|
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(usb, gigaset_table);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Control requests (empty fields: 00)
|
|
|
|
*
|
|
|
|
* RT|RQ|VALUE|INDEX|LEN |DATA
|
|
|
|
* In:
|
|
|
|
* C1 08 01
|
|
|
|
* Get flags (1 byte). Bits: 0=dtr,1=rts,3-7:?
|
|
|
|
* C1 0F ll ll
|
|
|
|
* Get device information/status (llll: 0x200 and 0x40 seen).
|
|
|
|
* Real size: I only saw MIN(llll,0x64).
|
|
|
|
* Contents: seems to be always the same...
|
|
|
|
* offset 0x00: Length of this structure (0x64) (len: 1,2,3 bytes)
|
|
|
|
* offset 0x3c: String (16 bit chars): "MCCI USB Serial V2.0"
|
|
|
|
* rest: ?
|
|
|
|
* Out:
|
|
|
|
* 41 11
|
|
|
|
* Initialize/reset device ?
|
|
|
|
* 41 00 xx 00
|
|
|
|
* ? (xx=00 or 01; 01 on start, 00 on close)
|
|
|
|
* 41 07 vv mm
|
|
|
|
* Set/clear flags vv=value, mm=mask (see RQ 08)
|
|
|
|
* 41 12 xx
|
|
|
|
* Used before the following configuration requests are issued
|
|
|
|
* (with xx=0x0f). I've seen other values<0xf, though.
|
|
|
|
* 41 01 xx xx
|
|
|
|
* Set baud rate. xxxx=ceil(0x384000/rate)=trunc(0x383fff/rate)+1.
|
|
|
|
* 41 03 ps bb
|
|
|
|
* Set byte size and parity. p: 0x20=even,0x10=odd,0x00=no parity
|
|
|
|
* [ 0x30: m, 0x40: s ]
|
|
|
|
* [s: 0: 1 stop bit; 1: 1.5; 2: 2]
|
|
|
|
* bb: bits/byte (seen 7 and 8)
|
|
|
|
* 41 13 -- -- -- -- 10 00 ww 00 00 00 xx 00 00 00 yy 00 00 00 zz 00 00 00
|
|
|
|
* ??
|
|
|
|
* Initialization: 01, 40, 00, 00
|
|
|
|
* Open device: 00 40, 00, 00
|
|
|
|
* yy and zz seem to be equal, either 0x00 or 0x0a
|
|
|
|
* (ww,xx) pairs seen: (00,00), (00,40), (01,40), (09,80), (19,80)
|
|
|
|
* 41 19 -- -- -- -- 06 00 00 00 00 xx 11 13
|
|
|
|
* Used after every "configuration sequence" (RQ 12, RQs 01/03/13).
|
|
|
|
* xx is usually 0x00 but was 0x7e before starting data transfer
|
2009-10-25 03:30:07 -06:00
|
|
|
* in unimodem mode. So, this might be an array of characters that
|
|
|
|
* need special treatment ("commit all bufferd data"?), 11=^Q, 13=^S.
|
2006-03-26 02:38:37 -07:00
|
|
|
*
|
|
|
|
* Unimodem mode: use "modprobe ppp_async flag_time=0" as the device _needs_ two
|
|
|
|
* flags per packet.
|
|
|
|
*/
|
|
|
|
|
2008-02-06 02:38:24 -07:00
|
|
|
/* functions called if a device of this driver is connected/disconnected */
|
2006-03-26 02:38:37 -07:00
|
|
|
static int gigaset_probe(struct usb_interface *interface,
|
2006-04-10 23:55:04 -06:00
|
|
|
const struct usb_device_id *id);
|
2006-03-26 02:38:37 -07:00
|
|
|
static void gigaset_disconnect(struct usb_interface *interface);
|
|
|
|
|
2008-02-06 02:38:27 -07:00
|
|
|
/* functions called before/after suspend */
|
|
|
|
static int gigaset_suspend(struct usb_interface *intf, pm_message_t message);
|
|
|
|
static int gigaset_resume(struct usb_interface *intf);
|
|
|
|
static int gigaset_pre_reset(struct usb_interface *intf);
|
|
|
|
|
2009-10-25 03:30:07 -06:00
|
|
|
static struct gigaset_driver *driver;
|
2006-03-26 02:38:37 -07:00
|
|
|
|
|
|
|
/* usb specific object needed to register this driver with the usb subsystem */
|
|
|
|
static struct usb_driver gigaset_usb_driver = {
|
2006-04-10 23:55:00 -06:00
|
|
|
.name = GIGASET_MODULENAME,
|
|
|
|
.probe = gigaset_probe,
|
|
|
|
.disconnect = gigaset_disconnect,
|
|
|
|
.id_table = gigaset_table,
|
2008-02-06 02:38:27 -07:00
|
|
|
.suspend = gigaset_suspend,
|
|
|
|
.resume = gigaset_resume,
|
|
|
|
.reset_resume = gigaset_resume,
|
|
|
|
.pre_reset = gigaset_pre_reset,
|
|
|
|
.post_reset = gigaset_resume,
|
2012-04-23 11:08:51 -06:00
|
|
|
.disable_hub_initiated_lpm = 1,
|
2006-03-26 02:38:37 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct usb_cardstate {
|
2006-04-10 23:55:00 -06:00
|
|
|
struct usb_device *udev; /* usb device pointer */
|
|
|
|
struct usb_interface *interface; /* interface for this device */
|
2008-02-06 02:38:28 -07:00
|
|
|
int busy; /* bulk output in progress */
|
2006-04-10 23:55:00 -06:00
|
|
|
|
|
|
|
/* Output buffer */
|
2006-04-10 23:55:04 -06:00
|
|
|
unsigned char *bulk_out_buffer;
|
|
|
|
int bulk_out_size;
|
2014-10-03 09:03:32 -06:00
|
|
|
int bulk_out_epnum;
|
2006-04-10 23:55:04 -06:00
|
|
|
struct urb *bulk_out_urb;
|
2006-04-10 23:55:00 -06:00
|
|
|
|
|
|
|
/* Input buffer */
|
2009-10-25 03:30:07 -06:00
|
|
|
unsigned char *rcvbuf;
|
2006-04-10 23:55:04 -06:00
|
|
|
int rcvbuf_size;
|
|
|
|
struct urb *read_urb;
|
2006-04-10 23:55:00 -06:00
|
|
|
|
2006-04-10 23:55:04 -06:00
|
|
|
char bchars[6]; /* for request 0x19 */
|
2006-03-26 02:38:37 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline unsigned tiocm_to_gigaset(unsigned state)
|
|
|
|
{
|
|
|
|
return ((state & TIOCM_DTR) ? 1 : 0) | ((state & TIOCM_RTS) ? 2 : 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state,
|
2006-04-10 23:55:04 -06:00
|
|
|
unsigned new_state)
|
2006-03-26 02:38:37 -07:00
|
|
|
{
|
2006-04-10 23:55:04 -06:00
|
|
|
struct usb_device *udev = cs->hw.usb->udev;
|
2006-03-26 02:38:37 -07:00
|
|
|
unsigned mask, val;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
mask = tiocm_to_gigaset(old_state ^ new_state);
|
|
|
|
val = tiocm_to_gigaset(new_state);
|
|
|
|
|
2006-04-10 23:55:04 -06:00
|
|
|
gig_dbg(DEBUG_USBREQ, "set flags 0x%02x with mask 0x%02x", val, mask);
|
|
|
|
r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 7, 0x41,
|
|
|
|
(val & 0xff) | ((mask & 0xff) << 8), 0,
|
|
|
|
NULL, 0, 2000 /* timeout? */);
|
2006-03-26 02:38:37 -07:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-13 06:44:18 -06:00
|
|
|
/*
|
|
|
|
* Set M105 configuration value
|
|
|
|
* using undocumented device commands reverse engineered from USB traces
|
|
|
|
* of the Siemens Windows driver
|
|
|
|
*/
|
2006-03-26 02:38:37 -07:00
|
|
|
static int set_value(struct cardstate *cs, u8 req, u16 val)
|
|
|
|
{
|
2006-04-10 23:55:04 -06:00
|
|
|
struct usb_device *udev = cs->hw.usb->udev;
|
2006-03-26 02:38:37 -07:00
|
|
|
int r, r2;
|
|
|
|
|
2006-04-10 23:55:04 -06:00
|
|
|
gig_dbg(DEBUG_USBREQ, "request %02x (%04x)",
|
|
|
|
(unsigned)req, (unsigned)val);
|
|
|
|
r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x12, 0x41,
|
|
|
|
0xf /*?*/, 0, NULL, 0, 2000 /*?*/);
|
2012-02-19 20:52:38 -07:00
|
|
|
/* no idea what this does */
|
2006-03-26 02:38:37 -07:00
|
|
|
if (r < 0) {
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_err(&udev->dev, "error %d on request 0x12\n", -r);
|
2006-03-26 02:38:37 -07:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2006-04-10 23:55:04 -06:00
|
|
|
r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), req, 0x41,
|
|
|
|
val, 0, NULL, 0, 2000 /*?*/);
|
2006-03-26 02:38:37 -07:00
|
|
|
if (r < 0)
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_err(&udev->dev, "error %d on request 0x%02x\n",
|
|
|
|
-r, (unsigned)req);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2006-04-10 23:55:04 -06:00
|
|
|
r2 = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x19, 0x41,
|
|
|
|
0, 0, cs->hw.usb->bchars, 6, 2000 /*?*/);
|
2006-03-26 02:38:37 -07:00
|
|
|
if (r2 < 0)
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_err(&udev->dev, "error %d on request 0x19\n", -r2);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
|
|
|
return r < 0 ? r : (r2 < 0 ? r2 : 0);
|
|
|
|
}
|
|
|
|
|
2009-05-13 06:44:18 -06:00
|
|
|
/*
|
|
|
|
* set the baud rate on the internal serial adapter
|
|
|
|
* using the undocumented parameter setting command
|
|
|
|
*/
|
2006-03-26 02:38:37 -07:00
|
|
|
static int gigaset_baud_rate(struct cardstate *cs, unsigned cflag)
|
|
|
|
{
|
|
|
|
u16 val;
|
|
|
|
u32 rate;
|
|
|
|
|
|
|
|
cflag &= CBAUD;
|
|
|
|
|
|
|
|
switch (cflag) {
|
|
|
|
case B300: rate = 300; break;
|
|
|
|
case B600: rate = 600; break;
|
|
|
|
case B1200: rate = 1200; break;
|
|
|
|
case B2400: rate = 2400; break;
|
|
|
|
case B4800: rate = 4800; break;
|
|
|
|
case B9600: rate = 9600; break;
|
|
|
|
case B19200: rate = 19200; break;
|
|
|
|
case B38400: rate = 38400; break;
|
|
|
|
case B57600: rate = 57600; break;
|
|
|
|
case B115200: rate = 115200; break;
|
|
|
|
default:
|
|
|
|
rate = 9600;
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_err(cs->dev, "unsupported baudrate request 0x%x,"
|
|
|
|
" using default of B9600\n", cflag);
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
val = 0x383fff / rate + 1;
|
|
|
|
|
|
|
|
return set_value(cs, 1, val);
|
|
|
|
}
|
|
|
|
|
2009-05-13 06:44:18 -06:00
|
|
|
/*
|
|
|
|
* set the line format on the internal serial adapter
|
|
|
|
* using the undocumented parameter setting command
|
|
|
|
*/
|
2006-03-26 02:38:37 -07:00
|
|
|
static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag)
|
|
|
|
{
|
|
|
|
u16 val = 0;
|
|
|
|
|
|
|
|
/* set the parity */
|
|
|
|
if (cflag & PARENB)
|
|
|
|
val |= (cflag & PARODD) ? 0x10 : 0x20;
|
|
|
|
|
|
|
|
/* set the number of data bits */
|
|
|
|
switch (cflag & CSIZE) {
|
|
|
|
case CS5:
|
|
|
|
val |= 5 << 8; break;
|
|
|
|
case CS6:
|
|
|
|
val |= 6 << 8; break;
|
|
|
|
case CS7:
|
|
|
|
val |= 7 << 8; break;
|
|
|
|
case CS8:
|
|
|
|
val |= 8 << 8; break;
|
|
|
|
default:
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_err(cs->dev, "CSIZE was not CS5-CS8, using default of 8\n");
|
2006-03-26 02:38:37 -07:00
|
|
|
val |= 8 << 8;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set the number of stop bits */
|
|
|
|
if (cflag & CSTOPB) {
|
|
|
|
if ((cflag & CSIZE) == CS5)
|
2009-10-25 03:30:07 -06:00
|
|
|
val |= 1; /* 1.5 stop bits */
|
2006-03-26 02:38:37 -07:00
|
|
|
else
|
|
|
|
val |= 2; /* 2 stop bits */
|
|
|
|
}
|
|
|
|
|
|
|
|
return set_value(cs, 3, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-25 03:30:07 -06:00
|
|
|
/*============================================================================*/
|
2006-03-26 02:38:37 -07:00
|
|
|
static int gigaset_init_bchannel(struct bc_state *bcs)
|
|
|
|
{
|
|
|
|
/* nothing to do for M10x */
|
|
|
|
gigaset_bchannel_up(bcs);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gigaset_close_bchannel(struct bc_state *bcs)
|
|
|
|
{
|
|
|
|
/* nothing to do for M10x */
|
|
|
|
gigaset_bchannel_down(bcs);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int write_modem(struct cardstate *cs);
|
2014-12-10 05:41:55 -07:00
|
|
|
static int send_cb(struct cardstate *cs);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
|
|
|
|
2006-04-10 23:55:00 -06:00
|
|
|
/* Write tasklet handler: Continue sending current skb, or send command, or
|
|
|
|
* start sending an skb from the send queue.
|
2006-03-26 02:38:37 -07:00
|
|
|
*/
|
|
|
|
static void gigaset_modem_fill(unsigned long data)
|
|
|
|
{
|
|
|
|
struct cardstate *cs = (struct cardstate *) data;
|
|
|
|
struct bc_state *bcs = &cs->bcs[0]; /* only one channel */
|
|
|
|
|
2006-04-10 23:55:04 -06:00
|
|
|
gig_dbg(DEBUG_OUTPUT, "modem_fill");
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2008-02-06 02:38:28 -07:00
|
|
|
if (cs->hw.usb->busy) {
|
2006-04-10 23:55:04 -06:00
|
|
|
gig_dbg(DEBUG_OUTPUT, "modem_fill: busy");
|
2006-03-26 02:38:37 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-12-10 05:41:55 -07:00
|
|
|
again:
|
|
|
|
if (!bcs->tx_skb) { /* no skb is being sent */
|
2014-12-10 05:41:55 -07:00
|
|
|
if (cs->cmdbuf) { /* commands to send? */
|
2014-12-10 05:41:55 -07:00
|
|
|
gig_dbg(DEBUG_OUTPUT, "modem_fill: cb");
|
2014-12-10 05:41:55 -07:00
|
|
|
if (send_cb(cs) < 0) {
|
2006-04-10 23:55:04 -06:00
|
|
|
gig_dbg(DEBUG_OUTPUT,
|
2014-12-10 05:41:55 -07:00
|
|
|
"modem_fill: send_cb failed");
|
|
|
|
goto again; /* no callback will be called! */
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
2014-12-10 05:41:55 -07:00
|
|
|
return;
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
2014-12-10 05:41:55 -07:00
|
|
|
|
|
|
|
/* skbs to send? */
|
|
|
|
bcs->tx_skb = skb_dequeue(&bcs->squeue);
|
|
|
|
if (!bcs->tx_skb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
gig_dbg(DEBUG_INTR, "Dequeued skb (Adr: %lx)!",
|
|
|
|
(unsigned long) bcs->tx_skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
gig_dbg(DEBUG_OUTPUT, "modem_fill: tx_skb");
|
|
|
|
if (write_modem(cs) < 0) {
|
|
|
|
gig_dbg(DEBUG_OUTPUT, "modem_fill: write_modem failed");
|
|
|
|
goto again; /* no callback will be called! */
|
|
|
|
}
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
|
2009-05-13 06:44:18 -06:00
|
|
|
/*
|
|
|
|
* Interrupt Input URB completion routine
|
2006-03-26 02:38:37 -07:00
|
|
|
*/
|
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 07:55:46 -06:00
|
|
|
static void gigaset_read_int_callback(struct urb *urb)
|
2006-03-26 02:38:37 -07:00
|
|
|
{
|
2009-10-25 03:30:07 -06:00
|
|
|
struct cardstate *cs = urb->context;
|
|
|
|
struct inbuf_t *inbuf = cs->inbuf;
|
2008-02-06 02:38:23 -07:00
|
|
|
int status = urb->status;
|
2006-03-26 02:38:37 -07:00
|
|
|
int r;
|
|
|
|
unsigned numbytes;
|
|
|
|
unsigned char *src;
|
2006-04-10 23:55:16 -06:00
|
|
|
unsigned long flags;
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2008-02-06 02:38:23 -07:00
|
|
|
if (!status) {
|
2006-03-26 02:38:37 -07:00
|
|
|
numbytes = urb->actual_length;
|
|
|
|
|
|
|
|
if (numbytes) {
|
2009-10-25 03:30:07 -06:00
|
|
|
src = cs->hw.usb->rcvbuf;
|
2006-03-26 02:38:37 -07:00
|
|
|
if (unlikely(*src))
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_warn(cs->dev,
|
2012-02-19 20:52:38 -07:00
|
|
|
"%s: There was no leading 0, but 0x%02x!\n",
|
2006-04-10 23:55:04 -06:00
|
|
|
__func__, (unsigned) *src);
|
2006-03-26 02:38:37 -07:00
|
|
|
++src; /* skip leading 0x00 */
|
|
|
|
--numbytes;
|
|
|
|
if (gigaset_fill_inbuf(inbuf, src, numbytes)) {
|
2006-04-10 23:55:04 -06:00
|
|
|
gig_dbg(DEBUG_INTR, "%s-->BH", __func__);
|
2006-03-26 02:38:37 -07:00
|
|
|
gigaset_schedule_event(inbuf->cs);
|
|
|
|
}
|
|
|
|
} else
|
2006-04-10 23:55:04 -06:00
|
|
|
gig_dbg(DEBUG_INTR, "Received zero block length");
|
2006-03-26 02:38:37 -07:00
|
|
|
} else {
|
|
|
|
/* The urb might have been killed. */
|
2008-02-06 02:38:24 -07:00
|
|
|
gig_dbg(DEBUG_ANY, "%s - nonzero status received: %d",
|
2008-02-06 02:38:23 -07:00
|
|
|
__func__, status);
|
2008-02-06 02:38:24 -07:00
|
|
|
if (status == -ENOENT || status == -ESHUTDOWN)
|
|
|
|
/* killed or endpoint shutdown: don't resubmit */
|
|
|
|
return;
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
2006-04-10 23:55:04 -06:00
|
|
|
|
2008-02-06 02:38:24 -07:00
|
|
|
/* resubmit URB */
|
|
|
|
spin_lock_irqsave(&cs->lock, flags);
|
|
|
|
if (!cs->connected) {
|
2006-04-10 23:55:16 -06:00
|
|
|
spin_unlock_irqrestore(&cs->lock, flags);
|
2008-12-26 02:21:29 -07:00
|
|
|
pr_err("%s: disconnected\n", __func__);
|
2008-02-06 02:38:24 -07:00
|
|
|
return;
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
2008-02-06 02:38:24 -07:00
|
|
|
r = usb_submit_urb(urb, GFP_ATOMIC);
|
|
|
|
spin_unlock_irqrestore(&cs->lock, flags);
|
|
|
|
if (r)
|
|
|
|
dev_err(cs->dev, "error %d resubmitting URB\n", -r);
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-04-10 23:55:00 -06:00
|
|
|
/* This callback routine is called when data was transmitted to the device. */
|
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 07:55:46 -06:00
|
|
|
static void gigaset_write_bulk_callback(struct urb *urb)
|
2006-03-26 02:38:37 -07:00
|
|
|
{
|
2006-04-10 23:55:08 -06:00
|
|
|
struct cardstate *cs = urb->context;
|
2008-02-06 02:38:23 -07:00
|
|
|
int status = urb->status;
|
2006-04-10 23:55:16 -06:00
|
|
|
unsigned long flags;
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2008-02-06 02:38:24 -07:00
|
|
|
switch (status) {
|
|
|
|
case 0: /* normal completion */
|
|
|
|
break;
|
|
|
|
case -ENOENT: /* killed */
|
|
|
|
gig_dbg(DEBUG_ANY, "%s: killed", __func__);
|
2008-02-06 02:38:28 -07:00
|
|
|
cs->hw.usb->busy = 0;
|
2008-02-06 02:38:24 -07:00
|
|
|
return;
|
|
|
|
default:
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_err(cs->dev, "bulk transfer failed (status %d)\n",
|
2008-02-06 02:38:23 -07:00
|
|
|
-status);
|
2006-04-10 23:55:00 -06:00
|
|
|
/* That's all we can do. Communication problems
|
2006-04-10 23:55:04 -06:00
|
|
|
are handled by timeouts or network protocols. */
|
2008-02-06 02:38:24 -07:00
|
|
|
}
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2006-04-10 23:55:16 -06:00
|
|
|
spin_lock_irqsave(&cs->lock, flags);
|
|
|
|
if (!cs->connected) {
|
2008-12-26 02:21:29 -07:00
|
|
|
pr_err("%s: disconnected\n", __func__);
|
2006-04-10 23:55:16 -06:00
|
|
|
} else {
|
2008-02-06 02:38:28 -07:00
|
|
|
cs->hw.usb->busy = 0;
|
2006-04-10 23:55:16 -06:00
|
|
|
tasklet_schedule(&cs->write_tasklet);
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&cs->lock, flags);
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
|
2014-12-10 05:41:55 -07:00
|
|
|
static int send_cb(struct cardstate *cs)
|
2006-03-26 02:38:37 -07:00
|
|
|
{
|
2014-12-10 05:41:55 -07:00
|
|
|
struct cmdbuf_t *cb = cs->cmdbuf;
|
2006-03-26 02:38:37 -07:00
|
|
|
unsigned long flags;
|
|
|
|
int count;
|
2009-10-25 03:30:07 -06:00
|
|
|
int status = -ENOENT;
|
2006-03-26 02:38:37 -07:00
|
|
|
struct usb_cardstate *ucs = cs->hw.usb;
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (!cb->len) {
|
|
|
|
spin_lock_irqsave(&cs->cmdlock, flags);
|
|
|
|
cs->cmdbytes -= cs->curlen;
|
2006-04-10 23:55:04 -06:00
|
|
|
gig_dbg(DEBUG_OUTPUT, "send_cb: sent %u bytes, %u left",
|
|
|
|
cs->curlen, cs->cmdbytes);
|
2014-12-10 05:41:55 -07:00
|
|
|
cs->cmdbuf = cb->next;
|
|
|
|
if (cs->cmdbuf) {
|
|
|
|
cs->cmdbuf->prev = NULL;
|
|
|
|
cs->curlen = cs->cmdbuf->len;
|
2006-03-26 02:38:37 -07:00
|
|
|
} else {
|
|
|
|
cs->lastcmdbuf = NULL;
|
|
|
|
cs->curlen = 0;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&cs->cmdlock, flags);
|
|
|
|
|
2014-12-10 05:41:55 -07:00
|
|
|
if (cb->wake_tasklet)
|
|
|
|
tasklet_schedule(cb->wake_tasklet);
|
|
|
|
kfree(cb);
|
|
|
|
|
|
|
|
cb = cs->cmdbuf;
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
2014-12-10 05:41:55 -07:00
|
|
|
|
2006-03-26 02:38:37 -07:00
|
|
|
if (cb) {
|
|
|
|
count = min(cb->len, ucs->bulk_out_size);
|
2006-04-10 23:55:16 -06:00
|
|
|
gig_dbg(DEBUG_OUTPUT, "send_cb: send %d bytes", count);
|
|
|
|
|
2006-03-26 02:38:37 -07:00
|
|
|
usb_fill_bulk_urb(ucs->bulk_out_urb, ucs->udev,
|
2006-04-10 23:55:04 -06:00
|
|
|
usb_sndbulkpipe(ucs->udev,
|
2014-10-03 09:03:32 -06:00
|
|
|
ucs->bulk_out_epnum),
|
2006-04-10 23:55:04 -06:00
|
|
|
cb->buf + cb->offset, count,
|
|
|
|
gigaset_write_bulk_callback, cs);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
|
|
|
cb->offset += count;
|
|
|
|
cb->len -= count;
|
2008-02-06 02:38:28 -07:00
|
|
|
ucs->busy = 1;
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2006-04-10 23:55:16 -06:00
|
|
|
spin_lock_irqsave(&cs->lock, flags);
|
2009-10-25 03:30:07 -06:00
|
|
|
status = cs->connected ?
|
|
|
|
usb_submit_urb(ucs->bulk_out_urb, GFP_ATOMIC) :
|
|
|
|
-ENODEV;
|
2006-04-10 23:55:16 -06:00
|
|
|
spin_unlock_irqrestore(&cs->lock, flags);
|
|
|
|
|
2006-03-26 02:38:37 -07:00
|
|
|
if (status) {
|
2008-02-06 02:38:28 -07:00
|
|
|
ucs->busy = 0;
|
2008-07-23 22:28:27 -06:00
|
|
|
dev_err(cs->dev,
|
|
|
|
"could not submit urb (error %d)\n",
|
|
|
|
-status);
|
2006-04-10 23:55:00 -06:00
|
|
|
cb->len = 0; /* skip urb => remove cb+wakeup
|
|
|
|
in next loop cycle */
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
}
|
2006-04-10 23:55:00 -06:00
|
|
|
} while (cb && status); /* next command on error */
|
2006-03-26 02:38:37 -07:00
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-04-10 23:55:00 -06:00
|
|
|
/* Send command to device. */
|
2010-07-05 08:18:43 -06:00
|
|
|
static int gigaset_write_cmd(struct cardstate *cs, struct cmdbuf_t *cb)
|
2006-03-26 02:38:37 -07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2014-10-11 05:46:30 -06:00
|
|
|
int len;
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2008-02-06 02:38:28 -07:00
|
|
|
gigaset_dbg_buffer(cs->mstate != MS_LOCKED ?
|
2012-02-19 20:52:38 -07:00
|
|
|
DEBUG_TRANSCMD : DEBUG_LOCKCMD,
|
2010-07-05 08:18:43 -06:00
|
|
|
"CMD Transmit", cb->len, cb->buf);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&cs->cmdlock, flags);
|
|
|
|
cb->prev = cs->lastcmdbuf;
|
|
|
|
if (cs->lastcmdbuf)
|
|
|
|
cs->lastcmdbuf->next = cb;
|
|
|
|
else {
|
|
|
|
cs->cmdbuf = cb;
|
2010-07-05 08:18:43 -06:00
|
|
|
cs->curlen = cb->len;
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
2010-07-05 08:18:43 -06:00
|
|
|
cs->cmdbytes += cb->len;
|
2006-03-26 02:38:37 -07:00
|
|
|
cs->lastcmdbuf = cb;
|
|
|
|
spin_unlock_irqrestore(&cs->cmdlock, flags);
|
|
|
|
|
2006-04-10 23:55:16 -06:00
|
|
|
spin_lock_irqsave(&cs->lock, flags);
|
2014-10-11 05:46:30 -06:00
|
|
|
len = cb->len;
|
2006-04-10 23:55:16 -06:00
|
|
|
if (cs->connected)
|
|
|
|
tasklet_schedule(&cs->write_tasklet);
|
|
|
|
spin_unlock_irqrestore(&cs->lock, flags);
|
2014-10-11 05:46:30 -06:00
|
|
|
return len;
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int gigaset_write_room(struct cardstate *cs)
|
|
|
|
{
|
|
|
|
unsigned bytes;
|
|
|
|
|
|
|
|
bytes = cs->cmdbytes;
|
|
|
|
return bytes < IF_WRITEBUF ? IF_WRITEBUF - bytes : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gigaset_chars_in_buffer(struct cardstate *cs)
|
|
|
|
{
|
|
|
|
return cs->cmdbytes;
|
|
|
|
}
|
|
|
|
|
2009-05-13 06:44:18 -06:00
|
|
|
/*
|
|
|
|
* set the break characters on the internal serial adapter
|
|
|
|
* using undocumented device commands reverse engineered from USB traces
|
|
|
|
* of the Siemens Windows driver
|
|
|
|
*/
|
2006-03-26 02:38:37 -07:00
|
|
|
static int gigaset_brkchars(struct cardstate *cs, const unsigned char buf[6])
|
|
|
|
{
|
2006-04-10 23:55:04 -06:00
|
|
|
struct usb_device *udev = cs->hw.usb->udev;
|
|
|
|
|
2006-04-10 23:55:11 -06:00
|
|
|
gigaset_dbg_buffer(DEBUG_USBREQ, "brkchars", 6, buf);
|
2006-03-26 02:38:37 -07:00
|
|
|
memcpy(cs->hw.usb->bchars, buf, 6);
|
2006-04-10 23:55:04 -06:00
|
|
|
return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x19, 0x41,
|
|
|
|
0, 0, &buf, 6, 2000);
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
|
2012-04-25 07:02:20 -06:00
|
|
|
static void gigaset_freebcshw(struct bc_state *bcs)
|
2006-03-26 02:38:37 -07:00
|
|
|
{
|
2007-05-08 21:27:03 -06:00
|
|
|
/* unused */
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize the b-channel structure */
|
|
|
|
static int gigaset_initbcshw(struct bc_state *bcs)
|
|
|
|
{
|
2007-05-08 21:27:03 -06:00
|
|
|
/* unused */
|
|
|
|
bcs->hw.usb = NULL;
|
2012-04-25 07:02:20 -06:00
|
|
|
return 0;
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void gigaset_reinitbcshw(struct bc_state *bcs)
|
|
|
|
{
|
2007-05-08 21:27:03 -06:00
|
|
|
/* nothing to do for M10x */
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void gigaset_freecshw(struct cardstate *cs)
|
|
|
|
{
|
|
|
|
tasklet_kill(&cs->write_tasklet);
|
|
|
|
kfree(cs->hw.usb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gigaset_initcshw(struct cardstate *cs)
|
|
|
|
{
|
|
|
|
struct usb_cardstate *ucs;
|
|
|
|
|
|
|
|
cs->hw.usb = ucs =
|
|
|
|
kmalloc(sizeof(struct usb_cardstate), GFP_KERNEL);
|
2008-12-26 02:21:29 -07:00
|
|
|
if (!ucs) {
|
|
|
|
pr_err("out of memory\n");
|
2012-04-25 07:02:20 -06:00
|
|
|
return -ENOMEM;
|
2008-12-26 02:21:29 -07:00
|
|
|
}
|
2006-03-26 02:38:37 -07:00
|
|
|
|
|
|
|
ucs->bchars[0] = 0;
|
|
|
|
ucs->bchars[1] = 0;
|
|
|
|
ucs->bchars[2] = 0;
|
|
|
|
ucs->bchars[3] = 0;
|
|
|
|
ucs->bchars[4] = 0x11;
|
|
|
|
ucs->bchars[5] = 0x13;
|
|
|
|
ucs->bulk_out_buffer = NULL;
|
|
|
|
ucs->bulk_out_urb = NULL;
|
|
|
|
ucs->read_urb = NULL;
|
|
|
|
tasklet_init(&cs->write_tasklet,
|
2009-11-19 02:55:53 -07:00
|
|
|
gigaset_modem_fill, (unsigned long) cs);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2012-04-25 07:02:20 -06:00
|
|
|
return 0;
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
|
2006-04-10 23:55:00 -06:00
|
|
|
/* Send data from current skb to the device. */
|
2006-03-26 02:38:37 -07:00
|
|
|
static int write_modem(struct cardstate *cs)
|
|
|
|
{
|
2006-04-10 23:55:08 -06:00
|
|
|
int ret = 0;
|
2006-03-26 02:38:37 -07:00
|
|
|
int count;
|
|
|
|
struct bc_state *bcs = &cs->bcs[0]; /* only one channel */
|
|
|
|
struct usb_cardstate *ucs = cs->hw.usb;
|
2006-04-10 23:55:16 -06:00
|
|
|
unsigned long flags;
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2010-02-22 06:09:52 -07:00
|
|
|
gig_dbg(DEBUG_OUTPUT, "len: %d...", bcs->tx_skb->len);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
|
|
|
if (!bcs->tx_skb->len) {
|
|
|
|
dev_kfree_skb_any(bcs->tx_skb);
|
|
|
|
bcs->tx_skb = NULL;
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-10-25 03:30:07 -06:00
|
|
|
/* Copy data to bulk out buffer and transmit data */
|
2006-03-26 02:38:37 -07:00
|
|
|
count = min(bcs->tx_skb->len, (unsigned) ucs->bulk_out_size);
|
2007-03-27 15:55:52 -06:00
|
|
|
skb_copy_from_linear_data(bcs->tx_skb, ucs->bulk_out_buffer, count);
|
2006-03-26 02:38:37 -07:00
|
|
|
skb_pull(bcs->tx_skb, count);
|
2008-02-06 02:38:28 -07:00
|
|
|
ucs->busy = 1;
|
2006-04-10 23:55:04 -06:00
|
|
|
gig_dbg(DEBUG_OUTPUT, "write_modem: send %d bytes", count);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2006-04-10 23:55:16 -06:00
|
|
|
spin_lock_irqsave(&cs->lock, flags);
|
|
|
|
if (cs->connected) {
|
|
|
|
usb_fill_bulk_urb(ucs->bulk_out_urb, ucs->udev,
|
|
|
|
usb_sndbulkpipe(ucs->udev,
|
2014-10-03 09:03:32 -06:00
|
|
|
ucs->bulk_out_epnum),
|
2006-04-10 23:55:16 -06:00
|
|
|
ucs->bulk_out_buffer, count,
|
|
|
|
gigaset_write_bulk_callback, cs);
|
2006-12-06 21:33:16 -07:00
|
|
|
ret = usb_submit_urb(ucs->bulk_out_urb, GFP_ATOMIC);
|
2006-04-10 23:55:16 -06:00
|
|
|
} else {
|
|
|
|
ret = -ENODEV;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&cs->lock, flags);
|
|
|
|
|
2006-03-26 02:38:37 -07:00
|
|
|
if (ret) {
|
2008-07-23 22:28:27 -06:00
|
|
|
dev_err(cs->dev, "could not submit urb (error %d)\n", -ret);
|
2008-02-06 02:38:28 -07:00
|
|
|
ucs->busy = 0;
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
2006-04-10 23:55:16 -06:00
|
|
|
|
2006-03-26 02:38:37 -07:00
|
|
|
if (!bcs->tx_skb->len) {
|
|
|
|
/* skb sent completely */
|
2009-10-25 03:30:07 -06:00
|
|
|
gigaset_skb_sent(bcs, bcs->tx_skb);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2006-04-10 23:55:04 -06:00
|
|
|
gig_dbg(DEBUG_INTR, "kfree skb (Adr: %lx)!",
|
|
|
|
(unsigned long) bcs->tx_skb);
|
2006-03-26 02:38:37 -07:00
|
|
|
dev_kfree_skb_any(bcs->tx_skb);
|
|
|
|
bcs->tx_skb = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gigaset_probe(struct usb_interface *interface,
|
2006-04-10 23:55:04 -06:00
|
|
|
const struct usb_device_id *id)
|
2006-03-26 02:38:37 -07:00
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
struct usb_device *udev = interface_to_usbdev(interface);
|
2008-02-06 02:38:24 -07:00
|
|
|
struct usb_host_interface *hostif = interface->cur_altsetting;
|
2006-03-26 02:38:37 -07:00
|
|
|
struct cardstate *cs = NULL;
|
|
|
|
struct usb_cardstate *ucs = NULL;
|
|
|
|
struct usb_endpoint_descriptor *endpoint;
|
|
|
|
int buffer_size;
|
|
|
|
|
2008-02-06 02:38:24 -07:00
|
|
|
gig_dbg(DEBUG_ANY, "%s: Check if device matches ...", __func__);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
|
|
|
/* See if the device offered us matches what we can accept */
|
2006-05-15 10:44:35 -06:00
|
|
|
if ((le16_to_cpu(udev->descriptor.idVendor) != USB_M105_VENDOR_ID) ||
|
2008-02-06 02:38:24 -07:00
|
|
|
(le16_to_cpu(udev->descriptor.idProduct) != USB_M105_PRODUCT_ID)) {
|
|
|
|
gig_dbg(DEBUG_ANY, "device ID (0x%x, 0x%x) not for me - skip",
|
|
|
|
le16_to_cpu(udev->descriptor.idVendor),
|
|
|
|
le16_to_cpu(udev->descriptor.idProduct));
|
2006-03-26 02:38:37 -07:00
|
|
|
return -ENODEV;
|
2008-02-06 02:38:24 -07:00
|
|
|
}
|
|
|
|
if (hostif->desc.bInterfaceNumber != 0) {
|
|
|
|
gig_dbg(DEBUG_ANY, "interface %d not for me - skip",
|
|
|
|
hostif->desc.bInterfaceNumber);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
if (hostif->desc.bAlternateSetting != 0) {
|
|
|
|
dev_notice(&udev->dev, "unsupported altsetting %d - skip",
|
|
|
|
hostif->desc.bAlternateSetting);
|
2006-03-26 02:38:37 -07:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
if (hostif->desc.bInterfaceClass != 255) {
|
2008-02-06 02:38:24 -07:00
|
|
|
dev_notice(&udev->dev, "unsupported interface class %d - skip",
|
|
|
|
hostif->desc.bInterfaceClass);
|
2006-03-26 02:38:37 -07:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_info(&udev->dev, "%s: Device matched ... !\n", __func__);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
tree-wide: fix comment/printk typos
"gadget", "through", "command", "maintain", "maintain", "controller", "address",
"between", "initiali[zs]e", "instead", "function", "select", "already",
"equal", "access", "management", "hierarchy", "registration", "interest",
"relative", "memory", "offset", "already",
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2010-11-01 13:38:34 -06:00
|
|
|
/* allocate memory for our device state and initialize it */
|
2008-02-06 02:38:29 -07:00
|
|
|
cs = gigaset_initcs(driver, 1, 1, 0, cidmode, GIGASET_MODULENAME);
|
|
|
|
if (!cs)
|
2006-03-26 02:38:37 -07:00
|
|
|
return -ENODEV;
|
|
|
|
ucs = cs->hw.usb;
|
|
|
|
|
2006-04-10 23:55:04 -06:00
|
|
|
/* save off device structure ptrs for later use */
|
|
|
|
usb_get_dev(udev);
|
|
|
|
ucs->udev = udev;
|
|
|
|
ucs->interface = interface;
|
2006-04-10 23:55:07 -06:00
|
|
|
cs->dev = &interface->dev;
|
|
|
|
|
|
|
|
/* save address of controller structure */
|
2009-05-13 06:44:18 -06:00
|
|
|
usb_set_intfdata(interface, cs);
|
2006-04-10 23:55:04 -06:00
|
|
|
|
2006-03-26 02:38:37 -07:00
|
|
|
endpoint = &hostif->endpoint[0].desc;
|
|
|
|
|
|
|
|
buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
|
|
|
|
ucs->bulk_out_size = buffer_size;
|
2014-10-03 09:03:32 -06:00
|
|
|
ucs->bulk_out_epnum = usb_endpoint_num(endpoint);
|
2006-03-26 02:38:37 -07:00
|
|
|
ucs->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
|
|
|
|
if (!ucs->bulk_out_buffer) {
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_err(cs->dev, "Couldn't allocate bulk_out_buffer\n");
|
2006-03-26 02:38:37 -07:00
|
|
|
retval = -ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2006-12-06 21:33:17 -07:00
|
|
|
ucs->bulk_out_urb = usb_alloc_urb(0, GFP_KERNEL);
|
2006-03-26 02:38:37 -07:00
|
|
|
if (!ucs->bulk_out_urb) {
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_err(cs->dev, "Couldn't allocate bulk_out_urb\n");
|
2006-03-26 02:38:37 -07:00
|
|
|
retval = -ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
endpoint = &hostif->endpoint[1].desc;
|
|
|
|
|
2008-02-06 02:38:28 -07:00
|
|
|
ucs->busy = 0;
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2006-12-06 21:33:17 -07:00
|
|
|
ucs->read_urb = usb_alloc_urb(0, GFP_KERNEL);
|
2006-03-26 02:38:37 -07:00
|
|
|
if (!ucs->read_urb) {
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_err(cs->dev, "No free urbs available\n");
|
2006-03-26 02:38:37 -07:00
|
|
|
retval = -ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
|
|
|
|
ucs->rcvbuf_size = buffer_size;
|
2009-10-25 03:30:07 -06:00
|
|
|
ucs->rcvbuf = kmalloc(buffer_size, GFP_KERNEL);
|
|
|
|
if (!ucs->rcvbuf) {
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_err(cs->dev, "Couldn't allocate rcvbuf\n");
|
2006-03-26 02:38:37 -07:00
|
|
|
retval = -ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
/* Fill the interrupt urb and send it to the core */
|
|
|
|
usb_fill_int_urb(ucs->read_urb, udev,
|
2014-10-03 09:03:32 -06:00
|
|
|
usb_rcvintpipe(udev, usb_endpoint_num(endpoint)),
|
2009-10-25 03:30:07 -06:00
|
|
|
ucs->rcvbuf, buffer_size,
|
2006-04-10 23:55:04 -06:00
|
|
|
gigaset_read_int_callback,
|
2009-10-25 03:30:07 -06:00
|
|
|
cs, endpoint->bInterval);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2006-12-06 21:33:17 -07:00
|
|
|
retval = usb_submit_urb(ucs->read_urb, GFP_KERNEL);
|
2006-03-26 02:38:37 -07:00
|
|
|
if (retval) {
|
2006-04-10 23:55:04 -06:00
|
|
|
dev_err(cs->dev, "Could not submit URB (error %d)\n", -retval);
|
2006-03-26 02:38:37 -07:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* tell common part that the device is ready */
|
|
|
|
if (startmode == SM_LOCKED)
|
2008-02-06 02:38:28 -07:00
|
|
|
cs->mstate = MS_LOCKED;
|
2006-04-10 23:55:07 -06:00
|
|
|
|
2012-04-25 07:02:20 -06:00
|
|
|
retval = gigaset_start(cs);
|
|
|
|
if (retval < 0) {
|
2006-03-26 02:38:37 -07:00
|
|
|
tasklet_kill(&cs->write_tasklet);
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
2006-11-08 07:34:17 -07:00
|
|
|
usb_kill_urb(ucs->read_urb);
|
2006-03-26 02:38:37 -07:00
|
|
|
kfree(ucs->bulk_out_buffer);
|
2006-11-08 07:34:17 -07:00
|
|
|
usb_free_urb(ucs->bulk_out_urb);
|
2009-10-25 03:30:07 -06:00
|
|
|
kfree(ucs->rcvbuf);
|
2006-11-08 07:34:17 -07:00
|
|
|
usb_free_urb(ucs->read_urb);
|
2006-04-10 23:55:07 -06:00
|
|
|
usb_set_intfdata(interface, NULL);
|
2006-03-26 02:38:37 -07:00
|
|
|
ucs->read_urb = ucs->bulk_out_urb = NULL;
|
2009-10-25 03:30:07 -06:00
|
|
|
ucs->rcvbuf = ucs->bulk_out_buffer = NULL;
|
2006-04-10 23:55:04 -06:00
|
|
|
usb_put_dev(ucs->udev);
|
|
|
|
ucs->udev = NULL;
|
|
|
|
ucs->interface = NULL;
|
2008-02-06 02:38:29 -07:00
|
|
|
gigaset_freecs(cs);
|
2006-03-26 02:38:37 -07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gigaset_disconnect(struct usb_interface *interface)
|
|
|
|
{
|
|
|
|
struct cardstate *cs;
|
|
|
|
struct usb_cardstate *ucs;
|
|
|
|
|
|
|
|
cs = usb_get_intfdata(interface);
|
|
|
|
ucs = cs->hw.usb;
|
2008-02-06 02:38:24 -07:00
|
|
|
|
|
|
|
dev_info(cs->dev, "disconnecting Gigaset USB adapter\n");
|
|
|
|
|
2006-03-26 02:38:37 -07:00
|
|
|
usb_kill_urb(ucs->read_urb);
|
|
|
|
|
|
|
|
gigaset_stop(cs);
|
|
|
|
|
2006-04-10 23:55:07 -06:00
|
|
|
usb_set_intfdata(interface, NULL);
|
2006-03-26 02:38:37 -07:00
|
|
|
tasklet_kill(&cs->write_tasklet);
|
|
|
|
|
2008-02-06 02:38:24 -07:00
|
|
|
usb_kill_urb(ucs->bulk_out_urb);
|
2006-03-26 02:38:37 -07:00
|
|
|
|
|
|
|
kfree(ucs->bulk_out_buffer);
|
2006-11-08 07:34:17 -07:00
|
|
|
usb_free_urb(ucs->bulk_out_urb);
|
2009-10-25 03:30:07 -06:00
|
|
|
kfree(ucs->rcvbuf);
|
2006-11-08 07:34:17 -07:00
|
|
|
usb_free_urb(ucs->read_urb);
|
2006-04-10 23:55:00 -06:00
|
|
|
ucs->read_urb = ucs->bulk_out_urb = NULL;
|
2009-10-25 03:30:07 -06:00
|
|
|
ucs->rcvbuf = ucs->bulk_out_buffer = NULL;
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2006-04-10 23:55:07 -06:00
|
|
|
usb_put_dev(ucs->udev);
|
|
|
|
ucs->interface = NULL;
|
|
|
|
ucs->udev = NULL;
|
|
|
|
cs->dev = NULL;
|
2008-02-06 02:38:29 -07:00
|
|
|
gigaset_freecs(cs);
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
|
2008-02-06 02:38:27 -07:00
|
|
|
/* gigaset_suspend
|
|
|
|
* This function is called before the USB connection is suspended or reset.
|
|
|
|
*/
|
|
|
|
static int gigaset_suspend(struct usb_interface *intf, pm_message_t message)
|
|
|
|
{
|
|
|
|
struct cardstate *cs = usb_get_intfdata(intf);
|
|
|
|
|
|
|
|
/* stop activity */
|
|
|
|
cs->connected = 0; /* prevent rescheduling */
|
|
|
|
usb_kill_urb(cs->hw.usb->read_urb);
|
|
|
|
tasklet_kill(&cs->write_tasklet);
|
|
|
|
usb_kill_urb(cs->hw.usb->bulk_out_urb);
|
|
|
|
|
|
|
|
gig_dbg(DEBUG_SUSPEND, "suspend complete");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* gigaset_resume
|
|
|
|
* This function is called after the USB connection has been resumed or reset.
|
|
|
|
*/
|
|
|
|
static int gigaset_resume(struct usb_interface *intf)
|
|
|
|
{
|
|
|
|
struct cardstate *cs = usb_get_intfdata(intf);
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
/* resubmit interrupt URB */
|
|
|
|
cs->connected = 1;
|
|
|
|
rc = usb_submit_urb(cs->hw.usb->read_urb, GFP_KERNEL);
|
|
|
|
if (rc) {
|
|
|
|
dev_err(cs->dev, "Could not submit read URB (error %d)\n", -rc);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
gig_dbg(DEBUG_SUSPEND, "resume complete");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* gigaset_pre_reset
|
|
|
|
* This function is called before the USB connection is reset.
|
|
|
|
*/
|
|
|
|
static int gigaset_pre_reset(struct usb_interface *intf)
|
|
|
|
{
|
|
|
|
/* same as suspend */
|
|
|
|
return gigaset_suspend(intf, PMSG_ON);
|
|
|
|
}
|
|
|
|
|
2007-03-29 02:20:34 -06:00
|
|
|
static const struct gigaset_ops ops = {
|
2016-12-16 17:58:06 -07:00
|
|
|
.write_cmd = gigaset_write_cmd,
|
|
|
|
.write_room = gigaset_write_room,
|
|
|
|
.chars_in_buffer = gigaset_chars_in_buffer,
|
|
|
|
.brkchars = gigaset_brkchars,
|
|
|
|
.init_bchannel = gigaset_init_bchannel,
|
|
|
|
.close_bchannel = gigaset_close_bchannel,
|
|
|
|
.initbcshw = gigaset_initbcshw,
|
|
|
|
.freebcshw = gigaset_freebcshw,
|
|
|
|
.reinitbcshw = gigaset_reinitbcshw,
|
|
|
|
.initcshw = gigaset_initcshw,
|
|
|
|
.freecshw = gigaset_freecshw,
|
|
|
|
.set_modem_ctrl = gigaset_set_modem_ctrl,
|
|
|
|
.baud_rate = gigaset_baud_rate,
|
|
|
|
.set_line_ctrl = gigaset_set_line_ctrl,
|
|
|
|
.send_skb = gigaset_m10x_send_skb,
|
|
|
|
.handle_input = gigaset_m10x_input,
|
2006-03-26 02:38:37 -07:00
|
|
|
};
|
|
|
|
|
2009-05-13 06:44:18 -06:00
|
|
|
/*
|
2006-03-26 02:38:37 -07:00
|
|
|
* This function is called while kernel-module is loaded
|
|
|
|
*/
|
|
|
|
static int __init usb_gigaset_init(void)
|
|
|
|
{
|
|
|
|
int result;
|
|
|
|
|
tree-wide: fix comment/printk typos
"gadget", "through", "command", "maintain", "maintain", "controller", "address",
"between", "initiali[zs]e", "instead", "function", "select", "already",
"equal", "access", "management", "hierarchy", "registration", "interest",
"relative", "memory", "offset", "already",
Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2010-11-01 13:38:34 -06:00
|
|
|
/* allocate memory for our driver state and initialize it */
|
2009-10-25 03:30:07 -06:00
|
|
|
driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
|
|
|
|
GIGASET_MODULENAME, GIGASET_DEVNAME,
|
|
|
|
&ops, THIS_MODULE);
|
2012-04-25 07:02:20 -06:00
|
|
|
if (driver == NULL) {
|
|
|
|
result = -ENOMEM;
|
2006-03-26 02:38:37 -07:00
|
|
|
goto error;
|
2012-04-25 07:02:20 -06:00
|
|
|
}
|
2006-03-26 02:38:37 -07:00
|
|
|
|
|
|
|
/* register this driver with the USB subsystem */
|
|
|
|
result = usb_register(&gigaset_usb_driver);
|
|
|
|
if (result < 0) {
|
2008-12-26 02:21:29 -07:00
|
|
|
pr_err("error %d registering USB driver\n", -result);
|
2006-03-26 02:38:37 -07:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2008-12-26 02:21:29 -07:00
|
|
|
pr_info(DRIVER_DESC "\n");
|
2006-03-26 02:38:37 -07:00
|
|
|
return 0;
|
|
|
|
|
2008-02-06 02:38:29 -07:00
|
|
|
error:
|
2006-03-26 02:38:37 -07:00
|
|
|
if (driver)
|
|
|
|
gigaset_freedriver(driver);
|
|
|
|
driver = NULL;
|
2012-04-25 07:02:20 -06:00
|
|
|
return result;
|
2006-03-26 02:38:37 -07:00
|
|
|
}
|
|
|
|
|
2009-05-13 06:44:18 -06:00
|
|
|
/*
|
2006-03-26 02:38:37 -07:00
|
|
|
* This function is called while unloading the kernel-module
|
|
|
|
*/
|
|
|
|
static void __exit usb_gigaset_exit(void)
|
|
|
|
{
|
2008-02-06 02:38:29 -07:00
|
|
|
int i;
|
|
|
|
|
2006-03-26 02:38:37 -07:00
|
|
|
gigaset_blockdriver(driver); /* => probe will fail
|
2006-04-10 23:55:04 -06:00
|
|
|
* => no gigaset_start any more
|
|
|
|
*/
|
2006-03-26 02:38:37 -07:00
|
|
|
|
2008-02-06 02:38:29 -07:00
|
|
|
/* stop all connected devices */
|
|
|
|
for (i = 0; i < driver->minors; i++)
|
|
|
|
gigaset_shutdown(driver->cs + i);
|
|
|
|
|
2006-03-26 02:38:37 -07:00
|
|
|
/* from now on, no isdn callback should be possible */
|
|
|
|
|
|
|
|
/* deregister this driver with the USB subsystem */
|
|
|
|
usb_deregister(&gigaset_usb_driver);
|
|
|
|
/* this will call the disconnect-callback */
|
|
|
|
/* from now on, no disconnect/probe callback should be running */
|
|
|
|
|
|
|
|
gigaset_freedriver(driver);
|
|
|
|
driver = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
module_init(usb_gigaset_init);
|
|
|
|
module_exit(usb_gigaset_exit);
|
|
|
|
|
|
|
|
MODULE_AUTHOR(DRIVER_AUTHOR);
|
|
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|