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