aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/atm
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/usb/atm')
-rw-r--r--drivers/usb/atm/Kconfig13
-rw-r--r--drivers/usb/atm/Makefile1
-rw-r--r--drivers/usb/atm/cxacru.c1
-rw-r--r--drivers/usb/atm/speedtch.c1
-rw-r--r--drivers/usb/atm/ueagle-atm.c1820
-rw-r--r--drivers/usb/atm/usbatm.c4
-rw-r--r--drivers/usb/atm/xusbatm.c1
7 files changed, 1836 insertions, 5 deletions
diff --git a/drivers/usb/atm/Kconfig b/drivers/usb/atm/Kconfig
index f429862e0974..550ddfa71a43 100644
--- a/drivers/usb/atm/Kconfig
+++ b/drivers/usb/atm/Kconfig
@@ -44,6 +44,19 @@ config USB_CXACRU
44 To compile this driver as a module, choose M here: the 44 To compile this driver as a module, choose M here: the
45 module will be called cxacru. 45 module will be called cxacru.
46 46
47config USB_UEAGLEATM
48 tristate "ADI 930 and eagle USB DSL modem"
49 depends on USB_ATM
50 select FW_LOADER
51 help
52 Say Y here if you have an ADSL USB modem based on the ADI 930
53 or eagle chipset. In order to use your modem you will need to
54 install firmwares and CMV (Command Management Variables); see
55 <https://gna.org/projects/ueagleatm/> for details.
56
57 To compile this driver as a module, choose M here: the
58 module will be called ueagle-atm.
59
47config USB_XUSBATM 60config USB_XUSBATM
48 tristate "Other USB DSL modem support" 61 tristate "Other USB DSL modem support"
49 depends on USB_ATM 62 depends on USB_ATM
diff --git a/drivers/usb/atm/Makefile b/drivers/usb/atm/Makefile
index 85099718c683..4c4a776ab1cd 100644
--- a/drivers/usb/atm/Makefile
+++ b/drivers/usb/atm/Makefile
@@ -4,6 +4,7 @@
4 4
5obj-$(CONFIG_USB_CXACRU) += cxacru.o 5obj-$(CONFIG_USB_CXACRU) += cxacru.o
6obj-$(CONFIG_USB_SPEEDTOUCH) += speedtch.o 6obj-$(CONFIG_USB_SPEEDTOUCH) += speedtch.o
7obj-$(CONFIG_USB_UEAGLEATM) += ueagle-atm.o
7obj-$(CONFIG_USB_ATM) += usbatm.o 8obj-$(CONFIG_USB_ATM) += usbatm.o
8obj-$(CONFIG_USB_XUSBATM) += xusbatm.o 9obj-$(CONFIG_USB_XUSBATM) += xusbatm.o
9 10
diff --git a/drivers/usb/atm/cxacru.c b/drivers/usb/atm/cxacru.c
index 9d59dc62e6d2..af0a41e7870e 100644
--- a/drivers/usb/atm/cxacru.c
+++ b/drivers/usb/atm/cxacru.c
@@ -853,7 +853,6 @@ static int cxacru_usb_probe(struct usb_interface *intf, const struct usb_device_
853} 853}
854 854
855static struct usb_driver cxacru_usb_driver = { 855static struct usb_driver cxacru_usb_driver = {
856 .owner = THIS_MODULE,
857 .name = cxacru_driver_name, 856 .name = cxacru_driver_name,
858 .probe = cxacru_usb_probe, 857 .probe = cxacru_usb_probe,
859 .disconnect = usbatm_usb_disconnect, 858 .disconnect = usbatm_usb_disconnect,
diff --git a/drivers/usb/atm/speedtch.c b/drivers/usb/atm/speedtch.c
index d0cbbb7f0385..b28336148658 100644
--- a/drivers/usb/atm/speedtch.c
+++ b/drivers/usb/atm/speedtch.c
@@ -659,7 +659,6 @@ MODULE_DEVICE_TABLE(usb, speedtch_usb_ids);
659static int speedtch_usb_probe(struct usb_interface *, const struct usb_device_id *); 659static int speedtch_usb_probe(struct usb_interface *, const struct usb_device_id *);
660 660
661static struct usb_driver speedtch_usb_driver = { 661static struct usb_driver speedtch_usb_driver = {
662 .owner = THIS_MODULE,
663 .name = speedtch_driver_name, 662 .name = speedtch_driver_name,
664 .probe = speedtch_usb_probe, 663 .probe = speedtch_usb_probe,
665 .disconnect = usbatm_usb_disconnect, 664 .disconnect = usbatm_usb_disconnect,
diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
new file mode 100644
index 000000000000..7d2a679989ed
--- /dev/null
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -0,0 +1,1820 @@
1/*-
2 * Copyright (c) 2003, 2004
3 * Damien Bergamini <damien.bergamini@free.fr>. All rights reserved.
4 *
5 * Copyright (c) 2005 Matthieu Castet <castet.matthieu@free.fr>
6 *
7 * This software is available to you under a choice of one of two
8 * licenses. You may choose to be licensed under the terms of the GNU
9 * General Public License (GPL) Version 2, available from the file
10 * COPYING in the main directory of this source tree, or the
11 * BSD license below:
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 * notice unmodified, this list of conditions, and the following
18 * disclaimer.
19 * 2. Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in the
21 * documentation and/or other materials provided with the distribution.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 *
35 * GPL license :
36 * This program is free software; you can redistribute it and/or
37 * modify it under the terms of the GNU General Public License
38 * as published by the Free Software Foundation; either version 2
39 * of the License, or (at your option) any later version.
40 *
41 * This program is distributed in the hope that it will be useful,
42 * but WITHOUT ANY WARRANTY; without even the implied warranty of
43 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
44 * GNU General Public License for more details.
45 *
46 * You should have received a copy of the GNU General Public License
47 * along with this program; if not, write to the Free Software
48 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
49 *
50 *
51 * HISTORY : some part of the code was base on ueagle 1.3 BSD driver,
52 * Damien Bergamini agree to put his code under a DUAL GPL/BSD license.
53 *
54 * The rest of the code was was rewritten from scratch.
55 */
56
57#include <linux/module.h>
58#include <linux/moduleparam.h>
59#include <linux/init.h>
60#include <linux/crc32.h>
61#include <linux/usb.h>
62#include <linux/firmware.h>
63#include <linux/ctype.h>
64#include <linux/kthread.h>
65#include <linux/version.h>
66#include <asm/unaligned.h>
67
68#include "usbatm.h"
69
70#define EAGLEUSBVERSION "ueagle 1.1"
71
72
73/*
74 * Debug macros
75 */
76#define uea_dbg(usb_dev, format, args...) \
77 do { \
78 if (debug >= 1) \
79 dev_dbg(&(usb_dev)->dev, \
80 "[ueagle-atm dbg] %s: " format, \
81 __FUNCTION__, ##args); \
82 } while (0)
83
84#define uea_vdbg(usb_dev, format, args...) \
85 do { \
86 if (debug >= 2) \
87 dev_dbg(&(usb_dev)->dev, \
88 "[ueagle-atm vdbg] " format, ##args); \
89 } while (0)
90
91#define uea_enters(usb_dev) \
92 uea_vdbg(usb_dev, "entering %s\n", __FUNCTION__)
93
94#define uea_leaves(usb_dev) \
95 uea_vdbg(usb_dev, "leaving %s\n", __FUNCTION__)
96
97#define uea_err(usb_dev, format,args...) \
98 dev_err(&(usb_dev)->dev ,"[UEAGLE-ATM] " format , ##args)
99
100#define uea_warn(usb_dev, format,args...) \
101 dev_warn(&(usb_dev)->dev ,"[Ueagle-atm] " format, ##args)
102
103#define uea_info(usb_dev, format,args...) \
104 dev_info(&(usb_dev)->dev ,"[ueagle-atm] " format, ##args)
105
106struct uea_cmvs {
107 u32 address;
108 u16 offset;
109 u32 data;
110} __attribute__ ((packed));
111
112struct uea_softc {
113 struct usb_device *usb_dev;
114 struct usbatm_data *usbatm;
115
116 int modem_index;
117 unsigned int driver_info;
118
119 int booting;
120 int reset;
121
122 wait_queue_head_t sync_q;
123
124 struct task_struct *kthread;
125 u32 data;
126 wait_queue_head_t cmv_ack_wait;
127 int cmv_ack;
128
129 struct work_struct task;
130 u16 pageno;
131 u16 ovl;
132
133 const struct firmware *dsp_firm;
134 struct urb *urb_int;
135
136 u8 cmv_function;
137 u16 cmv_idx;
138 u32 cmv_address;
139 u16 cmv_offset;
140
141 /* keep in sync with eaglectl */
142 struct uea_stats {
143 struct {
144 u32 state;
145 u32 flags;
146 u32 mflags;
147 u32 vidcpe;
148 u32 vidco;
149 u32 dsrate;
150 u32 usrate;
151 u32 dsunc;
152 u32 usunc;
153 u32 dscorr;
154 u32 uscorr;
155 u32 txflow;
156 u32 rxflow;
157 u32 usattenuation;
158 u32 dsattenuation;
159 u32 dsmargin;
160 u32 usmargin;
161 u32 firmid;
162 } phy;
163 } stats;
164};
165
166/*
167 * Elsa IDs
168 */
169#define ELSA_VID 0x05CC
170#define ELSA_PID_PSTFIRM 0x3350
171#define ELSA_PID_PREFIRM 0x3351
172
173/*
174 * Sagem USB IDs
175 */
176#define EAGLE_VID 0x1110
177#define EAGLE_I_PID_PREFIRM 0x9010 /* Eagle I */
178#define EAGLE_I_PID_PSTFIRM 0x900F /* Eagle I */
179
180#define EAGLE_IIC_PID_PREFIRM 0x9024 /* Eagle IIC */
181#define EAGLE_IIC_PID_PSTFIRM 0x9023 /* Eagle IIC */
182
183#define EAGLE_II_PID_PREFIRM 0x9022 /* Eagle II */
184#define EAGLE_II_PID_PSTFIRM 0x9021 /* Eagle II */
185
186/*
187 * Eagle III Pid
188 */
189#define EAGLE_III_PID_PREFIRM 0x9032 /* Eagle III */
190#define EAGLE_III_PID_PSTFIRM 0x9031 /* Eagle III */
191
192/*
193 * USR USB IDs
194 */
195#define USR_VID 0x0BAF
196#define MILLER_A_PID_PREFIRM 0x00F2
197#define MILLER_A_PID_PSTFIRM 0x00F1
198#define MILLER_B_PID_PREFIRM 0x00FA
199#define MILLER_B_PID_PSTFIRM 0x00F9
200#define HEINEKEN_A_PID_PREFIRM 0x00F6
201#define HEINEKEN_A_PID_PSTFIRM 0x00F5
202#define HEINEKEN_B_PID_PREFIRM 0x00F8
203#define HEINEKEN_B_PID_PSTFIRM 0x00F7
204
205#define PREFIRM 0
206#define PSTFIRM (1<<7)
207enum {
208 ADI930 = 0,
209 EAGLE_I,
210 EAGLE_II,
211 EAGLE_III
212};
213
214/* macros for both struct usb_device_id and struct uea_softc */
215#define UEA_IS_PREFIRM(x) \
216 (!((x)->driver_info & PSTFIRM))
217#define UEA_CHIP_VERSION(x) \
218 ((x)->driver_info & 0xf)
219
220#define IS_ISDN(sc) \
221 (le16_to_cpu(sc->usb_dev->descriptor.bcdDevice) & 0x80)
222
223#define INS_TO_USBDEV(ins) ins->usb_dev
224
225#define GET_STATUS(data) \
226 ((data >> 8) & 0xf)
227#define IS_OPERATIONAL(sc) \
228 (GET_STATUS(sc->stats.phy.state) == 2)
229
230/*
231 * Set of macros to handle unaligned data in the firmware blob.
232 * The FW_GET_BYTE() macro is provided only for consistency.
233 */
234
235#define FW_GET_BYTE(p) *((__u8 *) (p))
236#define FW_GET_WORD(p) le16_to_cpu(get_unaligned((__le16 *) (p)))
237#define FW_GET_LONG(p) le32_to_cpu(get_unaligned((__le32 *) (p)))
238
239#define FW_DIR "ueagle-atm/"
240#define NB_MODEM 4
241
242#define BULK_TIMEOUT 300
243#define CTRL_TIMEOUT 1000
244
245#define ACK_TIMEOUT msecs_to_jiffies(1500)
246
247#define UEA_INTR_IFACE_NO 0
248#define UEA_US_IFACE_NO 1
249#define UEA_DS_IFACE_NO 2
250
251#define FASTEST_ISO_INTF 8
252
253#define UEA_BULK_DATA_PIPE 0x02
254#define UEA_IDMA_PIPE 0x04
255#define UEA_INTR_PIPE 0x04
256#define UEA_ISO_DATA_PIPE 0x08
257
258#define UEA_SET_BLOCK 0x0001
259#define UEA_SET_MODE 0x0003
260#define UEA_SET_2183_DATA 0x0004
261#define UEA_SET_TIMEOUT 0x0011
262
263#define UEA_LOOPBACK_OFF 0x0002
264#define UEA_LOOPBACK_ON 0x0003
265#define UEA_BOOT_IDMA 0x0006
266#define UEA_START_RESET 0x0007
267#define UEA_END_RESET 0x0008
268
269#define UEA_SWAP_MAILBOX (0x3fcd | 0x4000)
270#define UEA_MPTX_START (0x3fce | 0x4000)
271#define UEA_MPTX_MAILBOX (0x3fd6 | 0x4000)
272#define UEA_MPRX_MAILBOX (0x3fdf | 0x4000)
273
274/* structure describing a block within a DSP page */
275struct block_info {
276 __le16 wHdr;
277#define UEA_BIHDR 0xabcd
278 __le16 wAddress;
279 __le16 wSize;
280 __le16 wOvlOffset;
281 __le16 wOvl; /* overlay */
282 __le16 wLast;
283} __attribute__ ((packed));
284#define BLOCK_INFO_SIZE 12
285
286/* structure representing a CMV (Configuration and Management Variable) */
287struct cmv {
288 __le16 wPreamble;
289#define PREAMBLE 0x535c
290 __u8 bDirection;
291#define MODEMTOHOST 0x01
292#define HOSTTOMODEM 0x10
293 __u8 bFunction;
294#define FUNCTION_TYPE(f) ((f) >> 4)
295#define MEMACCESS 0x1
296#define ADSLDIRECTIVE 0x7
297
298#define FUNCTION_SUBTYPE(f) ((f) & 0x0f)
299/* for MEMACCESS */
300#define REQUESTREAD 0x0
301#define REQUESTWRITE 0x1
302#define REPLYREAD 0x2
303#define REPLYWRITE 0x3
304/* for ADSLDIRECTIVE */
305#define KERNELREADY 0x0
306#define MODEMREADY 0x1
307
308#define MAKEFUNCTION(t, s) (((t) & 0xf) << 4 | ((s) & 0xf))
309 __le16 wIndex;
310 __le32 dwSymbolicAddress;
311#define MAKESA(a, b, c, d) \
312 (((c) & 0xff) << 24 | \
313 ((d) & 0xff) << 16 | \
314 ((a) & 0xff) << 8 | \
315 ((b) & 0xff))
316
317#define SA_CNTL MAKESA('C', 'N', 'T', 'L')
318#define SA_DIAG MAKESA('D', 'I', 'A', 'G')
319#define SA_INFO MAKESA('I', 'N', 'F', 'O')
320#define SA_OPTN MAKESA('O', 'P', 'T', 'N')
321#define SA_RATE MAKESA('R', 'A', 'T', 'E')
322#define SA_STAT MAKESA('S', 'T', 'A', 'T')
323 __le16 wOffsetAddress;
324 __le32 dwData;
325} __attribute__ ((packed));
326#define CMV_SIZE 16
327
328/* structure representing swap information */
329struct swap_info {
330 __u8 bSwapPageNo;
331 __u8 bOvl; /* overlay */
332} __attribute__ ((packed));
333
334/* structure representing interrupt data */
335struct intr_pkt {
336 __u8 bType;
337 __u8 bNotification;
338 __le16 wValue;
339 __le16 wIndex;
340 __le16 wLength;
341 __le16 wInterrupt;
342#define INT_LOADSWAPPAGE 0x0001
343#define INT_INCOMINGCMV 0x0002
344 union {
345 struct {
346 struct swap_info swapinfo;
347 __le16 wDataSize;
348 } __attribute__ ((packed)) s1;
349
350 struct {
351 struct cmv cmv;
352 __le16 wDataSize;
353 } __attribute__ ((packed)) s2;
354 } __attribute__ ((packed)) u;
355#define bSwapPageNo u.s1.swapinfo.bSwapPageNo
356#define bOvl u.s1.swapinfo.bOvl
357} __attribute__ ((packed));
358#define INTR_PKT_SIZE 28
359
360static struct usb_driver uea_driver;
361static DECLARE_MUTEX(uea_semaphore);
362static const char *chip_name[] = {"ADI930", "Eagle I", "Eagle II", "Eagle III"};
363
364static int modem_index;
365static unsigned int debug;
366static int sync_wait[NB_MODEM];
367static char *cmv_file[NB_MODEM];
368
369module_param(debug, uint, 0644);
370MODULE_PARM_DESC(debug, "module debug level (0=off,1=on,2=verbose)");
371module_param_array(sync_wait, bool, NULL, 0644);
372MODULE_PARM_DESC(sync_wait, "wait the synchronisation before starting ATM");
373module_param_array(cmv_file, charp, NULL, 0644);
374MODULE_PARM_DESC(cmv_file,
375 "file name with configuration and management variables");
376
377#define UPDATE_ATM_STAT(type, val) \
378 do { \
379 if (sc->usbatm->atm_dev) \
380 sc->usbatm->atm_dev->type = val; \
381 } while (0)
382
383/* Firmware loading */
384#define LOAD_INTERNAL 0xA0
385#define F8051_USBCS 0x7f92
386
387/**
388 * uea_send_modem_cmd - Send a command for pre-firmware devices.
389 */
390static int uea_send_modem_cmd(struct usb_device *usb,
391 u16 addr, u16 size, u8 * buff)
392{
393 int ret = -ENOMEM;
394 u8 *xfer_buff;
395
396 xfer_buff = kmalloc(size, GFP_KERNEL);
397 if (xfer_buff) {
398 memcpy(xfer_buff, buff, size);
399 ret = usb_control_msg(usb,
400 usb_sndctrlpipe(usb, 0),
401 LOAD_INTERNAL,
402 USB_DIR_OUT | USB_TYPE_VENDOR |
403 USB_RECIP_DEVICE, addr, 0, xfer_buff,
404 size, CTRL_TIMEOUT);
405 kfree(xfer_buff);
406 }
407
408 if (ret < 0)
409 return ret;
410
411 return (ret == size) ? 0 : -EIO;
412}
413
414static void uea_upload_pre_firmware(const struct firmware *fw_entry, void *context)
415{
416 struct usb_device *usb = context;
417 u8 *pfw, value;
418 u32 crc = 0;
419 int ret, size;
420
421 uea_enters(usb);
422 if (!fw_entry) {
423 uea_err(usb, "firmware is not available\n");
424 goto err;
425 }
426
427 pfw = fw_entry->data;
428 size = fw_entry->size;
429 if (size < 4)
430 goto err_fw_corrupted;
431
432 crc = FW_GET_LONG(pfw);
433 pfw += 4;
434 size -= 4;
435 if (crc32_be(0, pfw, size) != crc)
436 goto err_fw_corrupted;
437
438 /*
439 * Start to upload formware : send reset
440 */
441 value = 1;
442 ret = uea_send_modem_cmd(usb, F8051_USBCS, sizeof(value), &value);
443
444 if (ret < 0) {
445 uea_err(usb, "modem reset failed with error %d\n", ret);
446 goto err;
447 }
448
449 while (size > 3) {
450 u8 len = FW_GET_BYTE(pfw);
451 u16 add = FW_GET_WORD(pfw + 1);
452
453 size -= len + 3;
454 if (size < 0)
455 goto err_fw_corrupted;
456
457 ret = uea_send_modem_cmd(usb, add, len, pfw + 3);
458 if (ret < 0) {
459 uea_err(usb, "uploading firmware data failed "
460 "with error %d\n", ret);
461 goto err;
462 }
463 pfw += len + 3;
464 }
465
466 if (size != 0)
467 goto err_fw_corrupted;
468
469 /*
470 * Tell the modem we finish : de-assert reset
471 */
472 value = 0;
473 ret = uea_send_modem_cmd(usb, F8051_USBCS, 1, &value);
474 if (ret < 0)
475 uea_err(usb, "modem de-assert failed with error %d\n", ret);
476 else
477 uea_info(usb, "firmware uploaded\n");
478
479 uea_leaves(usb);
480 return;
481
482err_fw_corrupted:
483 uea_err(usb, "firmware is corrupted\n");
484err:
485 uea_leaves(usb);
486}
487
488/**
489 * uea_load_firmware - Load usb firmware for pre-firmware devices.
490 */
491static int uea_load_firmware(struct usb_device *usb, unsigned int ver)
492{
493 int ret;
494 char *fw_name = FW_DIR "eagle.fw";
495
496 uea_enters(usb);
497 uea_info(usb, "pre-firmware device, uploading firmware\n");
498
499 switch (ver) {
500 case ADI930:
501 fw_name = FW_DIR "adi930.fw";
502 break;
503 case EAGLE_I:
504 fw_name = FW_DIR "eagleI.fw";
505 break;
506 case EAGLE_II:
507 fw_name = FW_DIR "eagleII.fw";
508 break;
509 case EAGLE_III:
510 fw_name = FW_DIR "eagleIII.fw";
511 break;
512 }
513
514 ret = request_firmware_nowait(THIS_MODULE, 1, fw_name, &usb->dev, usb, uea_upload_pre_firmware);
515 if (ret)
516 uea_err(usb, "firmware %s is not available\n", fw_name);
517 else
518 uea_info(usb, "loading firmware %s\n", fw_name);
519
520 uea_leaves(usb);
521 return ret;
522}
523
524/* modem management : dsp firmware, send/read CMV, monitoring statistic
525 */
526
527/*
528 * Make sure that the DSP code provided is safe to use.
529 */
530static int check_dsp(u8 *dsp, unsigned int len)
531{
532 u8 pagecount, blockcount;
533 u16 blocksize;
534 u32 pageoffset;
535 unsigned int i, j, p, pp;
536
537 pagecount = FW_GET_BYTE(dsp);
538 p = 1;
539
540 /* enough space for page offsets? */
541 if (p + 4 * pagecount > len)
542 return 1;
543
544 for (i = 0; i < pagecount; i++) {
545
546 pageoffset = FW_GET_LONG(dsp + p);
547 p += 4;
548
549 if (pageoffset == 0)
550 continue;
551
552 /* enough space for blockcount? */
553 if (pageoffset >= len)
554 return 1;
555
556 pp = pageoffset;
557 blockcount = FW_GET_BYTE(dsp + pp);
558 pp += 1;
559
560 for (j = 0; j < blockcount; j++) {
561
562 /* enough space for block header? */
563 if (pp + 4 > len)
564 return 1;
565
566 pp += 2; /* skip blockaddr */
567 blocksize = FW_GET_WORD(dsp + pp);
568 pp += 2;
569
570 /* enough space for block data? */
571 if (pp + blocksize > len)
572 return 1;
573
574 pp += blocksize;
575 }
576 }
577
578 return 0;
579}
580
581/*
582 * send data to the idma pipe
583 * */
584static int uea_idma_write(struct uea_softc *sc, void *data, u32 size)
585{
586 int ret = -ENOMEM;
587 u8 *xfer_buff;
588 int bytes_read;
589
590 xfer_buff = kmalloc(size, GFP_KERNEL);
591 if (!xfer_buff) {
592 uea_err(INS_TO_USBDEV(sc), "can't allocate xfer_buff\n");
593 return ret;
594 }
595
596 memcpy(xfer_buff, data, size);
597
598 ret = usb_bulk_msg(sc->usb_dev,
599 usb_sndbulkpipe(sc->usb_dev, UEA_IDMA_PIPE),
600 xfer_buff, size, &bytes_read, BULK_TIMEOUT);
601
602 kfree(xfer_buff);
603 if (ret < 0)
604 return ret;
605 if (size != bytes_read) {
606 uea_err(INS_TO_USBDEV(sc), "size != bytes_read %d %d\n", size,
607 bytes_read);
608 return -EIO;
609 }
610
611 return 0;
612}
613
614static int request_dsp(struct uea_softc *sc)
615{
616 int ret;
617 char *dsp_name;
618
619 if (UEA_CHIP_VERSION(sc) == ADI930) {
620 if (IS_ISDN(sc))
621 dsp_name = FW_DIR "DSP9i.bin";
622 else
623 dsp_name = FW_DIR "DSP9p.bin";
624 } else {
625 if (IS_ISDN(sc))
626 dsp_name = FW_DIR "DSPei.bin";
627 else
628 dsp_name = FW_DIR "DSPep.bin";
629 }
630
631 ret = request_firmware(&sc->dsp_firm,
632 dsp_name, &sc->usb_dev->dev);
633 if (ret < 0) {
634 uea_err(INS_TO_USBDEV(sc),
635 "requesting firmware %s failed with error %d\n",
636 dsp_name, ret);
637 return ret;
638 }
639
640 if (check_dsp(sc->dsp_firm->data, sc->dsp_firm->size)) {
641 uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n",
642 dsp_name);
643 release_firmware(sc->dsp_firm);
644 sc->dsp_firm = NULL;
645 return -EILSEQ;
646 }
647
648 return 0;
649}
650
651/*
652 * The uea_load_page() function must be called within a process context
653 */
654static void uea_load_page(void *xsc)
655{
656 struct uea_softc *sc = xsc;
657 u16 pageno = sc->pageno;
658 u16 ovl = sc->ovl;
659 struct block_info bi;
660
661 u8 *p;
662 u8 pagecount, blockcount;
663 u16 blockaddr, blocksize;
664 u32 pageoffset;
665 int i;
666
667 /* reload firmware when reboot start and it's loaded already */
668 if (ovl == 0 && pageno == 0 && sc->dsp_firm) {
669 release_firmware(sc->dsp_firm);
670 sc->dsp_firm = NULL;
671 }
672
673 if (sc->dsp_firm == NULL && request_dsp(sc) < 0)
674 return;
675
676 p = sc->dsp_firm->data;
677 pagecount = FW_GET_BYTE(p);
678 p += 1;
679
680 if (pageno >= pagecount)
681 goto bad1;
682
683 p += 4 * pageno;
684 pageoffset = FW_GET_LONG(p);
685
686 if (pageoffset == 0)
687 goto bad1;
688
689 p = sc->dsp_firm->data + pageoffset;
690 blockcount = FW_GET_BYTE(p);
691 p += 1;
692
693 uea_dbg(INS_TO_USBDEV(sc),
694 "sending %u blocks for DSP page %u\n", blockcount, pageno);
695
696 bi.wHdr = cpu_to_le16(UEA_BIHDR);
697 bi.wOvl = cpu_to_le16(ovl);
698 bi.wOvlOffset = cpu_to_le16(ovl | 0x8000);
699
700 for (i = 0; i < blockcount; i++) {
701 blockaddr = FW_GET_WORD(p);
702 p += 2;
703
704 blocksize = FW_GET_WORD(p);
705 p += 2;
706
707 bi.wSize = cpu_to_le16(blocksize);
708 bi.wAddress = cpu_to_le16(blockaddr);
709 bi.wLast = cpu_to_le16((i == blockcount - 1) ? 1 : 0);
710
711 /* send block info through the IDMA pipe */
712 if (uea_idma_write(sc, &bi, BLOCK_INFO_SIZE))
713 goto bad2;
714
715 /* send block data through the IDMA pipe */
716 if (uea_idma_write(sc, p, blocksize))
717 goto bad2;
718
719 p += blocksize;
720 }
721
722 return;
723
724bad2:
725 uea_err(INS_TO_USBDEV(sc), "sending DSP block %u failed\n", i);
726 return;
727bad1:
728 uea_err(INS_TO_USBDEV(sc), "invalid DSP page %u requested\n",pageno);
729}
730
731static inline void wake_up_cmv_ack(struct uea_softc *sc)
732{
733 sc->cmv_ack = 1;
734 wake_up(&sc->cmv_ack_wait);
735}
736
737static inline int wait_cmv_ack(struct uea_softc *sc)
738{
739 int ret = wait_event_timeout(sc->cmv_ack_wait,
740 sc->cmv_ack, ACK_TIMEOUT);
741 sc->cmv_ack = 0;
742
743 if (ret < 0)
744 return ret;
745
746 return (ret == 0) ? -ETIMEDOUT : 0;
747
748}
749
750#define UCDC_SEND_ENCAPSULATED_COMMAND 0x00
751
752static int uea_request(struct uea_softc *sc,
753 u16 value, u16 index, u16 size, void *data)
754{
755 u8 *xfer_buff;
756 int ret = -ENOMEM;
757
758 xfer_buff = kmalloc(size, GFP_KERNEL);
759 if (!xfer_buff) {
760 uea_err(INS_TO_USBDEV(sc), "can't allocate xfer_buff\n");
761 return ret;
762 }
763 memcpy(xfer_buff, data, size);
764
765 ret = usb_control_msg(sc->usb_dev, usb_sndctrlpipe(sc->usb_dev, 0),
766 UCDC_SEND_ENCAPSULATED_COMMAND,
767 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
768 value, index, xfer_buff, size, CTRL_TIMEOUT);
769
770 kfree(xfer_buff);
771 if (ret < 0) {
772 uea_err(INS_TO_USBDEV(sc), "usb_control_msg error %d\n", ret);
773 return ret;
774 }
775
776 if (ret != size) {
777 uea_err(INS_TO_USBDEV(sc),
778 "usb_control_msg send only %d bytes (instead of %d)\n",
779 ret, size);
780 return -EIO;
781 }
782
783 return 0;
784}
785
786static int uea_cmv(struct uea_softc *sc,
787 u8 function, u32 address, u16 offset, u32 data)
788{
789 struct cmv cmv;
790 int ret;
791
792 /* we send a request, but we expect a reply */
793 sc->cmv_function = function | 0x2;
794 sc->cmv_idx++;
795 sc->cmv_address = address;
796 sc->cmv_offset = offset;
797
798 cmv.wPreamble = cpu_to_le16(PREAMBLE);
799 cmv.bDirection = HOSTTOMODEM;
800 cmv.bFunction = function;
801 cmv.wIndex = cpu_to_le16(sc->cmv_idx);
802 put_unaligned(cpu_to_le32(address), &cmv.dwSymbolicAddress);
803 cmv.wOffsetAddress = cpu_to_le16(offset);
804 put_unaligned(cpu_to_le32(data >> 16 | data << 16), &cmv.dwData);
805
806 ret = uea_request(sc, UEA_SET_BLOCK, UEA_MPTX_START, CMV_SIZE, &cmv);
807 if (ret < 0)
808 return ret;
809 return wait_cmv_ack(sc);
810}
811
812static inline int uea_read_cmv(struct uea_softc *sc,
813 u32 address, u16 offset, u32 *data)
814{
815 int ret = uea_cmv(sc, MAKEFUNCTION(MEMACCESS, REQUESTREAD),
816 address, offset, 0);
817 if (ret < 0)
818 uea_err(INS_TO_USBDEV(sc),
819 "reading cmv failed with error %d\n", ret);
820 else
821 *data = sc->data;
822
823 return ret;
824}
825
826static inline int uea_write_cmv(struct uea_softc *sc,
827 u32 address, u16 offset, u32 data)
828{
829 int ret = uea_cmv(sc, MAKEFUNCTION(MEMACCESS, REQUESTWRITE),
830 address, offset, data);
831 if (ret < 0)
832 uea_err(INS_TO_USBDEV(sc),
833 "writing cmv failed with error %d\n", ret);
834
835 return ret;
836}
837
838/*
839 * Monitor the modem and update the stat
840 * return 0 if everything is ok
841 * return < 0 if an error occurs (-EAGAIN reboot needed)
842 */
843static int uea_stat(struct uea_softc *sc)
844{
845 u32 data;
846 int ret;
847
848 uea_enters(INS_TO_USBDEV(sc));
849 data = sc->stats.phy.state;
850
851 ret = uea_read_cmv(sc, SA_STAT, 0, &sc->stats.phy.state);
852 if (ret < 0)
853 return ret;
854
855 switch (GET_STATUS(sc->stats.phy.state)) {
856 case 0: /* not yet synchronized */
857 uea_dbg(INS_TO_USBDEV(sc),
858 "modem not yet synchronized\n");
859 return 0;
860
861 case 1: /* initialization */
862 uea_dbg(INS_TO_USBDEV(sc), "modem initializing\n");
863 return 0;
864
865 case 2: /* operational */
866 uea_vdbg(INS_TO_USBDEV(sc), "modem operational\n");
867 break;
868
869 case 3: /* fail ... */
870 uea_info(INS_TO_USBDEV(sc), "modem synchronization failed\n");
871 return -EAGAIN;
872
873 case 4 ... 6: /* test state */
874 uea_warn(INS_TO_USBDEV(sc),
875 "modem in test mode - not supported\n");
876 return -EAGAIN;
877
878 case 7: /* fast-retain ... */
879 uea_info(INS_TO_USBDEV(sc), "modem in fast-retain mode\n");
880 return 0;
881 default:
882 uea_err(INS_TO_USBDEV(sc), "modem invalid SW mode %d\n",
883 GET_STATUS(sc->stats.phy.state));
884 return -EAGAIN;
885 }
886
887 if (GET_STATUS(data) != 2) {
888 uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_OFF, 0, NULL);
889 uea_info(INS_TO_USBDEV(sc), "modem operational\n");
890
891 /* release the dsp firmware as it is not needed until
892 * the next failure
893 */
894 if (sc->dsp_firm) {
895 release_firmware(sc->dsp_firm);
896 sc->dsp_firm = NULL;
897 }
898
899 ret = uea_read_cmv(sc, SA_INFO, 10, &sc->stats.phy.firmid);
900 if (ret < 0)
901 return ret;
902 uea_info(INS_TO_USBDEV(sc), "ATU-R firmware version : %x\n",
903 sc->stats.phy.firmid);
904 }
905
906 /* always update it as atm layer could not be init when we switch to
907 * operational state
908 */
909 UPDATE_ATM_STAT(signal, ATM_PHY_SIG_FOUND);
910
911 /* wake up processes waiting for synchronization */
912 wake_up(&sc->sync_q);
913
914 ret = uea_read_cmv(sc, SA_DIAG, 2, &sc->stats.phy.flags);
915 if (ret < 0)
916 return ret;
917 sc->stats.phy.mflags |= sc->stats.phy.flags;
918
919 /* in case of a flags ( for example delineation LOSS (& 0x10)),
920 * we check the status again in order to detect the failure earlier
921 */
922 if (sc->stats.phy.flags) {
923 uea_dbg(INS_TO_USBDEV(sc), "Stat flag = %d\n",
924 sc->stats.phy.flags);
925 return 0;
926 }
927
928 ret = uea_read_cmv(sc, SA_RATE, 0, &data);
929 if (ret < 0)
930 return ret;
931
932 /* in bulk mode the modem have problem with high rate
933 * changing internal timing could improve things, but the
934 * value is misterious.
935 * ADI930 don't support it (-EPIPE error).
936 */
937 if (UEA_CHIP_VERSION(sc) != ADI930
938 && sc->stats.phy.dsrate != (data >> 16) * 32) {
939 /* Original timming from ADI(used in windows driver)
940 * 0x20ffff>>16 * 32 = 32 * 32 = 1Mbits
941 */
942 u16 timeout = (data <= 0x20ffff) ? 0 : 1;
943 ret = uea_request(sc, UEA_SET_TIMEOUT, timeout, 0, NULL);
944 uea_info(INS_TO_USBDEV(sc),
945 "setting new timeout %d%s\n", timeout,
946 ret < 0?" failed":"");
947 }
948 sc->stats.phy.dsrate = (data >> 16) * 32;
949 sc->stats.phy.usrate = (data & 0xffff) * 32;
950 UPDATE_ATM_STAT(link_rate, sc->stats.phy.dsrate * 1000 / 424);
951
952 ret = uea_read_cmv(sc, SA_DIAG, 23, &data);
953 if (ret < 0)
954 return ret;
955 sc->stats.phy.dsattenuation = (data & 0xff) / 2;
956
957 ret = uea_read_cmv(sc, SA_DIAG, 47, &data);
958 if (ret < 0)
959 return ret;
960 sc->stats.phy.usattenuation = (data & 0xff) / 2;
961
962 ret = uea_read_cmv(sc, SA_DIAG, 25, &sc->stats.phy.dsmargin);
963 if (ret < 0)
964 return ret;
965
966 ret = uea_read_cmv(sc, SA_DIAG, 49, &sc->stats.phy.usmargin);
967 if (ret < 0)
968 return ret;
969
970 ret = uea_read_cmv(sc, SA_DIAG, 51, &sc->stats.phy.rxflow);
971 if (ret < 0)
972 return ret;
973
974 ret = uea_read_cmv(sc, SA_DIAG, 52, &sc->stats.phy.txflow);
975 if (ret < 0)
976 return ret;
977
978 ret = uea_read_cmv(sc, SA_DIAG, 54, &sc->stats.phy.dsunc);
979 if (ret < 0)
980 return ret;
981
982 /* only for atu-c */
983 ret = uea_read_cmv(sc, SA_DIAG, 58, &sc->stats.phy.usunc);
984 if (ret < 0)
985 return ret;
986
987 ret = uea_read_cmv(sc, SA_DIAG, 53, &sc->stats.phy.dscorr);
988 if (ret < 0)
989 return ret;
990
991 /* only for atu-c */
992 ret = uea_read_cmv(sc, SA_DIAG, 57, &sc->stats.phy.uscorr);
993 if (ret < 0)
994 return ret;
995
996 ret = uea_read_cmv(sc, SA_INFO, 8, &sc->stats.phy.vidco);
997 if (ret < 0)
998 return ret;
999
1000 ret = uea_read_cmv(sc, SA_INFO, 13, &sc->stats.phy.vidcpe);
1001 if (ret < 0)
1002 return ret;
1003
1004 return 0;
1005}
1006
1007static int request_cmvs(struct uea_softc *sc,
1008 struct uea_cmvs **cmvs, const struct firmware **fw)
1009{
1010 int ret, size;
1011 u8 *data;
1012 char *file;
1013 static char cmv_name[256] = FW_DIR;
1014
1015 if (cmv_file[sc->modem_index] == NULL) {
1016 if (UEA_CHIP_VERSION(sc) == ADI930)
1017 file = (IS_ISDN(sc)) ? "CMV9i.bin" : "CMV9p.bin";
1018 else
1019 file = (IS_ISDN(sc)) ? "CMVei.bin" : "CMVep.bin";
1020 } else
1021 file = cmv_file[sc->modem_index];
1022
1023 strcpy(cmv_name, FW_DIR);
1024 strlcat(cmv_name, file, sizeof(cmv_name));
1025
1026 ret = request_firmware(fw, cmv_name, &sc->usb_dev->dev);
1027 if (ret < 0) {
1028 uea_err(INS_TO_USBDEV(sc),
1029 "requesting firmware %s failed with error %d\n",
1030 cmv_name, ret);
1031 return ret;
1032 }
1033
1034 data = (u8 *) (*fw)->data;
1035 size = *data * sizeof(struct uea_cmvs) + 1;
1036 if (size != (*fw)->size) {
1037 uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n",
1038 cmv_name);
1039 release_firmware(*fw);
1040 return -EILSEQ;
1041 }
1042
1043 *cmvs = (struct uea_cmvs *)(data + 1);
1044 return *data;
1045}
1046
1047/* Start boot post firmware modem:
1048 * - send reset commands through usb control pipe
1049 * - start workqueue for DSP loading
1050 * - send CMV options to modem
1051 */
1052
1053static int uea_start_reset(struct uea_softc *sc)
1054{
1055 u16 zero = 0; /* ;-) */
1056 int i, len, ret;
1057 struct uea_cmvs *cmvs;
1058 const struct firmware *cmvs_fw;
1059
1060 uea_enters(INS_TO_USBDEV(sc));
1061 uea_info(INS_TO_USBDEV(sc), "(re)booting started\n");
1062
1063 sc->booting = 1;
1064 UPDATE_ATM_STAT(signal, ATM_PHY_SIG_LOST);
1065
1066 /* reset statistics */
1067 memset(&sc->stats, 0, sizeof(struct uea_stats));
1068
1069 /* tell the modem that we want to boot in IDMA mode */
1070 uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_ON, 0, NULL);
1071 uea_request(sc, UEA_SET_MODE, UEA_BOOT_IDMA, 0, NULL);
1072
1073 /* enter reset mode */
1074 uea_request(sc, UEA_SET_MODE, UEA_START_RESET, 0, NULL);
1075
1076 /* original driver use 200ms, but windows driver use 100ms */
1077 msleep(100);
1078
1079 /* leave reset mode */
1080 uea_request(sc, UEA_SET_MODE, UEA_END_RESET, 0, NULL);
1081
1082 /* clear tx and rx mailboxes */
1083 uea_request(sc, UEA_SET_2183_DATA, UEA_MPTX_MAILBOX, 2, &zero);
1084 uea_request(sc, UEA_SET_2183_DATA, UEA_MPRX_MAILBOX, 2, &zero);
1085 uea_request(sc, UEA_SET_2183_DATA, UEA_SWAP_MAILBOX, 2, &zero);
1086
1087 msleep(1000);
1088 sc->cmv_function = MAKEFUNCTION(ADSLDIRECTIVE, MODEMREADY);
1089 sc->booting = 0;
1090
1091 /* start loading DSP */
1092 sc->pageno = 0;
1093 sc->ovl = 0;
1094 schedule_work(&sc->task);
1095
1096 /* wait for modem ready CMV */
1097 ret = wait_cmv_ack(sc);
1098 if (ret < 0)
1099 return ret;
1100
1101 /* Enter in R-IDLE (cmv) until instructed otherwise */
1102 ret = uea_write_cmv(sc, SA_CNTL, 0, 1);
1103 if (ret < 0)
1104 return ret;
1105
1106 /* get options */
1107 ret = len = request_cmvs(sc, &cmvs, &cmvs_fw);
1108 if (ret < 0)
1109 return ret;
1110
1111 /* send options */
1112 for (i = 0; i < len; i++) {
1113 ret = uea_write_cmv(sc, FW_GET_LONG(&cmvs[i].address),
1114 FW_GET_WORD(&cmvs[i].offset),
1115 FW_GET_LONG(&cmvs[i].data));
1116 if (ret < 0)
1117 goto out;
1118 }
1119 /* Enter in R-ACT-REQ */
1120 ret = uea_write_cmv(sc, SA_CNTL, 0, 2);
1121out:
1122 release_firmware(cmvs_fw);
1123 sc->reset = 0;
1124 uea_leaves(INS_TO_USBDEV(sc));
1125 return ret;
1126}
1127
1128/*
1129 * In case of an error wait 1s before rebooting the modem
1130 * if the modem don't request reboot (-EAGAIN).
1131 * Monitor the modem every 1s.
1132 */
1133
1134static int uea_kthread(void *data)
1135{
1136 struct uea_softc *sc = data;
1137 int ret = -EAGAIN;
1138
1139 uea_enters(INS_TO_USBDEV(sc));
1140 while (!kthread_should_stop()) {
1141 if (ret < 0 || sc->reset)
1142 ret = uea_start_reset(sc);
1143 if (!ret)
1144 ret = uea_stat(sc);
1145 if (ret != -EAGAIN)
1146 msleep(1000);
1147 }
1148 uea_leaves(INS_TO_USBDEV(sc));
1149 return ret;
1150}
1151
1152/* Load second usb firmware for ADI930 chip */
1153static int load_XILINX_firmware(struct uea_softc *sc)
1154{
1155 const struct firmware *fw_entry;
1156 int ret, size, u, ln;
1157 u8 *pfw, value;
1158 char *fw_name = FW_DIR "930-fpga.bin";
1159
1160 uea_enters(INS_TO_USBDEV(sc));
1161
1162 ret = request_firmware(&fw_entry, fw_name, &sc->usb_dev->dev);
1163 if (ret) {
1164 uea_err(INS_TO_USBDEV(sc), "firmware %s is not available\n",
1165 fw_name);
1166 goto err0;
1167 }
1168
1169 pfw = fw_entry->data;
1170 size = fw_entry->size;
1171 if (size != 0x577B) {
1172 uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n",
1173 fw_name);
1174 ret = -EILSEQ;
1175 goto err1;
1176 }
1177 for (u = 0; u < size; u += ln) {
1178 ln = min(size - u, 64);
1179 ret = uea_request(sc, 0xe, 0, ln, pfw + u);
1180 if (ret < 0) {
1181 uea_err(INS_TO_USBDEV(sc),
1182 "elsa download data failed (%d)\n", ret);
1183 goto err1;
1184 }
1185 }
1186
1187 /* finish to send the fpga
1188 */
1189 ret = uea_request(sc, 0xe, 1, 0, NULL);
1190 if (ret < 0) {
1191 uea_err(INS_TO_USBDEV(sc),
1192 "elsa download data failed (%d)\n", ret);
1193 goto err1;
1194 }
1195
1196 /*
1197 * Tell the modem we finish : de-assert reset
1198 */
1199 value = 0;
1200 ret = uea_send_modem_cmd(sc->usb_dev, 0xe, 1, &value);
1201 if (ret < 0)
1202 uea_err(sc->usb_dev, "elsa de-assert failed with error %d\n", ret);
1203
1204
1205err1:
1206 release_firmware(fw_entry);
1207err0:
1208 uea_leaves(INS_TO_USBDEV(sc));
1209 return ret;
1210}
1211
1212static void uea_dispatch_cmv(struct uea_softc *sc, struct cmv* cmv)
1213{
1214 uea_enters(INS_TO_USBDEV(sc));
1215 if (le16_to_cpu(cmv->wPreamble) != PREAMBLE)
1216 goto bad1;
1217
1218 if (cmv->bDirection != MODEMTOHOST)
1219 goto bad1;
1220
1221 /* FIXME : ADI930 reply wrong preambule (func = 2, sub = 2) to
1222 * the first MEMACESS cmv. Ignore it...
1223 */
1224 if (cmv->bFunction != sc->cmv_function) {
1225 if (UEA_CHIP_VERSION(sc) == ADI930
1226 && cmv->bFunction == MAKEFUNCTION(2, 2)) {
1227 cmv->wIndex = cpu_to_le16(sc->cmv_idx);
1228 put_unaligned(cpu_to_le32(sc->cmv_address), &cmv->dwSymbolicAddress);
1229 cmv->wOffsetAddress = cpu_to_le16(sc->cmv_offset);
1230 }
1231 else
1232 goto bad2;
1233 }
1234
1235 if (cmv->bFunction == MAKEFUNCTION(ADSLDIRECTIVE, MODEMREADY)) {
1236 wake_up_cmv_ack(sc);
1237 return;
1238 }
1239
1240 /* in case of MEMACCESS */
1241 if (le16_to_cpu(cmv->wIndex) != sc->cmv_idx ||
1242 le32_to_cpu(get_unaligned(&cmv->dwSymbolicAddress)) !=
1243 sc->cmv_address
1244 || le16_to_cpu(cmv->wOffsetAddress) != sc->cmv_offset)
1245 goto bad2;
1246
1247 sc->data = le32_to_cpu(get_unaligned(&cmv->dwData));
1248 sc->data = sc->data << 16 | sc->data >> 16;
1249
1250 wake_up_cmv_ack(sc);
1251 return;
1252
1253bad2:
1254 uea_err(INS_TO_USBDEV(sc), "unexpected cmv received,"
1255 "Function : %d, Subfunction : %d\n",
1256 FUNCTION_TYPE(cmv->bFunction),
1257 FUNCTION_SUBTYPE(cmv->bFunction));
1258 return;
1259
1260bad1:
1261 uea_err(INS_TO_USBDEV(sc), "invalid cmv received, "
1262 "wPreamble %d, bDirection %d\n",
1263 le16_to_cpu(cmv->wPreamble), cmv->bDirection);
1264}
1265
1266/*
1267 * interrupt handler
1268 */
1269static void uea_intr(struct urb *urb, struct pt_regs *regs)
1270{
1271 struct uea_softc *sc = (struct uea_softc *)urb->context;
1272 struct intr_pkt *intr;
1273 uea_enters(INS_TO_USBDEV(sc));
1274
1275 if (urb->status < 0) {
1276 uea_err(INS_TO_USBDEV(sc), "uea_intr() failed with %d\n",
1277 urb->status);
1278 return;
1279 }
1280
1281 intr = (struct intr_pkt *) urb->transfer_buffer;
1282
1283 /* device-to-host interrupt */
1284 if (intr->bType != 0x08 || sc->booting) {
1285 uea_err(INS_TO_USBDEV(sc), "wrong intr\n");
1286 // rebooting ?
1287 // sc->reset = 1;
1288 goto resubmit;
1289 }
1290
1291 switch (le16_to_cpu(intr->wInterrupt)) {
1292 case INT_LOADSWAPPAGE:
1293 sc->pageno = intr->bSwapPageNo;
1294 sc->ovl = intr->bOvl >> 4 | intr->bOvl << 4;
1295 schedule_work(&sc->task);
1296 break;
1297
1298 case INT_INCOMINGCMV:
1299 uea_dispatch_cmv(sc, &intr->u.s2.cmv);
1300 break;
1301
1302 default:
1303 uea_err(INS_TO_USBDEV(sc), "unknown intr %u\n",
1304 le16_to_cpu(intr->wInterrupt));
1305 }
1306
1307resubmit:
1308 usb_submit_urb(sc->urb_int, GFP_ATOMIC);
1309}
1310
1311/*
1312 * Start the modem : init the data and start kernel thread
1313 */
1314static int uea_boot(struct uea_softc *sc)
1315{
1316 int ret;
1317 struct intr_pkt *intr;
1318
1319 uea_enters(INS_TO_USBDEV(sc));
1320
1321 INIT_WORK(&sc->task, uea_load_page, sc);
1322 init_waitqueue_head(&sc->sync_q);
1323 init_waitqueue_head(&sc->cmv_ack_wait);
1324
1325 if (UEA_CHIP_VERSION(sc) == ADI930)
1326 load_XILINX_firmware(sc);
1327
1328 intr = kmalloc(INTR_PKT_SIZE, GFP_KERNEL);
1329 if (!intr) {
1330 uea_err(INS_TO_USBDEV(sc),
1331 "cannot allocate interrupt package\n");
1332 uea_leaves(INS_TO_USBDEV(sc));
1333 return -ENOMEM;
1334 }
1335
1336 sc->urb_int = usb_alloc_urb(0, GFP_KERNEL);
1337 if (!sc->urb_int) {
1338 uea_err(INS_TO_USBDEV(sc), "cannot allocate interrupt URB\n");
1339 goto err;
1340 }
1341
1342 usb_fill_int_urb(sc->urb_int, sc->usb_dev,
1343 usb_rcvintpipe(sc->usb_dev, UEA_INTR_PIPE),
1344 intr, INTR_PKT_SIZE, uea_intr, sc,
1345 sc->usb_dev->actconfig->interface[0]->altsetting[0].
1346 endpoint[0].desc.bInterval);
1347
1348 ret = usb_submit_urb(sc->urb_int, GFP_KERNEL);
1349 if (ret < 0) {
1350 uea_err(INS_TO_USBDEV(sc),
1351 "urb submition failed with error %d\n", ret);
1352 goto err1;
1353 }
1354
1355 sc->kthread = kthread_run(uea_kthread, sc, "ueagle-atm");
1356 if (sc->kthread == ERR_PTR(-ENOMEM)) {
1357 uea_err(INS_TO_USBDEV(sc), "failed to create thread\n");
1358 goto err2;
1359 }
1360
1361 uea_leaves(INS_TO_USBDEV(sc));
1362 return 0;
1363
1364err2:
1365 usb_kill_urb(sc->urb_int);
1366err1:
1367 kfree(intr);
1368err:
1369 usb_free_urb(sc->urb_int);
1370 uea_leaves(INS_TO_USBDEV(sc));
1371 return -ENOMEM;
1372}
1373
1374/*
1375 * Stop the modem : kill kernel thread and free data
1376 */
1377static void uea_stop(struct uea_softc *sc)
1378{
1379 int ret;
1380 uea_enters(INS_TO_USBDEV(sc));
1381 ret = kthread_stop(sc->kthread);
1382 uea_info(INS_TO_USBDEV(sc), "kthread finish with status %d\n", ret);
1383
1384 /* stop any pending boot process */
1385 flush_scheduled_work();
1386
1387 uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_ON, 0, NULL);
1388
1389 usb_kill_urb(sc->urb_int);
1390 kfree(sc->urb_int->transfer_buffer);
1391 usb_free_urb(sc->urb_int);
1392
1393 if (sc->dsp_firm)
1394 release_firmware(sc->dsp_firm);
1395 uea_leaves(INS_TO_USBDEV(sc));
1396}
1397
1398/* syfs interface */
1399static struct uea_softc *dev_to_uea(struct device *dev)
1400{
1401 struct usb_interface *intf;
1402 struct usbatm_data *usbatm;
1403
1404 intf = to_usb_interface(dev);
1405 if (!intf)
1406 return NULL;
1407
1408 usbatm = usb_get_intfdata(intf);
1409 if (!usbatm)
1410 return NULL;
1411
1412 return usbatm->driver_data;
1413}
1414
1415static ssize_t read_status(struct device *dev, struct device_attribute *attr,
1416 char *buf)
1417{
1418 int ret = -ENODEV;
1419 struct uea_softc *sc;
1420
1421 down(&uea_semaphore);
1422 sc = dev_to_uea(dev);
1423 if (!sc)
1424 goto out;
1425 ret = snprintf(buf, 10, "%08x\n", sc->stats.phy.state);
1426out:
1427 up(&uea_semaphore);
1428 return ret;
1429}
1430
1431static ssize_t reboot(struct device *dev, struct device_attribute *attr,
1432 const char *buf, size_t count)
1433{
1434 int ret = -ENODEV;
1435 struct uea_softc *sc;
1436
1437 down(&uea_semaphore);
1438 sc = dev_to_uea(dev);
1439 if (!sc)
1440 goto out;
1441 sc->reset = 1;
1442 ret = count;
1443out:
1444 up(&uea_semaphore);
1445 return ret;
1446}
1447
1448static DEVICE_ATTR(stat_status, S_IWUGO | S_IRUGO, read_status, reboot);
1449
1450static ssize_t read_human_status(struct device *dev, struct device_attribute *attr,
1451 char *buf)
1452{
1453 int ret = -ENODEV;
1454 struct uea_softc *sc;
1455
1456 down(&uea_semaphore);
1457 sc = dev_to_uea(dev);
1458 if (!sc)
1459 goto out;
1460
1461 switch (GET_STATUS(sc->stats.phy.state)) {
1462 case 0:
1463 ret = sprintf(buf, "Modem is booting\n");
1464 break;
1465 case 1:
1466 ret = sprintf(buf, "Modem is initializing\n");
1467 break;
1468 case 2:
1469 ret = sprintf(buf, "Modem is operational\n");
1470 break;
1471 default:
1472 ret = sprintf(buf, "Modem synchronization failed\n");
1473 break;
1474 }
1475out:
1476 up(&uea_semaphore);
1477 return ret;
1478}
1479
1480static DEVICE_ATTR(stat_human_status, S_IWUGO | S_IRUGO, read_human_status, NULL);
1481
1482static ssize_t read_delin(struct device *dev, struct device_attribute *attr,
1483 char *buf)
1484{
1485 int ret = -ENODEV;
1486 struct uea_softc *sc;
1487
1488 down(&uea_semaphore);
1489 sc = dev_to_uea(dev);
1490 if (!sc)
1491 goto out;
1492
1493 if (sc->stats.phy.flags & 0x0C00)
1494 ret = sprintf(buf, "ERROR\n");
1495 else if (sc->stats.phy.flags & 0x0030)
1496 ret = sprintf(buf, "LOSS\n");
1497 else
1498 ret = sprintf(buf, "GOOD\n");
1499out:
1500 up(&uea_semaphore);
1501 return ret;
1502}
1503
1504static DEVICE_ATTR(stat_delin, S_IWUGO | S_IRUGO, read_delin, NULL);
1505
1506#define UEA_ATTR(name, reset) \
1507 \
1508static ssize_t read_##name(struct device *dev, \
1509 struct device_attribute *attr, char *buf) \
1510{ \
1511 int ret = -ENODEV; \
1512 struct uea_softc *sc; \
1513 \
1514 down(&uea_semaphore); \
1515 sc = dev_to_uea(dev); \
1516 if (!sc) \
1517 goto out; \
1518 ret = snprintf(buf, 10, "%08x\n", sc->stats.phy.name); \
1519 if (reset) \
1520 sc->stats.phy.name = 0; \
1521out: \
1522 up(&uea_semaphore); \
1523 return ret; \
1524} \
1525 \
1526static DEVICE_ATTR(stat_##name, S_IRUGO, read_##name, NULL)
1527
1528UEA_ATTR(mflags, 1);
1529UEA_ATTR(vidcpe, 0);
1530UEA_ATTR(usrate, 0);
1531UEA_ATTR(dsrate, 0);
1532UEA_ATTR(usattenuation, 0);
1533UEA_ATTR(dsattenuation, 0);
1534UEA_ATTR(usmargin, 0);
1535UEA_ATTR(dsmargin, 0);
1536UEA_ATTR(txflow, 0);
1537UEA_ATTR(rxflow, 0);
1538UEA_ATTR(uscorr, 0);
1539UEA_ATTR(dscorr, 0);
1540UEA_ATTR(usunc, 0);
1541UEA_ATTR(dsunc, 0);
1542
1543/* Retrieve the device End System Identifier (MAC) */
1544
1545#define htoi(x) (isdigit(x) ? x-'0' : toupper(x)-'A'+10)
1546static int uea_getesi(struct uea_softc *sc, u_char * esi)
1547{
1548 unsigned char mac_str[2 * ETH_ALEN + 1];
1549 int i;
1550 if (usb_string
1551 (sc->usb_dev, sc->usb_dev->descriptor.iSerialNumber, mac_str,
1552 sizeof(mac_str)) != 2 * ETH_ALEN)
1553 return 1;
1554
1555 for (i = 0; i < ETH_ALEN; i++)
1556 esi[i] = htoi(mac_str[2 * i]) * 16 + htoi(mac_str[2 * i + 1]);
1557
1558 return 0;
1559}
1560
1561/* ATM stuff */
1562static int uea_atm_open(struct usbatm_data *usbatm, struct atm_dev *atm_dev)
1563{
1564 struct uea_softc *sc = usbatm->driver_data;
1565
1566 return uea_getesi(sc, atm_dev->esi);
1567}
1568
1569static int uea_heavy(struct usbatm_data *usbatm, struct usb_interface *intf)
1570{
1571 struct uea_softc *sc = usbatm->driver_data;
1572
1573 wait_event(sc->sync_q, IS_OPERATIONAL(sc));
1574
1575 return 0;
1576
1577}
1578
1579static int claim_interface(struct usb_device *usb_dev,
1580 struct usbatm_data *usbatm, int ifnum)
1581{
1582 int ret;
1583 struct usb_interface *intf = usb_ifnum_to_if(usb_dev, ifnum);
1584
1585 if (!intf) {
1586 uea_err(usb_dev, "interface %d not found\n", ifnum);
1587 return -ENODEV;
1588 }
1589
1590 ret = usb_driver_claim_interface(&uea_driver, intf, usbatm);
1591 if (ret != 0)
1592 uea_err(usb_dev, "can't claim interface %d, error %d\n", ifnum,
1593 ret);
1594 return ret;
1595}
1596
1597static void create_fs_entries(struct uea_softc *sc, struct usb_interface *intf)
1598{
1599 /* sysfs interface */
1600 device_create_file(&intf->dev, &dev_attr_stat_status);
1601 device_create_file(&intf->dev, &dev_attr_stat_mflags);
1602 device_create_file(&intf->dev, &dev_attr_stat_human_status);
1603 device_create_file(&intf->dev, &dev_attr_stat_delin);
1604 device_create_file(&intf->dev, &dev_attr_stat_vidcpe);
1605 device_create_file(&intf->dev, &dev_attr_stat_usrate);
1606 device_create_file(&intf->dev, &dev_attr_stat_dsrate);
1607 device_create_file(&intf->dev, &dev_attr_stat_usattenuation);
1608 device_create_file(&intf->dev, &dev_attr_stat_dsattenuation);
1609 device_create_file(&intf->dev, &dev_attr_stat_usmargin);
1610 device_create_file(&intf->dev, &dev_attr_stat_dsmargin);
1611 device_create_file(&intf->dev, &dev_attr_stat_txflow);
1612 device_create_file(&intf->dev, &dev_attr_stat_rxflow);
1613 device_create_file(&intf->dev, &dev_attr_stat_uscorr);
1614 device_create_file(&intf->dev, &dev_attr_stat_dscorr);
1615 device_create_file(&intf->dev, &dev_attr_stat_usunc);
1616 device_create_file(&intf->dev, &dev_attr_stat_dsunc);
1617}
1618
1619static int uea_bind(struct usbatm_data *usbatm, struct usb_interface *intf,
1620 const struct usb_device_id *id, int *heavy)
1621{
1622 struct usb_device *usb = interface_to_usbdev(intf);
1623 struct uea_softc *sc;
1624 int ret, ifnum = intf->altsetting->desc.bInterfaceNumber;
1625
1626 uea_enters(usb);
1627
1628 /* interface 0 is for firmware/monitoring */
1629 if (ifnum != UEA_INTR_IFACE_NO)
1630 return -ENODEV;
1631
1632 *heavy = sync_wait[modem_index];
1633
1634 /* interface 1 is for outbound traffic */
1635 ret = claim_interface(usb, usbatm, UEA_US_IFACE_NO);
1636 if (ret < 0)
1637 return ret;
1638
1639 /* ADI930 has only 2 interfaces and inbound traffic
1640 * is on interface 1
1641 */
1642 if (UEA_CHIP_VERSION(id) != ADI930) {
1643 /* interface 2 is for inbound traffic */
1644 ret = claim_interface(usb, usbatm, UEA_DS_IFACE_NO);
1645 if (ret < 0)
1646 return ret;
1647 }
1648
1649 sc = kzalloc(sizeof(struct uea_softc), GFP_KERNEL);
1650 if (!sc) {
1651 uea_err(INS_TO_USBDEV(sc), "uea_init: not enough memory !\n");
1652 return -ENOMEM;
1653 }
1654
1655 sc->usb_dev = usb;
1656 usbatm->driver_data = sc;
1657 sc->usbatm = usbatm;
1658 sc->modem_index = (modem_index < NB_MODEM) ? modem_index++ : 0;
1659 sc->driver_info = id->driver_info;
1660
1661 ret = uea_boot(sc);
1662 if (ret < 0) {
1663 kfree(sc);
1664 return ret;
1665 }
1666
1667 create_fs_entries(sc, intf);
1668 return 0;
1669}
1670
1671static void destroy_fs_entries(struct uea_softc *sc, struct usb_interface *intf)
1672{
1673 /* sysfs interface */
1674 device_remove_file(&intf->dev, &dev_attr_stat_status);
1675 device_remove_file(&intf->dev, &dev_attr_stat_mflags);
1676 device_remove_file(&intf->dev, &dev_attr_stat_human_status);
1677 device_remove_file(&intf->dev, &dev_attr_stat_delin);
1678 device_remove_file(&intf->dev, &dev_attr_stat_vidcpe);
1679 device_remove_file(&intf->dev, &dev_attr_stat_usrate);
1680 device_remove_file(&intf->dev, &dev_attr_stat_dsrate);
1681 device_remove_file(&intf->dev, &dev_attr_stat_usattenuation);
1682 device_remove_file(&intf->dev, &dev_attr_stat_dsattenuation);
1683 device_remove_file(&intf->dev, &dev_attr_stat_usmargin);
1684 device_remove_file(&intf->dev, &dev_attr_stat_dsmargin);
1685 device_remove_file(&intf->dev, &dev_attr_stat_txflow);
1686 device_remove_file(&intf->dev, &dev_attr_stat_rxflow);
1687 device_remove_file(&intf->dev, &dev_attr_stat_uscorr);
1688 device_remove_file(&intf->dev, &dev_attr_stat_dscorr);
1689 device_remove_file(&intf->dev, &dev_attr_stat_usunc);
1690 device_remove_file(&intf->dev, &dev_attr_stat_dsunc);
1691}
1692
1693static void uea_unbind(struct usbatm_data *usbatm, struct usb_interface *intf)
1694{
1695 struct uea_softc *sc = usbatm->driver_data;
1696
1697 destroy_fs_entries(sc, intf);
1698 uea_stop(sc);
1699 kfree(sc);
1700}
1701
1702static struct usbatm_driver uea_usbatm_driver = {
1703 .driver_name = "ueagle-atm",
1704 .owner = THIS_MODULE,
1705 .bind = uea_bind,
1706 .atm_start = uea_atm_open,
1707 .unbind = uea_unbind,
1708 .heavy_init = uea_heavy,
1709 .in = UEA_BULK_DATA_PIPE,
1710 .out = UEA_BULK_DATA_PIPE,
1711};
1712
1713static int uea_probe(struct usb_interface *intf, const struct usb_device_id *id)
1714{
1715 struct usb_device *usb = interface_to_usbdev(intf);
1716
1717 uea_enters(usb);
1718 uea_info(usb, "ADSL device founded vid (%#X) pid (%#X) : %s\n",
1719 le16_to_cpu(usb->descriptor.idVendor),
1720 le16_to_cpu(usb->descriptor.idProduct),
1721 chip_name[UEA_CHIP_VERSION(id)]);
1722
1723 usb_reset_device(usb);
1724
1725 if (UEA_IS_PREFIRM(id))
1726 return uea_load_firmware(usb, UEA_CHIP_VERSION(id));
1727
1728 return usbatm_usb_probe(intf, id, &uea_usbatm_driver);
1729}
1730
1731static void uea_disconnect(struct usb_interface *intf)
1732{
1733 struct usb_device *usb = interface_to_usbdev(intf);
1734 int ifnum = intf->altsetting->desc.bInterfaceNumber;
1735 uea_enters(usb);
1736
1737 /* ADI930 has 2 interfaces and eagle 3 interfaces.
1738 * Pre-firmware device has one interface
1739 */
1740 if (usb->config->desc.bNumInterfaces != 1 && ifnum == 0) {
1741 down(&uea_semaphore);
1742 usbatm_usb_disconnect(intf);
1743 up(&uea_semaphore);
1744 uea_info(usb, "ADSL device removed\n");
1745 }
1746
1747 uea_leaves(usb);
1748}
1749
1750/*
1751 * List of supported VID/PID
1752 */
1753static const struct usb_device_id uea_ids[] = {
1754 {USB_DEVICE(ELSA_VID, ELSA_PID_PREFIRM), .driver_info = ADI930 | PREFIRM},
1755 {USB_DEVICE(ELSA_VID, ELSA_PID_PSTFIRM), .driver_info = ADI930 | PSTFIRM},
1756 {USB_DEVICE(EAGLE_VID, EAGLE_I_PID_PREFIRM), .driver_info = EAGLE_I | PREFIRM},
1757 {USB_DEVICE(EAGLE_VID, EAGLE_I_PID_PSTFIRM), .driver_info = EAGLE_I | PSTFIRM},
1758 {USB_DEVICE(EAGLE_VID, EAGLE_II_PID_PREFIRM), .driver_info = EAGLE_II | PREFIRM},
1759 {USB_DEVICE(EAGLE_VID, EAGLE_II_PID_PSTFIRM), .driver_info = EAGLE_II | PSTFIRM},
1760 {USB_DEVICE(EAGLE_VID, EAGLE_IIC_PID_PREFIRM), .driver_info = EAGLE_II | PREFIRM},
1761 {USB_DEVICE(EAGLE_VID, EAGLE_IIC_PID_PSTFIRM), .driver_info = EAGLE_II | PSTFIRM},
1762 {USB_DEVICE(EAGLE_VID, EAGLE_III_PID_PREFIRM), .driver_info = EAGLE_III | PREFIRM},
1763 {USB_DEVICE(EAGLE_VID, EAGLE_III_PID_PSTFIRM), .driver_info = EAGLE_III | PSTFIRM},
1764 {USB_DEVICE(USR_VID, MILLER_A_PID_PREFIRM), .driver_info = EAGLE_I | PREFIRM},
1765 {USB_DEVICE(USR_VID, MILLER_A_PID_PSTFIRM), .driver_info = EAGLE_I | PSTFIRM},
1766 {USB_DEVICE(USR_VID, MILLER_B_PID_PREFIRM), .driver_info = EAGLE_I | PREFIRM},
1767 {USB_DEVICE(USR_VID, MILLER_B_PID_PSTFIRM), .driver_info = EAGLE_I | PSTFIRM},
1768 {USB_DEVICE(USR_VID, HEINEKEN_A_PID_PREFIRM),.driver_info = EAGLE_I | PREFIRM},
1769 {USB_DEVICE(USR_VID, HEINEKEN_A_PID_PSTFIRM),.driver_info = EAGLE_I | PSTFIRM},
1770 {USB_DEVICE(USR_VID, HEINEKEN_B_PID_PREFIRM),.driver_info = EAGLE_I | PREFIRM},
1771 {USB_DEVICE(USR_VID, HEINEKEN_B_PID_PSTFIRM),.driver_info = EAGLE_I | PSTFIRM},
1772 {}
1773};
1774
1775/*
1776 * USB driver descriptor
1777 */
1778static struct usb_driver uea_driver = {
1779 .name = "ueagle-atm",
1780 .id_table = uea_ids,
1781 .probe = uea_probe,
1782 .disconnect = uea_disconnect,
1783};
1784
1785MODULE_DEVICE_TABLE(usb, uea_ids);
1786
1787/**
1788 * uea_init - Initialize the module.
1789 * Register to USB subsystem
1790 */
1791static int __init uea_init(void)
1792{
1793 printk(KERN_INFO "[ueagle-atm] driver " EAGLEUSBVERSION " loaded\n");
1794
1795 usb_register(&uea_driver);
1796
1797 return 0;
1798}
1799
1800module_init(uea_init);
1801
1802/**
1803 * uea_exit - Destroy module
1804 * Deregister with USB subsystem
1805 */
1806static void __exit uea_exit(void)
1807{
1808 /*
1809 * This calls automatically the uea_disconnect method if necessary:
1810 */
1811 usb_deregister(&uea_driver);
1812
1813 printk(KERN_INFO "[ueagle-atm] driver unloaded\n");
1814}
1815
1816module_exit(uea_exit);
1817
1818MODULE_AUTHOR("Damien Bergamini/Matthieu Castet/Stanislaw W. Gruszka");
1819MODULE_DESCRIPTION("ADI 930/Eagle USB ADSL Modem driver");
1820MODULE_LICENSE("Dual BSD/GPL");
diff --git a/drivers/usb/atm/usbatm.c b/drivers/usb/atm/usbatm.c
index 2e6593e6c1bd..9baa6296fc95 100644
--- a/drivers/usb/atm/usbatm.c
+++ b/drivers/usb/atm/usbatm.c
@@ -646,14 +646,14 @@ static void usbatm_destroy_instance(struct kref *kref)
646 kfree(instance); 646 kfree(instance);
647} 647}
648 648
649void usbatm_get_instance(struct usbatm_data *instance) 649static void usbatm_get_instance(struct usbatm_data *instance)
650{ 650{
651 dbg("%s", __func__); 651 dbg("%s", __func__);
652 652
653 kref_get(&instance->refcount); 653 kref_get(&instance->refcount);
654} 654}
655 655
656void usbatm_put_instance(struct usbatm_data *instance) 656static void usbatm_put_instance(struct usbatm_data *instance)
657{ 657{
658 dbg("%s", __func__); 658 dbg("%s", __func__);
659 659
diff --git a/drivers/usb/atm/xusbatm.c b/drivers/usb/atm/xusbatm.c
index 7fe7fb484d10..5c76e3aaaa5e 100644
--- a/drivers/usb/atm/xusbatm.c
+++ b/drivers/usb/atm/xusbatm.c
@@ -140,7 +140,6 @@ static int xusbatm_usb_probe(struct usb_interface *intf,
140} 140}
141 141
142static struct usb_driver xusbatm_usb_driver = { 142static struct usb_driver xusbatm_usb_driver = {
143 .owner = THIS_MODULE,
144 .name = xusbatm_driver_name, 143 .name = xusbatm_driver_name,
145 .probe = xusbatm_usb_probe, 144 .probe = xusbatm_usb_probe,
146 .disconnect = usbatm_usb_disconnect, 145 .disconnect = usbatm_usb_disconnect,
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-14 00:04:52 -0500