target/linux/omap24xx/patches-3.1/250-cbus.patch

   1 --- /dev/null
   2 +++ b/drivers/cbus/cbus.c
   3 @@ -0,0 +1,333 @@
   4 +/*
   5 + * drivers/cbus/cbus.c
   6 + *
   7 + * Support functions for CBUS serial protocol
   8 + *
   9 + * Copyright (C) 2004-2010 Nokia Corporation
  10 + * Contact: Felipe Balbi <felipe.balbi@nokia.com>
  11 + *
  12 + * Written by Juha Yrjölä <juha.yrjola@nokia.com>,
  13 + *           David Weinehall <david.weinehall@nokia.com>, and
  14 + *           Mikko Ylinen <mikko.k.ylinen@nokia.com>
  15 + *
  16 + * Several updates and cleanups by Felipe Balbi <felipe.balbi@nokia.com>
  17 + *
  18 + * This file is subject to the terms and conditions of the GNU General
  19 + * Public License. See the file "COPYING" in the main directory of this
  20 + * archive for more details.
  21 + *
  22 + * This program is distributed in the hope that it will be useful,
  23 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25 + * GNU General Public License for more details.
  26 + *
  27 + * You should have received a copy of the GNU General Public License
  28 + * along with this program; if not, write to the Free Software
  29 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  30 + */
  31 +
  32 +#include <linux/device.h>
  33 +#include <linux/init.h>
  34 +#include <linux/kernel.h>
  35 +#include <linux/slab.h>
  36 +#include <linux/spinlock.h>
  37 +#include <linux/gpio.h>
  38 +#include <linux/platform_device.h>
  39 +#include <linux/platform_data/cbus.h>
  40 +
  41 +#include "cbus.h"
  42 +
  43 +#define CBUS_XFER_READ         1
  44 +#define CBUS_XFER_WRITE                0
  45 +
  46 +struct cbus_host {
  47 +       /* host lock */
  48 +       spinlock_t      lock;
  49 +
  50 +       struct device   *dev;
  51 +
  52 +       int             clk_gpio;
  53 +       int             dat_gpio;
  54 +       int             sel_gpio;
  55 +};
  56 +
  57 +/**
  58 + * cbus_send_bit - sends one bit over the bus
  59 + * @host: the host we're using
  60 + * @bit: one bit of information to send
  61 + * @input: whether to set data pin as input after sending
  62 + */
  63 +static int cbus_send_bit(struct cbus_host *host, unsigned bit,
  64 +               unsigned input)
  65 +{
  66 +       int ret = 0;
  67 +
  68 +       gpio_set_value(host->dat_gpio, bit ? 1 : 0);
  69 +       gpio_set_value(host->clk_gpio, 1);
  70 +
  71 +       /* The data bit is read on the rising edge of CLK */
  72 +       if (input)
  73 +               ret = gpio_direction_input(host->dat_gpio);
  74 +
  75 +       gpio_set_value(host->clk_gpio, 0);
  76 +
  77 +       return ret;
  78 +}
  79 +
  80 +/**
  81 + * cbus_send_data - sends @len amount of data over the bus
  82 + * @host: the host we're using
  83 + * @data: the data to send
  84 + * @len: size of the transfer
  85 + * @input: whether to set data pin as input after sending
  86 + */
  87 +static int cbus_send_data(struct cbus_host *host, unsigned data, unsigned len,
  88 +               unsigned input)
  89 +{
  90 +       int ret = 0;
  91 +       int i;
  92 +
  93 +       for (i = len; i > 0; i--) {
  94 +               ret = cbus_send_bit(host, data & (1 << (i - 1)),
  95 +                               input && (i == 1));
  96 +               if (ret < 0)
  97 +                       goto out;
  98 +       }
  99 +
 100 +out:
 101 +       return ret;
 102 +}
 103 +
 104 +/**
 105 + * cbus_receive_bit - receives one bit from the bus
 106 + * @host: the host we're using
 107 + */
 108 +static int cbus_receive_bit(struct cbus_host *host)
 109 +{
 110 +       int ret;
 111 +
 112 +       gpio_set_value(host->clk_gpio, 1);
 113 +       ret = gpio_get_value(host->dat_gpio);
 114 +       if (ret < 0)
 115 +               goto out;
 116 +       gpio_set_value(host->clk_gpio, 0);
 117 +
 118 +out:
 119 +       return ret;
 120 +}
 121 +
 122 +/**
 123 + * cbus_receive_data - receives @len data from the bus
 124 + * @host: the host we're using
 125 + * @len: the length of data to receive
 126 + */
 127 +static int cbus_receive_data(struct cbus_host *host, unsigned len)
 128 +{
 129 +       int ret = 0;
 130 +       int i;
 131 +
 132 +       for (i = 16; i > 0; i--) {
 133 +               int bit = cbus_receive_bit(host);
 134 +
 135 +               if (bit < 0)
 136 +                       goto out;
 137 +
 138 +               if (bit)
 139 +                       ret |= 1 << (i - 1);
 140 +       }
 141 +
 142 +out:
 143 +       return ret;
 144 +}
 145 +
 146 +/**
 147 + * cbus_transfer - transfers data over the bus
 148 + * @host: the host we're using
 149 + * @rw: read/write flag
 150 + * @dev: device address
 151 + * @reg: register address
 152 + * @data: if @rw == 0 data to send otherwise 0
 153 + */
 154 +static int cbus_transfer(struct cbus_host *host, unsigned rw, unsigned dev,
 155 +               unsigned reg, unsigned data)
 156 +{
 157 +       unsigned long flags;
 158 +       int input = 0;
 159 +       int ret = 0;
 160 +
 161 +       /* We don't want interrupts disturbing our transfer */
 162 +       spin_lock_irqsave(&host->lock, flags);
 163 +
 164 +       /* Reset state and start of transfer, SEL stays down during transfer */
 165 +       gpio_set_value(host->sel_gpio, 0);
 166 +
 167 +       /* Set the DAT pin to output */
 168 +       gpio_direction_output(host->dat_gpio, 1);
 169 +
 170 +       /* Send the device address */
 171 +       ret = cbus_send_data(host, dev, 3, 0);
 172 +       if (ret < 0) {
 173 +               dev_dbg(host->dev, "failed sending device addr\n");
 174 +               goto out;
 175 +       }
 176 +
 177 +       /* Send the rw flag */
 178 +       ret = cbus_send_bit(host, rw, 0);
 179 +       if (ret < 0) {
 180 +               dev_dbg(host->dev, "failed sending read/write flag\n");
 181 +               goto out;
 182 +       }
 183 +
 184 +       /* Send the register address */
 185 +       if (rw)
 186 +               input = true;
 187 +
 188 +       ret = cbus_send_data(host, reg, 5, input);
 189 +       if (ret < 0) {
 190 +               dev_dbg(host->dev, "failed sending register addr\n");
 191 +               goto out;
 192 +       }
 193 +
 194 +       if (!rw) {
 195 +               ret = cbus_send_data(host, data, 16, 0);
 196 +               if (ret < 0) {
 197 +                       dev_dbg(host->dev, "failed sending data\n");
 198 +                       goto out;
 199 +               }
 200 +       } else {
 201 +               gpio_set_value(host->clk_gpio, 1);
 202 +
 203 +               ret = cbus_receive_data(host, 16);
 204 +               if (ret < 0) {
 205 +                       dev_dbg(host->dev, "failed receiving data\n");
 206 +                       goto out;
 207 +               }
 208 +       }
 209 +
 210 +       /* Indicate end of transfer, SEL goes up until next transfer */
 211 +       gpio_set_value(host->sel_gpio, 1);
 212 +       gpio_set_value(host->clk_gpio, 1);
 213 +       gpio_set_value(host->clk_gpio, 0);
 214 +
 215 +out:
 216 +       spin_unlock_irqrestore(&host->lock, flags);
 217 +
 218 +       return ret;
 219 +}
 220 +
 221 +/**
 222 + * cbus_read_reg - reads a given register from the device
 223 + * @child: the child device
 224 + * @dev: device address
 225 + * @reg: register address
 226 + */
 227 +int cbus_read_reg(struct device *child, unsigned dev, unsigned reg)
 228 +{
 229 +       struct cbus_host        *host = dev_get_drvdata(child->parent);
 230 +
 231 +       return cbus_transfer(host, CBUS_XFER_READ, dev, reg, 0);
 232 +}
 233 +EXPORT_SYMBOL(cbus_read_reg);
 234 +
 235 +/**
 236 + * cbus_write_reg - writes to a given register of the device
 237 + * @child: the child device
 238 + * @dev: device address
 239 + * @reg: register address
 240 + * @val: data to be written to @reg
 241 + */
 242 +int cbus_write_reg(struct device *child, unsigned dev, unsigned reg,
 243 +               unsigned val)
 244 +{
 245 +       struct cbus_host        *host = dev_get_drvdata(child->parent);
 246 +
 247 +       return cbus_transfer(host, CBUS_XFER_WRITE, dev, reg, val);
 248 +}
 249 +EXPORT_SYMBOL(cbus_write_reg);
 250 +
 251 +static int __init cbus_bus_probe(struct platform_device *pdev)
 252 +{
 253 +       struct cbus_host *chost;
 254 +       struct cbus_host_platform_data *pdata = pdev->dev.platform_data;
 255 +       int ret;
 256 +
 257 +       chost = kzalloc(sizeof(*chost), GFP_KERNEL);
 258 +       if (chost == NULL)
 259 +               return -ENOMEM;
 260 +
 261 +       spin_lock_init(&chost->lock);
 262 +
 263 +       chost->clk_gpio = pdata->clk_gpio;
 264 +       chost->dat_gpio = pdata->dat_gpio;
 265 +       chost->sel_gpio = pdata->sel_gpio;
 266 +       chost->dev = &pdev->dev;
 267 +
 268 +       ret = gpio_request(chost->clk_gpio, "CBUS clk");
 269 +       if (ret < 0)
 270 +               goto exit1;
 271 +
 272 +       ret = gpio_request(chost->dat_gpio, "CBUS data");
 273 +       if (ret < 0)
 274 +               goto exit2;
 275 +
 276 +       ret = gpio_request(chost->sel_gpio, "CBUS sel");
 277 +       if (ret < 0)
 278 +               goto exit3;
 279 +
 280 +       gpio_direction_output(chost->clk_gpio, 0);
 281 +       gpio_direction_input(chost->dat_gpio);
 282 +       gpio_direction_output(chost->sel_gpio, 1);
 283 +
 284 +       gpio_set_value(chost->clk_gpio, 1);
 285 +       gpio_set_value(chost->clk_gpio, 0);
 286 +
 287 +       platform_set_drvdata(pdev, chost);
 288 +
 289 +       return 0;
 290 +exit3:
 291 +       gpio_free(chost->dat_gpio);
 292 +exit2:
 293 +       gpio_free(chost->clk_gpio);
 294 +exit1:
 295 +       kfree(chost);
 296 +
 297 +       return ret;
 298 +}
 299 +
 300 +static void __exit cbus_bus_remove(struct platform_device *pdev)
 301 +{
 302 +       struct cbus_host        *chost = platform_get_drvdata(pdev);
 303 +
 304 +       gpio_free(chost->sel_gpio);
 305 +       gpio_free(chost->dat_gpio);
 306 +       gpio_free(chost->clk_gpio);
 307 +
 308 +       kfree(chost);
 309 +}
 310 +
 311 +static struct platform_driver cbus_driver = {
 312 +       .remove         = __exit_p(cbus_bus_remove),
 313 +       .driver         = {
 314 +               .name   = "cbus",
 315 +       },
 316 +};
 317 +
 318 +static int __init cbus_bus_init(void)
 319 +{
 320 +       return platform_driver_probe(&cbus_driver, cbus_bus_probe);
 321 +}
 322 +subsys_initcall(cbus_bus_init);
 323 +
 324 +static void __exit cbus_bus_exit(void)
 325 +{
 326 +       platform_driver_unregister(&cbus_driver);
 327 +}
 328 +module_exit(cbus_bus_exit);
 329 +
 330 +MODULE_DESCRIPTION("CBUS serial protocol");
 331 +MODULE_LICENSE("GPL");
 332 +MODULE_AUTHOR("Juha Yrjölä");
 333 +MODULE_AUTHOR("David Weinehall");
 334 +MODULE_AUTHOR("Mikko Ylinen");
 335 +MODULE_AUTHOR("Felipe Balbi <felipe.balbi@nokia.com>");
 336 +
 337 --- /dev/null
 338 +++ b/drivers/cbus/cbus.h
 339 @@ -0,0 +1,30 @@
 340 +/*
 341 + * drivers/cbus/cbus.h
 342 + *
 343 + * Copyright (C) 2004, 2005 Nokia Corporation
 344 + *
 345 + * Written by Juha Yrjölä <juha.yrjola@nokia.com> and
 346 + *           David Weinehall <david.weinehall@nokia.com>
 347 + *
 348 + * This file is subject to the terms and conditions of the GNU General
 349 + * Public License. See the file "COPYING" in the main directory of this
 350 + * archive for more details.
 351 + *
 352 + * This program is distributed in the hope that it will be useful,
 353 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 354 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 355 + * GNU General Public License for more details.
 356 + *
 357 + * You should have received a copy of the GNU General Public License
 358 + * along with this program; if not, write to the Free Software
 359 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 360 + */
 361 +
 362 +#ifndef __DRIVERS_CBUS_CBUS_H
 363 +#define __DRIVERS_CBUS_CBUS_H
 364 +
 365 +extern int cbus_read_reg(struct device *, unsigned dev, unsigned reg);
 366 +extern int cbus_write_reg(struct device *, unsigned dev, unsigned reg,
 367 +               unsigned val);
 368 +
 369 +#endif /* __DRIVERS_CBUS_CBUS_H */
 370 --- /dev/null
 371 +++ b/drivers/cbus/Kconfig
 372 @@ -0,0 +1,86 @@
 373 +#
 374 +# CBUS device configuration
 375 +#
 376 +
 377 +menu "CBUS support"
 378 +
 379 +config CBUS
 380 +       bool "CBUS support on OMAP"
 381 +       ---help---
 382 +         CBUS is a proprietary serial protocol by Nokia.  It is mainly
 383 +         used for accessing Energy Management auxiliary chips.
 384 +
 385 +         If you want CBUS support, you should say Y here.
 386 +
 387 +config CBUS_TAHVO
 388 +       depends on CBUS
 389 +       bool "Support for Tahvo"
 390 +       ---help---
 391 +         Tahvo is a mixed signal ASIC with some system features
 392 +
 393 +         If you want Tahvo support, you should say Y here.
 394 +
 395 +if CBUS_TAHVO
 396 +
 397 +config CBUS_TAHVO_USB
 398 +       depends on USB
 399 +       depends on ARCH_OMAP
 400 +       select USB_OTG_UTILS
 401 +       tristate "Support for Tahvo USB transceiver"
 402 +       ---help---
 403 +         If you want Tahvo support for USB transceiver, say Y or M here.
 404 +
 405 +config CBUS_TAHVO_USB_HOST_BY_DEFAULT
 406 +       depends on CBUS_TAHVO_USB && USB_OTG
 407 +       boolean "Device in USB host mode by default"
 408 +       ---help---
 409 +         Say Y here, if you want the device to enter USB host mode
 410 +         by default on bootup.
 411 +
 412 +endif # CBUS_TAHVO
 413 +
 414 +config CBUS_RETU
 415 +       depends on CBUS
 416 +       bool "Support for Retu"
 417 +       ---help---
 418 +         Retu is a mixed signal ASIC with some system features
 419 +
 420 +         If you want Retu support, you should say Y here.
 421 +
 422 +if CBUS_RETU
 423 +
 424 +config CBUS_RETU_POWERBUTTON
 425 +       depends on INPUT
 426 +       bool "Support for Retu power button"
 427 +       ---help---
 428 +         The power button on Nokia 770 is connected to the Retu ASIC.
 429 +
 430 +         If you want support for the Retu power button, you should say Y here.
 431 +
 432 +config CBUS_RETU_RTC
 433 +       depends on RTC_CLASS
 434 +       depends on ARCH_OMAP
 435 +       tristate "Support for Retu pseudo-RTC"
 436 +       ---help---
 437 +         Say Y here if you want support for the device that alleges to be an
 438 +         RTC in Retu. This will expose a sysfs interface for it.
 439 +
 440 +config CBUS_RETU_WDT
 441 +       depends on SYSFS && WATCHDOG
 442 +       depends on ARCH_OMAP
 443 +       tristate "Support for Retu watchdog timer"
 444 +       ---help---
 445 +         Say Y here if you want support for the watchdog in Retu. This will
 446 +         expose a sysfs interface to grok it.
 447 +
 448 +config CBUS_RETU_HEADSET
 449 +       depends on SYSFS
 450 +       tristate "Support for headset detection with Retu/Vilma"
 451 +       ---help---
 452 +         Say Y here if you want support detecting a headset that's connected
 453 +         to Retu/Vilma. Detection state and events are exposed through
 454 +         sysfs.
 455 +
 456 +endif # CBUS_RETU
 457 +
 458 +endmenu
 459 --- /dev/null
 460 +++ b/drivers/cbus/Makefile
 461 @@ -0,0 +1,13 @@
 462 +#
 463 +# Makefile for CBUS.
 464 +#
 465 +
 466 +obj-$(CONFIG_CBUS)             += cbus.o
 467 +obj-$(CONFIG_CBUS_TAHVO)       += tahvo.o
 468 +obj-$(CONFIG_CBUS_RETU)                += retu.o
 469 +obj-$(CONFIG_CBUS_TAHVO_USB)   += tahvo-usb.o
 470 +
 471 +obj-$(CONFIG_CBUS_RETU_POWERBUTTON) += retu-pwrbutton.o
 472 +obj-$(CONFIG_CBUS_RETU_RTC)    += retu-rtc.o
 473 +obj-$(CONFIG_CBUS_RETU_WDT)    += retu-wdt.o
 474 +obj-$(CONFIG_CBUS_RETU_HEADSET)        += retu-headset.o
 475 --- /dev/null
 476 +++ b/drivers/cbus/retu.c
 477 @@ -0,0 +1,549 @@
 478 +/**
 479 + * drivers/cbus/retu.c
 480 + *
 481 + * Support functions for Retu ASIC
 482 + *
 483 + * Copyright (C) 2004, 2005 Nokia Corporation
 484 + *
 485 + * Written by Juha Yrjölä <juha.yrjola@nokia.com>,
 486 + *           David Weinehall <david.weinehall@nokia.com>, and
 487 + *           Mikko Ylinen <mikko.k.ylinen@nokia.com>
 488 + *
 489 + * This file is subject to the terms and conditions of the GNU General
 490 + * Public License. See the file "COPYING" in the main directory of this
 491 + * archive for more details.
 492 + *
 493 + * This program is distributed in the hope that it will be useful,
 494 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 495 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 496 + * GNU General Public License for more details.
 497 + *
 498 + * You should have received a copy of the GNU General Public License
 499 + * along with this program; if not, write to the Free Software
 500 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 501 + */
 502 +
 503 +#include <linux/module.h>
 504 +#include <linux/init.h>
 505 +
 506 +#include <linux/slab.h>
 507 +#include <linux/kernel.h>
 508 +#include <linux/errno.h>
 509 +#include <linux/device.h>
 510 +#include <linux/mutex.h>
 511 +#include <linux/irq.h>
 512 +#include <linux/interrupt.h>
 513 +#include <linux/platform_device.h>
 514 +#include <linux/platform_data/cbus.h>
 515 +
 516 +#include <asm/bitops.h>
 517 +
 518 +#include "cbus.h"
 519 +#include "retu.h"
 520 +
 521 +struct retu {
 522 +       /* Device lock */
 523 +       struct mutex            mutex;
 524 +       struct device           *dev;
 525 +
 526 +       int                     devid;
 527 +
 528 +       int                     irq_base;
 529 +       int                     irq_end;
 530 +
 531 +       int                     irq;
 532 +
 533 +       int                     ack;
 534 +       bool                    ack_pending;
 535 +
 536 +       int                     mask;
 537 +       bool                    mask_pending;
 538 +
 539 +       bool                    is_vilma;
 540 +};
 541 +
 542 +static struct retu *the_retu;
 543 +
 544 +/**
 545 + * __retu_read_reg - Read a value from a register in Retu
 546 + * @retu: pointer to retu structure
 547 + * @reg: the register address to read from
 548 + */
 549 +static int __retu_read_reg(struct retu *retu, unsigned reg)
 550 +{
 551 +       return cbus_read_reg(retu->dev, retu->devid, reg);
 552 +}
 553 +
 554 +/**
 555 + * __retu_write_reg - Writes a value to a register in Retu
 556 + * @retu: pointer to retu structure
 557 + * @reg: the register address to write to
 558 + * @val: the value to write to the register
 559 + */
 560 +static void __retu_write_reg(struct retu *retu, unsigned reg, u16 val)
 561 +{
 562 +       cbus_write_reg(retu->dev, retu->devid, reg, val);
 563 +}
 564 +
 565 +/**
 566 + * retu_read_reg - Read a value from a register in Retu
 567 + * @child: device pointer for the calling child
 568 + * @reg: the register to read from
 569 + *
 570 + * This function returns the contents of the specified register
 571 + */
 572 +int retu_read_reg(struct device *child, unsigned reg)
 573 +{
 574 +       struct retu             *retu = dev_get_drvdata(child->parent);
 575 +
 576 +       return __retu_read_reg(retu, reg);
 577 +}
 578 +EXPORT_SYMBOL_GPL(retu_read_reg);
 579 +
 580 +/**
 581 + * retu_write_reg - Write a value to a register in Retu
 582 + * @child: the pointer to our calling child
 583 + * @reg: the register to write to
 584 + * @val: the value to write to the register
 585 + *
 586 + * This function writes a value to the specified register
 587 + */
 588 +void retu_write_reg(struct device *child, unsigned reg, u16 val)
 589 +{
 590 +       struct retu             *retu = dev_get_drvdata(child->parent);
 591 +
 592 +       mutex_lock(&retu->mutex);
 593 +       __retu_write_reg(retu, reg, val);
 594 +       mutex_unlock(&retu->mutex);
 595 +}
 596 +EXPORT_SYMBOL_GPL(retu_write_reg);
 597 +
 598 +/**
 599 + * retu_set_clear_reg_bits - helper function to read/set/clear bits
 600 + * @child: device pointer to calling child
 601 + * @reg: the register address
 602 + * @set: mask for setting bits
 603 + * @clear: mask for clearing bits
 604 + */
 605 +void retu_set_clear_reg_bits(struct device *child, unsigned reg, u16 set,
 606 +               u16 clear)
 607 +{
 608 +       struct retu             *retu = dev_get_drvdata(child->parent);
 609 +       u16                     w;
 610 +
 611 +       mutex_lock(&retu->mutex);
 612 +       w = __retu_read_reg(retu, reg);
 613 +       w &= ~clear;
 614 +       w |= set;
 615 +       __retu_write_reg(retu, reg, w);
 616 +       mutex_unlock(&retu->mutex);
 617 +}
 618 +EXPORT_SYMBOL_GPL(retu_set_clear_reg_bits);
 619 +
 620 +#define ADC_MAX_CHAN_NUMBER    13
 621 +
 622 +/**
 623 + * retu_read_adc - Reads AD conversion result
 624 + * @child: device pointer to calling child
 625 + * @channel: the ADC channel to read from
 626 + */
 627 +int retu_read_adc(struct device *child, int channel)
 628 +{
 629 +       struct retu             *retu = dev_get_drvdata(child->parent);
 630 +       int                     res;
 631 +
 632 +       if (!retu)
 633 +               return -ENODEV;
 634 +
 635 +       if (channel < 0 || channel > ADC_MAX_CHAN_NUMBER)
 636 +               return -EINVAL;
 637 +
 638 +       mutex_lock(&retu->mutex);
 639 +
 640 +       if ((channel == 8) && retu->is_vilma) {
 641 +               int scr = __retu_read_reg(retu, RETU_REG_ADCSCR);
 642 +               int ch = (__retu_read_reg(retu, RETU_REG_ADCR) >> 10) & 0xf;
 643 +               if (((scr & 0xff) != 0) && (ch != 8))
 644 +                       __retu_write_reg(retu, RETU_REG_ADCSCR, (scr & ~0xff));
 645 +       }
 646 +
 647 +       /* Select the channel and read result */
 648 +       __retu_write_reg(retu, RETU_REG_ADCR, channel << 10);
 649 +       res = __retu_read_reg(retu, RETU_REG_ADCR) & 0x3ff;
 650 +
 651 +       if (retu->is_vilma)
 652 +               __retu_write_reg(retu, RETU_REG_ADCR, (1 << 13));
 653 +
 654 +       /* Unlock retu */
 655 +       mutex_unlock(&retu->mutex);
 656 +
 657 +       return res;
 658 +}
 659 +EXPORT_SYMBOL_GPL(retu_read_adc);
 660 +
 661 +static irqreturn_t retu_irq_handler(int irq, void *_retu)
 662 +{
 663 +       struct retu             *retu = _retu;
 664 +
 665 +       u16                     idr;
 666 +       u16                     imr;
 667 +
 668 +       mutex_lock(&retu->mutex);
 669 +       idr = __retu_read_reg(retu, RETU_REG_IDR);
 670 +       imr = __retu_read_reg(retu, RETU_REG_IMR);
 671 +       mutex_unlock(&retu->mutex);
 672 +
 673 +       idr &= ~imr;
 674 +       if (!idr) {
 675 +               dev_vdbg(retu->dev, "No IRQ, spurious?\n");
 676 +               return IRQ_NONE;
 677 +       }
 678 +
 679 +       while (idr) {
 680 +               unsigned long   pending = __ffs(idr);
 681 +               unsigned int    irq;
 682 +
 683 +               idr &= ~BIT(pending);
 684 +               irq = pending + retu->irq_base;
 685 +               handle_nested_irq(irq);
 686 +       }
 687 +
 688 +       return IRQ_HANDLED;
 689 +}
 690 +
 691 +/* -------------------------------------------------------------------------- */
 692 +
 693 +static void retu_irq_mask(struct irq_data *data)
 694 +{
 695 +       struct retu             *retu = irq_data_get_irq_chip_data(data);
 696 +       int                     irq = data->irq;
 697 +
 698 +       retu->mask |= (1 << (irq - retu->irq_base));
 699 +       retu->mask_pending = true;
 700 +}
 701 +
 702 +static void retu_irq_unmask(struct irq_data *data)
 703 +{
 704 +       struct retu             *retu = irq_data_get_irq_chip_data(data);
 705 +       int                     irq = data->irq;
 706 +
 707 +       retu->mask &= ~(1 << (irq - retu->irq_base));
 708 +       retu->mask_pending = true;
 709 +
 710 +}
 711 +
 712 +static void retu_irq_ack(struct irq_data *data)
 713 +{
 714 +       struct retu             *retu = irq_data_get_irq_chip_data(data);
 715 +       int                     irq = data->irq;
 716 +
 717 +       retu->ack |= (1 << (irq - retu->irq_base));
 718 +       retu->ack_pending = true;
 719 +}
 720 +
 721 +static void retu_bus_lock(struct irq_data *data)
 722 +{
 723 +       struct retu             *retu = irq_data_get_irq_chip_data(data);
 724 +
 725 +       mutex_lock(&retu->mutex);
 726 +}
 727 +
 728 +static void retu_bus_sync_unlock(struct irq_data *data)
 729 +{
 730 +       struct retu             *retu = irq_data_get_irq_chip_data(data);
 731 +
 732 +       if (retu->mask_pending) {
 733 +               __retu_write_reg(retu, RETU_REG_IMR, retu->mask);
 734 +               retu->mask_pending = false;
 735 +       }
 736 +
 737 +       if (retu->ack_pending) {
 738 +               __retu_write_reg(retu, RETU_REG_IDR, retu->ack);
 739 +               retu->ack_pending = false;
 740 +       }
 741 +
 742 +       mutex_unlock(&retu->mutex);
 743 +}
 744 +
 745 +static struct irq_chip retu_irq_chip = {
 746 +       .name                   = "retu",
 747 +       .irq_bus_lock           = retu_bus_lock,
 748 +       .irq_bus_sync_unlock    = retu_bus_sync_unlock,
 749 +       .irq_mask               = retu_irq_mask,
 750 +       .irq_unmask             = retu_irq_unmask,
 751 +       .irq_ack                = retu_irq_ack,
 752 +};
 753 +
 754 +static inline void retu_irq_setup(int irq)
 755 +{
 756 +#ifdef CONFIG_ARM
 757 +       set_irq_flags(irq, IRQF_VALID);
 758 +#else
 759 +       irq_set_noprobe(irq);
 760 +#endif
 761 +}
 762 +
 763 +static void retu_irq_init(struct retu *retu)
 764 +{
 765 +       int                     base = retu->irq_base;
 766 +       int                     end = retu->irq_end;
 767 +       int                     irq;
 768 +
 769 +       for (irq = base; irq < end; irq++) {
 770 +               irq_set_chip_data(irq, retu);
 771 +               irq_set_chip_and_handler(irq, &retu_irq_chip,
 772 +                               handle_simple_irq);
 773 +               irq_set_nested_thread(irq, 1);
 774 +               retu_irq_setup(irq);
 775 +       }
 776 +}
 777 +
 778 +static void retu_irq_exit(struct retu *retu)
 779 +{
 780 +       int                     base = retu->irq_base;
 781 +       int                     end = retu->irq_end;
 782 +       int                     irq;
 783 +
 784 +       for (irq = base; irq < end; irq++) {
 785 +#ifdef CONFIG_ARM
 786 +               set_irq_flags(irq, 0);
 787 +#endif
 788 +               irq_set_chip_and_handler(irq, NULL, NULL);
 789 +               irq_set_chip_data(irq, NULL);
 790 +       }
 791 +}
 792 +
 793 +/* -------------------------------------------------------------------------- */
 794 +
 795 +/**
 796 + * retu_power_off - Shut down power to system
 797 + *
 798 + * This function puts the system in power off state
 799 + */
 800 +static void retu_power_off(void)
 801 +{
 802 +       struct retu             *retu = the_retu;
 803 +       unsigned                reg;
 804 +
 805 +       reg = __retu_read_reg(retu, RETU_REG_CC1);
 806 +
 807 +       /* Ignore power button state */
 808 +       __retu_write_reg(retu, RETU_REG_CC1, reg | 2);
 809 +       /* Expire watchdog immediately */
 810 +       __retu_write_reg(retu, RETU_REG_WATCHDOG, 0);
 811 +       /* Wait for poweroff*/
 812 +       for (;;);
 813 +}
 814 +
 815 +static struct resource generic_resources[] = {
 816 +       {
 817 +               .start  = -EINVAL,      /* fixed later */
 818 +               .flags  = IORESOURCE_IRQ,
 819 +       },
 820 +       {
 821 +               .start  = -EINVAL,      /* fixed later */
 822 +               .flags  = IORESOURCE_IRQ,
 823 +       },
 824 +};
 825 +
 826 +/**
 827 + * retu_allocate_child - Allocates one Retu child
 828 + * @name: name of new child
 829 + * @parent: parent device for this child
 830 + */
 831 +static struct device *retu_allocate_child(char *name, struct device *parent,
 832 +               int irq_base, int irq1, int irq2, int num)
 833 +{
 834 +       struct platform_device          *pdev;
 835 +       int                             status;
 836 +
 837 +       pdev = platform_device_alloc(name, -1);
 838 +       if (!pdev) {
 839 +               dev_dbg(parent, "can't allocate %s\n", name);
 840 +               goto err;
 841 +       }
 842 +
 843 +       pdev->dev.parent = parent;
 844 +
 845 +       if (num) {
 846 +               generic_resources[0].start = irq_base + irq1;
 847 +               generic_resources[1].start = irq_base + irq2;
 848 +
 849 +               status = platform_device_add_resources(pdev,
 850 +                               generic_resources, num);
 851 +               if (status < 0) {
 852 +                       dev_dbg(parent, "can't add resources to %s\n", name);
 853 +                       goto err;
 854 +               }
 855 +       }
 856 +
 857 +       status = platform_device_add(pdev);
 858 +       if (status < 0) {
 859 +               dev_dbg(parent, "can't add %s\n", name);
 860 +               goto err;
 861 +       }
 862 +
 863 +       return &pdev->dev;
 864 +
 865 +err:
 866 +       platform_device_put(pdev);
 867 +
 868 +       return NULL;
 869 +}
 870 +
 871 +/**
 872 + * retu_allocate_children - Allocates Retu's children
 873 + */
 874 +static int retu_allocate_children(struct device *parent, int irq_base)
 875 +{
 876 +       struct device   *child;
 877 +
 878 +       child = retu_allocate_child("retu-pwrbutton", parent, irq_base,
 879 +                       RETU_INT_PWR, -1, 1);
 880 +       if (!child)
 881 +               return -ENOMEM;
 882 +
 883 +       child = retu_allocate_child("retu-headset", parent, irq_base,
 884 +                       RETU_INT_HOOK, -1, 1);
 885 +       if (!child)
 886 +               return -ENOMEM;
 887 +
 888 +       child = retu_allocate_child("retu-rtc", parent, irq_base,
 889 +                       RETU_INT_RTCS, RETU_INT_RTCA, 2);
 890 +       if (!child)
 891 +               return -ENOMEM;
 892 +
 893 +       child = retu_allocate_child("retu-wdt", parent, -1, -1, -1, 0);
 894 +       if (!child)
 895 +               return -ENOMEM;
 896 +
 897 +       return 0;
 898 +}
 899 +
 900 +/**
 901 + * retu_probe - Probe for Retu ASIC
 902 + * @dev: the Retu device
 903 + *
 904 + * Probe for the Retu ASIC and allocate memory
 905 + * for its device-struct if found
 906 + */
 907 +static int __devinit retu_probe(struct platform_device *pdev)
 908 +{
 909 +       struct retu     *retu;
 910 +       struct cbus_retu_platform_data *pdata = pdev->dev.platform_data;
 911 +
 912 +       int             ret = -ENOMEM;
 913 +       int             rev;
 914 +
 915 +       retu = kzalloc(sizeof(*retu), GFP_KERNEL);
 916 +       if (!retu) {
 917 +               dev_err(&pdev->dev, "not enough memory\n");
 918 +               goto err0;
 919 +       }
 920 +
 921 +       platform_set_drvdata(pdev, retu);
 922 +
 923 +       ret = irq_alloc_descs(-1, 0, MAX_RETU_IRQ_HANDLERS, 0);
 924 +       if (ret < 0) {
 925 +               dev_err(&pdev->dev, "failed to allocate IRQ descs\n");
 926 +               goto err1;
 927 +       }
 928 +
 929 +       retu->irq       = platform_get_irq(pdev, 0);
 930 +       retu->irq_base  = ret;
 931 +       retu->irq_end   = ret + MAX_RETU_IRQ_HANDLERS;
 932 +       retu->devid     = pdata->devid;
 933 +       retu->dev       = &pdev->dev;
 934 +       the_retu        = retu;
 935 +
 936 +       mutex_init(&retu->mutex);
 937 +
 938 +       retu_irq_init(retu);
 939 +
 940 +       rev = __retu_read_reg(retu, RETU_REG_ASICR) & 0xff;
 941 +       if (rev & (1 << 7))
 942 +               retu->is_vilma = true;
 943 +
 944 +       dev_info(&pdev->dev, "%s v%d.%d found\n",
 945 +                       retu->is_vilma ? "Vilma" : "Retu",
 946 +                       (rev >> 4) & 0x07, rev & 0x0f);
 947 +
 948 +       /* Mask all RETU interrupts */
 949 +       __retu_write_reg(retu, RETU_REG_IMR, 0xffff);
 950 +
 951 +       ret = request_threaded_irq(retu->irq, NULL, retu_irq_handler,
 952 +                       IRQF_ONESHOT, "retu", retu);
 953 +       if (ret < 0) {
 954 +               dev_err(&pdev->dev, "Unable to register IRQ handler\n");
 955 +               goto err2;
 956 +       }
 957 +
 958 +       irq_set_irq_wake(retu->irq, 1);
 959 +
 960 +       /* Register power off function */
 961 +       pm_power_off = retu_power_off;
 962 +
 963 +       ret = retu_allocate_children(&pdev->dev, retu->irq_base);
 964 +       if (ret < 0) {
 965 +               dev_err(&pdev->dev, "Unable to allocate Retu children\n");
 966 +               goto err3;
 967 +       }
 968 +
 969 +       return 0;
 970 +
 971 +err3:
 972 +       pm_power_off = NULL;
 973 +       free_irq(retu->irq, retu);
 974 +
 975 +err2:
 976 +       retu_irq_exit(retu);
 977 +       irq_free_descs(retu->irq_base, MAX_RETU_IRQ_HANDLERS);
 978 +
 979 +err1:
 980 +       kfree(retu);
 981 +       the_retu = NULL;
 982 +
 983 +err0:
 984 +       return ret;
 985 +}
 986 +
 987 +static int __devexit retu_remove(struct platform_device *pdev)
 988 +{
 989 +       struct retu             *retu = platform_get_drvdata(pdev);
 990 +
 991 +       pm_power_off = NULL;
 992 +       the_retu = NULL;
 993 +
 994 +       free_irq(retu->irq, retu);
 995 +       retu_irq_exit(retu);
 996 +       irq_free_descs(retu->irq_base, MAX_RETU_IRQ_HANDLERS);
 997 +       kfree(retu);
 998 +
 999 +       return 0;
1000 +}
1001 +
1002 +static struct platform_driver retu_driver = {
1003 +       .probe          = retu_probe,
1004 +       .remove         = __devexit_p(retu_remove),
1005 +       .driver         = {
1006 +               .name   = "retu",
1007 +       },
1008 +};
1009 +
1010 +static int __init retu_init(void)
1011 +{
1012 +       return platform_driver_register(&retu_driver);
1013 +}
1014 +subsys_initcall(retu_init);
1015 +
1016 +static void __exit retu_exit(void)
1017 +{
1018 +       platform_driver_unregister(&retu_driver);
1019 +}
1020 +module_exit(retu_exit);
1021 +
1022 +MODULE_DESCRIPTION("Retu ASIC control");
1023 +MODULE_LICENSE("GPL");
1024 +MODULE_AUTHOR("Juha Yrjölä");
1025 +MODULE_AUTHOR("David Weinehall");
1026 +MODULE_AUTHOR("Mikko Ylinen");
1027 --- /dev/null
1028 +++ b/drivers/cbus/retu.h
1029 @@ -0,0 +1,85 @@
1030 +/**
1031 + * drivers/cbus/retu.h
1032 + *
1033 + * Copyright (C) 2004, 2005 Nokia Corporation
1034 + *
1035 + * Written by Juha Yrjölä <juha.yrjola@nokia.com> and
1036 + *           David Weinehall <david.weinehall@nokia.com>
1037 + *
1038 + * This file is subject to the terms and conditions of the GNU General
1039 + * Public License. See the file "COPYING" in the main directory of this
1040 + * archive for more details.
1041 + *
1042 + * This program is distributed in the hope that it will be useful,
1043 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1044 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1045 + * GNU General Public License for more details.
1046 +
1047 + * You should have received a copy of the GNU General Public License
1048 + * along with this program; if not, write to the Free Software
1049 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
1050 + */
1051 +
1052 +#ifndef __DRIVERS_CBUS_RETU_H
1053 +#define __DRIVERS_CBUS_RETU_H
1054 +
1055 +#include <linux/types.h>
1056 +
1057 +/* Registers */
1058 +#define RETU_REG_ASICR         0x00    /* ASIC ID & revision */
1059 +#define RETU_REG_IDR           0x01    /* Interrupt ID */
1060 +#define RETU_REG_IMR           0x02    /* Interrupt mask */
1061 +#define RETU_REG_RTCDSR                0x03    /* RTC seconds register */
1062 +#define RETU_REG_RTCHMR                0x04    /* RTC hours and minutes register */
1063 +#define RETU_REG_RTCHMAR       0x05    /* RTC hours and minutes alarm and time set register */
1064 +#define RETU_REG_RTCCALR       0x06    /* RTC calibration register */
1065 +#define RETU_REG_ADCR          0x08    /* ADC result */
1066 +#define RETU_REG_ADCSCR                0x09    /* ADC sample ctrl */
1067 +#define RETU_REG_CC1           0x0d    /* Common control register 1 */
1068 +#define RETU_REG_CC2           0x0e    /* Common control register 2 */
1069 +#define RETU_REG_CTRL_CLR      0x0f    /* Regulator clear register */
1070 +#define RETU_REG_CTRL_SET      0x10    /* Regulator set register */
1071 +#define RETU_REG_STATUS                0x16    /* Status register */
1072 +#define  RETU_REG_STATUS_BATAVAIL      0x0100 /* Battery available */
1073 +#define  RETU_REG_STATUS_CHGPLUG       0x1000 /* Charger is plugged in */
1074 +#define RETU_REG_WATCHDOG      0x17    /* Watchdog register */
1075 +#define RETU_REG_AUDTXR                0x18    /* Audio Codec Tx register */
1076 +#define RETU_REG_MAX           0x1f
1077 +
1078 +/* Interrupt sources */
1079 +#define RETU_INT_PWR           0
1080 +#define RETU_INT_CHAR          1
1081 +#define RETU_INT_RTCS          2
1082 +#define RETU_INT_RTCM          3
1083 +#define RETU_INT_RTCD          4
1084 +#define RETU_INT_RTCA          5
1085 +#define RETU_INT_HOOK          6
1086 +#define RETU_INT_HEAD          7
1087 +#define RETU_INT_ADCS          8
1088 +
1089 +#define        MAX_RETU_IRQ_HANDLERS   16
1090 +
1091 +/* ADC channels */
1092 +#define RETU_ADC_GND           0x00 /* Ground */
1093 +#define RETU_ADC_BSI           0x01 /* Battery Size Indicator */
1094 +#define RETU_ADC_BATTEMP       0x02 /* Battery temperature */
1095 +#define RETU_ADC_CHGVOLT       0x03 /* Charger voltage */
1096 +#define RETU_ADC_HEADSET       0x04 /* Headset detection */
1097 +#define RETU_ADC_HOOKDET       0x05 /* Hook detection */
1098 +#define RETU_ADC_RFGP          0x06 /* RF GP */
1099 +#define RETU_ADC_WBTX          0x07 /* Wideband Tx detection */
1100 +#define RETU_ADC_BATTVOLT      0x08 /* Battery voltage measurement */
1101 +#define RETU_ADC_GND2          0x09 /* Ground */
1102 +#define RETU_ADC_LIGHTSENS     0x0A /* Light sensor */
1103 +#define RETU_ADC_LIGHTTEMP     0x0B /* Light sensor temperature */
1104 +#define RETU_ADC_BKUPVOLT      0x0C /* Backup battery voltage */
1105 +#define RETU_ADC_TEMP          0x0D /* RETU temperature */
1106 +
1107 +
1108 +int retu_read_reg(struct device *child, unsigned reg);
1109 +void retu_write_reg(struct device *child, unsigned reg, u16 val);
1110 +void retu_set_clear_reg_bits(struct device *child, unsigned reg, u16 set,
1111 +               u16 clear);
1112 +int retu_read_adc(struct device *child, int channel);
1113 +
1114 +#endif /* __DRIVERS_CBUS_RETU_H */
1115 --- /dev/null
1116 +++ b/drivers/cbus/retu-headset.c
1117 @@ -0,0 +1,359 @@
1118 +/**
1119 + * Retu/Vilma headset detection
1120 + *
1121 + * Copyright (C) 2006 Nokia Corporation
1122 + *
1123 + * Written by Juha Yrjölä
1124 + *
1125 + * This file is subject to the terms and conditions of the GNU General
1126 + * Public License. See the file "COPYING" in the main directory of this
1127 + * archive for more details.
1128 + *
1129 + * This program is distributed in the hope that it will be useful,
1130 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1131 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1132 + * GNU General Public License for more details.
1133 + *
1134 + * You should have received a copy of the GNU General Public License
1135 + * along with this program; if not, write to the Free Software
1136 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
1137 + */
1138 +
1139 +#include <linux/module.h>
1140 +#include <linux/init.h>
1141 +#include <linux/kernel.h>
1142 +#include <linux/irq.h>
1143 +#include <linux/interrupt.h>
1144 +#include <linux/slab.h>
1145 +#include <linux/delay.h>
1146 +#include <linux/input.h>
1147 +#include <linux/platform_device.h>
1148 +
1149 +#include "retu.h"
1150 +
1151 +#define RETU_ADC_CHANNEL_HOOKDET       0x05
1152 +
1153 +#define RETU_HEADSET_KEY               KEY_PHONE
1154 +
1155 +struct retu_headset {
1156 +       spinlock_t                      lock;
1157 +       struct mutex                    mutex;
1158 +       struct device                   *dev;
1159 +       struct input_dev                *idev;
1160 +       unsigned                        bias_enabled;
1161 +       unsigned                        detection_enabled;
1162 +       unsigned                        pressed;
1163 +       struct timer_list               enable_timer;
1164 +       struct timer_list               detect_timer;
1165 +       int                             irq;
1166 +};
1167 +
1168 +static void retu_headset_set_bias(struct retu_headset *hs, int enable)
1169 +{
1170 +       if (enable) {
1171 +               retu_set_clear_reg_bits(hs->dev, RETU_REG_AUDTXR,
1172 +                                       (1 << 0) | (1 << 1), 0);
1173 +               msleep(2);
1174 +               retu_set_clear_reg_bits(hs->dev, RETU_REG_AUDTXR,
1175 +                               1 << 3, 0);
1176 +       } else {
1177 +               retu_set_clear_reg_bits(hs->dev, RETU_REG_AUDTXR, 0,
1178 +                                       (1 << 0) | (1 << 1) | (1 << 3));
1179 +       }
1180 +}
1181 +
1182 +static void retu_headset_enable(struct retu_headset *hs)
1183 +{
1184 +       mutex_lock(&hs->mutex);
1185 +       if (!hs->bias_enabled) {
1186 +               hs->bias_enabled = 1;
1187 +               retu_headset_set_bias(hs, 1);
1188 +       }
1189 +       mutex_unlock(&hs->mutex);
1190 +}
1191 +
1192 +static void retu_headset_disable(struct retu_headset *hs)
1193 +{
1194 +       mutex_lock(&hs->mutex);
1195 +       if (hs->bias_enabled) {
1196 +               hs->bias_enabled = 0;
1197 +               retu_headset_set_bias(hs, 0);
1198 +       }
1199 +       mutex_unlock(&hs->mutex);
1200 +}
1201 +
1202 +static void retu_headset_det_enable(struct retu_headset *hs)
1203 +{
1204 +       mutex_lock(&hs->mutex);
1205 +       if (!hs->detection_enabled) {
1206 +               hs->detection_enabled = 1;
1207 +               retu_set_clear_reg_bits(hs->dev, RETU_REG_CC1,
1208 +                               (1 << 10) | (1 << 8), 0);
1209 +       }
1210 +       mutex_unlock(&hs->mutex);
1211 +}
1212 +
1213 +static void retu_headset_det_disable(struct retu_headset *hs)
1214 +{
1215 +       unsigned long flags;
1216 +
1217 +       mutex_lock(&hs->mutex);
1218 +       if (hs->detection_enabled) {
1219 +               hs->detection_enabled = 0;
1220 +               del_timer_sync(&hs->enable_timer);
1221 +               del_timer_sync(&hs->detect_timer);
1222 +               spin_lock_irqsave(&hs->lock, flags);
1223 +               if (hs->pressed)
1224 +                       input_report_key(hs->idev, RETU_HEADSET_KEY, 0);
1225 +               spin_unlock_irqrestore(&hs->lock, flags);
1226 +               retu_set_clear_reg_bits(hs->dev, RETU_REG_CC1, 0,
1227 +                               (1 << 10) | (1 << 8));
1228 +       }
1229 +       mutex_unlock(&hs->mutex);
1230 +}
1231 +
1232 +static ssize_t retu_headset_hookdet_show(struct device *dev,
1233 +                                        struct device_attribute *attr,
1234 +                                        char *buf)
1235 +{
1236 +       int val;
1237 +
1238 +       val = retu_read_adc(dev, RETU_ADC_CHANNEL_HOOKDET);
1239 +       return sprintf(buf, "%d\n", val);
1240 +}
1241 +
1242 +static DEVICE_ATTR(hookdet, S_IRUGO, retu_headset_hookdet_show, NULL);
1243 +
1244 +static ssize_t retu_headset_enable_show(struct device *dev,
1245 +                                       struct device_attribute *attr,
1246 +                                       char *buf)
1247 +{
1248 +       struct retu_headset *hs = dev_get_drvdata(dev);
1249 +
1250 +       return sprintf(buf, "%u\n", hs->bias_enabled);
1251 +}
1252 +
1253 +static ssize_t retu_headset_enable_store(struct device *dev,
1254 +                                        struct device_attribute *attr,
1255 +                                        const char *buf, size_t count)
1256 +{
1257 +       struct retu_headset *hs = dev_get_drvdata(dev);
1258 +       int enable;
1259 +
1260 +       if (sscanf(buf, "%u", &enable) != 1)
1261 +               return -EINVAL;
1262 +       if (enable)
1263 +               retu_headset_enable(hs);
1264 +       else
1265 +               retu_headset_disable(hs);
1266 +       return count;
1267 +}
1268 +
1269 +static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR | S_IWGRP,
1270 +                  retu_headset_enable_show, retu_headset_enable_store);
1271 +
1272 +static ssize_t retu_headset_enable_det_show(struct device *dev,
1273 +                                           struct device_attribute *attr,
1274 +                                           char *buf)
1275 +{
1276 +       struct retu_headset *hs = dev_get_drvdata(dev);
1277 +
1278 +       return sprintf(buf, "%u\n", hs->detection_enabled);
1279 +}
1280 +
1281 +static ssize_t retu_headset_enable_det_store(struct device *dev,
1282 +                                            struct device_attribute *attr,
1283 +                                            const char *buf, size_t count)
1284 +{
1285 +       struct retu_headset *hs = dev_get_drvdata(dev);
1286 +       int enable;
1287 +
1288 +       if (sscanf(buf, "%u", &enable) != 1)
1289 +               return -EINVAL;
1290 +       if (enable)
1291 +               retu_headset_det_enable(hs);
1292 +       else
1293 +               retu_headset_det_disable(hs);
1294 +       return count;
1295 +}
1296 +
1297 +static DEVICE_ATTR(enable_det, S_IRUGO | S_IWUSR | S_IWGRP,
1298 +                  retu_headset_enable_det_show,
1299 +                  retu_headset_enable_det_store);
1300 +
1301 +static irqreturn_t retu_headset_hook_interrupt(int irq, void *_hs)
1302 +{
1303 +       struct retu_headset     *hs = _hs;
1304 +       unsigned long           flags;
1305 +
1306 +       spin_lock_irqsave(&hs->lock, flags);
1307 +       if (!hs->pressed) {
1308 +               /* Headset button was just pressed down. */
1309 +               hs->pressed = 1;
1310 +               input_report_key(hs->idev, RETU_HEADSET_KEY, 1);
1311 +       }
1312 +       spin_unlock_irqrestore(&hs->lock, flags);
1313 +       retu_set_clear_reg_bits(hs->dev, RETU_REG_CC1, 0,
1314 +                       (1 << 10) | (1 << 8));
1315 +       mod_timer(&hs->enable_timer, jiffies + msecs_to_jiffies(50));
1316 +
1317 +       return IRQ_HANDLED;
1318 +}
1319 +
1320 +static void retu_headset_enable_timer(unsigned long arg)
1321 +{
1322 +       struct retu_headset *hs = (struct retu_headset *) arg;
1323 +
1324 +       retu_set_clear_reg_bits(hs->dev, RETU_REG_CC1,
1325 +                       (1 << 10) | (1 << 8), 0);
1326 +       mod_timer(&hs->detect_timer, jiffies + msecs_to_jiffies(350));
1327 +}
1328 +
1329 +static void retu_headset_detect_timer(unsigned long arg)
1330 +{
1331 +       struct retu_headset *hs = (struct retu_headset *) arg;
1332 +       unsigned long flags;
1333 +
1334 +       spin_lock_irqsave(&hs->lock, flags);
1335 +       if (hs->pressed) {
1336 +               hs->pressed = 0;
1337 +               input_report_key(hs->idev, RETU_HEADSET_KEY, 0);
1338 +       }
1339 +       spin_unlock_irqrestore(&hs->lock, flags);
1340 +}
1341 +
1342 +static int __init retu_headset_probe(struct platform_device *pdev)
1343 +{
1344 +       struct retu_headset *hs;
1345 +       int irq;
1346 +       int r;
1347 +
1348 +       hs = kzalloc(sizeof(*hs), GFP_KERNEL);
1349 +       if (hs == NULL)
1350 +               return -ENOMEM;
1351 +
1352 +       hs->dev = &pdev->dev;
1353 +
1354 +       hs->idev = input_allocate_device();
1355 +       if (hs->idev == NULL) {
1356 +               r = -ENOMEM;
1357 +               goto err1;
1358 +       }
1359 +       hs->idev->name = "retu-headset";
1360 +       hs->idev->dev.parent = &pdev->dev;
1361 +       set_bit(EV_KEY, hs->idev->evbit);
1362 +       set_bit(RETU_HEADSET_KEY, hs->idev->keybit);
1363 +       r = input_register_device(hs->idev);
1364 +       if (r < 0)
1365 +               goto err2;
1366 +
1367 +       r = device_create_file(&pdev->dev, &dev_attr_hookdet);
1368 +       if (r < 0)
1369 +               goto err3;
1370 +       r = device_create_file(&pdev->dev, &dev_attr_enable);
1371 +       if (r < 0)
1372 +               goto err4;
1373 +       r = device_create_file(&pdev->dev, &dev_attr_enable_det);
1374 +       if (r < 0)
1375 +               goto err5;
1376 +       platform_set_drvdata(pdev, hs);
1377 +
1378 +       spin_lock_init(&hs->lock);
1379 +       mutex_init(&hs->mutex);
1380 +       setup_timer(&hs->enable_timer, retu_headset_enable_timer,
1381 +                   (unsigned long) hs);
1382 +       setup_timer(&hs->detect_timer, retu_headset_detect_timer,
1383 +                   (unsigned long) hs);
1384 +
1385 +       irq = platform_get_irq(pdev, 0);
1386 +       hs->irq = irq;
1387 +
1388 +       r = request_threaded_irq(irq, NULL, retu_headset_hook_interrupt, 0,
1389 +                       "hookdet", hs);
1390 +       if (r != 0) {
1391 +               dev_err(&pdev->dev, "hookdet IRQ not available\n");
1392 +               goto err6;
1393 +       }
1394 +
1395 +       return 0;
1396 +err6:
1397 +       device_remove_file(&pdev->dev, &dev_attr_enable_det);
1398 +err5:
1399 +       device_remove_file(&pdev->dev, &dev_attr_enable);
1400 +err4:
1401 +       device_remove_file(&pdev->dev, &dev_attr_hookdet);
1402 +err3:
1403 +       input_unregister_device(hs->idev);
1404 +err2:
1405 +       input_free_device(hs->idev);
1406 +err1:
1407 +       kfree(hs);
1408 +       return r;
1409 +}
1410 +
1411 +static int retu_headset_remove(struct platform_device *pdev)
1412 +{
1413 +       struct retu_headset *hs = platform_get_drvdata(pdev);
1414 +
1415 +       device_remove_file(&pdev->dev, &dev_attr_hookdet);
1416 +       device_remove_file(&pdev->dev, &dev_attr_enable);
1417 +       device_remove_file(&pdev->dev, &dev_attr_enable_det);
1418 +       retu_headset_disable(hs);
1419 +       retu_headset_det_disable(hs);
1420 +       free_irq(hs->irq, hs);
1421 +       input_unregister_device(hs->idev);
1422 +       input_free_device(hs->idev);
1423 +
1424 +       return 0;
1425 +}
1426 +
1427 +static int retu_headset_suspend(struct platform_device *pdev,
1428 +                               pm_message_t mesg)
1429 +{
1430 +       struct retu_headset *hs = platform_get_drvdata(pdev);
1431 +
1432 +       mutex_lock(&hs->mutex);
1433 +       if (hs->bias_enabled)
1434 +               retu_headset_set_bias(hs, 0);
1435 +       mutex_unlock(&hs->mutex);
1436 +
1437 +       return 0;
1438 +}
1439 +
1440 +static int retu_headset_resume(struct platform_device *pdev)
1441 +{
1442 +       struct retu_headset *hs = platform_get_drvdata(pdev);
1443 +
1444 +       mutex_lock(&hs->mutex);
1445 +       if (hs->bias_enabled)
1446 +               retu_headset_set_bias(hs, 1);
1447 +       mutex_unlock(&hs->mutex);
1448 +
1449 +       return 0;
1450 +}
1451 +
1452 +static struct platform_driver retu_headset_driver = {
1453 +       .remove         = retu_headset_remove,
1454 +       .suspend        = retu_headset_suspend,
1455 +       .resume         = retu_headset_resume,
1456 +       .driver         = {
1457 +               .name   = "retu-headset",
1458 +       },
1459 +};
1460 +
1461 +static int __init retu_headset_init(void)
1462 +{
1463 +       return platform_driver_probe(&retu_headset_driver, retu_headset_probe);
1464 +}
1465 +
1466 +static void __exit retu_headset_exit(void)
1467 +{
1468 +       platform_driver_unregister(&retu_headset_driver);
1469 +}
1470 +
1471 +module_init(retu_headset_init);
1472 +module_exit(retu_headset_exit);
1473 +
1474 +MODULE_DESCRIPTION("Retu/Vilma headset detection");
1475 +MODULE_LICENSE("GPL");
1476 +MODULE_AUTHOR("Juha Yrjölä");
1477 --- /dev/null
1478 +++ b/drivers/cbus/retu-pwrbutton.c
1479 @@ -0,0 +1,165 @@
1480 +/**
1481 + * drivers/cbus/retu-pwrbutton.c
1482 + *
1483 + * Driver for sending retu power button event to input-layer
1484 + *
1485 + * Copyright (C) 2004-2010 Nokia Corporation
1486 + *
1487 + * Written by
1488 + *     Ari Saastamoinen <ari.saastamoinen@elektrobit.com>
1489 + *     Juha Yrjola <juha.yrjola@solidboot.com>
1490 + *
1491 + * Contact: Felipe Balbi <felipe.balbi@nokia.com>
1492 + *
1493 + * This file is subject to the terms and conditions of the GNU General
1494 + * Public License. See the file "COPYING" in the main directory of this
1495 + * archive for more details.
1496 + *
1497 + * This program is distributed in the hope that it will be useful,
1498 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1499 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1500 + * GNU General Public License for more details.
1501 + *
1502 + * You should have received a copy of the GNU General Public License
1503 + * along with this program; if not, write to the Free Software
1504 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
1505 + */
1506 +
1507 +#include <linux/module.h>
1508 +#include <linux/init.h>
1509 +#include <linux/kernel.h>
1510 +#include <linux/errno.h>
1511 +#include <linux/input.h>
1512 +#include <linux/jiffies.h>
1513 +#include <linux/bitops.h>
1514 +#include <linux/irq.h>
1515 +#include <linux/interrupt.h>
1516 +#include <linux/platform_device.h>
1517 +#include <linux/slab.h>
1518 +
1519 +#include "retu.h"
1520 +
1521 +#define RETU_STATUS_PWRONX     (1 << 5)
1522 +
1523 +#define PWRBTN_DELAY           20
1524 +#define PWRBTN_UP              0
1525 +#define PWRBTN_PRESSED         1
1526 +
1527 +struct retu_pwrbutton {
1528 +       struct input_dev        *idev;
1529 +       struct device           *dev;
1530 +
1531 +       int                     state;
1532 +       int                     irq;
1533 +};
1534 +
1535 +static irqreturn_t retubutton_irq(int irq, void *_pwr)
1536 +{
1537 +       struct retu_pwrbutton *pwr = _pwr;
1538 +       int state;
1539 +
1540 +       if (retu_read_reg(pwr->dev, RETU_REG_STATUS) & RETU_STATUS_PWRONX)
1541 +               state = PWRBTN_UP;
1542 +       else
1543 +               state = PWRBTN_PRESSED;
1544 +
1545 +       if (pwr->state != state) {
1546 +               input_report_key(pwr->idev, KEY_POWER, state);
1547 +               input_sync(pwr->idev);
1548 +               pwr->state = state;
1549 +       }
1550 +
1551 +       return IRQ_HANDLED;
1552 +}
1553 +
1554 +static int __init retubutton_probe(struct platform_device *pdev)
1555 +{
1556 +       struct retu_pwrbutton           *pwr;
1557 +       int                             ret = 0;
1558 +
1559 +       pwr = kzalloc(sizeof(*pwr), GFP_KERNEL);
1560 +       if (!pwr) {
1561 +               dev_err(&pdev->dev, "not enough memory\n");
1562 +               ret = -ENOMEM;
1563 +               goto err0;
1564 +       }
1565 +
1566 +       pwr->dev = &pdev->dev;
1567 +       pwr->irq = platform_get_irq(pdev, 0);
1568 +       platform_set_drvdata(pdev, pwr);
1569 +
1570 +       ret = request_threaded_irq(pwr->irq, NULL, retubutton_irq, 0,
1571 +                       "retu-pwrbutton", pwr);
1572 +       if (ret < 0) {
1573 +               dev_err(&pdev->dev, "Cannot allocate irq\n");
1574 +               goto err1;
1575 +       }
1576 +
1577 +       pwr->idev = input_allocate_device();
1578 +       if (!pwr->idev) {
1579 +               dev_err(&pdev->dev, "can't allocate input device\n");
1580 +               ret = -ENOMEM;
1581 +               goto err2;
1582 +       }
1583 +
1584 +       pwr->idev->evbit[0] = BIT_MASK(EV_KEY);
1585 +       pwr->idev->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
1586 +       pwr->idev->name = "retu-pwrbutton";
1587 +
1588 +       ret = input_register_device(pwr->idev);
1589 +       if (ret < 0) {
1590 +               dev_err(&pdev->dev, "failed to register input device\n");
1591 +               goto err3;
1592 +       }
1593 +
1594 +       return 0;
1595 +
1596 +err3:
1597 +       input_free_device(pwr->idev);
1598 +
1599 +err2:
1600 +       free_irq(pwr->irq, pwr);
1601 +
1602 +err1:
1603 +       kfree(pwr);
1604 +
1605 +err0:
1606 +       return ret;
1607 +}
1608 +
1609 +static int __exit retubutton_remove(struct platform_device *pdev)
1610 +{
1611 +       struct retu_pwrbutton           *pwr = platform_get_drvdata(pdev);
1612 +
1613 +       free_irq(pwr->irq, pwr);
1614 +       input_unregister_device(pwr->idev);
1615 +       input_free_device(pwr->idev);
1616 +       kfree(pwr);
1617 +
1618 +       return 0;
1619 +}
1620 +
1621 +static struct platform_driver retu_pwrbutton_driver = {
1622 +       .remove         = __exit_p(retubutton_remove),
1623 +       .driver         = {
1624 +               .name   = "retu-pwrbutton",
1625 +       },
1626 +};
1627 +
1628 +static int __init retubutton_init(void)
1629 +{
1630 +       return platform_driver_probe(&retu_pwrbutton_driver, retubutton_probe);
1631 +}
1632 +module_init(retubutton_init);
1633 +
1634 +static void __exit retubutton_exit(void)
1635 +{
1636 +       platform_driver_unregister(&retu_pwrbutton_driver);
1637 +}
1638 +module_exit(retubutton_exit);
1639 +
1640 +MODULE_DESCRIPTION("Retu Power Button");
1641 +MODULE_LICENSE("GPL");
1642 +MODULE_AUTHOR("Ari Saastamoinen");
1643 +MODULE_AUTHOR("Felipe Balbi <felipe.balbi@nokia.com>");
1644 +
1645 --- /dev/null
1646 +++ b/drivers/cbus/retu-rtc.c
1647 @@ -0,0 +1,287 @@
1648 +/**
1649 + * drivers/cbus/retu-rtc.c
1650 + *
1651 + * Support for Retu RTC
1652 + *
1653 + * Copyright (C) 2004, 2005 Nokia Corporation
1654 + *
1655 + * Written by Paul Mundt <paul.mundt@nokia.com> and
1656 + *            Igor Stoppa <igor.stoppa@nokia.com>
1657 + *
1658 + * The Retu RTC is essentially a partial read-only RTC that gives us Retu's
1659 + * idea of what time actually is. It's left as a userspace excercise to map
1660 + * this back to time in the real world and ensure that calibration settings
1661 + * are sane to compensate for any horrible drift (on account of not being able
1662 + * to set the clock to anything).
1663 + *
1664 + * Days are semi-writeable. Namely, Retu will only track 255 days for us
1665 + * consecutively, after which the counter is explicitly stuck at 255 until
1666 + * someone comes along and clears it with a write. In the event that no one
1667 + * comes along and clears it, we no longer have any idea what day it is.
1668 + *
1669 + * This file is subject to the terms and conditions of the GNU General
1670 + * Public License. See the file "COPYING" in the main directory of this
1671 + * archive for more details.
1672 + *
1673 + * This program is distributed in the hope that it will be useful,
1674 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1675 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1676 + * GNU General Public License for more details.
1677 + *
1678 + * You should have received a copy of the GNU General Public License
1679 + * along with this program; if not, write to the Free Software
1680 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
1681 + */
1682 +
1683 +#include <linux/device.h>
1684 +#include <linux/init.h>
1685 +#include <linux/kernel.h>
1686 +#include <linux/slab.h>
1687 +#include <linux/module.h>
1688 +#include <linux/platform_device.h>
1689 +#include <linux/mutex.h>
1690 +#include <linux/rtc.h>
1691 +
1692 +#include "cbus.h"
1693 +#include "retu.h"
1694 +
1695 +struct retu_rtc {
1696 +       /* device lock */
1697 +       struct mutex            mutex;
1698 +       struct device           *dev;
1699 +       struct rtc_device       *rtc;
1700 +
1701 +       u16                     alarm_expired;
1702 +       int                     irq_rtcs;
1703 +       int                     irq_rtca;
1704 +};
1705 +
1706 +static void retu_rtc_do_reset(struct retu_rtc *rtc)
1707 +{
1708 +       u16 ccr1;
1709 +
1710 +       ccr1 = retu_read_reg(rtc->dev, RETU_REG_CC1);
1711 +       /* RTC in reset */
1712 +       retu_write_reg(rtc->dev, RETU_REG_CC1, ccr1 | 0x0001);
1713 +       /* RTC in normal operating mode */
1714 +       retu_write_reg(rtc->dev, RETU_REG_CC1, ccr1 & ~0x0001);
1715 +
1716 +       /* Disable alarm and RTC WD */
1717 +       retu_write_reg(rtc->dev, RETU_REG_RTCHMAR, 0x7f3f);
1718 +       /* Set Calibration register to default value */
1719 +       retu_write_reg(rtc->dev, RETU_REG_RTCCALR, 0x00c0);
1720 +
1721 +       rtc->alarm_expired = 0;
1722 +}
1723 +
1724 +static irqreturn_t retu_rtc_interrupt(int irq, void *_rtc)
1725 +{
1726 +       struct retu_rtc         *rtc = _rtc;
1727 +
1728 +       mutex_lock(&rtc->mutex);
1729 +       rtc->alarm_expired = 1;
1730 +       retu_write_reg(rtc->dev, RETU_REG_RTCHMAR, (24 << 8) | 60);
1731 +       mutex_unlock(&rtc->mutex);
1732 +
1733 +       return IRQ_HANDLED;
1734 +}
1735 +
1736 +static int retu_rtc_init_irq(struct retu_rtc *rtc)
1737 +{
1738 +       int irq;
1739 +       int ret;
1740 +
1741 +       irq = platform_get_irq(to_platform_device(rtc->dev), 0);
1742 +       rtc->irq_rtcs = irq;
1743 +
1744 +       irq = platform_get_irq(to_platform_device(rtc->dev), 1);
1745 +       rtc->irq_rtca = irq;
1746 +
1747 +       ret = request_threaded_irq(rtc->irq_rtcs, NULL, retu_rtc_interrupt,
1748 +                       0, "RTCS", rtc);
1749 +       if (ret != 0)
1750 +               return ret;
1751 +
1752 +       ret = request_threaded_irq(rtc->irq_rtca, NULL, retu_rtc_interrupt,
1753 +                       0, "RTCA", rtc);
1754 +       if (ret != 0) {
1755 +               free_irq(rtc->irq_rtcs, rtc);
1756 +               return ret;
1757 +       }
1758 +
1759 +       return 0;
1760 +}
1761 +
1762 +static int retu_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
1763 +{
1764 +       struct retu_rtc         *rtc = dev_get_drvdata(dev);
1765 +       u16                     chmar;
1766 +
1767 +       mutex_lock(&rtc->mutex);
1768 +
1769 +       chmar = ((alm->time.tm_hour & 0x1f) << 8) | (alm->time.tm_min & 0x3f);
1770 +       retu_write_reg(rtc->dev, RETU_REG_RTCHMAR, chmar);
1771 +
1772 +       mutex_unlock(&rtc->mutex);
1773 +
1774 +       return 0;
1775 +}
1776 +
1777 +static int retu_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
1778 +{
1779 +       struct retu_rtc         *rtc = dev_get_drvdata(dev);
1780 +       u16                     chmar;
1781 +
1782 +       mutex_lock(&rtc->mutex);
1783 +
1784 +       chmar = retu_read_reg(rtc->dev, RETU_REG_RTCHMAR);
1785 +
1786 +       alm->time.tm_hour       = (chmar >> 8) & 0x1f;
1787 +       alm->time.tm_min        = chmar & 0x3f;
1788 +       alm->enabled            = !!rtc->alarm_expired;
1789 +
1790 +       mutex_unlock(&rtc->mutex);
1791 +
1792 +       return 0;
1793 +}
1794 +
1795 +static int retu_rtc_set_time(struct device *dev, struct rtc_time *tm)
1796 +{
1797 +       struct retu_rtc         *rtc = dev_get_drvdata(dev);
1798 +       u16                     dsr;
1799 +       u16                     hmr;
1800 +
1801 +       dsr = ((tm->tm_mday & 0xff) << 8) | (tm->tm_hour & 0xff);
1802 +       hmr = ((tm->tm_min & 0xff) << 8) | (tm->tm_sec & 0xff);
1803 +
1804 +       mutex_lock(&rtc->mutex);
1805 +
1806 +       retu_write_reg(rtc->dev, RETU_REG_RTCDSR, dsr);
1807 +       retu_write_reg(rtc->dev, RETU_REG_RTCHMR, hmr);
1808 +
1809 +       mutex_unlock(&rtc->mutex);
1810 +
1811 +       return 0;
1812 +}
1813 +
1814 +static int retu_rtc_read_time(struct device *dev, struct rtc_time *tm)
1815 +{
1816 +       struct retu_rtc         *rtc = dev_get_drvdata(dev);
1817 +       u16                     dsr;
1818 +       u16                     hmr;
1819 +
1820 +       /*
1821 +        * DSR holds days and hours
1822 +        * HMR hols minutes and seconds
1823 +        *
1824 +        * both are 16 bit registers with 8-bit for each field.
1825 +        */
1826 +
1827 +       mutex_lock(&rtc->mutex);
1828 +
1829 +       dsr     = retu_read_reg(rtc->dev, RETU_REG_RTCDSR);
1830 +       hmr     = retu_read_reg(rtc->dev, RETU_REG_RTCHMR);
1831 +
1832 +       tm->tm_sec      = hmr & 0xff;
1833 +       tm->tm_min      = hmr >> 8;
1834 +       tm->tm_hour     = dsr & 0xff;
1835 +       tm->tm_mday     = dsr >> 8;
1836 +
1837 +       mutex_unlock(&rtc->mutex);
1838 +
1839 +       return 0;
1840 +}
1841 +
1842 +static struct rtc_class_ops retu_rtc_ops = {
1843 +       .read_time              = retu_rtc_read_time,
1844 +       .set_time               = retu_rtc_set_time,
1845 +       .read_alarm             = retu_rtc_read_alarm,
1846 +       .set_alarm              = retu_rtc_set_alarm,
1847 +};
1848 +
1849 +static int __init retu_rtc_probe(struct platform_device *pdev)
1850 +{
1851 +       struct retu_rtc         *rtc;
1852 +       int                     r;
1853 +
1854 +       rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
1855 +       if (!rtc) {
1856 +               dev_err(&pdev->dev, "not enough memory\n");
1857 +               r = -ENOMEM;
1858 +               goto err0;
1859 +       }
1860 +
1861 +       rtc->dev = &pdev->dev;
1862 +       platform_set_drvdata(pdev, rtc);
1863 +       mutex_init(&rtc->mutex);
1864 +
1865 +       rtc->alarm_expired = retu_read_reg(rtc->dev, RETU_REG_IDR) &
1866 +               (0x1 << RETU_INT_RTCA);
1867 +
1868 +       r = retu_rtc_init_irq(rtc);
1869 +       if (r < 0) {
1870 +               dev_err(&pdev->dev, "failed to request retu irq\n");
1871 +               goto err1;
1872 +       }
1873 +
1874 +       /* If the calibration register is zero, we've probably lost power */
1875 +       if (!(retu_read_reg(rtc->dev, RETU_REG_RTCCALR) & 0x00ff))
1876 +               retu_rtc_do_reset(rtc);
1877 +
1878 +       rtc->rtc = rtc_device_register(pdev->name, &pdev->dev, &
1879 +                       retu_rtc_ops, THIS_MODULE);
1880 +       if (IS_ERR(rtc->rtc)) {
1881 +               dev_err(&pdev->dev, "can't register RTC device\n");
1882 +               goto err2;
1883 +       }
1884 +
1885 +       return 0;
1886 +
1887 +err2:
1888 +       free_irq(rtc->irq_rtcs, rtc);
1889 +       free_irq(rtc->irq_rtca, rtc);
1890 +
1891 +err1:
1892 +       kfree(rtc);
1893 +
1894 +err0:
1895 +       return r;
1896 +}
1897 +
1898 +static int __devexit retu_rtc_remove(struct platform_device *pdev)
1899 +{
1900 +       struct retu_rtc         *rtc = platform_get_drvdata(pdev);
1901 +
1902 +       free_irq(rtc->irq_rtcs, rtc);
1903 +       free_irq(rtc->irq_rtca, rtc);
1904 +       rtc_device_unregister(rtc->rtc);
1905 +       kfree(rtc);
1906 +
1907 +       return 0;
1908 +}
1909 +
1910 +static struct platform_driver retu_rtc_driver = {
1911 +       .remove         = __exit_p(retu_rtc_remove),
1912 +       .driver         = {
1913 +               .name   = "retu-rtc",
1914 +       },
1915 +};
1916 +
1917 +static int __init retu_rtc_init(void)
1918 +{
1919 +       return platform_driver_probe(&retu_rtc_driver, retu_rtc_probe);
1920 +}
1921 +module_init(retu_rtc_init);
1922 +
1923 +static void __exit retu_rtc_exit(void)
1924 +{
1925 +       platform_driver_unregister(&retu_rtc_driver);
1926 +}
1927 +module_exit(retu_rtc_exit);
1928 +
1929 +MODULE_DESCRIPTION("Retu RTC");
1930 +MODULE_LICENSE("GPL");
1931 +MODULE_AUTHOR("Paul Mundt");
1932 +MODULE_AUTHOR("Igor Stoppa");
1933 +MODULE_AUTHOR("Felipe Balbi <felipe.balbi@nokia.com>");
1934 +
1935 --- /dev/null
1936 +++ b/drivers/cbus/retu-wdt.c
1937 @@ -0,0 +1,272 @@
1938 +/**
1939 + * drivers/cbus/retu-wdt.c
1940 + *
1941 + * Driver for Retu watchdog
1942 + *
1943 + * Copyright (C) 2004, 2005 Nokia Corporation
1944 + *
1945 + * Written by Amit Kucheria <amit.kucheria@nokia.com>
1946 + *
1947 + * Cleanups by Michael Buesch <mb@bu3sch.de> (C) 2011
1948 + *
1949 + * This file is subject to the terms and conditions of the GNU General
1950 + * Public License. See the file "COPYING" in the main directory of this
1951 + * archive for more details.
1952 + *
1953 + * This program is distributed in the hope that it will be useful,
1954 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1955 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1956 + * GNU General Public License for more details.
1957 + *
1958 + * You should have received a copy of the GNU General Public License
1959 + * along with this program; if not, write to the Free Software
1960 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
1961 + */
1962 +
1963 +#include <linux/kernel.h>
1964 +#include <linux/slab.h>
1965 +#include <linux/module.h>
1966 +#include <linux/device.h>
1967 +#include <linux/init.h>
1968 +#include <linux/fs.h>
1969 +#include <linux/io.h>
1970 +#include <linux/platform_device.h>
1971 +
1972 +#include <linux/completion.h>
1973 +#include <linux/errno.h>
1974 +#include <linux/moduleparam.h>
1975 +#include <linux/miscdevice.h>
1976 +#include <linux/watchdog.h>
1977 +
1978 +#include <asm/uaccess.h>
1979 +
1980 +#include <plat/prcm.h>
1981 +
1982 +#include "cbus.h"
1983 +#include "retu.h"
1984 +
1985 +/* Watchdog timeout in seconds */
1986 +#define RETU_WDT_MIN_TIMER 0
1987 +#define RETU_WDT_DEFAULT_TIMER 32
1988 +#define RETU_WDT_MAX_TIMER 63
1989 +
1990 +struct retu_wdt_dev {
1991 +       struct device           *dev;
1992 +       unsigned int            period_val;     /* Current period of watchdog */
1993 +       unsigned long           users;
1994 +       struct miscdevice       miscdev;
1995 +       struct delayed_work     ping_work;
1996 +       struct mutex            mutex;
1997 +};
1998 +
1999 +
2000 +static inline void _retu_modify_counter(struct retu_wdt_dev *wdev,
2001 +                                       unsigned int new)
2002 +{
2003 +       retu_write_reg(wdev->dev, RETU_REG_WATCHDOG, (u16)new);
2004 +}
2005 +
2006 +static int retu_modify_counter(struct retu_wdt_dev *wdev, unsigned int new)
2007 +{
2008 +       if (new < RETU_WDT_MIN_TIMER || new > RETU_WDT_MAX_TIMER)
2009 +               return -EINVAL;
2010 +
2011 +       mutex_lock(&wdev->mutex);
2012 +       wdev->period_val = new;
2013 +       _retu_modify_counter(wdev, wdev->period_val);
2014 +       mutex_unlock(&wdev->mutex);
2015 +
2016 +       return 0;
2017 +}
2018 +
2019 +/*
2020 + * Since retu watchdog cannot be disabled in hardware, we must kick it
2021 + * with a timer until userspace watchdog software takes over. Do this
2022 + * unless /dev/watchdog is open or CONFIG_WATCHDOG_NOWAYOUT is set.
2023 + */
2024 +static void retu_wdt_ping_enable(struct retu_wdt_dev *wdev)
2025 +{
2026 +       _retu_modify_counter(wdev, RETU_WDT_MAX_TIMER);
2027 +       schedule_delayed_work(&wdev->ping_work,
2028 +                             round_jiffies_relative(RETU_WDT_DEFAULT_TIMER * HZ));
2029 +}
2030 +
2031 +static void retu_wdt_ping_disable(struct retu_wdt_dev *wdev)
2032 +{
2033 +       _retu_modify_counter(wdev, RETU_WDT_MAX_TIMER);
2034 +       cancel_delayed_work_sync(&wdev->ping_work);
2035 +}
2036 +
2037 +static void retu_wdt_ping_work(struct work_struct *work)
2038 +{
2039 +       struct retu_wdt_dev *wdev = container_of(to_delayed_work(work),
2040 +                                       struct retu_wdt_dev, ping_work);
2041 +       retu_wdt_ping_enable(wdev);
2042 +}
2043 +
2044 +static int retu_wdt_open(struct inode *inode, struct file *file)
2045 +{
2046 +       struct miscdevice *mdev = file->private_data;
2047 +       struct retu_wdt_dev *wdev = container_of(mdev, struct retu_wdt_dev, miscdev);
2048 +
2049 +       if (test_and_set_bit(0, &wdev->users))
2050 +               return -EBUSY;
2051 +
2052 +       retu_wdt_ping_disable(wdev);
2053 +
2054 +       return nonseekable_open(inode, file);
2055 +}
2056 +
2057 +static int retu_wdt_release(struct inode *inode, struct file *file)
2058 +{
2059 +       struct miscdevice *mdev = file->private_data;
2060 +       struct retu_wdt_dev *wdev = container_of(mdev, struct retu_wdt_dev, miscdev);
2061 +
2062 +#ifndef CONFIG_WATCHDOG_NOWAYOUT
2063 +       retu_wdt_ping_enable(wdev);
2064 +#endif
2065 +       clear_bit(0, &wdev->users);
2066 +
2067 +       return 0;
2068 +}
2069 +
2070 +static ssize_t retu_wdt_write(struct file *file, const char __user *data,
2071 +                                               size_t len, loff_t *ppos)
2072 +{
2073 +       struct miscdevice *mdev = file->private_data;
2074 +       struct retu_wdt_dev *wdev = container_of(mdev, struct retu_wdt_dev, miscdev);
2075 +
2076 +       if (len)
2077 +               retu_modify_counter(wdev, RETU_WDT_MAX_TIMER);
2078 +
2079 +       return len;
2080 +}
2081 +
2082 +static long retu_wdt_ioctl(struct file *file, unsigned int cmd,
2083 +                          unsigned long arg)
2084 +{
2085 +       struct miscdevice *mdev = file->private_data;
2086 +       struct retu_wdt_dev *wdev = container_of(mdev, struct retu_wdt_dev, miscdev);
2087 +       int new_margin;
2088 +
2089 +       static const struct watchdog_info ident = {
2090 +               .identity = "Retu Watchdog",
2091 +               .options = WDIOF_SETTIMEOUT,
2092 +               .firmware_version = 0,
2093 +       };
2094 +
2095 +       switch (cmd) {
2096 +       default:
2097 +               return -ENOTTY;
2098 +       case WDIOC_GETSUPPORT:
2099 +               return copy_to_user((struct watchdog_info __user *)arg, &ident,
2100 +                                                       sizeof(ident));
2101 +       case WDIOC_GETSTATUS:
2102 +               return put_user(0, (int __user *)arg);
2103 +       case WDIOC_GETBOOTSTATUS:
2104 +               if (cpu_is_omap16xx())
2105 +                       return put_user(omap_readw(ARM_SYSST),
2106 +                                       (int __user *)arg);
2107 +               if (cpu_is_omap24xx())
2108 +                       return put_user(omap_prcm_get_reset_sources(),
2109 +                                       (int __user *)arg);
2110 +       case WDIOC_KEEPALIVE:
2111 +               retu_modify_counter(wdev, RETU_WDT_MAX_TIMER);
2112 +               break;
2113 +       case WDIOC_SETTIMEOUT:
2114 +               if (get_user(new_margin, (int __user *)arg))
2115 +                       return -EFAULT;
2116 +               retu_modify_counter(wdev, new_margin);
2117 +               /* Fall through */
2118 +       case WDIOC_GETTIMEOUT:
2119 +               return put_user(wdev->period_val, (int __user *)arg);
2120 +       }
2121 +
2122 +       return 0;
2123 +}
2124 +
2125 +static const struct file_operations retu_wdt_fops = {
2126 +       .owner          = THIS_MODULE,
2127 +       .write          = retu_wdt_write,
2128 +       .unlocked_ioctl = retu_wdt_ioctl,
2129 +       .open           = retu_wdt_open,
2130 +       .release        = retu_wdt_release,
2131 +};
2132 +
2133 +static int __init retu_wdt_probe(struct platform_device *pdev)
2134 +{
2135 +       struct retu_wdt_dev *wdev;
2136 +       int ret;
2137 +
2138 +       wdev = kzalloc(sizeof(struct retu_wdt_dev), GFP_KERNEL);
2139 +       if (!wdev)
2140 +               return -ENOMEM;
2141 +
2142 +       wdev->dev = &pdev->dev;
2143 +       wdev->period_val = RETU_WDT_DEFAULT_TIMER;
2144 +       mutex_init(&wdev->mutex);
2145 +
2146 +       platform_set_drvdata(pdev, wdev);
2147 +
2148 +       wdev->miscdev.parent = &pdev->dev;
2149 +       wdev->miscdev.minor = WATCHDOG_MINOR;
2150 +       wdev->miscdev.name = "watchdog";
2151 +       wdev->miscdev.fops = &retu_wdt_fops;
2152 +
2153 +       ret = misc_register(&wdev->miscdev);
2154 +       if (ret)
2155 +               goto err_free_wdev;
2156 +
2157 +       INIT_DELAYED_WORK(&wdev->ping_work, retu_wdt_ping_work);
2158 +
2159 +       /* Kick the watchdog for kernel booting to finish.
2160 +        * If nowayout is not set, we start the ping work. */
2161 +#ifdef CONFIG_WATCHDOG_NOWAYOUT
2162 +       retu_modify_counter(wdev, RETU_WDT_MAX_TIMER);
2163 +#else
2164 +       retu_wdt_ping_enable(wdev);
2165 +#endif
2166 +
2167 +       return 0;
2168 +
2169 +err_free_wdev:
2170 +       kfree(wdev);
2171 +
2172 +       return ret;
2173 +}
2174 +
2175 +static int __devexit retu_wdt_remove(struct platform_device *pdev)
2176 +{
2177 +       struct retu_wdt_dev *wdev;
2178 +
2179 +       wdev = platform_get_drvdata(pdev);
2180 +       misc_deregister(&wdev->miscdev);
2181 +       cancel_delayed_work_sync(&wdev->ping_work);
2182 +       kfree(wdev);
2183 +
2184 +       return 0;
2185 +}
2186 +
2187 +static struct platform_driver retu_wdt_driver = {
2188 +       .remove         = __exit_p(retu_wdt_remove),
2189 +       .driver         = {
2190 +               .name   = "retu-wdt",
2191 +       },
2192 +};
2193 +
2194 +static int __init retu_wdt_init(void)
2195 +{
2196 +       return platform_driver_probe(&retu_wdt_driver, retu_wdt_probe);
2197 +}
2198 +
2199 +static void __exit retu_wdt_exit(void)
2200 +{
2201 +       platform_driver_unregister(&retu_wdt_driver);
2202 +}
2203 +
2204 +module_init(retu_wdt_init);
2205 +module_exit(retu_wdt_exit);
2206 +
2207 +MODULE_DESCRIPTION("Retu WatchDog");
2208 +MODULE_AUTHOR("Amit Kucheria");
2209 +MODULE_LICENSE("GPL");
2210 --- /dev/null
2211 +++ b/drivers/cbus/tahvo.c
2212 @@ -0,0 +1,423 @@
2213 +/**
2214 + * drivers/cbus/tahvo.c
2215 + *
2216 + * Support functions for Tahvo ASIC
2217 + *
2218 + * Copyright (C) 2004, 2005 Nokia Corporation
2219 + *
2220 + * Written by Juha Yrjölä <juha.yrjola@nokia.com>,
2221 + *           David Weinehall <david.weinehall@nokia.com>, and
2222 + *           Mikko Ylinen <mikko.k.ylinen@nokia.com>
2223 + *
2224 + * This file is subject to the terms and conditions of the GNU General
2225 + * Public License. See the file "COPYING" in the main directory of this
2226 + * archive for more details.
2227 + *
2228 + * This program is distributed in the hope that it will be useful,
2229 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2230 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2231 + * GNU General Public License for more details.
2232 + *
2233 + * You should have received a copy of the GNU General Public License
2234 + * along with this program; if not, write to the Free Software
2235 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
2236 + */
2237 +
2238 +#include <linux/module.h>
2239 +#include <linux/init.h>
2240 +
2241 +#include <linux/slab.h>
2242 +#include <linux/kernel.h>
2243 +#include <linux/errno.h>
2244 +#include <linux/device.h>
2245 +#include <linux/irq.h>
2246 +#include <linux/interrupt.h>
2247 +#include <linux/platform_device.h>
2248 +#include <linux/platform_data/cbus.h>
2249 +#include <linux/mutex.h>
2250 +
2251 +#include "cbus.h"
2252 +#include "tahvo.h"
2253 +
2254 +struct tahvo {
2255 +       /* device lock */
2256 +       struct mutex    mutex;
2257 +       struct device   *dev;
2258 +
2259 +       int             irq_base;
2260 +       int             irq_end;
2261 +       int             irq;
2262 +
2263 +       int             ack;
2264 +       int             mask;
2265 +
2266 +       unsigned int    mask_pending:1;
2267 +       unsigned int    ack_pending:1;
2268 +       unsigned int    is_betty:1;
2269 +};
2270 +
2271 +/**
2272 + * __tahvo_read_reg - Reads a value from a register in Tahvo
2273 + * @tahvo: pointer to tahvo structure
2274 + * @reg: the register address to read from
2275 + */
2276 +static int __tahvo_read_reg(struct tahvo *tahvo, unsigned reg)
2277 +{
2278 +       return cbus_read_reg(tahvo->dev, CBUS_TAHVO_DEVICE_ID, reg);
2279 +}
2280 +
2281 +/**
2282 + * __tahvo_write_reg - Writes a value to a register in Tahvo
2283 + * @tahvo: pointer to tahvo structure
2284 + * @reg: register address to write to
2285 + * @val: the value to be written to @reg
2286 + */
2287 +static void __tahvo_write_reg(struct tahvo *tahvo, unsigned reg, u16 val)
2288 +{
2289 +       cbus_write_reg(tahvo->dev, CBUS_TAHVO_DEVICE_ID, reg, val);
2290 +}
2291 +
2292 +/**
2293 + * tahvo_read_reg - Read a value from a register in Tahvo
2294 + * @child: device pointer from the calling child
2295 + * @reg: the register to read from
2296 + *
2297 + * This function returns the contents of the specified register
2298 + */
2299 +int tahvo_read_reg(struct device *child, unsigned reg)
2300 +{
2301 +       struct tahvo            *tahvo = dev_get_drvdata(child->parent);
2302 +
2303 +       return __tahvo_read_reg(tahvo, reg);
2304 +}
2305 +EXPORT_SYMBOL(tahvo_read_reg);
2306 +
2307 +/**
2308 + * tahvo_write_reg - Write a value to a register in Tahvo
2309 + * @child: device pointer from the calling child
2310 + * @reg: the register to write to
2311 + * @val : the value to write to the register
2312 + *
2313 + * This function writes a value to the specified register
2314 + */
2315 +void tahvo_write_reg(struct device *child, unsigned reg, u16 val)
2316 +{
2317 +       struct tahvo            *tahvo = dev_get_drvdata(child->parent);
2318 +
2319 +       __tahvo_write_reg(tahvo, reg, val);
2320 +}
2321 +EXPORT_SYMBOL(tahvo_write_reg);
2322 +
2323 +/**
2324 + * tahvo_set_clear_reg_bits - set and clear register bits atomically
2325 + * @child: device pointer from the calling child
2326 + * @reg: the register to write to
2327 + * @bits: the bits to set
2328 + *
2329 + * This function sets and clears the specified Tahvo register bits atomically
2330 + */
2331 +void tahvo_set_clear_reg_bits(struct device *child, unsigned reg, u16 set,
2332 +               u16 clear)
2333 +{
2334 +       struct tahvo            *tahvo = dev_get_drvdata(child->parent);
2335 +       u16                     w;
2336 +
2337 +       mutex_lock(&tahvo->mutex);
2338 +       w = __tahvo_read_reg(tahvo, reg);
2339 +       w &= ~clear;
2340 +       w |= set;
2341 +       __tahvo_write_reg(tahvo, reg, w);
2342 +       mutex_unlock(&tahvo->mutex);
2343 +}
2344 +
2345 +static irqreturn_t tahvo_irq_handler(int irq, void *_tahvo)
2346 +{
2347 +       struct tahvo            *tahvo = _tahvo;
2348 +       u16                     id;
2349 +       u16                     im;
2350 +
2351 +       id = __tahvo_read_reg(tahvo, TAHVO_REG_IDR);
2352 +       im = __tahvo_read_reg(tahvo, TAHVO_REG_IMR);
2353 +       id &= ~im;
2354 +
2355 +       if (!id) {
2356 +               dev_vdbg(tahvo->dev, "No IRQ, spurious ?\n");
2357 +               return IRQ_NONE;
2358 +       }
2359 +
2360 +       while (id) {
2361 +               unsigned long   pending = __ffs(id);
2362 +               unsigned int    irq;
2363 +
2364 +               id &= ~BIT(pending);
2365 +               irq = pending + tahvo->irq_base;
2366 +               handle_nested_irq(irq);
2367 +       }
2368 +
2369 +       return IRQ_HANDLED;
2370 +}
2371 +
2372 +/* -------------------------------------------------------------------------- */
2373 +
2374 +static void tahvo_irq_bus_lock(struct irq_data *data)
2375 +{
2376 +       struct tahvo            *tahvo = irq_data_get_irq_chip_data(data);
2377 +
2378 +       mutex_lock(&tahvo->mutex);
2379 +}
2380 +
2381 +static void tahvo_irq_bus_sync_unlock(struct irq_data *data)
2382 +{
2383 +       struct tahvo            *tahvo = irq_data_get_irq_chip_data(data);
2384 +
2385 +       if (tahvo->mask_pending) {
2386 +               __tahvo_write_reg(tahvo, TAHVO_REG_IMR, tahvo->mask);
2387 +               tahvo->mask_pending = false;
2388 +       }
2389 +
2390 +       if (tahvo->ack_pending) {
2391 +               __tahvo_write_reg(tahvo, TAHVO_REG_IDR, tahvo->ack);
2392 +               tahvo->ack_pending = false;
2393 +       }
2394 +
2395 +       mutex_unlock(&tahvo->mutex);
2396 +}
2397 +
2398 +static void tahvo_irq_mask(struct irq_data *data)
2399 +{
2400 +       struct tahvo            *tahvo = irq_data_get_irq_chip_data(data);
2401 +       int                     irq = data->irq;
2402 +
2403 +       tahvo->mask |= (1 << (irq - tahvo->irq_base));
2404 +       tahvo->mask_pending = true;
2405 +}
2406 +
2407 +static void tahvo_irq_unmask(struct irq_data *data)
2408 +{
2409 +       struct tahvo            *tahvo = irq_data_get_irq_chip_data(data);
2410 +       int                     irq = data->irq;
2411 +
2412 +       tahvo->mask &= ~(1 << (irq - tahvo->irq_base));
2413 +       tahvo->mask_pending = true;
2414 +}
2415 +
2416 +static void tahvo_irq_ack(struct irq_data *data)
2417 +{
2418 +       struct tahvo            *tahvo = irq_data_get_irq_chip_data(data);
2419 +       int                     irq = data->irq;
2420 +
2421 +       tahvo->ack |= (1 << (irq - tahvo->irq_base));
2422 +       tahvo->ack_pending = true;
2423 +}
2424 +
2425 +static struct irq_chip tahvo_irq_chip = {
2426 +       .name                   = "tahvo",
2427 +       .irq_bus_lock           = tahvo_irq_bus_lock,
2428 +       .irq_bus_sync_unlock    = tahvo_irq_bus_sync_unlock,
2429 +       .irq_mask               = tahvo_irq_mask,
2430 +       .irq_unmask             = tahvo_irq_unmask,
2431 +       .irq_ack                = tahvo_irq_ack,
2432 +};
2433 +
2434 +static inline void tahvo_irq_setup(int irq)
2435 +{
2436 +#ifdef CONFIG_ARM
2437 +       set_irq_flags(irq, IRQF_VALID);
2438 +#else
2439 +       irq_set_noprobe(irq);
2440 +#endif
2441 +}
2442 +
2443 +static void tahvo_irq_init(struct tahvo *tahvo)
2444 +{
2445 +       int                     base = tahvo->irq_base;
2446 +       int                     end = tahvo->irq_end;
2447 +       int                     irq;
2448 +
2449 +       for (irq = base; irq < end; irq++) {
2450 +               irq_set_chip_data(irq, tahvo);
2451 +               irq_set_chip_and_handler(irq, &tahvo_irq_chip,
2452 +                               handle_simple_irq);
2453 +               irq_set_nested_thread(irq, 1);
2454 +               tahvo_irq_setup(irq);
2455 +       }
2456 +}
2457 +
2458 +/* -------------------------------------------------------------------------- */
2459 +
2460 +static struct resource generic_resources[] = {
2461 +       {
2462 +               .start          = -EINVAL,      /* fixed later */
2463 +               .flags          = IORESOURCE_IRQ,
2464 +       },
2465 +};
2466 +
2467 +static struct device *tahvo_allocate_child(const char *name,
2468 +               struct device *parent, int irq)
2469 +{
2470 +       struct platform_device  *pdev;
2471 +       int                     ret;
2472 +
2473 +       pdev = platform_device_alloc(name, -1);
2474 +       if (!pdev) {
2475 +               dev_dbg(parent, "can't allocate %s\n", name);
2476 +               goto err0;
2477 +       }
2478 +
2479 +       pdev->dev.parent = parent;
2480 +
2481 +       if (irq > 0) {
2482 +               generic_resources[0].start = irq;
2483 +
2484 +               ret = platform_device_add_resources(pdev, generic_resources,
2485 +                               ARRAY_SIZE(generic_resources));
2486 +               if (ret < 0) {
2487 +                       dev_dbg(parent, "can't add resources to %s\n", name);
2488 +                       goto err1;
2489 +               }
2490 +       }
2491 +
2492 +       ret = platform_device_add(pdev);
2493 +       if (ret < 0) {
2494 +               dev_dbg(parent, "can't add %s\n", name);
2495 +               goto err1;
2496 +       }
2497 +
2498 +       return &pdev->dev;
2499 +
2500 +err1:
2501 +       platform_device_put(pdev);
2502 +
2503 +err0:
2504 +       return NULL;
2505 +}
2506 +
2507 +static int tahvo_allocate_children(struct device *parent, int irq_base)
2508 +{
2509 +       struct device           *child;
2510 +
2511 +       child = tahvo_allocate_child("tahvo-usb", parent,
2512 +                       irq_base + TAHVO_INT_VBUSON);
2513 +       if (!child)
2514 +               return -ENOMEM;
2515 +
2516 +       child = tahvo_allocate_child("tahvo-pwm", parent, -1);
2517 +       if (!child)
2518 +               return -ENOMEM;
2519 +
2520 +       return 0;
2521 +}
2522 +
2523 +static int __devinit tahvo_probe(struct platform_device *pdev)
2524 +{
2525 +       struct tahvo            *tahvo;
2526 +       int                     rev;
2527 +       int                     ret;
2528 +       int                     irq;
2529 +       int                     id;
2530 +
2531 +       tahvo = kzalloc(sizeof(*tahvo), GFP_KERNEL);
2532 +       if (!tahvo) {
2533 +               dev_err(&pdev->dev, "not enough memory\n");
2534 +               ret = -ENOMEM;
2535 +               goto err0;
2536 +       }
2537 +
2538 +       irq = platform_get_irq(pdev, 0);
2539 +       platform_set_drvdata(pdev, tahvo);
2540 +
2541 +       mutex_init(&tahvo->mutex);
2542 +
2543 +       ret = irq_alloc_descs(-1, 0, MAX_TAHVO_IRQ_HANDLERS, 0);
2544 +       if (ret < 0) {
2545 +               dev_err(&pdev->dev, "failed to allocate IRQ descs\n");
2546 +               goto err1;
2547 +       }
2548 +
2549 +       tahvo->irq_base = ret;
2550 +       tahvo->irq_end  = ret + MAX_TAHVO_IRQ_HANDLERS;
2551 +       tahvo->dev      = &pdev->dev;
2552 +       tahvo->irq      = irq;
2553 +
2554 +       tahvo_irq_init(tahvo);
2555 +
2556 +       rev = __tahvo_read_reg(tahvo, TAHVO_REG_ASICR);
2557 +
2558 +       id = (rev >> 8) & 0xff;
2559 +
2560 +       if (id == 0x0b)
2561 +               tahvo->is_betty = true;
2562 +
2563 +       ret = tahvo_allocate_children(&pdev->dev, tahvo->irq_base);
2564 +       if (ret < 0) {
2565 +               dev_err(&pdev->dev, "failed to allocate children\n");
2566 +               goto err2;
2567 +       }
2568 +
2569 +       dev_err(&pdev->dev, "%s v%d.%d found\n",
2570 +                       tahvo->is_betty ? "Betty" : "Tahvo",
2571 +                       (rev >> 4) & 0x0f, rev & 0x0f);
2572 +
2573 +       /* Mask all TAHVO interrupts */
2574 +       __tahvo_write_reg(tahvo, TAHVO_REG_IMR, 0xffff);
2575 +
2576 +       ret = request_threaded_irq(irq, NULL, tahvo_irq_handler,
2577 +                       IRQF_TRIGGER_RISING | IRQF_ONESHOT,
2578 +                       "tahvo", tahvo);
2579 +       if (ret < 0) {
2580 +               dev_err(&pdev->dev, "Unable to register IRQ handler\n");
2581 +               goto err2;
2582 +       }
2583 +
2584 +       return 0;
2585 +
2586 +err2:
2587 +       irq_free_descs(tahvo->irq_base, MAX_TAHVO_IRQ_HANDLERS);
2588 +
2589 +err1:
2590 +       kfree(tahvo);
2591 +
2592 +err0:
2593 +       return ret;
2594 +}
2595 +
2596 +static int __devexit tahvo_remove(struct platform_device *pdev)
2597 +{
2598 +       struct tahvo            *tahvo = platform_get_drvdata(pdev);
2599 +       int                     irq;
2600 +
2601 +       irq = platform_get_irq(pdev, 0);
2602 +
2603 +       free_irq(irq, 0);
2604 +       irq_free_descs(tahvo->irq_base, MAX_TAHVO_IRQ_HANDLERS);
2605 +       kfree(tahvo);
2606 +
2607 +       return 0;
2608 +}
2609 +
2610 +static struct platform_driver tahvo_driver = {
2611 +       .probe          = tahvo_probe,
2612 +       .remove         = __devexit_p(tahvo_remove),
2613 +       .driver         = {
2614 +               .name   = "tahvo",
2615 +       },
2616 +};
2617 +
2618 +static int __init tahvo_init(void)
2619 +{
2620 +       return platform_driver_register(&tahvo_driver);
2621 +}
2622 +subsys_initcall(tahvo_init);
2623 +
2624 +static void __exit tahvo_exit(void)
2625 +{
2626 +       platform_driver_unregister(&tahvo_driver);
2627 +}
2628 +module_exit(tahvo_exit);
2629 +
2630 +MODULE_DESCRIPTION("Tahvo ASIC control");
2631 +MODULE_LICENSE("GPL");
2632 +MODULE_AUTHOR("Juha Yrjölä");
2633 +MODULE_AUTHOR("David Weinehall");
2634 +MODULE_AUTHOR("Mikko Ylinen");
2635 +
2636 --- /dev/null
2637 +++ b/drivers/cbus/tahvo.h
2638 @@ -0,0 +1,58 @@
2639 +/*
2640 + * drivers/cbus/tahvo.h
2641 + *
2642 + * Copyright (C) 2004, 2005 Nokia Corporation
2643 + *
2644 + * Written by Juha Yrjölä <juha.yrjola@nokia.com> and
2645 + *           David Weinehall <david.weinehall@nokia.com>
2646 + *
2647 + * This file is subject to the terms and conditions of the GNU General
2648 + * Public License. See the file "COPYING" in the main directory of this
2649 + * archive for more details.
2650 + *
2651 + * This program is distributed in the hope that it will be useful,
2652 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2653 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2654 + * GNU General Public License for more details.
2655 +
2656 + * You should have received a copy of the GNU General Public License
2657 + * along with this program; if not, write to the Free Software
2658 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
2659 + */
2660 +
2661 +#ifndef __DRIVERS_CBUS_TAHVO_H
2662 +#define __DRIVERS_CBUS_TAHVO_H
2663 +
2664 +#include <linux/types.h>
2665 +
2666 +/* Registers */
2667 +#define TAHVO_REG_ASICR                0x00    /* ASIC ID & revision */
2668 +#define TAHVO_REG_IDR          0x01    /* Interrupt ID */
2669 +#define TAHVO_REG_IDSR         0x02    /* Interrupt status */
2670 +#define TAHVO_REG_IMR          0x03    /* Interrupt mask */
2671 +#define TAHVO_REG_CHGCURR      0x04    /* Charge current control PWM (8-bit) */
2672 +#define TAHVO_REG_LEDPWMR      0x05    /* LED PWM */
2673 +#define TAHVO_REG_USBR         0x06    /* USB control */
2674 +#define TAHVO_REG_CHGCTL       0x08    /* Charge control register */
2675 +#define  TAHVO_REG_CHGCTL_EN           0x0001  /* Global charge enable */
2676 +#define  TAHVO_REG_CHGCTL_PWMOVR       0x0004  /* PWM override. Force charge PWM to 0%/100% duty cycle. */
2677 +#define  TAHVO_REG_CHGCTL_PWMOVRZERO   0x0008  /* If set, PWM override is 0% (If unset -> 100%) */
2678 +#define  TAHVO_REG_CHGCTL_CURMEAS      0x0040  /* Enable battery current measurement. */
2679 +#define  TAHVO_REG_CHGCTL_CURTIMRST    0x0080  /* Current measure timer reset. */
2680 +#define TAHVO_REG_BATCURRTIMER 0x0c    /* Battery current measure timer (8-bit) */
2681 +#define TAHVO_REG_BATCURR      0x0d    /* Battery (dis)charge current (signed 16-bit) */
2682 +
2683 +#define TAHVO_REG_MAX          0x0d
2684 +
2685 +/* Interrupt sources */
2686 +#define TAHVO_INT_VBUSON       0
2687 +#define TAHVO_INT_BATCURR      7 /* Battery current measure timer */
2688 +
2689 +#define MAX_TAHVO_IRQ_HANDLERS 8
2690 +
2691 +int tahvo_read_reg(struct device *child, unsigned reg);
2692 +void tahvo_write_reg(struct device *child, unsigned reg, u16 val);
2693 +void tahvo_set_clear_reg_bits(struct device *child, unsigned reg, u16 set,
2694 +               u16 clear);
2695 +
2696 +#endif /* __DRIVERS_CBUS_TAHVO_H */
2697 --- /dev/null
2698 +++ b/drivers/cbus/tahvo-usb.c
2699 @@ -0,0 +1,740 @@
2700 +/**
2701 + * drivers/cbus/tahvo-usb.c
2702 + *
2703 + * Tahvo USB transeiver
2704 + *
2705 + * Copyright (C) 2005-2006 Nokia Corporation
2706 + *
2707 + * Parts copied from drivers/i2c/chips/isp1301_omap.c
2708 + * Copyright (C) 2004 Texas Instruments
2709 + * Copyright (C) 2004 David Brownell
2710 + *
2711 + * Written by Juha Yrjölä <juha.yrjola@nokia.com>,
2712 + *           Tony Lindgren <tony@atomide.com>, and
2713 + *           Timo Teräs <timo.teras@nokia.com>
2714 + *
2715 + * This file is subject to the terms and conditions of the GNU General
2716 + * Public License. See the file "COPYING" in the main directory of this
2717 + * archive for more details.
2718 + *
2719 + * This program is distributed in the hope that it will be useful,
2720 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2721 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2722 + * GNU General Public License for more details.
2723 + *
2724 + * You should have received a copy of the GNU General Public License
2725 + * along with this program; if not, write to the Free Software
2726 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
2727 + */
2728 +
2729 +#include <linux/kernel.h>
2730 +#include <linux/module.h>
2731 +#include <linux/init.h>
2732 +#include <linux/slab.h>
2733 +#include <linux/io.h>
2734 +#include <linux/interrupt.h>
2735 +#include <linux/platform_device.h>
2736 +#include <linux/usb/ch9.h>
2737 +#include <linux/usb/gadget.h>
2738 +#include <linux/usb.h>
2739 +#include <linux/usb/otg.h>
2740 +#include <linux/i2c.h>
2741 +#include <linux/workqueue.h>
2742 +#include <linux/kobject.h>
2743 +#include <linux/clk.h>
2744 +#include <linux/mutex.h>
2745 +
2746 +#include <asm/irq.h>
2747 +#include <plat/usb.h>
2748 +
2749 +#include "cbus.h"
2750 +#include "tahvo.h"
2751 +
2752 +#define DRIVER_NAME     "tahvo-usb"
2753 +
2754 +#define USBR_SLAVE_CONTROL     (1 << 8)
2755 +#define USBR_VPPVIO_SW         (1 << 7)
2756 +#define USBR_SPEED             (1 << 6)
2757 +#define USBR_REGOUT            (1 << 5)
2758 +#define USBR_MASTER_SW2                (1 << 4)
2759 +#define USBR_MASTER_SW1                (1 << 3)
2760 +#define USBR_SLAVE_SW          (1 << 2)
2761 +#define USBR_NSUSPEND          (1 << 1)
2762 +#define USBR_SEMODE            (1 << 0)
2763 +
2764 +/* bits in OTG_CTRL */
2765 +
2766 +/* Bits that are controlled by OMAP OTG and are read-only */
2767 +#define OTG_CTRL_OMAP_MASK     (OTG_PULLDOWN|OTG_PULLUP|OTG_DRV_VBUS|\
2768 +                               OTG_PD_VBUS|OTG_PU_VBUS|OTG_PU_ID)
2769 +/* Bits that are controlled by transceiver */
2770 +#define OTG_CTRL_XCVR_MASK     (OTG_ASESSVLD|OTG_BSESSEND|\
2771 +                               OTG_BSESSVLD|OTG_VBUSVLD|OTG_ID)
2772 +/* Bits that are controlled by system */
2773 +#define OTG_CTRL_SYS_MASK      (OTG_A_BUSREQ|OTG_A_SETB_HNPEN|OTG_B_BUSREQ|\
2774 +                               OTG_B_HNPEN|OTG_BUSDROP)
2775 +
2776 +#if defined(CONFIG_USB_OHCI_HCD) && !defined(CONFIG_USB_OTG)
2777 +#error tahvo-otg.c does not work with OCHI yet!
2778 +#endif
2779 +
2780 +#define TAHVO_MODE_HOST                0
2781 +#define TAHVO_MODE_PERIPHERAL  1
2782 +
2783 +#ifdef CONFIG_USB_OTG
2784 +#define TAHVO_MODE(tu)         (tu)->tahvo_mode
2785 +#elif defined(CONFIG_USB_GADGET_OMAP)
2786 +#define TAHVO_MODE(tu)         TAHVO_MODE_PERIPHERAL
2787 +#else
2788 +#define TAHVO_MODE(tu)         TAHVO_MODE_HOST
2789 +#endif
2790 +
2791 +struct tahvo_usb {
2792 +       struct device           *dev;
2793 +       struct platform_device *pt_dev;
2794 +       struct otg_transceiver otg;
2795 +       int vbus_state;
2796 +       struct mutex serialize;
2797 +#ifdef CONFIG_USB_OTG
2798 +       int tahvo_mode;
2799 +#endif
2800 +       struct clk *ick;
2801 +
2802 +       int             irq;
2803 +};
2804 +static struct tahvo_usb *tahvo_usb_device;
2805 +
2806 +/*
2807 + * ---------------------------------------------------------------------------
2808 + * OTG related functions
2809 + *
2810 + * These shoud be separated into omap-otg.c driver module, as they are used
2811 + * by various transceivers. These functions are needed in the UDC-only case
2812 + * as well. These functions are copied from GPL isp1301_omap.c
2813 + * ---------------------------------------------------------------------------
2814 + */
2815 +static struct platform_device *tahvo_otg_dev;
2816 +
2817 +static irqreturn_t omap_otg_irq(int irq, void *arg)
2818 +{
2819 +       u16 otg_irq;
2820 +
2821 +       otg_irq = omap_readw(OTG_IRQ_SRC);
2822 +       if (otg_irq & OPRT_CHG) {
2823 +               omap_writew(OPRT_CHG, OTG_IRQ_SRC);
2824 +       } else if (otg_irq & B_SRP_TMROUT) {
2825 +               omap_writew(B_SRP_TMROUT, OTG_IRQ_SRC);
2826 +       } else if (otg_irq & B_HNP_FAIL) {
2827 +               omap_writew(B_HNP_FAIL, OTG_IRQ_SRC);
2828 +       } else if (otg_irq & A_SRP_DETECT) {
2829 +               omap_writew(A_SRP_DETECT, OTG_IRQ_SRC);
2830 +       } else if (otg_irq & A_REQ_TMROUT) {
2831 +               omap_writew(A_REQ_TMROUT, OTG_IRQ_SRC);
2832 +       } else if (otg_irq & A_VBUS_ERR) {
2833 +               omap_writew(A_VBUS_ERR, OTG_IRQ_SRC);
2834 +       } else if (otg_irq & DRIVER_SWITCH) {
2835 +#ifdef CONFIG_USB_OTG
2836 +               if ((!(omap_readl(OTG_CTRL) & OTG_DRIVER_SEL)) &&
2837 +                  tu->otg.host && tu->otg.state == OTG_STATE_A_HOST) {
2838 +                       /* role is host */
2839 +                       usb_bus_start_enum(tu->otg.host,
2840 +                                          tu->otg.host->otg_port);
2841 +               }
2842 +#endif
2843 +               omap_writew(DRIVER_SWITCH, OTG_IRQ_SRC);
2844 +       } else
2845 +               return IRQ_NONE;
2846 +
2847 +       return IRQ_HANDLED;
2848 +
2849 +}
2850 +
2851 +static int tahvo_otg_init(void)
2852 +{
2853 +       u32 l;
2854 +
2855 +#ifdef CONFIG_USB_OTG
2856 +       if (!tahvo_otg_dev) {
2857 +               printk("tahvo-usb: no tahvo_otg_dev\n");
2858 +               return -ENODEV;
2859 +       }
2860 +#endif
2861 +
2862 +       l = omap_readl(OTG_SYSCON_1);
2863 +       l &= ~OTG_IDLE_EN;
2864 +       omap_writel(l, OTG_SYSCON_1);
2865 +       udelay(100);
2866 +
2867 +       /* some of these values are board-specific... */
2868 +       l = omap_readl(OTG_SYSCON_2);
2869 +       l |= OTG_EN
2870 +               /* for B-device: */
2871 +               | SRP_GPDATA            /* 9msec Bdev D+ pulse */
2872 +               | SRP_GPDVBUS           /* discharge after VBUS pulse */
2873 +               // | (3 << 24)          /* 2msec VBUS pulse */
2874 +               /* for A-device: */
2875 +               | (0 << 20)             /* 200ms nominal A_WAIT_VRISE timer */
2876 +               | SRP_DPW               /* detect 167+ns SRP pulses */
2877 +               | SRP_DATA | SRP_VBUS;  /* accept both kinds of SRP pulse */
2878 +       omap_writel(l, OTG_SYSCON_2);
2879 +
2880 +       omap_writew(DRIVER_SWITCH | OPRT_CHG
2881 +                       | B_SRP_TMROUT | B_HNP_FAIL
2882 +                                 | A_VBUS_ERR | A_SRP_DETECT | A_REQ_TMROUT,
2883 +                                       OTG_IRQ_EN);
2884 +       l = omap_readl(OTG_SYSCON_2);
2885 +       l |= OTG_EN;
2886 +       omap_writel(l, OTG_SYSCON_2);
2887 +
2888 +       return 0;
2889 +}
2890 +
2891 +static int __init omap_otg_probe(struct platform_device *pdev)
2892 +{
2893 +       int ret;
2894 +
2895 +       tahvo_otg_dev = pdev;
2896 +       ret = tahvo_otg_init();
2897 +       if (ret != 0) {
2898 +               printk(KERN_ERR "tahvo-usb: tahvo_otg_init failed\n");
2899 +               return ret;
2900 +       }
2901 +
2902 +       return request_irq(tahvo_otg_dev->resource[1].start,
2903 +                          omap_otg_irq, IRQF_DISABLED, DRIVER_NAME,
2904 +                          tahvo_usb_device);
2905 +}
2906 +
2907 +static int __exit omap_otg_remove(struct platform_device *pdev)
2908 +{
2909 +       free_irq(tahvo_otg_dev->resource[1].start, tahvo_usb_device);
2910 +       tahvo_otg_dev = NULL;
2911 +
2912 +       return 0;
2913 +}
2914 +
2915 +struct platform_driver omap_otg_driver = {
2916 +       .driver         = {
2917 +               .name   = "omap_otg",
2918 +       },
2919 +       .remove         = __exit_p(omap_otg_remove),
2920 +};
2921 +
2922 +/*
2923 + * ---------------------------------------------------------------------------
2924 + * Tahvo related functions
2925 + * These are Nokia proprietary code, except for the OTG register settings,
2926 + * which are copied from isp1301.c
2927 + * ---------------------------------------------------------------------------
2928 + */
2929 +static ssize_t vbus_state_show(struct device *device,
2930 +                              struct device_attribute *attr, char *buf)
2931 +{
2932 +       struct tahvo_usb *tu = dev_get_drvdata(device);
2933 +       return sprintf(buf, "%d\n", tu->vbus_state);
2934 +}
2935 +static DEVICE_ATTR(vbus_state, 0444, vbus_state_show, NULL);
2936 +
2937 +int vbus_active = 0;
2938 +
2939 +static void check_vbus_state(struct tahvo_usb *tu)
2940 +{
2941 +       int reg, prev_state;
2942 +
2943 +       reg = tahvo_read_reg(tu->dev, TAHVO_REG_IDSR);
2944 +       if (reg & 0x01) {
2945 +               u32 l;
2946 +
2947 +               vbus_active = 1;
2948 +               switch (tu->otg.state) {
2949 +               case OTG_STATE_B_IDLE:
2950 +                       /* Enable the gadget driver */
2951 +                       if (tu->otg.gadget)
2952 +                               usb_gadget_vbus_connect(tu->otg.gadget);
2953 +                       /* Set B-session valid and not B-sessio ended to indicate
2954 +                        * Vbus to be ok. */
2955 +                       l = omap_readl(OTG_CTRL);
2956 +                       l &= ~OTG_BSESSEND;
2957 +                       l |= OTG_BSESSVLD;
2958 +                       omap_writel(l, OTG_CTRL);
2959 +
2960 +                       tu->otg.state = OTG_STATE_B_PERIPHERAL;
2961 +                       break;
2962 +               case OTG_STATE_A_IDLE:
2963 +                       /* Session is now valid assuming the USB hub is driving Vbus */
2964 +                       tu->otg.state = OTG_STATE_A_HOST;
2965 +                       break;
2966 +               default:
2967 +                       break;
2968 +               }
2969 +               printk("USB cable connected\n");
2970 +       } else {
2971 +               switch (tu->otg.state) {
2972 +               case OTG_STATE_B_PERIPHERAL:
2973 +                       if (tu->otg.gadget)
2974 +                               usb_gadget_vbus_disconnect(tu->otg.gadget);
2975 +                       tu->otg.state = OTG_STATE_B_IDLE;
2976 +                       break;
2977 +               case OTG_STATE_A_HOST:
2978 +                       tu->otg.state = OTG_STATE_A_IDLE;
2979 +                       break;
2980 +               default:
2981 +                       break;
2982 +               }
2983 +               printk("USB cable disconnected\n");
2984 +               vbus_active = 0;
2985 +       }
2986 +
2987 +       prev_state = tu->vbus_state;
2988 +       tu->vbus_state = reg & 0x01;
2989 +       if (prev_state != tu->vbus_state)
2990 +               sysfs_notify(&tu->pt_dev->dev.kobj, NULL, "vbus_state");
2991 +}
2992 +
2993 +static void tahvo_usb_become_host(struct tahvo_usb *tu)
2994 +{
2995 +       u32 l;
2996 +
2997 +       /* Clear system and transceiver controlled bits
2998 +        * also mark the A-session is always valid */
2999 +       tahvo_otg_init();
3000 +
3001 +       l = omap_readl(OTG_CTRL);
3002 +       l &= ~(OTG_CTRL_XCVR_MASK | OTG_CTRL_SYS_MASK);
3003 +       l |= OTG_ASESSVLD;
3004 +       omap_writel(l, OTG_CTRL);
3005 +
3006 +       /* Power up the transceiver in USB host mode */
3007 +       tahvo_write_reg(tu->dev, TAHVO_REG_USBR, USBR_REGOUT | USBR_NSUSPEND |
3008 +                       USBR_MASTER_SW2 | USBR_MASTER_SW1);
3009 +       tu->otg.state = OTG_STATE_A_IDLE;
3010 +
3011 +       check_vbus_state(tu);
3012 +}
3013 +
3014 +static void tahvo_usb_stop_host(struct tahvo_usb *tu)
3015 +{
3016 +       tu->otg.state = OTG_STATE_A_IDLE;
3017 +}
3018 +
3019 +static void tahvo_usb_become_peripheral(struct tahvo_usb *tu)
3020 +{
3021 +       u32 l;
3022 +
3023 +       /* Clear system and transceiver controlled bits
3024 +        * and enable ID to mark peripheral mode and
3025 +        * BSESSEND to mark no Vbus */
3026 +       tahvo_otg_init();
3027 +       l = omap_readl(OTG_CTRL);
3028 +       l &= ~(OTG_CTRL_XCVR_MASK | OTG_CTRL_SYS_MASK | OTG_BSESSVLD);
3029 +       l |= OTG_ID | OTG_BSESSEND;
3030 +       omap_writel(l, OTG_CTRL);
3031 +
3032 +       /* Power up transceiver and set it in USB perhiperal mode */
3033 +       tahvo_write_reg(tu->dev, TAHVO_REG_USBR, USBR_SLAVE_CONTROL | USBR_REGOUT | USBR_NSUSPEND | USBR_SLAVE_SW);
3034 +       tu->otg.state = OTG_STATE_B_IDLE;
3035 +
3036 +       check_vbus_state(tu);
3037 +}
3038 +
3039 +static void tahvo_usb_stop_peripheral(struct tahvo_usb *tu)
3040 +{
3041 +       u32 l;
3042 +
3043 +       l = omap_readl(OTG_CTRL);
3044 +       l &= ~OTG_BSESSVLD;
3045 +       l |= OTG_BSESSEND;
3046 +       omap_writel(l, OTG_CTRL);
3047 +
3048 +       if (tu->otg.gadget)
3049 +               usb_gadget_vbus_disconnect(tu->otg.gadget);
3050 +       tu->otg.state = OTG_STATE_B_IDLE;
3051 +
3052 +}
3053 +
3054 +static void tahvo_usb_power_off(struct tahvo_usb *tu)
3055 +{
3056 +       u32 l;
3057 +       int id;
3058 +
3059 +       /* Disable gadget controller if any */
3060 +       if (tu->otg.gadget)
3061 +               usb_gadget_vbus_disconnect(tu->otg.gadget);
3062 +
3063 +       /* Disable OTG and interrupts */
3064 +       if (TAHVO_MODE(tu) == TAHVO_MODE_PERIPHERAL)
3065 +               id = OTG_ID;
3066 +       else
3067 +               id = 0;
3068 +       l = omap_readl(OTG_CTRL);
3069 +       l &= ~(OTG_CTRL_XCVR_MASK | OTG_CTRL_SYS_MASK | OTG_BSESSVLD);
3070 +       l |= id | OTG_BSESSEND;
3071 +       omap_writel(l, OTG_CTRL);
3072 +       omap_writew(0, OTG_IRQ_EN);
3073 +
3074 +       l = omap_readl(OTG_SYSCON_2);
3075 +       l &= ~OTG_EN;
3076 +       omap_writel(l, OTG_SYSCON_2);
3077 +
3078 +       l = omap_readl(OTG_SYSCON_1);
3079 +       l |= OTG_IDLE_EN;
3080 +       omap_writel(l, OTG_SYSCON_1);
3081 +
3082 +       /* Power off transceiver */
3083 +       tahvo_write_reg(tu->dev, TAHVO_REG_USBR, 0);
3084 +       tu->otg.state = OTG_STATE_UNDEFINED;
3085 +}
3086 +
3087 +
3088 +static int tahvo_usb_set_power(struct otg_transceiver *dev, unsigned mA)
3089 +{
3090 +       struct tahvo_usb *tu = container_of(dev, struct tahvo_usb, otg);
3091 +
3092 +       dev_dbg(&tu->pt_dev->dev, "set_power %d mA\n", mA);
3093 +
3094 +       if (dev->state == OTG_STATE_B_PERIPHERAL) {
3095 +               /* REVISIT: Can Tahvo charge battery from VBUS? */
3096 +       }
3097 +       return 0;
3098 +}
3099 +
3100 +static int tahvo_usb_set_suspend(struct otg_transceiver *dev, int suspend)
3101 +{
3102 +       struct tahvo_usb *tu = container_of(dev, struct tahvo_usb, otg);
3103 +       u16 w;
3104 +
3105 +       dev_dbg(&tu->pt_dev->dev, "set_suspend\n");
3106 +
3107 +       w = tahvo_read_reg(tu->dev, TAHVO_REG_USBR);
3108 +       if (suspend)
3109 +               w &= ~USBR_NSUSPEND;
3110 +       else
3111 +               w |= USBR_NSUSPEND;
3112 +       tahvo_write_reg(tu->dev, TAHVO_REG_USBR, w);
3113 +
3114 +       return 0;
3115 +}
3116 +
3117 +static int tahvo_usb_start_srp(struct otg_transceiver *dev)
3118 +{
3119 +       struct tahvo_usb *tu = container_of(dev, struct tahvo_usb, otg);
3120 +       u32 otg_ctrl;
3121 +
3122 +       dev_dbg(&tu->pt_dev->dev, "start_srp\n");
3123 +
3124 +       if (!dev || tu->otg.state != OTG_STATE_B_IDLE)
3125 +               return -ENODEV;
3126 +
3127 +       otg_ctrl = omap_readl(OTG_CTRL);
3128 +       if (!(otg_ctrl & OTG_BSESSEND))
3129 +               return -EINVAL;
3130 +
3131 +       otg_ctrl |= OTG_B_BUSREQ;
3132 +       otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_SYS_MASK;
3133 +       omap_writel(otg_ctrl, OTG_CTRL);
3134 +       tu->otg.state = OTG_STATE_B_SRP_INIT;
3135 +
3136 +       return 0;
3137 +}
3138 +
3139 +static int tahvo_usb_start_hnp(struct otg_transceiver *otg)
3140 +{
3141 +       struct tahvo_usb *tu = container_of(otg, struct tahvo_usb, otg);
3142 +
3143 +       dev_dbg(&tu->pt_dev->dev, "start_hnp\n");
3144 +#ifdef CONFIG_USB_OTG
3145 +       /* REVISIT: Add this for OTG */
3146 +#endif
3147 +       return -EINVAL;
3148 +}
3149 +
3150 +static int tahvo_usb_set_host(struct otg_transceiver *otg, struct usb_bus *host)
3151 +{
3152 +       struct tahvo_usb *tu = container_of(otg, struct tahvo_usb, otg);
3153 +       u32 l;
3154 +
3155 +       dev_dbg(&tu->pt_dev->dev, "set_host %p\n", host);
3156 +
3157 +       if (otg == NULL)
3158 +               return -ENODEV;
3159 +
3160 +#if defined(CONFIG_USB_OTG) || !defined(CONFIG_USB_GADGET_OMAP)
3161 +
3162 +       mutex_lock(&tu->serialize);
3163 +
3164 +       if (host == NULL) {
3165 +               if (TAHVO_MODE(tu) == TAHVO_MODE_HOST)
3166 +                       tahvo_usb_power_off(tu);
3167 +               tu->otg.host = NULL;
3168 +               mutex_unlock(&tu->serialize);
3169 +               return 0;
3170 +       }
3171 +
3172 +       l = omap_readl(OTG_SYSCON_1);
3173 +       l &= ~(OTG_IDLE_EN | HST_IDLE_EN | DEV_IDLE_EN);
3174 +       omap_writel(l, OTG_SYSCON_1);
3175 +
3176 +       if (TAHVO_MODE(tu) == TAHVO_MODE_HOST) {
3177 +               tu->otg.host = NULL;
3178 +               tahvo_usb_become_host(tu);
3179 +       }
3180 +
3181 +       tu->otg.host = host;
3182 +
3183 +       mutex_unlock(&tu->serialize);
3184 +#else
3185 +       /* No host mode configured, so do not allow host controlled to be set */
3186 +       return -EINVAL;
3187 +#endif
3188 +
3189 +       return 0;
3190 +}
3191 +
3192 +static int tahvo_usb_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget)
3193 +{
3194 +       struct tahvo_usb *tu = container_of(otg, struct tahvo_usb, otg);
3195 +
3196 +       dev_dbg(&tu->pt_dev->dev, "set_peripheral %p\n", gadget);
3197 +
3198 +       if (!otg)
3199 +               return -ENODEV;
3200 +
3201 +#if defined(CONFIG_USB_OTG) || defined(CONFIG_USB_GADGET_OMAP)
3202 +
3203 +       mutex_lock(&tu->serialize);
3204 +
3205 +       if (!gadget) {
3206 +               if (TAHVO_MODE(tu) == TAHVO_MODE_PERIPHERAL)
3207 +                       tahvo_usb_power_off(tu);
3208 +               tu->otg.gadget = NULL;
3209 +               mutex_unlock(&tu->serialize);
3210 +               return 0;
3211 +       }
3212 +
3213 +       tu->otg.gadget = gadget;
3214 +       if (TAHVO_MODE(tu) == TAHVO_MODE_PERIPHERAL)
3215 +               tahvo_usb_become_peripheral(tu);
3216 +
3217 +       mutex_unlock(&tu->serialize);
3218 +#else
3219 +       /* No gadget mode configured, so do not allow host controlled to be set */
3220 +       return -EINVAL;
3221 +#endif
3222 +
3223 +       return 0;
3224 +}
3225 +
3226 +static irqreturn_t tahvo_usb_vbus_interrupt(int irq, void *_tu)
3227 +{
3228 +       struct tahvo_usb *tu = _tu;
3229 +
3230 +       check_vbus_state(tu);
3231 +
3232 +       return IRQ_HANDLED;
3233 +}
3234 +
3235 +#ifdef CONFIG_USB_OTG
3236 +static ssize_t otg_mode_show(struct device *device,
3237 +                            struct device_attribute *attr, char *buf)
3238 +{
3239 +       struct tahvo_usb *tu = dev_get_drvdata(device);
3240 +       switch (tu->tahvo_mode) {
3241 +       case TAHVO_MODE_HOST:
3242 +               return sprintf(buf, "host\n");
3243 +       case TAHVO_MODE_PERIPHERAL:
3244 +               return sprintf(buf, "peripheral\n");
3245 +       }
3246 +       return sprintf(buf, "unknown\n");
3247 +}
3248 +
3249 +static ssize_t otg_mode_store(struct device *device,
3250 +                             struct device_attribute *attr,
3251 +                             const char *buf, size_t count)
3252 +{
3253 +       struct tahvo_usb *tu = dev_get_drvdata(device);
3254 +       int r;
3255 +
3256 +       r = strlen(buf);
3257 +       mutex_lock(&tu->serialize);
3258 +       if (strncmp(buf, "host", 4) == 0) {
3259 +               if (tu->tahvo_mode == TAHVO_MODE_PERIPHERAL)
3260 +                       tahvo_usb_stop_peripheral(tu);
3261 +               tu->tahvo_mode = TAHVO_MODE_HOST;
3262 +               if (tu->otg.host) {
3263 +                       printk(KERN_INFO "Selected HOST mode: host controller present.\n");
3264 +                       tahvo_usb_become_host(tu);
3265 +               } else {
3266 +                       printk(KERN_INFO "Selected HOST mode: no host controller, powering off.\n");
3267 +                       tahvo_usb_power_off(tu);
3268 +               }
3269 +       } else if (strncmp(buf, "peripheral", 10) == 0) {
3270 +               if (tu->tahvo_mode == TAHVO_MODE_HOST)
3271 +                       tahvo_usb_stop_host(tu);
3272 +               tu->tahvo_mode = TAHVO_MODE_PERIPHERAL;
3273 +               if (tu->otg.gadget) {
3274 +                       printk(KERN_INFO "Selected PERIPHERAL mode: gadget driver present.\n");
3275 +                       tahvo_usb_become_peripheral(tu);
3276 +               } else {
3277 +                       printk(KERN_INFO "Selected PERIPHERAL mode: no gadget driver, powering off.\n");
3278 +                       tahvo_usb_power_off(tu);
3279 +               }
3280 +       } else
3281 +               r = -EINVAL;
3282 +
3283 +       mutex_unlock(&tu->serialize);
3284 +       return r;
3285 +}
3286 +
3287 +static DEVICE_ATTR(otg_mode, 0644, otg_mode_show, otg_mode_store);
3288 +#endif
3289 +
3290 +static int __init tahvo_usb_probe(struct platform_device *pdev)
3291 +{
3292 +       struct tahvo_usb *tu;
3293 +       struct device *dev = &pdev->dev;
3294 +       int ret;
3295 +       int irq;
3296 +
3297 +       dev_dbg(dev, "probe\n");
3298 +
3299 +       /* Create driver data */
3300 +       tu = kzalloc(sizeof(*tu), GFP_KERNEL);
3301 +       if (!tu)
3302 +               return -ENOMEM;
3303 +       tahvo_usb_device = tu;
3304 +
3305 +       tu->dev = dev;
3306 +       tu->pt_dev = pdev;
3307 +#ifdef CONFIG_USB_OTG
3308 +       /* Default mode */
3309 +#ifdef CONFIG_CBUS_TAHVO_USB_HOST_BY_DEFAULT
3310 +       tu->tahvo_mode = TAHVO_MODE_HOST;
3311 +#else
3312 +       tu->tahvo_mode = TAHVO_MODE_PERIPHERAL;
3313 +#endif
3314 +#endif
3315 +
3316 +       mutex_init(&tu->serialize);
3317 +
3318 +       tu->ick = clk_get(NULL, "usb_l4_ick");
3319 +       if (IS_ERR(tu->ick)) {
3320 +               dev_err(dev, "Failed to get usb_l4_ick\n");
3321 +               ret = PTR_ERR(tu->ick);
3322 +               goto err_free_tu;
3323 +       }
3324 +       clk_enable(tu->ick);
3325 +
3326 +       /* Set initial state, so that we generate kevents only on
3327 +        * state changes */
3328 +       tu->vbus_state = tahvo_read_reg(tu->dev, TAHVO_REG_IDSR) & 0x01;
3329 +
3330 +       irq = platform_get_irq(pdev, 0);
3331 +       tu->irq = irq;
3332 +
3333 +       /* We cannot enable interrupt until omap_udc is initialized */
3334 +       ret = request_threaded_irq(irq, NULL, tahvo_usb_vbus_interrupt,
3335 +                       IRQF_ONESHOT, "tahvo-vbus", tu);
3336 +       if (ret != 0) {
3337 +               printk(KERN_ERR "Could not register Tahvo interrupt for VBUS\n");
3338 +               goto err_release_clk;
3339 +       }
3340 +
3341 +       /* Attributes */
3342 +       ret = device_create_file(dev, &dev_attr_vbus_state);
3343 +#ifdef CONFIG_USB_OTG
3344 +       ret |= device_create_file(dev, &dev_attr_otg_mode);
3345 +#endif
3346 +       if (ret)
3347 +               printk(KERN_ERR "attribute creation failed: %d\n", ret);
3348 +
3349 +       /* Create OTG interface */
3350 +       tahvo_usb_power_off(tu);
3351 +       tu->otg.state = OTG_STATE_UNDEFINED;
3352 +       tu->otg.label = DRIVER_NAME;
3353 +       tu->otg.set_host = tahvo_usb_set_host;
3354 +       tu->otg.set_peripheral = tahvo_usb_set_peripheral;
3355 +       tu->otg.set_power = tahvo_usb_set_power;
3356 +       tu->otg.set_suspend = tahvo_usb_set_suspend;
3357 +       tu->otg.start_srp = tahvo_usb_start_srp;
3358 +       tu->otg.start_hnp = tahvo_usb_start_hnp;
3359 +
3360 +       ret = otg_set_transceiver(&tu->otg);
3361 +       if (ret < 0) {
3362 +               printk(KERN_ERR "Cannot register USB transceiver\n");
3363 +               goto err_free_irq;
3364 +       }
3365 +
3366 +       dev_set_drvdata(dev, tu);
3367 +
3368 +       return 0;
3369 +
3370 +err_free_irq:
3371 +       free_irq(tu->irq, tu);
3372 +err_release_clk:
3373 +       clk_disable(tu->ick);
3374 +       clk_put(tu->ick);
3375 +err_free_tu:
3376 +       kfree(tu);
3377 +       tahvo_usb_device = NULL;
3378 +
3379 +       return ret;
3380 +}
3381 +
3382 +static int __exit tahvo_usb_remove(struct platform_device *pdev)
3383 +{
3384 +       struct tahvo_usb *tu = platform_get_drvdata(pdev);
3385 +
3386 +       dev_dbg(&pdev->dev, "remove\n");
3387 +
3388 +       free_irq(tu->irq, tu);
3389 +       flush_scheduled_work();
3390 +       otg_set_transceiver(0);
3391 +       device_remove_file(&pdev->dev, &dev_attr_vbus_state);
3392 +#ifdef CONFIG_USB_OTG
3393 +       device_remove_file(&pdev->dev, &dev_attr_otg_mode);
3394 +#endif
3395 +       clk_disable(tu->ick);
3396 +       clk_put(tu->ick);
3397 +
3398 +       kfree(tu);
3399 +       tahvo_usb_device = NULL;
3400 +
3401 +       return 0;
3402 +}
3403 +
3404 +static struct platform_driver tahvo_usb_driver = {
3405 +       .driver         = {
3406 +               .name   = "tahvo-usb",
3407 +       },
3408 +       .remove         = __exit_p(tahvo_usb_remove),
3409 +};
3410 +
3411 +static int __init tahvo_usb_init(void)
3412 +{
3413 +       int ret = 0;
3414 +
3415 +       ret = platform_driver_probe(&tahvo_usb_driver, tahvo_usb_probe);
3416 +       if (ret)
3417 +               return ret;
3418 +
3419 +       ret = platform_driver_probe(&omap_otg_driver, omap_otg_probe);
3420 +       if (ret) {
3421 +               platform_driver_unregister(&tahvo_usb_driver);
3422 +               return ret;
3423 +       }
3424 +
3425 +       return 0;
3426 +}
3427 +
3428 +subsys_initcall(tahvo_usb_init);
3429 +
3430 +static void __exit tahvo_usb_exit(void)
3431 +{
3432 +       platform_driver_unregister(&omap_otg_driver);
3433 +       platform_driver_unregister(&tahvo_usb_driver);
3434 +}
3435 +module_exit(tahvo_usb_exit);
3436 +
3437 +MODULE_DESCRIPTION("Tahvo USB OTG Transceiver Driver");
3438 +MODULE_LICENSE("GPL");
3439 +MODULE_AUTHOR("Juha Yrjölä, Tony Lindgren, and Timo Teräs");
3440 --- a/drivers/Makefile
3441 +++ b/drivers/Makefile
3442 @@ -76,7 +76,7 @@ obj-$(CONFIG_GAMEPORT)                += input/gamepor
3443  obj-$(CONFIG_INPUT)            += input/
3444  obj-$(CONFIG_I2O)              += message/
3445  obj-$(CONFIG_RTC_LIB)          += rtc/
3446 -obj-y                          += i2c/ media/
3447 +obj-y                          += i2c/ media/ cbus/
3448  obj-$(CONFIG_PPS)              += pps/
3449  obj-$(CONFIG_PTP_1588_CLOCK)   += ptp/
3450  obj-$(CONFIG_W1)               += w1/
3451 --- a/drivers/Kconfig
3452 +++ b/drivers/Kconfig
3453 @@ -2,6 +2,8 @@ menu "Device Drivers"
3454
3455  source "drivers/base/Kconfig"
3456
3457 +source "drivers/cbus/Kconfig"
3458 +
3459  source "drivers/connector/Kconfig"
3460
3461  source "drivers/mtd/Kconfig"