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