drivers/media/v4l2-core/v4l2-dev.c

   1 /*
   2  * Video capture interface for Linux version 2
   3  *
   4  *      A generic video device interface for the LINUX operating system
   5  *      using a set of device structures/vectors for low level operations.
   6  *
   7  *      This program is free software; you can redistribute it and/or
   8  *      modify it under the terms of the GNU General Public License
   9  *      as published by the Free Software Foundation; either version
  10  *      2 of the License, or (at your option) any later version.
  11  *
  12  * Authors:     Alan Cox, <alan@lxorguk.ukuu.org.uk> (version 1)
  13  *              Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
  14  *
  15  * Fixes:       20000516  Claudio Matsuoka <claudio@conectiva.com>
  16  *              - Added procfs support
  17  */
  18
  19 #include <linux/module.h>
  20 #include <linux/types.h>
  21 #include <linux/kernel.h>
  22 #include <linux/mm.h>
  23 #include <linux/string.h>
  24 #include <linux/errno.h>
  25 #include <linux/init.h>
  26 #include <linux/kmod.h>
  27 #include <linux/slab.h>
  28 #include <asm/uaccess.h>
  29
  30 #include <media/v4l2-common.h>
  31 #include <media/v4l2-device.h>
  32 #include <media/v4l2-ioctl.h>
  33
  34 #define VIDEO_NUM_DEVICES       256
  35 #define VIDEO_NAME              "video4linux"
  36
  37 /*
  38  *      sysfs stuff
  39  */
  40
  41 static ssize_t index_show(struct device *cd,
  42                           struct device_attribute *attr, char *buf)
  43 {
  44         struct video_device *vdev = to_video_device(cd);
  45
  46         return sprintf(buf, "%i\n", vdev->index);
  47 }
  48 static DEVICE_ATTR_RO(index);
  49
  50 static ssize_t debug_show(struct device *cd,
  51                           struct device_attribute *attr, char *buf)
  52 {
  53         struct video_device *vdev = to_video_device(cd);
  54
  55         return sprintf(buf, "%i\n", vdev->debug);
  56 }
  57
  58 static ssize_t debug_store(struct device *cd, struct device_attribute *attr,
  59                           const char *buf, size_t len)
  60 {
  61         struct video_device *vdev = to_video_device(cd);
  62         int res = 0;
  63         u16 value;
  64
  65         res = kstrtou16(buf, 0, &value);
  66         if (res)
  67                 return res;
  68
  69         vdev->debug = value;
  70         return len;
  71 }
  72 static DEVICE_ATTR_RW(debug);
  73
  74 static ssize_t name_show(struct device *cd,
  75                          struct device_attribute *attr, char *buf)
  76 {
  77         struct video_device *vdev = to_video_device(cd);
  78
  79         return sprintf(buf, "%.*s\n", (int)sizeof(vdev->name), vdev->name);
  80 }
  81 static DEVICE_ATTR_RO(name);
  82
  83 static struct attribute *video_device_attrs[] = {
  84         &dev_attr_name.attr,
  85         &dev_attr_debug.attr,
  86         &dev_attr_index.attr,
  87         NULL,
  88 };
  89 ATTRIBUTE_GROUPS(video_device);
  90
  91 /*
  92  *      Active devices
  93  */
  94 static struct video_device *video_device[VIDEO_NUM_DEVICES];
  95 static DEFINE_MUTEX(videodev_lock);
  96 static DECLARE_BITMAP(devnode_nums[VFL_TYPE_MAX], VIDEO_NUM_DEVICES);
  97
  98 /* Device node utility functions */
  99
 100 /* Note: these utility functions all assume that vfl_type is in the range
 101    [0, VFL_TYPE_MAX-1]. */
 102
 103 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
 104 /* Return the bitmap corresponding to vfl_type. */
 105 static inline unsigned long *devnode_bits(int vfl_type)
 106 {
 107         /* Any types not assigned to fixed minor ranges must be mapped to
 108            one single bitmap for the purposes of finding a free node number
 109            since all those unassigned types use the same minor range. */
 110         int idx = (vfl_type > VFL_TYPE_RADIO) ? VFL_TYPE_MAX - 1 : vfl_type;
 111
 112         return devnode_nums[idx];
 113 }
 114 #else
 115 /* Return the bitmap corresponding to vfl_type. */
 116 static inline unsigned long *devnode_bits(int vfl_type)
 117 {
 118         return devnode_nums[vfl_type];
 119 }
 120 #endif
 121
 122 /* Mark device node number vdev->num as used */
 123 static inline void devnode_set(struct video_device *vdev)
 124 {
 125         set_bit(vdev->num, devnode_bits(vdev->vfl_type));
 126 }
 127
 128 /* Mark device node number vdev->num as unused */
 129 static inline void devnode_clear(struct video_device *vdev)
 130 {
 131         clear_bit(vdev->num, devnode_bits(vdev->vfl_type));
 132 }
 133
 134 /* Try to find a free device node number in the range [from, to> */
 135 static inline int devnode_find(struct video_device *vdev, int from, int to)
 136 {
 137         return find_next_zero_bit(devnode_bits(vdev->vfl_type), to, from);
 138 }
 139
 140 struct video_device *video_device_alloc(void)
 141 {
 142         return kzalloc(sizeof(struct video_device), GFP_KERNEL);
 143 }
 144 EXPORT_SYMBOL(video_device_alloc);
 145
 146 void video_device_release(struct video_device *vdev)
 147 {
 148         kfree(vdev);
 149 }
 150 EXPORT_SYMBOL(video_device_release);
 151
 152 void video_device_release_empty(struct video_device *vdev)
 153 {
 154         /* Do nothing */
 155         /* Only valid when the video_device struct is a static. */
 156 }
 157 EXPORT_SYMBOL(video_device_release_empty);
 158
 159 static inline void video_get(struct video_device *vdev)
 160 {
 161         get_device(&vdev->dev);
 162 }
 163
 164 static inline void video_put(struct video_device *vdev)
 165 {
 166         put_device(&vdev->dev);
 167 }
 168
 169 /* Called when the last user of the video device exits. */
 170 static void v4l2_device_release(struct device *cd)
 171 {
 172         struct video_device *vdev = to_video_device(cd);
 173         struct v4l2_device *v4l2_dev = vdev->v4l2_dev;
 174
 175         mutex_lock(&videodev_lock);
 176         if (WARN_ON(video_device[vdev->minor] != vdev)) {
 177                 /* should not happen */
 178                 mutex_unlock(&videodev_lock);
 179                 return;
 180         }
 181
 182         /* Free up this device for reuse */
 183         video_device[vdev->minor] = NULL;
 184
 185         /* Delete the cdev on this minor as well */
 186         cdev_del(vdev->cdev);
 187         /* Just in case some driver tries to access this from
 188            the release() callback. */
 189         vdev->cdev = NULL;
 190
 191         /* Mark device node number as free */
 192         devnode_clear(vdev);
 193
 194         mutex_unlock(&videodev_lock);
 195
 196 #if defined(CONFIG_MEDIA_CONTROLLER)
 197         if (v4l2_dev && v4l2_dev->mdev &&
 198             vdev->vfl_type != VFL_TYPE_SUBDEV)
 199                 media_device_unregister_entity(&vdev->entity);
 200 #endif
 201
 202         /* Do not call v4l2_device_put if there is no release callback set.
 203          * Drivers that have no v4l2_device release callback might free the
 204          * v4l2_dev instance in the video_device release callback below, so we
 205          * must perform this check here.
 206          *
 207          * TODO: In the long run all drivers that use v4l2_device should use the
 208          * v4l2_device release callback. This check will then be unnecessary.
 209          */
 210         if (v4l2_dev && v4l2_dev->release == NULL)
 211                 v4l2_dev = NULL;
 212
 213         /* Release video_device and perform other
 214            cleanups as needed. */
 215         vdev->release(vdev);
 216
 217         /* Decrease v4l2_device refcount */
 218         if (v4l2_dev)
 219                 v4l2_device_put(v4l2_dev);
 220 }
 221
 222 static struct class video_class = {
 223         .name = VIDEO_NAME,
 224         .dev_groups = video_device_groups,
 225 };
 226
 227 struct video_device *video_devdata(struct file *file)
 228 {
 229         return video_device[iminor(file_inode(file))];
 230 }
 231 EXPORT_SYMBOL(video_devdata);
 232
 233
 234 /* Priority handling */
 235
 236 static inline bool prio_is_valid(enum v4l2_priority prio)
 237 {
 238         return prio == V4L2_PRIORITY_BACKGROUND ||
 239                prio == V4L2_PRIORITY_INTERACTIVE ||
 240                prio == V4L2_PRIORITY_RECORD;
 241 }
 242
 243 void v4l2_prio_init(struct v4l2_prio_state *global)
 244 {
 245         memset(global, 0, sizeof(*global));
 246 }
 247 EXPORT_SYMBOL(v4l2_prio_init);
 248
 249 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
 250                      enum v4l2_priority new)
 251 {
 252         if (!prio_is_valid(new))
 253                 return -EINVAL;
 254         if (*local == new)
 255                 return 0;
 256
 257         atomic_inc(&global->prios[new]);
 258         if (prio_is_valid(*local))
 259                 atomic_dec(&global->prios[*local]);
 260         *local = new;
 261         return 0;
 262 }
 263 EXPORT_SYMBOL(v4l2_prio_change);
 264
 265 void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
 266 {
 267         v4l2_prio_change(global, local, V4L2_PRIORITY_DEFAULT);
 268 }
 269 EXPORT_SYMBOL(v4l2_prio_open);
 270
 271 void v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority local)
 272 {
 273         if (prio_is_valid(local))
 274                 atomic_dec(&global->prios[local]);
 275 }
 276 EXPORT_SYMBOL(v4l2_prio_close);
 277
 278 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
 279 {
 280         if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
 281                 return V4L2_PRIORITY_RECORD;
 282         if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
 283                 return V4L2_PRIORITY_INTERACTIVE;
 284         if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
 285                 return V4L2_PRIORITY_BACKGROUND;
 286         return V4L2_PRIORITY_UNSET;
 287 }
 288 EXPORT_SYMBOL(v4l2_prio_max);
 289
 290 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local)
 291 {
 292         return (local < v4l2_prio_max(global)) ? -EBUSY : 0;
 293 }
 294 EXPORT_SYMBOL(v4l2_prio_check);
 295
 296
 297 static ssize_t v4l2_read(struct file *filp, char __user *buf,
 298                 size_t sz, loff_t *off)
 299 {
 300         struct video_device *vdev = video_devdata(filp);
 301         int ret = -ENODEV;
 302
 303         if (!vdev->fops->read)
 304                 return -EINVAL;
 305         if (video_is_registered(vdev))
 306                 ret = vdev->fops->read(filp, buf, sz, off);
 307         if (vdev->debug)
 308                 printk(KERN_DEBUG "%s: read: %zd (%d)\n",
 309                         video_device_node_name(vdev), sz, ret);
 310         return ret;
 311 }
 312
 313 static ssize_t v4l2_write(struct file *filp, const char __user *buf,
 314                 size_t sz, loff_t *off)
 315 {
 316         struct video_device *vdev = video_devdata(filp);
 317         int ret = -ENODEV;
 318
 319         if (!vdev->fops->write)
 320                 return -EINVAL;
 321         if (video_is_registered(vdev))
 322                 ret = vdev->fops->write(filp, buf, sz, off);
 323         if (vdev->debug)
 324                 printk(KERN_DEBUG "%s: write: %zd (%d)\n",
 325                         video_device_node_name(vdev), sz, ret);
 326         return ret;
 327 }
 328
 329 static unsigned int v4l2_poll(struct file *filp, struct poll_table_struct *poll)
 330 {
 331         struct video_device *vdev = video_devdata(filp);
 332         unsigned int res = POLLERR | POLLHUP;
 333
 334         if (!vdev->fops->poll)
 335                 return DEFAULT_POLLMASK;
 336         if (video_is_registered(vdev))
 337                 res = vdev->fops->poll(filp, poll);
 338         if (vdev->debug > 2)
 339                 printk(KERN_DEBUG "%s: poll: %08x\n",
 340                         video_device_node_name(vdev), res);
 341         return res;
 342 }
 343
 344 static long v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 345 {
 346         struct video_device *vdev = video_devdata(filp);
 347         int ret = -ENODEV;
 348
 349         if (vdev->fops->unlocked_ioctl) {
 350                 struct mutex *lock = v4l2_ioctl_get_lock(vdev, cmd);
 351
 352                 if (lock && mutex_lock_interruptible(lock))
 353                         return -ERESTARTSYS;
 354                 if (video_is_registered(vdev))
 355                         ret = vdev->fops->unlocked_ioctl(filp, cmd, arg);
 356                 if (lock)
 357                         mutex_unlock(lock);
 358         } else if (vdev->fops->ioctl) {
 359                 /* This code path is a replacement for the BKL. It is a major
 360                  * hack but it will have to do for those drivers that are not
 361                  * yet converted to use unlocked_ioctl.
 362                  *
 363                  * There are two options: if the driver implements struct
 364                  * v4l2_device, then the lock defined there is used to
 365                  * serialize the ioctls. Otherwise the v4l2 core lock defined
 366                  * below is used. This lock is really bad since it serializes
 367                  * completely independent devices.
 368                  *
 369                  * Both variants suffer from the same problem: if the driver
 370                  * sleeps, then it blocks all ioctls since the lock is still
 371                  * held. This is very common for VIDIOC_DQBUF since that
 372                  * normally waits for a frame to arrive. As a result any other
 373                  * ioctl calls will proceed very, very slowly since each call
 374                  * will have to wait for the VIDIOC_QBUF to finish. Things that
 375                  * should take 0.01s may now take 10-20 seconds.
 376                  *
 377                  * The workaround is to *not* take the lock for VIDIOC_DQBUF.
 378                  * This actually works OK for videobuf-based drivers, since
 379                  * videobuf will take its own internal lock.
 380                  */
 381                 static DEFINE_MUTEX(v4l2_ioctl_mutex);
 382                 struct mutex *m = vdev->v4l2_dev ?
 383                         &vdev->v4l2_dev->ioctl_lock : &v4l2_ioctl_mutex;
 384
 385                 if (cmd != VIDIOC_DQBUF && mutex_lock_interruptible(m))
 386                         return -ERESTARTSYS;
 387                 if (video_is_registered(vdev))
 388                         ret = vdev->fops->ioctl(filp, cmd, arg);
 389                 if (cmd != VIDIOC_DQBUF)
 390                         mutex_unlock(m);
 391         } else
 392                 ret = -ENOTTY;
 393
 394         return ret;
 395 }
 396
 397 #ifdef CONFIG_MMU
 398 #define v4l2_get_unmapped_area NULL
 399 #else
 400 static unsigned long v4l2_get_unmapped_area(struct file *filp,
 401                 unsigned long addr, unsigned long len, unsigned long pgoff,
 402                 unsigned long flags)
 403 {
 404         struct video_device *vdev = video_devdata(filp);
 405         int ret;
 406
 407         if (!vdev->fops->get_unmapped_area)
 408                 return -ENOSYS;
 409         if (!video_is_registered(vdev))
 410                 return -ENODEV;
 411         ret = vdev->fops->get_unmapped_area(filp, addr, len, pgoff, flags);
 412         if (vdev->debug)
 413                 printk(KERN_DEBUG "%s: get_unmapped_area (%d)\n",
 414                         video_device_node_name(vdev), ret);
 415         return ret;
 416 }
 417 #endif
 418
 419 static int v4l2_mmap(struct file *filp, struct vm_area_struct *vm)
 420 {
 421         struct video_device *vdev = video_devdata(filp);
 422         int ret = -ENODEV;
 423
 424         if (!vdev->fops->mmap)
 425                 return -ENODEV;
 426         if (video_is_registered(vdev))
 427                 ret = vdev->fops->mmap(filp, vm);
 428         if (vdev->debug)
 429                 printk(KERN_DEBUG "%s: mmap (%d)\n",
 430                         video_device_node_name(vdev), ret);
 431         return ret;
 432 }
 433
 434 /* Override for the open function */
 435 static int v4l2_open(struct inode *inode, struct file *filp)
 436 {
 437         struct video_device *vdev;
 438         int ret = 0;
 439
 440         /* Check if the video device is available */
 441         mutex_lock(&videodev_lock);
 442         vdev = video_devdata(filp);
 443         /* return ENODEV if the video device has already been removed. */
 444         if (vdev == NULL || !video_is_registered(vdev)) {
 445                 mutex_unlock(&videodev_lock);
 446                 return -ENODEV;
 447         }
 448         /* and increase the device refcount */
 449         video_get(vdev);
 450         mutex_unlock(&videodev_lock);
 451         if (vdev->fops->open) {
 452                 if (video_is_registered(vdev))
 453                         ret = vdev->fops->open(filp);
 454                 else
 455                         ret = -ENODEV;
 456         }
 457
 458         if (vdev->debug)
 459                 printk(KERN_DEBUG "%s: open (%d)\n",
 460                         video_device_node_name(vdev), ret);
 461         /* decrease the refcount in case of an error */
 462         if (ret)
 463                 video_put(vdev);
 464         return ret;
 465 }
 466
 467 /* Override for the release function */
 468 static int v4l2_release(struct inode *inode, struct file *filp)
 469 {
 470         struct video_device *vdev = video_devdata(filp);
 471         int ret = 0;
 472
 473         if (vdev->fops->release)
 474                 ret = vdev->fops->release(filp);
 475         if (vdev->debug)
 476                 printk(KERN_DEBUG "%s: release\n",
 477                         video_device_node_name(vdev));
 478
 479         /* decrease the refcount unconditionally since the release()
 480            return value is ignored. */
 481         video_put(vdev);
 482         return ret;
 483 }
 484
 485 static const struct file_operations v4l2_fops = {
 486         .owner = THIS_MODULE,
 487         .read = v4l2_read,
 488         .write = v4l2_write,
 489         .open = v4l2_open,
 490         .get_unmapped_area = v4l2_get_unmapped_area,
 491         .mmap = v4l2_mmap,
 492         .unlocked_ioctl = v4l2_ioctl,
 493 #ifdef CONFIG_COMPAT
 494         .compat_ioctl = v4l2_compat_ioctl32,
 495 #endif
 496         .release = v4l2_release,
 497         .poll = v4l2_poll,
 498         .llseek = no_llseek,
 499 };
 500
 501 /**
 502  * get_index - assign stream index number based on v4l2_dev
 503  * @vdev: video_device to assign index number to, vdev->v4l2_dev should be assigned
 504  *
 505  * Note that when this is called the new device has not yet been registered
 506  * in the video_device array, but it was able to obtain a minor number.
 507  *
 508  * This means that we can always obtain a free stream index number since
 509  * the worst case scenario is that there are VIDEO_NUM_DEVICES - 1 slots in
 510  * use of the video_device array.
 511  *
 512  * Returns a free index number.
 513  */
 514 static int get_index(struct video_device *vdev)
 515 {
 516         /* This can be static since this function is called with the global
 517            videodev_lock held. */
 518         static DECLARE_BITMAP(used, VIDEO_NUM_DEVICES);
 519         int i;
 520
 521         bitmap_zero(used, VIDEO_NUM_DEVICES);
 522
 523         for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
 524                 if (video_device[i] != NULL &&
 525                     video_device[i]->v4l2_dev == vdev->v4l2_dev) {
 526                         set_bit(video_device[i]->index, used);
 527                 }
 528         }
 529
 530         return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
 531 }
 532
 533 #define SET_VALID_IOCTL(ops, cmd, op)                   \
 534         if (ops->op)                                    \
 535                 set_bit(_IOC_NR(cmd), valid_ioctls)
 536
 537 /* This determines which ioctls are actually implemented in the driver.
 538    It's a one-time thing which simplifies video_ioctl2 as it can just do
 539    a bit test.
 540
 541    Note that drivers can override this by setting bits to 1 in
 542    vdev->valid_ioctls. If an ioctl is marked as 1 when this function is
 543    called, then that ioctl will actually be marked as unimplemented.
 544
 545    It does that by first setting up the local valid_ioctls bitmap, and
 546    at the end do a:
 547
 548    vdev->valid_ioctls = valid_ioctls & ~(vdev->valid_ioctls)
 549  */
 550 static void determine_valid_ioctls(struct video_device *vdev)
 551 {
 552         DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE);
 553         const struct v4l2_ioctl_ops *ops = vdev->ioctl_ops;
 554         bool is_vid = vdev->vfl_type == VFL_TYPE_GRABBER;
 555         bool is_vbi = vdev->vfl_type == VFL_TYPE_VBI;
 556         bool is_radio = vdev->vfl_type == VFL_TYPE_RADIO;
 557         bool is_sdr = vdev->vfl_type == VFL_TYPE_SDR;
 558         bool is_rx = vdev->vfl_dir != VFL_DIR_TX;
 559         bool is_tx = vdev->vfl_dir != VFL_DIR_RX;
 560
 561         bitmap_zero(valid_ioctls, BASE_VIDIOC_PRIVATE);
 562
 563         /* vfl_type and vfl_dir independent ioctls */
 564
 565         SET_VALID_IOCTL(ops, VIDIOC_QUERYCAP, vidioc_querycap);
 566         if (ops->vidioc_g_priority)
 567                 set_bit(_IOC_NR(VIDIOC_G_PRIORITY), valid_ioctls);
 568         if (ops->vidioc_s_priority)
 569                 set_bit(_IOC_NR(VIDIOC_S_PRIORITY), valid_ioctls);
 570         /* Note: the control handler can also be passed through the filehandle,
 571            and that can't be tested here. If the bit for these control ioctls
 572            is set, then the ioctl is valid. But if it is 0, then it can still
 573            be valid if the filehandle passed the control handler. */
 574         if (vdev->ctrl_handler || ops->vidioc_queryctrl)
 575                 set_bit(_IOC_NR(VIDIOC_QUERYCTRL), valid_ioctls);
 576         if (vdev->ctrl_handler || ops->vidioc_query_ext_ctrl)
 577                 set_bit(_IOC_NR(VIDIOC_QUERY_EXT_CTRL), valid_ioctls);
 578         if (vdev->ctrl_handler || ops->vidioc_g_ctrl || ops->vidioc_g_ext_ctrls)
 579                 set_bit(_IOC_NR(VIDIOC_G_CTRL), valid_ioctls);
 580         if (vdev->ctrl_handler || ops->vidioc_s_ctrl || ops->vidioc_s_ext_ctrls)
 581                 set_bit(_IOC_NR(VIDIOC_S_CTRL), valid_ioctls);
 582         if (vdev->ctrl_handler || ops->vidioc_g_ext_ctrls)
 583                 set_bit(_IOC_NR(VIDIOC_G_EXT_CTRLS), valid_ioctls);
 584         if (vdev->ctrl_handler || ops->vidioc_s_ext_ctrls)
 585                 set_bit(_IOC_NR(VIDIOC_S_EXT_CTRLS), valid_ioctls);
 586         if (vdev->ctrl_handler || ops->vidioc_try_ext_ctrls)
 587                 set_bit(_IOC_NR(VIDIOC_TRY_EXT_CTRLS), valid_ioctls);
 588         if (vdev->ctrl_handler || ops->vidioc_querymenu)
 589                 set_bit(_IOC_NR(VIDIOC_QUERYMENU), valid_ioctls);
 590         SET_VALID_IOCTL(ops, VIDIOC_G_FREQUENCY, vidioc_g_frequency);
 591         SET_VALID_IOCTL(ops, VIDIOC_S_FREQUENCY, vidioc_s_frequency);
 592         SET_VALID_IOCTL(ops, VIDIOC_LOG_STATUS, vidioc_log_status);
 593 #ifdef CONFIG_VIDEO_ADV_DEBUG
 594         set_bit(_IOC_NR(VIDIOC_DBG_G_CHIP_INFO), valid_ioctls);
 595         set_bit(_IOC_NR(VIDIOC_DBG_G_REGISTER), valid_ioctls);
 596         set_bit(_IOC_NR(VIDIOC_DBG_S_REGISTER), valid_ioctls);
 597 #endif
 598         /* yes, really vidioc_subscribe_event */
 599         SET_VALID_IOCTL(ops, VIDIOC_DQEVENT, vidioc_subscribe_event);
 600         SET_VALID_IOCTL(ops, VIDIOC_SUBSCRIBE_EVENT, vidioc_subscribe_event);
 601         SET_VALID_IOCTL(ops, VIDIOC_UNSUBSCRIBE_EVENT, vidioc_unsubscribe_event);
 602         if (ops->vidioc_enum_freq_bands || ops->vidioc_g_tuner || ops->vidioc_g_modulator)
 603                 set_bit(_IOC_NR(VIDIOC_ENUM_FREQ_BANDS), valid_ioctls);
 604
 605         if (is_vid) {
 606                 /* video specific ioctls */
 607                 if ((is_rx && (ops->vidioc_enum_fmt_vid_cap ||
 608                                ops->vidioc_enum_fmt_vid_cap_mplane ||
 609                                ops->vidioc_enum_fmt_vid_overlay)) ||
 610                     (is_tx && (ops->vidioc_enum_fmt_vid_out ||
 611                                ops->vidioc_enum_fmt_vid_out_mplane)))
 612                         set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
 613                 if ((is_rx && (ops->vidioc_g_fmt_vid_cap ||
 614                                ops->vidioc_g_fmt_vid_cap_mplane ||
 615                                ops->vidioc_g_fmt_vid_overlay)) ||
 616                     (is_tx && (ops->vidioc_g_fmt_vid_out ||
 617                                ops->vidioc_g_fmt_vid_out_mplane ||
 618                                ops->vidioc_g_fmt_vid_out_overlay)))
 619                          set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
 620                 if ((is_rx && (ops->vidioc_s_fmt_vid_cap ||
 621                                ops->vidioc_s_fmt_vid_cap_mplane ||
 622                                ops->vidioc_s_fmt_vid_overlay)) ||
 623                     (is_tx && (ops->vidioc_s_fmt_vid_out ||
 624                                ops->vidioc_s_fmt_vid_out_mplane ||
 625                                ops->vidioc_s_fmt_vid_out_overlay)))
 626                          set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
 627                 if ((is_rx && (ops->vidioc_try_fmt_vid_cap ||
 628                                ops->vidioc_try_fmt_vid_cap_mplane ||
 629                                ops->vidioc_try_fmt_vid_overlay)) ||
 630                     (is_tx && (ops->vidioc_try_fmt_vid_out ||
 631                                ops->vidioc_try_fmt_vid_out_mplane ||
 632                                ops->vidioc_try_fmt_vid_out_overlay)))
 633                          set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
 634                 SET_VALID_IOCTL(ops, VIDIOC_OVERLAY, vidioc_overlay);
 635                 SET_VALID_IOCTL(ops, VIDIOC_G_FBUF, vidioc_g_fbuf);
 636                 SET_VALID_IOCTL(ops, VIDIOC_S_FBUF, vidioc_s_fbuf);
 637                 SET_VALID_IOCTL(ops, VIDIOC_G_JPEGCOMP, vidioc_g_jpegcomp);
 638                 SET_VALID_IOCTL(ops, VIDIOC_S_JPEGCOMP, vidioc_s_jpegcomp);
 639                 SET_VALID_IOCTL(ops, VIDIOC_G_ENC_INDEX, vidioc_g_enc_index);
 640                 SET_VALID_IOCTL(ops, VIDIOC_ENCODER_CMD, vidioc_encoder_cmd);
 641                 SET_VALID_IOCTL(ops, VIDIOC_TRY_ENCODER_CMD, vidioc_try_encoder_cmd);
 642                 SET_VALID_IOCTL(ops, VIDIOC_DECODER_CMD, vidioc_decoder_cmd);
 643                 SET_VALID_IOCTL(ops, VIDIOC_TRY_DECODER_CMD, vidioc_try_decoder_cmd);
 644                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
 645                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
 646         } else if (is_vbi) {
 647                 /* vbi specific ioctls */
 648                 if ((is_rx && (ops->vidioc_g_fmt_vbi_cap ||
 649                                ops->vidioc_g_fmt_sliced_vbi_cap)) ||
 650                     (is_tx && (ops->vidioc_g_fmt_vbi_out ||
 651                                ops->vidioc_g_fmt_sliced_vbi_out)))
 652                         set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
 653                 if ((is_rx && (ops->vidioc_s_fmt_vbi_cap ||
 654                                ops->vidioc_s_fmt_sliced_vbi_cap)) ||
 655                     (is_tx && (ops->vidioc_s_fmt_vbi_out ||
 656                                ops->vidioc_s_fmt_sliced_vbi_out)))
 657                         set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
 658                 if ((is_rx && (ops->vidioc_try_fmt_vbi_cap ||
 659                                ops->vidioc_try_fmt_sliced_vbi_cap)) ||
 660                     (is_tx && (ops->vidioc_try_fmt_vbi_out ||
 661                                ops->vidioc_try_fmt_sliced_vbi_out)))
 662                         set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
 663                 SET_VALID_IOCTL(ops, VIDIOC_G_SLICED_VBI_CAP, vidioc_g_sliced_vbi_cap);
 664         } else if (is_sdr) {
 665                 /* SDR specific ioctls */
 666                 if (ops->vidioc_enum_fmt_sdr_cap)
 667                         set_bit(_IOC_NR(VIDIOC_ENUM_FMT), valid_ioctls);
 668                 if (ops->vidioc_g_fmt_sdr_cap)
 669                         set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
 670                 if (ops->vidioc_s_fmt_sdr_cap)
 671                         set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
 672                 if (ops->vidioc_try_fmt_sdr_cap)
 673                         set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
 674         }
 675
 676         if (is_vid || is_vbi || is_sdr) {
 677                 /* ioctls valid for video, vbi or sdr */
 678                 SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs);
 679                 SET_VALID_IOCTL(ops, VIDIOC_QUERYBUF, vidioc_querybuf);
 680                 SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf);
 681                 SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf);
 682                 SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf);
 683                 SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs);
 684                 SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf);
 685                 SET_VALID_IOCTL(ops, VIDIOC_STREAMON, vidioc_streamon);
 686                 SET_VALID_IOCTL(ops, VIDIOC_STREAMOFF, vidioc_streamoff);
 687         }
 688
 689         if (is_vid || is_vbi) {
 690                 /* ioctls valid for video or vbi */
 691                 if (ops->vidioc_s_std)
 692                         set_bit(_IOC_NR(VIDIOC_ENUMSTD), valid_ioctls);
 693                 SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std);
 694                 SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std);
 695                 if (is_rx) {
 696                         SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd);
 697                         SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
 698                         SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
 699                         SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
 700                         SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio);
 701                         SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio);
 702                         SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio);
 703                         SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings);
 704                         SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid);
 705                 }
 706                 if (is_tx) {
 707                         SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output);
 708                         SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output);
 709                         SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output);
 710                         SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDOUT, vidioc_enumaudout);
 711                         SET_VALID_IOCTL(ops, VIDIOC_G_AUDOUT, vidioc_g_audout);
 712                         SET_VALID_IOCTL(ops, VIDIOC_S_AUDOUT, vidioc_s_audout);
 713                 }
 714                 if (ops->vidioc_g_crop || ops->vidioc_g_selection)
 715                         set_bit(_IOC_NR(VIDIOC_G_CROP), valid_ioctls);
 716                 if (ops->vidioc_s_crop || ops->vidioc_s_selection)
 717                         set_bit(_IOC_NR(VIDIOC_S_CROP), valid_ioctls);
 718                 SET_VALID_IOCTL(ops, VIDIOC_G_SELECTION, vidioc_g_selection);
 719                 SET_VALID_IOCTL(ops, VIDIOC_S_SELECTION, vidioc_s_selection);
 720                 if (ops->vidioc_cropcap || ops->vidioc_g_selection)
 721                         set_bit(_IOC_NR(VIDIOC_CROPCAP), valid_ioctls);
 722                 if (ops->vidioc_g_parm || (vdev->vfl_type == VFL_TYPE_GRABBER &&
 723                                         ops->vidioc_g_std))
 724                         set_bit(_IOC_NR(VIDIOC_G_PARM), valid_ioctls);
 725                 SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
 726                 SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings);
 727                 SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings);
 728                 SET_VALID_IOCTL(ops, VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings);
 729                 SET_VALID_IOCTL(ops, VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap);
 730                 SET_VALID_IOCTL(ops, VIDIOC_G_EDID, vidioc_g_edid);
 731         }
 732         if (is_tx && (is_radio || is_sdr)) {
 733                 /* radio transmitter only ioctls */
 734                 SET_VALID_IOCTL(ops, VIDIOC_G_MODULATOR, vidioc_g_modulator);
 735                 SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator);
 736         }
 737         if (is_rx) {
 738                 /* receiver only ioctls */
 739                 SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner);
 740                 SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner);
 741                 SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK, vidioc_s_hw_freq_seek);
 742         }
 743
 744         bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls,
 745                         BASE_VIDIOC_PRIVATE);
 746 }
 747
 748 /**
 749  *      __video_register_device - register video4linux devices
 750  *      @vdev: video device structure we want to register
 751  *      @type: type of device to register
 752  *      @nr:   which device node number (0 == /dev/video0, 1 == /dev/video1, ...
 753  *             -1 == first free)
 754  *      @warn_if_nr_in_use: warn if the desired device node number
 755  *             was already in use and another number was chosen instead.
 756  *      @owner: module that owns the video device node
 757  *
 758  *      The registration code assigns minor numbers and device node numbers
 759  *      based on the requested type and registers the new device node with
 760  *      the kernel.
 761  *
 762  *      This function assumes that struct video_device was zeroed when it
 763  *      was allocated and does not contain any stale date.
 764  *
 765  *      An error is returned if no free minor or device node number could be
 766  *      found, or if the registration of the device node failed.
 767  *
 768  *      Zero is returned on success.
 769  *
 770  *      Valid types are
 771  *
 772  *      %VFL_TYPE_GRABBER - A frame grabber
 773  *
 774  *      %VFL_TYPE_VBI - Vertical blank data (undecoded)
 775  *
 776  *      %VFL_TYPE_RADIO - A radio card
 777  *
 778  *      %VFL_TYPE_SUBDEV - A subdevice
 779  *
 780  *      %VFL_TYPE_SDR - Software Defined Radio
 781  */
 782 int __video_register_device(struct video_device *vdev, int type, int nr,
 783                 int warn_if_nr_in_use, struct module *owner)
 784 {
 785         int i = 0;
 786         int ret;
 787         int minor_offset = 0;
 788         int minor_cnt = VIDEO_NUM_DEVICES;
 789         const char *name_base;
 790
 791         /* A minor value of -1 marks this video device as never
 792            having been registered */
 793         vdev->minor = -1;
 794
 795         /* the release callback MUST be present */
 796         if (WARN_ON(!vdev->release))
 797                 return -EINVAL;
 798         /* the v4l2_dev pointer MUST be present */
 799         if (WARN_ON(!vdev->v4l2_dev))
 800                 return -EINVAL;
 801
 802         /* v4l2_fh support */
 803         spin_lock_init(&vdev->fh_lock);
 804         INIT_LIST_HEAD(&vdev->fh_list);
 805
 806         /* Part 1: check device type */
 807         switch (type) {
 808         case VFL_TYPE_GRABBER:
 809                 name_base = "video";
 810                 break;
 811         case VFL_TYPE_VBI:
 812                 name_base = "vbi";
 813                 break;
 814         case VFL_TYPE_RADIO:
 815                 name_base = "radio";
 816                 break;
 817         case VFL_TYPE_SUBDEV:
 818                 name_base = "v4l-subdev";
 819                 break;
 820         case VFL_TYPE_SDR:
 821                 /* Use device name 'swradio' because 'sdr' was already taken. */
 822                 name_base = "swradio";
 823                 break;
 824         default:
 825                 printk(KERN_ERR "%s called with unknown type: %d\n",
 826                        __func__, type);
 827                 return -EINVAL;
 828         }
 829
 830         vdev->vfl_type = type;
 831         vdev->cdev = NULL;
 832         if (vdev->dev_parent == NULL)
 833                 vdev->dev_parent = vdev->v4l2_dev->dev;
 834         if (vdev->ctrl_handler == NULL)
 835                 vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
 836         /* If the prio state pointer is NULL, then use the v4l2_device
 837            prio state. */
 838         if (vdev->prio == NULL)
 839                 vdev->prio = &vdev->v4l2_dev->prio;
 840
 841         /* Part 2: find a free minor, device node number and device index. */
 842 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
 843         /* Keep the ranges for the first four types for historical
 844          * reasons.
 845          * Newer devices (not yet in place) should use the range
 846          * of 128-191 and just pick the first free minor there
 847          * (new style). */
 848         switch (type) {
 849         case VFL_TYPE_GRABBER:
 850                 minor_offset = 0;
 851                 minor_cnt = 64;
 852                 break;
 853         case VFL_TYPE_RADIO:
 854                 minor_offset = 64;
 855                 minor_cnt = 64;
 856                 break;
 857         case VFL_TYPE_VBI:
 858                 minor_offset = 224;
 859                 minor_cnt = 32;
 860                 break;
 861         default:
 862                 minor_offset = 128;
 863                 minor_cnt = 64;
 864                 break;
 865         }
 866 #endif
 867
 868         /* Pick a device node number */
 869         mutex_lock(&videodev_lock);
 870         nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
 871         if (nr == minor_cnt)
 872                 nr = devnode_find(vdev, 0, minor_cnt);
 873         if (nr == minor_cnt) {
 874                 printk(KERN_ERR "could not get a free device node number\n");
 875                 mutex_unlock(&videodev_lock);
 876                 return -ENFILE;
 877         }
 878 #ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
 879         /* 1-on-1 mapping of device node number to minor number */
 880         i = nr;
 881 #else
 882         /* The device node number and minor numbers are independent, so
 883            we just find the first free minor number. */
 884         for (i = 0; i < VIDEO_NUM_DEVICES; i++)
 885                 if (video_device[i] == NULL)
 886                         break;
 887         if (i == VIDEO_NUM_DEVICES) {
 888                 mutex_unlock(&videodev_lock);
 889                 printk(KERN_ERR "could not get a free minor\n");
 890                 return -ENFILE;
 891         }
 892 #endif
 893         vdev->minor = i + minor_offset;
 894         vdev->num = nr;
 895         devnode_set(vdev);
 896
 897         /* Should not happen since we thought this minor was free */
 898         WARN_ON(video_device[vdev->minor] != NULL);
 899         vdev->index = get_index(vdev);
 900         video_device[vdev->minor] = vdev;
 901         mutex_unlock(&videodev_lock);
 902
 903         if (vdev->ioctl_ops)
 904                 determine_valid_ioctls(vdev);
 905
 906         /* Part 3: Initialize the character device */
 907         vdev->cdev = cdev_alloc();
 908         if (vdev->cdev == NULL) {
 909                 ret = -ENOMEM;
 910                 goto cleanup;
 911         }
 912         vdev->cdev->ops = &v4l2_fops;
 913         vdev->cdev->owner = owner;
 914         ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
 915         if (ret < 0) {
 916                 printk(KERN_ERR "%s: cdev_add failed\n", __func__);
 917                 kfree(vdev->cdev);
 918                 vdev->cdev = NULL;
 919                 goto cleanup;
 920         }
 921
 922         /* Part 4: register the device with sysfs */
 923         vdev->dev.class = &video_class;
 924         vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
 925         vdev->dev.parent = vdev->dev_parent;
 926         dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
 927         ret = device_register(&vdev->dev);
 928         if (ret < 0) {
 929                 printk(KERN_ERR "%s: device_register failed\n", __func__);
 930                 goto cleanup;
 931         }
 932         /* Register the release callback that will be called when the last
 933            reference to the device goes away. */
 934         vdev->dev.release = v4l2_device_release;
 935
 936         if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
 937                 printk(KERN_WARNING "%s: requested %s%d, got %s\n", __func__,
 938                         name_base, nr, video_device_node_name(vdev));
 939
 940         /* Increase v4l2_device refcount */
 941         if (vdev->v4l2_dev)
 942                 v4l2_device_get(vdev->v4l2_dev);
 943
 944 #if defined(CONFIG_MEDIA_CONTROLLER)
 945         /* Part 5: Register the entity. */
 946         if (vdev->v4l2_dev && vdev->v4l2_dev->mdev &&
 947             vdev->vfl_type != VFL_TYPE_SUBDEV) {
 948                 vdev->entity.type = MEDIA_ENT_T_DEVNODE_V4L;
 949                 vdev->entity.name = vdev->name;
 950                 vdev->entity.info.v4l.major = VIDEO_MAJOR;
 951                 vdev->entity.info.v4l.minor = vdev->minor;
 952                 ret = media_device_register_entity(vdev->v4l2_dev->mdev,
 953                         &vdev->entity);
 954                 if (ret < 0)
 955                         printk(KERN_WARNING
 956                                "%s: media_device_register_entity failed\n",
 957                                __func__);
 958         }
 959 #endif
 960         /* Part 6: Activate this minor. The char device can now be used. */
 961         set_bit(V4L2_FL_REGISTERED, &vdev->flags);
 962
 963         return 0;
 964
 965 cleanup:
 966         mutex_lock(&videodev_lock);
 967         if (vdev->cdev)
 968                 cdev_del(vdev->cdev);
 969         video_device[vdev->minor] = NULL;
 970         devnode_clear(vdev);
 971         mutex_unlock(&videodev_lock);
 972         /* Mark this video device as never having been registered. */
 973         vdev->minor = -1;
 974         return ret;
 975 }
 976 EXPORT_SYMBOL(__video_register_device);
 977
 978 /**
 979  *      video_unregister_device - unregister a video4linux device
 980  *      @vdev: the device to unregister
 981  *
 982  *      This unregisters the passed device. Future open calls will
 983  *      be met with errors.
 984  */
 985 void video_unregister_device(struct video_device *vdev)
 986 {
 987         /* Check if vdev was ever registered at all */
 988         if (!vdev || !video_is_registered(vdev))
 989                 return;
 990
 991         mutex_lock(&videodev_lock);
 992         /* This must be in a critical section to prevent a race with v4l2_open.
 993          * Once this bit has been cleared video_get may never be called again.
 994          */
 995         clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
 996         mutex_unlock(&videodev_lock);
 997         device_unregister(&vdev->dev);
 998 }
 999 EXPORT_SYMBOL(video_unregister_device);
