workbench/hidds/hidd.i2c/i2cclass.c

   1 /*
   2     Copyright � 2004-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <exec/types.h>
   7 #include <hidd/hidd.h>
   8 #include <hidd/i2c.h>
   9 #include <oop/oop.h>
  10
  11 #include <utility/tagitem.h>
  12 #include <utility/hooks.h>
  13 #include <devices/timer.h>
  14
  15 #include <proto/exec.h>
  16 #include <proto/utility.h>
  17 #include <proto/oop.h>
  18
  19 #include <aros/symbolsets.h>
  20
  21 #include "i2c.h"
  22
  23 #define DEBUG 0
  24 #include <aros/debug.h>
  25 #include <aros/atomic.h>
  26
  27 /*
  28     There are no static AttrBases in this class. Therefore it might be placed
  29     directly in ROM without any harm
  30 */
  31 #undef HiddI2CAttrBase
  32 #undef HiddI2CDeviceAttrBase
  33
  34 #define HiddI2CAttrBase         (SD(cl)->hiddI2CAB)
  35 #define HiddI2CDeviceAttrBase   (SD(cl)->hiddI2CDeviceAB)
  36 #define HiddAttrBase            (SD(cl)->hiddAB)
  37
  38 static void I2C_UDelay(tDrvData *drv, ULONG delay)
  39 {
  40     drv->mp.mp_SigTask = FindTask(NULL);
  41     drv->tr.tr_node.io_Command = TR_ADDREQUEST;
  42     drv->tr.tr_time.tv_secs = delay / 10000;
  43     drv->tr.tr_time.tv_micro = 10 * (delay % 10000);
  44
  45     DoIO((struct IORequest *)&drv->tr);
  46
  47     drv->mp.mp_SigTask = NULL;
  48 }
  49
  50
  51 static BOOL RaiseSCL(OOP_Class *cl, OOP_Object *o, BOOL sda, ULONG timeout)
  52 {
  53     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
  54
  55     int i;
  56     BOOL scl;
  57
  58     I2C_PutBits(o, 1, sda);
  59     I2C_UDelay(drv, drv->RiseFallTime);
  60
  61     for (i=timeout; i>0; i -= drv->RiseFallTime)
  62     {
  63         I2C_GetBits(o, &scl, &sda);
  64         if (scl) break;
  65         I2C_UDelay(drv, drv->RiseFallTime);
  66     }
  67
  68     if (i <= 0)
  69     {
  70         bug("[I2C] RaiseSCL(<%s>,%d,%d) timeout\n", drv->name, sda, timeout);
  71         return FALSE;
  72     }
  73
  74     return TRUE;
  75 }
  76
  77 static BOOL WriteBit(OOP_Class *cl, OOP_Object *o, BOOL sda, ULONG timeout)
  78 {
  79     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
  80
  81     BOOL r;
  82
  83     I2C_PutBits(o, 0, sda);
  84     I2C_UDelay(drv, drv->RiseFallTime);
  85
  86     r = RaiseSCL(cl, o, sda, timeout);
  87     I2C_UDelay(drv, drv->HoldTime);
  88
  89     I2C_PutBits(o, 0, sda);
  90     I2C_UDelay(drv, drv->HoldTime);
  91
  92     return r;
  93 }
  94
  95 static BOOL ReadBit(OOP_Class *cl, OOP_Object *o, BOOL *sda, ULONG timeout)
  96 {
  97     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
  98
  99     BOOL scl, r;
 100
 101     r = RaiseSCL(cl, o, 1, timeout);
 102     I2C_UDelay(drv, drv->HoldTime);
 103
 104     I2C_GetBits(o, &scl, sda);
 105
 106     I2C_PutBits(o, 0, 1);
 107     I2C_UDelay(drv, drv->HoldTime);
 108
 109     return r;
 110 }
 111
 112 /*** Hidd::I2C */
 113
 114 void METHOD(I2C, Hidd_I2C, PutBits)
 115 {
 116     bug("[I2C] Pure virtual method I2C::PutBits() called!!!\n");
 117 }
 118
 119 void METHOD(I2C, Hidd_I2C, GetBits)
 120 {
 121     bug("[I2C] Pure virtual method I2C::GetBits() called!!!\n");
 122 }
 123
 124 BOOL METHOD(I2C, Hidd_I2C, Start)
 125 {
 126     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
 127
 128     LOCK_HW
 129
 130     if (!RaiseSCL(cl, o, 1, msg->timeout)) {
 131         UNLOCK_HW
 132         return FALSE;
 133     }
 134
 135     I2C_PutBits(o, 1, 0);
 136     I2C_UDelay(drv, drv->HoldTime);
 137     I2C_PutBits(o, 0, 0);
 138     I2C_UDelay(drv, drv->HoldTime);
 139
 140     D(bug("\n[I2C]: <"));
 141
 142     UNLOCK_HW
 143
 144     return TRUE;
 145 }
 146
 147 BOOL METHOD(I2C, Hidd_I2C, Address)
 148 {
 149     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
 150     tDevData *dev = (tDevData *)OOP_INST_DATA(SD(cl)->i2cDeviceClass, msg->device);
 151
 152     LOCK_HW
 153
 154     if (I2C_Start(o, dev->StartTimeout)) {
 155         if (I2C_PutByte(o, msg->device, msg->address & 0xFF)) {
 156             if ((msg->address & 0xF8) != 0xF0 &&
 157                 (msg->address & 0xFE) != 0x00) {
 158                 UNLOCK_HW;
 159                 return TRUE;
 160                 }
 161
 162             if (I2C_PutByte(o, msg->device, (msg->address >> 8) & 0xFF)) {
 163                 UNLOCK_HW;
 164                 return TRUE;
 165             }
 166         }
 167
 168         I2C_Stop(o, msg->device);
 169     }
 170
 171     UNLOCK_HW
 172
 173     return FALSE;
 174 }
 175
 176 BOOL METHOD(I2C, Hidd_I2C, ProbeAddress)
 177 {
 178     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
 179
 180     struct TagItem attrs[] = {
 181         { aHidd_I2CDevice_Driver,   (IPTR)o         },
 182         { aHidd_I2CDevice_Address,  msg->address    },
 183         { aHidd_I2CDevice_Name,     (IPTR)"Probing" },
 184         { TAG_DONE, 0UL }
 185     };
 186
 187     BOOL r = FALSE;
 188
 189     D(bug("[I2C] I2C::ProbeAddress(%04x)\n", msg->address));
 190
 191     LOCK_HW
 192
 193     OOP_Object *probing = OOP_NewObject(SD(cl)->i2cDeviceClass, NULL, attrs);
 194
 195     if (probing)
 196     {
 197         r = I2C_Address(o, probing, msg->address);
 198         if (r)
 199           I2C_Stop(o, probing);
 200
 201         OOP_DisposeObject(probing);
 202     }
 203
 204     UNLOCK_HW
 205
 206     return r;
 207 }
 208
 209
 210 void METHOD(I2C, Hidd_I2C, Stop)
 211 {
 212     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
 213
 214     LOCK_HW
 215
 216     I2C_PutBits(o, 0, 0);
 217     I2C_UDelay(drv, drv->RiseFallTime);
 218
 219     I2C_PutBits(o, 1, 0);
 220     I2C_UDelay(drv, drv->HoldTime);
 221     I2C_PutBits(o, 1, 1);
 222     I2C_UDelay(drv, drv->HoldTime);
 223
 224     D(bug(">\n"));
 225
 226     UNLOCK_HW
 227 }
 228
 229 BOOL METHOD(I2C, Hidd_I2C, PutByte)
 230 {
 231     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
 232     tDevData *dev = (tDevData *)OOP_INST_DATA(SD(cl)->i2cDeviceClass, msg->device);
 233
 234     BOOL r, scl, sda;
 235     int i;
 236
 237     LOCK_HW
 238
 239     if (!WriteBit(cl, o, (msg->data >> 7) & 1, dev->ByteTimeout))
 240     {
 241         UNLOCK_HW
 242         return FALSE;
 243     }
 244
 245     for (i = 6; i >= 0; i--)
 246         if (!WriteBit(cl, o, (msg->data >> i) & 1, dev->BitTimeout))
 247         {
 248             UNLOCK_HW
 249             return FALSE;
 250         }
 251
 252     I2C_PutBits(o, 0, 1);
 253     I2C_UDelay(drv, drv->RiseFallTime);
 254
 255     r = RaiseSCL(cl, o, 1, drv->HoldTime);
 256
 257     if (r)
 258     {
 259         for (i = dev->AcknTimeout; i > 0; i -= drv->HoldTime)
 260         {
 261             I2C_UDelay(drv, drv->HoldTime);
 262             I2C_GetBits(o, &scl, &sda);
 263             if (sda == 0) break;
 264         }
 265
 266         if (i <= 0) {
 267             D(bug("[I2C] PutByte(<%s>, 0x%02x, %d, %d, %d) timeout",
 268                                        drv->name, msg->data, dev->BitTimeout,
 269                                        dev->ByteTimeout, dev->AcknTimeout));
 270             r = FALSE;
 271         }
 272
 273         D(bug("W%02x%c ", (int) msg->data, sda ? '-' : '+'));
 274     }
 275
 276     I2C_PutBits(o, 0, 1);
 277     I2C_UDelay(drv, drv->HoldTime);
 278
 279     UNLOCK_HW
 280
 281     return r;
 282 }
 283
 284 BOOL METHOD(I2C, Hidd_I2C, GetByte)
 285 {
 286     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
 287     tDevData *dev = (tDevData *)OOP_INST_DATA(SD(cl)->i2cDeviceClass, msg->device);
 288
 289     int i;
 290     BOOL sda;
 291
 292     LOCK_HW
 293
 294     I2C_PutBits(o, 0, 1);
 295     I2C_UDelay(drv, drv->RiseFallTime);
 296
 297     if (!ReadBit(cl, o, &sda, dev->ByteTimeout))
 298     {
 299         UNLOCK_HW
 300         return FALSE;
 301     }
 302
 303
 304     *msg->data = (sda? 1:0) << 7;
 305
 306     for (i = 6; i >= 0; i--)
 307         if (!ReadBit(cl, o, &sda, dev->BitTimeout))
 308         {
 309             UNLOCK_HW
 310             return FALSE;
 311         }
 312         else
 313             *msg->data |= (sda? 1:0) << i;
 314
 315     if (!WriteBit(cl, o, msg->last ? 1 : 0, dev->BitTimeout))
 316     {
 317         UNLOCK_HW
 318         return FALSE;
 319     }
 320
 321     D(bug("R%02x%c ", (int) *msg->data, msg->last ? '+' : '-'));
 322
 323     UNLOCK_HW
 324
 325     return TRUE;
 326 }
 327
 328 BOOL METHOD(I2C, Hidd_I2C, WriteRead)
 329 {
 330     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
 331     tDevData *dev = (tDevData *)OOP_INST_DATA(SD(cl)->i2cDeviceClass, msg->device);
 332
 333     BOOL r = TRUE;
 334     int s = 0;
 335
 336     ULONG nWrite = msg->writeLength;
 337     UBYTE *WriteBuffer = msg->writeBuffer;
 338     ULONG nRead = msg->readLength;
 339     UBYTE *ReadBuffer = msg->readBuffer;
 340
 341     LOCK_HW
 342
 343     if (r && nWrite > 0) {
 344         r = I2C_Address(o, msg->device, dev->address & ~1);
 345         if (r) {
 346             for (; nWrite > 0; WriteBuffer++, nWrite--)
 347                 if (!(r = I2C_PutByte(o, msg->device, *WriteBuffer)))
 348                     break;
 349             s++;
 350         }
 351     }
 352
 353     if (r && nRead > 0) {
 354         r = I2C_Address(o, msg->device, dev->address | 1);
 355         if (r) {
 356             for (; nRead > 0; ReadBuffer++, nRead--)
 357                 if (!(r = I2C_GetByte(o, msg->device, ReadBuffer, nRead == 1)))
 358                     break;
 359             s++;
 360         }
 361     }
 362
 363     if (s) I2C_Stop(o, msg->device);
 364
 365     UNLOCK_HW
 366
 367     return r;
 368 }
 369
 370 /*** Root */
 371
 372 void METHOD(I2C, Root, Get)
 373 {
 374     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
 375
 376     ULONG idx;
 377
 378     if (IS_I2C_ATTR(msg->attrID, idx))
 379     {
 380         switch (idx)
 381         {
 382             case aoHidd_I2C_HoldTime:
 383                 *msg->storage = drv->HoldTime;
 384                 break;
 385
 386             case aoHidd_I2C_BitTimeout:
 387                 *msg->storage = drv->BitTimeout;
 388                 break;
 389
 390             case aoHidd_I2C_ByteTimeout:
 391                 *msg->storage = drv->ByteTimeout;
 392                 break;
 393
 394             case aoHidd_I2C_AcknTimeout:
 395                 *msg->storage = drv->AcknTimeout;
 396                 break;
 397
 398             case aoHidd_I2C_StartTimeout:
 399                 *msg->storage = drv->StartTimeout;
 400                 break;
 401
 402             case aoHidd_I2C_RiseFallTime:
 403                 *msg->storage = drv->RiseFallTime;
 404                 break;
 405
 406             case aoHidd_I2C_Name:
 407                 *msg->storage = (IPTR)drv->name;
 408                 break;
 409         }
 410     }
 411     else
 412     {
 413         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 414     }
 415 }
 416
 417 void METHOD(I2C, Root, Set)
 418 {
 419     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
 420
 421     ULONG idx;
 422     struct TagItem *tag;
 423     struct TagItem *tags = msg->attrList;
 424
 425     while ((tag = NextTagItem(&tags)))
 426     {
 427         if (IS_I2C_ATTR(tag->ti_Tag, idx))
 428         {
 429             switch (idx)
 430             {
 431                 case aoHidd_I2C_HoldTime:
 432                     drv->HoldTime = tag->ti_Data;
 433                     break;
 434
 435                 case aoHidd_I2C_BitTimeout:
 436                     drv->BitTimeout = tag->ti_Data;
 437                     break;
 438
 439                 case aoHidd_I2C_ByteTimeout:
 440                     drv->ByteTimeout = tag->ti_Data;
 441                     break;
 442
 443                 case aoHidd_I2C_AcknTimeout:
 444                     drv->AcknTimeout = tag->ti_Data;
 445                     break;
 446
 447                 case aoHidd_I2C_StartTimeout:
 448                     drv->StartTimeout = tag->ti_Data;
 449                     break;
 450
 451                 case aoHidd_I2C_RiseFallTime:
 452                     drv->RiseFallTime = tag->ti_Data;
 453                     break;
 454             }
 455         }
 456     }
 457 }
 458
 459 OOP_Object *METHOD(I2C, Root, New)
 460 {
 461     D(bug("[I2C] new()\n"));
 462
 463     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
 464     if (o)
 465     {
 466         tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
 467         struct TagItem *tag, *tags = msg->attrList;
 468
 469         drv->HoldTime = 5;
 470         drv->AcknTimeout = 5;
 471         drv->BitTimeout = 5;
 472         drv->ByteTimeout = 5;
 473         drv->RiseFallTime = 2;
 474         drv->StartTimeout = 5;
 475
 476         drv->name = (STRPTR)"bus?";
 477
 478         InitSemaphore(&drv->driver_lock);
 479
 480         D(bug("[I2C] Initializing MsgPort\n"));
 481
 482         /* Initialize MsgPort */
 483         drv->mp.mp_SigBit = SIGB_SINGLE;
 484         drv->mp.mp_Flags = PA_SIGNAL;
 485         drv->mp.mp_SigTask = FindTask(NULL);
 486         drv->mp.mp_Node.ln_Type = NT_MSGPORT;
 487         NEWLIST(&drv->mp.mp_MsgList);
 488
 489         drv->tr.tr_node.io_Message.mn_ReplyPort = &drv->mp;
 490         drv->tr.tr_node.io_Message.mn_Length = sizeof(drv->tr);
 491
 492         D(bug("[I2C] Trying to open UNIT_MICROHZ of timer.device\n"));
 493
 494         if (!OpenDevice((STRPTR)"timer.device", UNIT_MICROHZ, (struct IORequest *)&drv->tr, 0))
 495         {
 496             D(bug("[I2C] Everything OK\n"));
 497
 498             tags=msg->attrList;
 499
 500             while((tag = NextTagItem(&tags)))
 501             {
 502                 ULONG idx;
 503
 504                 if (IS_I2C_ATTR(tag->ti_Tag, idx))
 505                 {
 506                     switch(idx)
 507                     {
 508                         case aoHidd_I2C_Name:
 509                             drv->name = (STRPTR)tag->ti_Data;
 510                             break;
 511
 512                         case aoHidd_I2C_HoldTime:
 513                             drv->HoldTime = tag->ti_Data;
 514                             break;
 515
 516                         case aoHidd_I2C_BitTimeout:
 517                             drv->BitTimeout = tag->ti_Data;
 518                             break;
 519
 520                         case aoHidd_I2C_ByteTimeout:
 521                             drv->ByteTimeout = tag->ti_Data;
 522                             break;
 523
 524                         case aoHidd_I2C_AcknTimeout:
 525                             drv->AcknTimeout = tag->ti_Data;
 526                             break;
 527
 528                         case aoHidd_I2C_StartTimeout:
 529                             drv->StartTimeout = tag->ti_Data;
 530                             break;
 531
 532                         case aoHidd_I2C_RiseFallTime:
 533                             drv->RiseFallTime = tag->ti_Data;
 534                             break;
 535                     }
 536                 }
 537             }
 538         }
 539         else
 540         {
 541             D(bug("[I2C] Opening of timer.device failed\n"));
 542             OOP_MethodID disp_mid = OOP_GetMethodID((STRPTR)IID_Root, moRoot_Dispose);
 543             OOP_CoerceMethod(cl, o, (OOP_Msg) &disp_mid);
 544             o = NULL;
 545         }
 546
 547     }
 548
 549     return o;
 550 }
 551
 552 VOID METHOD(I2C, Root, Dispose)
 553 {
 554     tDrvData *drv = (tDrvData *)OOP_INST_DATA(cl, o);
 555
 556     D(bug("[I2C] Dispose()\n"));
 557
 558     CloseDevice((struct IORequest *)&drv->tr);
 559
 560     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 561 }
 562
 563 /* Class initialization and destruction */
 564
 565 //#undef UtilityBase
 566 //#define UtilityBase (sd->utilitybase)
 567
 568 static int I2C_ExpungeClass(LIBBASETYPEPTR LIBBASE)
 569 {
 570     D(bug("[I2C] Base Class destruction\n"));
 571
 572     OOP_ReleaseAttrBase(IID_Hidd_I2CDevice);
 573     OOP_ReleaseAttrBase(IID_Hidd_I2C);
 574     OOP_ReleaseAttrBase(IID_Hidd);
 575
 576     return TRUE;
 577 }
 578
 579 static int I2C_InitClass(LIBBASETYPEPTR LIBBASE)
 580 {
 581     D(bug("[I2C] base class initialization\n"));
 582
 583     LIBBASE->sd.hiddI2CAB = OOP_ObtainAttrBase(IID_Hidd_I2C);
 584     LIBBASE->sd.hiddI2CDeviceAB = OOP_ObtainAttrBase(IID_Hidd_I2CDevice);
 585     LIBBASE->sd.hiddAB = OOP_ObtainAttrBase(IID_Hidd);
 586
 587     if (LIBBASE->sd.hiddI2CAB && LIBBASE->sd.hiddI2CDeviceAB && LIBBASE->sd.hiddAB)
 588     {
 589         D(bug("[I2C] Everything OK\n"));
 590         return TRUE;
 591     }
 592
 593     return FALSE;
 594 }
 595
 596 ADD2INITLIB(I2C_InitClass, 0)
 597 ADD2EXPUNGELIB(I2C_ExpungeClass, 0)