media/radio/radio-sf16fmr2.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* SF16-FMR2 and SF16-FMD2 radio driver for Linux
0003  * Copyright (c) 2011 Ondrej Zary
0004  *
0005  * Original driver was (c) 2000-2002 Ziglio Frediano, freddy77@angelfire.com
0006  * but almost nothing remained here after conversion to generic TEA575x
0007  * implementation
0008  */
0009
0010 #include <linux/delay.h>
0011 #include <linux/module.h>   /* Modules          */
0012 #include <linux/init.h>     /* Initdata         */
0013 #include <linux/slab.h>
0014 #include <linux/ioport.h>   /* request_region       */
0015 #include <linux/io.h>       /* outb, outb_p         */
0016 #include <linux/isa.h>
0017 #include <linux/pnp.h>
0018 #include <media/drv-intf/tea575x.h>
0019
0020 MODULE_AUTHOR("Ondrej Zary");
0021 MODULE_DESCRIPTION("MediaForte SF16-FMR2 and SF16-FMD2 FM radio card driver");
0022 MODULE_LICENSE("GPL");
0023
0024 /* these cards can only use two different ports (0x384 and 0x284) */
0025 #define FMR2_MAX 2
0026
0027 static int radio_nr[FMR2_MAX] = { [0 ... (FMR2_MAX - 1)] = -1 };
0028 module_param_array(radio_nr, int, NULL, 0444);
0029 MODULE_PARM_DESC(radio_nr, "Radio device numbers");
0030
0031 struct fmr2 {
0032     int io;
0033     struct v4l2_device v4l2_dev;
0034     struct snd_tea575x tea;
0035     struct v4l2_ctrl *volume;
0036     struct v4l2_ctrl *balance;
0037     bool is_fmd2;
0038 };
0039
0040 static int num_fmr2_cards;
0041 static struct fmr2 *fmr2_cards[FMR2_MAX];
0042 static bool isa_registered;
0043 static bool pnp_registered;
0044
0045 /* the port is hardwired on SF16-FMR2 */
0046 #define FMR2_PORT   0x384
0047
0048 /* TEA575x tuner pins */
0049 #define STR_DATA    (1 << 0)
0050 #define STR_CLK     (1 << 1)
0051 #define STR_WREN    (1 << 2)
0052 #define STR_MOST    (1 << 3)
0053 /* PT2254A/TC9154A volume control pins */
0054 #define PT_ST       (1 << 4)
0055 #define PT_CK       (1 << 5)
0056 #define PT_DATA     (1 << 6)
0057 /* volume control presence pin */
0058 #define FMR2_HASVOL (1 << 7)
0059
0060 static void fmr2_tea575x_set_pins(struct snd_tea575x *tea, u8 pins)
0061 {
0062     struct fmr2 *fmr2 = tea->private_data;
0063     u8 bits = 0;
0064
0065     bits |= (pins & TEA575X_DATA) ? STR_DATA : 0;
0066     bits |= (pins & TEA575X_CLK)  ? STR_CLK  : 0;
0067     /* WRITE_ENABLE is inverted, DATA must be high during read */
0068     bits |= (pins & TEA575X_WREN) ? 0 : STR_WREN | STR_DATA;
0069
0070     outb(bits, fmr2->io);
0071 }
0072
0073 static u8 fmr2_tea575x_get_pins(struct snd_tea575x *tea)
0074 {
0075     struct fmr2 *fmr2 = tea->private_data;
0076     u8 bits = inb(fmr2->io);
0077
0078     return  ((bits & STR_DATA) ? TEA575X_DATA : 0) |
0079         ((bits & STR_MOST) ? TEA575X_MOST : 0);
0080 }
0081
0082 static void fmr2_tea575x_set_direction(struct snd_tea575x *tea, bool output)
0083 {
0084 }
0085
0086 static const struct snd_tea575x_ops fmr2_tea_ops = {
0087     .set_pins = fmr2_tea575x_set_pins,
0088     .get_pins = fmr2_tea575x_get_pins,
0089     .set_direction = fmr2_tea575x_set_direction,
0090 };
0091
0092 /* TC9154A/PT2254A volume control */
0093
0094 /* 18-bit shift register bit definitions */
0095 #define TC9154A_ATT_MAJ_0DB (1 << 0)
0096 #define TC9154A_ATT_MAJ_10DB    (1 << 1)
0097 #define TC9154A_ATT_MAJ_20DB    (1 << 2)
0098 #define TC9154A_ATT_MAJ_30DB    (1 << 3)
0099 #define TC9154A_ATT_MAJ_40DB    (1 << 4)
0100 #define TC9154A_ATT_MAJ_50DB    (1 << 5)
0101 #define TC9154A_ATT_MAJ_60DB    (1 << 6)
0102
0103 #define TC9154A_ATT_MIN_0DB (1 << 7)
0104 #define TC9154A_ATT_MIN_2DB (1 << 8)
0105 #define TC9154A_ATT_MIN_4DB (1 << 9)
0106 #define TC9154A_ATT_MIN_6DB (1 << 10)
0107 #define TC9154A_ATT_MIN_8DB (1 << 11)
0108 /* bit 12 is ignored */
0109 #define TC9154A_CHANNEL_LEFT    (1 << 13)
0110 #define TC9154A_CHANNEL_RIGHT   (1 << 14)
0111 /* bits 15, 16, 17 must be 0 */
0112
0113 #define TC9154A_ATT_MAJ(x)  (1 << x)
0114 #define TC9154A_ATT_MIN(x)  (1 << (7 + x))
0115
0116 static void tc9154a_set_pins(struct fmr2 *fmr2, u8 pins)
0117 {
0118     if (!fmr2->tea.mute)
0119         pins |= STR_WREN;
0120
0121     outb(pins, fmr2->io);
0122 }
0123
0124 static void tc9154a_set_attenuation(struct fmr2 *fmr2, int att, u32 channel)
0125 {
0126     int i;
0127     u32 reg;
0128     u8 bit;
0129
0130     reg = TC9154A_ATT_MAJ(att / 10) | TC9154A_ATT_MIN((att % 10) / 2);
0131     reg |= channel;
0132     /* write 18-bit shift register, LSB first */
0133     for (i = 0; i < 18; i++) {
0134         bit = reg & (1 << i) ? PT_DATA : 0;
0135         tc9154a_set_pins(fmr2, bit);
0136         udelay(5);
0137         tc9154a_set_pins(fmr2, bit | PT_CK);
0138         udelay(5);
0139         tc9154a_set_pins(fmr2, bit);
0140     }
0141
0142     /* latch register data */
0143     udelay(5);
0144     tc9154a_set_pins(fmr2, PT_ST);
0145     udelay(5);
0146     tc9154a_set_pins(fmr2, 0);
0147 }
0148
0149 static int fmr2_s_ctrl(struct v4l2_ctrl *ctrl)
0150 {
0151     struct snd_tea575x *tea = container_of(ctrl->handler, struct snd_tea575x, ctrl_handler);
0152     struct fmr2 *fmr2 = tea->private_data;
0153     int volume, balance, left, right;
0154
0155     switch (ctrl->id) {
0156     case V4L2_CID_AUDIO_VOLUME:
0157         volume = ctrl->val;
0158         balance = fmr2->balance->cur.val;
0159         break;
0160     case V4L2_CID_AUDIO_BALANCE:
0161         balance = ctrl->val;
0162         volume = fmr2->volume->cur.val;
0163         break;
0164     default:
0165         return -EINVAL;
0166     }
0167
0168     left = right = volume;
0169     if (balance < 0)
0170         right = max(0, right + balance);
0171     if (balance > 0)
0172         left = max(0, left - balance);
0173
0174     tc9154a_set_attenuation(fmr2, abs(left - 68), TC9154A_CHANNEL_LEFT);
0175     tc9154a_set_attenuation(fmr2, abs(right - 68), TC9154A_CHANNEL_RIGHT);
0176
0177     return 0;
0178 }
0179
0180 static const struct v4l2_ctrl_ops fmr2_ctrl_ops = {
0181     .s_ctrl = fmr2_s_ctrl,
0182 };
0183
0184 static int fmr2_tea_ext_init(struct snd_tea575x *tea)
0185 {
0186     struct fmr2 *fmr2 = tea->private_data;
0187
0188     /* FMR2 can have volume control, FMD2 can't (uses SB16 mixer) */
0189     if (!fmr2->is_fmd2 && inb(fmr2->io) & FMR2_HASVOL) {
0190         fmr2->volume = v4l2_ctrl_new_std(&tea->ctrl_handler, &fmr2_ctrl_ops, V4L2_CID_AUDIO_VOLUME, 0, 68, 2, 56);
0191         fmr2->balance = v4l2_ctrl_new_std(&tea->ctrl_handler, &fmr2_ctrl_ops, V4L2_CID_AUDIO_BALANCE, -68, 68, 2, 0);
0192         if (tea->ctrl_handler.error) {
0193             printk(KERN_ERR "radio-sf16fmr2: can't initialize controls\n");
0194             return tea->ctrl_handler.error;
0195         }
0196     }
0197
0198     return 0;
0199 }
0200
0201 static const struct pnp_device_id fmr2_pnp_ids[] = {
0202     { .id = "MFRad13" }, /* tuner subdevice of SF16-FMD2 */
0203     { .id = "" }
0204 };
0205 MODULE_DEVICE_TABLE(pnp, fmr2_pnp_ids);
0206
0207 static int fmr2_probe(struct fmr2 *fmr2, struct device *pdev, int io)
0208 {
0209     int err, i;
0210     char *card_name = fmr2->is_fmd2 ? "SF16-FMD2" : "SF16-FMR2";
0211
0212     /* avoid errors if a card was already registered at given port */
0213     for (i = 0; i < num_fmr2_cards; i++)
0214         if (io == fmr2_cards[i]->io)
0215             return -EBUSY;
0216
0217     strscpy(fmr2->v4l2_dev.name, "radio-sf16fmr2",
0218         sizeof(fmr2->v4l2_dev.name));
0219     fmr2->io = io;
0220
0221     if (!request_region(fmr2->io, 2, fmr2->v4l2_dev.name)) {
0222         printk(KERN_ERR "radio-sf16fmr2: I/O port 0x%x already in use\n", fmr2->io);
0223         return -EBUSY;
0224     }
0225
0226     dev_set_drvdata(pdev, fmr2);
0227     err = v4l2_device_register(pdev, &fmr2->v4l2_dev);
0228     if (err < 0) {
0229         v4l2_err(&fmr2->v4l2_dev, "Could not register v4l2_device\n");
0230         release_region(fmr2->io, 2);
0231         return err;
0232     }
0233     fmr2->tea.v4l2_dev = &fmr2->v4l2_dev;
0234     fmr2->tea.private_data = fmr2;
0235     fmr2->tea.radio_nr = radio_nr[num_fmr2_cards];
0236     fmr2->tea.ops = &fmr2_tea_ops;
0237     fmr2->tea.ext_init = fmr2_tea_ext_init;
0238     strscpy(fmr2->tea.card, card_name, sizeof(fmr2->tea.card));
0239     snprintf(fmr2->tea.bus_info, sizeof(fmr2->tea.bus_info), "%s:%s",
0240             fmr2->is_fmd2 ? "PnP" : "ISA", dev_name(pdev));
0241
0242     if (snd_tea575x_init(&fmr2->tea, THIS_MODULE)) {
0243         printk(KERN_ERR "radio-sf16fmr2: Unable to detect TEA575x tuner\n");
0244         release_region(fmr2->io, 2);
0245         return -ENODEV;
0246     }
0247
0248     printk(KERN_INFO "radio-sf16fmr2: %s radio card at 0x%x.\n",
0249             card_name, fmr2->io);
0250     return 0;
0251 }
0252
0253 static int fmr2_isa_match(struct device *pdev, unsigned int ndev)
0254 {
0255     struct fmr2 *fmr2 = kzalloc(sizeof(*fmr2), GFP_KERNEL);
0256     if (!fmr2)
0257         return 0;
0258
0259     if (fmr2_probe(fmr2, pdev, FMR2_PORT)) {
0260         kfree(fmr2);
0261         return 0;
0262     }
0263     dev_set_drvdata(pdev, fmr2);
0264     fmr2_cards[num_fmr2_cards++] = fmr2;
0265
0266     return 1;
0267 }
0268
0269 static int fmr2_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id)
0270 {
0271     int ret;
0272     struct fmr2 *fmr2 = kzalloc(sizeof(*fmr2), GFP_KERNEL);
0273     if (!fmr2)
0274         return -ENOMEM;
0275
0276     fmr2->is_fmd2 = true;
0277     ret = fmr2_probe(fmr2, &pdev->dev, pnp_port_start(pdev, 0));
0278     if (ret) {
0279         kfree(fmr2);
0280         return ret;
0281     }
0282     pnp_set_drvdata(pdev, fmr2);
0283     fmr2_cards[num_fmr2_cards++] = fmr2;
0284
0285     return 0;
0286 }
0287
0288 static void fmr2_remove(struct fmr2 *fmr2)
0289 {
0290     snd_tea575x_exit(&fmr2->tea);
0291     release_region(fmr2->io, 2);
0292     v4l2_device_unregister(&fmr2->v4l2_dev);
0293     kfree(fmr2);
0294 }
0295
0296 static void fmr2_isa_remove(struct device *pdev, unsigned int ndev)
0297 {
0298     fmr2_remove(dev_get_drvdata(pdev));
0299 }
0300
0301 static void fmr2_pnp_remove(struct pnp_dev *pdev)
0302 {
0303     fmr2_remove(pnp_get_drvdata(pdev));
0304     pnp_set_drvdata(pdev, NULL);
0305 }
0306
0307 static struct isa_driver fmr2_isa_driver = {
0308     .match      = fmr2_isa_match,
0309     .remove     = fmr2_isa_remove,
0310     .driver     = {
0311         .name   = "radio-sf16fmr2",
0312     },
0313 };
0314
0315 static struct pnp_driver fmr2_pnp_driver = {
0316     .name       = "radio-sf16fmr2",
0317     .id_table   = fmr2_pnp_ids,
0318     .probe      = fmr2_pnp_probe,
0319     .remove     = fmr2_pnp_remove,
0320 };
0321
0322 static int __init fmr2_init(void)
0323 {
0324     int ret;
0325
0326     ret = pnp_register_driver(&fmr2_pnp_driver);
0327     if (!ret)
0328         pnp_registered = true;
0329     ret = isa_register_driver(&fmr2_isa_driver, 1);
0330     if (!ret)
0331         isa_registered = true;
0332
0333     return (pnp_registered || isa_registered) ? 0 : ret;
0334 }
0335
0336 static void __exit fmr2_exit(void)
0337 {
0338     if (pnp_registered)
0339         pnp_unregister_driver(&fmr2_pnp_driver);
0340     if (isa_registered)
0341         isa_unregister_driver(&fmr2_isa_driver);
0342 }
0343
0344 module_init(fmr2_init);
0345 module_exit(fmr2_exit);