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