ueagle-atm.c 68 KB

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