cadence_master.c 43 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702
  1. // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
  2. // Copyright(c) 2015-17 Intel Corporation.
  3. /*
  4. * Cadence SoundWire Master module
  5. * Used by Master driver
  6. */
  7. #include <linux/delay.h>
  8. #include <linux/device.h>
  9. #include <linux/debugfs.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/io.h>
  12. #include <linux/module.h>
  13. #include <linux/mod_devicetable.h>
  14. #include <linux/pm_runtime.h>
  15. #include <linux/soundwire/sdw_registers.h>
  16. #include <linux/soundwire/sdw.h>
  17. #include <sound/pcm_params.h>
  18. #include <sound/soc.h>
  19. #include <linux/workqueue.h>
  20. #include "bus.h"
  21. #include "cadence_master.h"
  22. static int interrupt_mask;
  23. module_param_named(cnds_mcp_int_mask, interrupt_mask, int, 0444);
  24. MODULE_PARM_DESC(cdns_mcp_int_mask, "Cadence MCP IntMask");
  25. #define CDNS_MCP_CONFIG 0x0
  26. #define CDNS_MCP_CONFIG_MCMD_RETRY GENMASK(27, 24)
  27. #define CDNS_MCP_CONFIG_MPREQ_DELAY GENMASK(20, 16)
  28. #define CDNS_MCP_CONFIG_MMASTER BIT(7)
  29. #define CDNS_MCP_CONFIG_BUS_REL BIT(6)
  30. #define CDNS_MCP_CONFIG_SNIFFER BIT(5)
  31. #define CDNS_MCP_CONFIG_SSPMOD BIT(4)
  32. #define CDNS_MCP_CONFIG_CMD BIT(3)
  33. #define CDNS_MCP_CONFIG_OP GENMASK(2, 0)
  34. #define CDNS_MCP_CONFIG_OP_NORMAL 0
  35. #define CDNS_MCP_CONTROL 0x4
  36. #define CDNS_MCP_CONTROL_RST_DELAY GENMASK(10, 8)
  37. #define CDNS_MCP_CONTROL_CMD_RST BIT(7)
  38. #define CDNS_MCP_CONTROL_SOFT_RST BIT(6)
  39. #define CDNS_MCP_CONTROL_SW_RST BIT(5)
  40. #define CDNS_MCP_CONTROL_HW_RST BIT(4)
  41. #define CDNS_MCP_CONTROL_CLK_PAUSE BIT(3)
  42. #define CDNS_MCP_CONTROL_CLK_STOP_CLR BIT(2)
  43. #define CDNS_MCP_CONTROL_CMD_ACCEPT BIT(1)
  44. #define CDNS_MCP_CONTROL_BLOCK_WAKEUP BIT(0)
  45. #define CDNS_MCP_CMDCTRL 0x8
  46. #define CDNS_MCP_CMDCTRL_INSERT_PARITY_ERR BIT(2)
  47. #define CDNS_MCP_SSPSTAT 0xC
  48. #define CDNS_MCP_FRAME_SHAPE 0x10
  49. #define CDNS_MCP_FRAME_SHAPE_INIT 0x14
  50. #define CDNS_MCP_FRAME_SHAPE_COL_MASK GENMASK(2, 0)
  51. #define CDNS_MCP_FRAME_SHAPE_ROW_MASK GENMASK(7, 3)
  52. #define CDNS_MCP_CONFIG_UPDATE 0x18
  53. #define CDNS_MCP_CONFIG_UPDATE_BIT BIT(0)
  54. #define CDNS_MCP_PHYCTRL 0x1C
  55. #define CDNS_MCP_SSP_CTRL0 0x20
  56. #define CDNS_MCP_SSP_CTRL1 0x28
  57. #define CDNS_MCP_CLK_CTRL0 0x30
  58. #define CDNS_MCP_CLK_CTRL1 0x38
  59. #define CDNS_MCP_CLK_MCLKD_MASK GENMASK(7, 0)
  60. #define CDNS_MCP_STAT 0x40
  61. #define CDNS_MCP_STAT_ACTIVE_BANK BIT(20)
  62. #define CDNS_MCP_STAT_CLK_STOP BIT(16)
  63. #define CDNS_MCP_INTSTAT 0x44
  64. #define CDNS_MCP_INTMASK 0x48
  65. #define CDNS_MCP_INT_IRQ BIT(31)
  66. #define CDNS_MCP_INT_RESERVED1 GENMASK(30, 17)
  67. #define CDNS_MCP_INT_WAKEUP BIT(16)
  68. #define CDNS_MCP_INT_SLAVE_RSVD BIT(15)
  69. #define CDNS_MCP_INT_SLAVE_ALERT BIT(14)
  70. #define CDNS_MCP_INT_SLAVE_ATTACH BIT(13)
  71. #define CDNS_MCP_INT_SLAVE_NATTACH BIT(12)
  72. #define CDNS_MCP_INT_SLAVE_MASK GENMASK(15, 12)
  73. #define CDNS_MCP_INT_DPINT BIT(11)
  74. #define CDNS_MCP_INT_CTRL_CLASH BIT(10)
  75. #define CDNS_MCP_INT_DATA_CLASH BIT(9)
  76. #define CDNS_MCP_INT_PARITY BIT(8)
  77. #define CDNS_MCP_INT_CMD_ERR BIT(7)
  78. #define CDNS_MCP_INT_RESERVED2 GENMASK(6, 4)
  79. #define CDNS_MCP_INT_RX_NE BIT(3)
  80. #define CDNS_MCP_INT_RX_WL BIT(2)
  81. #define CDNS_MCP_INT_TXE BIT(1)
  82. #define CDNS_MCP_INT_TXF BIT(0)
  83. #define CDNS_MCP_INT_RESERVED (CDNS_MCP_INT_RESERVED1 | CDNS_MCP_INT_RESERVED2)
  84. #define CDNS_MCP_INTSET 0x4C
  85. #define CDNS_MCP_SLAVE_STAT 0x50
  86. #define CDNS_MCP_SLAVE_STAT_MASK GENMASK(1, 0)
  87. #define CDNS_MCP_SLAVE_INTSTAT0 0x54
  88. #define CDNS_MCP_SLAVE_INTSTAT1 0x58
  89. #define CDNS_MCP_SLAVE_INTSTAT_NPRESENT BIT(0)
  90. #define CDNS_MCP_SLAVE_INTSTAT_ATTACHED BIT(1)
  91. #define CDNS_MCP_SLAVE_INTSTAT_ALERT BIT(2)
  92. #define CDNS_MCP_SLAVE_INTSTAT_RESERVED BIT(3)
  93. #define CDNS_MCP_SLAVE_STATUS_BITS GENMASK(3, 0)
  94. #define CDNS_MCP_SLAVE_STATUS_NUM 4
  95. #define CDNS_MCP_SLAVE_INTMASK0 0x5C
  96. #define CDNS_MCP_SLAVE_INTMASK1 0x60
  97. #define CDNS_MCP_SLAVE_INTMASK0_MASK GENMASK(31, 0)
  98. #define CDNS_MCP_SLAVE_INTMASK1_MASK GENMASK(15, 0)
  99. #define CDNS_MCP_PORT_INTSTAT 0x64
  100. #define CDNS_MCP_PDI_STAT 0x6C
  101. #define CDNS_MCP_FIFOLEVEL 0x78
  102. #define CDNS_MCP_FIFOSTAT 0x7C
  103. #define CDNS_MCP_RX_FIFO_AVAIL GENMASK(5, 0)
  104. #define CDNS_MCP_CMD_BASE 0x80
  105. #define CDNS_MCP_RESP_BASE 0x80
  106. #define CDNS_MCP_CMD_LEN 0x20
  107. #define CDNS_MCP_CMD_WORD_LEN 0x4
  108. #define CDNS_MCP_CMD_SSP_TAG BIT(31)
  109. #define CDNS_MCP_CMD_COMMAND GENMASK(30, 28)
  110. #define CDNS_MCP_CMD_DEV_ADDR GENMASK(27, 24)
  111. #define CDNS_MCP_CMD_REG_ADDR GENMASK(23, 8)
  112. #define CDNS_MCP_CMD_REG_DATA GENMASK(7, 0)
  113. #define CDNS_MCP_CMD_READ 2
  114. #define CDNS_MCP_CMD_WRITE 3
  115. #define CDNS_MCP_RESP_RDATA GENMASK(15, 8)
  116. #define CDNS_MCP_RESP_ACK BIT(0)
  117. #define CDNS_MCP_RESP_NACK BIT(1)
  118. #define CDNS_DP_SIZE 128
  119. #define CDNS_DPN_B0_CONFIG(n) (0x100 + CDNS_DP_SIZE * (n))
  120. #define CDNS_DPN_B0_CH_EN(n) (0x104 + CDNS_DP_SIZE * (n))
  121. #define CDNS_DPN_B0_SAMPLE_CTRL(n) (0x108 + CDNS_DP_SIZE * (n))
  122. #define CDNS_DPN_B0_OFFSET_CTRL(n) (0x10C + CDNS_DP_SIZE * (n))
  123. #define CDNS_DPN_B0_HCTRL(n) (0x110 + CDNS_DP_SIZE * (n))
  124. #define CDNS_DPN_B0_ASYNC_CTRL(n) (0x114 + CDNS_DP_SIZE * (n))
  125. #define CDNS_DPN_B1_CONFIG(n) (0x118 + CDNS_DP_SIZE * (n))
  126. #define CDNS_DPN_B1_CH_EN(n) (0x11C + CDNS_DP_SIZE * (n))
  127. #define CDNS_DPN_B1_SAMPLE_CTRL(n) (0x120 + CDNS_DP_SIZE * (n))
  128. #define CDNS_DPN_B1_OFFSET_CTRL(n) (0x124 + CDNS_DP_SIZE * (n))
  129. #define CDNS_DPN_B1_HCTRL(n) (0x128 + CDNS_DP_SIZE * (n))
  130. #define CDNS_DPN_B1_ASYNC_CTRL(n) (0x12C + CDNS_DP_SIZE * (n))
  131. #define CDNS_DPN_CONFIG_BPM BIT(18)
  132. #define CDNS_DPN_CONFIG_BGC GENMASK(17, 16)
  133. #define CDNS_DPN_CONFIG_WL GENMASK(12, 8)
  134. #define CDNS_DPN_CONFIG_PORT_DAT GENMASK(3, 2)
  135. #define CDNS_DPN_CONFIG_PORT_FLOW GENMASK(1, 0)
  136. #define CDNS_DPN_SAMPLE_CTRL_SI GENMASK(15, 0)
  137. #define CDNS_DPN_OFFSET_CTRL_1 GENMASK(7, 0)
  138. #define CDNS_DPN_OFFSET_CTRL_2 GENMASK(15, 8)
  139. #define CDNS_DPN_HCTRL_HSTOP GENMASK(3, 0)
  140. #define CDNS_DPN_HCTRL_HSTART GENMASK(7, 4)
  141. #define CDNS_DPN_HCTRL_LCTRL GENMASK(10, 8)
  142. #define CDNS_PORTCTRL 0x130
  143. #define CDNS_PORTCTRL_TEST_FAILED BIT(1)
  144. #define CDNS_PORTCTRL_DIRN BIT(7)
  145. #define CDNS_PORTCTRL_BANK_INVERT BIT(8)
  146. #define CDNS_PORT_OFFSET 0x80
  147. #define CDNS_PDI_CONFIG(n) (0x1100 + (n) * 16)
  148. #define CDNS_PDI_CONFIG_SOFT_RESET BIT(24)
  149. #define CDNS_PDI_CONFIG_CHANNEL GENMASK(15, 8)
  150. #define CDNS_PDI_CONFIG_PORT GENMASK(4, 0)
  151. /* Driver defaults */
  152. #define CDNS_TX_TIMEOUT 2000
  153. #define CDNS_SCP_RX_FIFOLEVEL 0x2
  154. /*
  155. * register accessor helpers
  156. */
  157. static inline u32 cdns_readl(struct sdw_cdns *cdns, int offset)
  158. {
  159. return readl(cdns->registers + offset);
  160. }
  161. static inline void cdns_writel(struct sdw_cdns *cdns, int offset, u32 value)
  162. {
  163. writel(value, cdns->registers + offset);
  164. }
  165. static inline void cdns_updatel(struct sdw_cdns *cdns,
  166. int offset, u32 mask, u32 val)
  167. {
  168. u32 tmp;
  169. tmp = cdns_readl(cdns, offset);
  170. tmp = (tmp & ~mask) | val;
  171. cdns_writel(cdns, offset, tmp);
  172. }
  173. static int cdns_set_wait(struct sdw_cdns *cdns, int offset, u32 mask, u32 value)
  174. {
  175. int timeout = 10;
  176. u32 reg_read;
  177. /* Wait for bit to be set */
  178. do {
  179. reg_read = readl(cdns->registers + offset);
  180. if ((reg_read & mask) == value)
  181. return 0;
  182. timeout--;
  183. usleep_range(50, 100);
  184. } while (timeout != 0);
  185. return -ETIMEDOUT;
  186. }
  187. static int cdns_clear_bit(struct sdw_cdns *cdns, int offset, u32 value)
  188. {
  189. writel(value, cdns->registers + offset);
  190. /* Wait for bit to be self cleared */
  191. return cdns_set_wait(cdns, offset, value, 0);
  192. }
  193. /*
  194. * all changes to the MCP_CONFIG, MCP_CONTROL, MCP_CMDCTRL and MCP_PHYCTRL
  195. * need to be confirmed with a write to MCP_CONFIG_UPDATE
  196. */
  197. static int cdns_config_update(struct sdw_cdns *cdns)
  198. {
  199. int ret;
  200. if (sdw_cdns_is_clock_stop(cdns)) {
  201. dev_err(cdns->dev, "Cannot program MCP_CONFIG_UPDATE in ClockStopMode\n");
  202. return -EINVAL;
  203. }
  204. ret = cdns_clear_bit(cdns, CDNS_MCP_CONFIG_UPDATE,
  205. CDNS_MCP_CONFIG_UPDATE_BIT);
  206. if (ret < 0)
  207. dev_err(cdns->dev, "Config update timedout\n");
  208. return ret;
  209. }
  210. /*
  211. * debugfs
  212. */
  213. #ifdef CONFIG_DEBUG_FS
  214. #define RD_BUF (2 * PAGE_SIZE)
  215. static ssize_t cdns_sprintf(struct sdw_cdns *cdns,
  216. char *buf, size_t pos, unsigned int reg)
  217. {
  218. return scnprintf(buf + pos, RD_BUF - pos,
  219. "%4x\t%8x\n", reg, cdns_readl(cdns, reg));
  220. }
  221. static int cdns_reg_show(struct seq_file *s, void *data)
  222. {
  223. struct sdw_cdns *cdns = s->private;
  224. char *buf;
  225. ssize_t ret;
  226. int num_ports;
  227. int i, j;
  228. buf = kzalloc(RD_BUF, GFP_KERNEL);
  229. if (!buf)
  230. return -ENOMEM;
  231. ret = scnprintf(buf, RD_BUF, "Register Value\n");
  232. ret += scnprintf(buf + ret, RD_BUF - ret, "\nMCP Registers\n");
  233. /* 8 MCP registers */
  234. for (i = CDNS_MCP_CONFIG; i <= CDNS_MCP_PHYCTRL; i += sizeof(u32))
  235. ret += cdns_sprintf(cdns, buf, ret, i);
  236. ret += scnprintf(buf + ret, RD_BUF - ret,
  237. "\nStatus & Intr Registers\n");
  238. /* 13 Status & Intr registers (offsets 0x70 and 0x74 not defined) */
  239. for (i = CDNS_MCP_STAT; i <= CDNS_MCP_FIFOSTAT; i += sizeof(u32))
  240. ret += cdns_sprintf(cdns, buf, ret, i);
  241. ret += scnprintf(buf + ret, RD_BUF - ret,
  242. "\nSSP & Clk ctrl Registers\n");
  243. ret += cdns_sprintf(cdns, buf, ret, CDNS_MCP_SSP_CTRL0);
  244. ret += cdns_sprintf(cdns, buf, ret, CDNS_MCP_SSP_CTRL1);
  245. ret += cdns_sprintf(cdns, buf, ret, CDNS_MCP_CLK_CTRL0);
  246. ret += cdns_sprintf(cdns, buf, ret, CDNS_MCP_CLK_CTRL1);
  247. ret += scnprintf(buf + ret, RD_BUF - ret,
  248. "\nDPn B0 Registers\n");
  249. num_ports = cdns->num_ports;
  250. for (i = 0; i < num_ports; i++) {
  251. ret += scnprintf(buf + ret, RD_BUF - ret,
  252. "\nDP-%d\n", i);
  253. for (j = CDNS_DPN_B0_CONFIG(i);
  254. j < CDNS_DPN_B0_ASYNC_CTRL(i); j += sizeof(u32))
  255. ret += cdns_sprintf(cdns, buf, ret, j);
  256. }
  257. ret += scnprintf(buf + ret, RD_BUF - ret,
  258. "\nDPn B1 Registers\n");
  259. for (i = 0; i < num_ports; i++) {
  260. ret += scnprintf(buf + ret, RD_BUF - ret,
  261. "\nDP-%d\n", i);
  262. for (j = CDNS_DPN_B1_CONFIG(i);
  263. j < CDNS_DPN_B1_ASYNC_CTRL(i); j += sizeof(u32))
  264. ret += cdns_sprintf(cdns, buf, ret, j);
  265. }
  266. ret += scnprintf(buf + ret, RD_BUF - ret,
  267. "\nDPn Control Registers\n");
  268. for (i = 0; i < num_ports; i++)
  269. ret += cdns_sprintf(cdns, buf, ret,
  270. CDNS_PORTCTRL + i * CDNS_PORT_OFFSET);
  271. ret += scnprintf(buf + ret, RD_BUF - ret,
  272. "\nPDIn Config Registers\n");
  273. /* number of PDI and ports is interchangeable */
  274. for (i = 0; i < num_ports; i++)
  275. ret += cdns_sprintf(cdns, buf, ret, CDNS_PDI_CONFIG(i));
  276. seq_printf(s, "%s", buf);
  277. kfree(buf);
  278. return 0;
  279. }
  280. DEFINE_SHOW_ATTRIBUTE(cdns_reg);
  281. static int cdns_hw_reset(void *data, u64 value)
  282. {
  283. struct sdw_cdns *cdns = data;
  284. int ret;
  285. if (value != 1)
  286. return -EINVAL;
  287. /* Userspace changed the hardware state behind the kernel's back */
  288. add_taint(TAINT_USER, LOCKDEP_STILL_OK);
  289. ret = sdw_cdns_exit_reset(cdns);
  290. dev_dbg(cdns->dev, "link hw_reset done: %d\n", ret);
  291. return ret;
  292. }
  293. DEFINE_DEBUGFS_ATTRIBUTE(cdns_hw_reset_fops, NULL, cdns_hw_reset, "%llu\n");
  294. static int cdns_parity_error_injection(void *data, u64 value)
  295. {
  296. struct sdw_cdns *cdns = data;
  297. struct sdw_bus *bus;
  298. int ret;
  299. if (value != 1)
  300. return -EINVAL;
  301. bus = &cdns->bus;
  302. /*
  303. * Resume Master device. If this results in a bus reset, the
  304. * Slave devices will re-attach and be re-enumerated.
  305. */
  306. ret = pm_runtime_get_sync(bus->dev);
  307. if (ret < 0 && ret != -EACCES) {
  308. dev_err_ratelimited(cdns->dev,
  309. "pm_runtime_get_sync failed in %s, ret %d\n",
  310. __func__, ret);
  311. pm_runtime_put_noidle(bus->dev);
  312. return ret;
  313. }
  314. /*
  315. * wait long enough for Slave(s) to be in steady state. This
  316. * does not need to be super precise.
  317. */
  318. msleep(200);
  319. /*
  320. * Take the bus lock here to make sure that any bus transactions
  321. * will be queued while we inject a parity error on a dummy read
  322. */
  323. mutex_lock(&bus->bus_lock);
  324. /* program hardware to inject parity error */
  325. cdns_updatel(cdns, CDNS_MCP_CMDCTRL,
  326. CDNS_MCP_CMDCTRL_INSERT_PARITY_ERR,
  327. CDNS_MCP_CMDCTRL_INSERT_PARITY_ERR);
  328. /* commit changes */
  329. cdns_updatel(cdns, CDNS_MCP_CONFIG_UPDATE,
  330. CDNS_MCP_CONFIG_UPDATE_BIT,
  331. CDNS_MCP_CONFIG_UPDATE_BIT);
  332. /* do a broadcast dummy read to avoid bus clashes */
  333. ret = sdw_bread_no_pm_unlocked(&cdns->bus, 0xf, SDW_SCP_DEVID_0);
  334. dev_info(cdns->dev, "parity error injection, read: %d\n", ret);
  335. /* program hardware to disable parity error */
  336. cdns_updatel(cdns, CDNS_MCP_CMDCTRL,
  337. CDNS_MCP_CMDCTRL_INSERT_PARITY_ERR,
  338. 0);
  339. /* commit changes */
  340. cdns_updatel(cdns, CDNS_MCP_CONFIG_UPDATE,
  341. CDNS_MCP_CONFIG_UPDATE_BIT,
  342. CDNS_MCP_CONFIG_UPDATE_BIT);
  343. /* Continue bus operation with parity error injection disabled */
  344. mutex_unlock(&bus->bus_lock);
  345. /* Userspace changed the hardware state behind the kernel's back */
  346. add_taint(TAINT_USER, LOCKDEP_STILL_OK);
  347. /*
  348. * allow Master device to enter pm_runtime suspend. This may
  349. * also result in Slave devices suspending.
  350. */
  351. pm_runtime_mark_last_busy(bus->dev);
  352. pm_runtime_put_autosuspend(bus->dev);
  353. return 0;
  354. }
  355. DEFINE_DEBUGFS_ATTRIBUTE(cdns_parity_error_fops, NULL,
  356. cdns_parity_error_injection, "%llu\n");
  357. /**
  358. * sdw_cdns_debugfs_init() - Cadence debugfs init
  359. * @cdns: Cadence instance
  360. * @root: debugfs root
  361. */
  362. void sdw_cdns_debugfs_init(struct sdw_cdns *cdns, struct dentry *root)
  363. {
  364. debugfs_create_file("cdns-registers", 0400, root, cdns, &cdns_reg_fops);
  365. debugfs_create_file("cdns-hw-reset", 0200, root, cdns,
  366. &cdns_hw_reset_fops);
  367. debugfs_create_file("cdns-parity-error-injection", 0200, root, cdns,
  368. &cdns_parity_error_fops);
  369. }
  370. EXPORT_SYMBOL_GPL(sdw_cdns_debugfs_init);
  371. #endif /* CONFIG_DEBUG_FS */
  372. /*
  373. * IO Calls
  374. */
  375. static enum sdw_command_response
  376. cdns_fill_msg_resp(struct sdw_cdns *cdns,
  377. struct sdw_msg *msg, int count, int offset)
  378. {
  379. int nack = 0, no_ack = 0;
  380. int i;
  381. /* check message response */
  382. for (i = 0; i < count; i++) {
  383. if (!(cdns->response_buf[i] & CDNS_MCP_RESP_ACK)) {
  384. no_ack = 1;
  385. dev_dbg_ratelimited(cdns->dev, "Msg Ack not received\n");
  386. }
  387. if (cdns->response_buf[i] & CDNS_MCP_RESP_NACK) {
  388. nack = 1;
  389. dev_err_ratelimited(cdns->dev, "Msg NACK received\n");
  390. }
  391. }
  392. if (nack) {
  393. dev_err_ratelimited(cdns->dev, "Msg NACKed for Slave %d\n", msg->dev_num);
  394. return SDW_CMD_FAIL;
  395. }
  396. if (no_ack) {
  397. dev_dbg_ratelimited(cdns->dev, "Msg ignored for Slave %d\n", msg->dev_num);
  398. return SDW_CMD_IGNORED;
  399. }
  400. /* fill response */
  401. for (i = 0; i < count; i++)
  402. msg->buf[i + offset] = FIELD_GET(CDNS_MCP_RESP_RDATA, cdns->response_buf[i]);
  403. return SDW_CMD_OK;
  404. }
  405. static enum sdw_command_response
  406. _cdns_xfer_msg(struct sdw_cdns *cdns, struct sdw_msg *msg, int cmd,
  407. int offset, int count, bool defer)
  408. {
  409. unsigned long time;
  410. u32 base, i, data;
  411. u16 addr;
  412. /* Program the watermark level for RX FIFO */
  413. if (cdns->msg_count != count) {
  414. cdns_writel(cdns, CDNS_MCP_FIFOLEVEL, count);
  415. cdns->msg_count = count;
  416. }
  417. base = CDNS_MCP_CMD_BASE;
  418. addr = msg->addr;
  419. for (i = 0; i < count; i++) {
  420. data = FIELD_PREP(CDNS_MCP_CMD_DEV_ADDR, msg->dev_num);
  421. data |= FIELD_PREP(CDNS_MCP_CMD_COMMAND, cmd);
  422. data |= FIELD_PREP(CDNS_MCP_CMD_REG_ADDR, addr);
  423. addr++;
  424. if (msg->flags == SDW_MSG_FLAG_WRITE)
  425. data |= msg->buf[i + offset];
  426. data |= FIELD_PREP(CDNS_MCP_CMD_SSP_TAG, msg->ssp_sync);
  427. cdns_writel(cdns, base, data);
  428. base += CDNS_MCP_CMD_WORD_LEN;
  429. }
  430. if (defer)
  431. return SDW_CMD_OK;
  432. /* wait for timeout or response */
  433. time = wait_for_completion_timeout(&cdns->tx_complete,
  434. msecs_to_jiffies(CDNS_TX_TIMEOUT));
  435. if (!time) {
  436. dev_err(cdns->dev, "IO transfer timed out, cmd %d device %d addr %x len %d\n",
  437. cmd, msg->dev_num, msg->addr, msg->len);
  438. msg->len = 0;
  439. return SDW_CMD_TIMEOUT;
  440. }
  441. return cdns_fill_msg_resp(cdns, msg, count, offset);
  442. }
  443. static enum sdw_command_response
  444. cdns_program_scp_addr(struct sdw_cdns *cdns, struct sdw_msg *msg)
  445. {
  446. int nack = 0, no_ack = 0;
  447. unsigned long time;
  448. u32 data[2], base;
  449. int i;
  450. /* Program the watermark level for RX FIFO */
  451. if (cdns->msg_count != CDNS_SCP_RX_FIFOLEVEL) {
  452. cdns_writel(cdns, CDNS_MCP_FIFOLEVEL, CDNS_SCP_RX_FIFOLEVEL);
  453. cdns->msg_count = CDNS_SCP_RX_FIFOLEVEL;
  454. }
  455. data[0] = FIELD_PREP(CDNS_MCP_CMD_DEV_ADDR, msg->dev_num);
  456. data[0] |= FIELD_PREP(CDNS_MCP_CMD_COMMAND, 0x3);
  457. data[1] = data[0];
  458. data[0] |= FIELD_PREP(CDNS_MCP_CMD_REG_ADDR, SDW_SCP_ADDRPAGE1);
  459. data[1] |= FIELD_PREP(CDNS_MCP_CMD_REG_ADDR, SDW_SCP_ADDRPAGE2);
  460. data[0] |= msg->addr_page1;
  461. data[1] |= msg->addr_page2;
  462. base = CDNS_MCP_CMD_BASE;
  463. cdns_writel(cdns, base, data[0]);
  464. base += CDNS_MCP_CMD_WORD_LEN;
  465. cdns_writel(cdns, base, data[1]);
  466. time = wait_for_completion_timeout(&cdns->tx_complete,
  467. msecs_to_jiffies(CDNS_TX_TIMEOUT));
  468. if (!time) {
  469. dev_err(cdns->dev, "SCP Msg trf timed out\n");
  470. msg->len = 0;
  471. return SDW_CMD_TIMEOUT;
  472. }
  473. /* check response the writes */
  474. for (i = 0; i < 2; i++) {
  475. if (!(cdns->response_buf[i] & CDNS_MCP_RESP_ACK)) {
  476. no_ack = 1;
  477. dev_err(cdns->dev, "Program SCP Ack not received\n");
  478. if (cdns->response_buf[i] & CDNS_MCP_RESP_NACK) {
  479. nack = 1;
  480. dev_err(cdns->dev, "Program SCP NACK received\n");
  481. }
  482. }
  483. }
  484. /* For NACK, NO ack, don't return err if we are in Broadcast mode */
  485. if (nack) {
  486. dev_err_ratelimited(cdns->dev,
  487. "SCP_addrpage NACKed for Slave %d\n", msg->dev_num);
  488. return SDW_CMD_FAIL;
  489. }
  490. if (no_ack) {
  491. dev_dbg_ratelimited(cdns->dev,
  492. "SCP_addrpage ignored for Slave %d\n", msg->dev_num);
  493. return SDW_CMD_IGNORED;
  494. }
  495. return SDW_CMD_OK;
  496. }
  497. static int cdns_prep_msg(struct sdw_cdns *cdns, struct sdw_msg *msg, int *cmd)
  498. {
  499. int ret;
  500. if (msg->page) {
  501. ret = cdns_program_scp_addr(cdns, msg);
  502. if (ret) {
  503. msg->len = 0;
  504. return ret;
  505. }
  506. }
  507. switch (msg->flags) {
  508. case SDW_MSG_FLAG_READ:
  509. *cmd = CDNS_MCP_CMD_READ;
  510. break;
  511. case SDW_MSG_FLAG_WRITE:
  512. *cmd = CDNS_MCP_CMD_WRITE;
  513. break;
  514. default:
  515. dev_err(cdns->dev, "Invalid msg cmd: %d\n", msg->flags);
  516. return -EINVAL;
  517. }
  518. return 0;
  519. }
  520. enum sdw_command_response
  521. cdns_xfer_msg(struct sdw_bus *bus, struct sdw_msg *msg)
  522. {
  523. struct sdw_cdns *cdns = bus_to_cdns(bus);
  524. int cmd = 0, ret, i;
  525. ret = cdns_prep_msg(cdns, msg, &cmd);
  526. if (ret)
  527. return SDW_CMD_FAIL_OTHER;
  528. for (i = 0; i < msg->len / CDNS_MCP_CMD_LEN; i++) {
  529. ret = _cdns_xfer_msg(cdns, msg, cmd, i * CDNS_MCP_CMD_LEN,
  530. CDNS_MCP_CMD_LEN, false);
  531. if (ret < 0)
  532. goto exit;
  533. }
  534. if (!(msg->len % CDNS_MCP_CMD_LEN))
  535. goto exit;
  536. ret = _cdns_xfer_msg(cdns, msg, cmd, i * CDNS_MCP_CMD_LEN,
  537. msg->len % CDNS_MCP_CMD_LEN, false);
  538. exit:
  539. return ret;
  540. }
  541. EXPORT_SYMBOL(cdns_xfer_msg);
  542. enum sdw_command_response
  543. cdns_xfer_msg_defer(struct sdw_bus *bus,
  544. struct sdw_msg *msg, struct sdw_defer *defer)
  545. {
  546. struct sdw_cdns *cdns = bus_to_cdns(bus);
  547. int cmd = 0, ret;
  548. /* for defer only 1 message is supported */
  549. if (msg->len > 1)
  550. return -ENOTSUPP;
  551. ret = cdns_prep_msg(cdns, msg, &cmd);
  552. if (ret)
  553. return SDW_CMD_FAIL_OTHER;
  554. cdns->defer = defer;
  555. cdns->defer->length = msg->len;
  556. return _cdns_xfer_msg(cdns, msg, cmd, 0, msg->len, true);
  557. }
  558. EXPORT_SYMBOL(cdns_xfer_msg_defer);
  559. enum sdw_command_response
  560. cdns_reset_page_addr(struct sdw_bus *bus, unsigned int dev_num)
  561. {
  562. struct sdw_cdns *cdns = bus_to_cdns(bus);
  563. struct sdw_msg msg;
  564. /* Create dummy message with valid device number */
  565. memset(&msg, 0, sizeof(msg));
  566. msg.dev_num = dev_num;
  567. return cdns_program_scp_addr(cdns, &msg);
  568. }
  569. EXPORT_SYMBOL(cdns_reset_page_addr);
  570. /*
  571. * IRQ handling
  572. */
  573. static void cdns_read_response(struct sdw_cdns *cdns)
  574. {
  575. u32 num_resp, cmd_base;
  576. int i;
  577. num_resp = cdns_readl(cdns, CDNS_MCP_FIFOSTAT);
  578. num_resp &= CDNS_MCP_RX_FIFO_AVAIL;
  579. cmd_base = CDNS_MCP_CMD_BASE;
  580. for (i = 0; i < num_resp; i++) {
  581. cdns->response_buf[i] = cdns_readl(cdns, cmd_base);
  582. cmd_base += CDNS_MCP_CMD_WORD_LEN;
  583. }
  584. }
  585. static int cdns_update_slave_status(struct sdw_cdns *cdns,
  586. u32 slave0, u32 slave1)
  587. {
  588. enum sdw_slave_status status[SDW_MAX_DEVICES + 1];
  589. bool is_slave = false;
  590. u64 slave;
  591. u32 mask;
  592. int i, set_status;
  593. /* combine the two status */
  594. slave = ((u64)slave1 << 32) | slave0;
  595. memset(status, 0, sizeof(status));
  596. for (i = 0; i <= SDW_MAX_DEVICES; i++) {
  597. mask = (slave >> (i * CDNS_MCP_SLAVE_STATUS_NUM)) &
  598. CDNS_MCP_SLAVE_STATUS_BITS;
  599. if (!mask)
  600. continue;
  601. is_slave = true;
  602. set_status = 0;
  603. if (mask & CDNS_MCP_SLAVE_INTSTAT_RESERVED) {
  604. status[i] = SDW_SLAVE_RESERVED;
  605. set_status++;
  606. }
  607. if (mask & CDNS_MCP_SLAVE_INTSTAT_ATTACHED) {
  608. status[i] = SDW_SLAVE_ATTACHED;
  609. set_status++;
  610. }
  611. if (mask & CDNS_MCP_SLAVE_INTSTAT_ALERT) {
  612. status[i] = SDW_SLAVE_ALERT;
  613. set_status++;
  614. }
  615. if (mask & CDNS_MCP_SLAVE_INTSTAT_NPRESENT) {
  616. status[i] = SDW_SLAVE_UNATTACHED;
  617. set_status++;
  618. }
  619. /* first check if Slave reported multiple status */
  620. if (set_status > 1) {
  621. u32 val;
  622. dev_warn_ratelimited(cdns->dev,
  623. "Slave %d reported multiple Status: %d\n",
  624. i, mask);
  625. /* check latest status extracted from PING commands */
  626. val = cdns_readl(cdns, CDNS_MCP_SLAVE_STAT);
  627. val >>= (i * 2);
  628. switch (val & 0x3) {
  629. case 0:
  630. status[i] = SDW_SLAVE_UNATTACHED;
  631. break;
  632. case 1:
  633. status[i] = SDW_SLAVE_ATTACHED;
  634. break;
  635. case 2:
  636. status[i] = SDW_SLAVE_ALERT;
  637. break;
  638. case 3:
  639. default:
  640. status[i] = SDW_SLAVE_RESERVED;
  641. break;
  642. }
  643. dev_warn_ratelimited(cdns->dev,
  644. "Slave %d status updated to %d\n",
  645. i, status[i]);
  646. }
  647. }
  648. if (is_slave)
  649. return sdw_handle_slave_status(&cdns->bus, status);
  650. return 0;
  651. }
  652. /**
  653. * sdw_cdns_irq() - Cadence interrupt handler
  654. * @irq: irq number
  655. * @dev_id: irq context
  656. */
  657. irqreturn_t sdw_cdns_irq(int irq, void *dev_id)
  658. {
  659. struct sdw_cdns *cdns = dev_id;
  660. u32 int_status;
  661. int ret = IRQ_HANDLED;
  662. /* Check if the link is up */
  663. if (!cdns->link_up)
  664. return IRQ_NONE;
  665. int_status = cdns_readl(cdns, CDNS_MCP_INTSTAT);
  666. /* check for reserved values read as zero */
  667. if (int_status & CDNS_MCP_INT_RESERVED)
  668. return IRQ_NONE;
  669. if (!(int_status & CDNS_MCP_INT_IRQ))
  670. return IRQ_NONE;
  671. if (int_status & CDNS_MCP_INT_RX_WL) {
  672. cdns_read_response(cdns);
  673. if (cdns->defer) {
  674. cdns_fill_msg_resp(cdns, cdns->defer->msg,
  675. cdns->defer->length, 0);
  676. complete(&cdns->defer->complete);
  677. cdns->defer = NULL;
  678. } else {
  679. complete(&cdns->tx_complete);
  680. }
  681. }
  682. if (int_status & CDNS_MCP_INT_PARITY) {
  683. /* Parity error detected by Master */
  684. dev_err_ratelimited(cdns->dev, "Parity error\n");
  685. }
  686. if (int_status & CDNS_MCP_INT_CTRL_CLASH) {
  687. /* Slave is driving bit slot during control word */
  688. dev_err_ratelimited(cdns->dev, "Bus clash for control word\n");
  689. }
  690. if (int_status & CDNS_MCP_INT_DATA_CLASH) {
  691. /*
  692. * Multiple slaves trying to drive bit slot, or issue with
  693. * ownership of data bits or Slave gone bonkers
  694. */
  695. dev_err_ratelimited(cdns->dev, "Bus clash for data word\n");
  696. }
  697. if (cdns->bus.params.m_data_mode != SDW_PORT_DATA_MODE_NORMAL &&
  698. int_status & CDNS_MCP_INT_DPINT) {
  699. u32 port_intstat;
  700. /* just log which ports report an error */
  701. port_intstat = cdns_readl(cdns, CDNS_MCP_PORT_INTSTAT);
  702. dev_err_ratelimited(cdns->dev, "DP interrupt: PortIntStat %8x\n",
  703. port_intstat);
  704. /* clear status w/ write1 */
  705. cdns_writel(cdns, CDNS_MCP_PORT_INTSTAT, port_intstat);
  706. }
  707. if (int_status & CDNS_MCP_INT_SLAVE_MASK) {
  708. /* Mask the Slave interrupt and wake thread */
  709. cdns_updatel(cdns, CDNS_MCP_INTMASK,
  710. CDNS_MCP_INT_SLAVE_MASK, 0);
  711. int_status &= ~CDNS_MCP_INT_SLAVE_MASK;
  712. /*
  713. * Deal with possible race condition between interrupt
  714. * handling and disabling interrupts on suspend.
  715. *
  716. * If the master is in the process of disabling
  717. * interrupts, don't schedule a workqueue
  718. */
  719. if (cdns->interrupt_enabled)
  720. schedule_work(&cdns->work);
  721. }
  722. cdns_writel(cdns, CDNS_MCP_INTSTAT, int_status);
  723. return ret;
  724. }
  725. EXPORT_SYMBOL(sdw_cdns_irq);
  726. /**
  727. * To update slave status in a work since we will need to handle
  728. * other interrupts eg. CDNS_MCP_INT_RX_WL during the update slave
  729. * process.
  730. * @work: cdns worker thread
  731. */
  732. static void cdns_update_slave_status_work(struct work_struct *work)
  733. {
  734. struct sdw_cdns *cdns =
  735. container_of(work, struct sdw_cdns, work);
  736. u32 slave0, slave1;
  737. dev_dbg_ratelimited(cdns->dev, "Slave status change\n");
  738. slave0 = cdns_readl(cdns, CDNS_MCP_SLAVE_INTSTAT0);
  739. slave1 = cdns_readl(cdns, CDNS_MCP_SLAVE_INTSTAT1);
  740. cdns_update_slave_status(cdns, slave0, slave1);
  741. cdns_writel(cdns, CDNS_MCP_SLAVE_INTSTAT0, slave0);
  742. cdns_writel(cdns, CDNS_MCP_SLAVE_INTSTAT1, slave1);
  743. /* clear and unmask Slave interrupt now */
  744. cdns_writel(cdns, CDNS_MCP_INTSTAT, CDNS_MCP_INT_SLAVE_MASK);
  745. cdns_updatel(cdns, CDNS_MCP_INTMASK,
  746. CDNS_MCP_INT_SLAVE_MASK, CDNS_MCP_INT_SLAVE_MASK);
  747. }
  748. /*
  749. * init routines
  750. */
  751. /**
  752. * sdw_cdns_exit_reset() - Program reset parameters and start bus operations
  753. * @cdns: Cadence instance
  754. */
  755. int sdw_cdns_exit_reset(struct sdw_cdns *cdns)
  756. {
  757. /* program maximum length reset to be safe */
  758. cdns_updatel(cdns, CDNS_MCP_CONTROL,
  759. CDNS_MCP_CONTROL_RST_DELAY,
  760. CDNS_MCP_CONTROL_RST_DELAY);
  761. /* use hardware generated reset */
  762. cdns_updatel(cdns, CDNS_MCP_CONTROL,
  763. CDNS_MCP_CONTROL_HW_RST,
  764. CDNS_MCP_CONTROL_HW_RST);
  765. /* commit changes */
  766. cdns_updatel(cdns, CDNS_MCP_CONFIG_UPDATE,
  767. CDNS_MCP_CONFIG_UPDATE_BIT,
  768. CDNS_MCP_CONFIG_UPDATE_BIT);
  769. /* don't wait here */
  770. return 0;
  771. }
  772. EXPORT_SYMBOL(sdw_cdns_exit_reset);
  773. /**
  774. * sdw_cdns_enable_slave_interrupt() - Enable SDW slave interrupts
  775. * @cdns: Cadence instance
  776. * @state: boolean for true/false
  777. */
  778. static void cdns_enable_slave_interrupts(struct sdw_cdns *cdns, bool state)
  779. {
  780. u32 mask;
  781. mask = cdns_readl(cdns, CDNS_MCP_INTMASK);
  782. if (state)
  783. mask |= CDNS_MCP_INT_SLAVE_MASK;
  784. else
  785. mask &= ~CDNS_MCP_INT_SLAVE_MASK;
  786. cdns_writel(cdns, CDNS_MCP_INTMASK, mask);
  787. }
  788. /**
  789. * sdw_cdns_enable_interrupt() - Enable SDW interrupts
  790. * @cdns: Cadence instance
  791. * @state: True if we are trying to enable interrupt.
  792. */
  793. int sdw_cdns_enable_interrupt(struct sdw_cdns *cdns, bool state)
  794. {
  795. u32 slave_intmask0 = 0;
  796. u32 slave_intmask1 = 0;
  797. u32 mask = 0;
  798. if (!state)
  799. goto update_masks;
  800. slave_intmask0 = CDNS_MCP_SLAVE_INTMASK0_MASK;
  801. slave_intmask1 = CDNS_MCP_SLAVE_INTMASK1_MASK;
  802. /* enable detection of all slave state changes */
  803. mask = CDNS_MCP_INT_SLAVE_MASK;
  804. /* enable detection of bus issues */
  805. mask |= CDNS_MCP_INT_CTRL_CLASH | CDNS_MCP_INT_DATA_CLASH |
  806. CDNS_MCP_INT_PARITY;
  807. /* port interrupt limited to test modes for now */
  808. if (cdns->bus.params.m_data_mode != SDW_PORT_DATA_MODE_NORMAL)
  809. mask |= CDNS_MCP_INT_DPINT;
  810. /* enable detection of RX fifo level */
  811. mask |= CDNS_MCP_INT_RX_WL;
  812. /*
  813. * CDNS_MCP_INT_IRQ needs to be set otherwise all previous
  814. * settings are irrelevant
  815. */
  816. mask |= CDNS_MCP_INT_IRQ;
  817. if (interrupt_mask) /* parameter override */
  818. mask = interrupt_mask;
  819. update_masks:
  820. /* clear slave interrupt status before enabling interrupt */
  821. if (state) {
  822. u32 slave_state;
  823. slave_state = cdns_readl(cdns, CDNS_MCP_SLAVE_INTSTAT0);
  824. cdns_writel(cdns, CDNS_MCP_SLAVE_INTSTAT0, slave_state);
  825. slave_state = cdns_readl(cdns, CDNS_MCP_SLAVE_INTSTAT1);
  826. cdns_writel(cdns, CDNS_MCP_SLAVE_INTSTAT1, slave_state);
  827. }
  828. cdns->interrupt_enabled = state;
  829. /*
  830. * Complete any on-going status updates before updating masks,
  831. * and cancel queued status updates.
  832. *
  833. * There could be a race with a new interrupt thrown before
  834. * the 3 mask updates below are complete, so in the interrupt
  835. * we use the 'interrupt_enabled' status to prevent new work
  836. * from being queued.
  837. */
  838. if (!state)
  839. cancel_work_sync(&cdns->work);
  840. cdns_writel(cdns, CDNS_MCP_SLAVE_INTMASK0, slave_intmask0);
  841. cdns_writel(cdns, CDNS_MCP_SLAVE_INTMASK1, slave_intmask1);
  842. cdns_writel(cdns, CDNS_MCP_INTMASK, mask);
  843. return 0;
  844. }
  845. EXPORT_SYMBOL(sdw_cdns_enable_interrupt);
  846. static int cdns_allocate_pdi(struct sdw_cdns *cdns,
  847. struct sdw_cdns_pdi **stream,
  848. u32 num, u32 pdi_offset)
  849. {
  850. struct sdw_cdns_pdi *pdi;
  851. int i;
  852. if (!num)
  853. return 0;
  854. pdi = devm_kcalloc(cdns->dev, num, sizeof(*pdi), GFP_KERNEL);
  855. if (!pdi)
  856. return -ENOMEM;
  857. for (i = 0; i < num; i++) {
  858. pdi[i].num = i + pdi_offset;
  859. }
  860. *stream = pdi;
  861. return 0;
  862. }
  863. /**
  864. * sdw_cdns_pdi_init() - PDI initialization routine
  865. *
  866. * @cdns: Cadence instance
  867. * @config: Stream configurations
  868. */
  869. int sdw_cdns_pdi_init(struct sdw_cdns *cdns,
  870. struct sdw_cdns_stream_config config)
  871. {
  872. struct sdw_cdns_streams *stream;
  873. int offset;
  874. int ret;
  875. cdns->pcm.num_bd = config.pcm_bd;
  876. cdns->pcm.num_in = config.pcm_in;
  877. cdns->pcm.num_out = config.pcm_out;
  878. cdns->pdm.num_bd = config.pdm_bd;
  879. cdns->pdm.num_in = config.pdm_in;
  880. cdns->pdm.num_out = config.pdm_out;
  881. /* Allocate PDIs for PCMs */
  882. stream = &cdns->pcm;
  883. /* we allocate PDI0 and PDI1 which are used for Bulk */
  884. offset = 0;
  885. ret = cdns_allocate_pdi(cdns, &stream->bd,
  886. stream->num_bd, offset);
  887. if (ret)
  888. return ret;
  889. offset += stream->num_bd;
  890. ret = cdns_allocate_pdi(cdns, &stream->in,
  891. stream->num_in, offset);
  892. if (ret)
  893. return ret;
  894. offset += stream->num_in;
  895. ret = cdns_allocate_pdi(cdns, &stream->out,
  896. stream->num_out, offset);
  897. if (ret)
  898. return ret;
  899. /* Update total number of PCM PDIs */
  900. stream->num_pdi = stream->num_bd + stream->num_in + stream->num_out;
  901. cdns->num_ports = stream->num_pdi;
  902. /* Allocate PDIs for PDMs */
  903. stream = &cdns->pdm;
  904. ret = cdns_allocate_pdi(cdns, &stream->bd,
  905. stream->num_bd, offset);
  906. if (ret)
  907. return ret;
  908. offset += stream->num_bd;
  909. ret = cdns_allocate_pdi(cdns, &stream->in,
  910. stream->num_in, offset);
  911. if (ret)
  912. return ret;
  913. offset += stream->num_in;
  914. ret = cdns_allocate_pdi(cdns, &stream->out,
  915. stream->num_out, offset);
  916. if (ret)
  917. return ret;
  918. /* Update total number of PDM PDIs */
  919. stream->num_pdi = stream->num_bd + stream->num_in + stream->num_out;
  920. cdns->num_ports += stream->num_pdi;
  921. return 0;
  922. }
  923. EXPORT_SYMBOL(sdw_cdns_pdi_init);
  924. static u32 cdns_set_initial_frame_shape(int n_rows, int n_cols)
  925. {
  926. u32 val;
  927. int c;
  928. int r;
  929. r = sdw_find_row_index(n_rows);
  930. c = sdw_find_col_index(n_cols);
  931. val = FIELD_PREP(CDNS_MCP_FRAME_SHAPE_ROW_MASK, r);
  932. val |= FIELD_PREP(CDNS_MCP_FRAME_SHAPE_COL_MASK, c);
  933. return val;
  934. }
  935. static void cdns_init_clock_ctrl(struct sdw_cdns *cdns)
  936. {
  937. struct sdw_bus *bus = &cdns->bus;
  938. struct sdw_master_prop *prop = &bus->prop;
  939. u32 val;
  940. u32 ssp_interval;
  941. int divider;
  942. /* Set clock divider */
  943. divider = (prop->mclk_freq / prop->max_clk_freq) - 1;
  944. cdns_updatel(cdns, CDNS_MCP_CLK_CTRL0,
  945. CDNS_MCP_CLK_MCLKD_MASK, divider);
  946. cdns_updatel(cdns, CDNS_MCP_CLK_CTRL1,
  947. CDNS_MCP_CLK_MCLKD_MASK, divider);
  948. /*
  949. * Frame shape changes after initialization have to be done
  950. * with the bank switch mechanism
  951. */
  952. val = cdns_set_initial_frame_shape(prop->default_row,
  953. prop->default_col);
  954. cdns_writel(cdns, CDNS_MCP_FRAME_SHAPE_INIT, val);
  955. /* Set SSP interval to default value */
  956. ssp_interval = prop->default_frame_rate / SDW_CADENCE_GSYNC_HZ;
  957. cdns_writel(cdns, CDNS_MCP_SSP_CTRL0, ssp_interval);
  958. cdns_writel(cdns, CDNS_MCP_SSP_CTRL1, ssp_interval);
  959. }
  960. /**
  961. * sdw_cdns_init() - Cadence initialization
  962. * @cdns: Cadence instance
  963. */
  964. int sdw_cdns_init(struct sdw_cdns *cdns)
  965. {
  966. u32 val;
  967. cdns_init_clock_ctrl(cdns);
  968. /* reset msg_count to default value of FIFOLEVEL */
  969. cdns->msg_count = cdns_readl(cdns, CDNS_MCP_FIFOLEVEL);
  970. /* flush command FIFOs */
  971. cdns_updatel(cdns, CDNS_MCP_CONTROL, CDNS_MCP_CONTROL_CMD_RST,
  972. CDNS_MCP_CONTROL_CMD_RST);
  973. /* Set cmd accept mode */
  974. cdns_updatel(cdns, CDNS_MCP_CONTROL, CDNS_MCP_CONTROL_CMD_ACCEPT,
  975. CDNS_MCP_CONTROL_CMD_ACCEPT);
  976. /* Configure mcp config */
  977. val = cdns_readl(cdns, CDNS_MCP_CONFIG);
  978. /* enable bus operations with clock and data */
  979. val &= ~CDNS_MCP_CONFIG_OP;
  980. val |= CDNS_MCP_CONFIG_OP_NORMAL;
  981. /* Set cmd mode for Tx and Rx cmds */
  982. val &= ~CDNS_MCP_CONFIG_CMD;
  983. /* Disable sniffer mode */
  984. val &= ~CDNS_MCP_CONFIG_SNIFFER;
  985. /* Disable auto bus release */
  986. val &= ~CDNS_MCP_CONFIG_BUS_REL;
  987. if (cdns->bus.multi_link)
  988. /* Set Multi-master mode to take gsync into account */
  989. val |= CDNS_MCP_CONFIG_MMASTER;
  990. /* leave frame delay to hardware default of 0x1F */
  991. /* leave command retry to hardware default of 0 */
  992. cdns_writel(cdns, CDNS_MCP_CONFIG, val);
  993. /* changes will be committed later */
  994. return 0;
  995. }
  996. EXPORT_SYMBOL(sdw_cdns_init);
  997. int cdns_bus_conf(struct sdw_bus *bus, struct sdw_bus_params *params)
  998. {
  999. struct sdw_master_prop *prop = &bus->prop;
  1000. struct sdw_cdns *cdns = bus_to_cdns(bus);
  1001. int mcp_clkctrl_off;
  1002. int divider;
  1003. if (!params->curr_dr_freq) {
  1004. dev_err(cdns->dev, "NULL curr_dr_freq\n");
  1005. return -EINVAL;
  1006. }
  1007. divider = prop->mclk_freq * SDW_DOUBLE_RATE_FACTOR /
  1008. params->curr_dr_freq;
  1009. divider--; /* divider is 1/(N+1) */
  1010. if (params->next_bank)
  1011. mcp_clkctrl_off = CDNS_MCP_CLK_CTRL1;
  1012. else
  1013. mcp_clkctrl_off = CDNS_MCP_CLK_CTRL0;
  1014. cdns_updatel(cdns, mcp_clkctrl_off, CDNS_MCP_CLK_MCLKD_MASK, divider);
  1015. return 0;
  1016. }
  1017. EXPORT_SYMBOL(cdns_bus_conf);
  1018. static int cdns_port_params(struct sdw_bus *bus,
  1019. struct sdw_port_params *p_params, unsigned int bank)
  1020. {
  1021. struct sdw_cdns *cdns = bus_to_cdns(bus);
  1022. int dpn_config = 0, dpn_config_off;
  1023. if (bank)
  1024. dpn_config_off = CDNS_DPN_B1_CONFIG(p_params->num);
  1025. else
  1026. dpn_config_off = CDNS_DPN_B0_CONFIG(p_params->num);
  1027. dpn_config = cdns_readl(cdns, dpn_config_off);
  1028. u32p_replace_bits(&dpn_config, (p_params->bps - 1), CDNS_DPN_CONFIG_WL);
  1029. u32p_replace_bits(&dpn_config, p_params->flow_mode, CDNS_DPN_CONFIG_PORT_FLOW);
  1030. u32p_replace_bits(&dpn_config, p_params->data_mode, CDNS_DPN_CONFIG_PORT_DAT);
  1031. cdns_writel(cdns, dpn_config_off, dpn_config);
  1032. return 0;
  1033. }
  1034. static int cdns_transport_params(struct sdw_bus *bus,
  1035. struct sdw_transport_params *t_params,
  1036. enum sdw_reg_bank bank)
  1037. {
  1038. struct sdw_cdns *cdns = bus_to_cdns(bus);
  1039. int dpn_offsetctrl = 0, dpn_offsetctrl_off;
  1040. int dpn_config = 0, dpn_config_off;
  1041. int dpn_hctrl = 0, dpn_hctrl_off;
  1042. int num = t_params->port_num;
  1043. int dpn_samplectrl_off;
  1044. /*
  1045. * Note: Only full data port is supported on the Master side for
  1046. * both PCM and PDM ports.
  1047. */
  1048. if (bank) {
  1049. dpn_config_off = CDNS_DPN_B1_CONFIG(num);
  1050. dpn_samplectrl_off = CDNS_DPN_B1_SAMPLE_CTRL(num);
  1051. dpn_hctrl_off = CDNS_DPN_B1_HCTRL(num);
  1052. dpn_offsetctrl_off = CDNS_DPN_B1_OFFSET_CTRL(num);
  1053. } else {
  1054. dpn_config_off = CDNS_DPN_B0_CONFIG(num);
  1055. dpn_samplectrl_off = CDNS_DPN_B0_SAMPLE_CTRL(num);
  1056. dpn_hctrl_off = CDNS_DPN_B0_HCTRL(num);
  1057. dpn_offsetctrl_off = CDNS_DPN_B0_OFFSET_CTRL(num);
  1058. }
  1059. dpn_config = cdns_readl(cdns, dpn_config_off);
  1060. u32p_replace_bits(&dpn_config, t_params->blk_grp_ctrl, CDNS_DPN_CONFIG_BGC);
  1061. u32p_replace_bits(&dpn_config, t_params->blk_pkg_mode, CDNS_DPN_CONFIG_BPM);
  1062. cdns_writel(cdns, dpn_config_off, dpn_config);
  1063. u32p_replace_bits(&dpn_offsetctrl, t_params->offset1, CDNS_DPN_OFFSET_CTRL_1);
  1064. u32p_replace_bits(&dpn_offsetctrl, t_params->offset2, CDNS_DPN_OFFSET_CTRL_2);
  1065. cdns_writel(cdns, dpn_offsetctrl_off, dpn_offsetctrl);
  1066. u32p_replace_bits(&dpn_hctrl, t_params->hstart, CDNS_DPN_HCTRL_HSTART);
  1067. u32p_replace_bits(&dpn_hctrl, t_params->hstop, CDNS_DPN_HCTRL_HSTOP);
  1068. u32p_replace_bits(&dpn_hctrl, t_params->lane_ctrl, CDNS_DPN_HCTRL_LCTRL);
  1069. cdns_writel(cdns, dpn_hctrl_off, dpn_hctrl);
  1070. cdns_writel(cdns, dpn_samplectrl_off, (t_params->sample_interval - 1));
  1071. return 0;
  1072. }
  1073. static int cdns_port_enable(struct sdw_bus *bus,
  1074. struct sdw_enable_ch *enable_ch, unsigned int bank)
  1075. {
  1076. struct sdw_cdns *cdns = bus_to_cdns(bus);
  1077. int dpn_chnen_off, ch_mask;
  1078. if (bank)
  1079. dpn_chnen_off = CDNS_DPN_B1_CH_EN(enable_ch->port_num);
  1080. else
  1081. dpn_chnen_off = CDNS_DPN_B0_CH_EN(enable_ch->port_num);
  1082. ch_mask = enable_ch->ch_mask * enable_ch->enable;
  1083. cdns_writel(cdns, dpn_chnen_off, ch_mask);
  1084. return 0;
  1085. }
  1086. static const struct sdw_master_port_ops cdns_port_ops = {
  1087. .dpn_set_port_params = cdns_port_params,
  1088. .dpn_set_port_transport_params = cdns_transport_params,
  1089. .dpn_port_enable_ch = cdns_port_enable,
  1090. };
  1091. /**
  1092. * sdw_cdns_is_clock_stop: Check clock status
  1093. *
  1094. * @cdns: Cadence instance
  1095. */
  1096. bool sdw_cdns_is_clock_stop(struct sdw_cdns *cdns)
  1097. {
  1098. return !!(cdns_readl(cdns, CDNS_MCP_STAT) & CDNS_MCP_STAT_CLK_STOP);
  1099. }
  1100. EXPORT_SYMBOL(sdw_cdns_is_clock_stop);
  1101. /**
  1102. * sdw_cdns_clock_stop: Cadence clock stop configuration routine
  1103. *
  1104. * @cdns: Cadence instance
  1105. * @block_wake: prevent wakes if required by the platform
  1106. */
  1107. int sdw_cdns_clock_stop(struct sdw_cdns *cdns, bool block_wake)
  1108. {
  1109. bool slave_present = false;
  1110. struct sdw_slave *slave;
  1111. int ret;
  1112. /* Check suspend status */
  1113. if (sdw_cdns_is_clock_stop(cdns)) {
  1114. dev_dbg(cdns->dev, "Clock is already stopped\n");
  1115. return 0;
  1116. }
  1117. /*
  1118. * Before entering clock stop we mask the Slave
  1119. * interrupts. This helps avoid having to deal with e.g. a
  1120. * Slave becoming UNATTACHED while the clock is being stopped
  1121. */
  1122. cdns_enable_slave_interrupts(cdns, false);
  1123. /*
  1124. * For specific platforms, it is required to be able to put
  1125. * master into a state in which it ignores wake-up trials
  1126. * in clock stop state
  1127. */
  1128. if (block_wake)
  1129. cdns_updatel(cdns, CDNS_MCP_CONTROL,
  1130. CDNS_MCP_CONTROL_BLOCK_WAKEUP,
  1131. CDNS_MCP_CONTROL_BLOCK_WAKEUP);
  1132. list_for_each_entry(slave, &cdns->bus.slaves, node) {
  1133. if (slave->status == SDW_SLAVE_ATTACHED ||
  1134. slave->status == SDW_SLAVE_ALERT) {
  1135. slave_present = true;
  1136. break;
  1137. }
  1138. }
  1139. /*
  1140. * This CMD_ACCEPT should be used when there are no devices
  1141. * attached on the link when entering clock stop mode. If this is
  1142. * not set and there is a broadcast write then the command ignored
  1143. * will be treated as a failure
  1144. */
  1145. if (!slave_present)
  1146. cdns_updatel(cdns, CDNS_MCP_CONTROL,
  1147. CDNS_MCP_CONTROL_CMD_ACCEPT,
  1148. CDNS_MCP_CONTROL_CMD_ACCEPT);
  1149. else
  1150. cdns_updatel(cdns, CDNS_MCP_CONTROL,
  1151. CDNS_MCP_CONTROL_CMD_ACCEPT, 0);
  1152. /* commit changes */
  1153. ret = cdns_config_update(cdns);
  1154. if (ret < 0) {
  1155. dev_err(cdns->dev, "%s: config_update failed\n", __func__);
  1156. return ret;
  1157. }
  1158. /* Prepare slaves for clock stop */
  1159. if (slave_present) {
  1160. ret = sdw_bus_prep_clk_stop(&cdns->bus);
  1161. if (ret < 0 && ret != -ENODATA) {
  1162. dev_err(cdns->dev, "prepare clock stop failed %d\n", ret);
  1163. return ret;
  1164. }
  1165. }
  1166. /*
  1167. * Enter clock stop mode and only report errors if there are
  1168. * Slave devices present (ALERT or ATTACHED)
  1169. */
  1170. ret = sdw_bus_clk_stop(&cdns->bus);
  1171. if (ret < 0 && slave_present && ret != -ENODATA) {
  1172. dev_err(cdns->dev, "bus clock stop failed %d", ret);
  1173. return ret;
  1174. }
  1175. ret = cdns_set_wait(cdns, CDNS_MCP_STAT,
  1176. CDNS_MCP_STAT_CLK_STOP,
  1177. CDNS_MCP_STAT_CLK_STOP);
  1178. if (ret < 0)
  1179. dev_err(cdns->dev, "Clock stop failed %d\n", ret);
  1180. return ret;
  1181. }
  1182. EXPORT_SYMBOL(sdw_cdns_clock_stop);
  1183. /**
  1184. * sdw_cdns_clock_restart: Cadence PM clock restart configuration routine
  1185. *
  1186. * @cdns: Cadence instance
  1187. * @bus_reset: context may be lost while in low power modes and the bus
  1188. * may require a Severe Reset and re-enumeration after a wake.
  1189. */
  1190. int sdw_cdns_clock_restart(struct sdw_cdns *cdns, bool bus_reset)
  1191. {
  1192. int ret;
  1193. /* unmask Slave interrupts that were masked when stopping the clock */
  1194. cdns_enable_slave_interrupts(cdns, true);
  1195. ret = cdns_clear_bit(cdns, CDNS_MCP_CONTROL,
  1196. CDNS_MCP_CONTROL_CLK_STOP_CLR);
  1197. if (ret < 0) {
  1198. dev_err(cdns->dev, "Couldn't exit from clock stop\n");
  1199. return ret;
  1200. }
  1201. ret = cdns_set_wait(cdns, CDNS_MCP_STAT, CDNS_MCP_STAT_CLK_STOP, 0);
  1202. if (ret < 0) {
  1203. dev_err(cdns->dev, "clock stop exit failed %d\n", ret);
  1204. return ret;
  1205. }
  1206. cdns_updatel(cdns, CDNS_MCP_CONTROL,
  1207. CDNS_MCP_CONTROL_BLOCK_WAKEUP, 0);
  1208. /*
  1209. * clear CMD_ACCEPT so that the command ignored
  1210. * will be treated as a failure during a broadcast write
  1211. */
  1212. cdns_updatel(cdns, CDNS_MCP_CONTROL, CDNS_MCP_CONTROL_CMD_ACCEPT, 0);
  1213. if (!bus_reset) {
  1214. /* enable bus operations with clock and data */
  1215. cdns_updatel(cdns, CDNS_MCP_CONFIG,
  1216. CDNS_MCP_CONFIG_OP,
  1217. CDNS_MCP_CONFIG_OP_NORMAL);
  1218. ret = cdns_config_update(cdns);
  1219. if (ret < 0) {
  1220. dev_err(cdns->dev, "%s: config_update failed\n", __func__);
  1221. return ret;
  1222. }
  1223. ret = sdw_bus_exit_clk_stop(&cdns->bus);
  1224. if (ret < 0)
  1225. dev_err(cdns->dev, "bus failed to exit clock stop %d\n", ret);
  1226. }
  1227. return ret;
  1228. }
  1229. EXPORT_SYMBOL(sdw_cdns_clock_restart);
  1230. /**
  1231. * sdw_cdns_probe() - Cadence probe routine
  1232. * @cdns: Cadence instance
  1233. */
  1234. int sdw_cdns_probe(struct sdw_cdns *cdns)
  1235. {
  1236. init_completion(&cdns->tx_complete);
  1237. cdns->bus.port_ops = &cdns_port_ops;
  1238. INIT_WORK(&cdns->work, cdns_update_slave_status_work);
  1239. return 0;
  1240. }
  1241. EXPORT_SYMBOL(sdw_cdns_probe);
  1242. int cdns_set_sdw_stream(struct snd_soc_dai *dai,
  1243. void *stream, bool pcm, int direction)
  1244. {
  1245. struct sdw_cdns *cdns = snd_soc_dai_get_drvdata(dai);
  1246. struct sdw_cdns_dma_data *dma;
  1247. if (stream) {
  1248. /* first paranoia check */
  1249. if (direction == SNDRV_PCM_STREAM_PLAYBACK)
  1250. dma = dai->playback_dma_data;
  1251. else
  1252. dma = dai->capture_dma_data;
  1253. if (dma) {
  1254. dev_err(dai->dev,
  1255. "dma_data already allocated for dai %s\n",
  1256. dai->name);
  1257. return -EINVAL;
  1258. }
  1259. /* allocate and set dma info */
  1260. dma = kzalloc(sizeof(*dma), GFP_KERNEL);
  1261. if (!dma)
  1262. return -ENOMEM;
  1263. if (pcm)
  1264. dma->stream_type = SDW_STREAM_PCM;
  1265. else
  1266. dma->stream_type = SDW_STREAM_PDM;
  1267. dma->bus = &cdns->bus;
  1268. dma->link_id = cdns->instance;
  1269. dma->stream = stream;
  1270. if (direction == SNDRV_PCM_STREAM_PLAYBACK)
  1271. dai->playback_dma_data = dma;
  1272. else
  1273. dai->capture_dma_data = dma;
  1274. } else {
  1275. /* for NULL stream we release allocated dma_data */
  1276. if (direction == SNDRV_PCM_STREAM_PLAYBACK) {
  1277. kfree(dai->playback_dma_data);
  1278. dai->playback_dma_data = NULL;
  1279. } else {
  1280. kfree(dai->capture_dma_data);
  1281. dai->capture_dma_data = NULL;
  1282. }
  1283. }
  1284. return 0;
  1285. }
  1286. EXPORT_SYMBOL(cdns_set_sdw_stream);
  1287. /**
  1288. * cdns_find_pdi() - Find a free PDI
  1289. *
  1290. * @cdns: Cadence instance
  1291. * @offset: Starting offset
  1292. * @num: Number of PDIs
  1293. * @pdi: PDI instances
  1294. * @dai_id: DAI id
  1295. *
  1296. * Find a PDI for a given PDI array. The PDI num and dai_id are
  1297. * expected to match, return NULL otherwise.
  1298. */
  1299. static struct sdw_cdns_pdi *cdns_find_pdi(struct sdw_cdns *cdns,
  1300. unsigned int offset,
  1301. unsigned int num,
  1302. struct sdw_cdns_pdi *pdi,
  1303. int dai_id)
  1304. {
  1305. int i;
  1306. for (i = offset; i < offset + num; i++)
  1307. if (pdi[i].num == dai_id)
  1308. return &pdi[i];
  1309. return NULL;
  1310. }
  1311. /**
  1312. * sdw_cdns_config_stream: Configure a stream
  1313. *
  1314. * @cdns: Cadence instance
  1315. * @ch: Channel count
  1316. * @dir: Data direction
  1317. * @pdi: PDI to be used
  1318. */
  1319. void sdw_cdns_config_stream(struct sdw_cdns *cdns,
  1320. u32 ch, u32 dir, struct sdw_cdns_pdi *pdi)
  1321. {
  1322. u32 offset, val = 0;
  1323. if (dir == SDW_DATA_DIR_RX) {
  1324. val = CDNS_PORTCTRL_DIRN;
  1325. if (cdns->bus.params.m_data_mode != SDW_PORT_DATA_MODE_NORMAL)
  1326. val |= CDNS_PORTCTRL_TEST_FAILED;
  1327. }
  1328. offset = CDNS_PORTCTRL + pdi->num * CDNS_PORT_OFFSET;
  1329. cdns_updatel(cdns, offset,
  1330. CDNS_PORTCTRL_DIRN | CDNS_PORTCTRL_TEST_FAILED,
  1331. val);
  1332. val = pdi->num;
  1333. val |= CDNS_PDI_CONFIG_SOFT_RESET;
  1334. val |= FIELD_PREP(CDNS_PDI_CONFIG_CHANNEL, (1 << ch) - 1);
  1335. cdns_writel(cdns, CDNS_PDI_CONFIG(pdi->num), val);
  1336. }
  1337. EXPORT_SYMBOL(sdw_cdns_config_stream);
  1338. /**
  1339. * sdw_cdns_alloc_pdi() - Allocate a PDI
  1340. *
  1341. * @cdns: Cadence instance
  1342. * @stream: Stream to be allocated
  1343. * @ch: Channel count
  1344. * @dir: Data direction
  1345. * @dai_id: DAI id
  1346. */
  1347. struct sdw_cdns_pdi *sdw_cdns_alloc_pdi(struct sdw_cdns *cdns,
  1348. struct sdw_cdns_streams *stream,
  1349. u32 ch, u32 dir, int dai_id)
  1350. {
  1351. struct sdw_cdns_pdi *pdi = NULL;
  1352. if (dir == SDW_DATA_DIR_RX)
  1353. pdi = cdns_find_pdi(cdns, 0, stream->num_in, stream->in,
  1354. dai_id);
  1355. else
  1356. pdi = cdns_find_pdi(cdns, 0, stream->num_out, stream->out,
  1357. dai_id);
  1358. /* check if we found a PDI, else find in bi-directional */
  1359. if (!pdi)
  1360. pdi = cdns_find_pdi(cdns, 2, stream->num_bd, stream->bd,
  1361. dai_id);
  1362. if (pdi) {
  1363. pdi->l_ch_num = 0;
  1364. pdi->h_ch_num = ch - 1;
  1365. pdi->dir = dir;
  1366. pdi->ch_count = ch;
  1367. }
  1368. return pdi;
  1369. }
  1370. EXPORT_SYMBOL(sdw_cdns_alloc_pdi);
  1371. MODULE_LICENSE("Dual BSD/GPL");
  1372. MODULE_DESCRIPTION("Cadence Soundwire Library");