Commit | Line | Data |
---|---|---|
f3d9478b JB |
1 | /* |
2 | * Apple Onboard Audio pmf GPIOs | |
3 | * | |
4 | * Copyright 2006 Johannes Berg <johannes@sipsolutions.net> | |
5 | * | |
6 | * GPL v2, can be found in COPYING. | |
7 | */ | |
8 | ||
5a0e3ad6 | 9 | #include <linux/slab.h> |
f3d9478b JB |
10 | #include <asm/pmac_feature.h> |
11 | #include <asm/pmac_pfunc.h> | |
12 | #include "../aoa.h" | |
13 | ||
14 | #define PMF_GPIO(name, bit) \ | |
15 | static void pmf_gpio_set_##name(struct gpio_runtime *rt, int on)\ | |
16 | { \ | |
17 | struct pmf_args args = { .count = 1, .u[0].v = !on }; \ | |
e53fcabc BH |
18 | int rc; \ |
19 | \ | |
f3d9478b | 20 | if (unlikely(!rt)) return; \ |
e53fcabc | 21 | rc = pmf_call_function(rt->node, #name "-mute", &args); \ |
be6a83dd | 22 | if (rc && rc != -ENODEV) \ |
e53fcabc BH |
23 | printk(KERN_WARNING "pmf_gpio_set_" #name \ |
24 | " failed, rc: %d\n", rc); \ | |
f3d9478b JB |
25 | rt->implementation_private &= ~(1<<bit); \ |
26 | rt->implementation_private |= (!!on << bit); \ | |
27 | } \ | |
28 | static int pmf_gpio_get_##name(struct gpio_runtime *rt) \ | |
29 | { \ | |
30 | if (unlikely(!rt)) return 0; \ | |
31 | return (rt->implementation_private>>bit)&1; \ | |
32 | } | |
33 | ||
34 | PMF_GPIO(headphone, 0); | |
35 | PMF_GPIO(amp, 1); | |
36 | PMF_GPIO(lineout, 2); | |
37 | ||
38 | static void pmf_gpio_set_hw_reset(struct gpio_runtime *rt, int on) | |
39 | { | |
40 | struct pmf_args args = { .count = 1, .u[0].v = !!on }; | |
e53fcabc | 41 | int rc; |
f3d9478b JB |
42 | |
43 | if (unlikely(!rt)) return; | |
e53fcabc BH |
44 | rc = pmf_call_function(rt->node, "hw-reset", &args); |
45 | if (rc) | |
46 | printk(KERN_WARNING "pmf_gpio_set_hw_reset" | |
47 | " failed, rc: %d\n", rc); | |
f3d9478b JB |
48 | } |
49 | ||
50 | static void pmf_gpio_all_amps_off(struct gpio_runtime *rt) | |
51 | { | |
52 | int saved; | |
53 | ||
54 | if (unlikely(!rt)) return; | |
55 | saved = rt->implementation_private; | |
56 | pmf_gpio_set_headphone(rt, 0); | |
57 | pmf_gpio_set_amp(rt, 0); | |
58 | pmf_gpio_set_lineout(rt, 0); | |
59 | rt->implementation_private = saved; | |
60 | } | |
61 | ||
62 | static void pmf_gpio_all_amps_restore(struct gpio_runtime *rt) | |
63 | { | |
64 | int s; | |
65 | ||
66 | if (unlikely(!rt)) return; | |
67 | s = rt->implementation_private; | |
68 | pmf_gpio_set_headphone(rt, (s>>0)&1); | |
69 | pmf_gpio_set_amp(rt, (s>>1)&1); | |
70 | pmf_gpio_set_lineout(rt, (s>>2)&1); | |
71 | } | |
72 | ||
c4028958 | 73 | static void pmf_handle_notify(struct work_struct *work) |
f3d9478b | 74 | { |
c4028958 DH |
75 | struct gpio_notification *notif = |
76 | container_of(work, struct gpio_notification, work.work); | |
f3d9478b JB |
77 | |
78 | mutex_lock(¬if->mutex); | |
79 | if (notif->notify) | |
80 | notif->notify(notif->data); | |
81 | mutex_unlock(¬if->mutex); | |
82 | } | |
83 | ||
84 | static void pmf_gpio_init(struct gpio_runtime *rt) | |
85 | { | |
86 | pmf_gpio_all_amps_off(rt); | |
87 | rt->implementation_private = 0; | |
c4028958 DH |
88 | INIT_DELAYED_WORK(&rt->headphone_notify.work, pmf_handle_notify); |
89 | INIT_DELAYED_WORK(&rt->line_in_notify.work, pmf_handle_notify); | |
90 | INIT_DELAYED_WORK(&rt->line_out_notify.work, pmf_handle_notify); | |
f3d9478b JB |
91 | mutex_init(&rt->headphone_notify.mutex); |
92 | mutex_init(&rt->line_in_notify.mutex); | |
93 | mutex_init(&rt->line_out_notify.mutex); | |
94 | } | |
95 | ||
96 | static void pmf_gpio_exit(struct gpio_runtime *rt) | |
97 | { | |
98 | pmf_gpio_all_amps_off(rt); | |
99 | rt->implementation_private = 0; | |
100 | ||
101 | if (rt->headphone_notify.gpio_private) | |
102 | pmf_unregister_irq_client(rt->headphone_notify.gpio_private); | |
103 | if (rt->line_in_notify.gpio_private) | |
104 | pmf_unregister_irq_client(rt->line_in_notify.gpio_private); | |
105 | if (rt->line_out_notify.gpio_private) | |
106 | pmf_unregister_irq_client(rt->line_out_notify.gpio_private); | |
107 | ||
108 | /* make sure no work is pending before freeing | |
109 | * all things */ | |
5b84ba26 TH |
110 | cancel_delayed_work_sync(&rt->headphone_notify.work); |
111 | cancel_delayed_work_sync(&rt->line_in_notify.work); | |
112 | cancel_delayed_work_sync(&rt->line_out_notify.work); | |
f3d9478b JB |
113 | |
114 | mutex_destroy(&rt->headphone_notify.mutex); | |
115 | mutex_destroy(&rt->line_in_notify.mutex); | |
116 | mutex_destroy(&rt->line_out_notify.mutex); | |
117 | ||
6237cdac | 118 | kfree(rt->headphone_notify.gpio_private); |
119 | kfree(rt->line_in_notify.gpio_private); | |
120 | kfree(rt->line_out_notify.gpio_private); | |
f3d9478b JB |
121 | } |
122 | ||
123 | static void pmf_handle_notify_irq(void *data) | |
124 | { | |
125 | struct gpio_notification *notif = data; | |
126 | ||
c4028958 | 127 | schedule_delayed_work(¬if->work, 0); |
f3d9478b JB |
128 | } |
129 | ||
130 | static int pmf_set_notify(struct gpio_runtime *rt, | |
131 | enum notify_type type, | |
132 | notify_func_t notify, | |
133 | void *data) | |
134 | { | |
135 | struct gpio_notification *notif; | |
136 | notify_func_t old; | |
137 | struct pmf_irq_client *irq_client; | |
138 | char *name; | |
139 | int err = -EBUSY; | |
140 | ||
141 | switch (type) { | |
142 | case AOA_NOTIFY_HEADPHONE: | |
143 | notif = &rt->headphone_notify; | |
144 | name = "headphone-detect"; | |
145 | break; | |
146 | case AOA_NOTIFY_LINE_IN: | |
147 | notif = &rt->line_in_notify; | |
148 | name = "linein-detect"; | |
149 | break; | |
150 | case AOA_NOTIFY_LINE_OUT: | |
151 | notif = &rt->line_out_notify; | |
152 | name = "lineout-detect"; | |
153 | break; | |
154 | default: | |
155 | return -EINVAL; | |
156 | } | |
157 | ||
158 | mutex_lock(¬if->mutex); | |
159 | ||
160 | old = notif->notify; | |
161 | ||
162 | if (!old && !notify) { | |
163 | err = 0; | |
164 | goto out_unlock; | |
165 | } | |
166 | ||
167 | if (old && notify) { | |
168 | if (old == notify && notif->data == data) | |
169 | err = 0; | |
170 | goto out_unlock; | |
171 | } | |
172 | ||
173 | if (old && !notify) { | |
174 | irq_client = notif->gpio_private; | |
175 | pmf_unregister_irq_client(irq_client); | |
176 | kfree(irq_client); | |
177 | notif->gpio_private = NULL; | |
178 | } | |
179 | if (!old && notify) { | |
180 | irq_client = kzalloc(sizeof(struct pmf_irq_client), | |
181 | GFP_KERNEL); | |
f065fabc JL |
182 | if (!irq_client) { |
183 | err = -ENOMEM; | |
184 | goto out_unlock; | |
185 | } | |
f3d9478b JB |
186 | irq_client->data = notif; |
187 | irq_client->handler = pmf_handle_notify_irq; | |
188 | irq_client->owner = THIS_MODULE; | |
189 | err = pmf_register_irq_client(rt->node, | |
190 | name, | |
191 | irq_client); | |
192 | if (err) { | |
193 | printk(KERN_ERR "snd-aoa: gpio layer failed to" | |
194 | " register %s irq (%d)\n", name, err); | |
195 | kfree(irq_client); | |
196 | goto out_unlock; | |
197 | } | |
198 | notif->gpio_private = irq_client; | |
199 | } | |
200 | notif->notify = notify; | |
201 | notif->data = data; | |
202 | ||
203 | err = 0; | |
204 | out_unlock: | |
205 | mutex_unlock(¬if->mutex); | |
206 | return err; | |
207 | } | |
208 | ||
209 | static int pmf_get_detect(struct gpio_runtime *rt, | |
210 | enum notify_type type) | |
211 | { | |
212 | char *name; | |
213 | int err = -EBUSY, ret; | |
214 | struct pmf_args args = { .count = 1, .u[0].p = &ret }; | |
215 | ||
216 | switch (type) { | |
217 | case AOA_NOTIFY_HEADPHONE: | |
218 | name = "headphone-detect"; | |
219 | break; | |
220 | case AOA_NOTIFY_LINE_IN: | |
221 | name = "linein-detect"; | |
222 | break; | |
223 | case AOA_NOTIFY_LINE_OUT: | |
224 | name = "lineout-detect"; | |
225 | break; | |
226 | default: | |
227 | return -EINVAL; | |
228 | } | |
229 | ||
230 | err = pmf_call_function(rt->node, name, &args); | |
231 | if (err) | |
232 | return err; | |
233 | return ret; | |
234 | } | |
235 | ||
236 | static struct gpio_methods methods = { | |
237 | .init = pmf_gpio_init, | |
238 | .exit = pmf_gpio_exit, | |
239 | .all_amps_off = pmf_gpio_all_amps_off, | |
240 | .all_amps_restore = pmf_gpio_all_amps_restore, | |
241 | .set_headphone = pmf_gpio_set_headphone, | |
242 | .set_speakers = pmf_gpio_set_amp, | |
243 | .set_lineout = pmf_gpio_set_lineout, | |
244 | .set_hw_reset = pmf_gpio_set_hw_reset, | |
245 | .get_headphone = pmf_gpio_get_headphone, | |
246 | .get_speakers = pmf_gpio_get_amp, | |
247 | .get_lineout = pmf_gpio_get_lineout, | |
248 | .set_notify = pmf_set_notify, | |
249 | .get_detect = pmf_get_detect, | |
250 | }; | |
251 | ||
252 | struct gpio_methods *pmf_gpio_methods = &methods; | |
253 | EXPORT_SYMBOL_GPL(pmf_gpio_methods); |