Attachment #112063: 4400_speakup-20070204.patch for bug #166086

source "drivers/char/speakup/Kconfig"

This file is intended to give you an overview of the default keys used

by speakup for it's review functions.  You may change them to be

anything you want but that will take some familiarity with key

mapping.

We have remapped the insert or zero key on the keypad to act as a

shift key.  Well, actually as an altgr key.  So in the following list

InsKeyPad-period means hold down the insert key like a shift key and

hit the keypad period.

KeyPad-8		Say current Line

InsKeyPad-8		say from top of screen to reading cursor.

KeyPad-7		Say Previous Line (UP one line)

KeyPad-9		Say Next Line (down one line)

KeyPad-5		Say Current Word

InsKeyPad-5		Spell Current Word

KeyPad-4		Say Previous Word (left one word)

InsKeyPad-4		say from left edge of line to reading cursor.

KeyPad-6		Say Next Word (right one word)

InsKeyPad-6		Say from reading cursor to right edge of line.

KeyPad-2		Say Current Letter

InsKeyPad-2		say current letter phonetically

KeyPad-1		Say Previous Character (left one letter)

KeyPad-3		Say Next Character (right one letter)

KeyPad-plus		Say Entire Screen

InsKeyPad-plus		Say from reading cursor line to bottom of screen.

KeyPad-Minus		Park reading cursor (toggle)

InsKeyPad-minus		Say character hex and decimal value.

KeyPad-period		Say Position (current line, position and console)

InsKeyPad-period	say colour attributes of current position.

InsKeyPad-9		Move reading cursor to top of screen (insert pgup)

InsKeyPad-3		Move reading cursor to bottom of screen (insert pgdn)

InsKeyPad-7		Move reading cursor to left edge of screen (insert home)

InsKeyPad-1		Move reading cursor to right edge of screen (insert end)

ControlKeyPad-1		Move reading cursor to last character on current line.

KeyPad-Enter		Shut Up (until another key is hit) and sync reading cursor

InsKeyPad-Enter		Shut Up (until toggled back on).

InsKeyPad-star n<x|y>	go to line (y) or column (x). Where 'n' is any

		allowed value for the row or column for your current screen.

KeyPad-/		Mark and Cut screen region.

InsKeyPad-/		Paste screen region into any console.

Hitting any key while speakup is outputting speech will quiet the

synth until it has caught up with what is being printed on the

console.

This document assumes you have had some experience with kernel

compilation and installation.  If you have not, I recommend you get

the kernel source and read the README and various documents in the

linux/Documentation directory.  In particular the Changes file to make

sure you have the appropriate utilities needed for installing a 2.2.xx

or 2.4xx kernel.  It isn't as difficult as you might think.  The

kernel README is intimidating the first time but once you get the

steps down, it's really pretty easy.  Getting through the "make

config" is the tedious bit.

The first thing to do is to place a copy of the tarball in the /usr/src

directory which is the directory the linux tree is located in as well.

Next untar speakup by typing:

tar zxf speakup-1.00.tar.gz

cd speakup-1.00

./install

Note the dot-slash before the install.  This will copy the speakup

directory to the kernel tree and apply the various patches and

components to the appropriate kernel files.  Depending on how

experienced you are with kernel compiling and hacking will determine

whether you should bother looking at any failed patches.  If this

happens, you should probably write to the speakup mailing list for

help or myself.

If all of the patch hunks apply successfully then just continue with

the standard steps to compile the kernel with:

make mrproper

make config

When you get to the section console speech output, answer 'y' to the

CONFIG_SPEAKUP prompt.  You will be given a submenu with the list of

synthesizers which are currently supported.  You can include as many

synths in the kernel as you wish but remember each one takes up kernel

space.  You can only choose one of the synths as the default or none,

so just type dtlk or whatever is the correct string for the

synthesizer you have.  You will also be asked if you wish to build-in

a speakup key map.  If you do not say 'y' to this option you will need

to load a speakup map at boot time with whichever mechanism your

distribution uses for loading key maps.

We have placed the speakup configuration options in make config just

after the vga console choice.  For the DoubleTalk PC driver included

by Jim Van Zandt.  I recommend you say no to that option.  I have not

tried configuring them both in, but I wouldn't be at all surprised if

it didn't work.

If all goes well up to this point you can continue with the compiling

process by doing:

make dep >dep.file 2>&1 &

make bzImage >cc.file 2>&1 &

make modules >mod.file 2>&1 &

I always redirect output to the files dep.file and cc.file so I can

look over the compilation record to make sure there are no errors and

warnings.

Okay, you are ready to install the newly compiled kernel.  Make sure

you make an linux.old entry in your lilo.conf file so you can recover

if it blows up.  next as root run "make modules_install" to install

whatever modules you compiled and move the bzImage from

/usr/src/linux/arch/i386/boot to wherever your kernel lives.  Also

move the System.map from /usr/src/linux to where your System.map

lives.  On our systems we use debian so we create an vmlinuz-speakup

and System.map-speakup in our /boot directory and set the symbolic

links vmlinuz and System.map in the root (/) directory to point to the

images.  Now type lilo to tell lilo to build the new booter file and

install it.

As of version 0.07, the keymap for speakup is automatically built in

at compile time.  If you have other keymaps installed at boot time,

you might want to consider removing them before you reboot the system.

If everything has gone OK up until now, cross your fingers and type:

shutdown -r now

Your system should start talking to you as soon as it starts booting.

It will talk and talk and ... well, you might want to hit the

keypad-enter key to tell it to shut up.  You should also read the

DefaultKeyAssignments file to learn the various review functions

available.

As of v-0.10 the speakup configuration options are in the

/proc/speakup subtree.  The individual options should be fairly

obvious by their names such as rate, volume, punc_level and so forth.

You can manipulate them by cat'ing or echoing new values to them such

as:

echo 9 >/proc/speakup/rate

You can see what the current values are by cat'ing those files to the console:

cat /proc/speakup/rate

I have probably managed to overlook a whole whack of things because

this is the, enter version number here, draft.  Don't worry we'll get

it right eventually.  If you like the package you really should get on

the mailing list and start participating in it's development.

  Kirk

email: kirk@braille.uwo.ca

phone: (519) 679-6845 (home)

		       Speakup Keymap Tutorial

This is meant to be a basic tutorial on how to change the Linux keymap

file to assign speakup review functions to desired keys.  It is not

intended to be a replacement for the loadkeys(8) or keymap(5) man

pages.

The basic lay-out of the keymap file is a series of lines with the

following fields.  The keyword keycode indicates this is the start of

a new key assignment.  It is then followed by a number which

represents the actual key on the keyboard.  That number is followed by

the equals '=' operator and finally a list of keywords representing

key names such as keypad5.  Each line can have quite a few key

functions on it.  They are interpreted by loadkeys in order and

assigned to key shift states depending on the order they are

encountered.  So for example, the first value after the equals is the

keys unshifted state, while the second is the keys shifted state.  If

you wish to learn the order they are interpreted in read the

loadkeys(8) and keymap(5) man pages.

You can have subsequent lines which are indented and start with

another keyword for the various shifted states.  This way you can

assign some of the states without having to specify them all in order

up until you get to the one you want to assign.

In speakup, we have assigned the insert key on the number pad to the

altgr keyword.  This is not required; you could choose any other

shifted state keyword.  We used altgr because it typically represents

the right hand alt key.  In Linux each shift key is separate and

independent, so the left shift and the right shift keys are not

necessarily the same.  The altgr key is not really used for anything

important, so we steel it.

Here are the default key assignments for the number eight on the

keypad:

keycode  72 = KP_8            

	alt     keycode  72 = Ascii_8         

As you can see, the first line starts with keycode followed by 72

which is the actual number assigned to the key when the keyboard port

is read.  The KP_8 after the equal sign, is the symbolic representation

of the function called when that key is hit.

The second line is the same format except it starts with the keyword

alt which is indented.  That means that the function at the end of

that line Ascii_8 is applied to the alt-shifted eight key.

Now here are the speakup assignments for that key:

keycode  72 = 0x0d0a

	altgr keycode 72 = 0x0d20

#keycode  72 = KP_8            

	alt     keycode  72 = Ascii_8         

Notice that the only thing which has changed on the first line is the

function called when the key is struck.  It is a hexadecimal number

identifying the function called in a look up table.  It is not a

symbolic representation yet because that means we need to change the

loadkeys program to understand our symbolic names.  We will do this in

the future but for now it is more expedient to just use the table

indices.  You will find a table at the bottom of this document

listing the review functions and their corresponding hex lookups.

The 0x0d0a in the first line above is speakup's say line function.

