speedtch.c 28.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7
/******************************************************************************
 *  speedtch.c  -  Alcatel SpeedTouch USB xDSL modem driver
 *
 *  Copyright (C) 2001, Alcatel
 *  Copyright (C) 2003, Duncan Sands
 *  Copyright (C) 2004, David Woodhouse
 *
8 9
 *  Based on "modem_run.c", copyright (C) 2001, Benoit Papillault
 *
L
Linus Torvalds 已提交
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *  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.
 *
 *  This program is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 *  more details.
 *
 *  You should have received a copy of the GNU General Public License along with
 *  this program; if not, write to the Free Software Foundation, Inc., 59
 *  Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 ******************************************************************************/

26 27 28 29
#include <asm/page.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/firmware.h>
L
Linus Torvalds 已提交
30
#include <linux/gfp.h>
31
#include <linux/init.h>
L
Linus Torvalds 已提交
32
#include <linux/kernel.h>
33 34
#include <linux/module.h>
#include <linux/moduleparam.h>
L
Linus Torvalds 已提交
35
#include <linux/slab.h>
36 37
#include <linux/stat.h>
#include <linux/timer.h>
38 39
#include <linux/types.h>
#include <linux/usb_ch9.h>
40
#include <linux/workqueue.h>
L
Linus Torvalds 已提交
41

42
#include "usbatm.h"
L
Linus Torvalds 已提交
43 44

#define DRIVER_AUTHOR	"Johan Verrept, Duncan Sands <duncan.sands@free.fr>"
45
#define DRIVER_VERSION	"1.10"
L
Linus Torvalds 已提交
46 47 48 49
#define DRIVER_DESC	"Alcatel SpeedTouch USB driver version " DRIVER_VERSION

static const char speedtch_driver_name[] = "speedtch";

50 51
#define CTRL_TIMEOUT 2000	/* milliseconds */
#define DATA_TIMEOUT 2000	/* milliseconds */
L
Linus Torvalds 已提交
52

53 54 55 56 57
#define OFFSET_7	0		/* size 1 */
#define OFFSET_b	1		/* size 8 */
#define OFFSET_d	9		/* size 4 */
#define OFFSET_e	13		/* size 1 */
#define OFFSET_f	14		/* size 1 */
L
Linus Torvalds 已提交
58

59 60 61 62 63
#define SIZE_7		1
#define SIZE_b		8
#define SIZE_d		4
#define SIZE_e		1
#define SIZE_f		1
L
Linus Torvalds 已提交
64

65 66
#define MIN_POLL_DELAY		5000	/* milliseconds */
#define MAX_POLL_DELAY		60000	/* milliseconds */
L
Linus Torvalds 已提交
67

68
#define RESUBMIT_DELAY		1000	/* milliseconds */
L
Linus Torvalds 已提交
69

70
#define DEFAULT_BULK_ALTSETTING	1
71
#define DEFAULT_ISOC_ALTSETTING	3
72
#define DEFAULT_DL_512_FIRST	0
73
#define DEFAULT_ENABLE_ISOC	0
74
#define DEFAULT_SW_BUFFERING	0
L
Linus Torvalds 已提交
75

76
static unsigned int altsetting = 0; /* zero means: use the default */
77
static int dl_512_first = DEFAULT_DL_512_FIRST;
78
static int enable_isoc = DEFAULT_ENABLE_ISOC;
79
static int sw_buffering = DEFAULT_SW_BUFFERING;
L
Linus Torvalds 已提交
80

