pn533.c 59 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598
  1. /*
  2. * Copyright (C) 2011 Instituto Nokia de Tecnologia
  3. * Copyright (C) 2012-2013 Tieto Poland
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation; either version 2 of the License, or
  8. * (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program; if not, write to the
  17. * Free Software Foundation, Inc.,
  18. * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19. */
  20. #include <linux/device.h>
  21. #include <linux/kernel.h>
  22. #include <linux/module.h>
  23. #include <linux/slab.h>
  24. #include <linux/usb.h>
  25. #include <linux/nfc.h>
  26. #include <linux/netdevice.h>
  27. #include <net/nfc/nfc.h>
  28. #define VERSION "0.1"
  29. #define PN533_VENDOR_ID 0x4CC
  30. #define PN533_PRODUCT_ID 0x2533
  31. #define SCM_VENDOR_ID 0x4E6
  32. #define SCL3711_PRODUCT_ID 0x5591
  33. #define SONY_VENDOR_ID 0x054c
  34. #define PASORI_PRODUCT_ID 0x02e1
  35. #define PN533_DEVICE_STD 0x1
  36. #define PN533_DEVICE_PASORI 0x2
  37. #define PN533_ALL_PROTOCOLS (NFC_PROTO_JEWEL_MASK | NFC_PROTO_MIFARE_MASK |\
  38. NFC_PROTO_FELICA_MASK | NFC_PROTO_ISO14443_MASK |\
  39. NFC_PROTO_NFC_DEP_MASK |\
  40. NFC_PROTO_ISO14443_B_MASK)
  41. #define PN533_NO_TYPE_B_PROTOCOLS (NFC_PROTO_JEWEL_MASK | \
  42. NFC_PROTO_MIFARE_MASK | \
  43. NFC_PROTO_FELICA_MASK | \
  44. NFC_PROTO_ISO14443_MASK | \
  45. NFC_PROTO_NFC_DEP_MASK)
  46. static const struct usb_device_id pn533_table[] = {
  47. { .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  48. .idVendor = PN533_VENDOR_ID,
  49. .idProduct = PN533_PRODUCT_ID,
  50. .driver_info = PN533_DEVICE_STD,
  51. },
  52. { .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  53. .idVendor = SCM_VENDOR_ID,
  54. .idProduct = SCL3711_PRODUCT_ID,
  55. .driver_info = PN533_DEVICE_STD,
  56. },
  57. { .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  58. .idVendor = SONY_VENDOR_ID,
  59. .idProduct = PASORI_PRODUCT_ID,
  60. .driver_info = PN533_DEVICE_PASORI,
  61. },
  62. { }
  63. };
  64. MODULE_DEVICE_TABLE(usb, pn533_table);
  65. /* How much time we spend listening for initiators */
  66. #define PN533_LISTEN_TIME 2
  67. /* Standard pn533 frame definitions */
  68. #define PN533_STD_FRAME_HEADER_LEN (sizeof(struct pn533_std_frame) \
  69. + 2) /* data[0] TFI, data[1] CC */
  70. #define PN533_STD_FRAME_TAIL_LEN 2 /* data[len] DCS, data[len + 1] postamble*/
  71. /*
  72. * Max extended frame payload len, excluding TFI and CC
  73. * which are already in PN533_FRAME_HEADER_LEN.
  74. */
  75. #define PN533_STD_FRAME_MAX_PAYLOAD_LEN 263
  76. #define PN533_STD_FRAME_ACK_SIZE 6 /* Preamble (1), SoPC (2), ACK Code (2),
  77. Postamble (1) */
  78. #define PN533_STD_FRAME_CHECKSUM(f) (f->data[f->datalen])
  79. #define PN533_STD_FRAME_POSTAMBLE(f) (f->data[f->datalen + 1])
  80. /* start of frame */
  81. #define PN533_STD_FRAME_SOF 0x00FF
  82. /* standard frame identifier: in/out/error */
  83. #define PN533_STD_FRAME_IDENTIFIER(f) (f->data[0]) /* TFI */
  84. #define PN533_STD_FRAME_DIR_OUT 0xD4
  85. #define PN533_STD_FRAME_DIR_IN 0xD5
  86. /* PN533 Commands */
  87. #define PN533_STD_FRAME_CMD(f) (f->data[1])
  88. #define PN533_CMD_GET_FIRMWARE_VERSION 0x02
  89. #define PN533_CMD_RF_CONFIGURATION 0x32
  90. #define PN533_CMD_IN_DATA_EXCHANGE 0x40
  91. #define PN533_CMD_IN_COMM_THRU 0x42
  92. #define PN533_CMD_IN_LIST_PASSIVE_TARGET 0x4A
  93. #define PN533_CMD_IN_ATR 0x50
  94. #define PN533_CMD_IN_RELEASE 0x52
  95. #define PN533_CMD_IN_JUMP_FOR_DEP 0x56
  96. #define PN533_CMD_TG_INIT_AS_TARGET 0x8c
  97. #define PN533_CMD_TG_GET_DATA 0x86
  98. #define PN533_CMD_TG_SET_DATA 0x8e
  99. #define PN533_CMD_UNDEF 0xff
  100. #define PN533_CMD_RESPONSE(cmd) (cmd + 1)
  101. /* PN533 Return codes */
  102. #define PN533_CMD_RET_MASK 0x3F
  103. #define PN533_CMD_MI_MASK 0x40
  104. #define PN533_CMD_RET_SUCCESS 0x00
  105. struct pn533;
  106. typedef int (*pn533_cmd_complete_t) (struct pn533 *dev, void *arg, int status);
  107. typedef int (*pn533_send_async_complete_t) (struct pn533 *dev, void *arg,
  108. struct sk_buff *resp);
  109. /* structs for pn533 commands */
  110. /* PN533_CMD_GET_FIRMWARE_VERSION */
  111. struct pn533_fw_version {
  112. u8 ic;
  113. u8 ver;
  114. u8 rev;
  115. u8 support;
  116. };
  117. /* PN533_CMD_RF_CONFIGURATION */
  118. #define PN533_CFGITEM_TIMING 0x02
  119. #define PN533_CFGITEM_MAX_RETRIES 0x05
  120. #define PN533_CFGITEM_PASORI 0x82
  121. #define PN533_CONFIG_TIMING_102 0xb
  122. #define PN533_CONFIG_TIMING_204 0xc
  123. #define PN533_CONFIG_TIMING_409 0xd
  124. #define PN533_CONFIG_TIMING_819 0xe
  125. #define PN533_CONFIG_MAX_RETRIES_NO_RETRY 0x00
  126. #define PN533_CONFIG_MAX_RETRIES_ENDLESS 0xFF
  127. struct pn533_config_max_retries {
  128. u8 mx_rty_atr;
  129. u8 mx_rty_psl;
  130. u8 mx_rty_passive_act;
  131. } __packed;
  132. struct pn533_config_timing {
  133. u8 rfu;
  134. u8 atr_res_timeout;
  135. u8 dep_timeout;
  136. } __packed;
  137. /* PN533_CMD_IN_LIST_PASSIVE_TARGET */
  138. /* felica commands opcode */
  139. #define PN533_FELICA_OPC_SENSF_REQ 0
  140. #define PN533_FELICA_OPC_SENSF_RES 1
  141. /* felica SENSF_REQ parameters */
  142. #define PN533_FELICA_SENSF_SC_ALL 0xFFFF
  143. #define PN533_FELICA_SENSF_RC_NO_SYSTEM_CODE 0
  144. #define PN533_FELICA_SENSF_RC_SYSTEM_CODE 1
  145. #define PN533_FELICA_SENSF_RC_ADVANCED_PROTOCOL 2
  146. /* type B initiator_data values */
  147. #define PN533_TYPE_B_AFI_ALL_FAMILIES 0
  148. #define PN533_TYPE_B_POLL_METHOD_TIMESLOT 0
  149. #define PN533_TYPE_B_POLL_METHOD_PROBABILISTIC 1
  150. union pn533_cmd_poll_initdata {
  151. struct {
  152. u8 afi;
  153. u8 polling_method;
  154. } __packed type_b;
  155. struct {
  156. u8 opcode;
  157. __be16 sc;
  158. u8 rc;
  159. u8 tsn;
  160. } __packed felica;
  161. };
  162. /* Poll modulations */
  163. enum {
  164. PN533_POLL_MOD_106KBPS_A,
  165. PN533_POLL_MOD_212KBPS_FELICA,
  166. PN533_POLL_MOD_424KBPS_FELICA,
  167. PN533_POLL_MOD_106KBPS_JEWEL,
  168. PN533_POLL_MOD_847KBPS_B,
  169. PN533_LISTEN_MOD,
  170. __PN533_POLL_MOD_AFTER_LAST,
  171. };
  172. #define PN533_POLL_MOD_MAX (__PN533_POLL_MOD_AFTER_LAST - 1)
  173. struct pn533_poll_modulations {
  174. struct {
  175. u8 maxtg;
  176. u8 brty;
  177. union pn533_cmd_poll_initdata initiator_data;
  178. } __packed data;
  179. u8 len;
  180. };
  181. static const struct pn533_poll_modulations poll_mod[] = {
  182. [PN533_POLL_MOD_106KBPS_A] = {
  183. .data = {
  184. .maxtg = 1,
  185. .brty = 0,
  186. },
  187. .len = 2,
  188. },
  189. [PN533_POLL_MOD_212KBPS_FELICA] = {
  190. .data = {
  191. .maxtg = 1,
  192. .brty = 1,
  193. .initiator_data.felica = {
  194. .opcode = PN533_FELICA_OPC_SENSF_REQ,
  195. .sc = PN533_FELICA_SENSF_SC_ALL,
  196. .rc = PN533_FELICA_SENSF_RC_NO_SYSTEM_CODE,
  197. .tsn = 0,
  198. },
  199. },
  200. .len = 7,
  201. },
  202. [PN533_POLL_MOD_424KBPS_FELICA] = {
  203. .data = {
  204. .maxtg = 1,
  205. .brty = 2,
  206. .initiator_data.felica = {
  207. .opcode = PN533_FELICA_OPC_SENSF_REQ,
  208. .sc = PN533_FELICA_SENSF_SC_ALL,
  209. .rc = PN533_FELICA_SENSF_RC_NO_SYSTEM_CODE,
  210. .tsn = 0,
  211. },
  212. },
  213. .len = 7,
  214. },
  215. [PN533_POLL_MOD_106KBPS_JEWEL] = {
  216. .data = {
  217. .maxtg = 1,
  218. .brty = 4,
  219. },
  220. .len = 2,
  221. },
  222. [PN533_POLL_MOD_847KBPS_B] = {
  223. .data = {
  224. .maxtg = 1,
  225. .brty = 8,
  226. .initiator_data.type_b = {
  227. .afi = PN533_TYPE_B_AFI_ALL_FAMILIES,
  228. .polling_method =
  229. PN533_TYPE_B_POLL_METHOD_TIMESLOT,
  230. },
  231. },
  232. .len = 3,
  233. },
  234. [PN533_LISTEN_MOD] = {
  235. .len = 0,
  236. },
  237. };
  238. /* PN533_CMD_IN_ATR */
  239. struct pn533_cmd_activate_response {
  240. u8 status;
  241. u8 nfcid3t[10];
  242. u8 didt;
  243. u8 bst;
  244. u8 brt;
  245. u8 to;
  246. u8 ppt;
  247. /* optional */
  248. u8 gt[];
  249. } __packed;
  250. struct pn533_cmd_jump_dep_response {
  251. u8 status;
  252. u8 tg;
  253. u8 nfcid3t[10];
  254. u8 didt;
  255. u8 bst;
  256. u8 brt;
  257. u8 to;
  258. u8 ppt;
  259. /* optional */
  260. u8 gt[];
  261. } __packed;
  262. /* PN533_TG_INIT_AS_TARGET */
  263. #define PN533_INIT_TARGET_PASSIVE 0x1
  264. #define PN533_INIT_TARGET_DEP 0x2
  265. #define PN533_INIT_TARGET_RESP_FRAME_MASK 0x3
  266. #define PN533_INIT_TARGET_RESP_ACTIVE 0x1
  267. #define PN533_INIT_TARGET_RESP_DEP 0x4
  268. struct pn533 {
  269. struct usb_device *udev;
  270. struct usb_interface *interface;
  271. struct nfc_dev *nfc_dev;
  272. struct urb *out_urb;
  273. struct urb *in_urb;
  274. struct sk_buff_head resp_q;
  275. struct workqueue_struct *wq;
  276. struct work_struct cmd_work;
  277. struct work_struct cmd_complete_work;
  278. struct work_struct poll_work;
  279. struct work_struct mi_work;
  280. struct work_struct tg_work;
  281. struct timer_list listen_timer;
  282. int wq_in_error;
  283. int cancel_listen;
  284. void *cmd_complete_mi_arg;
  285. struct mutex cmd_lock;
  286. struct pn533_cmd *cmd;
  287. struct pn533_poll_modulations *poll_mod_active[PN533_POLL_MOD_MAX + 1];
  288. u8 poll_mod_count;
  289. u8 poll_mod_curr;
  290. u32 poll_protocols;
  291. u32 listen_protocols;
  292. u8 *gb;
  293. size_t gb_len;
  294. u8 tgt_available_prots;
  295. u8 tgt_active_prot;
  296. u8 tgt_mode;
  297. u32 device_type;
  298. struct list_head cmd_queue;
  299. u8 cmd_pending;
  300. struct pn533_frame_ops *ops;
  301. };
  302. struct pn533_cmd {
  303. struct list_head queue;
  304. u8 code;
  305. struct sk_buff *req;
  306. struct sk_buff *resp;
  307. int resp_len;
  308. pn533_send_async_complete_t complete_cb;
  309. void *complete_cb_context;
  310. };
  311. struct pn533_std_frame {
  312. u8 preamble;
  313. __be16 start_frame;
  314. u8 datalen;
  315. u8 datalen_checksum;
  316. u8 data[];
  317. } __packed;
  318. struct pn533_frame_ops {
  319. void (*tx_frame_init)(void *frame, u8 cmd_code);
  320. void (*tx_frame_finish)(void *frame);
  321. void (*tx_update_payload_len)(void *frame, int len);
  322. int tx_header_len;
  323. int tx_tail_len;
  324. bool (*rx_is_frame_valid)(void *frame);
  325. int (*rx_frame_size)(void *frame);
  326. int rx_header_len;
  327. int rx_tail_len;
  328. int max_payload_len;
  329. u8 (*get_cmd_code)(void *frame);
  330. };
  331. /* The rule: value + checksum = 0 */
  332. static inline u8 pn533_std_checksum(u8 value)
  333. {
  334. return ~value + 1;
  335. }
  336. /* The rule: sum(data elements) + checksum = 0 */
  337. static u8 pn533_std_data_checksum(u8 *data, int datalen)
  338. {
  339. u8 sum = 0;
  340. int i;
  341. for (i = 0; i < datalen; i++)
  342. sum += data[i];
  343. return pn533_std_checksum(sum);
  344. }
  345. static void pn533_std_tx_frame_init(void *_frame, u8 cmd_code)
  346. {
  347. struct pn533_std_frame *frame = _frame;
  348. frame->preamble = 0;
  349. frame->start_frame = cpu_to_be16(PN533_STD_FRAME_SOF);
  350. PN533_STD_FRAME_IDENTIFIER(frame) = PN533_STD_FRAME_DIR_OUT;
  351. PN533_STD_FRAME_CMD(frame) = cmd_code;
  352. frame->datalen = 2;
  353. }
  354. static void pn533_std_tx_frame_finish(void *_frame)
  355. {
  356. struct pn533_std_frame *frame = _frame;
  357. frame->datalen_checksum = pn533_std_checksum(frame->datalen);
  358. PN533_STD_FRAME_CHECKSUM(frame) =
  359. pn533_std_data_checksum(frame->data, frame->datalen);
  360. PN533_STD_FRAME_POSTAMBLE(frame) = 0;
  361. }
  362. static void pn533_std_tx_update_payload_len(void *_frame, int len)
  363. {
  364. struct pn533_std_frame *frame = _frame;
  365. frame->datalen += len;
  366. }
  367. static bool pn533_std_rx_frame_is_valid(void *_frame)
  368. {
  369. u8 checksum;
  370. struct pn533_std_frame *frame = _frame;
  371. if (frame->start_frame != cpu_to_be16(PN533_STD_FRAME_SOF))
  372. return false;
  373. checksum = pn533_std_checksum(frame->datalen);
  374. if (checksum != frame->datalen_checksum)
  375. return false;
  376. checksum = pn533_std_data_checksum(frame->data, frame->datalen);
  377. if (checksum != PN533_STD_FRAME_CHECKSUM(frame))
  378. return false;
  379. return true;
  380. }
  381. static bool pn533_std_rx_frame_is_ack(struct pn533_std_frame *frame)
  382. {
  383. if (frame->start_frame != cpu_to_be16(PN533_STD_FRAME_SOF))
  384. return false;
  385. if (frame->datalen != 0 || frame->datalen_checksum != 0xFF)
  386. return false;
  387. return true;
  388. }
  389. static inline int pn533_std_rx_frame_size(void *frame)
  390. {
  391. struct pn533_std_frame *f = frame;
  392. return sizeof(struct pn533_std_frame) + f->datalen +
  393. PN533_STD_FRAME_TAIL_LEN;
  394. }
  395. static u8 pn533_std_get_cmd_code(void *frame)
  396. {
  397. struct pn533_std_frame *f = frame;
  398. return PN533_STD_FRAME_CMD(f);
  399. }
  400. static struct pn533_frame_ops pn533_std_frame_ops = {
  401. .tx_frame_init = pn533_std_tx_frame_init,
  402. .tx_frame_finish = pn533_std_tx_frame_finish,
  403. .tx_update_payload_len = pn533_std_tx_update_payload_len,
  404. .tx_header_len = PN533_STD_FRAME_HEADER_LEN,
  405. .tx_tail_len = PN533_STD_FRAME_TAIL_LEN,
  406. .rx_is_frame_valid = pn533_std_rx_frame_is_valid,
  407. .rx_frame_size = pn533_std_rx_frame_size,
  408. .rx_header_len = PN533_STD_FRAME_HEADER_LEN,
  409. .rx_tail_len = PN533_STD_FRAME_TAIL_LEN,
  410. .max_payload_len = PN533_STD_FRAME_MAX_PAYLOAD_LEN,
  411. .get_cmd_code = pn533_std_get_cmd_code,
  412. };
  413. static bool pn533_rx_frame_is_cmd_response(struct pn533 *dev, void *frame)
  414. {
  415. return (dev->ops->get_cmd_code(frame) ==
  416. PN533_CMD_RESPONSE(dev->cmd->code));
  417. }
  418. static void pn533_recv_response(struct urb *urb)
  419. {
  420. struct pn533 *dev = urb->context;
  421. u8 *in_frame;
  422. switch (urb->status) {
  423. case 0:
  424. break; /* success */
  425. case -ECONNRESET:
  426. case -ENOENT:
  427. nfc_dev_dbg(&dev->interface->dev,
  428. "The urb has been canceled (status %d)",
  429. urb->status);
  430. dev->wq_in_error = urb->status;
  431. goto sched_wq;
  432. case -ESHUTDOWN:
  433. default:
  434. nfc_dev_err(&dev->interface->dev,
  435. "Urb failure (status %d)", urb->status);
  436. dev->wq_in_error = urb->status;
  437. goto sched_wq;
  438. }
  439. in_frame = dev->in_urb->transfer_buffer;
  440. nfc_dev_dbg(&dev->interface->dev, "Received a frame.");
  441. print_hex_dump_debug("PN533 RX: ", DUMP_PREFIX_NONE, 16, 1, in_frame,
  442. dev->ops->rx_frame_size(in_frame), false);
  443. if (!dev->ops->rx_is_frame_valid(in_frame)) {
  444. nfc_dev_err(&dev->interface->dev, "Received an invalid frame");
  445. dev->wq_in_error = -EIO;
  446. goto sched_wq;
  447. }
  448. if (!pn533_rx_frame_is_cmd_response(dev, in_frame)) {
  449. nfc_dev_err(&dev->interface->dev,
  450. "It it not the response to the last command");
  451. dev->wq_in_error = -EIO;
  452. goto sched_wq;
  453. }
  454. dev->wq_in_error = 0;
  455. sched_wq:
  456. queue_work(dev->wq, &dev->cmd_complete_work);
  457. }
  458. static int pn533_submit_urb_for_response(struct pn533 *dev, gfp_t flags)
  459. {
  460. dev->in_urb->complete = pn533_recv_response;
  461. return usb_submit_urb(dev->in_urb, flags);
  462. }
  463. static void pn533_recv_ack(struct urb *urb)
  464. {
  465. struct pn533 *dev = urb->context;
  466. struct pn533_std_frame *in_frame;
  467. int rc;
  468. switch (urb->status) {
  469. case 0:
  470. break; /* success */
  471. case -ECONNRESET:
  472. case -ENOENT:
  473. nfc_dev_dbg(&dev->interface->dev,
  474. "The urb has been stopped (status %d)",
  475. urb->status);
  476. dev->wq_in_error = urb->status;
  477. goto sched_wq;
  478. case -ESHUTDOWN:
  479. default:
  480. nfc_dev_err(&dev->interface->dev,
  481. "Urb failure (status %d)", urb->status);
  482. dev->wq_in_error = urb->status;
  483. goto sched_wq;
  484. }
  485. in_frame = dev->in_urb->transfer_buffer;
  486. if (!pn533_std_rx_frame_is_ack(in_frame)) {
  487. nfc_dev_err(&dev->interface->dev, "Received an invalid ack");
  488. dev->wq_in_error = -EIO;
  489. goto sched_wq;
  490. }
  491. rc = pn533_submit_urb_for_response(dev, GFP_ATOMIC);
  492. if (rc) {
  493. nfc_dev_err(&dev->interface->dev,
  494. "usb_submit_urb failed with result %d", rc);
  495. dev->wq_in_error = rc;
  496. goto sched_wq;
  497. }
  498. return;
  499. sched_wq:
  500. queue_work(dev->wq, &dev->cmd_complete_work);
  501. }
  502. static int pn533_submit_urb_for_ack(struct pn533 *dev, gfp_t flags)
  503. {
  504. dev->in_urb->complete = pn533_recv_ack;
  505. return usb_submit_urb(dev->in_urb, flags);
  506. }
  507. static int pn533_send_ack(struct pn533 *dev, gfp_t flags)
  508. {
  509. u8 ack[PN533_STD_FRAME_ACK_SIZE] = {0x00, 0x00, 0xff, 0x00, 0xff, 0x00};
  510. /* spec 7.1.1.3: Preamble, SoPC (2), ACK Code (2), Postamble */
  511. int rc;
  512. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  513. dev->out_urb->transfer_buffer = ack;
  514. dev->out_urb->transfer_buffer_length = sizeof(ack);
  515. rc = usb_submit_urb(dev->out_urb, flags);
  516. return rc;
  517. }
  518. static int __pn533_send_frame_async(struct pn533 *dev,
  519. struct sk_buff *out,
  520. struct sk_buff *in,
  521. int in_len)
  522. {
  523. int rc;
  524. dev->out_urb->transfer_buffer = out->data;
  525. dev->out_urb->transfer_buffer_length = out->len;
  526. dev->in_urb->transfer_buffer = in->data;
  527. dev->in_urb->transfer_buffer_length = in_len;
  528. print_hex_dump_debug("PN533 TX: ", DUMP_PREFIX_NONE, 16, 1,
  529. out->data, out->len, false);
  530. rc = usb_submit_urb(dev->out_urb, GFP_KERNEL);
  531. if (rc)
  532. return rc;
  533. rc = pn533_submit_urb_for_ack(dev, GFP_KERNEL);
  534. if (rc)
  535. goto error;
  536. return 0;
  537. error:
  538. usb_unlink_urb(dev->out_urb);
  539. return rc;
  540. }
  541. static void pn533_build_cmd_frame(struct pn533 *dev, u8 cmd_code,
  542. struct sk_buff *skb)
  543. {
  544. /* payload is already there, just update datalen */
  545. int payload_len = skb->len;
  546. struct pn533_frame_ops *ops = dev->ops;
  547. skb_push(skb, ops->tx_header_len);
  548. skb_put(skb, ops->tx_tail_len);
  549. ops->tx_frame_init(skb->data, cmd_code);
  550. ops->tx_update_payload_len(skb->data, payload_len);
  551. ops->tx_frame_finish(skb->data);
  552. }
  553. static int pn533_send_async_complete(struct pn533 *dev)
  554. {
  555. struct pn533_cmd *cmd = dev->cmd;
  556. int status = dev->wq_in_error;
  557. struct sk_buff *req = cmd->req;
  558. struct sk_buff *resp = cmd->resp;
  559. int rc;
  560. dev_kfree_skb(req);
  561. if (status < 0) {
  562. rc = cmd->complete_cb(dev, cmd->complete_cb_context,
  563. ERR_PTR(status));
  564. dev_kfree_skb(resp);
  565. goto done;
  566. }
  567. skb_put(resp, dev->ops->rx_frame_size(resp->data));
  568. skb_pull(resp, dev->ops->rx_header_len);
  569. skb_trim(resp, resp->len - dev->ops->rx_tail_len);
  570. rc = cmd->complete_cb(dev, cmd->complete_cb_context, resp);
  571. done:
  572. kfree(cmd);
  573. dev->cmd = NULL;
  574. return rc;
  575. }
  576. static int __pn533_send_async(struct pn533 *dev, u8 cmd_code,
  577. struct sk_buff *req, struct sk_buff *resp,
  578. int resp_len,
  579. pn533_send_async_complete_t complete_cb,
  580. void *complete_cb_context)
  581. {
  582. struct pn533_cmd *cmd;
  583. int rc = 0;
  584. nfc_dev_dbg(&dev->interface->dev, "Sending command 0x%x", cmd_code);
  585. cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
  586. if (!cmd)
  587. return -ENOMEM;
  588. cmd->code = cmd_code;
  589. cmd->req = req;
  590. cmd->resp = resp;
  591. cmd->resp_len = resp_len;
  592. cmd->complete_cb = complete_cb;
  593. cmd->complete_cb_context = complete_cb_context;
  594. pn533_build_cmd_frame(dev, cmd_code, req);
  595. mutex_lock(&dev->cmd_lock);
  596. if (!dev->cmd_pending) {
  597. rc = __pn533_send_frame_async(dev, req, resp, resp_len);
  598. if (rc)
  599. goto error;
  600. dev->cmd_pending = 1;
  601. dev->cmd = cmd;
  602. goto unlock;
  603. }
  604. nfc_dev_dbg(&dev->interface->dev, "%s Queueing command 0x%x", __func__,
  605. cmd_code);
  606. INIT_LIST_HEAD(&cmd->queue);
  607. list_add_tail(&cmd->queue, &dev->cmd_queue);
  608. goto unlock;
  609. error:
  610. kfree(cmd);
  611. unlock:
  612. mutex_unlock(&dev->cmd_lock);
  613. return rc;
  614. }
  615. static int pn533_send_data_async(struct pn533 *dev, u8 cmd_code,
  616. struct sk_buff *req,
  617. pn533_send_async_complete_t complete_cb,
  618. void *complete_cb_context)
  619. {
  620. struct sk_buff *resp;
  621. int rc;
  622. int resp_len = dev->ops->rx_header_len +
  623. dev->ops->max_payload_len +
  624. dev->ops->rx_tail_len;
  625. resp = nfc_alloc_recv_skb(resp_len, GFP_KERNEL);
  626. if (!resp)
  627. return -ENOMEM;
  628. rc = __pn533_send_async(dev, cmd_code, req, resp, resp_len, complete_cb,
  629. complete_cb_context);
  630. if (rc)
  631. dev_kfree_skb(resp);
  632. return rc;
  633. }
  634. static int pn533_send_cmd_async(struct pn533 *dev, u8 cmd_code,
  635. struct sk_buff *req,
  636. pn533_send_async_complete_t complete_cb,
  637. void *complete_cb_context)
  638. {
  639. struct sk_buff *resp;
  640. int rc;
  641. int resp_len = dev->ops->rx_header_len +
  642. dev->ops->max_payload_len +
  643. dev->ops->rx_tail_len;
  644. resp = alloc_skb(resp_len, GFP_KERNEL);
  645. if (!resp)
  646. return -ENOMEM;
  647. rc = __pn533_send_async(dev, cmd_code, req, resp, resp_len, complete_cb,
  648. complete_cb_context);
  649. if (rc)
  650. dev_kfree_skb(resp);
  651. return rc;
  652. }
  653. /*
  654. * pn533_send_cmd_direct_async
  655. *
  656. * The function sends a piority cmd directly to the chip omiting the cmd
  657. * queue. It's intended to be used by chaining mechanism of received responses
  658. * where the host has to request every single chunk of data before scheduling
  659. * next cmd from the queue.
  660. */
  661. static int pn533_send_cmd_direct_async(struct pn533 *dev, u8 cmd_code,
  662. struct sk_buff *req,
  663. pn533_send_async_complete_t complete_cb,
  664. void *complete_cb_context)
  665. {
  666. struct sk_buff *resp;
  667. struct pn533_cmd *cmd;
  668. int rc;
  669. int resp_len = dev->ops->rx_header_len +
  670. dev->ops->max_payload_len +
  671. dev->ops->rx_tail_len;
  672. resp = alloc_skb(resp_len, GFP_KERNEL);
  673. if (!resp)
  674. return -ENOMEM;
  675. cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
  676. if (!cmd) {
  677. dev_kfree_skb(resp);
  678. return -ENOMEM;
  679. }
  680. cmd->code = cmd_code;
  681. cmd->req = req;
  682. cmd->resp = resp;
  683. cmd->resp_len = resp_len;
  684. cmd->complete_cb = complete_cb;
  685. cmd->complete_cb_context = complete_cb_context;
  686. pn533_build_cmd_frame(dev, cmd_code, req);
  687. rc = __pn533_send_frame_async(dev, req, resp, resp_len);
  688. if (rc < 0) {
  689. dev_kfree_skb(resp);
  690. kfree(cmd);
  691. } else {
  692. dev->cmd = cmd;
  693. }
  694. return rc;
  695. }
  696. static void pn533_wq_cmd_complete(struct work_struct *work)
  697. {
  698. struct pn533 *dev = container_of(work, struct pn533, cmd_complete_work);
  699. int rc;
  700. rc = pn533_send_async_complete(dev);
  701. if (rc != -EINPROGRESS)
  702. queue_work(dev->wq, &dev->cmd_work);
  703. }
  704. static void pn533_wq_cmd(struct work_struct *work)
  705. {
  706. struct pn533 *dev = container_of(work, struct pn533, cmd_work);
  707. struct pn533_cmd *cmd;
  708. int rc;
  709. mutex_lock(&dev->cmd_lock);
  710. if (list_empty(&dev->cmd_queue)) {
  711. dev->cmd_pending = 0;
  712. mutex_unlock(&dev->cmd_lock);
  713. return;
  714. }
  715. cmd = list_first_entry(&dev->cmd_queue, struct pn533_cmd, queue);
  716. list_del(&cmd->queue);
  717. mutex_unlock(&dev->cmd_lock);
  718. rc = __pn533_send_frame_async(dev, cmd->req, cmd->resp, cmd->resp_len);
  719. if (rc < 0) {
  720. dev_kfree_skb(cmd->req);
  721. dev_kfree_skb(cmd->resp);
  722. kfree(cmd);
  723. return;
  724. }
  725. dev->cmd = cmd;
  726. }
  727. struct pn533_sync_cmd_response {
  728. struct sk_buff *resp;
  729. struct completion done;
  730. };
  731. static int pn533_send_sync_complete(struct pn533 *dev, void *_arg,
  732. struct sk_buff *resp)
  733. {
  734. struct pn533_sync_cmd_response *arg = _arg;
  735. arg->resp = resp;
  736. complete(&arg->done);
  737. return 0;
  738. }
  739. /* pn533_send_cmd_sync
  740. *
  741. * Please note the req parameter is freed inside the function to
  742. * limit a number of return value interpretations by the caller.
  743. *
  744. * 1. negative in case of error during TX path -> req should be freed
  745. *
  746. * 2. negative in case of error during RX path -> req should not be freed
  747. * as it's been already freed at the begining of RX path by
  748. * async_complete_cb.
  749. *
  750. * 3. valid pointer in case of succesfult RX path
  751. *
  752. * A caller has to check a return value with IS_ERR macro. If the test pass,
  753. * the returned pointer is valid.
  754. *
  755. * */
  756. static struct sk_buff *pn533_send_cmd_sync(struct pn533 *dev, u8 cmd_code,
  757. struct sk_buff *req)
  758. {
  759. int rc;
  760. struct pn533_sync_cmd_response arg;
  761. init_completion(&arg.done);
  762. rc = pn533_send_cmd_async(dev, cmd_code, req,
  763. pn533_send_sync_complete, &arg);
  764. if (rc) {
  765. dev_kfree_skb(req);
  766. return ERR_PTR(rc);
  767. }
  768. wait_for_completion(&arg.done);
  769. return arg.resp;
  770. }
  771. static void pn533_send_complete(struct urb *urb)
  772. {
  773. struct pn533 *dev = urb->context;
  774. switch (urb->status) {
  775. case 0:
  776. break; /* success */
  777. case -ECONNRESET:
  778. case -ENOENT:
  779. nfc_dev_dbg(&dev->interface->dev,
  780. "The urb has been stopped (status %d)",
  781. urb->status);
  782. break;
  783. case -ESHUTDOWN:
  784. default:
  785. nfc_dev_err(&dev->interface->dev,
  786. "Urb failure (status %d)", urb->status);
  787. }
  788. }
  789. static struct sk_buff *pn533_alloc_skb(struct pn533 *dev, unsigned int size)
  790. {
  791. struct sk_buff *skb;
  792. skb = alloc_skb(dev->ops->tx_header_len +
  793. size +
  794. dev->ops->tx_tail_len, GFP_KERNEL);
  795. if (skb)
  796. skb_reserve(skb, dev->ops->tx_header_len);
  797. return skb;
  798. }
  799. struct pn533_target_type_a {
  800. __be16 sens_res;
  801. u8 sel_res;
  802. u8 nfcid_len;
  803. u8 nfcid_data[];
  804. } __packed;
  805. #define PN533_TYPE_A_SENS_RES_NFCID1(x) ((u8)((be16_to_cpu(x) & 0x00C0) >> 6))
  806. #define PN533_TYPE_A_SENS_RES_SSD(x) ((u8)((be16_to_cpu(x) & 0x001F) >> 0))
  807. #define PN533_TYPE_A_SENS_RES_PLATCONF(x) ((u8)((be16_to_cpu(x) & 0x0F00) >> 8))
  808. #define PN533_TYPE_A_SENS_RES_SSD_JEWEL 0x00
  809. #define PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL 0x0C
  810. #define PN533_TYPE_A_SEL_PROT(x) (((x) & 0x60) >> 5)
  811. #define PN533_TYPE_A_SEL_CASCADE(x) (((x) & 0x04) >> 2)
  812. #define PN533_TYPE_A_SEL_PROT_MIFARE 0
  813. #define PN533_TYPE_A_SEL_PROT_ISO14443 1
  814. #define PN533_TYPE_A_SEL_PROT_DEP 2
  815. #define PN533_TYPE_A_SEL_PROT_ISO14443_DEP 3
  816. static bool pn533_target_type_a_is_valid(struct pn533_target_type_a *type_a,
  817. int target_data_len)
  818. {
  819. u8 ssd;
  820. u8 platconf;
  821. if (target_data_len < sizeof(struct pn533_target_type_a))
  822. return false;
  823. /* The lenght check of nfcid[] and ats[] are not being performed because
  824. the values are not being used */
  825. /* Requirement 4.6.3.3 from NFC Forum Digital Spec */
  826. ssd = PN533_TYPE_A_SENS_RES_SSD(type_a->sens_res);
  827. platconf = PN533_TYPE_A_SENS_RES_PLATCONF(type_a->sens_res);
  828. if ((ssd == PN533_TYPE_A_SENS_RES_SSD_JEWEL &&
  829. platconf != PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL) ||
  830. (ssd != PN533_TYPE_A_SENS_RES_SSD_JEWEL &&
  831. platconf == PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL))
  832. return false;
  833. /* Requirements 4.8.2.1, 4.8.2.3, 4.8.2.5 and 4.8.2.7 from NFC Forum */
  834. if (PN533_TYPE_A_SEL_CASCADE(type_a->sel_res) != 0)
  835. return false;
  836. return true;
  837. }
  838. static int pn533_target_found_type_a(struct nfc_target *nfc_tgt, u8 *tgt_data,
  839. int tgt_data_len)
  840. {
  841. struct pn533_target_type_a *tgt_type_a;
  842. tgt_type_a = (struct pn533_target_type_a *)tgt_data;
  843. if (!pn533_target_type_a_is_valid(tgt_type_a, tgt_data_len))
  844. return -EPROTO;
  845. switch (PN533_TYPE_A_SEL_PROT(tgt_type_a->sel_res)) {
  846. case PN533_TYPE_A_SEL_PROT_MIFARE:
  847. nfc_tgt->supported_protocols = NFC_PROTO_MIFARE_MASK;
  848. break;
  849. case PN533_TYPE_A_SEL_PROT_ISO14443:
  850. nfc_tgt->supported_protocols = NFC_PROTO_ISO14443_MASK;
  851. break;
  852. case PN533_TYPE_A_SEL_PROT_DEP:
  853. nfc_tgt->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
  854. break;
  855. case PN533_TYPE_A_SEL_PROT_ISO14443_DEP:
  856. nfc_tgt->supported_protocols = NFC_PROTO_ISO14443_MASK |
  857. NFC_PROTO_NFC_DEP_MASK;
  858. break;
  859. }
  860. nfc_tgt->sens_res = be16_to_cpu(tgt_type_a->sens_res);
  861. nfc_tgt->sel_res = tgt_type_a->sel_res;
  862. nfc_tgt->nfcid1_len = tgt_type_a->nfcid_len;
  863. memcpy(nfc_tgt->nfcid1, tgt_type_a->nfcid_data, nfc_tgt->nfcid1_len);
  864. return 0;
  865. }
  866. struct pn533_target_felica {
  867. u8 pol_res;
  868. u8 opcode;
  869. u8 nfcid2[8];
  870. u8 pad[8];
  871. /* optional */
  872. u8 syst_code[];
  873. } __packed;
  874. #define PN533_FELICA_SENSF_NFCID2_DEP_B1 0x01
  875. #define PN533_FELICA_SENSF_NFCID2_DEP_B2 0xFE
  876. static bool pn533_target_felica_is_valid(struct pn533_target_felica *felica,
  877. int target_data_len)
  878. {
  879. if (target_data_len < sizeof(struct pn533_target_felica))
  880. return false;
  881. if (felica->opcode != PN533_FELICA_OPC_SENSF_RES)
  882. return false;
  883. return true;
  884. }
  885. static int pn533_target_found_felica(struct nfc_target *nfc_tgt, u8 *tgt_data,
  886. int tgt_data_len)
  887. {
  888. struct pn533_target_felica *tgt_felica;
  889. tgt_felica = (struct pn533_target_felica *)tgt_data;
  890. if (!pn533_target_felica_is_valid(tgt_felica, tgt_data_len))
  891. return -EPROTO;
  892. if ((tgt_felica->nfcid2[0] == PN533_FELICA_SENSF_NFCID2_DEP_B1) &&
  893. (tgt_felica->nfcid2[1] == PN533_FELICA_SENSF_NFCID2_DEP_B2))
  894. nfc_tgt->supported_protocols = NFC_PROTO_NFC_DEP_MASK;
  895. else
  896. nfc_tgt->supported_protocols = NFC_PROTO_FELICA_MASK;
  897. memcpy(nfc_tgt->sensf_res, &tgt_felica->opcode, 9);
  898. nfc_tgt->sensf_res_len = 9;
  899. return 0;
  900. }
  901. struct pn533_target_jewel {
  902. __be16 sens_res;
  903. u8 jewelid[4];
  904. } __packed;
  905. static bool pn533_target_jewel_is_valid(struct pn533_target_jewel *jewel,
  906. int target_data_len)
  907. {
  908. u8 ssd;
  909. u8 platconf;
  910. if (target_data_len < sizeof(struct pn533_target_jewel))
  911. return false;
  912. /* Requirement 4.6.3.3 from NFC Forum Digital Spec */
  913. ssd = PN533_TYPE_A_SENS_RES_SSD(jewel->sens_res);
  914. platconf = PN533_TYPE_A_SENS_RES_PLATCONF(jewel->sens_res);
  915. if ((ssd == PN533_TYPE_A_SENS_RES_SSD_JEWEL &&
  916. platconf != PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL) ||
  917. (ssd != PN533_TYPE_A_SENS_RES_SSD_JEWEL &&
  918. platconf == PN533_TYPE_A_SENS_RES_PLATCONF_JEWEL))
  919. return false;
  920. return true;
  921. }
  922. static int pn533_target_found_jewel(struct nfc_target *nfc_tgt, u8 *tgt_data,
  923. int tgt_data_len)
  924. {
  925. struct pn533_target_jewel *tgt_jewel;
  926. tgt_jewel = (struct pn533_target_jewel *)tgt_data;
  927. if (!pn533_target_jewel_is_valid(tgt_jewel, tgt_data_len))
  928. return -EPROTO;
  929. nfc_tgt->supported_protocols = NFC_PROTO_JEWEL_MASK;
  930. nfc_tgt->sens_res = be16_to_cpu(tgt_jewel->sens_res);
  931. nfc_tgt->nfcid1_len = 4;
  932. memcpy(nfc_tgt->nfcid1, tgt_jewel->jewelid, nfc_tgt->nfcid1_len);
  933. return 0;
  934. }
  935. struct pn533_type_b_prot_info {
  936. u8 bitrate;
  937. u8 fsci_type;
  938. u8 fwi_adc_fo;
  939. } __packed;
  940. #define PN533_TYPE_B_PROT_FCSI(x) (((x) & 0xF0) >> 4)
  941. #define PN533_TYPE_B_PROT_TYPE(x) (((x) & 0x0F) >> 0)
  942. #define PN533_TYPE_B_PROT_TYPE_RFU_MASK 0x8
  943. struct pn533_type_b_sens_res {
  944. u8 opcode;
  945. u8 nfcid[4];
  946. u8 appdata[4];
  947. struct pn533_type_b_prot_info prot_info;
  948. } __packed;
  949. #define PN533_TYPE_B_OPC_SENSB_RES 0x50
  950. struct pn533_target_type_b {
  951. struct pn533_type_b_sens_res sensb_res;
  952. u8 attrib_res_len;
  953. u8 attrib_res[];
  954. } __packed;
  955. static bool pn533_target_type_b_is_valid(struct pn533_target_type_b *type_b,
  956. int target_data_len)
  957. {
  958. if (target_data_len < sizeof(struct pn533_target_type_b))
  959. return false;
  960. if (type_b->sensb_res.opcode != PN533_TYPE_B_OPC_SENSB_RES)
  961. return false;
  962. if (PN533_TYPE_B_PROT_TYPE(type_b->sensb_res.prot_info.fsci_type) &
  963. PN533_TYPE_B_PROT_TYPE_RFU_MASK)
  964. return false;
  965. return true;
  966. }
  967. static int pn533_target_found_type_b(struct nfc_target *nfc_tgt, u8 *tgt_data,
  968. int tgt_data_len)
  969. {
  970. struct pn533_target_type_b *tgt_type_b;
  971. tgt_type_b = (struct pn533_target_type_b *)tgt_data;
  972. if (!pn533_target_type_b_is_valid(tgt_type_b, tgt_data_len))
  973. return -EPROTO;
  974. nfc_tgt->supported_protocols = NFC_PROTO_ISO14443_B_MASK;
  975. return 0;
  976. }
  977. static int pn533_target_found(struct pn533 *dev, u8 tg, u8 *tgdata,
  978. int tgdata_len)
  979. {
  980. struct nfc_target nfc_tgt;
  981. int rc;
  982. nfc_dev_dbg(&dev->interface->dev, "%s - modulation=%d", __func__,
  983. dev->poll_mod_curr);
  984. if (tg != 1)
  985. return -EPROTO;
  986. memset(&nfc_tgt, 0, sizeof(struct nfc_target));
  987. switch (dev->poll_mod_curr) {
  988. case PN533_POLL_MOD_106KBPS_A:
  989. rc = pn533_target_found_type_a(&nfc_tgt, tgdata, tgdata_len);
  990. break;
  991. case PN533_POLL_MOD_212KBPS_FELICA:
  992. case PN533_POLL_MOD_424KBPS_FELICA:
  993. rc = pn533_target_found_felica(&nfc_tgt, tgdata, tgdata_len);
  994. break;
  995. case PN533_POLL_MOD_106KBPS_JEWEL:
  996. rc = pn533_target_found_jewel(&nfc_tgt, tgdata, tgdata_len);
  997. break;
  998. case PN533_POLL_MOD_847KBPS_B:
  999. rc = pn533_target_found_type_b(&nfc_tgt, tgdata, tgdata_len);
  1000. break;
  1001. default:
  1002. nfc_dev_err(&dev->interface->dev,
  1003. "Unknown current poll modulation");
  1004. return -EPROTO;
  1005. }
  1006. if (rc)
  1007. return rc;
  1008. if (!(nfc_tgt.supported_protocols & dev->poll_protocols)) {
  1009. nfc_dev_dbg(&dev->interface->dev,
  1010. "The Tg found doesn't have the desired protocol");
  1011. return -EAGAIN;
  1012. }
  1013. nfc_dev_dbg(&dev->interface->dev,
  1014. "Target found - supported protocols: 0x%x",
  1015. nfc_tgt.supported_protocols);
  1016. dev->tgt_available_prots = nfc_tgt.supported_protocols;
  1017. nfc_targets_found(dev->nfc_dev, &nfc_tgt, 1);
  1018. return 0;
  1019. }
  1020. static inline void pn533_poll_next_mod(struct pn533 *dev)
  1021. {
  1022. dev->poll_mod_curr = (dev->poll_mod_curr + 1) % dev->poll_mod_count;
  1023. }
  1024. static void pn533_poll_reset_mod_list(struct pn533 *dev)
  1025. {
  1026. dev->poll_mod_count = 0;
  1027. }
  1028. static void pn533_poll_add_mod(struct pn533 *dev, u8 mod_index)
  1029. {
  1030. dev->poll_mod_active[dev->poll_mod_count] =
  1031. (struct pn533_poll_modulations *)&poll_mod[mod_index];
  1032. dev->poll_mod_count++;
  1033. }
  1034. static void pn533_poll_create_mod_list(struct pn533 *dev,
  1035. u32 im_protocols, u32 tm_protocols)
  1036. {
  1037. pn533_poll_reset_mod_list(dev);
  1038. if ((im_protocols & NFC_PROTO_MIFARE_MASK) ||
  1039. (im_protocols & NFC_PROTO_ISO14443_MASK) ||
  1040. (im_protocols & NFC_PROTO_NFC_DEP_MASK))
  1041. pn533_poll_add_mod(dev, PN533_POLL_MOD_106KBPS_A);
  1042. if (im_protocols & NFC_PROTO_FELICA_MASK ||
  1043. im_protocols & NFC_PROTO_NFC_DEP_MASK) {
  1044. pn533_poll_add_mod(dev, PN533_POLL_MOD_212KBPS_FELICA);
  1045. pn533_poll_add_mod(dev, PN533_POLL_MOD_424KBPS_FELICA);
  1046. }
  1047. if (im_protocols & NFC_PROTO_JEWEL_MASK)
  1048. pn533_poll_add_mod(dev, PN533_POLL_MOD_106KBPS_JEWEL);
  1049. if (im_protocols & NFC_PROTO_ISO14443_B_MASK)
  1050. pn533_poll_add_mod(dev, PN533_POLL_MOD_847KBPS_B);
  1051. if (tm_protocols)
  1052. pn533_poll_add_mod(dev, PN533_LISTEN_MOD);
  1053. }
  1054. static int pn533_start_poll_complete(struct pn533 *dev, struct sk_buff *resp)
  1055. {
  1056. u8 nbtg, tg, *tgdata;
  1057. int rc, tgdata_len;
  1058. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1059. nbtg = resp->data[0];
  1060. tg = resp->data[1];
  1061. tgdata = &resp->data[2];
  1062. tgdata_len = resp->len - 2; /* nbtg + tg */
  1063. if (nbtg) {
  1064. rc = pn533_target_found(dev, tg, tgdata, tgdata_len);
  1065. /* We must stop the poll after a valid target found */
  1066. if (rc == 0) {
  1067. pn533_poll_reset_mod_list(dev);
  1068. return 0;
  1069. }
  1070. }
  1071. return -EAGAIN;
  1072. }
  1073. static struct sk_buff *pn533_alloc_poll_tg_frame(struct pn533 *dev)
  1074. {
  1075. struct sk_buff *skb;
  1076. u8 *felica, *nfcid3, *gb;
  1077. u8 *gbytes = dev->gb;
  1078. size_t gbytes_len = dev->gb_len;
  1079. u8 felica_params[18] = {0x1, 0xfe, /* DEP */
  1080. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, /* random */
  1081. 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
  1082. 0xff, 0xff}; /* System code */
  1083. u8 mifare_params[6] = {0x1, 0x1, /* SENS_RES */
  1084. 0x0, 0x0, 0x0,
  1085. 0x40}; /* SEL_RES for DEP */
  1086. unsigned int skb_len = 36 + /* mode (1), mifare (6),
  1087. felica (18), nfcid3 (10), gb_len (1) */
  1088. gbytes_len +
  1089. 1; /* len Tk*/
  1090. skb = pn533_alloc_skb(dev, skb_len);
  1091. if (!skb)
  1092. return NULL;
  1093. /* DEP support only */
  1094. *skb_put(skb, 1) = PN533_INIT_TARGET_DEP;
  1095. /* MIFARE params */
  1096. memcpy(skb_put(skb, 6), mifare_params, 6);
  1097. /* Felica params */
  1098. felica = skb_put(skb, 18);
  1099. memcpy(felica, felica_params, 18);
  1100. get_random_bytes(felica + 2, 6);
  1101. /* NFCID3 */
  1102. nfcid3 = skb_put(skb, 10);
  1103. memset(nfcid3, 0, 10);
  1104. memcpy(nfcid3, felica, 8);
  1105. /* General bytes */
  1106. *skb_put(skb, 1) = gbytes_len;
  1107. gb = skb_put(skb, gbytes_len);
  1108. memcpy(gb, gbytes, gbytes_len);
  1109. /* Len Tk */
  1110. *skb_put(skb, 1) = 0;
  1111. return skb;
  1112. }
  1113. #define PN533_CMD_DATAEXCH_HEAD_LEN 1
  1114. #define PN533_CMD_DATAEXCH_DATA_MAXLEN 262
  1115. static int pn533_tm_get_data_complete(struct pn533 *dev, void *arg,
  1116. struct sk_buff *resp)
  1117. {
  1118. u8 status;
  1119. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1120. if (IS_ERR(resp))
  1121. return PTR_ERR(resp);
  1122. status = resp->data[0];
  1123. skb_pull(resp, sizeof(status));
  1124. if (status != 0) {
  1125. nfc_tm_deactivated(dev->nfc_dev);
  1126. dev->tgt_mode = 0;
  1127. dev_kfree_skb(resp);
  1128. return 0;
  1129. }
  1130. return nfc_tm_data_received(dev->nfc_dev, resp);
  1131. }
  1132. static void pn533_wq_tg_get_data(struct work_struct *work)
  1133. {
  1134. struct pn533 *dev = container_of(work, struct pn533, tg_work);
  1135. struct sk_buff *skb;
  1136. int rc;
  1137. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1138. skb = pn533_alloc_skb(dev, 0);
  1139. if (!skb)
  1140. return;
  1141. rc = pn533_send_data_async(dev, PN533_CMD_TG_GET_DATA, skb,
  1142. pn533_tm_get_data_complete, NULL);
  1143. if (rc < 0)
  1144. dev_kfree_skb(skb);
  1145. return;
  1146. }
  1147. #define ATR_REQ_GB_OFFSET 17
  1148. static int pn533_init_target_complete(struct pn533 *dev, struct sk_buff *resp)
  1149. {
  1150. u8 mode, *cmd, comm_mode = NFC_COMM_PASSIVE, *gb;
  1151. size_t gb_len;
  1152. int rc;
  1153. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1154. if (resp->len < ATR_REQ_GB_OFFSET + 1)
  1155. return -EINVAL;
  1156. mode = resp->data[0];
  1157. cmd = &resp->data[1];
  1158. nfc_dev_dbg(&dev->interface->dev, "Target mode 0x%x len %d\n",
  1159. mode, resp->len);
  1160. if ((mode & PN533_INIT_TARGET_RESP_FRAME_MASK) ==
  1161. PN533_INIT_TARGET_RESP_ACTIVE)
  1162. comm_mode = NFC_COMM_ACTIVE;
  1163. if ((mode & PN533_INIT_TARGET_RESP_DEP) == 0) /* Only DEP supported */
  1164. return -EOPNOTSUPP;
  1165. gb = cmd + ATR_REQ_GB_OFFSET;
  1166. gb_len = resp->len - (ATR_REQ_GB_OFFSET + 1);
  1167. rc = nfc_tm_activated(dev->nfc_dev, NFC_PROTO_NFC_DEP_MASK,
  1168. comm_mode, gb, gb_len);
  1169. if (rc < 0) {
  1170. nfc_dev_err(&dev->interface->dev,
  1171. "Error when signaling target activation");
  1172. return rc;
  1173. }
  1174. dev->tgt_mode = 1;
  1175. queue_work(dev->wq, &dev->tg_work);
  1176. return 0;
  1177. }
  1178. static void pn533_listen_mode_timer(unsigned long data)
  1179. {
  1180. struct pn533 *dev = (struct pn533 *)data;
  1181. nfc_dev_dbg(&dev->interface->dev, "Listen mode timeout");
  1182. /* An ack will cancel the last issued command (poll) */
  1183. pn533_send_ack(dev, GFP_ATOMIC);
  1184. dev->cancel_listen = 1;
  1185. pn533_poll_next_mod(dev);
  1186. queue_work(dev->wq, &dev->poll_work);
  1187. }
  1188. static int pn533_poll_complete(struct pn533 *dev, void *arg,
  1189. struct sk_buff *resp)
  1190. {
  1191. struct pn533_poll_modulations *cur_mod;
  1192. int rc;
  1193. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1194. if (IS_ERR(resp)) {
  1195. rc = PTR_ERR(resp);
  1196. nfc_dev_err(&dev->interface->dev, "%s Poll complete error %d",
  1197. __func__, rc);
  1198. if (rc == -ENOENT) {
  1199. if (dev->poll_mod_count != 0)
  1200. return rc;
  1201. else
  1202. goto stop_poll;
  1203. } else if (rc < 0) {
  1204. nfc_dev_err(&dev->interface->dev,
  1205. "Error %d when running poll", rc);
  1206. goto stop_poll;
  1207. }
  1208. }
  1209. cur_mod = dev->poll_mod_active[dev->poll_mod_curr];
  1210. if (cur_mod->len == 0) { /* Target mode */
  1211. del_timer(&dev->listen_timer);
  1212. rc = pn533_init_target_complete(dev, resp);
  1213. goto done;
  1214. }
  1215. /* Initiator mode */
  1216. rc = pn533_start_poll_complete(dev, resp);
  1217. if (!rc)
  1218. goto done;
  1219. if (!dev->poll_mod_count) {
  1220. nfc_dev_dbg(&dev->interface->dev, "Polling has been stoped.");
  1221. goto done;
  1222. }
  1223. pn533_poll_next_mod(dev);
  1224. queue_work(dev->wq, &dev->poll_work);
  1225. done:
  1226. dev_kfree_skb(resp);
  1227. return rc;
  1228. stop_poll:
  1229. nfc_dev_err(&dev->interface->dev, "Polling operation has been stopped");
  1230. pn533_poll_reset_mod_list(dev);
  1231. dev->poll_protocols = 0;
  1232. return rc;
  1233. }
  1234. static struct sk_buff *pn533_alloc_poll_in_frame(struct pn533 *dev,
  1235. struct pn533_poll_modulations *mod)
  1236. {
  1237. struct sk_buff *skb;
  1238. skb = pn533_alloc_skb(dev, mod->len);
  1239. if (!skb)
  1240. return NULL;
  1241. memcpy(skb_put(skb, mod->len), &mod->data, mod->len);
  1242. return skb;
  1243. }
  1244. static int pn533_send_poll_frame(struct pn533 *dev)
  1245. {
  1246. struct pn533_poll_modulations *mod;
  1247. struct sk_buff *skb;
  1248. int rc;
  1249. u8 cmd_code;
  1250. mod = dev->poll_mod_active[dev->poll_mod_curr];
  1251. nfc_dev_dbg(&dev->interface->dev, "%s mod len %d\n",
  1252. __func__, mod->len);
  1253. if (mod->len == 0) { /* Listen mode */
  1254. cmd_code = PN533_CMD_TG_INIT_AS_TARGET;
  1255. skb = pn533_alloc_poll_tg_frame(dev);
  1256. } else { /* Polling mode */
  1257. cmd_code = PN533_CMD_IN_LIST_PASSIVE_TARGET;
  1258. skb = pn533_alloc_poll_in_frame(dev, mod);
  1259. }
  1260. if (!skb) {
  1261. nfc_dev_err(&dev->interface->dev, "Failed to allocate skb.");
  1262. return -ENOMEM;
  1263. }
  1264. rc = pn533_send_cmd_async(dev, cmd_code, skb, pn533_poll_complete,
  1265. NULL);
  1266. if (rc < 0) {
  1267. dev_kfree_skb(skb);
  1268. nfc_dev_err(&dev->interface->dev, "Polling loop error %d", rc);
  1269. }
  1270. return rc;
  1271. }
  1272. static void pn533_wq_poll(struct work_struct *work)
  1273. {
  1274. struct pn533 *dev = container_of(work, struct pn533, poll_work);
  1275. struct pn533_poll_modulations *cur_mod;
  1276. int rc;
  1277. cur_mod = dev->poll_mod_active[dev->poll_mod_curr];
  1278. nfc_dev_dbg(&dev->interface->dev,
  1279. "%s cancel_listen %d modulation len %d",
  1280. __func__, dev->cancel_listen, cur_mod->len);
  1281. if (dev->cancel_listen == 1) {
  1282. dev->cancel_listen = 0;
  1283. usb_kill_urb(dev->in_urb);
  1284. }
  1285. rc = pn533_send_poll_frame(dev);
  1286. if (rc)
  1287. return;
  1288. if (cur_mod->len == 0 && dev->poll_mod_count > 1)
  1289. mod_timer(&dev->listen_timer, jiffies + PN533_LISTEN_TIME * HZ);
  1290. return;
  1291. }
  1292. static int pn533_start_poll(struct nfc_dev *nfc_dev,
  1293. u32 im_protocols, u32 tm_protocols)
  1294. {
  1295. struct pn533 *dev = nfc_get_drvdata(nfc_dev);
  1296. nfc_dev_dbg(&dev->interface->dev,
  1297. "%s: im protocols 0x%x tm protocols 0x%x",
  1298. __func__, im_protocols, tm_protocols);
  1299. if (dev->tgt_active_prot) {
  1300. nfc_dev_err(&dev->interface->dev,
  1301. "Cannot poll with a target already activated");
  1302. return -EBUSY;
  1303. }
  1304. if (dev->tgt_mode) {
  1305. nfc_dev_err(&dev->interface->dev,
  1306. "Cannot poll while already being activated");
  1307. return -EBUSY;
  1308. }
  1309. if (tm_protocols) {
  1310. dev->gb = nfc_get_local_general_bytes(nfc_dev, &dev->gb_len);
  1311. if (dev->gb == NULL)
  1312. tm_protocols = 0;
  1313. }
  1314. dev->poll_mod_curr = 0;
  1315. pn533_poll_create_mod_list(dev, im_protocols, tm_protocols);
  1316. dev->poll_protocols = im_protocols;
  1317. dev->listen_protocols = tm_protocols;
  1318. return pn533_send_poll_frame(dev);
  1319. }
  1320. static void pn533_stop_poll(struct nfc_dev *nfc_dev)
  1321. {
  1322. struct pn533 *dev = nfc_get_drvdata(nfc_dev);
  1323. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1324. del_timer(&dev->listen_timer);
  1325. if (!dev->poll_mod_count) {
  1326. nfc_dev_dbg(&dev->interface->dev,
  1327. "Polling operation was not running");
  1328. return;
  1329. }
  1330. /* An ack will cancel the last issued command (poll) */
  1331. pn533_send_ack(dev, GFP_KERNEL);
  1332. /* prevent pn533_start_poll_complete to issue a new poll meanwhile */
  1333. usb_kill_urb(dev->in_urb);
  1334. pn533_poll_reset_mod_list(dev);
  1335. }
  1336. static int pn533_activate_target_nfcdep(struct pn533 *dev)
  1337. {
  1338. struct pn533_cmd_activate_response *rsp;
  1339. u16 gt_len;
  1340. int rc;
  1341. struct sk_buff *skb;
  1342. struct sk_buff *resp;
  1343. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1344. skb = pn533_alloc_skb(dev, sizeof(u8) * 2); /*TG + Next*/
  1345. if (!skb)
  1346. return -ENOMEM;
  1347. *skb_put(skb, sizeof(u8)) = 1; /* TG */
  1348. *skb_put(skb, sizeof(u8)) = 0; /* Next */
  1349. resp = pn533_send_cmd_sync(dev, PN533_CMD_IN_ATR, skb);
  1350. if (IS_ERR(resp))
  1351. return PTR_ERR(resp);
  1352. rsp = (struct pn533_cmd_activate_response *)resp->data;
  1353. rc = rsp->status & PN533_CMD_RET_MASK;
  1354. if (rc != PN533_CMD_RET_SUCCESS) {
  1355. nfc_dev_err(&dev->interface->dev,
  1356. "Target activation failed (error 0x%x)", rc);
  1357. dev_kfree_skb(resp);
  1358. return -EIO;
  1359. }
  1360. /* ATR_RES general bytes are located at offset 16 */
  1361. gt_len = resp->len - 16;
  1362. rc = nfc_set_remote_general_bytes(dev->nfc_dev, rsp->gt, gt_len);
  1363. dev_kfree_skb(resp);
  1364. return rc;
  1365. }
  1366. static int pn533_activate_target(struct nfc_dev *nfc_dev,
  1367. struct nfc_target *target, u32 protocol)
  1368. {
  1369. struct pn533 *dev = nfc_get_drvdata(nfc_dev);
  1370. int rc;
  1371. nfc_dev_dbg(&dev->interface->dev, "%s - protocol=%u", __func__,
  1372. protocol);
  1373. if (dev->poll_mod_count) {
  1374. nfc_dev_err(&dev->interface->dev,
  1375. "Cannot activate while polling");
  1376. return -EBUSY;
  1377. }
  1378. if (dev->tgt_active_prot) {
  1379. nfc_dev_err(&dev->interface->dev,
  1380. "There is already an active target");
  1381. return -EBUSY;
  1382. }
  1383. if (!dev->tgt_available_prots) {
  1384. nfc_dev_err(&dev->interface->dev,
  1385. "There is no available target to activate");
  1386. return -EINVAL;
  1387. }
  1388. if (!(dev->tgt_available_prots & (1 << protocol))) {
  1389. nfc_dev_err(&dev->interface->dev,
  1390. "Target doesn't support requested proto %u",
  1391. protocol);
  1392. return -EINVAL;
  1393. }
  1394. if (protocol == NFC_PROTO_NFC_DEP) {
  1395. rc = pn533_activate_target_nfcdep(dev);
  1396. if (rc) {
  1397. nfc_dev_err(&dev->interface->dev,
  1398. "Activating target with DEP failed %d", rc);
  1399. return rc;
  1400. }
  1401. }
  1402. dev->tgt_active_prot = protocol;
  1403. dev->tgt_available_prots = 0;
  1404. return 0;
  1405. }
  1406. static void pn533_deactivate_target(struct nfc_dev *nfc_dev,
  1407. struct nfc_target *target)
  1408. {
  1409. struct pn533 *dev = nfc_get_drvdata(nfc_dev);
  1410. struct sk_buff *skb;
  1411. struct sk_buff *resp;
  1412. int rc;
  1413. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1414. if (!dev->tgt_active_prot) {
  1415. nfc_dev_err(&dev->interface->dev, "There is no active target");
  1416. return;
  1417. }
  1418. dev->tgt_active_prot = 0;
  1419. skb_queue_purge(&dev->resp_q);
  1420. skb = pn533_alloc_skb(dev, sizeof(u8));
  1421. if (!skb)
  1422. return;
  1423. *skb_put(skb, 1) = 1; /* TG*/
  1424. resp = pn533_send_cmd_sync(dev, PN533_CMD_IN_RELEASE, skb);
  1425. if (IS_ERR(resp))
  1426. return;
  1427. rc = resp->data[0] & PN533_CMD_RET_MASK;
  1428. if (rc != PN533_CMD_RET_SUCCESS)
  1429. nfc_dev_err(&dev->interface->dev,
  1430. "Error 0x%x when releasing the target", rc);
  1431. dev_kfree_skb(resp);
  1432. return;
  1433. }
  1434. static int pn533_in_dep_link_up_complete(struct pn533 *dev, void *arg,
  1435. struct sk_buff *resp)
  1436. {
  1437. struct pn533_cmd_jump_dep_response *rsp;
  1438. u8 target_gt_len;
  1439. int rc;
  1440. u8 active = *(u8 *)arg;
  1441. kfree(arg);
  1442. if (IS_ERR(resp))
  1443. return PTR_ERR(resp);
  1444. if (dev->tgt_available_prots &&
  1445. !(dev->tgt_available_prots & (1 << NFC_PROTO_NFC_DEP))) {
  1446. nfc_dev_err(&dev->interface->dev,
  1447. "The target does not support DEP");
  1448. rc = -EINVAL;
  1449. goto error;
  1450. }
  1451. rsp = (struct pn533_cmd_jump_dep_response *)resp->data;
  1452. rc = rsp->status & PN533_CMD_RET_MASK;
  1453. if (rc != PN533_CMD_RET_SUCCESS) {
  1454. nfc_dev_err(&dev->interface->dev,
  1455. "Bringing DEP link up failed (error 0x%x)", rc);
  1456. goto error;
  1457. }
  1458. if (!dev->tgt_available_prots) {
  1459. struct nfc_target nfc_target;
  1460. nfc_dev_dbg(&dev->interface->dev, "Creating new target");
  1461. nfc_target.supported_protocols = NFC_PROTO_NFC_DEP_MASK;
  1462. nfc_target.nfcid1_len = 10;
  1463. memcpy(nfc_target.nfcid1, rsp->nfcid3t, nfc_target.nfcid1_len);
  1464. rc = nfc_targets_found(dev->nfc_dev, &nfc_target, 1);
  1465. if (rc)
  1466. goto error;
  1467. dev->tgt_available_prots = 0;
  1468. }
  1469. dev->tgt_active_prot = NFC_PROTO_NFC_DEP;
  1470. /* ATR_RES general bytes are located at offset 17 */
  1471. target_gt_len = resp->len - 17;
  1472. rc = nfc_set_remote_general_bytes(dev->nfc_dev,
  1473. rsp->gt, target_gt_len);
  1474. if (rc == 0)
  1475. rc = nfc_dep_link_is_up(dev->nfc_dev,
  1476. dev->nfc_dev->targets[0].idx,
  1477. !active, NFC_RF_INITIATOR);
  1478. error:
  1479. dev_kfree_skb(resp);
  1480. return rc;
  1481. }
  1482. static int pn533_mod_to_baud(struct pn533 *dev)
  1483. {
  1484. switch (dev->poll_mod_curr) {
  1485. case PN533_POLL_MOD_106KBPS_A:
  1486. return 0;
  1487. case PN533_POLL_MOD_212KBPS_FELICA:
  1488. return 1;
  1489. case PN533_POLL_MOD_424KBPS_FELICA:
  1490. return 2;
  1491. default:
  1492. return -EINVAL;
  1493. }
  1494. }
  1495. #define PASSIVE_DATA_LEN 5
  1496. static int pn533_dep_link_up(struct nfc_dev *nfc_dev, struct nfc_target *target,
  1497. u8 comm_mode, u8 *gb, size_t gb_len)
  1498. {
  1499. struct pn533 *dev = nfc_get_drvdata(nfc_dev);
  1500. struct sk_buff *skb;
  1501. int rc, baud, skb_len;
  1502. u8 *next, *arg;
  1503. u8 passive_data[PASSIVE_DATA_LEN] = {0x00, 0xff, 0xff, 0x00, 0x3};
  1504. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1505. if (dev->poll_mod_count) {
  1506. nfc_dev_err(&dev->interface->dev,
  1507. "Cannot bring the DEP link up while polling");
  1508. return -EBUSY;
  1509. }
  1510. if (dev->tgt_active_prot) {
  1511. nfc_dev_err(&dev->interface->dev,
  1512. "There is already an active target");
  1513. return -EBUSY;
  1514. }
  1515. baud = pn533_mod_to_baud(dev);
  1516. if (baud < 0) {
  1517. nfc_dev_err(&dev->interface->dev,
  1518. "Invalid curr modulation %d", dev->poll_mod_curr);
  1519. return baud;
  1520. }
  1521. skb_len = 3 + gb_len; /* ActPass + BR + Next */
  1522. if (comm_mode == NFC_COMM_PASSIVE)
  1523. skb_len += PASSIVE_DATA_LEN;
  1524. skb = pn533_alloc_skb(dev, skb_len);
  1525. if (!skb)
  1526. return -ENOMEM;
  1527. *skb_put(skb, 1) = !comm_mode; /* ActPass */
  1528. *skb_put(skb, 1) = baud; /* Baud rate */
  1529. next = skb_put(skb, 1); /* Next */
  1530. *next = 0;
  1531. if (comm_mode == NFC_COMM_PASSIVE && baud > 0) {
  1532. memcpy(skb_put(skb, PASSIVE_DATA_LEN), passive_data,
  1533. PASSIVE_DATA_LEN);
  1534. *next |= 1;
  1535. }
  1536. if (gb != NULL && gb_len > 0) {
  1537. memcpy(skb_put(skb, gb_len), gb, gb_len);
  1538. *next |= 4; /* We have some Gi */
  1539. } else {
  1540. *next = 0;
  1541. }
  1542. arg = kmalloc(sizeof(*arg), GFP_KERNEL);
  1543. if (!arg) {
  1544. dev_kfree_skb(skb);
  1545. return -ENOMEM;
  1546. }
  1547. *arg = !comm_mode;
  1548. rc = pn533_send_cmd_async(dev, PN533_CMD_IN_JUMP_FOR_DEP, skb,
  1549. pn533_in_dep_link_up_complete, arg);
  1550. if (rc < 0) {
  1551. dev_kfree_skb(skb);
  1552. kfree(arg);
  1553. }
  1554. return rc;
  1555. }
  1556. static int pn533_dep_link_down(struct nfc_dev *nfc_dev)
  1557. {
  1558. struct pn533 *dev = nfc_get_drvdata(nfc_dev);
  1559. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1560. pn533_poll_reset_mod_list(dev);
  1561. if (dev->tgt_mode || dev->tgt_active_prot) {
  1562. pn533_send_ack(dev, GFP_KERNEL);
  1563. usb_kill_urb(dev->in_urb);
  1564. }
  1565. dev->tgt_active_prot = 0;
  1566. dev->tgt_mode = 0;
  1567. skb_queue_purge(&dev->resp_q);
  1568. return 0;
  1569. }
  1570. struct pn533_data_exchange_arg {
  1571. data_exchange_cb_t cb;
  1572. void *cb_context;
  1573. };
  1574. static struct sk_buff *pn533_build_response(struct pn533 *dev)
  1575. {
  1576. struct sk_buff *skb, *tmp, *t;
  1577. unsigned int skb_len = 0, tmp_len = 0;
  1578. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1579. if (skb_queue_empty(&dev->resp_q))
  1580. return NULL;
  1581. if (skb_queue_len(&dev->resp_q) == 1) {
  1582. skb = skb_dequeue(&dev->resp_q);
  1583. goto out;
  1584. }
  1585. skb_queue_walk_safe(&dev->resp_q, tmp, t)
  1586. skb_len += tmp->len;
  1587. nfc_dev_dbg(&dev->interface->dev, "%s total length %d\n",
  1588. __func__, skb_len);
  1589. skb = alloc_skb(skb_len, GFP_KERNEL);
  1590. if (skb == NULL)
  1591. goto out;
  1592. skb_put(skb, skb_len);
  1593. skb_queue_walk_safe(&dev->resp_q, tmp, t) {
  1594. memcpy(skb->data + tmp_len, tmp->data, tmp->len);
  1595. tmp_len += tmp->len;
  1596. }
  1597. out:
  1598. skb_queue_purge(&dev->resp_q);
  1599. return skb;
  1600. }
  1601. static int pn533_data_exchange_complete(struct pn533 *dev, void *_arg,
  1602. struct sk_buff *resp)
  1603. {
  1604. struct pn533_data_exchange_arg *arg = _arg;
  1605. struct sk_buff *skb;
  1606. int rc = 0;
  1607. u8 status, ret, mi;
  1608. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1609. if (IS_ERR(resp)) {
  1610. rc = PTR_ERR(resp);
  1611. goto _error;
  1612. }
  1613. status = resp->data[0];
  1614. ret = status & PN533_CMD_RET_MASK;
  1615. mi = status & PN533_CMD_MI_MASK;
  1616. skb_pull(resp, sizeof(status));
  1617. if (ret != PN533_CMD_RET_SUCCESS) {
  1618. nfc_dev_err(&dev->interface->dev,
  1619. "Exchanging data failed (error 0x%x)", ret);
  1620. rc = -EIO;
  1621. goto error;
  1622. }
  1623. skb_queue_tail(&dev->resp_q, resp);
  1624. if (mi) {
  1625. dev->cmd_complete_mi_arg = arg;
  1626. queue_work(dev->wq, &dev->mi_work);
  1627. return -EINPROGRESS;
  1628. }
  1629. skb = pn533_build_response(dev);
  1630. if (!skb)
  1631. goto error;
  1632. arg->cb(arg->cb_context, skb, 0);
  1633. kfree(arg);
  1634. return 0;
  1635. error:
  1636. dev_kfree_skb(resp);
  1637. _error:
  1638. skb_queue_purge(&dev->resp_q);
  1639. arg->cb(arg->cb_context, NULL, rc);
  1640. kfree(arg);
  1641. return rc;
  1642. }
  1643. static int pn533_transceive(struct nfc_dev *nfc_dev,
  1644. struct nfc_target *target, struct sk_buff *skb,
  1645. data_exchange_cb_t cb, void *cb_context)
  1646. {
  1647. struct pn533 *dev = nfc_get_drvdata(nfc_dev);
  1648. struct pn533_data_exchange_arg *arg = NULL;
  1649. int rc;
  1650. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1651. if (skb->len > PN533_CMD_DATAEXCH_DATA_MAXLEN) {
  1652. /* TODO: Implement support to multi-part data exchange */
  1653. nfc_dev_err(&dev->interface->dev,
  1654. "Data length greater than the max allowed: %d",
  1655. PN533_CMD_DATAEXCH_DATA_MAXLEN);
  1656. rc = -ENOSYS;
  1657. goto error;
  1658. }
  1659. if (!dev->tgt_active_prot) {
  1660. nfc_dev_err(&dev->interface->dev,
  1661. "Can't exchange data if there is no active target");
  1662. rc = -EINVAL;
  1663. goto error;
  1664. }
  1665. arg = kmalloc(sizeof(*arg), GFP_KERNEL);
  1666. if (!arg) {
  1667. rc = -ENOMEM;
  1668. goto error;
  1669. }
  1670. arg->cb = cb;
  1671. arg->cb_context = cb_context;
  1672. switch (dev->device_type) {
  1673. case PN533_DEVICE_PASORI:
  1674. if (dev->tgt_active_prot == NFC_PROTO_FELICA) {
  1675. rc = pn533_send_data_async(dev, PN533_CMD_IN_COMM_THRU,
  1676. skb,
  1677. pn533_data_exchange_complete,
  1678. arg);
  1679. break;
  1680. }
  1681. default:
  1682. *skb_push(skb, sizeof(u8)) = 1; /*TG*/
  1683. rc = pn533_send_data_async(dev, PN533_CMD_IN_DATA_EXCHANGE,
  1684. skb, pn533_data_exchange_complete,
  1685. arg);
  1686. break;
  1687. }
  1688. if (rc < 0) /* rc from send_async */
  1689. goto error;
  1690. return 0;
  1691. error:
  1692. kfree(arg);
  1693. dev_kfree_skb(skb);
  1694. return rc;
  1695. }
  1696. static int pn533_tm_send_complete(struct pn533 *dev, void *arg,
  1697. struct sk_buff *resp)
  1698. {
  1699. u8 status;
  1700. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1701. if (IS_ERR(resp))
  1702. return PTR_ERR(resp);
  1703. status = resp->data[0];
  1704. dev_kfree_skb(resp);
  1705. if (status != 0) {
  1706. nfc_tm_deactivated(dev->nfc_dev);
  1707. dev->tgt_mode = 0;
  1708. return 0;
  1709. }
  1710. queue_work(dev->wq, &dev->tg_work);
  1711. return 0;
  1712. }
  1713. static int pn533_tm_send(struct nfc_dev *nfc_dev, struct sk_buff *skb)
  1714. {
  1715. struct pn533 *dev = nfc_get_drvdata(nfc_dev);
  1716. int rc;
  1717. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1718. if (skb->len > PN533_CMD_DATAEXCH_DATA_MAXLEN) {
  1719. nfc_dev_err(&dev->interface->dev,
  1720. "Data length greater than the max allowed: %d",
  1721. PN533_CMD_DATAEXCH_DATA_MAXLEN);
  1722. return -ENOSYS;
  1723. }
  1724. rc = pn533_send_data_async(dev, PN533_CMD_TG_SET_DATA, skb,
  1725. pn533_tm_send_complete, NULL);
  1726. if (rc < 0)
  1727. dev_kfree_skb(skb);
  1728. return rc;
  1729. }
  1730. static void pn533_wq_mi_recv(struct work_struct *work)
  1731. {
  1732. struct pn533 *dev = container_of(work, struct pn533, mi_work);
  1733. struct sk_buff *skb;
  1734. int rc;
  1735. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1736. skb = pn533_alloc_skb(dev, PN533_CMD_DATAEXCH_HEAD_LEN);
  1737. if (!skb)
  1738. goto error;
  1739. switch (dev->device_type) {
  1740. case PN533_DEVICE_PASORI:
  1741. if (dev->tgt_active_prot == NFC_PROTO_FELICA) {
  1742. rc = pn533_send_cmd_direct_async(dev,
  1743. PN533_CMD_IN_COMM_THRU,
  1744. skb,
  1745. pn533_data_exchange_complete,
  1746. dev->cmd_complete_mi_arg);
  1747. break;
  1748. }
  1749. default:
  1750. *skb_put(skb, sizeof(u8)) = 1; /*TG*/
  1751. rc = pn533_send_cmd_direct_async(dev,
  1752. PN533_CMD_IN_DATA_EXCHANGE,
  1753. skb,
  1754. pn533_data_exchange_complete,
  1755. dev->cmd_complete_mi_arg);
  1756. break;
  1757. }
  1758. if (rc == 0) /* success */
  1759. return;
  1760. nfc_dev_err(&dev->interface->dev,
  1761. "Error %d when trying to perform data_exchange", rc);
  1762. dev_kfree_skb(skb);
  1763. kfree(dev->cmd_complete_mi_arg);
  1764. error:
  1765. pn533_send_ack(dev, GFP_KERNEL);
  1766. queue_work(dev->wq, &dev->cmd_work);
  1767. }
  1768. static int pn533_set_configuration(struct pn533 *dev, u8 cfgitem, u8 *cfgdata,
  1769. u8 cfgdata_len)
  1770. {
  1771. struct sk_buff *skb;
  1772. struct sk_buff *resp;
  1773. int skb_len;
  1774. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1775. skb_len = sizeof(cfgitem) + cfgdata_len; /* cfgitem + cfgdata */
  1776. skb = pn533_alloc_skb(dev, skb_len);
  1777. if (!skb)
  1778. return -ENOMEM;
  1779. *skb_put(skb, sizeof(cfgitem)) = cfgitem;
  1780. memcpy(skb_put(skb, cfgdata_len), cfgdata, cfgdata_len);
  1781. resp = pn533_send_cmd_sync(dev, PN533_CMD_RF_CONFIGURATION, skb);
  1782. if (IS_ERR(resp))
  1783. return PTR_ERR(resp);
  1784. dev_kfree_skb(resp);
  1785. return 0;
  1786. }
  1787. static int pn533_get_firmware_version(struct pn533 *dev,
  1788. struct pn533_fw_version *fv)
  1789. {
  1790. struct sk_buff *skb;
  1791. struct sk_buff *resp;
  1792. skb = pn533_alloc_skb(dev, 0);
  1793. if (!skb)
  1794. return -ENOMEM;
  1795. resp = pn533_send_cmd_sync(dev, PN533_CMD_GET_FIRMWARE_VERSION, skb);
  1796. if (IS_ERR(resp))
  1797. return PTR_ERR(resp);
  1798. fv->ic = resp->data[0];
  1799. fv->ver = resp->data[1];
  1800. fv->rev = resp->data[2];
  1801. fv->support = resp->data[3];
  1802. dev_kfree_skb(resp);
  1803. return 0;
  1804. }
  1805. static int pn533_pasori_fw_reset(struct pn533 *dev)
  1806. {
  1807. struct sk_buff *skb;
  1808. struct sk_buff *resp;
  1809. nfc_dev_dbg(&dev->interface->dev, "%s", __func__);
  1810. skb = pn533_alloc_skb(dev, sizeof(u8));
  1811. if (!skb)
  1812. return -ENOMEM;
  1813. *skb_put(skb, sizeof(u8)) = 0x1;
  1814. resp = pn533_send_cmd_sync(dev, 0x18, skb);
  1815. if (IS_ERR(resp))
  1816. return PTR_ERR(resp);
  1817. dev_kfree_skb(resp);
  1818. return 0;
  1819. }
  1820. static struct nfc_ops pn533_nfc_ops = {
  1821. .dev_up = NULL,
  1822. .dev_down = NULL,
  1823. .dep_link_up = pn533_dep_link_up,
  1824. .dep_link_down = pn533_dep_link_down,
  1825. .start_poll = pn533_start_poll,
  1826. .stop_poll = pn533_stop_poll,
  1827. .activate_target = pn533_activate_target,
  1828. .deactivate_target = pn533_deactivate_target,
  1829. .im_transceive = pn533_transceive,
  1830. .tm_send = pn533_tm_send,
  1831. };
  1832. static int pn533_setup(struct pn533 *dev)
  1833. {
  1834. struct pn533_config_max_retries max_retries;
  1835. struct pn533_config_timing timing;
  1836. u8 pasori_cfg[3] = {0x08, 0x01, 0x08};
  1837. int rc;
  1838. switch (dev->device_type) {
  1839. case PN533_DEVICE_STD:
  1840. max_retries.mx_rty_atr = PN533_CONFIG_MAX_RETRIES_ENDLESS;
  1841. max_retries.mx_rty_psl = 2;
  1842. max_retries.mx_rty_passive_act =
  1843. PN533_CONFIG_MAX_RETRIES_NO_RETRY;
  1844. timing.rfu = PN533_CONFIG_TIMING_102;
  1845. timing.atr_res_timeout = PN533_CONFIG_TIMING_204;
  1846. timing.dep_timeout = PN533_CONFIG_TIMING_409;
  1847. break;
  1848. case PN533_DEVICE_PASORI:
  1849. max_retries.mx_rty_atr = 0x2;
  1850. max_retries.mx_rty_psl = 0x1;
  1851. max_retries.mx_rty_passive_act =
  1852. PN533_CONFIG_MAX_RETRIES_NO_RETRY;
  1853. timing.rfu = PN533_CONFIG_TIMING_102;
  1854. timing.atr_res_timeout = PN533_CONFIG_TIMING_102;
  1855. timing.dep_timeout = PN533_CONFIG_TIMING_204;
  1856. break;
  1857. default:
  1858. nfc_dev_err(&dev->interface->dev, "Unknown device type %d\n",
  1859. dev->device_type);
  1860. return -EINVAL;
  1861. }
  1862. rc = pn533_set_configuration(dev, PN533_CFGITEM_MAX_RETRIES,
  1863. (u8 *)&max_retries, sizeof(max_retries));
  1864. if (rc) {
  1865. nfc_dev_err(&dev->interface->dev,
  1866. "Error on setting MAX_RETRIES config");
  1867. return rc;
  1868. }
  1869. rc = pn533_set_configuration(dev, PN533_CFGITEM_TIMING,
  1870. (u8 *)&timing, sizeof(timing));
  1871. if (rc) {
  1872. nfc_dev_err(&dev->interface->dev,
  1873. "Error on setting RF timings");
  1874. return rc;
  1875. }
  1876. switch (dev->device_type) {
  1877. case PN533_DEVICE_STD:
  1878. break;
  1879. case PN533_DEVICE_PASORI:
  1880. pn533_pasori_fw_reset(dev);
  1881. rc = pn533_set_configuration(dev, PN533_CFGITEM_PASORI,
  1882. pasori_cfg, 3);
  1883. if (rc) {
  1884. nfc_dev_err(&dev->interface->dev,
  1885. "Error while settings PASORI config");
  1886. return rc;
  1887. }
  1888. pn533_pasori_fw_reset(dev);
  1889. break;
  1890. }
  1891. return 0;
  1892. }
  1893. static int pn533_probe(struct usb_interface *interface,
  1894. const struct usb_device_id *id)
  1895. {
  1896. struct pn533_fw_version fw_ver;
  1897. struct pn533 *dev;
  1898. struct usb_host_interface *iface_desc;
  1899. struct usb_endpoint_descriptor *endpoint;
  1900. int in_endpoint = 0;
  1901. int out_endpoint = 0;
  1902. int rc = -ENOMEM;
  1903. int i;
  1904. u32 protocols;
  1905. dev = kzalloc(sizeof(*dev), GFP_KERNEL);
  1906. if (!dev)
  1907. return -ENOMEM;
  1908. dev->udev = usb_get_dev(interface_to_usbdev(interface));
  1909. dev->interface = interface;
  1910. mutex_init(&dev->cmd_lock);
  1911. iface_desc = interface->cur_altsetting;
  1912. for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
  1913. endpoint = &iface_desc->endpoint[i].desc;
  1914. if (!in_endpoint && usb_endpoint_is_bulk_in(endpoint))
  1915. in_endpoint = endpoint->bEndpointAddress;
  1916. if (!out_endpoint && usb_endpoint_is_bulk_out(endpoint))
  1917. out_endpoint = endpoint->bEndpointAddress;
  1918. }
  1919. if (!in_endpoint || !out_endpoint) {
  1920. nfc_dev_err(&interface->dev,
  1921. "Could not find bulk-in or bulk-out endpoint");
  1922. rc = -ENODEV;
  1923. goto error;
  1924. }
  1925. dev->in_urb = usb_alloc_urb(0, GFP_KERNEL);
  1926. dev->out_urb = usb_alloc_urb(0, GFP_KERNEL);
  1927. if (!dev->in_urb || !dev->out_urb)
  1928. goto error;
  1929. usb_fill_bulk_urb(dev->in_urb, dev->udev,
  1930. usb_rcvbulkpipe(dev->udev, in_endpoint),
  1931. NULL, 0, NULL, dev);
  1932. usb_fill_bulk_urb(dev->out_urb, dev->udev,
  1933. usb_sndbulkpipe(dev->udev, out_endpoint),
  1934. NULL, 0, pn533_send_complete, dev);
  1935. INIT_WORK(&dev->cmd_work, pn533_wq_cmd);
  1936. INIT_WORK(&dev->cmd_complete_work, pn533_wq_cmd_complete);
  1937. INIT_WORK(&dev->mi_work, pn533_wq_mi_recv);
  1938. INIT_WORK(&dev->tg_work, pn533_wq_tg_get_data);
  1939. INIT_WORK(&dev->poll_work, pn533_wq_poll);
  1940. dev->wq = alloc_ordered_workqueue("pn533", 0);
  1941. if (dev->wq == NULL)
  1942. goto error;
  1943. init_timer(&dev->listen_timer);
  1944. dev->listen_timer.data = (unsigned long) dev;
  1945. dev->listen_timer.function = pn533_listen_mode_timer;
  1946. skb_queue_head_init(&dev->resp_q);
  1947. INIT_LIST_HEAD(&dev->cmd_queue);
  1948. usb_set_intfdata(interface, dev);
  1949. dev->ops = &pn533_std_frame_ops;
  1950. dev->device_type = id->driver_info;
  1951. switch (dev->device_type) {
  1952. case PN533_DEVICE_STD:
  1953. protocols = PN533_ALL_PROTOCOLS;
  1954. break;
  1955. case PN533_DEVICE_PASORI:
  1956. protocols = PN533_NO_TYPE_B_PROTOCOLS;
  1957. break;
  1958. default:
  1959. nfc_dev_err(&dev->interface->dev, "Unknown device type %d\n",
  1960. dev->device_type);
  1961. rc = -EINVAL;
  1962. goto destroy_wq;
  1963. }
  1964. memset(&fw_ver, 0, sizeof(fw_ver));
  1965. rc = pn533_get_firmware_version(dev, &fw_ver);
  1966. if (rc < 0)
  1967. goto destroy_wq;
  1968. nfc_dev_info(&dev->interface->dev,
  1969. "NXP PN533 firmware ver %d.%d now attached",
  1970. fw_ver.ver, fw_ver.rev);
  1971. dev->nfc_dev = nfc_allocate_device(&pn533_nfc_ops, protocols,
  1972. NFC_SE_NONE,
  1973. dev->ops->tx_header_len +
  1974. PN533_CMD_DATAEXCH_HEAD_LEN,
  1975. dev->ops->tx_tail_len);
  1976. if (!dev->nfc_dev)
  1977. goto destroy_wq;
  1978. nfc_set_parent_dev(dev->nfc_dev, &interface->dev);
  1979. nfc_set_drvdata(dev->nfc_dev, dev);
  1980. rc = nfc_register_device(dev->nfc_dev);
  1981. if (rc)
  1982. goto free_nfc_dev;
  1983. rc = pn533_setup(dev);
  1984. if (rc)
  1985. goto unregister_nfc_dev;
  1986. return 0;
  1987. unregister_nfc_dev:
  1988. nfc_unregister_device(dev->nfc_dev);
  1989. free_nfc_dev:
  1990. nfc_free_device(dev->nfc_dev);
  1991. destroy_wq:
  1992. destroy_workqueue(dev->wq);
  1993. error:
  1994. usb_free_urb(dev->in_urb);
  1995. usb_free_urb(dev->out_urb);
  1996. kfree(dev);
  1997. return rc;
  1998. }
  1999. static void pn533_disconnect(struct usb_interface *interface)
  2000. {
  2001. struct pn533 *dev;
  2002. struct pn533_cmd *cmd, *n;
  2003. dev = usb_get_intfdata(interface);
  2004. usb_set_intfdata(interface, NULL);
  2005. nfc_unregister_device(dev->nfc_dev);
  2006. nfc_free_device(dev->nfc_dev);
  2007. usb_kill_urb(dev->in_urb);
  2008. usb_kill_urb(dev->out_urb);
  2009. destroy_workqueue(dev->wq);
  2010. skb_queue_purge(&dev->resp_q);
  2011. del_timer(&dev->listen_timer);
  2012. list_for_each_entry_safe(cmd, n, &dev->cmd_queue, queue) {
  2013. list_del(&cmd->queue);
  2014. kfree(cmd);
  2015. }
  2016. usb_free_urb(dev->in_urb);
  2017. usb_free_urb(dev->out_urb);
  2018. kfree(dev);
  2019. nfc_dev_info(&interface->dev, "NXP PN533 NFC device disconnected");
  2020. }
  2021. static struct usb_driver pn533_driver = {
  2022. .name = "pn533",
  2023. .probe = pn533_probe,
  2024. .disconnect = pn533_disconnect,
  2025. .id_table = pn533_table,
  2026. };
  2027. module_usb_driver(pn533_driver);
  2028. MODULE_AUTHOR("Lauro Ramos Venancio <lauro.venancio@openbossa.org>");
  2029. MODULE_AUTHOR("Aloisio Almeida Jr <aloisio.almeida@openbossa.org>");
  2030. MODULE_AUTHOR("Waldemar Rymarkiewicz <waldemar.rymarkiewicz@tieto.com>");
  2031. MODULE_DESCRIPTION("PN533 usb driver ver " VERSION);
  2032. MODULE_VERSION(VERSION);
  2033. MODULE_LICENSE("GPL");