Quelle  kobjects.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Speakup kobject implementation
 *
 * Copyright (C) 2009 William Hubbs
 *
 * This code is based on kobject-example.c, which came with linux 2.6.x.
 *
 * Copyright (C) 2004-2007 Greg Kroah-Hartman <greg@kroah.com>
 * Copyright (C) 2007 Novell Inc.
 *
 * Released under the GPL version 2 only.
 *
 */
#include <linux/slab.h>  /* For kmalloc. */
#include <linux/kernel.h>
#include <linux/kobject.h>
#include <linux/string.h>
#include <linux/string_helpers.h>
#include <linux/sysfs.h>
#include <linux/ctype.h>

#include "speakup.h"
#include "spk_priv.h"

/*
 * This is called when a user reads the characters or chartab sys file.
 */
static ssize_t chars_chartab_show(struct kobject *kobj,
      struct kobj_attribute *attr, char *buf)
{
 int i;
 int len = 0;
 char *cp;
 char *buf_pointer = buf;
 size_t bufsize = PAGE_SIZE;
 unsigned long flags;

 spin_lock_irqsave(&speakup_info.spinlock, flags);
 *buf_pointer = '\0';
 for (i = 0; i < 256; i++) {
  if (bufsize <= 1)
   break;
  if (strcmp("characters", attr->attr.name) == 0) {
   len = scnprintf(buf_pointer, bufsize, "%d\t%s\n",
     i, spk_characters[i]);
  } else { /* show chartab entry */
   if (IS_TYPE(i, B_CTL))
    cp = "B_CTL";
   else if (IS_TYPE(i, WDLM))
    cp = "WDLM";
   else if (IS_TYPE(i, A_PUNC))
    cp = "A_PUNC";
   else if (IS_TYPE(i, PUNC))
    cp = "PUNC";
   else if (IS_TYPE(i, NUM))
    cp = "NUM";
   else if (IS_TYPE(i, A_CAP))
    cp = "A_CAP";
   else if (IS_TYPE(i, ALPHA))
    cp = "ALPHA";
   else if (IS_TYPE(i, B_CAPSYM))
    cp = "B_CAPSYM";
   else if (IS_TYPE(i, B_SYM))
    cp = "B_SYM";
   else
    cp = "0";
   len =
       scnprintf(buf_pointer, bufsize, "%d\t%s\n", i, cp);
  }
  bufsize -= len;
  buf_pointer += len;
 }
 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 return buf_pointer - buf;
}

/*
 * Print informational messages or warnings after updating
 * character descriptions or chartab entries.
 */
static void report_char_chartab_status(int reset, int received, int used,
           int rejected, int do_characters)
{
 static char const *object_type[] = {
  "character class entries",
  "character descriptions",
 };
 int len;
 char buf[80];

 if (reset) {
  pr_info("%s reset to defaults\n", object_type[do_characters]);
 } else if (received) {
  len = snprintf(buf, sizeof(buf),
          " updated %d of %d %s\n",
          used, received, object_type[do_characters]);
  if (rejected)
   snprintf(buf + (len - 1), sizeof(buf) - (len - 1),
     " with %d reject%s\n",
     rejected, rejected > 1 ? "s" : "");
  pr_info("%s", buf);
 }
}

/*
 * This is called when a user changes the characters or chartab parameters.
 */
