static struct rtl2832_sdr_format formats[] = {
        {
-               .name           = "Complex U8",
                .pixelformat    = V4L2_SDR_FMT_CU8,
                .buffersize     = BULK_BUFFER_SIZE,
        }, {
-               .name           = "Complex U16LE (emulated)",
                .pixelformat    = V4L2_SDR_FMT_CU16LE,
                .buffersize     = BULK_BUFFER_SIZE * 2,
        },
        if (f->index >= dev->num_formats)
                return -EINVAL;
 
-       strscpy(f->description, formats[f->index].name, sizeof(f->description));
        f->pixelformat = formats[f->index].pixelformat;
 
        return 0;
 
 
 /* stream formats */
 struct airspy_format {
-       char    *name;
        u32     pixelformat;
        u32     buffersize;
 };
 /* format descriptions for capture and preview */
 static struct airspy_format formats[] = {
        {
-               .name           = "Real U12LE",
                .pixelformat    = V4L2_SDR_FMT_RU12LE,
                .buffersize     = BULK_BUFFER_SIZE,
        },
        if (f->index >= NUM_FORMATS)
                return -EINVAL;
 
-       strscpy(f->description, formats[f->index].name, sizeof(f->description));
        f->pixelformat = formats[f->index].pixelformat;
 
        return 0;
 
 
        dprintk(1, "%s called\n", __func__);
 
-       f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       strscpy(f->description, "Packed YUV2", sizeof(f->description));
-
-       f->flags = 0;
        f->pixelformat = V4L2_PIX_FMT_UYVY;
 
        return 0;
 
 static int cpia2_enum_fmt_vid_cap(struct file *file, void *fh,
                                            struct v4l2_fmtdesc *f)
 {
-       int index = f->index;
-
-       if (index < 0 || index > 1)
-              return -EINVAL;
+       if (f->index > 1)
+               return -EINVAL;
 
-       memset(f, 0, sizeof(*f));
-       f->index = index;
-       f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       f->flags = V4L2_FMT_FLAG_COMPRESSED;
-       switch(index) {
-       case 0:
-               strscpy(f->description, "MJPEG", sizeof(f->description));
+       if (f->index == 0)
                f->pixelformat = V4L2_PIX_FMT_MJPEG;
-               break;
-       case 1:
-               strscpy(f->description, "JPEG", sizeof(f->description));
+       else
                f->pixelformat = V4L2_PIX_FMT_JPEG;
-               break;
-       default:
-               return -EINVAL;
-       }
-
        return 0;
 }
 
 
        if (f->index != 0)
                return -EINVAL;
 
-       strscpy(f->description, "MPEG", sizeof(f->description));
        f->pixelformat = V4L2_PIX_FMT_MPEG;
 
        return 0;
 
 /* supported video standards */
 static struct cx231xx_fmt format[] = {
        {
-        .name = "16bpp YUY2, 4:2:2, packed",
         .fourcc = V4L2_PIX_FMT_YUYV,
         .depth = 16,
         .reg = 0,
        if (unlikely(f->index >= ARRAY_SIZE(format)))
                return -EINVAL;
 
-       strscpy(f->description, format[f->index].name, sizeof(f->description));
        f->pixelformat = format[f->index].fourcc;
 
        return 0;
 
 #define CX23417_RESET    9
 
 struct cx23417_fmt {
-       char  *name;
        u32   fourcc;          /* v4l2 format id */
        int   depth;
        int   flags;
 
