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 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(¬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