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