~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/sysdev/fsl_gtm.c

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Freescale General-purpose Timers Module
  3  *
  4  * Copyright (c) Freescale Semiconductor, Inc. 2006.
  5  *               Shlomi Gridish <gridish@freescale.com>
  6  *               Jerry Huang <Chang-Ming.Huang@freescale.com>
  7  * Copyright (c) MontaVista Software, Inc. 2008.
  8  *               Anton Vorontsov <avorontsov@ru.mvista.com>
  9  *
 10  * This program is free software; you can redistribute  it and/or modify it
 11  * under  the terms of  the GNU General  Public License as published by the
 12  * Free Software Foundation;  either version 2 of the  License, or (at your
 13  * option) any later version.
 14  */
 15 
 16 #include <linux/kernel.h>
 17 #include <linux/err.h>
 18 #include <linux/errno.h>
 19 #include <linux/list.h>
 20 #include <linux/io.h>
 21 #include <linux/of.h>
 22 #include <linux/spinlock.h>
 23 #include <linux/bitops.h>
 24 #include <linux/slab.h>
 25 #include <linux/export.h>
 26 #include <asm/fsl_gtm.h>
 27 
 28 #define GTCFR_STP(x)            ((x) & 1 ? 1 << 5 : 1 << 1)
 29 #define GTCFR_RST(x)            ((x) & 1 ? 1 << 4 : 1 << 0)
 30 
 31 #define GTMDR_ICLK_MASK         (3 << 1)
 32 #define GTMDR_ICLK_ICAS         (0 << 1)
 33 #define GTMDR_ICLK_ICLK         (1 << 1)
 34 #define GTMDR_ICLK_SLGO         (2 << 1)
 35 #define GTMDR_FRR               (1 << 3)
 36 #define GTMDR_ORI               (1 << 4)
 37 #define GTMDR_SPS(x)            ((x) << 8)
 38 
 39 struct gtm_timers_regs {
 40         u8      gtcfr1;         /* Timer 1, Timer 2 global config register */
 41         u8      res0[0x3];
 42         u8      gtcfr2;         /* Timer 3, timer 4 global config register */
 43         u8      res1[0xB];
 44         __be16  gtmdr1;         /* Timer 1 mode register */
 45         __be16  gtmdr2;         /* Timer 2 mode register */
 46         __be16  gtrfr1;         /* Timer 1 reference register */
 47         __be16  gtrfr2;         /* Timer 2 reference register */
 48         __be16  gtcpr1;         /* Timer 1 capture register */
 49         __be16  gtcpr2;         /* Timer 2 capture register */
 50         __be16  gtcnr1;         /* Timer 1 counter */
 51         __be16  gtcnr2;         /* Timer 2 counter */
 52         __be16  gtmdr3;         /* Timer 3 mode register */
 53         __be16  gtmdr4;         /* Timer 4 mode register */
 54         __be16  gtrfr3;         /* Timer 3 reference register */
 55         __be16  gtrfr4;         /* Timer 4 reference register */
 56         __be16  gtcpr3;         /* Timer 3 capture register */
 57         __be16  gtcpr4;         /* Timer 4 capture register */
 58         __be16  gtcnr3;         /* Timer 3 counter */
 59         __be16  gtcnr4;         /* Timer 4 counter */
 60         __be16  gtevr1;         /* Timer 1 event register */
 61         __be16  gtevr2;         /* Timer 2 event register */
 62         __be16  gtevr3;         /* Timer 3 event register */
 63         __be16  gtevr4;         /* Timer 4 event register */
 64         __be16  gtpsr1;         /* Timer 1 prescale register */
 65         __be16  gtpsr2;         /* Timer 2 prescale register */
 66         __be16  gtpsr3;         /* Timer 3 prescale register */
 67         __be16  gtpsr4;         /* Timer 4 prescale register */
 68         u8 res2[0x40];
 69 } __attribute__ ((packed));
 70 
 71 struct gtm {
 72         unsigned int clock;
 73         struct gtm_timers_regs __iomem *regs;
 74         struct gtm_timer timers[4];
 75         spinlock_t lock;
 76         struct list_head list_node;
 77 };
 78 
 79 static LIST_HEAD(gtms);
 80 
 81 /**
 82  * gtm_get_timer - request GTM timer to use it with the rest of GTM API
 83  * Context:     non-IRQ
 84  *
 85  * This function reserves GTM timer for later use. It returns gtm_timer
 86  * structure to use with the rest of GTM API, you should use timer->irq
 87  * to manage timer interrupt.
 88  */
 89 struct gtm_timer *gtm_get_timer16(void)
 90 {
 91         struct gtm *gtm = NULL;
 92         int i;
 93 
 94         list_for_each_entry(gtm, &gtms, list_node) {
 95                 spin_lock_irq(&gtm->lock);
 96 
 97                 for (i = 0; i < ARRAY_SIZE(gtm->timers); i++) {
 98                         if (!gtm->timers[i].requested) {
 99                                 gtm->timers[i].requested = true;
100                                 spin_unlock_irq(&gtm->lock);
101                                 return &gtm->timers[i];
102                         }
103                 }
104 
105                 spin_unlock_irq(&gtm->lock);
106         }
107 
108         if (gtm)
109                 return ERR_PTR(-EBUSY);
110         return ERR_PTR(-ENODEV);
111 }
112 EXPORT_SYMBOL(gtm_get_timer16);
113 
114 /**
115  * gtm_get_specific_timer - request specific GTM timer
116  * @gtm:        specific GTM, pass here GTM's device_node->data
117  * @timer:      specific timer number, Timer1 is 0.
118  * Context:     non-IRQ
119  *
120  * This function reserves GTM timer for later use. It returns gtm_timer
121  * structure to use with the rest of GTM API, you should use timer->irq
122  * to manage timer interrupt.
123  */
124 struct gtm_timer *gtm_get_specific_timer16(struct gtm *gtm,
125                                            unsigned int timer)
126 {
127         struct gtm_timer *ret = ERR_PTR(-EBUSY);
128 
129         if (timer > 3)
130                 return ERR_PTR(-EINVAL);
131 
132         spin_lock_irq(&gtm->lock);
133 
134         if (gtm->timers[timer].requested)
135                 goto out;
136 
137         ret = &gtm->timers[timer];
138         ret->requested = true;
139 
140 out:
141         spin_unlock_irq(&gtm->lock);
142         return ret;
143 }
144 EXPORT_SYMBOL(gtm_get_specific_timer16);
145 
146 /**
147  * gtm_put_timer16 - release 16 bits GTM timer
148  * @tmr:        pointer to the gtm_timer structure obtained from gtm_get_timer
149  * Context:     any
150  *
151  * This function releases GTM timer so others may request it.
152  */
153 void gtm_put_timer16(struct gtm_timer *tmr)
154 {
155         gtm_stop_timer16(tmr);
156 
157         spin_lock_irq(&tmr->gtm->lock);
158         tmr->requested = false;
159         spin_unlock_irq(&tmr->gtm->lock);
160 }
161 EXPORT_SYMBOL(gtm_put_timer16);
162 
163 /*
164  * This is back-end for the exported functions, it's used to reset single
165  * timer in reference mode.
166  */
167 static int gtm_set_ref_timer16(struct gtm_timer *tmr, int frequency,
168                                int reference_value, bool free_run)
169 {
170         struct gtm *gtm = tmr->gtm;
171         int num = tmr - &gtm->timers[0];
172         unsigned int prescaler;
173         u8 iclk = GTMDR_ICLK_ICLK;
174         u8 psr;
175         u8 sps;
176         unsigned long flags;
177         int max_prescaler = 256 * 256 * 16;
178 
179         /* CPM2 doesn't have primary prescaler */
180         if (!tmr->gtpsr)
181                 max_prescaler /= 256;
182 
183         prescaler = gtm->clock / frequency;
184         /*
185          * We have two 8 bit prescalers -- primary and secondary (psr, sps),
186          * plus "slow go" mode (clk / 16). So, total prescale value is
187          * 16 * (psr + 1) * (sps + 1). Though, for CPM2 GTMs we losing psr.
188          */
189         if (prescaler > max_prescaler)
190                 return -EINVAL;
191 
192         if (prescaler > max_prescaler / 16) {
193                 iclk = GTMDR_ICLK_SLGO;
194                 prescaler /= 16;
195         }
196 
197         if (prescaler <= 256) {
198                 psr = 0;
199                 sps = prescaler - 1;
200         } else {
201                 psr = 256 - 1;
202                 sps = prescaler / 256 - 1;
203         }
204 
205         spin_lock_irqsave(&gtm->lock, flags);
206 
207         /*
208          * Properly reset timers: stop, reset, set up prescalers, reference
209          * value and clear event register.
210          */
211         clrsetbits_8(tmr->gtcfr, ~(GTCFR_STP(num) | GTCFR_RST(num)),
212                                  GTCFR_STP(num) | GTCFR_RST(num));
213 
214         setbits8(tmr->gtcfr, GTCFR_STP(num));
215 
216         if (tmr->gtpsr)
217                 out_be16(tmr->gtpsr, psr);
218         clrsetbits_be16(tmr->gtmdr, 0xFFFF, iclk | GTMDR_SPS(sps) |
219                         GTMDR_ORI | (free_run ? GTMDR_FRR : 0));
220         out_be16(tmr->gtcnr, 0);
221         out_be16(tmr->gtrfr, reference_value);
222         out_be16(tmr->gtevr, 0xFFFF);
223 
224         /* Let it be. */
225         clrbits8(tmr->gtcfr, GTCFR_STP(num));
226 
227         spin_unlock_irqrestore(&gtm->lock, flags);
228 
229         return 0;
230 }
231 
232 /**
233  * gtm_set_timer16 - (re)set 16 bit timer with arbitrary precision
234  * @tmr:        pointer to the gtm_timer structure obtained from gtm_get_timer
235  * @usec:       timer interval in microseconds
236  * @reload:     if set, the timer will reset upon expiry rather than
237  *              continue running free.
238  * Context:     any
239  *
240  * This function (re)sets the GTM timer so that it counts up to the requested
241  * interval value, and fires the interrupt when the value is reached. This
242  * function will reduce the precision of the timer as needed in order for the
243  * requested timeout to fit in a 16-bit register.
244  */
245 int gtm_set_timer16(struct gtm_timer *tmr, unsigned long usec, bool reload)
246 {
247         /* quite obvious, frequency which is enough for ┬ÁSec precision */
248         int freq = 1000000;
249         unsigned int bit;
250 
251         bit = fls_long(usec);
252         if (bit > 15) {
253                 freq >>= bit - 15;
254                 usec >>= bit - 15;
255         }
256 
257         if (!freq)
258                 return -EINVAL;
259 
260         return gtm_set_ref_timer16(tmr, freq, usec, reload);
261 }
262 EXPORT_SYMBOL(gtm_set_timer16);
263 
264 /**
265  * gtm_set_exact_utimer16 - (re)set 16 bits timer
266  * @tmr:        pointer to the gtm_timer structure obtained from gtm_get_timer
267  * @usec:       timer interval in microseconds
268  * @reload:     if set, the timer will reset upon expiry rather than
269  *              continue running free.
270  * Context:     any
271  *
272  * This function (re)sets GTM timer so that it counts up to the requested
273  * interval value, and fires the interrupt when the value is reached. If reload
274  * flag was set, timer will also reset itself upon reference value, otherwise
275  * it continues to increment.
276  *
277  * The _exact_ bit in the function name states that this function will not
278  * crop precision of the "usec" argument, thus usec is limited to 16 bits
279  * (single timer width).
280  */
281 int gtm_set_exact_timer16(struct gtm_timer *tmr, u16 usec, bool reload)
282 {
283         /* quite obvious, frequency which is enough for ┬ÁSec precision */
284         const int freq = 1000000;
285 
286         /*
287          * We can lower the frequency (and probably power consumption) by
288          * dividing both frequency and usec by 2 until there is no remainder.
289          * But we won't bother with this unless savings are measured, so just
290          * run the timer as is.
291          */
292 
293         return gtm_set_ref_timer16(tmr, freq, usec, reload);
294 }
295 EXPORT_SYMBOL(gtm_set_exact_timer16);
296 
297 /**
298  * gtm_stop_timer16 - stop single timer
299  * @tmr:        pointer to the gtm_timer structure obtained from gtm_get_timer
300  * Context:     any
301  *
302  * This function simply stops the GTM timer.
303  */
304 void gtm_stop_timer16(struct gtm_timer *tmr)
305 {
306         struct gtm *gtm = tmr->gtm;
307         int num = tmr - &gtm->timers[0];
308         unsigned long flags;
309 
310         spin_lock_irqsave(&gtm->lock, flags);
311 
312         setbits8(tmr->gtcfr, GTCFR_STP(num));
313         out_be16(tmr->gtevr, 0xFFFF);
314 
315         spin_unlock_irqrestore(&gtm->lock, flags);
316 }
317 EXPORT_SYMBOL(gtm_stop_timer16);
318 
319 /**
320  * gtm_ack_timer16 - acknowledge timer event (free-run timers only)
321  * @tmr:        pointer to the gtm_timer structure obtained from gtm_get_timer
322  * @events:     events mask to ack
323  * Context:     any
324  *
325  * Thus function used to acknowledge timer interrupt event, use it inside the
326  * interrupt handler.
327  */
328 void gtm_ack_timer16(struct gtm_timer *tmr, u16 events)
329 {
330         out_be16(tmr->gtevr, events);
331 }
332 EXPORT_SYMBOL(gtm_ack_timer16);
333 
334 static void __init gtm_set_shortcuts(struct device_node *np,
335                                      struct gtm_timer *timers,
336                                      struct gtm_timers_regs __iomem *regs)
337 {
338         /*
339          * Yeah, I don't like this either, but timers' registers a bit messed,
340          * so we have to provide shortcuts to write timer independent code.
341          * Alternative option is to create gt*() accessors, but that will be
342          * even uglier and cryptic.
343          */
344         timers[0].gtcfr = &regs->gtcfr1;
345         timers[0].gtmdr = &regs->gtmdr1;
346         timers[0].gtcnr = &regs->gtcnr1;
347         timers[0].gtrfr = &regs->gtrfr1;
348         timers[0].gtevr = &regs->gtevr1;
349 
350         timers[1].gtcfr = &regs->gtcfr1;
351         timers[1].gtmdr = &regs->gtmdr2;
352         timers[1].gtcnr = &regs->gtcnr2;
353         timers[1].gtrfr = &regs->gtrfr2;
354         timers[1].gtevr = &regs->gtevr2;
355 
356         timers[2].gtcfr = &regs->gtcfr2;
357         timers[2].gtmdr = &regs->gtmdr3;
358         timers[2].gtcnr = &regs->gtcnr3;
359         timers[2].gtrfr = &regs->gtrfr3;
360         timers[2].gtevr = &regs->gtevr3;
361 
362         timers[3].gtcfr = &regs->gtcfr2;
363         timers[3].gtmdr = &regs->gtmdr4;
364         timers[3].gtcnr = &regs->gtcnr4;
365         timers[3].gtrfr = &regs->gtrfr4;
366         timers[3].gtevr = &regs->gtevr4;
367 
368         /* CPM2 doesn't have primary prescaler */
369         if (!of_device_is_compatible(np, "fsl,cpm2-gtm")) {
370                 timers[0].gtpsr = &regs->gtpsr1;
371                 timers[1].gtpsr = &regs->gtpsr2;
372                 timers[2].gtpsr = &regs->gtpsr3;
373                 timers[3].gtpsr = &regs->gtpsr4;
374         }
375 }
376 
377 static int __init fsl_gtm_init(void)
378 {
379         struct device_node *np;
380 
381         for_each_compatible_node(np, NULL, "fsl,gtm") {
382                 int i;
383                 struct gtm *gtm;
384                 const u32 *clock;
385                 int size;
386 
387                 gtm = kzalloc(sizeof(*gtm), GFP_KERNEL);
388                 if (!gtm) {
389                         pr_err("%s: unable to allocate memory\n",
390                                 np->full_name);
391                         continue;
392                 }
393 
394                 spin_lock_init(&gtm->lock);
395 
396                 clock = of_get_property(np, "clock-frequency", &size);
397                 if (!clock || size != sizeof(*clock)) {
398                         pr_err("%s: no clock-frequency\n", np->full_name);
399                         goto err;
400                 }
401                 gtm->clock = *clock;
402 
403                 for (i = 0; i < ARRAY_SIZE(gtm->timers); i++) {
404                         int ret;
405                         struct resource irq;
406 
407                         ret = of_irq_to_resource(np, i, &irq);
408                         if (ret == NO_IRQ) {
409                                 pr_err("%s: not enough interrupts specified\n",
410                                        np->full_name);
411                                 goto err;
412                         }
413                         gtm->timers[i].irq = irq.start;
414                         gtm->timers[i].gtm = gtm;
415                 }
416 
417                 gtm->regs = of_iomap(np, 0);
418                 if (!gtm->regs) {
419                         pr_err("%s: unable to iomap registers\n",
420                                np->full_name);
421                         goto err;
422                 }
423 
424                 gtm_set_shortcuts(np, gtm->timers, gtm->regs);
425                 list_add(&gtm->list_node, &gtms);
426 
427                 /* We don't want to lose the node and its ->data */
428                 np->data = gtm;
429                 of_node_get(np);
430 
431                 continue;
432 err:
433                 kfree(gtm);
434         }
435         return 0;
436 }
437 arch_initcall(fsl_gtm_init);
438 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp