Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Speakup kobject implementation
4 *
5 * Copyright (C) 2009 William Hubbs
6 *
7 * This code is based on kobject-example.c, which came with linux 2.6.x.
8 *
9 * Copyright (C) 2004-2007 Greg Kroah-Hartman <greg@kroah.com>
10 * Copyright (C) 2007 Novell Inc.
11 *
12 * Released under the GPL version 2 only.
13 *
14 */
15#include <linux/slab.h> /* For kmalloc. */
16#include <linux/kernel.h>
17#include <linux/kobject.h>
18#include <linux/string.h>
19#include <linux/string_helpers.h>
20#include <linux/sysfs.h>
21#include <linux/ctype.h>
22
23#include "speakup.h"
24#include "spk_priv.h"
25
26/*
27 * This is called when a user reads the characters or chartab sys file.
28 */
29static ssize_t chars_chartab_show(struct kobject *kobj,
30 struct kobj_attribute *attr, char *buf)
31{
32 int i;
33 int len = 0;
34 char *cp;
35 char *buf_pointer = buf;
36 size_t bufsize = PAGE_SIZE;
37 unsigned long flags;
38
39 spin_lock_irqsave(&speakup_info.spinlock, flags);
40 *buf_pointer = '\0';
41 for (i = 0; i < 256; i++) {
42 if (bufsize <= 1)
43 break;
44 if (strcmp("characters", attr->attr.name) == 0) {
45 len = scnprintf(buf_pointer, bufsize, "%d\t%s\n",
46 i, spk_characters[i]);
47 } else { /* show chartab entry */
48 if (IS_TYPE(i, B_CTL))
49 cp = "B_CTL";
50 else if (IS_TYPE(i, WDLM))
51 cp = "WDLM";
52 else if (IS_TYPE(i, A_PUNC))
53 cp = "A_PUNC";
54 else if (IS_TYPE(i, PUNC))
55 cp = "PUNC";
56 else if (IS_TYPE(i, NUM))
57 cp = "NUM";
58 else if (IS_TYPE(i, A_CAP))
59 cp = "A_CAP";
60 else if (IS_TYPE(i, ALPHA))
61 cp = "ALPHA";
62 else if (IS_TYPE(i, B_CAPSYM))
63 cp = "B_CAPSYM";
64 else if (IS_TYPE(i, B_SYM))
65 cp = "B_SYM";
66 else
67 cp = "0";
68 len =
69 scnprintf(buf_pointer, bufsize, "%d\t%s\n", i, cp);
70 }
71 bufsize -= len;
72 buf_pointer += len;
73 }
74 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
75 return buf_pointer - buf;
76}
77
78/*
79 * Print informational messages or warnings after updating
80 * character descriptions or chartab entries.
81 */
82static void report_char_chartab_status(int reset, int received, int used,
83 int rejected, int do_characters)
84{
85 static char const *object_type[] = {
86 "character class entries",
87 "character descriptions",
88 };
89 int len;
90 char buf[80];
91
92 if (reset) {
93 pr_info("%s reset to defaults\n", object_type[do_characters]);
94 } else if (received) {
95 len = snprintf(buf, sizeof(buf),
96 " updated %d of %d %s\n",
97 used, received, object_type[do_characters]);
98 if (rejected)
99 snprintf(buf + (len - 1), sizeof(buf) - (len - 1),
100 " with %d reject%s\n",
101 rejected, rejected > 1 ? "s" : "");
102 pr_info("%s", buf);
103 }
104}
105
106/*
107 * This is called when a user changes the characters or chartab parameters.
108 */
109static ssize_t chars_chartab_store(struct kobject *kobj,
110 struct kobj_attribute *attr,
111 const char *buf, size_t count)
112{
113 char *cp = (char *)buf;
114 char *end = cp + count; /* the null at the end of the buffer */
115 char *linefeed = NULL;
116 char keyword[MAX_DESC_LEN + 1];
117 char *outptr = NULL; /* Will hold keyword or desc. */
118 char *temp = NULL;
119 char *desc = NULL;
120 ssize_t retval = count;
121 unsigned long flags;
122 unsigned long index = 0;
123 int charclass = 0;
124 int received = 0;
125 int used = 0;
126 int rejected = 0;
127 int reset = 0;
128 int do_characters = !strcmp(attr->attr.name, "characters");
129 size_t desc_length = 0;
130 int i;
131
132 spin_lock_irqsave(&speakup_info.spinlock, flags);
133 while (cp < end) {
134 while ((cp < end) && (*cp == ' ' || *cp == '\t'))
135 cp++;
136
137 if (cp == end)
138 break;
139 if ((*cp == '\n') || strchr("dDrR", *cp)) {
140 reset = 1;
141 break;
142 }
143 received++;
144
145 linefeed = strchr(cp, '\n');
146 if (!linefeed) {
147 rejected++;
148 break;
149 }
150
151 if (!isdigit(*cp)) {
152 rejected++;
153 cp = linefeed + 1;
154 continue;
155 }
156
157 /*
158 * Do not replace with kstrtoul:
159 * here we need temp to be updated
160 */
161 index = simple_strtoul(cp, &temp, 10);
162 if (index > 255) {
163 rejected++;
164 cp = linefeed + 1;
165 continue;
166 }
167
168 while ((temp < linefeed) && (*temp == ' ' || *temp == '\t'))
169 temp++;
170
171 desc_length = linefeed - temp;
172 if (desc_length > MAX_DESC_LEN) {
173 rejected++;
174 cp = linefeed + 1;
175 continue;
176 }
177 if (do_characters) {
178 desc = kmalloc(desc_length + 1, GFP_ATOMIC);
179 if (!desc) {
180 retval = -ENOMEM;
181 reset = 1; /* just reset on error. */
182 break;
183 }
184 outptr = desc;
185 } else {
186 outptr = keyword;
187 }
188
189 for (i = 0; i < desc_length; i++)
190 outptr[i] = temp[i];
191 outptr[desc_length] = '\0';
192
193 if (do_characters) {
194 if (spk_characters[index] != spk_default_chars[index])
195 kfree(spk_characters[index]);
196 spk_characters[index] = desc;
197 used++;
198 } else {
199 charclass = spk_chartab_get_value(keyword);
200 if (charclass == 0) {
201 rejected++;
202 cp = linefeed + 1;
203 continue;
204 }
205 if (charclass != spk_chartab[index]) {
206 spk_chartab[index] = charclass;
207 used++;
208 }
209 }
210 cp = linefeed + 1;
211 }
212
213 if (reset) {
214 if (do_characters)
215 spk_reset_default_chars();
216 else
217 spk_reset_default_chartab();
218 }
219
220 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
221 report_char_chartab_status(reset, received, used, rejected,
222 do_characters);
223 return retval;
224}
225
226/*
227 * This is called when a user reads the keymap parameter.
228 */
229static ssize_t keymap_show(struct kobject *kobj, struct kobj_attribute *attr,
230 char *buf)
231{
232 char *cp = buf;
233 int i;
234 int n;
235 int num_keys;
236 int nstates;
237 u_char *cp1;
238 u_char ch;
239 unsigned long flags;
240
241 spin_lock_irqsave(&speakup_info.spinlock, flags);
242 cp1 = spk_key_buf + SHIFT_TBL_SIZE;
243 num_keys = (int)(*cp1);
244 nstates = (int)cp1[1];
245 cp += sprintf(cp, "%d, %d, %d,\n", KEY_MAP_VER, num_keys, nstates);
246 cp1 += 2; /* now pointing at shift states */
247 /* dump num_keys+1 as first row is shift states + flags,
248 * each subsequent row is key + states
249 */
250 for (n = 0; n <= num_keys; n++) {
251 for (i = 0; i <= nstates; i++) {
252 ch = *cp1++;
253 cp += sprintf(cp, "%d,", (int)ch);
254 *cp++ = (i < nstates) ? SPACE : '\n';
255 }
256 }
257 cp += sprintf(cp, "0, %d\n", KEY_MAP_VER);
258 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
259 return (int)(cp - buf);
260}
261
262/*
263 * This is called when a user changes the keymap parameter.
264 */
265static ssize_t keymap_store(struct kobject *kobj, struct kobj_attribute *attr,
266 const char *buf, size_t count)
267{
268 int i;
269 ssize_t ret = count;
270 char *in_buff = NULL;
271 char *cp;
272 u_char *cp1;
273 unsigned long flags;
274
275 spin_lock_irqsave(&speakup_info.spinlock, flags);
276 in_buff = kmemdup(buf, count + 1, GFP_ATOMIC);
277 if (!in_buff) {
278 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
279 return -ENOMEM;
280 }
281 if (strchr("dDrR", *in_buff)) {
282 spk_set_key_info(spk_key_defaults, spk_key_buf);
283 pr_info("keymap set to default values\n");
284 kfree(in_buff);
285 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
286 return count;
287 }
288 if (in_buff[count - 1] == '\n')
289 in_buff[count - 1] = '\0';
290 cp = in_buff;
291 cp1 = (u_char *)in_buff;
292 for (i = 0; i < 3; i++) {
293 cp = spk_s2uchar(cp, cp1);
294 cp1++;
295 }
296 i = (int)cp1[-2] + 1;
297 i *= (int)cp1[-1] + 1;
298 i += 2; /* 0 and last map ver */
299 if (cp1[-3] != KEY_MAP_VER || cp1[-1] > 10 ||
300 i + SHIFT_TBL_SIZE + 4 >= sizeof(spk_key_buf)) {
301 pr_warn("i %d %d %d %d\n", i,
302 (int)cp1[-3], (int)cp1[-2], (int)cp1[-1]);
303 kfree(in_buff);
304 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
305 return -EINVAL;
306 }
307 while (--i >= 0) {
308 cp = spk_s2uchar(cp, cp1);
309 cp1++;
310 if (!(*cp))
311 break;
312 }
313 if (i != 0 || cp1[-1] != KEY_MAP_VER || cp1[-2] != 0) {
314 ret = -EINVAL;
315 pr_warn("end %d %d %d %d\n", i,
316 (int)cp1[-3], (int)cp1[-2], (int)cp1[-1]);
317 } else {
318 if (spk_set_key_info(in_buff, spk_key_buf)) {
319 spk_set_key_info(spk_key_defaults, spk_key_buf);
320 ret = -EINVAL;
321 pr_warn("set key failed\n");
322 }
323 }
324 kfree(in_buff);
325 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
326 return ret;
327}
328
329/*
330 * This is called when a user changes the value of the silent parameter.
331 */
332static ssize_t silent_store(struct kobject *kobj, struct kobj_attribute *attr,
333 const char *buf, size_t count)
334{
335 int len;
336 struct vc_data *vc = vc_cons[fg_console].d;
337 char ch = 0;
338 char shut;
339 unsigned long flags;
340
341 len = strlen(buf);
342 if (len > 0 && len < 3) {
343 ch = buf[0];
344 if (ch == '\n')
345 ch = '0';
346 }
347 if (ch < '0' || ch > '7') {
348 pr_warn("silent value '%c' not in range (0,7)\n", ch);
349 return -EINVAL;
350 }
351 spin_lock_irqsave(&speakup_info.spinlock, flags);
352 if (ch & 2) {
353 shut = 1;
354 spk_do_flush();
355 } else {
356 shut = 0;
357 }
358 if (ch & 4)
359 shut |= 0x40;
360 if (ch & 1)
361 spk_shut_up |= shut;
362 else
363 spk_shut_up &= ~shut;
364 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
365 return count;
366}
367
368/*
369 * This is called when a user reads the synth setting.
370 */
371static ssize_t synth_show(struct kobject *kobj, struct kobj_attribute *attr,
372 char *buf)
373{
374 int rv;
375
376 if (!synth)
377 rv = sprintf(buf, "%s\n", "none");
378 else
379 rv = sprintf(buf, "%s\n", synth->name);
380 return rv;
381}
382
383/*
384 * This is called when a user requests to change synthesizers.
385 */
386static ssize_t synth_store(struct kobject *kobj, struct kobj_attribute *attr,
387 const char *buf, size_t count)
388{
389 int len;
390 char new_synth_name[10];
391
392 len = strlen(buf);
393 if (len < 2 || len > 9)
394 return -EINVAL;
395 memcpy(new_synth_name, buf, len);
396 if (new_synth_name[len - 1] == '\n')
397 len--;
398 new_synth_name[len] = '\0';
399 spk_strlwr(new_synth_name);
400 if (synth && !strcmp(new_synth_name, synth->name)) {
401 pr_warn("%s already in use\n", new_synth_name);
402 } else if (synth_init(new_synth_name) != 0) {
403 pr_warn("failed to init synth %s\n", new_synth_name);
404 return -ENODEV;
405 }
406 return count;
407}
408
409/*
410 * This is called when text is sent to the synth via the synth_direct file.
411 */
412static ssize_t synth_direct_store(struct kobject *kobj,
413 struct kobj_attribute *attr,
414 const char *buf, size_t count)
415{
416 u_char tmp[256];
417 int len;
418 int bytes;
419 const char *ptr = buf;
420 unsigned long flags;
421
422 if (!synth)
423 return -EPERM;
424
425 len = strlen(buf);
426 spin_lock_irqsave(&speakup_info.spinlock, flags);
427 while (len > 0) {
428 bytes = min_t(size_t, len, 250);
429 strncpy(tmp, ptr, bytes);
430 tmp[bytes] = '\0';
431 string_unescape_any_inplace(tmp);
432 synth_printf("%s", tmp);
433 ptr += bytes;
434 len -= bytes;
435 }
436 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
437 return count;
438}
439
440/*
441 * This function is called when a user reads the version.
442 */
443static ssize_t version_show(struct kobject *kobj, struct kobj_attribute *attr,
444 char *buf)
445{
446 char *cp;
447
448 cp = buf;
449 cp += sprintf(cp, "Speakup version %s\n", SPEAKUP_VERSION);
450 if (synth)
451 cp += sprintf(cp, "%s synthesizer driver version %s\n",
452 synth->name, synth->version);
453 return cp - buf;
454}
455
456/*
457 * This is called when a user reads the punctuation settings.
458 */
459static ssize_t punc_show(struct kobject *kobj, struct kobj_attribute *attr,
460 char *buf)
461{
462 int i;
463 char *cp = buf;
464 struct st_var_header *p_header;
465 struct punc_var_t *var;
466 struct st_bits_data *pb;
467 short mask;
468 unsigned long flags;
469
470 p_header = spk_var_header_by_name(attr->attr.name);
471 if (!p_header) {
472 pr_warn("p_header is null, attr->attr.name is %s\n",
473 attr->attr.name);
474 return -EINVAL;
475 }
476
477 var = spk_get_punc_var(p_header->var_id);
478 if (!var) {
479 pr_warn("var is null, p_header->var_id is %i\n",
480 p_header->var_id);
481 return -EINVAL;
482 }
483
484 spin_lock_irqsave(&speakup_info.spinlock, flags);
485 pb = (struct st_bits_data *)&spk_punc_info[var->value];
486 mask = pb->mask;
487 for (i = 33; i < 128; i++) {
488 if (!(spk_chartab[i] & mask))
489 continue;
490 *cp++ = (char)i;
491 }
492 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
493 return cp - buf;
494}
495
496/*
497 * This is called when a user changes the punctuation settings.
498 */
499static ssize_t punc_store(struct kobject *kobj, struct kobj_attribute *attr,
500 const char *buf, size_t count)
501{
502 int x;
503 struct st_var_header *p_header;
504 struct punc_var_t *var;
505 char punc_buf[100];
506 unsigned long flags;
507
508 x = strlen(buf);
509 if (x < 1 || x > 99)
510 return -EINVAL;
511
512 p_header = spk_var_header_by_name(attr->attr.name);
513 if (!p_header) {
514 pr_warn("p_header is null, attr->attr.name is %s\n",
515 attr->attr.name);
516 return -EINVAL;
517 }
518
519 var = spk_get_punc_var(p_header->var_id);
520 if (!var) {
521 pr_warn("var is null, p_header->var_id is %i\n",
522 p_header->var_id);
523 return -EINVAL;
524 }
525
526 memcpy(punc_buf, buf, x);
527
528 while (x && punc_buf[x - 1] == '\n')
529 x--;
530 punc_buf[x] = '\0';
531
532 spin_lock_irqsave(&speakup_info.spinlock, flags);
533
534 if (*punc_buf == 'd' || *punc_buf == 'r')
535 x = spk_set_mask_bits(NULL, var->value, 3);
536 else
537 x = spk_set_mask_bits(punc_buf, var->value, 3);
538
539 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
540 return count;
541}
542
543/*
544 * This function is called when a user reads one of the variable parameters.
545 */
546ssize_t spk_var_show(struct kobject *kobj, struct kobj_attribute *attr,
547 char *buf)
548{
549 int rv = 0;
550 struct st_var_header *param;
551 struct var_t *var;
552 char *cp1;
553 char *cp;
554 char ch;
555 unsigned long flags;
556
557 param = spk_var_header_by_name(attr->attr.name);
558 if (!param)
559 return -EINVAL;
560
561 spin_lock_irqsave(&speakup_info.spinlock, flags);
562 var = (struct var_t *)param->data;
563 switch (param->var_type) {
564 case VAR_NUM:
565 case VAR_TIME:
566 if (var)
567 rv = sprintf(buf, "%i\n", var->u.n.value);
568 else
569 rv = sprintf(buf, "0\n");
570 break;
571 case VAR_STRING:
572 if (var) {
573 cp1 = buf;
574 *cp1++ = '"';
575 for (cp = (char *)param->p_val; (ch = *cp); cp++) {
576 if (ch >= ' ' && ch < '~')
577 *cp1++ = ch;
578 else
579 cp1 += sprintf(cp1, "\\x%02x", ch);
580 }
581 *cp1++ = '"';
582 *cp1++ = '\n';
583 *cp1 = '\0';
584 rv = cp1 - buf;
585 } else {
586 rv = sprintf(buf, "\"\"\n");
587 }
588 break;
589 default:
590 rv = sprintf(buf, "Bad parameter %s, type %i\n",
591 param->name, param->var_type);
592 break;
593 }
594 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
595 return rv;
596}
597EXPORT_SYMBOL_GPL(spk_var_show);
598
599/*
600 * Used to reset either default_pitch or default_vol.
601 */
602static inline void spk_reset_default_value(char *header_name,
603 int *synth_default_value, int idx)
604{
605 struct st_var_header *param;
606
607 if (synth && synth_default_value) {
608 param = spk_var_header_by_name(header_name);
609 if (param) {
610 spk_set_num_var(synth_default_value[idx],
611 param, E_NEW_DEFAULT);
612 spk_set_num_var(0, param, E_DEFAULT);
613 pr_info("%s reset to default value\n", param->name);
614 }
615 }
616}
617
618/*
619 * This function is called when a user echos a value to one of the
620 * variable parameters.
621 */
622ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr,
623 const char *buf, size_t count)
624{
625 struct st_var_header *param;
626 int ret;
627 int len;
628 char *cp;
629 struct var_t *var_data;
630 long value;
631 unsigned long flags;
632
633 param = spk_var_header_by_name(attr->attr.name);
634 if (!param)
635 return -EINVAL;
636 if (!param->data)
637 return 0;
638 ret = 0;
639 cp = (char *)buf;
640 string_unescape_any_inplace(cp);
641
642 spin_lock_irqsave(&speakup_info.spinlock, flags);
643 switch (param->var_type) {
644 case VAR_NUM:
645 case VAR_TIME:
646 if (*cp == 'd' || *cp == 'r' || *cp == '\0')
647 len = E_DEFAULT;
648 else if (*cp == '+' || *cp == '-')
649 len = E_INC;
650 else
651 len = E_SET;
652 if (kstrtol(cp, 10, &value) == 0)
653 ret = spk_set_num_var(value, param, len);
654 else
655 pr_warn("overflow or parsing error has occurred");
656 if (ret == -ERANGE) {
657 var_data = param->data;
658 pr_warn("value for %s out of range, expect %d to %d\n",
659 param->name,
660 var_data->u.n.low, var_data->u.n.high);
661 }
662
663 /*
664 * If voice was just changed, we might need to reset our default
665 * pitch and volume.
666 */
667 if (param->var_id == VOICE && synth &&
668 (ret == 0 || ret == -ERESTART)) {
669 var_data = param->data;
670 value = var_data->u.n.value;
671 spk_reset_default_value("pitch", synth->default_pitch,
672 value);
673 spk_reset_default_value("vol", synth->default_vol,
674 value);
675 }
676 break;
677 case VAR_STRING:
678 len = strlen(cp);
679 if ((len >= 1) && (cp[len - 1] == '\n'))
680 --len;
681 if ((len >= 2) && (cp[0] == '"') && (cp[len - 1] == '"')) {
682 ++cp;
683 len -= 2;
684 }
685 cp[len] = '\0';
686 ret = spk_set_string_var(cp, param, len);
687 if (ret == -E2BIG)
688 pr_warn("value too long for %s\n",
689 param->name);
690 break;
691 default:
692 pr_warn("%s unknown type %d\n",
693 param->name, (int)param->var_type);
694 break;
695 }
696 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
697
698 if (ret == -ERESTART)
699 pr_info("%s reset to default value\n", param->name);
700 return count;
701}
702EXPORT_SYMBOL_GPL(spk_var_store);
703
704/*
705 * Functions for reading and writing lists of i18n messages. Incomplete.
706 */
707
708static ssize_t message_show_helper(char *buf, enum msg_index_t first,
709 enum msg_index_t last)
710{
711 size_t bufsize = PAGE_SIZE;
712 char *buf_pointer = buf;
713 int printed;
714 enum msg_index_t cursor;
715 int index = 0;
716 *buf_pointer = '\0'; /* buf_pointer always looking at a NUL byte. */
717
718 for (cursor = first; cursor <= last; cursor++, index++) {
719 if (bufsize <= 1)
720 break;
721 printed = scnprintf(buf_pointer, bufsize, "%d\t%s\n",
722 index, spk_msg_get(cursor));
723 buf_pointer += printed;
724 bufsize -= printed;
725 }
726
727 return buf_pointer - buf;
728}
729
730static void report_msg_status(int reset, int received, int used,
731 int rejected, char *groupname)
732{
733 int len;
734 char buf[160];
735
736 if (reset) {
737 pr_info("i18n messages from group %s reset to defaults\n",
738 groupname);
739 } else if (received) {
740 len = snprintf(buf, sizeof(buf),
741 " updated %d of %d i18n messages from group %s\n",
742 used, received, groupname);
743 if (rejected)
744 snprintf(buf + (len - 1), sizeof(buf) - (len - 1),
745 " with %d reject%s\n",
746 rejected, rejected > 1 ? "s" : "");
747 pr_info("%s", buf);
748 }
749}
750
751static ssize_t message_store_helper(const char *buf, size_t count,
752 struct msg_group_t *group)
753{
754 char *cp = (char *)buf;
755 char *end = cp + count;
756 char *linefeed = NULL;
757 char *temp = NULL;
758 ssize_t msg_stored = 0;
759 ssize_t retval = count;
760 size_t desc_length = 0;
761 unsigned long index = 0;
762 int received = 0;
763 int used = 0;
764 int rejected = 0;
765 int reset = 0;
766 enum msg_index_t firstmessage = group->start;
767 enum msg_index_t lastmessage = group->end;
768 enum msg_index_t curmessage;
769
770 while (cp < end) {
771 while ((cp < end) && (*cp == ' ' || *cp == '\t'))
772 cp++;
773
774 if (cp == end)
775 break;
776 if (strchr("dDrR", *cp)) {
777 reset = 1;
778 break;
779 }
780 received++;
781
782 linefeed = strchr(cp, '\n');
783 if (!linefeed) {
784 rejected++;
785 break;
786 }
787
788 if (!isdigit(*cp)) {
789 rejected++;
790 cp = linefeed + 1;
791 continue;
792 }
793
794 /*
795 * Do not replace with kstrtoul:
796 * here we need temp to be updated
797 */
798 index = simple_strtoul(cp, &temp, 10);
799
800 while ((temp < linefeed) && (*temp == ' ' || *temp == '\t'))
801 temp++;
802
803 desc_length = linefeed - temp;
804 curmessage = firstmessage + index;
805
806 /*
807 * Note the check (curmessage < firstmessage). It is not
808 * redundant. Suppose that the user gave us an index
809 * equal to ULONG_MAX - 1. If firstmessage > 1, then
810 * firstmessage + index < firstmessage!
811 */
812
813 if ((curmessage < firstmessage) || (curmessage > lastmessage)) {
814 rejected++;
815 cp = linefeed + 1;
816 continue;
817 }
818
819 msg_stored = spk_msg_set(curmessage, temp, desc_length);
820 if (msg_stored < 0) {
821 retval = msg_stored;
822 if (msg_stored == -ENOMEM)
823 reset = 1;
824 break;
825 }
826
827 used++;
828
829 cp = linefeed + 1;
830 }
831
832 if (reset)
833 spk_reset_msg_group(group);
834
835 report_msg_status(reset, received, used, rejected, group->name);
836 return retval;
837}
838
839static ssize_t message_show(struct kobject *kobj,
840 struct kobj_attribute *attr, char *buf)
841{
842 ssize_t retval = 0;
843 struct msg_group_t *group = spk_find_msg_group(attr->attr.name);
844 unsigned long flags;
845
846 if (WARN_ON(!group))
847 return -EINVAL;
848
849 spin_lock_irqsave(&speakup_info.spinlock, flags);
850 retval = message_show_helper(buf, group->start, group->end);
851 spin_unlock_irqrestore(&speakup_info.spinlock, flags);
852 return retval;
853}
854
855static ssize_t message_store(struct kobject *kobj, struct kobj_attribute *attr,
856 const char *buf, size_t count)
857{
858 struct msg_group_t *group = spk_find_msg_group(attr->attr.name);
859
860 if (WARN_ON(!group))
861 return -EINVAL;
862
863 return message_store_helper(buf, count, group);
864}
865
866/*
867 * Declare the attributes.
868 */
869static struct kobj_attribute keymap_attribute =
870 __ATTR_RW(keymap);
871static struct kobj_attribute silent_attribute =
872 __ATTR_WO(silent);
873static struct kobj_attribute synth_attribute =
874 __ATTR_RW(synth);
875static struct kobj_attribute synth_direct_attribute =
876 __ATTR_WO(synth_direct);
877static struct kobj_attribute version_attribute =
878 __ATTR_RO(version);
879
880static struct kobj_attribute delimiters_attribute =
881 __ATTR(delimiters, 0644, punc_show, punc_store);
882static struct kobj_attribute ex_num_attribute =
883 __ATTR(ex_num, 0644, punc_show, punc_store);
884static struct kobj_attribute punc_all_attribute =
885 __ATTR(punc_all, 0644, punc_show, punc_store);
886static struct kobj_attribute punc_most_attribute =
887 __ATTR(punc_most, 0644, punc_show, punc_store);
888static struct kobj_attribute punc_some_attribute =
889 __ATTR(punc_some, 0644, punc_show, punc_store);
890static struct kobj_attribute repeats_attribute =
891 __ATTR(repeats, 0644, punc_show, punc_store);
892
893static struct kobj_attribute attrib_bleep_attribute =
894 __ATTR(attrib_bleep, 0644, spk_var_show, spk_var_store);
895static struct kobj_attribute bell_pos_attribute =
896 __ATTR(bell_pos, 0644, spk_var_show, spk_var_store);
897static struct kobj_attribute bleep_time_attribute =
898 __ATTR(bleep_time, 0644, spk_var_show, spk_var_store);
899static struct kobj_attribute bleeps_attribute =
900 __ATTR(bleeps, 0644, spk_var_show, spk_var_store);
901static struct kobj_attribute cursor_time_attribute =
902 __ATTR(cursor_time, 0644, spk_var_show, spk_var_store);
903static struct kobj_attribute key_echo_attribute =
904 __ATTR(key_echo, 0644, spk_var_show, spk_var_store);
905static struct kobj_attribute no_interrupt_attribute =
906 __ATTR(no_interrupt, 0644, spk_var_show, spk_var_store);
907static struct kobj_attribute punc_level_attribute =
908 __ATTR(punc_level, 0644, spk_var_show, spk_var_store);
909static struct kobj_attribute reading_punc_attribute =
910 __ATTR(reading_punc, 0644, spk_var_show, spk_var_store);
911static struct kobj_attribute say_control_attribute =
912 __ATTR(say_control, 0644, spk_var_show, spk_var_store);
913static struct kobj_attribute say_word_ctl_attribute =
914 __ATTR(say_word_ctl, 0644, spk_var_show, spk_var_store);
915static struct kobj_attribute spell_delay_attribute =
916 __ATTR(spell_delay, 0644, spk_var_show, spk_var_store);
917static struct kobj_attribute cur_phonetic_attribute =
918 __ATTR(cur_phonetic, 0644, spk_var_show, spk_var_store);
919
920/*
921 * These attributes are i18n related.
922 */
923static struct kobj_attribute announcements_attribute =
924 __ATTR(announcements, 0644, message_show, message_store);
925static struct kobj_attribute characters_attribute =
926 __ATTR(characters, 0644, chars_chartab_show,
927 chars_chartab_store);
928static struct kobj_attribute chartab_attribute =
929 __ATTR(chartab, 0644, chars_chartab_show,
930 chars_chartab_store);
931static struct kobj_attribute ctl_keys_attribute =
932 __ATTR(ctl_keys, 0644, message_show, message_store);
933static struct kobj_attribute colors_attribute =
934 __ATTR(colors, 0644, message_show, message_store);
935static struct kobj_attribute formatted_attribute =
936 __ATTR(formatted, 0644, message_show, message_store);
937static struct kobj_attribute function_names_attribute =
938 __ATTR(function_names, 0644, message_show, message_store);
939static struct kobj_attribute key_names_attribute =
940 __ATTR(key_names, 0644, message_show, message_store);
941static struct kobj_attribute states_attribute =
942 __ATTR(states, 0644, message_show, message_store);
943
944/*
945 * Create groups of attributes so that we can create and destroy them all
946 * at once.
947 */
948static struct attribute *main_attrs[] = {
949 &keymap_attribute.attr,
950 &silent_attribute.attr,
951 &synth_attribute.attr,
952 &synth_direct_attribute.attr,
953 &version_attribute.attr,
954 &delimiters_attribute.attr,
955 &ex_num_attribute.attr,
956 &punc_all_attribute.attr,
957 &punc_most_attribute.attr,
958 &punc_some_attribute.attr,
959 &repeats_attribute.attr,
960 &attrib_bleep_attribute.attr,
961 &bell_pos_attribute.attr,
962 &bleep_time_attribute.attr,
963 &bleeps_attribute.attr,
964 &cursor_time_attribute.attr,
965 &key_echo_attribute.attr,
966 &no_interrupt_attribute.attr,
967 &punc_level_attribute.attr,
968 &reading_punc_attribute.attr,
969 &say_control_attribute.attr,
970 &say_word_ctl_attribute.attr,
971 &spell_delay_attribute.attr,
972 &cur_phonetic_attribute.attr,
973 NULL,
974};
975
976static struct attribute *i18n_attrs[] = {
977 &announcements_attribute.attr,
978 &characters_attribute.attr,
979 &chartab_attribute.attr,
980 &ctl_keys_attribute.attr,
981 &colors_attribute.attr,
982 &formatted_attribute.attr,
983 &function_names_attribute.attr,
984 &key_names_attribute.attr,
985 &states_attribute.attr,
986 NULL,
987};
988
989/*
990 * An unnamed attribute group will put all of the attributes directly in
991 * the kobject directory. If we specify a name, a subdirectory will be
992 * created for the attributes with the directory being the name of the
993 * attribute group.
994 */
995static const struct attribute_group main_attr_group = {
996 .attrs = main_attrs,
997};
998
999static const struct attribute_group i18n_attr_group = {
1000 .attrs = i18n_attrs,
1001 .name = "i18n",
1002};
1003
1004static struct kobject *accessibility_kobj;
1005struct kobject *speakup_kobj;
1006
1007int speakup_kobj_init(void)
1008{
1009 int retval;
1010
1011 /*
1012 * Create a simple kobject with the name of "accessibility",
1013 * located under /sys/
1014 *
1015 * As this is a simple directory, no uevent will be sent to
1016 * userspace. That is why this function should not be used for
1017 * any type of dynamic kobjects, where the name and number are
1018 * not known ahead of time.
1019 */
1020 accessibility_kobj = kobject_create_and_add("accessibility", NULL);
1021 if (!accessibility_kobj) {
1022 retval = -ENOMEM;
1023 goto out;
1024 }
1025
1026 speakup_kobj = kobject_create_and_add("speakup", accessibility_kobj);
1027 if (!speakup_kobj) {
1028 retval = -ENOMEM;
1029 goto err_acc;
1030 }
1031
1032 /* Create the files associated with this kobject */
1033 retval = sysfs_create_group(speakup_kobj, &main_attr_group);
1034 if (retval)
1035 goto err_speakup;
1036
1037 retval = sysfs_create_group(speakup_kobj, &i18n_attr_group);
1038 if (retval)
1039 goto err_group;
1040
1041 goto out;
1042
1043err_group:
1044 sysfs_remove_group(speakup_kobj, &main_attr_group);
1045err_speakup:
1046 kobject_put(speakup_kobj);
1047err_acc:
1048 kobject_put(accessibility_kobj);
1049out:
1050 return retval;
1051}
1052
1053void speakup_kobj_exit(void)
1054{
1055 sysfs_remove_group(speakup_kobj, &i18n_attr_group);
1056 sysfs_remove_group(speakup_kobj, &main_attr_group);
1057 kobject_put(speakup_kobj);
1058 kobject_put(accessibility_kobj);
1059}