workbench/hidds/nouveau/drm/drm-aros/drm_compat_funcs.c

   1 /*
   2     Copyright 2009, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include "drm_compat_funcs.h"
   7 #include "drm_aros_config.h"
   8
   9 #define PIO_RESERVED                (IPTR)0x40000UL
  10
  11 void iowrite32(u32 val, void * addr)
  12 {
  13     if ((IPTR)addr >= PIO_RESERVED)
  14         writel(val, addr);
  15     else
  16         IMPLEMENT("PIO\n");
  17 }
  18
  19 unsigned int ioread32(void * addr)
  20 {
  21     if ((IPTR)addr >= PIO_RESERVED)
  22         return readl(addr);
  23     else
  24         IMPLEMENT("PIO\n");
  25
  26     return 0xffffffff;
  27 }
  28
  29 void iowrite16(u16 val, void * addr)
  30 {
  31     if ((IPTR)addr >= PIO_RESERVED)
  32         writew(val, addr);
  33     else
  34         IMPLEMENT("PIO\n");
  35 }
  36
  37 unsigned int ioread16(void * addr)
  38 {
  39     if ((IPTR)addr >= PIO_RESERVED)
  40         return readw(addr);
  41     else
  42         IMPLEMENT("PIO\n");
  43
  44     return 0xffff;
  45 }
  46
  47 void iowrite8(u8 val, void * addr)
  48 {
  49     if ((IPTR)addr >= PIO_RESERVED)
  50         writeb(val, addr);
  51     else
  52         IMPLEMENT("PIO\n");
  53 }
  54
  55 unsigned int ioread8(void * addr)
  56 {
  57     if ((IPTR)addr >= PIO_RESERVED)
  58         return readb(addr);
  59     else
  60         IMPLEMENT("PIO\n");
  61
  62     return 0xff;
  63 }
  64
  65 /* Bit operations */
  66 void clear_bit(int nr, volatile void * addr)
  67 {
  68     unsigned long mask = 1 << nr;
  69
  70     *(unsigned long*)addr &= ~mask;
  71 }
  72
  73 void set_bit(int nr, volatile void *addr)
  74 {
  75     unsigned long mask = 1 << nr;
  76
  77     *(unsigned long*)addr |= mask;
  78 }
  79
  80 int test_bit(int nr, volatile void *addr)
  81 {
  82     unsigned long mask = 1 << nr;
  83
  84     return (*(unsigned long*)addr) & mask;
  85 }
  86
  87 /* Delay handling */
  88 #include <aros/symbolsets.h>
  89 #include <devices/timer.h>
  90 struct MsgPort *p = NULL;
  91 struct timerequest *io = NULL;
  92
  93 void udelay(unsigned long usecs)
  94 {
  95     /* Create local clone so that the function is task safe */
  96     struct timerequest  timerio;
  97     struct MsgPort      timermp;
  98
  99     memset(&timermp, 0, sizeof(timermp));
 100
 101     timermp.mp_Node.ln_Type = NT_MSGPORT;
 102     timermp.mp_Flags        = PA_SIGNAL;
 103     timermp.mp_SigBit       = SIGB_SINGLE;
 104     timermp.mp_SigTask      = FindTask(NULL);
 105     NEWLIST(&timermp.mp_MsgList);
 106
 107     timerio = *io;
 108
 109     timerio.tr_node.io_Message.mn_Node.ln_Type  = NT_REPLYMSG;
 110     timerio.tr_node.io_Message.mn_ReplyPort     = &timermp;
 111     timerio.tr_node.io_Command                  = TR_ADDREQUEST;
 112     timerio.tr_time.tv_secs                     = usecs / 1000000;
 113     timerio.tr_time.tv_micro                    = usecs - (timerio.tr_time.tv_secs * 1000000);
 114
 115     SetSignal(0, SIGF_SINGLE);
 116
 117     DoIO((struct IORequest*)&timerio);
 118 }
 119
 120 static BOOL init_timer()
 121 {
 122     p = CreateMsgPort();
 123
 124     if (!p)
 125         return FALSE;
 126
 127     io = CreateIORequest(p, sizeof(struct timerequest));
 128
 129     if(!io)
 130     {
 131         DeleteMsgPort(p);
 132         return FALSE;
 133     }
 134
 135     if (OpenDevice("timer.device", UNIT_MICROHZ, (struct IORequest *)io, 0) != 0)
 136     {
 137         DeleteIORequest(io);
 138         DeleteMsgPort(p);
 139     }
 140
 141     return TRUE;
 142 }
 143
 144 static BOOL deinit_timer()
 145 {
 146     if (io)
 147     {
 148         CloseDevice((struct IORequest *)io);
 149         DeleteIORequest((struct IORequest *)io);
 150         io = NULL;
 151     }
 152
 153     if (p)
 154     {
 155         DeleteMsgPort(p);
 156         p = NULL;
 157     }
 158
 159     return TRUE;
 160 }
 161
 162 ADD2INIT(init_timer, 5);
 163 ADD2EXIT(deinit_timer, 5);
 164
 165 /* Page handling */
 166 void __free_page(struct page * p)
 167 {
 168     if (p->allocated_buffer)
 169         HIDDNouveauFree(p->allocated_buffer);
 170     p->allocated_buffer = NULL;
 171     p->address = NULL;
 172     HIDDNouveauFree(p);
 173 }
 174
 175 struct page * create_page_helper()
 176 {
 177     struct page * p;
 178     p = HIDDNouveauAlloc(sizeof(*p));
 179     p->allocated_buffer = HIDDNouveauAlloc(PAGE_SIZE + PAGE_SIZE - 1);
 180     p->address = PAGE_ALIGN(p->allocated_buffer);
 181     return p;
 182 }
 183
 184 /* IDR handling */
 185 int idr_pre_get_internal(struct idr *idp)
 186 {
 187     if (idp->size <= idp->occupied + idp->last_starting_id)
 188     {
 189         /* Create new table */
 190         ULONG newsize = idp->size ? idp->size * 2 : 128;
 191         IPTR * newtab = HIDDNouveauAlloc(newsize * sizeof(IPTR));
 192
 193         if (newtab == NULL)
 194             return 0;
 195
 196
 197         if (idp->pointers)
 198         {
 199             /* Copy old table into new */
 200             CopyMem(idp->pointers, newtab, idp->size * sizeof(IPTR));
 201
 202             /* Release old table */
 203             HIDDNouveauFree(idp->pointers);
 204         }
 205
 206         idp->pointers = newtab;
 207         idp->size = newsize;
 208     }
 209
 210     return 1;
 211 }
 212
 213 int idr_get_new_above(struct idr *idp, void *ptr, int starting_id, int *id)
 214 {
 215     int i = starting_id;
 216     idp->last_starting_id = starting_id;
 217
 218     for(;i < idp->size;i++)
 219     {
 220         if (idp->pointers[i] == (IPTR)NULL)
 221         {
 222             *id = i;
 223             idp->pointers[i] = (IPTR)ptr;
 224             idp->occupied++;
 225             return 0;
 226         }
 227     }
 228
 229     return -EAGAIN;
 230 }
 231
 232 void *idr_find(struct idr *idp, int id)
 233 {
 234     if ((id < idp->size) && (id >= 0))
 235         return (APTR)idp->pointers[id];
 236     else
 237         return NULL;
 238 }
 239
 240 void idr_remove(struct idr *idp, int id)
 241 {
 242     if ((id < idp->size) && (id >= 0))
 243     {
 244         idp->pointers[id] = (IPTR)NULL;
 245         idp->occupied--;
 246     }
 247 }
 248
 249 void idr_init(struct idr *idp)
 250 {
 251     idp->size = 0;
 252     idp->pointers = NULL;
 253     idp->occupied = 0;
 254     idp->last_starting_id = 0;
 255 }
 256
 257 /* PCI handling */
 258 #include "drm_aros.h"
 259 #include <aros/libcall.h>
 260 #include <proto/oop.h>
 261 #include <hidd/pci.h>
 262 #include <hidd/hidd.h>
 263
 264 void *ioremap(resource_size_t offset, unsigned long size)
 265 {
 266     if (pciDriver)
 267     {
 268         struct pHidd_PCIDriver_MapPCI mappci,*msg = &mappci;
 269         mappci.mID = OOP_GetMethodID(IID_Hidd_PCIDriver, moHidd_PCIDriver_MapPCI);
 270         mappci.PCIAddress = (APTR)offset;
 271         mappci.Length = size;
 272         return (APTR)OOP_DoMethod(pciDriver, (OOP_Msg)msg);
 273     }
 274     else
 275     {
 276         bug("BUG: ioremap used without acquiring pciDriver\n");
 277         return NULL;
 278     }
 279 }
 280
 281 void iounmap(void * addr)
 282 {
 283     if (pciDriver)
 284     {
 285         struct pHidd_PCIDriver_UnmapPCI unmappci,*msg=&unmappci;
 286
 287         unmappci.mID = OOP_GetMethodID(IID_Hidd_PCIDriver, moHidd_PCIDriver_UnmapPCI);
 288         unmappci.CPUAddress = addr;
 289         unmappci.Length = 0; /* This works on i386 but may create problems on other archs */
 290
 291         OOP_DoMethod(pciDriver, (OOP_Msg)msg);
 292     }
 293 }
 294
 295 resource_size_t pci_resource_start(struct pci_dev * pdev, unsigned int resource)
 296 {
 297     APTR start = (APTR)NULL;
 298     switch(resource)
 299     {
 300         case(0): OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_Base0, (APTR)&start); break;
 301         case(1): OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_Base1, (APTR)&start); break;
 302         case(2): OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_Base2, (APTR)&start); break;
 303         case(3): OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_Base3, (APTR)&start); break;
 304         case(4): OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_Base4, (APTR)&start); break;
 305         case(5): OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_Base5, (APTR)&start); break;
 306         default: bug("ResourceID %d not supported\n", resource);
 307     }
 308
 309     return (resource_size_t)start;
 310 }
 311
 312 unsigned long pci_resource_len(struct pci_dev * pdev, unsigned int resource)
 313 {
 314     IPTR len = (IPTR)0;
 315
 316     if (pci_resource_start(pdev, resource) != 0)
 317     {
 318         /*
 319          * FIXME:
 320          * The length reading is only correct when the resource actually exists.
 321          * pci.hidd can however return a non 0 lenght for a resource that does
 322          * not exsist. Possible fix in pci.hidd needed
 323          */
 324
 325         switch(resource)
 326         {
 327             case(0): OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_Size0, (APTR)&len); break;
 328             case(1): OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_Size1, (APTR)&len); break;
 329             case(2): OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_Size2, (APTR)&len); break;
 330             case(3): OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_Size3, (APTR)&len); break;
 331             case(4): OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_Size4, (APTR)&len); break;
 332             case(5): OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_Size5, (APTR)&len); break;
 333             default: bug("ResourceID %d not supported\n", resource);
 334         }
 335     }
 336
 337     return len;
 338 }
 339
 340 struct GetBusSlotEnumeratorData
 341 {
 342     IPTR Bus;
 343     IPTR Dev;
 344     IPTR Sub;
 345     OOP_Object ** pciDevice;
 346 };
 347
 348 AROS_UFH3(void, GetBusSlotEnumerator,
 349     AROS_UFHA(struct Hook *, hook, A0),
 350     AROS_UFHA(OOP_Object *, pciDevice, A2),
 351     AROS_UFHA(APTR, message, A1))
 352 {
 353     AROS_USERFUNC_INIT
 354
 355     struct GetBusSlotEnumeratorData * data = hook->h_Data;
 356
 357     IPTR Bus;
 358     IPTR Dev;
 359     IPTR Sub;
 360
 361     if (*data->pciDevice)
 362         return; /* Already found, should not happen */
 363
 364     /* Get the Device's properties */
 365     OOP_GetAttr(pciDevice, aHidd_PCIDevice_Bus, &Bus);
 366     OOP_GetAttr(pciDevice, aHidd_PCIDevice_Dev, &Dev);
 367     OOP_GetAttr(pciDevice, aHidd_PCIDevice_Sub, &Sub);
 368
 369     if (data->Bus == Bus &&
 370         data->Dev == Dev &&
 371         data->Sub == Sub)
 372     {
 373         (*data->pciDevice) = pciDevice;
 374     }
 375
 376     AROS_USERFUNC_EXIT
 377 }
 378 void * pci_get_bus_and_slot(unsigned int bus, unsigned int dev, unsigned int fun)
 379 {
 380     OOP_Object * pciDevice = NULL;
 381
 382     if (pciBus)
 383     {
 384         struct GetBusSlotEnumeratorData data = {
 385         Bus: bus,
 386         Dev: dev,
 387         Sub: fun,
 388         pciDevice: &pciDevice,
 389         };
 390
 391         struct Hook FindHook = {
 392         h_Entry:    (IPTR (*)())GetBusSlotEnumerator,
 393         h_Data:     &data,
 394         };
 395
 396         struct TagItem Requirements[] = {
 397         { TAG_DONE,             0UL }
 398         };
 399
 400         struct pHidd_PCI_EnumDevices enummsg = {
 401         mID:        OOP_GetMethodID(IID_Hidd_PCI, moHidd_PCI_EnumDevices),
 402         callback:   &FindHook,
 403         requirements:   (struct TagItem*)&Requirements,
 404         }, *msg = &enummsg;
 405
 406         OOP_DoMethod(pciBus, (OOP_Msg)msg);
 407     }
 408
 409     return pciDevice;
 410 }
 411
 412 int pci_read_config_word(struct pci_dev * pdev, int where, u16 *val)
 413 {
 414     struct pHidd_PCIDevice_ReadConfigWord rcwmsg = {
 415     mID: OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigWord),
 416     reg: (UBYTE)where,
 417     }, *msg = &rcwmsg;
 418
 419     *val = (UWORD)OOP_DoMethod((OOP_Object*)pdev->oopdev, (OOP_Msg)msg);
 420     D(bug("pci_read_config_word: %d -> %d\n", where, *val));
 421
 422     return 0;
 423 }
 424
 425 int pci_read_config_dword(struct pci_dev * pdev, int where, u32 *val)
 426 {
 427     struct pHidd_PCIDevice_ReadConfigLong rclmsg = {
 428     mID: OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigLong),
 429     reg: (UBYTE)where,
 430     }, *msg = &rclmsg;
 431
 432     *val = (ULONG)OOP_DoMethod((OOP_Object*)pdev->oopdev, (OOP_Msg)msg);
 433     D(bug("pci_read_config_dword: %d -> %d\n", where, *val));
 434
 435     return 0;
 436 }
 437
 438 int pci_write_config_dword(struct pci_dev * pdev, int where, u32 val)
 439 {
 440     struct pHidd_PCIDevice_WriteConfigLong wclmsg = {
 441     mID: OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigLong),
 442     reg: (UBYTE)where,
 443     val: val,
 444     }, *msg = &wclmsg;
 445
 446     OOP_DoMethod((OOP_Object*)pdev->oopdev, (OOP_Msg)msg);
 447     D(bug("pci_write_config_dword: %d -> %d\n", where, val));
 448
 449     return 0;
 450 }
 451
 452 int pci_is_pcie(struct pci_dev * pdev)
 453 {
 454     IPTR PCIECap;
 455     OOP_GetAttr((OOP_Object *)pdev->oopdev, aHidd_PCIDevice_CapabilityPCIE, (APTR)&PCIECap);
 456     return PCIECap;
 457 }
 458
 459 #include <hidd/agp.h>
 460
 461 /* AGP handling */
 462 struct agp_bridge_data * global_agp_bridge = NULL; /* TODO: implement freeing */
 463 struct Library * HiddAgpBase = NULL; /* TODO: Implement  freeing */
 464 OOP_AttrBase HiddAGPBridgeDeviceAttrBase = 0; /* TODO: Implement  freeing */
 465
 466 struct agp_bridge_data *agp_backend_acquire(void * dev)
 467 {
 468     /* TODO:
 469        if no bridge return NULL
 470        if already acquired return NULL, else acquire
 471      */
 472     return agp_find_bridge(dev);
 473 }
 474
 475 void agp_backend_release(struct agp_bridge_data * bridge)
 476 {
 477     /* TODO: release acquired lock */
 478 }
 479
 480 void agp_free_memory(struct agp_memory * mem)
 481 {
 482     HIDDNouveauFree(mem->pages);
 483     HIDDNouveauFree(mem);
 484 }
 485
 486 struct agp_memory *agp_allocate_memory(struct agp_bridge_data * bridge,
 487     size_t num_pages , u32 type)
 488 {
 489     if ((type != AGP_USER_MEMORY) && (type != AGP_USER_CACHED_MEMORY))
 490     {
 491         IMPLEMENT("Unsupported memory type: %d\n", type);
 492         return NULL;
 493     }
 494
 495     struct agp_memory * mem = HIDDNouveauAlloc(sizeof(struct agp_memory));
 496     mem->pages = HIDDNouveauAlloc(sizeof(struct page *) * num_pages);
 497     mem->page_count = 0; /* Not a typo, will be filled later */
 498     mem->type = type;
 499     mem->is_flushed = FALSE;
 500     mem->is_bound = FALSE;
 501     mem->pg_start = 0;
 502     return mem;
 503 }
 504
 505 int agp_copy_info(struct agp_bridge_data * bridge, struct agp_kern_info * info)
 506 {
 507     info->chipset = SUPPORTED;
 508     info->cant_use_aperture = 0;
 509     info->page_mask = ~0UL;
 510     if (bridge->mode & (1<<3) /* AGPSTAT_MODE_3_0 */)
 511         info->mode = bridge->mode & ~(0x00ff00c4); /* AGP3_RESERVED_MASK */
 512     else
 513         info->mode = bridge->mode & ~(0x00fffcc8); /* AGP2_RESERVED_MASK */
 514
 515     info->aper_base = (unsigned long)bridge->aperturebase;
 516     info->aper_size = (unsigned long)bridge->aperturesize;
 517
 518     return 0;
 519 }
 520
 521 struct agp_bridge_data * agp_find_bridge(void * dev)
 522 {
 523     OOP_Object * agpbus = NULL;
 524
 525     if (global_agp_bridge)
 526         return global_agp_bridge;
 527
 528     if (!HiddAgpBase)
 529     {
 530         HiddAgpBase = OpenLibrary("agp.hidd", 1);
 531         HiddAGPBridgeDeviceAttrBase = OOP_ObtainAttrBase((STRPTR)IID_Hidd_AGPBridgeDevice);
 532     }
 533
 534     /* Get AGP bus object */
 535     agpbus = OOP_NewObject(NULL, CLID_Hidd_AGP, NULL);
 536
 537     if(agpbus)
 538     {
 539         struct pHidd_AGP_GetBridgeDevice gbdmsg = {
 540         mID : OOP_GetMethodID(IID_Hidd_AGP, moHidd_AGP_GetBridgeDevice)
 541         };
 542         OOP_Object * bridgedevice = NULL;
 543
 544         bridgedevice = (OOP_Object*)OOP_DoMethod(agpbus, (OOP_Msg)&gbdmsg);
 545
 546         OOP_DisposeObject(agpbus);
 547
 548         /* AGP bridge was found and initialized */
 549         if (bridgedevice)
 550         {
 551             IPTR mode = 0, aperbase = 0, apersize = 0;
 552
 553             global_agp_bridge = HIDDNouveauAlloc(sizeof(struct agp_bridge_data));
 554             global_agp_bridge->agpbridgedevice = (IPTR)bridgedevice;
 555
 556             OOP_GetAttr(bridgedevice, aHidd_AGPBridgeDevice_Mode, (APTR)&mode);
 557             global_agp_bridge->mode = mode;
 558
 559             OOP_GetAttr(bridgedevice, aHidd_AGPBridgeDevice_ApertureBase, (APTR)&aperbase);
 560             global_agp_bridge->aperturebase = aperbase;
 561
 562             OOP_GetAttr(bridgedevice, aHidd_AGPBridgeDevice_ApertureSize, (APTR)&apersize);
 563             global_agp_bridge->aperturesize = apersize;
 564         }
 565     }
 566
 567     return global_agp_bridge;
 568 }
 569
 570 void agp_enable(struct agp_bridge_data * bridge, u32 mode)
 571 {
 572     if (!bridge || !bridge->agpbridgedevice)
 573         return;
 574
 575     struct pHidd_AGPBridgeDevice_Enable emsg = {
 576     mID:            OOP_GetMethodID(IID_Hidd_AGPBridgeDevice, moHidd_AGPBridgeDevice_Enable),
 577     requestedmode:  mode
 578     };
 579
 580     OOP_DoMethod((OOP_Object *)bridge->agpbridgedevice, (OOP_Msg)&emsg);
 581 }
 582
 583 int agp_bind_memory(struct agp_memory * mem, off_t offset)
 584 {
 585     if (!mem || mem->is_bound)
 586         return -EINVAL;
 587
 588     if ((mem->type != AGP_USER_MEMORY) && (mem->type != AGP_USER_CACHED_MEMORY))
 589     {
 590         IMPLEMENT("Unsupported memory type: %d\n", mem->type);
 591         return -EINVAL;
 592     }
 593
 594     if (!mem->is_flushed)
 595     {
 596         /* TODO: Flush memory */
 597         mem->is_flushed = TRUE;
 598     }
 599
 600     /* TODO: agp_map_memory */
 601     /* TODO: Move flush/map into bind call on the side of agp.hidd */
 602
 603     struct pHidd_AGPBridgeDevice_BindMemory bmmsg = {
 604     mID:        OOP_GetMethodID(IID_Hidd_AGPBridgeDevice, moHidd_AGPBridgeDevice_BindMemory),
 605     address:    (IPTR)(mem->pages[0]->address),
 606     size:       mem->page_count * PAGE_SIZE,
 607     offset:     offset,
 608     type:       (mem->type == AGP_USER_MEMORY ? vHidd_AGP_NormalMemory : vHidd_AGP_CachedMemory)
 609     };
 610
 611     OOP_DoMethod((OOP_Object *)global_agp_bridge->agpbridgedevice, (OOP_Msg)&bmmsg);
 612
 613     mem->is_bound = TRUE;
 614     mem->pg_start = offset;
 615     return 0;
 616 }
 617
 618 int agp_unbind_memory(struct agp_memory * mem)
 619 {
 620     if (!mem || !mem->is_bound)
 621         return -EINVAL;
 622
 623     struct pHidd_AGPBridgeDevice_UnBindMemory ubmmsg = {
 624     mID:        OOP_GetMethodID(IID_Hidd_AGPBridgeDevice, moHidd_AGPBridgeDevice_UnBindMemory),
 625     offset:     mem->pg_start,
 626     size:       mem->page_count * PAGE_SIZE,
 627     };
 628
 629     OOP_DoMethod((OOP_Object *)global_agp_bridge->agpbridgedevice, (OOP_Msg)&ubmmsg);
 630
 631     /* TODO: agp_unmap_memory */
 632
 633     mem->is_bound = FALSE;
 634     mem->pg_start = 0;
 635     return 0;
 636 }
 637
 638 void agp_flush_chipset(struct agp_bridge_data * bridge)
 639 {
 640     if (!bridge || !bridge->agpbridgedevice)
 641         return;
 642
 643     struct pHidd_AGPBridgeDevice_FlushChipset fcmsg = {
 644     mID:        OOP_GetMethodID(IID_Hidd_AGPBridgeDevice, moHidd_AGPBridgeDevice_FlushChipset),
 645     };
 646
 647     OOP_DoMethod((OOP_Object *)bridge->agpbridgedevice, (OOP_Msg)&fcmsg);
 648 }
 649
 650 /* jiffies handling */
 651 #include <sys/time.h>
 652
 653 /* jiffies are supposed to be very precise time value. They are implemented
 654    as rather very unprecise */
 655 unsigned long get_jiffies()
 656 {
 657     struct timeval tv;
 658     unsigned long val = 0;
 659
 660     gettimeofday(&tv, NULL);
 661
 662     val = tv.tv_sec * 1000000 + tv.tv_usec; /* Yes, overflow */
 663
 664     /* TODO: Maybe make sure that each call to get_jiffies returns a different value? */
 665
 666     return val;
 667 }
 668
 669 /* I2C handling */
 670 #include <hidd/i2c.h>
 671
 672 OOP_AttrBase HiddI2CDeviceAttrBase = 0; /* TODO: Implement  freeing */
 673
 674 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
 675 {
 676     /* FIXME: This function is not generic. It has hardcoded cases that are present in nouveau */
 677     if (adap->i2cdriver == (IPTR)0)
 678     {
 679         bug("ERROR: i2c_transfer called without driver present\n");
 680         return 0;
 681     }
 682
 683     if (HiddI2CDeviceAttrBase == 0)
 684         HiddI2CDeviceAttrBase = OOP_ObtainAttrBase((STRPTR)IID_Hidd_I2CDevice);
 685
 686     if (HiddI2CDeviceAttrBase == 0)
 687     {
 688         bug("ERROR: i2c_trasfer not able to obtain HiddI2CDeviceAttrBase\n");
 689         return 0;
 690     }
 691
 692     /* Go through supported cases */
 693     if ((num == 2) && (msgs[0].addr == 0x50) && (msgs[1].addr == 0x50) && (msgs[0].len == 1) && (msgs[1].len == 1))
 694     {
 695         /* This is probing for DDC */
 696         D(bug("i2c_transfer - probing for DDC\n"));
 697         if (HIDD_I2C_ProbeAddress((OOP_Object *)adap->i2cdriver, 0xa0)) /* AROS has shifted addresses (<< 1) */
 698             return 2;
 699         else
 700             return 0;
 701     }
 702     else if ((num == 2) && (msgs[0].addr == 0x75) && (msgs[1].addr == 0x75) && (msgs[0].len == 1) && (msgs[1].len == 1))
 703     {
 704         /* This is probing for some hardware related to TV output on nv04 */
 705         D(bug("i2c_transfer - probing for some hardware related to TV output on nv04\n"));
 706         if (HIDD_I2C_ProbeAddress((OOP_Object *)adap->i2cdriver, 0xea)) /* AROS has shifted addresses (<< 1) */
 707             return 2;
 708         else
 709             return 0;
 710     }
 711     else if ((num == 2) && (msgs[0].addr == 0x50) && (msgs[1].addr == 0x50) && (msgs[0].len == 1) && (msgs[1].len != 1))
 712     {
 713         /* This is reading data from DDC */
 714         struct pHidd_I2CDevice_WriteRead msg;
 715         BOOL result = FALSE;
 716
 717         struct TagItem attrs[] =
 718         {
 719             { aHidd_I2CDevice_Driver,   (IPTR)adap->i2cdriver   },
 720             { aHidd_I2CDevice_Address,  0xa0                    },
 721             { aHidd_I2CDevice_Name,     (IPTR)"Read DDC"        },
 722             { TAG_DONE, 0UL }
 723         };
 724
 725         D(bug("i2c_transfer - reading from DDC\n"));
 726
 727         OOP_Object *obj = OOP_NewObject(NULL, CLID_Hidd_I2CDevice, attrs);
 728
 729         msg.mID = OOP_GetMethodID((STRPTR)IID_Hidd_I2CDevice, moHidd_I2CDevice_WriteRead);
 730         msg.readBuffer = msgs[1].buf;
 731         msg.readLength = msgs[1].len;
 732         msg.writeBuffer = msgs[0].buf;
 733         msg.writeLength = msgs[0].len;
 734
 735         result = OOP_DoMethod(obj, &msg.mID);
 736
 737         OOP_DisposeObject(obj);
 738
 739         if (result)
 740             return 2;
 741         else
 742             return 0;
 743     }
 744     else if ((num == 2) && (msgs[0].addr == 0x54) && (msgs[1].addr == 0x54) && (msgs[0].len == 1) && (msgs[1].len == 1))
 745     {
 746         /* This is reading data from register 0x54 */
 747         struct pHidd_I2CDevice_WriteRead msg;
 748         BOOL result = FALSE;
 749
 750         struct TagItem attrs[] =
 751         {
 752             { aHidd_I2CDevice_Driver,   (IPTR)adap->i2cdriver   },
 753             { aHidd_I2CDevice_Address,  0xa8                    },
 754             { aHidd_I2CDevice_Name,     (IPTR)"Read Register"   },
 755             { TAG_DONE, 0UL }
 756         };
 757
 758         D(bug("i2c_transfer - reading from register 0x54\n"));
 759
 760         OOP_Object *obj = OOP_NewObject(NULL, CLID_Hidd_I2CDevice, attrs);
 761
 762         msg.mID = OOP_GetMethodID((STRPTR)IID_Hidd_I2CDevice, moHidd_I2CDevice_WriteRead);
 763         msg.readBuffer = msgs[1].buf;
 764         msg.readLength = msgs[1].len;
 765         msg.writeBuffer = msgs[0].buf;
 766         msg.writeLength = msgs[0].len;
 767
 768         result = OOP_DoMethod(obj, &msg.mID);
 769
 770         OOP_DisposeObject(obj);
 771
 772         if (result)
 773             return 2;
 774         else
 775             return 0;
 776     }
 777     else
 778     {
 779         /* Not supported case */
 780         bug("i2c_transfer case not supported: num = %d\n", num);
 781     }
 782
 783     /* Failure */
 784     return 0;
 785 }
 786
 787 int i2c_del_adapter(struct i2c_adapter * adap)
 788 {
 789     IMPLEMENT("\n");
 790     return 0;
 791 }
 792
 793 /* Other */
 794 unsigned int hweight32(unsigned int number)
 795 {
 796     unsigned int result = 0;
 797     int i = 0;
 798
 799     for (i = 0; i < 32; i++)
 800     {
 801         if (number & 0x1) result++;
 802         number >>= 1;
 803     }
 804
 805     return result;
 806 }
 807
 808 unsigned int hweight8(unsigned int number)
 809 {
 810     unsigned int result = 0;
 811     int i = 0;
 812
 813     for (i = 0; i < 8; i++)
 814     {
 815         if (number & 0x1) result++;
 816         number >>= 1;
 817     }
 818
 819     return result;
 820 }