static ssize_t chars_chartab_store(struct kobject *kobj,
       struct kobj_attribute *attr,
       const char *buf, size_t count)
{
 char *cp = (char *)buf;
 char *end = cp + count; /* the null at the end of the buffer */
 char *linefeed = NULL;
 char keyword[MAX_DESC_LEN + 1];
 char *outptr = NULL; /* Will hold keyword or desc. */
 char *temp = NULL;
 char *desc = NULL;
 ssize_t retval = count;
 unsigned long flags;
 unsigned long index = 0;
 int charclass = 0;
 int received = 0;
 int used = 0;
 int rejected = 0;
 int reset = 0;
 int do_characters = !strcmp(attr->attr.name, "characters");
 size_t desc_length = 0;
 int i;

 spin_lock_irqsave(&speakup_info.spinlock, flags);
 while (cp < end) {
  while ((cp < end) && (*cp == ' ' || *cp == '\t'))
   cp++;

  if (cp == end)
   break;
  if ((*cp == '\n') || strchr("dDrR", *cp)) {
   reset = 1;
   break;
  }
  received++;

  linefeed = strchr(cp, '\n');
  if (!linefeed) {
   rejected++;
   break;
  }

  if (!isdigit(*cp)) {
   rejected++;
   cp = linefeed + 1;
   continue;
  }

  /*
 * Do not replace with kstrtoul:
 * here we need temp to be updated
 */
  index = simple_strtoul(cp, &temp, 10);
  if (index > 255) {
   rejected++;
   cp = linefeed + 1;
   continue;
  }

  while ((temp < linefeed) && (*temp == ' ' || *temp == '\t'))
   temp++;

  desc_length = linefeed - temp;
  if (desc_length > MAX_DESC_LEN) {
   rejected++;
   cp = linefeed + 1;
   continue;
  }
  if (do_characters) {
   desc = kmalloc(desc_length + 1, GFP_ATOMIC);
   if (!desc) {
    retval = -ENOMEM;
    reset = 1; /* just reset on error. */
    break;
   }
   outptr = desc;
  } else {
   outptr = keyword;
  }

  for (i = 0; i < desc_length; i++)
   outptr[i] = temp[i];
  outptr[desc_length] = '\0';

  if (do_characters) {
   if (spk_characters[index] != spk_default_chars[index])
    kfree(spk_characters[index]);
   spk_characters[index] = desc;
   used++;
  } else {
   charclass = spk_chartab_get_value(keyword);
   if (charclass == 0) {
    rejected++;
    cp = linefeed + 1;
    continue;
   }
   if (charclass != spk_chartab[index]) {
    spk_chartab[index] = charclass;
    used++;
   }
  }
  cp = linefeed + 1;
 }

 if (reset) {
  if (do_characters)
   spk_reset_default_chars();
  else
   spk_reset_default_chartab();
 }

 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 report_char_chartab_status(reset, received, used, rejected,
       do_characters);
 return retval;
}

/*
 * This is called when a user reads the keymap parameter.
 */
static ssize_t keymap_show(struct kobject *kobj, struct kobj_attribute *attr,
      char *buf)
{
 char *cp = buf;
 int i;
 int n;
 int num_keys;
 int nstates;
 u_char *cp1;
 u_char ch;
 unsigned long flags;

 spin_lock_irqsave(&speakup_info.spinlock, flags);
 cp1 = spk_key_buf + SHIFT_TBL_SIZE;
 num_keys = (int)(*cp1);
 nstates = (int)cp1[1];
 cp += sprintf(cp, "%d, %d, %d,\n", KEY_MAP_VER, num_keys, nstates);
 cp1 += 2; /* now pointing at shift states */
 /* dump num_keys+1 as first row is shift states + flags,
 * each subsequent row is key + states
 */
 for (n = 0; n <= num_keys; n++) {
  for (i = 0; i <= nstates; i++) {
   ch = *cp1++;
   cp += sprintf(cp, "%d,", (int)ch);
   *cp++ = (i < nstates) ? SPACE : '\n';
  }
 }
 cp += sprintf(cp, "0, %d\n", KEY_MAP_VER);
 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 return (int)(cp - buf);
}

/*
 * This is called when a user changes the keymap parameter.
 */
