arch/blackfin/kernel/gptimers.c

   1 /*
   2  * gptimers.c - Blackfin General Purpose Timer core API
   3  *
   4  * Copyright (c) 2005-2008 Analog Devices Inc.
   5  * Copyright (C) 2005 John DeHority
   6  * Copyright (C) 2006 Hella Aglaia GmbH (awe@aglaia-gmbh.de)
   7  *
   8  * Licensed under the GPLv2.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/io.h>
  14
  15 #include <asm/blackfin.h>
  16 #include <asm/gptimers.h>
  17
  18 #ifdef DEBUG
  19 # define tassert(expr)
  20 #else
  21 # define tassert(expr) \
  22         if (!(expr)) \
  23                 printk(KERN_DEBUG "%s:%s:%i: Assertion failed: " #expr "\n", __FILE__, __func__, __LINE__);
  24 #endif
  25
  26 #define BFIN_TIMER_NUM_GROUP  (BFIN_TIMER_OCTET(MAX_BLACKFIN_GPTIMERS - 1) + 1)
  27
  28 static struct bfin_gptimer_regs * const timer_regs[MAX_BLACKFIN_GPTIMERS] =
  29 {
  30         (void *)TIMER0_CONFIG,
  31         (void *)TIMER1_CONFIG,
  32         (void *)TIMER2_CONFIG,
  33 #if (MAX_BLACKFIN_GPTIMERS > 3)
  34         (void *)TIMER3_CONFIG,
  35         (void *)TIMER4_CONFIG,
  36         (void *)TIMER5_CONFIG,
  37         (void *)TIMER6_CONFIG,
  38         (void *)TIMER7_CONFIG,
  39 # if (MAX_BLACKFIN_GPTIMERS > 8)
  40         (void *)TIMER8_CONFIG,
  41         (void *)TIMER9_CONFIG,
  42         (void *)TIMER10_CONFIG,
  43 #  if (MAX_BLACKFIN_GPTIMERS > 11)
  44         (void *)TIMER11_CONFIG,
  45 #  endif
  46 # endif
  47 #endif
  48 };
  49
  50 static struct bfin_gptimer_group_regs * const group_regs[BFIN_TIMER_NUM_GROUP] =
  51 {
  52         (void *)TIMER0_GROUP_REG,
  53 #if (MAX_BLACKFIN_GPTIMERS > 8)
  54         (void *)TIMER8_GROUP_REG,
  55 #endif
  56 };
  57
  58 static uint32_t const trun_mask[MAX_BLACKFIN_GPTIMERS] =
  59 {
  60         TIMER_STATUS_TRUN0,
  61         TIMER_STATUS_TRUN1,
  62         TIMER_STATUS_TRUN2,
  63 #if (MAX_BLACKFIN_GPTIMERS > 3)
  64         TIMER_STATUS_TRUN3,
  65         TIMER_STATUS_TRUN4,
  66         TIMER_STATUS_TRUN5,
  67         TIMER_STATUS_TRUN6,
  68         TIMER_STATUS_TRUN7,
  69 # if (MAX_BLACKFIN_GPTIMERS > 8)
  70         TIMER_STATUS_TRUN8,
  71         TIMER_STATUS_TRUN9,
  72         TIMER_STATUS_TRUN10,
  73 #  if (MAX_BLACKFIN_GPTIMERS > 11)
  74         TIMER_STATUS_TRUN11,
  75 #  endif
  76 # endif
  77 #endif
  78 };
  79
  80 static uint32_t const tovf_mask[MAX_BLACKFIN_GPTIMERS] =
  81 {
  82         TIMER_STATUS_TOVF0,
  83         TIMER_STATUS_TOVF1,
  84         TIMER_STATUS_TOVF2,
  85 #if (MAX_BLACKFIN_GPTIMERS > 3)
  86         TIMER_STATUS_TOVF3,
  87         TIMER_STATUS_TOVF4,
  88         TIMER_STATUS_TOVF5,
  89         TIMER_STATUS_TOVF6,
  90         TIMER_STATUS_TOVF7,
  91 # if (MAX_BLACKFIN_GPTIMERS > 8)
  92         TIMER_STATUS_TOVF8,
  93         TIMER_STATUS_TOVF9,
  94         TIMER_STATUS_TOVF10,
  95 #  if (MAX_BLACKFIN_GPTIMERS > 11)
  96         TIMER_STATUS_TOVF11,
  97 #  endif
  98 # endif
  99 #endif
 100 };
 101
 102 static uint32_t const timil_mask[MAX_BLACKFIN_GPTIMERS] =
 103 {
 104         TIMER_STATUS_TIMIL0,
 105         TIMER_STATUS_TIMIL1,
 106         TIMER_STATUS_TIMIL2,
 107 #if (MAX_BLACKFIN_GPTIMERS > 3)
 108         TIMER_STATUS_TIMIL3,
 109         TIMER_STATUS_TIMIL4,
 110         TIMER_STATUS_TIMIL5,
 111         TIMER_STATUS_TIMIL6,
 112         TIMER_STATUS_TIMIL7,
 113 # if (MAX_BLACKFIN_GPTIMERS > 8)
 114         TIMER_STATUS_TIMIL8,
 115         TIMER_STATUS_TIMIL9,
 116         TIMER_STATUS_TIMIL10,
 117 #  if (MAX_BLACKFIN_GPTIMERS > 11)
 118         TIMER_STATUS_TIMIL11,
 119 #  endif
 120 # endif
 121 #endif
 122 };
 123
 124 void set_gptimer_pwidth(unsigned int timer_id, uint32_t value)
 125 {
 126         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 127         bfin_write(&timer_regs[timer_id]->width, value);
 128         SSYNC();
 129 }
 130 EXPORT_SYMBOL(set_gptimer_pwidth);
 131
 132 uint32_t get_gptimer_pwidth(unsigned int timer_id)
 133 {
 134         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 135         return bfin_read(&timer_regs[timer_id]->width);
 136 }
 137 EXPORT_SYMBOL(get_gptimer_pwidth);
 138
 139 void set_gptimer_period(unsigned int timer_id, uint32_t period)
 140 {
 141         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 142         bfin_write(&timer_regs[timer_id]->period, period);
 143         SSYNC();
 144 }
 145 EXPORT_SYMBOL(set_gptimer_period);
 146
 147 uint32_t get_gptimer_period(unsigned int timer_id)
 148 {
 149         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 150         return bfin_read(&timer_regs[timer_id]->period);
 151 }
 152 EXPORT_SYMBOL(get_gptimer_period);
 153
 154 uint32_t get_gptimer_count(unsigned int timer_id)
 155 {
 156         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 157         return bfin_read(&timer_regs[timer_id]->counter);
 158 }
 159 EXPORT_SYMBOL(get_gptimer_count);
 160
 161 uint32_t get_gptimer_status(unsigned int group)
 162 {
 163         tassert(group < BFIN_TIMER_NUM_GROUP);
 164         return bfin_read(&group_regs[group]->status);
 165 }
 166 EXPORT_SYMBOL(get_gptimer_status);
 167
 168 void set_gptimer_status(unsigned int group, uint32_t value)
 169 {
 170         tassert(group < BFIN_TIMER_NUM_GROUP);
 171         bfin_write(&group_regs[group]->status, value);
 172         SSYNC();
 173 }
 174 EXPORT_SYMBOL(set_gptimer_status);
 175
 176 static uint32_t read_gptimer_status(unsigned int timer_id)
 177 {
 178         return bfin_read(&group_regs[BFIN_TIMER_OCTET(timer_id)]->status);
 179 }
 180
 181 int get_gptimer_intr(unsigned int timer_id)
 182 {
 183         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 184         return !!(read_gptimer_status(timer_id) & timil_mask[timer_id]);
 185 }
 186 EXPORT_SYMBOL(get_gptimer_intr);
 187
 188 void clear_gptimer_intr(unsigned int timer_id)
 189 {
 190         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 191         bfin_write(&group_regs[BFIN_TIMER_OCTET(timer_id)]->status, timil_mask[timer_id]);
 192 }
 193 EXPORT_SYMBOL(clear_gptimer_intr);
 194
 195 int get_gptimer_over(unsigned int timer_id)
 196 {
 197         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 198         return !!(read_gptimer_status(timer_id) & tovf_mask[timer_id]);
 199 }
 200 EXPORT_SYMBOL(get_gptimer_over);
 201
 202 void clear_gptimer_over(unsigned int timer_id)
 203 {
 204         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 205         bfin_write(&group_regs[BFIN_TIMER_OCTET(timer_id)]->status, tovf_mask[timer_id]);
 206 }
 207 EXPORT_SYMBOL(clear_gptimer_over);
 208
 209 int get_gptimer_run(unsigned int timer_id)
 210 {
 211         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 212         return !!(read_gptimer_status(timer_id) & trun_mask[timer_id]);
 213 }
 214 EXPORT_SYMBOL(get_gptimer_run);
 215
 216 void set_gptimer_config(unsigned int timer_id, uint16_t config)
 217 {
 218         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 219         bfin_write(&timer_regs[timer_id]->config, config);
 220         SSYNC();
 221 }
 222 EXPORT_SYMBOL(set_gptimer_config);
 223
 224 uint16_t get_gptimer_config(unsigned int timer_id)
 225 {
 226         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 227         return bfin_read(&timer_regs[timer_id]->config);
 228 }
 229 EXPORT_SYMBOL(get_gptimer_config);
 230
 231 void enable_gptimers(uint16_t mask)
 232 {
 233         int i;
 234         tassert((mask & ~BLACKFIN_GPTIMER_IDMASK) == 0);
 235         for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i) {
 236                 bfin_write(&group_regs[i]->enable, mask & 0xFF);
 237                 mask >>= 8;
 238         }
 239         SSYNC();
 240 }
 241 EXPORT_SYMBOL(enable_gptimers);
 242
 243 static void _disable_gptimers(uint16_t mask)
 244 {
 245         int i;
 246         uint16_t m = mask;
 247         tassert((mask & ~BLACKFIN_GPTIMER_IDMASK) == 0);
 248         for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i) {
 249                 bfin_write(&group_regs[i]->disable, m & 0xFF);
 250                 m >>= 8;
 251         }
 252 }
 253
 254 void disable_gptimers(uint16_t mask)
 255 {
 256         int i;
 257         _disable_gptimers(mask);
 258         for (i = 0; i < MAX_BLACKFIN_GPTIMERS; ++i)
 259                 if (mask & (1 << i))
 260                         bfin_write(&group_regs[BFIN_TIMER_OCTET(i)]->status, trun_mask[i]);
 261         SSYNC();
 262 }
 263 EXPORT_SYMBOL(disable_gptimers);
 264
 265 void disable_gptimers_sync(uint16_t mask)
 266 {
 267         _disable_gptimers(mask);
 268         SSYNC();
 269 }
 270 EXPORT_SYMBOL(disable_gptimers_sync);
 271
 272 void set_gptimer_pulse_hi(unsigned int timer_id)
 273 {
 274         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 275         bfin_write_or(&timer_regs[timer_id]->config, TIMER_PULSE_HI);
 276         SSYNC();
 277 }
 278 EXPORT_SYMBOL(set_gptimer_pulse_hi);
 279
 280 void clear_gptimer_pulse_hi(unsigned int timer_id)
 281 {
 282         tassert(timer_id < MAX_BLACKFIN_GPTIMERS);
 283         bfin_write_and(&timer_regs[timer_id]->config, ~TIMER_PULSE_HI);
 284         SSYNC();
 285 }
 286 EXPORT_SYMBOL(clear_gptimer_pulse_hi);
 287
 288 uint16_t get_enabled_gptimers(void)
 289 {
 290         int i;
 291         uint16_t result = 0;
 292         for (i = 0; i < BFIN_TIMER_NUM_GROUP; ++i)
 293                 result |= (bfin_read(&group_regs[i]->enable) << (i << 3));
 294         return result;
 295 }
 296 EXPORT_SYMBOL(get_enabled_gptimers);
 297
 298 MODULE_AUTHOR("Axel Weiss (awe@aglaia-gmbh.de)");
 299 MODULE_DESCRIPTION("Blackfin General Purpose Timers API");
 300 MODULE_LICENSE("GPL");