From 6dd866cd2308aa3c0453ce71d52222b9bd7c7671 Mon Sep 17 00:00:00 2001 From: Shaun Ruffell Date: Mon, 3 Jan 2011 18:25:05 +0000 Subject: dahdi_dynamic: Trivial removal of 'zaptel' references. Replaces all the 'z' references to 'd' as appropriate and cleans up any formatting problems that popped up as a result. The intent here is to reduce confusion in the future as someone may wonder what the 'Z's refer to. Signed-off-by: Shaun Ruffell Acked-by: Kinsey Moore git-svn-id: http://svn.asterisk.org/svn/dahdi/linux/trunk@9567 a0bf4364-ded3-4de4-8d8a-66a801d63aff --- drivers/dahdi/dahdi_dynamic.c | 402 +++++++++++++++++++++--------------------- 1 file changed, 204 insertions(+), 198 deletions(-) (limited to 'drivers/dahdi/dahdi_dynamic.c') diff --git a/drivers/dahdi/dahdi_dynamic.c b/drivers/dahdi/dahdi_dynamic.c index 1a1d84b..14b3a73 100644 --- a/drivers/dahdi/dahdi_dynamic.c +++ b/drivers/dahdi/dahdi_dynamic.c @@ -67,9 +67,9 @@ /* Arbitrary limit to the max # of channels in a span */ #define DAHDI_DYNAMIC_MAX_CHANS 256 -#define ZTD_FLAG_YELLOW_ALARM (1 << 0) -#define ZTD_FLAG_SIGBITS_PRESENT (1 << 1) -#define ZTD_FLAG_LOOPBACK (1 << 2) +#define DAHDI_DYNAMIC_FLAG_YELLOW_ALARM (1 << 0) +#define DAHDI_DYNAMIC_FLAG_SIGBITS_PRESENT (1 << 1) +#define DAHDI_DYNAMIC_FLAG_LOOPBACK (1 << 2) #define ERR_NSAMP (1 << 16) #define ERR_NCHAN (1 << 17) @@ -79,8 +79,8 @@ EXPORT_SYMBOL(dahdi_dynamic_register); EXPORT_SYMBOL(dahdi_dynamic_unregister); EXPORT_SYMBOL(dahdi_dynamic_receive); -static int ztdynamic_init(void); -static void ztdynamic_cleanup(void); +static int dahdi_dynamic_init(void); +static void dahdi_dynamic_cleanup(void); #ifdef ENABLE_TASKLETS static int taskletrun; @@ -88,9 +88,9 @@ static int taskletsched; static int taskletpending; static int taskletexec; static int txerrors; -static struct tasklet_struct ztd_tlet; +static struct tasklet_struct dahdi_dynamic_tlet; -static void ztd_tasklet(unsigned long data); +static void dahdi_dynamic_tasklet(unsigned long data); #endif struct dahdi_dynamic { @@ -127,19 +127,19 @@ static void checkmaster(void) { int newhasmaster=0; int best = 9999999; - struct dahdi_dynamic *z, *master=NULL; + struct dahdi_dynamic *d, *master = NULL; rcu_read_lock(); - list_for_each_entry_rcu(z, &dspan_list, list) { - if (z->timing) { - z->master = 0; - if (!(z->span.alarms & DAHDI_ALARM_RED) && - (z->timing < best) && !z->dead) { + list_for_each_entry_rcu(d, &dspan_list, list) { + if (d->timing) { + d->master = 0; + if (!(d->span.alarms & DAHDI_ALARM_RED) && + (d->timing < best) && !d->dead) { /* If not in alarm and they're a better timing source, use them */ - master = z; - best = z->timing; + master = d; + best = d->timing; newhasmaster = 1; } } @@ -158,9 +158,9 @@ static void checkmaster(void) printk(KERN_INFO "TDMoX: No master.\n"); } -static void ztd_sendmessage(struct dahdi_dynamic *z) +static void dahdi_dynamic_sendmessage(struct dahdi_dynamic *d) { - unsigned char *buf = z->msgbuf; + unsigned char *buf = d->msgbuf; unsigned short bits; int msglen = 0; int x; @@ -172,26 +172,26 @@ static void ztd_sendmessage(struct dahdi_dynamic *z) /* Byte 1: Flags */ *buf = 0; - if (z->span.alarms & DAHDI_ALARM_RED) - *buf |= ZTD_FLAG_YELLOW_ALARM; - *buf |= ZTD_FLAG_SIGBITS_PRESENT; + if (d->span.alarms & DAHDI_ALARM_RED) + *buf |= DAHDI_DYNAMIC_FLAG_YELLOW_ALARM; + *buf |= DAHDI_DYNAMIC_FLAG_SIGBITS_PRESENT; buf++; msglen++; /* Bytes 2-3: Transmit counter */ - *((unsigned short *)buf) = htons((unsigned short)z->txcnt); - z->txcnt++; + *((unsigned short *)buf) = htons((unsigned short)d->txcnt); + d->txcnt++; buf++; msglen++; buf++; msglen++; /* Bytes 4-5: Number of channels */ - *((unsigned short *)buf) = htons((unsigned short)z->span.channels); + *((unsigned short *)buf) = htons((unsigned short)d->span.channels); buf++; msglen++; buf++; msglen++; bits = 0; offset = 0; - for (x=0;xspan.channels;x++) { + for (x = 0; x < d->span.channels; x++) { offset = x % 4; - bits |= (z->chans[x]->txsig & 0xf) << (offset << 2); + bits |= (d->chans[x]->txsig & 0xf) << (offset << 2); if (offset == 3) { /* Write the bits when we have four channels */ *((unsigned short *)buf) = htons(bits); @@ -208,33 +208,34 @@ static void ztd_sendmessage(struct dahdi_dynamic *z) buf++; msglen++; } - for (x=0;xspan.channels;x++) { - memcpy(buf, z->chans[x]->writechunk, DAHDI_CHUNKSIZE); + for (x = 0; x < d->span.channels; x++) { + memcpy(buf, d->chans[x]->writechunk, DAHDI_CHUNKSIZE); buf += DAHDI_CHUNKSIZE; msglen += DAHDI_CHUNKSIZE; } - z->driver->transmit(z->pvt, z->msgbuf, msglen); + d->driver->transmit(d->pvt, d->msgbuf, msglen); } -static void __ztdynamic_run(void) +static void __dahdi_dynamic_run(void) { - struct dahdi_dynamic *z; + struct dahdi_dynamic *d; struct dahdi_dynamic_driver *drv; int y; rcu_read_lock(); - list_for_each_entry_rcu(z, &dspan_list, list) { - if (!z->dead) { - for (y=0;yspan.channels;y++) { + list_for_each_entry_rcu(d, &dspan_list, list) { + if (!d->dead) { + for (y = 0; y < d->span.channels; y++) { + struct dahdi_chan *const c = d->span.chans[y]; /* Echo cancel double buffered data */ - dahdi_ec_chunk(z->span.chans[y], z->span.chans[y]->readchunk, z->span.chans[y]->writechunk); + dahdi_ec_chunk(c, c->readchunk, c->writechunk); } - dahdi_receive(&z->span); - dahdi_transmit(&z->span); + dahdi_receive(&d->span); + dahdi_transmit(&d->span); /* Handle all transmissions now */ - ztd_sendmessage(z); + dahdi_dynamic_sendmessage(d); } } @@ -248,18 +249,18 @@ static void __ztdynamic_run(void) } #ifdef ENABLE_TASKLETS -static void ztdynamic_run(void) +static void dahdi_dynamic_run(void) { if (likely(!taskletpending)) { taskletpending = 1; taskletsched++; - tasklet_hi_schedule(&ztd_tlet); + tasklet_hi_schedule(&dahdi_dynamic_tlet); } else { txerrors++; } } #else -#define ztdynamic_run __ztdynamic_run +#define dahdi_dynamic_run __dahdi_dynamic_run #endif static inline struct dahdi_dynamic *dynamic_from_span(struct dahdi_span *span) @@ -269,7 +270,7 @@ static inline struct dahdi_dynamic *dynamic_from_span(struct dahdi_span *span) void dahdi_dynamic_receive(struct dahdi_span *span, unsigned char *msg, int msglen) { - struct dahdi_dynamic *ztd = dynamic_from_span(span); + struct dahdi_dynamic *dtd = dynamic_from_span(span); int newerr=0; int sflags; int xlen; @@ -283,10 +284,9 @@ void dahdi_dynamic_receive(struct dahdi_span *span, unsigned char *msg, int msgl if (unlikely(msglen < 6)) { rcu_read_unlock(); newerr = ERR_LEN; - if (newerr != ztd->err) { + if (newerr != dtd->err) printk(KERN_NOTICE "Span %s: Insufficient samples for header (only %d)\n", span->name, msglen); - } - ztd->err = newerr; + dtd->err = newerr; return; } @@ -294,10 +294,9 @@ void dahdi_dynamic_receive(struct dahdi_span *span, unsigned char *msg, int msgl if (unlikely(*msg != DAHDI_CHUNKSIZE)) { rcu_read_unlock(); newerr = ERR_NSAMP | msg[0]; - if (newerr != ztd->err) { + if (newerr != dtd->err) printk(KERN_NOTICE "Span %s: Expected %d samples, but receiving %d\n", span->name, DAHDI_CHUNKSIZE, msg[0]); - } - ztd->err = newerr; + dtd->err = newerr; return; } msg++; @@ -312,10 +311,9 @@ void dahdi_dynamic_receive(struct dahdi_span *span, unsigned char *msg, int msgl if (unlikely(nchans != span->channels)) { rcu_read_unlock(); newerr = ERR_NCHAN | nchans; - if (newerr != ztd->err) { + if (newerr != dtd->err) printk(KERN_NOTICE "Span %s: Expected %d channels, but receiving %d\n", span->name, span->channels, nchans); - } - ztd->err = newerr; + dtd->err = newerr; return; } msg++; @@ -329,7 +327,7 @@ void dahdi_dynamic_receive(struct dahdi_span *span, unsigned char *msg, int msgl /* Add samples of audio */ xlen += nchans * DAHDI_CHUNKSIZE; /* If RBS info is there, add that */ - if (sflags & ZTD_FLAG_SIGBITS_PRESENT) { + if (sflags & DAHDI_DYNAMIC_FLAG_SIGBITS_PRESENT) { /* Account for sigbits -- one short per 4 channels*/ xlen += ((nchans + 3) / 4) * 2; } @@ -337,17 +335,16 @@ void dahdi_dynamic_receive(struct dahdi_span *span, unsigned char *msg, int msgl if (unlikely(xlen != msglen)) { rcu_read_unlock(); newerr = ERR_LEN | xlen; - if (newerr != ztd->err) { + if (newerr != dtd->err) printk(KERN_NOTICE "Span %s: Expected message size %d, but was %d instead\n", span->name, xlen, msglen); - } - ztd->err = newerr; + dtd->err = newerr; return; } bits = 0; /* Record sigbits if present */ - if (sflags & ZTD_FLAG_SIGBITS_PRESENT) { + if (sflags & DAHDI_DYNAMIC_FLAG_SIGBITS_PRESENT) { for (x=0;xmaster; + master = dtd->master; - rxcnt = ztd->rxcnt; - ztd->rxcnt = rxpos+1; + rxcnt = dtd->rxcnt; + dtd->rxcnt = rxpos+1; /* Keep track of last received packet */ - ztd->rxjif = jiffies; + dtd->rxjif = jiffies; rcu_read_unlock(); /* Check for Yellow alarm */ newalarm = span->alarms & ~(DAHDI_ALARM_YELLOW | DAHDI_ALARM_RED); - if (sflags & ZTD_FLAG_YELLOW_ALARM) + if (sflags & DAHDI_DYNAMIC_FLAG_YELLOW_ALARM) newalarm |= DAHDI_ALARM_YELLOW; if (newalarm != span->alarms) { @@ -399,45 +396,43 @@ void dahdi_dynamic_receive(struct dahdi_span *span, unsigned char *msg, int msgl /* If this is our master span, then run everything */ if (master) - ztdynamic_run(); + dahdi_dynamic_run(); } -static void dynamic_destroy(struct dahdi_dynamic *z) +static void dynamic_destroy(struct dahdi_dynamic *d) { unsigned int x; /* Unregister span if appropriate */ - if (test_bit(DAHDI_FLAGBIT_REGISTERED, &z->span.flags)) - dahdi_unregister(&z->span); + if (test_bit(DAHDI_FLAGBIT_REGISTERED, &d->span.flags)) + dahdi_unregister(&d->span); /* Destroy the pvt stuff if there */ - if (z->pvt) - z->driver->destroy(z->pvt); + if (d->pvt) + d->driver->destroy(d->pvt); /* Free message buffer if appropriate */ - if (z->msgbuf) - kfree(z->msgbuf); + kfree(d->msgbuf); /* Free channels */ - for (x = 0; x < z->span.channels; x++) { - kfree(z->chans[x]); - } + for (x = 0; x < d->span.channels; x++) + kfree(d->chans[x]); - /* Free z */ - kfree(z); + /* Free d */ + kfree(d); checkmaster(); } -static struct dahdi_dynamic *find_dynamic(struct dahdi_dynamic_span *zds) +static struct dahdi_dynamic *find_dynamic(struct dahdi_dynamic_span *dds) { - struct dahdi_dynamic *z = NULL, *found = NULL; + struct dahdi_dynamic *d = NULL, *found = NULL; rcu_read_lock(); - list_for_each_entry_rcu(z, &dspan_list, list) { - if (!strcmp(z->dname, zds->driver) && - !strcmp(z->addr, zds->addr)) { - found = z; + list_for_each_entry_rcu(d, &dspan_list, list) { + if (!strcmp(d->dname, dds->driver) && + !strcmp(d->addr, dds->addr)) { + found = d; break; } } @@ -448,13 +443,13 @@ static struct dahdi_dynamic *find_dynamic(struct dahdi_dynamic_span *zds) static struct dahdi_dynamic_driver *find_driver(char *name) { - struct dahdi_dynamic_driver *ztd, *found = NULL; + struct dahdi_dynamic_driver *dtd, *found = NULL; rcu_read_lock(); - list_for_each_entry_rcu(ztd, &driver_list, list) { + list_for_each_entry_rcu(dtd, &driver_list, list) { /* here's our driver */ - if (!strcmp(name, ztd->name)) { - found = ztd; + if (!strcmp(name, dtd->name)) { + found = dtd; break; } } @@ -463,214 +458,223 @@ static struct dahdi_dynamic_driver *find_driver(char *name) return found; } -static int destroy_dynamic(struct dahdi_dynamic_span *zds) +static int destroy_dynamic(struct dahdi_dynamic_span *dds) { unsigned long flags; - struct dahdi_dynamic *z; + struct dahdi_dynamic *d; - z = find_dynamic(zds); - if (unlikely(!z)) { + d = find_dynamic(dds); + if (unlikely(!d)) return -EINVAL; - } - if (z->usecount) { + if (d->usecount) { printk(KERN_NOTICE "Attempt to destroy dynamic span while it is in use\n"); return -EBUSY; } spin_lock_irqsave(&dspan_lock, flags); - list_del_rcu(&z->list); + list_del_rcu(&d->list); spin_unlock_irqrestore(&dspan_lock, flags); synchronize_rcu(); /* Destroy it */ - dynamic_destroy(z); + dynamic_destroy(d); return 0; } -static int ztd_rbsbits(struct dahdi_chan *chan, int bits) +static int dahdi_dynamic_rbsbits(struct dahdi_chan *chan, int bits) { /* Don't have to do anything */ return 0; } -static int ztd_open(struct dahdi_chan *chan) +static int dahdi_dynamic_open(struct dahdi_chan *chan) { - struct dahdi_dynamic *z = dynamic_from_span(chan->span); - if (likely(z)) { - if (unlikely(z->dead)) + struct dahdi_dynamic *d = dynamic_from_span(chan->span); + if (likely(d)) { + if (unlikely(d->dead)) return -ENODEV; - z->usecount++; + d->usecount++; } return 0; } -static int ztd_chanconfig(struct dahdi_chan *chan, int sigtype) +static int dahdi_dynamic_chanconfig(struct dahdi_chan *chan, int sigtype) { return 0; } -static int ztd_close(struct dahdi_chan *chan) +static int dahdi_dynamic_close(struct dahdi_chan *chan) { - struct dahdi_dynamic *z = dynamic_from_span(chan->span); - if (z) { - z->usecount--; - if (z->dead && !z->usecount) - dynamic_destroy(z); + struct dahdi_dynamic *d = dynamic_from_span(chan->span); + if (d) { + d->usecount--; + if (d->dead && !d->usecount) + dynamic_destroy(d); } return 0; } static const struct dahdi_span_ops dynamic_ops = { .owner = THIS_MODULE, - .rbsbits = ztd_rbsbits, - .open = ztd_open, - .close = ztd_close, - .chanconfig = ztd_chanconfig, + .rbsbits = dahdi_dynamic_rbsbits, + .open = dahdi_dynamic_open, + .close = dahdi_dynamic_close, + .chanconfig = dahdi_dynamic_chanconfig, }; -static int create_dynamic(struct dahdi_dynamic_span *zds) +static int create_dynamic(struct dahdi_dynamic_span *dds) { - struct dahdi_dynamic *z; - struct dahdi_dynamic_driver *ztd; + struct dahdi_dynamic *d; + struct dahdi_dynamic_driver *dtd; unsigned long flags; int x; int bufsize; - if (zds->numchans < 1) { - printk(KERN_NOTICE "Can't be less than 1 channel (%d)!\n", zds->numchans); + if (dds->numchans < 1) { + printk(KERN_NOTICE "Can't be less than 1 channel (%d)!\n", + dds->numchans); return -EINVAL; } - if (zds->numchans >= DAHDI_DYNAMIC_MAX_CHANS) { - printk(KERN_NOTICE "Can't create dynamic span with greater than %d channels. See ztdynamic.c and increase DAHDI_DYNAMIC_MAX_CHANS\n", zds->numchans); + if (dds->numchans >= DAHDI_DYNAMIC_MAX_CHANS) { + printk(KERN_NOTICE "Can't create dynamic span with greater " + "than %d channels. See dahdi_dynamic.c and increase " + "DAHDI_DYNAMIC_MAX_CHANS\n", dds->numchans); return -EINVAL; } - z = find_dynamic(zds); - if (z) + d = find_dynamic(dds); + if (d) return -EEXIST; /* Allocate memory */ - z = (struct dahdi_dynamic *) kmalloc(sizeof(struct dahdi_dynamic), GFP_KERNEL); - if (!z) { + d = kmalloc(sizeof(*d), GFP_KERNEL); + if (!d) return -ENOMEM; - } /* Zero it out */ - memset(z, 0, sizeof(*z)); + memset(d, 0, sizeof(*d)); - for (x = 0; x < zds->numchans; x++) { - if (!(z->chans[x] = kmalloc(sizeof(*z->chans[x]), GFP_KERNEL))) { - dynamic_destroy(z); + for (x = 0; x < dds->numchans; x++) { + d->chans[x] = kmalloc(sizeof(*d->chans[x]), GFP_KERNEL); + if (!d->chans[x]) { + dynamic_destroy(d); return -ENOMEM; } - memset(z->chans[x], 0, sizeof(*z->chans[x])); + memset(d->chans[x], 0, sizeof(*d->chans[x])); } /* Allocate message buffer with sample space and header space */ - bufsize = zds->numchans * DAHDI_CHUNKSIZE + zds->numchans / 4 + 48; + bufsize = dds->numchans * DAHDI_CHUNKSIZE + dds->numchans / 4 + 48; - z->msgbuf = kmalloc(bufsize, GFP_KERNEL); + d->msgbuf = kmalloc(bufsize, GFP_KERNEL); - if (!z->msgbuf) { - dynamic_destroy(z); + if (!d->msgbuf) { + dynamic_destroy(d); return -ENOMEM; } /* Zero out -- probably not needed but why not */ - memset(z->msgbuf, 0, bufsize); + memset(d->msgbuf, 0, bufsize); /* Setup parameters properly assuming we're going to be okay. */ - dahdi_copy_string(z->dname, zds->driver, sizeof(z->dname)); - dahdi_copy_string(z->addr, zds->addr, sizeof(z->addr)); - z->timing = zds->timing; - sprintf(z->span.name, "DYN/%s/%s", zds->driver, zds->addr); - sprintf(z->span.desc, "Dynamic '%s' span at '%s'", zds->driver, zds->addr); - z->span.channels = zds->numchans; - z->span.deflaw = DAHDI_LAW_MULAW; - z->span.flags |= DAHDI_FLAG_RBS; - z->span.chans = z->chans; - z->span.ops = &dynamic_ops; - for (x=0; x < z->span.channels; x++) { - sprintf(z->chans[x]->name, "DYN/%s/%s/%d", zds->driver, zds->addr, x+1); - z->chans[x]->sigcap = DAHDI_SIG_EM | DAHDI_SIG_CLEAR | DAHDI_SIG_FXSLS | - DAHDI_SIG_FXSKS | DAHDI_SIG_FXSGS | DAHDI_SIG_FXOLS | - DAHDI_SIG_FXOKS | DAHDI_SIG_FXOGS | DAHDI_SIG_SF | - DAHDI_SIG_DACS_RBS | DAHDI_SIG_CAS; - z->chans[x]->chanpos = x + 1; - z->chans[x]->pvt = z; + dahdi_copy_string(d->dname, dds->driver, sizeof(d->dname)); + dahdi_copy_string(d->addr, dds->addr, sizeof(d->addr)); + d->timing = dds->timing; + sprintf(d->span.name, "DYN/%s/%s", dds->driver, dds->addr); + sprintf(d->span.desc, "Dynamic '%s' span at '%s'", + dds->driver, dds->addr); + d->span.channels = dds->numchans; + d->span.deflaw = DAHDI_LAW_MULAW; + d->span.flags |= DAHDI_FLAG_RBS; + d->span.chans = d->chans; + d->span.ops = &dynamic_ops; + for (x = 0; x < d->span.channels; x++) { + sprintf(d->chans[x]->name, "DYN/%s/%s/%d", + dds->driver, dds->addr, x+1); + d->chans[x]->sigcap = DAHDI_SIG_EM | DAHDI_SIG_CLEAR | + DAHDI_SIG_FXSLS | DAHDI_SIG_FXSKS | + DAHDI_SIG_FXSGS | DAHDI_SIG_FXOLS | + DAHDI_SIG_FXOKS | DAHDI_SIG_FXOGS | + DAHDI_SIG_SF | DAHDI_SIG_DACS_RBS | + DAHDI_SIG_CAS; + d->chans[x]->chanpos = x + 1; + d->chans[x]->pvt = d; } - ztd = find_driver(zds->driver); - if (!ztd) { + dtd = find_driver(dds->driver); + if (!dtd) { #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,70) char fn[80]; #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,70) - request_module("dahdi_dynamic_%s", zds->driver); + request_module("dahdi_dynamic_%s", dds->driver); #else - sprintf(fn, "dahdi_dynamic_%s", zds->driver); + sprintf(fn, "dahdi_dynamic_%s", dds->driver); request_module(fn); #endif - ztd = find_driver(zds->driver); + dtd = find_driver(dds->driver); } /* Another race -- should let the module get unloaded while we have it here */ - if (!ztd) { - printk(KERN_NOTICE "No such driver '%s' for dynamic span\n", zds->driver); - dynamic_destroy(z); + if (!dtd) { + printk(KERN_NOTICE "No such driver '%s' for dynamic span\n", + dds->driver); + dynamic_destroy(d); return -EINVAL; } /* Create the stuff */ - z->pvt = ztd->create(&z->span, z->addr); - if (!z->pvt) { - printk(KERN_NOTICE "Driver '%s' (%s) rejected address '%s'\n", ztd->name, ztd->desc, z->addr); + d->pvt = dtd->create(&d->span, d->addr); + if (!d->pvt) { + printk(KERN_NOTICE "Driver '%s' (%s) rejected address '%s'\n", + dtd->name, dtd->desc, d->addr); /* Creation failed */ return -EINVAL; } /* Remember the driver */ - z->driver = ztd; + d->driver = dtd; /* Whee! We're created. Now register the span */ - if (dahdi_register(&z->span, 0)) { - printk(KERN_NOTICE "Unable to register span '%s'\n", z->span.name); - dynamic_destroy(z); + if (dahdi_register(&d->span, 0)) { + printk(KERN_NOTICE "Unable to register span '%s'\n", + d->span.name); + dynamic_destroy(d); return -EINVAL; } spin_lock_irqsave(&dspan_lock, flags); - list_add_rcu(&z->list, &dspan_list); + list_add_rcu(&d->list, &dspan_list); spin_unlock_irqrestore(&dspan_lock, flags); checkmaster(); /* All done */ - return z->span.spanno; + return d->span.spanno; } #ifdef ENABLE_TASKLETS -static void ztd_tasklet(unsigned long data) +static void dahdi_dynamic_tasklet(unsigned long data) { taskletrun++; if (taskletpending) { taskletexec++; - __ztdynamic_run(); + __dahdi_dynamic_run(); } taskletpending = 0; } #endif -static int ztdynamic_ioctl(unsigned int cmd, unsigned long data) +static int dahdi_dynamic_ioctl(unsigned int cmd, unsigned long data) { - struct dahdi_dynamic_span zds; + struct dahdi_dynamic_span dds; int res; switch(cmd) { case 0: @@ -678,27 +682,29 @@ static int ztdynamic_ioctl(unsigned int cmd, unsigned long data) spans are pulling timing, then now is the time to process them */ if (!hasmaster) - ztdynamic_run(); + dahdi_dynamic_run(); return 0; case DAHDI_DYNAMIC_CREATE: - if (copy_from_user(&zds, (__user const void *) data, sizeof(zds))) + if (copy_from_user(&dds, (__user const void *)data, + sizeof(dds))) return -EFAULT; if (debug) printk(KERN_DEBUG "Dynamic Create\n"); - res = create_dynamic(&zds); + res = create_dynamic(&dds); if (res < 0) return res; - zds.spanno = res; + dds.spanno = res; /* Let them know the new span number */ - if (copy_to_user((__user void *) data, &zds, sizeof(zds))) + if (copy_to_user((__user void *) data, &dds, sizeof(dds))) return -EFAULT; return 0; case DAHDI_DYNAMIC_DESTROY: - if (copy_from_user(&zds, (__user const void *) data, sizeof(zds))) + if (copy_from_user(&dds, (__user const void *)data, + sizeof(dds))) return -EFAULT; if (debug) printk(KERN_DEBUG "Dynamic Destroy\n"); - return destroy_dynamic(&zds); + return destroy_dynamic(&dds); } return -ENOTTY; @@ -721,7 +727,7 @@ int dahdi_dynamic_register(struct dahdi_dynamic_driver *dri) void dahdi_dynamic_unregister(struct dahdi_dynamic_driver *dri) { - struct dahdi_dynamic *z; + struct dahdi_dynamic *d; unsigned long flags; spin_lock_irqsave(&driver_lock, flags); @@ -729,17 +735,17 @@ void dahdi_dynamic_unregister(struct dahdi_dynamic_driver *dri) spin_unlock_irqrestore(&driver_lock, flags); synchronize_rcu(); - list_for_each_entry(z, &dspan_list, list) { - if (z->driver == dri) { + list_for_each_entry(d, &dspan_list, list) { + if (d->driver == dri) { spin_lock_irqsave(&dspan_lock, flags); - list_del_rcu(&z->list); + list_del_rcu(&d->list); spin_unlock_irqrestore(&dspan_lock, flags); synchronize_rcu(); - if (!z->usecount) - dynamic_destroy(z); + if (!d->usecount) + dynamic_destroy(d); else - z->dead = 1; + d->dead = 1; } } } @@ -750,17 +756,17 @@ static void check_for_red_alarm(unsigned long ignored) { int newalarm; int alarmchanged = 0; - struct dahdi_dynamic *z; + struct dahdi_dynamic *d; rcu_read_lock(); - list_for_each_entry_rcu(z, &dspan_list, list) { - newalarm = z->span.alarms & ~DAHDI_ALARM_RED; + list_for_each_entry_rcu(d, &dspan_list, list) { + newalarm = d->span.alarms & ~DAHDI_ALARM_RED; /* If nothing received for a second, consider that RED ALARM */ - if ((jiffies - z->rxjif) > 1 * HZ) { + if ((jiffies - d->rxjif) > 1 * HZ) { newalarm |= DAHDI_ALARM_RED; - if (z->span.alarms != newalarm) { - z->span.alarms = newalarm; - dahdi_alarm_notify(&z->span); + if (d->span.alarms != newalarm) { + d->span.alarms = newalarm; + dahdi_alarm_notify(&d->span); alarmchanged++; } } @@ -774,9 +780,9 @@ static void check_for_red_alarm(unsigned long ignored) mod_timer(&alarmcheck, jiffies + 1 * HZ); } -static int ztdynamic_init(void) +static int dahdi_dynamic_init(void) { - dahdi_set_dynamic_ioctl(ztdynamic_ioctl); + dahdi_set_dynamic_ioctl(dahdi_dynamic_ioctl); /* Start process to check for RED ALARM */ init_timer(&alarmcheck); @@ -786,18 +792,18 @@ static int ztdynamic_init(void) /* Check once per second */ mod_timer(&alarmcheck, jiffies + 1 * HZ); #ifdef ENABLE_TASKLETS - tasklet_init(&ztd_tlet, ztd_tasklet, 0); + tasklet_init(&dahdi_dynamic_tlet, dahdi_dynamic_tasklet, 0); #endif printk(KERN_INFO "DAHDI Dynamic Span support LOADED\n"); return 0; } -static void ztdynamic_cleanup(void) +static void dahdi_dynamic_cleanup(void) { #ifdef ENABLE_TASKLETS if (taskletpending) { - tasklet_disable(&ztd_tlet); - tasklet_kill(&ztd_tlet); + tasklet_disable(&dahdi_dynamic_tlet); + tasklet_kill(&dahdi_dynamic_tlet); } #endif dahdi_set_dynamic_ioctl(NULL); @@ -811,5 +817,5 @@ MODULE_DESCRIPTION("DAHDI Dynamic Span Support"); MODULE_AUTHOR("Mark Spencer "); MODULE_LICENSE("GPL v2"); -module_init(ztdynamic_init); -module_exit(ztdynamic_cleanup); +module_init(dahdi_dynamic_init); +module_exit(dahdi_dynamic_cleanup); -- cgit v1.2.3