dpio.c 3.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158
  1. /*
  2. * Copyright (C) 2013-2015 Freescale Semiconductor
  3. *
  4. * SPDX-License-Identifier: GPL-2.0+
  5. */
  6. #include <fsl-mc/fsl_mc_sys.h>
  7. #include <fsl-mc/fsl_mc_cmd.h>
  8. #include <fsl-mc/fsl_dpio.h>
  9. int dpio_open(struct fsl_mc_io *mc_io,
  10. uint32_t cmd_flags,
  11. int dpio_id,
  12. uint16_t *token)
  13. {
  14. struct mc_command cmd = { 0 };
  15. int err;
  16. /* prepare command */
  17. cmd.header = mc_encode_cmd_header(DPIO_CMDID_OPEN,
  18. cmd_flags,
  19. 0);
  20. DPIO_CMD_OPEN(cmd, dpio_id);
  21. /* send command to mc*/
  22. err = mc_send_command(mc_io, &cmd);
  23. if (err)
  24. return err;
  25. /* retrieve response parameters */
  26. *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
  27. return 0;
  28. }
  29. int dpio_close(struct fsl_mc_io *mc_io,
  30. uint32_t cmd_flags,
  31. uint16_t token)
  32. {
  33. struct mc_command cmd = { 0 };
  34. /* prepare command */
  35. cmd.header = mc_encode_cmd_header(DPIO_CMDID_CLOSE,
  36. cmd_flags,
  37. token);
  38. /* send command to mc*/
  39. return mc_send_command(mc_io, &cmd);
  40. }
  41. int dpio_create(struct fsl_mc_io *mc_io,
  42. uint32_t cmd_flags,
  43. const struct dpio_cfg *cfg,
  44. uint16_t *token)
  45. {
  46. struct mc_command cmd = { 0 };
  47. int err;
  48. /* prepare command */
  49. cmd.header = mc_encode_cmd_header(DPIO_CMDID_CREATE,
  50. cmd_flags,
  51. 0);
  52. DPIO_CMD_CREATE(cmd, cfg);
  53. /* send command to mc*/
  54. err = mc_send_command(mc_io, &cmd);
  55. if (err)
  56. return err;
  57. /* retrieve response parameters */
  58. *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
  59. return 0;
  60. }
  61. int dpio_destroy(struct fsl_mc_io *mc_io,
  62. uint32_t cmd_flags,
  63. uint16_t token)
  64. {
  65. struct mc_command cmd = { 0 };
  66. /* prepare command */
  67. cmd.header = mc_encode_cmd_header(DPIO_CMDID_DESTROY,
  68. cmd_flags,
  69. token);
  70. /* send command to mc*/
  71. return mc_send_command(mc_io, &cmd);
  72. }
  73. int dpio_enable(struct fsl_mc_io *mc_io,
  74. uint32_t cmd_flags,
  75. uint16_t token)
  76. {
  77. struct mc_command cmd = { 0 };
  78. /* prepare command */
  79. cmd.header = mc_encode_cmd_header(DPIO_CMDID_ENABLE,
  80. cmd_flags,
  81. token);
  82. /* send command to mc*/
  83. return mc_send_command(mc_io, &cmd);
  84. }
  85. int dpio_disable(struct fsl_mc_io *mc_io,
  86. uint32_t cmd_flags,
  87. uint16_t token)
  88. {
  89. struct mc_command cmd = { 0 };
  90. /* prepare command */
  91. cmd.header = mc_encode_cmd_header(DPIO_CMDID_DISABLE,
  92. cmd_flags,
  93. token);
  94. /* send command to mc*/
  95. return mc_send_command(mc_io, &cmd);
  96. }
  97. int dpio_reset(struct fsl_mc_io *mc_io,
  98. uint32_t cmd_flags,
  99. uint16_t token)
  100. {
  101. struct mc_command cmd = { 0 };
  102. /* prepare command */
  103. cmd.header = mc_encode_cmd_header(DPIO_CMDID_RESET,
  104. cmd_flags,
  105. token);
  106. /* send command to mc*/
  107. return mc_send_command(mc_io, &cmd);
  108. }
  109. int dpio_get_attributes(struct fsl_mc_io *mc_io,
  110. uint32_t cmd_flags,
  111. uint16_t token,
  112. struct dpio_attr *attr)
  113. {
  114. struct mc_command cmd = { 0 };
  115. int err;
  116. /* prepare command */
  117. cmd.header = mc_encode_cmd_header(DPIO_CMDID_GET_ATTR,
  118. cmd_flags,
  119. token);
  120. /* send command to mc*/
  121. err = mc_send_command(mc_io, &cmd);
  122. if (err)
  123. return err;
  124. /* retrieve response parameters */
  125. DPIO_RSP_GET_ATTR(cmd, attr);
  126. return 0;
  127. }