1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* SF16-FMR2 and SF16-FMD2 radio driver for Linux |
3 | * Copyright (c) 2011 Ondrej Zary |
4 | * |
5 | * Original driver was (c) 2000-2002 Ziglio Frediano, freddy77@angelfire.com |
6 | * but almost nothing remained here after conversion to generic TEA575x |
7 | * implementation |
8 | */ |
9 | |
10 | #include <linux/delay.h> |
11 | #include <linux/module.h> /* Modules */ |
12 | #include <linux/init.h> /* Initdata */ |
13 | #include <linux/slab.h> |
14 | #include <linux/ioport.h> /* request_region */ |
15 | #include <linux/io.h> /* outb, outb_p */ |
16 | #include <linux/isa.h> |
17 | #include <linux/pnp.h> |
18 | #include <media/drv-intf/tea575x.h> |
19 | |
20 | MODULE_AUTHOR("Ondrej Zary" ); |
21 | MODULE_DESCRIPTION("MediaForte SF16-FMR2 and SF16-FMD2 FM radio card driver" ); |
22 | MODULE_LICENSE("GPL" ); |
23 | |
24 | /* these cards can only use two different ports (0x384 and 0x284) */ |
25 | #define FMR2_MAX 2 |
26 | |
27 | static int radio_nr[FMR2_MAX] = { [0 ... (FMR2_MAX - 1)] = -1 }; |
28 | module_param_array(radio_nr, int, NULL, 0444); |
29 | MODULE_PARM_DESC(radio_nr, "Radio device numbers" ); |
30 | |
31 | struct fmr2 { |
32 | int io; |
33 | struct v4l2_device v4l2_dev; |
34 | struct snd_tea575x tea; |
35 | struct v4l2_ctrl *volume; |
36 | struct v4l2_ctrl *balance; |
37 | bool is_fmd2; |
38 | }; |
39 | |
40 | static int num_fmr2_cards; |
41 | static struct fmr2 *fmr2_cards[FMR2_MAX]; |
42 | static bool isa_registered; |
43 | static bool pnp_registered; |
44 | |
45 | /* the port is hardwired on SF16-FMR2 */ |
46 | #define FMR2_PORT 0x384 |
47 | |
48 | /* TEA575x tuner pins */ |
49 | #define STR_DATA (1 << 0) |
50 | #define STR_CLK (1 << 1) |
51 | #define STR_WREN (1 << 2) |
52 | #define STR_MOST (1 << 3) |
53 | /* PT2254A/TC9154A volume control pins */ |
54 | #define PT_ST (1 << 4) |
55 | #define PT_CK (1 << 5) |
56 | #define PT_DATA (1 << 6) |
57 | /* volume control presence pin */ |
58 | #define FMR2_HASVOL (1 << 7) |
59 | |
60 | static void fmr2_tea575x_set_pins(struct snd_tea575x *tea, u8 pins) |
61 | { |
62 | struct fmr2 *fmr2 = tea->private_data; |
63 | u8 bits = 0; |
64 | |
65 | bits |= (pins & TEA575X_DATA) ? STR_DATA : 0; |
66 | bits |= (pins & TEA575X_CLK) ? STR_CLK : 0; |
67 | /* WRITE_ENABLE is inverted, DATA must be high during read */ |
68 | bits |= (pins & TEA575X_WREN) ? 0 : STR_WREN | STR_DATA; |
69 | |
70 | outb(value: bits, port: fmr2->io); |
71 | } |
72 | |
73 | static u8 fmr2_tea575x_get_pins(struct snd_tea575x *tea) |
74 | { |
75 | struct fmr2 *fmr2 = tea->private_data; |
76 | u8 bits = inb(port: fmr2->io); |
77 | |
78 | return ((bits & STR_DATA) ? TEA575X_DATA : 0) | |
79 | ((bits & STR_MOST) ? TEA575X_MOST : 0); |
80 | } |
81 | |
82 | static void fmr2_tea575x_set_direction(struct snd_tea575x *tea, bool output) |
83 | { |
84 | } |
85 | |
86 | static const struct snd_tea575x_ops fmr2_tea_ops = { |
87 | .set_pins = fmr2_tea575x_set_pins, |
88 | .get_pins = fmr2_tea575x_get_pins, |
89 | .set_direction = fmr2_tea575x_set_direction, |
90 | }; |
91 | |
92 | /* TC9154A/PT2254A volume control */ |
93 | |
94 | /* 18-bit shift register bit definitions */ |
95 | #define TC9154A_ATT_MAJ_0DB (1 << 0) |
96 | #define TC9154A_ATT_MAJ_10DB (1 << 1) |
97 | #define TC9154A_ATT_MAJ_20DB (1 << 2) |
98 | #define TC9154A_ATT_MAJ_30DB (1 << 3) |
99 | #define TC9154A_ATT_MAJ_40DB (1 << 4) |
100 | #define TC9154A_ATT_MAJ_50DB (1 << 5) |
101 | #define TC9154A_ATT_MAJ_60DB (1 << 6) |
102 | |
103 | #define TC9154A_ATT_MIN_0DB (1 << 7) |
104 | #define TC9154A_ATT_MIN_2DB (1 << 8) |
105 | #define TC9154A_ATT_MIN_4DB (1 << 9) |
106 | #define TC9154A_ATT_MIN_6DB (1 << 10) |
107 | #define TC9154A_ATT_MIN_8DB (1 << 11) |
108 | /* bit 12 is ignored */ |
109 | #define TC9154A_CHANNEL_LEFT (1 << 13) |
110 | #define TC9154A_CHANNEL_RIGHT (1 << 14) |
111 | /* bits 15, 16, 17 must be 0 */ |
112 | |
113 | #define TC9154A_ATT_MAJ(x) (1 << x) |
114 | #define TC9154A_ATT_MIN(x) (1 << (7 + x)) |
115 | |
116 | static void tc9154a_set_pins(struct fmr2 *fmr2, u8 pins) |
117 | { |
118 | if (!fmr2->tea.mute) |
119 | pins |= STR_WREN; |
120 | |
121 | outb(value: pins, port: fmr2->io); |
122 | } |
123 | |
124 | static void tc9154a_set_attenuation(struct fmr2 *fmr2, int att, u32 channel) |
125 | { |
126 | int i; |
127 | u32 reg; |
128 | u8 bit; |
129 | |
130 | reg = TC9154A_ATT_MAJ(att / 10) | TC9154A_ATT_MIN((att % 10) / 2); |
131 | reg |= channel; |
132 | /* write 18-bit shift register, LSB first */ |
133 | for (i = 0; i < 18; i++) { |
134 | bit = reg & (1 << i) ? PT_DATA : 0; |
135 | tc9154a_set_pins(fmr2, pins: bit); |
136 | udelay(5); |
137 | tc9154a_set_pins(fmr2, pins: bit | PT_CK); |
138 | udelay(5); |
139 | tc9154a_set_pins(fmr2, pins: bit); |
140 | } |
141 | |
142 | /* latch register data */ |
143 | udelay(5); |
144 | tc9154a_set_pins(fmr2, PT_ST); |
145 | udelay(5); |
146 | tc9154a_set_pins(fmr2, pins: 0); |
147 | } |
148 | |
149 | static int fmr2_s_ctrl(struct v4l2_ctrl *ctrl) |
150 | { |
151 | struct snd_tea575x *tea = container_of(ctrl->handler, struct snd_tea575x, ctrl_handler); |
152 | struct fmr2 *fmr2 = tea->private_data; |
153 | int volume, balance, left, right; |
154 | |
155 | switch (ctrl->id) { |
156 | case V4L2_CID_AUDIO_VOLUME: |
157 | volume = ctrl->val; |
158 | balance = fmr2->balance->cur.val; |
159 | break; |
160 | case V4L2_CID_AUDIO_BALANCE: |
161 | balance = ctrl->val; |
162 | volume = fmr2->volume->cur.val; |
163 | break; |
164 | default: |
165 | return -EINVAL; |
166 | } |
167 | |
168 | left = right = volume; |
169 | if (balance < 0) |
170 | right = max(0, right + balance); |
171 | if (balance > 0) |
172 | left = max(0, left - balance); |
173 | |
174 | tc9154a_set_attenuation(fmr2, abs(left - 68), TC9154A_CHANNEL_LEFT); |
175 | tc9154a_set_attenuation(fmr2, abs(right - 68), TC9154A_CHANNEL_RIGHT); |
176 | |
177 | return 0; |
178 | } |
179 | |
180 | static const struct v4l2_ctrl_ops fmr2_ctrl_ops = { |
181 | .s_ctrl = fmr2_s_ctrl, |
182 | }; |
183 | |
184 | static int fmr2_tea_ext_init(struct snd_tea575x *tea) |
185 | { |
186 | struct fmr2 *fmr2 = tea->private_data; |
187 | |
188 | /* FMR2 can have volume control, FMD2 can't (uses SB16 mixer) */ |
189 | if (!fmr2->is_fmd2 && inb(port: fmr2->io) & FMR2_HASVOL) { |
190 | fmr2->volume = v4l2_ctrl_new_std(hdl: &tea->ctrl_handler, ops: &fmr2_ctrl_ops, V4L2_CID_AUDIO_VOLUME, min: 0, max: 68, step: 2, def: 56); |
191 | fmr2->balance = v4l2_ctrl_new_std(hdl: &tea->ctrl_handler, ops: &fmr2_ctrl_ops, V4L2_CID_AUDIO_BALANCE, min: -68, max: 68, step: 2, def: 0); |
192 | if (tea->ctrl_handler.error) { |
193 | printk(KERN_ERR "radio-sf16fmr2: can't initialize controls\n" ); |
194 | return tea->ctrl_handler.error; |
195 | } |
196 | } |
197 | |
198 | return 0; |
199 | } |
200 | |
201 | static const struct pnp_device_id fmr2_pnp_ids[] = { |
202 | { .id = "MFRad13" }, /* tuner subdevice of SF16-FMD2 */ |
203 | { .id = "" } |
204 | }; |
205 | MODULE_DEVICE_TABLE(pnp, fmr2_pnp_ids); |
206 | |
207 | static int fmr2_probe(struct fmr2 *fmr2, struct device *pdev, int io) |
208 | { |
209 | int err, i; |
210 | char *card_name = fmr2->is_fmd2 ? "SF16-FMD2" : "SF16-FMR2" ; |
211 | |
212 | /* avoid errors if a card was already registered at given port */ |
213 | for (i = 0; i < num_fmr2_cards; i++) |
214 | if (io == fmr2_cards[i]->io) |
215 | return -EBUSY; |
216 | |
217 | strscpy(fmr2->v4l2_dev.name, "radio-sf16fmr2" , |
218 | sizeof(fmr2->v4l2_dev.name)); |
219 | fmr2->io = io; |
220 | |
221 | if (!request_region(fmr2->io, 2, fmr2->v4l2_dev.name)) { |
222 | printk(KERN_ERR "radio-sf16fmr2: I/O port 0x%x already in use\n" , fmr2->io); |
223 | return -EBUSY; |
224 | } |
225 | |
226 | dev_set_drvdata(dev: pdev, data: fmr2); |
227 | err = v4l2_device_register(dev: pdev, v4l2_dev: &fmr2->v4l2_dev); |
228 | if (err < 0) { |
229 | v4l2_err(&fmr2->v4l2_dev, "Could not register v4l2_device\n" ); |
230 | release_region(fmr2->io, 2); |
231 | return err; |
232 | } |
233 | fmr2->tea.v4l2_dev = &fmr2->v4l2_dev; |
234 | fmr2->tea.private_data = fmr2; |
235 | fmr2->tea.radio_nr = radio_nr[num_fmr2_cards]; |
236 | fmr2->tea.ops = &fmr2_tea_ops; |
237 | fmr2->tea.ext_init = fmr2_tea_ext_init; |
238 | strscpy(fmr2->tea.card, card_name, sizeof(fmr2->tea.card)); |
239 | snprintf(buf: fmr2->tea.bus_info, size: sizeof(fmr2->tea.bus_info), fmt: "%s:%s" , |
240 | fmr2->is_fmd2 ? "PnP" : "ISA" , dev_name(dev: pdev)); |
241 | |
242 | if (snd_tea575x_init(tea: &fmr2->tea, THIS_MODULE)) { |
243 | printk(KERN_ERR "radio-sf16fmr2: Unable to detect TEA575x tuner\n" ); |
244 | release_region(fmr2->io, 2); |
245 | return -ENODEV; |
246 | } |
247 | |
248 | printk(KERN_INFO "radio-sf16fmr2: %s radio card at 0x%x.\n" , |
249 | card_name, fmr2->io); |
250 | return 0; |
251 | } |
252 | |
253 | static int fmr2_isa_match(struct device *pdev, unsigned int ndev) |
254 | { |
255 | struct fmr2 *fmr2 = kzalloc(size: sizeof(*fmr2), GFP_KERNEL); |
256 | if (!fmr2) |
257 | return 0; |
258 | |
259 | if (fmr2_probe(fmr2, pdev, FMR2_PORT)) { |
260 | kfree(objp: fmr2); |
261 | return 0; |
262 | } |
263 | dev_set_drvdata(dev: pdev, data: fmr2); |
264 | fmr2_cards[num_fmr2_cards++] = fmr2; |
265 | |
266 | return 1; |
267 | } |
268 | |
269 | static int fmr2_pnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *id) |
270 | { |
271 | int ret; |
272 | struct fmr2 *fmr2 = kzalloc(size: sizeof(*fmr2), GFP_KERNEL); |
273 | if (!fmr2) |
274 | return -ENOMEM; |
275 | |
276 | fmr2->is_fmd2 = true; |
277 | ret = fmr2_probe(fmr2, pdev: &pdev->dev, io: pnp_port_start(dev: pdev, bar: 0)); |
278 | if (ret) { |
279 | kfree(objp: fmr2); |
280 | return ret; |
281 | } |
282 | pnp_set_drvdata(pdev, data: fmr2); |
283 | fmr2_cards[num_fmr2_cards++] = fmr2; |
284 | |
285 | return 0; |
286 | } |
287 | |
288 | static void fmr2_remove(struct fmr2 *fmr2) |
289 | { |
290 | snd_tea575x_exit(tea: &fmr2->tea); |
291 | release_region(fmr2->io, 2); |
292 | v4l2_device_unregister(v4l2_dev: &fmr2->v4l2_dev); |
293 | kfree(objp: fmr2); |
294 | } |
295 | |
296 | static void fmr2_isa_remove(struct device *pdev, unsigned int ndev) |
297 | { |
298 | fmr2_remove(fmr2: dev_get_drvdata(dev: pdev)); |
299 | } |
300 | |
301 | static void fmr2_pnp_remove(struct pnp_dev *pdev) |
302 | { |
303 | fmr2_remove(fmr2: pnp_get_drvdata(pdev)); |
304 | pnp_set_drvdata(pdev, NULL); |
305 | } |
306 | |
307 | static struct isa_driver fmr2_isa_driver = { |
308 | .match = fmr2_isa_match, |
309 | .remove = fmr2_isa_remove, |
310 | .driver = { |
311 | .name = "radio-sf16fmr2" , |
312 | }, |
313 | }; |
314 | |
315 | static struct pnp_driver fmr2_pnp_driver = { |
316 | .name = "radio-sf16fmr2" , |
317 | .id_table = fmr2_pnp_ids, |
318 | .probe = fmr2_pnp_probe, |
319 | .remove = fmr2_pnp_remove, |
320 | }; |
321 | |
322 | static int __init fmr2_init(void) |
323 | { |
324 | int ret; |
325 | |
326 | ret = pnp_register_driver(drv: &fmr2_pnp_driver); |
327 | if (!ret) |
328 | pnp_registered = true; |
329 | ret = isa_register_driver(&fmr2_isa_driver, 1); |
330 | if (!ret) |
331 | isa_registered = true; |
332 | |
333 | return (pnp_registered || isa_registered) ? 0 : ret; |
334 | } |
335 | |
336 | static void __exit fmr2_exit(void) |
337 | { |
338 | if (pnp_registered) |
339 | pnp_unregister_driver(drv: &fmr2_pnp_driver); |
340 | if (isa_registered) |
341 | isa_unregister_driver(&fmr2_isa_driver); |
342 | } |
343 | |
344 | module_init(fmr2_init); |
345 | module_exit(fmr2_exit); |
346 | |