The second line ends with 0x0d20 which is speakup's read from top of

screen to reading cursor line.

The third line is the original key assignment commented out with a

number-sign '#' at the beginning.  I do that so I can easily find the

keys I want to affect by symbolic name.  Otherwise I would need to

keep a look up table for all the keycodes.  I recommend you do this as

well or you'll be very sorry at some point in the future.

The forth line is just the standard key assignment for the left hand

alt key.

Now let's say we want to design a different keyboard layout.  I'll use

an example for the JAWS style keypad because I've specifically been

asked to help with that.  JAWS uses the eight on the keypad to move up

a line or the speakup function to read previous line.  JAWS also uses

the keypad_8 key in a shifted mode to read the current line.  I

apologize if these are not quite right.  It has been a long time since

I used JAWS.  So we would have the following two lines:

keycode  72 = 0x0d0b

	altgr keycode 72 = 0x0d0a

The hex value 0x0d0b in the first line is speakup's SAY_PREVIOUS_LINE

function.  The 0x0d0a in the second line is the same say_line function

as we had earlier.  So when the number eight is hit on the keypad

speakup will read the previous line and when the number eight is

shifted with the insert key on the keypad it will read the current

line.

As you can tell, it is not really very difficult to reassign the keys

to different review functions.

Once you have carefully edited the keymap file, called default.map in

the speakup distribution, you copy it into the /etc/kbd directory.

Make sure you back up the original default.map from that directory

first, if there is one.  Then you run loadkeys to load the new map

into the kernel:

loadkeys /etc/kbd/default.map

If you wish to build your new keyboard lay-out into the kernel, after

testing it, copy the default.map file into the drivers/char directory,

with the name defkeymap.map, of your Linux source tree.  Then rm the

defkeymap.c file and recompile the kernel.  Because there is no

