sound/core/timer.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Timers abstract layer
0004  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
0005  */
0006
0007 #include <linux/delay.h>
0008 #include <linux/init.h>
0009 #include <linux/slab.h>
0010 #include <linux/time.h>
0011 #include <linux/mutex.h>
0012 #include <linux/device.h>
0013 #include <linux/module.h>
0014 #include <linux/string.h>
0015 #include <linux/sched/signal.h>
0016 #include <sound/core.h>
0017 #include <sound/timer.h>
0018 #include <sound/control.h>
0019 #include <sound/info.h>
0020 #include <sound/minors.h>
0021 #include <sound/initval.h>
0022 #include <linux/kmod.h>
0023
0024 /* internal flags */
0025 #define SNDRV_TIMER_IFLG_PAUSED     0x00010000
0026 #define SNDRV_TIMER_IFLG_DEAD       0x00020000
0027
0028 #if IS_ENABLED(CONFIG_SND_HRTIMER)
0029 #define DEFAULT_TIMER_LIMIT 4
0030 #else
0031 #define DEFAULT_TIMER_LIMIT 1
0032 #endif
0033
0034 static int timer_limit = DEFAULT_TIMER_LIMIT;
0035 static int timer_tstamp_monotonic = 1;
0036 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>");
0037 MODULE_DESCRIPTION("ALSA timer interface");
0038 MODULE_LICENSE("GPL");
0039 module_param(timer_limit, int, 0444);
0040 MODULE_PARM_DESC(timer_limit, "Maximum global timers in system.");
0041 module_param(timer_tstamp_monotonic, int, 0444);
0042 MODULE_PARM_DESC(timer_tstamp_monotonic, "Use posix monotonic clock source for timestamps (default).");
0043
0044 MODULE_ALIAS_CHARDEV(CONFIG_SND_MAJOR, SNDRV_MINOR_TIMER);
0045 MODULE_ALIAS("devname:snd/timer");
0046
0047 enum timer_tread_format {
0048     TREAD_FORMAT_NONE = 0,
0049     TREAD_FORMAT_TIME64,
0050     TREAD_FORMAT_TIME32,
0051 };
0052
0053 struct snd_timer_tread32 {
0054     int event;
0055     s32 tstamp_sec;
0056     s32 tstamp_nsec;
0057     unsigned int val;
0058 };
0059
0060 struct snd_timer_tread64 {
0061     int event;
0062     u8 pad1[4];
0063     s64 tstamp_sec;
0064     s64 tstamp_nsec;
0065     unsigned int val;
0066     u8 pad2[4];
0067 };
0068
0069 struct snd_timer_user {
0070     struct snd_timer_instance *timeri;
0071     int tread;      /* enhanced read with timestamps and events */
0072     unsigned long ticks;
0073     unsigned long overrun;
0074     int qhead;
0075     int qtail;
0076     int qused;
0077     int queue_size;
0078     bool disconnected;
0079     struct snd_timer_read *queue;
0080     struct snd_timer_tread64 *tqueue;
0081     spinlock_t qlock;
0082     unsigned long last_resolution;
0083     unsigned int filter;
0084     struct timespec64 tstamp;       /* trigger tstamp */
0085     wait_queue_head_t qchange_sleep;
0086     struct snd_fasync *fasync;
0087     struct mutex ioctl_lock;
0088 };
0089
0090 struct snd_timer_status32 {
0091     s32 tstamp_sec;         /* Timestamp - last update */
0092     s32 tstamp_nsec;
0093     unsigned int resolution;    /* current period resolution in ns */
0094     unsigned int lost;      /* counter of master tick lost */
0095     unsigned int overrun;       /* count of read queue overruns */
0096     unsigned int queue;     /* used queue size */
0097     unsigned char reserved[64]; /* reserved */
0098 };
0099
0100 #define SNDRV_TIMER_IOCTL_STATUS32  _IOR('T', 0x14, struct snd_timer_status32)
0101
0102 struct snd_timer_status64 {
0103     s64 tstamp_sec;         /* Timestamp - last update */
0104     s64 tstamp_nsec;
0105     unsigned int resolution;    /* current period resolution in ns */
0106     unsigned int lost;      /* counter of master tick lost */
0107     unsigned int overrun;       /* count of read queue overruns */
0108     unsigned int queue;     /* used queue size */
0109     unsigned char reserved[64]; /* reserved */
0110 };
0111
0112 #define SNDRV_TIMER_IOCTL_STATUS64  _IOR('T', 0x14, struct snd_timer_status64)
0113
0114 /* list of timers */
0115 static LIST_HEAD(snd_timer_list);
0116
0117 /* list of slave instances */
0118 static LIST_HEAD(snd_timer_slave_list);
0119
0120 /* lock for slave active lists */
0121 static DEFINE_SPINLOCK(slave_active_lock);
0122
0123 #define MAX_SLAVE_INSTANCES 1000
0124 static int num_slaves;
0125
0126 static DEFINE_MUTEX(register_mutex);
0127
0128 static int snd_timer_free(struct snd_timer *timer);
0129 static int snd_timer_dev_free(struct snd_device *device);
0130 static int snd_timer_dev_register(struct snd_device *device);
0131 static int snd_timer_dev_disconnect(struct snd_device *device);
0132
0133 static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left);
0134
0135 /*
0136  * create a timer instance with the given owner string.
0137  */
0138 struct snd_timer_instance *snd_timer_instance_new(const char *owner)
0139 {
0140     struct snd_timer_instance *timeri;
0141
0142     timeri = kzalloc(sizeof(*timeri), GFP_KERNEL);
0143     if (timeri == NULL)
0144         return NULL;
0145     timeri->owner = kstrdup(owner, GFP_KERNEL);
0146     if (! timeri->owner) {
0147         kfree(timeri);
0148         return NULL;
0149     }
0150     INIT_LIST_HEAD(&timeri->open_list);
0151     INIT_LIST_HEAD(&timeri->active_list);
0152     INIT_LIST_HEAD(&timeri->ack_list);
0153     INIT_LIST_HEAD(&timeri->slave_list_head);
0154     INIT_LIST_HEAD(&timeri->slave_active_head);
0155
0156     return timeri;
0157 }
0158 EXPORT_SYMBOL(snd_timer_instance_new);
0159
0160 void snd_timer_instance_free(struct snd_timer_instance *timeri)
0161 {
0162     if (timeri) {
0163         if (timeri->private_free)
0164             timeri->private_free(timeri);
0165         kfree(timeri->owner);
0166         kfree(timeri);
0167     }
0168 }
0169 EXPORT_SYMBOL(snd_timer_instance_free);
0170
0171 /*
0172  * find a timer instance from the given timer id
0173  */
0174 static struct snd_timer *snd_timer_find(struct snd_timer_id *tid)
0175 {
0176     struct snd_timer *timer;
0177
0178     list_for_each_entry(timer, &snd_timer_list, device_list) {
0179         if (timer->tmr_class != tid->dev_class)
0180             continue;
0181         if ((timer->tmr_class == SNDRV_TIMER_CLASS_CARD ||
0182              timer->tmr_class == SNDRV_TIMER_CLASS_PCM) &&
0183             (timer->card == NULL ||
0184              timer->card->number != tid->card))
0185             continue;
0186         if (timer->tmr_device != tid->device)
0187             continue;
0188         if (timer->tmr_subdevice != tid->subdevice)
0189             continue;
0190         return timer;
0191     }
0192     return NULL;
0193 }
0194
0195 #ifdef CONFIG_MODULES
0196
0197 static void snd_timer_request(struct snd_timer_id *tid)
0198 {
0199     switch (tid->dev_class) {
0200     case SNDRV_TIMER_CLASS_GLOBAL:
0201         if (tid->device < timer_limit)
0202             request_module("snd-timer-%i", tid->device);
0203         break;
0204     case SNDRV_TIMER_CLASS_CARD:
0205     case SNDRV_TIMER_CLASS_PCM:
0206         if (tid->card < snd_ecards_limit)
0207             request_module("snd-card-%i", tid->card);
0208         break;
0209     default:
0210         break;
0211     }
0212 }
0213
0214 #endif
0215
0216 /* move the slave if it belongs to the master; return 1 if match */
0217 static int check_matching_master_slave(struct snd_timer_instance *master,
0218                        struct snd_timer_instance *slave)
0219 {
0220     if (slave->slave_class != master->slave_class ||
0221         slave->slave_id != master->slave_id)
0222         return 0;
0223     if (master->timer->num_instances >= master->timer->max_instances)
0224         return -EBUSY;
0225     list_move_tail(&slave->open_list, &master->slave_list_head);
0226     master->timer->num_instances++;
0227     spin_lock_irq(&slave_active_lock);
0228     spin_lock(&master->timer->lock);
0229     slave->master = master;
0230     slave->timer = master->timer;
0231     if (slave->flags & SNDRV_TIMER_IFLG_RUNNING)
0232         list_add_tail(&slave->active_list, &master->slave_active_head);
0233     spin_unlock(&master->timer->lock);
0234     spin_unlock_irq(&slave_active_lock);
0235     return 1;
0236 }
0237
0238 /*
0239  * look for a master instance matching with the slave id of the given slave.
0240  * when found, relink the open_link of the slave.
0241  *
0242  * call this with register_mutex down.
0243  */
0244 static int snd_timer_check_slave(struct snd_timer_instance *slave)
0245 {
0246     struct snd_timer *timer;
0247     struct snd_timer_instance *master;
0248     int err = 0;
0249
0250     /* FIXME: it's really dumb to look up all entries.. */
0251     list_for_each_entry(timer, &snd_timer_list, device_list) {
0252         list_for_each_entry(master, &timer->open_list_head, open_list) {
0253             err = check_matching_master_slave(master, slave);
0254             if (err != 0) /* match found or error */
0255                 goto out;
0256         }
0257     }
0258  out:
0259     return err < 0 ? err : 0;
0260 }
0261
0262 /*
0263  * look for slave instances matching with the slave id of the given master.
0264  * when found, relink the open_link of slaves.
0265  *
0266  * call this with register_mutex down.
0267  */
0268 static int snd_timer_check_master(struct snd_timer_instance *master)
0269 {
0270     struct snd_timer_instance *slave, *tmp;
0271     int err = 0;
0272
0273     /* check all pending slaves */
0274     list_for_each_entry_safe(slave, tmp, &snd_timer_slave_list, open_list) {
0275         err = check_matching_master_slave(master, slave);
0276         if (err < 0)
0277             break;
0278     }
0279     return err < 0 ? err : 0;
0280 }
0281
0282 static void snd_timer_close_locked(struct snd_timer_instance *timeri,
0283                    struct device **card_devp_to_put);
0284
0285 /*
0286  * open a timer instance
0287  * when opening a master, the slave id must be here given.
0288  */
0289 int snd_timer_open(struct snd_timer_instance *timeri,
0290            struct snd_timer_id *tid,
0291            unsigned int slave_id)
0292 {
0293     struct snd_timer *timer;
0294     struct device *card_dev_to_put = NULL;
0295     int err;
0296
0297     mutex_lock(&register_mutex);
0298     if (tid->dev_class == SNDRV_TIMER_CLASS_SLAVE) {
0299         /* open a slave instance */
0300         if (tid->dev_sclass <= SNDRV_TIMER_SCLASS_NONE ||
0301             tid->dev_sclass > SNDRV_TIMER_SCLASS_OSS_SEQUENCER) {
0302             pr_debug("ALSA: timer: invalid slave class %i\n",
0303                  tid->dev_sclass);
0304             err = -EINVAL;
0305             goto unlock;
0306         }
0307         if (num_slaves >= MAX_SLAVE_INSTANCES) {
0308             err = -EBUSY;
0309             goto unlock;
0310         }
0311         timeri->slave_class = tid->dev_sclass;
0312         timeri->slave_id = tid->device;
0313         timeri->flags |= SNDRV_TIMER_IFLG_SLAVE;
0314         list_add_tail(&timeri->open_list, &snd_timer_slave_list);
0315         num_slaves++;
0316         err = snd_timer_check_slave(timeri);
0317         goto list_added;
0318     }
0319
0320     /* open a master instance */
0321     timer = snd_timer_find(tid);
0322 #ifdef CONFIG_MODULES
0323     if (!timer) {
0324         mutex_unlock(&register_mutex);
0325         snd_timer_request(tid);
0326         mutex_lock(&register_mutex);
0327         timer = snd_timer_find(tid);
0328     }
0329 #endif
0330     if (!timer) {
0331         err = -ENODEV;
0332         goto unlock;
0333     }
0334     if (!list_empty(&timer->open_list_head)) {
0335         struct snd_timer_instance *t =
0336             list_entry(timer->open_list_head.next,
0337                     struct snd_timer_instance, open_list);
0338         if (t->flags & SNDRV_TIMER_IFLG_EXCLUSIVE) {
0339             err = -EBUSY;
0340             goto unlock;
0341         }
0342     }
0343     if (timer->num_instances >= timer->max_instances) {
0344         err = -EBUSY;
0345         goto unlock;
0346     }
0347     if (!try_module_get(timer->module)) {
0348         err = -EBUSY;
0349         goto unlock;
0350     }
0351     /* take a card refcount for safe disconnection */
0352     if (timer->card) {
0353         get_device(&timer->card->card_dev);
0354         card_dev_to_put = &timer->card->card_dev;
0355     }
0356
0357     if (list_empty(&timer->open_list_head) && timer->hw.open) {
0358         err = timer->hw.open(timer);
0359         if (err) {
0360             module_put(timer->module);
0361             goto unlock;
0362         }
0363     }
0364
0365     timeri->timer = timer;
0366     timeri->slave_class = tid->dev_sclass;
0367     timeri->slave_id = slave_id;
0368
0369     list_add_tail(&timeri->open_list, &timer->open_list_head);
0370     timer->num_instances++;
0371     err = snd_timer_check_master(timeri);
0372 list_added:
0373     if (err < 0)
0374         snd_timer_close_locked(timeri, &card_dev_to_put);
0375
0376  unlock:
0377     mutex_unlock(&register_mutex);
0378     /* put_device() is called after unlock for avoiding deadlock */
0379     if (err < 0 && card_dev_to_put)
0380         put_device(card_dev_to_put);
0381     return err;
0382 }
0383 EXPORT_SYMBOL(snd_timer_open);
0384
0385 /*
0386  * close a timer instance
0387  * call this with register_mutex down.
0388  */
0389 static void snd_timer_close_locked(struct snd_timer_instance *timeri,
0390                    struct device **card_devp_to_put)
0391 {
0392     struct snd_timer *timer = timeri->timer;
0393     struct snd_timer_instance *slave, *tmp;
0394
0395     if (timer) {
0396         spin_lock_irq(&timer->lock);
0397         timeri->flags |= SNDRV_TIMER_IFLG_DEAD;
0398         spin_unlock_irq(&timer->lock);
0399     }
0400
0401     if (!list_empty(&timeri->open_list)) {
0402         list_del_init(&timeri->open_list);
0403         if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE)
0404             num_slaves--;
0405     }
0406
0407     /* force to stop the timer */
0408     snd_timer_stop(timeri);
0409
0410     if (timer) {
0411         timer->num_instances--;
0412         /* wait, until the active callback is finished */
0413         spin_lock_irq(&timer->lock);
0414         while (timeri->flags & SNDRV_TIMER_IFLG_CALLBACK) {
0415             spin_unlock_irq(&timer->lock);
0416             udelay(10);
0417             spin_lock_irq(&timer->lock);
0418         }
0419         spin_unlock_irq(&timer->lock);
0420
0421         /* remove slave links */
0422         spin_lock_irq(&slave_active_lock);
0423         spin_lock(&timer->lock);
0424         timeri->timer = NULL;
0425         list_for_each_entry_safe(slave, tmp, &timeri->slave_list_head,
0426                      open_list) {
0427             list_move_tail(&slave->open_list, &snd_timer_slave_list);
0428             timer->num_instances--;
0429             slave->master = NULL;
0430             slave->timer = NULL;
0431             list_del_init(&slave->ack_list);
0432             list_del_init(&slave->active_list);
0433         }
0434         spin_unlock(&timer->lock);
0435         spin_unlock_irq(&slave_active_lock);
0436
0437         /* slave doesn't need to release timer resources below */
0438         if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE)
0439             timer = NULL;
0440     }
0441
0442     if (timer) {
0443         if (list_empty(&timer->open_list_head) && timer->hw.close)
0444             timer->hw.close(timer);
0445         /* release a card refcount for safe disconnection */
0446         if (timer->card)
0447             *card_devp_to_put = &timer->card->card_dev;
0448         module_put(timer->module);
0449     }
0450 }
0451
0452 /*
0453  * close a timer instance
0454  */
0455 void snd_timer_close(struct snd_timer_instance *timeri)
0456 {
0457     struct device *card_dev_to_put = NULL;
0458
0459     if (snd_BUG_ON(!timeri))
0460         return;
0461
0462     mutex_lock(&register_mutex);
0463     snd_timer_close_locked(timeri, &card_dev_to_put);
0464     mutex_unlock(&register_mutex);
0465     /* put_device() is called after unlock for avoiding deadlock */
0466     if (card_dev_to_put)
0467         put_device(card_dev_to_put);
0468 }
0469 EXPORT_SYMBOL(snd_timer_close);
0470
0471 static unsigned long snd_timer_hw_resolution(struct snd_timer *timer)
0472 {
0473     if (timer->hw.c_resolution)
0474         return timer->hw.c_resolution(timer);
0475     else
0476         return timer->hw.resolution;
0477 }
0478
0479 unsigned long snd_timer_resolution(struct snd_timer_instance *timeri)
0480 {
0481     struct snd_timer * timer;
0482     unsigned long ret = 0;
0483     unsigned long flags;
0484
0485     if (timeri == NULL)
0486         return 0;
0487     timer = timeri->timer;
0488     if (timer) {
0489         spin_lock_irqsave(&timer->lock, flags);
0490         ret = snd_timer_hw_resolution(timer);
0491         spin_unlock_irqrestore(&timer->lock, flags);
0492     }
0493     return ret;
0494 }
0495 EXPORT_SYMBOL(snd_timer_resolution);
0496
0497 static void snd_timer_notify1(struct snd_timer_instance *ti, int event)
0498 {
0499     struct snd_timer *timer = ti->timer;
0500     unsigned long resolution = 0;
0501     struct snd_timer_instance *ts;
0502     struct timespec64 tstamp;
0503
0504     if (timer_tstamp_monotonic)
0505         ktime_get_ts64(&tstamp);
0506     else
0507         ktime_get_real_ts64(&tstamp);
0508     if (snd_BUG_ON(event < SNDRV_TIMER_EVENT_START ||
0509                event > SNDRV_TIMER_EVENT_PAUSE))
0510         return;
0511     if (timer &&
0512         (event == SNDRV_TIMER_EVENT_START ||
0513          event == SNDRV_TIMER_EVENT_CONTINUE))
0514         resolution = snd_timer_hw_resolution(timer);
0515     if (ti->ccallback)
0516         ti->ccallback(ti, event, &tstamp, resolution);
0517     if (ti->flags & SNDRV_TIMER_IFLG_SLAVE)
0518         return;
0519     if (timer == NULL)
0520         return;
0521     if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
0522         return;
0523     event += 10; /* convert to SNDRV_TIMER_EVENT_MXXX */
0524     list_for_each_entry(ts, &ti->slave_active_head, active_list)
0525         if (ts->ccallback)
0526             ts->ccallback(ts, event, &tstamp, resolution);
0527 }
0528
0529 /* start/continue a master timer */
0530 static int snd_timer_start1(struct snd_timer_instance *timeri,
0531                 bool start, unsigned long ticks)
0532 {
0533     struct snd_timer *timer;
0534     int result;
0535     unsigned long flags;
0536
0537     timer = timeri->timer;
0538     if (!timer)
0539         return -EINVAL;
0540
0541     spin_lock_irqsave(&timer->lock, flags);
0542     if (timeri->flags & SNDRV_TIMER_IFLG_DEAD) {
0543         result = -EINVAL;
0544         goto unlock;
0545     }
0546     if (timer->card && timer->card->shutdown) {
0547         result = -ENODEV;
0548         goto unlock;
0549     }
0550     if (timeri->flags & (SNDRV_TIMER_IFLG_RUNNING |
0551                  SNDRV_TIMER_IFLG_START)) {
0552         result = -EBUSY;
0553         goto unlock;
0554     }
0555
0556     if (start)
0557         timeri->ticks = timeri->cticks = ticks;
0558     else if (!timeri->cticks)
0559         timeri->cticks = 1;
0560     timeri->pticks = 0;
0561
0562     list_move_tail(&timeri->active_list, &timer->active_list_head);
0563     if (timer->running) {
0564         if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
0565             goto __start_now;
0566         timer->flags |= SNDRV_TIMER_FLG_RESCHED;
0567         timeri->flags |= SNDRV_TIMER_IFLG_START;
0568         result = 1; /* delayed start */
0569     } else {
0570         if (start)
0571             timer->sticks = ticks;
0572         timer->hw.start(timer);
0573           __start_now:
0574         timer->running++;
0575         timeri->flags |= SNDRV_TIMER_IFLG_RUNNING;
0576         result = 0;
0577     }
0578     snd_timer_notify1(timeri, start ? SNDRV_TIMER_EVENT_START :
0579               SNDRV_TIMER_EVENT_CONTINUE);
0580  unlock:
0581     spin_unlock_irqrestore(&timer->lock, flags);
0582     return result;
0583 }
0584
0585 /* start/continue a slave timer */
0586 static int snd_timer_start_slave(struct snd_timer_instance *timeri,
0587                  bool start)
0588 {
0589     unsigned long flags;
0590     int err;
0591
0592     spin_lock_irqsave(&slave_active_lock, flags);
0593     if (timeri->flags & SNDRV_TIMER_IFLG_DEAD) {
0594         err = -EINVAL;
0595         goto unlock;
0596     }
0597     if (timeri->flags & SNDRV_TIMER_IFLG_RUNNING) {
0598         err = -EBUSY;
0599         goto unlock;
0600     }
0601     timeri->flags |= SNDRV_TIMER_IFLG_RUNNING;
0602     if (timeri->master && timeri->timer) {
0603         spin_lock(&timeri->timer->lock);
0604         list_add_tail(&timeri->active_list,
0605                   &timeri->master->slave_active_head);
0606         snd_timer_notify1(timeri, start ? SNDRV_TIMER_EVENT_START :
0607                   SNDRV_TIMER_EVENT_CONTINUE);
0608         spin_unlock(&timeri->timer->lock);
0609     }
0610     err = 1; /* delayed start */
0611  unlock:
0612     spin_unlock_irqrestore(&slave_active_lock, flags);
0613     return err;
0614 }
0615
0616 /* stop/pause a master timer */
0617 static int snd_timer_stop1(struct snd_timer_instance *timeri, bool stop)
0618 {
0619     struct snd_timer *timer;
0620     int result = 0;
0621     unsigned long flags;
0622
0623     timer = timeri->timer;
0624     if (!timer)
0625         return -EINVAL;
0626     spin_lock_irqsave(&timer->lock, flags);
0627     list_del_init(&timeri->ack_list);
0628     list_del_init(&timeri->active_list);
0629     if (!(timeri->flags & (SNDRV_TIMER_IFLG_RUNNING |
0630                    SNDRV_TIMER_IFLG_START))) {
0631         result = -EBUSY;
0632         goto unlock;
0633     }
0634     if (timer->card && timer->card->shutdown)
0635         goto unlock;
0636     if (stop) {
0637         timeri->cticks = timeri->ticks;
0638         timeri->pticks = 0;
0639     }
0640     if ((timeri->flags & SNDRV_TIMER_IFLG_RUNNING) &&
0641         !(--timer->running)) {
0642         timer->hw.stop(timer);
0643         if (timer->flags & SNDRV_TIMER_FLG_RESCHED) {
0644             timer->flags &= ~SNDRV_TIMER_FLG_RESCHED;
0645             snd_timer_reschedule(timer, 0);
0646             if (timer->flags & SNDRV_TIMER_FLG_CHANGE) {
0647                 timer->flags &= ~SNDRV_TIMER_FLG_CHANGE;
0648                 timer->hw.start(timer);
0649             }
0650         }
0651     }
0652     timeri->flags &= ~(SNDRV_TIMER_IFLG_RUNNING | SNDRV_TIMER_IFLG_START);
0653     if (stop)
0654         timeri->flags &= ~SNDRV_TIMER_IFLG_PAUSED;
0655     else
0656         timeri->flags |= SNDRV_TIMER_IFLG_PAUSED;
0657     snd_timer_notify1(timeri, stop ? SNDRV_TIMER_EVENT_STOP :
0658               SNDRV_TIMER_EVENT_PAUSE);
0659  unlock:
0660     spin_unlock_irqrestore(&timer->lock, flags);
0661     return result;
0662 }
0663
0664 /* stop/pause a slave timer */
0665 static int snd_timer_stop_slave(struct snd_timer_instance *timeri, bool stop)
0666 {
0667     unsigned long flags;
0668     bool running;
0669
0670     spin_lock_irqsave(&slave_active_lock, flags);
0671     running = timeri->flags & SNDRV_TIMER_IFLG_RUNNING;
0672     timeri->flags &= ~SNDRV_TIMER_IFLG_RUNNING;
0673     if (timeri->timer) {
0674         spin_lock(&timeri->timer->lock);
0675         list_del_init(&timeri->ack_list);
0676         list_del_init(&timeri->active_list);
0677         if (running)
0678             snd_timer_notify1(timeri, stop ? SNDRV_TIMER_EVENT_STOP :
0679                       SNDRV_TIMER_EVENT_PAUSE);
0680         spin_unlock(&timeri->timer->lock);
0681     }
0682     spin_unlock_irqrestore(&slave_active_lock, flags);
0683     return running ? 0 : -EBUSY;
0684 }
0685
0686 /*
0687  *  start the timer instance
0688  */
0689 int snd_timer_start(struct snd_timer_instance *timeri, unsigned int ticks)
0690 {
0691     if (timeri == NULL || ticks < 1)
0692         return -EINVAL;
0693     if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE)
0694         return snd_timer_start_slave(timeri, true);
0695     else
0696         return snd_timer_start1(timeri, true, ticks);
0697 }
0698 EXPORT_SYMBOL(snd_timer_start);
0699
0700 /*
0701  * stop the timer instance.
0702  *
0703  * do not call this from the timer callback!
0704  */
0705 int snd_timer_stop(struct snd_timer_instance *timeri)
0706 {
0707     if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE)
0708         return snd_timer_stop_slave(timeri, true);
0709     else
0710         return snd_timer_stop1(timeri, true);
0711 }
0712 EXPORT_SYMBOL(snd_timer_stop);
0713
0714 /*
0715  * start again..  the tick is kept.
0716  */
0717 int snd_timer_continue(struct snd_timer_instance *timeri)
0718 {
0719     /* timer can continue only after pause */
0720     if (!(timeri->flags & SNDRV_TIMER_IFLG_PAUSED))
0721         return -EINVAL;
0722
0723     if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE)
0724         return snd_timer_start_slave(timeri, false);
0725     else
0726         return snd_timer_start1(timeri, false, 0);
0727 }
0728 EXPORT_SYMBOL(snd_timer_continue);
0729
0730 /*
0731  * pause.. remember the ticks left
0732  */
0733 int snd_timer_pause(struct snd_timer_instance * timeri)
0734 {
0735     if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE)
0736         return snd_timer_stop_slave(timeri, false);
0737     else
0738         return snd_timer_stop1(timeri, false);
0739 }
0740 EXPORT_SYMBOL(snd_timer_pause);
0741
0742 /*
0743  * reschedule the timer
0744  *
0745  * start pending instances and check the scheduling ticks.
0746  * when the scheduling ticks is changed set CHANGE flag to reprogram the timer.
0747  */
0748 static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left)
0749 {
0750     struct snd_timer_instance *ti;
0751     unsigned long ticks = ~0UL;
0752
0753     list_for_each_entry(ti, &timer->active_list_head, active_list) {
0754         if (ti->flags & SNDRV_TIMER_IFLG_START) {
0755             ti->flags &= ~SNDRV_TIMER_IFLG_START;
0756             ti->flags |= SNDRV_TIMER_IFLG_RUNNING;
0757             timer->running++;
0758         }
0759         if (ti->flags & SNDRV_TIMER_IFLG_RUNNING) {
0760             if (ticks > ti->cticks)
0761                 ticks = ti->cticks;
0762         }
0763     }
0764     if (ticks == ~0UL) {
0765         timer->flags &= ~SNDRV_TIMER_FLG_RESCHED;
0766         return;
0767     }
0768     if (ticks > timer->hw.ticks)
0769         ticks = timer->hw.ticks;
0770     if (ticks_left != ticks)
0771         timer->flags |= SNDRV_TIMER_FLG_CHANGE;
0772     timer->sticks = ticks;
0773 }
0774
0775 /* call callbacks in timer ack list */
0776 static void snd_timer_process_callbacks(struct snd_timer *timer,
0777                     struct list_head *head)
0778 {
0779     struct snd_timer_instance *ti;
0780     unsigned long resolution, ticks;
0781
0782     while (!list_empty(head)) {
0783         ti = list_first_entry(head, struct snd_timer_instance,
0784                       ack_list);
0785
0786         /* remove from ack_list and make empty */
0787         list_del_init(&ti->ack_list);
0788
0789         if (!(ti->flags & SNDRV_TIMER_IFLG_DEAD)) {
0790             ticks = ti->pticks;
0791             ti->pticks = 0;
0792             resolution = ti->resolution;
0793             ti->flags |= SNDRV_TIMER_IFLG_CALLBACK;
0794             spin_unlock(&timer->lock);
0795             if (ti->callback)
0796                 ti->callback(ti, resolution, ticks);
0797             spin_lock(&timer->lock);
0798             ti->flags &= ~SNDRV_TIMER_IFLG_CALLBACK;
0799         }
0800     }
0801 }
0802
0803 /* clear pending instances from ack list */
0804 static void snd_timer_clear_callbacks(struct snd_timer *timer,
0805                       struct list_head *head)
0806 {
0807     unsigned long flags;
0808
0809     spin_lock_irqsave(&timer->lock, flags);
0810     while (!list_empty(head))
0811         list_del_init(head->next);
0812     spin_unlock_irqrestore(&timer->lock, flags);
0813 }
0814
0815 /*
0816  * timer work
0817  *
0818  */
0819 static void snd_timer_work(struct work_struct *work)
0820 {
0821     struct snd_timer *timer = container_of(work, struct snd_timer, task_work);
0822     unsigned long flags;
0823
0824     if (timer->card && timer->card->shutdown) {
0825         snd_timer_clear_callbacks(timer, &timer->sack_list_head);
0826         return;
0827     }
0828
0829     spin_lock_irqsave(&timer->lock, flags);
0830     snd_timer_process_callbacks(timer, &timer->sack_list_head);
0831     spin_unlock_irqrestore(&timer->lock, flags);
0832 }
0833
0834 /*
0835  * timer interrupt
0836  *
0837  * ticks_left is usually equal to timer->sticks.
0838  *
0839  */
0840 void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left)
0841 {
0842     struct snd_timer_instance *ti, *ts, *tmp;
0843     unsigned long resolution;
0844     struct list_head *ack_list_head;
0845     unsigned long flags;
0846     bool use_work = false;
0847
0848     if (timer == NULL)
0849         return;
0850
0851     if (timer->card && timer->card->shutdown) {
0852         snd_timer_clear_callbacks(timer, &timer->ack_list_head);
0853         return;
0854     }
0855
0856     spin_lock_irqsave(&timer->lock, flags);
0857
0858     /* remember the current resolution */
0859     resolution = snd_timer_hw_resolution(timer);
0860
0861     /* loop for all active instances
0862      * Here we cannot use list_for_each_entry because the active_list of a
0863      * processed instance is relinked to done_list_head before the callback
0864      * is called.
0865      */
0866     list_for_each_entry_safe(ti, tmp, &timer->active_list_head,
0867                  active_list) {
0868         if (ti->flags & SNDRV_TIMER_IFLG_DEAD)
0869             continue;
0870         if (!(ti->flags & SNDRV_TIMER_IFLG_RUNNING))
0871             continue;
0872         ti->pticks += ticks_left;
0873         ti->resolution = resolution;
0874         if (ti->cticks < ticks_left)
0875             ti->cticks = 0;
0876         else
0877             ti->cticks -= ticks_left;
0878         if (ti->cticks) /* not expired */
0879             continue;
0880         if (ti->flags & SNDRV_TIMER_IFLG_AUTO) {
0881             ti->cticks = ti->ticks;
0882         } else {
0883             ti->flags &= ~SNDRV_TIMER_IFLG_RUNNING;
0884             --timer->running;
0885             list_del_init(&ti->active_list);
0886         }
0887         if ((timer->hw.flags & SNDRV_TIMER_HW_WORK) ||
0888             (ti->flags & SNDRV_TIMER_IFLG_FAST))
0889             ack_list_head = &timer->ack_list_head;
0890         else
0891             ack_list_head = &timer->sack_list_head;
0892         if (list_empty(&ti->ack_list))
0893             list_add_tail(&ti->ack_list, ack_list_head);
0894         list_for_each_entry(ts, &ti->slave_active_head, active_list) {
0895             ts->pticks = ti->pticks;
0896             ts->resolution = resolution;
0897             if (list_empty(&ts->ack_list))
0898                 list_add_tail(&ts->ack_list, ack_list_head);
0899         }
0900     }
0901     if (timer->flags & SNDRV_TIMER_FLG_RESCHED)
0902         snd_timer_reschedule(timer, timer->sticks);
0903     if (timer->running) {
0904         if (timer->hw.flags & SNDRV_TIMER_HW_STOP) {
0905             timer->hw.stop(timer);
0906             timer->flags |= SNDRV_TIMER_FLG_CHANGE;
0907         }
0908         if (!(timer->hw.flags & SNDRV_TIMER_HW_AUTO) ||
0909             (timer->flags & SNDRV_TIMER_FLG_CHANGE)) {
0910             /* restart timer */
0911             timer->flags &= ~SNDRV_TIMER_FLG_CHANGE;
0912             timer->hw.start(timer);
0913         }
0914     } else {
0915         timer->hw.stop(timer);
0916     }
0917
0918     /* now process all fast callbacks */
0919     snd_timer_process_callbacks(timer, &timer->ack_list_head);
0920
0921     /* do we have any slow callbacks? */
0922     use_work = !list_empty(&timer->sack_list_head);
0923     spin_unlock_irqrestore(&timer->lock, flags);
0924
0925     if (use_work)
0926         queue_work(system_highpri_wq, &timer->task_work);
0927 }
0928 EXPORT_SYMBOL(snd_timer_interrupt);
0929
0930 /*
0931
0932  */
0933
0934 int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid,
0935           struct snd_timer **rtimer)
0936 {
0937     struct snd_timer *timer;
0938     int err;
0939     static const struct snd_device_ops ops = {
0940         .dev_free = snd_timer_dev_free,
0941         .dev_register = snd_timer_dev_register,
0942         .dev_disconnect = snd_timer_dev_disconnect,
0943     };
0944
0945     if (snd_BUG_ON(!tid))
0946         return -EINVAL;
0947     if (tid->dev_class == SNDRV_TIMER_CLASS_CARD ||
0948         tid->dev_class == SNDRV_TIMER_CLASS_PCM) {
0949         if (WARN_ON(!card))
0950             return -EINVAL;
0951     }
0952     if (rtimer)
0953         *rtimer = NULL;
0954     timer = kzalloc(sizeof(*timer), GFP_KERNEL);
0955     if (!timer)
0956         return -ENOMEM;
0957     timer->tmr_class = tid->dev_class;
0958     timer->card = card;
0959     timer->tmr_device = tid->device;
0960     timer->tmr_subdevice = tid->subdevice;
0961     if (id)
0962         strscpy(timer->id, id, sizeof(timer->id));
0963     timer->sticks = 1;
0964     INIT_LIST_HEAD(&timer->device_list);
0965     INIT_LIST_HEAD(&timer->open_list_head);
0966     INIT_LIST_HEAD(&timer->active_list_head);
0967     INIT_LIST_HEAD(&timer->ack_list_head);
0968     INIT_LIST_HEAD(&timer->sack_list_head);
0969     spin_lock_init(&timer->lock);
0970     INIT_WORK(&timer->task_work, snd_timer_work);
0971     timer->max_instances = 1000; /* default limit per timer */
0972     if (card != NULL) {
0973         timer->module = card->module;
0974         err = snd_device_new(card, SNDRV_DEV_TIMER, timer, &ops);
0975         if (err < 0) {
0976             snd_timer_free(timer);
0977             return err;
0978         }
0979     }
0980     if (rtimer)
0981         *rtimer = timer;
0982     return 0;
0983 }
0984 EXPORT_SYMBOL(snd_timer_new);
0985
0986 static int snd_timer_free(struct snd_timer *timer)
0987 {
0988     if (!timer)
0989         return 0;
0990
0991     mutex_lock(&register_mutex);
0992     if (! list_empty(&timer->open_list_head)) {
0993         struct list_head *p, *n;
0994         struct snd_timer_instance *ti;
0995         pr_warn("ALSA: timer %p is busy?\n", timer);
0996         list_for_each_safe(p, n, &timer->open_list_head) {
0997             list_del_init(p);
0998             ti = list_entry(p, struct snd_timer_instance, open_list);
0999             ti->timer = NULL;
1000         }
1001     }
1002     list_del(&timer->device_list);
1003     mutex_unlock(&register_mutex);
1004
1005     if (timer->private_free)
1006         timer->private_free(timer);
1007     kfree(timer);
1008     return 0;
1009 }
1010
1011 static int snd_timer_dev_free(struct snd_device *device)
1012 {
1013     struct snd_timer *timer = device->device_data;
1014     return snd_timer_free(timer);
1015 }
1016
1017 static int snd_timer_dev_register(struct snd_device *dev)
1018 {
1019     struct snd_timer *timer = dev->device_data;
1020     struct snd_timer *timer1;
1021
1022     if (snd_BUG_ON(!timer || !timer->hw.start || !timer->hw.stop))
1023         return -ENXIO;
1024     if (!(timer->hw.flags & SNDRV_TIMER_HW_SLAVE) &&
1025         !timer->hw.resolution && timer->hw.c_resolution == NULL)
1026             return -EINVAL;
1027
1028     mutex_lock(&register_mutex);
1029     list_for_each_entry(timer1, &snd_timer_list, device_list) {
1030         if (timer1->tmr_class > timer->tmr_class)
1031             break;
1032         if (timer1->tmr_class < timer->tmr_class)
1033             continue;
1034         if (timer1->card && timer->card) {
1035             if (timer1->card->number > timer->card->number)
1036                 break;
1037             if (timer1->card->number < timer->card->number)
1038                 continue;
1039         }
1040         if (timer1->tmr_device > timer->tmr_device)
1041             break;
1042         if (timer1->tmr_device < timer->tmr_device)
1043             continue;
1044         if (timer1->tmr_subdevice > timer->tmr_subdevice)
1045             break;
1046         if (timer1->tmr_subdevice < timer->tmr_subdevice)
1047             continue;
1048         /* conflicts.. */
1049         mutex_unlock(&register_mutex);
1050         return -EBUSY;
1051     }
1052     list_add_tail(&timer->device_list, &timer1->device_list);
1053     mutex_unlock(&register_mutex);
1054     return 0;
1055 }
1056
1057 static int snd_timer_dev_disconnect(struct snd_device *device)
1058 {
1059     struct snd_timer *timer = device->device_data;
1060     struct snd_timer_instance *ti;
1061
1062     mutex_lock(&register_mutex);
1063     list_del_init(&timer->device_list);
1064     /* wake up pending sleepers */
1065     list_for_each_entry(ti, &timer->open_list_head, open_list) {
1066         if (ti->disconnect)
1067             ti->disconnect(ti);
1068     }
1069     mutex_unlock(&register_mutex);
1070     return 0;
1071 }
1072
1073 void snd_timer_notify(struct snd_timer *timer, int event, struct timespec64 *tstamp)
1074 {
1075     unsigned long flags;
1076     unsigned long resolution = 0;
1077     struct snd_timer_instance *ti, *ts;
1078
1079     if (timer->card && timer->card->shutdown)
1080         return;
1081     if (! (timer->hw.flags & SNDRV_TIMER_HW_SLAVE))
1082         return;
1083     if (snd_BUG_ON(event < SNDRV_TIMER_EVENT_MSTART ||
1084                event > SNDRV_TIMER_EVENT_MRESUME))
1085         return;
1086     spin_lock_irqsave(&timer->lock, flags);
1087     if (event == SNDRV_TIMER_EVENT_MSTART ||
1088         event == SNDRV_TIMER_EVENT_MCONTINUE ||
1089         event == SNDRV_TIMER_EVENT_MRESUME)
1090         resolution = snd_timer_hw_resolution(timer);
1091     list_for_each_entry(ti, &timer->active_list_head, active_list) {
1092         if (ti->ccallback)
1093             ti->ccallback(ti, event, tstamp, resolution);
1094         list_for_each_entry(ts, &ti->slave_active_head, active_list)
1095             if (ts->ccallback)
1096                 ts->ccallback(ts, event, tstamp, resolution);
1097     }
1098     spin_unlock_irqrestore(&timer->lock, flags);
1099 }
1100 EXPORT_SYMBOL(snd_timer_notify);
1101
1102 /*
1103  * exported functions for global timers
1104  */
1105 int snd_timer_global_new(char *id, int device, struct snd_timer **rtimer)
1106 {
1107     struct snd_timer_id tid;
1108
1109     tid.dev_class = SNDRV_TIMER_CLASS_GLOBAL;
1110     tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
1111     tid.card = -1;
1112     tid.device = device;
1113     tid.subdevice = 0;
1114     return snd_timer_new(NULL, id, &tid, rtimer);
1115 }
1116 EXPORT_SYMBOL(snd_timer_global_new);
1117
1118 int snd_timer_global_free(struct snd_timer *timer)
1119 {
1120     return snd_timer_free(timer);
1121 }
1122 EXPORT_SYMBOL(snd_timer_global_free);
1123
1124 int snd_timer_global_register(struct snd_timer *timer)
1125 {
1126     struct snd_device dev;
1127
1128     memset(&dev, 0, sizeof(dev));
1129     dev.device_data = timer;
1130     return snd_timer_dev_register(&dev);
1131 }
1132 EXPORT_SYMBOL(snd_timer_global_register);
1133
1134 /*
1135  *  System timer
1136  */
1137
1138 struct snd_timer_system_private {
1139     struct timer_list tlist;
1140     struct snd_timer *snd_timer;
1141     unsigned long last_expires;
1142     unsigned long last_jiffies;
1143     unsigned long correction;
1144 };
1145
1146 static void snd_timer_s_function(struct timer_list *t)
1147 {
1148     struct snd_timer_system_private *priv = from_timer(priv, t,
1149                                 tlist);
1150     struct snd_timer *timer = priv->snd_timer;
1151     unsigned long jiff = jiffies;
1152     if (time_after(jiff, priv->last_expires))
1153         priv->correction += (long)jiff - (long)priv->last_expires;
1154     snd_timer_interrupt(timer, (long)jiff - (long)priv->last_jiffies);
1155 }
1156
1157 static int snd_timer_s_start(struct snd_timer * timer)
1158 {
1159     struct snd_timer_system_private *priv;
1160     unsigned long njiff;
1161
1162     priv = (struct snd_timer_system_private *) timer->private_data;
1163     njiff = (priv->last_jiffies = jiffies);
1164     if (priv->correction > timer->sticks - 1) {
1165         priv->correction -= timer->sticks - 1;
1166         njiff++;
1167     } else {
1168         njiff += timer->sticks - priv->correction;
1169         priv->correction = 0;
1170     }
1171     priv->last_expires = njiff;
1172     mod_timer(&priv->tlist, njiff);
1173     return 0;
1174 }
1175
1176 static int snd_timer_s_stop(struct snd_timer * timer)
1177 {
1178     struct snd_timer_system_private *priv;
1179     unsigned long jiff;
1180
1181     priv = (struct snd_timer_system_private *) timer->private_data;
1182     del_timer(&priv->tlist);
1183     jiff = jiffies;
1184     if (time_before(jiff, priv->last_expires))
1185         timer->sticks = priv->last_expires - jiff;
1186     else
1187         timer->sticks = 1;
1188     priv->correction = 0;
1189     return 0;
1190 }
1191
1192 static int snd_timer_s_close(struct snd_timer *timer)
1193 {
1194     struct snd_timer_system_private *priv;
1195
1196     priv = (struct snd_timer_system_private *)timer->private_data;
1197     del_timer_sync(&priv->tlist);
1198     return 0;
1199 }
1200
1201 static const struct snd_timer_hardware snd_timer_system =
1202 {
1203     .flags =    SNDRV_TIMER_HW_FIRST | SNDRV_TIMER_HW_WORK,
1204     .resolution =   1000000000L / HZ,
1205     .ticks =    10000000L,
1206     .close =    snd_timer_s_close,
1207     .start =    snd_timer_s_start,
1208     .stop =     snd_timer_s_stop
1209 };
1210
1211 static void snd_timer_free_system(struct snd_timer *timer)
1212 {
1213     kfree(timer->private_data);
1214 }
1215
1216 static int snd_timer_register_system(void)
1217 {
1218     struct snd_timer *timer;
1219     struct snd_timer_system_private *priv;
1220     int err;
1221
1222     err = snd_timer_global_new("system", SNDRV_TIMER_GLOBAL_SYSTEM, &timer);
1223     if (err < 0)
1224         return err;
1225     strcpy(timer->name, "system timer");
1226     timer->hw = snd_timer_system;
1227     priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1228     if (priv == NULL) {
1229         snd_timer_free(timer);
1230         return -ENOMEM;
1231     }
1232     priv->snd_timer = timer;
1233     timer_setup(&priv->tlist, snd_timer_s_function, 0);
1234     timer->private_data = priv;
1235     timer->private_free = snd_timer_free_system;
1236     return snd_timer_global_register(timer);
1237 }
1238
1239 #ifdef CONFIG_SND_PROC_FS
1240 /*
1241  *  Info interface
1242  */
1243
1244 static void snd_timer_proc_read(struct snd_info_entry *entry,
1245                 struct snd_info_buffer *buffer)
1246 {
1247     struct snd_timer *timer;
1248     struct snd_timer_instance *ti;
1249
1250     mutex_lock(&register_mutex);
1251     list_for_each_entry(timer, &snd_timer_list, device_list) {
1252         if (timer->card && timer->card->shutdown)
1253             continue;
1254         switch (timer->tmr_class) {
1255         case SNDRV_TIMER_CLASS_GLOBAL:
1256             snd_iprintf(buffer, "G%i: ", timer->tmr_device);
1257             break;
1258         case SNDRV_TIMER_CLASS_CARD:
1259             snd_iprintf(buffer, "C%i-%i: ",
1260                     timer->card->number, timer->tmr_device);
1261             break;
1262         case SNDRV_TIMER_CLASS_PCM:
1263             snd_iprintf(buffer, "P%i-%i-%i: ", timer->card->number,
1264                     timer->tmr_device, timer->tmr_subdevice);
1265             break;
1266         default:
1267             snd_iprintf(buffer, "?%i-%i-%i-%i: ", timer->tmr_class,
1268                     timer->card ? timer->card->number : -1,
1269                     timer->tmr_device, timer->tmr_subdevice);
1270         }
1271         snd_iprintf(buffer, "%s :", timer->name);
1272         if (timer->hw.resolution)
1273             snd_iprintf(buffer, " %lu.%03luus (%lu ticks)",
1274                     timer->hw.resolution / 1000,
1275                     timer->hw.resolution % 1000,
1276                     timer->hw.ticks);
1277         if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
1278             snd_iprintf(buffer, " SLAVE");
1279         snd_iprintf(buffer, "\n");
1280         list_for_each_entry(ti, &timer->open_list_head, open_list)
1281             snd_iprintf(buffer, "  Client %s : %s\n",
1282                     ti->owner ? ti->owner : "unknown",
1283                     (ti->flags & (SNDRV_TIMER_IFLG_START |
1284                           SNDRV_TIMER_IFLG_RUNNING))
1285                     ? "running" : "stopped");
1286     }
1287     mutex_unlock(&register_mutex);
1288 }
1289
1290 static struct snd_info_entry *snd_timer_proc_entry;
1291
1292 static void __init snd_timer_proc_init(void)
1293 {
1294     struct snd_info_entry *entry;
1295
1296     entry = snd_info_create_module_entry(THIS_MODULE, "timers", NULL);
1297     if (entry != NULL) {
1298         entry->c.text.read = snd_timer_proc_read;
1299         if (snd_info_register(entry) < 0) {
1300             snd_info_free_entry(entry);
1301             entry = NULL;
1302         }
1303     }
1304     snd_timer_proc_entry = entry;
1305 }
1306
1307 static void __exit snd_timer_proc_done(void)
1308 {
1309     snd_info_free_entry(snd_timer_proc_entry);
1310 }
1311 #else /* !CONFIG_SND_PROC_FS */
1312 #define snd_timer_proc_init()
1313 #define snd_timer_proc_done()
1314 #endif
1315
1316 /*
1317  *  USER SPACE interface
1318  */
1319
1320 static void snd_timer_user_interrupt(struct snd_timer_instance *timeri,
1321                      unsigned long resolution,
1322                      unsigned long ticks)
1323 {
1324     struct snd_timer_user *tu = timeri->callback_data;
1325     struct snd_timer_read *r;
1326     int prev;
1327
1328     spin_lock(&tu->qlock);
1329     if (tu->qused > 0) {
1330         prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1;
1331         r = &tu->queue[prev];
1332         if (r->resolution == resolution) {
1333             r->ticks += ticks;
1334             goto __wake;
1335         }
1336     }
1337     if (tu->qused >= tu->queue_size) {
1338         tu->overrun++;
1339     } else {
1340         r = &tu->queue[tu->qtail++];
1341         tu->qtail %= tu->queue_size;
1342         r->resolution = resolution;
1343         r->ticks = ticks;
1344         tu->qused++;
1345     }
1346       __wake:
1347     spin_unlock(&tu->qlock);
1348     snd_kill_fasync(tu->fasync, SIGIO, POLL_IN);
1349     wake_up(&tu->qchange_sleep);
1350 }
1351
1352 static void snd_timer_user_append_to_tqueue(struct snd_timer_user *tu,
1353                         struct snd_timer_tread64 *tread)
1354 {
1355     if (tu->qused >= tu->queue_size) {
1356         tu->overrun++;
1357     } else {
1358         memcpy(&tu->tqueue[tu->qtail++], tread, sizeof(*tread));
1359         tu->qtail %= tu->queue_size;
1360         tu->qused++;
1361     }
1362 }
1363
1364 static void snd_timer_user_ccallback(struct snd_timer_instance *timeri,
1365                      int event,
1366                      struct timespec64 *tstamp,
1367                      unsigned long resolution)
1368 {
1369     struct snd_timer_user *tu = timeri->callback_data;
1370     struct snd_timer_tread64 r1;
1371     unsigned long flags;
1372
1373     if (event >= SNDRV_TIMER_EVENT_START &&
1374         event <= SNDRV_TIMER_EVENT_PAUSE)
1375         tu->tstamp = *tstamp;
1376     if ((tu->filter & (1 << event)) == 0 || !tu->tread)
1377         return;
1378     memset(&r1, 0, sizeof(r1));
1379     r1.event = event;
1380     r1.tstamp_sec = tstamp->tv_sec;
1381     r1.tstamp_nsec = tstamp->tv_nsec;
1382     r1.val = resolution;
1383     spin_lock_irqsave(&tu->qlock, flags);
1384     snd_timer_user_append_to_tqueue(tu, &r1);
1385     spin_unlock_irqrestore(&tu->qlock, flags);
1386     snd_kill_fasync(tu->fasync, SIGIO, POLL_IN);
1387     wake_up(&tu->qchange_sleep);
1388 }
1389
1390 static void snd_timer_user_disconnect(struct snd_timer_instance *timeri)
1391 {
1392     struct snd_timer_user *tu = timeri->callback_data;
1393
1394     tu->disconnected = true;
1395     wake_up(&tu->qchange_sleep);
1396 }
1397
1398 static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri,
1399                       unsigned long resolution,
1400                       unsigned long ticks)
1401 {
1402     struct snd_timer_user *tu = timeri->callback_data;
1403     struct snd_timer_tread64 *r, r1;
1404     struct timespec64 tstamp;
1405     int prev, append = 0;
1406
1407     memset(&r1, 0, sizeof(r1));
1408     memset(&tstamp, 0, sizeof(tstamp));
1409     spin_lock(&tu->qlock);
1410     if ((tu->filter & ((1 << SNDRV_TIMER_EVENT_RESOLUTION) |
1411                (1 << SNDRV_TIMER_EVENT_TICK))) == 0) {
1412         spin_unlock(&tu->qlock);
1413         return;
1414     }
1415     if (tu->last_resolution != resolution || ticks > 0) {
1416         if (timer_tstamp_monotonic)
1417             ktime_get_ts64(&tstamp);
1418         else
1419             ktime_get_real_ts64(&tstamp);
1420     }
1421     if ((tu->filter & (1 << SNDRV_TIMER_EVENT_RESOLUTION)) &&
1422         tu->last_resolution != resolution) {
1423         r1.event = SNDRV_TIMER_EVENT_RESOLUTION;
1424         r1.tstamp_sec = tstamp.tv_sec;
1425         r1.tstamp_nsec = tstamp.tv_nsec;
1426         r1.val = resolution;
1427         snd_timer_user_append_to_tqueue(tu, &r1);
1428         tu->last_resolution = resolution;
1429         append++;
1430     }
1431     if ((tu->filter & (1 << SNDRV_TIMER_EVENT_TICK)) == 0)
1432         goto __wake;
1433     if (ticks == 0)
1434         goto __wake;
1435     if (tu->qused > 0) {
1436         prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1;
1437         r = &tu->tqueue[prev];
1438         if (r->event == SNDRV_TIMER_EVENT_TICK) {
1439             r->tstamp_sec = tstamp.tv_sec;
1440             r->tstamp_nsec = tstamp.tv_nsec;
1441             r->val += ticks;
1442             append++;
1443             goto __wake;
1444         }
1445     }
1446     r1.event = SNDRV_TIMER_EVENT_TICK;
1447     r1.tstamp_sec = tstamp.tv_sec;
1448     r1.tstamp_nsec = tstamp.tv_nsec;
1449     r1.val = ticks;
1450     snd_timer_user_append_to_tqueue(tu, &r1);
1451     append++;
1452       __wake:
1453     spin_unlock(&tu->qlock);
1454     if (append == 0)
1455         return;
1456     snd_kill_fasync(tu->fasync, SIGIO, POLL_IN);
1457     wake_up(&tu->qchange_sleep);
1458 }
1459
1460 static int realloc_user_queue(struct snd_timer_user *tu, int size)
1461 {
1462     struct snd_timer_read *queue = NULL;
1463     struct snd_timer_tread64 *tqueue = NULL;
1464
1465     if (tu->tread) {
1466         tqueue = kcalloc(size, sizeof(*tqueue), GFP_KERNEL);
1467         if (!tqueue)
1468             return -ENOMEM;
1469     } else {
1470         queue = kcalloc(size, sizeof(*queue), GFP_KERNEL);
1471         if (!queue)
1472             return -ENOMEM;
1473     }
1474
1475     spin_lock_irq(&tu->qlock);
1476     kfree(tu->queue);
1477     kfree(tu->tqueue);
1478     tu->queue_size = size;
1479     tu->queue = queue;
1480     tu->tqueue = tqueue;
1481     tu->qhead = tu->qtail = tu->qused = 0;
1482     spin_unlock_irq(&tu->qlock);
1483
1484     return 0;
1485 }
1486
1487 static int snd_timer_user_open(struct inode *inode, struct file *file)
1488 {
1489     struct snd_timer_user *tu;
1490     int err;
1491
1492     err = stream_open(inode, file);
1493     if (err < 0)
1494         return err;
1495
1496     tu = kzalloc(sizeof(*tu), GFP_KERNEL);
1497     if (tu == NULL)
1498         return -ENOMEM;
1499     spin_lock_init(&tu->qlock);
1500     init_waitqueue_head(&tu->qchange_sleep);
1501     mutex_init(&tu->ioctl_lock);
1502     tu->ticks = 1;
1503     if (realloc_user_queue(tu, 128) < 0) {
1504         kfree(tu);
1505         return -ENOMEM;
1506     }
1507     file->private_data = tu;
1508     return 0;
1509 }
1510
1511 static int snd_timer_user_release(struct inode *inode, struct file *file)
1512 {
1513     struct snd_timer_user *tu;
1514
1515     if (file->private_data) {
1516         tu = file->private_data;
1517         file->private_data = NULL;
1518         mutex_lock(&tu->ioctl_lock);
1519         if (tu->timeri) {
1520             snd_timer_close(tu->timeri);
1521             snd_timer_instance_free(tu->timeri);
1522         }
1523         mutex_unlock(&tu->ioctl_lock);
1524         snd_fasync_free(tu->fasync);
1525         kfree(tu->queue);
1526         kfree(tu->tqueue);
1527         kfree(tu);
1528     }
1529     return 0;
1530 }
1531
1532 static void snd_timer_user_zero_id(struct snd_timer_id *id)
1533 {
1534     id->dev_class = SNDRV_TIMER_CLASS_NONE;
1535     id->dev_sclass = SNDRV_TIMER_SCLASS_NONE;
1536     id->card = -1;
1537     id->device = -1;
1538     id->subdevice = -1;
1539 }
1540
1541 static void snd_timer_user_copy_id(struct snd_timer_id *id, struct snd_timer *timer)
1542 {
1543     id->dev_class = timer->tmr_class;
1544     id->dev_sclass = SNDRV_TIMER_SCLASS_NONE;
1545     id->card = timer->card ? timer->card->number : -1;
1546     id->device = timer->tmr_device;
1547     id->subdevice = timer->tmr_subdevice;
1548 }
1549
1550 static int snd_timer_user_next_device(struct snd_timer_id __user *_tid)
1551 {
1552     struct snd_timer_id id;
1553     struct snd_timer *timer;
1554     struct list_head *p;
1555
1556     if (copy_from_user(&id, _tid, sizeof(id)))
1557         return -EFAULT;
1558     mutex_lock(&register_mutex);
1559     if (id.dev_class < 0) {     /* first item */
1560         if (list_empty(&snd_timer_list))
1561             snd_timer_user_zero_id(&id);
1562         else {
1563             timer = list_entry(snd_timer_list.next,
1564                        struct snd_timer, device_list);
1565             snd_timer_user_copy_id(&id, timer);
1566         }
1567     } else {
1568         switch (id.dev_class) {
1569         case SNDRV_TIMER_CLASS_GLOBAL:
1570             id.device = id.device < 0 ? 0 : id.device + 1;
1571             list_for_each(p, &snd_timer_list) {
1572                 timer = list_entry(p, struct snd_timer, device_list);
1573                 if (timer->tmr_class > SNDRV_TIMER_CLASS_GLOBAL) {
1574                     snd_timer_user_copy_id(&id, timer);
1575                     break;
1576                 }
1577                 if (timer->tmr_device >= id.device) {
1578                     snd_timer_user_copy_id(&id, timer);
1579                     break;
1580                 }
1581             }
1582             if (p == &snd_timer_list)
1583                 snd_timer_user_zero_id(&id);
1584             break;
1585         case SNDRV_TIMER_CLASS_CARD:
1586         case SNDRV_TIMER_CLASS_PCM:
1587             if (id.card < 0) {
1588                 id.card = 0;
1589             } else {
1590                 if (id.device < 0) {
1591                     id.device = 0;
1592                 } else {
1593                     if (id.subdevice < 0)
1594                         id.subdevice = 0;
1595                     else if (id.subdevice < INT_MAX)
1596                         id.subdevice++;
1597                 }
1598             }
1599             list_for_each(p, &snd_timer_list) {
1600                 timer = list_entry(p, struct snd_timer, device_list);
1601                 if (timer->tmr_class > id.dev_class) {
1602                     snd_timer_user_copy_id(&id, timer);
1603                     break;
1604                 }
1605                 if (timer->tmr_class < id.dev_class)
1606                     continue;
1607                 if (timer->card->number > id.card) {
1608                     snd_timer_user_copy_id(&id, timer);
1609                     break;
1610                 }
1611                 if (timer->card->number < id.card)
1612                     continue;
1613                 if (timer->tmr_device > id.device) {
1614                     snd_timer_user_copy_id(&id, timer);
1615                     break;
1616                 }
1617                 if (timer->tmr_device < id.device)
1618                     continue;
1619                 if (timer->tmr_subdevice > id.subdevice) {
1620                     snd_timer_user_copy_id(&id, timer);
1621                     break;
1622                 }
1623                 if (timer->tmr_subdevice < id.subdevice)
1624                     continue;
1625                 snd_timer_user_copy_id(&id, timer);
1626                 break;
1627             }
1628             if (p == &snd_timer_list)
1629                 snd_timer_user_zero_id(&id);
1630             break;
1631         default:
1632             snd_timer_user_zero_id(&id);
1633         }
1634     }
1635     mutex_unlock(&register_mutex);
1636     if (copy_to_user(_tid, &id, sizeof(*_tid)))
1637         return -EFAULT;
1638     return 0;
1639 }
1640
1641 static int snd_timer_user_ginfo(struct file *file,
1642                 struct snd_timer_ginfo __user *_ginfo)
1643 {
1644     struct snd_timer_ginfo *ginfo;
1645     struct snd_timer_id tid;
1646     struct snd_timer *t;
1647     struct list_head *p;
1648     int err = 0;
1649
1650     ginfo = memdup_user(_ginfo, sizeof(*ginfo));
1651     if (IS_ERR(ginfo))
1652         return PTR_ERR(ginfo);
1653
1654     tid = ginfo->tid;
1655     memset(ginfo, 0, sizeof(*ginfo));
1656     ginfo->tid = tid;
1657     mutex_lock(&register_mutex);
1658     t = snd_timer_find(&tid);
1659     if (t != NULL) {
1660         ginfo->card = t->card ? t->card->number : -1;
1661         if (t->hw.flags & SNDRV_TIMER_HW_SLAVE)
1662             ginfo->flags |= SNDRV_TIMER_FLG_SLAVE;
1663         strscpy(ginfo->id, t->id, sizeof(ginfo->id));
1664         strscpy(ginfo->name, t->name, sizeof(ginfo->name));
1665         ginfo->resolution = t->hw.resolution;
1666         if (t->hw.resolution_min > 0) {
1667             ginfo->resolution_min = t->hw.resolution_min;
1668             ginfo->resolution_max = t->hw.resolution_max;
1669         }
1670         list_for_each(p, &t->open_list_head) {
1671             ginfo->clients++;
1672         }
1673     } else {
1674         err = -ENODEV;
1675     }
1676     mutex_unlock(&register_mutex);
1677     if (err >= 0 && copy_to_user(_ginfo, ginfo, sizeof(*ginfo)))
1678         err = -EFAULT;
1679     kfree(ginfo);
1680     return err;
1681 }
1682
1683 static int timer_set_gparams(struct snd_timer_gparams *gparams)
1684 {
1685     struct snd_timer *t;
1686     int err;
1687
1688     mutex_lock(&register_mutex);
1689     t = snd_timer_find(&gparams->tid);
1690     if (!t) {
1691         err = -ENODEV;
1692         goto _error;
1693     }
1694     if (!list_empty(&t->open_list_head)) {
1695         err = -EBUSY;
1696         goto _error;
1697     }
1698     if (!t->hw.set_period) {
1699         err = -ENOSYS;
1700         goto _error;
1701     }
1702     err = t->hw.set_period(t, gparams->period_num, gparams->period_den);
1703 _error:
1704     mutex_unlock(&register_mutex);
1705     return err;
1706 }
1707
1708 static int snd_timer_user_gparams(struct file *file,
1709                   struct snd_timer_gparams __user *_gparams)
1710 {
1711     struct snd_timer_gparams gparams;
1712
1713     if (copy_from_user(&gparams, _gparams, sizeof(gparams)))
1714         return -EFAULT;
1715     return timer_set_gparams(&gparams);
1716 }
1717
1718 static int snd_timer_user_gstatus(struct file *file,
1719                   struct snd_timer_gstatus __user *_gstatus)
1720 {
1721     struct snd_timer_gstatus gstatus;
1722     struct snd_timer_id tid;
1723     struct snd_timer *t;
1724     int err = 0;
1725
1726     if (copy_from_user(&gstatus, _gstatus, sizeof(gstatus)))
1727         return -EFAULT;
1728     tid = gstatus.tid;
1729     memset(&gstatus, 0, sizeof(gstatus));
1730     gstatus.tid = tid;
1731     mutex_lock(&register_mutex);
1732     t = snd_timer_find(&tid);
1733     if (t != NULL) {
1734         spin_lock_irq(&t->lock);
1735         gstatus.resolution = snd_timer_hw_resolution(t);
1736         if (t->hw.precise_resolution) {
1737             t->hw.precise_resolution(t, &gstatus.resolution_num,
1738                          &gstatus.resolution_den);
1739         } else {
1740             gstatus.resolution_num = gstatus.resolution;
1741             gstatus.resolution_den = 1000000000uL;
1742         }
1743         spin_unlock_irq(&t->lock);
1744     } else {
1745         err = -ENODEV;
1746     }
1747     mutex_unlock(&register_mutex);
1748     if (err >= 0 && copy_to_user(_gstatus, &gstatus, sizeof(gstatus)))
1749         err = -EFAULT;
1750     return err;
1751 }
1752
1753 static int snd_timer_user_tselect(struct file *file,
1754                   struct snd_timer_select __user *_tselect)
1755 {
1756     struct snd_timer_user *tu;
1757     struct snd_timer_select tselect;
1758     char str[32];
1759     int err = 0;
1760
1761     tu = file->private_data;
1762     if (tu->timeri) {
1763         snd_timer_close(tu->timeri);
1764         snd_timer_instance_free(tu->timeri);
1765         tu->timeri = NULL;
1766     }
1767     if (copy_from_user(&tselect, _tselect, sizeof(tselect))) {
1768         err = -EFAULT;
1769         goto __err;
1770     }
1771     sprintf(str, "application %i", current->pid);
1772     if (tselect.id.dev_class != SNDRV_TIMER_CLASS_SLAVE)
1773         tselect.id.dev_sclass = SNDRV_TIMER_SCLASS_APPLICATION;
1774     tu->timeri = snd_timer_instance_new(str);
1775     if (!tu->timeri) {
1776         err = -ENOMEM;
1777         goto __err;
1778     }
1779
1780     tu->timeri->flags |= SNDRV_TIMER_IFLG_FAST;
1781     tu->timeri->callback = tu->tread
1782             ? snd_timer_user_tinterrupt : snd_timer_user_interrupt;
1783     tu->timeri->ccallback = snd_timer_user_ccallback;
1784     tu->timeri->callback_data = (void *)tu;
1785     tu->timeri->disconnect = snd_timer_user_disconnect;
1786
1787     err = snd_timer_open(tu->timeri, &tselect.id, current->pid);
1788     if (err < 0) {
1789         snd_timer_instance_free(tu->timeri);
1790         tu->timeri = NULL;
1791     }
1792
1793       __err:
1794     return err;
1795 }
1796
1797 static int snd_timer_user_info(struct file *file,
1798                    struct snd_timer_info __user *_info)
1799 {
1800     struct snd_timer_user *tu;
1801     struct snd_timer_info *info;
1802     struct snd_timer *t;
1803     int err = 0;
1804
1805     tu = file->private_data;
1806     if (!tu->timeri)
1807         return -EBADFD;
1808     t = tu->timeri->timer;
1809     if (!t)
1810         return -EBADFD;
1811
1812     info = kzalloc(sizeof(*info), GFP_KERNEL);
1813     if (! info)
1814         return -ENOMEM;
1815     info->card = t->card ? t->card->number : -1;
1816     if (t->hw.flags & SNDRV_TIMER_HW_SLAVE)
1817         info->flags |= SNDRV_TIMER_FLG_SLAVE;
1818     strscpy(info->id, t->id, sizeof(info->id));
1819     strscpy(info->name, t->name, sizeof(info->name));
1820     info->resolution = t->hw.resolution;
1821     if (copy_to_user(_info, info, sizeof(*_info)))
1822         err = -EFAULT;
1823     kfree(info);
1824     return err;
1825 }
1826
1827 static int snd_timer_user_params(struct file *file,
1828                  struct snd_timer_params __user *_params)
1829 {
1830     struct snd_timer_user *tu;
1831     struct snd_timer_params params;
1832     struct snd_timer *t;
1833     int err;
1834
1835     tu = file->private_data;
1836     if (!tu->timeri)
1837         return -EBADFD;
1838     t = tu->timeri->timer;
1839     if (!t)
1840         return -EBADFD;
1841     if (copy_from_user(&params, _params, sizeof(params)))
1842         return -EFAULT;
1843     if (!(t->hw.flags & SNDRV_TIMER_HW_SLAVE)) {
1844         u64 resolution;
1845
1846         if (params.ticks < 1) {
1847             err = -EINVAL;
1848             goto _end;
1849         }
1850
1851         /* Don't allow resolution less than 1ms */
1852         resolution = snd_timer_resolution(tu->timeri);
1853         resolution *= params.ticks;
1854         if (resolution < 1000000) {
1855             err = -EINVAL;
1856             goto _end;
1857         }
1858     }
1859     if (params.queue_size > 0 &&
1860         (params.queue_size < 32 || params.queue_size > 1024)) {
1861         err = -EINVAL;
1862         goto _end;
1863     }
1864     if (params.filter & ~((1<<SNDRV_TIMER_EVENT_RESOLUTION)|
1865                   (1<<SNDRV_TIMER_EVENT_TICK)|
1866                   (1<<SNDRV_TIMER_EVENT_START)|
1867                   (1<<SNDRV_TIMER_EVENT_STOP)|
1868                   (1<<SNDRV_TIMER_EVENT_CONTINUE)|
1869                   (1<<SNDRV_TIMER_EVENT_PAUSE)|
1870                   (1<<SNDRV_TIMER_EVENT_SUSPEND)|
1871                   (1<<SNDRV_TIMER_EVENT_RESUME)|
1872                   (1<<SNDRV_TIMER_EVENT_MSTART)|
1873                   (1<<SNDRV_TIMER_EVENT_MSTOP)|
1874                   (1<<SNDRV_TIMER_EVENT_MCONTINUE)|
1875                   (1<<SNDRV_TIMER_EVENT_MPAUSE)|
1876                   (1<<SNDRV_TIMER_EVENT_MSUSPEND)|
1877                   (1<<SNDRV_TIMER_EVENT_MRESUME))) {
1878         err = -EINVAL;
1879         goto _end;
1880     }
1881     snd_timer_stop(tu->timeri);
1882     spin_lock_irq(&t->lock);
1883     tu->timeri->flags &= ~(SNDRV_TIMER_IFLG_AUTO|
1884                    SNDRV_TIMER_IFLG_EXCLUSIVE|
1885                    SNDRV_TIMER_IFLG_EARLY_EVENT);
1886     if (params.flags & SNDRV_TIMER_PSFLG_AUTO)
1887         tu->timeri->flags |= SNDRV_TIMER_IFLG_AUTO;
1888     if (params.flags & SNDRV_TIMER_PSFLG_EXCLUSIVE)
1889         tu->timeri->flags |= SNDRV_TIMER_IFLG_EXCLUSIVE;
1890     if (params.flags & SNDRV_TIMER_PSFLG_EARLY_EVENT)
1891         tu->timeri->flags |= SNDRV_TIMER_IFLG_EARLY_EVENT;
1892     spin_unlock_irq(&t->lock);
1893     if (params.queue_size > 0 &&
1894         (unsigned int)tu->queue_size != params.queue_size) {
1895         err = realloc_user_queue(tu, params.queue_size);
1896         if (err < 0)
1897             goto _end;
1898     }
1899     spin_lock_irq(&tu->qlock);
1900     tu->qhead = tu->qtail = tu->qused = 0;
1901     if (tu->timeri->flags & SNDRV_TIMER_IFLG_EARLY_EVENT) {
1902         if (tu->tread) {
1903             struct snd_timer_tread64 tread;
1904             memset(&tread, 0, sizeof(tread));
1905             tread.event = SNDRV_TIMER_EVENT_EARLY;
1906             tread.tstamp_sec = 0;
1907             tread.tstamp_nsec = 0;
1908             tread.val = 0;
1909             snd_timer_user_append_to_tqueue(tu, &tread);
1910         } else {
1911             struct snd_timer_read *r = &tu->queue[0];
1912             r->resolution = 0;
1913             r->ticks = 0;
1914             tu->qused++;
1915             tu->qtail++;
1916         }
1917     }
1918     tu->filter = params.filter;
1919     tu->ticks = params.ticks;
1920     spin_unlock_irq(&tu->qlock);
1921     err = 0;
1922  _end:
1923     if (copy_to_user(_params, &params, sizeof(params)))
1924         return -EFAULT;
1925     return err;
1926 }
1927
1928 static int snd_timer_user_status32(struct file *file,
1929                    struct snd_timer_status32 __user *_status)
1930  {
1931     struct snd_timer_user *tu;
1932     struct snd_timer_status32 status;
1933
1934     tu = file->private_data;
1935     if (!tu->timeri)
1936         return -EBADFD;
1937     memset(&status, 0, sizeof(status));
1938     status.tstamp_sec = tu->tstamp.tv_sec;
1939     status.tstamp_nsec = tu->tstamp.tv_nsec;
1940     status.resolution = snd_timer_resolution(tu->timeri);
1941     status.lost = tu->timeri->lost;
1942     status.overrun = tu->overrun;
1943     spin_lock_irq(&tu->qlock);
1944     status.queue = tu->qused;
1945     spin_unlock_irq(&tu->qlock);
1946     if (copy_to_user(_status, &status, sizeof(status)))
1947         return -EFAULT;
1948     return 0;
1949 }
1950
1951 static int snd_timer_user_status64(struct file *file,
1952                    struct snd_timer_status64 __user *_status)
1953 {
1954     struct snd_timer_user *tu;
1955     struct snd_timer_status64 status;
1956
1957     tu = file->private_data;
1958     if (!tu->timeri)
1959         return -EBADFD;
1960     memset(&status, 0, sizeof(status));
1961     status.tstamp_sec = tu->tstamp.tv_sec;
1962     status.tstamp_nsec = tu->tstamp.tv_nsec;
1963     status.resolution = snd_timer_resolution(tu->timeri);
1964     status.lost = tu->timeri->lost;
1965     status.overrun = tu->overrun;
1966     spin_lock_irq(&tu->qlock);
1967     status.queue = tu->qused;
1968     spin_unlock_irq(&tu->qlock);
1969     if (copy_to_user(_status, &status, sizeof(status)))
1970         return -EFAULT;
1971     return 0;
1972 }
1973
1974 static int snd_timer_user_start(struct file *file)
1975 {
1976     int err;
1977     struct snd_timer_user *tu;
1978
1979     tu = file->private_data;
1980     if (!tu->timeri)
1981         return -EBADFD;
1982     snd_timer_stop(tu->timeri);
1983     tu->timeri->lost = 0;
1984     tu->last_resolution = 0;
1985     err = snd_timer_start(tu->timeri, tu->ticks);
1986     if (err < 0)
1987         return err;
1988     return 0;
1989 }
1990
1991 static int snd_timer_user_stop(struct file *file)
1992 {
1993     int err;
1994     struct snd_timer_user *tu;
1995
1996     tu = file->private_data;
1997     if (!tu->timeri)
1998         return -EBADFD;
1999     err = snd_timer_stop(tu->timeri);
2000     if (err < 0)
2001         return err;
2002     return 0;
2003 }
2004
2005 static int snd_timer_user_continue(struct file *file)
2006 {
2007     int err;
2008     struct snd_timer_user *tu;
2009
2010     tu = file->private_data;
2011     if (!tu->timeri)
2012         return -EBADFD;
2013     /* start timer instead of continue if it's not used before */
2014     if (!(tu->timeri->flags & SNDRV_TIMER_IFLG_PAUSED))
2015         return snd_timer_user_start(file);
2016     tu->timeri->lost = 0;
2017     err = snd_timer_continue(tu->timeri);
2018     if (err < 0)
2019         return err;
2020     return 0;
2021 }
2022
2023 static int snd_timer_user_pause(struct file *file)
2024 {
2025     int err;
2026     struct snd_timer_user *tu;
2027
2028     tu = file->private_data;
2029     if (!tu->timeri)
2030         return -EBADFD;
2031     err = snd_timer_pause(tu->timeri);
2032     if (err < 0)
2033         return err;
2034     return 0;
2035 }
2036
2037 static int snd_timer_user_tread(void __user *argp, struct snd_timer_user *tu,
2038                 unsigned int cmd, bool compat)
2039 {
2040     int __user *p = argp;
2041     int xarg, old_tread;
2042
2043     if (tu->timeri) /* too late */
2044         return -EBUSY;
2045     if (get_user(xarg, p))
2046         return -EFAULT;
2047
2048     old_tread = tu->tread;
2049
2050     if (!xarg)
2051         tu->tread = TREAD_FORMAT_NONE;
2052     else if (cmd == SNDRV_TIMER_IOCTL_TREAD64 ||
2053          (IS_ENABLED(CONFIG_64BIT) && !compat))
2054         tu->tread = TREAD_FORMAT_TIME64;
2055     else
2056         tu->tread = TREAD_FORMAT_TIME32;
2057
2058     if (tu->tread != old_tread &&
2059         realloc_user_queue(tu, tu->queue_size) < 0) {
2060         tu->tread = old_tread;
2061         return -ENOMEM;
2062     }
2063
2064     return 0;
2065 }
2066
2067 enum {
2068     SNDRV_TIMER_IOCTL_START_OLD = _IO('T', 0x20),
2069     SNDRV_TIMER_IOCTL_STOP_OLD = _IO('T', 0x21),
2070     SNDRV_TIMER_IOCTL_CONTINUE_OLD = _IO('T', 0x22),
2071     SNDRV_TIMER_IOCTL_PAUSE_OLD = _IO('T', 0x23),
2072 };
2073
2074 static long __snd_timer_user_ioctl(struct file *file, unsigned int cmd,
2075                  unsigned long arg, bool compat)
2076 {
2077     struct snd_timer_user *tu;
2078     void __user *argp = (void __user *)arg;
2079     int __user *p = argp;
2080
2081     tu = file->private_data;
2082     switch (cmd) {
2083     case SNDRV_TIMER_IOCTL_PVERSION:
2084         return put_user(SNDRV_TIMER_VERSION, p) ? -EFAULT : 0;
2085     case SNDRV_TIMER_IOCTL_NEXT_DEVICE:
2086         return snd_timer_user_next_device(argp);
2087     case SNDRV_TIMER_IOCTL_TREAD_OLD:
2088     case SNDRV_TIMER_IOCTL_TREAD64:
2089         return snd_timer_user_tread(argp, tu, cmd, compat);
2090     case SNDRV_TIMER_IOCTL_GINFO:
2091         return snd_timer_user_ginfo(file, argp);
2092     case SNDRV_TIMER_IOCTL_GPARAMS:
2093         return snd_timer_user_gparams(file, argp);
2094     case SNDRV_TIMER_IOCTL_GSTATUS:
2095         return snd_timer_user_gstatus(file, argp);
2096     case SNDRV_TIMER_IOCTL_SELECT:
2097         return snd_timer_user_tselect(file, argp);
2098     case SNDRV_TIMER_IOCTL_INFO:
2099         return snd_timer_user_info(file, argp);
2100     case SNDRV_TIMER_IOCTL_PARAMS:
2101         return snd_timer_user_params(file, argp);
2102     case SNDRV_TIMER_IOCTL_STATUS32:
2103         return snd_timer_user_status32(file, argp);
2104     case SNDRV_TIMER_IOCTL_STATUS64:
2105         return snd_timer_user_status64(file, argp);
2106     case SNDRV_TIMER_IOCTL_START:
2107     case SNDRV_TIMER_IOCTL_START_OLD:
2108         return snd_timer_user_start(file);
2109     case SNDRV_TIMER_IOCTL_STOP:
2110     case SNDRV_TIMER_IOCTL_STOP_OLD:
2111         return snd_timer_user_stop(file);
2112     case SNDRV_TIMER_IOCTL_CONTINUE:
2113     case SNDRV_TIMER_IOCTL_CONTINUE_OLD:
2114         return snd_timer_user_continue(file);
2115     case SNDRV_TIMER_IOCTL_PAUSE:
2116     case SNDRV_TIMER_IOCTL_PAUSE_OLD:
2117         return snd_timer_user_pause(file);
2118     }
2119     return -ENOTTY;
2120 }
2121
2122 static long snd_timer_user_ioctl(struct file *file, unsigned int cmd,
2123                  unsigned long arg)
2124 {
2125     struct snd_timer_user *tu = file->private_data;
2126     long ret;
2127
2128     mutex_lock(&tu->ioctl_lock);
2129     ret = __snd_timer_user_ioctl(file, cmd, arg, false);
2130     mutex_unlock(&tu->ioctl_lock);
2131     return ret;
2132 }
2133
2134 static int snd_timer_user_fasync(int fd, struct file * file, int on)
2135 {
2136     struct snd_timer_user *tu;
2137
2138     tu = file->private_data;
2139     return snd_fasync_helper(fd, file, on, &tu->fasync);
2140 }
2141
2142 static ssize_t snd_timer_user_read(struct file *file, char __user *buffer,
2143                    size_t count, loff_t *offset)
2144 {
2145     struct snd_timer_tread64 *tread;
2146     struct snd_timer_tread32 tread32;
2147     struct snd_timer_user *tu;
2148     long result = 0, unit;
2149     int qhead;
2150     int err = 0;
2151
2152     tu = file->private_data;
2153     switch (tu->tread) {
2154     case TREAD_FORMAT_TIME64:
2155         unit = sizeof(struct snd_timer_tread64);
2156         break;
2157     case TREAD_FORMAT_TIME32:
2158         unit = sizeof(struct snd_timer_tread32);
2159         break;
2160     case TREAD_FORMAT_NONE:
2161         unit = sizeof(struct snd_timer_read);
2162         break;
2163     default:
2164         WARN_ONCE(1, "Corrupt snd_timer_user\n");
2165         return -ENOTSUPP;
2166     }
2167
2168     mutex_lock(&tu->ioctl_lock);
2169     spin_lock_irq(&tu->qlock);
2170     while ((long)count - result >= unit) {
2171         while (!tu->qused) {
2172             wait_queue_entry_t wait;
2173
2174             if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
2175                 err = -EAGAIN;
2176                 goto _error;
2177             }
2178
2179             set_current_state(TASK_INTERRUPTIBLE);
2180             init_waitqueue_entry(&wait, current);
2181             add_wait_queue(&tu->qchange_sleep, &wait);
2182
2183             spin_unlock_irq(&tu->qlock);
2184             mutex_unlock(&tu->ioctl_lock);
2185             schedule();
2186             mutex_lock(&tu->ioctl_lock);
2187             spin_lock_irq(&tu->qlock);
2188
2189             remove_wait_queue(&tu->qchange_sleep, &wait);
2190
2191             if (tu->disconnected) {
2192                 err = -ENODEV;
2193                 goto _error;
2194             }
2195             if (signal_pending(current)) {
2196                 err = -ERESTARTSYS;
2197                 goto _error;
2198             }
2199         }
2200
2201         qhead = tu->qhead++;
2202         tu->qhead %= tu->queue_size;
2203         tu->qused--;
2204         spin_unlock_irq(&tu->qlock);
2205
2206         tread = &tu->tqueue[qhead];
2207
2208         switch (tu->tread) {
2209         case TREAD_FORMAT_TIME64:
2210             if (copy_to_user(buffer, tread,
2211                      sizeof(struct snd_timer_tread64)))
2212                 err = -EFAULT;
2213             break;
2214         case TREAD_FORMAT_TIME32:
2215             memset(&tread32, 0, sizeof(tread32));
2216             tread32 = (struct snd_timer_tread32) {
2217                 .event = tread->event,
2218                 .tstamp_sec = tread->tstamp_sec,
2219                 .tstamp_nsec = tread->tstamp_nsec,
2220                 .val = tread->val,
2221             };
2222
2223             if (copy_to_user(buffer, &tread32, sizeof(tread32)))
2224                 err = -EFAULT;
2225             break;
2226         case TREAD_FORMAT_NONE:
2227             if (copy_to_user(buffer, &tu->queue[qhead],
2228                      sizeof(struct snd_timer_read)))
2229                 err = -EFAULT;
2230             break;
2231         default:
2232             err = -ENOTSUPP;
2233             break;
2234         }
2235
2236         spin_lock_irq(&tu->qlock);
2237         if (err < 0)
2238             goto _error;
2239         result += unit;
2240         buffer += unit;
2241     }
2242  _error:
2243     spin_unlock_irq(&tu->qlock);
2244     mutex_unlock(&tu->ioctl_lock);
2245     return result > 0 ? result : err;
2246 }
2247
2248 static __poll_t snd_timer_user_poll(struct file *file, poll_table * wait)
2249 {
2250         __poll_t mask;
2251         struct snd_timer_user *tu;
2252
2253         tu = file->private_data;
2254
2255         poll_wait(file, &tu->qchange_sleep, wait);
2256
2257     mask = 0;
2258     spin_lock_irq(&tu->qlock);
2259     if (tu->qused)
2260         mask |= EPOLLIN | EPOLLRDNORM;
2261     if (tu->disconnected)
2262         mask |= EPOLLERR;
2263     spin_unlock_irq(&tu->qlock);
2264
2265     return mask;
2266 }
2267
2268 #ifdef CONFIG_COMPAT
2269 #include "timer_compat.c"
2270 #else
2271 #define snd_timer_user_ioctl_compat NULL
2272 #endif
2273
2274 static const struct file_operations snd_timer_f_ops =
2275 {
2276     .owner =    THIS_MODULE,
2277     .read =     snd_timer_user_read,
2278     .open =     snd_timer_user_open,
2279     .release =  snd_timer_user_release,
2280     .llseek =   no_llseek,
2281     .poll =     snd_timer_user_poll,
2282     .unlocked_ioctl =   snd_timer_user_ioctl,
2283     .compat_ioctl = snd_timer_user_ioctl_compat,
2284     .fasync =   snd_timer_user_fasync,
2285 };
2286
2287 /* unregister the system timer */
2288 static void snd_timer_free_all(void)
2289 {
2290     struct snd_timer *timer, *n;
2291
2292     list_for_each_entry_safe(timer, n, &snd_timer_list, device_list)
2293         snd_timer_free(timer);
2294 }
2295
2296 static struct device timer_dev;
2297
2298 /*
2299  *  ENTRY functions
2300  */
2301
2302 static int __init alsa_timer_init(void)
2303 {
2304     int err;
2305
2306     snd_device_initialize(&timer_dev, NULL);
2307     dev_set_name(&timer_dev, "timer");
2308
2309 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
2310     snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1,
2311                   "system timer");
2312 #endif
2313
2314     err = snd_timer_register_system();
2315     if (err < 0) {
2316         pr_err("ALSA: unable to register system timer (%i)\n", err);
2317         goto put_timer;
2318     }
2319
2320     err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0,
2321                   &snd_timer_f_ops, NULL, &timer_dev);
2322     if (err < 0) {
2323         pr_err("ALSA: unable to register timer device (%i)\n", err);
2324         snd_timer_free_all();
2325         goto put_timer;
2326     }
2327
2328     snd_timer_proc_init();
2329     return 0;
2330
2331 put_timer:
2332     put_device(&timer_dev);
2333     return err;
2334 }
2335
2336 static void __exit alsa_timer_exit(void)
2337 {
2338     snd_unregister_device(&timer_dev);
2339     snd_timer_free_all();
2340     put_device(&timer_dev);
2341     snd_timer_proc_done();
2342 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
2343     snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1);
2344 #endif
2345 }
2346
2347 module_init(alsa_timer_init)
2348 module_exit(alsa_timer_exit)