| 1 | /* |
| 2 | * Digital Beep Input Interface for HD-audio codec |
| 3 | * |
| 4 | * Author: Matthew Ranostay <mranostay@embeddedalley.com> |
| 5 | * Copyright (c) 2008 Embedded Alley Solutions Inc |
| 6 | * |
| 7 | * This driver is free software; you can redistribute it and/or modify |
| 8 | * it under the terms of the GNU General Public License as published by |
| 9 | * the Free Software Foundation; either version 2 of the License, or |
| 10 | * (at your option) any later version. |
| 11 | * |
| 12 | * This driver is distributed in the hope that it will be useful, |
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 15 | * GNU General Public License for more details. |
| 16 | * |
| 17 | * You should have received a copy of the GNU General Public License |
| 18 | * along with this program; if not, write to the Free Software |
| 19 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 20 | */ |
| 21 | |
| 22 | #include <linux/input.h> |
| 23 | #include <linux/slab.h> |
| 24 | #include <linux/workqueue.h> |
| 25 | #include <linux/export.h> |
| 26 | #include <sound/core.h> |
| 27 | #include "hda_beep.h" |
| 28 | #include "hda_local.h" |
| 29 | |
| 30 | enum { |
| 31 | DIGBEEP_HZ_STEP = 46875, /* 46.875 Hz */ |
| 32 | DIGBEEP_HZ_MIN = 93750, /* 93.750 Hz */ |
| 33 | DIGBEEP_HZ_MAX = 12000000, /* 12 KHz */ |
| 34 | }; |
| 35 | |
| 36 | static void snd_hda_generate_beep(struct work_struct *work) |
| 37 | { |
| 38 | struct hda_beep *beep = |
| 39 | container_of(work, struct hda_beep, beep_work); |
| 40 | struct hda_codec *codec = beep->codec; |
| 41 | int tone; |
| 42 | |
| 43 | if (!beep->enabled) |
| 44 | return; |
| 45 | |
| 46 | tone = beep->tone; |
| 47 | if (tone && !beep->playing) { |
| 48 | snd_hda_power_up(codec); |
| 49 | beep->playing = 1; |
| 50 | } |
| 51 | /* generate tone */ |
| 52 | snd_hda_codec_write(codec, beep->nid, 0, |
| 53 | AC_VERB_SET_BEEP_CONTROL, tone); |
| 54 | if (!tone && beep->playing) { |
| 55 | beep->playing = 0; |
| 56 | snd_hda_power_down(codec); |
| 57 | } |
| 58 | } |
| 59 | |
| 60 | /* (non-standard) Linear beep tone calculation for IDT/STAC codecs |
| 61 | * |
| 62 | * The tone frequency of beep generator on IDT/STAC codecs is |
| 63 | * defined from the 8bit tone parameter, in Hz, |
| 64 | * freq = 48000 * (257 - tone) / 1024 |
| 65 | * that is from 12kHz to 93.75Hz in steps of 46.875 Hz |
| 66 | */ |
| 67 | static int beep_linear_tone(struct hda_beep *beep, int hz) |
| 68 | { |
| 69 | if (hz <= 0) |
| 70 | return 0; |
| 71 | hz *= 1000; /* fixed point */ |
| 72 | hz = hz - DIGBEEP_HZ_MIN |
| 73 | + DIGBEEP_HZ_STEP / 2; /* round to nearest step */ |
| 74 | if (hz < 0) |
| 75 | hz = 0; /* turn off PC beep*/ |
| 76 | else if (hz >= (DIGBEEP_HZ_MAX - DIGBEEP_HZ_MIN)) |
| 77 | hz = 1; /* max frequency */ |
| 78 | else { |
| 79 | hz /= DIGBEEP_HZ_STEP; |
| 80 | hz = 255 - hz; |
| 81 | } |
| 82 | return hz; |
| 83 | } |
| 84 | |
| 85 | /* HD-audio standard beep tone parameter calculation |
| 86 | * |
| 87 | * The tone frequency in Hz is calculated as |
| 88 | * freq = 48000 / (tone * 4) |
| 89 | * from 47Hz to 12kHz |
| 90 | */ |
| 91 | static int beep_standard_tone(struct hda_beep *beep, int hz) |
| 92 | { |
| 93 | if (hz <= 0) |
| 94 | return 0; /* disabled */ |
| 95 | hz = 12000 / hz; |
| 96 | if (hz > 0xff) |
| 97 | return 0xff; |
| 98 | if (hz <= 0) |
| 99 | return 1; |
| 100 | return hz; |
| 101 | } |
| 102 | |
| 103 | static int snd_hda_beep_event(struct input_dev *dev, unsigned int type, |
| 104 | unsigned int code, int hz) |
| 105 | { |
| 106 | struct hda_beep *beep = input_get_drvdata(dev); |
| 107 | |
| 108 | switch (code) { |
| 109 | case SND_BELL: |
| 110 | if (hz) |
| 111 | hz = 1000; |
| 112 | /* fallthru */ |
| 113 | case SND_TONE: |
| 114 | if (beep->linear_tone) |
| 115 | beep->tone = beep_linear_tone(beep, hz); |
| 116 | else |
| 117 | beep->tone = beep_standard_tone(beep, hz); |
| 118 | break; |
| 119 | default: |
| 120 | return -1; |
| 121 | } |
| 122 | |
| 123 | /* schedule beep event */ |
| 124 | schedule_work(&beep->beep_work); |
| 125 | return 0; |
| 126 | } |
| 127 | |
| 128 | static void turn_off_beep(struct hda_beep *beep) |
| 129 | { |
| 130 | cancel_work_sync(&beep->beep_work); |
| 131 | if (beep->playing) { |
| 132 | /* turn off beep */ |
| 133 | snd_hda_codec_write(beep->codec, beep->nid, 0, |
| 134 | AC_VERB_SET_BEEP_CONTROL, 0); |
| 135 | beep->playing = 0; |
| 136 | snd_hda_power_down(beep->codec); |
| 137 | } |
| 138 | } |
| 139 | |
| 140 | static void snd_hda_do_detach(struct hda_beep *beep) |
| 141 | { |
| 142 | input_unregister_device(beep->dev); |
| 143 | beep->dev = NULL; |
| 144 | turn_off_beep(beep); |
| 145 | } |
| 146 | |
| 147 | static int snd_hda_do_attach(struct hda_beep *beep) |
| 148 | { |
| 149 | struct input_dev *input_dev; |
| 150 | struct hda_codec *codec = beep->codec; |
| 151 | int err; |
| 152 | |
| 153 | input_dev = input_allocate_device(); |
| 154 | if (!input_dev) |
| 155 | return -ENOMEM; |
| 156 | |
| 157 | /* setup digital beep device */ |
| 158 | input_dev->name = "HDA Digital PCBeep"; |
| 159 | input_dev->phys = beep->phys; |
| 160 | input_dev->id.bustype = BUS_PCI; |
| 161 | |
| 162 | input_dev->id.vendor = codec->vendor_id >> 16; |
| 163 | input_dev->id.product = codec->vendor_id & 0xffff; |
| 164 | input_dev->id.version = 0x01; |
| 165 | |
| 166 | input_dev->evbit[0] = BIT_MASK(EV_SND); |
| 167 | input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE); |
| 168 | input_dev->event = snd_hda_beep_event; |
| 169 | input_dev->dev.parent = &codec->dev; |
| 170 | input_set_drvdata(input_dev, beep); |
| 171 | |
| 172 | err = input_register_device(input_dev); |
| 173 | if (err < 0) { |
| 174 | input_free_device(input_dev); |
| 175 | codec_err(codec, "hda_beep: unable to register input device\n"); |
| 176 | return err; |
| 177 | } |
| 178 | beep->dev = input_dev; |
| 179 | return 0; |
| 180 | } |
| 181 | |
| 182 | int snd_hda_enable_beep_device(struct hda_codec *codec, int enable) |
| 183 | { |
| 184 | struct hda_beep *beep = codec->beep; |
| 185 | if (!beep) |
| 186 | return 0; |
| 187 | enable = !!enable; |
| 188 | if (beep->enabled != enable) { |
| 189 | beep->enabled = enable; |
| 190 | if (!enable) |
| 191 | turn_off_beep(beep); |
| 192 | return 1; |
| 193 | } |
| 194 | return 0; |
| 195 | } |
| 196 | EXPORT_SYMBOL_GPL(snd_hda_enable_beep_device); |
| 197 | |
| 198 | int snd_hda_attach_beep_device(struct hda_codec *codec, int nid) |
| 199 | { |
| 200 | struct hda_beep *beep; |
| 201 | int err; |
| 202 | |
| 203 | if (!snd_hda_get_bool_hint(codec, "beep")) |
| 204 | return 0; /* disabled explicitly by hints */ |
| 205 | if (codec->beep_mode == HDA_BEEP_MODE_OFF) |
| 206 | return 0; /* disabled by module option */ |
| 207 | |
| 208 | beep = kzalloc(sizeof(*beep), GFP_KERNEL); |
| 209 | if (beep == NULL) |
| 210 | return -ENOMEM; |
| 211 | snprintf(beep->phys, sizeof(beep->phys), |
| 212 | "card%d/codec#%d/beep0", codec->bus->card->number, codec->addr); |
| 213 | /* enable linear scale */ |
| 214 | snd_hda_codec_write_cache(codec, nid, 0, |
| 215 | AC_VERB_SET_DIGI_CONVERT_2, 0x01); |
| 216 | |
| 217 | beep->nid = nid; |
| 218 | beep->codec = codec; |
| 219 | codec->beep = beep; |
| 220 | |
| 221 | INIT_WORK(&beep->beep_work, &snd_hda_generate_beep); |
| 222 | mutex_init(&beep->mutex); |
| 223 | |
| 224 | err = snd_hda_do_attach(beep); |
| 225 | if (err < 0) { |
| 226 | kfree(beep); |
| 227 | codec->beep = NULL; |
| 228 | return err; |
| 229 | } |
| 230 | |
| 231 | return 0; |
| 232 | } |
| 233 | EXPORT_SYMBOL_GPL(snd_hda_attach_beep_device); |
| 234 | |
| 235 | void snd_hda_detach_beep_device(struct hda_codec *codec) |
| 236 | { |
| 237 | struct hda_beep *beep = codec->beep; |
| 238 | if (beep) { |
| 239 | if (beep->dev) |
| 240 | snd_hda_do_detach(beep); |
| 241 | codec->beep = NULL; |
| 242 | kfree(beep); |
| 243 | } |
| 244 | } |
| 245 | EXPORT_SYMBOL_GPL(snd_hda_detach_beep_device); |
| 246 | |
| 247 | static bool ctl_has_mute(struct snd_kcontrol *kcontrol) |
| 248 | { |
| 249 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
| 250 | return query_amp_caps(codec, get_amp_nid(kcontrol), |
| 251 | get_amp_direction(kcontrol)) & AC_AMPCAP_MUTE; |
| 252 | } |
| 253 | |
| 254 | /* get/put callbacks for beep mute mixer switches */ |
| 255 | int snd_hda_mixer_amp_switch_get_beep(struct snd_kcontrol *kcontrol, |
| 256 | struct snd_ctl_elem_value *ucontrol) |
| 257 | { |
| 258 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
| 259 | struct hda_beep *beep = codec->beep; |
| 260 | if (beep && (!beep->enabled || !ctl_has_mute(kcontrol))) { |
| 261 | ucontrol->value.integer.value[0] = |
| 262 | ucontrol->value.integer.value[1] = beep->enabled; |
| 263 | return 0; |
| 264 | } |
| 265 | return snd_hda_mixer_amp_switch_get(kcontrol, ucontrol); |
| 266 | } |
| 267 | EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_get_beep); |
| 268 | |
| 269 | int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol, |
| 270 | struct snd_ctl_elem_value *ucontrol) |
| 271 | { |
| 272 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); |
| 273 | struct hda_beep *beep = codec->beep; |
| 274 | if (beep) { |
| 275 | u8 chs = get_amp_channels(kcontrol); |
| 276 | int enable = 0; |
| 277 | long *valp = ucontrol->value.integer.value; |
| 278 | if (chs & 1) { |
| 279 | enable |= *valp; |
| 280 | valp++; |
| 281 | } |
| 282 | if (chs & 2) |
| 283 | enable |= *valp; |
| 284 | snd_hda_enable_beep_device(codec, enable); |
| 285 | } |
| 286 | if (!ctl_has_mute(kcontrol)) |
| 287 | return 0; |
| 288 | return snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); |
| 289 | } |
| 290 | EXPORT_SYMBOL_GPL(snd_hda_mixer_amp_switch_put_beep); |