V4L/DVB (13590): cpia: convert it to use proc_fops

X-Patchwork-Id: 62090

Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

1 files changed, 105 insertions, 107 deletions

diff --git a/drivers/media/video/cpia.c b/drivers/media/video/cpia.c
index d6f2653afb6c..551ddf216a4b 100644
--- a/drivers/media/video/cpia.c
+++ b/drivers/media/video/cpia.c
@@ -32,6 +32,7 @@
 #include <linux/fs.h>
 #include <linux/vmalloc.h>
 #include <linux/sched.h>
+#include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/proc_fs.h>
 #include <linux/ctype.h>
@@ -244,72 +245,67 @@ static void rvfree(void *mem, unsigned long size)
 #ifdef CONFIG_PROC_FS
 static struct proc_dir_entry *cpia_proc_root=NULL;
 
-static int cpia_read_proc(char *page, char **start, off_t off,
-                          int count, int *eof, void *data)
+static int cpia_proc_show(struct seq_file *m, void *v)
 {
-        char *out = page;
-        int len, tmp;
-        struct cam_data *cam = data;
+        struct cam_data *cam = m->private;
+        int tmp;
         char tmpstr[29];
 
-        /* IMPORTANT: This output MUST be kept under PAGE_SIZE
-         *            or we need to get more sophisticated. */
-
-        out += sprintf(out, "read-only\n-----------------------\n");
-        out += sprintf(out, "V4L Driver version:       %d.%d.%d\n",
+        seq_printf(m, "read-only\n-----------------------\n");
+        seq_printf(m, "V4L Driver version:       %d.%d.%d\n",
                        CPIA_MAJ_VER, CPIA_MIN_VER, CPIA_PATCH_VER);
-        out += sprintf(out, "CPIA Version:             %d.%02d (%d.%d)\n",
+        seq_printf(m, "CPIA Version:             %d.%02d (%d.%d)\n",
                        cam->params.version.firmwareVersion,
                        cam->params.version.firmwareRevision,
                        cam->params.version.vcVersion,
                        cam->params.version.vcRevision);
-        out += sprintf(out, "CPIA PnP-ID:              %04x:%04x:%04x\n",
+        seq_printf(m, "CPIA PnP-ID:              %04x:%04x:%04x\n",
                        cam->params.pnpID.vendor, cam->params.pnpID.product,
                        cam->params.pnpID.deviceRevision);
-        out += sprintf(out, "VP-Version:               %d.%d %04x\n",
+        seq_printf(m, "VP-Version:               %d.%d %04x\n",
                        cam->params.vpVersion.vpVersion,
                        cam->params.vpVersion.vpRevision,
                        cam->params.vpVersion.cameraHeadID);
 
-        out += sprintf(out, "system_state:             %#04x\n",
+        seq_printf(m, "system_state:             %#04x\n",
                        cam->params.status.systemState);
-        out += sprintf(out, "grab_state:               %#04x\n",
+        seq_printf(m, "grab_state:               %#04x\n",
                        cam->params.status.grabState);
-        out += sprintf(out, "stream_state:             %#04x\n",
+        seq_printf(m, "stream_state:             %#04x\n",
                        cam->params.status.streamState);
-        out += sprintf(out, "fatal_error:              %#04x\n",
+        seq_printf(m, "fatal_error:              %#04x\n",
                        cam->params.status.fatalError);
-        out += sprintf(out, "cmd_error:                %#04x\n",
+        seq_printf(m, "cmd_error:                %#04x\n",
                        cam->params.status.cmdError);
-        out += sprintf(out, "debug_flags:              %#04x\n",
+        seq_printf(m, "debug_flags:              %#04x\n",
                        cam->params.status.debugFlags);
-        out += sprintf(out, "vp_status:                %#04x\n",
+        seq_printf(m, "vp_status:                %#04x\n",
                        cam->params.status.vpStatus);
-        out += sprintf(out, "error_code:               %#04x\n",
+        seq_printf(m, "error_code:               %#04x\n",
                        cam->params.status.errorCode);
         /* QX3 specific entries */
         if (cam->params.qx3.qx3_detected) {
-                out += sprintf(out, "button:                   %4d\n",
+                seq_printf(m, "button:                   %4d\n",
                                cam->params.qx3.button);
-                out += sprintf(out, "cradled:                  %4d\n",
+                seq_printf(m, "cradled:                  %4d\n",
                                cam->params.qx3.cradled);
         }
-        out += sprintf(out, "video_size:               %s\n",
+        seq_printf(m, "video_size:               %s\n",
                        cam->params.format.videoSize == VIDEOSIZE_CIF ?
                        "CIF " : "QCIF");
-        out += sprintf(out, "roi:                      (%3d, %3d) to (%3d, %3d)\n",
+        seq_printf(m, "roi:                      (%3d, %3d) to (%3d, %3d)\n",
                        cam->params.roi.colStart*8,
                        cam->params.roi.rowStart*4,
                        cam->params.roi.colEnd*8,
                        cam->params.roi.rowEnd*4);
-        out += sprintf(out, "actual_fps:               %3d\n", cam->fps);
-        out += sprintf(out, "transfer_rate:            %4dkB/s\n",
+        seq_printf(m, "actual_fps:               %3d\n", cam->fps);
+        seq_printf(m, "transfer_rate:            %4dkB/s\n",
                        cam->transfer_rate);
 
-        out += sprintf(out, "\nread-write\n");
-        out += sprintf(out, "-----------------------  current       min"
+        seq_printf(m, "\nread-write\n");
+        seq_printf(m, "-----------------------  current       min"
                        "       max   default  comment\n");
-        out += sprintf(out, "brightness:             %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "brightness:             %8d  %8d  %8d  %8d\n",
                        cam->params.colourParams.brightness, 0, 100, 50);
         if (cam->params.version.firmwareVersion == 1 &&
            cam->params.version.firmwareRevision == 2)
@@ -318,26 +314,26 @@ static int cpia_read_proc(char *page, char **start, off_t off,
         else
                 tmp = 96;
 
-        out += sprintf(out, "contrast:               %8d  %8d  %8d  %8d"
+        seq_printf(m, "contrast:               %8d  %8d  %8d  %8d"
                        "  steps of 8\n",
                        cam->params.colourParams.contrast, 0, tmp, 48);
-        out += sprintf(out, "saturation:             %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "saturation:             %8d  %8d  %8d  %8d\n",
                        cam->params.colourParams.saturation, 0, 100, 50);
         tmp = (25000+5000*cam->params.sensorFps.baserate)/
               (1<<cam->params.sensorFps.divisor);
-        out += sprintf(out, "sensor_fps:             %4d.%03d  %8d  %8d  %8d\n",
+        seq_printf(m, "sensor_fps:             %4d.%03d  %8d  %8d  %8d\n",
                        tmp/1000, tmp%1000, 3, 30, 15);
-        out += sprintf(out, "stream_start_line:      %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "stream_start_line:      %8d  %8d  %8d  %8d\n",
                        2*cam->params.streamStartLine, 0,
                        cam->params.format.videoSize == VIDEOSIZE_CIF ? 288:144,
                        cam->params.format.videoSize == VIDEOSIZE_CIF ? 240:120);
-        out += sprintf(out, "sub_sample:             %8s  %8s  %8s  %8s\n",
+        seq_printf(m, "sub_sample:             %8s  %8s  %8s  %8s\n",
                        cam->params.format.subSample == SUBSAMPLE_420 ?
                        "420" : "422", "420", "422", "422");
-        out += sprintf(out, "yuv_order:              %8s  %8s  %8s  %8s\n",
+        seq_printf(m, "yuv_order:              %8s  %8s  %8s  %8s\n",
                        cam->params.format.yuvOrder == YUVORDER_YUYV ?
                        "YUYV" : "UYVY", "YUYV" , "UYVY", "YUYV");
-        out += sprintf(out, "ecp_timing:             %8s  %8s  %8s  %8s\n",
+        seq_printf(m, "ecp_timing:             %8s  %8s  %8s  %8s\n",
                        cam->params.ecpTiming ? "slow" : "normal", "slow",
                        "normal", "normal");
 
@@ -346,13 +342,13 @@ static int cpia_read_proc(char *page, char **start, off_t off,
         } else {
                 sprintf(tmpstr, "manual");
         }
-        out += sprintf(out, "color_balance_mode:     %8s  %8s  %8s"
+        seq_printf(m, "color_balance_mode:     %8s  %8s  %8s"
                        "  %8s\n",  tmpstr, "manual", "auto", "auto");
-        out += sprintf(out, "red_gain:               %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "red_gain:               %8d  %8d  %8d  %8d\n",
                        cam->params.colourBalance.redGain, 0, 212, 32);
-        out += sprintf(out, "green_gain:             %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "green_gain:             %8d  %8d  %8d  %8d\n",
                        cam->params.colourBalance.greenGain, 0, 212, 6);
-        out += sprintf(out, "blue_gain:              %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "blue_gain:              %8d  %8d  %8d  %8d\n",
                        cam->params.colourBalance.blueGain, 0, 212, 92);
 
         if (cam->params.version.firmwareVersion == 1 &&
@@ -363,10 +359,10 @@ static int cpia_read_proc(char *page, char **start, off_t off,
                 sprintf(tmpstr, "%8d  %8d  %8d", 1, 8, 2);
 
         if (cam->params.exposure.gainMode == 0)
-                out += sprintf(out, "max_gain:                unknown  %28s"
+                seq_printf(m, "max_gain:                unknown  %28s"
                                "  powers of 2\n", tmpstr);
         else
-                out += sprintf(out, "max_gain:               %8d  %28s"
+                seq_printf(m, "max_gain:               %8d  %28s"
                                "  1,2,4 or 8 \n",
                                1<<(cam->params.exposure.gainMode-1), tmpstr);
 
@@ -382,12 +378,12 @@ static int cpia_read_proc(char *page, char **start, off_t off,
                 sprintf(tmpstr, "unknown");
                 break;
         }
-        out += sprintf(out, "exposure_mode:          %8s  %8s  %8s"
+        seq_printf(m, "exposure_mode:          %8s  %8s  %8s"
                        "  %8s\n",  tmpstr, "manual", "auto", "auto");
-        out += sprintf(out, "centre_weight:          %8s  %8s  %8s  %8s\n",
+        seq_printf(m, "centre_weight:          %8s  %8s  %8s  %8s\n",
                        (2-cam->params.exposure.centreWeight) ? "on" : "off",
                        "off", "on", "on");
-        out += sprintf(out, "gain:                   %8d  %8d  max_gain  %8d  1,2,4,8 possible\n",
+        seq_printf(m, "gain:                   %8d  %8d  max_gain  %8d  1,2,4,8 possible\n",
                        1<<cam->params.exposure.gain, 1, 1);
         if (cam->params.version.firmwareVersion == 1 &&
            cam->params.version.firmwareRevision == 2)
@@ -396,7 +392,7 @@ static int cpia_read_proc(char *page, char **start, off_t off,
         else
                 tmp = 510;
 
-        out += sprintf(out, "fine_exp:               %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "fine_exp:               %8d  %8d  %8d  %8d\n",
                        cam->params.exposure.fineExp*2, 0, tmp, 0);
         if (cam->params.version.firmwareVersion == 1 &&
            cam->params.version.firmwareRevision == 2)
@@ -405,127 +401,122 @@ static int cpia_read_proc(char *page, char **start, off_t off,
         else
                 tmp = MAX_EXP;
 
-        out += sprintf(out, "coarse_exp:             %8d  %8d  %8d"
+        seq_printf(m, "coarse_exp:             %8d  %8d  %8d"
                        "  %8d\n", cam->params.exposure.coarseExpLo+
                        256*cam->params.exposure.coarseExpHi, 0, tmp, 185);
-        out += sprintf(out, "red_comp:               %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "red_comp:               %8d  %8d  %8d  %8d\n",
                        cam->params.exposure.redComp, COMP_RED, 255, COMP_RED);
-        out += sprintf(out, "green1_comp:            %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "green1_comp:            %8d  %8d  %8d  %8d\n",
                        cam->params.exposure.green1Comp, COMP_GREEN1, 255,
                        COMP_GREEN1);
-        out += sprintf(out, "green2_comp:            %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "green2_comp:            %8d  %8d  %8d  %8d\n",
                        cam->params.exposure.green2Comp, COMP_GREEN2, 255,
                        COMP_GREEN2);
-        out += sprintf(out, "blue_comp:              %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "blue_comp:              %8d  %8d  %8d  %8d\n",
                        cam->params.exposure.blueComp, COMP_BLUE, 255, COMP_BLUE);
 
-        out += sprintf(out, "apcor_gain1:            %#8x  %#8x  %#8x  %#8x\n",
+        seq_printf(m, "apcor_gain1:            %#8x  %#8x  %#8x  %#8x\n",
                        cam->params.apcor.gain1, 0, 0xff, 0x1c);
-        out += sprintf(out, "apcor_gain2:            %#8x  %#8x  %#8x  %#8x\n",
+        seq_printf(m, "apcor_gain2:            %#8x  %#8x  %#8x  %#8x\n",
                        cam->params.apcor.gain2, 0, 0xff, 0x1a);
-        out += sprintf(out, "apcor_gain4:            %#8x  %#8x  %#8x  %#8x\n",
+        seq_printf(m, "apcor_gain4:            %#8x  %#8x  %#8x  %#8x\n",
                        cam->params.apcor.gain4, 0, 0xff, 0x2d);
-        out += sprintf(out, "apcor_gain8:            %#8x  %#8x  %#8x  %#8x\n",
+        seq_printf(m, "apcor_gain8:            %#8x  %#8x  %#8x  %#8x\n",
                        cam->params.apcor.gain8, 0, 0xff, 0x2a);
-        out += sprintf(out, "vl_offset_gain1:        %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "vl_offset_gain1:        %8d  %8d  %8d  %8d\n",
                        cam->params.vlOffset.gain1, 0, 255, 24);
-        out += sprintf(out, "vl_offset_gain2:        %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "vl_offset_gain2:        %8d  %8d  %8d  %8d\n",
                        cam->params.vlOffset.gain2, 0, 255, 28);
-        out += sprintf(out, "vl_offset_gain4:        %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "vl_offset_gain4:        %8d  %8d  %8d  %8d\n",
                        cam->params.vlOffset.gain4, 0, 255, 30);
-        out += sprintf(out, "vl_offset_gain8:        %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "vl_offset_gain8:        %8d  %8d  %8d  %8d\n",
                        cam->params.vlOffset.gain8, 0, 255, 30);
-        out += sprintf(out, "flicker_control:        %8s  %8s  %8s  %8s\n",
+        seq_printf(m, "flicker_control:        %8s  %8s  %8s  %8s\n",
                        cam->params.flickerControl.flickerMode ? "on" : "off",
                        "off", "on", "off");
-        out += sprintf(out, "mains_frequency:        %8d  %8d  %8d  %8d"
+        seq_printf(m, "mains_frequency:        %8d  %8d  %8d  %8d"
                        " only 50/60\n",
                        cam->mainsFreq ? 60 : 50, 50, 60, 50);
         if(cam->params.flickerControl.allowableOverExposure < 0)
-                out += sprintf(out, "allowable_overexposure: %4dauto      auto  %8d      auto\n",
+                seq_printf(m, "allowable_overexposure: %4dauto      auto  %8d      auto\n",
                                -cam->params.flickerControl.allowableOverExposure,
                                255);
         else
-                out += sprintf(out, "allowable_overexposure: %8d      auto  %8d      auto\n",
+                seq_printf(m, "allowable_overexposure: %8d      auto  %8d      auto\n",
                                cam->params.flickerControl.allowableOverExposure,
                                255);
-        out += sprintf(out, "compression_mode:       ");
+        seq_printf(m, "compression_mode:       ");
         switch(cam->params.compression.mode) {
         case CPIA_COMPRESSION_NONE:
-                out += sprintf(out, "%8s", "none");
+                seq_printf(m, "%8s", "none");
                 break;
         case CPIA_COMPRESSION_AUTO:
-                out += sprintf(out, "%8s", "auto");
+                seq_printf(m, "%8s", "auto");
                 break;
         case CPIA_COMPRESSION_MANUAL:
-                out += sprintf(out, "%8s", "manual");
+                seq_printf(m, "%8s", "manual");
                 break;
         default:
-                out += sprintf(out, "%8s", "unknown");
+                seq_printf(m, "%8s", "unknown");
                 break;
         }
-        out += sprintf(out, "    none,auto,manual      auto\n");
-        out += sprintf(out, "decimation_enable:      %8s  %8s  %8s  %8s\n",
+        seq_printf(m, "    none,auto,manual      auto\n");
+        seq_printf(m, "decimation_enable:      %8s  %8s  %8s  %8s\n",
                        cam->params.compression.decimation ==
                        DECIMATION_ENAB ? "on":"off", "off", "on",
                        "off");
-        out += sprintf(out, "compression_target:    %9s %9s %9s %9s\n",
+        seq_printf(m, "compression_target:    %9s %9s %9s %9s\n",
                        cam->params.compressionTarget.frTargeting  ==
                        CPIA_COMPRESSION_TARGET_FRAMERATE ?
                        "framerate":"quality",
                        "framerate", "quality", "quality");
-        out += sprintf(out, "target_framerate:       %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "target_framerate:       %8d  %8d  %8d  %8d\n",
                        cam->params.compressionTarget.targetFR, 1, 30, 15);
-        out += sprintf(out, "target_quality:         %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "target_quality:         %8d  %8d  %8d  %8d\n",
                        cam->params.compressionTarget.targetQ, 1, 64, 5);
-        out += sprintf(out, "y_threshold:            %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "y_threshold:            %8d  %8d  %8d  %8d\n",
                        cam->params.yuvThreshold.yThreshold, 0, 31, 6);
-        out += sprintf(out, "uv_threshold:           %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "uv_threshold:           %8d  %8d  %8d  %8d\n",
                        cam->params.yuvThreshold.uvThreshold, 0, 31, 6);
-        out += sprintf(out, "hysteresis:             %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "hysteresis:             %8d  %8d  %8d  %8d\n",
                        cam->params.compressionParams.hysteresis, 0, 255, 3);
-        out += sprintf(out, "threshold_max:          %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "threshold_max:          %8d  %8d  %8d  %8d\n",
                        cam->params.compressionParams.threshMax, 0, 255, 11);
-        out += sprintf(out, "small_step:             %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "small_step:             %8d  %8d  %8d  %8d\n",
                        cam->params.compressionParams.smallStep, 0, 255, 1);
-        out += sprintf(out, "large_step:             %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "large_step:             %8d  %8d  %8d  %8d\n",
                        cam->params.compressionParams.largeStep, 0, 255, 3);
-        out += sprintf(out, "decimation_hysteresis:  %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "decimation_hysteresis:  %8d  %8d  %8d  %8d\n",
                        cam->params.compressionParams.decimationHysteresis,
                        0, 255, 2);
-        out += sprintf(out, "fr_diff_step_thresh:    %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "fr_diff_step_thresh:    %8d  %8d  %8d  %8d\n",
                        cam->params.compressionParams.frDiffStepThresh,
                        0, 255, 5);
-        out += sprintf(out, "q_diff_step_thresh:     %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "q_diff_step_thresh:     %8d  %8d  %8d  %8d\n",
                        cam->params.compressionParams.qDiffStepThresh,
                        0, 255, 3);
-        out += sprintf(out, "decimation_thresh_mod:  %8d  %8d  %8d  %8d\n",
+        seq_printf(m, "decimation_thresh_mod:  %8d  %8d  %8d  %8d\n",
                        cam->params.compressionParams.decimationThreshMod,
                        0, 255, 2);
         /* QX3 specific entries */
         if (cam->params.qx3.qx3_detected) {
-                out += sprintf(out, "toplight:               %8s  %8s  %8s  %8s\n",
+                seq_printf(m, "toplight:               %8s  %8s  %8s  %8s\n",
                                cam->params.qx3.toplight ? "on" : "off",
                                "off", "on", "off");
-                out += sprintf(out, "bottomlight:            %8s  %8s  %8s  %8s\n",
+                seq_printf(m, "bottomlight:            %8s  %8s  %8s  %8s\n",
                                cam->params.qx3.bottomlight ? "on" : "off",
                                "off", "on", "off");
         }
 
-        len = out - page;
-        len -= off;
-        if (len < count) {
-                *eof = 1;
-                if (len <= 0) return 0;
-        } else
-                len = count;
-
-        *start = page + off;
-        return len;
+        return 0;
 }
 
+static int cpia_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, cpia_proc_show, PDE(inode)->data);
+}
 
-static int match(char *checkstr, char **buffer, unsigned long *count,
+static int match(char *checkstr, char **buffer, size_t *count,
                  int *find_colon, int *err)
 {
         int ret, colon_found = 1;
@@ -551,7 +542,7 @@ static int match(char *checkstr, char **buffer, unsigned long *count,
         return ret;
 }
 
-static unsigned long int value(char **buffer, unsigned long *count, int *err)
+static unsigned long int value(char **buffer, size_t *count, int *err)
 {
         char *p;
         unsigned long int ret;
@@ -565,10 +556,10 @@ static unsigned long int value(char **buffer, unsigned long *count, int *err)
         return ret;
 }
 
-static int cpia_write_proc(struct file *file, const char __user *buf,
-                           unsigned long count, void *data)
+static ssize_t cpia_proc_write(struct file *file, const char __user *buf,
+                               size_t count, loff_t *pos)
 {
-        struct cam_data *cam = data;
+        struct cam_data *cam = PDE(file->f_path.dentry->d_inode)->data;
         struct cam_params new_params;
         char *page, *buffer;
         int retval, find_colon;
@@ -582,7 +573,7 @@ static int cpia_write_proc(struct file *file, const char __user *buf,
          * from the comx driver
          */
         if (count > PAGE_SIZE) {
-                printk(KERN_ERR "count is %lu > %d!!!\n", count, (int)PAGE_SIZE);
+                printk(KERN_ERR "count is %zu > %d!!!\n", count, (int)PAGE_SIZE);
                 return -ENOSPC;
         }
 
@@ -1340,6 +1331,15 @@ out:
         return retval;
 }
 
+static const struct file_operations cpia_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = cpia_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = cpia_proc_write,
+};
+
 static void create_proc_cpia_cam(struct cam_data *cam)
 {
         struct proc_dir_entry *ent;
@@ -1347,14 +1347,12 @@ static void create_proc_cpia_cam(struct cam_data *cam)
         if (!cpia_proc_root || !cam)
                 return;
 
-        ent = create_proc_entry(video_device_node_name(&cam->vdev),
-                                S_IFREG|S_IRUGO|S_IWUSR, cpia_proc_root);
+        ent = proc_create_data(video_device_node_name(&cam->vdev),
+                               S_IRUGO|S_IWUSR, cpia_proc_root,
+                               &cpia_proc_fops, cam);
         if (!ent)
                 return;
 
-        ent->data = cam;
-        ent->read_proc = cpia_read_proc;
-        ent->write_proc = cpia_write_proc;
         /*
            size of the proc entry is 3736 bytes for the standard webcam;
            the extra features of the QX3 microscope add 189 bytes.