~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/platforms/pseries/eeh_pseries.c

Version: ~ [ linux-5.5 ] ~ [ linux-5.4.15 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.98 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.167 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.211 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.211 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * The file intends to implement the platform dependent EEH operations on pseries.
  3  * Actually, the pseries platform is built based on RTAS heavily. That means the
  4  * pseries platform dependent EEH operations will be built on RTAS calls. The functions
  5  * are derived from arch/powerpc/platforms/pseries/eeh.c and necessary cleanup has
  6  * been done.
  7  *
  8  * Copyright Benjamin Herrenschmidt & Gavin Shan, IBM Corporation 2011.
  9  * Copyright IBM Corporation 2001, 2005, 2006
 10  * Copyright Dave Engebretsen & Todd Inglett 2001
 11  * Copyright Linas Vepstas 2005, 2006
 12  *
 13  * This program is free software; you can redistribute it and/or modify
 14  * it under the terms of the GNU General Public License as published by
 15  * the Free Software Foundation; either version 2 of the License, or
 16  * (at your option) any later version.
 17  *
 18  * This program is distributed in the hope that it will be useful,
 19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 21  * GNU General Public License for more details.
 22  *
 23  * You should have received a copy of the GNU General Public License
 24  * along with this program; if not, write to the Free Software
 25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 26  */
 27 
 28 #include <linux/atomic.h>
 29 #include <linux/delay.h>
 30 #include <linux/export.h>
 31 #include <linux/init.h>
 32 #include <linux/list.h>
 33 #include <linux/of.h>
 34 #include <linux/pci.h>
 35 #include <linux/proc_fs.h>
 36 #include <linux/rbtree.h>
 37 #include <linux/sched.h>
 38 #include <linux/seq_file.h>
 39 #include <linux/spinlock.h>
 40 
 41 #include <asm/eeh.h>
 42 #include <asm/eeh_event.h>
 43 #include <asm/io.h>
 44 #include <asm/machdep.h>
 45 #include <asm/ppc-pci.h>
 46 #include <asm/rtas.h>
 47 
 48 /* RTAS tokens */
 49 static int ibm_set_eeh_option;
 50 static int ibm_set_slot_reset;
 51 static int ibm_read_slot_reset_state;
 52 static int ibm_read_slot_reset_state2;
 53 static int ibm_slot_error_detail;
 54 static int ibm_get_config_addr_info;
 55 static int ibm_get_config_addr_info2;
 56 static int ibm_configure_pe;
 57 
 58 #ifdef CONFIG_PCI_IOV
 59 void pseries_pcibios_bus_add_device(struct pci_dev *pdev)
 60 {
 61         struct pci_dn *pdn = pci_get_pdn(pdev);
 62         struct pci_dn *physfn_pdn;
 63         struct eeh_dev *edev;
 64 
 65         if (!pdev->is_virtfn)
 66                 return;
 67 
 68         pdn->device_id  =  pdev->device;
 69         pdn->vendor_id  =  pdev->vendor;
 70         pdn->class_code =  pdev->class;
 71         /*
 72          * Last allow unfreeze return code used for retrieval
 73          * by user space in eeh-sysfs to show the last command
 74          * completion from platform.
 75          */
 76         pdn->last_allow_rc =  0;
 77         physfn_pdn      =  pci_get_pdn(pdev->physfn);
 78         pdn->pe_number  =  physfn_pdn->pe_num_map[pdn->vf_index];
 79         edev = pdn_to_eeh_dev(pdn);
 80 
 81         /*
 82          * The following operations will fail if VF's sysfs files
 83          * aren't created or its resources aren't finalized.
 84          */
 85         eeh_add_device_early(pdn);
 86         eeh_add_device_late(pdev);
 87         edev->pe_config_addr =  (pdn->busno << 16) | (pdn->devfn << 8);
 88         eeh_rmv_from_parent_pe(edev); /* Remove as it is adding to bus pe */
 89         eeh_add_to_parent_pe(edev);   /* Add as VF PE type */
 90         eeh_sysfs_add_device(pdev);
 91 
 92 }
 93 #endif
 94 
 95 /*
 96  * Buffer for reporting slot-error-detail rtas calls. Its here
 97  * in BSS, and not dynamically alloced, so that it ends up in
 98  * RMO where RTAS can access it.
 99  */
100 static unsigned char slot_errbuf[RTAS_ERROR_LOG_MAX];
101 static DEFINE_SPINLOCK(slot_errbuf_lock);
102 static int eeh_error_buf_size;
103 
104 /**
105  * pseries_eeh_init - EEH platform dependent initialization
106  *
107  * EEH platform dependent initialization on pseries.
108  */
109 static int pseries_eeh_init(void)
110 {
111         /* figure out EEH RTAS function call tokens */
112         ibm_set_eeh_option              = rtas_token("ibm,set-eeh-option");
113         ibm_set_slot_reset              = rtas_token("ibm,set-slot-reset");
114         ibm_read_slot_reset_state2      = rtas_token("ibm,read-slot-reset-state2");
115         ibm_read_slot_reset_state       = rtas_token("ibm,read-slot-reset-state");
116         ibm_slot_error_detail           = rtas_token("ibm,slot-error-detail");
117         ibm_get_config_addr_info2       = rtas_token("ibm,get-config-addr-info2");
118         ibm_get_config_addr_info        = rtas_token("ibm,get-config-addr-info");
119         ibm_configure_pe                = rtas_token("ibm,configure-pe");
120 
121         /*
122          * ibm,configure-pe and ibm,configure-bridge have the same semantics,
123          * however ibm,configure-pe can be faster.  If we can't find
124          * ibm,configure-pe then fall back to using ibm,configure-bridge.
125          */
126         if (ibm_configure_pe == RTAS_UNKNOWN_SERVICE)
127                 ibm_configure_pe        = rtas_token("ibm,configure-bridge");
128 
129         /*
130          * Necessary sanity check. We needn't check "get-config-addr-info"
131          * and its variant since the old firmware probably support address
132          * of domain/bus/slot/function for EEH RTAS operations.
133          */
134         if (ibm_set_eeh_option == RTAS_UNKNOWN_SERVICE          ||
135             ibm_set_slot_reset == RTAS_UNKNOWN_SERVICE          ||
136             (ibm_read_slot_reset_state2 == RTAS_UNKNOWN_SERVICE &&
137              ibm_read_slot_reset_state == RTAS_UNKNOWN_SERVICE) ||
138             ibm_slot_error_detail == RTAS_UNKNOWN_SERVICE       ||
139             ibm_configure_pe == RTAS_UNKNOWN_SERVICE) {
140                 pr_info("EEH functionality not supported\n");
141                 return -EINVAL;
142         }
143 
144         /* Initialize error log lock and size */
145         spin_lock_init(&slot_errbuf_lock);
146         eeh_error_buf_size = rtas_token("rtas-error-log-max");
147         if (eeh_error_buf_size == RTAS_UNKNOWN_SERVICE) {
148                 pr_info("%s: unknown EEH error log size\n",
149                         __func__);
150                 eeh_error_buf_size = 1024;
151         } else if (eeh_error_buf_size > RTAS_ERROR_LOG_MAX) {
152                 pr_info("%s: EEH error log size %d exceeds the maximal %d\n",
153                         __func__, eeh_error_buf_size, RTAS_ERROR_LOG_MAX);
154                 eeh_error_buf_size = RTAS_ERROR_LOG_MAX;
155         }
156 
157         /* Set EEH probe mode */
158         eeh_add_flag(EEH_PROBE_MODE_DEVTREE | EEH_ENABLE_IO_FOR_LOG);
159 
160 #ifdef CONFIG_PCI_IOV
161         /* Set EEH machine dependent code */
162         ppc_md.pcibios_bus_add_device = pseries_pcibios_bus_add_device;
163 #endif
164 
165         return 0;
166 }
167 
168 static int pseries_eeh_cap_start(struct pci_dn *pdn)
169 {
170         u32 status;
171 
172         if (!pdn)
173                 return 0;
174 
175         rtas_read_config(pdn, PCI_STATUS, 2, &status);
176         if (!(status & PCI_STATUS_CAP_LIST))
177                 return 0;
178 
179         return PCI_CAPABILITY_LIST;
180 }
181 
182 
183 static int pseries_eeh_find_cap(struct pci_dn *pdn, int cap)
184 {
185         int pos = pseries_eeh_cap_start(pdn);
186         int cnt = 48;   /* Maximal number of capabilities */
187         u32 id;
188 
189         if (!pos)
190                 return 0;
191 
192         while (cnt--) {
193                 rtas_read_config(pdn, pos, 1, &pos);
194                 if (pos < 0x40)
195                         break;
196                 pos &= ~3;
197                 rtas_read_config(pdn, pos + PCI_CAP_LIST_ID, 1, &id);
198                 if (id == 0xff)
199                         break;
200                 if (id == cap)
201                         return pos;
202                 pos += PCI_CAP_LIST_NEXT;
203         }
204 
205         return 0;
206 }
207 
208 static int pseries_eeh_find_ecap(struct pci_dn *pdn, int cap)
209 {
210         struct eeh_dev *edev = pdn_to_eeh_dev(pdn);
211         u32 header;
212         int pos = 256;
213         int ttl = (4096 - 256) / 8;
214 
215         if (!edev || !edev->pcie_cap)
216                 return 0;
217         if (rtas_read_config(pdn, pos, 4, &header) != PCIBIOS_SUCCESSFUL)
218                 return 0;
219         else if (!header)
220                 return 0;
221 
222         while (ttl-- > 0) {
223                 if (PCI_EXT_CAP_ID(header) == cap && pos)
224                         return pos;
225 
226                 pos = PCI_EXT_CAP_NEXT(header);
227                 if (pos < 256)
228                         break;
229 
230                 if (rtas_read_config(pdn, pos, 4, &header) != PCIBIOS_SUCCESSFUL)
231                         break;
232         }
233 
234         return 0;
235 }
236 
237 /**
238  * pseries_eeh_probe - EEH probe on the given device
239  * @pdn: PCI device node
240  * @data: Unused
241  *
242  * When EEH module is installed during system boot, all PCI devices
243  * are checked one by one to see if it supports EEH. The function
244  * is introduced for the purpose.
245  */
246 static void *pseries_eeh_probe(struct pci_dn *pdn, void *data)
247 {
248         struct eeh_dev *edev;
249         struct eeh_pe pe;
250         u32 pcie_flags;
251         int enable = 0;
252         int ret;
253 
254         /* Retrieve OF node and eeh device */
255         edev = pdn_to_eeh_dev(pdn);
256         if (!edev || edev->pe)
257                 return NULL;
258 
259         /* Check class/vendor/device IDs */
260         if (!pdn->vendor_id || !pdn->device_id || !pdn->class_code)
261                 return NULL;
262 
263         /* Skip for PCI-ISA bridge */
264         if ((pdn->class_code >> 8) == PCI_CLASS_BRIDGE_ISA)
265                 return NULL;
266 
267         /*
268          * Update class code and mode of eeh device. We need
269          * correctly reflects that current device is root port
270          * or PCIe switch downstream port.
271          */
272         edev->class_code = pdn->class_code;
273         edev->pcix_cap = pseries_eeh_find_cap(pdn, PCI_CAP_ID_PCIX);
274         edev->pcie_cap = pseries_eeh_find_cap(pdn, PCI_CAP_ID_EXP);
275         edev->aer_cap = pseries_eeh_find_ecap(pdn, PCI_EXT_CAP_ID_ERR);
276         edev->mode &= 0xFFFFFF00;
277         if ((edev->class_code >> 8) == PCI_CLASS_BRIDGE_PCI) {
278                 edev->mode |= EEH_DEV_BRIDGE;
279                 if (edev->pcie_cap) {
280                         rtas_read_config(pdn, edev->pcie_cap + PCI_EXP_FLAGS,
281                                          2, &pcie_flags);
282                         pcie_flags = (pcie_flags & PCI_EXP_FLAGS_TYPE) >> 4;
283                         if (pcie_flags == PCI_EXP_TYPE_ROOT_PORT)
284                                 edev->mode |= EEH_DEV_ROOT_PORT;
285                         else if (pcie_flags == PCI_EXP_TYPE_DOWNSTREAM)
286                                 edev->mode |= EEH_DEV_DS_PORT;
287                 }
288         }
289 
290         /* Initialize the fake PE */
291         memset(&pe, 0, sizeof(struct eeh_pe));
292         pe.phb = pdn->phb;
293         pe.config_addr = (pdn->busno << 16) | (pdn->devfn << 8);
294 
295         /* Enable EEH on the device */
296         ret = eeh_ops->set_option(&pe, EEH_OPT_ENABLE);
297         if (!ret) {
298                 /* Retrieve PE address */
299                 edev->pe_config_addr = eeh_ops->get_pe_addr(&pe);
300                 pe.addr = edev->pe_config_addr;
301 
302                 /* Some older systems (Power4) allow the ibm,set-eeh-option
303                  * call to succeed even on nodes where EEH is not supported.
304                  * Verify support explicitly.
305                  */
306                 ret = eeh_ops->get_state(&pe, NULL);
307                 if (ret > 0 && ret != EEH_STATE_NOT_SUPPORT)
308                         enable = 1;
309 
310                 if (enable) {
311                         eeh_add_flag(EEH_ENABLED);
312                         eeh_add_to_parent_pe(edev);
313 
314                         pr_debug("%s: EEH enabled on %02x:%02x.%01x PHB#%x-PE#%x\n",
315                                 __func__, pdn->busno, PCI_SLOT(pdn->devfn),
316                                 PCI_FUNC(pdn->devfn), pe.phb->global_number,
317                                 pe.addr);
318                 } else if (pdn->parent && pdn_to_eeh_dev(pdn->parent) &&
319                            (pdn_to_eeh_dev(pdn->parent))->pe) {
320                         /* This device doesn't support EEH, but it may have an
321                          * EEH parent, in which case we mark it as supported.
322                          */
323                         edev->pe_config_addr = pdn_to_eeh_dev(pdn->parent)->pe_config_addr;
324                         eeh_add_to_parent_pe(edev);
325                 }
326         }
327 
328         /* Save memory bars */
329         eeh_save_bars(edev);
330 
331         return NULL;
332 }
333 
334 /**
335  * pseries_eeh_set_option - Initialize EEH or MMIO/DMA reenable
336  * @pe: EEH PE
337  * @option: operation to be issued
338  *
339  * The function is used to control the EEH functionality globally.
340  * Currently, following options are support according to PAPR:
341  * Enable EEH, Disable EEH, Enable MMIO and Enable DMA
342  */
343 static int pseries_eeh_set_option(struct eeh_pe *pe, int option)
344 {
345         int ret = 0;
346         int config_addr;
347 
348         /*
349          * When we're enabling or disabling EEH functioality on
350          * the particular PE, the PE config address is possibly
351          * unavailable. Therefore, we have to figure it out from
352          * the FDT node.
353          */
354         switch (option) {
355         case EEH_OPT_DISABLE:
356         case EEH_OPT_ENABLE:
357         case EEH_OPT_THAW_MMIO:
358         case EEH_OPT_THAW_DMA:
359                 config_addr = pe->config_addr;
360                 if (pe->addr)
361                         config_addr = pe->addr;
362                 break;
363         case EEH_OPT_FREEZE_PE:
364                 /* Not support */
365                 return 0;
366         default:
367                 pr_err("%s: Invalid option %d\n",
368                         __func__, option);
369                 return -EINVAL;
370         }
371 
372         ret = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
373                         config_addr, BUID_HI(pe->phb->buid),
374                         BUID_LO(pe->phb->buid), option);
375 
376         return ret;
377 }
378 
379 /**
380  * pseries_eeh_get_pe_addr - Retrieve PE address
381  * @pe: EEH PE
382  *
383  * Retrieve the assocated PE address. Actually, there're 2 RTAS
384  * function calls dedicated for the purpose. We need implement
385  * it through the new function and then the old one. Besides,
386  * you should make sure the config address is figured out from
387  * FDT node before calling the function.
388  *
389  * It's notable that zero'ed return value means invalid PE config
390  * address.
391  */
392 static int pseries_eeh_get_pe_addr(struct eeh_pe *pe)
393 {
394         int ret = 0;
395         int rets[3];
396 
397         if (ibm_get_config_addr_info2 != RTAS_UNKNOWN_SERVICE) {
398                 /*
399                  * First of all, we need to make sure there has one PE
400                  * associated with the device. Otherwise, PE address is
401                  * meaningless.
402                  */
403                 ret = rtas_call(ibm_get_config_addr_info2, 4, 2, rets,
404                                 pe->config_addr, BUID_HI(pe->phb->buid),
405                                 BUID_LO(pe->phb->buid), 1);
406                 if (ret || (rets[0] == 0))
407                         return 0;
408 
409                 /* Retrieve the associated PE config address */
410                 ret = rtas_call(ibm_get_config_addr_info2, 4, 2, rets,
411                                 pe->config_addr, BUID_HI(pe->phb->buid),
412                                 BUID_LO(pe->phb->buid), 0);
413                 if (ret) {
414                         pr_warn("%s: Failed to get address for PHB#%x-PE#%x\n",
415                                 __func__, pe->phb->global_number, pe->config_addr);
416                         return 0;
417                 }
418 
419                 return rets[0];
420         }
421 
422         if (ibm_get_config_addr_info != RTAS_UNKNOWN_SERVICE) {
423                 ret = rtas_call(ibm_get_config_addr_info, 4, 2, rets,
424                                 pe->config_addr, BUID_HI(pe->phb->buid),
425                                 BUID_LO(pe->phb->buid), 0);
426                 if (ret) {
427                         pr_warn("%s: Failed to get address for PHB#%x-PE#%x\n",
428                                 __func__, pe->phb->global_number, pe->config_addr);
429                         return 0;
430                 }
431 
432                 return rets[0];
433         }
434 
435         return ret;
436 }
437 
438 /**
439  * pseries_eeh_get_state - Retrieve PE state
440  * @pe: EEH PE
441  * @delay: suggested time to wait if state is unavailable
442  *
443  * Retrieve the state of the specified PE. On RTAS compliant
444  * pseries platform, there already has one dedicated RTAS function
445  * for the purpose. It's notable that the associated PE config address
446  * might be ready when calling the function. Therefore, endeavour to
447  * use the PE config address if possible. Further more, there're 2
448  * RTAS calls for the purpose, we need to try the new one and back
449  * to the old one if the new one couldn't work properly.
450  */
451 static int pseries_eeh_get_state(struct eeh_pe *pe, int *delay)
452 {
453         int config_addr;
454         int ret;
455         int rets[4];
456         int result;
457 
458         /* Figure out PE config address if possible */
459         config_addr = pe->config_addr;
460         if (pe->addr)
461                 config_addr = pe->addr;
462 
463         if (ibm_read_slot_reset_state2 != RTAS_UNKNOWN_SERVICE) {
464                 ret = rtas_call(ibm_read_slot_reset_state2, 3, 4, rets,
465                                 config_addr, BUID_HI(pe->phb->buid),
466                                 BUID_LO(pe->phb->buid));
467         } else if (ibm_read_slot_reset_state != RTAS_UNKNOWN_SERVICE) {
468                 /* Fake PE unavailable info */
469                 rets[2] = 0;
470                 ret = rtas_call(ibm_read_slot_reset_state, 3, 3, rets,
471                                 config_addr, BUID_HI(pe->phb->buid),
472                                 BUID_LO(pe->phb->buid));
473         } else {
474                 return EEH_STATE_NOT_SUPPORT;
475         }
476 
477         if (ret)
478                 return ret;
479 
480         /* Parse the result out */
481         if (!rets[1])
482                 return EEH_STATE_NOT_SUPPORT;
483 
484         switch(rets[0]) {
485         case 0:
486                 result = EEH_STATE_MMIO_ACTIVE |
487                          EEH_STATE_DMA_ACTIVE;
488                 break;
489         case 1:
490                 result = EEH_STATE_RESET_ACTIVE |
491                          EEH_STATE_MMIO_ACTIVE  |
492                          EEH_STATE_DMA_ACTIVE;
493                 break;
494         case 2:
495                 result = 0;
496                 break;
497         case 4:
498                 result = EEH_STATE_MMIO_ENABLED;
499                 break;
500         case 5:
501                 if (rets[2]) {
502                         if (delay)
503                                 *delay = rets[2];
504                         result = EEH_STATE_UNAVAILABLE;
505                 } else {
506                         result = EEH_STATE_NOT_SUPPORT;
507                 }
508                 break;
509         default:
510                 result = EEH_STATE_NOT_SUPPORT;
511         }
512 
513         return result;
514 }
515 
516 /**
517  * pseries_eeh_reset - Reset the specified PE
518  * @pe: EEH PE
519  * @option: reset option
520  *
521  * Reset the specified PE
522  */
523 static int pseries_eeh_reset(struct eeh_pe *pe, int option)
524 {
525         int config_addr;
526         int ret;
527 
528         /* Figure out PE address */
529         config_addr = pe->config_addr;
530         if (pe->addr)
531                 config_addr = pe->addr;
532 
533         /* Reset PE through RTAS call */
534         ret = rtas_call(ibm_set_slot_reset, 4, 1, NULL,
535                         config_addr, BUID_HI(pe->phb->buid),
536                         BUID_LO(pe->phb->buid), option);
537 
538         /* If fundamental-reset not supported, try hot-reset */
539         if (option == EEH_RESET_FUNDAMENTAL &&
540             ret == -8) {
541                 option = EEH_RESET_HOT;
542                 ret = rtas_call(ibm_set_slot_reset, 4, 1, NULL,
543                                 config_addr, BUID_HI(pe->phb->buid),
544                                 BUID_LO(pe->phb->buid), option);
545         }
546 
547         /* We need reset hold or settlement delay */
548         if (option == EEH_RESET_FUNDAMENTAL ||
549             option == EEH_RESET_HOT)
550                 msleep(EEH_PE_RST_HOLD_TIME);
551         else
552                 msleep(EEH_PE_RST_SETTLE_TIME);
553 
554         return ret;
555 }
556 
557 /**
558  * pseries_eeh_get_log - Retrieve error log
559  * @pe: EEH PE
560  * @severity: temporary or permanent error log
561  * @drv_log: driver log to be combined with retrieved error log
562  * @len: length of driver log
563  *
564  * Retrieve the temporary or permanent error from the PE.
565  * Actually, the error will be retrieved through the dedicated
566  * RTAS call.
567  */
568 static int pseries_eeh_get_log(struct eeh_pe *pe, int severity, char *drv_log, unsigned long len)
569 {
570         int config_addr;
571         unsigned long flags;
572         int ret;
573 
574         spin_lock_irqsave(&slot_errbuf_lock, flags);
575         memset(slot_errbuf, 0, eeh_error_buf_size);
576 
577         /* Figure out the PE address */
578         config_addr = pe->config_addr;
579         if (pe->addr)
580                 config_addr = pe->addr;
581 
582         ret = rtas_call(ibm_slot_error_detail, 8, 1, NULL, config_addr,
583                         BUID_HI(pe->phb->buid), BUID_LO(pe->phb->buid),
584                         virt_to_phys(drv_log), len,
585                         virt_to_phys(slot_errbuf), eeh_error_buf_size,
586                         severity);
587         if (!ret)
588                 log_error(slot_errbuf, ERR_TYPE_RTAS_LOG, 0);
589         spin_unlock_irqrestore(&slot_errbuf_lock, flags);
590 
591         return ret;
592 }
593 
594 /**
595  * pseries_eeh_configure_bridge - Configure PCI bridges in the indicated PE
596  * @pe: EEH PE
597  *
598  * The function will be called to reconfigure the bridges included
599  * in the specified PE so that the mulfunctional PE would be recovered
600  * again.
601  */
602 static int pseries_eeh_configure_bridge(struct eeh_pe *pe)
603 {
604         int config_addr;
605         int ret;
606         /* Waiting 0.2s maximum before skipping configuration */
607         int max_wait = 200;
608 
609         /* Figure out the PE address */
610         config_addr = pe->config_addr;
611         if (pe->addr)
612                 config_addr = pe->addr;
613 
614         while (max_wait > 0) {
615                 ret = rtas_call(ibm_configure_pe, 3, 1, NULL,
616                                 config_addr, BUID_HI(pe->phb->buid),
617                                 BUID_LO(pe->phb->buid));
618 
619                 if (!ret)
620                         return ret;
621 
622                 /*
623                  * If RTAS returns a delay value that's above 100ms, cut it
624                  * down to 100ms in case firmware made a mistake.  For more
625                  * on how these delay values work see rtas_busy_delay_time
626                  */
627                 if (ret > RTAS_EXTENDED_DELAY_MIN+2 &&
628                     ret <= RTAS_EXTENDED_DELAY_MAX)
629                         ret = RTAS_EXTENDED_DELAY_MIN+2;
630 
631                 max_wait -= rtas_busy_delay_time(ret);
632 
633                 if (max_wait < 0)
634                         break;
635 
636                 rtas_busy_delay(ret);
637         }
638 
639         pr_warn("%s: Unable to configure bridge PHB#%x-PE#%x (%d)\n",
640                 __func__, pe->phb->global_number, pe->addr, ret);
641         return ret;
642 }
643 
644 /**
645  * pseries_eeh_read_config - Read PCI config space
646  * @pdn: PCI device node
647  * @where: PCI address
648  * @size: size to read
649  * @val: return value
650  *
651  * Read config space from the speicifed device
652  */
653 static int pseries_eeh_read_config(struct pci_dn *pdn, int where, int size, u32 *val)
654 {
655         return rtas_read_config(pdn, where, size, val);
656 }
657 
658 /**
659  * pseries_eeh_write_config - Write PCI config space
660  * @pdn: PCI device node
661  * @where: PCI address
662  * @size: size to write
663  * @val: value to be written
664  *
665  * Write config space to the specified device
666  */
667 static int pseries_eeh_write_config(struct pci_dn *pdn, int where, int size, u32 val)
668 {
669         return rtas_write_config(pdn, where, size, val);
670 }
671 
672 static int pseries_eeh_restore_config(struct pci_dn *pdn)
673 {
674         struct eeh_dev *edev = pdn_to_eeh_dev(pdn);
675         s64 ret = 0;
676 
677         if (!edev)
678                 return -EEXIST;
679 
680         /*
681          * FIXME: The MPS, error routing rules, timeout setting are worthy
682          * to be exported by firmware in extendible way.
683          */
684         if (edev->physfn)
685                 ret = eeh_restore_vf_config(pdn);
686 
687         if (ret) {
688                 pr_warn("%s: Can't reinit PCI dev 0x%x (%lld)\n",
689                         __func__, edev->pe_config_addr, ret);
690                 return -EIO;
691         }
692 
693         return ret;
694 }
695 
696 #ifdef CONFIG_PCI_IOV
697 int pseries_send_allow_unfreeze(struct pci_dn *pdn,
698                                 u16 *vf_pe_array, int cur_vfs)
699 {
700         int rc;
701         int ibm_allow_unfreeze = rtas_token("ibm,open-sriov-allow-unfreeze");
702         unsigned long buid, addr;
703 
704         addr = rtas_config_addr(pdn->busno, pdn->devfn, 0);
705         buid = pdn->phb->buid;
706         spin_lock(&rtas_data_buf_lock);
707         memcpy(rtas_data_buf, vf_pe_array, RTAS_DATA_BUF_SIZE);
708         rc = rtas_call(ibm_allow_unfreeze, 5, 1, NULL,
709                        addr,
710                        BUID_HI(buid),
711                        BUID_LO(buid),
712                        rtas_data_buf, cur_vfs * sizeof(u16));
713         spin_unlock(&rtas_data_buf_lock);
714         if (rc)
715                 pr_warn("%s: Failed to allow unfreeze for PHB#%x-PE#%lx, rc=%x\n",
716                         __func__,
717                         pdn->phb->global_number, addr, rc);
718         return rc;
719 }
720 
721 static int pseries_call_allow_unfreeze(struct eeh_dev *edev)
722 {
723         struct pci_dn *pdn, *tmp, *parent, *physfn_pdn;
724         int cur_vfs = 0, rc = 0, vf_index, bus, devfn;
725         u16 *vf_pe_array;
726 
727         vf_pe_array = kzalloc(RTAS_DATA_BUF_SIZE, GFP_KERNEL);
728         if (!vf_pe_array)
729                 return -ENOMEM;
730         if (pci_num_vf(edev->physfn ? edev->physfn : edev->pdev)) {
731                 if (edev->pdev->is_physfn) {
732                         cur_vfs = pci_num_vf(edev->pdev);
733                         pdn = eeh_dev_to_pdn(edev);
734                         parent = pdn->parent;
735                         for (vf_index = 0; vf_index < cur_vfs; vf_index++)
736                                 vf_pe_array[vf_index] =
737                                         cpu_to_be16(pdn->pe_num_map[vf_index]);
738                         rc = pseries_send_allow_unfreeze(pdn, vf_pe_array,
739                                                          cur_vfs);
740                         pdn->last_allow_rc = rc;
741                         for (vf_index = 0; vf_index < cur_vfs; vf_index++) {
742                                 list_for_each_entry_safe(pdn, tmp,
743                                                          &parent->child_list,
744                                                          list) {
745                                         bus = pci_iov_virtfn_bus(edev->pdev,
746                                                                  vf_index);
747                                         devfn = pci_iov_virtfn_devfn(edev->pdev,
748                                                                      vf_index);
749                                         if (pdn->busno != bus ||
750                                             pdn->devfn != devfn)
751                                                 continue;
752                                         pdn->last_allow_rc = rc;
753                                 }
754                         }
755                 } else {
756                         pdn = pci_get_pdn(edev->pdev);
757                         vf_pe_array[0] = cpu_to_be16(pdn->pe_number);
758                         physfn_pdn = pci_get_pdn(edev->physfn);
759                         rc = pseries_send_allow_unfreeze(physfn_pdn,
760                                                          vf_pe_array, 1);
761                         pdn->last_allow_rc = rc;
762                 }
763         }
764 
765         kfree(vf_pe_array);
766         return rc;
767 }
768 
769 static int pseries_notify_resume(struct pci_dn *pdn)
770 {
771         struct eeh_dev *edev = pdn_to_eeh_dev(pdn);
772 
773         if (!edev)
774                 return -EEXIST;
775 
776         if (rtas_token("ibm,open-sriov-allow-unfreeze")
777             == RTAS_UNKNOWN_SERVICE)
778                 return -EINVAL;
779 
780         if (edev->pdev->is_physfn || edev->pdev->is_virtfn)
781                 return pseries_call_allow_unfreeze(edev);
782 
783         return 0;
784 }
785 #endif
786 
787 static struct eeh_ops pseries_eeh_ops = {
788         .name                   = "pseries",
789         .init                   = pseries_eeh_init,
790         .probe                  = pseries_eeh_probe,
791         .set_option             = pseries_eeh_set_option,
792         .get_pe_addr            = pseries_eeh_get_pe_addr,
793         .get_state              = pseries_eeh_get_state,
794         .reset                  = pseries_eeh_reset,
795         .get_log                = pseries_eeh_get_log,
796         .configure_bridge       = pseries_eeh_configure_bridge,
797         .err_inject             = NULL,
798         .read_config            = pseries_eeh_read_config,
799         .write_config           = pseries_eeh_write_config,
800         .next_error             = NULL,
801         .restore_config         = pseries_eeh_restore_config,
802 #ifdef CONFIG_PCI_IOV
803         .notify_resume          = pseries_notify_resume
804 #endif
805 };
806 
807 /**
808  * eeh_pseries_init - Register platform dependent EEH operations
809  *
810  * EEH initialization on pseries platform. This function should be
811  * called before any EEH related functions.
812  */
813 static int __init eeh_pseries_init(void)
814 {
815         int ret;
816 
817         ret = eeh_ops_register(&pseries_eeh_ops);
818         if (!ret)
819                 pr_info("EEH: pSeries platform initialized\n");
820         else
821                 pr_info("EEH: pSeries platform initialization failure (%d)\n",
822                         ret);
823 
824         return ret;
825 }
826 machine_early_initcall(pseries, eeh_pseries_init);
827 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp