pcie-dw_ep.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863
  1. /*
  2. * Copyright (c) 2006-2023, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2023-09-23 GuEe-GUI first version
  9. */
  10. #define DBG_TAG "pcie.dw-ep"
  11. #define DBG_LVL DBG_INFO
  12. #include <rtdbg.h>
  13. #include "pcie-dw.h"
  14. struct dw_pcie_ep_func *dw_pcie_ep_get_func_from_ep(struct dw_pcie_ep *ep, rt_uint8_t func_no)
  15. {
  16. struct dw_pcie_ep_func *ep_func;
  17. rt_list_for_each_entry(ep_func, &ep->func_nodes, list)
  18. {
  19. if (ep_func->func_no == func_no)
  20. {
  21. return ep_func;
  22. }
  23. }
  24. return RT_NULL;
  25. }
  26. static rt_uint8_t dw_pcie_ep_func_select(struct dw_pcie_ep *ep, rt_uint8_t func_no)
  27. {
  28. rt_uint8_t func_offset = 0;
  29. if (ep->ops->func_select)
  30. {
  31. func_offset = ep->ops->func_select(ep, func_no);
  32. }
  33. return func_offset;
  34. }
  35. static void __dw_pcie_ep_reset_bar(struct dw_pcie *pci, rt_uint8_t func_no,
  36. int bar_idx, int flags)
  37. {
  38. rt_uint32_t reg;
  39. rt_uint8_t func_offset = 0;
  40. struct dw_pcie_ep *ep = &pci->endpoint;
  41. func_offset = dw_pcie_ep_func_select(ep, func_no);
  42. reg = func_offset + PCIR_BAR(bar_idx);
  43. dw_pcie_dbi_ro_writable_enable(pci, RT_TRUE);
  44. dw_pcie_writel_dbi2(pci, reg, 0x0);
  45. dw_pcie_writel_dbi(pci, reg, 0x0);
  46. if (flags & PCIM_BAR_MEM_TYPE_64)
  47. {
  48. dw_pcie_writel_dbi2(pci, reg + 4, 0x0);
  49. dw_pcie_writel_dbi(pci, reg + 4, 0x0);
  50. }
  51. dw_pcie_dbi_ro_writable_enable(pci, RT_FALSE);
  52. }
  53. void dw_pcie_ep_reset_bar(struct dw_pcie *pci, int bar_idx)
  54. {
  55. rt_uint8_t func_no, funcs = pci->endpoint.epc->max_functions;
  56. for (func_no = 0; func_no < funcs; ++func_no)
  57. {
  58. __dw_pcie_ep_reset_bar(pci, func_no, bar_idx, 0);
  59. }
  60. }
  61. static rt_uint8_t __dw_pcie_ep_find_next_cap(struct dw_pcie_ep *ep, rt_uint8_t func_no,
  62. rt_uint8_t cap_ptr, rt_uint8_t cap)
  63. {
  64. rt_uint16_t reg;
  65. rt_uint8_t func_offset = 0, cap_id, next_cap_ptr;
  66. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  67. if (!cap_ptr)
  68. {
  69. return 0;
  70. }
  71. func_offset = dw_pcie_ep_func_select(ep, func_no);
  72. reg = dw_pcie_readw_dbi(pci, func_offset + cap_ptr);
  73. cap_id = (reg & 0x00ff);
  74. if (cap_id > PCIY_MAX)
  75. {
  76. return 0;
  77. }
  78. if (cap_id == cap)
  79. {
  80. return cap_ptr;
  81. }
  82. next_cap_ptr = (reg & 0xff00) >> 8;
  83. return __dw_pcie_ep_find_next_cap(ep, func_no, next_cap_ptr, cap);
  84. }
  85. static rt_uint8_t dw_pcie_ep_find_capability(struct dw_pcie_ep *ep, rt_uint8_t func_no,
  86. rt_uint8_t cap)
  87. {
  88. rt_uint16_t reg;
  89. rt_uint8_t func_offset = 0, next_cap_ptr;
  90. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  91. func_offset = dw_pcie_ep_func_select(ep, func_no);
  92. reg = dw_pcie_readw_dbi(pci, func_offset + PCIR_CAP_PTR);
  93. next_cap_ptr = reg & 0x00ff;
  94. return __dw_pcie_ep_find_next_cap(ep, func_no, next_cap_ptr, cap);
  95. }
  96. rt_err_t dw_pcie_ep_inbound_atu(struct dw_pcie_ep *ep, rt_uint8_t func_no,
  97. int bar_idx, rt_ubase_t cpu_addr, enum dw_pcie_aspace_type aspace_type)
  98. {
  99. rt_err_t err;
  100. rt_uint32_t free_win;
  101. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  102. free_win = rt_bitmap_next_clear_bit(ep->ib_window_map, 0, ep->num_ib_windows);
  103. if (free_win >= ep->num_ib_windows)
  104. {
  105. LOG_E("No free inbound window");
  106. return -RT_EEMPTY;
  107. }
  108. err = dw_pcie_prog_inbound_atu(pci, func_no, free_win, bar_idx, cpu_addr, aspace_type);
  109. if (err)
  110. {
  111. LOG_E("Failed to program IB window error = %s", rt_strerror(err));
  112. return err;
  113. }
  114. ep->bar_to_atu[bar_idx] = free_win;
  115. rt_bitmap_set_bit(ep->ib_window_map, free_win);
  116. return RT_EOK;
  117. }
  118. rt_err_t dw_pcie_ep_outbound_atu(struct dw_pcie_ep *ep, rt_uint8_t func_no,
  119. rt_ubase_t phys_addr, rt_uint64_t pci_addr, rt_size_t size)
  120. {
  121. rt_uint32_t free_win;
  122. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  123. free_win = rt_bitmap_next_clear_bit(ep->ob_window_map, 0, ep->num_ob_windows);
  124. if (free_win >= ep->num_ob_windows)
  125. {
  126. LOG_E("No free outbound window");
  127. return -RT_EEMPTY;
  128. }
  129. dw_pcie_prog_ep_outbound_atu(pci, func_no, free_win, PCIE_ATU_TYPE_MEM,
  130. phys_addr, pci_addr, size);
  131. ep->outbound_addr[free_win] = phys_addr;
  132. rt_bitmap_set_bit(ep->ob_window_map, free_win);
  133. return RT_EOK;
  134. }
  135. static rt_err_t dw_pcie_ep_write_header(struct rt_pci_ep *epc, rt_uint8_t func_no,
  136. struct rt_pci_ep_header *hdr)
  137. {
  138. rt_uint8_t func_offset = 0;
  139. struct dw_pcie_ep *ep = epc->priv;
  140. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  141. func_offset = dw_pcie_ep_func_select(ep, func_no);
  142. dw_pcie_dbi_ro_writable_enable(pci, RT_TRUE);
  143. dw_pcie_writew_dbi(pci, func_offset + PCIR_VENDOR, hdr->vendor);
  144. dw_pcie_writew_dbi(pci, func_offset + PCIR_DEVICE, hdr->device);
  145. dw_pcie_writeb_dbi(pci, func_offset + PCIR_REVID, hdr->revision);
  146. dw_pcie_writeb_dbi(pci, func_offset + PCIR_PROGIF, hdr->progif);
  147. dw_pcie_writew_dbi(pci, func_offset + PCIR_SUBCLASS, hdr->subclass | hdr->class_code << 8);
  148. dw_pcie_writeb_dbi(pci, func_offset + PCIR_CACHELNSZ, hdr->cache_line_size);
  149. dw_pcie_writew_dbi(pci, func_offset + PCIR_SUBVEND_0, hdr->subsystem_vendor);
  150. dw_pcie_writew_dbi(pci, func_offset + PCIR_SUBDEV_0, hdr->subsystem_device);
  151. dw_pcie_writeb_dbi(pci, func_offset + PCIR_INTPIN, hdr->intx);
  152. dw_pcie_dbi_ro_writable_enable(pci, RT_FALSE);
  153. return 0;
  154. }
  155. static rt_err_t dw_pcie_ep_clear_bar(struct rt_pci_ep *epc, rt_uint8_t func_no,
  156. struct rt_pci_ep_bar *bar, int bar_idx)
  157. {
  158. rt_uint32_t atu_index;
  159. struct dw_pcie_ep *ep = epc->priv;
  160. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  161. atu_index = ep->bar_to_atu[bar_idx];
  162. __dw_pcie_ep_reset_bar(pci, func_no, bar_idx, ep->epc_bar[bar_idx]->bus.flags);
  163. dw_pcie_disable_atu(pci, atu_index, DW_PCIE_REGION_INBOUND);
  164. rt_bitmap_clear_bit(ep->ib_window_map, atu_index);
  165. ep->epc_bar[bar_idx] = RT_NULL;
  166. return RT_EOK;
  167. }
  168. static rt_err_t dw_pcie_ep_set_bar(struct rt_pci_ep *epc, rt_uint8_t func_no,
  169. struct rt_pci_ep_bar *bar, int bar_idx)
  170. {
  171. rt_err_t err;
  172. rt_uint32_t reg;
  173. rt_uint8_t func_offset = 0;
  174. rt_size_t size = bar->bus.size;
  175. rt_ubase_t flags = bar->bus.flags;
  176. enum dw_pcie_aspace_type aspace_type;
  177. struct dw_pcie_ep *ep = epc->priv;
  178. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  179. func_offset = dw_pcie_ep_func_select(ep, func_no);
  180. reg = PCIR_BAR(bar_idx) + func_offset;
  181. if (!(flags & PCIM_BAR_SPACE))
  182. {
  183. aspace_type = DW_PCIE_ASPACE_MEM;
  184. }
  185. else
  186. {
  187. aspace_type = DW_PCIE_ASPACE_IO;
  188. }
  189. err = dw_pcie_ep_inbound_atu(ep, func_no, bar_idx, bar->bus.base, aspace_type);
  190. if (err)
  191. {
  192. return err;
  193. }
  194. dw_pcie_dbi_ro_writable_enable(pci, RT_TRUE);
  195. dw_pcie_writel_dbi2(pci, reg, rt_lower_32_bits(size - 1));
  196. dw_pcie_writel_dbi(pci, reg, flags);
  197. if (flags & PCIM_BAR_MEM_TYPE_64)
  198. {
  199. dw_pcie_writel_dbi2(pci, reg + 4, rt_upper_32_bits(size - 1));
  200. dw_pcie_writel_dbi(pci, reg + 4, 0);
  201. }
  202. ep->epc_bar[bar_idx] = bar;
  203. dw_pcie_dbi_ro_writable_enable(pci, RT_FALSE);
  204. return 0;
  205. }
  206. static rt_err_t dw_pcie_find_index(struct dw_pcie_ep *ep,
  207. rt_ubase_t addr, rt_uint32_t *atu_index)
  208. {
  209. for (rt_uint32_t index = 0; index < ep->num_ob_windows; ++index)
  210. {
  211. if (ep->outbound_addr[index] != addr)
  212. {
  213. continue;
  214. }
  215. *atu_index = index;
  216. return RT_EOK;
  217. }
  218. return -RT_EINVAL;
  219. }
  220. static rt_err_t dw_pcie_ep_unmap_addr(struct rt_pci_ep *epc, rt_uint8_t func_no,
  221. rt_ubase_t addr)
  222. {
  223. rt_err_t err;
  224. rt_uint32_t atu_index;
  225. struct dw_pcie_ep *ep = epc->priv;
  226. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  227. if ((err = dw_pcie_find_index(ep, addr, &atu_index)))
  228. {
  229. return err;
  230. }
  231. dw_pcie_disable_atu(pci, atu_index, DW_PCIE_REGION_OUTBOUND);
  232. rt_bitmap_clear_bit(ep->ob_window_map, atu_index);
  233. return RT_EOK;
  234. }
  235. static rt_err_t dw_pcie_ep_map_addr(struct rt_pci_ep *epc, rt_uint8_t func_no,
  236. rt_ubase_t addr, rt_uint64_t pci_addr, rt_size_t size)
  237. {
  238. rt_err_t err;
  239. struct dw_pcie_ep *ep = epc->priv;
  240. err = dw_pcie_ep_outbound_atu(ep, func_no, addr, pci_addr, size);
  241. if (err)
  242. {
  243. LOG_E("Failed to enable address error = %s", rt_strerror(err));
  244. return err;
  245. }
  246. return RT_EOK;
  247. }
  248. static rt_err_t dw_pcie_ep_set_msi(struct rt_pci_ep *epc, rt_uint8_t func_no,
  249. unsigned irq_nr)
  250. {
  251. rt_uint32_t val, reg;
  252. rt_uint8_t func_offset = 0;
  253. struct dw_pcie_ep_func *ep_func;
  254. struct dw_pcie_ep *ep = epc->priv;
  255. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  256. ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
  257. if (!ep_func || !ep_func->msi_cap)
  258. {
  259. return -RT_EINVAL;
  260. }
  261. func_offset = dw_pcie_ep_func_select(ep, func_no);
  262. reg = ep_func->msi_cap + func_offset + PCIR_MSI_CTRL;
  263. val = dw_pcie_readw_dbi(pci, reg);
  264. val &= ~PCIM_MSICTRL_MMC_MASK;
  265. val |= (irq_nr << 1) & PCIM_MSICTRL_MMC_MASK;
  266. dw_pcie_dbi_ro_writable_enable(pci, RT_TRUE);
  267. dw_pcie_writew_dbi(pci, reg, val);
  268. dw_pcie_dbi_ro_writable_enable(pci, RT_FALSE);
  269. return RT_EOK;
  270. }
  271. static rt_err_t dw_pcie_ep_get_msi(struct rt_pci_ep *epc, rt_uint8_t func_no,
  272. unsigned *out_irq_nr)
  273. {
  274. rt_uint32_t val, reg;
  275. rt_uint8_t func_offset = 0;
  276. struct dw_pcie_ep *ep = epc->priv;
  277. struct dw_pcie_ep_func *ep_func;
  278. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  279. ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
  280. if (!ep_func || !ep_func->msi_cap)
  281. {
  282. return -RT_EINVAL;
  283. }
  284. func_offset = dw_pcie_ep_func_select(ep, func_no);
  285. reg = ep_func->msi_cap + func_offset + PCIR_MSI_CTRL;
  286. val = dw_pcie_readw_dbi(pci, reg);
  287. if (!(val & PCIM_MSICTRL_MSI_ENABLE))
  288. {
  289. return -RT_EINVAL;
  290. }
  291. *out_irq_nr = (val & PCIM_MSICTRL_MME_MASK) >> 4;
  292. return RT_EOK;
  293. }
  294. static rt_err_t dw_pcie_ep_set_msix(struct rt_pci_ep *epc, rt_uint8_t func_no,
  295. unsigned irq_nr, int bar_idx, rt_off_t offset)
  296. {
  297. rt_uint32_t val, reg;
  298. rt_uint8_t func_offset = 0;
  299. struct dw_pcie_ep_func *ep_func;
  300. struct dw_pcie_ep *ep = epc->priv;
  301. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  302. ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
  303. if (!ep_func || !ep_func->msix_cap)
  304. {
  305. return -RT_EINVAL;
  306. }
  307. dw_pcie_dbi_ro_writable_enable(pci, RT_TRUE);
  308. func_offset = dw_pcie_ep_func_select(ep, func_no);
  309. reg = ep_func->msix_cap + func_offset + PCIR_MSIX_CTRL;
  310. val = dw_pcie_readw_dbi(pci, reg);
  311. val &= ~PCIM_MSIXCTRL_TABLE_SIZE;
  312. val |= irq_nr;
  313. dw_pcie_writew_dbi(pci, reg, val);
  314. reg = ep_func->msix_cap + func_offset + PCIR_MSIX_TABLE;
  315. val = offset | bar_idx;
  316. dw_pcie_writel_dbi(pci, reg, val);
  317. reg = ep_func->msix_cap + func_offset + PCIR_MSIX_PBA;
  318. val = (offset + (irq_nr * PCIM_MSIX_ENTRY_SIZE)) | bar_idx;
  319. dw_pcie_writel_dbi(pci, reg, val);
  320. dw_pcie_dbi_ro_writable_enable(pci, RT_FALSE);
  321. return RT_EOK;
  322. }
  323. static rt_err_t dw_pcie_ep_get_msix(struct rt_pci_ep *epc, rt_uint8_t func_no,
  324. unsigned *out_irq_nr)
  325. {
  326. rt_uint32_t val, reg;
  327. rt_uint8_t func_offset = 0;
  328. struct dw_pcie_ep_func *ep_func;
  329. struct dw_pcie_ep *ep = epc->priv;
  330. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  331. ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
  332. if (!ep_func || !ep_func->msix_cap)
  333. {
  334. return -RT_EINVAL;
  335. }
  336. func_offset = dw_pcie_ep_func_select(ep, func_no);
  337. reg = ep_func->msix_cap + func_offset + PCIR_MSIX_CTRL;
  338. val = dw_pcie_readw_dbi(pci, reg);
  339. if (!(val & PCIM_MSIXCTRL_MSIX_ENABLE))
  340. {
  341. return -RT_EINVAL;
  342. }
  343. *out_irq_nr = val & PCIM_MSIXCTRL_TABLE_SIZE;
  344. return RT_EOK;
  345. }
  346. static rt_err_t dw_pcie_ep_raise_irq(struct rt_pci_ep *epc, rt_uint8_t func_no,
  347. enum rt_pci_ep_irq type, unsigned irq)
  348. {
  349. struct dw_pcie_ep *ep = epc->priv;
  350. if (!ep->ops->raise_irq)
  351. {
  352. return -RT_ENOSYS;
  353. }
  354. return ep->ops->raise_irq(ep, func_no, type, irq);
  355. }
  356. static rt_err_t dw_pcie_ep_stop(struct rt_pci_ep *epc)
  357. {
  358. struct dw_pcie_ep *ep = epc->priv;
  359. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  360. if (pci->ops->stop_link)
  361. {
  362. pci->ops->stop_link(pci);
  363. }
  364. return RT_EOK;
  365. }
  366. static rt_err_t dw_pcie_ep_start(struct rt_pci_ep *epc)
  367. {
  368. struct dw_pcie_ep *ep = epc->priv;
  369. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  370. if (pci->ops->start_link)
  371. {
  372. return pci->ops->start_link(pci);
  373. }
  374. return RT_EOK;
  375. }
  376. static const struct rt_pci_ep_ops dw_pcie_ep_ops =
  377. {
  378. .write_header = dw_pcie_ep_write_header,
  379. .set_bar = dw_pcie_ep_set_bar,
  380. .clear_bar = dw_pcie_ep_clear_bar,
  381. .map_addr = dw_pcie_ep_map_addr,
  382. .unmap_addr = dw_pcie_ep_unmap_addr,
  383. .set_msi = dw_pcie_ep_set_msi,
  384. .get_msi = dw_pcie_ep_get_msi,
  385. .set_msix = dw_pcie_ep_set_msix,
  386. .get_msix = dw_pcie_ep_get_msix,
  387. .raise_irq = dw_pcie_ep_raise_irq,
  388. .start = dw_pcie_ep_start,
  389. .stop = dw_pcie_ep_stop,
  390. };
  391. rt_err_t dw_pcie_ep_raise_legacy_irq(struct dw_pcie_ep *ep, rt_uint8_t func_no)
  392. {
  393. LOG_E("EP cannot trigger legacy IRQs");
  394. return -RT_EINVAL;
  395. }
  396. rt_err_t dw_pcie_ep_raise_msi_irq(struct dw_pcie_ep *ep, rt_uint8_t func_no,
  397. unsigned irq)
  398. {
  399. rt_err_t err;
  400. rt_off_t aligned_offset;
  401. rt_uint8_t func_offset = 0;
  402. rt_uint64_t msg_addr;
  403. rt_uint16_t msg_ctrl, msg_data;
  404. rt_uint32_t msg_addr_lower, msg_addr_upper, reg;
  405. struct rt_pci_ep *epc = ep->epc;
  406. struct dw_pcie_ep_func *ep_func;
  407. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  408. ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
  409. if (!ep_func || !ep_func->msi_cap)
  410. {
  411. return -RT_EINVAL;
  412. }
  413. func_offset = dw_pcie_ep_func_select(ep, func_no);
  414. /* Raise MSI per the PCI Local Bus Specification Revision 3.0, 6.8.1. */
  415. reg = ep_func->msi_cap + func_offset + PCIR_MSI_CTRL;
  416. msg_ctrl = dw_pcie_readw_dbi(pci, reg);
  417. reg = ep_func->msi_cap + func_offset + PCIR_MSI_ADDR;
  418. msg_addr_lower = dw_pcie_readl_dbi(pci, reg);
  419. if (!!(msg_ctrl & PCIM_MSICTRL_64BIT))
  420. {
  421. reg = ep_func->msi_cap + func_offset + PCIR_MSI_ADDR_HIGH;
  422. msg_addr_upper = dw_pcie_readl_dbi(pci, reg);
  423. reg = ep_func->msi_cap + func_offset + PCIR_MSI_DATA_64BIT;
  424. msg_data = dw_pcie_readw_dbi(pci, reg);
  425. }
  426. else
  427. {
  428. msg_addr_upper = 0;
  429. reg = ep_func->msi_cap + func_offset + PCIR_MSI_DATA;
  430. msg_data = dw_pcie_readw_dbi(pci, reg);
  431. }
  432. aligned_offset = msg_addr_lower & (ep->page_size - 1);
  433. msg_addr = ((rt_uint64_t)msg_addr_upper << 32) | (msg_addr_lower & ~aligned_offset);
  434. if ((err = dw_pcie_ep_map_addr(epc, func_no, ep->msi_mem_phy, msg_addr, ep->page_size)))
  435. {
  436. return err;
  437. }
  438. HWREG32(ep->msi_mem + aligned_offset) = msg_data | (irq - 1);
  439. dw_pcie_ep_unmap_addr(epc, func_no, ep->msi_mem_phy);
  440. return RT_EOK;
  441. }
  442. rt_err_t dw_pcie_ep_raise_msix_irq_doorbell(struct dw_pcie_ep *ep, rt_uint8_t func_no,
  443. unsigned irq)
  444. {
  445. rt_uint32_t msg_data;
  446. struct dw_pcie_ep_func *ep_func;
  447. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  448. ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
  449. if (!ep_func || !ep_func->msix_cap)
  450. {
  451. return -RT_EINVAL;
  452. }
  453. msg_data = (func_no << PCIE_MSIX_DOORBELL_PF_SHIFT) | (irq - 1);
  454. dw_pcie_writel_dbi(pci, PCIE_MSIX_DOORBELL, msg_data);
  455. return RT_EOK;
  456. }
  457. rt_err_t dw_pcie_ep_raise_msix_irq(struct dw_pcie_ep *ep, rt_uint8_t func_no,
  458. unsigned irq)
  459. {
  460. rt_err_t err;
  461. int bar_idx;
  462. rt_uint64_t msg_addr;
  463. rt_uint32_t tbl_offset;
  464. rt_off_t aligned_offset;
  465. rt_uint8_t func_offset = 0;
  466. rt_uint32_t reg, msg_data, vec_ctrl;
  467. struct rt_pci_ep *epc = ep->epc;
  468. struct rt_pci_ep_msix_tbl *msix_tbl;
  469. struct dw_pcie_ep_func *ep_func;
  470. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  471. ep_func = dw_pcie_ep_get_func_from_ep(ep, func_no);
  472. if (!ep_func || !ep_func->msix_cap)
  473. {
  474. return -RT_EINVAL;
  475. }
  476. func_offset = dw_pcie_ep_func_select(ep, func_no);
  477. reg = ep_func->msix_cap + func_offset + PCIR_MSIX_TABLE;
  478. tbl_offset = dw_pcie_readl_dbi(pci, reg);
  479. bar_idx = (tbl_offset & PCIM_MSIX_BIR_MASK);
  480. tbl_offset &= PCIM_MSIX_TABLE_OFFSET;
  481. msix_tbl = (void *)ep->epc_bar[bar_idx]->cpu_addr + tbl_offset;
  482. msg_addr = msix_tbl[(irq - 1)].msg_addr;
  483. msg_data = msix_tbl[(irq - 1)].msg_data;
  484. vec_ctrl = msix_tbl[(irq - 1)].vector_ctrl;
  485. if (vec_ctrl & PCIM_MSIX_ENTRYVECTOR_CTRL_MASK)
  486. {
  487. return -RT_EINVAL;
  488. }
  489. aligned_offset = msg_addr & (ep->page_size - 1);
  490. if ((err = dw_pcie_ep_map_addr(epc, func_no, ep->msi_mem_phy, msg_addr, ep->page_size)))
  491. {
  492. return err;
  493. }
  494. HWREG32(ep->msi_mem + aligned_offset) = msg_data;
  495. dw_pcie_ep_unmap_addr(epc, func_no, ep->msi_mem_phy);
  496. return RT_EOK;
  497. }
  498. void dw_pcie_ep_exit(struct dw_pcie_ep *ep)
  499. {
  500. struct rt_pci_ep *epc = ep->epc;
  501. if (ep->msi_mem)
  502. {
  503. rt_pci_ep_mem_free(epc, ep->msi_mem, ep->msi_mem_phy, ep->page_size);
  504. }
  505. if (!rt_list_isempty(&ep->func_nodes))
  506. {
  507. struct dw_pcie_ep_func *ep_func, *ep_func_next;
  508. rt_list_for_each_entry_safe(ep_func, ep_func_next, &ep->func_nodes, list)
  509. {
  510. rt_list_remove(&ep_func->list);
  511. rt_free(ep_func);
  512. }
  513. }
  514. if (ep->ib_window_map)
  515. {
  516. rt_free(ep->ib_window_map);
  517. }
  518. if (ep->ob_window_map)
  519. {
  520. rt_free(ep->ob_window_map);
  521. }
  522. if (ep->outbound_addr)
  523. {
  524. rt_free(ep->outbound_addr);
  525. }
  526. if (epc)
  527. {
  528. rt_free(epc);
  529. }
  530. }
  531. static rt_uint32_t dw_pcie_ep_find_ext_capability(struct dw_pcie *pci, int cap)
  532. {
  533. rt_uint32_t header;
  534. int pos = (PCI_REGMAX + 1);
  535. while (pos)
  536. {
  537. header = dw_pcie_readl_dbi(pci, pos);
  538. if (PCI_EXTCAP_ID(header) == cap)
  539. {
  540. return pos;
  541. }
  542. if (!(pos = PCI_EXTCAP_NEXTPTR(header)))
  543. {
  544. break;
  545. }
  546. }
  547. return 0;
  548. }
  549. rt_err_t dw_pcie_ep_init_complete(struct dw_pcie_ep *ep)
  550. {
  551. rt_off_t offset;
  552. rt_size_t bar_nr;
  553. rt_uint32_t reg;
  554. rt_uint8_t hdr_type;
  555. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  556. hdr_type = dw_pcie_readb_dbi(pci, PCIR_HDRTYPE) & PCIM_HDRTYPE;
  557. if (hdr_type != PCIM_HDRTYPE_NORMAL)
  558. {
  559. LOG_E("PCIe controller is not set to EP mode hdr_type = %x", hdr_type);
  560. return -RT_EIO;
  561. }
  562. offset = dw_pcie_ep_find_ext_capability(pci, PCIZ_RESIZE_BAR);
  563. dw_pcie_dbi_ro_writable_enable(pci, RT_TRUE);
  564. if (offset)
  565. {
  566. reg = dw_pcie_readl_dbi(pci, offset + PCIM_REBAR_CTRL);
  567. bar_nr = (reg & PCIM_REBAR_CTRL_NBAR_MASK) >> PCIM_REBAR_CTRL_NBAR_SHIFT;
  568. for (int i = 0; i < bar_nr; ++i, offset += PCIM_REBAR_CTRL)
  569. {
  570. dw_pcie_writel_dbi(pci, offset + PCIM_REBAR_CAP, 0x0);
  571. }
  572. }
  573. dw_pcie_setup(pci);
  574. dw_pcie_dbi_ro_writable_enable(pci, RT_FALSE);
  575. return RT_EOK;
  576. }
  577. rt_err_t dw_pcie_ep_init(struct dw_pcie_ep *ep)
  578. {
  579. rt_err_t err;
  580. struct rt_pci_ep *epc = RT_NULL;
  581. struct dw_pcie_ep_func *ep_func;
  582. struct dw_pcie *pci = to_dw_pcie_from_endpoint(ep);
  583. struct rt_device *dev = pci->dev;
  584. rt_list_init(&ep->func_nodes);
  585. if (!pci->dbi_base || !pci->dbi_base2)
  586. {
  587. LOG_E("dbi_base/dbi_base2 is not populated");
  588. return -RT_EINVAL;
  589. }
  590. if ((err = rt_dm_dev_prop_read_u32(dev, "num-ib-windows", &ep->num_ib_windows)))
  591. {
  592. LOG_E("Unable to read 'num-ib-windows' property");
  593. return err;
  594. }
  595. if (ep->num_ib_windows > MAX_IATU_IN)
  596. {
  597. LOG_E("Invalid 'num-ib-windows'");
  598. return -RT_EINVAL;
  599. }
  600. if ((err = rt_dm_dev_prop_read_u32(dev, "num-ob-windows", &ep->num_ob_windows)))
  601. {
  602. LOG_E("Unable to read 'num-ob-windows' property");
  603. return err;
  604. }
  605. if (ep->num_ob_windows > MAX_IATU_OUT)
  606. {
  607. LOG_E("Invalid 'num-ob-windows'");
  608. return -RT_EINVAL;
  609. }
  610. ep->ib_window_map = rt_calloc(RT_BITMAP_LEN(ep->num_ib_windows), sizeof(rt_bitmap_t));
  611. if (!ep->ib_window_map)
  612. {
  613. return -RT_ENOMEM;
  614. }
  615. ep->ob_window_map = rt_calloc(RT_BITMAP_LEN(ep->num_ob_windows), sizeof(rt_bitmap_t));
  616. if (!ep->ob_window_map)
  617. {
  618. err = -RT_ENOMEM;
  619. goto _fail;
  620. }
  621. ep->outbound_addr = rt_calloc(ep->num_ob_windows, sizeof(rt_ubase_t));
  622. if (!ep->outbound_addr)
  623. {
  624. err = -RT_ENOMEM;
  625. goto _fail;
  626. }
  627. if (pci->link_gen < 1)
  628. {
  629. pci->link_gen = -1;
  630. rt_dm_dev_prop_read_u32(dev, "max-link-speed", &pci->link_gen);
  631. }
  632. epc = rt_calloc(1, sizeof(*epc));
  633. if (!epc)
  634. {
  635. err = -RT_ENOMEM;
  636. goto _fail;
  637. }
  638. epc->name = rt_dm_dev_get_name(dev);
  639. epc->rc_dev = dev;
  640. epc->ops = &dw_pcie_ep_ops;
  641. epc->priv = ep;
  642. if ((err = rt_pci_ep_register(epc)))
  643. {
  644. goto _fail;
  645. }
  646. ep->epc = epc;
  647. if (rt_dm_dev_prop_read_u8(dev, "max-functions", &epc->max_functions))
  648. {
  649. epc->max_functions = 1;
  650. }
  651. for (rt_uint8_t func_no = 0; func_no < epc->max_functions; ++func_no)
  652. {
  653. ep_func = rt_calloc(1, sizeof(*ep_func));
  654. if (!ep_func)
  655. {
  656. err = -RT_ENOMEM;
  657. goto _fail;
  658. }
  659. ep_func->func_no = func_no;
  660. ep_func->msi_cap = dw_pcie_ep_find_capability(ep, func_no, PCIY_MSI);
  661. ep_func->msix_cap = dw_pcie_ep_find_capability(ep, func_no, PCIY_MSIX);
  662. rt_list_init(&ep_func->list);
  663. rt_list_insert_after(&ep->func_nodes, &ep_func->list);
  664. }
  665. if (ep->ops->ep_init)
  666. {
  667. ep->ops->ep_init(ep);
  668. }
  669. if ((err = rt_pci_ep_mem_init(epc, ep->aspace, ep->aspace_size, ep->page_size)))
  670. {
  671. goto _fail;
  672. }
  673. ep->msi_mem = rt_pci_ep_mem_alloc(epc, &ep->msi_mem_phy, ep->page_size);
  674. if (!ep->msi_mem)
  675. {
  676. LOG_E("Failed to reserve memory for MSI/MSI-X");
  677. err = -RT_ENOMEM;
  678. goto _fail;
  679. }
  680. if ((err = dw_pcie_ep_init_complete(ep)))
  681. {
  682. goto _fail;
  683. }
  684. return RT_EOK;
  685. _fail:
  686. dw_pcie_ep_exit(ep);
  687. return err;
  688. }