git.oblomov.eu Git - linux-2.6/blob - sound/ppc/beep.c

   1 /*
   2  * Beep using pcm
   3  *
   4  * Copyright (c) by Takashi Iwai <tiwai@suse.de>
   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
  21 #include <sound/driver.h>
  22 #include <asm/io.h>
  23 #include <asm/irq.h>
  24 #include <linux/init.h>
  25 #include <linux/slab.h>
  26 #include <linux/input.h>
  27 #include <linux/pci.h>
  28 #include <linux/dma-mapping.h>
  29 #include <sound/core.h>
  30 #include <sound/control.h>
  31 #include "pmac.h"
  32
  33 struct snd_pmac_beep {
  34         int running;            /* boolean */
  35         int volume;             /* mixer volume: 0-100 */
  36         int volume_play;        /* currently playing volume */
  37         int hz;
  38         int nsamples;
  39         short *buf;             /* allocated wave buffer */
  40         dma_addr_t addr;        /* physical address of buffer */
  41         struct input_dev *dev;
  42 };
  43
  44 /*
  45  * stop beep if running
  46  */
  47 void snd_pmac_beep_stop(pmac_t *chip)
  48 {
  49         pmac_beep_t *beep = chip->beep;
  50         if (beep && beep->running) {
  51                 beep->running = 0;
  52                 snd_pmac_beep_dma_stop(chip);
  53         }
  54 }
  55
  56 /*
  57  * Stuff for outputting a beep.  The values range from -327 to +327
  58  * so we can multiply by an amplitude in the range 0..100 to get a
  59  * signed short value to put in the output buffer.
  60  */
  61 static short beep_wform[256] = {
  62         0,      40,     79,     117,    153,    187,    218,    245,
  63         269,    288,    304,    316,    323,    327,    327,    324,
  64         318,    310,    299,    288,    275,    262,    249,    236,
  65         224,    213,    204,    196,    190,    186,    183,    182,
  66         182,    183,    186,    189,    192,    196,    200,    203,
  67         206,    208,    209,    209,    209,    207,    204,    201,
  68         197,    193,    188,    183,    179,    174,    170,    166,
  69         163,    161,    160,    159,    159,    160,    161,    162,
  70         164,    166,    168,    169,    171,    171,    171,    170,
  71         169,    167,    163,    159,    155,    150,    144,    139,
  72         133,    128,    122,    117,    113,    110,    107,    105,
  73         103,    103,    103,    103,    104,    104,    105,    105,
  74         105,    103,    101,    97,     92,     86,     78,     68,
  75         58,     45,     32,     18,     3,      -11,    -26,    -41,
  76         -55,    -68,    -79,    -88,    -95,    -100,   -102,   -102,
  77         -99,    -93,    -85,    -75,    -62,    -48,    -33,    -16,
  78         0,      16,     33,     48,     62,     75,     85,     93,
  79         99,     102,    102,    100,    95,     88,     79,     68,
  80         55,     41,     26,     11,     -3,     -18,    -32,    -45,
  81         -58,    -68,    -78,    -86,    -92,    -97,    -101,   -103,
  82         -105,   -105,   -105,   -104,   -104,   -103,   -103,   -103,
  83         -103,   -105,   -107,   -110,   -113,   -117,   -122,   -128,
  84         -133,   -139,   -144,   -150,   -155,   -159,   -163,   -167,
  85         -169,   -170,   -171,   -171,   -171,   -169,   -168,   -166,
  86         -164,   -162,   -161,   -160,   -159,   -159,   -160,   -161,
  87         -163,   -166,   -170,   -174,   -179,   -183,   -188,   -193,
  88         -197,   -201,   -204,   -207,   -209,   -209,   -209,   -208,
  89         -206,   -203,   -200,   -196,   -192,   -189,   -186,   -183,
  90         -182,   -182,   -183,   -186,   -190,   -196,   -204,   -213,
  91         -224,   -236,   -249,   -262,   -275,   -288,   -299,   -310,
  92         -318,   -324,   -327,   -327,   -323,   -316,   -304,   -288,
  93         -269,   -245,   -218,   -187,   -153,   -117,   -79,    -40,
  94 };
  95
  96 #define BEEP_SRATE      22050   /* 22050 Hz sample rate */
  97 #define BEEP_BUFLEN     512
  98 #define BEEP_VOLUME     15      /* 0 - 100 */
  99
 100 static int snd_pmac_beep_event(struct input_dev *dev, unsigned int type, unsigned int code, int hz)
 101 {
 102         pmac_t *chip;
 103         pmac_beep_t *beep;
 104         unsigned long flags;
 105         int beep_speed = 0;
 106         int srate;
 107         int period, ncycles, nsamples;
 108         int i, j, f;
 109         short *p;
 110
 111         if (type != EV_SND)
 112                 return -1;
 113
 114         switch (code) {
 115         case SND_BELL: if (hz) hz = 1000;
 116         case SND_TONE: break;
 117         default: return -1;
 118         }
 119
 120         chip = dev->private;
 121         if (! chip || (beep = chip->beep) == NULL)
 122                 return -1;
 123
 124         if (! hz) {
 125                 spin_lock_irqsave(&chip->reg_lock, flags);
 126                 if (beep->running)
 127                         snd_pmac_beep_stop(chip);
 128                 spin_unlock_irqrestore(&chip->reg_lock, flags);
 129                 return 0;
 130         }
 131
 132         beep_speed = snd_pmac_rate_index(chip, &chip->playback, BEEP_SRATE);
 133         srate = chip->freq_table[beep_speed];
 134
 135         if (hz <= srate / BEEP_BUFLEN || hz > srate / 2)
 136                 hz = 1000;
 137
 138         spin_lock_irqsave(&chip->reg_lock, flags);
 139         if (chip->playback.running || chip->capture.running || beep->running) {
 140                 spin_unlock_irqrestore(&chip->reg_lock, flags);
 141                 return 0;
 142         }
 143         beep->running = 1;
 144         spin_unlock_irqrestore(&chip->reg_lock, flags);
 145
 146         if (hz == beep->hz && beep->volume == beep->volume_play) {
 147                 nsamples = beep->nsamples;
 148         } else {
 149                 period = srate * 256 / hz;      /* fixed point */
 150                 ncycles = BEEP_BUFLEN * 256 / period;
 151                 nsamples = (period * ncycles) >> 8;
 152                 f = ncycles * 65536 / nsamples;
 153                 j = 0;
 154                 p = beep->buf;
 155                 for (i = 0; i < nsamples; ++i, p += 2) {
 156                         p[0] = p[1] = beep_wform[j >> 8] * beep->volume;
 157                         j = (j + f) & 0xffff;
 158                 }
 159                 beep->hz = hz;
 160                 beep->volume_play = beep->volume;
 161                 beep->nsamples = nsamples;
 162         }
 163
 164         spin_lock_irqsave(&chip->reg_lock, flags);
 165         snd_pmac_beep_dma_start(chip, beep->nsamples * 4, beep->addr, beep_speed);
 166         spin_unlock_irqrestore(&chip->reg_lock, flags);
 167         return 0;
 168 }
 169
 170 /*
 171  * beep volume mixer
 172  */
 173
 174 #define chip_t pmac_t
 175
 176 static int snd_pmac_info_beep(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
 177 {
 178         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 179         uinfo->count = 1;
 180         uinfo->value.integer.min = 0;
 181         uinfo->value.integer.max = 100;
 182         return 0;
 183 }
 184
 185 static int snd_pmac_get_beep(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
 186 {
 187         pmac_t *chip = snd_kcontrol_chip(kcontrol);
 188         snd_assert(chip->beep, return -ENXIO);
 189         ucontrol->value.integer.value[0] = chip->beep->volume;
 190         return 0;
 191 }
 192
 193 static int snd_pmac_put_beep(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
 194 {
 195         pmac_t *chip = snd_kcontrol_chip(kcontrol);
 196         int oval;
 197         snd_assert(chip->beep, return -ENXIO);
 198         oval = chip->beep->volume;
 199         chip->beep->volume = ucontrol->value.integer.value[0];
 200         return oval != chip->beep->volume;
 201 }
 202
 203 static snd_kcontrol_new_t snd_pmac_beep_mixer = {
 204         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 205         .name = "Beep Playback Volume",
 206         .info = snd_pmac_info_beep,
 207         .get = snd_pmac_get_beep,
 208         .put = snd_pmac_put_beep,
 209 };
 210
 211 /* Initialize beep stuff */
 212 int __init snd_pmac_attach_beep(pmac_t *chip)
 213 {
 214         pmac_beep_t *beep;
 215         struct input_dev *input_dev;
 216         void *dmabuf;
 217         int err = -ENOMEM;
 218
 219         beep = kzalloc(sizeof(*beep), GFP_KERNEL);
 220         dmabuf = dma_alloc_coherent(&chip->pdev->dev, BEEP_BUFLEN * 4,
 221                                     &beep->addr, GFP_KERNEL);
 222         input_dev = input_allocate_device();
 223         if (!beep || !dmabuf || !input_dev)
 224                 goto fail;
 225
 226         /* FIXME: set more better values */
 227         input_dev->name = "PowerMac Beep";
 228         input_dev->phys = "powermac/beep";
 229         input_dev->id.bustype = BUS_ADB;
 230         input_dev->id.vendor = 0x001f;
 231         input_dev->id.product = 0x0001;
 232         input_dev->id.version = 0x0100;
 233
 234         input_dev->evbit[0] = BIT(EV_SND);
 235         input_dev->sndbit[0] = BIT(SND_BELL) | BIT(SND_TONE);
 236         input_dev->event = snd_pmac_beep_event;
 237         input_dev->private = chip;
 238         input_dev->cdev.dev = &chip->pdev->dev;
 239
 240         beep->dev = input_dev;
 241         beep->buf = dmabuf;
 242         beep->volume = BEEP_VOLUME;
 243         beep->running = 0;
 244
 245         err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_pmac_beep_mixer, chip));
 246         if (err < 0)
 247                 goto fail;
 248
 249         chip->beep = beep;
 250         input_register_device(beep->dev);
 251
 252         return 0;
 253
 254  fail:  input_free_device(input_dev);
 255         kfree(dmabuf);
 256         kfree(beep);
 257         return err;
 258 }
 259
 260 void snd_pmac_detach_beep(pmac_t *chip)
 261 {
 262         if (chip->beep) {
 263                 input_unregister_device(chip->beep->dev);
 264                 dma_free_coherent(&chip->pdev->dev, BEEP_BUFLEN * 4,
 265                                   chip->beep->buf, chip->beep->addr);
 266                 kfree(chip->beep);
 267                 chip->beep = NULL;
 268         }
 269 }