1 /******************************************************************************
2 * cxacru.c - driver for USB ADSL modems based on
3 * Conexant AccessRunner chipset
5 * Copyright (C) 2004 David Woodhouse, Duncan Sands, Roman Kagan
6 * Copyright (C) 2005 Duncan Sands, Roman Kagan (rkagan % mail ! ru)
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the Free
10 * Software Foundation; either version 2 of the License, or (at your option)
13 * This program is distributed in the hope that it will be useful, but WITHOUT
14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
18 * You should have received a copy of the GNU General Public License along with
19 * this program; if not, write to the Free Software Foundation, Inc., 59
20 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 ******************************************************************************/
25 * Credit is due for Josep Comas, who created the original patch to speedtch.c
26 * to support the different padding used by the AccessRunner (now generalized
27 * into usbatm), and the userspace firmware loading utility.
30 #include <linux/module.h>
31 #include <linux/moduleparam.h>
32 #include <linux/kernel.h>
33 #include <linux/timer.h>
34 #include <linux/errno.h>
35 #include <linux/slab.h>
36 #include <linux/init.h>
37 #include <linux/device.h> /* FIXME: linux/firmware.h should include it itself */
38 #include <linux/firmware.h>
42 #define DRIVER_AUTHOR "Roman Kagan, David Woodhouse, Duncan Sands"
43 #define DRIVER_VERSION "0.2"
44 #define DRIVER_DESC "Conexant AccessRunner ADSL USB modem driver"
46 static const char cxacru_driver_name
[] = "cxacru";
48 #define CXACRU_EP_CMD 0x01 /* Bulk/interrupt in/out */
49 #define CXACRU_EP_DATA 0x02 /* Bulk in/out */
51 #define CMD_PACKET_SIZE 64 /* Should be maxpacket(ep)? */
54 #define PLLFCLK_ADDR 0x00350068
55 #define PLLBCLK_ADDR 0x0035006c
56 #define SDRAMEN_ADDR 0x00350010
57 #define FW_ADDR 0x00801000
58 #define BR_ADDR 0x00180600
59 #define SIG_ADDR 0x00180500
60 #define BR_STACK_ADDR 0x00187f10
65 #define CMD_TIMEOUT 2000 /* msecs */
66 #define POLL_INTERVAL 5000 /* msecs */
68 /* commands for interaction with the modem through the control channel before
69 * firmware is loaded */
70 enum cxacru_fw_request
{
80 /* commands for interaction with the modem through the control channel once
81 * firmware is loaded */
82 enum cxacru_cm_request
{
83 CM_REQUEST_UNDEFINED
= 0x80,
85 CM_REQUEST_CHIP_GET_MAC_ADDRESS
,
86 CM_REQUEST_CHIP_GET_DP_VERSIONS
,
87 CM_REQUEST_CHIP_ADSL_LINE_START
,
88 CM_REQUEST_CHIP_ADSL_LINE_STOP
,
89 CM_REQUEST_CHIP_ADSL_LINE_GET_STATUS
,
90 CM_REQUEST_CHIP_ADSL_LINE_GET_SPEED
,
91 CM_REQUEST_CARD_INFO_GET
,
92 CM_REQUEST_CARD_DATA_GET
,
93 CM_REQUEST_CARD_DATA_SET
,
94 CM_REQUEST_COMMAND_HW_IO
,
95 CM_REQUEST_INTERFACE_HW_IO
,
96 CM_REQUEST_CARD_SERIAL_DATA_PATH_GET
,
97 CM_REQUEST_CARD_SERIAL_DATA_PATH_SET
,
98 CM_REQUEST_CARD_CONTROLLER_VERSION_GET
,
99 CM_REQUEST_CARD_GET_STATUS
,
100 CM_REQUEST_CARD_GET_MAC_ADDRESS
,
101 CM_REQUEST_CARD_GET_DATA_LINK_STATUS
,
105 /* reply codes to the commands above */
106 enum cxacru_cm_status
{
110 CM_STATUS_UNSUPPORTED
,
111 CM_STATUS_UNIMPLEMENTED
,
112 CM_STATUS_PARAMETER_ERROR
,
113 CM_STATUS_DBG_LOOPBACK
,
117 /* indices into CARD_INFO_GET return array */
118 enum cxacru_info_idx
{
119 CXINF_DOWNSTREAM_RATE
,
123 CXINF_MAC_ADDRESS_HIGH
,
124 CXINF_MAC_ADDRESS_LOW
,
125 CXINF_UPSTREAM_SNR_MARGIN
,
126 CXINF_DOWNSTREAM_SNR_MARGIN
,
127 CXINF_UPSTREAM_ATTENUATION
,
128 CXINF_DOWNSTREAM_ATTENUATION
,
129 CXINF_TRANSMITTER_POWER
,
130 CXINF_UPSTREAM_BITS_PER_FRAME
,
131 CXINF_DOWNSTREAM_BITS_PER_FRAME
,
132 CXINF_STARTUP_ATTEMPTS
,
133 CXINF_UPSTREAM_CRC_ERRORS
,
134 CXINF_DOWNSTREAM_CRC_ERRORS
,
135 CXINF_UPSTREAM_FEC_ERRORS
,
136 CXINF_DOWNSTREAM_FEC_ERRORS
,
137 CXINF_UPSTREAM_HEC_ERRORS
,
138 CXINF_DOWNSTREAM_HEC_ERRORS
,
139 CXINF_LINE_STARTABLE
,
142 CXINF_ADSL_HEADEND_ENVIRONMENT
,
143 CXINF_CONTROLLER_VERSION
,
144 /* dunno what the missing two mean */
148 struct cxacru_modem_type
{
155 struct usbatm_data
*usbatm
;
157 const struct cxacru_modem_type
*modem_type
;
160 struct work_struct poll_work
;
163 struct semaphore cm_serialize
;
168 struct completion rcv_done
;
169 struct completion snd_done
;
172 /* the following three functions are stolen from drivers/usb/core/message.c */
173 static void cxacru_blocking_completion(struct urb
*urb
, struct pt_regs
*regs
)
175 complete((struct completion
*)urb
->context
);
178 static void cxacru_timeout_kill(unsigned long data
)
180 usb_unlink_urb((struct urb
*) data
);
183 static int cxacru_start_wait_urb(struct urb
*urb
, struct completion
*done
,
186 struct timer_list timer
;
190 timer
.expires
= jiffies
+ msecs_to_jiffies(CMD_TIMEOUT
);
191 timer
.data
= (unsigned long) urb
;
192 timer
.function
= cxacru_timeout_kill
;
194 wait_for_completion(done
);
195 status
= urb
->status
;
196 if (status
== -ECONNRESET
)
198 del_timer_sync(&timer
);
201 *actual_length
= urb
->actual_length
;
205 static int cxacru_cm(struct cxacru_data
*instance
, enum cxacru_cm_request cm
,
206 u8
*wdata
, int wsize
, u8
*rdata
, int rsize
)
210 const int stride
= CMD_PACKET_SIZE
- 4;
211 u8
*wbuf
= instance
->snd_buf
;
212 u8
*rbuf
= instance
->rcv_buf
;
213 int wbuflen
= ((wsize
- 1) / stride
+ 1) * CMD_PACKET_SIZE
;
214 int rbuflen
= ((rsize
- 1) / stride
+ 1) * CMD_PACKET_SIZE
;
216 if (wbuflen
> PAGE_SIZE
|| rbuflen
> PAGE_SIZE
) {
217 dbg("too big transfer requested");
222 down(&instance
->cm_serialize
);
224 /* submit reading urb before the writing one */
225 init_completion(&instance
->rcv_done
);
226 ret
= usb_submit_urb(instance
->rcv_urb
, GFP_KERNEL
);
228 dbg("submitting read urb for cm %#x failed", cm
);
233 memset(wbuf
, 0, wbuflen
);
234 /* handle wsize == 0 */
236 for (offb
= offd
= 0; offd
< wsize
; offd
+= stride
, offb
+= CMD_PACKET_SIZE
) {
238 memcpy(wbuf
+ offb
+ 4, wdata
+ offd
, min_t(int, stride
, wsize
- offd
));
241 instance
->snd_urb
->transfer_buffer_length
= wbuflen
;
242 init_completion(&instance
->snd_done
);
243 ret
= usb_submit_urb(instance
->snd_urb
, GFP_KERNEL
);
245 dbg("submitting write urb for cm %#x failed", cm
);
250 ret
= cxacru_start_wait_urb(instance
->snd_urb
, &instance
->snd_done
, NULL
);
252 dbg("sending cm %#x failed", cm
);
257 ret
= cxacru_start_wait_urb(instance
->rcv_urb
, &instance
->rcv_done
, &actlen
);
259 dbg("receiving cm %#x failed", cm
);
263 if (actlen
% CMD_PACKET_SIZE
|| !actlen
) {
264 dbg("response is not a positive multiple of %d: %#x",
265 CMD_PACKET_SIZE
, actlen
);
270 /* check the return status and copy the data to the output buffer, if needed */
271 for (offb
= offd
= 0; offd
< rsize
&& offb
< actlen
; offb
+= CMD_PACKET_SIZE
) {
272 if (rbuf
[offb
] != cm
) {
273 dbg("wrong cm %#x in response", rbuf
[offb
]);
277 if (rbuf
[offb
+ 1] != CM_STATUS_SUCCESS
) {
278 dbg("response failed: %#x", rbuf
[offb
+ 1]);
284 memcpy(rdata
+ offd
, rbuf
+ offb
+ 4, min_t(int, stride
, rsize
- offd
));
291 up(&instance
->cm_serialize
);
295 static int cxacru_cm_get_array(struct cxacru_data
*instance
, enum cxacru_cm_request cm
,
301 const int stride
= CMD_PACKET_SIZE
/ (4 * 2) - 1;
302 int buflen
= ((size
- 1) / stride
+ 1 + size
* 2) * 4;
304 buf
= kmalloc(buflen
, GFP_KERNEL
);
308 ret
= cxacru_cm(instance
, cm
, NULL
, 0, (u8
*) buf
, buflen
);
312 /* len > 0 && len % 4 == 0 guaranteed by cxacru_cm() */
314 for (offb
= 0; offb
< len
; ) {
315 int l
= le32_to_cpu(buf
[offb
++]);
316 if (l
> stride
|| l
> (len
- offb
) / 2) {
317 dbg("wrong data length %#x in response", l
);
322 offd
= le32_to_cpu(buf
[offb
++]);
324 dbg("wrong index %#x in response", offd
);
328 data
[offd
] = le32_to_cpu(buf
[offb
++]);
339 static int cxacru_card_status(struct cxacru_data
*instance
)
341 int ret
= cxacru_cm(instance
, CM_REQUEST_CARD_GET_STATUS
, NULL
, 0, NULL
, 0);
342 if (ret
< 0) { /* firmware not loaded */
343 dbg("cxacru_adsl_start: CARD_GET_STATUS returned %d", ret
);
349 static void cxacru_poll_status(struct cxacru_data
*instance
);
351 static int cxacru_atm_start(struct usbatm_data
*usbatm_instance
,
352 struct atm_dev
*atm_dev
)
354 struct cxacru_data
*instance
= usbatm_instance
->driver_data
;
356 struct atm_dev *atm_dev = usbatm_instance->atm_dev;
360 dbg("cxacru_atm_start");
362 /* Read MAC address */
363 ret
= cxacru_cm(instance
, CM_REQUEST_CARD_GET_MAC_ADDRESS
, NULL
, 0,
364 atm_dev
->esi
, sizeof(atm_dev
->esi
));
366 atm_err(usbatm_instance
, "cxacru_atm_start: CARD_GET_MAC_ADDRESS returned %d\n", ret
);
371 ret
= cxacru_cm(instance
, CM_REQUEST_CHIP_ADSL_LINE_START
, NULL
, 0, NULL
, 0);
373 atm_err(usbatm_instance
, "cxacru_atm_start: CHIP_ADSL_LINE_START returned %d\n", ret
);
377 /* Start status polling */
378 cxacru_poll_status(instance
);
382 static void cxacru_poll_status(struct cxacru_data
*instance
)
384 u32 buf
[CXINF_MAX
] = {};
385 struct usbatm_data
*usbatm
= instance
->usbatm
;
386 struct atm_dev
*atm_dev
= usbatm
->atm_dev
;
389 ret
= cxacru_cm_get_array(instance
, CM_REQUEST_CARD_INFO_GET
, buf
, CXINF_MAX
);
391 atm_warn(usbatm
, "poll status: error %d\n", ret
);
395 if (instance
->line_status
== buf
[CXINF_LINE_STATUS
])
398 instance
->line_status
= buf
[CXINF_LINE_STATUS
];
399 switch (instance
->line_status
) {
401 atm_dev
->signal
= ATM_PHY_SIG_LOST
;
402 atm_info(usbatm
, "ADSL line: down\n");
406 atm_dev
->signal
= ATM_PHY_SIG_LOST
;
407 atm_info(usbatm
, "ADSL line: attempting to activate\n");
411 atm_dev
->signal
= ATM_PHY_SIG_LOST
;
412 atm_info(usbatm
, "ADSL line: training\n");
416 atm_dev
->signal
= ATM_PHY_SIG_LOST
;
417 atm_info(usbatm
, "ADSL line: channel analysis\n");
421 atm_dev
->signal
= ATM_PHY_SIG_LOST
;
422 atm_info(usbatm
, "ADSL line: exchange\n");
426 atm_dev
->link_rate
= buf
[CXINF_DOWNSTREAM_RATE
] * 1000 / 424;
427 atm_dev
->signal
= ATM_PHY_SIG_FOUND
;
429 atm_info(usbatm
, "ADSL line: up (%d kb/s down | %d kb/s up)\n",
430 buf
[CXINF_DOWNSTREAM_RATE
], buf
[CXINF_UPSTREAM_RATE
]);
434 atm_dev
->signal
= ATM_PHY_SIG_LOST
;
435 atm_info(usbatm
, "ADSL line: waiting\n");
439 atm_dev
->signal
= ATM_PHY_SIG_LOST
;
440 atm_info(usbatm
, "ADSL line: initializing\n");
444 atm_dev
->signal
= ATM_PHY_SIG_UNKNOWN
;
445 atm_info(usbatm
, "Unknown line state %02x\n", instance
->line_status
);
449 schedule_delayed_work(&instance
->poll_work
, msecs_to_jiffies(POLL_INTERVAL
));
452 static int cxacru_fw(struct usb_device
*usb_dev
, enum cxacru_fw_request fw
,
453 u8 code1
, u8 code2
, u32 addr
, u8
*data
, int size
)
458 const int stride
= CMD_PACKET_SIZE
- 8;
460 buf
= (u8
*) __get_free_page(GFP_KERNEL
);
466 int l
= min_t(int, stride
, size
- offd
);
471 *((u32
*) (buf
+ offb
)) = cpu_to_le32(addr
);
475 memcpy(buf
+ offb
, data
+ offd
, l
);
477 memset(buf
+ offb
+ l
, 0, stride
- l
);
480 if ((offb
>= PAGE_SIZE
) || (offd
>= size
)) {
481 ret
= usb_bulk_msg(usb_dev
, usb_sndbulkpipe(usb_dev
, CXACRU_EP_CMD
),
482 buf
, offb
, NULL
, CMD_TIMEOUT
);
484 dbg("sending fw %#x failed", fw
);
489 } while(offd
< size
);
490 dbg("sent fw %#x", fw
);
495 free_page((unsigned long) buf
);
499 static void cxacru_upload_firmware(struct cxacru_data
*instance
,
500 const struct firmware
*fw
,
501 const struct firmware
*bp
,
502 const struct firmware
*cf
)
506 struct usbatm_data
*usbatm
= instance
->usbatm
;
507 struct usb_device
*usb_dev
= usbatm
->usb_dev
;
508 u16 signature
[] = { usb_dev
->descriptor
.idVendor
, usb_dev
->descriptor
.idProduct
};
511 dbg("cxacru_upload_firmware");
513 /* FirmwarePllFClkValue */
514 val
= cpu_to_le32(instance
->modem_type
->pll_f_clk
);
515 ret
= cxacru_fw(usb_dev
, FW_WRITE_MEM
, 0x2, 0x0, PLLFCLK_ADDR
, (u8
*) &val
, 4);
517 usb_err(usbatm
, "FirmwarePllFClkValue failed: %d\n", ret
);
521 /* FirmwarePllBClkValue */
522 val
= cpu_to_le32(instance
->modem_type
->pll_b_clk
);
523 ret
= cxacru_fw(usb_dev
, FW_WRITE_MEM
, 0x2, 0x0, PLLBCLK_ADDR
, (u8
*) &val
, 4);
525 usb_err(usbatm
, "FirmwarePllBClkValue failed: %d\n", ret
);
530 val
= cpu_to_le32(SDRAM_ENA
);
531 ret
= cxacru_fw(usb_dev
, FW_WRITE_MEM
, 0x2, 0x0, SDRAMEN_ADDR
, (u8
*) &val
, 4);
533 usb_err(usbatm
, "Enable SDRAM failed: %d\n", ret
);
538 ret
= cxacru_fw(usb_dev
, FW_WRITE_MEM
, 0x2, 0x0, FW_ADDR
, fw
->data
, fw
->size
);
540 usb_err(usbatm
, "Firmware upload failed: %d\n", ret
);
545 if (instance
->modem_type
->boot_rom_patch
) {
546 ret
= cxacru_fw(usb_dev
, FW_WRITE_MEM
, 0x2, 0x0, BR_ADDR
, bp
->data
, bp
->size
);
548 usb_err(usbatm
, "Boot ROM patching failed: %d\n", ret
);
554 ret
= cxacru_fw(usb_dev
, FW_WRITE_MEM
, 0x2, 0x0, SIG_ADDR
, (u8
*) signature
, 4);
556 usb_err(usbatm
, "Signature storing failed: %d\n", ret
);
560 if (instance
->modem_type
->boot_rom_patch
) {
561 val
= cpu_to_le32(BR_ADDR
);
562 ret
= cxacru_fw(usb_dev
, FW_WRITE_MEM
, 0x2, 0x0, BR_STACK_ADDR
, (u8
*) &val
, 4);
565 ret
= cxacru_fw(usb_dev
, FW_GOTO_MEM
, 0x0, 0x0, FW_ADDR
, NULL
, 0);
568 usb_err(usbatm
, "Passing control to firmware failed: %d\n", ret
);
572 /* Delay to allow firmware to start up. */
573 msleep_interruptible(1000);
575 usb_clear_halt(usb_dev
, usb_sndbulkpipe(usb_dev
, CXACRU_EP_CMD
));
576 usb_clear_halt(usb_dev
, usb_rcvbulkpipe(usb_dev
, CXACRU_EP_CMD
));
577 usb_clear_halt(usb_dev
, usb_sndbulkpipe(usb_dev
, CXACRU_EP_DATA
));
578 usb_clear_halt(usb_dev
, usb_rcvbulkpipe(usb_dev
, CXACRU_EP_DATA
));
580 ret
= cxacru_cm(instance
, CM_REQUEST_CARD_GET_STATUS
, NULL
, 0, NULL
, 0);
582 usb_err(usbatm
, "modem failed to initialize: %d\n", ret
);
586 /* Load config data (le32), doing one packet at a time */
588 for (off
= 0; off
< cf
->size
/ 4; ) {
589 u32 buf
[CMD_PACKET_SIZE
/ 4 - 1];
590 int i
, len
= min_t(int, cf
->size
/ 4 - off
, CMD_PACKET_SIZE
/ 4 / 2 - 1);
591 buf
[0] = cpu_to_le32(len
);
592 for (i
= 0; i
< len
; i
++, off
++) {
593 buf
[i
* 2 + 1] = cpu_to_le32(off
);
594 memcpy(buf
+ i
* 2 + 2, cf
->data
+ off
* 4, 4);
596 ret
= cxacru_cm(instance
, CM_REQUEST_CARD_DATA_SET
,
597 (u8
*) buf
, len
, NULL
, 0);
599 usb_err(usbatm
, "load config data failed: %d\n", ret
);
604 msleep_interruptible(4000);
607 static int cxacru_find_firmware(struct cxacru_data
*instance
,
608 char* phase
, const struct firmware
**fw_p
)
610 struct usbatm_data
*usbatm
= instance
->usbatm
;
611 struct device
*dev
= &usbatm
->usb_intf
->dev
;
614 sprintf(buf
, "cxacru-%s.bin", phase
);
615 dbg("cxacru_find_firmware: looking for %s", buf
);
617 if (request_firmware(fw_p
, buf
, dev
)) {
618 usb_dbg(usbatm
, "no stage %s firmware found\n", phase
);
622 usb_info(usbatm
, "found firmware %s\n", buf
);
627 static int cxacru_heavy_init(struct usbatm_data
*usbatm_instance
,
628 struct usb_interface
*usb_intf
)
630 const struct firmware
*fw
, *bp
, *cf
;
631 struct cxacru_data
*instance
= usbatm_instance
->driver_data
;
633 int ret
= cxacru_find_firmware(instance
, "fw", &fw
);
635 usb_warn(usbatm_instance
, "firmware (cxacru-fw.bin) unavailable (system misconfigured?)\n");
639 if (instance
->modem_type
->boot_rom_patch
) {
640 ret
= cxacru_find_firmware(instance
, "bp", &bp
);
642 usb_warn(usbatm_instance
, "boot ROM patch (cxacru-bp.bin) unavailable (system misconfigured?)\n");
643 release_firmware(fw
);
648 if (cxacru_find_firmware(instance
, "cf", &cf
)) /* optional */
651 cxacru_upload_firmware(instance
, fw
, bp
, cf
);
654 release_firmware(cf
);
655 if (instance
->modem_type
->boot_rom_patch
)
656 release_firmware(bp
);
657 release_firmware(fw
);
659 ret
= cxacru_card_status(instance
);
661 dbg("modem initialisation failed");
663 dbg("done setting up the modem");
668 static int cxacru_bind(struct usbatm_data
*usbatm_instance
,
669 struct usb_interface
*intf
, const struct usb_device_id
*id
)
671 struct cxacru_data
*instance
;
672 struct usb_device
*usb_dev
= interface_to_usbdev(intf
);
676 instance
= kzalloc(sizeof(*instance
), GFP_KERNEL
);
678 dbg("cxacru_bind: no memory for instance data");
682 instance
->usbatm
= usbatm_instance
;
683 instance
->modem_type
= (struct cxacru_modem_type
*) id
->driver_info
;
685 instance
->rcv_buf
= (u8
*) __get_free_page(GFP_KERNEL
);
686 if (!instance
->rcv_buf
) {
687 dbg("cxacru_bind: no memory for rcv_buf");
691 instance
->snd_buf
= (u8
*) __get_free_page(GFP_KERNEL
);
692 if (!instance
->snd_buf
) {
693 dbg("cxacru_bind: no memory for snd_buf");
697 instance
->rcv_urb
= usb_alloc_urb(0, GFP_KERNEL
);
698 if (!instance
->rcv_urb
) {
699 dbg("cxacru_bind: no memory for rcv_urb");
703 instance
->snd_urb
= usb_alloc_urb(0, GFP_KERNEL
);
704 if (!instance
->snd_urb
) {
705 dbg("cxacru_bind: no memory for snd_urb");
710 usb_fill_int_urb(instance
->rcv_urb
,
711 usb_dev
, usb_rcvintpipe(usb_dev
, CXACRU_EP_CMD
),
712 instance
->rcv_buf
, PAGE_SIZE
,
713 cxacru_blocking_completion
, &instance
->rcv_done
, 1);
715 usb_fill_int_urb(instance
->snd_urb
,
716 usb_dev
, usb_sndintpipe(usb_dev
, CXACRU_EP_CMD
),
717 instance
->snd_buf
, PAGE_SIZE
,
718 cxacru_blocking_completion
, &instance
->snd_done
, 4);
720 init_MUTEX(&instance
->cm_serialize
);
722 INIT_WORK(&instance
->poll_work
, (void *)cxacru_poll_status
, instance
);
724 usbatm_instance
->driver_data
= instance
;
726 usbatm_instance
->flags
= (cxacru_card_status(instance
) ? 0 : UDSL_SKIP_HEAVY_INIT
);
731 free_page((unsigned long) instance
->snd_buf
);
732 free_page((unsigned long) instance
->rcv_buf
);
733 usb_free_urb(instance
->snd_urb
);
734 usb_free_urb(instance
->rcv_urb
);
740 static void cxacru_unbind(struct usbatm_data
*usbatm_instance
,
741 struct usb_interface
*intf
)
743 struct cxacru_data
*instance
= usbatm_instance
->driver_data
;
745 dbg("cxacru_unbind entered");
748 dbg("cxacru_unbind: NULL instance!");
752 while (!cancel_delayed_work(&instance
->poll_work
))
753 flush_scheduled_work();
755 usb_kill_urb(instance
->snd_urb
);
756 usb_kill_urb(instance
->rcv_urb
);
757 usb_free_urb(instance
->snd_urb
);
758 usb_free_urb(instance
->rcv_urb
);
760 free_page((unsigned long) instance
->snd_buf
);
761 free_page((unsigned long) instance
->rcv_buf
);
764 usbatm_instance
->driver_data
= NULL
;
767 static const struct cxacru_modem_type cxacru_cafe
= {
768 .pll_f_clk
= 0x02d874df,
769 .pll_b_clk
= 0x0196a51a,
773 static const struct cxacru_modem_type cxacru_cb00
= {
779 static const struct usb_device_id cxacru_usb_ids
[] = {
780 { /* V = Conexant P = ADSL modem (Euphrates project) */
781 USB_DEVICE(0x0572, 0xcafe), .driver_info
= (unsigned long) &cxacru_cafe
783 { /* V = Conexant P = ADSL modem (Hasbani project) */
784 USB_DEVICE(0x0572, 0xcb00), .driver_info
= (unsigned long) &cxacru_cb00
786 { /* V = Conexant P = ADSL modem */
787 USB_DEVICE(0x0572, 0xcb01), .driver_info
= (unsigned long) &cxacru_cb00
789 { /* V = Conexant P = ADSL modem (Well PTI-800) */
790 USB_DEVICE(0x0572, 0xcb02), .driver_info
= (unsigned long) &cxacru_cb00
792 { /* V = Conexant P = ADSL modem */
793 USB_DEVICE(0x0572, 0xcb06), .driver_info
= (unsigned long) &cxacru_cb00
795 { /* V = Olitec P = ADSL modem version 2 */
796 USB_DEVICE(0x08e3, 0x0100), .driver_info
= (unsigned long) &cxacru_cafe
798 { /* V = Olitec P = ADSL modem version 3 */
799 USB_DEVICE(0x08e3, 0x0102), .driver_info
= (unsigned long) &cxacru_cb00
801 { /* V = Trust/Amigo Technology Co. P = AMX-CA86U */
802 USB_DEVICE(0x0eb0, 0x3457), .driver_info
= (unsigned long) &cxacru_cafe
804 { /* V = Zoom P = 5510 */
805 USB_DEVICE(0x1803, 0x5510), .driver_info
= (unsigned long) &cxacru_cb00
807 { /* V = Draytek P = Vigor 318 */
808 USB_DEVICE(0x0675, 0x0200), .driver_info
= (unsigned long) &cxacru_cb00
810 { /* V = Zyxel P = 630-C1 aka OMNI ADSL USB (Annex A) */
811 USB_DEVICE(0x0586, 0x330a), .driver_info
= (unsigned long) &cxacru_cb00
813 { /* V = Zyxel P = 630-C3 aka OMNI ADSL USB (Annex B) */
814 USB_DEVICE(0x0586, 0x330b), .driver_info
= (unsigned long) &cxacru_cb00
816 { /* V = Aethra P = Starmodem UM1020 */
817 USB_DEVICE(0x0659, 0x0020), .driver_info
= (unsigned long) &cxacru_cb00
819 { /* V = Aztech Systems P = ? AKA Pirelli AUA-010 */
820 USB_DEVICE(0x0509, 0x0812), .driver_info
= (unsigned long) &cxacru_cb00
822 { /* V = Netopia P = Cayman 3341(Annex A)/3351(Annex B) */
823 USB_DEVICE(0x100d, 0xcb01), .driver_info
= (unsigned long) &cxacru_cb00
825 { /* V = Netopia P = Cayman 3342(Annex A)/3352(Annex B) */
826 USB_DEVICE(0x100d, 0x3342), .driver_info
= (unsigned long) &cxacru_cb00
831 MODULE_DEVICE_TABLE(usb
, cxacru_usb_ids
);
833 static struct usbatm_driver cxacru_driver
= {
834 .driver_name
= cxacru_driver_name
,
836 .heavy_init
= cxacru_heavy_init
,
837 .unbind
= cxacru_unbind
,
838 .atm_start
= cxacru_atm_start
,
839 .bulk_in
= CXACRU_EP_DATA
,
840 .bulk_out
= CXACRU_EP_DATA
,
845 static int cxacru_usb_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
847 return usbatm_usb_probe(intf
, id
, &cxacru_driver
);
850 static struct usb_driver cxacru_usb_driver
= {
851 .name
= cxacru_driver_name
,
852 .probe
= cxacru_usb_probe
,
853 .disconnect
= usbatm_usb_disconnect
,
854 .id_table
= cxacru_usb_ids
857 static int __init
cxacru_init(void)
859 return usb_register(&cxacru_usb_driver
);
862 static void __exit
cxacru_cleanup(void)
864 usb_deregister(&cxacru_usb_driver
);
867 module_init(cxacru_init
);
868 module_exit(cxacru_cleanup
);
870 MODULE_AUTHOR(DRIVER_AUTHOR
);
871 MODULE_DESCRIPTION(DRIVER_DESC
);
872 MODULE_LICENSE("GPL");
873 MODULE_VERSION(DRIVER_VERSION
);