dpni.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright 2013-2016 Freescale Semiconductor, Inc.
  4. * Copyright 2017 NXP
  5. */
  6. #include <fsl-mc/fsl_mc_sys.h>
  7. #include <fsl-mc/fsl_mc_cmd.h>
  8. #include <fsl-mc/fsl_dpni.h>
  9. int dpni_prepare_cfg(const struct dpni_cfg *cfg,
  10. uint8_t *cfg_buf)
  11. {
  12. uint64_t *params = (uint64_t *)cfg_buf;
  13. DPNI_PREP_CFG(params, cfg);
  14. return 0;
  15. }
  16. int dpni_extract_cfg(struct dpni_cfg *cfg,
  17. const uint8_t *cfg_buf)
  18. {
  19. uint64_t *params = (uint64_t *)cfg_buf;
  20. DPNI_EXT_CFG(params, cfg);
  21. return 0;
  22. }
  23. int dpni_open(struct fsl_mc_io *mc_io,
  24. uint32_t cmd_flags,
  25. int dpni_id,
  26. uint16_t *token)
  27. {
  28. struct mc_command cmd = { 0 };
  29. int err;
  30. /* prepare command */
  31. cmd.header = mc_encode_cmd_header(DPNI_CMDID_OPEN,
  32. cmd_flags,
  33. 0);
  34. DPNI_CMD_OPEN(cmd, dpni_id);
  35. /* send command to mc*/
  36. err = mc_send_command(mc_io, &cmd);
  37. if (err)
  38. return err;
  39. /* retrieve response parameters */
  40. *token = MC_CMD_HDR_READ_TOKEN(cmd.header);
  41. return 0;
  42. }
  43. int dpni_close(struct fsl_mc_io *mc_io,
  44. uint32_t cmd_flags,
  45. uint16_t token)
  46. {
  47. struct mc_command cmd = { 0 };
  48. /* prepare command */
  49. cmd.header = mc_encode_cmd_header(DPNI_CMDID_CLOSE,
  50. cmd_flags,
  51. token);
  52. /* send command to mc*/
  53. return mc_send_command(mc_io, &cmd);
  54. }
  55. int dpni_create(struct fsl_mc_io *mc_io,
  56. uint16_t dprc_token,
  57. uint32_t cmd_flags,
  58. const struct dpni_cfg *cfg,
  59. uint32_t *obj_id)
  60. {
  61. struct mc_command cmd = { 0 };
  62. int err;
  63. /* prepare command */
  64. cmd.header = mc_encode_cmd_header(DPNI_CMDID_CREATE,
  65. cmd_flags,
  66. dprc_token);
  67. DPNI_CMD_CREATE(cmd, cfg);
  68. /* send command to mc*/
  69. err = mc_send_command(mc_io, &cmd);
  70. if (err)
  71. return err;
  72. /* retrieve response parameters */
  73. MC_CMD_READ_OBJ_ID(cmd, *obj_id);
  74. return 0;
  75. }
  76. int dpni_destroy(struct fsl_mc_io *mc_io,
  77. uint16_t dprc_token,
  78. uint32_t cmd_flags,
  79. uint32_t obj_id)
  80. {
  81. struct mc_command cmd = { 0 };
  82. /* prepare command */
  83. cmd.header = mc_encode_cmd_header(DPNI_CMDID_DESTROY,
  84. cmd_flags,
  85. dprc_token);
  86. /* set object id to destroy */
  87. CMD_DESTROY_SET_OBJ_ID_PARAM0(cmd, obj_id);
  88. /* send command to mc*/
  89. return mc_send_command(mc_io, &cmd);
  90. }
  91. int dpni_set_pools(struct fsl_mc_io *mc_io,
  92. uint32_t cmd_flags,
  93. uint16_t token,
  94. const struct dpni_pools_cfg *cfg)
  95. {
  96. struct mc_command cmd = { 0 };
  97. /* prepare command */
  98. cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_POOLS,
  99. cmd_flags,
  100. token);
  101. DPNI_CMD_SET_POOLS(cmd, cfg);
  102. /* send command to mc*/
  103. return mc_send_command(mc_io, &cmd);
  104. }
  105. int dpni_enable(struct fsl_mc_io *mc_io,
  106. uint32_t cmd_flags,
  107. uint16_t token)
  108. {
  109. struct mc_command cmd = { 0 };
  110. /* prepare command */
  111. cmd.header = mc_encode_cmd_header(DPNI_CMDID_ENABLE,
  112. cmd_flags,
  113. token);
  114. /* send command to mc*/
  115. return mc_send_command(mc_io, &cmd);
  116. }
  117. int dpni_disable(struct fsl_mc_io *mc_io,
  118. uint32_t cmd_flags,
  119. uint16_t token)
  120. {
  121. struct mc_command cmd = { 0 };
  122. /* prepare command */
  123. cmd.header = mc_encode_cmd_header(DPNI_CMDID_DISABLE,
  124. cmd_flags,
  125. token);
  126. /* send command to mc*/
  127. return mc_send_command(mc_io, &cmd);
  128. }
  129. int dpni_reset(struct fsl_mc_io *mc_io,
  130. uint32_t cmd_flags,
  131. uint16_t token)
  132. {
  133. struct mc_command cmd = { 0 };
  134. /* prepare command */
  135. cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET,
  136. cmd_flags,
  137. token);
  138. /* send command to mc*/
  139. return mc_send_command(mc_io, &cmd);
  140. }
  141. int dpni_get_attributes(struct fsl_mc_io *mc_io,
  142. uint32_t cmd_flags,
  143. uint16_t token,
  144. struct dpni_attr *attr)
  145. {
  146. struct mc_command cmd = { 0 };
  147. int err;
  148. /* prepare command */
  149. cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_ATTR,
  150. cmd_flags,
  151. token);
  152. /* send command to mc*/
  153. err = mc_send_command(mc_io, &cmd);
  154. if (err)
  155. return err;
  156. /* retrieve response parameters */
  157. DPNI_RSP_GET_ATTR(cmd, attr);
  158. return 0;
  159. }
  160. int dpni_set_errors_behavior(struct fsl_mc_io *mc_io,
  161. uint32_t cmd_flags,
  162. uint16_t token,
  163. struct dpni_error_cfg *cfg)
  164. {
  165. struct mc_command cmd = { 0 };
  166. /* prepare command */
  167. cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_ERRORS_BEHAVIOR,
  168. cmd_flags,
  169. token);
  170. DPNI_CMD_SET_ERRORS_BEHAVIOR(cmd, cfg);
  171. /* send command to mc*/
  172. return mc_send_command(mc_io, &cmd);
  173. }
  174. int dpni_set_buffer_layout(struct fsl_mc_io *mc_io,
  175. uint32_t cmd_flags,
  176. uint16_t token,
  177. const struct dpni_buffer_layout *layout,
  178. enum dpni_queue_type type)
  179. {
  180. struct mc_command cmd = { 0 };
  181. /* prepare command */
  182. cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_BUFFER_LAYOUT,
  183. cmd_flags,
  184. token);
  185. DPNI_CMD_SET_BUFFER_LAYOUT(cmd, layout, type);
  186. /* send command to mc*/
  187. return mc_send_command(mc_io, &cmd);
  188. }
  189. int dpni_get_qdid(struct fsl_mc_io *mc_io,
  190. uint32_t cmd_flags,
  191. uint16_t token,
  192. uint16_t *qdid)
  193. {
  194. struct mc_command cmd = { 0 };
  195. int err;
  196. /* prepare command */
  197. cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QDID,
  198. cmd_flags,
  199. token);
  200. /* send command to mc*/
  201. err = mc_send_command(mc_io, &cmd);
  202. if (err)
  203. return err;
  204. /* retrieve response parameters */
  205. DPNI_RSP_GET_QDID(cmd, *qdid);
  206. return 0;
  207. }
  208. int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io,
  209. uint32_t cmd_flags,
  210. uint16_t token,
  211. uint16_t *data_offset)
  212. {
  213. struct mc_command cmd = { 0 };
  214. int err;
  215. /* prepare command */
  216. cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_TX_DATA_OFFSET,
  217. cmd_flags,
  218. token);
  219. /* send command to mc*/
  220. err = mc_send_command(mc_io, &cmd);
  221. if (err)
  222. return err;
  223. /* retrieve response parameters */
  224. DPNI_RSP_GET_TX_DATA_OFFSET(cmd, *data_offset);
  225. return 0;
  226. }
  227. int dpni_set_link_cfg(struct fsl_mc_io *mc_io,
  228. uint32_t cmd_flags,
  229. uint16_t token,
  230. const struct dpni_link_cfg *cfg)
  231. {
  232. struct mc_command cmd = { 0 };
  233. /* prepare command */
  234. cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_LINK_CFG,
  235. cmd_flags,
  236. token);
  237. DPNI_CMD_SET_LINK_CFG(cmd, cfg);
  238. /* send command to mc*/
  239. return mc_send_command(mc_io, &cmd);
  240. }
  241. int dpni_get_link_state(struct fsl_mc_io *mc_io,
  242. uint32_t cmd_flags,
  243. uint16_t token,
  244. struct dpni_link_state *state)
  245. {
  246. struct mc_command cmd = { 0 };
  247. int err;
  248. /* prepare command */
  249. cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_LINK_STATE,
  250. cmd_flags,
  251. token);
  252. /* send command to mc*/
  253. err = mc_send_command(mc_io, &cmd);
  254. if (err)
  255. return err;
  256. /* retrieve response parameters */
  257. DPNI_RSP_GET_LINK_STATE(cmd, state);
  258. return 0;
  259. }
  260. int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
  261. uint32_t cmd_flags,
  262. uint16_t token,
  263. const uint8_t mac_addr[6])
  264. {
  265. struct mc_command cmd = { 0 };
  266. /* prepare command */
  267. cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_PRIM_MAC,
  268. cmd_flags,
  269. token);
  270. DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr);
  271. /* send command to mc*/
  272. return mc_send_command(mc_io, &cmd);
  273. }
  274. int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io,
  275. uint32_t cmd_flags,
  276. uint16_t token,
  277. uint8_t mac_addr[6])
  278. {
  279. struct mc_command cmd = { 0 };
  280. int err;
  281. /* prepare command */
  282. cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_PRIM_MAC,
  283. cmd_flags,
  284. token);
  285. /* send command to mc*/
  286. err = mc_send_command(mc_io, &cmd);
  287. if (err)
  288. return err;
  289. /* retrieve response parameters */
  290. DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr);
  291. return 0;
  292. }
  293. int dpni_add_mac_addr(struct fsl_mc_io *mc_io,
  294. uint32_t cmd_flags,
  295. uint16_t token,
  296. const uint8_t mac_addr[6])
  297. {
  298. struct mc_command cmd = { 0 };
  299. /* prepare command */
  300. cmd.header = mc_encode_cmd_header(DPNI_CMDID_ADD_MAC_ADDR,
  301. cmd_flags,
  302. token);
  303. DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr);
  304. /* send command to mc*/
  305. return mc_send_command(mc_io, &cmd);
  306. }
  307. int dpni_remove_mac_addr(struct fsl_mc_io *mc_io,
  308. uint32_t cmd_flags,
  309. uint16_t token,
  310. const uint8_t mac_addr[6])
  311. {
  312. struct mc_command cmd = { 0 };
  313. /* prepare command */
  314. cmd.header = mc_encode_cmd_header(DPNI_CMDID_REMOVE_MAC_ADDR,
  315. cmd_flags,
  316. token);
  317. DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr);
  318. /* send command to mc*/
  319. return mc_send_command(mc_io, &cmd);
  320. }
  321. int dpni_get_api_version(struct fsl_mc_io *mc_io,
  322. u32 cmd_flags,
  323. u16 *major_ver,
  324. u16 *minor_ver)
  325. {
  326. struct mc_command cmd = { 0 };
  327. int err;
  328. /* prepare command */
  329. cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_API_VERSION,
  330. cmd_flags, 0);
  331. /* send command to mc */
  332. err = mc_send_command(mc_io, &cmd);
  333. if (err)
  334. return err;
  335. /* retrieve response parameters */
  336. mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
  337. return 0;
  338. }
  339. int dpni_set_queue(struct fsl_mc_io *mc_io,
  340. uint32_t cmd_flags,
  341. uint16_t token,
  342. enum dpni_queue_type type,
  343. uint8_t tc,
  344. uint8_t index,
  345. const struct dpni_queue *queue)
  346. {
  347. struct mc_command cmd = { 0 };
  348. /* prepare command */
  349. cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_QUEUE,
  350. cmd_flags,
  351. token);
  352. DPNI_CMD_SET_QUEUE(cmd, type, tc, index, queue);
  353. /* send command to mc*/
  354. return mc_send_command(mc_io, &cmd);
  355. }
  356. int dpni_get_queue(struct fsl_mc_io *mc_io,
  357. uint32_t cmd_flags,
  358. uint16_t token,
  359. enum dpni_queue_type type,
  360. uint8_t tc,
  361. uint8_t index,
  362. struct dpni_queue *queue)
  363. {
  364. struct mc_command cmd = { 0 };
  365. int err;
  366. /* prepare command */
  367. cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_QUEUE,
  368. cmd_flags,
  369. token);
  370. DPNI_CMD_GET_QUEUE(cmd, type, tc, index);
  371. /* send command to mc*/
  372. err = mc_send_command(mc_io, &cmd);
  373. if (err)
  374. return err;
  375. /* retrieve response parameters */
  376. DPNI_RSP_GET_QUEUE(cmd, queue);
  377. return 0;
  378. }
  379. int dpni_set_tx_confirmation_mode(struct fsl_mc_io *mc_io,
  380. uint32_t cmd_flags,
  381. uint16_t token,
  382. enum dpni_confirmation_mode mode)
  383. {
  384. struct dpni_tx_confirmation_mode *cmd_params;
  385. struct mc_command cmd = { 0 };
  386. /* prepare command */
  387. cmd.header = mc_encode_cmd_header(DPNI_CMDID_SET_TX_CONFIRMATION_MODE,
  388. cmd_flags,
  389. token);
  390. cmd_params = (struct dpni_tx_confirmation_mode *)cmd.params;
  391. cmd_params->confirmation_mode = mode;
  392. /* send command to mc*/
  393. return mc_send_command(mc_io, &cmd);
  394. }
  395. int dpni_get_statistics(struct fsl_mc_io *mc_io,
  396. uint32_t cmd_flags,
  397. uint16_t token,
  398. uint8_t page,
  399. struct dpni_statistics *stat)
  400. {
  401. struct mc_command cmd = { 0 };
  402. int err;
  403. /* prepare command */
  404. cmd.header = mc_encode_cmd_header(DPNI_CMDID_GET_STATISTICS,
  405. cmd_flags, token);
  406. DPNI_CMD_GET_STATISTICS(cmd, page);
  407. /* send command to mc*/
  408. err = mc_send_command(mc_io, &cmd);
  409. if (err)
  410. return err;
  411. /* retrieve response parameters */
  412. DPNI_RSP_GET_STATISTICS(cmd, stat);
  413. return 0;
  414. }
  415. int dpni_reset_statistics(struct fsl_mc_io *mc_io,
  416. uint32_t cmd_flags,
  417. uint16_t token)
  418. {
  419. struct mc_command cmd = { 0 };
  420. /* prepare command */
  421. cmd.header = mc_encode_cmd_header(DPNI_CMDID_RESET_STATISTICS,
  422. cmd_flags, token);
  423. /* send command to mc*/
  424. return mc_send_command(mc_io, &cmd);
  425. }