trf7970a.c 62 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * TI TRF7970a RFID/NFC Transceiver Driver
  4. *
  5. * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com
  6. *
  7. * Author: Erick Macias <[email protected]>
  8. * Author: Felipe Balbi <[email protected]>
  9. * Author: Mark A. Greer <[email protected]>
  10. */
  11. #include <linux/module.h>
  12. #include <linux/device.h>
  13. #include <linux/netdevice.h>
  14. #include <linux/interrupt.h>
  15. #include <linux/pm_runtime.h>
  16. #include <linux/nfc.h>
  17. #include <linux/skbuff.h>
  18. #include <linux/delay.h>
  19. #include <linux/gpio/consumer.h>
  20. #include <linux/of.h>
  21. #include <linux/spi/spi.h>
  22. #include <linux/regulator/consumer.h>
  23. #include <net/nfc/nfc.h>
  24. #include <net/nfc/digital.h>
  25. /* There are 3 ways the host can communicate with the trf7970a:
  26. * parallel mode, SPI with Slave Select (SS) mode, and SPI without
  27. * SS mode. The driver only supports the two SPI modes.
  28. *
  29. * The trf7970a is very timing sensitive and the VIN, EN2, and EN
  30. * pins must asserted in that order and with specific delays in between.
  31. * The delays used in the driver were provided by TI and have been
  32. * confirmed to work with this driver. There is a bug with the current
  33. * version of the trf7970a that requires that EN2 remain low no matter
  34. * what. If it goes high, it will generate an RF field even when in
  35. * passive target mode. TI has indicated that the chip will work okay
  36. * when EN2 is left low. The 'en2-rf-quirk' device tree property
  37. * indicates that trf7970a currently being used has the erratum and
  38. * that EN2 must be kept low.
  39. *
  40. * Timeouts are implemented using the delayed workqueue kernel facility.
  41. * Timeouts are required so things don't hang when there is no response
  42. * from the trf7970a (or tag). Using this mechanism creates a race with
  43. * interrupts, however. That is, an interrupt and a timeout could occur
  44. * closely enough together that one is blocked by the mutex while the other
  45. * executes. When the timeout handler executes first and blocks the
  46. * interrupt handler, it will eventually set the state to IDLE so the
  47. * interrupt handler will check the state and exit with no harm done.
  48. * When the interrupt handler executes first and blocks the timeout handler,
  49. * the cancel_delayed_work() call will know that it didn't cancel the
  50. * work item (i.e., timeout) and will return zero. That return code is
  51. * used by the timer handler to indicate that it should ignore the timeout
  52. * once its unblocked.
  53. *
  54. * Aborting an active command isn't as simple as it seems because the only
  55. * way to abort a command that's already been sent to the tag is so turn
  56. * off power to the tag. If we do that, though, we'd have to go through
  57. * the entire anticollision procedure again but the digital layer doesn't
  58. * support that. So, if an abort is received before trf7970a_send_cmd()
  59. * has sent the command to the tag, it simply returns -ECANCELED. If the
  60. * command has already been sent to the tag, then the driver continues
  61. * normally and recieves the response data (or error) but just before
  62. * sending the data upstream, it frees the rx_skb and sends -ECANCELED
  63. * upstream instead. If the command failed, that error will be sent
  64. * upstream.
  65. *
  66. * When recieving data from a tag and the interrupt status register has
  67. * only the SRX bit set, it means that all of the data has been received
  68. * (once what's in the fifo has been read). However, depending on timing
  69. * an interrupt status with only the SRX bit set may not be recived. In
  70. * those cases, the timeout mechanism is used to wait 20 ms in case more
  71. * data arrives. After 20 ms, it is assumed that all of the data has been
  72. * received and the accumulated rx data is sent upstream. The
  73. * 'TRF7970A_ST_WAIT_FOR_RX_DATA_CONT' state is used for this purpose
  74. * (i.e., it indicates that some data has been received but we're not sure
  75. * if there is more coming so a timeout in this state means all data has
  76. * been received and there isn't an error). The delay is 20 ms since delays
  77. * of ~16 ms have been observed during testing.
  78. *
  79. * When transmitting a frame larger than the FIFO size (127 bytes), the
  80. * driver will wait 20 ms for the FIFO to drain past the low-watermark
  81. * and generate an interrupt. The low-watermark set to 32 bytes so the
  82. * interrupt should fire after 127 - 32 = 95 bytes have been sent. At
  83. * the lowest possible bit rate (6.62 kbps for 15693), it will take up
  84. * to ~14.35 ms so 20 ms is used for the timeout.
  85. *
  86. * Type 2 write and sector select commands respond with a 4-bit ACK or NACK.
  87. * Having only 4 bits in the FIFO won't normally generate an interrupt so
  88. * driver enables the '4_bit_RX' bit of the Special Functions register 1
  89. * to cause an interrupt in that case. Leaving that bit for a read command
  90. * messes up the data returned so it is only enabled when the framing is
  91. * 'NFC_DIGITAL_FRAMING_NFCA_T2T' and the command is not a read command.
  92. * Unfortunately, that means that the driver has to peek into tx frames
  93. * when the framing is 'NFC_DIGITAL_FRAMING_NFCA_T2T'. This is done by
  94. * the trf7970a_per_cmd_config() routine.
  95. *
  96. * ISO/IEC 15693 frames specify whether to use single or double sub-carrier
  97. * frequencies and whether to use low or high data rates in the flags byte
  98. * of the frame. This means that the driver has to peek at all 15693 frames
  99. * to determine what speed to set the communication to. In addition, write
  100. * and lock commands use the OPTION flag to indicate that an EOF must be
  101. * sent to the tag before it will send its response. So the driver has to
  102. * examine all frames for that reason too.
  103. *
  104. * It is unclear how long to wait before sending the EOF. According to the
  105. * Note under Table 1-1 in section 1.6 of
  106. * http://www.ti.com/lit/ug/scbu011/scbu011.pdf, that wait should be at least
  107. * 10 ms for TI Tag-it HF-I tags; however testing has shown that is not long
  108. * enough so 20 ms is used. So the timer is set to 40 ms - 20 ms to drain
  109. * up to 127 bytes in the FIFO at the lowest bit rate plus another 20 ms to
  110. * ensure the wait is long enough before sending the EOF. This seems to work
  111. * reliably.
  112. */
  113. #define TRF7970A_SUPPORTED_PROTOCOLS \
  114. (NFC_PROTO_MIFARE_MASK | NFC_PROTO_ISO14443_MASK | \
  115. NFC_PROTO_ISO14443_B_MASK | NFC_PROTO_FELICA_MASK | \
  116. NFC_PROTO_ISO15693_MASK | NFC_PROTO_NFC_DEP_MASK)
  117. #define TRF7970A_AUTOSUSPEND_DELAY 30000 /* 30 seconds */
  118. #define TRF7970A_13MHZ_CLOCK_FREQUENCY 13560000
  119. #define TRF7970A_27MHZ_CLOCK_FREQUENCY 27120000
  120. #define TRF7970A_RX_SKB_ALLOC_SIZE 256
  121. #define TRF7970A_FIFO_SIZE 127
  122. /* TX length is 3 nibbles long ==> 4KB - 1 bytes max */
  123. #define TRF7970A_TX_MAX (4096 - 1)
  124. #define TRF7970A_WAIT_FOR_TX_IRQ 20
  125. #define TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT 20
  126. #define TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT 20
  127. #define TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF 40
  128. /* Guard times for various RF technologies (in us) */
  129. #define TRF7970A_GUARD_TIME_NFCA 5000
  130. #define TRF7970A_GUARD_TIME_NFCB 5000
  131. #define TRF7970A_GUARD_TIME_NFCF 20000
  132. #define TRF7970A_GUARD_TIME_15693 1000
  133. /* Quirks */
  134. /* Erratum: When reading IRQ Status register on trf7970a, we must issue a
  135. * read continuous command for IRQ Status and Collision Position registers.
  136. */
  137. #define TRF7970A_QUIRK_IRQ_STATUS_READ BIT(0)
  138. #define TRF7970A_QUIRK_EN2_MUST_STAY_LOW BIT(1)
  139. /* Direct commands */
  140. #define TRF7970A_CMD_IDLE 0x00
  141. #define TRF7970A_CMD_SOFT_INIT 0x03
  142. #define TRF7970A_CMD_RF_COLLISION 0x04
  143. #define TRF7970A_CMD_RF_COLLISION_RESPONSE_N 0x05
  144. #define TRF7970A_CMD_RF_COLLISION_RESPONSE_0 0x06
  145. #define TRF7970A_CMD_FIFO_RESET 0x0f
  146. #define TRF7970A_CMD_TRANSMIT_NO_CRC 0x10
  147. #define TRF7970A_CMD_TRANSMIT 0x11
  148. #define TRF7970A_CMD_DELAY_TRANSMIT_NO_CRC 0x12
  149. #define TRF7970A_CMD_DELAY_TRANSMIT 0x13
  150. #define TRF7970A_CMD_EOF 0x14
  151. #define TRF7970A_CMD_CLOSE_SLOT 0x15
  152. #define TRF7970A_CMD_BLOCK_RX 0x16
  153. #define TRF7970A_CMD_ENABLE_RX 0x17
  154. #define TRF7970A_CMD_TEST_INT_RF 0x18
  155. #define TRF7970A_CMD_TEST_EXT_RF 0x19
  156. #define TRF7970A_CMD_RX_GAIN_ADJUST 0x1a
  157. /* Bits determining whether its a direct command or register R/W,
  158. * whether to use a continuous SPI transaction or not, and the actual
  159. * direct cmd opcode or register address.
  160. */
  161. #define TRF7970A_CMD_BIT_CTRL BIT(7)
  162. #define TRF7970A_CMD_BIT_RW BIT(6)
  163. #define TRF7970A_CMD_BIT_CONTINUOUS BIT(5)
  164. #define TRF7970A_CMD_BIT_OPCODE(opcode) ((opcode) & 0x1f)
  165. /* Registers addresses */
  166. #define TRF7970A_CHIP_STATUS_CTRL 0x00
  167. #define TRF7970A_ISO_CTRL 0x01
  168. #define TRF7970A_ISO14443B_TX_OPTIONS 0x02
  169. #define TRF7970A_ISO14443A_HIGH_BITRATE_OPTIONS 0x03
  170. #define TRF7970A_TX_TIMER_SETTING_H_BYTE 0x04
  171. #define TRF7970A_TX_TIMER_SETTING_L_BYTE 0x05
  172. #define TRF7970A_TX_PULSE_LENGTH_CTRL 0x06
  173. #define TRF7970A_RX_NO_RESPONSE_WAIT 0x07
  174. #define TRF7970A_RX_WAIT_TIME 0x08
  175. #define TRF7970A_MODULATOR_SYS_CLK_CTRL 0x09
  176. #define TRF7970A_RX_SPECIAL_SETTINGS 0x0a
  177. #define TRF7970A_REG_IO_CTRL 0x0b
  178. #define TRF7970A_IRQ_STATUS 0x0c
  179. #define TRF7970A_COLLISION_IRQ_MASK 0x0d
  180. #define TRF7970A_COLLISION_POSITION 0x0e
  181. #define TRF7970A_RSSI_OSC_STATUS 0x0f
  182. #define TRF7970A_SPECIAL_FCN_REG1 0x10
  183. #define TRF7970A_SPECIAL_FCN_REG2 0x11
  184. #define TRF7970A_RAM1 0x12
  185. #define TRF7970A_RAM2 0x13
  186. #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS 0x14
  187. #define TRF7970A_NFC_LOW_FIELD_LEVEL 0x16
  188. #define TRF7970A_NFCID1 0x17
  189. #define TRF7970A_NFC_TARGET_LEVEL 0x18
  190. #define TRF79070A_NFC_TARGET_PROTOCOL 0x19
  191. #define TRF7970A_TEST_REGISTER1 0x1a
  192. #define TRF7970A_TEST_REGISTER2 0x1b
  193. #define TRF7970A_FIFO_STATUS 0x1c
  194. #define TRF7970A_TX_LENGTH_BYTE1 0x1d
  195. #define TRF7970A_TX_LENGTH_BYTE2 0x1e
  196. #define TRF7970A_FIFO_IO_REGISTER 0x1f
  197. /* Chip Status Control Register Bits */
  198. #define TRF7970A_CHIP_STATUS_VRS5_3 BIT(0)
  199. #define TRF7970A_CHIP_STATUS_REC_ON BIT(1)
  200. #define TRF7970A_CHIP_STATUS_AGC_ON BIT(2)
  201. #define TRF7970A_CHIP_STATUS_PM_ON BIT(3)
  202. #define TRF7970A_CHIP_STATUS_RF_PWR BIT(4)
  203. #define TRF7970A_CHIP_STATUS_RF_ON BIT(5)
  204. #define TRF7970A_CHIP_STATUS_DIRECT BIT(6)
  205. #define TRF7970A_CHIP_STATUS_STBY BIT(7)
  206. /* ISO Control Register Bits */
  207. #define TRF7970A_ISO_CTRL_15693_SGL_1OF4_662 0x00
  208. #define TRF7970A_ISO_CTRL_15693_SGL_1OF256_662 0x01
  209. #define TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648 0x02
  210. #define TRF7970A_ISO_CTRL_15693_SGL_1OF256_2648 0x03
  211. #define TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a 0x04
  212. #define TRF7970A_ISO_CTRL_15693_DBL_1OF256_667 0x05
  213. #define TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669 0x06
  214. #define TRF7970A_ISO_CTRL_15693_DBL_1OF256_2669 0x07
  215. #define TRF7970A_ISO_CTRL_14443A_106 0x08
  216. #define TRF7970A_ISO_CTRL_14443A_212 0x09
  217. #define TRF7970A_ISO_CTRL_14443A_424 0x0a
  218. #define TRF7970A_ISO_CTRL_14443A_848 0x0b
  219. #define TRF7970A_ISO_CTRL_14443B_106 0x0c
  220. #define TRF7970A_ISO_CTRL_14443B_212 0x0d
  221. #define TRF7970A_ISO_CTRL_14443B_424 0x0e
  222. #define TRF7970A_ISO_CTRL_14443B_848 0x0f
  223. #define TRF7970A_ISO_CTRL_FELICA_212 0x1a
  224. #define TRF7970A_ISO_CTRL_FELICA_424 0x1b
  225. #define TRF7970A_ISO_CTRL_NFC_NFCA_106 0x01
  226. #define TRF7970A_ISO_CTRL_NFC_NFCF_212 0x02
  227. #define TRF7970A_ISO_CTRL_NFC_NFCF_424 0x03
  228. #define TRF7970A_ISO_CTRL_NFC_CE_14443A 0x00
  229. #define TRF7970A_ISO_CTRL_NFC_CE_14443B 0x01
  230. #define TRF7970A_ISO_CTRL_NFC_CE BIT(2)
  231. #define TRF7970A_ISO_CTRL_NFC_ACTIVE BIT(3)
  232. #define TRF7970A_ISO_CTRL_NFC_INITIATOR BIT(4)
  233. #define TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE BIT(5)
  234. #define TRF7970A_ISO_CTRL_RFID BIT(5)
  235. #define TRF7970A_ISO_CTRL_DIR_MODE BIT(6)
  236. #define TRF7970A_ISO_CTRL_RX_CRC_N BIT(7) /* true == No CRC */
  237. #define TRF7970A_ISO_CTRL_RFID_SPEED_MASK 0x1f
  238. /* Modulator and SYS_CLK Control Register Bits */
  239. #define TRF7970A_MODULATOR_DEPTH(n) ((n) & 0x7)
  240. #define TRF7970A_MODULATOR_DEPTH_ASK10 (TRF7970A_MODULATOR_DEPTH(0))
  241. #define TRF7970A_MODULATOR_DEPTH_OOK (TRF7970A_MODULATOR_DEPTH(1))
  242. #define TRF7970A_MODULATOR_DEPTH_ASK7 (TRF7970A_MODULATOR_DEPTH(2))
  243. #define TRF7970A_MODULATOR_DEPTH_ASK8_5 (TRF7970A_MODULATOR_DEPTH(3))
  244. #define TRF7970A_MODULATOR_DEPTH_ASK13 (TRF7970A_MODULATOR_DEPTH(4))
  245. #define TRF7970A_MODULATOR_DEPTH_ASK16 (TRF7970A_MODULATOR_DEPTH(5))
  246. #define TRF7970A_MODULATOR_DEPTH_ASK22 (TRF7970A_MODULATOR_DEPTH(6))
  247. #define TRF7970A_MODULATOR_DEPTH_ASK30 (TRF7970A_MODULATOR_DEPTH(7))
  248. #define TRF7970A_MODULATOR_EN_ANA BIT(3)
  249. #define TRF7970A_MODULATOR_CLK(n) (((n) & 0x3) << 4)
  250. #define TRF7970A_MODULATOR_CLK_DISABLED (TRF7970A_MODULATOR_CLK(0))
  251. #define TRF7970A_MODULATOR_CLK_3_6 (TRF7970A_MODULATOR_CLK(1))
  252. #define TRF7970A_MODULATOR_CLK_6_13 (TRF7970A_MODULATOR_CLK(2))
  253. #define TRF7970A_MODULATOR_CLK_13_27 (TRF7970A_MODULATOR_CLK(3))
  254. #define TRF7970A_MODULATOR_EN_OOK BIT(6)
  255. #define TRF7970A_MODULATOR_27MHZ BIT(7)
  256. #define TRF7970A_RX_SPECIAL_SETTINGS_NO_LIM BIT(0)
  257. #define TRF7970A_RX_SPECIAL_SETTINGS_AGCR BIT(1)
  258. #define TRF7970A_RX_SPECIAL_SETTINGS_GD_0DB (0x0 << 2)
  259. #define TRF7970A_RX_SPECIAL_SETTINGS_GD_5DB (0x1 << 2)
  260. #define TRF7970A_RX_SPECIAL_SETTINGS_GD_10DB (0x2 << 2)
  261. #define TRF7970A_RX_SPECIAL_SETTINGS_GD_15DB (0x3 << 2)
  262. #define TRF7970A_RX_SPECIAL_SETTINGS_HBT BIT(4)
  263. #define TRF7970A_RX_SPECIAL_SETTINGS_M848 BIT(5)
  264. #define TRF7970A_RX_SPECIAL_SETTINGS_C424 BIT(6)
  265. #define TRF7970A_RX_SPECIAL_SETTINGS_C212 BIT(7)
  266. #define TRF7970A_REG_IO_CTRL_VRS(v) ((v) & 0x07)
  267. #define TRF7970A_REG_IO_CTRL_IO_LOW BIT(5)
  268. #define TRF7970A_REG_IO_CTRL_EN_EXT_PA BIT(6)
  269. #define TRF7970A_REG_IO_CTRL_AUTO_REG BIT(7)
  270. /* IRQ Status Register Bits */
  271. #define TRF7970A_IRQ_STATUS_NORESP BIT(0) /* ISO15693 only */
  272. #define TRF7970A_IRQ_STATUS_NFC_COL_ERROR BIT(0)
  273. #define TRF7970A_IRQ_STATUS_COL BIT(1)
  274. #define TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR BIT(2)
  275. #define TRF7970A_IRQ_STATUS_NFC_RF BIT(2)
  276. #define TRF7970A_IRQ_STATUS_PARITY_ERROR BIT(3)
  277. #define TRF7970A_IRQ_STATUS_NFC_SDD BIT(3)
  278. #define TRF7970A_IRQ_STATUS_CRC_ERROR BIT(4)
  279. #define TRF7970A_IRQ_STATUS_NFC_PROTO_ERROR BIT(4)
  280. #define TRF7970A_IRQ_STATUS_FIFO BIT(5)
  281. #define TRF7970A_IRQ_STATUS_SRX BIT(6)
  282. #define TRF7970A_IRQ_STATUS_TX BIT(7)
  283. #define TRF7970A_IRQ_STATUS_ERROR \
  284. (TRF7970A_IRQ_STATUS_COL | \
  285. TRF7970A_IRQ_STATUS_FRAMING_EOF_ERROR | \
  286. TRF7970A_IRQ_STATUS_PARITY_ERROR | \
  287. TRF7970A_IRQ_STATUS_CRC_ERROR)
  288. #define TRF7970A_RSSI_OSC_STATUS_RSSI_MASK (BIT(2) | BIT(1) | BIT(0))
  289. #define TRF7970A_RSSI_OSC_STATUS_RSSI_X_MASK (BIT(5) | BIT(4) | BIT(3))
  290. #define TRF7970A_RSSI_OSC_STATUS_RSSI_OSC_OK BIT(6)
  291. #define TRF7970A_SPECIAL_FCN_REG1_COL_7_6 BIT(0)
  292. #define TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL BIT(1)
  293. #define TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX BIT(2)
  294. #define TRF7970A_SPECIAL_FCN_REG1_SP_DIR_MODE BIT(3)
  295. #define TRF7970A_SPECIAL_FCN_REG1_NEXT_SLOT_37US BIT(4)
  296. #define TRF7970A_SPECIAL_FCN_REG1_PAR43 BIT(5)
  297. #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_124 (0x0 << 2)
  298. #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_120 (0x1 << 2)
  299. #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_112 (0x2 << 2)
  300. #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 (0x3 << 2)
  301. #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_4 0x0
  302. #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_8 0x1
  303. #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_16 0x2
  304. #define TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32 0x3
  305. #define TRF7970A_NFC_LOW_FIELD_LEVEL_RFDET(v) ((v) & 0x07)
  306. #define TRF7970A_NFC_LOW_FIELD_LEVEL_CLEX_DIS BIT(7)
  307. #define TRF7970A_NFC_TARGET_LEVEL_RFDET(v) ((v) & 0x07)
  308. #define TRF7970A_NFC_TARGET_LEVEL_HI_RF BIT(3)
  309. #define TRF7970A_NFC_TARGET_LEVEL_SDD_EN BIT(5)
  310. #define TRF7970A_NFC_TARGET_LEVEL_LD_S_4BYTES (0x0 << 6)
  311. #define TRF7970A_NFC_TARGET_LEVEL_LD_S_7BYTES (0x1 << 6)
  312. #define TRF7970A_NFC_TARGET_LEVEL_LD_S_10BYTES (0x2 << 6)
  313. #define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106 BIT(0)
  314. #define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_212 BIT(1)
  315. #define TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_424 (BIT(0) | BIT(1))
  316. #define TRF79070A_NFC_TARGET_PROTOCOL_PAS_14443B BIT(2)
  317. #define TRF79070A_NFC_TARGET_PROTOCOL_PAS_106 BIT(3)
  318. #define TRF79070A_NFC_TARGET_PROTOCOL_FELICA BIT(4)
  319. #define TRF79070A_NFC_TARGET_PROTOCOL_RF_L BIT(6)
  320. #define TRF79070A_NFC_TARGET_PROTOCOL_RF_H BIT(7)
  321. #define TRF79070A_NFC_TARGET_PROTOCOL_106A \
  322. (TRF79070A_NFC_TARGET_PROTOCOL_RF_H | \
  323. TRF79070A_NFC_TARGET_PROTOCOL_RF_L | \
  324. TRF79070A_NFC_TARGET_PROTOCOL_PAS_106 | \
  325. TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106)
  326. #define TRF79070A_NFC_TARGET_PROTOCOL_106B \
  327. (TRF79070A_NFC_TARGET_PROTOCOL_RF_H | \
  328. TRF79070A_NFC_TARGET_PROTOCOL_RF_L | \
  329. TRF79070A_NFC_TARGET_PROTOCOL_PAS_14443B | \
  330. TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_106)
  331. #define TRF79070A_NFC_TARGET_PROTOCOL_212F \
  332. (TRF79070A_NFC_TARGET_PROTOCOL_RF_H | \
  333. TRF79070A_NFC_TARGET_PROTOCOL_RF_L | \
  334. TRF79070A_NFC_TARGET_PROTOCOL_FELICA | \
  335. TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_212)
  336. #define TRF79070A_NFC_TARGET_PROTOCOL_424F \
  337. (TRF79070A_NFC_TARGET_PROTOCOL_RF_H | \
  338. TRF79070A_NFC_TARGET_PROTOCOL_RF_L | \
  339. TRF79070A_NFC_TARGET_PROTOCOL_FELICA | \
  340. TRF79070A_NFC_TARGET_PROTOCOL_NFCBR_424)
  341. #define TRF7970A_FIFO_STATUS_OVERFLOW BIT(7)
  342. /* NFC (ISO/IEC 14443A) Type 2 Tag commands */
  343. #define NFC_T2T_CMD_READ 0x30
  344. /* ISO 15693 commands codes */
  345. #define ISO15693_CMD_INVENTORY 0x01
  346. #define ISO15693_CMD_READ_SINGLE_BLOCK 0x20
  347. #define ISO15693_CMD_WRITE_SINGLE_BLOCK 0x21
  348. #define ISO15693_CMD_LOCK_BLOCK 0x22
  349. #define ISO15693_CMD_READ_MULTIPLE_BLOCK 0x23
  350. #define ISO15693_CMD_WRITE_MULTIPLE_BLOCK 0x24
  351. #define ISO15693_CMD_SELECT 0x25
  352. #define ISO15693_CMD_RESET_TO_READY 0x26
  353. #define ISO15693_CMD_WRITE_AFI 0x27
  354. #define ISO15693_CMD_LOCK_AFI 0x28
  355. #define ISO15693_CMD_WRITE_DSFID 0x29
  356. #define ISO15693_CMD_LOCK_DSFID 0x2a
  357. #define ISO15693_CMD_GET_SYSTEM_INFO 0x2b
  358. #define ISO15693_CMD_GET_MULTIPLE_BLOCK_SECURITY_STATUS 0x2c
  359. /* ISO 15693 request and response flags */
  360. #define ISO15693_REQ_FLAG_SUB_CARRIER BIT(0)
  361. #define ISO15693_REQ_FLAG_DATA_RATE BIT(1)
  362. #define ISO15693_REQ_FLAG_INVENTORY BIT(2)
  363. #define ISO15693_REQ_FLAG_PROTOCOL_EXT BIT(3)
  364. #define ISO15693_REQ_FLAG_SELECT BIT(4)
  365. #define ISO15693_REQ_FLAG_AFI BIT(4)
  366. #define ISO15693_REQ_FLAG_ADDRESS BIT(5)
  367. #define ISO15693_REQ_FLAG_NB_SLOTS BIT(5)
  368. #define ISO15693_REQ_FLAG_OPTION BIT(6)
  369. #define ISO15693_REQ_FLAG_SPEED_MASK \
  370. (ISO15693_REQ_FLAG_SUB_CARRIER | ISO15693_REQ_FLAG_DATA_RATE)
  371. enum trf7970a_state {
  372. TRF7970A_ST_PWR_OFF,
  373. TRF7970A_ST_RF_OFF,
  374. TRF7970A_ST_IDLE,
  375. TRF7970A_ST_IDLE_RX_BLOCKED,
  376. TRF7970A_ST_WAIT_FOR_TX_FIFO,
  377. TRF7970A_ST_WAIT_FOR_RX_DATA,
  378. TRF7970A_ST_WAIT_FOR_RX_DATA_CONT,
  379. TRF7970A_ST_WAIT_TO_ISSUE_EOF,
  380. TRF7970A_ST_LISTENING,
  381. TRF7970A_ST_LISTENING_MD,
  382. TRF7970A_ST_MAX
  383. };
  384. struct trf7970a {
  385. enum trf7970a_state state;
  386. struct device *dev;
  387. struct spi_device *spi;
  388. struct regulator *regulator;
  389. struct nfc_digital_dev *ddev;
  390. u32 quirks;
  391. bool is_initiator;
  392. bool aborting;
  393. struct sk_buff *tx_skb;
  394. struct sk_buff *rx_skb;
  395. nfc_digital_cmd_complete_t cb;
  396. void *cb_arg;
  397. u8 chip_status_ctrl;
  398. u8 iso_ctrl;
  399. u8 iso_ctrl_tech;
  400. u8 modulator_sys_clk_ctrl;
  401. u8 special_fcn_reg1;
  402. u8 io_ctrl;
  403. unsigned int guard_time;
  404. int technology;
  405. int framing;
  406. u8 md_rf_tech;
  407. u8 tx_cmd;
  408. bool issue_eof;
  409. struct gpio_desc *en_gpiod;
  410. struct gpio_desc *en2_gpiod;
  411. struct mutex lock;
  412. unsigned int timeout;
  413. bool ignore_timeout;
  414. struct delayed_work timeout_work;
  415. };
  416. static int trf7970a_cmd(struct trf7970a *trf, u8 opcode)
  417. {
  418. u8 cmd = TRF7970A_CMD_BIT_CTRL | TRF7970A_CMD_BIT_OPCODE(opcode);
  419. int ret;
  420. dev_dbg(trf->dev, "cmd: 0x%x\n", cmd);
  421. ret = spi_write(trf->spi, &cmd, 1);
  422. if (ret)
  423. dev_err(trf->dev, "%s - cmd: 0x%x, ret: %d\n", __func__, cmd,
  424. ret);
  425. return ret;
  426. }
  427. static int trf7970a_read(struct trf7970a *trf, u8 reg, u8 *val)
  428. {
  429. u8 addr = TRF7970A_CMD_BIT_RW | reg;
  430. int ret;
  431. ret = spi_write_then_read(trf->spi, &addr, 1, val, 1);
  432. if (ret)
  433. dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr,
  434. ret);
  435. dev_dbg(trf->dev, "read(0x%x): 0x%x\n", addr, *val);
  436. return ret;
  437. }
  438. static int trf7970a_read_cont(struct trf7970a *trf, u8 reg, u8 *buf,
  439. size_t len)
  440. {
  441. u8 addr = reg | TRF7970A_CMD_BIT_RW | TRF7970A_CMD_BIT_CONTINUOUS;
  442. struct spi_transfer t[2];
  443. struct spi_message m;
  444. int ret;
  445. dev_dbg(trf->dev, "read_cont(0x%x, %zd)\n", addr, len);
  446. spi_message_init(&m);
  447. memset(&t, 0, sizeof(t));
  448. t[0].tx_buf = &addr;
  449. t[0].len = sizeof(addr);
  450. spi_message_add_tail(&t[0], &m);
  451. t[1].rx_buf = buf;
  452. t[1].len = len;
  453. spi_message_add_tail(&t[1], &m);
  454. ret = spi_sync(trf->spi, &m);
  455. if (ret)
  456. dev_err(trf->dev, "%s - addr: 0x%x, ret: %d\n", __func__, addr,
  457. ret);
  458. return ret;
  459. }
  460. static int trf7970a_write(struct trf7970a *trf, u8 reg, u8 val)
  461. {
  462. u8 buf[2] = { reg, val };
  463. int ret;
  464. dev_dbg(trf->dev, "write(0x%x): 0x%x\n", reg, val);
  465. ret = spi_write(trf->spi, buf, 2);
  466. if (ret)
  467. dev_err(trf->dev, "%s - write: 0x%x 0x%x, ret: %d\n", __func__,
  468. buf[0], buf[1], ret);
  469. return ret;
  470. }
  471. static int trf7970a_read_irqstatus(struct trf7970a *trf, u8 *status)
  472. {
  473. int ret;
  474. u8 buf[2];
  475. u8 addr;
  476. addr = TRF7970A_IRQ_STATUS | TRF7970A_CMD_BIT_RW;
  477. if (trf->quirks & TRF7970A_QUIRK_IRQ_STATUS_READ) {
  478. addr |= TRF7970A_CMD_BIT_CONTINUOUS;
  479. ret = spi_write_then_read(trf->spi, &addr, 1, buf, 2);
  480. } else {
  481. ret = spi_write_then_read(trf->spi, &addr, 1, buf, 1);
  482. }
  483. if (ret)
  484. dev_err(trf->dev, "%s - irqstatus: Status read failed: %d\n",
  485. __func__, ret);
  486. else
  487. *status = buf[0];
  488. return ret;
  489. }
  490. static int trf7970a_read_target_proto(struct trf7970a *trf, u8 *target_proto)
  491. {
  492. int ret;
  493. u8 buf[2];
  494. u8 addr;
  495. addr = TRF79070A_NFC_TARGET_PROTOCOL | TRF7970A_CMD_BIT_RW |
  496. TRF7970A_CMD_BIT_CONTINUOUS;
  497. ret = spi_write_then_read(trf->spi, &addr, 1, buf, 2);
  498. if (ret)
  499. dev_err(trf->dev, "%s - target_proto: Read failed: %d\n",
  500. __func__, ret);
  501. else
  502. *target_proto = buf[0];
  503. return ret;
  504. }
  505. static int trf7970a_mode_detect(struct trf7970a *trf, u8 *rf_tech)
  506. {
  507. int ret;
  508. u8 target_proto, tech;
  509. ret = trf7970a_read_target_proto(trf, &target_proto);
  510. if (ret)
  511. return ret;
  512. switch (target_proto) {
  513. case TRF79070A_NFC_TARGET_PROTOCOL_106A:
  514. tech = NFC_DIGITAL_RF_TECH_106A;
  515. break;
  516. case TRF79070A_NFC_TARGET_PROTOCOL_106B:
  517. tech = NFC_DIGITAL_RF_TECH_106B;
  518. break;
  519. case TRF79070A_NFC_TARGET_PROTOCOL_212F:
  520. tech = NFC_DIGITAL_RF_TECH_212F;
  521. break;
  522. case TRF79070A_NFC_TARGET_PROTOCOL_424F:
  523. tech = NFC_DIGITAL_RF_TECH_424F;
  524. break;
  525. default:
  526. dev_dbg(trf->dev, "%s - mode_detect: target_proto: 0x%x\n",
  527. __func__, target_proto);
  528. return -EIO;
  529. }
  530. *rf_tech = tech;
  531. return ret;
  532. }
  533. static void trf7970a_send_upstream(struct trf7970a *trf)
  534. {
  535. dev_kfree_skb_any(trf->tx_skb);
  536. trf->tx_skb = NULL;
  537. if (trf->rx_skb && !IS_ERR(trf->rx_skb) && !trf->aborting)
  538. print_hex_dump_debug("trf7970a rx data: ", DUMP_PREFIX_NONE,
  539. 16, 1, trf->rx_skb->data, trf->rx_skb->len,
  540. false);
  541. trf->state = TRF7970A_ST_IDLE;
  542. if (trf->aborting) {
  543. dev_dbg(trf->dev, "Abort process complete\n");
  544. if (!IS_ERR(trf->rx_skb)) {
  545. kfree_skb(trf->rx_skb);
  546. trf->rx_skb = ERR_PTR(-ECANCELED);
  547. }
  548. trf->aborting = false;
  549. }
  550. trf->cb(trf->ddev, trf->cb_arg, trf->rx_skb);
  551. trf->rx_skb = NULL;
  552. }
  553. static void trf7970a_send_err_upstream(struct trf7970a *trf, int errno)
  554. {
  555. dev_dbg(trf->dev, "Error - state: %d, errno: %d\n", trf->state, errno);
  556. cancel_delayed_work(&trf->timeout_work);
  557. kfree_skb(trf->rx_skb);
  558. trf->rx_skb = ERR_PTR(errno);
  559. trf7970a_send_upstream(trf);
  560. }
  561. static int trf7970a_transmit(struct trf7970a *trf, struct sk_buff *skb,
  562. unsigned int len, const u8 *prefix,
  563. unsigned int prefix_len)
  564. {
  565. struct spi_transfer t[2];
  566. struct spi_message m;
  567. unsigned int timeout;
  568. int ret;
  569. print_hex_dump_debug("trf7970a tx data: ", DUMP_PREFIX_NONE,
  570. 16, 1, skb->data, len, false);
  571. spi_message_init(&m);
  572. memset(&t, 0, sizeof(t));
  573. t[0].tx_buf = prefix;
  574. t[0].len = prefix_len;
  575. spi_message_add_tail(&t[0], &m);
  576. t[1].tx_buf = skb->data;
  577. t[1].len = len;
  578. spi_message_add_tail(&t[1], &m);
  579. ret = spi_sync(trf->spi, &m);
  580. if (ret) {
  581. dev_err(trf->dev, "%s - Can't send tx data: %d\n", __func__,
  582. ret);
  583. return ret;
  584. }
  585. skb_pull(skb, len);
  586. if (skb->len > 0) {
  587. trf->state = TRF7970A_ST_WAIT_FOR_TX_FIFO;
  588. timeout = TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT;
  589. } else {
  590. if (trf->issue_eof) {
  591. trf->state = TRF7970A_ST_WAIT_TO_ISSUE_EOF;
  592. timeout = TRF7970A_WAIT_TO_ISSUE_ISO15693_EOF;
  593. } else {
  594. trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA;
  595. if (!trf->timeout)
  596. timeout = TRF7970A_WAIT_FOR_TX_IRQ;
  597. else
  598. timeout = trf->timeout;
  599. }
  600. }
  601. dev_dbg(trf->dev, "Setting timeout for %d ms, state: %d\n", timeout,
  602. trf->state);
  603. schedule_delayed_work(&trf->timeout_work, msecs_to_jiffies(timeout));
  604. return 0;
  605. }
  606. static void trf7970a_fill_fifo(struct trf7970a *trf)
  607. {
  608. struct sk_buff *skb = trf->tx_skb;
  609. unsigned int len;
  610. int ret;
  611. u8 fifo_bytes;
  612. u8 prefix;
  613. ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
  614. if (ret) {
  615. trf7970a_send_err_upstream(trf, ret);
  616. return;
  617. }
  618. dev_dbg(trf->dev, "Filling FIFO - fifo_bytes: 0x%x\n", fifo_bytes);
  619. fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW;
  620. /* Calculate how much more data can be written to the fifo */
  621. len = TRF7970A_FIFO_SIZE - fifo_bytes;
  622. if (!len) {
  623. schedule_delayed_work(&trf->timeout_work,
  624. msecs_to_jiffies(TRF7970A_WAIT_FOR_FIFO_DRAIN_TIMEOUT));
  625. return;
  626. }
  627. len = min(skb->len, len);
  628. prefix = TRF7970A_CMD_BIT_CONTINUOUS | TRF7970A_FIFO_IO_REGISTER;
  629. ret = trf7970a_transmit(trf, skb, len, &prefix, sizeof(prefix));
  630. if (ret)
  631. trf7970a_send_err_upstream(trf, ret);
  632. }
  633. static void trf7970a_drain_fifo(struct trf7970a *trf, u8 status)
  634. {
  635. struct sk_buff *skb = trf->rx_skb;
  636. int ret;
  637. u8 fifo_bytes;
  638. if (status & TRF7970A_IRQ_STATUS_ERROR) {
  639. trf7970a_send_err_upstream(trf, -EIO);
  640. return;
  641. }
  642. ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
  643. if (ret) {
  644. trf7970a_send_err_upstream(trf, ret);
  645. return;
  646. }
  647. dev_dbg(trf->dev, "Draining FIFO - fifo_bytes: 0x%x\n", fifo_bytes);
  648. fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW;
  649. if (!fifo_bytes)
  650. goto no_rx_data;
  651. if (fifo_bytes > skb_tailroom(skb)) {
  652. skb = skb_copy_expand(skb, skb_headroom(skb),
  653. max_t(int, fifo_bytes,
  654. TRF7970A_RX_SKB_ALLOC_SIZE),
  655. GFP_KERNEL);
  656. if (!skb) {
  657. trf7970a_send_err_upstream(trf, -ENOMEM);
  658. return;
  659. }
  660. kfree_skb(trf->rx_skb);
  661. trf->rx_skb = skb;
  662. }
  663. ret = trf7970a_read_cont(trf, TRF7970A_FIFO_IO_REGISTER,
  664. skb_put(skb, fifo_bytes), fifo_bytes);
  665. if (ret) {
  666. trf7970a_send_err_upstream(trf, ret);
  667. return;
  668. }
  669. /* If received Type 2 ACK/NACK, shift right 4 bits and pass up */
  670. if ((trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T) && (skb->len == 1) &&
  671. (trf->special_fcn_reg1 == TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX)) {
  672. skb->data[0] >>= 4;
  673. status = TRF7970A_IRQ_STATUS_SRX;
  674. } else {
  675. trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA_CONT;
  676. ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS, &fifo_bytes);
  677. if (ret) {
  678. trf7970a_send_err_upstream(trf, ret);
  679. return;
  680. }
  681. fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW;
  682. /* If there are bytes in the FIFO, set status to '0' so
  683. * the if stmt below doesn't fire and the driver will wait
  684. * for the trf7970a to generate another RX interrupt.
  685. */
  686. if (fifo_bytes)
  687. status = 0;
  688. }
  689. no_rx_data:
  690. if (status == TRF7970A_IRQ_STATUS_SRX) { /* Receive complete */
  691. trf7970a_send_upstream(trf);
  692. return;
  693. }
  694. dev_dbg(trf->dev, "Setting timeout for %d ms\n",
  695. TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT);
  696. schedule_delayed_work(&trf->timeout_work,
  697. msecs_to_jiffies(TRF7970A_WAIT_FOR_RX_DATA_TIMEOUT));
  698. }
  699. static irqreturn_t trf7970a_irq(int irq, void *dev_id)
  700. {
  701. struct trf7970a *trf = dev_id;
  702. int ret;
  703. u8 status, fifo_bytes, iso_ctrl;
  704. mutex_lock(&trf->lock);
  705. if (trf->state == TRF7970A_ST_RF_OFF) {
  706. mutex_unlock(&trf->lock);
  707. return IRQ_NONE;
  708. }
  709. ret = trf7970a_read_irqstatus(trf, &status);
  710. if (ret) {
  711. mutex_unlock(&trf->lock);
  712. return IRQ_NONE;
  713. }
  714. dev_dbg(trf->dev, "IRQ - state: %d, status: 0x%x\n", trf->state,
  715. status);
  716. if (!status) {
  717. mutex_unlock(&trf->lock);
  718. return IRQ_NONE;
  719. }
  720. switch (trf->state) {
  721. case TRF7970A_ST_IDLE:
  722. case TRF7970A_ST_IDLE_RX_BLOCKED:
  723. /* If initiator and getting interrupts caused by RF noise,
  724. * turn off the receiver to avoid unnecessary interrupts.
  725. * It will be turned back on in trf7970a_send_cmd() when
  726. * the next command is issued.
  727. */
  728. if (trf->is_initiator && (status & TRF7970A_IRQ_STATUS_ERROR)) {
  729. trf7970a_cmd(trf, TRF7970A_CMD_BLOCK_RX);
  730. trf->state = TRF7970A_ST_IDLE_RX_BLOCKED;
  731. }
  732. trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
  733. break;
  734. case TRF7970A_ST_WAIT_FOR_TX_FIFO:
  735. if (status & TRF7970A_IRQ_STATUS_TX) {
  736. trf->ignore_timeout =
  737. !cancel_delayed_work(&trf->timeout_work);
  738. trf7970a_fill_fifo(trf);
  739. } else {
  740. trf7970a_send_err_upstream(trf, -EIO);
  741. }
  742. break;
  743. case TRF7970A_ST_WAIT_FOR_RX_DATA:
  744. case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
  745. if (status & TRF7970A_IRQ_STATUS_SRX) {
  746. trf->ignore_timeout =
  747. !cancel_delayed_work(&trf->timeout_work);
  748. trf7970a_drain_fifo(trf, status);
  749. } else if (status & TRF7970A_IRQ_STATUS_FIFO) {
  750. ret = trf7970a_read(trf, TRF7970A_FIFO_STATUS,
  751. &fifo_bytes);
  752. fifo_bytes &= ~TRF7970A_FIFO_STATUS_OVERFLOW;
  753. if (ret)
  754. trf7970a_send_err_upstream(trf, ret);
  755. else if (!fifo_bytes)
  756. trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
  757. } else if ((status == TRF7970A_IRQ_STATUS_TX) ||
  758. (!trf->is_initiator &&
  759. (status == (TRF7970A_IRQ_STATUS_TX |
  760. TRF7970A_IRQ_STATUS_NFC_RF)))) {
  761. trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
  762. if (!trf->timeout) {
  763. trf->ignore_timeout =
  764. !cancel_delayed_work(&trf->timeout_work);
  765. trf->rx_skb = ERR_PTR(0);
  766. trf7970a_send_upstream(trf);
  767. break;
  768. }
  769. if (trf->is_initiator)
  770. break;
  771. iso_ctrl = trf->iso_ctrl;
  772. switch (trf->framing) {
  773. case NFC_DIGITAL_FRAMING_NFCA_STANDARD:
  774. trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
  775. iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
  776. trf->iso_ctrl = 0xff; /* Force ISO_CTRL write */
  777. break;
  778. case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:
  779. trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
  780. iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
  781. trf->iso_ctrl = 0xff; /* Force ISO_CTRL write */
  782. break;
  783. case NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE:
  784. ret = trf7970a_write(trf,
  785. TRF7970A_SPECIAL_FCN_REG1,
  786. TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL);
  787. if (ret)
  788. goto err_unlock_exit;
  789. trf->special_fcn_reg1 =
  790. TRF7970A_SPECIAL_FCN_REG1_14_ANTICOLL;
  791. break;
  792. default:
  793. break;
  794. }
  795. if (iso_ctrl != trf->iso_ctrl) {
  796. ret = trf7970a_write(trf, TRF7970A_ISO_CTRL,
  797. iso_ctrl);
  798. if (ret)
  799. goto err_unlock_exit;
  800. trf->iso_ctrl = iso_ctrl;
  801. }
  802. } else {
  803. trf7970a_send_err_upstream(trf, -EIO);
  804. }
  805. break;
  806. case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
  807. if (status != TRF7970A_IRQ_STATUS_TX)
  808. trf7970a_send_err_upstream(trf, -EIO);
  809. break;
  810. case TRF7970A_ST_LISTENING:
  811. if (status & TRF7970A_IRQ_STATUS_SRX) {
  812. trf->ignore_timeout =
  813. !cancel_delayed_work(&trf->timeout_work);
  814. trf7970a_drain_fifo(trf, status);
  815. } else if (!(status & TRF7970A_IRQ_STATUS_NFC_RF)) {
  816. trf7970a_send_err_upstream(trf, -EIO);
  817. }
  818. break;
  819. case TRF7970A_ST_LISTENING_MD:
  820. if (status & TRF7970A_IRQ_STATUS_SRX) {
  821. trf->ignore_timeout =
  822. !cancel_delayed_work(&trf->timeout_work);
  823. ret = trf7970a_mode_detect(trf, &trf->md_rf_tech);
  824. if (ret) {
  825. trf7970a_send_err_upstream(trf, ret);
  826. } else {
  827. trf->state = TRF7970A_ST_LISTENING;
  828. trf7970a_drain_fifo(trf, status);
  829. }
  830. } else if (!(status & TRF7970A_IRQ_STATUS_NFC_RF)) {
  831. trf7970a_send_err_upstream(trf, -EIO);
  832. }
  833. break;
  834. default:
  835. dev_err(trf->dev, "%s - Driver in invalid state: %d\n",
  836. __func__, trf->state);
  837. }
  838. err_unlock_exit:
  839. mutex_unlock(&trf->lock);
  840. return IRQ_HANDLED;
  841. }
  842. static void trf7970a_issue_eof(struct trf7970a *trf)
  843. {
  844. int ret;
  845. dev_dbg(trf->dev, "Issuing EOF\n");
  846. ret = trf7970a_cmd(trf, TRF7970A_CMD_FIFO_RESET);
  847. if (ret)
  848. trf7970a_send_err_upstream(trf, ret);
  849. ret = trf7970a_cmd(trf, TRF7970A_CMD_EOF);
  850. if (ret)
  851. trf7970a_send_err_upstream(trf, ret);
  852. trf->state = TRF7970A_ST_WAIT_FOR_RX_DATA;
  853. dev_dbg(trf->dev, "Setting timeout for %d ms, state: %d\n",
  854. trf->timeout, trf->state);
  855. schedule_delayed_work(&trf->timeout_work,
  856. msecs_to_jiffies(trf->timeout));
  857. }
  858. static void trf7970a_timeout_work_handler(struct work_struct *work)
  859. {
  860. struct trf7970a *trf = container_of(work, struct trf7970a,
  861. timeout_work.work);
  862. dev_dbg(trf->dev, "Timeout - state: %d, ignore_timeout: %d\n",
  863. trf->state, trf->ignore_timeout);
  864. mutex_lock(&trf->lock);
  865. if (trf->ignore_timeout)
  866. trf->ignore_timeout = false;
  867. else if (trf->state == TRF7970A_ST_WAIT_FOR_RX_DATA_CONT)
  868. trf7970a_drain_fifo(trf, TRF7970A_IRQ_STATUS_SRX);
  869. else if (trf->state == TRF7970A_ST_WAIT_TO_ISSUE_EOF)
  870. trf7970a_issue_eof(trf);
  871. else
  872. trf7970a_send_err_upstream(trf, -ETIMEDOUT);
  873. mutex_unlock(&trf->lock);
  874. }
  875. static int trf7970a_init(struct trf7970a *trf)
  876. {
  877. int ret;
  878. dev_dbg(trf->dev, "Initializing device - state: %d\n", trf->state);
  879. ret = trf7970a_cmd(trf, TRF7970A_CMD_SOFT_INIT);
  880. if (ret)
  881. goto err_out;
  882. ret = trf7970a_cmd(trf, TRF7970A_CMD_IDLE);
  883. if (ret)
  884. goto err_out;
  885. ret = trf7970a_write(trf, TRF7970A_REG_IO_CTRL,
  886. trf->io_ctrl | TRF7970A_REG_IO_CTRL_VRS(0x1));
  887. if (ret)
  888. goto err_out;
  889. ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL, 0);
  890. if (ret)
  891. goto err_out;
  892. usleep_range(1000, 2000);
  893. trf->chip_status_ctrl &= ~TRF7970A_CHIP_STATUS_RF_ON;
  894. ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL,
  895. trf->modulator_sys_clk_ctrl);
  896. if (ret)
  897. goto err_out;
  898. ret = trf7970a_write(trf, TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS,
  899. TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLH_96 |
  900. TRF7970A_ADJUTABLE_FIFO_IRQ_LEVELS_WLL_32);
  901. if (ret)
  902. goto err_out;
  903. ret = trf7970a_write(trf, TRF7970A_SPECIAL_FCN_REG1, 0);
  904. if (ret)
  905. goto err_out;
  906. trf->special_fcn_reg1 = 0;
  907. trf->iso_ctrl = 0xff;
  908. return 0;
  909. err_out:
  910. dev_dbg(trf->dev, "Couldn't init device: %d\n", ret);
  911. return ret;
  912. }
  913. static void trf7970a_switch_rf_off(struct trf7970a *trf)
  914. {
  915. if ((trf->state == TRF7970A_ST_PWR_OFF) ||
  916. (trf->state == TRF7970A_ST_RF_OFF))
  917. return;
  918. dev_dbg(trf->dev, "Switching rf off\n");
  919. trf->chip_status_ctrl &= ~TRF7970A_CHIP_STATUS_RF_ON;
  920. trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL, trf->chip_status_ctrl);
  921. trf->aborting = false;
  922. trf->state = TRF7970A_ST_RF_OFF;
  923. pm_runtime_mark_last_busy(trf->dev);
  924. pm_runtime_put_autosuspend(trf->dev);
  925. }
  926. static int trf7970a_switch_rf_on(struct trf7970a *trf)
  927. {
  928. int ret;
  929. dev_dbg(trf->dev, "Switching rf on\n");
  930. pm_runtime_get_sync(trf->dev);
  931. if (trf->state != TRF7970A_ST_RF_OFF) { /* Power on, RF off */
  932. dev_err(trf->dev, "%s - Incorrect state: %d\n", __func__,
  933. trf->state);
  934. return -EINVAL;
  935. }
  936. ret = trf7970a_init(trf);
  937. if (ret) {
  938. dev_err(trf->dev, "%s - Can't initialize: %d\n", __func__, ret);
  939. return ret;
  940. }
  941. trf->state = TRF7970A_ST_IDLE;
  942. return 0;
  943. }
  944. static int trf7970a_switch_rf(struct nfc_digital_dev *ddev, bool on)
  945. {
  946. struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
  947. int ret = 0;
  948. dev_dbg(trf->dev, "Switching RF - state: %d, on: %d\n", trf->state, on);
  949. mutex_lock(&trf->lock);
  950. if (on) {
  951. switch (trf->state) {
  952. case TRF7970A_ST_PWR_OFF:
  953. case TRF7970A_ST_RF_OFF:
  954. ret = trf7970a_switch_rf_on(trf);
  955. break;
  956. case TRF7970A_ST_IDLE:
  957. case TRF7970A_ST_IDLE_RX_BLOCKED:
  958. break;
  959. default:
  960. dev_err(trf->dev, "%s - Invalid request: %d %d\n",
  961. __func__, trf->state, on);
  962. trf7970a_switch_rf_off(trf);
  963. ret = -EINVAL;
  964. }
  965. } else {
  966. switch (trf->state) {
  967. case TRF7970A_ST_PWR_OFF:
  968. case TRF7970A_ST_RF_OFF:
  969. break;
  970. default:
  971. dev_err(trf->dev, "%s - Invalid request: %d %d\n",
  972. __func__, trf->state, on);
  973. ret = -EINVAL;
  974. fallthrough;
  975. case TRF7970A_ST_IDLE:
  976. case TRF7970A_ST_IDLE_RX_BLOCKED:
  977. case TRF7970A_ST_WAIT_FOR_RX_DATA:
  978. case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
  979. trf7970a_switch_rf_off(trf);
  980. }
  981. }
  982. mutex_unlock(&trf->lock);
  983. return ret;
  984. }
  985. static int trf7970a_in_config_rf_tech(struct trf7970a *trf, int tech)
  986. {
  987. int ret = 0;
  988. dev_dbg(trf->dev, "rf technology: %d\n", tech);
  989. switch (tech) {
  990. case NFC_DIGITAL_RF_TECH_106A:
  991. trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443A_106;
  992. trf->modulator_sys_clk_ctrl =
  993. (trf->modulator_sys_clk_ctrl & 0xf8) |
  994. TRF7970A_MODULATOR_DEPTH_OOK;
  995. trf->guard_time = TRF7970A_GUARD_TIME_NFCA;
  996. break;
  997. case NFC_DIGITAL_RF_TECH_106B:
  998. trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_14443B_106;
  999. trf->modulator_sys_clk_ctrl =
  1000. (trf->modulator_sys_clk_ctrl & 0xf8) |
  1001. TRF7970A_MODULATOR_DEPTH_ASK10;
  1002. trf->guard_time = TRF7970A_GUARD_TIME_NFCB;
  1003. break;
  1004. case NFC_DIGITAL_RF_TECH_212F:
  1005. trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_212;
  1006. trf->modulator_sys_clk_ctrl =
  1007. (trf->modulator_sys_clk_ctrl & 0xf8) |
  1008. TRF7970A_MODULATOR_DEPTH_ASK10;
  1009. trf->guard_time = TRF7970A_GUARD_TIME_NFCF;
  1010. break;
  1011. case NFC_DIGITAL_RF_TECH_424F:
  1012. trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_FELICA_424;
  1013. trf->modulator_sys_clk_ctrl =
  1014. (trf->modulator_sys_clk_ctrl & 0xf8) |
  1015. TRF7970A_MODULATOR_DEPTH_ASK10;
  1016. trf->guard_time = TRF7970A_GUARD_TIME_NFCF;
  1017. break;
  1018. case NFC_DIGITAL_RF_TECH_ISO15693:
  1019. trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648;
  1020. trf->modulator_sys_clk_ctrl =
  1021. (trf->modulator_sys_clk_ctrl & 0xf8) |
  1022. TRF7970A_MODULATOR_DEPTH_OOK;
  1023. trf->guard_time = TRF7970A_GUARD_TIME_15693;
  1024. break;
  1025. default:
  1026. dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech);
  1027. return -EINVAL;
  1028. }
  1029. trf->technology = tech;
  1030. /* If in initiator mode and not changing the RF tech due to a
  1031. * PSL sequence (indicated by 'trf->iso_ctrl == 0xff' from
  1032. * trf7970a_init()), clear the NFC Target Detection Level register
  1033. * due to erratum.
  1034. */
  1035. if (trf->iso_ctrl == 0xff)
  1036. ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL, 0);
  1037. return ret;
  1038. }
  1039. static int trf7970a_is_rf_field(struct trf7970a *trf, bool *is_rf_field)
  1040. {
  1041. int ret;
  1042. u8 rssi;
  1043. ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
  1044. trf->chip_status_ctrl |
  1045. TRF7970A_CHIP_STATUS_REC_ON);
  1046. if (ret)
  1047. return ret;
  1048. ret = trf7970a_cmd(trf, TRF7970A_CMD_TEST_EXT_RF);
  1049. if (ret)
  1050. return ret;
  1051. usleep_range(50, 60);
  1052. ret = trf7970a_read(trf, TRF7970A_RSSI_OSC_STATUS, &rssi);
  1053. if (ret)
  1054. return ret;
  1055. ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
  1056. trf->chip_status_ctrl);
  1057. if (ret)
  1058. return ret;
  1059. if (rssi & TRF7970A_RSSI_OSC_STATUS_RSSI_MASK)
  1060. *is_rf_field = true;
  1061. else
  1062. *is_rf_field = false;
  1063. return 0;
  1064. }
  1065. static int trf7970a_in_config_framing(struct trf7970a *trf, int framing)
  1066. {
  1067. u8 iso_ctrl = trf->iso_ctrl_tech;
  1068. bool is_rf_field = false;
  1069. int ret;
  1070. dev_dbg(trf->dev, "framing: %d\n", framing);
  1071. switch (framing) {
  1072. case NFC_DIGITAL_FRAMING_NFCA_SHORT:
  1073. case NFC_DIGITAL_FRAMING_NFCA_STANDARD:
  1074. trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
  1075. iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
  1076. break;
  1077. case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:
  1078. case NFC_DIGITAL_FRAMING_NFCA_T4T:
  1079. case NFC_DIGITAL_FRAMING_NFCB:
  1080. case NFC_DIGITAL_FRAMING_NFCB_T4T:
  1081. case NFC_DIGITAL_FRAMING_NFCF:
  1082. case NFC_DIGITAL_FRAMING_NFCF_T3T:
  1083. case NFC_DIGITAL_FRAMING_ISO15693_INVENTORY:
  1084. case NFC_DIGITAL_FRAMING_ISO15693_T5T:
  1085. case NFC_DIGITAL_FRAMING_NFCA_NFC_DEP:
  1086. case NFC_DIGITAL_FRAMING_NFCF_NFC_DEP:
  1087. trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
  1088. iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
  1089. break;
  1090. case NFC_DIGITAL_FRAMING_NFCA_T2T:
  1091. trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
  1092. iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
  1093. break;
  1094. default:
  1095. dev_dbg(trf->dev, "Unsupported Framing: %d\n", framing);
  1096. return -EINVAL;
  1097. }
  1098. trf->framing = framing;
  1099. if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
  1100. ret = trf7970a_is_rf_field(trf, &is_rf_field);
  1101. if (ret)
  1102. return ret;
  1103. if (is_rf_field)
  1104. return -EBUSY;
  1105. }
  1106. if (iso_ctrl != trf->iso_ctrl) {
  1107. ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
  1108. if (ret)
  1109. return ret;
  1110. trf->iso_ctrl = iso_ctrl;
  1111. ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL,
  1112. trf->modulator_sys_clk_ctrl);
  1113. if (ret)
  1114. return ret;
  1115. }
  1116. if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
  1117. ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
  1118. trf->chip_status_ctrl |
  1119. TRF7970A_CHIP_STATUS_RF_ON);
  1120. if (ret)
  1121. return ret;
  1122. trf->chip_status_ctrl |= TRF7970A_CHIP_STATUS_RF_ON;
  1123. usleep_range(trf->guard_time, trf->guard_time + 1000);
  1124. }
  1125. return 0;
  1126. }
  1127. static int trf7970a_in_configure_hw(struct nfc_digital_dev *ddev, int type,
  1128. int param)
  1129. {
  1130. struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
  1131. int ret;
  1132. dev_dbg(trf->dev, "Configure hw - type: %d, param: %d\n", type, param);
  1133. mutex_lock(&trf->lock);
  1134. trf->is_initiator = true;
  1135. if ((trf->state == TRF7970A_ST_PWR_OFF) ||
  1136. (trf->state == TRF7970A_ST_RF_OFF)) {
  1137. ret = trf7970a_switch_rf_on(trf);
  1138. if (ret)
  1139. goto err_unlock;
  1140. }
  1141. switch (type) {
  1142. case NFC_DIGITAL_CONFIG_RF_TECH:
  1143. ret = trf7970a_in_config_rf_tech(trf, param);
  1144. break;
  1145. case NFC_DIGITAL_CONFIG_FRAMING:
  1146. ret = trf7970a_in_config_framing(trf, param);
  1147. break;
  1148. default:
  1149. dev_dbg(trf->dev, "Unknown type: %d\n", type);
  1150. ret = -EINVAL;
  1151. }
  1152. err_unlock:
  1153. mutex_unlock(&trf->lock);
  1154. return ret;
  1155. }
  1156. static int trf7970a_is_iso15693_write_or_lock(u8 cmd)
  1157. {
  1158. switch (cmd) {
  1159. case ISO15693_CMD_WRITE_SINGLE_BLOCK:
  1160. case ISO15693_CMD_LOCK_BLOCK:
  1161. case ISO15693_CMD_WRITE_MULTIPLE_BLOCK:
  1162. case ISO15693_CMD_WRITE_AFI:
  1163. case ISO15693_CMD_LOCK_AFI:
  1164. case ISO15693_CMD_WRITE_DSFID:
  1165. case ISO15693_CMD_LOCK_DSFID:
  1166. return 1;
  1167. default:
  1168. return 0;
  1169. }
  1170. }
  1171. static int trf7970a_per_cmd_config(struct trf7970a *trf,
  1172. const struct sk_buff *skb)
  1173. {
  1174. const u8 *req = skb->data;
  1175. u8 special_fcn_reg1, iso_ctrl;
  1176. int ret;
  1177. trf->issue_eof = false;
  1178. /* When issuing Type 2 read command, make sure the '4_bit_RX' bit in
  1179. * special functions register 1 is cleared; otherwise, its a write or
  1180. * sector select command and '4_bit_RX' must be set.
  1181. *
  1182. * When issuing an ISO 15693 command, inspect the flags byte to see
  1183. * what speed to use. Also, remember if the OPTION flag is set on
  1184. * a Type 5 write or lock command so the driver will know that it
  1185. * has to send an EOF in order to get a response.
  1186. */
  1187. if ((trf->technology == NFC_DIGITAL_RF_TECH_106A) &&
  1188. (trf->framing == NFC_DIGITAL_FRAMING_NFCA_T2T)) {
  1189. if (req[0] == NFC_T2T_CMD_READ)
  1190. special_fcn_reg1 = 0;
  1191. else
  1192. special_fcn_reg1 = TRF7970A_SPECIAL_FCN_REG1_4_BIT_RX;
  1193. if (special_fcn_reg1 != trf->special_fcn_reg1) {
  1194. ret = trf7970a_write(trf, TRF7970A_SPECIAL_FCN_REG1,
  1195. special_fcn_reg1);
  1196. if (ret)
  1197. return ret;
  1198. trf->special_fcn_reg1 = special_fcn_reg1;
  1199. }
  1200. } else if (trf->technology == NFC_DIGITAL_RF_TECH_ISO15693) {
  1201. iso_ctrl = trf->iso_ctrl & ~TRF7970A_ISO_CTRL_RFID_SPEED_MASK;
  1202. switch (req[0] & ISO15693_REQ_FLAG_SPEED_MASK) {
  1203. case 0x00:
  1204. iso_ctrl |= TRF7970A_ISO_CTRL_15693_SGL_1OF4_662;
  1205. break;
  1206. case ISO15693_REQ_FLAG_SUB_CARRIER:
  1207. iso_ctrl |= TRF7970A_ISO_CTRL_15693_DBL_1OF4_667a;
  1208. break;
  1209. case ISO15693_REQ_FLAG_DATA_RATE:
  1210. iso_ctrl |= TRF7970A_ISO_CTRL_15693_SGL_1OF4_2648;
  1211. break;
  1212. case (ISO15693_REQ_FLAG_SUB_CARRIER |
  1213. ISO15693_REQ_FLAG_DATA_RATE):
  1214. iso_ctrl |= TRF7970A_ISO_CTRL_15693_DBL_1OF4_2669;
  1215. break;
  1216. }
  1217. if (iso_ctrl != trf->iso_ctrl) {
  1218. ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
  1219. if (ret)
  1220. return ret;
  1221. trf->iso_ctrl = iso_ctrl;
  1222. }
  1223. if ((trf->framing == NFC_DIGITAL_FRAMING_ISO15693_T5T) &&
  1224. trf7970a_is_iso15693_write_or_lock(req[1]) &&
  1225. (req[0] & ISO15693_REQ_FLAG_OPTION))
  1226. trf->issue_eof = true;
  1227. }
  1228. return 0;
  1229. }
  1230. static int trf7970a_send_cmd(struct nfc_digital_dev *ddev,
  1231. struct sk_buff *skb, u16 timeout,
  1232. nfc_digital_cmd_complete_t cb, void *arg)
  1233. {
  1234. struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
  1235. u8 prefix[5];
  1236. unsigned int len;
  1237. int ret;
  1238. u8 status;
  1239. dev_dbg(trf->dev, "New request - state: %d, timeout: %d ms, len: %d\n",
  1240. trf->state, timeout, skb->len);
  1241. if (skb->len > TRF7970A_TX_MAX)
  1242. return -EINVAL;
  1243. mutex_lock(&trf->lock);
  1244. if ((trf->state != TRF7970A_ST_IDLE) &&
  1245. (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) {
  1246. dev_err(trf->dev, "%s - Bogus state: %d\n", __func__,
  1247. trf->state);
  1248. ret = -EIO;
  1249. goto out_err;
  1250. }
  1251. if (trf->aborting) {
  1252. dev_dbg(trf->dev, "Abort process complete\n");
  1253. trf->aborting = false;
  1254. ret = -ECANCELED;
  1255. goto out_err;
  1256. }
  1257. if (timeout) {
  1258. trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE,
  1259. GFP_KERNEL);
  1260. if (!trf->rx_skb) {
  1261. dev_dbg(trf->dev, "Can't alloc rx_skb\n");
  1262. ret = -ENOMEM;
  1263. goto out_err;
  1264. }
  1265. }
  1266. if (trf->state == TRF7970A_ST_IDLE_RX_BLOCKED) {
  1267. ret = trf7970a_cmd(trf, TRF7970A_CMD_ENABLE_RX);
  1268. if (ret)
  1269. goto out_err;
  1270. trf->state = TRF7970A_ST_IDLE;
  1271. }
  1272. if (trf->is_initiator) {
  1273. ret = trf7970a_per_cmd_config(trf, skb);
  1274. if (ret)
  1275. goto out_err;
  1276. }
  1277. trf->ddev = ddev;
  1278. trf->tx_skb = skb;
  1279. trf->cb = cb;
  1280. trf->cb_arg = arg;
  1281. trf->timeout = timeout;
  1282. trf->ignore_timeout = false;
  1283. len = skb->len;
  1284. /* TX data must be prefixed with a FIFO reset cmd, a cmd that depends
  1285. * on what the current framing is, the address of the TX length byte 1
  1286. * register (0x1d), and the 2 byte length of the data to be transmitted.
  1287. * That totals 5 bytes.
  1288. */
  1289. prefix[0] = TRF7970A_CMD_BIT_CTRL |
  1290. TRF7970A_CMD_BIT_OPCODE(TRF7970A_CMD_FIFO_RESET);
  1291. prefix[1] = TRF7970A_CMD_BIT_CTRL |
  1292. TRF7970A_CMD_BIT_OPCODE(trf->tx_cmd);
  1293. prefix[2] = TRF7970A_CMD_BIT_CONTINUOUS | TRF7970A_TX_LENGTH_BYTE1;
  1294. if (trf->framing == NFC_DIGITAL_FRAMING_NFCA_SHORT) {
  1295. prefix[3] = 0x00;
  1296. prefix[4] = 0x0f; /* 7 bits */
  1297. } else {
  1298. prefix[3] = (len & 0xf00) >> 4;
  1299. prefix[3] |= ((len & 0xf0) >> 4);
  1300. prefix[4] = ((len & 0x0f) << 4);
  1301. }
  1302. len = min_t(int, skb->len, TRF7970A_FIFO_SIZE);
  1303. /* Clear possible spurious interrupt */
  1304. ret = trf7970a_read_irqstatus(trf, &status);
  1305. if (ret)
  1306. goto out_err;
  1307. ret = trf7970a_transmit(trf, skb, len, prefix, sizeof(prefix));
  1308. if (ret) {
  1309. kfree_skb(trf->rx_skb);
  1310. trf->rx_skb = NULL;
  1311. }
  1312. out_err:
  1313. mutex_unlock(&trf->lock);
  1314. return ret;
  1315. }
  1316. static int trf7970a_tg_config_rf_tech(struct trf7970a *trf, int tech)
  1317. {
  1318. int ret = 0;
  1319. dev_dbg(trf->dev, "rf technology: %d\n", tech);
  1320. switch (tech) {
  1321. case NFC_DIGITAL_RF_TECH_106A:
  1322. trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
  1323. TRF7970A_ISO_CTRL_NFC_CE | TRF7970A_ISO_CTRL_NFC_CE_14443A;
  1324. trf->modulator_sys_clk_ctrl =
  1325. (trf->modulator_sys_clk_ctrl & 0xf8) |
  1326. TRF7970A_MODULATOR_DEPTH_OOK;
  1327. break;
  1328. case NFC_DIGITAL_RF_TECH_212F:
  1329. trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
  1330. TRF7970A_ISO_CTRL_NFC_NFCF_212;
  1331. trf->modulator_sys_clk_ctrl =
  1332. (trf->modulator_sys_clk_ctrl & 0xf8) |
  1333. TRF7970A_MODULATOR_DEPTH_ASK10;
  1334. break;
  1335. case NFC_DIGITAL_RF_TECH_424F:
  1336. trf->iso_ctrl_tech = TRF7970A_ISO_CTRL_NFC_NFC_CE_MODE |
  1337. TRF7970A_ISO_CTRL_NFC_NFCF_424;
  1338. trf->modulator_sys_clk_ctrl =
  1339. (trf->modulator_sys_clk_ctrl & 0xf8) |
  1340. TRF7970A_MODULATOR_DEPTH_ASK10;
  1341. break;
  1342. default:
  1343. dev_dbg(trf->dev, "Unsupported rf technology: %d\n", tech);
  1344. return -EINVAL;
  1345. }
  1346. trf->technology = tech;
  1347. /* Normally we write the ISO_CTRL register in
  1348. * trf7970a_tg_config_framing() because the framing can change
  1349. * the value written. However, when sending a PSL RES,
  1350. * digital_tg_send_psl_res_complete() doesn't call
  1351. * trf7970a_tg_config_framing() so we must write the register
  1352. * here.
  1353. */
  1354. if ((trf->framing == NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED) &&
  1355. (trf->iso_ctrl_tech != trf->iso_ctrl)) {
  1356. ret = trf7970a_write(trf, TRF7970A_ISO_CTRL,
  1357. trf->iso_ctrl_tech);
  1358. trf->iso_ctrl = trf->iso_ctrl_tech;
  1359. }
  1360. return ret;
  1361. }
  1362. /* Since this is a target routine, several of the framing calls are
  1363. * made between receiving the request and sending the response so they
  1364. * should take effect until after the response is sent. This is accomplished
  1365. * by skipping the ISO_CTRL register write here and doing it in the interrupt
  1366. * handler.
  1367. */
  1368. static int trf7970a_tg_config_framing(struct trf7970a *trf, int framing)
  1369. {
  1370. u8 iso_ctrl = trf->iso_ctrl_tech;
  1371. int ret;
  1372. dev_dbg(trf->dev, "framing: %d\n", framing);
  1373. switch (framing) {
  1374. case NFC_DIGITAL_FRAMING_NFCA_NFC_DEP:
  1375. trf->tx_cmd = TRF7970A_CMD_TRANSMIT_NO_CRC;
  1376. iso_ctrl |= TRF7970A_ISO_CTRL_RX_CRC_N;
  1377. break;
  1378. case NFC_DIGITAL_FRAMING_NFCA_STANDARD:
  1379. case NFC_DIGITAL_FRAMING_NFCA_STANDARD_WITH_CRC_A:
  1380. case NFC_DIGITAL_FRAMING_NFCA_ANTICOL_COMPLETE:
  1381. /* These ones are applied in the interrupt handler */
  1382. iso_ctrl = trf->iso_ctrl; /* Don't write to ISO_CTRL yet */
  1383. break;
  1384. case NFC_DIGITAL_FRAMING_NFCF_NFC_DEP:
  1385. trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
  1386. iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
  1387. break;
  1388. case NFC_DIGITAL_FRAMING_NFC_DEP_ACTIVATED:
  1389. trf->tx_cmd = TRF7970A_CMD_TRANSMIT;
  1390. iso_ctrl &= ~TRF7970A_ISO_CTRL_RX_CRC_N;
  1391. break;
  1392. default:
  1393. dev_dbg(trf->dev, "Unsupported Framing: %d\n", framing);
  1394. return -EINVAL;
  1395. }
  1396. trf->framing = framing;
  1397. if (iso_ctrl != trf->iso_ctrl) {
  1398. ret = trf7970a_write(trf, TRF7970A_ISO_CTRL, iso_ctrl);
  1399. if (ret)
  1400. return ret;
  1401. trf->iso_ctrl = iso_ctrl;
  1402. ret = trf7970a_write(trf, TRF7970A_MODULATOR_SYS_CLK_CTRL,
  1403. trf->modulator_sys_clk_ctrl);
  1404. if (ret)
  1405. return ret;
  1406. }
  1407. if (!(trf->chip_status_ctrl & TRF7970A_CHIP_STATUS_RF_ON)) {
  1408. ret = trf7970a_write(trf, TRF7970A_CHIP_STATUS_CTRL,
  1409. trf->chip_status_ctrl |
  1410. TRF7970A_CHIP_STATUS_RF_ON);
  1411. if (ret)
  1412. return ret;
  1413. trf->chip_status_ctrl |= TRF7970A_CHIP_STATUS_RF_ON;
  1414. }
  1415. return 0;
  1416. }
  1417. static int trf7970a_tg_configure_hw(struct nfc_digital_dev *ddev, int type,
  1418. int param)
  1419. {
  1420. struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
  1421. int ret;
  1422. dev_dbg(trf->dev, "Configure hw - type: %d, param: %d\n", type, param);
  1423. mutex_lock(&trf->lock);
  1424. trf->is_initiator = false;
  1425. if ((trf->state == TRF7970A_ST_PWR_OFF) ||
  1426. (trf->state == TRF7970A_ST_RF_OFF)) {
  1427. ret = trf7970a_switch_rf_on(trf);
  1428. if (ret)
  1429. goto err_unlock;
  1430. }
  1431. switch (type) {
  1432. case NFC_DIGITAL_CONFIG_RF_TECH:
  1433. ret = trf7970a_tg_config_rf_tech(trf, param);
  1434. break;
  1435. case NFC_DIGITAL_CONFIG_FRAMING:
  1436. ret = trf7970a_tg_config_framing(trf, param);
  1437. break;
  1438. default:
  1439. dev_dbg(trf->dev, "Unknown type: %d\n", type);
  1440. ret = -EINVAL;
  1441. }
  1442. err_unlock:
  1443. mutex_unlock(&trf->lock);
  1444. return ret;
  1445. }
  1446. static int _trf7970a_tg_listen(struct nfc_digital_dev *ddev, u16 timeout,
  1447. nfc_digital_cmd_complete_t cb, void *arg,
  1448. bool mode_detect)
  1449. {
  1450. struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
  1451. int ret;
  1452. mutex_lock(&trf->lock);
  1453. if ((trf->state != TRF7970A_ST_IDLE) &&
  1454. (trf->state != TRF7970A_ST_IDLE_RX_BLOCKED)) {
  1455. dev_err(trf->dev, "%s - Bogus state: %d\n", __func__,
  1456. trf->state);
  1457. ret = -EIO;
  1458. goto out_err;
  1459. }
  1460. if (trf->aborting) {
  1461. dev_dbg(trf->dev, "Abort process complete\n");
  1462. trf->aborting = false;
  1463. ret = -ECANCELED;
  1464. goto out_err;
  1465. }
  1466. trf->rx_skb = nfc_alloc_recv_skb(TRF7970A_RX_SKB_ALLOC_SIZE,
  1467. GFP_KERNEL);
  1468. if (!trf->rx_skb) {
  1469. dev_dbg(trf->dev, "Can't alloc rx_skb\n");
  1470. ret = -ENOMEM;
  1471. goto out_err;
  1472. }
  1473. ret = trf7970a_write(trf, TRF7970A_RX_SPECIAL_SETTINGS,
  1474. TRF7970A_RX_SPECIAL_SETTINGS_HBT |
  1475. TRF7970A_RX_SPECIAL_SETTINGS_M848 |
  1476. TRF7970A_RX_SPECIAL_SETTINGS_C424 |
  1477. TRF7970A_RX_SPECIAL_SETTINGS_C212);
  1478. if (ret)
  1479. goto out_err;
  1480. ret = trf7970a_write(trf, TRF7970A_REG_IO_CTRL,
  1481. trf->io_ctrl | TRF7970A_REG_IO_CTRL_VRS(0x1));
  1482. if (ret)
  1483. goto out_err;
  1484. ret = trf7970a_write(trf, TRF7970A_NFC_LOW_FIELD_LEVEL,
  1485. TRF7970A_NFC_LOW_FIELD_LEVEL_RFDET(0x3));
  1486. if (ret)
  1487. goto out_err;
  1488. ret = trf7970a_write(trf, TRF7970A_NFC_TARGET_LEVEL,
  1489. TRF7970A_NFC_TARGET_LEVEL_RFDET(0x7));
  1490. if (ret)
  1491. goto out_err;
  1492. trf->ddev = ddev;
  1493. trf->cb = cb;
  1494. trf->cb_arg = arg;
  1495. trf->timeout = timeout;
  1496. trf->ignore_timeout = false;
  1497. ret = trf7970a_cmd(trf, TRF7970A_CMD_ENABLE_RX);
  1498. if (ret)
  1499. goto out_err;
  1500. trf->state = mode_detect ? TRF7970A_ST_LISTENING_MD :
  1501. TRF7970A_ST_LISTENING;
  1502. schedule_delayed_work(&trf->timeout_work, msecs_to_jiffies(timeout));
  1503. out_err:
  1504. mutex_unlock(&trf->lock);
  1505. return ret;
  1506. }
  1507. static int trf7970a_tg_listen(struct nfc_digital_dev *ddev, u16 timeout,
  1508. nfc_digital_cmd_complete_t cb, void *arg)
  1509. {
  1510. const struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
  1511. dev_dbg(trf->dev, "Listen - state: %d, timeout: %d ms\n",
  1512. trf->state, timeout);
  1513. return _trf7970a_tg_listen(ddev, timeout, cb, arg, false);
  1514. }
  1515. static int trf7970a_tg_listen_md(struct nfc_digital_dev *ddev,
  1516. u16 timeout, nfc_digital_cmd_complete_t cb,
  1517. void *arg)
  1518. {
  1519. const struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
  1520. int ret;
  1521. dev_dbg(trf->dev, "Listen MD - state: %d, timeout: %d ms\n",
  1522. trf->state, timeout);
  1523. ret = trf7970a_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_RF_TECH,
  1524. NFC_DIGITAL_RF_TECH_106A);
  1525. if (ret)
  1526. return ret;
  1527. ret = trf7970a_tg_configure_hw(ddev, NFC_DIGITAL_CONFIG_FRAMING,
  1528. NFC_DIGITAL_FRAMING_NFCA_NFC_DEP);
  1529. if (ret)
  1530. return ret;
  1531. return _trf7970a_tg_listen(ddev, timeout, cb, arg, true);
  1532. }
  1533. static int trf7970a_tg_get_rf_tech(struct nfc_digital_dev *ddev, u8 *rf_tech)
  1534. {
  1535. const struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
  1536. dev_dbg(trf->dev, "Get RF Tech - state: %d, rf_tech: %d\n",
  1537. trf->state, trf->md_rf_tech);
  1538. *rf_tech = trf->md_rf_tech;
  1539. return 0;
  1540. }
  1541. static void trf7970a_abort_cmd(struct nfc_digital_dev *ddev)
  1542. {
  1543. struct trf7970a *trf = nfc_digital_get_drvdata(ddev);
  1544. dev_dbg(trf->dev, "Abort process initiated\n");
  1545. mutex_lock(&trf->lock);
  1546. switch (trf->state) {
  1547. case TRF7970A_ST_WAIT_FOR_TX_FIFO:
  1548. case TRF7970A_ST_WAIT_FOR_RX_DATA:
  1549. case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
  1550. case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
  1551. trf->aborting = true;
  1552. break;
  1553. case TRF7970A_ST_LISTENING:
  1554. trf->ignore_timeout = !cancel_delayed_work(&trf->timeout_work);
  1555. trf7970a_send_err_upstream(trf, -ECANCELED);
  1556. dev_dbg(trf->dev, "Abort process complete\n");
  1557. break;
  1558. default:
  1559. break;
  1560. }
  1561. mutex_unlock(&trf->lock);
  1562. }
  1563. static const struct nfc_digital_ops trf7970a_nfc_ops = {
  1564. .in_configure_hw = trf7970a_in_configure_hw,
  1565. .in_send_cmd = trf7970a_send_cmd,
  1566. .tg_configure_hw = trf7970a_tg_configure_hw,
  1567. .tg_send_cmd = trf7970a_send_cmd,
  1568. .tg_listen = trf7970a_tg_listen,
  1569. .tg_listen_md = trf7970a_tg_listen_md,
  1570. .tg_get_rf_tech = trf7970a_tg_get_rf_tech,
  1571. .switch_rf = trf7970a_switch_rf,
  1572. .abort_cmd = trf7970a_abort_cmd,
  1573. };
  1574. static int trf7970a_power_up(struct trf7970a *trf)
  1575. {
  1576. int ret;
  1577. dev_dbg(trf->dev, "Powering up - state: %d\n", trf->state);
  1578. if (trf->state != TRF7970A_ST_PWR_OFF)
  1579. return 0;
  1580. ret = regulator_enable(trf->regulator);
  1581. if (ret) {
  1582. dev_err(trf->dev, "%s - Can't enable VIN: %d\n", __func__, ret);
  1583. return ret;
  1584. }
  1585. usleep_range(5000, 6000);
  1586. if (trf->en2_gpiod &&
  1587. !(trf->quirks & TRF7970A_QUIRK_EN2_MUST_STAY_LOW)) {
  1588. gpiod_set_value_cansleep(trf->en2_gpiod, 1);
  1589. usleep_range(1000, 2000);
  1590. }
  1591. gpiod_set_value_cansleep(trf->en_gpiod, 1);
  1592. usleep_range(20000, 21000);
  1593. trf->state = TRF7970A_ST_RF_OFF;
  1594. return 0;
  1595. }
  1596. static int trf7970a_power_down(struct trf7970a *trf)
  1597. {
  1598. int ret;
  1599. dev_dbg(trf->dev, "Powering down - state: %d\n", trf->state);
  1600. if (trf->state == TRF7970A_ST_PWR_OFF)
  1601. return 0;
  1602. if (trf->state != TRF7970A_ST_RF_OFF) {
  1603. dev_dbg(trf->dev, "Can't power down - not RF_OFF state (%d)\n",
  1604. trf->state);
  1605. return -EBUSY;
  1606. }
  1607. gpiod_set_value_cansleep(trf->en_gpiod, 0);
  1608. if (trf->en2_gpiod && !(trf->quirks & TRF7970A_QUIRK_EN2_MUST_STAY_LOW))
  1609. gpiod_set_value_cansleep(trf->en2_gpiod, 0);
  1610. ret = regulator_disable(trf->regulator);
  1611. if (ret)
  1612. dev_err(trf->dev, "%s - Can't disable VIN: %d\n", __func__,
  1613. ret);
  1614. trf->state = TRF7970A_ST_PWR_OFF;
  1615. return ret;
  1616. }
  1617. static int trf7970a_startup(struct trf7970a *trf)
  1618. {
  1619. int ret;
  1620. ret = trf7970a_power_up(trf);
  1621. if (ret)
  1622. return ret;
  1623. pm_runtime_set_active(trf->dev);
  1624. pm_runtime_enable(trf->dev);
  1625. pm_runtime_mark_last_busy(trf->dev);
  1626. return 0;
  1627. }
  1628. static void trf7970a_shutdown(struct trf7970a *trf)
  1629. {
  1630. switch (trf->state) {
  1631. case TRF7970A_ST_WAIT_FOR_TX_FIFO:
  1632. case TRF7970A_ST_WAIT_FOR_RX_DATA:
  1633. case TRF7970A_ST_WAIT_FOR_RX_DATA_CONT:
  1634. case TRF7970A_ST_WAIT_TO_ISSUE_EOF:
  1635. case TRF7970A_ST_LISTENING:
  1636. trf7970a_send_err_upstream(trf, -ECANCELED);
  1637. fallthrough;
  1638. case TRF7970A_ST_IDLE:
  1639. case TRF7970A_ST_IDLE_RX_BLOCKED:
  1640. trf7970a_switch_rf_off(trf);
  1641. break;
  1642. default:
  1643. break;
  1644. }
  1645. pm_runtime_disable(trf->dev);
  1646. pm_runtime_set_suspended(trf->dev);
  1647. trf7970a_power_down(trf);
  1648. }
  1649. static int trf7970a_get_autosuspend_delay(const struct device_node *np)
  1650. {
  1651. int autosuspend_delay, ret;
  1652. ret = of_property_read_u32(np, "autosuspend-delay", &autosuspend_delay);
  1653. if (ret)
  1654. autosuspend_delay = TRF7970A_AUTOSUSPEND_DELAY;
  1655. return autosuspend_delay;
  1656. }
  1657. static int trf7970a_probe(struct spi_device *spi)
  1658. {
  1659. const struct device_node *np = spi->dev.of_node;
  1660. struct trf7970a *trf;
  1661. int uvolts, autosuspend_delay, ret;
  1662. u32 clk_freq = TRF7970A_13MHZ_CLOCK_FREQUENCY;
  1663. if (!np) {
  1664. dev_err(&spi->dev, "No Device Tree entry\n");
  1665. return -EINVAL;
  1666. }
  1667. trf = devm_kzalloc(&spi->dev, sizeof(*trf), GFP_KERNEL);
  1668. if (!trf)
  1669. return -ENOMEM;
  1670. trf->state = TRF7970A_ST_PWR_OFF;
  1671. trf->dev = &spi->dev;
  1672. trf->spi = spi;
  1673. spi->mode = SPI_MODE_1;
  1674. spi->bits_per_word = 8;
  1675. ret = spi_setup(spi);
  1676. if (ret < 0) {
  1677. dev_err(trf->dev, "Can't set up SPI Communication\n");
  1678. return ret;
  1679. }
  1680. if (of_property_read_bool(np, "irq-status-read-quirk"))
  1681. trf->quirks |= TRF7970A_QUIRK_IRQ_STATUS_READ;
  1682. /* There are two enable pins - only EN must be present in the DT */
  1683. trf->en_gpiod = devm_gpiod_get_index(trf->dev, "ti,enable", 0,
  1684. GPIOD_OUT_LOW);
  1685. if (IS_ERR(trf->en_gpiod)) {
  1686. dev_err(trf->dev, "No EN GPIO property\n");
  1687. return PTR_ERR(trf->en_gpiod);
  1688. }
  1689. trf->en2_gpiod = devm_gpiod_get_index_optional(trf->dev, "ti,enable", 1,
  1690. GPIOD_OUT_LOW);
  1691. if (!trf->en2_gpiod) {
  1692. dev_info(trf->dev, "No EN2 GPIO property\n");
  1693. } else if (IS_ERR(trf->en2_gpiod)) {
  1694. dev_err(trf->dev, "Error getting EN2 GPIO property: %ld\n",
  1695. PTR_ERR(trf->en2_gpiod));
  1696. return PTR_ERR(trf->en2_gpiod);
  1697. } else if (of_property_read_bool(np, "en2-rf-quirk")) {
  1698. trf->quirks |= TRF7970A_QUIRK_EN2_MUST_STAY_LOW;
  1699. }
  1700. of_property_read_u32(np, "clock-frequency", &clk_freq);
  1701. if ((clk_freq != TRF7970A_27MHZ_CLOCK_FREQUENCY) &&
  1702. (clk_freq != TRF7970A_13MHZ_CLOCK_FREQUENCY)) {
  1703. dev_err(trf->dev,
  1704. "clock-frequency (%u Hz) unsupported\n", clk_freq);
  1705. return -EINVAL;
  1706. }
  1707. if (clk_freq == TRF7970A_27MHZ_CLOCK_FREQUENCY) {
  1708. trf->modulator_sys_clk_ctrl = TRF7970A_MODULATOR_27MHZ;
  1709. dev_dbg(trf->dev, "trf7970a configured for 27MHz crystal\n");
  1710. } else {
  1711. trf->modulator_sys_clk_ctrl = 0;
  1712. }
  1713. ret = devm_request_threaded_irq(trf->dev, spi->irq, NULL,
  1714. trf7970a_irq,
  1715. IRQF_TRIGGER_RISING | IRQF_ONESHOT,
  1716. "trf7970a", trf);
  1717. if (ret) {
  1718. dev_err(trf->dev, "Can't request IRQ#%d: %d\n", spi->irq, ret);
  1719. return ret;
  1720. }
  1721. mutex_init(&trf->lock);
  1722. INIT_DELAYED_WORK(&trf->timeout_work, trf7970a_timeout_work_handler);
  1723. trf->regulator = devm_regulator_get(&spi->dev, "vin");
  1724. if (IS_ERR(trf->regulator)) {
  1725. ret = PTR_ERR(trf->regulator);
  1726. dev_err(trf->dev, "Can't get VIN regulator: %d\n", ret);
  1727. goto err_destroy_lock;
  1728. }
  1729. ret = regulator_enable(trf->regulator);
  1730. if (ret) {
  1731. dev_err(trf->dev, "Can't enable VIN: %d\n", ret);
  1732. goto err_destroy_lock;
  1733. }
  1734. uvolts = regulator_get_voltage(trf->regulator);
  1735. if (uvolts > 4000000)
  1736. trf->chip_status_ctrl = TRF7970A_CHIP_STATUS_VRS5_3;
  1737. trf->regulator = devm_regulator_get(&spi->dev, "vdd-io");
  1738. if (IS_ERR(trf->regulator)) {
  1739. ret = PTR_ERR(trf->regulator);
  1740. dev_err(trf->dev, "Can't get VDD_IO regulator: %d\n", ret);
  1741. goto err_destroy_lock;
  1742. }
  1743. ret = regulator_enable(trf->regulator);
  1744. if (ret) {
  1745. dev_err(trf->dev, "Can't enable VDD_IO: %d\n", ret);
  1746. goto err_destroy_lock;
  1747. }
  1748. if (regulator_get_voltage(trf->regulator) == 1800000) {
  1749. trf->io_ctrl = TRF7970A_REG_IO_CTRL_IO_LOW;
  1750. dev_dbg(trf->dev, "trf7970a config vdd_io to 1.8V\n");
  1751. }
  1752. trf->ddev = nfc_digital_allocate_device(&trf7970a_nfc_ops,
  1753. TRF7970A_SUPPORTED_PROTOCOLS,
  1754. NFC_DIGITAL_DRV_CAPS_IN_CRC |
  1755. NFC_DIGITAL_DRV_CAPS_TG_CRC, 0,
  1756. 0);
  1757. if (!trf->ddev) {
  1758. dev_err(trf->dev, "Can't allocate NFC digital device\n");
  1759. ret = -ENOMEM;
  1760. goto err_disable_regulator;
  1761. }
  1762. nfc_digital_set_parent_dev(trf->ddev, trf->dev);
  1763. nfc_digital_set_drvdata(trf->ddev, trf);
  1764. spi_set_drvdata(spi, trf);
  1765. autosuspend_delay = trf7970a_get_autosuspend_delay(np);
  1766. pm_runtime_set_autosuspend_delay(trf->dev, autosuspend_delay);
  1767. pm_runtime_use_autosuspend(trf->dev);
  1768. ret = trf7970a_startup(trf);
  1769. if (ret)
  1770. goto err_free_ddev;
  1771. ret = nfc_digital_register_device(trf->ddev);
  1772. if (ret) {
  1773. dev_err(trf->dev, "Can't register NFC digital device: %d\n",
  1774. ret);
  1775. goto err_shutdown;
  1776. }
  1777. return 0;
  1778. err_shutdown:
  1779. trf7970a_shutdown(trf);
  1780. err_free_ddev:
  1781. nfc_digital_free_device(trf->ddev);
  1782. err_disable_regulator:
  1783. regulator_disable(trf->regulator);
  1784. err_destroy_lock:
  1785. mutex_destroy(&trf->lock);
  1786. return ret;
  1787. }
  1788. static void trf7970a_remove(struct spi_device *spi)
  1789. {
  1790. struct trf7970a *trf = spi_get_drvdata(spi);
  1791. mutex_lock(&trf->lock);
  1792. trf7970a_shutdown(trf);
  1793. mutex_unlock(&trf->lock);
  1794. nfc_digital_unregister_device(trf->ddev);
  1795. nfc_digital_free_device(trf->ddev);
  1796. regulator_disable(trf->regulator);
  1797. mutex_destroy(&trf->lock);
  1798. }
  1799. #ifdef CONFIG_PM_SLEEP
  1800. static int trf7970a_suspend(struct device *dev)
  1801. {
  1802. struct spi_device *spi = to_spi_device(dev);
  1803. struct trf7970a *trf = spi_get_drvdata(spi);
  1804. mutex_lock(&trf->lock);
  1805. trf7970a_shutdown(trf);
  1806. mutex_unlock(&trf->lock);
  1807. return 0;
  1808. }
  1809. static int trf7970a_resume(struct device *dev)
  1810. {
  1811. struct spi_device *spi = to_spi_device(dev);
  1812. struct trf7970a *trf = spi_get_drvdata(spi);
  1813. int ret;
  1814. mutex_lock(&trf->lock);
  1815. ret = trf7970a_startup(trf);
  1816. mutex_unlock(&trf->lock);
  1817. return ret;
  1818. }
  1819. #endif
  1820. #ifdef CONFIG_PM
  1821. static int trf7970a_pm_runtime_suspend(struct device *dev)
  1822. {
  1823. struct spi_device *spi = to_spi_device(dev);
  1824. struct trf7970a *trf = spi_get_drvdata(spi);
  1825. int ret;
  1826. mutex_lock(&trf->lock);
  1827. ret = trf7970a_power_down(trf);
  1828. mutex_unlock(&trf->lock);
  1829. return ret;
  1830. }
  1831. static int trf7970a_pm_runtime_resume(struct device *dev)
  1832. {
  1833. struct spi_device *spi = to_spi_device(dev);
  1834. struct trf7970a *trf = spi_get_drvdata(spi);
  1835. int ret;
  1836. ret = trf7970a_power_up(trf);
  1837. if (!ret)
  1838. pm_runtime_mark_last_busy(dev);
  1839. return ret;
  1840. }
  1841. #endif
  1842. static const struct dev_pm_ops trf7970a_pm_ops = {
  1843. SET_SYSTEM_SLEEP_PM_OPS(trf7970a_suspend, trf7970a_resume)
  1844. SET_RUNTIME_PM_OPS(trf7970a_pm_runtime_suspend,
  1845. trf7970a_pm_runtime_resume, NULL)
  1846. };
  1847. static const struct of_device_id trf7970a_of_match[] = {
  1848. {.compatible = "ti,trf7970a",},
  1849. {},
  1850. };
  1851. MODULE_DEVICE_TABLE(of, trf7970a_of_match);
  1852. static const struct spi_device_id trf7970a_id_table[] = {
  1853. {"trf7970a", 0},
  1854. {}
  1855. };
  1856. MODULE_DEVICE_TABLE(spi, trf7970a_id_table);
  1857. static struct spi_driver trf7970a_spi_driver = {
  1858. .probe = trf7970a_probe,
  1859. .remove = trf7970a_remove,
  1860. .id_table = trf7970a_id_table,
  1861. .driver = {
  1862. .name = "trf7970a",
  1863. .of_match_table = of_match_ptr(trf7970a_of_match),
  1864. .pm = &trf7970a_pm_ops,
  1865. },
  1866. };
  1867. module_spi_driver(trf7970a_spi_driver);
  1868. MODULE_AUTHOR("Mark A. Greer <[email protected]>");
  1869. MODULE_LICENSE("GPL v2");
  1870. MODULE_DESCRIPTION("TI trf7970a RFID/NFC Transceiver Driver");