| /drivers/video/drm/idr.c |
|---|
| File deleted |
| /drivers/video/drm/i2c/i2c-core.c |
|---|
| File deleted |
| /drivers/video/drm/i2c/i2c-algo-bit.c |
|---|
| File deleted |
| /drivers/video/drm/drm_crtc.c |
|---|
| 222,7 → 222,6 |
| obj->id = new_id; |
| obj->type = obj_type; |
| return 0; |
| } |
| 362,8 → 361,6 |
| void drm_crtc_init(struct drm_device *dev, struct drm_crtc *crtc, |
| const struct drm_crtc_funcs *funcs) |
| { |
| ENTRY(); |
| crtc->dev = dev; |
| crtc->funcs = funcs; |
| 372,10 → 369,7 |
| list_add_tail(&crtc->head, &dev->mode_config.crtc_list); |
| dev->mode_config.num_crtc++; |
| // mutex_unlock(&dev->mode_config.mutex); |
| LEAVE(); |
| } |
| EXPORT_SYMBOL(drm_crtc_init); |
| 592,7 → 586,6 |
| struct drm_property *dpms; |
| int i; |
| ENTRY(); |
| /* |
| * Standard properties (apply to all connectors) |
| */ |
| 608,7 → 601,6 |
| drm_dpms_enum_list[i].name); |
| dev->mode_config.dpms_property = dpms; |
| LEAVE(); |
| return 0; |
| } |
| 802,8 → 794,6 |
| */ |
| void drm_mode_config_init(struct drm_device *dev) |
| { |
| ENTRY(); |
| // mutex_init(&dev->mode_config.mutex); |
| // mutex_init(&dev->mode_config.idr_mutex); |
| INIT_LIST_HEAD(&dev->mode_config.fb_list); |
| 813,7 → 803,6 |
| INIT_LIST_HEAD(&dev->mode_config.encoder_list); |
| INIT_LIST_HEAD(&dev->mode_config.property_list); |
| INIT_LIST_HEAD(&dev->mode_config.property_blob_list); |
| idr_init(&dev->mode_config.crtc_idr); |
| // mutex_lock(&dev->mode_config.mutex); |
| 825,9 → 814,6 |
| dev->mode_config.num_connector = 0; |
| dev->mode_config.num_crtc = 0; |
| dev->mode_config.num_encoder = 0; |
| LEAVE(); |
| } |
| EXPORT_SYMBOL(drm_mode_config_init); |
| 1960,7 → 1946,6 |
| } |
| drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY); |
| property->flags = flags; |
| property->num_values = num_values; |
| INIT_LIST_HEAD(&property->enum_blob_list); |
| 1968,11 → 1953,7 |
| if (name) |
| strncpy(property->name, name, DRM_PROP_NAME_LEN); |
| list_add_tail(&property->head, &dev->mode_config.property_list); |
| dbgprintf("%s %x name %s\n", __FUNCTION__, property, name); |
| return property; |
| fail: |
| kfree(property); |
| /drivers/video/drm/drm_crtc_helper.c |
|---|
| 479,8 → 479,6 |
| drm_pick_crtcs(dev, crtcs, modes, 0, width, height); |
| dbgprintf("done\n"); |
| i = 0; |
| list_for_each_entry(connector, &dev->mode_config.connector_list, head) { |
| struct drm_display_mode *mode = modes[i]; |
| 504,8 → 502,6 |
| kfree(crtcs); |
| kfree(modes); |
| kfree(enabled); |
| LEAVE(); |
| } |
| /** |
| 522,7 → 518,7 |
| struct drm_crtc *tmp; |
| int crtc_mask = 1; |
| // WARN(!crtc, "checking null crtc?"); |
| WARN(!crtc, "checking null crtc?"); |
| dev = crtc->dev; |
| 913,7 → 909,7 |
| drm_setup_crtcs(dev); |
| /* alert the driver fb layer */ |
| // dev->mode_config.funcs->fb_changed(dev); |
| dev->mode_config.funcs->fb_changed(dev); |
| /* FIXME: send hotplug event */ |
| return true; |
| 937,8 → 933,6 |
| struct drm_connector *connector; |
| int count = 0; |
| ENTRY(); |
| count = drm_helper_probe_connector_modes(dev, |
| dev->mode_config.max_width, |
| dev->mode_config.max_height); |
| 958,10 → 952,8 |
| drm_setup_crtcs(dev); |
| /* alert the driver fb layer */ |
| // dev->mode_config.funcs->fb_changed(dev); |
| dev->mode_config.funcs->fb_changed(dev); |
| LEAVE(); |
| return 0; |
| } |
| EXPORT_SYMBOL(drm_helper_initial_config); |
| /drivers/video/drm/drm_edid.c |
|---|
| 27,12 → 27,8 |
| * DEALINGS IN THE SOFTWARE. |
| */ |
| //#include <linux/kernel.h> |
| #include <types.h> |
| #include <list.h> |
| #include <linux/idr.h> |
| #include <linux/i2c.h> |
| #include <linux/i2c-algo-bit.h> |
| //#include <linux/i2c.h> |
| //#include <linux/i2c-algo-bit.h> |
| #include "drmP.h" |
| #include "drm_edid.h" |
| /drivers/video/drm/include/errno.h |
|---|
| File deleted |
| /drivers/video/drm/include/linux/i2c.h |
|---|
| File deleted |
| /drivers/video/drm/include/linux/idr.h |
|---|
| File deleted |
| /drivers/video/drm/include/linux/bitops.h |
|---|
| File deleted |
| /drivers/video/drm/include/linux/i2c-algo-bit.h |
|---|
| File deleted |
| /drivers/video/drm/include/drmP.h |
|---|
| 67,9 → 67,6 |
| __func__, ##args); \ |
| } while (0) |
| #define DRM_DEBUG(fmt, arg...) \ |
| printk("[" DRM_NAME ":%s] " fmt , __func__ , ##arg) |
| #if 0 |
| /***********************************************************************/ |
| /drivers/video/drm/include/drm_crtc.h |
|---|
| 25,10 → 25,10 |
| #ifndef __DRM_CRTC_H__ |
| #define __DRM_CRTC_H__ |
| #include <linux/i2c.h> |
| //#include <linux/i2c.h> |
| //#include <linux/spinlock.h> |
| //#include <linux/types.h> |
| #include <linux/idr.h> |
| //#include <linux/idr.h> |
| //#include <linux/fb.h> |
| /drivers/video/drm/include/drm_edid.h |
|---|
| 193,6 → 193,97 |
| #define EDID_PRODUCT_ID(e) ((e)->prod_code[0] | ((e)->prod_code[1] << 8)) |
| #define KOBJ_NAME_LEN 20 |
| #define I2C_NAME_SIZE 20 |
| /* --- Defines for bit-adapters --------------------------------------- */ |
| /* |
| * This struct contains the hw-dependent functions of bit-style adapters to |
| * manipulate the line states, and to init any hw-specific features. This is |
| * only used if you have more than one hw-type of adapter running. |
| */ |
| struct i2c_algo_bit_data { |
| void *data; /* private data for lowlevel routines */ |
| void (*setsda) (void *data, int state); |
| void (*setscl) (void *data, int state); |
| int (*getsda) (void *data); |
| int (*getscl) (void *data); |
| /* local settings */ |
| int udelay; /* half clock cycle time in us, |
| minimum 2 us for fast-mode I2C, |
| minimum 5 us for standard-mode I2C and SMBus, |
| maximum 50 us for SMBus */ |
| int timeout; /* in jiffies */ |
| }; |
| struct i2c_client; |
| /* |
| * i2c_adapter is the structure used to identify a physical i2c bus along |
| * with the access algorithms necessary to access it. |
| */ |
| struct i2c_adapter { |
| // struct module *owner; |
| unsigned int id; |
| unsigned int class; |
| // const struct i2c_algorithm *algo; /* the algorithm to access the bus */ |
| void *algo_data; |
| /* --- administration stuff. */ |
| int (*client_register)(struct i2c_client *); |
| int (*client_unregister)(struct i2c_client *); |
| /* data fields that are valid for all devices */ |
| u8 level; /* nesting level for lockdep */ |
| // struct mutex bus_lock; |
| // struct mutex clist_lock; |
| int timeout; |
| int retries; |
| // struct device dev; /* the adapter device */ |
| int nr; |
| struct list_head clients; /* DEPRECATED */ |
| char name[48]; |
| // struct completion dev_released; |
| }; |
| #define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev) |
| struct i2c_client { |
| unsigned short flags; /* div., see below */ |
| unsigned short addr; /* chip address - NOTE: 7bit */ |
| /* addresses are stored in the */ |
| /* _LOWER_ 7 bits */ |
| char name[I2C_NAME_SIZE]; |
| struct i2c_adapter *adapter; /* the adapter we sit on */ |
| // struct i2c_driver *driver; /* and our access routines */ |
| // struct device dev; /* the device structure */ |
| int irq; /* irq issued by device (or -1) */ |
| char driver_name[KOBJ_NAME_LEN]; |
| struct list_head list; /* DEPRECATED */ |
| // struct completion released; |
| }; |
| #define to_i2c_client(d) container_of(d, struct i2c_client, dev) |
| int i2c_bit_add_bus(struct i2c_adapter *); |
| int i2c_bit_add_numbered_bus(struct i2c_adapter *); |
| struct i2c_msg { |
| u16 addr; /* slave address */ |
| u16 flags; |
| #define I2C_M_TEN 0x0010 /* this is a ten bit chip address */ |
| #define I2C_M_RD 0x0001 /* read data, from slave to master */ |
| #define I2C_M_NOSTART 0x4000 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
| #define I2C_M_REV_DIR_ADDR 0x2000 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
| #define I2C_M_IGNORE_NAK 0x1000 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
| #define I2C_M_NO_RD_ACK 0x0800 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
| #define I2C_M_RECV_LEN 0x0400 /* length will be first received byte */ |
| u16 len; /* msg length */ |
| u8 *buf; /* pointer to msg data */ |
| }; |
| #endif /* __DRM_EDID_H__ */ |
| /drivers/video/drm/include/types.h |
|---|
| 86,6 → 86,9 |
| #define DRM_INFO(fmt, arg...) dbgprintf("DRM: "fmt , ##arg) |
| #define DRM_DEBUG(fmt, arg...) \ |
| printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ##arg) |
| #define DRM_ERROR(fmt, arg...) \ |
| printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ##arg) |
| 227,6 → 230,24 |
| #define EXPORT_SYMBOL(x) |
| #define IDR_BITS 5 |
| #define IDR_FULL 0xfffffffful |
| struct idr_layer { |
| unsigned long bitmap; /* A zero bit means "space here" */ |
| struct idr_layer *ary[1<<IDR_BITS]; |
| int count; /* When zero, we can release it */ |
| }; |
| struct idr { |
| struct idr_layer *top; |
| struct idr_layer *id_free; |
| int layers; |
| int id_free_cnt; |
| // spinlock_t lock; |
| }; |
| #define min(x,y) ({ \ |
| typeof(x) _x = (x); \ |
| typeof(y) _y = (y); \ |
| 271,10 → 292,7 |
| { |
| if (n != 0 && size > ULONG_MAX / n) |
| return NULL; |
| return kzalloc(n * size, 0); |
| return kmalloc(n * size, 0); |
| } |
| #define ENTRY() dbgprintf("entry %s\n",__FUNCTION__) |
| #define LEAVE() dbgprintf("leave %s\n",__FUNCTION__) |
| #endif //__TYPES_H__ |
| /drivers/video/drm/radeon/radeon_encoders.c |
|---|
| File deleted |
| /drivers/video/drm/radeon/radeon_fence.c |
|---|
| File deleted |
| /drivers/video/drm/radeon/atikms.lds |
|---|
| File deleted |
| /drivers/video/drm/radeon/makefile |
|---|
| File deleted |
| /drivers/video/drm/radeon/atombios_crtc.c |
|---|
| 549,9 → 549,6 |
| radeon_crtc->crtc_offset = |
| AVIVO_D2CRTC_H_TOTAL - AVIVO_D1CRTC_H_TOTAL; |
| drm_crtc_helper_add(&radeon_crtc->base, &atombios_helper_funcs); |
| dbgprintf("done %s\n",__FUNCTION__); |
| } |
| void radeon_init_disp_bw_avivo(struct drm_device *dev, |
| /drivers/video/drm/radeon/radeon_atombios.c |
|---|
| 447,7 → 447,7 |
| struct bios_connector bios_connectors[ATOM_MAX_SUPPORTED_DEVICE]; |
| atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset); |
| ENTRY(); |
| supported_devices = |
| (union atom_supported_devices *)(ctx->bios + data_offset); |
| 596,7 → 596,7 |
| } |
| radeon_link_encoder_connector(dev); |
| LEAVE(); |
| return true; |
| } |
| /drivers/video/drm/radeon/radeon_device.c |
|---|
| 37,9 → 37,11 |
| #include <syscall.h> |
| int radeon_modeset = -1; |
| int radeon_dynclks = -1; |
| int radeon_r4xx_atom = 0; |
| int radeon_agpmode = -1; |
| int radeon_agpmode = 0; |
| int radeon_vram_limit = 0; |
| int radeon_gart_size = 512; /* default gart size */ |
| int radeon_benchmarking = 0; |
| int radeon_connector_table = 0; |
| 515,6 → 517,7 |
| if (r) { |
| return r; |
| } |
| // r = radeon_init(rdev); |
| r = rdev->asic->init(rdev); |
| 636,15 → 639,14 |
| if (!r) { |
| r = radeon_cp_init(rdev, 1024 * 1024); |
| } |
| // if (!r) { |
| // r = radeon_wb_init(rdev); |
| // if (r) { |
| // DRM_ERROR("radeon: failled initializing WB (%d).\n", r); |
| // return r; |
| // } |
| // } |
| if (!r) { |
| r = radeon_wb_init(rdev); |
| if (r) { |
| DRM_ERROR("radeon: failled initializing WB (%d).\n", r); |
| return r; |
| } |
| } |
| #if 0 |
| if (!r) { |
| r = radeon_ib_pool_init(rdev); |
| if (r) { |
| 652,6 → 654,8 |
| return r; |
| } |
| } |
| #if 0 |
| if (!r) { |
| r = radeon_ib_test(rdev); |
| if (r) { |
| 659,16 → 663,14 |
| return r; |
| } |
| } |
| #endif |
| ret = r; |
| r = radeon_modeset_init(rdev); |
| if (r) { |
| return r; |
| } |
| // if (rdev->fbdev_rfb && rdev->fbdev_rfb->obj) { |
| // rdev->fbdev_robj = rdev->fbdev_rfb->obj->driver_private; |
| // } |
| if (rdev->fbdev_rfb && rdev->fbdev_rfb->obj) { |
| rdev->fbdev_robj = rdev->fbdev_rfb->obj->driver_private; |
| } |
| if (!ret) { |
| DRM_INFO("radeon: kernel modesetting successfully initialized.\n"); |
| } |
| 676,7 → 678,9 |
| // radeon_benchmark(rdev); |
| // } |
| return -1; |
| #endif |
| return ret; |
| } |
| static struct pci_device_id pciidlist[] = { |
| /drivers/video/drm/radeon/radeon_display.c |
|---|
| 179,8 → 179,6 |
| struct radeon_crtc *radeon_crtc; |
| int i; |
| ENTRY(); |
| radeon_crtc = kzalloc(sizeof(struct radeon_crtc) + (RADEONFB_CONN_LIMIT * sizeof(struct drm_connector *)), GFP_KERNEL); |
| if (radeon_crtc == NULL) |
| return; |
| 204,8 → 202,6 |
| radeon_atombios_init_crtc(dev, radeon_crtc); |
| else |
| radeon_legacy_init_crtc(dev, radeon_crtc); |
| LEAVE(); |
| } |
| static const char *encoder_names[34] = { |
| 322,8 → 318,6 |
| struct drm_connector *drm_connector; |
| bool ret = false; |
| ENTRY(); |
| if (rdev->bios) { |
| if (rdev->is_atom_bios) { |
| if (rdev->family >= CHIP_R600) |
| 341,7 → 335,6 |
| list_for_each_entry(drm_connector, &dev->mode_config.connector_list, head) |
| radeon_ddc_dump(drm_connector); |
| } |
| LEAVE(); |
| return ret; |
| } |
| 591,8 → 584,6 |
| .create_handle = radeon_user_framebuffer_create_handle, |
| }; |
| #endif |
| struct drm_framebuffer * |
| radeon_framebuffer_create(struct drm_device *dev, |
| struct drm_mode_fb_cmd *mode_cmd, |
| 604,8 → 595,8 |
| if (radeon_fb == NULL) { |
| return NULL; |
| } |
| // drm_framebuffer_init(dev, &radeon_fb->base, &radeon_fb_funcs); |
| // drm_helper_mode_fill_fb_struct(&radeon_fb->base, mode_cmd); |
| drm_framebuffer_init(dev, &radeon_fb->base, &radeon_fb_funcs); |
| drm_helper_mode_fill_fb_struct(&radeon_fb->base, mode_cmd); |
| radeon_fb->obj = obj; |
| return &radeon_fb->base; |
| } |
| 617,25 → 608,20 |
| { |
| struct drm_gem_object *obj; |
| return NULL; |
| obj = drm_gem_object_lookup(dev, file_priv, mode_cmd->handle); |
| // obj = drm_gem_object_lookup(dev, file_priv, mode_cmd->handle); |
| // |
| // return radeon_framebuffer_create(dev, mode_cmd, obj); |
| return radeon_framebuffer_create(dev, mode_cmd, obj); |
| } |
| static const struct drm_mode_config_funcs radeon_mode_funcs = { |
| // .fb_create = radeon_user_framebuffer_create, |
| // .fb_changed = radeonfb_probe, |
| .fb_create = radeon_user_framebuffer_create, |
| .fb_changed = radeonfb_probe, |
| }; |
| #endif |
| int radeon_modeset_init(struct radeon_device *rdev) |
| { |
| dbgprintf("%s\n",__FUNCTION__); |
| int num_crtc = 2, i; |
| int ret; |
| 642,7 → 628,7 |
| drm_mode_config_init(rdev->ddev); |
| rdev->mode_info.mode_config_initialized = true; |
| rdev->ddev->mode_config.funcs = (void *)&radeon_mode_funcs; |
| // rdev->ddev->mode_config.funcs = (void *)&radeon_mode_funcs; |
| if (ASIC_IS_AVIVO(rdev)) { |
| rdev->ddev->mode_config.max_width = 8192; |
| 665,9 → 651,6 |
| return ret; |
| } |
| drm_helper_initial_config(rdev->ddev); |
| dbgprintf("done %s\n",__FUNCTION__); |
| return 0; |
| } |
| /drivers/video/drm/radeon/radeon_i2c.c |
|---|
| 179,7 → 179,7 |
| i2c->algo.timeout = 2; |
| i2c->algo.data = i2c; |
| i2c->rec = *rec; |
| // i2c_set_adapdata(&i2c->adapter, i2c); |
| i2c_set_adapdata(&i2c->adapter, i2c); |
| ret = i2c_bit_add_bus(&i2c->adapter); |
| if (ret) { |
| 199,7 → 199,7 |
| if (!i2c) |
| return; |
| // i2c_del_adapter(&i2c->adapter); |
| i2c_del_adapter(&i2c->adapter); |
| kfree(i2c); |
| } |
| /drivers/video/drm/radeon/radeon_mode.h |
|---|
| 30,12 → 30,14 |
| #ifndef RADEON_MODE_H |
| #define RADEON_MODE_H |
| #include <drm_crtc.h> |
| #include <drm_mode.h> |
| #include "drm_mode.h" |
| #include "drm_crtc.h" |
| #include <drm_edid.h> |
| #include <linux/i2c.h> |
| #include <linux/i2c-algo-bit.h> |
| //#include <linux/i2c.h> |
| //#include <linux/i2c-id.h> |
| //#include <linux/i2c-algo-bit.h> |
| #define to_radeon_crtc(x) container_of(x, struct radeon_crtc, base) |
| #define to_radeon_connector(x) container_of(x, struct radeon_connector, base) |
| #define to_radeon_encoder(x) container_of(x, struct radeon_encoder, base) |
| /drivers/video/drm/radeon/r100.c |
|---|
| 26,8 → 26,8 |
| * Jerome Glisse |
| */ |
| //#include <linux/seq_file.h> |
| #include "drmP.h" |
| #include "drm.h" |
| //#include "drmP.h" |
| //#include "drm.h" |
| #include "radeon_drm.h" |
| #include "radeon_microcode.h" |
| #include "radeon_reg.h" |
| /drivers/video/drm/radeon/r300.c |
|---|
| 26,8 → 26,8 |
| * Jerome Glisse |
| */ |
| //#include <linux/seq_file.h> |
| #include "drmP.h" |
| #include "drm.h" |
| //#include "drmP.h" |
| //#include "drm.h" |
| #include "radeon_reg.h" |
| #include "radeon.h" |
| /drivers/video/drm/radeon/r520.c |
|---|
| 25,7 → 25,7 |
| * Alex Deucher |
| * Jerome Glisse |
| */ |
| #include "drmP.h" |
| //#include "drmP.h" |
| #include "radeon_reg.h" |
| #include "radeon.h" |
| 501,4 → 501,4 |
| //domodedovo 9-00 16/07/2009 |
| /drivers/video/drm/radeon/radeon_asic.h |
|---|
| 403,8 → 403,8 |
| .gpu_reset = &rv515_gpu_reset, |
| .mc_init = &r520_mc_init, |
| .mc_fini = &r520_mc_fini, |
| // .wb_init = &r100_wb_init, |
| // .wb_fini = &r100_wb_fini, |
| .wb_init = &r100_wb_init, |
| .wb_fini = &r100_wb_fini, |
| .gart_enable = &r300_gart_enable, |
| .gart_disable = &rv370_pcie_gart_disable, |
| .gart_tlb_flush = &rv370_pcie_gart_tlb_flush, |
| /drivers/video/drm/radeon/radeon_gart.c |
|---|
| 25,7 → 25,7 |
| * Alex Deucher |
| * Jerome Glisse |
| */ |
| #include "drmP.h" |
| //#include "drmP.h" |
| #include "radeon_drm.h" |
| #include "radeon.h" |
| #include "radeon_reg.h" |
| 80,7 → 80,6 |
| uint32_t gpu_addr; |
| int r; |
| dbgprintf("%s\n",__FUNCTION__); |
| if (rdev->gart.table.vram.robj == NULL) { |
| r = radeon_object_create(rdev, NULL, |
| /drivers/video/drm/radeon/radeon_object.c |
|---|
| 29,8 → 29,8 |
| * Thomas Hellstrom <thomas-at-tungstengraphics-dot-com> |
| * Dave Airlie |
| */ |
| #include <list.h> |
| #include <drmP.h> |
| //#include <linux/list.h> |
| //#include <drm/drmP.h> |
| #include "radeon_drm.h" |
| #include "radeon.h" |
| 359,8 → 359,6 |
| { |
| int r = 0; |
| dbgprintf("%s\n",__FUNCTION__); |
| r = drm_mm_init(&mm_vram, 0x800000 >> PAGE_SHIFT, |
| ((rdev->mc.aper_size - 0x800000) >> PAGE_SHIFT)); |
| if (r) { |
| /drivers/video/drm/radeon/radeon_ring.c |
|---|
| 26,7 → 26,7 |
| * Jerome Glisse |
| */ |
| //#include <linux/seq_file.h> |
| #include "drmP.h" |
| //#include "drmP.h" |
| #include "radeon_drm.h" |
| #include "radeon_reg.h" |
| #include "radeon.h" |
| 99,6 → 99,7 |
| return r; |
| } |
| void radeon_ib_free(struct radeon_device *rdev, struct radeon_ib **ib) |
| { |
| struct radeon_ib *tmp = *ib; |
| /drivers/video/drm/radeon/rv515.c |
|---|
| 26,7 → 26,7 |
| * Jerome Glisse |
| */ |
| //#include <linux/seq_file.h> |
| #include "drmP.h" |
| //#include "drmP.h" |
| #include "radeon_reg.h" |
| #include "radeon.h" |