2 * Emma Mobile Timer Support - STI
4 * Copyright (C) 2012 Magnus Damm
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 #include <linux/init.h>
21 #include <linux/platform_device.h>
22 #include <linux/spinlock.h>
23 #include <linux/interrupt.h>
24 #include <linux/ioport.h>
26 #include <linux/clk.h>
27 #include <linux/irq.h>
28 #include <linux/err.h>
29 #include <linux/delay.h>
30 #include <linux/clocksource.h>
31 #include <linux/clockchips.h>
32 #include <linux/slab.h>
33 #include <linux/module.h>
35 enum { USER_CLOCKSOURCE
, USER_CLOCKEVENT
, USER_NR
};
40 struct platform_device
*pdev
;
41 unsigned int active
[USER_NR
];
44 struct clock_event_device ced
;
45 struct clocksource cs
;
48 #define STI_CONTROL 0x00
49 #define STI_COMPA_H 0x10
50 #define STI_COMPA_L 0x14
51 #define STI_COMPB_H 0x18
52 #define STI_COMPB_L 0x1c
53 #define STI_COUNT_H 0x20
54 #define STI_COUNT_L 0x24
55 #define STI_COUNT_RAW_H 0x28
56 #define STI_COUNT_RAW_L 0x2c
57 #define STI_SET_H 0x30
58 #define STI_SET_L 0x34
59 #define STI_INTSTATUS 0x40
60 #define STI_INTRAWSTATUS 0x44
61 #define STI_INTENSET 0x48
62 #define STI_INTENCLR 0x4c
63 #define STI_INTFFCLR 0x50
65 static inline unsigned long em_sti_read(struct em_sti_priv
*p
, int offs
)
67 return ioread32(p
->base
+ offs
);
70 static inline void em_sti_write(struct em_sti_priv
*p
, int offs
,
73 iowrite32(value
, p
->base
+ offs
);
76 static int em_sti_enable(struct em_sti_priv
*p
)
81 ret
= clk_prepare_enable(p
->clk
);
83 dev_err(&p
->pdev
->dev
, "cannot enable clock\n");
87 /* configure channel, periodic mode and maximum timeout */
88 p
->rate
= clk_get_rate(p
->clk
);
90 /* reset the counter */
91 em_sti_write(p
, STI_SET_H
, 0x40000000);
92 em_sti_write(p
, STI_SET_L
, 0x00000000);
94 /* mask and clear pending interrupts */
95 em_sti_write(p
, STI_INTENCLR
, 3);
96 em_sti_write(p
, STI_INTFFCLR
, 3);
98 /* enable updates of counter registers */
99 em_sti_write(p
, STI_CONTROL
, 1);
104 static void em_sti_disable(struct em_sti_priv
*p
)
106 /* mask interrupts */
107 em_sti_write(p
, STI_INTENCLR
, 3);
110 clk_disable_unprepare(p
->clk
);
113 static u64
em_sti_count(struct em_sti_priv
*p
)
118 /* the STI hardware buffers the 48-bit count, but to
119 * break it out into two 32-bit access the registers
120 * must be accessed in a certain order.
121 * Always read STI_COUNT_H before STI_COUNT_L.
123 raw_spin_lock_irqsave(&p
->lock
, flags
);
124 ticks
= (u64
)(em_sti_read(p
, STI_COUNT_H
) & 0xffff) << 32;
125 ticks
|= em_sti_read(p
, STI_COUNT_L
);
126 raw_spin_unlock_irqrestore(&p
->lock
, flags
);
131 static u64
em_sti_set_next(struct em_sti_priv
*p
, u64 next
)
135 raw_spin_lock_irqsave(&p
->lock
, flags
);
137 /* mask compare A interrupt */
138 em_sti_write(p
, STI_INTENCLR
, 1);
140 /* update compare A value */
141 em_sti_write(p
, STI_COMPA_H
, next
>> 32);
142 em_sti_write(p
, STI_COMPA_L
, next
& 0xffffffff);
144 /* clear compare A interrupt source */
145 em_sti_write(p
, STI_INTFFCLR
, 1);
147 /* unmask compare A interrupt */
148 em_sti_write(p
, STI_INTENSET
, 1);
150 raw_spin_unlock_irqrestore(&p
->lock
, flags
);
155 static irqreturn_t
em_sti_interrupt(int irq
, void *dev_id
)
157 struct em_sti_priv
*p
= dev_id
;
159 p
->ced
.event_handler(&p
->ced
);
163 static int em_sti_start(struct em_sti_priv
*p
, unsigned int user
)
169 raw_spin_lock_irqsave(&p
->lock
, flags
);
170 used_before
= p
->active
[USER_CLOCKSOURCE
] | p
->active
[USER_CLOCKEVENT
];
172 ret
= em_sti_enable(p
);
176 raw_spin_unlock_irqrestore(&p
->lock
, flags
);
181 static void em_sti_stop(struct em_sti_priv
*p
, unsigned int user
)
184 int used_before
, used_after
;
186 raw_spin_lock_irqsave(&p
->lock
, flags
);
187 used_before
= p
->active
[USER_CLOCKSOURCE
] | p
->active
[USER_CLOCKEVENT
];
189 used_after
= p
->active
[USER_CLOCKSOURCE
] | p
->active
[USER_CLOCKEVENT
];
191 if (used_before
&& !used_after
)
193 raw_spin_unlock_irqrestore(&p
->lock
, flags
);
196 static struct em_sti_priv
*cs_to_em_sti(struct clocksource
*cs
)
198 return container_of(cs
, struct em_sti_priv
, cs
);
201 static u64
em_sti_clocksource_read(struct clocksource
*cs
)
203 return em_sti_count(cs_to_em_sti(cs
));
206 static int em_sti_clocksource_enable(struct clocksource
*cs
)
209 struct em_sti_priv
*p
= cs_to_em_sti(cs
);
211 ret
= em_sti_start(p
, USER_CLOCKSOURCE
);
213 __clocksource_update_freq_hz(cs
, p
->rate
);
217 static void em_sti_clocksource_disable(struct clocksource
*cs
)
219 em_sti_stop(cs_to_em_sti(cs
), USER_CLOCKSOURCE
);
222 static void em_sti_clocksource_resume(struct clocksource
*cs
)
224 em_sti_clocksource_enable(cs
);
227 static int em_sti_register_clocksource(struct em_sti_priv
*p
)
229 struct clocksource
*cs
= &p
->cs
;
231 cs
->name
= dev_name(&p
->pdev
->dev
);
233 cs
->read
= em_sti_clocksource_read
;
234 cs
->enable
= em_sti_clocksource_enable
;
235 cs
->disable
= em_sti_clocksource_disable
;
236 cs
->suspend
= em_sti_clocksource_disable
;
237 cs
->resume
= em_sti_clocksource_resume
;
238 cs
->mask
= CLOCKSOURCE_MASK(48);
239 cs
->flags
= CLOCK_SOURCE_IS_CONTINUOUS
;
241 dev_info(&p
->pdev
->dev
, "used as clock source\n");
243 /* Register with dummy 1 Hz value, gets updated in ->enable() */
244 clocksource_register_hz(cs
, 1);
248 static struct em_sti_priv
*ced_to_em_sti(struct clock_event_device
*ced
)
250 return container_of(ced
, struct em_sti_priv
, ced
);
253 static int em_sti_clock_event_shutdown(struct clock_event_device
*ced
)
255 struct em_sti_priv
*p
= ced_to_em_sti(ced
);
256 em_sti_stop(p
, USER_CLOCKEVENT
);
260 static int em_sti_clock_event_set_oneshot(struct clock_event_device
*ced
)
262 struct em_sti_priv
*p
= ced_to_em_sti(ced
);
264 dev_info(&p
->pdev
->dev
, "used for oneshot clock events\n");
265 em_sti_start(p
, USER_CLOCKEVENT
);
266 clockevents_config(&p
->ced
, p
->rate
);
270 static int em_sti_clock_event_next(unsigned long delta
,
271 struct clock_event_device
*ced
)
273 struct em_sti_priv
*p
= ced_to_em_sti(ced
);
277 next
= em_sti_set_next(p
, em_sti_count(p
) + delta
);
278 safe
= em_sti_count(p
) < (next
- 1);
283 static void em_sti_register_clockevent(struct em_sti_priv
*p
)
285 struct clock_event_device
*ced
= &p
->ced
;
287 ced
->name
= dev_name(&p
->pdev
->dev
);
288 ced
->features
= CLOCK_EVT_FEAT_ONESHOT
;
290 ced
->cpumask
= cpu_possible_mask
;
291 ced
->set_next_event
= em_sti_clock_event_next
;
292 ced
->set_state_shutdown
= em_sti_clock_event_shutdown
;
293 ced
->set_state_oneshot
= em_sti_clock_event_set_oneshot
;
295 dev_info(&p
->pdev
->dev
, "used for clock events\n");
297 /* Register with dummy 1 Hz value, gets updated in ->set_state_oneshot() */
298 clockevents_config_and_register(ced
, 1, 2, 0xffffffff);
301 static int em_sti_probe(struct platform_device
*pdev
)
303 struct em_sti_priv
*p
;
304 struct resource
*res
;
307 p
= devm_kzalloc(&pdev
->dev
, sizeof(*p
), GFP_KERNEL
);
312 platform_set_drvdata(pdev
, p
);
314 irq
= platform_get_irq(pdev
, 0);
316 dev_err(&pdev
->dev
, "failed to get irq\n");
320 /* map memory, let base point to the STI instance */
321 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
322 p
->base
= devm_ioremap_resource(&pdev
->dev
, res
);
324 return PTR_ERR(p
->base
);
326 /* get hold of clock */
327 p
->clk
= devm_clk_get(&pdev
->dev
, "sclk");
328 if (IS_ERR(p
->clk
)) {
329 dev_err(&pdev
->dev
, "cannot get clock\n");
330 return PTR_ERR(p
->clk
);
333 if (devm_request_irq(&pdev
->dev
, irq
, em_sti_interrupt
,
334 IRQF_TIMER
| IRQF_IRQPOLL
| IRQF_NOBALANCING
,
335 dev_name(&pdev
->dev
), p
)) {
336 dev_err(&pdev
->dev
, "failed to request low IRQ\n");
340 raw_spin_lock_init(&p
->lock
);
341 em_sti_register_clockevent(p
);
342 em_sti_register_clocksource(p
);
346 static int em_sti_remove(struct platform_device
*pdev
)
348 return -EBUSY
; /* cannot unregister clockevent and clocksource */
351 static const struct of_device_id em_sti_dt_ids
[] = {
352 { .compatible
= "renesas,em-sti", },
355 MODULE_DEVICE_TABLE(of
, em_sti_dt_ids
);
357 static struct platform_driver em_sti_device_driver
= {
358 .probe
= em_sti_probe
,
359 .remove
= em_sti_remove
,
362 .of_match_table
= em_sti_dt_ids
,
366 static int __init
em_sti_init(void)
368 return platform_driver_register(&em_sti_device_driver
);
371 static void __exit
em_sti_exit(void)
373 platform_driver_unregister(&em_sti_device_driver
);
376 subsys_initcall(em_sti_init
);
377 module_exit(em_sti_exit
);
379 MODULE_AUTHOR("Magnus Damm");
380 MODULE_DESCRIPTION("Renesas Emma Mobile STI Timer Driver");
381 MODULE_LICENSE("GPL v2");