char/agp/alpha-agp.c

0001 #include <linux/module.h>
0002 #include <linux/pci.h>
0003 #include <linux/init.h>
0004 #include <linux/agp_backend.h>
0005 #include <linux/mm.h>
0006 #include <linux/slab.h>
0007
0008 #include <asm/machvec.h>
0009 #include <asm/agp_backend.h>
0010 #include "../../../arch/alpha/kernel/pci_impl.h"
0011
0012 #include "agp.h"
0013
0014 static vm_fault_t alpha_core_agp_vm_fault(struct vm_fault *vmf)
0015 {
0016     alpha_agp_info *agp = agp_bridge->dev_private_data;
0017     dma_addr_t dma_addr;
0018     unsigned long pa;
0019     struct page *page;
0020
0021     dma_addr = vmf->address - vmf->vma->vm_start + agp->aperture.bus_base;
0022     pa = agp->ops->translate(agp, dma_addr);
0023
0024     if (pa == (unsigned long)-EINVAL)
0025         return VM_FAULT_SIGBUS; /* no translation */
0026
0027     /*
0028      * Get the page, inc the use count, and return it
0029      */
0030     page = virt_to_page(__va(pa));
0031     get_page(page);
0032     vmf->page = page;
0033     return 0;
0034 }
0035
0036 static struct aper_size_info_fixed alpha_core_agp_sizes[] =
0037 {
0038     { 0, 0, 0 }, /* filled in by alpha_core_agp_setup */
0039 };
0040
0041 static const struct vm_operations_struct alpha_core_agp_vm_ops = {
0042     .fault = alpha_core_agp_vm_fault,
0043 };
0044
0045
0046 static int alpha_core_agp_fetch_size(void)
0047 {
0048     return alpha_core_agp_sizes[0].size;
0049 }
0050
0051 static int alpha_core_agp_configure(void)
0052 {
0053     alpha_agp_info *agp = agp_bridge->dev_private_data;
0054     agp_bridge->gart_bus_addr = agp->aperture.bus_base;
0055     return 0;
0056 }
0057
0058 static void alpha_core_agp_cleanup(void)
0059 {
0060     alpha_agp_info *agp = agp_bridge->dev_private_data;
0061
0062     agp->ops->cleanup(agp);
0063 }
0064
0065 static void alpha_core_agp_tlbflush(struct agp_memory *mem)
0066 {
0067     alpha_agp_info *agp = agp_bridge->dev_private_data;
0068     alpha_mv.mv_pci_tbi(agp->hose, 0, -1);
0069 }
0070
0071 static void alpha_core_agp_enable(struct agp_bridge_data *bridge, u32 mode)
0072 {
0073     alpha_agp_info *agp = bridge->dev_private_data;
0074
0075     agp->mode.lw = agp_collect_device_status(bridge, mode,
0076                     agp->capability.lw);
0077
0078     agp->mode.bits.enable = 1;
0079     agp->ops->configure(agp);
0080
0081     agp_device_command(agp->mode.lw, false);
0082 }
0083
0084 static int alpha_core_agp_insert_memory(struct agp_memory *mem, off_t pg_start,
0085                     int type)
0086 {
0087     alpha_agp_info *agp = agp_bridge->dev_private_data;
0088     int num_entries, status;
0089     void *temp;
0090
0091     if (type >= AGP_USER_TYPES || mem->type >= AGP_USER_TYPES)
0092         return -EINVAL;
0093
0094     temp = agp_bridge->current_size;
0095     num_entries = A_SIZE_FIX(temp)->num_entries;
0096     if ((pg_start + mem->page_count) > num_entries)
0097         return -EINVAL;
0098
0099     status = agp->ops->bind(agp, pg_start, mem);
0100     mb();
0101     alpha_core_agp_tlbflush(mem);
0102
0103     return status;
0104 }
0105
0106 static int alpha_core_agp_remove_memory(struct agp_memory *mem, off_t pg_start,
0107                     int type)
0108 {
0109     alpha_agp_info *agp = agp_bridge->dev_private_data;
0110     int status;
0111
0112     status = agp->ops->unbind(agp, pg_start, mem);
0113     alpha_core_agp_tlbflush(mem);
0114     return status;
0115 }
0116
0117 static int alpha_core_agp_create_free_gatt_table(struct agp_bridge_data *a)
0118 {
0119     return 0;
0120 }
0121
0122 struct agp_bridge_driver alpha_core_agp_driver = {
0123     .owner          = THIS_MODULE,
0124     .aperture_sizes     = alpha_core_agp_sizes,
0125     .num_aperture_sizes = 1,
0126     .size_type      = FIXED_APER_SIZE,
0127     .cant_use_aperture  = true,
0128     .masks          = NULL,
0129
0130     .fetch_size     = alpha_core_agp_fetch_size,
0131     .configure      = alpha_core_agp_configure,
0132     .agp_enable     = alpha_core_agp_enable,
0133     .cleanup        = alpha_core_agp_cleanup,
0134     .tlb_flush      = alpha_core_agp_tlbflush,
0135     .mask_memory        = agp_generic_mask_memory,
0136     .cache_flush        = global_cache_flush,
0137     .create_gatt_table  = alpha_core_agp_create_free_gatt_table,
0138     .free_gatt_table    = alpha_core_agp_create_free_gatt_table,
0139     .insert_memory      = alpha_core_agp_insert_memory,
0140     .remove_memory      = alpha_core_agp_remove_memory,
0141     .alloc_by_type      = agp_generic_alloc_by_type,
0142     .free_by_type       = agp_generic_free_by_type,
0143     .agp_alloc_page     = agp_generic_alloc_page,
0144     .agp_alloc_pages    = agp_generic_alloc_pages,
0145     .agp_destroy_page   = agp_generic_destroy_page,
0146     .agp_destroy_pages  = agp_generic_destroy_pages,
0147     .agp_type_to_mask_type  = agp_generic_type_to_mask_type,
0148 };
0149
0150 struct agp_bridge_data *alpha_bridge;
0151
0152 int __init
0153 alpha_core_agp_setup(void)
0154 {
0155     alpha_agp_info *agp = alpha_mv.agp_info();
0156     struct pci_dev *pdev;   /* faked */
0157     struct aper_size_info_fixed *aper_size;
0158
0159     if (!agp)
0160         return -ENODEV;
0161     if (agp->ops->setup(agp))
0162         return -ENODEV;
0163
0164     /*
0165      * Build the aperture size descriptor
0166      */
0167     aper_size = alpha_core_agp_sizes;
0168     aper_size->size = agp->aperture.size / (1024 * 1024);
0169     aper_size->num_entries = agp->aperture.size / PAGE_SIZE;
0170     aper_size->page_order = __ffs(aper_size->num_entries / 1024);
0171
0172     /*
0173      * Build a fake pci_dev struct
0174      */
0175     pdev = pci_alloc_dev(NULL);
0176     if (!pdev)
0177         return -ENOMEM;
0178     pdev->vendor = 0xffff;
0179     pdev->device = 0xffff;
0180     pdev->sysdata = agp->hose;
0181
0182     alpha_bridge = agp_alloc_bridge();
0183     if (!alpha_bridge)
0184         goto fail;
0185
0186     alpha_bridge->driver = &alpha_core_agp_driver;
0187     alpha_bridge->vm_ops = &alpha_core_agp_vm_ops;
0188     alpha_bridge->current_size = aper_size; /* only 1 size */
0189     alpha_bridge->dev_private_data = agp;
0190     alpha_bridge->dev = pdev;
0191     alpha_bridge->mode = agp->capability.lw;
0192
0193     printk(KERN_INFO PFX "Detected AGP on hose %d\n", agp->hose->index);
0194     return agp_add_bridge(alpha_bridge);
0195
0196  fail:
0197     kfree(pdev);
0198     return -ENOMEM;
0199 }
0200
0201 static int __init agp_alpha_core_init(void)
0202 {
0203     if (agp_off)
0204         return -EINVAL;
0205     if (alpha_mv.agp_info)
0206         return alpha_core_agp_setup();
0207     return -ENODEV;
0208 }
0209
0210 static void __exit agp_alpha_core_cleanup(void)
0211 {
0212     agp_remove_bridge(alpha_bridge);
0213     agp_put_bridge(alpha_bridge);
0214 }
0215
0216 module_init(agp_alpha_core_init);
0217 module_exit(agp_alpha_core_cleanup);
0218
0219 MODULE_AUTHOR("Jeff Wiedemeier <Jeff.Wiedemeier@hp.com>");
0220 MODULE_LICENSE("GPL and additional rights");