1 /* 2 * PCM timer handling on ctxfi 3 * 4 * This source file is released under GPL v2 license (no other versions). 5 * See the COPYING file included in the main directory of this source 6 * distribution for the license terms and conditions. 7 */ 8 9 #include <linux/slab.h> 10 #include <linux/math64.h> 11 #include <linux/moduleparam.h> 12 #include <sound/core.h> 13 #include <sound/pcm.h> 14 #include "ctatc.h" 15 #include "cthardware.h" 16 #include "cttimer.h" 17 18 static bool use_system_timer; 19 MODULE_PARM_DESC(use_system_timer, "Force to use system-timer"); 20 module_param(use_system_timer, bool, S_IRUGO); 21 22 struct ct_timer_ops { 23 void (*init)(struct ct_timer_instance *); 24 void (*prepare)(struct ct_timer_instance *); 25 void (*start)(struct ct_timer_instance *); 26 void (*stop)(struct ct_timer_instance *); 27 void (*free_instance)(struct ct_timer_instance *); 28 void (*interrupt)(struct ct_timer *); 29 void (*free_global)(struct ct_timer *); 30 }; 31 32 /* timer instance -- assigned to each PCM stream */ 33 struct ct_timer_instance { 34 spinlock_t lock; 35 struct ct_timer *timer_base; 36 struct ct_atc_pcm *apcm; 37 struct snd_pcm_substream *substream; 38 struct timer_list timer; 39 struct list_head instance_list; 40 struct list_head running_list; 41 unsigned int position; 42 unsigned int frag_count; 43 unsigned int running:1; 44 unsigned int need_update:1; 45 }; 46 47 /* timer instance manager */ 48 struct ct_timer { 49 spinlock_t lock; /* global timer lock (for xfitimer) */ 50 spinlock_t list_lock; /* lock for instance list */ 51 struct ct_atc *atc; 52 struct ct_timer_ops *ops; 53 struct list_head instance_head; 54 struct list_head running_head; 55 unsigned int wc; /* current wallclock */ 56 unsigned int irq_handling:1; /* in IRQ handling */ 57 unsigned int reprogram:1; /* need to reprogram the internval */ 58 unsigned int running:1; /* global timer running */ 59 }; 60 61 62 /* 63 * system-timer-based updates 64 */ 65 66 static void ct_systimer_callback(unsigned long data) 67 { 68 struct ct_timer_instance *ti = (struct ct_timer_instance *)data; 69 struct snd_pcm_substream *substream = ti->substream; 70 struct snd_pcm_runtime *runtime = substream->runtime; 71 struct ct_atc_pcm *apcm = ti->apcm; 72 unsigned int period_size = runtime->period_size; 73 unsigned int buffer_size = runtime->buffer_size; 74 unsigned long flags; 75 unsigned int position, dist, interval; 76 77 position = substream->ops->pointer(substream); 78 dist = (position + buffer_size - ti->position) % buffer_size; 79 if (dist >= period_size || 80 position / period_size != ti->position / period_size) { 81 apcm->interrupt(apcm); 82 ti->position = position; 83 } 84 /* Add extra HZ*5/1000 to avoid overrun issue when recording 85 * at 8kHz in 8-bit format or at 88kHz in 24-bit format. */ 86 interval = ((period_size - (position % period_size)) 87 * HZ + (runtime->rate - 1)) / runtime->rate + HZ * 5 / 1000; 88 spin_lock_irqsave(&ti->lock, flags); 89 if (ti->running) 90 mod_timer(&ti->timer, jiffies + interval); 91 spin_unlock_irqrestore(&ti->lock, flags); 92 } 93 94 static void ct_systimer_init(struct ct_timer_instance *ti) 95 { 96 setup_timer(&ti->timer, ct_systimer_callback, 97 (unsigned long)ti); 98 } 99 100 static void ct_systimer_start(struct ct_timer_instance *ti) 101 { 102 struct snd_pcm_runtime *runtime = ti->substream->runtime; 103 unsigned long flags; 104 105 spin_lock_irqsave(&ti->lock, flags); 106 ti->running = 1; 107 mod_timer(&ti->timer, 108 jiffies + (runtime->period_size * HZ + 109 (runtime->rate - 1)) / runtime->rate); 110 spin_unlock_irqrestore(&ti->lock, flags); 111 } 112 113 static void ct_systimer_stop(struct ct_timer_instance *ti) 114 { 115 unsigned long flags; 116 117 spin_lock_irqsave(&ti->lock, flags); 118 ti->running = 0; 119 del_timer(&ti->timer); 120 spin_unlock_irqrestore(&ti->lock, flags); 121 } 122 123 static void ct_systimer_prepare(struct ct_timer_instance *ti) 124 { 125 ct_systimer_stop(ti); 126 try_to_del_timer_sync(&ti->timer); 127 } 128 129 #define ct_systimer_free ct_systimer_prepare 130 131 static struct ct_timer_ops ct_systimer_ops = { 132 .init = ct_systimer_init, 133 .free_instance = ct_systimer_free, 134 .prepare = ct_systimer_prepare, 135 .start = ct_systimer_start, 136 .stop = ct_systimer_stop, 137 }; 138 139 140 /* 141 * Handling multiple streams using a global emu20k1 timer irq 142 */ 143 144 #define CT_TIMER_FREQ 48000 145 #define MIN_TICKS 1 146 #define MAX_TICKS ((1 << 13) - 1) 147 148 static void ct_xfitimer_irq_rearm(struct ct_timer *atimer, int ticks) 149 { 150 struct hw *hw = atimer->atc->hw; 151 if (ticks > MAX_TICKS) 152 ticks = MAX_TICKS; 153 hw->set_timer_tick(hw, ticks); 154 if (!atimer->running) 155 hw->set_timer_irq(hw, 1); 156 atimer->running = 1; 157 } 158 159 static void ct_xfitimer_irq_stop(struct ct_timer *atimer) 160 { 161 if (atimer->running) { 162 struct hw *hw = atimer->atc->hw; 163 hw->set_timer_irq(hw, 0); 164 hw->set_timer_tick(hw, 0); 165 atimer->running = 0; 166 } 167 } 168 169 static inline unsigned int ct_xfitimer_get_wc(struct ct_timer *atimer) 170 { 171 struct hw *hw = atimer->atc->hw; 172 return hw->get_wc(hw); 173 } 174 175 /* 176 * reprogram the timer interval; 177 * checks the running instance list and determines the next timer interval. 178 * also updates the each stream position, returns the number of streams 179 * to call snd_pcm_period_elapsed() appropriately 180 * 181 * call this inside the lock and irq disabled 182 */ 183 static int ct_xfitimer_reprogram(struct ct_timer *atimer, int can_update) 184 { 185 struct ct_timer_instance *ti; 186 unsigned int min_intr = (unsigned int)-1; 187 int updates = 0; 188 unsigned int wc, diff; 189 190 if (list_empty(&atimer->running_head)) { 191 ct_xfitimer_irq_stop(atimer); 192 atimer->reprogram = 0; /* clear flag */ 193 return 0; 194 } 195 196 wc = ct_xfitimer_get_wc(atimer); 197 diff = wc - atimer->wc; 198 atimer->wc = wc; 199 list_for_each_entry(ti, &atimer->running_head, running_list) { 200 if (ti->frag_count > diff) 201 ti->frag_count -= diff; 202 else { 203 unsigned int pos; 204 unsigned int period_size, rate; 205 206 period_size = ti->substream->runtime->period_size; 207 rate = ti->substream->runtime->rate; 208 pos = ti->substream->ops->pointer(ti->substream); 209 if (pos / period_size != ti->position / period_size) { 210 ti->need_update = 1; 211 ti->position = pos; 212 updates++; 213 } 214 pos %= period_size; 215 pos = period_size - pos; 216 ti->frag_count = div_u64((u64)pos * CT_TIMER_FREQ + 217 rate - 1, rate); 218 } 219 if (ti->need_update && !can_update) 220 min_intr = 0; /* pending to the next irq */ 221 if (ti->frag_count < min_intr) 222 min_intr = ti->frag_count; 223 } 224 225 if (min_intr < MIN_TICKS) 226 min_intr = MIN_TICKS; 227 ct_xfitimer_irq_rearm(atimer, min_intr); 228 atimer->reprogram = 0; /* clear flag */ 229 return updates; 230 } 231 232 /* look through the instance list and call period_elapsed if needed */ 233 static void ct_xfitimer_check_period(struct ct_timer *atimer) 234 { 235 struct ct_timer_instance *ti; 236 unsigned long flags; 237 238 spin_lock_irqsave(&atimer->list_lock, flags); 239 list_for_each_entry(ti, &atimer->instance_head, instance_list) { 240 if (ti->running && ti->need_update) { 241 ti->need_update = 0; 242 ti->apcm->interrupt(ti->apcm); 243 } 244 } 245 spin_unlock_irqrestore(&atimer->list_lock, flags); 246 } 247 248 /* Handle timer-interrupt */ 249 static void ct_xfitimer_callback(struct ct_timer *atimer) 250 { 251 int update; 252 unsigned long flags; 253 254 spin_lock_irqsave(&atimer->lock, flags); 255 atimer->irq_handling = 1; 256 do { 257 update = ct_xfitimer_reprogram(atimer, 1); 258 spin_unlock(&atimer->lock); 259 if (update) 260 ct_xfitimer_check_period(atimer); 261 spin_lock(&atimer->lock); 262 } while (atimer->reprogram); 263 atimer->irq_handling = 0; 264 spin_unlock_irqrestore(&atimer->lock, flags); 265 } 266 267 static void ct_xfitimer_prepare(struct ct_timer_instance *ti) 268 { 269 ti->frag_count = ti->substream->runtime->period_size; 270 ti->running = 0; 271 ti->need_update = 0; 272 } 273 274 275 /* start/stop the timer */ 276 static void ct_xfitimer_update(struct ct_timer *atimer) 277 { 278 unsigned long flags; 279 280 spin_lock_irqsave(&atimer->lock, flags); 281 if (atimer->irq_handling) { 282 /* reached from IRQ handler; let it handle later */ 283 atimer->reprogram = 1; 284 spin_unlock_irqrestore(&atimer->lock, flags); 285 return; 286 } 287 288 ct_xfitimer_irq_stop(atimer); 289 ct_xfitimer_reprogram(atimer, 0); 290 spin_unlock_irqrestore(&atimer->lock, flags); 291 } 292 293 static void ct_xfitimer_start(struct ct_timer_instance *ti) 294 { 295 struct ct_timer *atimer = ti->timer_base; 296 unsigned long flags; 297 298 spin_lock_irqsave(&atimer->lock, flags); 299 if (list_empty(&ti->running_list)) 300 atimer->wc = ct_xfitimer_get_wc(atimer); 301 ti->running = 1; 302 ti->need_update = 0; 303 list_add(&ti->running_list, &atimer->running_head); 304 spin_unlock_irqrestore(&atimer->lock, flags); 305 ct_xfitimer_update(atimer); 306 } 307 308 static void ct_xfitimer_stop(struct ct_timer_instance *ti) 309 { 310 struct ct_timer *atimer = ti->timer_base; 311 unsigned long flags; 312 313 spin_lock_irqsave(&atimer->lock, flags); 314 list_del_init(&ti->running_list); 315 ti->running = 0; 316 spin_unlock_irqrestore(&atimer->lock, flags); 317 ct_xfitimer_update(atimer); 318 } 319 320 static void ct_xfitimer_free_global(struct ct_timer *atimer) 321 { 322 ct_xfitimer_irq_stop(atimer); 323 } 324 325 static struct ct_timer_ops ct_xfitimer_ops = { 326 .prepare = ct_xfitimer_prepare, 327 .start = ct_xfitimer_start, 328 .stop = ct_xfitimer_stop, 329 .interrupt = ct_xfitimer_callback, 330 .free_global = ct_xfitimer_free_global, 331 }; 332 333 /* 334 * timer instance 335 */ 336 337 struct ct_timer_instance * 338 ct_timer_instance_new(struct ct_timer *atimer, struct ct_atc_pcm *apcm) 339 { 340 struct ct_timer_instance *ti; 341 342 ti = kzalloc(sizeof(*ti), GFP_KERNEL); 343 if (!ti) 344 return NULL; 345 spin_lock_init(&ti->lock); 346 INIT_LIST_HEAD(&ti->instance_list); 347 INIT_LIST_HEAD(&ti->running_list); 348 ti->timer_base = atimer; 349 ti->apcm = apcm; 350 ti->substream = apcm->substream; 351 if (atimer->ops->init) 352 atimer->ops->init(ti); 353 354 spin_lock_irq(&atimer->list_lock); 355 list_add(&ti->instance_list, &atimer->instance_head); 356 spin_unlock_irq(&atimer->list_lock); 357 358 return ti; 359 } 360 361 void ct_timer_prepare(struct ct_timer_instance *ti) 362 { 363 if (ti->timer_base->ops->prepare) 364 ti->timer_base->ops->prepare(ti); 365 ti->position = 0; 366 ti->running = 0; 367 } 368 369 void ct_timer_start(struct ct_timer_instance *ti) 370 { 371 struct ct_timer *atimer = ti->timer_base; 372 atimer->ops->start(ti); 373 } 374 375 void ct_timer_stop(struct ct_timer_instance *ti) 376 { 377 struct ct_timer *atimer = ti->timer_base; 378 atimer->ops->stop(ti); 379 } 380 381 void ct_timer_instance_free(struct ct_timer_instance *ti) 382 { 383 struct ct_timer *atimer = ti->timer_base; 384 385 atimer->ops->stop(ti); /* to be sure */ 386 if (atimer->ops->free_instance) 387 atimer->ops->free_instance(ti); 388 389 spin_lock_irq(&atimer->list_lock); 390 list_del(&ti->instance_list); 391 spin_unlock_irq(&atimer->list_lock); 392 393 kfree(ti); 394 } 395 396 /* 397 * timer manager 398 */ 399 400 static void ct_timer_interrupt(void *data, unsigned int status) 401 { 402 struct ct_timer *timer = data; 403 404 /* Interval timer interrupt */ 405 if ((status & IT_INT) && timer->ops->interrupt) 406 timer->ops->interrupt(timer); 407 } 408 409 struct ct_timer *ct_timer_new(struct ct_atc *atc) 410 { 411 struct ct_timer *atimer; 412 struct hw *hw; 413 414 atimer = kzalloc(sizeof(*atimer), GFP_KERNEL); 415 if (!atimer) 416 return NULL; 417 spin_lock_init(&atimer->lock); 418 spin_lock_init(&atimer->list_lock); 419 INIT_LIST_HEAD(&atimer->instance_head); 420 INIT_LIST_HEAD(&atimer->running_head); 421 atimer->atc = atc; 422 hw = atc->hw; 423 if (!use_system_timer && hw->set_timer_irq) { 424 dev_info(atc->card->dev, "Use xfi-native timer\n"); 425 atimer->ops = &ct_xfitimer_ops; 426 hw->irq_callback_data = atimer; 427 hw->irq_callback = ct_timer_interrupt; 428 } else { 429 dev_info(atc->card->dev, "Use system timer\n"); 430 atimer->ops = &ct_systimer_ops; 431 } 432 return atimer; 433 } 434 435 void ct_timer_free(struct ct_timer *atimer) 436 { 437 struct hw *hw = atimer->atc->hw; 438 hw->irq_callback = NULL; 439 if (atimer->ops->free_global) 440 atimer->ops->free_global(atimer); 441 kfree(atimer); 442 } 443 444