renesas/drm.git - libdrm, cloned from git://anongit.freedesktop.org/mesa/drm

diff options

author	Jesse Barnes <jbarnes@jbarnes-t61.(none)>	2008-06-04 09:38:44 -0700
committer	Jesse Barnes <jbarnes@virtuousgeek.org>	2008-06-04 09:38:44 -0700
commit	52183fb05b8f8db0705e230fc0b8a436512759a1 (patch)
tree	efdcacf80088ebe04c5a6d03692f1e015f937693 /bsd-core/mach64_drv.h
parent	cf1964f971cc298ece91064953f7d00ed13e541d (diff)

Fix crash in drm_mode_connector_update_edid_property

We need to initialize the edid_blob_ptr to NULL when we init a connector, otherwise drm_mode_connector_update_edid_property may think there's a valid EDID lying around and try to destroy it, causing a crash.

Diffstat (limited to 'bsd-core/mach64_drv.h')

0 files changed, 0 insertions, 0 deletions

/* * drm_sysfs.c - Modifications to drm_sysfs_class.c to support * extra sysfs attribute from DRM. Normal drm_sysfs_class * does not allow adding attributes. * * Copyright (c) 2004 Jon Smirl <jonsmirl@gmail.com> * Copyright (c) 2003-2004 Greg Kroah-Hartman <greg@kroah.com> * Copyright (c) 2003-2004 IBM Corp. * * This file is released under the GPLv2 * */ #include <linux/device.h> #include <linux/kdev_t.h> #include <linux/err.h> #include "drm_core.h" #include "drmP.h" #define to_drm_minor(d) container_of(d, struct drm_minor, kdev) /** * drm_sysfs_suspend - DRM class suspend hook * @dev: Linux device to suspend * @state: power state to enter * * Just figures out what the actual struct drm_device associated with * @dev is and calls its suspend hook, if present. */ static int drm_sysfs_suspend(struct device *dev, pm_message_t state) { struct drm_minor *drm_minor = to_drm_minor(dev); struct drm_device *drm_dev = drm_minor->dev; printk(KERN_ERR "%s\n", __FUNCTION__); if (drm_minor->type == DRM_MINOR_CONTROL) if (drm_dev->driver->suspend) return drm_dev->driver->suspend(drm_dev, state); return 0; } /** * drm_sysfs_resume - DRM class resume hook * @dev: Linux device to resume * * Just figures out what the actual struct drm_device associated with * @dev is and calls its resume hook, if present. */ static int drm_sysfs_resume(struct device *dev) { struct drm_minor *drm_minor = to_drm_minor(dev); struct drm_device *drm_dev = drm_minor->dev; if (drm_minor->type == DRM_MINOR_CONTROL) if (drm_dev->driver->resume) return drm_dev->driver->resume(drm_dev); return 0; } /* Display the version of drm_core. This doesn't work right in current design */ static ssize_t version_show(struct class *dev, char *buf) { return sprintf(buf, "%s %d.%d.%d %s\n", CORE_NAME, CORE_MAJOR, CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE); } static CLASS_ATTR(version, S_IRUGO, version_show, NULL); /** * drm_sysfs_create - create a struct drm_sysfs_class structure * @owner: pointer to the module that is to "own" this struct drm_sysfs_class * @name: pointer to a string for the name of this class. * * This is used to create DRM class pointer that can then be used * in calls to drm_sysfs_device_add(). * * Note, the pointer created here is to be destroyed when finished by making a * call to drm_sysfs_destroy(). */ struct class *drm_sysfs_create(struct module *owner, char *name) { struct class *class; int err; class = class_create(owner, name); if (IS_ERR(class)) { err = PTR_ERR(class); goto err_out; } #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)) class->suspend = drm_sysfs_suspend; class->resume = drm_sysfs_resume; #endif err = class_create_file(class, &class_attr_version); if (err) goto err_out_class; return class; err_out_class: class_destroy(class); err_out: return ERR_PTR(err); } /** * drm_sysfs_destroy - destroys DRM class * * Destroy the DRM device class. */ void drm_sysfs_destroy(void) { if ((drm_class == NULL) || (IS_ERR(drm_class))) return; class_remove_file(drm_class, &class_attr_version); class_destroy(drm_class); } static ssize_t show_dri(struct device *device, struct device_attribute *attr, char *buf) { struct drm_minor *drm_minor = to_drm_minor(device); struct drm_device *drm_dev = drm_minor->dev; if (drm_dev->driver->dri_library_name) return drm_dev->driver->dri_library_name(drm_dev, buf); return snprintf(buf, PAGE_SIZE, "%s\n", drm_dev->driver->pci_driver.name); } /** * drm_sysfs_device_release - do nothing * @dev: Linux device * * Normally, this would free the DRM device associated with @dev, along * with cleaning up any other stuff. But we do that in the DRM core, so * this function can just return and hope that the core does its job. */ static void drm_sysfs_device_release(struct device *dev) { return; } /* * Connector properties */ static ssize_t status_show(struct device *device, struct device_attribute *attr, char *buf) { struct drm_connector *connector = container_of(device, struct drm_connector, kdev); return snprintf(buf, PAGE_SIZE, "%s", drm_get_connector_status_name(connector->funcs->detect(connector))); } static ssize_t dpms_show(struct device *device, struct device_attribute *attr, char *buf) { struct drm_connector *connector = container_of(device, struct drm_connector, kdev); struct drm_device *dev = connector->dev; uint64_t dpms_status; int ret; ret = drm_connector_property_get_value(connector, dev->mode_config.dpms_property, &dpms_status); if (ret) return 0; return snprintf(buf, PAGE_SIZE, "%s", drm_get_dpms_name((int)dpms_status)); } static ssize_t enabled_show(struct device *device, struct device_attribute *attr, char *buf) { struct drm_connector *connector = container_of(device, struct drm_connector, kdev); if (connector->encoder) return snprintf(buf, PAGE_SIZE, "enabled"); else return snprintf(buf, PAGE_SIZE, "disabled"); } static ssize_t edid_show(struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t off, size_t count) { struct device *connector_dev = container_of(kobj, struct device, kobj); struct drm_connector *connector = container_of(connector_dev, struct drm_connector, kdev); unsigned char *edid; size_t size; if (!connector->edid_blob_ptr) return 0; edid = connector->edid_blob_ptr->data; size = connector->edid_blob_ptr->length; if (!edid) return 0; if (off >= size) return 0; if (off + count > size) count = size - off; memcpy(buf, edid + off, count); return count; } static ssize_t modes_show(struct device *device, struct device_attribute *attr, char *buf) { struct drm_connector *connector = container_of(device, struct drm_connector, kdev); struct drm_display_mode *mode; int written = 0; list_for_each_entry(mode, &connector->modes, head) { written += snprintf(buf + written, PAGE_SIZE - written, "%s\n", mode->name); } return written; } static ssize_t subconnector_show(struct device *device, struct device_attribute *attr, char *buf) { struct drm_connector *connector = container_of(device, struct drm_connector, kdev); struct drm_device *dev = connector->dev; struct drm_property *prop = NULL; uint64_t subconnector; int ret; switch (connector->connector_type) { case DRM_MODE_CONNECTOR_DVII: prop = dev->mode_config.dvi_i_subconnector_property; break; case DRM_MODE_CONNECTOR_Composite: case DRM_MODE_CONNECTOR_SVIDEO: case DRM_MODE_CONNECTOR_Component: prop = dev->mode_config.tv_subconnector_property; break; default: DRM_ERROR("Wrong connector type for this property\n"); return 0; } if (!prop) { DRM_ERROR("Unable to find subconnector property\n"); return 0; } ret = drm_connector_property_get_value(connector, prop, &subconnector); if (ret) return 0; return snprintf(buf, PAGE_SIZE, "%s", drm_get_subconnector_name((int)subconnector)); } static ssize_t select_subconnector_show(struct device *device, struct device_attribute *attr, char *buf) { struct drm_connector *connector = container_of(device, struct drm_connector, kdev); struct drm_device *dev = connector->dev; struct drm_property *prop = NULL; uint64_t subconnector; int ret; switch (connector->connector_type) { case DRM_MODE_CONNECTOR_DVII:


context:
space:
mode: