1 /*
2 * dvbdev.c
3 *
4 * Copyright (C) 2000 Ralph Metzler <ralph@convergence.de>
5 * & Marcus Metzler <marcus@convergence.de>
6 * for convergence integrated media GmbH
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation; either version 2.1
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 */
19
20 #define pr_fmt(fmt) "dvbdev: " fmt
21
22 #include <linux/types.h>
23 #include <linux/errno.h>
24 #include <linux/string.h>
25 #include <linux/module.h>
26 #include <linux/kernel.h>
27 #include <linux/i2c.h>
28 #include <linux/init.h>
29 #include <linux/slab.h>
30 #include <linux/device.h>
31 #include <linux/fs.h>
32 #include <linux/cdev.h>
33 #include <linux/mutex.h>
34 #include <media/dvbdev.h>
35
36 /* Due to enum tuner_pad_index */
37 #include <media/tuner.h>
38
39 static DEFINE_MUTEX(dvbdev_mutex);
40 static LIST_HEAD(dvbdevfops_list);
41 static int dvbdev_debug;
42
43 module_param(dvbdev_debug, int, 0644);
44 MODULE_PARM_DESC(dvbdev_debug, "Turn on/off device debugging (default:off).");
45
46 #define dprintk(fmt, arg...) do { \
47 if (dvbdev_debug) \
48 printk(KERN_DEBUG pr_fmt("%s: " fmt), \
49 __func__, ##arg); \
50 } while (0)
51
52 static LIST_HEAD(dvb_adapter_list);
53 static DEFINE_MUTEX(dvbdev_register_lock);
54
55 static const char * const dnames[] = {
56 [DVB_DEVICE_VIDEO] = "video",
57 [DVB_DEVICE_AUDIO] = "audio",
58 [DVB_DEVICE_SEC] = "sec",
59 [DVB_DEVICE_FRONTEND] = "frontend",
60 [DVB_DEVICE_DEMUX] = "demux",
61 [DVB_DEVICE_DVR] = "dvr",
62 [DVB_DEVICE_CA] = "ca",
63 [DVB_DEVICE_NET] = "net",
64 [DVB_DEVICE_OSD] = "osd"
65 };
66
67 #ifdef CONFIG_DVB_DYNAMIC_MINORS
68 #define MAX_DVB_MINORS 256
69 #define DVB_MAX_IDS MAX_DVB_MINORS
70 #else
71 #define DVB_MAX_IDS 4
72
73 static const u8 minor_type[] = {
74 [DVB_DEVICE_VIDEO] = 0,
75 [DVB_DEVICE_AUDIO] = 1,
76 [DVB_DEVICE_SEC] = 2,
77 [DVB_DEVICE_FRONTEND] = 3,
78 [DVB_DEVICE_DEMUX] = 4,
79 [DVB_DEVICE_DVR] = 5,
80 [DVB_DEVICE_CA] = 6,
81 [DVB_DEVICE_NET] = 7,
82 [DVB_DEVICE_OSD] = 8,
83 };
84
85 #define nums2minor(num, type, id) \
86 (((num) << 6) | ((id) << 4) | minor_type[type])
87
88 #define MAX_DVB_MINORS (DVB_MAX_ADAPTERS*64)
89 #endif
90
91 static struct class *dvb_class;
92
93 static struct dvb_device *dvb_minors[MAX_DVB_MINORS];
94 static DECLARE_RWSEM(minor_rwsem);
95
dvb_device_open(struct inode * inode,struct file * file)96 static int dvb_device_open(struct inode *inode, struct file *file)
97 {
98 struct dvb_device *dvbdev;
99 unsigned int minor = iminor(inode);
100
101 if (minor >= MAX_DVB_MINORS)
102 return -ENODEV;
103
104 mutex_lock(&dvbdev_mutex);
105 down_read(&minor_rwsem);
106
107 dvbdev = dvb_minors[minor];
108
109 if (dvbdev && dvbdev->fops) {
110 int err = 0;
111 const struct file_operations *new_fops;
112
113 new_fops = fops_get(dvbdev->fops);
114 if (!new_fops)
115 goto fail;
116 file->private_data = dvb_device_get(dvbdev);
117 replace_fops(file, new_fops);
118 if (file->f_op->open)
119 err = file->f_op->open(inode, file);
120 up_read(&minor_rwsem);
121 mutex_unlock(&dvbdev_mutex);
122 if (err)
123 dvb_device_put(dvbdev);
124 return err;
125 }
126 fail:
127 up_read(&minor_rwsem);
128 mutex_unlock(&dvbdev_mutex);
129 return -ENODEV;
130 }
131
132
133 static const struct file_operations dvb_device_fops =
134 {
135 .owner = THIS_MODULE,
136 .open = dvb_device_open,
137 .llseek = noop_llseek,
138 };
139
140 static struct cdev dvb_device_cdev;
141
dvb_generic_open(struct inode * inode,struct file * file)142 int dvb_generic_open(struct inode *inode, struct file *file)
143 {
144 struct dvb_device *dvbdev = file->private_data;
145
146 if (!dvbdev)
147 return -ENODEV;
148
149 if (!dvbdev->users)
150 return -EBUSY;
151
152 if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
153 if (!dvbdev->readers)
154 return -EBUSY;
155 dvbdev->readers--;
156 } else {
157 if (!dvbdev->writers)
158 return -EBUSY;
159 dvbdev->writers--;
160 }
161
162 dvbdev->users--;
163 return 0;
164 }
165 EXPORT_SYMBOL(dvb_generic_open);
166
167
dvb_generic_release(struct inode * inode,struct file * file)168 int dvb_generic_release(struct inode *inode, struct file *file)
169 {
170 struct dvb_device *dvbdev = file->private_data;
171
172 if (!dvbdev)
173 return -ENODEV;
174
175 if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
176 dvbdev->readers++;
177 } else {
178 dvbdev->writers++;
179 }
180
181 dvbdev->users++;
182
183 dvb_device_put(dvbdev);
184
185 return 0;
186 }
187 EXPORT_SYMBOL(dvb_generic_release);
188
189
dvb_generic_ioctl(struct file * file,unsigned int cmd,unsigned long arg)190 long dvb_generic_ioctl(struct file *file,
191 unsigned int cmd, unsigned long arg)
192 {
193 struct dvb_device *dvbdev = file->private_data;
194
195 if (!dvbdev)
196 return -ENODEV;
197
198 if (!dvbdev->kernel_ioctl)
199 return -EINVAL;
200
201 return dvb_usercopy(file, cmd, arg, dvbdev->kernel_ioctl);
202 }
203 EXPORT_SYMBOL(dvb_generic_ioctl);
204
205
dvbdev_get_free_id(struct dvb_adapter * adap,int type)206 static int dvbdev_get_free_id (struct dvb_adapter *adap, int type)
207 {
208 u32 id = 0;
209
210 while (id < DVB_MAX_IDS) {
211 struct dvb_device *dev;
212 list_for_each_entry(dev, &adap->device_list, list_head)
213 if (dev->type == type && dev->id == id)
214 goto skip;
215 return id;
216 skip:
217 id++;
218 }
219 return -ENFILE;
220 }
221
dvb_media_device_free(struct dvb_device * dvbdev)222 static void dvb_media_device_free(struct dvb_device *dvbdev)
223 {
224 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
225 if (dvbdev->entity) {
226 media_device_unregister_entity(dvbdev->entity);
227 kfree(dvbdev->entity);
228 kfree(dvbdev->pads);
229 dvbdev->entity = NULL;
230 dvbdev->pads = NULL;
231 }
232
233 if (dvbdev->tsout_entity) {
234 int i;
235
236 for (i = 0; i < dvbdev->tsout_num_entities; i++) {
237 media_device_unregister_entity(&dvbdev->tsout_entity[i]);
238 kfree(dvbdev->tsout_entity[i].name);
239 }
240 kfree(dvbdev->tsout_entity);
241 kfree(dvbdev->tsout_pads);
242 dvbdev->tsout_entity = NULL;
243 dvbdev->tsout_pads = NULL;
244
245 dvbdev->tsout_num_entities = 0;
246 }
247
248 if (dvbdev->intf_devnode) {
249 media_devnode_remove(dvbdev->intf_devnode);
250 dvbdev->intf_devnode = NULL;
251 }
252
253 if (dvbdev->adapter->conn) {
254 media_device_unregister_entity(dvbdev->adapter->conn);
255 kfree(dvbdev->adapter->conn);
256 dvbdev->adapter->conn = NULL;
257 kfree(dvbdev->adapter->conn_pads);
258 dvbdev->adapter->conn_pads = NULL;
259 }
260 #endif
261 }
262
263 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
dvb_create_tsout_entity(struct dvb_device * dvbdev,const char * name,int npads)264 static int dvb_create_tsout_entity(struct dvb_device *dvbdev,
265 const char *name, int npads)
266 {
267 int i, ret = 0;
268
269 dvbdev->tsout_pads = kcalloc(npads, sizeof(*dvbdev->tsout_pads),
270 GFP_KERNEL);
271 if (!dvbdev->tsout_pads)
272 return -ENOMEM;
273
274 dvbdev->tsout_entity = kcalloc(npads, sizeof(*dvbdev->tsout_entity),
275 GFP_KERNEL);
276 if (!dvbdev->tsout_entity)
277 return -ENOMEM;
278
279 dvbdev->tsout_num_entities = npads;
280
281 for (i = 0; i < npads; i++) {
282 struct media_pad *pads = &dvbdev->tsout_pads[i];
283 struct media_entity *entity = &dvbdev->tsout_entity[i];
284
285 entity->name = kasprintf(GFP_KERNEL, "%s #%d", name, i);
286 if (!entity->name)
287 return -ENOMEM;
288
289 entity->function = MEDIA_ENT_F_IO_DTV;
290 pads->flags = MEDIA_PAD_FL_SINK;
291
292 ret = media_entity_pads_init(entity, 1, pads);
293 if (ret < 0)
294 return ret;
295
296 ret = media_device_register_entity(dvbdev->adapter->mdev,
297 entity);
298 if (ret < 0)
299 return ret;
300 }
301 return 0;
302 }
303
304 #define DEMUX_TSOUT "demux-tsout"
305 #define DVR_TSOUT "dvr-tsout"
306
dvb_create_media_entity(struct dvb_device * dvbdev,int type,int demux_sink_pads)307 static int dvb_create_media_entity(struct dvb_device *dvbdev,
308 int type, int demux_sink_pads)
309 {
310 int i, ret, npads;
311
312 switch (type) {
313 case DVB_DEVICE_FRONTEND:
314 npads = 2;
315 break;
316 case DVB_DEVICE_DVR:
317 ret = dvb_create_tsout_entity(dvbdev, DVR_TSOUT,
318 demux_sink_pads);
319 return ret;
320 case DVB_DEVICE_DEMUX:
321 npads = 1 + demux_sink_pads;
322 ret = dvb_create_tsout_entity(dvbdev, DEMUX_TSOUT,
323 demux_sink_pads);
324 if (ret < 0)
325 return ret;
326 break;
327 case DVB_DEVICE_CA:
328 npads = 2;
329 break;
330 case DVB_DEVICE_NET:
331 /*
332 * We should be creating entities for the MPE/ULE
333 * decapsulation hardware (or software implementation).
334 *
335 * However, the number of for the MPE/ULE decaps may not be
336 * fixed. As we don't have yet dynamic support for PADs at
337 * the Media Controller, let's not create the decap
338 * entities yet.
339 */
340 return 0;
341 default:
342 return 0;
343 }
344
345 dvbdev->entity = kzalloc(sizeof(*dvbdev->entity), GFP_KERNEL);
346 if (!dvbdev->entity)
347 return -ENOMEM;
348
349 dvbdev->entity->name = dvbdev->name;
350
351 if (npads) {
352 dvbdev->pads = kcalloc(npads, sizeof(*dvbdev->pads),
353 GFP_KERNEL);
354 if (!dvbdev->pads) {
355 kfree(dvbdev->entity);
356 dvbdev->entity = NULL;
357 return -ENOMEM;
358 }
359 }
360
361 switch (type) {
362 case DVB_DEVICE_FRONTEND:
363 dvbdev->entity->function = MEDIA_ENT_F_DTV_DEMOD;
364 dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
365 dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE;
366 break;
367 case DVB_DEVICE_DEMUX:
368 dvbdev->entity->function = MEDIA_ENT_F_TS_DEMUX;
369 dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
370 for (i = 1; i < npads; i++)
371 dvbdev->pads[i].flags = MEDIA_PAD_FL_SOURCE;
372 break;
373 case DVB_DEVICE_CA:
374 dvbdev->entity->function = MEDIA_ENT_F_DTV_CA;
375 dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
376 dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE;
377 break;
378 default:
379 /* Should never happen, as the first switch prevents it */
380 kfree(dvbdev->entity);
381 kfree(dvbdev->pads);
382 dvbdev->entity = NULL;
383 dvbdev->pads = NULL;
384 return 0;
385 }
386
387 if (npads) {
388 ret = media_entity_pads_init(dvbdev->entity, npads, dvbdev->pads);
389 if (ret)
390 return ret;
391 }
392 ret = media_device_register_entity(dvbdev->adapter->mdev,
393 dvbdev->entity);
394 if (ret)
395 return ret;
396
397 pr_info("%s: media entity '%s' registered.\n",
398 __func__, dvbdev->entity->name);
399
400 return 0;
401 }
402 #endif
403
dvb_register_media_device(struct dvb_device * dvbdev,int type,int minor,unsigned demux_sink_pads)404 static int dvb_register_media_device(struct dvb_device *dvbdev,
405 int type, int minor,
406 unsigned demux_sink_pads)
407 {
408 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
409 struct media_link *link;
410 u32 intf_type;
411 int ret;
412
413 if (!dvbdev->adapter->mdev)
414 return 0;
415
416 ret = dvb_create_media_entity(dvbdev, type, demux_sink_pads);
417 if (ret)
418 return ret;
419
420 switch (type) {
421 case DVB_DEVICE_FRONTEND:
422 intf_type = MEDIA_INTF_T_DVB_FE;
423 break;
424 case DVB_DEVICE_DEMUX:
425 intf_type = MEDIA_INTF_T_DVB_DEMUX;
426 break;
427 case DVB_DEVICE_DVR:
428 intf_type = MEDIA_INTF_T_DVB_DVR;
429 break;
430 case DVB_DEVICE_CA:
431 intf_type = MEDIA_INTF_T_DVB_CA;
432 break;
433 case DVB_DEVICE_NET:
434 intf_type = MEDIA_INTF_T_DVB_NET;
435 break;
436 default:
437 return 0;
438 }
439
440 dvbdev->intf_devnode = media_devnode_create(dvbdev->adapter->mdev,
441 intf_type, 0,
442 DVB_MAJOR, minor);
443
444 if (!dvbdev->intf_devnode)
445 return -ENOMEM;
446
447 /*
448 * Create the "obvious" link, e. g. the ones that represent
449 * a direct association between an interface and an entity.
450 * Other links should be created elsewhere, like:
451 * DVB FE intf -> tuner
452 * DVB demux intf -> dvr
453 */
454
455 if (!dvbdev->entity)
456 return 0;
457
458 link = media_create_intf_link(dvbdev->entity,
459 &dvbdev->intf_devnode->intf,
460 MEDIA_LNK_FL_ENABLED |
461 MEDIA_LNK_FL_IMMUTABLE);
462 if (!link)
463 return -ENOMEM;
464 #endif
465 return 0;
466 }
467
dvb_register_device(struct dvb_adapter * adap,struct dvb_device ** pdvbdev,const struct dvb_device * template,void * priv,enum dvb_device_type type,int demux_sink_pads)468 int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
469 const struct dvb_device *template, void *priv,
470 enum dvb_device_type type, int demux_sink_pads)
471 {
472 struct dvb_device *dvbdev;
473 struct file_operations *dvbdevfops = NULL;
474 struct dvbdevfops_node *node = NULL, *new_node = NULL;
475 struct device *clsdev;
476 int minor;
477 int id, ret;
478
479 mutex_lock(&dvbdev_register_lock);
480
481 if ((id = dvbdev_get_free_id (adap, type)) < 0) {
482 mutex_unlock(&dvbdev_register_lock);
483 *pdvbdev = NULL;
484 pr_err("%s: couldn't find free device id\n", __func__);
485 return -ENFILE;
486 }
487
488 *pdvbdev = dvbdev = kzalloc(sizeof(*dvbdev), GFP_KERNEL);
489 if (!dvbdev){
490 mutex_unlock(&dvbdev_register_lock);
491 return -ENOMEM;
492 }
493
494 /*
495 * When a device of the same type is probe()d more than once,
496 * the first allocated fops are used. This prevents memory leaks
497 * that can occur when the same device is probe()d repeatedly.
498 */
499 list_for_each_entry(node, &dvbdevfops_list, list_head) {
500 if (node->fops->owner == adap->module &&
501 node->type == type &&
502 node->template == template) {
503 dvbdevfops = node->fops;
504 break;
505 }
506 }
507
508 if (dvbdevfops == NULL) {
509 dvbdevfops = kmemdup(template->fops, sizeof(*dvbdevfops), GFP_KERNEL);
510 if (!dvbdevfops) {
511 kfree(dvbdev);
512 *pdvbdev = NULL;
513 mutex_unlock(&dvbdev_register_lock);
514 return -ENOMEM;
515 }
516
517 new_node = kzalloc(sizeof(struct dvbdevfops_node), GFP_KERNEL);
518 if (!new_node) {
519 kfree(dvbdevfops);
520 kfree(dvbdev);
521 *pdvbdev = NULL;
522 mutex_unlock(&dvbdev_register_lock);
523 return -ENOMEM;
524 }
525
526 new_node->fops = dvbdevfops;
527 new_node->type = type;
528 new_node->template = template;
529 list_add_tail (&new_node->list_head, &dvbdevfops_list);
530 }
531
532 memcpy(dvbdev, template, sizeof(struct dvb_device));
533 kref_init(&dvbdev->ref);
534 dvbdev->type = type;
535 dvbdev->id = id;
536 dvbdev->adapter = adap;
537 dvbdev->priv = priv;
538 dvbdev->fops = dvbdevfops;
539 init_waitqueue_head (&dvbdev->wait_queue);
540 dvbdevfops->owner = adap->module;
541 list_add_tail (&dvbdev->list_head, &adap->device_list);
542 down_write(&minor_rwsem);
543 #ifdef CONFIG_DVB_DYNAMIC_MINORS
544 for (minor = 0; minor < MAX_DVB_MINORS; minor++)
545 if (dvb_minors[minor] == NULL)
546 break;
547 #else
548 minor = nums2minor(adap->num, type, id);
549 #endif
550 if (minor >= MAX_DVB_MINORS) {
551 if (new_node) {
552 list_del (&new_node->list_head);
553 kfree(dvbdevfops);
554 kfree(new_node);
555 }
556 list_del (&dvbdev->list_head);
557 kfree(dvbdev);
558 *pdvbdev = NULL;
559 up_write(&minor_rwsem);
560 mutex_unlock(&dvbdev_register_lock);
561 return -EINVAL;
562 }
563
564 dvbdev->minor = minor;
565 dvb_minors[minor] = dvb_device_get(dvbdev);
566 up_write(&minor_rwsem);
567 ret = dvb_register_media_device(dvbdev, type, minor, demux_sink_pads);
568 if (ret) {
569 pr_err("%s: dvb_register_media_device failed to create the mediagraph\n",
570 __func__);
571 if (new_node) {
572 list_del (&new_node->list_head);
573 kfree(dvbdevfops);
574 kfree(new_node);
575 }
576 dvb_media_device_free(dvbdev);
577 list_del (&dvbdev->list_head);
578 kfree(dvbdev);
579 *pdvbdev = NULL;
580 mutex_unlock(&dvbdev_register_lock);
581 return ret;
582 }
583
584 clsdev = device_create(dvb_class, adap->device,
585 MKDEV(DVB_MAJOR, minor),
586 dvbdev, "dvb%d.%s%d", adap->num, dnames[type], id);
587 if (IS_ERR(clsdev)) {
588 pr_err("%s: failed to create device dvb%d.%s%d (%ld)\n",
589 __func__, adap->num, dnames[type], id, PTR_ERR(clsdev));
590 if (new_node) {
591 list_del (&new_node->list_head);
592 kfree(dvbdevfops);
593 kfree(new_node);
594 }
595 dvb_media_device_free(dvbdev);
596 list_del (&dvbdev->list_head);
597 kfree(dvbdev);
598 *pdvbdev = NULL;
599 mutex_unlock(&dvbdev_register_lock);
600 return PTR_ERR(clsdev);
601 }
602
603 dprintk("DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n",
604 adap->num, dnames[type], id, minor, minor);
605
606 mutex_unlock(&dvbdev_register_lock);
607 return 0;
608 }
609 EXPORT_SYMBOL(dvb_register_device);
610
611
dvb_remove_device(struct dvb_device * dvbdev)612 void dvb_remove_device(struct dvb_device *dvbdev)
613 {
614 if (!dvbdev)
615 return;
616
617 down_write(&minor_rwsem);
618 dvb_minors[dvbdev->minor] = NULL;
619 dvb_device_put(dvbdev);
620 up_write(&minor_rwsem);
621
622 dvb_media_device_free(dvbdev);
623
624 device_destroy(dvb_class, MKDEV(DVB_MAJOR, dvbdev->minor));
625
626 list_del (&dvbdev->list_head);
627 }
628 EXPORT_SYMBOL(dvb_remove_device);
629
630
dvb_free_device(struct kref * ref)631 static void dvb_free_device(struct kref *ref)
632 {
633 struct dvb_device *dvbdev = container_of(ref, struct dvb_device, ref);
634
635 kfree (dvbdev);
636 }
637
638
dvb_device_get(struct dvb_device * dvbdev)639 struct dvb_device *dvb_device_get(struct dvb_device *dvbdev)
640 {
641 kref_get(&dvbdev->ref);
642 return dvbdev;
643 }
644 EXPORT_SYMBOL(dvb_device_get);
645
646
dvb_device_put(struct dvb_device * dvbdev)647 void dvb_device_put(struct dvb_device *dvbdev)
648 {
649 if (dvbdev)
650 kref_put(&dvbdev->ref, dvb_free_device);
651 }
652
653
dvb_unregister_device(struct dvb_device * dvbdev)654 void dvb_unregister_device(struct dvb_device *dvbdev)
655 {
656 dvb_remove_device(dvbdev);
657 dvb_device_put(dvbdev);
658 }
659 EXPORT_SYMBOL(dvb_unregister_device);
660
661
662 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
663
dvb_create_io_intf_links(struct dvb_adapter * adap,struct media_interface * intf,char * name)664 static int dvb_create_io_intf_links(struct dvb_adapter *adap,
665 struct media_interface *intf,
666 char *name)
667 {
668 struct media_device *mdev = adap->mdev;
669 struct media_entity *entity;
670 struct media_link *link;
671
672 media_device_for_each_entity(entity, mdev) {
673 if (entity->function == MEDIA_ENT_F_IO_DTV) {
674 if (strncmp(entity->name, name, strlen(name)))
675 continue;
676 link = media_create_intf_link(entity, intf,
677 MEDIA_LNK_FL_ENABLED |
678 MEDIA_LNK_FL_IMMUTABLE);
679 if (!link)
680 return -ENOMEM;
681 }
682 }
683 return 0;
684 }
685
dvb_create_media_graph(struct dvb_adapter * adap,bool create_rf_connector)686 int dvb_create_media_graph(struct dvb_adapter *adap,
687 bool create_rf_connector)
688 {
689 struct media_device *mdev = adap->mdev;
690 struct media_entity *entity, *tuner = NULL, *demod = NULL, *conn;
691 struct media_entity *demux = NULL, *ca = NULL;
692 struct media_link *link;
693 struct media_interface *intf;
694 unsigned demux_pad = 0;
695 unsigned dvr_pad = 0;
696 unsigned ntuner = 0, ndemod = 0;
697 int ret, pad_source, pad_sink;
698 static const char *connector_name = "Television";
699
700 if (!mdev)
701 return 0;
702
703 media_device_for_each_entity(entity, mdev) {
704 switch (entity->function) {
705 case MEDIA_ENT_F_TUNER:
706 tuner = entity;
707 ntuner++;
708 break;
709 case MEDIA_ENT_F_DTV_DEMOD:
710 demod = entity;
711 ndemod++;
712 break;
713 case MEDIA_ENT_F_TS_DEMUX:
714 demux = entity;
715 break;
716 case MEDIA_ENT_F_DTV_CA:
717 ca = entity;
718 break;
719 }
720 }
721
722 /*
723 * Prepare to signalize to media_create_pad_links() that multiple
724 * entities of the same type exists and a 1:n or n:1 links need to be
725 * created.
726 * NOTE: if both tuner and demod have multiple instances, it is up
727 * to the caller driver to create such links.
728 */
729 if (ntuner > 1)
730 tuner = NULL;
731 if (ndemod > 1)
732 demod = NULL;
733
734 if (create_rf_connector) {
735 conn = kzalloc(sizeof(*conn), GFP_KERNEL);
736 if (!conn)
737 return -ENOMEM;
738 adap->conn = conn;
739
740 adap->conn_pads = kzalloc(sizeof(*adap->conn_pads), GFP_KERNEL);
741 if (!adap->conn_pads)
742 return -ENOMEM;
743
744 conn->flags = MEDIA_ENT_FL_CONNECTOR;
745 conn->function = MEDIA_ENT_F_CONN_RF;
746 conn->name = connector_name;
747 adap->conn_pads->flags = MEDIA_PAD_FL_SOURCE;
748
749 ret = media_entity_pads_init(conn, 1, adap->conn_pads);
750 if (ret)
751 return ret;
752
753 ret = media_device_register_entity(mdev, conn);
754 if (ret)
755 return ret;
756
757 if (!ntuner) {
758 ret = media_create_pad_links(mdev,
759 MEDIA_ENT_F_CONN_RF,
760 conn, 0,
761 MEDIA_ENT_F_DTV_DEMOD,
762 demod, 0,
763 MEDIA_LNK_FL_ENABLED,
764 false);
765 } else {
766 pad_sink = media_get_pad_index(tuner, true,
767 PAD_SIGNAL_ANALOG);
768 if (pad_sink < 0)
769 return -EINVAL;
770 ret = media_create_pad_links(mdev,
771 MEDIA_ENT_F_CONN_RF,
772 conn, 0,
773 MEDIA_ENT_F_TUNER,
774 tuner, pad_sink,
775 MEDIA_LNK_FL_ENABLED,
776 false);
777 }
778 if (ret)
779 return ret;
780 }
781
782 if (ntuner && ndemod) {
783 /* NOTE: first found tuner source pad presumed correct */
784 pad_source = media_get_pad_index(tuner, false,
785 PAD_SIGNAL_ANALOG);
786 if (pad_source < 0)
787 return -EINVAL;
788 ret = media_create_pad_links(mdev,
789 MEDIA_ENT_F_TUNER,
790 tuner, pad_source,
791 MEDIA_ENT_F_DTV_DEMOD,
792 demod, 0, MEDIA_LNK_FL_ENABLED,
793 false);
794 if (ret)
795 return ret;
796 }
797
798 if (ndemod && demux) {
799 ret = media_create_pad_links(mdev,
800 MEDIA_ENT_F_DTV_DEMOD,
801 demod, 1,
802 MEDIA_ENT_F_TS_DEMUX,
803 demux, 0, MEDIA_LNK_FL_ENABLED,
804 false);
805 if (ret)
806 return ret;
807 }
808 if (demux && ca) {
809 ret = media_create_pad_link(demux, 1, ca,
810 0, MEDIA_LNK_FL_ENABLED);
811 if (ret)
812 return ret;
813 }
814
815 /* Create demux links for each ringbuffer/pad */
816 if (demux) {
817 media_device_for_each_entity(entity, mdev) {
818 if (entity->function == MEDIA_ENT_F_IO_DTV) {
819 if (!strncmp(entity->name, DVR_TSOUT,
820 strlen(DVR_TSOUT))) {
821 ret = media_create_pad_link(demux,
822 ++dvr_pad,
823 entity, 0, 0);
824 if (ret)
825 return ret;
826 }
827 if (!strncmp(entity->name, DEMUX_TSOUT,
828 strlen(DEMUX_TSOUT))) {
829 ret = media_create_pad_link(demux,
830 ++demux_pad,
831 entity, 0, 0);
832 if (ret)
833 return ret;
834 }
835 }
836 }
837 }
838
839 /* Create interface links for FE->tuner, DVR->demux and CA->ca */
840 media_device_for_each_intf(intf, mdev) {
841 if (intf->type == MEDIA_INTF_T_DVB_CA && ca) {
842 link = media_create_intf_link(ca, intf,
843 MEDIA_LNK_FL_ENABLED |
844 MEDIA_LNK_FL_IMMUTABLE);
845 if (!link)
846 return -ENOMEM;
847 }
848
849 if (intf->type == MEDIA_INTF_T_DVB_FE && tuner) {
850 link = media_create_intf_link(tuner, intf,
851 MEDIA_LNK_FL_ENABLED |
852 MEDIA_LNK_FL_IMMUTABLE);
853 if (!link)
854 return -ENOMEM;
855 }
856 #if 0
857 /*
858 * Indirect link - let's not create yet, as we don't know how
859 * to handle indirect links, nor if this will
860 * actually be needed.
861 */
862 if (intf->type == MEDIA_INTF_T_DVB_DVR && demux) {
863 link = media_create_intf_link(demux, intf,
864 MEDIA_LNK_FL_ENABLED |
865 MEDIA_LNK_FL_IMMUTABLE);
866 if (!link)
867 return -ENOMEM;
868 }
869 #endif
870 if (intf->type == MEDIA_INTF_T_DVB_DVR) {
871 ret = dvb_create_io_intf_links(adap, intf, DVR_TSOUT);
872 if (ret)
873 return ret;
874 }
875 if (intf->type == MEDIA_INTF_T_DVB_DEMUX) {
876 ret = dvb_create_io_intf_links(adap, intf, DEMUX_TSOUT);
877 if (ret)
878 return ret;
879 }
880 }
881 return 0;
882 }
883 EXPORT_SYMBOL_GPL(dvb_create_media_graph);
884 #endif
885
dvbdev_check_free_adapter_num(int num)886 static int dvbdev_check_free_adapter_num(int num)
887 {
888 struct list_head *entry;
889 list_for_each(entry, &dvb_adapter_list) {
890 struct dvb_adapter *adap;
891 adap = list_entry(entry, struct dvb_adapter, list_head);
892 if (adap->num == num)
893 return 0;
894 }
895 return 1;
896 }
897
dvbdev_get_free_adapter_num(void)898 static int dvbdev_get_free_adapter_num (void)
899 {
900 int num = 0;
901
902 while (num < DVB_MAX_ADAPTERS) {
903 if (dvbdev_check_free_adapter_num(num))
904 return num;
905 num++;
906 }
907
908 return -ENFILE;
909 }
910
911
dvb_register_adapter(struct dvb_adapter * adap,const char * name,struct module * module,struct device * device,short * adapter_nums)912 int dvb_register_adapter(struct dvb_adapter *adap, const char *name,
913 struct module *module, struct device *device,
914 short *adapter_nums)
915 {
916 int i, num;
917
918 mutex_lock(&dvbdev_register_lock);
919
920 for (i = 0; i < DVB_MAX_ADAPTERS; ++i) {
921 num = adapter_nums[i];
922 if (num >= 0 && num < DVB_MAX_ADAPTERS) {
923 /* use the one the driver asked for */
924 if (dvbdev_check_free_adapter_num(num))
925 break;
926 } else {
927 num = dvbdev_get_free_adapter_num();
928 break;
929 }
930 num = -1;
931 }
932
933 if (num < 0) {
934 mutex_unlock(&dvbdev_register_lock);
935 return -ENFILE;
936 }
937
938 memset (adap, 0, sizeof(struct dvb_adapter));
939 INIT_LIST_HEAD (&adap->device_list);
940
941 pr_info("DVB: registering new adapter (%s)\n", name);
942
943 adap->num = num;
944 adap->name = name;
945 adap->module = module;
946 adap->device = device;
947 adap->mfe_shared = 0;
948 adap->mfe_dvbdev = NULL;
949 mutex_init (&adap->mfe_lock);
950
951 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
952 mutex_init(&adap->mdev_lock);
953 #endif
954
955 list_add_tail (&adap->list_head, &dvb_adapter_list);
956
957 mutex_unlock(&dvbdev_register_lock);
958
959 return num;
960 }
961 EXPORT_SYMBOL(dvb_register_adapter);
962
963
dvb_unregister_adapter(struct dvb_adapter * adap)964 int dvb_unregister_adapter(struct dvb_adapter *adap)
965 {
966 mutex_lock(&dvbdev_register_lock);
967 list_del (&adap->list_head);
968 mutex_unlock(&dvbdev_register_lock);
969 return 0;
970 }
971 EXPORT_SYMBOL(dvb_unregister_adapter);
972
973 /* if the miracle happens and "generic_usercopy()" is included into
974 the kernel, then this can vanish. please don't make the mistake and
975 define this as video_usercopy(). this will introduce a dependency
976 to the v4l "videodev.o" module, which is unnecessary for some
977 cards (ie. the budget dvb-cards don't need the v4l module...) */
dvb_usercopy(struct file * file,unsigned int cmd,unsigned long arg,int (* func)(struct file * file,unsigned int cmd,void * arg))978 int dvb_usercopy(struct file *file,
979 unsigned int cmd, unsigned long arg,
980 int (*func)(struct file *file,
981 unsigned int cmd, void *arg))
982 {
983 char sbuf[128];
984 void *mbuf = NULL;
985 void *parg = NULL;
986 int err = -EINVAL;
987
988 /* Copy arguments into temp kernel buffer */
989 switch (_IOC_DIR(cmd)) {
990 case _IOC_NONE:
991 /*
992 * For this command, the pointer is actually an integer
993 * argument.
994 */
995 parg = (void *) arg;
996 break;
997 case _IOC_READ: /* some v4l ioctls are marked wrong ... */
998 case _IOC_WRITE:
999 case (_IOC_WRITE | _IOC_READ):
1000 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
1001 parg = sbuf;
1002 } else {
1003 /* too big to allocate from stack */
1004 mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
1005 if (NULL == mbuf)
1006 return -ENOMEM;
1007 parg = mbuf;
1008 }
1009
1010 err = -EFAULT;
1011 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
1012 goto out;
1013 break;
1014 }
1015
1016 /* call driver */
1017 if ((err = func(file, cmd, parg)) == -ENOIOCTLCMD)
1018 err = -ENOTTY;
1019
1020 if (err < 0)
1021 goto out;
1022
1023 /* Copy results into user buffer */
1024 switch (_IOC_DIR(cmd))
1025 {
1026 case _IOC_READ:
1027 case (_IOC_WRITE | _IOC_READ):
1028 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
1029 err = -EFAULT;
1030 break;
1031 }
1032
1033 out:
1034 kfree(mbuf);
1035 return err;
1036 }
1037
1038 #if IS_ENABLED(CONFIG_I2C)
dvb_module_probe(const char * module_name,const char * name,struct i2c_adapter * adap,unsigned char addr,void * platform_data)1039 struct i2c_client *dvb_module_probe(const char *module_name,
1040 const char *name,
1041 struct i2c_adapter *adap,
1042 unsigned char addr,
1043 void *platform_data)
1044 {
1045 struct i2c_client *client;
1046 struct i2c_board_info *board_info;
1047
1048 board_info = kzalloc(sizeof(*board_info), GFP_KERNEL);
1049 if (!board_info)
1050 return NULL;
1051
1052 if (name)
1053 strscpy(board_info->type, name, I2C_NAME_SIZE);
1054 else
1055 strscpy(board_info->type, module_name, I2C_NAME_SIZE);
1056
1057 board_info->addr = addr;
1058 board_info->platform_data = platform_data;
1059 request_module(module_name);
1060 client = i2c_new_client_device(adap, board_info);
1061 if (!i2c_client_has_driver(client)) {
1062 kfree(board_info);
1063 return NULL;
1064 }
1065
1066 if (!try_module_get(client->dev.driver->owner)) {
1067 i2c_unregister_device(client);
1068 client = NULL;
1069 }
1070
1071 kfree(board_info);
1072 return client;
1073 }
1074 EXPORT_SYMBOL_GPL(dvb_module_probe);
1075
dvb_module_release(struct i2c_client * client)1076 void dvb_module_release(struct i2c_client *client)
1077 {
1078 if (!client)
1079 return;
1080
1081 module_put(client->dev.driver->owner);
1082 i2c_unregister_device(client);
1083 }
1084 EXPORT_SYMBOL_GPL(dvb_module_release);
1085 #endif
1086
dvb_uevent(struct device * dev,struct kobj_uevent_env * env)1087 static int dvb_uevent(struct device *dev, struct kobj_uevent_env *env)
1088 {
1089 struct dvb_device *dvbdev = dev_get_drvdata(dev);
1090
1091 add_uevent_var(env, "DVB_ADAPTER_NUM=%d", dvbdev->adapter->num);
1092 add_uevent_var(env, "DVB_DEVICE_TYPE=%s", dnames[dvbdev->type]);
1093 add_uevent_var(env, "DVB_DEVICE_NUM=%d", dvbdev->id);
1094 return 0;
1095 }
1096
dvb_devnode(struct device * dev,umode_t * mode)1097 static char *dvb_devnode(struct device *dev, umode_t *mode)
1098 {
1099 struct dvb_device *dvbdev = dev_get_drvdata(dev);
1100
1101 return kasprintf(GFP_KERNEL, "dvb/adapter%d/%s%d",
1102 dvbdev->adapter->num, dnames[dvbdev->type], dvbdev->id);
1103 }
1104
1105
init_dvbdev(void)1106 static int __init init_dvbdev(void)
1107 {
1108 int retval;
1109 dev_t dev = MKDEV(DVB_MAJOR, 0);
1110
1111 if ((retval = register_chrdev_region(dev, MAX_DVB_MINORS, "DVB")) != 0) {
1112 pr_err("dvb-core: unable to get major %d\n", DVB_MAJOR);
1113 return retval;
1114 }
1115
1116 cdev_init(&dvb_device_cdev, &dvb_device_fops);
1117 if ((retval = cdev_add(&dvb_device_cdev, dev, MAX_DVB_MINORS)) != 0) {
1118 pr_err("dvb-core: unable register character device\n");
1119 goto error;
1120 }
1121
1122 dvb_class = class_create(THIS_MODULE, "dvb");
1123 if (IS_ERR(dvb_class)) {
1124 retval = PTR_ERR(dvb_class);
1125 goto error;
1126 }
1127 dvb_class->dev_uevent = dvb_uevent;
1128 dvb_class->devnode = dvb_devnode;
1129 return 0;
1130
1131 error:
1132 cdev_del(&dvb_device_cdev);
1133 unregister_chrdev_region(dev, MAX_DVB_MINORS);
1134 return retval;
1135 }
1136
1137
exit_dvbdev(void)1138 static void __exit exit_dvbdev(void)
1139 {
1140 struct dvbdevfops_node *node, *next;
1141
1142 class_destroy(dvb_class);
1143 cdev_del(&dvb_device_cdev);
1144 unregister_chrdev_region(MKDEV(DVB_MAJOR, 0), MAX_DVB_MINORS);
1145
1146 list_for_each_entry_safe(node, next, &dvbdevfops_list, list_head) {
1147 list_del (&node->list_head);
1148 kfree(node->fops);
1149 kfree(node);
1150 }
1151 }
1152
1153 subsys_initcall(init_dvbdev);
1154 module_exit(exit_dvbdev);
1155
1156 MODULE_DESCRIPTION("DVB Core Driver");
1157 MODULE_AUTHOR("Marcus Metzler, Ralph Metzler, Holger Waechtler");
1158 MODULE_LICENSE("GPL");
1159