mtk-cmdq-helper.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537
  1. // SPDX-License-Identifier: GPL-2.0
  2. //
  3. // Copyright (c) 2018 MediaTek Inc.
  4. #include <linux/completion.h>
  5. #include <linux/errno.h>
  6. #include <linux/dma-mapping.h>
  7. #include <linux/module.h>
  8. #include <linux/mailbox_controller.h>
  9. #include <linux/soc/mediatek/mtk-cmdq.h>
  10. #define CMDQ_WRITE_ENABLE_MASK BIT(0)
  11. #define CMDQ_POLL_ENABLE_MASK BIT(0)
  12. #define CMDQ_EOC_IRQ_EN BIT(0)
  13. #define CMDQ_REG_TYPE 1
  14. #define CMDQ_JUMP_RELATIVE 1
  15. struct cmdq_instruction {
  16. union {
  17. u32 value;
  18. u32 mask;
  19. struct {
  20. u16 arg_c;
  21. u16 src_reg;
  22. };
  23. };
  24. union {
  25. u16 offset;
  26. u16 event;
  27. u16 reg_dst;
  28. };
  29. union {
  30. u8 subsys;
  31. struct {
  32. u8 sop:5;
  33. u8 arg_c_t:1;
  34. u8 src_t:1;
  35. u8 dst_t:1;
  36. };
  37. };
  38. u8 op;
  39. };
  40. int cmdq_dev_get_client_reg(struct device *dev,
  41. struct cmdq_client_reg *client_reg, int idx)
  42. {
  43. struct of_phandle_args spec;
  44. int err;
  45. if (!client_reg)
  46. return -ENOENT;
  47. err = of_parse_phandle_with_fixed_args(dev->of_node,
  48. "mediatek,gce-client-reg",
  49. 3, idx, &spec);
  50. if (err < 0) {
  51. dev_err(dev,
  52. "error %d can't parse gce-client-reg property (%d)",
  53. err, idx);
  54. return err;
  55. }
  56. client_reg->subsys = (u8)spec.args[0];
  57. client_reg->offset = (u16)spec.args[1];
  58. client_reg->size = (u16)spec.args[2];
  59. of_node_put(spec.np);
  60. return 0;
  61. }
  62. EXPORT_SYMBOL(cmdq_dev_get_client_reg);
  63. static void cmdq_client_timeout(struct timer_list *t)
  64. {
  65. struct cmdq_client *client = from_timer(client, t, timer);
  66. dev_err(client->client.dev, "cmdq timeout!\n");
  67. }
  68. struct cmdq_client *cmdq_mbox_create(struct device *dev, int index, u32 timeout)
  69. {
  70. struct cmdq_client *client;
  71. client = kzalloc(sizeof(*client), GFP_KERNEL);
  72. if (!client)
  73. return (struct cmdq_client *)-ENOMEM;
  74. client->timeout_ms = timeout;
  75. if (timeout != CMDQ_NO_TIMEOUT) {
  76. spin_lock_init(&client->lock);
  77. timer_setup(&client->timer, cmdq_client_timeout, 0);
  78. }
  79. client->pkt_cnt = 0;
  80. client->client.dev = dev;
  81. client->client.tx_block = false;
  82. client->client.knows_txdone = true;
  83. client->chan = mbox_request_channel(&client->client, index);
  84. if (IS_ERR(client->chan)) {
  85. long err;
  86. dev_err(dev, "failed to request channel\n");
  87. err = PTR_ERR(client->chan);
  88. kfree(client);
  89. return ERR_PTR(err);
  90. }
  91. return client;
  92. }
  93. EXPORT_SYMBOL(cmdq_mbox_create);
  94. void cmdq_mbox_destroy(struct cmdq_client *client)
  95. {
  96. if (client->timeout_ms != CMDQ_NO_TIMEOUT) {
  97. spin_lock(&client->lock);
  98. del_timer_sync(&client->timer);
  99. spin_unlock(&client->lock);
  100. }
  101. mbox_free_channel(client->chan);
  102. kfree(client);
  103. }
  104. EXPORT_SYMBOL(cmdq_mbox_destroy);
  105. struct cmdq_pkt *cmdq_pkt_create(struct cmdq_client *client, size_t size)
  106. {
  107. struct cmdq_pkt *pkt;
  108. struct device *dev;
  109. dma_addr_t dma_addr;
  110. pkt = kzalloc(sizeof(*pkt), GFP_KERNEL);
  111. if (!pkt)
  112. return ERR_PTR(-ENOMEM);
  113. pkt->va_base = kzalloc(size, GFP_KERNEL);
  114. if (!pkt->va_base) {
  115. kfree(pkt);
  116. return ERR_PTR(-ENOMEM);
  117. }
  118. pkt->buf_size = size;
  119. pkt->cl = (void *)client;
  120. dev = client->chan->mbox->dev;
  121. dma_addr = dma_map_single(dev, pkt->va_base, pkt->buf_size,
  122. DMA_TO_DEVICE);
  123. if (dma_mapping_error(dev, dma_addr)) {
  124. dev_err(dev, "dma map failed, size=%u\n", (u32)(u64)size);
  125. kfree(pkt->va_base);
  126. kfree(pkt);
  127. return ERR_PTR(-ENOMEM);
  128. }
  129. pkt->pa_base = dma_addr;
  130. return pkt;
  131. }
  132. EXPORT_SYMBOL(cmdq_pkt_create);
  133. void cmdq_pkt_destroy(struct cmdq_pkt *pkt)
  134. {
  135. struct cmdq_client *client = (struct cmdq_client *)pkt->cl;
  136. dma_unmap_single(client->chan->mbox->dev, pkt->pa_base, pkt->buf_size,
  137. DMA_TO_DEVICE);
  138. kfree(pkt->va_base);
  139. kfree(pkt);
  140. }
  141. EXPORT_SYMBOL(cmdq_pkt_destroy);
  142. static int cmdq_pkt_append_command(struct cmdq_pkt *pkt,
  143. struct cmdq_instruction inst)
  144. {
  145. struct cmdq_instruction *cmd_ptr;
  146. if (unlikely(pkt->cmd_buf_size + CMDQ_INST_SIZE > pkt->buf_size)) {
  147. /*
  148. * In the case of allocated buffer size (pkt->buf_size) is used
  149. * up, the real required size (pkt->cmdq_buf_size) is still
  150. * increased, so that the user knows how much memory should be
  151. * ultimately allocated after appending all commands and
  152. * flushing the command packet. Therefor, the user can call
  153. * cmdq_pkt_create() again with the real required buffer size.
  154. */
  155. pkt->cmd_buf_size += CMDQ_INST_SIZE;
  156. WARN_ONCE(1, "%s: buffer size %u is too small !\n",
  157. __func__, (u32)pkt->buf_size);
  158. return -ENOMEM;
  159. }
  160. cmd_ptr = pkt->va_base + pkt->cmd_buf_size;
  161. *cmd_ptr = inst;
  162. pkt->cmd_buf_size += CMDQ_INST_SIZE;
  163. return 0;
  164. }
  165. int cmdq_pkt_write(struct cmdq_pkt *pkt, u8 subsys, u16 offset, u32 value)
  166. {
  167. struct cmdq_instruction inst;
  168. inst.op = CMDQ_CODE_WRITE;
  169. inst.value = value;
  170. inst.offset = offset;
  171. inst.subsys = subsys;
  172. return cmdq_pkt_append_command(pkt, inst);
  173. }
  174. EXPORT_SYMBOL(cmdq_pkt_write);
  175. int cmdq_pkt_write_mask(struct cmdq_pkt *pkt, u8 subsys,
  176. u16 offset, u32 value, u32 mask)
  177. {
  178. struct cmdq_instruction inst = { {0} };
  179. u16 offset_mask = offset;
  180. int err;
  181. if (mask != 0xffffffff) {
  182. inst.op = CMDQ_CODE_MASK;
  183. inst.mask = ~mask;
  184. err = cmdq_pkt_append_command(pkt, inst);
  185. if (err < 0)
  186. return err;
  187. offset_mask |= CMDQ_WRITE_ENABLE_MASK;
  188. }
  189. err = cmdq_pkt_write(pkt, subsys, offset_mask, value);
  190. return err;
  191. }
  192. EXPORT_SYMBOL(cmdq_pkt_write_mask);
  193. int cmdq_pkt_read_s(struct cmdq_pkt *pkt, u16 high_addr_reg_idx, u16 addr_low,
  194. u16 reg_idx)
  195. {
  196. struct cmdq_instruction inst = {};
  197. inst.op = CMDQ_CODE_READ_S;
  198. inst.dst_t = CMDQ_REG_TYPE;
  199. inst.sop = high_addr_reg_idx;
  200. inst.reg_dst = reg_idx;
  201. inst.src_reg = addr_low;
  202. return cmdq_pkt_append_command(pkt, inst);
  203. }
  204. EXPORT_SYMBOL(cmdq_pkt_read_s);
  205. int cmdq_pkt_write_s(struct cmdq_pkt *pkt, u16 high_addr_reg_idx,
  206. u16 addr_low, u16 src_reg_idx)
  207. {
  208. struct cmdq_instruction inst = {};
  209. inst.op = CMDQ_CODE_WRITE_S;
  210. inst.src_t = CMDQ_REG_TYPE;
  211. inst.sop = high_addr_reg_idx;
  212. inst.offset = addr_low;
  213. inst.src_reg = src_reg_idx;
  214. return cmdq_pkt_append_command(pkt, inst);
  215. }
  216. EXPORT_SYMBOL(cmdq_pkt_write_s);
  217. int cmdq_pkt_write_s_mask(struct cmdq_pkt *pkt, u16 high_addr_reg_idx,
  218. u16 addr_low, u16 src_reg_idx, u32 mask)
  219. {
  220. struct cmdq_instruction inst = {};
  221. int err;
  222. inst.op = CMDQ_CODE_MASK;
  223. inst.mask = ~mask;
  224. err = cmdq_pkt_append_command(pkt, inst);
  225. if (err < 0)
  226. return err;
  227. inst.mask = 0;
  228. inst.op = CMDQ_CODE_WRITE_S_MASK;
  229. inst.src_t = CMDQ_REG_TYPE;
  230. inst.sop = high_addr_reg_idx;
  231. inst.offset = addr_low;
  232. inst.src_reg = src_reg_idx;
  233. return cmdq_pkt_append_command(pkt, inst);
  234. }
  235. EXPORT_SYMBOL(cmdq_pkt_write_s_mask);
  236. int cmdq_pkt_write_s_value(struct cmdq_pkt *pkt, u8 high_addr_reg_idx,
  237. u16 addr_low, u32 value)
  238. {
  239. struct cmdq_instruction inst = {};
  240. inst.op = CMDQ_CODE_WRITE_S;
  241. inst.sop = high_addr_reg_idx;
  242. inst.offset = addr_low;
  243. inst.value = value;
  244. return cmdq_pkt_append_command(pkt, inst);
  245. }
  246. EXPORT_SYMBOL(cmdq_pkt_write_s_value);
  247. int cmdq_pkt_write_s_mask_value(struct cmdq_pkt *pkt, u8 high_addr_reg_idx,
  248. u16 addr_low, u32 value, u32 mask)
  249. {
  250. struct cmdq_instruction inst = {};
  251. int err;
  252. inst.op = CMDQ_CODE_MASK;
  253. inst.mask = ~mask;
  254. err = cmdq_pkt_append_command(pkt, inst);
  255. if (err < 0)
  256. return err;
  257. inst.op = CMDQ_CODE_WRITE_S_MASK;
  258. inst.sop = high_addr_reg_idx;
  259. inst.offset = addr_low;
  260. inst.value = value;
  261. return cmdq_pkt_append_command(pkt, inst);
  262. }
  263. EXPORT_SYMBOL(cmdq_pkt_write_s_mask_value);
  264. int cmdq_pkt_wfe(struct cmdq_pkt *pkt, u16 event, bool clear)
  265. {
  266. struct cmdq_instruction inst = { {0} };
  267. u32 clear_option = clear ? CMDQ_WFE_UPDATE : 0;
  268. if (event >= CMDQ_MAX_EVENT)
  269. return -EINVAL;
  270. inst.op = CMDQ_CODE_WFE;
  271. inst.value = CMDQ_WFE_OPTION | clear_option;
  272. inst.event = event;
  273. return cmdq_pkt_append_command(pkt, inst);
  274. }
  275. EXPORT_SYMBOL(cmdq_pkt_wfe);
  276. int cmdq_pkt_clear_event(struct cmdq_pkt *pkt, u16 event)
  277. {
  278. struct cmdq_instruction inst = { {0} };
  279. if (event >= CMDQ_MAX_EVENT)
  280. return -EINVAL;
  281. inst.op = CMDQ_CODE_WFE;
  282. inst.value = CMDQ_WFE_UPDATE;
  283. inst.event = event;
  284. return cmdq_pkt_append_command(pkt, inst);
  285. }
  286. EXPORT_SYMBOL(cmdq_pkt_clear_event);
  287. int cmdq_pkt_set_event(struct cmdq_pkt *pkt, u16 event)
  288. {
  289. struct cmdq_instruction inst = {};
  290. if (event >= CMDQ_MAX_EVENT)
  291. return -EINVAL;
  292. inst.op = CMDQ_CODE_WFE;
  293. inst.value = CMDQ_WFE_UPDATE | CMDQ_WFE_UPDATE_VALUE;
  294. inst.event = event;
  295. return cmdq_pkt_append_command(pkt, inst);
  296. }
  297. EXPORT_SYMBOL(cmdq_pkt_set_event);
  298. int cmdq_pkt_poll(struct cmdq_pkt *pkt, u8 subsys,
  299. u16 offset, u32 value)
  300. {
  301. struct cmdq_instruction inst = { {0} };
  302. int err;
  303. inst.op = CMDQ_CODE_POLL;
  304. inst.value = value;
  305. inst.offset = offset;
  306. inst.subsys = subsys;
  307. err = cmdq_pkt_append_command(pkt, inst);
  308. return err;
  309. }
  310. EXPORT_SYMBOL(cmdq_pkt_poll);
  311. int cmdq_pkt_poll_mask(struct cmdq_pkt *pkt, u8 subsys,
  312. u16 offset, u32 value, u32 mask)
  313. {
  314. struct cmdq_instruction inst = { {0} };
  315. int err;
  316. inst.op = CMDQ_CODE_MASK;
  317. inst.mask = ~mask;
  318. err = cmdq_pkt_append_command(pkt, inst);
  319. if (err < 0)
  320. return err;
  321. offset = offset | CMDQ_POLL_ENABLE_MASK;
  322. err = cmdq_pkt_poll(pkt, subsys, offset, value);
  323. return err;
  324. }
  325. EXPORT_SYMBOL(cmdq_pkt_poll_mask);
  326. int cmdq_pkt_assign(struct cmdq_pkt *pkt, u16 reg_idx, u32 value)
  327. {
  328. struct cmdq_instruction inst = {};
  329. inst.op = CMDQ_CODE_LOGIC;
  330. inst.dst_t = CMDQ_REG_TYPE;
  331. inst.reg_dst = reg_idx;
  332. inst.value = value;
  333. return cmdq_pkt_append_command(pkt, inst);
  334. }
  335. EXPORT_SYMBOL(cmdq_pkt_assign);
  336. int cmdq_pkt_jump(struct cmdq_pkt *pkt, dma_addr_t addr)
  337. {
  338. struct cmdq_instruction inst = {};
  339. inst.op = CMDQ_CODE_JUMP;
  340. inst.offset = CMDQ_JUMP_RELATIVE;
  341. inst.value = addr >>
  342. cmdq_get_shift_pa(((struct cmdq_client *)pkt->cl)->chan);
  343. return cmdq_pkt_append_command(pkt, inst);
  344. }
  345. EXPORT_SYMBOL(cmdq_pkt_jump);
  346. int cmdq_pkt_finalize(struct cmdq_pkt *pkt)
  347. {
  348. struct cmdq_instruction inst = { {0} };
  349. int err;
  350. /* insert EOC and generate IRQ for each command iteration */
  351. inst.op = CMDQ_CODE_EOC;
  352. inst.value = CMDQ_EOC_IRQ_EN;
  353. err = cmdq_pkt_append_command(pkt, inst);
  354. if (err < 0)
  355. return err;
  356. /* JUMP to end */
  357. inst.op = CMDQ_CODE_JUMP;
  358. inst.value = CMDQ_JUMP_PASS >>
  359. cmdq_get_shift_pa(((struct cmdq_client *)pkt->cl)->chan);
  360. err = cmdq_pkt_append_command(pkt, inst);
  361. return err;
  362. }
  363. EXPORT_SYMBOL(cmdq_pkt_finalize);
  364. static void cmdq_pkt_flush_async_cb(struct cmdq_cb_data data)
  365. {
  366. struct cmdq_pkt *pkt = (struct cmdq_pkt *)data.data;
  367. struct cmdq_task_cb *cb = &pkt->cb;
  368. struct cmdq_client *client = (struct cmdq_client *)pkt->cl;
  369. if (client->timeout_ms != CMDQ_NO_TIMEOUT) {
  370. unsigned long flags = 0;
  371. spin_lock_irqsave(&client->lock, flags);
  372. if (--client->pkt_cnt == 0)
  373. del_timer(&client->timer);
  374. else
  375. mod_timer(&client->timer, jiffies +
  376. msecs_to_jiffies(client->timeout_ms));
  377. spin_unlock_irqrestore(&client->lock, flags);
  378. }
  379. dma_sync_single_for_cpu(client->chan->mbox->dev, pkt->pa_base,
  380. pkt->cmd_buf_size, DMA_TO_DEVICE);
  381. if (cb->cb) {
  382. data.data = cb->data;
  383. cb->cb(data);
  384. }
  385. }
  386. int cmdq_pkt_flush_async(struct cmdq_pkt *pkt, cmdq_async_flush_cb cb,
  387. void *data)
  388. {
  389. int err;
  390. unsigned long flags = 0;
  391. struct cmdq_client *client = (struct cmdq_client *)pkt->cl;
  392. pkt->cb.cb = cb;
  393. pkt->cb.data = data;
  394. pkt->async_cb.cb = cmdq_pkt_flush_async_cb;
  395. pkt->async_cb.data = pkt;
  396. dma_sync_single_for_device(client->chan->mbox->dev, pkt->pa_base,
  397. pkt->cmd_buf_size, DMA_TO_DEVICE);
  398. if (client->timeout_ms != CMDQ_NO_TIMEOUT) {
  399. spin_lock_irqsave(&client->lock, flags);
  400. if (client->pkt_cnt++ == 0)
  401. mod_timer(&client->timer, jiffies +
  402. msecs_to_jiffies(client->timeout_ms));
  403. spin_unlock_irqrestore(&client->lock, flags);
  404. }
  405. err = mbox_send_message(client->chan, pkt);
  406. if (err < 0)
  407. return err;
  408. /* We can send next packet immediately, so just call txdone. */
  409. mbox_client_txdone(client->chan, 0);
  410. return 0;
  411. }
  412. EXPORT_SYMBOL(cmdq_pkt_flush_async);
  413. struct cmdq_flush_completion {
  414. struct completion cmplt;
  415. bool err;
  416. };
  417. static void cmdq_pkt_flush_cb(struct cmdq_cb_data data)
  418. {
  419. struct cmdq_flush_completion *cmplt;
  420. cmplt = (struct cmdq_flush_completion *)data.data;
  421. if (data.sta != CMDQ_CB_NORMAL)
  422. cmplt->err = true;
  423. else
  424. cmplt->err = false;
  425. complete(&cmplt->cmplt);
  426. }
  427. int cmdq_pkt_flush(struct cmdq_pkt *pkt)
  428. {
  429. struct cmdq_flush_completion cmplt;
  430. int err;
  431. init_completion(&cmplt.cmplt);
  432. err = cmdq_pkt_flush_async(pkt, cmdq_pkt_flush_cb, &cmplt);
  433. if (err < 0)
  434. return err;
  435. wait_for_completion(&cmplt.cmplt);
  436. return cmplt.err ? -EFAULT : 0;
  437. }
  438. EXPORT_SYMBOL(cmdq_pkt_flush);
  439. MODULE_LICENSE("GPL v2");