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