SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/mfd/ucb1x00-core.c

   1 /*
   2  *  linux/drivers/mfd/ucb1x00-core.c
   3  *
   4  *  Copyright (C) 2001 Russell King, All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License.
   9  *
  10  *  The UCB1x00 core driver provides basic services for handling IO,
  11  *  the ADC, interrupts, and accessing registers.  It is designed
  12  *  such that everything goes through this layer, thereby providing
  13  *  a consistent locking methodology, as well as allowing the drivers
  14  *  to be used on other non-MCP-enabled hardware platforms.
  15  *
  16  *  Note that all locks are private to this file.  Nothing else may
  17  *  touch them.
  18  */
  19 #include <linux/module.h>
  20 #include <linux/kernel.h>
  21 #include <linux/sched.h>
  22 #include <linux/slab.h>
  23 #include <linux/init.h>
  24 #include <linux/errno.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/device.h>
  27 #include <linux/mutex.h>
  28 #include <linux/mfd/ucb1x00.h>
  29 #include <linux/gpio.h>
  30
  31 #include <mach/dma.h>
  32 #include <mach/hardware.h>
  33
  34 static DEFINE_MUTEX(ucb1x00_mutex);
  35 static LIST_HEAD(ucb1x00_drivers);
  36 static LIST_HEAD(ucb1x00_devices);
  37
  38 /**
  39  *      ucb1x00_io_set_dir - set IO direction
  40  *      @ucb: UCB1x00 structure describing chip
  41  *      @in:  bitfield of IO pins to be set as inputs
  42  *      @out: bitfield of IO pins to be set as outputs
  43  *
  44  *      Set the IO direction of the ten general purpose IO pins on
  45  *      the UCB1x00 chip.  The @in bitfield has priority over the
  46  *      @out bitfield, in that if you specify a pin as both input
  47  *      and output, it will end up as an input.
  48  *
  49  *      ucb1x00_enable must have been called to enable the comms
  50  *      before using this function.
  51  *
  52  *      This function takes a spinlock, disabling interrupts.
  53  */
  54 void ucb1x00_io_set_dir(struct ucb1x00 *ucb, unsigned int in, unsigned int out)
  55 {
  56         unsigned long flags;
  57
  58         spin_lock_irqsave(&ucb->io_lock, flags);
  59         ucb->io_dir |= out;
  60         ucb->io_dir &= ~in;
  61
  62         ucb1x00_reg_write(ucb, UCB_IO_DIR, ucb->io_dir);
  63         spin_unlock_irqrestore(&ucb->io_lock, flags);
  64 }
  65
  66 /**
  67  *      ucb1x00_io_write - set or clear IO outputs
  68  *      @ucb:   UCB1x00 structure describing chip
  69  *      @set:   bitfield of IO pins to set to logic '1'
  70  *      @clear: bitfield of IO pins to set to logic '0'
  71  *
  72  *      Set the IO output state of the specified IO pins.  The value
  73  *      is retained if the pins are subsequently configured as inputs.
  74  *      The @clear bitfield has priority over the @set bitfield -
  75  *      outputs will be cleared.
  76  *
  77  *      ucb1x00_enable must have been called to enable the comms
  78  *      before using this function.
  79  *
  80  *      This function takes a spinlock, disabling interrupts.
  81  */
  82 void ucb1x00_io_write(struct ucb1x00 *ucb, unsigned int set, unsigned int clear)
  83 {
  84         unsigned long flags;
  85
  86         spin_lock_irqsave(&ucb->io_lock, flags);
  87         ucb->io_out |= set;
  88         ucb->io_out &= ~clear;
  89
  90         ucb1x00_reg_write(ucb, UCB_IO_DATA, ucb->io_out);
  91         spin_unlock_irqrestore(&ucb->io_lock, flags);
  92 }
  93
  94 /**
  95  *      ucb1x00_io_read - read the current state of the IO pins
  96  *      @ucb: UCB1x00 structure describing chip
  97  *
  98  *      Return a bitfield describing the logic state of the ten
  99  *      general purpose IO pins.
 100  *
 101  *      ucb1x00_enable must have been called to enable the comms
 102  *      before using this function.
 103  *
 104  *      This function does not take any semaphores or spinlocks.
 105  */
 106 unsigned int ucb1x00_io_read(struct ucb1x00 *ucb)
 107 {
 108         return ucb1x00_reg_read(ucb, UCB_IO_DATA);
 109 }
 110
 111 static void ucb1x00_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 112 {
 113         struct ucb1x00 *ucb = container_of(chip, struct ucb1x00, gpio);
 114         unsigned long flags;
 115
 116         spin_lock_irqsave(&ucb->io_lock, flags);
 117         if (value)
 118                 ucb->io_out |= 1 << offset;
 119         else
 120                 ucb->io_out &= ~(1 << offset);
 121
 122         ucb1x00_reg_write(ucb, UCB_IO_DATA, ucb->io_out);
 123         spin_unlock_irqrestore(&ucb->io_lock, flags);
 124 }
 125
 126 static int ucb1x00_gpio_get(struct gpio_chip *chip, unsigned offset)
 127 {
 128         struct ucb1x00 *ucb = container_of(chip, struct ucb1x00, gpio);
 129         return ucb1x00_reg_read(ucb, UCB_IO_DATA) & (1 << offset);
 130 }
 131
 132 static int ucb1x00_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 133 {
 134         struct ucb1x00 *ucb = container_of(chip, struct ucb1x00, gpio);
 135         unsigned long flags;
 136
 137         spin_lock_irqsave(&ucb->io_lock, flags);
 138         ucb->io_dir &= ~(1 << offset);
 139         ucb1x00_reg_write(ucb, UCB_IO_DIR, ucb->io_dir);
 140         spin_unlock_irqrestore(&ucb->io_lock, flags);
 141
 142         return 0;
 143 }
 144
 145 static int ucb1x00_gpio_direction_output(struct gpio_chip *chip, unsigned offset
 146                 , int value)
 147 {
 148         struct ucb1x00 *ucb = container_of(chip, struct ucb1x00, gpio);
 149         unsigned long flags;
 150
 151         spin_lock_irqsave(&ucb->io_lock, flags);
 152         ucb->io_dir |= (1 << offset);
 153         ucb1x00_reg_write(ucb, UCB_IO_DIR, ucb->io_dir);
 154
 155         if (value)
 156                 ucb->io_out |= 1 << offset;
 157         else
 158                 ucb->io_out &= ~(1 << offset);
 159         ucb1x00_reg_write(ucb, UCB_IO_DATA, ucb->io_out);
 160         spin_unlock_irqrestore(&ucb->io_lock, flags);
 161
 162         return 0;
 163 }
 164
 165 /*
 166  * UCB1300 data sheet says we must:
 167  *  1. enable ADC       => 5us (including reference startup time)
 168  *  2. select input     => 51*tsibclk  => 4.3us
 169  *  3. start conversion => 102*tsibclk => 8.5us
 170  * (tsibclk = 1/11981000)
 171  * Period between SIB 128-bit frames = 10.7us
 172  */
 173
 174 /**
 175  *      ucb1x00_adc_enable - enable the ADC converter
 176  *      @ucb: UCB1x00 structure describing chip
 177  *
 178  *      Enable the ucb1x00 and ADC converter on the UCB1x00 for use.
 179  *      Any code wishing to use the ADC converter must call this
 180  *      function prior to using it.
 181  *
 182  *      This function takes the ADC semaphore to prevent two or more
 183  *      concurrent uses, and therefore may sleep.  As a result, it
 184  *      can only be called from process context, not interrupt
 185  *      context.
 186  *
 187  *      You should release the ADC as soon as possible using
 188  *      ucb1x00_adc_disable.
 189  */
 190 void ucb1x00_adc_enable(struct ucb1x00 *ucb)
 191 {
 192         down(&ucb->adc_sem);
 193
 194         ucb->adc_cr |= UCB_ADC_ENA;
 195
 196         ucb1x00_enable(ucb);
 197         ucb1x00_reg_write(ucb, UCB_ADC_CR, ucb->adc_cr);
 198 }
 199
 200 /**
 201  *      ucb1x00_adc_read - read the specified ADC channel
 202  *      @ucb: UCB1x00 structure describing chip
 203  *      @adc_channel: ADC channel mask
 204  *      @sync: wait for syncronisation pulse.
 205  *
 206  *      Start an ADC conversion and wait for the result.  Note that
 207  *      synchronised ADC conversions (via the ADCSYNC pin) must wait
 208  *      until the trigger is asserted and the conversion is finished.
 209  *
 210  *      This function currently spins waiting for the conversion to
 211  *      complete (2 frames max without sync).
 212  *
 213  *      If called for a synchronised ADC conversion, it may sleep
 214  *      with the ADC semaphore held.
 215  */
 216 unsigned int ucb1x00_adc_read(struct ucb1x00 *ucb, int adc_channel, int sync)
 217 {
 218         unsigned int val;
 219
 220         if (sync)
 221                 adc_channel |= UCB_ADC_SYNC_ENA;
 222
 223         ucb1x00_reg_write(ucb, UCB_ADC_CR, ucb->adc_cr | adc_channel);
 224         ucb1x00_reg_write(ucb, UCB_ADC_CR, ucb->adc_cr | adc_channel | UCB_ADC_START);
 225
 226         for (;;) {
 227                 val = ucb1x00_reg_read(ucb, UCB_ADC_DATA);
 228                 if (val & UCB_ADC_DAT_VAL)
 229                         break;
 230                 /* yield to other processes */
 231                 set_current_state(TASK_INTERRUPTIBLE);
 232                 schedule_timeout(1);
 233         }
 234
 235         return UCB_ADC_DAT(val);
 236 }
 237
 238 /**
 239  *      ucb1x00_adc_disable - disable the ADC converter
 240  *      @ucb: UCB1x00 structure describing chip
 241  *
 242  *      Disable the ADC converter and release the ADC semaphore.
 243  */
 244 void ucb1x00_adc_disable(struct ucb1x00 *ucb)
 245 {
 246         ucb->adc_cr &= ~UCB_ADC_ENA;
 247         ucb1x00_reg_write(ucb, UCB_ADC_CR, ucb->adc_cr);
 248         ucb1x00_disable(ucb);
 249
 250         up(&ucb->adc_sem);
 251 }
 252
 253 /*
 254  * UCB1x00 Interrupt handling.
 255  *
 256  * The UCB1x00 can generate interrupts when the SIBCLK is stopped.
 257  * Since we need to read an internal register, we must re-enable
 258  * SIBCLK to talk to the chip.  We leave the clock running until
 259  * we have finished processing all interrupts from the chip.
 260  */
 261 static irqreturn_t ucb1x00_irq(int irqnr, void *devid)
 262 {
 263         struct ucb1x00 *ucb = devid;
 264         struct ucb1x00_irq *irq;
 265         unsigned int isr, i;
 266
 267         ucb1x00_enable(ucb);
 268         isr = ucb1x00_reg_read(ucb, UCB_IE_STATUS);
 269         ucb1x00_reg_write(ucb, UCB_IE_CLEAR, isr);
 270         ucb1x00_reg_write(ucb, UCB_IE_CLEAR, 0);
 271
 272         for (i = 0, irq = ucb->irq_handler; i < 16 && isr; i++, isr >>= 1, irq++)
 273                 if (isr & 1 && irq->fn)
 274                         irq->fn(i, irq->devid);
 275         ucb1x00_disable(ucb);
 276
 277         return IRQ_HANDLED;
 278 }
 279
 280 /**
 281  *      ucb1x00_hook_irq - hook a UCB1x00 interrupt
 282  *      @ucb:   UCB1x00 structure describing chip
 283  *      @idx:   interrupt index
 284  *      @fn:    function to call when interrupt is triggered
 285  *      @devid: device id to pass to interrupt handler
 286  *
 287  *      Hook the specified interrupt.  You can only register one handler
 288  *      for each interrupt source.  The interrupt source is not enabled
 289  *      by this function; use ucb1x00_enable_irq instead.
 290  *
 291  *      Interrupt handlers will be called with other interrupts enabled.
 292  *
 293  *      Returns zero on success, or one of the following errors:
 294  *       -EINVAL if the interrupt index is invalid
 295  *       -EBUSY if the interrupt has already been hooked
 296  */
 297 int ucb1x00_hook_irq(struct ucb1x00 *ucb, unsigned int idx, void (*fn)(int, void *), void *devid)
 298 {
 299         struct ucb1x00_irq *irq;
 300         int ret = -EINVAL;
 301
 302         if (idx < 16) {
 303                 irq = ucb->irq_handler + idx;
 304                 ret = -EBUSY;
 305
 306                 spin_lock_irq(&ucb->lock);
 307                 if (irq->fn == NULL) {
 308                         irq->devid = devid;
 309                         irq->fn = fn;
 310                         ret = 0;
 311                 }
 312                 spin_unlock_irq(&ucb->lock);
 313         }
 314         return ret;
 315 }
 316
 317 /**
 318  *      ucb1x00_enable_irq - enable an UCB1x00 interrupt source
 319  *      @ucb: UCB1x00 structure describing chip
 320  *      @idx: interrupt index
 321  *      @edges: interrupt edges to enable
 322  *
 323  *      Enable the specified interrupt to trigger on %UCB_RISING,
 324  *      %UCB_FALLING or both edges.  The interrupt should have been
 325  *      hooked by ucb1x00_hook_irq.
 326  */
 327 void ucb1x00_enable_irq(struct ucb1x00 *ucb, unsigned int idx, int edges)
 328 {
 329         unsigned long flags;
 330
 331         if (idx < 16) {
 332                 spin_lock_irqsave(&ucb->lock, flags);
 333
 334                 ucb1x00_enable(ucb);
 335                 if (edges & UCB_RISING) {
 336                         ucb->irq_ris_enbl |= 1 << idx;
 337                         ucb1x00_reg_write(ucb, UCB_IE_RIS, ucb->irq_ris_enbl);
 338                 }
 339                 if (edges & UCB_FALLING) {
 340                         ucb->irq_fal_enbl |= 1 << idx;
 341                         ucb1x00_reg_write(ucb, UCB_IE_FAL, ucb->irq_fal_enbl);
 342                 }
 343                 ucb1x00_disable(ucb);
 344                 spin_unlock_irqrestore(&ucb->lock, flags);
 345         }
 346 }
 347
 348 /**
 349  *      ucb1x00_disable_irq - disable an UCB1x00 interrupt source
 350  *      @ucb: UCB1x00 structure describing chip
 351  *      @edges: interrupt edges to disable
 352  *
 353  *      Disable the specified interrupt triggering on the specified
 354  *      (%UCB_RISING, %UCB_FALLING or both) edges.
 355  */
 356 void ucb1x00_disable_irq(struct ucb1x00 *ucb, unsigned int idx, int edges)
 357 {
 358         unsigned long flags;
 359
 360         if (idx < 16) {
 361                 spin_lock_irqsave(&ucb->lock, flags);
 362
 363                 ucb1x00_enable(ucb);
 364                 if (edges & UCB_RISING) {
 365                         ucb->irq_ris_enbl &= ~(1 << idx);
 366                         ucb1x00_reg_write(ucb, UCB_IE_RIS, ucb->irq_ris_enbl);
 367                 }
 368                 if (edges & UCB_FALLING) {
 369                         ucb->irq_fal_enbl &= ~(1 << idx);
 370                         ucb1x00_reg_write(ucb, UCB_IE_FAL, ucb->irq_fal_enbl);
 371                 }
 372                 ucb1x00_disable(ucb);
 373                 spin_unlock_irqrestore(&ucb->lock, flags);
 374         }
 375 }
 376
 377 /**
 378  *      ucb1x00_free_irq - disable and free the specified UCB1x00 interrupt
 379  *      @ucb: UCB1x00 structure describing chip
 380  *      @idx: interrupt index
 381  *      @devid: device id.
 382  *
 383  *      Disable the interrupt source and remove the handler.  devid must
 384  *      match the devid passed when hooking the interrupt.
 385  *
 386  *      Returns zero on success, or one of the following errors:
 387  *       -EINVAL if the interrupt index is invalid
 388  *       -ENOENT if devid does not match
 389  */
 390 int ucb1x00_free_irq(struct ucb1x00 *ucb, unsigned int idx, void *devid)
 391 {
 392         struct ucb1x00_irq *irq;
 393         int ret;
 394
 395         if (idx >= 16)
 396                 goto bad;
 397
 398         irq = ucb->irq_handler + idx;
 399         ret = -ENOENT;
 400
 401         spin_lock_irq(&ucb->lock);
 402         if (irq->devid == devid) {
 403                 ucb->irq_ris_enbl &= ~(1 << idx);
 404                 ucb->irq_fal_enbl &= ~(1 << idx);
 405
 406                 ucb1x00_enable(ucb);
 407                 ucb1x00_reg_write(ucb, UCB_IE_RIS, ucb->irq_ris_enbl);
 408                 ucb1x00_reg_write(ucb, UCB_IE_FAL, ucb->irq_fal_enbl);
 409                 ucb1x00_disable(ucb);
 410
 411                 irq->fn = NULL;
 412                 irq->devid = NULL;
 413                 ret = 0;
 414         }
 415         spin_unlock_irq(&ucb->lock);
 416         return ret;
 417
 418 bad:
 419         printk(KERN_ERR "Freeing bad UCB1x00 irq %d\n", idx);
 420         return -EINVAL;
 421 }
 422
 423 static int ucb1x00_add_dev(struct ucb1x00 *ucb, struct ucb1x00_driver *drv)
 424 {
 425         struct ucb1x00_dev *dev;
 426         int ret = -ENOMEM;
 427
 428         dev = kmalloc(sizeof(struct ucb1x00_dev), GFP_KERNEL);
 429         if (dev) {
 430                 dev->ucb = ucb;
 431                 dev->drv = drv;
 432
 433                 ret = drv->add(dev);
 434
 435                 if (ret == 0) {
 436                         list_add(&dev->dev_node, &ucb->devs);
 437                         list_add(&dev->drv_node, &drv->devs);
 438                 } else {
 439                         kfree(dev);
 440                 }
 441         }
 442         return ret;
 443 }
 444
 445 static void ucb1x00_remove_dev(struct ucb1x00_dev *dev)
 446 {
 447         dev->drv->remove(dev);
 448         list_del(&dev->dev_node);
 449         list_del(&dev->drv_node);
 450         kfree(dev);
 451 }
 452
 453 /*
 454  * Try to probe our interrupt, rather than relying on lots of
 455  * hard-coded machine dependencies.  For reference, the expected
 456  * IRQ mappings are:
 457  *
 458  *      Machine         Default IRQ
 459  *      adsbitsy        IRQ_GPCIN4
 460  *      cerf            IRQ_GPIO_UCB1200_IRQ
 461  *      flexanet        IRQ_GPIO_GUI
 462  *      freebird        IRQ_GPIO_FREEBIRD_UCB1300_IRQ
 463  *      graphicsclient  ADS_EXT_IRQ(8)
 464  *      graphicsmaster  ADS_EXT_IRQ(8)
 465  *      lart            LART_IRQ_UCB1200
 466  *      omnimeter       IRQ_GPIO23
 467  *      pfs168          IRQ_GPIO_UCB1300_IRQ
 468  *      simpad          IRQ_GPIO_UCB1300_IRQ
 469  *      shannon         SHANNON_IRQ_GPIO_IRQ_CODEC
 470  *      yopy            IRQ_GPIO_UCB1200_IRQ
 471  */
 472 static int ucb1x00_detect_irq(struct ucb1x00 *ucb)
 473 {
 474         unsigned long mask;
 475
 476         mask = probe_irq_on();
 477         if (!mask) {
 478                 probe_irq_off(mask);
 479                 return NO_IRQ;
 480         }
 481
 482         /*
 483          * Enable the ADC interrupt.
 484          */
 485         ucb1x00_reg_write(ucb, UCB_IE_RIS, UCB_IE_ADC);
 486         ucb1x00_reg_write(ucb, UCB_IE_FAL, UCB_IE_ADC);
 487         ucb1x00_reg_write(ucb, UCB_IE_CLEAR, 0xffff);
 488         ucb1x00_reg_write(ucb, UCB_IE_CLEAR, 0);
 489
 490         /*
 491          * Cause an ADC interrupt.
 492          */
 493         ucb1x00_reg_write(ucb, UCB_ADC_CR, UCB_ADC_ENA);
 494         ucb1x00_reg_write(ucb, UCB_ADC_CR, UCB_ADC_ENA | UCB_ADC_START);
 495
 496         /*
 497          * Wait for the conversion to complete.
 498          */
 499         while ((ucb1x00_reg_read(ucb, UCB_ADC_DATA) & UCB_ADC_DAT_VAL) == 0);
 500         ucb1x00_reg_write(ucb, UCB_ADC_CR, 0);
 501
 502         /*
 503          * Disable and clear interrupt.
 504          */
 505         ucb1x00_reg_write(ucb, UCB_IE_RIS, 0);
 506         ucb1x00_reg_write(ucb, UCB_IE_FAL, 0);
 507         ucb1x00_reg_write(ucb, UCB_IE_CLEAR, 0xffff);
 508         ucb1x00_reg_write(ucb, UCB_IE_CLEAR, 0);
 509
 510         /*
 511          * Read triggered interrupt.
 512          */
 513         return probe_irq_off(mask);
 514 }
 515
 516 static void ucb1x00_release(struct device *dev)
 517 {
 518         struct ucb1x00 *ucb = classdev_to_ucb1x00(dev);
 519         kfree(ucb);
 520 }
 521
 522 static struct class ucb1x00_class = {
 523         .name           = "ucb1x00",
 524         .dev_release    = ucb1x00_release,
 525 };
 526
 527 static int ucb1x00_probe(struct mcp *mcp)
 528 {
 529         struct ucb1x00 *ucb;
 530         struct ucb1x00_driver *drv;
 531         unsigned int id;
 532         int ret = -ENODEV;
 533         int temp;
 534
 535         mcp_enable(mcp);
 536         id = mcp_reg_read(mcp, UCB_ID);
 537
 538         if (id != UCB_ID_1200 && id != UCB_ID_1300 && id != UCB_ID_TC35143) {
 539                 printk(KERN_WARNING "UCB1x00 ID not found: %04x\n", id);
 540                 goto err_disable;
 541         }
 542
 543         ucb = kzalloc(sizeof(struct ucb1x00), GFP_KERNEL);
 544         ret = -ENOMEM;
 545         if (!ucb)
 546                 goto err_disable;
 547
 548
 549         ucb->dev.class = &ucb1x00_class;
 550         ucb->dev.parent = &mcp->attached_device;
 551         dev_set_name(&ucb->dev, "ucb1x00");
 552
 553         spin_lock_init(&ucb->lock);
 554         spin_lock_init(&ucb->io_lock);
 555         sema_init(&ucb->adc_sem, 1);
 556
 557         ucb->id  = id;
 558         ucb->mcp = mcp;
 559         ucb->irq = ucb1x00_detect_irq(ucb);
 560         if (ucb->irq == NO_IRQ) {
 561                 printk(KERN_ERR "UCB1x00: IRQ probe failed\n");
 562                 ret = -ENODEV;
 563                 goto err_free;
 564         }
 565
 566         ucb->gpio.base = -1;
 567         if (mcp->gpio_base != 0) {
 568                 ucb->gpio.label = dev_name(&ucb->dev);
 569                 ucb->gpio.base = mcp->gpio_base;
 570                 ucb->gpio.ngpio = 10;
 571                 ucb->gpio.set = ucb1x00_gpio_set;
 572                 ucb->gpio.get = ucb1x00_gpio_get;
 573                 ucb->gpio.direction_input = ucb1x00_gpio_direction_input;
 574                 ucb->gpio.direction_output = ucb1x00_gpio_direction_output;
 575                 ret = gpiochip_add(&ucb->gpio);
 576                 if (ret)
 577                         goto err_free;
 578         } else
 579                 dev_info(&ucb->dev, "gpio_base not set so no gpiolib support");
 580
 581         ret = request_irq(ucb->irq, ucb1x00_irq, IRQF_TRIGGER_RISING,
 582                           "UCB1x00", ucb);
 583         if (ret) {
 584                 printk(KERN_ERR "ucb1x00: unable to grab irq%d: %d\n",
 585                         ucb->irq, ret);
 586                 goto err_gpio;
 587         }
 588
 589         mcp_set_drvdata(mcp, ucb);
 590
 591         ret = device_register(&ucb->dev);
 592         if (ret)
 593                 goto err_irq;
 594
 595
 596         INIT_LIST_HEAD(&ucb->devs);
 597         mutex_lock(&ucb1x00_mutex);
 598         list_add(&ucb->node, &ucb1x00_devices);
 599         list_for_each_entry(drv, &ucb1x00_drivers, node) {
 600                 ucb1x00_add_dev(ucb, drv);
 601         }
 602         mutex_unlock(&ucb1x00_mutex);
 603
 604         goto out;
 605
 606  err_irq:
 607         free_irq(ucb->irq, ucb);
 608  err_gpio:
 609         if (ucb->gpio.base != -1)
 610                 temp = gpiochip_remove(&ucb->gpio);
 611  err_free:
 612         kfree(ucb);
 613  err_disable:
 614         mcp_disable(mcp);
 615  out:
 616         return ret;
 617 }
 618
 619 static void ucb1x00_remove(struct mcp *mcp)
 620 {
 621         struct ucb1x00 *ucb = mcp_get_drvdata(mcp);
 622         struct list_head *l, *n;
 623         int ret;
 624
 625         mutex_lock(&ucb1x00_mutex);
 626         list_del(&ucb->node);
 627         list_for_each_safe(l, n, &ucb->devs) {
 628                 struct ucb1x00_dev *dev = list_entry(l, struct ucb1x00_dev, dev_node);
 629                 ucb1x00_remove_dev(dev);
 630         }
 631         mutex_unlock(&ucb1x00_mutex);
 632
 633         if (ucb->gpio.base != -1) {
 634                 ret = gpiochip_remove(&ucb->gpio);
 635                 if (ret)
 636                         dev_err(&ucb->dev, "Can't remove gpio chip: %d\n", ret);
 637         }
 638
 639         free_irq(ucb->irq, ucb);
 640         device_unregister(&ucb->dev);
 641 }
 642
 643 int ucb1x00_register_driver(struct ucb1x00_driver *drv)
 644 {
 645         struct ucb1x00 *ucb;
 646
 647         INIT_LIST_HEAD(&drv->devs);
 648         mutex_lock(&ucb1x00_mutex);
 649         list_add(&drv->node, &ucb1x00_drivers);
 650         list_for_each_entry(ucb, &ucb1x00_devices, node) {
 651                 ucb1x00_add_dev(ucb, drv);
 652         }
 653         mutex_unlock(&ucb1x00_mutex);
 654         return 0;
 655 }
 656
 657 void ucb1x00_unregister_driver(struct ucb1x00_driver *drv)
 658 {
 659         struct list_head *n, *l;
 660
 661         mutex_lock(&ucb1x00_mutex);
 662         list_del(&drv->node);
 663         list_for_each_safe(l, n, &drv->devs) {
 664                 struct ucb1x00_dev *dev = list_entry(l, struct ucb1x00_dev, drv_node);
 665                 ucb1x00_remove_dev(dev);
 666         }
 667         mutex_unlock(&ucb1x00_mutex);
 668 }
 669
 670 static int ucb1x00_suspend(struct mcp *mcp, pm_message_t state)
 671 {
 672         struct ucb1x00 *ucb = mcp_get_drvdata(mcp);
 673         struct ucb1x00_dev *dev;
 674
 675         mutex_lock(&ucb1x00_mutex);
 676         list_for_each_entry(dev, &ucb->devs, dev_node) {
 677                 if (dev->drv->suspend)
 678                         dev->drv->suspend(dev, state);
 679         }
 680         mutex_unlock(&ucb1x00_mutex);
 681         return 0;
 682 }
 683
 684 static int ucb1x00_resume(struct mcp *mcp)
 685 {
 686         struct ucb1x00 *ucb = mcp_get_drvdata(mcp);
 687         struct ucb1x00_dev *dev;
 688
 689         ucb1x00_reg_write(ucb, UCB_IO_DIR, ucb->io_dir);
 690         mutex_lock(&ucb1x00_mutex);
 691         list_for_each_entry(dev, &ucb->devs, dev_node) {
 692                 if (dev->drv->resume)
 693                         dev->drv->resume(dev);
 694         }
 695         mutex_unlock(&ucb1x00_mutex);
 696         return 0;
 697 }
 698
 699 static struct mcp_driver ucb1x00_driver = {
 700         .drv            = {
 701                 .name   = "ucb1x00",
 702         },
 703         .probe          = ucb1x00_probe,
 704         .remove         = ucb1x00_remove,
 705         .suspend        = ucb1x00_suspend,
 706         .resume         = ucb1x00_resume,
 707 };
 708
 709 static int __init ucb1x00_init(void)
 710 {
 711         int ret = class_register(&ucb1x00_class);
 712         if (ret == 0) {
 713                 ret = mcp_driver_register(&ucb1x00_driver);
 714                 if (ret)
 715                         class_unregister(&ucb1x00_class);
 716         }
 717         return ret;
 718 }
 719
 720 static void __exit ucb1x00_exit(void)
 721 {
 722         mcp_driver_unregister(&ucb1x00_driver);
 723         class_unregister(&ucb1x00_class);
 724 }
 725
 726 module_init(ucb1x00_init);
 727 module_exit(ucb1x00_exit);
 728
 729 EXPORT_SYMBOL(ucb1x00_io_set_dir);
 730 EXPORT_SYMBOL(ucb1x00_io_write);
 731 EXPORT_SYMBOL(ucb1x00_io_read);
 732
 733 EXPORT_SYMBOL(ucb1x00_adc_enable);
 734 EXPORT_SYMBOL(ucb1x00_adc_read);
 735 EXPORT_SYMBOL(ucb1x00_adc_disable);
 736
 737 EXPORT_SYMBOL(ucb1x00_hook_irq);
 738 EXPORT_SYMBOL(ucb1x00_free_irq);
 739 EXPORT_SYMBOL(ucb1x00_enable_irq);
 740 EXPORT_SYMBOL(ucb1x00_disable_irq);
 741
 742 EXPORT_SYMBOL(ucb1x00_register_driver);
 743 EXPORT_SYMBOL(ucb1x00_unregister_driver);
 744
 745 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
 746 MODULE_DESCRIPTION("UCB1x00 core driver");
 747 MODULE_LICENSE("GPL");