sound/ppc/toonie.c

   1 /*
   2  * Mac Mini "toonie" mixer control
   3  *
   4  * Copyright (c) 2005 by Benjamin Herrenschmidt <benh@kernel.crashing.org>
   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 <linux/init.h>
  23 #include <linux/delay.h>
  24 #include <linux/i2c.h>
  25 #include <linux/kmod.h>
  26 #include <linux/slab.h>
  27 #include <linux/interrupt.h>
  28 #include <sound/core.h>
  29 #include <asm/io.h>
  30 #include <asm/irq.h>
  31 #include <asm/machdep.h>
  32 #include <asm/pmac_feature.h>
  33 #include "pmac.h"
  34
  35 #undef DEBUG
  36
  37 #ifdef DEBUG
  38 #define DBG(fmt...) printk(fmt)
  39 #else
  40 #define DBG(fmt...)
  41 #endif
  42
  43 struct pmac_gpio {
  44         unsigned int addr;
  45         u8 active_val;
  46         u8 inactive_val;
  47         u8 active_state;
  48 };
  49
  50 struct pmac_toonie
  51 {
  52         struct pmac_gpio        hp_detect_gpio;
  53         struct pmac_gpio        hp_mute_gpio;
  54         struct pmac_gpio        amp_mute_gpio;
  55         int                     hp_detect_irq;
  56         int                     auto_mute_notify;
  57         struct work_struct      detect_work;
  58 };
  59
  60
  61 /*
  62  * gpio access
  63  */
  64 #define do_gpio_write(gp, val) \
  65         pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, (gp)->addr, val)
  66 #define do_gpio_read(gp) \
  67         pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, (gp)->addr, 0)
  68 #define tumbler_gpio_free(gp) /* NOP */
  69
  70 static void write_audio_gpio(struct pmac_gpio *gp, int active)
  71 {
  72         if (! gp->addr)
  73                 return;
  74         active = active ? gp->active_val : gp->inactive_val;
  75         do_gpio_write(gp, active);
  76         DBG("(I) gpio %x write %d\n", gp->addr, active);
  77 }
  78
  79 static int check_audio_gpio(struct pmac_gpio *gp)
  80 {
  81         int ret;
  82
  83         if (! gp->addr)
  84                 return 0;
  85
  86         ret = do_gpio_read(gp);
  87
  88         return (ret & 0xd) == (gp->active_val & 0xd);
  89 }
  90
  91 static int read_audio_gpio(struct pmac_gpio *gp)
  92 {
  93         int ret;
  94         if (! gp->addr)
  95                 return 0;
  96         ret = ((do_gpio_read(gp) & 0x02) !=0);
  97         return ret == gp->active_state;
  98 }
  99
 100
 101 enum { TOONIE_MUTE_HP, TOONIE_MUTE_AMP };
 102
 103 static int toonie_get_mute_switch(struct snd_kcontrol *kcontrol,
 104                                   struct snd_ctl_elem_value *ucontrol)
 105 {
 106         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
 107         struct pmac_toonie *mix = chip->mixer_data;
 108         struct pmac_gpio *gp;
 109
 110         if (mix == NULL)
 111                 return -ENODEV;
 112         switch(kcontrol->private_value) {
 113         case TOONIE_MUTE_HP:
 114                 gp = &mix->hp_mute_gpio;
 115                 break;
 116         case TOONIE_MUTE_AMP:
 117                 gp = &mix->amp_mute_gpio;
 118                 break;
 119         default:
 120                 return -EINVAL;
 121         }
 122         ucontrol->value.integer.value[0] = !check_audio_gpio(gp);
 123         return 0;
 124 }
 125
 126 static int toonie_put_mute_switch(struct snd_kcontrol *kcontrol,
 127                                    struct snd_ctl_elem_value *ucontrol)
 128 {
 129         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
 130         struct pmac_toonie *mix = chip->mixer_data;
 131         struct pmac_gpio *gp;
 132         int val;
 133
 134         if (chip->update_automute && chip->auto_mute)
 135                 return 0; /* don't touch in the auto-mute mode */
 136
 137         if (mix == NULL)
 138                 return -ENODEV;
 139
 140         switch(kcontrol->private_value) {
 141         case TOONIE_MUTE_HP:
 142                 gp = &mix->hp_mute_gpio;
 143                 break;
 144         case TOONIE_MUTE_AMP:
 145                 gp = &mix->amp_mute_gpio;
 146                 break;
 147         default:
 148                 return -EINVAL;
 149         }
 150         val = ! check_audio_gpio(gp);
 151         if (val != ucontrol->value.integer.value[0]) {
 152                 write_audio_gpio(gp, ! ucontrol->value.integer.value[0]);
 153                 return 1;
 154         }
 155         return 0;
 156 }
 157
 158 static struct snd_kcontrol_new toonie_hp_sw __initdata = {
 159         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 160         .name = "Headphone Playback Switch",
 161         .info = snd_pmac_boolean_mono_info,
 162         .get = toonie_get_mute_switch,
 163         .put = toonie_put_mute_switch,
 164         .private_value = TOONIE_MUTE_HP,
 165 };
 166 static struct snd_kcontrol_new toonie_speaker_sw __initdata = {
 167         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 168         .name = "PC Speaker Playback Switch",
 169         .info = snd_pmac_boolean_mono_info,
 170         .get = toonie_get_mute_switch,
 171         .put = toonie_put_mute_switch,
 172         .private_value = TOONIE_MUTE_AMP,
 173 };
 174
 175 /*
 176  * auto-mute stuffs
 177  */
 178 static int toonie_detect_headphone(struct snd_pmac *chip)
 179 {
 180         struct pmac_toonie *mix = chip->mixer_data;
 181         int detect = 0;
 182
 183         if (mix->hp_detect_gpio.addr)
 184                 detect |= read_audio_gpio(&mix->hp_detect_gpio);
 185         return detect;
 186 }
 187
 188 static void toonie_check_mute(struct snd_pmac *chip, struct pmac_gpio *gp, int val,
 189                               int do_notify, struct snd_kcontrol *sw)
 190 {
 191         if (check_audio_gpio(gp) != val) {
 192                 write_audio_gpio(gp, val);
 193                 if (do_notify)
 194                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
 195                                        &sw->id);
 196         }
 197 }
 198
 199 static void toonie_detect_handler(void *self)
 200 {
 201         struct snd_pmac *chip = (struct snd_pmac *) self;
 202         struct pmac_toonie *mix;
 203         int headphone;
 204
 205         if (!chip)
 206                 return;
 207
 208         mix = chip->mixer_data;
 209         snd_assert(mix, return);
 210
 211         headphone = toonie_detect_headphone(chip);
 212
 213         DBG("headphone: %d, lineout: %d\n", headphone, lineout);
 214
 215         if (headphone) {
 216                 /* unmute headphone/lineout & mute speaker */
 217                 toonie_check_mute(chip, &mix->hp_mute_gpio, 0,
 218                                   mix->auto_mute_notify, chip->master_sw_ctl);
 219                 toonie_check_mute(chip, &mix->amp_mute_gpio, 1,
 220                                   mix->auto_mute_notify, chip->speaker_sw_ctl);
 221         } else {
 222                 /* unmute speaker, mute others */
 223                 toonie_check_mute(chip, &mix->amp_mute_gpio, 0,
 224                                   mix->auto_mute_notify, chip->speaker_sw_ctl);
 225                 toonie_check_mute(chip, &mix->hp_mute_gpio, 1,
 226                                   mix->auto_mute_notify, chip->master_sw_ctl);
 227         }
 228         if (mix->auto_mute_notify) {
 229                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
 230                                        &chip->hp_detect_ctl->id);
 231         }
 232 }
 233
 234 static void toonie_update_automute(struct snd_pmac *chip, int do_notify)
 235 {
 236         if (chip->auto_mute) {
 237                 struct pmac_toonie *mix;
 238                 mix = chip->mixer_data;
 239                 snd_assert(mix, return);
 240                 mix->auto_mute_notify = do_notify;
 241                 schedule_work(&mix->detect_work);
 242         }
 243 }
 244
 245 /* interrupt - headphone plug changed */
 246 static irqreturn_t toonie_hp_intr(int irq, void *devid, struct pt_regs *regs)
 247 {
 248         struct snd_pmac *chip = devid;
 249
 250         if (chip->update_automute && chip->initialized) {
 251                 chip->update_automute(chip, 1);
 252                 return IRQ_HANDLED;
 253         }
 254         return IRQ_NONE;
 255 }
 256
 257 /* look for audio gpio device */
 258 static int find_audio_gpio(const char *name, const char *platform,
 259                            struct pmac_gpio *gp)
 260 {
 261         struct device_node *np;
 262         u32 *base, addr;
 263
 264         if (! (np = find_devices("gpio")))
 265                 return -ENODEV;
 266
 267         for (np = np->child; np; np = np->sibling) {
 268                 char *property = get_property(np, "audio-gpio", NULL);
 269                 if (property && strcmp(property, name) == 0)
 270                         break;
 271                 if (device_is_compatible(np, name))
 272                         break;
 273         }
 274         if (np == NULL)
 275                 return -ENODEV;
 276
 277         base = (u32 *)get_property(np, "AAPL,address", NULL);
 278         if (! base) {
 279                 base = (u32 *)get_property(np, "reg", NULL);
 280                 if (!base) {
 281                         DBG("(E) cannot find address for device %s !\n", name);
 282                         return -ENODEV;
 283                 }
 284                 addr = *base;
 285                 if (addr < 0x50)
 286                         addr += 0x50;
 287         } else
 288                 addr = *base;
 289
 290         gp->addr = addr & 0x0000ffff;
 291
 292         /* Try to find the active state, default to 0 ! */
 293         base = (u32 *)get_property(np, "audio-gpio-active-state", NULL);
 294         if (base) {
 295                 gp->active_state = *base;
 296                 gp->active_val = (*base) ? 0x5 : 0x4;
 297                 gp->inactive_val = (*base) ? 0x4 : 0x5;
 298         } else {
 299                 u32 *prop = NULL;
 300                 gp->active_state = 0;
 301                 gp->active_val = 0x4;
 302                 gp->inactive_val = 0x5;
 303                 /* Here are some crude hacks to extract the GPIO polarity and
 304                  * open collector informations out of the do-platform script
 305                  * as we don't yet have an interpreter for these things
 306                  */
 307                 if (platform)
 308                         prop = (u32 *)get_property(np, platform, NULL);
 309                 if (prop) {
 310                         if (prop[3] == 0x9 && prop[4] == 0x9) {
 311                                 gp->active_val = 0xd;
 312                                 gp->inactive_val = 0xc;
 313                         }
 314                         if (prop[3] == 0x1 && prop[4] == 0x1) {
 315                                 gp->active_val = 0x5;
 316                                 gp->inactive_val = 0x4;
 317                         }
 318                 }
 319         }
 320
 321         DBG("(I) GPIO device %s found, offset: %x, active state: %d !\n",
 322             name, gp->addr, gp->active_state);
 323
 324         return (np->n_intrs > 0) ? np->intrs[0].line : 0;
 325 }
 326
 327 static void toonie_cleanup(struct snd_pmac *chip)
 328 {
 329         struct pmac_toonie *mix = chip->mixer_data;
 330         if (! mix)
 331                 return;
 332         if (mix->hp_detect_irq >= 0)
 333                 free_irq(mix->hp_detect_irq, chip);
 334         kfree(mix);
 335         chip->mixer_data = NULL;
 336 }
 337
 338 int snd_pmac_toonie_init(struct snd_pmac *chip)
 339 {
 340         struct pmac_toonie *mix;
 341
 342         mix = kmalloc(sizeof(*mix), GFP_KERNEL);
 343         if (! mix)
 344                 return -ENOMEM;
 345
 346         chip->mixer_data = mix;
 347         chip->mixer_free = toonie_cleanup;
 348
 349         find_audio_gpio("headphone-mute", NULL, &mix->hp_mute_gpio);
 350         find_audio_gpio("amp-mute", NULL, &mix->amp_mute_gpio);
 351         mix->hp_detect_irq = find_audio_gpio("headphone-detect",
 352                                              NULL, &mix->hp_detect_gpio);
 353
 354         strcpy(chip->card->mixername, "PowerMac Toonie");
 355
 356         chip->master_sw_ctl = snd_ctl_new1(&toonie_hp_sw, chip);
 357         snd_ctl_add(chip->card, chip->master_sw_ctl);
 358
 359         chip->speaker_sw_ctl = snd_ctl_new1(&toonie_speaker_sw, chip);
 360         snd_ctl_add(chip->card, chip->speaker_sw_ctl);
 361
 362         INIT_WORK(&mix->detect_work, toonie_detect_handler, (void *)chip);
 363
 364         if (mix->hp_detect_irq >= 0) {
 365                 snd_pmac_add_automute(chip);
 366
 367                 chip->detect_headphone = toonie_detect_headphone;
 368                 chip->update_automute = toonie_update_automute;
 369                 toonie_update_automute(chip, 0);
 370
 371                 if (request_irq(mix->hp_detect_irq, toonie_hp_intr, 0,
 372                                 "Sound Headphone Detection", chip) < 0)
 373                         mix->hp_detect_irq = -1;
 374         }
 375
 376         return 0;
 377 }
 378