diff --git a/Makefile b/Makefile index 66ae2984a38c..4958e39a9d9c 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ VERSION = 3 PATCHLEVEL = 4 -SUBLEVEL = 85 +SUBLEVEL = 86 EXTRAVERSION = NAME = Saber-toothed Squirrel diff --git a/arch/x86/include/asm/topology.h b/arch/x86/include/asm/topology.h index b9676ae37ada..ddaf130e9000 100644 --- a/arch/x86/include/asm/topology.h +++ b/arch/x86/include/asm/topology.h @@ -157,9 +157,10 @@ static inline void setup_node_to_cpumask_map(void) { } extern const struct cpumask *cpu_coregroup_mask(int cpu); -#ifdef ENABLE_TOPO_DEFINES #define topology_physical_package_id(cpu) (cpu_data(cpu).phys_proc_id) #define topology_core_id(cpu) (cpu_data(cpu).cpu_core_id) + +#ifdef ENABLE_TOPO_DEFINES #define topology_core_cpumask(cpu) (per_cpu(cpu_core_map, cpu)) #define topology_thread_cpumask(cpu) (per_cpu(cpu_sibling_map, cpu)) diff --git a/drivers/input/mouse/synaptics.c b/drivers/input/mouse/synaptics.c index e2c2e1e2bd6f..c1f7e9b65088 100644 --- a/drivers/input/mouse/synaptics.c +++ b/drivers/input/mouse/synaptics.c @@ -232,11 +232,22 @@ static int synaptics_identify(struct psmouse *psmouse) * Read touchpad resolution and maximum reported coordinates * Resolution is left zero if touchpad does not support the query */ + +static const int *quirk_min_max; + static int synaptics_resolution(struct psmouse *psmouse) { struct synaptics_data *priv = psmouse->private; unsigned char resp[3]; + if (quirk_min_max) { + priv->x_min = quirk_min_max[0]; + priv->x_max = quirk_min_max[1]; + priv->y_min = quirk_min_max[2]; + priv->y_max = quirk_min_max[3]; + return 0; + } + if (SYN_ID_MAJOR(priv->identity) < 4) return 0; @@ -1412,10 +1423,54 @@ static const struct dmi_system_id __initconst olpc_dmi_table[] = { { } }; +static const struct dmi_system_id min_max_dmi_table[] __initconst = { +#if defined(CONFIG_DMI) + { + /* Lenovo ThinkPad Helix */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), + DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad Helix"), + }, + .driver_data = (int []){1024, 5052, 2258, 4832}, + }, + { + /* Lenovo ThinkPad X240 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), + DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad X240"), + }, + .driver_data = (int []){1232, 5710, 1156, 4696}, + }, + { + /* Lenovo ThinkPad T440s */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), + DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T440"), + }, + .driver_data = (int []){1024, 5112, 2024, 4832}, + }, + { + /* Lenovo ThinkPad T540p */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), + DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T540"), + }, + .driver_data = (int []){1024, 5056, 2058, 4832}, + }, +#endif + { } +}; + void __init synaptics_module_init(void) { + const struct dmi_system_id *min_max_dmi; + impaired_toshiba_kbc = dmi_check_system(toshiba_dmi_table); broken_olpc_ec = dmi_check_system(olpc_dmi_table); + + min_max_dmi = dmi_first_match(min_max_dmi_table); + if (min_max_dmi) + quirk_min_max = min_max_dmi->driver_data; } static int __synaptics_init(struct psmouse *psmouse, bool absolute_mode) diff --git a/drivers/staging/speakup/i18n.c b/drivers/staging/speakup/i18n.c index c2119433f333..7656014c7bdd 100644 --- a/drivers/staging/speakup/i18n.c +++ b/drivers/staging/speakup/i18n.c @@ -390,7 +390,7 @@ static struct msg_group_t all_groups[] = { static const int num_groups = sizeof(all_groups) / sizeof(struct msg_group_t); -char *msg_get(enum msg_index_t index) +char *spk_msg_get(enum msg_index_t index) { char *ch; @@ -540,7 +540,7 @@ static int fmt_validate(char *template, char *user) * -EINVAL - Invalid format specifiers in formatted message or illegal index. * -ENOMEM - Unable to allocate memory. */ -ssize_t msg_set(enum msg_index_t index, char *text, size_t length) +ssize_t spk_msg_set(enum msg_index_t index, char *text, size_t length) { int rc = 0; char *newstr = NULL; @@ -575,7 +575,7 @@ ssize_t msg_set(enum msg_index_t index, char *text, size_t length) * Find a message group, given its name. Return a pointer to the structure * if found, or NULL otherwise. */ -struct msg_group_t *find_msg_group(const char *group_name) +struct msg_group_t *spk_find_msg_group(const char *group_name) { struct msg_group_t *group = NULL; int i; @@ -589,7 +589,7 @@ struct msg_group_t *find_msg_group(const char *group_name) return group; } -void reset_msg_group(struct msg_group_t *group) +void spk_reset_msg_group(struct msg_group_t *group) { unsigned long flags; enum msg_index_t i; @@ -605,14 +605,14 @@ void reset_msg_group(struct msg_group_t *group) } /* Called at initialization time, to establish default messages. */ -void initialize_msgs(void) +void spk_initialize_msgs(void) { memcpy(speakup_msgs, speakup_default_msgs, sizeof(speakup_default_msgs)); } /* Free user-supplied strings when module is unloaded: */ -void free_user_msgs(void) +void spk_free_user_msgs(void) { enum msg_index_t index; unsigned long flags; diff --git a/drivers/staging/speakup/i18n.h b/drivers/staging/speakup/i18n.h index 65caa8010776..dd338f4218de 100644 --- a/drivers/staging/speakup/i18n.h +++ b/drivers/staging/speakup/i18n.h @@ -218,11 +218,11 @@ struct msg_group_t { enum msg_index_t end; }; -extern char *msg_get(enum msg_index_t index); -extern ssize_t msg_set(enum msg_index_t index, char *text, size_t length); -extern struct msg_group_t *find_msg_group(const char *group_name); -extern void reset_msg_group(struct msg_group_t *group); -extern void initialize_msgs(void); -extern void free_user_msgs(void); +extern char *spk_msg_get(enum msg_index_t index); +extern ssize_t spk_msg_set(enum msg_index_t index, char *text, size_t length); +extern struct msg_group_t *spk_find_msg_group(const char *group_name); +extern void spk_reset_msg_group(struct msg_group_t *group); +extern void spk_initialize_msgs(void); +extern void spk_free_user_msgs(void); #endif diff --git a/drivers/staging/speakup/keyhelp.c b/drivers/staging/speakup/keyhelp.c index 170f38815ffd..4c584ecbd1fa 100644 --- a/drivers/staging/speakup/keyhelp.c +++ b/drivers/staging/speakup/keyhelp.c @@ -115,10 +115,10 @@ static void say_key(int key) key &= 0xff; for (i = 0; i < 6; i++) { if (state & masks[i]) - synth_printf(" %s", msg_get(MSG_STATES_START + i)); + synth_printf(" %s", spk_msg_get(MSG_STATES_START + i)); } if ((key > 0) && (key <= num_key_names)) - synth_printf(" %s\n", msg_get(MSG_KEYNAMES_START + (key - 1))); + synth_printf(" %s\n", spk_msg_get(MSG_KEYNAMES_START + (key - 1))); } static int help_init(void) @@ -126,9 +126,9 @@ static int help_init(void) char start = SPACE; int i; int num_funcs = MSG_FUNCNAMES_END - MSG_FUNCNAMES_START + 1; -state_tbl = our_keys[0]+SHIFT_TBL_SIZE+2; +state_tbl = spk_our_keys[0]+SHIFT_TBL_SIZE+2; for (i = 0; i < num_funcs; i++) { - char *cur_funcname = msg_get(MSG_FUNCNAMES_START + i); + char *cur_funcname = spk_msg_get(MSG_FUNCNAMES_START + i); if (start == *cur_funcname) continue; start = *cur_funcname; @@ -137,7 +137,7 @@ state_tbl = our_keys[0]+SHIFT_TBL_SIZE+2; return 0; } -int handle_help(struct vc_data *vc, u_char type, u_char ch, u_short key) +int spk_handle_help(struct vc_data *vc, u_char type, u_char ch, u_short key) { int i, n; char *name; @@ -147,15 +147,15 @@ int handle_help(struct vc_data *vc, u_char type, u_char ch, u_short key) help_init(); if (type == KT_LATIN) { if (ch == SPACE) { - special_handler = NULL; - synth_printf("%s\n", msg_get(MSG_LEAVING_HELP)); + spk_special_handler = NULL; + synth_printf("%s\n", spk_msg_get(MSG_LEAVING_HELP)); return 1; } ch |= 32; /* lower case */ if (ch < 'a' || ch > 'z') return -1; if (letter_offsets[ch-'a'] == -1) { - synth_printf(msg_get(MSG_NO_COMMAND), ch); + synth_printf(spk_msg_get(MSG_NO_COMMAND), ch); synth_printf("\n"); return 1; } @@ -169,47 +169,47 @@ int handle_help(struct vc_data *vc, u_char type, u_char ch, u_short key) cur_item--; else return -1; - } else if (type == KT_SPKUP && ch == SPEAKUP_HELP && !special_handler) { - special_handler = handle_help; - synth_printf("%s\n", msg_get(MSG_HELP_INFO)); + } else if (type == KT_SPKUP && ch == SPEAKUP_HELP && !spk_special_handler) { + spk_special_handler = spk_handle_help; + synth_printf("%s\n", spk_msg_get(MSG_HELP_INFO)); build_key_data(); /* rebuild each time in case new mapping */ return 1; } else { name = NULL; if ((type != KT_SPKUP) && (key > 0) && (key <= num_key_names)) { synth_printf("%s\n", - msg_get(MSG_KEYNAMES_START + key-1)); + spk_msg_get(MSG_KEYNAMES_START + key-1)); return 1; } for (i = 0; funcvals[i] != 0 && !name; i++) { if (ch == funcvals[i]) - name = msg_get(MSG_FUNCNAMES_START + i); + name = spk_msg_get(MSG_FUNCNAMES_START + i); } if (!name) return -1; - kp = our_keys[key]+1; + kp = spk_our_keys[key]+1; for (i = 0; i < nstates; i++) { if (ch == kp[i]) break; } key += (state_tbl[i] << 8); say_key(key); - synth_printf(msg_get(MSG_KEYDESC), name); + synth_printf(spk_msg_get(MSG_KEYDESC), name); synth_printf("\n"); return 1; } - name = msg_get(MSG_FUNCNAMES_START + cur_item); + name = spk_msg_get(MSG_FUNCNAMES_START + cur_item); func = funcvals[cur_item]; synth_printf("%s", name); if (key_offsets[func] == 0) { - synth_printf(" %s\n", msg_get(MSG_IS_UNASSIGNED)); + synth_printf(" %s\n", spk_msg_get(MSG_IS_UNASSIGNED)); return 1; } p_keys = key_data + key_offsets[func]; for (n = 0; p_keys[n]; n++) { val = p_keys[n]; if (n > 0) - synth_printf("%s ", msg_get(MSG_DISJUNCTION)); + synth_printf("%s ", spk_msg_get(MSG_DISJUNCTION)); say_key(val); } return 1; diff --git a/drivers/staging/speakup/kobjects.c b/drivers/staging/speakup/kobjects.c index 2093896c546b..86387f48b30c 100644 --- a/drivers/staging/speakup/kobjects.c +++ b/drivers/staging/speakup/kobjects.c @@ -41,7 +41,7 @@ static ssize_t chars_chartab_show(struct kobject *kobj, break; if (strcmp("characters", attr->attr.name) == 0) { len = scnprintf(buf_pointer, bufsize, "%d\t%s\n", - i, characters[i]); + i, spk_characters[i]); } else { /* show chartab entry */ if (IS_TYPE(i, B_CTL)) cp = "B_CTL"; @@ -185,12 +185,12 @@ static ssize_t chars_chartab_store(struct kobject *kobj, outptr[desc_length] = '\0'; if (do_characters) { - if (characters[index] != default_chars[index]) - kfree(characters[index]); - characters[index] = desc; + if (spk_characters[index] != spk_default_chars[index]) + kfree(spk_characters[index]); + spk_characters[index] = desc; used++; } else { - charclass = chartab_get_value(keyword); + charclass = spk_chartab_get_value(keyword); if (charclass == 0) { rejected++; cp = linefeed + 1; @@ -206,9 +206,9 @@ static ssize_t chars_chartab_store(struct kobject *kobj, if (reset) { if (do_characters) - reset_default_chars(); + spk_reset_default_chars(); else - reset_default_chartab(); + spk_reset_default_chartab(); } spk_unlock(flags); @@ -232,7 +232,7 @@ static ssize_t keymap_show(struct kobject *kobj, struct kobj_attribute *attr, u_char ch; unsigned long flags; spk_lock(flags); - cp1 = key_buf + SHIFT_TBL_SIZE; + cp1 = spk_key_buf + SHIFT_TBL_SIZE; num_keys = (int)(*cp1); nstates = (int)cp1[1]; cp += sprintf(cp, "%d, %d, %d,\n", KEY_MAP_VER, num_keys, nstates); @@ -271,7 +271,7 @@ static ssize_t keymap_store(struct kobject *kobj, struct kobj_attribute *attr, return -ENOMEM; } if (strchr("dDrR", *in_buff)) { - set_key_info(key_defaults, key_buf); + spk_set_key_info(spk_key_defaults, spk_key_buf); pr_info("keymap set to default values\n"); kfree(in_buff); spk_unlock(flags); @@ -282,14 +282,14 @@ static ssize_t keymap_store(struct kobject *kobj, struct kobj_attribute *attr, cp = in_buff; cp1 = (u_char *)in_buff; for (i = 0; i < 3; i++) { - cp = s2uchar(cp, cp1); + cp = spk_s2uchar(cp, cp1); cp1++; } i = (int)cp1[-2]+1; i *= (int)cp1[-1]+1; i += 2; /* 0 and last map ver */ if (cp1[-3] != KEY_MAP_VER || cp1[-1] > 10 || - i+SHIFT_TBL_SIZE+4 >= sizeof(key_buf)) { + i+SHIFT_TBL_SIZE+4 >= sizeof(spk_key_buf)) { pr_warn("i %d %d %d %d\n", i, (int)cp1[-3], (int)cp1[-2], (int)cp1[-1]); kfree(in_buff); @@ -297,7 +297,7 @@ static ssize_t keymap_store(struct kobject *kobj, struct kobj_attribute *attr, return -EINVAL; } while (--i >= 0) { - cp = s2uchar(cp, cp1); + cp = spk_s2uchar(cp, cp1); cp1++; if (!(*cp)) break; @@ -307,8 +307,8 @@ static ssize_t keymap_store(struct kobject *kobj, struct kobj_attribute *attr, pr_warn("end %d %d %d %d\n", i, (int)cp1[-3], (int)cp1[-2], (int)cp1[-1]); } else { - if (set_key_info(in_buff, key_buf)) { - set_key_info(key_defaults, key_buf); + if (spk_set_key_info(in_buff, spk_key_buf)) { + spk_set_key_info(spk_key_defaults, spk_key_buf); ret = -EINVAL; pr_warn("set key failed\n"); } @@ -343,7 +343,7 @@ static ssize_t silent_store(struct kobject *kobj, struct kobj_attribute *attr, spk_lock(flags); if (ch&2) { shut = 1; - do_flush(); + spk_do_flush(); } else { shut = 0; } @@ -388,7 +388,7 @@ static ssize_t synth_store(struct kobject *kobj, struct kobj_attribute *attr, if (new_synth_name[len - 1] == '\n') len--; new_synth_name[len] = '\0'; - strlwr(new_synth_name); + spk_strlwr(new_synth_name); if ((synth != NULL) && (!strcmp(new_synth_name, synth->name))) { pr_warn("%s already in use\n", new_synth_name); } else if (synth_init(new_synth_name) != 0) { @@ -417,7 +417,7 @@ static ssize_t synth_direct_store(struct kobject *kobj, bytes = min_t(size_t, len, 250); strncpy(tmp, ptr, bytes); tmp[bytes] = '\0'; - xlate(tmp); + spk_xlate(tmp); synth_printf("%s", tmp); ptr += bytes; len -= bytes; @@ -455,14 +455,14 @@ static ssize_t punc_show(struct kobject *kobj, struct kobj_attribute *attr, short mask; unsigned long flags; - p_header = var_header_by_name(attr->attr.name); + p_header = spk_var_header_by_name(attr->attr.name); if (p_header == NULL) { pr_warn("p_header is null, attr->attr.name is %s\n", attr->attr.name); return -EINVAL; } - var = get_punc_var(p_header->var_id); + var = spk_get_punc_var(p_header->var_id); if (var == NULL) { pr_warn("var is null, p_header->var_id is %i\n", p_header->var_id); @@ -470,7 +470,7 @@ static ssize_t punc_show(struct kobject *kobj, struct kobj_attribute *attr, } spk_lock(flags); - pb = (struct st_bits_data *) &punc_info[var->value]; + pb = (struct st_bits_data *) &spk_punc_info[var->value]; mask = pb->mask; for (i = 33; i < 128; i++) { if (!(spk_chartab[i]&mask)) @@ -497,14 +497,14 @@ static ssize_t punc_store(struct kobject *kobj, struct kobj_attribute *attr, if (x < 1 || x > 99) return -EINVAL; - p_header = var_header_by_name(attr->attr.name); + p_header = spk_var_header_by_name(attr->attr.name); if (p_header == NULL) { pr_warn("p_header is null, attr->attr.name is %s\n", attr->attr.name); return -EINVAL; } - var = get_punc_var(p_header->var_id); + var = spk_get_punc_var(p_header->var_id); if (var == NULL) { pr_warn("var is null, p_header->var_id is %i\n", p_header->var_id); @@ -520,9 +520,9 @@ static ssize_t punc_store(struct kobject *kobj, struct kobj_attribute *attr, spk_lock(flags); if (*punc_buf == 'd' || *punc_buf == 'r') - x = set_mask_bits(0, var->value, 3); + x = spk_set_mask_bits(0, var->value, 3); else - x = set_mask_bits(punc_buf, var->value, 3); + x = spk_set_mask_bits(punc_buf, var->value, 3); spk_unlock(flags); return count; @@ -542,7 +542,7 @@ ssize_t spk_var_show(struct kobject *kobj, struct kobj_attribute *attr, char ch; unsigned long flags; - param = var_header_by_name(attr->attr.name); + param = spk_var_header_by_name(attr->attr.name); if (param == NULL) return -EINVAL; @@ -599,13 +599,13 @@ ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr, int value; unsigned long flags; - param = var_header_by_name(attr->attr.name); + param = spk_var_header_by_name(attr->attr.name); if (param == NULL) return -EINVAL; if (param->data == NULL) return 0; ret = 0; - cp = xlate((char *) buf); + cp = spk_xlate((char *) buf); spk_lock(flags); switch (param->var_type) { @@ -618,7 +618,7 @@ ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr, else len = E_SET; speakup_s2i(cp, &value); - ret = set_num_var(value, param, len); + ret = spk_set_num_var(value, param, len); if (ret == E_RANGE) { var_data = param->data; pr_warn("value for %s out of range, expect %d to %d\n", @@ -636,7 +636,7 @@ ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr, } cp = (char *) buf; cp[len] = '\0'; - ret = set_string_var(buf, param, len); + ret = spk_set_string_var(buf, param, len); if (ret == E_TOOLONG) pr_warn("value too long for %s\n", attr->attr.name); @@ -652,19 +652,19 @@ ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr, */ if (strcmp(attr->attr.name, "voice") == 0) { if (synth && synth->default_pitch) { - param = var_header_by_name("pitch"); + param = spk_var_header_by_name("pitch"); if (param) { - set_num_var(synth->default_pitch[value], param, + spk_set_num_var(synth->default_pitch[value], param, E_NEW_DEFAULT); - set_num_var(0, param, E_DEFAULT); + spk_set_num_var(0, param, E_DEFAULT); } } if (synth && synth->default_vol) { - param = var_header_by_name("vol"); + param = spk_var_header_by_name("vol"); if (param) { - set_num_var(synth->default_vol[value], param, + spk_set_num_var(synth->default_vol[value], param, E_NEW_DEFAULT); - set_num_var(0, param, E_DEFAULT); + spk_set_num_var(0, param, E_DEFAULT); } } } @@ -694,7 +694,7 @@ static ssize_t message_show_helper(char *buf, enum msg_index_t first, if (bufsize <= 1) break; printed = scnprintf(buf_pointer, bufsize, "%d\t%s\n", - index, msg_get(cursor)); + index, spk_msg_get(cursor)); buf_pointer += printed; bufsize -= printed; } @@ -788,7 +788,7 @@ static ssize_t message_store_helper(const char *buf, size_t count, continue; } - msg_stored = msg_set(curmessage, temp, desc_length); + msg_stored = spk_msg_set(curmessage, temp, desc_length); if (msg_stored < 0) { retval = msg_stored; if (msg_stored == -ENOMEM) @@ -802,7 +802,7 @@ static ssize_t message_store_helper(const char *buf, size_t count, } if (reset) - reset_msg_group(group); + spk_reset_msg_group(group); report_msg_status(reset, received, used, rejected, group->name); return retval; @@ -812,7 +812,7 @@ static ssize_t message_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf) { ssize_t retval = 0; - struct msg_group_t *group = find_msg_group(attr->attr.name); + struct msg_group_t *group = spk_find_msg_group(attr->attr.name); unsigned long flags; BUG_ON(!group); @@ -826,7 +826,7 @@ static ssize_t message_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count) { ssize_t retval = 0; - struct msg_group_t *group = find_msg_group(attr->attr.name); + struct msg_group_t *group = spk_find_msg_group(attr->attr.name); BUG_ON(!group); retval = message_store_helper(buf, count, group); diff --git a/drivers/staging/speakup/main.c b/drivers/staging/speakup/main.c index 40e2488b9679..463d125ee77b 100644 --- a/drivers/staging/speakup/main.c +++ b/drivers/staging/speakup/main.c @@ -65,23 +65,23 @@ MODULE_VERSION(SPEAKUP_VERSION); char *synth_name; module_param_named(synth, synth_name, charp, S_IRUGO); -module_param_named(quiet, quiet_boot, bool, S_IRUGO); +module_param_named(quiet, spk_quiet_boot, bool, S_IRUGO); MODULE_PARM_DESC(synth, "Synth to start if speakup is built in."); MODULE_PARM_DESC(quiet, "Do not announce when the synthesizer is found."); -special_func special_handler; +special_func spk_special_handler; -short pitch_shift, synth_flags; +short spk_pitch_shift, synth_flags; static char buf[256]; -int attrib_bleep, bleeps, bleep_time = 10; -int no_intr, spell_delay; -int key_echo, say_word_ctl; -int say_ctrl, bell_pos; -short punc_mask; -int punc_level, reading_punc; -char str_caps_start[MAXVARLEN + 1] = "\0", str_caps_stop[MAXVARLEN + 1] = "\0"; -const struct st_bits_data punc_info[] = { +int spk_attrib_bleep, spk_bleeps, spk_bleep_time = 10; +int spk_no_intr, spk_spell_delay; +int spk_key_echo, spk_say_word_ctl; +int spk_say_ctrl, spk_bell_pos; +short spk_punc_mask; +int spk_punc_level, spk_reading_punc; +char spk_str_caps_start[MAXVARLEN + 1] = "\0", spk_str_caps_stop[MAXVARLEN + 1] = "\0"; +const struct st_bits_data spk_punc_info[] = { {"none", "", 0}, {"some", "/$%&@", SOME}, {"most", "$%&#()=+*/@^<>|\\", MOST}, @@ -95,9 +95,9 @@ const struct st_bits_data punc_info[] = { static char mark_cut_flag; #define MAX_KEY 160 -u_char *our_keys[MAX_KEY], *shift_table; -u_char key_buf[600]; -const u_char key_defaults[] = { +u_char *spk_our_keys[MAX_KEY], *spk_shift_table; +u_char spk_key_buf[600]; +const u_char spk_key_defaults[] = { #include "speakupmap.h" }; @@ -129,9 +129,9 @@ static char *phonetic[] = { /* array of 256 char pointers (one for each character description) * initialized to default_chars and user selectable via * /proc/speakup/characters */ -char *characters[256]; +char *spk_characters[256]; -char *default_chars[256] = { +char *spk_default_chars[256] = { /*000*/ "null", "^a", "^b", "^c", "^d", "^e", "^f", "^g", /*008*/ "^h", "^i", "^j", "^k", "^l", "^m", "^n", "^o", /*016*/ "^p", "^q", "^r", "^s", "^t", "^u", "^v", "^w", @@ -238,7 +238,7 @@ static u_short default_chartab[256] = { }; struct task_struct *speakup_task; -struct bleep unprocessed_sound; +struct bleep spk_unprocessed_sound; static int spk_keydown; static u_char spk_lastkey, spk_close_press, keymap_flags; static u_char last_keycode, this_speakup_key; @@ -282,13 +282,13 @@ static void bleep(u_short val) 350, 370, 392, 414, 440, 466, 491, 523, 554, 587, 619, 659 }; short freq; - int time = bleep_time; + int time = spk_bleep_time; freq = vals[val % 12]; if (val > 11) freq *= (1 << (val / 12)); - unprocessed_sound.freq = freq; - unprocessed_sound.jiffies = msecs_to_jiffies(time); - unprocessed_sound.active = 1; + spk_unprocessed_sound.freq = freq; + spk_unprocessed_sound.jiffies = msecs_to_jiffies(time); + spk_unprocessed_sound.active = 1; /* We can only have 1 active sound at a time. */ } @@ -300,7 +300,7 @@ static void speakup_shut_up(struct vc_data *vc) spk_parked &= 0xfe; speakup_date(vc); if (synth != NULL) - do_flush(); + spk_do_flush(); } static void speech_kill(struct vc_data *vc) @@ -313,9 +313,9 @@ static void speech_kill(struct vc_data *vc) if (val == 2 || spk_killed) { /* dead */ spk_shut_up &= ~0x40; - synth_printf("%s\n", msg_get(MSG_IAM_ALIVE)); + synth_printf("%s\n", spk_msg_get(MSG_IAM_ALIVE)); } else { - synth_printf("%s\n", msg_get(MSG_YOU_KILLED_SPEAKUP)); + synth_printf("%s\n", spk_msg_get(MSG_YOU_KILLED_SPEAKUP)); spk_shut_up |= 0x40; } } @@ -324,10 +324,10 @@ static void speakup_off(struct vc_data *vc) { if (spk_shut_up & 0x80) { spk_shut_up &= 0x7f; - synth_printf("%s\n", msg_get(MSG_HEY_THATS_BETTER)); + synth_printf("%s\n", spk_msg_get(MSG_HEY_THATS_BETTER)); } else { spk_shut_up |= 0x80; - synth_printf("%s\n", msg_get(MSG_YOU_TURNED_ME_OFF)); + synth_printf("%s\n", spk_msg_get(MSG_YOU_TURNED_ME_OFF)); } speakup_date(vc); } @@ -336,10 +336,10 @@ static void speakup_parked(struct vc_data *vc) { if (spk_parked & 0x80) { spk_parked = 0; - synth_printf("%s\n", msg_get(MSG_UNPARKED)); + synth_printf("%s\n", spk_msg_get(MSG_UNPARKED)); } else { spk_parked |= 0x80; - synth_printf("%s\n", msg_get(MSG_PARKED)); + synth_printf("%s\n", spk_msg_get(MSG_PARKED)); } } @@ -350,16 +350,16 @@ static void speakup_cut(struct vc_data *vc) if (!mark_cut_flag) { mark_cut_flag = 1; - xs = (u_short) spk_x; - ys = (u_short) spk_y; + spk_xs = (u_short) spk_x; + spk_ys = (u_short) spk_y; spk_sel_cons = vc; - synth_printf("%s\n", msg_get(MSG_MARK)); + synth_printf("%s\n", spk_msg_get(MSG_MARK)); return; } - xe = (u_short) spk_x; - ye = (u_short) spk_y; + spk_xe = (u_short) spk_x; + spk_ye = (u_short) spk_y; mark_cut_flag = 0; - synth_printf("%s\n", msg_get(MSG_CUT)); + synth_printf("%s\n", spk_msg_get(MSG_CUT)); speakup_clear_selection(); ret = speakup_set_selection(tty); @@ -383,9 +383,9 @@ static void speakup_paste(struct vc_data *vc) { if (mark_cut_flag) { mark_cut_flag = 0; - synth_printf("%s\n", msg_get(MSG_MARK_CLEARED)); + synth_printf("%s\n", spk_msg_get(MSG_MARK_CLEARED)); } else { - synth_printf("%s\n", msg_get(MSG_PASTE)); + synth_printf("%s\n", spk_msg_get(MSG_PASTE)); speakup_paste_selection(tty); } } @@ -395,16 +395,16 @@ static void say_attributes(struct vc_data *vc) int fg = spk_attr & 0x0f; int bg = spk_attr >> 4; if (fg > 8) { - synth_printf("%s ", msg_get(MSG_BRIGHT)); + synth_printf("%s ", spk_msg_get(MSG_BRIGHT)); fg -= 8; } - synth_printf("%s", msg_get(MSG_COLORS_START + fg)); + synth_printf("%s", spk_msg_get(MSG_COLORS_START + fg)); if (bg > 7) { - synth_printf(" %s ", msg_get(MSG_ON_BLINKING)); + synth_printf(" %s ", spk_msg_get(MSG_ON_BLINKING)); bg -= 8; } else - synth_printf(" %s ", msg_get(MSG_ON)); - synth_printf("%s\n", msg_get(MSG_COLORS_START + bg)); + synth_printf(" %s ", spk_msg_get(MSG_ON)); + synth_printf("%s\n", spk_msg_get(MSG_COLORS_START + bg)); } enum { @@ -417,24 +417,24 @@ enum { static void announce_edge(struct vc_data *vc, int msg_id) { - if (bleeps & 1) + if (spk_bleeps & 1) bleep(spk_y); - if ((bleeps & 2) && (msg_id < edge_quiet)) - synth_printf("%s\n", msg_get(MSG_EDGE_MSGS_START + msg_id - 1)); + if ((spk_bleeps & 2) && (msg_id < edge_quiet)) + synth_printf("%s\n", spk_msg_get(MSG_EDGE_MSGS_START + msg_id - 1)); } static void speak_char(u_char ch) { - char *cp = characters[ch]; - struct var_t *direct = get_var(DIRECT); + char *cp = spk_characters[ch]; + struct var_t *direct = spk_get_var(DIRECT); if (direct && direct->u.n.value) { if (IS_CHAR(ch, B_CAP)) { - pitch_shift++; - synth_printf("%s", str_caps_start); + spk_pitch_shift++; + synth_printf("%s", spk_str_caps_start); } synth_printf("%c", ch); if (IS_CHAR(ch, B_CAP)) - synth_printf("%s", str_caps_stop); + synth_printf("%s", spk_str_caps_stop); return; } if (cp == NULL) { @@ -443,13 +443,13 @@ static void speak_char(u_char ch) } synth_buffer_add(SPACE); if (IS_CHAR(ch, B_CAP)) { - pitch_shift++; - synth_printf("%s", str_caps_start); + spk_pitch_shift++; + synth_printf("%s", spk_str_caps_start); synth_printf("%s", cp); - synth_printf("%s", str_caps_stop); + synth_printf("%s", spk_str_caps_stop); } else { if (*cp == '^') { - synth_printf("%s", msg_get(MSG_CTRL)); + synth_printf("%s", spk_msg_get(MSG_CTRL)); cp++; } synth_printf("%s", cp); @@ -479,9 +479,9 @@ static void say_char(struct vc_data *vc) spk_old_attr = spk_attr; ch = get_char(vc, (u_short *) spk_pos, &spk_attr); if (spk_attr != spk_old_attr) { - if (attrib_bleep & 1) + if (spk_attrib_bleep & 1) bleep(spk_y); - if (attrib_bleep & 2) + if (spk_attrib_bleep & 2) say_attributes(vc); } speak_char(ch & 0xff); @@ -497,7 +497,7 @@ static void say_phonetic_char(struct vc_data *vc) synth_printf("%s\n", phonetic[--ch]); } else { if (IS_CHAR(ch, B_NUM)) - synth_printf("%s ", msg_get(MSG_NUMBER)); + synth_printf("%s ", spk_msg_get(MSG_NUMBER)); speak_char(ch); } } @@ -527,8 +527,8 @@ static void say_next_char(struct vc_data *vc) } /* get_word - will first check to see if the character under the - * reading cursor is a space and if say_word_ctl is true it will - * return the word space. If say_word_ctl is not set it will check to + * reading cursor is a space and if spk_say_word_ctl is true it will + * return the word space. If spk_say_word_ctl is not set it will check to * see if there is a word starting on the next position to the right * and return that word if it exists. If it does not exist it will * move left to the beginning of any previous word on the line or the @@ -544,9 +544,9 @@ static u_long get_word(struct vc_data *vc) ch = (char)get_char(vc, (u_short *) tmp_pos, &temp); /* decided to take out the sayword if on a space (mis-information */ - if (say_word_ctl && ch == SPACE) { + if (spk_say_word_ctl && ch == SPACE) { *buf = '\0'; - synth_printf("%s\n", msg_get(MSG_SPACE)); + synth_printf("%s\n", spk_msg_get(MSG_SPACE)); return 0; } else if ((tmpx < vc->vc_cols - 2) && (ch == SPACE || ch == 0 || IS_WDLM(ch)) @@ -582,13 +582,13 @@ static u_long get_word(struct vc_data *vc) static void say_word(struct vc_data *vc) { u_long cnt = get_word(vc); - u_short saved_punc_mask = punc_mask; + u_short saved_punc_mask = spk_punc_mask; if (cnt == 0) return; - punc_mask = PUNC; + spk_punc_mask = PUNC; buf[cnt++] = SPACE; spkup_write(buf, cnt); - punc_mask = saved_punc_mask; + spk_punc_mask = saved_punc_mask; } static void say_prev_word(struct vc_data *vc) @@ -686,22 +686,22 @@ static void say_next_word(struct vc_data *vc) static void spell_word(struct vc_data *vc) { static char *delay_str[] = { "", ",", ".", ". .", ". . ." }; - char *cp = buf, *str_cap = str_caps_stop; - char *cp1, *last_cap = str_caps_stop; + char *cp = buf, *str_cap = spk_str_caps_stop; + char *cp1, *last_cap = spk_str_caps_stop; u_char ch; if (!get_word(vc)) return; while ((ch = (u_char) *cp)) { if (cp != buf) - synth_printf(" %s ", delay_str[spell_delay]); + synth_printf(" %s ", delay_str[spk_spell_delay]); if (IS_CHAR(ch, B_CAP)) { - str_cap = str_caps_start; - if (*str_caps_stop) - pitch_shift++; + str_cap = spk_str_caps_start; + if (*spk_str_caps_stop) + spk_pitch_shift++; else /* synth has no pitch */ - last_cap = str_caps_stop; + last_cap = spk_str_caps_stop; } else - str_cap = str_caps_stop; + str_cap = spk_str_caps_stop; if (str_cap != last_cap) { synth_printf("%s", str_cap); last_cap = str_cap; @@ -711,17 +711,17 @@ static void spell_word(struct vc_data *vc) ch &= 31; cp1 = phonetic[--ch]; } else { - cp1 = characters[ch]; + cp1 = spk_characters[ch]; if (*cp1 == '^') { - synth_printf("%s", msg_get(MSG_CTRL)); + synth_printf("%s", spk_msg_get(MSG_CTRL)); cp1++; } } synth_printf("%s", cp1); cp++; } - if (str_cap != str_caps_stop) - synth_printf("%s", str_caps_stop); + if (str_cap != spk_str_caps_stop) + synth_printf("%s", spk_str_caps_stop); } static int get_line(struct vc_data *vc) @@ -746,9 +746,9 @@ static void say_line(struct vc_data *vc) { int i = get_line(vc); char *cp; - u_short saved_punc_mask = punc_mask; + u_short saved_punc_mask = spk_punc_mask; if (i == 0) { - synth_printf("%s\n", msg_get(MSG_BLANK)); + synth_printf("%s\n", spk_msg_get(MSG_BLANK)); return; } buf[i++] = '\n'; @@ -758,9 +758,9 @@ static void say_line(struct vc_data *vc) cp++; synth_printf("%d, ", (cp - buf) + 1); } - punc_mask = punc_masks[reading_punc]; + spk_punc_mask = spk_punc_masks[spk_reading_punc]; spkup_write(buf, i); - punc_mask = saved_punc_mask; + spk_punc_mask = saved_punc_mask; } static void say_prev_line(struct vc_data *vc) @@ -792,7 +792,7 @@ static int say_from_to(struct vc_data *vc, u_long from, u_long to, { int i = 0; u_char tmp; - u_short saved_punc_mask = punc_mask; + u_short saved_punc_mask = spk_punc_mask; spk_old_attr = spk_attr; spk_attr = get_attributes((u_short *) from); while (from < to) { @@ -809,10 +809,10 @@ static int say_from_to(struct vc_data *vc, u_long from, u_long to, if (i < 1) return i; if (read_punc) - punc_mask = punc_info[reading_punc].mask; + spk_punc_mask = spk_punc_info[spk_reading_punc].mask; spkup_write(buf, i); if (read_punc) - punc_mask = saved_punc_mask; + spk_punc_mask = saved_punc_mask; return i - 1; } @@ -824,7 +824,7 @@ static void say_line_from_to(struct vc_data *vc, u_long from, u_long to, start += from * 2; if (say_from_to(vc, start, end, read_punc) <= 0) if (cursor_track != read_all_mode) - synth_printf("%s\n", msg_get(MSG_BLANK)); + synth_printf("%s\n", spk_msg_get(MSG_BLANK)); } /* Sentence Reading Commands */ @@ -924,7 +924,7 @@ static void speakup_win_say(struct vc_data *vc) { u_long start, end, from, to; if (win_start < 2) { - synth_printf("%s\n", msg_get(MSG_NO_WINDOW)); + synth_printf("%s\n", spk_msg_get(MSG_NO_WINDOW)); return; } start = vc->vc_origin + (win_top * vc->vc_size_row); @@ -975,7 +975,7 @@ static void say_first_char(struct vc_data *vc) u_char ch; spk_parked |= 0x01; if (len == 0) { - synth_printf("%s\n", msg_get(MSG_BLANK)); + synth_printf("%s\n", spk_msg_get(MSG_BLANK)); return; } for (i = 0; i < len; i++) @@ -994,7 +994,7 @@ static void say_last_char(struct vc_data *vc) u_char ch; spk_parked |= 0x01; if (len == 0) { - synth_printf("%s\n", msg_get(MSG_BLANK)); + synth_printf("%s\n", spk_msg_get(MSG_BLANK)); return; } ch = buf[--len]; @@ -1006,7 +1006,7 @@ static void say_last_char(struct vc_data *vc) static void say_position(struct vc_data *vc) { - synth_printf(msg_get(MSG_POS_INFO), spk_y + 1, spk_x + 1, + synth_printf(spk_msg_get(MSG_POS_INFO), spk_y + 1, spk_x + 1, vc->vc_num + 1); synth_printf("\n"); } @@ -1017,7 +1017,7 @@ static void say_char_num(struct vc_data *vc) u_char tmp; u_short ch = get_char(vc, (u_short *) spk_pos, &tmp); ch &= 0xff; - synth_printf(msg_get(MSG_CHAR_INFO), ch, ch); + synth_printf(spk_msg_get(MSG_CHAR_INFO), ch, ch); } /* these are stub functions to keep keyboard.c happy. */ @@ -1066,7 +1066,7 @@ static void spkup_write(const char *in_buf, int count) } else { if ((last_type & CH_RPT) && rep_count > 2) { synth_printf(" "); - synth_printf(msg_get(MSG_REPEAT_DESC), + synth_printf(spk_msg_get(MSG_REPEAT_DESC), ++rep_count); synth_printf(" "); } @@ -1074,7 +1074,7 @@ static void spkup_write(const char *in_buf, int count) } if (ch == spk_lastkey) { rep_count = 0; - if (key_echo == 1 && ch >= MINECHOCHAR) + if (spk_key_echo == 1 && ch >= MINECHOCHAR) speak_char(ch); } else if (char_type & B_ALPHA) { if ((synth_flags & SF_DEC) && (last_type & PUNC)) @@ -1083,7 +1083,7 @@ static void spkup_write(const char *in_buf, int count) } else if (char_type & B_NUM) { rep_count = 0; synth_printf("%c", ch); - } else if (char_type & punc_mask) { + } else if (char_type & spk_punc_mask) { speak_char(ch); char_type &= ~PUNC; /* for dec nospell processing */ } else if (char_type & SYNTH_OK) { @@ -1111,7 +1111,7 @@ static void spkup_write(const char *in_buf, int count) if (in_count > 2 && rep_count > 2) { if (last_type & CH_RPT) { synth_printf(" "); - synth_printf(msg_get(MSG_REPEAT_DESC2), ++rep_count); + synth_printf(spk_msg_get(MSG_REPEAT_DESC2), ++rep_count); synth_printf(" "); } rep_count = 0; @@ -1135,22 +1135,22 @@ static void do_handle_shift(struct vc_data *vc, u_char value, char up_flag) case KVAL(K_SHIFT): del_timer(&cursor_timer); spk_shut_up &= 0xfe; - do_flush(); + spk_do_flush(); read_all_doc(vc); break; case KVAL(K_CTRL): del_timer(&cursor_timer); cursor_track = prev_cursor_track; spk_shut_up &= 0xfe; - do_flush(); + spk_do_flush(); break; } } else { spk_shut_up &= 0xfe; - do_flush(); + spk_do_flush(); } - if (say_ctrl && value < NUM_CTL_LABELS) - synth_printf("%s", msg_get(MSG_CTL_START + value)); + if (spk_say_ctrl && value < NUM_CTL_LABELS) + synth_printf("%s", spk_msg_get(MSG_CTL_START + value)); spk_unlock(flags); } @@ -1171,12 +1171,12 @@ static void do_handle_latin(struct vc_data *vc, u_char value, char up_flag) spk_lastkey = value; spk_keydown++; spk_parked &= 0xfe; - if (key_echo == 2 && value >= MINECHOCHAR) + if (spk_key_echo == 2 && value >= MINECHOCHAR) speak_char(value); spk_unlock(flags); } -int set_key_info(const u_char *key_info, u_char *k_buffer) +int spk_set_key_info(const u_char *key_info, u_char *k_buffer) { int i = 0, states, key_data_len; const u_char *cp = key_info; @@ -1188,12 +1188,12 @@ int set_key_info(const u_char *key_info, u_char *k_buffer) num_keys = *cp; states = (int)cp[1]; key_data_len = (states + 1) * (num_keys + 1); - if (key_data_len + SHIFT_TBL_SIZE + 4 >= sizeof(key_buf)) + if (key_data_len + SHIFT_TBL_SIZE + 4 >= sizeof(spk_key_buf)) return -2; memset(k_buffer, 0, SHIFT_TBL_SIZE); - memset(our_keys, 0, sizeof(our_keys)); - shift_table = k_buffer; - our_keys[0] = shift_table; + memset(spk_our_keys, 0, sizeof(spk_our_keys)); + spk_shift_table = k_buffer; + spk_our_keys[0] = spk_shift_table; cp1 += SHIFT_TBL_SIZE; memcpy(cp1, cp, key_data_len + 3); /* get num_keys, states and data */ @@ -1202,13 +1202,13 @@ int set_key_info(const u_char *key_info, u_char *k_buffer) ch = *cp1++; if (ch >= SHIFT_TBL_SIZE) return -3; - shift_table[ch] = i; + spk_shift_table[ch] = i; } keymap_flags = *cp1++; while ((ch = *cp1)) { if (ch >= MAX_KEY) return -4; - our_keys[ch] = cp1; + spk_our_keys[ch] = cp1; cp1 += states + 1; } return 0; @@ -1237,24 +1237,24 @@ static void toggle_cursoring(struct vc_data *vc) cursor_track = prev_cursor_track; if (++cursor_track >= CT_Max) cursor_track = 0; - synth_printf("%s\n", msg_get(MSG_CURSOR_MSGS_START + cursor_track)); + synth_printf("%s\n", spk_msg_get(MSG_CURSOR_MSGS_START + cursor_track)); } -void reset_default_chars(void) +void spk_reset_default_chars(void) { int i; /* First, free any non-default */ for (i = 0; i < 256; i++) { - if ((characters[i] != NULL) - && (characters[i] != default_chars[i])) - kfree(characters[i]); + if ((spk_characters[i] != NULL) + && (spk_characters[i] != spk_default_chars[i])) + kfree(spk_characters[i]); } - memcpy(characters, default_chars, sizeof(default_chars)); + memcpy(spk_characters, spk_default_chars, sizeof(spk_default_chars)); } -void reset_default_chartab(void) +void spk_reset_default_chartab(void) { memcpy(spk_chartab, default_chartab, sizeof(default_chartab)); } @@ -1267,8 +1267,8 @@ static int edit_bits(struct vc_data *vc, u_char type, u_char ch, u_short key) if (type != KT_LATIN || (ch_type & B_NUM) || ch < SPACE) return -1; if (ch == SPACE) { - synth_printf("%s\n", msg_get(MSG_EDIT_DONE)); - special_handler = NULL; + synth_printf("%s\n", spk_msg_get(MSG_EDIT_DONE)); + spk_special_handler = NULL; return 1; } if (mask < PUNC && !(ch_type & PUNC)) @@ -1276,8 +1276,8 @@ static int edit_bits(struct vc_data *vc, u_char type, u_char ch, u_short key) spk_chartab[ch] ^= mask; speak_char(ch); synth_printf(" %s\n", - (spk_chartab[ch] & mask) ? msg_get(MSG_ON) : - msg_get(MSG_OFF)); + (spk_chartab[ch] & mask) ? spk_msg_get(MSG_ON) : + spk_msg_get(MSG_OFF)); return 1; } @@ -1346,7 +1346,7 @@ static void read_all_doc(struct vc_data *vc) if (cursor_track != read_all_mode) prev_cursor_track = cursor_track; cursor_track = read_all_mode; - reset_index_count(0); + spk_reset_index_count(0); if (get_sentence_buf(vc, 0) == -1) kbd_fakekey2(vc, RA_DOWN_ARROW); else { @@ -1361,7 +1361,7 @@ static void stop_read_all(struct vc_data *vc) del_timer(&cursor_timer); cursor_track = prev_cursor_track; spk_shut_up &= 0xfe; - do_flush(); + spk_do_flush(); } static void start_read_all_timer(struct vc_data *vc, int command) @@ -1370,7 +1370,7 @@ static void start_read_all_timer(struct vc_data *vc, int command) cursor_con = vc->vc_num; read_all_key = command; - cursor_timeout = get_var(CURSOR_TIME); + cursor_timeout = spk_get_var(CURSOR_TIME); mod_timer(&cursor_timer, jiffies + msecs_to_jiffies(cursor_timeout->u.n.value)); } @@ -1382,9 +1382,9 @@ static void handle_cursor_read_all(struct vc_data *vc, int command) switch (command) { case RA_NEXT_SENT: /* Get Current Sentence */ - get_index_count(&indcount, &sentcount); + spk_get_index_count(&indcount, &sentcount); /*printk("%d %d ", indcount, sentcount); */ - reset_index_count(sentcount + 1); + spk_reset_index_count(sentcount + 1); if (indcount == 1) { if (!say_sentence_num(sentcount + 1, 0)) { kbd_fakekey2(vc, RA_FIND_NEXT_SENT); @@ -1395,7 +1395,7 @@ static void handle_cursor_read_all(struct vc_data *vc, int command) sn = 0; if (!say_sentence_num(sentcount + 1, 1)) { sn = 1; - reset_index_count(sn); + spk_reset_index_count(sn); } else synth_insert_next_index(0); if (!say_sentence_num(sn, 0)) { @@ -1437,7 +1437,7 @@ static void handle_cursor_read_all(struct vc_data *vc, int command) case RA_FIND_PREV_SENT: break; case RA_TIMER: - get_index_count(&indcount, &sentcount); + spk_get_index_count(&indcount, &sentcount); if (indcount < 2) kbd_fakekey2(vc, RA_DOWN_ARROW); else @@ -1458,7 +1458,7 @@ static int pre_handle_cursor(struct vc_data *vc, u_char value, char up_flag) } del_timer(&cursor_timer); spk_shut_up &= 0xfe; - do_flush(); + spk_do_flush(); start_read_all_timer(vc, value + 1); spk_unlock(flags); return NOTIFY_STOP; @@ -1479,8 +1479,8 @@ static void do_handle_cursor(struct vc_data *vc, u_char value, char up_flag) return; } spk_shut_up &= 0xfe; - if (no_intr) - do_flush(); + if (spk_no_intr) + spk_do_flush(); /* the key press flushes if !no_inter but we want to flush on cursor * moves regardless of no_inter state */ is_cursor = value + 1; @@ -1491,7 +1491,7 @@ static void do_handle_cursor(struct vc_data *vc, u_char value, char up_flag) cursor_con = vc->vc_num; if (cursor_track == CT_Highlight) reset_highlight_buffers(vc); - cursor_timeout = get_var(CURSOR_TIME); + cursor_timeout = spk_get_var(CURSOR_TIME); mod_timer(&cursor_timer, jiffies + msecs_to_jiffies(cursor_timeout->u.n.value)); spk_unlock(flags); @@ -1603,7 +1603,7 @@ static int speak_highlight(struct vc_data *vc) if (speakup_console[vc_num]->ht.ry[hc] != vc->vc_y) return 0; spk_parked |= 0x01; - do_flush(); + spk_do_flush(); spkup_write(speakup_console[vc_num]->ht.highbuf[hc], speakup_console[vc_num]->ht.highsize[hc]); spk_pos = spk_cp = speakup_console[vc_num]->ht.rpos[hc]; @@ -1685,7 +1685,7 @@ static void speakup_con_write(struct vc_data *vc, const char *str, int len) if (!spk_trylock(flags)) /* Speakup output, discard */ return; - if (bell_pos && spk_keydown && (vc->vc_x == bell_pos - 1)) + if (spk_bell_pos && spk_keydown && (vc->vc_x == spk_bell_pos - 1)) bleep(3); if ((is_cursor) || (cursor_track == read_all_mode)) { if (cursor_track == CT_Highlight) @@ -1726,19 +1726,19 @@ static void do_handle_spec(struct vc_data *vc, u_char value, char up_flag) return; spk_lock(flags); spk_shut_up &= 0xfe; - if (no_intr) - do_flush(); + if (spk_no_intr) + spk_do_flush(); switch (value) { case KVAL(K_CAPS): - label = msg_get(MSG_KEYNAME_CAPSLOCK); + label = spk_msg_get(MSG_KEYNAME_CAPSLOCK); on_off = vt_get_leds(fg_console, VC_CAPSLOCK); break; case KVAL(K_NUM): - label = msg_get(MSG_KEYNAME_NUMLOCK); + label = spk_msg_get(MSG_KEYNAME_NUMLOCK); on_off = vt_get_leds(fg_console, VC_NUMLOCK); break; case KVAL(K_HOLD): - label = msg_get(MSG_KEYNAME_SCROLLLOCK); + label = spk_msg_get(MSG_KEYNAME_SCROLLLOCK); on_off = vt_get_leds(fg_console, VC_SCROLLOCK); if (speakup_console[vc->vc_num]) speakup_console[vc->vc_num]->tty_stopped = on_off; @@ -1750,7 +1750,7 @@ static void do_handle_spec(struct vc_data *vc, u_char value, char up_flag) } if (on_off < 2) synth_printf("%s %s\n", - label, msg_get(MSG_STATUS_START + on_off)); + label, spk_msg_get(MSG_STATUS_START + on_off)); spk_unlock(flags); } @@ -1764,13 +1764,13 @@ static int inc_dec_var(u_char value) int var_id = (int)value - VAR_START; int how = (var_id & 1) ? E_INC : E_DEC; var_id = var_id / 2 + FIRST_SET_VAR; - p_header = get_var_header(var_id); + p_header = spk_get_var_header(var_id); if (p_header == NULL) return -1; if (p_header->var_type != VAR_NUM) return -1; var_data = p_header->data; - if (set_num_var(1, p_header, how) != 0) + if (spk_set_num_var(1, p_header, how) != 0) return -1; if (!spk_close_press) { for (pn = p_header->name; *pn; pn++) { @@ -1790,18 +1790,18 @@ static void speakup_win_set(struct vc_data *vc) { char info[40]; if (win_start > 1) { - synth_printf("%s\n", msg_get(MSG_WINDOW_ALREADY_SET)); + synth_printf("%s\n", spk_msg_get(MSG_WINDOW_ALREADY_SET)); return; } if (spk_x < win_left || spk_y < win_top) { - synth_printf("%s\n", msg_get(MSG_END_BEFORE_START)); + synth_printf("%s\n", spk_msg_get(MSG_END_BEFORE_START)); return; } if (win_start && spk_x == win_left && spk_y == win_top) { win_left = 0; win_right = vc->vc_cols - 1; win_bottom = spk_y; - snprintf(info, sizeof(info), msg_get(MSG_WINDOW_LINE), + snprintf(info, sizeof(info), spk_msg_get(MSG_WINDOW_LINE), (int)win_top + 1); } else { if (!win_start) { @@ -1811,8 +1811,8 @@ static void speakup_win_set(struct vc_data *vc) win_bottom = spk_y; win_right = spk_x; } - snprintf(info, sizeof(info), msg_get(MSG_WINDOW_BOUNDARY), - (win_start) ? msg_get(MSG_END) : msg_get(MSG_START), + snprintf(info, sizeof(info), spk_msg_get(MSG_WINDOW_BOUNDARY), + (win_start) ? spk_msg_get(MSG_END) : spk_msg_get(MSG_START), (int)spk_y + 1, (int)spk_x + 1); } synth_printf("%s\n", info); @@ -1824,32 +1824,32 @@ static void speakup_win_clear(struct vc_data *vc) win_top = win_bottom = 0; win_left = win_right = 0; win_start = 0; - synth_printf("%s\n", msg_get(MSG_WINDOW_CLEARED)); + synth_printf("%s\n", spk_msg_get(MSG_WINDOW_CLEARED)); } static void speakup_win_enable(struct vc_data *vc) { if (win_start < 2) { - synth_printf("%s\n", msg_get(MSG_NO_WINDOW)); + synth_printf("%s\n", spk_msg_get(MSG_NO_WINDOW)); return; } win_enabled ^= 1; if (win_enabled) - synth_printf("%s\n", msg_get(MSG_WINDOW_SILENCED)); + synth_printf("%s\n", spk_msg_get(MSG_WINDOW_SILENCED)); else - synth_printf("%s\n", msg_get(MSG_WINDOW_SILENCE_DISABLED)); + synth_printf("%s\n", spk_msg_get(MSG_WINDOW_SILENCE_DISABLED)); } static void speakup_bits(struct vc_data *vc) { int val = this_speakup_key - (FIRST_EDIT_BITS - 1); - if (special_handler != NULL || val < 1 || val > 6) { - synth_printf("%s\n", msg_get(MSG_ERROR)); + if (spk_special_handler != NULL || val < 1 || val > 6) { + synth_printf("%s\n", spk_msg_get(MSG_ERROR)); return; } - pb_edit = &punc_info[val]; - synth_printf(msg_get(MSG_EDIT_PROMPT), pb_edit->name); - special_handler = edit_bits; + pb_edit = &spk_punc_info[val]; + synth_printf(spk_msg_get(MSG_EDIT_PROMPT), pb_edit->name); + spk_special_handler = edit_bits; } static int handle_goto(struct vc_data *vc, u_char type, u_char ch, u_short key) @@ -1887,9 +1887,9 @@ static int handle_goto(struct vc_data *vc, u_char type, u_char ch, u_short key) if (ch < 'x' || ch > 'y') { oops: if (!spk_killed) - synth_printf(" %s\n", msg_get(MSG_GOTO_CANCELED)); + synth_printf(" %s\n", spk_msg_get(MSG_GOTO_CANCELED)); goto_buf[num = 0] = '\0'; - special_handler = NULL; + spk_special_handler = NULL; return 1; } cp = speakup_s2i(goto_buf, &go_pos); @@ -1917,7 +1917,7 @@ oops: } goto_buf[num = 0] = '\0'; do_goto: - special_handler = NULL; + spk_special_handler = NULL; spk_parked |= 0x01; if (goto_x) { spk_pos -= spk_x * 2; @@ -1934,18 +1934,18 @@ do_goto: static void speakup_goto(struct vc_data *vc) { - if (special_handler != NULL) { - synth_printf("%s\n", msg_get(MSG_ERROR)); + if (spk_special_handler != NULL) { + synth_printf("%s\n", spk_msg_get(MSG_ERROR)); return; } - synth_printf("%s\n", msg_get(MSG_GOTO)); - special_handler = handle_goto; + synth_printf("%s\n", spk_msg_get(MSG_GOTO)); + spk_special_handler = handle_goto; return; } static void speakup_help(struct vc_data *vc) { - handle_help(vc, KT_SPKUP, SPEAKUP_HELP, 0); + spk_handle_help(vc, KT_SPKUP, SPEAKUP_HELP, 0); } static void do_nothing(struct vc_data *vc) @@ -1992,7 +1992,7 @@ static void do_spkup(struct vc_data *vc, u_char value) spk_shut_up &= 0xfe; this_speakup_key = value; if (value < SPKUP_MAX_FUNC && spkup_handler[value]) { - do_flush(); + spk_do_flush(); (*spkup_handler[value]) (vc); } else { if (inc_dec_var(value) < 0) @@ -2032,7 +2032,7 @@ speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym, } if (keycode >= MAX_KEY) goto no_map; - key_info = our_keys[keycode]; + key_info = spk_our_keys[keycode]; if (key_info == 0) goto no_map; /* Check valid read all mode keys */ @@ -2051,7 +2051,7 @@ speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym, } } shift_info = (shift_state & 0x0f) + key_speakup; - offset = shift_table[shift_info]; + offset = spk_shift_table[shift_info]; if (offset) { new_key = key_info[offset]; if (new_key) { @@ -2062,7 +2062,7 @@ speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym, if (up_flag || spk_killed) goto out; spk_shut_up &= 0xfe; - do_flush(); + spk_do_flush(); goto out; } if (up_flag) @@ -2070,7 +2070,7 @@ speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym, if (last_keycode == keycode && last_spk_jiffy + MAX_DELAY > jiffies) { spk_close_press = 1; - offset = shift_table[shift_info + 32]; + offset = spk_shift_table[shift_info + 32]; /* double press? */ if (offset && key_info[offset]) new_key = key_info[offset]; @@ -2082,7 +2082,7 @@ speakup_key(struct vc_data *vc, int shift_state, int keycode, u_short keysym, } } no_map: - if (type == KT_SPKUP && special_handler == NULL) { + if (type == KT_SPKUP && spk_special_handler == NULL) { do_spkup(vc, new_key); spk_close_press = 0; ret = 1; @@ -2096,9 +2096,9 @@ no_map: || (value == KVAL(K_LEFT)) || (value == KVAL(K_RIGHT)); if ((cursor_track != read_all_mode) || !kh) - if (!no_intr) - do_flush(); - if (special_handler) { + if (!spk_no_intr) + spk_do_flush(); + if (spk_special_handler) { if (type == KT_SPEC && value == 1) { value = '\n'; type = KT_LATIN; @@ -2106,7 +2106,7 @@ no_map: type = KT_LATIN; else if (value == 0x7f) value = 8; /* make del = backspace */ - ret = (*special_handler) (vc, type, value, keycode); + ret = (*spk_special_handler) (vc, type, value, keycode); spk_close_press = 0; if (ret < 0) bleep(9); @@ -2237,11 +2237,11 @@ static void __exit speakup_exit(void) speakup_unregister_var(i); for (i = 0; i < 256; i++) { - if (characters[i] != default_chars[i]) - kfree(characters[i]); + if (spk_characters[i] != spk_default_chars[i]) + kfree(spk_characters[i]); } - free_user_msgs(); + spk_free_user_msgs(); } /* call by: module_init() */ @@ -2254,20 +2254,20 @@ static int __init speakup_init(void) struct var_t *var; /* These first few initializations cannot fail. */ - initialize_msgs(); /* Initialize arrays for i18n. */ - reset_default_chars(); - reset_default_chartab(); - strlwr(synth_name); + spk_initialize_msgs(); /* Initialize arrays for i18n. */ + spk_reset_default_chars(); + spk_reset_default_chartab(); + spk_strlwr(synth_name); spk_vars[0].u.n.high = vc->vc_cols; for (var = spk_vars; var->var_id != MAXVARS; var++) speakup_register_var(var); for (var = synth_time_vars; (var->var_id >= 0) && (var->var_id < MAXVARS); var++) speakup_register_var(var); - for (i = 1; punc_info[i].mask != 0; i++) - set_mask_bits(0, i, 2); + for (i = 1; spk_punc_info[i].mask != 0; i++) + spk_set_mask_bits(0, i, 2); - set_key_info(key_defaults, key_buf); + spk_set_key_info(spk_key_defaults, spk_key_buf); /* From here on out, initializations can fail. */ err = speakup_add_virtual_keyboard(); @@ -2290,7 +2290,7 @@ static int __init speakup_init(void) goto error_kobjects; } - if (quiet_boot) + if (spk_quiet_boot) spk_shut_up |= 0x01; err = speakup_kobj_init(); @@ -2352,11 +2352,11 @@ error_virtkeyboard: speakup_unregister_var(i); for (i = 0; i < 256; i++) { - if (characters[i] != default_chars[i]) - kfree(characters[i]); + if (spk_characters[i] != spk_default_chars[i]) + kfree(spk_characters[i]); } - free_user_msgs(); + spk_free_user_msgs(); out: return err; diff --git a/drivers/staging/speakup/selection.c b/drivers/staging/speakup/selection.c index fe1f405d5d70..1217c79ed712 100644 --- a/drivers/staging/speakup/selection.c +++ b/drivers/staging/speakup/selection.c @@ -10,7 +10,7 @@ /* Don't take this from : 011-015 on the screen aren't spaces */ #define ishardspace(c) ((c) == ' ') -unsigned short xs, ys, xe, ye; /* our region points */ +unsigned short spk_xs, spk_ys, spk_xe, spk_ye; /* our region points */ /* Variables for selection control. */ /* must not be disallocated */ @@ -51,12 +51,12 @@ int speakup_set_selection(struct tty_struct *tty) int i, ps, pe; struct vc_data *vc = vc_cons[fg_console].d; - xs = limit(xs, vc->vc_cols - 1); - ys = limit(ys, vc->vc_rows - 1); - xe = limit(xe, vc->vc_cols - 1); - ye = limit(ye, vc->vc_rows - 1); - ps = ys * vc->vc_size_row + (xs << 1); - pe = ye * vc->vc_size_row + (xe << 1); + spk_xs = limit(spk_xs, vc->vc_cols - 1); + spk_ys = limit(spk_ys, vc->vc_rows - 1); + spk_xe = limit(spk_xe, vc->vc_cols - 1); + spk_ye = limit(spk_ye, vc->vc_rows - 1); + ps = spk_ys * vc->vc_size_row + (spk_xs << 1); + pe = spk_ye * vc->vc_size_row + (spk_xe << 1); if (ps > pe) { /* make sel_start <= sel_end */ diff --git a/drivers/staging/speakup/serialio.c b/drivers/staging/speakup/serialio.c index a97d3d5b58a4..e4d27aa2898f 100644 --- a/drivers/staging/speakup/serialio.c +++ b/drivers/staging/speakup/serialio.c @@ -116,7 +116,7 @@ static void start_serial_interrupt(int irq) outb(1, speakup_info.port_tts + UART_FCR); /* Turn FIFO On */ } -void stop_serial_interrupt(void) +void spk_stop_serial_interrupt(void) { if (speakup_info.port_tts == 0) return; @@ -130,7 +130,7 @@ void stop_serial_interrupt(void) free_irq(serstate->irq, (void *) synth_readbuf_handler); } -int wait_for_xmitr(void) +int spk_wait_for_xmitr(void) { int tmout = SPK_XMITR_TIMEOUT; if ((synth->alive) && (timeouts >= NUM_DISABLE_TIMEOUTS)) { @@ -195,7 +195,7 @@ EXPORT_SYMBOL_GPL(spk_serial_in_nowait); int spk_serial_out(const char ch) { - if (synth->alive && wait_for_xmitr()) { + if (synth->alive && spk_wait_for_xmitr()) { outb_p(ch, speakup_info.port_tts); return 1; } diff --git a/drivers/staging/speakup/speakup.h b/drivers/staging/speakup/speakup.h index e66579e6147a..22f0fbb85f42 100644 --- a/drivers/staging/speakup/speakup.h +++ b/drivers/staging/speakup/speakup.h @@ -50,34 +50,34 @@ #define E_UNDEF -1 extern int speakup_thread(void *data); -extern void reset_default_chars(void); -extern void reset_default_chartab(void); +extern void spk_reset_default_chars(void); +extern void spk_reset_default_chartab(void); extern void synth_start(void); void synth_insert_next_index(int sent_num); -void reset_index_count(int sc); -void get_index_count(int *linecount, int *sentcount); -extern int set_key_info(const u_char *key_info, u_char *k_buffer); -extern char *strlwr(char *s); +void spk_reset_index_count(int sc); +void spk_get_index_count(int *linecount, int *sentcount); +extern int spk_set_key_info(const u_char *key_info, u_char *k_buffer); +extern char *spk_strlwr(char *s); extern char *speakup_s2i(char *start, int *dest); -extern char *s2uchar(char *start, char *dest); -extern char *xlate(char *s); +extern char *spk_s2uchar(char *start, char *dest); +extern char *spk_xlate(char *s); extern int speakup_kobj_init(void); extern void speakup_kobj_exit(void); -extern int chartab_get_value(char *keyword); +extern int spk_chartab_get_value(char *keyword); extern void speakup_register_var(struct var_t *var); extern void speakup_unregister_var(enum var_id_t var_id); -extern struct st_var_header *get_var_header(enum var_id_t var_id); -extern struct st_var_header *var_header_by_name(const char *name); -extern struct punc_var_t *get_punc_var(enum var_id_t var_id); -extern int set_num_var(int val, struct st_var_header *var, int how); -extern int set_string_var(const char *page, struct st_var_header *var, int len); -extern int set_mask_bits(const char *input, const int which, const int how); -extern special_func special_handler; -extern int handle_help(struct vc_data *vc, u_char type, u_char ch, u_short key); +extern struct st_var_header *spk_get_var_header(enum var_id_t var_id); +extern struct st_var_header *spk_var_header_by_name(const char *name); +extern struct punc_var_t *spk_get_punc_var(enum var_id_t var_id); +extern int spk_set_num_var(int val, struct st_var_header *var, int how); +extern int spk_set_string_var(const char *page, struct st_var_header *var, int len); +extern int spk_set_mask_bits(const char *input, const int which, const int how); +extern special_func spk_special_handler; +extern int spk_handle_help(struct vc_data *vc, u_char type, u_char ch, u_short key); extern int synth_init(char *name); extern void synth_release(void); -extern void do_flush(void); +extern void spk_do_flush(void); extern void speakup_start_ttys(void); extern void synth_buffer_add(char ch); extern void synth_buffer_clear(void); @@ -90,35 +90,35 @@ extern void synth_write(const char *buf, size_t count); extern int synth_supports_indexing(void); extern struct vc_data *spk_sel_cons; -extern unsigned short xs, ys, xe, ye; /* our region points */ +extern unsigned short spk_xs, spk_ys, spk_xe, spk_ye; /* our region points */ extern wait_queue_head_t speakup_event; extern struct kobject *speakup_kobj; extern struct task_struct *speakup_task; -extern const u_char key_defaults[]; +extern const u_char spk_key_defaults[]; /* Protect speakup synthesizer list */ extern struct mutex spk_mutex; extern struct st_spk_t *speakup_console[]; extern struct spk_synth *synth; -extern char pitch_buff[]; -extern u_char *our_keys[]; -extern short punc_masks[]; -extern char str_caps_start[], str_caps_stop[]; -extern const struct st_bits_data punc_info[]; -extern u_char key_buf[600]; -extern char *characters[]; -extern char *default_chars[]; +extern char spk_pitch_buff[]; +extern u_char *spk_our_keys[]; +extern short spk_punc_masks[]; +extern char spk_str_caps_start[], spk_str_caps_stop[]; +extern const struct st_bits_data spk_punc_info[]; +extern u_char spk_key_buf[600]; +extern char *spk_characters[]; +extern char *spk_default_chars[]; extern u_short spk_chartab[]; -extern int no_intr, say_ctrl, say_word_ctl, punc_level; -extern int reading_punc, attrib_bleep, bleeps; -extern int bleep_time, bell_pos; -extern int spell_delay, key_echo; -extern short punc_mask; -extern short pitch_shift, synth_flags; -extern bool quiet_boot; +extern int spk_no_intr, spk_say_ctrl, spk_say_word_ctl, spk_punc_level; +extern int spk_reading_punc, spk_attrib_bleep, spk_bleeps; +extern int spk_bleep_time, spk_bell_pos; +extern int spk_spell_delay, spk_key_echo; +extern short spk_punc_mask; +extern short spk_pitch_shift, synth_flags; +extern bool spk_quiet_boot; extern char *synth_name; -extern struct bleep unprocessed_sound; +extern struct bleep spk_unprocessed_sound; /* Prototypes from fakekey.c. */ int speakup_add_virtual_keyboard(void); diff --git a/drivers/staging/speakup/speakup_acntpc.c b/drivers/staging/speakup/speakup_acntpc.c index bbe28b6809e0..1c1f0d560449 100644 --- a/drivers/staging/speakup/speakup_acntpc.c +++ b/drivers/staging/speakup/speakup_acntpc.c @@ -182,9 +182,9 @@ static void do_catch_up(struct spk_synth *synth) struct var_t *full_time; struct var_t *jiffy_delta; - jiffy_delta = get_var(JIFFY); - delay_time = get_var(DELAY); - full_time = get_var(FULL); + jiffy_delta = spk_get_var(JIFFY); + delay_time = spk_get_var(DELAY); + full_time = spk_get_var(FULL); spk_lock(flags); jiffy_delta_val = jiffy_delta->u.n.value; diff --git a/drivers/staging/speakup/speakup_acntsa.c b/drivers/staging/speakup/speakup_acntsa.c index 590fa6bb0ed4..22a8b7291098 100644 --- a/drivers/staging/speakup/speakup_acntsa.c +++ b/drivers/staging/speakup/speakup_acntsa.c @@ -128,7 +128,7 @@ static int synth_probe(struct spk_synth *synth) { int failed; - failed = serial_synth_probe(synth); + failed = spk_serial_synth_probe(synth); if (failed == 0) { spk_synth_immediate(synth, "\033=R\r"); mdelay(100); diff --git a/drivers/staging/speakup/speakup_apollo.c b/drivers/staging/speakup/speakup_apollo.c index 00d5cedd00ab..3e450ccbda66 100644 --- a/drivers/staging/speakup/speakup_apollo.c +++ b/drivers/staging/speakup/speakup_apollo.c @@ -112,7 +112,7 @@ static struct spk_synth synth_apollo = { .startup = SYNTH_START, .checkval = SYNTH_CHECK, .vars = vars, - .probe = serial_synth_probe, + .probe = spk_serial_synth_probe, .release = spk_serial_release, .synth_immediate = spk_synth_immediate, .catch_up = do_catch_up, @@ -145,9 +145,9 @@ static void do_catch_up(struct spk_synth *synth) int delay_time_val = 0; int jiffy_delta_val = 0; - jiffy_delta = get_var(JIFFY); - delay_time = get_var(DELAY); - full_time = get_var(FULL); + jiffy_delta = spk_get_var(JIFFY); + delay_time = spk_get_var(DELAY); + full_time = spk_get_var(FULL); spk_lock(flags); jiffy_delta_val = jiffy_delta->u.n.value; spk_unlock(flags); diff --git a/drivers/staging/speakup/speakup_audptr.c b/drivers/staging/speakup/speakup_audptr.c index 94e509992c8b..3508aee98ab0 100644 --- a/drivers/staging/speakup/speakup_audptr.c +++ b/drivers/staging/speakup/speakup_audptr.c @@ -162,7 +162,7 @@ static int synth_probe(struct spk_synth *synth) { int failed = 0; - failed = serial_synth_probe(synth); + failed = spk_serial_synth_probe(synth); if (failed == 0) synth_version(synth); synth->alive = !failed; diff --git a/drivers/staging/speakup/speakup_bns.c b/drivers/staging/speakup/speakup_bns.c index 43e5b54f344c..4bfe3d458dc0 100644 --- a/drivers/staging/speakup/speakup_bns.c +++ b/drivers/staging/speakup/speakup_bns.c @@ -100,7 +100,7 @@ static struct spk_synth synth_bns = { .startup = SYNTH_START, .checkval = SYNTH_CHECK, .vars = vars, - .probe = serial_synth_probe, + .probe = spk_serial_synth_probe, .release = spk_serial_release, .synth_immediate = spk_synth_immediate, .catch_up = spk_do_catch_up, diff --git a/drivers/staging/speakup/speakup_decext.c b/drivers/staging/speakup/speakup_decext.c index b4ef9153f42e..d39a0de286fb 100644 --- a/drivers/staging/speakup/speakup_decext.c +++ b/drivers/staging/speakup/speakup_decext.c @@ -130,7 +130,7 @@ static struct spk_synth synth_decext = { .startup = SYNTH_START, .checkval = SYNTH_CHECK, .vars = vars, - .probe = serial_synth_probe, + .probe = spk_serial_synth_probe, .release = spk_serial_release, .synth_immediate = spk_synth_immediate, .catch_up = do_catch_up, @@ -162,8 +162,8 @@ static void do_catch_up(struct spk_synth *synth) int jiffy_delta_val = 0; int delay_time_val = 0; - jiffy_delta = get_var(JIFFY); - delay_time = get_var(DELAY); + jiffy_delta = spk_get_var(JIFFY); + delay_time = spk_get_var(DELAY); spk_lock(flags); jiffy_delta_val = jiffy_delta->u.n.value; diff --git a/drivers/staging/speakup/speakup_decpc.c b/drivers/staging/speakup/speakup_decpc.c index de25527decf6..cda6b0f73c41 100644 --- a/drivers/staging/speakup/speakup_decpc.c +++ b/drivers/staging/speakup/speakup_decpc.c @@ -375,8 +375,8 @@ static void do_catch_up(struct spk_synth *synth) int jiffy_delta_val; int delay_time_val; - jiffy_delta = get_var(JIFFY); - delay_time = get_var(DELAY); + jiffy_delta = spk_get_var(JIFFY); + delay_time = spk_get_var(DELAY); spk_lock(flags); jiffy_delta_val = jiffy_delta->u.n.value; spk_unlock(flags); diff --git a/drivers/staging/speakup/speakup_dectlk.c b/drivers/staging/speakup/speakup_dectlk.c index daff3b9a4a6d..0dd2eb96cb28 100644 --- a/drivers/staging/speakup/speakup_dectlk.c +++ b/drivers/staging/speakup/speakup_dectlk.c @@ -134,7 +134,7 @@ static struct spk_synth synth_dectlk = { .vars = vars, .default_pitch = ap_defaults, .default_vol = g5_defaults, - .probe = serial_synth_probe, + .probe = spk_serial_synth_probe, .release = spk_serial_release, .synth_immediate = spk_synth_immediate, .catch_up = do_catch_up, @@ -214,8 +214,8 @@ static void do_catch_up(struct spk_synth *synth) int jiffy_delta_val; int delay_time_val; - jiffy_delta = get_var(JIFFY); - delay_time = get_var(DELAY); + jiffy_delta = spk_get_var(JIFFY); + delay_time = spk_get_var(DELAY); spk_lock(flags); jiffy_delta_val = jiffy_delta->u.n.value; spk_unlock(flags); diff --git a/drivers/staging/speakup/speakup_dtlk.c b/drivers/staging/speakup/speakup_dtlk.c index 97bc476746cd..a9cefbd3ea93 100644 --- a/drivers/staging/speakup/speakup_dtlk.c +++ b/drivers/staging/speakup/speakup_dtlk.c @@ -198,8 +198,8 @@ static void do_catch_up(struct spk_synth *synth) int jiffy_delta_val; int delay_time_val; - jiffy_delta = get_var(JIFFY); - delay_time = get_var(DELAY); + jiffy_delta = spk_get_var(JIFFY); + delay_time = spk_get_var(DELAY); spk_lock(flags); jiffy_delta_val = jiffy_delta->u.n.value; spk_unlock(flags); diff --git a/drivers/staging/speakup/speakup_dummy.c b/drivers/staging/speakup/speakup_dummy.c index c20f41188be1..4a24b9c1e8e3 100644 --- a/drivers/staging/speakup/speakup_dummy.c +++ b/drivers/staging/speakup/speakup_dummy.c @@ -102,7 +102,7 @@ static struct spk_synth synth_dummy = { .startup = SYNTH_START, .checkval = SYNTH_CHECK, .vars = vars, - .probe = serial_synth_probe, + .probe = spk_serial_synth_probe, .release = spk_serial_release, .synth_immediate = spk_synth_immediate, .catch_up = spk_do_catch_up, diff --git a/drivers/staging/speakup/speakup_keypc.c b/drivers/staging/speakup/speakup_keypc.c index 496e01481f9e..feb5f22cc169 100644 --- a/drivers/staging/speakup/speakup_keypc.c +++ b/drivers/staging/speakup/speakup_keypc.c @@ -184,9 +184,9 @@ static void do_catch_up(struct spk_synth *synth) int full_time_val; int jiffy_delta_val; - jiffy_delta = get_var(JIFFY); - delay_time = get_var(DELAY); - full_time = get_var(FULL); + jiffy_delta = spk_get_var(JIFFY); + delay_time = spk_get_var(DELAY); + full_time = spk_get_var(FULL); spk_lock(flags); jiffy_delta_val = jiffy_delta->u.n.value; spk_unlock(flags); diff --git a/drivers/staging/speakup/speakup_ltlk.c b/drivers/staging/speakup/speakup_ltlk.c index 971de1a13712..326f94d6b079 100644 --- a/drivers/staging/speakup/speakup_ltlk.c +++ b/drivers/staging/speakup/speakup_ltlk.c @@ -161,7 +161,7 @@ static int synth_probe(struct spk_synth *synth) { int failed = 0; - failed = serial_synth_probe(synth); + failed = spk_serial_synth_probe(synth); if (failed == 0) synth_interrogate(synth); synth->alive = !failed; diff --git a/drivers/staging/speakup/speakup_spkout.c b/drivers/staging/speakup/speakup_spkout.c index 9a3a80d9701e..e74f85620c68 100644 --- a/drivers/staging/speakup/speakup_spkout.c +++ b/drivers/staging/speakup/speakup_spkout.c @@ -107,7 +107,7 @@ static struct spk_synth synth_spkout = { .startup = SYNTH_START, .checkval = SYNTH_CHECK, .vars = vars, - .probe = serial_synth_probe, + .probe = spk_serial_synth_probe, .release = spk_serial_release, .synth_immediate = spk_synth_immediate, .catch_up = spk_do_catch_up, diff --git a/drivers/staging/speakup/speakup_txprt.c b/drivers/staging/speakup/speakup_txprt.c index 5d5bf7c3d0b1..5a29b9fcc930 100644 --- a/drivers/staging/speakup/speakup_txprt.c +++ b/drivers/staging/speakup/speakup_txprt.c @@ -100,7 +100,7 @@ static struct spk_synth synth_txprt = { .startup = SYNTH_START, .checkval = SYNTH_CHECK, .vars = vars, - .probe = serial_synth_probe, + .probe = spk_serial_synth_probe, .release = spk_serial_release, .synth_immediate = spk_synth_immediate, .catch_up = spk_do_catch_up, diff --git a/drivers/staging/speakup/spk_priv.h b/drivers/staging/speakup/spk_priv.h index a47c5b78d57d..303105b46013 100644 --- a/drivers/staging/speakup/spk_priv.h +++ b/drivers/staging/speakup/spk_priv.h @@ -45,8 +45,8 @@ #define KT_SPKUP 15 extern const struct old_serial_port *spk_serial_init(int index); -extern void stop_serial_interrupt(void); -extern int wait_for_xmitr(void); +extern void spk_stop_serial_interrupt(void); +extern int spk_wait_for_xmitr(void); extern unsigned char spk_serial_in(void); extern unsigned char spk_serial_in_nowait(void); extern int spk_serial_out(const char ch); @@ -55,13 +55,13 @@ extern void spk_serial_release(void); extern char synth_buffer_getc(void); extern char synth_buffer_peek(void); extern int synth_buffer_empty(void); -extern struct var_t *get_var(enum var_id_t var_id); +extern struct var_t *spk_get_var(enum var_id_t var_id); extern ssize_t spk_var_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf); extern ssize_t spk_var_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count); -extern int serial_synth_probe(struct spk_synth *synth); +extern int spk_serial_synth_probe(struct spk_synth *synth); extern const char *spk_synth_immediate(struct spk_synth *synth, const char *buff); extern void spk_do_catch_up(struct spk_synth *synth); extern void spk_synth_flush(struct spk_synth *synth); diff --git a/drivers/staging/speakup/synth.c b/drivers/staging/speakup/synth.c index 5710fc582beb..33efbd320930 100644 --- a/drivers/staging/speakup/synth.c +++ b/drivers/staging/speakup/synth.c @@ -20,9 +20,9 @@ #define MAXSYNTHS 16 /* Max number of synths in array. */ static struct spk_synth *synths[MAXSYNTHS]; struct spk_synth *synth; -char pitch_buff[32] = ""; +char spk_pitch_buff[32] = ""; static int module_status; -bool quiet_boot; +bool spk_quiet_boot; struct speakup_info_t speakup_info = { .spinlock = __SPIN_LOCK_UNLOCKED(speakup_info.spinlock), @@ -32,7 +32,7 @@ EXPORT_SYMBOL_GPL(speakup_info); static int do_synth_init(struct spk_synth *in_synth); -int serial_synth_probe(struct spk_synth *synth) +int spk_serial_synth_probe(struct spk_synth *synth) { const struct old_serial_port *ser; int failed = 0; @@ -59,7 +59,7 @@ int serial_synth_probe(struct spk_synth *synth) synth->alive = 1; return 0; } -EXPORT_SYMBOL_GPL(serial_synth_probe); +EXPORT_SYMBOL_GPL(spk_serial_synth_probe); /* Main loop of the progression thread: keep eating from the buffer * and push to the serial port, waiting as needed @@ -79,9 +79,9 @@ void spk_do_catch_up(struct spk_synth *synth) int delay_time_val; int full_time_val; - jiffy_delta = get_var(JIFFY); - full_time = get_var(FULL); - delay_time = get_var(DELAY); + jiffy_delta = spk_get_var(JIFFY); + full_time = spk_get_var(FULL); + delay_time = spk_get_var(DELAY); spk_lock(flags); jiffy_delta_val = jiffy_delta->u.n.value; @@ -139,7 +139,7 @@ const char *spk_synth_immediate(struct spk_synth *synth, const char *buff) while ((ch = *buff)) { if (ch == '\n') ch = synth->procspeech; - if (wait_for_xmitr()) + if (spk_wait_for_xmitr()) outb(ch, speakup_info.port_tts); else return buff; @@ -166,7 +166,7 @@ int spk_synth_is_alive_restart(struct spk_synth *synth) { if (synth->alive) return 1; - if (!synth->alive && wait_for_xmitr() > 0) { + if (!synth->alive && spk_wait_for_xmitr() > 0) { /* restart */ synth->alive = 1; synth_printf("%s", synth->init); @@ -192,20 +192,20 @@ void synth_start(void) synth_buffer_clear(); return; } - trigger_time = get_var(TRIGGER); + trigger_time = spk_get_var(TRIGGER); if (!timer_pending(&thread_timer)) mod_timer(&thread_timer, jiffies + msecs_to_jiffies(trigger_time->u.n.value)); } -void do_flush(void) +void spk_do_flush(void) { speakup_info.flushing = 1; synth_buffer_clear(); if (synth->alive) { - if (pitch_shift) { - synth_printf("%s", pitch_buff); - pitch_shift = 0; + if (spk_pitch_shift) { + synth_printf("%s", spk_pitch_buff); + spk_pitch_shift = 0; } } wake_up_interruptible_all(&speakup_event); @@ -241,7 +241,7 @@ EXPORT_SYMBOL_GPL(synth_printf); static int index_count; static int sentence_count; -void reset_index_count(int sc) +void spk_reset_index_count(int sc) { static int first = 1; if (first) @@ -277,7 +277,7 @@ void synth_insert_next_index(int sent_num) } } -void get_index_count(int *linecount, int *sentcount) +void spk_get_index_count(int *linecount, int *sentcount) { int ind = synth->get_index(); if (ind) { @@ -384,7 +384,7 @@ static int do_synth_init(struct spk_synth *in_synth) for (var = synth->vars; (var->var_id >= 0) && (var->var_id < MAXVARS); var++) speakup_register_var(var); - if (!quiet_boot) + if (!spk_quiet_boot) synth_printf("%s found\n", synth->long_name); if (synth->attributes.name && sysfs_create_group(speakup_kobj, &(synth->attributes)) < 0) @@ -412,7 +412,7 @@ void synth_release(void) sysfs_remove_group(speakup_kobj, &(synth->attributes)); for (var = synth->vars; var->var_id != MAXVARS; var++) speakup_unregister_var(var->var_id); - stop_serial_interrupt(); + spk_stop_serial_interrupt(); synth->release(); synth = NULL; } @@ -460,4 +460,4 @@ void synth_remove(struct spk_synth *in_synth) } EXPORT_SYMBOL_GPL(synth_remove); -short punc_masks[] = { 0, SOME, MOST, PUNC, PUNC|B_SYM }; +short spk_punc_masks[] = { 0, SOME, MOST, PUNC, PUNC|B_SYM }; diff --git a/drivers/staging/speakup/thread.c b/drivers/staging/speakup/thread.c index 103c5c81ee85..42fa660a7e0d 100644 --- a/drivers/staging/speakup/thread.c +++ b/drivers/staging/speakup/thread.c @@ -23,8 +23,8 @@ int speakup_thread(void *data) DEFINE_WAIT(wait); while (1) { spk_lock(flags); - our_sound = unprocessed_sound; - unprocessed_sound.active = 0; + our_sound = spk_unprocessed_sound; + spk_unprocessed_sound.active = 0; prepare_to_wait(&speakup_event, &wait, TASK_INTERRUPTIBLE); should_break = kthread_should_stop() || diff --git a/drivers/staging/speakup/varhandlers.c b/drivers/staging/speakup/varhandlers.c index ab7de9389dd6..f8c1e457d389 100644 --- a/drivers/staging/speakup/varhandlers.c +++ b/drivers/staging/speakup/varhandlers.c @@ -16,24 +16,24 @@ static struct st_var_header var_headers[] = { { "ex_num", EXNUMBER, VAR_PROC, NULL, NULL }, { "characters", CHARS, VAR_PROC, NULL, NULL }, { "synth_direct", SYNTH_DIRECT, VAR_PROC, NULL, NULL }, - { "caps_start", CAPS_START, VAR_STRING, str_caps_start, NULL }, - { "caps_stop", CAPS_STOP, VAR_STRING, str_caps_stop, NULL }, + { "caps_start", CAPS_START, VAR_STRING, spk_str_caps_start, NULL }, + { "caps_stop", CAPS_STOP, VAR_STRING, spk_str_caps_stop, NULL }, { "delay_time", DELAY, VAR_TIME, NULL, NULL }, { "trigger_time", TRIGGER, VAR_TIME, NULL, NULL }, { "jiffy_delta", JIFFY, VAR_TIME, NULL, NULL }, { "full_time", FULL, VAR_TIME, NULL, NULL }, - { "spell_delay", SPELL_DELAY, VAR_NUM, &spell_delay, NULL }, - { "bleeps", BLEEPS, VAR_NUM, &bleeps, NULL }, - { "attrib_bleep", ATTRIB_BLEEP, VAR_NUM, &attrib_bleep, NULL }, - { "bleep_time", BLEEP_TIME, VAR_TIME, &bleep_time, NULL }, + { "spell_delay", SPELL_DELAY, VAR_NUM, &spk_spell_delay, NULL }, + { "bleeps", BLEEPS, VAR_NUM, &spk_bleeps, NULL }, + { "attrib_bleep", ATTRIB_BLEEP, VAR_NUM, &spk_attrib_bleep, NULL }, + { "bleep_time", BLEEP_TIME, VAR_TIME, &spk_bleep_time, NULL }, { "cursor_time", CURSOR_TIME, VAR_TIME, NULL, NULL }, - { "punc_level", PUNC_LEVEL, VAR_NUM, &punc_level, NULL }, - { "reading_punc", READING_PUNC, VAR_NUM, &reading_punc, NULL }, - { "say_control", SAY_CONTROL, VAR_NUM, &say_ctrl, NULL }, - { "say_word_ctl", SAY_WORD_CTL, VAR_NUM, &say_word_ctl, NULL }, - { "no_interrupt", NO_INTERRUPT, VAR_NUM, &no_intr, NULL }, - { "key_echo", KEY_ECHO, VAR_NUM, &key_echo, NULL }, - { "bell_pos", BELL_POS, VAR_NUM, &bell_pos, NULL }, + { "punc_level", PUNC_LEVEL, VAR_NUM, &spk_punc_level, NULL }, + { "reading_punc", READING_PUNC, VAR_NUM, &spk_reading_punc, NULL }, + { "say_control", SAY_CONTROL, VAR_NUM, &spk_say_ctrl, NULL }, + { "say_word_ctl", SAY_WORD_CTL, VAR_NUM, &spk_say_word_ctl, NULL }, + { "no_interrupt", NO_INTERRUPT, VAR_NUM, &spk_no_intr, NULL }, + { "key_echo", KEY_ECHO, VAR_NUM, &spk_key_echo, NULL }, + { "bell_pos", BELL_POS, VAR_NUM, &spk_bell_pos, NULL }, { "rate", RATE, VAR_NUM, NULL, NULL }, { "pitch", PITCH, VAR_NUM, NULL, NULL }, { "vol", VOL, VAR_NUM, NULL, NULL }, @@ -58,7 +58,7 @@ static struct punc_var_t punc_vars[] = { { -1, -1 }, }; -int chartab_get_value(char *keyword) +int spk_chartab_get_value(char *keyword) { int value = 0; @@ -103,11 +103,11 @@ void speakup_register_var(struct var_t *var) p_header->data = var; switch (p_header->var_type) { case VAR_STRING: - set_string_var(nothing, p_header, 0); + spk_set_string_var(nothing, p_header, 0); break; case VAR_NUM: case VAR_TIME: - set_num_var(0, p_header, E_DEFAULT); + spk_set_num_var(0, p_header, E_DEFAULT); break; default: break; @@ -123,7 +123,7 @@ void speakup_unregister_var(enum var_id_t var_id) p_header->data = NULL; } -struct st_var_header *get_var_header(enum var_id_t var_id) +struct st_var_header *spk_get_var_header(enum var_id_t var_id) { struct st_var_header *p_header; if (var_id < 0 || var_id >= MAXVARS) @@ -134,7 +134,7 @@ struct st_var_header *get_var_header(enum var_id_t var_id) return p_header; } -struct st_var_header *var_header_by_name(const char *name) +struct st_var_header *spk_var_header_by_name(const char *name) { int i; struct st_var_header *where = NULL; @@ -151,15 +151,15 @@ struct st_var_header *var_header_by_name(const char *name) return where; } -struct var_t *get_var(enum var_id_t var_id) +struct var_t *spk_get_var(enum var_id_t var_id) { BUG_ON(var_id < 0 || var_id >= MAXVARS); BUG_ON(!var_ptrs[var_id]); return var_ptrs[var_id]->data; } -EXPORT_SYMBOL_GPL(get_var); +EXPORT_SYMBOL_GPL(spk_get_var); -struct punc_var_t *get_punc_var(enum var_id_t var_id) +struct punc_var_t *spk_get_punc_var(enum var_id_t var_id) { struct punc_var_t *rv = NULL; struct punc_var_t *where; @@ -175,7 +175,7 @@ struct punc_var_t *get_punc_var(enum var_id_t var_id) } /* handlers for setting vars */ -int set_num_var(int input, struct st_var_header *var, int how) +int spk_set_num_var(int input, struct st_var_header *var, int how) { int val; short ret = 0; @@ -217,7 +217,7 @@ int set_num_var(int input, struct st_var_header *var, int how) if (p_val != NULL) *p_val = val; if (var->var_id == PUNC_LEVEL) { - punc_mask = punc_masks[val]; + spk_punc_mask = spk_punc_masks[val]; return ret; } if (var_data->u.n.multiplier != 0) @@ -232,7 +232,7 @@ int set_num_var(int input, struct st_var_header *var, int how) if (!var_data->u.n.synth_fmt) return ret; if (var->var_id == PITCH) - cp = pitch_buff; + cp = spk_pitch_buff; else cp = buf; if (!var_data->u.n.out_str) @@ -244,7 +244,7 @@ int set_num_var(int input, struct st_var_header *var, int how) return ret; } -int set_string_var(const char *page, struct st_var_header *var, int len) +int spk_set_string_var(const char *page, struct st_var_header *var, int len) { int ret = 0; struct var_t *var_data = var->data; @@ -267,21 +267,21 @@ int set_string_var(const char *page, struct st_var_header *var, int len) return ret; } -/* set_mask_bits sets or clears the punc/delim/repeat bits, +/* spk_set_mask_bits sets or clears the punc/delim/repeat bits, * if input is null uses the defaults. * values for how: 0 clears bits of chars supplied, * 1 clears allk, 2 sets bits for chars */ -int set_mask_bits(const char *input, const int which, const int how) +int spk_set_mask_bits(const char *input, const int which, const int how) { u_char *cp; - short mask = punc_info[which].mask; + short mask = spk_punc_info[which].mask; if (how&1) { - for (cp = (u_char *)punc_info[3].value; *cp; cp++) + for (cp = (u_char *)spk_punc_info[3].value; *cp; cp++) spk_chartab[*cp] &= ~mask; } cp = (u_char *)input; if (cp == 0) - cp = punc_info[which].value; + cp = spk_punc_info[which].value; else { for ( ; *cp; cp++) { if (*cp < SPACE) @@ -308,7 +308,7 @@ int set_mask_bits(const char *input, const int which, const int how) return 0; } -char *strlwr(char *s) +char *spk_strlwr(char *s) { char *p; if (s == NULL) @@ -341,7 +341,7 @@ char *speakup_s2i(char *start, int *dest) return start; } -char *s2uchar(char *start, char *dest) +char *spk_s2uchar(char *start, char *dest) { int val = 0; while (*start && *start <= SPACE) @@ -357,7 +357,7 @@ char *s2uchar(char *start, char *dest) return start; } -char *xlate(char *s) +char *spk_xlate(char *s) { static const char finds[] = "nrtvafe"; static const char subs[] = "\n\r\t\013\001\014\033"; diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c index 25264c4d390f..5b6dcba304b1 100644 --- a/fs/ext4/inode.c +++ b/fs/ext4/inode.c @@ -37,6 +37,7 @@ #include #include #include +#include #include "ext4_jbd2.h" #include "xattr.h" @@ -3580,18 +3581,20 @@ int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc) void ext4_set_inode_flags(struct inode *inode) { unsigned int flags = EXT4_I(inode)->i_flags; + unsigned int new_fl = 0; - inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC); if (flags & EXT4_SYNC_FL) - inode->i_flags |= S_SYNC; + new_fl |= S_SYNC; if (flags & EXT4_APPEND_FL) - inode->i_flags |= S_APPEND; + new_fl |= S_APPEND; if (flags & EXT4_IMMUTABLE_FL) - inode->i_flags |= S_IMMUTABLE; + new_fl |= S_IMMUTABLE; if (flags & EXT4_NOATIME_FL) - inode->i_flags |= S_NOATIME; + new_fl |= S_NOATIME; if (flags & EXT4_DIRSYNC_FL) - inode->i_flags |= S_DIRSYNC; + new_fl |= S_DIRSYNC; + set_mask_bits(&inode->i_flags, + S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC, new_fl); } /* Propagate flags from i_flags to EXT4_I(inode)->i_flags */ diff --git a/include/linux/bitops.h b/include/linux/bitops.h index a3b6b82108b9..c1dde8e00d25 100644 --- a/include/linux/bitops.h +++ b/include/linux/bitops.h @@ -185,6 +185,21 @@ static inline unsigned long __ffs64(u64 word) #ifdef __KERNEL__ +#ifndef set_mask_bits +#define set_mask_bits(ptr, _mask, _bits) \ +({ \ + const typeof(*ptr) mask = (_mask), bits = (_bits); \ + typeof(*ptr) old, new; \ + \ + do { \ + old = ACCESS_ONCE(*ptr); \ + new = (old & ~mask) | bits; \ + } while (cmpxchg(ptr, old, new) != old); \ + \ + new; \ +}) +#endif + #ifndef find_last_bit /** * find_last_bit - find the last set bit in a memory region diff --git a/net/netfilter/nf_conntrack_proto_dccp.c b/net/netfilter/nf_conntrack_proto_dccp.c index 24fdce256cb0..31dbf0050768 100644 --- a/net/netfilter/nf_conntrack_proto_dccp.c +++ b/net/netfilter/nf_conntrack_proto_dccp.c @@ -431,7 +431,7 @@ static bool dccp_new(struct nf_conn *ct, const struct sk_buff *skb, const char *msg; u_int8_t state; - dh = skb_header_pointer(skb, dataoff, sizeof(_dh), &dh); + dh = skb_header_pointer(skb, dataoff, sizeof(_dh), &_dh); BUG_ON(dh == NULL); state = dccp_state_table[CT_DCCP_ROLE_CLIENT][dh->dccph_type][CT_DCCP_NONE]; @@ -488,7 +488,7 @@ static int dccp_packet(struct nf_conn *ct, const struct sk_buff *skb, u_int8_t type, old_state, new_state; enum ct_dccp_roles role; - dh = skb_header_pointer(skb, dataoff, sizeof(_dh), &dh); + dh = skb_header_pointer(skb, dataoff, sizeof(_dh), &_dh); BUG_ON(dh == NULL); type = dh->dccph_type; @@ -579,7 +579,7 @@ static int dccp_error(struct net *net, struct nf_conn *tmpl, unsigned int cscov; const char *msg; - dh = skb_header_pointer(skb, dataoff, sizeof(_dh), &dh); + dh = skb_header_pointer(skb, dataoff, sizeof(_dh), &_dh); if (dh == NULL) { msg = "nf_ct_dccp: short packet "; goto out_invalid;