12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015 |
- #include <linux/delay.h>
- #include <linux/init.h>
- #include <linux/slab.h>
- #include <linux/time.h>
- #include <linux/mutex.h>
- #include <linux/device.h>
- #include <linux/module.h>
- #include <linux/string.h>
- #include <sound/core.h>
- #include <sound/timer.h>
- #include <sound/control.h>
- #include <sound/info.h>
- #include <sound/minors.h>
- #include <sound/initval.h>
- #include <linux/kmod.h>
- #if IS_ENABLED(CONFIG_SND_HRTIMER)
- #define DEFAULT_TIMER_LIMIT 4
- #elif IS_ENABLED(CONFIG_SND_RTCTIMER)
- #define DEFAULT_TIMER_LIMIT 2
- #else
- #define DEFAULT_TIMER_LIMIT 1
- #endif
- static int timer_limit = DEFAULT_TIMER_LIMIT;
- static int timer_tstamp_monotonic = 1;
- MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>");
- MODULE_DESCRIPTION("ALSA timer interface");
- MODULE_LICENSE("GPL");
- module_param(timer_limit, int, 0444);
- MODULE_PARM_DESC(timer_limit, "Maximum global timers in system.");
- module_param(timer_tstamp_monotonic, int, 0444);
- MODULE_PARM_DESC(timer_tstamp_monotonic, "Use posix monotonic clock source for timestamps (default).");
- MODULE_ALIAS_CHARDEV(CONFIG_SND_MAJOR, SNDRV_MINOR_TIMER);
- MODULE_ALIAS("devname:snd/timer");
- struct snd_timer_user {
- struct snd_timer_instance *timeri;
- int tread;
- unsigned long ticks;
- unsigned long overrun;
- int qhead;
- int qtail;
- int qused;
- int queue_size;
- struct snd_timer_read *queue;
- struct snd_timer_tread *tqueue;
- spinlock_t qlock;
- unsigned long last_resolution;
- unsigned int filter;
- struct timespec tstamp;
- wait_queue_head_t qchange_sleep;
- struct fasync_struct *fasync;
- struct mutex tread_sem;
- };
- static LIST_HEAD(snd_timer_list);
- static LIST_HEAD(snd_timer_slave_list);
- static DEFINE_SPINLOCK(slave_active_lock);
- static DEFINE_MUTEX(register_mutex);
- static int snd_timer_free(struct snd_timer *timer);
- static int snd_timer_dev_free(struct snd_device *device);
- static int snd_timer_dev_register(struct snd_device *device);
- static int snd_timer_dev_disconnect(struct snd_device *device);
- static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left);
- static struct snd_timer_instance *snd_timer_instance_new(char *owner,
- struct snd_timer *timer)
- {
- struct snd_timer_instance *timeri;
- timeri = kzalloc(sizeof(*timeri), GFP_KERNEL);
- if (timeri == NULL)
- return NULL;
- timeri->owner = kstrdup(owner, GFP_KERNEL);
- if (! timeri->owner) {
- kfree(timeri);
- return NULL;
- }
- INIT_LIST_HEAD(&timeri->open_list);
- INIT_LIST_HEAD(&timeri->active_list);
- INIT_LIST_HEAD(&timeri->ack_list);
- INIT_LIST_HEAD(&timeri->slave_list_head);
- INIT_LIST_HEAD(&timeri->slave_active_head);
- timeri->timer = timer;
- if (timer && !try_module_get(timer->module)) {
- kfree(timeri->owner);
- kfree(timeri);
- return NULL;
- }
- return timeri;
- }
- static struct snd_timer *snd_timer_find(struct snd_timer_id *tid)
- {
- struct snd_timer *timer = NULL;
- list_for_each_entry(timer, &snd_timer_list, device_list) {
- if (timer->tmr_class != tid->dev_class)
- continue;
- if ((timer->tmr_class == SNDRV_TIMER_CLASS_CARD ||
- timer->tmr_class == SNDRV_TIMER_CLASS_PCM) &&
- (timer->card == NULL ||
- timer->card->number != tid->card))
- continue;
- if (timer->tmr_device != tid->device)
- continue;
- if (timer->tmr_subdevice != tid->subdevice)
- continue;
- return timer;
- }
- return NULL;
- }
- #ifdef CONFIG_MODULES
- static void snd_timer_request(struct snd_timer_id *tid)
- {
- switch (tid->dev_class) {
- case SNDRV_TIMER_CLASS_GLOBAL:
- if (tid->device < timer_limit)
- request_module("snd-timer-%i", tid->device);
- break;
- case SNDRV_TIMER_CLASS_CARD:
- case SNDRV_TIMER_CLASS_PCM:
- if (tid->card < snd_ecards_limit)
- request_module("snd-card-%i", tid->card);
- break;
- default:
- break;
- }
- }
- #endif
- static void snd_timer_check_slave(struct snd_timer_instance *slave)
- {
- struct snd_timer *timer;
- struct snd_timer_instance *master;
-
- list_for_each_entry(timer, &snd_timer_list, device_list) {
- list_for_each_entry(master, &timer->open_list_head, open_list) {
- if (slave->slave_class == master->slave_class &&
- slave->slave_id == master->slave_id) {
- list_move_tail(&slave->open_list,
- &master->slave_list_head);
- spin_lock_irq(&slave_active_lock);
- slave->master = master;
- slave->timer = master->timer;
- spin_unlock_irq(&slave_active_lock);
- return;
- }
- }
- }
- }
- static void snd_timer_check_master(struct snd_timer_instance *master)
- {
- struct snd_timer_instance *slave, *tmp;
-
- list_for_each_entry_safe(slave, tmp, &snd_timer_slave_list, open_list) {
- if (slave->slave_class == master->slave_class &&
- slave->slave_id == master->slave_id) {
- list_move_tail(&slave->open_list, &master->slave_list_head);
- spin_lock_irq(&slave_active_lock);
- slave->master = master;
- slave->timer = master->timer;
- if (slave->flags & SNDRV_TIMER_IFLG_RUNNING)
- list_add_tail(&slave->active_list,
- &master->slave_active_head);
- spin_unlock_irq(&slave_active_lock);
- }
- }
- }
- int snd_timer_open(struct snd_timer_instance **ti,
- char *owner, struct snd_timer_id *tid,
- unsigned int slave_id)
- {
- struct snd_timer *timer;
- struct snd_timer_instance *timeri = NULL;
- if (tid->dev_class == SNDRV_TIMER_CLASS_SLAVE) {
-
- if (tid->dev_sclass <= SNDRV_TIMER_SCLASS_NONE ||
- tid->dev_sclass > SNDRV_TIMER_SCLASS_OSS_SEQUENCER) {
- pr_debug("ALSA: timer: invalid slave class %i\n",
- tid->dev_sclass);
- return -EINVAL;
- }
- mutex_lock(®ister_mutex);
- timeri = snd_timer_instance_new(owner, NULL);
- if (!timeri) {
- mutex_unlock(®ister_mutex);
- return -ENOMEM;
- }
- timeri->slave_class = tid->dev_sclass;
- timeri->slave_id = tid->device;
- timeri->flags |= SNDRV_TIMER_IFLG_SLAVE;
- list_add_tail(&timeri->open_list, &snd_timer_slave_list);
- snd_timer_check_slave(timeri);
- mutex_unlock(®ister_mutex);
- *ti = timeri;
- return 0;
- }
-
- mutex_lock(®ister_mutex);
- timer = snd_timer_find(tid);
- #ifdef CONFIG_MODULES
- if (!timer) {
- mutex_unlock(®ister_mutex);
- snd_timer_request(tid);
- mutex_lock(®ister_mutex);
- timer = snd_timer_find(tid);
- }
- #endif
- if (!timer) {
- mutex_unlock(®ister_mutex);
- return -ENODEV;
- }
- if (!list_empty(&timer->open_list_head)) {
- timeri = list_entry(timer->open_list_head.next,
- struct snd_timer_instance, open_list);
- if (timeri->flags & SNDRV_TIMER_IFLG_EXCLUSIVE) {
- mutex_unlock(®ister_mutex);
- return -EBUSY;
- }
- }
- timeri = snd_timer_instance_new(owner, timer);
- if (!timeri) {
- mutex_unlock(®ister_mutex);
- return -ENOMEM;
- }
- timeri->slave_class = tid->dev_sclass;
- timeri->slave_id = slave_id;
- if (list_empty(&timer->open_list_head) && timer->hw.open)
- timer->hw.open(timer);
- list_add_tail(&timeri->open_list, &timer->open_list_head);
- snd_timer_check_master(timeri);
- mutex_unlock(®ister_mutex);
- *ti = timeri;
- return 0;
- }
- static int _snd_timer_stop(struct snd_timer_instance *timeri,
- int keep_flag, int event);
- int snd_timer_close(struct snd_timer_instance *timeri)
- {
- struct snd_timer *timer = NULL;
- struct snd_timer_instance *slave, *tmp;
- if (snd_BUG_ON(!timeri))
- return -ENXIO;
-
- snd_timer_stop(timeri);
- if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) {
-
- spin_lock_irq(&slave_active_lock);
- while (timeri->flags & SNDRV_TIMER_IFLG_CALLBACK) {
- spin_unlock_irq(&slave_active_lock);
- udelay(10);
- spin_lock_irq(&slave_active_lock);
- }
- spin_unlock_irq(&slave_active_lock);
- mutex_lock(®ister_mutex);
- list_del(&timeri->open_list);
- mutex_unlock(®ister_mutex);
- } else {
- timer = timeri->timer;
- if (snd_BUG_ON(!timer))
- goto out;
-
- spin_lock_irq(&timer->lock);
- while (timeri->flags & SNDRV_TIMER_IFLG_CALLBACK) {
- spin_unlock_irq(&timer->lock);
- udelay(10);
- spin_lock_irq(&timer->lock);
- }
- spin_unlock_irq(&timer->lock);
- mutex_lock(®ister_mutex);
- list_del(&timeri->open_list);
- if (timer && list_empty(&timer->open_list_head) &&
- timer->hw.close)
- timer->hw.close(timer);
-
- list_for_each_entry_safe(slave, tmp, &timeri->slave_list_head,
- open_list) {
- spin_lock_irq(&slave_active_lock);
- _snd_timer_stop(slave, 1, SNDRV_TIMER_EVENT_RESOLUTION);
- list_move_tail(&slave->open_list, &snd_timer_slave_list);
- slave->master = NULL;
- slave->timer = NULL;
- spin_unlock_irq(&slave_active_lock);
- }
- mutex_unlock(®ister_mutex);
- }
- out:
- if (timeri->private_free)
- timeri->private_free(timeri);
- kfree(timeri->owner);
- kfree(timeri);
- if (timer)
- module_put(timer->module);
- return 0;
- }
- unsigned long snd_timer_resolution(struct snd_timer_instance *timeri)
- {
- struct snd_timer * timer;
- if (timeri == NULL)
- return 0;
- if ((timer = timeri->timer) != NULL) {
- if (timer->hw.c_resolution)
- return timer->hw.c_resolution(timer);
- return timer->hw.resolution;
- }
- return 0;
- }
- static void snd_timer_notify1(struct snd_timer_instance *ti, int event)
- {
- struct snd_timer *timer;
- unsigned long flags;
- unsigned long resolution = 0;
- struct snd_timer_instance *ts;
- struct timespec tstamp;
- if (timer_tstamp_monotonic)
- ktime_get_ts(&tstamp);
- else
- getnstimeofday(&tstamp);
- if (snd_BUG_ON(event < SNDRV_TIMER_EVENT_START ||
- event > SNDRV_TIMER_EVENT_PAUSE))
- return;
- if (event == SNDRV_TIMER_EVENT_START ||
- event == SNDRV_TIMER_EVENT_CONTINUE)
- resolution = snd_timer_resolution(ti);
- if (ti->ccallback)
- ti->ccallback(ti, event, &tstamp, resolution);
- if (ti->flags & SNDRV_TIMER_IFLG_SLAVE)
- return;
- timer = ti->timer;
- if (timer == NULL)
- return;
- if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
- return;
- spin_lock_irqsave(&timer->lock, flags);
- list_for_each_entry(ts, &ti->slave_active_head, active_list)
- if (ts->ccallback)
- ts->ccallback(ti, event + 100, &tstamp, resolution);
- spin_unlock_irqrestore(&timer->lock, flags);
- }
- static int snd_timer_start1(struct snd_timer *timer, struct snd_timer_instance *timeri,
- unsigned long sticks)
- {
- list_move_tail(&timeri->active_list, &timer->active_list_head);
- if (timer->running) {
- if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
- goto __start_now;
- timer->flags |= SNDRV_TIMER_FLG_RESCHED;
- timeri->flags |= SNDRV_TIMER_IFLG_START;
- return 1;
- } else {
- timer->sticks = sticks;
- timer->hw.start(timer);
- __start_now:
- timer->running++;
- timeri->flags |= SNDRV_TIMER_IFLG_RUNNING;
- return 0;
- }
- }
- static int snd_timer_start_slave(struct snd_timer_instance *timeri)
- {
- unsigned long flags;
- spin_lock_irqsave(&slave_active_lock, flags);
- timeri->flags |= SNDRV_TIMER_IFLG_RUNNING;
- if (timeri->master)
- list_add_tail(&timeri->active_list,
- &timeri->master->slave_active_head);
- spin_unlock_irqrestore(&slave_active_lock, flags);
- return 1;
- }
- int snd_timer_start(struct snd_timer_instance *timeri, unsigned int ticks)
- {
- struct snd_timer *timer;
- int result = -EINVAL;
- unsigned long flags;
- if (timeri == NULL || ticks < 1)
- return -EINVAL;
- if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) {
- result = snd_timer_start_slave(timeri);
- snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_START);
- return result;
- }
- timer = timeri->timer;
- if (timer == NULL)
- return -EINVAL;
- spin_lock_irqsave(&timer->lock, flags);
- timeri->ticks = timeri->cticks = ticks;
- timeri->pticks = 0;
- result = snd_timer_start1(timer, timeri, ticks);
- spin_unlock_irqrestore(&timer->lock, flags);
- snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_START);
- return result;
- }
- static int _snd_timer_stop(struct snd_timer_instance * timeri,
- int keep_flag, int event)
- {
- struct snd_timer *timer;
- unsigned long flags;
- if (snd_BUG_ON(!timeri))
- return -ENXIO;
- if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) {
- if (!keep_flag) {
- spin_lock_irqsave(&slave_active_lock, flags);
- timeri->flags &= ~SNDRV_TIMER_IFLG_RUNNING;
- spin_unlock_irqrestore(&slave_active_lock, flags);
- }
- goto __end;
- }
- timer = timeri->timer;
- if (!timer)
- return -EINVAL;
- spin_lock_irqsave(&timer->lock, flags);
- list_del_init(&timeri->ack_list);
- list_del_init(&timeri->active_list);
- if ((timeri->flags & SNDRV_TIMER_IFLG_RUNNING) &&
- !(--timer->running)) {
- timer->hw.stop(timer);
- if (timer->flags & SNDRV_TIMER_FLG_RESCHED) {
- timer->flags &= ~SNDRV_TIMER_FLG_RESCHED;
- snd_timer_reschedule(timer, 0);
- if (timer->flags & SNDRV_TIMER_FLG_CHANGE) {
- timer->flags &= ~SNDRV_TIMER_FLG_CHANGE;
- timer->hw.start(timer);
- }
- }
- }
- if (!keep_flag)
- timeri->flags &=
- ~(SNDRV_TIMER_IFLG_RUNNING | SNDRV_TIMER_IFLG_START);
- spin_unlock_irqrestore(&timer->lock, flags);
- __end:
- if (event != SNDRV_TIMER_EVENT_RESOLUTION)
- snd_timer_notify1(timeri, event);
- return 0;
- }
- int snd_timer_stop(struct snd_timer_instance *timeri)
- {
- struct snd_timer *timer;
- unsigned long flags;
- int err;
- err = _snd_timer_stop(timeri, 0, SNDRV_TIMER_EVENT_STOP);
- if (err < 0)
- return err;
- timer = timeri->timer;
- if (!timer)
- return -EINVAL;
- spin_lock_irqsave(&timer->lock, flags);
- timeri->cticks = timeri->ticks;
- timeri->pticks = 0;
- spin_unlock_irqrestore(&timer->lock, flags);
- return 0;
- }
- int snd_timer_continue(struct snd_timer_instance *timeri)
- {
- struct snd_timer *timer;
- int result = -EINVAL;
- unsigned long flags;
- if (timeri == NULL)
- return result;
- if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE)
- return snd_timer_start_slave(timeri);
- timer = timeri->timer;
- if (! timer)
- return -EINVAL;
- spin_lock_irqsave(&timer->lock, flags);
- if (!timeri->cticks)
- timeri->cticks = 1;
- timeri->pticks = 0;
- result = snd_timer_start1(timer, timeri, timer->sticks);
- spin_unlock_irqrestore(&timer->lock, flags);
- snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_CONTINUE);
- return result;
- }
- int snd_timer_pause(struct snd_timer_instance * timeri)
- {
- return _snd_timer_stop(timeri, 0, SNDRV_TIMER_EVENT_PAUSE);
- }
- static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left)
- {
- struct snd_timer_instance *ti;
- unsigned long ticks = ~0UL;
- list_for_each_entry(ti, &timer->active_list_head, active_list) {
- if (ti->flags & SNDRV_TIMER_IFLG_START) {
- ti->flags &= ~SNDRV_TIMER_IFLG_START;
- ti->flags |= SNDRV_TIMER_IFLG_RUNNING;
- timer->running++;
- }
- if (ti->flags & SNDRV_TIMER_IFLG_RUNNING) {
- if (ticks > ti->cticks)
- ticks = ti->cticks;
- }
- }
- if (ticks == ~0UL) {
- timer->flags &= ~SNDRV_TIMER_FLG_RESCHED;
- return;
- }
- if (ticks > timer->hw.ticks)
- ticks = timer->hw.ticks;
- if (ticks_left != ticks)
- timer->flags |= SNDRV_TIMER_FLG_CHANGE;
- timer->sticks = ticks;
- }
- static void snd_timer_tasklet(unsigned long arg)
- {
- struct snd_timer *timer = (struct snd_timer *) arg;
- struct snd_timer_instance *ti;
- struct list_head *p;
- unsigned long resolution, ticks;
- unsigned long flags;
- spin_lock_irqsave(&timer->lock, flags);
-
- while (!list_empty(&timer->sack_list_head)) {
- p = timer->sack_list_head.next;
- ti = list_entry(p, struct snd_timer_instance, ack_list);
-
- list_del_init(p);
- ticks = ti->pticks;
- ti->pticks = 0;
- resolution = ti->resolution;
- ti->flags |= SNDRV_TIMER_IFLG_CALLBACK;
- spin_unlock(&timer->lock);
- if (ti->callback)
- ti->callback(ti, resolution, ticks);
- spin_lock(&timer->lock);
- ti->flags &= ~SNDRV_TIMER_IFLG_CALLBACK;
- }
- spin_unlock_irqrestore(&timer->lock, flags);
- }
- void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left)
- {
- struct snd_timer_instance *ti, *ts, *tmp;
- unsigned long resolution, ticks;
- struct list_head *p, *ack_list_head;
- unsigned long flags;
- int use_tasklet = 0;
- if (timer == NULL)
- return;
- spin_lock_irqsave(&timer->lock, flags);
-
- if (timer->hw.c_resolution)
- resolution = timer->hw.c_resolution(timer);
- else
- resolution = timer->hw.resolution;
-
- list_for_each_entry_safe(ti, tmp, &timer->active_list_head,
- active_list) {
- if (!(ti->flags & SNDRV_TIMER_IFLG_RUNNING))
- continue;
- ti->pticks += ticks_left;
- ti->resolution = resolution;
- if (ti->cticks < ticks_left)
- ti->cticks = 0;
- else
- ti->cticks -= ticks_left;
- if (ti->cticks)
- continue;
- if (ti->flags & SNDRV_TIMER_IFLG_AUTO) {
- ti->cticks = ti->ticks;
- } else {
- ti->flags &= ~SNDRV_TIMER_IFLG_RUNNING;
- if (--timer->running)
- list_del(&ti->active_list);
- }
- if ((timer->hw.flags & SNDRV_TIMER_HW_TASKLET) ||
- (ti->flags & SNDRV_TIMER_IFLG_FAST))
- ack_list_head = &timer->ack_list_head;
- else
- ack_list_head = &timer->sack_list_head;
- if (list_empty(&ti->ack_list))
- list_add_tail(&ti->ack_list, ack_list_head);
- list_for_each_entry(ts, &ti->slave_active_head, active_list) {
- ts->pticks = ti->pticks;
- ts->resolution = resolution;
- if (list_empty(&ts->ack_list))
- list_add_tail(&ts->ack_list, ack_list_head);
- }
- }
- if (timer->flags & SNDRV_TIMER_FLG_RESCHED)
- snd_timer_reschedule(timer, timer->sticks);
- if (timer->running) {
- if (timer->hw.flags & SNDRV_TIMER_HW_STOP) {
- timer->hw.stop(timer);
- timer->flags |= SNDRV_TIMER_FLG_CHANGE;
- }
- if (!(timer->hw.flags & SNDRV_TIMER_HW_AUTO) ||
- (timer->flags & SNDRV_TIMER_FLG_CHANGE)) {
-
- timer->flags &= ~SNDRV_TIMER_FLG_CHANGE;
- timer->hw.start(timer);
- }
- } else {
- timer->hw.stop(timer);
- }
-
- while (!list_empty(&timer->ack_list_head)) {
- p = timer->ack_list_head.next;
- ti = list_entry(p, struct snd_timer_instance, ack_list);
-
- list_del_init(p);
- ticks = ti->pticks;
- ti->pticks = 0;
- ti->flags |= SNDRV_TIMER_IFLG_CALLBACK;
- spin_unlock(&timer->lock);
- if (ti->callback)
- ti->callback(ti, resolution, ticks);
- spin_lock(&timer->lock);
- ti->flags &= ~SNDRV_TIMER_IFLG_CALLBACK;
- }
-
- use_tasklet = !list_empty(&timer->sack_list_head);
- spin_unlock_irqrestore(&timer->lock, flags);
- if (use_tasklet)
- tasklet_schedule(&timer->task_queue);
- }
- int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid,
- struct snd_timer **rtimer)
- {
- struct snd_timer *timer;
- int err;
- static struct snd_device_ops ops = {
- .dev_free = snd_timer_dev_free,
- .dev_register = snd_timer_dev_register,
- .dev_disconnect = snd_timer_dev_disconnect,
- };
- if (snd_BUG_ON(!tid))
- return -EINVAL;
- if (rtimer)
- *rtimer = NULL;
- timer = kzalloc(sizeof(*timer), GFP_KERNEL);
- if (!timer)
- return -ENOMEM;
- timer->tmr_class = tid->dev_class;
- timer->card = card;
- timer->tmr_device = tid->device;
- timer->tmr_subdevice = tid->subdevice;
- if (id)
- strlcpy(timer->id, id, sizeof(timer->id));
- INIT_LIST_HEAD(&timer->device_list);
- INIT_LIST_HEAD(&timer->open_list_head);
- INIT_LIST_HEAD(&timer->active_list_head);
- INIT_LIST_HEAD(&timer->ack_list_head);
- INIT_LIST_HEAD(&timer->sack_list_head);
- spin_lock_init(&timer->lock);
- tasklet_init(&timer->task_queue, snd_timer_tasklet,
- (unsigned long)timer);
- if (card != NULL) {
- timer->module = card->module;
- err = snd_device_new(card, SNDRV_DEV_TIMER, timer, &ops);
- if (err < 0) {
- snd_timer_free(timer);
- return err;
- }
- }
- if (rtimer)
- *rtimer = timer;
- return 0;
- }
- static int snd_timer_free(struct snd_timer *timer)
- {
- if (!timer)
- return 0;
- mutex_lock(®ister_mutex);
- if (! list_empty(&timer->open_list_head)) {
- struct list_head *p, *n;
- struct snd_timer_instance *ti;
- pr_warn("ALSA: timer %p is busy?\n", timer);
- list_for_each_safe(p, n, &timer->open_list_head) {
- list_del_init(p);
- ti = list_entry(p, struct snd_timer_instance, open_list);
- ti->timer = NULL;
- }
- }
- list_del(&timer->device_list);
- mutex_unlock(®ister_mutex);
- if (timer->private_free)
- timer->private_free(timer);
- kfree(timer);
- return 0;
- }
- static int snd_timer_dev_free(struct snd_device *device)
- {
- struct snd_timer *timer = device->device_data;
- return snd_timer_free(timer);
- }
- static int snd_timer_dev_register(struct snd_device *dev)
- {
- struct snd_timer *timer = dev->device_data;
- struct snd_timer *timer1;
- if (snd_BUG_ON(!timer || !timer->hw.start || !timer->hw.stop))
- return -ENXIO;
- if (!(timer->hw.flags & SNDRV_TIMER_HW_SLAVE) &&
- !timer->hw.resolution && timer->hw.c_resolution == NULL)
- return -EINVAL;
- mutex_lock(®ister_mutex);
- list_for_each_entry(timer1, &snd_timer_list, device_list) {
- if (timer1->tmr_class > timer->tmr_class)
- break;
- if (timer1->tmr_class < timer->tmr_class)
- continue;
- if (timer1->card && timer->card) {
- if (timer1->card->number > timer->card->number)
- break;
- if (timer1->card->number < timer->card->number)
- continue;
- }
- if (timer1->tmr_device > timer->tmr_device)
- break;
- if (timer1->tmr_device < timer->tmr_device)
- continue;
- if (timer1->tmr_subdevice > timer->tmr_subdevice)
- break;
- if (timer1->tmr_subdevice < timer->tmr_subdevice)
- continue;
-
- mutex_unlock(®ister_mutex);
- return -EBUSY;
- }
- list_add_tail(&timer->device_list, &timer1->device_list);
- mutex_unlock(®ister_mutex);
- return 0;
- }
- static int snd_timer_dev_disconnect(struct snd_device *device)
- {
- struct snd_timer *timer = device->device_data;
- mutex_lock(®ister_mutex);
- list_del_init(&timer->device_list);
- mutex_unlock(®ister_mutex);
- return 0;
- }
- void snd_timer_notify(struct snd_timer *timer, int event, struct timespec *tstamp)
- {
- unsigned long flags;
- unsigned long resolution = 0;
- struct snd_timer_instance *ti, *ts;
- if (! (timer->hw.flags & SNDRV_TIMER_HW_SLAVE))
- return;
- if (snd_BUG_ON(event < SNDRV_TIMER_EVENT_MSTART ||
- event > SNDRV_TIMER_EVENT_MRESUME))
- return;
- spin_lock_irqsave(&timer->lock, flags);
- if (event == SNDRV_TIMER_EVENT_MSTART ||
- event == SNDRV_TIMER_EVENT_MCONTINUE ||
- event == SNDRV_TIMER_EVENT_MRESUME) {
- if (timer->hw.c_resolution)
- resolution = timer->hw.c_resolution(timer);
- else
- resolution = timer->hw.resolution;
- }
- list_for_each_entry(ti, &timer->active_list_head, active_list) {
- if (ti->ccallback)
- ti->ccallback(ti, event, tstamp, resolution);
- list_for_each_entry(ts, &ti->slave_active_head, active_list)
- if (ts->ccallback)
- ts->ccallback(ts, event, tstamp, resolution);
- }
- spin_unlock_irqrestore(&timer->lock, flags);
- }
- int snd_timer_global_new(char *id, int device, struct snd_timer **rtimer)
- {
- struct snd_timer_id tid;
- tid.dev_class = SNDRV_TIMER_CLASS_GLOBAL;
- tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
- tid.card = -1;
- tid.device = device;
- tid.subdevice = 0;
- return snd_timer_new(NULL, id, &tid, rtimer);
- }
- int snd_timer_global_free(struct snd_timer *timer)
- {
- return snd_timer_free(timer);
- }
- int snd_timer_global_register(struct snd_timer *timer)
- {
- struct snd_device dev;
- memset(&dev, 0, sizeof(dev));
- dev.device_data = timer;
- return snd_timer_dev_register(&dev);
- }
- struct snd_timer_system_private {
- struct timer_list tlist;
- unsigned long last_expires;
- unsigned long last_jiffies;
- unsigned long correction;
- };
- static void snd_timer_s_function(unsigned long data)
- {
- struct snd_timer *timer = (struct snd_timer *)data;
- struct snd_timer_system_private *priv = timer->private_data;
- unsigned long jiff = jiffies;
- if (time_after(jiff, priv->last_expires))
- priv->correction += (long)jiff - (long)priv->last_expires;
- snd_timer_interrupt(timer, (long)jiff - (long)priv->last_jiffies);
- }
- static int snd_timer_s_start(struct snd_timer * timer)
- {
- struct snd_timer_system_private *priv;
- unsigned long njiff;
- priv = (struct snd_timer_system_private *) timer->private_data;
- njiff = (priv->last_jiffies = jiffies);
- if (priv->correction > timer->sticks - 1) {
- priv->correction -= timer->sticks - 1;
- njiff++;
- } else {
- njiff += timer->sticks - priv->correction;
- priv->correction = 0;
- }
- priv->last_expires = priv->tlist.expires = njiff;
- add_timer(&priv->tlist);
- return 0;
- }
- static int snd_timer_s_stop(struct snd_timer * timer)
- {
- struct snd_timer_system_private *priv;
- unsigned long jiff;
- priv = (struct snd_timer_system_private *) timer->private_data;
- del_timer(&priv->tlist);
- jiff = jiffies;
- if (time_before(jiff, priv->last_expires))
- timer->sticks = priv->last_expires - jiff;
- else
- timer->sticks = 1;
- priv->correction = 0;
- return 0;
- }
- static struct snd_timer_hardware snd_timer_system =
- {
- .flags = SNDRV_TIMER_HW_FIRST | SNDRV_TIMER_HW_TASKLET,
- .resolution = 1000000000L / HZ,
- .ticks = 10000000L,
- .start = snd_timer_s_start,
- .stop = snd_timer_s_stop
- };
- static void snd_timer_free_system(struct snd_timer *timer)
- {
- kfree(timer->private_data);
- }
- static int snd_timer_register_system(void)
- {
- struct snd_timer *timer;
- struct snd_timer_system_private *priv;
- int err;
- err = snd_timer_global_new("system", SNDRV_TIMER_GLOBAL_SYSTEM, &timer);
- if (err < 0)
- return err;
- strcpy(timer->name, "system timer");
- timer->hw = snd_timer_system;
- priv = kzalloc(sizeof(*priv), GFP_KERNEL);
- if (priv == NULL) {
- snd_timer_free(timer);
- return -ENOMEM;
- }
- setup_timer(&priv->tlist, snd_timer_s_function, (unsigned long) timer);
- timer->private_data = priv;
- timer->private_free = snd_timer_free_system;
- return snd_timer_global_register(timer);
- }
- #ifdef CONFIG_SND_PROC_FS
- static void snd_timer_proc_read(struct snd_info_entry *entry,
- struct snd_info_buffer *buffer)
- {
- struct snd_timer *timer;
- struct snd_timer_instance *ti;
- mutex_lock(®ister_mutex);
- list_for_each_entry(timer, &snd_timer_list, device_list) {
- switch (timer->tmr_class) {
- case SNDRV_TIMER_CLASS_GLOBAL:
- snd_iprintf(buffer, "G%i: ", timer->tmr_device);
- break;
- case SNDRV_TIMER_CLASS_CARD:
- snd_iprintf(buffer, "C%i-%i: ",
- timer->card->number, timer->tmr_device);
- break;
- case SNDRV_TIMER_CLASS_PCM:
- snd_iprintf(buffer, "P%i-%i-%i: ", timer->card->number,
- timer->tmr_device, timer->tmr_subdevice);
- break;
- default:
- snd_iprintf(buffer, "?%i-%i-%i-%i: ", timer->tmr_class,
- timer->card ? timer->card->number : -1,
- timer->tmr_device, timer->tmr_subdevice);
- }
- snd_iprintf(buffer, "%s :", timer->name);
- if (timer->hw.resolution)
- snd_iprintf(buffer, " %lu.%03luus (%lu ticks)",
- timer->hw.resolution / 1000,
- timer->hw.resolution % 1000,
- timer->hw.ticks);
- if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
- snd_iprintf(buffer, " SLAVE");
- snd_iprintf(buffer, "\n");
- list_for_each_entry(ti, &timer->open_list_head, open_list)
- snd_iprintf(buffer, " Client %s : %s\n",
- ti->owner ? ti->owner : "unknown",
- ti->flags & (SNDRV_TIMER_IFLG_START |
- SNDRV_TIMER_IFLG_RUNNING)
- ? "running" : "stopped");
- }
- mutex_unlock(®ister_mutex);
- }
- static struct snd_info_entry *snd_timer_proc_entry;
- static void __init snd_timer_proc_init(void)
- {
- struct snd_info_entry *entry;
- entry = snd_info_create_module_entry(THIS_MODULE, "timers", NULL);
- if (entry != NULL) {
- entry->c.text.read = snd_timer_proc_read;
- if (snd_info_register(entry) < 0) {
- snd_info_free_entry(entry);
- entry = NULL;
- }
- }
- snd_timer_proc_entry = entry;
- }
- static void __exit snd_timer_proc_done(void)
- {
- snd_info_free_entry(snd_timer_proc_entry);
- }
- #else
- #define snd_timer_proc_init()
- #define snd_timer_proc_done()
- #endif
- static void snd_timer_user_interrupt(struct snd_timer_instance *timeri,
- unsigned long resolution,
- unsigned long ticks)
- {
- struct snd_timer_user *tu = timeri->callback_data;
- struct snd_timer_read *r;
- int prev;
- spin_lock(&tu->qlock);
- if (tu->qused > 0) {
- prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1;
- r = &tu->queue[prev];
- if (r->resolution == resolution) {
- r->ticks += ticks;
- goto __wake;
- }
- }
- if (tu->qused >= tu->queue_size) {
- tu->overrun++;
- } else {
- r = &tu->queue[tu->qtail++];
- tu->qtail %= tu->queue_size;
- r->resolution = resolution;
- r->ticks = ticks;
- tu->qused++;
- }
- __wake:
- spin_unlock(&tu->qlock);
- kill_fasync(&tu->fasync, SIGIO, POLL_IN);
- wake_up(&tu->qchange_sleep);
- }
- static void snd_timer_user_append_to_tqueue(struct snd_timer_user *tu,
- struct snd_timer_tread *tread)
- {
- if (tu->qused >= tu->queue_size) {
- tu->overrun++;
- } else {
- memcpy(&tu->tqueue[tu->qtail++], tread, sizeof(*tread));
- tu->qtail %= tu->queue_size;
- tu->qused++;
- }
- }
- static void snd_timer_user_ccallback(struct snd_timer_instance *timeri,
- int event,
- struct timespec *tstamp,
- unsigned long resolution)
- {
- struct snd_timer_user *tu = timeri->callback_data;
- struct snd_timer_tread r1;
- unsigned long flags;
- if (event >= SNDRV_TIMER_EVENT_START &&
- event <= SNDRV_TIMER_EVENT_PAUSE)
- tu->tstamp = *tstamp;
- if ((tu->filter & (1 << event)) == 0 || !tu->tread)
- return;
- r1.event = event;
- r1.tstamp = *tstamp;
- r1.val = resolution;
- spin_lock_irqsave(&tu->qlock, flags);
- snd_timer_user_append_to_tqueue(tu, &r1);
- spin_unlock_irqrestore(&tu->qlock, flags);
- kill_fasync(&tu->fasync, SIGIO, POLL_IN);
- wake_up(&tu->qchange_sleep);
- }
- static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri,
- unsigned long resolution,
- unsigned long ticks)
- {
- struct snd_timer_user *tu = timeri->callback_data;
- struct snd_timer_tread *r, r1;
- struct timespec tstamp;
- int prev, append = 0;
- memset(&tstamp, 0, sizeof(tstamp));
- spin_lock(&tu->qlock);
- if ((tu->filter & ((1 << SNDRV_TIMER_EVENT_RESOLUTION) |
- (1 << SNDRV_TIMER_EVENT_TICK))) == 0) {
- spin_unlock(&tu->qlock);
- return;
- }
- if (tu->last_resolution != resolution || ticks > 0) {
- if (timer_tstamp_monotonic)
- ktime_get_ts(&tstamp);
- else
- getnstimeofday(&tstamp);
- }
- if ((tu->filter & (1 << SNDRV_TIMER_EVENT_RESOLUTION)) &&
- tu->last_resolution != resolution) {
- r1.event = SNDRV_TIMER_EVENT_RESOLUTION;
- r1.tstamp = tstamp;
- r1.val = resolution;
- snd_timer_user_append_to_tqueue(tu, &r1);
- tu->last_resolution = resolution;
- append++;
- }
- if ((tu->filter & (1 << SNDRV_TIMER_EVENT_TICK)) == 0)
- goto __wake;
- if (ticks == 0)
- goto __wake;
- if (tu->qused > 0) {
- prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1;
- r = &tu->tqueue[prev];
- if (r->event == SNDRV_TIMER_EVENT_TICK) {
- r->tstamp = tstamp;
- r->val += ticks;
- append++;
- goto __wake;
- }
- }
- r1.event = SNDRV_TIMER_EVENT_TICK;
- r1.tstamp = tstamp;
- r1.val = ticks;
- snd_timer_user_append_to_tqueue(tu, &r1);
- append++;
- __wake:
- spin_unlock(&tu->qlock);
- if (append == 0)
- return;
- kill_fasync(&tu->fasync, SIGIO, POLL_IN);
- wake_up(&tu->qchange_sleep);
- }
- static int snd_timer_user_open(struct inode *inode, struct file *file)
- {
- struct snd_timer_user *tu;
- int err;
- err = nonseekable_open(inode, file);
- if (err < 0)
- return err;
- tu = kzalloc(sizeof(*tu), GFP_KERNEL);
- if (tu == NULL)
- return -ENOMEM;
- spin_lock_init(&tu->qlock);
- init_waitqueue_head(&tu->qchange_sleep);
- mutex_init(&tu->tread_sem);
- tu->ticks = 1;
- tu->queue_size = 128;
- tu->queue = kmalloc(tu->queue_size * sizeof(struct snd_timer_read),
- GFP_KERNEL);
- if (tu->queue == NULL) {
- kfree(tu);
- return -ENOMEM;
- }
- file->private_data = tu;
- return 0;
- }
- static int snd_timer_user_release(struct inode *inode, struct file *file)
- {
- struct snd_timer_user *tu;
- if (file->private_data) {
- tu = file->private_data;
- file->private_data = NULL;
- if (tu->timeri)
- snd_timer_close(tu->timeri);
- kfree(tu->queue);
- kfree(tu->tqueue);
- kfree(tu);
- }
- return 0;
- }
- static void snd_timer_user_zero_id(struct snd_timer_id *id)
- {
- id->dev_class = SNDRV_TIMER_CLASS_NONE;
- id->dev_sclass = SNDRV_TIMER_SCLASS_NONE;
- id->card = -1;
- id->device = -1;
- id->subdevice = -1;
- }
- static void snd_timer_user_copy_id(struct snd_timer_id *id, struct snd_timer *timer)
- {
- id->dev_class = timer->tmr_class;
- id->dev_sclass = SNDRV_TIMER_SCLASS_NONE;
- id->card = timer->card ? timer->card->number : -1;
- id->device = timer->tmr_device;
- id->subdevice = timer->tmr_subdevice;
- }
- static int snd_timer_user_next_device(struct snd_timer_id __user *_tid)
- {
- struct snd_timer_id id;
- struct snd_timer *timer;
- struct list_head *p;
- if (copy_from_user(&id, _tid, sizeof(id)))
- return -EFAULT;
- mutex_lock(®ister_mutex);
- if (id.dev_class < 0) {
- if (list_empty(&snd_timer_list))
- snd_timer_user_zero_id(&id);
- else {
- timer = list_entry(snd_timer_list.next,
- struct snd_timer, device_list);
- snd_timer_user_copy_id(&id, timer);
- }
- } else {
- switch (id.dev_class) {
- case SNDRV_TIMER_CLASS_GLOBAL:
- id.device = id.device < 0 ? 0 : id.device + 1;
- list_for_each(p, &snd_timer_list) {
- timer = list_entry(p, struct snd_timer, device_list);
- if (timer->tmr_class > SNDRV_TIMER_CLASS_GLOBAL) {
- snd_timer_user_copy_id(&id, timer);
- break;
- }
- if (timer->tmr_device >= id.device) {
- snd_timer_user_copy_id(&id, timer);
- break;
- }
- }
- if (p == &snd_timer_list)
- snd_timer_user_zero_id(&id);
- break;
- case SNDRV_TIMER_CLASS_CARD:
- case SNDRV_TIMER_CLASS_PCM:
- if (id.card < 0) {
- id.card = 0;
- } else {
- if (id.card < 0) {
- id.card = 0;
- } else {
- if (id.device < 0) {
- id.device = 0;
- } else {
- if (id.subdevice < 0) {
- id.subdevice = 0;
- } else {
- id.subdevice++;
- }
- }
- }
- }
- list_for_each(p, &snd_timer_list) {
- timer = list_entry(p, struct snd_timer, device_list);
- if (timer->tmr_class > id.dev_class) {
- snd_timer_user_copy_id(&id, timer);
- break;
- }
- if (timer->tmr_class < id.dev_class)
- continue;
- if (timer->card->number > id.card) {
- snd_timer_user_copy_id(&id, timer);
- break;
- }
- if (timer->card->number < id.card)
- continue;
- if (timer->tmr_device > id.device) {
- snd_timer_user_copy_id(&id, timer);
- break;
- }
- if (timer->tmr_device < id.device)
- continue;
- if (timer->tmr_subdevice > id.subdevice) {
- snd_timer_user_copy_id(&id, timer);
- break;
- }
- if (timer->tmr_subdevice < id.subdevice)
- continue;
- snd_timer_user_copy_id(&id, timer);
- break;
- }
- if (p == &snd_timer_list)
- snd_timer_user_zero_id(&id);
- break;
- default:
- snd_timer_user_zero_id(&id);
- }
- }
- mutex_unlock(®ister_mutex);
- if (copy_to_user(_tid, &id, sizeof(*_tid)))
- return -EFAULT;
- return 0;
- }
- static int snd_timer_user_ginfo(struct file *file,
- struct snd_timer_ginfo __user *_ginfo)
- {
- struct snd_timer_ginfo *ginfo;
- struct snd_timer_id tid;
- struct snd_timer *t;
- struct list_head *p;
- int err = 0;
- ginfo = memdup_user(_ginfo, sizeof(*ginfo));
- if (IS_ERR(ginfo))
- return PTR_ERR(ginfo);
- tid = ginfo->tid;
- memset(ginfo, 0, sizeof(*ginfo));
- ginfo->tid = tid;
- mutex_lock(®ister_mutex);
- t = snd_timer_find(&tid);
- if (t != NULL) {
- ginfo->card = t->card ? t->card->number : -1;
- if (t->hw.flags & SNDRV_TIMER_HW_SLAVE)
- ginfo->flags |= SNDRV_TIMER_FLG_SLAVE;
- strlcpy(ginfo->id, t->id, sizeof(ginfo->id));
- strlcpy(ginfo->name, t->name, sizeof(ginfo->name));
- ginfo->resolution = t->hw.resolution;
- if (t->hw.resolution_min > 0) {
- ginfo->resolution_min = t->hw.resolution_min;
- ginfo->resolution_max = t->hw.resolution_max;
- }
- list_for_each(p, &t->open_list_head) {
- ginfo->clients++;
- }
- } else {
- err = -ENODEV;
- }
- mutex_unlock(®ister_mutex);
- if (err >= 0 && copy_to_user(_ginfo, ginfo, sizeof(*ginfo)))
- err = -EFAULT;
- kfree(ginfo);
- return err;
- }
- static int snd_timer_user_gparams(struct file *file,
- struct snd_timer_gparams __user *_gparams)
- {
- struct snd_timer_gparams gparams;
- struct snd_timer *t;
- int err;
- if (copy_from_user(&gparams, _gparams, sizeof(gparams)))
- return -EFAULT;
- mutex_lock(®ister_mutex);
- t = snd_timer_find(&gparams.tid);
- if (!t) {
- err = -ENODEV;
- goto _error;
- }
- if (!list_empty(&t->open_list_head)) {
- err = -EBUSY;
- goto _error;
- }
- if (!t->hw.set_period) {
- err = -ENOSYS;
- goto _error;
- }
- err = t->hw.set_period(t, gparams.period_num, gparams.period_den);
- _error:
- mutex_unlock(®ister_mutex);
- return err;
- }
- static int snd_timer_user_gstatus(struct file *file,
- struct snd_timer_gstatus __user *_gstatus)
- {
- struct snd_timer_gstatus gstatus;
- struct snd_timer_id tid;
- struct snd_timer *t;
- int err = 0;
- if (copy_from_user(&gstatus, _gstatus, sizeof(gstatus)))
- return -EFAULT;
- tid = gstatus.tid;
- memset(&gstatus, 0, sizeof(gstatus));
- gstatus.tid = tid;
- mutex_lock(®ister_mutex);
- t = snd_timer_find(&tid);
- if (t != NULL) {
- if (t->hw.c_resolution)
- gstatus.resolution = t->hw.c_resolution(t);
- else
- gstatus.resolution = t->hw.resolution;
- if (t->hw.precise_resolution) {
- t->hw.precise_resolution(t, &gstatus.resolution_num,
- &gstatus.resolution_den);
- } else {
- gstatus.resolution_num = gstatus.resolution;
- gstatus.resolution_den = 1000000000uL;
- }
- } else {
- err = -ENODEV;
- }
- mutex_unlock(®ister_mutex);
- if (err >= 0 && copy_to_user(_gstatus, &gstatus, sizeof(gstatus)))
- err = -EFAULT;
- return err;
- }
- static int snd_timer_user_tselect(struct file *file,
- struct snd_timer_select __user *_tselect)
- {
- struct snd_timer_user *tu;
- struct snd_timer_select tselect;
- char str[32];
- int err = 0;
- tu = file->private_data;
- mutex_lock(&tu->tread_sem);
- if (tu->timeri) {
- snd_timer_close(tu->timeri);
- tu->timeri = NULL;
- }
- if (copy_from_user(&tselect, _tselect, sizeof(tselect))) {
- err = -EFAULT;
- goto __err;
- }
- sprintf(str, "application %i", current->pid);
- if (tselect.id.dev_class != SNDRV_TIMER_CLASS_SLAVE)
- tselect.id.dev_sclass = SNDRV_TIMER_SCLASS_APPLICATION;
- err = snd_timer_open(&tu->timeri, str, &tselect.id, current->pid);
- if (err < 0)
- goto __err;
- kfree(tu->queue);
- tu->queue = NULL;
- kfree(tu->tqueue);
- tu->tqueue = NULL;
- if (tu->tread) {
- tu->tqueue = kmalloc(tu->queue_size * sizeof(struct snd_timer_tread),
- GFP_KERNEL);
- if (tu->tqueue == NULL)
- err = -ENOMEM;
- } else {
- tu->queue = kmalloc(tu->queue_size * sizeof(struct snd_timer_read),
- GFP_KERNEL);
- if (tu->queue == NULL)
- err = -ENOMEM;
- }
- if (err < 0) {
- snd_timer_close(tu->timeri);
- tu->timeri = NULL;
- } else {
- tu->timeri->flags |= SNDRV_TIMER_IFLG_FAST;
- tu->timeri->callback = tu->tread
- ? snd_timer_user_tinterrupt : snd_timer_user_interrupt;
- tu->timeri->ccallback = snd_timer_user_ccallback;
- tu->timeri->callback_data = (void *)tu;
- }
- __err:
- mutex_unlock(&tu->tread_sem);
- return err;
- }
- static int snd_timer_user_info(struct file *file,
- struct snd_timer_info __user *_info)
- {
- struct snd_timer_user *tu;
- struct snd_timer_info *info;
- struct snd_timer *t;
- int err = 0;
- tu = file->private_data;
- if (!tu->timeri)
- return -EBADFD;
- t = tu->timeri->timer;
- if (!t)
- return -EBADFD;
- info = kzalloc(sizeof(*info), GFP_KERNEL);
- if (! info)
- return -ENOMEM;
- info->card = t->card ? t->card->number : -1;
- if (t->hw.flags & SNDRV_TIMER_HW_SLAVE)
- info->flags |= SNDRV_TIMER_FLG_SLAVE;
- strlcpy(info->id, t->id, sizeof(info->id));
- strlcpy(info->name, t->name, sizeof(info->name));
- info->resolution = t->hw.resolution;
- if (copy_to_user(_info, info, sizeof(*_info)))
- err = -EFAULT;
- kfree(info);
- return err;
- }
- static int snd_timer_user_params(struct file *file,
- struct snd_timer_params __user *_params)
- {
- struct snd_timer_user *tu;
- struct snd_timer_params params;
- struct snd_timer *t;
- struct snd_timer_read *tr;
- struct snd_timer_tread *ttr;
- int err;
- tu = file->private_data;
- if (!tu->timeri)
- return -EBADFD;
- t = tu->timeri->timer;
- if (!t)
- return -EBADFD;
- if (copy_from_user(¶ms, _params, sizeof(params)))
- return -EFAULT;
- if (!(t->hw.flags & SNDRV_TIMER_HW_SLAVE) && params.ticks < 1) {
- err = -EINVAL;
- goto _end;
- }
- if (params.queue_size > 0 &&
- (params.queue_size < 32 || params.queue_size > 1024)) {
- err = -EINVAL;
- goto _end;
- }
- if (params.filter & ~((1<<SNDRV_TIMER_EVENT_RESOLUTION)|
- (1<<SNDRV_TIMER_EVENT_TICK)|
- (1<<SNDRV_TIMER_EVENT_START)|
- (1<<SNDRV_TIMER_EVENT_STOP)|
- (1<<SNDRV_TIMER_EVENT_CONTINUE)|
- (1<<SNDRV_TIMER_EVENT_PAUSE)|
- (1<<SNDRV_TIMER_EVENT_SUSPEND)|
- (1<<SNDRV_TIMER_EVENT_RESUME)|
- (1<<SNDRV_TIMER_EVENT_MSTART)|
- (1<<SNDRV_TIMER_EVENT_MSTOP)|
- (1<<SNDRV_TIMER_EVENT_MCONTINUE)|
- (1<<SNDRV_TIMER_EVENT_MPAUSE)|
- (1<<SNDRV_TIMER_EVENT_MSUSPEND)|
- (1<<SNDRV_TIMER_EVENT_MRESUME))) {
- err = -EINVAL;
- goto _end;
- }
- snd_timer_stop(tu->timeri);
- spin_lock_irq(&t->lock);
- tu->timeri->flags &= ~(SNDRV_TIMER_IFLG_AUTO|
- SNDRV_TIMER_IFLG_EXCLUSIVE|
- SNDRV_TIMER_IFLG_EARLY_EVENT);
- if (params.flags & SNDRV_TIMER_PSFLG_AUTO)
- tu->timeri->flags |= SNDRV_TIMER_IFLG_AUTO;
- if (params.flags & SNDRV_TIMER_PSFLG_EXCLUSIVE)
- tu->timeri->flags |= SNDRV_TIMER_IFLG_EXCLUSIVE;
- if (params.flags & SNDRV_TIMER_PSFLG_EARLY_EVENT)
- tu->timeri->flags |= SNDRV_TIMER_IFLG_EARLY_EVENT;
- spin_unlock_irq(&t->lock);
- if (params.queue_size > 0 &&
- (unsigned int)tu->queue_size != params.queue_size) {
- if (tu->tread) {
- ttr = kmalloc(params.queue_size * sizeof(*ttr),
- GFP_KERNEL);
- if (ttr) {
- kfree(tu->tqueue);
- tu->queue_size = params.queue_size;
- tu->tqueue = ttr;
- }
- } else {
- tr = kmalloc(params.queue_size * sizeof(*tr),
- GFP_KERNEL);
- if (tr) {
- kfree(tu->queue);
- tu->queue_size = params.queue_size;
- tu->queue = tr;
- }
- }
- }
- tu->qhead = tu->qtail = tu->qused = 0;
- if (tu->timeri->flags & SNDRV_TIMER_IFLG_EARLY_EVENT) {
- if (tu->tread) {
- struct snd_timer_tread tread;
- tread.event = SNDRV_TIMER_EVENT_EARLY;
- tread.tstamp.tv_sec = 0;
- tread.tstamp.tv_nsec = 0;
- tread.val = 0;
- snd_timer_user_append_to_tqueue(tu, &tread);
- } else {
- struct snd_timer_read *r = &tu->queue[0];
- r->resolution = 0;
- r->ticks = 0;
- tu->qused++;
- tu->qtail++;
- }
- }
- tu->filter = params.filter;
- tu->ticks = params.ticks;
- err = 0;
- _end:
- if (copy_to_user(_params, ¶ms, sizeof(params)))
- return -EFAULT;
- return err;
- }
- static int snd_timer_user_status(struct file *file,
- struct snd_timer_status __user *_status)
- {
- struct snd_timer_user *tu;
- struct snd_timer_status status;
- tu = file->private_data;
- if (!tu->timeri)
- return -EBADFD;
- memset(&status, 0, sizeof(status));
- status.tstamp = tu->tstamp;
- status.resolution = snd_timer_resolution(tu->timeri);
- status.lost = tu->timeri->lost;
- status.overrun = tu->overrun;
- spin_lock_irq(&tu->qlock);
- status.queue = tu->qused;
- spin_unlock_irq(&tu->qlock);
- if (copy_to_user(_status, &status, sizeof(status)))
- return -EFAULT;
- return 0;
- }
- static int snd_timer_user_start(struct file *file)
- {
- int err;
- struct snd_timer_user *tu;
- tu = file->private_data;
- if (!tu->timeri)
- return -EBADFD;
- snd_timer_stop(tu->timeri);
- tu->timeri->lost = 0;
- tu->last_resolution = 0;
- return (err = snd_timer_start(tu->timeri, tu->ticks)) < 0 ? err : 0;
- }
- static int snd_timer_user_stop(struct file *file)
- {
- int err;
- struct snd_timer_user *tu;
- tu = file->private_data;
- if (!tu->timeri)
- return -EBADFD;
- return (err = snd_timer_stop(tu->timeri)) < 0 ? err : 0;
- }
- static int snd_timer_user_continue(struct file *file)
- {
- int err;
- struct snd_timer_user *tu;
- tu = file->private_data;
- if (!tu->timeri)
- return -EBADFD;
- tu->timeri->lost = 0;
- return (err = snd_timer_continue(tu->timeri)) < 0 ? err : 0;
- }
- static int snd_timer_user_pause(struct file *file)
- {
- int err;
- struct snd_timer_user *tu;
- tu = file->private_data;
- if (!tu->timeri)
- return -EBADFD;
- return (err = snd_timer_pause(tu->timeri)) < 0 ? err : 0;
- }
- enum {
- SNDRV_TIMER_IOCTL_START_OLD = _IO('T', 0x20),
- SNDRV_TIMER_IOCTL_STOP_OLD = _IO('T', 0x21),
- SNDRV_TIMER_IOCTL_CONTINUE_OLD = _IO('T', 0x22),
- SNDRV_TIMER_IOCTL_PAUSE_OLD = _IO('T', 0x23),
- };
- static long snd_timer_user_ioctl(struct file *file, unsigned int cmd,
- unsigned long arg)
- {
- struct snd_timer_user *tu;
- void __user *argp = (void __user *)arg;
- int __user *p = argp;
- tu = file->private_data;
- switch (cmd) {
- case SNDRV_TIMER_IOCTL_PVERSION:
- return put_user(SNDRV_TIMER_VERSION, p) ? -EFAULT : 0;
- case SNDRV_TIMER_IOCTL_NEXT_DEVICE:
- return snd_timer_user_next_device(argp);
- case SNDRV_TIMER_IOCTL_TREAD:
- {
- int xarg;
- mutex_lock(&tu->tread_sem);
- if (tu->timeri) {
- mutex_unlock(&tu->tread_sem);
- return -EBUSY;
- }
- if (get_user(xarg, p)) {
- mutex_unlock(&tu->tread_sem);
- return -EFAULT;
- }
- tu->tread = xarg ? 1 : 0;
- mutex_unlock(&tu->tread_sem);
- return 0;
- }
- case SNDRV_TIMER_IOCTL_GINFO:
- return snd_timer_user_ginfo(file, argp);
- case SNDRV_TIMER_IOCTL_GPARAMS:
- return snd_timer_user_gparams(file, argp);
- case SNDRV_TIMER_IOCTL_GSTATUS:
- return snd_timer_user_gstatus(file, argp);
- case SNDRV_TIMER_IOCTL_SELECT:
- return snd_timer_user_tselect(file, argp);
- case SNDRV_TIMER_IOCTL_INFO:
- return snd_timer_user_info(file, argp);
- case SNDRV_TIMER_IOCTL_PARAMS:
- return snd_timer_user_params(file, argp);
- case SNDRV_TIMER_IOCTL_STATUS:
- return snd_timer_user_status(file, argp);
- case SNDRV_TIMER_IOCTL_START:
- case SNDRV_TIMER_IOCTL_START_OLD:
- return snd_timer_user_start(file);
- case SNDRV_TIMER_IOCTL_STOP:
- case SNDRV_TIMER_IOCTL_STOP_OLD:
- return snd_timer_user_stop(file);
- case SNDRV_TIMER_IOCTL_CONTINUE:
- case SNDRV_TIMER_IOCTL_CONTINUE_OLD:
- return snd_timer_user_continue(file);
- case SNDRV_TIMER_IOCTL_PAUSE:
- case SNDRV_TIMER_IOCTL_PAUSE_OLD:
- return snd_timer_user_pause(file);
- }
- return -ENOTTY;
- }
- static int snd_timer_user_fasync(int fd, struct file * file, int on)
- {
- struct snd_timer_user *tu;
- tu = file->private_data;
- return fasync_helper(fd, file, on, &tu->fasync);
- }
- static ssize_t snd_timer_user_read(struct file *file, char __user *buffer,
- size_t count, loff_t *offset)
- {
- struct snd_timer_user *tu;
- long result = 0, unit;
- int err = 0;
- tu = file->private_data;
- unit = tu->tread ? sizeof(struct snd_timer_tread) : sizeof(struct snd_timer_read);
- spin_lock_irq(&tu->qlock);
- while ((long)count - result >= unit) {
- while (!tu->qused) {
- wait_queue_t wait;
- if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
- err = -EAGAIN;
- break;
- }
- set_current_state(TASK_INTERRUPTIBLE);
- init_waitqueue_entry(&wait, current);
- add_wait_queue(&tu->qchange_sleep, &wait);
- spin_unlock_irq(&tu->qlock);
- schedule();
- spin_lock_irq(&tu->qlock);
- remove_wait_queue(&tu->qchange_sleep, &wait);
- if (signal_pending(current)) {
- err = -ERESTARTSYS;
- break;
- }
- }
- spin_unlock_irq(&tu->qlock);
- if (err < 0)
- goto _error;
- if (tu->tread) {
- if (copy_to_user(buffer, &tu->tqueue[tu->qhead++],
- sizeof(struct snd_timer_tread))) {
- err = -EFAULT;
- goto _error;
- }
- } else {
- if (copy_to_user(buffer, &tu->queue[tu->qhead++],
- sizeof(struct snd_timer_read))) {
- err = -EFAULT;
- goto _error;
- }
- }
- tu->qhead %= tu->queue_size;
- result += unit;
- buffer += unit;
- spin_lock_irq(&tu->qlock);
- tu->qused--;
- }
- spin_unlock_irq(&tu->qlock);
- _error:
- return result > 0 ? result : err;
- }
- static unsigned int snd_timer_user_poll(struct file *file, poll_table * wait)
- {
- unsigned int mask;
- struct snd_timer_user *tu;
- tu = file->private_data;
- poll_wait(file, &tu->qchange_sleep, wait);
- mask = 0;
- if (tu->qused)
- mask |= POLLIN | POLLRDNORM;
- return mask;
- }
- #ifdef CONFIG_COMPAT
- #include "timer_compat.c"
- #else
- #define snd_timer_user_ioctl_compat NULL
- #endif
- static const struct file_operations snd_timer_f_ops =
- {
- .owner = THIS_MODULE,
- .read = snd_timer_user_read,
- .open = snd_timer_user_open,
- .release = snd_timer_user_release,
- .llseek = no_llseek,
- .poll = snd_timer_user_poll,
- .unlocked_ioctl = snd_timer_user_ioctl,
- .compat_ioctl = snd_timer_user_ioctl_compat,
- .fasync = snd_timer_user_fasync,
- };
- static void snd_timer_free_all(void)
- {
- struct snd_timer *timer, *n;
- list_for_each_entry_safe(timer, n, &snd_timer_list, device_list)
- snd_timer_free(timer);
- }
- static struct device timer_dev;
- static int __init alsa_timer_init(void)
- {
- int err;
- snd_device_initialize(&timer_dev, NULL);
- dev_set_name(&timer_dev, "timer");
- #ifdef SNDRV_OSS_INFO_DEV_TIMERS
- snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1,
- "system timer");
- #endif
- err = snd_timer_register_system();
- if (err < 0) {
- pr_err("ALSA: unable to register system timer (%i)\n", err);
- put_device(&timer_dev);
- return err;
- }
- err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0,
- &snd_timer_f_ops, NULL, &timer_dev);
- if (err < 0) {
- pr_err("ALSA: unable to register timer device (%i)\n", err);
- snd_timer_free_all();
- put_device(&timer_dev);
- return err;
- }
- snd_timer_proc_init();
- return 0;
- }
- static void __exit alsa_timer_exit(void)
- {
- snd_unregister_device(&timer_dev);
- snd_timer_free_all();
- put_device(&timer_dev);
- snd_timer_proc_done();
- #ifdef SNDRV_OSS_INFO_DEV_TIMERS
- snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1);
- #endif
- }
- module_init(alsa_timer_init)
- module_exit(alsa_timer_exit)
- EXPORT_SYMBOL(snd_timer_open);
- EXPORT_SYMBOL(snd_timer_close);
- EXPORT_SYMBOL(snd_timer_resolution);
- EXPORT_SYMBOL(snd_timer_start);
- EXPORT_SYMBOL(snd_timer_stop);
- EXPORT_SYMBOL(snd_timer_continue);
- EXPORT_SYMBOL(snd_timer_pause);
- EXPORT_SYMBOL(snd_timer_new);
- EXPORT_SYMBOL(snd_timer_notify);
- EXPORT_SYMBOL(snd_timer_global_new);
- EXPORT_SYMBOL(snd_timer_global_free);
- EXPORT_SYMBOL(snd_timer_global_register);
- EXPORT_SYMBOL(snd_timer_interrupt);
|