D
Duncan Sands 已提交
81 82 83 84 85 86 87 88 89 90 91 92
#define DEFAULT_B_MAX_DSL	8128
#define DEFAULT_MODEM_MODE	11
#define MODEM_OPTION_LENGTH	16
static const unsigned char DEFAULT_MODEM_OPTION[MODEM_OPTION_LENGTH] = {
	0x10, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

static unsigned int BMaxDSL = DEFAULT_B_MAX_DSL;
static unsigned char ModemMode = DEFAULT_MODEM_MODE;
static unsigned char ModemOption[MODEM_OPTION_LENGTH];
static int num_ModemOption;

93
module_param(altsetting, uint, S_IRUGO | S_IWUSR);
94
MODULE_PARM_DESC(altsetting,
95 96 97
		"Alternative setting for data interface (bulk_default: "
		__MODULE_STRING(DEFAULT_BULK_ALTSETTING) "; isoc_default: "
		__MODULE_STRING(DEFAULT_ISOC_ALTSETTING) ")");
L
Linus Torvalds 已提交
98

99 100 101 102
module_param(dl_512_first, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(dl_512_first,
		 "Read 512 bytes before sending firmware (default: "
		 __MODULE_STRING(DEFAULT_DL_512_FIRST) ")");
L
Linus Torvalds 已提交
103

104 105 106 107 108
module_param(enable_isoc, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(enable_isoc,
		"Use isochronous transfers if available (default: "
		__MODULE_STRING(DEFAULT_ENABLE_ISOC) ")");

109 110 111 112
module_param(sw_buffering, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(sw_buffering,
		 "Enable software buffering (default: "
		 __MODULE_STRING(DEFAULT_SW_BUFFERING) ")");
L
Linus Torvalds 已提交
113

D
Duncan Sands 已提交
114 115 116 117 118 119 120 121 122 123 124
module_param(BMaxDSL, uint, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(BMaxDSL,
		"default: " __MODULE_STRING(DEFAULT_B_MAX_DSL));

module_param(ModemMode, byte, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(ModemMode,
		"default: " __MODULE_STRING(DEFAULT_MODEM_MODE));

module_param_array(ModemOption, byte, &num_ModemOption, S_IRUGO);
MODULE_PARM_DESC(ModemOption, "default: 0x10,0x00,0x00,0x00,0x20");

125
#define INTERFACE_DATA		1
126
#define ENDPOINT_INT		0x81
127 128
#define ENDPOINT_BULK_DATA	0x07
#define ENDPOINT_ISOC_DATA	0x07
129
#define ENDPOINT_FIRMWARE	0x05
L
Linus Torvalds 已提交
130

131
#define hex2int(c) ( (c >= '0') && (c <= '9') ? (c - '0') : ((c & 0xf) + 9) )
L
Linus Torvalds 已提交
132

D
Duncan Sands 已提交
133 134 135 136 137 138 139
struct speedtch_params {
	unsigned int altsetting;
	unsigned int BMaxDSL;
	unsigned char ModemMode;
	unsigned char ModemOption[MODEM_OPTION_LENGTH];
};

L
Linus Torvalds 已提交
140
struct speedtch_instance_data {
141 142
	struct usbatm_data *usbatm;

D
Duncan Sands 已提交
143
	struct speedtch_params params; /* set in probe, constant afterwards */
144

D
David Howells 已提交
145
	struct delayed_work status_checker;
L
Linus Torvalds 已提交
146

147 148
	unsigned char last_status;

149 150 151
	int poll_delay; /* milliseconds */

	struct timer_list resubmit_timer;
L
Linus Torvalds 已提交
152 153 154
	struct urb *int_urb;
	unsigned char int_data[16];

D
Duncan Sands 已提交
155
	unsigned char scratch_buffer[16];
L
Linus Torvalds 已提交
156 157 158 159 160 161
};

/***************
**  firmware  **
***************/

162
static void speedtch_set_swbuff(struct speedtch_instance_data *instance, int state)
L
Linus Torvalds 已提交
163
{
164 165
	struct usbatm_data *usbatm = instance->usbatm;
	struct usb_device *usb_dev = usbatm->usb_dev;
L
Linus Torvalds 已提交
166 167
	int ret;

168 169 170 171 172 173 174 175
	ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
			      0x32, 0x40, state ? 0x01 : 0x00, 0x00, NULL, 0, CTRL_TIMEOUT);
	if (ret < 0)
		usb_warn(usbatm,
			 "%sabling SW buffering: usb_control_msg returned %d\n",
			 state ? "En" : "Dis", ret);
	else
		dbg("speedtch_set_swbuff: %sbled SW buffering", state ? "En" : "Dis");
L
Linus Torvalds 已提交
176 177 178 179
}

static void speedtch_test_sequence(struct speedtch_instance_data *instance)
{
180 181 182
	struct usbatm_data *usbatm = instance->usbatm;
	struct usb_device *usb_dev = usbatm->usb_dev;
	unsigned char *buf = instance->scratch_buffer;
L
Linus Torvalds 已提交
183 184 185 186 187
	int ret;

	/* URB 147 */
	buf[0] = 0x1c;
	buf[1] = 0x50;
188 189
	ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
			      0x01, 0x40, 0x0b, 0x00, buf, 2, CTRL_TIMEOUT);
L
Linus Torvalds 已提交
190
	if (ret < 0)
191
		usb_warn(usbatm, "%s failed on URB147: %d\n", __func__, ret);
L
Linus Torvalds 已提交
192 193 194 195

	/* URB 148 */
	buf[0] = 0x32;
	buf[1] = 0x00;
196 197
	ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
			      0x01, 0x40, 0x02, 0x00, buf, 2, CTRL_TIMEOUT);
L
Linus Torvalds 已提交
198
	if (ret < 0)
199
		usb_warn(usbatm, "%s failed on URB148: %d\n", __func__, ret);
L
Linus Torvalds 已提交
200 201 202 203 204

	/* URB 149 */
	buf[0] = 0x01;
	buf[1] = 0x00;
	buf[2] = 0x01;
205 206
	ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
			      0x01, 0x40, 0x03, 0x00, buf, 3, CTRL_TIMEOUT);
L
Linus Torvalds 已提交
207
	if (ret < 0)
208
		usb_warn(usbatm, "%s failed on URB149: %d\n", __func__, ret);
L
Linus Torvalds 已提交
209 210 211 212 213

	/* URB 150 */
	buf[0] = 0x01;
	buf[1] = 0x00;
	buf[2] = 0x01;
214 215
	ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
			      0x01, 0x40, 0x04, 0x00, buf, 3, CTRL_TIMEOUT);
L
Linus Torvalds 已提交
216
	if (ret < 0)
217
		usb_warn(usbatm, "%s failed on URB150: %d\n", __func__, ret);
D
Duncan Sands 已提交
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245

	/* Extra initialisation in recent drivers - gives higher speeds */

	/* URBext1 */
	buf[0] = instance->params.ModemMode;
	ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
			      0x01, 0x40, 0x11, 0x00, buf, 1, CTRL_TIMEOUT);
	if (ret < 0)
		usb_warn(usbatm, "%s failed on URBext1: %d\n", __func__, ret);

	/* URBext2 */
	/* This seems to be the one which actually triggers the higher sync
	   rate -- it does require the new firmware too, although it works OK
	   with older firmware */
	ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
			      0x01, 0x40, 0x14, 0x00,
			      instance->params.ModemOption,
			      MODEM_OPTION_LENGTH, CTRL_TIMEOUT);
	if (ret < 0)
		usb_warn(usbatm, "%s failed on URBext2: %d\n", __func__, ret);

	/* URBext3 */
	buf[0] = instance->params.BMaxDSL & 0xff;
	buf[1] = instance->params.BMaxDSL >> 8;
	ret = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
			      0x01, 0x40, 0x12, 0x00, buf, 2, CTRL_TIMEOUT);
	if (ret < 0)
		usb_warn(usbatm, "%s failed on URBext3: %d\n", __func__, ret);
L
Linus Torvalds 已提交
246 247
}

