← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/input/misc/m68kspkr.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/input/misc/m68kspkr.c
 
1
/*
 
2
 *  m68k beeper driver for Linux
 
3
 *
 
4
 *  Copyright (c) 2002 Richard Zidlicky
 
5
 *  Copyright (c) 2002 Vojtech Pavlik
 
6
 *  Copyright (c) 1992 Orest Zborowski
 
7
 *
 
8
 */
 
9
 
 
10
/*
 
11
 * This program is free software; you can redistribute it and/or modify it
 
12
 * under the terms of the GNU General Public License version 2 as published by
 
13
 * the Free Software Foundation
 
14
 */
 
15
 
 
16
#include <linux/kernel.h>
 
17
#include <linux/module.h>
 
18
#include <linux/init.h>
 
19
#include <linux/input.h>
 
20
#include <linux/platform_device.h>
 
21
#include <asm/machdep.h>
 
22
#include <asm/io.h>
 
23
 
 
24
MODULE_AUTHOR("Richard Zidlicky <rz@linux-m68k.org>");
 
25
MODULE_DESCRIPTION("m68k beeper driver");
 
26
MODULE_LICENSE("GPL");
 
27
 
 
28
static struct platform_device *m68kspkr_platform_device;
 
29
 
 
30
static int m68kspkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
 
31
{
 
32
        unsigned int count = 0;
 
33
 
 
34
        if (type != EV_SND)
 
35
                return -1;
 
36
 
 
37
        switch (code) {
 
38
                case SND_BELL: if (value) value = 1000;
 
39
                case SND_TONE: break;
 
40
                default: return -1;
 
41
        }
 
42
 
 
43
        if (value > 20 && value < 32767)
 
44
                count = 1193182 / value;
 
45
 
 
46
        mach_beep(count, -1);
 
47
 
 
48
        return 0;
 
49
}
 
50
 
 
51
static int __devinit m68kspkr_probe(struct platform_device *dev)
 
52
{
 
53
        struct input_dev *input_dev;
 
54
        int err;
 
55
 
 
56
        input_dev = input_allocate_device();
 
57
        if (!input_dev)
 
58
                return -ENOMEM;
 
59
 
 
60
        input_dev->name = "m68k beeper";
 
61
        input_dev->phys = "m68k/generic";
 
62
        input_dev->id.bustype = BUS_HOST;
 
63
        input_dev->id.vendor  = 0x001f;
 
64
        input_dev->id.product = 0x0001;
 
65
        input_dev->id.version = 0x0100;
 
66
        input_dev->dev.parent = &dev->dev;
 
67
 
 
68
        input_dev->evbit[0] = BIT_MASK(EV_SND);
 
69
        input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
 
70
        input_dev->event = m68kspkr_event;
 
71
 
 
72
        err = input_register_device(input_dev);
 
73
        if (err) {
 
74
                input_free_device(input_dev);
 
75
                return err;
 
76
        }
 
77
 
 
78
        platform_set_drvdata(dev, input_dev);
 
79
 
 
80
        return 0;
 
81
}
 
82
 
 
83
static int __devexit m68kspkr_remove(struct platform_device *dev)
 
84
{
 
85
        struct input_dev *input_dev = platform_get_drvdata(dev);
 
86
 
 
87
        input_unregister_device(input_dev);
 
88
        platform_set_drvdata(dev, NULL);
 
89
        /* turn off the speaker */
 
90
        m68kspkr_event(NULL, EV_SND, SND_BELL, 0);
 
91
 
 
92
        return 0;
 
93
}
 
94
 
 
95
static void m68kspkr_shutdown(struct platform_device *dev)
 
96
{
 
97
        /* turn off the speaker */
 
98
        m68kspkr_event(NULL, EV_SND, SND_BELL, 0);
 
99
}
 
100
 
 
101
static struct platform_driver m68kspkr_platform_driver = {
 
102
        .driver         = {
 
103
                .name   = "m68kspkr",
 
104
                .owner  = THIS_MODULE,
 
105
        },
 
106
        .probe          = m68kspkr_probe,
 
107
        .remove         = __devexit_p(m68kspkr_remove),
 
108
        .shutdown       = m68kspkr_shutdown,
 
109
};
 
110
 
 
111
static int __init m68kspkr_init(void)
 
112
{
 
113
        int err;
 
114
 
 
115
        if (!mach_beep) {
 
116
                printk(KERN_INFO "m68kspkr: no lowlevel beep support\n");
 
117
                return -ENODEV;
 
118
        }
 
119
 
 
120
        err = platform_driver_register(&m68kspkr_platform_driver);
 
121
        if (err)
 
122
                return err;
 
123
 
 
124
        m68kspkr_platform_device = platform_device_alloc("m68kspkr", -1);
 
125
        if (!m68kspkr_platform_device) {
 
126
                err = -ENOMEM;
 
127
                goto err_unregister_driver;
 
128
        }
 
129
 
 
130
        err = platform_device_add(m68kspkr_platform_device);
 
131
        if (err)
 
132
                goto err_free_device;
 
133
 
 
134
        return 0;
 
135
 
 
136
 err_free_device:
 
137
        platform_device_put(m68kspkr_platform_device);
 
138
 err_unregister_driver:
 
139
        platform_driver_unregister(&m68kspkr_platform_driver);
 
140
 
 
141
        return err;
 
142
}
 
143
 
 
144
static void __exit m68kspkr_exit(void)
 
145
{
 
146
        platform_device_unregister(m68kspkr_platform_device);
 
147
        platform_driver_unregister(&m68kspkr_platform_driver);
 
148
}
 
149
 
 
150
module_init(m68kspkr_init);
 
151
module_exit(m68kspkr_exit);