projects / openwrt / svn-archive / archive.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
omap24xx: Improve n810 battery management
[openwrt/svn-archive/archive.git] / target / linux / omap24xx / patches-2.6.36 / 500-cbus.patch
1 ---
2 arch/arm/Kconfig | 4
3 drivers/Makefile | 2
4 drivers/cbus/Kconfig | 89 ++++
5 drivers/cbus/Makefile | 14
6 drivers/cbus/cbus.c | 309 ++++++++++++++++
7 drivers/cbus/cbus.h | 36 +
8 drivers/cbus/retu-headset.c | 356 ++++++++++++++++++
9 drivers/cbus/retu-pwrbutton.c | 118 ++++++
10 drivers/cbus/retu-rtc.c | 477 ++++++++++++++++++++++++
11 drivers/cbus/retu-user.c | 424 ++++++++++++++++++++++
12 drivers/cbus/retu-wdt.c | 387 ++++++++++++++++++++
13 drivers/cbus/retu.c | 468 ++++++++++++++++++++++++
14 drivers/cbus/retu.h | 77 ++++
15 drivers/cbus/tahvo-usb.c | 788 +++++++++++++++++++++++++++++++++++++++++
16 drivers/cbus/tahvo-user.c | 406 +++++++++++++++++++++
17 drivers/cbus/tahvo.c | 443 +++++++++++++++++++++++
18 drivers/cbus/tahvo.h | 61 +++
19 drivers/cbus/user_retu_tahvo.h | 75 +++
20 18 files changed, 4533 insertions(+), 1 deletion(-)
21
22 --- /dev/null
23 +++ linux-2.6.36-rc7/drivers/cbus/cbus.c
24 @@ -0,0 +1,309 @@
25 +/*
26 + * drivers/cbus/cbus.c
27 + *
28 + * Support functions for CBUS serial protocol
29 + *
30 + * Copyright (C) 2004, 2005 Nokia Corporation
31 + *
32 + * Written by Juha Yrjölä <juha.yrjola@nokia.com>,
33 + * David Weinehall <david.weinehall@nokia.com>, and
34 + * Mikko Ylinen <mikko.k.ylinen@nokia.com>
35 + *
36 + * This file is subject to the terms and conditions of the GNU General
37 + * Public License. See the file "COPYING" in the main directory of this
38 + * archive for more details.
39 + *
40 + * This program is distributed in the hope that it will be useful,
41 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
42 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
43 + * GNU General Public License for more details.
44 + *
45 + * You should have received a copy of the GNU General Public License
46 + * along with this program; if not, write to the Free Software
47 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
48 + */
49 +
50 +#include <linux/device.h>
51 +#include <linux/init.h>
52 +#include <linux/kernel.h>
53 +#include <linux/delay.h>
54 +#include <linux/spinlock.h>
55 +#include <linux/gpio.h>
56 +#include <linux/platform_device.h>
57 +#include <linux/slab.h>
58 +
59 +#include <asm/io.h>
60 +#include <asm/mach-types.h>
61 +
62 +#include <plat/board.h>
63 +#include <plat/cbus.h>
64 +
65 +#include "cbus.h"
66 +
67 +struct cbus_host *cbus_host = NULL;
68 +EXPORT_SYMBOL(cbus_host);
69 +
70 +#ifdef CONFIG_ARCH_OMAP1
71 +/* We use our own MPUIO functions to get closer to 1MHz bus speed */
72 +
73 +static inline void cbus_set_gpio_direction(u32 base, int mpuio, int is_input)
74 +{
75 + u16 w;
76 +
77 + mpuio &= 0x0f;
78 + w = __raw_readw(base + OMAP_MPUIO_IO_CNTL);
79 + if (is_input)
80 + w |= 1 << mpuio;
81 + else
82 + w &= ~(1 << mpuio);
83 + __raw_writew(w, base + OMAP_MPUIO_IO_CNTL);
84 +
85 +}
86 +
87 +static inline void cbus_set_gpio_dataout(u32 base, int mpuio, int enable)
88 +{
89 + u16 w;
90 +
91 + mpuio &= 0x0f;
92 + w = __raw_readw(base + OMAP_MPUIO_OUTPUT);
93 + if (enable)
94 + w |= 1 << mpuio;
95 + else
96 + w &= ~(1 << mpuio);
97 + __raw_writew(w, base + OMAP_MPUIO_OUTPUT);
98 +}
99 +
100 +static inline int cbus_get_gpio_datain(u32 base, int mpuio)
101 +{
102 + mpuio &= 0x0f;
103 +
104 + return (__raw_readw(base + OMAP_MPUIO_INPUT_LATCH) & (1 << mpuio)) != 0;
105 +}
106 +
107 +static void cbus_send_bit(struct cbus_host *host, u32 base, int bit,
108 + int set_to_input)
109 +{
110 + cbus_set_gpio_dataout(base, host->dat_gpio, bit ? 1 : 0);
111 + cbus_set_gpio_dataout(base, host->clk_gpio, 1);
112 +
113 + /* The data bit is read on the rising edge of CLK */
114 + if (set_to_input)
115 + cbus_set_gpio_direction(base, host->dat_gpio, 1);
116 +
117 + cbus_set_gpio_dataout(base, host->clk_gpio, 0);
118 +}
119 +
120 +static u8 cbus_receive_bit(struct cbus_host *host, u32 base)
121 +{
122 + u8 ret;
123 +
124 + cbus_set_gpio_dataout(base, host->clk_gpio, 1);
125 + ret = cbus_get_gpio_datain(base, host->dat_gpio);
126 + cbus_set_gpio_dataout(base, host->clk_gpio, 0);
127 +
128 + return ret;
129 +}
130 +
131 +#define cbus_output(base, gpio, val) cbus_set_gpio_direction(base, gpio, 0)
132 +
133 +#else
134 +
135 +#define cbus_output(base, gpio, val) gpio_direction_output(gpio, val)
136 +#define cbus_set_gpio_dataout(base, gpio, enable) gpio_set_value(gpio, enable)
137 +#define cbus_get_gpio_datain(base, int, gpio) gpio_get_value(gpio)
138 +
139 +static void _cbus_send_bit(struct cbus_host *host, int bit, int set_to_input)
140 +{
141 + gpio_set_value(host->dat_gpio, bit ? 1 : 0);
142 + gpio_set_value(host->clk_gpio, 1);
143 +
144 + /* The data bit is read on the rising edge of CLK */
145 + if (set_to_input)
146 + gpio_direction_input(host->dat_gpio);
147 +
148 + gpio_set_value(host->clk_gpio, 0);
149 +}
150 +
151 +static u8 _cbus_receive_bit(struct cbus_host *host)
152 +{
153 + u8 ret;
154 +
155 + gpio_set_value(host->clk_gpio, 1);
156 + ret = gpio_get_value(host->dat_gpio);
157 + gpio_set_value(host->clk_gpio, 0);
158 +
159 + return ret;
160 +}
161 +
162 +#define cbus_send_bit(host, base, bit, set_to_input) _cbus_send_bit(host, bit, set_to_input)
163 +#define cbus_receive_bit(host, base) _cbus_receive_bit(host)
164 +
165 +#endif
166 +
167 +static int cbus_transfer(struct cbus_host *host, int dev, int reg, int data)
168 +{
169 + int i;
170 + int is_read = 0;
171 + unsigned long flags;
172 + u32 base;
173 +
174 +#ifdef CONFIG_ARCH_OMAP1
175 + base = OMAP1_IO_ADDRESS(OMAP1_MPUIO_BASE);
176 +#else
177 + base = 0;
178 +#endif
179 +
180 + if (data < 0)
181 + is_read = 1;
182 +
183 + /* We don't want interrupts disturbing our transfer */
184 + spin_lock_irqsave(&host->lock, flags);
185 +
186 + /* Reset state and start of transfer, SEL stays down during transfer */
187 + cbus_set_gpio_dataout(base, host->sel_gpio, 0);
188 +
189 + /* Set the DAT pin to output */
190 + cbus_output(base, host->dat_gpio, 1);
191 +
192 + /* Send the device address */
193 + for (i = 3; i > 0; i--)
194 + cbus_send_bit(host, base, dev & (1 << (i - 1)), 0);
195 +
196 + /* Send the rw flag */
197 + cbus_send_bit(host, base, is_read, 0);
198 +
199 + /* Send the register address */
200 + for (i = 5; i > 0; i--) {
201 + int set_to_input = 0;
202 +
203 + if (is_read && i == 1)
204 + set_to_input = 1;
205 +
206 + cbus_send_bit(host, base, reg & (1 << (i - 1)), set_to_input);
207 + }
208 +
209 + if (!is_read) {
210 + for (i = 16; i > 0; i--)
211 + cbus_send_bit(host, base, data & (1 << (i - 1)), 0);
212 + } else {
213 + cbus_set_gpio_dataout(base, host->clk_gpio, 1);
214 + data = 0;
215 +
216 + for (i = 16; i > 0; i--) {
217 + u8 bit = cbus_receive_bit(host, base);
218 +
219 + if (bit)
220 + data |= 1 << (i - 1);
221 + }
222 + }
223 +
224 + /* Indicate end of transfer, SEL goes up until next transfer */
225 + cbus_set_gpio_dataout(base, host->sel_gpio, 1);
226 + cbus_set_gpio_dataout(base, host->clk_gpio, 1);
227 + cbus_set_gpio_dataout(base, host->clk_gpio, 0);
228 +
229 + spin_unlock_irqrestore(&host->lock, flags);
230 +
231 + return is_read ? data : 0;
232 +}
233 +
234 +/*
235 + * Read a given register from the device
236 + */
237 +int cbus_read_reg(struct cbus_host *host, int dev, int reg)
238 +{
239 + return cbus_host ? cbus_transfer(host, dev, reg, -1) : -ENODEV;
240 +}
241 +EXPORT_SYMBOL(cbus_read_reg);
242 +
243 +/*
244 + * Write to a given register of the device
245 + */
246 +int cbus_write_reg(struct cbus_host *host, int dev, int reg, u16 val)
247 +{
248 + return cbus_host ? cbus_transfer(host, dev, reg, (int)val) : -ENODEV;
249 +}
250 +EXPORT_SYMBOL(cbus_write_reg);
251 +
252 +static int __init cbus_bus_probe(struct platform_device *pdev)
253 +{
254 + struct cbus_host *chost;
255 + struct cbus_host_platform_data *pdata = pdev->dev.platform_data;
256 + int ret;
257 +
258 + chost = kzalloc(sizeof (*chost), GFP_KERNEL);
259 + if (chost == NULL)
260 + return -ENOMEM;
261 +
262 + spin_lock_init(&chost->lock);
263 +
264 + chost->clk_gpio = pdata->clk_gpio;
265 + chost->dat_gpio = pdata->dat_gpio;
266 + chost->sel_gpio = pdata->sel_gpio;
267 +
268 + if ((ret = gpio_request(chost->clk_gpio, "CBUS clk")) < 0)
269 + goto exit1;
270 +
271 + if ((ret = gpio_request(chost->dat_gpio, "CBUS data")) < 0)
272 + goto exit2;
273 +
274 + if ((ret = gpio_request(chost->sel_gpio, "CBUS sel")) < 0)
275 + goto exit3;
276 +
277 + gpio_direction_output(chost->clk_gpio, 0);
278 + gpio_direction_input(chost->dat_gpio);
279 + gpio_direction_output(chost->sel_gpio, 1);
280 +
281 + gpio_set_value(chost->clk_gpio, 1);
282 + gpio_set_value(chost->clk_gpio, 0);
283 +
284 + platform_set_drvdata(pdev, chost);
285 +
286 + cbus_host = chost;
287 +
288 + return 0;
289 +exit3:
290 + gpio_free(chost->dat_gpio);
291 +exit2:
292 + gpio_free(chost->clk_gpio);
293 +exit1:
294 + kfree(chost);
295 +
296 + return ret;
297 +}
298 +
299 +static void __exit cbus_bus_remove(struct platform_device *pdev)
300 +{
301 + struct cbus_host *chost = platform_get_drvdata(pdev);
302 +
303 + gpio_free(chost->dat_gpio);
304 + gpio_free(chost->clk_gpio);
305 + kfree(chost);
306 +}
307 +
308 +static struct platform_driver cbus_driver = {
309 + .remove = __exit_p(cbus_bus_remove),
310 + .driver = {
311 + .name = "cbus",
312 + },
313 +};
314 +
315 +static int __init cbus_bus_init(void)
316 +{
317 + return platform_driver_probe(&cbus_driver, cbus_bus_probe);
318 +}
319 +
320 +subsys_initcall(cbus_bus_init);
321 +
322 +static void __exit cbus_bus_exit(void)
323 +{
324 + platform_driver_unregister(&cbus_driver);
325 +}
326 +module_exit(cbus_bus_exit);
327 +
328 +MODULE_DESCRIPTION("CBUS serial protocol");
329 +MODULE_LICENSE("GPL");
330 +MODULE_AUTHOR("Juha Yrjölä");
331 +MODULE_AUTHOR("David Weinehall");
332 +MODULE_AUTHOR("Mikko Ylinen");
333 +
334 --- /dev/null
335 +++ linux-2.6.36-rc7/drivers/cbus/cbus.h
336 @@ -0,0 +1,36 @@
337 +/*
338 + * drivers/cbus/cbus.h
339 + *
340 + * Copyright (C) 2004, 2005 Nokia Corporation
341 + *
342 + * Written by Juha Yrjölä <juha.yrjola@nokia.com> and
343 + * David Weinehall <david.weinehall@nokia.com>
344 + *
345 + * This file is subject to the terms and conditions of the GNU General
346 + * Public License. See the file "COPYING" in the main directory of this
347 + * archive for more details.
348 + *
349 + * This program is distributed in the hope that it will be useful,
350 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
351 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
352 + * GNU General Public License for more details.
353 + *
354 + * You should have received a copy of the GNU General Public License
355 + * along with this program; if not, write to the Free Software
356 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
357 + */
358 +
359 +#ifndef __DRIVERS_CBUS_CBUS_H
360 +#define __DRIVERS_CBUS_CBUS_H
361 +
362 +struct cbus_host {
363 + int clk_gpio, dat_gpio, sel_gpio;
364 + spinlock_t lock;
365 +};
366 +
367 +extern struct cbus_host *cbus_host;
368 +
369 +extern int cbus_read_reg(struct cbus_host *host, int dev, int reg);
370 +extern int cbus_write_reg(struct cbus_host *host, int dev, int reg, u16 val);
371 +
372 +#endif /* __DRIVERS_CBUS_CBUS_H */
373 --- /dev/null
374 +++ linux-2.6.36-rc7/drivers/cbus/Kconfig
375 @@ -0,0 +1,89 @@
376 +#
377 +# CBUS device configuration
378 +#
379 +
380 +menu "CBUS support"
381 +
382 +config CBUS
383 + depends on ARCH_OMAP
384 + bool "CBUS support on OMAP"
385 + ---help---
386 + CBUS is a proprietary serial protocol by Nokia. It is mainly
387 + used for accessing Energy Management auxiliary chips.
388 +
389 + If you want CBUS support, you should say Y here.
390 +
391 +config CBUS_TAHVO
392 + depends on CBUS
393 + bool "Support for Tahvo"
394 + ---help---
395 + Tahvo is a mixed signal ASIC with some system features
396 +
397 + If you want Tahvo support, you should say Y here.
398 +
399 +config CBUS_TAHVO_USER
400 + depends on CBUS_TAHVO
401 + bool "Support for Tahvo user space functions"
402 + ---help---
403 + If you want support for Tahvo's user space read/write etc. functions,
404 + you should say Y here.
405 +
406 +config CBUS_TAHVO_USB
407 + depends on CBUS_TAHVO && USB
408 + tristate "Support for Tahvo USB transceiver"
409 + ---help---
410 + If you want Tahvo support for USB transceiver, say Y or M here.
411 +
412 +config CBUS_TAHVO_USB_HOST_BY_DEFAULT
413 + depends on CBUS_TAHVO_USB && USB_OTG
414 + boolean "Device in USB host mode by default"
415 + ---help---
416 + Say Y here, if you want the device to enter USB host mode
417 + by default on bootup.
418 +
419 +config CBUS_RETU
420 + depends on CBUS
421 + bool "Support for Retu"
422 + ---help---
423 + Retu is a mixed signal ASIC with some system features
424 +
425 + If you want Retu support, you should say Y here.
426 +
427 +config CBUS_RETU_USER
428 + depends on CBUS_RETU
429 + bool "Support for Retu user space functions"
430 + ---help---
431 + If you want support for Retu's user space read/write etc. functions,
432 + you should say Y here.
433 +
434 +config CBUS_RETU_POWERBUTTON
435 + depends on CBUS_RETU
436 + bool "Support for Retu power button"
437 + ---help---
438 + The power button on Nokia 770 is connected to the Retu ASIC.
439 +
440 + If you want support for the Retu power button, you should say Y here.
441 +
442 +config CBUS_RETU_RTC
443 + depends on CBUS_RETU && SYSFS
444 + tristate "Support for Retu pseudo-RTC"
445 + ---help---
446 + Say Y here if you want support for the device that alleges to be an
447 + RTC in Retu. This will expose a sysfs interface for it.
448 +
449 +config CBUS_RETU_WDT
450 + depends on CBUS_RETU && SYSFS && WATCHDOG
451 + tristate "Support for Retu watchdog timer"
452 + ---help---
453 + Say Y here if you want support for the watchdog in Retu. This will
454 + expose a sysfs interface to grok it.
455 +
456 +config CBUS_RETU_HEADSET
457 + depends on CBUS_RETU && SYSFS
458 + tristate "Support for headset detection with Retu/Vilma"
459 + ---help---
460 + Say Y here if you want support detecting a headset that's connected
461 + to Retu/Vilma. Detection state and events are exposed through
462 + sysfs.
463 +
464 +endmenu
465 --- /dev/null
466 +++ linux-2.6.36-rc7/drivers/cbus/Makefile
467 @@ -0,0 +1,14 @@
468 +#
469 +# Makefile for CBUS.
470 +#
471 +
472 +obj-$(CONFIG_CBUS) += cbus.o
473 +obj-$(CONFIG_CBUS_TAHVO) += tahvo.o
474 +obj-$(CONFIG_CBUS_RETU) += retu.o
475 +obj-$(CONFIG_CBUS_TAHVO_USB) += tahvo-usb.o
476 +obj-$(CONFIG_CBUS_RETU_POWERBUTTON) += retu-pwrbutton.o
477 +obj-$(CONFIG_CBUS_RETU_RTC) += retu-rtc.o
478 +obj-$(CONFIG_CBUS_RETU_WDT) += retu-wdt.o
479 +obj-$(CONFIG_CBUS_TAHVO_USER) += tahvo-user.o
480 +obj-$(CONFIG_CBUS_RETU_USER) += retu-user.o
481 +obj-$(CONFIG_CBUS_RETU_HEADSET) += retu-headset.o
482 --- /dev/null
483 +++ linux-2.6.36-rc7/drivers/cbus/retu.c
484 @@ -0,0 +1,468 @@
485 +/**
486 + * drivers/cbus/retu.c
487 + *
488 + * Support functions for Retu ASIC
489 + *
490 + * Copyright (C) 2004, 2005 Nokia Corporation
491 + *
492 + * Written by Juha Yrjölä <juha.yrjola@nokia.com>,
493 + * David Weinehall <david.weinehall@nokia.com>, and
494 + * Mikko Ylinen <mikko.k.ylinen@nokia.com>
495 + *
496 + * This file is subject to the terms and conditions of the GNU General
497 + * Public License. See the file "COPYING" in the main directory of this
498 + * archive for more details.
499 + *
500 + * This program is distributed in the hope that it will be useful,
501 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
502 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
503 + * GNU General Public License for more details.
504 + *
505 + * You should have received a copy of the GNU General Public License
506 + * along with this program; if not, write to the Free Software
507 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
508 + */
509 +
510 +#include <linux/module.h>
511 +#include <linux/init.h>
512 +
513 +#include <linux/kernel.h>
514 +#include <linux/errno.h>
515 +#include <linux/device.h>
516 +#include <linux/miscdevice.h>
517 +#include <linux/poll.h>
518 +#include <linux/fs.h>
519 +#include <linux/irq.h>
520 +#include <linux/interrupt.h>
521 +#include <linux/platform_device.h>
522 +#include <linux/gpio.h>
523 +
524 +#include <asm/uaccess.h>
525 +#include <asm/mach-types.h>
526 +
527 +#include <plat/mux.h>
528 +#include <plat/board.h>
529 +
530 +#include "cbus.h"
531 +#include "retu.h"
532 +
533 +#define RETU_ID 0x01
534 +#define PFX "retu: "
535 +
536 +static int retu_initialized;
537 +static int retu_irq_pin;
538 +static int retu_is_vilma;
539 +
540 +static struct tasklet_struct retu_tasklet;
541 +spinlock_t retu_lock = SPIN_LOCK_UNLOCKED;
542 +
543 +static struct completion device_release;
544 +
545 +struct retu_irq_handler_desc {
546 + int (*func)(unsigned long);
547 + unsigned long arg;
548 + char name[8];
549 +};
550 +
551 +static struct retu_irq_handler_desc retu_irq_handlers[MAX_RETU_IRQ_HANDLERS];
552 +
553 +/**
554 + * retu_read_reg - Read a value from a register in Retu
555 + * @reg: the register to read from
556 + *
557 + * This function returns the contents of the specified register
558 + */
559 +int retu_read_reg(int reg)
560 +{
561 + BUG_ON(!retu_initialized);
562 + return cbus_read_reg(cbus_host, RETU_ID, reg);
563 +}
564 +
565 +/**
566 + * retu_write_reg - Write a value to a register in Retu
567 + * @reg: the register to write to
568 + * @reg: the value to write to the register
569 + *
570 + * This function writes a value to the specified register
571 + */
572 +void retu_write_reg(int reg, u16 val)
573 +{
574 + BUG_ON(!retu_initialized);
575 + cbus_write_reg(cbus_host, RETU_ID, reg, val);
576 +}
577 +
578 +void retu_set_clear_reg_bits(int reg, u16 set, u16 clear)
579 +{
580 + unsigned long flags;
581 + u16 w;
582 +
583 + spin_lock_irqsave(&retu_lock, flags);
584 + w = retu_read_reg(reg);
585 + w &= ~clear;
586 + w |= set;
587 + retu_write_reg(reg, w);
588 + spin_unlock_irqrestore(&retu_lock, flags);
589 +}
590 +
591 +#define ADC_MAX_CHAN_NUMBER 13
592 +
593 +int retu_read_adc(int channel)
594 +{
595 + unsigned long flags;
596 + int res;
597 +
598 + if (channel < 0 || channel > ADC_MAX_CHAN_NUMBER)
599 + return -EINVAL;
600 +
601 + spin_lock_irqsave(&retu_lock, flags);
602 +
603 + if ((channel == 8) && retu_is_vilma) {
604 + int scr = retu_read_reg(RETU_REG_ADCSCR);
605 + int ch = (retu_read_reg(RETU_REG_ADCR) >> 10) & 0xf;
606 + if (((scr & 0xff) != 0) && (ch != 8))
607 + retu_write_reg (RETU_REG_ADCSCR, (scr & ~0xff));
608 + }
609 +
610 + /* Select the channel and read result */
611 + retu_write_reg(RETU_REG_ADCR, channel << 10);
612 + res = retu_read_reg(RETU_REG_ADCR) & 0x3ff;
613 +
614 + if (retu_is_vilma)
615 + retu_write_reg(RETU_REG_ADCR, (1 << 13));
616 +
617 + /* Unlock retu */
618 + spin_unlock_irqrestore(&retu_lock, flags);
619 +
620 + return res;
621 +}
622 +
623 +
624 +static u16 retu_disable_bogus_irqs(u16 mask)
625 +{
626 + int i;
627 +
628 + for (i = 0; i < MAX_RETU_IRQ_HANDLERS; i++) {
629 + if (mask & (1 << i))
630 + continue;
631 + if (retu_irq_handlers[i].func != NULL)
632 + continue;
633 + /* an IRQ was enabled but we don't have a handler for it */
634 + printk(KERN_INFO PFX "disabling bogus IRQ %d\n", i);
635 + mask |= (1 << i);
636 + }
637 + return mask;
638 +}
639 +
640 +/*
641 + * Disable given RETU interrupt
642 + */
643 +void retu_disable_irq(int id)
644 +{
645 + unsigned long flags;
646 + u16 mask;
647 +
648 + spin_lock_irqsave(&retu_lock, flags);
649 + mask = retu_read_reg(RETU_REG_IMR);
650 + mask |= 1 << id;
651 + mask = retu_disable_bogus_irqs(mask);
652 + retu_write_reg(RETU_REG_IMR, mask);
653 + spin_unlock_irqrestore(&retu_lock, flags);
654 +}
655 +
656 +/*
657 + * Enable given RETU interrupt
658 + */
659 +void retu_enable_irq(int id)
660 +{
661 + unsigned long flags;
662 + u16 mask;
663 +
664 + if (id == 3) {
665 + printk("Enabling Retu IRQ %d\n", id);
666 + dump_stack();
667 + }
668 + spin_lock_irqsave(&retu_lock, flags);
669 + mask = retu_read_reg(RETU_REG_IMR);
670 + mask &= ~(1 << id);
671 + mask = retu_disable_bogus_irqs(mask);
672 + retu_write_reg(RETU_REG_IMR, mask);
673 + spin_unlock_irqrestore(&retu_lock, flags);
674 +}
675 +
676 +/*
677 + * Acknowledge given RETU interrupt
678 + */
679 +void retu_ack_irq(int id)
680 +{
681 + retu_write_reg(RETU_REG_IDR, 1 << id);
682 +}
683 +
684 +/*
685 + * RETU interrupt handler. Only schedules the tasklet.
686 + */
687 +static irqreturn_t retu_irq_handler(int irq, void *dev_id)
688 +{
689 + tasklet_schedule(&retu_tasklet);
690 + return IRQ_HANDLED;
691 +}
692 +
693 +/*
694 + * Tasklet handler
695 + */
696 +static void retu_tasklet_handler(unsigned long data)
697 +{
698 + struct retu_irq_handler_desc *hnd;
699 + u16 id;
700 + u16 im;
701 + int i;
702 +
703 + for (;;) {
704 + id = retu_read_reg(RETU_REG_IDR);
705 + im = ~retu_read_reg(RETU_REG_IMR);
706 + id &= im;
707 +
708 + if (!id)
709 + break;
710 +
711 + for (i = 0; id != 0; i++, id >>= 1) {
712 + if (!(id & 1))
713 + continue;
714 + hnd = &retu_irq_handlers[i];
715 + if (hnd->func == NULL) {
716 + /* Spurious retu interrupt - disable and ack it */
717 + printk(KERN_INFO "Spurious Retu interrupt "
718 + "(id %d)\n", i);
719 + retu_disable_irq(i);
720 + retu_ack_irq(i);
721 + continue;
722 + }
723 + hnd->func(hnd->arg);
724 + /*
725 + * Don't acknowledge the interrupt here
726 + * It must be done explicitly
727 + */
728 + }
729 + }
730 +}
731 +
732 +/*
733 + * Register the handler for a given RETU interrupt source.
734 + */
735 +int retu_request_irq(int id, void *irq_handler, unsigned long arg, char *name)
736 +{
737 + struct retu_irq_handler_desc *hnd;
738 +
739 + if (irq_handler == NULL || id >= MAX_RETU_IRQ_HANDLERS ||
740 + name == NULL) {
741 + printk(KERN_ERR PFX "Invalid arguments to %s\n",
742 + __FUNCTION__);
743 + return -EINVAL;
744 + }
745 + hnd = &retu_irq_handlers[id];
746 + if (hnd->func != NULL) {
747 + printk(KERN_ERR PFX "IRQ %d already reserved\n", id);
748 + return -EBUSY;
749 + }
750 + printk(KERN_INFO PFX "Registering interrupt %d for device %s\n",
751 + id, name);
752 + hnd->func = irq_handler;
753 + hnd->arg = arg;
754 + strlcpy(hnd->name, name, sizeof(hnd->name));
755 +
756 + retu_ack_irq(id);
757 + retu_enable_irq(id);
758 +
759 + return 0;
760 +}
761 +
762 +/*
763 + * Unregister the handler for a given RETU interrupt source.
764 + */
765 +void retu_free_irq(int id)
766 +{
767 + struct retu_irq_handler_desc *hnd;
768 +
769 + if (id >= MAX_RETU_IRQ_HANDLERS) {
770 + printk(KERN_ERR PFX "Invalid argument to %s\n",
771 + __FUNCTION__);
772 + return;
773 + }
774 + hnd = &retu_irq_handlers[id];
775 + if (hnd->func == NULL) {
776 + printk(KERN_ERR PFX "IRQ %d already freed\n", id);
777 + return;
778 + }
779 +
780 + retu_disable_irq(id);
781 + hnd->func = NULL;
782 +}
783 +
784 +/**
785 + * retu_power_off - Shut down power to system
786 + *
787 + * This function puts the system in power off state
788 + */
789 +static void retu_power_off(void)
790 +{
791 + /* Ignore power button state */
792 + retu_write_reg(RETU_REG_CC1, retu_read_reg(RETU_REG_CC1) | 2);
793 + /* Expire watchdog immediately */
794 + retu_write_reg(RETU_REG_WATCHDOG, 0);
795 + /* Wait for poweroff*/
796 + for (;;);
797 +}
798 +
799 +/**
800 + * retu_probe - Probe for Retu ASIC
801 + * @dev: the Retu device
802 + *
803 + * Probe for the Retu ASIC and allocate memory
804 + * for its device-struct if found
805 + */
806 +static int __devinit retu_probe(struct device *dev)
807 +{
808 + int rev, ret;
809 +
810 + /* Prepare tasklet */
811 + tasklet_init(&retu_tasklet, retu_tasklet_handler, 0);
812 +
813 + /* REVISIT: Pass these from board-*.c files in platform_data */
814 + if (machine_is_nokia770()) {
815 + retu_irq_pin = 62;
816 + } else if (machine_is_nokia_n800() || machine_is_nokia_n810() ||
817 + machine_is_nokia_n810_wimax()) {
818 + retu_irq_pin = 108;
819 + } else {
820 + printk(KERN_ERR "cbus: Unsupported board for tahvo\n");
821 + return -ENODEV;
822 + }
823 +
824 + if ((ret = gpio_request(retu_irq_pin, "RETU irq")) < 0) {
825 + printk(KERN_ERR PFX "Unable to reserve IRQ GPIO\n");
826 + return ret;
827 + }
828 +
829 + /* Set the pin as input */
830 + gpio_direction_input(retu_irq_pin);
831 +
832 + /* Rising edge triggers the IRQ */
833 + set_irq_type(gpio_to_irq(retu_irq_pin), IRQ_TYPE_EDGE_RISING);
834 +
835 + retu_initialized = 1;
836 +
837 + rev = retu_read_reg(RETU_REG_ASICR) & 0xff;
838 + if (rev & (1 << 7))
839 + retu_is_vilma = 1;
840 +
841 + printk(KERN_INFO "%s v%d.%d found\n", retu_is_vilma ? "Vilma" : "Retu",
842 + (rev >> 4) & 0x07, rev & 0x0f);
843 +
844 + /* Mask all RETU interrupts */
845 + retu_write_reg(RETU_REG_IMR, 0xffff);
846 +
847 + ret = request_irq(gpio_to_irq(retu_irq_pin), retu_irq_handler, 0,
848 + "retu", 0);
849 + if (ret < 0) {
850 + printk(KERN_ERR PFX "Unable to register IRQ handler\n");
851 + gpio_free(retu_irq_pin);
852 + return ret;
853 + }
854 + set_irq_wake(gpio_to_irq(retu_irq_pin), 1);
855 +
856 + /* Register power off function */
857 + pm_power_off = retu_power_off;
858 +
859 +#ifdef CONFIG_CBUS_RETU_USER
860 + /* Initialize user-space interface */
861 + if (retu_user_init() < 0) {
862 + printk(KERN_ERR "Unable to initialize driver\n");
863 + free_irq(gpio_to_irq(retu_irq_pin), 0);
864 + gpio_free(retu_irq_pin);
865 + return ret;
866 + }
867 +#endif
868 +
869 + return 0;
870 +}
871 +
872 +static int retu_remove(struct device *dev)
873 +{
874 +#ifdef CONFIG_CBUS_RETU_USER
875 + retu_user_cleanup();
876 +#endif
877 + /* Mask all RETU interrupts */
878 + retu_write_reg(RETU_REG_IMR, 0xffff);
879 + free_irq(gpio_to_irq(retu_irq_pin), 0);
880 + gpio_free(retu_irq_pin);
881 + tasklet_kill(&retu_tasklet);
882 +
883 + return 0;
884 +}
885 +
886 +static void retu_device_release(struct device *dev)
887 +{
888 + complete(&device_release);
889 +}
890 +
891 +static struct device_driver retu_driver = {
892 + .name = "retu",
893 + .bus = &platform_bus_type,
894 + .probe = retu_probe,
895 + .remove = retu_remove,
896 +};
897 +
898 +static struct platform_device retu_device = {
899 + .name = "retu",
900 + .id = -1,
901 + .dev = {
902 + .release = retu_device_release,
903 + }
904 +};
905 +
906 +/**
907 + * retu_init - initialise Retu driver
908 + *
909 + * Initialise the Retu driver and return 0 if everything worked ok
910 + */
911 +static int __init retu_init(void)
912 +{
913 + int ret = 0;
914 +
915 + printk(KERN_INFO "Retu/Vilma driver initialising\n");
916 +
917 + init_completion(&device_release);
918 +
919 + if ((ret = driver_register(&retu_driver)) < 0)
920 + return ret;
921 +
922 + if ((ret = platform_device_register(&retu_device)) < 0) {
923 + driver_unregister(&retu_driver);
924 + return ret;
925 + }
926 + return 0;
927 +}
928 +
929 +/*
930 + * Cleanup
931 + */
932 +static void __exit retu_exit(void)
933 +{
934 + platform_device_unregister(&retu_device);
935 + driver_unregister(&retu_driver);
936 + wait_for_completion(&device_release);
937 +}
938 +
939 +EXPORT_SYMBOL(retu_request_irq);
940 +EXPORT_SYMBOL(retu_free_irq);
941 +EXPORT_SYMBOL(retu_enable_irq);
942 +EXPORT_SYMBOL(retu_disable_irq);
943 +EXPORT_SYMBOL(retu_ack_irq);
944 +EXPORT_SYMBOL(retu_read_reg);
945 +EXPORT_SYMBOL(retu_write_reg);
946 +
947 +subsys_initcall(retu_init);
948 +module_exit(retu_exit);
949 +
950 +MODULE_DESCRIPTION("Retu ASIC control");
951 +MODULE_LICENSE("GPL");
952 +MODULE_AUTHOR("Juha Yrjölä, David Weinehall, and Mikko Ylinen");
953 --- /dev/null
954 +++ linux-2.6.36-rc7/drivers/cbus/retu.h
955 @@ -0,0 +1,77 @@
956 +/**
957 + * drivers/cbus/retu.h
958 + *
959 + * Copyright (C) 2004, 2005 Nokia Corporation
960 + *
961 + * Written by Juha Yrjölä <juha.yrjola@nokia.com> and
962 + * David Weinehall <david.weinehall@nokia.com>
963 + *
964 + * This file is subject to the terms and conditions of the GNU General
965 + * Public License. See the file "COPYING" in the main directory of this
966 + * archive for more details.
967 + *
968 + * This program is distributed in the hope that it will be useful,
969 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
970 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
971 + * GNU General Public License for more details.
972 +
973 + * You should have received a copy of the GNU General Public License
974 + * along with this program; if not, write to the Free Software
975 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
976 + */
977 +
978 +#ifndef __DRIVERS_CBUS_RETU_H
979 +#define __DRIVERS_CBUS_RETU_H
980 +
981 +#include <linux/types.h>
982 +
983 +/* Registers */
984 +#define RETU_REG_ASICR 0x00 /* ASIC ID & revision */
985 +#define RETU_REG_IDR 0x01 /* Interrupt ID */
986 +#define RETU_REG_IMR 0x02 /* Interrupt mask */
987 +#define RETU_REG_RTCDSR 0x03 /* RTC seconds register */
988 +#define RETU_REG_RTCHMR 0x04 /* RTC hours and minutes register */
989 +#define RETU_REG_RTCHMAR 0x05 /* RTC hours and minutes alarm and time set register */
990 +#define RETU_REG_RTCCALR 0x06 /* RTC calibration register */
991 +#define RETU_REG_ADCR 0x08 /* ADC result */
992 +#define RETU_REG_ADCSCR 0x09 /* ADC sample ctrl */
993 +#define RETU_REG_CC1 0x0d /* Common control register 1 */
994 +#define RETU_REG_CC2 0x0e /* Common control register 2 */
995 +#define RETU_REG_CTRL_CLR 0x0f /* Regulator clear register */
996 +#define RETU_REG_CTRL_SET 0x10 /* Regulator set register */
997 +#define RETU_REG_STATUS 0x16 /* Status register */
998 +#define RETU_REG_WATCHDOG 0x17 /* Watchdog register */
999 +#define RETU_REG_AUDTXR 0x18 /* Audio Codec Tx register */
1000 +#define RETU_REG_MAX 0x1f
1001 +
1002 +/* Interrupt sources */
1003 +#define RETU_INT_PWR 0
1004 +#define RETU_INT_CHAR 1
1005 +#define RETU_INT_RTCS 2
1006 +#define RETU_INT_RTCM 3
1007 +#define RETU_INT_RTCD 4
1008 +#define RETU_INT_RTCA 5
1009 +#define RETU_INT_HOOK 6
1010 +#define RETU_INT_HEAD 7
1011 +#define RETU_INT_ADCS 8
1012 +
1013 +#define MAX_RETU_IRQ_HANDLERS 16
1014 +
1015 +int retu_read_reg(int reg);
1016 +void retu_write_reg(int reg, u16 val);
1017 +void retu_set_clear_reg_bits(int reg, u16 set, u16 clear);
1018 +int retu_read_adc(int channel);
1019 +int retu_request_irq(int id, void *irq_handler, unsigned long arg, char *name);
1020 +void retu_free_irq(int id);
1021 +void retu_enable_irq(int id);
1022 +void retu_disable_irq(int id);
1023 +void retu_ack_irq(int id);
1024 +
1025 +#ifdef CONFIG_CBUS_RETU_USER
1026 +int retu_user_init(void);
1027 +void retu_user_cleanup(void);
1028 +#endif
1029 +
1030 +extern spinlock_t retu_lock;
1031 +
1032 +#endif /* __DRIVERS_CBUS_RETU_H */
1033 --- /dev/null
1034 +++ linux-2.6.36-rc7/drivers/cbus/retu-headset.c
1035 @@ -0,0 +1,356 @@
1036 +/**
1037 + * Retu/Vilma headset detection
1038 + *
1039 + * Copyright (C) 2006 Nokia Corporation
1040 + *
1041 + * Written by Juha Yrjölä
1042 + *
1043 + * This file is subject to the terms and conditions of the GNU General
1044 + * Public License. See the file "COPYING" in the main directory of this
1045 + * archive for more details.
1046 + *
1047 + * This program is distributed in the hope that it will be useful,
1048 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1049 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1050 + * GNU General Public License for more details.
1051 + *
1052 + * You should have received a copy of the GNU General Public License
1053 + * along with this program; if not, write to the Free Software
1054 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1055 + */
1056 +
1057 +#include <linux/module.h>
1058 +#include <linux/init.h>
1059 +#include <linux/kernel.h>
1060 +#include <linux/delay.h>
1061 +#include <linux/input.h>
1062 +#include <linux/platform_device.h>
1063 +#include <linux/slab.h>
1064 +
1065 +#include "retu.h"
1066 +
1067 +#define RETU_ADC_CHANNEL_HOOKDET 0x05
1068 +
1069 +#define RETU_HEADSET_KEY KEY_PHONE
1070 +
1071 +struct retu_headset {
1072 + spinlock_t lock;
1073 + struct mutex mutex;
1074 + struct platform_device *pdev;
1075 + struct input_dev *idev;
1076 + unsigned bias_enabled;
1077 + unsigned detection_enabled;
1078 + unsigned pressed;
1079 + struct timer_list enable_timer;
1080 + struct timer_list detect_timer;
1081 +};
1082 +
1083 +static void retu_headset_set_bias(int enable)
1084 +{
1085 + if (enable) {
1086 + retu_set_clear_reg_bits(RETU_REG_AUDTXR,
1087 + (1 << 0) | (1 << 1), 0);
1088 + msleep(2);
1089 + retu_set_clear_reg_bits(RETU_REG_AUDTXR, 1 << 3, 0);
1090 + } else {
1091 + retu_set_clear_reg_bits(RETU_REG_AUDTXR, 0,
1092 + (1 << 0) | (1 << 1) | (1 << 3));
1093 + }
1094 +}
1095 +
1096 +static void retu_headset_enable(struct retu_headset *hs)
1097 +{
1098 + mutex_lock(&hs->mutex);
1099 + if (!hs->bias_enabled) {
1100 + hs->bias_enabled = 1;
1101 + retu_headset_set_bias(1);
1102 + }
1103 + mutex_unlock(&hs->mutex);
1104 +}
1105 +
1106 +static void retu_headset_disable(struct retu_headset *hs)
1107 +{
1108 + mutex_lock(&hs->mutex);
1109 + if (hs->bias_enabled) {
1110 + hs->bias_enabled = 0;
1111 + retu_headset_set_bias(0);
1112 + }
1113 + mutex_unlock(&hs->mutex);
1114 +}
1115 +
1116 +static void retu_headset_det_enable(struct retu_headset *hs)
1117 +{
1118 + mutex_lock(&hs->mutex);
1119 + if (!hs->detection_enabled) {
1120 + hs->detection_enabled = 1;
1121 + retu_set_clear_reg_bits(RETU_REG_CC1, (1 << 10) | (1 << 8), 0);
1122 + retu_enable_irq(RETU_INT_HOOK);
1123 + }
1124 + mutex_unlock(&hs->mutex);
1125 +}
1126 +
1127 +static void retu_headset_det_disable(struct retu_headset *hs)
1128 +{
1129 + unsigned long flags;
1130 +
1131 + mutex_lock(&hs->mutex);
1132 + if (hs->detection_enabled) {
1133 + hs->detection_enabled = 0;
1134 + retu_disable_irq(RETU_INT_HOOK);
1135 + del_timer_sync(&hs->enable_timer);
1136 + del_timer_sync(&hs->detect_timer);
1137 + spin_lock_irqsave(&hs->lock, flags);
1138 + if (hs->pressed)
1139 + input_report_key(hs->idev, RETU_HEADSET_KEY, 0);
1140 + spin_unlock_irqrestore(&hs->lock, flags);
1141 + retu_set_clear_reg_bits(RETU_REG_CC1, 0, (1 << 10) | (1 << 8));
1142 + }
1143 + mutex_unlock(&hs->mutex);
1144 +}
1145 +
1146 +static ssize_t retu_headset_hookdet_show(struct device *dev,
1147 + struct device_attribute *attr,
1148 + char *buf)
1149 +{
1150 + int val;
1151 +
1152 + val = retu_read_adc(RETU_ADC_CHANNEL_HOOKDET);
1153 + return sprintf(buf, "%d\n", val);
1154 +}
1155 +
1156 +static DEVICE_ATTR(hookdet, S_IRUGO, retu_headset_hookdet_show, NULL);
1157 +
1158 +static ssize_t retu_headset_enable_show(struct device *dev,
1159 + struct device_attribute *attr,
1160 + char *buf)
1161 +{
1162 + struct retu_headset *hs = dev_get_drvdata(dev);
1163 +
1164 + return sprintf(buf, "%u\n", hs->bias_enabled);
1165 +}
1166 +
1167 +static ssize_t retu_headset_enable_store(struct device *dev,
1168 + struct device_attribute *attr,
1169 + const char *buf, size_t count)
1170 +{
1171 + struct retu_headset *hs = dev_get_drvdata(dev);
1172 + int enable;
1173 +
1174 + if (sscanf(buf, "%u", &enable) != 1)
1175 + return -EINVAL;
1176 + if (enable)
1177 + retu_headset_enable(hs);
1178 + else
1179 + retu_headset_disable(hs);
1180 + return count;
1181 +}
1182 +
1183 +static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR | S_IWGRP,
1184 + retu_headset_enable_show, retu_headset_enable_store);
1185 +
1186 +static ssize_t retu_headset_enable_det_show(struct device *dev,
1187 + struct device_attribute *attr,
1188 + char *buf)
1189 +{
1190 + struct retu_headset *hs = dev_get_drvdata(dev);
1191 +
1192 + return sprintf(buf, "%u\n", hs->detection_enabled);
1193 +}
1194 +
1195 +static ssize_t retu_headset_enable_det_store(struct device *dev,
1196 + struct device_attribute *attr,
1197 + const char *buf, size_t count)
1198 +{
1199 + struct retu_headset *hs = dev_get_drvdata(dev);
1200 + int enable;
1201 +
1202 + if (sscanf(buf, "%u", &enable) != 1)
1203 + return -EINVAL;
1204 + if (enable)
1205 + retu_headset_det_enable(hs);
1206 + else
1207 + retu_headset_det_disable(hs);
1208 + return count;
1209 +}
1210 +
1211 +static DEVICE_ATTR(enable_det, S_IRUGO | S_IWUSR | S_IWGRP,
1212 + retu_headset_enable_det_show,
1213 + retu_headset_enable_det_store);
1214 +
1215 +static void retu_headset_hook_interrupt(unsigned long arg)
1216 +{
1217 + struct retu_headset *hs = (struct retu_headset *) arg;
1218 + unsigned long flags;
1219 +
1220 + retu_ack_irq(RETU_INT_HOOK);
1221 + spin_lock_irqsave(&hs->lock, flags);
1222 + if (!hs->pressed) {
1223 + /* Headset button was just pressed down. */
1224 + hs->pressed = 1;
1225 + input_report_key(hs->idev, RETU_HEADSET_KEY, 1);
1226 + }
1227 + spin_unlock_irqrestore(&hs->lock, flags);
1228 + retu_set_clear_reg_bits(RETU_REG_CC1, 0, (1 << 10) | (1 << 8));
1229 + mod_timer(&hs->enable_timer, jiffies + msecs_to_jiffies(50));
1230 +}
1231 +
1232 +static void retu_headset_enable_timer(unsigned long arg)
1233 +{
1234 + struct retu_headset *hs = (struct retu_headset *) arg;
1235 +
1236 + retu_set_clear_reg_bits(RETU_REG_CC1, (1 << 10) | (1 << 8), 0);
1237 + mod_timer(&hs->detect_timer, jiffies + msecs_to_jiffies(350));
1238 +}
1239 +
1240 +static void retu_headset_detect_timer(unsigned long arg)
1241 +{
1242 + struct retu_headset *hs = (struct retu_headset *) arg;
1243 + unsigned long flags;
1244 +
1245 + spin_lock_irqsave(&hs->lock, flags);
1246 + if (hs->pressed) {
1247 + hs->pressed = 0;
1248 + input_report_key(hs->idev, RETU_HEADSET_KEY, 0);
1249 + }
1250 + spin_unlock_irqrestore(&hs->lock, flags);
1251 +}
1252 +
1253 +static int __init retu_headset_probe(struct platform_device *pdev)
1254 +{
1255 + struct retu_headset *hs;
1256 + int r;
1257 +
1258 + hs = kzalloc(sizeof(*hs), GFP_KERNEL);
1259 + if (hs == NULL)
1260 + return -ENOMEM;
1261 +
1262 + hs->pdev = pdev;
1263 +
1264 + hs->idev = input_allocate_device();
1265 + if (hs->idev == NULL) {
1266 + r = -ENOMEM;
1267 + goto err1;
1268 + }
1269 + hs->idev->name = "retu-headset";
1270 + hs->idev->dev.parent = &pdev->dev;
1271 + set_bit(EV_KEY, hs->idev->evbit);
1272 + set_bit(RETU_HEADSET_KEY, hs->idev->keybit);
1273 + r = input_register_device(hs->idev);
1274 + if (r < 0)
1275 + goto err2;
1276 +
1277 + r = device_create_file(&pdev->dev, &dev_attr_hookdet);
1278 + if (r < 0)
1279 + goto err3;
1280 + r = device_create_file(&pdev->dev, &dev_attr_enable);
1281 + if (r < 0)
1282 + goto err4;
1283 + r = device_create_file(&pdev->dev, &dev_attr_enable_det);
1284 + if (r < 0)
1285 + goto err5;
1286 + platform_set_drvdata(pdev, hs);
1287 +
1288 + spin_lock_init(&hs->lock);
1289 + mutex_init(&hs->mutex);
1290 + setup_timer(&hs->enable_timer, retu_headset_enable_timer,
1291 + (unsigned long) hs);
1292 + setup_timer(&hs->detect_timer, retu_headset_detect_timer,
1293 + (unsigned long) hs);
1294 +
1295 + r = retu_request_irq(RETU_INT_HOOK, retu_headset_hook_interrupt,
1296 + (unsigned long) hs, "hookdet");
1297 + if (r != 0) {
1298 + dev_err(&pdev->dev, "hookdet IRQ not available\n");
1299 + goto err6;
1300 + }
1301 + retu_disable_irq(RETU_INT_HOOK);
1302 + return 0;
1303 +err6:
1304 + device_remove_file(&pdev->dev, &dev_attr_enable_det);
1305 +err5:
1306 + device_remove_file(&pdev->dev, &dev_attr_enable);
1307 +err4:
1308 + device_remove_file(&pdev->dev, &dev_attr_hookdet);
1309 +err3:
1310 + input_unregister_device(hs->idev);
1311 +err2:
1312 + input_free_device(hs->idev);
1313 +err1:
1314 + kfree(hs);
1315 + return r;
1316 +}
1317 +
1318 +static int retu_headset_remove(struct platform_device *pdev)
1319 +{
1320 + struct retu_headset *hs = platform_get_drvdata(pdev);
1321 +
1322 + device_remove_file(&pdev->dev, &dev_attr_hookdet);
1323 + device_remove_file(&pdev->dev, &dev_attr_enable);
1324 + device_remove_file(&pdev->dev, &dev_attr_enable_det);
1325 + retu_headset_disable(hs);
1326 + retu_headset_det_disable(hs);
1327 + retu_free_irq(RETU_INT_HOOK);
1328 + input_unregister_device(hs->idev);
1329 + input_free_device(hs->idev);
1330 + return 0;
1331 +}
1332 +
1333 +static int retu_headset_suspend(struct platform_device *pdev,
1334 + pm_message_t mesg)
1335 +{
1336 + struct retu_headset *hs = platform_get_drvdata(pdev);
1337 +
1338 + mutex_lock(&hs->mutex);
1339 + if (hs->bias_enabled)
1340 + retu_headset_set_bias(0);
1341 + mutex_unlock(&hs->mutex);
1342 +
1343 + return 0;
1344 +}
1345 +
1346 +static int retu_headset_resume(struct platform_device *pdev)
1347 +{
1348 + struct retu_headset *hs = platform_get_drvdata(pdev);
1349 +
1350 + mutex_lock(&hs->mutex);
1351 + if (hs->bias_enabled)
1352 + retu_headset_set_bias(1);
1353 + mutex_unlock(&hs->mutex);
1354 +
1355 + return 0;
1356 +}
1357 +
1358 +static struct platform_driver retu_headset_driver = {
1359 + .probe = retu_headset_probe,
1360 + .remove = retu_headset_remove,
1361 + .suspend = retu_headset_suspend,
1362 + .resume = retu_headset_resume,
1363 + .driver = {
1364 + .name = "retu-headset",
1365 + },
1366 +};
1367 +
1368 +static int __init retu_headset_init(void)
1369 +{
1370 + int r;
1371 +
1372 + printk(KERN_INFO "Retu/Vilma headset driver initializing\n");
1373 +
1374 + r = platform_driver_register(&retu_headset_driver);
1375 + if (r < 0)
1376 + return r;
1377 +
1378 + return 0;
1379 +}
1380 +
1381 +static void __exit retu_headset_exit(void)
1382 +{
1383 + platform_driver_unregister(&retu_headset_driver);
1384 +}
1385 +
1386 +module_init(retu_headset_init);
1387 +module_exit(retu_headset_exit);
1388 +
1389 +MODULE_DESCRIPTION("Retu/Vilma headset detection");
1390 +MODULE_LICENSE("GPL");
1391 +MODULE_AUTHOR("Juha Yrjölä");
1392 --- /dev/null
1393 +++ linux-2.6.36-rc7/drivers/cbus/retu-pwrbutton.c
1394 @@ -0,0 +1,118 @@
1395 +/**
1396 + * drivers/cbus/retu-pwrbutton.c
1397 + *
1398 + * Driver for sending retu power button event to input-layer
1399 + *
1400 + * Copyright (C) 2004 Nokia Corporation
1401 + *
1402 + * Written by Ari Saastamoinen <ari.saastamoinen@elektrobit.com>
1403 + *
1404 + * Contact Juha Yrjölä <juha.yrjola@nokia.com>
1405 + *
1406 + * This file is subject to the terms and conditions of the GNU General
1407 + * Public License. See the file "COPYING" in the main directory of this
1408 + * archive for more details.
1409 + *
1410 + * This program is distributed in the hope that it will be useful,
1411 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1412 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1413 + * GNU General Public License for more details.
1414 + *
1415 + * You should have received a copy of the GNU General Public License
1416 + * along with this program; if not, write to the Free Software
1417 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1418 + */
1419 +
1420 +#include <linux/module.h>
1421 +#include <linux/init.h>
1422 +#include <linux/kernel.h>
1423 +#include <linux/errno.h>
1424 +#include <linux/input.h>
1425 +#include <linux/timer.h>
1426 +#include <linux/jiffies.h>
1427 +#include <linux/bitops.h>
1428 +
1429 +#include "retu.h"
1430 +
1431 +#define RETU_STATUS_PWRONX (1 << 5)
1432 +
1433 +#define PWRBTN_DELAY 20
1434 +#define PWRBTN_UP 0
1435 +#define PWRBTN_PRESSED 1
1436 +
1437 +static int pwrbtn_state;
1438 +static struct input_dev *pwrbtn_dev;
1439 +static struct timer_list pwrbtn_timer;
1440 +
1441 +static void retubutton_timer_func(unsigned long arg)
1442 +{
1443 + int state;
1444 +
1445 + if (retu_read_reg(RETU_REG_STATUS) & RETU_STATUS_PWRONX)
1446 + state = PWRBTN_UP;
1447 + else
1448 + state = PWRBTN_PRESSED;
1449 +
1450 + if (pwrbtn_state != state) {
1451 + input_report_key(pwrbtn_dev, KEY_POWER, state);
1452 + pwrbtn_state = state;
1453 + }
1454 +}
1455 +
1456 +/**
1457 + * Interrupt function is called whenever power button key is pressed
1458 + * or released.
1459 + */
1460 +static void retubutton_irq(unsigned long arg)
1461 +{
1462 + retu_ack_irq(RETU_INT_PWR);
1463 + mod_timer(&pwrbtn_timer, jiffies + msecs_to_jiffies(PWRBTN_DELAY));
1464 +}
1465 +
1466 +/**
1467 + * Init function.
1468 + * Allocates interrupt for power button and registers itself to input layer.
1469 + */
1470 +static int __init retubutton_init(void)
1471 +{
1472 + int irq;
1473 +
1474 + printk(KERN_INFO "Retu power button driver initialized\n");
1475 + irq = RETU_INT_PWR;
1476 +
1477 + init_timer(&pwrbtn_timer);
1478 + pwrbtn_timer.function = retubutton_timer_func;
1479 +
1480 + if (retu_request_irq(irq, &retubutton_irq, 0, "PwrOnX") < 0) {
1481 + printk(KERN_ERR "%s@%s: Cannot allocate irq\n",
1482 + __FUNCTION__, __FILE__);
1483 + return -EBUSY;
1484 + }
1485 +
1486 + pwrbtn_dev = input_allocate_device();
1487 + if (!pwrbtn_dev)
1488 + return -ENOMEM;
1489 +
1490 + pwrbtn_dev->evbit[0] = BIT_MASK(EV_KEY);
1491 + pwrbtn_dev->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
1492 + pwrbtn_dev->name = "retu-pwrbutton";
1493 +
1494 + return input_register_device(pwrbtn_dev);
1495 +}
1496 +
1497 +/**
1498 + * Cleanup function which is called when driver is unloaded
1499 + */
1500 +static void __exit retubutton_exit(void)
1501 +{
1502 + retu_free_irq(RETU_INT_PWR);
1503 + del_timer_sync(&pwrbtn_timer);
1504 + input_unregister_device(pwrbtn_dev);
1505 +}
1506 +
1507 +module_init(retubutton_init);
1508 +module_exit(retubutton_exit);
1509 +
1510 +MODULE_DESCRIPTION("Retu Power Button");
1511 +MODULE_LICENSE("GPL");
1512 +MODULE_AUTHOR("Ari Saastamoinen");
1513 --- /dev/null
1514 +++ linux-2.6.36-rc7/drivers/cbus/retu-rtc.c
1515 @@ -0,0 +1,477 @@
1516 +/**
1517 + * drivers/cbus/retu-rtc.c
1518 + *
1519 + * Support for Retu RTC
1520 + *
1521 + * Copyright (C) 2004, 2005 Nokia Corporation
1522 + *
1523 + * Written by Paul Mundt <paul.mundt@nokia.com> and
1524 + * Igor Stoppa <igor.stoppa@nokia.com>
1525 + *
1526 + * The Retu RTC is essentially a partial read-only RTC that gives us Retu's
1527 + * idea of what time actually is. It's left as a userspace excercise to map
1528 + * this back to time in the real world and ensure that calibration settings
1529 + * are sane to compensate for any horrible drift (on account of not being able
1530 + * to set the clock to anything).
1531 + *
1532 + * Days are semi-writeable. Namely, Retu will only track 255 days for us
1533 + * consecutively, after which the counter is explicitly stuck at 255 until
1534 + * someone comes along and clears it with a write. In the event that no one
1535 + * comes along and clears it, we no longer have any idea what day it is.
1536 + *
1537 + * This file is subject to the terms and conditions of the GNU General
1538 + * Public License. See the file "COPYING" in the main directory of this
1539 + * archive for more details.
1540 + *
1541 + * This program is distributed in the hope that it will be useful,
1542 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1543 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1544 + * GNU General Public License for more details.
1545 + *
1546 + * You should have received a copy of the GNU General Public License
1547 + * along with this program; if not, write to the Free Software
1548 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1549 + */
1550 +
1551 +#include <linux/device.h>
1552 +#include <linux/init.h>
1553 +#include <linux/kernel.h>
1554 +#include <linux/module.h>
1555 +#include <linux/completion.h>
1556 +#include <linux/platform_device.h>
1557 +#include <linux/mutex.h>
1558 +#include <linux/workqueue.h>
1559 +
1560 +#include "cbus.h"
1561 +#include "retu.h"
1562 +
1563 +static struct mutex retu_rtc_mutex;
1564 +static u16 retu_rtc_alarm_expired;
1565 +static u16 retu_rtc_reset_occurred;
1566 +
1567 +static DECLARE_COMPLETION(retu_rtc_exited);
1568 +static DECLARE_COMPLETION(retu_rtc_sync);
1569 +
1570 +static void retu_rtc_barrier(void);
1571 +
1572 +static void retu_rtc_device_release(struct device *dev)
1573 +{
1574 + complete(&retu_rtc_exited);
1575 +}
1576 +
1577 +static ssize_t retu_rtc_time_show(struct device *dev, struct device_attribute *attr,
1578 + char *buf)
1579 +{
1580 + u16 dsr, hmr, dsr2;
1581 +
1582 + mutex_lock(&retu_rtc_mutex);
1583 +
1584 + do {
1585 + u16 dummy;
1586 +
1587 + /*
1588 + * Not being in_interrupt() for a retu rtc IRQ, we need to
1589 + * read twice for consistency..
1590 + */
1591 + dummy = retu_read_reg(RETU_REG_RTCDSR);
1592 + dsr = retu_read_reg(RETU_REG_RTCDSR);
1593 +
1594 + dummy = retu_read_reg(RETU_REG_RTCHMR);
1595 + hmr = retu_read_reg(RETU_REG_RTCHMR);
1596 +
1597 + dummy = retu_read_reg(RETU_REG_RTCDSR);
1598 + dsr2 = retu_read_reg(RETU_REG_RTCDSR);
1599 + } while ((dsr != dsr2));
1600 +
1601 + mutex_unlock(&retu_rtc_mutex);
1602 +
1603 + /*
1604 + * Format a 32-bit date-string for userspace
1605 + *
1606 + * days | hours | minutes | seconds
1607 + *
1608 + * 8 bits for each.
1609 + *
1610 + * This mostly sucks because days and seconds are tracked in RTCDSR
1611 + * while hours and minutes are tracked in RTCHMR. And yes, there
1612 + * really are no words that can describe an 8 bit day register (or
1613 + * rather, none that will be reprinted here).
1614 + */
1615 + return sprintf(buf, "0x%08x\n", (((dsr >> 8) & 0xff) << 24) |
1616 + (((hmr >> 8) & 0x1f) << 16) |
1617 + ((hmr & 0x3f) << 8) | (dsr & 0x3f));
1618 +}
1619 +
1620 +static ssize_t retu_rtc_time_store(struct device *dev, struct device_attribute *attr,
1621 + const char *buf, size_t count)
1622 +{
1623 + mutex_lock(&retu_rtc_mutex);
1624 + /*
1625 + * Writing anything to the day counter forces it to 0
1626 + * The seconds counter would be cleared by resetting the minutes counter,
1627 + * however this won't happen, since we are using the hh:mm counters as
1628 + * a set of free running counters and the day counter as a multiple
1629 + * overflow holder.
1630 + */
1631 +
1632 + /* Reset day counter, but keep Temperature Shutdown state */
1633 + retu_write_reg(RETU_REG_RTCDSR,
1634 + retu_read_reg(RETU_REG_RTCDSR) & (1 << 6));
1635 +
1636 + mutex_unlock(&retu_rtc_mutex);
1637 +
1638 + return count;
1639 +}
1640 +
1641 +static DEVICE_ATTR(time, S_IRUGO | S_IWUSR, retu_rtc_time_show,
1642 + retu_rtc_time_store);
1643 +
1644 +
1645 +static ssize_t retu_rtc_reset_show(struct device *dev, struct device_attribute *attr, char *buf)
1646 +{
1647 + /*
1648 + * Returns the status of the rtc
1649 + *
1650 + * 0: no reset has occurred or the status has been cleared
1651 + * 1: a reset has occurred
1652 + *
1653 + * RTC needs to be reset only when both main battery
1654 + * _AND_ backup battery are discharged
1655 + */
1656 + return sprintf(buf, "%u\n", retu_rtc_reset_occurred);
1657 +}
1658 +
1659 +static void retu_rtc_do_reset(void)
1660 +{
1661 + u16 ccr1;
1662 +
1663 + ccr1 = retu_read_reg(RETU_REG_CC1);
1664 + /* RTC in reset */
1665 + retu_write_reg(RETU_REG_CC1, ccr1 | 0x0001);
1666 + /* RTC in normal operating mode */
1667 + retu_write_reg(RETU_REG_CC1, ccr1 & ~0x0001);
1668 +
1669 + retu_rtc_barrier();
1670 + /* Disable alarm and RTC WD */
1671 + retu_write_reg(RETU_REG_RTCHMAR, 0x7f3f);
1672 + /* Set Calibration register to default value */
1673 + retu_write_reg(RETU_REG_RTCCALR, 0x00c0);
1674 +
1675 + retu_rtc_alarm_expired = 0;
1676 + retu_rtc_reset_occurred = 1;
1677 +}
1678 +
1679 +static ssize_t retu_rtc_reset_store(struct device *dev, struct device_attribute *attr,
1680 + const char *buf, size_t count)
1681 +{
1682 + unsigned choice;
1683 +
1684 + if(sscanf(buf, "%u", &choice) != 1)
1685 + return count;
1686 + mutex_lock(&retu_rtc_mutex);
1687 + if (choice == 0)
1688 + retu_rtc_reset_occurred = 0;
1689 + else if (choice == 1)
1690 + retu_rtc_do_reset();
1691 + mutex_unlock(&retu_rtc_mutex);
1692 + return count;
1693 +}
1694 +
1695 +static DEVICE_ATTR(reset, S_IRUGO | S_IWUSR, retu_rtc_reset_show,
1696 + retu_rtc_reset_store);
1697 +
1698 +static ssize_t retu_rtc_alarm_show(struct device *dev, struct device_attribute *attr,
1699 + char *buf)
1700 +{
1701 + u16 chmar;
1702 + ssize_t retval;
1703 +
1704 + mutex_lock(&retu_rtc_mutex);
1705 + /*
1706 + * Format a 16-bit date-string for userspace
1707 + *
1708 + * hours | minutes
1709 + * 8 bits for each.
1710 + */
1711 + chmar = retu_read_reg(RETU_REG_RTCHMAR);
1712 + /* No shifting needed, only masking unrelated bits */
1713 + retval = sprintf(buf, "0x%04x\n", chmar & 0x1f3f);
1714 + mutex_unlock(&retu_rtc_mutex);
1715 +
1716 + return retval;
1717 +}
1718 +
1719 +static ssize_t retu_rtc_alarm_store(struct device *dev, struct device_attribute *attr,
1720 + const char *buf, size_t count)
1721 +{
1722 + u16 chmar;
1723 + unsigned alrm;
1724 + unsigned hours;
1725 + unsigned minutes;
1726 +
1727 + mutex_lock(&retu_rtc_mutex);
1728 +
1729 + if(sscanf(buf, "%x", &alrm) != 1)
1730 + return count;
1731 + hours = (alrm >> 8) & 0x001f;
1732 + minutes = (alrm >> 0) & 0x003f;
1733 + if ((hours < 24 && minutes < 60) || (hours == 24 && minutes == 60)) {
1734 + /*
1735 + * OK, the time format for the alarm is valid (including the
1736 + * disabling values)
1737 + */
1738 + /* Keeps the RTC watchdog status */
1739 + chmar = retu_read_reg(RETU_REG_RTCHMAR) & 0x6000;
1740 + chmar |= alrm & 0x1f3f; /* Stores the requested alarm */
1741 + retu_rtc_barrier();
1742 + retu_write_reg(RETU_REG_RTCHMAR, chmar);
1743 + /* If the alarm is being disabled */
1744 + if (hours == 24 && minutes == 60) {
1745 + /* disable the interrupt */
1746 + retu_disable_irq(RETU_INT_RTCA);
1747 + retu_rtc_alarm_expired = 0;
1748 + } else
1749 + /* enable the interrupt */
1750 + retu_enable_irq(RETU_INT_RTCA);
1751 + }
1752 + mutex_unlock(&retu_rtc_mutex);
1753 +
1754 + return count;
1755 +}
1756 +
1757 +static DEVICE_ATTR(alarm, S_IRUGO | S_IWUSR, retu_rtc_alarm_show,
1758 + retu_rtc_alarm_store);
1759 +
1760 +static ssize_t retu_rtc_alarm_expired_show(struct device *dev, struct device_attribute *attr,
1761 + char *buf)
1762 +{
1763 + ssize_t retval;
1764 +
1765 + retval = sprintf(buf, "%u\n", retu_rtc_alarm_expired);
1766 +
1767 + return retval;
1768 +}
1769 +
1770 +static ssize_t retu_rtc_alarm_expired_store(struct device *dev, struct device_attribute *attr,
1771 + const char *buf, size_t count)
1772 +{
1773 + retu_rtc_alarm_expired = 0;
1774 +
1775 + return count;
1776 +}
1777 +
1778 +static DEVICE_ATTR(alarm_expired, S_IRUGO | S_IWUSR, retu_rtc_alarm_expired_show,
1779 + retu_rtc_alarm_expired_store);
1780 +
1781 +
1782 +static ssize_t retu_rtc_cal_show(struct device *dev, struct device_attribute *attr,
1783 + char *buf)
1784 +{
1785 + u16 rtccalr1;
1786 +
1787 + mutex_lock(&retu_rtc_mutex);
1788 + rtccalr1 = retu_read_reg(RETU_REG_RTCCALR);
1789 + mutex_unlock(&retu_rtc_mutex);
1790 +
1791 + /*
1792 + * Shows the status of the Calibration Register.
1793 + *
1794 + * Default, after power loss: 0x0000
1795 + * Default, for R&D: 0x00C0
1796 + * Default, for factory: 0x00??
1797 + *
1798 + */
1799 + return sprintf(buf, "0x%04x\n", rtccalr1 & 0x00ff);
1800 +}
1801 +
1802 +static ssize_t retu_rtc_cal_store(struct device *dev, struct device_attribute *attr,
1803 + const char *buf, size_t count)
1804 +{
1805 + unsigned calibration_value;
1806 +
1807 + if (sscanf(buf, "%x", &calibration_value) != 1)
1808 + return count;
1809 +
1810 + mutex_lock(&retu_rtc_mutex);
1811 + retu_rtc_barrier();
1812 + retu_write_reg(RETU_REG_RTCCALR, calibration_value & 0x00ff);
1813 + mutex_unlock(&retu_rtc_mutex);
1814 +
1815 + return count;
1816 +}
1817 +
1818 +static DEVICE_ATTR(cal, S_IRUGO | S_IWUSR, retu_rtc_cal_show,
1819 + retu_rtc_cal_store);
1820 +
1821 +static struct platform_device retu_rtc_device;
1822 +
1823 +static void retu_rtca_disable(void)
1824 +{
1825 + retu_disable_irq(RETU_INT_RTCA);
1826 + retu_rtc_alarm_expired = 1;
1827 + retu_rtc_barrier();
1828 + retu_write_reg(RETU_REG_RTCHMAR, (24 << 8) | 60);
1829 +}
1830 +
1831 +static void retu_rtca_expired(struct work_struct *unused)
1832 +{
1833 + retu_rtca_disable();
1834 + sysfs_notify(&retu_rtc_device.dev.kobj, NULL, "alarm_expired");
1835 +}
1836 +
1837 +DECLARE_WORK(retu_rtca_work, retu_rtca_expired);
1838 +
1839 +/*
1840 + * RTCHMR RTCHMAR RTCCAL must be accessed within 0.9 s since the seconds
1841 + * interrupt has been signaled in the IDR register
1842 + */
1843 +static void retu_rtcs_interrupt(unsigned long unused)
1844 +{
1845 + retu_ack_irq(RETU_INT_RTCS);
1846 + complete_all(&retu_rtc_sync);
1847 +}
1848 +
1849 +static void retu_rtca_interrupt(unsigned long unused)
1850 +{
1851 + retu_ack_irq(RETU_INT_RTCA);
1852 + schedule_work(&retu_rtca_work);
1853 +}
1854 +
1855 +static int retu_rtc_init_irq(void)
1856 +{
1857 + int ret;
1858 +
1859 + ret = retu_request_irq(RETU_INT_RTCS, retu_rtcs_interrupt, 0, "RTCS");
1860 + if (ret != 0)
1861 + return ret;
1862 + /*
1863 + * We will take care of enabling and disabling the interrupt
1864 + * elsewhere, so leave it off by default..
1865 + */
1866 + retu_disable_irq(RETU_INT_RTCS);
1867 +
1868 + ret = retu_request_irq(RETU_INT_RTCA, retu_rtca_interrupt, 0, "RTCA");
1869 + if (ret != 0) {
1870 + retu_free_irq(RETU_INT_RTCS);
1871 + return ret;
1872 + }
1873 + retu_disable_irq(RETU_INT_RTCA);
1874 +
1875 + return 0;
1876 +}
1877 +
1878 +
1879 +static int __devinit retu_rtc_probe(struct device *dev)
1880 +{
1881 + int r;
1882 +
1883 + retu_rtc_alarm_expired = retu_read_reg(RETU_REG_IDR) &
1884 + (0x1 << RETU_INT_RTCA);
1885 +
1886 + if ((r = retu_rtc_init_irq()) != 0)
1887 + return r;
1888 +
1889 + mutex_init(&retu_rtc_mutex);
1890 +
1891 + /* If the calibration register is zero, we've probably lost
1892 + * power */
1893 + if (retu_read_reg(RETU_REG_RTCCALR) & 0x00ff)
1894 + retu_rtc_reset_occurred = 0;
1895 + else
1896 + retu_rtc_do_reset();
1897 +
1898 + if ((r = device_create_file(dev, &dev_attr_time)) != 0)
1899 + return r;
1900 + else if ((r = device_create_file(dev, &dev_attr_reset)) != 0)
1901 + goto err_unregister_time;
1902 + else if ((r = device_create_file(dev, &dev_attr_alarm)) != 0)
1903 + goto err_unregister_reset;
1904 + else if ((r = device_create_file(dev, &dev_attr_alarm_expired)) != 0)
1905 + goto err_unregister_alarm;
1906 + else if ((r = device_create_file(dev, &dev_attr_cal)) != 0)
1907 + goto err_unregister_alarm_expired;
1908 + else
1909 + return r;
1910 +
1911 +err_unregister_alarm_expired:
1912 + device_remove_file(dev, &dev_attr_alarm_expired);
1913 +err_unregister_alarm:
1914 + device_remove_file(dev, &dev_attr_alarm);
1915 +err_unregister_reset:
1916 + device_remove_file(dev, &dev_attr_reset);
1917 +err_unregister_time:
1918 + device_remove_file(dev, &dev_attr_time);
1919 + return r;
1920 +}
1921 +
1922 +static int __devexit retu_rtc_remove(struct device *dev)
1923 +{
1924 + retu_disable_irq(RETU_INT_RTCS);
1925 + retu_free_irq(RETU_INT_RTCS);
1926 + retu_free_irq(RETU_INT_RTCA);
1927 + device_remove_file(dev, &dev_attr_cal);
1928 + device_remove_file(dev, &dev_attr_alarm_expired);
1929 + device_remove_file(dev, &dev_attr_alarm);
1930 + device_remove_file(dev, &dev_attr_reset);
1931 + device_remove_file(dev, &dev_attr_time);
1932 + return 0;
1933 +}
1934 +
1935 +static struct device_driver retu_rtc_driver = {
1936 + .name = "retu-rtc",
1937 + .bus = &platform_bus_type,
1938 + .probe = retu_rtc_probe,
1939 + .remove = __devexit_p(retu_rtc_remove),
1940 +};
1941 +
1942 +static struct platform_device retu_rtc_device = {
1943 + .name = "retu-rtc",
1944 + .id = -1,
1945 + .dev = {
1946 + .release = retu_rtc_device_release,
1947 + },
1948 +};
1949 +
1950 +/* This function provides syncronization with the RTCS interrupt handler */
1951 +static void retu_rtc_barrier(void)
1952 +{
1953 + INIT_COMPLETION(retu_rtc_sync);
1954 + retu_ack_irq(RETU_INT_RTCS);
1955 + retu_enable_irq(RETU_INT_RTCS);
1956 + wait_for_completion(&retu_rtc_sync);
1957 + retu_disable_irq(RETU_INT_RTCS);
1958 +}
1959 +
1960 +static int __init retu_rtc_init(void)
1961 +{
1962 + int ret;
1963 +
1964 + init_completion(&retu_rtc_exited);
1965 +
1966 + if ((ret = driver_register(&retu_rtc_driver)) != 0)
1967 + return ret;
1968 +
1969 + if ((ret = platform_device_register(&retu_rtc_device)) != 0)
1970 + goto err_unregister_driver;
1971 +
1972 + return 0;
1973 +
1974 +err_unregister_driver:
1975 + driver_unregister(&retu_rtc_driver);
1976 + return ret;
1977 +}
1978 +
1979 +static void __exit retu_rtc_exit(void)
1980 +{
1981 + platform_device_unregister(&retu_rtc_device);
1982 + driver_unregister(&retu_rtc_driver);
1983 +
1984 + wait_for_completion(&retu_rtc_exited);
1985 +}
1986 +
1987 +module_init(retu_rtc_init);
1988 +module_exit(retu_rtc_exit);
1989 +
1990 +MODULE_DESCRIPTION("Retu RTC");
1991 +MODULE_LICENSE("GPL");
1992 +MODULE_AUTHOR("Paul Mundt and Igor Stoppa");
1993 --- /dev/null
1994 +++ linux-2.6.36-rc7/drivers/cbus/retu-user.c
1995 @@ -0,0 +1,424 @@
1996 +/**
1997 + * drivers/cbus/retu-user.c
1998 + *
1999 + * Retu user space interface functions
2000 + *
2001 + * Copyright (C) 2004, 2005 Nokia Corporation
2002 + *
2003 + * Written by Mikko Ylinen <mikko.k.ylinen@nokia.com>
2004 + *
2005 + * This file is subject to the terms and conditions of the GNU General
2006 + * Public License. See the file "COPYING" in the main directory of this
2007 + * archive for more details.
2008 + *
2009 + * This program is distributed in the hope that it will be useful,
2010 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2011 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2012 + * GNU General Public License for more details.
2013 + *
2014 + * You should have received a copy of the GNU General Public License
2015 + * along with this program; if not, write to the Free Software
2016 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
2017 + */
2018 +
2019 +#include <linux/types.h>
2020 +#include <linux/kernel.h>
2021 +#include <linux/interrupt.h>
2022 +#include <linux/module.h>
2023 +#include <linux/init.h>
2024 +#include <linux/fs.h>
2025 +#include <linux/miscdevice.h>
2026 +#include <linux/poll.h>
2027 +#include <linux/list.h>
2028 +#include <linux/spinlock.h>
2029 +#include <linux/sched.h>
2030 +#include <linux/mutex.h>
2031 +#include <linux/slab.h>
2032 +
2033 +#include <asm/uaccess.h>
2034 +
2035 +#include "retu.h"
2036 +
2037 +#include "user_retu_tahvo.h"
2038 +
2039 +/* Maximum size of IRQ node buffer/pool */
2040 +#define RETU_MAX_IRQ_BUF_LEN 16
2041 +
2042 +#define PFX "retu-user: "
2043 +
2044 +/* Bitmap for marking the interrupt sources as having the handlers */
2045 +static u32 retu_irq_bits;
2046 +
2047 +/* For allowing only one user process to subscribe to the retu interrupts */
2048 +static struct file *retu_irq_subscr = NULL;
2049 +
2050 +/* For poll and IRQ passing */
2051 +struct retu_irq {
2052 + u32 id;
2053 + struct list_head node;
2054 +};
2055 +
2056 +static spinlock_t retu_irqs_lock;
2057 +static struct retu_irq *retu_irq_block;
2058 +static LIST_HEAD(retu_irqs);
2059 +static LIST_HEAD(retu_irqs_reserve);
2060 +
2061 +/* Wait queue - used when user wants to read the device */
2062 +DECLARE_WAIT_QUEUE_HEAD(retu_user_waitqueue);
2063 +
2064 +/* Semaphore to protect irq subscription sequence */
2065 +static struct mutex retu_mutex;
2066 +
2067 +/* This array specifies RETU register types (read/write/toggle) */
2068 +static const u8 retu_access_bits[] = {
2069 + 1,
2070 + 4,
2071 + 3,
2072 + 3,
2073 + 1,
2074 + 3,
2075 + 3,
2076 + 0,
2077 + 3,
2078 + 3,
2079 + 3,
2080 + 3,
2081 + 3,
2082 + 3,
2083 + 3,
2084 + 4,
2085 + 4,
2086 + 3,
2087 + 0,
2088 + 0,
2089 + 0,
2090 + 0,
2091 + 1,
2092 + 3,
2093 + 3,
2094 + 3,
2095 + 3,
2096 + 3,
2097 + 3,
2098 + 3,
2099 + 3,
2100 + 3
2101 +};
2102 +
2103 +/*
2104 + * The handler for all RETU interrupts.
2105 + *
2106 + * arg is the interrupt source in RETU.
2107 + */
2108 +static void retu_user_irq_handler(unsigned long arg)
2109 +{
2110 + struct retu_irq *irq;
2111 +
2112 + retu_ack_irq(arg);
2113 +
2114 + spin_lock(&retu_irqs_lock);
2115 + if (list_empty(&retu_irqs_reserve)) {
2116 + spin_unlock(&retu_irqs_lock);
2117 + return;
2118 + }
2119 + irq = list_entry((&retu_irqs_reserve)->next, struct retu_irq, node);
2120 + irq->id = arg;
2121 + list_move_tail(&irq->node, &retu_irqs);
2122 + spin_unlock(&retu_irqs_lock);
2123 +
2124 + /* wake up waiting thread */
2125 + wake_up(&retu_user_waitqueue);
2126 +}
2127 +
2128 +/*
2129 + * This routine sets up the interrupt handler and marks an interrupt source
2130 + * in RETU as a candidate for signal delivery to the user process.
2131 + */
2132 +static int retu_user_subscribe_to_irq(int id, struct file *filp)
2133 +{
2134 + int ret;
2135 +
2136 + mutex_lock(&retu_mutex);
2137 + if ((retu_irq_subscr != NULL) && (retu_irq_subscr != filp)) {
2138 + mutex_unlock(&retu_mutex);
2139 + return -EBUSY;
2140 + }
2141 + /* Store the file pointer of the first user process registering IRQs */
2142 + retu_irq_subscr = filp;
2143 + mutex_unlock(&retu_mutex);
2144 +
2145 + if (retu_irq_bits & (1 << id))
2146 + return 0;
2147 +
2148 + ret = retu_request_irq(id, retu_user_irq_handler, id, "");
2149 + if (ret < 0)
2150 + return ret;
2151 +
2152 + /* Mark that this interrupt has a handler */
2153 + retu_irq_bits |= 1 << id;
2154 +
2155 + return 0;
2156 +}
2157 +
2158 +/*
2159 + * Unregisters all RETU interrupt handlers.
2160 + */
2161 +static void retu_unreg_irq_handlers(void)
2162 +{
2163 + int id;
2164 +
2165 + if (!retu_irq_bits)
2166 + return;
2167 +
2168 + for (id = 0; id < MAX_RETU_IRQ_HANDLERS; id++)
2169 + if (retu_irq_bits & (1 << id))
2170 + retu_free_irq(id);
2171 +
2172 + retu_irq_bits = 0;
2173 +}
2174 +
2175 +/*
2176 + * Write to RETU register.
2177 + * Returns 0 upon success, a negative error value otherwise.
2178 + */
2179 +static int retu_user_write_with_mask(u32 field, u16 value)
2180 +{
2181 + u32 mask;
2182 + u32 reg;
2183 + u_short tmp;
2184 + unsigned long flags;
2185 +
2186 + mask = MASK(field);
2187 + reg = REG(field);
2188 +
2189 + /* Detect bad mask and reg */
2190 + if (mask == 0 || reg > RETU_REG_MAX ||
2191 + retu_access_bits[reg] == READ_ONLY) {
2192 + printk(KERN_ERR PFX "invalid arguments (reg=%#x, mask=%#x)\n",
2193 + reg, mask);
2194 + return -EINVAL;
2195 + }
2196 +
2197 + /* Justify value according to mask */
2198 + while (!(mask & 1)) {
2199 + value = value << 1;
2200 + mask = mask >> 1;
2201 + }
2202 +
2203 + spin_lock_irqsave(&retu_lock, flags);
2204 + if (retu_access_bits[reg] == TOGGLE) {
2205 + /* No need to detect previous content of register */
2206 + tmp = 0;
2207 + } else {
2208 + /* Read current value of register */
2209 + tmp = retu_read_reg(reg);
2210 + }
2211 +
2212 + /* Generate new value */
2213 + tmp = (tmp & ~MASK(field)) | (value & MASK(field));
2214 + /* Write data to RETU */
2215 + retu_write_reg(reg, tmp);
2216 + spin_unlock_irqrestore(&retu_lock, flags);
2217 +
2218 + return 0;
2219 +}
2220 +
2221 +/*
2222 + * Read RETU register.
2223 + */
2224 +static u32 retu_user_read_with_mask(u32 field)
2225 +{
2226 + u_short value;
2227 + u32 mask, reg;
2228 +
2229 + mask = MASK(field);
2230 + reg = REG(field);
2231 +
2232 + /* Detect bad mask and reg */
2233 + if (mask == 0 || reg > RETU_REG_MAX) {
2234 + printk(KERN_ERR PFX "invalid arguments (reg=%#x, mask=%#x)\n",
2235 + reg, mask);
2236 + return -EINVAL;
2237 + }
2238 +
2239 + /* Read the register */
2240 + value = retu_read_reg(reg) & mask;
2241 +
2242 + /* Right justify value */
2243 + while (!(mask & 1)) {
2244 + value = value >> 1;
2245 + mask = mask >> 1;
2246 + }
2247 +
2248 + return value;
2249 +}
2250 +
2251 +/*
2252 + * Close device
2253 + */
2254 +static int retu_close(struct inode *inode, struct file *filp)
2255 +{
2256 + /* Unregister all interrupts that have been registered */
2257 + if (retu_irq_subscr == filp) {
2258 + retu_unreg_irq_handlers();
2259 + retu_irq_subscr = NULL;
2260 + }
2261 +
2262 + return 0;
2263 +}
2264 +
2265 +/*
2266 + * Device control (ioctl)
2267 + */
2268 +static long retu_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
2269 +{
2270 + struct retu_tahvo_write_parms par;
2271 + int ret;
2272 +
2273 + switch (cmd) {
2274 + case URT_IOCT_IRQ_SUBSCR:
2275 + return retu_user_subscribe_to_irq(arg, filp);
2276 + case RETU_IOCH_READ:
2277 + return retu_user_read_with_mask(arg);
2278 + case RETU_IOCX_WRITE:
2279 + ret = copy_from_user(&par, (void __user *) arg, sizeof(par));
2280 + if (ret)
2281 + printk(KERN_ERR "copy_from_user failed: %d\n", ret);
2282 + par.result = retu_user_write_with_mask(par.field, par.value);
2283 + ret = copy_to_user((void __user *) arg, &par, sizeof(par));
2284 + if (ret)
2285 + printk(KERN_ERR "copy_to_user failed: %d\n", ret);
2286 + break;
2287 + case RETU_IOCH_ADC_READ:
2288 + return retu_read_adc(arg);
2289 + default:
2290 + return -ENOIOCTLCMD;
2291 + }
2292 + return 0;
2293 +}
2294 +
2295 +/*
2296 + * Read from device
2297 + */
2298 +static ssize_t retu_read(struct file *filp, char *buf, size_t count,
2299 + loff_t * offp)
2300 +{
2301 + struct retu_irq *irq;
2302 +
2303 + u32 nr, i;
2304 +
2305 + /* read not permitted if neither filp nor anyone has registered IRQs */
2306 + if (retu_irq_subscr != filp)
2307 + return -EPERM;
2308 +
2309 + if ((count < sizeof(u32)) || ((count % sizeof(u32)) != 0))
2310 + return -EINVAL;
2311 +
2312 + nr = count / sizeof(u32);
2313 +
2314 + for (i = 0; i < nr; i++) {
2315 + unsigned long flags;
2316 + u32 irq_id;
2317 + int ret;
2318 +
2319 + ret = wait_event_interruptible(retu_user_waitqueue,
2320 + !list_empty(&retu_irqs));
2321 + if (ret < 0)
2322 + return ret;
2323 +
2324 + spin_lock_irqsave(&retu_irqs_lock, flags);
2325 + irq = list_entry((&retu_irqs)->next, struct retu_irq, node);
2326 + irq_id = irq->id;
2327 + list_move(&irq->node, &retu_irqs_reserve);
2328 + spin_unlock_irqrestore(&retu_irqs_lock, flags);
2329 +
2330 + ret = copy_to_user(buf + i * sizeof(irq_id), &irq_id,
2331 + sizeof(irq_id));
2332 + if (ret)
2333 + printk(KERN_ERR "copy_to_user failed: %d\n", ret);
2334 + }
2335 +
2336 + return count;
2337 +}
2338 +
2339 +/*
2340 + * Poll method
2341 + */
2342 +static unsigned retu_poll(struct file *filp, struct poll_table_struct *pt)
2343 +{
2344 + if (!list_empty(&retu_irqs))
2345 + return POLLIN;
2346 +
2347 + poll_wait(filp, &retu_user_waitqueue, pt);
2348 +
2349 + if (!list_empty(&retu_irqs))
2350 + return POLLIN;
2351 + else
2352 + return 0;
2353 +}
2354 +
2355 +static struct file_operations retu_user_fileops = {
2356 + .owner = THIS_MODULE,
2357 + .unlocked_ioctl = retu_ioctl,
2358 + .read = retu_read,
2359 + .release = retu_close,
2360 + .poll = retu_poll
2361 +};
2362 +
2363 +static struct miscdevice retu_device = {
2364 + .minor = MISC_DYNAMIC_MINOR,
2365 + .name = "retu",
2366 + .fops = &retu_user_fileops
2367 +};
2368 +
2369 +/*
2370 + * Initialization
2371 + *
2372 + * @return 0 if successful, error value otherwise.
2373 + */
2374 +int retu_user_init(void)
2375 +{
2376 + struct retu_irq *irq;
2377 + int res, i;
2378 +
2379 + irq = kmalloc(sizeof(*irq) * RETU_MAX_IRQ_BUF_LEN, GFP_KERNEL);
2380 + if (irq == NULL) {
2381 + printk(KERN_ERR PFX "kmalloc failed\n");
2382 + return -ENOMEM;
2383 + }
2384 + memset(irq, 0, sizeof(*irq) * RETU_MAX_IRQ_BUF_LEN);
2385 + for (i = 0; i < RETU_MAX_IRQ_BUF_LEN; i++)
2386 + list_add(&irq[i].node, &retu_irqs_reserve);
2387 +
2388 + retu_irq_block = irq;
2389 +
2390 + spin_lock_init(&retu_irqs_lock);
2391 + mutex_init(&retu_mutex);
2392 +
2393 + /* Request a misc device */
2394 + res = misc_register(&retu_device);
2395 + if (res < 0) {
2396 + printk(KERN_ERR PFX "unable to register misc device for %s\n",
2397 + retu_device.name);
2398 + kfree(irq);
2399 + return res;
2400 + }
2401 +
2402 + return 0;
2403 +}
2404 +
2405 +/*
2406 + * Cleanup.
2407 + */
2408 +void retu_user_cleanup(void)
2409 +{
2410 + /* Unregister our misc device */
2411 + misc_deregister(&retu_device);
2412 + /* Unregister and disable all RETU interrupts used by this module */
2413 + retu_unreg_irq_handlers();
2414 + kfree(retu_irq_block);
2415 +}
2416 +
2417 +MODULE_DESCRIPTION("Retu ASIC user space functions");
2418 +MODULE_LICENSE("GPL");
2419 +MODULE_AUTHOR("Mikko Ylinen");
2420 --- /dev/null
2421 +++ linux-2.6.36-rc7/drivers/cbus/retu-wdt.c
2422 @@ -0,0 +1,387 @@
2423 +/**
2424 + * drivers/cbus/retu-wdt.c
2425 + *
2426 + * Driver for Retu watchdog
2427 + *
2428 + * Copyright (C) 2004, 2005 Nokia Corporation
2429 + *
2430 + * Written by Amit Kucheria <amit.kucheria@nokia.com>
2431 + *
2432 + * This file is subject to the terms and conditions of the GNU General
2433 + * Public License. See the file "COPYING" in the main directory of this
2434 + * archive for more details.
2435 + *
2436 + * This program is distributed in the hope that it will be useful,
2437 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2438 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2439 + * GNU General Public License for more details.
2440 + *
2441 + * You should have received a copy of the GNU General Public License
2442 + * along with this program; if not, write to the Free Software
2443 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
2444 + */
2445 +
2446 +#include <linux/kernel.h>
2447 +#include <linux/module.h>
2448 +#include <linux/device.h>
2449 +#include <linux/init.h>
2450 +#include <linux/fs.h>
2451 +#include <linux/io.h>
2452 +#include <linux/platform_device.h>
2453 +#include <linux/slab.h>
2454 +
2455 +#include <linux/completion.h>
2456 +#include <linux/errno.h>
2457 +#include <linux/moduleparam.h>
2458 +#include <linux/platform_device.h>
2459 +#include <linux/miscdevice.h>
2460 +#include <linux/watchdog.h>
2461 +
2462 +#include <asm/uaccess.h>
2463 +
2464 +#include <plat/prcm.h>
2465 +
2466 +#include "cbus.h"
2467 +#include "retu.h"
2468 +
2469 +/* Watchdog timeout in seconds */
2470 +#define RETU_WDT_MIN_TIMER 0
2471 +#define RETU_WDT_DEFAULT_TIMER 32
2472 +#define RETU_WDT_MAX_TIMER 63
2473 +
2474 +static struct completion retu_wdt_completion;
2475 +static DEFINE_MUTEX(retu_wdt_mutex);
2476 +
2477 +/* Current period of watchdog */
2478 +static unsigned int period_val = RETU_WDT_DEFAULT_TIMER;
2479 +static int counter_param = RETU_WDT_MAX_TIMER;
2480 +
2481 +struct retu_wdt_dev {
2482 + struct device *dev;
2483 + int users;
2484 + struct miscdevice retu_wdt_miscdev;
2485 + struct timer_list ping_timer;
2486 +};
2487 +
2488 +static struct retu_wdt_dev *retu_wdt;
2489 +
2490 +static void retu_wdt_set_ping_timer(unsigned long enable);
2491 +
2492 +static int _retu_modify_counter(unsigned int new)
2493 +{
2494 + retu_write_reg(RETU_REG_WATCHDOG, (u16)new);
2495 +
2496 + return 0;
2497 +}
2498 +
2499 +static int retu_modify_counter(unsigned int new)
2500 +{
2501 + if (new < RETU_WDT_MIN_TIMER || new > RETU_WDT_MAX_TIMER)
2502 + return -EINVAL;
2503 +
2504 + mutex_lock(&retu_wdt_mutex);
2505 + period_val = new;
2506 + _retu_modify_counter(period_val);
2507 + mutex_unlock(&retu_wdt_mutex);
2508 +
2509 + return 0;
2510 +}
2511 +
2512 +static ssize_t retu_wdt_period_show(struct device *dev,
2513 + struct device_attribute *attr, char *buf)
2514 +{
2515 + /* Show current max counter */
2516 + return sprintf(buf, "%u\n", (u16)period_val);
2517 +}
2518 +
2519 +/*
2520 + * Note: This inteface is non-standard and likely to disappear!
2521 + * Use /dev/watchdog instead, that's the standard.
2522 + */
2523 +static ssize_t retu_wdt_period_store(struct device *dev,
2524 + struct device_attribute *attr,
2525 + const char *buf, size_t count)
2526 +{
2527 + unsigned int new_period;
2528 + int ret;
2529 +
2530 +#ifdef CONFIG_WATCHDOG_NOWAYOUT
2531 + retu_wdt_set_ping_timer(0);
2532 +#endif
2533 +
2534 + if (sscanf(buf, "%u", &new_period) != 1) {
2535 + printk(KERN_ALERT "retu_wdt_period_store: Invalid input\n");
2536 + return -EINVAL;
2537 + }
2538 +
2539 + ret = retu_modify_counter(new_period);
2540 + if (ret < 0)
2541 + return ret;
2542 +
2543 + return strnlen(buf, count);
2544 +}
2545 +
2546 +static ssize_t retu_wdt_counter_show(struct device *dev,
2547 + struct device_attribute *attr, char *buf)
2548 +{
2549 + u16 counter;
2550 +
2551 + /* Show current value in watchdog counter */
2552 + counter = retu_read_reg(RETU_REG_WATCHDOG);
2553 +
2554 + /* Only the 5 LSB are important */
2555 + return snprintf(buf, PAGE_SIZE, "%u\n", (counter & 0x3F));
2556 +}
2557 +
2558 +static DEVICE_ATTR(period, S_IRUGO | S_IWUSR, retu_wdt_period_show, \
2559 + retu_wdt_period_store);
2560 +static DEVICE_ATTR(counter, S_IRUGO, retu_wdt_counter_show, NULL);
2561 +
2562 +/*----------------------------------------------------------------------------*/
2563 +
2564 +/*
2565 + * Since retu watchdog cannot be disabled in hardware, we must kick it
2566 + * with a timer until userspace watchdog software takes over. Do this
2567 + * unless /dev/watchdog is open or CONFIG_WATCHDOG_NOWAYOUT is set.
2568 + */
2569 +static void retu_wdt_set_ping_timer(unsigned long enable)
2570 +{
2571 + _retu_modify_counter(RETU_WDT_MAX_TIMER);
2572 + if (enable)
2573 + mod_timer(&retu_wdt->ping_timer,
2574 + jiffies + RETU_WDT_DEFAULT_TIMER * HZ);
2575 + else
2576 + del_timer_sync(&retu_wdt->ping_timer);
2577 +}
2578 +
2579 +static int retu_wdt_open(struct inode *inode, struct file *file)
2580 +{
2581 + if (test_and_set_bit(1, (unsigned long *)&(retu_wdt->users)))
2582 + return -EBUSY;
2583 +
2584 + file->private_data = (void *)retu_wdt;
2585 + retu_wdt_set_ping_timer(0);
2586 +
2587 + return nonseekable_open(inode, file);
2588 +}
2589 +
2590 +static int retu_wdt_release(struct inode *inode, struct file *file)
2591 +{
2592 + struct retu_wdt_dev *wdev = file->private_data;
2593 +
2594 +#ifndef CONFIG_WATCHDOG_NOWAYOUT
2595 + retu_wdt_set_ping_timer(1);
2596 +#endif
2597 + wdev->users = 0;
2598 +
2599 + return 0;
2600 +}
2601 +
2602 +static ssize_t retu_wdt_write(struct file *file, const char __user *data,
2603 + size_t len, loff_t *ppos)
2604 +{
2605 + if (len)
2606 + retu_modify_counter(RETU_WDT_MAX_TIMER);
2607 +
2608 + return len;
2609 +}
2610 +
2611 +static long retu_wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2612 +{
2613 + int new_margin;
2614 +
2615 + static struct watchdog_info ident = {
2616 + .identity = "Retu Watchdog",
2617 + .options = WDIOF_SETTIMEOUT,
2618 + .firmware_version = 0,
2619 + };
2620 +
2621 + switch (cmd) {
2622 + default:
2623 + return -ENOTTY;
2624 + case WDIOC_GETSUPPORT:
2625 + return copy_to_user((struct watchdog_info __user *)arg, &ident,
2626 + sizeof(ident));
2627 + case WDIOC_GETSTATUS:
2628 + return put_user(0, (int __user *)arg);
2629 + case WDIOC_GETBOOTSTATUS:
2630 + if (cpu_is_omap16xx())
2631 + return put_user(omap_readw(ARM_SYSST),
2632 + (int __user *)arg);
2633 + if (cpu_is_omap24xx())
2634 + return put_user(omap_prcm_get_reset_sources(),
2635 + (int __user *)arg);
2636 + case WDIOC_KEEPALIVE:
2637 + retu_modify_counter(RETU_WDT_MAX_TIMER);
2638 + break;
2639 + case WDIOC_SETTIMEOUT:
2640 + if (get_user(new_margin, (int __user *)arg))
2641 + return -EFAULT;
2642 + retu_modify_counter(new_margin);
2643 + /* Fall through */
2644 + case WDIOC_GETTIMEOUT:
2645 + return put_user(period_val, (int __user *)arg);
2646 + }
2647 +
2648 + return 0;
2649 +}
2650 +
2651 +/* Start kicking retu watchdog until user space starts doing the kicking */
2652 +static int __init retu_wdt_ping(void)
2653 +{
2654 +
2655 +#ifdef CONFIG_WATCHDOG_NOWAYOUT
2656 + retu_modify_counter(RETU_WDT_MAX_TIMER);
2657 +#else
2658 + retu_wdt_set_ping_timer(1);
2659 +#endif
2660 +
2661 + return 0;
2662 +}
2663 +late_initcall(retu_wdt_ping);
2664 +
2665 +static const struct file_operations retu_wdt_fops = {
2666 + .owner = THIS_MODULE,
2667 + .write = retu_wdt_write,
2668 + .unlocked_ioctl = retu_wdt_ioctl,
2669 + .open = retu_wdt_open,
2670 + .release = retu_wdt_release,
2671 +};
2672 +
2673 +/*----------------------------------------------------------------------------*/
2674 +
2675 +static int __devinit retu_wdt_probe(struct device *dev)
2676 +{
2677 + struct retu_wdt_dev *wdev;
2678 + int ret;
2679 +
2680 + wdev = kzalloc(sizeof(struct retu_wdt_dev), GFP_KERNEL);
2681 + if (!wdev)
2682 + return -ENOMEM;
2683 +
2684 + wdev->users = 0;
2685 +
2686 + ret = device_create_file(dev, &dev_attr_period);
2687 + if (ret) {
2688 + printk(KERN_ERR "retu_wdt_probe: Error creating "
2689 + "sys device file: period\n");
2690 + goto free1;
2691 + }
2692 +
2693 + ret = device_create_file(dev, &dev_attr_counter);
2694 + if (ret) {
2695 + printk(KERN_ERR "retu_wdt_probe: Error creating "
2696 + "sys device file: counter\n");
2697 + goto free2;
2698 + }
2699 +
2700 + dev_set_drvdata(dev, wdev);
2701 + retu_wdt = wdev;
2702 + wdev->retu_wdt_miscdev.parent = dev;
2703 + wdev->retu_wdt_miscdev.minor = WATCHDOG_MINOR;
2704 + wdev->retu_wdt_miscdev.name = "watchdog";
2705 + wdev->retu_wdt_miscdev.fops = &retu_wdt_fops;
2706 +
2707 + ret = misc_register(&(wdev->retu_wdt_miscdev));
2708 + if (ret)
2709 + goto free3;
2710 +
2711 + setup_timer(&wdev->ping_timer, retu_wdt_set_ping_timer, 1);
2712 +
2713 + /* Kick the watchdog for kernel booting to finish */
2714 + retu_modify_counter(RETU_WDT_MAX_TIMER);
2715 +
2716 + return 0;
2717 +
2718 +free3:
2719 + device_remove_file(dev, &dev_attr_counter);
2720 +
2721 +free2:
2722 + device_remove_file(dev, &dev_attr_period);
2723 +free1:
2724 + kfree(wdev);
2725 +
2726 + return ret;
2727 +}
2728 +
2729 +static int __devexit retu_wdt_remove(struct device *dev)
2730 +{
2731 + struct retu_wdt_dev *wdev;
2732 +
2733 + wdev = dev_get_drvdata(dev);
2734 + misc_deregister(&(wdev->retu_wdt_miscdev));
2735 + device_remove_file(dev, &dev_attr_period);
2736 + device_remove_file(dev, &dev_attr_counter);
2737 + kfree(wdev);
2738 +
2739 + return 0;
2740 +}
2741 +
2742 +static void retu_wdt_device_release(struct device *dev)
2743 +{
2744 + complete(&retu_wdt_completion);
2745 +}
2746 +
2747 +static struct platform_device retu_wdt_device = {
2748 + .name = "retu-watchdog",
2749 + .id = -1,
2750 + .dev = {
2751 + .release = retu_wdt_device_release,
2752 + },
2753 +};
2754 +
2755 +static struct device_driver retu_wdt_driver = {
2756 + .name = "retu-watchdog",
2757 + .bus = &platform_bus_type,
2758 + .probe = retu_wdt_probe,
2759 + .remove = __devexit_p(retu_wdt_remove),
2760 +};
2761 +
2762 +static int __init retu_wdt_init(void)
2763 +{
2764 + int ret;
2765 +
2766 + init_completion(&retu_wdt_completion);
2767 +
2768 + ret = driver_register(&retu_wdt_driver);
2769 + if (ret)
2770 + return ret;
2771 +
2772 + ret = platform_device_register(&retu_wdt_device);
2773 + if (ret)
2774 + goto exit1;
2775 +
2776 + /* passed as module parameter? */
2777 + ret = retu_modify_counter(counter_param);
2778 + if (ret == -EINVAL) {
2779 + ret = retu_modify_counter(RETU_WDT_DEFAULT_TIMER);
2780 + printk(KERN_INFO
2781 + "retu_wdt_init: Intializing to default value\n");
2782 + }
2783 +
2784 + printk(KERN_INFO "Retu watchdog driver initialized\n");
2785 + return ret;
2786 +
2787 +exit1:
2788 + driver_unregister(&retu_wdt_driver);
2789 + wait_for_completion(&retu_wdt_completion);
2790 +
2791 + return ret;
2792 +}
2793 +
2794 +static void __exit retu_wdt_exit(void)
2795 +{
2796 + platform_device_unregister(&retu_wdt_device);
2797 + driver_unregister(&retu_wdt_driver);
2798 +
2799 + wait_for_completion(&retu_wdt_completion);
2800 +}
2801 +
2802 +module_init(retu_wdt_init);
2803 +module_exit(retu_wdt_exit);
2804 +module_param(counter_param, int, 0);
2805 +
2806 +MODULE_DESCRIPTION("Retu WatchDog");
2807 +MODULE_AUTHOR("Amit Kucheria");
2808 +MODULE_LICENSE("GPL");
2809 +
2810 --- /dev/null
2811 +++ linux-2.6.36-rc7/drivers/cbus/tahvo.c
2812 @@ -0,0 +1,443 @@
2813 +/**
2814 + * drivers/cbus/tahvo.c
2815 + *
2816 + * Support functions for Tahvo ASIC
2817 + *
2818 + * Copyright (C) 2004, 2005 Nokia Corporation
2819 + *
2820 + * Written by Juha Yrjölä <juha.yrjola@nokia.com>,
2821 + * David Weinehall <david.weinehall@nokia.com>, and
2822 + * Mikko Ylinen <mikko.k.ylinen@nokia.com>
2823 + *
2824 + * This file is subject to the terms and conditions of the GNU General
2825 + * Public License. See the file "COPYING" in the main directory of this
2826 + * archive for more details.
2827 + *
2828 + * This program is distributed in the hope that it will be useful,
2829 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2830 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2831 + * GNU General Public License for more details.
2832 + *
2833 + * You should have received a copy of the GNU General Public License
2834 + * along with this program; if not, write to the Free Software
2835 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
2836 + */
2837 +
2838 +#include <linux/module.h>
2839 +#include <linux/init.h>
2840 +
2841 +#include <linux/kernel.h>
2842 +#include <linux/errno.h>
2843 +#include <linux/device.h>
2844 +#include <linux/miscdevice.h>
2845 +#include <linux/poll.h>
2846 +#include <linux/fs.h>
2847 +#include <linux/irq.h>
2848 +#include <linux/interrupt.h>
2849 +#include <linux/platform_device.h>
2850 +#include <linux/gpio.h>
2851 +
2852 +#include <asm/uaccess.h>
2853 +#include <asm/mach-types.h>
2854 +
2855 +#include <plat/mux.h>
2856 +#include <plat/board.h>
2857 +
2858 +#include "cbus.h"
2859 +#include "tahvo.h"
2860 +
2861 +#define TAHVO_ID 0x02
2862 +#define PFX "tahvo: "
2863 +
2864 +static int tahvo_initialized;
2865 +static int tahvo_irq_pin;
2866 +static int tahvo_is_betty;
2867 +
2868 +static struct tasklet_struct tahvo_tasklet;
2869 +spinlock_t tahvo_lock = SPIN_LOCK_UNLOCKED;
2870 +
2871 +static struct completion device_release;
2872 +
2873 +struct tahvo_irq_handler_desc {
2874 + int (*func)(unsigned long);
2875 + unsigned long arg;
2876 + char name[8];
2877 +};
2878 +
2879 +static struct tahvo_irq_handler_desc tahvo_irq_handlers[MAX_TAHVO_IRQ_HANDLERS];
2880 +
2881 +/**
2882 + * tahvo_read_reg - Read a value from a register in Tahvo
2883 + * @reg: the register to read from
2884 + *
2885 + * This function returns the contents of the specified register
2886 + */
2887 +int tahvo_read_reg(int reg)
2888 +{
2889 + BUG_ON(!tahvo_initialized);
2890 + return cbus_read_reg(cbus_host, TAHVO_ID, reg);
2891 +}
2892 +
2893 +/**
2894 + * tahvo_write_reg - Write a value to a register in Tahvo
2895 + * @reg: the register to write to
2896 + * @reg: the value to write to the register
2897 + *
2898 + * This function writes a value to the specified register
2899 + */
2900 +void tahvo_write_reg(int reg, u16 val)
2901 +{
2902 + BUG_ON(!tahvo_initialized);
2903 + cbus_write_reg(cbus_host, TAHVO_ID, reg, val);
2904 +}
2905 +
2906 +/**
2907 + * tahvo_set_clear_reg_bits - set and clear register bits atomically
2908 + * @reg: the register to write to
2909 + * @bits: the bits to set
2910 + *
2911 + * This function sets and clears the specified Tahvo register bits atomically
2912 + */
2913 +void tahvo_set_clear_reg_bits(int reg, u16 set, u16 clear)
2914 +{
2915 + unsigned long flags;
2916 + u16 w;
2917 +
2918 + spin_lock_irqsave(&tahvo_lock, flags);
2919 + w = tahvo_read_reg(reg);
2920 + w &= ~clear;
2921 + w |= set;
2922 + tahvo_write_reg(reg, w);
2923 + spin_unlock_irqrestore(&tahvo_lock, flags);
2924 +}
2925 +
2926 +/*
2927 + * Disable given TAHVO interrupt
2928 + */
2929 +void tahvo_disable_irq(int id)
2930 +{
2931 + unsigned long flags;
2932 + u16 mask;
2933 +
2934 + spin_lock_irqsave(&tahvo_lock, flags);
2935 + mask = tahvo_read_reg(TAHVO_REG_IMR);
2936 + mask |= 1 << id;
2937 + tahvo_write_reg(TAHVO_REG_IMR, mask);
2938 + spin_unlock_irqrestore(&tahvo_lock, flags);
2939 +}
2940 +
2941 +/*
2942 + * Enable given TAHVO interrupt
2943 + */
2944 +void tahvo_enable_irq(int id)
2945 +{
2946 + unsigned long flags;
2947 + u16 mask;
2948 +
2949 + spin_lock_irqsave(&tahvo_lock, flags);
2950 + mask = tahvo_read_reg(TAHVO_REG_IMR);
2951 + mask &= ~(1 << id);
2952 + tahvo_write_reg(TAHVO_REG_IMR, mask);
2953 + spin_unlock_irqrestore(&tahvo_lock, flags);
2954 +}
2955 +
2956 +/*
2957 + * Acknowledge given TAHVO interrupt
2958 + */
2959 +void tahvo_ack_irq(int id)
2960 +{
2961 + tahvo_write_reg(TAHVO_REG_IDR, 1 << id);
2962 +}
2963 +
2964 +static int tahvo_7bit_backlight;
2965 +
2966 +int tahvo_get_backlight_level(void)
2967 +{
2968 + int mask;
2969 +
2970 + if (tahvo_7bit_backlight)
2971 + mask = 0x7f;
2972 + else
2973 + mask = 0x0f;
2974 + return tahvo_read_reg(TAHVO_REG_LEDPWMR) & mask;
2975 +}
2976 +
2977 +int tahvo_get_max_backlight_level(void)
2978 +{
2979 + if (tahvo_7bit_backlight)
2980 + return 0x7f;
2981 + else
2982 + return 0x0f;
2983 +}
2984 +
2985 +void tahvo_set_backlight_level(int level)
2986 +{
2987 + int max_level;
2988 +
2989 + max_level = tahvo_get_max_backlight_level();
2990 + if (level > max_level)
2991 + level = max_level;
2992 + tahvo_write_reg(TAHVO_REG_LEDPWMR, level);
2993 +}
2994 +
2995 +/*
2996 + * TAHVO interrupt handler. Only schedules the tasklet.
2997 + */
2998 +static irqreturn_t tahvo_irq_handler(int irq, void *dev_id)
2999 +{
3000 + tasklet_schedule(&tahvo_tasklet);
3001 + return IRQ_HANDLED;
3002 +}
3003 +
3004 +/*
3005 + * Tasklet handler
3006 + */
3007 +static void tahvo_tasklet_handler(unsigned long data)
3008 +{
3009 + struct tahvo_irq_handler_desc *hnd;
3010 + u16 id;
3011 + u16 im;
3012 + int i;
3013 +
3014 + for (;;) {
3015 + id = tahvo_read_reg(TAHVO_REG_IDR);
3016 + im = ~tahvo_read_reg(TAHVO_REG_IMR);
3017 + id &= im;
3018 +
3019 + if (!id)
3020 + break;
3021 +
3022 + for (i = 0; id != 0; i++, id >>= 1) {
3023 + if (!(id & 1))
3024 + continue;
3025 + hnd = &tahvo_irq_handlers[i];
3026 + if (hnd->func == NULL) {
3027 + /* Spurious tahvo interrupt - just ack it */
3028 + printk(KERN_INFO "Spurious Tahvo interrupt "
3029 + "(id %d)\n", i);
3030 + tahvo_disable_irq(i);
3031 + tahvo_ack_irq(i);
3032 + continue;
3033 + }
3034 + hnd->func(hnd->arg);
3035 + /*
3036 + * Don't acknowledge the interrupt here
3037 + * It must be done explicitly
3038 + */
3039 + }
3040 + }
3041 +}
3042 +
3043 +/*
3044 + * Register the handler for a given TAHVO interrupt source.
3045 + */
3046 +int tahvo_request_irq(int id, void *irq_handler, unsigned long arg, char *name)
3047 +{
3048 + struct tahvo_irq_handler_desc *hnd;
3049 +
3050 + if (irq_handler == NULL || id >= MAX_TAHVO_IRQ_HANDLERS ||
3051 + name == NULL) {
3052 + printk(KERN_ERR PFX "Invalid arguments to %s\n",
3053 + __FUNCTION__);
3054 + return -EINVAL;
3055 + }
3056 + hnd = &tahvo_irq_handlers[id];
3057 + if (hnd->func != NULL) {
3058 + printk(KERN_ERR PFX "IRQ %d already reserved\n", id);
3059 + return -EBUSY;
3060 + }
3061 + printk(KERN_INFO PFX "Registering interrupt %d for device %s\n",
3062 + id, name);
3063 + hnd->func = irq_handler;
3064 + hnd->arg = arg;
3065 + strlcpy(hnd->name, name, sizeof(hnd->name));
3066 +
3067 + tahvo_ack_irq(id);
3068 + tahvo_enable_irq(id);
3069 +
3070 + return 0;
3071 +}
3072 +
3073 +/*
3074 + * Unregister the handler for a given TAHVO interrupt source.
3075 + */
3076 +void tahvo_free_irq(int id)
3077 +{
3078 + struct tahvo_irq_handler_desc *hnd;
3079 +
3080 + if (id >= MAX_TAHVO_IRQ_HANDLERS) {
3081 + printk(KERN_ERR PFX "Invalid argument to %s\n",
3082 + __FUNCTION__);
3083 + return;
3084 + }
3085 + hnd = &tahvo_irq_handlers[id];
3086 + if (hnd->func == NULL) {
3087 + printk(KERN_ERR PFX "IRQ %d already freed\n", id);
3088 + return;
3089 + }
3090 +
3091 + tahvo_disable_irq(id);
3092 + hnd->func = NULL;
3093 +}
3094 +
3095 +/**
3096 + * tahvo_probe - Probe for Tahvo ASIC
3097 + * @dev: the Tahvo device
3098 + *
3099 + * Probe for the Tahvo ASIC and allocate memory
3100 + * for its device-struct if found
3101 + */
3102 +static int __devinit tahvo_probe(struct device *dev)
3103 +{
3104 + int rev, id, ret;
3105 +
3106 + /* Prepare tasklet */
3107 + tasklet_init(&tahvo_tasklet, tahvo_tasklet_handler, 0);
3108 +
3109 + tahvo_initialized = 1;
3110 +
3111 + rev = tahvo_read_reg(TAHVO_REG_ASICR);
3112 +
3113 + id = (rev >> 8) & 0xff;
3114 + if (id == 0x03) {
3115 + if ((rev & 0xff) >= 0x50)
3116 + tahvo_7bit_backlight = 1;
3117 + } else if (id == 0x0b) {
3118 + tahvo_is_betty = 1;
3119 + tahvo_7bit_backlight = 1;
3120 + } else {
3121 + printk(KERN_ERR "Tahvo/Betty chip not found");
3122 + return -ENODEV;
3123 + }
3124 +
3125 + printk(KERN_INFO "%s v%d.%d found\n", tahvo_is_betty ? "Betty" : "Tahvo",
3126 + (rev >> 4) & 0x0f, rev & 0x0f);
3127 +
3128 + /* REVISIT: Pass these from board-*.c files in platform_data */
3129 + if (machine_is_nokia770()) {
3130 + tahvo_irq_pin = 40;
3131 + } else if (machine_is_nokia_n800() || machine_is_nokia_n810() ||
3132 + machine_is_nokia_n810_wimax()) {
3133 + tahvo_irq_pin = 111;
3134 + } else {
3135 + printk(KERN_ERR "cbus: Unsupported board for tahvo\n");
3136 + return -ENODEV;
3137 + }
3138 +
3139 + if ((ret = gpio_request(tahvo_irq_pin, "TAHVO irq")) < 0) {
3140 + printk(KERN_ERR PFX "Unable to reserve IRQ GPIO\n");
3141 + return ret;
3142 + }
3143 +
3144 + /* Set the pin as input */
3145 + gpio_direction_input(tahvo_irq_pin);
3146 +
3147 + /* Rising edge triggers the IRQ */
3148 + set_irq_type(gpio_to_irq(tahvo_irq_pin), IRQ_TYPE_EDGE_RISING);
3149 +
3150 + /* Mask all TAHVO interrupts */
3151 + tahvo_write_reg(TAHVO_REG_IMR, 0xffff);
3152 +
3153 + ret = request_irq(gpio_to_irq(tahvo_irq_pin), tahvo_irq_handler, 0,
3154 + "tahvo", 0);
3155 + if (ret < 0) {
3156 + printk(KERN_ERR PFX "Unable to register IRQ handler\n");
3157 + gpio_free(tahvo_irq_pin);
3158 + return ret;
3159 + }
3160 +#ifdef CONFIG_CBUS_TAHVO_USER
3161 + /* Initialize user-space interface */
3162 + if (tahvo_user_init() < 0) {
3163 + printk(KERN_ERR "Unable to initialize driver\n");
3164 + free_irq(gpio_to_irq(tahvo_irq_pin), 0);
3165 + gpio_free(tahvo_irq_pin);
3166 + return ret;
3167 + }
3168 +#endif
3169 + return 0;
3170 +}
3171 +
3172 +static int tahvo_remove(struct device *dev)
3173 +{
3174 +#ifdef CONFIG_CBUS_TAHVO_USER
3175 + tahvo_user_cleanup();
3176 +#endif
3177 + /* Mask all TAHVO interrupts */
3178 + tahvo_write_reg(TAHVO_REG_IMR, 0xffff);
3179 + free_irq(gpio_to_irq(tahvo_irq_pin), 0);
3180 + gpio_free(tahvo_irq_pin);
3181 + tasklet_kill(&tahvo_tasklet);
3182 +
3183 + return 0;
3184 +}
3185 +
3186 +static void tahvo_device_release(struct device *dev)
3187 +{
3188 + complete(&device_release);
3189 +}
3190 +
3191 +static struct device_driver tahvo_driver = {
3192 + .name = "tahvo",
3193 + .bus = &platform_bus_type,
3194 + .probe = tahvo_probe,
3195 + .remove = tahvo_remove,
3196 +};
3197 +
3198 +static struct platform_device tahvo_device = {
3199 + .name = "tahvo",
3200 + .id = -1,
3201 + .dev = {
3202 + .release = tahvo_device_release,
3203 + }
3204 +};
3205 +
3206 +/**
3207 + * tahvo_init - initialise Tahvo driver
3208 + *
3209 + * Initialise the Tahvo driver and return 0 if everything worked ok
3210 + */
3211 +static int __init tahvo_init(void)
3212 +{
3213 + int ret = 0;
3214 +
3215 + printk(KERN_INFO "Tahvo/Betty driver initialising\n");
3216 +
3217 + init_completion(&device_release);
3218 +
3219 + if ((ret = driver_register(&tahvo_driver)) < 0)
3220 + return ret;
3221 +
3222 + if ((ret = platform_device_register(&tahvo_device)) < 0) {
3223 + driver_unregister(&tahvo_driver);
3224 + return ret;
3225 + }
3226 + return 0;
3227 +}
3228 +
3229 +/*
3230 + * Cleanup
3231 + */
3232 +static void __exit tahvo_exit(void)
3233 +{
3234 + platform_device_unregister(&tahvo_device);
3235 + driver_unregister(&tahvo_driver);
3236 + wait_for_completion(&device_release);
3237 +}
3238 +
3239 +EXPORT_SYMBOL(tahvo_request_irq);
3240 +EXPORT_SYMBOL(tahvo_free_irq);
3241 +EXPORT_SYMBOL(tahvo_enable_irq);
3242 +EXPORT_SYMBOL(tahvo_disable_irq);
3243 +EXPORT_SYMBOL(tahvo_ack_irq);
3244 +EXPORT_SYMBOL(tahvo_read_reg);
3245 +EXPORT_SYMBOL(tahvo_write_reg);
3246 +EXPORT_SYMBOL(tahvo_get_backlight_level);
3247 +EXPORT_SYMBOL(tahvo_get_max_backlight_level);
3248 +EXPORT_SYMBOL(tahvo_set_backlight_level);
3249 +
3250 +subsys_initcall(tahvo_init);
3251 +module_exit(tahvo_exit);
3252 +
3253 +MODULE_DESCRIPTION("Tahvo ASIC control");
3254 +MODULE_LICENSE("GPL");
3255 +MODULE_AUTHOR("Juha Yrjölä, David Weinehall, and Mikko Ylinen");
3256 --- /dev/null
3257 +++ linux-2.6.36-rc7/drivers/cbus/tahvo.h
3258 @@ -0,0 +1,61 @@
3259 +/*
3260 + * drivers/cbus/tahvo.h
3261 + *
3262 + * Copyright (C) 2004, 2005 Nokia Corporation
3263 + *
3264 + * Written by Juha Yrjölä <juha.yrjola@nokia.com> and
3265 + * David Weinehall <david.weinehall@nokia.com>
3266 + *
3267 + * This file is subject to the terms and conditions of the GNU General
3268 + * Public License. See the file "COPYING" in the main directory of this
3269 + * archive for more details.
3270 + *
3271 + * This program is distributed in the hope that it will be useful,
3272 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
3273 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
3274 + * GNU General Public License for more details.
3275 +
3276 + * You should have received a copy of the GNU General Public License
3277 + * along with this program; if not, write to the Free Software
3278 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
3279 + */
3280 +
3281 +#ifndef __DRIVERS_CBUS_TAHVO_H
3282 +#define __DRIVERS_CBUS_TAHVO_H
3283 +
3284 +#include <linux/types.h>
3285 +
3286 +/* Registers */
3287 +#define TAHVO_REG_ASICR 0x00 /* ASIC ID & revision */
3288 +#define TAHVO_REG_IDR 0x01 /* Interrupt ID */
3289 +#define TAHVO_REG_IDSR 0x02 /* Interrupt status */
3290 +#define TAHVO_REG_IMR 0x03 /* Interrupt mask */
3291 +#define TAHVO_REG_LEDPWMR 0x05 /* LED PWM */
3292 +#define TAHVO_REG_USBR 0x06 /* USB control */
3293 +#define TAHVO_REG_MAX 0x0d
3294 +
3295 +/* Interrupt sources */
3296 +#define TAHVO_INT_VBUSON 0
3297 +
3298 +#define MAX_TAHVO_IRQ_HANDLERS 8
3299 +
3300 +int tahvo_read_reg(int reg);
3301 +void tahvo_write_reg(int reg, u16 val);
3302 +void tahvo_set_clear_reg_bits(int reg, u16 set, u16 clear);
3303 +int tahvo_request_irq(int id, void *irq_handler, unsigned long arg, char *name);
3304 +void tahvo_free_irq(int id);
3305 +void tahvo_enable_irq(int id);
3306 +void tahvo_disable_irq(int id);
3307 +void tahvo_ack_irq(int id);
3308 +int tahvo_get_backlight_level(void);
3309 +int tahvo_get_max_backlight_level(void);
3310 +void tahvo_set_backlight_level(int level);
3311 +
3312 +#ifdef CONFIG_CBUS_TAHVO_USER
3313 +int tahvo_user_init(void);
3314 +void tahvo_user_cleanup(void);
3315 +#endif
3316 +
3317 +extern spinlock_t tahvo_lock;
3318 +
3319 +#endif /* __DRIVERS_CBUS_TAHVO_H */
3320 --- /dev/null
3321 +++ linux-2.6.36-rc7/drivers/cbus/tahvo-usb.c
3322 @@ -0,0 +1,788 @@
3323 +/**
3324 + * drivers/cbus/tahvo-usb.c
3325 + *
3326 + * Tahvo USB transeiver
3327 + *
3328 + * Copyright (C) 2005-2006 Nokia Corporation
3329 + *
3330 + * Parts copied from drivers/i2c/chips/isp1301_omap.c
3331 + * Copyright (C) 2004 Texas Instruments
3332 + * Copyright (C) 2004 David Brownell
3333 + *
3334 + * Written by Juha Yrjölä <juha.yrjola@nokia.com>,
3335 + * Tony Lindgren <tony@atomide.com>, and
3336 + * Timo Teräs <timo.teras@nokia.com>
3337 + *
3338 + * This file is subject to the terms and conditions of the GNU General
3339 + * Public License. See the file "COPYING" in the main directory of this
3340 + * archive for more details.
3341 + *
3342 + * This program is distributed in the hope that it will be useful,
3343 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
3344 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
3345 + * GNU General Public License for more details.
3346 + *
3347 + * You should have received a copy of the GNU General Public License
3348 + * along with this program; if not, write to the Free Software
3349 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
3350 + */
3351 +
3352 +#include <linux/kernel.h>
3353 +#include <linux/module.h>
3354 +#include <linux/init.h>
3355 +#include <linux/slab.h>
3356 +#include <linux/io.h>
3357 +#include <linux/interrupt.h>
3358 +#include <linux/platform_device.h>
3359 +#include <linux/usb/ch9.h>
3360 +#include <linux/usb/gadget.h>
3361 +#include <linux/usb.h>
3362 +#include <linux/usb/otg.h>
3363 +#include <linux/i2c.h>
3364 +#include <linux/workqueue.h>
3365 +#include <linux/kobject.h>
3366 +#include <linux/clk.h>
3367 +#include <linux/mutex.h>
3368 +
3369 +#include <asm/irq.h>
3370 +#include <plat/usb.h>
3371 +
3372 +#include "cbus.h"
3373 +#include "tahvo.h"
3374 +
3375 +#define DRIVER_NAME "tahvo-usb"
3376 +
3377 +#define USBR_SLAVE_CONTROL (1 << 8)
3378 +#define USBR_VPPVIO_SW (1 << 7)
3379 +#define USBR_SPEED (1 << 6)
3380 +#define USBR_REGOUT (1 << 5)
3381 +#define USBR_MASTER_SW2 (1 << 4)
3382 +#define USBR_MASTER_SW1 (1 << 3)
3383 +#define USBR_SLAVE_SW (1 << 2)
3384 +#define USBR_NSUSPEND (1 << 1)
3385 +#define USBR_SEMODE (1 << 0)
3386 +
3387 +/* bits in OTG_CTRL */
3388 +
3389 +/* Bits that are controlled by OMAP OTG and are read-only */
3390 +#define OTG_CTRL_OMAP_MASK (OTG_PULLDOWN|OTG_PULLUP|OTG_DRV_VBUS|\
3391 + OTG_PD_VBUS|OTG_PU_VBUS|OTG_PU_ID)
3392 +/* Bits that are controlled by transceiver */
3393 +#define OTG_CTRL_XCVR_MASK (OTG_ASESSVLD|OTG_BSESSEND|\
3394 + OTG_BSESSVLD|OTG_VBUSVLD|OTG_ID)
3395 +/* Bits that are controlled by system */
3396 +#define OTG_CTRL_SYS_MASK (OTG_A_BUSREQ|OTG_A_SETB_HNPEN|OTG_B_BUSREQ|\
3397 + OTG_B_HNPEN|OTG_BUSDROP)
3398 +
3399 +#if defined(CONFIG_USB_OHCI_HCD) && !defined(CONFIG_USB_OTG)
3400 +#error tahvo-otg.c does not work with OCHI yet!
3401 +#endif
3402 +
3403 +#define TAHVO_MODE_HOST 0
3404 +#define TAHVO_MODE_PERIPHERAL 1
3405 +
3406 +#ifdef CONFIG_USB_OTG
3407 +#define TAHVO_MODE(tu) (tu)->tahvo_mode
3408 +#elif defined(CONFIG_USB_GADGET_OMAP)
3409 +#define TAHVO_MODE(tu) TAHVO_MODE_PERIPHERAL
3410 +#else
3411 +#define TAHVO_MODE(tu) TAHVO_MODE_HOST
3412 +#endif
3413 +
3414 +struct tahvo_usb {
3415 + struct platform_device *pt_dev;
3416 + struct otg_transceiver otg;
3417 + int vbus_state;
3418 + struct work_struct irq_work;
3419 + struct mutex serialize;
3420 +#ifdef CONFIG_USB_OTG
3421 + int tahvo_mode;
3422 +#endif
3423 +};
3424 +static struct platform_device tahvo_usb_device;
3425 +
3426 +/*
3427 + * ---------------------------------------------------------------------------
3428 + * OTG related functions
3429 + *
3430 + * These shoud be separated into omap-otg.c driver module, as they are used
3431 + * by various transceivers. These functions are needed in the UDC-only case
3432 + * as well. These functions are copied from GPL isp1301_omap.c
3433 + * ---------------------------------------------------------------------------
3434 + */
3435 +static struct platform_device *tahvo_otg_dev;
3436 +
3437 +static irqreturn_t omap_otg_irq(int irq, void *arg)
3438 +{
3439 + struct platform_device *otg_dev = arg;
3440 + struct tahvo_usb *tu = platform_get_drvdata(otg_dev);
3441 + u16 otg_irq;
3442 +
3443 + otg_irq = omap_readw(OTG_IRQ_SRC);
3444 + if (otg_irq & OPRT_CHG) {
3445 + omap_writew(OPRT_CHG, OTG_IRQ_SRC);
3446 + } else if (otg_irq & B_SRP_TMROUT) {
3447 + omap_writew(B_SRP_TMROUT, OTG_IRQ_SRC);
3448 + } else if (otg_irq & B_HNP_FAIL) {
3449 + omap_writew(B_HNP_FAIL, OTG_IRQ_SRC);
3450 + } else if (otg_irq & A_SRP_DETECT) {
3451 + omap_writew(A_SRP_DETECT, OTG_IRQ_SRC);
3452 + } else if (otg_irq & A_REQ_TMROUT) {
3453 + omap_writew(A_REQ_TMROUT, OTG_IRQ_SRC);
3454 + } else if (otg_irq & A_VBUS_ERR) {
3455 + omap_writew(A_VBUS_ERR, OTG_IRQ_SRC);
3456 + } else if (otg_irq & DRIVER_SWITCH) {
3457 + if ((!(omap_readl(OTG_CTRL) & OTG_DRIVER_SEL)) &&
3458 + tu->otg.host && tu->otg.state == OTG_STATE_A_HOST) {
3459 + /* role is host */
3460 + usb_bus_start_enum(tu->otg.host,
3461 + tu->otg.host->otg_port);
3462 + }
3463 + omap_writew(DRIVER_SWITCH, OTG_IRQ_SRC);
3464 + } else
3465 + return IRQ_NONE;
3466 +
3467 + return IRQ_HANDLED;
3468 +
3469 +}
3470 +
3471 +static int tahvo_omap_otg_init(void)
3472 +{
3473 + u32 l;
3474 +
3475 +#ifdef CONFIG_USB_OTG
3476 + if (!tahvo_otg_dev) {
3477 + printk("tahvo-usb: no tahvo_otg_dev\n");
3478 + return -ENODEV;
3479 + }
3480 +#endif
3481 +
3482 + l = omap_readl(OTG_SYSCON_1);
3483 + l &= ~OTG_IDLE_EN;
3484 + omap_writel(l, OTG_SYSCON_1);
3485 + udelay(100);
3486 +
3487 + /* some of these values are board-specific... */
3488 + l = omap_readl(OTG_SYSCON_2);
3489 + l |= OTG_EN
3490 + /* for B-device: */
3491 + | SRP_GPDATA /* 9msec Bdev D+ pulse */
3492 + | SRP_GPDVBUS /* discharge after VBUS pulse */
3493 + // | (3 << 24) /* 2msec VBUS pulse */
3494 + /* for A-device: */
3495 + | (0 << 20) /* 200ms nominal A_WAIT_VRISE timer */
3496 + | SRP_DPW /* detect 167+ns SRP pulses */
3497 + | SRP_DATA | SRP_VBUS; /* accept both kinds of SRP pulse */
3498 + omap_writel(l, OTG_SYSCON_2);
3499 +
3500 + omap_writew(DRIVER_SWITCH | OPRT_CHG
3501 + | B_SRP_TMROUT | B_HNP_FAIL
3502 + | A_VBUS_ERR | A_SRP_DETECT | A_REQ_TMROUT,
3503 + OTG_IRQ_EN);
3504 + l = omap_readl(OTG_SYSCON_2);
3505 + l |= OTG_EN;
3506 + omap_writel(l, OTG_SYSCON_2);
3507 +
3508 + return 0;
3509 +}
3510 +
3511 +static int omap_otg_probe(struct platform_device *pdev)
3512 +{
3513 + int ret, err;
3514 +
3515 + tahvo_otg_dev = pdev;
3516 + ret = tahvo_omap_otg_init();
3517 + if (ret != 0) {
3518 + printk(KERN_ERR "tahvo-usb: omap_otg_init failed\n");
3519 + return ret;
3520 + }
3521 +
3522 + err = request_irq(tahvo_otg_dev->resource[1].start,
3523 + omap_otg_irq, IRQF_DISABLED, DRIVER_NAME,
3524 + &tahvo_usb_device);
3525 +
3526 + return err;
3527 +}
3528 +
3529 +static int omap_otg_remove(struct platform_device *pdev)
3530 +{
3531 + free_irq(tahvo_otg_dev->resource[1].start, &tahvo_usb_device);
3532 + tahvo_otg_dev = NULL;
3533 +
3534 + return 0;
3535 +}
3536 +
3537 +static struct platform_driver omap_otg_driver = {
3538 + .probe = omap_otg_probe,
3539 + .remove = omap_otg_remove,
3540 + .driver = {
3541 + .name = "omap_otg",
3542 + }
3543 +};
3544 +
3545 +/*
3546 + * ---------------------------------------------------------------------------
3547 + * Tahvo related functions
3548 + * These are Nokia proprietary code, except for the OTG register settings,
3549 + * which are copied from isp1301.c
3550 + * ---------------------------------------------------------------------------
3551 + */
3552 +static ssize_t vbus_state_show(struct device *device,
3553 + struct device_attribute *attr, char *buf)
3554 +{
3555 + struct platform_device *pdev = to_platform_device(device);
3556 + struct tahvo_usb *tu = platform_get_drvdata(pdev);
3557 + return sprintf(buf, "%d\n", tu->vbus_state);
3558 +}
3559 +static DEVICE_ATTR(vbus_state, 0444, vbus_state_show, NULL);
3560 +
3561 +int vbus_active = 0;
3562 +
3563 +#if 0
3564 +
3565 +static int host_suspend(struct tahvo_usb *tu)
3566 +{
3567 + struct device *dev;
3568 +
3569 + if (!tu->otg.host)
3570 + return -ENODEV;
3571 +
3572 + /* Currently ASSUMES only the OTG port matters;
3573 + * other ports could be active...
3574 + */
3575 + dev = tu->otg.host->controller;
3576 + return dev->driver->suspend(dev, PMSG_SUSPEND);
3577 +}
3578 +
3579 +static int host_resume(struct tahvo_usb *tu)
3580 +{
3581 + struct device *dev;
3582 +
3583 + if (!tu->otg.host)
3584 + return -ENODEV;
3585 +
3586 + dev = tu->otg.host->controller;
3587 + return dev->driver->resume(dev);
3588 +}
3589 +
3590 +#else
3591 +
3592 +static int host_suspend(struct tahvo_usb *tu)
3593 +{
3594 + return 0;
3595 +}
3596 +
3597 +static int host_resume(struct tahvo_usb *tu)
3598 +{
3599 + return 0;
3600 +}
3601 +
3602 +#endif
3603 +
3604 +static void check_vbus_state(struct tahvo_usb *tu)
3605 +{
3606 + int reg, prev_state;
3607 +
3608 + reg = tahvo_read_reg(TAHVO_REG_IDSR);
3609 + if (reg & 0x01) {
3610 + u32 l;
3611 +
3612 + vbus_active = 1;
3613 + switch (tu->otg.state) {
3614 + case OTG_STATE_B_IDLE:
3615 + /* Enable the gadget driver */
3616 + if (tu->otg.gadget)
3617 + usb_gadget_vbus_connect(tu->otg.gadget);
3618 + /* Set B-session valid and not B-sessio ended to indicate
3619 + * Vbus to be ok. */
3620 + l = omap_readl(OTG_CTRL);
3621 + l &= ~OTG_BSESSEND;
3622 + l |= OTG_BSESSVLD;
3623 + omap_writel(l, OTG_CTRL);
3624 +
3625 + tu->otg.state = OTG_STATE_B_PERIPHERAL;
3626 + break;
3627 + case OTG_STATE_A_IDLE:
3628 + /* Session is now valid assuming the USB hub is driving Vbus */
3629 + tu->otg.state = OTG_STATE_A_HOST;
3630 + host_resume(tu);
3631 + break;
3632 + default:
3633 + break;
3634 + }
3635 + printk("USB cable connected\n");
3636 + } else {
3637 + switch (tu->otg.state) {
3638 + case OTG_STATE_B_PERIPHERAL:
3639 + if (tu->otg.gadget)
3640 + usb_gadget_vbus_disconnect(tu->otg.gadget);
3641 + tu->otg.state = OTG_STATE_B_IDLE;
3642 + break;
3643 + case OTG_STATE_A_HOST:
3644 + tu->otg.state = OTG_STATE_A_IDLE;
3645 + break;
3646 + default:
3647 + break;
3648 + }
3649 + printk("USB cable disconnected\n");
3650 + vbus_active = 0;
3651 + }
3652 +
3653 + prev_state = tu->vbus_state;
3654 + tu->vbus_state = reg & 0x01;
3655 + if (prev_state != tu->vbus_state)
3656 + sysfs_notify(&tu->pt_dev->dev.kobj, NULL, "vbus_state");
3657 +}
3658 +
3659 +static void tahvo_usb_become_host(struct tahvo_usb *tu)
3660 +{
3661 + u32 l;
3662 +
3663 + /* Clear system and transceiver controlled bits
3664 + * also mark the A-session is always valid */
3665 + tahvo_omap_otg_init();
3666 +
3667 + l = omap_readl(OTG_CTRL);
3668 + l &= ~(OTG_CTRL_XCVR_MASK | OTG_CTRL_SYS_MASK);
3669 + l |= OTG_ASESSVLD;
3670 + omap_writel(l, OTG_CTRL);
3671 +
3672 + /* Power up the transceiver in USB host mode */
3673 + tahvo_write_reg(TAHVO_REG_USBR, USBR_REGOUT | USBR_NSUSPEND |
3674 + USBR_MASTER_SW2 | USBR_MASTER_SW1);
3675 + tu->otg.state = OTG_STATE_A_IDLE;
3676 +
3677 + check_vbus_state(tu);
3678 +}
3679 +
3680 +static void tahvo_usb_stop_host(struct tahvo_usb *tu)
3681 +{
3682 + host_suspend(tu);
3683 + tu->otg.state = OTG_STATE_A_IDLE;
3684 +}
3685 +
3686 +static void tahvo_usb_become_peripheral(struct tahvo_usb *tu)
3687 +{
3688 + u32 l;
3689 +
3690 + /* Clear system and transceiver controlled bits
3691 + * and enable ID to mark peripheral mode and
3692 + * BSESSEND to mark no Vbus */
3693 + tahvo_omap_otg_init();
3694 + l = omap_readl(OTG_CTRL);
3695 + l &= ~(OTG_CTRL_XCVR_MASK | OTG_CTRL_SYS_MASK | OTG_BSESSVLD);
3696 + l |= OTG_ID | OTG_BSESSEND;
3697 + omap_writel(l, OTG_CTRL);
3698 +
3699 + /* Power up transceiver and set it in USB perhiperal mode */
3700 + tahvo_write_reg(TAHVO_REG_USBR, USBR_SLAVE_CONTROL | USBR_REGOUT | USBR_NSUSPEND | USBR_SLAVE_SW);
3701 + tu->otg.state = OTG_STATE_B_IDLE;
3702 +
3703 + check_vbus_state(tu);
3704 +}
3705 +
3706 +static void tahvo_usb_stop_peripheral(struct tahvo_usb *tu)
3707 +{
3708 + u32 l;
3709 +
3710 + l = omap_readl(OTG_CTRL);
3711 + l &= ~OTG_BSESSVLD;
3712 + l |= OTG_BSESSEND;
3713 + omap_writel(l, OTG_CTRL);
3714 +
3715 + if (tu->otg.gadget)
3716 + usb_gadget_vbus_disconnect(tu->otg.gadget);
3717 + tu->otg.state = OTG_STATE_B_IDLE;
3718 +
3719 +}
3720 +
3721 +static void tahvo_usb_power_off(struct tahvo_usb *tu)
3722 +{
3723 + u32 l;
3724 + int id;
3725 +
3726 + /* Disable gadget controller if any */
3727 + if (tu->otg.gadget)
3728 + usb_gadget_vbus_disconnect(tu->otg.gadget);
3729 +
3730 + host_suspend(tu);
3731 +
3732 + /* Disable OTG and interrupts */
3733 + if (TAHVO_MODE(tu) == TAHVO_MODE_PERIPHERAL)
3734 + id = OTG_ID;
3735 + else
3736 + id = 0;
3737 + l = omap_readl(OTG_CTRL);
3738 + l &= ~(OTG_CTRL_XCVR_MASK | OTG_CTRL_SYS_MASK | OTG_BSESSVLD);
3739 + l |= id | OTG_BSESSEND;
3740 + omap_writel(l, OTG_CTRL);
3741 + omap_writew(0, OTG_IRQ_EN);
3742 +
3743 + l = omap_readl(OTG_SYSCON_2);
3744 + l &= ~OTG_EN;
3745 + omap_writel(l, OTG_SYSCON_2);
3746 +
3747 + l = omap_readl(OTG_SYSCON_1);
3748 + l |= OTG_IDLE_EN;
3749 + omap_writel(l, OTG_SYSCON_1);
3750 +
3751 + /* Power off transceiver */
3752 + tahvo_write_reg(TAHVO_REG_USBR, 0);
3753 + tu->otg.state = OTG_STATE_UNDEFINED;
3754 +}
3755 +
3756 +
3757 +static int tahvo_usb_set_power(struct otg_transceiver *dev, unsigned mA)
3758 +{
3759 + struct tahvo_usb *tu = container_of(dev, struct tahvo_usb, otg);
3760 +
3761 + dev_dbg(&tu->pt_dev->dev, "set_power %d mA\n", mA);
3762 +
3763 + if (dev->state == OTG_STATE_B_PERIPHERAL) {
3764 + /* REVISIT: Can Tahvo charge battery from VBUS? */
3765 + }
3766 + return 0;
3767 +}
3768 +
3769 +static int tahvo_usb_set_suspend(struct otg_transceiver *dev, int suspend)
3770 +{
3771 + struct tahvo_usb *tu = container_of(dev, struct tahvo_usb, otg);
3772 + u16 w;
3773 +
3774 + dev_dbg(&tu->pt_dev->dev, "set_suspend\n");
3775 +
3776 + w = tahvo_read_reg(TAHVO_REG_USBR);
3777 + if (suspend)
3778 + w &= ~USBR_NSUSPEND;
3779 + else
3780 + w |= USBR_NSUSPEND;
3781 + tahvo_write_reg(TAHVO_REG_USBR, w);
3782 +
3783 + return 0;
3784 +}
3785 +
3786 +static int tahvo_usb_start_srp(struct otg_transceiver *dev)
3787 +{
3788 + struct tahvo_usb *tu = container_of(dev, struct tahvo_usb, otg);
3789 + u32 otg_ctrl;
3790 +
3791 + dev_dbg(&tu->pt_dev->dev, "start_srp\n");
3792 +
3793 + if (!dev || tu->otg.state != OTG_STATE_B_IDLE)
3794 + return -ENODEV;
3795 +
3796 + otg_ctrl = omap_readl(OTG_CTRL);
3797 + if (!(otg_ctrl & OTG_BSESSEND))
3798 + return -EINVAL;
3799 +
3800 + otg_ctrl |= OTG_B_BUSREQ;
3801 + otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_SYS_MASK;
3802 + omap_writel(otg_ctrl, OTG_CTRL);
3803 + tu->otg.state = OTG_STATE_B_SRP_INIT;
3804 +
3805 + return 0;
3806 +}
3807 +
3808 +static int tahvo_usb_start_hnp(struct otg_transceiver *otg)
3809 +{
3810 + struct tahvo_usb *tu = container_of(otg, struct tahvo_usb, otg);
3811 +
3812 + dev_dbg(&tu->pt_dev->dev, "start_hnp\n");
3813 +#ifdef CONFIG_USB_OTG
3814 + /* REVISIT: Add this for OTG */
3815 +#endif
3816 + return -EINVAL;
3817 +}
3818 +
3819 +static int tahvo_usb_set_host(struct otg_transceiver *otg, struct usb_bus *host)
3820 +{
3821 + struct tahvo_usb *tu = container_of(otg, struct tahvo_usb, otg);
3822 + u32 l;
3823 +
3824 + dev_dbg(&tu->pt_dev->dev, "set_host %p\n", host);
3825 +
3826 + if (otg == NULL)
3827 + return -ENODEV;
3828 +
3829 +#if defined(CONFIG_USB_OTG) || !defined(CONFIG_USB_GADGET_OMAP)
3830 +
3831 + mutex_lock(&tu->serialize);
3832 +
3833 + if (host == NULL) {
3834 + if (TAHVO_MODE(tu) == TAHVO_MODE_HOST)
3835 + tahvo_usb_power_off(tu);
3836 + tu->otg.host = NULL;
3837 + mutex_unlock(&tu->serialize);
3838 + return 0;
3839 + }
3840 +
3841 + l = omap_readl(OTG_SYSCON_1);
3842 + l &= ~(OTG_IDLE_EN | HST_IDLE_EN | DEV_IDLE_EN);
3843 + omap_writel(l, OTG_SYSCON_1);
3844 +
3845 + if (TAHVO_MODE(tu) == TAHVO_MODE_HOST) {
3846 + tu->otg.host = NULL;
3847 + tahvo_usb_become_host(tu);
3848 + } else
3849 + host_suspend(tu);
3850 +
3851 + tu->otg.host = host;
3852 +
3853 + mutex_unlock(&tu->serialize);
3854 +#else
3855 + /* No host mode configured, so do not allow host controlled to be set */
3856 + return -EINVAL;
3857 +#endif
3858 +
3859 + return 0;
3860 +}
3861 +
3862 +static int tahvo_usb_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget)
3863 +{
3864 + struct tahvo_usb *tu = container_of(otg, struct tahvo_usb, otg);
3865 +
3866 + dev_dbg(&tu->pt_dev->dev, "set_peripheral %p\n", gadget);
3867 +
3868 + if (!otg)
3869 + return -ENODEV;
3870 +
3871 +#if defined(CONFIG_USB_OTG) || defined(CONFIG_USB_GADGET_OMAP)
3872 +
3873 + mutex_lock(&tu->serialize);
3874 +
3875 + if (!gadget) {
3876 + if (TAHVO_MODE(tu) == TAHVO_MODE_PERIPHERAL)
3877 + tahvo_usb_power_off(tu);
3878 + tu->otg.gadget = NULL;
3879 + mutex_unlock(&tu->serialize);
3880 + return 0;
3881 + }
3882 +
3883 + tu->otg.gadget = gadget;
3884 + if (TAHVO_MODE(tu) == TAHVO_MODE_PERIPHERAL)
3885 + tahvo_usb_become_peripheral(tu);
3886 +
3887 + mutex_unlock(&tu->serialize);
3888 +#else
3889 + /* No gadget mode configured, so do not allow host controlled to be set */
3890 + return -EINVAL;
3891 +#endif
3892 +
3893 + return 0;
3894 +}
3895 +
3896 +static void tahvo_usb_irq_work(struct work_struct *work)
3897 +{
3898 + struct tahvo_usb *tu = container_of(work, struct tahvo_usb, irq_work);
3899 +
3900 + mutex_lock(&tu->serialize);
3901 + check_vbus_state(tu);
3902 + mutex_unlock(&tu->serialize);
3903 +}
3904 +
3905 +static void tahvo_usb_vbus_interrupt(unsigned long arg)
3906 +{
3907 + struct tahvo_usb *tu = (struct tahvo_usb *) arg;
3908 +
3909 + tahvo_ack_irq(TAHVO_INT_VBUSON);
3910 + /* Seems we need this to acknowledge the interrupt */
3911 + tahvo_read_reg(TAHVO_REG_IDSR);
3912 + schedule_work(&tu->irq_work);
3913 +}
3914 +
3915 +#ifdef CONFIG_USB_OTG
3916 +static ssize_t otg_mode_show(struct device *device,
3917 + struct device_attribute *attr, char *buf)
3918 +{
3919 + struct platform_device *pdev = to_platform_device(device);
3920 + struct tahvo_usb *tu = platform_get_drvdata(pdev);
3921 +
3922 + switch (tu->tahvo_mode) {
3923 + case TAHVO_MODE_HOST:
3924 + return sprintf(buf, "host\n");
3925 + case TAHVO_MODE_PERIPHERAL:
3926 + return sprintf(buf, "peripheral\n");
3927 + }
3928 +
3929 + return sprintf(buf, "unknown\n");
3930 +}
3931 +
3932 +static ssize_t otg_mode_store(struct device *device,
3933 + struct device_attribute *attr,
3934 + const char *buf, size_t count)
3935 +{
3936 + struct platform_device *pdev = to_platform_device(device);
3937 + struct tahvo_usb *tu = platform_get_drvdata(pdev);
3938 + int r;
3939 +
3940 + r = strlen(buf);
3941 + mutex_lock(&tu->serialize);
3942 + if (strncmp(buf, "host", 4) == 0) {
3943 + if (tu->tahvo_mode == TAHVO_MODE_PERIPHERAL)
3944 + tahvo_usb_stop_peripheral(tu);
3945 + tu->tahvo_mode = TAHVO_MODE_HOST;
3946 + if (tu->otg.host) {
3947 + printk(KERN_INFO "Selected HOST mode: host controller present.\n");
3948 + tahvo_usb_become_host(tu);
3949 + } else {
3950 + printk(KERN_INFO "Selected HOST mode: no host controller, powering off.\n");
3951 + tahvo_usb_power_off(tu);
3952 + }
3953 + } else if (strncmp(buf, "peripheral", 10) == 0) {
3954 + if (tu->tahvo_mode == TAHVO_MODE_HOST)
3955 + tahvo_usb_stop_host(tu);
3956 + tu->tahvo_mode = TAHVO_MODE_PERIPHERAL;
3957 + if (tu->otg.gadget) {
3958 + printk(KERN_INFO "Selected PERIPHERAL mode: gadget driver present.\n");
3959 + tahvo_usb_become_peripheral(tu);
3960 + } else {
3961 + printk(KERN_INFO "Selected PERIPHERAL mode: no gadget driver, powering off.\n");
3962 + tahvo_usb_power_off(tu);
3963 + }
3964 + } else
3965 + r = -EINVAL;
3966 +
3967 + mutex_unlock(&tu->serialize);
3968 + return r;
3969 +}
3970 +
3971 +static DEVICE_ATTR(otg_mode, 0644, otg_mode_show, otg_mode_store);
3972 +#endif
3973 +
3974 +static int tahvo_usb_probe(struct platform_device *pdev)
3975 +{
3976 + struct tahvo_usb *tu;
3977 + int ret;
3978 +
3979 + dev_dbg(&pdev->dev, "probe\n");
3980 +
3981 + /* Create driver data */
3982 + tu = kmalloc(sizeof(*tu), GFP_KERNEL);
3983 + if (!tu)
3984 + return -ENOMEM;
3985 + memset(tu, 0, sizeof(*tu));
3986 + tu->pt_dev = pdev;
3987 +#ifdef CONFIG_USB_OTG
3988 + /* Default mode */
3989 +#ifdef CONFIG_CBUS_TAHVO_USB_HOST_BY_DEFAULT
3990 + tu->tahvo_mode = TAHVO_MODE_HOST;
3991 +#else
3992 + tu->tahvo_mode = TAHVO_MODE_PERIPHERAL;
3993 +#endif
3994 +#endif
3995 +
3996 + INIT_WORK(&tu->irq_work, tahvo_usb_irq_work);
3997 + mutex_init(&tu->serialize);
3998 +
3999 + /* Set initial state, so that we generate kevents only on
4000 + * state changes */
4001 + tu->vbus_state = tahvo_read_reg(TAHVO_REG_IDSR) & 0x01;
4002 +
4003 + /* We cannot enable interrupt until omap_udc is initialized */
4004 + ret = tahvo_request_irq(TAHVO_INT_VBUSON, tahvo_usb_vbus_interrupt,
4005 + (unsigned long) tu, "vbus_interrupt");
4006 + if (ret != 0) {
4007 + kfree(tu);
4008 + printk(KERN_ERR "Could not register Tahvo interrupt for VBUS\n");
4009 + return ret;
4010 + }
4011 +
4012 + /* Attributes */
4013 + ret = device_create_file(&pdev->dev, &dev_attr_vbus_state);
4014 +#ifdef CONFIG_USB_OTG
4015 + ret |= device_create_file(&pdev->dev, &dev_attr_otg_mode);
4016 +#endif
4017 + if (ret)
4018 + printk(KERN_ERR "attribute creation failed: %d\n", ret);
4019 +
4020 + /* Create OTG interface */
4021 + tahvo_usb_power_off(tu);
4022 + tu->otg.state = OTG_STATE_UNDEFINED;
4023 + tu->otg.label = DRIVER_NAME;
4024 + tu->otg.set_host = tahvo_usb_set_host;
4025 + tu->otg.set_peripheral = tahvo_usb_set_peripheral;
4026 + tu->otg.set_power = tahvo_usb_set_power;
4027 + tu->otg.set_suspend = tahvo_usb_set_suspend;
4028 + tu->otg.start_srp = tahvo_usb_start_srp;
4029 + tu->otg.start_hnp = tahvo_usb_start_hnp;
4030 +
4031 + ret = otg_set_transceiver(&tu->otg);
4032 + if (ret < 0) {
4033 + printk(KERN_ERR "Cannot register USB transceiver\n");
4034 + kfree(tu);
4035 + tahvo_free_irq(TAHVO_INT_VBUSON);
4036 + return ret;
4037 + }
4038 +
4039 + platform_set_drvdata(pdev, tu);
4040 +
4041 + /* Act upon current vbus state once at startup. A vbus state irq may or
4042 + * may not be generated in addition to this. */
4043 + schedule_work(&tu->irq_work);
4044 + return 0;
4045 +}
4046 +
4047 +static int tahvo_usb_remove(struct platform_device *pdev)
4048 +{
4049 + dev_dbg(&pdev->dev, "remove\n");
4050 +
4051 + tahvo_free_irq(TAHVO_INT_VBUSON);
4052 + flush_scheduled_work();
4053 + otg_set_transceiver(0);
4054 + device_remove_file(&pdev->dev, &dev_attr_vbus_state);
4055 +#ifdef CONFIG_USB_OTG
4056 + device_remove_file(&pdev->dev, &dev_attr_otg_mode);
4057 +#endif
4058 + return 0;
4059 +}
4060 +
4061 +static struct platform_driver tahvo_usb_driver = {
4062 + .probe = tahvo_usb_probe,
4063 + .remove = tahvo_usb_remove,
4064 + .driver = {
4065 + .name = "tahvo-usb",
4066 + }
4067 +};
4068 +
4069 +static struct platform_device tahvo_usb_device = {
4070 + .name = "tahvo-usb",
4071 + .id = -1,
4072 +};
4073 +
4074 +static int __init tahvo_usb_init(void)
4075 +{
4076 + int ret = 0;
4077 +
4078 + printk(KERN_INFO "Tahvo USB transceiver driver initializing\n");
4079 +
4080 + ret = platform_driver_register(&tahvo_usb_driver);
4081 + if (ret)
4082 + return ret;
4083 + ret = platform_driver_register(&omap_otg_driver);
4084 + if (ret) {
4085 + platform_driver_unregister(&tahvo_usb_driver);
4086 + return ret;
4087 + }
4088 +
4089 + ret = platform_device_register(&tahvo_usb_device);
4090 + if (ret) {
4091 + platform_driver_unregister(&omap_otg_driver);
4092 + platform_driver_unregister(&tahvo_usb_driver);
4093 + return ret;
4094 + }
4095 +
4096 + return 0;
4097 +}
4098 +subsys_initcall(tahvo_usb_init);
4099 +
4100 +static void __exit tahvo_usb_exit(void)
4101 +{
4102 + platform_device_unregister(&tahvo_usb_device);
4103 + platform_driver_unregister(&omap_otg_driver);
4104 + platform_driver_unregister(&tahvo_usb_driver);
4105 +}
4106 +module_exit(tahvo_usb_exit);
4107 +
4108 +MODULE_DESCRIPTION("Tahvo USB OTG Transceiver Driver");
4109 +MODULE_LICENSE("GPL");
4110 +MODULE_AUTHOR("Juha Yrjölä, Tony Lindgren, and Timo Teräs");
4111 --- /dev/null
4112 +++ linux-2.6.36-rc7/drivers/cbus/tahvo-user.c
4113 @@ -0,0 +1,406 @@
4114 +/**
4115 + * drivers/cbus/tahvo-user.c
4116 + *
4117 + * Tahvo user space interface functions
4118 + *
4119 + * Copyright (C) 2004, 2005 Nokia Corporation
4120 + *
4121 + * Written by Mikko Ylinen <mikko.k.ylinen@nokia.com>
4122 + *
4123 + * This file is subject to the terms and conditions of the GNU General
4124 + * Public License. See the file "COPYING" in the main directory of this
4125 + * archive for more details.
4126 + *
4127 + * This program is distributed in the hope that it will be useful,
4128 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
4129 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4130 + * GNU General Public License for more details.
4131 + *
4132 + * You should have received a copy of the GNU General Public License
4133 + * along with this program; if not, write to the Free Software
4134 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
4135 + */
4136 +
4137 +#include <linux/types.h>
4138 +#include <linux/kernel.h>
4139 +#include <linux/interrupt.h>
4140 +#include <linux/module.h>
4141 +#include <linux/init.h>
4142 +#include <linux/fs.h>
4143 +#include <linux/miscdevice.h>
4144 +#include <linux/poll.h>
4145 +#include <linux/list.h>
4146 +#include <linux/spinlock.h>
4147 +#include <linux/sched.h>
4148 +#include <linux/mutex.h>
4149 +#include <linux/slab.h>
4150 +
4151 +#include <asm/uaccess.h>
4152 +
4153 +#include "tahvo.h"
4154 +
4155 +#include "user_retu_tahvo.h"
4156 +
4157 +/* Maximum size of IRQ node buffer/pool */
4158 +#define TAHVO_MAX_IRQ_BUF_LEN 16
4159 +
4160 +#define PFX "tahvo-user: "
4161 +
4162 +/* Bitmap for marking the interrupt sources as having the handlers */
4163 +static u32 tahvo_irq_bits;
4164 +
4165 +/* For allowing only one user process to subscribe to the tahvo interrupts */
4166 +static struct file *tahvo_irq_subscr = NULL;
4167 +
4168 +/* For poll and IRQ passing */
4169 +struct tahvo_irq {
4170 + u32 id;
4171 + struct list_head node;
4172 +};
4173 +
4174 +static spinlock_t tahvo_irqs_lock;
4175 +static struct tahvo_irq *tahvo_irq_block;
4176 +static LIST_HEAD(tahvo_irqs);
4177 +static LIST_HEAD(tahvo_irqs_reserve);
4178 +
4179 +/* Wait queue - used when user wants to read the device */
4180 +DECLARE_WAIT_QUEUE_HEAD(tahvo_user_waitqueue);
4181 +
4182 +/* Semaphore to protect irq subscription sequence */
4183 +static struct mutex tahvo_mutex;
4184 +
4185 +/* This array specifies TAHVO register types (read/write/toggle) */
4186 +static const u8 tahvo_access_bits[] = {
4187 + 1,
4188 + 4,
4189 + 1,
4190 + 3,
4191 + 3,
4192 + 3,
4193 + 3,
4194 + 3,
4195 + 3,
4196 + 3,
4197 + 3,
4198 + 3,
4199 + 3,
4200 + 1
4201 +};
4202 +
4203 +/*
4204 + * The handler for all TAHVO interrupts.
4205 + *
4206 + * arg is the interrupt source in TAHVO.
4207 + */
4208 +static void tahvo_user_irq_handler(unsigned long arg)
4209 +{
4210 + struct tahvo_irq *irq;
4211 +
4212 + /* user has to re-enable the interrupt once ready
4213 + * for receiving them again */
4214 + tahvo_disable_irq(arg);
4215 + tahvo_ack_irq(arg);
4216 +
4217 + spin_lock(&tahvo_irqs_lock);
4218 + if (list_empty(&tahvo_irqs_reserve)) {
4219 + spin_unlock(&tahvo_irqs_lock);
4220 + return;
4221 + }
4222 + irq = list_entry((&tahvo_irqs_reserve)->next, struct tahvo_irq, node);
4223 + irq->id = arg;
4224 + list_move_tail(&irq->node, &tahvo_irqs);
4225 + spin_unlock(&tahvo_irqs_lock);
4226 +
4227 + /* wake up waiting thread */
4228 + wake_up(&tahvo_user_waitqueue);
4229 +}
4230 +
4231 +/*
4232 + * This routine sets up the interrupt handler and marks an interrupt source
4233 + * in TAHVO as a candidate for signal delivery to the user process.
4234 + */
4235 +static int tahvo_user_subscribe_to_irq(int id, struct file *filp)
4236 +{
4237 + int ret;
4238 +
4239 + mutex_lock(&tahvo_mutex);
4240 + if ((tahvo_irq_subscr != NULL) && (tahvo_irq_subscr != filp)) {
4241 + mutex_unlock(&tahvo_mutex);
4242 + return -EBUSY;
4243 + }
4244 + /* Store the file pointer of the first user process registering IRQs */
4245 + tahvo_irq_subscr = filp;
4246 + mutex_unlock(&tahvo_mutex);
4247 +
4248 + if (tahvo_irq_bits & (1 << id))
4249 + return 0;
4250 +
4251 + ret = tahvo_request_irq(id, tahvo_user_irq_handler, id, "");
4252 + if (ret < 0)
4253 + return ret;
4254 +
4255 + /* Mark that this interrupt has a handler */
4256 + tahvo_irq_bits |= 1 << id;
4257 +
4258 + return 0;
4259 +}
4260 +
4261 +/*
4262 + * Unregister all TAHVO interrupt handlers
4263 + */
4264 +static void tahvo_unreg_irq_handlers(void)
4265 +{
4266 + int id;
4267 +
4268 + if (!tahvo_irq_bits)
4269 + return;
4270 +
4271 + for (id = 0; id < MAX_TAHVO_IRQ_HANDLERS; id++)
4272 + if (tahvo_irq_bits & (1 << id))
4273 + tahvo_free_irq(id);
4274 +
4275 + tahvo_irq_bits = 0;
4276 +}
4277 +
4278 +/*
4279 + * Write to TAHVO register.
4280 + * Returns 0 upon success, a negative error value otherwise.
4281 + */
4282 +static int tahvo_user_write_with_mask(u32 field, u16 value)
4283 +{
4284 + u32 mask;
4285 + u32 reg;
4286 + u_short tmp;
4287 + unsigned long flags;
4288 +
4289 + mask = MASK(field);
4290 + reg = REG(field);
4291 +
4292 + /* Detect bad mask and reg */
4293 + if (mask == 0 || reg > TAHVO_REG_MAX ||
4294 + tahvo_access_bits[reg] == READ_ONLY) {
4295 + printk(KERN_ERR PFX "invalid arguments (reg=%#x, mask=%#x)\n",
4296 + reg, mask);
4297 + return -EINVAL;
4298 + }
4299 +
4300 + /* Justify value according to mask */
4301 + while (!(mask & 1)) {
4302 + value = value << 1;
4303 + mask = mask >> 1;
4304 + }
4305 +
4306 + spin_lock_irqsave(&tahvo_lock, flags);
4307 + if (tahvo_access_bits[reg] == TOGGLE) {
4308 + /* No need to detect previous content of register */
4309 + tmp = 0;
4310 + } else {
4311 + /* Read current value of register */
4312 + tmp = tahvo_read_reg(reg);
4313 + }
4314 + /* Generate a new value */
4315 + tmp = (tmp & ~MASK(field)) | (value & MASK(field));
4316 + /* Write data to TAHVO */
4317 + tahvo_write_reg(reg, tmp);
4318 + spin_unlock_irqrestore(&tahvo_lock, flags);
4319 +
4320 + return 0;
4321 +}
4322 +
4323 +/*
4324 + * Read TAHVO register.
4325 + */
4326 +static u32 tahvo_user_read_with_mask(u32 field)
4327 +{
4328 + u_short value;
4329 + u32 mask, reg;
4330 +
4331 + mask = MASK(field);
4332 + reg = REG(field);
4333 +
4334 + /* Detect bad mask and reg */
4335 + if (mask == 0 || reg > TAHVO_REG_MAX) {
4336 + printk(KERN_ERR PFX "invalid arguments (reg=%#x, mask=%#x)\n",
4337 + reg, mask);
4338 + return -EINVAL;
4339 + }
4340 +
4341 + /* Read the register */
4342 + value = tahvo_read_reg(reg) & mask;
4343 +
4344 + /* Right justify value */
4345 + while (!(mask & 1)) {
4346 + value = value >> 1;
4347 + mask = mask >> 1;
4348 + }
4349 +
4350 + return value;
4351 +}
4352 +
4353 +/*
4354 + * Close device
4355 + */
4356 +static int tahvo_close(struct inode *inode, struct file *filp)
4357 +{
4358 + /* Unregister all interrupts that have been registered */
4359 + if (tahvo_irq_subscr == filp) {
4360 + tahvo_unreg_irq_handlers();
4361 + tahvo_irq_subscr = NULL;
4362 + }
4363 +
4364 + return 0;
4365 +}
4366 +
4367 +/*
4368 + * Device control (ioctl)
4369 + */
4370 +static long tahvo_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
4371 +{
4372 + struct retu_tahvo_write_parms par;
4373 + int ret;
4374 +
4375 + switch (cmd) {
4376 + case URT_IOCT_IRQ_SUBSCR:
4377 + return tahvo_user_subscribe_to_irq(arg, filp);
4378 + case TAHVO_IOCH_READ:
4379 + return tahvo_user_read_with_mask(arg);
4380 + case TAHVO_IOCX_WRITE:
4381 + ret = copy_from_user(&par, (void __user *) arg, sizeof(par));
4382 + if (ret)
4383 + printk(KERN_ERR "copy_from_user failed: %d\n", ret);
4384 + par.result = tahvo_user_write_with_mask(par.field, par.value);
4385 + ret = copy_to_user((void __user *) arg, &par, sizeof(par));
4386 + if (ret)
4387 + printk(KERN_ERR "copy_to_user failed: %d\n", ret);
4388 + break;
4389 + default:
4390 + return -ENOIOCTLCMD;
4391 + }
4392 + return 0;
4393 +}
4394 +
4395 +/*
4396 + * Read from device
4397 + */
4398 +static ssize_t tahvo_read(struct file *filp, char *buf, size_t count,
4399 + loff_t * offp)
4400 +{
4401 + struct tahvo_irq *irq;
4402 +
4403 + u32 nr, i;
4404 +
4405 + /* read not permitted if neither filp nor anyone has registered IRQs */
4406 + if (tahvo_irq_subscr != filp)
4407 + return -EPERM;
4408 +
4409 + if ((count < sizeof(u32)) || ((count % sizeof(u32)) != 0))
4410 + return -EINVAL;
4411 +
4412 + nr = count / sizeof(u32);
4413 +
4414 + for (i = 0; i < nr; i++) {
4415 + unsigned long flags;
4416 + u32 irq_id;
4417 + int ret;
4418 +
4419 + ret = wait_event_interruptible(tahvo_user_waitqueue,
4420 + !list_empty(&tahvo_irqs));
4421 + if (ret < 0)
4422 + return ret;
4423 +
4424 + spin_lock_irqsave(&tahvo_irqs_lock, flags);
4425 + irq = list_entry((&tahvo_irqs)->next, struct tahvo_irq, node);
4426 + irq_id = irq->id;
4427 + list_move(&irq->node, &tahvo_irqs_reserve);
4428 + spin_unlock_irqrestore(&tahvo_irqs_lock, flags);
4429 +
4430 + ret = copy_to_user(buf + i * sizeof(irq_id), &irq_id,
4431 + sizeof(irq_id));
4432 + if (ret)
4433 + printk(KERN_ERR "copy_to_user failed: %d\n", ret);
4434 + }
4435 +
4436 + return count;
4437 +}
4438 +
4439 +/*
4440 + * Poll method
4441 + */
4442 +static unsigned tahvo_poll(struct file *filp, struct poll_table_struct *pt)
4443 +{
4444 + if (!list_empty(&tahvo_irqs))
4445 + return POLLIN;
4446 +
4447 + poll_wait(filp, &tahvo_user_waitqueue, pt);
4448 +
4449 + if (!list_empty(&tahvo_irqs))
4450 + return POLLIN;
4451 + else
4452 + return 0;
4453 +}
4454 +
4455 +static struct file_operations tahvo_user_fileops = {
4456 + .owner = THIS_MODULE,
4457 + .unlocked_ioctl = tahvo_ioctl,
4458 + .read = tahvo_read,
4459 + .release = tahvo_close,
4460 + .poll = tahvo_poll
4461 +};
4462 +
4463 +static struct miscdevice tahvo_device = {
4464 + .minor = MISC_DYNAMIC_MINOR,
4465 + .name = "tahvo",
4466 + .fops = &tahvo_user_fileops
4467 +};
4468 +
4469 +/*
4470 + * Initialization
4471 + *
4472 + * @return 0 if successful, error value otherwise.
4473 + */
4474 +int tahvo_user_init(void)
4475 +{
4476 + struct tahvo_irq *irq;
4477 + int res, i;
4478 +
4479 + irq = kmalloc(sizeof(*irq) * TAHVO_MAX_IRQ_BUF_LEN, GFP_KERNEL);
4480 + if (irq == NULL) {
4481 + printk(KERN_ERR PFX "kmalloc failed\n");
4482 + return -ENOMEM;
4483 + }
4484 + memset(irq, 0, sizeof(*irq) * TAHVO_MAX_IRQ_BUF_LEN);
4485 + for (i = 0; i < TAHVO_MAX_IRQ_BUF_LEN; i++)
4486 + list_add(&irq[i].node, &tahvo_irqs_reserve);
4487 +
4488 + tahvo_irq_block = irq;
4489 +
4490 + spin_lock_init(&tahvo_irqs_lock);
4491 + mutex_init(&tahvo_mutex);
4492 +
4493 + /* Request a misc device */
4494 + res = misc_register(&tahvo_device);
4495 + if (res < 0) {
4496 + printk(KERN_ERR PFX "unable to register misc device for %s\n",
4497 + tahvo_device.name);
4498 + kfree(irq);
4499 + return res;
4500 + }
4501 +
4502 + return 0;
4503 +}
4504 +
4505 +/*
4506 + * Cleanup.
4507 + */
4508 +void tahvo_user_cleanup(void)
4509 +{
4510 + /* Unregister our misc device */
4511 + misc_deregister(&tahvo_device);
4512 + /* Unregister and disable all TAHVO interrupts */
4513 + tahvo_unreg_irq_handlers();
4514 + kfree(tahvo_irq_block);
4515 +}
4516 +
4517 +MODULE_DESCRIPTION("Tahvo ASIC user space functions");
4518 +MODULE_LICENSE("GPL");
4519 +MODULE_AUTHOR("Mikko Ylinen");
4520 --- /dev/null
4521 +++ linux-2.6.36-rc7/drivers/cbus/user_retu_tahvo.h
4522 @@ -0,0 +1,75 @@
4523 +/**
4524 + * drivers/cbus/user_retu_tahvo.h
4525 + *
4526 + * Copyright (C) 2004, 2005 Nokia Corporation
4527 + *
4528 + * Written by Mikko Ylinen <mikko.k.ylinen@nokia.com>
4529 + *
4530 + * Definitions and types used by both retu-user and tahvo-user.
4531 + *
4532 + * This file is subject to the terms and conditions of the GNU General
4533 + * Public License. See the file "COPYING" in the main directory of this
4534 + * archive for more details.
4535 + *
4536 + * This program is distributed in the hope that it will be useful,
4537 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
4538 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4539 + * GNU General Public License for more details.
4540 +
4541 + * You should have received a copy of the GNU General Public License
4542 + * along with this program; if not, write to the Free Software
4543 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
4544 + */
4545 +
4546 +#ifndef _USER_RETU_TAHVO_H
4547 +#define _USER_RETU_TAHVO_H
4548 +
4549 +/* Chip IDs */
4550 +#define CHIP_RETU 1
4551 +#define CHIP_TAHVO 2
4552 +
4553 +/* Register access type bits */
4554 +#define READ_ONLY 1
4555 +#define WRITE_ONLY 2
4556 +#define READ_WRITE 3
4557 +#define TOGGLE 4
4558 +
4559 +#define MASK(field) ((u16)(field & 0xFFFF))
4560 +#define REG(field) ((u16)((field >> 16) & 0x3F))
4561 +
4562 +/*** IOCTL definitions. These should be kept in sync with user space **********/
4563 +
4564 +#define URT_IOC_MAGIC '`'
4565 +
4566 +/*
4567 + * IOCTL function naming conventions:
4568 + * ==================================
4569 + * 0 -- No argument and return value
4570 + * S -- Set through a pointer
4571 + * T -- Tell directly with the argument value
4572 + * G -- Reply by setting through a pointer
4573 + * Q -- response is on the return value
4574 + * X -- S and G atomically
4575 + * H -- T and Q atomically
4576 + */
4577 +
4578 +/* General */
4579 +#define URT_IOCT_IRQ_SUBSCR _IO(URT_IOC_MAGIC, 0)
4580 +
4581 +/* RETU */
4582 +#define RETU_IOCH_READ _IO(URT_IOC_MAGIC, 1)
4583 +#define RETU_IOCX_WRITE _IO(URT_IOC_MAGIC, 2)
4584 +#define RETU_IOCH_ADC_READ _IO(URT_IOC_MAGIC, 3)
4585 +
4586 +/* TAHVO */
4587 +#define TAHVO_IOCH_READ _IO(URT_IOC_MAGIC, 4)
4588 +#define TAHVO_IOCX_WRITE _IO(URT_IOC_MAGIC, 5)
4589 +
4590 +/* This structure is used for writing RETU/TAHVO registers */
4591 +struct retu_tahvo_write_parms {
4592 + u32 field;
4593 + u16 value;
4594 + u8 result;
4595 +};
4596 +
4597 +#endif
4598 --- linux-2.6.36-rc7.orig/drivers/Makefile
4599 +++ linux-2.6.36-rc7/drivers/Makefile
4600 @@ -74,7 +74,7 @@ obj-$(CONFIG_GAMEPORT) += input/gamepor
4601 obj-$(CONFIG_INPUT) += input/
4602 obj-$(CONFIG_I2O) += message/
4603 obj-$(CONFIG_RTC_LIB) += rtc/
4604 -obj-y += i2c/ media/
4605 +obj-y += i2c/ media/ cbus/
4606 obj-$(CONFIG_PPS) += pps/
4607 obj-$(CONFIG_W1) += w1/
4608 obj-$(CONFIG_POWER_SUPPLY) += power/
4609 --- linux-2.6.36-rc7.orig/arch/arm/Kconfig
4610 +++ linux-2.6.36-rc7/arch/arm/Kconfig
4611 @@ -1785,6 +1785,10 @@ source "net/Kconfig"
4612
4613 source "drivers/Kconfig"
4614
4615 +if ARCH_OMAP
4616 +source "drivers/cbus/Kconfig"
4617 +endif
4618 +
4619 source "fs/Kconfig"
4620
4621 source "arch/arm/Kconfig.debug"
OpenWrt SVN history