drivers/misc/smpro-errmon.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Ampere Computing SoC's SMpro Error Monitoring Driver
   4  *
   5  * Copyright (c) 2022, Ampere Computing LLC
   6  *
   7  */
   8
   9 #include <linux/i2c.h>
  10 #include <linux/mod_devicetable.h>
  11 #include <linux/module.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/regmap.h>
  14
  15 /* GPI RAS Error Registers */
  16 #define GPI_RAS_ERR             0x7E
  17
  18 /* Core and L2C Error Registers */
  19 #define CORE_CE_ERR_CNT         0x80
  20 #define CORE_CE_ERR_LEN         0x81
  21 #define CORE_CE_ERR_DATA        0x82
  22 #define CORE_UE_ERR_CNT         0x83
  23 #define CORE_UE_ERR_LEN         0x84
  24 #define CORE_UE_ERR_DATA        0x85
  25
  26 /* Memory Error Registers */
  27 #define MEM_CE_ERR_CNT          0x90
  28 #define MEM_CE_ERR_LEN          0x91
  29 #define MEM_CE_ERR_DATA         0x92
  30 #define MEM_UE_ERR_CNT          0x93
  31 #define MEM_UE_ERR_LEN          0x94
  32 #define MEM_UE_ERR_DATA         0x95
  33
  34 /* RAS Error/Warning Registers */
  35 #define ERR_SMPRO_TYPE          0xA0
  36 #define ERR_PMPRO_TYPE          0xA1
  37 #define ERR_SMPRO_INFO_LO       0xA2
  38 #define ERR_SMPRO_INFO_HI       0xA3
  39 #define ERR_SMPRO_DATA_LO       0xA4
  40 #define ERR_SMPRO_DATA_HI       0xA5
  41 #define WARN_SMPRO_INFO_LO      0xAA
  42 #define WARN_SMPRO_INFO_HI      0xAB
  43 #define ERR_PMPRO_INFO_LO       0xA6
  44 #define ERR_PMPRO_INFO_HI       0xA7
  45 #define ERR_PMPRO_DATA_LO       0xA8
  46 #define ERR_PMPRO_DATA_HI       0xA9
  47 #define WARN_PMPRO_INFO_LO      0xAC
  48 #define WARN_PMPRO_INFO_HI      0xAD
  49
  50 /* Boot Stage Register */
  51 #define BOOTSTAGE               0xB0
  52 #define DIMM_SYNDROME_SEL       0xB4
  53 #define DIMM_SYNDROME_ERR       0xB5
  54 #define DIMM_SYNDROME_STAGE     4
  55
  56 /* PCIE Error Registers */
  57 #define PCIE_CE_ERR_CNT         0xC0
  58 #define PCIE_CE_ERR_LEN         0xC1
  59 #define PCIE_CE_ERR_DATA        0xC2
  60 #define PCIE_UE_ERR_CNT         0xC3
  61 #define PCIE_UE_ERR_LEN         0xC4
  62 #define PCIE_UE_ERR_DATA        0xC5
  63
  64 /* Other Error Registers */
  65 #define OTHER_CE_ERR_CNT        0xD0
  66 #define OTHER_CE_ERR_LEN        0xD1
  67 #define OTHER_CE_ERR_DATA       0xD2
  68 #define OTHER_UE_ERR_CNT        0xD8
  69 #define OTHER_UE_ERR_LEN        0xD9
  70 #define OTHER_UE_ERR_DATA       0xDA
  71
  72 /* Event Data Registers */
  73 #define VRD_WARN_FAULT_EVENT_DATA       0x78
  74 #define VRD_HOT_EVENT_DATA              0x79
  75 #define DIMM_HOT_EVENT_DATA             0x7A
  76 #define DIMM_2X_REFRESH_EVENT_DATA      0x96
  77
  78 #define MAX_READ_BLOCK_LENGTH   48
  79
  80 #define RAS_SMPRO_ERR           0
  81 #define RAS_PMPRO_ERR           1
  82
  83 enum RAS_48BYTES_ERR_TYPES {
  84         CORE_CE_ERR,
  85         CORE_UE_ERR,
  86         MEM_CE_ERR,
  87         MEM_UE_ERR,
  88         PCIE_CE_ERR,
  89         PCIE_UE_ERR,
  90         OTHER_CE_ERR,
  91         OTHER_UE_ERR,
  92         NUM_48BYTES_ERR_TYPE,
  93 };
  94
  95 struct smpro_error_hdr {
  96         u8 count;       /* Number of the RAS errors */
  97         u8 len;         /* Number of data bytes */
  98         u8 data;        /* Start of 48-byte data */
  99         u8 max_cnt;     /* Max num of errors */
 100 };
 101
 102 /*
 103  * Included Address of registers to get Count, Length of data and Data
 104  * of the 48 bytes error data
 105  */
 106 static struct smpro_error_hdr smpro_error_table[] = {
 107         [CORE_CE_ERR] = {
 108                 .count = CORE_CE_ERR_CNT,
 109                 .len = CORE_CE_ERR_LEN,
 110                 .data = CORE_CE_ERR_DATA,
 111                 .max_cnt = 32
 112         },
 113         [CORE_UE_ERR] = {
 114                 .count = CORE_UE_ERR_CNT,
 115                 .len = CORE_UE_ERR_LEN,
 116                 .data = CORE_UE_ERR_DATA,
 117                 .max_cnt = 32
 118         },
 119         [MEM_CE_ERR] = {
 120                 .count = MEM_CE_ERR_CNT,
 121                 .len = MEM_CE_ERR_LEN,
 122                 .data = MEM_CE_ERR_DATA,
 123                 .max_cnt = 16
 124         },
 125         [MEM_UE_ERR] = {
 126                 .count = MEM_UE_ERR_CNT,
 127                 .len = MEM_UE_ERR_LEN,
 128                 .data = MEM_UE_ERR_DATA,
 129                 .max_cnt = 16
 130         },
 131         [PCIE_CE_ERR] = {
 132                 .count = PCIE_CE_ERR_CNT,
 133                 .len = PCIE_CE_ERR_LEN,
 134                 .data = PCIE_CE_ERR_DATA,
 135                 .max_cnt = 96
 136         },
 137         [PCIE_UE_ERR] = {
 138                 .count = PCIE_UE_ERR_CNT,
 139                 .len = PCIE_UE_ERR_LEN,
 140                 .data = PCIE_UE_ERR_DATA,
 141                 .max_cnt = 96
 142         },
 143         [OTHER_CE_ERR] = {
 144                 .count = OTHER_CE_ERR_CNT,
 145                 .len = OTHER_CE_ERR_LEN,
 146                 .data = OTHER_CE_ERR_DATA,
 147                 .max_cnt = 8
 148         },
 149         [OTHER_UE_ERR] = {
 150                 .count = OTHER_UE_ERR_CNT,
 151                 .len = OTHER_UE_ERR_LEN,
 152                 .data = OTHER_UE_ERR_DATA,
 153                 .max_cnt = 8
 154         },
 155 };
 156
 157 /*
 158  * List of SCP registers which are used to get
 159  * one type of RAS Internal errors.
 160  */
 161 struct smpro_int_error_hdr {
 162         u8 type;
 163         u8 info_l;
 164         u8 info_h;
 165         u8 data_l;
 166         u8 data_h;
 167         u8 warn_l;
 168         u8 warn_h;
 169 };
 170
 171 static struct smpro_int_error_hdr list_smpro_int_error_hdr[] = {
 172         [RAS_SMPRO_ERR] = {
 173                 .type = ERR_SMPRO_TYPE,
 174                 .info_l = ERR_SMPRO_INFO_LO,
 175                 .info_h = ERR_SMPRO_INFO_HI,
 176                 .data_l = ERR_SMPRO_DATA_LO,
 177                 .data_h = ERR_SMPRO_DATA_HI,
 178                 .warn_l = WARN_SMPRO_INFO_LO,
 179                 .warn_h = WARN_SMPRO_INFO_HI,
 180         },
 181         [RAS_PMPRO_ERR] = {
 182                 .type = ERR_PMPRO_TYPE,
 183                 .info_l = ERR_PMPRO_INFO_LO,
 184                 .info_h = ERR_PMPRO_INFO_HI,
 185                 .data_l = ERR_PMPRO_DATA_LO,
 186                 .data_h = ERR_PMPRO_DATA_HI,
 187                 .warn_l = WARN_PMPRO_INFO_LO,
 188                 .warn_h = WARN_PMPRO_INFO_HI,
 189         },
 190 };
 191
 192 struct smpro_errmon {
 193         struct regmap *regmap;
 194 };
 195
 196 enum EVENT_TYPES {
 197         VRD_WARN_FAULT_EVENT,
 198         VRD_HOT_EVENT,
 199         DIMM_HOT_EVENT,
 200         DIMM_2X_REFRESH_EVENT,
 201         NUM_EVENTS_TYPE,
 202 };
 203
 204 /* Included Address of event source and data registers */
 205 static u8 smpro_event_table[NUM_EVENTS_TYPE] = {
 206         VRD_WARN_FAULT_EVENT_DATA,
 207         VRD_HOT_EVENT_DATA,
 208         DIMM_HOT_EVENT_DATA,
 209         DIMM_2X_REFRESH_EVENT_DATA,
 210 };
 211
 212 static ssize_t smpro_event_data_read(struct device *dev,
 213                                      struct device_attribute *da, char *buf,
 214                                      int channel)
 215 {
 216         struct smpro_errmon *errmon = dev_get_drvdata(dev);
 217         s32 event_data;
 218         int ret;
 219
 220         ret = regmap_read(errmon->regmap, smpro_event_table[channel], &event_data);
 221         if (ret)
 222                 return ret;
 223         /* Clear event after read */
 224         if (event_data != 0)
 225                 regmap_write(errmon->regmap, smpro_event_table[channel], event_data);
 226
 227         return sysfs_emit(buf, "%04x\n", event_data);
 228 }
 229
 230 static ssize_t smpro_overflow_data_read(struct device *dev, struct device_attribute *da,
 231                                         char *buf, int channel)
 232 {
 233         struct smpro_errmon *errmon = dev_get_drvdata(dev);
 234         struct smpro_error_hdr *err_info;
 235         s32 err_count;
 236         int ret;
 237
 238         err_info = &smpro_error_table[channel];
 239
 240         ret = regmap_read(errmon->regmap, err_info->count, &err_count);
 241         if (ret)
 242                 return ret;
 243
 244         /* Bit 8 indicates the overflow status */
 245         return sysfs_emit(buf, "%d\n", (err_count & BIT(8)) ? 1 : 0);
 246 }
 247
 248 static ssize_t smpro_error_data_read(struct device *dev, struct device_attribute *da,
 249                                      char *buf, int channel)
 250 {
 251         struct smpro_errmon *errmon = dev_get_drvdata(dev);
 252         unsigned char err_data[MAX_READ_BLOCK_LENGTH];
 253         struct smpro_error_hdr *err_info;
 254         s32 err_count, err_length;
 255         int ret;
 256
 257         err_info = &smpro_error_table[channel];
 258
 259         ret = regmap_read(errmon->regmap, err_info->count, &err_count);
 260         /* Error count is the low byte */
 261         err_count &= 0xff;
 262         if (ret || !err_count || err_count > err_info->max_cnt)
 263                 return ret;
 264
 265         ret = regmap_read(errmon->regmap, err_info->len, &err_length);
 266         if (ret || err_length <= 0)
 267                 return ret;
 268
 269         if (err_length > MAX_READ_BLOCK_LENGTH)
 270                 err_length = MAX_READ_BLOCK_LENGTH;
 271
 272         memset(err_data, 0x00, MAX_READ_BLOCK_LENGTH);
 273         ret = regmap_noinc_read(errmon->regmap, err_info->data, err_data, err_length);
 274         if (ret < 0)
 275                 return ret;
 276
 277         /* clear the error */
 278         ret = regmap_write(errmon->regmap, err_info->count, 0x100);
 279         if (ret)
 280                 return ret;
 281         /*
 282          * The output of Core/Memory/PCIe/Others UE/CE errors follows the format
 283          * specified in section 5.8.1 CE/UE Error Data record in
 284          * Altra SOC BMC Interface specification.
 285          */
 286         return sysfs_emit(buf, "%*phN\n", MAX_READ_BLOCK_LENGTH, err_data);
 287 }
 288
 289 /*
 290  * Output format:
 291  * <4-byte hex value of error info><4-byte hex value of error extensive data>
 292  * Where:
 293  *   + error info : The error information
 294  *   + error data : Extensive data (32 bits)
 295  * Reference to section 5.10 RAS Internal Error Register Definition in
 296  * Altra SOC BMC Interface specification
 297  */
 298 static ssize_t smpro_internal_err_read(struct device *dev, struct device_attribute *da,
 299                                        char *buf, int channel)
 300 {
 301         struct smpro_errmon *errmon = dev_get_drvdata(dev);
 302         struct smpro_int_error_hdr *err_info;
 303         unsigned int err[4] = { 0 };
 304         unsigned int err_type;
 305         unsigned int val;
 306         int ret;
 307
 308         /* read error status */
 309         ret = regmap_read(errmon->regmap, GPI_RAS_ERR, &val);
 310         if (ret)
 311                 return ret;
 312
 313         if ((channel == RAS_SMPRO_ERR && !(val & BIT(0))) ||
 314             (channel == RAS_PMPRO_ERR && !(val & BIT(1))))
 315                 return 0;
 316
 317         err_info = &list_smpro_int_error_hdr[channel];
 318         ret = regmap_read(errmon->regmap, err_info->type, &val);
 319         if (ret)
 320                 return ret;
 321
 322         err_type = (val & BIT(1)) ? BIT(1) :
 323                    (val & BIT(2)) ? BIT(2) : 0;
 324
 325         if (!err_type)
 326                 return 0;
 327
 328         ret = regmap_read(errmon->regmap, err_info->info_l, err + 1);
 329         if (ret)
 330                 return ret;
 331
 332         ret = regmap_read(errmon->regmap, err_info->info_h, err);
 333         if (ret)
 334                 return ret;
 335
 336         if (err_type & BIT(2)) {
 337                 /* Error with data type */
 338                 ret = regmap_read(errmon->regmap, err_info->data_l, err + 3);
 339                 if (ret)
 340                         return ret;
 341
 342                 ret = regmap_read(errmon->regmap, err_info->data_h, err + 2);
 343                 if (ret)
 344                         return ret;
 345         }
 346
 347         /* clear the read errors */
 348         ret = regmap_write(errmon->regmap, err_info->type, err_type);
 349         if (ret)
 350                 return ret;
 351
 352         return sysfs_emit(buf, "%*phN\n", (int)sizeof(err), err);
 353 }
 354
 355 /*
 356  * Output format:
 357  * <4-byte hex value of warining info>
 358  * Reference to section 5.10 RAS Internal Error Register Definition in
 359  * Altra SOC BMC Interface specification
 360  */
 361 static ssize_t smpro_internal_warn_read(struct device *dev, struct device_attribute *da,
 362                                         char *buf, int channel)
 363 {
 364         struct smpro_errmon *errmon = dev_get_drvdata(dev);
 365         struct smpro_int_error_hdr *err_info;
 366         unsigned int warn[2] = { 0 };
 367         unsigned int val;
 368         int ret;
 369
 370         /* read error status */
 371         ret = regmap_read(errmon->regmap, GPI_RAS_ERR, &val);
 372         if (ret)
 373                 return ret;
 374
 375         if ((channel == RAS_SMPRO_ERR && !(val & BIT(0))) ||
 376             (channel == RAS_PMPRO_ERR && !(val & BIT(1))))
 377                 return 0;
 378
 379         err_info = &list_smpro_int_error_hdr[channel];
 380         ret = regmap_read(errmon->regmap, err_info->type, &val);
 381         if (ret)
 382                 return ret;
 383
 384         if (!(val & BIT(0)))
 385                 return 0;
 386
 387         ret = regmap_read(errmon->regmap, err_info->warn_l, warn + 1);
 388         if (ret)
 389                 return ret;
 390
 391         ret = regmap_read(errmon->regmap, err_info->warn_h, warn);
 392         if (ret)
 393                 return ret;
 394
 395         /* clear the warning */
 396         ret = regmap_write(errmon->regmap, err_info->type, BIT(0));
 397         if (ret)
 398                 return ret;
 399
 400         return sysfs_emit(buf, "%*phN\n", (int)sizeof(warn), warn);
 401 }
 402
 403 #define ERROR_OVERFLOW_RO(_error, _index) \
 404         static ssize_t overflow_##_error##_show(struct device *dev,            \
 405                                                 struct device_attribute *da,   \
 406                                                 char *buf)                     \
 407         {                                                                      \
 408                 return smpro_overflow_data_read(dev, da, buf, _index);         \
 409         }                                                                      \
 410         static DEVICE_ATTR_RO(overflow_##_error)
 411
 412 ERROR_OVERFLOW_RO(core_ce, CORE_CE_ERR);
 413 ERROR_OVERFLOW_RO(core_ue, CORE_UE_ERR);
 414 ERROR_OVERFLOW_RO(mem_ce, MEM_CE_ERR);
 415 ERROR_OVERFLOW_RO(mem_ue, MEM_UE_ERR);
 416 ERROR_OVERFLOW_RO(pcie_ce, PCIE_CE_ERR);
 417 ERROR_OVERFLOW_RO(pcie_ue, PCIE_UE_ERR);
 418 ERROR_OVERFLOW_RO(other_ce, OTHER_CE_ERR);
 419 ERROR_OVERFLOW_RO(other_ue, OTHER_UE_ERR);
 420
 421 #define ERROR_RO(_error, _index) \
 422         static ssize_t error_##_error##_show(struct device *dev,            \
 423                                              struct device_attribute *da,   \
 424                                              char *buf)                     \
 425         {                                                                   \
 426                 return smpro_error_data_read(dev, da, buf, _index);         \
 427         }                                                                   \
 428         static DEVICE_ATTR_RO(error_##_error)
 429
 430 ERROR_RO(core_ce, CORE_CE_ERR);
 431 ERROR_RO(core_ue, CORE_UE_ERR);
 432 ERROR_RO(mem_ce, MEM_CE_ERR);
 433 ERROR_RO(mem_ue, MEM_UE_ERR);
 434 ERROR_RO(pcie_ce, PCIE_CE_ERR);
 435 ERROR_RO(pcie_ue, PCIE_UE_ERR);
 436 ERROR_RO(other_ce, OTHER_CE_ERR);
 437 ERROR_RO(other_ue, OTHER_UE_ERR);
 438
 439 static ssize_t error_smpro_show(struct device *dev, struct device_attribute *da, char *buf)
 440 {
 441         return smpro_internal_err_read(dev, da, buf, RAS_SMPRO_ERR);
 442 }
 443 static DEVICE_ATTR_RO(error_smpro);
 444
 445 static ssize_t error_pmpro_show(struct device *dev, struct device_attribute *da, char *buf)
 446 {
 447         return smpro_internal_err_read(dev, da, buf, RAS_PMPRO_ERR);
 448 }
 449 static DEVICE_ATTR_RO(error_pmpro);
 450
 451 static ssize_t warn_smpro_show(struct device *dev, struct device_attribute *da, char *buf)
 452 {
 453         return smpro_internal_warn_read(dev, da, buf, RAS_SMPRO_ERR);
 454 }
 455 static DEVICE_ATTR_RO(warn_smpro);
 456
 457 static ssize_t warn_pmpro_show(struct device *dev, struct device_attribute *da, char *buf)
 458 {
 459         return smpro_internal_warn_read(dev, da, buf, RAS_PMPRO_ERR);
 460 }
 461 static DEVICE_ATTR_RO(warn_pmpro);
 462
 463 #define EVENT_RO(_event, _index) \
 464         static ssize_t event_##_event##_show(struct device *dev,            \
 465                                              struct device_attribute *da,   \
 466                                              char *buf)                     \
 467         {                                                                   \
 468                 return smpro_event_data_read(dev, da, buf, _index);         \
 469         }                                                                   \
 470         static DEVICE_ATTR_RO(event_##_event)
 471
 472 EVENT_RO(vrd_warn_fault, VRD_WARN_FAULT_EVENT);
 473 EVENT_RO(vrd_hot, VRD_HOT_EVENT);
 474 EVENT_RO(dimm_hot, DIMM_HOT_EVENT);
 475 EVENT_RO(dimm_2x_refresh, DIMM_2X_REFRESH_EVENT);
 476
 477 static ssize_t smpro_dimm_syndrome_read(struct device *dev, struct device_attribute *da,
 478                                         char *buf, unsigned int slot)
 479 {
 480         struct smpro_errmon *errmon = dev_get_drvdata(dev);
 481         unsigned int data;
 482         int ret;
 483
 484         ret = regmap_read(errmon->regmap, BOOTSTAGE, &data);
 485         if (ret)
 486                 return ret;
 487
 488         /* check for valid stage */
 489         data = (data >> 8) & 0xff;
 490         if (data != DIMM_SYNDROME_STAGE)
 491                 return ret;
 492
 493         /* Write the slot ID to retrieve Error Syndrome */
 494         ret = regmap_write(errmon->regmap, DIMM_SYNDROME_SEL, slot);
 495         if (ret)
 496                 return ret;
 497
 498         /* Read the Syndrome error */
 499         ret = regmap_read(errmon->regmap, DIMM_SYNDROME_ERR, &data);
 500         if (ret || !data)
 501                 return ret;
 502
 503         return sysfs_emit(buf, "%04x\n", data);
 504 }
 505
 506 #define EVENT_DIMM_SYNDROME(_slot) \
 507         static ssize_t event_dimm##_slot##_syndrome_show(struct device *dev,          \
 508                                                          struct device_attribute *da, \
 509                                                          char *buf)                   \
 510         {                                                                             \
 511                 return smpro_dimm_syndrome_read(dev, da, buf, _slot);                 \
 512         }                                                                             \
 513         static DEVICE_ATTR_RO(event_dimm##_slot##_syndrome)
 514
 515 EVENT_DIMM_SYNDROME(0);
 516 EVENT_DIMM_SYNDROME(1);
 517 EVENT_DIMM_SYNDROME(2);
 518 EVENT_DIMM_SYNDROME(3);
 519 EVENT_DIMM_SYNDROME(4);
 520 EVENT_DIMM_SYNDROME(5);
 521 EVENT_DIMM_SYNDROME(6);
 522 EVENT_DIMM_SYNDROME(7);
 523 EVENT_DIMM_SYNDROME(8);
 524 EVENT_DIMM_SYNDROME(9);
 525 EVENT_DIMM_SYNDROME(10);
 526 EVENT_DIMM_SYNDROME(11);
 527 EVENT_DIMM_SYNDROME(12);
 528 EVENT_DIMM_SYNDROME(13);
 529 EVENT_DIMM_SYNDROME(14);
 530 EVENT_DIMM_SYNDROME(15);
 531
 532 static struct attribute *smpro_errmon_attrs[] = {
 533         &dev_attr_overflow_core_ce.attr,
 534         &dev_attr_overflow_core_ue.attr,
 535         &dev_attr_overflow_mem_ce.attr,
 536         &dev_attr_overflow_mem_ue.attr,
 537         &dev_attr_overflow_pcie_ce.attr,
 538         &dev_attr_overflow_pcie_ue.attr,
 539         &dev_attr_overflow_other_ce.attr,
 540         &dev_attr_overflow_other_ue.attr,
 541         &dev_attr_error_core_ce.attr,
 542         &dev_attr_error_core_ue.attr,
 543         &dev_attr_error_mem_ce.attr,
 544         &dev_attr_error_mem_ue.attr,
 545         &dev_attr_error_pcie_ce.attr,
 546         &dev_attr_error_pcie_ue.attr,
 547         &dev_attr_error_other_ce.attr,
 548         &dev_attr_error_other_ue.attr,
 549         &dev_attr_error_smpro.attr,
 550         &dev_attr_error_pmpro.attr,
 551         &dev_attr_warn_smpro.attr,
 552         &dev_attr_warn_pmpro.attr,
 553         &dev_attr_event_vrd_warn_fault.attr,
 554         &dev_attr_event_vrd_hot.attr,
 555         &dev_attr_event_dimm_hot.attr,
 556         &dev_attr_event_dimm_2x_refresh.attr,
 557         &dev_attr_event_dimm0_syndrome.attr,
 558         &dev_attr_event_dimm1_syndrome.attr,
 559         &dev_attr_event_dimm2_syndrome.attr,
 560         &dev_attr_event_dimm3_syndrome.attr,
 561         &dev_attr_event_dimm4_syndrome.attr,
 562         &dev_attr_event_dimm5_syndrome.attr,
 563         &dev_attr_event_dimm6_syndrome.attr,
 564         &dev_attr_event_dimm7_syndrome.attr,
 565         &dev_attr_event_dimm8_syndrome.attr,
 566         &dev_attr_event_dimm9_syndrome.attr,
 567         &dev_attr_event_dimm10_syndrome.attr,
 568         &dev_attr_event_dimm11_syndrome.attr,
 569         &dev_attr_event_dimm12_syndrome.attr,
 570         &dev_attr_event_dimm13_syndrome.attr,
 571         &dev_attr_event_dimm14_syndrome.attr,
 572         &dev_attr_event_dimm15_syndrome.attr,
 573         NULL
 574 };
 575
 576 ATTRIBUTE_GROUPS(smpro_errmon);
 577
 578 static int smpro_errmon_probe(struct platform_device *pdev)
 579 {
 580         struct smpro_errmon *errmon;
 581
 582         errmon = devm_kzalloc(&pdev->dev, sizeof(struct smpro_errmon), GFP_KERNEL);
 583         if (!errmon)
 584                 return -ENOMEM;
 585
 586         platform_set_drvdata(pdev, errmon);
 587
 588         errmon->regmap = dev_get_regmap(pdev->dev.parent, NULL);
 589         if (!errmon->regmap)
 590                 return -ENODEV;
 591
 592         return 0;
 593 }
 594
 595 static struct platform_driver smpro_errmon_driver = {
 596         .probe          = smpro_errmon_probe,
 597         .driver = {
 598                 .name   = "smpro-errmon",
 599                 .dev_groups = smpro_errmon_groups,
 600         },
 601 };
 602
 603 module_platform_driver(smpro_errmon_driver);
 604
 605 MODULE_AUTHOR("Tung Nguyen <tung.nguyen@amperecomputing.com>");
 606 MODULE_AUTHOR("Thinh Pham <thinh.pham@amperecomputing.com>");
 607 MODULE_AUTHOR("Hoang Nguyen <hnguyen@amperecomputing.com>");
 608 MODULE_AUTHOR("Thu Nguyen <thu@os.amperecomputing.com>");
 609 MODULE_AUTHOR("Quan Nguyen <quan@os.amperecomputing.com>");
 610 MODULE_DESCRIPTION("Ampere Altra SMpro driver");
 611 MODULE_LICENSE("GPL");