248 249 250
static int speedtch_upload_firmware(struct speedtch_instance_data *instance,
				     const struct firmware *fw1,
				     const struct firmware *fw2)
L
Linus Torvalds 已提交
251
{
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
	unsigned char *buffer;
	struct usbatm_data *usbatm = instance->usbatm;
	struct usb_interface *intf;
	struct usb_device *usb_dev = usbatm->usb_dev;
	int actual_length;
	int ret = 0;
	int offset;

	usb_dbg(usbatm, "%s entered\n", __func__);

	if (!(buffer = (unsigned char *)__get_free_page(GFP_KERNEL))) {
		ret = -ENOMEM;
		usb_dbg(usbatm, "%s: no memory for buffer!\n", __func__);
		goto out;
	}

	if (!(intf = usb_ifnum_to_if(usb_dev, 2))) {
		ret = -ENODEV;
		usb_dbg(usbatm, "%s: interface not found!\n", __func__);
		goto out_free;
	}

	/* URB 7 */
	if (dl_512_first) {	/* some modems need a read before writing the firmware */
		ret = usb_bulk_msg(usb_dev, usb_rcvbulkpipe(usb_dev, ENDPOINT_FIRMWARE),
				   buffer, 0x200, &actual_length, 2000);

		if (ret < 0 && ret != -ETIMEDOUT)
280
			usb_warn(usbatm, "%s: read BLOCK0 from modem failed (%d)!\n", __func__, ret);
281 282 283 284 285 286 287 288 289 290 291 292 293
		else
			usb_dbg(usbatm, "%s: BLOCK0 downloaded (%d bytes)\n", __func__, ret);
	}

	/* URB 8 : both leds are static green */
	for (offset = 0; offset < fw1->size; offset += PAGE_SIZE) {
		int thislen = min_t(int, PAGE_SIZE, fw1->size - offset);
		memcpy(buffer, fw1->data + offset, thislen);

		ret = usb_bulk_msg(usb_dev, usb_sndbulkpipe(usb_dev, ENDPOINT_FIRMWARE),
				   buffer, thislen, &actual_length, DATA_TIMEOUT);

		if (ret < 0) {
294
			usb_err(usbatm, "%s: write BLOCK1 to modem failed (%d)!\n", __func__, ret);
295 296 297 298 299 300 301 302 303 304
			goto out_free;
		}
		usb_dbg(usbatm, "%s: BLOCK1 uploaded (%zu bytes)\n", __func__, fw1->size);
	}

	/* USB led blinking green, ADSL led off */

	/* URB 11 */
	ret = usb_bulk_msg(usb_dev, usb_rcvbulkpipe(usb_dev, ENDPOINT_FIRMWARE),
			   buffer, 0x200, &actual_length, DATA_TIMEOUT);
L
Linus Torvalds 已提交
305 306

	if (ret < 0) {
307
		usb_err(usbatm, "%s: read BLOCK2 from modem failed (%d)!\n", __func__, ret);
308
		goto out_free;
L
Linus Torvalds 已提交
309
	}
310
	usb_dbg(usbatm, "%s: BLOCK2 downloaded (%d bytes)\n", __func__, actual_length);
L
Linus Torvalds 已提交
311

312 313 314 315 316 317 318 319 320
	/* URBs 12 to 139 - USB led blinking green, ADSL led off */
	for (offset = 0; offset < fw2->size; offset += PAGE_SIZE) {
		int thislen = min_t(int, PAGE_SIZE, fw2->size - offset);
		memcpy(buffer, fw2->data + offset, thislen);

		ret = usb_bulk_msg(usb_dev, usb_sndbulkpipe(usb_dev, ENDPOINT_FIRMWARE),
				   buffer, thislen, &actual_length, DATA_TIMEOUT);

		if (ret < 0) {
321
			usb_err(usbatm, "%s: write BLOCK3 to modem failed (%d)!\n", __func__, ret);
322 323 324 325 326 327 328 329 330 331 332 333
			goto out_free;
		}
	}
	usb_dbg(usbatm, "%s: BLOCK3 uploaded (%zu bytes)\n", __func__, fw2->size);

	/* USB led static green, ADSL led static red */

	/* URB 142 */
	ret = usb_bulk_msg(usb_dev, usb_rcvbulkpipe(usb_dev, ENDPOINT_FIRMWARE),
			   buffer, 0x200, &actual_length, DATA_TIMEOUT);

	if (ret < 0) {
334
		usb_err(usbatm, "%s: read BLOCK4 from modem failed (%d)!\n", __func__, ret);
335 336 337 338 339 340 341 342 343 344
		goto out_free;
	}

	/* success */
	usb_dbg(usbatm, "%s: BLOCK4 downloaded (%d bytes)\n", __func__, actual_length);

	/* Delay to allow firmware to start up. We can do this here
	   because we're in our own kernel thread anyway. */
	msleep_interruptible(1000);

D
Duncan Sands 已提交
345 346
	if ((ret = usb_set_interface(usb_dev, INTERFACE_DATA, instance->params.altsetting)) < 0) {
		usb_err(usbatm, "%s: setting interface to %d failed (%d)!\n", __func__, instance->params.altsetting, ret);
347 348 349
		goto out_free;
	}

350 351 352 353 354 355 356 357 358 359 360 361 362
	/* Enable software buffering, if requested */
	if (sw_buffering)
		speedtch_set_swbuff(instance, 1);

	/* Magic spell; don't ask us what this does */
	speedtch_test_sequence(instance);

	ret = 0;

out_free:
	free_page((unsigned long)buffer);
out:
	return ret;
L
Linus Torvalds 已提交
363 364
}

365 366
static int speedtch_find_firmware(struct usbatm_data *usbatm, struct usb_interface *intf,
				  int phase, const struct firmware **fw_p)
L
Linus Torvalds 已提交
367
{
368 369 370 371 372
	struct device *dev = &intf->dev;
	const u16 bcdDevice = le16_to_cpu(interface_to_usbdev(intf)->descriptor.bcdDevice);
	const u8 major_revision = bcdDevice >> 8;
	const u8 minor_revision = bcdDevice & 0xff;
	char buf[24];
L
Linus Torvalds 已提交
373

374
	sprintf(buf, "speedtch-%d.bin.%x.%02x", phase, major_revision, minor_revision);
375
	usb_dbg(usbatm, "%s: looking for %s\n", __func__, buf);
L
Linus Torvalds 已提交
376

377 378
	if (request_firmware(fw_p, buf, dev)) {
		sprintf(buf, "speedtch-%d.bin.%x", phase, major_revision);
379
		usb_dbg(usbatm, "%s: looking for %s\n", __func__, buf);
L
Linus Torvalds 已提交
380

381 382
		if (request_firmware(fw_p, buf, dev)) {
			sprintf(buf, "speedtch-%d.bin", phase);
383
			usb_dbg(usbatm, "%s: looking for %s\n", __func__, buf);
384 385

			if (request_firmware(fw_p, buf, dev)) {
386
				usb_err(usbatm, "%s: no stage %d firmware found!\n", __func__, phase);
387 388 389
				return -ENOENT;
			}
		}
L
Linus Torvalds 已提交
390 391
	}

392
	usb_info(usbatm, "found stage %d firmware %s\n", phase, buf);
L
Linus Torvalds 已提交
393

394 395 396 397 398 399 400 401 402
	return 0;
}

static int speedtch_heavy_init(struct usbatm_data *usbatm, struct usb_interface *intf)
{
	const struct firmware *fw1, *fw2;
	struct speedtch_instance_data *instance = usbatm->driver_data;
	int ret;

403 404
	if ((ret = speedtch_find_firmware(usbatm, intf, 1, &fw1)) < 0)
		return ret;
405

406
	if ((ret = speedtch_find_firmware(usbatm, intf, 2, &fw2)) < 0) {
407 408
		release_firmware(fw1);
		return ret;
L
Linus Torvalds 已提交
409 410
	}

411 412
	if ((ret = speedtch_upload_firmware(instance, fw1, fw2)) < 0)
		usb_err(usbatm, "%s: firmware upload failed (%d)!\n", __func__, ret);
413 414 415

	release_firmware(fw2);
	release_firmware(fw1);
L
Linus Torvalds 已提交
416

417
	return ret;
L
Linus Torvalds 已提交
418 419
}

420 421 422 423 424 425

/**********
**  ATM  **
**********/

static int speedtch_read_status(struct speedtch_instance_data *instance)
L
Linus Torvalds 已提交
426
{
427 428 429
	struct usbatm_data *usbatm = instance->usbatm;
	struct usb_device *usb_dev = usbatm->usb_dev;
	unsigned char *buf = instance->scratch_buffer;
L
Linus Torvalds 已提交
430 431
	int ret;

D
Duncan Sands 已提交
432
	memset(buf, 0, 16);
L
Linus Torvalds 已提交
433

434
	ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
L
Linus Torvalds 已提交
435 436 437
			      0x12, 0xc0, 0x07, 0x00, buf + OFFSET_7, SIZE_7,
			      CTRL_TIMEOUT);
	if (ret < 0) {
438
		atm_dbg(usbatm, "%s: MSG 7 failed\n", __func__);
L
Linus Torvalds 已提交
439 440 441
		return ret;
	}

442
	ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
L
Linus Torvalds 已提交
443 444 445
			      0x12, 0xc0, 0x0b, 0x00, buf + OFFSET_b, SIZE_b,
			      CTRL_TIMEOUT);
	if (ret < 0) {
446
		atm_dbg(usbatm, "%s: MSG B failed\n", __func__);
L
Linus Torvalds 已提交
447 448 449
		return ret;
	}

450
	ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
L
Linus Torvalds 已提交
451 452 453
			      0x12, 0xc0, 0x0d, 0x00, buf + OFFSET_d, SIZE_d,
			      CTRL_TIMEOUT);
	if (ret < 0) {
454
		atm_dbg(usbatm, "%s: MSG D failed\n", __func__);
L
Linus Torvalds 已提交
455 456 457
		return ret;
	}

458
	ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
L
Linus Torvalds 已提交
459 460 461
			      0x01, 0xc0, 0x0e, 0x00, buf + OFFSET_e, SIZE_e,
			      CTRL_TIMEOUT);
	if (ret < 0) {
462
		atm_dbg(usbatm, "%s: MSG E failed\n", __func__);
L
Linus Torvalds 已提交
463 464 465
		return ret;
	}

466
	ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
L
Linus Torvalds 已提交
467 468 469
			      0x01, 0xc0, 0x0f, 0x00, buf + OFFSET_f, SIZE_f,
			      CTRL_TIMEOUT);
	if (ret < 0) {
470
		atm_dbg(usbatm, "%s: MSG F failed\n", __func__);
L
Linus Torvalds 已提交
471 472 473 474 475 476
		return ret;
	}

	return 0;
}

477
static int speedtch_start_synchro(struct speedtch_instance_data *instance)
L
Linus Torvalds 已提交
478
{
479 480 481
	struct usbatm_data *usbatm = instance->usbatm;
	struct usb_device *usb_dev = usbatm->usb_dev;
	unsigned char *buf = instance->scratch_buffer;
L
Linus Torvalds 已提交
482 483
	int ret;

484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
	atm_dbg(usbatm, "%s entered\n", __func__);

	memset(buf, 0, 2);

	ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
			      0x12, 0xc0, 0x04, 0x00,
			      buf, 2, CTRL_TIMEOUT);

	if (ret < 0)
		atm_warn(usbatm, "failed to start ADSL synchronisation: %d\n", ret);
	else
		atm_dbg(usbatm, "%s: modem prodded. %d bytes returned: %02x %02x\n",
			__func__, ret, buf[0], buf[1]);

	return ret;
}