1000
1001 /*
1002  *      Initialise video for linux
1003  */
1004 static int __init videodev_init(void)
1005 {
1006         dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1007         int ret;
1008
1009         printk(KERN_INFO "Linux video capture interface: v2.00\n");
1010         ret = register_chrdev_region(dev, VIDEO_NUM_DEVICES, VIDEO_NAME);
1011         if (ret < 0) {
1012                 printk(KERN_WARNING "videodev: unable to get major %d\n",
1013                                 VIDEO_MAJOR);
1014                 return ret;
1015         }
1016
1017         ret = class_register(&video_class);
1018         if (ret < 0) {
1019                 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1020                 printk(KERN_WARNING "video_dev: class_register failed\n");
1021                 return -EIO;
1022         }
1023
1024         return 0;
1025 }
1026
1027 static void __exit videodev_exit(void)
1028 {
1029         dev_t dev = MKDEV(VIDEO_MAJOR, 0);
1030
1031         class_unregister(&video_class);
1032         unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
1033 }
1034
1035 subsys_initcall(videodev_init);
1036 module_exit(videodev_exit)
1037
1038 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
1039 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
1040 MODULE_LICENSE("GPL");
1041 MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);
1042
1043
1044 /*
1045  * Local variables:
1046  * c-basic-offset: 8
1047  * End:
1048  */