static ssize_t keymap_store(struct kobject *kobj, struct kobj_attribute *attr,
       const char *buf, size_t count)
{
 int i;
 ssize_t ret = count;
 char *in_buff = NULL;
 char *cp;
 u_char *cp1;
 unsigned long flags;

 spin_lock_irqsave(&speakup_info.spinlock, flags);
 in_buff = kmemdup(buf, count + 1, GFP_ATOMIC);
 if (!in_buff) {
  spin_unlock_irqrestore(&speakup_info.spinlock, flags);
  return -ENOMEM;
 }
 if (strchr("dDrR", *in_buff)) {
  spk_set_key_info(spk_key_defaults, spk_key_buf);
  pr_info("keymap set to default values\n");
  kfree(in_buff);
  spin_unlock_irqrestore(&speakup_info.spinlock, flags);
  return count;
 }
 if (in_buff[count - 1] == '\n')
  in_buff[count - 1] = '\0';
 cp = in_buff;
 cp1 = (u_char *)in_buff;
 for (i = 0; i < 3; i++) {
  cp = spk_s2uchar(cp, cp1);
  cp1++;
 }
 i = (int)cp1[-2] + 1;
 i *= (int)cp1[-1] + 1;
 i += 2; /* 0 and last map ver */
 if (cp1[-3] != KEY_MAP_VER || cp1[-1] > 10 ||
     i + SHIFT_TBL_SIZE + 4 >= sizeof(spk_key_buf)) {
  pr_warn("i %d %d %d %d\n", i,
   (int)cp1[-3], (int)cp1[-2], (int)cp1[-1]);
  kfree(in_buff);
  spin_unlock_irqrestore(&speakup_info.spinlock, flags);
  return -EINVAL;
 }
 while (--i >= 0) {
  cp = spk_s2uchar(cp, cp1);
  cp1++;
  if (!(*cp))
   break;
 }
 if (i != 0 || cp1[-1] != KEY_MAP_VER || cp1[-2] != 0) {
  ret = -EINVAL;
  pr_warn("end %d %d %d %d\n", i,
   (int)cp1[-3], (int)cp1[-2], (int)cp1[-1]);
 } else {
  if (spk_set_key_info(in_buff, spk_key_buf)) {
   spk_set_key_info(spk_key_defaults, spk_key_buf);
   ret = -EINVAL;
   pr_warn("set key failed\n");
  }
 }
 kfree(in_buff);
 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 return ret;
}

/*
 * This is called when a user changes the value of the silent parameter.
 */
static ssize_t silent_store(struct kobject *kobj, struct kobj_attribute *attr,
       const char *buf, size_t count)
{
 int len;
 struct vc_data *vc = vc_cons[fg_console].d;
 char ch = 0;
 char shut;
 unsigned long flags;

 len = strlen(buf);
 if (len > 0 && len < 3) {
  ch = buf[0];
  if (ch == '\n')
   ch = '0';
 }
 if (ch < '0' || ch > '7') {
  pr_warn("silent value '%c' not in range (0,7)\n", ch);
  return -EINVAL;
 }
 spin_lock_irqsave(&speakup_info.spinlock, flags);
 if (ch & 2) {
  shut = 1;
  spk_do_flush();
 } else {
  shut = 0;
 }
 if (ch & 4)
  shut |= 0x40;
 if (ch & 1)
  spk_shut_up |= shut;
 else
  spk_shut_up &= ~shut;
 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 return count;
}

/*
 * This is called when a user reads the synth setting.
 */
static ssize_t synth_show(struct kobject *kobj, struct kobj_attribute *attr,
     char *buf)
{
 int rv;

 if (!synth)
  rv = sprintf(buf, "%s\n", "none");
 else
  rv = sprintf(buf, "%s\n", synth->name);
 return rv;
}

/*
 * This is called when a user requests to change synthesizers.
 */
static ssize_t synth_store(struct kobject *kobj, struct kobj_attribute *attr,
      const char *buf, size_t count)
{
 int len;
 char new_synth_name[10];

 len = strlen(buf);
 if (len < 2 || len > 9)
  return -EINVAL;
 memcpy(new_synth_name, buf, len);
 if (new_synth_name[len - 1] == '\n')
  len--;
 new_synth_name[len] = '\0';
 spk_strlwr(new_synth_name);
 if (synth && !strcmp(new_synth_name, synth->name)) {
  pr_warn("%s already in use\n", new_synth_name);
 } else if (synth_init(new_synth_name) != 0) {
  pr_warn("failed to init synth %s\n", new_synth_name);
  return -ENODEV;
 }
 return count;
}