D
David Howells 已提交
501
static void speedtch_check_status(struct work_struct *work)
502
{
D
David Howells 已提交
503 504 505
	struct speedtch_instance_data *instance =
		container_of(work, struct speedtch_instance_data,
			     status_checker.work);
506 507 508
	struct usbatm_data *usbatm = instance->usbatm;
	struct atm_dev *atm_dev = usbatm->atm_dev;
	unsigned char *buf = instance->scratch_buffer;
509 510
	int down_speed, up_speed, ret;
	unsigned char status;
511

512
#ifdef VERBOSE_DEBUG
513
	atm_dbg(usbatm, "%s entered\n", __func__);
514
#endif
515 516 517 518

	ret = speedtch_read_status(instance);
	if (ret < 0) {
		atm_warn(usbatm, "error %d fetching device status\n", ret);
519
		instance->poll_delay = min(2 * instance->poll_delay, MAX_POLL_DELAY);
L
Linus Torvalds 已提交
520 521 522
		return;
	}

523
	instance->poll_delay = max(instance->poll_delay / 2, MIN_POLL_DELAY);
524

525
	status = buf[OFFSET_7];
L
Linus Torvalds 已提交
526

527
	if ((status != instance->last_status) || !status) {
528 529
		atm_dbg(usbatm, "%s: line state 0x%02x\n", __func__, status);

530 531
		switch (status) {
		case 0:
532
			atm_dev->signal = ATM_PHY_SIG_LOST;
533
			if (instance->last_status)
534
				atm_info(usbatm, "ADSL line is down\n");
535
			/* It may never resync again unless we ask it to... */
536
			ret = speedtch_start_synchro(instance);
537
			break;
L
Linus Torvalds 已提交
538

539
		case 0x08:
540
			atm_dev->signal = ATM_PHY_SIG_UNKNOWN;
541
			atm_info(usbatm, "ADSL line is blocked?\n");
542
			break;
L
Linus Torvalds 已提交
543

544
		case 0x10:
545
			atm_dev->signal = ATM_PHY_SIG_LOST;
546
			atm_info(usbatm, "ADSL line is synchronising\n");
547
			break;
L
Linus Torvalds 已提交
548

549 550
		case 0x20:
			down_speed = buf[OFFSET_b] | (buf[OFFSET_b + 1] << 8)
L
Linus Torvalds 已提交
551
				| (buf[OFFSET_b + 2] << 16) | (buf[OFFSET_b + 3] << 24);
552
			up_speed = buf[OFFSET_b + 4] | (buf[OFFSET_b + 5] << 8)
L
Linus Torvalds 已提交
553 554
				| (buf[OFFSET_b + 6] << 16) | (buf[OFFSET_b + 7] << 24);

555
			if (!(down_speed & 0x0000ffff) && !(up_speed & 0x0000ffff)) {
L
Linus Torvalds 已提交
556 557 558 559
				down_speed >>= 16;
				up_speed >>= 16;
			}

560 561 562 563
			atm_dev->link_rate = down_speed * 1000 / 424;
			atm_dev->signal = ATM_PHY_SIG_FOUND;

			atm_info(usbatm,
564
				 "ADSL line is up (%d kb/s down | %d kb/s up)\n",
565
				 down_speed, up_speed);
566
			break;
L
Linus Torvalds 已提交
567

568
		default:
569
			atm_dev->signal = ATM_PHY_SIG_UNKNOWN;
570
			atm_info(usbatm, "unknown line state %02x\n", status);
571
			break;
L
Linus Torvalds 已提交
572
		}
573 574

		instance->last_status = status;
L
Linus Torvalds 已提交
575 576 577
	}
}

578
static void speedtch_status_poll(unsigned long data)
L
Linus Torvalds 已提交
579 580 581
{
	struct speedtch_instance_data *instance = (void *)data;

D
David Howells 已提交
582
	schedule_delayed_work(&instance->status_checker, 0);
583 584 585 586 587

	/* The following check is racy, but the race is harmless */
	if (instance->poll_delay < MAX_POLL_DELAY)
		mod_timer(&instance->status_checker.timer, jiffies + msecs_to_jiffies(instance->poll_delay));
	else
588
		atm_warn(instance->usbatm, "Too many failures - disabling line status polling\n");
L
Linus Torvalds 已提交
589 590
}

591
static void speedtch_resubmit_int(unsigned long data)
L
Linus Torvalds 已提交
592
{
593 594 595
	struct speedtch_instance_data *instance = (void *)data;
	struct urb *int_urb = instance->int_urb;
	int ret;
L
Linus Torvalds 已提交
596

597
	atm_dbg(instance->usbatm, "%s entered\n", __func__);
L
Linus Torvalds 已提交
598

599 600 601
	if (int_urb) {
		ret = usb_submit_urb(int_urb, GFP_ATOMIC);
		if (!ret)
D
David Howells 已提交
602
			schedule_delayed_work(&instance->status_checker, 0);
603 604 605
		else {
			atm_dbg(instance->usbatm, "%s: usb_submit_urb failed with result %d\n", __func__, ret);
			mod_timer(&instance->resubmit_timer, jiffies + msecs_to_jiffies(RESUBMIT_DELAY));
L
Linus Torvalds 已提交
606 607
		}
	}
608
}
L
Linus Torvalds 已提交
609

