sparcspkr.c

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