linux/drivers/mfd/ab8500-debugfs.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (C) ST-Ericsson SA 2010
   4 *
   5 * Author: Mattias Wallin <mattias.wallin@stericsson.com> for ST-Ericsson.
   6 */
   7/*
   8 * AB8500 register access
   9 * ======================
  10 *
  11 * read:
  12 * # echo BANK  >  <debugfs>/ab8500/register-bank
  13 * # echo ADDR  >  <debugfs>/ab8500/register-address
  14 * # cat <debugfs>/ab8500/register-value
  15 *
  16 * write:
  17 * # echo BANK  >  <debugfs>/ab8500/register-bank
  18 * # echo ADDR  >  <debugfs>/ab8500/register-address
  19 * # echo VALUE >  <debugfs>/ab8500/register-value
  20 *
  21 * read all registers from a bank:
  22 * # echo BANK  >  <debugfs>/ab8500/register-bank
  23 * # cat <debugfs>/ab8500/all-bank-register
  24 *
  25 * BANK   target AB8500 register bank
  26 * ADDR   target AB8500 register address
  27 * VALUE  decimal or 0x-prefixed hexadecimal
  28 *
  29 *
  30 * User Space notification on AB8500 IRQ
  31 * =====================================
  32 *
  33 * Allows user space entity to be notified when target AB8500 IRQ occurs.
  34 * When subscribed, a sysfs entry is created in ab8500.i2c platform device.
  35 * One can pool this file to get target IRQ occurence information.
  36 *
  37 * subscribe to an AB8500 IRQ:
  38 * # echo IRQ  >  <debugfs>/ab8500/irq-subscribe
  39 *
  40 * unsubscribe from an AB8500 IRQ:
  41 * # echo IRQ  >  <debugfs>/ab8500/irq-unsubscribe
  42 *
  43 *
  44 * AB8500 register formated read/write access
  45 * ==========================================
  46 *
  47 * Read:  read data, data>>SHIFT, data&=MASK, output data
  48 *        [0xABCDEF98] shift=12 mask=0xFFF => 0x00000CDE
  49 * Write: read data, data &= ~(MASK<<SHIFT), data |= (VALUE<<SHIFT), write data
  50 *        [0xABCDEF98] shift=12 mask=0xFFF value=0x123 => [0xAB123F98]
  51 *
  52 * Usage:
  53 * # echo "CMD [OPTIONS] BANK ADRESS [VALUE]" > $debugfs/ab8500/hwreg
  54 *
  55 * CMD      read      read access
  56 *          write     write access
  57 *
  58 * BANK     target reg bank
  59 * ADDRESS  target reg address
  60 * VALUE    (write) value to be updated
  61 *
  62 * OPTIONS
  63 *  -d|-dec            (read) output in decimal
  64 *  -h|-hexa           (read) output in 0x-hexa (default)
  65 *  -l|-w|-b           32bit (default), 16bit or 8bit reg access
  66 *  -m|-mask MASK      0x-hexa mask (default 0xFFFFFFFF)
  67 *  -s|-shift SHIFT    bit shift value (read:left, write:right)
  68 *  -o|-offset OFFSET  address offset to add to ADDRESS value
  69 *
  70 * Warning: bit shift operation is applied to bit-mask.
  71 * Warning: bit shift direction depends on read or right command.
  72 */
  73
  74#include <linux/seq_file.h>
  75#include <linux/uaccess.h>
  76#include <linux/fs.h>
  77#include <linux/init.h>
  78#include <linux/debugfs.h>
  79#include <linux/platform_device.h>
  80#include <linux/interrupt.h>
  81#include <linux/kobject.h>
  82#include <linux/slab.h>
  83#include <linux/irq.h>
  84
  85#include <linux/mfd/abx500.h>
  86#include <linux/mfd/abx500/ab8500.h>
  87#include <linux/mfd/abx500/ab8500-gpadc.h>
  88
  89#ifdef CONFIG_DEBUG_FS
  90#include <linux/string.h>
  91#include <linux/ctype.h>
  92#endif
  93
  94static u32 debug_bank;
  95static u32 debug_address;
  96
  97static int irq_ab8500;
  98static int irq_first;
  99static int irq_last;
 100static u32 *irq_count;
 101static int num_irqs;
 102
 103static struct device_attribute **dev_attr;
 104static char **event_name;
 105
 106static u8 avg_sample = SAMPLE_16;
 107static u8 trig_edge = RISING_EDGE;
 108static u8 conv_type = ADC_SW;
 109static u8 trig_timer;
 110
 111/**
 112 * struct ab8500_reg_range
 113 * @first: the first address of the range
 114 * @last: the last address of the range
 115 * @perm: access permissions for the range
 116 */
 117struct ab8500_reg_range {
 118        u8 first;
 119        u8 last;
 120        u8 perm;
 121};
 122
 123/**
 124 * struct ab8500_prcmu_ranges
 125 * @num_ranges: the number of ranges in the list
 126 * @bankid: bank identifier
 127 * @range: the list of register ranges
 128 */
 129struct ab8500_prcmu_ranges {
 130        u8 num_ranges;
 131        u8 bankid;
 132        const struct ab8500_reg_range *range;
 133};
 134
 135/* hwreg- "mask" and "shift" entries ressources */
 136struct hwreg_cfg {
 137        u32  bank;      /* target bank */
 138        unsigned long addr;      /* target address */
 139        uint fmt;       /* format */
 140        unsigned long mask; /* read/write mask, applied before any bit shift */
 141        long shift;     /* bit shift (read:right shift, write:left shift */
 142};
 143/* fmt bit #0: 0=hexa, 1=dec */
 144#define REG_FMT_DEC(c) ((c)->fmt & 0x1)
 145#define REG_FMT_HEX(c) (!REG_FMT_DEC(c))
 146
 147static struct hwreg_cfg hwreg_cfg = {
 148        .addr = 0,                      /* default: invalid phys addr */
 149        .fmt = 0,                       /* default: 32bit access, hex output */
 150        .mask = 0xFFFFFFFF,     /* default: no mask */
 151        .shift = 0,                     /* default: no bit shift */
 152};
 153
 154#define AB8500_NAME_STRING "ab8500"
 155#define AB8500_ADC_NAME_STRING "gpadc"
 156#define AB8500_NUM_BANKS AB8500_DEBUG_FIELD_LAST
 157
 158#define AB8500_REV_REG 0x80
 159
 160static struct ab8500_prcmu_ranges *debug_ranges;
 161
 162static struct ab8500_prcmu_ranges ab8500_debug_ranges[AB8500_NUM_BANKS] = {
 163        [AB8500_M_FSM_RANK] = {
 164                .num_ranges = 0,
 165                .range = NULL,
 166        },
 167        [AB8500_SYS_CTRL1_BLOCK] = {
 168                .num_ranges = 3,
 169                .range = (struct ab8500_reg_range[]) {
 170                        {
 171                                .first = 0x00,
 172                                .last = 0x02,
 173                        },
 174                        {
 175                                .first = 0x42,
 176                                .last = 0x42,
 177                        },
 178                        {
 179                                .first = 0x80,
 180                                .last = 0x81,
 181                        },
 182                },
 183        },
 184        [AB8500_SYS_CTRL2_BLOCK] = {
 185                .num_ranges = 4,
 186                .range = (struct ab8500_reg_range[]) {
 187                        {
 188                                .first = 0x00,
 189                                .last = 0x0D,
 190                        },
 191                        {
 192                                .first = 0x0F,
 193                                .last = 0x17,
 194                        },
 195                        {
 196                                .first = 0x30,
 197                                .last = 0x30,
 198                        },
 199                        {
 200                                .first = 0x32,
 201                                .last = 0x33,
 202                        },
 203                },
 204        },
 205        [AB8500_REGU_CTRL1] = {
 206                .num_ranges = 3,
 207                .range = (struct ab8500_reg_range[]) {
 208                        {
 209                                .first = 0x00,
 210                                .last = 0x00,
 211                        },
 212                        {
 213                                .first = 0x03,
 214                                .last = 0x10,
 215                        },
 216                        {
 217                                .first = 0x80,
 218                                .last = 0x84,
 219                        },
 220                },
 221        },
 222        [AB8500_REGU_CTRL2] = {
 223                .num_ranges = 5,
 224                .range = (struct ab8500_reg_range[]) {
 225                        {
 226                                .first = 0x00,
 227                                .last = 0x15,
 228                        },
 229                        {
 230                                .first = 0x17,
 231                                .last = 0x19,
 232                        },
 233                        {
 234                                .first = 0x1B,
 235                                .last = 0x1D,
 236                        },
 237                        {
 238                                .first = 0x1F,
 239                                .last = 0x22,
 240                        },
 241                        {
 242                                .first = 0x40,
 243                                .last = 0x44,
 244                        },
 245                        /*
 246                         * 0x80-0x8B are SIM registers and should
 247                         * not be accessed from here
 248                         */
 249                },
 250        },
 251        [AB8500_USB] = {
 252                .num_ranges = 2,
 253                .range = (struct ab8500_reg_range[]) {
 254                        {
 255                                .first = 0x80,
 256                                .last = 0x83,
 257                        },
 258                        {
 259                                .first = 0x87,
 260                                .last = 0x8A,
 261                        },
 262                },
 263        },
 264        [AB8500_TVOUT] = {
 265                .num_ranges = 9,
 266                .range = (struct ab8500_reg_range[]) {
 267                        {
 268                                .first = 0x00,
 269                                .last = 0x12,
 270                        },
 271                        {
 272                                .first = 0x15,
 273                                .last = 0x17,
 274                        },
 275                        {
 276                                .first = 0x19,
 277                                .last = 0x21,
 278                        },
 279                        {
 280                                .first = 0x27,
 281                                .last = 0x2C,
 282                        },
 283                        {
 284                                .first = 0x41,
 285                                .last = 0x41,
 286                        },
 287                        {
 288                                .first = 0x45,
 289                                .last = 0x5B,
 290                        },
 291                        {
 292                                .first = 0x5D,
 293                                .last = 0x5D,
 294                        },
 295                        {
 296                                .first = 0x69,
 297                                .last = 0x69,
 298                        },
 299                        {
 300                                .first = 0x80,
 301                                .last = 0x81,
 302                        },
 303                },
 304        },
 305        [AB8500_DBI] = {
 306                .num_ranges = 0,
 307                .range = NULL,
 308        },
 309        [AB8500_ECI_AV_ACC] = {
 310                .num_ranges = 1,
 311                .range = (struct ab8500_reg_range[]) {
 312                        {
 313                                .first = 0x80,
 314                                .last = 0x82,
 315                        },
 316                },
 317        },
 318        [AB8500_RESERVED] = {
 319                .num_ranges = 0,
 320                .range = NULL,
 321        },
 322        [AB8500_GPADC] = {
 323                .num_ranges = 1,
 324                .range = (struct ab8500_reg_range[]) {
 325                        {
 326                                .first = 0x00,
 327                                .last = 0x08,
 328                        },
 329                },
 330        },
 331        [AB8500_CHARGER] = {
 332                .num_ranges = 9,
 333                .range = (struct ab8500_reg_range[]) {
 334                        {
 335                                .first = 0x00,
 336                                .last = 0x03,
 337                        },
 338                        {
 339                                .first = 0x05,
 340                                .last = 0x05,
 341                        },
 342                        {
 343                                .first = 0x40,
 344                                .last = 0x40,
 345                        },
 346                        {
 347                                .first = 0x42,
 348                                .last = 0x42,
 349                        },
 350                        {
 351                                .first = 0x44,
 352                                .last = 0x44,
 353                        },
 354                        {
 355                                .first = 0x50,
 356                                .last = 0x55,
 357                        },
 358                        {
 359                                .first = 0x80,
 360                                .last = 0x82,
 361                        },
 362                        {
 363                                .first = 0xC0,
 364                                .last = 0xC2,
 365                        },
 366                        {
 367                                .first = 0xf5,
 368                                .last = 0xf6,
 369                        },
 370                },
 371        },
 372        [AB8500_GAS_GAUGE] = {
 373                .num_ranges = 3,
 374                .range = (struct ab8500_reg_range[]) {
 375                        {
 376                                .first = 0x00,
 377                                .last = 0x00,
 378                        },
 379                        {
 380                                .first = 0x07,
 381                                .last = 0x0A,
 382                        },
 383                        {
 384                                .first = 0x10,
 385                                .last = 0x14,
 386                        },
 387                },
 388        },
 389        [AB8500_AUDIO] = {
 390                .num_ranges = 1,
 391                .range = (struct ab8500_reg_range[]) {
 392                        {
 393                                .first = 0x00,
 394                                .last = 0x6F,
 395                        },
 396                },
 397        },
 398        [AB8500_INTERRUPT] = {
 399                .num_ranges = 0,
 400                .range = NULL,
 401        },
 402        [AB8500_RTC] = {
 403                .num_ranges = 1,
 404                .range = (struct ab8500_reg_range[]) {
 405                        {
 406                                .first = 0x00,
 407                                .last = 0x0F,
 408                        },
 409                },
 410        },
 411        [AB8500_MISC] = {
 412                .num_ranges = 8,
 413                .range = (struct ab8500_reg_range[]) {
 414                        {
 415                                .first = 0x00,
 416                                .last = 0x05,
 417                        },
 418                        {
 419                                .first = 0x10,
 420                                .last = 0x15,
 421                        },
 422                        {
 423                                .first = 0x20,
 424                                .last = 0x25,
 425                        },
 426                        {
 427                                .first = 0x30,
 428                                .last = 0x35,
 429                        },
 430                        {
 431                                .first = 0x40,
 432                                .last = 0x45,
 433                        },
 434                        {
 435                                .first = 0x50,
 436                                .last = 0x50,
 437                        },
 438                        {
 439                                .first = 0x60,
 440                                .last = 0x67,
 441                        },
 442                        {
 443                                .first = 0x80,
 444                                .last = 0x80,
 445                        },
 446                },
 447        },
 448        [AB8500_DEVELOPMENT] = {
 449                .num_ranges = 1,
 450                .range = (struct ab8500_reg_range[]) {
 451                        {
 452                                .first = 0x00,
 453                                .last = 0x00,
 454                        },
 455                },
 456        },
 457        [AB8500_DEBUG] = {
 458                .num_ranges = 1,
 459                .range = (struct ab8500_reg_range[]) {
 460                        {
 461                                .first = 0x05,
 462                                .last = 0x07,
 463                        },
 464                },
 465        },
 466        [AB8500_PROD_TEST] = {
 467                .num_ranges = 0,
 468                .range = NULL,
 469        },
 470        [AB8500_STE_TEST] = {
 471                .num_ranges = 0,
 472                .range = NULL,
 473        },
 474        [AB8500_OTP_EMUL] = {
 475                .num_ranges = 1,
 476                .range = (struct ab8500_reg_range[]) {
 477                        {
 478                                .first = 0x01,
 479                                .last = 0x0F,
 480                        },
 481                },
 482        },
 483};
 484
 485static struct ab8500_prcmu_ranges ab8505_debug_ranges[AB8500_NUM_BANKS] = {
 486        [0x0] = {
 487                .num_ranges = 0,
 488                .range = NULL,
 489        },
 490        [AB8500_SYS_CTRL1_BLOCK] = {
 491                .num_ranges = 5,
 492                .range = (struct ab8500_reg_range[]) {
 493                        {
 494                                .first = 0x00,
 495                                .last = 0x04,
 496                        },
 497                        {
 498                                .first = 0x42,
 499                                .last = 0x42,
 500                        },
 501                        {
 502                                .first = 0x52,
 503                                .last = 0x52,
 504                        },
 505                        {
 506                                .first = 0x54,
 507                                .last = 0x57,
 508                        },
 509                        {
 510                                .first = 0x80,
 511                                .last = 0x83,
 512                        },
 513                },
 514        },
 515        [AB8500_SYS_CTRL2_BLOCK] = {
 516                .num_ranges = 5,
 517                .range = (struct ab8500_reg_range[]) {
 518                        {
 519                                .first = 0x00,
 520                                .last = 0x0D,
 521                        },
 522                        {
 523                                .first = 0x0F,
 524                                .last = 0x17,
 525                        },
 526                        {
 527                                .first = 0x20,
 528                                .last = 0x20,
 529                        },
 530                        {
 531                                .first = 0x30,
 532                                .last = 0x30,
 533                        },
 534                        {
 535                                .first = 0x32,
 536                                .last = 0x3A,
 537                        },
 538                },
 539        },
 540        [AB8500_REGU_CTRL1] = {
 541                .num_ranges = 3,
 542                .range = (struct ab8500_reg_range[]) {
 543                        {
 544                                .first = 0x00,
 545                                .last = 0x00,
 546                        },
 547                        {
 548                                .first = 0x03,
 549                                .last = 0x11,
 550                        },
 551                        {
 552                                .first = 0x80,
 553                                .last = 0x86,
 554                        },
 555                },
 556        },
 557        [AB8500_REGU_CTRL2] = {
 558                .num_ranges = 6,
 559                .range = (struct ab8500_reg_range[]) {
 560                        {
 561                                .first = 0x00,
 562                                .last = 0x06,
 563                        },
 564                        {
 565                                .first = 0x08,
 566                                .last = 0x15,
 567                        },
 568                        {
 569                                .first = 0x17,
 570                                .last = 0x19,
 571                        },
 572                        {
 573                                .first = 0x1B,
 574                                .last = 0x1D,
 575                        },
 576                        {
 577                                .first = 0x1F,
 578                                .last = 0x30,
 579                        },
 580                        {
 581                                .first = 0x40,
 582                                .last = 0x48,
 583                        },
 584                        /*
 585                         * 0x80-0x8B are SIM registers and should
 586                         * not be accessed from here
 587                         */
 588                },
 589        },
 590        [AB8500_USB] = {
 591                .num_ranges = 3,
 592                .range = (struct ab8500_reg_range[]) {
 593                        {
 594                                .first = 0x80,
 595                                .last = 0x83,
 596                        },
 597                        {
 598                                .first = 0x87,
 599                                .last = 0x8A,
 600                        },
 601                        {
 602                                .first = 0x91,
 603                                .last = 0x94,
 604                        },
 605                },
 606        },
 607        [AB8500_TVOUT] = {
 608                .num_ranges = 0,
 609                .range = NULL,
 610        },
 611        [AB8500_DBI] = {
 612                .num_ranges = 0,
 613                .range = NULL,
 614        },
 615        [AB8500_ECI_AV_ACC] = {
 616                .num_ranges = 1,
 617                .range = (struct ab8500_reg_range[]) {
 618                        {
 619                                .first = 0x80,
 620                                .last = 0x82,
 621                        },
 622                },
 623        },
 624        [AB8500_RESERVED] = {
 625                .num_ranges = 0,
 626                .range = NULL,
 627        },
 628        [AB8500_GPADC] = {
 629                .num_ranges = 1,
 630                .range = (struct ab8500_reg_range[]) {
 631                        {
 632                                .first = 0x00,
 633                                .last = 0x08,
 634                        },
 635                },
 636        },
 637        [AB8500_CHARGER] = {
 638                .num_ranges = 9,
 639                .range = (struct ab8500_reg_range[]) {
 640                        {
 641                                .first = 0x02,
 642                                .last = 0x03,
 643                        },
 644                        {
 645                                .first = 0x05,
 646                                .last = 0x05,
 647                        },
 648                        {
 649                                .first = 0x40,
 650                                .last = 0x44,
 651                        },
 652                        {
 653                                .first = 0x50,
 654                                .last = 0x57,
 655                        },
 656                        {
 657                                .first = 0x60,
 658                                .last = 0x60,
 659                        },
 660                        {
 661                                .first = 0xA0,
 662                                .last = 0xA7,
 663                        },
 664                        {
 665                                .first = 0xAF,
 666                                .last = 0xB2,
 667                        },
 668                        {
 669                                .first = 0xC0,
 670                                .last = 0xC2,
 671                        },
 672                        {
 673                                .first = 0xF5,
 674                                .last = 0xF5,
 675                        },
 676                },
 677        },
 678        [AB8500_GAS_GAUGE] = {
 679                .num_ranges = 3,
 680                .range = (struct ab8500_reg_range[]) {
 681                        {
 682                                .first = 0x00,
 683                                .last = 0x00,
 684                        },
 685                        {
 686                                .first = 0x07,
 687                                .last = 0x0A,
 688                        },
 689                        {
 690                                .first = 0x10,
 691                                .last = 0x14,
 692                        },
 693                },
 694        },
 695        [AB8500_AUDIO] = {
 696                .num_ranges = 1,
 697                .range = (struct ab8500_reg_range[]) {
 698                        {
 699                                .first = 0x00,
 700                                .last = 0x83,
 701                        },
 702                },
 703        },
 704        [AB8500_INTERRUPT] = {
 705                .num_ranges = 11,
 706                .range = (struct ab8500_reg_range[]) {
 707                        {
 708                                .first = 0x00,
 709                                .last = 0x04,
 710                        },
 711                        {
 712                                .first = 0x06,
 713                                .last = 0x07,
 714                        },
 715                        {
 716                                .first = 0x09,
 717                                .last = 0x09,
 718                        },
 719                        {
 720                                .first = 0x0B,
 721                                .last = 0x0C,
 722                        },
 723                        {
 724                                .first = 0x12,
 725                                .last = 0x15,
 726                        },
 727                        {
 728                                .first = 0x18,
 729                                .last = 0x18,
 730                        },
 731                        /* Latch registers should not be read here */
 732                        {
 733                                .first = 0x40,
 734                                .last = 0x44,
 735                        },
 736                        {
 737                                .first = 0x46,
 738                                .last = 0x49,
 739                        },
 740                        {
 741                                .first = 0x4B,
 742                                .last = 0x4D,
 743                        },
 744                        {
 745                                .first = 0x52,
 746                                .last = 0x55,
 747                        },
 748                        {
 749                                .first = 0x58,
 750                                .last = 0x58,
 751                        },
 752                        /* LatchHier registers should not be read here */
 753                },
 754        },
 755        [AB8500_RTC] = {
 756                .num_ranges = 2,
 757                .range = (struct ab8500_reg_range[]) {
 758                        {
 759                                .first = 0x00,
 760                                .last = 0x14,
 761                        },
 762                        {
 763                                .first = 0x16,
 764                                .last = 0x17,
 765                        },
 766                },
 767        },
 768        [AB8500_MISC] = {
 769                .num_ranges = 8,
 770                .range = (struct ab8500_reg_range[]) {
 771                        {
 772                                .first = 0x00,
 773                                .last = 0x06,
 774                        },
 775                        {
 776                                .first = 0x10,
 777                                .last = 0x16,
 778                        },
 779                        {
 780                                .first = 0x20,
 781                                .last = 0x26,
 782                        },
 783                        {
 784                                .first = 0x30,
 785                                .last = 0x36,
 786                        },
 787                        {
 788                                .first = 0x40,
 789                                .last = 0x46,
 790                        },
 791                        {
 792                                .first = 0x50,
 793                                .last = 0x50,
 794                        },
 795                        {
 796                                .first = 0x60,
 797                                .last = 0x6B,
 798                        },
 799                        {
 800                                .first = 0x80,
 801                                .last = 0x82,
 802                        },
 803                },
 804        },
 805        [AB8500_DEVELOPMENT] = {
 806                .num_ranges = 2,
 807                .range = (struct ab8500_reg_range[]) {
 808                        {
 809                                .first = 0x00,
 810                                .last = 0x00,
 811                        },
 812                        {
 813                                .first = 0x05,
 814                                .last = 0x05,
 815                        },
 816                },
 817        },
 818        [AB8500_DEBUG] = {
 819                .num_ranges = 1,
 820                .range = (struct ab8500_reg_range[]) {
 821                        {
 822                                .first = 0x05,
 823                                .last = 0x07,
 824                        },
 825                },
 826        },
 827        [AB8500_PROD_TEST] = {
 828                .num_ranges = 0,
 829                .range = NULL,
 830        },
 831        [AB8500_STE_TEST] = {
 832                .num_ranges = 0,
 833                .range = NULL,
 834        },
 835        [AB8500_OTP_EMUL] = {
 836                .num_ranges = 1,
 837                .range = (struct ab8500_reg_range[]) {
 838                        {
 839                                .first = 0x01,
 840                                .last = 0x15,
 841                        },
 842                },
 843        },
 844};
 845
 846static struct ab8500_prcmu_ranges ab8540_debug_ranges[AB8500_NUM_BANKS] = {
 847        [AB8500_M_FSM_RANK] = {
 848                .num_ranges = 1,
 849                .range = (struct ab8500_reg_range[]) {
 850                        {
 851                                .first = 0x00,
 852                                .last = 0x0B,
 853                        },
 854                },
 855        },
 856        [AB8500_SYS_CTRL1_BLOCK] = {
 857                .num_ranges = 6,
 858                .range = (struct ab8500_reg_range[]) {
 859                        {
 860                                .first = 0x00,
 861                                .last = 0x04,
 862                        },
 863                        {
 864                                .first = 0x42,
 865                                .last = 0x42,
 866                        },
 867                        {
 868                                .first = 0x50,
 869                                .last = 0x54,
 870                        },
 871                        {
 872                                .first = 0x57,
 873                                .last = 0x57,
 874                        },
 875                        {
 876                                .first = 0x80,
 877                                .last = 0x83,
 878                        },
 879                        {
 880                                .first = 0x90,
 881                                .last = 0x90,
 882                        },
 883                },
 884        },
 885        [AB8500_SYS_CTRL2_BLOCK] = {
 886                .num_ranges = 5,
 887                .range = (struct ab8500_reg_range[]) {
 888                        {
 889                                .first = 0x00,
 890                                .last = 0x0D,
 891                        },
 892                        {
 893                                .first = 0x0F,
 894                                .last = 0x10,
 895                        },
 896                        {
 897                                .first = 0x20,
 898                                .last = 0x21,
 899                        },
 900                        {
 901                                .first = 0x32,
 902                                .last = 0x3C,
 903                        },
 904                        {
 905                                .first = 0x40,
 906                                .last = 0x42,
 907                        },
 908                },
 909        },
 910        [AB8500_REGU_CTRL1] = {
 911                .num_ranges = 4,
 912                .range = (struct ab8500_reg_range[]) {
 913                        {
 914                                .first = 0x03,
 915                                .last = 0x15,
 916                        },
 917                        {
 918                                .first = 0x20,
 919                                .last = 0x20,
 920                        },
 921                        {
 922                                .first = 0x80,
 923                                .last = 0x85,
 924                        },
 925                        {
 926                                .first = 0x87,
 927                                .last = 0x88,
 928                        },
 929                },
 930        },
 931        [AB8500_REGU_CTRL2] = {
 932                .num_ranges = 8,
 933                .range = (struct ab8500_reg_range[]) {
 934                        {
 935                                .first = 0x00,
 936                                .last = 0x06,
 937                        },
 938                        {
 939                                .first = 0x08,
 940                                .last = 0x15,
 941                        },
 942                        {
 943                                .first = 0x17,
 944                                .last = 0x19,
 945                        },
 946                        {
 947                                .first = 0x1B,
 948                                .last = 0x1D,
 949                        },
 950                        {
 951                                .first = 0x1F,
 952                                .last = 0x2F,
 953                        },
 954                        {
 955                                .first = 0x31,
 956                                .last = 0x3A,
 957                        },
 958                        {
 959                                .first = 0x43,
 960                                .last = 0x44,
 961                        },
 962                        {
 963                                .first = 0x48,
 964                                .last = 0x49,
 965                        },
 966                },
 967        },
 968        [AB8500_USB] = {
 969                .num_ranges = 3,
 970                .range = (struct ab8500_reg_range[]) {
 971                        {
 972                                .first = 0x80,
 973                                .last = 0x83,
 974                        },
 975                        {
 976                                .first = 0x87,
 977                                .last = 0x8A,
 978                        },
 979                        {
 980                                .first = 0x91,
 981                                .last = 0x94,
 982                        },
 983                },
 984        },
 985        [AB8500_TVOUT] = {
 986                .num_ranges = 0,
 987                .range = NULL
 988        },
 989        [AB8500_DBI] = {
 990                .num_ranges = 4,
 991                .range = (struct ab8500_reg_range[]) {
 992                        {
 993                                .first = 0x00,
 994                                .last = 0x07,
 995                        },
 996                        {
 997                                .first = 0x10,
 998                                .last = 0x11,
 999                        },
1000                        {
1001                                .first = 0x20,
1002                                .last = 0x21,
1003                        },
1004                        {
1005                                .first = 0x30,
1006                                .last = 0x43,
1007                        },
1008                },
1009        },
1010        [AB8500_ECI_AV_ACC] = {
1011                .num_ranges = 2,
1012                .range = (struct ab8500_reg_range[]) {
1013                        {
1014                                .first = 0x00,
1015                                .last = 0x03,
1016                        },
1017                        {
1018                                .first = 0x80,
1019                                .last = 0x82,
1020                        },
1021                },
1022        },
1023        [AB8500_RESERVED] = {
1024                .num_ranges = 0,
1025                .range = NULL,
1026        },
1027        [AB8500_GPADC] = {
1028                .num_ranges = 4,
1029                .range = (struct ab8500_reg_range[]) {
1030                        {
1031                                .first = 0x00,
1032                                .last = 0x01,
1033                        },
1034                        {
1035                                .first = 0x04,
1036                                .last = 0x06,
1037                        },
1038                        {
1039                                .first = 0x09,
1040                                .last = 0x0A,
1041                        },
1042                        {
1043                                .first = 0x10,
1044                                .last = 0x14,
1045                        },
1046                },
1047        },
1048        [AB8500_CHARGER] = {
1049                .num_ranges = 10,
1050                .range = (struct ab8500_reg_range[]) {
1051                        {
1052                                .first = 0x00,
1053                                .last = 0x00,
1054                        },
1055                        {
1056                                .first = 0x02,
1057                                .last = 0x05,
1058                        },
1059                        {
1060                                .first = 0x40,
1061                                .last = 0x44,
1062                        },
1063                        {
1064                                .first = 0x50,
1065                                .last = 0x57,
1066                        },
1067                        {
1068                                .first = 0x60,
1069                                .last = 0x60,
1070                        },
1071                        {
1072                                .first = 0x70,
1073                                .last = 0x70,
1074                        },
1075                        {
1076                                .first = 0xA0,
1077                                .last = 0xA9,
1078                        },
1079                        {
1080                                .first = 0xAF,
1081                                .last = 0xB2,
1082                        },
1083                        {
1084                                .first = 0xC0,
1085                                .last = 0xC6,
1086                        },
1087                        {
1088                                .first = 0xF5,
1089                                .last = 0xF5,
1090                        },
1091                },
1092        },
1093        [AB8500_GAS_GAUGE] = {
1094                .num_ranges = 3,
1095                .range = (struct ab8500_reg_range[]) {
1096                        {
1097                                .first = 0x00,
1098                                .last = 0x00,
1099                        },
1100                        {
1101                                .first = 0x07,
1102                                .last = 0x0A,
1103                        },
1104                        {
1105                                .first = 0x10,
1106                                .last = 0x14,
1107                        },
1108                },
1109        },
1110        [AB8500_AUDIO] = {
1111                .num_ranges = 1,
1112                .range = (struct ab8500_reg_range[]) {
1113                        {
1114                                .first = 0x00,
1115                                .last = 0x9f,
1116                        },
1117                },
1118        },
1119        [AB8500_INTERRUPT] = {
1120                .num_ranges = 6,
1121                .range = (struct ab8500_reg_range[]) {
1122                        {
1123                                .first = 0x00,
1124                                .last = 0x05,
1125                        },
1126                        {
1127                                .first = 0x0B,
1128                                .last = 0x0D,
1129                        },
1130                        {
1131                                .first = 0x12,
1132                                .last = 0x20,
1133                        },
1134                        /* Latch registers should not be read here */
1135                        {
1136                                .first = 0x40,
1137                                .last = 0x45,
1138                        },
1139                        {
1140                                .first = 0x4B,
1141                                .last = 0x4D,
1142                        },
1143                        {
1144                                .first = 0x52,
1145                                .last = 0x60,
1146                        },
1147                        /* LatchHier registers should not be read here */
1148                },
1149        },
1150        [AB8500_RTC] = {
1151                .num_ranges = 3,
1152                .range = (struct ab8500_reg_range[]) {
1153                        {
1154                                .first = 0x00,
1155                                .last = 0x07,
1156                        },
1157                        {
1158                                .first = 0x0B,
1159                                .last = 0x18,
1160                        },
1161                        {
1162                                .first = 0x20,
1163                                .last = 0x25,
1164                        },
1165                },
1166        },
1167        [AB8500_MISC] = {
1168                .num_ranges = 9,
1169                .range = (struct ab8500_reg_range[]) {
1170                        {
1171                                .first = 0x00,
1172                                .last = 0x06,
1173                        },
1174                        {
1175                                .first = 0x10,
1176                                .last = 0x16,
1177                        },
1178                        {
1179                                .first = 0x20,
1180                                .last = 0x26,
1181                        },
1182                        {
1183                                .first = 0x30,
1184                                .last = 0x36,
1185                        },
1186                        {
1187                                .first = 0x40,
1188                                .last = 0x49,
1189                        },
1190                        {
1191                                .first = 0x50,
1192                                .last = 0x50,
1193                        },
1194                        {
1195                                .first = 0x60,
1196                                .last = 0x6B,
1197                        },
1198                        {
1199                                .first = 0x70,
1200                                .last = 0x74,
1201                        },
1202                        {
1203                                .first = 0x80,
1204                                .last = 0x82,
1205                        },
1206                },
1207        },
1208        [AB8500_DEVELOPMENT] = {
1209                .num_ranges = 3,
1210                .range = (struct ab8500_reg_range[]) {
1211                        {
1212                                .first = 0x00,
1213                                .last = 0x01,
1214                        },
1215                        {
1216                                .first = 0x06,
1217                                .last = 0x06,
1218                        },
1219                        {
1220                                .first = 0x10,
1221                                .last = 0x21,
1222                        },
1223                },
1224        },
1225        [AB8500_DEBUG] = {
1226                .num_ranges = 3,
1227                .range = (struct ab8500_reg_range[]) {
1228                        {
1229                                .first = 0x01,
1230                                .last = 0x0C,
1231                        },
1232                        {
1233                                .first = 0x0E,
1234                                .last = 0x11,
1235                        },
1236                        {
1237                                .first = 0x80,
1238                                .last = 0x81,
1239                        },
1240                },
1241        },
1242        [AB8500_PROD_TEST] = {
1243                .num_ranges = 0,
1244                .range = NULL,
1245        },
1246        [AB8500_STE_TEST] = {
1247                .num_ranges = 0,
1248                .range = NULL,
1249        },
1250        [AB8500_OTP_EMUL] = {
1251                .num_ranges = 1,
1252                .range = (struct ab8500_reg_range[]) {
1253                        {
1254                                .first = 0x00,
1255                                .last = 0x3F,
1256                        },
1257                },
1258        },
1259};
1260
1261static irqreturn_t ab8500_debug_handler(int irq, void *data)
1262{
1263        char buf[16];
1264        struct kobject *kobj = (struct kobject *)data;
1265        unsigned int irq_abb = irq - irq_first;
1266
1267        if (irq_abb < num_irqs)
1268                irq_count[irq_abb]++;
1269        /*
1270         * This makes it possible to use poll for events (EPOLLPRI | EPOLLERR)
1271         * from userspace on sysfs file named <irq-nr>
1272         */
1273        sprintf(buf, "%d", irq);
1274        sysfs_notify(kobj, NULL, buf);
1275
1276        return IRQ_HANDLED;
1277}
1278
1279/* Prints to seq_file or log_buf */
1280static int ab8500_registers_print(struct device *dev, u32 bank,
1281                                  struct seq_file *s)
1282{
1283        unsigned int i;
1284
1285        for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
1286                u32 reg;
1287
1288                for (reg = debug_ranges[bank].range[i].first;
1289                        reg <= debug_ranges[bank].range[i].last;
1290                        reg++) {
1291                        u8 value;
1292                        int err;
1293
1294                        err = abx500_get_register_interruptible(dev,
1295                                (u8)bank, (u8)reg, &value);
1296                        if (err < 0) {
1297                                dev_err(dev, "ab->read fail %d\n", err);
1298                                return err;
1299                        }
1300
1301                        if (s) {
1302                                seq_printf(s, "  [0x%02X/0x%02X]: 0x%02X\n",
1303                                           bank, reg, value);
1304                                /*
1305                                 * Error is not returned here since
1306                                 * the output is wanted in any case
1307                                 */
1308                                if (seq_has_overflowed(s))
1309                                        return 0;
1310                        } else {
1311                                dev_info(dev, " [0x%02X/0x%02X]: 0x%02X\n",
1312                                         bank, reg, value);
1313                        }
1314                }
1315        }
1316
1317        return 0;
1318}
1319
1320static int ab8500_bank_registers_show(struct seq_file *s, void *p)
1321{
1322        struct device *dev = s->private;
1323        u32 bank = debug_bank;
1324
1325        seq_puts(s, AB8500_NAME_STRING " register values:\n");
1326
1327        seq_printf(s, " bank 0x%02X:\n", bank);
1328
1329        return ab8500_registers_print(dev, bank, s);
1330}
1331
1332DEFINE_SHOW_ATTRIBUTE(ab8500_bank_registers);
1333
1334static int ab8500_print_all_banks(struct seq_file *s, void *p)
1335{
1336        struct device *dev = s->private;
1337        unsigned int i;
1338
1339        seq_puts(s, AB8500_NAME_STRING " register values:\n");
1340
1341        for (i = 0; i < AB8500_NUM_BANKS; i++) {
1342                int err;
1343
1344                seq_printf(s, " bank 0x%02X:\n", i);
1345                err = ab8500_registers_print(dev, i, s);
1346                if (err)
1347                        return err;
1348        }
1349        return 0;
1350}
1351
1352/* Dump registers to kernel log */
1353void ab8500_dump_all_banks(struct device *dev)
1354{
1355        unsigned int i;
1356
1357        dev_info(dev, "ab8500 register values:\n");
1358
1359        for (i = 1; i < AB8500_NUM_BANKS; i++) {
1360                dev_info(dev, " bank 0x%02X:\n", i);
1361                ab8500_registers_print(dev, i, NULL);
1362        }
1363}
1364
1365static int ab8500_all_banks_open(struct inode *inode, struct file *file)
1366{
1367        struct seq_file *s;
1368        int err;
1369
1370        err = single_open(file, ab8500_print_all_banks, inode->i_private);
1371        if (!err) {
1372                /* Default buf size in seq_read is not enough */
1373                s = (struct seq_file *)file->private_data;
1374                s->size = (PAGE_SIZE * 2);
1375                s->buf = kmalloc(s->size, GFP_KERNEL);
1376                if (!s->buf) {
1377                        single_release(inode, file);
1378                        err = -ENOMEM;
1379                }
1380        }
1381        return err;
1382}
1383
1384static const struct file_operations ab8500_all_banks_fops = {
1385        .open = ab8500_all_banks_open,
1386        .read = seq_read,
1387        .llseek = seq_lseek,
1388        .release = single_release,
1389        .owner = THIS_MODULE,
1390};
1391
1392static int ab8500_bank_print(struct seq_file *s, void *p)
1393{
1394        seq_printf(s, "0x%02X\n", debug_bank);
1395        return 0;
1396}
1397
1398static int ab8500_bank_open(struct inode *inode, struct file *file)
1399{
1400        return single_open(file, ab8500_bank_print, inode->i_private);
1401}
1402
1403static ssize_t ab8500_bank_write(struct file *file,
1404        const char __user *user_buf,
1405        size_t count, loff_t *ppos)
1406{
1407        struct device *dev = ((struct seq_file *)(file->private_data))->private;
1408        unsigned long user_bank;
1409        int err;
1410
1411        err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
1412        if (err)
1413                return err;
1414
1415        if (user_bank >= AB8500_NUM_BANKS) {
1416                dev_err(dev, "debugfs error input > number of banks\n");
1417                return -EINVAL;
1418        }
1419
1420        debug_bank = user_bank;
1421
1422        return count;
1423}
1424
1425static int ab8500_address_print(struct seq_file *s, void *p)
1426{
1427        seq_printf(s, "0x%02X\n", debug_address);
1428        return 0;
1429}
1430
1431static int ab8500_address_open(struct inode *inode, struct file *file)
1432{
1433        return single_open(file, ab8500_address_print, inode->i_private);
1434}
1435
1436static ssize_t ab8500_address_write(struct file *file,
1437                                    const char __user *user_buf,
1438                                    size_t count, loff_t *ppos)
1439{
1440        struct device *dev = ((struct seq_file *)(file->private_data))->private;
1441        unsigned long user_address;
1442        int err;
1443
1444        err = kstrtoul_from_user(user_buf, count, 0, &user_address);
1445        if (err)
1446                return err;
1447
1448        if (user_address > 0xff) {
1449                dev_err(dev, "debugfs error input > 0xff\n");
1450                return -EINVAL;
1451        }
1452        debug_address = user_address;
1453
1454        return count;
1455}
1456
1457static int ab8500_val_print(struct seq_file *s, void *p)
1458{
1459        struct device *dev = s->private;
1460        int ret;
1461        u8 regvalue;
1462
1463        ret = abx500_get_register_interruptible(dev,
1464                (u8)debug_bank, (u8)debug_address, &regvalue);
1465        if (ret < 0) {
1466                dev_err(dev, "abx500_get_reg fail %d, %d\n",
1467                        ret, __LINE__);
1468                return -EINVAL;
1469        }
1470        seq_printf(s, "0x%02X\n", regvalue);
1471
1472        return 0;
1473}
1474
1475static int ab8500_val_open(struct inode *inode, struct file *file)
1476{
1477        return single_open(file, ab8500_val_print, inode->i_private);
1478}
1479
1480static ssize_t ab8500_val_write(struct file *file,
1481                                const char __user *user_buf,
1482                                size_t count, loff_t *ppos)
1483{
1484        struct device *dev = ((struct seq_file *)(file->private_data))->private;
1485        unsigned long user_val;
1486        int err;
1487
1488        err = kstrtoul_from_user(user_buf, count, 0, &user_val);
1489        if (err)
1490                return err;
1491
1492        if (user_val > 0xff) {
1493                dev_err(dev, "debugfs error input > 0xff\n");
1494                return -EINVAL;
1495        }
1496        err = abx500_set_register_interruptible(dev,
1497                (u8)debug_bank, debug_address, (u8)user_val);
1498        if (err < 0) {
1499                pr_err("abx500_set_reg failed %d, %d", err, __LINE__);
1500                return -EINVAL;
1501        }
1502
1503        return count;
1504}
1505
1506/*
1507 * Interrupt status
1508 */
1509static u32 num_interrupts[AB8500_MAX_NR_IRQS];
1510static u32 num_wake_interrupts[AB8500_MAX_NR_IRQS];
1511static int num_interrupt_lines;
1512
1513void ab8500_debug_register_interrupt(int line)
1514{
1515        if (line < num_interrupt_lines)
1516                num_interrupts[line]++;
1517}
1518
1519static int ab8500_interrupts_show(struct seq_file *s, void *p)
1520{
1521        int line;
1522
1523        seq_puts(s, "name: number:  number of: wake:\n");
1524
1525        for (line = 0; line < num_interrupt_lines; line++) {
1526                struct irq_desc *desc = irq_to_desc(line + irq_first);
1527
1528                seq_printf(s, "%3i:  %6i %4i",
1529                           line,
1530                           num_interrupts[line],
1531                           num_wake_interrupts[line]);
1532
1533                if (desc && desc->name)
1534                        seq_printf(s, "-%-8s", desc->name);
1535                if (desc && desc->action) {
1536                        struct irqaction *action = desc->action;
1537
1538                        seq_printf(s, "  %s", action->name);
1539                        while ((action = action->next) != NULL)
1540                                seq_printf(s, ", %s", action->name);
1541                }
1542                seq_putc(s, '\n');
1543        }
1544
1545        return 0;
1546}
1547
1548DEFINE_SHOW_ATTRIBUTE(ab8500_interrupts);
1549
1550/*
1551 * - HWREG DB8500 formated routines
1552 */
1553static int ab8500_hwreg_print(struct seq_file *s, void *d)
1554{
1555        struct device *dev = s->private;
1556        int ret;
1557        u8 regvalue;
1558
1559        ret = abx500_get_register_interruptible(dev,
1560                (u8)hwreg_cfg.bank, (u8)hwreg_cfg.addr, &regvalue);
1561        if (ret < 0) {
1562                dev_err(dev, "abx500_get_reg fail %d, %d\n",
1563                        ret, __LINE__);
1564                return -EINVAL;
1565        }
1566
1567        if (hwreg_cfg.shift >= 0)
1568                regvalue >>= hwreg_cfg.shift;
1569        else
1570                regvalue <<= -hwreg_cfg.shift;
1571        regvalue &= hwreg_cfg.mask;
1572
1573        if (REG_FMT_DEC(&hwreg_cfg))
1574                seq_printf(s, "%d\n", regvalue);
1575        else
1576                seq_printf(s, "0x%02X\n", regvalue);
1577        return 0;
1578}
1579
1580static int ab8500_hwreg_open(struct inode *inode, struct file *file)
1581{
1582        return single_open(file, ab8500_hwreg_print, inode->i_private);
1583}
1584
1585#define AB8500_SUPPLY_CONTROL_CONFIG_1 0x01
1586#define AB8500_SUPPLY_CONTROL_REG 0x00
1587#define AB8500_FIRST_SIM_REG 0x80
1588#define AB8500_LAST_SIM_REG 0x8B
1589#define AB8505_LAST_SIM_REG 0x8C
1590
1591static int ab8500_modem_show(struct seq_file *s, void *p)
1592{
1593        struct device *dev = s->private;
1594        struct ab8500 *ab8500;
1595        int err;
1596        u8 value;
1597        u8 orig_value;
1598        u32 bank = AB8500_REGU_CTRL2;
1599        u32 last_sim_reg = AB8500_LAST_SIM_REG;
1600        u32 reg;
1601
1602        ab8500 = dev_get_drvdata(dev->parent);
1603        dev_warn(dev, "WARNING! This operation can interfer with modem side\n"
1604                "and should only be done with care\n");
1605
1606        err = abx500_get_register_interruptible(dev,
1607                AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, &orig_value);
1608        if (err < 0)
1609                goto report_read_failure;
1610
1611        /* Config 1 will allow APE side to read SIM registers */
1612        err = abx500_set_register_interruptible(dev,
1613                AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG,
1614                AB8500_SUPPLY_CONTROL_CONFIG_1);
1615        if (err < 0)
1616                goto report_write_failure;
1617
1618        seq_printf(s, " bank 0x%02X:\n", bank);
1619
1620        if (is_ab9540(ab8500) || is_ab8505(ab8500))
1621                last_sim_reg = AB8505_LAST_SIM_REG;
1622
1623        for (reg = AB8500_FIRST_SIM_REG; reg <= last_sim_reg; reg++) {
1624                err = abx500_get_register_interruptible(dev,
1625                        bank, reg, &value);
1626                if (err < 0)
1627                        goto report_read_failure;
1628
1629                seq_printf(s, "  [0x%02X/0x%02X]: 0x%02X\n", bank, reg, value);
1630        }
1631        err = abx500_set_register_interruptible(dev,
1632                AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, orig_value);
1633        if (err < 0)
1634                goto report_write_failure;
1635
1636        return 0;
1637
1638report_read_failure:
1639        dev_err(dev, "ab->read fail %d\n", err);
1640        return err;
1641
1642report_write_failure:
1643        dev_err(dev, "ab->write fail %d\n", err);
1644        return err;
1645}
1646
1647DEFINE_SHOW_ATTRIBUTE(ab8500_modem);
1648
1649static int ab8500_gpadc_bat_ctrl_show(struct seq_file *s, void *p)
1650{
1651        int bat_ctrl_raw;
1652        int bat_ctrl_convert;
1653        struct ab8500_gpadc *gpadc;
1654
1655        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1656        bat_ctrl_raw = ab8500_gpadc_read_raw(gpadc, BAT_CTRL,
1657                avg_sample, trig_edge, trig_timer, conv_type);
1658        bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1659                BAT_CTRL, bat_ctrl_raw);
1660
1661        seq_printf(s, "%d,0x%X\n", bat_ctrl_convert, bat_ctrl_raw);
1662
1663        return 0;
1664}
1665
1666DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_bat_ctrl);
1667
1668static int ab8500_gpadc_btemp_ball_show(struct seq_file *s, void *p)
1669{
1670        int btemp_ball_raw;
1671        int btemp_ball_convert;
1672        struct ab8500_gpadc *gpadc;
1673
1674        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1675        btemp_ball_raw = ab8500_gpadc_read_raw(gpadc, BTEMP_BALL,
1676                avg_sample, trig_edge, trig_timer, conv_type);
1677        btemp_ball_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
1678                btemp_ball_raw);
1679
1680        seq_printf(s, "%d,0x%X\n", btemp_ball_convert, btemp_ball_raw);
1681
1682        return 0;
1683}
1684
1685DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_btemp_ball);
1686
1687static int ab8500_gpadc_main_charger_v_show(struct seq_file *s, void *p)
1688{
1689        int main_charger_v_raw;
1690        int main_charger_v_convert;
1691        struct ab8500_gpadc *gpadc;
1692
1693        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1694        main_charger_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_V,
1695                avg_sample, trig_edge, trig_timer, conv_type);
1696        main_charger_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1697                MAIN_CHARGER_V, main_charger_v_raw);
1698
1699        seq_printf(s, "%d,0x%X\n", main_charger_v_convert, main_charger_v_raw);
1700
1701        return 0;
1702}
1703
1704DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_main_charger_v);
1705
1706static int ab8500_gpadc_acc_detect1_show(struct seq_file *s, void *p)
1707{
1708        int acc_detect1_raw;
1709        int acc_detect1_convert;
1710        struct ab8500_gpadc *gpadc;
1711
1712        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1713        acc_detect1_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT1,
1714                avg_sample, trig_edge, trig_timer, conv_type);
1715        acc_detect1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ACC_DETECT1,
1716                acc_detect1_raw);
1717
1718        seq_printf(s, "%d,0x%X\n", acc_detect1_convert, acc_detect1_raw);
1719
1720        return 0;
1721}
1722
1723DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_acc_detect1);
1724
1725static int ab8500_gpadc_acc_detect2_show(struct seq_file *s, void *p)
1726{
1727        int acc_detect2_raw;
1728        int acc_detect2_convert;
1729        struct ab8500_gpadc *gpadc;
1730
1731        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1732        acc_detect2_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT2,
1733                avg_sample, trig_edge, trig_timer, conv_type);
1734        acc_detect2_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1735                ACC_DETECT2, acc_detect2_raw);
1736
1737        seq_printf(s, "%d,0x%X\n", acc_detect2_convert, acc_detect2_raw);
1738
1739        return 0;
1740}
1741
1742DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_acc_detect2);
1743
1744static int ab8500_gpadc_aux1_show(struct seq_file *s, void *p)
1745{
1746        int aux1_raw;
1747        int aux1_convert;
1748        struct ab8500_gpadc *gpadc;
1749
1750        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1751        aux1_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX1,
1752                avg_sample, trig_edge, trig_timer, conv_type);
1753        aux1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX1,
1754                aux1_raw);
1755
1756        seq_printf(s, "%d,0x%X\n", aux1_convert, aux1_raw);
1757
1758        return 0;
1759}
1760
1761DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_aux1);
1762
1763static int ab8500_gpadc_aux2_show(struct seq_file *s, void *p)
1764{
1765        int aux2_raw;
1766        int aux2_convert;
1767        struct ab8500_gpadc *gpadc;
1768
1769        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1770        aux2_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX2,
1771                avg_sample, trig_edge, trig_timer, conv_type);
1772        aux2_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX2,
1773                aux2_raw);
1774
1775        seq_printf(s, "%d,0x%X\n", aux2_convert, aux2_raw);
1776
1777        return 0;
1778}
1779
1780DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_aux2);
1781
1782static int ab8500_gpadc_main_bat_v_show(struct seq_file *s, void *p)
1783{
1784        int main_bat_v_raw;
1785        int main_bat_v_convert;
1786        struct ab8500_gpadc *gpadc;
1787
1788        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1789        main_bat_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_BAT_V,
1790                avg_sample, trig_edge, trig_timer, conv_type);
1791        main_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
1792                main_bat_v_raw);
1793
1794        seq_printf(s, "%d,0x%X\n", main_bat_v_convert, main_bat_v_raw);
1795
1796        return 0;
1797}
1798
1799DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_main_bat_v);
1800
1801static int ab8500_gpadc_vbus_v_show(struct seq_file *s, void *p)
1802{
1803        int vbus_v_raw;
1804        int vbus_v_convert;
1805        struct ab8500_gpadc *gpadc;
1806
1807        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1808        vbus_v_raw =  ab8500_gpadc_read_raw(gpadc, VBUS_V,
1809                avg_sample, trig_edge, trig_timer, conv_type);
1810        vbus_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, VBUS_V,
1811                vbus_v_raw);
1812
1813        seq_printf(s, "%d,0x%X\n", vbus_v_convert, vbus_v_raw);
1814
1815        return 0;
1816}
1817
1818DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_vbus_v);
1819
1820static int ab8500_gpadc_main_charger_c_show(struct seq_file *s, void *p)
1821{
1822        int main_charger_c_raw;
1823        int main_charger_c_convert;
1824        struct ab8500_gpadc *gpadc;
1825
1826        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1827        main_charger_c_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_C,
1828                avg_sample, trig_edge, trig_timer, conv_type);
1829        main_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1830                MAIN_CHARGER_C, main_charger_c_raw);
1831
1832        seq_printf(s, "%d,0x%X\n", main_charger_c_convert, main_charger_c_raw);
1833
1834        return 0;
1835}
1836
1837DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_main_charger_c);
1838
1839static int ab8500_gpadc_usb_charger_c_show(struct seq_file *s, void *p)
1840{
1841        int usb_charger_c_raw;
1842        int usb_charger_c_convert;
1843        struct ab8500_gpadc *gpadc;
1844
1845        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1846        usb_charger_c_raw = ab8500_gpadc_read_raw(gpadc, USB_CHARGER_C,
1847                avg_sample, trig_edge, trig_timer, conv_type);
1848        usb_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1849                USB_CHARGER_C, usb_charger_c_raw);
1850
1851        seq_printf(s, "%d,0x%X\n", usb_charger_c_convert, usb_charger_c_raw);
1852
1853        return 0;
1854}
1855
1856DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_usb_charger_c);
1857
1858static int ab8500_gpadc_bk_bat_v_show(struct seq_file *s, void *p)
1859{
1860        int bk_bat_v_raw;
1861        int bk_bat_v_convert;
1862        struct ab8500_gpadc *gpadc;
1863
1864        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1865        bk_bat_v_raw = ab8500_gpadc_read_raw(gpadc, BK_BAT_V,
1866                avg_sample, trig_edge, trig_timer, conv_type);
1867        bk_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1868                BK_BAT_V, bk_bat_v_raw);
1869
1870        seq_printf(s, "%d,0x%X\n", bk_bat_v_convert, bk_bat_v_raw);
1871
1872        return 0;
1873}
1874
1875DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_bk_bat_v);
1876
1877static int ab8500_gpadc_die_temp_show(struct seq_file *s, void *p)
1878{
1879        int die_temp_raw;
1880        int die_temp_convert;
1881        struct ab8500_gpadc *gpadc;
1882
1883        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1884        die_temp_raw = ab8500_gpadc_read_raw(gpadc, DIE_TEMP,
1885                avg_sample, trig_edge, trig_timer, conv_type);
1886        die_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, DIE_TEMP,
1887                die_temp_raw);
1888
1889        seq_printf(s, "%d,0x%X\n", die_temp_convert, die_temp_raw);
1890
1891        return 0;
1892}
1893
1894DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_die_temp);
1895
1896static int ab8500_gpadc_usb_id_show(struct seq_file *s, void *p)
1897{
1898        int usb_id_raw;
1899        int usb_id_convert;
1900        struct ab8500_gpadc *gpadc;
1901
1902        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1903        usb_id_raw = ab8500_gpadc_read_raw(gpadc, USB_ID,
1904                avg_sample, trig_edge, trig_timer, conv_type);
1905        usb_id_convert = ab8500_gpadc_ad_to_voltage(gpadc, USB_ID,
1906                usb_id_raw);
1907
1908        seq_printf(s, "%d,0x%X\n", usb_id_convert, usb_id_raw);
1909
1910        return 0;
1911}
1912
1913DEFINE_SHOW_ATTRIBUTE(ab8500_gpadc_usb_id);
1914
1915static int ab8540_gpadc_xtal_temp_show(struct seq_file *s, void *p)
1916{
1917        int xtal_temp_raw;
1918        int xtal_temp_convert;
1919        struct ab8500_gpadc *gpadc;
1920
1921        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1922        xtal_temp_raw = ab8500_gpadc_read_raw(gpadc, XTAL_TEMP,
1923                avg_sample, trig_edge, trig_timer, conv_type);
1924        xtal_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, XTAL_TEMP,
1925                xtal_temp_raw);
1926
1927        seq_printf(s, "%d,0x%X\n", xtal_temp_convert, xtal_temp_raw);
1928
1929        return 0;
1930}
1931
1932DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_xtal_temp);
1933
1934static int ab8540_gpadc_vbat_true_meas_show(struct seq_file *s, void *p)
1935{
1936        int vbat_true_meas_raw;
1937        int vbat_true_meas_convert;
1938        struct ab8500_gpadc *gpadc;
1939
1940        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1941        vbat_true_meas_raw = ab8500_gpadc_read_raw(gpadc, VBAT_TRUE_MEAS,
1942                avg_sample, trig_edge, trig_timer, conv_type);
1943        vbat_true_meas_convert =
1944                ab8500_gpadc_ad_to_voltage(gpadc, VBAT_TRUE_MEAS,
1945                                           vbat_true_meas_raw);
1946
1947        seq_printf(s, "%d,0x%X\n", vbat_true_meas_convert, vbat_true_meas_raw);
1948
1949        return 0;
1950}
1951
1952DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_vbat_true_meas);
1953
1954static int ab8540_gpadc_bat_ctrl_and_ibat_show(struct seq_file *s, void *p)
1955{
1956        int bat_ctrl_raw;
1957        int bat_ctrl_convert;
1958        int ibat_raw;
1959        int ibat_convert;
1960        struct ab8500_gpadc *gpadc;
1961
1962        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1963        bat_ctrl_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_CTRL_AND_IBAT,
1964                avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
1965
1966        bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc, BAT_CTRL,
1967                bat_ctrl_raw);
1968        ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
1969                ibat_raw);
1970
1971        seq_printf(s,
1972                   "%d,0x%X\n"
1973                   "%d,0x%X\n",
1974                   bat_ctrl_convert, bat_ctrl_raw,
1975                   ibat_convert, ibat_raw);
1976
1977        return 0;
1978}
1979
1980DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_bat_ctrl_and_ibat);
1981
1982static int ab8540_gpadc_vbat_meas_and_ibat_show(struct seq_file *s, void *p)
1983{
1984        int vbat_meas_raw;
1985        int vbat_meas_convert;
1986        int ibat_raw;
1987        int ibat_convert;
1988        struct ab8500_gpadc *gpadc;
1989
1990        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1991        vbat_meas_raw = ab8500_gpadc_double_read_raw(gpadc, VBAT_MEAS_AND_IBAT,
1992                avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
1993        vbat_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
1994                vbat_meas_raw);
1995        ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
1996                ibat_raw);
1997
1998        seq_printf(s,
1999                   "%d,0x%X\n"
2000                   "%d,0x%X\n",
2001                   vbat_meas_convert, vbat_meas_raw,
2002                   ibat_convert, ibat_raw);
2003
2004        return 0;
2005}
2006
2007DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_vbat_meas_and_ibat);
2008
2009static int ab8540_gpadc_vbat_true_meas_and_ibat_show(struct seq_file *s, void *p)
2010{
2011        int vbat_true_meas_raw;
2012        int vbat_true_meas_convert;
2013        int ibat_raw;
2014        int ibat_convert;
2015        struct ab8500_gpadc *gpadc;
2016
2017        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2018        vbat_true_meas_raw = ab8500_gpadc_double_read_raw(gpadc,
2019                        VBAT_TRUE_MEAS_AND_IBAT, avg_sample, trig_edge,
2020                        trig_timer, conv_type, &ibat_raw);
2021        vbat_true_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2022                        VBAT_TRUE_MEAS, vbat_true_meas_raw);
2023        ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2024                ibat_raw);
2025
2026        seq_printf(s,
2027                   "%d,0x%X\n"
2028                   "%d,0x%X\n",
2029                   vbat_true_meas_convert, vbat_true_meas_raw,
2030                   ibat_convert, ibat_raw);
2031
2032        return 0;
2033}
2034
2035DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_vbat_true_meas_and_ibat);
2036
2037static int ab8540_gpadc_bat_temp_and_ibat_show(struct seq_file *s, void *p)
2038{
2039        int bat_temp_raw;
2040        int bat_temp_convert;
2041        int ibat_raw;
2042        int ibat_convert;
2043        struct ab8500_gpadc *gpadc;
2044
2045        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2046        bat_temp_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_TEMP_AND_IBAT,
2047                avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2048        bat_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
2049                bat_temp_raw);
2050        ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2051                ibat_raw);
2052
2053        seq_printf(s,
2054                   "%d,0x%X\n"
2055                   "%d,0x%X\n",
2056                   bat_temp_convert, bat_temp_raw,
2057                   ibat_convert, ibat_raw);
2058
2059        return 0;
2060}
2061
2062DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_bat_temp_and_ibat);
2063
2064static int ab8540_gpadc_otp_calib_show(struct seq_file *s, void *p)
2065{
2066        struct ab8500_gpadc *gpadc;
2067        u16 vmain_l, vmain_h, btemp_l, btemp_h;
2068        u16 vbat_l, vbat_h, ibat_l, ibat_h;
2069
2070        gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2071        ab8540_gpadc_get_otp(gpadc, &vmain_l, &vmain_h, &btemp_l, &btemp_h,
2072                        &vbat_l, &vbat_h, &ibat_l, &ibat_h);
2073        seq_printf(s,
2074                   "VMAIN_L:0x%X\n"
2075                   "VMAIN_H:0x%X\n"
2076                   "BTEMP_L:0x%X\n"
2077                   "BTEMP_H:0x%X\n"
2078                   "VBAT_L:0x%X\n"
2079                   "VBAT_H:0x%X\n"
2080                   "IBAT_L:0x%X\n"
2081                   "IBAT_H:0x%X\n",
2082                   vmain_l, vmain_h, btemp_l, btemp_h,
2083                   vbat_l, vbat_h, ibat_l, ibat_h);
2084
2085        return 0;
2086}
2087
2088DEFINE_SHOW_ATTRIBUTE(ab8540_gpadc_otp_calib);
2089
2090static int ab8500_gpadc_avg_sample_print(struct seq_file *s, void *p)
2091{
2092        seq_printf(s, "%d\n", avg_sample);
2093
2094        return 0;
2095}
2096
2097static int ab8500_gpadc_avg_sample_open(struct inode *inode, struct file *file)
2098{
2099        return single_open(file, ab8500_gpadc_avg_sample_print,
2100                inode->i_private);
2101}
2102
2103static ssize_t ab8500_gpadc_avg_sample_write(struct file *file,
2104        const char __user *user_buf,
2105        size_t count, loff_t *ppos)
2106{
2107        struct device *dev = ((struct seq_file *)(file->private_data))->private;
2108        unsigned long user_avg_sample;
2109        int err;
2110
2111        err = kstrtoul_from_user(user_buf, count, 0, &user_avg_sample);
2112        if (err)
2113                return err;
2114
2115        if ((user_avg_sample == SAMPLE_1) || (user_avg_sample == SAMPLE_4)
2116                        || (user_avg_sample == SAMPLE_8)
2117                        || (user_avg_sample == SAMPLE_16)) {
2118                avg_sample = (u8) user_avg_sample;
2119        } else {
2120                dev_err(dev,
2121                        "debugfs err input: should be egal to 1, 4, 8 or 16\n");
2122                return -EINVAL;
2123        }
2124
2125        return count;
2126}
2127
2128static const struct file_operations ab8500_gpadc_avg_sample_fops = {
2129        .open = ab8500_gpadc_avg_sample_open,
2130        .read = seq_read,
2131        .write = ab8500_gpadc_avg_sample_write,
2132        .llseek = seq_lseek,
2133        .release = single_release,
2134        .owner = THIS_MODULE,
2135};
2136
2137static int ab8500_gpadc_trig_edge_print(struct seq_file *s, void *p)
2138{
2139        seq_printf(s, "%d\n", trig_edge);
2140
2141        return 0;
2142}
2143
2144static int ab8500_gpadc_trig_edge_open(struct inode *inode, struct file *file)
2145{
2146        return single_open(file, ab8500_gpadc_trig_edge_print,
2147                inode->i_private);
2148}
2149
2150static ssize_t ab8500_gpadc_trig_edge_write(struct file *file,
2151        const char __user *user_buf,
2152        size_t count, loff_t *ppos)
2153{
2154        struct device *dev = ((struct seq_file *)(file->private_data))->private;
2155        unsigned long user_trig_edge;
2156        int err;
2157
2158        err = kstrtoul_from_user(user_buf, count, 0, &user_trig_edge);
2159        if (err)
2160                return err;
2161
2162        if ((user_trig_edge == RISING_EDGE)
2163                        || (user_trig_edge == FALLING_EDGE)) {
2164                trig_edge = (u8) user_trig_edge;
2165        } else {
2166                dev_err(dev, "Wrong input:\n"
2167                        "Enter 0. Rising edge\n"
2168                        "Enter 1. Falling edge\n");
2169                return -EINVAL;
2170        }
2171
2172        return count;
2173}
2174
2175static const struct file_operations ab8500_gpadc_trig_edge_fops = {
2176        .open = ab8500_gpadc_trig_edge_open,
2177        .read = seq_read,
2178        .write = ab8500_gpadc_trig_edge_write,
2179        .llseek = seq_lseek,
2180        .release = single_release,
2181        .owner = THIS_MODULE,
2182};
2183
2184static int ab8500_gpadc_trig_timer_print(struct seq_file *s, void *p)
2185{
2186        seq_printf(s, "%d\n", trig_timer);
2187
2188        return 0;
2189}
2190
2191static int ab8500_gpadc_trig_timer_open(struct inode *inode, struct file *file)
2192{
2193        return single_open(file, ab8500_gpadc_trig_timer_print,
2194                inode->i_private);
2195}
2196
2197static ssize_t ab8500_gpadc_trig_timer_write(struct file *file,
2198        const char __user *user_buf,
2199        size_t count, loff_t *ppos)
2200{
2201        struct device *dev = ((struct seq_file *)(file->private_data))->private;
2202        unsigned long user_trig_timer;
2203        int err;
2204
2205        err = kstrtoul_from_user(user_buf, count, 0, &user_trig_timer);
2206        if (err)
2207                return err;
2208
2209        if (user_trig_timer & ~0xFF) {
2210                dev_err(dev,
2211                        "debugfs error input: should be between 0 to 255\n");
2212                return -EINVAL;
2213        }
2214
2215        trig_timer = (u8) user_trig_timer;
2216
2217        return count;
2218}
2219
2220static const struct file_operations ab8500_gpadc_trig_timer_fops = {
2221        .open = ab8500_gpadc_trig_timer_open,
2222        .read = seq_read,
2223        .write = ab8500_gpadc_trig_timer_write,
2224        .llseek = seq_lseek,
2225        .release = single_release,
2226        .owner = THIS_MODULE,
2227};
2228
2229static int ab8500_gpadc_conv_type_print(struct seq_file *s, void *p)
2230{
2231        seq_printf(s, "%d\n", conv_type);
2232
2233        return 0;
2234}
2235
2236static int ab8500_gpadc_conv_type_open(struct inode *inode, struct file *file)
2237{
2238        return single_open(file, ab8500_gpadc_conv_type_print,
2239                inode->i_private);
2240}
2241
2242static ssize_t ab8500_gpadc_conv_type_write(struct file *file,
2243        const char __user *user_buf,
2244        size_t count, loff_t *ppos)
2245{
2246        struct device *dev = ((struct seq_file *)(file->private_data))->private;
2247        unsigned long user_conv_type;
2248        int err;
2249
2250        err = kstrtoul_from_user(user_buf, count, 0, &user_conv_type);
2251        if (err)
2252                return err;
2253
2254        if ((user_conv_type == ADC_SW)
2255                        || (user_conv_type == ADC_HW)) {
2256                conv_type = (u8) user_conv_type;
2257        } else {
2258                dev_err(dev, "Wrong input:\n"
2259                        "Enter 0. ADC SW conversion\n"
2260                        "Enter 1. ADC HW conversion\n");
2261                return -EINVAL;
2262        }
2263
2264        return count;
2265}
2266
2267static const struct file_operations ab8500_gpadc_conv_type_fops = {
2268        .open = ab8500_gpadc_conv_type_open,
2269        .read = seq_read,
2270        .write = ab8500_gpadc_conv_type_write,
2271        .llseek = seq_lseek,
2272        .release = single_release,
2273        .owner = THIS_MODULE,
2274};
2275
2276/*
2277 * return length of an ASCII numerical value, 0 is string is not a
2278 * numerical value.
2279 * string shall start at value 1st char.
2280 * string can be tailed with \0 or space or newline chars only.
2281 * value can be decimal or hexadecimal (prefixed 0x or 0X).
2282 */
2283static int strval_len(char *b)
2284{
2285        char *s = b;
2286
2287        if ((*s == '0') && ((*(s+1) == 'x') || (*(s+1) == 'X'))) {
2288                s += 2;
2289                for (; *s && (*s != ' ') && (*s != '\n'); s++) {
2290                        if (!isxdigit(*s))
2291                                return 0;
2292                }
2293        } else {
2294                if (*s == '-')
2295                        s++;
2296                for (; *s && (*s != ' ') && (*s != '\n'); s++) {
2297                        if (!isdigit(*s))
2298                                return 0;
2299                }
2300        }
2301        return (int) (s-b);
2302}
2303
2304/*
2305 * parse hwreg input data.
2306 * update global hwreg_cfg only if input data syntax is ok.
2307 */
2308static ssize_t hwreg_common_write(char *b, struct hwreg_cfg *cfg,
2309                struct device *dev)
2310{
2311        uint write, val = 0;
2312        u8  regvalue;
2313        int ret;
2314        struct hwreg_cfg loc = {
2315                .bank = 0,          /* default: invalid phys addr */
2316                .addr = 0,          /* default: invalid phys addr */
2317                .fmt = 0,           /* default: 32bit access, hex output */
2318                .mask = 0xFFFFFFFF, /* default: no mask */
2319                .shift = 0,         /* default: no bit shift */
2320        };
2321
2322        /* read or write ? */
2323        if (!strncmp(b, "read ", 5)) {
2324                write = 0;
2325                b += 5;
2326        } else if (!strncmp(b, "write ", 6)) {
2327                write = 1;
2328                b += 6;
2329        } else
2330                return -EINVAL;
2331
2332        /* OPTIONS -l|-w|-b -s -m -o */
2333        while ((*b == ' ') || (*b == '-')) {
2334                if (*(b-1) != ' ') {
2335                        b++;
2336                        continue;
2337                }
2338                if ((!strncmp(b, "-d ", 3)) ||
2339                                (!strncmp(b, "-dec ", 5))) {
2340                        b += (*(b+2) == ' ') ? 3 : 5;
2341                        loc.fmt |= (1<<0);
2342                } else if ((!strncmp(b, "-h ", 3)) ||
2343                                (!strncmp(b, "-hex ", 5))) {
2344                        b += (*(b+2) == ' ') ? 3 : 5;
2345                        loc.fmt &= ~(1<<0);
2346                } else if ((!strncmp(b, "-m ", 3)) ||
2347                                (!strncmp(b, "-mask ", 6))) {
2348                        b += (*(b+2) == ' ') ? 3 : 6;
2349                        if (strval_len(b) == 0)
2350                                return -EINVAL;
2351                        ret = kstrtoul(b, 0, &loc.mask);
2352                        if (ret)
2353                                return ret;
2354                } else if ((!strncmp(b, "-s ", 3)) ||
2355                                (!strncmp(b, "-shift ", 7))) {
2356                        b += (*(b+2) == ' ') ? 3 : 7;
2357                        if (strval_len(b) == 0)
2358                                return -EINVAL;
2359                        ret = kstrtol(b, 0, &loc.shift);
2360                        if (ret)
2361                                return ret;
2362                } else {
2363                        return -EINVAL;
2364                }
2365        }
2366        /* get arg BANK and ADDRESS */
2367        if (strval_len(b) == 0)
2368                return -EINVAL;
2369        ret = kstrtouint(b, 0, &loc.bank);
2370        if (ret)
2371                return ret;
2372        while (*b == ' ')
2373                b++;
2374        if (strval_len(b) == 0)
2375                return -EINVAL;
2376        ret = kstrtoul(b, 0, &loc.addr);
2377        if (ret)
2378                return ret;
2379
2380        if (write) {
2381                while (*b == ' ')
2382                        b++;
2383                if (strval_len(b) == 0)
2384                        return -EINVAL;
2385                ret = kstrtouint(b, 0, &val);
2386                if (ret)
2387                        return ret;
2388        }
2389
2390        /* args are ok, update target cfg (mainly for read) */
2391        *cfg = loc;
2392
2393#ifdef ABB_HWREG_DEBUG
2394        pr_warn("HWREG request: %s, %s,\n", (write) ? "write" : "read",
2395                REG_FMT_DEC(cfg) ? "decimal" : "hexa");
2396        pr_warn("  addr=0x%08X, mask=0x%X, shift=%d" "value=0x%X\n",
2397                cfg->addr, cfg->mask, cfg->shift, val);
2398#endif
2399
2400        if (!write)
2401                return 0;
2402
2403        ret = abx500_get_register_interruptible(dev,
2404                        (u8)cfg->bank, (u8)cfg->addr, &regvalue);
2405        if (ret < 0) {
2406                dev_err(dev, "abx500_get_reg fail %d, %d\n",
2407                        ret, __LINE__);
2408                return -EINVAL;
2409        }
2410
2411        if (cfg->shift >= 0) {
2412                regvalue &= ~(cfg->mask << (cfg->shift));
2413                val = (val & cfg->mask) << (cfg->shift);
2414        } else {
2415                regvalue &= ~(cfg->mask >> (-cfg->shift));
2416                val = (val & cfg->mask) >> (-cfg->shift);
2417        }
2418        val = val | regvalue;
2419
2420        ret = abx500_set_register_interruptible(dev,
2421                        (u8)cfg->bank, (u8)cfg->addr, (u8)val);
2422        if (ret < 0) {
2423                pr_err("abx500_set_reg failed %d, %d", ret, __LINE__);
2424                return -EINVAL;
2425        }
2426
2427        return 0;
2428}
2429
2430static ssize_t ab8500_hwreg_write(struct file *file,
2431        const char __user *user_buf, size_t count, loff_t *ppos)
2432{
2433        struct device *dev = ((struct seq_file *)(file->private_data))->private;
2434        char buf[128];
2435        int buf_size, ret;
2436
2437        /* Get userspace string and assure termination */
2438        buf_size = min(count, (sizeof(buf)-1));
2439        if (copy_from_user(buf, user_buf, buf_size))
2440                return -EFAULT;
2441        buf[buf_size] = 0;
2442
2443        /* get args and process */
2444        ret = hwreg_common_write(buf, &hwreg_cfg, dev);
2445        return (ret) ? ret : buf_size;
2446}
2447
2448/*
2449 * - irq subscribe/unsubscribe stuff
2450 */
2451static int ab8500_subscribe_unsubscribe_print(struct seq_file *s, void *p)
2452{
2453        seq_printf(s, "%d\n", irq_first);
2454
2455        return 0;
2456}
2457
2458static int ab8500_subscribe_unsubscribe_open(struct inode *inode,
2459                                             struct file *file)
2460{
2461        return single_open(file, ab8500_subscribe_unsubscribe_print,
2462                inode->i_private);
2463}
2464
2465/*
2466 * Userspace should use poll() on this file. When an event occur
2467 * the blocking poll will be released.
2468 */
2469static ssize_t show_irq(struct device *dev,
2470                        struct device_attribute *attr, char *buf)
2471{
2472        unsigned long name;
2473        unsigned int irq_index;
2474        int err;
2475
2476        err = kstrtoul(attr->attr.name, 0, &name);
2477        if (err)
2478                return err;
2479
2480        irq_index = name - irq_first;
2481        if (irq_index >= num_irqs)
2482                return -EINVAL;
2483
2484        return sprintf(buf, "%u\n", irq_count[irq_index]);
2485}
2486
2487static ssize_t ab8500_subscribe_write(struct file *file,
2488                                      const char __user *user_buf,
2489                                      size_t count, loff_t *ppos)
2490{
2491        struct device *dev = ((struct seq_file *)(file->private_data))->private;
2492        unsigned long user_val;
2493        int err;
2494        unsigned int irq_index;
2495
2496        err = kstrtoul_from_user(user_buf, count, 0, &user_val);
2497        if (err)
2498                return err;
2499
2500        if (user_val < irq_first) {
2501                dev_err(dev, "debugfs error input < %d\n", irq_first);
2502                return -EINVAL;
2503        }
2504        if (user_val > irq_last) {
2505                dev_err(dev, "debugfs error input > %d\n", irq_last);
2506                return -EINVAL;
2507        }
2508
2509        irq_index = user_val - irq_first;
2510        if (irq_index >= num_irqs)
2511                return -EINVAL;
2512
2513        /*
2514         * This will create a sysfs file named <irq-nr> which userspace can
2515         * use to select or poll and get the AB8500 events
2516         */
2517        dev_attr[irq_index] = kmalloc(sizeof(struct device_attribute),
2518                GFP_KERNEL);
2519        if (!dev_attr[irq_index])
2520                return -ENOMEM;
2521
2522        event_name[irq_index] = kasprintf(GFP_KERNEL, "%lu", user_val);
2523        if (!event_name[irq_index])
2524                return -ENOMEM;
2525
2526        dev_attr[irq_index]->show = show_irq;
2527        dev_attr[irq_index]->store = NULL;
2528        dev_attr[irq_index]->attr.name = event_name[irq_index];
2529        dev_attr[irq_index]->attr.mode = S_IRUGO;
2530        err = sysfs_create_file(&dev->kobj, &dev_attr[irq_index]->attr);
2531        if (err < 0) {
2532                pr_info("sysfs_create_file failed %d\n", err);
2533                return err;
2534        }
2535
2536        err = request_threaded_irq(user_val, NULL, ab8500_debug_handler,
2537                                   IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
2538                                   "ab8500-debug", &dev->kobj);
2539        if (err < 0) {
2540                pr_info("request_threaded_irq failed %d, %lu\n",
2541                        err, user_val);
2542                sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
2543                return err;
2544        }
2545
2546        return count;
2547}
2548
2549static ssize_t ab8500_unsubscribe_write(struct file *file,
2550                                        const char __user *user_buf,
2551                                        size_t count, loff_t *ppos)
2552{
2553        struct device *dev = ((struct seq_file *)(file->private_data))->private;
2554        unsigned long user_val;
2555        int err;
2556        unsigned int irq_index;
2557
2558        err = kstrtoul_from_user(user_buf, count, 0, &user_val);
2559        if (err)
2560                return err;
2561
2562        if (user_val < irq_first) {
2563                dev_err(dev, "debugfs error input < %d\n", irq_first);
2564                return -EINVAL;
2565        }
2566        if (user_val > irq_last) {
2567                dev_err(dev, "debugfs error input > %d\n", irq_last);
2568                return -EINVAL;
2569        }
2570
2571        irq_index = user_val - irq_first;
2572        if (irq_index >= num_irqs)
2573                return -EINVAL;
2574
2575        /* Set irq count to 0 when unsubscribe */
2576        irq_count[irq_index] = 0;
2577
2578        if (dev_attr[irq_index])
2579                sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
2580
2581
2582        free_irq(user_val, &dev->kobj);
2583        kfree(event_name[irq_index]);
2584        kfree(dev_attr[irq_index]);
2585
2586        return count;
2587}
2588
2589/*
2590 * - several debugfs nodes fops
2591 */
2592
2593static const struct file_operations ab8500_bank_fops = {
2594        .open = ab8500_bank_open,
2595        .write = ab8500_bank_write,
2596        .read = seq_read,
2597        .llseek = seq_lseek,
2598        .release = single_release,
2599        .owner = THIS_MODULE,
2600};
2601
2602static const struct file_operations ab8500_address_fops = {
2603        .open = ab8500_address_open,
2604        .write = ab8500_address_write,
2605        .read = seq_read,
2606        .llseek = seq_lseek,
2607        .release = single_release,
2608        .owner = THIS_MODULE,
2609};
2610
2611static const struct file_operations ab8500_val_fops = {
2612        .open = ab8500_val_open,
2613        .write = ab8500_val_write,
2614        .read = seq_read,
2615        .llseek = seq_lseek,
2616        .release = single_release,
2617        .owner = THIS_MODULE,
2618};
2619
2620static const struct file_operations ab8500_subscribe_fops = {
2621        .open = ab8500_subscribe_unsubscribe_open,
2622        .write = ab8500_subscribe_write,
2623        .read = seq_read,
2624        .llseek = seq_lseek,
2625        .release = single_release,
2626        .owner = THIS_MODULE,
2627};
2628
2629static const struct file_operations ab8500_unsubscribe_fops = {
2630        .open = ab8500_subscribe_unsubscribe_open,
2631        .write = ab8500_unsubscribe_write,
2632        .read = seq_read,
2633        .llseek = seq_lseek,
2634        .release = single_release,
2635        .owner = THIS_MODULE,
2636};
2637
2638static const struct file_operations ab8500_hwreg_fops = {
2639        .open = ab8500_hwreg_open,
2640        .write = ab8500_hwreg_write,
2641        .read = seq_read,
2642        .llseek = seq_lseek,
2643        .release = single_release,
2644        .owner = THIS_MODULE,
2645};
2646
2647static int ab8500_debug_probe(struct platform_device *plf)
2648{
2649        struct dentry *ab8500_dir;
2650        struct dentry *ab8500_gpadc_dir;
2651        struct ab8500 *ab8500;
2652        struct resource *res;
2653
2654        debug_bank = AB8500_MISC;
2655        debug_address = AB8500_REV_REG & 0x00FF;
2656
2657        ab8500 = dev_get_drvdata(plf->dev.parent);
2658        num_irqs = ab8500->mask_size;
2659
2660        irq_count = devm_kcalloc(&plf->dev,
2661                                 num_irqs, sizeof(*irq_count), GFP_KERNEL);
2662        if (!irq_count)
2663                return -ENOMEM;
2664
2665        dev_attr = devm_kcalloc(&plf->dev,
2666                                num_irqs, sizeof(*dev_attr), GFP_KERNEL);
2667        if (!dev_attr)
2668                return -ENOMEM;
2669
2670        event_name = devm_kcalloc(&plf->dev,
2671                                  num_irqs, sizeof(*event_name), GFP_KERNEL);
2672        if (!event_name)
2673                return -ENOMEM;
2674
2675        res = platform_get_resource_byname(plf, 0, "IRQ_AB8500");
2676        if (!res) {
2677                dev_err(&plf->dev, "AB8500 irq not found, err %d\n", irq_first);
2678                return -ENXIO;
2679        }
2680        irq_ab8500 = res->start;
2681
2682        irq_first = platform_get_irq_byname(plf, "IRQ_FIRST");
2683        if (irq_first < 0)
2684                return irq_first;
2685
2686        irq_last = platform_get_irq_byname(plf, "IRQ_LAST");
2687        if (irq_last < 0)
2688                return irq_last;
2689
2690        ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
2691
2692        ab8500_gpadc_dir = debugfs_create_dir(AB8500_ADC_NAME_STRING,
2693                                              ab8500_dir);
2694
2695        debugfs_create_file("all-bank-registers", S_IRUGO, ab8500_dir,
2696                            &plf->dev, &ab8500_bank_registers_fops);
2697        debugfs_create_file("all-banks", S_IRUGO, ab8500_dir,
2698                            &plf->dev, &ab8500_all_banks_fops);
2699        debugfs_create_file("register-bank", (S_IRUGO | S_IWUSR | S_IWGRP),
2700                            ab8500_dir, &plf->dev, &ab8500_bank_fops);
2701        debugfs_create_file("register-address", (S_IRUGO | S_IWUSR | S_IWGRP),
2702                            ab8500_dir, &plf->dev, &ab8500_address_fops);
2703        debugfs_create_file("register-value", (S_IRUGO | S_IWUSR | S_IWGRP),
2704                            ab8500_dir, &plf->dev, &ab8500_val_fops);
2705        debugfs_create_file("irq-subscribe", (S_IRUGO | S_IWUSR | S_IWGRP),
2706                            ab8500_dir, &plf->dev, &ab8500_subscribe_fops);
2707
2708        if (is_ab8500(ab8500)) {
2709                debug_ranges = ab8500_debug_ranges;
2710                num_interrupt_lines = AB8500_NR_IRQS;
2711        } else if (is_ab8505(ab8500)) {
2712                debug_ranges = ab8505_debug_ranges;
2713                num_interrupt_lines = AB8505_NR_IRQS;
2714        } else if (is_ab9540(ab8500)) {
2715                debug_ranges = ab8505_debug_ranges;
2716                num_interrupt_lines = AB9540_NR_IRQS;
2717        } else if (is_ab8540(ab8500)) {
2718                debug_ranges = ab8540_debug_ranges;
2719                num_interrupt_lines = AB8540_NR_IRQS;
2720        }
2721
2722        debugfs_create_file("interrupts", (S_IRUGO), ab8500_dir, &plf->dev,
2723                            &ab8500_interrupts_fops);
2724        debugfs_create_file("irq-unsubscribe", (S_IRUGO | S_IWUSR | S_IWGRP),
2725                            ab8500_dir, &plf->dev, &ab8500_unsubscribe_fops);
2726        debugfs_create_file("hwreg", (S_IRUGO | S_IWUSR | S_IWGRP), ab8500_dir,
2727                            &plf->dev, &ab8500_hwreg_fops);
2728        debugfs_create_file("all-modem-registers", (S_IRUGO | S_IWUSR | S_IWGRP),
2729                            ab8500_dir, &plf->dev, &ab8500_modem_fops);
2730        debugfs_create_file("bat_ctrl", (S_IRUGO | S_IWUSR | S_IWGRP),
2731                            ab8500_gpadc_dir, &plf->dev,
2732                            &ab8500_gpadc_bat_ctrl_fops);
2733        debugfs_create_file("btemp_ball", (S_IRUGO | S_IWUSR | S_IWGRP),
2734                            ab8500_gpadc_dir, &plf->dev,
2735                            &ab8500_gpadc_btemp_ball_fops);
2736        debugfs_create_file("main_charger_v", (S_IRUGO | S_IWUSR | S_IWGRP),
2737                            ab8500_gpadc_dir, &plf->dev,
2738                            &ab8500_gpadc_main_charger_v_fops);
2739        debugfs_create_file("acc_detect1", (S_IRUGO | S_IWUSR | S_IWGRP),
2740                            ab8500_gpadc_dir, &plf->dev,
2741                            &ab8500_gpadc_acc_detect1_fops);
2742        debugfs_create_file("acc_detect2", (S_IRUGO | S_IWUSR | S_IWGRP),
2743                            ab8500_gpadc_dir, &plf->dev,
2744                            &ab8500_gpadc_acc_detect2_fops);
2745        debugfs_create_file("adc_aux1", (S_IRUGO | S_IWUSR | S_IWGRP),
2746                            ab8500_gpadc_dir, &plf->dev,
2747                            &ab8500_gpadc_aux1_fops);
2748        debugfs_create_file("adc_aux2", (S_IRUGO | S_IWUSR | S_IWGRP),
2749                            ab8500_gpadc_dir, &plf->dev,
2750                            &ab8500_gpadc_aux2_fops);
2751        debugfs_create_file("main_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
2752                            ab8500_gpadc_dir, &plf->dev,
2753                            &ab8500_gpadc_main_bat_v_fops);
2754        debugfs_create_file("vbus_v", (S_IRUGO | S_IWUSR | S_IWGRP),
2755                            ab8500_gpadc_dir, &plf->dev,
2756                            &ab8500_gpadc_vbus_v_fops);
2757        debugfs_create_file("main_charger_c", (S_IRUGO | S_IWUSR | S_IWGRP),
2758                            ab8500_gpadc_dir, &plf->dev,
2759                            &ab8500_gpadc_main_charger_c_fops);
2760        debugfs_create_file("usb_charger_c", (S_IRUGO | S_IWUSR | S_IWGRP),
2761                            ab8500_gpadc_dir, &plf->dev,
2762                            &ab8500_gpadc_usb_charger_c_fops);
2763        debugfs_create_file("bk_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
2764                            ab8500_gpadc_dir, &plf->dev,
2765                            &ab8500_gpadc_bk_bat_v_fops);
2766        debugfs_create_file("die_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
2767                            ab8500_gpadc_dir, &plf->dev,
2768                            &ab8500_gpadc_die_temp_fops);
2769        debugfs_create_file("usb_id", (S_IRUGO | S_IWUSR | S_IWGRP),
2770                            ab8500_gpadc_dir, &plf->dev,
2771                            &ab8500_gpadc_usb_id_fops);
2772        if (is_ab8540(ab8500)) {
2773                debugfs_create_file("xtal_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
2774                                    ab8500_gpadc_dir, &plf->dev,
2775                                    &ab8540_gpadc_xtal_temp_fops);
2776                debugfs_create_file("vbattruemeas", (S_IRUGO | S_IWUSR | S_IWGRP),
2777                                    ab8500_gpadc_dir, &plf->dev,
2778                                    &ab8540_gpadc_vbat_true_meas_fops);
2779                debugfs_create_file("batctrl_and_ibat", (S_IRUGO | S_IWUGO),
2780                                    ab8500_gpadc_dir, &plf->dev,
2781                                    &ab8540_gpadc_bat_ctrl_and_ibat_fops);
2782                debugfs_create_file("vbatmeas_and_ibat", (S_IRUGO | S_IWUGO),
2783                                    ab8500_gpadc_dir, &plf->dev,
2784                                    &ab8540_gpadc_vbat_meas_and_ibat_fops);
2785                debugfs_create_file("vbattruemeas_and_ibat", (S_IRUGO | S_IWUGO),
2786                                    ab8500_gpadc_dir, &plf->dev,
2787                                    &ab8540_gpadc_vbat_true_meas_and_ibat_fops);
2788                debugfs_create_file("battemp_and_ibat", (S_IRUGO | S_IWUGO),
2789                                    ab8500_gpadc_dir, &plf->dev,
2790                                    &ab8540_gpadc_bat_temp_and_ibat_fops);
2791                debugfs_create_file("otp_calib", (S_IRUGO | S_IWUSR | S_IWGRP),
2792                                    ab8500_gpadc_dir, &plf->dev,
2793                                    &ab8540_gpadc_otp_calib_fops);
2794        }
2795        debugfs_create_file("avg_sample", (S_IRUGO | S_IWUSR | S_IWGRP),
2796                            ab8500_gpadc_dir, &plf->dev,
2797                            &ab8500_gpadc_avg_sample_fops);
2798        debugfs_create_file("trig_edge", (S_IRUGO | S_IWUSR | S_IWGRP),
2799                            ab8500_gpadc_dir, &plf->dev,
2800                            &ab8500_gpadc_trig_edge_fops);
2801        debugfs_create_file("trig_timer", (S_IRUGO | S_IWUSR | S_IWGRP),
2802                            ab8500_gpadc_dir, &plf->dev,
2803                            &ab8500_gpadc_trig_timer_fops);
2804        debugfs_create_file("conv_type", (S_IRUGO | S_IWUSR | S_IWGRP),
2805                            ab8500_gpadc_dir, &plf->dev,
2806                            &ab8500_gpadc_conv_type_fops);
2807
2808        return 0;
2809}
2810
2811static struct platform_driver ab8500_debug_driver = {
2812        .driver = {
2813                .name = "ab8500-debug",
2814                .suppress_bind_attrs = true,
2815        },
2816        .probe  = ab8500_debug_probe,
2817};
2818
2819static int __init ab8500_debug_init(void)
2820{
2821        return platform_driver_register(&ab8500_debug_driver);
2822}
2823subsys_initcall(ab8500_debug_init);
2824