610
static void speedtch_handle_int(struct urb *int_urb)
611 612 613 614 615
{
	struct speedtch_instance_data *instance = int_urb->context;
	struct usbatm_data *usbatm = instance->usbatm;
	unsigned int count = int_urb->actual_length;
	int ret = int_urb->status;
L
Linus Torvalds 已提交
616

617
	/* The magic interrupt for "up state" */
618
	static const unsigned char up_int[6]   = { 0xa1, 0x00, 0x01, 0x00, 0x00, 0x00 };
619
	/* The magic interrupt for "down state" */
620
	static const unsigned char down_int[6] = { 0xa1, 0x00, 0x00, 0x00, 0x00, 0x00 };
621 622

	atm_dbg(usbatm, "%s entered\n", __func__);
L
Linus Torvalds 已提交
623 624

	if (ret < 0) {
625 626
		atm_dbg(usbatm, "%s: nonzero urb status %d!\n", __func__, ret);
		goto fail;
L
Linus Torvalds 已提交
627 628
	}

629 630
	if ((count == 6) && !memcmp(up_int, instance->int_data, 6)) {
		del_timer(&instance->status_checker.timer);
631
		atm_info(usbatm, "DSL line goes up\n");
632
	} else if ((count == 6) && !memcmp(down_int, instance->int_data, 6)) {
633
		atm_info(usbatm, "DSL line goes down\n");
634 635
	} else {
		int i;
L
Linus Torvalds 已提交
636

637 638 639 640 641 642
		atm_dbg(usbatm, "%s: unknown interrupt packet of length %d:", __func__, count);
		for (i = 0; i < count; i++)
			printk(" %02x", instance->int_data[i]);
		printk("\n");
		goto fail;
	}
L
Linus Torvalds 已提交
643

644 645
	if ((int_urb = instance->int_urb)) {
		ret = usb_submit_urb(int_urb, GFP_ATOMIC);
D
David Howells 已提交
646
		schedule_delayed_work(&instance->status_checker, 0);
L
Linus Torvalds 已提交
647
		if (ret < 0) {
648 649
			atm_dbg(usbatm, "%s: usb_submit_urb failed with result %d\n", __func__, ret);
			goto fail;
L
Linus Torvalds 已提交
650 651 652 653 654
		}
	}

	return;

655 656 657
fail:
	if ((int_urb = instance->int_urb))
		mod_timer(&instance->resubmit_timer, jiffies + msecs_to_jiffies(RESUBMIT_DELAY));
L
Linus Torvalds 已提交
658 659
}

660
static int speedtch_atm_start(struct usbatm_data *usbatm, struct atm_dev *atm_dev)
L
Linus Torvalds 已提交
661
{
662 663 664 665
	struct usb_device *usb_dev = usbatm->usb_dev;
	struct speedtch_instance_data *instance = usbatm->driver_data;
	int i, ret;
	unsigned char mac_str[13];
L
Linus Torvalds 已提交
666

667
	atm_dbg(usbatm, "%s entered\n", __func__);
L
Linus Torvalds 已提交
668

669 670 671 672 673 674
	/* Set MAC address, it is stored in the serial number */
	memset(atm_dev->esi, 0, sizeof(atm_dev->esi));
	if (usb_string(usb_dev, usb_dev->descriptor.iSerialNumber, mac_str, sizeof(mac_str)) == 12) {
		for (i = 0; i < 6; i++)
			atm_dev->esi[i] = (hex2int(mac_str[i * 2]) * 16) + (hex2int(mac_str[i * 2 + 1]));
	}
L
Linus Torvalds 已提交
675

676 677
	/* Start modem synchronisation */
	ret = speedtch_start_synchro(instance);
L
Linus Torvalds 已提交
678

679 680 681 682 683 684 685 686
	/* Set up interrupt endpoint */
	if (instance->int_urb) {
		ret = usb_submit_urb(instance->int_urb, GFP_KERNEL);
		if (ret < 0) {
			/* Doesn't matter; we'll poll anyway */
			atm_dbg(usbatm, "%s: submission of interrupt URB failed (%d)!\n", __func__, ret);
			usb_free_urb(instance->int_urb);
			instance->int_urb = NULL;
L
Linus Torvalds 已提交
687 688 689
		}
	}

690 691
	/* Start status polling */
	mod_timer(&instance->status_checker.timer, jiffies + msecs_to_jiffies(1000));
L
Linus Torvalds 已提交
692 693 694 695

	return 0;
}

696
static void speedtch_atm_stop(struct usbatm_data *usbatm, struct atm_dev *atm_dev)
L
Linus Torvalds 已提交
697
{
698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720
	struct speedtch_instance_data *instance = usbatm->driver_data;
	struct urb *int_urb = instance->int_urb;

	atm_dbg(usbatm, "%s entered\n", __func__);

	del_timer_sync(&instance->status_checker.timer);

	/*
	 * Since resubmit_timer and int_urb can schedule themselves and
	 * each other, shutting them down correctly takes some care
	 */
	instance->int_urb = NULL; /* signal shutdown */
	mb();
	usb_kill_urb(int_urb);
	del_timer_sync(&instance->resubmit_timer);
	/*
	 * At this point, speedtch_handle_int and speedtch_resubmit_int
	 * can run or be running, but instance->int_urb == NULL means that
	 * they will not reschedule
	 */
	usb_kill_urb(int_urb);
	del_timer_sync(&instance->resubmit_timer);
	usb_free_urb(int_urb);
L
Linus Torvalds 已提交
721

722 723
	flush_scheduled_work();
}
L
Linus Torvalds 已提交
724 725


726 727 728
/**********
**  USB  **
**********/
L
Linus Torvalds 已提交
729

730 731 732 733
static struct usb_device_id speedtch_usb_ids[] = {
	{USB_DEVICE(0x06b9, 0x4061)},
	{}
};
L
Linus Torvalds 已提交
734

735
MODULE_DEVICE_TABLE(usb, speedtch_usb_ids);
L
Linus Torvalds 已提交
736

