/* format descriptions for capture and preview */
 static struct saa7146_format formats[] = {
        {
-               .name           = "RGB-8 (3-3-2)",
                .pixelformat    = V4L2_PIX_FMT_RGB332,
                .trans          = RGB08_COMPOSED,
                .depth          = 8,
                .flags          = 0,
        }, {
-               .name           = "RGB-16 (5/B-6/G-5/R)",
                .pixelformat    = V4L2_PIX_FMT_RGB565,
                .trans          = RGB16_COMPOSED,
                .depth          = 16,
                .flags          = 0,
        }, {
-               .name           = "RGB-24 (B-G-R)",
                .pixelformat    = V4L2_PIX_FMT_BGR24,
                .trans          = RGB24_COMPOSED,
                .depth          = 24,
                .flags          = 0,
        }, {
-               .name           = "RGB-32 (B-G-R)",
                .pixelformat    = V4L2_PIX_FMT_BGR32,
                .trans          = RGB32_COMPOSED,
                .depth          = 32,
                .flags          = 0,
        }, {
-               .name           = "RGB-32 (R-G-B)",
                .pixelformat    = V4L2_PIX_FMT_RGB32,
                .trans          = RGB32_COMPOSED,
                .depth          = 32,
                .flags          = 0,
                .swap           = 0x2,
        }, {
-               .name           = "Greyscale-8",
                .pixelformat    = V4L2_PIX_FMT_GREY,
                .trans          = Y8,
                .depth          = 8,
                .flags          = 0,
        }, {
-               .name           = "YUV 4:2:2 planar (Y-Cb-Cr)",
                .pixelformat    = V4L2_PIX_FMT_YUV422P,
                .trans          = YUV422_DECOMPOSED,
                .depth          = 16,
                .flags          = FORMAT_BYTE_SWAP|FORMAT_IS_PLANAR,
        }, {
-               .name           = "YVU 4:2:0 planar (Y-Cb-Cr)",
                .pixelformat    = V4L2_PIX_FMT_YVU420,
                .trans          = YUV420_DECOMPOSED,
                .depth          = 12,
                .flags          = FORMAT_BYTE_SWAP|FORMAT_IS_PLANAR,
        }, {
-               .name           = "YUV 4:2:0 planar (Y-Cb-Cr)",
                .pixelformat    = V4L2_PIX_FMT_YUV420,
                .trans          = YUV420_DECOMPOSED,
                .depth          = 12,
                .flags          = FORMAT_IS_PLANAR,
        }, {
-               .name           = "YUV 4:2:2 (U-Y-V-Y)",
                .pixelformat    = V4L2_PIX_FMT_UYVY,
                .trans          = YUV422_COMPOSED,
                .depth          = 16,
        }
        vv->ov.win = fmt.fmt.win;
 
-       DEB_D("%dx%d+%d+%d %s field=%s\n",
+       DEB_D("%dx%d+%d+%d 0x%08x field=%s\n",
              vv->ov.win.w.width, vv->ov.win.w.height,
              vv->ov.win.w.left, vv->ov.win.w.top,
-             vv->ov_fmt->name, v4l2_field_names[vv->ov.win.field]);
+             vv->ov_fmt->pixelformat, v4l2_field_names[vv->ov.win.field]);
 
        if (0 != (ret = saa7146_enable_overlay(fh))) {
                DEB_D("enabling overlay failed: %d\n", ret);
 {
        if (f->index >= ARRAY_SIZE(formats))
                return -EINVAL;
-       strscpy((char *)f->description, formats[f->index].name,
-               sizeof(f->description));
        f->pixelformat = formats[f->index].pixelformat;
        return 0;
 }
 
    packed pixel formats must come first */
 static const struct bttv_format formats[] = {
        {
-               .name     = "8 bpp, gray",
                .fourcc   = V4L2_PIX_FMT_GREY,
                .btformat = BT848_COLOR_FMT_Y8,
                .depth    = 8,
                .flags    = FORMAT_FLAGS_PACKED,
        },{
-               .name     = "8 bpp, dithered color",
                .fourcc   = V4L2_PIX_FMT_HI240,
                .btformat = BT848_COLOR_FMT_RGB8,
                .depth    = 8,
                .flags    = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
        },{
-               .name     = "15 bpp RGB, le",
                .fourcc   = V4L2_PIX_FMT_RGB555,
                .btformat = BT848_COLOR_FMT_RGB15,
                .depth    = 16,
                .flags    = FORMAT_FLAGS_PACKED,
        },{
-               .name     = "15 bpp RGB, be",
                .fourcc   = V4L2_PIX_FMT_RGB555X,
                .btformat = BT848_COLOR_FMT_RGB15,
                .btswap   = 0x03, /* byteswap */
                .depth    = 16,
                .flags    = FORMAT_FLAGS_PACKED,
        },{
-               .name     = "16 bpp RGB, le",
                .fourcc   = V4L2_PIX_FMT_RGB565,
                .btformat = BT848_COLOR_FMT_RGB16,
                .depth    = 16,
                .flags    = FORMAT_FLAGS_PACKED,
        },{
-               .name     = "16 bpp RGB, be",
                .fourcc   = V4L2_PIX_FMT_RGB565X,
                .btformat = BT848_COLOR_FMT_RGB16,
                .btswap   = 0x03, /* byteswap */
                .depth    = 16,
                .flags    = FORMAT_FLAGS_PACKED,
        },{
-               .name     = "24 bpp RGB, le",
                .fourcc   = V4L2_PIX_FMT_BGR24,
                .btformat = BT848_COLOR_FMT_RGB24,
                .depth    = 24,
                .flags    = FORMAT_FLAGS_PACKED,
        },{
-               .name     = "32 bpp RGB, le",
                .fourcc   = V4L2_PIX_FMT_BGR32,
                .btformat = BT848_COLOR_FMT_RGB32,
                .depth    = 32,
                .flags    = FORMAT_FLAGS_PACKED,
        },{
-               .name     = "32 bpp RGB, be",
                .fourcc   = V4L2_PIX_FMT_RGB32,
                .btformat = BT848_COLOR_FMT_RGB32,
                .btswap   = 0x0f, /* byte+word swap */
                .depth    = 32,
                .flags    = FORMAT_FLAGS_PACKED,
        },{
-               .name     = "4:2:2, packed, YUYV",
                .fourcc   = V4L2_PIX_FMT_YUYV,
                .btformat = BT848_COLOR_FMT_YUY2,
                .depth    = 16,
                .flags    = FORMAT_FLAGS_PACKED,
        },{
-               .name     = "4:2:2, packed, UYVY",
                .fourcc   = V4L2_PIX_FMT_UYVY,
                .btformat = BT848_COLOR_FMT_YUY2,
                .btswap   = 0x03, /* byteswap */
                .depth    = 16,
                .flags    = FORMAT_FLAGS_PACKED,
        },{
-               .name     = "4:2:2, planar, Y-Cb-Cr",
                .fourcc   = V4L2_PIX_FMT_YUV422P,
                .btformat = BT848_COLOR_FMT_YCrCb422,
                .depth    = 16,
                .hshift   = 1,
                .vshift   = 0,
        },{
-               .name     = "4:2:0, planar, Y-Cb-Cr",
                .fourcc   = V4L2_PIX_FMT_YUV420,
                .btformat = BT848_COLOR_FMT_YCrCb422,
                .depth    = 12,
                .hshift   = 1,
                .vshift   = 1,
        },{
-               .name     = "4:2:0, planar, Y-Cr-Cb",
                .fourcc   = V4L2_PIX_FMT_YVU420,
                .btformat = BT848_COLOR_FMT_YCrCb422,
                .depth    = 12,
                .hshift   = 1,
                .vshift   = 1,
        },{
-               .name     = "4:1:1, planar, Y-Cb-Cr",
                .fourcc   = V4L2_PIX_FMT_YUV411P,
                .btformat = BT848_COLOR_FMT_YCrCb411,
                .depth    = 12,
                .hshift   = 2,
                .vshift   = 0,
        },{
-               .name     = "4:1:0, planar, Y-Cb-Cr",
                .fourcc   = V4L2_PIX_FMT_YUV410,
                .btformat = BT848_COLOR_FMT_YCrCb411,
                .depth    = 9,
                .hshift   = 2,
                .vshift   = 2,
        },{
-               .name     = "4:1:0, planar, Y-Cr-Cb",
                .fourcc   = V4L2_PIX_FMT_YVU410,
                .btformat = BT848_COLOR_FMT_YCrCb411,
                .depth    = 9,
                .hshift   = 2,
                .vshift   = 2,
        },{
-               .name     = "raw scanlines",
                .fourcc   = -1,
                .btformat = BT848_COLOR_FMT_RAW,
                .depth    = 8,
                return -EINVAL;
 
        f->pixelformat = formats[i].fourcc;
-       strscpy(f->description, formats[i].name, sizeof(f->description));
 
        return i;
 }
 
        const struct bttv_tvnorm *tvnorm = bttv_tvnorms + buf->tvnorm;
        struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
 
-       dprintk("%d: buffer field: %s  format: %s  size: %dx%d\n",
+       dprintk("%d: buffer field: %s  format: 0x%08x  size: %dx%d\n",
                btv->c.nr, v4l2_field_names[buf->vb.field],
-               buf->fmt->name, buf->vb.width, buf->vb.height);
+               buf->fmt->fourcc, buf->vb.width, buf->vb.height);
 
        /* packed pixel modes */
        if (buf->fmt->flags & FORMAT_FLAGS_PACKED) {
                  struct bttv_buffer *buf)
 {
        /* check interleave, bottom+top fields */
-       dprintk("%d: overlay fields: %s format: %s  size: %dx%d\n",
+       dprintk("%d: overlay fields: %s format: 0x%08x  size: %dx%d\n",
                btv->c.nr, v4l2_field_names[buf->vb.field],
-               fmt->name, ov->w.width, ov->w.height);
+               fmt->fourcc, ov->w.width, ov->w.height);
 
        /* calculate geometry */
        bttv_calc_geo(btv,&buf->geo,ov->w.width,ov->w.height,
 
 extern const struct bttv_tvnorm bttv_tvnorms[];
 
 struct bttv_format {
-       char *name;
        int  fourcc;          /* video4linux 2      */
        int  btformat;        /* BT848_COLOR_FMT_*  */
        int  btswap;          /* BT848_COLOR_CTL_*  */
 
 {
        switch (f->index) {
        case 0:
-               strscpy(f->description, "YUV 4:2:2", sizeof(f->description));
                f->pixelformat = V4L2_PIX_FMT_YUYV;
                break;
        case 1:
-               strscpy(f->description, "RGB24", sizeof(f->description));
                f->pixelformat = V4L2_PIX_FMT_RGB24;
                break;
        case 2:
-               strscpy(f->description, "RGB32", sizeof(f->description));
                f->pixelformat = V4L2_PIX_FMT_BGR32;
                break;
        default:
 {
        switch (f->index) {
        case 0:
-               strscpy(f->description, "YUV 4:2:2", sizeof(f->description));
                f->pixelformat = V4L2_PIX_FMT_YUYV;
                break;
        case 1:
-               strscpy(f->description, "RGB32", sizeof(f->description));
                f->pixelformat = V4L2_PIX_FMT_BGR32;
                break;
        default:
 
        if (f->index != 0)
                return -EINVAL;
 
-       strscpy(f->description, "MPEG", sizeof(f->description));
        f->pixelformat = V4L2_PIX_FMT_MPEG;
 
        return 0;
 
 #define FORMAT_FLAGS_PACKED       0x01
 static struct cx23885_fmt formats[] = {
        {
-               .name     = "4:2:2, packed, YUYV",
                .fourcc   = V4L2_PIX_FMT_YUYV,
                .depth    = 16,
                .flags    = FORMAT_FLAGS_PACKED,
        default:
                BUG();
        }
-       dprintk(2, "[%p/%d] buffer_init - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
+       dprintk(2, "[%p/%d] buffer_init - %dx%d %dbpp 0x%08x - dma=0x%08lx\n",
                buf, buf->vb.vb2_buf.index,
-               dev->width, dev->height, dev->fmt->depth, dev->fmt->name,
+               dev->width, dev->height, dev->fmt->depth, dev->fmt->fourcc,
                (unsigned long)buf->risc.dma);
        return 0;
 }
        if (unlikely(f->index >= ARRAY_SIZE(formats)))
                return -EINVAL;
 
-       strscpy(f->description, formats[f->index].name,
-               sizeof(f->description));
        f->pixelformat = formats[f->index].fourcc;
 
        return 0;
 
        V4L2_STD_PAL_60 |  V4L2_STD_SECAM_L   |  V4L2_STD_SECAM_DK)
 
 struct cx23885_fmt {
-       char  *name;
        u32   fourcc;          /* v4l2 format id */
        int   depth;
        int   flags;
 
 
 static const struct cx25821_fmt formats[] = {
        {
-               .name = "4:1:1, packed, Y41P",
                .fourcc = V4L2_PIX_FMT_Y41P,
                .depth = 12,
                .flags = FORMAT_FLAGS_PACKED,
        }, {
-               .name = "4:2:2, packed, YUYV",
                .fourcc = V4L2_PIX_FMT_YUYV,
                .depth = 16,
                .flags = FORMAT_FLAGS_PACKED,
                break;
        }
 
-       dprintk(2, "[%p/%d] buffer_prep - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
+       dprintk(2, "[%p/%d] buffer_prep - %dx%d %dbpp 0x%08x - dma=0x%08lx\n",
                buf, buf->vb.vb2_buf.index, chan->width, chan->height,
-               chan->fmt->depth, chan->fmt->name,
+               chan->fmt->depth, chan->fmt->fourcc,
                (unsigned long)buf->risc.dma);
 
        return ret;
        if (unlikely(f->index >= ARRAY_SIZE(formats)))
                return -EINVAL;
 
-       strscpy(f->description, formats[f->index].name, sizeof(f->description));
        f->pixelformat = formats[f->index].fourcc;
 
        return 0;
 
 #define VID_CHANNEL_NUM 8
 
 struct cx25821_fmt {
-       char *name;
        u32 fourcc;             /* v4l2 format id */
        int depth;
        int flags;
 
        if (f->index != 0)
                return -EINVAL;
 
-       strscpy(f->description, "MPEG", sizeof(f->description));
        f->pixelformat = V4L2_PIX_FMT_MPEG;
-       f->flags = V4L2_FMT_FLAG_COMPRESSED;
        return 0;
 }
 
 
 
 static const struct cx8800_fmt formats[] = {
        {
-               .name     = "8 bpp, gray",
                .fourcc   = V4L2_PIX_FMT_GREY,
                .cxformat = ColorFormatY8,
                .depth    = 8,
                .flags    = FORMAT_FLAGS_PACKED,
        }, {
-               .name     = "15 bpp RGB, le",
                .fourcc   = V4L2_PIX_FMT_RGB555,
                .cxformat = ColorFormatRGB15,
                .depth    = 16,
                .flags    = FORMAT_FLAGS_PACKED,
        }, {
-               .name     = "15 bpp RGB, be",
                .fourcc   = V4L2_PIX_FMT_RGB555X,
                .cxformat = ColorFormatRGB15 | ColorFormatBSWAP,
                .depth    = 16,
                .flags    = FORMAT_FLAGS_PACKED,
        }, {
-               .name     = "16 bpp RGB, le",
                .fourcc   = V4L2_PIX_FMT_RGB565,
                .cxformat = ColorFormatRGB16,
                .depth    = 16,
                .flags    = FORMAT_FLAGS_PACKED,
        }, {
-               .name     = "16 bpp RGB, be",
                .fourcc   = V4L2_PIX_FMT_RGB565X,
                .cxformat = ColorFormatRGB16 | ColorFormatBSWAP,
                .depth    = 16,
                .flags    = FORMAT_FLAGS_PACKED,
        }, {
-               .name     = "24 bpp RGB, le",
                .fourcc   = V4L2_PIX_FMT_BGR24,
                .cxformat = ColorFormatRGB24,
                .depth    = 24,
                .flags    = FORMAT_FLAGS_PACKED,
        }, {
-               .name     = "32 bpp RGB, le",
                .fourcc   = V4L2_PIX_FMT_BGR32,
                .cxformat = ColorFormatRGB32,
                .depth    = 32,
                .flags    = FORMAT_FLAGS_PACKED,
        }, {
-               .name     = "32 bpp RGB, be",
                .fourcc   = V4L2_PIX_FMT_RGB32,
                .cxformat = ColorFormatRGB32 | ColorFormatBSWAP |
                            ColorFormatWSWAP,
                .depth    = 32,
                .flags    = FORMAT_FLAGS_PACKED,
        }, {
-               .name     = "4:2:2, packed, YUYV",
                .fourcc   = V4L2_PIX_FMT_YUYV,
                .cxformat = ColorFormatYUY2,
                .depth    = 16,
                .flags    = FORMAT_FLAGS_PACKED,
        }, {
-               .name     = "4:2:2, packed, UYVY",
                .fourcc   = V4L2_PIX_FMT_UYVY,
                .cxformat = ColorFormatYUY2 | ColorFormatBSWAP,
                .depth    = 16,
                break;
        }
        dprintk(2,
-               "[%p/%d] buffer_prepare - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
-               buf, buf->vb.vb2_buf.index,
-               core->width, core->height, dev->fmt->depth, dev->fmt->name,
+               "[%p/%d] %s - %dx%d %dbpp 0x%08x - dma=0x%08lx\n",
+               buf, buf->vb.vb2_buf.index, __func__,
+               core->width, core->height, dev->fmt->depth, dev->fmt->fourcc,
                (unsigned long)buf->risc.dma);
        return 0;
 }
        if (unlikely(f->index >= ARRAY_SIZE(formats)))
                return -EINVAL;
 
-       strscpy(f->description, formats[f->index].name, sizeof(f->description));
        f->pixelformat = formats[f->index].fourcc;
 
        return 0;
 
 /* static data                                                 */
 
 struct cx8800_fmt {
-       const char  *name;
        u32   fourcc;          /* v4l2 format id */
        int   depth;
        int   flags;
 
        if (f->index)
                return -EINVAL;
        f->pixelformat = V4L2_PIX_FMT_GREY;
-       strscpy(f->description, "8-bit Greyscale", sizeof(f->description));
        return 0;
 }
 
 
        if (f->index == 0) {
                /* standard YUV 422 capture */
                f->flags = 0;
-               strscpy(f->description, "YUV422", sizeof(f->description));
                f->pixelformat = V4L2_PIX_FMT_YUYV;
        } else {
                /* compressed MJPEG capture */
-               f->flags = V4L2_FMT_FLAG_COMPRESSED;
-               strscpy(f->description, "MJPEG", sizeof(f->description));
                f->pixelformat = V4L2_PIX_FMT_MJPEG;
        }
 
 
        if (f->index != 0)
                return -EINVAL;
 
-       strscpy(f->description, "MPEG TS", sizeof(f->description));
        f->pixelformat = V4L2_PIX_FMT_MPEG;
-       f->flags = V4L2_FMT_FLAG_COMPRESSED;
        return 0;
 }
 
 
 
 static struct saa7134_format formats[] = {
        {
-               .name     = "8 bpp gray",
                .fourcc   = V4L2_PIX_FMT_GREY,
                .depth    = 8,
                .pm       = 0x06,
        },{
-               .name     = "15 bpp RGB, le",
                .fourcc   = V4L2_PIX_FMT_RGB555,
                .depth    = 16,
                .pm       = 0x13 | 0x80,
        },{
-               .name     = "15 bpp RGB, be",
                .fourcc   = V4L2_PIX_FMT_RGB555X,
                .depth    = 16,
                .pm       = 0x13 | 0x80,
                .bswap    = 1,
        },{
-               .name     = "16 bpp RGB, le",
                .fourcc   = V4L2_PIX_FMT_RGB565,
                .depth    = 16,
                .pm       = 0x10 | 0x80,
        },{
-               .name     = "16 bpp RGB, be",
                .fourcc   = V4L2_PIX_FMT_RGB565X,
                .depth    = 16,
                .pm       = 0x10 | 0x80,
                .bswap    = 1,
        },{
-               .name     = "24 bpp RGB, le",
                .fourcc   = V4L2_PIX_FMT_BGR24,
                .depth    = 24,
                .pm       = 0x11,
        },{
-               .name     = "24 bpp RGB, be",
                .fourcc   = V4L2_PIX_FMT_RGB24,
                .depth    = 24,
                .pm       = 0x11,
                .bswap    = 1,
        },{
-               .name     = "32 bpp RGB, le",
                .fourcc   = V4L2_PIX_FMT_BGR32,
                .depth    = 32,
                .pm       = 0x12,
        },{
-               .name     = "32 bpp RGB, be",
                .fourcc   = V4L2_PIX_FMT_RGB32,
                .depth    = 32,
                .pm       = 0x12,
                .bswap    = 1,
                .wswap    = 1,
        },{
-               .name     = "4:2:2 packed, YUYV",
                .fourcc   = V4L2_PIX_FMT_YUYV,
                .depth    = 16,
                .pm       = 0x00,
                .bswap    = 1,
                .yuv      = 1,
        },{
-               .name     = "4:2:2 packed, UYVY",
                .fourcc   = V4L2_PIX_FMT_UYVY,
                .depth    = 16,
                .pm       = 0x00,
                .yuv      = 1,
        },{
-               .name     = "4:2:2 planar, Y-Cb-Cr",
                .fourcc   = V4L2_PIX_FMT_YUV422P,
                .depth    = 16,
                .pm       = 0x09,
                .hshift   = 1,
                .vshift   = 0,
        },{
-               .name     = "4:2:0 planar, Y-Cb-Cr",
                .fourcc   = V4L2_PIX_FMT_YUV420,
                .depth    = 12,
                .pm       = 0x0a,
                .hshift   = 1,
                .vshift   = 1,
        },{
-               .name     = "4:2:0 planar, Y-Cb-Cr",
                .fourcc   = V4L2_PIX_FMT_YVU420,
                .depth    = 12,
                .pm       = 0x0a,
                return err;
 
        dev->ovfield = dev->win.field;
-       video_dbg("start_preview %dx%d+%d+%d %s field=%s\n",
-               dev->win.w.width, dev->win.w.height,
-               dev->win.w.left, dev->win.w.top,
-               dev->ovfmt->name, v4l2_field_names[dev->ovfield]);
+       video_dbg("%s %dx%d+%d+%d 0x%08x field=%s\n", __func__,
+                 dev->win.w.width, dev->win.w.height,
+                 dev->win.w.left, dev->win.w.top,
+                 dev->ovfmt->fourcc, v4l2_field_names[dev->ovfield]);
 
        /* setup window + clipping */
        set_size(dev, TASK_B, dev->win.w.width, dev->win.w.height,
        if (f->index >= FORMATS)
                return -EINVAL;
 
-       strscpy(f->description, formats[f->index].name,
-               sizeof(f->description));
-
        f->pixelformat = formats[f->index].fourcc;
 
        return 0;
        if ((f->index >= FORMATS) || formats[f->index].planar)
                return -EINVAL;
 
-       strscpy(f->description, formats[f->index].name,
-               sizeof(f->description));
-
        f->pixelformat = formats[f->index].fourcc;
 
        return 0;
 
 };
 
 struct saa7134_format {
-       char           *name;
        unsigned int   fourcc;
        unsigned int   depth;
        unsigned int   pm;
 
        if (f->index != 0)
                return -EINVAL;
 
-       strscpy(f->description, "MPEG", sizeof(f->description));
        f->pixelformat = V4L2_PIX_FMT_MPEG;
 
        return 0;
 
                switch (dev_type) {
                case SOLO_DEV_6010:
                        f->pixelformat = V4L2_PIX_FMT_MPEG4;
-                       strscpy(f->description, "MPEG-4 part 2",
-                               sizeof(f->description));
                        break;
                case SOLO_DEV_6110:
                        f->pixelformat = V4L2_PIX_FMT_H264;
-                       strscpy(f->description, "H.264", sizeof(f->description));
                        break;
                }
                break;
        case 1:
                f->pixelformat = V4L2_PIX_FMT_MJPEG;
-               strscpy(f->description, "MJPEG", sizeof(f->description));
                break;
        default:
                return -EINVAL;
        }
-
-       f->flags = V4L2_FMT_FLAG_COMPRESSED;
-
        return 0;
 }
 
 
                return -EINVAL;
 
        f->pixelformat = V4L2_PIX_FMT_UYVY;
-       strscpy(f->description, "UYUV 4:2:2 Packed", sizeof(f->description));
-
        return 0;
 }
 
 
        if (f->index != 0)
                return -EINVAL;
 
-       strscpy(f->description, "4:2:2, packed, UYVY", sizeof(f->description));
        f->pixelformat = V4L2_PIX_FMT_UYVY;
-       f->flags = 0;
        return 0;
 }
 
 
  */
 static const struct tw68_format formats[] = {
        {
-               .name           = "15 bpp RGB, le",
                .fourcc         = V4L2_PIX_FMT_RGB555,
                .depth          = 16,
                .twformat       = ColorFormatRGB15,
        }, {
-               .name           = "15 bpp RGB, be",
                .fourcc         = V4L2_PIX_FMT_RGB555X,
                .depth          = 16,
                .twformat       = ColorFormatRGB15 | ColorFormatBSWAP,
        }, {
-               .name           = "16 bpp RGB, le",
                .fourcc         = V4L2_PIX_FMT_RGB565,
                .depth          = 16,
                .twformat       = ColorFormatRGB16,
        }, {
-               .name           = "16 bpp RGB, be",
                .fourcc         = V4L2_PIX_FMT_RGB565X,
                .depth          = 16,
                .twformat       = ColorFormatRGB16 | ColorFormatBSWAP,
        }, {
-               .name           = "24 bpp RGB, le",
                .fourcc         = V4L2_PIX_FMT_BGR24,
                .depth          = 24,
                .twformat       = ColorFormatRGB24,
        }, {
-               .name           = "24 bpp RGB, be",
                .fourcc         = V4L2_PIX_FMT_RGB24,
                .depth          = 24,
                .twformat       = ColorFormatRGB24 | ColorFormatBSWAP,
        }, {
-               .name           = "32 bpp RGB, le",
                .fourcc         = V4L2_PIX_FMT_BGR32,
                .depth          = 32,
                .twformat       = ColorFormatRGB32,
        }, {
-               .name           = "32 bpp RGB, be",
                .fourcc         = V4L2_PIX_FMT_RGB32,
                .depth          = 32,
                .twformat       = ColorFormatRGB32 | ColorFormatBSWAP |
                                  ColorFormatWSWAP,
        }, {
-               .name           = "4:2:2 packed, YUYV",
                .fourcc         = V4L2_PIX_FMT_YUYV,
                .depth          = 16,
                .twformat       = ColorFormatYUY2,
        }, {
-               .name           = "4:2:2 packed, UYVY",
                .fourcc         = V4L2_PIX_FMT_UYVY,
                .depth          = 16,
                .twformat       = ColorFormatYUY2 | ColorFormatBSWAP,
        if (f->index >= FORMATS)
                return -EINVAL;
 
-       strscpy(f->description, formats[f->index].name,
-               sizeof(f->description));
-
        f->pixelformat = formats[f->index].fourcc;
 
        return 0;
 
 };
 
 struct tw68_format {
-       char    *name;
        u32     fourcc;
        u32     depth;
        u32     twformat;
 
 #define FORMAT_IS_PLANAR       0x2
 
 struct saa7146_format {
-       char    *name;
        u32     pixelformat;
        u32     trans;
        u8      depth;