Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 1 | /* |
| 2 | * PC-Speaker driver for Linux |
| 3 | * |
| 4 | * Copyright (C) 1997-2001 David Woodhouse |
| 5 | * Copyright (C) 2001-2008 Stas Sergeev |
| 6 | */ |
| 7 | |
| 8 | #include <linux/init.h> |
| 9 | #include <linux/moduleparam.h> |
| 10 | #include <linux/platform_device.h> |
| 11 | #include <sound/core.h> |
| 12 | #include <sound/initval.h> |
| 13 | #include <sound/pcm.h> |
Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 14 | #include <linux/input.h> |
Mariusz Kozlowski | 9ecaeda | 2008-03-18 09:03:03 +0100 | [diff] [blame] | 15 | #include <linux/delay.h> |
Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 16 | #include <asm/bitops.h> |
| 17 | #include "pcsp_input.h" |
| 18 | #include "pcsp.h" |
| 19 | |
| 20 | MODULE_AUTHOR("Stas Sergeev <stsp@users.sourceforge.net>"); |
| 21 | MODULE_DESCRIPTION("PC-Speaker driver"); |
| 22 | MODULE_LICENSE("GPL"); |
| 23 | MODULE_SUPPORTED_DEVICE("{{PC-Speaker, pcsp}}"); |
| 24 | MODULE_ALIAS("platform:pcspkr"); |
| 25 | |
| 26 | static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */ |
| 27 | static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */ |
| 28 | static int enable = SNDRV_DEFAULT_ENABLE1; /* Enable this card */ |
| 29 | |
| 30 | module_param(index, int, 0444); |
| 31 | MODULE_PARM_DESC(index, "Index value for pcsp soundcard."); |
| 32 | module_param(id, charp, 0444); |
| 33 | MODULE_PARM_DESC(id, "ID string for pcsp soundcard."); |
| 34 | module_param(enable, bool, 0444); |
Stas Sergeev | 5233731 | 2008-03-06 11:01:16 +0100 | [diff] [blame] | 35 | MODULE_PARM_DESC(enable, "Enable PC-Speaker sound."); |
Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 36 | |
| 37 | struct snd_pcsp pcsp_chip; |
| 38 | |
| 39 | static int __devinit snd_pcsp_create(struct snd_card *card) |
| 40 | { |
| 41 | static struct snd_device_ops ops = { }; |
| 42 | struct timespec tp; |
| 43 | int err; |
| 44 | int div, min_div, order; |
| 45 | |
| 46 | hrtimer_get_res(CLOCK_MONOTONIC, &tp); |
| 47 | if (tp.tv_sec || tp.tv_nsec > PCSP_MAX_PERIOD_NS) { |
| 48 | printk(KERN_ERR "PCSP: Timer resolution is not sufficient " |
| 49 | "(%linS)\n", tp.tv_nsec); |
| 50 | printk(KERN_ERR "PCSP: Make sure you have HPET and ACPI " |
| 51 | "enabled.\n"); |
| 52 | return -EIO; |
| 53 | } |
| 54 | |
| 55 | if (loops_per_jiffy >= PCSP_MIN_LPJ && tp.tv_nsec <= PCSP_MIN_PERIOD_NS) |
| 56 | min_div = MIN_DIV; |
| 57 | else |
| 58 | min_div = MAX_DIV; |
| 59 | #if PCSP_DEBUG |
| 60 | printk("PCSP: lpj=%li, min_div=%i, res=%li\n", |
| 61 | loops_per_jiffy, min_div, tp.tv_nsec); |
| 62 | #endif |
| 63 | |
| 64 | div = MAX_DIV / min_div; |
| 65 | order = fls(div) - 1; |
| 66 | |
| 67 | pcsp_chip.max_treble = min(order, PCSP_MAX_TREBLE); |
| 68 | pcsp_chip.treble = min(pcsp_chip.max_treble, PCSP_DEFAULT_TREBLE); |
| 69 | pcsp_chip.playback_ptr = 0; |
| 70 | pcsp_chip.period_ptr = 0; |
| 71 | atomic_set(&pcsp_chip.timer_active, 0); |
| 72 | pcsp_chip.enable = 1; |
| 73 | pcsp_chip.pcspkr = 1; |
| 74 | |
| 75 | spin_lock_init(&pcsp_chip.substream_lock); |
| 76 | |
| 77 | pcsp_chip.card = card; |
| 78 | pcsp_chip.port = 0x61; |
| 79 | pcsp_chip.irq = -1; |
| 80 | pcsp_chip.dma = -1; |
| 81 | |
| 82 | /* Register device */ |
| 83 | err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, &pcsp_chip, &ops); |
| 84 | if (err < 0) |
| 85 | return err; |
| 86 | |
| 87 | return 0; |
| 88 | } |
| 89 | |
| 90 | static int __devinit snd_card_pcsp_probe(int devnum, struct device *dev) |
| 91 | { |
| 92 | struct snd_card *card; |
| 93 | int err; |
| 94 | |
| 95 | if (devnum != 0) |
| 96 | return -EINVAL; |
| 97 | |
| 98 | hrtimer_init(&pcsp_chip.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); |
Takashi Iwai | 8a75f4f | 2008-11-14 13:58:43 +0100 | [diff] [blame] | 99 | pcsp_chip.timer.cb_mode = HRTIMER_CB_IRQSAFE_UNLOCKED; |
Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 100 | pcsp_chip.timer.function = pcsp_do_timer; |
| 101 | |
| 102 | card = snd_card_new(index, id, THIS_MODULE, 0); |
| 103 | if (!card) |
| 104 | return -ENOMEM; |
| 105 | |
| 106 | err = snd_pcsp_create(card); |
| 107 | if (err < 0) { |
| 108 | snd_card_free(card); |
| 109 | return err; |
| 110 | } |
| 111 | err = snd_pcsp_new_pcm(&pcsp_chip); |
| 112 | if (err < 0) { |
| 113 | snd_card_free(card); |
| 114 | return err; |
| 115 | } |
| 116 | err = snd_pcsp_new_mixer(&pcsp_chip); |
| 117 | if (err < 0) { |
| 118 | snd_card_free(card); |
| 119 | return err; |
| 120 | } |
| 121 | |
| 122 | snd_card_set_dev(pcsp_chip.card, dev); |
| 123 | |
| 124 | strcpy(card->driver, "PC-Speaker"); |
| 125 | strcpy(card->shortname, "pcsp"); |
| 126 | sprintf(card->longname, "Internal PC-Speaker at port 0x%x", |
| 127 | pcsp_chip.port); |
| 128 | |
| 129 | err = snd_card_register(card); |
| 130 | if (err < 0) { |
| 131 | snd_card_free(card); |
| 132 | return err; |
| 133 | } |
| 134 | |
| 135 | return 0; |
| 136 | } |
| 137 | |
| 138 | static int __devinit alsa_card_pcsp_init(struct device *dev) |
| 139 | { |
Stas Sergeev | 5233731 | 2008-03-06 11:01:16 +0100 | [diff] [blame] | 140 | int err; |
| 141 | |
| 142 | err = snd_card_pcsp_probe(0, dev); |
| 143 | if (err) { |
| 144 | printk(KERN_ERR "PC-Speaker initialization failed.\n"); |
| 145 | return err; |
| 146 | } |
Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 147 | |
| 148 | #ifdef CONFIG_DEBUG_PAGEALLOC |
| 149 | /* Well, CONFIG_DEBUG_PAGEALLOC makes the sound horrible. Lets alert */ |
Stas Sergeev | efd89d9 | 2008-04-23 17:16:38 +0200 | [diff] [blame] | 150 | printk(KERN_WARNING "PCSP: CONFIG_DEBUG_PAGEALLOC is enabled, " |
| 151 | "which may make the sound noisy.\n"); |
Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 152 | #endif |
| 153 | |
Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 154 | return 0; |
| 155 | } |
| 156 | |
| 157 | static void __devexit alsa_card_pcsp_exit(struct snd_pcsp *chip) |
| 158 | { |
| 159 | snd_card_free(chip->card); |
| 160 | } |
| 161 | |
| 162 | static int __devinit pcsp_probe(struct platform_device *dev) |
| 163 | { |
| 164 | int err; |
Stas Sergeev | 5233731 | 2008-03-06 11:01:16 +0100 | [diff] [blame] | 165 | |
Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 166 | err = pcspkr_input_init(&pcsp_chip.input_dev, &dev->dev); |
| 167 | if (err < 0) |
| 168 | return err; |
| 169 | |
| 170 | err = alsa_card_pcsp_init(&dev->dev); |
| 171 | if (err < 0) { |
| 172 | pcspkr_input_remove(pcsp_chip.input_dev); |
| 173 | return err; |
| 174 | } |
| 175 | |
| 176 | platform_set_drvdata(dev, &pcsp_chip); |
| 177 | return 0; |
| 178 | } |
| 179 | |
| 180 | static int __devexit pcsp_remove(struct platform_device *dev) |
| 181 | { |
| 182 | struct snd_pcsp *chip = platform_get_drvdata(dev); |
| 183 | alsa_card_pcsp_exit(chip); |
| 184 | pcspkr_input_remove(chip->input_dev); |
| 185 | platform_set_drvdata(dev, NULL); |
| 186 | return 0; |
| 187 | } |
| 188 | |
| 189 | static void pcsp_stop_beep(struct snd_pcsp *chip) |
| 190 | { |
Takashi Iwai | 96c7d47 | 2008-08-11 10:18:39 +0200 | [diff] [blame] | 191 | pcsp_sync_stop(chip); |
| 192 | pcspkr_stop_sound(); |
Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 193 | } |
| 194 | |
Johann Felix Soden | 983e097 | 2008-05-02 09:54:31 +0200 | [diff] [blame] | 195 | #ifdef CONFIG_PM |
Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 196 | static int pcsp_suspend(struct platform_device *dev, pm_message_t state) |
| 197 | { |
| 198 | struct snd_pcsp *chip = platform_get_drvdata(dev); |
| 199 | pcsp_stop_beep(chip); |
| 200 | snd_pcm_suspend_all(chip->pcm); |
| 201 | return 0; |
| 202 | } |
Johann Felix Soden | 983e097 | 2008-05-02 09:54:31 +0200 | [diff] [blame] | 203 | #else |
| 204 | #define pcsp_suspend NULL |
| 205 | #endif /* CONFIG_PM */ |
Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 206 | |
| 207 | static void pcsp_shutdown(struct platform_device *dev) |
| 208 | { |
| 209 | struct snd_pcsp *chip = platform_get_drvdata(dev); |
| 210 | pcsp_stop_beep(chip); |
| 211 | } |
| 212 | |
| 213 | static struct platform_driver pcsp_platform_driver = { |
| 214 | .driver = { |
| 215 | .name = "pcspkr", |
| 216 | .owner = THIS_MODULE, |
| 217 | }, |
| 218 | .probe = pcsp_probe, |
| 219 | .remove = __devexit_p(pcsp_remove), |
| 220 | .suspend = pcsp_suspend, |
| 221 | .shutdown = pcsp_shutdown, |
| 222 | }; |
| 223 | |
| 224 | static int __init pcsp_init(void) |
| 225 | { |
Stas Sergeev | 5233731 | 2008-03-06 11:01:16 +0100 | [diff] [blame] | 226 | if (!enable) |
| 227 | return -ENODEV; |
Stas Sergeev | 9ab4d07 | 2008-03-03 10:53:54 +0100 | [diff] [blame] | 228 | return platform_driver_register(&pcsp_platform_driver); |
| 229 | } |
| 230 | |
| 231 | static void __exit pcsp_exit(void) |
| 232 | { |
| 233 | platform_driver_unregister(&pcsp_platform_driver); |
| 234 | } |
| 235 | |
| 236 | module_init(pcsp_init); |
| 237 | module_exit(pcsp_exit); |