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