btusb.c 117 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. *
  4. * Generic Bluetooth USB driver
  5. *
  6. * Copyright (C) 2005-2008 Marcel Holtmann <marcel@holtmann.org>
  7. */
  8. #include <linux/dmi.h>
  9. #include <linux/module.h>
  10. #include <linux/usb.h>
  11. #include <linux/usb/quirks.h>
  12. #include <linux/firmware.h>
  13. #include <linux/iopoll.h>
  14. #include <linux/of_device.h>
  15. #include <linux/of_irq.h>
  16. #include <linux/suspend.h>
  17. #include <linux/gpio/consumer.h>
  18. #include <asm/unaligned.h>
  19. #include <net/bluetooth/bluetooth.h>
  20. #include <net/bluetooth/hci_core.h>
  21. #include "btintel.h"
  22. #include "btbcm.h"
  23. #include "btrtl.h"
  24. #define VERSION "0.8"
  25. static bool disable_scofix;
  26. static bool force_scofix;
  27. static bool enable_autosuspend = IS_ENABLED(CONFIG_BT_HCIBTUSB_AUTOSUSPEND);
  28. static bool reset = true;
  29. static struct usb_driver btusb_driver;
  30. #define BTUSB_IGNORE 0x01
  31. #define BTUSB_DIGIANSWER 0x02
  32. #define BTUSB_CSR 0x04
  33. #define BTUSB_SNIFFER 0x08
  34. #define BTUSB_BCM92035 0x10
  35. #define BTUSB_BROKEN_ISOC 0x20
  36. #define BTUSB_WRONG_SCO_MTU 0x40
  37. #define BTUSB_ATH3012 0x80
  38. #define BTUSB_INTEL 0x100
  39. #define BTUSB_INTEL_BOOT 0x200
  40. #define BTUSB_BCM_PATCHRAM 0x400
  41. #define BTUSB_MARVELL 0x800
  42. #define BTUSB_SWAVE 0x1000
  43. #define BTUSB_INTEL_NEW 0x2000
  44. #define BTUSB_AMP 0x4000
  45. #define BTUSB_QCA_ROME 0x8000
  46. #define BTUSB_BCM_APPLE 0x10000
  47. #define BTUSB_REALTEK 0x20000
  48. #define BTUSB_BCM2045 0x40000
  49. #define BTUSB_IFNUM_2 0x80000
  50. #define BTUSB_CW6622 0x100000
  51. #define BTUSB_MEDIATEK 0x200000
  52. #define BTUSB_WIDEBAND_SPEECH 0x400000
  53. #define BTUSB_VALID_LE_STATES 0x800000
  54. #define BTUSB_QCA_WCN6855 0x1000000
  55. static const struct usb_device_id btusb_table[] = {
  56. /* Generic Bluetooth USB device */
  57. { USB_DEVICE_INFO(0xe0, 0x01, 0x01) },
  58. /* Generic Bluetooth AMP device */
  59. { USB_DEVICE_INFO(0xe0, 0x01, 0x04), .driver_info = BTUSB_AMP },
  60. /* Generic Bluetooth USB interface */
  61. { USB_INTERFACE_INFO(0xe0, 0x01, 0x01) },
  62. /* Apple-specific (Broadcom) devices */
  63. { USB_VENDOR_AND_INTERFACE_INFO(0x05ac, 0xff, 0x01, 0x01),
  64. .driver_info = BTUSB_BCM_APPLE | BTUSB_IFNUM_2 },
  65. /* MediaTek MT76x0E */
  66. { USB_DEVICE(0x0e8d, 0x763f) },
  67. /* Broadcom SoftSailing reporting vendor specific */
  68. { USB_DEVICE(0x0a5c, 0x21e1) },
  69. /* Apple MacBookPro 7,1 */
  70. { USB_DEVICE(0x05ac, 0x8213) },
  71. /* Apple iMac11,1 */
  72. { USB_DEVICE(0x05ac, 0x8215) },
  73. /* Apple MacBookPro6,2 */
  74. { USB_DEVICE(0x05ac, 0x8218) },
  75. /* Apple MacBookAir3,1, MacBookAir3,2 */
  76. { USB_DEVICE(0x05ac, 0x821b) },
  77. /* Apple MacBookAir4,1 */
  78. { USB_DEVICE(0x05ac, 0x821f) },
  79. /* Apple MacBookPro8,2 */
  80. { USB_DEVICE(0x05ac, 0x821a) },
  81. /* Apple MacMini5,1 */
  82. { USB_DEVICE(0x05ac, 0x8281) },
  83. /* AVM BlueFRITZ! USB v2.0 */
  84. { USB_DEVICE(0x057c, 0x3800), .driver_info = BTUSB_SWAVE },
  85. /* Bluetooth Ultraport Module from IBM */
  86. { USB_DEVICE(0x04bf, 0x030a) },
  87. /* ALPS Modules with non-standard id */
  88. { USB_DEVICE(0x044e, 0x3001) },
  89. { USB_DEVICE(0x044e, 0x3002) },
  90. /* Ericsson with non-standard id */
  91. { USB_DEVICE(0x0bdb, 0x1002) },
  92. /* Canyon CN-BTU1 with HID interfaces */
  93. { USB_DEVICE(0x0c10, 0x0000) },
  94. /* Broadcom BCM20702A0 */
  95. { USB_DEVICE(0x413c, 0x8197) },
  96. /* Broadcom BCM20702B0 (Dynex/Insignia) */
  97. { USB_DEVICE(0x19ff, 0x0239), .driver_info = BTUSB_BCM_PATCHRAM },
  98. /* Broadcom BCM43142A0 (Foxconn/Lenovo) */
  99. { USB_VENDOR_AND_INTERFACE_INFO(0x105b, 0xff, 0x01, 0x01),
  100. .driver_info = BTUSB_BCM_PATCHRAM },
  101. /* Broadcom BCM920703 (HTC Vive) */
  102. { USB_VENDOR_AND_INTERFACE_INFO(0x0bb4, 0xff, 0x01, 0x01),
  103. .driver_info = BTUSB_BCM_PATCHRAM },
  104. /* Foxconn - Hon Hai */
  105. { USB_VENDOR_AND_INTERFACE_INFO(0x0489, 0xff, 0x01, 0x01),
  106. .driver_info = BTUSB_BCM_PATCHRAM },
  107. /* Lite-On Technology - Broadcom based */
  108. { USB_VENDOR_AND_INTERFACE_INFO(0x04ca, 0xff, 0x01, 0x01),
  109. .driver_info = BTUSB_BCM_PATCHRAM },
  110. /* Broadcom devices with vendor specific id */
  111. { USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01),
  112. .driver_info = BTUSB_BCM_PATCHRAM },
  113. /* ASUSTek Computer - Broadcom based */
  114. { USB_VENDOR_AND_INTERFACE_INFO(0x0b05, 0xff, 0x01, 0x01),
  115. .driver_info = BTUSB_BCM_PATCHRAM },
  116. /* Belkin F8065bf - Broadcom based */
  117. { USB_VENDOR_AND_INTERFACE_INFO(0x050d, 0xff, 0x01, 0x01),
  118. .driver_info = BTUSB_BCM_PATCHRAM },
  119. /* IMC Networks - Broadcom based */
  120. { USB_VENDOR_AND_INTERFACE_INFO(0x13d3, 0xff, 0x01, 0x01),
  121. .driver_info = BTUSB_BCM_PATCHRAM },
  122. /* Dell Computer - Broadcom based */
  123. { USB_VENDOR_AND_INTERFACE_INFO(0x413c, 0xff, 0x01, 0x01),
  124. .driver_info = BTUSB_BCM_PATCHRAM },
  125. /* Toshiba Corp - Broadcom based */
  126. { USB_VENDOR_AND_INTERFACE_INFO(0x0930, 0xff, 0x01, 0x01),
  127. .driver_info = BTUSB_BCM_PATCHRAM },
  128. /* Intel Bluetooth USB Bootloader (RAM module) */
  129. { USB_DEVICE(0x8087, 0x0a5a),
  130. .driver_info = BTUSB_INTEL_BOOT | BTUSB_BROKEN_ISOC },
  131. { } /* Terminating entry */
  132. };
  133. MODULE_DEVICE_TABLE(usb, btusb_table);
  134. static const struct usb_device_id blacklist_table[] = {
  135. /* CSR BlueCore devices */
  136. { USB_DEVICE(0x0a12, 0x0001), .driver_info = BTUSB_CSR },
  137. /* Broadcom BCM2033 without firmware */
  138. { USB_DEVICE(0x0a5c, 0x2033), .driver_info = BTUSB_IGNORE },
  139. /* Broadcom BCM2045 devices */
  140. { USB_DEVICE(0x0a5c, 0x2045), .driver_info = BTUSB_BCM2045 },
  141. /* Atheros 3011 with sflash firmware */
  142. { USB_DEVICE(0x0489, 0xe027), .driver_info = BTUSB_IGNORE },
  143. { USB_DEVICE(0x0489, 0xe03d), .driver_info = BTUSB_IGNORE },
  144. { USB_DEVICE(0x04f2, 0xaff1), .driver_info = BTUSB_IGNORE },
  145. { USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE },
  146. { USB_DEVICE(0x0cf3, 0x3002), .driver_info = BTUSB_IGNORE },
  147. { USB_DEVICE(0x0cf3, 0xe019), .driver_info = BTUSB_IGNORE },
  148. { USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE },
  149. /* Atheros AR9285 Malbec with sflash firmware */
  150. { USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE },
  151. /* Atheros 3012 with sflash firmware */
  152. { USB_DEVICE(0x0489, 0xe04d), .driver_info = BTUSB_ATH3012 },
  153. { USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 },
  154. { USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 },
  155. { USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 },
  156. { USB_DEVICE(0x0489, 0xe05f), .driver_info = BTUSB_ATH3012 },
  157. { USB_DEVICE(0x0489, 0xe076), .driver_info = BTUSB_ATH3012 },
  158. { USB_DEVICE(0x0489, 0xe078), .driver_info = BTUSB_ATH3012 },
  159. { USB_DEVICE(0x0489, 0xe095), .driver_info = BTUSB_ATH3012 },
  160. { USB_DEVICE(0x04c5, 0x1330), .driver_info = BTUSB_ATH3012 },
  161. { USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 },
  162. { USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 },
  163. { USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 },
  164. { USB_DEVICE(0x04ca, 0x3007), .driver_info = BTUSB_ATH3012 },
  165. { USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 },
  166. { USB_DEVICE(0x04ca, 0x300b), .driver_info = BTUSB_ATH3012 },
  167. { USB_DEVICE(0x04ca, 0x300d), .driver_info = BTUSB_ATH3012 },
  168. { USB_DEVICE(0x04ca, 0x300f), .driver_info = BTUSB_ATH3012 },
  169. { USB_DEVICE(0x04ca, 0x3010), .driver_info = BTUSB_ATH3012 },
  170. { USB_DEVICE(0x04ca, 0x3014), .driver_info = BTUSB_ATH3012 },
  171. { USB_DEVICE(0x04ca, 0x3018), .driver_info = BTUSB_ATH3012 },
  172. { USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 },
  173. { USB_DEVICE(0x0930, 0x021c), .driver_info = BTUSB_ATH3012 },
  174. { USB_DEVICE(0x0930, 0x0220), .driver_info = BTUSB_ATH3012 },
  175. { USB_DEVICE(0x0930, 0x0227), .driver_info = BTUSB_ATH3012 },
  176. { USB_DEVICE(0x0b05, 0x17d0), .driver_info = BTUSB_ATH3012 },
  177. { USB_DEVICE(0x0cf3, 0x0036), .driver_info = BTUSB_ATH3012 },
  178. { USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },
  179. { USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },
  180. { USB_DEVICE(0x0cf3, 0x311d), .driver_info = BTUSB_ATH3012 },
  181. { USB_DEVICE(0x0cf3, 0x311e), .driver_info = BTUSB_ATH3012 },
  182. { USB_DEVICE(0x0cf3, 0x311f), .driver_info = BTUSB_ATH3012 },
  183. { USB_DEVICE(0x0cf3, 0x3121), .driver_info = BTUSB_ATH3012 },
  184. { USB_DEVICE(0x0cf3, 0x817a), .driver_info = BTUSB_ATH3012 },
  185. { USB_DEVICE(0x0cf3, 0x817b), .driver_info = BTUSB_ATH3012 },
  186. { USB_DEVICE(0x0cf3, 0xe003), .driver_info = BTUSB_ATH3012 },
  187. { USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 },
  188. { USB_DEVICE(0x0cf3, 0xe005), .driver_info = BTUSB_ATH3012 },
  189. { USB_DEVICE(0x0cf3, 0xe006), .driver_info = BTUSB_ATH3012 },
  190. { USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 },
  191. { USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 },
  192. { USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 },
  193. { USB_DEVICE(0x13d3, 0x3395), .driver_info = BTUSB_ATH3012 },
  194. { USB_DEVICE(0x13d3, 0x3402), .driver_info = BTUSB_ATH3012 },
  195. { USB_DEVICE(0x13d3, 0x3408), .driver_info = BTUSB_ATH3012 },
  196. { USB_DEVICE(0x13d3, 0x3423), .driver_info = BTUSB_ATH3012 },
  197. { USB_DEVICE(0x13d3, 0x3432), .driver_info = BTUSB_ATH3012 },
  198. { USB_DEVICE(0x13d3, 0x3472), .driver_info = BTUSB_ATH3012 },
  199. { USB_DEVICE(0x13d3, 0x3474), .driver_info = BTUSB_ATH3012 },
  200. { USB_DEVICE(0x13d3, 0x3487), .driver_info = BTUSB_ATH3012 },
  201. { USB_DEVICE(0x13d3, 0x3490), .driver_info = BTUSB_ATH3012 },
  202. /* Atheros AR5BBU12 with sflash firmware */
  203. { USB_DEVICE(0x0489, 0xe02c), .driver_info = BTUSB_IGNORE },
  204. /* Atheros AR5BBU12 with sflash firmware */
  205. { USB_DEVICE(0x0489, 0xe036), .driver_info = BTUSB_ATH3012 },
  206. { USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 },
  207. /* QCA ROME chipset */
  208. { USB_DEVICE(0x0cf3, 0x535b), .driver_info = BTUSB_QCA_ROME |
  209. BTUSB_WIDEBAND_SPEECH },
  210. { USB_DEVICE(0x0cf3, 0xe007), .driver_info = BTUSB_QCA_ROME |
  211. BTUSB_WIDEBAND_SPEECH },
  212. { USB_DEVICE(0x0cf3, 0xe009), .driver_info = BTUSB_QCA_ROME |
  213. BTUSB_WIDEBAND_SPEECH },
  214. { USB_DEVICE(0x0cf3, 0xe010), .driver_info = BTUSB_QCA_ROME |
  215. BTUSB_WIDEBAND_SPEECH },
  216. { USB_DEVICE(0x0cf3, 0xe300), .driver_info = BTUSB_QCA_ROME |
  217. BTUSB_WIDEBAND_SPEECH },
  218. { USB_DEVICE(0x0cf3, 0xe301), .driver_info = BTUSB_QCA_ROME |
  219. BTUSB_WIDEBAND_SPEECH },
  220. { USB_DEVICE(0x0cf3, 0xe360), .driver_info = BTUSB_QCA_ROME |
  221. BTUSB_WIDEBAND_SPEECH },
  222. { USB_DEVICE(0x0cf3, 0xe500), .driver_info = BTUSB_QCA_ROME |
  223. BTUSB_WIDEBAND_SPEECH },
  224. { USB_DEVICE(0x0489, 0xe092), .driver_info = BTUSB_QCA_ROME |
  225. BTUSB_WIDEBAND_SPEECH },
  226. { USB_DEVICE(0x0489, 0xe09f), .driver_info = BTUSB_QCA_ROME |
  227. BTUSB_WIDEBAND_SPEECH },
  228. { USB_DEVICE(0x0489, 0xe0a2), .driver_info = BTUSB_QCA_ROME |
  229. BTUSB_WIDEBAND_SPEECH },
  230. { USB_DEVICE(0x04ca, 0x3011), .driver_info = BTUSB_QCA_ROME |
  231. BTUSB_WIDEBAND_SPEECH },
  232. { USB_DEVICE(0x04ca, 0x3015), .driver_info = BTUSB_QCA_ROME |
  233. BTUSB_WIDEBAND_SPEECH },
  234. { USB_DEVICE(0x04ca, 0x3016), .driver_info = BTUSB_QCA_ROME |
  235. BTUSB_WIDEBAND_SPEECH },
  236. { USB_DEVICE(0x04ca, 0x301a), .driver_info = BTUSB_QCA_ROME |
  237. BTUSB_WIDEBAND_SPEECH },
  238. { USB_DEVICE(0x04ca, 0x3021), .driver_info = BTUSB_QCA_ROME |
  239. BTUSB_WIDEBAND_SPEECH },
  240. { USB_DEVICE(0x13d3, 0x3491), .driver_info = BTUSB_QCA_ROME |
  241. BTUSB_WIDEBAND_SPEECH },
  242. { USB_DEVICE(0x13d3, 0x3496), .driver_info = BTUSB_QCA_ROME |
  243. BTUSB_WIDEBAND_SPEECH },
  244. { USB_DEVICE(0x13d3, 0x3501), .driver_info = BTUSB_QCA_ROME |
  245. BTUSB_WIDEBAND_SPEECH },
  246. /* QCA WCN6855 chipset */
  247. { USB_DEVICE(0x0cf3, 0xe600), .driver_info = BTUSB_QCA_WCN6855 |
  248. BTUSB_WIDEBAND_SPEECH },
  249. /* Broadcom BCM2035 */
  250. { USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },
  251. { USB_DEVICE(0x0a5c, 0x200a), .driver_info = BTUSB_WRONG_SCO_MTU },
  252. { USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU },
  253. /* Broadcom BCM2045 */
  254. { USB_DEVICE(0x0a5c, 0x2039), .driver_info = BTUSB_WRONG_SCO_MTU },
  255. { USB_DEVICE(0x0a5c, 0x2101), .driver_info = BTUSB_WRONG_SCO_MTU },
  256. /* IBM/Lenovo ThinkPad with Broadcom chip */
  257. { USB_DEVICE(0x0a5c, 0x201e), .driver_info = BTUSB_WRONG_SCO_MTU },
  258. { USB_DEVICE(0x0a5c, 0x2110), .driver_info = BTUSB_WRONG_SCO_MTU },
  259. /* HP laptop with Broadcom chip */
  260. { USB_DEVICE(0x03f0, 0x171d), .driver_info = BTUSB_WRONG_SCO_MTU },
  261. /* Dell laptop with Broadcom chip */
  262. { USB_DEVICE(0x413c, 0x8126), .driver_info = BTUSB_WRONG_SCO_MTU },
  263. /* Dell Wireless 370 and 410 devices */
  264. { USB_DEVICE(0x413c, 0x8152), .driver_info = BTUSB_WRONG_SCO_MTU },
  265. { USB_DEVICE(0x413c, 0x8156), .driver_info = BTUSB_WRONG_SCO_MTU },
  266. /* Belkin F8T012 and F8T013 devices */
  267. { USB_DEVICE(0x050d, 0x0012), .driver_info = BTUSB_WRONG_SCO_MTU },
  268. { USB_DEVICE(0x050d, 0x0013), .driver_info = BTUSB_WRONG_SCO_MTU },
  269. /* Asus WL-BTD202 device */
  270. { USB_DEVICE(0x0b05, 0x1715), .driver_info = BTUSB_WRONG_SCO_MTU },
  271. /* Kensington Bluetooth USB adapter */
  272. { USB_DEVICE(0x047d, 0x105e), .driver_info = BTUSB_WRONG_SCO_MTU },
  273. /* RTX Telecom based adapters with buggy SCO support */
  274. { USB_DEVICE(0x0400, 0x0807), .driver_info = BTUSB_BROKEN_ISOC },
  275. { USB_DEVICE(0x0400, 0x080a), .driver_info = BTUSB_BROKEN_ISOC },
  276. /* CONWISE Technology based adapters with buggy SCO support */
  277. { USB_DEVICE(0x0e5e, 0x6622),
  278. .driver_info = BTUSB_BROKEN_ISOC | BTUSB_CW6622},
  279. /* Roper Class 1 Bluetooth Dongle (Silicon Wave based) */
  280. { USB_DEVICE(0x1310, 0x0001), .driver_info = BTUSB_SWAVE },
  281. /* Digianswer devices */
  282. { USB_DEVICE(0x08fd, 0x0001), .driver_info = BTUSB_DIGIANSWER },
  283. { USB_DEVICE(0x08fd, 0x0002), .driver_info = BTUSB_IGNORE },
  284. /* CSR BlueCore Bluetooth Sniffer */
  285. { USB_DEVICE(0x0a12, 0x0002),
  286. .driver_info = BTUSB_SNIFFER | BTUSB_BROKEN_ISOC },
  287. /* Frontline ComProbe Bluetooth Sniffer */
  288. { USB_DEVICE(0x16d3, 0x0002),
  289. .driver_info = BTUSB_SNIFFER | BTUSB_BROKEN_ISOC },
  290. /* Marvell Bluetooth devices */
  291. { USB_DEVICE(0x1286, 0x2044), .driver_info = BTUSB_MARVELL },
  292. { USB_DEVICE(0x1286, 0x2046), .driver_info = BTUSB_MARVELL },
  293. { USB_DEVICE(0x1286, 0x204e), .driver_info = BTUSB_MARVELL },
  294. /* Intel Bluetooth devices */
  295. { USB_DEVICE(0x8087, 0x0025), .driver_info = BTUSB_INTEL_NEW |
  296. BTUSB_WIDEBAND_SPEECH |
  297. BTUSB_VALID_LE_STATES },
  298. { USB_DEVICE(0x8087, 0x0026), .driver_info = BTUSB_INTEL_NEW |
  299. BTUSB_WIDEBAND_SPEECH },
  300. { USB_DEVICE(0x8087, 0x0029), .driver_info = BTUSB_INTEL_NEW |
  301. BTUSB_WIDEBAND_SPEECH },
  302. { USB_DEVICE(0x8087, 0x0032), .driver_info = BTUSB_INTEL_NEW |
  303. BTUSB_WIDEBAND_SPEECH},
  304. { USB_DEVICE(0x8087, 0x07da), .driver_info = BTUSB_CSR },
  305. { USB_DEVICE(0x8087, 0x07dc), .driver_info = BTUSB_INTEL },
  306. { USB_DEVICE(0x8087, 0x0a2a), .driver_info = BTUSB_INTEL },
  307. { USB_DEVICE(0x8087, 0x0a2b), .driver_info = BTUSB_INTEL_NEW |
  308. BTUSB_WIDEBAND_SPEECH },
  309. { USB_DEVICE(0x8087, 0x0aa7), .driver_info = BTUSB_INTEL |
  310. BTUSB_WIDEBAND_SPEECH },
  311. { USB_DEVICE(0x8087, 0x0aaa), .driver_info = BTUSB_INTEL_NEW |
  312. BTUSB_WIDEBAND_SPEECH |
  313. BTUSB_VALID_LE_STATES },
  314. { USB_DEVICE(0x10ab, 0x9309), .driver_info = BTUSB_QCA_WCN6855 |
  315. BTUSB_WIDEBAND_SPEECH |
  316. BTUSB_VALID_LE_STATES },
  317. { USB_DEVICE(0x10ab, 0x9409), .driver_info = BTUSB_QCA_WCN6855 |
  318. BTUSB_WIDEBAND_SPEECH |
  319. BTUSB_VALID_LE_STATES },
  320. { USB_DEVICE(0x0489, 0xe0d0), .driver_info = BTUSB_QCA_WCN6855 |
  321. BTUSB_WIDEBAND_SPEECH |
  322. BTUSB_VALID_LE_STATES },
  323. /* Other Intel Bluetooth devices */
  324. { USB_VENDOR_AND_INTERFACE_INFO(0x8087, 0xe0, 0x01, 0x01),
  325. .driver_info = BTUSB_IGNORE },
  326. /* Realtek 8822CE Bluetooth devices */
  327. { USB_DEVICE(0x0bda, 0xb00c), .driver_info = BTUSB_REALTEK |
  328. BTUSB_WIDEBAND_SPEECH },
  329. { USB_DEVICE(0x0bda, 0xc822), .driver_info = BTUSB_REALTEK |
  330. BTUSB_WIDEBAND_SPEECH },
  331. /* Realtek Bluetooth devices */
  332. { USB_VENDOR_AND_INTERFACE_INFO(0x0bda, 0xe0, 0x01, 0x01),
  333. .driver_info = BTUSB_REALTEK },
  334. /* MediaTek Bluetooth devices */
  335. { USB_VENDOR_AND_INTERFACE_INFO(0x0e8d, 0xe0, 0x01, 0x01),
  336. .driver_info = BTUSB_MEDIATEK |
  337. BTUSB_WIDEBAND_SPEECH |
  338. BTUSB_VALID_LE_STATES },
  339. /* MediaTek MT7922A Bluetooth devices */
  340. { USB_DEVICE(0x0489, 0xe0d8), .driver_info = BTUSB_MEDIATEK |
  341. BTUSB_WIDEBAND_SPEECH |
  342. BTUSB_VALID_LE_STATES },
  343. { USB_DEVICE(0x0489, 0xe0d9), .driver_info = BTUSB_MEDIATEK |
  344. BTUSB_WIDEBAND_SPEECH |
  345. BTUSB_VALID_LE_STATES },
  346. /* Additional Realtek 8723AE Bluetooth devices */
  347. { USB_DEVICE(0x0930, 0x021d), .driver_info = BTUSB_REALTEK },
  348. { USB_DEVICE(0x13d3, 0x3394), .driver_info = BTUSB_REALTEK },
  349. /* Additional Realtek 8723BE Bluetooth devices */
  350. { USB_DEVICE(0x0489, 0xe085), .driver_info = BTUSB_REALTEK },
  351. { USB_DEVICE(0x0489, 0xe08b), .driver_info = BTUSB_REALTEK },
  352. { USB_DEVICE(0x13d3, 0x3410), .driver_info = BTUSB_REALTEK },
  353. { USB_DEVICE(0x13d3, 0x3416), .driver_info = BTUSB_REALTEK },
  354. { USB_DEVICE(0x13d3, 0x3459), .driver_info = BTUSB_REALTEK },
  355. { USB_DEVICE(0x13d3, 0x3494), .driver_info = BTUSB_REALTEK },
  356. /* Additional Realtek 8723BU Bluetooth devices */
  357. { USB_DEVICE(0x7392, 0xa611), .driver_info = BTUSB_REALTEK },
  358. /* Additional Realtek 8723DE Bluetooth devices */
  359. { USB_DEVICE(0x0bda, 0xb009), .driver_info = BTUSB_REALTEK },
  360. { USB_DEVICE(0x2ff8, 0xb011), .driver_info = BTUSB_REALTEK },
  361. /* Additional Realtek 8821AE Bluetooth devices */
  362. { USB_DEVICE(0x0b05, 0x17dc), .driver_info = BTUSB_REALTEK },
  363. { USB_DEVICE(0x13d3, 0x3414), .driver_info = BTUSB_REALTEK },
  364. { USB_DEVICE(0x13d3, 0x3458), .driver_info = BTUSB_REALTEK },
  365. { USB_DEVICE(0x13d3, 0x3461), .driver_info = BTUSB_REALTEK },
  366. { USB_DEVICE(0x13d3, 0x3462), .driver_info = BTUSB_REALTEK },
  367. /* Additional Realtek 8822BE Bluetooth devices */
  368. { USB_DEVICE(0x13d3, 0x3526), .driver_info = BTUSB_REALTEK },
  369. { USB_DEVICE(0x0b05, 0x185c), .driver_info = BTUSB_REALTEK },
  370. /* Additional Realtek 8822CE Bluetooth devices */
  371. { USB_DEVICE(0x04ca, 0x4005), .driver_info = BTUSB_REALTEK },
  372. { USB_DEVICE(0x13d3, 0x3548), .driver_info = BTUSB_REALTEK },
  373. /* Silicon Wave based devices */
  374. { USB_DEVICE(0x0c10, 0x0000), .driver_info = BTUSB_SWAVE },
  375. { } /* Terminating entry */
  376. };
  377. /* The Bluetooth USB module build into some devices needs to be reset on resume,
  378. * this is a problem with the platform (likely shutting off all power) not with
  379. * the module itself. So we use a DMI list to match known broken platforms.
  380. */
  381. static const struct dmi_system_id btusb_needs_reset_resume_table[] = {
  382. {
  383. /* Dell OptiPlex 3060 (QCA ROME device 0cf3:e007) */
  384. .matches = {
  385. DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
  386. DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 3060"),
  387. },
  388. },
  389. {
  390. /* Dell XPS 9360 (QCA ROME device 0cf3:e300) */
  391. .matches = {
  392. DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
  393. DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9360"),
  394. },
  395. },
  396. {
  397. /* Dell Inspiron 5565 (QCA ROME device 0cf3:e009) */
  398. .matches = {
  399. DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
  400. DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 5565"),
  401. },
  402. },
  403. {}
  404. };
  405. #define BTUSB_MAX_ISOC_FRAMES 10
  406. #define BTUSB_INTR_RUNNING 0
  407. #define BTUSB_BULK_RUNNING 1
  408. #define BTUSB_ISOC_RUNNING 2
  409. #define BTUSB_SUSPENDING 3
  410. #define BTUSB_DID_ISO_RESUME 4
  411. #define BTUSB_BOOTLOADER 5
  412. #define BTUSB_DOWNLOADING 6
  413. #define BTUSB_FIRMWARE_LOADED 7
  414. #define BTUSB_FIRMWARE_FAILED 8
  415. #define BTUSB_BOOTING 9
  416. #define BTUSB_DIAG_RUNNING 10
  417. #define BTUSB_OOB_WAKE_ENABLED 11
  418. #define BTUSB_HW_RESET_ACTIVE 12
  419. #define BTUSB_TX_WAIT_VND_EVT 13
  420. #define BTUSB_WAKEUP_DISABLE 14
  421. #define BTUSB_USE_ALT3_FOR_WBS 15
  422. struct btusb_data {
  423. struct hci_dev *hdev;
  424. struct usb_device *udev;
  425. struct usb_interface *intf;
  426. struct usb_interface *isoc;
  427. struct usb_interface *diag;
  428. unsigned isoc_ifnum;
  429. unsigned long flags;
  430. struct work_struct work;
  431. struct work_struct waker;
  432. struct usb_anchor deferred;
  433. struct usb_anchor tx_anchor;
  434. int tx_in_flight;
  435. spinlock_t txlock;
  436. struct usb_anchor intr_anchor;
  437. struct usb_anchor bulk_anchor;
  438. struct usb_anchor isoc_anchor;
  439. struct usb_anchor diag_anchor;
  440. struct usb_anchor ctrl_anchor;
  441. spinlock_t rxlock;
  442. struct sk_buff *evt_skb;
  443. struct sk_buff *acl_skb;
  444. struct sk_buff *sco_skb;
  445. struct usb_endpoint_descriptor *intr_ep;
  446. struct usb_endpoint_descriptor *bulk_tx_ep;
  447. struct usb_endpoint_descriptor *bulk_rx_ep;
  448. struct usb_endpoint_descriptor *isoc_tx_ep;
  449. struct usb_endpoint_descriptor *isoc_rx_ep;
  450. struct usb_endpoint_descriptor *diag_tx_ep;
  451. struct usb_endpoint_descriptor *diag_rx_ep;
  452. struct gpio_desc *reset_gpio;
  453. __u8 cmdreq_type;
  454. __u8 cmdreq;
  455. unsigned int sco_num;
  456. unsigned int air_mode;
  457. bool usb_alt6_packet_flow;
  458. int isoc_altsetting;
  459. int suspend_count;
  460. int (*recv_event)(struct hci_dev *hdev, struct sk_buff *skb);
  461. int (*recv_bulk)(struct btusb_data *data, void *buffer, int count);
  462. int (*setup_on_usb)(struct hci_dev *hdev);
  463. int oob_wake_irq; /* irq for out-of-band wake-on-bt */
  464. unsigned cmd_timeout_cnt;
  465. };
  466. static void btusb_intel_cmd_timeout(struct hci_dev *hdev)
  467. {
  468. struct btusb_data *data = hci_get_drvdata(hdev);
  469. struct gpio_desc *reset_gpio = data->reset_gpio;
  470. if (++data->cmd_timeout_cnt < 5)
  471. return;
  472. if (!reset_gpio) {
  473. bt_dev_err(hdev, "No way to reset. Ignoring and continuing");
  474. return;
  475. }
  476. /*
  477. * Toggle the hard reset line if the platform provides one. The reset
  478. * is going to yank the device off the USB and then replug. So doing
  479. * once is enough. The cleanup is handled correctly on the way out
  480. * (standard USB disconnect), and the new device is detected cleanly
  481. * and bound to the driver again like it should be.
  482. */
  483. if (test_and_set_bit(BTUSB_HW_RESET_ACTIVE, &data->flags)) {
  484. bt_dev_err(hdev, "last reset failed? Not resetting again");
  485. return;
  486. }
  487. bt_dev_err(hdev, "Initiating HW reset via gpio");
  488. gpiod_set_value_cansleep(reset_gpio, 1);
  489. msleep(100);
  490. gpiod_set_value_cansleep(reset_gpio, 0);
  491. }
  492. static void btusb_rtl_cmd_timeout(struct hci_dev *hdev)
  493. {
  494. struct btusb_data *data = hci_get_drvdata(hdev);
  495. struct gpio_desc *reset_gpio = data->reset_gpio;
  496. if (++data->cmd_timeout_cnt < 5)
  497. return;
  498. if (!reset_gpio) {
  499. bt_dev_err(hdev, "No gpio to reset Realtek device, ignoring");
  500. return;
  501. }
  502. /* Toggle the hard reset line. The Realtek device is going to
  503. * yank itself off the USB and then replug. The cleanup is handled
  504. * correctly on the way out (standard USB disconnect), and the new
  505. * device is detected cleanly and bound to the driver again like
  506. * it should be.
  507. */
  508. if (test_and_set_bit(BTUSB_HW_RESET_ACTIVE, &data->flags)) {
  509. bt_dev_err(hdev, "last reset failed? Not resetting again");
  510. return;
  511. }
  512. bt_dev_err(hdev, "Reset Realtek device via gpio");
  513. gpiod_set_value_cansleep(reset_gpio, 1);
  514. msleep(200);
  515. gpiod_set_value_cansleep(reset_gpio, 0);
  516. }
  517. static void btusb_qca_cmd_timeout(struct hci_dev *hdev)
  518. {
  519. struct btusb_data *data = hci_get_drvdata(hdev);
  520. int err;
  521. if (++data->cmd_timeout_cnt < 5)
  522. return;
  523. bt_dev_err(hdev, "Multiple cmd timeouts seen. Resetting usb device.");
  524. /* This is not an unbalanced PM reference since the device will reset */
  525. err = usb_autopm_get_interface(data->intf);
  526. if (!err)
  527. usb_queue_reset_device(data->intf);
  528. else
  529. bt_dev_err(hdev, "Failed usb_autopm_get_interface with %d", err);
  530. }
  531. static inline void btusb_free_frags(struct btusb_data *data)
  532. {
  533. unsigned long flags;
  534. spin_lock_irqsave(&data->rxlock, flags);
  535. kfree_skb(data->evt_skb);
  536. data->evt_skb = NULL;
  537. kfree_skb(data->acl_skb);
  538. data->acl_skb = NULL;
  539. kfree_skb(data->sco_skb);
  540. data->sco_skb = NULL;
  541. spin_unlock_irqrestore(&data->rxlock, flags);
  542. }
  543. static int btusb_recv_intr(struct btusb_data *data, void *buffer, int count)
  544. {
  545. struct sk_buff *skb;
  546. unsigned long flags;
  547. int err = 0;
  548. spin_lock_irqsave(&data->rxlock, flags);
  549. skb = data->evt_skb;
  550. while (count) {
  551. int len;
  552. if (!skb) {
  553. skb = bt_skb_alloc(HCI_MAX_EVENT_SIZE, GFP_ATOMIC);
  554. if (!skb) {
  555. err = -ENOMEM;
  556. break;
  557. }
  558. hci_skb_pkt_type(skb) = HCI_EVENT_PKT;
  559. hci_skb_expect(skb) = HCI_EVENT_HDR_SIZE;
  560. }
  561. len = min_t(uint, hci_skb_expect(skb), count);
  562. skb_put_data(skb, buffer, len);
  563. count -= len;
  564. buffer += len;
  565. hci_skb_expect(skb) -= len;
  566. if (skb->len == HCI_EVENT_HDR_SIZE) {
  567. /* Complete event header */
  568. hci_skb_expect(skb) = hci_event_hdr(skb)->plen;
  569. if (skb_tailroom(skb) < hci_skb_expect(skb)) {
  570. kfree_skb(skb);
  571. skb = NULL;
  572. err = -EILSEQ;
  573. break;
  574. }
  575. }
  576. if (!hci_skb_expect(skb)) {
  577. /* Complete frame */
  578. data->recv_event(data->hdev, skb);
  579. skb = NULL;
  580. }
  581. }
  582. data->evt_skb = skb;
  583. spin_unlock_irqrestore(&data->rxlock, flags);
  584. return err;
  585. }
  586. static int btusb_recv_bulk(struct btusb_data *data, void *buffer, int count)
  587. {
  588. struct sk_buff *skb;
  589. unsigned long flags;
  590. int err = 0;
  591. spin_lock_irqsave(&data->rxlock, flags);
  592. skb = data->acl_skb;
  593. while (count) {
  594. int len;
  595. if (!skb) {
  596. skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
  597. if (!skb) {
  598. err = -ENOMEM;
  599. break;
  600. }
  601. hci_skb_pkt_type(skb) = HCI_ACLDATA_PKT;
  602. hci_skb_expect(skb) = HCI_ACL_HDR_SIZE;
  603. }
  604. len = min_t(uint, hci_skb_expect(skb), count);
  605. skb_put_data(skb, buffer, len);
  606. count -= len;
  607. buffer += len;
  608. hci_skb_expect(skb) -= len;
  609. if (skb->len == HCI_ACL_HDR_SIZE) {
  610. __le16 dlen = hci_acl_hdr(skb)->dlen;
  611. /* Complete ACL header */
  612. hci_skb_expect(skb) = __le16_to_cpu(dlen);
  613. if (skb_tailroom(skb) < hci_skb_expect(skb)) {
  614. kfree_skb(skb);
  615. skb = NULL;
  616. err = -EILSEQ;
  617. break;
  618. }
  619. }
  620. if (!hci_skb_expect(skb)) {
  621. /* Complete frame */
  622. hci_recv_frame(data->hdev, skb);
  623. skb = NULL;
  624. }
  625. }
  626. data->acl_skb = skb;
  627. spin_unlock_irqrestore(&data->rxlock, flags);
  628. return err;
  629. }
  630. static int btusb_recv_isoc(struct btusb_data *data, void *buffer, int count)
  631. {
  632. struct sk_buff *skb;
  633. unsigned long flags;
  634. int err = 0;
  635. spin_lock_irqsave(&data->rxlock, flags);
  636. skb = data->sco_skb;
  637. while (count) {
  638. int len;
  639. if (!skb) {
  640. skb = bt_skb_alloc(HCI_MAX_SCO_SIZE, GFP_ATOMIC);
  641. if (!skb) {
  642. err = -ENOMEM;
  643. break;
  644. }
  645. hci_skb_pkt_type(skb) = HCI_SCODATA_PKT;
  646. hci_skb_expect(skb) = HCI_SCO_HDR_SIZE;
  647. }
  648. len = min_t(uint, hci_skb_expect(skb), count);
  649. skb_put_data(skb, buffer, len);
  650. count -= len;
  651. buffer += len;
  652. hci_skb_expect(skb) -= len;
  653. if (skb->len == HCI_SCO_HDR_SIZE) {
  654. /* Complete SCO header */
  655. hci_skb_expect(skb) = hci_sco_hdr(skb)->dlen;
  656. if (skb_tailroom(skb) < hci_skb_expect(skb)) {
  657. kfree_skb(skb);
  658. skb = NULL;
  659. err = -EILSEQ;
  660. break;
  661. }
  662. }
  663. if (!hci_skb_expect(skb)) {
  664. /* Complete frame */
  665. hci_recv_frame(data->hdev, skb);
  666. skb = NULL;
  667. }
  668. }
  669. data->sco_skb = skb;
  670. spin_unlock_irqrestore(&data->rxlock, flags);
  671. return err;
  672. }
  673. static void btusb_intr_complete(struct urb *urb)
  674. {
  675. struct hci_dev *hdev = urb->context;
  676. struct btusb_data *data = hci_get_drvdata(hdev);
  677. int err;
  678. BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
  679. urb->actual_length);
  680. if (!test_bit(HCI_RUNNING, &hdev->flags))
  681. return;
  682. if (urb->status == 0) {
  683. hdev->stat.byte_rx += urb->actual_length;
  684. if (btusb_recv_intr(data, urb->transfer_buffer,
  685. urb->actual_length) < 0) {
  686. bt_dev_err(hdev, "corrupted event packet");
  687. hdev->stat.err_rx++;
  688. }
  689. } else if (urb->status == -ENOENT) {
  690. /* Avoid suspend failed when usb_kill_urb */
  691. return;
  692. }
  693. if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
  694. return;
  695. usb_mark_last_busy(data->udev);
  696. usb_anchor_urb(urb, &data->intr_anchor);
  697. err = usb_submit_urb(urb, GFP_ATOMIC);
  698. if (err < 0) {
  699. /* -EPERM: urb is being killed;
  700. * -ENODEV: device got disconnected
  701. */
  702. if (err != -EPERM && err != -ENODEV)
  703. bt_dev_err(hdev, "urb %p failed to resubmit (%d)",
  704. urb, -err);
  705. usb_unanchor_urb(urb);
  706. }
  707. }
  708. static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)
  709. {
  710. struct btusb_data *data = hci_get_drvdata(hdev);
  711. struct urb *urb;
  712. unsigned char *buf;
  713. unsigned int pipe;
  714. int err, size;
  715. BT_DBG("%s", hdev->name);
  716. if (!data->intr_ep)
  717. return -ENODEV;
  718. urb = usb_alloc_urb(0, mem_flags);
  719. if (!urb)
  720. return -ENOMEM;
  721. size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
  722. buf = kmalloc(size, mem_flags);
  723. if (!buf) {
  724. usb_free_urb(urb);
  725. return -ENOMEM;
  726. }
  727. pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
  728. usb_fill_int_urb(urb, data->udev, pipe, buf, size,
  729. btusb_intr_complete, hdev, data->intr_ep->bInterval);
  730. urb->transfer_flags |= URB_FREE_BUFFER;
  731. usb_anchor_urb(urb, &data->intr_anchor);
  732. err = usb_submit_urb(urb, mem_flags);
  733. if (err < 0) {
  734. if (err != -EPERM && err != -ENODEV)
  735. bt_dev_err(hdev, "urb %p submission failed (%d)",
  736. urb, -err);
  737. usb_unanchor_urb(urb);
  738. }
  739. usb_free_urb(urb);
  740. return err;
  741. }
  742. static void btusb_bulk_complete(struct urb *urb)
  743. {
  744. struct hci_dev *hdev = urb->context;
  745. struct btusb_data *data = hci_get_drvdata(hdev);
  746. int err;
  747. BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
  748. urb->actual_length);
  749. if (!test_bit(HCI_RUNNING, &hdev->flags))
  750. return;
  751. if (urb->status == 0) {
  752. hdev->stat.byte_rx += urb->actual_length;
  753. if (data->recv_bulk(data, urb->transfer_buffer,
  754. urb->actual_length) < 0) {
  755. bt_dev_err(hdev, "corrupted ACL packet");
  756. hdev->stat.err_rx++;
  757. }
  758. } else if (urb->status == -ENOENT) {
  759. /* Avoid suspend failed when usb_kill_urb */
  760. return;
  761. }
  762. if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
  763. return;
  764. usb_anchor_urb(urb, &data->bulk_anchor);
  765. usb_mark_last_busy(data->udev);
  766. err = usb_submit_urb(urb, GFP_ATOMIC);
  767. if (err < 0) {
  768. /* -EPERM: urb is being killed;
  769. * -ENODEV: device got disconnected
  770. */
  771. if (err != -EPERM && err != -ENODEV)
  772. bt_dev_err(hdev, "urb %p failed to resubmit (%d)",
  773. urb, -err);
  774. usb_unanchor_urb(urb);
  775. }
  776. }
  777. static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)
  778. {
  779. struct btusb_data *data = hci_get_drvdata(hdev);
  780. struct urb *urb;
  781. unsigned char *buf;
  782. unsigned int pipe;
  783. int err, size = HCI_MAX_FRAME_SIZE;
  784. BT_DBG("%s", hdev->name);
  785. if (!data->bulk_rx_ep)
  786. return -ENODEV;
  787. urb = usb_alloc_urb(0, mem_flags);
  788. if (!urb)
  789. return -ENOMEM;
  790. buf = kmalloc(size, mem_flags);
  791. if (!buf) {
  792. usb_free_urb(urb);
  793. return -ENOMEM;
  794. }
  795. pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
  796. usb_fill_bulk_urb(urb, data->udev, pipe, buf, size,
  797. btusb_bulk_complete, hdev);
  798. urb->transfer_flags |= URB_FREE_BUFFER;
  799. usb_mark_last_busy(data->udev);
  800. usb_anchor_urb(urb, &data->bulk_anchor);
  801. err = usb_submit_urb(urb, mem_flags);
  802. if (err < 0) {
  803. if (err != -EPERM && err != -ENODEV)
  804. bt_dev_err(hdev, "urb %p submission failed (%d)",
  805. urb, -err);
  806. usb_unanchor_urb(urb);
  807. }
  808. usb_free_urb(urb);
  809. return err;
  810. }
  811. static void btusb_isoc_complete(struct urb *urb)
  812. {
  813. struct hci_dev *hdev = urb->context;
  814. struct btusb_data *data = hci_get_drvdata(hdev);
  815. int i, err;
  816. BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
  817. urb->actual_length);
  818. if (!test_bit(HCI_RUNNING, &hdev->flags))
  819. return;
  820. if (urb->status == 0) {
  821. for (i = 0; i < urb->number_of_packets; i++) {
  822. unsigned int offset = urb->iso_frame_desc[i].offset;
  823. unsigned int length = urb->iso_frame_desc[i].actual_length;
  824. if (urb->iso_frame_desc[i].status)
  825. continue;
  826. hdev->stat.byte_rx += length;
  827. if (btusb_recv_isoc(data, urb->transfer_buffer + offset,
  828. length) < 0) {
  829. bt_dev_err(hdev, "corrupted SCO packet");
  830. hdev->stat.err_rx++;
  831. }
  832. }
  833. } else if (urb->status == -ENOENT) {
  834. /* Avoid suspend failed when usb_kill_urb */
  835. return;
  836. }
  837. if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))
  838. return;
  839. usb_anchor_urb(urb, &data->isoc_anchor);
  840. err = usb_submit_urb(urb, GFP_ATOMIC);
  841. if (err < 0) {
  842. /* -EPERM: urb is being killed;
  843. * -ENODEV: device got disconnected
  844. */
  845. if (err != -EPERM && err != -ENODEV)
  846. bt_dev_err(hdev, "urb %p failed to resubmit (%d)",
  847. urb, -err);
  848. usb_unanchor_urb(urb);
  849. }
  850. }
  851. static inline void __fill_isoc_descriptor_msbc(struct urb *urb, int len,
  852. int mtu, struct btusb_data *data)
  853. {
  854. int i, offset = 0;
  855. unsigned int interval;
  856. BT_DBG("len %d mtu %d", len, mtu);
  857. /* For mSBC ALT 6 setting the host will send the packet at continuous
  858. * flow. As per core spec 5, vol 4, part B, table 2.1. For ALT setting
  859. * 6 the HCI PACKET INTERVAL should be 7.5ms for every usb packets.
  860. * To maintain the rate we send 63bytes of usb packets alternatively for
  861. * 7ms and 8ms to maintain the rate as 7.5ms.
  862. */
  863. if (data->usb_alt6_packet_flow) {
  864. interval = 7;
  865. data->usb_alt6_packet_flow = false;
  866. } else {
  867. interval = 6;
  868. data->usb_alt6_packet_flow = true;
  869. }
  870. for (i = 0; i < interval; i++) {
  871. urb->iso_frame_desc[i].offset = offset;
  872. urb->iso_frame_desc[i].length = offset;
  873. }
  874. if (len && i < BTUSB_MAX_ISOC_FRAMES) {
  875. urb->iso_frame_desc[i].offset = offset;
  876. urb->iso_frame_desc[i].length = len;
  877. i++;
  878. }
  879. urb->number_of_packets = i;
  880. }
  881. static inline void __fill_isoc_descriptor(struct urb *urb, int len, int mtu)
  882. {
  883. int i, offset = 0;
  884. BT_DBG("len %d mtu %d", len, mtu);
  885. for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;
  886. i++, offset += mtu, len -= mtu) {
  887. urb->iso_frame_desc[i].offset = offset;
  888. urb->iso_frame_desc[i].length = mtu;
  889. }
  890. if (len && i < BTUSB_MAX_ISOC_FRAMES) {
  891. urb->iso_frame_desc[i].offset = offset;
  892. urb->iso_frame_desc[i].length = len;
  893. i++;
  894. }
  895. urb->number_of_packets = i;
  896. }
  897. static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)
  898. {
  899. struct btusb_data *data = hci_get_drvdata(hdev);
  900. struct urb *urb;
  901. unsigned char *buf;
  902. unsigned int pipe;
  903. int err, size;
  904. BT_DBG("%s", hdev->name);
  905. if (!data->isoc_rx_ep)
  906. return -ENODEV;
  907. urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);
  908. if (!urb)
  909. return -ENOMEM;
  910. size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *
  911. BTUSB_MAX_ISOC_FRAMES;
  912. buf = kmalloc(size, mem_flags);
  913. if (!buf) {
  914. usb_free_urb(urb);
  915. return -ENOMEM;
  916. }
  917. pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);
  918. usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete,
  919. hdev, data->isoc_rx_ep->bInterval);
  920. urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP;
  921. __fill_isoc_descriptor(urb, size,
  922. le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));
  923. usb_anchor_urb(urb, &data->isoc_anchor);
  924. err = usb_submit_urb(urb, mem_flags);
  925. if (err < 0) {
  926. if (err != -EPERM && err != -ENODEV)
  927. bt_dev_err(hdev, "urb %p submission failed (%d)",
  928. urb, -err);
  929. usb_unanchor_urb(urb);
  930. }
  931. usb_free_urb(urb);
  932. return err;
  933. }
  934. static void btusb_diag_complete(struct urb *urb)
  935. {
  936. struct hci_dev *hdev = urb->context;
  937. struct btusb_data *data = hci_get_drvdata(hdev);
  938. int err;
  939. BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
  940. urb->actual_length);
  941. if (urb->status == 0) {
  942. struct sk_buff *skb;
  943. skb = bt_skb_alloc(urb->actual_length, GFP_ATOMIC);
  944. if (skb) {
  945. skb_put_data(skb, urb->transfer_buffer,
  946. urb->actual_length);
  947. hci_recv_diag(hdev, skb);
  948. }
  949. } else if (urb->status == -ENOENT) {
  950. /* Avoid suspend failed when usb_kill_urb */
  951. return;
  952. }
  953. if (!test_bit(BTUSB_DIAG_RUNNING, &data->flags))
  954. return;
  955. usb_anchor_urb(urb, &data->diag_anchor);
  956. usb_mark_last_busy(data->udev);
  957. err = usb_submit_urb(urb, GFP_ATOMIC);
  958. if (err < 0) {
  959. /* -EPERM: urb is being killed;
  960. * -ENODEV: device got disconnected
  961. */
  962. if (err != -EPERM && err != -ENODEV)
  963. bt_dev_err(hdev, "urb %p failed to resubmit (%d)",
  964. urb, -err);
  965. usb_unanchor_urb(urb);
  966. }
  967. }
  968. static int btusb_submit_diag_urb(struct hci_dev *hdev, gfp_t mem_flags)
  969. {
  970. struct btusb_data *data = hci_get_drvdata(hdev);
  971. struct urb *urb;
  972. unsigned char *buf;
  973. unsigned int pipe;
  974. int err, size = HCI_MAX_FRAME_SIZE;
  975. BT_DBG("%s", hdev->name);
  976. if (!data->diag_rx_ep)
  977. return -ENODEV;
  978. urb = usb_alloc_urb(0, mem_flags);
  979. if (!urb)
  980. return -ENOMEM;
  981. buf = kmalloc(size, mem_flags);
  982. if (!buf) {
  983. usb_free_urb(urb);
  984. return -ENOMEM;
  985. }
  986. pipe = usb_rcvbulkpipe(data->udev, data->diag_rx_ep->bEndpointAddress);
  987. usb_fill_bulk_urb(urb, data->udev, pipe, buf, size,
  988. btusb_diag_complete, hdev);
  989. urb->transfer_flags |= URB_FREE_BUFFER;
  990. usb_mark_last_busy(data->udev);
  991. usb_anchor_urb(urb, &data->diag_anchor);
  992. err = usb_submit_urb(urb, mem_flags);
  993. if (err < 0) {
  994. if (err != -EPERM && err != -ENODEV)
  995. bt_dev_err(hdev, "urb %p submission failed (%d)",
  996. urb, -err);
  997. usb_unanchor_urb(urb);
  998. }
  999. usb_free_urb(urb);
  1000. return err;
  1001. }
  1002. static void btusb_tx_complete(struct urb *urb)
  1003. {
  1004. struct sk_buff *skb = urb->context;
  1005. struct hci_dev *hdev = (struct hci_dev *)skb->dev;
  1006. struct btusb_data *data = hci_get_drvdata(hdev);
  1007. unsigned long flags;
  1008. BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
  1009. urb->actual_length);
  1010. if (!test_bit(HCI_RUNNING, &hdev->flags))
  1011. goto done;
  1012. if (!urb->status)
  1013. hdev->stat.byte_tx += urb->transfer_buffer_length;
  1014. else
  1015. hdev->stat.err_tx++;
  1016. done:
  1017. spin_lock_irqsave(&data->txlock, flags);
  1018. data->tx_in_flight--;
  1019. spin_unlock_irqrestore(&data->txlock, flags);
  1020. kfree(urb->setup_packet);
  1021. kfree_skb(skb);
  1022. }
  1023. static void btusb_isoc_tx_complete(struct urb *urb)
  1024. {
  1025. struct sk_buff *skb = urb->context;
  1026. struct hci_dev *hdev = (struct hci_dev *)skb->dev;
  1027. BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
  1028. urb->actual_length);
  1029. if (!test_bit(HCI_RUNNING, &hdev->flags))
  1030. goto done;
  1031. if (!urb->status)
  1032. hdev->stat.byte_tx += urb->transfer_buffer_length;
  1033. else
  1034. hdev->stat.err_tx++;
  1035. done:
  1036. kfree(urb->setup_packet);
  1037. kfree_skb(skb);
  1038. }
  1039. static int btusb_open(struct hci_dev *hdev)
  1040. {
  1041. struct btusb_data *data = hci_get_drvdata(hdev);
  1042. int err;
  1043. BT_DBG("%s", hdev->name);
  1044. err = usb_autopm_get_interface(data->intf);
  1045. if (err < 0)
  1046. return err;
  1047. /* Patching USB firmware files prior to starting any URBs of HCI path
  1048. * It is more safe to use USB bulk channel for downloading USB patch
  1049. */
  1050. if (data->setup_on_usb) {
  1051. err = data->setup_on_usb(hdev);
  1052. if (err < 0)
  1053. goto setup_fail;
  1054. }
  1055. data->intf->needs_remote_wakeup = 1;
  1056. /* Disable device remote wakeup when host is suspended
  1057. * For Realtek chips, global suspend without
  1058. * SET_FEATURE (DEVICE_REMOTE_WAKEUP) can save more power in device.
  1059. */
  1060. if (test_bit(BTUSB_WAKEUP_DISABLE, &data->flags))
  1061. device_wakeup_disable(&data->udev->dev);
  1062. if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
  1063. goto done;
  1064. err = btusb_submit_intr_urb(hdev, GFP_KERNEL);
  1065. if (err < 0)
  1066. goto failed;
  1067. err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);
  1068. if (err < 0) {
  1069. usb_kill_anchored_urbs(&data->intr_anchor);
  1070. goto failed;
  1071. }
  1072. set_bit(BTUSB_BULK_RUNNING, &data->flags);
  1073. btusb_submit_bulk_urb(hdev, GFP_KERNEL);
  1074. if (data->diag) {
  1075. if (!btusb_submit_diag_urb(hdev, GFP_KERNEL))
  1076. set_bit(BTUSB_DIAG_RUNNING, &data->flags);
  1077. }
  1078. done:
  1079. usb_autopm_put_interface(data->intf);
  1080. return 0;
  1081. failed:
  1082. clear_bit(BTUSB_INTR_RUNNING, &data->flags);
  1083. setup_fail:
  1084. usb_autopm_put_interface(data->intf);
  1085. return err;
  1086. }
  1087. static void btusb_stop_traffic(struct btusb_data *data)
  1088. {
  1089. usb_kill_anchored_urbs(&data->intr_anchor);
  1090. usb_kill_anchored_urbs(&data->bulk_anchor);
  1091. usb_kill_anchored_urbs(&data->isoc_anchor);
  1092. usb_kill_anchored_urbs(&data->diag_anchor);
  1093. usb_kill_anchored_urbs(&data->ctrl_anchor);
  1094. }
  1095. static int btusb_close(struct hci_dev *hdev)
  1096. {
  1097. struct btusb_data *data = hci_get_drvdata(hdev);
  1098. int err;
  1099. BT_DBG("%s", hdev->name);
  1100. cancel_work_sync(&data->work);
  1101. cancel_work_sync(&data->waker);
  1102. clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
  1103. clear_bit(BTUSB_BULK_RUNNING, &data->flags);
  1104. clear_bit(BTUSB_INTR_RUNNING, &data->flags);
  1105. clear_bit(BTUSB_DIAG_RUNNING, &data->flags);
  1106. btusb_stop_traffic(data);
  1107. btusb_free_frags(data);
  1108. err = usb_autopm_get_interface(data->intf);
  1109. if (err < 0)
  1110. goto failed;
  1111. data->intf->needs_remote_wakeup = 0;
  1112. /* Enable remote wake up for auto-suspend */
  1113. if (test_bit(BTUSB_WAKEUP_DISABLE, &data->flags))
  1114. data->intf->needs_remote_wakeup = 1;
  1115. usb_autopm_put_interface(data->intf);
  1116. failed:
  1117. usb_scuttle_anchored_urbs(&data->deferred);
  1118. return 0;
  1119. }
  1120. static int btusb_flush(struct hci_dev *hdev)
  1121. {
  1122. struct btusb_data *data = hci_get_drvdata(hdev);
  1123. BT_DBG("%s", hdev->name);
  1124. usb_kill_anchored_urbs(&data->tx_anchor);
  1125. btusb_free_frags(data);
  1126. return 0;
  1127. }
  1128. static struct urb *alloc_ctrl_urb(struct hci_dev *hdev, struct sk_buff *skb)
  1129. {
  1130. struct btusb_data *data = hci_get_drvdata(hdev);
  1131. struct usb_ctrlrequest *dr;
  1132. struct urb *urb;
  1133. unsigned int pipe;
  1134. urb = usb_alloc_urb(0, GFP_KERNEL);
  1135. if (!urb)
  1136. return ERR_PTR(-ENOMEM);
  1137. dr = kmalloc(sizeof(*dr), GFP_KERNEL);
  1138. if (!dr) {
  1139. usb_free_urb(urb);
  1140. return ERR_PTR(-ENOMEM);
  1141. }
  1142. dr->bRequestType = data->cmdreq_type;
  1143. dr->bRequest = data->cmdreq;
  1144. dr->wIndex = 0;
  1145. dr->wValue = 0;
  1146. dr->wLength = __cpu_to_le16(skb->len);
  1147. pipe = usb_sndctrlpipe(data->udev, 0x00);
  1148. usb_fill_control_urb(urb, data->udev, pipe, (void *)dr,
  1149. skb->data, skb->len, btusb_tx_complete, skb);
  1150. skb->dev = (void *)hdev;
  1151. return urb;
  1152. }
  1153. static struct urb *alloc_bulk_urb(struct hci_dev *hdev, struct sk_buff *skb)
  1154. {
  1155. struct btusb_data *data = hci_get_drvdata(hdev);
  1156. struct urb *urb;
  1157. unsigned int pipe;
  1158. if (!data->bulk_tx_ep)
  1159. return ERR_PTR(-ENODEV);
  1160. urb = usb_alloc_urb(0, GFP_KERNEL);
  1161. if (!urb)
  1162. return ERR_PTR(-ENOMEM);
  1163. pipe = usb_sndbulkpipe(data->udev, data->bulk_tx_ep->bEndpointAddress);
  1164. usb_fill_bulk_urb(urb, data->udev, pipe,
  1165. skb->data, skb->len, btusb_tx_complete, skb);
  1166. skb->dev = (void *)hdev;
  1167. return urb;
  1168. }
  1169. static struct urb *alloc_isoc_urb(struct hci_dev *hdev, struct sk_buff *skb)
  1170. {
  1171. struct btusb_data *data = hci_get_drvdata(hdev);
  1172. struct urb *urb;
  1173. unsigned int pipe;
  1174. if (!data->isoc_tx_ep)
  1175. return ERR_PTR(-ENODEV);
  1176. urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_KERNEL);
  1177. if (!urb)
  1178. return ERR_PTR(-ENOMEM);
  1179. pipe = usb_sndisocpipe(data->udev, data->isoc_tx_ep->bEndpointAddress);
  1180. usb_fill_int_urb(urb, data->udev, pipe,
  1181. skb->data, skb->len, btusb_isoc_tx_complete,
  1182. skb, data->isoc_tx_ep->bInterval);
  1183. urb->transfer_flags = URB_ISO_ASAP;
  1184. if (data->isoc_altsetting == 6)
  1185. __fill_isoc_descriptor_msbc(urb, skb->len,
  1186. le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize),
  1187. data);
  1188. else
  1189. __fill_isoc_descriptor(urb, skb->len,
  1190. le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));
  1191. skb->dev = (void *)hdev;
  1192. return urb;
  1193. }
  1194. static int submit_tx_urb(struct hci_dev *hdev, struct urb *urb)
  1195. {
  1196. struct btusb_data *data = hci_get_drvdata(hdev);
  1197. int err;
  1198. usb_anchor_urb(urb, &data->tx_anchor);
  1199. err = usb_submit_urb(urb, GFP_KERNEL);
  1200. if (err < 0) {
  1201. if (err != -EPERM && err != -ENODEV)
  1202. bt_dev_err(hdev, "urb %p submission failed (%d)",
  1203. urb, -err);
  1204. kfree(urb->setup_packet);
  1205. usb_unanchor_urb(urb);
  1206. } else {
  1207. usb_mark_last_busy(data->udev);
  1208. }
  1209. usb_free_urb(urb);
  1210. return err;
  1211. }
  1212. static int submit_or_queue_tx_urb(struct hci_dev *hdev, struct urb *urb)
  1213. {
  1214. struct btusb_data *data = hci_get_drvdata(hdev);
  1215. unsigned long flags;
  1216. bool suspending;
  1217. spin_lock_irqsave(&data->txlock, flags);
  1218. suspending = test_bit(BTUSB_SUSPENDING, &data->flags);
  1219. if (!suspending)
  1220. data->tx_in_flight++;
  1221. spin_unlock_irqrestore(&data->txlock, flags);
  1222. if (!suspending)
  1223. return submit_tx_urb(hdev, urb);
  1224. usb_anchor_urb(urb, &data->deferred);
  1225. schedule_work(&data->waker);
  1226. usb_free_urb(urb);
  1227. return 0;
  1228. }
  1229. static int btusb_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
  1230. {
  1231. struct urb *urb;
  1232. BT_DBG("%s", hdev->name);
  1233. switch (hci_skb_pkt_type(skb)) {
  1234. case HCI_COMMAND_PKT:
  1235. urb = alloc_ctrl_urb(hdev, skb);
  1236. if (IS_ERR(urb))
  1237. return PTR_ERR(urb);
  1238. hdev->stat.cmd_tx++;
  1239. return submit_or_queue_tx_urb(hdev, urb);
  1240. case HCI_ACLDATA_PKT:
  1241. urb = alloc_bulk_urb(hdev, skb);
  1242. if (IS_ERR(urb))
  1243. return PTR_ERR(urb);
  1244. hdev->stat.acl_tx++;
  1245. return submit_or_queue_tx_urb(hdev, urb);
  1246. case HCI_SCODATA_PKT:
  1247. if (hci_conn_num(hdev, SCO_LINK) < 1)
  1248. return -ENODEV;
  1249. urb = alloc_isoc_urb(hdev, skb);
  1250. if (IS_ERR(urb))
  1251. return PTR_ERR(urb);
  1252. hdev->stat.sco_tx++;
  1253. return submit_tx_urb(hdev, urb);
  1254. }
  1255. return -EILSEQ;
  1256. }
  1257. static void btusb_notify(struct hci_dev *hdev, unsigned int evt)
  1258. {
  1259. struct btusb_data *data = hci_get_drvdata(hdev);
  1260. BT_DBG("%s evt %d", hdev->name, evt);
  1261. if (hci_conn_num(hdev, SCO_LINK) != data->sco_num) {
  1262. data->sco_num = hci_conn_num(hdev, SCO_LINK);
  1263. data->air_mode = evt;
  1264. schedule_work(&data->work);
  1265. }
  1266. }
  1267. static inline int __set_isoc_interface(struct hci_dev *hdev, int altsetting)
  1268. {
  1269. struct btusb_data *data = hci_get_drvdata(hdev);
  1270. struct usb_interface *intf = data->isoc;
  1271. struct usb_endpoint_descriptor *ep_desc;
  1272. int i, err;
  1273. if (!data->isoc)
  1274. return -ENODEV;
  1275. err = usb_set_interface(data->udev, data->isoc_ifnum, altsetting);
  1276. if (err < 0) {
  1277. bt_dev_err(hdev, "setting interface failed (%d)", -err);
  1278. return err;
  1279. }
  1280. data->isoc_altsetting = altsetting;
  1281. data->isoc_tx_ep = NULL;
  1282. data->isoc_rx_ep = NULL;
  1283. for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
  1284. ep_desc = &intf->cur_altsetting->endpoint[i].desc;
  1285. if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {
  1286. data->isoc_tx_ep = ep_desc;
  1287. continue;
  1288. }
  1289. if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {
  1290. data->isoc_rx_ep = ep_desc;
  1291. continue;
  1292. }
  1293. }
  1294. if (!data->isoc_tx_ep || !data->isoc_rx_ep) {
  1295. bt_dev_err(hdev, "invalid SCO descriptors");
  1296. return -ENODEV;
  1297. }
  1298. return 0;
  1299. }
  1300. static int btusb_switch_alt_setting(struct hci_dev *hdev, int new_alts)
  1301. {
  1302. struct btusb_data *data = hci_get_drvdata(hdev);
  1303. int err;
  1304. if (data->isoc_altsetting != new_alts) {
  1305. unsigned long flags;
  1306. clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
  1307. usb_kill_anchored_urbs(&data->isoc_anchor);
  1308. /* When isochronous alternate setting needs to be
  1309. * changed, because SCO connection has been added
  1310. * or removed, a packet fragment may be left in the
  1311. * reassembling state. This could lead to wrongly
  1312. * assembled fragments.
  1313. *
  1314. * Clear outstanding fragment when selecting a new
  1315. * alternate setting.
  1316. */
  1317. spin_lock_irqsave(&data->rxlock, flags);
  1318. kfree_skb(data->sco_skb);
  1319. data->sco_skb = NULL;
  1320. spin_unlock_irqrestore(&data->rxlock, flags);
  1321. err = __set_isoc_interface(hdev, new_alts);
  1322. if (err < 0)
  1323. return err;
  1324. }
  1325. if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
  1326. if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)
  1327. clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
  1328. else
  1329. btusb_submit_isoc_urb(hdev, GFP_KERNEL);
  1330. }
  1331. return 0;
  1332. }
  1333. static struct usb_host_interface *btusb_find_altsetting(struct btusb_data *data,
  1334. int alt)
  1335. {
  1336. struct usb_interface *intf = data->isoc;
  1337. int i;
  1338. BT_DBG("Looking for Alt no :%d", alt);
  1339. if (!intf)
  1340. return NULL;
  1341. for (i = 0; i < intf->num_altsetting; i++) {
  1342. if (intf->altsetting[i].desc.bAlternateSetting == alt)
  1343. return &intf->altsetting[i];
  1344. }
  1345. return NULL;
  1346. }
  1347. static void btusb_work(struct work_struct *work)
  1348. {
  1349. struct btusb_data *data = container_of(work, struct btusb_data, work);
  1350. struct hci_dev *hdev = data->hdev;
  1351. int new_alts = 0;
  1352. int err;
  1353. if (data->sco_num > 0) {
  1354. if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {
  1355. err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf);
  1356. if (err < 0) {
  1357. clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
  1358. usb_kill_anchored_urbs(&data->isoc_anchor);
  1359. return;
  1360. }
  1361. set_bit(BTUSB_DID_ISO_RESUME, &data->flags);
  1362. }
  1363. if (data->air_mode == HCI_NOTIFY_ENABLE_SCO_CVSD) {
  1364. if (hdev->voice_setting & 0x0020) {
  1365. static const int alts[3] = { 2, 4, 5 };
  1366. new_alts = alts[data->sco_num - 1];
  1367. } else {
  1368. new_alts = data->sco_num;
  1369. }
  1370. } else if (data->air_mode == HCI_NOTIFY_ENABLE_SCO_TRANSP) {
  1371. /* Bluetooth USB spec recommends alt 6 (63 bytes), but
  1372. * many adapters do not support it. Alt 1 appears to
  1373. * work for all adapters that do not have alt 6, and
  1374. * which work with WBS at all. Some devices prefer
  1375. * alt 3 (HCI payload >= 60 Bytes let air packet
  1376. * data satisfy 60 bytes), requiring
  1377. * MTU >= 3 (packets) * 25 (size) - 3 (headers) = 72
  1378. * see also Core spec 5, vol 4, B 2.1.1 & Table 2.1.
  1379. */
  1380. if (btusb_find_altsetting(data, 6))
  1381. new_alts = 6;
  1382. else if (btusb_find_altsetting(data, 3) &&
  1383. hdev->sco_mtu >= 72 &&
  1384. test_bit(BTUSB_USE_ALT3_FOR_WBS, &data->flags))
  1385. new_alts = 3;
  1386. else
  1387. new_alts = 1;
  1388. }
  1389. if (btusb_switch_alt_setting(hdev, new_alts) < 0)
  1390. bt_dev_err(hdev, "set USB alt:(%d) failed!", new_alts);
  1391. } else {
  1392. clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
  1393. usb_kill_anchored_urbs(&data->isoc_anchor);
  1394. __set_isoc_interface(hdev, 0);
  1395. if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))
  1396. usb_autopm_put_interface(data->isoc ? data->isoc : data->intf);
  1397. }
  1398. }
  1399. static void btusb_waker(struct work_struct *work)
  1400. {
  1401. struct btusb_data *data = container_of(work, struct btusb_data, waker);
  1402. int err;
  1403. err = usb_autopm_get_interface(data->intf);
  1404. if (err < 0)
  1405. return;
  1406. usb_autopm_put_interface(data->intf);
  1407. }
  1408. static int btusb_setup_bcm92035(struct hci_dev *hdev)
  1409. {
  1410. struct sk_buff *skb;
  1411. u8 val = 0x00;
  1412. BT_DBG("%s", hdev->name);
  1413. skb = __hci_cmd_sync(hdev, 0xfc3b, 1, &val, HCI_INIT_TIMEOUT);
  1414. if (IS_ERR(skb))
  1415. bt_dev_err(hdev, "BCM92035 command failed (%ld)", PTR_ERR(skb));
  1416. else
  1417. kfree_skb(skb);
  1418. return 0;
  1419. }
  1420. static int btusb_setup_csr(struct hci_dev *hdev)
  1421. {
  1422. struct btusb_data *data = hci_get_drvdata(hdev);
  1423. u16 bcdDevice = le16_to_cpu(data->udev->descriptor.bcdDevice);
  1424. struct hci_rp_read_local_version *rp;
  1425. struct sk_buff *skb;
  1426. bool is_fake = false;
  1427. BT_DBG("%s", hdev->name);
  1428. skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
  1429. HCI_INIT_TIMEOUT);
  1430. if (IS_ERR(skb)) {
  1431. int err = PTR_ERR(skb);
  1432. bt_dev_err(hdev, "CSR: Local version failed (%d)", err);
  1433. return err;
  1434. }
  1435. if (skb->len != sizeof(struct hci_rp_read_local_version)) {
  1436. bt_dev_err(hdev, "CSR: Local version length mismatch");
  1437. kfree_skb(skb);
  1438. return -EIO;
  1439. }
  1440. rp = (struct hci_rp_read_local_version *)skb->data;
  1441. /* Detect a wide host of Chinese controllers that aren't CSR.
  1442. *
  1443. * Known fake bcdDevices: 0x0100, 0x0134, 0x1915, 0x2520, 0x7558, 0x8891
  1444. *
  1445. * The main thing they have in common is that these are really popular low-cost
  1446. * options that support newer Bluetooth versions but rely on heavy VID/PID
  1447. * squatting of this poor old Bluetooth 1.1 device. Even sold as such.
  1448. *
  1449. * We detect actual CSR devices by checking that the HCI manufacturer code
  1450. * is Cambridge Silicon Radio (10) and ensuring that LMP sub-version and
  1451. * HCI rev values always match. As they both store the firmware number.
  1452. */
  1453. if (le16_to_cpu(rp->manufacturer) != 10 ||
  1454. le16_to_cpu(rp->hci_rev) != le16_to_cpu(rp->lmp_subver))
  1455. is_fake = true;
  1456. /* Known legit CSR firmware build numbers and their supported BT versions:
  1457. * - 1.1 (0x1) -> 0x0073, 0x020d, 0x033c, 0x034e
  1458. * - 1.2 (0x2) -> 0x04d9, 0x0529
  1459. * - 2.0 (0x3) -> 0x07a6, 0x07ad, 0x0c5c
  1460. * - 2.1 (0x4) -> 0x149c, 0x1735, 0x1899 (0x1899 is a BlueCore4-External)
  1461. * - 4.0 (0x6) -> 0x1d86, 0x2031, 0x22bb
  1462. *
  1463. * e.g. Real CSR dongles with LMP subversion 0x73 are old enough that
  1464. * support BT 1.1 only; so it's a dead giveaway when some
  1465. * third-party BT 4.0 dongle reuses it.
  1466. */
  1467. else if (le16_to_cpu(rp->lmp_subver) <= 0x034e &&
  1468. le16_to_cpu(rp->hci_ver) > BLUETOOTH_VER_1_1)
  1469. is_fake = true;
  1470. else if (le16_to_cpu(rp->lmp_subver) <= 0x0529 &&
  1471. le16_to_cpu(rp->hci_ver) > BLUETOOTH_VER_1_2)
  1472. is_fake = true;
  1473. else if (le16_to_cpu(rp->lmp_subver) <= 0x0c5c &&
  1474. le16_to_cpu(rp->hci_ver) > BLUETOOTH_VER_2_0)
  1475. is_fake = true;
  1476. else if (le16_to_cpu(rp->lmp_subver) <= 0x1899 &&
  1477. le16_to_cpu(rp->hci_ver) > BLUETOOTH_VER_2_1)
  1478. is_fake = true;
  1479. else if (le16_to_cpu(rp->lmp_subver) <= 0x22bb &&
  1480. le16_to_cpu(rp->hci_ver) > BLUETOOTH_VER_4_0)
  1481. is_fake = true;
  1482. /* Other clones which beat all the above checks */
  1483. else if (bcdDevice == 0x0134 &&
  1484. le16_to_cpu(rp->lmp_subver) == 0x0c5c &&
  1485. le16_to_cpu(rp->hci_ver) == BLUETOOTH_VER_2_0)
  1486. is_fake = true;
  1487. if (is_fake) {
  1488. bt_dev_warn(hdev, "CSR: Unbranded CSR clone detected; adding workarounds...");
  1489. /* Generally these clones have big discrepancies between
  1490. * advertised features and what's actually supported.
  1491. * Probably will need to be expanded in the future;
  1492. * without these the controller will lock up.
  1493. */
  1494. set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks);
  1495. set_bit(HCI_QUIRK_BROKEN_ERR_DATA_REPORTING, &hdev->quirks);
  1496. /* Clear the reset quirk since this is not an actual
  1497. * early Bluetooth 1.1 device from CSR.
  1498. */
  1499. clear_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
  1500. clear_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
  1501. }
  1502. kfree_skb(skb);
  1503. return 0;
  1504. }
  1505. static const struct firmware *btusb_setup_intel_get_fw(struct hci_dev *hdev,
  1506. struct intel_version *ver)
  1507. {
  1508. const struct firmware *fw;
  1509. char fwname[64];
  1510. int ret;
  1511. snprintf(fwname, sizeof(fwname),
  1512. "intel/ibt-hw-%x.%x.%x-fw-%x.%x.%x.%x.%x.bseq",
  1513. ver->hw_platform, ver->hw_variant, ver->hw_revision,
  1514. ver->fw_variant, ver->fw_revision, ver->fw_build_num,
  1515. ver->fw_build_ww, ver->fw_build_yy);
  1516. ret = request_firmware(&fw, fwname, &hdev->dev);
  1517. if (ret < 0) {
  1518. if (ret == -EINVAL) {
  1519. bt_dev_err(hdev, "Intel firmware file request failed (%d)",
  1520. ret);
  1521. return NULL;
  1522. }
  1523. bt_dev_err(hdev, "failed to open Intel firmware file: %s (%d)",
  1524. fwname, ret);
  1525. /* If the correct firmware patch file is not found, use the
  1526. * default firmware patch file instead
  1527. */
  1528. snprintf(fwname, sizeof(fwname), "intel/ibt-hw-%x.%x.bseq",
  1529. ver->hw_platform, ver->hw_variant);
  1530. if (request_firmware(&fw, fwname, &hdev->dev) < 0) {
  1531. bt_dev_err(hdev, "failed to open default fw file: %s",
  1532. fwname);
  1533. return NULL;
  1534. }
  1535. }
  1536. bt_dev_info(hdev, "Intel Bluetooth firmware file: %s", fwname);
  1537. return fw;
  1538. }
  1539. static int btusb_setup_intel_patching(struct hci_dev *hdev,
  1540. const struct firmware *fw,
  1541. const u8 **fw_ptr, int *disable_patch)
  1542. {
  1543. struct sk_buff *skb;
  1544. struct hci_command_hdr *cmd;
  1545. const u8 *cmd_param;
  1546. struct hci_event_hdr *evt = NULL;
  1547. const u8 *evt_param = NULL;
  1548. int remain = fw->size - (*fw_ptr - fw->data);
  1549. /* The first byte indicates the types of the patch command or event.
  1550. * 0x01 means HCI command and 0x02 is HCI event. If the first bytes
  1551. * in the current firmware buffer doesn't start with 0x01 or
  1552. * the size of remain buffer is smaller than HCI command header,
  1553. * the firmware file is corrupted and it should stop the patching
  1554. * process.
  1555. */
  1556. if (remain > HCI_COMMAND_HDR_SIZE && *fw_ptr[0] != 0x01) {
  1557. bt_dev_err(hdev, "Intel fw corrupted: invalid cmd read");
  1558. return -EINVAL;
  1559. }
  1560. (*fw_ptr)++;
  1561. remain--;
  1562. cmd = (struct hci_command_hdr *)(*fw_ptr);
  1563. *fw_ptr += sizeof(*cmd);
  1564. remain -= sizeof(*cmd);
  1565. /* Ensure that the remain firmware data is long enough than the length
  1566. * of command parameter. If not, the firmware file is corrupted.
  1567. */
  1568. if (remain < cmd->plen) {
  1569. bt_dev_err(hdev, "Intel fw corrupted: invalid cmd len");
  1570. return -EFAULT;
  1571. }
  1572. /* If there is a command that loads a patch in the firmware
  1573. * file, then enable the patch upon success, otherwise just
  1574. * disable the manufacturer mode, for example patch activation
  1575. * is not required when the default firmware patch file is used
  1576. * because there are no patch data to load.
  1577. */
  1578. if (*disable_patch && le16_to_cpu(cmd->opcode) == 0xfc8e)
  1579. *disable_patch = 0;
  1580. cmd_param = *fw_ptr;
  1581. *fw_ptr += cmd->plen;
  1582. remain -= cmd->plen;
  1583. /* This reads the expected events when the above command is sent to the
  1584. * device. Some vendor commands expects more than one events, for
  1585. * example command status event followed by vendor specific event.
  1586. * For this case, it only keeps the last expected event. so the command
  1587. * can be sent with __hci_cmd_sync_ev() which returns the sk_buff of
  1588. * last expected event.
  1589. */
  1590. while (remain > HCI_EVENT_HDR_SIZE && *fw_ptr[0] == 0x02) {
  1591. (*fw_ptr)++;
  1592. remain--;
  1593. evt = (struct hci_event_hdr *)(*fw_ptr);
  1594. *fw_ptr += sizeof(*evt);
  1595. remain -= sizeof(*evt);
  1596. if (remain < evt->plen) {
  1597. bt_dev_err(hdev, "Intel fw corrupted: invalid evt len");
  1598. return -EFAULT;
  1599. }
  1600. evt_param = *fw_ptr;
  1601. *fw_ptr += evt->plen;
  1602. remain -= evt->plen;
  1603. }
  1604. /* Every HCI commands in the firmware file has its correspond event.
  1605. * If event is not found or remain is smaller than zero, the firmware
  1606. * file is corrupted.
  1607. */
  1608. if (!evt || !evt_param || remain < 0) {
  1609. bt_dev_err(hdev, "Intel fw corrupted: invalid evt read");
  1610. return -EFAULT;
  1611. }
  1612. skb = __hci_cmd_sync_ev(hdev, le16_to_cpu(cmd->opcode), cmd->plen,
  1613. cmd_param, evt->evt, HCI_INIT_TIMEOUT);
  1614. if (IS_ERR(skb)) {
  1615. bt_dev_err(hdev, "sending Intel patch command (0x%4.4x) failed (%ld)",
  1616. cmd->opcode, PTR_ERR(skb));
  1617. return PTR_ERR(skb);
  1618. }
  1619. /* It ensures that the returned event matches the event data read from
  1620. * the firmware file. At fist, it checks the length and then
  1621. * the contents of the event.
  1622. */
  1623. if (skb->len != evt->plen) {
  1624. bt_dev_err(hdev, "mismatch event length (opcode 0x%4.4x)",
  1625. le16_to_cpu(cmd->opcode));
  1626. kfree_skb(skb);
  1627. return -EFAULT;
  1628. }
  1629. if (memcmp(skb->data, evt_param, evt->plen)) {
  1630. bt_dev_err(hdev, "mismatch event parameter (opcode 0x%4.4x)",
  1631. le16_to_cpu(cmd->opcode));
  1632. kfree_skb(skb);
  1633. return -EFAULT;
  1634. }
  1635. kfree_skb(skb);
  1636. return 0;
  1637. }
  1638. static int btusb_setup_intel(struct hci_dev *hdev)
  1639. {
  1640. struct sk_buff *skb;
  1641. const struct firmware *fw;
  1642. const u8 *fw_ptr;
  1643. int disable_patch, err;
  1644. struct intel_version ver;
  1645. BT_DBG("%s", hdev->name);
  1646. /* The controller has a bug with the first HCI command sent to it
  1647. * returning number of completed commands as zero. This would stall the
  1648. * command processing in the Bluetooth core.
  1649. *
  1650. * As a workaround, send HCI Reset command first which will reset the
  1651. * number of completed commands and allow normal command processing
  1652. * from now on.
  1653. */
  1654. skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
  1655. if (IS_ERR(skb)) {
  1656. bt_dev_err(hdev, "sending initial HCI reset command failed (%ld)",
  1657. PTR_ERR(skb));
  1658. return PTR_ERR(skb);
  1659. }
  1660. kfree_skb(skb);
  1661. /* Read Intel specific controller version first to allow selection of
  1662. * which firmware file to load.
  1663. *
  1664. * The returned information are hardware variant and revision plus
  1665. * firmware variant, revision and build number.
  1666. */
  1667. err = btintel_read_version(hdev, &ver);
  1668. if (err)
  1669. return err;
  1670. bt_dev_info(hdev, "read Intel version: %02x%02x%02x%02x%02x%02x%02x%02x%02x",
  1671. ver.hw_platform, ver.hw_variant, ver.hw_revision,
  1672. ver.fw_variant, ver.fw_revision, ver.fw_build_num,
  1673. ver.fw_build_ww, ver.fw_build_yy, ver.fw_patch_num);
  1674. /* fw_patch_num indicates the version of patch the device currently
  1675. * have. If there is no patch data in the device, it is always 0x00.
  1676. * So, if it is other than 0x00, no need to patch the device again.
  1677. */
  1678. if (ver.fw_patch_num) {
  1679. bt_dev_info(hdev, "Intel device is already patched. "
  1680. "patch num: %02x", ver.fw_patch_num);
  1681. goto complete;
  1682. }
  1683. /* Opens the firmware patch file based on the firmware version read
  1684. * from the controller. If it fails to open the matching firmware
  1685. * patch file, it tries to open the default firmware patch file.
  1686. * If no patch file is found, allow the device to operate without
  1687. * a patch.
  1688. */
  1689. fw = btusb_setup_intel_get_fw(hdev, &ver);
  1690. if (!fw)
  1691. goto complete;
  1692. fw_ptr = fw->data;
  1693. /* Enable the manufacturer mode of the controller.
  1694. * Only while this mode is enabled, the driver can download the
  1695. * firmware patch data and configuration parameters.
  1696. */
  1697. err = btintel_enter_mfg(hdev);
  1698. if (err) {
  1699. release_firmware(fw);
  1700. return err;
  1701. }
  1702. disable_patch = 1;
  1703. /* The firmware data file consists of list of Intel specific HCI
  1704. * commands and its expected events. The first byte indicates the
  1705. * type of the message, either HCI command or HCI event.
  1706. *
  1707. * It reads the command and its expected event from the firmware file,
  1708. * and send to the controller. Once __hci_cmd_sync_ev() returns,
  1709. * the returned event is compared with the event read from the firmware
  1710. * file and it will continue until all the messages are downloaded to
  1711. * the controller.
  1712. *
  1713. * Once the firmware patching is completed successfully,
  1714. * the manufacturer mode is disabled with reset and activating the
  1715. * downloaded patch.
  1716. *
  1717. * If the firmware patching fails, the manufacturer mode is
  1718. * disabled with reset and deactivating the patch.
  1719. *
  1720. * If the default patch file is used, no reset is done when disabling
  1721. * the manufacturer.
  1722. */
  1723. while (fw->size > fw_ptr - fw->data) {
  1724. int ret;
  1725. ret = btusb_setup_intel_patching(hdev, fw, &fw_ptr,
  1726. &disable_patch);
  1727. if (ret < 0)
  1728. goto exit_mfg_deactivate;
  1729. }
  1730. release_firmware(fw);
  1731. if (disable_patch)
  1732. goto exit_mfg_disable;
  1733. /* Patching completed successfully and disable the manufacturer mode
  1734. * with reset and activate the downloaded firmware patches.
  1735. */
  1736. err = btintel_exit_mfg(hdev, true, true);
  1737. if (err)
  1738. return err;
  1739. /* Need build number for downloaded fw patches in
  1740. * every power-on boot
  1741. */
  1742. err = btintel_read_version(hdev, &ver);
  1743. if (err)
  1744. return err;
  1745. bt_dev_info(hdev, "Intel BT fw patch 0x%02x completed & activated",
  1746. ver.fw_patch_num);
  1747. goto complete;
  1748. exit_mfg_disable:
  1749. /* Disable the manufacturer mode without reset */
  1750. err = btintel_exit_mfg(hdev, false, false);
  1751. if (err)
  1752. return err;
  1753. bt_dev_info(hdev, "Intel firmware patch completed");
  1754. goto complete;
  1755. exit_mfg_deactivate:
  1756. release_firmware(fw);
  1757. /* Patching failed. Disable the manufacturer mode with reset and
  1758. * deactivate the downloaded firmware patches.
  1759. */
  1760. err = btintel_exit_mfg(hdev, true, false);
  1761. if (err)
  1762. return err;
  1763. bt_dev_info(hdev, "Intel firmware patch completed and deactivated");
  1764. complete:
  1765. /* Set the event mask for Intel specific vendor events. This enables
  1766. * a few extra events that are useful during general operation.
  1767. */
  1768. btintel_set_event_mask_mfg(hdev, false);
  1769. btintel_check_bdaddr(hdev);
  1770. return 0;
  1771. }
  1772. static int inject_cmd_complete(struct hci_dev *hdev, __u16 opcode)
  1773. {
  1774. struct sk_buff *skb;
  1775. struct hci_event_hdr *hdr;
  1776. struct hci_ev_cmd_complete *evt;
  1777. skb = bt_skb_alloc(sizeof(*hdr) + sizeof(*evt) + 1, GFP_KERNEL);
  1778. if (!skb)
  1779. return -ENOMEM;
  1780. hdr = skb_put(skb, sizeof(*hdr));
  1781. hdr->evt = HCI_EV_CMD_COMPLETE;
  1782. hdr->plen = sizeof(*evt) + 1;
  1783. evt = skb_put(skb, sizeof(*evt));
  1784. evt->ncmd = 0x01;
  1785. evt->opcode = cpu_to_le16(opcode);
  1786. skb_put_u8(skb, 0x00);
  1787. hci_skb_pkt_type(skb) = HCI_EVENT_PKT;
  1788. return hci_recv_frame(hdev, skb);
  1789. }
  1790. static int btusb_recv_bulk_intel(struct btusb_data *data, void *buffer,
  1791. int count)
  1792. {
  1793. /* When the device is in bootloader mode, then it can send
  1794. * events via the bulk endpoint. These events are treated the
  1795. * same way as the ones received from the interrupt endpoint.
  1796. */
  1797. if (test_bit(BTUSB_BOOTLOADER, &data->flags))
  1798. return btusb_recv_intr(data, buffer, count);
  1799. return btusb_recv_bulk(data, buffer, count);
  1800. }
  1801. static void btusb_intel_bootup(struct btusb_data *data, const void *ptr,
  1802. unsigned int len)
  1803. {
  1804. const struct intel_bootup *evt = ptr;
  1805. if (len != sizeof(*evt))
  1806. return;
  1807. if (test_and_clear_bit(BTUSB_BOOTING, &data->flags))
  1808. wake_up_bit(&data->flags, BTUSB_BOOTING);
  1809. }
  1810. static void btusb_intel_secure_send_result(struct btusb_data *data,
  1811. const void *ptr, unsigned int len)
  1812. {
  1813. const struct intel_secure_send_result *evt = ptr;
  1814. if (len != sizeof(*evt))
  1815. return;
  1816. if (evt->result)
  1817. set_bit(BTUSB_FIRMWARE_FAILED, &data->flags);
  1818. if (test_and_clear_bit(BTUSB_DOWNLOADING, &data->flags) &&
  1819. test_bit(BTUSB_FIRMWARE_LOADED, &data->flags))
  1820. wake_up_bit(&data->flags, BTUSB_DOWNLOADING);
  1821. }
  1822. static int btusb_recv_event_intel(struct hci_dev *hdev, struct sk_buff *skb)
  1823. {
  1824. struct btusb_data *data = hci_get_drvdata(hdev);
  1825. if (test_bit(BTUSB_BOOTLOADER, &data->flags)) {
  1826. struct hci_event_hdr *hdr = (void *)skb->data;
  1827. if (skb->len > HCI_EVENT_HDR_SIZE && hdr->evt == 0xff &&
  1828. hdr->plen > 0) {
  1829. const void *ptr = skb->data + HCI_EVENT_HDR_SIZE + 1;
  1830. unsigned int len = skb->len - HCI_EVENT_HDR_SIZE - 1;
  1831. switch (skb->data[2]) {
  1832. case 0x02:
  1833. /* When switching to the operational firmware
  1834. * the device sends a vendor specific event
  1835. * indicating that the bootup completed.
  1836. */
  1837. btusb_intel_bootup(data, ptr, len);
  1838. break;
  1839. case 0x06:
  1840. /* When the firmware loading completes the
  1841. * device sends out a vendor specific event
  1842. * indicating the result of the firmware
  1843. * loading.
  1844. */
  1845. btusb_intel_secure_send_result(data, ptr, len);
  1846. break;
  1847. }
  1848. }
  1849. }
  1850. return hci_recv_frame(hdev, skb);
  1851. }
  1852. static int btusb_send_frame_intel(struct hci_dev *hdev, struct sk_buff *skb)
  1853. {
  1854. struct btusb_data *data = hci_get_drvdata(hdev);
  1855. struct urb *urb;
  1856. BT_DBG("%s", hdev->name);
  1857. switch (hci_skb_pkt_type(skb)) {
  1858. case HCI_COMMAND_PKT:
  1859. if (test_bit(BTUSB_BOOTLOADER, &data->flags)) {
  1860. struct hci_command_hdr *cmd = (void *)skb->data;
  1861. __u16 opcode = le16_to_cpu(cmd->opcode);
  1862. /* When in bootloader mode and the command 0xfc09
  1863. * is received, it needs to be send down the
  1864. * bulk endpoint. So allocate a bulk URB instead.
  1865. */
  1866. if (opcode == 0xfc09)
  1867. urb = alloc_bulk_urb(hdev, skb);
  1868. else
  1869. urb = alloc_ctrl_urb(hdev, skb);
  1870. /* When the 0xfc01 command is issued to boot into
  1871. * the operational firmware, it will actually not
  1872. * send a command complete event. To keep the flow
  1873. * control working inject that event here.
  1874. */
  1875. if (opcode == 0xfc01)
  1876. inject_cmd_complete(hdev, opcode);
  1877. } else {
  1878. urb = alloc_ctrl_urb(hdev, skb);
  1879. }
  1880. if (IS_ERR(urb))
  1881. return PTR_ERR(urb);
  1882. hdev->stat.cmd_tx++;
  1883. return submit_or_queue_tx_urb(hdev, urb);
  1884. case HCI_ACLDATA_PKT:
  1885. urb = alloc_bulk_urb(hdev, skb);
  1886. if (IS_ERR(urb))
  1887. return PTR_ERR(urb);
  1888. hdev->stat.acl_tx++;
  1889. return submit_or_queue_tx_urb(hdev, urb);
  1890. case HCI_SCODATA_PKT:
  1891. if (hci_conn_num(hdev, SCO_LINK) < 1)
  1892. return -ENODEV;
  1893. urb = alloc_isoc_urb(hdev, skb);
  1894. if (IS_ERR(urb))
  1895. return PTR_ERR(urb);
  1896. hdev->stat.sco_tx++;
  1897. return submit_tx_urb(hdev, urb);
  1898. }
  1899. return -EILSEQ;
  1900. }
  1901. static bool btusb_setup_intel_new_get_fw_name(struct intel_version *ver,
  1902. struct intel_boot_params *params,
  1903. char *fw_name, size_t len,
  1904. const char *suffix)
  1905. {
  1906. switch (ver->hw_variant) {
  1907. case 0x0b: /* SfP */
  1908. case 0x0c: /* WsP */
  1909. snprintf(fw_name, len, "intel/ibt-%u-%u.%s",
  1910. le16_to_cpu(ver->hw_variant),
  1911. le16_to_cpu(params->dev_revid),
  1912. suffix);
  1913. break;
  1914. case 0x11: /* JfP */
  1915. case 0x12: /* ThP */
  1916. case 0x13: /* HrP */
  1917. case 0x14: /* CcP */
  1918. snprintf(fw_name, len, "intel/ibt-%u-%u-%u.%s",
  1919. le16_to_cpu(ver->hw_variant),
  1920. le16_to_cpu(ver->hw_revision),
  1921. le16_to_cpu(ver->fw_revision),
  1922. suffix);
  1923. break;
  1924. default:
  1925. return false;
  1926. }
  1927. return true;
  1928. }
  1929. static int btusb_intel_download_firmware(struct hci_dev *hdev,
  1930. struct intel_version *ver,
  1931. struct intel_boot_params *params,
  1932. u32 *boot_param)
  1933. {
  1934. const struct firmware *fw;
  1935. char fwname[64];
  1936. int err;
  1937. struct btusb_data *data = hci_get_drvdata(hdev);
  1938. if (!ver || !params)
  1939. return -EINVAL;
  1940. /* The hardware platform number has a fixed value of 0x37 and
  1941. * for now only accept this single value.
  1942. */
  1943. if (ver->hw_platform != 0x37) {
  1944. bt_dev_err(hdev, "Unsupported Intel hardware platform (%u)",
  1945. ver->hw_platform);
  1946. return -EINVAL;
  1947. }
  1948. /* Check for supported iBT hardware variants of this firmware
  1949. * loading method.
  1950. *
  1951. * This check has been put in place to ensure correct forward
  1952. * compatibility options when newer hardware variants come along.
  1953. */
  1954. switch (ver->hw_variant) {
  1955. case 0x0b: /* SfP */
  1956. case 0x0c: /* WsP */
  1957. case 0x11: /* JfP */
  1958. case 0x12: /* ThP */
  1959. case 0x13: /* HrP */
  1960. case 0x14: /* CcP */
  1961. break;
  1962. default:
  1963. bt_dev_err(hdev, "Unsupported Intel hardware variant (%u)",
  1964. ver->hw_variant);
  1965. return -EINVAL;
  1966. }
  1967. btintel_version_info(hdev, ver);
  1968. /* The firmware variant determines if the device is in bootloader
  1969. * mode or is running operational firmware. The value 0x06 identifies
  1970. * the bootloader and the value 0x23 identifies the operational
  1971. * firmware.
  1972. *
  1973. * When the operational firmware is already present, then only
  1974. * the check for valid Bluetooth device address is needed. This
  1975. * determines if the device will be added as configured or
  1976. * unconfigured controller.
  1977. *
  1978. * It is not possible to use the Secure Boot Parameters in this
  1979. * case since that command is only available in bootloader mode.
  1980. */
  1981. if (ver->fw_variant == 0x23) {
  1982. clear_bit(BTUSB_BOOTLOADER, &data->flags);
  1983. btintel_check_bdaddr(hdev);
  1984. return 0;
  1985. }
  1986. /* If the device is not in bootloader mode, then the only possible
  1987. * choice is to return an error and abort the device initialization.
  1988. */
  1989. if (ver->fw_variant != 0x06) {
  1990. bt_dev_err(hdev, "Unsupported Intel firmware variant (%u)",
  1991. ver->fw_variant);
  1992. return -ENODEV;
  1993. }
  1994. /* Read the secure boot parameters to identify the operating
  1995. * details of the bootloader.
  1996. */
  1997. err = btintel_read_boot_params(hdev, params);
  1998. if (err)
  1999. return err;
  2000. /* It is required that every single firmware fragment is acknowledged
  2001. * with a command complete event. If the boot parameters indicate
  2002. * that this bootloader does not send them, then abort the setup.
  2003. */
  2004. if (params->limited_cce != 0x00) {
  2005. bt_dev_err(hdev, "Unsupported Intel firmware loading method (%u)",
  2006. params->limited_cce);
  2007. return -EINVAL;
  2008. }
  2009. /* If the OTP has no valid Bluetooth device address, then there will
  2010. * also be no valid address for the operational firmware.
  2011. */
  2012. if (!bacmp(&params->otp_bdaddr, BDADDR_ANY)) {
  2013. bt_dev_info(hdev, "No device address configured");
  2014. set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
  2015. }
  2016. /* With this Intel bootloader only the hardware variant and device
  2017. * revision information are used to select the right firmware for SfP
  2018. * and WsP.
  2019. *
  2020. * The firmware filename is ibt-<hw_variant>-<dev_revid>.sfi.
  2021. *
  2022. * Currently the supported hardware variants are:
  2023. * 11 (0x0b) for iBT3.0 (LnP/SfP)
  2024. * 12 (0x0c) for iBT3.5 (WsP)
  2025. *
  2026. * For ThP/JfP and for future SKU's, the FW name varies based on HW
  2027. * variant, HW revision and FW revision, as these are dependent on CNVi
  2028. * and RF Combination.
  2029. *
  2030. * 17 (0x11) for iBT3.5 (JfP)
  2031. * 18 (0x12) for iBT3.5 (ThP)
  2032. *
  2033. * The firmware file name for these will be
  2034. * ibt-<hw_variant>-<hw_revision>-<fw_revision>.sfi.
  2035. *
  2036. */
  2037. err = btusb_setup_intel_new_get_fw_name(ver, params, fwname,
  2038. sizeof(fwname), "sfi");
  2039. if (!err) {
  2040. bt_dev_err(hdev, "Unsupported Intel firmware naming");
  2041. return -EINVAL;
  2042. }
  2043. err = request_firmware(&fw, fwname, &hdev->dev);
  2044. if (err < 0) {
  2045. bt_dev_err(hdev, "Failed to load Intel firmware file (%d)", err);
  2046. return err;
  2047. }
  2048. bt_dev_info(hdev, "Found device firmware: %s", fwname);
  2049. if (fw->size < 644) {
  2050. bt_dev_err(hdev, "Invalid size of firmware file (%zu)",
  2051. fw->size);
  2052. err = -EBADF;
  2053. goto done;
  2054. }
  2055. set_bit(BTUSB_DOWNLOADING, &data->flags);
  2056. /* Start firmware downloading and get boot parameter */
  2057. err = btintel_download_firmware(hdev, fw, boot_param);
  2058. if (err < 0) {
  2059. /* When FW download fails, send Intel Reset to retry
  2060. * FW download.
  2061. */
  2062. btintel_reset_to_bootloader(hdev);
  2063. goto done;
  2064. }
  2065. set_bit(BTUSB_FIRMWARE_LOADED, &data->flags);
  2066. bt_dev_info(hdev, "Waiting for firmware download to complete");
  2067. /* Before switching the device into operational mode and with that
  2068. * booting the loaded firmware, wait for the bootloader notification
  2069. * that all fragments have been successfully received.
  2070. *
  2071. * When the event processing receives the notification, then the
  2072. * BTUSB_DOWNLOADING flag will be cleared.
  2073. *
  2074. * The firmware loading should not take longer than 5 seconds
  2075. * and thus just timeout if that happens and fail the setup
  2076. * of this device.
  2077. */
  2078. err = wait_on_bit_timeout(&data->flags, BTUSB_DOWNLOADING,
  2079. TASK_INTERRUPTIBLE,
  2080. msecs_to_jiffies(5000));
  2081. if (err == -EINTR) {
  2082. bt_dev_err(hdev, "Firmware loading interrupted");
  2083. goto done;
  2084. }
  2085. if (err) {
  2086. bt_dev_err(hdev, "Firmware loading timeout");
  2087. err = -ETIMEDOUT;
  2088. btintel_reset_to_bootloader(hdev);
  2089. goto done;
  2090. }
  2091. if (test_bit(BTUSB_FIRMWARE_FAILED, &data->flags)) {
  2092. bt_dev_err(hdev, "Firmware loading failed");
  2093. err = -ENOEXEC;
  2094. goto done;
  2095. }
  2096. done:
  2097. release_firmware(fw);
  2098. return err;
  2099. }
  2100. static int btusb_setup_intel_new(struct hci_dev *hdev)
  2101. {
  2102. struct btusb_data *data = hci_get_drvdata(hdev);
  2103. struct intel_version ver;
  2104. struct intel_boot_params params;
  2105. u32 boot_param;
  2106. char ddcname[64];
  2107. ktime_t calltime, delta, rettime;
  2108. unsigned long long duration;
  2109. int err;
  2110. struct intel_debug_features features;
  2111. BT_DBG("%s", hdev->name);
  2112. /* Set the default boot parameter to 0x0 and it is updated to
  2113. * SKU specific boot parameter after reading Intel_Write_Boot_Params
  2114. * command while downloading the firmware.
  2115. */
  2116. boot_param = 0x00000000;
  2117. calltime = ktime_get();
  2118. /* Read the Intel version information to determine if the device
  2119. * is in bootloader mode or if it already has operational firmware
  2120. * loaded.
  2121. */
  2122. err = btintel_read_version(hdev, &ver);
  2123. if (err) {
  2124. bt_dev_err(hdev, "Intel Read version failed (%d)", err);
  2125. btintel_reset_to_bootloader(hdev);
  2126. return err;
  2127. }
  2128. err = btusb_intel_download_firmware(hdev, &ver, &params, &boot_param);
  2129. if (err)
  2130. return err;
  2131. /* controller is already having an operational firmware */
  2132. if (ver.fw_variant == 0x23)
  2133. goto finish;
  2134. rettime = ktime_get();
  2135. delta = ktime_sub(rettime, calltime);
  2136. duration = (unsigned long long) ktime_to_ns(delta) >> 10;
  2137. bt_dev_info(hdev, "Firmware loaded in %llu usecs", duration);
  2138. calltime = ktime_get();
  2139. set_bit(BTUSB_BOOTING, &data->flags);
  2140. err = btintel_send_intel_reset(hdev, boot_param);
  2141. if (err) {
  2142. bt_dev_err(hdev, "Intel Soft Reset failed (%d)", err);
  2143. btintel_reset_to_bootloader(hdev);
  2144. return err;
  2145. }
  2146. /* The bootloader will not indicate when the device is ready. This
  2147. * is done by the operational firmware sending bootup notification.
  2148. *
  2149. * Booting into operational firmware should not take longer than
  2150. * 1 second. However if that happens, then just fail the setup
  2151. * since something went wrong.
  2152. */
  2153. bt_dev_info(hdev, "Waiting for device to boot");
  2154. err = wait_on_bit_timeout(&data->flags, BTUSB_BOOTING,
  2155. TASK_INTERRUPTIBLE,
  2156. msecs_to_jiffies(1000));
  2157. if (err == -EINTR) {
  2158. bt_dev_err(hdev, "Device boot interrupted");
  2159. return -EINTR;
  2160. }
  2161. if (err) {
  2162. bt_dev_err(hdev, "Device boot timeout");
  2163. btintel_reset_to_bootloader(hdev);
  2164. return -ETIMEDOUT;
  2165. }
  2166. rettime = ktime_get();
  2167. delta = ktime_sub(rettime, calltime);
  2168. duration = (unsigned long long) ktime_to_ns(delta) >> 10;
  2169. bt_dev_info(hdev, "Device booted in %llu usecs", duration);
  2170. clear_bit(BTUSB_BOOTLOADER, &data->flags);
  2171. err = btusb_setup_intel_new_get_fw_name(&ver, &params, ddcname,
  2172. sizeof(ddcname), "ddc");
  2173. if (!err) {
  2174. bt_dev_err(hdev, "Unsupported Intel firmware naming");
  2175. } else {
  2176. /* Once the device is running in operational mode, it needs to
  2177. * apply the device configuration (DDC) parameters.
  2178. *
  2179. * The device can work without DDC parameters, so even if it
  2180. * fails to load the file, no need to fail the setup.
  2181. */
  2182. btintel_load_ddc_config(hdev, ddcname);
  2183. }
  2184. /* Read the Intel supported features and if new exception formats
  2185. * supported, need to load the additional DDC config to enable.
  2186. */
  2187. btintel_read_debug_features(hdev, &features);
  2188. /* Set DDC mask for available debug features */
  2189. btintel_set_debug_features(hdev, &features);
  2190. /* Read the Intel version information after loading the FW */
  2191. err = btintel_read_version(hdev, &ver);
  2192. if (err)
  2193. return err;
  2194. btintel_version_info(hdev, &ver);
  2195. finish:
  2196. /* All Intel controllers that support the Microsoft vendor
  2197. * extension are using 0xFC1E for VsMsftOpCode.
  2198. */
  2199. switch (ver.hw_variant) {
  2200. case 0x12: /* ThP */
  2201. hci_set_msft_opcode(hdev, 0xFC1E);
  2202. break;
  2203. }
  2204. /* Set the event mask for Intel specific vendor events. This enables
  2205. * a few extra events that are useful during general operation. It
  2206. * does not enable any debugging related events.
  2207. *
  2208. * The device will function correctly without these events enabled
  2209. * and thus no need to fail the setup.
  2210. */
  2211. btintel_set_event_mask(hdev, false);
  2212. return 0;
  2213. }
  2214. static int btusb_shutdown_intel(struct hci_dev *hdev)
  2215. {
  2216. struct sk_buff *skb;
  2217. long ret;
  2218. /* In the shutdown sequence where Bluetooth is turned off followed
  2219. * by WiFi being turned off, turning WiFi back on causes issue with
  2220. * the RF calibration.
  2221. *
  2222. * To ensure that any RF activity has been stopped, issue HCI Reset
  2223. * command to clear all ongoing activity including advertising,
  2224. * scanning etc.
  2225. */
  2226. skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
  2227. if (IS_ERR(skb)) {
  2228. ret = PTR_ERR(skb);
  2229. bt_dev_err(hdev, "HCI reset during shutdown failed");
  2230. return ret;
  2231. }
  2232. kfree_skb(skb);
  2233. /* Some platforms have an issue with BT LED when the interface is
  2234. * down or BT radio is turned off, which takes 5 seconds to BT LED
  2235. * goes off. This command turns off the BT LED immediately.
  2236. */
  2237. skb = __hci_cmd_sync(hdev, 0xfc3f, 0, NULL, HCI_INIT_TIMEOUT);
  2238. if (IS_ERR(skb)) {
  2239. ret = PTR_ERR(skb);
  2240. bt_dev_err(hdev, "turning off Intel device LED failed");
  2241. return ret;
  2242. }
  2243. kfree_skb(skb);
  2244. return 0;
  2245. }
  2246. static int btusb_shutdown_intel_new(struct hci_dev *hdev)
  2247. {
  2248. struct sk_buff *skb;
  2249. /* Send HCI Reset to the controller to stop any BT activity which
  2250. * were triggered. This will help to save power and maintain the
  2251. * sync b/w Host and controller
  2252. */
  2253. skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
  2254. if (IS_ERR(skb)) {
  2255. bt_dev_err(hdev, "HCI reset during shutdown failed");
  2256. return PTR_ERR(skb);
  2257. }
  2258. kfree_skb(skb);
  2259. return 0;
  2260. }
  2261. #define FIRMWARE_MT7663 "mediatek/mt7663pr2h.bin"
  2262. #define FIRMWARE_MT7668 "mediatek/mt7668pr2h.bin"
  2263. #define HCI_WMT_MAX_EVENT_SIZE 64
  2264. enum {
  2265. BTMTK_WMT_PATCH_DWNLD = 0x1,
  2266. BTMTK_WMT_FUNC_CTRL = 0x6,
  2267. BTMTK_WMT_RST = 0x7,
  2268. BTMTK_WMT_SEMAPHORE = 0x17,
  2269. };
  2270. enum {
  2271. BTMTK_WMT_INVALID,
  2272. BTMTK_WMT_PATCH_UNDONE,
  2273. BTMTK_WMT_PATCH_DONE,
  2274. BTMTK_WMT_ON_UNDONE,
  2275. BTMTK_WMT_ON_DONE,
  2276. BTMTK_WMT_ON_PROGRESS,
  2277. };
  2278. struct btmtk_wmt_hdr {
  2279. u8 dir;
  2280. u8 op;
  2281. __le16 dlen;
  2282. u8 flag;
  2283. } __packed;
  2284. struct btmtk_hci_wmt_cmd {
  2285. struct btmtk_wmt_hdr hdr;
  2286. u8 data[256];
  2287. } __packed;
  2288. struct btmtk_hci_wmt_evt {
  2289. struct hci_event_hdr hhdr;
  2290. struct btmtk_wmt_hdr whdr;
  2291. } __packed;
  2292. struct btmtk_hci_wmt_evt_funcc {
  2293. struct btmtk_hci_wmt_evt hwhdr;
  2294. __be16 status;
  2295. } __packed;
  2296. struct btmtk_tci_sleep {
  2297. u8 mode;
  2298. __le16 duration;
  2299. __le16 host_duration;
  2300. u8 host_wakeup_pin;
  2301. u8 time_compensation;
  2302. } __packed;
  2303. struct btmtk_hci_wmt_params {
  2304. u8 op;
  2305. u8 flag;
  2306. u16 dlen;
  2307. const void *data;
  2308. u32 *status;
  2309. };
  2310. static void btusb_mtk_wmt_recv(struct urb *urb)
  2311. {
  2312. struct hci_dev *hdev = urb->context;
  2313. struct btusb_data *data = hci_get_drvdata(hdev);
  2314. struct hci_event_hdr *hdr;
  2315. struct sk_buff *skb;
  2316. int err;
  2317. if (urb->status == 0 && urb->actual_length > 0) {
  2318. hdev->stat.byte_rx += urb->actual_length;
  2319. /* WMT event shouldn't be fragmented and the size should be
  2320. * less than HCI_WMT_MAX_EVENT_SIZE.
  2321. */
  2322. skb = bt_skb_alloc(HCI_WMT_MAX_EVENT_SIZE, GFP_ATOMIC);
  2323. if (!skb) {
  2324. hdev->stat.err_rx++;
  2325. kfree(urb->setup_packet);
  2326. return;
  2327. }
  2328. hci_skb_pkt_type(skb) = HCI_EVENT_PKT;
  2329. skb_put_data(skb, urb->transfer_buffer, urb->actual_length);
  2330. hdr = (void *)skb->data;
  2331. /* Fix up the vendor event id with 0xff for vendor specific
  2332. * instead of 0xe4 so that event send via monitoring socket can
  2333. * be parsed properly.
  2334. */
  2335. hdr->evt = 0xff;
  2336. /* When someone waits for the WMT event, the skb is being cloned
  2337. * and being processed the events from there then.
  2338. */
  2339. if (test_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags)) {
  2340. data->evt_skb = skb_clone(skb, GFP_ATOMIC);
  2341. if (!data->evt_skb) {
  2342. kfree_skb(skb);
  2343. kfree(urb->setup_packet);
  2344. return;
  2345. }
  2346. }
  2347. err = hci_recv_frame(hdev, skb);
  2348. if (err < 0) {
  2349. kfree_skb(data->evt_skb);
  2350. data->evt_skb = NULL;
  2351. kfree(urb->setup_packet);
  2352. return;
  2353. }
  2354. if (test_and_clear_bit(BTUSB_TX_WAIT_VND_EVT,
  2355. &data->flags)) {
  2356. /* Barrier to sync with other CPUs */
  2357. smp_mb__after_atomic();
  2358. wake_up_bit(&data->flags,
  2359. BTUSB_TX_WAIT_VND_EVT);
  2360. }
  2361. kfree(urb->setup_packet);
  2362. return;
  2363. } else if (urb->status == -ENOENT) {
  2364. /* Avoid suspend failed when usb_kill_urb */
  2365. return;
  2366. }
  2367. usb_mark_last_busy(data->udev);
  2368. /* The URB complete handler is still called with urb->actual_length = 0
  2369. * when the event is not available, so we should keep re-submitting
  2370. * URB until WMT event returns, Also, It's necessary to wait some time
  2371. * between the two consecutive control URBs to relax the target device
  2372. * to generate the event. Otherwise, the WMT event cannot return from
  2373. * the device successfully.
  2374. */
  2375. udelay(100);
  2376. usb_anchor_urb(urb, &data->ctrl_anchor);
  2377. err = usb_submit_urb(urb, GFP_ATOMIC);
  2378. if (err < 0) {
  2379. kfree(urb->setup_packet);
  2380. /* -EPERM: urb is being killed;
  2381. * -ENODEV: device got disconnected
  2382. */
  2383. if (err != -EPERM && err != -ENODEV)
  2384. bt_dev_err(hdev, "urb %p failed to resubmit (%d)",
  2385. urb, -err);
  2386. usb_unanchor_urb(urb);
  2387. }
  2388. }
  2389. static int btusb_mtk_submit_wmt_recv_urb(struct hci_dev *hdev)
  2390. {
  2391. struct btusb_data *data = hci_get_drvdata(hdev);
  2392. struct usb_ctrlrequest *dr;
  2393. unsigned char *buf;
  2394. int err, size = 64;
  2395. unsigned int pipe;
  2396. struct urb *urb;
  2397. urb = usb_alloc_urb(0, GFP_KERNEL);
  2398. if (!urb)
  2399. return -ENOMEM;
  2400. dr = kmalloc(sizeof(*dr), GFP_KERNEL);
  2401. if (!dr) {
  2402. usb_free_urb(urb);
  2403. return -ENOMEM;
  2404. }
  2405. dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_IN;
  2406. dr->bRequest = 1;
  2407. dr->wIndex = cpu_to_le16(0);
  2408. dr->wValue = cpu_to_le16(48);
  2409. dr->wLength = cpu_to_le16(size);
  2410. buf = kmalloc(size, GFP_KERNEL);
  2411. if (!buf) {
  2412. kfree(dr);
  2413. usb_free_urb(urb);
  2414. return -ENOMEM;
  2415. }
  2416. pipe = usb_rcvctrlpipe(data->udev, 0);
  2417. usb_fill_control_urb(urb, data->udev, pipe, (void *)dr,
  2418. buf, size, btusb_mtk_wmt_recv, hdev);
  2419. urb->transfer_flags |= URB_FREE_BUFFER;
  2420. usb_anchor_urb(urb, &data->ctrl_anchor);
  2421. err = usb_submit_urb(urb, GFP_KERNEL);
  2422. if (err < 0) {
  2423. if (err != -EPERM && err != -ENODEV)
  2424. bt_dev_err(hdev, "urb %p submission failed (%d)",
  2425. urb, -err);
  2426. usb_unanchor_urb(urb);
  2427. }
  2428. usb_free_urb(urb);
  2429. return err;
  2430. }
  2431. static int btusb_mtk_hci_wmt_sync(struct hci_dev *hdev,
  2432. struct btmtk_hci_wmt_params *wmt_params)
  2433. {
  2434. struct btusb_data *data = hci_get_drvdata(hdev);
  2435. struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc;
  2436. u32 hlen, status = BTMTK_WMT_INVALID;
  2437. struct btmtk_hci_wmt_evt *wmt_evt;
  2438. struct btmtk_hci_wmt_cmd wc;
  2439. struct btmtk_wmt_hdr *hdr;
  2440. int err;
  2441. /* Send the WMT command and wait until the WMT event returns */
  2442. hlen = sizeof(*hdr) + wmt_params->dlen;
  2443. if (hlen > 255)
  2444. return -EINVAL;
  2445. hdr = (struct btmtk_wmt_hdr *)&wc;
  2446. hdr->dir = 1;
  2447. hdr->op = wmt_params->op;
  2448. hdr->dlen = cpu_to_le16(wmt_params->dlen + 1);
  2449. hdr->flag = wmt_params->flag;
  2450. memcpy(wc.data, wmt_params->data, wmt_params->dlen);
  2451. set_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags);
  2452. err = __hci_cmd_send(hdev, 0xfc6f, hlen, &wc);
  2453. if (err < 0) {
  2454. clear_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags);
  2455. return err;
  2456. }
  2457. /* Submit control IN URB on demand to process the WMT event */
  2458. err = btusb_mtk_submit_wmt_recv_urb(hdev);
  2459. if (err < 0)
  2460. return err;
  2461. /* The vendor specific WMT commands are all answered by a vendor
  2462. * specific event and will have the Command Status or Command
  2463. * Complete as with usual HCI command flow control.
  2464. *
  2465. * After sending the command, wait for BTUSB_TX_WAIT_VND_EVT
  2466. * state to be cleared. The driver specific event receive routine
  2467. * will clear that state and with that indicate completion of the
  2468. * WMT command.
  2469. */
  2470. err = wait_on_bit_timeout(&data->flags, BTUSB_TX_WAIT_VND_EVT,
  2471. TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT);
  2472. if (err == -EINTR) {
  2473. bt_dev_err(hdev, "Execution of wmt command interrupted");
  2474. clear_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags);
  2475. return err;
  2476. }
  2477. if (err) {
  2478. bt_dev_err(hdev, "Execution of wmt command timed out");
  2479. clear_bit(BTUSB_TX_WAIT_VND_EVT, &data->flags);
  2480. return -ETIMEDOUT;
  2481. }
  2482. /* Parse and handle the return WMT event */
  2483. wmt_evt = (struct btmtk_hci_wmt_evt *)data->evt_skb->data;
  2484. if (wmt_evt->whdr.op != hdr->op) {
  2485. bt_dev_err(hdev, "Wrong op received %d expected %d",
  2486. wmt_evt->whdr.op, hdr->op);
  2487. err = -EIO;
  2488. goto err_free_skb;
  2489. }
  2490. switch (wmt_evt->whdr.op) {
  2491. case BTMTK_WMT_SEMAPHORE:
  2492. if (wmt_evt->whdr.flag == 2)
  2493. status = BTMTK_WMT_PATCH_UNDONE;
  2494. else
  2495. status = BTMTK_WMT_PATCH_DONE;
  2496. break;
  2497. case BTMTK_WMT_FUNC_CTRL:
  2498. wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt;
  2499. if (be16_to_cpu(wmt_evt_funcc->status) == 0x404)
  2500. status = BTMTK_WMT_ON_DONE;
  2501. else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420)
  2502. status = BTMTK_WMT_ON_PROGRESS;
  2503. else
  2504. status = BTMTK_WMT_ON_UNDONE;
  2505. break;
  2506. }
  2507. if (wmt_params->status)
  2508. *wmt_params->status = status;
  2509. err_free_skb:
  2510. kfree_skb(data->evt_skb);
  2511. data->evt_skb = NULL;
  2512. return err;
  2513. }
  2514. static int btusb_mtk_setup_firmware(struct hci_dev *hdev, const char *fwname)
  2515. {
  2516. struct btmtk_hci_wmt_params wmt_params;
  2517. const struct firmware *fw;
  2518. const u8 *fw_ptr;
  2519. size_t fw_size;
  2520. int err, dlen;
  2521. u8 flag, param;
  2522. err = request_firmware(&fw, fwname, &hdev->dev);
  2523. if (err < 0) {
  2524. bt_dev_err(hdev, "Failed to load firmware file (%d)", err);
  2525. return err;
  2526. }
  2527. /* Power on data RAM the firmware relies on. */
  2528. param = 1;
  2529. wmt_params.op = BTMTK_WMT_FUNC_CTRL;
  2530. wmt_params.flag = 3;
  2531. wmt_params.dlen = sizeof(param);
  2532. wmt_params.data = &param;
  2533. wmt_params.status = NULL;
  2534. err = btusb_mtk_hci_wmt_sync(hdev, &wmt_params);
  2535. if (err < 0) {
  2536. bt_dev_err(hdev, "Failed to power on data RAM (%d)", err);
  2537. goto err_release_fw;
  2538. }
  2539. fw_ptr = fw->data;
  2540. fw_size = fw->size;
  2541. /* The size of patch header is 30 bytes, should be skip */
  2542. if (fw_size < 30) {
  2543. err = -EINVAL;
  2544. goto err_release_fw;
  2545. }
  2546. fw_size -= 30;
  2547. fw_ptr += 30;
  2548. flag = 1;
  2549. wmt_params.op = BTMTK_WMT_PATCH_DWNLD;
  2550. wmt_params.status = NULL;
  2551. while (fw_size > 0) {
  2552. dlen = min_t(int, 250, fw_size);
  2553. /* Tell deivice the position in sequence */
  2554. if (fw_size - dlen <= 0)
  2555. flag = 3;
  2556. else if (fw_size < fw->size - 30)
  2557. flag = 2;
  2558. wmt_params.flag = flag;
  2559. wmt_params.dlen = dlen;
  2560. wmt_params.data = fw_ptr;
  2561. err = btusb_mtk_hci_wmt_sync(hdev, &wmt_params);
  2562. if (err < 0) {
  2563. bt_dev_err(hdev, "Failed to send wmt patch dwnld (%d)",
  2564. err);
  2565. goto err_release_fw;
  2566. }
  2567. fw_size -= dlen;
  2568. fw_ptr += dlen;
  2569. }
  2570. wmt_params.op = BTMTK_WMT_RST;
  2571. wmt_params.flag = 4;
  2572. wmt_params.dlen = 0;
  2573. wmt_params.data = NULL;
  2574. wmt_params.status = NULL;
  2575. /* Activate funciton the firmware providing to */
  2576. err = btusb_mtk_hci_wmt_sync(hdev, &wmt_params);
  2577. if (err < 0) {
  2578. bt_dev_err(hdev, "Failed to send wmt rst (%d)", err);
  2579. goto err_release_fw;
  2580. }
  2581. /* Wait a few moments for firmware activation done */
  2582. usleep_range(10000, 12000);
  2583. err_release_fw:
  2584. release_firmware(fw);
  2585. return err;
  2586. }
  2587. static int btusb_mtk_func_query(struct hci_dev *hdev)
  2588. {
  2589. struct btmtk_hci_wmt_params wmt_params;
  2590. int status, err;
  2591. u8 param = 0;
  2592. /* Query whether the function is enabled */
  2593. wmt_params.op = BTMTK_WMT_FUNC_CTRL;
  2594. wmt_params.flag = 4;
  2595. wmt_params.dlen = sizeof(param);
  2596. wmt_params.data = &param;
  2597. wmt_params.status = &status;
  2598. err = btusb_mtk_hci_wmt_sync(hdev, &wmt_params);
  2599. if (err < 0) {
  2600. bt_dev_err(hdev, "Failed to query function status (%d)", err);
  2601. return err;
  2602. }
  2603. return status;
  2604. }
  2605. static int btusb_mtk_reg_read(struct btusb_data *data, u32 reg, u32 *val)
  2606. {
  2607. int pipe, err, size = sizeof(u32);
  2608. void *buf;
  2609. buf = kzalloc(size, GFP_KERNEL);
  2610. if (!buf)
  2611. return -ENOMEM;
  2612. pipe = usb_rcvctrlpipe(data->udev, 0);
  2613. err = usb_control_msg(data->udev, pipe, 0x63,
  2614. USB_TYPE_VENDOR | USB_DIR_IN,
  2615. reg >> 16, reg & 0xffff,
  2616. buf, size, USB_CTRL_SET_TIMEOUT);
  2617. if (err < 0)
  2618. goto err_free_buf;
  2619. *val = get_unaligned_le32(buf);
  2620. err_free_buf:
  2621. kfree(buf);
  2622. return err;
  2623. }
  2624. static int btusb_mtk_id_get(struct btusb_data *data, u32 *id)
  2625. {
  2626. return btusb_mtk_reg_read(data, 0x80000008, id);
  2627. }
  2628. static int btusb_mtk_setup(struct hci_dev *hdev)
  2629. {
  2630. struct btusb_data *data = hci_get_drvdata(hdev);
  2631. struct btmtk_hci_wmt_params wmt_params;
  2632. ktime_t calltime, delta, rettime;
  2633. struct btmtk_tci_sleep tci_sleep;
  2634. unsigned long long duration;
  2635. struct sk_buff *skb;
  2636. const char *fwname;
  2637. int err, status;
  2638. u32 dev_id;
  2639. u8 param;
  2640. calltime = ktime_get();
  2641. err = btusb_mtk_id_get(data, &dev_id);
  2642. if (err < 0) {
  2643. bt_dev_err(hdev, "Failed to get device id (%d)", err);
  2644. return err;
  2645. }
  2646. switch (dev_id) {
  2647. case 0x7663:
  2648. fwname = FIRMWARE_MT7663;
  2649. break;
  2650. case 0x7668:
  2651. fwname = FIRMWARE_MT7668;
  2652. break;
  2653. default:
  2654. bt_dev_err(hdev, "Unsupported support hardware variant (%08x)",
  2655. dev_id);
  2656. return -ENODEV;
  2657. }
  2658. /* Query whether the firmware is already download */
  2659. wmt_params.op = BTMTK_WMT_SEMAPHORE;
  2660. wmt_params.flag = 1;
  2661. wmt_params.dlen = 0;
  2662. wmt_params.data = NULL;
  2663. wmt_params.status = &status;
  2664. err = btusb_mtk_hci_wmt_sync(hdev, &wmt_params);
  2665. if (err < 0) {
  2666. bt_dev_err(hdev, "Failed to query firmware status (%d)", err);
  2667. return err;
  2668. }
  2669. if (status == BTMTK_WMT_PATCH_DONE) {
  2670. bt_dev_info(hdev, "firmware already downloaded");
  2671. goto ignore_setup_fw;
  2672. }
  2673. /* Setup a firmware which the device definitely requires */
  2674. err = btusb_mtk_setup_firmware(hdev, fwname);
  2675. if (err < 0)
  2676. return err;
  2677. ignore_setup_fw:
  2678. err = readx_poll_timeout(btusb_mtk_func_query, hdev, status,
  2679. status < 0 || status != BTMTK_WMT_ON_PROGRESS,
  2680. 2000, 5000000);
  2681. /* -ETIMEDOUT happens */
  2682. if (err < 0)
  2683. return err;
  2684. /* The other errors happen in btusb_mtk_func_query */
  2685. if (status < 0)
  2686. return status;
  2687. if (status == BTMTK_WMT_ON_DONE) {
  2688. bt_dev_info(hdev, "function already on");
  2689. goto ignore_func_on;
  2690. }
  2691. /* Enable Bluetooth protocol */
  2692. param = 1;
  2693. wmt_params.op = BTMTK_WMT_FUNC_CTRL;
  2694. wmt_params.flag = 0;
  2695. wmt_params.dlen = sizeof(param);
  2696. wmt_params.data = &param;
  2697. wmt_params.status = NULL;
  2698. err = btusb_mtk_hci_wmt_sync(hdev, &wmt_params);
  2699. if (err < 0) {
  2700. bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
  2701. return err;
  2702. }
  2703. ignore_func_on:
  2704. /* Apply the low power environment setup */
  2705. tci_sleep.mode = 0x5;
  2706. tci_sleep.duration = cpu_to_le16(0x640);
  2707. tci_sleep.host_duration = cpu_to_le16(0x640);
  2708. tci_sleep.host_wakeup_pin = 0;
  2709. tci_sleep.time_compensation = 0;
  2710. skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep,
  2711. HCI_INIT_TIMEOUT);
  2712. if (IS_ERR(skb)) {
  2713. err = PTR_ERR(skb);
  2714. bt_dev_err(hdev, "Failed to apply low power setting (%d)", err);
  2715. return err;
  2716. }
  2717. kfree_skb(skb);
  2718. rettime = ktime_get();
  2719. delta = ktime_sub(rettime, calltime);
  2720. duration = (unsigned long long)ktime_to_ns(delta) >> 10;
  2721. bt_dev_info(hdev, "Device setup in %llu usecs", duration);
  2722. return 0;
  2723. }
  2724. static int btusb_mtk_shutdown(struct hci_dev *hdev)
  2725. {
  2726. struct btmtk_hci_wmt_params wmt_params;
  2727. u8 param = 0;
  2728. int err;
  2729. /* Disable the device */
  2730. wmt_params.op = BTMTK_WMT_FUNC_CTRL;
  2731. wmt_params.flag = 0;
  2732. wmt_params.dlen = sizeof(param);
  2733. wmt_params.data = &param;
  2734. wmt_params.status = NULL;
  2735. err = btusb_mtk_hci_wmt_sync(hdev, &wmt_params);
  2736. if (err < 0) {
  2737. bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
  2738. return err;
  2739. }
  2740. return 0;
  2741. }
  2742. MODULE_FIRMWARE(FIRMWARE_MT7663);
  2743. MODULE_FIRMWARE(FIRMWARE_MT7668);
  2744. #ifdef CONFIG_PM
  2745. /* Configure an out-of-band gpio as wake-up pin, if specified in device tree */
  2746. static int marvell_config_oob_wake(struct hci_dev *hdev)
  2747. {
  2748. struct sk_buff *skb;
  2749. struct btusb_data *data = hci_get_drvdata(hdev);
  2750. struct device *dev = &data->udev->dev;
  2751. u16 pin, gap, opcode;
  2752. int ret;
  2753. u8 cmd[5];
  2754. /* Move on if no wakeup pin specified */
  2755. if (of_property_read_u16(dev->of_node, "marvell,wakeup-pin", &pin) ||
  2756. of_property_read_u16(dev->of_node, "marvell,wakeup-gap-ms", &gap))
  2757. return 0;
  2758. /* Vendor specific command to configure a GPIO as wake-up pin */
  2759. opcode = hci_opcode_pack(0x3F, 0x59);
  2760. cmd[0] = opcode & 0xFF;
  2761. cmd[1] = opcode >> 8;
  2762. cmd[2] = 2; /* length of parameters that follow */
  2763. cmd[3] = pin;
  2764. cmd[4] = gap; /* time in ms, for which wakeup pin should be asserted */
  2765. skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);
  2766. if (!skb) {
  2767. bt_dev_err(hdev, "%s: No memory\n", __func__);
  2768. return -ENOMEM;
  2769. }
  2770. skb_put_data(skb, cmd, sizeof(cmd));
  2771. hci_skb_pkt_type(skb) = HCI_COMMAND_PKT;
  2772. ret = btusb_send_frame(hdev, skb);
  2773. if (ret) {
  2774. bt_dev_err(hdev, "%s: configuration failed\n", __func__);
  2775. kfree_skb(skb);
  2776. return ret;
  2777. }
  2778. return 0;
  2779. }
  2780. #endif
  2781. static int btusb_set_bdaddr_marvell(struct hci_dev *hdev,
  2782. const bdaddr_t *bdaddr)
  2783. {
  2784. struct sk_buff *skb;
  2785. u8 buf[8];
  2786. long ret;
  2787. buf[0] = 0xfe;
  2788. buf[1] = sizeof(bdaddr_t);
  2789. memcpy(buf + 2, bdaddr, sizeof(bdaddr_t));
  2790. skb = __hci_cmd_sync(hdev, 0xfc22, sizeof(buf), buf, HCI_INIT_TIMEOUT);
  2791. if (IS_ERR(skb)) {
  2792. ret = PTR_ERR(skb);
  2793. bt_dev_err(hdev, "changing Marvell device address failed (%ld)",
  2794. ret);
  2795. return ret;
  2796. }
  2797. kfree_skb(skb);
  2798. return 0;
  2799. }
  2800. static int btusb_set_bdaddr_ath3012(struct hci_dev *hdev,
  2801. const bdaddr_t *bdaddr)
  2802. {
  2803. struct sk_buff *skb;
  2804. u8 buf[10];
  2805. long ret;
  2806. buf[0] = 0x01;
  2807. buf[1] = 0x01;
  2808. buf[2] = 0x00;
  2809. buf[3] = sizeof(bdaddr_t);
  2810. memcpy(buf + 4, bdaddr, sizeof(bdaddr_t));
  2811. skb = __hci_cmd_sync(hdev, 0xfc0b, sizeof(buf), buf, HCI_INIT_TIMEOUT);
  2812. if (IS_ERR(skb)) {
  2813. ret = PTR_ERR(skb);
  2814. bt_dev_err(hdev, "Change address command failed (%ld)", ret);
  2815. return ret;
  2816. }
  2817. kfree_skb(skb);
  2818. return 0;
  2819. }
  2820. static int btusb_set_bdaddr_wcn6855(struct hci_dev *hdev,
  2821. const bdaddr_t *bdaddr)
  2822. {
  2823. struct sk_buff *skb;
  2824. u8 buf[6];
  2825. long ret;
  2826. memcpy(buf, bdaddr, sizeof(bdaddr_t));
  2827. skb = __hci_cmd_sync_ev(hdev, 0xfc14, sizeof(buf), buf,
  2828. HCI_EV_CMD_COMPLETE, HCI_INIT_TIMEOUT);
  2829. if (IS_ERR(skb)) {
  2830. ret = PTR_ERR(skb);
  2831. bt_dev_err(hdev, "Change address command failed (%ld)", ret);
  2832. return ret;
  2833. }
  2834. kfree_skb(skb);
  2835. return 0;
  2836. }
  2837. #define QCA_DFU_PACKET_LEN 4096
  2838. #define QCA_GET_TARGET_VERSION 0x09
  2839. #define QCA_CHECK_STATUS 0x05
  2840. #define QCA_DFU_DOWNLOAD 0x01
  2841. #define QCA_SYSCFG_UPDATED 0x40
  2842. #define QCA_PATCH_UPDATED 0x80
  2843. #define QCA_DFU_TIMEOUT 3000
  2844. struct qca_version {
  2845. __le32 rom_version;
  2846. __le32 patch_version;
  2847. __le32 ram_version;
  2848. __le32 ref_clock;
  2849. __u8 reserved[4];
  2850. } __packed;
  2851. struct qca_rampatch_version {
  2852. __le16 rom_version_high;
  2853. __le16 rom_version_low;
  2854. __le16 patch_version;
  2855. } __packed;
  2856. struct qca_device_info {
  2857. u32 rom_version;
  2858. u8 rampatch_hdr; /* length of header in rampatch */
  2859. u8 nvm_hdr; /* length of header in NVM */
  2860. u8 ver_offset; /* offset of version structure in rampatch */
  2861. };
  2862. static const struct qca_device_info qca_devices_table[] = {
  2863. { 0x00000100, 20, 4, 8 }, /* Rome 1.0 */
  2864. { 0x00000101, 20, 4, 8 }, /* Rome 1.1 */
  2865. { 0x00000200, 28, 4, 16 }, /* Rome 2.0 */
  2866. { 0x00000201, 28, 4, 16 }, /* Rome 2.1 */
  2867. { 0x00000300, 28, 4, 16 }, /* Rome 3.0 */
  2868. { 0x00000302, 28, 4, 16 }, /* Rome 3.2 */
  2869. { 0x00130100, 40, 4, 16 }, /* WCN6855 1.0 */
  2870. { 0x00130200, 40, 4, 16 }, /* WCN6855 2.0 */
  2871. };
  2872. static int btusb_qca_send_vendor_req(struct usb_device *udev, u8 request,
  2873. void *data, u16 size)
  2874. {
  2875. int pipe, err;
  2876. u8 *buf;
  2877. buf = kmalloc(size, GFP_KERNEL);
  2878. if (!buf)
  2879. return -ENOMEM;
  2880. /* Found some of USB hosts have IOT issues with ours so that we should
  2881. * not wait until HCI layer is ready.
  2882. */
  2883. pipe = usb_rcvctrlpipe(udev, 0);
  2884. err = usb_control_msg(udev, pipe, request, USB_TYPE_VENDOR | USB_DIR_IN,
  2885. 0, 0, buf, size, USB_CTRL_SET_TIMEOUT);
  2886. if (err < 0) {
  2887. dev_err(&udev->dev, "Failed to access otp area (%d)", err);
  2888. goto done;
  2889. }
  2890. memcpy(data, buf, size);
  2891. done:
  2892. kfree(buf);
  2893. return err;
  2894. }
  2895. static int btusb_setup_qca_download_fw(struct hci_dev *hdev,
  2896. const struct firmware *firmware,
  2897. size_t hdr_size)
  2898. {
  2899. struct btusb_data *btdata = hci_get_drvdata(hdev);
  2900. struct usb_device *udev = btdata->udev;
  2901. size_t count, size, sent = 0;
  2902. int pipe, len, err;
  2903. u8 *buf;
  2904. buf = kmalloc(QCA_DFU_PACKET_LEN, GFP_KERNEL);
  2905. if (!buf)
  2906. return -ENOMEM;
  2907. count = firmware->size;
  2908. size = min_t(size_t, count, hdr_size);
  2909. memcpy(buf, firmware->data, size);
  2910. /* USB patches should go down to controller through USB path
  2911. * because binary format fits to go down through USB channel.
  2912. * USB control path is for patching headers and USB bulk is for
  2913. * patch body.
  2914. */
  2915. pipe = usb_sndctrlpipe(udev, 0);
  2916. err = usb_control_msg(udev, pipe, QCA_DFU_DOWNLOAD, USB_TYPE_VENDOR,
  2917. 0, 0, buf, size, USB_CTRL_SET_TIMEOUT);
  2918. if (err < 0) {
  2919. bt_dev_err(hdev, "Failed to send headers (%d)", err);
  2920. goto done;
  2921. }
  2922. sent += size;
  2923. count -= size;
  2924. /* ep2 need time to switch from function acl to function dfu,
  2925. * so we add 20ms delay here.
  2926. */
  2927. msleep(20);
  2928. while (count) {
  2929. size = min_t(size_t, count, QCA_DFU_PACKET_LEN);
  2930. memcpy(buf, firmware->data + sent, size);
  2931. pipe = usb_sndbulkpipe(udev, 0x02);
  2932. err = usb_bulk_msg(udev, pipe, buf, size, &len,
  2933. QCA_DFU_TIMEOUT);
  2934. if (err < 0) {
  2935. bt_dev_err(hdev, "Failed to send body at %zd of %zd (%d)",
  2936. sent, firmware->size, err);
  2937. break;
  2938. }
  2939. if (size != len) {
  2940. bt_dev_err(hdev, "Failed to get bulk buffer");
  2941. err = -EILSEQ;
  2942. break;
  2943. }
  2944. sent += size;
  2945. count -= size;
  2946. }
  2947. done:
  2948. kfree(buf);
  2949. return err;
  2950. }
  2951. static int btusb_setup_qca_load_rampatch(struct hci_dev *hdev,
  2952. struct qca_version *ver,
  2953. const struct qca_device_info *info)
  2954. {
  2955. struct qca_rampatch_version *rver;
  2956. const struct firmware *fw;
  2957. u32 ver_rom, ver_patch, rver_rom;
  2958. u16 rver_rom_low, rver_rom_high, rver_patch;
  2959. char fwname[64];
  2960. int err;
  2961. ver_rom = le32_to_cpu(ver->rom_version);
  2962. ver_patch = le32_to_cpu(ver->patch_version);
  2963. snprintf(fwname, sizeof(fwname), "qca/rampatch_usb_%08x.bin", ver_rom);
  2964. err = request_firmware(&fw, fwname, &hdev->dev);
  2965. if (err) {
  2966. bt_dev_err(hdev, "failed to request rampatch file: %s (%d)",
  2967. fwname, err);
  2968. return err;
  2969. }
  2970. bt_dev_info(hdev, "using rampatch file: %s", fwname);
  2971. rver = (struct qca_rampatch_version *)(fw->data + info->ver_offset);
  2972. rver_rom_low = le16_to_cpu(rver->rom_version_low);
  2973. rver_patch = le16_to_cpu(rver->patch_version);
  2974. if (ver_rom & ~0xffffU) {
  2975. rver_rom_high = le16_to_cpu(rver->rom_version_high);
  2976. rver_rom = le32_to_cpu(rver_rom_high << 16 | rver_rom_low);
  2977. } else {
  2978. rver_rom = rver_rom_low;
  2979. }
  2980. bt_dev_info(hdev, "QCA: patch rome 0x%x build 0x%x, "
  2981. "firmware rome 0x%x build 0x%x",
  2982. rver_rom, rver_patch, ver_rom, ver_patch);
  2983. if (rver_rom != ver_rom || rver_patch <= ver_patch) {
  2984. bt_dev_err(hdev, "rampatch file version did not match with firmware");
  2985. err = -EINVAL;
  2986. goto done;
  2987. }
  2988. err = btusb_setup_qca_download_fw(hdev, fw, info->rampatch_hdr);
  2989. done:
  2990. release_firmware(fw);
  2991. return err;
  2992. }
  2993. static int btusb_setup_qca_load_nvm(struct hci_dev *hdev,
  2994. struct qca_version *ver,
  2995. const struct qca_device_info *info)
  2996. {
  2997. const struct firmware *fw;
  2998. char fwname[64];
  2999. int err;
  3000. snprintf(fwname, sizeof(fwname), "qca/nvm_usb_%08x.bin",
  3001. le32_to_cpu(ver->rom_version));
  3002. err = request_firmware(&fw, fwname, &hdev->dev);
  3003. if (err) {
  3004. bt_dev_err(hdev, "failed to request NVM file: %s (%d)",
  3005. fwname, err);
  3006. return err;
  3007. }
  3008. bt_dev_info(hdev, "using NVM file: %s", fwname);
  3009. err = btusb_setup_qca_download_fw(hdev, fw, info->nvm_hdr);
  3010. release_firmware(fw);
  3011. return err;
  3012. }
  3013. /* identify the ROM version and check whether patches are needed */
  3014. static bool btusb_qca_need_patch(struct usb_device *udev)
  3015. {
  3016. struct qca_version ver;
  3017. if (btusb_qca_send_vendor_req(udev, QCA_GET_TARGET_VERSION, &ver,
  3018. sizeof(ver)) < 0)
  3019. return false;
  3020. /* only low ROM versions need patches */
  3021. return !(le32_to_cpu(ver.rom_version) & ~0xffffU);
  3022. }
  3023. static int btusb_setup_qca(struct hci_dev *hdev)
  3024. {
  3025. struct btusb_data *btdata = hci_get_drvdata(hdev);
  3026. struct usb_device *udev = btdata->udev;
  3027. const struct qca_device_info *info = NULL;
  3028. struct qca_version ver;
  3029. u32 ver_rom;
  3030. u8 status;
  3031. int i, err;
  3032. err = btusb_qca_send_vendor_req(udev, QCA_GET_TARGET_VERSION, &ver,
  3033. sizeof(ver));
  3034. if (err < 0)
  3035. return err;
  3036. ver_rom = le32_to_cpu(ver.rom_version);
  3037. for (i = 0; i < ARRAY_SIZE(qca_devices_table); i++) {
  3038. if (ver_rom == qca_devices_table[i].rom_version)
  3039. info = &qca_devices_table[i];
  3040. }
  3041. if (!info) {
  3042. /* If the rom_version is not matched in the qca_devices_table
  3043. * and the high ROM version is not zero, we assume this chip no
  3044. * need to load the rampatch and nvm.
  3045. */
  3046. if (ver_rom & ~0xffffU)
  3047. return 0;
  3048. bt_dev_err(hdev, "don't support firmware rome 0x%x", ver_rom);
  3049. return -ENODEV;
  3050. }
  3051. err = btusb_qca_send_vendor_req(udev, QCA_CHECK_STATUS, &status,
  3052. sizeof(status));
  3053. if (err < 0)
  3054. return err;
  3055. if (!(status & QCA_PATCH_UPDATED)) {
  3056. err = btusb_setup_qca_load_rampatch(hdev, &ver, info);
  3057. if (err < 0)
  3058. return err;
  3059. }
  3060. if (!(status & QCA_SYSCFG_UPDATED)) {
  3061. err = btusb_setup_qca_load_nvm(hdev, &ver, info);
  3062. if (err < 0)
  3063. return err;
  3064. }
  3065. return 0;
  3066. }
  3067. static inline int __set_diag_interface(struct hci_dev *hdev)
  3068. {
  3069. struct btusb_data *data = hci_get_drvdata(hdev);
  3070. struct usb_interface *intf = data->diag;
  3071. int i;
  3072. if (!data->diag)
  3073. return -ENODEV;
  3074. data->diag_tx_ep = NULL;
  3075. data->diag_rx_ep = NULL;
  3076. for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
  3077. struct usb_endpoint_descriptor *ep_desc;
  3078. ep_desc = &intf->cur_altsetting->endpoint[i].desc;
  3079. if (!data->diag_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
  3080. data->diag_tx_ep = ep_desc;
  3081. continue;
  3082. }
  3083. if (!data->diag_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
  3084. data->diag_rx_ep = ep_desc;
  3085. continue;
  3086. }
  3087. }
  3088. if (!data->diag_tx_ep || !data->diag_rx_ep) {
  3089. bt_dev_err(hdev, "invalid diagnostic descriptors");
  3090. return -ENODEV;
  3091. }
  3092. return 0;
  3093. }
  3094. static struct urb *alloc_diag_urb(struct hci_dev *hdev, bool enable)
  3095. {
  3096. struct btusb_data *data = hci_get_drvdata(hdev);
  3097. struct sk_buff *skb;
  3098. struct urb *urb;
  3099. unsigned int pipe;
  3100. if (!data->diag_tx_ep)
  3101. return ERR_PTR(-ENODEV);
  3102. urb = usb_alloc_urb(0, GFP_KERNEL);
  3103. if (!urb)
  3104. return ERR_PTR(-ENOMEM);
  3105. skb = bt_skb_alloc(2, GFP_KERNEL);
  3106. if (!skb) {
  3107. usb_free_urb(urb);
  3108. return ERR_PTR(-ENOMEM);
  3109. }
  3110. skb_put_u8(skb, 0xf0);
  3111. skb_put_u8(skb, enable);
  3112. pipe = usb_sndbulkpipe(data->udev, data->diag_tx_ep->bEndpointAddress);
  3113. usb_fill_bulk_urb(urb, data->udev, pipe,
  3114. skb->data, skb->len, btusb_tx_complete, skb);
  3115. skb->dev = (void *)hdev;
  3116. return urb;
  3117. }
  3118. static int btusb_bcm_set_diag(struct hci_dev *hdev, bool enable)
  3119. {
  3120. struct btusb_data *data = hci_get_drvdata(hdev);
  3121. struct urb *urb;
  3122. if (!data->diag)
  3123. return -ENODEV;
  3124. if (!test_bit(HCI_RUNNING, &hdev->flags))
  3125. return -ENETDOWN;
  3126. urb = alloc_diag_urb(hdev, enable);
  3127. if (IS_ERR(urb))
  3128. return PTR_ERR(urb);
  3129. return submit_or_queue_tx_urb(hdev, urb);
  3130. }
  3131. #ifdef CONFIG_PM
  3132. static irqreturn_t btusb_oob_wake_handler(int irq, void *priv)
  3133. {
  3134. struct btusb_data *data = priv;
  3135. pm_wakeup_event(&data->udev->dev, 0);
  3136. pm_system_wakeup();
  3137. /* Disable only if not already disabled (keep it balanced) */
  3138. if (test_and_clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags)) {
  3139. disable_irq_nosync(irq);
  3140. disable_irq_wake(irq);
  3141. }
  3142. return IRQ_HANDLED;
  3143. }
  3144. static const struct of_device_id btusb_match_table[] = {
  3145. { .compatible = "usb1286,204e" },
  3146. { .compatible = "usbcf3,e300" }, /* QCA6174A */
  3147. { .compatible = "usb4ca,301a" }, /* QCA6174A (Lite-On) */
  3148. { }
  3149. };
  3150. MODULE_DEVICE_TABLE(of, btusb_match_table);
  3151. /* Use an oob wakeup pin? */
  3152. static int btusb_config_oob_wake(struct hci_dev *hdev)
  3153. {
  3154. struct btusb_data *data = hci_get_drvdata(hdev);
  3155. struct device *dev = &data->udev->dev;
  3156. int irq, ret;
  3157. clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags);
  3158. if (!of_match_device(btusb_match_table, dev))
  3159. return 0;
  3160. /* Move on if no IRQ specified */
  3161. irq = of_irq_get_byname(dev->of_node, "wakeup");
  3162. if (irq <= 0) {
  3163. bt_dev_dbg(hdev, "%s: no OOB Wakeup IRQ in DT", __func__);
  3164. return 0;
  3165. }
  3166. irq_set_status_flags(irq, IRQ_NOAUTOEN);
  3167. ret = devm_request_irq(&hdev->dev, irq, btusb_oob_wake_handler,
  3168. 0, "OOB Wake-on-BT", data);
  3169. if (ret) {
  3170. bt_dev_err(hdev, "%s: IRQ request failed", __func__);
  3171. return ret;
  3172. }
  3173. ret = device_init_wakeup(dev, true);
  3174. if (ret) {
  3175. bt_dev_err(hdev, "%s: failed to init_wakeup", __func__);
  3176. return ret;
  3177. }
  3178. data->oob_wake_irq = irq;
  3179. bt_dev_info(hdev, "OOB Wake-on-BT configured at IRQ %u", irq);
  3180. return 0;
  3181. }
  3182. #endif
  3183. static void btusb_check_needs_reset_resume(struct usb_interface *intf)
  3184. {
  3185. if (dmi_check_system(btusb_needs_reset_resume_table))
  3186. interface_to_usbdev(intf)->quirks |= USB_QUIRK_RESET_RESUME;
  3187. }
  3188. static bool btusb_prevent_wake(struct hci_dev *hdev)
  3189. {
  3190. struct btusb_data *data = hci_get_drvdata(hdev);
  3191. if (test_bit(BTUSB_WAKEUP_DISABLE, &data->flags))
  3192. return true;
  3193. return !device_may_wakeup(&data->udev->dev);
  3194. }
  3195. static int btusb_probe(struct usb_interface *intf,
  3196. const struct usb_device_id *id)
  3197. {
  3198. struct usb_endpoint_descriptor *ep_desc;
  3199. struct gpio_desc *reset_gpio;
  3200. struct btusb_data *data;
  3201. struct hci_dev *hdev;
  3202. unsigned ifnum_base;
  3203. int i, err;
  3204. BT_DBG("intf %p id %p", intf, id);
  3205. /* interface numbers are hardcoded in the spec */
  3206. if (intf->cur_altsetting->desc.bInterfaceNumber != 0) {
  3207. if (!(id->driver_info & BTUSB_IFNUM_2))
  3208. return -ENODEV;
  3209. if (intf->cur_altsetting->desc.bInterfaceNumber != 2)
  3210. return -ENODEV;
  3211. }
  3212. ifnum_base = intf->cur_altsetting->desc.bInterfaceNumber;
  3213. if (!id->driver_info) {
  3214. const struct usb_device_id *match;
  3215. match = usb_match_id(intf, blacklist_table);
  3216. if (match)
  3217. id = match;
  3218. }
  3219. if (id->driver_info == BTUSB_IGNORE)
  3220. return -ENODEV;
  3221. if (id->driver_info & BTUSB_ATH3012) {
  3222. struct usb_device *udev = interface_to_usbdev(intf);
  3223. /* Old firmware would otherwise let ath3k driver load
  3224. * patch and sysconfig files
  3225. */
  3226. if (le16_to_cpu(udev->descriptor.bcdDevice) <= 0x0001 &&
  3227. !btusb_qca_need_patch(udev))
  3228. return -ENODEV;
  3229. }
  3230. data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
  3231. if (!data)
  3232. return -ENOMEM;
  3233. for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
  3234. ep_desc = &intf->cur_altsetting->endpoint[i].desc;
  3235. if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {
  3236. data->intr_ep = ep_desc;
  3237. continue;
  3238. }
  3239. if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
  3240. data->bulk_tx_ep = ep_desc;
  3241. continue;
  3242. }
  3243. if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
  3244. data->bulk_rx_ep = ep_desc;
  3245. continue;
  3246. }
  3247. }
  3248. if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep)
  3249. return -ENODEV;
  3250. if (id->driver_info & BTUSB_AMP) {
  3251. data->cmdreq_type = USB_TYPE_CLASS | 0x01;
  3252. data->cmdreq = 0x2b;
  3253. } else {
  3254. data->cmdreq_type = USB_TYPE_CLASS;
  3255. data->cmdreq = 0x00;
  3256. }
  3257. data->udev = interface_to_usbdev(intf);
  3258. data->intf = intf;
  3259. INIT_WORK(&data->work, btusb_work);
  3260. INIT_WORK(&data->waker, btusb_waker);
  3261. init_usb_anchor(&data->deferred);
  3262. init_usb_anchor(&data->tx_anchor);
  3263. spin_lock_init(&data->txlock);
  3264. init_usb_anchor(&data->intr_anchor);
  3265. init_usb_anchor(&data->bulk_anchor);
  3266. init_usb_anchor(&data->isoc_anchor);
  3267. init_usb_anchor(&data->diag_anchor);
  3268. init_usb_anchor(&data->ctrl_anchor);
  3269. spin_lock_init(&data->rxlock);
  3270. if (id->driver_info & BTUSB_INTEL_NEW) {
  3271. data->recv_event = btusb_recv_event_intel;
  3272. data->recv_bulk = btusb_recv_bulk_intel;
  3273. set_bit(BTUSB_BOOTLOADER, &data->flags);
  3274. } else {
  3275. data->recv_event = hci_recv_frame;
  3276. data->recv_bulk = btusb_recv_bulk;
  3277. }
  3278. hdev = hci_alloc_dev();
  3279. if (!hdev)
  3280. return -ENOMEM;
  3281. hdev->bus = HCI_USB;
  3282. hci_set_drvdata(hdev, data);
  3283. if (id->driver_info & BTUSB_AMP)
  3284. hdev->dev_type = HCI_AMP;
  3285. else
  3286. hdev->dev_type = HCI_PRIMARY;
  3287. data->hdev = hdev;
  3288. SET_HCIDEV_DEV(hdev, &intf->dev);
  3289. reset_gpio = gpiod_get_optional(&data->udev->dev, "reset",
  3290. GPIOD_OUT_LOW);
  3291. if (IS_ERR(reset_gpio)) {
  3292. err = PTR_ERR(reset_gpio);
  3293. goto out_free_dev;
  3294. } else if (reset_gpio) {
  3295. data->reset_gpio = reset_gpio;
  3296. }
  3297. hdev->open = btusb_open;
  3298. hdev->close = btusb_close;
  3299. hdev->flush = btusb_flush;
  3300. hdev->send = btusb_send_frame;
  3301. hdev->notify = btusb_notify;
  3302. hdev->prevent_wake = btusb_prevent_wake;
  3303. #ifdef CONFIG_PM
  3304. err = btusb_config_oob_wake(hdev);
  3305. if (err)
  3306. goto out_free_dev;
  3307. /* Marvell devices may need a specific chip configuration */
  3308. if (id->driver_info & BTUSB_MARVELL && data->oob_wake_irq) {
  3309. err = marvell_config_oob_wake(hdev);
  3310. if (err)
  3311. goto out_free_dev;
  3312. }
  3313. #endif
  3314. if (id->driver_info & BTUSB_CW6622)
  3315. set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks);
  3316. if (id->driver_info & BTUSB_BCM2045)
  3317. set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks);
  3318. if (id->driver_info & BTUSB_BCM92035)
  3319. hdev->setup = btusb_setup_bcm92035;
  3320. if (IS_ENABLED(CONFIG_BT_HCIBTUSB_BCM) &&
  3321. (id->driver_info & BTUSB_BCM_PATCHRAM)) {
  3322. hdev->manufacturer = 15;
  3323. hdev->setup = btbcm_setup_patchram;
  3324. hdev->set_diag = btusb_bcm_set_diag;
  3325. hdev->set_bdaddr = btbcm_set_bdaddr;
  3326. /* Broadcom LM_DIAG Interface numbers are hardcoded */
  3327. data->diag = usb_ifnum_to_if(data->udev, ifnum_base + 2);
  3328. }
  3329. if (IS_ENABLED(CONFIG_BT_HCIBTUSB_BCM) &&
  3330. (id->driver_info & BTUSB_BCM_APPLE)) {
  3331. hdev->manufacturer = 15;
  3332. hdev->setup = btbcm_setup_apple;
  3333. hdev->set_diag = btusb_bcm_set_diag;
  3334. /* Broadcom LM_DIAG Interface numbers are hardcoded */
  3335. data->diag = usb_ifnum_to_if(data->udev, ifnum_base + 2);
  3336. }
  3337. if (id->driver_info & BTUSB_INTEL) {
  3338. hdev->manufacturer = 2;
  3339. hdev->setup = btusb_setup_intel;
  3340. hdev->shutdown = btusb_shutdown_intel;
  3341. hdev->set_diag = btintel_set_diag_mfg;
  3342. hdev->set_bdaddr = btintel_set_bdaddr;
  3343. hdev->cmd_timeout = btusb_intel_cmd_timeout;
  3344. set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
  3345. set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
  3346. set_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks);
  3347. }
  3348. if (id->driver_info & BTUSB_INTEL_NEW) {
  3349. hdev->manufacturer = 2;
  3350. hdev->send = btusb_send_frame_intel;
  3351. hdev->setup = btusb_setup_intel_new;
  3352. hdev->shutdown = btusb_shutdown_intel_new;
  3353. hdev->hw_error = btintel_hw_error;
  3354. hdev->set_diag = btintel_set_diag;
  3355. hdev->set_bdaddr = btintel_set_bdaddr;
  3356. hdev->cmd_timeout = btusb_intel_cmd_timeout;
  3357. set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
  3358. set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
  3359. set_bit(HCI_QUIRK_NON_PERSISTENT_DIAG, &hdev->quirks);
  3360. }
  3361. if (id->driver_info & BTUSB_MARVELL)
  3362. hdev->set_bdaddr = btusb_set_bdaddr_marvell;
  3363. if (IS_ENABLED(CONFIG_BT_HCIBTUSB_MTK) &&
  3364. (id->driver_info & BTUSB_MEDIATEK)) {
  3365. hdev->setup = btusb_mtk_setup;
  3366. hdev->shutdown = btusb_mtk_shutdown;
  3367. hdev->manufacturer = 70;
  3368. set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
  3369. }
  3370. if (id->driver_info & BTUSB_SWAVE) {
  3371. set_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks);
  3372. set_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks);
  3373. }
  3374. if (id->driver_info & BTUSB_INTEL_BOOT) {
  3375. hdev->manufacturer = 2;
  3376. set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
  3377. }
  3378. if (id->driver_info & BTUSB_ATH3012) {
  3379. data->setup_on_usb = btusb_setup_qca;
  3380. hdev->set_bdaddr = btusb_set_bdaddr_ath3012;
  3381. set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
  3382. set_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks);
  3383. }
  3384. if (id->driver_info & BTUSB_QCA_ROME) {
  3385. data->setup_on_usb = btusb_setup_qca;
  3386. hdev->set_bdaddr = btusb_set_bdaddr_ath3012;
  3387. hdev->cmd_timeout = btusb_qca_cmd_timeout;
  3388. set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
  3389. btusb_check_needs_reset_resume(intf);
  3390. }
  3391. if (id->driver_info & BTUSB_QCA_WCN6855) {
  3392. data->setup_on_usb = btusb_setup_qca;
  3393. hdev->set_bdaddr = btusb_set_bdaddr_wcn6855;
  3394. hdev->cmd_timeout = btusb_qca_cmd_timeout;
  3395. set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
  3396. }
  3397. if (id->driver_info & BTUSB_AMP) {
  3398. /* AMP controllers do not support SCO packets */
  3399. data->isoc = NULL;
  3400. } else {
  3401. /* Interface orders are hardcoded in the specification */
  3402. data->isoc = usb_ifnum_to_if(data->udev, ifnum_base + 1);
  3403. data->isoc_ifnum = ifnum_base + 1;
  3404. }
  3405. if (IS_ENABLED(CONFIG_BT_HCIBTUSB_RTL) &&
  3406. (id->driver_info & BTUSB_REALTEK)) {
  3407. hdev->setup = btrtl_setup_realtek;
  3408. hdev->shutdown = btrtl_shutdown_realtek;
  3409. hdev->cmd_timeout = btusb_rtl_cmd_timeout;
  3410. /* Realtek devices lose their updated firmware over global
  3411. * suspend that means host doesn't send SET_FEATURE
  3412. * (DEVICE_REMOTE_WAKEUP)
  3413. */
  3414. set_bit(BTUSB_WAKEUP_DISABLE, &data->flags);
  3415. set_bit(BTUSB_USE_ALT3_FOR_WBS, &data->flags);
  3416. }
  3417. if (!reset)
  3418. set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
  3419. if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {
  3420. if (!disable_scofix)
  3421. set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);
  3422. }
  3423. if (id->driver_info & BTUSB_BROKEN_ISOC)
  3424. data->isoc = NULL;
  3425. if (id->driver_info & BTUSB_WIDEBAND_SPEECH)
  3426. set_bit(HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED, &hdev->quirks);
  3427. if (id->driver_info & BTUSB_VALID_LE_STATES)
  3428. set_bit(HCI_QUIRK_VALID_LE_STATES, &hdev->quirks);
  3429. if (id->driver_info & BTUSB_DIGIANSWER) {
  3430. data->cmdreq_type = USB_TYPE_VENDOR;
  3431. set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
  3432. }
  3433. if (id->driver_info & BTUSB_CSR) {
  3434. struct usb_device *udev = data->udev;
  3435. u16 bcdDevice = le16_to_cpu(udev->descriptor.bcdDevice);
  3436. /* Old firmware would otherwise execute USB reset */
  3437. if (bcdDevice < 0x117)
  3438. set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
  3439. /* This must be set first in case we disable it for fakes */
  3440. set_bit(HCI_QUIRK_SIMULTANEOUS_DISCOVERY, &hdev->quirks);
  3441. /* Fake CSR devices with broken commands */
  3442. if (le16_to_cpu(udev->descriptor.idVendor) == 0x0a12 &&
  3443. le16_to_cpu(udev->descriptor.idProduct) == 0x0001)
  3444. hdev->setup = btusb_setup_csr;
  3445. }
  3446. if (id->driver_info & BTUSB_SNIFFER) {
  3447. struct usb_device *udev = data->udev;
  3448. /* New sniffer firmware has crippled HCI interface */
  3449. if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
  3450. set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
  3451. }
  3452. if (id->driver_info & BTUSB_INTEL_BOOT) {
  3453. /* A bug in the bootloader causes that interrupt interface is
  3454. * only enabled after receiving SetInterface(0, AltSetting=0).
  3455. */
  3456. err = usb_set_interface(data->udev, 0, 0);
  3457. if (err < 0) {
  3458. BT_ERR("failed to set interface 0, alt 0 %d", err);
  3459. goto out_free_dev;
  3460. }
  3461. }
  3462. if (data->isoc) {
  3463. err = usb_driver_claim_interface(&btusb_driver,
  3464. data->isoc, data);
  3465. if (err < 0)
  3466. goto out_free_dev;
  3467. }
  3468. if (IS_ENABLED(CONFIG_BT_HCIBTUSB_BCM) && data->diag) {
  3469. if (!usb_driver_claim_interface(&btusb_driver,
  3470. data->diag, data))
  3471. __set_diag_interface(hdev);
  3472. else
  3473. data->diag = NULL;
  3474. }
  3475. if (enable_autosuspend)
  3476. usb_enable_autosuspend(data->udev);
  3477. err = hci_register_dev(hdev);
  3478. if (err < 0)
  3479. goto out_free_dev;
  3480. usb_set_intfdata(intf, data);
  3481. return 0;
  3482. out_free_dev:
  3483. if (data->reset_gpio)
  3484. gpiod_put(data->reset_gpio);
  3485. hci_free_dev(hdev);
  3486. return err;
  3487. }
  3488. static void btusb_disconnect(struct usb_interface *intf)
  3489. {
  3490. struct btusb_data *data = usb_get_intfdata(intf);
  3491. struct hci_dev *hdev;
  3492. BT_DBG("intf %p", intf);
  3493. if (!data)
  3494. return;
  3495. hdev = data->hdev;
  3496. usb_set_intfdata(data->intf, NULL);
  3497. if (data->isoc)
  3498. usb_set_intfdata(data->isoc, NULL);
  3499. if (data->diag)
  3500. usb_set_intfdata(data->diag, NULL);
  3501. hci_unregister_dev(hdev);
  3502. if (intf == data->intf) {
  3503. if (data->isoc)
  3504. usb_driver_release_interface(&btusb_driver, data->isoc);
  3505. if (data->diag)
  3506. usb_driver_release_interface(&btusb_driver, data->diag);
  3507. } else if (intf == data->isoc) {
  3508. if (data->diag)
  3509. usb_driver_release_interface(&btusb_driver, data->diag);
  3510. usb_driver_release_interface(&btusb_driver, data->intf);
  3511. } else if (intf == data->diag) {
  3512. usb_driver_release_interface(&btusb_driver, data->intf);
  3513. if (data->isoc)
  3514. usb_driver_release_interface(&btusb_driver, data->isoc);
  3515. }
  3516. if (data->oob_wake_irq)
  3517. device_init_wakeup(&data->udev->dev, false);
  3518. if (data->reset_gpio)
  3519. gpiod_put(data->reset_gpio);
  3520. hci_free_dev(hdev);
  3521. }
  3522. #ifdef CONFIG_PM
  3523. static int btusb_suspend(struct usb_interface *intf, pm_message_t message)
  3524. {
  3525. struct btusb_data *data = usb_get_intfdata(intf);
  3526. BT_DBG("intf %p", intf);
  3527. if (data->suspend_count++)
  3528. return 0;
  3529. spin_lock_irq(&data->txlock);
  3530. if (!(PMSG_IS_AUTO(message) && data->tx_in_flight)) {
  3531. set_bit(BTUSB_SUSPENDING, &data->flags);
  3532. spin_unlock_irq(&data->txlock);
  3533. } else {
  3534. spin_unlock_irq(&data->txlock);
  3535. data->suspend_count--;
  3536. return -EBUSY;
  3537. }
  3538. cancel_work_sync(&data->work);
  3539. btusb_stop_traffic(data);
  3540. usb_kill_anchored_urbs(&data->tx_anchor);
  3541. if (data->oob_wake_irq && device_may_wakeup(&data->udev->dev)) {
  3542. set_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags);
  3543. enable_irq_wake(data->oob_wake_irq);
  3544. enable_irq(data->oob_wake_irq);
  3545. }
  3546. /* For global suspend, Realtek devices lose the loaded fw
  3547. * in them. But for autosuspend, firmware should remain.
  3548. * Actually, it depends on whether the usb host sends
  3549. * set feature (enable wakeup) or not.
  3550. */
  3551. if (test_bit(BTUSB_WAKEUP_DISABLE, &data->flags)) {
  3552. if (PMSG_IS_AUTO(message) &&
  3553. device_can_wakeup(&data->udev->dev))
  3554. data->udev->do_remote_wakeup = 1;
  3555. else if (!PMSG_IS_AUTO(message))
  3556. data->udev->reset_resume = 1;
  3557. }
  3558. return 0;
  3559. }
  3560. static void play_deferred(struct btusb_data *data)
  3561. {
  3562. struct urb *urb;
  3563. int err;
  3564. while ((urb = usb_get_from_anchor(&data->deferred))) {
  3565. usb_anchor_urb(urb, &data->tx_anchor);
  3566. err = usb_submit_urb(urb, GFP_ATOMIC);
  3567. if (err < 0) {
  3568. if (err != -EPERM && err != -ENODEV)
  3569. BT_ERR("%s urb %p submission failed (%d)",
  3570. data->hdev->name, urb, -err);
  3571. kfree(urb->setup_packet);
  3572. usb_unanchor_urb(urb);
  3573. usb_free_urb(urb);
  3574. break;
  3575. }
  3576. data->tx_in_flight++;
  3577. usb_free_urb(urb);
  3578. }
  3579. /* Cleanup the rest deferred urbs. */
  3580. while ((urb = usb_get_from_anchor(&data->deferred))) {
  3581. kfree(urb->setup_packet);
  3582. usb_free_urb(urb);
  3583. }
  3584. }
  3585. static int btusb_resume(struct usb_interface *intf)
  3586. {
  3587. struct btusb_data *data = usb_get_intfdata(intf);
  3588. struct hci_dev *hdev = data->hdev;
  3589. int err = 0;
  3590. BT_DBG("intf %p", intf);
  3591. if (--data->suspend_count)
  3592. return 0;
  3593. /* Disable only if not already disabled (keep it balanced) */
  3594. if (test_and_clear_bit(BTUSB_OOB_WAKE_ENABLED, &data->flags)) {
  3595. disable_irq(data->oob_wake_irq);
  3596. disable_irq_wake(data->oob_wake_irq);
  3597. }
  3598. if (!test_bit(HCI_RUNNING, &hdev->flags))
  3599. goto done;
  3600. if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {
  3601. err = btusb_submit_intr_urb(hdev, GFP_NOIO);
  3602. if (err < 0) {
  3603. clear_bit(BTUSB_INTR_RUNNING, &data->flags);
  3604. goto failed;
  3605. }
  3606. }
  3607. if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {
  3608. err = btusb_submit_bulk_urb(hdev, GFP_NOIO);
  3609. if (err < 0) {
  3610. clear_bit(BTUSB_BULK_RUNNING, &data->flags);
  3611. goto failed;
  3612. }
  3613. btusb_submit_bulk_urb(hdev, GFP_NOIO);
  3614. }
  3615. if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
  3616. if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)
  3617. clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
  3618. else
  3619. btusb_submit_isoc_urb(hdev, GFP_NOIO);
  3620. }
  3621. spin_lock_irq(&data->txlock);
  3622. play_deferred(data);
  3623. clear_bit(BTUSB_SUSPENDING, &data->flags);
  3624. spin_unlock_irq(&data->txlock);
  3625. schedule_work(&data->work);
  3626. return 0;
  3627. failed:
  3628. usb_scuttle_anchored_urbs(&data->deferred);
  3629. done:
  3630. spin_lock_irq(&data->txlock);
  3631. clear_bit(BTUSB_SUSPENDING, &data->flags);
  3632. spin_unlock_irq(&data->txlock);
  3633. return err;
  3634. }
  3635. #endif
  3636. static struct usb_driver btusb_driver = {
  3637. .name = "btusb",
  3638. .probe = btusb_probe,
  3639. .disconnect = btusb_disconnect,
  3640. #ifdef CONFIG_PM
  3641. .suspend = btusb_suspend,
  3642. .resume = btusb_resume,
  3643. #endif
  3644. .id_table = btusb_table,
  3645. .supports_autosuspend = 1,
  3646. .disable_hub_initiated_lpm = 1,
  3647. };
  3648. module_usb_driver(btusb_driver);
  3649. module_param(disable_scofix, bool, 0644);
  3650. MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");
  3651. module_param(force_scofix, bool, 0644);
  3652. MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");
  3653. module_param(enable_autosuspend, bool, 0644);
  3654. MODULE_PARM_DESC(enable_autosuspend, "Enable USB autosuspend by default");
  3655. module_param(reset, bool, 0644);
  3656. MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
  3657. MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
  3658. MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);
  3659. MODULE_VERSION(VERSION);
  3660. MODULE_LICENSE("GPL");