struct drm_display_mode *mode = NULL;
        struct drm_mode_set set;
        uint32_t __user *set_connectors_ptr;
-       int ret = 0;
+       int ret;
        int i;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
        struct drm_mode_fb_cmd2 *r = data;
        struct drm_mode_config *config = &dev->mode_config;
        struct drm_framebuffer *fb;
-       int ret = 0;
+       int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
        struct drm_framebuffer *fb;
        unsigned flags;
        int num_clips;
-       int ret = 0;
+       int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
        struct drm_display_mode *mode;
        struct drm_mode_object *obj;
        struct drm_mode_modeinfo *umode = &mode_cmd->mode;
-       int ret = 0;
+       int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
        struct drm_connector *connector;
        struct drm_display_mode mode;
        struct drm_mode_modeinfo *umode = &mode_cmd->mode;
-       int ret = 0;
+       int ret;
 
        if (!drm_core_check_feature(dev, DRIVER_MODESET))
                return -EINVAL;
                                            struct edid *edid)
 {
        struct drm_device *dev = connector->dev;
-       int ret = 0, size;
+       int ret, size;
 
        if (connector->edid_blob_ptr)
                drm_property_destroy_blob(dev, connector->edid_blob_ptr);
 
        int count = 0, ro, fail = 0;
        struct drm_crtc_helper_funcs *crtc_funcs;
        struct drm_mode_set save_set;
-       int ret = 0;
+       int ret;
        int i;
 
        DRM_DEBUG_KMS("\n");
 
 {
        char *connector_name = drm_get_connector_name(connector);
        char *edidname = edid_firmware, *last, *colon;
-       int ret = 0;
+       int ret;
 
        if (*edidname == '\0')
-               return ret;
+               return 0;
 
        colon = strchr(edidname, ':');
        if (colon != NULL) {
                if (strncmp(connector_name, edidname, colon - edidname))
-                       return ret;
+                       return 0;
                edidname = colon + 1;
                if (*edidname == '\0')
-                       return ret;
+                       return 0;
        }
 
        last = edidname + strlen(edidname) - 1;
 
                       int crtc_count, int max_conn_count)
 {
        struct drm_crtc *crtc;
-       int ret = 0;
        int i;
 
        fb_helper->dev = dev;
                                sizeof(struct drm_connector *),
                                GFP_KERNEL);
 
-               if (!fb_helper->crtc_info[i].mode_set.connectors) {
-                       ret = -ENOMEM;
+               if (!fb_helper->crtc_info[i].mode_set.connectors)
                        goto out_free;
-               }
                fb_helper->crtc_info[i].mode_set.num_connectors = 0;
        }
 
 
        struct drm_gem_mm *mm = dev->mm_private;
        struct drm_map_list *list;
        struct drm_local_map *map;
-       int ret = 0;
+       int ret;
 
        /* Set the object up for mmap'ing */
        list = &obj->map_list;
 
  */
 int drm_irq_install(struct drm_device *dev)
 {
-       int ret = 0;
+       int ret;
        unsigned long sh_flags = 0;
        char *irqname;
 
 u32 drm_get_last_vbltimestamp(struct drm_device *dev, int crtc,
                              struct timeval *tvblank, unsigned flags)
 {
-       int ret = 0;
+       int ret;
 
        /* Define requested maximum error on timestamps (nanoseconds). */
        int max_error = (int) drm_timestamp_precision * 1000;
                    struct drm_file *file_priv)
 {
        struct drm_modeset_ctl *modeset = data;
-       int ret = 0;
        unsigned int crtc;
 
        /* If drm_vblank_init() hasn't been called yet, just no-op */
        if (!dev->num_crtcs)
-               goto out;
+               return 0;
 
        crtc = modeset->crtc;
-       if (crtc >= dev->num_crtcs) {
-               ret = -EINVAL;
-               goto out;
-       }
+       if (crtc >= dev->num_crtcs)
+               return -EINVAL;
 
        switch (modeset->cmd) {
        case _DRM_PRE_MODESET:
                drm_vblank_post_modeset(dev, crtc);
                break;
        default:
-               ret = -EINVAL;
-               break;
+               return -EINVAL;
        }
 
-out:
-       return ret;
+       return 0;
 }
 
 static int drm_queue_vblank_event(struct drm_device *dev, int pipe,
                    struct drm_file *file_priv)
 {
        union drm_wait_vblank *vblwait = data;
-       int ret = 0;
+       int ret;
        unsigned int flags, seq, crtc, high_crtc;
 
        if ((!drm_dev_to_irq(dev)) || (!dev->irq_enabled))
 
 
 void drm_idlelock_take(struct drm_lock_data *lock_data)
 {
-       int ret = 0;
+       int ret;
 
        spin_lock_bh(&lock_data->spinlock);
        lock_data->kernel_waiters++;
 
 int drm_setmaster_ioctl(struct drm_device *dev, void *data,
                        struct drm_file *file_priv)
 {
-       int ret = 0;
+       int ret;
 
        if (file_priv->is_master)
                return 0;
 
        int attr_cnt = 0;
        int opt_cnt = 0;
        int i;
-       int ret = 0;
+       int ret;
 
        /* We shouldn't get called more than once for the same connector */
        BUG_ON(device_is_registered(&connector->kdev));