/*
 * This is called when text is sent to the synth via the synth_direct file.
 */
static ssize_t synth_direct_store(struct kobject *kobj,
      struct kobj_attribute *attr,
      const char *buf, size_t count)
{
 char *unescaped;
 unsigned long flags;

 if (!synth)
  return -EPERM;

 unescaped = kstrdup(buf, GFP_KERNEL);
 if (!unescaped)
  return -ENOMEM;

 string_unescape_any_inplace(unescaped);

 spin_lock_irqsave(&speakup_info.spinlock, flags);
 synth_write(unescaped, strlen(unescaped));
 spin_unlock_irqrestore(&speakup_info.spinlock, flags);

 kfree(unescaped);

 return count;
}

/*
 * This function is called when a user reads the version.
 */
static ssize_t version_show(struct kobject *kobj, struct kobj_attribute *attr,
       char *buf)
{
 char *cp;

 cp = buf;
 cp += sprintf(cp, "Speakup version %s\n", SPEAKUP_VERSION);
 if (synth)
  cp += sprintf(cp, "%s synthesizer driver version %s\n",
  synth->name, synth->version);
 return cp - buf;
}

/*
 * This is called when a user reads the punctuation settings.
 */
static ssize_t punc_show(struct kobject *kobj, struct kobj_attribute *attr,
    char *buf)
{
 int i;
 char *cp = buf;
 struct st_var_header *p_header;
 struct punc_var_t *var;
 struct st_bits_data *pb;
 short mask;
 unsigned long flags;

 p_header = spk_var_header_by_name(attr->attr.name);
 if (!p_header) {
  pr_warn("p_header is null, attr->attr.name is %s\n",
   attr->attr.name);
  return -EINVAL;
 }

 var = spk_get_punc_var(p_header->var_id);
 if (!var) {
  pr_warn("var is null, p_header->var_id is %i\n",
   p_header->var_id);
  return -EINVAL;
 }

 spin_lock_irqsave(&speakup_info.spinlock, flags);
 pb = (struct st_bits_data *)&spk_punc_info[var->value];
 mask = pb->mask;
 for (i = 33; i < 128; i++) {
  if (!(spk_chartab[i] & mask))
   continue;
  *cp++ = (char)i;
 }
 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 return cp - buf;
}

/*
 * This is called when a user changes the punctuation settings.
 */
static ssize_t punc_store(struct kobject *kobj, struct kobj_attribute *attr,
     const char *buf, size_t count)
{
 int x;
 struct st_var_header *p_header;
 struct punc_var_t *var;
 char punc_buf[100];
 unsigned long flags;

 x = strlen(buf);
 if (x < 1 || x > 99)
  return -EINVAL;

 p_header = spk_var_header_by_name(attr->attr.name);
 if (!p_header) {
  pr_warn("p_header is null, attr->attr.name is %s\n",
   attr->attr.name);
  return -EINVAL;
 }

 var = spk_get_punc_var(p_header->var_id);
 if (!var) {
  pr_warn("var is null, p_header->var_id is %i\n",
   p_header->var_id);
  return -EINVAL;
 }

 memcpy(punc_buf, buf, x);

 while (x && punc_buf[x - 1] == '\n')
  x--;
 punc_buf[x] = '\0';

 spin_lock_irqsave(&speakup_info.spinlock, flags);

 if (*punc_buf == 'd' || *punc_buf == 'r')
  x = spk_set_mask_bits(NULL, var->value, 3);
 else
  x = spk_set_mask_bits(punc_buf, var->value, 3);

 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 return count;
}

/*
 * This function is called when a user reads one of the variable parameters.
 */
ssize_t spk_var_show(struct kobject *kobj, struct kobj_attribute *attr,
       char *buf)
{
 int rv = 0;
 struct st_var_header *param;
 struct var_t *var;
 char *cp1;
 char *cp;
 char ch;
 unsigned long flags;

 param = spk_var_header_by_name(attr->attr.name);
 if (!param)
  return -EINVAL;

 spin_lock_irqsave(&speakup_info.spinlock, flags);
 var = (struct var_t *)param->data;
 switch (param->var_type) {
 case VAR_NUM:
 case VAR_TIME:
  if (var)
   rv = sprintf(buf, "%i\n", var->u.n.value);
  else
   rv = sprintf(buf, "0\n");
  break;
 case VAR_STRING:
  if (var) {
   cp1 = buf;
   *cp1++ = '"';
   for (cp = (char *)param->p_val; (ch = *cp); cp++) {
    if (ch >= ' ' && ch < '~')
     *cp1++ = ch;
    else
     cp1 += sprintf(cp1, "\\x%02x", ch);
   }
   *cp1++ = '"';
   *cp1++ = '\n';
   *cp1 = '\0';
   rv = cp1 - buf;
  } else {
   rv = sprintf(buf, "\"\"\n");
  }
  break;
 default:
  rv = sprintf(buf, "Bad parameter %s, type %i\n",
        param->name, param->var_type);
  break;
 }
 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 return rv;
}
EXPORT_SYMBOL_GPL(spk_var_show);

/*
 * Used to reset either default_pitch or default_vol.
 */
static inline void spk_reset_default_value(char *header_name,
        int *synth_default_value, int idx)
{
 struct st_var_header *param;

 if (synth && synth_default_value) {
  param = spk_var_header_by_name(header_name);
  if (param)  {
   spk_set_num_var(synth_default_value[idx],
     param, E_NEW_DEFAULT);
   spk_set_num_var(0, param, E_DEFAULT);
   pr_info("%s reset to default value\n", param->name);
  }
 }
}

/*
 * This function is called when a user echos a value to one of the
 * variable parameters.
 */
ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr,
        const char *buf, size_t count)
{
 struct st_var_header *param;
 int ret;
 int len;
 char *cp;
 struct var_t *var_data;
 long value;
 unsigned long flags;

 param = spk_var_header_by_name(attr->attr.name);
 if (!param)
  return -EINVAL;
 if (!param->data)
  return 0;
 ret = 0;
 cp = (char *)buf;
 string_unescape_any_inplace(cp);

 spin_lock_irqsave(&speakup_info.spinlock, flags);
 switch (param->var_type) {
 case VAR_NUM:
 case VAR_TIME:
  if (*cp == 'd' || *cp == 'r' || *cp == '\0')
   len = E_DEFAULT;
  else if (*cp == '+' || *cp == '-')
   len = E_INC;
  else
   len = E_SET;
  if (kstrtol(cp, 10, &value) == 0)
   ret = spk_set_num_var(value, param, len);
  else
   pr_warn("overflow or parsing error has occurred");
  if (ret == -ERANGE) {
   var_data = param->data;
   pr_warn("value for %s out of range, expect %d to %d\n",
    param->name,
    var_data->u.n.low, var_data->u.n.high);
  }

        /*
* If voice was just changed, we might need to reset our default
* pitch and volume.
*/
  if (param->var_id == VOICE && synth &&
      (ret == 0 || ret == -ERESTART)) {
   var_data = param->data;
   value = var_data->u.n.value;
   spk_reset_default_value("pitch", synth->default_pitch,
      value);
   spk_reset_default_value("vol", synth->default_vol,
      value);
  }
  break;
 case VAR_STRING:
  len = strlen(cp);
  if ((len >= 1) && (cp[len - 1] == '\n'))
   --len;
  if ((len >= 2) && (cp[0] == '"') && (cp[len - 1] == '"')) {
   ++cp;
   len -= 2;
  }
  cp[len] = '\0';
  ret = spk_set_string_var(cp, param, len);
  if (ret == -E2BIG)
   pr_warn("value too long for %s\n",
    param->name);
  break;
 default:
  pr_warn("%s unknown type %d\n",
   param->name, (int)param->var_type);
 break;
 }
 spin_unlock_irqrestore(&speakup_info.spinlock, flags);

 if (ret == -ERESTART)
  pr_info("%s reset to default value\n", param->name);
 return count;
}
EXPORT_SYMBOL_GPL(spk_var_store);