 /* supported video standards */
 static struct em28xx_fmt format[] = {
        {
-               .name     = "16 bpp YUY2, 4:2:2, packed",
                .fourcc   = V4L2_PIX_FMT_YUYV,
                .depth    = 16,
                .reg      = EM28XX_OUTFMT_YUV422_Y0UY1V,
        }, {
-               .name     = "16 bpp RGB 565, LE",
                .fourcc   = V4L2_PIX_FMT_RGB565,
                .depth    = 16,
                .reg      = EM28XX_OUTFMT_RGB_16_656,
        }, {
-               .name     = "8 bpp Bayer RGRG..GBGB",
                .fourcc   = V4L2_PIX_FMT_SRGGB8,
                .depth    = 8,
                .reg      = EM28XX_OUTFMT_RGB_8_RGRG,
        }, {
-               .name     = "8 bpp Bayer BGBG..GRGR",
                .fourcc   = V4L2_PIX_FMT_SBGGR8,
                .depth    = 8,
                .reg      = EM28XX_OUTFMT_RGB_8_BGBG,
        }, {
-               .name     = "8 bpp Bayer GRGR..BGBG",
                .fourcc   = V4L2_PIX_FMT_SGRBG8,
                .depth    = 8,
                .reg      = EM28XX_OUTFMT_RGB_8_GRGR,
        }, {
-               .name     = "8 bpp Bayer GBGB..RGRG",
                .fourcc   = V4L2_PIX_FMT_SGBRG8,
                .depth    = 8,
                .reg      = EM28XX_OUTFMT_RGB_8_GBGB,
        }, {
-               .name     = "12 bpp YUV411",
                .fourcc   = V4L2_PIX_FMT_YUV411P,
                .depth    = 12,
                .reg      = EM28XX_OUTFMT_YUV411,
        if (unlikely(f->index >= ARRAY_SIZE(format)))
                return -EINVAL;
 
-       strscpy(f->description, format[f->index].name, sizeof(f->description));
        f->pixelformat = format[f->index].fourcc;
 
        return 0;
 
 /**
  * struct em28xx_fmt - Struct to enumberate video formats
  *
- * @name:      Name for the video standard
  * @fourcc:    v4l2 format id
  * @depth:     mean number of bits to represent a pixel
  * @reg:       em28xx register value to set it
  */
 struct em28xx_fmt {
-       char    *name;
        u32     fourcc;
        int     depth;
        int     reg;
 
 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
                                        struct v4l2_fmtdesc *fmt)
 {
-       char *desc = NULL;
-
        switch (fmt->index) {
        case 0:
                fmt->pixelformat = V4L2_PIX_FMT_MJPEG;
-               desc = "Motion JPEG";
                break;
        case 1:
                fmt->pixelformat = V4L2_PIX_FMT_MPEG1;
-               desc = "MPEG-1 ES";
                break;
        case 2:
                fmt->pixelformat = V4L2_PIX_FMT_MPEG2;
-               desc = "MPEG-2 ES";
                break;
        case 3:
                fmt->pixelformat = V4L2_PIX_FMT_MPEG4;
-               desc = "MPEG-4 ES";
                break;
        default:
                return -EINVAL;
        }
-       fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       fmt->flags = V4L2_FMT_FLAG_COMPRESSED;
-
-       strscpy(fmt->description, desc, sizeof(fmt->description));
-
        return 0;
 }
 
 
                return -EINVAL;         /* no more format */
 
        fmtdesc->pixelformat = fmt_tb[index];
-       if (gspca_dev->cam.cam_mode[i].sizeimage <
-                       gspca_dev->cam.cam_mode[i].width *
-                               gspca_dev->cam.cam_mode[i].height)
-               fmtdesc->flags = V4L2_FMT_FLAG_COMPRESSED;
-       fmtdesc->description[0] = fmtdesc->pixelformat & 0xff;
-       fmtdesc->description[1] = (fmtdesc->pixelformat >> 8) & 0xff;
-       fmtdesc->description[2] = (fmtdesc->pixelformat >> 16) & 0xff;
-       fmtdesc->description[3] = fmtdesc->pixelformat >> 24;
-       fmtdesc->description[4] = '\0';
        return 0;
 }
 
 
        if (f->index != 0)
                return -EINVAL;
 
-       f->flags = V4L2_FMT_FLAG_COMPRESSED;
-       strscpy(f->description, "MPEG2-TS with AVC/AAC streams",
-               sizeof(f->description));
        f->pixelformat = V4L2_PIX_FMT_MPEG;
 
        return 0;
 
 
 /* stream formats */
 struct msi2500_format {
-       char    *name;
        u32     pixelformat;
        u32     buffersize;
 };
 /* format descriptions for capture and preview */
 static struct msi2500_format formats[] = {
        {
-               .name           = "Complex S8",
                .pixelformat    = V4L2_SDR_FMT_CS8,
                .buffersize     = 3 * 1008,
 #if 0
        }, {
-               .name           = "10+2-bit signed",
                .pixelformat    = MSI2500_PIX_FMT_SDR_MSI2500_384,
        }, {
-               .name           = "12-bit signed",
                .pixelformat    = MSI2500_PIX_FMT_SDR_S12,
 #endif
        }, {
-               .name           = "Complex S14LE",
                .pixelformat    = V4L2_SDR_FMT_CS14LE,
                .buffersize     = 3 * 1008,
        }, {
-               .name           = "Complex U8 (emulated)",
                .pixelformat    = V4L2_SDR_FMT_CU8,
                .buffersize     = 3 * 1008,
        }, {
-               .name           = "Complex U16LE (emulated)",
                .pixelformat    =  V4L2_SDR_FMT_CU16LE,
                .buffersize     = 3 * 1008,
        },
        if (f->index >= dev->num_formats)
                return -EINVAL;
 
-       strscpy(f->description, formats[f->index].name, sizeof(f->description));
        f->pixelformat = formats[f->index].pixelformat;
 
