workbench/hidds/i2c/i2cclass.c

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