gfx_inf.c

IBM source for pallas/vulcan/vesta

            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    case IOC_GFX_REPORT_CURSOR:
        {
            GFX_COORDINATE_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            rtn = gfx_inf_h_report_cursor_position(&parm);
            if(rtn >= 0)
            {
                if(copy_to_user((void *)ioctl_parm, &parm,
                    sizeof(parm)))
                    rtn = -1;
            }
            break;
        }

    case IOC_GFX_GET_SCREEN_INFO:
        {
            GFX_SCREEN_INFO_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            rtn = gfx_inf_h_get_screen_info(&parm);
            if(rtn >= 0)
            {
                if(copy_to_user((void *)ioctl_parm, &parm,
                    sizeof(parm)))
                    rtn = -1;
            }
            break;
        }

    case IOC_GFX_SET_SCREEN_INFO:
        {
            GFX_SCREEN_INFO_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_set_screen_info(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    case IOC_GFX_SET_DISPLAY_CONTROL:
        {
            GFX_DISPLAY_CONTROL_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_set_display_control(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    case IOC_GFX_GET_DISPLAY_CONTROL:
        {
            GFX_DISPLAY_CONTROL_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_get_display_control(&parm);
                if(rtn >= 0)
                {
                    if(copy_to_user((void *)ioctl_parm, &parm,
                        sizeof(parm)))
                        rtn = -1;
                }
            }
            break;
        }

    case IOC_GFX_SET_VISUAL_DEVICE_CONTROL:
        {
            GFX_VISUAL_DEVICE_CONTROL_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_set_visual_device_control(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    case IOC_GFX_GET_VISUAL_DEVICE_CONTROL:
        {
            GFX_VISUAL_DEVICE_CONTROL_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_get_visual_device_control(&parm);
                if(rtn >= 0)
                {
                    if(copy_to_user((void *)ioctl_parm, &parm,
                        sizeof(parm)))
                        rtn = -1;
                }
            }
            break;
        }

    case IOC_GFX_SET_SURFACE_CLIP_RECT:
        {
            GFX_SET_CLIP_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_set_surface_clip_rect(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            if(rtn >= 0)
            {
                if(copy_to_user((void *)ioctl_parm, &parm,
                    sizeof(parm)))
                    rtn = -1;
            }
            break;
        }

    case IOC_GFX_BITBLT:
        {
            GFX_BITBLT_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_bitBLT(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    case IOC_GFX_ADV_BITBLT:
        {
            GFX_ADV_BITBLT_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_advancedBitBLT(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    case IOC_GFX_FILLBLT:
        {
            GFX_FILLBLT_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_fillBLT(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    case IOC_GFX_ADV_FILLBLT:
        {
            GFX_ADV_FILLBLT_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_advancedFillBLT(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    case IOC_GFX_BLEND:
        {
            GFX_BLEND_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_blend(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    case IOC_GFX_ADV_BLEND:
        {
            GFX_ADV_BLEND_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_advancedBlend(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    case IOC_GFX_COLORKEY:
        {
            GFX_COLORKEY_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_colorKey(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    case IOC_GFX_RESIZE:
        {
            GFX_RESIZE_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm, 
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_resize(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    /*
     * Allocate physically contiguous memory suitable for use by graphics hardware or DMA controller.
     * For use with cached mmap() to allow user space application to set up memory prior to the transfer.
     * -- BJC 102102
     */
     case IOC_GFX_PMALLOC:
        {
            GFX_PMALLOC_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm,
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_pmalloc(&parm);
                copy_to_user((void *)ioctl_parm, &parm, sizeof(parm));		
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    /*
     *  Transfer video frame from system memory to frame buffer using a DMA controller.
     *  -- BJC 102102
     */
    case IOC_GFX_DMABLT:
        {
            GFX_DMABLT_PARM_T parm;
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            if(copy_from_user(&parm, (void *)ioctl_parm,
                sizeof(parm)) == 0)
            {
                rtn = gfx_inf_h_dmablt(&parm);
            }
            else
            {
                PDEBUG("copy from user fail!\n");
            }
            break;
        }

    /*
     *  If an asynchronous mode of transfer was used for DMABLT, wait for it
     *  to finish. -- BJC 102102
     */
    case IOC_GFX_DMABLT_WAIT:
        {
            if(!ioctl_parm)
            {
                PDEBUG("Invalid IOCTL parm\n");
                break;
            }
            rtn = gfx_inf_h_dmablt_wait();
            break;
        }

    case IOC_GFX_WAIT_FOR_COMPLETE:
        {
            rtn = gfx_inf_h_wait_for_engine((int)ioctl_parm);
            break;    
        }    
    
    case IOC_GFX_RESET_ENGINE:
        {
            rtn = gfx_inf_h_reset_engine();
            break;
        }

    case IOC_GFX_SET_ENGINE_MODE:
        {
            rtn = gfx_inf_h_set_engine_mode((int)ioctl_parm);
            break;    
        }

    case IOC_GFX_GET_ENGINE_MODE:
        {
            rtn = gfx_inf_h_get_engine_mode();
            break;    
        }

    default:
        PDEBUG("Invalid IOCTL cmd magic=0x%2.2x, id=%d, mode=0x%2.2x\n", _IOC_TYPE(ioctl_cmd), _IOC_NR(ioctl_cmd), _IOC_DIR(ioctl_cmd));
        break;
    }

    if(rtn < 0)
    {
        PDEBUG("call failed\n");
    }

    return rtn;
}



static int gfx_inf_mmap(struct file *file, struct vm_area_struct *vma)
{
    unsigned long size;
    
    if(vma->vm_flags & VM_EXEC)
        return -EPERM;
    
    size = vma->vm_end - vma->vm_start;
    PDEBUG("mmap size = 0x%8.8lx\n", size);
    if(size == 0)
        return EINVAL;

    // To make things safer, I'll check if it is my baby
    // Aliens are simply rejected.  
    // The cost of some slowdown should be acceptable
    if(_gfx_inf_h_validate_surface_address(vma->vm_pgoff << PAGE_SHIFT, size))
    {
// BJC 102102        PDEBUG("Invalid surface address specified\n");
// BJC 102102        return -EPERM;  // don't permit it
        PDEBUG("mmaping alien memory region with caching enabled\n"); // BJC 102102
    } else {
// BJC102102        vma->vm_page_prot.pgprot |= _PAGE_NO_CACHE;	// map without caching
    }

    vma->vm_flags |= VM_SHM | VM_IO ; // | VM_DONTCOPY | VM_DONTEXPAND;        // we are just not in system memory
    
    if(remap_page_range(vma->vm_start, vma->vm_pgoff << PAGE_SHIFT, 
        size, vma->vm_page_prot))
        return -EAGAIN;
    return 0;
}

static devfs_handle_t devfs_handle;

static int __init gfx_inf_init(void)
{
    int rtn = gfx_inf_h_init(GFX_MAX_ALLOWED_SURFACES);

    // print the driver verision info for futher reference
    PVERSION(GFX_DRIVER_NAME);

    if(rtn < 0) 
    {
        PFATALE("GFX: Failed to initialize device!\n"); 
        return -1;
    }

    if (devfs_register_chrdev(GFX_DEV_MAJOR, GFX_DRIVER_NAME, &GfxFops) < 0)
    {
        gfx_inf_h_deinit(2);
        PFATALE("GFX: Failed to register device!\n"); 
        return -1;
    }

    devfs_handle = devfs_find_handle(NULL, "stbgfx",
                                0, 0, DEVFS_SPECIAL_CHR,0);
    
    if(devfs_handle == NULL)
    {
      
      devfs_handle = devfs_register(NULL, "stbgfx", DEVFS_FL_DEFAULT,
                                GFX_DEV_MAJOR, 0,
                                S_IFCHR | S_IRUSR | S_IWUSR,
                                &GfxFops, NULL);
    }
    else
      devfs_handle = NULL;
      
    /*
     *  Initialize the dma module -- BJC 102102
     */    
    if(gfx_atom_init() != 0) {
        PFATALE("GFX: Failed to initialize graphics atom!\n");
    }
    return 0;
}

static void __exit gfx_inf_deinit(void)
{
    devfs_unregister_chrdev(GFX_DEV_MAJOR, GFX_DRIVER_NAME);
    if(devfs_handle != NULL)
      devfs_unregister(devfs_handle);
    gfx_inf_h_deinit(2);
    gfx_atom_deinit();  // BJC 102102
}

module_init(gfx_inf_init);
module_exit(gfx_inf_deinit);