737
static int speedtch_usb_probe(struct usb_interface *, const struct usb_device_id *);
L
Linus Torvalds 已提交
738

739 740 741 742 743 744
static struct usb_driver speedtch_usb_driver = {
	.name		= speedtch_driver_name,
	.probe		= speedtch_usb_probe,
	.disconnect	= usbatm_usb_disconnect,
	.id_table	= speedtch_usb_ids
};
L
Linus Torvalds 已提交
745

746 747 748
static void speedtch_release_interfaces(struct usb_device *usb_dev, int num_interfaces) {
	struct usb_interface *cur_intf;
	int i;
L
Linus Torvalds 已提交
749

750 751 752 753 754
	for(i = 0; i < num_interfaces; i++)
		if ((cur_intf = usb_ifnum_to_if(usb_dev, i))) {
			usb_set_intfdata(cur_intf, NULL);
			usb_driver_release_interface(&speedtch_usb_driver, cur_intf);
		}
L
Linus Torvalds 已提交
755 756
}

757 758
static int speedtch_bind(struct usbatm_data *usbatm,
			 struct usb_interface *intf,
D
Duncan Sands 已提交
759
			 const struct usb_device_id *id)
L
Linus Torvalds 已提交
760
{
761
	struct usb_device *usb_dev = interface_to_usbdev(intf);
762
	struct usb_interface *cur_intf, *data_intf;
763 764 765 766
	struct speedtch_instance_data *instance;
	int ifnum = intf->altsetting->desc.bInterfaceNumber;
	int num_interfaces = usb_dev->actconfig->desc.bNumInterfaces;
	int i, ret;
767
	int use_isoc;
L
Linus Torvalds 已提交
768

769
	usb_dbg(usbatm, "%s entered\n", __func__);
L
Linus Torvalds 已提交
770

771 772
	/* sanity checks */

773
	if (usb_dev->descriptor.bDeviceClass != USB_CLASS_VENDOR_SPEC) {
774
		usb_err(usbatm, "%s: wrong device class %d\n", __func__, usb_dev->descriptor.bDeviceClass);
L
Linus Torvalds 已提交
775 776 777
		return -ENODEV;
	}

778 779 780 781 782
	if (!(data_intf = usb_ifnum_to_if(usb_dev, INTERFACE_DATA))) {
		usb_err(usbatm, "%s: data interface not found!\n", __func__);
		return -ENODEV;
	}

783
	/* claim all interfaces */
L
Linus Torvalds 已提交
784

785 786
	for (i=0; i < num_interfaces; i++) {
		cur_intf = usb_ifnum_to_if(usb_dev, i);
L
Linus Torvalds 已提交
787

788 789
		if ((i != ifnum) && cur_intf) {
			ret = usb_driver_claim_interface(&speedtch_usb_driver, cur_intf, usbatm);
L
Linus Torvalds 已提交
790

791
			if (ret < 0) {
792
				usb_err(usbatm, "%s: failed to claim interface %2d (%d)!\n", __func__, i, ret);
793 794 795 796 797
				speedtch_release_interfaces(usb_dev, i);
				return ret;
			}
		}
	}
L
Linus Torvalds 已提交
798

799
	instance = kzalloc(sizeof(*instance), GFP_KERNEL);
800

L
Linus Torvalds 已提交
801
	if (!instance) {
802
		usb_err(usbatm, "%s: no memory for instance data!\n", __func__);
803 804
		ret = -ENOMEM;
		goto fail_release;
L
Linus Torvalds 已提交
805 806
	}

807
	instance->usbatm = usbatm;
L
Linus Torvalds 已提交
808

D
Duncan Sands 已提交
809 810 811 812 813 814
	/* module parameters may change at any moment, so take a snapshot */
	instance->params.altsetting = altsetting;
	instance->params.BMaxDSL = BMaxDSL;
	instance->params.ModemMode = ModemMode;
	memcpy(instance->params.ModemOption, DEFAULT_MODEM_OPTION, MODEM_OPTION_LENGTH);
	memcpy(instance->params.ModemOption, ModemOption, num_ModemOption);
815
	use_isoc = enable_isoc;
816

D
Duncan Sands 已提交
817 818 819 820
	if (instance->params.altsetting)
		if ((ret = usb_set_interface(usb_dev, INTERFACE_DATA, instance->params.altsetting)) < 0) {
			usb_err(usbatm, "%s: setting interface to %2d failed (%d)!\n", __func__, instance->params.altsetting, ret);
			instance->params.altsetting = 0; /* fall back to default */
821 822
		}

D
Duncan Sands 已提交
823
	if (!instance->params.altsetting && use_isoc)
824 825 826
		if ((ret = usb_set_interface(usb_dev, INTERFACE_DATA, DEFAULT_ISOC_ALTSETTING)) < 0) {
			usb_dbg(usbatm, "%s: setting interface to %2d failed (%d)!\n", __func__, DEFAULT_ISOC_ALTSETTING, ret);
			use_isoc = 0; /* fall back to bulk */
827
		}
828 829 830 831 832 833 834 835 836 837 838 839

	if (use_isoc) {
		const struct usb_host_interface *desc = data_intf->cur_altsetting;
		const __u8 target_address = USB_DIR_IN | usbatm->driver->isoc_in;
		int i;

		use_isoc = 0; /* fall back to bulk if endpoint not found */

		for (i=0; i<desc->desc.bNumEndpoints; i++) {
			const struct usb_endpoint_descriptor *endpoint_desc = &desc->endpoint[i].desc;

			if ((endpoint_desc->bEndpointAddress == target_address)) {
840 841
				use_isoc =
					usb_endpoint_xfer_isoc(endpoint_desc);
842 843 844 845 846 847
				break;
			}
		}

		if (!use_isoc)
			usb_info(usbatm, "isochronous transfer not supported - using bulk\n");
848 849
	}

D
Duncan Sands 已提交
850
	if (!use_isoc && !instance->params.altsetting)
851 852 853 854 855
		if ((ret = usb_set_interface(usb_dev, INTERFACE_DATA, DEFAULT_BULK_ALTSETTING)) < 0) {
			usb_err(usbatm, "%s: setting interface to %2d failed (%d)!\n", __func__, DEFAULT_BULK_ALTSETTING, ret);
			goto fail_free;
		}

D
Duncan Sands 已提交
856 857
	if (!instance->params.altsetting)
		instance->params.altsetting = use_isoc ? DEFAULT_ISOC_ALTSETTING : DEFAULT_BULK_ALTSETTING;
858 859 860

	usbatm->flags |= (use_isoc ? UDSL_USE_ISOC : 0);

D
David Howells 已提交
861
	INIT_DELAYED_WORK(&instance->status_checker, speedtch_check_status);
L
Linus Torvalds 已提交
862

863 864
	instance->status_checker.timer.function = speedtch_status_poll;
	instance->status_checker.timer.data = (unsigned long)instance;
865
	instance->last_status = 0xff;
866
	instance->poll_delay = MIN_POLL_DELAY;
L
Linus Torvalds 已提交
867

868 869 870
	init_timer(&instance->resubmit_timer);
	instance->resubmit_timer.function = speedtch_resubmit_int;
	instance->resubmit_timer.data = (unsigned long)instance;
L
Linus Torvalds 已提交
871

872
	instance->int_urb = usb_alloc_urb(0, GFP_KERNEL);
L
Linus Torvalds 已提交
873

874 875 876 877 878 879 880
	if (instance->int_urb)
		usb_fill_int_urb(instance->int_urb, usb_dev,
				 usb_rcvintpipe(usb_dev, ENDPOINT_INT),
				 instance->int_data, sizeof(instance->int_data),
				 speedtch_handle_int, instance, 50);
	else
		usb_dbg(usbatm, "%s: no memory for interrupt urb!\n", __func__);
L
Linus Torvalds 已提交
881

882 883 884 885
	/* check whether the modem already seems to be alive */
	ret = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
			      0x12, 0xc0, 0x07, 0x00,
			      instance->scratch_buffer + OFFSET_7, SIZE_7, 500);
