linux/drivers/accessibility/speakup/synth.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/types.h>
#include <linux/ctype.h>	/* for isdigit() and friends */
#include <linux/fs.h>
#include <linux/mm.h>		/* for verify_area */
#include <linux/errno.h>	/* for -EBUSY */
#include <linux/ioport.h>	/* for check_region, request_region */
#include <linux/interrupt.h>
#include <linux/delay.h>	/* for loops_per_sec */
#include <linux/kmod.h>
#include <linux/jiffies.h>
#include <linux/uaccess.h>	/* for copy_from_user */
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/kthread.h>

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

static LIST_HEAD(synths);
struct spk_synth *synth;
char spk_pitch_buff[32] = …;
static int module_status;
bool spk_quiet_boot;

struct speakup_info_t speakup_info = …;
EXPORT_SYMBOL_GPL(…);

static int do_synth_init(struct spk_synth *in_synth);

/*
 * Main loop of the progression thread: keep eating from the buffer
 * and push to the serial port, waiting as needed
 *
 * For devices that have a "full" notification mechanism, the driver can
 * adapt the loop the way they prefer.
 */
static void _spk_do_catch_up(struct spk_synth *synth, int unicode)
{ … }

void spk_do_catch_up(struct spk_synth *synth)
{ … }
EXPORT_SYMBOL_GPL(…);

void spk_do_catch_up_unicode(struct spk_synth *synth)
{ … }
EXPORT_SYMBOL_GPL(…);

void spk_synth_flush(struct spk_synth *synth)
{ … }
EXPORT_SYMBOL_GPL(…);

unsigned char spk_synth_get_index(struct spk_synth *synth)
{ … }
EXPORT_SYMBOL_GPL(…);

int spk_synth_is_alive_nop(struct spk_synth *synth)
{ … }
EXPORT_SYMBOL_GPL(…);

int spk_synth_is_alive_restart(struct spk_synth *synth)
{ … }
EXPORT_SYMBOL_GPL(…);

static void thread_wake_up(struct timer_list *unused)
{ … }

static DEFINE_TIMER(thread_timer, thread_wake_up);

void synth_start(void)
{ … }

void spk_do_flush(void)
{ … }

void synth_write(const char *_buf, size_t count)
{ … }

/* Consume one utf-8 character from buf (that contains up to count bytes),
 * returns the unicode codepoint if valid, -1 otherwise.
 * In all cases, returns the number of consumed bytes in *consumed,
 * and the minimum number of bytes that would be needed for the next character
 * in *want.
 */
s32 synth_utf8_get(const char *buf, size_t count, size_t *consumed, size_t *want)
{ … }

void synth_writeu(const char *buf, size_t count)
{ … }

void synth_printf(const char *fmt, ...)
{ … }
EXPORT_SYMBOL_GPL(…);

void synth_putwc(u16 wc)
{ … }
EXPORT_SYMBOL_GPL(…);

void synth_putwc_s(u16 wc)
{ … }
EXPORT_SYMBOL_GPL(…);

void synth_putws(const u16 *buf)
{ … }
EXPORT_SYMBOL_GPL(…);

void synth_putws_s(const u16 *buf)
{ … }
EXPORT_SYMBOL_GPL(…);

static int index_count;
static int sentence_count;

void spk_reset_index_count(int sc)
{ … }

int synth_supports_indexing(void)
{ … }

void synth_insert_next_index(int sent_num)
{ … }

void spk_get_index_count(int *linecount, int *sentcount)
{ … }

static struct resource synth_res;

int synth_request_region(unsigned long start, unsigned long n)
{ … }
EXPORT_SYMBOL_GPL(…);

int synth_release_region(unsigned long start, unsigned long n)
{ … }
EXPORT_SYMBOL_GPL(…);

struct var_t synth_time_vars[] = …;

/* called by: speakup_init() */
int synth_init(char *synth_name)
{ … }

/* called by: synth_add() */
static int do_synth_init(struct spk_synth *in_synth)
{ … }

void synth_release(void)
{ … }

/* called by: all_driver_init() */
int synth_add(struct spk_synth *in_synth)
{ … }
EXPORT_SYMBOL_GPL(…);

void synth_remove(struct spk_synth *in_synth)
{ … }
EXPORT_SYMBOL_GPL(…);

struct spk_synth *synth_current(void)
{ … }
EXPORT_SYMBOL_GPL(…);

short spk_punc_masks[] = …;