drivers/mfd/ab8500-debugfs.c

   1 /*
   2  * Copyright (C) ST-Ericsson SA 2010
   3  *
   4  * Author: Mattias Wallin <mattias.wallin@stericsson.com> 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         u32  addr;      /* target address */
 139         uint fmt;       /* format */
 140         uint mask;      /* read/write mask, applied before any bit shift */
 141         int  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                                 err = seq_printf(s, "  [0x%02X/0x%02X]: 0x%02X\n",
1308                                         bank, reg, value);
1309                                 if (err < 0) {
1310                                         /* Error is not returned here since
1311                                          * the output is wanted in any case */
1312                                         return 0;
1313                                 }
1314                         } else {
1315                                 printk(KERN_INFO" [0x%02X/0x%02X]: 0x%02X\n",
1316                                         bank, reg, value);
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_printf(s, AB8500_NAME_STRING " register values:\n");
1329
1330         seq_printf(s, " bank 0x%02X:\n", bank);
1331
1332         ab8500_registers_print(dev, bank, s);
1333         return 0;
1334 }
1335
1336 static int ab8500_registers_open(struct inode *inode, struct file *file)
1337 {
1338         return single_open(file, ab8500_print_bank_registers, inode->i_private);
1339 }
1340
1341 static const struct file_operations ab8500_registers_fops = {
1342         .open = ab8500_registers_open,
1343         .read = seq_read,
1344         .llseek = seq_lseek,
1345         .release = single_release,
1346         .owner = THIS_MODULE,
1347 };
1348
1349 static int ab8500_print_all_banks(struct seq_file *s, void *p)
1350 {
1351         struct device *dev = s->private;
1352         unsigned int i;
1353         int err;
1354
1355         seq_printf(s, AB8500_NAME_STRING " register values:\n");
1356
1357         for (i = 0; i < AB8500_NUM_BANKS; i++) {
1358                 err = seq_printf(s, " bank 0x%02X:\n", i);
1359
1360                 ab8500_registers_print(dev, i, s);
1361         }
1362         return 0;
1363 }
1364
1365 /* Dump registers to kernel log */
1366 void ab8500_dump_all_banks(struct device *dev)
1367 {
1368         unsigned int i;
1369
1370         printk(KERN_INFO"ab8500 register values:\n");
1371
1372         for (i = 1; i < AB8500_NUM_BANKS; i++) {
1373                 printk(KERN_INFO" bank 0x%02X:\n", i);
1374                 ab8500_registers_print(dev, i, NULL);
1375         }
1376 }
1377
1378 /* Space for 500 registers. */
1379 #define DUMP_MAX_REGS 700
1380 static struct ab8500_register_dump
1381 {
1382         u8 bank;
1383         u8 reg;
1384         u8 value;
1385 } ab8500_complete_register_dump[DUMP_MAX_REGS];
1386
1387 extern int prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size);
1388
1389 /* This shall only be called upon kernel panic! */
1390 void ab8500_dump_all_banks_to_mem(void)
1391 {
1392         int i, r = 0;
1393         u8 bank;
1394         int err = 0;
1395
1396         pr_info("Saving all ABB registers at \"ab8500_complete_register_dump\" "
1397                 "for crash analyze.\n");
1398
1399         for (bank = 0; bank < AB8500_NUM_BANKS; bank++) {
1400                 for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
1401                         u8 reg;
1402
1403                         for (reg = debug_ranges[bank].range[i].first;
1404                              reg <= debug_ranges[bank].range[i].last;
1405                              reg++) {
1406                                 u8 value;
1407
1408                                 err = prcmu_abb_read(bank, reg, &value, 1);
1409
1410                                 if (err < 0)
1411                                         goto out;
1412
1413                                 ab8500_complete_register_dump[r].bank = bank;
1414                                 ab8500_complete_register_dump[r].reg = reg;
1415                                 ab8500_complete_register_dump[r].value = value;
1416
1417                                 r++;
1418
1419                                 if (r >= DUMP_MAX_REGS) {
1420                                         pr_err("%s: too many register to dump!\n",
1421                                                 __func__);
1422                                         err = -EINVAL;
1423                                         goto out;
1424                                 }
1425                         }
1426                 }
1427         }
1428 out:
1429         if (err >= 0)
1430                 pr_info("Saved all ABB registers.\n");
1431         else
1432                 pr_info("Failed to save all ABB registers.\n");
1433 }
1434
1435 static int ab8500_all_banks_open(struct inode *inode, struct file *file)
1436 {
1437         struct seq_file *s;
1438         int err;
1439
1440         err = single_open(file, ab8500_print_all_banks, inode->i_private);
1441         if (!err) {
1442                 /* Default buf size in seq_read is not enough */
1443                 s = (struct seq_file *)file->private_data;
1444                 s->size = (PAGE_SIZE * 2);
1445                 s->buf = kmalloc(s->size, GFP_KERNEL);
1446                 if (!s->buf) {
1447                         single_release(inode, file);
1448                         err = -ENOMEM;
1449                 }
1450         }
1451         return err;
1452 }
1453
1454 static const struct file_operations ab8500_all_banks_fops = {
1455         .open = ab8500_all_banks_open,
1456         .read = seq_read,
1457         .llseek = seq_lseek,
1458         .release = single_release,
1459         .owner = THIS_MODULE,
1460 };
1461
1462 static int ab8500_bank_print(struct seq_file *s, void *p)
1463 {
1464         return seq_printf(s, "0x%02X\n", debug_bank);
1465 }
1466
1467 static int ab8500_bank_open(struct inode *inode, struct file *file)
1468 {
1469         return single_open(file, ab8500_bank_print, inode->i_private);
1470 }
1471
1472 static ssize_t ab8500_bank_write(struct file *file,
1473         const char __user *user_buf,
1474         size_t count, loff_t *ppos)
1475 {
1476         struct device *dev = ((struct seq_file *)(file->private_data))->private;
1477         unsigned long user_bank;
1478         int err;
1479
1480         err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
1481         if (err)
1482                 return err;
1483
1484         if (user_bank >= AB8500_NUM_BANKS) {
1485                 dev_err(dev, "debugfs error input > number of banks\n");
1486                 return -EINVAL;
1487         }
1488
1489         debug_bank = user_bank;
1490
1491         return count;
1492 }
1493
1494 static int ab8500_address_print(struct seq_file *s, void *p)
1495 {
1496         return seq_printf(s, "0x%02X\n", debug_address);
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                 printk(KERN_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_printf(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                 struct irqaction *action = desc->action;
1604
1605                 seq_printf(s, "%3i:  %6i %4i", 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 (action) {
1612                         seq_printf(s, "  %s", action->name);
1613                         while ((action = action->next) != NULL)
1614                                 seq_printf(s, ", %s", action->name);
1615                 }
1616                 seq_putc(s, '\n');
1617         }
1618
1619         return 0;
1620 }
1621
1622 static int ab8500_interrupts_open(struct inode *inode, struct file *file)
1623 {
1624         return single_open(file, ab8500_interrupts_print, inode->i_private);
1625 }
1626
1627 /*
1628  * - HWREG DB8500 formated routines
1629  */
1630 static int ab8500_hwreg_print(struct seq_file *s, void *d)
1631 {
1632         struct device *dev = s->private;
1633         int ret;
1634         u8 regvalue;
1635
1636         ret = abx500_get_register_interruptible(dev,
1637                 (u8)hwreg_cfg.bank, (u8)hwreg_cfg.addr, &regvalue);
1638         if (ret < 0) {
1639                 dev_err(dev, "abx500_get_reg fail %d, %d\n",
1640                         ret, __LINE__);
1641                 return -EINVAL;
1642         }
1643
1644         if (hwreg_cfg.shift >= 0)
1645                 regvalue >>= hwreg_cfg.shift;
1646         else
1647                 regvalue <<= -hwreg_cfg.shift;
1648         regvalue &= hwreg_cfg.mask;
1649
1650         if (REG_FMT_DEC(&hwreg_cfg))
1651                 seq_printf(s, "%d\n", regvalue);
1652         else
1653                 seq_printf(s, "0x%02X\n", regvalue);
1654         return 0;
1655 }
1656
1657 static int ab8500_hwreg_open(struct inode *inode, struct file *file)
1658 {
1659         return single_open(file, ab8500_hwreg_print, inode->i_private);
1660 }
1661
1662 #define AB8500_SUPPLY_CONTROL_CONFIG_1 0x01
1663 #define AB8500_SUPPLY_CONTROL_REG 0x00
1664 #define AB8500_FIRST_SIM_REG 0x80
1665 #define AB8500_LAST_SIM_REG 0x8B
1666 #define AB8505_LAST_SIM_REG 0x8C
1667
1668 static int ab8500_print_modem_registers(struct seq_file *s, void *p)
1669 {
1670         struct device *dev = s->private;
1671         struct ab8500 *ab8500;
1672         int err;
1673         u8 value;
1674         u8 orig_value;
1675         u32 bank = AB8500_REGU_CTRL2;
1676         u32 last_sim_reg = AB8500_LAST_SIM_REG;
1677         u32 reg;
1678
1679         ab8500 = dev_get_drvdata(dev->parent);
1680         dev_warn(dev, "WARNING! This operation can interfer with modem side\n"
1681                 "and should only be done with care\n");
1682
1683         err = abx500_get_register_interruptible(dev,
1684                 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, &orig_value);
1685         if (err < 0) {
1686                 dev_err(dev, "ab->read fail %d\n", err);
1687                 return err;
1688         }
1689         /* Config 1 will allow APE side to read SIM registers */
1690         err = abx500_set_register_interruptible(dev,
1691                 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG,
1692                 AB8500_SUPPLY_CONTROL_CONFIG_1);
1693         if (err < 0) {
1694                 dev_err(dev, "ab->write fail %d\n", err);
1695                 return err;
1696         }
1697
1698         seq_printf(s, " bank 0x%02X:\n", bank);
1699
1700         if (is_ab9540(ab8500) || is_ab8505(ab8500))
1701                 last_sim_reg = AB8505_LAST_SIM_REG;
1702
1703         for (reg = AB8500_FIRST_SIM_REG; reg <= last_sim_reg; reg++) {
1704                 err = abx500_get_register_interruptible(dev,
1705                         bank, reg, &value);
1706                 if (err < 0) {
1707                         dev_err(dev, "ab->read fail %d\n", err);
1708                         return err;
1709                 }
1710                 err = seq_printf(s, "  [0x%02X/0x%02X]: 0x%02X\n",
1711                         bank, reg, value);
1712         }
1713         err = abx500_set_register_interruptible(dev,
1714                 AB8500_REGU_CTRL1, AB8500_SUPPLY_CONTROL_REG, orig_value);
1715         if (err < 0) {
1716                 dev_err(dev, "ab->write fail %d\n", err);
1717                 return err;
1718         }
1719         return 0;
1720 }
1721
1722 static int ab8500_modem_open(struct inode *inode, struct file *file)
1723 {
1724         return single_open(file, ab8500_print_modem_registers, inode->i_private);
1725 }
1726
1727 static const struct file_operations ab8500_modem_fops = {
1728         .open = ab8500_modem_open,
1729         .read = seq_read,
1730         .llseek = seq_lseek,
1731         .release = single_release,
1732         .owner = THIS_MODULE,
1733 };
1734
1735 static int ab8500_gpadc_bat_ctrl_print(struct seq_file *s, void *p)
1736 {
1737         int bat_ctrl_raw;
1738         int bat_ctrl_convert;
1739         struct ab8500_gpadc *gpadc;
1740
1741         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1742         bat_ctrl_raw = ab8500_gpadc_read_raw(gpadc, BAT_CTRL,
1743                 avg_sample, trig_edge, trig_timer, conv_type);
1744         bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1745                 BAT_CTRL, bat_ctrl_raw);
1746
1747         return seq_printf(s, "%d,0x%X\n",
1748                 bat_ctrl_convert, bat_ctrl_raw);
1749 }
1750
1751 static int ab8500_gpadc_bat_ctrl_open(struct inode *inode, struct file *file)
1752 {
1753         return single_open(file, ab8500_gpadc_bat_ctrl_print, inode->i_private);
1754 }
1755
1756 static const struct file_operations ab8500_gpadc_bat_ctrl_fops = {
1757         .open = ab8500_gpadc_bat_ctrl_open,
1758         .read = seq_read,
1759         .llseek = seq_lseek,
1760         .release = single_release,
1761         .owner = THIS_MODULE,
1762 };
1763
1764 static int ab8500_gpadc_btemp_ball_print(struct seq_file *s, void *p)
1765 {
1766         int btemp_ball_raw;
1767         int btemp_ball_convert;
1768         struct ab8500_gpadc *gpadc;
1769
1770         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1771         btemp_ball_raw = ab8500_gpadc_read_raw(gpadc, BTEMP_BALL,
1772                 avg_sample, trig_edge, trig_timer, conv_type);
1773         btemp_ball_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
1774                 btemp_ball_raw);
1775
1776         return seq_printf(s,
1777                 "%d,0x%X\n", btemp_ball_convert, btemp_ball_raw);
1778 }
1779
1780 static int ab8500_gpadc_btemp_ball_open(struct inode *inode,
1781                                         struct file *file)
1782 {
1783         return single_open(file, ab8500_gpadc_btemp_ball_print, inode->i_private);
1784 }
1785
1786 static const struct file_operations ab8500_gpadc_btemp_ball_fops = {
1787         .open = ab8500_gpadc_btemp_ball_open,
1788         .read = seq_read,
1789         .llseek = seq_lseek,
1790         .release = single_release,
1791         .owner = THIS_MODULE,
1792 };
1793
1794 static int ab8500_gpadc_main_charger_v_print(struct seq_file *s, void *p)
1795 {
1796         int main_charger_v_raw;
1797         int main_charger_v_convert;
1798         struct ab8500_gpadc *gpadc;
1799
1800         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1801         main_charger_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_V,
1802                 avg_sample, trig_edge, trig_timer, conv_type);
1803         main_charger_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1804                 MAIN_CHARGER_V, main_charger_v_raw);
1805
1806         return seq_printf(s, "%d,0x%X\n",
1807                         main_charger_v_convert, main_charger_v_raw);
1808 }
1809
1810 static int ab8500_gpadc_main_charger_v_open(struct inode *inode,
1811                                             struct file *file)
1812 {
1813         return single_open(file, ab8500_gpadc_main_charger_v_print,
1814                 inode->i_private);
1815 }
1816
1817 static const struct file_operations ab8500_gpadc_main_charger_v_fops = {
1818         .open = ab8500_gpadc_main_charger_v_open,
1819         .read = seq_read,
1820         .llseek = seq_lseek,
1821         .release = single_release,
1822         .owner = THIS_MODULE,
1823 };
1824
1825 static int ab8500_gpadc_acc_detect1_print(struct seq_file *s, void *p)
1826 {
1827         int acc_detect1_raw;
1828         int acc_detect1_convert;
1829         struct ab8500_gpadc *gpadc;
1830
1831         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1832         acc_detect1_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT1,
1833                 avg_sample, trig_edge, trig_timer, conv_type);
1834         acc_detect1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ACC_DETECT1,
1835                 acc_detect1_raw);
1836
1837         return seq_printf(s, "%d,0x%X\n",
1838                 acc_detect1_convert, acc_detect1_raw);
1839 }
1840
1841 static int ab8500_gpadc_acc_detect1_open(struct inode *inode,
1842                                          struct file *file)
1843 {
1844         return single_open(file, ab8500_gpadc_acc_detect1_print,
1845                 inode->i_private);
1846 }
1847
1848 static const struct file_operations ab8500_gpadc_acc_detect1_fops = {
1849         .open = ab8500_gpadc_acc_detect1_open,
1850         .read = seq_read,
1851         .llseek = seq_lseek,
1852         .release = single_release,
1853         .owner = THIS_MODULE,
1854 };
1855
1856 static int ab8500_gpadc_acc_detect2_print(struct seq_file *s, void *p)
1857 {
1858         int acc_detect2_raw;
1859         int acc_detect2_convert;
1860         struct ab8500_gpadc *gpadc;
1861
1862         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1863         acc_detect2_raw = ab8500_gpadc_read_raw(gpadc, ACC_DETECT2,
1864                 avg_sample, trig_edge, trig_timer, conv_type);
1865         acc_detect2_convert = ab8500_gpadc_ad_to_voltage(gpadc,
1866                 ACC_DETECT2, acc_detect2_raw);
1867
1868         return seq_printf(s, "%d,0x%X\n",
1869                 acc_detect2_convert, acc_detect2_raw);
1870 }
1871
1872 static int ab8500_gpadc_acc_detect2_open(struct inode *inode,
1873                 struct file *file)
1874 {
1875         return single_open(file, ab8500_gpadc_acc_detect2_print,
1876                 inode->i_private);
1877 }
1878
1879 static const struct file_operations ab8500_gpadc_acc_detect2_fops = {
1880         .open = ab8500_gpadc_acc_detect2_open,
1881         .read = seq_read,
1882         .llseek = seq_lseek,
1883         .release = single_release,
1884         .owner = THIS_MODULE,
1885 };
1886
1887 static int ab8500_gpadc_aux1_print(struct seq_file *s, void *p)
1888 {
1889         int aux1_raw;
1890         int aux1_convert;
1891         struct ab8500_gpadc *gpadc;
1892
1893         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1894         aux1_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX1,
1895                 avg_sample, trig_edge, trig_timer, conv_type);
1896         aux1_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX1,
1897                 aux1_raw);
1898
1899         return seq_printf(s, "%d,0x%X\n",
1900                 aux1_convert, aux1_raw);
1901 }
1902
1903 static int ab8500_gpadc_aux1_open(struct inode *inode, struct file *file)
1904 {
1905         return single_open(file, ab8500_gpadc_aux1_print, inode->i_private);
1906 }
1907
1908 static const struct file_operations ab8500_gpadc_aux1_fops = {
1909         .open = ab8500_gpadc_aux1_open,
1910         .read = seq_read,
1911         .llseek = seq_lseek,
1912         .release = single_release,
1913         .owner = THIS_MODULE,
1914 };
1915
1916 static int ab8500_gpadc_aux2_print(struct seq_file *s, void *p)
1917 {
1918         int aux2_raw;
1919         int aux2_convert;
1920         struct ab8500_gpadc *gpadc;
1921
1922         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1923         aux2_raw = ab8500_gpadc_read_raw(gpadc, ADC_AUX2,
1924                 avg_sample, trig_edge, trig_timer, conv_type);
1925         aux2_convert = ab8500_gpadc_ad_to_voltage(gpadc, ADC_AUX2,
1926                 aux2_raw);
1927
1928         return seq_printf(s, "%d,0x%X\n",
1929                         aux2_convert, aux2_raw);
1930 }
1931
1932 static int ab8500_gpadc_aux2_open(struct inode *inode, struct file *file)
1933 {
1934         return single_open(file, ab8500_gpadc_aux2_print, inode->i_private);
1935 }
1936
1937 static const struct file_operations ab8500_gpadc_aux2_fops = {
1938         .open = ab8500_gpadc_aux2_open,
1939         .read = seq_read,
1940         .llseek = seq_lseek,
1941         .release = single_release,
1942         .owner = THIS_MODULE,
1943 };
1944
1945 static int ab8500_gpadc_main_bat_v_print(struct seq_file *s, void *p)
1946 {
1947         int main_bat_v_raw;
1948         int main_bat_v_convert;
1949         struct ab8500_gpadc *gpadc;
1950
1951         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1952         main_bat_v_raw = ab8500_gpadc_read_raw(gpadc, MAIN_BAT_V,
1953                 avg_sample, trig_edge, trig_timer, conv_type);
1954         main_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
1955                 main_bat_v_raw);
1956
1957         return seq_printf(s, "%d,0x%X\n",
1958                 main_bat_v_convert, main_bat_v_raw);
1959 }
1960
1961 static int ab8500_gpadc_main_bat_v_open(struct inode *inode,
1962                                         struct file *file)
1963 {
1964         return single_open(file, ab8500_gpadc_main_bat_v_print, inode->i_private);
1965 }
1966
1967 static const struct file_operations ab8500_gpadc_main_bat_v_fops = {
1968         .open = ab8500_gpadc_main_bat_v_open,
1969         .read = seq_read,
1970         .llseek = seq_lseek,
1971         .release = single_release,
1972         .owner = THIS_MODULE,
1973 };
1974
1975 static int ab8500_gpadc_vbus_v_print(struct seq_file *s, void *p)
1976 {
1977         int vbus_v_raw;
1978         int vbus_v_convert;
1979         struct ab8500_gpadc *gpadc;
1980
1981         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
1982         vbus_v_raw =  ab8500_gpadc_read_raw(gpadc, VBUS_V,
1983                 avg_sample, trig_edge, trig_timer, conv_type);
1984         vbus_v_convert = ab8500_gpadc_ad_to_voltage(gpadc, VBUS_V,
1985                 vbus_v_raw);
1986
1987         return seq_printf(s, "%d,0x%X\n",
1988                 vbus_v_convert, vbus_v_raw);
1989 }
1990
1991 static int ab8500_gpadc_vbus_v_open(struct inode *inode, struct file *file)
1992 {
1993         return single_open(file, ab8500_gpadc_vbus_v_print, inode->i_private);
1994 }
1995
1996 static const struct file_operations ab8500_gpadc_vbus_v_fops = {
1997         .open = ab8500_gpadc_vbus_v_open,
1998         .read = seq_read,
1999         .llseek = seq_lseek,
2000         .release = single_release,
2001         .owner = THIS_MODULE,
2002 };
2003
2004 static int ab8500_gpadc_main_charger_c_print(struct seq_file *s, void *p)
2005 {
2006         int main_charger_c_raw;
2007         int main_charger_c_convert;
2008         struct ab8500_gpadc *gpadc;
2009
2010         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2011         main_charger_c_raw = ab8500_gpadc_read_raw(gpadc, MAIN_CHARGER_C,
2012                 avg_sample, trig_edge, trig_timer, conv_type);
2013         main_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2014                 MAIN_CHARGER_C, main_charger_c_raw);
2015
2016         return seq_printf(s, "%d,0x%X\n",
2017                 main_charger_c_convert, main_charger_c_raw);
2018 }
2019
2020 static int ab8500_gpadc_main_charger_c_open(struct inode *inode,
2021                 struct file *file)
2022 {
2023         return single_open(file, ab8500_gpadc_main_charger_c_print,
2024                 inode->i_private);
2025 }
2026
2027 static const struct file_operations ab8500_gpadc_main_charger_c_fops = {
2028         .open = ab8500_gpadc_main_charger_c_open,
2029         .read = seq_read,
2030         .llseek = seq_lseek,
2031         .release = single_release,
2032         .owner = THIS_MODULE,
2033 };
2034
2035 static int ab8500_gpadc_usb_charger_c_print(struct seq_file *s, void *p)
2036 {
2037         int usb_charger_c_raw;
2038         int usb_charger_c_convert;
2039         struct ab8500_gpadc *gpadc;
2040
2041         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2042         usb_charger_c_raw = ab8500_gpadc_read_raw(gpadc, USB_CHARGER_C,
2043                 avg_sample, trig_edge, trig_timer, conv_type);
2044         usb_charger_c_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2045                 USB_CHARGER_C, usb_charger_c_raw);
2046
2047         return seq_printf(s, "%d,0x%X\n",
2048                 usb_charger_c_convert, usb_charger_c_raw);
2049 }
2050
2051 static int ab8500_gpadc_usb_charger_c_open(struct inode *inode,
2052                 struct file *file)
2053 {
2054         return single_open(file, ab8500_gpadc_usb_charger_c_print,
2055                 inode->i_private);
2056 }
2057
2058 static const struct file_operations ab8500_gpadc_usb_charger_c_fops = {
2059         .open = ab8500_gpadc_usb_charger_c_open,
2060         .read = seq_read,
2061         .llseek = seq_lseek,
2062         .release = single_release,
2063         .owner = THIS_MODULE,
2064 };
2065
2066 static int ab8500_gpadc_bk_bat_v_print(struct seq_file *s, void *p)
2067 {
2068         int bk_bat_v_raw;
2069         int bk_bat_v_convert;
2070         struct ab8500_gpadc *gpadc;
2071
2072         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2073         bk_bat_v_raw = ab8500_gpadc_read_raw(gpadc, BK_BAT_V,
2074                 avg_sample, trig_edge, trig_timer, conv_type);
2075         bk_bat_v_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2076                 BK_BAT_V, bk_bat_v_raw);
2077
2078         return seq_printf(s, "%d,0x%X\n",
2079                 bk_bat_v_convert, bk_bat_v_raw);
2080 }
2081
2082 static int ab8500_gpadc_bk_bat_v_open(struct inode *inode, struct file *file)
2083 {
2084         return single_open(file, ab8500_gpadc_bk_bat_v_print, inode->i_private);
2085 }
2086
2087 static const struct file_operations ab8500_gpadc_bk_bat_v_fops = {
2088         .open = ab8500_gpadc_bk_bat_v_open,
2089         .read = seq_read,
2090         .llseek = seq_lseek,
2091         .release = single_release,
2092         .owner = THIS_MODULE,
2093 };
2094
2095 static int ab8500_gpadc_die_temp_print(struct seq_file *s, void *p)
2096 {
2097         int die_temp_raw;
2098         int die_temp_convert;
2099         struct ab8500_gpadc *gpadc;
2100
2101         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2102         die_temp_raw = ab8500_gpadc_read_raw(gpadc, DIE_TEMP,
2103                 avg_sample, trig_edge, trig_timer, conv_type);
2104         die_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, DIE_TEMP,
2105                 die_temp_raw);
2106
2107         return seq_printf(s, "%d,0x%X\n",
2108                 die_temp_convert, die_temp_raw);
2109 }
2110
2111 static int ab8500_gpadc_die_temp_open(struct inode *inode, struct file *file)
2112 {
2113         return single_open(file, ab8500_gpadc_die_temp_print, inode->i_private);
2114 }
2115
2116 static const struct file_operations ab8500_gpadc_die_temp_fops = {
2117         .open = ab8500_gpadc_die_temp_open,
2118         .read = seq_read,
2119         .llseek = seq_lseek,
2120         .release = single_release,
2121         .owner = THIS_MODULE,
2122 };
2123
2124 static int ab8500_gpadc_usb_id_print(struct seq_file *s, void *p)
2125 {
2126         int usb_id_raw;
2127         int usb_id_convert;
2128         struct ab8500_gpadc *gpadc;
2129
2130         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2131         usb_id_raw = ab8500_gpadc_read_raw(gpadc, USB_ID,
2132                 avg_sample, trig_edge, trig_timer, conv_type);
2133         usb_id_convert = ab8500_gpadc_ad_to_voltage(gpadc, USB_ID,
2134                 usb_id_raw);
2135
2136         return seq_printf(s, "%d,0x%X\n",
2137                 usb_id_convert, usb_id_raw);
2138 }
2139
2140 static int ab8500_gpadc_usb_id_open(struct inode *inode, struct file *file)
2141 {
2142         return single_open(file, ab8500_gpadc_usb_id_print, inode->i_private);
2143 }
2144
2145 static const struct file_operations ab8500_gpadc_usb_id_fops = {
2146         .open = ab8500_gpadc_usb_id_open,
2147         .read = seq_read,
2148         .llseek = seq_lseek,
2149         .release = single_release,
2150         .owner = THIS_MODULE,
2151 };
2152
2153 static int ab8540_gpadc_xtal_temp_print(struct seq_file *s, void *p)
2154 {
2155         int xtal_temp_raw;
2156         int xtal_temp_convert;
2157         struct ab8500_gpadc *gpadc;
2158
2159         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2160         xtal_temp_raw = ab8500_gpadc_read_raw(gpadc, XTAL_TEMP,
2161                 avg_sample, trig_edge, trig_timer, conv_type);
2162         xtal_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, XTAL_TEMP,
2163                 xtal_temp_raw);
2164
2165         return seq_printf(s, "%d,0x%X\n",
2166                 xtal_temp_convert, xtal_temp_raw);
2167 }
2168
2169 static int ab8540_gpadc_xtal_temp_open(struct inode *inode, struct file *file)
2170 {
2171         return single_open(file, ab8540_gpadc_xtal_temp_print,
2172                 inode->i_private);
2173 }
2174
2175 static const struct file_operations ab8540_gpadc_xtal_temp_fops = {
2176         .open = ab8540_gpadc_xtal_temp_open,
2177         .read = seq_read,
2178         .llseek = seq_lseek,
2179         .release = single_release,
2180         .owner = THIS_MODULE,
2181 };
2182
2183 static int ab8540_gpadc_vbat_true_meas_print(struct seq_file *s, void *p)
2184 {
2185         int vbat_true_meas_raw;
2186         int vbat_true_meas_convert;
2187         struct ab8500_gpadc *gpadc;
2188
2189         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2190         vbat_true_meas_raw = ab8500_gpadc_read_raw(gpadc, VBAT_TRUE_MEAS,
2191                 avg_sample, trig_edge, trig_timer, conv_type);
2192         vbat_true_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc, VBAT_TRUE_MEAS,
2193                 vbat_true_meas_raw);
2194
2195         return seq_printf(s, "%d,0x%X\n",
2196                 vbat_true_meas_convert, vbat_true_meas_raw);
2197 }
2198
2199 static int ab8540_gpadc_vbat_true_meas_open(struct inode *inode,
2200                 struct file *file)
2201 {
2202         return single_open(file, ab8540_gpadc_vbat_true_meas_print,
2203                 inode->i_private);
2204 }
2205
2206 static const struct file_operations ab8540_gpadc_vbat_true_meas_fops = {
2207         .open = ab8540_gpadc_vbat_true_meas_open,
2208         .read = seq_read,
2209         .llseek = seq_lseek,
2210         .release = single_release,
2211         .owner = THIS_MODULE,
2212 };
2213
2214 static int ab8540_gpadc_bat_ctrl_and_ibat_print(struct seq_file *s, void *p)
2215 {
2216         int bat_ctrl_raw;
2217         int bat_ctrl_convert;
2218         int ibat_raw;
2219         int ibat_convert;
2220         struct ab8500_gpadc *gpadc;
2221
2222         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2223         bat_ctrl_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_CTRL_AND_IBAT,
2224                 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2225
2226         bat_ctrl_convert = ab8500_gpadc_ad_to_voltage(gpadc, BAT_CTRL,
2227                 bat_ctrl_raw);
2228         ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2229                 ibat_raw);
2230
2231         return seq_printf(s, "%d,0x%X\n"  "%d,0x%X\n",
2232                 bat_ctrl_convert, bat_ctrl_raw,
2233                 ibat_convert, ibat_raw);
2234 }
2235
2236 static int ab8540_gpadc_bat_ctrl_and_ibat_open(struct inode *inode,
2237                 struct file *file)
2238 {
2239         return single_open(file, ab8540_gpadc_bat_ctrl_and_ibat_print,
2240                 inode->i_private);
2241 }
2242
2243 static const struct file_operations ab8540_gpadc_bat_ctrl_and_ibat_fops = {
2244         .open = ab8540_gpadc_bat_ctrl_and_ibat_open,
2245         .read = seq_read,
2246         .llseek = seq_lseek,
2247         .release = single_release,
2248         .owner = THIS_MODULE,
2249 };
2250
2251 static int ab8540_gpadc_vbat_meas_and_ibat_print(struct seq_file *s, void *p)
2252 {
2253         int vbat_meas_raw;
2254         int vbat_meas_convert;
2255         int ibat_raw;
2256         int ibat_convert;
2257         struct ab8500_gpadc *gpadc;
2258
2259         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2260         vbat_meas_raw = ab8500_gpadc_double_read_raw(gpadc, VBAT_MEAS_AND_IBAT,
2261                 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2262         vbat_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc, MAIN_BAT_V,
2263                 vbat_meas_raw);
2264         ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2265                 ibat_raw);
2266
2267         return seq_printf(s, "%d,0x%X\n"  "%d,0x%X\n",
2268                 vbat_meas_convert, vbat_meas_raw,
2269                 ibat_convert, ibat_raw);
2270 }
2271
2272 static int ab8540_gpadc_vbat_meas_and_ibat_open(struct inode *inode,
2273                 struct file *file)
2274 {
2275         return single_open(file, ab8540_gpadc_vbat_meas_and_ibat_print,
2276                 inode->i_private);
2277 }
2278
2279 static const struct file_operations ab8540_gpadc_vbat_meas_and_ibat_fops = {
2280         .open = ab8540_gpadc_vbat_meas_and_ibat_open,
2281         .read = seq_read,
2282         .llseek = seq_lseek,
2283         .release = single_release,
2284         .owner = THIS_MODULE,
2285 };
2286
2287 static int ab8540_gpadc_vbat_true_meas_and_ibat_print(struct seq_file *s, void *p)
2288 {
2289         int vbat_true_meas_raw;
2290         int vbat_true_meas_convert;
2291         int ibat_raw;
2292         int ibat_convert;
2293         struct ab8500_gpadc *gpadc;
2294
2295         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2296         vbat_true_meas_raw = ab8500_gpadc_double_read_raw(gpadc,
2297                         VBAT_TRUE_MEAS_AND_IBAT, avg_sample, trig_edge,
2298                         trig_timer, conv_type, &ibat_raw);
2299         vbat_true_meas_convert = ab8500_gpadc_ad_to_voltage(gpadc,
2300                         VBAT_TRUE_MEAS, vbat_true_meas_raw);
2301         ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2302                 ibat_raw);
2303
2304         return seq_printf(s, "%d,0x%X\n"  "%d,0x%X\n",
2305                 vbat_true_meas_convert, vbat_true_meas_raw,
2306                 ibat_convert, ibat_raw);
2307 }
2308
2309 static int ab8540_gpadc_vbat_true_meas_and_ibat_open(struct inode *inode,
2310                 struct file *file)
2311 {
2312         return single_open(file, ab8540_gpadc_vbat_true_meas_and_ibat_print,
2313                 inode->i_private);
2314 }
2315
2316 static const struct file_operations ab8540_gpadc_vbat_true_meas_and_ibat_fops = {
2317         .open = ab8540_gpadc_vbat_true_meas_and_ibat_open,
2318         .read = seq_read,
2319         .llseek = seq_lseek,
2320         .release = single_release,
2321         .owner = THIS_MODULE,
2322 };
2323
2324 static int ab8540_gpadc_bat_temp_and_ibat_print(struct seq_file *s, void *p)
2325 {
2326         int bat_temp_raw;
2327         int bat_temp_convert;
2328         int ibat_raw;
2329         int ibat_convert;
2330         struct ab8500_gpadc *gpadc;
2331
2332         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2333         bat_temp_raw = ab8500_gpadc_double_read_raw(gpadc, BAT_TEMP_AND_IBAT,
2334                 avg_sample, trig_edge, trig_timer, conv_type, &ibat_raw);
2335         bat_temp_convert = ab8500_gpadc_ad_to_voltage(gpadc, BTEMP_BALL,
2336                 bat_temp_raw);
2337         ibat_convert = ab8500_gpadc_ad_to_voltage(gpadc, IBAT_VIRTUAL_CHANNEL,
2338                 ibat_raw);
2339
2340         return seq_printf(s, "%d,0x%X\n"  "%d,0x%X\n",
2341                 bat_temp_convert, bat_temp_raw,
2342                 ibat_convert, ibat_raw);
2343 }
2344
2345 static int ab8540_gpadc_bat_temp_and_ibat_open(struct inode *inode,
2346                 struct file *file)
2347 {
2348         return single_open(file, ab8540_gpadc_bat_temp_and_ibat_print,
2349                 inode->i_private);
2350 }
2351
2352 static const struct file_operations ab8540_gpadc_bat_temp_and_ibat_fops = {
2353         .open = ab8540_gpadc_bat_temp_and_ibat_open,
2354         .read = seq_read,
2355         .llseek = seq_lseek,
2356         .release = single_release,
2357         .owner = THIS_MODULE,
2358 };
2359
2360 static int ab8540_gpadc_otp_cal_print(struct seq_file *s, void *p)
2361 {
2362         struct ab8500_gpadc *gpadc;
2363         u16 vmain_l, vmain_h, btemp_l, btemp_h;
2364         u16 vbat_l, vbat_h, ibat_l, ibat_h;
2365
2366         gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2367         ab8540_gpadc_get_otp(gpadc, &vmain_l, &vmain_h, &btemp_l, &btemp_h,
2368                         &vbat_l, &vbat_h, &ibat_l, &ibat_h);
2369         return seq_printf(s, "VMAIN_L:0x%X\n"
2370                 "VMAIN_H:0x%X\n"
2371                 "BTEMP_L:0x%X\n"
2372                 "BTEMP_H:0x%X\n"
2373                 "VBAT_L:0x%X\n"
2374                 "VBAT_H:0x%X\n"
2375                 "IBAT_L:0x%X\n"
2376                 "IBAT_H:0x%X\n",
2377                 vmain_l, vmain_h, btemp_l, btemp_h, vbat_l, vbat_h, ibat_l, ibat_h);
2378 }
2379
2380 static int ab8540_gpadc_otp_cal_open(struct inode *inode, struct file *file)
2381 {
2382         return single_open(file, ab8540_gpadc_otp_cal_print, inode->i_private);
2383 }
2384
2385 static const struct file_operations ab8540_gpadc_otp_calib_fops = {
2386         .open = ab8540_gpadc_otp_cal_open,
2387         .read = seq_read,
2388         .llseek = seq_lseek,
2389         .release = single_release,
2390         .owner = THIS_MODULE,
2391 };
2392
2393 static int ab8500_gpadc_avg_sample_print(struct seq_file *s, void *p)
2394 {
2395         return seq_printf(s, "%d\n", avg_sample);
2396 }
2397
2398 static int ab8500_gpadc_avg_sample_open(struct inode *inode, struct file *file)
2399 {
2400         return single_open(file, ab8500_gpadc_avg_sample_print,
2401                 inode->i_private);
2402 }
2403
2404 static ssize_t ab8500_gpadc_avg_sample_write(struct file *file,
2405         const char __user *user_buf,
2406         size_t count, loff_t *ppos)
2407 {
2408         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2409         unsigned long user_avg_sample;
2410         int err;
2411
2412         err = kstrtoul_from_user(user_buf, count, 0, &user_avg_sample);
2413         if (err)
2414                 return err;
2415
2416         if ((user_avg_sample == SAMPLE_1) || (user_avg_sample == SAMPLE_4)
2417                         || (user_avg_sample == SAMPLE_8)
2418                         || (user_avg_sample == SAMPLE_16)) {
2419                 avg_sample = (u8) user_avg_sample;
2420         } else {
2421                 dev_err(dev, "debugfs error input: "
2422                         "should be egal to 1, 4, 8 or 16\n");
2423                 return -EINVAL;
2424         }
2425
2426         return count;
2427 }
2428
2429 static const struct file_operations ab8500_gpadc_avg_sample_fops = {
2430         .open = ab8500_gpadc_avg_sample_open,
2431         .read = seq_read,
2432         .write = ab8500_gpadc_avg_sample_write,
2433         .llseek = seq_lseek,
2434         .release = single_release,
2435         .owner = THIS_MODULE,
2436 };
2437
2438 static int ab8500_gpadc_trig_edge_print(struct seq_file *s, void *p)
2439 {
2440         return seq_printf(s, "%d\n", trig_edge);
2441 }
2442
2443 static int ab8500_gpadc_trig_edge_open(struct inode *inode, struct file *file)
2444 {
2445         return single_open(file, ab8500_gpadc_trig_edge_print,
2446                 inode->i_private);
2447 }
2448
2449 static ssize_t ab8500_gpadc_trig_edge_write(struct file *file,
2450         const char __user *user_buf,
2451         size_t count, loff_t *ppos)
2452 {
2453         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2454         unsigned long user_trig_edge;
2455         int err;
2456
2457         err = kstrtoul_from_user(user_buf, count, 0, &user_trig_edge);
2458         if (err)
2459                 return err;
2460
2461         if ((user_trig_edge == RISING_EDGE)
2462                         || (user_trig_edge == FALLING_EDGE)) {
2463                 trig_edge = (u8) user_trig_edge;
2464         } else {
2465                 dev_err(dev, "Wrong input:\n"
2466                         "Enter 0. Rising edge\n"
2467                         "Enter 1. Falling edge\n");
2468                 return -EINVAL;
2469         }
2470
2471         return count;
2472 }
2473
2474 static const struct file_operations ab8500_gpadc_trig_edge_fops = {
2475         .open = ab8500_gpadc_trig_edge_open,
2476         .read = seq_read,
2477         .write = ab8500_gpadc_trig_edge_write,
2478         .llseek = seq_lseek,
2479         .release = single_release,
2480         .owner = THIS_MODULE,
2481 };
2482
2483 static int ab8500_gpadc_trig_timer_print(struct seq_file *s, void *p)
2484 {
2485         return seq_printf(s, "%d\n", trig_timer);
2486 }
2487
2488 static int ab8500_gpadc_trig_timer_open(struct inode *inode, struct file *file)
2489 {
2490         return single_open(file, ab8500_gpadc_trig_timer_print,
2491                 inode->i_private);
2492 }
2493
2494 static ssize_t ab8500_gpadc_trig_timer_write(struct file *file,
2495         const char __user *user_buf,
2496         size_t count, loff_t *ppos)
2497 {
2498         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2499         unsigned long user_trig_timer;
2500         int err;
2501
2502         err = kstrtoul_from_user(user_buf, count, 0, &user_trig_timer);
2503         if (err)
2504                 return err;
2505
2506         if ((user_trig_timer >= 0) && (user_trig_timer <= 255)) {
2507                 trig_timer = (u8) user_trig_timer;
2508         } else {
2509                 dev_err(dev, "debugfs error input: "
2510                         "should be beetween 0 to 255\n");
2511                 return -EINVAL;
2512         }
2513
2514         return count;
2515 }
2516
2517 static const struct file_operations ab8500_gpadc_trig_timer_fops = {
2518         .open = ab8500_gpadc_trig_timer_open,
2519         .read = seq_read,
2520         .write = ab8500_gpadc_trig_timer_write,
2521         .llseek = seq_lseek,
2522         .release = single_release,
2523         .owner = THIS_MODULE,
2524 };
2525
2526 static int ab8500_gpadc_conv_type_print(struct seq_file *s, void *p)
2527 {
2528         return seq_printf(s, "%d\n", conv_type);
2529 }
2530
2531 static int ab8500_gpadc_conv_type_open(struct inode *inode, struct file *file)
2532 {
2533         return single_open(file, ab8500_gpadc_conv_type_print,
2534                 inode->i_private);
2535 }
2536
2537 static ssize_t ab8500_gpadc_conv_type_write(struct file *file,
2538         const char __user *user_buf,
2539         size_t count, loff_t *ppos)
2540 {
2541         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2542         unsigned long user_conv_type;
2543         int err;
2544
2545         err = kstrtoul_from_user(user_buf, count, 0, &user_conv_type);
2546         if (err)
2547                 return err;
2548
2549         if ((user_conv_type == ADC_SW)
2550                         || (user_conv_type == ADC_HW)) {
2551                 conv_type = (u8) user_conv_type;
2552         } else {
2553                 dev_err(dev, "Wrong input:\n"
2554                         "Enter 0. ADC SW conversion\n"
2555                         "Enter 1. ADC HW conversion\n");
2556                 return -EINVAL;
2557         }
2558
2559         return count;
2560 }
2561
2562 static const struct file_operations ab8500_gpadc_conv_type_fops = {
2563         .open = ab8500_gpadc_conv_type_open,
2564         .read = seq_read,
2565         .write = ab8500_gpadc_conv_type_write,
2566         .llseek = seq_lseek,
2567         .release = single_release,
2568         .owner = THIS_MODULE,
2569 };
2570
2571 /*
2572  * return length of an ASCII numerical value, 0 is string is not a
2573  * numerical value.
2574  * string shall start at value 1st char.
2575  * string can be tailed with \0 or space or newline chars only.
2576  * value can be decimal or hexadecimal (prefixed 0x or 0X).
2577  */
2578 static int strval_len(char *b)
2579 {
2580         char *s = b;
2581         if ((*s == '0') && ((*(s+1) == 'x') || (*(s+1) == 'X'))) {
2582                 s += 2;
2583                 for (; *s && (*s != ' ') && (*s != '\n'); s++) {
2584                         if (!isxdigit(*s))
2585                                 return 0;
2586                 }
2587         } else {
2588                 if (*s == '-')
2589                         s++;
2590                 for (; *s && (*s != ' ') && (*s != '\n'); s++) {
2591                         if (!isdigit(*s))
2592                                 return 0;
2593                 }
2594         }
2595         return (int) (s-b);
2596 }
2597
2598 /*
2599  * parse hwreg input data.
2600  * update global hwreg_cfg only if input data syntax is ok.
2601  */
2602 static ssize_t hwreg_common_write(char *b, struct hwreg_cfg *cfg,
2603                 struct device *dev)
2604 {
2605         uint write, val = 0;
2606         u8  regvalue;
2607         int ret;
2608         struct hwreg_cfg loc = {
2609                 .bank = 0,          /* default: invalid phys addr */
2610                 .addr = 0,          /* default: invalid phys addr */
2611                 .fmt = 0,           /* default: 32bit access, hex output */
2612                 .mask = 0xFFFFFFFF, /* default: no mask */
2613                 .shift = 0,         /* default: no bit shift */
2614         };
2615
2616         /* read or write ? */
2617         if (!strncmp(b, "read ", 5)) {
2618                 write = 0;
2619                 b += 5;
2620         } else if (!strncmp(b, "write ", 6)) {
2621                 write = 1;
2622                 b += 6;
2623         } else
2624                 return -EINVAL;
2625
2626         /* OPTIONS -l|-w|-b -s -m -o */
2627         while ((*b == ' ') || (*b == '-')) {
2628                 if (*(b-1) != ' ') {
2629                         b++;
2630                         continue;
2631                 }
2632                 if ((!strncmp(b, "-d ", 3)) ||
2633                                 (!strncmp(b, "-dec ", 5))) {
2634                         b += (*(b+2) == ' ') ? 3 : 5;
2635                         loc.fmt |= (1<<0);
2636                 } else if ((!strncmp(b, "-h ", 3)) ||
2637                                 (!strncmp(b, "-hex ", 5))) {
2638                         b += (*(b+2) == ' ') ? 3 : 5;
2639                         loc.fmt &= ~(1<<0);
2640                 } else if ((!strncmp(b, "-m ", 3)) ||
2641                                 (!strncmp(b, "-mask ", 6))) {
2642                         b += (*(b+2) == ' ') ? 3 : 6;
2643                         if (strval_len(b) == 0)
2644                                 return -EINVAL;
2645                         loc.mask = simple_strtoul(b, &b, 0);
2646                 } else if ((!strncmp(b, "-s ", 3)) ||
2647                                 (!strncmp(b, "-shift ", 7))) {
2648                         b += (*(b+2) == ' ') ? 3 : 7;
2649                         if (strval_len(b) == 0)
2650                                 return -EINVAL;
2651                         loc.shift = simple_strtol(b, &b, 0);
2652                 } else {
2653                         return -EINVAL;
2654                 }
2655         }
2656         /* get arg BANK and ADDRESS */
2657         if (strval_len(b) == 0)
2658                 return -EINVAL;
2659         loc.bank = simple_strtoul(b, &b, 0);
2660         while (*b == ' ')
2661                 b++;
2662         if (strval_len(b) == 0)
2663                 return -EINVAL;
2664         loc.addr = simple_strtoul(b, &b, 0);
2665
2666         if (write) {
2667                 while (*b == ' ')
2668                         b++;
2669                 if (strval_len(b) == 0)
2670                         return -EINVAL;
2671                 val = simple_strtoul(b, &b, 0);
2672         }
2673
2674         /* args are ok, update target cfg (mainly for read) */
2675         *cfg = loc;
2676
2677 #ifdef ABB_HWREG_DEBUG
2678         pr_warn("HWREG request: %s, %s, addr=0x%08X, mask=0x%X, shift=%d"
2679                         "value=0x%X\n", (write) ? "write" : "read",
2680                         REG_FMT_DEC(cfg) ? "decimal" : "hexa",
2681                         cfg->addr, cfg->mask, cfg->shift, val);
2682 #endif
2683
2684         if (!write)
2685                 return 0;
2686
2687         ret = abx500_get_register_interruptible(dev,
2688                         (u8)cfg->bank, (u8)cfg->addr, &regvalue);
2689         if (ret < 0) {
2690                 dev_err(dev, "abx500_get_reg fail %d, %d\n",
2691                         ret, __LINE__);
2692                 return -EINVAL;
2693         }
2694
2695         if (cfg->shift >= 0) {
2696                 regvalue &= ~(cfg->mask << (cfg->shift));
2697                 val = (val & cfg->mask) << (cfg->shift);
2698         } else {
2699                 regvalue &= ~(cfg->mask >> (-cfg->shift));
2700                 val = (val & cfg->mask) >> (-cfg->shift);
2701         }
2702         val = val | regvalue;
2703
2704         ret = abx500_set_register_interruptible(dev,
2705                         (u8)cfg->bank, (u8)cfg->addr, (u8)val);
2706         if (ret < 0) {
2707                 pr_err("abx500_set_reg failed %d, %d", ret, __LINE__);
2708                 return -EINVAL;
2709         }
2710
2711         return 0;
2712 }
2713
2714 static ssize_t ab8500_hwreg_write(struct file *file,
2715         const char __user *user_buf, size_t count, loff_t *ppos)
2716 {
2717         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2718         char buf[128];
2719         int buf_size, ret;
2720
2721         /* Get userspace string and assure termination */
2722         buf_size = min(count, (sizeof(buf)-1));
2723         if (copy_from_user(buf, user_buf, buf_size))
2724                 return -EFAULT;
2725         buf[buf_size] = 0;
2726
2727         /* get args and process */
2728         ret = hwreg_common_write(buf, &hwreg_cfg, dev);
2729         return (ret) ? ret : buf_size;
2730 }
2731
2732 /*
2733  * - irq subscribe/unsubscribe stuff
2734  */
2735 static int ab8500_subscribe_unsubscribe_print(struct seq_file *s, void *p)
2736 {
2737         seq_printf(s, "%d\n", irq_first);
2738
2739         return 0;
2740 }
2741
2742 static int ab8500_subscribe_unsubscribe_open(struct inode *inode,
2743                                              struct file *file)
2744 {
2745         return single_open(file, ab8500_subscribe_unsubscribe_print,
2746                 inode->i_private);
2747 }
2748
2749 /*
2750  * Userspace should use poll() on this file. When an event occur
2751  * the blocking poll will be released.
2752  */
2753 static ssize_t show_irq(struct device *dev,
2754                         struct device_attribute *attr, char *buf)
2755 {
2756         unsigned long name;
2757         unsigned int irq_index;
2758         int err;
2759
2760         err = kstrtoul(attr->attr.name, 0, &name);
2761         if (err)
2762                 return err;
2763
2764         irq_index = name - irq_first;
2765         if (irq_index >= num_irqs)
2766                 return -EINVAL;
2767         else
2768                 return sprintf(buf, "%u\n", irq_count[irq_index]);
2769 }
2770
2771 static ssize_t ab8500_subscribe_write(struct file *file,
2772                                       const char __user *user_buf,
2773                                       size_t count, loff_t *ppos)
2774 {
2775         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2776         unsigned long user_val;
2777         int err;
2778         unsigned int irq_index;
2779
2780         err = kstrtoul_from_user(user_buf, count, 0, &user_val);
2781         if (err)
2782                 return err;
2783
2784         if (user_val < irq_first) {
2785                 dev_err(dev, "debugfs error input < %d\n", irq_first);
2786                 return -EINVAL;
2787         }
2788         if (user_val > irq_last) {
2789                 dev_err(dev, "debugfs error input > %d\n", irq_last);
2790                 return -EINVAL;
2791         }
2792
2793         irq_index = user_val - irq_first;
2794         if (irq_index >= num_irqs)
2795                 return -EINVAL;
2796
2797         /*
2798          * This will create a sysfs file named <irq-nr> which userspace can
2799          * use to select or poll and get the AB8500 events
2800          */
2801         dev_attr[irq_index] = kmalloc(sizeof(struct device_attribute),
2802                 GFP_KERNEL);
2803         if (!dev_attr[irq_index])
2804                 return -ENOMEM;
2805
2806         event_name[irq_index] = kmalloc(count, GFP_KERNEL);
2807         if (!event_name[irq_index])
2808                 return -ENOMEM;
2809
2810         sprintf(event_name[irq_index], "%lu", user_val);
2811         dev_attr[irq_index]->show = show_irq;
2812         dev_attr[irq_index]->store = NULL;
2813         dev_attr[irq_index]->attr.name = event_name[irq_index];
2814         dev_attr[irq_index]->attr.mode = S_IRUGO;
2815         err = sysfs_create_file(&dev->kobj, &dev_attr[irq_index]->attr);
2816         if (err < 0) {
2817                 printk(KERN_ERR "sysfs_create_file failed %d\n", err);
2818                 return err;
2819         }
2820
2821         err = request_threaded_irq(user_val, NULL, ab8500_debug_handler,
2822                                    IRQF_SHARED | IRQF_NO_SUSPEND,
2823                                    "ab8500-debug", &dev->kobj);
2824         if (err < 0) {
2825                 printk(KERN_ERR "request_threaded_irq failed %d, %lu\n",
2826                        err, user_val);
2827                 sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
2828                 return err;
2829         }
2830
2831         return count;
2832 }
2833
2834 static ssize_t ab8500_unsubscribe_write(struct file *file,
2835                                         const char __user *user_buf,
2836                                         size_t count, loff_t *ppos)
2837 {
2838         struct device *dev = ((struct seq_file *)(file->private_data))->private;
2839         unsigned long user_val;
2840         int err;
2841         unsigned int irq_index;
2842
2843         err = kstrtoul_from_user(user_buf, count, 0, &user_val);
2844         if (err)
2845                 return err;
2846
2847         if (user_val < irq_first) {
2848                 dev_err(dev, "debugfs error input < %d\n", irq_first);
2849                 return -EINVAL;
2850         }
2851         if (user_val > irq_last) {
2852                 dev_err(dev, "debugfs error input > %d\n", irq_last);
2853                 return -EINVAL;
2854         }
2855
2856         irq_index = user_val - irq_first;
2857         if (irq_index >= num_irqs)
2858                 return -EINVAL;
2859
2860         /* Set irq count to 0 when unsubscribe */
2861         irq_count[irq_index] = 0;
2862
2863         if (dev_attr[irq_index])
2864                 sysfs_remove_file(&dev->kobj, &dev_attr[irq_index]->attr);
2865
2866
2867         free_irq(user_val, &dev->kobj);
2868         kfree(event_name[irq_index]);
2869         kfree(dev_attr[irq_index]);
2870
2871         return count;
2872 }
2873
2874 /*
2875  * - several deubgfs nodes fops
2876  */
2877
2878 static const struct file_operations ab8500_bank_fops = {
2879         .open = ab8500_bank_open,
2880         .write = ab8500_bank_write,
2881         .read = seq_read,
2882         .llseek = seq_lseek,
2883         .release = single_release,
2884         .owner = THIS_MODULE,
2885 };
2886
2887 static const struct file_operations ab8500_address_fops = {
2888         .open = ab8500_address_open,
2889         .write = ab8500_address_write,
2890         .read = seq_read,
2891         .llseek = seq_lseek,
2892         .release = single_release,
2893         .owner = THIS_MODULE,
2894 };
2895
2896 static const struct file_operations ab8500_val_fops = {
2897         .open = ab8500_val_open,
2898         .write = ab8500_val_write,
2899         .read = seq_read,
2900         .llseek = seq_lseek,
2901         .release = single_release,
2902         .owner = THIS_MODULE,
2903 };
2904
2905 static const struct file_operations ab8500_interrupts_fops = {
2906         .open = ab8500_interrupts_open,
2907         .read = seq_read,
2908         .llseek = seq_lseek,
2909         .release = single_release,
2910         .owner = THIS_MODULE,
2911 };
2912
2913 static const struct file_operations ab8500_subscribe_fops = {
2914         .open = ab8500_subscribe_unsubscribe_open,
2915         .write = ab8500_subscribe_write,
2916         .read = seq_read,
2917         .llseek = seq_lseek,
2918         .release = single_release,
2919         .owner = THIS_MODULE,
2920 };
2921
2922 static const struct file_operations ab8500_unsubscribe_fops = {
2923         .open = ab8500_subscribe_unsubscribe_open,
2924         .write = ab8500_unsubscribe_write,
2925         .read = seq_read,
2926         .llseek = seq_lseek,
2927         .release = single_release,
2928         .owner = THIS_MODULE,
2929 };
2930
2931 static const struct file_operations ab8500_hwreg_fops = {
2932         .open = ab8500_hwreg_open,
2933         .write = ab8500_hwreg_write,
2934         .read = seq_read,
2935         .llseek = seq_lseek,
2936         .release = single_release,
2937         .owner = THIS_MODULE,
2938 };
2939
2940 static struct dentry *ab8500_dir;
2941 static struct dentry *ab8500_gpadc_dir;
2942
2943 static int ab8500_debug_probe(struct platform_device *plf)
2944 {
2945         struct dentry *file;
2946         struct ab8500 *ab8500;
2947         struct resource *res;
2948         debug_bank = AB8500_MISC;
2949         debug_address = AB8500_REV_REG & 0x00FF;
2950
2951         ab8500 = dev_get_drvdata(plf->dev.parent);
2952         num_irqs = ab8500->mask_size;
2953
2954         irq_count = devm_kzalloc(&plf->dev,
2955                                  sizeof(*irq_count)*num_irqs, GFP_KERNEL);
2956         if (!irq_count)
2957                 return -ENOMEM;
2958
2959         dev_attr = devm_kzalloc(&plf->dev,
2960                                 sizeof(*dev_attr)*num_irqs,GFP_KERNEL);
2961         if (!dev_attr)
2962                 return -ENOMEM;
2963
2964         event_name = devm_kzalloc(&plf->dev,
2965                                   sizeof(*event_name)*num_irqs, GFP_KERNEL);
2966         if (!event_name)
2967                 return -ENOMEM;
2968
2969         res = platform_get_resource_byname(plf, 0, "IRQ_AB8500");
2970         if (!res) {
2971                 dev_err(&plf->dev, "AB8500 irq not found, err %d\n",
2972                         irq_first);
2973                 return ENXIO;
2974         }
2975         irq_ab8500 = res->start;
2976
2977         irq_first = platform_get_irq_byname(plf, "IRQ_FIRST");
2978         if (irq_first < 0) {
2979                 dev_err(&plf->dev, "First irq not found, err %d\n",
2980                         irq_first);
2981                 return irq_first;
2982         }
2983
2984         irq_last = platform_get_irq_byname(plf, "IRQ_LAST");
2985         if (irq_last < 0) {
2986                 dev_err(&plf->dev, "Last irq not found, err %d\n",
2987                         irq_last);
2988                 return irq_last;
2989         }
2990
2991         ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
2992         if (!ab8500_dir)
2993                 goto err;
2994
2995         ab8500_gpadc_dir = debugfs_create_dir(AB8500_ADC_NAME_STRING,
2996                 ab8500_dir);
2997         if (!ab8500_gpadc_dir)
2998                 goto err;
2999
3000         file = debugfs_create_file("all-bank-registers", S_IRUGO,
3001                 ab8500_dir, &plf->dev, &ab8500_registers_fops);
3002         if (!file)
3003                 goto err;
3004
3005         file = debugfs_create_file("all-banks", S_IRUGO,
3006                 ab8500_dir, &plf->dev, &ab8500_all_banks_fops);
3007         if (!file)
3008                 goto err;
3009
3010         file = debugfs_create_file("register-bank", (S_IRUGO | S_IWUSR | S_IWGRP),
3011                 ab8500_dir, &plf->dev, &ab8500_bank_fops);
3012         if (!file)
3013                 goto err;
3014
3015         file = debugfs_create_file("register-address", (S_IRUGO | S_IWUSR | S_IWGRP),
3016                 ab8500_dir, &plf->dev, &ab8500_address_fops);
3017         if (!file)
3018                 goto err;
3019
3020         file = debugfs_create_file("register-value", (S_IRUGO | S_IWUSR | S_IWGRP),
3021                 ab8500_dir, &plf->dev, &ab8500_val_fops);
3022         if (!file)
3023                 goto err;
3024
3025         file = debugfs_create_file("irq-subscribe", (S_IRUGO | S_IWUSR | S_IWGRP),
3026                 ab8500_dir, &plf->dev, &ab8500_subscribe_fops);
3027         if (!file)
3028                 goto err;
3029
3030         if (is_ab8500(ab8500)) {
3031                 debug_ranges = ab8500_debug_ranges;
3032                 num_interrupt_lines = AB8500_NR_IRQS;
3033         } else if (is_ab8505(ab8500)) {
3034                 debug_ranges = ab8505_debug_ranges;
3035                 num_interrupt_lines = AB8505_NR_IRQS;
3036         } else if (is_ab9540(ab8500)) {
3037                 debug_ranges = ab8505_debug_ranges;
3038                 num_interrupt_lines = AB9540_NR_IRQS;
3039         } else if (is_ab8540(ab8500)) {
3040                 debug_ranges = ab8540_debug_ranges;
3041                 num_interrupt_lines = AB8540_NR_IRQS;
3042         }
3043
3044         file = debugfs_create_file("interrupts", (S_IRUGO),
3045                 ab8500_dir, &plf->dev, &ab8500_interrupts_fops);
3046         if (!file)
3047                 goto err;
3048
3049         file = debugfs_create_file("irq-unsubscribe", (S_IRUGO | S_IWUSR | S_IWGRP),
3050                 ab8500_dir, &plf->dev, &ab8500_unsubscribe_fops);
3051         if (!file)
3052                 goto err;
3053
3054         file = debugfs_create_file("hwreg", (S_IRUGO | S_IWUSR | S_IWGRP),
3055                 ab8500_dir, &plf->dev, &ab8500_hwreg_fops);
3056         if (!file)
3057                 goto err;
3058
3059         file = debugfs_create_file("all-modem-registers", (S_IRUGO | S_IWUSR | S_IWGRP),
3060                 ab8500_dir, &plf->dev, &ab8500_modem_fops);
3061         if (!file)
3062                 goto err;
3063
3064         file = debugfs_create_file("bat_ctrl", (S_IRUGO | S_IWUSR | S_IWGRP),
3065                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_bat_ctrl_fops);
3066         if (!file)
3067                 goto err;
3068
3069         file = debugfs_create_file("btemp_ball", (S_IRUGO | S_IWUSR | S_IWGRP),
3070                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_btemp_ball_fops);
3071         if (!file)
3072                 goto err;
3073
3074         file = debugfs_create_file("main_charger_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3075                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_main_charger_v_fops);
3076         if (!file)
3077                 goto err;
3078
3079         file = debugfs_create_file("acc_detect1", (S_IRUGO | S_IWUSR | S_IWGRP),
3080                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_acc_detect1_fops);
3081         if (!file)
3082                 goto err;
3083
3084         file = debugfs_create_file("acc_detect2", (S_IRUGO | S_IWUSR | S_IWGRP),
3085                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_acc_detect2_fops);
3086         if (!file)
3087                 goto err;
3088
3089         file = debugfs_create_file("adc_aux1", (S_IRUGO | S_IWUSR | S_IWGRP),
3090                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_aux1_fops);
3091         if (!file)
3092                 goto err;
3093
3094         file = debugfs_create_file("adc_aux2", (S_IRUGO | S_IWUSR | S_IWGRP),
3095                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_aux2_fops);
3096         if (!file)
3097                 goto err;
3098
3099         file = debugfs_create_file("main_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3100                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_main_bat_v_fops);
3101         if (!file)
3102                 goto err;
3103
3104         file = debugfs_create_file("vbus_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3105                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_vbus_v_fops);
3106         if (!file)
3107                 goto err;
3108
3109         file = debugfs_create_file("main_charger_c", (S_IRUGO | S_IWUSR | S_IWGRP),
3110                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_main_charger_c_fops);
3111         if (!file)
3112                 goto err;
3113
3114         file = debugfs_create_file("usb_charger_c", (S_IRUGO | S_IWUSR | S_IWGRP),
3115                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_usb_charger_c_fops);
3116         if (!file)
3117                 goto err;
3118
3119         file = debugfs_create_file("bk_bat_v", (S_IRUGO | S_IWUSR | S_IWGRP),
3120                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_bk_bat_v_fops);
3121         if (!file)
3122                 goto err;
3123
3124         file = debugfs_create_file("die_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
3125                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_die_temp_fops);
3126         if (!file)
3127                 goto err;
3128
3129         file = debugfs_create_file("usb_id", (S_IRUGO | S_IWUSR | S_IWGRP),
3130                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_usb_id_fops);
3131         if (!file)
3132                 goto err;
3133
3134         if (is_ab8540(ab8500)) {
3135                 file = debugfs_create_file("xtal_temp", (S_IRUGO | S_IWUSR | S_IWGRP),
3136                         ab8500_gpadc_dir, &plf->dev, &ab8540_gpadc_xtal_temp_fops);
3137                 if (!file)
3138                         goto err;
3139                 file = debugfs_create_file("vbattruemeas", (S_IRUGO | S_IWUSR | S_IWGRP),
3140                         ab8500_gpadc_dir, &plf->dev,
3141                         &ab8540_gpadc_vbat_true_meas_fops);
3142                 if (!file)
3143                         goto err;
3144                 file = debugfs_create_file("batctrl_and_ibat",
3145                         (S_IRUGO | S_IWUGO), ab8500_gpadc_dir,
3146                         &plf->dev, &ab8540_gpadc_bat_ctrl_and_ibat_fops);
3147                 if (!file)
3148                         goto err;
3149                 file = debugfs_create_file("vbatmeas_and_ibat",
3150                         (S_IRUGO | S_IWUGO), ab8500_gpadc_dir,
3151                         &plf->dev,
3152                         &ab8540_gpadc_vbat_meas_and_ibat_fops);
3153                 if (!file)
3154                         goto err;
3155                 file = debugfs_create_file("vbattruemeas_and_ibat",
3156                         (S_IRUGO | S_IWUGO), ab8500_gpadc_dir,
3157                         &plf->dev,
3158                         &ab8540_gpadc_vbat_true_meas_and_ibat_fops);
3159                 if (!file)
3160                         goto err;
3161                 file = debugfs_create_file("battemp_and_ibat",
3162                         (S_IRUGO | S_IWUGO), ab8500_gpadc_dir,
3163                         &plf->dev, &ab8540_gpadc_bat_temp_and_ibat_fops);
3164                 if (!file)
3165                         goto err;
3166                 file = debugfs_create_file("otp_calib", (S_IRUGO | S_IWUSR | S_IWGRP),
3167                         ab8500_gpadc_dir, &plf->dev, &ab8540_gpadc_otp_calib_fops);
3168                 if (!file)
3169                         goto err;
3170         }
3171         file = debugfs_create_file("avg_sample", (S_IRUGO | S_IWUSR | S_IWGRP),
3172                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_avg_sample_fops);
3173         if (!file)
3174                 goto err;
3175
3176         file = debugfs_create_file("trig_edge", (S_IRUGO | S_IWUSR | S_IWGRP),
3177                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_trig_edge_fops);
3178         if (!file)
3179                 goto err;
3180
3181         file = debugfs_create_file("trig_timer", (S_IRUGO | S_IWUSR | S_IWGRP),
3182                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_trig_timer_fops);
3183         if (!file)
3184                 goto err;
3185
3186         file = debugfs_create_file("conv_type", (S_IRUGO | S_IWUSR | S_IWGRP),
3187                 ab8500_gpadc_dir, &plf->dev, &ab8500_gpadc_conv_type_fops);
3188         if (!file)
3189                 goto err;
3190
3191         return 0;
3192
3193 err:
3194         if (ab8500_dir)
3195                 debugfs_remove_recursive(ab8500_dir);
3196         dev_err(&plf->dev, "failed to create debugfs entries.\n");
3197
3198         return -ENOMEM;
3199 }
3200
3201 static int ab8500_debug_remove(struct platform_device *plf)
3202 {
3203         debugfs_remove_recursive(ab8500_dir);
3204
3205         return 0;
3206 }
3207
3208 static struct platform_driver ab8500_debug_driver = {
3209         .driver = {
3210                 .name = "ab8500-debug",
3211                 .owner = THIS_MODULE,
3212         },
3213         .probe  = ab8500_debug_probe,
3214         .remove = ab8500_debug_remove
3215 };
3216
3217 static int __init ab8500_debug_init(void)
3218 {
3219         return platform_driver_register(&ab8500_debug_driver);
3220 }
3221
3222 static void __exit ab8500_debug_exit(void)
3223 {
3224         platform_driver_unregister(&ab8500_debug_driver);
3225 }
3226 subsys_initcall(ab8500_debug_init);
3227 module_exit(ab8500_debug_exit);
3228
3229 MODULE_AUTHOR("Mattias WALLIN <mattias.wallin@stericsson.com");
3230 MODULE_DESCRIPTION("AB8500 DEBUG");
3231 MODULE_LICENSE("GPL v2");