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 | */ |
29 | static 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: buf_pointer, size: bufsize, fmt: "%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: buf_pointer, size: bufsize, fmt: "%d\t%s\n" , i, cp); |
70 | } |
71 | bufsize -= len; |
72 | buf_pointer += len; |
73 | } |
74 | spin_unlock_irqrestore(lock: &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 | */ |
82 | static 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, size: sizeof(buf), |
96 | fmt: " updated %d of %d %s\n" , |
97 | used, received, object_type[do_characters]); |
98 | if (rejected) |
99 | snprintf(buf: buf + (len - 1), size: sizeof(buf) - (len - 1), |
100 | fmt: " 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 | */ |
109 | static 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(c: *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(size: 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(objp: 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(lock: &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 | */ |
229 | static 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(buf: cp, fmt: "%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(buf: cp, fmt: "%d," , (int)ch); |
254 | *cp++ = (i < nstates) ? SPACE : '\n'; |
255 | } |
256 | } |
257 | cp += sprintf(buf: cp, fmt: "0, %d\n" , KEY_MAP_VER); |
258 | spin_unlock_irqrestore(lock: &speakup_info.spinlock, flags); |
259 | return (int)(cp - buf); |
260 | } |
261 | |
262 | /* |
263 | * This is called when a user changes the keymap parameter. |
264 | */ |
265 | static 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(p: buf, size: count + 1, GFP_ATOMIC); |
277 | if (!in_buff) { |
278 | spin_unlock_irqrestore(lock: &speakup_info.spinlock, flags); |
279 | return -ENOMEM; |
280 | } |
281 | if (strchr("dDrR" , *in_buff)) { |
282 | spk_set_key_info(key_info: spk_key_defaults, k_buffer: spk_key_buf); |
283 | pr_info("keymap set to default values\n" ); |
284 | kfree(objp: in_buff); |
285 | spin_unlock_irqrestore(lock: &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(start: cp, dest: 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(objp: in_buff); |
304 | spin_unlock_irqrestore(lock: &speakup_info.spinlock, flags); |
305 | return -EINVAL; |
306 | } |
307 | while (--i >= 0) { |
308 | cp = spk_s2uchar(start: cp, dest: 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(key_info: in_buff, k_buffer: spk_key_buf)) { |
319 | spk_set_key_info(key_info: spk_key_defaults, k_buffer: spk_key_buf); |
320 | ret = -EINVAL; |
321 | pr_warn("set key failed\n" ); |
322 | } |
323 | } |
324 | kfree(objp: in_buff); |
325 | spin_unlock_irqrestore(lock: &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 | */ |
332 | static 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(lock: &speakup_info.spinlock, flags); |
365 | return count; |
366 | } |
367 | |
368 | /* |
369 | * This is called when a user reads the synth setting. |
370 | */ |
371 | static 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, fmt: "%s\n" , "none" ); |
378 | else |
379 | rv = sprintf(buf, fmt: "%s\n" , synth->name); |
380 | return rv; |
381 | } |
382 | |
383 | /* |
384 | * This is called when a user requests to change synthesizers. |
385 | */ |
386 | static 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(s: 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(name: 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 | */ |
412 | static ssize_t synth_direct_store(struct kobject *kobj, |
413 | struct kobj_attribute *attr, |
414 | const char *buf, size_t count) |
415 | { |
416 | char *unescaped; |
417 | unsigned long flags; |
418 | |
419 | if (!synth) |
420 | return -EPERM; |
421 | |
422 | unescaped = kstrdup(s: buf, GFP_KERNEL); |
423 | if (!unescaped) |
424 | return -ENOMEM; |
425 | |
426 | string_unescape_any_inplace(buf: unescaped); |
427 | |
428 | spin_lock_irqsave(&speakup_info.spinlock, flags); |
429 | synth_write(buf: unescaped, strlen(unescaped)); |
430 | spin_unlock_irqrestore(lock: &speakup_info.spinlock, flags); |
431 | |
432 | kfree(objp: unescaped); |
433 | |
434 | return count; |
435 | } |
436 | |
437 | /* |
438 | * This function is called when a user reads the version. |
439 | */ |
440 | static ssize_t version_show(struct kobject *kobj, struct kobj_attribute *attr, |
441 | char *buf) |
442 | { |
443 | char *cp; |
444 | |
445 | cp = buf; |
446 | cp += sprintf(buf: cp, fmt: "Speakup version %s\n" , SPEAKUP_VERSION); |
447 | if (synth) |
448 | cp += sprintf(buf: cp, fmt: "%s synthesizer driver version %s\n" , |
449 | synth->name, synth->version); |
450 | return cp - buf; |
451 | } |
452 | |
453 | /* |
454 | * This is called when a user reads the punctuation settings. |
455 | */ |
456 | static ssize_t punc_show(struct kobject *kobj, struct kobj_attribute *attr, |
457 | char *buf) |
458 | { |
459 | int i; |
460 | char *cp = buf; |
461 | struct st_var_header *; |
462 | struct punc_var_t *var; |
463 | struct st_bits_data *pb; |
464 | short mask; |
465 | unsigned long flags; |
466 | |
467 | p_header = spk_var_header_by_name(name: attr->attr.name); |
468 | if (!p_header) { |
469 | pr_warn("p_header is null, attr->attr.name is %s\n" , |
470 | attr->attr.name); |
471 | return -EINVAL; |
472 | } |
473 | |
474 | var = spk_get_punc_var(var_id: p_header->var_id); |
475 | if (!var) { |
476 | pr_warn("var is null, p_header->var_id is %i\n" , |
477 | p_header->var_id); |
478 | return -EINVAL; |
479 | } |
480 | |
481 | spin_lock_irqsave(&speakup_info.spinlock, flags); |
482 | pb = (struct st_bits_data *)&spk_punc_info[var->value]; |
483 | mask = pb->mask; |
484 | for (i = 33; i < 128; i++) { |
485 | if (!(spk_chartab[i] & mask)) |
486 | continue; |
487 | *cp++ = (char)i; |
488 | } |
489 | spin_unlock_irqrestore(lock: &speakup_info.spinlock, flags); |
490 | return cp - buf; |
491 | } |
492 | |
493 | /* |
494 | * This is called when a user changes the punctuation settings. |
495 | */ |
496 | static ssize_t punc_store(struct kobject *kobj, struct kobj_attribute *attr, |
497 | const char *buf, size_t count) |
498 | { |
499 | int x; |
500 | struct st_var_header *; |
501 | struct punc_var_t *var; |
502 | char punc_buf[100]; |
503 | unsigned long flags; |
504 | |
505 | x = strlen(buf); |
506 | if (x < 1 || x > 99) |
507 | return -EINVAL; |
508 | |
509 | p_header = spk_var_header_by_name(name: attr->attr.name); |
510 | if (!p_header) { |
511 | pr_warn("p_header is null, attr->attr.name is %s\n" , |
512 | attr->attr.name); |
513 | return -EINVAL; |
514 | } |
515 | |
516 | var = spk_get_punc_var(var_id: p_header->var_id); |
517 | if (!var) { |
518 | pr_warn("var is null, p_header->var_id is %i\n" , |
519 | p_header->var_id); |
520 | return -EINVAL; |
521 | } |
522 | |
523 | memcpy(punc_buf, buf, x); |
524 | |
525 | while (x && punc_buf[x - 1] == '\n') |
526 | x--; |
527 | punc_buf[x] = '\0'; |
528 | |
529 | spin_lock_irqsave(&speakup_info.spinlock, flags); |
530 | |
531 | if (*punc_buf == 'd' || *punc_buf == 'r') |
532 | x = spk_set_mask_bits(NULL, which: var->value, how: 3); |
533 | else |
534 | x = spk_set_mask_bits(input: punc_buf, which: var->value, how: 3); |
535 | |
536 | spin_unlock_irqrestore(lock: &speakup_info.spinlock, flags); |
537 | return count; |
538 | } |
539 | |
540 | /* |
541 | * This function is called when a user reads one of the variable parameters. |
542 | */ |
543 | ssize_t spk_var_show(struct kobject *kobj, struct kobj_attribute *attr, |
544 | char *buf) |
545 | { |
546 | int rv = 0; |
547 | struct st_var_header *param; |
548 | struct var_t *var; |
549 | char *cp1; |
550 | char *cp; |
551 | char ch; |
552 | unsigned long flags; |
553 | |
554 | param = spk_var_header_by_name(name: attr->attr.name); |
555 | if (!param) |
556 | return -EINVAL; |
557 | |
558 | spin_lock_irqsave(&speakup_info.spinlock, flags); |
559 | var = (struct var_t *)param->data; |
560 | switch (param->var_type) { |
561 | case VAR_NUM: |
562 | case VAR_TIME: |
563 | if (var) |
564 | rv = sprintf(buf, fmt: "%i\n" , var->u.n.value); |
565 | else |
566 | rv = sprintf(buf, fmt: "0\n" ); |
567 | break; |
568 | case VAR_STRING: |
569 | if (var) { |
570 | cp1 = buf; |
571 | *cp1++ = '"'; |
572 | for (cp = (char *)param->p_val; (ch = *cp); cp++) { |
573 | if (ch >= ' ' && ch < '~') |
574 | *cp1++ = ch; |
575 | else |
576 | cp1 += sprintf(buf: cp1, fmt: "\\x%02x" , ch); |
577 | } |
578 | *cp1++ = '"'; |
579 | *cp1++ = '\n'; |
580 | *cp1 = '\0'; |
581 | rv = cp1 - buf; |
582 | } else { |
583 | rv = sprintf(buf, fmt: "\"\"\n" ); |
584 | } |
585 | break; |
586 | default: |
587 | rv = sprintf(buf, fmt: "Bad parameter %s, type %i\n" , |
588 | param->name, param->var_type); |
589 | break; |
590 | } |
591 | spin_unlock_irqrestore(lock: &speakup_info.spinlock, flags); |
592 | return rv; |
593 | } |
594 | EXPORT_SYMBOL_GPL(spk_var_show); |
595 | |
596 | /* |
597 | * Used to reset either default_pitch or default_vol. |
598 | */ |
599 | static inline void spk_reset_default_value(char *, |
600 | int *synth_default_value, int idx) |
601 | { |
602 | struct st_var_header *param; |
603 | |
604 | if (synth && synth_default_value) { |
605 | param = spk_var_header_by_name(name: header_name); |
606 | if (param) { |
607 | spk_set_num_var(val: synth_default_value[idx], |
608 | var: param, how: E_NEW_DEFAULT); |
609 | spk_set_num_var(val: 0, var: param, how: E_DEFAULT); |
610 | pr_info("%s reset to default value\n" , param->name); |
611 | } |
612 | } |
613 | } |
614 | |
615 | /* |
616 | * This function is called when a user echos a value to one of the |
617 | * variable parameters. |
618 | */ |
619 | ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr, |
620 | const char *buf, size_t count) |
621 | { |
622 | struct st_var_header *param; |
623 | int ret; |
624 | int len; |
625 | char *cp; |
626 | struct var_t *var_data; |
627 | long value; |
628 | unsigned long flags; |
629 | |
630 | param = spk_var_header_by_name(name: attr->attr.name); |
631 | if (!param) |
632 | return -EINVAL; |
633 | if (!param->data) |
634 | return 0; |
635 | ret = 0; |
636 | cp = (char *)buf; |
637 | string_unescape_any_inplace(buf: cp); |
638 | |
639 | spin_lock_irqsave(&speakup_info.spinlock, flags); |
640 | switch (param->var_type) { |
641 | case VAR_NUM: |
642 | case VAR_TIME: |
643 | if (*cp == 'd' || *cp == 'r' || *cp == '\0') |
644 | len = E_DEFAULT; |
645 | else if (*cp == '+' || *cp == '-') |
646 | len = E_INC; |
647 | else |
648 | len = E_SET; |
649 | if (kstrtol(s: cp, base: 10, res: &value) == 0) |
650 | ret = spk_set_num_var(val: value, var: param, how: len); |
651 | else |
652 | pr_warn("overflow or parsing error has occurred" ); |
653 | if (ret == -ERANGE) { |
654 | var_data = param->data; |
655 | pr_warn("value for %s out of range, expect %d to %d\n" , |
656 | param->name, |
657 | var_data->u.n.low, var_data->u.n.high); |
658 | } |
659 | |
660 | /* |
661 | * If voice was just changed, we might need to reset our default |
662 | * pitch and volume. |
663 | */ |
664 | if (param->var_id == VOICE && synth && |
665 | (ret == 0 || ret == -ERESTART)) { |
666 | var_data = param->data; |
667 | value = var_data->u.n.value; |
668 | spk_reset_default_value(header_name: "pitch" , synth_default_value: synth->default_pitch, |
669 | idx: value); |
670 | spk_reset_default_value(header_name: "vol" , synth_default_value: synth->default_vol, |
671 | idx: value); |
672 | } |
673 | break; |
674 | case VAR_STRING: |
675 | len = strlen(cp); |
676 | if ((len >= 1) && (cp[len - 1] == '\n')) |
677 | --len; |
678 | if ((len >= 2) && (cp[0] == '"') && (cp[len - 1] == '"')) { |
679 | ++cp; |
680 | len -= 2; |
681 | } |
682 | cp[len] = '\0'; |
683 | ret = spk_set_string_var(page: cp, var: param, len); |
684 | if (ret == -E2BIG) |
685 | pr_warn("value too long for %s\n" , |
686 | param->name); |
687 | break; |
688 | default: |
689 | pr_warn("%s unknown type %d\n" , |
690 | param->name, (int)param->var_type); |
691 | break; |
692 | } |
693 | spin_unlock_irqrestore(lock: &speakup_info.spinlock, flags); |
694 | |
695 | if (ret == -ERESTART) |
696 | pr_info("%s reset to default value\n" , param->name); |
697 | return count; |
698 | } |
699 | EXPORT_SYMBOL_GPL(spk_var_store); |
700 | |
701 | /* |
702 | * Functions for reading and writing lists of i18n messages. Incomplete. |
703 | */ |
704 | |
705 | static ssize_t message_show_helper(char *buf, enum msg_index_t first, |
706 | enum msg_index_t last) |
707 | { |
708 | size_t bufsize = PAGE_SIZE; |
709 | char *buf_pointer = buf; |
710 | int printed; |
711 | enum msg_index_t cursor; |
712 | int index = 0; |
713 | *buf_pointer = '\0'; /* buf_pointer always looking at a NUL byte. */ |
714 | |
715 | for (cursor = first; cursor <= last; cursor++, index++) { |
716 | if (bufsize <= 1) |
717 | break; |
718 | printed = scnprintf(buf: buf_pointer, size: bufsize, fmt: "%d\t%s\n" , |
719 | index, spk_msg_get(index: cursor)); |
720 | buf_pointer += printed; |
721 | bufsize -= printed; |
722 | } |
723 | |
724 | return buf_pointer - buf; |
725 | } |
726 | |
727 | static void report_msg_status(int reset, int received, int used, |
728 | int rejected, char *groupname) |
729 | { |
730 | int len; |
731 | char buf[160]; |
732 | |
733 | if (reset) { |
734 | pr_info("i18n messages from group %s reset to defaults\n" , |
735 | groupname); |
736 | } else if (received) { |
737 | len = snprintf(buf, size: sizeof(buf), |
738 | fmt: " updated %d of %d i18n messages from group %s\n" , |
739 | used, received, groupname); |
740 | if (rejected) |
741 | snprintf(buf: buf + (len - 1), size: sizeof(buf) - (len - 1), |
742 | fmt: " with %d reject%s\n" , |
743 | rejected, rejected > 1 ? "s" : "" ); |
744 | pr_info("%s" , buf); |
745 | } |
746 | } |
747 | |
748 | static ssize_t message_store_helper(const char *buf, size_t count, |
749 | struct msg_group_t *group) |
750 | { |
751 | char *cp = (char *)buf; |
752 | char *end = cp + count; |
753 | char *linefeed = NULL; |
754 | char *temp = NULL; |
755 | ssize_t msg_stored = 0; |
756 | ssize_t retval = count; |
757 | size_t desc_length = 0; |
758 | unsigned long index = 0; |
759 | int received = 0; |
760 | int used = 0; |
761 | int rejected = 0; |
762 | int reset = 0; |
763 | enum msg_index_t firstmessage = group->start; |
764 | enum msg_index_t lastmessage = group->end; |
765 | enum msg_index_t curmessage; |
766 | |
767 | while (cp < end) { |
768 | while ((cp < end) && (*cp == ' ' || *cp == '\t')) |
769 | cp++; |
770 | |
771 | if (cp == end) |
772 | break; |
773 | if (strchr("dDrR" , *cp)) { |
774 | reset = 1; |
775 | break; |
776 | } |
777 | received++; |
778 | |
779 | linefeed = strchr(cp, '\n'); |
780 | if (!linefeed) { |
781 | rejected++; |
782 | break; |
783 | } |
784 | |
785 | if (!isdigit(c: *cp)) { |
786 | rejected++; |
787 | cp = linefeed + 1; |
788 | continue; |
789 | } |
790 | |
791 | /* |
792 | * Do not replace with kstrtoul: |
793 | * here we need temp to be updated |
794 | */ |
795 | index = simple_strtoul(cp, &temp, 10); |
796 | |
797 | while ((temp < linefeed) && (*temp == ' ' || *temp == '\t')) |
798 | temp++; |
799 | |
800 | desc_length = linefeed - temp; |
801 | curmessage = firstmessage + index; |
802 | |
803 | /* |
804 | * Note the check (curmessage < firstmessage). It is not |
805 | * redundant. Suppose that the user gave us an index |
806 | * equal to ULONG_MAX - 1. If firstmessage > 1, then |
807 | * firstmessage + index < firstmessage! |
808 | */ |
809 | |
810 | if ((curmessage < firstmessage) || (curmessage > lastmessage)) { |
811 | rejected++; |
812 | cp = linefeed + 1; |
813 | continue; |
814 | } |
815 | |
816 | msg_stored = spk_msg_set(index: curmessage, text: temp, length: desc_length); |
817 | if (msg_stored < 0) { |
818 | retval = msg_stored; |
819 | if (msg_stored == -ENOMEM) |
820 | reset = 1; |
821 | break; |
822 | } |
823 | |
824 | used++; |
825 | |
826 | cp = linefeed + 1; |
827 | } |
828 | |
829 | if (reset) |
830 | spk_reset_msg_group(group); |
831 | |
832 | report_msg_status(reset, received, used, rejected, groupname: group->name); |
833 | return retval; |
834 | } |
835 | |
836 | static ssize_t message_show(struct kobject *kobj, |
837 | struct kobj_attribute *attr, char *buf) |
838 | { |
839 | ssize_t retval = 0; |
840 | struct msg_group_t *group = spk_find_msg_group(group_name: attr->attr.name); |
841 | unsigned long flags; |
842 | |
843 | if (WARN_ON(!group)) |
844 | return -EINVAL; |
845 | |
846 | spin_lock_irqsave(&speakup_info.spinlock, flags); |
847 | retval = message_show_helper(buf, first: group->start, last: group->end); |
848 | spin_unlock_irqrestore(lock: &speakup_info.spinlock, flags); |
849 | return retval; |
850 | } |
851 | |
852 | static ssize_t message_store(struct kobject *kobj, struct kobj_attribute *attr, |
853 | const char *buf, size_t count) |
854 | { |
855 | struct msg_group_t *group = spk_find_msg_group(group_name: attr->attr.name); |
856 | |
857 | if (WARN_ON(!group)) |
858 | return -EINVAL; |
859 | |
860 | return message_store_helper(buf, count, group); |
861 | } |
862 | |
863 | /* |
864 | * Declare the attributes. |
865 | */ |
866 | static struct kobj_attribute keymap_attribute = |
867 | __ATTR_RW(keymap); |
868 | static struct kobj_attribute silent_attribute = |
869 | __ATTR_WO(silent); |
870 | static struct kobj_attribute synth_attribute = |
871 | __ATTR_RW(synth); |
872 | static struct kobj_attribute synth_direct_attribute = |
873 | __ATTR_WO(synth_direct); |
874 | static struct kobj_attribute version_attribute = |
875 | __ATTR_RO(version); |
876 | |
877 | static struct kobj_attribute delimiters_attribute = |
878 | __ATTR(delimiters, 0644, punc_show, punc_store); |
879 | static struct kobj_attribute ex_num_attribute = |
880 | __ATTR(ex_num, 0644, punc_show, punc_store); |
881 | static struct kobj_attribute punc_all_attribute = |
882 | __ATTR(punc_all, 0644, punc_show, punc_store); |
883 | static struct kobj_attribute punc_most_attribute = |
884 | __ATTR(punc_most, 0644, punc_show, punc_store); |
885 | static struct kobj_attribute punc_some_attribute = |
886 | __ATTR(punc_some, 0644, punc_show, punc_store); |
887 | static struct kobj_attribute repeats_attribute = |
888 | __ATTR(repeats, 0644, punc_show, punc_store); |
889 | |
890 | static struct kobj_attribute attrib_bleep_attribute = |
891 | __ATTR(attrib_bleep, 0644, spk_var_show, spk_var_store); |
892 | static struct kobj_attribute bell_pos_attribute = |
893 | __ATTR(bell_pos, 0644, spk_var_show, spk_var_store); |
894 | static struct kobj_attribute bleep_time_attribute = |
895 | __ATTR(bleep_time, 0644, spk_var_show, spk_var_store); |
896 | static struct kobj_attribute bleeps_attribute = |
897 | __ATTR(bleeps, 0644, spk_var_show, spk_var_store); |
898 | static struct kobj_attribute cursor_time_attribute = |
899 | __ATTR(cursor_time, 0644, spk_var_show, spk_var_store); |
900 | static struct kobj_attribute key_echo_attribute = |
901 | __ATTR(key_echo, 0644, spk_var_show, spk_var_store); |
902 | static struct kobj_attribute no_interrupt_attribute = |
903 | __ATTR(no_interrupt, 0644, spk_var_show, spk_var_store); |
904 | static struct kobj_attribute punc_level_attribute = |
905 | __ATTR(punc_level, 0644, spk_var_show, spk_var_store); |
906 | static struct kobj_attribute reading_punc_attribute = |
907 | __ATTR(reading_punc, 0644, spk_var_show, spk_var_store); |
908 | static struct kobj_attribute say_control_attribute = |
909 | __ATTR(say_control, 0644, spk_var_show, spk_var_store); |
910 | static struct kobj_attribute say_word_ctl_attribute = |
911 | __ATTR(say_word_ctl, 0644, spk_var_show, spk_var_store); |
912 | static struct kobj_attribute spell_delay_attribute = |
913 | __ATTR(spell_delay, 0644, spk_var_show, spk_var_store); |
914 | static struct kobj_attribute cur_phonetic_attribute = |
915 | __ATTR(cur_phonetic, 0644, spk_var_show, spk_var_store); |
916 | |
917 | /* |
918 | * These attributes are i18n related. |
919 | */ |
920 | static struct kobj_attribute announcements_attribute = |
921 | __ATTR(announcements, 0644, message_show, message_store); |
922 | static struct kobj_attribute characters_attribute = |
923 | __ATTR(characters, 0644, chars_chartab_show, |
924 | chars_chartab_store); |
925 | static struct kobj_attribute chartab_attribute = |
926 | __ATTR(chartab, 0644, chars_chartab_show, |
927 | chars_chartab_store); |
928 | static struct kobj_attribute ctl_keys_attribute = |
929 | __ATTR(ctl_keys, 0644, message_show, message_store); |
930 | static struct kobj_attribute colors_attribute = |
931 | __ATTR(colors, 0644, message_show, message_store); |
932 | static struct kobj_attribute formatted_attribute = |
933 | __ATTR(formatted, 0644, message_show, message_store); |
934 | static struct kobj_attribute function_names_attribute = |
935 | __ATTR(function_names, 0644, message_show, message_store); |
936 | static struct kobj_attribute key_names_attribute = |
937 | __ATTR(key_names, 0644, message_show, message_store); |
938 | static struct kobj_attribute states_attribute = |
939 | __ATTR(states, 0644, message_show, message_store); |
940 | |
941 | /* |
942 | * Create groups of attributes so that we can create and destroy them all |
943 | * at once. |
944 | */ |
945 | static struct attribute *main_attrs[] = { |
946 | &keymap_attribute.attr, |
947 | &silent_attribute.attr, |
948 | &synth_attribute.attr, |
949 | &synth_direct_attribute.attr, |
950 | &version_attribute.attr, |
951 | &delimiters_attribute.attr, |
952 | &ex_num_attribute.attr, |
953 | &punc_all_attribute.attr, |
954 | &punc_most_attribute.attr, |
955 | &punc_some_attribute.attr, |
956 | &repeats_attribute.attr, |
957 | &attrib_bleep_attribute.attr, |
958 | &bell_pos_attribute.attr, |
959 | &bleep_time_attribute.attr, |
960 | &bleeps_attribute.attr, |
961 | &cursor_time_attribute.attr, |
962 | &key_echo_attribute.attr, |
963 | &no_interrupt_attribute.attr, |
964 | &punc_level_attribute.attr, |
965 | &reading_punc_attribute.attr, |
966 | &say_control_attribute.attr, |
967 | &say_word_ctl_attribute.attr, |
968 | &spell_delay_attribute.attr, |
969 | &cur_phonetic_attribute.attr, |
970 | NULL, |
971 | }; |
972 | |
973 | static struct attribute *i18n_attrs[] = { |
974 | &announcements_attribute.attr, |
975 | &characters_attribute.attr, |
976 | &chartab_attribute.attr, |
977 | &ctl_keys_attribute.attr, |
978 | &colors_attribute.attr, |
979 | &formatted_attribute.attr, |
980 | &function_names_attribute.attr, |
981 | &key_names_attribute.attr, |
982 | &states_attribute.attr, |
983 | NULL, |
984 | }; |
985 | |
986 | /* |
987 | * An unnamed attribute group will put all of the attributes directly in |
988 | * the kobject directory. If we specify a name, a subdirectory will be |
989 | * created for the attributes with the directory being the name of the |
990 | * attribute group. |
991 | */ |
992 | static const struct attribute_group main_attr_group = { |
993 | .attrs = main_attrs, |
994 | }; |
995 | |
996 | static const struct attribute_group i18n_attr_group = { |
997 | .attrs = i18n_attrs, |
998 | .name = "i18n" , |
999 | }; |
1000 | |
1001 | static struct kobject *accessibility_kobj; |
1002 | struct kobject *speakup_kobj; |
1003 | |
1004 | int speakup_kobj_init(void) |
1005 | { |
1006 | int retval; |
1007 | |
1008 | /* |
1009 | * Create a simple kobject with the name of "accessibility", |
1010 | * located under /sys/ |
1011 | * |
1012 | * As this is a simple directory, no uevent will be sent to |
1013 | * userspace. That is why this function should not be used for |
1014 | * any type of dynamic kobjects, where the name and number are |
1015 | * not known ahead of time. |
1016 | */ |
1017 | accessibility_kobj = kobject_create_and_add(name: "accessibility" , NULL); |
1018 | if (!accessibility_kobj) { |
1019 | retval = -ENOMEM; |
1020 | goto out; |
1021 | } |
1022 | |
1023 | speakup_kobj = kobject_create_and_add(name: "speakup" , parent: accessibility_kobj); |
1024 | if (!speakup_kobj) { |
1025 | retval = -ENOMEM; |
1026 | goto err_acc; |
1027 | } |
1028 | |
1029 | /* Create the files associated with this kobject */ |
1030 | retval = sysfs_create_group(kobj: speakup_kobj, grp: &main_attr_group); |
1031 | if (retval) |
1032 | goto err_speakup; |
1033 | |
1034 | retval = sysfs_create_group(kobj: speakup_kobj, grp: &i18n_attr_group); |
1035 | if (retval) |
1036 | goto err_group; |
1037 | |
1038 | goto out; |
1039 | |
1040 | err_group: |
1041 | sysfs_remove_group(kobj: speakup_kobj, grp: &main_attr_group); |
1042 | err_speakup: |
1043 | kobject_put(kobj: speakup_kobj); |
1044 | err_acc: |
1045 | kobject_put(kobj: accessibility_kobj); |
1046 | out: |
1047 | return retval; |
1048 | } |
1049 | |
1050 | void speakup_kobj_exit(void) |
1051 | { |
1052 | sysfs_remove_group(kobj: speakup_kobj, grp: &i18n_attr_group); |
1053 | sysfs_remove_group(kobj: speakup_kobj, grp: &main_attr_group); |
1054 | kobject_put(kobj: speakup_kobj); |
1055 | kobject_put(kobj: accessibility_kobj); |
1056 | } |
1057 | |