Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9c1a5077 authored by David S. Miller's avatar David S. Miller
Browse files

input: Rewrite sparcspkr device probing. 



Remove all dependencies on EBUS and ISA bus layers, which we'd like to
remove as they are superfluous.

While we're here, add support for proper frequency changing on BBC
beep devices.  Unlike the comments that were here, this device can
in fact use a programmable frequency.

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent dc8ca2a1

drivers/input/misc/sparcspkr.c

+184 −78
Original line number Diff line number Diff line
@@ -2,33 +2,69 @@ 
 *  Driver for PC-speaker like devices found on various Sparc systems.

 *

 *  Copyright (c) 2002 Vojtech Pavlik

 *  Copyright (c) 2002, 2006 David S. Miller (davem@davemloft.net)

 *  Copyright (c) 2002, 2006, 2008 David S. Miller (davem@davemloft.net)

 */

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/init.h>

#include <linux/input.h>

#include <linux/platform_device.h>

#include <linux/of_device.h>



#include <asm/io.h>

#include <asm/ebus.h>

#include <asm/isa.h>



MODULE_AUTHOR("David S. Miller <davem@davemloft.net>");

MODULE_DESCRIPTION("Sparc Speaker beeper driver");

MODULE_LICENSE("GPL");



struct grover_beep_info {

	void __iomem	*freq_regs;

	void __iomem	*enable_reg;

};



struct bbc_beep_info {

	u32		clock_freq;

	void __iomem	*regs;

};



struct sparcspkr_state {

	const char		*name;

	unsigned long		iobase;

	int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);

	spinlock_t		lock;

	struct input_dev	*input_dev;

	union {

		struct grover_beep_info grover;

		struct bbc_beep_info bbc;

	} u;

};



static int ebus_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)

static u32 bbc_count_to_reg(struct bbc_beep_info *info, unsigned int count)

{

	u32 val, clock_freq = info->clock_freq;

	int i;



	if (!count)

		return 0;



	if (count <= clock_freq >> 20)

		return 1 << 18;



	if (count >= clock_freq >> 12)

		return 1 << 10;



	val = 1 << 18;

	for (i = 19; i >= 11; i--) {

		val >>= 1;

		if (count <= clock_freq >> i)

			break;

	}



	return val;

}



static int bbc_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)

{

	struct sparcspkr_state *state = dev_get_drvdata(dev->dev.parent);

	struct bbc_beep_info *info = &state->u.bbc;

	unsigned int count = 0;

	unsigned long flags;
@@ -44,24 +80,29 @@ static int ebus_spkr_event(struct input_dev *dev, unsigned int type, unsigned in 
	if (value > 20 && value < 32767)

		count = 1193182 / value;



	count = bbc_count_to_reg(info, count);



	spin_lock_irqsave(&state->lock, flags);



	/* EBUS speaker only has on/off state, the frequency does not

	 * appear to be programmable.

	 */

	if (state->iobase & 0x2UL)

		outb(!!count, state->iobase);

	else

		outl(!!count, state->iobase);

	if (count) {

		outb(0x01,                 info->regs + 0);

		outb(0x00,                 info->regs + 2);

		outb((count >> 16) & 0xff, info->regs + 3);

		outb((count >>  8) & 0xff, info->regs + 4);

		outb(0x00,                 info->regs + 5);

	} else {

		outb(0x00,                 info->regs + 0);

	}



	spin_unlock_irqrestore(&state->lock, flags);



	return 0;

}



static int isa_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)

static int grover_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)

