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