linux/drivers/mfd/ab3100-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 AB3100 IC on the I2C bus
   5 * and some basic chip-configuration.
   6 * Author: Linus Walleij <linus.walleij@stericsson.com>
   7 */
   8
   9#include <linux/i2c.h>
  10#include <linux/mutex.h>
  11#include <linux/list.h>
  12#include <linux/notifier.h>
  13#include <linux/slab.h>
  14#include <linux/err.h>
  15#include <linux/module.h>
  16#include <linux/platform_device.h>
  17#include <linux/device.h>
  18#include <linux/interrupt.h>
  19#include <linux/random.h>
  20#include <linux/debugfs.h>
  21#include <linux/seq_file.h>
  22#include <linux/uaccess.h>
  23#include <linux/mfd/core.h>
  24#include <linux/mfd/abx500.h>
  25
  26/* These are the only registers inside AB3100 used in this main file */
  27
  28/* Interrupt event registers */
  29#define AB3100_EVENTA1          0x21
  30#define AB3100_EVENTA2          0x22
  31#define AB3100_EVENTA3          0x23
  32
  33/* AB3100 DAC converter registers */
  34#define AB3100_DIS              0x00
  35#define AB3100_D0C              0x01
  36#define AB3100_D1C              0x02
  37#define AB3100_D2C              0x03
  38#define AB3100_D3C              0x04
  39
  40/* Chip ID register */
  41#define AB3100_CID              0x20
  42
  43/* AB3100 interrupt registers */
  44#define AB3100_IMRA1            0x24
  45#define AB3100_IMRA2            0x25
  46#define AB3100_IMRA3            0x26
  47#define AB3100_IMRB1            0x2B
  48#define AB3100_IMRB2            0x2C
  49#define AB3100_IMRB3            0x2D
  50
  51/* System Power Monitoring and control registers */
  52#define AB3100_MCA              0x2E
  53#define AB3100_MCB              0x2F
  54
  55/* SIM power up */
  56#define AB3100_SUP              0x50
  57
  58/*
  59 * I2C communication
  60 *
  61 * The AB3100 is usually assigned address 0x48 (7-bit)
  62 * The chip is defined in the platform i2c_board_data section.
  63 */
  64static int ab3100_get_chip_id(struct device *dev)
  65{
  66        struct ab3100 *ab3100 = dev_get_drvdata(dev->parent);
  67
  68        return (int)ab3100->chip_id;
  69}
  70
  71static int ab3100_set_register_interruptible(struct ab3100 *ab3100,
  72        u8 reg, u8 regval)
  73{
  74        u8 regandval[2] = {reg, regval};
  75        int err;
  76
  77        err = mutex_lock_interruptible(&ab3100->access_mutex);
  78        if (err)
  79                return err;
  80
  81        /*
  82         * A two-byte write message with the first byte containing the register
  83         * number and the second byte containing the value to be written
  84         * effectively sets a register in the AB3100.
  85         */
  86        err = i2c_master_send(ab3100->i2c_client, regandval, 2);
  87        if (err < 0) {
  88                dev_err(ab3100->dev,
  89                        "write error (write register): %d\n",
  90                        err);
  91        } else if (err != 2) {
  92                dev_err(ab3100->dev,
  93                        "write error (write register) "
  94                        "%d bytes transferred (expected 2)\n",
  95                        err);
  96                err = -EIO;
  97        } else {
  98                /* All is well */
  99                err = 0;
 100        }
 101        mutex_unlock(&ab3100->access_mutex);
 102        return err;
 103}
 104
 105static int set_register_interruptible(struct device *dev,
 106        u8 bank, u8 reg, u8 value)
 107{
 108        struct ab3100 *ab3100 = dev_get_drvdata(dev->parent);
 109
 110        return ab3100_set_register_interruptible(ab3100, reg, value);
 111}
 112
 113/*
 114 * The test registers exist at an I2C bus address up one
 115 * from the ordinary base. They are not supposed to be used
 116 * in production code, but sometimes you have to do that
 117 * anyway. It's currently only used from this file so declare
 118 * it static and do not export.
 119 */
 120static int ab3100_set_test_register_interruptible(struct ab3100 *ab3100,
 121                                    u8 reg, u8 regval)
 122{
 123        u8 regandval[2] = {reg, regval};
 124        int err;
 125
 126        err = mutex_lock_interruptible(&ab3100->access_mutex);
 127        if (err)
 128                return err;
 129
 130        err = i2c_master_send(ab3100->testreg_client, regandval, 2);
 131        if (err < 0) {
 132                dev_err(ab3100->dev,
 133                        "write error (write test register): %d\n",
 134                        err);
 135        } else if (err != 2) {
 136                dev_err(ab3100->dev,
 137                        "write error (write test register) "
 138                        "%d bytes transferred (expected 2)\n",
 139                        err);
 140                err = -EIO;
 141        } else {
 142                /* All is well */
 143                err = 0;
 144        }
 145        mutex_unlock(&ab3100->access_mutex);
 146
 147        return err;
 148}
 149
 150static int ab3100_get_register_interruptible(struct ab3100 *ab3100,
 151                                             u8 reg, u8 *regval)
 152{
 153        int err;
 154
 155        err = mutex_lock_interruptible(&ab3100->access_mutex);
 156        if (err)
 157                return err;
 158
 159        /*
 160         * AB3100 require an I2C "stop" command between each message, else
 161         * it will not work. The only way of achieveing this with the
 162         * message transport layer is to send the read and write messages
 163         * separately.
 164         */
 165        err = i2c_master_send(ab3100->i2c_client, &reg, 1);
 166        if (err < 0) {
 167                dev_err(ab3100->dev,
 168                        "write error (send register address): %d\n",
 169                        err);
 170                goto get_reg_out_unlock;
 171        } else if (err != 1) {
 172                dev_err(ab3100->dev,
 173                        "write error (send register address) "
 174                        "%d bytes transferred (expected 1)\n",
 175                        err);
 176                err = -EIO;
 177                goto get_reg_out_unlock;
 178        } else {
 179                /* All is well */
 180                err = 0;
 181        }
 182
 183        err = i2c_master_recv(ab3100->i2c_client, regval, 1);
 184        if (err < 0) {
 185                dev_err(ab3100->dev,
 186                        "write error (read register): %d\n",
 187                        err);
 188                goto get_reg_out_unlock;
 189        } else if (err != 1) {
 190                dev_err(ab3100->dev,
 191                        "write error (read register) "
 192                        "%d bytes transferred (expected 1)\n",
 193                        err);
 194                err = -EIO;
 195                goto get_reg_out_unlock;
 196        } else {
 197                /* All is well */
 198                err = 0;
 199        }
 200
 201 get_reg_out_unlock:
 202        mutex_unlock(&ab3100->access_mutex);
 203        return err;
 204}
 205
 206static int get_register_interruptible(struct device *dev, u8 bank, u8 reg,
 207                                      u8 *value)
 208{
 209        struct ab3100 *ab3100 = dev_get_drvdata(dev->parent);
 210
 211        return ab3100_get_register_interruptible(ab3100, reg, value);
 212}
 213
 214static int ab3100_get_register_page_interruptible(struct ab3100 *ab3100,
 215                             u8 first_reg, u8 *regvals, u8 numregs)
 216{
 217        int err;
 218
 219        if (ab3100->chip_id == 0xa0 ||
 220            ab3100->chip_id == 0xa1)
 221                /* These don't support paged reads */
 222                return -EIO;
 223
 224        err = mutex_lock_interruptible(&ab3100->access_mutex);
 225        if (err)
 226                return err;
 227
 228        /*
 229         * Paged read also require an I2C "stop" command.
 230         */
 231        err = i2c_master_send(ab3100->i2c_client, &first_reg, 1);
 232        if (err < 0) {
 233                dev_err(ab3100->dev,
 234                        "write error (send first register address): %d\n",
 235                        err);
 236                goto get_reg_page_out_unlock;
 237        } else if (err != 1) {
 238                dev_err(ab3100->dev,
 239                        "write error (send first register address) "
 240                        "%d bytes transferred (expected 1)\n",
 241                        err);
 242                err = -EIO;
 243                goto get_reg_page_out_unlock;
 244        }
 245
 246        err = i2c_master_recv(ab3100->i2c_client, regvals, numregs);
 247        if (err < 0) {
 248                dev_err(ab3100->dev,
 249                        "write error (read register page): %d\n",
 250                        err);
 251                goto get_reg_page_out_unlock;
 252        } else if (err != numregs) {
 253                dev_err(ab3100->dev,
 254                        "write error (read register page) "
 255                        "%d bytes transferred (expected %d)\n",
 256                        err, numregs);
 257                err = -EIO;
 258                goto get_reg_page_out_unlock;
 259        }
 260
 261        /* All is well */
 262        err = 0;
 263
 264 get_reg_page_out_unlock:
 265        mutex_unlock(&ab3100->access_mutex);
 266        return err;
 267}
 268
 269static int get_register_page_interruptible(struct device *dev, u8 bank,
 270        u8 first_reg, u8 *regvals, u8 numregs)
 271{
 272        struct ab3100 *ab3100 = dev_get_drvdata(dev->parent);
 273
 274        return ab3100_get_register_page_interruptible(ab3100,
 275                        first_reg, regvals, numregs);
 276}
 277
 278static int ab3100_mask_and_set_register_interruptible(struct ab3100 *ab3100,
 279                                 u8 reg, u8 andmask, u8 ormask)
 280{
 281        u8 regandval[2] = {reg, 0};
 282        int err;
 283
 284        err = mutex_lock_interruptible(&ab3100->access_mutex);
 285        if (err)
 286                return err;
 287
 288        /* First read out the target register */
 289        err = i2c_master_send(ab3100->i2c_client, &reg, 1);
 290        if (err < 0) {
 291                dev_err(ab3100->dev,
 292                        "write error (maskset send address): %d\n",
 293                        err);
 294                goto get_maskset_unlock;
 295        } else if (err != 1) {
 296                dev_err(ab3100->dev,
 297                        "write error (maskset send address) "
 298                        "%d bytes transferred (expected 1)\n",
 299                        err);
 300                err = -EIO;
 301                goto get_maskset_unlock;
 302        }
 303
 304        err = i2c_master_recv(ab3100->i2c_client, &regandval[1], 1);
 305        if (err < 0) {
 306                dev_err(ab3100->dev,
 307                        "write error (maskset read register): %d\n",
 308                        err);
 309                goto get_maskset_unlock;
 310        } else if (err != 1) {
 311                dev_err(ab3100->dev,
 312                        "write error (maskset read register) "
 313                        "%d bytes transferred (expected 1)\n",
 314                        err);
 315                err = -EIO;
 316                goto get_maskset_unlock;
 317        }
 318
 319        /* Modify the register */
 320        regandval[1] &= andmask;
 321        regandval[1] |= ormask;
 322
 323        /* Write the register */
 324        err = i2c_master_send(ab3100->i2c_client, regandval, 2);
 325        if (err < 0) {
 326                dev_err(ab3100->dev,
 327                        "write error (write register): %d\n",
 328                        err);
 329                goto get_maskset_unlock;
 330        } else if (err != 2) {
 331                dev_err(ab3100->dev,
 332                        "write error (write register) "
 333                        "%d bytes transferred (expected 2)\n",
 334                        err);
 335                err = -EIO;
 336                goto get_maskset_unlock;
 337        }
 338
 339        /* All is well */
 340        err = 0;
 341
 342 get_maskset_unlock:
 343        mutex_unlock(&ab3100->access_mutex);
 344        return err;
 345}
 346
 347static int mask_and_set_register_interruptible(struct device *dev, u8 bank,
 348        u8 reg, u8 bitmask, u8 bitvalues)
 349{
 350        struct ab3100 *ab3100 = dev_get_drvdata(dev->parent);
 351
 352        return ab3100_mask_and_set_register_interruptible(ab3100,
 353                        reg, bitmask, (bitmask & bitvalues));
 354}
 355
 356/*
 357 * Register a simple callback for handling any AB3100 events.
 358 */
 359int ab3100_event_register(struct ab3100 *ab3100,
 360                          struct notifier_block *nb)
 361{
 362        return blocking_notifier_chain_register(&ab3100->event_subscribers,
 363                                               nb);
 364}
 365EXPORT_SYMBOL(ab3100_event_register);
 366
 367/*
 368 * Remove a previously registered callback.
 369 */
 370int ab3100_event_unregister(struct ab3100 *ab3100,
 371                            struct notifier_block *nb)
 372{
 373  return blocking_notifier_chain_unregister(&ab3100->event_subscribers,
 374                                            nb);
 375}
 376EXPORT_SYMBOL(ab3100_event_unregister);
 377
 378
 379static int ab3100_event_registers_startup_state_get(struct device *dev,
 380                                             u8 *event)
 381{
 382        struct ab3100 *ab3100 = dev_get_drvdata(dev->parent);
 383        if (!ab3100->startup_events_read)
 384                return -EAGAIN; /* Try again later */
 385        memcpy(event, ab3100->startup_events, 3);
 386        return 0;
 387}
 388
 389static struct abx500_ops ab3100_ops = {
 390        .get_chip_id = ab3100_get_chip_id,
 391        .set_register = set_register_interruptible,
 392        .get_register = get_register_interruptible,
 393        .get_register_page = get_register_page_interruptible,
 394        .set_register_page = NULL,
 395        .mask_and_set_register = mask_and_set_register_interruptible,
 396        .event_registers_startup_state_get =
 397                ab3100_event_registers_startup_state_get,
 398        .startup_irq_enabled = NULL,
 399};
 400
 401/*
 402 * This is a threaded interrupt handler so we can make some
 403 * I2C calls etc.
 404 */
 405static irqreturn_t ab3100_irq_handler(int irq, void *data)
 406{
 407        struct ab3100 *ab3100 = data;
 408        u8 event_regs[3];
 409        u32 fatevent;
 410        int err;
 411
 412        err = ab3100_get_register_page_interruptible(ab3100, AB3100_EVENTA1,
 413                                       event_regs, 3);
 414        if (err)
 415                goto err_event;
 416
 417        fatevent = (event_regs[0] << 16) |
 418                (event_regs[1] << 8) |
 419                event_regs[2];
 420
 421        if (!ab3100->startup_events_read) {
 422                ab3100->startup_events[0] = event_regs[0];
 423                ab3100->startup_events[1] = event_regs[1];
 424                ab3100->startup_events[2] = event_regs[2];
 425                ab3100->startup_events_read = true;
 426        }
 427        /*
 428         * The notified parties will have to mask out the events
 429         * they're interested in and react to them. They will be
 430         * notified on all events, then they use the fatevent value
 431         * to determine if they're interested.
 432         */
 433        blocking_notifier_call_chain(&ab3100->event_subscribers,
 434                                     fatevent, NULL);
 435
 436        dev_dbg(ab3100->dev,
 437                "IRQ Event: 0x%08x\n", fatevent);
 438
 439        return IRQ_HANDLED;
 440
 441 err_event:
 442        dev_dbg(ab3100->dev,
 443                "error reading event status\n");
 444        return IRQ_HANDLED;
 445}
 446
 447#ifdef CONFIG_DEBUG_FS
 448/*
 449 * Some debugfs entries only exposed if we're using debug
 450 */
 451static int ab3100_registers_print(struct seq_file *s, void *p)
 452{
 453        struct ab3100 *ab3100 = s->private;
 454        u8 value;
 455        u8 reg;
 456
 457        seq_printf(s, "AB3100 registers:\n");
 458
 459        for (reg = 0; reg < 0xff; reg++) {
 460                ab3100_get_register_interruptible(ab3100, reg, &value);
 461                seq_printf(s, "[0x%x]:  0x%x\n", reg, value);
 462        }
 463        return 0;
 464}
 465
 466static int ab3100_registers_open(struct inode *inode, struct file *file)
 467{
 468        return single_open(file, ab3100_registers_print, inode->i_private);
 469}
 470
 471static const struct file_operations ab3100_registers_fops = {
 472        .open = ab3100_registers_open,
 473        .read = seq_read,
 474        .llseek = seq_lseek,
 475        .release = single_release,
 476        .owner = THIS_MODULE,
 477};
 478
 479struct ab3100_get_set_reg_priv {
 480        struct ab3100 *ab3100;
 481        bool mode;
 482};
 483
 484static ssize_t ab3100_get_set_reg(struct file *file,
 485                                  const char __user *user_buf,
 486                                  size_t count, loff_t *ppos)
 487{
 488        struct ab3100_get_set_reg_priv *priv = file->private_data;
 489        struct ab3100 *ab3100 = priv->ab3100;
 490        char buf[32];
 491        ssize_t buf_size;
 492        int regp;
 493        unsigned long user_reg;
 494        int err;
 495        int i = 0;
 496
 497        /* Get userspace string and assure termination */
 498        buf_size = min(count, (sizeof(buf)-1));
 499        if (copy_from_user(buf, user_buf, buf_size))
 500                return -EFAULT;
 501        buf[buf_size] = 0;
 502
 503        /*
 504         * The idea is here to parse a string which is either
 505         * "0xnn" for reading a register, or "0xaa 0xbb" for
 506         * writing 0xbb to the register 0xaa. First move past
 507         * whitespace and then begin to parse the register.
 508         */
 509        while ((i < buf_size) && (buf[i] == ' '))
 510                i++;
 511        regp = i;
 512
 513        /*
 514         * Advance pointer to end of string then terminate
 515         * the register string. This is needed to satisfy
 516         * the strict_strtoul() function.
 517         */
 518        while ((i < buf_size) && (buf[i] != ' '))
 519                i++;
 520        buf[i] = '\0';
 521
 522        err = strict_strtoul(&buf[regp], 16, &user_reg);
 523        if (err)
 524                return err;
 525        if (user_reg > 0xff)
 526                return -EINVAL;
 527
 528        /* Either we read or we write a register here */
 529        if (!priv->mode) {
 530                /* Reading */
 531                u8 reg = (u8) user_reg;
 532                u8 regvalue;
 533
 534                ab3100_get_register_interruptible(ab3100, reg, &regvalue);
 535
 536                dev_info(ab3100->dev,
 537                         "debug read AB3100 reg[0x%02x]: 0x%02x\n",
 538                         reg, regvalue);
 539        } else {
 540                int valp;
 541                unsigned long user_value;
 542                u8 reg = (u8) user_reg;
 543                u8 value;
 544                u8 regvalue;
 545
 546                /*
 547                 * Writing, we need some value to write to
 548                 * the register so keep parsing the string
 549                 * from userspace.
 550                 */
 551                i++;
 552                while ((i < buf_size) && (buf[i] == ' '))
 553                        i++;
 554                valp = i;
 555                while ((i < buf_size) && (buf[i] != ' '))
 556                        i++;
 557                buf[i] = '\0';
 558
 559                err = strict_strtoul(&buf[valp], 16, &user_value);
 560                if (err)
 561                        return err;
 562                if (user_reg > 0xff)
 563                        return -EINVAL;
 564
 565                value = (u8) user_value;
 566                ab3100_set_register_interruptible(ab3100, reg, value);
 567                ab3100_get_register_interruptible(ab3100, reg, &regvalue);
 568
 569                dev_info(ab3100->dev,
 570                         "debug write reg[0x%02x] with 0x%02x, "
 571                         "after readback: 0x%02x\n",
 572                         reg, value, regvalue);
 573        }
 574        return buf_size;
 575}
 576
 577static const struct file_operations ab3100_get_set_reg_fops = {
 578        .open = simple_open,
 579        .write = ab3100_get_set_reg,
 580        .llseek = noop_llseek,
 581};
 582
 583static struct dentry *ab3100_dir;
 584static struct dentry *ab3100_reg_file;
 585static struct ab3100_get_set_reg_priv ab3100_get_priv;
 586static struct dentry *ab3100_get_reg_file;
 587static struct ab3100_get_set_reg_priv ab3100_set_priv;
 588static struct dentry *ab3100_set_reg_file;
 589
 590static void ab3100_setup_debugfs(struct ab3100 *ab3100)
 591{
 592        int err;
 593
 594        ab3100_dir = debugfs_create_dir("ab3100", NULL);
 595        if (!ab3100_dir)
 596                goto exit_no_debugfs;
 597
 598        ab3100_reg_file = debugfs_create_file("registers",
 599                                S_IRUGO, ab3100_dir, ab3100,
 600                                &ab3100_registers_fops);
 601        if (!ab3100_reg_file) {
 602                err = -ENOMEM;
 603                goto exit_destroy_dir;
 604        }
 605
 606        ab3100_get_priv.ab3100 = ab3100;
 607        ab3100_get_priv.mode = false;
 608        ab3100_get_reg_file = debugfs_create_file("get_reg",
 609                                S_IWUSR, ab3100_dir, &ab3100_get_priv,
 610                                &ab3100_get_set_reg_fops);
 611        if (!ab3100_get_reg_file) {
 612                err = -ENOMEM;
 613                goto exit_destroy_reg;
 614        }
 615
 616        ab3100_set_priv.ab3100 = ab3100;
 617        ab3100_set_priv.mode = true;
 618        ab3100_set_reg_file = debugfs_create_file("set_reg",
 619                                S_IWUSR, ab3100_dir, &ab3100_set_priv,
 620                                &ab3100_get_set_reg_fops);
 621        if (!ab3100_set_reg_file) {
 622                err = -ENOMEM;
 623                goto exit_destroy_get_reg;
 624        }
 625        return;
 626
 627 exit_destroy_get_reg:
 628        debugfs_remove(ab3100_get_reg_file);
 629 exit_destroy_reg:
 630        debugfs_remove(ab3100_reg_file);
 631 exit_destroy_dir:
 632        debugfs_remove(ab3100_dir);
 633 exit_no_debugfs:
 634        return;
 635}
 636static inline void ab3100_remove_debugfs(void)
 637{
 638        debugfs_remove(ab3100_set_reg_file);
 639        debugfs_remove(ab3100_get_reg_file);
 640        debugfs_remove(ab3100_reg_file);
 641        debugfs_remove(ab3100_dir);
 642}
 643#else
 644static inline void ab3100_setup_debugfs(struct ab3100 *ab3100)
 645{
 646}
 647static inline void ab3100_remove_debugfs(void)
 648{
 649}
 650#endif
 651
 652/*
 653 * Basic set-up, datastructure creation/destruction and I2C interface.
 654 * This sets up a default config in the AB3100 chip so that it
 655 * will work as expected.
 656 */
 657
 658struct ab3100_init_setting {
 659        u8 abreg;
 660        u8 setting;
 661};
 662
 663static const struct ab3100_init_setting __devinitconst
 664ab3100_init_settings[] = {
 665        {
 666                .abreg = AB3100_MCA,
 667                .setting = 0x01
 668        }, {
 669                .abreg = AB3100_MCB,
 670                .setting = 0x30
 671        }, {
 672                .abreg = AB3100_IMRA1,
 673                .setting = 0x00
 674        }, {
 675                .abreg = AB3100_IMRA2,
 676                .setting = 0xFF
 677        }, {
 678                .abreg = AB3100_IMRA3,
 679                .setting = 0x01
 680        }, {
 681                .abreg = AB3100_IMRB1,
 682                .setting = 0xBF
 683        }, {
 684                .abreg = AB3100_IMRB2,
 685                .setting = 0xFF
 686        }, {
 687                .abreg = AB3100_IMRB3,
 688                .setting = 0xFF
 689        }, {
 690                .abreg = AB3100_SUP,
 691                .setting = 0x00
 692        }, {
 693                .abreg = AB3100_DIS,
 694                .setting = 0xF0
 695        }, {
 696                .abreg = AB3100_D0C,
 697                .setting = 0x00
 698        }, {
 699                .abreg = AB3100_D1C,
 700                .setting = 0x00
 701        }, {
 702                .abreg = AB3100_D2C,
 703                .setting = 0x00
 704        }, {
 705                .abreg = AB3100_D3C,
 706                .setting = 0x00
 707        },
 708};
 709
 710static int __devinit ab3100_setup(struct ab3100 *ab3100)
 711{
 712        int err = 0;
 713        int i;
 714
 715        for (i = 0; i < ARRAY_SIZE(ab3100_init_settings); i++) {
 716                err = ab3100_set_register_interruptible(ab3100,
 717                                          ab3100_init_settings[i].abreg,
 718                                          ab3100_init_settings[i].setting);
 719                if (err)
 720                        goto exit_no_setup;
 721        }
 722
 723        /*
 724         * Special trick to make the AB3100 use the 32kHz clock (RTC)
 725         * bit 3 in test register 0x02 is a special, undocumented test
 726         * register bit that only exist in AB3100 P1E
 727         */
 728        if (ab3100->chip_id == 0xc4) {
 729                dev_warn(ab3100->dev,
 730                         "AB3100 P1E variant detected, "
 731                         "forcing chip to 32KHz\n");
 732                err = ab3100_set_test_register_interruptible(ab3100,
 733                        0x02, 0x08);
 734        }
 735
 736 exit_no_setup:
 737        return err;
 738}
 739
 740/* The subdevices of the AB3100 */
 741static struct mfd_cell ab3100_devs[] = {
 742        {
 743                .name = "ab3100-dac",
 744                .id = -1,
 745        },
 746        {
 747                .name = "ab3100-leds",
 748                .id = -1,
 749        },
 750        {
 751                .name = "ab3100-power",
 752                .id = -1,
 753        },
 754        {
 755                .name = "ab3100-regulators",
 756                .id = -1,
 757        },
 758        {
 759                .name = "ab3100-sim",
 760                .id = -1,
 761        },
 762        {
 763                .name = "ab3100-uart",
 764                .id = -1,
 765        },
 766        {
 767                .name = "ab3100-rtc",
 768                .id = -1,
 769        },
 770        {
 771                .name = "ab3100-charger",
 772                .id = -1,
 773        },
 774        {
 775                .name = "ab3100-boost",
 776                .id = -1,
 777        },
 778        {
 779                .name = "ab3100-adc",
 780                .id = -1,
 781        },
 782        {
 783                .name = "ab3100-fuelgauge",
 784                .id = -1,
 785        },
 786        {
 787                .name = "ab3100-vibrator",
 788                .id = -1,
 789        },
 790        {
 791                .name = "ab3100-otp",
 792                .id = -1,
 793        },
 794        {
 795                .name = "ab3100-codec",
 796                .id = -1,
 797        },
 798};
 799
 800struct ab_family_id {
 801        u8      id;
 802        char    *name;
 803};
 804
 805static const struct ab_family_id ids[] __devinitconst = {
 806        /* AB3100 */
 807        {
 808                .id = 0xc0,
 809                .name = "P1A"
 810        }, {
 811                .id = 0xc1,
 812                .name = "P1B"
 813        }, {
 814                .id = 0xc2,
 815                .name = "P1C"
 816        }, {
 817                .id = 0xc3,
 818                .name = "P1D"
 819        }, {
 820                .id = 0xc4,
 821                .name = "P1E"
 822        }, {
 823                .id = 0xc5,
 824                .name = "P1F/R1A"
 825        }, {
 826                .id = 0xc6,
 827                .name = "P1G/R1A"
 828        }, {
 829                .id = 0xc7,
 830                .name = "P2A/R2A"
 831        }, {
 832                .id = 0xc8,
 833                .name = "P2B/R2B"
 834        },
 835        /* AB3000 variants, not supported */
 836        {
 837                .id = 0xa0
 838        }, {
 839                .id = 0xa1
 840        }, {
 841                .id = 0xa2
 842        }, {
 843                .id = 0xa3
 844        }, {
 845                .id = 0xa4
 846        }, {
 847                .id = 0xa5
 848        }, {
 849                .id = 0xa6
 850        }, {
 851                .id = 0xa7
 852        },
 853        /* Terminator */
 854        {
 855                .id = 0x00,
 856        },
 857};
 858
 859static int __devinit ab3100_probe(struct i2c_client *client,
 860                                  const struct i2c_device_id *id)
 861{
 862        struct ab3100 *ab3100;
 863        struct ab3100_platform_data *ab3100_plf_data =
 864                client->dev.platform_data;
 865        int err;
 866        int i;
 867
 868        ab3100 = devm_kzalloc(&client->dev, sizeof(struct ab3100), GFP_KERNEL);
 869        if (!ab3100) {
 870                dev_err(&client->dev, "could not allocate AB3100 device\n");
 871                return -ENOMEM;
 872        }
 873
 874        /* Initialize data structure */
 875        mutex_init(&ab3100->access_mutex);
 876        BLOCKING_INIT_NOTIFIER_HEAD(&ab3100->event_subscribers);
 877
 878        ab3100->i2c_client = client;
 879        ab3100->dev = &ab3100->i2c_client->dev;
 880
 881        i2c_set_clientdata(client, ab3100);
 882
 883        /* Read chip ID register */
 884        err = ab3100_get_register_interruptible(ab3100, AB3100_CID,
 885                                                &ab3100->chip_id);
 886        if (err) {
 887                dev_err(&client->dev,
 888                        "could not communicate with the AB3100 analog "
 889                        "baseband chip\n");
 890                goto exit_no_detect;
 891        }
 892
 893        for (i = 0; ids[i].id != 0x0; i++) {
 894                if (ids[i].id == ab3100->chip_id) {
 895                        if (ids[i].name != NULL) {
 896                                snprintf(&ab3100->chip_name[0],
 897                                         sizeof(ab3100->chip_name) - 1,
 898                                         "AB3100 %s",
 899                                         ids[i].name);
 900                                break;
 901                        } else {
 902                                dev_err(&client->dev,
 903                                        "AB3000 is not supported\n");
 904                                goto exit_no_detect;
 905                        }
 906                }
 907        }
 908
 909        if (ids[i].id == 0x0) {
 910                dev_err(&client->dev, "unknown analog baseband chip id: 0x%x\n",
 911                        ab3100->chip_id);
 912                dev_err(&client->dev, "accepting it anyway. Please update "
 913                        "the driver.\n");
 914                goto exit_no_detect;
 915        }
 916
 917        dev_info(&client->dev, "Detected chip: %s\n",
 918                 &ab3100->chip_name[0]);
 919
 920        /* Attach a second dummy i2c_client to the test register address */
 921        ab3100->testreg_client = i2c_new_dummy(client->adapter,
 922                                               client->addr + 1);
 923        if (!ab3100->testreg_client) {
 924                err = -ENOMEM;
 925                goto exit_no_testreg_client;
 926        }
 927
 928        err = ab3100_setup(ab3100);
 929        if (err)
 930                goto exit_no_setup;
 931
 932        err = devm_request_threaded_irq(&client->dev,
 933                                        client->irq, NULL, ab3100_irq_handler,
 934                                        IRQF_ONESHOT, "ab3100-core", ab3100);
 935        if (err)
 936                goto exit_no_irq;
 937
 938        err = abx500_register_ops(&client->dev, &ab3100_ops);
 939        if (err)
 940                goto exit_no_ops;
 941
 942        /* Set up and register the platform devices. */
 943        for (i = 0; i < ARRAY_SIZE(ab3100_devs); i++) {
 944                ab3100_devs[i].platform_data = ab3100_plf_data;
 945                ab3100_devs[i].pdata_size = sizeof(struct ab3100_platform_data);
 946        }
 947
 948        err = mfd_add_devices(&client->dev, 0, ab3100_devs,
 949                              ARRAY_SIZE(ab3100_devs), NULL, 0, NULL);
 950
 951        ab3100_setup_debugfs(ab3100);
 952
 953        return 0;
 954
 955 exit_no_ops:
 956 exit_no_irq:
 957 exit_no_setup:
 958        i2c_unregister_device(ab3100->testreg_client);
 959 exit_no_testreg_client:
 960 exit_no_detect:
 961        return err;
 962}
 963
 964static int __devexit ab3100_remove(struct i2c_client *client)
 965{
 966        struct ab3100 *ab3100 = i2c_get_clientdata(client);
 967
 968        /* Unregister subdevices */
 969        mfd_remove_devices(&client->dev);
 970        ab3100_remove_debugfs();
 971        i2c_unregister_device(ab3100->testreg_client);
 972        return 0;
 973}
 974
 975static const struct i2c_device_id ab3100_id[] = {
 976        { "ab3100", 0 },
 977        { }
 978};
 979MODULE_DEVICE_TABLE(i2c, ab3100_id);
 980
 981static struct i2c_driver ab3100_driver = {
 982        .driver = {
 983                .name   = "ab3100",
 984                .owner  = THIS_MODULE,
 985        },
 986        .id_table       = ab3100_id,
 987        .probe          = ab3100_probe,
 988        .remove         = __devexit_p(ab3100_remove),
 989};
 990
 991static int __init ab3100_i2c_init(void)
 992{
 993        return i2c_add_driver(&ab3100_driver);
 994}
 995
 996static void __exit ab3100_i2c_exit(void)
 997{
 998        i2c_del_driver(&ab3100_driver);
 999}
1000
1001subsys_initcall(ab3100_i2c_init);
1002module_exit(ab3100_i2c_exit);
1003
1004MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
1005MODULE_DESCRIPTION("AB3100 core driver");
1006MODULE_LICENSE("GPL");
1007
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.