eeh_pe.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669
  1. /*
  2. * The file intends to implement PE based on the information from
  3. * platforms. Basically, there have 3 types of PEs: PHB/Bus/Device.
  4. * All the PEs should be organized as hierarchy tree. The first level
  5. * of the tree will be associated to existing PHBs since the particular
  6. * PE is only meaningful in one PHB domain.
  7. *
  8. * Copyright Benjamin Herrenschmidt & Gavin Shan, IBM Corporation 2012.
  9. *
  10. * This program is free software; you can redistribute it and/or modify
  11. * it under the terms of the GNU General Public License as published by
  12. * the Free Software Foundation; either version 2 of the License, or
  13. * (at your option) any later version.
  14. *
  15. * This program is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. * GNU General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU General Public License
  21. * along with this program; if not, write to the Free Software
  22. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23. */
  24. #include <linux/export.h>
  25. #include <linux/gfp.h>
  26. #include <linux/init.h>
  27. #include <linux/kernel.h>
  28. #include <linux/pci.h>
  29. #include <linux/string.h>
  30. #include <asm/pci-bridge.h>
  31. #include <asm/ppc-pci.h>
  32. static LIST_HEAD(eeh_phb_pe);
  33. /**
  34. * eeh_pe_alloc - Allocate PE
  35. * @phb: PCI controller
  36. * @type: PE type
  37. *
  38. * Allocate PE instance dynamically.
  39. */
  40. static struct eeh_pe *eeh_pe_alloc(struct pci_controller *phb, int type)
  41. {
  42. struct eeh_pe *pe;
  43. /* Allocate PHB PE */
  44. pe = kzalloc(sizeof(struct eeh_pe), GFP_KERNEL);
  45. if (!pe) return NULL;
  46. /* Initialize PHB PE */
  47. pe->type = type;
  48. pe->phb = phb;
  49. INIT_LIST_HEAD(&pe->child_list);
  50. INIT_LIST_HEAD(&pe->child);
  51. INIT_LIST_HEAD(&pe->edevs);
  52. return pe;
  53. }
  54. /**
  55. * eeh_phb_pe_create - Create PHB PE
  56. * @phb: PCI controller
  57. *
  58. * The function should be called while the PHB is detected during
  59. * system boot or PCI hotplug in order to create PHB PE.
  60. */
  61. int eeh_phb_pe_create(struct pci_controller *phb)
  62. {
  63. struct eeh_pe *pe;
  64. /* Allocate PHB PE */
  65. pe = eeh_pe_alloc(phb, EEH_PE_PHB);
  66. if (!pe) {
  67. pr_err("%s: out of memory!\n", __func__);
  68. return -ENOMEM;
  69. }
  70. /* Put it into the list */
  71. list_add_tail(&pe->child, &eeh_phb_pe);
  72. pr_debug("EEH: Add PE for PHB#%d\n", phb->global_number);
  73. return 0;
  74. }
  75. /**
  76. * eeh_phb_pe_get - Retrieve PHB PE based on the given PHB
  77. * @phb: PCI controller
  78. *
  79. * The overall PEs form hierarchy tree. The first layer of the
  80. * hierarchy tree is composed of PHB PEs. The function is used
  81. * to retrieve the corresponding PHB PE according to the given PHB.
  82. */
  83. struct eeh_pe *eeh_phb_pe_get(struct pci_controller *phb)
  84. {
  85. struct eeh_pe *pe;
  86. list_for_each_entry(pe, &eeh_phb_pe, child) {
  87. /*
  88. * Actually, we needn't check the type since
  89. * the PE for PHB has been determined when that
  90. * was created.
  91. */
  92. if ((pe->type & EEH_PE_PHB) && pe->phb == phb)
  93. return pe;
  94. }
  95. return NULL;
  96. }
  97. /**
  98. * eeh_pe_next - Retrieve the next PE in the tree
  99. * @pe: current PE
  100. * @root: root PE
  101. *
  102. * The function is used to retrieve the next PE in the
  103. * hierarchy PE tree.
  104. */
  105. static struct eeh_pe *eeh_pe_next(struct eeh_pe *pe,
  106. struct eeh_pe *root)
  107. {
  108. struct list_head *next = pe->child_list.next;
  109. if (next == &pe->child_list) {
  110. while (1) {
  111. if (pe == root)
  112. return NULL;
  113. next = pe->child.next;
  114. if (next != &pe->parent->child_list)
  115. break;
  116. pe = pe->parent;
  117. }
  118. }
  119. return list_entry(next, struct eeh_pe, child);
  120. }
  121. /**
  122. * eeh_pe_traverse - Traverse PEs in the specified PHB
  123. * @root: root PE
  124. * @fn: callback
  125. * @flag: extra parameter to callback
  126. *
  127. * The function is used to traverse the specified PE and its
  128. * child PEs. The traversing is to be terminated once the
  129. * callback returns something other than NULL, or no more PEs
  130. * to be traversed.
  131. */
  132. static void *eeh_pe_traverse(struct eeh_pe *root,
  133. eeh_traverse_func fn, void *flag)
  134. {
  135. struct eeh_pe *pe;
  136. void *ret;
  137. for (pe = root; pe; pe = eeh_pe_next(pe, root)) {
  138. ret = fn(pe, flag);
  139. if (ret) return ret;
  140. }
  141. return NULL;
  142. }
  143. /**
  144. * eeh_pe_dev_traverse - Traverse the devices from the PE
  145. * @root: EEH PE
  146. * @fn: function callback
  147. * @flag: extra parameter to callback
  148. *
  149. * The function is used to traverse the devices of the specified
  150. * PE and its child PEs.
  151. */
  152. void *eeh_pe_dev_traverse(struct eeh_pe *root,
  153. eeh_traverse_func fn, void *flag)
  154. {
  155. struct eeh_pe *pe;
  156. struct eeh_dev *edev;
  157. void *ret;
  158. if (!root) {
  159. pr_warning("%s: Invalid PE %p\n", __func__, root);
  160. return NULL;
  161. }
  162. /* Traverse root PE */
  163. for (pe = root; pe; pe = eeh_pe_next(pe, root)) {
  164. eeh_pe_for_each_dev(pe, edev) {
  165. ret = fn(edev, flag);
  166. if (ret)
  167. return ret;
  168. }
  169. }
  170. return NULL;
  171. }
  172. /**
  173. * __eeh_pe_get - Check the PE address
  174. * @data: EEH PE
  175. * @flag: EEH device
  176. *
  177. * For one particular PE, it can be identified by PE address
  178. * or tranditional BDF address. BDF address is composed of
  179. * Bus/Device/Function number. The extra data referred by flag
  180. * indicates which type of address should be used.
  181. */
  182. static void *__eeh_pe_get(void *data, void *flag)
  183. {
  184. struct eeh_pe *pe = (struct eeh_pe *)data;
  185. struct eeh_dev *edev = (struct eeh_dev *)flag;
  186. /* Unexpected PHB PE */
  187. if (pe->type & EEH_PE_PHB)
  188. return NULL;
  189. /* We prefer PE address */
  190. if (edev->pe_config_addr &&
  191. (edev->pe_config_addr == pe->addr))
  192. return pe;
  193. /* Try BDF address */
  194. if (edev->config_addr &&
  195. (edev->config_addr == pe->config_addr))
  196. return pe;
  197. return NULL;
  198. }
  199. /**
  200. * eeh_pe_get - Search PE based on the given address
  201. * @edev: EEH device
  202. *
  203. * Search the corresponding PE based on the specified address which
  204. * is included in the eeh device. The function is used to check if
  205. * the associated PE has been created against the PE address. It's
  206. * notable that the PE address has 2 format: traditional PE address
  207. * which is composed of PCI bus/device/function number, or unified
  208. * PE address.
  209. */
  210. struct eeh_pe *eeh_pe_get(struct eeh_dev *edev)
  211. {
  212. struct eeh_pe *root = eeh_phb_pe_get(edev->phb);
  213. struct eeh_pe *pe;
  214. pe = eeh_pe_traverse(root, __eeh_pe_get, edev);
  215. return pe;
  216. }
  217. /**
  218. * eeh_pe_get_parent - Retrieve the parent PE
  219. * @edev: EEH device
  220. *
  221. * The whole PEs existing in the system are organized as hierarchy
  222. * tree. The function is used to retrieve the parent PE according
  223. * to the parent EEH device.
  224. */
  225. static struct eeh_pe *eeh_pe_get_parent(struct eeh_dev *edev)
  226. {
  227. struct device_node *dn;
  228. struct eeh_dev *parent;
  229. /*
  230. * It might have the case for the indirect parent
  231. * EEH device already having associated PE, but
  232. * the direct parent EEH device doesn't have yet.
  233. */
  234. dn = edev->dn->parent;
  235. while (dn) {
  236. /* We're poking out of PCI territory */
  237. if (!PCI_DN(dn)) return NULL;
  238. parent = of_node_to_eeh_dev(dn);
  239. /* We're poking out of PCI territory */
  240. if (!parent) return NULL;
  241. if (parent->pe)
  242. return parent->pe;
  243. dn = dn->parent;
  244. }
  245. return NULL;
  246. }
  247. /**
  248. * eeh_add_to_parent_pe - Add EEH device to parent PE
  249. * @edev: EEH device
  250. *
  251. * Add EEH device to the parent PE. If the parent PE already
  252. * exists, the PE type will be changed to EEH_PE_BUS. Otherwise,
  253. * we have to create new PE to hold the EEH device and the new
  254. * PE will be linked to its parent PE as well.
  255. */
  256. int eeh_add_to_parent_pe(struct eeh_dev *edev)
  257. {
  258. struct eeh_pe *pe, *parent;
  259. /*
  260. * Search the PE has been existing or not according
  261. * to the PE address. If that has been existing, the
  262. * PE should be composed of PCI bus and its subordinate
  263. * components.
  264. */
  265. pe = eeh_pe_get(edev);
  266. if (pe && !(pe->type & EEH_PE_INVALID)) {
  267. if (!edev->pe_config_addr) {
  268. pr_err("%s: PE with addr 0x%x already exists\n",
  269. __func__, edev->config_addr);
  270. return -EEXIST;
  271. }
  272. /* Mark the PE as type of PCI bus */
  273. pe->type = EEH_PE_BUS;
  274. edev->pe = pe;
  275. /* Put the edev to PE */
  276. list_add_tail(&edev->list, &pe->edevs);
  277. pr_debug("EEH: Add %s to Bus PE#%x\n",
  278. edev->dn->full_name, pe->addr);
  279. return 0;
  280. } else if (pe && (pe->type & EEH_PE_INVALID)) {
  281. list_add_tail(&edev->list, &pe->edevs);
  282. edev->pe = pe;
  283. /*
  284. * We're running to here because of PCI hotplug caused by
  285. * EEH recovery. We need clear EEH_PE_INVALID until the top.
  286. */
  287. parent = pe;
  288. while (parent) {
  289. if (!(parent->type & EEH_PE_INVALID))
  290. break;
  291. parent->type &= ~EEH_PE_INVALID;
  292. parent = parent->parent;
  293. }
  294. pr_debug("EEH: Add %s to Device PE#%x, Parent PE#%x\n",
  295. edev->dn->full_name, pe->addr, pe->parent->addr);
  296. return 0;
  297. }
  298. /* Create a new EEH PE */
  299. pe = eeh_pe_alloc(edev->phb, EEH_PE_DEVICE);
  300. if (!pe) {
  301. pr_err("%s: out of memory!\n", __func__);
  302. return -ENOMEM;
  303. }
  304. pe->addr = edev->pe_config_addr;
  305. pe->config_addr = edev->config_addr;
  306. /*
  307. * While doing PE reset, we probably hot-reset the
  308. * upstream bridge. However, the PCI devices including
  309. * the associated EEH devices might be removed when EEH
  310. * core is doing recovery. So that won't safe to retrieve
  311. * the bridge through downstream EEH device. We have to
  312. * trace the parent PCI bus, then the upstream bridge.
  313. */
  314. if (eeh_probe_mode_dev())
  315. pe->bus = eeh_dev_to_pci_dev(edev)->bus;
  316. /*
  317. * Put the new EEH PE into hierarchy tree. If the parent
  318. * can't be found, the newly created PE will be attached
  319. * to PHB directly. Otherwise, we have to associate the
  320. * PE with its parent.
  321. */
  322. parent = eeh_pe_get_parent(edev);
  323. if (!parent) {
  324. parent = eeh_phb_pe_get(edev->phb);
  325. if (!parent) {
  326. pr_err("%s: No PHB PE is found (PHB Domain=%d)\n",
  327. __func__, edev->phb->global_number);
  328. edev->pe = NULL;
  329. kfree(pe);
  330. return -EEXIST;
  331. }
  332. }
  333. pe->parent = parent;
  334. /*
  335. * Put the newly created PE into the child list and
  336. * link the EEH device accordingly.
  337. */
  338. list_add_tail(&pe->child, &parent->child_list);
  339. list_add_tail(&edev->list, &pe->edevs);
  340. edev->pe = pe;
  341. pr_debug("EEH: Add %s to Device PE#%x, Parent PE#%x\n",
  342. edev->dn->full_name, pe->addr, pe->parent->addr);
  343. return 0;
  344. }
  345. /**
  346. * eeh_rmv_from_parent_pe - Remove one EEH device from the associated PE
  347. * @edev: EEH device
  348. * @purge_pe: remove PE or not
  349. *
  350. * The PE hierarchy tree might be changed when doing PCI hotplug.
  351. * Also, the PCI devices or buses could be removed from the system
  352. * during EEH recovery. So we have to call the function remove the
  353. * corresponding PE accordingly if necessary.
  354. */
  355. int eeh_rmv_from_parent_pe(struct eeh_dev *edev, int purge_pe)
  356. {
  357. struct eeh_pe *pe, *parent, *child;
  358. int cnt;
  359. if (!edev->pe) {
  360. pr_warning("%s: No PE found for EEH device %s\n",
  361. __func__, edev->dn->full_name);
  362. return -EEXIST;
  363. }
  364. /* Remove the EEH device */
  365. pe = edev->pe;
  366. edev->pe = NULL;
  367. list_del(&edev->list);
  368. /*
  369. * Check if the parent PE includes any EEH devices.
  370. * If not, we should delete that. Also, we should
  371. * delete the parent PE if it doesn't have associated
  372. * child PEs and EEH devices.
  373. */
  374. while (1) {
  375. parent = pe->parent;
  376. if (pe->type & EEH_PE_PHB)
  377. break;
  378. if (purge_pe) {
  379. if (list_empty(&pe->edevs) &&
  380. list_empty(&pe->child_list)) {
  381. list_del(&pe->child);
  382. kfree(pe);
  383. } else {
  384. break;
  385. }
  386. } else {
  387. if (list_empty(&pe->edevs)) {
  388. cnt = 0;
  389. list_for_each_entry(child, &pe->child_list, child) {
  390. if (!(child->type & EEH_PE_INVALID)) {
  391. cnt++;
  392. break;
  393. }
  394. }
  395. if (!cnt)
  396. pe->type |= EEH_PE_INVALID;
  397. else
  398. break;
  399. }
  400. }
  401. pe = parent;
  402. }
  403. return 0;
  404. }
  405. /**
  406. * eeh_pe_update_time_stamp - Update PE's frozen time stamp
  407. * @pe: EEH PE
  408. *
  409. * We have time stamp for each PE to trace its time of getting
  410. * frozen in last hour. The function should be called to update
  411. * the time stamp on first error of the specific PE. On the other
  412. * handle, we needn't account for errors happened in last hour.
  413. */
  414. void eeh_pe_update_time_stamp(struct eeh_pe *pe)
  415. {
  416. struct timeval tstamp;
  417. if (!pe) return;
  418. if (pe->freeze_count <= 0) {
  419. pe->freeze_count = 0;
  420. do_gettimeofday(&pe->tstamp);
  421. } else {
  422. do_gettimeofday(&tstamp);
  423. if (tstamp.tv_sec - pe->tstamp.tv_sec > 3600) {
  424. pe->tstamp = tstamp;
  425. pe->freeze_count = 0;
  426. }
  427. }
  428. }
  429. /**
  430. * __eeh_pe_state_mark - Mark the state for the PE
  431. * @data: EEH PE
  432. * @flag: state
  433. *
  434. * The function is used to mark the indicated state for the given
  435. * PE. Also, the associated PCI devices will be put into IO frozen
  436. * state as well.
  437. */
  438. static void *__eeh_pe_state_mark(void *data, void *flag)
  439. {
  440. struct eeh_pe *pe = (struct eeh_pe *)data;
  441. int state = *((int *)flag);
  442. struct eeh_dev *tmp;
  443. struct pci_dev *pdev;
  444. /*
  445. * Mark the PE with the indicated state. Also,
  446. * the associated PCI device will be put into
  447. * I/O frozen state to avoid I/O accesses from
  448. * the PCI device driver.
  449. */
  450. pe->state |= state;
  451. eeh_pe_for_each_dev(pe, tmp) {
  452. pdev = eeh_dev_to_pci_dev(tmp);
  453. if (pdev)
  454. pdev->error_state = pci_channel_io_frozen;
  455. }
  456. return NULL;
  457. }
  458. /**
  459. * eeh_pe_state_mark - Mark specified state for PE and its associated device
  460. * @pe: EEH PE
  461. *
  462. * EEH error affects the current PE and its child PEs. The function
  463. * is used to mark appropriate state for the affected PEs and the
  464. * associated devices.
  465. */
  466. void eeh_pe_state_mark(struct eeh_pe *pe, int state)
  467. {
  468. eeh_pe_traverse(pe, __eeh_pe_state_mark, &state);
  469. }
  470. /**
  471. * __eeh_pe_state_clear - Clear state for the PE
  472. * @data: EEH PE
  473. * @flag: state
  474. *
  475. * The function is used to clear the indicated state from the
  476. * given PE. Besides, we also clear the check count of the PE
  477. * as well.
  478. */
  479. static void *__eeh_pe_state_clear(void *data, void *flag)
  480. {
  481. struct eeh_pe *pe = (struct eeh_pe *)data;
  482. int state = *((int *)flag);
  483. pe->state &= ~state;
  484. pe->check_count = 0;
  485. return NULL;
  486. }
  487. /**
  488. * eeh_pe_state_clear - Clear state for the PE and its children
  489. * @pe: PE
  490. * @state: state to be cleared
  491. *
  492. * When the PE and its children has been recovered from error,
  493. * we need clear the error state for that. The function is used
  494. * for the purpose.
  495. */
  496. void eeh_pe_state_clear(struct eeh_pe *pe, int state)
  497. {
  498. eeh_pe_traverse(pe, __eeh_pe_state_clear, &state);
  499. }
  500. /**
  501. * eeh_restore_one_device_bars - Restore the Base Address Registers for one device
  502. * @data: EEH device
  503. * @flag: Unused
  504. *
  505. * Loads the PCI configuration space base address registers,
  506. * the expansion ROM base address, the latency timer, and etc.
  507. * from the saved values in the device node.
  508. */
  509. static void *eeh_restore_one_device_bars(void *data, void *flag)
  510. {
  511. int i;
  512. u32 cmd;
  513. struct eeh_dev *edev = (struct eeh_dev *)data;
  514. struct device_node *dn = eeh_dev_to_of_node(edev);
  515. for (i = 4; i < 10; i++)
  516. eeh_ops->write_config(dn, i*4, 4, edev->config_space[i]);
  517. /* 12 == Expansion ROM Address */
  518. eeh_ops->write_config(dn, 12*4, 4, edev->config_space[12]);
  519. #define BYTE_SWAP(OFF) (8*((OFF)/4)+3-(OFF))
  520. #define SAVED_BYTE(OFF) (((u8 *)(edev->config_space))[BYTE_SWAP(OFF)])
  521. eeh_ops->write_config(dn, PCI_CACHE_LINE_SIZE, 1,
  522. SAVED_BYTE(PCI_CACHE_LINE_SIZE));
  523. eeh_ops->write_config(dn, PCI_LATENCY_TIMER, 1,
  524. SAVED_BYTE(PCI_LATENCY_TIMER));
  525. /* max latency, min grant, interrupt pin and line */
  526. eeh_ops->write_config(dn, 15*4, 4, edev->config_space[15]);
  527. /*
  528. * Restore PERR & SERR bits, some devices require it,
  529. * don't touch the other command bits
  530. */
  531. eeh_ops->read_config(dn, PCI_COMMAND, 4, &cmd);
  532. if (edev->config_space[1] & PCI_COMMAND_PARITY)
  533. cmd |= PCI_COMMAND_PARITY;
  534. else
  535. cmd &= ~PCI_COMMAND_PARITY;
  536. if (edev->config_space[1] & PCI_COMMAND_SERR)
  537. cmd |= PCI_COMMAND_SERR;
  538. else
  539. cmd &= ~PCI_COMMAND_SERR;
  540. eeh_ops->write_config(dn, PCI_COMMAND, 4, cmd);
  541. return NULL;
  542. }
  543. /**
  544. * eeh_pe_restore_bars - Restore the PCI config space info
  545. * @pe: EEH PE
  546. *
  547. * This routine performs a recursive walk to the children
  548. * of this device as well.
  549. */
  550. void eeh_pe_restore_bars(struct eeh_pe *pe)
  551. {
  552. /*
  553. * We needn't take the EEH lock since eeh_pe_dev_traverse()
  554. * will take that.
  555. */
  556. eeh_pe_dev_traverse(pe, eeh_restore_one_device_bars, NULL);
  557. }
  558. /**
  559. * eeh_pe_bus_get - Retrieve PCI bus according to the given PE
  560. * @pe: EEH PE
  561. *
  562. * Retrieve the PCI bus according to the given PE. Basically,
  563. * there're 3 types of PEs: PHB/Bus/Device. For PHB PE, the
  564. * primary PCI bus will be retrieved. The parent bus will be
  565. * returned for BUS PE. However, we don't have associated PCI
  566. * bus for DEVICE PE.
  567. */
  568. struct pci_bus *eeh_pe_bus_get(struct eeh_pe *pe)
  569. {
  570. struct pci_bus *bus = NULL;
  571. struct eeh_dev *edev;
  572. struct pci_dev *pdev;
  573. if (pe->type & EEH_PE_PHB) {
  574. bus = pe->phb->bus;
  575. } else if (pe->type & EEH_PE_BUS ||
  576. pe->type & EEH_PE_DEVICE) {
  577. if (pe->bus) {
  578. bus = pe->bus;
  579. goto out;
  580. }
  581. edev = list_first_entry(&pe->edevs, struct eeh_dev, list);
  582. pdev = eeh_dev_to_pci_dev(edev);
  583. if (pdev)
  584. bus = pdev->bus;
  585. }
  586. out:
  587. return bus;
  588. }