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
;
59 const char *audio_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
)
116 *irqptr
= irq_of_parse_and_map(np
, 0);
121 /* 0x4 is outenable, 0x1 is out, thus 4 or 5 */
122 #define SWITCH_GPIO(name, v, on) \
124 (name##_gpio_activestate==0?4:5): \
125 (name##_gpio_activestate==0?5:4)))
127 #define FTR_GPIO(name, bit) \
128 static void ftr_gpio_set_##name(struct gpio_runtime *rt, int on)\
132 if (unlikely(!rt)) return; \
134 if (name##_mute_gpio < 0) \
137 v = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, \
141 /* muted = !on... */ \
142 v = SWITCH_GPIO(name##_mute, v, !on); \
144 pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, \
145 name##_mute_gpio, v); \
147 rt->implementation_private &= ~(1<<bit); \
148 rt->implementation_private |= (!!on << bit); \
150 static int ftr_gpio_get_##name(struct gpio_runtime *rt) \
152 if (unlikely(!rt)) return 0; \
153 return (rt->implementation_private>>bit)&1; \
156 FTR_GPIO(headphone
, 0);
158 FTR_GPIO(lineout
, 2);
160 static void ftr_gpio_set_hw_reset(struct gpio_runtime
*rt
, int on
)
164 if (unlikely(!rt
)) return;
165 if (hw_reset_gpio
< 0)
168 v
= pmac_call_feature(PMAC_FTR_READ_GPIO
, NULL
,
170 v
= SWITCH_GPIO(hw_reset
, v
, on
);
171 pmac_call_feature(PMAC_FTR_WRITE_GPIO
, NULL
,
175 static void ftr_gpio_all_amps_off(struct gpio_runtime
*rt
)
179 if (unlikely(!rt
)) return;
180 saved
= rt
->implementation_private
;
181 ftr_gpio_set_headphone(rt
, 0);
182 ftr_gpio_set_amp(rt
, 0);
183 ftr_gpio_set_lineout(rt
, 0);
184 rt
->implementation_private
= saved
;
187 static void ftr_gpio_all_amps_restore(struct gpio_runtime
*rt
)
191 if (unlikely(!rt
)) return;
192 s
= rt
->implementation_private
;
193 ftr_gpio_set_headphone(rt
, (s
>>0)&1);
194 ftr_gpio_set_amp(rt
, (s
>>1)&1);
195 ftr_gpio_set_lineout(rt
, (s
>>2)&1);
198 static void ftr_handle_notify(void *data
)
200 struct gpio_notification
*notif
= data
;
202 mutex_lock(¬if
->mutex
);
204 notif
->notify(notif
->data
);
205 mutex_unlock(¬if
->mutex
);
208 static void gpio_enable_dual_edge(int gpio
)
214 v
= pmac_call_feature(PMAC_FTR_READ_GPIO
, NULL
, gpio
, 0);
215 v
|= 0x80; /* enable dual edge */
216 pmac_call_feature(PMAC_FTR_WRITE_GPIO
, NULL
, gpio
, v
);
219 static void ftr_gpio_init(struct gpio_runtime
*rt
)
221 get_gpio("headphone-mute", NULL
,
222 &headphone_mute_gpio
,
223 &headphone_mute_gpio_activestate
);
224 get_gpio("amp-mute", NULL
,
226 &_mute_gpio_activestate
);
227 get_gpio("lineout-mute", NULL
,
229 &lineout_mute_gpio_activestate
);
230 get_gpio("hw-reset", "audio-hw-reset",
232 &hw_reset_gpio_activestate
);
234 headphone_detect_node
= get_gpio("headphone-detect", NULL
,
235 &headphone_detect_gpio
,
236 &headphone_detect_gpio_activestate
);
237 /* go Apple, and thanks for giving these different names
238 * across the board... */
239 lineout_detect_node
= get_gpio("lineout-detect", "line-output-detect",
240 &lineout_detect_gpio
,
241 &lineout_detect_gpio_activestate
);
242 linein_detect_node
= get_gpio("linein-detect", "line-input-detect",
244 &linein_detect_gpio_activestate
);
246 gpio_enable_dual_edge(headphone_detect_gpio
);
247 gpio_enable_dual_edge(lineout_detect_gpio
);
248 gpio_enable_dual_edge(linein_detect_gpio
);
250 get_irq(headphone_detect_node
, &headphone_detect_irq
);
251 get_irq(lineout_detect_node
, &lineout_detect_irq
);
252 get_irq(linein_detect_node
, &linein_detect_irq
);
254 ftr_gpio_all_amps_off(rt
);
255 rt
->implementation_private
= 0;
256 INIT_WORK(&rt
->headphone_notify
.work
, ftr_handle_notify
,
257 &rt
->headphone_notify
);
258 INIT_WORK(&rt
->line_in_notify
.work
, ftr_handle_notify
,
259 &rt
->line_in_notify
);
260 INIT_WORK(&rt
->line_out_notify
.work
, ftr_handle_notify
,
261 &rt
->line_out_notify
);
262 mutex_init(&rt
->headphone_notify
.mutex
);
263 mutex_init(&rt
->line_in_notify
.mutex
);
264 mutex_init(&rt
->line_out_notify
.mutex
);
267 static void ftr_gpio_exit(struct gpio_runtime
*rt
)
269 ftr_gpio_all_amps_off(rt
);
270 rt
->implementation_private
= 0;
271 if (rt
->headphone_notify
.notify
)
272 free_irq(headphone_detect_irq
, &rt
->headphone_notify
);
273 if (rt
->line_in_notify
.gpio_private
)
274 free_irq(linein_detect_irq
, &rt
->line_in_notify
);
275 if (rt
->line_out_notify
.gpio_private
)
276 free_irq(lineout_detect_irq
, &rt
->line_out_notify
);
277 cancel_delayed_work(&rt
->headphone_notify
.work
);
278 cancel_delayed_work(&rt
->line_in_notify
.work
);
279 cancel_delayed_work(&rt
->line_out_notify
.work
);
280 flush_scheduled_work();
281 mutex_destroy(&rt
->headphone_notify
.mutex
);
282 mutex_destroy(&rt
->line_in_notify
.mutex
);
283 mutex_destroy(&rt
->line_out_notify
.mutex
);
286 static irqreturn_t
ftr_handle_notify_irq(int xx
, void *data
)
288 struct gpio_notification
*notif
= data
;
290 schedule_work(¬if
->work
);
295 static int ftr_set_notify(struct gpio_runtime
*rt
,
296 enum notify_type type
,
297 notify_func_t notify
,
300 struct gpio_notification
*notif
;
307 case AOA_NOTIFY_HEADPHONE
:
308 notif
= &rt
->headphone_notify
;
309 name
= "headphone-detect";
310 irq
= headphone_detect_irq
;
312 case AOA_NOTIFY_LINE_IN
:
313 notif
= &rt
->line_in_notify
;
314 name
= "linein-detect";
315 irq
= linein_detect_irq
;
317 case AOA_NOTIFY_LINE_OUT
:
318 notif
= &rt
->line_out_notify
;
319 name
= "lineout-detect";
320 irq
= lineout_detect_irq
;
329 mutex_lock(¬if
->mutex
);
333 if (!old
&& !notify
) {
339 if (old
== notify
&& notif
->data
== data
)
345 free_irq(irq
, notif
);
347 if (!old
&& notify
) {
348 err
= request_irq(irq
, ftr_handle_notify_irq
, 0, name
, notif
);
353 notif
->notify
= notify
;
358 mutex_unlock(¬if
->mutex
);
362 static int ftr_get_detect(struct gpio_runtime
*rt
,
363 enum notify_type type
)
365 int gpio
, ret
, active
;
368 case AOA_NOTIFY_HEADPHONE
:
369 gpio
= headphone_detect_gpio
;
370 active
= headphone_detect_gpio_activestate
;
372 case AOA_NOTIFY_LINE_IN
:
373 gpio
= linein_detect_gpio
;
374 active
= linein_detect_gpio_activestate
;
376 case AOA_NOTIFY_LINE_OUT
:
377 gpio
= lineout_detect_gpio
;
378 active
= lineout_detect_gpio_activestate
;
387 ret
= pmac_call_feature(PMAC_FTR_READ_GPIO
, NULL
, gpio
, 0);
390 return ((ret
>> 1) & 1) == active
;
393 static struct gpio_methods methods
= {
394 .init
= ftr_gpio_init
,
395 .exit
= ftr_gpio_exit
,
396 .all_amps_off
= ftr_gpio_all_amps_off
,
397 .all_amps_restore
= ftr_gpio_all_amps_restore
,
398 .set_headphone
= ftr_gpio_set_headphone
,
399 .set_speakers
= ftr_gpio_set_amp
,
400 .set_lineout
= ftr_gpio_set_lineout
,
401 .set_hw_reset
= ftr_gpio_set_hw_reset
,
402 .get_headphone
= ftr_gpio_get_headphone
,
403 .get_speakers
= ftr_gpio_get_amp
,
404 .get_lineout
= ftr_gpio_get_lineout
,
405 .set_notify
= ftr_set_notify
,
406 .get_detect
= ftr_get_detect
,
409 struct gpio_methods
*ftr_gpio_methods
= &methods
;
410 EXPORT_SYMBOL_GPL(ftr_gpio_methods
);