drivers/staging/speakup/speakup_keypc.c

   1 /*
   2  * written by David Borowski
   3  *
   4  * Copyright (C) 2003 David Borowski.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * specificly written as a driver for the speakup screenreview
  21  * package it's not a general device driver.
  22  * This driver is for the Keynote Gold internal synthesizer.
  23  */
  24 #include <linux/jiffies.h>
  25 #include <linux/sched.h>
  26 #include <linux/timer.h>
  27 #include <linux/kthread.h>
  28 #include <linux/serial_reg.h>
  29
  30 #include "spk_priv.h"
  31 #include "speakup.h"
  32
  33 #define DRV_VERSION "2.10"
  34 #define SYNTH_IO_EXTENT 0x04
  35 #define SWAIT udelay(70)
  36 #define PROCSPEECH 0x1f
  37 #define SYNTH_CLEAR 0x03
  38
  39 static int synth_probe(struct spk_synth *synth);
  40 static void keynote_release(void);
  41 static const char *synth_immediate(struct spk_synth *synth, const char *buf);
  42 static void do_catch_up(struct spk_synth *synth);
  43 static void synth_flush(struct spk_synth *synth);
  44
  45 static int synth_port;
  46 static int port_forced;
  47 static unsigned int synth_portlist[] = { 0x2a8, 0 };
  48
  49 static struct var_t vars[] = {
  50         { CAPS_START, .u.s = {"[f130]" } },
  51         { CAPS_STOP, .u.s = {"[f90]" } },
  52         { RATE, .u.n = {"\04%c ", 8, 0, 10, 81, -8, NULL } },
  53         { PITCH, .u.n = {"[f%d]", 5, 0, 9, 40, 10, NULL } },
  54         { DIRECT, .u.n = {NULL, 0, 0, 1, 0, 0, NULL } },
  55         V_LAST_VAR
  56 };
  57
  58 /*
  59  * These attributes will appear in /sys/accessibility/speakup/keypc.
  60  */
  61 static struct kobj_attribute caps_start_attribute =
  62         __ATTR(caps_start, USER_RW, spk_var_show, spk_var_store);
  63 static struct kobj_attribute caps_stop_attribute =
  64         __ATTR(caps_stop, USER_RW, spk_var_show, spk_var_store);
  65 static struct kobj_attribute pitch_attribute =
  66         __ATTR(pitch, USER_RW, spk_var_show, spk_var_store);
  67 static struct kobj_attribute rate_attribute =
  68         __ATTR(rate, USER_RW, spk_var_show, spk_var_store);
  69
  70 static struct kobj_attribute delay_time_attribute =
  71         __ATTR(delay_time, ROOT_W, spk_var_show, spk_var_store);
  72 static struct kobj_attribute direct_attribute =
  73         __ATTR(direct, USER_RW, spk_var_show, spk_var_store);
  74 static struct kobj_attribute full_time_attribute =
  75         __ATTR(full_time, ROOT_W, spk_var_show, spk_var_store);
  76 static struct kobj_attribute jiffy_delta_attribute =
  77         __ATTR(jiffy_delta, ROOT_W, spk_var_show, spk_var_store);
  78 static struct kobj_attribute trigger_time_attribute =
  79         __ATTR(trigger_time, ROOT_W, spk_var_show, spk_var_store);
  80
  81 /*
  82  * Create a group of attributes so that we can create and destroy them all
  83  * at once.
  84  */
  85 static struct attribute *synth_attrs[] = {
  86         &caps_start_attribute.attr,
  87         &caps_stop_attribute.attr,
  88         &pitch_attribute.attr,
  89         &rate_attribute.attr,
  90         &delay_time_attribute.attr,
  91         &direct_attribute.attr,
  92         &full_time_attribute.attr,
  93         &jiffy_delta_attribute.attr,
  94         &trigger_time_attribute.attr,
  95         NULL,   /* need to NULL terminate the list of attributes */
  96 };
  97
  98 static struct spk_synth synth_keypc = {
  99         .name = "keypc",
 100         .version = DRV_VERSION,
 101         .long_name = "Keynote PC",
 102         .init = "[t][n7,1][n8,0]",
 103         .procspeech = PROCSPEECH,
 104         .clear = SYNTH_CLEAR,
 105         .delay = 500,
 106         .trigger = 50,
 107         .jiffies = 50,
 108         .full = 1000,
 109         .startup = SYNTH_START,
 110         .checkval = SYNTH_CHECK,
 111         .vars = vars,
 112         .probe = synth_probe,
 113         .release = keynote_release,
 114         .synth_immediate = synth_immediate,
 115         .catch_up = do_catch_up,
 116         .flush = synth_flush,
 117         .is_alive = spk_synth_is_alive_nop,
 118         .synth_adjust = NULL,
 119         .read_buff_add = NULL,
 120         .get_index = NULL,
 121         .indexing = {
 122                 .command = NULL,
 123                 .lowindex = 0,
 124                 .highindex = 0,
 125                 .currindex = 0,
 126         },
 127         .attributes = {
 128                 .attrs = synth_attrs,
 129                 .name = "keypc",
 130         },
 131 };
 132
 133 static inline bool synth_writable(void)
 134 {
 135         return (inb_p(synth_port + UART_RX) & 0x10) != 0;
 136 }
 137
 138 static inline bool synth_full(void)
 139 {
 140         return (inb_p(synth_port + UART_RX) & 0x80) == 0;
 141 }
 142
 143 static char *oops(void)
 144 {
 145         int s1, s2, s3, s4;
 146         s1 = inb_p(synth_port);
 147         s2 = inb_p(synth_port+1);
 148         s3 = inb_p(synth_port+2);
 149         s4 = inb_p(synth_port+3);
 150         pr_warn("synth timeout %d %d %d %d\n", s1, s2, s3, s4);
 151         return NULL;
 152 }
 153
 154 static const char *synth_immediate(struct spk_synth *synth, const char *buf)
 155 {
 156         u_char ch;
 157         int timeout;
 158         while ((ch = *buf)) {
 159                 if (ch == '\n')
 160                         ch = PROCSPEECH;
 161                 if (synth_full())
 162                         return buf;
 163                 timeout = 1000;
 164                 while (synth_writable())
 165                         if (--timeout <= 0)
 166                                 return oops();
 167                 outb_p(ch, synth_port);
 168                 udelay(70);
 169                 buf++;
 170         }
 171         return 0;
 172 }
 173
 174 static void do_catch_up(struct spk_synth *synth)
 175 {
 176         u_char ch;
 177         int timeout;
 178         unsigned long flags;
 179         unsigned long jiff_max;
 180         struct var_t *jiffy_delta;
 181         struct var_t *delay_time;
 182         struct var_t *full_time;
 183         int delay_time_val;
 184         int full_time_val;
 185         int jiffy_delta_val;
 186
 187         jiffy_delta = get_var(JIFFY);
 188         delay_time = get_var(DELAY);
 189         full_time = get_var(FULL);
 190 spk_lock(flags);
 191         jiffy_delta_val = jiffy_delta->u.n.value;
 192         spk_unlock(flags);
 193
 194         jiff_max = jiffies + jiffy_delta_val;
 195         while (!kthread_should_stop()) {
 196                 spk_lock(flags);
 197                 if (speakup_info.flushing) {
 198                         speakup_info.flushing = 0;
 199                         spk_unlock(flags);
 200                         synth->flush(synth);
 201                         continue;
 202                 }
 203                 if (synth_buffer_empty()) {
 204                         spk_unlock(flags);
 205                         break;
 206                 }
 207                 set_current_state(TASK_INTERRUPTIBLE);
 208                 full_time_val = full_time->u.n.value;
 209                 spk_unlock(flags);
 210                 if (synth_full()) {
 211                         schedule_timeout(msecs_to_jiffies(full_time_val));
 212                         continue;
 213                 }
 214                 set_current_state(TASK_RUNNING);
 215                 timeout = 1000;
 216                 while (synth_writable())
 217                         if (--timeout <= 0)
 218                                 break;
 219                 if (timeout <= 0) {
 220                         oops();
 221                         break;
 222                 }
 223                 spk_lock(flags);
 224                 ch = synth_buffer_getc();
 225                 spk_unlock(flags);
 226                 if (ch == '\n')
 227                         ch = PROCSPEECH;
 228                 outb_p(ch, synth_port);
 229                 SWAIT;
 230                 if ((jiffies >= jiff_max) && (ch == SPACE)) {
 231                         timeout = 1000;
 232                         while (synth_writable())
 233                                 if (--timeout <= 0)
 234                                         break;
 235                         if (timeout <= 0) {
 236                                 oops();
 237                                 break;
 238                         }
 239                         outb_p(PROCSPEECH, synth_port);
 240                         spk_lock(flags);
 241                         jiffy_delta_val = jiffy_delta->u.n.value;
 242                         delay_time_val = delay_time->u.n.value;
 243                         spk_unlock(flags);
 244                         schedule_timeout(msecs_to_jiffies(delay_time_val));
 245                         jiff_max = jiffies+jiffy_delta_val;
 246                 }
 247         }
 248         timeout = 1000;
 249         while (synth_writable())
 250                 if (--timeout <= 0)
 251                         break;
 252         if (timeout <= 0)
 253                 oops();
 254         else
 255                 outb_p(PROCSPEECH, synth_port);
 256 }
 257
 258 static void synth_flush(struct spk_synth *synth)
 259 {
 260         outb_p(SYNTH_CLEAR, synth_port);
 261 }
 262
 263 static int synth_probe(struct spk_synth *synth)
 264 {
 265         unsigned int port_val = 0;
 266         int i = 0;
 267         pr_info("Probing for %s.\n", synth->long_name);
 268         if (port_forced) {
 269                 synth_port = port_forced;
 270                 pr_info("probe forced to %x by kernel command line\n",
 271                                 synth_port);
 272                 if (synth_request_region(synth_port-1, SYNTH_IO_EXTENT)) {
 273                         pr_warn("sorry, port already reserved\n");
 274                         return -EBUSY;
 275                 }
 276                 port_val = inb(synth_port);
 277         } else {
 278                 for (i = 0; synth_portlist[i]; i++) {
 279                         if (synth_request_region(synth_portlist[i],
 280                                                 SYNTH_IO_EXTENT)) {
 281                                 pr_warn
 282                                     ("request_region: failed with 0x%x, %d\n",
 283                                      synth_portlist[i], SYNTH_IO_EXTENT);
 284                                 continue;
 285                         }
 286                         port_val = inb(synth_portlist[i]);
 287                         if (port_val == 0x80) {
 288                                 synth_port = synth_portlist[i];
 289                                 break;
 290                         }
 291                 }
 292         }
 293         if (port_val != 0x80) {
 294                 pr_info("%s: not found\n", synth->long_name);
 295                 synth_release_region(synth_port, SYNTH_IO_EXTENT);
 296                 synth_port = 0;
 297                 return -ENODEV;
 298         }
 299         pr_info("%s: %03x-%03x, driver version %s,\n", synth->long_name,
 300                 synth_port, synth_port+SYNTH_IO_EXTENT-1,
 301                 synth->version);
 302         synth->alive = 1;
 303         return 0;
 304 }
 305
 306 static void keynote_release(void)
 307 {
 308         if (synth_port)
 309                 synth_release_region(synth_port, SYNTH_IO_EXTENT);
 310         synth_port = 0;
 311 }
 312
 313 module_param_named(port, port_forced, int, S_IRUGO);
 314 module_param_named(start, synth_keypc.startup, short, S_IRUGO);
 315
 316 MODULE_PARM_DESC(port, "Set the port for the synthesizer (override probing).");
 317 MODULE_PARM_DESC(start, "Start the synthesizer once it is loaded.");
 318
 319 static int __init keypc_init(void)
 320 {
 321         return synth_add(&synth_keypc);
 322 }
 323
 324 static void __exit keypc_exit(void)
 325 {
 326         synth_remove(&synth_keypc);
 327 }
 328
 329 module_init(keypc_init);
 330 module_exit(keypc_exit);
 331 MODULE_AUTHOR("David Borowski");
 332 MODULE_DESCRIPTION("Speakup support for Keynote Gold PC synthesizers");
 333 MODULE_LICENSE("GPL");
 334 MODULE_VERSION(DRV_VERSION);
 335