Merge branch 'bugzilla-13041' into release
[linux-2.6] / drivers / input / misc / sparcspkr.c
1 /*
2  *  Driver for PC-speaker like devices found on various Sparc systems.
3  *
4  *  Copyright (c) 2002 Vojtech Pavlik
5  *  Copyright (c) 2002, 2006, 2008 David S. Miller (davem@davemloft.net)
6  */
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/input.h>
11 #include <linux/of_device.h>
12
13 #include <asm/io.h>
14
15 MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
16 MODULE_DESCRIPTION("Sparc Speaker beeper driver");
17 MODULE_LICENSE("GPL");
18
19 struct grover_beep_info {
20         void __iomem    *freq_regs;
21         void __iomem    *enable_reg;
22 };
23
24 struct bbc_beep_info {
25         u32             clock_freq;
26         void __iomem    *regs;
27 };
28
29 struct sparcspkr_state {
30         const char              *name;
31         int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
32         spinlock_t              lock;
33         struct input_dev        *input_dev;
34         union {
35                 struct grover_beep_info grover;
36                 struct bbc_beep_info bbc;
37         } u;
38 };
39
40 static u32 bbc_count_to_reg(struct bbc_beep_info *info, unsigned int count)
41 {
42         u32 val, clock_freq = info->clock_freq;
43         int i;
44
45         if (!count)
46                 return 0;
47
48         if (count <= clock_freq >> 20)
49                 return 1 << 18;
50
51         if (count >= clock_freq >> 12)
52                 return 1 << 10;
53
54         val = 1 << 18;
55         for (i = 19; i >= 11; i--) {
56                 val >>= 1;
57                 if (count <= clock_freq >> i)
58                         break;
59         }
60
61         return val;
62 }
63
64 static int bbc_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
65 {
66         struct sparcspkr_state *state = dev_get_drvdata(dev->dev.parent);
67         struct bbc_beep_info *info = &state->u.bbc;
68         unsigned int count = 0;
69         unsigned long flags;
70
71         if (type != EV_SND)
72                 return -1;
73
74         switch (code) {
75                 case SND_BELL: if (value) value = 1000;
76                 case SND_TONE: break;
77                 default: return -1;
78         }
79
80         if (value > 20 && value < 32767)
81                 count = 1193182 / value;
82
83         count = bbc_count_to_reg(info, count);
84
85         spin_lock_irqsave(&state->lock, flags);
86
87         if (count) {
88                 outb(0x01,                 info->regs + 0);
89                 outb(0x00,                 info->regs + 2);
90                 outb((count >> 16) & 0xff, info->regs + 3);
91                 outb((count >>  8) & 0xff, info->regs + 4);
92                 outb(0x00,                 info->regs + 5);
93         } else {
94                 outb(0x00,                 info->regs + 0);
95         }
96
97         spin_unlock_irqrestore(&state->lock, flags);
98
99         return 0;
100 }
101
102 static int grover_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
103 {
104         struct sparcspkr_state *state = dev_get_drvdata(dev->dev.parent);
105         struct grover_beep_info *info = &state->u.grover;
106         unsigned int count = 0;
107         unsigned long flags;
108
109         if (type != EV_SND)
110                 return -1;
111
112         switch (code) {
113                 case SND_BELL: if (value) value = 1000;
114                 case SND_TONE: break;
115                 default: return -1;
116         }
117
118         if (value > 20 && value < 32767)
119                 count = 1193182 / value;
120
121         spin_lock_irqsave(&state->lock, flags);
122
123         if (count) {
124                 /* enable counter 2 */
125                 outb(inb(info->enable_reg) | 3, info->enable_reg);
126                 /* set command for counter 2, 2 byte write */
127                 outb(0xB6, info->freq_regs + 1);
128                 /* select desired HZ */
129                 outb(count & 0xff, info->freq_regs + 0);
130                 outb((count >> 8) & 0xff, info->freq_regs + 0);
131         } else {
132                 /* disable counter 2 */
133                 outb(inb_p(info->enable_reg) & 0xFC, info->enable_reg);
134         }
135
136         spin_unlock_irqrestore(&state->lock, flags);
137
138         return 0;
139 }
140
141 static int __devinit sparcspkr_probe(struct device *dev)
142 {
143         struct sparcspkr_state *state = dev_get_drvdata(dev);
144         struct input_dev *input_dev;
145         int error;
146
147         input_dev = input_allocate_device();
148         if (!input_dev)
149                 return -ENOMEM;
150
151         input_dev->name = state->name;
152         input_dev->phys = "sparc/input0";
153         input_dev->id.bustype = BUS_ISA;
154         input_dev->id.vendor = 0x001f;
155         input_dev->id.product = 0x0001;
156         input_dev->id.version = 0x0100;
157         input_dev->dev.parent = dev;
158
159         input_dev->evbit[0] = BIT_MASK(EV_SND);
160         input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
161
162         input_dev->event = state->event;
163
164         error = input_register_device(input_dev);
165         if (error) {
166                 input_free_device(input_dev);
167                 return error;
168         }
169
170         state->input_dev = input_dev;
171
172         return 0;
173 }
174
175 static int sparcspkr_shutdown(struct of_device *dev)
176 {
177         struct sparcspkr_state *state = dev_get_drvdata(&dev->dev);
178         struct input_dev *input_dev = state->input_dev;
179
180         /* turn off the speaker */
181         state->event(input_dev, EV_SND, SND_BELL, 0);
182
183         return 0;
184 }
185
186 static int __devinit bbc_beep_probe(struct of_device *op, const struct of_device_id *match)
187 {
188         struct sparcspkr_state *state;
189         struct bbc_beep_info *info;
190         struct device_node *dp;
191         int err = -ENOMEM;
192
193         state = kzalloc(sizeof(*state), GFP_KERNEL);
194         if (!state)
195                 goto out_err;
196
197         state->name = "Sparc BBC Speaker";
198         state->event = bbc_spkr_event;
199         spin_lock_init(&state->lock);
200
201         dp = of_find_node_by_path("/");
202         err = -ENODEV;
203         if (!dp)
204                 goto out_free;
205
206         info = &state->u.bbc;
207         info->clock_freq = of_getintprop_default(dp, "clock-frequency", 0);
208         if (!info->clock_freq)
209                 goto out_free;
210
211         info->regs = of_ioremap(&op->resource[0], 0, 6, "bbc beep");
212         if (!info->regs)
213                 goto out_free;
214
215         dev_set_drvdata(&op->dev, state);
216
217         err = sparcspkr_probe(&op->dev);
218         if (err)
219                 goto out_clear_drvdata;
220
221         return 0;
222
223 out_clear_drvdata:
224         dev_set_drvdata(&op->dev, NULL);
225         of_iounmap(&op->resource[0], info->regs, 6);
226
227 out_free:
228         kfree(state);
229 out_err:
230         return err;
231 }
232
233 static int bbc_remove(struct of_device *op)
234 {
235         struct sparcspkr_state *state = dev_get_drvdata(&op->dev);
236         struct input_dev *input_dev = state->input_dev;
237         struct bbc_beep_info *info = &state->u.bbc;
238
239         /* turn off the speaker */
240         state->event(input_dev, EV_SND, SND_BELL, 0);
241
242         input_unregister_device(input_dev);
243
244         of_iounmap(&op->resource[0], info->regs, 6);
245
246         dev_set_drvdata(&op->dev, NULL);
247         kfree(state);
248
249         return 0;
250 }
251
252 static const struct of_device_id bbc_beep_match[] = {
253         {
254                 .name = "beep",
255                 .compatible = "SUNW,bbc-beep",
256         },
257         {},
258 };
259
260 static struct of_platform_driver bbc_beep_driver = {
261         .name           = "bbcbeep",
262         .match_table    = bbc_beep_match,
263         .probe          = bbc_beep_probe,
264         .remove         = __devexit_p(bbc_remove),
265         .shutdown       = sparcspkr_shutdown,
266 };
267
268 static int __devinit grover_beep_probe(struct of_device *op, const struct of_device_id *match)
269 {
270         struct sparcspkr_state *state;
271         struct grover_beep_info *info;
272         int err = -ENOMEM;
273
274         state = kzalloc(sizeof(*state), GFP_KERNEL);
275         if (!state)
276                 goto out_err;
277
278         state->name = "Sparc Grover Speaker";
279         state->event = grover_spkr_event;
280         spin_lock_init(&state->lock);
281
282         info = &state->u.grover;
283         info->freq_regs = of_ioremap(&op->resource[2], 0, 2, "grover beep freq");
284         if (!info->freq_regs)
285                 goto out_free;
286
287         info->enable_reg = of_ioremap(&op->resource[3], 0, 1, "grover beep enable");
288         if (!info->enable_reg)
289                 goto out_unmap_freq_regs;
290
291         dev_set_drvdata(&op->dev, state);
292
293         err = sparcspkr_probe(&op->dev);
294         if (err)
295                 goto out_clear_drvdata;
296
297         return 0;
298
299 out_clear_drvdata:
300         dev_set_drvdata(&op->dev, NULL);
301         of_iounmap(&op->resource[3], info->enable_reg, 1);
302
303 out_unmap_freq_regs:
304         of_iounmap(&op->resource[2], info->freq_regs, 2);
305 out_free:
306         kfree(state);
307 out_err:
308         return err;
309 }
310
311 static int grover_remove(struct of_device *op)
312 {
313         struct sparcspkr_state *state = dev_get_drvdata(&op->dev);
314         struct grover_beep_info *info = &state->u.grover;
315         struct input_dev *input_dev = state->input_dev;
316
317         /* turn off the speaker */
318         state->event(input_dev, EV_SND, SND_BELL, 0);
319
320         input_unregister_device(input_dev);
321
322         of_iounmap(&op->resource[3], info->enable_reg, 1);
323         of_iounmap(&op->resource[2], info->freq_regs, 2);
324
325         dev_set_drvdata(&op->dev, NULL);
326         kfree(state);
327
328         return 0;
329 }
330
331 static const struct of_device_id grover_beep_match[] = {
332         {
333                 .name = "beep",
334                 .compatible = "SUNW,smbus-beep",
335         },
336         {},
337 };
338
339 static struct of_platform_driver grover_beep_driver = {
340         .name           = "groverbeep",
341         .match_table    = grover_beep_match,
342         .probe          = grover_beep_probe,
343         .remove         = __devexit_p(grover_remove),
344         .shutdown       = sparcspkr_shutdown,
345 };
346
347 static int __init sparcspkr_init(void)
348 {
349         int err = of_register_driver(&bbc_beep_driver,
350                                      &of_platform_bus_type);
351
352         if (!err) {
353                 err = of_register_driver(&grover_beep_driver,
354                                          &of_platform_bus_type);
355                 if (err)
356                         of_unregister_driver(&bbc_beep_driver);
357         }
358
359         return err;
360 }
361
362 static void __exit sparcspkr_exit(void)
363 {
364         of_unregister_driver(&bbc_beep_driver);
365         of_unregister_driver(&grover_beep_driver);
366 }
367
368 module_init(sparcspkr_init);
369 module_exit(sparcspkr_exit);