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