linux/drivers/mfd/ab3550-core.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2007-2010 ST-Ericsson
   3 * License terms: GNU General Public License (GPL) version 2
   4 * Low-level core for exclusive access to the AB3550 IC on the I2C bus
   5 * and some basic chip-configuration.
   6 * Author: Bengt Jonsson <bengt.g.jonsson@stericsson.com>
   7 * Author: Mattias Nilsson <mattias.i.nilsson@stericsson.com>
   8 * Author: Mattias Wallin <mattias.wallin@stericsson.com>
   9 * Author: Rickard Andersson <rickard.andersson@stericsson.com>
  10 */
  11
  12#include <linux/i2c.h>
  13#include <linux/mutex.h>
  14#include <linux/err.h>
  15#include <linux/platform_device.h>
  16#include <linux/slab.h>
  17#include <linux/device.h>
  18#include <linux/irq.h>
  19#include <linux/interrupt.h>
  20#include <linux/random.h>
  21#include <linux/workqueue.h>
  22#include <linux/debugfs.h>
  23#include <linux/seq_file.h>
  24#include <linux/uaccess.h>
  25#include <linux/mfd/abx500.h>
  26#include <linux/list.h>
  27#include <linux/bitops.h>
  28#include <linux/spinlock.h>
  29#include <linux/mfd/core.h>
  30
  31#define AB3550_NAME_STRING "ab3550"
  32#define AB3550_ID_FORMAT_STRING "AB3550 %s"
  33#define AB3550_NUM_BANKS 2
  34#define AB3550_NUM_EVENT_REG 5
  35
  36/* These are the only registers inside AB3550 used in this main file */
  37
  38/* Chip ID register */
  39#define AB3550_CID_REG           0x20
  40
  41/* Interrupt event registers */
  42#define AB3550_EVENT_BANK        0
  43#define AB3550_EVENT_REG         0x22
  44
  45/* Read/write operation values. */
  46#define AB3550_PERM_RD (0x01)
  47#define AB3550_PERM_WR (0x02)
  48
  49/* Read/write permissions. */
  50#define AB3550_PERM_RO (AB3550_PERM_RD)
  51#define AB3550_PERM_RW (AB3550_PERM_RD | AB3550_PERM_WR)
  52
  53/**
  54 * struct ab3550
  55 * @access_mutex: lock out concurrent accesses to the AB registers
  56 * @i2c_client: I2C client for this chip
  57 * @chip_name: name of this chip variant
  58 * @chip_id: 8 bit chip ID for this chip variant
  59 * @mask_work: a worker for writing to mask registers
  60 * @event_lock: a lock to protect the event_mask
  61 * @event_mask: a local copy of the mask event registers
  62 * @startup_events: a copy of the first reading of the event registers
  63 * @startup_events_read: whether the first events have been read
  64 */
  65struct ab3550 {
  66        struct mutex access_mutex;
  67        struct i2c_client *i2c_client[AB3550_NUM_BANKS];
  68        char chip_name[32];
  69        u8 chip_id;
  70        struct work_struct mask_work;
  71        spinlock_t event_lock;
  72        u8 event_mask[AB3550_NUM_EVENT_REG];
  73        u8 startup_events[AB3550_NUM_EVENT_REG];
  74        bool startup_events_read;
  75#ifdef CONFIG_DEBUG_FS
  76        unsigned int debug_bank;
  77        unsigned int debug_address;
  78#endif
  79};
  80
  81/**
  82 * struct ab3550_reg_range
  83 * @first: the first address of the range
  84 * @last: the last address of the range
  85 * @perm: access permissions for the range
  86 */
  87struct ab3550_reg_range {
  88        u8 first;
  89        u8 last;
  90        u8 perm;
  91};
  92
  93/**
  94 * struct ab3550_reg_ranges
  95 * @count: the number of ranges in the list
  96 * @range: the list of register ranges
  97 */
  98struct ab3550_reg_ranges {
  99        u8 count;
 100        const struct ab3550_reg_range *range;
 101};
 102
 103/*
 104 * Permissible register ranges for reading and writing per device and bank.
 105 *
 106 * The ranges must be listed in increasing address order, and no overlaps are
 107 * allowed. It is assumed that write permission implies read permission
 108 * (i.e. only RO and RW permissions should be used).  Ranges with write
 109 * permission must not be split up.
 110 */
 111
 112#define NO_RANGE {.count = 0, .range = NULL,}
 113
 114static struct
 115ab3550_reg_ranges ab3550_reg_ranges[AB3550_NUM_DEVICES][AB3550_NUM_BANKS] = {
 116        [AB3550_DEVID_DAC] = {
 117                NO_RANGE,
 118                {
 119                        .count = 2,
 120                        .range = (struct ab3550_reg_range[]) {
 121                                {
 122                                        .first = 0xb0,
 123                                        .last = 0xba,
 124                                        .perm = AB3550_PERM_RW,
 125                                },
 126                                {
 127                                        .first = 0xbc,
 128                                        .last = 0xc3,
 129                                        .perm = AB3550_PERM_RW,
 130                                },
 131                        },
 132                },
 133        },
 134        [AB3550_DEVID_LEDS] = {
 135                NO_RANGE,
 136                {
 137                        .count = 2,
 138                        .range = (struct ab3550_reg_range[]) {
 139                                {
 140                                        .first = 0x5a,
 141                                        .last = 0x88,
 142                                        .perm = AB3550_PERM_RW,
 143                                },
 144                                {
 145                                        .first = 0x8a,
 146                                        .last = 0xad,
 147                                        .perm = AB3550_PERM_RW,
 148                                },
 149                        }
 150                },
 151        },
 152        [AB3550_DEVID_POWER] = {
 153                {
 154                        .count = 1,
 155                        .range = (struct ab3550_reg_range[]) {
 156                                {
 157                                        .first = 0x21,
 158                                        .last = 0x21,
 159                                        .perm = AB3550_PERM_RO,
 160                                },
 161                        }
 162                },
 163                NO_RANGE,
 164        },
 165        [AB3550_DEVID_REGULATORS] = {
 166                {
 167                        .count = 1,
 168                        .range = (struct ab3550_reg_range[]) {
 169                                {
 170                                        .first = 0x69,
 171                                        .last = 0xa3,
 172                                        .perm = AB3550_PERM_RW,
 173                                },
 174                        }
 175                },
 176                {
 177                        .count = 1,
 178                        .range = (struct ab3550_reg_range[]) {
 179                                {
 180                                        .first = 0x14,
 181                                        .last = 0x16,
 182                                        .perm = AB3550_PERM_RW,
 183                                },
 184                        }
 185                },
 186        },
 187        [AB3550_DEVID_SIM] = {
 188                {
 189                        .count = 1,
 190                        .range = (struct ab3550_reg_range[]) {
 191                                {
 192                                        .first = 0x21,
 193                                        .last = 0x21,
 194                                        .perm = AB3550_PERM_RO,
 195                                },
 196                        }
 197                },
 198                {
 199                        .count = 1,
 200                        .range = (struct ab3550_reg_range[]) {
 201                                {
 202                                        .first = 0x14,
 203                                        .last = 0x17,
 204                                        .perm = AB3550_PERM_RW,
 205                                },
 206                        }
 207
 208                },
 209        },
 210        [AB3550_DEVID_UART] = {
 211                NO_RANGE,
 212                NO_RANGE,
 213        },
 214        [AB3550_DEVID_RTC] = {
 215                {
 216                        .count = 1,
 217                        .range = (struct ab3550_reg_range[]) {
 218                                {
 219                                        .first = 0x00,
 220                                        .last = 0x0c,
 221                                        .perm = AB3550_PERM_RW,
 222                                },
 223                        }
 224                },
 225                NO_RANGE,
 226        },
 227        [AB3550_DEVID_CHARGER] = {
 228                {
 229                        .count = 2,
 230                        .range = (struct ab3550_reg_range[]) {
 231                                {
 232                                        .first = 0x10,
 233                                        .last = 0x1a,
 234                                        .perm = AB3550_PERM_RW,
 235                                },
 236                                {
 237                                        .first = 0x21,
 238                                        .last = 0x21,
 239                                        .perm = AB3550_PERM_RO,
 240                                },
 241                        }
 242                },
 243                NO_RANGE,
 244        },
 245        [AB3550_DEVID_ADC] = {
 246                NO_RANGE,
 247                {
 248                        .count = 1,
 249                        .range = (struct ab3550_reg_range[]) {
 250                                {
 251                                        .first = 0x20,
 252                                        .last = 0x56,
 253                                        .perm = AB3550_PERM_RW,
 254                                },
 255
 256                        }
 257                },
 258        },
 259        [AB3550_DEVID_FUELGAUGE] = {
 260                {
 261                        .count = 1,
 262                        .range = (struct ab3550_reg_range[]) {
 263                                {
 264                                        .first = 0x21,
 265                                        .last = 0x21,
 266                                        .perm = AB3550_PERM_RO,
 267                                },
 268                        }
 269                },
 270                {
 271                        .count = 1,
 272                        .range = (struct ab3550_reg_range[]) {
 273                                {
 274                                        .first = 0x00,
 275                                        .last = 0x0e,
 276                                        .perm = AB3550_PERM_RW,
 277                                },
 278                        }
 279                },
 280        },
 281        [AB3550_DEVID_VIBRATOR] = {
 282                NO_RANGE,
 283                {
 284                        .count = 1,
 285                        .range = (struct ab3550_reg_range[]) {
 286                                {
 287                                        .first = 0x10,
 288                                        .last = 0x13,
 289                                        .perm = AB3550_PERM_RW,
 290                                },
 291
 292                        }
 293                },
 294        },
 295        [AB3550_DEVID_CODEC] = {
 296                {
 297                        .count = 2,
 298                        .range = (struct ab3550_reg_range[]) {
 299                                {
 300                                        .first = 0x31,
 301                                        .last = 0x63,
 302                                        .perm = AB3550_PERM_RW,
 303                                },
 304                                {
 305                                        .first = 0x65,
 306                                        .last = 0x68,
 307                                        .perm = AB3550_PERM_RW,
 308                                },
 309                        }
 310                },
 311                NO_RANGE,
 312        },
 313};
 314
 315static struct mfd_cell ab3550_devs[AB3550_NUM_DEVICES] = {
 316        [AB3550_DEVID_DAC] = {
 317                .name = "ab3550-dac",
 318                .id = AB3550_DEVID_DAC,
 319                .num_resources = 0,
 320        },
 321        [AB3550_DEVID_LEDS] = {
 322                .name = "ab3550-leds",
 323                .id = AB3550_DEVID_LEDS,
 324        },
 325        [AB3550_DEVID_POWER] = {
 326                .name = "ab3550-power",
 327                .id = AB3550_DEVID_POWER,
 328        },
 329        [AB3550_DEVID_REGULATORS] = {
 330                .name = "ab3550-regulators",
 331                .id = AB3550_DEVID_REGULATORS,
 332        },
 333        [AB3550_DEVID_SIM] = {
 334                .name = "ab3550-sim",
 335                .id = AB3550_DEVID_SIM,
 336        },
 337        [AB3550_DEVID_UART] = {
 338                .name = "ab3550-uart",
 339                .id = AB3550_DEVID_UART,
 340        },
 341        [AB3550_DEVID_RTC] = {
 342                .name = "ab3550-rtc",
 343                .id = AB3550_DEVID_RTC,
 344        },
 345        [AB3550_DEVID_CHARGER] = {
 346                .name = "ab3550-charger",
 347                .id = AB3550_DEVID_CHARGER,
 348        },
 349        [AB3550_DEVID_ADC] = {
 350                .name = "ab3550-adc",
 351                .id = AB3550_DEVID_ADC,
 352                .num_resources = 10,
 353                .resources = (struct resource[]) {
 354                        {
 355                                .name = "TRIGGER-0",
 356                                .flags = IORESOURCE_IRQ,
 357                                .start = 16,
 358                                .end = 16,
 359                        },
 360                        {
 361                                .name = "TRIGGER-1",
 362                                .flags = IORESOURCE_IRQ,
 363                                .start = 17,
 364                                .end = 17,
 365                        },
 366                        {
 367                                .name = "TRIGGER-2",
 368                                .flags = IORESOURCE_IRQ,
 369                                .start = 18,
 370                                .end = 18,
 371                        },
 372                        {
 373                                .name = "TRIGGER-3",
 374                                .flags = IORESOURCE_IRQ,
 375                                .start = 19,
 376                                .end = 19,
 377                        },
 378                        {
 379                                .name = "TRIGGER-4",
 380                                .flags = IORESOURCE_IRQ,
 381                                .start = 20,
 382                                .end = 20,
 383                        },
 384                        {
 385                                .name = "TRIGGER-5",
 386                                .flags = IORESOURCE_IRQ,
 387                                .start = 21,
 388                                .end = 21,
 389                        },
 390                        {
 391                                .name = "TRIGGER-6",
 392                                .flags = IORESOURCE_IRQ,
 393                                .start = 22,
 394                                .end = 22,
 395                        },
 396                        {
 397                                .name = "TRIGGER-7",
 398                                .flags = IORESOURCE_IRQ,
 399                                .start = 23,
 400                                .end = 23,
 401                        },
 402                        {
 403                                .name = "TRIGGER-VBAT-TXON",
 404                                .flags = IORESOURCE_IRQ,
 405                                .start = 13,
 406                                .end = 13,
 407                        },
 408                        {
 409                                .name = "TRIGGER-VBAT",
 410                                .flags = IORESOURCE_IRQ,
 411                                .start = 12,
 412                                .end = 12,
 413                        },
 414                },
 415        },
 416        [AB3550_DEVID_FUELGAUGE] = {
 417                .name = "ab3550-fuelgauge",
 418                .id = AB3550_DEVID_FUELGAUGE,
 419        },
 420        [AB3550_DEVID_VIBRATOR] = {
 421                .name = "ab3550-vibrator",
 422                .id = AB3550_DEVID_VIBRATOR,
 423        },
 424        [AB3550_DEVID_CODEC] = {
 425                .name = "ab3550-codec",
 426                .id = AB3550_DEVID_CODEC,
 427        },
 428};
 429
 430/*
 431 * I2C transactions with error messages.
 432 */
 433static int ab3550_i2c_master_send(struct ab3550 *ab, u8 bank, u8 *data,
 434        u8 count)
 435{
 436        int err;
 437
 438        err = i2c_master_send(ab->i2c_client[bank], data, count);
 439        if (err < 0) {
 440                dev_err(&ab->i2c_client[0]->dev, "send error: %d\n", err);
 441                return err;
 442        }
 443        return 0;
 444}
 445
 446static int ab3550_i2c_master_recv(struct ab3550 *ab, u8 bank, u8 *data,
 447        u8 count)
 448{
 449        int err;
 450
 451        err = i2c_master_recv(ab->i2c_client[bank], data, count);
 452        if (err < 0) {
 453                dev_err(&ab->i2c_client[0]->dev, "receive error: %d\n", err);
 454                return err;
 455        }
 456        return 0;
 457}
 458
 459/*
 460 * Functionality for getting/setting register values.
 461 */
 462static int get_register_interruptible(struct ab3550 *ab, u8 bank, u8 reg,
 463        u8 *value)
 464{
 465        int err;
 466
 467        err = mutex_lock_interruptible(&ab->access_mutex);
 468        if (err)
 469                return err;
 470
 471        err = ab3550_i2c_master_send(ab, bank, &reg, 1);
 472        if (!err)
 473                err = ab3550_i2c_master_recv(ab, bank, value, 1);
 474
 475        mutex_unlock(&ab->access_mutex);
 476        return err;
 477}
 478
 479static int get_register_page_interruptible(struct ab3550 *ab, u8 bank,
 480        u8 first_reg, u8 *regvals, u8 numregs)
 481{
 482        int err;
 483
 484        err = mutex_lock_interruptible(&ab->access_mutex);
 485        if (err)
 486                return err;
 487
 488        err = ab3550_i2c_master_send(ab, bank, &first_reg, 1);
 489        if (!err)
 490                err = ab3550_i2c_master_recv(ab, bank, regvals, numregs);
 491
 492        mutex_unlock(&ab->access_mutex);
 493        return err;
 494}
 495
 496static int mask_and_set_register_interruptible(struct ab3550 *ab, u8 bank,
 497        u8 reg, u8 bitmask, u8 bitvalues)
 498{
 499        int err = 0;
 500
 501        if (likely(bitmask)) {
 502                u8 reg_bits[2] = {reg, 0};
 503
 504                err = mutex_lock_interruptible(&ab->access_mutex);
 505                if (err)
 506                        return err;
 507
 508                if (bitmask == 0xFF) /* No need to read in this case. */
 509                        reg_bits[1] = bitvalues;
 510                else { /* Read and modify the register value. */
 511                        u8 bits;
 512
 513                        err = ab3550_i2c_master_send(ab, bank, &reg, 1);
 514                        if (err)
 515                                goto unlock_and_return;
 516                        err = ab3550_i2c_master_recv(ab, bank, &bits, 1);
 517                        if (err)
 518                                goto unlock_and_return;
 519                        reg_bits[1] = ((~bitmask & bits) |
 520                                (bitmask & bitvalues));
 521                }
 522                /* Write the new value. */
 523                err = ab3550_i2c_master_send(ab, bank, reg_bits, 2);
 524unlock_and_return:
 525                mutex_unlock(&ab->access_mutex);
 526        }
 527        return err;
 528}
 529
 530/*
 531 * Read/write permission checking functions.
 532 */
 533static bool page_write_allowed(const struct ab3550_reg_ranges *ranges,
 534        u8 first_reg, u8 last_reg)
 535{
 536        u8 i;
 537
 538        if (last_reg < first_reg)
 539                return false;
 540
 541        for (i = 0; i < ranges->count; i++) {
 542                if (first_reg < ranges->range[i].first)
 543                        break;
 544                if ((last_reg <= ranges->range[i].last) &&
 545                        (ranges->range[i].perm & AB3550_PERM_WR))
 546                        return true;
 547        }
 548        return false;
 549}
 550
 551static bool reg_write_allowed(const struct ab3550_reg_ranges *ranges, u8 reg)
 552{
 553        return page_write_allowed(ranges, reg, reg);
 554}
 555
 556static bool page_read_allowed(const struct ab3550_reg_ranges *ranges,
 557        u8 first_reg, u8 last_reg)
 558{
 559        u8 i;
 560
 561        if (last_reg < first_reg)
 562                return false;
 563        /* Find the range (if it exists in the list) that includes first_reg. */
 564        for (i = 0; i < ranges->count; i++) {
 565                if (first_reg < ranges->range[i].first)
 566                        return false;
 567                if (first_reg <= ranges->range[i].last)
 568                        break;
 569        }
 570        /* Make sure that the entire range up to and including last_reg is
 571         * readable. This may span several of the ranges in the list.
 572         */
 573        while ((i < ranges->count) &&
 574                (ranges->range[i].perm & AB3550_PERM_RD)) {
 575                if (last_reg <= ranges->range[i].last)
 576                        return true;
 577                if ((++i >= ranges->count) ||
 578                        (ranges->range[i].first !=
 579                         (ranges->range[i - 1].last + 1))) {
 580                        break;
 581                }
 582        }
 583        return false;
 584}
 585
 586static bool reg_read_allowed(const struct ab3550_reg_ranges *ranges, u8 reg)
 587{
 588        return page_read_allowed(ranges, reg, reg);
 589}
 590
 591/*
 592 * The register access functionality.
 593 */
 594static int ab3550_get_chip_id(struct device *dev)
 595{
 596        struct ab3550 *ab = dev_get_drvdata(dev->parent);
 597        return (int)ab->chip_id;
 598}
 599
 600static int ab3550_mask_and_set_register_interruptible(struct device *dev,
 601        u8 bank, u8 reg, u8 bitmask, u8 bitvalues)
 602{
 603        struct ab3550 *ab;
 604        struct platform_device *pdev = to_platform_device(dev);
 605
 606        if ((AB3550_NUM_BANKS <= bank) ||
 607                !reg_write_allowed(&ab3550_reg_ranges[pdev->id][bank], reg))
 608                return -EINVAL;
 609
 610        ab = dev_get_drvdata(dev->parent);
 611        return mask_and_set_register_interruptible(ab, bank, reg,
 612                bitmask, bitvalues);
 613}
 614
 615static int ab3550_set_register_interruptible(struct device *dev, u8 bank,
 616        u8 reg, u8 value)
 617{
 618        return ab3550_mask_and_set_register_interruptible(dev, bank, reg, 0xFF,
 619                value);
 620}
 621
 622static int ab3550_get_register_interruptible(struct device *dev, u8 bank,
 623        u8 reg, u8 *value)
 624{
 625        struct ab3550 *ab;
 626        struct platform_device *pdev = to_platform_device(dev);
 627
 628        if ((AB3550_NUM_BANKS <= bank) ||
 629                !reg_read_allowed(&ab3550_reg_ranges[pdev->id][bank], reg))
 630                return -EINVAL;
 631
 632        ab = dev_get_drvdata(dev->parent);
 633        return get_register_interruptible(ab, bank, reg, value);
 634}
 635
 636static int ab3550_get_register_page_interruptible(struct device *dev, u8 bank,
 637        u8 first_reg, u8 *regvals, u8 numregs)
 638{
 639        struct ab3550 *ab;
 640        struct platform_device *pdev = to_platform_device(dev);
 641
 642        if ((AB3550_NUM_BANKS <= bank) ||
 643                !page_read_allowed(&ab3550_reg_ranges[pdev->id][bank],
 644                        first_reg, (first_reg + numregs - 1)))
 645                return -EINVAL;
 646
 647        ab = dev_get_drvdata(dev->parent);
 648        return get_register_page_interruptible(ab, bank, first_reg, regvals,
 649                numregs);
 650}
 651
 652static int ab3550_event_registers_startup_state_get(struct device *dev,
 653        u8 *event)
 654{
 655        struct ab3550 *ab;
 656
 657        ab = dev_get_drvdata(dev->parent);
 658        if (!ab->startup_events_read)
 659                return -EAGAIN; /* Try again later */
 660
 661        memcpy(event, ab->startup_events, AB3550_NUM_EVENT_REG);
 662        return 0;
 663}
 664
 665static int ab3550_startup_irq_enabled(struct device *dev, unsigned int irq)
 666{
 667        struct ab3550 *ab;
 668        struct ab3550_platform_data *plf_data;
 669        bool val;
 670
 671        ab = irq_get_chip_data(irq);
 672        plf_data = ab->i2c_client[0]->dev.platform_data;
 673        irq -= plf_data->irq.base;
 674        val = ((ab->startup_events[irq / 8] & BIT(irq % 8)) != 0);
 675
 676        return val;
 677}
 678
 679static struct abx500_ops ab3550_ops = {
 680        .get_chip_id = ab3550_get_chip_id,
 681        .get_register = ab3550_get_register_interruptible,
 682        .set_register = ab3550_set_register_interruptible,
 683        .get_register_page = ab3550_get_register_page_interruptible,
 684        .set_register_page = NULL,
 685        .mask_and_set_register = ab3550_mask_and_set_register_interruptible,
 686        .event_registers_startup_state_get =
 687                ab3550_event_registers_startup_state_get,
 688        .startup_irq_enabled = ab3550_startup_irq_enabled,
 689};
 690
 691static irqreturn_t ab3550_irq_handler(int irq, void *data)
 692{
 693        struct ab3550 *ab = data;
 694        int err;
 695        unsigned int i;
 696        u8 e[AB3550_NUM_EVENT_REG];
 697        u8 *events;
 698        unsigned long flags;
 699
 700        events = (ab->startup_events_read ? e : ab->startup_events);
 701
 702        err = get_register_page_interruptible(ab, AB3550_EVENT_BANK,
 703                AB3550_EVENT_REG, events, AB3550_NUM_EVENT_REG);
 704        if (err)
 705                goto err_event_rd;
 706
 707        if (!ab->startup_events_read) {
 708                dev_info(&ab->i2c_client[0]->dev,
 709                        "startup events 0x%x,0x%x,0x%x,0x%x,0x%x\n",
 710                        ab->startup_events[0], ab->startup_events[1],
 711                        ab->startup_events[2], ab->startup_events[3],
 712                        ab->startup_events[4]);
 713                ab->startup_events_read = true;
 714                goto out;
 715        }
 716
 717        /* The two highest bits in event[4] are not used. */
 718        events[4] &= 0x3f;
 719
 720        spin_lock_irqsave(&ab->event_lock, flags);
 721        for (i = 0; i < AB3550_NUM_EVENT_REG; i++)
 722                events[i] &= ~ab->event_mask[i];
 723        spin_unlock_irqrestore(&ab->event_lock, flags);
 724
 725        for (i = 0; i < AB3550_NUM_EVENT_REG; i++) {
 726                u8 bit;
 727                u8 event_reg;
 728
 729                dev_dbg(&ab->i2c_client[0]->dev, "IRQ Event[%d]: 0x%2x\n",
 730                        i, events[i]);
 731
 732                event_reg = events[i];
 733                for (bit = 0; event_reg; bit++, event_reg /= 2) {
 734                        if (event_reg % 2) {
 735                                unsigned int irq;
 736                                struct ab3550_platform_data *plf_data;
 737
 738                                plf_data = ab->i2c_client[0]->dev.platform_data;
 739                                irq = plf_data->irq.base + (i * 8) + bit;
 740                                handle_nested_irq(irq);
 741                        }
 742                }
 743        }
 744out:
 745        return IRQ_HANDLED;
 746
 747err_event_rd:
 748        dev_dbg(&ab->i2c_client[0]->dev, "error reading event registers\n");
 749        return IRQ_HANDLED;
 750}
 751
 752#ifdef CONFIG_DEBUG_FS
 753static struct ab3550_reg_ranges debug_ranges[AB3550_NUM_BANKS] = {
 754        {
 755                .count = 6,
 756                .range = (struct ab3550_reg_range[]) {
 757                        {
 758                                .first = 0x00,
 759                                .last = 0x0e,
 760                        },
 761                        {
 762                                .first = 0x10,
 763                                .last = 0x1a,
 764                        },
 765                        {
 766                                .first = 0x1e,
 767                                .last = 0x4f,
 768                        },
 769                        {
 770                                .first = 0x51,
 771                                .last = 0x63,
 772                        },
 773                        {
 774                                .first = 0x65,
 775                                .last = 0xa3,
 776                        },
 777                        {
 778                                .first = 0xa5,
 779                                .last = 0xa8,
 780                        },
 781                }
 782        },
 783        {
 784                .count = 8,
 785                .range = (struct ab3550_reg_range[]) {
 786                        {
 787                                .first = 0x00,
 788                                .last = 0x0e,
 789                        },
 790                        {
 791                                .first = 0x10,
 792                                .last = 0x17,
 793                        },
 794                        {
 795                                .first = 0x1a,
 796                                .last = 0x1c,
 797                        },
 798                        {
 799                                .first = 0x20,
 800                                .last = 0x56,
 801                        },
 802                        {
 803                                .first = 0x5a,
 804                                .last = 0x88,
 805                        },
 806                        {
 807                                .first = 0x8a,
 808                                .last = 0xad,
 809                        },
 810                        {
 811                                .first = 0xb0,
 812                                .last = 0xba,
 813                        },
 814                        {
 815                                .first = 0xbc,
 816                                .last = 0xc3,
 817                        },
 818                }
 819        },
 820};
 821
 822static int ab3550_registers_print(struct seq_file *s, void *p)
 823{
 824        struct ab3550 *ab = s->private;
 825        int bank;
 826
 827        seq_printf(s, AB3550_NAME_STRING " register values:\n");
 828
 829        for (bank = 0; bank < AB3550_NUM_BANKS; bank++) {
 830                unsigned int i;
 831
 832                seq_printf(s, " bank %d:\n", bank);
 833                for (i = 0; i < debug_ranges[bank].count; i++) {
 834                        u8 reg;
 835
 836                        for (reg = debug_ranges[bank].range[i].first;
 837                                reg <= debug_ranges[bank].range[i].last;
 838                                reg++) {
 839                                u8 value;
 840
 841                                get_register_interruptible(ab, bank, reg,
 842                                        &value);
 843                                seq_printf(s, "  [%d/0x%02X]: 0x%02X\n", bank,
 844                                        reg, value);
 845                        }
 846                }
 847        }
 848        return 0;
 849}
 850
 851static int ab3550_registers_open(struct inode *inode, struct file *file)
 852{
 853        return single_open(file, ab3550_registers_print, inode->i_private);
 854}
 855
 856static const struct file_operations ab3550_registers_fops = {
 857        .open = ab3550_registers_open,
 858        .read = seq_read,
 859        .llseek = seq_lseek,
 860        .release = single_release,
 861        .owner = THIS_MODULE,
 862};
 863
 864static int ab3550_bank_print(struct seq_file *s, void *p)
 865{
 866        struct ab3550 *ab = s->private;
 867
 868        seq_printf(s, "%d\n", ab->debug_bank);
 869        return 0;
 870}
 871
 872static int ab3550_bank_open(struct inode *inode, struct file *file)
 873{
 874        return single_open(file, ab3550_bank_print, inode->i_private);
 875}
 876
 877static ssize_t ab3550_bank_write(struct file *file,
 878        const char __user *user_buf,
 879        size_t count, loff_t *ppos)
 880{
 881        struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
 882        char buf[32];
 883        int buf_size;
 884        unsigned long user_bank;
 885        int err;
 886
 887        /* Get userspace string and assure termination */
 888        buf_size = min(count, (sizeof(buf) - 1));
 889        if (copy_from_user(buf, user_buf, buf_size))
 890                return -EFAULT;
 891        buf[buf_size] = 0;
 892
 893        err = strict_strtoul(buf, 0, &user_bank);
 894        if (err)
 895                return -EINVAL;
 896
 897        if (user_bank >= AB3550_NUM_BANKS) {
 898                dev_err(&ab->i2c_client[0]->dev,
 899                        "debugfs error input > number of banks\n");
 900                return -EINVAL;
 901        }
 902
 903        ab->debug_bank = user_bank;
 904
 905        return buf_size;
 906}
 907
 908static int ab3550_address_print(struct seq_file *s, void *p)
 909{
 910        struct ab3550 *ab = s->private;
 911
 912        seq_printf(s, "0x%02X\n", ab->debug_address);
 913        return 0;
 914}
 915
 916static int ab3550_address_open(struct inode *inode, struct file *file)
 917{
 918        return single_open(file, ab3550_address_print, inode->i_private);
 919}
 920
 921static ssize_t ab3550_address_write(struct file *file,
 922        const char __user *user_buf,
 923        size_t count, loff_t *ppos)
 924{
 925        struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
 926        char buf[32];
 927        int buf_size;
 928        unsigned long user_address;
 929        int err;
 930
 931        /* Get userspace string and assure termination */
 932        buf_size = min(count, (sizeof(buf) - 1));
 933        if (copy_from_user(buf, user_buf, buf_size))
 934                return -EFAULT;
 935        buf[buf_size] = 0;
 936
 937        err = strict_strtoul(buf, 0, &user_address);
 938        if (err)
 939                return -EINVAL;
 940        if (user_address > 0xff) {
 941                dev_err(&ab->i2c_client[0]->dev,
 942                        "debugfs error input > 0xff\n");
 943                return -EINVAL;
 944        }
 945        ab->debug_address = user_address;
 946        return buf_size;
 947}
 948
 949static int ab3550_val_print(struct seq_file *s, void *p)
 950{
 951        struct ab3550 *ab = s->private;
 952        int err;
 953        u8 regvalue;
 954
 955        err = get_register_interruptible(ab, (u8)ab->debug_bank,
 956                (u8)ab->debug_address, &regvalue);
 957        if (err)
 958                return -EINVAL;
 959        seq_printf(s, "0x%02X\n", regvalue);
 960
 961        return 0;
 962}
 963
 964static int ab3550_val_open(struct inode *inode, struct file *file)
 965{
 966        return single_open(file, ab3550_val_print, inode->i_private);
 967}
 968
 969static ssize_t ab3550_val_write(struct file *file,
 970        const char __user *user_buf,
 971        size_t count, loff_t *ppos)
 972{
 973        struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
 974        char buf[32];
 975        int buf_size;
 976        unsigned long user_val;
 977        int err;
 978        u8 regvalue;
 979
 980        /* Get userspace string and assure termination */
 981        buf_size = min(count, (sizeof(buf)-1));
 982        if (copy_from_user(buf, user_buf, buf_size))
 983                return -EFAULT;
 984        buf[buf_size] = 0;
 985
 986        err = strict_strtoul(buf, 0, &user_val);
 987        if (err)
 988                return -EINVAL;
 989        if (user_val > 0xff) {
 990                dev_err(&ab->i2c_client[0]->dev,
 991                        "debugfs error input > 0xff\n");
 992                return -EINVAL;
 993        }
 994        err = mask_and_set_register_interruptible(
 995                ab, (u8)ab->debug_bank,
 996                (u8)ab->debug_address, 0xFF, (u8)user_val);
 997        if (err)
 998                return -EINVAL;
 999
1000        get_register_interruptible(ab, (u8)ab->debug_bank,
1001                (u8)ab->debug_address, &regvalue);
1002        if (err)
1003                return -EINVAL;
1004
1005        return buf_size;
1006}
1007
1008static const struct file_operations ab3550_bank_fops = {
1009        .open = ab3550_bank_open,
1010        .write = ab3550_bank_write,
1011        .read = seq_read,
1012        .llseek = seq_lseek,
1013        .release = single_release,
1014        .owner = THIS_MODULE,
1015};
1016
1017static const struct file_operations ab3550_address_fops = {
1018        .open = ab3550_address_open,
1019        .write = ab3550_address_write,
1020        .read = seq_read,
1021        .llseek = seq_lseek,
1022        .release = single_release,
1023        .owner = THIS_MODULE,
1024};
1025
1026static const struct file_operations ab3550_val_fops = {
1027        .open = ab3550_val_open,
1028        .write = ab3550_val_write,
1029        .read = seq_read,
1030        .llseek = seq_lseek,
1031        .release = single_release,
1032        .owner = THIS_MODULE,
1033};
1034
1035static struct dentry *ab3550_dir;
1036static struct dentry *ab3550_reg_file;
1037static struct dentry *ab3550_bank_file;
1038static struct dentry *ab3550_address_file;
1039static struct dentry *ab3550_val_file;
1040
1041static inline void ab3550_setup_debugfs(struct ab3550 *ab)
1042{
1043        ab->debug_bank = 0;
1044        ab->debug_address = 0x00;
1045
1046        ab3550_dir = debugfs_create_dir(AB3550_NAME_STRING, NULL);
1047        if (!ab3550_dir)
1048                goto exit_no_debugfs;
1049
1050        ab3550_reg_file = debugfs_create_file("all-registers",
1051                S_IRUGO, ab3550_dir, ab, &ab3550_registers_fops);
1052        if (!ab3550_reg_file)
1053                goto exit_destroy_dir;
1054
1055        ab3550_bank_file = debugfs_create_file("register-bank",
1056                (S_IRUGO | S_IWUSR), ab3550_dir, ab, &ab3550_bank_fops);
1057        if (!ab3550_bank_file)
1058                goto exit_destroy_reg;
1059
1060        ab3550_address_file = debugfs_create_file("register-address",
1061                (S_IRUGO | S_IWUSR), ab3550_dir, ab, &ab3550_address_fops);
1062        if (!ab3550_address_file)
1063                goto exit_destroy_bank;
1064
1065        ab3550_val_file = debugfs_create_file("register-value",
1066                (S_IRUGO | S_IWUSR), ab3550_dir, ab, &ab3550_val_fops);
1067        if (!ab3550_val_file)
1068                goto exit_destroy_address;
1069
1070        return;
1071
1072exit_destroy_address:
1073        debugfs_remove(ab3550_address_file);
1074exit_destroy_bank:
1075        debugfs_remove(ab3550_bank_file);
1076exit_destroy_reg:
1077        debugfs_remove(ab3550_reg_file);
1078exit_destroy_dir:
1079        debugfs_remove(ab3550_dir);
1080exit_no_debugfs:
1081        dev_err(&ab->i2c_client[0]->dev, "failed to create debugfs entries.\n");
1082        return;
1083}
1084
1085static inline void ab3550_remove_debugfs(void)
1086{
1087        debugfs_remove(ab3550_val_file);
1088        debugfs_remove(ab3550_address_file);
1089        debugfs_remove(ab3550_bank_file);
1090        debugfs_remove(ab3550_reg_file);
1091        debugfs_remove(ab3550_dir);
1092}
1093
1094#else /* !CONFIG_DEBUG_FS */
1095static inline void ab3550_setup_debugfs(struct ab3550 *ab)
1096{
1097}
1098static inline void ab3550_remove_debugfs(void)
1099{
1100}
1101#endif
1102
1103/*
1104 * Basic set-up, datastructure creation/destruction and I2C interface.
1105 * This sets up a default config in the AB3550 chip so that it
1106 * will work as expected.
1107 */
1108static int __init ab3550_setup(struct ab3550 *ab)
1109{
1110        int err = 0;
1111        int i;
1112        struct ab3550_platform_data *plf_data;
1113        struct abx500_init_settings *settings;
1114
1115        plf_data = ab->i2c_client[0]->dev.platform_data;
1116        settings = plf_data->init_settings;
1117
1118        for (i = 0; i < plf_data->init_settings_sz; i++) {
1119                err = mask_and_set_register_interruptible(ab,
1120                        settings[i].bank,
1121                        settings[i].reg,
1122                        0xFF, settings[i].setting);
1123                if (err)
1124                        goto exit_no_setup;
1125
1126                /* If event mask register update the event mask in ab3550 */
1127                if ((settings[i].bank == 0) &&
1128                        (AB3550_IMR1 <= settings[i].reg) &&
1129                        (settings[i].reg <= AB3550_IMR5)) {
1130                        ab->event_mask[settings[i].reg - AB3550_IMR1] =
1131                                settings[i].setting;
1132                }
1133        }
1134exit_no_setup:
1135        return err;
1136}
1137
1138static void ab3550_mask_work(struct work_struct *work)
1139{
1140        struct ab3550 *ab = container_of(work, struct ab3550, mask_work);
1141        int i;
1142        unsigned long flags;
1143        u8 mask[AB3550_NUM_EVENT_REG];
1144
1145        spin_lock_irqsave(&ab->event_lock, flags);
1146        for (i = 0; i < AB3550_NUM_EVENT_REG; i++)
1147                mask[i] = ab->event_mask[i];
1148        spin_unlock_irqrestore(&ab->event_lock, flags);
1149
1150        for (i = 0; i < AB3550_NUM_EVENT_REG; i++) {
1151                int err;
1152
1153                err = mask_and_set_register_interruptible(ab, 0,
1154                        (AB3550_IMR1 + i), ~0, mask[i]);
1155                if (err)
1156                        dev_err(&ab->i2c_client[0]->dev,
1157                                "ab3550_mask_work failed 0x%x,0x%x\n",
1158                                (AB3550_IMR1 + i), mask[i]);
1159        }
1160}
1161
1162static void ab3550_mask(struct irq_data *data)
1163{
1164        unsigned long flags;
1165        struct ab3550 *ab;
1166        struct ab3550_platform_data *plf_data;
1167        int irq;
1168
1169        ab = irq_data_get_irq_chip_data(data);
1170        plf_data = ab->i2c_client[0]->dev.platform_data;
1171        irq = data->irq - plf_data->irq.base;
1172
1173        spin_lock_irqsave(&ab->event_lock, flags);
1174        ab->event_mask[irq / 8] |= BIT(irq % 8);
1175        spin_unlock_irqrestore(&ab->event_lock, flags);
1176
1177        schedule_work(&ab->mask_work);
1178}
1179
1180static void ab3550_unmask(struct irq_data *data)
1181{
1182        unsigned long flags;
1183        struct ab3550 *ab;
1184        struct ab3550_platform_data *plf_data;
1185        int irq;
1186
1187        ab = irq_data_get_irq_chip_data(data);
1188        plf_data = ab->i2c_client[0]->dev.platform_data;
1189        irq = data->irq - plf_data->irq.base;
1190
1191        spin_lock_irqsave(&ab->event_lock, flags);
1192        ab->event_mask[irq / 8] &= ~BIT(irq % 8);
1193        spin_unlock_irqrestore(&ab->event_lock, flags);
1194
1195        schedule_work(&ab->mask_work);
1196}
1197
1198static void noop(struct irq_data *data)
1199{
1200}
1201
1202static struct irq_chip ab3550_irq_chip = {
1203        .name           = "ab3550-core", /* Keep the same name as the request */
1204        .irq_disable    = ab3550_mask, /* No default to mask in chip.c */
1205        .irq_ack        = noop,
1206        .irq_mask       = ab3550_mask,
1207        .irq_unmask     = ab3550_unmask,
1208};
1209
1210struct ab_family_id {
1211        u8      id;
1212        char    *name;
1213};
1214
1215static const struct ab_family_id ids[] __initdata = {
1216        /* AB3550 */
1217        {
1218                .id = AB3550_P1A,
1219                .name = "P1A"
1220        },
1221        /* Terminator */
1222        {
1223                .id = 0x00,
1224        }
1225};
1226
1227static int __init ab3550_probe(struct i2c_client *client,
1228        const struct i2c_device_id *id)
1229{
1230        struct ab3550 *ab;
1231        struct ab3550_platform_data *ab3550_plf_data =
1232                client->dev.platform_data;
1233        int err;
1234        int i;
1235        int num_i2c_clients = 0;
1236
1237        ab = kzalloc(sizeof(struct ab3550), GFP_KERNEL);
1238        if (!ab) {
1239                dev_err(&client->dev,
1240                        "could not allocate " AB3550_NAME_STRING " device\n");
1241                return -ENOMEM;
1242        }
1243
1244        /* Initialize data structure */
1245        mutex_init(&ab->access_mutex);
1246        spin_lock_init(&ab->event_lock);
1247        ab->i2c_client[0] = client;
1248
1249        i2c_set_clientdata(client, ab);
1250
1251        /* Read chip ID register */
1252        err = get_register_interruptible(ab, 0, AB3550_CID_REG, &ab->chip_id);
1253        if (err) {
1254                dev_err(&client->dev, "could not communicate with the analog "
1255                        "baseband chip\n");
1256                goto exit_no_detect;
1257        }
1258
1259        for (i = 0; ids[i].id != 0x0; i++) {
1260                if (ids[i].id == ab->chip_id) {
1261                        snprintf(&ab->chip_name[0], sizeof(ab->chip_name) - 1,
1262                                AB3550_ID_FORMAT_STRING, ids[i].name);
1263                        break;
1264                }
1265        }
1266
1267        if (ids[i].id == 0x0) {
1268                dev_err(&client->dev, "unknown analog baseband chip id: 0x%x\n",
1269                        ab->chip_id);
1270                dev_err(&client->dev, "driver not started!\n");
1271                goto exit_no_detect;
1272        }
1273
1274        dev_info(&client->dev, "detected AB chip: %s\n", &ab->chip_name[0]);
1275
1276        /* Attach other dummy I2C clients. */
1277        while (++num_i2c_clients < AB3550_NUM_BANKS) {
1278                ab->i2c_client[num_i2c_clients] =
1279                        i2c_new_dummy(client->adapter,
1280                                (client->addr + num_i2c_clients));
1281                if (!ab->i2c_client[num_i2c_clients]) {
1282                        err = -ENOMEM;
1283                        goto exit_no_dummy_client;
1284                }
1285                strlcpy(ab->i2c_client[num_i2c_clients]->name, id->name,
1286                        sizeof(ab->i2c_client[num_i2c_clients]->name));
1287        }
1288
1289        err = ab3550_setup(ab);
1290        if (err)
1291                goto exit_no_setup;
1292
1293        INIT_WORK(&ab->mask_work, ab3550_mask_work);
1294
1295        for (i = 0; i < ab3550_plf_data->irq.count; i++) {
1296                unsigned int irq;
1297
1298                irq = ab3550_plf_data->irq.base + i;
1299                irq_set_chip_data(irq, ab);
1300                irq_set_chip_and_handler(irq, &ab3550_irq_chip,
1301                                         handle_simple_irq);
1302                irq_set_nested_thread(irq, 1);
1303#ifdef CONFIG_ARM
1304                set_irq_flags(irq, IRQF_VALID);
1305#else
1306                irq_set_noprobe(irq);
1307#endif
1308        }
1309
1310        err = request_threaded_irq(client->irq, NULL, ab3550_irq_handler,
1311                IRQF_ONESHOT, "ab3550-core", ab);
1312        /* This real unpredictable IRQ is of course sampled for entropy */
1313        rand_initialize_irq(client->irq);
1314
1315        if (err)
1316                goto exit_no_irq;
1317
1318        err = abx500_register_ops(&client->dev, &ab3550_ops);
1319        if (err)
1320                goto exit_no_ops;
1321
1322        /* Set up and register the platform devices. */
1323        for (i = 0; i < AB3550_NUM_DEVICES; i++)
1324                ab3550_devs[i].mfd_data = ab3550_plf_data->dev_data[i];
1325
1326        err = mfd_add_devices(&client->dev, 0, ab3550_devs,
1327                ARRAY_SIZE(ab3550_devs), NULL,
1328                ab3550_plf_data->irq.base);
1329
1330        ab3550_setup_debugfs(ab);
1331
1332        return 0;
1333
1334exit_no_ops:
1335exit_no_irq:
1336exit_no_setup:
1337exit_no_dummy_client:
1338        /* Unregister the dummy i2c clients. */
1339        while (--num_i2c_clients)
1340                i2c_unregister_device(ab->i2c_client[num_i2c_clients]);
1341exit_no_detect:
1342        kfree(ab);
1343        return err;
1344}
1345
1346static int __exit ab3550_remove(struct i2c_client *client)
1347{
1348        struct ab3550 *ab = i2c_get_clientdata(client);
1349        int num_i2c_clients = AB3550_NUM_BANKS;
1350
1351        mfd_remove_devices(&client->dev);
1352        ab3550_remove_debugfs();
1353
1354        while (--num_i2c_clients)
1355                i2c_unregister_device(ab->i2c_client[num_i2c_clients]);
1356
1357        /*
1358         * At this point, all subscribers should have unregistered
1359         * their notifiers so deactivate IRQ
1360         */
1361        free_irq(client->irq, ab);
1362        kfree(ab);
1363        return 0;
1364}
1365
1366static const struct i2c_device_id ab3550_id[] = {
1367        {AB3550_NAME_STRING, 0},
1368        {}
1369};
1370MODULE_DEVICE_TABLE(i2c, ab3550_id);
1371
1372static struct i2c_driver ab3550_driver = {
1373        .driver = {
1374                .name   = AB3550_NAME_STRING,
1375                .owner  = THIS_MODULE,
1376        },
1377        .id_table       = ab3550_id,
1378        .probe          = ab3550_probe,
1379        .remove         = __exit_p(ab3550_remove),
1380};
1381
1382static int __init ab3550_i2c_init(void)
1383{
1384        return i2c_add_driver(&ab3550_driver);
1385}
1386
1387static void __exit ab3550_i2c_exit(void)
1388{
1389        i2c_del_driver(&ab3550_driver);
1390}
1391
1392subsys_initcall(ab3550_i2c_init);
1393module_exit(ab3550_i2c_exit);
1394
1395MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
1396MODULE_DESCRIPTION("AB3550 core driver");
1397MODULE_LICENSE("GPL");
1398