cxacru.c 39 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381
  1. /******************************************************************************
  2. * cxacru.c - driver for USB ADSL modems based on
  3. * Conexant AccessRunner chipset
  4. *
  5. * Copyright (C) 2004 David Woodhouse, Duncan Sands, Roman Kagan
  6. * Copyright (C) 2005 Duncan Sands, Roman Kagan (rkagan % mail ! ru)
  7. * Copyright (C) 2007 Simon Arlott
  8. * Copyright (C) 2009 Simon Arlott
  9. *
  10. * This program is free software; you can redistribute it and/or modify it
  11. * under the terms of the GNU General Public License as published by the Free
  12. * Software Foundation; either version 2 of the License, or (at your option)
  13. * any later version.
  14. *
  15. * This program is distributed in the hope that it will be useful, but WITHOUT
  16. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  18. * more details.
  19. *
  20. * You should have received a copy of the GNU General Public License along with
  21. * this program; if not, write to the Free Software Foundation, Inc., 59
  22. * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. *
  24. ******************************************************************************/
  25. /*
  26. * Credit is due for Josep Comas, who created the original patch to speedtch.c
  27. * to support the different padding used by the AccessRunner (now generalized
  28. * into usbatm), and the userspace firmware loading utility.
  29. */
  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>
  38. #include <linux/firmware.h>
  39. #include <linux/mutex.h>
  40. #include <asm/unaligned.h>
  41. #include "usbatm.h"
  42. #define DRIVER_AUTHOR "Roman Kagan, David Woodhouse, Duncan Sands, Simon Arlott"
  43. #define DRIVER_VERSION "0.4"
  44. #define DRIVER_DESC "Conexant AccessRunner ADSL USB modem driver"
  45. static const char cxacru_driver_name[] = "cxacru";
  46. #define CXACRU_EP_CMD 0x01 /* Bulk/interrupt in/out */
  47. #define CXACRU_EP_DATA 0x02 /* Bulk in/out */
  48. #define CMD_PACKET_SIZE 64 /* Should be maxpacket(ep)? */
  49. #define CMD_MAX_CONFIG ((CMD_PACKET_SIZE / 4 - 1) / 2)
  50. /* Addresses */
  51. #define PLLFCLK_ADDR 0x00350068
  52. #define PLLBCLK_ADDR 0x0035006c
  53. #define SDRAMEN_ADDR 0x00350010
  54. #define FW_ADDR 0x00801000
  55. #define BR_ADDR 0x00180600
  56. #define SIG_ADDR 0x00180500
  57. #define BR_STACK_ADDR 0x00187f10
  58. /* Values */
  59. #define SDRAM_ENA 0x1
  60. #define CMD_TIMEOUT 2000 /* msecs */
  61. #define POLL_INTERVAL 1 /* secs */
  62. /* commands for interaction with the modem through the control channel before
  63. * firmware is loaded */
  64. enum cxacru_fw_request {
  65. FW_CMD_ERR,
  66. FW_GET_VER,
  67. FW_READ_MEM,
  68. FW_WRITE_MEM,
  69. FW_RMW_MEM,
  70. FW_CHECKSUM_MEM,
  71. FW_GOTO_MEM,
  72. };
  73. /* commands for interaction with the modem through the control channel once
  74. * firmware is loaded */
  75. enum cxacru_cm_request {
  76. CM_REQUEST_UNDEFINED = 0x80,
  77. CM_REQUEST_TEST,
  78. CM_REQUEST_CHIP_GET_MAC_ADDRESS,
  79. CM_REQUEST_CHIP_GET_DP_VERSIONS,
  80. CM_REQUEST_CHIP_ADSL_LINE_START,
  81. CM_REQUEST_CHIP_ADSL_LINE_STOP,
  82. CM_REQUEST_CHIP_ADSL_LINE_GET_STATUS,
  83. CM_REQUEST_CHIP_ADSL_LINE_GET_SPEED,
  84. CM_REQUEST_CARD_INFO_GET,
  85. CM_REQUEST_CARD_DATA_GET,
  86. CM_REQUEST_CARD_DATA_SET,
  87. CM_REQUEST_COMMAND_HW_IO,
  88. CM_REQUEST_INTERFACE_HW_IO,
  89. CM_REQUEST_CARD_SERIAL_DATA_PATH_GET,
  90. CM_REQUEST_CARD_SERIAL_DATA_PATH_SET,
  91. CM_REQUEST_CARD_CONTROLLER_VERSION_GET,
  92. CM_REQUEST_CARD_GET_STATUS,
  93. CM_REQUEST_CARD_GET_MAC_ADDRESS,
  94. CM_REQUEST_CARD_GET_DATA_LINK_STATUS,
  95. CM_REQUEST_MAX,
  96. };
  97. /* commands for interaction with the flash memory
  98. *
  99. * read: response is the contents of the first 60 bytes of flash memory
  100. * write: request contains the 60 bytes of data to write to flash memory
  101. * response is the contents of the first 60 bytes of flash memory
  102. *
  103. * layout: PP PP VV VV MM MM MM MM MM MM ?? ?? SS SS SS SS SS SS SS SS
  104. * SS SS SS SS SS SS SS SS 00 00 00 00 00 00 00 00 00 00 00 00
  105. * 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  106. *
  107. * P: le16 USB Product ID
  108. * V: le16 USB Vendor ID
  109. * M: be48 MAC Address
  110. * S: le16 ASCII Serial Number
  111. */
  112. enum cxacru_cm_flash {
  113. CM_FLASH_READ = 0xa1,
  114. CM_FLASH_WRITE = 0xa2
  115. };
  116. /* reply codes to the commands above */
  117. enum cxacru_cm_status {
  118. CM_STATUS_UNDEFINED,
  119. CM_STATUS_SUCCESS,
  120. CM_STATUS_ERROR,
  121. CM_STATUS_UNSUPPORTED,
  122. CM_STATUS_UNIMPLEMENTED,
  123. CM_STATUS_PARAMETER_ERROR,
  124. CM_STATUS_DBG_LOOPBACK,
  125. CM_STATUS_MAX,
  126. };
  127. /* indices into CARD_INFO_GET return array */
  128. enum cxacru_info_idx {
  129. CXINF_DOWNSTREAM_RATE,
  130. CXINF_UPSTREAM_RATE,
  131. CXINF_LINK_STATUS,
  132. CXINF_LINE_STATUS,
  133. CXINF_MAC_ADDRESS_HIGH,
  134. CXINF_MAC_ADDRESS_LOW,
  135. CXINF_UPSTREAM_SNR_MARGIN,
  136. CXINF_DOWNSTREAM_SNR_MARGIN,
  137. CXINF_UPSTREAM_ATTENUATION,
  138. CXINF_DOWNSTREAM_ATTENUATION,
  139. CXINF_TRANSMITTER_POWER,
  140. CXINF_UPSTREAM_BITS_PER_FRAME,
  141. CXINF_DOWNSTREAM_BITS_PER_FRAME,
  142. CXINF_STARTUP_ATTEMPTS,
  143. CXINF_UPSTREAM_CRC_ERRORS,
  144. CXINF_DOWNSTREAM_CRC_ERRORS,
  145. CXINF_UPSTREAM_FEC_ERRORS,
  146. CXINF_DOWNSTREAM_FEC_ERRORS,
  147. CXINF_UPSTREAM_HEC_ERRORS,
  148. CXINF_DOWNSTREAM_HEC_ERRORS,
  149. CXINF_LINE_STARTABLE,
  150. CXINF_MODULATION,
  151. CXINF_ADSL_HEADEND,
  152. CXINF_ADSL_HEADEND_ENVIRONMENT,
  153. CXINF_CONTROLLER_VERSION,
  154. /* dunno what the missing two mean */
  155. CXINF_MAX = 0x1c,
  156. };
  157. enum cxacru_poll_state {
  158. CXPOLL_STOPPING,
  159. CXPOLL_STOPPED,
  160. CXPOLL_POLLING,
  161. CXPOLL_SHUTDOWN
  162. };
  163. struct cxacru_modem_type {
  164. u32 pll_f_clk;
  165. u32 pll_b_clk;
  166. int boot_rom_patch;
  167. };
  168. struct cxacru_data {
  169. struct usbatm_data *usbatm;
  170. const struct cxacru_modem_type *modem_type;
  171. int line_status;
  172. struct mutex adsl_state_serialize;
  173. int adsl_status;
  174. struct delayed_work poll_work;
  175. u32 card_info[CXINF_MAX];
  176. struct mutex poll_state_serialize;
  177. enum cxacru_poll_state poll_state;
  178. /* contol handles */
  179. struct mutex cm_serialize;
  180. u8 *rcv_buf;
  181. u8 *snd_buf;
  182. struct urb *rcv_urb;
  183. struct urb *snd_urb;
  184. struct completion rcv_done;
  185. struct completion snd_done;
  186. };
  187. static int cxacru_cm(struct cxacru_data *instance, enum cxacru_cm_request cm,
  188. u8 *wdata, int wsize, u8 *rdata, int rsize);
  189. static void cxacru_poll_status(struct work_struct *work);
  190. /* Card info exported through sysfs */
  191. #define CXACRU__ATTR_INIT(_name) \
  192. static DEVICE_ATTR(_name, S_IRUGO, cxacru_sysfs_show_##_name, NULL)
  193. #define CXACRU_CMD_INIT(_name) \
  194. static DEVICE_ATTR(_name, S_IWUSR | S_IRUGO, \
  195. cxacru_sysfs_show_##_name, cxacru_sysfs_store_##_name)
  196. #define CXACRU_SET_INIT(_name) \
  197. static DEVICE_ATTR(_name, S_IWUSR, \
  198. NULL, cxacru_sysfs_store_##_name)
  199. #define CXACRU_ATTR_INIT(_value, _type, _name) \
  200. static ssize_t cxacru_sysfs_show_##_name(struct device *dev, \
  201. struct device_attribute *attr, char *buf) \
  202. { \
  203. struct cxacru_data *instance = to_usbatm_driver_data(\
  204. to_usb_interface(dev)); \
  205. \
  206. if (instance == NULL) \
  207. return -ENODEV; \
  208. \
  209. return cxacru_sysfs_showattr_##_type(instance->card_info[_value], buf); \
  210. } \
  211. CXACRU__ATTR_INIT(_name)
  212. #define CXACRU_ATTR_CREATE(_v, _t, _name) CXACRU_DEVICE_CREATE_FILE(_name)
  213. #define CXACRU_CMD_CREATE(_name) CXACRU_DEVICE_CREATE_FILE(_name)
  214. #define CXACRU_SET_CREATE(_name) CXACRU_DEVICE_CREATE_FILE(_name)
  215. #define CXACRU__ATTR_CREATE(_name) CXACRU_DEVICE_CREATE_FILE(_name)
  216. #define CXACRU_ATTR_REMOVE(_v, _t, _name) CXACRU_DEVICE_REMOVE_FILE(_name)
  217. #define CXACRU_CMD_REMOVE(_name) CXACRU_DEVICE_REMOVE_FILE(_name)
  218. #define CXACRU_SET_REMOVE(_name) CXACRU_DEVICE_REMOVE_FILE(_name)
  219. #define CXACRU__ATTR_REMOVE(_name) CXACRU_DEVICE_REMOVE_FILE(_name)
  220. static ssize_t cxacru_sysfs_showattr_u32(u32 value, char *buf)
  221. {
  222. return snprintf(buf, PAGE_SIZE, "%u\n", value);
  223. }
  224. static ssize_t cxacru_sysfs_showattr_s8(s8 value, char *buf)
  225. {
  226. return snprintf(buf, PAGE_SIZE, "%d\n", value);
  227. }
  228. static ssize_t cxacru_sysfs_showattr_dB(s16 value, char *buf)
  229. {
  230. if (likely(value >= 0)) {
  231. return snprintf(buf, PAGE_SIZE, "%u.%02u\n",
  232. value / 100, value % 100);
  233. } else {
  234. value = -value;
  235. return snprintf(buf, PAGE_SIZE, "-%u.%02u\n",
  236. value / 100, value % 100);
  237. }
  238. }
  239. static ssize_t cxacru_sysfs_showattr_bool(u32 value, char *buf)
  240. {
  241. static char *str[] = { "no", "yes" };
  242. if (unlikely(value >= ARRAY_SIZE(str)))
  243. return snprintf(buf, PAGE_SIZE, "%u\n", value);
  244. return snprintf(buf, PAGE_SIZE, "%s\n", str[value]);
  245. }
  246. static ssize_t cxacru_sysfs_showattr_LINK(u32 value, char *buf)
  247. {
  248. static char *str[] = { NULL, "not connected", "connected", "lost" };
  249. if (unlikely(value >= ARRAY_SIZE(str) || str[value] == NULL))
  250. return snprintf(buf, PAGE_SIZE, "%u\n", value);
  251. return snprintf(buf, PAGE_SIZE, "%s\n", str[value]);
  252. }
  253. static ssize_t cxacru_sysfs_showattr_LINE(u32 value, char *buf)
  254. {
  255. static char *str[] = { "down", "attempting to activate",
  256. "training", "channel analysis", "exchange", "up",
  257. "waiting", "initialising"
  258. };
  259. if (unlikely(value >= ARRAY_SIZE(str)))
  260. return snprintf(buf, PAGE_SIZE, "%u\n", value);
  261. return snprintf(buf, PAGE_SIZE, "%s\n", str[value]);
  262. }
  263. static ssize_t cxacru_sysfs_showattr_MODU(u32 value, char *buf)
  264. {
  265. static char *str[] = {
  266. "",
  267. "ANSI T1.413",
  268. "ITU-T G.992.1 (G.DMT)",
  269. "ITU-T G.992.2 (G.LITE)"
  270. };
  271. if (unlikely(value >= ARRAY_SIZE(str)))
  272. return snprintf(buf, PAGE_SIZE, "%u\n", value);
  273. return snprintf(buf, PAGE_SIZE, "%s\n", str[value]);
  274. }
  275. /*
  276. * This could use MAC_ADDRESS_HIGH and MAC_ADDRESS_LOW, but since
  277. * this data is already in atm_dev there's no point.
  278. *
  279. * MAC_ADDRESS_HIGH = 0x????5544
  280. * MAC_ADDRESS_LOW = 0x33221100
  281. * Where 00-55 are bytes 0-5 of the MAC.
  282. */
  283. static ssize_t cxacru_sysfs_show_mac_address(struct device *dev,
  284. struct device_attribute *attr, char *buf)
  285. {
  286. struct cxacru_data *instance = to_usbatm_driver_data(
  287. to_usb_interface(dev));
  288. if (instance == NULL || instance->usbatm->atm_dev == NULL)
  289. return -ENODEV;
  290. return snprintf(buf, PAGE_SIZE, "%pM\n",
  291. instance->usbatm->atm_dev->esi);
  292. }
  293. static ssize_t cxacru_sysfs_show_adsl_state(struct device *dev,
  294. struct device_attribute *attr, char *buf)
  295. {
  296. static char *str[] = { "running", "stopped" };
  297. struct cxacru_data *instance = to_usbatm_driver_data(
  298. to_usb_interface(dev));
  299. u32 value;
  300. if (instance == NULL)
  301. return -ENODEV;
  302. value = instance->card_info[CXINF_LINE_STARTABLE];
  303. if (unlikely(value >= ARRAY_SIZE(str)))
  304. return snprintf(buf, PAGE_SIZE, "%u\n", value);
  305. return snprintf(buf, PAGE_SIZE, "%s\n", str[value]);
  306. }
  307. static ssize_t cxacru_sysfs_store_adsl_state(struct device *dev,
  308. struct device_attribute *attr, const char *buf, size_t count)
  309. {
  310. struct cxacru_data *instance = to_usbatm_driver_data(
  311. to_usb_interface(dev));
  312. int ret;
  313. int poll = -1;
  314. char str_cmd[8];
  315. int len = strlen(buf);
  316. if (!capable(CAP_NET_ADMIN))
  317. return -EACCES;
  318. ret = sscanf(buf, "%7s", str_cmd);
  319. if (ret != 1)
  320. return -EINVAL;
  321. ret = 0;
  322. if (instance == NULL)
  323. return -ENODEV;
  324. if (mutex_lock_interruptible(&instance->adsl_state_serialize))
  325. return -ERESTARTSYS;
  326. if (!strcmp(str_cmd, "stop") || !strcmp(str_cmd, "restart")) {
  327. ret = cxacru_cm(instance, CM_REQUEST_CHIP_ADSL_LINE_STOP, NULL, 0, NULL, 0);
  328. if (ret < 0) {
  329. atm_err(instance->usbatm, "change adsl state:"
  330. " CHIP_ADSL_LINE_STOP returned %d\n", ret);
  331. ret = -EIO;
  332. } else {
  333. ret = len;
  334. poll = CXPOLL_STOPPED;
  335. }
  336. }
  337. /* Line status is only updated every second
  338. * and the device appears to only react to
  339. * START/STOP every second too. Wait 1.5s to
  340. * be sure that restart will have an effect. */
  341. if (!strcmp(str_cmd, "restart"))
  342. msleep(1500);
  343. if (!strcmp(str_cmd, "start") || !strcmp(str_cmd, "restart")) {
  344. ret = cxacru_cm(instance, CM_REQUEST_CHIP_ADSL_LINE_START, NULL, 0, NULL, 0);
  345. if (ret < 0) {
  346. atm_err(instance->usbatm, "change adsl state:"
  347. " CHIP_ADSL_LINE_START returned %d\n", ret);
  348. ret = -EIO;
  349. } else {
  350. ret = len;
  351. poll = CXPOLL_POLLING;
  352. }
  353. }
  354. if (!strcmp(str_cmd, "poll")) {
  355. ret = len;
  356. poll = CXPOLL_POLLING;
  357. }
  358. if (ret == 0) {
  359. ret = -EINVAL;
  360. poll = -1;
  361. }
  362. if (poll == CXPOLL_POLLING) {
  363. mutex_lock(&instance->poll_state_serialize);
  364. switch (instance->poll_state) {
  365. case CXPOLL_STOPPED:
  366. /* start polling */
  367. instance->poll_state = CXPOLL_POLLING;
  368. break;
  369. case CXPOLL_STOPPING:
  370. /* abort stop request */
  371. instance->poll_state = CXPOLL_POLLING;
  372. case CXPOLL_POLLING:
  373. case CXPOLL_SHUTDOWN:
  374. /* don't start polling */
  375. poll = -1;
  376. }
  377. mutex_unlock(&instance->poll_state_serialize);
  378. } else if (poll == CXPOLL_STOPPED) {
  379. mutex_lock(&instance->poll_state_serialize);
  380. /* request stop */
  381. if (instance->poll_state == CXPOLL_POLLING)
  382. instance->poll_state = CXPOLL_STOPPING;
  383. mutex_unlock(&instance->poll_state_serialize);
  384. }
  385. mutex_unlock(&instance->adsl_state_serialize);
  386. if (poll == CXPOLL_POLLING)
  387. cxacru_poll_status(&instance->poll_work.work);
  388. return ret;
  389. }
  390. /* CM_REQUEST_CARD_DATA_GET times out, so no show attribute */
  391. static ssize_t cxacru_sysfs_store_adsl_config(struct device *dev,
  392. struct device_attribute *attr, const char *buf, size_t count)
  393. {
  394. struct cxacru_data *instance = to_usbatm_driver_data(
  395. to_usb_interface(dev));
  396. int len = strlen(buf);
  397. int ret, pos, num;
  398. __le32 data[CMD_PACKET_SIZE / 4];
  399. if (!capable(CAP_NET_ADMIN))
  400. return -EACCES;
  401. if (instance == NULL)
  402. return -ENODEV;
  403. pos = 0;
  404. num = 0;
  405. while (pos < len) {
  406. int tmp;
  407. u32 index;
  408. u32 value;
  409. ret = sscanf(buf + pos, "%x=%x%n", &index, &value, &tmp);
  410. if (ret < 2)
  411. return -EINVAL;
  412. if (index < 0 || index > 0x7f)
  413. return -EINVAL;
  414. pos += tmp;
  415. /* skip trailing newline */
  416. if (buf[pos] == '\n' && pos == len-1)
  417. pos++;
  418. data[num * 2 + 1] = cpu_to_le32(index);
  419. data[num * 2 + 2] = cpu_to_le32(value);
  420. num++;
  421. /* send config values when data buffer is full
  422. * or no more data
  423. */
  424. if (pos >= len || num >= CMD_MAX_CONFIG) {
  425. char log[CMD_MAX_CONFIG * 12 + 1]; /* %02x=%08x */
  426. data[0] = cpu_to_le32(num);
  427. ret = cxacru_cm(instance, CM_REQUEST_CARD_DATA_SET,
  428. (u8 *) data, 4 + num * 8, NULL, 0);
  429. if (ret < 0) {
  430. atm_err(instance->usbatm,
  431. "set card data returned %d\n", ret);
  432. return -EIO;
  433. }
  434. for (tmp = 0; tmp < num; tmp++)
  435. snprintf(log + tmp*12, 13, " %02x=%08x",
  436. le32_to_cpu(data[tmp * 2 + 1]),
  437. le32_to_cpu(data[tmp * 2 + 2]));
  438. atm_info(instance->usbatm, "config%s\n", log);
  439. num = 0;
  440. }
  441. }
  442. return len;
  443. }
  444. /*
  445. * All device attributes are included in CXACRU_ALL_FILES
  446. * so that the same list can be used multiple times:
  447. * INIT (define the device attributes)
  448. * CREATE (create all the device files)
  449. * REMOVE (remove all the device files)
  450. *
  451. * With the last two being defined as needed in the functions
  452. * they are used in before calling CXACRU_ALL_FILES()
  453. */
  454. #define CXACRU_ALL_FILES(_action) \
  455. CXACRU_ATTR_##_action(CXINF_DOWNSTREAM_RATE, u32, downstream_rate); \
  456. CXACRU_ATTR_##_action(CXINF_UPSTREAM_RATE, u32, upstream_rate); \
  457. CXACRU_ATTR_##_action(CXINF_LINK_STATUS, LINK, link_status); \
  458. CXACRU_ATTR_##_action(CXINF_LINE_STATUS, LINE, line_status); \
  459. CXACRU__ATTR_##_action( mac_address); \
  460. CXACRU_ATTR_##_action(CXINF_UPSTREAM_SNR_MARGIN, dB, upstream_snr_margin); \
  461. CXACRU_ATTR_##_action(CXINF_DOWNSTREAM_SNR_MARGIN, dB, downstream_snr_margin); \
  462. CXACRU_ATTR_##_action(CXINF_UPSTREAM_ATTENUATION, dB, upstream_attenuation); \
  463. CXACRU_ATTR_##_action(CXINF_DOWNSTREAM_ATTENUATION, dB, downstream_attenuation); \
  464. CXACRU_ATTR_##_action(CXINF_TRANSMITTER_POWER, s8, transmitter_power); \
  465. CXACRU_ATTR_##_action(CXINF_UPSTREAM_BITS_PER_FRAME, u32, upstream_bits_per_frame); \
  466. CXACRU_ATTR_##_action(CXINF_DOWNSTREAM_BITS_PER_FRAME, u32, downstream_bits_per_frame); \
  467. CXACRU_ATTR_##_action(CXINF_STARTUP_ATTEMPTS, u32, startup_attempts); \
  468. CXACRU_ATTR_##_action(CXINF_UPSTREAM_CRC_ERRORS, u32, upstream_crc_errors); \
  469. CXACRU_ATTR_##_action(CXINF_DOWNSTREAM_CRC_ERRORS, u32, downstream_crc_errors); \
  470. CXACRU_ATTR_##_action(CXINF_UPSTREAM_FEC_ERRORS, u32, upstream_fec_errors); \
  471. CXACRU_ATTR_##_action(CXINF_DOWNSTREAM_FEC_ERRORS, u32, downstream_fec_errors); \
  472. CXACRU_ATTR_##_action(CXINF_UPSTREAM_HEC_ERRORS, u32, upstream_hec_errors); \
  473. CXACRU_ATTR_##_action(CXINF_DOWNSTREAM_HEC_ERRORS, u32, downstream_hec_errors); \
  474. CXACRU_ATTR_##_action(CXINF_LINE_STARTABLE, bool, line_startable); \
  475. CXACRU_ATTR_##_action(CXINF_MODULATION, MODU, modulation); \
  476. CXACRU_ATTR_##_action(CXINF_ADSL_HEADEND, u32, adsl_headend); \
  477. CXACRU_ATTR_##_action(CXINF_ADSL_HEADEND_ENVIRONMENT, u32, adsl_headend_environment); \
  478. CXACRU_ATTR_##_action(CXINF_CONTROLLER_VERSION, u32, adsl_controller_version); \
  479. CXACRU_CMD_##_action( adsl_state); \
  480. CXACRU_SET_##_action( adsl_config);
  481. CXACRU_ALL_FILES(INIT);
  482. /* the following three functions are stolen from drivers/usb/core/message.c */
  483. static void cxacru_blocking_completion(struct urb *urb)
  484. {
  485. complete(urb->context);
  486. }
  487. static void cxacru_timeout_kill(unsigned long data)
  488. {
  489. usb_unlink_urb((struct urb *) data);
  490. }
  491. static int cxacru_start_wait_urb(struct urb *urb, struct completion *done,
  492. int *actual_length)
  493. {
  494. struct timer_list timer;
  495. init_timer(&timer);
  496. timer.expires = jiffies + msecs_to_jiffies(CMD_TIMEOUT);
  497. timer.data = (unsigned long) urb;
  498. timer.function = cxacru_timeout_kill;
  499. add_timer(&timer);
  500. wait_for_completion(done);
  501. del_timer_sync(&timer);
  502. if (actual_length)
  503. *actual_length = urb->actual_length;
  504. return urb->status; /* must read status after completion */
  505. }
  506. static int cxacru_cm(struct cxacru_data *instance, enum cxacru_cm_request cm,
  507. u8 *wdata, int wsize, u8 *rdata, int rsize)
  508. {
  509. int ret, actlen;
  510. int offb, offd;
  511. const int stride = CMD_PACKET_SIZE - 4;
  512. u8 *wbuf = instance->snd_buf;
  513. u8 *rbuf = instance->rcv_buf;
  514. int wbuflen = ((wsize - 1) / stride + 1) * CMD_PACKET_SIZE;
  515. int rbuflen = ((rsize - 1) / stride + 1) * CMD_PACKET_SIZE;
  516. if (wbuflen > PAGE_SIZE || rbuflen > PAGE_SIZE) {
  517. if (printk_ratelimit())
  518. usb_err(instance->usbatm, "requested transfer size too large (%d, %d)\n",
  519. wbuflen, rbuflen);
  520. ret = -ENOMEM;
  521. goto err;
  522. }
  523. mutex_lock(&instance->cm_serialize);
  524. /* submit reading urb before the writing one */
  525. init_completion(&instance->rcv_done);
  526. ret = usb_submit_urb(instance->rcv_urb, GFP_KERNEL);
  527. if (ret < 0) {
  528. if (printk_ratelimit())
  529. usb_err(instance->usbatm, "submit of read urb for cm %#x failed (%d)\n",
  530. cm, ret);
  531. goto fail;
  532. }
  533. memset(wbuf, 0, wbuflen);
  534. /* handle wsize == 0 */
  535. wbuf[0] = cm;
  536. for (offb = offd = 0; offd < wsize; offd += stride, offb += CMD_PACKET_SIZE) {
  537. wbuf[offb] = cm;
  538. memcpy(wbuf + offb + 4, wdata + offd, min_t(int, stride, wsize - offd));
  539. }
  540. instance->snd_urb->transfer_buffer_length = wbuflen;
  541. init_completion(&instance->snd_done);
  542. ret = usb_submit_urb(instance->snd_urb, GFP_KERNEL);
  543. if (ret < 0) {
  544. if (printk_ratelimit())
  545. usb_err(instance->usbatm, "submit of write urb for cm %#x failed (%d)\n",
  546. cm, ret);
  547. goto fail;
  548. }
  549. ret = cxacru_start_wait_urb(instance->snd_urb, &instance->snd_done, NULL);
  550. if (ret < 0) {
  551. if (printk_ratelimit())
  552. usb_err(instance->usbatm, "send of cm %#x failed (%d)\n", cm, ret);
  553. goto fail;
  554. }
  555. ret = cxacru_start_wait_urb(instance->rcv_urb, &instance->rcv_done, &actlen);
  556. if (ret < 0) {
  557. if (printk_ratelimit())
  558. usb_err(instance->usbatm, "receive of cm %#x failed (%d)\n", cm, ret);
  559. goto fail;
  560. }
  561. if (actlen % CMD_PACKET_SIZE || !actlen) {
  562. if (printk_ratelimit())
  563. usb_err(instance->usbatm, "invalid response length to cm %#x: %d\n",
  564. cm, actlen);
  565. ret = -EIO;
  566. goto fail;
  567. }
  568. /* check the return status and copy the data to the output buffer, if needed */
  569. for (offb = offd = 0; offd < rsize && offb < actlen; offb += CMD_PACKET_SIZE) {
  570. if (rbuf[offb] != cm) {
  571. if (printk_ratelimit())
  572. usb_err(instance->usbatm, "wrong cm %#x in response to cm %#x\n",
  573. rbuf[offb], cm);
  574. ret = -EIO;
  575. goto fail;
  576. }
  577. if (rbuf[offb + 1] != CM_STATUS_SUCCESS) {
  578. if (printk_ratelimit())
  579. usb_err(instance->usbatm, "response to cm %#x failed: %#x\n",
  580. cm, rbuf[offb + 1]);
  581. ret = -EIO;
  582. goto fail;
  583. }
  584. if (offd >= rsize)
  585. break;
  586. memcpy(rdata + offd, rbuf + offb + 4, min_t(int, stride, rsize - offd));
  587. offd += stride;
  588. }
  589. ret = offd;
  590. usb_dbg(instance->usbatm, "cm %#x\n", cm);
  591. fail:
  592. mutex_unlock(&instance->cm_serialize);
  593. err:
  594. return ret;
  595. }
  596. static int cxacru_cm_get_array(struct cxacru_data *instance, enum cxacru_cm_request cm,
  597. u32 *data, int size)
  598. {
  599. int ret, len;
  600. __le32 *buf;
  601. int offb;
  602. unsigned int offd;
  603. const int stride = CMD_PACKET_SIZE / (4 * 2) - 1;
  604. int buflen = ((size - 1) / stride + 1 + size * 2) * 4;
  605. buf = kmalloc(buflen, GFP_KERNEL);
  606. if (!buf)
  607. return -ENOMEM;
  608. ret = cxacru_cm(instance, cm, NULL, 0, (u8 *) buf, buflen);
  609. if (ret < 0)
  610. goto cleanup;
  611. /* len > 0 && len % 4 == 0 guaranteed by cxacru_cm() */
  612. len = ret / 4;
  613. for (offb = 0; offb < len; ) {
  614. int l = le32_to_cpu(buf[offb++]);
  615. if (l < 0 || l > stride || l > (len - offb) / 2) {
  616. if (printk_ratelimit())
  617. usb_err(instance->usbatm, "invalid data length from cm %#x: %d\n",
  618. cm, l);
  619. ret = -EIO;
  620. goto cleanup;
  621. }
  622. while (l--) {
  623. offd = le32_to_cpu(buf[offb++]);
  624. if (offd >= size) {
  625. if (printk_ratelimit())
  626. usb_err(instance->usbatm, "wrong index %#x in response to cm %#x\n",
  627. offd, cm);
  628. ret = -EIO;
  629. goto cleanup;
  630. }
  631. data[offd] = le32_to_cpu(buf[offb++]);
  632. }
  633. }
  634. ret = 0;
  635. cleanup:
  636. kfree(buf);
  637. return ret;
  638. }
  639. static int cxacru_card_status(struct cxacru_data *instance)
  640. {
  641. int ret = cxacru_cm(instance, CM_REQUEST_CARD_GET_STATUS, NULL, 0, NULL, 0);
  642. if (ret < 0) { /* firmware not loaded */
  643. usb_dbg(instance->usbatm, "cxacru_adsl_start: CARD_GET_STATUS returned %d\n", ret);
  644. return ret;
  645. }
  646. return 0;
  647. }
  648. static void cxacru_remove_device_files(struct usbatm_data *usbatm_instance,
  649. struct atm_dev *atm_dev)
  650. {
  651. struct usb_interface *intf = usbatm_instance->usb_intf;
  652. #define CXACRU_DEVICE_REMOVE_FILE(_name) \
  653. device_remove_file(&intf->dev, &dev_attr_##_name);
  654. CXACRU_ALL_FILES(REMOVE);
  655. #undef CXACRU_DEVICE_REMOVE_FILE
  656. }
  657. static int cxacru_atm_start(struct usbatm_data *usbatm_instance,
  658. struct atm_dev *atm_dev)
  659. {
  660. struct cxacru_data *instance = usbatm_instance->driver_data;
  661. struct usb_interface *intf = usbatm_instance->usb_intf;
  662. int ret;
  663. int start_polling = 1;
  664. dev_dbg(&intf->dev, "%s\n", __func__);
  665. /* Read MAC address */
  666. ret = cxacru_cm(instance, CM_REQUEST_CARD_GET_MAC_ADDRESS, NULL, 0,
  667. atm_dev->esi, sizeof(atm_dev->esi));
  668. if (ret < 0) {
  669. atm_err(usbatm_instance, "cxacru_atm_start: CARD_GET_MAC_ADDRESS returned %d\n", ret);
  670. return ret;
  671. }
  672. #define CXACRU_DEVICE_CREATE_FILE(_name) \
  673. ret = device_create_file(&intf->dev, &dev_attr_##_name); \
  674. if (unlikely(ret)) \
  675. goto fail_sysfs;
  676. CXACRU_ALL_FILES(CREATE);
  677. #undef CXACRU_DEVICE_CREATE_FILE
  678. /* start ADSL */
  679. mutex_lock(&instance->adsl_state_serialize);
  680. ret = cxacru_cm(instance, CM_REQUEST_CHIP_ADSL_LINE_START, NULL, 0, NULL, 0);
  681. if (ret < 0)
  682. atm_err(usbatm_instance, "cxacru_atm_start: CHIP_ADSL_LINE_START returned %d\n", ret);
  683. /* Start status polling */
  684. mutex_lock(&instance->poll_state_serialize);
  685. switch (instance->poll_state) {
  686. case CXPOLL_STOPPED:
  687. /* start polling */
  688. instance->poll_state = CXPOLL_POLLING;
  689. break;
  690. case CXPOLL_STOPPING:
  691. /* abort stop request */
  692. instance->poll_state = CXPOLL_POLLING;
  693. case CXPOLL_POLLING:
  694. case CXPOLL_SHUTDOWN:
  695. /* don't start polling */
  696. start_polling = 0;
  697. }
  698. mutex_unlock(&instance->poll_state_serialize);
  699. mutex_unlock(&instance->adsl_state_serialize);
  700. printk(KERN_INFO "%s%d: %s %pM\n", atm_dev->type, atm_dev->number,
  701. usbatm_instance->description, atm_dev->esi);
  702. if (start_polling)
  703. cxacru_poll_status(&instance->poll_work.work);
  704. return 0;
  705. fail_sysfs:
  706. usb_err(usbatm_instance, "cxacru_atm_start: device_create_file failed (%d)\n", ret);
  707. cxacru_remove_device_files(usbatm_instance, atm_dev);
  708. return ret;
  709. }
  710. static void cxacru_poll_status(struct work_struct *work)
  711. {
  712. struct cxacru_data *instance =
  713. container_of(work, struct cxacru_data, poll_work.work);
  714. u32 buf[CXINF_MAX] = {};
  715. struct usbatm_data *usbatm = instance->usbatm;
  716. struct atm_dev *atm_dev = usbatm->atm_dev;
  717. int keep_polling = 1;
  718. int ret;
  719. ret = cxacru_cm_get_array(instance, CM_REQUEST_CARD_INFO_GET, buf, CXINF_MAX);
  720. if (ret < 0) {
  721. if (ret != -ESHUTDOWN)
  722. atm_warn(usbatm, "poll status: error %d\n", ret);
  723. mutex_lock(&instance->poll_state_serialize);
  724. if (instance->poll_state != CXPOLL_SHUTDOWN) {
  725. instance->poll_state = CXPOLL_STOPPED;
  726. if (ret != -ESHUTDOWN)
  727. atm_warn(usbatm, "polling disabled, set adsl_state"
  728. " to 'start' or 'poll' to resume\n");
  729. }
  730. mutex_unlock(&instance->poll_state_serialize);
  731. goto reschedule;
  732. }
  733. memcpy(instance->card_info, buf, sizeof(instance->card_info));
  734. if (instance->adsl_status != buf[CXINF_LINE_STARTABLE]) {
  735. instance->adsl_status = buf[CXINF_LINE_STARTABLE];
  736. switch (instance->adsl_status) {
  737. case 0:
  738. atm_printk(KERN_INFO, usbatm, "ADSL state: running\n");
  739. break;
  740. case 1:
  741. atm_printk(KERN_INFO, usbatm, "ADSL state: stopped\n");
  742. break;
  743. default:
  744. atm_printk(KERN_INFO, usbatm, "Unknown adsl status %02x\n", instance->adsl_status);
  745. break;
  746. }
  747. }
  748. if (instance->line_status == buf[CXINF_LINE_STATUS])
  749. goto reschedule;
  750. instance->line_status = buf[CXINF_LINE_STATUS];
  751. switch (instance->line_status) {
  752. case 0:
  753. atm_dev_signal_change(atm_dev, ATM_PHY_SIG_LOST);
  754. atm_info(usbatm, "ADSL line: down\n");
  755. break;
  756. case 1:
  757. atm_dev_signal_change(atm_dev, ATM_PHY_SIG_LOST);
  758. atm_info(usbatm, "ADSL line: attempting to activate\n");
  759. break;
  760. case 2:
  761. atm_dev_signal_change(atm_dev, ATM_PHY_SIG_LOST);
  762. atm_info(usbatm, "ADSL line: training\n");
  763. break;
  764. case 3:
  765. atm_dev_signal_change(atm_dev, ATM_PHY_SIG_LOST);
  766. atm_info(usbatm, "ADSL line: channel analysis\n");
  767. break;
  768. case 4:
  769. atm_dev_signal_change(atm_dev, ATM_PHY_SIG_LOST);
  770. atm_info(usbatm, "ADSL line: exchange\n");
  771. break;
  772. case 5:
  773. atm_dev->link_rate = buf[CXINF_DOWNSTREAM_RATE] * 1000 / 424;
  774. atm_dev_signal_change(atm_dev, ATM_PHY_SIG_FOUND);
  775. atm_info(usbatm, "ADSL line: up (%d kb/s down | %d kb/s up)\n",
  776. buf[CXINF_DOWNSTREAM_RATE], buf[CXINF_UPSTREAM_RATE]);
  777. break;
  778. case 6:
  779. atm_dev_signal_change(atm_dev, ATM_PHY_SIG_LOST);
  780. atm_info(usbatm, "ADSL line: waiting\n");
  781. break;
  782. case 7:
  783. atm_dev_signal_change(atm_dev, ATM_PHY_SIG_LOST);
  784. atm_info(usbatm, "ADSL line: initializing\n");
  785. break;
  786. default:
  787. atm_dev_signal_change(atm_dev, ATM_PHY_SIG_UNKNOWN);
  788. atm_info(usbatm, "Unknown line state %02x\n", instance->line_status);
  789. break;
  790. }
  791. reschedule:
  792. mutex_lock(&instance->poll_state_serialize);
  793. if (instance->poll_state == CXPOLL_STOPPING &&
  794. instance->adsl_status == 1 && /* stopped */
  795. instance->line_status == 0) /* down */
  796. instance->poll_state = CXPOLL_STOPPED;
  797. if (instance->poll_state == CXPOLL_STOPPED)
  798. keep_polling = 0;
  799. mutex_unlock(&instance->poll_state_serialize);
  800. if (keep_polling)
  801. schedule_delayed_work(&instance->poll_work,
  802. round_jiffies_relative(POLL_INTERVAL*HZ));
  803. }
  804. static int cxacru_fw(struct usb_device *usb_dev, enum cxacru_fw_request fw,
  805. u8 code1, u8 code2, u32 addr, const u8 *data, int size)
  806. {
  807. int ret;
  808. u8 *buf;
  809. int offd, offb;
  810. const int stride = CMD_PACKET_SIZE - 8;
  811. buf = (u8 *) __get_free_page(GFP_KERNEL);
  812. if (!buf)
  813. return -ENOMEM;
  814. offb = offd = 0;
  815. do {
  816. int l = min_t(int, stride, size - offd);
  817. buf[offb++] = fw;
  818. buf[offb++] = l;
  819. buf[offb++] = code1;
  820. buf[offb++] = code2;
  821. put_unaligned(cpu_to_le32(addr), (__le32 *)(buf + offb));
  822. offb += 4;
  823. addr += l;
  824. if (l)
  825. memcpy(buf + offb, data + offd, l);
  826. if (l < stride)
  827. memset(buf + offb + l, 0, stride - l);
  828. offb += stride;
  829. offd += stride;
  830. if ((offb >= PAGE_SIZE) || (offd >= size)) {
  831. ret = usb_bulk_msg(usb_dev, usb_sndbulkpipe(usb_dev, CXACRU_EP_CMD),
  832. buf, offb, NULL, CMD_TIMEOUT);
  833. if (ret < 0) {
  834. dev_dbg(&usb_dev->dev, "sending fw %#x failed\n", fw);
  835. goto cleanup;
  836. }
  837. offb = 0;
  838. }
  839. } while (offd < size);
  840. dev_dbg(&usb_dev->dev, "sent fw %#x\n", fw);
  841. ret = 0;
  842. cleanup:
  843. free_page((unsigned long) buf);
  844. return ret;
  845. }
  846. static void cxacru_upload_firmware(struct cxacru_data *instance,
  847. const struct firmware *fw,
  848. const struct firmware *bp)
  849. {
  850. int ret;
  851. struct usbatm_data *usbatm = instance->usbatm;
  852. struct usb_device *usb_dev = usbatm->usb_dev;
  853. __le16 signature[] = { usb_dev->descriptor.idVendor,
  854. usb_dev->descriptor.idProduct };
  855. __le32 val;
  856. usb_dbg(usbatm, "%s\n", __func__);
  857. /* FirmwarePllFClkValue */
  858. val = cpu_to_le32(instance->modem_type->pll_f_clk);
  859. ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, PLLFCLK_ADDR, (u8 *) &val, 4);
  860. if (ret) {
  861. usb_err(usbatm, "FirmwarePllFClkValue failed: %d\n", ret);
  862. return;
  863. }
  864. /* FirmwarePllBClkValue */
  865. val = cpu_to_le32(instance->modem_type->pll_b_clk);
  866. ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, PLLBCLK_ADDR, (u8 *) &val, 4);
  867. if (ret) {
  868. usb_err(usbatm, "FirmwarePllBClkValue failed: %d\n", ret);
  869. return;
  870. }
  871. /* Enable SDRAM */
  872. val = cpu_to_le32(SDRAM_ENA);
  873. ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, SDRAMEN_ADDR, (u8 *) &val, 4);
  874. if (ret) {
  875. usb_err(usbatm, "Enable SDRAM failed: %d\n", ret);
  876. return;
  877. }
  878. /* Firmware */
  879. usb_info(usbatm, "loading firmware\n");
  880. ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, FW_ADDR, fw->data, fw->size);
  881. if (ret) {
  882. usb_err(usbatm, "Firmware upload failed: %d\n", ret);
  883. return;
  884. }
  885. /* Boot ROM patch */
  886. if (instance->modem_type->boot_rom_patch) {
  887. usb_info(usbatm, "loading boot ROM patch\n");
  888. ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, BR_ADDR, bp->data, bp->size);
  889. if (ret) {
  890. usb_err(usbatm, "Boot ROM patching failed: %d\n", ret);
  891. return;
  892. }
  893. }
  894. /* Signature */
  895. ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, SIG_ADDR, (u8 *) signature, 4);
  896. if (ret) {
  897. usb_err(usbatm, "Signature storing failed: %d\n", ret);
  898. return;
  899. }
  900. usb_info(usbatm, "starting device\n");
  901. if (instance->modem_type->boot_rom_patch) {
  902. val = cpu_to_le32(BR_ADDR);
  903. ret = cxacru_fw(usb_dev, FW_WRITE_MEM, 0x2, 0x0, BR_STACK_ADDR, (u8 *) &val, 4);
  904. } else {
  905. ret = cxacru_fw(usb_dev, FW_GOTO_MEM, 0x0, 0x0, FW_ADDR, NULL, 0);
  906. }
  907. if (ret) {
  908. usb_err(usbatm, "Passing control to firmware failed: %d\n", ret);
  909. return;
  910. }
  911. /* Delay to allow firmware to start up. */
  912. msleep_interruptible(1000);
  913. usb_clear_halt(usb_dev, usb_sndbulkpipe(usb_dev, CXACRU_EP_CMD));
  914. usb_clear_halt(usb_dev, usb_rcvbulkpipe(usb_dev, CXACRU_EP_CMD));
  915. usb_clear_halt(usb_dev, usb_sndbulkpipe(usb_dev, CXACRU_EP_DATA));
  916. usb_clear_halt(usb_dev, usb_rcvbulkpipe(usb_dev, CXACRU_EP_DATA));
  917. ret = cxacru_cm(instance, CM_REQUEST_CARD_GET_STATUS, NULL, 0, NULL, 0);
  918. if (ret < 0) {
  919. usb_err(usbatm, "modem failed to initialize: %d\n", ret);
  920. return;
  921. }
  922. }
  923. static int cxacru_find_firmware(struct cxacru_data *instance,
  924. char *phase, const struct firmware **fw_p)
  925. {
  926. struct usbatm_data *usbatm = instance->usbatm;
  927. struct device *dev = &usbatm->usb_intf->dev;
  928. char buf[16];
  929. sprintf(buf, "cxacru-%s.bin", phase);
  930. usb_dbg(usbatm, "cxacru_find_firmware: looking for %s\n", buf);
  931. if (request_firmware(fw_p, buf, dev)) {
  932. usb_dbg(usbatm, "no stage %s firmware found\n", phase);
  933. return -ENOENT;
  934. }
  935. usb_info(usbatm, "found firmware %s\n", buf);
  936. return 0;
  937. }
  938. static int cxacru_heavy_init(struct usbatm_data *usbatm_instance,
  939. struct usb_interface *usb_intf)
  940. {
  941. const struct firmware *fw, *bp;
  942. struct cxacru_data *instance = usbatm_instance->driver_data;
  943. int ret = cxacru_find_firmware(instance, "fw", &fw);
  944. if (ret) {
  945. usb_warn(usbatm_instance, "firmware (cxacru-fw.bin) unavailable (system misconfigured?)\n");
  946. return ret;
  947. }
  948. if (instance->modem_type->boot_rom_patch) {
  949. ret = cxacru_find_firmware(instance, "bp", &bp);
  950. if (ret) {
  951. usb_warn(usbatm_instance, "boot ROM patch (cxacru-bp.bin) unavailable (system misconfigured?)\n");
  952. release_firmware(fw);
  953. return ret;
  954. }
  955. }
  956. cxacru_upload_firmware(instance, fw, bp);
  957. if (instance->modem_type->boot_rom_patch)
  958. release_firmware(bp);
  959. release_firmware(fw);
  960. ret = cxacru_card_status(instance);
  961. if (ret)
  962. usb_dbg(usbatm_instance, "modem initialisation failed\n");
  963. else
  964. usb_dbg(usbatm_instance, "done setting up the modem\n");
  965. return ret;
  966. }
  967. static int cxacru_bind(struct usbatm_data *usbatm_instance,
  968. struct usb_interface *intf, const struct usb_device_id *id)
  969. {
  970. struct cxacru_data *instance;
  971. struct usb_device *usb_dev = interface_to_usbdev(intf);
  972. struct usb_host_endpoint *cmd_ep = usb_dev->ep_in[CXACRU_EP_CMD];
  973. int ret;
  974. /* instance init */
  975. instance = kzalloc(sizeof(*instance), GFP_KERNEL);
  976. if (!instance) {
  977. usb_dbg(usbatm_instance, "cxacru_bind: no memory for instance data\n");
  978. return -ENOMEM;
  979. }
  980. instance->usbatm = usbatm_instance;
  981. instance->modem_type = (struct cxacru_modem_type *) id->driver_info;
  982. mutex_init(&instance->poll_state_serialize);
  983. instance->poll_state = CXPOLL_STOPPED;
  984. instance->line_status = -1;
  985. instance->adsl_status = -1;
  986. mutex_init(&instance->adsl_state_serialize);
  987. instance->rcv_buf = (u8 *) __get_free_page(GFP_KERNEL);
  988. if (!instance->rcv_buf) {
  989. usb_dbg(usbatm_instance, "cxacru_bind: no memory for rcv_buf\n");
  990. ret = -ENOMEM;
  991. goto fail;
  992. }
  993. instance->snd_buf = (u8 *) __get_free_page(GFP_KERNEL);
  994. if (!instance->snd_buf) {
  995. usb_dbg(usbatm_instance, "cxacru_bind: no memory for snd_buf\n");
  996. ret = -ENOMEM;
  997. goto fail;
  998. }
  999. instance->rcv_urb = usb_alloc_urb(0, GFP_KERNEL);
  1000. if (!instance->rcv_urb) {
  1001. usb_dbg(usbatm_instance, "cxacru_bind: no memory for rcv_urb\n");
  1002. ret = -ENOMEM;
  1003. goto fail;
  1004. }
  1005. instance->snd_urb = usb_alloc_urb(0, GFP_KERNEL);
  1006. if (!instance->snd_urb) {
  1007. usb_dbg(usbatm_instance, "cxacru_bind: no memory for snd_urb\n");
  1008. ret = -ENOMEM;
  1009. goto fail;
  1010. }
  1011. if (!cmd_ep) {
  1012. usb_dbg(usbatm_instance, "cxacru_bind: no command endpoint\n");
  1013. ret = -ENODEV;
  1014. goto fail;
  1015. }
  1016. if ((cmd_ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
  1017. == USB_ENDPOINT_XFER_INT) {
  1018. usb_fill_int_urb(instance->rcv_urb,
  1019. usb_dev, usb_rcvintpipe(usb_dev, CXACRU_EP_CMD),
  1020. instance->rcv_buf, PAGE_SIZE,
  1021. cxacru_blocking_completion, &instance->rcv_done, 1);
  1022. usb_fill_int_urb(instance->snd_urb,
  1023. usb_dev, usb_sndintpipe(usb_dev, CXACRU_EP_CMD),
  1024. instance->snd_buf, PAGE_SIZE,
  1025. cxacru_blocking_completion, &instance->snd_done, 4);
  1026. } else {
  1027. usb_fill_bulk_urb(instance->rcv_urb,
  1028. usb_dev, usb_rcvbulkpipe(usb_dev, CXACRU_EP_CMD),
  1029. instance->rcv_buf, PAGE_SIZE,
  1030. cxacru_blocking_completion, &instance->rcv_done);
  1031. usb_fill_bulk_urb(instance->snd_urb,
  1032. usb_dev, usb_sndbulkpipe(usb_dev, CXACRU_EP_CMD),
  1033. instance->snd_buf, PAGE_SIZE,
  1034. cxacru_blocking_completion, &instance->snd_done);
  1035. }
  1036. mutex_init(&instance->cm_serialize);
  1037. INIT_DELAYED_WORK(&instance->poll_work, cxacru_poll_status);
  1038. usbatm_instance->driver_data = instance;
  1039. usbatm_instance->flags = (cxacru_card_status(instance) ? 0 : UDSL_SKIP_HEAVY_INIT);
  1040. return 0;
  1041. fail:
  1042. free_page((unsigned long) instance->snd_buf);
  1043. free_page((unsigned long) instance->rcv_buf);
  1044. usb_free_urb(instance->snd_urb);
  1045. usb_free_urb(instance->rcv_urb);
  1046. kfree(instance);
  1047. return ret;
  1048. }
  1049. static void cxacru_unbind(struct usbatm_data *usbatm_instance,
  1050. struct usb_interface *intf)
  1051. {
  1052. struct cxacru_data *instance = usbatm_instance->driver_data;
  1053. int is_polling = 1;
  1054. usb_dbg(usbatm_instance, "cxacru_unbind entered\n");
  1055. if (!instance) {
  1056. usb_dbg(usbatm_instance, "cxacru_unbind: NULL instance!\n");
  1057. return;
  1058. }
  1059. mutex_lock(&instance->poll_state_serialize);
  1060. BUG_ON(instance->poll_state == CXPOLL_SHUTDOWN);
  1061. /* ensure that status polling continues unless
  1062. * it has already stopped */
  1063. if (instance->poll_state == CXPOLL_STOPPED)
  1064. is_polling = 0;
  1065. /* stop polling from being stopped or started */
  1066. instance->poll_state = CXPOLL_SHUTDOWN;
  1067. mutex_unlock(&instance->poll_state_serialize);
  1068. if (is_polling)
  1069. cancel_delayed_work_sync(&instance->poll_work);
  1070. usb_kill_urb(instance->snd_urb);
  1071. usb_kill_urb(instance->rcv_urb);
  1072. usb_free_urb(instance->snd_urb);
  1073. usb_free_urb(instance->rcv_urb);
  1074. free_page((unsigned long) instance->snd_buf);
  1075. free_page((unsigned long) instance->rcv_buf);
  1076. kfree(instance);
  1077. usbatm_instance->driver_data = NULL;
  1078. }
  1079. static const struct cxacru_modem_type cxacru_cafe = {
  1080. .pll_f_clk = 0x02d874df,
  1081. .pll_b_clk = 0x0196a51a,
  1082. .boot_rom_patch = 1,
  1083. };
  1084. static const struct cxacru_modem_type cxacru_cb00 = {
  1085. .pll_f_clk = 0x5,
  1086. .pll_b_clk = 0x3,
  1087. .boot_rom_patch = 0,
  1088. };
  1089. static const struct usb_device_id cxacru_usb_ids[] = {
  1090. { /* V = Conexant P = ADSL modem (Euphrates project) */
  1091. USB_DEVICE(0x0572, 0xcafe), .driver_info = (unsigned long) &cxacru_cafe
  1092. },
  1093. { /* V = Conexant P = ADSL modem (Hasbani project) */
  1094. USB_DEVICE(0x0572, 0xcb00), .driver_info = (unsigned long) &cxacru_cb00
  1095. },
  1096. { /* V = Conexant P = ADSL modem */
  1097. USB_DEVICE(0x0572, 0xcb01), .driver_info = (unsigned long) &cxacru_cb00
  1098. },
  1099. { /* V = Conexant P = ADSL modem (Well PTI-800) */
  1100. USB_DEVICE(0x0572, 0xcb02), .driver_info = (unsigned long) &cxacru_cb00
  1101. },
  1102. { /* V = Conexant P = ADSL modem */
  1103. USB_DEVICE(0x0572, 0xcb06), .driver_info = (unsigned long) &cxacru_cb00
  1104. },
  1105. { /* V = Conexant P = ADSL modem (ZTE ZXDSL 852) */
  1106. USB_DEVICE(0x0572, 0xcb07), .driver_info = (unsigned long) &cxacru_cb00
  1107. },
  1108. { /* V = Olitec P = ADSL modem version 2 */
  1109. USB_DEVICE(0x08e3, 0x0100), .driver_info = (unsigned long) &cxacru_cafe
  1110. },
  1111. { /* V = Olitec P = ADSL modem version 3 */
  1112. USB_DEVICE(0x08e3, 0x0102), .driver_info = (unsigned long) &cxacru_cb00
  1113. },
  1114. { /* V = Trust/Amigo Technology Co. P = AMX-CA86U */
  1115. USB_DEVICE(0x0eb0, 0x3457), .driver_info = (unsigned long) &cxacru_cafe
  1116. },
  1117. { /* V = Zoom P = 5510 */
  1118. USB_DEVICE(0x1803, 0x5510), .driver_info = (unsigned long) &cxacru_cb00
  1119. },
  1120. { /* V = Draytek P = Vigor 318 */
  1121. USB_DEVICE(0x0675, 0x0200), .driver_info = (unsigned long) &cxacru_cb00
  1122. },
  1123. { /* V = Zyxel P = 630-C1 aka OMNI ADSL USB (Annex A) */
  1124. USB_DEVICE(0x0586, 0x330a), .driver_info = (unsigned long) &cxacru_cb00
  1125. },
  1126. { /* V = Zyxel P = 630-C3 aka OMNI ADSL USB (Annex B) */
  1127. USB_DEVICE(0x0586, 0x330b), .driver_info = (unsigned long) &cxacru_cb00
  1128. },
  1129. { /* V = Aethra P = Starmodem UM1020 */
  1130. USB_DEVICE(0x0659, 0x0020), .driver_info = (unsigned long) &cxacru_cb00
  1131. },
  1132. { /* V = Aztech Systems P = ? AKA Pirelli AUA-010 */
  1133. USB_DEVICE(0x0509, 0x0812), .driver_info = (unsigned long) &cxacru_cb00
  1134. },
  1135. { /* V = Netopia P = Cayman 3341(Annex A)/3351(Annex B) */
  1136. USB_DEVICE(0x100d, 0xcb01), .driver_info = (unsigned long) &cxacru_cb00
  1137. },
  1138. { /* V = Netopia P = Cayman 3342(Annex A)/3352(Annex B) */
  1139. USB_DEVICE(0x100d, 0x3342), .driver_info = (unsigned long) &cxacru_cb00
  1140. },
  1141. {}
  1142. };
  1143. MODULE_DEVICE_TABLE(usb, cxacru_usb_ids);
  1144. static struct usbatm_driver cxacru_driver = {
  1145. .driver_name = cxacru_driver_name,
  1146. .bind = cxacru_bind,
  1147. .heavy_init = cxacru_heavy_init,
  1148. .unbind = cxacru_unbind,
  1149. .atm_start = cxacru_atm_start,
  1150. .atm_stop = cxacru_remove_device_files,
  1151. .bulk_in = CXACRU_EP_DATA,
  1152. .bulk_out = CXACRU_EP_DATA,
  1153. .rx_padding = 3,
  1154. .tx_padding = 11,
  1155. };
  1156. static int cxacru_usb_probe(struct usb_interface *intf,
  1157. const struct usb_device_id *id)
  1158. {
  1159. struct usb_device *usb_dev = interface_to_usbdev(intf);
  1160. char buf[15];
  1161. /* Avoid ADSL routers (cx82310_eth).
  1162. * Abort if bDeviceClass is 0xff and iProduct is "USB NET CARD".
  1163. */
  1164. if (usb_dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC
  1165. && usb_string(usb_dev, usb_dev->descriptor.iProduct,
  1166. buf, sizeof(buf)) > 0) {
  1167. if (!strcmp(buf, "USB NET CARD")) {
  1168. dev_info(&intf->dev, "ignoring cx82310_eth device\n");
  1169. return -ENODEV;
  1170. }
  1171. }
  1172. return usbatm_usb_probe(intf, id, &cxacru_driver);
  1173. }
  1174. static struct usb_driver cxacru_usb_driver = {
  1175. .name = cxacru_driver_name,
  1176. .probe = cxacru_usb_probe,
  1177. .disconnect = usbatm_usb_disconnect,
  1178. .id_table = cxacru_usb_ids
  1179. };
  1180. module_usb_driver(cxacru_usb_driver);
  1181. MODULE_AUTHOR(DRIVER_AUTHOR);
  1182. MODULE_DESCRIPTION(DRIVER_DESC);
  1183. MODULE_LICENSE("GPL");
  1184. MODULE_VERSION(DRIVER_VERSION);