{

	struct sparcspkr_state *state = dev_get_drvdata(dev->dev.parent);

	struct grover_beep_info *info = &state->u.grover;

	unsigned int count = 0;

	unsigned long flags;
@@ -81,15 +122,15 @@ static int isa_spkr_event(struct input_dev *dev, unsigned int type, unsigned int 


	if (count) {

		/* enable counter 2 */

		outb(inb(state->iobase + 0x61) | 3, state->iobase + 0x61);

		outb(inb(info->enable_reg) | 3, info->enable_reg);

		/* set command for counter 2, 2 byte write */

		outb(0xB6, state->iobase + 0x43);

		outb(0xB6, info->freq_regs + 1);

		/* select desired HZ */

		outb(count & 0xff, state->iobase + 0x42);

		outb((count >> 8) & 0xff, state->iobase + 0x42);

		outb(count & 0xff, info->freq_regs + 0);

		outb((count >> 8) & 0xff, info->freq_regs + 0);

	} else {

		/* disable counter 2 */

		outb(inb_p(state->iobase + 0x61) & 0xFC, state->iobase + 0x61);

		outb(inb_p(info->enable_reg) & 0xFC, info->enable_reg);

	}



	spin_unlock_irqrestore(&state->lock, flags);
@@ -131,22 +172,6 @@ static int __devinit sparcspkr_probe(struct device *dev) 
	return 0;

}



static int __devexit sparcspkr_remove(struct of_device *dev)

{

	struct sparcspkr_state *state = dev_get_drvdata(&dev->dev);

	struct input_dev *input_dev = state->input_dev;



	/* turn off the speaker */

	state->event(input_dev, EV_SND, SND_BELL, 0);



	input_unregister_device(input_dev);



	dev_set_drvdata(&dev->dev, NULL);

	kfree(state);



	return 0;

}



static int sparcspkr_shutdown(struct of_device *dev)

{

	struct sparcspkr_state *state = dev_get_drvdata(&dev->dev);
@@ -158,96 +183,177 @@ static int sparcspkr_shutdown(struct of_device *dev) 
	return 0;

}



static int __devinit ebus_beep_probe(struct of_device *dev, const struct of_device_id *match)

static int __devinit bbc_beep_probe(struct of_device *op, const struct of_device_id *match)

{

	struct linux_ebus_device *edev = to_ebus_device(&dev->dev);

	struct sparcspkr_state *state;

	int err;

	struct bbc_beep_info *info;

	struct device_node *dp;

	int err = -ENOMEM;



	state = kzalloc(sizeof(*state), GFP_KERNEL);

	if (!state)

		return -ENOMEM;

		goto out_err;



	state->name = "Sparc EBUS Speaker";

	state->iobase = edev->resource[0].start;

	state->event = ebus_spkr_event;

	state->name = "Sparc BBC Speaker";

	state->event = bbc_spkr_event;

	spin_lock_init(&state->lock);



	dev_set_drvdata(&dev->dev, state);

	dp = of_find_node_by_path("/");

	err = -ENODEV;

	if (!dp)

		goto out_free;



	info = &state->u.bbc;

	info->clock_freq = of_getintprop_default(dp, "clock-frequency", 0);

	if (!info->clock_freq)

		goto out_free;



	info->regs = of_ioremap(&op->resource[0], 0, 6, "bbc beep");

	if (!info->regs)

		goto out_free;



	dev_set_drvdata(&op->dev, state);



	err = sparcspkr_probe(&op->dev);

	if (err)

		goto out_clear_drvdata;



	err = sparcspkr_probe(&dev->dev);

	if (err) {

		dev_set_drvdata(&dev->dev, NULL);

	return 0;



out_clear_drvdata:

	dev_set_drvdata(&op->dev, NULL);

	of_iounmap(&op->resource[0], info->regs, 6);



out_free:

	kfree(state);

out_err:

	return err;

}



static int bbc_remove(struct of_device *op)

{

	struct sparcspkr_state *state = dev_get_drvdata(&op->dev);

	struct input_dev *input_dev = state->input_dev;

	struct bbc_beep_info *info = &state->u.bbc;



	/* turn off the speaker */

	state->event(input_dev, EV_SND, SND_BELL, 0);



	input_unregister_device(input_dev);



	of_iounmap(&op->resource[0], info->regs, 6);



	dev_set_drvdata(&op->dev, NULL);

	kfree(state);



	return 0;

}



static struct of_device_id ebus_beep_match[] = {

static struct of_device_id bbc_beep_match[] = {

	{

		.name = "beep",

		.compatible = "SUNW,bbc-beep",

	},

	{},

};



static struct of_platform_driver ebus_beep_driver = {

	.name		= "beep",

	.match_table	= ebus_beep_match,

	.probe		= ebus_beep_probe,

	.remove		= __devexit_p(sparcspkr_remove),

static struct of_platform_driver bbc_beep_driver = {

	.name		= "bbcbeep",

	.match_table	= bbc_beep_match,

	.probe		= bbc_beep_probe,

	.remove		= __devexit_p(bbc_remove),

	.shutdown	= sparcspkr_shutdown,

};



static int __devinit isa_beep_probe(struct of_device *dev, const struct of_device_id *match)

static int __devinit grover_beep_probe(struct of_device *op, const struct of_device_id *match)

{

	struct sparc_isa_device *idev = to_isa_device(&dev->dev);

	struct sparcspkr_state *state;

	int err;

	struct grover_beep_info *info;

	int err = -ENOMEM;



	state = kzalloc(sizeof(*state), GFP_KERNEL);

	if (!state)

		return -ENOMEM;

		goto out_err;



	state->name = "Sparc ISA Speaker";

	state->iobase = idev->resource.start;

	state->event = isa_spkr_event;

	state->name = "Sparc Grover Speaker";

	state->event = grover_spkr_event;

	spin_lock_init(&state->lock);



	dev_set_drvdata(&dev->dev, state);

	info = &state->u.grover;

	info->freq_regs = of_ioremap(&op->resource[2], 0, 2, "grover beep freq");

	if (!info->freq_regs)

		goto out_free;



	info->enable_reg = of_ioremap(&op->resource[3], 0, 1, "grover beep enable");

	if (!info->enable_reg)

		goto out_unmap_freq_regs;



	dev_set_drvdata(&op->dev, state);



	err = sparcspkr_probe(&dev->dev);

	if (err) {

		dev_set_drvdata(&dev->dev, NULL);

	err = sparcspkr_probe(&op->dev);

	if (err)

		goto out_clear_drvdata;



	return 0;



out_clear_drvdata:

	dev_set_drvdata(&op->dev, NULL);

	of_iounmap(&op->resource[3], info->enable_reg, 1);



out_unmap_freq_regs:

	of_iounmap(&op->resource[2], info->freq_regs, 2);

out_free:

	kfree(state);

out_err:

	return err;

}



static int grover_remove(struct of_device *op)

{

	struct sparcspkr_state *state = dev_get_drvdata(&op->dev);

	struct grover_beep_info *info = &state->u.grover;

	struct input_dev *input_dev = state->input_dev;



	/* turn off the speaker */

	state->event(input_dev, EV_SND, SND_BELL, 0);



	input_unregister_device(input_dev);



	of_iounmap(&op->resource[3], info->enable_reg, 1);

	of_iounmap(&op->resource[2], info->freq_regs, 2);



	dev_set_drvdata(&op->dev, NULL);

	kfree(state);



	return 0;

}



static struct of_device_id isa_beep_match[] = {

static struct of_device_id grover_beep_match[] = {

	{

		.name = "dma",

		.name = "beep",

		.compatible = "SUNW,smbus-beep",

	},

	{},

};



static struct of_platform_driver isa_beep_driver = {

	.name		= "beep",

	.match_table	= isa_beep_match,

	.probe		= isa_beep_probe,

	.remove		= __devexit_p(sparcspkr_remove),

static struct of_platform_driver grover_beep_driver = {

	.name		= "groverbeep",

	.match_table	= grover_beep_match,

	.probe		= grover_beep_probe,

	.remove		= __devexit_p(grover_remove),

	.shutdown	= sparcspkr_shutdown,

};



static int __init sparcspkr_init(void)

{

	int err = of_register_driver(&ebus_beep_driver, &ebus_bus_type);

	int err = of_register_driver(&bbc_beep_driver,

				     &of_platform_bus_type);



	if (!err) {

		err = of_register_driver(&isa_beep_driver, &isa_bus_type);

		err = of_register_driver(&grover_beep_driver,

					 &of_platform_bus_type);

		if (err)

			of_unregister_driver(&ebus_beep_driver);

			of_unregister_driver(&bbc_beep_driver);

	}



	return err;
@@ -255,8 +361,8 @@ static int __init sparcspkr_init(void) 


static void __exit sparcspkr_exit(void)

{

	of_unregister_driver(&ebus_beep_driver);

	of_unregister_driver(&isa_beep_driver);

	of_unregister_driver(&bbc_beep_driver);

	of_unregister_driver(&grover_beep_driver);

}



module_init(sparcspkr_init);