projects / openwrt / svn-archive / archive.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
omap24xx: Update kernel config. This also fixes module loading.
[openwrt/svn-archive/archive.git] / target / linux / omap24xx / patches-2.6.35 / 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 | 425 ++++++++++++++++++++++
12 drivers/cbus/retu-wdt.c | 388 ++++++++++++++++++++
13 drivers/cbus/retu.c | 468 ++++++++++++++++++++++++
14 drivers/cbus/retu.h | 77 ++++
15 drivers/cbus/tahvo-usb.c | 777 +++++++++++++++++++++++++++++++++++++++++
16 drivers/cbus/tahvo-user.c | 407 +++++++++++++++++++++
17 drivers/cbus/tahvo.c | 443 +++++++++++++++++++++++
18 drivers/cbus/tahvo.h | 61 +++
19 drivers/cbus/user_retu_tahvo.h | 75 +++
20 18 files changed, 4525 insertions(+), 1 deletion(-)
21
22 --- /dev/null
23 +++ linux-2.6.35/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.35/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.35/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.35/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.35/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.35/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.35/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.35/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.35/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.35/drivers/cbus/retu-user.c
1995 @@ -0,0 +1,425 @@
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 int retu_ioctl(struct inode *inode, struct file *filp,
2269 + unsigned int cmd, unsigned long arg)
2270 +{
2271 + struct retu_tahvo_write_parms par;
2272 + int ret;
2273 +
2274 + switch (cmd) {
2275 + case URT_IOCT_IRQ_SUBSCR:
2276 + return retu_user_subscribe_to_irq(arg, filp);
2277 + case RETU_IOCH_READ:
2278 + return retu_user_read_with_mask(arg);
2279 + case RETU_IOCX_WRITE:
2280 + ret = copy_from_user(&par, (void __user *) arg, sizeof(par));
2281 + if (ret)
2282 + printk(KERN_ERR "copy_from_user failed: %d\n", ret);
2283 + par.result = retu_user_write_with_mask(par.field, par.value);
2284 + ret = copy_to_user((void __user *) arg, &par, sizeof(par));
2285 + if (ret)
2286 + printk(KERN_ERR "copy_to_user failed: %d\n", ret);
2287 + break;
2288 + case RETU_IOCH_ADC_READ:
2289 + return retu_read_adc(arg);
2290 + default:
2291 + return -ENOIOCTLCMD;
2292 + }
2293 + return 0;
2294 +}
2295 +
2296 +/*
2297 + * Read from device
2298 + */
2299 +static ssize_t retu_read(struct file *filp, char *buf, size_t count,
2300 + loff_t * offp)
2301 +{
2302 + struct retu_irq *irq;
2303 +
2304 + u32 nr, i;
2305 +
2306 + /* read not permitted if neither filp nor anyone has registered IRQs */
2307 + if (retu_irq_subscr != filp)
2308 + return -EPERM;
2309 +
2310 + if ((count < sizeof(u32)) || ((count % sizeof(u32)) != 0))
2311 + return -EINVAL;
2312 +
2313 + nr = count / sizeof(u32);
2314 +
2315 + for (i = 0; i < nr; i++) {
2316 + unsigned long flags;
2317 + u32 irq_id;
2318 + int ret;
2319 +
2320 + ret = wait_event_interruptible(retu_user_waitqueue,
2321 + !list_empty(&retu_irqs));
2322 + if (ret < 0)
2323 + return ret;
2324 +
2325 + spin_lock_irqsave(&retu_irqs_lock, flags);
2326 + irq = list_entry((&retu_irqs)->next, struct retu_irq, node);
2327 + irq_id = irq->id;
2328 + list_move(&irq->node, &retu_irqs_reserve);
2329 + spin_unlock_irqrestore(&retu_irqs_lock, flags);
2330 +
2331 + ret = copy_to_user(buf + i * sizeof(irq_id), &irq_id,
2332 + sizeof(irq_id));
2333 + if (ret)
2334 + printk(KERN_ERR "copy_to_user failed: %d\n", ret);
2335 + }
2336 +
2337 + return count;
2338 +}
2339 +
2340 +/*
2341 + * Poll method
2342 + */
2343 +static unsigned retu_poll(struct file *filp, struct poll_table_struct *pt)
2344 +{
2345 + if (!list_empty(&retu_irqs))
2346 + return POLLIN;
2347 +
2348 + poll_wait(filp, &retu_user_waitqueue, pt);
2349 +
2350 + if (!list_empty(&retu_irqs))
2351 + return POLLIN;
2352 + else
2353 + return 0;
2354 +}
2355 +
2356 +static struct file_operations retu_user_fileops = {
2357 + .owner = THIS_MODULE,
2358 + .ioctl = retu_ioctl,
2359 + .read = retu_read,
2360 + .release = retu_close,
2361 + .poll = retu_poll
2362 +};
2363 +
2364 +static struct miscdevice retu_device = {
2365 + .minor = MISC_DYNAMIC_MINOR,
2366 + .name = "retu",
2367 + .fops = &retu_user_fileops
2368 +};
2369 +
2370 +/*
2371 + * Initialization
2372 + *
2373 + * @return 0 if successful, error value otherwise.
2374 + */
2375 +int retu_user_init(void)
2376 +{
2377 + struct retu_irq *irq;
2378 + int res, i;
2379 +
2380 + irq = kmalloc(sizeof(*irq) * RETU_MAX_IRQ_BUF_LEN, GFP_KERNEL);
2381 + if (irq == NULL) {
2382 + printk(KERN_ERR PFX "kmalloc failed\n");
2383 + return -ENOMEM;
2384 + }
2385 + memset(irq, 0, sizeof(*irq) * RETU_MAX_IRQ_BUF_LEN);
2386 + for (i = 0; i < RETU_MAX_IRQ_BUF_LEN; i++)
2387 + list_add(&irq[i].node, &retu_irqs_reserve);
2388 +
2389 + retu_irq_block = irq;
2390 +
2391 + spin_lock_init(&retu_irqs_lock);
2392 + mutex_init(&retu_mutex);
2393 +
2394 + /* Request a misc device */
2395 + res = misc_register(&retu_device);
2396 + if (res < 0) {
2397 + printk(KERN_ERR PFX "unable to register misc device for %s\n",
2398 + retu_device.name);
2399 + kfree(irq);
2400 + return res;
2401 + }
2402 +
2403 + return 0;
2404 +}
2405 +
2406 +/*
2407 + * Cleanup.
2408 + */
2409 +void retu_user_cleanup(void)
2410 +{
2411 + /* Unregister our misc device */
2412 + misc_deregister(&retu_device);
2413 + /* Unregister and disable all RETU interrupts used by this module */
2414 + retu_unreg_irq_handlers();
2415 + kfree(retu_irq_block);
2416 +}
2417 +
2418 +MODULE_DESCRIPTION("Retu ASIC user space functions");
2419 +MODULE_LICENSE("GPL");
2420 +MODULE_AUTHOR("Mikko Ylinen");
2421 --- /dev/null
2422 +++ linux-2.6.35/drivers/cbus/retu-wdt.c
2423 @@ -0,0 +1,388 @@
2424 +/**
2425 + * drivers/cbus/retu-wdt.c
2426 + *
2427 + * Driver for Retu watchdog
2428 + *
2429 + * Copyright (C) 2004, 2005 Nokia Corporation
2430 + *
2431 + * Written by Amit Kucheria <amit.kucheria@nokia.com>
2432 + *
2433 + * This file is subject to the terms and conditions of the GNU General
2434 + * Public License. See the file "COPYING" in the main directory of this
2435 + * archive for more details.
2436 + *
2437 + * This program is distributed in the hope that it will be useful,
2438 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2439 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2440 + * GNU General Public License for more details.
2441 + *
2442 + * You should have received a copy of the GNU General Public License
2443 + * along with this program; if not, write to the Free Software
2444 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
2445 + */
2446 +
2447 +#include <linux/kernel.h>
2448 +#include <linux/module.h>
2449 +#include <linux/device.h>
2450 +#include <linux/init.h>
2451 +#include <linux/fs.h>
2452 +#include <linux/io.h>
2453 +#include <linux/platform_device.h>
2454 +#include <linux/slab.h>
2455 +
2456 +#include <linux/completion.h>
2457 +#include <linux/errno.h>
2458 +#include <linux/moduleparam.h>
2459 +#include <linux/platform_device.h>
2460 +#include <linux/miscdevice.h>
2461 +#include <linux/watchdog.h>
2462 +
2463 +#include <asm/uaccess.h>
2464 +
2465 +#include <plat/prcm.h>
2466 +
2467 +#include "cbus.h"
2468 +#include "retu.h"
2469 +
2470 +/* Watchdog timeout in seconds */
2471 +#define RETU_WDT_MIN_TIMER 0
2472 +#define RETU_WDT_DEFAULT_TIMER 32
2473 +#define RETU_WDT_MAX_TIMER 63
2474 +
2475 +static struct completion retu_wdt_completion;
2476 +static DEFINE_MUTEX(retu_wdt_mutex);
2477 +
2478 +/* Current period of watchdog */
2479 +static unsigned int period_val = RETU_WDT_DEFAULT_TIMER;
2480 +static int counter_param = RETU_WDT_MAX_TIMER;
2481 +
2482 +struct retu_wdt_dev {
2483 + struct device *dev;
2484 + int users;
2485 + struct miscdevice retu_wdt_miscdev;
2486 + struct timer_list ping_timer;
2487 +};
2488 +
2489 +static struct retu_wdt_dev *retu_wdt;
2490 +
2491 +static void retu_wdt_set_ping_timer(unsigned long enable);
2492 +
2493 +static int _retu_modify_counter(unsigned int new)
2494 +{
2495 + retu_write_reg(RETU_REG_WATCHDOG, (u16)new);
2496 +
2497 + return 0;
2498 +}
2499 +
2500 +static int retu_modify_counter(unsigned int new)
2501 +{
2502 + if (new < RETU_WDT_MIN_TIMER || new > RETU_WDT_MAX_TIMER)
2503 + return -EINVAL;
2504 +
2505 + mutex_lock(&retu_wdt_mutex);
2506 + period_val = new;
2507 + _retu_modify_counter(period_val);
2508 + mutex_unlock(&retu_wdt_mutex);
2509 +
2510 + return 0;
2511 +}
2512 +
2513 +static ssize_t retu_wdt_period_show(struct device *dev,
2514 + struct device_attribute *attr, char *buf)
2515 +{
2516 + /* Show current max counter */
2517 + return sprintf(buf, "%u\n", (u16)period_val);
2518 +}
2519 +
2520 +/*
2521 + * Note: This inteface is non-standard and likely to disappear!
2522 + * Use /dev/watchdog instead, that's the standard.
2523 + */
2524 +static ssize_t retu_wdt_period_store(struct device *dev,
2525 + struct device_attribute *attr,
2526 + const char *buf, size_t count)
2527 +{
2528 + unsigned int new_period;
2529 + int ret;
2530 +
2531 +#ifdef CONFIG_WATCHDOG_NOWAYOUT
2532 + retu_wdt_set_ping_timer(0);
2533 +#endif
2534 +
2535 + if (sscanf(buf, "%u", &new_period) != 1) {
2536 + printk(KERN_ALERT "retu_wdt_period_store: Invalid input\n");
2537 + return -EINVAL;
2538 + }
2539 +
2540 + ret = retu_modify_counter(new_period);
2541 + if (ret < 0)
2542 + return ret;
2543 +
2544 + return strnlen(buf, count);
2545 +}
2546 +
2547 +static ssize_t retu_wdt_counter_show(struct device *dev,
2548 + struct device_attribute *attr, char *buf)
2549 +{
2550 + u16 counter;
2551 +
2552 + /* Show current value in watchdog counter */
2553 + counter = retu_read_reg(RETU_REG_WATCHDOG);
2554 +
2555 + /* Only the 5 LSB are important */
2556 + return snprintf(buf, PAGE_SIZE, "%u\n", (counter & 0x3F));
2557 +}
2558 +
2559 +static DEVICE_ATTR(period, S_IRUGO | S_IWUSR, retu_wdt_period_show, \
2560 + retu_wdt_period_store);
2561 +static DEVICE_ATTR(counter, S_IRUGO, retu_wdt_counter_show, NULL);
2562 +
2563 +/*----------------------------------------------------------------------------*/
2564 +
2565 +/*
2566 + * Since retu watchdog cannot be disabled in hardware, we must kick it
2567 + * with a timer until userspace watchdog software takes over. Do this
2568 + * unless /dev/watchdog is open or CONFIG_WATCHDOG_NOWAYOUT is set.
2569 + */
2570 +static void retu_wdt_set_ping_timer(unsigned long enable)
2571 +{
2572 + _retu_modify_counter(RETU_WDT_MAX_TIMER);
2573 + if (enable)
2574 + mod_timer(&retu_wdt->ping_timer,
2575 + jiffies + RETU_WDT_DEFAULT_TIMER * HZ);
2576 + else
2577 + del_timer_sync(&retu_wdt->ping_timer);
2578 +}
2579 +
2580 +static int retu_wdt_open(struct inode *inode, struct file *file)
2581 +{
2582 + if (test_and_set_bit(1, (unsigned long *)&(retu_wdt->users)))
2583 + return -EBUSY;
2584 +
2585 + file->private_data = (void *)retu_wdt;
2586 + retu_wdt_set_ping_timer(0);
2587 +
2588 + return nonseekable_open(inode, file);
2589 +}
2590 +
2591 +static int retu_wdt_release(struct inode *inode, struct file *file)
2592 +{
2593 + struct retu_wdt_dev *wdev = file->private_data;
2594 +
2595 +#ifndef CONFIG_WATCHDOG_NOWAYOUT
2596 + retu_wdt_set_ping_timer(1);
2597 +#endif
2598 + wdev->users = 0;
2599 +
2600 + return 0;
2601 +}
2602 +
2603 +static ssize_t retu_wdt_write(struct file *file, const char __user *data,
2604 + size_t len, loff_t *ppos)
2605 +{
2606 + if (len)
2607 + retu_modify_counter(RETU_WDT_MAX_TIMER);
2608 +
2609 + return len;
2610 +}
2611 +
2612 +static int retu_wdt_ioctl(struct inode *inode, struct file *file,
2613 + unsigned int cmd, unsigned long arg)
2614 +{
2615 + int new_margin;
2616 +
2617 + static struct watchdog_info ident = {
2618 + .identity = "Retu Watchdog",
2619 + .options = WDIOF_SETTIMEOUT,
2620 + .firmware_version = 0,
2621 + };
2622 +
2623 + switch (cmd) {
2624 + default:
2625 + return -ENOTTY;
2626 + case WDIOC_GETSUPPORT:
2627 + return copy_to_user((struct watchdog_info __user *)arg, &ident,
2628 + sizeof(ident));
2629 + case WDIOC_GETSTATUS:
2630 + return put_user(0, (int __user *)arg);
2631 + case WDIOC_GETBOOTSTATUS:
2632 + if (cpu_is_omap16xx())
2633 + return put_user(omap_readw(ARM_SYSST),
2634 + (int __user *)arg);
2635 + if (cpu_is_omap24xx())
2636 + return put_user(omap_prcm_get_reset_sources(),
2637 + (int __user *)arg);
2638 + case WDIOC_KEEPALIVE:
2639 + retu_modify_counter(RETU_WDT_MAX_TIMER);
2640 + break;
2641 + case WDIOC_SETTIMEOUT:
2642 + if (get_user(new_margin, (int __user *)arg))
2643 + return -EFAULT;
2644 + retu_modify_counter(new_margin);
2645 + /* Fall through */
2646 + case WDIOC_GETTIMEOUT:
2647 + return put_user(period_val, (int __user *)arg);
2648 + }
2649 +
2650 + return 0;
2651 +}
2652 +
2653 +/* Start kicking retu watchdog until user space starts doing the kicking */
2654 +static int __init retu_wdt_ping(void)
2655 +{
2656 +
2657 +#ifdef CONFIG_WATCHDOG_NOWAYOUT
2658 + retu_modify_counter(RETU_WDT_MAX_TIMER);
2659 +#else
2660 + retu_wdt_set_ping_timer(1);
2661 +#endif
2662 +
2663 + return 0;
2664 +}
2665 +late_initcall(retu_wdt_ping);
2666 +
2667 +static const struct file_operations retu_wdt_fops = {
2668 + .owner = THIS_MODULE,
2669 + .write = retu_wdt_write,
2670 + .ioctl = retu_wdt_ioctl,
2671 + .open = retu_wdt_open,
2672 + .release = retu_wdt_release,
2673 +};
2674 +
2675 +/*----------------------------------------------------------------------------*/
2676 +
2677 +static int __devinit retu_wdt_probe(struct device *dev)
2678 +{
2679 + struct retu_wdt_dev *wdev;
2680 + int ret;
2681 +
2682 + wdev = kzalloc(sizeof(struct retu_wdt_dev), GFP_KERNEL);
2683 + if (!wdev)
2684 + return -ENOMEM;
2685 +
2686 + wdev->users = 0;
2687 +
2688 + ret = device_create_file(dev, &dev_attr_period);
2689 + if (ret) {
2690 + printk(KERN_ERR "retu_wdt_probe: Error creating "
2691 + "sys device file: period\n");
2692 + goto free1;
2693 + }
2694 +
2695 + ret = device_create_file(dev, &dev_attr_counter);
2696 + if (ret) {
2697 + printk(KERN_ERR "retu_wdt_probe: Error creating "
2698 + "sys device file: counter\n");
2699 + goto free2;
2700 + }
2701 +
2702 + dev_set_drvdata(dev, wdev);
2703 + retu_wdt = wdev;
2704 + wdev->retu_wdt_miscdev.parent = dev;
2705 + wdev->retu_wdt_miscdev.minor = WATCHDOG_MINOR;
2706 + wdev->retu_wdt_miscdev.name = "watchdog";
2707 + wdev->retu_wdt_miscdev.fops = &retu_wdt_fops;
2708 +
2709 + ret = misc_register(&(wdev->retu_wdt_miscdev));
2710 + if (ret)
2711 + goto free3;
2712 +
2713 + setup_timer(&wdev->ping_timer, retu_wdt_set_ping_timer, 1);
2714 +
2715 + /* Kick the watchdog for kernel booting to finish */
2716 + retu_modify_counter(RETU_WDT_MAX_TIMER);
2717 +
2718 + return 0;
2719 +
2720 +free3:
2721 + device_remove_file(dev, &dev_attr_counter);
2722 +
2723 +free2:
2724 + device_remove_file(dev, &dev_attr_period);
2725 +free1:
2726 + kfree(wdev);
2727 +
2728 + return ret;
2729 +}
2730 +
2731 +static int __devexit retu_wdt_remove(struct device *dev)
2732 +{
2733 + struct retu_wdt_dev *wdev;
2734 +
2735 + wdev = dev_get_drvdata(dev);
2736 + misc_deregister(&(wdev->retu_wdt_miscdev));
2737 + device_remove_file(dev, &dev_attr_period);
2738 + device_remove_file(dev, &dev_attr_counter);
2739 + kfree(wdev);
2740 +
2741 + return 0;
2742 +}
2743 +
2744 +static void retu_wdt_device_release(struct device *dev)
2745 +{
2746 + complete(&retu_wdt_completion);
2747 +}
2748 +
2749 +static struct platform_device retu_wdt_device = {
2750 + .name = "retu-watchdog",
2751 + .id = -1,
2752 + .dev = {
2753 + .release = retu_wdt_device_release,
2754 + },
2755 +};
2756 +
2757 +static struct device_driver retu_wdt_driver = {
2758 + .name = "retu-watchdog",
2759 + .bus = &platform_bus_type,
2760 + .probe = retu_wdt_probe,
2761 + .remove = __devexit_p(retu_wdt_remove),
2762 +};
2763 +
2764 +static int __init retu_wdt_init(void)
2765 +{
2766 + int ret;
2767 +
2768 + init_completion(&retu_wdt_completion);
2769 +
2770 + ret = driver_register(&retu_wdt_driver);
2771 + if (ret)
2772 + return ret;
2773 +
2774 + ret = platform_device_register(&retu_wdt_device);
2775 + if (ret)
2776 + goto exit1;
2777 +
2778 + /* passed as module parameter? */
2779 + ret = retu_modify_counter(counter_param);
2780 + if (ret == -EINVAL) {
2781 + ret = retu_modify_counter(RETU_WDT_DEFAULT_TIMER);
2782 + printk(KERN_INFO
2783 + "retu_wdt_init: Intializing to default value\n");
2784 + }
2785 +
2786 + printk(KERN_INFO "Retu watchdog driver initialized\n");
2787 + return ret;
2788 +
2789 +exit1:
2790 + driver_unregister(&retu_wdt_driver);
2791 + wait_for_completion(&retu_wdt_completion);
2792 +
2793 + return ret;
2794 +}
2795 +
2796 +static void __exit retu_wdt_exit(void)
2797 +{
2798 + platform_device_unregister(&retu_wdt_device);
2799 + driver_unregister(&retu_wdt_driver);
2800 +
2801 + wait_for_completion(&retu_wdt_completion);
2802 +}
2803 +
2804 +module_init(retu_wdt_init);
2805 +module_exit(retu_wdt_exit);
2806 +module_param(counter_param, int, 0);
2807 +
2808 +MODULE_DESCRIPTION("Retu WatchDog");
2809 +MODULE_AUTHOR("Amit Kucheria");
2810 +MODULE_LICENSE("GPL");
2811 +
2812 --- /dev/null
2813 +++ linux-2.6.35/drivers/cbus/tahvo.c
2814 @@ -0,0 +1,443 @@
2815 +/**
2816 + * drivers/cbus/tahvo.c
2817 + *
2818 + * Support functions for Tahvo ASIC
2819 + *
2820 + * Copyright (C) 2004, 2005 Nokia Corporation
2821 + *
2822 + * Written by Juha Yrjölä <juha.yrjola@nokia.com>,
2823 + * David Weinehall <david.weinehall@nokia.com>, and
2824 + * Mikko Ylinen <mikko.k.ylinen@nokia.com>
2825 + *
2826 + * This file is subject to the terms and conditions of the GNU General
2827 + * Public License. See the file "COPYING" in the main directory of this
2828 + * archive for more details.
2829 + *
2830 + * This program is distributed in the hope that it will be useful,
2831 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2832 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2833 + * GNU General Public License for more details.
2834 + *
2835 + * You should have received a copy of the GNU General Public License
2836 + * along with this program; if not, write to the Free Software
2837 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
2838 + */
2839 +
2840 +#include <linux/module.h>
2841 +#include <linux/init.h>
2842 +
2843 +#include <linux/kernel.h>
2844 +#include <linux/errno.h>
2845 +#include <linux/device.h>
2846 +#include <linux/miscdevice.h>
2847 +#include <linux/poll.h>
2848 +#include <linux/fs.h>
2849 +#include <linux/irq.h>
2850 +#include <linux/interrupt.h>
2851 +#include <linux/platform_device.h>
2852 +#include <linux/gpio.h>
2853 +
2854 +#include <asm/uaccess.h>
2855 +#include <asm/mach-types.h>
2856 +
2857 +#include <plat/mux.h>
2858 +#include <plat/board.h>
2859 +
2860 +#include "cbus.h"
2861 +#include "tahvo.h"
2862 +
2863 +#define TAHVO_ID 0x02
2864 +#define PFX "tahvo: "
2865 +
2866 +static int tahvo_initialized;
2867 +static int tahvo_irq_pin;
2868 +static int tahvo_is_betty;
2869 +
2870 +static struct tasklet_struct tahvo_tasklet;
2871 +spinlock_t tahvo_lock = SPIN_LOCK_UNLOCKED;
2872 +
2873 +static struct completion device_release;
2874 +
2875 +struct tahvo_irq_handler_desc {
2876 + int (*func)(unsigned long);
2877 + unsigned long arg;
2878 + char name[8];
2879 +};
2880 +
2881 +static struct tahvo_irq_handler_desc tahvo_irq_handlers[MAX_TAHVO_IRQ_HANDLERS];
2882 +
2883 +/**
2884 + * tahvo_read_reg - Read a value from a register in Tahvo
2885 + * @reg: the register to read from
2886 + *
2887 + * This function returns the contents of the specified register
2888 + */
2889 +int tahvo_read_reg(int reg)
2890 +{
2891 + BUG_ON(!tahvo_initialized);
2892 + return cbus_read_reg(cbus_host, TAHVO_ID, reg);
2893 +}
2894 +
2895 +/**
2896 + * tahvo_write_reg - Write a value to a register in Tahvo
2897 + * @reg: the register to write to
2898 + * @reg: the value to write to the register
2899 + *
2900 + * This function writes a value to the specified register
2901 + */
2902 +void tahvo_write_reg(int reg, u16 val)
2903 +{
2904 + BUG_ON(!tahvo_initialized);
2905 + cbus_write_reg(cbus_host, TAHVO_ID, reg, val);
2906 +}
2907 +
2908 +/**
2909 + * tahvo_set_clear_reg_bits - set and clear register bits atomically
2910 + * @reg: the register to write to
2911 + * @bits: the bits to set
2912 + *
2913 + * This function sets and clears the specified Tahvo register bits atomically
2914 + */
2915 +void tahvo_set_clear_reg_bits(int reg, u16 set, u16 clear)
2916 +{
2917 + unsigned long flags;
2918 + u16 w;
2919 +
2920 + spin_lock_irqsave(&tahvo_lock, flags);
2921 + w = tahvo_read_reg(reg);
2922 + w &= ~clear;
2923 + w |= set;
2924 + tahvo_write_reg(reg, w);
2925 + spin_unlock_irqrestore(&tahvo_lock, flags);
2926 +}
2927 +
2928 +/*
2929 + * Disable given TAHVO interrupt
2930 + */
2931 +void tahvo_disable_irq(int id)
2932 +{
2933 + unsigned long flags;
2934 + u16 mask;
2935 +
2936 + spin_lock_irqsave(&tahvo_lock, flags);
2937 + mask = tahvo_read_reg(TAHVO_REG_IMR);
2938 + mask |= 1 << id;
2939 + tahvo_write_reg(TAHVO_REG_IMR, mask);
2940 + spin_unlock_irqrestore(&tahvo_lock, flags);
2941 +}
2942 +
2943 +/*
2944 + * Enable given TAHVO interrupt
2945 + */
2946 +void tahvo_enable_irq(int id)
2947 +{
2948 + unsigned long flags;
2949 + u16 mask;
2950 +
2951 + spin_lock_irqsave(&tahvo_lock, flags);
2952 + mask = tahvo_read_reg(TAHVO_REG_IMR);
2953 + mask &= ~(1 << id);
2954 + tahvo_write_reg(TAHVO_REG_IMR, mask);
2955 + spin_unlock_irqrestore(&tahvo_lock, flags);
2956 +}
2957 +
2958 +/*
2959 + * Acknowledge given TAHVO interrupt
2960 + */
2961 +void tahvo_ack_irq(int id)
2962 +{
2963 + tahvo_write_reg(TAHVO_REG_IDR, 1 << id);
2964 +}
2965 +
2966 +static int tahvo_7bit_backlight;
2967 +
2968 +int tahvo_get_backlight_level(void)
2969 +{
2970 + int mask;
2971 +
2972 + if (tahvo_7bit_backlight)
2973 + mask = 0x7f;
2974 + else
2975 + mask = 0x0f;
2976 + return tahvo_read_reg(TAHVO_REG_LEDPWMR) & mask;
2977 +}
2978 +
2979 +int tahvo_get_max_backlight_level(void)
2980 +{
2981 + if (tahvo_7bit_backlight)
2982 + return 0x7f;
2983 + else
2984 + return 0x0f;
2985 +}
2986 +
2987 +void tahvo_set_backlight_level(int level)
2988 +{
2989 + int max_level;
2990 +
2991 + max_level = tahvo_get_max_backlight_level();
2992 + if (level > max_level)
2993 + level = max_level;
2994 + tahvo_write_reg(TAHVO_REG_LEDPWMR, level);
2995 +}
2996 +
2997 +/*
2998 + * TAHVO interrupt handler. Only schedules the tasklet.
2999 + */
3000 +static irqreturn_t tahvo_irq_handler(int irq, void *dev_id)
3001 +{
3002 + tasklet_schedule(&tahvo_tasklet);
3003 + return IRQ_HANDLED;
3004 +}
3005 +
3006 +/*
3007 + * Tasklet handler
3008 + */
3009 +static void tahvo_tasklet_handler(unsigned long data)
3010 +{
3011 + struct tahvo_irq_handler_desc *hnd;
3012 + u16 id;
3013 + u16 im;
3014 + int i;
3015 +
3016 + for (;;) {
3017 + id = tahvo_read_reg(TAHVO_REG_IDR);
3018 + im = ~tahvo_read_reg(TAHVO_REG_IMR);
3019 + id &= im;
3020 +
3021 + if (!id)
3022 + break;
3023 +
3024 + for (i = 0; id != 0; i++, id >>= 1) {
3025 + if (!(id & 1))
3026 + continue;
3027 + hnd = &tahvo_irq_handlers[i];
3028 + if (hnd->func == NULL) {
3029 + /* Spurious tahvo interrupt - just ack it */
3030 + printk(KERN_INFO "Spurious Tahvo interrupt "
3031 + "(id %d)\n", i);
3032 + tahvo_disable_irq(i);
3033 + tahvo_ack_irq(i);
3034 + continue;
3035 + }
3036 + hnd->func(hnd->arg);
3037 + /*
3038 + * Don't acknowledge the interrupt here
3039 + * It must be done explicitly
3040 + */
3041 + }
3042 + }
3043 +}
3044 +
3045 +/*
3046 + * Register the handler for a given TAHVO interrupt source.
3047 + */
3048 +int tahvo_request_irq(int id, void *irq_handler, unsigned long arg, char *name)
3049 +{
3050 + struct tahvo_irq_handler_desc *hnd;
3051 +
3052 + if (irq_handler == NULL || id >= MAX_TAHVO_IRQ_HANDLERS ||
3053 + name == NULL) {
3054 + printk(KERN_ERR PFX "Invalid arguments to %s\n",
3055 + __FUNCTION__);
3056 + return -EINVAL;
3057 + }
3058 + hnd = &tahvo_irq_handlers[id];
3059 + if (hnd->func != NULL) {
3060 + printk(KERN_ERR PFX "IRQ %d already reserved\n", id);
3061 + return -EBUSY;
3062 + }
3063 + printk(KERN_INFO PFX "Registering interrupt %d for device %s\n",
3064 + id, name);
3065 + hnd->func = irq_handler;
3066 + hnd->arg = arg;
3067 + strlcpy(hnd->name, name, sizeof(hnd->name));
3068 +
3069 + tahvo_ack_irq(id);
3070 + tahvo_enable_irq(id);
3071 +
3072 + return 0;
3073 +}
3074 +
3075 +/*
3076 + * Unregister the handler for a given TAHVO interrupt source.
3077 + */
3078 +void tahvo_free_irq(int id)
3079 +{
3080 + struct tahvo_irq_handler_desc *hnd;
3081 +
3082 + if (id >= MAX_TAHVO_IRQ_HANDLERS) {
3083 + printk(KERN_ERR PFX "Invalid argument to %s\n",
3084 + __FUNCTION__);
3085 + return;
3086 + }
3087 + hnd = &tahvo_irq_handlers[id];
3088 + if (hnd->func == NULL) {
3089 + printk(KERN_ERR PFX "IRQ %d already freed\n", id);
3090 + return;
3091 + }
3092 +
3093 + tahvo_disable_irq(id);
3094 + hnd->func = NULL;
3095 +}
3096 +
3097 +/**
3098 + * tahvo_probe - Probe for Tahvo ASIC
3099 + * @dev: the Tahvo device
3100 + *
3101 + * Probe for the Tahvo ASIC and allocate memory
3102 + * for its device-struct if found
3103 + */
3104 +static int __devinit tahvo_probe(struct device *dev)
3105 +{
3106 + int rev, id, ret;
3107 +
3108 + /* Prepare tasklet */
3109 + tasklet_init(&tahvo_tasklet, tahvo_tasklet_handler, 0);
3110 +
3111 + tahvo_initialized = 1;
3112 +
3113 + rev = tahvo_read_reg(TAHVO_REG_ASICR);
3114 +
3115 + id = (rev >> 8) & 0xff;
3116 + if (id == 0x03) {
3117 + if ((rev & 0xff) >= 0x50)
3118 + tahvo_7bit_backlight = 1;
3119 + } else if (id == 0x0b) {
3120 + tahvo_is_betty = 1;
3121 + tahvo_7bit_backlight = 1;
3122 + } else {
3123 + printk(KERN_ERR "Tahvo/Betty chip not found");
3124 + return -ENODEV;
3125 + }
3126 +
3127 + printk(KERN_INFO "%s v%d.%d found\n", tahvo_is_betty ? "Betty" : "Tahvo",
3128 + (rev >> 4) & 0x0f, rev & 0x0f);
3129 +
3130 + /* REVISIT: Pass these from board-*.c files in platform_data */
3131 + if (machine_is_nokia770()) {
3132 + tahvo_irq_pin = 40;
3133 + } else if (machine_is_nokia_n800() || machine_is_nokia_n810() ||
3134 + machine_is_nokia_n810_wimax()) {
3135 + tahvo_irq_pin = 111;
3136 + } else {
3137 + printk(KERN_ERR "cbus: Unsupported board for tahvo\n");
3138 + return -ENODEV;
3139 + }
3140 +
3141 + if ((ret = gpio_request(tahvo_irq_pin, "TAHVO irq")) < 0) {
3142 + printk(KERN_ERR PFX "Unable to reserve IRQ GPIO\n");
3143 + return ret;
3144 + }
3145 +
3146 + /* Set the pin as input */
3147 + gpio_direction_input(tahvo_irq_pin);
3148 +
3149 + /* Rising edge triggers the IRQ */
3150 + set_irq_type(gpio_to_irq(tahvo_irq_pin), IRQ_TYPE_EDGE_RISING);
3151 +
3152 + /* Mask all TAHVO interrupts */
3153 + tahvo_write_reg(TAHVO_REG_IMR, 0xffff);
3154 +
3155 + ret = request_irq(gpio_to_irq(tahvo_irq_pin), tahvo_irq_handler, 0,
3156 + "tahvo", 0);
3157 + if (ret < 0) {
3158 + printk(KERN_ERR PFX "Unable to register IRQ handler\n");
3159 + gpio_free(tahvo_irq_pin);
3160 + return ret;
3161 + }
3162 +#ifdef CONFIG_CBUS_TAHVO_USER
3163 + /* Initialize user-space interface */
3164 + if (tahvo_user_init() < 0) {
3165 + printk(KERN_ERR "Unable to initialize driver\n");
3166 + free_irq(gpio_to_irq(tahvo_irq_pin), 0);
3167 + gpio_free(tahvo_irq_pin);
3168 + return ret;
3169 + }
3170 +#endif
3171 + return 0;
3172 +}
3173 +
3174 +static int tahvo_remove(struct device *dev)
3175 +{
3176 +#ifdef CONFIG_CBUS_TAHVO_USER
3177 + tahvo_user_cleanup();
3178 +#endif
3179 + /* Mask all TAHVO interrupts */
3180 + tahvo_write_reg(TAHVO_REG_IMR, 0xffff);
3181 + free_irq(gpio_to_irq(tahvo_irq_pin), 0);
3182 + gpio_free(tahvo_irq_pin);
3183 + tasklet_kill(&tahvo_tasklet);
3184 +
3185 + return 0;
3186 +}
3187 +
3188 +static void tahvo_device_release(struct device *dev)
3189 +{
3190 + complete(&device_release);
3191 +}
3192 +
3193 +static struct device_driver tahvo_driver = {
3194 + .name = "tahvo",
3195 + .bus = &platform_bus_type,
3196 + .probe = tahvo_probe,
3197 + .remove = tahvo_remove,
3198 +};
3199 +
3200 +static struct platform_device tahvo_device = {
3201 + .name = "tahvo",
3202 + .id = -1,
3203 + .dev = {
3204 + .release = tahvo_device_release,
3205 + }
3206 +};
3207 +
3208 +/**
3209 + * tahvo_init - initialise Tahvo driver
3210 + *
3211 + * Initialise the Tahvo driver and return 0 if everything worked ok
3212 + */
3213 +static int __init tahvo_init(void)
3214 +{
3215 + int ret = 0;
3216 +
3217 + printk(KERN_INFO "Tahvo/Betty driver initialising\n");
3218 +
3219 + init_completion(&device_release);
3220 +
3221 + if ((ret = driver_register(&tahvo_driver)) < 0)
3222 + return ret;
3223 +
3224 + if ((ret = platform_device_register(&tahvo_device)) < 0) {
3225 + driver_unregister(&tahvo_driver);
3226 + return ret;
3227 + }
3228 + return 0;
3229 +}
3230 +
3231 +/*
3232 + * Cleanup
3233 + */
3234 +static void __exit tahvo_exit(void)
3235 +{
3236 + platform_device_unregister(&tahvo_device);
3237 + driver_unregister(&tahvo_driver);
3238 + wait_for_completion(&device_release);
3239 +}
3240 +
3241 +EXPORT_SYMBOL(tahvo_request_irq);
3242 +EXPORT_SYMBOL(tahvo_free_irq);
3243 +EXPORT_SYMBOL(tahvo_enable_irq);
3244 +EXPORT_SYMBOL(tahvo_disable_irq);
3245 +EXPORT_SYMBOL(tahvo_ack_irq);
3246 +EXPORT_SYMBOL(tahvo_read_reg);
3247 +EXPORT_SYMBOL(tahvo_write_reg);
3248 +EXPORT_SYMBOL(tahvo_get_backlight_level);
3249 +EXPORT_SYMBOL(tahvo_get_max_backlight_level);
3250 +EXPORT_SYMBOL(tahvo_set_backlight_level);
3251 +
3252 +subsys_initcall(tahvo_init);
3253 +module_exit(tahvo_exit);
3254 +
3255 +MODULE_DESCRIPTION("Tahvo ASIC control");
3256 +MODULE_LICENSE("GPL");
3257 +MODULE_AUTHOR("Juha Yrjölä, David Weinehall, and Mikko Ylinen");
3258 --- /dev/null
3259 +++ linux-2.6.35/drivers/cbus/tahvo.h
3260 @@ -0,0 +1,61 @@
3261 +/*
3262 + * drivers/cbus/tahvo.h
3263 + *
3264 + * Copyright (C) 2004, 2005 Nokia Corporation
3265 + *
3266 + * Written by Juha Yrjölä <juha.yrjola@nokia.com> and
3267 + * David Weinehall <david.weinehall@nokia.com>
3268 + *
3269 + * This file is subject to the terms and conditions of the GNU General
3270 + * Public License. See the file "COPYING" in the main directory of this
3271 + * archive for more details.
3272 + *
3273 + * This program is distributed in the hope that it will be useful,
3274 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
3275 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
3276 + * GNU General Public License for more details.
3277 +
3278 + * You should have received a copy of the GNU General Public License
3279 + * along with this program; if not, write to the Free Software
3280 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
3281 + */
3282 +
3283 +#ifndef __DRIVERS_CBUS_TAHVO_H
3284 +#define __DRIVERS_CBUS_TAHVO_H
3285 +
3286 +#include <linux/types.h>
3287 +
3288 +/* Registers */
3289 +#define TAHVO_REG_ASICR 0x00 /* ASIC ID & revision */
3290 +#define TAHVO_REG_IDR 0x01 /* Interrupt ID */
3291 +#define TAHVO_REG_IDSR 0x02 /* Interrupt status */
3292 +#define TAHVO_REG_IMR 0x03 /* Interrupt mask */
3293 +#define TAHVO_REG_LEDPWMR 0x05 /* LED PWM */
3294 +#define TAHVO_REG_USBR 0x06 /* USB control */
3295 +#define TAHVO_REG_MAX 0x0d
3296 +
3297 +/* Interrupt sources */
3298 +#define TAHVO_INT_VBUSON 0
3299 +
3300 +#define MAX_TAHVO_IRQ_HANDLERS 8
3301 +
3302 +int tahvo_read_reg(int reg);
3303 +void tahvo_write_reg(int reg, u16 val);
3304 +void tahvo_set_clear_reg_bits(int reg, u16 set, u16 clear);
3305 +int tahvo_request_irq(int id, void *irq_handler, unsigned long arg, char *name);
3306 +void tahvo_free_irq(int id);
3307 +void tahvo_enable_irq(int id);
3308 +void tahvo_disable_irq(int id);
3309 +void tahvo_ack_irq(int id);
3310 +int tahvo_get_backlight_level(void);
3311 +int tahvo_get_max_backlight_level(void);
3312 +void tahvo_set_backlight_level(int level);
3313 +
3314 +#ifdef CONFIG_CBUS_TAHVO_USER
3315 +int tahvo_user_init(void);
3316 +void tahvo_user_cleanup(void);
3317 +#endif
3318 +
3319 +extern spinlock_t tahvo_lock;
3320 +
3321 +#endif /* __DRIVERS_CBUS_TAHVO_H */
3322 --- /dev/null
3323 +++ linux-2.6.35/drivers/cbus/tahvo-usb.c
3324 @@ -0,0 +1,777 @@
3325 +/**
3326 + * drivers/cbus/tahvo-usb.c
3327 + *
3328 + * Tahvo USB transeiver
3329 + *
3330 + * Copyright (C) 2005-2006 Nokia Corporation
3331 + *
3332 + * Parts copied from drivers/i2c/chips/isp1301_omap.c
3333 + * Copyright (C) 2004 Texas Instruments
3334 + * Copyright (C) 2004 David Brownell
3335 + *
3336 + * Written by Juha Yrjölä <juha.yrjola@nokia.com>,
3337 + * Tony Lindgren <tony@atomide.com>, and
3338 + * Timo Teräs <timo.teras@nokia.com>
3339 + *
3340 + * This file is subject to the terms and conditions of the GNU General
3341 + * Public License. See the file "COPYING" in the main directory of this
3342 + * archive for more details.
3343 + *
3344 + * This program is distributed in the hope that it will be useful,
3345 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
3346 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
3347 + * GNU General Public License for more details.
3348 + *
3349 + * You should have received a copy of the GNU General Public License
3350 + * along with this program; if not, write to the Free Software
3351 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
3352 + */
3353 +
3354 +#include <linux/kernel.h>
3355 +#include <linux/module.h>
3356 +#include <linux/init.h>
3357 +#include <linux/slab.h>
3358 +#include <linux/io.h>
3359 +#include <linux/interrupt.h>
3360 +#include <linux/platform_device.h>
3361 +#include <linux/usb/ch9.h>
3362 +#include <linux/usb/gadget.h>
3363 +#include <linux/usb.h>
3364 +#include <linux/usb/otg.h>
3365 +#include <linux/i2c.h>
3366 +#include <linux/workqueue.h>
3367 +#include <linux/kobject.h>
3368 +#include <linux/clk.h>
3369 +#include <linux/mutex.h>
3370 +
3371 +#include <asm/irq.h>
3372 +#include <plat/usb.h>
3373 +
3374 +#include "cbus.h"
3375 +#include "tahvo.h"
3376 +
3377 +#define DRIVER_NAME "tahvo-usb"
3378 +
3379 +#define USBR_SLAVE_CONTROL (1 << 8)
3380 +#define USBR_VPPVIO_SW (1 << 7)
3381 +#define USBR_SPEED (1 << 6)
3382 +#define USBR_REGOUT (1 << 5)
3383 +#define USBR_MASTER_SW2 (1 << 4)
3384 +#define USBR_MASTER_SW1 (1 << 3)
3385 +#define USBR_SLAVE_SW (1 << 2)
3386 +#define USBR_NSUSPEND (1 << 1)
3387 +#define USBR_SEMODE (1 << 0)
3388 +
3389 +/* bits in OTG_CTRL */
3390 +
3391 +/* Bits that are controlled by OMAP OTG and are read-only */
3392 +#define OTG_CTRL_OMAP_MASK (OTG_PULLDOWN|OTG_PULLUP|OTG_DRV_VBUS|\
3393 + OTG_PD_VBUS|OTG_PU_VBUS|OTG_PU_ID)
3394 +/* Bits that are controlled by transceiver */
3395 +#define OTG_CTRL_XCVR_MASK (OTG_ASESSVLD|OTG_BSESSEND|\
3396 + OTG_BSESSVLD|OTG_VBUSVLD|OTG_ID)
3397 +/* Bits that are controlled by system */
3398 +#define OTG_CTRL_SYS_MASK (OTG_A_BUSREQ|OTG_A_SETB_HNPEN|OTG_B_BUSREQ|\
3399 + OTG_B_HNPEN|OTG_BUSDROP)
3400 +
3401 +#if defined(CONFIG_USB_OHCI_HCD) && !defined(CONFIG_USB_OTG)
3402 +#error tahvo-otg.c does not work with OCHI yet!
3403 +#endif
3404 +
3405 +#define TAHVO_MODE_HOST 0
3406 +#define TAHVO_MODE_PERIPHERAL 1
3407 +
3408 +#ifdef CONFIG_USB_OTG
3409 +#define TAHVO_MODE(tu) (tu)->tahvo_mode
3410 +#elif defined(CONFIG_USB_GADGET_OMAP)
3411 +#define TAHVO_MODE(tu) TAHVO_MODE_PERIPHERAL
3412 +#else
3413 +#define TAHVO_MODE(tu) TAHVO_MODE_HOST
3414 +#endif
3415 +
3416 +struct tahvo_usb {
3417 + struct platform_device *pt_dev;
3418 + struct otg_transceiver otg;
3419 + int vbus_state;
3420 + struct work_struct irq_work;
3421 + struct mutex serialize;
3422 +#ifdef CONFIG_USB_OTG
3423 + int tahvo_mode;
3424 +#endif
3425 +};
3426 +static struct platform_device tahvo_usb_device;
3427 +
3428 +/*
3429 + * ---------------------------------------------------------------------------
3430 + * OTG related functions
3431 + *
3432 + * These shoud be separated into omap-otg.c driver module, as they are used
3433 + * by various transceivers. These functions are needed in the UDC-only case
3434 + * as well. These functions are copied from GPL isp1301_omap.c
3435 + * ---------------------------------------------------------------------------
3436 + */
3437 +static struct platform_device *tahvo_otg_dev;
3438 +
3439 +static irqreturn_t omap_otg_irq(int irq, void *arg)
3440 +{
3441 + struct platform_device *otg_dev = arg;
3442 + struct tahvo_usb *tu = platform_get_drvdata(otg_dev);
3443 + u16 otg_irq;
3444 +
3445 + otg_irq = omap_readw(OTG_IRQ_SRC);
3446 + if (otg_irq & OPRT_CHG) {
3447 + omap_writew(OPRT_CHG, OTG_IRQ_SRC);
3448 + } else if (otg_irq & B_SRP_TMROUT) {
3449 + omap_writew(B_SRP_TMROUT, OTG_IRQ_SRC);
3450 + } else if (otg_irq & B_HNP_FAIL) {
3451 + omap_writew(B_HNP_FAIL, OTG_IRQ_SRC);
3452 + } else if (otg_irq & A_SRP_DETECT) {
3453 + omap_writew(A_SRP_DETECT, OTG_IRQ_SRC);
3454 + } else if (otg_irq & A_REQ_TMROUT) {
3455 + omap_writew(A_REQ_TMROUT, OTG_IRQ_SRC);
3456 + } else if (otg_irq & A_VBUS_ERR) {
3457 + omap_writew(A_VBUS_ERR, OTG_IRQ_SRC);
3458 + } else if (otg_irq & DRIVER_SWITCH) {
3459 + if ((!(omap_readl(OTG_CTRL) & OTG_DRIVER_SEL)) &&
3460 + tu->otg.host && tu->otg.state == OTG_STATE_A_HOST) {
3461 + /* role is host */
3462 + usb_bus_start_enum(tu->otg.host,
3463 + tu->otg.host->otg_port);
3464 + }
3465 + omap_writew(DRIVER_SWITCH, OTG_IRQ_SRC);
3466 + } else
3467 + return IRQ_NONE;
3468 +
3469 + return IRQ_HANDLED;
3470 +
3471 +}
3472 +
3473 +static int omap_otg_init(void)
3474 +{
3475 + u32 l;
3476 +
3477 +#ifdef CONFIG_USB_OTG
3478 + if (!tahvo_otg_dev) {
3479 + printk("tahvo-usb: no tahvo_otg_dev\n");
3480 + return -ENODEV;
3481 + }
3482 +#endif
3483 +
3484 + l = omap_readl(OTG_SYSCON_1);
3485 + l &= ~OTG_IDLE_EN;
3486 + omap_writel(l, OTG_SYSCON_1);
3487 + udelay(100);
3488 +
3489 + /* some of these values are board-specific... */
3490 + l = omap_readl(OTG_SYSCON_2);
3491 + l |= OTG_EN
3492 + /* for B-device: */
3493 + | SRP_GPDATA /* 9msec Bdev D+ pulse */
3494 + | SRP_GPDVBUS /* discharge after VBUS pulse */
3495 + // | (3 << 24) /* 2msec VBUS pulse */
3496 + /* for A-device: */
3497 + | (0 << 20) /* 200ms nominal A_WAIT_VRISE timer */
3498 + | SRP_DPW /* detect 167+ns SRP pulses */
3499 + | SRP_DATA | SRP_VBUS; /* accept both kinds of SRP pulse */
3500 + omap_writel(l, OTG_SYSCON_2);
3501 +
3502 + omap_writew(DRIVER_SWITCH | OPRT_CHG
3503 + | B_SRP_TMROUT | B_HNP_FAIL
3504 + | A_VBUS_ERR | A_SRP_DETECT | A_REQ_TMROUT,
3505 + OTG_IRQ_EN);
3506 + l = omap_readl(OTG_SYSCON_2);
3507 + l |= OTG_EN;
3508 + omap_writel(l, OTG_SYSCON_2);
3509 +
3510 + return 0;
3511 +}
3512 +
3513 +static int omap_otg_probe(struct device *dev)
3514 +{
3515 + int ret;
3516 +
3517 + tahvo_otg_dev = to_platform_device(dev);
3518 + ret = omap_otg_init();
3519 + if (ret != 0) {
3520 + printk(KERN_ERR "tahvo-usb: omap_otg_init failed\n");
3521 + return ret;
3522 + }
3523 +
3524 + return request_irq(tahvo_otg_dev->resource[1].start,
3525 + omap_otg_irq, IRQF_DISABLED, DRIVER_NAME,
3526 + &tahvo_usb_device);
3527 +}
3528 +
3529 +static int omap_otg_remove(struct device *dev)
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 +struct device_driver omap_otg_driver = {
3538 + .name = "omap_otg",
3539 + .bus = &platform_bus_type,
3540 + .probe = omap_otg_probe,
3541 + .remove = omap_otg_remove,
3542 +};
3543 +
3544 +/*
3545 + * ---------------------------------------------------------------------------
3546 + * Tahvo related functions
3547 + * These are Nokia proprietary code, except for the OTG register settings,
3548 + * which are copied from isp1301.c
3549 + * ---------------------------------------------------------------------------
3550 + */
3551 +static ssize_t vbus_state_show(struct device *device,
3552 + struct device_attribute *attr, char *buf)
3553 +{
3554 + struct tahvo_usb *tu = dev_get_drvdata(device);
3555 + return sprintf(buf, "%d\n", tu->vbus_state);
3556 +}
3557 +static DEVICE_ATTR(vbus_state, 0444, vbus_state_show, NULL);
3558 +
3559 +int vbus_active = 0;
3560 +
3561 +#if 0
3562 +
3563 +static int host_suspend(struct tahvo_usb *tu)
3564 +{
3565 + struct device *dev;
3566 +
3567 + if (!tu->otg.host)
3568 + return -ENODEV;
3569 +
3570 + /* Currently ASSUMES only the OTG port matters;
3571 + * other ports could be active...
3572 + */
3573 + dev = tu->otg.host->controller;
3574 + return dev->driver->suspend(dev, PMSG_SUSPEND);
3575 +}
3576 +
3577 +static int host_resume(struct tahvo_usb *tu)
3578 +{
3579 + struct device *dev;
3580 +
3581 + if (!tu->otg.host)
3582 + return -ENODEV;
3583 +
3584 + dev = tu->otg.host->controller;
3585 + return dev->driver->resume(dev);
3586 +}
3587 +
3588 +#else
3589 +
3590 +static int host_suspend(struct tahvo_usb *tu)
3591 +{
3592 + return 0;
3593 +}
3594 +
3595 +static int host_resume(struct tahvo_usb *tu)
3596 +{
3597 + return 0;
3598 +}
3599 +
3600 +#endif
3601 +
3602 +static void check_vbus_state(struct tahvo_usb *tu)
3603 +{
3604 + int reg, prev_state;
3605 +
3606 + reg = tahvo_read_reg(TAHVO_REG_IDSR);
3607 + if (reg & 0x01) {
3608 + u32 l;
3609 +
3610 + vbus_active = 1;
3611 + switch (tu->otg.state) {
3612 + case OTG_STATE_B_IDLE:
3613 + /* Enable the gadget driver */
3614 + if (tu->otg.gadget)
3615 + usb_gadget_vbus_connect(tu->otg.gadget);
3616 + /* Set B-session valid and not B-sessio ended to indicate
3617 + * Vbus to be ok. */
3618 + l = omap_readl(OTG_CTRL);
3619 + l &= ~OTG_BSESSEND;
3620 + l |= OTG_BSESSVLD;
3621 + omap_writel(l, OTG_CTRL);
3622 +
3623 + tu->otg.state = OTG_STATE_B_PERIPHERAL;
3624 + break;
3625 + case OTG_STATE_A_IDLE:
3626 + /* Session is now valid assuming the USB hub is driving Vbus */
3627 + tu->otg.state = OTG_STATE_A_HOST;
3628 + host_resume(tu);
3629 + break;
3630 + default:
3631 + break;
3632 + }
3633 + printk("USB cable connected\n");
3634 + } else {
3635 + switch (tu->otg.state) {
3636 + case OTG_STATE_B_PERIPHERAL:
3637 + if (tu->otg.gadget)
3638 + usb_gadget_vbus_disconnect(tu->otg.gadget);
3639 + tu->otg.state = OTG_STATE_B_IDLE;
3640 + break;
3641 + case OTG_STATE_A_HOST:
3642 + tu->otg.state = OTG_STATE_A_IDLE;
3643 + break;
3644 + default:
3645 + break;
3646 + }
3647 + printk("USB cable disconnected\n");
3648 + vbus_active = 0;
3649 + }
3650 +
3651 + prev_state = tu->vbus_state;
3652 + tu->vbus_state = reg & 0x01;
3653 + if (prev_state != tu->vbus_state)
3654 + sysfs_notify(&tu->pt_dev->dev.kobj, NULL, "vbus_state");
3655 +}
3656 +
3657 +static void tahvo_usb_become_host(struct tahvo_usb *tu)
3658 +{
3659 + u32 l;
3660 +
3661 + /* Clear system and transceiver controlled bits
3662 + * also mark the A-session is always valid */
3663 + omap_otg_init();
3664 +
3665 + l = omap_readl(OTG_CTRL);
3666 + l &= ~(OTG_CTRL_XCVR_MASK | OTG_CTRL_SYS_MASK);
3667 + l |= OTG_ASESSVLD;
3668 + omap_writel(l, OTG_CTRL);
3669 +
3670 + /* Power up the transceiver in USB host mode */
3671 + tahvo_write_reg(TAHVO_REG_USBR, USBR_REGOUT | USBR_NSUSPEND |
3672 + USBR_MASTER_SW2 | USBR_MASTER_SW1);
3673 + tu->otg.state = OTG_STATE_A_IDLE;
3674 +
3675 + check_vbus_state(tu);
3676 +}
3677 +
3678 +static void tahvo_usb_stop_host(struct tahvo_usb *tu)
3679 +{
3680 + host_suspend(tu);
3681 + tu->otg.state = OTG_STATE_A_IDLE;
3682 +}
3683 +
3684 +static void tahvo_usb_become_peripheral(struct tahvo_usb *tu)
3685 +{
3686 + u32 l;
3687 +
3688 + /* Clear system and transceiver controlled bits
3689 + * and enable ID to mark peripheral mode and
3690 + * BSESSEND to mark no Vbus */
3691 + omap_otg_init();
3692 + l = omap_readl(OTG_CTRL);
3693 + l &= ~(OTG_CTRL_XCVR_MASK | OTG_CTRL_SYS_MASK | OTG_BSESSVLD);
3694 + l |= OTG_ID | OTG_BSESSEND;
3695 + omap_writel(l, OTG_CTRL);
3696 +
3697 + /* Power up transceiver and set it in USB perhiperal mode */
3698 + tahvo_write_reg(TAHVO_REG_USBR, USBR_SLAVE_CONTROL | USBR_REGOUT | USBR_NSUSPEND | USBR_SLAVE_SW);
3699 + tu->otg.state = OTG_STATE_B_IDLE;
3700 +
3701 + check_vbus_state(tu);
3702 +}
3703 +
3704 +static void tahvo_usb_stop_peripheral(struct tahvo_usb *tu)
3705 +{
3706 + u32 l;
3707 +
3708 + l = omap_readl(OTG_CTRL);
3709 + l &= ~OTG_BSESSVLD;
3710 + l |= OTG_BSESSEND;
3711 + omap_writel(l, OTG_CTRL);
3712 +
3713 + if (tu->otg.gadget)
3714 + usb_gadget_vbus_disconnect(tu->otg.gadget);
3715 + tu->otg.state = OTG_STATE_B_IDLE;
3716 +
3717 +}
3718 +
3719 +static void tahvo_usb_power_off(struct tahvo_usb *tu)
3720 +{
3721 + u32 l;
3722 + int id;
3723 +
3724 + /* Disable gadget controller if any */
3725 + if (tu->otg.gadget)
3726 + usb_gadget_vbus_disconnect(tu->otg.gadget);
3727 +
3728 + host_suspend(tu);
3729 +
3730 + /* Disable OTG and interrupts */
3731 + if (TAHVO_MODE(tu) == TAHVO_MODE_PERIPHERAL)
3732 + id = OTG_ID;
3733 + else
3734 + id = 0;
3735 + l = omap_readl(OTG_CTRL);
3736 + l &= ~(OTG_CTRL_XCVR_MASK | OTG_CTRL_SYS_MASK | OTG_BSESSVLD);
3737 + l |= id | OTG_BSESSEND;
3738 + omap_writel(l, OTG_CTRL);
3739 + omap_writew(0, OTG_IRQ_EN);
3740 +
3741 + l = omap_readl(OTG_SYSCON_2);
3742 + l &= ~OTG_EN;
3743 + omap_writel(l, OTG_SYSCON_2);
3744 +
3745 + l = omap_readl(OTG_SYSCON_1);
3746 + l |= OTG_IDLE_EN;
3747 + omap_writel(l, OTG_SYSCON_1);
3748 +
3749 + /* Power off transceiver */
3750 + tahvo_write_reg(TAHVO_REG_USBR, 0);
3751 + tu->otg.state = OTG_STATE_UNDEFINED;
3752 +}
3753 +
3754 +
3755 +static int tahvo_usb_set_power(struct otg_transceiver *dev, unsigned mA)
3756 +{
3757 + struct tahvo_usb *tu = container_of(dev, struct tahvo_usb, otg);
3758 +
3759 + dev_dbg(&tu->pt_dev->dev, "set_power %d mA\n", mA);
3760 +
3761 + if (dev->state == OTG_STATE_B_PERIPHERAL) {
3762 + /* REVISIT: Can Tahvo charge battery from VBUS? */
3763 + }
3764 + return 0;
3765 +}
3766 +
3767 +static int tahvo_usb_set_suspend(struct otg_transceiver *dev, int suspend)
3768 +{
3769 + struct tahvo_usb *tu = container_of(dev, struct tahvo_usb, otg);
3770 + u16 w;
3771 +
3772 + dev_dbg(&tu->pt_dev->dev, "set_suspend\n");
3773 +
3774 + w = tahvo_read_reg(TAHVO_REG_USBR);
3775 + if (suspend)
3776 + w &= ~USBR_NSUSPEND;
3777 + else
3778 + w |= USBR_NSUSPEND;
3779 + tahvo_write_reg(TAHVO_REG_USBR, w);
3780 +
3781 + return 0;
3782 +}
3783 +
3784 +static int tahvo_usb_start_srp(struct otg_transceiver *dev)
3785 +{
3786 + struct tahvo_usb *tu = container_of(dev, struct tahvo_usb, otg);
3787 + u32 otg_ctrl;
3788 +
3789 + dev_dbg(&tu->pt_dev->dev, "start_srp\n");
3790 +
3791 + if (!dev || tu->otg.state != OTG_STATE_B_IDLE)
3792 + return -ENODEV;
3793 +
3794 + otg_ctrl = omap_readl(OTG_CTRL);
3795 + if (!(otg_ctrl & OTG_BSESSEND))
3796 + return -EINVAL;
3797 +
3798 + otg_ctrl |= OTG_B_BUSREQ;
3799 + otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_SYS_MASK;
3800 + omap_writel(otg_ctrl, OTG_CTRL);
3801 + tu->otg.state = OTG_STATE_B_SRP_INIT;
3802 +
3803 + return 0;
3804 +}
3805 +
3806 +static int tahvo_usb_start_hnp(struct otg_transceiver *otg)
3807 +{
3808 + struct tahvo_usb *tu = container_of(otg, struct tahvo_usb, otg);
3809 +
3810 + dev_dbg(&tu->pt_dev->dev, "start_hnp\n");
3811 +#ifdef CONFIG_USB_OTG
3812 + /* REVISIT: Add this for OTG */
3813 +#endif
3814 + return -EINVAL;
3815 +}
3816 +
3817 +static int tahvo_usb_set_host(struct otg_transceiver *otg, struct usb_bus *host)
3818 +{
3819 + struct tahvo_usb *tu = container_of(otg, struct tahvo_usb, otg);
3820 + u32 l;
3821 +
3822 + dev_dbg(&tu->pt_dev->dev, "set_host %p\n", host);
3823 +
3824 + if (otg == NULL)
3825 + return -ENODEV;
3826 +
3827 +#if defined(CONFIG_USB_OTG) || !defined(CONFIG_USB_GADGET_OMAP)
3828 +
3829 + mutex_lock(&tu->serialize);
3830 +
3831 + if (host == NULL) {
3832 + if (TAHVO_MODE(tu) == TAHVO_MODE_HOST)
3833 + tahvo_usb_power_off(tu);
3834 + tu->otg.host = NULL;
3835 + mutex_unlock(&tu->serialize);
3836 + return 0;
3837 + }
3838 +
3839 + l = omap_readl(OTG_SYSCON_1);
3840 + l &= ~(OTG_IDLE_EN | HST_IDLE_EN | DEV_IDLE_EN);
3841 + omap_writel(l, OTG_SYSCON_1);
3842 +
3843 + if (TAHVO_MODE(tu) == TAHVO_MODE_HOST) {
3844 + tu->otg.host = NULL;
3845 + tahvo_usb_become_host(tu);
3846 + } else
3847 + host_suspend(tu);
3848 +
3849 + tu->otg.host = host;
3850 +
3851 + mutex_unlock(&tu->serialize);
3852 +#else
3853 + /* No host mode configured, so do not allow host controlled to be set */
3854 + return -EINVAL;
3855 +#endif
3856 +
3857 + return 0;
3858 +}
3859 +
3860 +static int tahvo_usb_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget)
3861 +{
3862 + struct tahvo_usb *tu = container_of(otg, struct tahvo_usb, otg);
3863 +
3864 + dev_dbg(&tu->pt_dev->dev, "set_peripheral %p\n", gadget);
3865 +
3866 + if (!otg)
3867 + return -ENODEV;
3868 +
3869 +#if defined(CONFIG_USB_OTG) || defined(CONFIG_USB_GADGET_OMAP)
3870 +
3871 + mutex_lock(&tu->serialize);
3872 +
3873 + if (!gadget) {
3874 + if (TAHVO_MODE(tu) == TAHVO_MODE_PERIPHERAL)
3875 + tahvo_usb_power_off(tu);
3876 + tu->otg.gadget = NULL;
3877 + mutex_unlock(&tu->serialize);
3878 + return 0;
3879 + }
3880 +
3881 + tu->otg.gadget = gadget;
3882 + if (TAHVO_MODE(tu) == TAHVO_MODE_PERIPHERAL)
3883 + tahvo_usb_become_peripheral(tu);
3884 +
3885 + mutex_unlock(&tu->serialize);
3886 +#else
3887 + /* No gadget mode configured, so do not allow host controlled to be set */
3888 + return -EINVAL;
3889 +#endif
3890 +
3891 + return 0;
3892 +}
3893 +
3894 +static void tahvo_usb_irq_work(struct work_struct *work)
3895 +{
3896 + struct tahvo_usb *tu = container_of(work, struct tahvo_usb, irq_work);
3897 +
3898 + mutex_lock(&tu->serialize);
3899 + check_vbus_state(tu);
3900 + mutex_unlock(&tu->serialize);
3901 +}
3902 +
3903 +static void tahvo_usb_vbus_interrupt(unsigned long arg)
3904 +{
3905 + struct tahvo_usb *tu = (struct tahvo_usb *) arg;
3906 +
3907 + tahvo_ack_irq(TAHVO_INT_VBUSON);
3908 + /* Seems we need this to acknowledge the interrupt */
3909 + tahvo_read_reg(TAHVO_REG_IDSR);
3910 + schedule_work(&tu->irq_work);
3911 +}
3912 +
3913 +#ifdef CONFIG_USB_OTG
3914 +static ssize_t otg_mode_show(struct device *device,
3915 + struct device_attribute *attr, char *buf)
3916 +{
3917 + struct tahvo_usb *tu = dev_get_drvdata(device);
3918 + switch (tu->tahvo_mode) {
3919 + case TAHVO_MODE_HOST:
3920 + return sprintf(buf, "host\n");
3921 + case TAHVO_MODE_PERIPHERAL:
3922 + return sprintf(buf, "peripheral\n");
3923 + }
3924 + return sprintf(buf, "unknown\n");
3925 +}
3926 +
3927 +static ssize_t otg_mode_store(struct device *device,
3928 + struct device_attribute *attr,
3929 + const char *buf, size_t count)
3930 +{
3931 + struct tahvo_usb *tu = dev_get_drvdata(device);
3932 + int r;
3933 +
3934 + r = strlen(buf);
3935 + mutex_lock(&tu->serialize);
3936 + if (strncmp(buf, "host", 4) == 0) {
3937 + if (tu->tahvo_mode == TAHVO_MODE_PERIPHERAL)
3938 + tahvo_usb_stop_peripheral(tu);
3939 + tu->tahvo_mode = TAHVO_MODE_HOST;
3940 + if (tu->otg.host) {
3941 + printk(KERN_INFO "Selected HOST mode: host controller present.\n");
3942 + tahvo_usb_become_host(tu);
3943 + } else {
3944 + printk(KERN_INFO "Selected HOST mode: no host controller, powering off.\n");
3945 + tahvo_usb_power_off(tu);
3946 + }
3947 + } else if (strncmp(buf, "peripheral", 10) == 0) {
3948 + if (tu->tahvo_mode == TAHVO_MODE_HOST)
3949 + tahvo_usb_stop_host(tu);
3950 + tu->tahvo_mode = TAHVO_MODE_PERIPHERAL;
3951 + if (tu->otg.gadget) {
3952 + printk(KERN_INFO "Selected PERIPHERAL mode: gadget driver present.\n");
3953 + tahvo_usb_become_peripheral(tu);
3954 + } else {
3955 + printk(KERN_INFO "Selected PERIPHERAL mode: no gadget driver, powering off.\n");
3956 + tahvo_usb_power_off(tu);
3957 + }
3958 + } else
3959 + r = -EINVAL;
3960 +
3961 + mutex_unlock(&tu->serialize);
3962 + return r;
3963 +}
3964 +
3965 +static DEVICE_ATTR(otg_mode, 0644, otg_mode_show, otg_mode_store);
3966 +#endif
3967 +
3968 +static int tahvo_usb_probe(struct device *dev)
3969 +{
3970 + struct tahvo_usb *tu;
3971 + int ret;
3972 +
3973 + dev_dbg(dev, "probe\n");
3974 +
3975 + /* Create driver data */
3976 + tu = kmalloc(sizeof(*tu), GFP_KERNEL);
3977 + if (!tu)
3978 + return -ENOMEM;
3979 + memset(tu, 0, sizeof(*tu));
3980 + tu->pt_dev = container_of(dev, struct platform_device, dev);
3981 +#ifdef CONFIG_USB_OTG
3982 + /* Default mode */
3983 +#ifdef CONFIG_CBUS_TAHVO_USB_HOST_BY_DEFAULT
3984 + tu->tahvo_mode = TAHVO_MODE_HOST;
3985 +#else
3986 + tu->tahvo_mode = TAHVO_MODE_PERIPHERAL;
3987 +#endif
3988 +#endif
3989 +
3990 + INIT_WORK(&tu->irq_work, tahvo_usb_irq_work);
3991 + mutex_init(&tu->serialize);
3992 +
3993 + /* Set initial state, so that we generate kevents only on
3994 + * state changes */
3995 + tu->vbus_state = tahvo_read_reg(TAHVO_REG_IDSR) & 0x01;
3996 +
3997 + /* We cannot enable interrupt until omap_udc is initialized */
3998 + ret = tahvo_request_irq(TAHVO_INT_VBUSON, tahvo_usb_vbus_interrupt,
3999 + (unsigned long) tu, "vbus_interrupt");
4000 + if (ret != 0) {
4001 + kfree(tu);
4002 + printk(KERN_ERR "Could not register Tahvo interrupt for VBUS\n");
4003 + return ret;
4004 + }
4005 +
4006 + /* Attributes */
4007 + ret = device_create_file(dev, &dev_attr_vbus_state);
4008 +#ifdef CONFIG_USB_OTG
4009 + ret |= device_create_file(dev, &dev_attr_otg_mode);
4010 +#endif
4011 + if (ret)
4012 + printk(KERN_ERR "attribute creation failed: %d\n", ret);
4013 +
4014 + /* Create OTG interface */
4015 + tahvo_usb_power_off(tu);
4016 + tu->otg.state = OTG_STATE_UNDEFINED;
4017 + tu->otg.label = DRIVER_NAME;
4018 + tu->otg.set_host = tahvo_usb_set_host;
4019 + tu->otg.set_peripheral = tahvo_usb_set_peripheral;
4020 + tu->otg.set_power = tahvo_usb_set_power;
4021 + tu->otg.set_suspend = tahvo_usb_set_suspend;
4022 + tu->otg.start_srp = tahvo_usb_start_srp;
4023 + tu->otg.start_hnp = tahvo_usb_start_hnp;
4024 +
4025 + ret = otg_set_transceiver(&tu->otg);
4026 + if (ret < 0) {
4027 + printk(KERN_ERR "Cannot register USB transceiver\n");
4028 + kfree(tu);
4029 + tahvo_free_irq(TAHVO_INT_VBUSON);
4030 + return ret;
4031 + }
4032 +
4033 + dev_set_drvdata(dev, tu);
4034 +
4035 + /* Act upon current vbus state once at startup. A vbus state irq may or
4036 + * may not be generated in addition to this. */
4037 + schedule_work(&tu->irq_work);
4038 + return 0;
4039 +}
4040 +
4041 +static int tahvo_usb_remove(struct device *dev)
4042 +{
4043 + dev_dbg(dev, "remove\n");
4044 +
4045 + tahvo_free_irq(TAHVO_INT_VBUSON);
4046 + flush_scheduled_work();
4047 + otg_set_transceiver(0);
4048 + device_remove_file(dev, &dev_attr_vbus_state);
4049 +#ifdef CONFIG_USB_OTG
4050 + device_remove_file(dev, &dev_attr_otg_mode);
4051 +#endif
4052 + return 0;
4053 +}
4054 +
4055 +static struct device_driver tahvo_usb_driver = {
4056 + .name = "tahvo-usb",
4057 + .bus = &platform_bus_type,
4058 + .probe = tahvo_usb_probe,
4059 + .remove = tahvo_usb_remove,
4060 +};
4061 +
4062 +static struct platform_device tahvo_usb_device = {
4063 + .name = "tahvo-usb",
4064 + .id = -1,
4065 +};
4066 +
4067 +static int __init tahvo_usb_init(void)
4068 +{
4069 + int ret = 0;
4070 +
4071 + printk(KERN_INFO "Tahvo USB transceiver driver initializing\n");
4072 + ret = driver_register(&tahvo_usb_driver);
4073 + if (ret)
4074 + return ret;
4075 + ret = platform_device_register(&tahvo_usb_device);
4076 + if (ret < 0) {
4077 + driver_unregister(&tahvo_usb_driver);
4078 + return ret;
4079 + }
4080 + ret = driver_register(&omap_otg_driver);
4081 + if (ret) {
4082 + platform_device_unregister(&tahvo_usb_device);
4083 + driver_unregister(&tahvo_usb_driver);
4084 + return ret;
4085 + }
4086 + return 0;
4087 +}
4088 +
4089 +subsys_initcall(tahvo_usb_init);
4090 +
4091 +static void __exit tahvo_usb_exit(void)
4092 +{
4093 + driver_unregister(&omap_otg_driver);
4094 + platform_device_unregister(&tahvo_usb_device);
4095 + driver_unregister(&tahvo_usb_driver);
4096 +}
4097 +module_exit(tahvo_usb_exit);
4098 +
4099 +MODULE_DESCRIPTION("Tahvo USB OTG Transceiver Driver");
4100 +MODULE_LICENSE("GPL");
4101 +MODULE_AUTHOR("Juha Yrjölä, Tony Lindgren, and Timo Teräs");
4102 --- /dev/null
4103 +++ linux-2.6.35/drivers/cbus/tahvo-user.c
4104 @@ -0,0 +1,407 @@
4105 +/**
4106 + * drivers/cbus/tahvo-user.c
4107 + *
4108 + * Tahvo user space interface functions
4109 + *
4110 + * Copyright (C) 2004, 2005 Nokia Corporation
4111 + *
4112 + * Written by Mikko Ylinen <mikko.k.ylinen@nokia.com>
4113 + *
4114 + * This file is subject to the terms and conditions of the GNU General
4115 + * Public License. See the file "COPYING" in the main directory of this
4116 + * archive for more details.
4117 + *
4118 + * This program is distributed in the hope that it will be useful,
4119 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
4120 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4121 + * GNU General Public License for more details.
4122 + *
4123 + * You should have received a copy of the GNU General Public License
4124 + * along with this program; if not, write to the Free Software
4125 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
4126 + */
4127 +
4128 +#include <linux/types.h>
4129 +#include <linux/kernel.h>
4130 +#include <linux/interrupt.h>
4131 +#include <linux/module.h>
4132 +#include <linux/init.h>
4133 +#include <linux/fs.h>
4134 +#include <linux/miscdevice.h>
4135 +#include <linux/poll.h>
4136 +#include <linux/list.h>
4137 +#include <linux/spinlock.h>
4138 +#include <linux/sched.h>
4139 +#include <linux/mutex.h>
4140 +#include <linux/slab.h>
4141 +
4142 +#include <asm/uaccess.h>
4143 +
4144 +#include "tahvo.h"
4145 +
4146 +#include "user_retu_tahvo.h"
4147 +
4148 +/* Maximum size of IRQ node buffer/pool */
4149 +#define TAHVO_MAX_IRQ_BUF_LEN 16
4150 +
4151 +#define PFX "tahvo-user: "
4152 +
4153 +/* Bitmap for marking the interrupt sources as having the handlers */
4154 +static u32 tahvo_irq_bits;
4155 +
4156 +/* For allowing only one user process to subscribe to the tahvo interrupts */
4157 +static struct file *tahvo_irq_subscr = NULL;
4158 +
4159 +/* For poll and IRQ passing */
4160 +struct tahvo_irq {
4161 + u32 id;
4162 + struct list_head node;
4163 +};
4164 +
4165 +static spinlock_t tahvo_irqs_lock;
4166 +static struct tahvo_irq *tahvo_irq_block;
4167 +static LIST_HEAD(tahvo_irqs);
4168 +static LIST_HEAD(tahvo_irqs_reserve);
4169 +
4170 +/* Wait queue - used when user wants to read the device */
4171 +DECLARE_WAIT_QUEUE_HEAD(tahvo_user_waitqueue);
4172 +
4173 +/* Semaphore to protect irq subscription sequence */
4174 +static struct mutex tahvo_mutex;
4175 +
4176 +/* This array specifies TAHVO register types (read/write/toggle) */
4177 +static const u8 tahvo_access_bits[] = {
4178 + 1,
4179 + 4,
4180 + 1,
4181 + 3,
4182 + 3,
4183 + 3,
4184 + 3,
4185 + 3,
4186 + 3,
4187 + 3,
4188 + 3,
4189 + 3,
4190 + 3,
4191 + 1
4192 +};
4193 +
4194 +/*
4195 + * The handler for all TAHVO interrupts.
4196 + *
4197 + * arg is the interrupt source in TAHVO.
4198 + */
4199 +static void tahvo_user_irq_handler(unsigned long arg)
4200 +{
4201 + struct tahvo_irq *irq;
4202 +
4203 + /* user has to re-enable the interrupt once ready
4204 + * for receiving them again */
4205 + tahvo_disable_irq(arg);
4206 + tahvo_ack_irq(arg);
4207 +
4208 + spin_lock(&tahvo_irqs_lock);
4209 + if (list_empty(&tahvo_irqs_reserve)) {
4210 + spin_unlock(&tahvo_irqs_lock);
4211 + return;
4212 + }
4213 + irq = list_entry((&tahvo_irqs_reserve)->next, struct tahvo_irq, node);
4214 + irq->id = arg;
4215 + list_move_tail(&irq->node, &tahvo_irqs);
4216 + spin_unlock(&tahvo_irqs_lock);
4217 +
4218 + /* wake up waiting thread */
4219 + wake_up(&tahvo_user_waitqueue);
4220 +}
4221 +
4222 +/*
4223 + * This routine sets up the interrupt handler and marks an interrupt source
4224 + * in TAHVO as a candidate for signal delivery to the user process.
4225 + */
4226 +static int tahvo_user_subscribe_to_irq(int id, struct file *filp)
4227 +{
4228 + int ret;
4229 +
4230 + mutex_lock(&tahvo_mutex);
4231 + if ((tahvo_irq_subscr != NULL) && (tahvo_irq_subscr != filp)) {
4232 + mutex_unlock(&tahvo_mutex);
4233 + return -EBUSY;
4234 + }
4235 + /* Store the file pointer of the first user process registering IRQs */
4236 + tahvo_irq_subscr = filp;
4237 + mutex_unlock(&tahvo_mutex);
4238 +
4239 + if (tahvo_irq_bits & (1 << id))
4240 + return 0;
4241 +
4242 + ret = tahvo_request_irq(id, tahvo_user_irq_handler, id, "");
4243 + if (ret < 0)
4244 + return ret;
4245 +
4246 + /* Mark that this interrupt has a handler */
4247 + tahvo_irq_bits |= 1 << id;
4248 +
4249 + return 0;
4250 +}
4251 +
4252 +/*
4253 + * Unregister all TAHVO interrupt handlers
4254 + */
4255 +static void tahvo_unreg_irq_handlers(void)
4256 +{
4257 + int id;
4258 +
4259 + if (!tahvo_irq_bits)
4260 + return;
4261 +
4262 + for (id = 0; id < MAX_TAHVO_IRQ_HANDLERS; id++)
4263 + if (tahvo_irq_bits & (1 << id))
4264 + tahvo_free_irq(id);
4265 +
4266 + tahvo_irq_bits = 0;
4267 +}
4268 +
4269 +/*
4270 + * Write to TAHVO register.
4271 + * Returns 0 upon success, a negative error value otherwise.
4272 + */
4273 +static int tahvo_user_write_with_mask(u32 field, u16 value)
4274 +{
4275 + u32 mask;
4276 + u32 reg;
4277 + u_short tmp;
4278 + unsigned long flags;
4279 +
4280 + mask = MASK(field);
4281 + reg = REG(field);
4282 +
4283 + /* Detect bad mask and reg */
4284 + if (mask == 0 || reg > TAHVO_REG_MAX ||
4285 + tahvo_access_bits[reg] == READ_ONLY) {
4286 + printk(KERN_ERR PFX "invalid arguments (reg=%#x, mask=%#x)\n",
4287 + reg, mask);
4288 + return -EINVAL;
4289 + }
4290 +
4291 + /* Justify value according to mask */
4292 + while (!(mask & 1)) {
4293 + value = value << 1;
4294 + mask = mask >> 1;
4295 + }
4296 +
4297 + spin_lock_irqsave(&tahvo_lock, flags);
4298 + if (tahvo_access_bits[reg] == TOGGLE) {
4299 + /* No need to detect previous content of register */
4300 + tmp = 0;
4301 + } else {
4302 + /* Read current value of register */
4303 + tmp = tahvo_read_reg(reg);
4304 + }
4305 + /* Generate a new value */
4306 + tmp = (tmp & ~MASK(field)) | (value & MASK(field));
4307 + /* Write data to TAHVO */
4308 + tahvo_write_reg(reg, tmp);
4309 + spin_unlock_irqrestore(&tahvo_lock, flags);
4310 +
4311 + return 0;
4312 +}
4313 +
4314 +/*
4315 + * Read TAHVO register.
4316 + */
4317 +static u32 tahvo_user_read_with_mask(u32 field)
4318 +{
4319 + u_short value;
4320 + u32 mask, reg;
4321 +
4322 + mask = MASK(field);
4323 + reg = REG(field);
4324 +
4325 + /* Detect bad mask and reg */
4326 + if (mask == 0 || reg > TAHVO_REG_MAX) {
4327 + printk(KERN_ERR PFX "invalid arguments (reg=%#x, mask=%#x)\n",
4328 + reg, mask);
4329 + return -EINVAL;
4330 + }
4331 +
4332 + /* Read the register */
4333 + value = tahvo_read_reg(reg) & mask;
4334 +
4335 + /* Right justify value */
4336 + while (!(mask & 1)) {
4337 + value = value >> 1;
4338 + mask = mask >> 1;
4339 + }
4340 +
4341 + return value;
4342 +}
4343 +
4344 +/*
4345 + * Close device
4346 + */
4347 +static int tahvo_close(struct inode *inode, struct file *filp)
4348 +{
4349 + /* Unregister all interrupts that have been registered */
4350 + if (tahvo_irq_subscr == filp) {
4351 + tahvo_unreg_irq_handlers();
4352 + tahvo_irq_subscr = NULL;
4353 + }
4354 +
4355 + return 0;
4356 +}
4357 +
4358 +/*
4359 + * Device control (ioctl)
4360 + */
4361 +static int tahvo_ioctl(struct inode *inode, struct file *filp,
4362 + unsigned int cmd, unsigned long arg)
4363 +{
4364 + struct retu_tahvo_write_parms par;
4365 + int ret;
4366 +
4367 + switch (cmd) {
4368 + case URT_IOCT_IRQ_SUBSCR:
4369 + return tahvo_user_subscribe_to_irq(arg, filp);
4370 + case TAHVO_IOCH_READ:
4371 + return tahvo_user_read_with_mask(arg);
4372 + case TAHVO_IOCX_WRITE:
4373 + ret = copy_from_user(&par, (void __user *) arg, sizeof(par));
4374 + if (ret)
4375 + printk(KERN_ERR "copy_from_user failed: %d\n", ret);
4376 + par.result = tahvo_user_write_with_mask(par.field, par.value);
4377 + ret = copy_to_user((void __user *) arg, &par, sizeof(par));
4378 + if (ret)
4379 + printk(KERN_ERR "copy_to_user failed: %d\n", ret);
4380 + break;
4381 + default:
4382 + return -ENOIOCTLCMD;
4383 + }
4384 + return 0;
4385 +}
4386 +
4387 +/*
4388 + * Read from device
4389 + */
4390 +static ssize_t tahvo_read(struct file *filp, char *buf, size_t count,
4391 + loff_t * offp)
4392 +{
4393 + struct tahvo_irq *irq;
4394 +
4395 + u32 nr, i;
4396 +
4397 + /* read not permitted if neither filp nor anyone has registered IRQs */
4398 + if (tahvo_irq_subscr != filp)
4399 + return -EPERM;
4400 +
4401 + if ((count < sizeof(u32)) || ((count % sizeof(u32)) != 0))
4402 + return -EINVAL;
4403 +
4404 + nr = count / sizeof(u32);
4405 +
4406 + for (i = 0; i < nr; i++) {
4407 + unsigned long flags;
4408 + u32 irq_id;
4409 + int ret;
4410 +
4411 + ret = wait_event_interruptible(tahvo_user_waitqueue,
4412 + !list_empty(&tahvo_irqs));
4413 + if (ret < 0)
4414 + return ret;
4415 +
4416 + spin_lock_irqsave(&tahvo_irqs_lock, flags);
4417 + irq = list_entry((&tahvo_irqs)->next, struct tahvo_irq, node);
4418 + irq_id = irq->id;
4419 + list_move(&irq->node, &tahvo_irqs_reserve);
4420 + spin_unlock_irqrestore(&tahvo_irqs_lock, flags);
4421 +
4422 + ret = copy_to_user(buf + i * sizeof(irq_id), &irq_id,
4423 + sizeof(irq_id));
4424 + if (ret)
4425 + printk(KERN_ERR "copy_to_user failed: %d\n", ret);
4426 + }
4427 +
4428 + return count;
4429 +}
4430 +
4431 +/*
4432 + * Poll method
4433 + */
4434 +static unsigned tahvo_poll(struct file *filp, struct poll_table_struct *pt)
4435 +{
4436 + if (!list_empty(&tahvo_irqs))
4437 + return POLLIN;
4438 +
4439 + poll_wait(filp, &tahvo_user_waitqueue, pt);
4440 +
4441 + if (!list_empty(&tahvo_irqs))
4442 + return POLLIN;
4443 + else
4444 + return 0;
4445 +}
4446 +
4447 +static struct file_operations tahvo_user_fileops = {
4448 + .owner = THIS_MODULE,
4449 + .ioctl = tahvo_ioctl,
4450 + .read = tahvo_read,
4451 + .release = tahvo_close,
4452 + .poll = tahvo_poll
4453 +};
4454 +
4455 +static struct miscdevice tahvo_device = {
4456 + .minor = MISC_DYNAMIC_MINOR,
4457 + .name = "tahvo",
4458 + .fops = &tahvo_user_fileops
4459 +};
4460 +
4461 +/*
4462 + * Initialization
4463 + *
4464 + * @return 0 if successful, error value otherwise.
4465 + */
4466 +int tahvo_user_init(void)
4467 +{
4468 + struct tahvo_irq *irq;
4469 + int res, i;
4470 +
4471 + irq = kmalloc(sizeof(*irq) * TAHVO_MAX_IRQ_BUF_LEN, GFP_KERNEL);
4472 + if (irq == NULL) {
4473 + printk(KERN_ERR PFX "kmalloc failed\n");
4474 + return -ENOMEM;
4475 + }
4476 + memset(irq, 0, sizeof(*irq) * TAHVO_MAX_IRQ_BUF_LEN);
4477 + for (i = 0; i < TAHVO_MAX_IRQ_BUF_LEN; i++)
4478 + list_add(&irq[i].node, &tahvo_irqs_reserve);
4479 +
4480 + tahvo_irq_block = irq;
4481 +
4482 + spin_lock_init(&tahvo_irqs_lock);
4483 + mutex_init(&tahvo_mutex);
4484 +
4485 + /* Request a misc device */
4486 + res = misc_register(&tahvo_device);
4487 + if (res < 0) {
4488 + printk(KERN_ERR PFX "unable to register misc device for %s\n",
4489 + tahvo_device.name);
4490 + kfree(irq);
4491 + return res;
4492 + }
4493 +
4494 + return 0;
4495 +}
4496 +
4497 +/*
4498 + * Cleanup.
4499 + */
4500 +void tahvo_user_cleanup(void)
4501 +{
4502 + /* Unregister our misc device */
4503 + misc_deregister(&tahvo_device);
4504 + /* Unregister and disable all TAHVO interrupts */
4505 + tahvo_unreg_irq_handlers();
4506 + kfree(tahvo_irq_block);
4507 +}
4508 +
4509 +MODULE_DESCRIPTION("Tahvo ASIC user space functions");
4510 +MODULE_LICENSE("GPL");
4511 +MODULE_AUTHOR("Mikko Ylinen");
4512 --- /dev/null
4513 +++ linux-2.6.35/drivers/cbus/user_retu_tahvo.h
4514 @@ -0,0 +1,75 @@
4515 +/**
4516 + * drivers/cbus/user_retu_tahvo.h
4517 + *
4518 + * Copyright (C) 2004, 2005 Nokia Corporation
4519 + *
4520 + * Written by Mikko Ylinen <mikko.k.ylinen@nokia.com>
4521 + *
4522 + * Definitions and types used by both retu-user and tahvo-user.
4523 + *
4524 + * This file is subject to the terms and conditions of the GNU General
4525 + * Public License. See the file "COPYING" in the main directory of this
4526 + * archive for more details.
4527 + *
4528 + * This program is distributed in the hope that it will be useful,
4529 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
4530 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4531 + * GNU General Public License for more details.
4532 +
4533 + * You should have received a copy of the GNU General Public License
4534 + * along with this program; if not, write to the Free Software
4535 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
4536 + */
4537 +
4538 +#ifndef _USER_RETU_TAHVO_H
4539 +#define _USER_RETU_TAHVO_H
4540 +
4541 +/* Chip IDs */
4542 +#define CHIP_RETU 1
4543 +#define CHIP_TAHVO 2
4544 +
4545 +/* Register access type bits */
4546 +#define READ_ONLY 1
4547 +#define WRITE_ONLY 2
4548 +#define READ_WRITE 3
4549 +#define TOGGLE 4
4550 +
4551 +#define MASK(field) ((u16)(field & 0xFFFF))
4552 +#define REG(field) ((u16)((field >> 16) & 0x3F))
4553 +
4554 +/*** IOCTL definitions. These should be kept in sync with user space **********/
4555 +
4556 +#define URT_IOC_MAGIC '`'
4557 +
4558 +/*
4559 + * IOCTL function naming conventions:
4560 + * ==================================
4561 + * 0 -- No argument and return value
4562 + * S -- Set through a pointer
4563 + * T -- Tell directly with the argument value
4564 + * G -- Reply by setting through a pointer
4565 + * Q -- response is on the return value
4566 + * X -- S and G atomically
4567 + * H -- T and Q atomically
4568 + */
4569 +
4570 +/* General */
4571 +#define URT_IOCT_IRQ_SUBSCR _IO(URT_IOC_MAGIC, 0)
4572 +
4573 +/* RETU */
4574 +#define RETU_IOCH_READ _IO(URT_IOC_MAGIC, 1)
4575 +#define RETU_IOCX_WRITE _IO(URT_IOC_MAGIC, 2)
4576 +#define RETU_IOCH_ADC_READ _IO(URT_IOC_MAGIC, 3)
4577 +
4578 +/* TAHVO */
4579 +#define TAHVO_IOCH_READ _IO(URT_IOC_MAGIC, 4)
4580 +#define TAHVO_IOCX_WRITE _IO(URT_IOC_MAGIC, 5)
4581 +
4582 +/* This structure is used for writing RETU/TAHVO registers */
4583 +struct retu_tahvo_write_parms {
4584 + u32 field;
4585 + u16 value;
4586 + u8 result;
4587 +};
4588 +
4589 +#endif
4590 --- linux-2.6.35.orig/drivers/Makefile
4591 +++ linux-2.6.35/drivers/Makefile
4592 @@ -74,7 +74,7 @@ obj-$(CONFIG_GAMEPORT) += input/gamepor
4593 obj-$(CONFIG_INPUT) += input/
4594 obj-$(CONFIG_I2O) += message/
4595 obj-$(CONFIG_RTC_LIB) += rtc/
4596 -obj-y += i2c/ media/
4597 +obj-y += i2c/ media/ cbus/
4598 obj-$(CONFIG_PPS) += pps/
4599 obj-$(CONFIG_W1) += w1/
4600 obj-$(CONFIG_POWER_SUPPLY) += power/
4601 --- linux-2.6.35.orig/arch/arm/Kconfig
4602 +++ linux-2.6.35/arch/arm/Kconfig
4603 @@ -1669,6 +1669,10 @@ source "net/Kconfig"
4604
4605 source "drivers/Kconfig"
4606
4607 +if ARCH_OMAP
4608 +source "drivers/cbus/Kconfig"
4609 +endif
4610 +
4611 source "fs/Kconfig"
4612
4613 source "arch/arm/Kconfig.debug"
OpenWrt SVN history