WorkStruct: make allyesconfig
[linux-3.10.git] / sound / aoa / core / snd-aoa-gpio-pmf.c
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
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, 0);
56         pmf_gpio_set_amp(rt, 0);
57         pmf_gpio_set_lineout(rt, 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, (s>>0)&1);
68         pmf_gpio_set_amp(rt, (s>>1)&1);
69         pmf_gpio_set_lineout(rt, (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(&notif->mutex);
78         if (notif->notify)
79                 notif->notify(notif->data);
80         mutex_unlock(&notif->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(&rt->headphone_notify.work);
110         cancel_delayed_work(&rt->line_in_notify.work);
111         cancel_delayed_work(&rt->line_out_notify.work);
112         flush_scheduled_work();
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
118         if (rt->headphone_notify.gpio_private)
119                 kfree(rt->headphone_notify.gpio_private);
120         if (rt->line_in_notify.gpio_private)
121                 kfree(rt->line_in_notify.gpio_private);
122         if (rt->line_out_notify.gpio_private)
123                 kfree(rt->line_out_notify.gpio_private);
124 }
125
126 static void pmf_handle_notify_irq(void *data)
127 {
128         struct gpio_notification *notif = data;
129
130         schedule_delayed_work(&notif->work, 0);
131 }
132
133 static int pmf_set_notify(struct gpio_runtime *rt,
134                           enum notify_type type,
135                           notify_func_t notify,
136                           void *data)
137 {
138         struct gpio_notification *notif;
139         notify_func_t old;
140         struct pmf_irq_client *irq_client;
141         char *name;
142         int err = -EBUSY;
143
144         switch (type) {
145         case AOA_NOTIFY_HEADPHONE:
146                 notif = &rt->headphone_notify;
147                 name = "headphone-detect";
148                 break;
149         case AOA_NOTIFY_LINE_IN:
150                 notif = &rt->line_in_notify;
151                 name = "linein-detect";
152                 break;
153         case AOA_NOTIFY_LINE_OUT:
154                 notif = &rt->line_out_notify;
155                 name = "lineout-detect";
156                 break;
157         default:
158                 return -EINVAL;
159         }
160
161         mutex_lock(&notif->mutex);
162
163         old = notif->notify;
164
165         if (!old && !notify) {
166                 err = 0;
167                 goto out_unlock;
168         }
169
170         if (old && notify) {
171                 if (old == notify && notif->data == data)
172                         err = 0;
173                 goto out_unlock;
174         }
175
176         if (old && !notify) {
177                 irq_client = notif->gpio_private;
178                 pmf_unregister_irq_client(irq_client);
179                 kfree(irq_client);
180                 notif->gpio_private = NULL;
181         }
182         if (!old && notify) {
183                 irq_client = kzalloc(sizeof(struct pmf_irq_client),
184                                      GFP_KERNEL);
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(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(&notif->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);