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