arch/powerpc/platforms/pseries/eeh_pseries.c

   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 devired 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_bridge;
  57 static int ibm_configure_pe;
  58
  59 /*
  60  * Buffer for reporting slot-error-detail rtas calls. Its here
  61  * in BSS, and not dynamically alloced, so that it ends up in
  62  * RMO where RTAS can access it.
  63  */
  64 static unsigned char slot_errbuf[RTAS_ERROR_LOG_MAX];
  65 static DEFINE_SPINLOCK(slot_errbuf_lock);
  66 static int eeh_error_buf_size;
  67
  68 /**
  69  * pseries_eeh_init - EEH platform dependent initialization
  70  *
  71  * EEH platform dependent initialization on pseries.
  72  */
  73 static int pseries_eeh_init(void)
  74 {
  75         /* figure out EEH RTAS function call tokens */
  76         ibm_set_eeh_option              = rtas_token("ibm,set-eeh-option");
  77         ibm_set_slot_reset              = rtas_token("ibm,set-slot-reset");
  78         ibm_read_slot_reset_state2      = rtas_token("ibm,read-slot-reset-state2");
  79         ibm_read_slot_reset_state       = rtas_token("ibm,read-slot-reset-state");
  80         ibm_slot_error_detail           = rtas_token("ibm,slot-error-detail");
  81         ibm_get_config_addr_info2       = rtas_token("ibm,get-config-addr-info2");
  82         ibm_get_config_addr_info        = rtas_token("ibm,get-config-addr-info");
  83         ibm_configure_pe                = rtas_token("ibm,configure-pe");
  84         ibm_configure_bridge            = rtas_token ("ibm,configure-bridge");
  85
  86         /* necessary sanity check */
  87         if (ibm_set_eeh_option == RTAS_UNKNOWN_SERVICE) {
  88                 pr_warning("%s: RTAS service <ibm,set-eeh-option> invalid\n",
  89                         __func__);
  90                 return -EINVAL;
  91         } else if (ibm_set_slot_reset == RTAS_UNKNOWN_SERVICE) {
  92                 pr_warning("%s: RTAS service <ibm, set-slot-reset> invalid\n",
  93                         __func__);
  94                 return -EINVAL;
  95         } else if (ibm_read_slot_reset_state2 == RTAS_UNKNOWN_SERVICE &&
  96                    ibm_read_slot_reset_state == RTAS_UNKNOWN_SERVICE) {
  97                 pr_warning("%s: RTAS service <ibm,read-slot-reset-state2> and "
  98                         "<ibm,read-slot-reset-state> invalid\n",
  99                         __func__);
 100                 return -EINVAL;
 101         } else if (ibm_slot_error_detail == RTAS_UNKNOWN_SERVICE) {
 102                 pr_warning("%s: RTAS service <ibm,slot-error-detail> invalid\n",
 103                         __func__);
 104                 return -EINVAL;
 105         } else if (ibm_get_config_addr_info2 == RTAS_UNKNOWN_SERVICE &&
 106                    ibm_get_config_addr_info == RTAS_UNKNOWN_SERVICE) {
 107                 pr_warning("%s: RTAS service <ibm,get-config-addr-info2> and "
 108                         "<ibm,get-config-addr-info> invalid\n",
 109                         __func__);
 110                 return -EINVAL;
 111         } else if (ibm_configure_pe == RTAS_UNKNOWN_SERVICE &&
 112                    ibm_configure_bridge == RTAS_UNKNOWN_SERVICE) {
 113                 pr_warning("%s: RTAS service <ibm,configure-pe> and "
 114                         "<ibm,configure-bridge> invalid\n",
 115                         __func__);
 116                 return -EINVAL;
 117         }
 118
 119         /* Initialize error log lock and size */
 120         spin_lock_init(&slot_errbuf_lock);
 121         eeh_error_buf_size = rtas_token("rtas-error-log-max");
 122         if (eeh_error_buf_size == RTAS_UNKNOWN_SERVICE) {
 123                 pr_warning("%s: unknown EEH error log size\n",
 124                         __func__);
 125                 eeh_error_buf_size = 1024;
 126         } else if (eeh_error_buf_size > RTAS_ERROR_LOG_MAX) {
 127                 pr_warning("%s: EEH error log size %d exceeds the maximal %d\n",
 128                         __func__, eeh_error_buf_size, RTAS_ERROR_LOG_MAX);
 129                 eeh_error_buf_size = RTAS_ERROR_LOG_MAX;
 130         }
 131
 132         return 0;
 133 }
 134
 135 /**
 136  * pseries_eeh_set_option - Initialize EEH or MMIO/DMA reenable
 137  * @dn: device node
 138  * @option: operation to be issued
 139  *
 140  * The function is used to control the EEH functionality globally.
 141  * Currently, following options are support according to PAPR:
 142  * Enable EEH, Disable EEH, Enable MMIO and Enable DMA
 143  */
 144 static int pseries_eeh_set_option(struct device_node *dn, int option)
 145 {
 146         int ret = 0;
 147         struct eeh_dev *edev;
 148         const u32 *reg;
 149         int config_addr;
 150
 151         edev = of_node_to_eeh_dev(dn);
 152
 153         /*
 154          * When we're enabling or disabling EEH functioality on
 155          * the particular PE, the PE config address is possibly
 156          * unavailable. Therefore, we have to figure it out from
 157          * the FDT node.
 158          */
 159         switch (option) {
 160         case EEH_OPT_DISABLE:
 161         case EEH_OPT_ENABLE:
 162                 reg = of_get_property(dn, "reg", NULL);
 163                 config_addr = reg[0];
 164                 break;
 165
 166         case EEH_OPT_THAW_MMIO:
 167         case EEH_OPT_THAW_DMA:
 168                 config_addr = edev->config_addr;
 169                 if (edev->pe_config_addr)
 170                         config_addr = edev->pe_config_addr;
 171                 break;
 172
 173         default:
 174                 pr_err("%s: Invalid option %d\n",
 175                         __func__, option);
 176                 return -EINVAL;
 177         }
 178
 179         ret = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
 180                         config_addr, BUID_HI(edev->phb->buid),
 181                         BUID_LO(edev->phb->buid), option);
 182
 183         return ret;
 184 }
 185
 186 /**
 187  * pseries_eeh_get_pe_addr - Retrieve PE address
 188  * @dn: device node
 189  *
 190  * Retrieve the assocated PE address. Actually, there're 2 RTAS
 191  * function calls dedicated for the purpose. We need implement
 192  * it through the new function and then the old one. Besides,
 193  * you should make sure the config address is figured out from
 194  * FDT node before calling the function.
 195  *
 196  * It's notable that zero'ed return value means invalid PE config
 197  * address.
 198  */
 199 static int pseries_eeh_get_pe_addr(struct device_node *dn)
 200 {
 201         struct eeh_dev *edev;
 202         int ret = 0;
 203         int rets[3];
 204
 205         edev = of_node_to_eeh_dev(dn);
 206
 207         if (ibm_get_config_addr_info2 != RTAS_UNKNOWN_SERVICE) {
 208                 /*
 209                  * First of all, we need to make sure there has one PE
 210                  * associated with the device. Otherwise, PE address is
 211                  * meaningless.
 212                  */
 213                 ret = rtas_call(ibm_get_config_addr_info2, 4, 2, rets,
 214                                 edev->config_addr, BUID_HI(edev->phb->buid),
 215                                 BUID_LO(edev->phb->buid), 1);
 216                 if (ret || (rets[0] == 0))
 217                         return 0;
 218
 219                 /* Retrieve the associated PE config address */
 220                 ret = rtas_call(ibm_get_config_addr_info2, 4, 2, rets,
 221                                 edev->config_addr, BUID_HI(edev->phb->buid),
 222                                 BUID_LO(edev->phb->buid), 0);
 223                 if (ret) {
 224                         pr_warning("%s: Failed to get PE address for %s\n",
 225                                 __func__, dn->full_name);
 226                         return 0;
 227                 }
 228
 229                 return rets[0];
 230         }
 231
 232         if (ibm_get_config_addr_info != RTAS_UNKNOWN_SERVICE) {
 233                 ret = rtas_call(ibm_get_config_addr_info, 4, 2, rets,
 234                                 edev->config_addr, BUID_HI(edev->phb->buid),
 235                                 BUID_LO(edev->phb->buid), 0);
 236                 if (ret) {
 237                         pr_warning("%s: Failed to get PE address for %s\n",
 238                                 __func__, dn->full_name);
 239                         return 0;
 240                 }
 241
 242                 return rets[0];
 243         }
 244
 245         return ret;
 246 }
 247
 248 /**
 249  * pseries_eeh_get_state - Retrieve PE state
 250  * @dn: PE associated device node
 251  * @state: return value
 252  *
 253  * Retrieve the state of the specified PE. On RTAS compliant
 254  * pseries platform, there already has one dedicated RTAS function
 255  * for the purpose. It's notable that the associated PE config address
 256  * might be ready when calling the function. Therefore, endeavour to
 257  * use the PE config address if possible. Further more, there're 2
 258  * RTAS calls for the purpose, we need to try the new one and back
 259  * to the old one if the new one couldn't work properly.
 260  */
 261 static int pseries_eeh_get_state(struct device_node *dn, int *state)
 262 {
 263         struct eeh_dev *edev;
 264         int config_addr;
 265         int ret;
 266         int rets[4];
 267         int result;
 268
 269         /* Figure out PE config address if possible */
 270         edev = of_node_to_eeh_dev(dn);
 271         config_addr = edev->config_addr;
 272         if (edev->pe_config_addr)
 273                 config_addr = edev->pe_config_addr;
 274
 275         if (ibm_read_slot_reset_state2 != RTAS_UNKNOWN_SERVICE) {
 276                 ret = rtas_call(ibm_read_slot_reset_state2, 3, 4, rets,
 277                                 config_addr, BUID_HI(edev->phb->buid),
 278                                 BUID_LO(edev->phb->buid));
 279         } else if (ibm_read_slot_reset_state != RTAS_UNKNOWN_SERVICE) {
 280                 /* Fake PE unavailable info */
 281                 rets[2] = 0;
 282                 ret = rtas_call(ibm_read_slot_reset_state, 3, 3, rets,
 283                                 config_addr, BUID_HI(edev->phb->buid),
 284                                 BUID_LO(edev->phb->buid));
 285         } else {
 286                 return EEH_STATE_NOT_SUPPORT;
 287         }
 288
 289         if (ret)
 290                 return ret;
 291
 292         /* Parse the result out */
 293         result = 0;
 294         if (rets[1]) {
 295                 switch(rets[0]) {
 296                 case 0:
 297                         result &= ~EEH_STATE_RESET_ACTIVE;
 298                         result |= EEH_STATE_MMIO_ACTIVE;
 299                         result |= EEH_STATE_DMA_ACTIVE;
 300                         break;
 301                 case 1:
 302                         result |= EEH_STATE_RESET_ACTIVE;
 303                         result |= EEH_STATE_MMIO_ACTIVE;
 304                         result |= EEH_STATE_DMA_ACTIVE;
 305                         break;
 306                 case 2:
 307                         result &= ~EEH_STATE_RESET_ACTIVE;
 308                         result &= ~EEH_STATE_MMIO_ACTIVE;
 309                         result &= ~EEH_STATE_DMA_ACTIVE;
 310                         break;
 311                 case 4:
 312                         result &= ~EEH_STATE_RESET_ACTIVE;
 313                         result &= ~EEH_STATE_MMIO_ACTIVE;
 314                         result &= ~EEH_STATE_DMA_ACTIVE;
 315                         result |= EEH_STATE_MMIO_ENABLED;
 316                         break;
 317                 case 5:
 318                         if (rets[2]) {
 319                                 if (state) *state = rets[2];
 320                                 result = EEH_STATE_UNAVAILABLE;
 321                         } else {
 322                                 result = EEH_STATE_NOT_SUPPORT;
 323                         }
 324                 default:
 325                         result = EEH_STATE_NOT_SUPPORT;
 326                 }
 327         } else {
 328                 result = EEH_STATE_NOT_SUPPORT;
 329         }
 330
 331         return result;
 332 }
 333
 334 /**
 335  * pseries_eeh_reset - Reset the specified PE
 336  * @dn: PE associated device node
 337  * @option: reset option
 338  *
 339  * Reset the specified PE
 340  */
 341 static int pseries_eeh_reset(struct device_node *dn, int option)
 342 {
 343         struct eeh_dev *edev;
 344         int config_addr;
 345         int ret;
 346
 347         /* Figure out PE address */
 348         edev = of_node_to_eeh_dev(dn);
 349         config_addr = edev->config_addr;
 350         if (edev->pe_config_addr)
 351                 config_addr = edev->pe_config_addr;
 352
 353         /* Reset PE through RTAS call */
 354         ret = rtas_call(ibm_set_slot_reset, 4, 1, NULL,
 355                         config_addr, BUID_HI(edev->phb->buid),
 356                         BUID_LO(edev->phb->buid), option);
 357
 358         /* If fundamental-reset not supported, try hot-reset */
 359         if (option == EEH_RESET_FUNDAMENTAL &&
 360             ret == -8) {
 361                 ret = rtas_call(ibm_set_slot_reset, 4, 1, NULL,
 362                                 config_addr, BUID_HI(edev->phb->buid),
 363                                 BUID_LO(edev->phb->buid), EEH_RESET_HOT);
 364         }
 365
 366         return ret;
 367 }
 368
 369 /**
 370  * pseries_eeh_wait_state - Wait for PE state
 371  * @dn: PE associated device node
 372  * @max_wait: maximal period in microsecond
 373  *
 374  * Wait for the state of associated PE. It might take some time
 375  * to retrieve the PE's state.
 376  */
 377 static int pseries_eeh_wait_state(struct device_node *dn, int max_wait)
 378 {
 379         int ret;
 380         int mwait;
 381
 382         /*
 383          * According to PAPR, the state of PE might be temporarily
 384          * unavailable. Under the circumstance, we have to wait
 385          * for indicated time determined by firmware. The maximal
 386          * wait time is 5 minutes, which is acquired from the original
 387          * EEH implementation. Also, the original implementation
 388          * also defined the minimal wait time as 1 second.
 389          */
 390 #define EEH_STATE_MIN_WAIT_TIME (1000)
 391 #define EEH_STATE_MAX_WAIT_TIME (300 * 1000)
 392
 393         while (1) {
 394                 ret = pseries_eeh_get_state(dn, &mwait);
 395
 396                 /*
 397                  * If the PE's state is temporarily unavailable,
 398                  * we have to wait for the specified time. Otherwise,
 399                  * the PE's state will be returned immediately.
 400                  */
 401                 if (ret != EEH_STATE_UNAVAILABLE)
 402                         return ret;
 403
 404                 if (max_wait <= 0) {
 405                         pr_warning("%s: Timeout when getting PE's state (%d)\n",
 406                                 __func__, max_wait);
 407                         return EEH_STATE_NOT_SUPPORT;
 408                 }
 409
 410                 if (mwait <= 0) {
 411                         pr_warning("%s: Firmware returned bad wait value %d\n",
 412                                 __func__, mwait);
 413                         mwait = EEH_STATE_MIN_WAIT_TIME;
 414                 } else if (mwait > EEH_STATE_MAX_WAIT_TIME) {
 415                         pr_warning("%s: Firmware returned too long wait value %d\n",
 416                                 __func__, mwait);
 417                         mwait = EEH_STATE_MAX_WAIT_TIME;
 418                 }
 419
 420                 max_wait -= mwait;
 421                 msleep(mwait);
 422         }
 423
 424         return EEH_STATE_NOT_SUPPORT;
 425 }
 426
 427 /**
 428  * pseries_eeh_get_log - Retrieve error log
 429  * @dn: device node
 430  * @severity: temporary or permanent error log
 431  * @drv_log: driver log to be combined with retrieved error log
 432  * @len: length of driver log
 433  *
 434  * Retrieve the temporary or permanent error from the PE.
 435  * Actually, the error will be retrieved through the dedicated
 436  * RTAS call.
 437  */
 438 static int pseries_eeh_get_log(struct device_node *dn, int severity, char *drv_log, unsigned long len)
 439 {
 440         struct eeh_dev *edev;
 441         int config_addr;
 442         unsigned long flags;
 443         int ret;
 444
 445         edev = of_node_to_eeh_dev(dn);
 446         spin_lock_irqsave(&slot_errbuf_lock, flags);
 447         memset(slot_errbuf, 0, eeh_error_buf_size);
 448
 449         /* Figure out the PE address */
 450         config_addr = edev->config_addr;
 451         if (edev->pe_config_addr)
 452                 config_addr = edev->pe_config_addr;
 453
 454         ret = rtas_call(ibm_slot_error_detail, 8, 1, NULL, config_addr,
 455                         BUID_HI(edev->phb->buid), BUID_LO(edev->phb->buid),
 456                         virt_to_phys(drv_log), len,
 457                         virt_to_phys(slot_errbuf), eeh_error_buf_size,
 458                         severity);
 459         if (!ret)
 460                 log_error(slot_errbuf, ERR_TYPE_RTAS_LOG, 0);
 461         spin_unlock_irqrestore(&slot_errbuf_lock, flags);
 462
 463         return ret;
 464 }
 465
 466 /**
 467  * pseries_eeh_configure_bridge - Configure PCI bridges in the indicated PE
 468  * @dn: PE associated device node
 469  *
 470  * The function will be called to reconfigure the bridges included
 471  * in the specified PE so that the mulfunctional PE would be recovered
 472  * again.
 473  */
 474 static int pseries_eeh_configure_bridge(struct device_node *dn)
 475 {
 476         struct eeh_dev *edev;
 477         int config_addr;
 478         int ret;
 479
 480         /* Figure out the PE address */
 481         edev = of_node_to_eeh_dev(dn);
 482         config_addr = edev->config_addr;
 483         if (edev->pe_config_addr)
 484                 config_addr = edev->pe_config_addr;
 485
 486         /* Use new configure-pe function, if supported */
 487         if (ibm_configure_pe != RTAS_UNKNOWN_SERVICE) {
 488                 ret = rtas_call(ibm_configure_pe, 3, 1, NULL,
 489                                 config_addr, BUID_HI(edev->phb->buid),
 490                                 BUID_LO(edev->phb->buid));
 491         } else if (ibm_configure_bridge != RTAS_UNKNOWN_SERVICE) {
 492                 ret = rtas_call(ibm_configure_bridge, 3, 1, NULL,
 493                                 config_addr, BUID_HI(edev->phb->buid),
 494                                 BUID_LO(edev->phb->buid));
 495         } else {
 496                 return -EFAULT;
 497         }
 498
 499         if (ret)
 500                 pr_warning("%s: Unable to configure bridge %d for %s\n",
 501                         __func__, ret, dn->full_name);
 502
 503         return ret;
 504 }
 505
 506 /**
 507  * pseries_eeh_read_config - Read PCI config space
 508  * @dn: device node
 509  * @where: PCI address
 510  * @size: size to read
 511  * @val: return value
 512  *
 513  * Read config space from the speicifed device
 514  */
 515 static int pseries_eeh_read_config(struct device_node *dn, int where, int size, u32 *val)
 516 {
 517         struct pci_dn *pdn;
 518
 519         pdn = PCI_DN(dn);
 520
 521         return rtas_read_config(pdn, where, size, val);
 522 }
 523
 524 /**
 525  * pseries_eeh_write_config - Write PCI config space
 526  * @dn: device node
 527  * @where: PCI address
 528  * @size: size to write
 529  * @val: value to be written
 530  *
 531  * Write config space to the specified device
 532  */
 533 static int pseries_eeh_write_config(struct device_node *dn, int where, int size, u32 val)
 534 {
 535         struct pci_dn *pdn;
 536
 537         pdn = PCI_DN(dn);
 538
 539         return rtas_write_config(pdn, where, size, val);
 540 }
 541
 542 static struct eeh_ops pseries_eeh_ops = {
 543         .name                   = "pseries",
 544         .init                   = pseries_eeh_init,
 545         .set_option             = pseries_eeh_set_option,
 546         .get_pe_addr            = pseries_eeh_get_pe_addr,
 547         .get_state              = pseries_eeh_get_state,
 548         .reset                  = pseries_eeh_reset,
 549         .wait_state             = pseries_eeh_wait_state,
 550         .get_log                = pseries_eeh_get_log,
 551         .configure_bridge       = pseries_eeh_configure_bridge,
 552         .read_config            = pseries_eeh_read_config,
 553         .write_config           = pseries_eeh_write_config
 554 };
 555
 556 /**
 557  * eeh_pseries_init - Register platform dependent EEH operations
 558  *
 559  * EEH initialization on pseries platform. This function should be
 560  * called before any EEH related functions.
 561  */
 562 int __init eeh_pseries_init(void)
 563 {
 564         return eeh_ops_register(&pseries_eeh_ops);
 565 }