/*
 * Functions for reading and writing lists of i18n messages.  Incomplete.
 */

static ssize_t message_show_helper(char *buf, enum msg_index_t first,
       enum msg_index_t last)
{
 size_t bufsize = PAGE_SIZE;
 char *buf_pointer = buf;
 int printed;
 enum msg_index_t cursor;
 int index = 0;
 *buf_pointer = '\0'; /* buf_pointer always looking at a NUL byte. */

 for (cursor = first; cursor <= last; cursor++, index++) {
  if (bufsize <= 1)
   break;
  printed = scnprintf(buf_pointer, bufsize, "%d\t%s\n",
        index, spk_msg_get(cursor));
  buf_pointer += printed;
  bufsize -= printed;
 }

 return buf_pointer - buf;
}

static void report_msg_status(int reset, int received, int used,
         int rejected, char *groupname)
{
 int len;
 char buf[160];

 if (reset) {
  pr_info("i18n messages from group %s reset to defaults\n",
   groupname);
 } else if (received) {
  len = snprintf(buf, sizeof(buf),
          " updated %d of %d i18n messages from group %s\n",
           used, received, groupname);
  if (rejected)
   snprintf(buf + (len - 1), sizeof(buf) - (len - 1),
     " with %d reject%s\n",
     rejected, rejected > 1 ? "s" : "");
  pr_info("%s", buf);
 }
}

static ssize_t message_store_helper(const char *buf, size_t count,
        struct msg_group_t *group)
{
 char *cp = (char *)buf;
 char *end = cp + count;
 char *linefeed = NULL;
 char *temp = NULL;
 ssize_t msg_stored = 0;
 ssize_t retval = count;
 size_t desc_length = 0;
 unsigned long index = 0;
 int received = 0;
 int used = 0;
 int rejected = 0;
 int reset = 0;
 enum msg_index_t firstmessage = group->start;
 enum msg_index_t lastmessage = group->end;
 enum msg_index_t curmessage;

 while (cp < end) {
  while ((cp < end) && (*cp == ' ' || *cp == '\t'))
   cp++;

  if (cp == end)
   break;
  if (strchr("dDrR", *cp)) {
   reset = 1;
   break;
  }
  received++;

  linefeed = strchr(cp, '\n');
  if (!linefeed) {
   rejected++;
   break;
  }

  if (!isdigit(*cp)) {
   rejected++;
   cp = linefeed + 1;
   continue;
  }

  /*
 * Do not replace with kstrtoul:
 * here we need temp to be updated
 */
  index = simple_strtoul(cp, &temp, 10);

  while ((temp < linefeed) && (*temp == ' ' || *temp == '\t'))
   temp++;

  desc_length = linefeed - temp;
  curmessage = firstmessage + index;

  /*
 * Note the check (curmessage < firstmessage).  It is not
 * redundant.  Suppose that the user gave us an index
 * equal to ULONG_MAX - 1.  If firstmessage > 1, then
 * firstmessage + index < firstmessage!
 */

  if ((curmessage < firstmessage) || (curmessage > lastmessage)) {
   rejected++;
   cp = linefeed + 1;
   continue;
  }

  msg_stored = spk_msg_set(curmessage, temp, desc_length);
  if (msg_stored < 0) {
   retval = msg_stored;
   if (msg_stored == -ENOMEM)
    reset = 1;
   break;
  }

  used++;

  cp = linefeed + 1;
 }

 if (reset)
  spk_reset_msg_group(group);

 report_msg_status(reset, received, used, rejected, group->name);
 return retval;
}

static ssize_t message_show(struct kobject *kobj,
       struct kobj_attribute *attr, char *buf)
{
 ssize_t retval = 0;
 struct msg_group_t *group = spk_find_msg_group(attr->attr.name);
 unsigned long flags;

