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