/* * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved. * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sub license, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ #include "via.h" #include "drmP.h" #include "via_drm.h" #include "via_drv.h" #include "via_ds.h" #include "via_mm.h" #define MAX_CONTEXT 100 unsigned int VIA_DEBUG = 1; typedef struct { int used; int context; set_t *sets[2]; /* 0 for frame buffer, 1 for AGP , 2 for System*/ } via_context_t; static via_context_t global_ppriv[MAX_CONTEXT]; static int add_alloc_set(int context, int type, unsigned int val) { int i, retval = 0; for (i = 0; i < MAX_CONTEXT; i++) { if (global_ppriv[i].used && global_ppriv[i].context == context) { retval = via_setAdd(global_ppriv[i].sets[type], val); break; } } return retval; } static int del_alloc_set(int context, int type, unsigned int val) { int i, retval = 0; for (i = 0; i < MAX_CONTEXT; i++) if (global_ppriv[i].used && global_ppriv[i].context == context) { retval = via_setDel(global_ppriv[i].sets[type], val); break; } return retval; } /* agp memory management */ static memHeap_t *AgpHeap = NULL; int via_agp_init( DRM_IOCTL_ARGS ) { drm_via_agp_t agp; DRM_COPY_FROM_USER_IOCTL(agp, (drm_via_agp_t *)data, sizeof(agp)); AgpHeap = via_mmInit(agp.offset, agp.size); DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size); return 0; } /* fb memory management */ static memHeap_t *FBHeap = NULL; int via_fb_init( DRM_IOCTL_ARGS ) { drm_via_fb_t fb; DRM_COPY_FROM_USER_IOCTL(fb, (drm_via_fb_t *)data, sizeof(fb)); FBHeap = via_mmInit(fb.offset, fb.size); DRM_DEBUG("offset = %u, size = %u", fb.offset, fb.size); return 0; } int via_init_context(struct drm_device *dev, int context) { int i; for (i = 0; i < MAX_CONTEXT ; i++) if (global_ppriv[i].used && (global_ppriv[i].context == context)) break; if (i >= MAX_CONTEXT) { for (i = 0; i < MAX_CONTEXT ; i++) { if (!global_ppriv[i].used) { global_ppriv[i].context = context; global_ppriv[i].used = 1; global_ppriv[i].sets[0] = via_setInit(); global_ppriv[i].sets[1] = via_setInit(); DRM_DEBUG("init allocation set, socket=%d," " context = %d\n", i, context); break; } } if ((i >= MAX_CONTEXT) || (global_ppriv[i].sets[0] == NULL) || (global_ppriv[i].sets[1] == NULL)) { return 0; } } return 1; } int via_final_context(struct drm_device *dev, int context) { int i; for (i=0; ictx_count == 1 && dev->dev_private) { if (dev->irq) DRM(irq_uninstall)(dev); via_do_cleanup_map(dev); } #endif return 1; } int via_mem_alloc( DRM_IOCTL_ARGS) { drm_via_mem_t mem; DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t *)data, sizeof(mem)); switch (mem.type) { case VIDEO : if (via_fb_alloc(&mem) < 0) return -EFAULT; DRM_COPY_TO_USER_IOCTL((drm_via_mem_t *)data, mem, sizeof(mem)); return 0; case AGP : if (via_agp_alloc(&mem) < 0) return -EFAULT; DRM_COPY_TO_USER_IOCTL((drm_via_mem_t *)data, mem, sizeof(mem)); return 0; } return -EFAULT; } int via_fb_alloc(drm_via_mem_t* mem) { drm_via_mm_t fb; PMemBlock block; int retval = 0; if (!FBHeap) return -1; fb.size = mem->size; fb.context = mem->context; block = via_mmAllocMem(FBHeap, fb.size, 5, 0); if (block) { fb.offset = block->ofs; fb.free = (unsigned int)block; if (!add_alloc_set(fb.context, VIDEO, fb.free)) { DRM_DEBUG("adding to allocation set fails\n"); via_mmFreeMem((PMemBlock)fb.free); retval = -1; } } else { fb.offset = 0; fb.size = 0; fb.free = 0; retval = -1; } mem->offset = fb.offset; mem->index = fb.free; DRM_DEBUG("alloc fb, size = %d, offset = %d\n", fb.size, (int)fb.offset); return retval; } int via_agp_alloc(drm_via_mem_t* mem) { drm_via_mm_t agp; PMemBlock block; int retval = 0; if (!AgpHeap) return -1; agp.size = mem->size; agp.context = mem->context; block = via_mmAllocMem(AgpHeap, agp.size, 5, 0); if (block) { agp.offset = block->ofs; agp.free = (unsigned int)block; if (!add_alloc_set(agp.context, AGP, agp.free)) { DRM_DEBUG("adding to allocation set fails\n"); via_mmFreeMem((PMemBlock)agp.free); retval = -1; } } else { agp.offset = 0; agp.size = 0; agp.free = 0; } mem->offset = agp.offset; mem->index = agp.free; DRM_DEBUG("alloc agp, size = %d, offset = %d\n", agp.size, (unsigned int)agp.offset); return retval; } int via_mem_free( DRM_IOCTL_ARGS ) { drm_via_mem_t mem; DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t *)data, sizeof(mem)); switch (mem.type) { case VIDEO : if (via_fb_free(&mem) == 0) return 0; break; case AGP : if (via_agp_free(&mem) == 0) return 0; break; } return -EFAULT; } int via_fb_free(drm_via_mem_t* mem) { drm_via_mm_t fb; int retval = 0; if (!FBHeap) { return -1; } fb.free = mem->index; fb.context = mem->context; if (!fb.free) { return -1; } via_mmFreeMem((PMemBlock)fb.free); if (!del_alloc_set(fb.context, VIDEO, fb.free)) { retval = -1; } DRM_DEBUG("free fb, free = %d\n", fb.free); return retval; } int via_agp_free(drm_via_mem_t* mem) { drm_via_mm_t agp; int retval = 0; agp.free = mem->index; agp.context = mem->context; if (!agp.free) return -1; via_mmFreeMem((PMemBlock)agp.free); if (!del_alloc_set(agp.context, AGP, agp.free)) { retval = -1; } DRM_DEBUG("free agp, free = %d\n", agp.free); return retval; } EXPORT_SYMBOL(via_fb_alloc); EXPORT_SYMBOL(via_fb_free); void DRM(driver_register_fns)(drm_device_t *dev) { dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL; dev->fn_tbl.context_ctor = via_init_context; dev->fn_tbl.context_dtor = via_final_context; dev->fn_tbl.vblank_wait = via_driver_vblank_wait; dev->fn_tbl.irq_preinstall = via_driver_irq_preinstall; dev->fn_tbl.irq_postinstall = via_driver_irq_postinstall; dev->fn_tbl.irq_uninstall = via_driver_irq_uninstall; dev->fn_tbl.irq_handler = via_driver_irq_handler; } mirl@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 "drmP.h" #include "drm_core.h" struct drm_sysfs_class { struct class_device_attribute attr; struct class class; }; #define to_drm_sysfs_class(d) container_of(d, struct drm_sysfs_class, class) struct simple_dev { dev_t dev; struct class_device class_dev; }; #define to_simple_dev(d) container_of(d, struct simple_dev, class_dev) static void release_simple_dev(struct class_device *class_dev) { struct simple_dev *s_dev = to_simple_dev(class_dev); kfree(s_dev); } static ssize_t show_dev(struct class_device *class_dev, char *buf) { struct simple_dev *s_dev = to_simple_dev(class_dev); return print_dev_t(buf, s_dev->dev); } static void drm_sysfs_class_release(struct class *class) { struct drm_sysfs_class *cs = to_drm_sysfs_class(class); kfree(cs); } /* 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 a struct drm_sysfs_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 drm_sysfs_class *drm_sysfs_create(struct module *owner, char *name) { struct drm_sysfs_class *cs; int retval; cs = kmalloc(sizeof(*cs), GFP_KERNEL); if (!cs) { retval = -ENOMEM; goto error; } memset(cs, 0x00, sizeof(*cs)); cs->class.name = name; cs->class.class_release = drm_sysfs_class_release; cs->class.release = release_simple_dev; cs->attr.attr.name = "dev"; cs->attr.attr.mode = S_IRUGO; cs->attr.attr.owner = owner; cs->attr.show = show_dev; cs->attr.store = NULL; retval = class_register(&cs->class); if (retval) goto error; retval = class_create_file(&cs->class, &class_attr_version); if (retval) goto error_with_class; return cs; error_with_class: class_unregister(&cs->class); error: kfree(cs); return ERR_PTR(retval); } /** * drm_sysfs_destroy - destroys a struct drm_sysfs_class structure * @cs: pointer to the struct drm_sysfs_class that is to be destroyed * * Note, the pointer to be destroyed must have been created with a call to * drm_sysfs_create(). */ void drm_sysfs_destroy(struct drm_sysfs_class *cs) { if ((cs == NULL) || (IS_ERR(cs))) return; class_unregister(&cs->class); } static ssize_t show_dri(struct class_device *class_device, char *buf) { struct drm_device * dev = ((struct drm_head *)class_get_devdata(class_device))->dev; if (dev->driver->dri_library_name) return dev->driver->dri_library_name(dev, buf); return snprintf(buf, PAGE_SIZE, "%s\n", dev->driver->pci_driver.name); } static struct class_device_attribute class_device_attrs[] = { __ATTR(dri_library_name, S_IRUGO, show_dri, NULL), }; /** * drm_sysfs_device_add - adds a class device to sysfs for a character driver * @cs: pointer to the struct drm_sysfs_class that this device should be registered to. * @dev: the dev_t for the device to be added. * @device: a pointer to a struct device that is assiociated with this class device. * @fmt: string for the class device's name * * A struct class_device will be created in sysfs, registered to the specified * class. A "dev" file will be created, showing the dev_t for the device. The * pointer to the struct class_device will be returned from the call. Any further * sysfs files that might be required can be created using this pointer. * Note: the struct drm_sysfs_class passed to this function must have previously been * created with a call to drm_sysfs_create(). */ struct class_device *drm_sysfs_device_add(struct drm_sysfs_class *cs, struct drm_head * head) { struct simple_dev *s_dev = NULL; int i, retval; if ((cs == NULL) || (IS_ERR(cs))) { retval = -ENODEV; goto error; } s_dev = kmalloc(sizeof(*s_dev), GFP_KERNEL); if (!s_dev) { retval = -ENOMEM; goto error; } memset(s_dev, 0x00, sizeof(*s_dev)); s_dev->dev = MKDEV(DRM_MAJOR, head->minor); s_dev->class_dev.dev = &head->dev->pdev->dev; s_dev->class_dev.class = &cs->class; snprintf(s_dev->class_dev.class_id, BUS_ID_SIZE, "card%d", head->minor); retval = class_device_register(&s_dev->class_dev); if (retval) goto error; retval = class_device_create_file(&s_dev->class_dev, &cs->attr); if (retval) goto error_with_device; class_set_devdata(&s_dev->class_dev, head); for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++) { retval = class_device_create_file(&s_dev->class_dev, &class_device_attrs[i]); if (retval) goto error_with_files; } return &s_dev->class_dev; error_with_files: while (i > 0) class_device_remove_file(&s_dev->class_dev, &class_device_attrs[--i]); class_device_remove_file(&s_dev->class_dev, &cs->attr); error_with_device: class_device_unregister(&s_dev->class_dev); error: kfree(s_dev); return ERR_PTR(retval); } /** * drm_sysfs_device_remove - removes a class device that was created with drm_sysfs_device_add() * @dev: the dev_t of the device that was previously registered. * * This call unregisters and cleans up a class device that was created with a * call to drm_sysfs_device_add() */ void drm_sysfs_device_remove(struct class_device *class_dev) { struct simple_dev *s_dev = to_simple_dev(class_dev); int i; for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++) class_device_remove_file(&s_dev->class_dev, &class_device_attrs[i]); class_device_unregister(&s_dev->class_dev); }
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-26 17:38:03 +0000