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