2 * Apple Onboard Audio feature call GPIO control
4 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
6 * GPL v2, can be found in COPYING.
8 * This file contains the GPIO control routines for
9 * direct (through feature calls) access to the GPIO
13 #include <asm/pmac_feature.h>
14 #include <linux/interrupt.h>
17 /* TODO: these are 20 global variables
18 * that aren't used on most machines...
19 * Move them into a dynamically allocated
20 * structure and use that.
23 /* these are the GPIO numbers (register addresses as offsets into
25 static int headphone_mute_gpio;
26 static int amp_mute_gpio;
27 static int lineout_mute_gpio;
28 static int hw_reset_gpio;
29 static int lineout_detect_gpio;
30 static int headphone_detect_gpio;
31 static int linein_detect_gpio;
33 /* see the SWITCH_GPIO macro */
34 static int headphone_mute_gpio_activestate;
35 static int amp_mute_gpio_activestate;
36 static int lineout_mute_gpio_activestate;
37 static int hw_reset_gpio_activestate;
38 static int lineout_detect_gpio_activestate;
39 static int headphone_detect_gpio_activestate;
40 static int linein_detect_gpio_activestate;
42 /* node pointers that we save when getting the GPIO number
43 * to get the interrupt later */
44 static struct device_node *lineout_detect_node;
45 static struct device_node *linein_detect_node;
46 static struct device_node *headphone_detect_node;
48 static int lineout_detect_irq;
49 static int linein_detect_irq;
50 static int headphone_detect_irq;
52 static struct device_node *get_gpio(char *name,
57 struct device_node *np, *gpio;
63 /* check if we can get it the easy way ... */
64 np = of_find_node_by_name(NULL, name);
66 /* some machines have only gpioX/extint-gpioX nodes,
67 * and an audio-gpio property saying what it is ...
68 * So what we have to do is enumerate all children
69 * of the gpio node and check them all. */
70 gpio = of_find_node_by_name(NULL, "gpio");
73 while ((np = of_get_next_child(gpio, np))) {
74 audio_gpio = get_property(np, "audio-gpio", NULL);
77 if (strcmp(audio_gpio, name) == 0)
79 if (altname && (strcmp(audio_gpio, altname) == 0))
82 /* still not found, assume not there */
87 reg = (u32 *)get_property(np, "reg", NULL);
93 /* this is a hack, usually the GPIOs 'reg' property
94 * should have the offset based from the GPIO space
95 * which is at 0x50, but apparently not always... */
99 reg = (u32 *)get_property(np, "audio-gpio-active-state", NULL);
101 /* Apple seems to default to 1, but
102 * that doesn't seem right at least on most
103 * machines. So until proven that the opposite
104 * is necessary, we default to 0
105 * (which, incidentally, snd-powermac also does...) */
108 *gpioactiveptr = *reg;
113 static void get_irq(struct device_node * np, int *irqptr)
115 *irqptr = irq_of_parse_and_map(np, 0);
118 /* 0x4 is outenable, 0x1 is out, thus 4 or 5 */
119 #define SWITCH_GPIO(name, v, on) \
121 (name##_gpio_activestate==0?4:5): \
122 (name##_gpio_activestate==0?5:4)))
124 #define FTR_GPIO(name, bit) \
125 static void ftr_gpio_set_##name(struct gpio_runtime *rt, int on)\
129 if (unlikely(!rt)) return; \
131 if (name##_mute_gpio < 0) \
134 v = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, \
138 /* muted = !on... */ \
139 v = SWITCH_GPIO(name##_mute, v, !on); \
141 pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, \
142 name##_mute_gpio, v); \
144 rt->implementation_private &= ~(1<<bit); \
145 rt->implementation_private |= (!!on << bit); \
147 static int ftr_gpio_get_##name(struct gpio_runtime *rt) \
149 if (unlikely(!rt)) return 0; \
150 return (rt->implementation_private>>bit)&1; \
153 FTR_GPIO(headphone, 0);
155 FTR_GPIO(lineout, 2);
157 static void ftr_gpio_set_hw_reset(struct gpio_runtime *rt, int on)
161 if (unlikely(!rt)) return;
162 if (hw_reset_gpio < 0)
165 v = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL,
167 v = SWITCH_GPIO(hw_reset, v, on);
168 pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL,
172 static void ftr_gpio_all_amps_off(struct gpio_runtime *rt)
176 if (unlikely(!rt)) return;
177 saved = rt->implementation_private;
178 ftr_gpio_set_headphone(rt, 0);
179 ftr_gpio_set_amp(rt, 0);
180 ftr_gpio_set_lineout(rt, 0);
181 rt->implementation_private = saved;
184 static void ftr_gpio_all_amps_restore(struct gpio_runtime *rt)
188 if (unlikely(!rt)) return;
189 s = rt->implementation_private;
190 ftr_gpio_set_headphone(rt, (s>>0)&1);
191 ftr_gpio_set_amp(rt, (s>>1)&1);
192 ftr_gpio_set_lineout(rt, (s>>2)&1);
195 static void ftr_handle_notify(void *data)
197 struct gpio_notification *notif = data;
199 mutex_lock(¬if->mutex);
201 notif->notify(notif->data);
202 mutex_unlock(¬if->mutex);
205 static void gpio_enable_dual_edge(int gpio)
211 v = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, gpio, 0);
212 v |= 0x80; /* enable dual edge */
213 pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, gpio, v);
216 static void ftr_gpio_init(struct gpio_runtime *rt)
218 get_gpio("headphone-mute", NULL,
219 &headphone_mute_gpio,
220 &headphone_mute_gpio_activestate);
221 get_gpio("amp-mute", NULL,
223 &_mute_gpio_activestate);
224 get_gpio("lineout-mute", NULL,
226 &lineout_mute_gpio_activestate);
227 get_gpio("hw-reset", "audio-hw-reset",
229 &hw_reset_gpio_activestate);
231 headphone_detect_node = get_gpio("headphone-detect", NULL,
232 &headphone_detect_gpio,
233 &headphone_detect_gpio_activestate);
234 /* go Apple, and thanks for giving these different names
235 * across the board... */
236 lineout_detect_node = get_gpio("lineout-detect", "line-output-detect",
237 &lineout_detect_gpio,
238 &lineout_detect_gpio_activestate);
239 linein_detect_node = get_gpio("linein-detect", "line-input-detect",
241 &linein_detect_gpio_activestate);
243 gpio_enable_dual_edge(headphone_detect_gpio);
244 gpio_enable_dual_edge(lineout_detect_gpio);
245 gpio_enable_dual_edge(linein_detect_gpio);
247 get_irq(headphone_detect_node, &headphone_detect_irq);
248 get_irq(lineout_detect_node, &lineout_detect_irq);
249 get_irq(linein_detect_node, &linein_detect_irq);
251 ftr_gpio_all_amps_off(rt);
252 rt->implementation_private = 0;
253 INIT_WORK(&rt->headphone_notify.work, ftr_handle_notify,
254 &rt->headphone_notify);
255 INIT_WORK(&rt->line_in_notify.work, ftr_handle_notify,
256 &rt->line_in_notify);
257 INIT_WORK(&rt->line_out_notify.work, ftr_handle_notify,
258 &rt->line_out_notify);
259 mutex_init(&rt->headphone_notify.mutex);
260 mutex_init(&rt->line_in_notify.mutex);
261 mutex_init(&rt->line_out_notify.mutex);
264 static void ftr_gpio_exit(struct gpio_runtime *rt)
266 ftr_gpio_all_amps_off(rt);
267 rt->implementation_private = 0;
268 if (rt->headphone_notify.notify)
269 free_irq(headphone_detect_irq, &rt->headphone_notify);
270 if (rt->line_in_notify.gpio_private)
271 free_irq(linein_detect_irq, &rt->line_in_notify);
272 if (rt->line_out_notify.gpio_private)
273 free_irq(lineout_detect_irq, &rt->line_out_notify);
274 cancel_delayed_work(&rt->headphone_notify.work);
275 cancel_delayed_work(&rt->line_in_notify.work);
276 cancel_delayed_work(&rt->line_out_notify.work);
277 flush_scheduled_work();
278 mutex_destroy(&rt->headphone_notify.mutex);
279 mutex_destroy(&rt->line_in_notify.mutex);
280 mutex_destroy(&rt->line_out_notify.mutex);
283 static irqreturn_t ftr_handle_notify_irq(int xx,
285 struct pt_regs *regs)
287 struct gpio_notification *notif = data;
289 schedule_work(¬if->work);
294 static int ftr_set_notify(struct gpio_runtime *rt,
295 enum notify_type type,
296 notify_func_t notify,
299 struct gpio_notification *notif;
306 case AOA_NOTIFY_HEADPHONE:
307 notif = &rt->headphone_notify;
308 name = "headphone-detect";
309 irq = headphone_detect_irq;
311 case AOA_NOTIFY_LINE_IN:
312 notif = &rt->line_in_notify;
313 name = "linein-detect";
314 irq = linein_detect_irq;
316 case AOA_NOTIFY_LINE_OUT:
317 notif = &rt->line_out_notify;
318 name = "lineout-detect";
319 irq = lineout_detect_irq;
328 mutex_lock(¬if->mutex);
332 if (!old && !notify) {
338 if (old == notify && notif->data == data)
344 free_irq(irq, notif);
346 if (!old && notify) {
347 err = request_irq(irq, ftr_handle_notify_irq, 0, name, notif);
352 notif->notify = notify;
357 mutex_unlock(¬if->mutex);
361 static int ftr_get_detect(struct gpio_runtime *rt,
362 enum notify_type type)
364 int gpio, ret, active;
367 case AOA_NOTIFY_HEADPHONE:
368 gpio = headphone_detect_gpio;
369 active = headphone_detect_gpio_activestate;
371 case AOA_NOTIFY_LINE_IN:
372 gpio = linein_detect_gpio;
373 active = linein_detect_gpio_activestate;
375 case AOA_NOTIFY_LINE_OUT:
376 gpio = lineout_detect_gpio;
377 active = lineout_detect_gpio_activestate;
386 ret = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, gpio, 0);
389 return ((ret >> 1) & 1) == active;
392 static struct gpio_methods methods = {
393 .init = ftr_gpio_init,
394 .exit = ftr_gpio_exit,
395 .all_amps_off = ftr_gpio_all_amps_off,
396 .all_amps_restore = ftr_gpio_all_amps_restore,
397 .set_headphone = ftr_gpio_set_headphone,
398 .set_speakers = ftr_gpio_set_amp,
399 .set_lineout = ftr_gpio_set_lineout,
400 .set_hw_reset = ftr_gpio_set_hw_reset,
401 .get_headphone = ftr_gpio_get_headphone,
402 .get_speakers = ftr_gpio_get_amp,
403 .get_lineout = ftr_gpio_get_lineout,
404 .set_notify = ftr_set_notify,
405 .get_detect = ftr_get_detect,
408 struct gpio_methods *ftr_gpio_methods = &methods;
409 EXPORT_SYMBOL_GPL(ftr_gpio_methods);