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