        return 0;
 
        case 0:
                /* RAW format */
                f->pixelformat = pdev->type <= 646 ? V4L2_PIX_FMT_PWC1 : V4L2_PIX_FMT_PWC2;
-               f->flags = V4L2_FMT_FLAG_COMPRESSED;
-               strscpy(f->description, "Raw Philips Webcam",
-                       sizeof(f->description));
                break;
        case 1:
                f->pixelformat = V4L2_PIX_FMT_YUV420;
-               strscpy(f->description, "4:2:0, planar, Y-Cb-Cr",
-                       sizeof(f->description));
                break;
        default:
                return -EINVAL;
 
 }
 
 struct s2255_fmt {
-       char *name;
        u32 fourcc;
        int depth;
 };
 /* JPEG formats must be defined last to support jpeg_enable parameter */
 static const struct s2255_fmt formats[] = {
        {
-               .name = "4:2:2, packed, YUYV",
                .fourcc = V4L2_PIX_FMT_YUYV,
                .depth = 16
 
        }, {
-               .name = "4:2:2, packed, UYVY",
                .fourcc = V4L2_PIX_FMT_UYVY,
                .depth = 16
        }, {
-               .name = "4:2:2, planar, YUV422P",
                .fourcc = V4L2_PIX_FMT_YUV422P,
                .depth = 16
 
        }, {
-               .name = "8bpp GREY",
                .fourcc = V4L2_PIX_FMT_GREY,
                .depth = 8
        }, {
-               .name = "JPG",
                .fourcc = V4L2_PIX_FMT_JPEG,
                .depth = 24
        }, {
-               .name = "MJPG",
                .fourcc = V4L2_PIX_FMT_MJPEG,
                .depth = 24
        }
        if (!jpeg_enable && ((formats[index].fourcc == V4L2_PIX_FMT_JPEG) ||
                        (formats[index].fourcc == V4L2_PIX_FMT_MJPEG)))
                return -EINVAL;
-       strscpy(f->description, formats[index].name, sizeof(f->description));
        f->pixelformat = formats[index].fourcc;
        return 0;
 }
 
 /* supported video standards */
 static struct stk1160_fmt format[] = {
        {
-               .name     = "16 bpp YUY2, 4:2:2, packed",
                .fourcc   = V4L2_PIX_FMT_UYVY,
                .depth    = 16,
        }
        if (f->index != 0)
                return -EINVAL;
 
-       strscpy(f->description, format[f->index].name, sizeof(f->description));
        f->pixelformat = format[f->index].fourcc;
        return 0;
 }
 
 };
 
 struct stk1160_fmt {
-       char  *name;
        u32   fourcc;          /* v4l2 format id */
        int   depth;
 };
 
