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