1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-2-Clause) 2 /* 3 * Copyright (c) 2003, 2004 4 * Damien Bergamini <damien.bergamini@free.fr>. All rights reserved. 5 * 6 * Copyright (c) 2005-2007 Matthieu Castet <castet.matthieu@free.fr> 7 * Copyright (c) 2005-2007 Stanislaw Gruszka <stf_xl@wp.pl> 8 * 9 * HISTORY : some part of the code was base on ueagle 1.3 BSD driver, 10 * Damien Bergamini agree to put his code under a DUAL GPL/BSD license. 11 * 12 * The rest of the code was rewritten from scratch. 13 */ 14 15 #include <linux/module.h> 16 #include <linux/moduleparam.h> 17 #include <linux/crc32.h> 18 #include <linux/hex.h> 19 #include <linux/usb.h> 20 #include <linux/firmware.h> 21 #include <linux/ctype.h> 22 #include <linux/sched.h> 23 #include <linux/kthread.h> 24 #include <linux/mutex.h> 25 #include <linux/freezer.h> 26 #include <linux/slab.h> 27 #include <linux/kernel.h> 28 29 #include <linux/unaligned.h> 30 31 #include "usbatm.h" 32 33 #define EAGLEUSBVERSION "ueagle 1.4" 34 35 36 /* 37 * Debug macros 38 */ 39 #define uea_dbg(usb_dev, format, args...) \ 40 do { \ 41 if (debug >= 1) \ 42 dev_dbg(&(usb_dev)->dev, \ 43 "[ueagle-atm dbg] %s: " format, \ 44 __func__, ##args); \ 45 } while (0) 46 47 #define uea_vdbg(usb_dev, format, args...) \ 48 do { \ 49 if (debug >= 2) \ 50 dev_dbg(&(usb_dev)->dev, \ 51 "[ueagle-atm vdbg] " format, ##args); \ 52 } while (0) 53 54 #define uea_err(usb_dev, format, args...) \ 55 dev_err(&(usb_dev)->dev , "[UEAGLE-ATM] " format , ##args) 56 57 #define uea_warn(usb_dev, format, args...) \ 58 dev_warn(&(usb_dev)->dev , "[Ueagle-atm] " format, ##args) 59 60 #define uea_info(usb_dev, format, args...) \ 61 dev_info(&(usb_dev)->dev , "[ueagle-atm] " format, ##args) 62 63 struct intr_pkt; 64 65 /* cmv's from firmware */ 66 struct uea_cmvs_v1 { 67 u32 address; 68 u16 offset; 69 u32 data; 70 } __packed; 71 72 struct uea_cmvs_v2 { 73 u32 group; 74 u32 address; 75 u32 offset; 76 u32 data; 77 } __packed; 78 79 /* information about currently processed cmv */ 80 struct cmv_dsc_e1 { 81 u8 function; 82 u16 idx; 83 u32 address; 84 u16 offset; 85 }; 86 87 struct cmv_dsc_e4 { 88 u16 function; 89 u16 offset; 90 u16 address; 91 u16 group; 92 }; 93 94 union cmv_dsc { 95 struct cmv_dsc_e1 e1; 96 struct cmv_dsc_e4 e4; 97 }; 98 99 struct uea_softc { 100 struct usb_device *usb_dev; 101 struct usbatm_data *usbatm; 102 103 int modem_index; 104 unsigned int driver_info; 105 int annex; 106 #define ANNEXA 0 107 #define ANNEXB 1 108 109 int booting; 110 int reset; 111 112 wait_queue_head_t sync_q; 113 114 struct task_struct *kthread; 115 u32 data; 116 u32 data1; 117 118 int cmv_ack; 119 union cmv_dsc cmv_dsc; 120 121 struct work_struct task; 122 u16 pageno; 123 u16 ovl; 124 125 const struct firmware *dsp_firm; 126 struct urb *urb_int; 127 128 void (*dispatch_cmv)(struct uea_softc *, struct intr_pkt *); 129 void (*schedule_load_page)(struct uea_softc *, struct intr_pkt *); 130 int (*stat)(struct uea_softc *); 131 int (*send_cmvs)(struct uea_softc *); 132 133 /* keep in sync with eaglectl */ 134 struct uea_stats { 135 struct { 136 u32 state; 137 u32 flags; 138 u32 mflags; 139 u32 vidcpe; 140 u32 vidco; 141 u32 dsrate; 142 u32 usrate; 143 u32 dsunc; 144 u32 usunc; 145 u32 dscorr; 146 u32 uscorr; 147 u32 txflow; 148 u32 rxflow; 149 u32 usattenuation; 150 u32 dsattenuation; 151 u32 dsmargin; 152 u32 usmargin; 153 u32 firmid; 154 } phy; 155 } stats; 156 }; 157 158 /* 159 * Elsa IDs 160 */ 161 #define ELSA_VID 0x05CC 162 #define ELSA_PID_PSTFIRM 0x3350 163 #define ELSA_PID_PREFIRM 0x3351 164 165 #define ELSA_PID_A_PREFIRM 0x3352 166 #define ELSA_PID_A_PSTFIRM 0x3353 167 #define ELSA_PID_B_PREFIRM 0x3362 168 #define ELSA_PID_B_PSTFIRM 0x3363 169 170 /* 171 * Devolo IDs : pots if (pid & 0x10) 172 */ 173 #define DEVOLO_VID 0x1039 174 #define DEVOLO_EAGLE_I_A_PID_PSTFIRM 0x2110 175 #define DEVOLO_EAGLE_I_A_PID_PREFIRM 0x2111 176 177 #define DEVOLO_EAGLE_I_B_PID_PSTFIRM 0x2100 178 #define DEVOLO_EAGLE_I_B_PID_PREFIRM 0x2101 179 180 #define DEVOLO_EAGLE_II_A_PID_PSTFIRM 0x2130 181 #define DEVOLO_EAGLE_II_A_PID_PREFIRM 0x2131 182 183 #define DEVOLO_EAGLE_II_B_PID_PSTFIRM 0x2120 184 #define DEVOLO_EAGLE_II_B_PID_PREFIRM 0x2121 185 186 /* 187 * Reference design USB IDs 188 */ 189 #define ANALOG_VID 0x1110 190 #define ADI930_PID_PREFIRM 0x9001 191 #define ADI930_PID_PSTFIRM 0x9000 192 193 #define EAGLE_I_PID_PREFIRM 0x9010 /* Eagle I */ 194 #define EAGLE_I_PID_PSTFIRM 0x900F /* Eagle I */ 195 196 #define EAGLE_IIC_PID_PREFIRM 0x9024 /* Eagle IIC */ 197 #define EAGLE_IIC_PID_PSTFIRM 0x9023 /* Eagle IIC */ 198 199 #define EAGLE_II_PID_PREFIRM 0x9022 /* Eagle II */ 200 #define EAGLE_II_PID_PSTFIRM 0x9021 /* Eagle II */ 201 202 #define EAGLE_III_PID_PREFIRM 0x9032 /* Eagle III */ 203 #define EAGLE_III_PID_PSTFIRM 0x9031 /* Eagle III */ 204 205 #define EAGLE_IV_PID_PREFIRM 0x9042 /* Eagle IV */ 206 #define EAGLE_IV_PID_PSTFIRM 0x9041 /* Eagle IV */ 207 208 /* 209 * USR USB IDs 210 */ 211 #define USR_VID 0x0BAF 212 #define MILLER_A_PID_PREFIRM 0x00F2 213 #define MILLER_A_PID_PSTFIRM 0x00F1 214 #define MILLER_B_PID_PREFIRM 0x00FA 215 #define MILLER_B_PID_PSTFIRM 0x00F9 216 #define HEINEKEN_A_PID_PREFIRM 0x00F6 217 #define HEINEKEN_A_PID_PSTFIRM 0x00F5 218 #define HEINEKEN_B_PID_PREFIRM 0x00F8 219 #define HEINEKEN_B_PID_PSTFIRM 0x00F7 220 221 #define PREFIRM 0 222 #define PSTFIRM (1<<7) 223 #define AUTO_ANNEX_A (1<<8) 224 #define AUTO_ANNEX_B (1<<9) 225 226 enum { 227 ADI930 = 0, 228 EAGLE_I, 229 EAGLE_II, 230 EAGLE_III, 231 EAGLE_IV 232 }; 233 234 /* macros for both struct usb_device_id and struct uea_softc */ 235 #define UEA_IS_PREFIRM(x) \ 236 (!((x)->driver_info & PSTFIRM)) 237 #define UEA_CHIP_VERSION(x) \ 238 ((x)->driver_info & 0xf) 239 240 #define IS_ISDN(x) \ 241 ((x)->annex & ANNEXB) 242 243 #define INS_TO_USBDEV(ins) (ins->usb_dev) 244 245 #define GET_STATUS(data) \ 246 ((data >> 8) & 0xf) 247 248 #define IS_OPERATIONAL(sc) \ 249 ((UEA_CHIP_VERSION(sc) != EAGLE_IV) ? \ 250 (GET_STATUS(sc->stats.phy.state) == 2) : \ 251 (sc->stats.phy.state == 7)) 252 253 /* 254 * Set of macros to handle unaligned data in the firmware blob. 255 * The FW_GET_BYTE() macro is provided only for consistency. 256 */ 257 258 #define FW_GET_BYTE(p) (*((__u8 *) (p))) 259 260 #define FW_DIR "ueagle-atm/" 261 #define EAGLE_FIRMWARE FW_DIR "eagle.fw" 262 #define ADI930_FIRMWARE FW_DIR "adi930.fw" 263 #define EAGLE_I_FIRMWARE FW_DIR "eagleI.fw" 264 #define EAGLE_II_FIRMWARE FW_DIR "eagleII.fw" 265 #define EAGLE_III_FIRMWARE FW_DIR "eagleIII.fw" 266 #define EAGLE_IV_FIRMWARE FW_DIR "eagleIV.fw" 267 268 #define DSP4I_FIRMWARE FW_DIR "DSP4i.bin" 269 #define DSP4P_FIRMWARE FW_DIR "DSP4p.bin" 270 #define DSP9I_FIRMWARE FW_DIR "DSP9i.bin" 271 #define DSP9P_FIRMWARE FW_DIR "DSP9p.bin" 272 #define DSPEI_FIRMWARE FW_DIR "DSPei.bin" 273 #define DSPEP_FIRMWARE FW_DIR "DSPep.bin" 274 #define FPGA930_FIRMWARE FW_DIR "930-fpga.bin" 275 276 #define CMV4P_FIRMWARE FW_DIR "CMV4p.bin" 277 #define CMV4PV2_FIRMWARE FW_DIR "CMV4p.bin.v2" 278 #define CMV4I_FIRMWARE FW_DIR "CMV4i.bin" 279 #define CMV4IV2_FIRMWARE FW_DIR "CMV4i.bin.v2" 280 #define CMV9P_FIRMWARE FW_DIR "CMV9p.bin" 281 #define CMV9PV2_FIRMWARE FW_DIR "CMV9p.bin.v2" 282 #define CMV9I_FIRMWARE FW_DIR "CMV9i.bin" 283 #define CMV9IV2_FIRMWARE FW_DIR "CMV9i.bin.v2" 284 #define CMVEP_FIRMWARE FW_DIR "CMVep.bin" 285 #define CMVEPV2_FIRMWARE FW_DIR "CMVep.bin.v2" 286 #define CMVEI_FIRMWARE FW_DIR "CMVei.bin" 287 #define CMVEIV2_FIRMWARE FW_DIR "CMVei.bin.v2" 288 289 #define UEA_FW_NAME_MAX 30 290 #define NB_MODEM 4 291 292 #define BULK_TIMEOUT 300 293 #define CTRL_TIMEOUT 1000 294 295 #define ACK_TIMEOUT msecs_to_jiffies(3000) 296 297 #define UEA_INTR_IFACE_NO 0 298 #define UEA_US_IFACE_NO 1 299 #define UEA_DS_IFACE_NO 2 300 301 #define FASTEST_ISO_INTF 8 302 303 #define UEA_BULK_DATA_PIPE 0x02 304 #define UEA_IDMA_PIPE 0x04 305 #define UEA_INTR_PIPE 0x04 306 #define UEA_ISO_DATA_PIPE 0x08 307 308 #define UEA_E1_SET_BLOCK 0x0001 309 #define UEA_E4_SET_BLOCK 0x002c 310 #define UEA_SET_MODE 0x0003 311 #define UEA_SET_2183_DATA 0x0004 312 #define UEA_SET_TIMEOUT 0x0011 313 314 #define UEA_LOOPBACK_OFF 0x0002 315 #define UEA_LOOPBACK_ON 0x0003 316 #define UEA_BOOT_IDMA 0x0006 317 #define UEA_START_RESET 0x0007 318 #define UEA_END_RESET 0x0008 319 320 #define UEA_SWAP_MAILBOX (0x3fcd | 0x4000) 321 #define UEA_MPTX_START (0x3fce | 0x4000) 322 #define UEA_MPTX_MAILBOX (0x3fd6 | 0x4000) 323 #define UEA_MPRX_MAILBOX (0x3fdf | 0x4000) 324 325 /* block information in eagle4 dsp firmware */ 326 struct block_index { 327 __le32 PageOffset; 328 __le32 NotLastBlock; 329 __le32 dummy; 330 __le32 PageSize; 331 __le32 PageAddress; 332 __le16 dummy1; 333 __le16 PageNumber; 334 } __packed; 335 336 #define E4_IS_BOOT_PAGE(PageSize) ((le32_to_cpu(PageSize)) & 0x80000000) 337 #define E4_PAGE_BYTES(PageSize) ((le32_to_cpu(PageSize) & 0x7fffffff) * 4) 338 339 #define E4_L1_STRING_HEADER 0x10 340 #define E4_MAX_PAGE_NUMBER 0x58 341 #define E4_NO_SWAPPAGE_HEADERS 0x31 342 343 /* l1_code is eagle4 dsp firmware format */ 344 struct l1_code { 345 u8 string_header[E4_L1_STRING_HEADER]; 346 u8 page_number_to_block_index[E4_MAX_PAGE_NUMBER]; 347 struct block_index page_header[E4_NO_SWAPPAGE_HEADERS]; 348 u8 code[]; 349 } __packed; 350 351 /* structures describing a block within a DSP page */ 352 struct block_info_e1 { 353 __le16 wHdr; 354 __le16 wAddress; 355 __le16 wSize; 356 __le16 wOvlOffset; 357 __le16 wOvl; /* overlay */ 358 __le16 wLast; 359 } __packed; 360 #define E1_BLOCK_INFO_SIZE 12 361 362 struct block_info_e4 { 363 __be16 wHdr; 364 __u8 bBootPage; 365 __u8 bPageNumber; 366 __be32 dwSize; 367 __be32 dwAddress; 368 __be16 wReserved; 369 } __packed; 370 #define E4_BLOCK_INFO_SIZE 14 371 372 #define UEA_BIHDR 0xabcd 373 #define UEA_RESERVED 0xffff 374 375 /* constants describing cmv type */ 376 #define E1_PREAMBLE 0x535c 377 #define E1_MODEMTOHOST 0x01 378 #define E1_HOSTTOMODEM 0x10 379 380 #define E1_MEMACCESS 0x1 381 #define E1_ADSLDIRECTIVE 0x7 382 #define E1_FUNCTION_TYPE(f) ((f) >> 4) 383 #define E1_FUNCTION_SUBTYPE(f) ((f) & 0x0f) 384 385 #define E4_MEMACCESS 0 386 #define E4_ADSLDIRECTIVE 0xf 387 #define E4_FUNCTION_TYPE(f) ((f) >> 8) 388 #define E4_FUNCTION_SIZE(f) ((f) & 0x0f) 389 #define E4_FUNCTION_SUBTYPE(f) (((f) >> 4) & 0x0f) 390 391 /* for MEMACCESS */ 392 #define E1_REQUESTREAD 0x0 393 #define E1_REQUESTWRITE 0x1 394 #define E1_REPLYREAD 0x2 395 #define E1_REPLYWRITE 0x3 396 397 #define E4_REQUESTREAD 0x0 398 #define E4_REQUESTWRITE 0x4 399 #define E4_REPLYREAD (E4_REQUESTREAD | 1) 400 #define E4_REPLYWRITE (E4_REQUESTWRITE | 1) 401 402 /* for ADSLDIRECTIVE */ 403 #define E1_KERNELREADY 0x0 404 #define E1_MODEMREADY 0x1 405 406 #define E4_KERNELREADY 0x0 407 #define E4_MODEMREADY 0x1 408 409 #define E1_MAKEFUNCTION(t, s) (((t) & 0xf) << 4 | ((s) & 0xf)) 410 #define E4_MAKEFUNCTION(t, st, s) (((t) & 0xf) << 8 | \ 411 ((st) & 0xf) << 4 | ((s) & 0xf)) 412 413 #define E1_MAKESA(a, b, c, d) \ 414 (((c) & 0xff) << 24 | \ 415 ((d) & 0xff) << 16 | \ 416 ((a) & 0xff) << 8 | \ 417 ((b) & 0xff)) 418 419 #define E1_GETSA1(a) ((a >> 8) & 0xff) 420 #define E1_GETSA2(a) (a & 0xff) 421 #define E1_GETSA3(a) ((a >> 24) & 0xff) 422 #define E1_GETSA4(a) ((a >> 16) & 0xff) 423 424 #define E1_SA_CNTL E1_MAKESA('C', 'N', 'T', 'L') 425 #define E1_SA_DIAG E1_MAKESA('D', 'I', 'A', 'G') 426 #define E1_SA_INFO E1_MAKESA('I', 'N', 'F', 'O') 427 #define E1_SA_OPTN E1_MAKESA('O', 'P', 'T', 'N') 428 #define E1_SA_RATE E1_MAKESA('R', 'A', 'T', 'E') 429 #define E1_SA_STAT E1_MAKESA('S', 'T', 'A', 'T') 430 431 #define E4_SA_CNTL 1 432 #define E4_SA_STAT 2 433 #define E4_SA_INFO 3 434 #define E4_SA_TEST 4 435 #define E4_SA_OPTN 5 436 #define E4_SA_RATE 6 437 #define E4_SA_DIAG 7 438 #define E4_SA_CNFG 8 439 440 /* structures representing a CMV (Configuration and Management Variable) */ 441 struct cmv_e1 { 442 __le16 wPreamble; 443 __u8 bDirection; 444 __u8 bFunction; 445 __le16 wIndex; 446 __le32 dwSymbolicAddress; 447 __le16 wOffsetAddress; 448 __le32 dwData; 449 } __packed; 450 451 struct cmv_e4 { 452 __be16 wGroup; 453 __be16 wFunction; 454 __be16 wOffset; 455 __be16 wAddress; 456 __be32 dwData[6]; 457 } __packed; 458 459 /* structures representing swap information */ 460 struct swap_info_e1 { 461 __u8 bSwapPageNo; 462 __u8 bOvl; /* overlay */ 463 } __packed; 464 465 struct swap_info_e4 { 466 __u8 bSwapPageNo; 467 } __packed; 468 469 /* structures representing interrupt data */ 470 #define e1_bSwapPageNo u.e1.s1.swapinfo.bSwapPageNo 471 #define e1_bOvl u.e1.s1.swapinfo.bOvl 472 #define e4_bSwapPageNo u.e4.s1.swapinfo.bSwapPageNo 473 474 #define INT_LOADSWAPPAGE 0x0001 475 #define INT_INCOMINGCMV 0x0002 476 477 union intr_data_e1 { 478 struct { 479 struct swap_info_e1 swapinfo; 480 __le16 wDataSize; 481 } __packed s1; 482 struct { 483 struct cmv_e1 cmv; 484 __le16 wDataSize; 485 } __packed s2; 486 } __packed; 487 488 union intr_data_e4 { 489 struct { 490 struct swap_info_e4 swapinfo; 491 __le16 wDataSize; 492 } __packed s1; 493 struct { 494 struct cmv_e4 cmv; 495 __le16 wDataSize; 496 } __packed s2; 497 } __packed; 498 499 struct intr_pkt { 500 __u8 bType; 501 __u8 bNotification; 502 __le16 wValue; 503 __le16 wIndex; 504 __le16 wLength; 505 __le16 wInterrupt; 506 union { 507 union intr_data_e1 e1; 508 union intr_data_e4 e4; 509 } u; 510 } __packed; 511 512 #define E1_INTR_PKT_SIZE 28 513 #define E4_INTR_PKT_SIZE 64 514 515 static struct usb_driver uea_driver; 516 static DEFINE_MUTEX(uea_mutex); 517 static const char * const chip_name[] = { 518 "ADI930", "Eagle I", "Eagle II", "Eagle III", "Eagle IV"}; 519 520 static int modem_index; 521 static unsigned int debug; 522 static unsigned int altsetting[NB_MODEM] = { 523 [0 ... (NB_MODEM - 1)] = FASTEST_ISO_INTF}; 524 static bool sync_wait[NB_MODEM]; 525 static char *cmv_file[NB_MODEM]; 526 static int annex[NB_MODEM]; 527 528 module_param(debug, uint, 0644); 529 MODULE_PARM_DESC(debug, "module debug level (0=off,1=on,2=verbose)"); 530 module_param_array(altsetting, uint, NULL, 0644); 531 MODULE_PARM_DESC(altsetting, "alternate setting for incoming traffic: 0=bulk, " 532 "1=isoc slowest, ... , 8=isoc fastest (default)"); 533 module_param_array(sync_wait, bool, NULL, 0644); 534 MODULE_PARM_DESC(sync_wait, "wait the synchronisation before starting ATM"); 535 module_param_array(cmv_file, charp, NULL, 0644); 536 MODULE_PARM_DESC(cmv_file, 537 "file name with configuration and management variables"); 538 module_param_array(annex, uint, NULL, 0644); 539 MODULE_PARM_DESC(annex, 540 "manually set annex a/b (0=auto, 1=annex a, 2=annex b)"); 541 542 #define uea_wait(sc, cond, timeo) \ 543 ({ \ 544 int _r = wait_event_freezable_timeout(sc->sync_q, \ 545 (cond) || kthread_should_stop(), timeo); \ 546 if (kthread_should_stop()) \ 547 _r = -ENODEV; \ 548 _r; \ 549 }) 550 551 #define UPDATE_ATM_STAT(type, val) \ 552 do { \ 553 if (sc->usbatm->atm_dev) \ 554 sc->usbatm->atm_dev->type = val; \ 555 } while (0) 556 557 #define UPDATE_ATM_SIGNAL(val) \ 558 do { \ 559 if (sc->usbatm->atm_dev) \ 560 atm_dev_signal_change(sc->usbatm->atm_dev, val); \ 561 } while (0) 562 563 564 /* Firmware loading */ 565 #define LOAD_INTERNAL 0xA0 566 #define F8051_USBCS 0x7f92 567 568 /* 569 * uea_send_modem_cmd - Send a command for pre-firmware devices. 570 */ 571 static int uea_send_modem_cmd(struct usb_device *usb, 572 u16 addr, u16 size, const u8 *buff) 573 { 574 int ret = -ENOMEM; 575 u8 *xfer_buff; 576 577 xfer_buff = kmemdup(buff, size, GFP_KERNEL); 578 if (xfer_buff) { 579 ret = usb_control_msg(usb, 580 usb_sndctrlpipe(usb, 0), 581 LOAD_INTERNAL, 582 USB_DIR_OUT | USB_TYPE_VENDOR | 583 USB_RECIP_DEVICE, addr, 0, xfer_buff, 584 size, CTRL_TIMEOUT); 585 kfree(xfer_buff); 586 } 587 588 if (ret < 0) 589 return ret; 590 591 return (ret == size) ? 0 : -EIO; 592 } 593 594 static void uea_upload_pre_firmware(const struct firmware *fw_entry, 595 void *context) 596 { 597 struct usb_device *usb = context; 598 const u8 *pfw; 599 u8 value; 600 u32 crc = 0; 601 int ret, size; 602 603 if (!fw_entry) { 604 uea_err(usb, "firmware is not available\n"); 605 goto err; 606 } 607 608 pfw = fw_entry->data; 609 size = fw_entry->size; 610 if (size < 4) 611 goto err_fw_corrupted; 612 613 crc = get_unaligned_le32(pfw); 614 pfw += 4; 615 size -= 4; 616 if (crc32_be(0, pfw, size) != crc) 617 goto err_fw_corrupted; 618 619 /* 620 * Start to upload firmware : send reset 621 */ 622 value = 1; 623 ret = uea_send_modem_cmd(usb, F8051_USBCS, sizeof(value), &value); 624 625 if (ret < 0) { 626 uea_err(usb, "modem reset failed with error %d\n", ret); 627 goto err; 628 } 629 630 while (size > 3) { 631 u8 len = FW_GET_BYTE(pfw); 632 u16 add = get_unaligned_le16(pfw + 1); 633 634 size -= len + 3; 635 if (size < 0) 636 goto err_fw_corrupted; 637 638 ret = uea_send_modem_cmd(usb, add, len, pfw + 3); 639 if (ret < 0) { 640 uea_err(usb, "uploading firmware data failed " 641 "with error %d\n", ret); 642 goto err; 643 } 644 pfw += len + 3; 645 } 646 647 if (size != 0) 648 goto err_fw_corrupted; 649 650 /* 651 * Tell the modem we finish : de-assert reset 652 */ 653 value = 0; 654 ret = uea_send_modem_cmd(usb, F8051_USBCS, 1, &value); 655 if (ret < 0) 656 uea_err(usb, "modem de-assert failed with error %d\n", ret); 657 else 658 uea_info(usb, "firmware uploaded\n"); 659 660 goto err; 661 662 err_fw_corrupted: 663 uea_err(usb, "firmware is corrupted\n"); 664 err: 665 release_firmware(fw_entry); 666 } 667 668 /* 669 * uea_load_firmware - Load usb firmware for pre-firmware devices. 670 */ 671 static int uea_load_firmware(struct usb_device *usb, unsigned int ver) 672 { 673 int ret; 674 char *fw_name = EAGLE_FIRMWARE; 675 676 uea_info(usb, "pre-firmware device, uploading firmware\n"); 677 678 switch (ver) { 679 case ADI930: 680 fw_name = ADI930_FIRMWARE; 681 break; 682 case EAGLE_I: 683 fw_name = EAGLE_I_FIRMWARE; 684 break; 685 case EAGLE_II: 686 fw_name = EAGLE_II_FIRMWARE; 687 break; 688 case EAGLE_III: 689 fw_name = EAGLE_III_FIRMWARE; 690 break; 691 case EAGLE_IV: 692 fw_name = EAGLE_IV_FIRMWARE; 693 break; 694 } 695 696 ret = request_firmware_nowait(THIS_MODULE, 1, fw_name, &usb->dev, 697 GFP_KERNEL, usb, 698 uea_upload_pre_firmware); 699 if (ret) 700 uea_err(usb, "firmware %s is not available\n", fw_name); 701 else 702 uea_info(usb, "loading firmware %s\n", fw_name); 703 704 return ret; 705 } 706 707 /* modem management : dsp firmware, send/read CMV, monitoring statistic 708 */ 709 710 /* 711 * Make sure that the DSP code provided is safe to use. 712 */ 713 static int check_dsp_e1(const u8 *dsp, unsigned int len) 714 { 715 u8 pagecount, blockcount; 716 u16 blocksize; 717 u32 pageoffset; 718 unsigned int i, j, p, pp; 719 720 pagecount = FW_GET_BYTE(dsp); 721 p = 1; 722 723 /* enough space for page offsets? */ 724 if (p + 4 * pagecount > len) 725 return 1; 726 727 for (i = 0; i < pagecount; i++) { 728 729 pageoffset = get_unaligned_le32(dsp + p); 730 p += 4; 731 732 if (pageoffset == 0) 733 continue; 734 735 /* enough space for blockcount? */ 736 if (pageoffset >= len) 737 return 1; 738 739 pp = pageoffset; 740 blockcount = FW_GET_BYTE(dsp + pp); 741 pp += 1; 742 743 for (j = 0; j < blockcount; j++) { 744 745 /* enough space for block header? */ 746 if (pp + 4 > len) 747 return 1; 748 749 pp += 2; /* skip blockaddr */ 750 blocksize = get_unaligned_le16(dsp + pp); 751 pp += 2; 752 753 /* enough space for block data? */ 754 if (pp + blocksize > len) 755 return 1; 756 757 pp += blocksize; 758 } 759 } 760 761 return 0; 762 } 763 764 static int check_dsp_e4(const u8 *dsp, int len) 765 { 766 int i; 767 struct l1_code *p = (struct l1_code *) dsp; 768 unsigned int sum = p->code - dsp; 769 770 if (len < sum) 771 return 1; 772 773 if (strcmp("STRATIPHY ANEXA", p->string_header) != 0 && 774 strcmp("STRATIPHY ANEXB", p->string_header) != 0) 775 return 1; 776 777 for (i = 0; i < E4_MAX_PAGE_NUMBER; i++) { 778 struct block_index *blockidx; 779 u8 blockno = p->page_number_to_block_index[i]; 780 if (blockno >= E4_NO_SWAPPAGE_HEADERS) 781 continue; 782 783 do { 784 u64 l; 785 786 if (blockno >= E4_NO_SWAPPAGE_HEADERS) 787 return 1; 788 789 blockidx = &p->page_header[blockno++]; 790 if ((u8 *)(blockidx + 1) - dsp >= len) 791 return 1; 792 793 if (le16_to_cpu(blockidx->PageNumber) != i) 794 return 1; 795 796 l = E4_PAGE_BYTES(blockidx->PageSize); 797 sum += l; 798 l += le32_to_cpu(blockidx->PageOffset); 799 if (l > len) 800 return 1; 801 802 /* zero is zero regardless endianness */ 803 } while (blockidx->NotLastBlock); 804 } 805 806 return (sum == len) ? 0 : 1; 807 } 808 809 /* 810 * send data to the idma pipe 811 * */ 812 static int uea_idma_write(struct uea_softc *sc, const void *data, u32 size) 813 { 814 int ret = -ENOMEM; 815 u8 *xfer_buff; 816 int bytes_read; 817 818 xfer_buff = kmemdup(data, size, GFP_KERNEL); 819 if (!xfer_buff) { 820 uea_err(INS_TO_USBDEV(sc), "can't allocate xfer_buff\n"); 821 return ret; 822 } 823 824 ret = usb_bulk_msg(sc->usb_dev, 825 usb_sndbulkpipe(sc->usb_dev, UEA_IDMA_PIPE), 826 xfer_buff, size, &bytes_read, BULK_TIMEOUT); 827 828 kfree(xfer_buff); 829 if (ret < 0) 830 return ret; 831 if (size != bytes_read) { 832 uea_err(INS_TO_USBDEV(sc), "size != bytes_read %d %d\n", size, 833 bytes_read); 834 return -EIO; 835 } 836 837 return 0; 838 } 839 840 static int request_dsp(struct uea_softc *sc) 841 { 842 int ret; 843 char *dsp_name; 844 845 if (UEA_CHIP_VERSION(sc) == EAGLE_IV) { 846 if (IS_ISDN(sc)) 847 dsp_name = DSP4I_FIRMWARE; 848 else 849 dsp_name = DSP4P_FIRMWARE; 850 } else if (UEA_CHIP_VERSION(sc) == ADI930) { 851 if (IS_ISDN(sc)) 852 dsp_name = DSP9I_FIRMWARE; 853 else 854 dsp_name = DSP9P_FIRMWARE; 855 } else { 856 if (IS_ISDN(sc)) 857 dsp_name = DSPEI_FIRMWARE; 858 else 859 dsp_name = DSPEP_FIRMWARE; 860 } 861 862 ret = request_firmware(&sc->dsp_firm, dsp_name, &sc->usb_dev->dev); 863 if (ret < 0) { 864 uea_err(INS_TO_USBDEV(sc), 865 "requesting firmware %s failed with error %d\n", 866 dsp_name, ret); 867 return ret; 868 } 869 870 if (UEA_CHIP_VERSION(sc) == EAGLE_IV) 871 ret = check_dsp_e4(sc->dsp_firm->data, sc->dsp_firm->size); 872 else 873 ret = check_dsp_e1(sc->dsp_firm->data, sc->dsp_firm->size); 874 875 if (ret) { 876 uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n", 877 dsp_name); 878 release_firmware(sc->dsp_firm); 879 sc->dsp_firm = NULL; 880 return -EILSEQ; 881 } 882 883 return 0; 884 } 885 886 /* 887 * The uea_load_page() function must be called within a process context 888 */ 889 static void uea_load_page_e1(struct work_struct *work) 890 { 891 struct uea_softc *sc = container_of(work, struct uea_softc, task); 892 u16 pageno = sc->pageno; 893 u16 ovl = sc->ovl; 894 struct block_info_e1 bi; 895 896 const u8 *p; 897 u8 pagecount, blockcount; 898 u16 blockaddr, blocksize; 899 u32 pageoffset; 900 int i; 901 902 /* reload firmware when reboot start and it's loaded already */ 903 if (ovl == 0 && pageno == 0) { 904 release_firmware(sc->dsp_firm); 905 sc->dsp_firm = NULL; 906 } 907 908 if (sc->dsp_firm == NULL && request_dsp(sc) < 0) 909 return; 910 911 p = sc->dsp_firm->data; 912 pagecount = FW_GET_BYTE(p); 913 p += 1; 914 915 if (pageno >= pagecount) 916 goto bad1; 917 918 p += 4 * pageno; 919 pageoffset = get_unaligned_le32(p); 920 921 if (pageoffset == 0) 922 goto bad1; 923 924 p = sc->dsp_firm->data + pageoffset; 925 blockcount = FW_GET_BYTE(p); 926 p += 1; 927 928 uea_dbg(INS_TO_USBDEV(sc), 929 "sending %u blocks for DSP page %u\n", blockcount, pageno); 930 931 bi.wHdr = cpu_to_le16(UEA_BIHDR); 932 bi.wOvl = cpu_to_le16(ovl); 933 bi.wOvlOffset = cpu_to_le16(ovl | 0x8000); 934 935 for (i = 0; i < blockcount; i++) { 936 blockaddr = get_unaligned_le16(p); 937 p += 2; 938 939 blocksize = get_unaligned_le16(p); 940 p += 2; 941 942 bi.wSize = cpu_to_le16(blocksize); 943 bi.wAddress = cpu_to_le16(blockaddr); 944 bi.wLast = cpu_to_le16((i == blockcount - 1) ? 1 : 0); 945 946 /* send block info through the IDMA pipe */ 947 if (uea_idma_write(sc, &bi, E1_BLOCK_INFO_SIZE)) 948 goto bad2; 949 950 /* send block data through the IDMA pipe */ 951 if (uea_idma_write(sc, p, blocksize)) 952 goto bad2; 953 954 p += blocksize; 955 } 956 957 return; 958 959 bad2: 960 uea_err(INS_TO_USBDEV(sc), "sending DSP block %u failed\n", i); 961 return; 962 bad1: 963 uea_err(INS_TO_USBDEV(sc), "invalid DSP page %u requested\n", pageno); 964 } 965 966 static void __uea_load_page_e4(struct uea_softc *sc, u8 pageno, int boot) 967 { 968 struct block_info_e4 bi; 969 struct block_index *blockidx; 970 struct l1_code *p = (struct l1_code *) sc->dsp_firm->data; 971 u8 blockno = p->page_number_to_block_index[pageno]; 972 973 bi.wHdr = cpu_to_be16(UEA_BIHDR); 974 bi.bBootPage = boot; 975 bi.bPageNumber = pageno; 976 bi.wReserved = cpu_to_be16(UEA_RESERVED); 977 978 do { 979 const u8 *blockoffset; 980 unsigned int blocksize; 981 982 blockidx = &p->page_header[blockno]; 983 blocksize = E4_PAGE_BYTES(blockidx->PageSize); 984 blockoffset = sc->dsp_firm->data + le32_to_cpu( 985 blockidx->PageOffset); 986 987 bi.dwSize = cpu_to_be32(blocksize); 988 bi.dwAddress = cpu_to_be32(le32_to_cpu(blockidx->PageAddress)); 989 990 uea_dbg(INS_TO_USBDEV(sc), 991 "sending block %u for DSP page " 992 "%u size %u address %x\n", 993 blockno, pageno, blocksize, 994 le32_to_cpu(blockidx->PageAddress)); 995 996 /* send block info through the IDMA pipe */ 997 if (uea_idma_write(sc, &bi, E4_BLOCK_INFO_SIZE)) 998 goto bad; 999 1000 /* send block data through the IDMA pipe */ 1001 if (uea_idma_write(sc, blockoffset, blocksize)) 1002 goto bad; 1003 1004 blockno++; 1005 } while (blockidx->NotLastBlock); 1006 1007 return; 1008 1009 bad: 1010 uea_err(INS_TO_USBDEV(sc), "sending DSP block %u failed\n", blockno); 1011 return; 1012 } 1013 1014 static void uea_load_page_e4(struct work_struct *work) 1015 { 1016 struct uea_softc *sc = container_of(work, struct uea_softc, task); 1017 u8 pageno = sc->pageno; 1018 int i; 1019 struct block_info_e4 bi; 1020 struct l1_code *p; 1021 1022 uea_dbg(INS_TO_USBDEV(sc), "sending DSP page %u\n", pageno); 1023 1024 /* reload firmware when reboot start and it's loaded already */ 1025 if (pageno == 0) { 1026 release_firmware(sc->dsp_firm); 1027 sc->dsp_firm = NULL; 1028 } 1029 1030 if (sc->dsp_firm == NULL && request_dsp(sc) < 0) 1031 return; 1032 1033 p = (struct l1_code *) sc->dsp_firm->data; 1034 if (pageno >= le16_to_cpu(p->page_header[0].PageNumber)) { 1035 uea_err(INS_TO_USBDEV(sc), "invalid DSP " 1036 "page %u requested\n", pageno); 1037 return; 1038 } 1039 1040 if (pageno != 0) { 1041 __uea_load_page_e4(sc, pageno, 0); 1042 return; 1043 } 1044 1045 uea_dbg(INS_TO_USBDEV(sc), 1046 "sending Main DSP page %u\n", p->page_header[0].PageNumber); 1047 1048 for (i = 0; i < le16_to_cpu(p->page_header[0].PageNumber); i++) { 1049 if (E4_IS_BOOT_PAGE(p->page_header[i].PageSize)) 1050 __uea_load_page_e4(sc, i, 1); 1051 } 1052 1053 uea_dbg(INS_TO_USBDEV(sc) , "sending start bi\n"); 1054 1055 bi.wHdr = cpu_to_be16(UEA_BIHDR); 1056 bi.bBootPage = 0; 1057 bi.bPageNumber = 0xff; 1058 bi.wReserved = cpu_to_be16(UEA_RESERVED); 1059 bi.dwSize = cpu_to_be32(E4_PAGE_BYTES(p->page_header[0].PageSize)); 1060 bi.dwAddress = cpu_to_be32(le32_to_cpu(p->page_header[0].PageAddress)); 1061 1062 /* send block info through the IDMA pipe */ 1063 if (uea_idma_write(sc, &bi, E4_BLOCK_INFO_SIZE)) 1064 uea_err(INS_TO_USBDEV(sc), "sending DSP start bi failed\n"); 1065 } 1066 1067 static inline void wake_up_cmv_ack(struct uea_softc *sc) 1068 { 1069 BUG_ON(sc->cmv_ack); 1070 sc->cmv_ack = 1; 1071 wake_up(&sc->sync_q); 1072 } 1073 1074 static inline int wait_cmv_ack(struct uea_softc *sc) 1075 { 1076 int ret = uea_wait(sc, sc->cmv_ack , ACK_TIMEOUT); 1077 1078 sc->cmv_ack = 0; 1079 1080 uea_dbg(INS_TO_USBDEV(sc), "wait_event_timeout : %d ms\n", 1081 jiffies_to_msecs(ret)); 1082 1083 if (ret < 0) 1084 return ret; 1085 1086 return (ret == 0) ? -ETIMEDOUT : 0; 1087 } 1088 1089 #define UCDC_SEND_ENCAPSULATED_COMMAND 0x00 1090 1091 static int uea_request(struct uea_softc *sc, 1092 u16 value, u16 index, u16 size, const void *data) 1093 { 1094 u8 *xfer_buff; 1095 int ret = -ENOMEM; 1096 1097 xfer_buff = kmemdup(data, size, GFP_KERNEL); 1098 if (!xfer_buff) { 1099 uea_err(INS_TO_USBDEV(sc), "can't allocate xfer_buff\n"); 1100 return ret; 1101 } 1102 1103 ret = usb_control_msg(sc->usb_dev, usb_sndctrlpipe(sc->usb_dev, 0), 1104 UCDC_SEND_ENCAPSULATED_COMMAND, 1105 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1106 value, index, xfer_buff, size, CTRL_TIMEOUT); 1107 1108 kfree(xfer_buff); 1109 if (ret < 0) { 1110 uea_err(INS_TO_USBDEV(sc), "usb_control_msg error %d\n", ret); 1111 return ret; 1112 } 1113 1114 if (ret != size) { 1115 uea_err(INS_TO_USBDEV(sc), 1116 "usb_control_msg send only %d bytes (instead of %d)\n", 1117 ret, size); 1118 return -EIO; 1119 } 1120 1121 return 0; 1122 } 1123 1124 static int uea_cmv_e1(struct uea_softc *sc, 1125 u8 function, u32 address, u16 offset, u32 data) 1126 { 1127 struct cmv_e1 cmv; 1128 int ret; 1129 1130 uea_vdbg(INS_TO_USBDEV(sc), "Function : %d-%d, Address : %c%c%c%c, " 1131 "offset : 0x%04x, data : 0x%08x\n", 1132 E1_FUNCTION_TYPE(function), 1133 E1_FUNCTION_SUBTYPE(function), 1134 E1_GETSA1(address), E1_GETSA2(address), 1135 E1_GETSA3(address), 1136 E1_GETSA4(address), offset, data); 1137 1138 /* we send a request, but we expect a reply */ 1139 sc->cmv_dsc.e1.function = function | 0x2; 1140 sc->cmv_dsc.e1.idx++; 1141 sc->cmv_dsc.e1.address = address; 1142 sc->cmv_dsc.e1.offset = offset; 1143 1144 cmv.wPreamble = cpu_to_le16(E1_PREAMBLE); 1145 cmv.bDirection = E1_HOSTTOMODEM; 1146 cmv.bFunction = function; 1147 cmv.wIndex = cpu_to_le16(sc->cmv_dsc.e1.idx); 1148 put_unaligned_le32(address, &cmv.dwSymbolicAddress); 1149 cmv.wOffsetAddress = cpu_to_le16(offset); 1150 put_unaligned_le32(data >> 16 | data << 16, &cmv.dwData); 1151 1152 ret = uea_request(sc, UEA_E1_SET_BLOCK, UEA_MPTX_START, 1153 sizeof(cmv), &cmv); 1154 if (ret < 0) 1155 return ret; 1156 1157 return wait_cmv_ack(sc); 1158 } 1159 1160 static int uea_cmv_e4(struct uea_softc *sc, 1161 u16 function, u16 group, u16 address, u16 offset, u32 data) 1162 { 1163 struct cmv_e4 cmv; 1164 int ret; 1165 1166 memset(&cmv, 0, sizeof(cmv)); 1167 1168 uea_vdbg(INS_TO_USBDEV(sc), "Function : %d-%d, Group : 0x%04x, " 1169 "Address : 0x%04x, offset : 0x%04x, data : 0x%08x\n", 1170 E4_FUNCTION_TYPE(function), E4_FUNCTION_SUBTYPE(function), 1171 group, address, offset, data); 1172 1173 /* we send a request, but we expect a reply */ 1174 sc->cmv_dsc.e4.function = function | (0x1 << 4); 1175 sc->cmv_dsc.e4.offset = offset; 1176 sc->cmv_dsc.e4.address = address; 1177 sc->cmv_dsc.e4.group = group; 1178 1179 cmv.wFunction = cpu_to_be16(function); 1180 cmv.wGroup = cpu_to_be16(group); 1181 cmv.wAddress = cpu_to_be16(address); 1182 cmv.wOffset = cpu_to_be16(offset); 1183 cmv.dwData[0] = cpu_to_be32(data); 1184 1185 ret = uea_request(sc, UEA_E4_SET_BLOCK, UEA_MPTX_START, 1186 sizeof(cmv), &cmv); 1187 if (ret < 0) 1188 return ret; 1189 1190 return wait_cmv_ack(sc); 1191 } 1192 1193 static inline int uea_read_cmv_e1(struct uea_softc *sc, 1194 u32 address, u16 offset, u32 *data) 1195 { 1196 int ret = uea_cmv_e1(sc, E1_MAKEFUNCTION(E1_MEMACCESS, E1_REQUESTREAD), 1197 address, offset, 0); 1198 if (ret < 0) 1199 uea_err(INS_TO_USBDEV(sc), 1200 "reading cmv failed with error %d\n", ret); 1201 else 1202 *data = sc->data; 1203 1204 return ret; 1205 } 1206 1207 static inline int uea_read_cmv_e4(struct uea_softc *sc, 1208 u8 size, u16 group, u16 address, u16 offset, u32 *data) 1209 { 1210 int ret = uea_cmv_e4(sc, E4_MAKEFUNCTION(E4_MEMACCESS, 1211 E4_REQUESTREAD, size), 1212 group, address, offset, 0); 1213 if (ret < 0) 1214 uea_err(INS_TO_USBDEV(sc), 1215 "reading cmv failed with error %d\n", ret); 1216 else { 1217 *data = sc->data; 1218 /* size is in 16-bit word quantities */ 1219 if (size > 2) 1220 *(data + 1) = sc->data1; 1221 } 1222 return ret; 1223 } 1224 1225 static inline int uea_write_cmv_e1(struct uea_softc *sc, 1226 u32 address, u16 offset, u32 data) 1227 { 1228 int ret = uea_cmv_e1(sc, E1_MAKEFUNCTION(E1_MEMACCESS, E1_REQUESTWRITE), 1229 address, offset, data); 1230 if (ret < 0) 1231 uea_err(INS_TO_USBDEV(sc), 1232 "writing cmv failed with error %d\n", ret); 1233 1234 return ret; 1235 } 1236 1237 static inline int uea_write_cmv_e4(struct uea_softc *sc, 1238 u8 size, u16 group, u16 address, u16 offset, u32 data) 1239 { 1240 int ret = uea_cmv_e4(sc, E4_MAKEFUNCTION(E4_MEMACCESS, 1241 E4_REQUESTWRITE, size), 1242 group, address, offset, data); 1243 if (ret < 0) 1244 uea_err(INS_TO_USBDEV(sc), 1245 "writing cmv failed with error %d\n", ret); 1246 1247 return ret; 1248 } 1249 1250 static void uea_set_bulk_timeout(struct uea_softc *sc, u32 dsrate) 1251 { 1252 int ret; 1253 u16 timeout; 1254 1255 /* in bulk mode the modem have problem with high rate 1256 * changing internal timing could improve things, but the 1257 * value is mysterious. 1258 * ADI930 don't support it (-EPIPE error). 1259 */ 1260 1261 if (UEA_CHIP_VERSION(sc) == ADI930 || 1262 altsetting[sc->modem_index] > 0 || 1263 sc->stats.phy.dsrate == dsrate) 1264 return; 1265 1266 /* Original timing (1Mbit/s) from ADI (used in windows driver) */ 1267 timeout = (dsrate <= 1024*1024) ? 0 : 1; 1268 ret = uea_request(sc, UEA_SET_TIMEOUT, timeout, 0, NULL); 1269 uea_info(INS_TO_USBDEV(sc), "setting new timeout %d%s\n", 1270 timeout, ret < 0 ? " failed" : ""); 1271 1272 } 1273 1274 /* 1275 * Monitor the modem and update the stat 1276 * return 0 if everything is ok 1277 * return < 0 if an error occurs (-EAGAIN reboot needed) 1278 */ 1279 static int uea_stat_e1(struct uea_softc *sc) 1280 { 1281 u32 data; 1282 int ret; 1283 1284 data = sc->stats.phy.state; 1285 1286 ret = uea_read_cmv_e1(sc, E1_SA_STAT, 0, &sc->stats.phy.state); 1287 if (ret < 0) 1288 return ret; 1289 1290 switch (GET_STATUS(sc->stats.phy.state)) { 1291 case 0: /* not yet synchronized */ 1292 uea_dbg(INS_TO_USBDEV(sc), 1293 "modem not yet synchronized\n"); 1294 return 0; 1295 1296 case 1: /* initialization */ 1297 uea_dbg(INS_TO_USBDEV(sc), "modem initializing\n"); 1298 return 0; 1299 1300 case 2: /* operational */ 1301 uea_vdbg(INS_TO_USBDEV(sc), "modem operational\n"); 1302 break; 1303 1304 case 3: /* fail ... */ 1305 uea_info(INS_TO_USBDEV(sc), "modem synchronization failed" 1306 " (may be try other cmv/dsp)\n"); 1307 return -EAGAIN; 1308 1309 case 4 ... 6: /* test state */ 1310 uea_warn(INS_TO_USBDEV(sc), 1311 "modem in test mode - not supported\n"); 1312 return -EAGAIN; 1313 1314 case 7: /* fast-retain ... */ 1315 uea_info(INS_TO_USBDEV(sc), "modem in fast-retain mode\n"); 1316 return 0; 1317 default: 1318 uea_err(INS_TO_USBDEV(sc), "modem invalid SW mode %d\n", 1319 GET_STATUS(sc->stats.phy.state)); 1320 return -EAGAIN; 1321 } 1322 1323 if (GET_STATUS(data) != 2) { 1324 uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_OFF, 0, NULL); 1325 uea_info(INS_TO_USBDEV(sc), "modem operational\n"); 1326 1327 /* release the dsp firmware as it is not needed until 1328 * the next failure 1329 */ 1330 release_firmware(sc->dsp_firm); 1331 sc->dsp_firm = NULL; 1332 } 1333 1334 /* always update it as atm layer could not be init when we switch to 1335 * operational state 1336 */ 1337 UPDATE_ATM_SIGNAL(ATM_PHY_SIG_FOUND); 1338 1339 /* wake up processes waiting for synchronization */ 1340 wake_up(&sc->sync_q); 1341 1342 ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 2, &sc->stats.phy.flags); 1343 if (ret < 0) 1344 return ret; 1345 sc->stats.phy.mflags |= sc->stats.phy.flags; 1346 1347 /* in case of a flags ( for example delineation LOSS (& 0x10)), 1348 * we check the status again in order to detect the failure earlier 1349 */ 1350 if (sc->stats.phy.flags) { 1351 uea_dbg(INS_TO_USBDEV(sc), "Stat flag = 0x%x\n", 1352 sc->stats.phy.flags); 1353 return 0; 1354 } 1355 1356 ret = uea_read_cmv_e1(sc, E1_SA_RATE, 0, &data); 1357 if (ret < 0) 1358 return ret; 1359 1360 uea_set_bulk_timeout(sc, (data >> 16) * 32); 1361 sc->stats.phy.dsrate = (data >> 16) * 32; 1362 sc->stats.phy.usrate = (data & 0xffff) * 32; 1363 UPDATE_ATM_STAT(link_rate, sc->stats.phy.dsrate * 1000 / 424); 1364 1365 ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 23, &data); 1366 if (ret < 0) 1367 return ret; 1368 sc->stats.phy.dsattenuation = (data & 0xff) / 2; 1369 1370 ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 47, &data); 1371 if (ret < 0) 1372 return ret; 1373 sc->stats.phy.usattenuation = (data & 0xff) / 2; 1374 1375 ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 25, &sc->stats.phy.dsmargin); 1376 if (ret < 0) 1377 return ret; 1378 1379 ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 49, &sc->stats.phy.usmargin); 1380 if (ret < 0) 1381 return ret; 1382 1383 ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 51, &sc->stats.phy.rxflow); 1384 if (ret < 0) 1385 return ret; 1386 1387 ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 52, &sc->stats.phy.txflow); 1388 if (ret < 0) 1389 return ret; 1390 1391 ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 54, &sc->stats.phy.dsunc); 1392 if (ret < 0) 1393 return ret; 1394 1395 /* only for atu-c */ 1396 ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 58, &sc->stats.phy.usunc); 1397 if (ret < 0) 1398 return ret; 1399 1400 ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 53, &sc->stats.phy.dscorr); 1401 if (ret < 0) 1402 return ret; 1403 1404 /* only for atu-c */ 1405 ret = uea_read_cmv_e1(sc, E1_SA_DIAG, 57, &sc->stats.phy.uscorr); 1406 if (ret < 0) 1407 return ret; 1408 1409 ret = uea_read_cmv_e1(sc, E1_SA_INFO, 8, &sc->stats.phy.vidco); 1410 if (ret < 0) 1411 return ret; 1412 1413 ret = uea_read_cmv_e1(sc, E1_SA_INFO, 13, &sc->stats.phy.vidcpe); 1414 if (ret < 0) 1415 return ret; 1416 1417 return 0; 1418 } 1419 1420 static int uea_stat_e4(struct uea_softc *sc) 1421 { 1422 u32 data; 1423 u32 tmp_arr[2]; 1424 int ret; 1425 1426 data = sc->stats.phy.state; 1427 1428 /* XXX only need to be done before operationnal... */ 1429 ret = uea_read_cmv_e4(sc, 1, E4_SA_STAT, 0, 0, &sc->stats.phy.state); 1430 if (ret < 0) 1431 return ret; 1432 1433 switch (sc->stats.phy.state) { 1434 case 0x0: /* not yet synchronized */ 1435 case 0x1: 1436 case 0x3: 1437 case 0x4: 1438 uea_dbg(INS_TO_USBDEV(sc), "modem not yet " 1439 "synchronized\n"); 1440 return 0; 1441 case 0x5: /* initialization */ 1442 case 0x6: 1443 case 0x9: 1444 case 0xa: 1445 uea_dbg(INS_TO_USBDEV(sc), "modem initializing\n"); 1446 return 0; 1447 case 0x2: /* fail ... */ 1448 uea_info(INS_TO_USBDEV(sc), "modem synchronization " 1449 "failed (may be try other cmv/dsp)\n"); 1450 return -EAGAIN; 1451 case 0x7: /* operational */ 1452 break; 1453 default: 1454 uea_warn(INS_TO_USBDEV(sc), "unknown state: %x\n", 1455 sc->stats.phy.state); 1456 return 0; 1457 } 1458 1459 if (data != 7) { 1460 uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_OFF, 0, NULL); 1461 uea_info(INS_TO_USBDEV(sc), "modem operational\n"); 1462 1463 /* release the dsp firmware as it is not needed until 1464 * the next failure 1465 */ 1466 release_firmware(sc->dsp_firm); 1467 sc->dsp_firm = NULL; 1468 } 1469 1470 /* always update it as atm layer could not be init when we switch to 1471 * operational state 1472 */ 1473 UPDATE_ATM_SIGNAL(ATM_PHY_SIG_FOUND); 1474 1475 /* wake up processes waiting for synchronization */ 1476 wake_up(&sc->sync_q); 1477 1478 /* TODO improve this state machine : 1479 * we need some CMV info : what they do and their unit 1480 * we should find the equivalent of eagle3- CMV 1481 */ 1482 /* check flags */ 1483 ret = uea_read_cmv_e4(sc, 1, E4_SA_DIAG, 0, 0, &sc->stats.phy.flags); 1484 if (ret < 0) 1485 return ret; 1486 sc->stats.phy.mflags |= sc->stats.phy.flags; 1487 1488 /* in case of a flags ( for example delineation LOSS (& 0x10)), 1489 * we check the status again in order to detect the failure earlier 1490 */ 1491 if (sc->stats.phy.flags) { 1492 uea_dbg(INS_TO_USBDEV(sc), "Stat flag = 0x%x\n", 1493 sc->stats.phy.flags); 1494 if (sc->stats.phy.flags & 1) /* delineation LOSS */ 1495 return -EAGAIN; 1496 if (sc->stats.phy.flags & 0x4000) /* Reset Flag */ 1497 return -EAGAIN; 1498 return 0; 1499 } 1500 1501 /* rate data may be in upper or lower half of 64 bit word, strange */ 1502 ret = uea_read_cmv_e4(sc, 4, E4_SA_RATE, 0, 0, tmp_arr); 1503 if (ret < 0) 1504 return ret; 1505 data = (tmp_arr[0]) ? tmp_arr[0] : tmp_arr[1]; 1506 sc->stats.phy.usrate = data / 1000; 1507 1508 ret = uea_read_cmv_e4(sc, 4, E4_SA_RATE, 1, 0, tmp_arr); 1509 if (ret < 0) 1510 return ret; 1511 data = (tmp_arr[0]) ? tmp_arr[0] : tmp_arr[1]; 1512 uea_set_bulk_timeout(sc, data / 1000); 1513 sc->stats.phy.dsrate = data / 1000; 1514 UPDATE_ATM_STAT(link_rate, sc->stats.phy.dsrate * 1000 / 424); 1515 1516 ret = uea_read_cmv_e4(sc, 1, E4_SA_INFO, 68, 1, &data); 1517 if (ret < 0) 1518 return ret; 1519 sc->stats.phy.dsattenuation = data / 10; 1520 1521 ret = uea_read_cmv_e4(sc, 1, E4_SA_INFO, 69, 1, &data); 1522 if (ret < 0) 1523 return ret; 1524 sc->stats.phy.usattenuation = data / 10; 1525 1526 ret = uea_read_cmv_e4(sc, 1, E4_SA_INFO, 68, 3, &data); 1527 if (ret < 0) 1528 return ret; 1529 sc->stats.phy.dsmargin = data / 2; 1530 1531 ret = uea_read_cmv_e4(sc, 1, E4_SA_INFO, 69, 3, &data); 1532 if (ret < 0) 1533 return ret; 1534 sc->stats.phy.usmargin = data / 10; 1535 1536 return 0; 1537 } 1538 1539 static void cmvs_file_name(struct uea_softc *sc, char *const cmv_name, int ver) 1540 { 1541 char file_arr[] = "CMVxy.bin"; 1542 char *file; 1543 1544 kernel_param_lock(THIS_MODULE); 1545 /* set proper name corresponding modem version and line type */ 1546 if (cmv_file[sc->modem_index] == NULL) { 1547 if (UEA_CHIP_VERSION(sc) == ADI930) 1548 file_arr[3] = '9'; 1549 else if (UEA_CHIP_VERSION(sc) == EAGLE_IV) 1550 file_arr[3] = '4'; 1551 else 1552 file_arr[3] = 'e'; 1553 1554 file_arr[4] = IS_ISDN(sc) ? 'i' : 'p'; 1555 file = file_arr; 1556 } else 1557 file = cmv_file[sc->modem_index]; 1558 1559 snprintf(cmv_name, UEA_FW_NAME_MAX, FW_DIR "%s%s", 1560 file, ver == 2 ? ".v2" : ""); 1561 kernel_param_unlock(THIS_MODULE); 1562 } 1563 1564 static int request_cmvs_old(struct uea_softc *sc, 1565 void **cmvs, const struct firmware **fw) 1566 { 1567 int ret, size; 1568 u8 *data; 1569 char cmv_name[UEA_FW_NAME_MAX]; /* 30 bytes stack variable */ 1570 1571 cmvs_file_name(sc, cmv_name, 1); 1572 ret = request_firmware(fw, cmv_name, &sc->usb_dev->dev); 1573 if (ret < 0) { 1574 uea_err(INS_TO_USBDEV(sc), 1575 "requesting firmware %s failed with error %d\n", 1576 cmv_name, ret); 1577 return ret; 1578 } 1579 1580 data = (u8 *) (*fw)->data; 1581 size = (*fw)->size; 1582 if (size < 1) 1583 goto err_fw_corrupted; 1584 1585 if (size != *data * sizeof(struct uea_cmvs_v1) + 1) 1586 goto err_fw_corrupted; 1587 1588 *cmvs = (void *)(data + 1); 1589 return *data; 1590 1591 err_fw_corrupted: 1592 uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n", cmv_name); 1593 release_firmware(*fw); 1594 return -EILSEQ; 1595 } 1596 1597 static int request_cmvs(struct uea_softc *sc, 1598 void **cmvs, const struct firmware **fw, int *ver) 1599 { 1600 int ret, size; 1601 u32 crc; 1602 u8 *data; 1603 char cmv_name[UEA_FW_NAME_MAX]; /* 30 bytes stack variable */ 1604 1605 cmvs_file_name(sc, cmv_name, 2); 1606 ret = request_firmware(fw, cmv_name, &sc->usb_dev->dev); 1607 if (ret < 0) { 1608 /* if caller can handle old version, try to provide it */ 1609 if (*ver == 1) { 1610 uea_warn(INS_TO_USBDEV(sc), "requesting " 1611 "firmware %s failed, " 1612 "try to get older cmvs\n", cmv_name); 1613 return request_cmvs_old(sc, cmvs, fw); 1614 } 1615 uea_err(INS_TO_USBDEV(sc), 1616 "requesting firmware %s failed with error %d\n", 1617 cmv_name, ret); 1618 return ret; 1619 } 1620 1621 size = (*fw)->size; 1622 data = (u8 *) (*fw)->data; 1623 if (size < 4 || strncmp(data, "cmv2", 4) != 0) { 1624 if (*ver == 1) { 1625 uea_warn(INS_TO_USBDEV(sc), "firmware %s is corrupted," 1626 " try to get older cmvs\n", cmv_name); 1627 release_firmware(*fw); 1628 return request_cmvs_old(sc, cmvs, fw); 1629 } 1630 goto err_fw_corrupted; 1631 } 1632 1633 *ver = 2; 1634 1635 data += 4; 1636 size -= 4; 1637 if (size < 5) 1638 goto err_fw_corrupted; 1639 1640 crc = get_unaligned_le32(data); 1641 data += 4; 1642 size -= 4; 1643 if (crc32_be(0, data, size) != crc) 1644 goto err_fw_corrupted; 1645 1646 if (size != *data * sizeof(struct uea_cmvs_v2) + 1) 1647 goto err_fw_corrupted; 1648 1649 *cmvs = (void *) (data + 1); 1650 return *data; 1651 1652 err_fw_corrupted: 1653 uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n", cmv_name); 1654 release_firmware(*fw); 1655 return -EILSEQ; 1656 } 1657 1658 static int uea_send_cmvs_e1(struct uea_softc *sc) 1659 { 1660 int i, ret, len; 1661 void *cmvs_ptr; 1662 const struct firmware *cmvs_fw; 1663 int ver = 1; /* we can handle v1 cmv firmware version; */ 1664 1665 /* Enter in R-IDLE (cmv) until instructed otherwise */ 1666 ret = uea_write_cmv_e1(sc, E1_SA_CNTL, 0, 1); 1667 if (ret < 0) 1668 return ret; 1669 1670 /* Dump firmware version */ 1671 ret = uea_read_cmv_e1(sc, E1_SA_INFO, 10, &sc->stats.phy.firmid); 1672 if (ret < 0) 1673 return ret; 1674 uea_info(INS_TO_USBDEV(sc), "ATU-R firmware version : %x\n", 1675 sc->stats.phy.firmid); 1676 1677 /* get options */ 1678 ret = len = request_cmvs(sc, &cmvs_ptr, &cmvs_fw, &ver); 1679 if (ret < 0) 1680 return ret; 1681 1682 /* send options */ 1683 if (ver == 1) { 1684 struct uea_cmvs_v1 *cmvs_v1 = cmvs_ptr; 1685 1686 uea_warn(INS_TO_USBDEV(sc), "use deprecated cmvs version, " 1687 "please update your firmware\n"); 1688 1689 for (i = 0; i < len; i++) { 1690 ret = uea_write_cmv_e1(sc, 1691 get_unaligned_le32(&cmvs_v1[i].address), 1692 get_unaligned_le16(&cmvs_v1[i].offset), 1693 get_unaligned_le32(&cmvs_v1[i].data)); 1694 if (ret < 0) 1695 goto out; 1696 } 1697 } else if (ver == 2) { 1698 struct uea_cmvs_v2 *cmvs_v2 = cmvs_ptr; 1699 1700 for (i = 0; i < len; i++) { 1701 ret = uea_write_cmv_e1(sc, 1702 get_unaligned_le32(&cmvs_v2[i].address), 1703 (u16) get_unaligned_le32(&cmvs_v2[i].offset), 1704 get_unaligned_le32(&cmvs_v2[i].data)); 1705 if (ret < 0) 1706 goto out; 1707 } 1708 } else { 1709 /* This really should not happen */ 1710 uea_err(INS_TO_USBDEV(sc), "bad cmvs version %d\n", ver); 1711 goto out; 1712 } 1713 1714 /* Enter in R-ACT-REQ */ 1715 ret = uea_write_cmv_e1(sc, E1_SA_CNTL, 0, 2); 1716 uea_vdbg(INS_TO_USBDEV(sc), "Entering in R-ACT-REQ state\n"); 1717 uea_info(INS_TO_USBDEV(sc), "modem started, waiting " 1718 "synchronization...\n"); 1719 out: 1720 release_firmware(cmvs_fw); 1721 return ret; 1722 } 1723 1724 static int uea_send_cmvs_e4(struct uea_softc *sc) 1725 { 1726 int i, ret, len; 1727 void *cmvs_ptr; 1728 const struct firmware *cmvs_fw; 1729 int ver = 2; /* we can only handle v2 cmv firmware version; */ 1730 1731 /* Enter in R-IDLE (cmv) until instructed otherwise */ 1732 ret = uea_write_cmv_e4(sc, 1, E4_SA_CNTL, 0, 0, 1); 1733 if (ret < 0) 1734 return ret; 1735 1736 /* Dump firmware version */ 1737 /* XXX don't read the 3th byte as it is always 6 */ 1738 ret = uea_read_cmv_e4(sc, 2, E4_SA_INFO, 55, 0, &sc->stats.phy.firmid); 1739 if (ret < 0) 1740 return ret; 1741 uea_info(INS_TO_USBDEV(sc), "ATU-R firmware version : %x\n", 1742 sc->stats.phy.firmid); 1743 1744 1745 /* get options */ 1746 ret = len = request_cmvs(sc, &cmvs_ptr, &cmvs_fw, &ver); 1747 if (ret < 0) 1748 return ret; 1749 1750 /* send options */ 1751 if (ver == 2) { 1752 struct uea_cmvs_v2 *cmvs_v2 = cmvs_ptr; 1753 1754 for (i = 0; i < len; i++) { 1755 ret = uea_write_cmv_e4(sc, 1, 1756 get_unaligned_le32(&cmvs_v2[i].group), 1757 get_unaligned_le32(&cmvs_v2[i].address), 1758 get_unaligned_le32(&cmvs_v2[i].offset), 1759 get_unaligned_le32(&cmvs_v2[i].data)); 1760 if (ret < 0) 1761 goto out; 1762 } 1763 } else { 1764 /* This really should not happen */ 1765 uea_err(INS_TO_USBDEV(sc), "bad cmvs version %d\n", ver); 1766 goto out; 1767 } 1768 1769 /* Enter in R-ACT-REQ */ 1770 ret = uea_write_cmv_e4(sc, 1, E4_SA_CNTL, 0, 0, 2); 1771 uea_vdbg(INS_TO_USBDEV(sc), "Entering in R-ACT-REQ state\n"); 1772 uea_info(INS_TO_USBDEV(sc), "modem started, waiting " 1773 "synchronization...\n"); 1774 out: 1775 release_firmware(cmvs_fw); 1776 return ret; 1777 } 1778 1779 /* Start boot post firmware modem: 1780 * - send reset commands through usb control pipe 1781 * - start workqueue for DSP loading 1782 * - send CMV options to modem 1783 */ 1784 1785 static int uea_start_reset(struct uea_softc *sc) 1786 { 1787 u16 zero = 0; /* ;-) */ 1788 int ret; 1789 1790 uea_info(INS_TO_USBDEV(sc), "(re)booting started\n"); 1791 1792 /* mask interrupt */ 1793 sc->booting = 1; 1794 /* We need to set this here because, a ack timeout could have occurred, 1795 * but before we start the reboot, the ack occurs and set this to 1. 1796 * So we will failed to wait Ready CMV. 1797 */ 1798 sc->cmv_ack = 0; 1799 UPDATE_ATM_SIGNAL(ATM_PHY_SIG_LOST); 1800 1801 /* reset statistics */ 1802 memset(&sc->stats, 0, sizeof(struct uea_stats)); 1803 1804 /* tell the modem that we want to boot in IDMA mode */ 1805 uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_ON, 0, NULL); 1806 uea_request(sc, UEA_SET_MODE, UEA_BOOT_IDMA, 0, NULL); 1807 1808 /* enter reset mode */ 1809 uea_request(sc, UEA_SET_MODE, UEA_START_RESET, 0, NULL); 1810 1811 /* original driver use 200ms, but windows driver use 100ms */ 1812 ret = uea_wait(sc, 0, msecs_to_jiffies(100)); 1813 if (ret < 0) 1814 return ret; 1815 1816 /* leave reset mode */ 1817 uea_request(sc, UEA_SET_MODE, UEA_END_RESET, 0, NULL); 1818 1819 if (UEA_CHIP_VERSION(sc) != EAGLE_IV) { 1820 /* clear tx and rx mailboxes */ 1821 uea_request(sc, UEA_SET_2183_DATA, UEA_MPTX_MAILBOX, 2, &zero); 1822 uea_request(sc, UEA_SET_2183_DATA, UEA_MPRX_MAILBOX, 2, &zero); 1823 uea_request(sc, UEA_SET_2183_DATA, UEA_SWAP_MAILBOX, 2, &zero); 1824 } 1825 1826 ret = uea_wait(sc, 0, msecs_to_jiffies(1000)); 1827 if (ret < 0) 1828 return ret; 1829 1830 if (UEA_CHIP_VERSION(sc) == EAGLE_IV) 1831 sc->cmv_dsc.e4.function = E4_MAKEFUNCTION(E4_ADSLDIRECTIVE, 1832 E4_MODEMREADY, 1); 1833 else 1834 sc->cmv_dsc.e1.function = E1_MAKEFUNCTION(E1_ADSLDIRECTIVE, 1835 E1_MODEMREADY); 1836 1837 /* demask interrupt */ 1838 sc->booting = 0; 1839 1840 /* start loading DSP */ 1841 sc->pageno = 0; 1842 sc->ovl = 0; 1843 schedule_work(&sc->task); 1844 1845 /* wait for modem ready CMV */ 1846 ret = wait_cmv_ack(sc); 1847 if (ret < 0) 1848 return ret; 1849 1850 uea_vdbg(INS_TO_USBDEV(sc), "Ready CMV received\n"); 1851 1852 ret = sc->send_cmvs(sc); 1853 if (ret < 0) 1854 return ret; 1855 1856 sc->reset = 0; 1857 return ret; 1858 } 1859 1860 /* 1861 * In case of an error wait 1s before rebooting the modem 1862 * if the modem don't request reboot (-EAGAIN). 1863 * Monitor the modem every 1s. 1864 */ 1865 1866 static int uea_kthread(void *data) 1867 { 1868 struct uea_softc *sc = data; 1869 int ret = -EAGAIN; 1870 1871 set_freezable(); 1872 while (!kthread_should_stop()) { 1873 if (ret < 0 || sc->reset) 1874 ret = uea_start_reset(sc); 1875 if (!ret) 1876 ret = sc->stat(sc); 1877 if (ret != -EAGAIN) 1878 uea_wait(sc, 0, msecs_to_jiffies(1000)); 1879 } 1880 1881 return ret; 1882 } 1883 1884 /* Load second usb firmware for ADI930 chip */ 1885 static int load_XILINX_firmware(struct uea_softc *sc) 1886 { 1887 const struct firmware *fw_entry; 1888 int ret, size, u, ln; 1889 const u8 *pfw; 1890 u8 value; 1891 char *fw_name = FPGA930_FIRMWARE; 1892 1893 ret = request_firmware(&fw_entry, fw_name, &sc->usb_dev->dev); 1894 if (ret) { 1895 uea_err(INS_TO_USBDEV(sc), "firmware %s is not available\n", 1896 fw_name); 1897 goto err0; 1898 } 1899 1900 pfw = fw_entry->data; 1901 size = fw_entry->size; 1902 if (size != 0x577B) { 1903 uea_err(INS_TO_USBDEV(sc), "firmware %s is corrupted\n", 1904 fw_name); 1905 ret = -EILSEQ; 1906 goto err1; 1907 } 1908 for (u = 0; u < size; u += ln) { 1909 ln = min(size - u, 64); 1910 ret = uea_request(sc, 0xe, 0, ln, pfw + u); 1911 if (ret < 0) { 1912 uea_err(INS_TO_USBDEV(sc), 1913 "elsa download data failed (%d)\n", ret); 1914 goto err1; 1915 } 1916 } 1917 1918 /* finish to send the fpga */ 1919 ret = uea_request(sc, 0xe, 1, 0, NULL); 1920 if (ret < 0) { 1921 uea_err(INS_TO_USBDEV(sc), 1922 "elsa download data failed (%d)\n", ret); 1923 goto err1; 1924 } 1925 1926 /* Tell the modem we finish : de-assert reset */ 1927 value = 0; 1928 ret = uea_send_modem_cmd(sc->usb_dev, 0xe, 1, &value); 1929 if (ret < 0) 1930 uea_err(sc->usb_dev, "elsa de-assert failed with error" 1931 " %d\n", ret); 1932 1933 err1: 1934 release_firmware(fw_entry); 1935 err0: 1936 return ret; 1937 } 1938 1939 /* The modem send us an ack. First with check if it right */ 1940 static void uea_dispatch_cmv_e1(struct uea_softc *sc, struct intr_pkt *intr) 1941 { 1942 struct cmv_dsc_e1 *dsc = &sc->cmv_dsc.e1; 1943 struct cmv_e1 *cmv = &intr->u.e1.s2.cmv; 1944 1945 if (le16_to_cpu(cmv->wPreamble) != E1_PREAMBLE) 1946 goto bad1; 1947 1948 if (cmv->bDirection != E1_MODEMTOHOST) 1949 goto bad1; 1950 1951 /* FIXME : ADI930 reply wrong preamble (func = 2, sub = 2) to 1952 * the first MEMACCESS cmv. Ignore it... 1953 */ 1954 if (cmv->bFunction != dsc->function) { 1955 if (UEA_CHIP_VERSION(sc) == ADI930 1956 && cmv->bFunction == E1_MAKEFUNCTION(2, 2)) { 1957 cmv->wIndex = cpu_to_le16(dsc->idx); 1958 put_unaligned_le32(dsc->address, 1959 &cmv->dwSymbolicAddress); 1960 cmv->wOffsetAddress = cpu_to_le16(dsc->offset); 1961 } else 1962 goto bad2; 1963 } 1964 1965 if (cmv->bFunction == E1_MAKEFUNCTION(E1_ADSLDIRECTIVE, 1966 E1_MODEMREADY)) { 1967 wake_up_cmv_ack(sc); 1968 return; 1969 } 1970 1971 /* in case of MEMACCESS */ 1972 if (le16_to_cpu(cmv->wIndex) != dsc->idx || 1973 get_unaligned_le32(&cmv->dwSymbolicAddress) != dsc->address || 1974 le16_to_cpu(cmv->wOffsetAddress) != dsc->offset) 1975 goto bad2; 1976 1977 sc->data = get_unaligned_le32(&cmv->dwData); 1978 sc->data = sc->data << 16 | sc->data >> 16; 1979 1980 wake_up_cmv_ack(sc); 1981 return; 1982 1983 bad2: 1984 uea_err(INS_TO_USBDEV(sc), "unexpected cmv received, " 1985 "Function : %d, Subfunction : %d\n", 1986 E1_FUNCTION_TYPE(cmv->bFunction), 1987 E1_FUNCTION_SUBTYPE(cmv->bFunction)); 1988 return; 1989 1990 bad1: 1991 uea_err(INS_TO_USBDEV(sc), "invalid cmv received, " 1992 "wPreamble %d, bDirection %d\n", 1993 le16_to_cpu(cmv->wPreamble), cmv->bDirection); 1994 } 1995 1996 /* The modem send us an ack. First with check if it right */ 1997 static void uea_dispatch_cmv_e4(struct uea_softc *sc, struct intr_pkt *intr) 1998 { 1999 struct cmv_dsc_e4 *dsc = &sc->cmv_dsc.e4; 2000 struct cmv_e4 *cmv = &intr->u.e4.s2.cmv; 2001 2002 uea_dbg(INS_TO_USBDEV(sc), "cmv %x %x %x %x %x %x\n", 2003 be16_to_cpu(cmv->wGroup), be16_to_cpu(cmv->wFunction), 2004 be16_to_cpu(cmv->wOffset), be16_to_cpu(cmv->wAddress), 2005 be32_to_cpu(cmv->dwData[0]), be32_to_cpu(cmv->dwData[1])); 2006 2007 if (be16_to_cpu(cmv->wFunction) != dsc->function) 2008 goto bad2; 2009 2010 if (be16_to_cpu(cmv->wFunction) == E4_MAKEFUNCTION(E4_ADSLDIRECTIVE, 2011 E4_MODEMREADY, 1)) { 2012 wake_up_cmv_ack(sc); 2013 return; 2014 } 2015 2016 /* in case of MEMACCESS */ 2017 if (be16_to_cpu(cmv->wOffset) != dsc->offset || 2018 be16_to_cpu(cmv->wGroup) != dsc->group || 2019 be16_to_cpu(cmv->wAddress) != dsc->address) 2020 goto bad2; 2021 2022 sc->data = be32_to_cpu(cmv->dwData[0]); 2023 sc->data1 = be32_to_cpu(cmv->dwData[1]); 2024 wake_up_cmv_ack(sc); 2025 return; 2026 2027 bad2: 2028 uea_err(INS_TO_USBDEV(sc), "unexpected cmv received, " 2029 "Function : %d, Subfunction : %d\n", 2030 E4_FUNCTION_TYPE(cmv->wFunction), 2031 E4_FUNCTION_SUBTYPE(cmv->wFunction)); 2032 return; 2033 } 2034 2035 static void uea_schedule_load_page_e1(struct uea_softc *sc, 2036 struct intr_pkt *intr) 2037 { 2038 sc->pageno = intr->e1_bSwapPageNo; 2039 sc->ovl = intr->e1_bOvl >> 4 | intr->e1_bOvl << 4; 2040 schedule_work(&sc->task); 2041 } 2042 2043 static void uea_schedule_load_page_e4(struct uea_softc *sc, 2044 struct intr_pkt *intr) 2045 { 2046 sc->pageno = intr->e4_bSwapPageNo; 2047 schedule_work(&sc->task); 2048 } 2049 2050 /* 2051 * interrupt handler 2052 */ 2053 static void uea_intr(struct urb *urb) 2054 { 2055 struct uea_softc *sc = urb->context; 2056 struct intr_pkt *intr = urb->transfer_buffer; 2057 int status = urb->status; 2058 2059 if (unlikely(status < 0)) { 2060 uea_err(INS_TO_USBDEV(sc), "uea_intr() failed with %d\n", 2061 status); 2062 return; 2063 } 2064 2065 /* device-to-host interrupt */ 2066 if (intr->bType != 0x08 || sc->booting) { 2067 uea_err(INS_TO_USBDEV(sc), "wrong interrupt\n"); 2068 goto resubmit; 2069 } 2070 2071 switch (le16_to_cpu(intr->wInterrupt)) { 2072 case INT_LOADSWAPPAGE: 2073 sc->schedule_load_page(sc, intr); 2074 break; 2075 2076 case INT_INCOMINGCMV: 2077 sc->dispatch_cmv(sc, intr); 2078 break; 2079 2080 default: 2081 uea_err(INS_TO_USBDEV(sc), "unknown interrupt %u\n", 2082 le16_to_cpu(intr->wInterrupt)); 2083 } 2084 2085 resubmit: 2086 usb_submit_urb(sc->urb_int, GFP_ATOMIC); 2087 } 2088 2089 /* 2090 * Start the modem : init the data and start kernel thread 2091 */ 2092 static int uea_boot(struct uea_softc *sc, struct usb_interface *intf) 2093 { 2094 struct intr_pkt *intr; 2095 int ret = -ENOMEM; 2096 int size; 2097 2098 if (UEA_CHIP_VERSION(sc) == EAGLE_IV) { 2099 size = E4_INTR_PKT_SIZE; 2100 sc->dispatch_cmv = uea_dispatch_cmv_e4; 2101 sc->schedule_load_page = uea_schedule_load_page_e4; 2102 sc->stat = uea_stat_e4; 2103 sc->send_cmvs = uea_send_cmvs_e4; 2104 INIT_WORK(&sc->task, uea_load_page_e4); 2105 } else { 2106 size = E1_INTR_PKT_SIZE; 2107 sc->dispatch_cmv = uea_dispatch_cmv_e1; 2108 sc->schedule_load_page = uea_schedule_load_page_e1; 2109 sc->stat = uea_stat_e1; 2110 sc->send_cmvs = uea_send_cmvs_e1; 2111 INIT_WORK(&sc->task, uea_load_page_e1); 2112 } 2113 2114 init_waitqueue_head(&sc->sync_q); 2115 2116 if (UEA_CHIP_VERSION(sc) == ADI930) 2117 load_XILINX_firmware(sc); 2118 2119 if (intf->cur_altsetting->desc.bNumEndpoints < 1) { 2120 ret = -ENODEV; 2121 goto err0; 2122 } 2123 2124 intr = kmalloc(size, GFP_KERNEL); 2125 if (!intr) 2126 goto err0; 2127 2128 sc->urb_int = usb_alloc_urb(0, GFP_KERNEL); 2129 if (!sc->urb_int) 2130 goto err1; 2131 2132 usb_fill_int_urb(sc->urb_int, sc->usb_dev, 2133 usb_rcvintpipe(sc->usb_dev, UEA_INTR_PIPE), 2134 intr, size, uea_intr, sc, 2135 intf->cur_altsetting->endpoint[0].desc.bInterval); 2136 2137 ret = usb_submit_urb(sc->urb_int, GFP_KERNEL); 2138 if (ret < 0) { 2139 uea_err(INS_TO_USBDEV(sc), 2140 "urb submission failed with error %d\n", ret); 2141 goto err1; 2142 } 2143 2144 /* Create worker thread, but don't start it here. Start it after 2145 * all usbatm generic initialization is done. 2146 */ 2147 sc->kthread = kthread_create(uea_kthread, sc, "ueagle-atm"); 2148 if (IS_ERR(sc->kthread)) { 2149 uea_err(INS_TO_USBDEV(sc), "failed to create thread\n"); 2150 ret = PTR_ERR(sc->kthread); 2151 goto err2; 2152 } 2153 2154 return 0; 2155 2156 err2: 2157 usb_kill_urb(sc->urb_int); 2158 err1: 2159 usb_free_urb(sc->urb_int); 2160 sc->urb_int = NULL; 2161 kfree(intr); 2162 err0: 2163 return ret; 2164 } 2165 2166 /* 2167 * Stop the modem : kill kernel thread and free data 2168 */ 2169 static void uea_stop(struct uea_softc *sc) 2170 { 2171 int ret; 2172 2173 ret = kthread_stop(sc->kthread); 2174 uea_dbg(INS_TO_USBDEV(sc), "kthread finish with status %d\n", ret); 2175 2176 uea_request(sc, UEA_SET_MODE, UEA_LOOPBACK_ON, 0, NULL); 2177 2178 usb_kill_urb(sc->urb_int); 2179 kfree(sc->urb_int->transfer_buffer); 2180 usb_free_urb(sc->urb_int); 2181 2182 /* flush the work item, when no one can schedule it */ 2183 flush_work(&sc->task); 2184 2185 release_firmware(sc->dsp_firm); 2186 } 2187 2188 /* syfs interface */ 2189 static struct uea_softc *dev_to_uea(struct device *dev) 2190 { 2191 struct usb_interface *intf; 2192 struct usbatm_data *usbatm; 2193 2194 intf = to_usb_interface(dev); 2195 if (!intf) 2196 return NULL; 2197 2198 usbatm = usb_get_intfdata(intf); 2199 if (!usbatm) 2200 return NULL; 2201 2202 return usbatm->driver_data; 2203 } 2204 2205 static ssize_t stat_status_show(struct device *dev, struct device_attribute *attr, 2206 char *buf) 2207 { 2208 int ret = -ENODEV; 2209 struct uea_softc *sc; 2210 2211 mutex_lock(&uea_mutex); 2212 sc = dev_to_uea(dev); 2213 if (!sc) 2214 goto out; 2215 ret = sysfs_emit(buf, "%08x\n", sc->stats.phy.state); 2216 out: 2217 mutex_unlock(&uea_mutex); 2218 return ret; 2219 } 2220 2221 static ssize_t stat_status_store(struct device *dev, struct device_attribute *attr, 2222 const char *buf, size_t count) 2223 { 2224 int ret = -ENODEV; 2225 struct uea_softc *sc; 2226 2227 mutex_lock(&uea_mutex); 2228 sc = dev_to_uea(dev); 2229 if (!sc) 2230 goto out; 2231 sc->reset = 1; 2232 ret = count; 2233 out: 2234 mutex_unlock(&uea_mutex); 2235 return ret; 2236 } 2237 2238 static DEVICE_ATTR_RW(stat_status); 2239 2240 static ssize_t stat_human_status_show(struct device *dev, 2241 struct device_attribute *attr, char *buf) 2242 { 2243 int ret = -ENODEV; 2244 int modem_state; 2245 struct uea_softc *sc; 2246 2247 mutex_lock(&uea_mutex); 2248 sc = dev_to_uea(dev); 2249 if (!sc) 2250 goto out; 2251 2252 if (UEA_CHIP_VERSION(sc) == EAGLE_IV) { 2253 switch (sc->stats.phy.state) { 2254 case 0x0: /* not yet synchronized */ 2255 case 0x1: 2256 case 0x3: 2257 case 0x4: 2258 modem_state = 0; 2259 break; 2260 case 0x5: /* initialization */ 2261 case 0x6: 2262 case 0x9: 2263 case 0xa: 2264 modem_state = 1; 2265 break; 2266 case 0x7: /* operational */ 2267 modem_state = 2; 2268 break; 2269 case 0x2: /* fail ... */ 2270 modem_state = 3; 2271 break; 2272 default: /* unknown */ 2273 modem_state = 4; 2274 break; 2275 } 2276 } else 2277 modem_state = GET_STATUS(sc->stats.phy.state); 2278 2279 switch (modem_state) { 2280 case 0: 2281 ret = sysfs_emit(buf, "Modem is booting\n"); 2282 break; 2283 case 1: 2284 ret = sysfs_emit(buf, "Modem is initializing\n"); 2285 break; 2286 case 2: 2287 ret = sysfs_emit(buf, "Modem is operational\n"); 2288 break; 2289 case 3: 2290 ret = sysfs_emit(buf, "Modem synchronization failed\n"); 2291 break; 2292 default: 2293 ret = sysfs_emit(buf, "Modem state is unknown\n"); 2294 break; 2295 } 2296 out: 2297 mutex_unlock(&uea_mutex); 2298 return ret; 2299 } 2300 2301 static DEVICE_ATTR_RO(stat_human_status); 2302 2303 static ssize_t stat_delin_show(struct device *dev, struct device_attribute *attr, 2304 char *buf) 2305 { 2306 int ret = -ENODEV; 2307 struct uea_softc *sc; 2308 char *delin = "GOOD"; 2309 2310 mutex_lock(&uea_mutex); 2311 sc = dev_to_uea(dev); 2312 if (!sc) 2313 goto out; 2314 2315 if (UEA_CHIP_VERSION(sc) == EAGLE_IV) { 2316 if (sc->stats.phy.flags & 0x4000) 2317 delin = "RESET"; 2318 else if (sc->stats.phy.flags & 0x0001) 2319 delin = "LOSS"; 2320 } else { 2321 if (sc->stats.phy.flags & 0x0C00) 2322 delin = "ERROR"; 2323 else if (sc->stats.phy.flags & 0x0030) 2324 delin = "LOSS"; 2325 } 2326 2327 ret = sysfs_emit(buf, "%s\n", delin); 2328 out: 2329 mutex_unlock(&uea_mutex); 2330 return ret; 2331 } 2332 2333 static DEVICE_ATTR_RO(stat_delin); 2334 2335 #define UEA_ATTR(name, reset) \ 2336 \ 2337 static ssize_t stat_##name##_show(struct device *dev, \ 2338 struct device_attribute *attr, char *buf) \ 2339 { \ 2340 int ret = -ENODEV; \ 2341 struct uea_softc *sc; \ 2342 \ 2343 mutex_lock(&uea_mutex); \ 2344 sc = dev_to_uea(dev); \ 2345 if (!sc) \ 2346 goto out; \ 2347 ret = sysfs_emit(buf, "%08x\n", sc->stats.phy.name); \ 2348 if (reset) \ 2349 sc->stats.phy.name = 0; \ 2350 out: \ 2351 mutex_unlock(&uea_mutex); \ 2352 return ret; \ 2353 } \ 2354 \ 2355 static DEVICE_ATTR_RO(stat_##name) 2356 2357 UEA_ATTR(mflags, 1); 2358 UEA_ATTR(vidcpe, 0); 2359 UEA_ATTR(usrate, 0); 2360 UEA_ATTR(dsrate, 0); 2361 UEA_ATTR(usattenuation, 0); 2362 UEA_ATTR(dsattenuation, 0); 2363 UEA_ATTR(usmargin, 0); 2364 UEA_ATTR(dsmargin, 0); 2365 UEA_ATTR(txflow, 0); 2366 UEA_ATTR(rxflow, 0); 2367 UEA_ATTR(uscorr, 0); 2368 UEA_ATTR(dscorr, 0); 2369 UEA_ATTR(usunc, 0); 2370 UEA_ATTR(dsunc, 0); 2371 UEA_ATTR(firmid, 0); 2372 2373 /* Retrieve the device End System Identifier (MAC) */ 2374 2375 static int uea_getesi(struct uea_softc *sc, u_char *esi) 2376 { 2377 unsigned char mac_str[2 * ETH_ALEN + 1]; 2378 int i; 2379 if (usb_string 2380 (sc->usb_dev, sc->usb_dev->descriptor.iSerialNumber, mac_str, 2381 sizeof(mac_str)) != 2 * ETH_ALEN) 2382 return 1; 2383 2384 for (i = 0; i < ETH_ALEN; i++) 2385 esi[i] = hex_to_bin(mac_str[2 * i]) * 16 + 2386 hex_to_bin(mac_str[2 * i + 1]); 2387 2388 return 0; 2389 } 2390 2391 /* ATM stuff */ 2392 static int uea_atm_open(struct usbatm_data *usbatm, struct atm_dev *atm_dev) 2393 { 2394 struct uea_softc *sc = usbatm->driver_data; 2395 2396 return uea_getesi(sc, atm_dev->esi); 2397 } 2398 2399 static int uea_heavy(struct usbatm_data *usbatm, struct usb_interface *intf) 2400 { 2401 struct uea_softc *sc = usbatm->driver_data; 2402 2403 wait_event_interruptible(sc->sync_q, IS_OPERATIONAL(sc)); 2404 2405 return 0; 2406 2407 } 2408 2409 static int claim_interface(struct usb_device *usb_dev, 2410 struct usbatm_data *usbatm, int ifnum) 2411 { 2412 int ret; 2413 struct usb_interface *intf = usb_ifnum_to_if(usb_dev, ifnum); 2414 2415 if (!intf) { 2416 uea_err(usb_dev, "interface %d not found\n", ifnum); 2417 return -ENODEV; 2418 } 2419 2420 ret = usb_driver_claim_interface(&uea_driver, intf, usbatm); 2421 if (ret != 0) 2422 uea_err(usb_dev, "can't claim interface %d, error %d\n", ifnum, 2423 ret); 2424 return ret; 2425 } 2426 2427 static struct attribute *uea_attrs[] = { 2428 &dev_attr_stat_status.attr, 2429 &dev_attr_stat_mflags.attr, 2430 &dev_attr_stat_human_status.attr, 2431 &dev_attr_stat_delin.attr, 2432 &dev_attr_stat_vidcpe.attr, 2433 &dev_attr_stat_usrate.attr, 2434 &dev_attr_stat_dsrate.attr, 2435 &dev_attr_stat_usattenuation.attr, 2436 &dev_attr_stat_dsattenuation.attr, 2437 &dev_attr_stat_usmargin.attr, 2438 &dev_attr_stat_dsmargin.attr, 2439 &dev_attr_stat_txflow.attr, 2440 &dev_attr_stat_rxflow.attr, 2441 &dev_attr_stat_uscorr.attr, 2442 &dev_attr_stat_dscorr.attr, 2443 &dev_attr_stat_usunc.attr, 2444 &dev_attr_stat_dsunc.attr, 2445 &dev_attr_stat_firmid.attr, 2446 NULL, 2447 }; 2448 ATTRIBUTE_GROUPS(uea); 2449 2450 static int uea_bind(struct usbatm_data *usbatm, struct usb_interface *intf, 2451 const struct usb_device_id *id) 2452 { 2453 struct usb_device *usb = interface_to_usbdev(intf); 2454 struct uea_softc *sc; 2455 int ret, ifnum = intf->altsetting->desc.bInterfaceNumber; 2456 unsigned int alt; 2457 2458 /* interface 0 is for firmware/monitoring */ 2459 if (ifnum != UEA_INTR_IFACE_NO) 2460 return -ENODEV; 2461 2462 usbatm->flags = (sync_wait[modem_index] ? 0 : UDSL_SKIP_HEAVY_INIT); 2463 2464 /* interface 1 is for outbound traffic */ 2465 ret = claim_interface(usb, usbatm, UEA_US_IFACE_NO); 2466 if (ret < 0) 2467 return ret; 2468 2469 /* ADI930 has only 2 interfaces and inbound traffic is on interface 1 */ 2470 if (UEA_CHIP_VERSION(id) != ADI930) { 2471 /* interface 2 is for inbound traffic */ 2472 ret = claim_interface(usb, usbatm, UEA_DS_IFACE_NO); 2473 if (ret < 0) 2474 return ret; 2475 } 2476 2477 sc = kzalloc_obj(struct uea_softc); 2478 if (!sc) 2479 return -ENOMEM; 2480 2481 sc->usb_dev = usb; 2482 usbatm->driver_data = sc; 2483 sc->usbatm = usbatm; 2484 sc->modem_index = (modem_index < NB_MODEM) ? modem_index++ : 0; 2485 sc->driver_info = id->driver_info; 2486 2487 /* first try to use module parameter */ 2488 if (annex[sc->modem_index] == 1) 2489 sc->annex = ANNEXA; 2490 else if (annex[sc->modem_index] == 2) 2491 sc->annex = ANNEXB; 2492 /* try to autodetect annex */ 2493 else if (sc->driver_info & AUTO_ANNEX_A) 2494 sc->annex = ANNEXA; 2495 else if (sc->driver_info & AUTO_ANNEX_B) 2496 sc->annex = ANNEXB; 2497 else 2498 sc->annex = (le16_to_cpu 2499 (sc->usb_dev->descriptor.bcdDevice) & 0x80) ? ANNEXB : ANNEXA; 2500 2501 alt = altsetting[sc->modem_index]; 2502 /* ADI930 don't support iso */ 2503 if (UEA_CHIP_VERSION(id) != ADI930 && alt > 0) { 2504 if (alt <= 8 && 2505 usb_set_interface(usb, UEA_DS_IFACE_NO, alt) == 0) { 2506 uea_dbg(usb, "set alternate %u for 2 interface\n", alt); 2507 uea_info(usb, "using iso mode\n"); 2508 usbatm->flags |= UDSL_USE_ISOC | UDSL_IGNORE_EILSEQ; 2509 } else { 2510 uea_err(usb, "setting alternate %u failed for " 2511 "2 interface, using bulk mode\n", alt); 2512 } 2513 } 2514 2515 ret = uea_boot(sc, intf); 2516 if (ret < 0) 2517 goto error; 2518 2519 return 0; 2520 2521 error: 2522 kfree(sc); 2523 return ret; 2524 } 2525 2526 static void uea_unbind(struct usbatm_data *usbatm, struct usb_interface *intf) 2527 { 2528 struct uea_softc *sc = usbatm->driver_data; 2529 2530 uea_stop(sc); 2531 kfree(sc); 2532 } 2533 2534 static struct usbatm_driver uea_usbatm_driver = { 2535 .driver_name = "ueagle-atm", 2536 .bind = uea_bind, 2537 .atm_start = uea_atm_open, 2538 .unbind = uea_unbind, 2539 .heavy_init = uea_heavy, 2540 .bulk_in = UEA_BULK_DATA_PIPE, 2541 .bulk_out = UEA_BULK_DATA_PIPE, 2542 .isoc_in = UEA_ISO_DATA_PIPE, 2543 }; 2544 2545 static int uea_probe(struct usb_interface *intf, const struct usb_device_id *id) 2546 { 2547 struct usb_device *usb = interface_to_usbdev(intf); 2548 int ret; 2549 2550 uea_dbg(usb, "ADSL device found with vid (%#X) pid (%#X) Rev (%#X): %s\n", 2551 le16_to_cpu(usb->descriptor.idVendor), 2552 le16_to_cpu(usb->descriptor.idProduct), 2553 le16_to_cpu(usb->descriptor.bcdDevice), 2554 chip_name[UEA_CHIP_VERSION(id)]); 2555 2556 usb_reset_device(usb); 2557 2558 if (UEA_IS_PREFIRM(id)) 2559 return uea_load_firmware(usb, UEA_CHIP_VERSION(id)); 2560 2561 ret = usbatm_usb_probe(intf, id, &uea_usbatm_driver); 2562 if (ret == 0) { 2563 struct usbatm_data *usbatm = usb_get_intfdata(intf); 2564 struct uea_softc *sc = usbatm->driver_data; 2565 2566 /* Ensure carrier is initialized to off as early as possible */ 2567 UPDATE_ATM_SIGNAL(ATM_PHY_SIG_LOST); 2568 2569 /* Only start the worker thread when all init is done */ 2570 wake_up_process(sc->kthread); 2571 } 2572 2573 return ret; 2574 } 2575 2576 static void uea_disconnect(struct usb_interface *intf) 2577 { 2578 struct usb_device *usb = interface_to_usbdev(intf); 2579 int ifnum = intf->altsetting->desc.bInterfaceNumber; 2580 2581 /* ADI930 has 2 interfaces and eagle 3 interfaces. 2582 * Pre-firmware device has one interface 2583 */ 2584 if (usb->config->desc.bNumInterfaces != 1 && ifnum == 0) { 2585 mutex_lock(&uea_mutex); 2586 usbatm_usb_disconnect(intf); 2587 mutex_unlock(&uea_mutex); 2588 uea_info(usb, "ADSL device removed\n"); 2589 } 2590 } 2591 2592 /* 2593 * List of supported VID/PID 2594 */ 2595 static const struct usb_device_id uea_ids[] = { 2596 {USB_DEVICE(ANALOG_VID, ADI930_PID_PREFIRM), 2597 .driver_info = ADI930 | PREFIRM}, 2598 {USB_DEVICE(ANALOG_VID, ADI930_PID_PSTFIRM), 2599 .driver_info = ADI930 | PSTFIRM}, 2600 {USB_DEVICE(ANALOG_VID, EAGLE_I_PID_PREFIRM), 2601 .driver_info = EAGLE_I | PREFIRM}, 2602 {USB_DEVICE(ANALOG_VID, EAGLE_I_PID_PSTFIRM), 2603 .driver_info = EAGLE_I | PSTFIRM}, 2604 {USB_DEVICE(ANALOG_VID, EAGLE_II_PID_PREFIRM), 2605 .driver_info = EAGLE_II | PREFIRM}, 2606 {USB_DEVICE(ANALOG_VID, EAGLE_II_PID_PSTFIRM), 2607 .driver_info = EAGLE_II | PSTFIRM}, 2608 {USB_DEVICE(ANALOG_VID, EAGLE_IIC_PID_PREFIRM), 2609 .driver_info = EAGLE_II | PREFIRM}, 2610 {USB_DEVICE(ANALOG_VID, EAGLE_IIC_PID_PSTFIRM), 2611 .driver_info = EAGLE_II | PSTFIRM}, 2612 {USB_DEVICE(ANALOG_VID, EAGLE_III_PID_PREFIRM), 2613 .driver_info = EAGLE_III | PREFIRM}, 2614 {USB_DEVICE(ANALOG_VID, EAGLE_III_PID_PSTFIRM), 2615 .driver_info = EAGLE_III | PSTFIRM}, 2616 {USB_DEVICE(ANALOG_VID, EAGLE_IV_PID_PREFIRM), 2617 .driver_info = EAGLE_IV | PREFIRM}, 2618 {USB_DEVICE(ANALOG_VID, EAGLE_IV_PID_PSTFIRM), 2619 .driver_info = EAGLE_IV | PSTFIRM}, 2620 {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_A_PID_PREFIRM), 2621 .driver_info = EAGLE_I | PREFIRM}, 2622 {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_A_PID_PSTFIRM), 2623 .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_A}, 2624 {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_B_PID_PREFIRM), 2625 .driver_info = EAGLE_I | PREFIRM}, 2626 {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_I_B_PID_PSTFIRM), 2627 .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_B}, 2628 {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_A_PID_PREFIRM), 2629 .driver_info = EAGLE_II | PREFIRM}, 2630 {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_A_PID_PSTFIRM), 2631 .driver_info = EAGLE_II | PSTFIRM | AUTO_ANNEX_A}, 2632 {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_B_PID_PREFIRM), 2633 .driver_info = EAGLE_II | PREFIRM}, 2634 {USB_DEVICE(DEVOLO_VID, DEVOLO_EAGLE_II_B_PID_PSTFIRM), 2635 .driver_info = EAGLE_II | PSTFIRM | AUTO_ANNEX_B}, 2636 {USB_DEVICE(ELSA_VID, ELSA_PID_PREFIRM), 2637 .driver_info = ADI930 | PREFIRM}, 2638 {USB_DEVICE(ELSA_VID, ELSA_PID_PSTFIRM), 2639 .driver_info = ADI930 | PSTFIRM}, 2640 {USB_DEVICE(ELSA_VID, ELSA_PID_A_PREFIRM), 2641 .driver_info = ADI930 | PREFIRM}, 2642 {USB_DEVICE(ELSA_VID, ELSA_PID_A_PSTFIRM), 2643 .driver_info = ADI930 | PSTFIRM | AUTO_ANNEX_A}, 2644 {USB_DEVICE(ELSA_VID, ELSA_PID_B_PREFIRM), 2645 .driver_info = ADI930 | PREFIRM}, 2646 {USB_DEVICE(ELSA_VID, ELSA_PID_B_PSTFIRM), 2647 .driver_info = ADI930 | PSTFIRM | AUTO_ANNEX_B}, 2648 {USB_DEVICE(USR_VID, MILLER_A_PID_PREFIRM), 2649 .driver_info = EAGLE_I | PREFIRM}, 2650 {USB_DEVICE(USR_VID, MILLER_A_PID_PSTFIRM), 2651 .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_A}, 2652 {USB_DEVICE(USR_VID, MILLER_B_PID_PREFIRM), 2653 .driver_info = EAGLE_I | PREFIRM}, 2654 {USB_DEVICE(USR_VID, MILLER_B_PID_PSTFIRM), 2655 .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_B}, 2656 {USB_DEVICE(USR_VID, HEINEKEN_A_PID_PREFIRM), 2657 .driver_info = EAGLE_I | PREFIRM}, 2658 {USB_DEVICE(USR_VID, HEINEKEN_A_PID_PSTFIRM), 2659 .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_A}, 2660 {USB_DEVICE(USR_VID, HEINEKEN_B_PID_PREFIRM), 2661 .driver_info = EAGLE_I | PREFIRM}, 2662 {USB_DEVICE(USR_VID, HEINEKEN_B_PID_PSTFIRM), 2663 .driver_info = EAGLE_I | PSTFIRM | AUTO_ANNEX_B}, 2664 {} 2665 }; 2666 2667 /* 2668 * USB driver descriptor 2669 */ 2670 static struct usb_driver uea_driver = { 2671 .name = "ueagle-atm", 2672 .id_table = uea_ids, 2673 .probe = uea_probe, 2674 .disconnect = uea_disconnect, 2675 .dev_groups = uea_groups, 2676 }; 2677 2678 MODULE_DEVICE_TABLE(usb, uea_ids); 2679 2680 module_usb_driver(uea_driver); 2681 2682 MODULE_AUTHOR("Damien Bergamini/Matthieu Castet/Stanislaw W. Gruszka"); 2683 MODULE_DESCRIPTION("ADI 930/Eagle USB ADSL Modem driver"); 2684 MODULE_LICENSE("Dual BSD/GPL"); 2685 MODULE_FIRMWARE(EAGLE_FIRMWARE); 2686 MODULE_FIRMWARE(ADI930_FIRMWARE); 2687 MODULE_FIRMWARE(EAGLE_I_FIRMWARE); 2688 MODULE_FIRMWARE(EAGLE_II_FIRMWARE); 2689 MODULE_FIRMWARE(EAGLE_III_FIRMWARE); 2690 MODULE_FIRMWARE(EAGLE_IV_FIRMWARE); 2691 MODULE_FIRMWARE(DSP4I_FIRMWARE); 2692 MODULE_FIRMWARE(DSP4P_FIRMWARE); 2693 MODULE_FIRMWARE(DSP9I_FIRMWARE); 2694 MODULE_FIRMWARE(DSP9P_FIRMWARE); 2695 MODULE_FIRMWARE(DSPEI_FIRMWARE); 2696 MODULE_FIRMWARE(DSPEP_FIRMWARE); 2697 MODULE_FIRMWARE(FPGA930_FIRMWARE); 2698 MODULE_FIRMWARE(CMV4P_FIRMWARE); 2699 MODULE_FIRMWARE(CMV4PV2_FIRMWARE); 2700 MODULE_FIRMWARE(CMV4I_FIRMWARE); 2701 MODULE_FIRMWARE(CMV4IV2_FIRMWARE); 2702 MODULE_FIRMWARE(CMV9P_FIRMWARE); 2703 MODULE_FIRMWARE(CMV9PV2_FIRMWARE); 2704 MODULE_FIRMWARE(CMV9I_FIRMWARE); 2705 MODULE_FIRMWARE(CMV9IV2_FIRMWARE); 2706 MODULE_FIRMWARE(CMVEP_FIRMWARE); 2707 MODULE_FIRMWARE(CMVEPV2_FIRMWARE); 2708 MODULE_FIRMWARE(CMVEI_FIRMWARE); 2709 MODULE_FIRMWARE(CMVEIV2_FIRMWARE); 2710