L
Linus Torvalds 已提交
886

887
	usbatm->flags |= (ret == SIZE_7 ? UDSL_SKIP_HEAVY_INIT : 0);
L
Linus Torvalds 已提交
888

D
Duncan Sands 已提交
889
	usb_dbg(usbatm, "%s: firmware %s loaded\n", __func__, usbatm->flags & UDSL_SKIP_HEAVY_INIT ? "already" : "not");
890

D
Duncan Sands 已提交
891
	if (!(usbatm->flags & UDSL_SKIP_HEAVY_INIT))
892 893
		if ((ret = usb_reset_device(usb_dev)) < 0) {
			usb_err(usbatm, "%s: device reset failed (%d)!\n", __func__, ret);
894
			goto fail_free;
895
		}
L
Linus Torvalds 已提交
896

897
        usbatm->driver_data = instance;
L
Linus Torvalds 已提交
898 899 900

	return 0;

901 902
fail_free:
	usb_free_urb(instance->int_urb);
L
Linus Torvalds 已提交
903
	kfree(instance);
904 905 906
fail_release:
	speedtch_release_interfaces(usb_dev, num_interfaces);
	return ret;
L
Linus Torvalds 已提交
907 908
}

909
static void speedtch_unbind(struct usbatm_data *usbatm, struct usb_interface *intf)
L
Linus Torvalds 已提交
910
{
911 912
	struct usb_device *usb_dev = interface_to_usbdev(intf);
	struct speedtch_instance_data *instance = usbatm->driver_data;
L
Linus Torvalds 已提交
913

914
	usb_dbg(usbatm, "%s entered\n", __func__);
L
Linus Torvalds 已提交
915

916 917 918
	speedtch_release_interfaces(usb_dev, usb_dev->actconfig->desc.bNumInterfaces);
	usb_free_urb(instance->int_urb);
	kfree(instance);
L
Linus Torvalds 已提交
919 920
}

921

L
Linus Torvalds 已提交
922 923 924 925
/***********
**  init  **
***********/

926 927 928 929 930 931 932
static struct usbatm_driver speedtch_usbatm_driver = {
	.driver_name	= speedtch_driver_name,
	.bind		= speedtch_bind,
	.heavy_init	= speedtch_heavy_init,
	.unbind		= speedtch_unbind,
	.atm_start	= speedtch_atm_start,
	.atm_stop	= speedtch_atm_stop,
933 934 935
	.bulk_in	= ENDPOINT_BULK_DATA,
	.bulk_out	= ENDPOINT_BULK_DATA,
	.isoc_in	= ENDPOINT_ISOC_DATA
936 937 938 939 940 941 942
};

static int speedtch_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
	return usbatm_usb_probe(intf, id, &speedtch_usbatm_driver);
}

L
Linus Torvalds 已提交
943 944
static int __init speedtch_usb_init(void)
{
945
	dbg("%s: driver version %s", __func__, DRIVER_VERSION);
L
Linus Torvalds 已提交
946 947 948 949 950 951

	return usb_register(&speedtch_usb_driver);
}

static void __exit speedtch_usb_cleanup(void)
{
952
	dbg("%s", __func__);
L
Linus Torvalds 已提交
953 954 955 956 957 958 959 960 961 962 963

	usb_deregister(&speedtch_usb_driver);
}

module_init(speedtch_usb_init);
module_exit(speedtch_usb_cleanup);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");
MODULE_VERSION(DRIVER_VERSION);