cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

pcspkr.c (2844B)

      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 *  PC Speaker beeper driver for Linux
      4 *
      5 *  Copyright (c) 2002 Vojtech Pavlik
      6 *  Copyright (c) 1992 Orest Zborowski
      7 */
      8
      9
     10#include <linux/kernel.h>
     11#include <linux/module.h>
     12#include <linux/i8253.h>
     13#include <linux/input.h>
     14#include <linux/platform_device.h>
     15#include <linux/timex.h>
     16#include <linux/io.h>
     17
     18MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
     19MODULE_DESCRIPTION("PC Speaker beeper driver");
     20MODULE_LICENSE("GPL");
     21MODULE_ALIAS("platform:pcspkr");
     22
     23static int pcspkr_event(struct input_dev *dev, unsigned int type,
     24			unsigned int code, int value)
     25{
     26	unsigned int count = 0;
     27	unsigned long flags;
     28
     29	if (type != EV_SND)
     30		return -EINVAL;
     31
     32	switch (code) {
     33	case SND_BELL:
     34		if (value)
     35			value = 1000;
     36		break;
     37	case SND_TONE:
     38		break;
     39	default:
     40		return -EINVAL;
     41	}
     42
     43	if (value > 20 && value < 32767)
     44		count = PIT_TICK_RATE / value;
     45
     46	raw_spin_lock_irqsave(&i8253_lock, flags);
     47
     48	if (count) {
     49		/* set command for counter 2, 2 byte write */
     50		outb_p(0xB6, 0x43);
     51		/* select desired HZ */
     52		outb_p(count & 0xff, 0x42);
     53		outb((count >> 8) & 0xff, 0x42);
     54		/* enable counter 2 */
     55		outb_p(inb_p(0x61) | 3, 0x61);
     56	} else {
     57		/* disable counter 2 */
     58		outb(inb_p(0x61) & 0xFC, 0x61);
     59	}
     60
     61	raw_spin_unlock_irqrestore(&i8253_lock, flags);
     62
     63	return 0;
     64}
     65
     66static int pcspkr_probe(struct platform_device *dev)
     67{
     68	struct input_dev *pcspkr_dev;
     69	int err;
     70
     71	pcspkr_dev = input_allocate_device();
     72	if (!pcspkr_dev)
     73		return -ENOMEM;
     74
     75	pcspkr_dev->name = "PC Speaker";
     76	pcspkr_dev->phys = "isa0061/input0";
     77	pcspkr_dev->id.bustype = BUS_ISA;
     78	pcspkr_dev->id.vendor = 0x001f;
     79	pcspkr_dev->id.product = 0x0001;
     80	pcspkr_dev->id.version = 0x0100;
     81	pcspkr_dev->dev.parent = &dev->dev;
     82
     83	pcspkr_dev->evbit[0] = BIT_MASK(EV_SND);
     84	pcspkr_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
     85	pcspkr_dev->event = pcspkr_event;
     86
     87	err = input_register_device(pcspkr_dev);
     88	if (err) {
     89		input_free_device(pcspkr_dev);
     90		return err;
     91	}
     92
     93	platform_set_drvdata(dev, pcspkr_dev);
     94
     95	return 0;
     96}
     97
     98static int pcspkr_remove(struct platform_device *dev)
     99{
    100	struct input_dev *pcspkr_dev = platform_get_drvdata(dev);
    101
    102	input_unregister_device(pcspkr_dev);
    103	/* turn off the speaker */
    104	pcspkr_event(NULL, EV_SND, SND_BELL, 0);
    105
    106	return 0;
    107}
    108
    109static int pcspkr_suspend(struct device *dev)
    110{
    111	pcspkr_event(NULL, EV_SND, SND_BELL, 0);
    112
    113	return 0;
    114}
    115
    116static void pcspkr_shutdown(struct platform_device *dev)
    117{
    118	/* turn off the speaker */
    119	pcspkr_event(NULL, EV_SND, SND_BELL, 0);
    120}
    121
    122static const struct dev_pm_ops pcspkr_pm_ops = {
    123	.suspend = pcspkr_suspend,
    124};
    125
    126static struct platform_driver pcspkr_platform_driver = {
    127	.driver		= {
    128		.name	= "pcspkr",
    129		.pm	= &pcspkr_pm_ops,
    130	},
    131	.probe		= pcspkr_probe,
    132	.remove		= pcspkr_remove,
    133	.shutdown	= pcspkr_shutdown,
    134};
    135module_platform_driver(pcspkr_platform_driver);
    136