stream.c 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479
  1. // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
  2. // Copyright(c) 2015-18 Intel Corporation.
  3. /*
  4. * stream.c - SoundWire Bus stream operations.
  5. */
  6. #include <linux/delay.h>
  7. #include <linux/device.h>
  8. #include <linux/init.h>
  9. #include <linux/module.h>
  10. #include <linux/mod_devicetable.h>
  11. #include <linux/slab.h>
  12. #include <linux/soundwire/sdw_registers.h>
  13. #include <linux/soundwire/sdw.h>
  14. #include "bus.h"
  15. /*
  16. * Array of supported rows and columns as per MIPI SoundWire Specification 1.1
  17. *
  18. * The rows are arranged as per the array index value programmed
  19. * in register. The index 15 has dummy value 0 in order to fill hole.
  20. */
  21. int rows[SDW_FRAME_ROWS] = {48, 50, 60, 64, 75, 80, 125, 147,
  22. 96, 100, 120, 128, 150, 160, 250, 0,
  23. 192, 200, 240, 256, 72, 144, 90, 180};
  24. int cols[SDW_FRAME_COLS] = {2, 4, 6, 8, 10, 12, 14, 16};
  25. static int sdw_find_col_index(int col)
  26. {
  27. int i;
  28. for (i = 0; i < SDW_FRAME_COLS; i++) {
  29. if (cols[i] == col)
  30. return i;
  31. }
  32. pr_warn("Requested column not found, selecting lowest column no: 2\n");
  33. return 0;
  34. }
  35. static int sdw_find_row_index(int row)
  36. {
  37. int i;
  38. for (i = 0; i < SDW_FRAME_ROWS; i++) {
  39. if (rows[i] == row)
  40. return i;
  41. }
  42. pr_warn("Requested row not found, selecting lowest row no: 48\n");
  43. return 0;
  44. }
  45. static int _sdw_program_slave_port_params(struct sdw_bus *bus,
  46. struct sdw_slave *slave,
  47. struct sdw_transport_params *t_params,
  48. enum sdw_dpn_type type)
  49. {
  50. u32 addr1, addr2, addr3, addr4;
  51. int ret;
  52. u16 wbuf;
  53. if (bus->params.next_bank) {
  54. addr1 = SDW_DPN_OFFSETCTRL2_B1(t_params->port_num);
  55. addr2 = SDW_DPN_BLOCKCTRL3_B1(t_params->port_num);
  56. addr3 = SDW_DPN_SAMPLECTRL2_B1(t_params->port_num);
  57. addr4 = SDW_DPN_HCTRL_B1(t_params->port_num);
  58. } else {
  59. addr1 = SDW_DPN_OFFSETCTRL2_B0(t_params->port_num);
  60. addr2 = SDW_DPN_BLOCKCTRL3_B0(t_params->port_num);
  61. addr3 = SDW_DPN_SAMPLECTRL2_B0(t_params->port_num);
  62. addr4 = SDW_DPN_HCTRL_B0(t_params->port_num);
  63. }
  64. /* Program DPN_OffsetCtrl2 registers */
  65. ret = sdw_write(slave, addr1, t_params->offset2);
  66. if (ret < 0) {
  67. dev_err(bus->dev, "DPN_OffsetCtrl2 register write failed");
  68. return ret;
  69. }
  70. /* Program DPN_BlockCtrl3 register */
  71. ret = sdw_write(slave, addr2, t_params->blk_pkg_mode);
  72. if (ret < 0) {
  73. dev_err(bus->dev, "DPN_BlockCtrl3 register write failed");
  74. return ret;
  75. }
  76. /*
  77. * Data ports are FULL, SIMPLE and REDUCED. This function handles
  78. * FULL and REDUCED only and and beyond this point only FULL is
  79. * handled, so bail out if we are not FULL data port type
  80. */
  81. if (type != SDW_DPN_FULL)
  82. return ret;
  83. /* Program DPN_SampleCtrl2 register */
  84. wbuf = (t_params->sample_interval - 1);
  85. wbuf &= SDW_DPN_SAMPLECTRL_HIGH;
  86. wbuf >>= SDW_REG_SHIFT(SDW_DPN_SAMPLECTRL_HIGH);
  87. ret = sdw_write(slave, addr3, wbuf);
  88. if (ret < 0) {
  89. dev_err(bus->dev, "DPN_SampleCtrl2 register write failed");
  90. return ret;
  91. }
  92. /* Program DPN_HCtrl register */
  93. wbuf = t_params->hstart;
  94. wbuf <<= SDW_REG_SHIFT(SDW_DPN_HCTRL_HSTART);
  95. wbuf |= t_params->hstop;
  96. ret = sdw_write(slave, addr4, wbuf);
  97. if (ret < 0)
  98. dev_err(bus->dev, "DPN_HCtrl register write failed");
  99. return ret;
  100. }
  101. static int sdw_program_slave_port_params(struct sdw_bus *bus,
  102. struct sdw_slave_runtime *s_rt,
  103. struct sdw_port_runtime *p_rt)
  104. {
  105. struct sdw_transport_params *t_params = &p_rt->transport_params;
  106. struct sdw_port_params *p_params = &p_rt->port_params;
  107. struct sdw_slave_prop *slave_prop = &s_rt->slave->prop;
  108. u32 addr1, addr2, addr3, addr4, addr5, addr6;
  109. struct sdw_dpn_prop *dpn_prop;
  110. int ret;
  111. u8 wbuf;
  112. dpn_prop = sdw_get_slave_dpn_prop(s_rt->slave,
  113. s_rt->direction,
  114. t_params->port_num);
  115. if (!dpn_prop)
  116. return -EINVAL;
  117. addr1 = SDW_DPN_PORTCTRL(t_params->port_num);
  118. addr2 = SDW_DPN_BLOCKCTRL1(t_params->port_num);
  119. if (bus->params.next_bank) {
  120. addr3 = SDW_DPN_SAMPLECTRL1_B1(t_params->port_num);
  121. addr4 = SDW_DPN_OFFSETCTRL1_B1(t_params->port_num);
  122. addr5 = SDW_DPN_BLOCKCTRL2_B1(t_params->port_num);
  123. addr6 = SDW_DPN_LANECTRL_B1(t_params->port_num);
  124. } else {
  125. addr3 = SDW_DPN_SAMPLECTRL1_B0(t_params->port_num);
  126. addr4 = SDW_DPN_OFFSETCTRL1_B0(t_params->port_num);
  127. addr5 = SDW_DPN_BLOCKCTRL2_B0(t_params->port_num);
  128. addr6 = SDW_DPN_LANECTRL_B0(t_params->port_num);
  129. }
  130. /* Program DPN_PortCtrl register */
  131. wbuf = p_params->data_mode << SDW_REG_SHIFT(SDW_DPN_PORTCTRL_DATAMODE);
  132. wbuf |= p_params->flow_mode;
  133. ret = sdw_update(s_rt->slave, addr1, 0xF, wbuf);
  134. if (ret < 0) {
  135. dev_err(&s_rt->slave->dev,
  136. "DPN_PortCtrl register write failed for port %d",
  137. t_params->port_num);
  138. return ret;
  139. }
  140. /* Program DPN_BlockCtrl1 register */
  141. ret = sdw_write(s_rt->slave, addr2, (p_params->bps - 1));
  142. if (ret < 0) {
  143. dev_err(&s_rt->slave->dev,
  144. "DPN_BlockCtrl1 register write failed for port %d",
  145. t_params->port_num);
  146. return ret;
  147. }
  148. /* Program DPN_SampleCtrl1 register */
  149. wbuf = (t_params->sample_interval - 1) & SDW_DPN_SAMPLECTRL_LOW;
  150. ret = sdw_write(s_rt->slave, addr3, wbuf);
  151. if (ret < 0) {
  152. dev_err(&s_rt->slave->dev,
  153. "DPN_SampleCtrl1 register write failed for port %d",
  154. t_params->port_num);
  155. return ret;
  156. }
  157. /* Program DPN_OffsetCtrl1 registers */
  158. ret = sdw_write(s_rt->slave, addr4, t_params->offset1);
  159. if (ret < 0) {
  160. dev_err(&s_rt->slave->dev,
  161. "DPN_OffsetCtrl1 register write failed for port %d",
  162. t_params->port_num);
  163. return ret;
  164. }
  165. /* Program DPN_BlockCtrl2 register*/
  166. if (t_params->blk_grp_ctrl_valid) {
  167. ret = sdw_write(s_rt->slave, addr5, t_params->blk_grp_ctrl);
  168. if (ret < 0) {
  169. dev_err(&s_rt->slave->dev,
  170. "DPN_BlockCtrl2 reg write failed for port %d",
  171. t_params->port_num);
  172. return ret;
  173. }
  174. }
  175. /* program DPN_LaneCtrl register */
  176. if (slave_prop->lane_control_support) {
  177. ret = sdw_write(s_rt->slave, addr6, t_params->lane_ctrl);
  178. if (ret < 0) {
  179. dev_err(&s_rt->slave->dev,
  180. "DPN_LaneCtrl register write failed for port %d",
  181. t_params->port_num);
  182. return ret;
  183. }
  184. }
  185. if (dpn_prop->type != SDW_DPN_SIMPLE) {
  186. ret = _sdw_program_slave_port_params(bus, s_rt->slave,
  187. t_params, dpn_prop->type);
  188. if (ret < 0)
  189. dev_err(&s_rt->slave->dev,
  190. "Transport reg write failed for port: %d",
  191. t_params->port_num);
  192. }
  193. return ret;
  194. }
  195. static int sdw_program_master_port_params(struct sdw_bus *bus,
  196. struct sdw_port_runtime *p_rt)
  197. {
  198. int ret;
  199. /*
  200. * we need to set transport and port parameters for the port.
  201. * Transport parameters refers to the smaple interval, offsets and
  202. * hstart/stop etc of the data. Port parameters refers to word
  203. * length, flow mode etc of the port
  204. */
  205. ret = bus->port_ops->dpn_set_port_transport_params(bus,
  206. &p_rt->transport_params,
  207. bus->params.next_bank);
  208. if (ret < 0)
  209. return ret;
  210. return bus->port_ops->dpn_set_port_params(bus,
  211. &p_rt->port_params,
  212. bus->params.next_bank);
  213. }
  214. /**
  215. * sdw_program_port_params() - Programs transport parameters of Master(s)
  216. * and Slave(s)
  217. *
  218. * @m_rt: Master stream runtime
  219. */
  220. static int sdw_program_port_params(struct sdw_master_runtime *m_rt)
  221. {
  222. struct sdw_slave_runtime *s_rt = NULL;
  223. struct sdw_bus *bus = m_rt->bus;
  224. struct sdw_port_runtime *p_rt;
  225. int ret = 0;
  226. /* Program transport & port parameters for Slave(s) */
  227. list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {
  228. list_for_each_entry(p_rt, &s_rt->port_list, port_node) {
  229. ret = sdw_program_slave_port_params(bus, s_rt, p_rt);
  230. if (ret < 0)
  231. return ret;
  232. }
  233. }
  234. /* Program transport & port parameters for Master(s) */
  235. list_for_each_entry(p_rt, &m_rt->port_list, port_node) {
  236. ret = sdw_program_master_port_params(bus, p_rt);
  237. if (ret < 0)
  238. return ret;
  239. }
  240. return 0;
  241. }
  242. /**
  243. * sdw_enable_disable_slave_ports: Enable/disable slave data port
  244. *
  245. * @bus: bus instance
  246. * @s_rt: slave runtime
  247. * @p_rt: port runtime
  248. * @en: enable or disable operation
  249. *
  250. * This function only sets the enable/disable bits in the relevant bank, the
  251. * actual enable/disable is done with a bank switch
  252. */
  253. static int sdw_enable_disable_slave_ports(struct sdw_bus *bus,
  254. struct sdw_slave_runtime *s_rt,
  255. struct sdw_port_runtime *p_rt, bool en)
  256. {
  257. struct sdw_transport_params *t_params = &p_rt->transport_params;
  258. u32 addr;
  259. int ret;
  260. if (bus->params.next_bank)
  261. addr = SDW_DPN_CHANNELEN_B1(p_rt->num);
  262. else
  263. addr = SDW_DPN_CHANNELEN_B0(p_rt->num);
  264. /*
  265. * Since bus doesn't support sharing a port across two streams,
  266. * it is safe to reset this register
  267. */
  268. if (en)
  269. ret = sdw_update(s_rt->slave, addr, 0xFF, p_rt->ch_mask);
  270. else
  271. ret = sdw_update(s_rt->slave, addr, 0xFF, 0x0);
  272. if (ret < 0)
  273. dev_err(&s_rt->slave->dev,
  274. "Slave chn_en reg write failed:%d port:%d",
  275. ret, t_params->port_num);
  276. return ret;
  277. }
  278. static int sdw_enable_disable_master_ports(struct sdw_master_runtime *m_rt,
  279. struct sdw_port_runtime *p_rt, bool en)
  280. {
  281. struct sdw_transport_params *t_params = &p_rt->transport_params;
  282. struct sdw_bus *bus = m_rt->bus;
  283. struct sdw_enable_ch enable_ch;
  284. int ret = 0;
  285. enable_ch.port_num = p_rt->num;
  286. enable_ch.ch_mask = p_rt->ch_mask;
  287. enable_ch.enable = en;
  288. /* Perform Master port channel(s) enable/disable */
  289. if (bus->port_ops->dpn_port_enable_ch) {
  290. ret = bus->port_ops->dpn_port_enable_ch(bus,
  291. &enable_ch, bus->params.next_bank);
  292. if (ret < 0) {
  293. dev_err(bus->dev,
  294. "Master chn_en write failed:%d port:%d",
  295. ret, t_params->port_num);
  296. return ret;
  297. }
  298. } else {
  299. dev_err(bus->dev,
  300. "dpn_port_enable_ch not supported, %s failed\n",
  301. en ? "enable" : "disable");
  302. return -EINVAL;
  303. }
  304. return 0;
  305. }
  306. /**
  307. * sdw_enable_disable_ports() - Enable/disable port(s) for Master and
  308. * Slave(s)
  309. *
  310. * @m_rt: Master stream runtime
  311. * @en: mode (enable/disable)
  312. */
  313. static int sdw_enable_disable_ports(struct sdw_master_runtime *m_rt, bool en)
  314. {
  315. struct sdw_port_runtime *s_port, *m_port;
  316. struct sdw_slave_runtime *s_rt = NULL;
  317. int ret = 0;
  318. /* Enable/Disable Slave port(s) */
  319. list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {
  320. list_for_each_entry(s_port, &s_rt->port_list, port_node) {
  321. ret = sdw_enable_disable_slave_ports(m_rt->bus, s_rt,
  322. s_port, en);
  323. if (ret < 0)
  324. return ret;
  325. }
  326. }
  327. /* Enable/Disable Master port(s) */
  328. list_for_each_entry(m_port, &m_rt->port_list, port_node) {
  329. ret = sdw_enable_disable_master_ports(m_rt, m_port, en);
  330. if (ret < 0)
  331. return ret;
  332. }
  333. return 0;
  334. }
  335. static int sdw_do_port_prep(struct sdw_slave_runtime *s_rt,
  336. struct sdw_prepare_ch prep_ch, enum sdw_port_prep_ops cmd)
  337. {
  338. const struct sdw_slave_ops *ops = s_rt->slave->ops;
  339. int ret;
  340. if (ops->port_prep) {
  341. ret = ops->port_prep(s_rt->slave, &prep_ch, cmd);
  342. if (ret < 0) {
  343. dev_err(&s_rt->slave->dev,
  344. "Slave Port Prep cmd %d failed: %d", cmd, ret);
  345. return ret;
  346. }
  347. }
  348. return 0;
  349. }
  350. static int sdw_prep_deprep_slave_ports(struct sdw_bus *bus,
  351. struct sdw_slave_runtime *s_rt,
  352. struct sdw_port_runtime *p_rt, bool prep)
  353. {
  354. struct completion *port_ready = NULL;
  355. struct sdw_dpn_prop *dpn_prop;
  356. struct sdw_prepare_ch prep_ch;
  357. unsigned int time_left;
  358. bool intr = false;
  359. int ret = 0, val;
  360. u32 addr;
  361. prep_ch.num = p_rt->num;
  362. prep_ch.ch_mask = p_rt->ch_mask;
  363. dpn_prop = sdw_get_slave_dpn_prop(s_rt->slave,
  364. s_rt->direction,
  365. prep_ch.num);
  366. if (!dpn_prop) {
  367. dev_err(bus->dev,
  368. "Slave Port:%d properties not found", prep_ch.num);
  369. return -EINVAL;
  370. }
  371. prep_ch.prepare = prep;
  372. prep_ch.bank = bus->params.next_bank;
  373. if (dpn_prop->device_interrupts || !dpn_prop->simple_ch_prep_sm)
  374. intr = true;
  375. /*
  376. * Enable interrupt before Port prepare.
  377. * For Port de-prepare, it is assumed that port
  378. * was prepared earlier
  379. */
  380. if (prep && intr) {
  381. ret = sdw_configure_dpn_intr(s_rt->slave, p_rt->num, prep,
  382. dpn_prop->device_interrupts);
  383. if (ret < 0)
  384. return ret;
  385. }
  386. /* Inform slave about the impending port prepare */
  387. sdw_do_port_prep(s_rt, prep_ch, SDW_OPS_PORT_PRE_PREP);
  388. /* Prepare Slave port implementing CP_SM */
  389. if (!dpn_prop->simple_ch_prep_sm) {
  390. addr = SDW_DPN_PREPARECTRL(p_rt->num);
  391. if (prep)
  392. ret = sdw_update(s_rt->slave, addr,
  393. 0xFF, p_rt->ch_mask);
  394. else
  395. ret = sdw_update(s_rt->slave, addr, 0xFF, 0x0);
  396. if (ret < 0) {
  397. dev_err(&s_rt->slave->dev,
  398. "Slave prep_ctrl reg write failed");
  399. return ret;
  400. }
  401. /* Wait for completion on port ready */
  402. port_ready = &s_rt->slave->port_ready[prep_ch.num];
  403. time_left = wait_for_completion_timeout(port_ready,
  404. msecs_to_jiffies(dpn_prop->ch_prep_timeout));
  405. val = sdw_read(s_rt->slave, SDW_DPN_PREPARESTATUS(p_rt->num));
  406. val &= p_rt->ch_mask;
  407. if (!time_left || val) {
  408. dev_err(&s_rt->slave->dev,
  409. "Chn prep failed for port:%d", prep_ch.num);
  410. return -ETIMEDOUT;
  411. }
  412. }
  413. /* Inform slaves about ports prepared */
  414. sdw_do_port_prep(s_rt, prep_ch, SDW_OPS_PORT_POST_PREP);
  415. /* Disable interrupt after Port de-prepare */
  416. if (!prep && intr)
  417. ret = sdw_configure_dpn_intr(s_rt->slave, p_rt->num, prep,
  418. dpn_prop->device_interrupts);
  419. return ret;
  420. }
  421. static int sdw_prep_deprep_master_ports(struct sdw_master_runtime *m_rt,
  422. struct sdw_port_runtime *p_rt, bool prep)
  423. {
  424. struct sdw_transport_params *t_params = &p_rt->transport_params;
  425. struct sdw_bus *bus = m_rt->bus;
  426. const struct sdw_master_port_ops *ops = bus->port_ops;
  427. struct sdw_prepare_ch prep_ch;
  428. int ret = 0;
  429. prep_ch.num = p_rt->num;
  430. prep_ch.ch_mask = p_rt->ch_mask;
  431. prep_ch.prepare = prep; /* Prepare/De-prepare */
  432. prep_ch.bank = bus->params.next_bank;
  433. /* Pre-prepare/Pre-deprepare port(s) */
  434. if (ops->dpn_port_prep) {
  435. ret = ops->dpn_port_prep(bus, &prep_ch);
  436. if (ret < 0) {
  437. dev_err(bus->dev, "Port prepare failed for port:%d",
  438. t_params->port_num);
  439. return ret;
  440. }
  441. }
  442. return ret;
  443. }
  444. /**
  445. * sdw_prep_deprep_ports() - Prepare/De-prepare port(s) for Master(s) and
  446. * Slave(s)
  447. *
  448. * @m_rt: Master runtime handle
  449. * @prep: Prepare or De-prepare
  450. */
  451. static int sdw_prep_deprep_ports(struct sdw_master_runtime *m_rt, bool prep)
  452. {
  453. struct sdw_slave_runtime *s_rt = NULL;
  454. struct sdw_port_runtime *p_rt;
  455. int ret = 0;
  456. /* Prepare/De-prepare Slave port(s) */
  457. list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {
  458. list_for_each_entry(p_rt, &s_rt->port_list, port_node) {
  459. ret = sdw_prep_deprep_slave_ports(m_rt->bus, s_rt,
  460. p_rt, prep);
  461. if (ret < 0)
  462. return ret;
  463. }
  464. }
  465. /* Prepare/De-prepare Master port(s) */
  466. list_for_each_entry(p_rt, &m_rt->port_list, port_node) {
  467. ret = sdw_prep_deprep_master_ports(m_rt, p_rt, prep);
  468. if (ret < 0)
  469. return ret;
  470. }
  471. return ret;
  472. }
  473. /**
  474. * sdw_notify_config() - Notify bus configuration
  475. *
  476. * @m_rt: Master runtime handle
  477. *
  478. * This function notifies the Master(s) and Slave(s) of the
  479. * new bus configuration.
  480. */
  481. static int sdw_notify_config(struct sdw_master_runtime *m_rt)
  482. {
  483. struct sdw_slave_runtime *s_rt;
  484. struct sdw_bus *bus = m_rt->bus;
  485. struct sdw_slave *slave;
  486. int ret = 0;
  487. if (bus->ops->set_bus_conf) {
  488. ret = bus->ops->set_bus_conf(bus, &bus->params);
  489. if (ret < 0)
  490. return ret;
  491. }
  492. list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {
  493. slave = s_rt->slave;
  494. if (slave->ops->bus_config) {
  495. ret = slave->ops->bus_config(slave, &bus->params);
  496. if (ret < 0)
  497. dev_err(bus->dev, "Notify Slave: %d failed",
  498. slave->dev_num);
  499. return ret;
  500. }
  501. }
  502. return ret;
  503. }
  504. /**
  505. * sdw_program_params() - Program transport and port parameters for Master(s)
  506. * and Slave(s)
  507. *
  508. * @bus: SDW bus instance
  509. */
  510. static int sdw_program_params(struct sdw_bus *bus)
  511. {
  512. struct sdw_master_runtime *m_rt = NULL;
  513. int ret = 0;
  514. list_for_each_entry(m_rt, &bus->m_rt_list, bus_node) {
  515. ret = sdw_program_port_params(m_rt);
  516. if (ret < 0) {
  517. dev_err(bus->dev,
  518. "Program transport params failed: %d", ret);
  519. return ret;
  520. }
  521. ret = sdw_notify_config(m_rt);
  522. if (ret < 0) {
  523. dev_err(bus->dev, "Notify bus config failed: %d", ret);
  524. return ret;
  525. }
  526. /* Enable port(s) on alternate bank for all active streams */
  527. if (m_rt->stream->state != SDW_STREAM_ENABLED)
  528. continue;
  529. ret = sdw_enable_disable_ports(m_rt, true);
  530. if (ret < 0) {
  531. dev_err(bus->dev, "Enable channel failed: %d", ret);
  532. return ret;
  533. }
  534. }
  535. return ret;
  536. }
  537. static int sdw_bank_switch(struct sdw_bus *bus)
  538. {
  539. int col_index, row_index;
  540. struct sdw_msg *wr_msg;
  541. u8 *wbuf = NULL;
  542. int ret = 0;
  543. u16 addr;
  544. wr_msg = kzalloc(sizeof(*wr_msg), GFP_KERNEL);
  545. if (!wr_msg)
  546. return -ENOMEM;
  547. wbuf = kzalloc(sizeof(*wbuf), GFP_KERNEL);
  548. if (!wbuf) {
  549. ret = -ENOMEM;
  550. goto error_1;
  551. }
  552. /* Get row and column index to program register */
  553. col_index = sdw_find_col_index(bus->params.col);
  554. row_index = sdw_find_row_index(bus->params.row);
  555. wbuf[0] = col_index | (row_index << 3);
  556. if (bus->params.next_bank)
  557. addr = SDW_SCP_FRAMECTRL_B1;
  558. else
  559. addr = SDW_SCP_FRAMECTRL_B0;
  560. sdw_fill_msg(wr_msg, NULL, addr, 1, SDW_BROADCAST_DEV_NUM,
  561. SDW_MSG_FLAG_WRITE, wbuf);
  562. wr_msg->ssp_sync = true;
  563. ret = sdw_transfer(bus, wr_msg);
  564. if (ret < 0) {
  565. dev_err(bus->dev, "Slave frame_ctrl reg write failed");
  566. goto error;
  567. }
  568. kfree(wr_msg);
  569. kfree(wbuf);
  570. bus->defer_msg.msg = NULL;
  571. bus->params.curr_bank = !bus->params.curr_bank;
  572. bus->params.next_bank = !bus->params.next_bank;
  573. return 0;
  574. error:
  575. kfree(wbuf);
  576. error_1:
  577. kfree(wr_msg);
  578. return ret;
  579. }
  580. static int do_bank_switch(struct sdw_stream_runtime *stream)
  581. {
  582. struct sdw_master_runtime *m_rt = stream->m_rt;
  583. const struct sdw_master_ops *ops;
  584. struct sdw_bus *bus = m_rt->bus;
  585. int ret = 0;
  586. ops = bus->ops;
  587. /* Pre-bank switch */
  588. if (ops->pre_bank_switch) {
  589. ret = ops->pre_bank_switch(bus);
  590. if (ret < 0) {
  591. dev_err(bus->dev, "Pre bank switch op failed: %d", ret);
  592. return ret;
  593. }
  594. }
  595. /* Bank switch */
  596. ret = sdw_bank_switch(bus);
  597. if (ret < 0) {
  598. dev_err(bus->dev, "Bank switch failed: %d", ret);
  599. return ret;
  600. }
  601. /* Post-bank switch */
  602. if (ops->post_bank_switch) {
  603. ret = ops->post_bank_switch(bus);
  604. if (ret < 0) {
  605. dev_err(bus->dev,
  606. "Post bank switch op failed: %d", ret);
  607. }
  608. }
  609. return ret;
  610. }
  611. /**
  612. * sdw_release_stream() - Free the assigned stream runtime
  613. *
  614. * @stream: SoundWire stream runtime
  615. *
  616. * sdw_release_stream should be called only once per stream
  617. */
  618. void sdw_release_stream(struct sdw_stream_runtime *stream)
  619. {
  620. kfree(stream);
  621. }
  622. EXPORT_SYMBOL(sdw_release_stream);
  623. /**
  624. * sdw_alloc_stream() - Allocate and return stream runtime
  625. *
  626. * @stream_name: SoundWire stream name
  627. *
  628. * Allocates a SoundWire stream runtime instance.
  629. * sdw_alloc_stream should be called only once per stream. Typically
  630. * invoked from ALSA/ASoC machine/platform driver.
  631. */
  632. struct sdw_stream_runtime *sdw_alloc_stream(char *stream_name)
  633. {
  634. struct sdw_stream_runtime *stream;
  635. stream = kzalloc(sizeof(*stream), GFP_KERNEL);
  636. if (!stream)
  637. return NULL;
  638. stream->name = stream_name;
  639. stream->state = SDW_STREAM_ALLOCATED;
  640. return stream;
  641. }
  642. EXPORT_SYMBOL(sdw_alloc_stream);
  643. /**
  644. * sdw_alloc_master_rt() - Allocates and initialize Master runtime handle
  645. *
  646. * @bus: SDW bus instance
  647. * @stream_config: Stream configuration
  648. * @stream: Stream runtime handle.
  649. *
  650. * This function is to be called with bus_lock held.
  651. */
  652. static struct sdw_master_runtime
  653. *sdw_alloc_master_rt(struct sdw_bus *bus,
  654. struct sdw_stream_config *stream_config,
  655. struct sdw_stream_runtime *stream)
  656. {
  657. struct sdw_master_runtime *m_rt;
  658. m_rt = stream->m_rt;
  659. /*
  660. * check if Master is already allocated (as a result of Slave adding
  661. * it first), if so skip allocation and go to configure
  662. */
  663. if (m_rt)
  664. goto stream_config;
  665. m_rt = kzalloc(sizeof(*m_rt), GFP_KERNEL);
  666. if (!m_rt)
  667. return NULL;
  668. /* Initialization of Master runtime handle */
  669. INIT_LIST_HEAD(&m_rt->port_list);
  670. INIT_LIST_HEAD(&m_rt->slave_rt_list);
  671. stream->m_rt = m_rt;
  672. list_add_tail(&m_rt->bus_node, &bus->m_rt_list);
  673. stream_config:
  674. m_rt->ch_count = stream_config->ch_count;
  675. m_rt->bus = bus;
  676. m_rt->stream = stream;
  677. m_rt->direction = stream_config->direction;
  678. return m_rt;
  679. }
  680. /**
  681. * sdw_alloc_slave_rt() - Allocate and initialize Slave runtime handle.
  682. *
  683. * @slave: Slave handle
  684. * @stream_config: Stream configuration
  685. * @stream: Stream runtime handle
  686. *
  687. * This function is to be called with bus_lock held.
  688. */
  689. static struct sdw_slave_runtime
  690. *sdw_alloc_slave_rt(struct sdw_slave *slave,
  691. struct sdw_stream_config *stream_config,
  692. struct sdw_stream_runtime *stream)
  693. {
  694. struct sdw_slave_runtime *s_rt = NULL;
  695. s_rt = kzalloc(sizeof(*s_rt), GFP_KERNEL);
  696. if (!s_rt)
  697. return NULL;
  698. INIT_LIST_HEAD(&s_rt->port_list);
  699. s_rt->ch_count = stream_config->ch_count;
  700. s_rt->direction = stream_config->direction;
  701. s_rt->slave = slave;
  702. return s_rt;
  703. }
  704. static void sdw_master_port_release(struct sdw_bus *bus,
  705. struct sdw_master_runtime *m_rt)
  706. {
  707. struct sdw_port_runtime *p_rt, *_p_rt;
  708. list_for_each_entry_safe(p_rt, _p_rt,
  709. &m_rt->port_list, port_node) {
  710. list_del(&p_rt->port_node);
  711. kfree(p_rt);
  712. }
  713. }
  714. static void sdw_slave_port_release(struct sdw_bus *bus,
  715. struct sdw_slave *slave,
  716. struct sdw_stream_runtime *stream)
  717. {
  718. struct sdw_port_runtime *p_rt, *_p_rt;
  719. struct sdw_master_runtime *m_rt = stream->m_rt;
  720. struct sdw_slave_runtime *s_rt;
  721. list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node) {
  722. if (s_rt->slave != slave)
  723. continue;
  724. list_for_each_entry_safe(p_rt, _p_rt,
  725. &s_rt->port_list, port_node) {
  726. list_del(&p_rt->port_node);
  727. kfree(p_rt);
  728. }
  729. }
  730. }
  731. /**
  732. * sdw_release_slave_stream() - Free Slave(s) runtime handle
  733. *
  734. * @slave: Slave handle.
  735. * @stream: Stream runtime handle.
  736. *
  737. * This function is to be called with bus_lock held.
  738. */
  739. static void sdw_release_slave_stream(struct sdw_slave *slave,
  740. struct sdw_stream_runtime *stream)
  741. {
  742. struct sdw_slave_runtime *s_rt, *_s_rt;
  743. struct sdw_master_runtime *m_rt = stream->m_rt;
  744. /* Retrieve Slave runtime handle */
  745. list_for_each_entry_safe(s_rt, _s_rt,
  746. &m_rt->slave_rt_list, m_rt_node) {
  747. if (s_rt->slave == slave) {
  748. list_del(&s_rt->m_rt_node);
  749. kfree(s_rt);
  750. return;
  751. }
  752. }
  753. }
  754. /**
  755. * sdw_release_master_stream() - Free Master runtime handle
  756. *
  757. * @stream: Stream runtime handle.
  758. *
  759. * This function is to be called with bus_lock held
  760. * It frees the Master runtime handle and associated Slave(s) runtime
  761. * handle. If this is called first then sdw_release_slave_stream() will have
  762. * no effect as Slave(s) runtime handle would already be freed up.
  763. */
  764. static void sdw_release_master_stream(struct sdw_stream_runtime *stream)
  765. {
  766. struct sdw_master_runtime *m_rt = stream->m_rt;
  767. struct sdw_slave_runtime *s_rt, *_s_rt;
  768. list_for_each_entry_safe(s_rt, _s_rt,
  769. &m_rt->slave_rt_list, m_rt_node)
  770. sdw_stream_remove_slave(s_rt->slave, stream);
  771. list_del(&m_rt->bus_node);
  772. }
  773. /**
  774. * sdw_stream_remove_master() - Remove master from sdw_stream
  775. *
  776. * @bus: SDW Bus instance
  777. * @stream: SoundWire stream
  778. *
  779. * This removes and frees port_rt and master_rt from a stream
  780. */
  781. int sdw_stream_remove_master(struct sdw_bus *bus,
  782. struct sdw_stream_runtime *stream)
  783. {
  784. mutex_lock(&bus->bus_lock);
  785. sdw_release_master_stream(stream);
  786. sdw_master_port_release(bus, stream->m_rt);
  787. stream->state = SDW_STREAM_RELEASED;
  788. kfree(stream->m_rt);
  789. stream->m_rt = NULL;
  790. mutex_unlock(&bus->bus_lock);
  791. return 0;
  792. }
  793. EXPORT_SYMBOL(sdw_stream_remove_master);
  794. /**
  795. * sdw_stream_remove_slave() - Remove slave from sdw_stream
  796. *
  797. * @slave: SDW Slave instance
  798. * @stream: SoundWire stream
  799. *
  800. * This removes and frees port_rt and slave_rt from a stream
  801. */
  802. int sdw_stream_remove_slave(struct sdw_slave *slave,
  803. struct sdw_stream_runtime *stream)
  804. {
  805. mutex_lock(&slave->bus->bus_lock);
  806. sdw_slave_port_release(slave->bus, slave, stream);
  807. sdw_release_slave_stream(slave, stream);
  808. mutex_unlock(&slave->bus->bus_lock);
  809. return 0;
  810. }
  811. EXPORT_SYMBOL(sdw_stream_remove_slave);
  812. /**
  813. * sdw_config_stream() - Configure the allocated stream
  814. *
  815. * @dev: SDW device
  816. * @stream: SoundWire stream
  817. * @stream_config: Stream configuration for audio stream
  818. * @is_slave: is API called from Slave or Master
  819. *
  820. * This function is to be called with bus_lock held.
  821. */
  822. static int sdw_config_stream(struct device *dev,
  823. struct sdw_stream_runtime *stream,
  824. struct sdw_stream_config *stream_config, bool is_slave)
  825. {
  826. /*
  827. * Update the stream rate, channel and bps based on data
  828. * source. For more than one data source (multilink),
  829. * match the rate, bps, stream type and increment number of channels.
  830. *
  831. * If rate/bps is zero, it means the values are not set, so skip
  832. * comparison and allow the value to be set and stored in stream
  833. */
  834. if (stream->params.rate &&
  835. stream->params.rate != stream_config->frame_rate) {
  836. dev_err(dev, "rate not matching, stream:%s", stream->name);
  837. return -EINVAL;
  838. }
  839. if (stream->params.bps &&
  840. stream->params.bps != stream_config->bps) {
  841. dev_err(dev, "bps not matching, stream:%s", stream->name);
  842. return -EINVAL;
  843. }
  844. stream->type = stream_config->type;
  845. stream->params.rate = stream_config->frame_rate;
  846. stream->params.bps = stream_config->bps;
  847. /* TODO: Update this check during Device-device support */
  848. if (is_slave)
  849. stream->params.ch_count += stream_config->ch_count;
  850. return 0;
  851. }
  852. static int sdw_is_valid_port_range(struct device *dev,
  853. struct sdw_port_runtime *p_rt)
  854. {
  855. if (!SDW_VALID_PORT_RANGE(p_rt->num)) {
  856. dev_err(dev,
  857. "SoundWire: Invalid port number :%d", p_rt->num);
  858. return -EINVAL;
  859. }
  860. return 0;
  861. }
  862. static struct sdw_port_runtime *sdw_port_alloc(struct device *dev,
  863. struct sdw_port_config *port_config,
  864. int port_index)
  865. {
  866. struct sdw_port_runtime *p_rt;
  867. p_rt = kzalloc(sizeof(*p_rt), GFP_KERNEL);
  868. if (!p_rt)
  869. return NULL;
  870. p_rt->ch_mask = port_config[port_index].ch_mask;
  871. p_rt->num = port_config[port_index].num;
  872. return p_rt;
  873. }
  874. static int sdw_master_port_config(struct sdw_bus *bus,
  875. struct sdw_master_runtime *m_rt,
  876. struct sdw_port_config *port_config,
  877. unsigned int num_ports)
  878. {
  879. struct sdw_port_runtime *p_rt;
  880. int i;
  881. /* Iterate for number of ports to perform initialization */
  882. for (i = 0; i < num_ports; i++) {
  883. p_rt = sdw_port_alloc(bus->dev, port_config, i);
  884. if (!p_rt)
  885. return -ENOMEM;
  886. /*
  887. * TODO: Check port capabilities for requested
  888. * configuration (audio mode support)
  889. */
  890. list_add_tail(&p_rt->port_node, &m_rt->port_list);
  891. }
  892. return 0;
  893. }
  894. static int sdw_slave_port_config(struct sdw_slave *slave,
  895. struct sdw_slave_runtime *s_rt,
  896. struct sdw_port_config *port_config,
  897. unsigned int num_config)
  898. {
  899. struct sdw_port_runtime *p_rt;
  900. int i, ret;
  901. /* Iterate for number of ports to perform initialization */
  902. for (i = 0; i < num_config; i++) {
  903. p_rt = sdw_port_alloc(&slave->dev, port_config, i);
  904. if (!p_rt)
  905. return -ENOMEM;
  906. /*
  907. * TODO: Check valid port range as defined by DisCo/
  908. * slave
  909. */
  910. ret = sdw_is_valid_port_range(&slave->dev, p_rt);
  911. if (ret < 0) {
  912. kfree(p_rt);
  913. return ret;
  914. }
  915. /*
  916. * TODO: Check port capabilities for requested
  917. * configuration (audio mode support)
  918. */
  919. list_add_tail(&p_rt->port_node, &s_rt->port_list);
  920. }
  921. return 0;
  922. }
  923. /**
  924. * sdw_stream_add_master() - Allocate and add master runtime to a stream
  925. *
  926. * @bus: SDW Bus instance
  927. * @stream_config: Stream configuration for audio stream
  928. * @port_config: Port configuration for audio stream
  929. * @num_ports: Number of ports
  930. * @stream: SoundWire stream
  931. */
  932. int sdw_stream_add_master(struct sdw_bus *bus,
  933. struct sdw_stream_config *stream_config,
  934. struct sdw_port_config *port_config,
  935. unsigned int num_ports,
  936. struct sdw_stream_runtime *stream)
  937. {
  938. struct sdw_master_runtime *m_rt = NULL;
  939. int ret;
  940. mutex_lock(&bus->bus_lock);
  941. m_rt = sdw_alloc_master_rt(bus, stream_config, stream);
  942. if (!m_rt) {
  943. dev_err(bus->dev,
  944. "Master runtime config failed for stream:%s",
  945. stream->name);
  946. ret = -ENOMEM;
  947. goto error;
  948. }
  949. ret = sdw_config_stream(bus->dev, stream, stream_config, false);
  950. if (ret)
  951. goto stream_error;
  952. ret = sdw_master_port_config(bus, m_rt, port_config, num_ports);
  953. if (ret)
  954. goto stream_error;
  955. stream->state = SDW_STREAM_CONFIGURED;
  956. stream_error:
  957. sdw_release_master_stream(stream);
  958. error:
  959. mutex_unlock(&bus->bus_lock);
  960. return ret;
  961. }
  962. EXPORT_SYMBOL(sdw_stream_add_master);
  963. /**
  964. * sdw_stream_add_slave() - Allocate and add master/slave runtime to a stream
  965. *
  966. * @slave: SDW Slave instance
  967. * @stream_config: Stream configuration for audio stream
  968. * @stream: SoundWire stream
  969. * @port_config: Port configuration for audio stream
  970. * @num_ports: Number of ports
  971. */
  972. int sdw_stream_add_slave(struct sdw_slave *slave,
  973. struct sdw_stream_config *stream_config,
  974. struct sdw_port_config *port_config,
  975. unsigned int num_ports,
  976. struct sdw_stream_runtime *stream)
  977. {
  978. struct sdw_slave_runtime *s_rt;
  979. struct sdw_master_runtime *m_rt;
  980. int ret;
  981. mutex_lock(&slave->bus->bus_lock);
  982. /*
  983. * If this API is invoked by Slave first then m_rt is not valid.
  984. * So, allocate m_rt and add Slave to it.
  985. */
  986. m_rt = sdw_alloc_master_rt(slave->bus, stream_config, stream);
  987. if (!m_rt) {
  988. dev_err(&slave->dev,
  989. "alloc master runtime failed for stream:%s",
  990. stream->name);
  991. ret = -ENOMEM;
  992. goto error;
  993. }
  994. s_rt = sdw_alloc_slave_rt(slave, stream_config, stream);
  995. if (!s_rt) {
  996. dev_err(&slave->dev,
  997. "Slave runtime config failed for stream:%s",
  998. stream->name);
  999. ret = -ENOMEM;
  1000. goto stream_error;
  1001. }
  1002. ret = sdw_config_stream(&slave->dev, stream, stream_config, true);
  1003. if (ret)
  1004. goto stream_error;
  1005. list_add_tail(&s_rt->m_rt_node, &m_rt->slave_rt_list);
  1006. ret = sdw_slave_port_config(slave, s_rt, port_config, num_ports);
  1007. if (ret)
  1008. goto stream_error;
  1009. stream->state = SDW_STREAM_CONFIGURED;
  1010. goto error;
  1011. stream_error:
  1012. /*
  1013. * we hit error so cleanup the stream, release all Slave(s) and
  1014. * Master runtime
  1015. */
  1016. sdw_release_master_stream(stream);
  1017. error:
  1018. mutex_unlock(&slave->bus->bus_lock);
  1019. return ret;
  1020. }
  1021. EXPORT_SYMBOL(sdw_stream_add_slave);
  1022. /**
  1023. * sdw_get_slave_dpn_prop() - Get Slave port capabilities
  1024. *
  1025. * @slave: Slave handle
  1026. * @direction: Data direction.
  1027. * @port_num: Port number
  1028. */
  1029. struct sdw_dpn_prop *sdw_get_slave_dpn_prop(struct sdw_slave *slave,
  1030. enum sdw_data_direction direction,
  1031. unsigned int port_num)
  1032. {
  1033. struct sdw_dpn_prop *dpn_prop;
  1034. u8 num_ports;
  1035. int i;
  1036. if (direction == SDW_DATA_DIR_TX) {
  1037. num_ports = hweight32(slave->prop.source_ports);
  1038. dpn_prop = slave->prop.src_dpn_prop;
  1039. } else {
  1040. num_ports = hweight32(slave->prop.sink_ports);
  1041. dpn_prop = slave->prop.sink_dpn_prop;
  1042. }
  1043. for (i = 0; i < num_ports; i++) {
  1044. dpn_prop = &dpn_prop[i];
  1045. if (dpn_prop->num == port_num)
  1046. return &dpn_prop[i];
  1047. }
  1048. return NULL;
  1049. }
  1050. static int _sdw_prepare_stream(struct sdw_stream_runtime *stream)
  1051. {
  1052. struct sdw_master_runtime *m_rt = stream->m_rt;
  1053. struct sdw_bus *bus = m_rt->bus;
  1054. struct sdw_master_prop *prop = NULL;
  1055. struct sdw_bus_params params;
  1056. int ret;
  1057. prop = &bus->prop;
  1058. memcpy(&params, &bus->params, sizeof(params));
  1059. /* TODO: Support Asynchronous mode */
  1060. if ((prop->max_freq % stream->params.rate) != 0) {
  1061. dev_err(bus->dev, "Async mode not supported");
  1062. return -EINVAL;
  1063. }
  1064. /* Increment cumulative bus bandwidth */
  1065. /* TODO: Update this during Device-Device support */
  1066. bus->params.bandwidth += m_rt->stream->params.rate *
  1067. m_rt->ch_count * m_rt->stream->params.bps;
  1068. /* Program params */
  1069. ret = sdw_program_params(bus);
  1070. if (ret < 0) {
  1071. dev_err(bus->dev, "Program params failed: %d", ret);
  1072. goto restore_params;
  1073. }
  1074. ret = do_bank_switch(stream);
  1075. if (ret < 0) {
  1076. dev_err(bus->dev, "Bank switch failed: %d", ret);
  1077. goto restore_params;
  1078. }
  1079. /* Prepare port(s) on the new clock configuration */
  1080. ret = sdw_prep_deprep_ports(m_rt, true);
  1081. if (ret < 0) {
  1082. dev_err(bus->dev, "Prepare port(s) failed ret = %d",
  1083. ret);
  1084. return ret;
  1085. }
  1086. stream->state = SDW_STREAM_PREPARED;
  1087. return ret;
  1088. restore_params:
  1089. memcpy(&bus->params, &params, sizeof(params));
  1090. return ret;
  1091. }
  1092. /**
  1093. * sdw_prepare_stream() - Prepare SoundWire stream
  1094. *
  1095. * @stream: Soundwire stream
  1096. *
  1097. * Documentation/driver-api/soundwire/stream.rst explains this API in detail
  1098. */
  1099. int sdw_prepare_stream(struct sdw_stream_runtime *stream)
  1100. {
  1101. int ret = 0;
  1102. if (!stream) {
  1103. pr_err("SoundWire: Handle not found for stream");
  1104. return -EINVAL;
  1105. }
  1106. mutex_lock(&stream->m_rt->bus->bus_lock);
  1107. ret = _sdw_prepare_stream(stream);
  1108. if (ret < 0)
  1109. pr_err("Prepare for stream:%s failed: %d", stream->name, ret);
  1110. mutex_unlock(&stream->m_rt->bus->bus_lock);
  1111. return ret;
  1112. }
  1113. EXPORT_SYMBOL(sdw_prepare_stream);
  1114. static int _sdw_enable_stream(struct sdw_stream_runtime *stream)
  1115. {
  1116. struct sdw_master_runtime *m_rt = stream->m_rt;
  1117. struct sdw_bus *bus = m_rt->bus;
  1118. int ret;
  1119. /* Program params */
  1120. ret = sdw_program_params(bus);
  1121. if (ret < 0) {
  1122. dev_err(bus->dev, "Program params failed: %d", ret);
  1123. return ret;
  1124. }
  1125. /* Enable port(s) */
  1126. ret = sdw_enable_disable_ports(m_rt, true);
  1127. if (ret < 0) {
  1128. dev_err(bus->dev, "Enable port(s) failed ret: %d", ret);
  1129. return ret;
  1130. }
  1131. ret = do_bank_switch(stream);
  1132. if (ret < 0) {
  1133. dev_err(bus->dev, "Bank switch failed: %d", ret);
  1134. return ret;
  1135. }
  1136. stream->state = SDW_STREAM_ENABLED;
  1137. return 0;
  1138. }
  1139. /**
  1140. * sdw_enable_stream() - Enable SoundWire stream
  1141. *
  1142. * @stream: Soundwire stream
  1143. *
  1144. * Documentation/driver-api/soundwire/stream.rst explains this API in detail
  1145. */
  1146. int sdw_enable_stream(struct sdw_stream_runtime *stream)
  1147. {
  1148. int ret = 0;
  1149. if (!stream) {
  1150. pr_err("SoundWire: Handle not found for stream");
  1151. return -EINVAL;
  1152. }
  1153. mutex_lock(&stream->m_rt->bus->bus_lock);
  1154. ret = _sdw_enable_stream(stream);
  1155. if (ret < 0)
  1156. pr_err("Enable for stream:%s failed: %d", stream->name, ret);
  1157. mutex_unlock(&stream->m_rt->bus->bus_lock);
  1158. return ret;
  1159. }
  1160. EXPORT_SYMBOL(sdw_enable_stream);
  1161. static int _sdw_disable_stream(struct sdw_stream_runtime *stream)
  1162. {
  1163. struct sdw_master_runtime *m_rt = stream->m_rt;
  1164. struct sdw_bus *bus = m_rt->bus;
  1165. int ret;
  1166. /* Disable port(s) */
  1167. ret = sdw_enable_disable_ports(m_rt, false);
  1168. if (ret < 0) {
  1169. dev_err(bus->dev, "Disable port(s) failed: %d", ret);
  1170. return ret;
  1171. }
  1172. stream->state = SDW_STREAM_DISABLED;
  1173. /* Program params */
  1174. ret = sdw_program_params(bus);
  1175. if (ret < 0) {
  1176. dev_err(bus->dev, "Program params failed: %d", ret);
  1177. return ret;
  1178. }
  1179. return do_bank_switch(stream);
  1180. }
  1181. /**
  1182. * sdw_disable_stream() - Disable SoundWire stream
  1183. *
  1184. * @stream: Soundwire stream
  1185. *
  1186. * Documentation/driver-api/soundwire/stream.rst explains this API in detail
  1187. */
  1188. int sdw_disable_stream(struct sdw_stream_runtime *stream)
  1189. {
  1190. int ret = 0;
  1191. if (!stream) {
  1192. pr_err("SoundWire: Handle not found for stream");
  1193. return -EINVAL;
  1194. }
  1195. mutex_lock(&stream->m_rt->bus->bus_lock);
  1196. ret = _sdw_disable_stream(stream);
  1197. if (ret < 0)
  1198. pr_err("Disable for stream:%s failed: %d", stream->name, ret);
  1199. mutex_unlock(&stream->m_rt->bus->bus_lock);
  1200. return ret;
  1201. }
  1202. EXPORT_SYMBOL(sdw_disable_stream);
  1203. static int _sdw_deprepare_stream(struct sdw_stream_runtime *stream)
  1204. {
  1205. struct sdw_master_runtime *m_rt = stream->m_rt;
  1206. struct sdw_bus *bus = m_rt->bus;
  1207. int ret = 0;
  1208. /* De-prepare port(s) */
  1209. ret = sdw_prep_deprep_ports(m_rt, false);
  1210. if (ret < 0) {
  1211. dev_err(bus->dev, "De-prepare port(s) failed: %d", ret);
  1212. return ret;
  1213. }
  1214. stream->state = SDW_STREAM_DEPREPARED;
  1215. /* TODO: Update this during Device-Device support */
  1216. bus->params.bandwidth -= m_rt->stream->params.rate *
  1217. m_rt->ch_count * m_rt->stream->params.bps;
  1218. /* Program params */
  1219. ret = sdw_program_params(bus);
  1220. if (ret < 0) {
  1221. dev_err(bus->dev, "Program params failed: %d", ret);
  1222. return ret;
  1223. }
  1224. return do_bank_switch(stream);
  1225. }
  1226. /**
  1227. * sdw_deprepare_stream() - Deprepare SoundWire stream
  1228. *
  1229. * @stream: Soundwire stream
  1230. *
  1231. * Documentation/driver-api/soundwire/stream.rst explains this API in detail
  1232. */
  1233. int sdw_deprepare_stream(struct sdw_stream_runtime *stream)
  1234. {
  1235. int ret = 0;
  1236. if (!stream) {
  1237. pr_err("SoundWire: Handle not found for stream");
  1238. return -EINVAL;
  1239. }
  1240. mutex_lock(&stream->m_rt->bus->bus_lock);
  1241. ret = _sdw_deprepare_stream(stream);
  1242. if (ret < 0)
  1243. pr_err("De-prepare for stream:%d failed: %d", ret, ret);
  1244. mutex_unlock(&stream->m_rt->bus->bus_lock);
  1245. return ret;
  1246. }
  1247. EXPORT_SYMBOL(sdw_deprepare_stream);