sound/core/timer.c

   1 /*
   2  *  Timers abstract layer
   3  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
   4  *
   5  *
   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, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19  *
  20  */
  21
  22 #include <sound/driver.h>
  23 #include <linux/delay.h>
  24 #include <linux/init.h>
  25 #include <linux/slab.h>
  26 #include <linux/time.h>
  27 #include <sound/core.h>
  28 #include <sound/timer.h>
  29 #include <sound/control.h>
  30 #include <sound/info.h>
  31 #include <sound/minors.h>
  32 #include <sound/initval.h>
  33 #include <linux/kmod.h>
  34 #ifdef CONFIG_KERNELD
  35 #include <linux/kerneld.h>
  36 #endif
  37
  38 #if !defined(CONFIG_SND_RTCTIMER) && !defined(CONFIG_SND_RTCTIMER_MODULE)
  39 #define DEFAULT_TIMER_LIMIT 1
  40 #else
  41 #define DEFAULT_TIMER_LIMIT 2
  42 #endif
  43
  44 static int timer_limit = DEFAULT_TIMER_LIMIT;
  45 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, Takashi Iwai <tiwai@suse.de>");
  46 MODULE_DESCRIPTION("ALSA timer interface");
  47 MODULE_LICENSE("GPL");
  48 MODULE_CLASSES("{sound}");
  49 MODULE_PARM(timer_limit, "i");
  50 MODULE_PARM_DESC(timer_limit, "Maximum global timers in system.");
  51
  52 typedef struct {
  53         snd_timer_instance_t *timeri;
  54         int tread;                      /* enhanced read with timestamps and events */
  55         unsigned long ticks;
  56         unsigned long overrun;
  57         int qhead;
  58         int qtail;
  59         int qused;
  60         int queue_size;
  61         snd_timer_read_t *queue;
  62         snd_timer_tread_t *tqueue;
  63         spinlock_t qlock;
  64         unsigned long last_resolution;
  65         unsigned int filter;
  66         struct timespec tstamp;         /* trigger tstamp */
  67         wait_queue_head_t qchange_sleep;
  68         struct fasync_struct *fasync;
  69 } snd_timer_user_t;
  70
  71 /* list of timers */
  72 static LIST_HEAD(snd_timer_list);
  73
  74 /* list of slave instances */
  75 static LIST_HEAD(snd_timer_slave_list);
  76
  77 /* lock for slave active lists */
  78 static spinlock_t slave_active_lock = SPIN_LOCK_UNLOCKED;
  79
  80 static DECLARE_MUTEX(register_mutex);
  81
  82 static int snd_timer_free(snd_timer_t *timer);
  83 static int snd_timer_dev_free(snd_device_t *device);
  84 static int snd_timer_dev_register(snd_device_t *device);
  85 static int snd_timer_dev_unregister(snd_device_t *device);
  86
  87 static void snd_timer_reschedule(snd_timer_t * timer, unsigned long ticks_left);
  88
  89 /*
  90  * create a timer instance with the given owner string.
  91  * when timer is not NULL, increments the module counter
  92  */
  93 static snd_timer_instance_t *snd_timer_instance_new(char *owner, snd_timer_t *timer)
  94 {
  95         snd_timer_instance_t *timeri;
  96         timeri = snd_kcalloc(sizeof(snd_timer_instance_t), GFP_KERNEL);
  97         if (timeri == NULL)
  98                 return NULL;
  99         timeri->owner = snd_kmalloc_strdup(owner, GFP_KERNEL);
 100         if (! timeri->owner) {
 101                 kfree(timeri);
 102                 return NULL;
 103         }
 104         INIT_LIST_HEAD(&timeri->open_list);
 105         INIT_LIST_HEAD(&timeri->active_list);
 106         INIT_LIST_HEAD(&timeri->ack_list);
 107         INIT_LIST_HEAD(&timeri->slave_list_head);
 108         INIT_LIST_HEAD(&timeri->slave_active_head);
 109
 110         timeri->timer = timer;
 111         if (timer && timer->card && !try_module_get(timer->card->module)) {
 112                 kfree(timeri->owner);
 113                 kfree(timeri);
 114                 return NULL;
 115         }
 116
 117         return timeri;
 118 }
 119
 120 /*
 121  * find a timer instance from the given timer id
 122  */
 123 static snd_timer_t *snd_timer_find(snd_timer_id_t *tid)
 124 {
 125         snd_timer_t *timer = NULL;
 126         struct list_head *p;
 127
 128         list_for_each(p, &snd_timer_list) {
 129                 timer = (snd_timer_t *)list_entry(p, snd_timer_t, device_list);
 130
 131                 if (timer->tmr_class != tid->dev_class)
 132                         continue;
 133                 if ((timer->tmr_class == SNDRV_TIMER_CLASS_CARD ||
 134                      timer->tmr_class == SNDRV_TIMER_CLASS_PCM) &&
 135                     (timer->card == NULL ||
 136                      timer->card->number != tid->card))
 137                         continue;
 138                 if (timer->tmr_device != tid->device)
 139                         continue;
 140                 if (timer->tmr_subdevice != tid->subdevice)
 141                         continue;
 142                 return timer;
 143         }
 144         return NULL;
 145 }
 146
 147 #ifdef CONFIG_KMOD
 148
 149 static void snd_timer_request(snd_timer_id_t *tid)
 150 {
 151         if (! current->fs->root)
 152                 return;
 153         switch (tid->dev_class) {
 154         case SNDRV_TIMER_CLASS_GLOBAL:
 155                 if (tid->device < timer_limit)
 156                         request_module("snd-timer-%i", tid->device);
 157                 break;
 158         case SNDRV_TIMER_CLASS_CARD:
 159         case SNDRV_TIMER_CLASS_PCM:
 160                 if (tid->card < snd_ecards_limit)
 161                         request_module("snd-card-%i", tid->card);
 162                 break;
 163         default:
 164                 break;
 165         }
 166 }
 167
 168 #endif
 169
 170 /*
 171  * look for a master instance matching with the slave id of the given slave.
 172  * when found, relink the open_link of the slave.
 173  *
 174  * call this with register_mutex down.
 175  */
 176 static void snd_timer_check_slave(snd_timer_instance_t *slave)
 177 {
 178         snd_timer_t *timer;
 179         snd_timer_instance_t *master;
 180         struct list_head *p, *q;
 181
 182         /* FIXME: it's really dumb to look up all entries.. */
 183         list_for_each(p, &snd_timer_list) {
 184                 timer = (snd_timer_t *)list_entry(p, snd_timer_t, device_list);
 185                 list_for_each(q, &timer->open_list_head) {
 186                         master = (snd_timer_instance_t *)list_entry(q, snd_timer_instance_t, open_list);
 187                         if (slave->slave_class == master->slave_class &&
 188                             slave->slave_id == master->slave_id) {
 189                                 list_del(&slave->open_list);
 190                                 list_add_tail(&slave->open_list, &master->slave_list_head);
 191                                 spin_lock_irq(&slave_active_lock);
 192                                 slave->master = master;
 193                                 slave->timer = master->timer;
 194                                 spin_unlock_irq(&slave_active_lock);
 195                                 return;
 196                         }
 197                 }
 198         }
 199 }
 200
 201 /*
 202  * look for slave instances matching with the slave id of the given master.
 203  * when found, relink the open_link of slaves.
 204  *
 205  * call this with register_mutex down.
 206  */
 207 static void snd_timer_check_master(snd_timer_instance_t *master)
 208 {
 209         snd_timer_instance_t *slave;
 210         struct list_head *p, *n;
 211
 212         /* check all pending slaves */
 213         list_for_each_safe(p, n, &snd_timer_slave_list) {
 214                 slave = (snd_timer_instance_t *)list_entry(p, snd_timer_instance_t, open_list);
 215                 if (slave->slave_class == master->slave_class &&
 216                     slave->slave_id == master->slave_id) {
 217                         list_del(p);
 218                         list_add_tail(p, &master->slave_list_head);
 219                         spin_lock_irq(&slave_active_lock);
 220                         slave->master = master;
 221                         slave->timer = master->timer;
 222                         if (slave->flags & SNDRV_TIMER_IFLG_RUNNING)
 223                                 list_add_tail(&slave->active_list, &master->slave_active_head);
 224                         spin_unlock_irq(&slave_active_lock);
 225                 }
 226         }
 227 }
 228
 229 /*
 230  * open a timer instance
 231  * when opening a master, the slave id must be here given.
 232  */
 233 int snd_timer_open(snd_timer_instance_t **ti,
 234                    char *owner, snd_timer_id_t *tid,
 235                    unsigned int slave_id)
 236 {
 237         snd_timer_t *timer;
 238         snd_timer_instance_t *timeri = NULL;
 239
 240         if (tid->dev_class == SNDRV_TIMER_CLASS_SLAVE) {
 241                 /* open a slave instance */
 242                 if (tid->dev_sclass <= SNDRV_TIMER_SCLASS_NONE ||
 243                     tid->dev_sclass > SNDRV_TIMER_SCLASS_OSS_SEQUENCER) {
 244                         snd_printd("invalid slave class %i\n", tid->dev_sclass);
 245                         return -EINVAL;
 246                 }
 247                 down(&register_mutex);
 248                 timeri = snd_timer_instance_new(owner, NULL);
 249                 timeri->slave_class = tid->dev_sclass;
 250                 timeri->slave_id = tid->device;
 251                 timeri->flags |= SNDRV_TIMER_IFLG_SLAVE;
 252                 list_add_tail(&timeri->open_list, &snd_timer_slave_list);
 253                 snd_timer_check_slave(timeri);
 254                 up(&register_mutex);
 255                 *ti = timeri;
 256                 return 0;
 257         }
 258
 259         /* open a master instance */
 260         down(&register_mutex);
 261         timer = snd_timer_find(tid);
 262 #ifdef CONFIG_KMOD
 263         if (timer == NULL) {
 264                 up(&register_mutex);
 265                 snd_timer_request(tid);
 266                 down(&register_mutex);
 267                 timer = snd_timer_find(tid);
 268         }
 269 #endif
 270         if (timer) {
 271                 if (!list_empty(&timer->open_list_head)) {
 272                         timeri = (snd_timer_instance_t *)list_entry(timer->open_list_head.next, snd_timer_instance_t, open_list);
 273                         if (timeri->flags & SNDRV_TIMER_IFLG_EXCLUSIVE) {
 274                                 up(&register_mutex);
 275                                 return -EBUSY;
 276                         }
 277                 }
 278                 timeri = snd_timer_instance_new(owner, timer);
 279                 if (timeri) {
 280                         timeri->slave_class = tid->dev_sclass;
 281                         timeri->slave_id = slave_id;
 282                         if (list_empty(&timer->open_list_head) && timer->hw.open)
 283                                 timer->hw.open(timer);
 284                         list_add_tail(&timeri->open_list, &timer->open_list_head);
 285                         snd_timer_check_master(timeri);
 286                 }
 287         } else {
 288                 up(&register_mutex);
 289                 return -ENODEV;
 290         }
 291         up(&register_mutex);
 292         *ti = timeri;
 293         return 0;
 294 }
 295
 296 static int _snd_timer_stop(snd_timer_instance_t * timeri, int keep_flag, enum sndrv_timer_event event);
 297
 298 /*
 299  * close a timer instance
 300  */
 301 int snd_timer_close(snd_timer_instance_t * timeri)
 302 {
 303         snd_timer_t *timer = NULL;
 304         struct list_head *p, *n;
 305         snd_timer_instance_t *slave;
 306
 307         snd_assert(timeri != NULL, return -ENXIO);
 308
 309         /* force to stop the timer */
 310         snd_timer_stop(timeri);
 311
 312         if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) {
 313                 /* wait, until the active callback is finished */
 314                 spin_lock_irq(&slave_active_lock);
 315                 while (timeri->flags & SNDRV_TIMER_IFLG_CALLBACK) {
 316                         spin_unlock_irq(&slave_active_lock);
 317                         udelay(10);
 318                         spin_lock_irq(&slave_active_lock);
 319                 }
 320                 spin_unlock_irq(&slave_active_lock);
 321                 down(&register_mutex);
 322                 list_del(&timeri->open_list);
 323                 up(&register_mutex);
 324         } else {
 325                 timer = timeri->timer;
 326                 /* wait, until the active callback is finished */
 327                 spin_lock_irq(&timer->lock);
 328                 while (timeri->flags & SNDRV_TIMER_IFLG_CALLBACK) {
 329                         spin_unlock_irq(&timer->lock);
 330                         udelay(10);
 331                         spin_lock_irq(&timer->lock);
 332                 }
 333                 spin_unlock_irq(&timer->lock);
 334                 down(&register_mutex);
 335                 list_del(&timeri->open_list);
 336                 if (timer && list_empty(&timer->open_list_head) && timer->hw.close)
 337                         timer->hw.close(timer);
 338                 /* remove slave links */
 339                 list_for_each_safe(p, n, &timeri->slave_list_head) {
 340                         slave = (snd_timer_instance_t *)list_entry(p, snd_timer_instance_t, open_list);
 341                         spin_lock_irq(&slave_active_lock);
 342                         _snd_timer_stop(slave, 1, SNDRV_TIMER_EVENT_RESOLUTION);
 343                         list_del(p);
 344                         list_add_tail(p, &snd_timer_slave_list);
 345                         slave->master = NULL;
 346                         slave->timer = NULL;
 347                         spin_unlock_irq(&slave_active_lock);
 348                 }
 349                 up(&register_mutex);
 350         }
 351         if (timeri->private_free)
 352                 timeri->private_free(timeri);
 353         if (timeri->owner)
 354                 kfree(timeri->owner);
 355         kfree(timeri);
 356         if (timer && timer->card)
 357                 module_put(timer->card->module);
 358         return 0;
 359 }
 360
 361 unsigned long snd_timer_resolution(snd_timer_instance_t * timeri)
 362 {
 363         snd_timer_t * timer;
 364
 365         if (timeri == NULL)
 366                 return 0;
 367         if ((timer = timeri->timer) != NULL) {
 368                 if (timer->hw.c_resolution)
 369                         return timer->hw.c_resolution(timer);
 370                 return timer->hw.resolution;
 371         }
 372         return 0;
 373 }
 374
 375 static void snd_timer_notify1(snd_timer_instance_t *ti, enum sndrv_timer_event event)
 376 {
 377         snd_timer_t *timer;
 378         unsigned long flags;
 379         unsigned long resolution = 0;
 380         snd_timer_instance_t *ts;
 381         struct list_head *n;
 382         struct timespec tstamp;
 383
 384         snd_timestamp_now(&tstamp, 1);
 385         snd_assert(event >= SNDRV_TIMER_EVENT_START && event <= SNDRV_TIMER_EVENT_PAUSE, return);
 386         if (event == SNDRV_TIMER_EVENT_START || event == SNDRV_TIMER_EVENT_CONTINUE)
 387                 resolution = snd_timer_resolution(ti);
 388         if (ti->ccallback)
 389                 ti->ccallback(ti, SNDRV_TIMER_EVENT_START, &tstamp, resolution);
 390         if (ti->flags & SNDRV_TIMER_IFLG_SLAVE)
 391                 return;
 392         timer = ti->timer;
 393         if (timer == NULL)
 394                 return;
 395         if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
 396                 return;
 397         spin_lock_irqsave(&timer->lock, flags);
 398         list_for_each(n, &ti->slave_active_head) {
 399                 ts = (snd_timer_instance_t *)list_entry(n, snd_timer_instance_t, active_list);
 400                 if (ts->ccallback)
 401                         ts->ccallback(ti, event + 100, &tstamp, resolution);
 402         }
 403         spin_unlock_irqrestore(&timer->lock, flags);
 404 }
 405
 406 static int snd_timer_start1(snd_timer_t *timer, snd_timer_instance_t *timeri, unsigned long sticks)
 407 {
 408         list_del(&timeri->active_list);
 409         list_add_tail(&timeri->active_list, &timer->active_list_head);
 410         if (timer->running) {
 411                 if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
 412                         goto __start_now;
 413                 timer->flags |= SNDRV_TIMER_FLG_RESCHED;
 414                 timeri->flags |= SNDRV_TIMER_IFLG_START;
 415                 return 1;       /* delayed start */
 416         } else {
 417                 timer->sticks = sticks;
 418                 timer->hw.start(timer);
 419               __start_now:
 420                 timer->running++;
 421                 timeri->flags |= SNDRV_TIMER_IFLG_RUNNING;
 422                 return 0;
 423         }
 424 }
 425
 426 static int snd_timer_start_slave(snd_timer_instance_t *timeri)
 427 {
 428         unsigned long flags;
 429
 430         spin_lock_irqsave(&slave_active_lock, flags);
 431         timeri->flags |= SNDRV_TIMER_IFLG_RUNNING;
 432         if (timeri->master)
 433                 list_add_tail(&timeri->active_list, &timeri->master->slave_active_head);
 434         spin_unlock_irqrestore(&slave_active_lock, flags);
 435         return 1; /* delayed start */
 436 }
 437
 438 /*
 439  *  start the timer instance
 440  */
 441 int snd_timer_start(snd_timer_instance_t * timeri, unsigned int ticks)
 442 {
 443         snd_timer_t *timer;
 444         int result = -EINVAL;
 445         unsigned long flags;
 446
 447         if (timeri == NULL || ticks < 1)
 448                 return -EINVAL;
 449         if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) {
 450                 result = snd_timer_start_slave(timeri);
 451                 snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_START);
 452                 return result;
 453         }
 454         timer = timeri->timer;
 455         if (timer == NULL)
 456                 return -EINVAL;
 457         spin_lock_irqsave(&timer->lock, flags);
 458         timeri->ticks = timeri->cticks = ticks;
 459         timeri->pticks = 0;
 460         result = snd_timer_start1(timer, timeri, ticks);
 461         spin_unlock_irqrestore(&timer->lock, flags);
 462         snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_START);
 463         return result;
 464 }
 465
 466 static int _snd_timer_stop(snd_timer_instance_t * timeri, int keep_flag, enum sndrv_timer_event event)
 467 {
 468         snd_timer_t *timer;
 469         unsigned long flags;
 470
 471         snd_assert(timeri != NULL, return -ENXIO);
 472
 473         if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) {
 474                 if (!keep_flag) {
 475                         spin_lock_irqsave(&slave_active_lock, flags);
 476                         timeri->flags &= ~SNDRV_TIMER_IFLG_RUNNING;
 477                         spin_unlock_irqrestore(&slave_active_lock, flags);
 478                 }
 479                 goto __end;
 480         }
 481         timer = timeri->timer;
 482         if (!timer)
 483                 return -EINVAL;
 484         spin_lock_irqsave(&timer->lock, flags);
 485         list_del_init(&timeri->ack_list);
 486         list_del_init(&timeri->active_list);
 487         if ((timeri->flags & SNDRV_TIMER_IFLG_RUNNING) &&
 488             !(--timer->running)) {
 489                 timer->hw.stop(timer);
 490                 if (timer->flags & SNDRV_TIMER_FLG_RESCHED) {
 491                         timer->flags &= ~SNDRV_TIMER_FLG_RESCHED;
 492                         snd_timer_reschedule(timer, 0);
 493                         if (timer->flags & SNDRV_TIMER_FLG_CHANGE) {
 494                                 timer->flags &= ~SNDRV_TIMER_FLG_CHANGE;
 495                                 timer->hw.start(timer);
 496                         }
 497                 }
 498         }
 499         if (!keep_flag)
 500                 timeri->flags &= ~(SNDRV_TIMER_IFLG_RUNNING|SNDRV_TIMER_IFLG_START);
 501         spin_unlock_irqrestore(&timer->lock, flags);
 502       __end:
 503         if (event != SNDRV_TIMER_EVENT_RESOLUTION)
 504                 snd_timer_notify1(timeri, event);
 505         return 0;
 506 }
 507
 508 /*
 509  * stop the timer instance.
 510  *
 511  * do not call this from the timer callback!
 512  */
 513 int snd_timer_stop(snd_timer_instance_t * timeri)
 514 {
 515         snd_timer_t *timer;
 516         unsigned long flags;
 517         int err;
 518
 519         err = _snd_timer_stop(timeri, 0, SNDRV_TIMER_EVENT_STOP);
 520         if (err < 0)
 521                 return err;
 522         timer = timeri->timer;
 523         spin_lock_irqsave(&timer->lock, flags);
 524         timeri->cticks = timeri->ticks;
 525         timeri->pticks = 0;
 526         spin_unlock_irqrestore(&timer->lock, flags);
 527         return 0;
 528 }
 529
 530 /*
 531  * start again..  the tick is kept.
 532  */
 533 int snd_timer_continue(snd_timer_instance_t * timeri)
 534 {
 535         snd_timer_t *timer;
 536         int result = -EINVAL;
 537         unsigned long flags;
 538
 539         if (timeri == NULL)
 540                 return result;
 541         if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE)
 542                 return snd_timer_start_slave(timeri);
 543         timer = timeri->timer;
 544         if (! timer)
 545                 return -EINVAL;
 546         spin_lock_irqsave(&timer->lock, flags);
 547         if (!timeri->cticks)
 548                 timeri->cticks = 1;
 549         timeri->pticks = 0;
 550         result = snd_timer_start1(timer, timeri, timer->sticks);
 551         spin_unlock_irqrestore(&timer->lock, flags);
 552         snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_CONTINUE);
 553         return result;
 554 }
 555
 556 /*
 557  * pause.. remember the ticks left
 558  */
 559 int snd_timer_pause(snd_timer_instance_t * timeri)
 560 {
 561         return _snd_timer_stop(timeri, 0, SNDRV_TIMER_EVENT_PAUSE);
 562 }
 563
 564 /*
 565  * reschedule the timer
 566  *
 567  * start pending instances and check the scheduling ticks.
 568  * when the scheduling ticks is changed set CHANGE flag to reprogram the timer.
 569  */
 570 static void snd_timer_reschedule(snd_timer_t * timer, unsigned long ticks_left)
 571 {
 572         snd_timer_instance_t *ti;
 573         unsigned long ticks = ~0UL;
 574         struct list_head *p;
 575
 576         list_for_each(p, &timer->active_list_head) {
 577                 ti = (snd_timer_instance_t *)list_entry(p, snd_timer_instance_t, active_list);
 578                 if (ti->flags & SNDRV_TIMER_IFLG_START) {
 579                         ti->flags &= ~SNDRV_TIMER_IFLG_START;
 580                         ti->flags |= SNDRV_TIMER_IFLG_RUNNING;
 581                         timer->running++;
 582                 }
 583                 if (ti->flags & SNDRV_TIMER_IFLG_RUNNING) {
 584                         if (ticks > ti->cticks)
 585                                 ticks = ti->cticks;
 586                 }
 587         }
 588         if (ticks == ~0UL) {
 589                 timer->flags &= ~SNDRV_TIMER_FLG_RESCHED;
 590                 return;
 591         }
 592         if (ticks > timer->hw.ticks)
 593                 ticks = timer->hw.ticks;
 594         if (ticks_left != ticks)
 595                 timer->flags |= SNDRV_TIMER_FLG_CHANGE;
 596         timer->sticks = ticks;
 597 }
 598
 599 /*
 600  * timer tasklet
 601  *
 602  */
 603 static void snd_timer_tasklet(unsigned long arg)
 604 {
 605         snd_timer_t *timer = (snd_timer_t *) arg;
 606         snd_timer_instance_t *ti;
 607         struct list_head *p;
 608         unsigned long resolution, ticks;
 609
 610         spin_lock(&timer->lock);
 611         /* now process all callbacks */
 612         while (!list_empty(&timer->sack_list_head)) {
 613                 p = timer->sack_list_head.next;         /* get first item */
 614                 ti = (snd_timer_instance_t *)list_entry(p, snd_timer_instance_t, ack_list);
 615
 616                 /* remove from ack_list and make empty */
 617                 list_del_init(p);
 618
 619                 ticks = ti->pticks;
 620                 ti->pticks = 0;
 621                 resolution = ti->resolution;
 622
 623                 ti->flags |= SNDRV_TIMER_IFLG_CALLBACK;
 624                 spin_unlock(&timer->lock);
 625                 if (ti->callback)
 626                         ti->callback(ti, resolution, ticks);
 627                 spin_lock(&timer->lock);
 628                 ti->flags &= ~SNDRV_TIMER_IFLG_CALLBACK;
 629         }
 630         spin_unlock(&timer->lock);
 631 }
 632
 633 /*
 634  * timer interrupt
 635  *
 636  * ticks_left is usually equal to timer->sticks.
 637  *
 638  */
 639 void snd_timer_interrupt(snd_timer_t * timer, unsigned long ticks_left)
 640 {
 641         snd_timer_instance_t *ti, *ts;
 642         unsigned long resolution, ticks;
 643         struct list_head *p, *q, *n;
 644         int use_tasklet = 0;
 645
 646         if (timer == NULL)
 647                 return;
 648
 649         spin_lock(&timer->lock);
 650
 651         /* remember the current resolution */
 652         if (timer->hw.c_resolution)
 653                 resolution = timer->hw.c_resolution(timer);
 654         else
 655                 resolution = timer->hw.resolution;
 656
 657         /* loop for all active instances
 658          * here we cannot use list_for_each because the active_list of a processed
 659          * instance is relinked to done_list_head before callback is called.
 660          */
 661         list_for_each_safe(p, n, &timer->active_list_head) {
 662                 ti = (snd_timer_instance_t *)list_entry(p, snd_timer_instance_t, active_list);
 663                 if (!(ti->flags & SNDRV_TIMER_IFLG_RUNNING))
 664                         continue;
 665                 ti->pticks += ticks_left;
 666                 ti->resolution = resolution;
 667                 if (ti->cticks < ticks_left)
 668                         ti->cticks = 0;
 669                 else
 670                         ti->cticks -= ticks_left;
 671                 if (ti->cticks) /* not expired */
 672                         continue;
 673                 if (ti->flags & SNDRV_TIMER_IFLG_AUTO) {
 674                         ti->cticks = ti->ticks;
 675                 } else {
 676                         ti->flags &= ~SNDRV_TIMER_IFLG_RUNNING;
 677                         if (--timer->running)
 678                                 list_del(p);
 679                 }
 680                 if (list_empty(&ti->ack_list)) {
 681                         if ((timer->hw.flags & SNDRV_TIMER_HW_TASKLET) ||
 682                             (ti->flags & SNDRV_TIMER_IFLG_FAST)) {
 683                                 list_add_tail(&ti->ack_list, &timer->ack_list_head);
 684                         } else {
 685                                 list_add_tail(&ti->ack_list, &timer->sack_list_head);
 686                         }
 687                 }
 688                 list_for_each(q, &ti->slave_active_head) {
 689                         ts = (snd_timer_instance_t *)list_entry(q, snd_timer_instance_t, active_list);
 690                         ts->pticks = ti->pticks;
 691                         ts->resolution = resolution;
 692                         if (list_empty(&ts->ack_list)) {
 693                                 if ((timer->hw.flags & SNDRV_TIMER_HW_TASKLET) ||
 694                                     (ti->flags & SNDRV_TIMER_IFLG_FAST)) {
 695                                         list_add_tail(&ts->ack_list, &timer->ack_list_head);
 696                                 } else {
 697                                         list_add_tail(&ts->ack_list, &timer->sack_list_head);
 698                                 }
 699                         }
 700                 }
 701         }
 702         if (timer->flags & SNDRV_TIMER_FLG_RESCHED)
 703                 snd_timer_reschedule(timer, ticks_left);
 704         if (timer->running) {
 705                 if (timer->hw.flags & SNDRV_TIMER_HW_STOP) {
 706                         timer->hw.stop(timer);
 707                         timer->flags |= SNDRV_TIMER_FLG_CHANGE;
 708                 }
 709                 if (!(timer->hw.flags & SNDRV_TIMER_HW_AUTO) ||
 710                     (timer->flags & SNDRV_TIMER_FLG_CHANGE)) {
 711                         /* restart timer */
 712                         timer->flags &= ~SNDRV_TIMER_FLG_CHANGE;
 713                         timer->hw.start(timer);
 714                 }
 715         } else {
 716                 timer->hw.stop(timer);
 717         }
 718
 719         /* now process all fast callbacks */
 720         while (!list_empty(&timer->ack_list_head)) {
 721                 p = timer->ack_list_head.next;          /* get first item */
 722                 ti = (snd_timer_instance_t *)list_entry(p, snd_timer_instance_t, ack_list);
 723
 724                 /* remove from ack_list and make empty */
 725                 list_del_init(p);
 726
 727                 ticks = ti->pticks;
 728                 ti->pticks = 0;
 729
 730                 ti->flags |= SNDRV_TIMER_IFLG_CALLBACK;
 731                 spin_unlock(&timer->lock);
 732                 if (ti->callback)
 733                         ti->callback(ti, resolution, ticks);
 734                 spin_lock(&timer->lock);
 735                 ti->flags &= ~SNDRV_TIMER_IFLG_CALLBACK;
 736         }
 737
 738         /* do we have any slow callbacks? */
 739         use_tasklet = !list_empty(&timer->sack_list_head);
 740         spin_unlock(&timer->lock);
 741
 742         if (use_tasklet)
 743                 tasklet_hi_schedule(&timer->task_queue);
 744 }
 745
 746 /*
 747
 748  */
 749
 750 int snd_timer_new(snd_card_t *card, char *id, snd_timer_id_t *tid, snd_timer_t ** rtimer)
 751 {
 752         snd_timer_t *timer;
 753         int err;
 754         static snd_device_ops_t ops = {
 755                 .dev_free = snd_timer_dev_free,
 756                 .dev_register = snd_timer_dev_register,
 757                 .dev_unregister = snd_timer_dev_unregister
 758         };
 759
 760         snd_assert(tid != NULL, return -EINVAL);
 761         snd_assert(rtimer != NULL, return -EINVAL);
 762         *rtimer = NULL;
 763         timer = snd_magic_kcalloc(snd_timer_t, 0, GFP_KERNEL);
 764         if (timer == NULL)
 765                 return -ENOMEM;
 766         timer->tmr_class = tid->dev_class;
 767         timer->card = card;
 768         timer->tmr_device = tid->device;
 769         timer->tmr_subdevice = tid->subdevice;
 770         if (id)
 771                 strlcpy(timer->id, id, sizeof(timer->id));
 772         INIT_LIST_HEAD(&timer->device_list);
 773         INIT_LIST_HEAD(&timer->open_list_head);
 774         INIT_LIST_HEAD(&timer->active_list_head);
 775         INIT_LIST_HEAD(&timer->ack_list_head);
 776         INIT_LIST_HEAD(&timer->sack_list_head);
 777         spin_lock_init(&timer->lock);
 778         tasklet_init(&timer->task_queue, snd_timer_tasklet, (unsigned long)timer);
 779         if (card != NULL) {
 780                 if ((err = snd_device_new(card, SNDRV_DEV_TIMER, timer, &ops)) < 0) {
 781                         snd_timer_free(timer);
 782                         return err;
 783                 }
 784         }
 785         *rtimer = timer;
 786         return 0;
 787 }
 788
 789 static int snd_timer_free(snd_timer_t *timer)
 790 {
 791         snd_assert(timer != NULL, return -ENXIO);
 792         if (timer->private_free)
 793                 timer->private_free(timer);
 794         snd_magic_kfree(timer);
 795         return 0;
 796 }
 797
 798 int snd_timer_dev_free(snd_device_t *device)
 799 {
 800         snd_timer_t *timer = snd_magic_cast(snd_timer_t, device->device_data, return -ENXIO);
 801         return snd_timer_free(timer);
 802 }
 803
 804 int snd_timer_dev_register(snd_device_t *dev)
 805 {
 806         snd_timer_t *timer = snd_magic_cast(snd_timer_t, dev->device_data, return -ENXIO);
 807         snd_timer_t *timer1;
 808         struct list_head *p;
 809
 810         snd_assert(timer != NULL && timer->hw.start != NULL && timer->hw.stop != NULL, return -ENXIO);
 811         if (!(timer->hw.flags & SNDRV_TIMER_HW_SLAVE) &&
 812             !timer->hw.resolution && timer->hw.c_resolution == NULL)
 813                 return -EINVAL;
 814
 815         down(&register_mutex);
 816         list_for_each(p, &snd_timer_list) {
 817                 timer1 = (snd_timer_t *)list_entry(p, snd_timer_t, device_list);
 818                 if (timer1->tmr_class > timer->tmr_class)
 819                         break;
 820                 if (timer1->tmr_class < timer->tmr_class)
 821                         continue;
 822                 if (timer1->card && timer->card) {
 823                         if (timer1->card->number > timer->card->number)
 824                                 break;
 825                         if (timer1->card->number < timer->card->number)
 826                                 continue;
 827                 }
 828                 if (timer1->tmr_device > timer->tmr_device)
 829                         break;
 830                 if (timer1->tmr_device < timer->tmr_device)
 831                         continue;
 832                 if (timer1->tmr_subdevice > timer->tmr_subdevice)
 833                         break;
 834                 if (timer1->tmr_subdevice < timer->tmr_subdevice)
 835                         continue;
 836                 /* conflicts.. */
 837                 up(&register_mutex);
 838                 return -EBUSY;
 839         }
 840         list_add_tail(&timer->device_list, p);
 841         up(&register_mutex);
 842         return 0;
 843 }
 844
 845 int snd_timer_unregister(snd_timer_t *timer)
 846 {
 847         struct list_head *p, *n;
 848         snd_timer_instance_t *ti;
 849
 850         snd_assert(timer != NULL, return -ENXIO);
 851         down(&register_mutex);
 852         if (! list_empty(&timer->open_list_head)) {
 853                 snd_printk(KERN_WARNING "timer 0x%lx is busy?\n", (long)timer);
 854                 list_for_each_safe(p, n, &timer->open_list_head) {
 855                         list_del_init(p);
 856                         ti = (snd_timer_instance_t *)list_entry(p, snd_timer_instance_t, open_list);
 857                         ti->timer = NULL;
 858                 }
 859         }
 860         list_del(&timer->device_list);
 861         up(&register_mutex);
 862         return snd_timer_free(timer);
 863 }
 864
 865 static int snd_timer_dev_unregister(snd_device_t *device)
 866 {
 867         snd_timer_t *timer = snd_magic_cast(snd_timer_t, device->device_data, return -ENXIO);
 868         return snd_timer_unregister(timer);
 869 }
 870
 871 void snd_timer_notify(snd_timer_t *timer, enum sndrv_timer_event event, struct timespec *tstamp)
 872 {
 873         unsigned long flags;
 874         unsigned long resolution = 0;
 875         snd_timer_instance_t *ti, *ts;
 876         struct list_head *p, *n;
 877
 878         snd_runtime_check(timer->hw.flags & SNDRV_TIMER_HW_SLAVE, return);
 879         snd_assert(event >= SNDRV_TIMER_EVENT_MSTART && event <= SNDRV_TIMER_EVENT_MPAUSE, return);
 880         spin_lock_irqsave(&timer->lock, flags);
 881         if (event == SNDRV_TIMER_EVENT_MSTART || event == SNDRV_TIMER_EVENT_MCONTINUE) {
 882                 if (timer->hw.c_resolution)
 883                         resolution = timer->hw.c_resolution(timer);
 884                 else
 885                         resolution = timer->hw.resolution;
 886         }
 887         list_for_each(p, &timer->active_list_head) {
 888                 ti = (snd_timer_instance_t *)list_entry(p, snd_timer_instance_t, active_list);
 889                 if (ti->ccallback)
 890                         ti->ccallback(ti, event, tstamp, resolution);
 891                 list_for_each(n, &ti->slave_active_head) {
 892                         ts = (snd_timer_instance_t *)list_entry(n, snd_timer_instance_t, active_list);
 893                         if (ts->ccallback)
 894                                 ts->ccallback(ts, event, tstamp, resolution);
 895                 }
 896         }
 897         spin_unlock_irqrestore(&timer->lock, flags);
 898 }
 899
 900 /*
 901  * exported functions for global timers
 902  */
 903 int snd_timer_global_new(char *id, int device, snd_timer_t **rtimer)
 904 {
 905         snd_timer_id_t tid;
 906
 907         tid.dev_class = SNDRV_TIMER_CLASS_GLOBAL;
 908         tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
 909         tid.card = -1;
 910         tid.device = device;
 911         tid.subdevice = 0;
 912         return snd_timer_new(NULL, id, &tid, rtimer);
 913 }
 914
 915 int snd_timer_global_free(snd_timer_t *timer)
 916 {
 917         return snd_timer_free(timer);
 918 }
 919
 920 int snd_timer_global_register(snd_timer_t *timer)
 921 {
 922         snd_device_t dev;
 923
 924         memset(&dev, 0, sizeof(dev));
 925         dev.device_data = timer;
 926         return snd_timer_dev_register(&dev);
 927 }
 928
 929 int snd_timer_global_unregister(snd_timer_t *timer)
 930 {
 931         return snd_timer_unregister(timer);
 932 }
 933
 934 /*
 935  *  System timer
 936  */
 937
 938 struct snd_timer_system_private {
 939         struct timer_list tlist;
 940         struct timer * timer;
 941         unsigned long last_expires;
 942         unsigned long last_jiffies;
 943         unsigned long correction;
 944 };
 945
 946 unsigned int snd_timer_system_resolution(void)
 947 {
 948         return 1000000000L / HZ;
 949 }
 950
 951 static void snd_timer_s_function(unsigned long data)
 952 {
 953         snd_timer_t *timer = (snd_timer_t *)data;
 954         struct snd_timer_system_private *priv = timer->private_data;
 955         unsigned long jiff = jiffies;
 956         if (time_after(jiff, priv->last_expires))
 957                 priv->correction = (long)jiff - (long)priv->last_expires;
 958         snd_timer_interrupt(timer, (long)jiff - (long)priv->last_jiffies);
 959 }
 960
 961 static int snd_timer_s_start(snd_timer_t * timer)
 962 {
 963         struct snd_timer_system_private *priv;
 964         unsigned long njiff;
 965
 966         priv = (struct snd_timer_system_private *) timer->private_data;
 967         njiff = (priv->last_jiffies = jiffies);
 968         if (priv->correction > timer->sticks - 1) {
 969                 priv->correction -= timer->sticks - 1;
 970                 njiff++;
 971         } else {
 972                 njiff += timer->sticks - priv->correction;
 973                 priv->correction -= timer->sticks;
 974         }
 975         priv->last_expires = priv->tlist.expires = njiff;
 976         add_timer(&priv->tlist);
 977         return 0;
 978 }
 979
 980 static int snd_timer_s_stop(snd_timer_t * timer)
 981 {
 982         struct snd_timer_system_private *priv;
 983         unsigned long jiff;
 984
 985         priv = (struct snd_timer_system_private *) timer->private_data;
 986         del_timer(&priv->tlist);
 987         jiff = jiffies;
 988         if (time_before(jiff, priv->last_expires))
 989                 timer->sticks = priv->last_expires - jiff;
 990         else
 991                 timer->sticks = 1;
 992         return 0;
 993 }
 994
 995 static struct _snd_timer_hardware snd_timer_system =
 996 {
 997         .flags =        SNDRV_TIMER_HW_FIRST | SNDRV_TIMER_HW_TASKLET,
 998         .resolution =   1000000000L / HZ,
 999         .ticks =        10000000L,
1000         .start =        snd_timer_s_start,
1001         .stop =         snd_timer_s_stop
1002 };
1003
1004 static void snd_timer_free_system(snd_timer_t *timer)
1005 {
1006         if (timer->private_data)
1007                 kfree(timer->private_data);
1008 }
1009
1010 static int snd_timer_register_system(void)
1011 {
1012         snd_timer_t *timer;
1013         struct snd_timer_system_private *priv;
1014         int err;
1015
1016         if ((err = snd_timer_global_new("system", SNDRV_TIMER_GLOBAL_SYSTEM, &timer)) < 0)
1017                 return err;
1018         strcpy(timer->name, "system timer");
1019         timer->hw = snd_timer_system;
1020         priv = (struct snd_timer_system_private *) snd_kcalloc(sizeof(struct snd_timer_system_private), GFP_KERNEL);
1021         if (priv == NULL) {
1022                 snd_timer_free(timer);
1023                 return -ENOMEM;
1024         }
1025         init_timer(&priv->tlist);
1026         priv->tlist.function = snd_timer_s_function;
1027         priv->tlist.data = (unsigned long) timer;
1028         timer->private_data = priv;
1029         timer->private_free = snd_timer_free_system;
1030         return snd_timer_global_register(timer);
1031 }
1032
1033 /*
1034  *  Info interface
1035  */
1036
1037 static void snd_timer_proc_read(snd_info_entry_t *entry,
1038                                 snd_info_buffer_t * buffer)
1039 {
1040         unsigned long flags;
1041         snd_timer_t *timer;
1042         snd_timer_instance_t *ti;
1043         struct list_head *p, *q;
1044
1045         down(&register_mutex);
1046         list_for_each(p, &snd_timer_list) {
1047                 timer = (snd_timer_t *)list_entry(p, snd_timer_t, device_list);
1048                 switch (timer->tmr_class) {
1049                 case SNDRV_TIMER_CLASS_GLOBAL:
1050                         snd_iprintf(buffer, "G%i: ", timer->tmr_device);
1051                         break;
1052                 case SNDRV_TIMER_CLASS_CARD:
1053                         snd_iprintf(buffer, "C%i-%i: ", timer->card->number, timer->tmr_device);
1054                         break;
1055                 case SNDRV_TIMER_CLASS_PCM:
1056                         snd_iprintf(buffer, "P%i-%i-%i: ", timer->card->number, timer->tmr_device, timer->tmr_subdevice);
1057                         break;
1058                 default:
1059                         snd_iprintf(buffer, "?%i-%i-%i-%i: ", timer->tmr_class, timer->card ? timer->card->number : -1, timer->tmr_device, timer->tmr_subdevice);
1060                 }
1061                 snd_iprintf(buffer, "%s :", timer->name);
1062                 if (timer->hw.resolution)
1063                         snd_iprintf(buffer, " %lu.%03luus (%lu ticks)", timer->hw.resolution / 1000, timer->hw.resolution % 1000, timer->hw.ticks);
1064                 if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
1065                         snd_iprintf(buffer, " SLAVE");
1066                 snd_iprintf(buffer, "\n");
1067                 spin_lock_irqsave(&timer->lock, flags);
1068                 list_for_each(q, &timer->open_list_head) {
1069                         ti = (snd_timer_instance_t *)list_entry(q, snd_timer_instance_t, open_list);
1070                         snd_iprintf(buffer, "  Client %s : %s : lost interrupts %li\n",
1071                                         ti->owner ? ti->owner : "unknown",
1072                                         ti->flags & (SNDRV_TIMER_IFLG_START|SNDRV_TIMER_IFLG_RUNNING) ? "running" : "stopped",
1073                                         ti->lost);
1074                 }
1075                 spin_unlock_irqrestore(&timer->lock, flags);
1076         }
1077         up(&register_mutex);
1078 }
1079
1080 /*
1081  *  USER SPACE interface
1082  */
1083
1084 static void snd_timer_user_interrupt(snd_timer_instance_t *timeri,
1085                                      unsigned long resolution,
1086                                      unsigned long ticks)
1087 {
1088         snd_timer_user_t *tu = snd_magic_cast(snd_timer_user_t, timeri->callback_data, return);
1089         snd_timer_read_t *r;
1090         int prev;
1091
1092         spin_lock(&tu->qlock);
1093         if (tu->qused > 0) {
1094                 prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1;
1095                 r = &tu->queue[prev];
1096                 if (r->resolution == resolution) {
1097                         r->ticks += ticks;
1098                         goto __wake;
1099                 }
1100         }
1101         if (tu->qused >= tu->queue_size) {
1102                 tu->overrun++;
1103         } else {
1104                 r = &tu->queue[tu->qtail++];
1105                 tu->qtail %= tu->queue_size;
1106                 r->resolution = resolution;
1107                 r->ticks = ticks;
1108                 tu->qused++;
1109         }
1110       __wake:
1111         spin_unlock(&tu->qlock);
1112         kill_fasync(&tu->fasync, SIGIO, POLL_IN);
1113         wake_up(&tu->qchange_sleep);
1114 }
1115
1116 static void snd_timer_user_append_to_tqueue(snd_timer_user_t *tu, snd_timer_tread_t *tread)
1117 {
1118         if (tu->qused >= tu->queue_size) {
1119                 tu->overrun++;
1120         } else {
1121                 memcpy(&tu->queue[tu->qtail++], tread, sizeof(*tread));
1122                 tu->qused++;
1123         }
1124 }
1125
1126 static void snd_timer_user_ccallback(snd_timer_instance_t *timeri,
1127                                      enum sndrv_timer_event event,
1128                                      struct timespec *tstamp,
1129                                      unsigned long resolution)
1130 {
1131         snd_timer_user_t *tu = snd_magic_cast(snd_timer_user_t, timeri->callback_data, return);
1132         snd_timer_tread_t r1;
1133
1134         if (event >= SNDRV_TIMER_EVENT_START && event <= SNDRV_TIMER_EVENT_PAUSE)
1135                 tu->tstamp = *tstamp;
1136         if ((tu->filter & (1 << event)) == 0 || !tu->tread)
1137                 return;
1138         r1.event = event;
1139         r1.tstamp = *tstamp;
1140         r1.val = resolution;
1141         spin_lock(&tu->qlock);
1142         snd_timer_user_append_to_tqueue(tu, &r1);
1143         spin_unlock(&tu->qlock);
1144 }
1145
1146 static void snd_timer_user_tinterrupt(snd_timer_instance_t *timeri,
1147                                       unsigned long resolution,
1148                                       unsigned long ticks)
1149 {
1150         snd_timer_user_t *tu = snd_magic_cast(snd_timer_user_t, timeri->callback_data, return);
1151         snd_timer_tread_t *r, r1;
1152         struct timespec tstamp;
1153         int prev, append = 0;
1154
1155         snd_timestamp_zero(&tstamp);
1156         spin_lock(&tu->qlock);
1157         if ((tu->filter & ((1 << SNDRV_TIMER_EVENT_RESOLUTION)|(1 << SNDRV_TIMER_EVENT_TICK))) == 0) {
1158                 spin_unlock(&tu->qlock);
1159                 return;
1160         }
1161         if (tu->last_resolution != resolution || ticks > 0)
1162                 snd_timestamp_now(&tstamp, 1);
1163         if ((tu->filter & (1 << SNDRV_TIMER_EVENT_RESOLUTION)) && tu->last_resolution != resolution) {
1164                 r1.event = SNDRV_TIMER_EVENT_RESOLUTION;
1165                 r1.tstamp = tstamp;
1166                 r1.val = resolution;
1167                 snd_timer_user_append_to_tqueue(tu, &r1);
1168                 tu->last_resolution = resolution;
1169                 append++;
1170         }
1171         if ((tu->filter & (1 << SNDRV_TIMER_EVENT_TICK)) == 0)
1172                 goto __wake;
1173         if (ticks == 0)
1174                 goto __wake;
1175         if (tu->qused > 0) {
1176                 prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1;
1177                 r = &tu->tqueue[prev];
1178                 if (r->event == SNDRV_TIMER_EVENT_TICK) {
1179                         r->tstamp = tstamp;
1180                         r->val += ticks;
1181                         append++;
1182                         goto __wake;
1183                 }
1184         }
1185         r1.event = SNDRV_TIMER_EVENT_TICK;
1186         r1.tstamp = tstamp;
1187         r1.val = ticks;
1188         snd_timer_user_append_to_tqueue(tu, &r1);
1189         append++;
1190       __wake:
1191         spin_unlock(&tu->qlock);
1192         if (append == 0)
1193                 return;
1194         kill_fasync(&tu->fasync, SIGIO, POLL_IN);
1195         wake_up(&tu->qchange_sleep);
1196 }
1197
1198 static int snd_timer_user_open(struct inode *inode, struct file *file)
1199 {
1200         snd_timer_user_t *tu;
1201
1202         tu = snd_magic_kcalloc(snd_timer_user_t, 0, GFP_KERNEL);
1203         if (tu == NULL)
1204                 return -ENOMEM;
1205         spin_lock_init(&tu->qlock);
1206         init_waitqueue_head(&tu->qchange_sleep);
1207         tu->ticks = 1;
1208         tu->queue_size = 128;
1209         tu->queue = (snd_timer_read_t *)kmalloc(tu->queue_size * sizeof(snd_timer_read_t), GFP_KERNEL);
1210         if (tu->queue == NULL) {
1211                 snd_magic_kfree(tu);
1212                 return -ENOMEM;
1213         }
1214         file->private_data = tu;
1215         return 0;
1216 }
1217
1218 static int snd_timer_user_release(struct inode *inode, struct file *file)
1219 {
1220         snd_timer_user_t *tu;
1221
1222         if (file->private_data) {
1223                 tu = snd_magic_cast(snd_timer_user_t, file->private_data, return -ENXIO);
1224                 file->private_data = NULL;
1225                 fasync_helper(-1, file, 0, &tu->fasync);
1226                 if (tu->timeri)
1227                         snd_timer_close(tu->timeri);
1228                 if (tu->queue)
1229                         kfree(tu->queue);
1230                 if (tu->tqueue)
1231                         kfree(tu->tqueue);
1232                 snd_magic_kfree(tu);
1233         }
1234         return 0;
1235 }
1236
1237 static void snd_timer_user_zero_id(snd_timer_id_t *id)
1238 {
1239         id->dev_class = SNDRV_TIMER_CLASS_NONE;
1240         id->dev_sclass = SNDRV_TIMER_SCLASS_NONE;
1241         id->card = -1;
1242         id->device = -1;
1243         id->subdevice = -1;
1244 }
1245
1246 static void snd_timer_user_copy_id(snd_timer_id_t *id, snd_timer_t *timer)
1247 {
1248         id->dev_class = timer->tmr_class;
1249         id->dev_sclass = SNDRV_TIMER_SCLASS_NONE;
1250         id->card = timer->card ? timer->card->number : -1;
1251         id->device = timer->tmr_device;
1252         id->subdevice = timer->tmr_subdevice;
1253 }
1254
1255 static int snd_timer_user_next_device(snd_timer_id_t *_tid)
1256 {
1257         snd_timer_id_t id;
1258         snd_timer_t *timer;
1259         struct list_head *p;
1260
1261         if (copy_from_user(&id, _tid, sizeof(id)))
1262                 return -EFAULT;
1263         down(&register_mutex);
1264         if (id.dev_class < 0) {         /* first item */
1265                 if (list_empty(&snd_timer_list))
1266                         snd_timer_user_zero_id(&id);
1267                 else {
1268                         timer = (snd_timer_t *)list_entry(snd_timer_list.next, snd_timer_t, device_list);
1269                         snd_timer_user_copy_id(&id, timer);
1270                 }
1271         } else {
1272                 switch (id.dev_class) {
1273                 case SNDRV_TIMER_CLASS_GLOBAL:
1274                         id.device = id.device < 0 ? 0 : id.device + 1;
1275                         list_for_each(p, &snd_timer_list) {
1276                                 timer = (snd_timer_t *)list_entry(p, snd_timer_t, device_list);
1277                                 if (timer->tmr_class > SNDRV_TIMER_CLASS_GLOBAL) {
1278                                         snd_timer_user_copy_id(&id, timer);
1279                                         break;
1280                                 }
1281                                 if (timer->tmr_device >= id.device) {
1282                                         snd_timer_user_copy_id(&id, timer);
1283                                         break;
1284                                 }
1285                         }
1286                         if (p == &snd_timer_list)
1287                                 snd_timer_user_zero_id(&id);
1288                         break;
1289                 case SNDRV_TIMER_CLASS_CARD:
1290                 case SNDRV_TIMER_CLASS_PCM:
1291                         if (id.card < 0) {
1292                                 id.card = 0;
1293                         } else {
1294                                 if (id.card < 0) {
1295                                         id.card = 0;
1296                                 } else {
1297                                         if (id.device < 0) {
1298                                                 id.device = 0;
1299                                         } else {
1300                                                 id.subdevice = id.subdevice < 0 ? 0 : id.subdevice + 1;
1301                                         }
1302                                 }
1303                         }
1304                         list_for_each(p, &snd_timer_list) {
1305                                 timer = (snd_timer_t *)list_entry(p, snd_timer_t, device_list);
1306                                 if (timer->tmr_class > id.dev_class) {
1307                                         snd_timer_user_copy_id(&id, timer);
1308                                         break;
1309                                 }
1310                                 if (timer->tmr_class < id.dev_class)
1311                                         continue;
1312                                 if (timer->card->number > id.card) {
1313                                         snd_timer_user_copy_id(&id, timer);
1314                                         break;
1315                                 }
1316                                 if (timer->card->number < id.card)
1317                                         continue;
1318                                 if (timer->tmr_device > id.device) {
1319                                         snd_timer_user_copy_id(&id, timer);
1320                                         break;
1321                                 }
1322                                 if (timer->tmr_device < id.device)
1323                                         continue;
1324                                 if (timer->tmr_subdevice > id.subdevice) {
1325                                         snd_timer_user_copy_id(&id, timer);
1326                                         break;
1327                                 }
1328                                 if (timer->tmr_subdevice < id.subdevice)
1329                                         continue;
1330                                 snd_timer_user_copy_id(&id, timer);
1331                                 break;
1332                         }
1333                         if (p == &snd_timer_list)
1334                                 snd_timer_user_zero_id(&id);
1335                         break;
1336                 default:
1337                         snd_timer_user_zero_id(&id);
1338                 }
1339         }
1340         up(&register_mutex);
1341         if (copy_to_user(_tid, &id, sizeof(*_tid)))
1342                 return -EFAULT;
1343         return 0;
1344 }
1345
1346 static int snd_timer_user_ginfo(struct file *file, snd_timer_ginfo_t *_ginfo)
1347 {
1348         snd_timer_ginfo_t ginfo;
1349         snd_timer_id_t tid;
1350         snd_timer_t *t;
1351         struct list_head *p;
1352         int err = 0;
1353
1354         if (copy_from_user(&ginfo, _ginfo, sizeof(ginfo)))
1355                 return -EFAULT;
1356         tid = ginfo.tid;
1357         memset(&ginfo, 0, sizeof(ginfo));
1358         ginfo.tid = tid;
1359         down(&register_mutex);
1360         t = snd_timer_find(&tid);
1361         if (t != NULL) {
1362                 ginfo.card = t->card ? t->card->number : -1;
1363                 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE)
1364                         ginfo.flags |= SNDRV_TIMER_FLG_SLAVE;
1365                 strlcpy(ginfo.id, t->id, sizeof(ginfo.id));
1366                 strlcpy(ginfo.name, t->name, sizeof(ginfo.name));
1367                 ginfo.resolution = t->hw.resolution;
1368                 if (t->hw.resolution_min > 0) {
1369                         ginfo.resolution_min = t->hw.resolution_min;
1370                         ginfo.resolution_max = t->hw.resolution_max;
1371                 }
1372                 list_for_each(p, &t->open_list_head) {
1373                         ginfo.clients++;
1374                 }
1375         } else {
1376                 err = -ENODEV;
1377         }
1378         up(&register_mutex);
1379         if (err >= 0 && copy_to_user(_ginfo, &ginfo, sizeof(ginfo)))
1380                 err = -EFAULT;
1381         return err;
1382 }
1383
1384 static int snd_timer_user_gparams(struct file *file, snd_timer_gparams_t *_gparams)
1385 {
1386         snd_timer_gparams_t gparams;
1387         snd_timer_t *t;
1388         int err;
1389
1390         if (copy_from_user(&gparams, _gparams, sizeof(gparams)))
1391                 return -EFAULT;
1392         down(&register_mutex);
1393         t = snd_timer_find(&gparams.tid);
1394         if (t != NULL) {
1395                 if (list_empty(&t->open_list_head)) {
1396                         if (t->hw.set_period)
1397                                 err = t->hw.set_period(t, gparams.period_num, gparams.period_den);
1398                         else
1399                                 err = -ENOSYS;
1400                 } else {
1401                         err = -EBUSY;
1402                 }
1403         } else {
1404                 err = -ENODEV;
1405         }
1406         up(&register_mutex);
1407         return err;
1408 }
1409
1410 static int snd_timer_user_gstatus(struct file *file, snd_timer_gstatus_t *_gstatus)
1411 {
1412         snd_timer_gstatus_t gstatus;
1413         snd_timer_id_t tid;
1414         snd_timer_t *t;
1415         int err = 0;
1416
1417         if (copy_from_user(&gstatus, _gstatus, sizeof(gstatus)))
1418                 return -EFAULT;
1419         tid = gstatus.tid;
1420         memset(&gstatus, 0, sizeof(gstatus));
1421         gstatus.tid = tid;
1422         down(&register_mutex);
1423         t = snd_timer_find(&tid);
1424         if (t != NULL) {
1425                 if (t->hw.c_resolution)
1426                         gstatus.resolution = t->hw.c_resolution(t);
1427                 else
1428                         gstatus.resolution = t->hw.resolution;
1429                 if (t->hw.precise_resolution) {
1430                         t->hw.precise_resolution(t, &gstatus.resolution_num, &gstatus.resolution_den);
1431                 } else {
1432                         gstatus.resolution_num = gstatus.resolution;
1433                         gstatus.resolution_den = 1000000000uL;
1434                 }
1435         } else {
1436                 err = -ENODEV;
1437         }
1438         up(&register_mutex);
1439         if (err >= 0 && copy_from_user(_gstatus, &gstatus, sizeof(gstatus)))
1440                 err = -EFAULT;
1441         return err;
1442 }
1443
1444 static int snd_timer_user_tselect(struct file *file, snd_timer_select_t *_tselect)
1445 {
1446         snd_timer_user_t *tu;
1447         snd_timer_select_t tselect;
1448         char str[32];
1449         int err;
1450
1451         tu = snd_magic_cast(snd_timer_user_t, file->private_data, return -ENXIO);
1452         if (tu->timeri)
1453                 snd_timer_close(tu->timeri);
1454         if (copy_from_user(&tselect, _tselect, sizeof(tselect)))
1455                 return -EFAULT;
1456         sprintf(str, "application %i", current->pid);
1457         if (tselect.id.dev_class != SNDRV_TIMER_CLASS_SLAVE)
1458                 tselect.id.dev_sclass = SNDRV_TIMER_SCLASS_APPLICATION;
1459         if ((err = snd_timer_open(&tu->timeri, str, &tselect.id, current->pid)) < 0)
1460                 return err;
1461
1462         if (tu->queue) {
1463                 kfree(tu->queue);
1464                 tu->queue = NULL;
1465         }
1466         if (tu->tqueue) {
1467                 kfree(tu->tqueue);
1468                 tu->tqueue = NULL;
1469         }
1470         if (tu->tread) {
1471                 tu->tqueue = (snd_timer_tread_t *)kmalloc(tu->queue_size * sizeof(snd_timer_tread_t), GFP_KERNEL);
1472                 if (tu->tqueue == NULL) {
1473                         snd_timer_close(tu->timeri);
1474                         return -ENOMEM;
1475                 }
1476         } else {
1477                 tu->queue = (snd_timer_read_t *)kmalloc(tu->queue_size * sizeof(snd_timer_read_t), GFP_KERNEL);
1478                 if (tu->queue == NULL) {
1479                         snd_timer_close(tu->timeri);
1480                         return -ENOMEM;
1481                 }
1482         }
1483
1484         tu->timeri->flags |= SNDRV_TIMER_IFLG_FAST;
1485         tu->timeri->callback = tu->tread ? snd_timer_user_tinterrupt : snd_timer_user_interrupt;
1486         tu->timeri->ccallback = snd_timer_user_ccallback;
1487         tu->timeri->callback_data = (void *)tu;
1488         return 0;
1489 }
1490
1491 static int snd_timer_user_info(struct file *file, snd_timer_info_t *_info)
1492 {
1493         snd_timer_user_t *tu;
1494         snd_timer_info_t info;
1495         snd_timer_t *t;
1496
1497         tu = snd_magic_cast(snd_timer_user_t, file->private_data, return -ENXIO);
1498         snd_assert(tu->timeri != NULL, return -ENXIO);
1499         t = tu->timeri->timer;
1500         snd_assert(t != NULL, return -ENXIO);
1501         memset(&info, 0, sizeof(info));
1502         info.card = t->card ? t->card->number : -1;
1503         if (t->hw.flags & SNDRV_TIMER_HW_SLAVE)
1504                 info.flags |= SNDRV_TIMER_FLG_SLAVE;
1505         strlcpy(info.id, t->id, sizeof(info.id));
1506         strlcpy(info.name, t->name, sizeof(info.name));
1507         info.resolution = t->hw.resolution;
1508         if (copy_to_user(_info, &info, sizeof(*_info)))
1509                 return -EFAULT;
1510         return 0;
1511 }
1512
1513 static int snd_timer_user_params(struct file *file, snd_timer_params_t *_params)
1514 {
1515         unsigned long flags;
1516         snd_timer_user_t *tu;
1517         snd_timer_params_t params;
1518         snd_timer_t *t;
1519         snd_timer_read_t *tr;
1520         snd_timer_tread_t *ttr;
1521         int err;
1522
1523         tu = snd_magic_cast(snd_timer_user_t, file->private_data, return -ENXIO);
1524         snd_assert(tu->timeri != NULL, return -ENXIO);
1525         t = tu->timeri->timer;
1526         snd_assert(t != NULL, return -ENXIO);
1527         if (copy_from_user(&params, _params, sizeof(params)))
1528                 return -EFAULT;
1529         if (!(t->hw.flags & SNDRV_TIMER_HW_SLAVE) && params.ticks < 1) {
1530                 err = -EINVAL;
1531                 goto _end;
1532         }
1533         if (params.queue_size > 0 && (params.queue_size < 32 || params.queue_size > 1024)) {
1534                 err = -EINVAL;
1535                 goto _end;
1536         }
1537         if (params.filter & ~((1<<SNDRV_TIMER_EVENT_RESOLUTION)|
1538                               (1<<SNDRV_TIMER_EVENT_TICK)|
1539                               (1<<SNDRV_TIMER_EVENT_START)|
1540                               (1<<SNDRV_TIMER_EVENT_STOP)|
1541                               (1<<SNDRV_TIMER_EVENT_CONTINUE)|
1542                               (1<<SNDRV_TIMER_EVENT_PAUSE)|
1543                               (1<<SNDRV_TIMER_EVENT_MSTART)|
1544                               (1<<SNDRV_TIMER_EVENT_MSTOP)|
1545                               (1<<SNDRV_TIMER_EVENT_MCONTINUE)|
1546                               (1<<SNDRV_TIMER_EVENT_MPAUSE))) {
1547                 err = -EINVAL;
1548                 goto _end;
1549         }
1550         snd_timer_stop(tu->timeri);
1551         spin_lock_irqsave(&t->lock, flags);
1552         if (params.flags & SNDRV_TIMER_PSFLG_AUTO) {
1553                 tu->timeri->flags |= SNDRV_TIMER_IFLG_AUTO;
1554         } else {
1555                 tu->timeri->flags &= ~SNDRV_TIMER_IFLG_AUTO;
1556         }
1557         if (params.flags & SNDRV_TIMER_PSFLG_EXCLUSIVE) {
1558                 tu->timeri->flags |= SNDRV_TIMER_IFLG_EXCLUSIVE;
1559         } else {
1560                 tu->timeri->flags &= ~SNDRV_TIMER_IFLG_EXCLUSIVE;
1561         }
1562         spin_unlock_irqrestore(&t->lock, flags);
1563         if (params.queue_size > 0 && (unsigned int)tu->queue_size != params.queue_size) {
1564                 if (tu->tread) {
1565                         ttr = (snd_timer_tread_t *)kmalloc(params.queue_size * sizeof(snd_timer_tread_t), GFP_KERNEL);
1566                         if (ttr) {
1567                                 kfree(tu->tqueue);
1568                                 tu->queue_size = params.queue_size;
1569                                 tu->tqueue = ttr;
1570                         }
1571                 } else {
1572                         tr = (snd_timer_read_t *)kmalloc(params.queue_size * sizeof(snd_timer_read_t), GFP_KERNEL);
1573                         if (tr) {
1574                                 kfree(tu->queue);
1575                                 tu->queue_size = params.queue_size;
1576                                 tu->queue = tr;
1577                         }
1578                 }
1579         }
1580         tu->filter = params.filter;
1581         tu->ticks = params.ticks;
1582         err = 0;
1583  _end:
1584         if (copy_to_user(_params, &params, sizeof(params)))
1585                 return -EFAULT;
1586         return err;
1587 }
1588
1589 static int snd_timer_user_status(struct file *file, snd_timer_status_t *_status)
1590 {
1591         unsigned long flags;
1592         snd_timer_user_t *tu;
1593         snd_timer_status_t status;
1594
1595         tu = snd_magic_cast(snd_timer_user_t, file->private_data, return -ENXIO);
1596         snd_assert(tu->timeri != NULL, return -ENXIO);
1597         memset(&status, 0, sizeof(status));
1598         status.tstamp = tu->tstamp;
1599         status.resolution = snd_timer_resolution(tu->timeri);
1600         status.lost = tu->timeri->lost;
1601         status.overrun = tu->overrun;
1602         spin_lock_irqsave(&tu->qlock, flags);
1603         status.queue = tu->qused;
1604         spin_unlock_irqrestore(&tu->qlock, flags);
1605         if (copy_to_user(_status, &status, sizeof(status)))
1606                 return -EFAULT;
1607         return 0;
1608 }
1609
1610 static int snd_timer_user_start(struct file *file)
1611 {
1612         int err;
1613         snd_timer_user_t *tu;
1614
1615         tu = snd_magic_cast(snd_timer_user_t, file->private_data, return -ENXIO);
1616         snd_assert(tu->timeri != NULL, return -ENXIO);
1617         snd_timer_stop(tu->timeri);
1618         tu->timeri->lost = 0;
1619         tu->last_resolution = 0;
1620         return (err = snd_timer_start(tu->timeri, tu->ticks)) < 0 ? err : 0;
1621 }
1622
1623 static int snd_timer_user_stop(struct file *file)
1624 {
1625         int err;
1626         snd_timer_user_t *tu;
1627
1628         tu = snd_magic_cast(snd_timer_user_t, file->private_data, return -ENXIO);
1629         snd_assert(tu->timeri != NULL, return -ENXIO);
1630         return (err = snd_timer_stop(tu->timeri)) < 0 ? err : 0;
1631 }
1632
1633 static int snd_timer_user_continue(struct file *file)
1634 {
1635         int err;
1636         snd_timer_user_t *tu;
1637
1638         tu = snd_magic_cast(snd_timer_user_t, file->private_data, return -ENXIO);
1639         snd_assert(tu->timeri != NULL, return -ENXIO);
1640         tu->timeri->lost = 0;
1641         return (err = snd_timer_continue(tu->timeri)) < 0 ? err : 0;
1642 }
1643
1644 static int snd_timer_user_ioctl(struct inode *inode, struct file *file,
1645                                 unsigned int cmd, unsigned long arg)
1646 {
1647         snd_timer_user_t *tu;
1648
1649         tu = snd_magic_cast(snd_timer_user_t, file->private_data, return -ENXIO);
1650         switch (cmd) {
1651         case SNDRV_TIMER_IOCTL_PVERSION:
1652                 return put_user(SNDRV_TIMER_VERSION, (int *)arg) ? -EFAULT : 0;
1653         case SNDRV_TIMER_IOCTL_NEXT_DEVICE:
1654                 return snd_timer_user_next_device((snd_timer_id_t *)arg);
1655         case SNDRV_TIMER_IOCTL_TREAD:
1656         {
1657                 int xarg;
1658
1659                 if (tu->timeri)         /* too late */
1660                         return -EBUSY;
1661                 if (get_user(xarg, (int *) arg))
1662                         return -EFAULT;
1663                 tu->tread = xarg ? 1 : 0;
1664                 return 0;
1665         }
1666         case SNDRV_TIMER_IOCTL_GINFO:
1667                 return snd_timer_user_ginfo(file, (snd_timer_ginfo_t *)arg);
1668         case SNDRV_TIMER_IOCTL_GPARAMS:
1669                 return snd_timer_user_gparams(file, (snd_timer_gparams_t *)arg);
1670         case SNDRV_TIMER_IOCTL_GSTATUS:
1671                 return snd_timer_user_gstatus(file, (snd_timer_gstatus_t *)arg);
1672         case SNDRV_TIMER_IOCTL_SELECT:
1673                 return snd_timer_user_tselect(file, (snd_timer_select_t *)arg);
1674         case SNDRV_TIMER_IOCTL_INFO:
1675                 return snd_timer_user_info(file, (snd_timer_info_t *)arg);
1676         case SNDRV_TIMER_IOCTL_PARAMS:
1677                 return snd_timer_user_params(file, (snd_timer_params_t *)arg);
1678         case SNDRV_TIMER_IOCTL_STATUS:
1679                 return snd_timer_user_status(file, (snd_timer_status_t *)arg);
1680         case SNDRV_TIMER_IOCTL_START:
1681                 return snd_timer_user_start(file);
1682         case SNDRV_TIMER_IOCTL_STOP:
1683                 return snd_timer_user_stop(file);
1684         case SNDRV_TIMER_IOCTL_CONTINUE:
1685                 return snd_timer_user_continue(file);
1686         }
1687         return -ENOTTY;
1688 }
1689
1690 static int snd_timer_user_fasync(int fd, struct file * file, int on)
1691 {
1692         snd_timer_user_t *tu;
1693         int err;
1694
1695         tu = snd_magic_cast(snd_timer_user_t, file->private_data, return -ENXIO);
1696         err = fasync_helper(fd, file, on, &tu->fasync);
1697         if (err < 0)
1698                 return err;
1699         return 0;
1700 }
1701
1702 static ssize_t snd_timer_user_read(struct file *file, char *buffer, size_t count, loff_t *offset)
1703 {
1704         snd_timer_user_t *tu;
1705         long result = 0, unit;
1706         int err = 0;
1707
1708         tu = snd_magic_cast(snd_timer_user_t, file->private_data, return -ENXIO);
1709         unit = tu->tread ? sizeof(snd_timer_tread_t) : sizeof(snd_timer_read_t);
1710         spin_lock_irq(&tu->qlock);
1711         while ((long)count - result >= unit) {
1712                 while (!tu->qused) {
1713                         wait_queue_t wait;
1714
1715                         if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
1716                                 err = -EAGAIN;
1717                                 break;
1718                         }
1719
1720                         set_current_state(TASK_INTERRUPTIBLE);
1721                         init_waitqueue_entry(&wait, current);
1722                         add_wait_queue(&tu->qchange_sleep, &wait);
1723
1724                         spin_unlock_irq(&tu->qlock);
1725                         schedule();
1726                         spin_lock_irq(&tu->qlock);
1727
1728                         remove_wait_queue(&tu->qchange_sleep, &wait);
1729
1730                         if (signal_pending(current)) {
1731                                 err = -ERESTARTSYS;
1732                                 break;
1733                         }
1734                 }
1735
1736                 spin_unlock_irq(&tu->qlock);
1737                 if (err < 0)
1738                         goto _error;
1739
1740                 if (tu->tread) {
1741                         if (copy_to_user(buffer, &tu->tqueue[tu->qhead++], sizeof(snd_timer_tread_t))) {
1742                                 err = -EFAULT;
1743                                 goto _error;
1744                         }
1745                 } else {
1746                         if (copy_to_user(buffer, &tu->queue[tu->qhead++], sizeof(snd_timer_read_t))) {
1747                                 err = -EFAULT;
1748                                 goto _error;
1749                         }
1750                 }
1751
1752                 tu->qhead %= tu->queue_size;
1753
1754                 result += unit;
1755                 buffer += unit;
1756
1757                 spin_lock_irq(&tu->qlock);
1758                 tu->qused--;
1759         }
1760         spin_unlock_irq(&tu->qlock);
1761  _error:
1762         return result > 0 ? result : err;
1763 }
1764
1765 static unsigned int snd_timer_user_poll(struct file *file, poll_table * wait)
1766 {
1767         unsigned int mask;
1768         snd_timer_user_t *tu;
1769
1770         tu = snd_magic_cast(snd_timer_user_t, file->private_data, return 0);
1771
1772         poll_wait(file, &tu->qchange_sleep, wait);
1773
1774         mask = 0;
1775         if (tu->qused)
1776                 mask |= POLLIN | POLLRDNORM;
1777
1778         return mask;
1779 }
1780
1781 static struct file_operations snd_timer_f_ops =
1782 {
1783         .owner =        THIS_MODULE,
1784         .read =         snd_timer_user_read,
1785         .open =         snd_timer_user_open,
1786         .release =      snd_timer_user_release,
1787         .poll =         snd_timer_user_poll,
1788         .ioctl =        snd_timer_user_ioctl,
1789         .fasync =       snd_timer_user_fasync,
1790 };
1791
1792 static snd_minor_t snd_timer_reg =
1793 {
1794         .comment =      "timer",
1795         .f_ops =        &snd_timer_f_ops,
1796 };
1797
1798 /*
1799  *  ENTRY functions
1800  */
1801
1802 static snd_info_entry_t *snd_timer_proc_entry = NULL;
1803
1804 static int __init alsa_timer_init(void)
1805 {
1806         int err;
1807         snd_info_entry_t *entry;
1808
1809 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
1810         snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1, "system timer");
1811 #endif
1812         if ((entry = snd_info_create_module_entry(THIS_MODULE, "timers", NULL)) != NULL) {
1813                 entry->c.text.read_size = SNDRV_TIMER_DEVICES * 128;
1814                 entry->c.text.read = snd_timer_proc_read;
1815                 if (snd_info_register(entry) < 0) {
1816                         snd_info_free_entry(entry);
1817                         entry = NULL;
1818                 }
1819         }
1820         snd_timer_proc_entry = entry;
1821         if ((err = snd_timer_register_system()) < 0)
1822                 snd_printk(KERN_ERR "unable to register system timer (%i)\n", err);
1823         if ((err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER,
1824                                         NULL, 0, &snd_timer_reg, "timer"))<0)
1825                 snd_printk(KERN_ERR "unable to register timer device (%i)\n", err);
1826         return 0;
1827 }
1828
1829 static void __exit alsa_timer_exit(void)
1830 {
1831         struct list_head *p, *n;
1832
1833         snd_unregister_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0);
1834         /* unregister the system timer */
1835         list_for_each_safe(p, n, &snd_timer_list) {
1836                 snd_timer_t *timer = (snd_timer_t *)list_entry(p, snd_timer_t, device_list);
1837                 snd_timer_unregister(timer);
1838         }
1839         if (snd_timer_proc_entry) {
1840                 snd_info_unregister(snd_timer_proc_entry);
1841                 snd_timer_proc_entry = NULL;
1842         }
1843 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
1844         snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1);
1845 #endif
1846 }
1847
1848 module_init(alsa_timer_init)
1849 module_exit(alsa_timer_exit)
1850
1851 #ifndef MODULE
1852 /* format is: snd-timer=timer_limit */
1853
1854 static int __init alsa_timer_setup(char *str)
1855 {
1856         (void)(get_option(&str,&timer_limit) == 2);
1857         return 1;
1858 }
1859
1860 __setup("snd-timer=", alsa_timer_setup);
1861 #endif /* ifndef MODULE */
1862
1863 EXPORT_SYMBOL(snd_timer_open);
1864 EXPORT_SYMBOL(snd_timer_close);
1865 EXPORT_SYMBOL(snd_timer_resolution);
1866 EXPORT_SYMBOL(snd_timer_start);
1867 EXPORT_SYMBOL(snd_timer_stop);
1868 EXPORT_SYMBOL(snd_timer_continue);
1869 EXPORT_SYMBOL(snd_timer_pause);
1870 EXPORT_SYMBOL(snd_timer_new);
1871 EXPORT_SYMBOL(snd_timer_notify);
1872 EXPORT_SYMBOL(snd_timer_global_new);
1873 EXPORT_SYMBOL(snd_timer_global_free);
1874 EXPORT_SYMBOL(snd_timer_global_register);
1875 EXPORT_SYMBOL(snd_timer_global_unregister);
1876 EXPORT_SYMBOL(snd_timer_interrupt);
1877 EXPORT_SYMBOL(snd_timer_system_resolution);