 if (WARN_ON(!group))
  return -EINVAL;

 spin_lock_irqsave(&speakup_info.spinlock, flags);
 retval = message_show_helper(buf, group->start, group->end);
 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
 return retval;
}

static ssize_t message_store(struct kobject *kobj, struct kobj_attribute *attr,
        const char *buf, size_t count)
{
 struct msg_group_t *group = spk_find_msg_group(attr->attr.name);

 if (WARN_ON(!group))
  return -EINVAL;

 return message_store_helper(buf, count, group);
}

/*
 * Declare the attributes.
 */
static struct kobj_attribute keymap_attribute =
 __ATTR_RW(keymap);
static struct kobj_attribute silent_attribute =
 __ATTR_WO(silent);
static struct kobj_attribute synth_attribute =
 __ATTR_RW(synth);
static struct kobj_attribute synth_direct_attribute =
 __ATTR_WO(synth_direct);
static struct kobj_attribute version_attribute =
 __ATTR_RO(version);

static struct kobj_attribute delimiters_attribute =
 __ATTR(delimiters, 0644, punc_show, punc_store);
static struct kobj_attribute ex_num_attribute =
 __ATTR(ex_num, 0644, punc_show, punc_store);
static struct kobj_attribute punc_all_attribute =
 __ATTR(punc_all, 0644, punc_show, punc_store);
static struct kobj_attribute punc_most_attribute =
 __ATTR(punc_most, 0644, punc_show, punc_store);
static struct kobj_attribute punc_some_attribute =
 __ATTR(punc_some, 0644, punc_show, punc_store);
static struct kobj_attribute repeats_attribute =
 __ATTR(repeats, 0644, punc_show, punc_store);

static struct kobj_attribute attrib_bleep_attribute =
 __ATTR(attrib_bleep, 0644, spk_var_show, spk_var_store);
static struct kobj_attribute bell_pos_attribute =
 __ATTR(bell_pos, 0644, spk_var_show, spk_var_store);
static struct kobj_attribute bleep_time_attribute =
 __ATTR(bleep_time, 0644, spk_var_show, spk_var_store);
static struct kobj_attribute bleeps_attribute =
 __ATTR(bleeps, 0644, spk_var_show, spk_var_store);
static struct kobj_attribute cursor_time_attribute =
 __ATTR(cursor_time, 0644, spk_var_show, spk_var_store);
static struct kobj_attribute key_echo_attribute =
 __ATTR(key_echo, 0644, spk_var_show, spk_var_store);
static struct kobj_attribute no_interrupt_attribute =
 __ATTR(no_interrupt, 0644, spk_var_show, spk_var_store);
static struct kobj_attribute punc_level_attribute =
 __ATTR(punc_level, 0644, spk_var_show, spk_var_store);
static struct kobj_attribute reading_punc_attribute =
 __ATTR(reading_punc, 0644, spk_var_show, spk_var_store);
static struct kobj_attribute say_control_attribute =
 __ATTR(say_control, 0644, spk_var_show, spk_var_store);
static struct kobj_attribute say_word_ctl_attribute =
 __ATTR(say_word_ctl, 0644, spk_var_show, spk_var_store);
static struct kobj_attribute spell_delay_attribute =
 __ATTR(spell_delay, 0644, spk_var_show, spk_var_store);
static struct kobj_attribute cur_phonetic_attribute =
 __ATTR(cur_phonetic, 0644, spk_var_show, spk_var_store);

/*
 * These attributes are i18n related.
 */
static struct kobj_attribute announcements_attribute =
 __ATTR(announcements, 0644, message_show, message_store);
static struct kobj_attribute characters_attribute =
 __ATTR(characters, 0644, chars_chartab_show,
        chars_chartab_store);
static struct kobj_attribute chartab_attribute =
 __ATTR(chartab, 0644, chars_chartab_show,
        chars_chartab_store);
static struct kobj_attribute ctl_keys_attribute =
 __ATTR(ctl_keys, 0644, message_show, message_store);
