Root/kernel/params.c

1/* Helpers for initial module or kernel cmdline parsing
2   Copyright (C) 2001 Rusty Russell.
3
4    This program is free software; you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation; either version 2 of the License, or
7    (at your option) any later version.
8
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program; if not, write to the Free Software
16    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17*/
18#include <linux/moduleparam.h>
19#include <linux/kernel.h>
20#include <linux/string.h>
21#include <linux/errno.h>
22#include <linux/module.h>
23#include <linux/device.h>
24#include <linux/err.h>
25#include <linux/slab.h>
26#include <linux/ctype.h>
27
28#if 0
29#define DEBUGP printk
30#else
31#define DEBUGP(fmt, a...)
32#endif
33
34static inline char dash2underscore(char c)
35{
36    if (c == '-')
37        return '_';
38    return c;
39}
40
41static inline int parameq(const char *input, const char *paramname)
42{
43    unsigned int i;
44    for (i = 0; dash2underscore(input[i]) == paramname[i]; i++)
45        if (input[i] == '\0')
46            return 1;
47    return 0;
48}
49
50static int parse_one(char *param,
51             char *val,
52             struct kernel_param *params,
53             unsigned num_params,
54             int (*handle_unknown)(char *param, char *val))
55{
56    unsigned int i;
57
58    /* Find parameter */
59    for (i = 0; i < num_params; i++) {
60        if (parameq(param, params[i].name)) {
61            DEBUGP("They are equal! Calling %p\n",
62                   params[i].set);
63            return params[i].set(val, &params[i]);
64        }
65    }
66
67    if (handle_unknown) {
68        DEBUGP("Unknown argument: calling %p\n", handle_unknown);
69        return handle_unknown(param, val);
70    }
71
72    DEBUGP("Unknown argument `%s'\n", param);
73    return -ENOENT;
74}
75
76/* You can use " around spaces, but can't escape ". */
77/* Hyphens and underscores equivalent in parameter names. */
78static char *next_arg(char *args, char **param, char **val)
79{
80    unsigned int i, equals = 0;
81    int in_quote = 0, quoted = 0;
82    char *next;
83
84    if (*args == '"') {
85        args++;
86        in_quote = 1;
87        quoted = 1;
88    }
89
90    for (i = 0; args[i]; i++) {
91        if (isspace(args[i]) && !in_quote)
92            break;
93        if (equals == 0) {
94            if (args[i] == '=')
95                equals = i;
96        }
97        if (args[i] == '"')
98            in_quote = !in_quote;
99    }
100
101    *param = args;
102    if (!equals)
103        *val = NULL;
104    else {
105        args[equals] = '\0';
106        *val = args + equals + 1;
107
108        /* Don't include quotes in value. */
109        if (**val == '"') {
110            (*val)++;
111            if (args[i-1] == '"')
112                args[i-1] = '\0';
113        }
114        if (quoted && args[i-1] == '"')
115            args[i-1] = '\0';
116    }
117
118    if (args[i]) {
119        args[i] = '\0';
120        next = args + i + 1;
121    } else
122        next = args + i;
123
124    /* Chew up trailing spaces. */
125    return skip_spaces(next);
126}
127
128/* Args looks like "foo=bar,bar2 baz=fuz wiz". */
129int parse_args(const char *name,
130           char *args,
131           struct kernel_param *params,
132           unsigned num,
133           int (*unknown)(char *param, char *val))
134{
135    char *param, *val;
136
137    DEBUGP("Parsing ARGS: %s\n", args);
138
139    /* Chew leading spaces */
140    args = skip_spaces(args);
141
142    while (*args) {
143        int ret;
144        int irq_was_disabled;
145
146        args = next_arg(args, &param, &val);
147        irq_was_disabled = irqs_disabled();
148        ret = parse_one(param, val, params, num, unknown);
149        if (irq_was_disabled && !irqs_disabled()) {
150            printk(KERN_WARNING "parse_args(): option '%s' enabled "
151                    "irq's!\n", param);
152        }
153        switch (ret) {
154        case -ENOENT:
155            printk(KERN_ERR "%s: Unknown parameter `%s'\n",
156                   name, param);
157            return ret;
158        case -ENOSPC:
159            printk(KERN_ERR
160                   "%s: `%s' too large for parameter `%s'\n",
161                   name, val ?: "", param);
162            return ret;
163        case 0:
164            break;
165        default:
166            printk(KERN_ERR
167                   "%s: `%s' invalid for parameter `%s'\n",
168                   name, val ?: "", param);
169            return ret;
170        }
171    }
172
173    /* All parsed OK. */
174    return 0;
175}
176
177/* Lazy bastard, eh? */
178#define STANDARD_PARAM_DEF(name, type, format, tmptype, strtolfn) \
179    int param_set_##name(const char *val, struct kernel_param *kp) \
180    { \
181        tmptype l; \
182        int ret; \
183                                    \
184        if (!val) return -EINVAL; \
185        ret = strtolfn(val, 0, &l); \
186        if (ret == -EINVAL || ((type)l != l)) \
187            return -EINVAL; \
188        *((type *)kp->arg) = l; \
189        return 0; \
190    } \
191    int param_get_##name(char *buffer, struct kernel_param *kp) \
192    { \
193        return sprintf(buffer, format, *((type *)kp->arg)); \
194    }
195
196STANDARD_PARAM_DEF(byte, unsigned char, "%c", unsigned long, strict_strtoul);
197STANDARD_PARAM_DEF(short, short, "%hi", long, strict_strtol);
198STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", unsigned long, strict_strtoul);
199STANDARD_PARAM_DEF(int, int, "%i", long, strict_strtol);
200STANDARD_PARAM_DEF(uint, unsigned int, "%u", unsigned long, strict_strtoul);
201STANDARD_PARAM_DEF(long, long, "%li", long, strict_strtol);
202STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", unsigned long, strict_strtoul);
203
204int param_set_charp(const char *val, struct kernel_param *kp)
205{
206    if (!val) {
207        printk(KERN_ERR "%s: string parameter expected\n",
208               kp->name);
209        return -EINVAL;
210    }
211
212    if (strlen(val) > 1024) {
213        printk(KERN_ERR "%s: string parameter too long\n",
214               kp->name);
215        return -ENOSPC;
216    }
217
218    /* This is a hack. We can't need to strdup in early boot, and we
219     * don't need to; this mangled commandline is preserved. */
220    if (slab_is_available()) {
221        *(char **)kp->arg = kstrdup(val, GFP_KERNEL);
222        if (!*(char **)kp->arg)
223            return -ENOMEM;
224    } else
225        *(const char **)kp->arg = val;
226
227    return 0;
228}
229
230int param_get_charp(char *buffer, struct kernel_param *kp)
231{
232    return sprintf(buffer, "%s", *((char **)kp->arg));
233}
234
235/* Actually could be a bool or an int, for historical reasons. */
236int param_set_bool(const char *val, struct kernel_param *kp)
237{
238    bool v;
239
240    /* No equals means "set"... */
241    if (!val) val = "1";
242
243    /* One of =[yYnN01] */
244    switch (val[0]) {
245    case 'y': case 'Y': case '1':
246        v = true;
247        break;
248    case 'n': case 'N': case '0':
249        v = false;
250        break;
251    default:
252        return -EINVAL;
253    }
254
255    if (kp->flags & KPARAM_ISBOOL)
256        *(bool *)kp->arg = v;
257    else
258        *(int *)kp->arg = v;
259    return 0;
260}
261
262int param_get_bool(char *buffer, struct kernel_param *kp)
263{
264    bool val;
265    if (kp->flags & KPARAM_ISBOOL)
266        val = *(bool *)kp->arg;
267    else
268        val = *(int *)kp->arg;
269
270    /* Y and N chosen as being relatively non-coder friendly */
271    return sprintf(buffer, "%c", val ? 'Y' : 'N');
272}
273
274/* This one must be bool. */
275int param_set_invbool(const char *val, struct kernel_param *kp)
276{
277    int ret;
278    bool boolval;
279    struct kernel_param dummy;
280
281    dummy.arg = &boolval;
282    dummy.flags = KPARAM_ISBOOL;
283    ret = param_set_bool(val, &dummy);
284    if (ret == 0)
285        *(bool *)kp->arg = !boolval;
286    return ret;
287}
288
289int param_get_invbool(char *buffer, struct kernel_param *kp)
290{
291    return sprintf(buffer, "%c", (*(bool *)kp->arg) ? 'N' : 'Y');
292}
293
294/* We break the rule and mangle the string. */
295static int param_array(const char *name,
296               const char *val,
297               unsigned int min, unsigned int max,
298               void *elem, int elemsize,
299               int (*set)(const char *, struct kernel_param *kp),
300               u16 flags,
301               unsigned int *num)
302{
303    int ret;
304    struct kernel_param kp;
305    char save;
306
307    /* Get the name right for errors. */
308    kp.name = name;
309    kp.arg = elem;
310    kp.flags = flags;
311
312    /* No equals sign? */
313    if (!val) {
314        printk(KERN_ERR "%s: expects arguments\n", name);
315        return -EINVAL;
316    }
317
318    *num = 0;
319    /* We expect a comma-separated list of values. */
320    do {
321        int len;
322
323        if (*num == max) {
324            printk(KERN_ERR "%s: can only take %i arguments\n",
325                   name, max);
326            return -EINVAL;
327        }
328        len = strcspn(val, ",");
329
330        /* nul-terminate and parse */
331        save = val[len];
332        ((char *)val)[len] = '\0';
333        ret = set(val, &kp);
334
335        if (ret != 0)
336            return ret;
337        kp.arg += elemsize;
338        val += len+1;
339        (*num)++;
340    } while (save == ',');
341
342    if (*num < min) {
343        printk(KERN_ERR "%s: needs at least %i arguments\n",
344               name, min);
345        return -EINVAL;
346    }
347    return 0;
348}
349
350int param_array_set(const char *val, struct kernel_param *kp)
351{
352    const struct kparam_array *arr = kp->arr;
353    unsigned int temp_num;
354
355    return param_array(kp->name, val, 1, arr->max, arr->elem,
356               arr->elemsize, arr->set, kp->flags,
357               arr->num ?: &temp_num);
358}
359
360int param_array_get(char *buffer, struct kernel_param *kp)
361{
362    int i, off, ret;
363    const struct kparam_array *arr = kp->arr;
364    struct kernel_param p;
365
366    p = *kp;
367    for (i = off = 0; i < (arr->num ? *arr->num : arr->max); i++) {
368        if (i)
369            buffer[off++] = ',';
370        p.arg = arr->elem + arr->elemsize * i;
371        ret = arr->get(buffer + off, &p);
372        if (ret < 0)
373            return ret;
374        off += ret;
375    }
376    buffer[off] = '\0';
377    return off;
378}
379
380int param_set_copystring(const char *val, struct kernel_param *kp)
381{
382    const struct kparam_string *kps = kp->str;
383
384    if (!val) {
385        printk(KERN_ERR "%s: missing param set value\n", kp->name);
386        return -EINVAL;
387    }
388    if (strlen(val)+1 > kps->maxlen) {
389        printk(KERN_ERR "%s: string doesn't fit in %u chars.\n",
390               kp->name, kps->maxlen-1);
391        return -ENOSPC;
392    }
393    strcpy(kps->string, val);
394    return 0;
395}
396
397int param_get_string(char *buffer, struct kernel_param *kp)
398{
399    const struct kparam_string *kps = kp->str;
400    return strlcpy(buffer, kps->string, kps->maxlen);
401}
402
403/* sysfs output in /sys/modules/XYZ/parameters/ */
404#define to_module_attr(n) container_of(n, struct module_attribute, attr)
405#define to_module_kobject(n) container_of(n, struct module_kobject, kobj)
406
407extern struct kernel_param __start___param[], __stop___param[];
408
409struct param_attribute
410{
411    struct module_attribute mattr;
412    struct kernel_param *param;
413};
414
415struct module_param_attrs
416{
417    unsigned int num;
418    struct attribute_group grp;
419    struct param_attribute attrs[0];
420};
421
422#ifdef CONFIG_SYSFS
423#define to_param_attr(n) container_of(n, struct param_attribute, mattr)
424
425static ssize_t param_attr_show(struct module_attribute *mattr,
426                   struct module *mod, char *buf)
427{
428    int count;
429    struct param_attribute *attribute = to_param_attr(mattr);
430
431    if (!attribute->param->get)
432        return -EPERM;
433
434    count = attribute->param->get(buf, attribute->param);
435    if (count > 0) {
436        strcat(buf, "\n");
437        ++count;
438    }
439    return count;
440}
441
442/* sysfs always hands a nul-terminated string in buf. We rely on that. */
443static ssize_t param_attr_store(struct module_attribute *mattr,
444                struct module *owner,
445                const char *buf, size_t len)
446{
447     int err;
448    struct param_attribute *attribute = to_param_attr(mattr);
449
450    if (!attribute->param->set)
451        return -EPERM;
452
453    err = attribute->param->set(buf, attribute->param);
454    if (!err)
455        return len;
456    return err;
457}
458#endif
459
460#ifdef CONFIG_MODULES
461#define __modinit
462#else
463#define __modinit __init
464#endif
465
466#ifdef CONFIG_SYSFS
467/*
468 * add_sysfs_param - add a parameter to sysfs
469 * @mk: struct module_kobject
470 * @kparam: the actual parameter definition to add to sysfs
471 * @name: name of parameter
472 *
473 * Create a kobject if for a (per-module) parameter if mp NULL, and
474 * create file in sysfs. Returns an error on out of memory. Always cleans up
475 * if there's an error.
476 */
477static __modinit int add_sysfs_param(struct module_kobject *mk,
478                     struct kernel_param *kp,
479                     const char *name)
480{
481    struct module_param_attrs *new;
482    struct attribute **attrs;
483    int err, num;
484
485    /* We don't bother calling this with invisible parameters. */
486    BUG_ON(!kp->perm);
487
488    if (!mk->mp) {
489        num = 0;
490        attrs = NULL;
491    } else {
492        num = mk->mp->num;
493        attrs = mk->mp->grp.attrs;
494    }
495
496    /* Enlarge. */
497    new = krealloc(mk->mp,
498               sizeof(*mk->mp) + sizeof(mk->mp->attrs[0]) * (num+1),
499               GFP_KERNEL);
500    if (!new) {
501        kfree(mk->mp);
502        err = -ENOMEM;
503        goto fail;
504    }
505    attrs = krealloc(attrs, sizeof(new->grp.attrs[0])*(num+2), GFP_KERNEL);
506    if (!attrs) {
507        err = -ENOMEM;
508        goto fail_free_new;
509    }
510
511    /* Sysfs wants everything zeroed. */
512    memset(new, 0, sizeof(*new));
513    memset(&new->attrs[num], 0, sizeof(new->attrs[num]));
514    memset(&attrs[num], 0, sizeof(attrs[num]));
515    new->grp.name = "parameters";
516    new->grp.attrs = attrs;
517
518    /* Tack new one on the end. */
519    sysfs_attr_init(&new->attrs[num].mattr.attr);
520    new->attrs[num].param = kp;
521    new->attrs[num].mattr.show = param_attr_show;
522    new->attrs[num].mattr.store = param_attr_store;
523    new->attrs[num].mattr.attr.name = (char *)name;
524    new->attrs[num].mattr.attr.mode = kp->perm;
525    new->num = num+1;
526
527    /* Fix up all the pointers, since krealloc can move us */
528    for (num = 0; num < new->num; num++)
529        new->grp.attrs[num] = &new->attrs[num].mattr.attr;
530    new->grp.attrs[num] = NULL;
531
532    mk->mp = new;
533    return 0;
534
535fail_free_new:
536    kfree(new);
537fail:
538    mk->mp = NULL;
539    return err;
540}
541
542#ifdef CONFIG_MODULES
543static void free_module_param_attrs(struct module_kobject *mk)
544{
545    kfree(mk->mp->grp.attrs);
546    kfree(mk->mp);
547    mk->mp = NULL;
548}
549
550/*
551 * module_param_sysfs_setup - setup sysfs support for one module
552 * @mod: module
553 * @kparam: module parameters (array)
554 * @num_params: number of module parameters
555 *
556 * Adds sysfs entries for module parameters under
557 * /sys/module/[mod->name]/parameters/
558 */
559int module_param_sysfs_setup(struct module *mod,
560                 struct kernel_param *kparam,
561                 unsigned int num_params)
562{
563    int i, err;
564    bool params = false;
565
566    for (i = 0; i < num_params; i++) {
567        if (kparam[i].perm == 0)
568            continue;
569        err = add_sysfs_param(&mod->mkobj, &kparam[i], kparam[i].name);
570        if (err)
571            return err;
572        params = true;
573    }
574
575    if (!params)
576        return 0;
577
578    /* Create the param group. */
579    err = sysfs_create_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
580    if (err)
581        free_module_param_attrs(&mod->mkobj);
582    return err;
583}
584
585/*
586 * module_param_sysfs_remove - remove sysfs support for one module
587 * @mod: module
588 *
589 * Remove sysfs entries for module parameters and the corresponding
590 * kobject.
591 */
592void module_param_sysfs_remove(struct module *mod)
593{
594    if (mod->mkobj.mp) {
595        sysfs_remove_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
596        /* We are positive that no one is using any param
597         * attrs at this point. Deallocate immediately. */
598        free_module_param_attrs(&mod->mkobj);
599    }
600}
601#endif
602
603void destroy_params(const struct kernel_param *params, unsigned num)
604{
605    /* FIXME: This should free kmalloced charp parameters. It doesn't. */
606}
607
608static void __init kernel_add_sysfs_param(const char *name,
609                      struct kernel_param *kparam,
610                      unsigned int name_skip)
611{
612    struct module_kobject *mk;
613    struct kobject *kobj;
614    int err;
615
616    kobj = kset_find_obj(module_kset, name);
617    if (kobj) {
618        /* We already have one. Remove params so we can add more. */
619        mk = to_module_kobject(kobj);
620        /* We need to remove it before adding parameters. */
621        sysfs_remove_group(&mk->kobj, &mk->mp->grp);
622    } else {
623        mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
624        BUG_ON(!mk);
625
626        mk->mod = THIS_MODULE;
627        mk->kobj.kset = module_kset;
628        err = kobject_init_and_add(&mk->kobj, &module_ktype, NULL,
629                       "%s", name);
630        if (err) {
631            kobject_put(&mk->kobj);
632            printk(KERN_ERR "Module '%s' failed add to sysfs, "
633                   "error number %d\n", name, err);
634            printk(KERN_ERR "The system will be unstable now.\n");
635            return;
636        }
637        /* So that exit path is even. */
638        kobject_get(&mk->kobj);
639    }
640
641    /* These should not fail at boot. */
642    err = add_sysfs_param(mk, kparam, kparam->name + name_skip);
643    BUG_ON(err);
644    err = sysfs_create_group(&mk->kobj, &mk->mp->grp);
645    BUG_ON(err);
646    kobject_uevent(&mk->kobj, KOBJ_ADD);
647    kobject_put(&mk->kobj);
648}
649
650/*
651 * param_sysfs_builtin - add contents in /sys/parameters for built-in modules
652 *
653 * Add module_parameters to sysfs for "modules" built into the kernel.
654 *
655 * The "module" name (KBUILD_MODNAME) is stored before a dot, the
656 * "parameter" name is stored behind a dot in kernel_param->name. So,
657 * extract the "module" name for all built-in kernel_param-eters,
658 * and for all who have the same, call kernel_add_sysfs_param.
659 */
660static void __init param_sysfs_builtin(void)
661{
662    struct kernel_param *kp;
663    unsigned int name_len;
664    char modname[MODULE_NAME_LEN];
665
666    for (kp = __start___param; kp < __stop___param; kp++) {
667        char *dot;
668
669        if (kp->perm == 0)
670            continue;
671
672        dot = strchr(kp->name, '.');
673        if (!dot) {
674            /* This happens for core_param() */
675            strcpy(modname, "kernel");
676            name_len = 0;
677        } else {
678            name_len = dot - kp->name + 1;
679            strlcpy(modname, kp->name, name_len);
680        }
681        kernel_add_sysfs_param(modname, kp, name_len);
682    }
683}
684
685
686/* module-related sysfs stuff */
687
688static ssize_t module_attr_show(struct kobject *kobj,
689                struct attribute *attr,
690                char *buf)
691{
692    struct module_attribute *attribute;
693    struct module_kobject *mk;
694    int ret;
695
696    attribute = to_module_attr(attr);
697    mk = to_module_kobject(kobj);
698
699    if (!attribute->show)
700        return -EIO;
701
702    ret = attribute->show(attribute, mk->mod, buf);
703
704    return ret;
705}
706
707static ssize_t module_attr_store(struct kobject *kobj,
708                struct attribute *attr,
709                const char *buf, size_t len)
710{
711    struct module_attribute *attribute;
712    struct module_kobject *mk;
713    int ret;
714
715    attribute = to_module_attr(attr);
716    mk = to_module_kobject(kobj);
717
718    if (!attribute->store)
719        return -EIO;
720
721    ret = attribute->store(attribute, mk->mod, buf, len);
722
723    return ret;
724}
725
726static const struct sysfs_ops module_sysfs_ops = {
727    .show = module_attr_show,
728    .store = module_attr_store,
729};
730
731static int uevent_filter(struct kset *kset, struct kobject *kobj)
732{
733    struct kobj_type *ktype = get_ktype(kobj);
734
735    if (ktype == &module_ktype)
736        return 1;
737    return 0;
738}
739
740static const struct kset_uevent_ops module_uevent_ops = {
741    .filter = uevent_filter,
742};
743
744struct kset *module_kset;
745int module_sysfs_initialized;
746
747struct kobj_type module_ktype = {
748    .sysfs_ops = &module_sysfs_ops,
749};
750
751/*
752 * param_sysfs_init - wrapper for built-in params support
753 */
754static int __init param_sysfs_init(void)
755{
756    module_kset = kset_create_and_add("module", &module_uevent_ops, NULL);
757    if (!module_kset) {
758        printk(KERN_WARNING "%s (%d): error creating kset\n",
759            __FILE__, __LINE__);
760        return -ENOMEM;
761    }
762    module_sysfs_initialized = 1;
763
764    param_sysfs_builtin();
765
766    return 0;
767}
768subsys_initcall(param_sysfs_init);
769
770#endif /* CONFIG_SYSFS */
771
772EXPORT_SYMBOL(param_set_byte);
773EXPORT_SYMBOL(param_get_byte);
774EXPORT_SYMBOL(param_set_short);
775EXPORT_SYMBOL(param_get_short);
776EXPORT_SYMBOL(param_set_ushort);
777EXPORT_SYMBOL(param_get_ushort);
778EXPORT_SYMBOL(param_set_int);
779EXPORT_SYMBOL(param_get_int);
780EXPORT_SYMBOL(param_set_uint);
781EXPORT_SYMBOL(param_get_uint);
782EXPORT_SYMBOL(param_set_long);
783EXPORT_SYMBOL(param_get_long);
784EXPORT_SYMBOL(param_set_ulong);
785EXPORT_SYMBOL(param_get_ulong);
786EXPORT_SYMBOL(param_set_charp);
787EXPORT_SYMBOL(param_get_charp);
788EXPORT_SYMBOL(param_set_bool);
789EXPORT_SYMBOL(param_get_bool);
790EXPORT_SYMBOL(param_set_invbool);
791EXPORT_SYMBOL(param_get_invbool);
792EXPORT_SYMBOL(param_array_set);
793EXPORT_SYMBOL(param_array_get);
794EXPORT_SYMBOL(param_set_copystring);
795EXPORT_SYMBOL(param_get_string);
796

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive