drivers/mfd/ab8500-debugfs.c

   1 /*
   2  * Copyright (C) ST-Ericsson SA 2010
   3  *
   4  * Author: Mattias Wallin <[email protected]> for ST-Ericsson.
   5  * License Terms: GNU General Public License v2
   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/module.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
  94 static u32 debug_bank;
  95 static u32 debug_address;
  96
  97 static int irq_ab8500;
  98 static int irq_first;
  99 static int irq_last;
 100 static u32 *irq_count;
 101 static int num_irqs;
 102
 103 static struct device_attribute **dev_attr;
 104 static char **event_name;
 105
 106 static u8 avg_sample = SAMPLE_16;
 107 static u8 trig_edge = RISING_EDGE;
 108 static u8 conv_type = ADC_SW;
 109 static 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  */
 117 struct 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  */
 129 struct 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 */
 136 struct 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
 147 static 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 24
 157
 158 #define AB8500_REV_REG 0x80
 159
 160 static struct ab8500_prcmu_ranges *debug_ranges;
 161
 162 static struct ab8500_prcmu_ranges ab8500_debug_ranges[AB8500_NUM_BANKS] = {
 163         [0x0] = {
 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                         /* 0x80-0x8B is SIM registers and should
 246                          * not be accessed from here */
 247                 },
 248         },
 249         [AB8500_USB] = {
 250                 .num_ranges = 2,
 251                 .range = (struct ab8500_reg_range[]) {
 252                         {
 253                                 .first = 0x80,
 254                                 .last = 0x83,
 255                         },
 256                         {
 257                                 .first = 0x87,
 258                                 .last = 0x8A,
 259                         },
 260                 },
 261         },
 262         [AB8500_TVOUT] = {
 263                 .num_ranges = 9,
 264                 .range = (struct ab8500_reg_range[]) {
 265                         {
 266                                 .first = 0x00,
 267                                 .last = 0x12,
 268                         },
 269                         {
 270                                 .first = 0x15,
 271                                 .last = 0x17,
 272                         },
 273                         {
 274                                 .first = 0x19,
 275                                 .last = 0x21,
 276                         },
 277                         {
 278                                 .first = 0x27,
 279                                 .last = 0x2C,
 280                         },
 281                         {
 282                                 .first = 0x41,
 283                                 .last = 0x41,
 284                         },
 285                         {
 286                                 .first = 0x45,
 287                                 .last = 0x5B,
 288                         },
 289                         {
 290                                 .first = 0x5D,
 291                                 .last = 0x5D,
 292                         },
 293                         {
 294                                 .first = 0x69,
 295                                 .last = 0x69,
 296                         },
 297                         {
 298                                 .first = 0x80,
 299                                 .last = 0x81,
 300                         },
 301                 },
 302         },
 303         [AB8500_DBI] = {
 304                 .num_ranges = 0,
 305                 .range = NULL,
 306         },
 307         [AB8500_ECI_AV_ACC] = {
 308                 .num_ranges = 1,
 309                 .range = (struct ab8500_reg_range[]) {
 310                         {
 311                                 .first = 0x80,
 312                                 .last = 0x82,
 313                         },
 314                 },
 315         },
 316         [0x9] = {
 317                 .num_ranges = 0,
 318                 .range = NULL,
 319         },
 320         [AB8500_GPADC] = {
 321                 .num_ranges = 1,
 322                 .range = (struct ab8500_reg_range[]) {
 323                         {
 324                                 .first = 0x00,
 325                                 .last = 0x08,
 326                         },
 327                 },
 328         },
 329         [AB8500_CHARGER] = {
 330                 .num_ranges = 9,
 331                 .range = (struct ab8500_reg_range[]) {
 332                         {
 333                                 .first = 0x00,
 334                                 .last = 0x03,
 335                         },
 336                         {
 337                                 .first = 0x05,
 338                                 .last = 0x05,
 339                         },
 340                         {
 341                                 .first = 0x40,
 342                                 .last = 0x40,
 343                         },
 344                         {
 345                                 .first = 0x42,
 346                                 .last = 0x42,
 347                         },
 348                         {
 349                                 .first = 0x44,
 350                                 .last = 0x44,
 351                         },
 352                         {
 353                                 .first = 0x50,
 354                                 .last = 0x55,
 355                         },
 356                         {
 357                                 .first = 0x80,
 358                                 .last = 0x82,
 359                         },
 360                         {
 361                                 .first = 0xC0,
 362                                 .last = 0xC2,
 363                         },
 364                         {
 365                                 .first = 0xf5,
 366                                 .last = 0xf6,
 367                         },
 368                 },
 369         },
 370         [AB8500_GAS_GAUGE] = {
 371                 .num_ranges = 3,
 372                 .range = (struct ab8500_reg_range[]) {
 373                         {
 374                                 .first = 0x00,
 375                                 .last = 0x00,
 376                         },
 377                         {
 378                                 .first = 0x07,
 379                                 .last = 0x0A,
 380                         },
 381                         {
 382                                 .first = 0x10,
 383                                 .last = 0x14,
 384                         },
 385                 },
 386         },
 387         [AB8500_DEVELOPMENT] = {
 388                 .num_ranges = 1,
 389                 .range = (struct ab8500_reg_range[]) {
 390                         {
 391                                 .first = 0x00,
 392                                 .last = 0x00,
 393                         },
 394                 },
 395         },
 396         [AB8500_DEBUG] = {
 397                 .num_ranges = 1,
 398                 .range = (struct ab8500_reg_range[]) {
 399                         {
 400                                 .first = 0x05,
 401                                 .last = 0x07,
 402                         },
 403                 },
 404         },
 405         [AB8500_AUDIO] = {
 406                 .num_ranges = 1,
 407                 .range = (struct ab8500_reg_range[]) {
 408                         {
 409                                 .first = 0x00,
 410                                 .last = 0x6F,
 411                         },
 412                 },
 413         },
 414         [AB8500_INTERRUPT] = {
 415                 .num_ranges = 0,
 416                 .range = NULL,
 417         },
 418         [AB8500_RTC] = {
 419                 .num_ranges = 1,
 420                 .range = (struct ab8500_reg_range[]) {
 421                         {
 422                                 .first = 0x00,
 423                                 .last = 0x0F,
 424                         },
 425                 },
 426         },
 427         [AB8500_MISC] = {
 428                 .num_ranges = 8,
 429                 .range = (struct ab8500_reg_range[]) {
 430                         {
 431                                 .first = 0x00,
 432                                 .last = 0x05,
 433                         },
 434                         {
 435                                 .first = 0x10,
 436                                 .last = 0x15,
 437                         },
 438                         {
 439                                 .first = 0x20,
 440                                 .last = 0x25,
 441                         },
 442                         {
 443                                 .first = 0x30,
 444                                 .last = 0x35,
 445                         },
 446                         {
 447                                 .first = 0x40,
 448                                 .last = 0x45,
 449                         },
 450                         {
 451                                 .first = 0x50,
 452                                 .last = 0x50,
 453                         },
 454                         {
 455                                 .first = 0x60,
 456                                 .last = 0x67,
 457                         },
 458                         {
 459                                 .first = 0x80,
 460                                 .last = 0x80,
 461                         },
 462                 },
 463         },
 464         [0x11] = {
 465                 .num_ranges = 0,
 466                 .range = NULL,
 467         },
 468         [0x12] = {
 469                 .num_ranges = 0,
 470                 .range = NULL,
 471         },
 472         [0x13] = {
 473                 .num_ranges = 0,
 474                 .range = NULL,
 475         },
 476         [0x14] = {
 477                 .num_ranges = 0,
 478                 .range = NULL,
 479         },
 480         [AB8500_OTP_EMUL] = {
 481                 .num_ranges = 1,
 482                 .range = (struct ab8500_reg_range[]) {
 483                         {
 484                                 .first = 0x01,
 485                                 .last = 0x0F,
 486                         },
 487                 },
 488         },
 489 };
 490
 491 static struct ab8500_prcmu_ranges ab8505_debug_ranges[AB8500_NUM_BANKS] = {
 492         [0x0] = {
 493                 .num_ranges = 0,
 494                 .range = NULL,
 495         },
 496         [AB8500_SYS_CTRL1_BLOCK] = {
 497                 .num_ranges = 5,
 498                 .range = (struct ab8500_reg_range[]) {
 499                         {
 500                                 .first = 0x00,
 501                                 .last = 0x04,
 502                         },
 503                         {
 504                                 .first = 0x42,
 505                                 .last = 0x42,
 506                         },
 507                         {
 508                                 .first = 0x52,
 509                                 .last = 0x52,
 510                         },
 511                         {
 512                                 .first = 0x54,
 513                                 .last = 0x57,
 514                         },
 515                         {
 516                                 .first = 0x80,
 517                                 .last = 0x83,
 518                         },
 519                 },
 520         },
 521         [AB8500_SYS_CTRL2_BLOCK] = {
 522                 .num_ranges = 5,
 523                 .range = (struct ab8500_reg_range[]) {
 524                         {
 525                                 .first = 0x00,
 526                                 .last = 0x0D,
 527                         },
 528                         {
 529                                 .first = 0x0F,
 530                                 .last = 0x17,
 531                         },
 532                         {
 533                                 .first = 0x20,
 534                                 .last = 0x20,
 535                         },
 536                         {
 537                                 .first = 0x30,
 538                                 .last = 0x30,
 539                         },
 540                         {
 541                                 .first = 0x32,
 542                                 .last = 0x3A,
 543                         },
 544                 },
 545         },
 546         [AB8500_REGU_CTRL1] = {
 547                 .num_ranges = 3,
 548                 .range = (struct ab8500_reg_range[]) {
 549                         {
 550                                 .first = 0x00,
 551                                 .last = 0x00,
 552                         },
 553                         {
 554                                 .first = 0x03,
 555                                 .last = 0x11,
 556                         },
 557                         {
 558                                 .first = 0x80,
 559                                 .last = 0x86,
 560                         },
 561                 },
 562         },
 563         [AB8500_REGU_CTRL2] = {
 564                 .num_ranges = 6,
 565                 .range = (struct ab8500_reg_range[]) {
 566                         {
 567                                 .first = 0x00,
 568                                 .last = 0x06,
 569                         },
 570                         {
 571                                 .first = 0x08,
 572                                 .last = 0x15,
 573                         },
 574                         {
 575                                 .first = 0x17,
 576                                 .last = 0x19,
 577                         },
 578                         {
 579                                 .first = 0x1B,
 580                                 .last = 0x1D,
 581                         },
 582                         {
 583                                 .first = 0x1F,
 584                                 .last = 0x30,
 585                         },
 586                         {
 587                                 .first = 0x40,
 588                                 .last = 0x48,
 589                         },
 590                         /* 0x80-0x8B is SIM registers and should
 591                          * not be accessed from here */
 592                 },
 593         },
 594         [AB8500_USB] = {
 595                 .num_ranges = 3,
 596                 .range = (struct ab8500_reg_range[]) {
 597                         {
 598                                 .first = 0x80,
 599                                 .last = 0x83,
 600                         },
 601                         {
 602                                 .first = 0x87,
 603                                 .last = 0x8A,
 604                         },
 605                         {
 606                                 .first = 0x91,
 607                                 .last = 0x94,
 608                         },
 609                 },
 610         },
 611         [AB8500_TVOUT] = {
 612                 .num_ranges = 0,
 613                 .range = NULL,
 614         },
 615         [AB8500_DBI] = {
 616                 .num_ranges = 0,
 617                 .range = NULL,
 618         },
 619         [AB8500_ECI_AV_ACC] = {
 620                 .num_ranges = 1,
 621                 .range = (struct ab8500_reg_range[]) {
 622                         {
 623                                 .first = 0x80,
 624                                 .last = 0x82,
 625                         },
 626                 },
 627         },
 628         [AB8500_RESERVED] = {
 629                 .num_ranges = 0,
 630                 .range = NULL,
 631         },
 632         [AB8500_GPADC] = {
 633                 .num_ranges = 1,
 634                 .range = (struct ab8500_reg_range[]) {
 635                         {
 636                                 .first = 0x00,
 637                                 .last = 0x08,
 638                         },
 639                 },
 640         },
 641         [AB8500_CHARGER] = {
 642                 .num_ranges = 9,
 643                 .range = (struct ab8500_reg_range[]) {
 644                         {
 645                                 .first = 0x02,
 646                                 .last = 0x03,
 647                         },
 648                         {
 649                                 .first = 0x05,
 650                                 .last = 0x05,
 651                         },
 652                         {
 653                                 .first = 0x40,
 654                                 .last = 0x44,
 655                         },
 656                         {
 657                                 .first = 0x50,
 658                                 .last = 0x57,
 659                         },
 660                         {
 661                                 .first = 0x60,
 662                                 .last = 0x60,
 663                         },
 664                         {
 665                                 .first = 0xA0,
 666                                 .last = 0xA7,
 667                         },
 668                         {
 669                                 .first = 0xAF,
 670                                 .last = 0xB2,
 671                         },
 672                         {
 673                                 .first = 0xC0,
 674                                 .last = 0xC2,
 675                         },
 676                         {
 677                                 .first = 0xF5,
 678                                 .last = 0xF5,
 679                         },
 680                 },
 681         },
 682         [AB8500_GAS_GAUGE] = {
 683                 .num_ranges = 3,
 684                 .range = (struct ab8500_reg_range[]) {
 685                         {
 686                                 .first = 0x00,
 687                                 .last = 0x00,
 688                         },
 689                         {
 690                                 .first = 0x07,
 691                                 .last = 0x0A,
 692                         },
 693                         {
 694                                 .first = 0x10,
 695                                 .last = 0x14,
 696                         },
 697                 },
 698         },
 699         [AB8500_AUDIO] = {
 700                 .num_ranges = 1,
 701                 .range = (struct ab8500_reg_range[]) {
 702                         {
 703                                 .first = 0x00,
 704                                 .last = 0x83,
 705                         },
 706                 },
 707         },
 708         [AB8500_INTERRUPT] = {
 709                 .num_ranges = 11,
 710                 .range = (struct ab8500_reg_range[]) {
 711                         {
 712                                 .first = 0x00,
 713                                 .last = 0x04,
 714                         },
 715                         {
 716                                 .first = 0x06,
 717                                 .last = 0x07,
 718                         },
 719                         {
 720                                 .first = 0x09,
 721                                 .last = 0x09,
 722                         },
 723                         {
 724                                 .first = 0x0B,
 725                                 .last = 0x0C,
 726                         },
 727                         {
 728                                 .first = 0x12,
 729                                 .last = 0x15,
 730                         },
 731                         {
 732                                 .first = 0x18,
 733                                 .last = 0x18,
 734                         },
 735                         /* Latch registers should not be read here */
 736                         {
 737                                 .first = 0x40,
 738                                 .last = 0x44,
 739                         },
 740                         {
 741                                 .first = 0x46,
 742                                 .last = 0x49,
 743                         },
 744                         {
 745                                 .first = 0x4B,
 746                                 .last = 0x4D,
 747                         },
 748                         {
 749                                 .first = 0x52,
 750                                 .last = 0x55,
 751                         },
 752                         {
 753                                 .first = 0x58,
 754                                 .last = 0x58,
 755                         },
 756                         /* LatchHier registers should not be read here */
 757                 },
 758         },
 759         [AB8500_RTC] = {
 760                 .num_ranges = 2,
 761                 .range = (struct ab8500_reg_range[]) {
 762                         {
 763                                 .first = 0x00,
 764                                 .last = 0x14,
 765                         },
 766                         {
 767                                 .first = 0x16,
 768                                 .last = 0x17,
 769                         },
 770                 },
 771         },
 772         [AB8500_MISC] = {
 773                 .num_ranges = 8,
 774                 .range = (struct ab8500_reg_range[]) {
 775                         {
 776                                 .first = 0x00,
 777                                 .last = 0x06,
 778                         },
 779                         {
 780                                 .first = 0x10,
 781                                 .last = 0x16,
 782                         },
 783                         {
 784                                 .first = 0x20,
 785                                 .last = 0x26,
 786                         },
 787                         {
 788                                 .first = 0x30,
 789                                 .last = 0x36,
 790                         },
 791                         {
 792                                 .first = 0x40,
 793                                 .last = 0x46,
 794                         },
 795                         {
 796                                 .first = 0x50,
 797                                 .last = 0x50,
 798                         },
 799                         {
 800                                 .first = 0x60,
 801                                 .last = 0x6B,
 802                         },
 803                         {
 804                                 .first = 0x80,
 805                                 .last = 0x82,
 806                         },
 807                 },
 808         },
 809         [AB8500_DEVELOPMENT] = {
 810                 .num_ranges = 2,
 811                 .range = (struct ab8500_reg_range[]) {
 812                         {
 813                                 .first = 0x00,
 814                                 .last = 0x00,
 815                         },
 816                         {
 817                                 .first = 0x05,
 818                                 .last = 0x05,
 819                         },
 820                 },
 821         },
 822         [AB8500_DEBUG] = {
 823                 .num_ranges = 1,
 824                 .range = (struct ab8500_reg_range[]) {
 825                         {
 826                                 .first = 0x05,
 827                                 .last = 0x07,
 828                         },
 829                 },
 830         },
 831         [AB8500_PROD_TEST] = {
 832                 .num_ranges = 0,
 833                 .range = NULL,
 834         },
 835         [AB8500_STE_TEST] = {
 836                 .num_ranges = 0,
 837                 .range = NULL,
 838         },
 839         [AB8500_OTP_EMUL] = {
 840                 .num_ranges = 1,
 841                 .range = (struct ab8500_reg_range[]) {
 842                         {
 843                                 .first = 0x01,
 844                                 .last = 0x15,
 845                         },
 846                 },
 847         },
 848 };
 849
 850 static struct ab8500_prcmu_ranges ab8540_debug_ranges[AB8500_NUM_BANKS] = {
 851         [AB8500_M_FSM_RANK] = {
 852                 .num_ranges = 1,
 853                 .range = (struct ab8500_reg_range[]) {
 854                         {
 855                                 .first = 0x00,
 856                                 .last = 0x0B,
 857                         },
 858                 },
 859         },
 860         [AB8500_SYS_CTRL1_BLOCK] = {
 861                 .num_ranges = 6,
 862                 .range = (struct ab8500_reg_range[]) {
 863                         {
 864                                 .first = 0x00,
 865                                 .last = 0x04,
 866                         },
 867                         {
 868                                 .first = 0x42,
 869                                 .last = 0x42,
 870                         },
 871                         {
 872                                 .first = 0x50,
 873                                 .last = 0x54,
 874                         },
 875                         {
 876                                 .first = 0x57,
 877                                 .last = 0x57,
 878                         },
 879                         {
 880                                 .first = 0x80,
 881                                 .last = 0x83,
 882                         },
 883                         {
 884                                 .first = 0x90,
 885                                 .last = 0x90,
 886                         },
 887                 },
 888         },
 889         [AB8500_SYS_CTRL2_BLOCK] = {
 890                 .num_ranges = 5,
 891                 .range = (struct ab8500_reg_range[]) {
 892                         {
 893                                 .first = 0x00,
 894                                 .last = 0x0D,
 895                         },
 896                         {
 897                                 .first = 0x0F,
 898                                 .last = 0x10,
 899                         },
 900                         {
 901                                 .first = 0x20,
 902                                 .last = 0x21,
 903                         },
 904                         {
 905                                 .first = 0x32,
 906                                 .last = 0x3C,
 907                         },
 908                         {
 909                                 .first = 0x40,
 910                                 .last = 0x42,
 911                         },
 912                 },
 913         },
 914         [AB8500_REGU_CTRL1] = {
 915                 .num_ranges = 4,
 916                 .range = (struct ab8500_reg_range[]) {
 917                         {
 918                                 .first = 0x03,
 919                                 .last = 0x15,
 920                         },
 921                         {
 922                                 .first = 0x20,
 923                                 .last = 0x20,
 924                         },
 925                         {
 926                                 .first = 0x80,
 927                                 .last = 0x85,
 928                         },
 929                         {
 930                                 .first = 0x87,
 931                                 .last = 0x88,
 932                         },
 933                 },
 934         },
 935         [AB8500_REGU_CTRL2] = {
 936                 .num_ranges = 8,
 937                 .range = (struct ab8500_reg_range[]) {
 938                         {
 939                                 .first = 0x00,
 940                                 .last = 0x06,
 941                         },
 942                         {
 943                                 .first = 0x08,
 944                                 .last = 0x15,
 945                         },
 946                         {
 947                                 .first = 0x17,
 948                                 .last = 0x19,
 949                         },
 950                         {
 951                                 .first = 0x1B,
 952                                 .last = 0x1D,
 953                         },
 954                         {
 955                                 .first = 0x1F,
 956                                 .last = 0x2F,
 957                         },
 958                         {
 959                                 .first = 0x31,
 960                                 .last = 0x3A,
 961                         },
 962                         {
 963                                 .first = 0x43,
 964                                 .last = 0x44,
 965                         },
 966                         {
 967                                 .first = 0x48,
 968                                 .last = 0x49,
 969                         },
 970                 },
 971         },
 972         [AB8500_USB] = {
 973                 .num_ranges = 3,
 974                 .range = (struct ab8500_reg_range[]) {
 975                         {
 976                                 .first = 0x80,
 977                                 .last = 0x83,
 978                         },
 979                         {
 980                                 .first = 0x87,
 981                                 .last = 0x8A,
 982                         },
 983                         {
 984                                 .first = 0x91,
 985                                 .last = 0x94,
 986                         },
 987                 },
 988         },
 989         [AB8500_TVOUT] = {
 990                 .num_ranges = 0,
 991                 .range = NULL
 992         },
 993         [AB8500_DBI] = {
 994                 .num_ranges = 4,
 995                 .range = (struct ab8500_reg_range[]) {
 996                         {
 997                                 .first = 0x00,
 998                                 .last = 0x07,
 999                         },
1000                         {
1001                                 .first = 0x10,
1002                                 .last = 0x11,
1003                         },
1004                         {
1005                                 .first = 0x20,
1006                                 .last = 0x21,
1007                         },
1008                         {
1009                                 .first = 0x30,
1010                                 .last = 0x43,
1011                         },
1012                 },
1013         },
1014         [AB8500_ECI_AV_ACC] = {
1015                 .num_ranges = 2,
1016                 .range = (struct ab8500_reg_range[]) {
1017                         {
1018                                 .first = 0x00,
1019                                 .last = 0x03,
1020                         },
1021                         {
1022                                 .first = 0x80,
1023                                 .last = 0x82,
1024                         },
1025                 },
1026         },
1027         [AB8500_RESERVED] = {
1028                 .num_ranges = 0,
1029                 .range = NULL,
1030         },
1031         [AB8500_GPADC] = {
1032                 .num_ranges = 4,
1033                 .range = (struct ab8500_reg_range[]) {
1034                         {
1035                                 .first = 0x00,
1036                                 .last = 0x01,
1037                         },
1038                         {
1039                                 .first = 0x04,
1040                                 .last = 0x06,
1041                         },
1042                         {
1043                                 .first = 0x09,
1044                                 .last = 0x0A,
1045                         },
1046                         {
1047                                 .first = 0x10,
1048                                 .last = 0x14,
1049                         },
1050                 },
1051         },
1052         [AB8500_CHARGER] = {
1053                 .num_ranges = 10,
1054                 .range = (struct ab8500_reg_range[]) {
1055                         {
1056                                 .first = 0x00,
1057                                 .last = 0x00,
1058                         },
1059                         {
1060                                 .first = 0x02,
1061                                 .last = 0x05,
1062                         },
1063                         {
1064                                 .first = 0x40,
1065                                 .last = 0x44,
1066                         },
1067                         {
1068                                 .first = 0x50,
1069                                 .last = 0x57,
1070                         },
1071                         {
1072                                 .first = 0x60,
1073                                 .last = 0x60,
1074                         },
1075                         {
1076                                 .first = 0x70,
1077                                 .last = 0x70,
1078                         },
1079                         {
1080                                 .first = 0xA0,
1081                                 .last = 0xA9,
1082                         },
1083                         {
1084                                 .first = 0xAF,
1085                                 .last = 0xB2,
1086                         },
1087                         {
1088                                 .first = 0xC0,
1089                                 .last = 0xC6,
1090                         },
1091                         {
1092                                 .first = 0xF5,
1093                                 .last = 0xF5,
1094                         },
1095                 },
1096         },
1097         [AB8500_GAS_GAUGE] = {
1098                 .num_ranges = 3,
1099                 .range = (struct ab8500_reg_range[]) {
1100                         {
1101                                 .first = 0x00,
1102                                 .last = 0x00,
1103                         },
1104                         {
1105                                 .first = 0x07,
1106                                 .last = 0x0A,
1107                         },
1108                         {
1109                                 .first = 0x10,
1110                                 .last = 0x14,
1111                         },
1112                 },
1113         },
1114         [AB8500_AUDIO] = {
1115                 .num_ranges = 1,
1116                 .range = (struct ab8500_reg_range[]) {
1117                         {
1118                                 .first = 0x00,
1119                                 .last = 0x9f,
1120                         },
1121                 },
1122         },
1123         [AB8500_INTERRUPT] = {
1124                 .num_ranges = 6,
1125                 .range = (struct ab8500_reg_range[]) {
1126                         {
1127                                 .first = 0x00,
1128                                 .last = 0x05,
1129                         },
1130                         {
1131                                 .first = 0x0B,
1132                                 .last = 0x0D,
1133                         },
1134                         {
1135                                 .first = 0x12,
1136                                 .last = 0x20,
1137                         },
1138                         /* Latch registers should not be read here */
1139                         {
1140                                 .first = 0x40,
1141                                 .last = 0x45,
1142                         },
1143                         {
1144                                 .first = 0x4B,
1145                                 .last = 0x4D,
1146                         },
1147                         {
1148                                 .first = 0x52,
1149                                 .last = 0x60,
1150                         },
1151                         /* LatchHier registers should not be read here */
1152                 },
1153         },
1154         [AB8500_RTC] = {
1155                 .num_ranges = 3,
1156                 .range = (struct ab8500_reg_range[]) {
1157                         {
1158                                 .first = 0x00,
1159                                 .last = 0x07,
1160                         },
1161                         {
1162                                 .first = 0x0B,
1163                                 .last = 0x18,
1164                         },
1165                         {
1166                                 .first = 0x20,
1167                                 .last = 0x25,
1168                         },
1169                 },
1170         },
1171         [AB8500_MISC] = {
1172                 .num_ranges = 9,
1173                 .range = (struct ab8500_reg_range[]) {
1174                         {
1175                                 .first = 0x00,
1176                                 .last = 0x06,
1177                         },
1178                         {
1179                                 .first = 0x10,
1180                                 .last = 0x16,
1181                         },
1182                         {
1183                                 .first = 0x20,
1184                                 .last = 0x26,
1185                         },
1186                         {
1187                                 .first = 0x30,
1188                                 .last = 0x36,
1189                         },
1190                         {
1191                                 .first = 0x40,
1192                                 .last = 0x49,
1193                         },
1194                         {
1195                                 .first = 0x50,
1196                                 .last = 0x50,
1197                         },
1198                         {
1199                                 .first = 0x60,
1200                                 .last = 0x6B,
1201                         },
1202                         {
1203                                 .first = 0x70,
1204                                 .last = 0x74,
1205                         },
1206                         {
1207                                 .first = 0x80,
1208                                 .last = 0x82,
1209                         },
1210                 },
1211         },
1212         [AB8500_DEVELOPMENT] = {
1213                 .num_ranges = 3,
1214                 .range = (struct ab8500_reg_range[]) {
1215                         {
1216                                 .first = 0x00,
1217                                 .last = 0x01,
1218                         },
1219                         {
1220                                 .first = 0x06,
1221                                 .last = 0x06,
1222                         },
1223                         {
1224                                 .first = 0x10,
1225                                 .last = 0x21,
1226                         },
1227                 },
1228         },
1229         [AB8500_DEBUG] = {
1230                 .num_ranges = 3,
1231                 .range = (struct ab8500_reg_range[]) {
1232                         {
1233                                 .first = 0x01,
1234                                 .last = 0x0C,
1235                         },
1236                         {
1237                                 .first = 0x0E,
1238                                 .last = 0x11,
1239                         },
1240                         {
1241                                 .first = 0x80,
1242                                 .last = 0x81,
1243                         },
1244                 },
1245         },
1246         [AB8500_PROD_TEST] = {
1247                 .num_ranges = 0,
1248                 .range = NULL,
1249         },
1250         [AB8500_STE_TEST] = {
1251                 .num_ranges = 0,
1252                 .range = NULL,
1253         },
1254         [AB8500_OTP_EMUL] = {
1255                 .num_ranges = 1,
1256                 .range = (struct ab8500_reg_range[]) {
1257                         {
1258                                 .first = 0x00,
1259                                 .last = 0x3F,
1260                         },
1261                 },
1262         },
1263 };
1264
1265
1266 static irqreturn_t ab8500_debug_handler(int irq, void *data)
1267 {
1268         char buf[16];
1269         struct kobject *kobj = (struct kobject *)data;
1270         unsigned int irq_abb = irq - irq_first;
1271
1272         if (irq_abb < num_irqs)
1273                 irq_count[irq_abb]++;
1274         /*
1275          * This makes it possible to use poll for events (POLLPRI | POLLERR)
1276          * from userspace on sysfs file named <irq-nr>
1277          */
1278         sprintf(buf, "%d", irq);
1279         sysfs_notify(kobj, NULL, buf);
1280
1281         return IRQ_HANDLED;
1282 }
1283
1284 /* Prints to seq_file or log_buf */
1285 static int ab8500_registers_print(struct device *dev, u32 bank,
1286                                   struct seq_file *s)
1287 {
1288         unsigned int i;
1289
1290         for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
1291                 u32 reg;
1292
1293                 for (reg = debug_ranges[bank].range[i].first;
1294                         reg <= debug_ranges[bank].range[i].last;
1295                         reg++) {
1296                         u8 value;
1297                         int err;
1298
1299                         err = abx500_get_register_interruptible(dev,
1300                                 (u8)bank, (u8)reg, &value);
1301                         if (err < 0) {
1302                                 dev_err(dev, "ab->read fail %d\n", err);
1303                                 return err;
1304                         }
1305
1306                         if (s) {
1307                                 seq_printf(s, "  [0x%02X/0x%02X]: 0x%02X\n",
1308                                            bank, reg, value);
1309                                 /* Error is not returned here since
1310                                  * the output is wanted in any case */
1311                                 if (seq_has_overflowed(s))
1312                                         return 0;
1313                         } else {
1314                                 dev_info(dev, " [0x%02X/0x%02X]: 0x%02X\n",
1315                                          bank, reg, value);
1316                         }
1317                 }
1318         }
1319
1320         return 0;
1321 }
1322
1323 static int ab8500_print_bank_registers(struct seq_file *s, void *p)
1324 {
1325         struct device *dev = s->private;
1326         u32 bank = debug_bank;
1327
1328         seq_puts(s, AB8500_NAME_STRING " register values:\n");
1329
1330         seq_printf(s, " bank 0x%02X:\n", bank);
1331
1332         return ab8500_registers_print(dev, bank, s);
1333 }
1334
1335 static int ab8500_registers_open(struct inode *inode, struct file *file)
1336 {
1337         return single_open(file, ab8500_print_bank_registers, inode->i_private);
1338 }
1339
1340 static const struct file_operations ab8500_registers_fops = {
1341         .open = ab8500_registers_open,
1342         .read = seq_read,
1343         .llseek = seq_lseek,
1344         .release = single_release,
1345         .owner = THIS_MODULE,
1346 };
1347
1348 static int ab8500_print_all_banks(struct seq_file *s, void *p)
1349 {
1350         struct device *dev = s->private;
1351         unsigned int i;
1352
1353         seq_puts(s, AB8500_NAME_STRING " register values:\n");
1354
1355         for (i = 0; i < AB8500_NUM_BANKS; i++) {
1356                 int err;
1357
1358                 seq_printf(s, " bank 0x%02X:\n", i);
1359                 err = ab8500_registers_print(dev, i, s);
1360                 if (err)
1361                         return err;
1362         }
1363         return 0;
1364 }
1365
1366 /* Dump registers to kernel log */
1367 void ab8500_dump_all_banks(struct device *dev)
1368 {
1369         unsigned int i;
1370
1371         dev_info(dev, "ab8500 register values:\n");
1372
1373         for (i = 1; i < AB8500_NUM_BANKS; i++) {
1374                 dev_info(dev, " bank 0x%02X:\n", i);
1375                 ab8500_registers_print(dev, i, NULL);
1376         }
1377 }
1378
1379 /* Space for 500 registers. */
1380 #define DUMP_MAX_REGS 700
1381 static struct ab8500_register_dump
1382 {
1383         u8 bank;
1384         u8 reg;
1385         u8 value;
1386 } ab8500_complete_register_dump[DUMP_MAX_REGS];
1387
1388 /* This shall only be called upon kernel panic! */
1389 void ab8500_dump_all_banks_to_mem(void)
1390 {
1391         int i, r = 0;
1392         u8 bank;
1393         int err = 0;
1394
1395         pr_info("Saving all ABB registers for crash analysis.\n");
1396
1397         for (bank = 0; bank < AB8500_NUM_BANKS; bank++) {
1398                 for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
1399                         u8 reg;
1400
1401                         for (reg = debug_ranges[bank].range[i].first;
1402                              reg <= debug_ranges[bank].range[i].last;
1403                              reg++) {
1404                                 u8 value;
1405
1406                                 err = prcmu_abb_read(bank, reg, &value, 1);
1407
1408                                 if (err < 0)
1409                                         goto out;
1410
1411                                 ab8500_complete_register_dump[r].bank = bank;
1412                                 ab8500_complete_register_dump[r].reg = reg;
1413                                 ab8500_complete_register_dump[r].value = value;
1414
1415                                 r++;
1416
1417                                 if (r >= DUMP_MAX_REGS) {
1418                                         pr_err("%s: too many register to dump!\n",
1419                                                 __func__);
1420                                         err = -EINVAL;
1421                                         goto out;
1422                                 }
1423                         }
1424                 }
1425         }
1426 out:
1427         if (err >= 0)
1428                 pr_info("Saved all ABB registers.\n");
1429         else
1430                 pr_info("Failed to save all ABB registers.\n");
1431 }
1432
1433 static int ab8500_all_banks_open(struct inode *inode, struct file *file)
1434 {
1435         struct seq_file *s;
1436         int err;
1437
1438         err = single_open(file, ab8500_print_all_banks, inode->i_private);
1439         if (!err) {
1440                 /* Default buf size in seq_read is not enough */
1441                 s = (struct seq_file *)file->private_data;
1442                 s->size = (PAGE_SIZE * 2);
1443                 s->buf = kmalloc(s->size, GFP_KERNEL);
1444                 if (!s->buf) {
1445                         single_release(inode, file);
1446                         err = -ENOMEM;
1447                 }
1448         }
1449         return err;
1450 }
1451
1452 static const struct file_operations ab8500_all_banks_fops = {
1453         .open = ab8500_all_banks_open,
1454         .read = seq_read,
1455         .llseek = seq_lseek,
1456         .release = single_release,
1457         .owner = THIS_MODULE,
1458 };
1459
1460 static int ab8500_bank_print(struct seq_file *s, void *p)
1461 {
1462         seq_printf(s, "0x%02X\n", debug_bank);
1463         return 0;
1464 }
1465
1466 static int ab8500_bank_open(struct inode *inode, struct file *file)
1467 {
1468         return single_open(file, ab8500_bank_print, inode->i_private);
1469 }
1470
1471 static ssize_t ab8500_bank_write(struct file *file,
1472         const char __user *user_buf,
1473         size_t count, loff_t *ppos)
1474 {
1475         struct device *dev = ((struct seq_file *)(file->private_data))->private;
1476         unsigned long user_bank;
1477         int err;
1478
1479         err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
1480         if (err)
1481                 return err;
1482
1483         if (user_bank >= AB8500_NUM_BANKS) {
1484                 dev_err(dev, "debugfs error input > number of banks\n");
1485                 return -EINVAL;
1486         }
1487
1488         debug_bank = user_bank;
1489
1490         return count;
1491 }
1492
1493 static int ab8500_address_print(struct seq_file *s, void *p)
1494 {
1495         seq_printf(s, "0x%02X\n", debug_address);
1496         return 0;
1497 }
1498
1499 static int ab8500_address_open(struct inode *inode, struct file *file)
1500 {
1501         return single_open(file, ab8500_address_print, inode->i_private);
1502 }
1503
1504 static ssize_t ab8500_address_write(struct file *file,
1505                                     const char __user *user_buf,
1506                                     size_t count, loff_t *ppos)
1507 {
1508         struct device *dev = ((struct seq_file *)(file->private_data))->private;
1509         unsigned long user_address;
1510         int err;
1511
1512         err = kstrtoul_from_user(user_buf, count, 0, &user_address);
1513         if (err)
1514                 return err;
1515
1516         if (user_address > 0xff) {
1517                 dev_err(dev, "debugfs error input > 0xff\n");
1518                 return -EINVAL;
1519         }
1520         debug_address = user_address;
1521
1522         return count;
1523 }
1524
1525 static int ab8500_val_print(struct seq_file *s, void *p)
1526 {
1527         struct device *dev = s->private;
1528         int ret;
1529         u8 regvalue;
1530
1531         ret = abx500_get_register_interruptible(dev,
1532                 (u8)debug_bank, (u8)debug_address, &regvalue);
1533         if (ret < 0) {
1534                 dev_err(dev, "abx500_get_reg fail %d, %d\n",
1535                         ret, __LINE__);
1536                 return -EINVAL;
1537         }
1538         seq_printf(s, "0x%02X\n", regvalue);
1539
1540         return 0;
1541 }
1542
1543 static int ab8500_val_open(struct inode *inode, struct file *file)
1544 {
1545         return single_open(file, ab8500_val_print, inode->i_private);
1546 }
1547
1548 static ssize_t ab8500_val_write(struct file *file,
1549                                 const char __user *user_buf,
1550                                 size_t count, loff_t *ppos)
1551 {
1552         struct device *dev = ((struct seq_file *)(file->private_data))->private;
1553         unsigned long user_val;
1554         int err;
1555
1556         err = kstrtoul_from_user(user_buf, count, 0, &user_val);
1557         if (err)
1558                 return err;
1559
1560         if (user_val > 0xff) {
1561                 dev_err(dev, "debugfs error input > 0xff\n");
1562                 return -EINVAL;
1563         }
1564         err = abx500_set_register_interruptible(dev,
1565                 (u8)debug_bank, debug_address, (u8)user_val);
1566         if (err < 0) {
1567                 pr_err("abx500_set_reg failed %d, %d", err, __LINE__);
1568                 return -EINVAL;
1569         }
1570
1571         return count;
1572 }
1573
1574 /*
1575  * Interrupt status
1576  */
1577 static u32 num_interrupts[AB8500_MAX_NR_IRQS];
1578 static u32 num_wake_interrupts[AB8500_MAX_NR_IRQS];
1579 static int num_interrupt_lines;
1580
1581 bool __attribute__((weak)) suspend_test_wake_cause_interrupt_is_mine(u32 my_int)
1582 {
1583         return false;
1584 }
1585
1586 void ab8500_debug_register_interrupt(int line)
1587 {
1588         if (line < num_interrupt_lines) {
1589                 num_interrupts[line]++;
1590                 if (suspend_test_wake_cause_interrupt_is_mine(irq_ab8500))
1591                         num_wake_interrupts[line]++;
1592         }
1593 }
1594
1595 static int ab8500_interrupts_print(struct seq_file *s, void *p)
1596 {
1597         int line;
1598
1599         seq_puts(s, "name: number:  number of: wake:\n");
1600
1601         for (line = 0; line < num_interrupt_lines; line++) {
1602                 struct irq_desc *desc = irq_to_desc(line + irq_first);
1603
1604                 seq_printf(s, "%3i:  %6i %4i",
1605                            line,
1606                            num_interrupts[line],
1607                            num_wake_interrupts[line]);
1608
1609                 if (desc && desc->name)
1610                         seq_printf(s, "-%-8s", desc->name);
1611                 if (desc && desc->action) {
1612                         struct irqaction *action = desc->action;
1613
1614                         seq_printf(s, "  %s", action->name);
1615                         while ((action = action->next) != NULL)
1616                                 seq_printf(s, ", %s", action->name);
1617                 }
1618                 seq_putc(s, '\n');
1619         }
1620
1621         return 0;
1622 }
1623
1624 static int ab8500_interrupts_open(struct inode *inode, struct file *file)
1625 {
1626         return single_open(file, ab8500_interrupts_print, inode->i_private);
1627 }
1628
1629 /*
1630  * - HWREG DB8500 formated routines
1631  */
1632 static int ab8500_hwreg_print(struct seq_file *s, void *d)
1633 {
1634         struct device *dev = s->private;
1635         int ret;
1636         u8 regvalue;
1637
1638         ret = abx500_get_register_interruptible(dev,
1639                 (u8)hwreg_cfg.bank, (u8)hwreg_cfg.addr, &regvalue);
1640         if (ret < 0) {
1641                 dev_err(dev, "abx500_get_reg fail %d, %d\n",
1642                         ret, __LINE__);
1643                 return -EINVAL;
1644         }
1645
1646         if (hwreg_cfg.shift >= 0)
1647                 regvalue >>= hwreg_cfg.shift;
1648         else
1649                 regvalue <<= -hwreg_cfg.shift;
1650         regvalue &= hwreg_cfg.mask;
1651
1652         if (REG_FMT_DEC(&hwreg_cfg))
1653                 seq_printf(s, "%d\n", regvalue);
1654         else
1655                 seq_printf(s, "0x%02X\n", regvalue);
1656         return 0;
1657 }
1658
1659 static int ab8500_hwreg_open(struct inode *inode, struct file *file)
1660 {
1661         return single_open(file, ab8500_hwreg_print, inode->i_private);
1662 }
1663
1664 #define AB8500_SUPPLY_CONTROL_CONFIG_1 0x01
1665 #define AB8500_SUPPLY_CONTROL_REG 0x00
1666 #define AB8500_FIRST_SIM_REG 0x80
1667 #define AB8500_LAST_SIM_REG 0x8B
1668 #define AB8505_LAST_SIM_REG 0x8C
1669
1670 static int ab8500_print_modem_registers(struct seq_file *s, void *p)
1671 {
1672         struct device *dev = s->private;
1673         struct ab8500 *ab8500;
1674         int err;
1675         u8 value;
1676         u8 orig_value;
1677         u32 bank = AB8500_REGU_CTRL2;
1678         u32 last_sim_reg = AB8500_LAST_SIM_REG;
1679         u32 reg;
1680
1681         ab8500 = dev_get_drvdata(dev->parent);
1682         dev_warn(dev, "WARNING! This operation can interfer with modem side\n"
1683                 "and should only be done with care\n");
1684
1685         err = abx500_get_register_interruptible(dev,
1686                 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, &orig_value);
1687         if (err < 0) {
1688                 dev_err(dev, "ab->read fail %d\n", err);
1689                 return err;
1690         }
1691         /* Config 1 will allow APE side to read SIM registers */
1692         err = abx500_set_register_interruptible(dev,
1693                 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG,
1694                 AB8500_SUPPLY_CONTROL_CONFIG_1);
1695         if (err < 0) {
1696                 dev_err(dev, "ab->write fail %d\n", err);
1697                 return err;
1698         }
1699
1700         seq_printf(s, " bank 0x%02X:\n", bank);
1701
1702         if (is_ab9540(ab8500) || is_ab8505(ab8500))
1703                 last_sim_reg = AB8505_LAST_SIM_REG;
1704
1705         for (reg = AB8500_FIRST_SIM_REG; reg <= last_sim_reg; reg++) {
1706                 err = abx500_get_register_interruptible(dev,
1707                         bank, reg, &value);
1708                 if (err < 0) {
1709                         dev_err(dev, "ab->read fail %d\n", err);
1710                         return err;
1711                 }
1712                 seq_printf(s, "  [0x%02X/0x%02X]: 0x%02X\n", bank, reg, value);
1713         }
1714         err = abx500_set_register_interruptible(dev,
1715                 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, orig_value);
1716         if (err < 0) {
1717                 dev_err(dev, "ab->write fail %d\n", err);
1718                 return err;
1719         }
1720         return 0;
1721 }
1722
1723 static int ab8500_modem_open(struct inode *inode, struct file *file)
1724 {
1725         return single_open(file, ab8500_print_modem_registers,
1726                            inode->i_private);
1727 }
1728
1729 static const struct file_operations ab8500_modem_fops = {
1730         .open = ab8500_modem_open,
1731         .read = seq_read,
1732         .llseek = seq_lseek,
1733         .release = single_release,
1734         .owner = THIS_MODULE,
1735 };
1736
1737 static int ab8500_gpadc_bat_ctrl_print(struct seq_file *s, void *p)
1738 {
1739         int bat_ctrl_raw;
1740         int bat_ctrl_convert;
1741         struct ab8500_gpadc *gpadc;
1742
1743         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1744         bat_ctrl_raw = ab8500_gpadc_read_raw(gpadc, BAT_CTRL,
1745                 avg_sample, trig_edge, trig_timer, conv_type);
1746         bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1747                 BAT_CTRL, bat_ctrl_raw);
1748
1749         seq_printf(s, "%d,0x%X\n", bat_ctrl_convert, bat_ctrl_raw);
1750
1751         return 0;
1752 }
1753
1754 static int ab8500_gpadc_bat_ctrl_open(struct inode *inode, struct file *file)
1755 {
1756         return single_open(file, ab8500_gpadc_bat_ctrl_print,
1757                            inode->i_private);
1758 }
1759
1760 static const struct file_operations ab8500_gpadc_bat_ctrl_fops = {
1761         .open = ab8500_gpadc_bat_ctrl_open,
1762         .read = seq_read,
1763         .llseek = seq_lseek,
1764         .release = single_release,
1765         .owner = THIS_MODULE,
1766 };
1767
1768 static int ab8500_gpadc_btemp_ball_print(struct seq_file *s, void *p)
1769 {
1770         int btemp_ball_raw;
1771         int btemp_ball_convert;
1772         struct ab8500_gpadc *gpadc;
1773
1774         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1775         btemp_ball_raw = ab8500_gpadc_read_raw(gpadc, BTEMP_BALL,
1776                 avg_sample, trig_edge, trig_timer, conv_type);
1777         btemp_ball_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
1778                 btemp_ball_raw);
1779
1780         seq_printf(s, "%d,0x%X\n", btemp_ball_convert, btemp_ball_raw);
1781
1782         return 0;
1783 }
1784
1785 static int ab8500_gpadc_btemp_ball_open(struct inode *inode,
1786                                         struct file *file)
1787 {
1788         return single_open(file, ab8500_gpadc_btemp_ball_print,
1789                            inode->i_private);
1790 }
1791
1792 static const struct file_operations ab8500_gpadc_btemp_ball_fops = {
1793         .open = ab8500_gpadc_btemp_ball_open,
1794         .read = seq_read,
1795         .llseek = seq_lseek,
1796         .release = single_release,
1797         .owner = THIS_MODULE,
1798 };
1799
1800 static int ab8500_gpadc_main_charger_v_print(struct seq_file *s, void *p)
1801 {
1802         int main_charger_v_raw;
1803         int main_charger_v_convert;
1804         struct ab8500_gpadc *gpadc;
1805
1806         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1807         main_charger_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_V,
1808                 avg_sample, trig_edge, trig_timer, conv_type);
1809         main_charger_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1810                 MAIN_CHARGER_V, main_charger_v_raw);
1811
1812         seq_printf(s, "%d,0x%X\n", main_charger_v_convert, main_charger_v_raw);
1813
1814         return 0;
1815 }
1816
1817 static int ab8500_gpadc_main_charger_v_open(struct inode *inode,
1818                                             struct file *file)
1819 {
1820         return single_open(file, ab8500_gpadc_main_charger_v_print,
1821                 inode->i_private);
1822 }
1823
1824 static const struct file_operations ab8500_gpadc_main_charger_v_fops = {
1825         .open = ab8500_gpadc_main_charger_v_open,
1826         .read = seq_read,
1827         .llseek = seq_lseek,
1828         .release = single_release,
1829         .owner = THIS_MODULE,
1830 };
1831
1832 static int ab8500_gpadc_acc_detect1_print(struct seq_file *s, void *p)
1833 {
1834         int acc_detect1_raw;
1835         int acc_detect1_convert;
1836         struct ab8500_gpadc *gpadc;
1837
1838         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1839         acc_detect1_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT1,
1840                 avg_sample, trig_edge, trig_timer, conv_type);
1841         acc_detect1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ACC_DETECT1,
1842                 acc_detect1_raw);
1843
1844         seq_printf(s, "%d,0x%X\n", acc_detect1_convert, acc_detect1_raw);
1845
1846         return 0;
1847 }
1848
1849 static int ab8500_gpadc_acc_detect1_open(struct inode *inode,
1850                                          struct file *file)
1851 {
1852         return single_open(file, ab8500_gpadc_acc_detect1_print,
1853                 inode->i_private);
1854 }
1855
1856 static const struct file_operations ab8500_gpadc_acc_detect1_fops = {
1857         .open = ab8500_gpadc_acc_detect1_open,
1858         .read = seq_read,
1859         .llseek = seq_lseek,
1860         .release = single_release,
1861         .owner = THIS_MODULE,
1862 };
1863
1864 static int ab8500_gpadc_acc_detect2_print(struct seq_file *s, void *p)
1865 {
1866         int acc_detect2_raw;
1867         int acc_detect2_convert;
1868         struct ab8500_gpadc *gpadc;
1869
1870         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1871         acc_detect2_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT2,
1872                 avg_sample, trig_edge, trig_timer, conv_type);
1873         acc_detect2_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1874                 ACC_DETECT2, acc_detect2_raw);
1875
1876         seq_printf(s, "%d,0x%X\n", acc_detect2_convert, acc_detect2_raw);
1877
1878         return 0;
1879 }
1880
1881 static int ab8500_gpadc_acc_detect2_open(struct inode *inode,
1882                 struct file *file)
1883 {
1884         return single_open(file, ab8500_gpadc_acc_detect2_print,
1885                 inode->i_private);
1886 }
1887
1888 static const struct file_operations ab8500_gpadc_acc_detect2_fops = {
1889         .open = ab8500_gpadc_acc_detect2_open,
1890         .read = seq_read,
1891         .llseek = seq_lseek,
1892         .release = single_release,
1893         .owner = THIS_MODULE,
1894 };
1895
1896 static int ab8500_gpadc_aux1_print(struct seq_file *s, void *p)
1897 {
1898         int aux1_raw;
1899         int aux1_convert;
1900         struct ab8500_gpadc *gpadc;
1901
1902         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1903         aux1_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX1,
1904                 avg_sample, trig_edge, trig_timer, conv_type);
1905         aux1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX1,
1906                 aux1_raw);
1907
1908         seq_printf(s, "%d,0x%X\n", aux1_convert, aux1_raw);
1909
1910         return 0;
1911 }
1912
1913 static int ab8500_gpadc_aux1_open(struct inode *inode, struct file *file)
1914 {
1915         return single_open(file, ab8500_gpadc_aux1_print, inode->i_private);
1916 }
1917
1918 static const struct file_operations ab8500_gpadc_aux1_fops = {
1919         .open = ab8500_gpadc_aux1_open,
1920         .read = seq_read,
1921         .llseek = seq_lseek,
1922         .release = single_release,
1923         .owner = THIS_MODULE,
1924 };
1925
1926 static int ab8500_gpadc_aux2_print(struct seq_file *s, void *p)
1927 {
1928         int aux2_raw;
1929         int aux2_convert;
1930         struct ab8500_gpadc *gpadc;
1931
1932         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1933         aux2_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX2,
1934                 avg_sample, trig_edge, trig_timer, conv_type);
1935         aux2_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX2,
1936                 aux2_raw);
1937
1938         seq_printf(s, "%d,0x%X\n", aux2_convert, aux2_raw);
1939
1940         return 0;
1941 }
1942
1943 static int ab8500_gpadc_aux2_open(struct inode *inode, struct file *file)
1944 {
1945         return single_open(file, ab8500_gpadc_aux2_print, inode->i_private);
1946 }
1947
1948 static const struct file_operations ab8500_gpadc_aux2_fops = {
1949         .open = ab8500_gpadc_aux2_open,
1950         .read = seq_read,
1951         .llseek = seq_lseek,
1952         .release = single_release,
1953         .owner = THIS_MODULE,
1954 };
1955
1956 static int ab8500_gpadc_main_bat_v_print(struct seq_file *s, void *p)
1957 {
1958         int main_bat_v_raw;
1959         int main_bat_v_convert;
1960         struct ab8500_gpadc *gpadc;
1961
1962         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1963         main_bat_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_BAT_V,
1964                 avg_sample, trig_edge, trig_timer, conv_type);
1965         main_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
1966                 main_bat_v_raw);
1967
1968         seq_printf(s, "%d,0x%X\n", main_bat_v_convert, main_bat_v_raw);
1969
1970         return 0;
1971 }
1972
1973 static int ab8500_gpadc_main_bat_v_open(struct inode *inode,
1974                                         struct file *file)
1975 {
1976         return single_open(file, ab8500_gpadc_main_bat_v_print,
1977                            inode->i_private);
1978 }
1979
1980 static const struct file_operations ab8500_gpadc_main_bat_v_fops = {
1981         .open = ab8500_gpadc_main_bat_v_open,
1982         .read = seq_read,
1983         .llseek = seq_lseek,
1984         .release = single_release,
1985         .owner = THIS_MODULE,
1986 };
1987
1988 static int ab8500_gpadc_vbus_v_print(struct seq_file *s, void *p)
1989 {
1990         int vbus_v_raw;
1991         int vbus_v_convert;
1992         struct ab8500_gpadc *gpadc;
1993
1994         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1995         vbus_v_raw =  ab8500_gpadc_read_raw(gpadc, VBUS_V,
1996                 avg_sample, trig_edge, trig_timer, conv_type);
1997         vbus_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, VBUS_V,
1998                 vbus_v_raw);
1999
2000         seq_printf(s, "%d,0x%X\n", vbus_v_convert, vbus_v_raw);
2001
2002         return 0;
2003 }
2004
2005 static int ab8500_gpadc_vbus_v_open(struct inode *inode, struct file *file)
2006 {
2007         return single_open(file, ab8500_gpadc_vbus_v_print, inode->i_private);
2008 }
2009
2010 static const struct file_operations ab8500_gpadc_vbus_v_fops = {
2011         .open = ab8500_gpadc_vbus_v_open,
2012         .read = seq_read,
2013         .llseek = seq_lseek,
2014         .release = single_release,
2015         .owner = THIS_MODULE,
2016 };
2017
2018 static int ab8500_gpadc_main_charger_c_print(struct seq_file *s, void *p)
2019 {
2020         int main_charger_c_raw;
2021         int main_charger_c_convert;
2022         struct ab8500_gpadc *gpadc;
2023
2024         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2025         main_charger_c_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_C,
2026                 avg_sample, trig_edge, trig_timer, conv_type);
2027         main_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2028                 MAIN_CHARGER_C, main_charger_c_raw);
2029
2030         seq_printf(s, "%d,0x%X\n", main_charger_c_convert, main_charger_c_raw);
2031
2032         return 0;
2033 }
2034
2035 static int ab8500_gpadc_main_charger_c_open(struct inode *inode,
2036                 struct file *file)
2037 {
2038         return single_open(file, ab8500_gpadc_main_charger_c_print,
2039                 inode->i_private);
2040 }
2041
2042 static const struct file_operations ab8500_gpadc_main_charger_c_fops = {
2043         .open = ab8500_gpadc_main_charger_c_open,
2044         .read = seq_read,
2045         .llseek = seq_lseek,
2046         .release = single_release,
2047         .owner = THIS_MODULE,
2048 };
2049
2050 static int ab8500_gpadc_usb_charger_c_print(struct seq_file *s, void *p)
2051 {
2052         int usb_charger_c_raw;
2053         int usb_charger_c_convert;
2054         struct ab8500_gpadc *gpadc;
2055
2056         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2057         usb_charger_c_raw = ab8500_gpadc_read_raw(gpadc, USB_CHARGER_C,
2058                 avg_sample, trig_edge, trig_timer, conv_type);
2059         usb_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2060                 USB_CHARGER_C, usb_charger_c_raw);
2061
2062         seq_printf(s, "%d,0x%X\n", usb_charger_c_convert, usb_charger_c_raw);
2063
2064         return 0;
2065 }
2066
2067 static int ab8500_gpadc_usb_charger_c_open(struct inode *inode,
2068                 struct file *file)
2069 {
2070         return single_open(file, ab8500_gpadc_usb_charger_c_print,
2071                 inode->i_private);
2072 }
2073
2074 static const struct file_operations ab8500_gpadc_usb_charger_c_fops = {
2075         .open = ab8500_gpadc_usb_charger_c_open,
2076         .read = seq_read,
2077         .llseek = seq_lseek,
2078         .release = single_release,
2079         .owner = THIS_MODULE,
2080 };
2081
2082 static int ab8500_gpadc_bk_bat_v_print(struct seq_file *s, void *p)
2083 {
2084         int bk_bat_v_raw;
2085         int bk_bat_v_convert;
2086         struct ab8500_gpadc *gpadc;
2087
2088         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2089         bk_bat_v_raw = ab8500_gpadc_read_raw(gpadc, BK_BAT_V,
2090                 avg_sample, trig_edge, trig_timer, conv_type);
2091         bk_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2092                 BK_BAT_V, bk_bat_v_raw);
2093
2094         seq_printf(s, "%d,0x%X\n", bk_bat_v_convert, bk_bat_v_raw);
2095
2096         return 0;
2097 }
2098
2099 static int ab8500_gpadc_bk_bat_v_open(struct inode *inode, struct file *file)
2100 {
2101         return single_open(file, ab8500_gpadc_bk_bat_v_print,
2102                            inode->i_private);
2103 }
2104
2105 static const struct file_operations ab8500_gpadc_bk_bat_v_fops = {
2106         .open = ab8500_gpadc_bk_bat_v_open,
2107         .read = seq_read,
2108         .llseek = seq_lseek,
2109         .release = single_release,
2110         .owner = THIS_MODULE,
2111 };
2112
2113 static int ab8500_gpadc_die_temp_print(struct seq_file *s, void *p)
2114 {
2115         int die_temp_raw;
2116         int die_temp_convert;
2117         struct ab8500_gpadc *gpadc;
2118
2119         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2120         die_temp_raw = ab8500_gpadc_read_raw(gpadc, DIE_TEMP,
2121                 avg_sample, trig_edge, trig_timer, conv_type);
2122         die_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, DIE_TEMP,
2123                 die_temp_raw);
2124
2125         seq_printf(s, "%d,0x%X\n", die_temp_convert, die_temp_raw);
2126
2127         return 0;
2128 }
2129
2130 static int ab8500_gpadc_die_temp_open(struct inode *inode, struct file *file)
2131 {
2132         return single_open(file, ab8500_gpadc_die_temp_print,
2133                            inode->i_private);
2134 }
2135
2136 static const struct file_operations ab8500_gpadc_die_temp_fops = {
2137         .open = ab8500_gpadc_die_temp_open,
2138         .read = seq_read,
2139         .llseek = seq_lseek,
2140         .release = single_release,
2141         .owner = THIS_MODULE,
2142 };
2143
2144 static int ab8500_gpadc_usb_id_print(struct seq_file *s, void *p)
2145 {
2146         int usb_id_raw;
2147         int usb_id_convert;
2148         struct ab8500_gpadc *gpadc;
2149
2150         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2151         usb_id_raw = ab8500_gpadc_read_raw(gpadc, USB_ID,
2152                 avg_sample, trig_edge, trig_timer, conv_type);
2153         usb_id_convert = ab8500_gpadc_ad_to_voltage(gpadc, USB_ID,
2154                 usb_id_raw);
2155
2156         seq_printf(s, "%d,0x%X\n", usb_id_convert, usb_id_raw);
2157
2158         return 0;
2159 }
2160
2161 static int ab8500_gpadc_usb_id_open(struct inode *inode, struct file *file)
2162 {
2163         return single_open(file, ab8500_gpadc_usb_id_print, inode->i_private);
2164 }
2165
2166 static const struct file_operations ab8500_gpadc_usb_id_fops = {
2167         .open = ab8500_gpadc_usb_id_open,
2168         .read = seq_read,
2169         .llseek = seq_lseek,
2170         .release = single_release,
2171         .owner = THIS_MODULE,
2172 };
2173
2174 static int ab8540_gpadc_xtal_temp_print(struct seq_file *s, void *p)
2175 {
2176         int xtal_temp_raw;
2177         int xtal_temp_convert;
2178         struct ab8500_gpadc *gpadc;
2179
2180         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2181         xtal_temp_raw = ab8500_gpadc_read_raw(gpadc, XTAL_TEMP,
2182                 avg_sample, trig_edge, trig_timer, conv_type);
2183         xtal_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, XTAL_TEMP,
2184                 xtal_temp_raw);
2185
2186         seq_printf(s, "%d,0x%X\n", xtal_temp_convert, xtal_temp_raw);
2187
2188         return 0;
2189 }
2190
2191 static int ab8540_gpadc_xtal_temp_open(struct inode *inode, struct file *file)
2192 {
2193         return single_open(file, ab8540_gpadc_xtal_temp_print,
2194                 inode->i_private);
2195 }
2196
2197 static const struct file_operations ab8540_gpadc_xtal_temp_fops = {
2198         .open = ab8540_gpadc_xtal_temp_open,
2199         .read = seq_read,
2200         .llseek = seq_lseek,
2201         .release = single_release,
2202         .owner = THIS_MODULE,
2203 };
2204
2205 static int ab8540_gpadc_vbat_true_meas_print(struct seq_file *s, void *p)
2206 {
2207         int vbat_true_meas_raw;
2208         int vbat_true_meas_convert;
2209         struct ab8500_gpadc *gpadc;
2210
2211         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2212         vbat_true_meas_raw = ab8500_gpadc_read_raw(gpadc, VBAT_TRUE_MEAS,
2213                 avg_sample, trig_edge, trig_timer, conv_type);
2214         vbat_true_meas_convert =
2215                 ab8500_gpadc_ad_to_voltage(gpadc, VBAT_TRUE_MEAS,
2216                                            vbat_true_meas_raw);
2217
2218         seq_printf(s, "%d,0x%X\n", vbat_true_meas_convert, vbat_true_meas_raw);
2219
2220         return 0;
2221 }
2222
2223 static int ab8540_gpadc_vbat_true_meas_open(struct inode *inode,
2224                 struct file *file)
2225 {
2226         return single_open(file, ab8540_gpadc_vbat_true_meas_print,
2227                 inode->i_private);
2228 }
2229
2230 static const struct file_operations ab8540_gpadc_vbat_true_meas_fops = {
2231         .open = ab8540_gpadc_vbat_true_meas_open,
2232         .read = seq_read,
2233         .llseek = seq_lseek,
2234         .release = single_release,
2235         .owner = THIS_MODULE,
2236 };
2237
2238 static int ab8540_gpadc_bat_ctrl_and_ibat_print(struct seq_file *s, void *p)
2239 {
2240         int bat_ctrl_raw;
2241         int bat_ctrl_convert;
2242         int ibat_raw;
2243         int ibat_convert;
2244         struct ab8500_gpadc *gpadc;
2245
2246         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2247         bat_ctrl_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_CTRL_AND_IBAT,
2248                 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2249
2250         bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc, BAT_CTRL,
2251                 bat_ctrl_raw);
2252         ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2253                 ibat_raw);
2254
2255         seq_printf(s,
2256                    "%d,0x%X\n"
2257                    "%d,0x%X\n",
2258                    bat_ctrl_convert, bat_ctrl_raw,
2259                    ibat_convert, ibat_raw);
2260
2261         return 0;
2262 }
2263
2264 static int ab8540_gpadc_bat_ctrl_and_ibat_open(struct inode *inode,
2265                 struct file *file)
2266 {
2267         return single_open(file, ab8540_gpadc_bat_ctrl_and_ibat_print,
2268                 inode->i_private);
2269 }
2270
2271 static const struct file_operations ab8540_gpadc_bat_ctrl_and_ibat_fops = {
2272         .open = ab8540_gpadc_bat_ctrl_and_ibat_open,
2273         .read = seq_read,
2274         .llseek = seq_lseek,
2275         .release = single_release,
2276         .owner = THIS_MODULE,
2277 };
2278
2279 static int ab8540_gpadc_vbat_meas_and_ibat_print(struct seq_file *s, void *p)
2280 {
2281         int vbat_meas_raw;
2282         int vbat_meas_convert;
2283         int ibat_raw;
2284         int ibat_convert;
2285         struct ab8500_gpadc *gpadc;
2286
2287         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2288         vbat_meas_raw = ab8500_gpadc_double_read_raw(gpadc, VBAT_MEAS_AND_IBAT,
2289                 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2290         vbat_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
2291                 vbat_meas_raw);
2292         ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2293                 ibat_raw);
2294
2295         seq_printf(s,
2296                    "%d,0x%X\n"
2297                    "%d,0x%X\n",
2298                    vbat_meas_convert, vbat_meas_raw,
2299                    ibat_convert, ibat_raw);
2300
2301         return 0;
2302 }
2303
2304 static int ab8540_gpadc_vbat_meas_and_ibat_open(struct inode *inode,
2305                 struct file *file)
2306 {
2307         return single_open(file, ab8540_gpadc_vbat_meas_and_ibat_print,
2308                 inode->i_private);
2309 }
2310
2311 static const struct file_operations ab8540_gpadc_vbat_meas_and_ibat_fops = {
2312         .open = ab8540_gpadc_vbat_meas_and_ibat_open,
2313         .read = seq_read,
2314         .llseek = seq_lseek,
2315         .release = single_release,
2316         .owner = THIS_MODULE,
2317 };
2318
2319 static int ab8540_gpadc_vbat_true_meas_and_ibat_print(struct seq_file *s,
2320                                                       void *p)
2321 {
2322         int vbat_true_meas_raw;
2323         int vbat_true_meas_convert;
2324         int ibat_raw;
2325         int ibat_convert;
2326         struct ab8500_gpadc *gpadc;
2327
2328         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2329         vbat_true_meas_raw = ab8500_gpadc_double_read_raw(gpadc,
2330                         VBAT_TRUE_MEAS_AND_IBAT, avg_sample, trig_edge,
2331                         trig_timer, conv_type, &ibat_raw);
2332         vbat_true_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2333                         VBAT_TRUE_MEAS, vbat_true_meas_raw);
2334         ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2335                 ibat_raw);
2336
2337         seq_printf(s,
2338                    "%d,0x%X\n"
2339                    "%d,0x%X\n",
2340                    vbat_true_meas_convert, vbat_true_meas_raw,
2341                    ibat_convert, ibat_raw);
2342
2343         return 0;
2344 }
2345
2346 static int ab8540_gpadc_vbat_true_meas_and_ibat_open(struct inode *inode,
2347                 struct file *file)
2348 {
2349         return single_open(file, ab8540_gpadc_vbat_true_meas_and_ibat_print,
2350                 inode->i_private);
2351 }
2352
2353 static const struct file_operations
2354 ab8540_gpadc_vbat_true_meas_and_ibat_fops = {
2355         .open = ab8540_gpadc_vbat_true_meas_and_ibat_open,
2356         .read = seq_read,
2357         .llseek = seq_lseek,
2358         .release = single_release,
2359         .owner = THIS_MODULE,
2360 };
2361
2362 static int ab8540_gpadc_bat_temp_and_ibat_print(struct seq_file *s, void *p)
2363 {
2364         int bat_temp_raw;
2365         int bat_temp_convert;
2366         int ibat_raw;
2367         int ibat_convert;
2368         struct ab8500_gpadc *gpadc;
2369
2370         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2371         bat_temp_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_TEMP_AND_IBAT,
2372                 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2373         bat_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
2374                 bat_temp_raw);
2375         ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2376                 ibat_raw);
2377
2378         seq_printf(s,
2379                    "%d,0x%X\n"
2380                    "%d,0x%X\n",
2381                    bat_temp_convert, bat_temp_raw,
2382                    ibat_convert, ibat_raw);
2383
2384         return 0;
2385 }
2386
2387 static int ab8540_gpadc_bat_temp_and_ibat_open(struct inode *inode,
2388                 struct file *file)
2389 {
2390         return single_open(file, ab8540_gpadc_bat_temp_and_ibat_print,
2391                 inode->i_private);
2392 }
2393
2394 static const struct file_operations ab8540_gpadc_bat_temp_and_ibat_fops = {
2395         .open = ab8540_gpadc_bat_temp_and_ibat_open,
2396         .read = seq_read,
2397         .llseek = seq_lseek,
2398         .release = single_release,
2399         .owner = THIS_MODULE,
2400 };
2401
2402 static int ab8540_gpadc_otp_cal_print(struct seq_file *s, void *p)
2403 {
2404         struct ab8500_gpadc *gpadc;
2405         u16 vmain_l, vmain_h, btemp_l, btemp_h;
2406         u16 vbat_l, vbat_h, ibat_l, ibat_h;
2407
2408         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2409         ab8540_gpadc_get_otp(gpadc, &vmain_l, &vmain_h, &btemp_l, &btemp_h,
2410                         &vbat_l, &vbat_h, &ibat_l, &ibat_h);
2411         seq_printf(s,
2412                    "VMAIN_L:0x%X\n"
2413                    "VMAIN_H:0x%X\n"
2414                    "BTEMP_L:0x%X\n"
2415                    "BTEMP_H:0x%X\n"
2416                    "VBAT_L:0x%X\n"
2417                    "VBAT_H:0x%X\n"
2418                    "IBAT_L:0x%X\n"
2419                    "IBAT_H:0x%X\n",
2420                    vmain_l, vmain_h, btemp_l, btemp_h,
2421                    vbat_l, vbat_h, ibat_l, ibat_h);
2422
2423         return 0;
2424 }
2425
2426 static int ab8540_gpadc_otp_cal_open(struct inode *inode, struct file *file)
2427 {
2428         return single_open(file, ab8540_gpadc_otp_cal_print, inode->i_private);
2429 }
2430
2431 static const struct file_operations ab8540_gpadc_otp_calib_fops = {
2432         .open = ab8540_gpadc_otp_cal_open,
2433         .read = seq_read,
2434         .llseek = seq_lseek,
2435         .release = single_release,
2436         .owner = THIS_MODULE,
2437 };
2438
2439 static int ab8500_gpadc_avg_sample_print(struct seq_file *s, void *p)
2440 {
2441         seq_printf(s, "%d\n", avg_sample);
2442
2443         return 0;
2444 }
2445
2446 static int ab8500_gpadc_avg_sample_open(struct inode *inode, struct file *file)
2447 {
2448         return single_open(file, ab8500_gpadc_avg_sample_print,
2449                 inode->i_private);
2450 }
2451
2452 static ssize_t ab8500_gpadc_avg_sample_write(struct file *file,
2453         const char __user *user_buf,
2454         size_t count, loff_t *ppos)
2455 {
2456         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2457         unsigned long user_avg_sample;
2458         int err;
2459
2460         err = kstrtoul_from_user(user_buf, count, 0, &user_avg_sample);
2461         if (err)
2462                 return err;
2463
2464         if ((user_avg_sample == SAMPLE_1) || (user_avg_sample == SAMPLE_4)
2465                         || (user_avg_sample == SAMPLE_8)
2466                         || (user_avg_sample == SAMPLE_16)) {
2467                 avg_sample = (u8) user_avg_sample;
2468         } else {
2469                 dev_err(dev,
2470                         "debugfs err input: should be egal to 1, 4, 8 or 16\n");
2471                 return -EINVAL;
2472         }
2473
2474         return count;
2475 }
2476
2477 static const struct file_operations ab8500_gpadc_avg_sample_fops = {
2478         .open = ab8500_gpadc_avg_sample_open,
2479         .read = seq_read,
2480         .write = ab8500_gpadc_avg_sample_write,
2481         .llseek = seq_lseek,
2482         .release = single_release,
2483         .owner = THIS_MODULE,
2484 };
2485
2486 static int ab8500_gpadc_trig_edge_print(struct seq_file *s, void *p)
2487 {
2488         seq_printf(s, "%d\n", trig_edge);
2489
2490         return 0;
2491 }
2492
2493 static int ab8500_gpadc_trig_edge_open(struct inode *inode, struct file *file)
2494 {
2495         return single_open(file, ab8500_gpadc_trig_edge_print,
2496                 inode->i_private);
2497 }
2498
2499 static ssize_t ab8500_gpadc_trig_edge_write(struct file *file,
2500         const char __user *user_buf,
2501         size_t count, loff_t *ppos)
2502 {
2503         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2504         unsigned long user_trig_edge;
2505         int err;
2506
2507         err = kstrtoul_from_user(user_buf, count, 0, &user_trig_edge);
2508         if (err)
2509                 return err;
2510
2511         if ((user_trig_edge == RISING_EDGE)
2512                         || (user_trig_edge == FALLING_EDGE)) {
2513                 trig_edge = (u8) user_trig_edge;
2514         } else {
2515                 dev_err(dev, "Wrong input:\n"
2516                         "Enter 0. Rising edge\n"
2517                         "Enter 1. Falling edge\n");
2518                 return -EINVAL;
2519         }
2520
2521         return count;
2522 }
2523
2524 static const struct file_operations ab8500_gpadc_trig_edge_fops = {
2525         .open = ab8500_gpadc_trig_edge_open,
2526         .read = seq_read,
2527         .write = ab8500_gpadc_trig_edge_write,
2528         .llseek = seq_lseek,
2529         .release = single_release,
2530         .owner = THIS_MODULE,
2531 };
2532
2533 static int ab8500_gpadc_trig_timer_print(struct seq_file *s, void *p)
2534 {
2535         seq_printf(s, "%d\n", trig_timer);
2536
2537         return 0;
2538 }
2539
2540 static int ab8500_gpadc_trig_timer_open(struct inode *inode, struct file *file)
2541 {
2542         return single_open(file, ab8500_gpadc_trig_timer_print,
2543                 inode->i_private);
2544 }
2545
2546 static ssize_t ab8500_gpadc_trig_timer_write(struct file *file,
2547         const char __user *user_buf,
2548         size_t count, loff_t *ppos)
2549 {
2550         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2551         unsigned long user_trig_timer;
2552         int err;
2553
2554         err = kstrtoul_from_user(user_buf, count, 0, &user_trig_timer);
2555         if (err)
2556                 return err;
2557
2558         if (user_trig_timer & ~0xFF) {
2559                 dev_err(dev,
2560                         "debugfs error input: should be beetween 0 to 255\n");
2561                 return -EINVAL;
2562         }
2563
2564         trig_timer = (u8) user_trig_timer;
2565
2566         return count;
2567 }
2568
2569 static const struct file_operations ab8500_gpadc_trig_timer_fops = {
2570         .open = ab8500_gpadc_trig_timer_open,
2571         .read = seq_read,
2572         .write = ab8500_gpadc_trig_timer_write,
2573         .llseek = seq_lseek,
2574         .release = single_release,
2575         .owner = THIS_MODULE,
2576 };
2577
2578 static int ab8500_gpadc_conv_type_print(struct seq_file *s, void *p)
2579 {
2580         seq_printf(s, "%d\n", conv_type);
2581
2582         return 0;
2583 }
2584
2585 static int ab8500_gpadc_conv_type_open(struct inode *inode, struct file *file)
2586 {
2587         return single_open(file, ab8500_gpadc_conv_type_print,
2588                 inode->i_private);
2589 }
2590
2591 static ssize_t ab8500_gpadc_conv_type_write(struct file *file,
2592         const char __user *user_buf,
2593         size_t count, loff_t *ppos)
2594 {
2595         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2596         unsigned long user_conv_type;
2597         int err;
2598
2599         err = kstrtoul_from_user(user_buf, count, 0, &user_conv_type);
2600         if (err)
2601                 return err;
2602
2603         if ((user_conv_type == ADC_SW)
2604                         || (user_conv_type == ADC_HW)) {
2605                 conv_type = (u8) user_conv_type;
2606         } else {
2607                 dev_err(dev, "Wrong input:\n"
2608                         "Enter 0. ADC SW conversion\n"
2609                         "Enter 1. ADC HW conversion\n");
2610                 return -EINVAL;
2611         }
2612
2613         return count;
2614 }
2615
2616 static const struct file_operations ab8500_gpadc_conv_type_fops = {
2617         .open = ab8500_gpadc_conv_type_open,
2618         .read = seq_read,
2619         .write = ab8500_gpadc_conv_type_write,
2620         .llseek = seq_lseek,
2621         .release = single_release,
2622         .owner = THIS_MODULE,
2623 };
2624
2625 /*
2626  * return length of an ASCII numerical value, 0 is string is not a
2627  * numerical value.
2628  * string shall start at value 1st char.
2629  * string can be tailed with \0 or space or newline chars only.
2630  * value can be decimal or hexadecimal (prefixed 0x or 0X).
2631  */
2632 static int strval_len(char *b)
2633 {
2634         char *s = b;
2635
2636         if ((*s == '0') && ((*(s+1) == 'x') || (*(s+1) == 'X'))) {
2637                 s += 2;
2638                 for (; *s && (*s != ' ') && (*s != '\n'); s++) {
2639                         if (!isxdigit(*s))
2640                                 return 0;
2641                 }
2642         } else {
2643                 if (*s == '-')
2644                         s++;
2645                 for (; *s && (*s != ' ') && (*s != '\n'); s++) {
2646                         if (!isdigit(*s))
2647                                 return 0;
2648                 }
2649         }
2650         return (int) (s-b);
2651 }
2652
2653 /*
2654  * parse hwreg input data.
2655  * update global hwreg_cfg only if input data syntax is ok.
2656  */
2657 static ssize_t hwreg_common_write(char *b, struct hwreg_cfg *cfg,
2658                 struct device *dev)
2659 {
2660         uint write, val = 0;
2661         u8  regvalue;
2662         int ret;
2663         struct hwreg_cfg loc = {
2664                 .bank = 0,          /* default: invalid phys addr */
2665                 .addr = 0,          /* default: invalid phys addr */
2666                 .fmt = 0,           /* default: 32bit access, hex output */
2667                 .mask = 0xFFFFFFFF, /* default: no mask */
2668                 .shift = 0,         /* default: no bit shift */
2669         };
2670
2671         /* read or write ? */
2672         if (!strncmp(b, "read ", 5)) {
2673                 write = 0;
2674                 b += 5;
2675         } else if (!strncmp(b, "write ", 6)) {
2676                 write = 1;
2677                 b += 6;
2678         } else
2679                 return -EINVAL;
2680
2681         /* OPTIONS -l|-w|-b -s -m -o */
2682         while ((*b == ' ') || (*b == '-')) {
2683                 if (*(b-1) != ' ') {
2684                         b++;
2685                         continue;
2686                 }
2687                 if ((!strncmp(b, "-d ", 3)) ||
2688                                 (!strncmp(b, "-dec ", 5))) {
2689                         b += (*(b+2) == ' ') ? 3 : 5;
2690                         loc.fmt |= (1<<0);
2691                 } else if ((!strncmp(b, "-h ", 3)) ||
2692                                 (!strncmp(b, "-hex ", 5))) {
2693                         b += (*(b+2) == ' ') ? 3 : 5;
2694                         loc.fmt &= ~(1<<0);
2695                 } else if ((!strncmp(b, "-m ", 3)) ||
2696                                 (!strncmp(b, "-mask ", 6))) {
2697                         b += (*(b+2) == ' ') ? 3 : 6;
2698                         if (strval_len(b) == 0)
2699                                 return -EINVAL;
2700                         ret = kstrtoul(b, 0, &loc.mask);
2701                         if (ret)
2702                                 return ret;
2703                 } else if ((!strncmp(b, "-s ", 3)) ||
2704                                 (!strncmp(b, "-shift ", 7))) {
2705                         b += (*(b+2) == ' ') ? 3 : 7;
2706                         if (strval_len(b) == 0)
2707                                 return -EINVAL;
2708                         ret = kstrtol(b, 0, &loc.shift);
2709                         if (ret)
2710                                 return ret;
2711                 } else {
2712                         return -EINVAL;
2713                 }
2714         }
2715         /* get arg BANK and ADDRESS */
2716         if (strval_len(b) == 0)
2717                 return -EINVAL;
2718         ret = kstrtouint(b, 0, &loc.bank);
2719         if (ret)
2720                 return ret;
2721         while (*b == ' ')
2722                 b++;
2723         if (strval_len(b) == 0)
2724                 return -EINVAL;
2725         ret = kstrtoul(b, 0, &loc.addr);
2726         if (ret)
2727                 return ret;
2728
2729         if (write) {
2730                 while (*b == ' ')
2731                         b++;
2732                 if (strval_len(b) == 0)
2733                         return -EINVAL;
2734                 ret = kstrtouint(b, 0, &val);
2735                 if (ret)
2736                         return ret;
2737         }
2738
2739         /* args are ok, update target cfg (mainly for read) */
2740         *cfg = loc;
2741
2742 #ifdef ABB_HWREG_DEBUG
2743         pr_warn("HWREG request: %s, %s,\n"
2744                 "  addr=0x%08X, mask=0x%X, shift=%d" "value=0x%X\n",
2745                 (write) ? "write" : "read",
2746                 REG_FMT_DEC(cfg) ? "decimal" : "hexa",
2747                 cfg->addr, cfg->mask, cfg->shift, val);
2748 #endif
2749
2750         if (!write)
2751                 return 0;
2752
2753         ret = abx500_get_register_interruptible(dev,
2754                         (u8)cfg->bank, (u8)cfg->addr, &regvalue);
2755         if (ret < 0) {
2756                 dev_err(dev, "abx500_get_reg fail %d, %d\n",
2757                         ret, __LINE__);
2758                 return -EINVAL;
2759         }
2760
2761         if (cfg->shift >= 0) {
2762                 regvalue &= ~(cfg->mask << (cfg->shift));
2763                 val = (val & cfg->mask) << (cfg->shift);
2764         } else {
2765                 regvalue &= ~(cfg->mask >> (-cfg->shift));
2766                 val = (val & cfg->mask) >> (-cfg->shift);
2767         }
2768         val = val | regvalue;
2769
2770         ret = abx500_set_register_interruptible(dev,
2771                         (u8)cfg->bank, (u8)cfg->addr, (u8)val);
2772         if (ret < 0) {
2773                 pr_err("abx500_set_reg failed %d, %d", ret, __LINE__);
2774                 return -EINVAL;
2775         }
2776
2777         return 0;
2778 }
2779
2780 static ssize_t ab8500_hwreg_write(struct file *file,
2781         const char __user *user_buf, size_t count, loff_t *ppos)
2782 {
2783         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2784         char buf[128];
2785         int buf_size, ret;
2786
2787         /* Get userspace string and assure termination */
2788         buf_size = min(count, (sizeof(buf)-1));
2789         if (copy_from_user(buf, user_buf, buf_size))
2790                 return -EFAULT;
2791         buf[buf_size] = 0;
2792
2793         /* get args and process */
2794         ret = hwreg_common_write(buf, &hwreg_cfg, dev);
2795         return (ret) ? ret : buf_size;
2796 }
2797
2798 /*
2799  * - irq subscribe/unsubscribe stuff
2800  */
2801 static int ab8500_subscribe_unsubscribe_print(struct seq_file *s, void *p)
2802 {
2803         seq_printf(s, "%d\n", irq_first);
2804
2805         return 0;
2806 }
2807
2808 static int ab8500_subscribe_unsubscribe_open(struct inode *inode,
2809                                              struct file *file)
2810 {
2811         return single_open(file, ab8500_subscribe_unsubscribe_print,
2812                 inode->i_private);
2813 }
2814
2815 /*
2816  * Userspace should use poll() on this file. When an event occur
2817  * the blocking poll will be released.
2818  */
2819 static ssize_t show_irq(struct device *dev,
2820                         struct device_attribute *attr, char *buf)
2821 {
2822         unsigned long name;
2823         unsigned int irq_index;
2824         int err;
2825
2826         err = kstrtoul(attr->attr.name, 0, &name);
2827         if (err)
2828                 return err;
2829
2830         irq_index = name - irq_first;
2831         if (irq_index >= num_irqs)
2832                 return -EINVAL;
2833
2834         return sprintf(buf, "%u\n", irq_count[irq_index]);
2835 }
2836
2837 static ssize_t ab8500_subscribe_write(struct file *file,
2838                                       const char __user *user_buf,
2839                                       size_t count, loff_t *ppos)
2840 {
2841         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2842         unsigned long user_val;
2843         int err;
2844         unsigned int irq_index;
2845
2846         err = kstrtoul_from_user(user_buf, count, 0, &user_val);
2847         if (err)
2848                 return err;
2849
2850         if (user_val < irq_first) {
2851                 dev_err(dev, "debugfs error input < %d\n", irq_first);
2852                 return -EINVAL;
2853         }
2854         if (user_val > irq_last) {
2855                 dev_err(dev, "debugfs error input > %d\n", irq_last);
2856                 return -EINVAL;
2857         }
2858
2859         irq_index = user_val - irq_first;
2860         if (irq_index >= num_irqs)
2861                 return -EINVAL;
2862
2863         /*
2864          * This will create a sysfs file named <irq-nr> which userspace can
2865          * use to select or poll and get the AB8500 events
2866          */
2867         dev_attr[irq_index] = kmalloc(sizeof(struct device_attribute),
2868                 GFP_KERNEL);
2869         if (!dev_attr[irq_index])
2870                 return -ENOMEM;
2871
2872         event_name[irq_index] = kmalloc(count, GFP_KERNEL);
2873         if (!event_name[irq_index])
2874                 return -ENOMEM;
2875
2876         sprintf(event_name[irq_index], "%lu", user_val);
2877         dev_attr[irq_index]->show = show_irq;
2878         dev_attr[irq_index]->store = NULL;
2879         dev_attr[irq_index]->attr.name = event_name[irq_index];
2880         dev_attr[irq_index]->attr.mode = S_IRUGO;
2881         err = sysfs_create_file(&dev->kobj, &dev_attr[irq_index]->attr);
2882         if (err < 0) {
2883                 pr_info("sysfs_create_file failed %d\n", err);
2884                 return err;
2885         }
2886
2887         err = request_threaded_irq(user_val, NULL, ab8500_debug_handler,
2888                                    IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
2889                                    "ab8500-debug", &dev->kobj);
2890         if (err < 0) {
2891                 pr_info("request_threaded_irq failed %d, %lu\n",
2892                         err, user_val);
2893                 sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
2894                 return err;
2895         }
2896
2897         return count;
2898 }
2899
2900 static ssize_t ab8500_unsubscribe_write(struct file *file,
2901                                         const char __user *user_buf,
2902                                         size_t count, loff_t *ppos)
2903 {
2904         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2905         unsigned long user_val;
2906         int err;
2907         unsigned int irq_index;
2908
2909         err = kstrtoul_from_user(user_buf, count, 0, &user_val);
2910         if (err)
2911                 return err;
2912
2913         if (user_val < irq_first) {
2914                 dev_err(dev, "debugfs error input < %d\n", irq_first);
2915                 return -EINVAL;
2916         }
2917         if (user_val > irq_last) {
2918                 dev_err(dev, "debugfs error input > %d\n", irq_last);
2919                 return -EINVAL;
2920         }
2921
2922         irq_index = user_val - irq_first;
2923         if (irq_index >= num_irqs)
2924                 return -EINVAL;
2925
2926         /* Set irq count to 0 when unsubscribe */
2927         irq_count[irq_index] = 0;
2928
2929         if (dev_attr[irq_index])
2930                 sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
2931
2932
2933         free_irq(user_val, &dev->kobj);
2934         kfree(event_name[irq_index]);
2935         kfree(dev_attr[irq_index]);
2936
2937         return count;
2938 }
2939
2940 /*
2941  * - several deubgfs nodes fops
2942  */
2943
2944 static const struct file_operations ab8500_bank_fops = {
2945         .open = ab8500_bank_open,
2946         .write = ab8500_bank_write,
2947         .read = seq_read,
2948         .llseek = seq_lseek,
2949         .release = single_release,
2950         .owner = THIS_MODULE,
2951 };
2952
2953 static const struct file_operations ab8500_address_fops = {
2954         .open = ab8500_address_open,
2955         .write = ab8500_address_write,
2956         .read = seq_read,
2957         .llseek = seq_lseek,
2958         .release = single_release,
2959         .owner = THIS_MODULE,
2960 };
2961
2962 static const struct file_operations ab8500_val_fops = {
2963         .open = ab8500_val_open,
2964         .write = ab8500_val_write,
2965         .read = seq_read,
2966         .llseek = seq_lseek,
2967         .release = single_release,
2968         .owner = THIS_MODULE,
2969 };
2970
2971 static const struct file_operations ab8500_interrupts_fops = {
2972         .open = ab8500_interrupts_open,
2973         .read = seq_read,
2974         .llseek = seq_lseek,
2975         .release = single_release,
2976         .owner = THIS_MODULE,
2977 };
2978
2979 static const struct file_operations ab8500_subscribe_fops = {
2980         .open = ab8500_subscribe_unsubscribe_open,
2981         .write = ab8500_subscribe_write,
2982         .read = seq_read,
2983         .llseek = seq_lseek,
2984         .release = single_release,
2985         .owner = THIS_MODULE,
2986 };
2987
2988 static const struct file_operations ab8500_unsubscribe_fops = {
2989         .open = ab8500_subscribe_unsubscribe_open,
2990         .write = ab8500_unsubscribe_write,
2991         .read = seq_read,
2992         .llseek = seq_lseek,
2993         .release = single_release,
2994         .owner = THIS_MODULE,
2995 };
2996
2997 static const struct file_operations ab8500_hwreg_fops = {
2998         .open = ab8500_hwreg_open,
2999         .write = ab8500_hwreg_write,
3000         .read = seq_read,
3001         .llseek = seq_lseek,
3002         .release = single_release,
3003         .owner = THIS_MODULE,
3004 };
3005
3006 static struct dentry *ab8500_dir;
3007 static struct dentry *ab8500_gpadc_dir;
3008
3009 static int ab8500_debug_probe(struct platform_device *plf)
3010 {
3011         struct dentry *file;
3012         struct ab8500 *ab8500;
3013         struct resource *res;
3014
3015         debug_bank = AB8500_MISC;
3016         debug_address = AB8500_REV_REG & 0x00FF;
3017
3018         ab8500 = dev_get_drvdata(plf->dev.parent);
3019         num_irqs = ab8500->mask_size;
3020
3021         irq_count = devm_kzalloc(&plf->dev,
3022                                  sizeof(*irq_count)*num_irqs, GFP_KERNEL);
3023         if (!irq_count)
3024                 return -ENOMEM;
3025
3026         dev_attr = devm_kzalloc(&plf->dev,
3027                                 sizeof(*dev_attr)*num_irqs, GFP_KERNEL);
3028         if (!dev_attr)
3029                 return -ENOMEM;
3030
3031         event_name = devm_kzalloc(&plf->dev,
3032                                   sizeof(*event_name)*num_irqs, GFP_KERNEL);
3033         if (!event_name)
3034                 return -ENOMEM;
3035
3036         res = platform_get_resource_byname(plf, 0, "IRQ_AB8500");
3037         if (!res) {
3038                 dev_err(&plf->dev, "AB8500 irq not found, err %d\n", irq_first);
3039                 return -ENXIO;
3040         }
3041         irq_ab8500 = res->start;
3042
3043         irq_first = platform_get_irq_byname(plf, "IRQ_FIRST");
3044         if (irq_first < 0) {
3045                 dev_err(&plf->dev, "First irq not found, err %d\n", irq_first);
3046                 return irq_first;
3047         }
3048
3049         irq_last = platform_get_irq_byname(plf, "IRQ_LAST");
3050         if (irq_last < 0) {
3051                 dev_err(&plf->dev, "Last irq not found, err %d\n", irq_last);
3052                 return irq_last;
3053         }
3054
3055         ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
3056         if (!ab8500_dir)
3057                 goto err;
3058
3059         ab8500_gpadc_dir = debugfs_create_dir(AB8500_ADC_NAME_STRING,
3060                                               ab8500_dir);
3061         if (!ab8500_gpadc_dir)
3062                 goto err;
3063
3064         file = debugfs_create_file("all-bank-registers", S_IRUGO, ab8500_dir,
3065                                    &plf->dev, &ab8500_registers_fops);
3066         if (!file)
3067                 goto err;
3068
3069         file = debugfs_create_file("all-banks", S_IRUGO, ab8500_dir,
3070                                    &plf->dev, &ab8500_all_banks_fops);
3071         if (!file)
3072                 goto err;
3073
3074         file = debugfs_create_file("register-bank",
3075                                    (S_IRUGO | S_IWUSR | S_IWGRP),
3076                                    ab8500_dir, &plf->dev, &ab8500_bank_fops);
3077         if (!file)
3078                 goto err;
3079
3080         file = debugfs_create_file("register-address",
3081                                    (S_IRUGO | S_IWUSR | S_IWGRP),
3082                                    ab8500_dir, &plf->dev, &ab8500_address_fops);
3083         if (!file)
3084                 goto err;
3085
3086         file = debugfs_create_file("register-value",
3087                                    (S_IRUGO | S_IWUSR | S_IWGRP),
3088                                    ab8500_dir, &plf->dev, &ab8500_val_fops);
3089         if (!file)
3090                 goto err;
3091
3092         file = debugfs_create_file("irq-subscribe",
3093                                    (S_IRUGO | S_IWUSR | S_IWGRP), ab8500_dir,
3094                                    &plf->dev, &ab8500_subscribe_fops);
3095         if (!file)
3096                 goto err;
3097
3098         if (is_ab8500(ab8500)) {
3099                 debug_ranges = ab8500_debug_ranges;
3100                 num_interrupt_lines = AB8500_NR_IRQS;
3101         } else if (is_ab8505(ab8500)) {
3102                 debug_ranges = ab8505_debug_ranges;
3103                 num_interrupt_lines = AB8505_NR_IRQS;
3104         } else if (is_ab9540(ab8500)) {
3105                 debug_ranges = ab8505_debug_ranges;
3106                 num_interrupt_lines = AB9540_NR_IRQS;
3107         } else if (is_ab8540(ab8500)) {
3108                 debug_ranges = ab8540_debug_ranges;
3109                 num_interrupt_lines = AB8540_NR_IRQS;
3110         }
3111
3112         file = debugfs_create_file("interrupts", (S_IRUGO), ab8500_dir,
3113                                    &plf->dev, &ab8500_interrupts_fops);
3114         if (!file)
3115                 goto err;
3116
3117         file = debugfs_create_file("irq-unsubscribe",
3118                                    (S_IRUGO | S_IWUSR | S_IWGRP), ab8500_dir,
3119                                    &plf->dev, &ab8500_unsubscribe_fops);
3120         if (!file)
3121                 goto err;
3122
3123         file = debugfs_create_file("hwreg", (S_IRUGO | S_IWUSR | S_IWGRP),
3124                                    ab8500_dir, &plf->dev, &ab8500_hwreg_fops);
3125         if (!file)
3126                 goto err;
3127
3128         file = debugfs_create_file("all-modem-registers",
3129                                    (S_IRUGO | S_IWUSR | S_IWGRP),
3130                                    ab8500_dir, &plf->dev, &ab8500_modem_fops);
3131         if (!file)
3132                 goto err;
3133
3134         file = debugfs_create_file("bat_ctrl", (S_IRUGO | S_IWUSR | S_IWGRP),
3135                                    ab8500_gpadc_dir, &plf->dev,
3136                                    &ab8500_gpadc_bat_ctrl_fops);
3137         if (!file)
3138                 goto err;
3139
3140         file = debugfs_create_file("btemp_ball", (S_IRUGO | S_IWUSR | S_IWGRP),
3141                                    ab8500_gpadc_dir,
3142                                    &plf->dev, &ab8500_gpadc_btemp_ball_fops);
3143         if (!file)
3144                 goto err;
3145
3146         file = debugfs_create_file("main_charger_v",
3147                                    (S_IRUGO | S_IWUSR | S_IWGRP),
3148                                    ab8500_gpadc_dir, &plf->dev,
3149                                    &ab8500_gpadc_main_charger_v_fops);
3150         if (!file)
3151                 goto err;
3152
3153         file = debugfs_create_file("acc_detect1",
3154                                    (S_IRUGO | S_IWUSR | S_IWGRP),
3155                                    ab8500_gpadc_dir, &plf->dev,
3156                                    &ab8500_gpadc_acc_detect1_fops);
3157         if (!file)
3158                 goto err;
3159
3160         file = debugfs_create_file("acc_detect2",
3161                                    (S_IRUGO | S_IWUSR | S_IWGRP),
3162                                    ab8500_gpadc_dir, &plf->dev,
3163                                    &ab8500_gpadc_acc_detect2_fops);
3164         if (!file)
3165                 goto err;
3166
3167         file = debugfs_create_file("adc_aux1", (S_IRUGO | S_IWUSR | S_IWGRP),
3168                                    ab8500_gpadc_dir, &plf->dev,
3169                                    &ab8500_gpadc_aux1_fops);
3170         if (!file)
3171                 goto err;
3172
3173         file = debugfs_create_file("adc_aux2", (S_IRUGO | S_IWUSR | S_IWGRP),
3174                                    ab8500_gpadc_dir, &plf->dev,
3175                                    &ab8500_gpadc_aux2_fops);
3176         if (!file)
3177                 goto err;
3178
3179         file = debugfs_create_file("main_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3180                                    ab8500_gpadc_dir, &plf->dev,
3181                                    &ab8500_gpadc_main_bat_v_fops);
3182         if (!file)
3183                 goto err;
3184
3185         file = debugfs_create_file("vbus_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3186                                    ab8500_gpadc_dir, &plf->dev,
3187                                    &ab8500_gpadc_vbus_v_fops);
3188         if (!file)
3189                 goto err;
3190
3191         file = debugfs_create_file("main_charger_c",
3192                                    (S_IRUGO | S_IWUSR | S_IWGRP),
3193                                    ab8500_gpadc_dir, &plf->dev,
3194                                    &ab8500_gpadc_main_charger_c_fops);
3195         if (!file)
3196                 goto err;
3197
3198         file = debugfs_create_file("usb_charger_c",
3199                                    (S_IRUGO | S_IWUSR | S_IWGRP),
3200                                    ab8500_gpadc_dir,
3201                                    &plf->dev, &ab8500_gpadc_usb_charger_c_fops);
3202         if (!file)
3203                 goto err;
3204
3205         file = debugfs_create_file("bk_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3206                                    ab8500_gpadc_dir, &plf->dev,
3207                                    &ab8500_gpadc_bk_bat_v_fops);
3208         if (!file)
3209                 goto err;
3210
3211         file = debugfs_create_file("die_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
3212                                    ab8500_gpadc_dir, &plf->dev,
3213                                    &ab8500_gpadc_die_temp_fops);
3214         if (!file)
3215                 goto err;
3216
3217         file = debugfs_create_file("usb_id", (S_IRUGO | S_IWUSR | S_IWGRP),
3218                                    ab8500_gpadc_dir, &plf->dev,
3219                                    &ab8500_gpadc_usb_id_fops);
3220         if (!file)
3221                 goto err;
3222
3223         if (is_ab8540(ab8500)) {
3224                 file = debugfs_create_file("xtal_temp",
3225                                            (S_IRUGO | S_IWUSR | S_IWGRP),
3226                                            ab8500_gpadc_dir, &plf->dev,
3227                                            &ab8540_gpadc_xtal_temp_fops);
3228                 if (!file)
3229                         goto err;
3230                 file = debugfs_create_file("vbattruemeas",
3231                                            (S_IRUGO | S_IWUSR | S_IWGRP),
3232                                            ab8500_gpadc_dir, &plf->dev,
3233                                            &ab8540_gpadc_vbat_true_meas_fops);
3234                 if (!file)
3235                         goto err;
3236                 file = debugfs_create_file("batctrl_and_ibat",
3237                                         (S_IRUGO | S_IWUGO),
3238                                         ab8500_gpadc_dir,
3239                                         &plf->dev,
3240                                         &ab8540_gpadc_bat_ctrl_and_ibat_fops);
3241                 if (!file)
3242                         goto err;
3243                 file = debugfs_create_file("vbatmeas_and_ibat",
3244                                         (S_IRUGO | S_IWUGO),
3245                                         ab8500_gpadc_dir, &plf->dev,
3246                                         &ab8540_gpadc_vbat_meas_and_ibat_fops);
3247                 if (!file)
3248                         goto err;
3249                 file = debugfs_create_file("vbattruemeas_and_ibat",
3250                                 (S_IRUGO | S_IWUGO),
3251                                 ab8500_gpadc_dir,
3252                                 &plf->dev,
3253                                 &ab8540_gpadc_vbat_true_meas_and_ibat_fops);
3254                 if (!file)
3255                         goto err;
3256                 file = debugfs_create_file("battemp_and_ibat",
3257                         (S_IRUGO | S_IWUGO),
3258                         ab8500_gpadc_dir,
3259                         &plf->dev, &ab8540_gpadc_bat_temp_and_ibat_fops);
3260                 if (!file)
3261                         goto err;
3262                 file = debugfs_create_file("otp_calib",
3263                                 (S_IRUGO | S_IWUSR | S_IWGRP),
3264                                 ab8500_gpadc_dir,
3265                                 &plf->dev, &ab8540_gpadc_otp_calib_fops);
3266                 if (!file)
3267                         goto err;
3268         }
3269         file = debugfs_create_file("avg_sample", (S_IRUGO | S_IWUSR | S_IWGRP),
3270                                    ab8500_gpadc_dir, &plf->dev,
3271                                    &ab8500_gpadc_avg_sample_fops);
3272         if (!file)
3273                 goto err;
3274
3275         file = debugfs_create_file("trig_edge", (S_IRUGO | S_IWUSR | S_IWGRP),
3276                                    ab8500_gpadc_dir, &plf->dev,
3277                                    &ab8500_gpadc_trig_edge_fops);
3278         if (!file)
3279                 goto err;
3280
3281         file = debugfs_create_file("trig_timer", (S_IRUGO | S_IWUSR | S_IWGRP),
3282                                    ab8500_gpadc_dir, &plf->dev,
3283                                    &ab8500_gpadc_trig_timer_fops);
3284         if (!file)
3285                 goto err;
3286
3287         file = debugfs_create_file("conv_type", (S_IRUGO | S_IWUSR | S_IWGRP),
3288                                    ab8500_gpadc_dir, &plf->dev,
3289                                    &ab8500_gpadc_conv_type_fops);
3290         if (!file)
3291                 goto err;
3292
3293         return 0;
3294
3295 err:
3296         debugfs_remove_recursive(ab8500_dir);
3297         dev_err(&plf->dev, "failed to create debugfs entries.\n");
3298
3299         return -ENOMEM;
3300 }
3301
3302 static int ab8500_debug_remove(struct platform_device *plf)
3303 {
3304         debugfs_remove_recursive(ab8500_dir);
3305
3306         return 0;
3307 }
3308
3309 static struct platform_driver ab8500_debug_driver = {
3310         .driver = {
3311                 .name = "ab8500-debug",
3312         },
3313         .probe  = ab8500_debug_probe,
3314         .remove = ab8500_debug_remove
3315 };
3316
3317 static int __init ab8500_debug_init(void)
3318 {
3319         return platform_driver_register(&ab8500_debug_driver);
3320 }
3321
3322 static void __exit ab8500_debug_exit(void)
3323 {
3324         platform_driver_unregister(&ab8500_debug_driver);
3325 }
3326 subsys_initcall(ab8500_debug_init);
3327 module_exit(ab8500_debug_exit);
3328
3329 MODULE_AUTHOR("Mattias WALLIN <[email protected]");
3330 MODULE_DESCRIPTION("AB8500 DEBUG");
3331 MODULE_LICENSE("GPL v2");