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(¬if->mutex); 78 if (notif->notify) 79 notif->notify(notif->data); 80 mutex_unlock(¬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(&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(¬if->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(¬if->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 if (!irq_client) { 186 err = -ENOMEM; 187 goto out_unlock; 188 } 189 irq_client->data = notif; 190 irq_client->handler = pmf_handle_notify_irq; 191 irq_client->owner = THIS_MODULE; 192 err = pmf_register_irq_client(rt->node, 193 name, 194 irq_client); 195 if (err) { 196 printk(KERN_ERR "snd-aoa: gpio layer failed to" 197 " register %s irq (%d)\n", name, err); 198 kfree(irq_client); 199 goto out_unlock; 200 } 201 notif->gpio_private = irq_client; 202 } 203 notif->notify = notify; 204 notif->data = data; 205 206 err = 0; 207 out_unlock: 208 mutex_unlock(¬if->mutex); 209 return err; 210 } 211 212 static int pmf_get_detect(struct gpio_runtime *rt, 213 enum notify_type type) 214 { 215 char *name; 216 int err = -EBUSY, ret; 217 struct pmf_args args = { .count = 1, .u[0].p = &ret }; 218 219 switch (type) { 220 case AOA_NOTIFY_HEADPHONE: 221 name = "headphone-detect"; 222 break; 223 case AOA_NOTIFY_LINE_IN: 224 name = "linein-detect"; 225 break; 226 case AOA_NOTIFY_LINE_OUT: 227 name = "lineout-detect"; 228 break; 229 default: 230 return -EINVAL; 231 } 232 233 err = pmf_call_function(rt->node, name, &args); 234 if (err) 235 return err; 236 return ret; 237 } 238 239 static struct gpio_methods methods = { 240 .init = pmf_gpio_init, 241 .exit = pmf_gpio_exit, 242 .all_amps_off = pmf_gpio_all_amps_off, 243 .all_amps_restore = pmf_gpio_all_amps_restore, 244 .set_headphone = pmf_gpio_set_headphone, 245 .set_speakers = pmf_gpio_set_amp, 246 .set_lineout = pmf_gpio_set_lineout, 247 .set_hw_reset = pmf_gpio_set_hw_reset, 248 .get_headphone = pmf_gpio_get_headphone, 249 .get_speakers = pmf_gpio_get_amp, 250 .get_lineout = pmf_gpio_get_lineout, 251 .set_notify = pmf_set_notify, 252 .get_detect = pmf_get_detect, 253 }; 254 255 struct gpio_methods *pmf_gpio_methods = &methods; 256 EXPORT_SYMBOL_GPL(pmf_gpio_methods); 257