Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: LGPL-2.1-or-later
0002 /*
0003  * dvbdev.c
0004  *
0005  * Copyright (C) 2000 Ralph  Metzler <ralph@convergence.de>
0006  *                  & Marcus Metzler <marcus@convergence.de>
0007  *                    for convergence integrated media GmbH
0008  */
0009 
0010 #define pr_fmt(fmt) "dvbdev: " fmt
0011 
0012 #include <linux/types.h>
0013 #include <linux/errno.h>
0014 #include <linux/string.h>
0015 #include <linux/module.h>
0016 #include <linux/kernel.h>
0017 #include <linux/i2c.h>
0018 #include <linux/init.h>
0019 #include <linux/slab.h>
0020 #include <linux/device.h>
0021 #include <linux/fs.h>
0022 #include <linux/cdev.h>
0023 #include <linux/mutex.h>
0024 #include <media/dvbdev.h>
0025 
0026 /* Due to enum tuner_pad_index */
0027 #include <media/tuner.h>
0028 
0029 static DEFINE_MUTEX(dvbdev_mutex);
0030 static int dvbdev_debug;
0031 
0032 module_param(dvbdev_debug, int, 0644);
0033 MODULE_PARM_DESC(dvbdev_debug, "Turn on/off device debugging (default:off).");
0034 
0035 #define dprintk(fmt, arg...) do {                   \
0036     if (dvbdev_debug)                       \
0037         printk(KERN_DEBUG pr_fmt("%s: " fmt),           \
0038                __func__, ##arg);                \
0039 } while (0)
0040 
0041 static LIST_HEAD(dvb_adapter_list);
0042 static DEFINE_MUTEX(dvbdev_register_lock);
0043 
0044 static const char * const dnames[] = {
0045     [DVB_DEVICE_VIDEO] =        "video",
0046     [DVB_DEVICE_AUDIO] =        "audio",
0047     [DVB_DEVICE_SEC] =      "sec",
0048     [DVB_DEVICE_FRONTEND] =     "frontend",
0049     [DVB_DEVICE_DEMUX] =        "demux",
0050     [DVB_DEVICE_DVR] =      "dvr",
0051     [DVB_DEVICE_CA] =       "ca",
0052     [DVB_DEVICE_NET] =      "net",
0053     [DVB_DEVICE_OSD] =      "osd"
0054 };
0055 
0056 #ifdef CONFIG_DVB_DYNAMIC_MINORS
0057 #define MAX_DVB_MINORS      256
0058 #define DVB_MAX_IDS     MAX_DVB_MINORS
0059 #else
0060 #define DVB_MAX_IDS     4
0061 
0062 static const u8 minor_type[] = {
0063        [DVB_DEVICE_VIDEO]      = 0,
0064        [DVB_DEVICE_AUDIO]      = 1,
0065        [DVB_DEVICE_SEC]        = 2,
0066        [DVB_DEVICE_FRONTEND]   = 3,
0067        [DVB_DEVICE_DEMUX]      = 4,
0068        [DVB_DEVICE_DVR]        = 5,
0069        [DVB_DEVICE_CA]         = 6,
0070        [DVB_DEVICE_NET]        = 7,
0071        [DVB_DEVICE_OSD]        = 8,
0072 };
0073 
0074 #define nums2minor(num, type, id) \
0075        (((num) << 6) | ((id) << 4) | minor_type[type])
0076 
0077 #define MAX_DVB_MINORS      (DVB_MAX_ADAPTERS*64)
0078 #endif
0079 
0080 static struct class *dvb_class;
0081 
0082 static struct dvb_device *dvb_minors[MAX_DVB_MINORS];
0083 static DECLARE_RWSEM(minor_rwsem);
0084 
0085 static int dvb_device_open(struct inode *inode, struct file *file)
0086 {
0087     struct dvb_device *dvbdev;
0088 
0089     mutex_lock(&dvbdev_mutex);
0090     down_read(&minor_rwsem);
0091     dvbdev = dvb_minors[iminor(inode)];
0092 
0093     if (dvbdev && dvbdev->fops) {
0094         int err = 0;
0095         const struct file_operations *new_fops;
0096 
0097         new_fops = fops_get(dvbdev->fops);
0098         if (!new_fops)
0099             goto fail;
0100         file->private_data = dvbdev;
0101         replace_fops(file, new_fops);
0102         if (file->f_op->open)
0103             err = file->f_op->open(inode, file);
0104         up_read(&minor_rwsem);
0105         mutex_unlock(&dvbdev_mutex);
0106         return err;
0107     }
0108 fail:
0109     up_read(&minor_rwsem);
0110     mutex_unlock(&dvbdev_mutex);
0111     return -ENODEV;
0112 }
0113 
0114 
0115 static const struct file_operations dvb_device_fops =
0116 {
0117     .owner =    THIS_MODULE,
0118     .open =     dvb_device_open,
0119     .llseek =   noop_llseek,
0120 };
0121 
0122 static struct cdev dvb_device_cdev;
0123 
0124 int dvb_generic_open(struct inode *inode, struct file *file)
0125 {
0126     struct dvb_device *dvbdev = file->private_data;
0127 
0128     if (!dvbdev)
0129         return -ENODEV;
0130 
0131     if (!dvbdev->users)
0132         return -EBUSY;
0133 
0134     if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
0135         if (!dvbdev->readers)
0136             return -EBUSY;
0137         dvbdev->readers--;
0138     } else {
0139         if (!dvbdev->writers)
0140             return -EBUSY;
0141         dvbdev->writers--;
0142     }
0143 
0144     dvbdev->users--;
0145     return 0;
0146 }
0147 EXPORT_SYMBOL(dvb_generic_open);
0148 
0149 
0150 int dvb_generic_release(struct inode *inode, struct file *file)
0151 {
0152     struct dvb_device *dvbdev = file->private_data;
0153 
0154     if (!dvbdev)
0155         return -ENODEV;
0156 
0157     if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
0158         dvbdev->readers++;
0159     } else {
0160         dvbdev->writers++;
0161     }
0162 
0163     dvbdev->users++;
0164     return 0;
0165 }
0166 EXPORT_SYMBOL(dvb_generic_release);
0167 
0168 
0169 long dvb_generic_ioctl(struct file *file,
0170                unsigned int cmd, unsigned long arg)
0171 {
0172     struct dvb_device *dvbdev = file->private_data;
0173 
0174     if (!dvbdev)
0175         return -ENODEV;
0176 
0177     if (!dvbdev->kernel_ioctl)
0178         return -EINVAL;
0179 
0180     return dvb_usercopy(file, cmd, arg, dvbdev->kernel_ioctl);
0181 }
0182 EXPORT_SYMBOL(dvb_generic_ioctl);
0183 
0184 
0185 static int dvbdev_get_free_id (struct dvb_adapter *adap, int type)
0186 {
0187     u32 id = 0;
0188 
0189     while (id < DVB_MAX_IDS) {
0190         struct dvb_device *dev;
0191         list_for_each_entry(dev, &adap->device_list, list_head)
0192             if (dev->type == type && dev->id == id)
0193                 goto skip;
0194         return id;
0195 skip:
0196         id++;
0197     }
0198     return -ENFILE;
0199 }
0200 
0201 static void dvb_media_device_free(struct dvb_device *dvbdev)
0202 {
0203 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
0204     if (dvbdev->entity) {
0205         media_device_unregister_entity(dvbdev->entity);
0206         kfree(dvbdev->entity);
0207         kfree(dvbdev->pads);
0208         dvbdev->entity = NULL;
0209         dvbdev->pads = NULL;
0210     }
0211 
0212     if (dvbdev->tsout_entity) {
0213         int i;
0214 
0215         for (i = 0; i < dvbdev->tsout_num_entities; i++) {
0216             media_device_unregister_entity(&dvbdev->tsout_entity[i]);
0217             kfree(dvbdev->tsout_entity[i].name);
0218         }
0219         kfree(dvbdev->tsout_entity);
0220         kfree(dvbdev->tsout_pads);
0221         dvbdev->tsout_entity = NULL;
0222         dvbdev->tsout_pads = NULL;
0223 
0224         dvbdev->tsout_num_entities = 0;
0225     }
0226 
0227     if (dvbdev->intf_devnode) {
0228         media_devnode_remove(dvbdev->intf_devnode);
0229         dvbdev->intf_devnode = NULL;
0230     }
0231 
0232     if (dvbdev->adapter->conn) {
0233         media_device_unregister_entity(dvbdev->adapter->conn);
0234         kfree(dvbdev->adapter->conn);
0235         dvbdev->adapter->conn = NULL;
0236         kfree(dvbdev->adapter->conn_pads);
0237         dvbdev->adapter->conn_pads = NULL;
0238     }
0239 #endif
0240 }
0241 
0242 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
0243 static int dvb_create_tsout_entity(struct dvb_device *dvbdev,
0244                     const char *name, int npads)
0245 {
0246     int i, ret = 0;
0247 
0248     dvbdev->tsout_pads = kcalloc(npads, sizeof(*dvbdev->tsout_pads),
0249                      GFP_KERNEL);
0250     if (!dvbdev->tsout_pads)
0251         return -ENOMEM;
0252 
0253     dvbdev->tsout_entity = kcalloc(npads, sizeof(*dvbdev->tsout_entity),
0254                        GFP_KERNEL);
0255     if (!dvbdev->tsout_entity)
0256         return -ENOMEM;
0257 
0258     dvbdev->tsout_num_entities = npads;
0259 
0260     for (i = 0; i < npads; i++) {
0261         struct media_pad *pads = &dvbdev->tsout_pads[i];
0262         struct media_entity *entity = &dvbdev->tsout_entity[i];
0263 
0264         entity->name = kasprintf(GFP_KERNEL, "%s #%d", name, i);
0265         if (!entity->name)
0266             return -ENOMEM;
0267 
0268         entity->function = MEDIA_ENT_F_IO_DTV;
0269         pads->flags = MEDIA_PAD_FL_SINK;
0270 
0271         ret = media_entity_pads_init(entity, 1, pads);
0272         if (ret < 0)
0273             return ret;
0274 
0275         ret = media_device_register_entity(dvbdev->adapter->mdev,
0276                            entity);
0277         if (ret < 0)
0278             return ret;
0279     }
0280     return 0;
0281 }
0282 
0283 #define DEMUX_TSOUT "demux-tsout"
0284 #define DVR_TSOUT   "dvr-tsout"
0285 
0286 static int dvb_create_media_entity(struct dvb_device *dvbdev,
0287                    int type, int demux_sink_pads)
0288 {
0289     int i, ret, npads;
0290 
0291     switch (type) {
0292     case DVB_DEVICE_FRONTEND:
0293         npads = 2;
0294         break;
0295     case DVB_DEVICE_DVR:
0296         ret = dvb_create_tsout_entity(dvbdev, DVR_TSOUT,
0297                           demux_sink_pads);
0298         return ret;
0299     case DVB_DEVICE_DEMUX:
0300         npads = 1 + demux_sink_pads;
0301         ret = dvb_create_tsout_entity(dvbdev, DEMUX_TSOUT,
0302                           demux_sink_pads);
0303         if (ret < 0)
0304             return ret;
0305         break;
0306     case DVB_DEVICE_CA:
0307         npads = 2;
0308         break;
0309     case DVB_DEVICE_NET:
0310         /*
0311          * We should be creating entities for the MPE/ULE
0312          * decapsulation hardware (or software implementation).
0313          *
0314          * However, the number of for the MPE/ULE decaps may not be
0315          * fixed. As we don't have yet dynamic support for PADs at
0316          * the Media Controller, let's not create the decap
0317          * entities yet.
0318          */
0319         return 0;
0320     default:
0321         return 0;
0322     }
0323 
0324     dvbdev->entity = kzalloc(sizeof(*dvbdev->entity), GFP_KERNEL);
0325     if (!dvbdev->entity)
0326         return -ENOMEM;
0327 
0328     dvbdev->entity->name = dvbdev->name;
0329 
0330     if (npads) {
0331         dvbdev->pads = kcalloc(npads, sizeof(*dvbdev->pads),
0332                        GFP_KERNEL);
0333         if (!dvbdev->pads) {
0334             kfree(dvbdev->entity);
0335             return -ENOMEM;
0336         }
0337     }
0338 
0339     switch (type) {
0340     case DVB_DEVICE_FRONTEND:
0341         dvbdev->entity->function = MEDIA_ENT_F_DTV_DEMOD;
0342         dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
0343         dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE;
0344         break;
0345     case DVB_DEVICE_DEMUX:
0346         dvbdev->entity->function = MEDIA_ENT_F_TS_DEMUX;
0347         dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
0348         for (i = 1; i < npads; i++)
0349             dvbdev->pads[i].flags = MEDIA_PAD_FL_SOURCE;
0350         break;
0351     case DVB_DEVICE_CA:
0352         dvbdev->entity->function = MEDIA_ENT_F_DTV_CA;
0353         dvbdev->pads[0].flags = MEDIA_PAD_FL_SINK;
0354         dvbdev->pads[1].flags = MEDIA_PAD_FL_SOURCE;
0355         break;
0356     default:
0357         /* Should never happen, as the first switch prevents it */
0358         kfree(dvbdev->entity);
0359         kfree(dvbdev->pads);
0360         dvbdev->entity = NULL;
0361         dvbdev->pads = NULL;
0362         return 0;
0363     }
0364 
0365     if (npads) {
0366         ret = media_entity_pads_init(dvbdev->entity, npads, dvbdev->pads);
0367         if (ret)
0368             return ret;
0369     }
0370     ret = media_device_register_entity(dvbdev->adapter->mdev,
0371                        dvbdev->entity);
0372     if (ret)
0373         return ret;
0374 
0375     pr_info("%s: media entity '%s' registered.\n",
0376         __func__, dvbdev->entity->name);
0377 
0378     return 0;
0379 }
0380 #endif
0381 
0382 static int dvb_register_media_device(struct dvb_device *dvbdev,
0383                      int type, int minor,
0384                      unsigned demux_sink_pads)
0385 {
0386 #if defined(CONFIG_MEDIA_CONTROLLER_DVB)
0387     struct media_link *link;
0388     u32 intf_type;
0389     int ret;
0390 
0391     if (!dvbdev->adapter->mdev)
0392         return 0;
0393 
0394     ret = dvb_create_media_entity(dvbdev, type, demux_sink_pads);
0395     if (ret)
0396         return ret;
0397 
0398     switch (type) {
0399     case DVB_DEVICE_FRONTEND:
0400         intf_type = MEDIA_INTF_T_DVB_FE;
0401         break;
0402     case DVB_DEVICE_DEMUX:
0403         intf_type = MEDIA_INTF_T_DVB_DEMUX;
0404         break;
0405     case DVB_DEVICE_DVR:
0406         intf_type = MEDIA_INTF_T_DVB_DVR;
0407         break;
0408     case DVB_DEVICE_CA:
0409         intf_type = MEDIA_INTF_T_DVB_CA;
0410         break;
0411     case DVB_DEVICE_NET:
0412         intf_type = MEDIA_INTF_T_DVB_NET;
0413         break;
0414     default:
0415         return 0;
0416     }
0417 
0418     dvbdev->intf_devnode = media_devnode_create(dvbdev->adapter->mdev,
0419                             intf_type, 0,
0420                             DVB_MAJOR, minor);
0421 
0422     if (!dvbdev->intf_devnode)
0423         return -ENOMEM;
0424 
0425     /*
0426      * Create the "obvious" link, e. g. the ones that represent
0427      * a direct association between an interface and an entity.
0428      * Other links should be created elsewhere, like:
0429      *      DVB FE intf    -> tuner
0430      *      DVB demux intf -> dvr
0431      */
0432 
0433     if (!dvbdev->entity)
0434         return 0;
0435 
0436     link = media_create_intf_link(dvbdev->entity,
0437                       &dvbdev->intf_devnode->intf,
0438                       MEDIA_LNK_FL_ENABLED |
0439                       MEDIA_LNK_FL_IMMUTABLE);
0440     if (!link)
0441         return -ENOMEM;
0442 #endif
0443     return 0;
0444 }
0445 
0446 int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
0447             const struct dvb_device *template, void *priv,
0448             enum dvb_device_type type, int demux_sink_pads)
0449 {
0450     struct dvb_device *dvbdev;
0451     struct file_operations *dvbdevfops;
0452     struct device *clsdev;
0453     int minor;
0454     int id, ret;
0455 
0456     mutex_lock(&dvbdev_register_lock);
0457 
0458     if ((id = dvbdev_get_free_id (adap, type)) < 0){
0459         mutex_unlock(&dvbdev_register_lock);
0460         *pdvbdev = NULL;
0461         pr_err("%s: couldn't find free device id\n", __func__);
0462         return -ENFILE;
0463     }
0464 
0465     *pdvbdev = dvbdev = kzalloc(sizeof(*dvbdev), GFP_KERNEL);
0466 
0467     if (!dvbdev){
0468         mutex_unlock(&dvbdev_register_lock);
0469         return -ENOMEM;
0470     }
0471 
0472     dvbdevfops = kmemdup(template->fops, sizeof(*dvbdevfops), GFP_KERNEL);
0473 
0474     if (!dvbdevfops){
0475         kfree (dvbdev);
0476         mutex_unlock(&dvbdev_register_lock);
0477         return -ENOMEM;
0478     }
0479 
0480     memcpy(dvbdev, template, sizeof(struct dvb_device));
0481     dvbdev->type = type;
0482     dvbdev->id = id;
0483     dvbdev->adapter = adap;
0484     dvbdev->priv = priv;
0485     dvbdev->fops = dvbdevfops;
0486     init_waitqueue_head (&dvbdev->wait_queue);
0487 
0488     dvbdevfops->owner = adap->module;
0489 
0490     list_add_tail (&dvbdev->list_head, &adap->device_list);
0491 
0492     down_write(&minor_rwsem);
0493 #ifdef CONFIG_DVB_DYNAMIC_MINORS
0494     for (minor = 0; minor < MAX_DVB_MINORS; minor++)
0495         if (dvb_minors[minor] == NULL)
0496             break;
0497 
0498     if (minor == MAX_DVB_MINORS) {
0499         list_del (&dvbdev->list_head);
0500         kfree(dvbdevfops);
0501         kfree(dvbdev);
0502         up_write(&minor_rwsem);
0503         mutex_unlock(&dvbdev_register_lock);
0504         return -EINVAL;
0505     }
0506 #else
0507     minor = nums2minor(adap->num, type, id);
0508 #endif
0509 
0510     dvbdev->minor = minor;
0511     dvb_minors[minor] = dvbdev;
0512     up_write(&minor_rwsem);
0513 
0514     ret = dvb_register_media_device(dvbdev, type, minor, demux_sink_pads);
0515     if (ret) {
0516         pr_err("%s: dvb_register_media_device failed to create the mediagraph\n",
0517               __func__);
0518 
0519         dvb_media_device_free(dvbdev);
0520         list_del (&dvbdev->list_head);
0521         kfree(dvbdevfops);
0522         kfree(dvbdev);
0523         mutex_unlock(&dvbdev_register_lock);
0524         return ret;
0525     }
0526 
0527     mutex_unlock(&dvbdev_register_lock);
0528 
0529     clsdev = device_create(dvb_class, adap->device,
0530                    MKDEV(DVB_MAJOR, minor),
0531                    dvbdev, "dvb%d.%s%d", adap->num, dnames[type], id);
0532     if (IS_ERR(clsdev)) {
0533         pr_err("%s: failed to create device dvb%d.%s%d (%ld)\n",
0534                __func__, adap->num, dnames[type], id, PTR_ERR(clsdev));
0535         dvb_media_device_free(dvbdev);
0536         list_del (&dvbdev->list_head);
0537         kfree(dvbdevfops);
0538         kfree(dvbdev);
0539         return PTR_ERR(clsdev);
0540     }
0541     dprintk("DVB: register adapter%d/%s%d @ minor: %i (0x%02x)\n",
0542         adap->num, dnames[type], id, minor, minor);
0543 
0544     return 0;
0545 }
0546 EXPORT_SYMBOL(dvb_register_device);
0547 
0548 
0549 void dvb_remove_device(struct dvb_device *dvbdev)
0550 {
0551     if (!dvbdev)
0552         return;
0553 
0554     down_write(&minor_rwsem);
0555     dvb_minors[dvbdev->minor] = NULL;
0556     up_write(&minor_rwsem);
0557 
0558     dvb_media_device_free(dvbdev);
0559 
0560     device_destroy(dvb_class, MKDEV(DVB_MAJOR, dvbdev->minor));
0561 
0562     list_del (&dvbdev->list_head);
0563 }
0564 EXPORT_SYMBOL(dvb_remove_device);
0565 
0566 
0567 void dvb_free_device(struct dvb_device *dvbdev)
0568 {
0569     if (!dvbdev)
0570         return;
0571 
0572     kfree (dvbdev->fops);
0573     kfree (dvbdev);
0574 }
0575 EXPORT_SYMBOL(dvb_free_device);
0576 
0577 
0578 void dvb_unregister_device(struct dvb_device *dvbdev)
0579 {
0580     dvb_remove_device(dvbdev);
0581     dvb_free_device(dvbdev);
0582 }
0583 EXPORT_SYMBOL(dvb_unregister_device);
0584 
0585 
0586 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0587 
0588 static int dvb_create_io_intf_links(struct dvb_adapter *adap,
0589                     struct media_interface *intf,
0590                     char *name)
0591 {
0592     struct media_device *mdev = adap->mdev;
0593     struct media_entity *entity;
0594     struct media_link *link;
0595 
0596     media_device_for_each_entity(entity, mdev) {
0597         if (entity->function == MEDIA_ENT_F_IO_DTV) {
0598             if (strncmp(entity->name, name, strlen(name)))
0599                 continue;
0600             link = media_create_intf_link(entity, intf,
0601                               MEDIA_LNK_FL_ENABLED |
0602                               MEDIA_LNK_FL_IMMUTABLE);
0603             if (!link)
0604                 return -ENOMEM;
0605         }
0606     }
0607     return 0;
0608 }
0609 
0610 int dvb_create_media_graph(struct dvb_adapter *adap,
0611                bool create_rf_connector)
0612 {
0613     struct media_device *mdev = adap->mdev;
0614     struct media_entity *entity, *tuner = NULL, *demod = NULL, *conn;
0615     struct media_entity *demux = NULL, *ca = NULL;
0616     struct media_link *link;
0617     struct media_interface *intf;
0618     unsigned demux_pad = 0;
0619     unsigned dvr_pad = 0;
0620     unsigned ntuner = 0, ndemod = 0;
0621     int ret, pad_source, pad_sink;
0622     static const char *connector_name = "Television";
0623 
0624     if (!mdev)
0625         return 0;
0626 
0627     media_device_for_each_entity(entity, mdev) {
0628         switch (entity->function) {
0629         case MEDIA_ENT_F_TUNER:
0630             tuner = entity;
0631             ntuner++;
0632             break;
0633         case MEDIA_ENT_F_DTV_DEMOD:
0634             demod = entity;
0635             ndemod++;
0636             break;
0637         case MEDIA_ENT_F_TS_DEMUX:
0638             demux = entity;
0639             break;
0640         case MEDIA_ENT_F_DTV_CA:
0641             ca = entity;
0642             break;
0643         }
0644     }
0645 
0646     /*
0647      * Prepare to signalize to media_create_pad_links() that multiple
0648      * entities of the same type exists and a 1:n or n:1 links need to be
0649      * created.
0650      * NOTE: if both tuner and demod have multiple instances, it is up
0651      * to the caller driver to create such links.
0652      */
0653     if (ntuner > 1)
0654         tuner = NULL;
0655     if (ndemod > 1)
0656         demod = NULL;
0657 
0658     if (create_rf_connector) {
0659         conn = kzalloc(sizeof(*conn), GFP_KERNEL);
0660         if (!conn)
0661             return -ENOMEM;
0662         adap->conn = conn;
0663 
0664         adap->conn_pads = kzalloc(sizeof(*adap->conn_pads), GFP_KERNEL);
0665         if (!adap->conn_pads)
0666             return -ENOMEM;
0667 
0668         conn->flags = MEDIA_ENT_FL_CONNECTOR;
0669         conn->function = MEDIA_ENT_F_CONN_RF;
0670         conn->name = connector_name;
0671         adap->conn_pads->flags = MEDIA_PAD_FL_SOURCE;
0672 
0673         ret = media_entity_pads_init(conn, 1, adap->conn_pads);
0674         if (ret)
0675             return ret;
0676 
0677         ret = media_device_register_entity(mdev, conn);
0678         if (ret)
0679             return ret;
0680 
0681         if (!ntuner) {
0682             ret = media_create_pad_links(mdev,
0683                              MEDIA_ENT_F_CONN_RF,
0684                              conn, 0,
0685                              MEDIA_ENT_F_DTV_DEMOD,
0686                              demod, 0,
0687                              MEDIA_LNK_FL_ENABLED,
0688                              false);
0689         } else {
0690             pad_sink = media_get_pad_index(tuner, true,
0691                                PAD_SIGNAL_ANALOG);
0692             if (pad_sink < 0)
0693                 return -EINVAL;
0694             ret = media_create_pad_links(mdev,
0695                              MEDIA_ENT_F_CONN_RF,
0696                              conn, 0,
0697                              MEDIA_ENT_F_TUNER,
0698                              tuner, pad_sink,
0699                              MEDIA_LNK_FL_ENABLED,
0700                              false);
0701         }
0702         if (ret)
0703             return ret;
0704     }
0705 
0706     if (ntuner && ndemod) {
0707         /* NOTE: first found tuner source pad presumed correct */
0708         pad_source = media_get_pad_index(tuner, false,
0709                          PAD_SIGNAL_ANALOG);
0710         if (pad_source < 0)
0711             return -EINVAL;
0712         ret = media_create_pad_links(mdev,
0713                          MEDIA_ENT_F_TUNER,
0714                          tuner, pad_source,
0715                          MEDIA_ENT_F_DTV_DEMOD,
0716                          demod, 0, MEDIA_LNK_FL_ENABLED,
0717                          false);
0718         if (ret)
0719             return ret;
0720     }
0721 
0722     if (ndemod && demux) {
0723         ret = media_create_pad_links(mdev,
0724                          MEDIA_ENT_F_DTV_DEMOD,
0725                          demod, 1,
0726                          MEDIA_ENT_F_TS_DEMUX,
0727                          demux, 0, MEDIA_LNK_FL_ENABLED,
0728                          false);
0729         if (ret)
0730             return ret;
0731     }
0732     if (demux && ca) {
0733         ret = media_create_pad_link(demux, 1, ca,
0734                         0, MEDIA_LNK_FL_ENABLED);
0735         if (ret)
0736             return ret;
0737     }
0738 
0739     /* Create demux links for each ringbuffer/pad */
0740     if (demux) {
0741         media_device_for_each_entity(entity, mdev) {
0742             if (entity->function == MEDIA_ENT_F_IO_DTV) {
0743                 if (!strncmp(entity->name, DVR_TSOUT,
0744                     strlen(DVR_TSOUT))) {
0745                     ret = media_create_pad_link(demux,
0746                                 ++dvr_pad,
0747                                 entity, 0, 0);
0748                     if (ret)
0749                         return ret;
0750                 }
0751                 if (!strncmp(entity->name, DEMUX_TSOUT,
0752                     strlen(DEMUX_TSOUT))) {
0753                     ret = media_create_pad_link(demux,
0754                                   ++demux_pad,
0755                                 entity, 0, 0);
0756                     if (ret)
0757                         return ret;
0758                 }
0759             }
0760         }
0761     }
0762 
0763     /* Create interface links for FE->tuner, DVR->demux and CA->ca */
0764     media_device_for_each_intf(intf, mdev) {
0765         if (intf->type == MEDIA_INTF_T_DVB_CA && ca) {
0766             link = media_create_intf_link(ca, intf,
0767                               MEDIA_LNK_FL_ENABLED |
0768                               MEDIA_LNK_FL_IMMUTABLE);
0769             if (!link)
0770                 return -ENOMEM;
0771         }
0772 
0773         if (intf->type == MEDIA_INTF_T_DVB_FE && tuner) {
0774             link = media_create_intf_link(tuner, intf,
0775                               MEDIA_LNK_FL_ENABLED |
0776                               MEDIA_LNK_FL_IMMUTABLE);
0777             if (!link)
0778                 return -ENOMEM;
0779         }
0780 #if 0
0781         /*
0782          * Indirect link - let's not create yet, as we don't know how
0783          *         to handle indirect links, nor if this will
0784          *         actually be needed.
0785          */
0786         if (intf->type == MEDIA_INTF_T_DVB_DVR && demux) {
0787             link = media_create_intf_link(demux, intf,
0788                               MEDIA_LNK_FL_ENABLED |
0789                               MEDIA_LNK_FL_IMMUTABLE);
0790             if (!link)
0791                 return -ENOMEM;
0792         }
0793 #endif
0794         if (intf->type == MEDIA_INTF_T_DVB_DVR) {
0795             ret = dvb_create_io_intf_links(adap, intf, DVR_TSOUT);
0796             if (ret)
0797                 return ret;
0798         }
0799         if (intf->type == MEDIA_INTF_T_DVB_DEMUX) {
0800             ret = dvb_create_io_intf_links(adap, intf, DEMUX_TSOUT);
0801             if (ret)
0802                 return ret;
0803         }
0804     }
0805     return 0;
0806 }
0807 EXPORT_SYMBOL_GPL(dvb_create_media_graph);
0808 #endif
0809 
0810 static int dvbdev_check_free_adapter_num(int num)
0811 {
0812     struct list_head *entry;
0813     list_for_each(entry, &dvb_adapter_list) {
0814         struct dvb_adapter *adap;
0815         adap = list_entry(entry, struct dvb_adapter, list_head);
0816         if (adap->num == num)
0817             return 0;
0818     }
0819     return 1;
0820 }
0821 
0822 static int dvbdev_get_free_adapter_num (void)
0823 {
0824     int num = 0;
0825 
0826     while (num < DVB_MAX_ADAPTERS) {
0827         if (dvbdev_check_free_adapter_num(num))
0828             return num;
0829         num++;
0830     }
0831 
0832     return -ENFILE;
0833 }
0834 
0835 
0836 int dvb_register_adapter(struct dvb_adapter *adap, const char *name,
0837              struct module *module, struct device *device,
0838              short *adapter_nums)
0839 {
0840     int i, num;
0841 
0842     mutex_lock(&dvbdev_register_lock);
0843 
0844     for (i = 0; i < DVB_MAX_ADAPTERS; ++i) {
0845         num = adapter_nums[i];
0846         if (num >= 0  &&  num < DVB_MAX_ADAPTERS) {
0847         /* use the one the driver asked for */
0848             if (dvbdev_check_free_adapter_num(num))
0849                 break;
0850         } else {
0851             num = dvbdev_get_free_adapter_num();
0852             break;
0853         }
0854         num = -1;
0855     }
0856 
0857     if (num < 0) {
0858         mutex_unlock(&dvbdev_register_lock);
0859         return -ENFILE;
0860     }
0861 
0862     memset (adap, 0, sizeof(struct dvb_adapter));
0863     INIT_LIST_HEAD (&adap->device_list);
0864 
0865     pr_info("DVB: registering new adapter (%s)\n", name);
0866 
0867     adap->num = num;
0868     adap->name = name;
0869     adap->module = module;
0870     adap->device = device;
0871     adap->mfe_shared = 0;
0872     adap->mfe_dvbdev = NULL;
0873     mutex_init (&adap->mfe_lock);
0874 
0875 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
0876     mutex_init(&adap->mdev_lock);
0877 #endif
0878 
0879     list_add_tail (&adap->list_head, &dvb_adapter_list);
0880 
0881     mutex_unlock(&dvbdev_register_lock);
0882 
0883     return num;
0884 }
0885 EXPORT_SYMBOL(dvb_register_adapter);
0886 
0887 
0888 int dvb_unregister_adapter(struct dvb_adapter *adap)
0889 {
0890     mutex_lock(&dvbdev_register_lock);
0891     list_del (&adap->list_head);
0892     mutex_unlock(&dvbdev_register_lock);
0893     return 0;
0894 }
0895 EXPORT_SYMBOL(dvb_unregister_adapter);
0896 
0897 /* if the miracle happens and "generic_usercopy()" is included into
0898    the kernel, then this can vanish. please don't make the mistake and
0899    define this as video_usercopy(). this will introduce a dependency
0900    to the v4l "videodev.o" module, which is unnecessary for some
0901    cards (ie. the budget dvb-cards don't need the v4l module...) */
0902 int dvb_usercopy(struct file *file,
0903              unsigned int cmd, unsigned long arg,
0904              int (*func)(struct file *file,
0905              unsigned int cmd, void *arg))
0906 {
0907     char    sbuf[128];
0908     void    *mbuf = NULL;
0909     void    *parg = NULL;
0910     int     err  = -EINVAL;
0911 
0912     /*  Copy arguments into temp kernel buffer  */
0913     switch (_IOC_DIR(cmd)) {
0914     case _IOC_NONE:
0915         /*
0916          * For this command, the pointer is actually an integer
0917          * argument.
0918          */
0919         parg = (void *) arg;
0920         break;
0921     case _IOC_READ: /* some v4l ioctls are marked wrong ... */
0922     case _IOC_WRITE:
0923     case (_IOC_WRITE | _IOC_READ):
0924         if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
0925             parg = sbuf;
0926         } else {
0927             /* too big to allocate from stack */
0928             mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
0929             if (NULL == mbuf)
0930                 return -ENOMEM;
0931             parg = mbuf;
0932         }
0933 
0934         err = -EFAULT;
0935         if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
0936             goto out;
0937         break;
0938     }
0939 
0940     /* call driver */
0941     if ((err = func(file, cmd, parg)) == -ENOIOCTLCMD)
0942         err = -ENOTTY;
0943 
0944     if (err < 0)
0945         goto out;
0946 
0947     /*  Copy results into user buffer  */
0948     switch (_IOC_DIR(cmd))
0949     {
0950     case _IOC_READ:
0951     case (_IOC_WRITE | _IOC_READ):
0952         if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
0953             err = -EFAULT;
0954         break;
0955     }
0956 
0957 out:
0958     kfree(mbuf);
0959     return err;
0960 }
0961 
0962 #if IS_ENABLED(CONFIG_I2C)
0963 struct i2c_client *dvb_module_probe(const char *module_name,
0964                     const char *name,
0965                     struct i2c_adapter *adap,
0966                     unsigned char addr,
0967                     void *platform_data)
0968 {
0969     struct i2c_client *client;
0970     struct i2c_board_info *board_info;
0971 
0972     board_info = kzalloc(sizeof(*board_info), GFP_KERNEL);
0973     if (!board_info)
0974         return NULL;
0975 
0976     if (name)
0977         strscpy(board_info->type, name, I2C_NAME_SIZE);
0978     else
0979         strscpy(board_info->type, module_name, I2C_NAME_SIZE);
0980 
0981     board_info->addr = addr;
0982     board_info->platform_data = platform_data;
0983     request_module(module_name);
0984     client = i2c_new_client_device(adap, board_info);
0985     if (!i2c_client_has_driver(client)) {
0986         kfree(board_info);
0987         return NULL;
0988     }
0989 
0990     if (!try_module_get(client->dev.driver->owner)) {
0991         i2c_unregister_device(client);
0992         client = NULL;
0993     }
0994 
0995     kfree(board_info);
0996     return client;
0997 }
0998 EXPORT_SYMBOL_GPL(dvb_module_probe);
0999 
1000 void dvb_module_release(struct i2c_client *client)
1001 {
1002     if (!client)
1003         return;
1004 
1005     module_put(client->dev.driver->owner);
1006     i2c_unregister_device(client);
1007 }
1008 EXPORT_SYMBOL_GPL(dvb_module_release);
1009 #endif
1010 
1011 static int dvb_uevent(struct device *dev, struct kobj_uevent_env *env)
1012 {
1013     struct dvb_device *dvbdev = dev_get_drvdata(dev);
1014 
1015     add_uevent_var(env, "DVB_ADAPTER_NUM=%d", dvbdev->adapter->num);
1016     add_uevent_var(env, "DVB_DEVICE_TYPE=%s", dnames[dvbdev->type]);
1017     add_uevent_var(env, "DVB_DEVICE_NUM=%d", dvbdev->id);
1018     return 0;
1019 }
1020 
1021 static char *dvb_devnode(struct device *dev, umode_t *mode)
1022 {
1023     struct dvb_device *dvbdev = dev_get_drvdata(dev);
1024 
1025     return kasprintf(GFP_KERNEL, "dvb/adapter%d/%s%d",
1026         dvbdev->adapter->num, dnames[dvbdev->type], dvbdev->id);
1027 }
1028 
1029 
1030 static int __init init_dvbdev(void)
1031 {
1032     int retval;
1033     dev_t dev = MKDEV(DVB_MAJOR, 0);
1034 
1035     if ((retval = register_chrdev_region(dev, MAX_DVB_MINORS, "DVB")) != 0) {
1036         pr_err("dvb-core: unable to get major %d\n", DVB_MAJOR);
1037         return retval;
1038     }
1039 
1040     cdev_init(&dvb_device_cdev, &dvb_device_fops);
1041     if ((retval = cdev_add(&dvb_device_cdev, dev, MAX_DVB_MINORS)) != 0) {
1042         pr_err("dvb-core: unable register character device\n");
1043         goto error;
1044     }
1045 
1046     dvb_class = class_create(THIS_MODULE, "dvb");
1047     if (IS_ERR(dvb_class)) {
1048         retval = PTR_ERR(dvb_class);
1049         goto error;
1050     }
1051     dvb_class->dev_uevent = dvb_uevent;
1052     dvb_class->devnode = dvb_devnode;
1053     return 0;
1054 
1055 error:
1056     cdev_del(&dvb_device_cdev);
1057     unregister_chrdev_region(dev, MAX_DVB_MINORS);
1058     return retval;
1059 }
1060 
1061 
1062 static void __exit exit_dvbdev(void)
1063 {
1064     class_destroy(dvb_class);
1065     cdev_del(&dvb_device_cdev);
1066     unregister_chrdev_region(MKDEV(DVB_MAJOR, 0), MAX_DVB_MINORS);
1067 }
1068 
1069 subsys_initcall(init_dvbdev);
1070 module_exit(exit_dvbdev);
1071 
1072 MODULE_DESCRIPTION("DVB Core Driver");
1073 MODULE_AUTHOR("Marcus Metzler, Ralph Metzler, Holger Waechtler");
1074 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!