pvr/module.c

   1 /**********************************************************************
   2  *
   3  * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful but, except
  10  * as otherwise stated in writing, without any warranty; without even the
  11  * implied warranty of merchantability or fitness for a particular purpose.
  12  * See the GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  17  *
  18  * The full GNU General Public License is included in this distribution in
  19  * the file called "COPYING".
  20  *
  21  * Contact Information:
  22  * Imagination Technologies Ltd. <gpl-support@imgtec.com>
  23  * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
  24  *
  25  ******************************************************************************/
  26
  27 #include <linux/init.h>
  28 #include <linux/kernel.h>
  29 #include <linux/module.h>
  30 #include <linux/version.h>
  31 #include <linux/fs.h>
  32 #include <linux/proc_fs.h>
  33 #include <linux/miscdevice.h>
  34
  35 #include <linux/platform_device.h>
  36
  37 #include "img_defs.h"
  38 #include "services.h"
  39 #include "kerneldisplay.h"
  40 #include "kernelbuffer.h"
  41 #include "syscommon.h"
  42 #include "pvrmmap.h"
  43 #include "mutils.h"
  44 #include "mm.h"
  45 #include "mmap.h"
  46 #include "pvr_debug.h"
  47 #include "srvkm.h"
  48 #include "perproc.h"
  49 #include "handle.h"
  50 #include "pvr_bridge_km.h"
  51 #include "sgx_bridge_km.h"
  52 #include "proc.h"
  53 #include "pvrmodule.h"
  54 #include "private_data.h"
  55
  56 #define DRVNAME         "pvrsrvkm"
  57
  58 #ifdef DEBUG
  59 static int debug = DBGPRIV_WARNING;
  60 #include <linux/moduleparam.h>
  61 module_param(debug, int, 0);
  62 #endif
  63
  64 static int pvr_open(struct inode unref__ * inode, struct file *filp)
  65 {
  66         struct PVRSRV_FILE_PRIVATE_DATA *priv;
  67         void *block_alloc;
  68         int ret = -ENOMEM;
  69         enum PVRSRV_ERROR err;
  70         u32 pid;
  71
  72         pvr_lock();
  73
  74         pid = OSGetCurrentProcessIDKM();
  75
  76         if (PVRSRVProcessConnect(pid) != PVRSRV_OK)
  77                 goto err_unlock;
  78
  79         err = OSAllocMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
  80                             sizeof(*priv),
  81                             (void **)&priv, &block_alloc);
  82
  83         if (err != PVRSRV_OK)
  84                 goto err_unlock;
  85
  86         priv->ui32OpenPID = pid;
  87         priv->hBlockAlloc = block_alloc;
  88         filp->private_data = priv;
  89
  90         ret = 0;
  91 err_unlock:
  92         pvr_unlock();
  93
  94         return ret;
  95 }
  96
  97 static int pvr_release(struct inode unref__ * inode, struct file *filp)
  98 {
  99         struct PVRSRV_FILE_PRIVATE_DATA *priv;
 100
 101         pvr_lock();
 102
 103         priv = filp->private_data;
 104
 105         PVRSRVProcessDisconnect(priv->ui32OpenPID);
 106
 107         OSFreeMem(PVRSRV_OS_NON_PAGEABLE_HEAP,
 108                   sizeof(*priv),
 109                   priv, priv->hBlockAlloc);
 110
 111         pvr_unlock();
 112
 113         return 0;
 114 }
 115
 116 static const struct file_operations pvr_fops = {
 117         .owner          = THIS_MODULE,
 118         .unlocked_ioctl = PVRSRV_BridgeDispatchKM,
 119         .open           = pvr_open,
 120         .release        = pvr_release,
 121         .mmap           = PVRMMap,
 122 };
 123
 124 static void pvr_shutdown(struct platform_device *pdev)
 125 {
 126         PVR_TRACE("pvr_shutdown(pdev=%p)", pdev);
 127
 128         (void)PVRSRVSetPowerStateKM(PVRSRV_POWER_STATE_D3);
 129 }
 130
 131 static int pvr_suspend(struct platform_device *pdev, pm_message_t state)
 132 {
 133         PVR_TRACE("pvr_suspend(pdev=%p)", pdev);
 134
 135         if (PVRSRVSetPowerStateKM(PVRSRV_POWER_STATE_D3) != PVRSRV_OK)
 136                 return -EINVAL;
 137         return 0;
 138 }
 139
 140 static int pvr_resume(struct platform_device *pdev)
 141 {
 142         PVR_TRACE("pvr_resume(pdev=%p)", pdev);
 143
 144         if (PVRSRVSetPowerStateKM(PVRSRV_POWER_STATE_D0) != PVRSRV_OK)
 145                 return -EINVAL;
 146         return 0;
 147 }
 148
 149 static struct miscdevice pvr_miscdevice = {
 150         .minor = MISC_DYNAMIC_MINOR,
 151         .name = DRVNAME,
 152         .fops = &pvr_fops,
 153 };
 154
 155 static int __devinit pvr_probe(struct platform_device *pdev)
 156 {
 157         struct SYS_DATA *sysdata;
 158         int ret;
 159
 160         PVR_TRACE("pvr_probe(pdev=%p)", pdev);
 161
 162         if (SysAcquireData(&sysdata) != PVRSRV_OK &&
 163             SysInitialise(pdev) != PVRSRV_OK) {
 164                 ret = -ENODEV;
 165                 goto err_exit;
 166         }
 167
 168         ret = misc_register(&pvr_miscdevice);
 169         if (ret < 0)
 170                 goto err_exit;
 171
 172         return 0;
 173
 174 err_exit:
 175         dev_err(&pdev->dev, "probe failed (%d)\n", ret);
 176
 177         return ret;
 178 }
 179
 180 static int __devexit pvr_remove(struct platform_device *pdev)
 181 {
 182         struct SYS_DATA *sysdata;
 183         int ret;
 184
 185         PVR_TRACE("pvr_remove(pdev=%p)", pdev);
 186
 187         ret = misc_deregister(&pvr_miscdevice);
 188         if (ret < 0) {
 189                 dev_err(&pdev->dev, "remove failed (%d)\n", ret);
 190                 return ret;
 191         }
 192
 193         if (SysAcquireData(&sysdata) == PVRSRV_OK)
 194                 SysDeinitialise(sysdata);
 195
 196         return 0;
 197 }
 198
 199
 200 static struct platform_driver pvr_driver = {
 201         .driver = {
 202                    .name = DRVNAME,
 203         },
 204         .probe          = pvr_probe,
 205         .remove         = __devexit_p(pvr_remove),
 206         .suspend        = pvr_suspend,
 207         .resume         = pvr_resume,
 208         .shutdown       = pvr_shutdown,
 209 };
 210
 211 static int __init pvr_init(void)
 212 {
 213         int error;
 214
 215         pvr_dbg_init();
 216
 217         PVR_TRACE("pvr_init");
 218
 219         pvr_init_lock();
 220
 221 #ifdef DEBUG
 222         PVRDebugSetLevel(debug);
 223 #endif
 224
 225         error = CreateProcEntries();
 226         if (error < 0)
 227                 goto err1;
 228
 229         error = -ENOMEM;
 230         if (LinuxMMInit() != PVRSRV_OK)
 231                 goto err2;
 232
 233         if (LinuxBridgeInit() != PVRSRV_OK)
 234                 goto err3;
 235
 236         PVRMMapInit();
 237
 238         error = platform_driver_register(&pvr_driver);
 239         if (error < 0)
 240                 goto err4;
 241
 242         return 0;
 243
 244 err4:
 245         PVRMMapCleanup();
 246         LinuxBridgeDeInit();
 247 err3:
 248         LinuxMMCleanup();
 249 err2:
 250         RemoveProcEntries();
 251 err1:
 252         pr_err("%s: failed (%d)\n", __func__, error);
 253
 254         return error;
 255 }
 256
 257 static void __exit pvr_cleanup(void)
 258 {
 259         struct SYS_DATA *sysdata;
 260
 261         PVR_TRACE("pvr_cleanup");
 262
 263         SysAcquireData(&sysdata);
 264
 265         platform_driver_unregister(&pvr_driver);
 266
 267         PVRMMapCleanup();
 268         LinuxMMCleanup();
 269         LinuxBridgeDeInit();
 270         RemoveProcEntries();
 271
 272         PVR_TRACE("pvr_cleanup: unloading");
 273
 274         pvr_dbg_cleanup();
 275 }
 276
 277 module_init(pvr_init);
 278 module_exit(pvr_cleanup);
 279
 280 MODULE_SUPPORTED_DEVICE(DRVNAME);
 281 MODULE_ALIAS("platform:" DRVNAME);
 282