2 * Driver for PC-speaker like devices found on various Sparc systems.
4 * Copyright (c) 2002 Vojtech Pavlik
5 * Copyright (c) 2002, 2006, 2008 David S. Miller (davem@davemloft.net)
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 #include <linux/slab.h>
16 MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");
17 MODULE_DESCRIPTION("Sparc Speaker beeper driver");
18 MODULE_LICENSE("GPL");
20 struct grover_beep_info
{
21 void __iomem
*freq_regs
;
22 void __iomem
*enable_reg
;
25 struct bbc_beep_info
{
30 struct sparcspkr_state
{
32 int (*event
)(struct input_dev
*dev
, unsigned int type
, unsigned int code
, int value
);
34 struct input_dev
*input_dev
;
36 struct grover_beep_info grover
;
37 struct bbc_beep_info bbc
;
41 static u32
bbc_count_to_reg(struct bbc_beep_info
*info
, unsigned int count
)
43 u32 val
, clock_freq
= info
->clock_freq
;
49 if (count
<= clock_freq
>> 20)
52 if (count
>= clock_freq
>> 12)
56 for (i
= 19; i
>= 11; i
--) {
58 if (count
<= clock_freq
>> i
)
65 static int bbc_spkr_event(struct input_dev
*dev
, unsigned int type
, unsigned int code
, int value
)
67 struct sparcspkr_state
*state
= dev_get_drvdata(dev
->dev
.parent
);
68 struct bbc_beep_info
*info
= &state
->u
.bbc
;
69 unsigned int count
= 0;
76 case SND_BELL
: if (value
) value
= 1000;
81 if (value
> 20 && value
< 32767)
82 count
= 1193182 / value
;
84 count
= bbc_count_to_reg(info
, count
);
86 spin_lock_irqsave(&state
->lock
, flags
);
89 outb(0x01, info
->regs
+ 0);
90 outb(0x00, info
->regs
+ 2);
91 outb((count
>> 16) & 0xff, info
->regs
+ 3);
92 outb((count
>> 8) & 0xff, info
->regs
+ 4);
93 outb(0x00, info
->regs
+ 5);
95 outb(0x00, info
->regs
+ 0);
98 spin_unlock_irqrestore(&state
->lock
, flags
);
103 static int grover_spkr_event(struct input_dev
*dev
, unsigned int type
, unsigned int code
, int value
)
105 struct sparcspkr_state
*state
= dev_get_drvdata(dev
->dev
.parent
);
106 struct grover_beep_info
*info
= &state
->u
.grover
;
107 unsigned int count
= 0;
114 case SND_BELL
: if (value
) value
= 1000;
115 case SND_TONE
: break;
119 if (value
> 20 && value
< 32767)
120 count
= 1193182 / value
;
122 spin_lock_irqsave(&state
->lock
, flags
);
125 /* enable counter 2 */
126 outb(inb(info
->enable_reg
) | 3, info
->enable_reg
);
127 /* set command for counter 2, 2 byte write */
128 outb(0xB6, info
->freq_regs
+ 1);
129 /* select desired HZ */
130 outb(count
& 0xff, info
->freq_regs
+ 0);
131 outb((count
>> 8) & 0xff, info
->freq_regs
+ 0);
133 /* disable counter 2 */
134 outb(inb_p(info
->enable_reg
) & 0xFC, info
->enable_reg
);
137 spin_unlock_irqrestore(&state
->lock
, flags
);
142 static int __devinit
sparcspkr_probe(struct device
*dev
)
144 struct sparcspkr_state
*state
= dev_get_drvdata(dev
);
145 struct input_dev
*input_dev
;
148 input_dev
= input_allocate_device();
152 input_dev
->name
= state
->name
;
153 input_dev
->phys
= "sparc/input0";
154 input_dev
->id
.bustype
= BUS_ISA
;
155 input_dev
->id
.vendor
= 0x001f;
156 input_dev
->id
.product
= 0x0001;
157 input_dev
->id
.version
= 0x0100;
158 input_dev
->dev
.parent
= dev
;
160 input_dev
->evbit
[0] = BIT_MASK(EV_SND
);
161 input_dev
->sndbit
[0] = BIT_MASK(SND_BELL
) | BIT_MASK(SND_TONE
);
163 input_dev
->event
= state
->event
;
165 error
= input_register_device(input_dev
);
167 input_free_device(input_dev
);
171 state
->input_dev
= input_dev
;
176 static int sparcspkr_shutdown(struct of_device
*dev
)
178 struct sparcspkr_state
*state
= dev_get_drvdata(&dev
->dev
);
179 struct input_dev
*input_dev
= state
->input_dev
;
181 /* turn off the speaker */
182 state
->event(input_dev
, EV_SND
, SND_BELL
, 0);
187 static int __devinit
bbc_beep_probe(struct of_device
*op
, const struct of_device_id
*match
)
189 struct sparcspkr_state
*state
;
190 struct bbc_beep_info
*info
;
191 struct device_node
*dp
;
194 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
198 state
->name
= "Sparc BBC Speaker";
199 state
->event
= bbc_spkr_event
;
200 spin_lock_init(&state
->lock
);
202 dp
= of_find_node_by_path("/");
207 info
= &state
->u
.bbc
;
208 info
->clock_freq
= of_getintprop_default(dp
, "clock-frequency", 0);
209 if (!info
->clock_freq
)
212 info
->regs
= of_ioremap(&op
->resource
[0], 0, 6, "bbc beep");
216 dev_set_drvdata(&op
->dev
, state
);
218 err
= sparcspkr_probe(&op
->dev
);
220 goto out_clear_drvdata
;
225 dev_set_drvdata(&op
->dev
, NULL
);
226 of_iounmap(&op
->resource
[0], info
->regs
, 6);
234 static int __devexit
bbc_remove(struct of_device
*op
)
236 struct sparcspkr_state
*state
= dev_get_drvdata(&op
->dev
);
237 struct input_dev
*input_dev
= state
->input_dev
;
238 struct bbc_beep_info
*info
= &state
->u
.bbc
;
240 /* turn off the speaker */
241 state
->event(input_dev
, EV_SND
, SND_BELL
, 0);
243 input_unregister_device(input_dev
);
245 of_iounmap(&op
->resource
[0], info
->regs
, 6);
247 dev_set_drvdata(&op
->dev
, NULL
);
253 static const struct of_device_id bbc_beep_match
[] = {
256 .compatible
= "SUNW,bbc-beep",
261 static struct of_platform_driver bbc_beep_driver
= {
263 .match_table
= bbc_beep_match
,
264 .probe
= bbc_beep_probe
,
265 .remove
= __devexit_p(bbc_remove
),
266 .shutdown
= sparcspkr_shutdown
,
269 static int __devinit
grover_beep_probe(struct of_device
*op
, const struct of_device_id
*match
)
271 struct sparcspkr_state
*state
;
272 struct grover_beep_info
*info
;
275 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
279 state
->name
= "Sparc Grover Speaker";
280 state
->event
= grover_spkr_event
;
281 spin_lock_init(&state
->lock
);
283 info
= &state
->u
.grover
;
284 info
->freq_regs
= of_ioremap(&op
->resource
[2], 0, 2, "grover beep freq");
285 if (!info
->freq_regs
)
288 info
->enable_reg
= of_ioremap(&op
->resource
[3], 0, 1, "grover beep enable");
289 if (!info
->enable_reg
)
290 goto out_unmap_freq_regs
;
292 dev_set_drvdata(&op
->dev
, state
);
294 err
= sparcspkr_probe(&op
->dev
);
296 goto out_clear_drvdata
;
301 dev_set_drvdata(&op
->dev
, NULL
);
302 of_iounmap(&op
->resource
[3], info
->enable_reg
, 1);
305 of_iounmap(&op
->resource
[2], info
->freq_regs
, 2);
312 static int __devexit
grover_remove(struct of_device
*op
)
314 struct sparcspkr_state
*state
= dev_get_drvdata(&op
->dev
);
315 struct grover_beep_info
*info
= &state
->u
.grover
;
316 struct input_dev
*input_dev
= state
->input_dev
;
318 /* turn off the speaker */
319 state
->event(input_dev
, EV_SND
, SND_BELL
, 0);
321 input_unregister_device(input_dev
);
323 of_iounmap(&op
->resource
[3], info
->enable_reg
, 1);
324 of_iounmap(&op
->resource
[2], info
->freq_regs
, 2);
326 dev_set_drvdata(&op
->dev
, NULL
);
332 static const struct of_device_id grover_beep_match
[] = {
335 .compatible
= "SUNW,smbus-beep",
340 static struct of_platform_driver grover_beep_driver
= {
341 .name
= "groverbeep",
342 .match_table
= grover_beep_match
,
343 .probe
= grover_beep_probe
,
344 .remove
= __devexit_p(grover_remove
),
345 .shutdown
= sparcspkr_shutdown
,
348 static int __init
sparcspkr_init(void)
350 int err
= of_register_driver(&bbc_beep_driver
,
351 &of_platform_bus_type
);
354 err
= of_register_driver(&grover_beep_driver
,
355 &of_platform_bus_type
);
357 of_unregister_driver(&bbc_beep_driver
);
363 static void __exit
sparcspkr_exit(void)
365 of_unregister_driver(&bbc_beep_driver
);
366 of_unregister_driver(&grover_beep_driver
);
369 module_init(sparcspkr_init
);
370 module_exit(sparcspkr_exit
);