drivers/staging/hv/osd.c

   1 /*
   2  *
   3  * Copyright (c) 2009, Microsoft Corporation.
   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 WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * 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., 59 Temple
  16  * Place - Suite 330, Boston, MA 02111-1307 USA.
  17  *
  18  * Authors:
  19  *   Haiyang Zhang <haiyangz@microsoft.com>
  20  *   Hank Janssen  <hjanssen@microsoft.com>
  21  *
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/init.h>
  26 #include <linux/types.h>
  27 #include <linux/mm.h>
  28 #include <linux/highmem.h>
  29 #include <linux/vmalloc.h>
  30 #include <linux/ioport.h>
  31 #include <linux/irq.h>
  32 #include <linux/interrupt.h>
  33 #include <linux/wait.h>
  34 #include <linux/spinlock.h>
  35 #include <linux/workqueue.h>
  36 #include <linux/kernel.h>
  37 #include <linux/timer.h>
  38 #include <linux/jiffies.h>
  39 #include <linux/delay.h>
  40 #include <linux/time.h>
  41
  42 #include <asm/io.h>
  43 #include <asm/bitops.h>
  44 #include <asm/kmap_types.h>
  45 #include <asm/atomic.h>
  46
  47 #include "include/osd.h"
  48
  49 //
  50 // Data types
  51 //
  52 typedef struct _TIMER {
  53         struct timer_list timer;
  54         PFN_TIMER_CALLBACK callback;
  55         void* context;
  56 }TIMER;
  57
  58
  59 typedef struct _WAITEVENT {
  60         int     condition;
  61         wait_queue_head_t event;
  62 } WAITEVENT;
  63
  64 typedef struct _SPINLOCK {
  65         spinlock_t              lock;
  66         unsigned long   flags;
  67 } SPINLOCK;
  68
  69 typedef struct _WORKQUEUE {
  70         struct workqueue_struct *queue;
  71 } WORKQUEUE;
  72
  73 typedef struct _WORKITEM {
  74         struct work_struct work;
  75         PFN_WORKITEM_CALLBACK callback;
  76         void* context;
  77 } WORKITEM;
  78
  79
  80 //
  81 // Global
  82 //
  83
  84 void LogMsg(const char *fmt, ...)
  85 {
  86         va_list args;
  87
  88         va_start(args, fmt);
  89         vprintk(fmt, args);
  90         va_end(args);
  91 }
  92
  93 void BitSet(unsigned int* addr, int bit)
  94 {
  95         set_bit(bit, (unsigned long*)addr);
  96 }
  97
  98 int BitTest(unsigned int* addr, int bit)
  99 {
 100         return test_bit(bit, (unsigned long*)addr);
 101 }
 102
 103 void BitClear(unsigned int* addr, int bit)
 104 {
 105         clear_bit(bit, (unsigned long*)addr);
 106 }
 107
 108 int BitTestAndClear(unsigned int* addr, int bit)
 109 {
 110         return test_and_clear_bit(bit, (unsigned long*)addr);
 111 }
 112
 113 int BitTestAndSet(unsigned int* addr, int bit)
 114 {
 115         return test_and_set_bit(bit, (unsigned long*)addr);
 116 }
 117
 118
 119 int InterlockedIncrement(int *val)
 120 {
 121         return atomic_inc_return((atomic_t*)val);
 122 }
 123
 124 int InterlockedDecrement(int *val)
 125 {
 126         return atomic_dec_return((atomic_t*)val);
 127 }
 128
 129 #ifndef atomic_cmpxchg
 130 #define atomic_cmpxchg(v, old, new) ((int)cmpxchg(&((v)->counter), old, new))
 131 #endif
 132 int InterlockedCompareExchange(int *val, int new, int curr)
 133 {
 134         //return ((int)cmpxchg(((atomic_t*)val), curr, new));
 135         return atomic_cmpxchg((atomic_t*)val, curr, new);
 136
 137 }
 138
 139 void Sleep(unsigned long usecs)
 140 {
 141         udelay(usecs);
 142 }
 143
 144 void* VirtualAllocExec(unsigned int size)
 145 {
 146 #ifdef __x86_64__
 147         return __vmalloc(size, GFP_KERNEL, PAGE_KERNEL_EXEC);
 148 #else
 149         return __vmalloc(size, GFP_KERNEL, __pgprot(__PAGE_KERNEL & (~_PAGE_NX)));
 150 #endif
 151 }
 152
 153 void VirtualFree(void* VirtAddr)
 154 {
 155         return vfree(VirtAddr);
 156 }
 157
 158 void* PageAlloc(unsigned int count)
 159 {
 160         void *p;
 161         p = (void *)__get_free_pages(GFP_KERNEL, get_order(count * PAGE_SIZE));
 162         if (p) memset(p, 0, count * PAGE_SIZE);
 163         return p;
 164
 165         //struct page* page = alloc_page(GFP_KERNEL|__GFP_ZERO);
 166         //void *p;
 167
 168         ////BUGBUG: We need to use kmap in case we are in HIMEM region
 169         //p = page_address(page);
 170         //if (p) memset(p, 0, PAGE_SIZE);
 171         //return p;
 172 }
 173
 174 void PageFree(void* page, unsigned int count)
 175 {
 176         free_pages((unsigned long)page, get_order(count * PAGE_SIZE));
 177         /*struct page* p = virt_to_page(page);
 178         __free_page(p);*/
 179 }
 180
 181
 182 void* PageMapVirtualAddress(unsigned long Pfn)
 183 {
 184         return kmap_atomic(pfn_to_page(Pfn), KM_IRQ0);
 185 }
 186
 187 void PageUnmapVirtualAddress(void* VirtAddr)
 188 {
 189         kunmap_atomic(VirtAddr, KM_IRQ0);
 190 }
 191
 192 void* MemAllocZeroed(unsigned int size)
 193 {
 194         void *p = kmalloc(size, GFP_KERNEL);
 195         if (p) memset(p, 0, size);
 196         return p;
 197 }
 198
 199 void* MemAllocAtomic(unsigned int size)
 200 {
 201         return kmalloc(size, GFP_ATOMIC);
 202 }
 203
 204 void MemFree(void* buf)
 205 {
 206         kfree(buf);
 207 }
 208
 209 void *MemMapIO(unsigned long phys, unsigned long size)
 210 {
 211 #if X2V_LINUX
 212 #ifdef __x86_64__
 213         return (void*)(phys + 0xFFFF83000C000000);
 214 #else // i386
 215         return (void*)(phys + 0xfb000000);
 216 #endif
 217 #else
 218         return (void*)GetVirtualAddress(phys); //return ioremap_nocache(phys, size);
 219 #endif
 220 }
 221
 222 void MemUnmapIO(void *virt)
 223 {
 224         //iounmap(virt);
 225 }
 226
 227 void MemoryFence()
 228 {
 229         mb();
 230 }
 231
 232 void TimerCallback(unsigned long data)
 233 {
 234         TIMER* t = (TIMER*)data;
 235
 236         t->callback(t->context);
 237 }
 238
 239 HANDLE TimerCreate(PFN_TIMER_CALLBACK pfnTimerCB, void* context)
 240 {
 241         TIMER* t = kmalloc(sizeof(TIMER), GFP_KERNEL);
 242         if (!t)
 243         {
 244                 return NULL;
 245         }
 246
 247         t->callback = pfnTimerCB;
 248         t->context = context;
 249
 250         init_timer(&t->timer);
 251         t->timer.data = (unsigned long)t;
 252         t->timer.function = TimerCallback;
 253
 254         return t;
 255 }
 256
 257 void TimerStart(HANDLE hTimer, u32 expirationInUs)
 258 {
 259         TIMER* t  = (TIMER* )hTimer;
 260
 261         t->timer.expires = jiffies + usecs_to_jiffies(expirationInUs);
 262         add_timer(&t->timer);
 263 }
 264
 265 int TimerStop(HANDLE hTimer)
 266 {
 267         TIMER* t  = (TIMER* )hTimer;
 268
 269         return del_timer(&t->timer);
 270 }
 271
 272 void TimerClose(HANDLE hTimer)
 273 {
 274         TIMER* t  = (TIMER* )hTimer;
 275
 276         del_timer(&t->timer);
 277         kfree(t);
 278 }
 279
 280 size_t GetTickCount(void)
 281 {
 282         return jiffies;
 283 }
 284
 285 signed long long GetTimestamp(void)
 286 {
 287         struct timeval t;
 288
 289         do_gettimeofday(&t);
 290
 291         return  timeval_to_ns(&t);
 292 }
 293
 294 HANDLE WaitEventCreate(void)
 295 {
 296         WAITEVENT* wait = kmalloc(sizeof(WAITEVENT), GFP_KERNEL);
 297         if (!wait)
 298         {
 299                 return NULL;
 300         }
 301
 302         wait->condition = 0;
 303         init_waitqueue_head(&wait->event);
 304         return wait;
 305 }
 306
 307 void WaitEventClose(HANDLE hWait)
 308 {
 309         WAITEVENT* waitEvent = (WAITEVENT* )hWait;
 310         kfree(waitEvent);
 311 }
 312
 313 void WaitEventSet(HANDLE hWait)
 314 {
 315         WAITEVENT* waitEvent = (WAITEVENT* )hWait;
 316         waitEvent->condition = 1;
 317         wake_up_interruptible(&waitEvent->event);
 318 }
 319
 320 int WaitEventWait(HANDLE hWait)
 321 {
 322         int ret=0;
 323         WAITEVENT* waitEvent = (WAITEVENT* )hWait;
 324
 325         ret= wait_event_interruptible(waitEvent->event,
 326                 waitEvent->condition);
 327         waitEvent->condition = 0;
 328         return ret;
 329 }
 330
 331 int WaitEventWaitEx(HANDLE hWait, u32 TimeoutInMs)
 332 {
 333         int ret=0;
 334         WAITEVENT* waitEvent = (WAITEVENT* )hWait;
 335
 336         ret= wait_event_interruptible_timeout(waitEvent->event,
 337                                                                                         waitEvent->condition,
 338                                                                                         msecs_to_jiffies(TimeoutInMs));
 339         waitEvent->condition = 0;
 340         return ret;
 341 }
 342
 343 HANDLE SpinlockCreate(void)
 344 {
 345         SPINLOCK* spin = kmalloc(sizeof(SPINLOCK), GFP_KERNEL);
 346         if (!spin)
 347         {
 348                 return NULL;
 349         }
 350         spin_lock_init(&spin->lock);
 351
 352         return spin;
 353 }
 354
 355 void SpinlockAcquire(HANDLE hSpin)
 356 {
 357         SPINLOCK* spin = (SPINLOCK* )hSpin;
 358
 359         spin_lock_irqsave(&spin->lock, spin->flags);
 360 }
 361
 362 void SpinlockRelease(HANDLE hSpin)
 363 {
 364         SPINLOCK* spin = (SPINLOCK* )hSpin;
 365
 366         spin_unlock_irqrestore(&spin->lock, spin->flags);
 367 }
 368
 369 void SpinlockClose(HANDLE hSpin)
 370 {
 371         SPINLOCK* spin = (SPINLOCK* )hSpin;
 372         kfree(spin);
 373 }
 374
 375 void* Physical2LogicalAddr(unsigned long PhysAddr)
 376 {
 377         void* logicalAddr = phys_to_virt(PhysAddr);
 378         BUG_ON(!virt_addr_valid(logicalAddr));
 379         return logicalAddr;
 380 }
 381
 382 unsigned long Logical2PhysicalAddr(void * LogicalAddr)
 383 {
 384         BUG_ON(!virt_addr_valid(LogicalAddr));
 385         return virt_to_phys(LogicalAddr);
 386 }
 387
 388
 389 unsigned long Virtual2Physical(void * VirtAddr)
 390 {
 391         unsigned long pfn = vmalloc_to_pfn(VirtAddr);
 392
 393         return pfn << PAGE_SHIFT;
 394 }
 395
 396 void WorkItemCallback(struct work_struct *work)
 397 {
 398         WORKITEM* w = (WORKITEM*)work;
 399
 400         w->callback(w->context);
 401
 402         kfree(w);
 403 }
 404
 405 HANDLE WorkQueueCreate(char* name)
 406 {
 407         WORKQUEUE *wq = kmalloc(sizeof(WORKQUEUE), GFP_KERNEL);
 408         if (!wq)
 409         {
 410                 return NULL;
 411         }
 412         wq->queue = create_workqueue(name);
 413
 414         return wq;
 415 }
 416
 417 void WorkQueueClose(HANDLE hWorkQueue)
 418 {
 419         WORKQUEUE *wq = (WORKQUEUE *)hWorkQueue;
 420
 421         destroy_workqueue(wq->queue);
 422
 423         return;
 424 }
 425
 426 int WorkQueueQueueWorkItem(HANDLE hWorkQueue, PFN_WORKITEM_CALLBACK workItem, void* context)
 427 {
 428         WORKQUEUE *wq = (WORKQUEUE *)hWorkQueue;
 429
 430         WORKITEM* w = kmalloc(sizeof(WORKITEM), GFP_ATOMIC);
 431         if (!w)
 432         {
 433                 return -1;
 434         }
 435
 436         w->callback = workItem,
 437         w->context = context;
 438         INIT_WORK(&w->work, WorkItemCallback);
 439         return queue_work(wq->queue, &w->work);
 440 }
 441
 442 void QueueWorkItem(PFN_WORKITEM_CALLBACK workItem, void* context)
 443 {
 444         WORKITEM* w = kmalloc(sizeof(WORKITEM), GFP_ATOMIC);
 445         if (!w)
 446         {
 447                 return;
 448         }
 449
 450         w->callback = workItem,
 451         w->context = context;
 452         INIT_WORK(&w->work, WorkItemCallback);
 453         schedule_work(&w->work);
 454 }