static struct kobj_attribute colors_attribute =
 __ATTR(colors, 0644, message_show, message_store);
static struct kobj_attribute formatted_attribute =
 __ATTR(formatted, 0644, message_show, message_store);
static struct kobj_attribute function_names_attribute =
 __ATTR(function_names, 0644, message_show, message_store);
static struct kobj_attribute key_names_attribute =
 __ATTR(key_names, 0644, message_show, message_store);
static struct kobj_attribute states_attribute =
 __ATTR(states, 0644, message_show, message_store);

/*
 * Create groups of attributes so that we can create and destroy them all
 * at once.
 */
static struct attribute *main_attrs[] = {
 &keymap_attribute.attr,
 &silent_attribute.attr,
 &synth_attribute.attr,
 &synth_direct_attribute.attr,
 &version_attribute.attr,
 &delimiters_attribute.attr,
 &ex_num_attribute.attr,
 &punc_all_attribute.attr,
 &punc_most_attribute.attr,
 &punc_some_attribute.attr,
 &repeats_attribute.attr,
 &attrib_bleep_attribute.attr,
 &bell_pos_attribute.attr,
 &bleep_time_attribute.attr,
 &bleeps_attribute.attr,
 &cursor_time_attribute.attr,
 &key_echo_attribute.attr,
 &no_interrupt_attribute.attr,
 &punc_level_attribute.attr,
 &reading_punc_attribute.attr,
 &say_control_attribute.attr,
 &say_word_ctl_attribute.attr,
 &spell_delay_attribute.attr,
 &cur_phonetic_attribute.attr,
 NULL,
};

static struct attribute *i18n_attrs[] = {
 &announcements_attribute.attr,
 &characters_attribute.attr,
 &chartab_attribute.attr,
 &ctl_keys_attribute.attr,
 &colors_attribute.attr,
 &formatted_attribute.attr,
 &function_names_attribute.attr,
 &key_names_attribute.attr,
 &states_attribute.attr,
 NULL,
};

/*
 * An unnamed attribute group will put all of the attributes directly in
 * the kobject directory.  If we specify a name, a subdirectory will be
 * created for the attributes with the directory being the name of the
 * attribute group.
 */
static const struct attribute_group main_attr_group = {
 .attrs = main_attrs,
};

static const struct attribute_group i18n_attr_group = {
 .attrs = i18n_attrs,
 .name = "i18n",
};

static struct kobject *accessibility_kobj;
struct kobject *speakup_kobj;

int speakup_kobj_init(void)
{
 int retval;

 /*
 * Create a simple kobject with the name of "accessibility",
 * located under /sys/
 *
 * As this is a simple directory, no uevent will be sent to
 * userspace.  That is why this function should not be used for
 * any type of dynamic kobjects, where the name and number are
 * not known ahead of time.
 */
 accessibility_kobj = kobject_create_and_add("accessibility", NULL);
 if (!accessibility_kobj) {
  retval = -ENOMEM;
  goto out;
 }

 speakup_kobj = kobject_create_and_add("speakup", accessibility_kobj);
 if (!speakup_kobj) {
  retval = -ENOMEM;
  goto err_acc;
 }

 /* Create the files associated with this kobject */
 retval = sysfs_create_group(speakup_kobj, &main_attr_group);
 if (retval)
  goto err_speakup;

 retval = sysfs_create_group(speakup_kobj, &i18n_attr_group);
 if (retval)
  goto err_group;

 goto out;

err_group:
 sysfs_remove_group(speakup_kobj, &main_attr_group);
err_speakup:
 kobject_put(speakup_kobj);
err_acc:
 kobject_put(accessibility_kobj);
out:
 return retval;
}

void speakup_kobj_exit(void)
{
 sysfs_remove_group(speakup_kobj, &i18n_attr_group);
 sysfs_remove_group(speakup_kobj, &main_attr_group);
 kobject_put(speakup_kobj);
 kobject_put(accessibility_kobj);
}