defkeymap.c `make' will rebuild it on the next compile.

Here is a list of the available speakup review functions at this point

in time.

SAY_CHAR 0x0d04 /* say this character */

SAY_PREV_CHAR 0x0d05 /* say character left of this char */

SAY_NEXT_CHAR 0x0d06 /* say char right of this char */

SAY_WORD 0x0d07 /* say this word under reading cursor */

SAY_PREV_WORD 0x0d08

SAY_NEXT_WORD 0x0d09

SAY_LINE 0x0d0a /* say this line */

SAY_PREV_LINE 0x0d0b /* say line above this line */

SAY_NEXT_LINE 0x0d0c

TOP_EDGE 0x0d0d /* move to top edge of screen */

BOTTOM_EDGE 0x0d0e

LEFT_EDGE 0x0d0f

RIGHT_EDGE 0x0d10

SAY_PHONETIC_CHAR 0x0d11 /* say this character phonetically */

SPELL_WORD 0x0d12 /* spell this word letter by letter */

SAY_SCREEN 0x0d14

SAY_POSITION 0x0d1b

SPEECH_OFF 0x0d1c

SAY_ATTRIBUTES 0x0d1d

SPEAKUP_PARKED 0x0d1e

SAY_FROM_TOP 0x0d20

SAY_TO_BOTTOM 0x0d21

SAY_FROM_LEFT 0x0d22

SAY_TO_RIGHT 0x0d23

Welcome to the speakup project for the Speakup speech package for Linux.

Speakup is written by Kirk Reiser and Andy Berdan.  It is licensed

under the GPL.  If you don't already know, the GPL stands for the GNU

General Public License.  Which basically states that this code is free to

copy, modify and distribute to anyone interested in playing with it.

The one thing you may not do is turn any part of it into proprietary

or commercial code without the permission of the author.  That's me.

If you are interested in being involved with the development of speech

output for Linux you can subscribe to the Speakup mailing list by

sending a message to speakup-request@braille.uwo.ca with the line: subscribe.  You can also subscribe by going to the speakup web page and following the links at http://www.linux-speakup.org.

We are at a very early stage in the development of this package.

Hopefully changes will happen often and many.  The current files in

this directory are:

DefaultKeyAssignments		# speakup's default review keys

INSTALLATION			#  for installing speakup from the tar ball.

README				# this file

keymap-tutorial			# a tutorial on how to layout the keyboard

Read the INSTALLATION file to learn how to apply the patches and the

default.map for the keyboard.  You should also read the Changes file.

It really has any new things I've added since last time.

There is no documentation in any of these files to instruct you what

to do if something goes wrong with the patching or compilation.  If

you would like that information you will need to subscribe to the

mailing list and ask for help, or write me kirk@braille.uwo.ca for

help.  I suggest the mailing list because I will probably tire quickly

of answering the same questions over and over.  You could always

decide to dig-in and take on the task, and write documentation to help

others.

There also is a speakup reflector for the Speak Freely package, which

many of us hang out on and discuss all sorts of topics from speakup

problems to ALSA driver installation and just about anything else

you'd like to talk about.  The reflector is at lwl.braille.uwo.ca:4074

with it's lwl page at lwl.braille.uwo.ca/speakup.html.  Come and join

us, it's fun!

Acknowledgements:

I am really very new at kernel hacking and screen review package

writing, so I have depended heavily on other folks kindness to help me

a long.  No doubt I will continue to abuse them freely and others

before this is a really good speech solution for Linux.  (Oh Well!,

somebody's got to do it.)

Theodore Ts'o.  He gave me a good discussion of unicode and UTF and

the like.  He doesn't even remember writing me about it.

Alan Cox.  He has answered many questions about scheduling and wait

queues and timers along with code fragments and so on.  I just wish I

understood it all totally.  He has also helped immensely in moving

this package toward inclusion in the standard kernel tree. (Maybe next

release!)

Martin Mares.  He pointed me in the right direction to figuring out

the colour attributes and other useful tidbits.

Paul McDermott.  He really is the catalyst for me to actually get

this all working.  Besides I like seeing him bounce around and get all

excited every time I have something new working.

John Covici, He was the first person to actually attempt writing

another synthesizer driver for speakup.  It was the Speakout driver so

it was also the first serial driver.

Brian Borowski, he was the first person to actually write a speakup

function other than Andy and I.

Jim Danley, he has more or less become my main man in helping test

code, add new features, bounce ideas off and generally become a good

friend.

Matt Campbell, he basically rewrote the drivers to be able to include

all synths in the kernel at the same time.  The distribution

maintainers appreciate him a lot as well.

Gene Collins, he was very helpful debugging the current release prior

to its public showing.  He has also worked hard educating others on

the list and writing the ALSA mini howto.

I would also like to really thank the folks that handle the

distribution packages.  I and many other people would not find access

to speakup nearly so convenient without their efforts.  They include

Bill Acker, Tom Moore, Matt Campbell, Joe Norton and Joshua Lambert.

There are probably many more I am forgetting right now.  I guess I'll

just have to add you all later.

Happy Hacking!

  Kirk

The Speakup User's Guide

For Speakup 2.0 and Later

By Gene Collins

Last modified on Tue Mar 29 10:54:19 2005

Document version 1.0

Copyright (c) 2005  Gene Collins

Permission is granted to copy, distribute and/or modify this document

under the terms of the GNU Free Documentation License, Version 1.2 or

any later version published by the Free Software Foundation; with no

Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A

copy of the license is included in the section entitled "GNU Free

Documentation License".

Preface

The purpose of this document is to familiarize users with the user

interface to Speakup, a Linux Screen Reader.  If you need instructions

for installing or obtaining Speakup, visit the web site at

http://linux-speakup.org/.  Speakup is a set of patches to the standard

Linux kernel source tree.  It can be built as a series of modules, or as

a part of a monolithic kernel.  These details are beyond the scope of

this manual, but the user may need to be aware of the module

capabilities, depending on how your system administrator has installed

Speakup.  If Speakup is built as a part of a monolithic kernel, and the

user is using a hardware synthesizer, then Speakup will be able to

provide speech access from the time the kernel is loaded, until the time

the system is shutdown.  This means that if you have obtained Linux

installation media for a distribution which includes Speakup as a part

of its kernel, you will be able, as a blind person, to install Linux

with speech access unaided by a sighted person.  Again, these details

are beyond the scope of this manual, but the user should be aware of

them.  See the web site mentioned above for further details.

1.  Starting Speakup

If your system administrator has installed Speakup to work with your

specific synthesizer by default, then all you need to do to use Speakup

is to boot your system, and Speakup should come up talking.  This

assumes of course  that your synthesizer is a supported hardware

synthesizer, and that it is either installed in or connected to your

system, and is if necessary powered on.

It is possible, however, that Speakup may have been compiled into the

kernel with no default synthesizer.  It is even possible that your

kernel has been compiled with support for some of the supported

synthesizers and not others.  If you find that this is the case, and

your synthesizer is supported but not available, complain to the person

who compiled and installed your kernel.  Or better yet, go to the web

site, and learn how to patch Speakup into your own kernel source, and

build and install your own kernel.

If your kernel has been compiled with Speakup, and has no default

synthesizer set, or you would like to use a different synthesizer than

the default one, then you may issue the following command at the boot

prompt of your boot loader.

linux speakup_synth=ltlk

This command would tell Speakup to look for and use a LiteTalk or

DoubleTalk LT at boot up.  You may replace the ltlk synthesizer keyword

with the keyword for whatever synthesizer you wish to use.  The

speakup_synth parameter will accept the following keywords, provided

that support for the related synthesizers has been built into the

kernel.

acntsa -- Accent SA

acntpc -- Accent PC

apolo -- Apolo

audptr -- Audapter

bns -- Braille 'n Speak

dectlk -- DecTalk Express (old and new, db9 serial only)

decext -- DecTalk (old) External

dtlk -- DoubleTalk PC

keypc -- Keynote Gold PC

ltlk -- DoubleTalk LT, LiteTalk, or external Tripletalk (db9 serial only)

spkout -- Speak Out

txprt -- Transport

Note: Speakup does * NOT * support usb connections!  Speakup also does *

NOT * support the internal Tripletalk!

Speakup does support two other synthesizers, but because they work in

conjunction with other software, they must be loaded as modules after

their related software is loaded, and so are not available at boot up. 

These are as follows:

decpc -- DecTalk PC (not available at boot up)

sftsyn -- One of several software synthesizers (not available at boot up)

See the sections on loading modules and software synthesizers later in

this manual for further details.  It should be noted here that the

speakup_synth boot parameter will have no effect if Speakup has been

compiled as modules.  In order for Speakup modules to be loaded during

the boot process, such action must be configured by your system

administrator.  This will mean that you will hear some, but not all,  of

the bootup messages.

2.  Basic operation

Once you have booted the system, and if necessary, have supplied the

proper bootup parameter for your synthesizer, Speakup will begin

talking as soon as the kernel is loaded.  In fact, it will talk a lot! 

It will speak all the boot up messages that the kernel prints on the

screen during the boot process.  This is because Speakup is not a

separate screen reader, but is actually built into the operating

system.  Since almost all console applications must print text on the

screen using the kernel, and must get their keyboard input through the

kernel, they are automatically handled properly by Speakup.  There are a

few exceptions, but we'll come to those later.

Note:  In this guide I will refer to the numeric keypad as the keypad. 

This is done because the speakupmap.map file referred to later in this

manual uses the term keypad instead of numeric keypad.  Also I'm lazy

and would rather only type one word.  So keypad it is.  Got it?  Good.

Most of the Speakup review keys are located on the keypad at the far

right of the keyboard.  The numlock key should be off, in order for these

to work.  If you toggle the numlock on, the keypad will produce numbers,

which is exactly what you want for spreadsheets and such.  For the

purposes of this guide, you should have the numlock turned off, which is

its default state at bootup.

You probably won't want to listen to all the bootup messages every time

you start your system, though it's a good idea to listen to them at

least once, just so you'll know what kind of information is available to

you during the boot process.  You can always review these messages after

bootup with the command:

dmesg | more

In order to speed the boot process, and to silence the speaking of the

bootup messages, just press the keypad enter key.  This key is located

in the bottom right corner of the keypad.  Speakup will shut up and stay

that way, until you press another key.

You can check to see if the boot process has completed by pressing the 8

key on the keypad, which reads the current line.  This also has the

effect of starting Speakup talking again, so you can press keypad enter

to silence it again if the boot process has not completed.  

When the boot process is complete, you will arrive at a "login" prompt.

At this point, you'll need to type in your user id and password, as

provided by your system administrator.  You will hear Speakup speak the

letters of your user id as you type it, but not the password.  This is

because the password is not displayed on the screen for security

reasons.  This has nothing to do with Speakup, it's a Linux security

feature.

Once you've logged in, you can run any Linux command or program which is

allowed by your user id.  Normal users will not be able to run programs

which require root privileges.

When you are running a program or command, Speakup will automatically

speak new text as it arrives on the screen.  You can at any time silence

the speech with keypad enter, or use any of the Speakup review keys. 

Here are some basic Speakup review keys, and a short description of what

they do.

keypad 1 -- read previous character

keypad 2 -- read current character (pressing keypad 2 twice rapidly will speak

	the current character phonetically)

keypad 3 -- read next character

keypad 4 -- read previous word

keypad 5 -- read current word (press twice rapidly to spell the current word)

keypad 6 -- read next word

keypad 7 -- read previous line

keypad 8 -- read current line (press twice rapidly to hear how much the

	text on the current line is indented)

keypad 9 -- read next line

keypad period -- speak current cursor position and announce current

	virtual console

It's also worth noting that the insert key on the keypad is mapped

as the speakup key.  Instead of pressing and releasing this key, as you

do under DOS or Windows, you hold it like a shift key, and press other

keys in combination with it.  For example, repeatedly holding keypad

insert, from now on called speakup, and keypad enter will toggle the

speaking of new text on the screen on and off.  This is not the same as

just pressing keypad enter by itself, which just silences the speech

until you hit another key.  When you hit speakup plus keypad enter,

Speakup will say, "You turned me off.", or "Hey, that's better."  When

Speakup is turned off, no new text on the screen will be spoken.  You

can still use the reading controls to review the screen however.

3.  Using the Speakup Help System

Speakup has a help system, which is compiled as a module.  It is loaded

automatically whenever the Speakup help system is invoked for the first

time, and remains loaded after that, until speakup is unloaded.  Note

that if speakup was compiled into a monolithic kernel on your system,

you will not be able to unload Speakup from your kernel.  If you try to

use the help system, and find that it is unavailable, then your system

administrator has not installed the Speakup help module, which is called

speakup_help.  Complain to your system administrator about this.

In order to enter the Speakup help system, press and hold the speakup

key (remember that this is the keypad insert key), and press the f1 key.

You will hear the message:

"Press space to leave help, cursor up or down to scroll, or a letter to

go to commands in list."

When you press the spacebar to leave the help system, you will hear:

"Leaving help."

While you are in the Speakup help system, you can scroll up or down

through the list of available commands using the cursor keys.  The list

of commands is arranged in alphabetical order.  If you wish to jump to

commands in a specific part of the alphabet, you may press the letter of

the alphabet you wish to jump to.

You can also just explore by typing keyboard keys.  Pressing keys will

cause Speakup to speak the command associated with that key.  For

example, if you press the keypad 8 key, you will hear:

"Keypad 8 is line, say current."

You'll notice that some commands do not have keys assigned to them. 

This is because they are very infrequently used commands, and are also

accessible through the proc system.  We'll discuss the proc system later

in this manual.

You'll also notice that some commands have two keys assigned to them. 

This is because Speakup has a built in set of alternative key bindings

for laptop users.  The alternate speakup key is the caps lock key.  You

can press and hold the caps lock key, while pressing an alternate

speakup command key to activate the command.  On most laptops, the

numeric keypad is defined as the keys in the j k l area of the keyboard.

There is usually a function key which turns this keypad function on and

off, and some other key which controls the numlock state.  Toggling the

keypad functionality on and off can become a royal pain.  So, Speakup

gives you a simple way to get at an alternative set of key mappings for

your laptop.  These are also available by default on desktop systems,

because Speakup does not know whether it is running on a desktop or

laptop.  So you may choose which set of Speakup keys to use.  Some

system administrators may have chosen to compile Speakup for a desktop

system without this set of alternate key bindings, but these details are

beyond the scope of this manual.  To use the caps lock for its normal

purpose, hold the shift key while toggling the caps lock on and off.  We

should note here, that holding the caps lock key and pressing the z key

will toggle the alternate j k l keypad on and off.

4.  Keys and Their Assigned Commands

In this section, we'll go through a list of all the speakup keys and

commands.  You can also get a list of commands and assigned keys from

the help system.

The following list was taken from the speakupmap.map file.  Key

assignments are on the left of the equal sign, and the associated

Speakup commands are on the right.  The designation "spk" means to press

and hold the speakup key, a.k.a. keypad insert, a.k.a. caps lock, while

pressing the other specified key.

spk key_f9 = punc_level_dec

spk key_f10 = punc_level_inc

spk key_f11 = reading_punc_dec

spk key_f12 = reading_punc_inc

spk key_1 = vol_dec

spk key_2 =  vol_inc

spk key_3 = pitch_dec

spk key_4 = pitch_inc

spk key_5 = rate_dec

spk key_6 = rate_inc

key_kpasterisk = toggle_cursoring

spk key_kpasterisk = speakup_goto

spk key_f1 = speakup_help

spk key_f2 = set_win

spk key_f3 = clear_win

spk key_f4 = enable_win

spk key_f5 = edit_some

spk key_f6 = edit_most

spk key_f7 = edit_delim

spk key_f8 = edit_repeat

shift spk key_f9 = edit_exnum

 key_kp7 = say_prev_line

spk key_kp7 = left_edge

 key_kp8 = say_line

double  key_kp8 = say_line_indent

spk key_kp8 = say_from_top

 key_kp9 = say_next_line

spk  key_kp9 = top_edge

 key_kpminus = speakup_parked

spk key_kpminus = say_char_num

 key_kp4 = say_prev_word

spk key_kp4 = say_from_left

 key_kp5 = say_word

double key_kp5 = spell_word

spk key_kp5 = spell_phonetic

 key_kp6 = say_next_word

spk key_kp6 = say_to_right

 key_kpplus = say_screen

spk key_kpplus = say_win

 key_kp1 = say_prev_char 

spk key_kp1 = right_edge

 key_kp2 = say_char

spk key_kp2 = say_to_bottom

double key_kp2 = say_phonetic_char

 key_kp3 = say_next_char  

spk  key_kp3 = bottom_edge

 key_kp0 = spk_key

 key_kpdot = say_position

spk key_kpdot = say_attributes

key_kpenter = speakup_quiet

spk key_kpenter = speakup_off

key_sysrq = speech_kill

 key_kpslash = speakup_cut

spk key_kpslash = speakup_paste

spk key_pageup = say_first_char

spk key_pagedown = say_last_char

key_capslock = spk_key

 spk key_z = spk_lock

key_leftmeta = spk_key

ctrl spk key_0 = speakup_goto

spk key_u = say_prev_line

spk key_i = say_line

double spk key_i = say_line_indent

spk key_o = say_next_line

spk key_minus = speakup_parked

shift spk key_minus = say_char_num

spk key_j = say_prev_word

spk key_k = say_word

double spk key_k = spell_word

spk key_l = say_next_word

spk key_m = say_prev_char

spk key_comma = say_char

double spk key_comma = say_phonetic_char

spk key_dot = say_next_char

spk key_n = say_position

 ctrl spk key_m = left_edge

 ctrl spk key_y = top_edge

 ctrl spk key_dot = right_edge

ctrl spk key_p = bottom_edge

spk key_apostrophe = say_screen

spk key_h = say_from_left

spk key_y = say_from_top

spk key_semicolon = say_to_right

spk key_p = say_to_bottom

spk key_slash = say_attributes

 spk key_enter = speakup_quiet

 ctrl  spk key_enter = speakup_off

 spk key_9 = speakup_cut

spk key_8 = speakup_paste

shift spk key_m = say_first_char

 ctrl spk key_semicolon = say_last_char

5.  The Speakup Proc System

The Speakup screen reader also creates a speakup subdirectory as a part

of the proc system.  You can see these entries by typing the command:

ls -1 /proc/speakup/*

If you issue the above ls command, you will get back something like

this:

/proc/speakup/attrib_bleep

/proc/speakup/bell_pos

/proc/speakup/bleep_time

/proc/speakup/bleeps

/proc/speakup/caps_start

/proc/speakup/caps_stop

/proc/speakup/characters

/proc/speakup/cursor_time

/proc/speakup/delay_time

/proc/speakup/delimiters

/proc/speakup/ex_num

/proc/speakup/freq

/proc/speakup/full_time

/proc/speakup/jiffy_delta

/proc/speakup/key_echo

/proc/speakup/keymap

/proc/speakup/no_interrupt

/proc/speakup/pitch

/proc/speakup/punc_all

/proc/speakup/punc_level

/proc/speakup/punc_most

/proc/speakup/punc_some

/proc/speakup/punct

/proc/speakup/rate

/proc/speakup/reading_punc

/proc/speakup/repeats

/proc/speakup/say_control

/proc/speakup/say_word_ctl

/proc/speakup/silent

/proc/speakup/spell_delay

/proc/speakup/synth_direct

/proc/speakup/synth_name

/proc/speakup/tone

/proc/speakup/trigger_time

/proc/speakup/version

/proc/speakup/voice

/proc/speakup/vol

In addition to using the Speakup hot keys to change such things as

volume, pitch, and rate, you can also echo values to the appropriate

entry in the /proc/speakup directory.  This is very useful, since it

lets you control Speakup parameters from within a script.  How you

would write such scripts is somewhat beyond the scope of this manual,

but I will include a couple of simple examples here to give you a

general idea of what such scripts can do.

Suppose for example, that you wanted to control both the punctuation

level and the reading punctuation level at the same time.  For

simplicity, we'll call them punc0, punc1, punc2, and punc3.  The scripts

might look something like this:

#!/bin/bash

# punc0

# set punc and reading punc levels to 0

echo 0 >/proc/speakup/punc_level

echo 0 >/proc/speakup/reading_punc

echo Punctuation level set to 0.

#!/bin/bash

# punc1

# set punc and reading punc levels to 1

echo 1 >/proc/speakup/punc_level

echo 1 >/proc/speakup/reading_punc

echo Punctuation level set to 1.

#!/bin/bash

# punc2

# set punc and reading punc levels to 2

echo 2 >/proc/speakup/punc_level

echo 2 >/proc/speakup/reading_punc

echo Punctuation level set to 2.

#!/bin/bash

# punc3

# set punc and reading punc levels to 3

echo 3 >/proc/speakup/punc_level

echo 3 >/proc/speakup/reading_punc

echo Punctuation level set to 3.

If you were to store these four small scripts in a directory in your

path, perhaps /usr/local/bin, and set the permissions to 755 with the

chmod command, then you could change the default reading punc and

punctuation levels at the same time by issuing just one command.  For

example, if you were to execute the punc3 command at your shell prompt,

then the reading punc and punc level would both get set to 3.

I should note that the above scripts were written to work with bash, but

regardless of which shell you use, you should be able to do something

similar.

The Speakup proc system also has another interesting use.  You can echo

Speakup parameters into the proc system in a script during system

startup, and speakup will return to your preferred parameters every time

the system is rebooted.

Most of the Speakup proc parameters can be manipulated by a regular user

on the system.  However, there are a few parameters that are dangerous

enough that they should only be manipulated by the root user on your

system.  There are even some parameters that are read only, and cannot

be written to at all.  For example, the version entry in the Speakup

proc system is read only.  This is because there is no reason for a user

to tamper with the version number which is reported by Speakup.  Doing

an ls -l on /proc/speakup/version will return this:

-r--r--r--    1 root     root            0 Mar 21 13:46 /proc/speakup/version

As you can see, the version entry in the Speakup proc system is read

only, is owned by root, and belongs to the root group.  Doing a cat of

/proc/speakup/version will display the Speakup version number, like

this:

cat /proc/speakup/version

Speakup v-2.00 CVS: Thu Oct 21 10:38:21 EDT 2004 

synth dtlk version 1.1

The display shows the Speakup version number, along with the version

number of the driver for the current synthesizer.

Looking at entries in the Speakup proc system can be useful in many

ways.  For example, you might wish to know what level your volume is set

at.  You could type:

cat /proc/speakup/vol

5

The number five which comes back is the level at which the synthesizer

volume is set at.

All the entries in the Speakup proc system are readable, some are

writable by root only, and some are writable by everyone.  Unless you

know what you are doing, you should probably leave the ones that are

writable by root only alone.  Most of the names are self explanatory. 

Vol for controlling volume, pitch for pitch, rate for controlling speaking

rate, etc.  If you find one you aren't sure about, you can post a query

on the Speakup list.

6.  Changing Synthesizers

It is possible to change to a different synthesizer while speakup is

running.  In other words, it is not necessary to reboot the system

in order to use a different synthesizer.  You can simply echo the

synthesizer keyword to the /proc/speakup/synth_name proc entry. 

Depending on your situation, you may wish to echo none to the synth_name

proc entry, to disable speech while one synthesizer is disconnected and

a second one is connected in its place.  Then echo the keyword for the

new synthesizer into the synth_name proc entry in order to start speech

with the newly connected synthesizer.  See the list of synthesizer

keywords in section 1 to find the keyword which matches your synth.

7.  Loading modules

As mentioned earlier, Speakup can either be completely compiled into the

kernel, with the exception of the help module, or it can be compiled as

a series of modules.   When compiled as modules, Speakup will only be

able to speak some of the bootup messages if your system administrator

has configured the system to load the modules at boo time. The modules

can  be loaded after the file systems have been checked and mounted, or

from an initrd.  There is a third possibility.  Speakup can be compiled

with some components built into the kernel, and others as modules.  As

we'll see in the next section, this is particularly useful when you are

working with software synthesizers.

If Speakup is completely compiled as modules, then you must use the

modprobe command to load Speakup.  You do this by loading the module for

the synthesizer driver you wish to use.  The driver modules are all

named speakup_<keyword>, where <keyword> is the keyword for the

synthesizer you want.  So, in order to load the driver for the DecTalk

Express, you would type the following command:

modprobe speakup_dectlk

Issuing this command would load the DecTalk Express driver and all other

related Speakup modules necessary to get Speakup up and running.

To completely unload Speakup, again presuming that it is entirely built

as modules, you would give the command:

modprobe -r speakup_dectlk

The above command assumes you were running a DecTalk Express.  If you

were using a different synth, then you would substitute its keyword in

place of dectlk.

But now, suppose we have a situation where the main Speakup component

is built into the kernel, and some or all of the drivers are built as

modules.  Since the main part of Speakup is compiled into the kernel, a

partial Speakup proc system has been created which we can take advantage

of by simply echoing the synthesizer keyword into the

/proc/speakup/synth_name proc entry.  This will cause the kernel to

automatically load the appropriate driver module, and start Speakup

talking.  To switch to another synth, just echo a new keyword to the

synth_name proc entry.  For example, to load the DoubleTalk LT driver,

you would type:

echo ltlk >/proc/speakup/synth_name

You can use the modprobe -r command to unload driver modules, regardless

of whether the main part of Speakup has been built into the kernel or

not.

8.  Using Software Synthesizers

Using a software synthesizer requires that some other software be

installed and running on your system.  For this reason, software

synthesizers are not available for use at bootup, or during a system

installation process.

In order to use a software synthesizer, you must have a package called

Speech Dispatcher running on your system, and it must be configured to

work with one of its supported software synthesizers.

Two open source synthesizers you might use are Flite and Festival.  You

might also choose to purchase the Software DecTalk from Fonix Sales Inc.

If you run a google search for Fonix, you'll find their web site.

You can obtain a copy of Speech Dispatcher from free(b)soft at

http://www.freebsoft.org/.  Follow the installation instructions that

come with Speech Dispatcher in order to install and configure Speech

Dispatcher.  You can check out the web site for your Linux distribution

in order to get a copy of either Flite or Festival.  Your Linux

distribution may also have a precompiled Speech Dispatcher package.

Once you've installed, configured, and tested Speech Dispatcher with your

chosen software synthesizer, you still need one more piece of software

in order to make things work.  You need a package called speechd-up. 

You get it from the free(b)soft web site mentioned above.  After you've

compiled and installed speechd-up, you are almost ready to begin using

your software synthesizer.

Before you can use a software synthesizer, you must have created the

/dev/softsynth device.  If you have not already done so, issue the

following commands as root:

cd /dev

mknod softsynth c 10 26

While we are at it, we might just as well create the /dev/synth device,

which can be used to let user space programs send information to your

synthesizer.  To create /dev/synth, change to the /dev directory, and

issue the following command as root:

mknod synth c 10 25

Now you can begin using your software synthesizer.  In order to do so,

echo the sftsyn keyword to the synth_name proc entry like this:

echo sftsyn >/proc/speakup/synth_name

Next run the speechd_up command like this:

speechd_up &

Your synth should now start talking, and you should be able to adjust

the pitch, rate, etc.

In this section, we have assumed that your copy of Speakup was compiled

with the speakup_sftsyn component either built into the kernel, or

compiled as a module.

9.  Using The DecTalk PC Card

The DecTalk PC card is an ISA card that is inserted into one of the ISA

slots in your computer.  It requires that the DecTalk PC software be

installed on your computer, and that the software be loaded onto the

Dectalk PC card before it can be used.

You can get the dec_pc.tgz file from the linux-speakup.org site.  The

dec_pc.tgz file is in the ~ftp/pub/linux/speakup directory.

After you have downloaded the dec_pc.tgz file, untar it in your home

directory, and read the Readme file in the newly created dec_pc

directory.

The easiest way to get the software working is to copy the entire dec_pc

directory into /user/local/lib.  To do this, su to root in your home

directory, and issue the command:

cp dec_pc /usr/local/lib

You will need to copy the dtload command from the dec_pc directory to a

directory in your path.  Either /usr/bin or /usr/local/bin is a good

choice.

You can now run the dtload command in order to load the DecTalk PC

software onto the card.  After you have done this, echo the decpc

keyword to the synth_name entry in the proc system like this:

echo decpc >/proc/speakup/synth_name

Your DecTalk PC should start talking, and then you can adjust the pitch,

rate, volume, voice, etc.  The voice entry in the Speakup proc system

will accept a number from 0 through 7 for the DecTalk PC synthesizer,

which will give you access to some of the DecTalk voices.

10.  Using Cursor Tracking

In Speakup version 2.0 and later, cursor tracking is turned on by

default.  This means that when you are using an editor, Speakup will

automatically speak characters as you move left and right with the

cursor keys, and lines as you move up and down with the cursor keys.

This is extremely useful, and makes editing files a snap.  But there are

times when cursor tracking can get in your way.  So Speakup provides a

toggle to turn cursor tracking on and off.  You do this with the keypad

asterisk key.  Pressing this key repeatedly will toggle the cursor

tracking on and off, and you will hear Speakup say, "cursoring off", and

"cursoring on".

Some folks like to turn cursor tracking off while they are using the

lynx web browser.  You definitely want to turn cursor tracking off when

you are using the alsamixer application.  Otherwise, you won't be able

to hear your mixer settings while you are using the arrow keys.

11.  Cut and Paste

One of Speakup's more useful features is the ability to cut and paste

text on the screen.  This means that you can capture information from a

program, and paste that captured text into a different place in the

program, or into an entirely different program, which may even be

running on a different console.

For example, in this manual, we have made references to several web

sites.  It would be nice if you could cut and paste these urls into your

web browser.  Speakup does this quite nicely.  Suppose you wanted to

past the following url into your browser:

http://linux-speakup.org/

Use the speakup review keys to position the reading cursor on the first

character of the above url.  When the reading cursor is in position,

press the keypad slash key once.  Speakup will say, "mark".  Next,

position the reading cursor on the rightmost character of the above

url. Press the keypad slash key once again to actually cut the text

from the screen.  Speakup will say, "cut".  Although we call this

cutting, Speakup does not actually delete the cut text from the screen. 

It makes a copy of the text in a special buffer for later pasting.

Now that you have the url cut from the screen, you can paste it into

your browser, or even paste the url on a command line as an argument to

your browser.

Suppose you want to start lynx and go to the Speakup site.

You can switch to a different console with the alt left and right

arrows, or you can switch to a specific console by typing alt and a

function key.  These are not Speakup commands, just standard Linux

console capabilities.

Once you've changed to an appropriate console, and are at a shell prompt,

type the word lynx, followed by a space.  Now press and hold the speakup

key, while you type the keypad slash character.  The url will be pasted

onto the command line, just as though you had typed it in.  Press the

enter key to execute the command.

The paste buffer will continue to hold the cut information, until a new

mark and cut operation is carried out.  This means you can paste the cut

information as many times as you like before doing another cut

operation.

You are not limited to cutting and pasting only one line on the screen.

You can also cut and paste rectangular regions of the screen.  Just

position the reading cursor at the top left corner of the text to be

cut, mark it with the keypad slash key, then position the reading cursor

at the bottom right corner of the region to be cut, and cut it with the

keypad slash key.

12.  Changing the Pronunciation of Characters

Through the /proc/speakup/chars proc entry, Speakup gives you the

ability to change how Speakup pronounces a given character.  You could,

for example, change how some punctuation characters are spoken.  You can

even change how Speakup will pronounce certain letters.

You may, for example, wish to change how Speakup pronounces the z

character.  The author of Speakup, Kirk Reiser, is Canadian, and thus

believes that the z should be pronounced zed.  If you are an American,

you might wish to use the zee pronunciation instead of zed.  You can

change the pronunciation of both the upper and lower case z with the

following two commands:

echo 90 zee >/proc/speakup/characters

echo 122 zee >/proc/speakup/characters

Let's examine the parts of the two previous commands.  They are issued

at the shell prompt, and could be placed in a startup script.

The word echo tells the shell that you want to have it display the

string of characters that follow the word echo.  If you were to just

type:

echo hello.

You would get the word hello printed on your screen as soon as you

pressed the enter key.  In this case, we are echoing strings that we

want to be redirected into the proc system.

The numbers 90 and 122 in the above echo commands are the ascii numeric

values for the upper and lower case z, the characters we wish to change.

The string zee is the pronunciation that we want Speakup to use for the

upper and lower case z.

The > symbol redirects the output of the echo command to a file, just

like in DOS, or at the Windows command prompt.

And finally, /proc/speakup/chars is the file entry in the proc system

where we want the output to be directed.  Speakup looks at the numeric

value of the character we want to change, and inserts the pronunciation

string into an internal table.

You can look at the whole table with the following command:

cat /proc/speakup/chars

Speakup will then print out the entire character pronunciation table.  I

won't display it here, but leave you to look at it at your convenience.

13.  Mapping Keys

Speakup has the capability of allowing you to assign or "map" keys to

internal Speakup commands.  This section necessarily assumes you have a

Linux kernel source tree installed, and that it has been patched and

configured with Speakup.  How you do this is beyond the scope of this

manual.  For this information, visit the Speakup web site at

http://linux-speakup.org/.  The reason you'll need the kernel source

tree patched with Speakup is that the genmap utility you'll need for

processing keymaps is in the

/usr/src/linux-<version_number>/drivers/char/speakup directory.  The

<version_number> in the above directory path is the version number of

the Linux source tree you are working with.

So ok, you've gone off and gotten your kernel source tree, and patched

and configured it.  Now you can start manipulating keymaps.

You can either use the

/usr/src/linux-<version_number>/drivers/char/speakup/speakupmap.map file

included with the Speakup source, or you can cut and paste the copy in

section 4 into a separate file.  If you use the one in the Speakup

source tree, make sure you make a backup of it before you start making

changes.  You have been warned!

Suppose that you want to swap the key assignments for the Speakup

say_last_char and the Speakup say_first_char commands.  The

speakupmap.map lists the key mappings for these two commands as follows:

spk key_pageup = say_first_char

spk key_pagedown = say_last_char

You can edit your copy of the speakupmap.map file and swap the command

names on the right side of the = (equals) sign.  You did make a backup,

right?  The new keymap lines would look like this:

spk key_pageup = say_last_char

spk key_pagedown = say_first_char

After you edit your copy of the speakupmap.map file, save it under a new

file name, perhaps newmap.map.  Then exit your editor and return to the

shell prompt.

You are now ready to load your keymap with your swapped key assignments.

 Assuming that you saved your new keymap as the file newmap.map, you

would load your keymap into the proc system like this:

/usr/src/linux-<version_number>/drivers/char/speakup/genmap newmap.map

>/proc/speakup/keymap

Remember to substitute your kernel version number for the

<version_number> in the above command.  Also note that although the

above command wrapped onto two lines in this document, you should type

it all on one line.

Your say first and say last characters should now be swapped.  Pressing

speakup pagedown should read you the first non-whitespace character on

the line your reading cursor is in, and pressing speakup pageup should

read you the last character on the line your reading cursor is in.

You should note that these new mappings will only stay in effect until

you reboot, or until you load another keymap.

One final warning.  If you try to load a partial map, you will quickly

find that all the mappings you didn't include in your file got deleted

from the working map.  Be extremely careful, and always make a backup! 

You have been warned!

14.  Using Speakup's Windowing Capability

Speakup has the capability of defining and manipulating windows on the

screen.  Speakup uses the term "Window", to mean a user defined area of

the screen.  The key strokes for defining and manipulating Speakup

windows are as follows:

speakup + f2 -- Set the bounds of the window.

Speakup + f3 -- clear the current window definition.

speakup + f4 -- Toggle window silence on and off.

speakup + keypad plus -- Say the currently defined window.

These capabilities are useful for tracking a certain part of the screen

without rereading the whole screen, or for silencing a part of the

screen that is constantly changing, such as a clock or status line.

There is no way to save these window settings, and you can only have one

window defined for each virtual console.  There is also no way to have

windows automaticly defined for specific applications.

In order to define a window, use the review keys to move your reading

cursor to the beginning of the area you want to define.  Then press

speakup + f2.  Speakup will tell you that the window starts at the

indicated row and column position.  Then move the reading cursor to the

end of the area to be defined as a window, and press speakup + f2 again.

 If there is more than one line in the window, Speakup will tell you

that the window ends at the indicated row and column position.  If there

is only one line in the window, then Speakup will tell you that the

window is the specified line on the screen.  If you are only defining a

one line window, you can just press speakup + f2 twice after placing the

reading cursor on the line you want to define as a window.  It is not

necessary to position the reading cursor at the end of the line in order

to define the whole line as a window.

                GNU Free Documentation License

                  Version 1.2, November 2002

 Copyright (C) 2000,2001,2002  Free Software Foundation, Inc.

     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 Everyone is permitted to copy and distribute verbatim copies

 of this license document, but changing it is not allowed.

0. PREAMBLE

The purpose of this License is to make a manual, textbook, or other

functional and useful document "free" in the sense of freedom: to

assure everyone the effective freedom to copy and redistribute it,

with or without modifying it, either commercially or noncommercially.

Secondarily, this License preserves for the author and publisher a way

to get credit for their work, while not being considered responsible

for modifications made by others.

This License is a kind of "copyleft", which means that derivative

works of the document must themselves be free in the same sense.  It

complements the GNU General Public License, which is a copyleft

license designed for free software.

We have designed this License in order to use it for manuals for free

software, because free software needs free documentation: a free

program should come with manuals providing the same freedoms that the

software does.  But this License is not limited to software manuals;

it can be used for any textual work, regardless of subject matter or

whether it is published as a printed book.  We recommend this License

principally for works whose purpose is instruction or reference.

1. APPLICABILITY AND DEFINITIONS

This License applies to any manual or other work, in any medium, that

contains a notice placed by the copyright holder saying it can be

distributed under the terms of this License.  Such a notice grants a

world-wide, royalty-free license, unlimited in duration, to use that

work under the conditions stated herein.  The "Document", below,

refers to any such manual or work.  Any member of the public is a

licensee, and is addressed as "you".  You accept the license if you

copy, modify or distribute the work in a way requiring permission

under copyright law.

A "Modified Version" of the Document means any work containing the

Document or a portion of it, either copied verbatim, or with

modifications and/or translated into another language.

A "Secondary Section" is a named appendix or a front-matter section of

the Document that deals exclusively with the relationship of the

publishers or authors of the Document to the Document's overall subject

(or to related matters) and contains nothing that could fall directly

within that overall subject.  (Thus, if the Document is in part a

textbook of mathematics, a Secondary Section may not explain any

mathematics.)  The relationship could be a matter of historical

connection with the subject or with related matters, or of legal,

commercial, philosophical, ethical or political position regarding

them.

The "Invariant Sections" are certain Secondary Sections whose titles

are designated, as being those of Invariant Sections, in the notice

that says that the Document is released under this License.  If a

section does not fit the above definition of Secondary then it is not

allowed to be designated as Invariant.  The Document may contain zero

Invariant Sections.  If the Document does not identify any Invariant

Sections then there are none.

The "Cover Texts" are certain short passages of text that are listed,

as Front-Cover Texts or Back-Cover Texts, in the notice that says that

the Document is released under this License.  A Front-Cover Text may

be at most 5 words, and a Back-Cover Text may be at most 25 words.

A "Transparent" copy of the Document means a machine-readable copy,

represented in a format whose specification is available to the

general public, that is suitable for revising the document

straightforwardly with generic text editors or (for images composed of

pixels) generic paint programs or (for drawings) some widely available

drawing editor, and that is suitable for input to text formatters or

for automatic translation to a variety of formats suitable for input

to text formatters.  A copy made in an otherwise Transparent file

format whose markup, or absence of markup, has been arranged to thwart

or discourage subsequent modification by readers is not Transparent.

An image format is not Transparent if used for any substantial amount

of text.  A copy that is not "Transparent" is called "Opaque".

Examples of suitable formats for Transparent copies include plain

ASCII without markup, Texinfo input format, LaTeX input format, SGML

or XML using a publicly available DTD, and standard-conforming simple

HTML, PostScript or PDF designed for human modification.  Examples of

transparent image formats include PNG, XCF and JPG.  Opaque formats

include proprietary formats that can be read and edited only by

proprietary word processors, SGML or XML for which the DTD and/or

processing tools are not generally available, and the

machine-generated HTML, PostScript or PDF produced by some word

processors for output purposes only.

The "Title Page" means, for a printed book, the title page itself,

plus such following pages as are needed to hold, legibly, the material

this License requires to appear in the title page.  For works in

formats which do not have any title page as such, "Title Page" means

the text near the most prominent appearance of the work's title,

preceding the beginning of the body of the text.

A section "Entitled XYZ" means a named subunit of the Document whose

title either is precisely XYZ or contains XYZ in parentheses following

text that translates XYZ in another language.  (Here XYZ stands for a

specific section name mentioned below, such as "Acknowledgements",

"Dedications", "Endorsements", or "History".)  To "Preserve the Title"

of such a section when you modify the Document means that it remains a

section "Entitled XYZ" according to this definition.

The Document may include Warranty Disclaimers next to the notice which

states that this License applies to the Document.  These Warranty

Disclaimers are considered to be included by reference in this

License, but only as regards disclaiming warranties: any other

implication that these Warranty Disclaimers may have is void and has

no effect on the meaning of this License.

2. VERBATIM COPYING

You may copy and distribute the Document in any medium, either

commercially or noncommercially, provided that this License, the

copyright notices, and the license notice saying this License applies

to the Document are reproduced in all copies, and that you add no other

conditions whatsoever to those of this License.  You may not use

technical measures to obstruct or control the reading or further

copying of the copies you make or distribute.  However, you may accept

compensation in exchange for copies.  If you distribute a large enough

number of copies you must also follow the conditions in section 3.

You may also lend copies, under the same conditions stated above, and

you may publicly display copies.

3. COPYING IN QUANTITY

If you publish printed copies (or copies in media that commonly have

printed covers) of the Document, numbering more than 100, and the

Document's license notice requires Cover Texts, you must enclose the

copies in covers that carry, clearly and legibly, all these Cover

Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on

the back cover.  Both covers must also clearly and legibly identify

you as the publisher of these copies.  The front cover must present

the full title with all words of the title equally prominent and

visible.  You may add other material on the covers in addition.

Copying with changes limited to the covers, as long as they preserve

the title of the Document and satisfy these conditions, can be treated

as verbatim copying in other respects.

If the required texts for either cover are too voluminous to fit

legibly, you should put the first ones listed (as many as fit

reasonably) on the actual cover, and continue the rest onto adjacent

pages.

If you publish or distribute Opaque copies of the Document numbering

more than 100, you must either include a machine-readable Transparent

copy along with each Opaque copy, or state in or with each Opaque copy

a computer-network location from which the general network-using

public has access to download using public-standard network protocols

a complete Transparent copy of the Document, free of added material.

If you use the latter option, you must take reasonably prudent steps,

when you begin distribution of Opaque copies in quantity, to ensure

that this Transparent copy will remain thus accessible at the stated

location until at least one year after the last time you distribute an

Opaque copy (directly or through your agents or retailers) of that

edition to the public.

It is requested, but not required, that you contact the authors of the

Document well before redistributing any large number of copies, to give

them a chance to provide you with an updated version of the Document.

4. MODIFICATIONS

You may copy and distribute a Modified Version of the Document under

the conditions of sections 2 and 3 above, provided that you release

the Modified Version under precisely this License, with the Modified

Version filling the role of the Document, thus licensing distribution

and modification of the Modified Version to whoever possesses a copy

of it.  In addition, you must do these things in the Modified Version:

A. Use in the Title Page (and on the covers, if any) a title distinct

   from that of the Document, and from those of previous versions

   (which should, if there were any, be listed in the History section

   of the Document).  You may use the same title as a previous version

   if the original publisher of that version gives permission.

B. List on the Title Page, as authors, one or more persons or entities

   responsible for authorship of the modifications in the Modified

   Version, together with at least five of the principal authors of the

   Document (all of its principal authors, if it has fewer than five),

   unless they release you from this requirement.

C. State on the Title page the name of the publisher of the

   Modified Version, as the publisher.

D. Preserve all the copyright notices of the Document.

E. Add an appropriate copyright notice for your modifications

   adjacent to the other copyright notices.

F. Include, immediately after the copyright notices, a license notice

   giving the public permission to use the Modified Version under the

   terms of this License, in the form shown in the Addendum below.

G. Preserve in that license notice the full lists of Invariant Sections

   and required Cover Texts given in the Document's license notice.

H. Include an unaltered copy of this License.

I. Preserve the section Entitled "History", Preserve its Title, and add

   to it an item stating at least the title, year, new authors, and

   publisher of the Modified Version as given on the Title Page.  If

   there is no section Entitled "History" in the Document, create one

   stating the title, year, authors, and publisher of the Document as

   given on its Title Page, then add an item describing the Modified

   Version as stated in the previous sentence.

J. Preserve the network location, if any, given in the Document for

   public access to a Transparent copy of the Document, and likewise

   the network locations given in the Document for previous versions

   it was based on.  These may be placed in the "History" section.

   You may omit a network location for a work that was published at

   least four years before the Document itself, or if the original

   publisher of the version it refers to gives permission.

K. For any section Entitled "Acknowledgements" or "Dedications",

   Preserve the Title of the section, and preserve in the section all

   the substance and tone of each of the contributor acknowledgements

   and/or dedications given therein.

L. Preserve all the Invariant Sections of the Document,

   unaltered in their text and in their titles.  Section numbers

   or the equivalent are not considered part of the section titles.

M. Delete any section Entitled "Endorsements".  Such a section

   may not be included in the Modified Version.

N. Do not retitle any existing section to be Entitled "Endorsements"

   or to conflict in title with any Invariant Section.

O. Preserve any Warranty Disclaimers.

If the Modified Version includes new front-matter sections or

appendices that qualify as Secondary Sections and contain no material

copied from the Document, you may at your option designate some or all

of these sections as invariant.  To do this, add their titles to the

list of Invariant Sections in the Modified Version's license notice.

These titles must be distinct from any other section titles.

You may add a section Entitled "Endorsements", provided it contains

nothing but endorsements of your Modified Version by various

parties--for example, statements of peer review or that the text has

been approved by an organization as the authoritative definition of a

standard.

You may add a passage of up to five words as a Front-Cover Text, and a

passage of up to 25 words as a Back-Cover Text, to the end of the list

of Cover Texts in the Modified Version.  Only one passage of

Front-Cover Text and one of Back-Cover Text may be added by (or

through arrangements made by) any one entity.  If the Document already

includes a cover text for the same cover, previously added by you or

by arrangement made by the same entity you are acting on behalf of,

you may not add another; but you may replace the old one, on explicit

permission from the previous publisher that added the old one.

The author(s) and publisher(s) of the Document do not by this License

give permission to use their names for publicity for or to assert or

imply endorsement of any Modified Version.

5. COMBINING DOCUMENTS

You may combine the Document with other documents released under this

License, under the terms defined in section 4 above for modified

versions, provided that you include in the combination all of the

Invariant Sections of all of the original documents, unmodified, and

list them all as Invariant Sections of your combined work in its

license notice, and that you preserve all their Warranty Disclaimers.

The combined work need only contain one copy of this License, and

multiple identical Invariant Sections may be replaced with a single

copy.  If there are multiple Invariant Sections with the same name but

different contents, make the title of each such section unique by

adding at the end of it, in parentheses, the name of the original

author or publisher of that section if known, or else a unique number.

Make the same adjustment to the section titles in the list of

Invariant Sections in the license notice of the combined work.

In the combination, you must combine any sections Entitled "History"

in the various original documents, forming one section Entitled

"History"; likewise combine any sections Entitled "Acknowledgements",

and any sections Entitled "Dedications".  You must delete all sections

Entitled "Endorsements".

6. COLLECTIONS OF DOCUMENTS

You may make a collection consisting of the Document and other documents

released under this License, and replace the individual copies of this

License in the various documents with a single copy that is included in

the collection, provided that you follow the rules of this License for

verbatim copying of each of the documents in all other respects.

You may extract a single document from such a collection, and distribute

it individually under this License, provided you insert a copy of this

License into the extracted document, and follow this License in all

other respects regarding verbatim copying of that document.

7. AGGREGATION WITH INDEPENDENT WORKS

A compilation of the Document or its derivatives with other separate

and independent documents or works, in or on a volume of a storage or

distribution medium, is called an "aggregate" if the copyright

resulting from the compilation is not used to limit the legal rights

of the compilation's users beyond what the individual works permit.

When the Document is included in an aggregate, this License does not

apply to the other works in the aggregate which are not themselves

derivative works of the Document.

If the Cover Text requirement of section 3 is applicable to these

copies of the Document, then if the Document is less than one half of

the entire aggregate, the Document's Cover Texts may be placed on

covers that bracket the Document within the aggregate, or the

electronic equivalent of covers if the Document is in electronic form.

Otherwise they must appear on printed covers that bracket the whole

aggregate.

8. TRANSLATION

Translation is considered a kind of modification, so you may

distribute translations of the Document under the terms of section 4.

Replacing Invariant Sections with translations requires special

permission from their copyright holders, but you may include

translations of some or all Invariant Sections in addition to the

original versions of these Invariant Sections.  You may include a

translation of this License, and all the license notices in the

Document, and any Warranty Disclaimers, provided that you also include

the original English version of this License and the original versions

of those notices and disclaimers.  In case of a disagreement between

the translation and the original version of this License or a notice

or disclaimer, the original version will prevail.

If a section in the Document is Entitled "Acknowledgements",

"Dedications", or "History", the requirement (section 4) to Preserve

its Title (section 1) will typically require changing the actual

title.

9. TERMINATION

You may not copy, modify, sublicense, or distribute the Document except

as expressly provided for under this License.  Any other attempt to

copy, modify, sublicense or distribute the Document is void, and will

automatically terminate your rights under this License.  However,

parties who have received copies, or rights, from you under this

License will not have their licenses terminated so long as such

parties remain in full compliance.

10. FUTURE REVISIONS OF THIS LICENSE

The Free Software Foundation may publish new, revised versions

of the GNU Free Documentation License from time to time.  Such new

versions will be similar in spirit to the present version, but may

differ in detail to address new problems or concerns.  See

http://www.gnu.org/copyleft/.

Each version of the License is given a distinguishing version number.

If the Document specifies that a particular numbered version of this

License "or any later version" applies to it, you have the option of

following the terms and conditions either of that specified version or

of any later version that has been published (not as a draft) by the

Free Software Foundation.  If the Document does not specify a version

number of this License, you may choose any version ever published (not

as a draft) by the Free Software Foundation.

ADDENDUM: How to use this License for your documents

To use this License in a document you have written, include a copy of

the License in the document and put the following copyright and

license notices just after the title page:

    Copyright (c)  YEAR  YOUR NAME.

    Permission is granted to copy, distribute and/or modify this document

    under the terms of the GNU Free Documentation License, Version 1.2

    or any later version published by the Free Software Foundation;

    with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.

    A copy of the license is included in the section entitled "GNU

    Free Documentation License".

If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,

replace the "with...Texts." line with this:

    with the Invariant Sections being LIST THEIR TITLES, with the

    Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.

If you have Invariant Sections without Cover Texts, or some other

combination of the three, merge those two alternatives to suit the

situation.

If your document contains nontrivial examples of program code, we

recommend releasing these examples in parallel under your choice of

free software license, such as the GNU General Public License,

to permit their use in free software.

The End.

EXPORT_SYMBOL_GPL(inverse_translate);

#include <linux/speakup.h>

#if defined(CONFIG_SPEAKUP_MODULE)

spk_key_func addr_spk_key = NULL;

#define speakup_key_call(__vc, __shift, __keycode, __key, __down)	\

	(addr_spk_key && (*addr_spk_key)(__vc, __shift, __keycode, __key, __down))

#elif defined(CONFIG_SPEAKUP)

#define speakup_key_call(__vc, __shift, __keycode, __key, __down)	\

	speakup_key(__vc, __shift, __keycode, __key, __down)

#else

#define speakup_key_call(__vc, __shift, __keycode, __key, __down)	0

#endif

/* Key types processed even in raw modes */

#define TYPES_ALLOWED_IN_RAW_MODE ((1 << KT_SPEC) | (1 << KT_SHIFT) | (1 << KT_SPKUP))

EXPORT_SYMBOL_GPL(kd_mksound);

		if (up_flag || (value >= ARRAY_SIZE(fn_handler)))

		if (speakup_key_call(vc, shift_final, keycode, K(KT_SHIFT,0), !down))

			return;

	if (speakup_key_call(vc, shift_final, keycode, keysym, !down))

		return;

struct input_dev *fakekeydev=NULL;

EXPORT_SYMBOL_GPL(fakekeydev);

	fakekeydev = dev;

obj-$(CONFIG_SPEAKUP)		+= speakup/

tristate 'Speakup console speech' CONFIG_SPEAKUP

if [ "$CONFIG_SPEAKUP" != "n" ]; then

	comment 'Type "y" for each synthesizer you want built into the kernel.'

	dep_tristate "Accent SA, acntsa" CONFIG_SPEAKUP_ACNTSA $CONFIG_SPEAKUP

	dep_tristate "Accent PC, acntpc" CONFIG_SPEAKUP_ACNTPC $CONFIG_SPEAKUP

	dep_tristate "Apollo, apollo" CONFIG_SPEAKUP_APOLLO $CONFIG_SPEAKUP

	dep_tristate "Audapter, audptr" CONFIG_SPEAKUP_AUDPTR $CONFIG_SPEAKUP

	dep_tristate "Braille 'n' Speak, bns" CONFIG_SPEAKUP_BNS $CONFIG_SPEAKUP

	dep_tristate "DECtalk Express, dectlk" CONFIG_SPEAKUP_DECTLK $CONFIG_SPEAKUP

	dep_tristate "DECtalk External (old), decext" CONFIG_SPEAKUP_DECEXT $CONFIG_SPEAKUP

	dep_tristate "DECtalk PC (big ISA card), decpc" CONFIG_SPEAKUP_DECPC $CONFIG_SPEAKUP

	if [ "$CONFIG_SPEAKUP_DECPC" = "y" ] ;then

	  comment 'warning: decpc can only be built as a module'

	fi

	comment 'In order to use this you will need'

	comment 'the dtload program and DECPC software files '

	  comment 'Read the accompanying DECPC documentation for more details'

	dep_tristate "DoubleTalk PC, dtlk" CONFIG_SPEAKUP_DTLK $CONFIG_SPEAKUP

	dep_tristate "Keynote Gold PC, keypc" CONFIG_SPEAKUP_KEYPC $CONFIG_SPEAKUP

	dep_tristate "DoubleTalk LT or LiteTalk, ltlk" CONFIG_SPEAKUP_LTLK $CONFIG_SPEAKUP

	dep_tristate "Software synthesizers /dev/sftsyn, sftsyn" CONFIG_SPEAKUP_SFTSYN $CONFIG_SPEAKUP

	dep_tristate "Speak Out, spkout" CONFIG_SPEAKUP_SPKOUT $CONFIG_SPEAKUP

	dep_tristate "Transport, txprt" CONFIG_SPEAKUP_TXPRT $CONFIG_SPEAKUP

	comment 'Enter the three to six character synth string from above or none.'

	string "Default synthesizer for Speakup" CONFIG_SPEAKUP_DEFAULT "none"

fi

#define CVSVERSION " CVS: Sat Oct 7 10:52:29 EDT 2006 "

/*

 * This is the DECtalk PC firmware loader for the Linux kernel, version 1.0

 *

 * Original 386BSD source:

 *      Copyright ( c ) 1996 Brian Buhrow <buhrow@lothlorien.nfbcal.org>

 *

 * Adapted for Linux:

 *      Copyright ( c ) 1997 Nicolas Pitre <nico@cam.org>

 *

 * Adapted for speakup:

 *      Copyright ( c ) 2003 David Borowski <david575@golden.net>

 *

 * All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * ( at your option ) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <malloc.h>

#include <sys/errno.h>

#include <asm/io.h>

#include "dtload.h"

#include "dtpc_reg.h"

static int verbose = 0, intest = 0,infd = -1;

static int image_len, total_paras;

static int dt_stat, dma_state = 0, has_kernel = 0;

static struct dos_reloc fixups[512];

static char *read_buff = NULL;

static struct dos_exe_header header;

static u_short iobase = 0x350;

static int dt_getstatus( )

{

	dt_stat =  inb_p( iobase )|(inb_p( iobase+1 )<<8);

	return dt_stat;

}

static void dt_sendcmd( u_int cmd )

{

  outb_p( cmd & 0xFF, iobase );

  outb_p( (cmd>>8) & 0xFF, iobase+1 );

}

static int dt_waitbit( int bit )

{

  int timeout = 100;

  while ( --timeout > 0 ) {

    if( (dt_getstatus( ) & bit ) == bit ) return 1;

    usleep( 1000 );

  }

  return 0;

}

static int dt_sendcmd_wait( u_int cmd, int bit )

{

  int timeout = 1000;

  outb_p( cmd & 0xFF, iobase );

  outb_p( (cmd>>8) & 0xFF, iobase+1 );

  while ( --timeout > 0 ) {

    if( (dt_getstatus( ) & bit ) == bit ) return 1;

    usleep( 1000 );

  }

  return 0;

}

static int dt_waitmode( int pattern )

{