        switch (fmtd->index) {
        case 0:
                fmtd->pixelformat = V4L2_PIX_FMT_RGB565;
-               strscpy(fmtd->description, "r5g6b5", sizeof(fmtd->description));
                break;
        case 1:
                fmtd->pixelformat = V4L2_PIX_FMT_RGB565X;
-               strscpy(fmtd->description, "r5g6b5BE", sizeof(fmtd->description));
                break;
        case 2:
                fmtd->pixelformat = V4L2_PIX_FMT_UYVY;
-               strscpy(fmtd->description, "yuv4:2:2", sizeof(fmtd->description));
                break;
        case 3:
                fmtd->pixelformat = V4L2_PIX_FMT_SBGGR8;
-               strscpy(fmtd->description, "Raw bayer", sizeof(fmtd->description));
                break;
        case 4:
                fmtd->pixelformat = V4L2_PIX_FMT_YUYV;
-               strscpy(fmtd->description, "yuv4:2:2", sizeof(fmtd->description));
                break;
        default:
                return -EINVAL;
 
 
 static struct tm6000_fmt format[] = {
        {
-               .name     = "4:2:2, packed, YVY2",
                .fourcc   = V4L2_PIX_FMT_YUYV,
                .depth    = 16,
        }, {
-               .name     = "4:2:2, packed, UYVY",
                .fourcc   = V4L2_PIX_FMT_UYVY,
                .depth    = 16,
        }, {
-               .name     = "A/V + VBI mux packet",
                .fourcc   = V4L2_PIX_FMT_TM6000,
                .depth    = 16,
        }
        if (f->index >= ARRAY_SIZE(format))
                return -EINVAL;
 
-       strscpy(f->description, format[f->index].name, sizeof(f->description));
        f->pixelformat = format[f->index].fourcc;
        return 0;
 }
 
  */
 
 struct tm6000_fmt {
-       char  *name;
        u32   fourcc;          /* v4l2 format id */
        int   depth;
 };
 
        if (f->index > 0)
                return -EINVAL;
 
-       strscpy(f->description, "16 bpp YUY2, 4:2:2, packed",
-               sizeof(f->description));
        f->pixelformat = V4L2_PIX_FMT_YUYV;
        return 0;
 }
 
 static int usbvision_nr;
 
 static struct usbvision_v4l2_format_st usbvision_v4l2_format[] = {
-       { 1, 1,  8, V4L2_PIX_FMT_GREY    , "GREY" },
-       { 1, 2, 16, V4L2_PIX_FMT_RGB565  , "RGB565" },
-       { 1, 3, 24, V4L2_PIX_FMT_RGB24   , "RGB24" },
-       { 1, 4, 32, V4L2_PIX_FMT_RGB32   , "RGB32" },
-       { 1, 2, 16, V4L2_PIX_FMT_RGB555  , "RGB555" },
-       { 1, 2, 16, V4L2_PIX_FMT_YUYV    , "YUV422" },
-       { 1, 2, 12, V4L2_PIX_FMT_YVU420  , "YUV420P" }, /* 1.5 ! */
-       { 1, 2, 16, V4L2_PIX_FMT_YUV422P , "YUV422P" }
+       { 1, 1,  8, V4L2_PIX_FMT_GREY },
+       { 1, 2, 16, V4L2_PIX_FMT_RGB565 },
+       { 1, 3, 24, V4L2_PIX_FMT_RGB24 },
+       { 1, 4, 32, V4L2_PIX_FMT_RGB32 },
+       { 1, 2, 16, V4L2_PIX_FMT_RGB555 },
+       { 1, 2, 16, V4L2_PIX_FMT_YUYV },
+       { 1, 2, 12, V4L2_PIX_FMT_YVU420 }, /* 1.5 ! */
+       { 1, 2, 16, V4L2_PIX_FMT_YUV422P }
 };
 
 /* Function prototypes */
 {
        if (vfd->index >= USBVISION_SUPPORTED_PALETTES - 1)
                return -EINVAL;
-       strscpy(vfd->description, usbvision_v4l2_format[vfd->index].desc,
-               sizeof(vfd->description));
        vfd->pixelformat = usbvision_v4l2_format[vfd->index].format;
        return 0;
 }
 
        int             bytes_per_pixel;
        int             depth;
        int             format;
-       char            *desc;
 };
 #define USBVISION_SUPPORTED_PALETTES ARRAY_SIZE(usbvision_v4l2_format)
 
 
 };
 
 struct zr364xx_fmt {
-       char *name;
        u32 fourcc;
        int depth;
 };
 /* image formats.  */
 static const struct zr364xx_fmt formats[] = {
        {
-               .name = "JPG",
                .fourcc = V4L2_PIX_FMT_JPEG,
                .depth = 24
        }
                                                  vb);
        int rc;
 
-       DBG("%s, field=%d, fmt name = %s\n", __func__, field,
-           cam->fmt ? cam->fmt->name : "");
+       DBG("%s, field=%d\n", __func__, field);
        if (!cam->fmt)
                return -EINVAL;
 
 {
        if (f->index > 0)
                return -EINVAL;
-       f->flags = V4L2_FMT_FLAG_COMPRESSED;
-       strscpy(f->description, formats[0].name, sizeof(f->description));
        f->pixelformat = formats[0].fourcc;
        return 0;
 }