workbench/hidds/hidd.i2c/i2cdeviceclass.c

   1 /*
   2     Copyright © 2004, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: PCI device class
   6     Lang: English
   7 */
   8
   9 #include <exec/types.h>
  10 #include <hidd/i2c.h>
  11 #include <oop/oop.h>
  12
  13 #include <utility/tagitem.h>
  14
  15 #include <proto/exec.h>
  16 #include <proto/utility.h>
  17 #include <proto/oop.h>
  18
  19 #include "i2c.h"
  20
  21 #define DEBUG 1
  22 #include <aros/debug.h>
  23
  24 #undef HiddI2CAttrBase
  25 #undef HiddI2CDeviceAttrBase
  26
  27 #define HiddI2CAttrBase         (SD(cl)->hiddI2CAB)
  28 #define HiddI2CDeviceAttrBase   (SD(cl)->hiddI2CDeviceAB)
  29 #define HiddAttrBase            (SD(cl)->hiddAB)
  30
  31 BOOL METHOD(I2CDev, Hidd_I2CDevice, Read)
  32 {
  33     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
  34
  35     return I2C_WriteRead(dev->driver, o, NULL, 0, msg->readBuffer, msg->readLength);
  36 }
  37
  38 BOOL METHOD(I2CDev, Hidd_I2CDevice, ReadByte)
  39 {
  40     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
  41
  42     return I2C_WriteRead(dev->driver, o, &msg->subaddr, 1, msg->data, 1);
  43 }
  44
  45 BOOL METHOD(I2CDev, Hidd_I2CDevice, ReadBytes)
  46 {
  47     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
  48
  49     return I2C_WriteRead(dev->driver, o, &msg->subaddr, 1, msg->data, msg->length);
  50 }
  51
  52 BOOL METHOD(I2CDev, Hidd_I2CDevice, ReadStatus)
  53 {
  54     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
  55
  56     return I2C_WriteRead(dev->driver, o, NULL, 0, msg->status, 1);
  57 }
  58
  59 BOOL METHOD(I2CDev, Hidd_I2CDevice, ReadWord)
  60 {
  61     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
  62     BOOL r;
  63     UBYTE buff[2];
  64
  65     if ((r = I2C_WriteRead(dev->driver, o, &msg->subaddr, 1, buff, 2)))
  66     {
  67         *msg->data = (buff[0] << 8) | buff[1];
  68     }
  69
  70     return r;
  71 }
  72
  73 BOOL METHOD(I2CDev, Hidd_I2CDevice, Write)
  74 {
  75     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
  76
  77     return I2C_WriteRead(dev->driver, o, msg->writeBuffer, msg->writeLength, NULL, 0);
  78 }
  79
  80 BOOL METHOD(I2CDev, Hidd_I2CDevice, WriteByte)
  81 {
  82     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
  83     UBYTE buff[2];
  84
  85     buff[0] = msg->subaddr;
  86     buff[1] = msg->data;
  87
  88     return I2C_WriteRead(dev->driver, o, buff, 2, NULL, 0);
  89 }
  90
  91 BOOL METHOD(I2CDev, Hidd_I2CDevice, WriteBytes)
  92 {
  93     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
  94     BOOL r = TRUE;
  95     ULONG nWrite = msg->length;
  96     UBYTE *WriteBuffer = msg->data;
  97
  98     if (nWrite > 0)
  99     {
 100         if ((r = I2C_Address(dev->driver, o, dev->address & ~1)))
 101         {
 102             if ((r = I2C_PutByte(dev->driver, o, msg->subaddr)))
 103             {
 104                 for (; nWrite > 0; WriteBuffer++, nWrite--)
 105                     if (!(r = I2C_PutByte(dev->driver, o, *WriteBuffer)))
 106                         break;
 107             }
 108
 109             I2C_Stop(dev->driver, o);
 110         }
 111     }
 112
 113     return r;
 114 }
 115
 116 BOOL METHOD(I2CDev, Hidd_I2CDevice, WriteWord)
 117 {
 118     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
 119     UBYTE buff[3];
 120
 121     buff[0] = msg->subaddr;
 122     buff[1] = msg->data >> 8;
 123     buff[2] = msg->data & 0xff;
 124
 125     return I2C_WriteRead(dev->driver, o, buff, 2, NULL, 0);
 126 }
 127
 128 BOOL METHOD(I2CDev, Hidd_I2CDevice, WriteVec)
 129 {
 130     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
 131     BOOL r = TRUE;
 132     int s = 0;
 133     ULONG nValues = msg->length;
 134     UBYTE *vec = msg->data;
 135
 136     if (nValues > 0)
 137     {
 138         for (; nValues > 0; nValues--, vec+=2)
 139         {
 140             if (!(r = I2C_Address(dev->driver, o, dev->address & ~1)))
 141                 break;
 142
 143             s++;
 144
 145             if (!(r = I2C_PutByte(dev->driver, o, vec[0])))
 146                 break;
 147
 148             if (!(r = I2C_PutByte(dev->driver, o, vec[1])))
 149                 break;
 150         }
 151
 152         if (s > 0) I2C_Stop(dev->driver, o);
 153     }
 154
 155     return r;
 156 }
 157
 158 BOOL METHOD(I2CDev, Hidd_I2CDevice, WriteRead)
 159 {
 160     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
 161
 162     return I2C_WriteRead(dev->driver, o, msg->writeBuffer, msg->writeLength, msg->readBuffer, msg->readLength);
 163 }
 164
 165 /*** Root */
 166
 167 OOP_Object *METHOD(I2CDev, Root, New)
 168 {
 169     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
 170     if (o)
 171     {
 172         struct TagItem *tag, *tags = msg->attrList;
 173         tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
 174         OOP_Object *driver = NULL;
 175         UWORD address = 0;
 176
 177         dev->HoldTime = -1;
 178         dev->AcknTimeout = -1;
 179         dev->BitTimeout = -1;
 180         dev->ByteTimeout = -1;
 181         dev->RiseFallTime = -1;
 182         dev->StartTimeout = -1;
 183
 184         dev->name = (STRPTR)"dev?";
 185
 186         tags=msg->attrList;
 187
 188         while((tag = NextTagItem(&tags)))
 189         {
 190             ULONG idx;
 191
 192             if (IS_I2CDEV_ATTR(tag->ti_Tag, idx))
 193             {
 194                 switch(idx)
 195                 {
 196                     case aoHidd_I2CDevice_Driver:
 197                         dev->driver = (OOP_Object*)tag->ti_Data;
 198                         driver = dev->driver;
 199                         break;
 200
 201                     case aoHidd_I2CDevice_Address:
 202                         dev->address = tag->ti_Data;
 203                         address = dev->address;
 204                         break;
 205
 206                     case aoHidd_I2CDevice_Name:
 207                         dev->name = (STRPTR)tag->ti_Data;
 208                         break;
 209
 210                     case aoHidd_I2CDevice_HoldTime:
 211                         dev->HoldTime = tag->ti_Data;
 212                         break;
 213
 214                     case aoHidd_I2CDevice_BitTimeout:
 215                         dev->BitTimeout = tag->ti_Data;
 216                         break;
 217
 218                     case aoHidd_I2CDevice_ByteTimeout:
 219                         dev->ByteTimeout = tag->ti_Data;
 220                         break;
 221
 222                     case aoHidd_I2CDevice_AcknTimeout:
 223                         dev->AcknTimeout = tag->ti_Data;
 224                         break;
 225
 226                     case aoHidd_I2CDevice_StartTimeout:
 227                         dev->StartTimeout = tag->ti_Data;
 228                         break;
 229
 230                     case aoHidd_I2CDevice_RiseFallTime:
 231                         dev->RiseFallTime = tag->ti_Data;
 232                         break;
 233                 }
 234             }
 235         }
 236
 237         if (driver && address)
 238         {
 239             IPTR val;
 240             if (dev->AcknTimeout == -1)
 241             {
 242                 OOP_GetAttr(driver, aHidd_I2C_AcknTimeout, &val);
 243                 dev->AcknTimeout = val;
 244             }
 245             if (dev->BitTimeout == -1)
 246             {
 247                 OOP_GetAttr(driver, aHidd_I2C_BitTimeout, &val);
 248                 dev->BitTimeout = val;
 249             }
 250             if (dev->ByteTimeout == -1)
 251             {
 252                 OOP_GetAttr(driver, aHidd_I2C_ByteTimeout, &val);
 253                 dev->ByteTimeout = val;
 254             }
 255             if (dev->HoldTime == -1)
 256             {
 257                 OOP_GetAttr(driver, aHidd_I2C_HoldTime, &val);
 258                 dev->HoldTime = val;
 259             }
 260             if (dev->RiseFallTime == -1)
 261             {
 262                 OOP_GetAttr(driver, aHidd_I2C_RiseFallTime, &val);
 263                 dev->RiseFallTime = val;
 264             }
 265             if (dev->StartTimeout == -1)
 266             {
 267                 OOP_GetAttr(driver, aHidd_I2C_StartTimeout, &val);
 268                 dev->StartTimeout = val;
 269             }
 270         }
 271         else
 272         {
 273              OOP_MethodID disp_mid = OOP_GetMethodID((STRPTR)IID_Root, moRoot_Dispose);
 274              OOP_CoerceMethod(cl, o, (OOP_Msg) &disp_mid);
 275              o = NULL;
 276         }
 277     }
 278
 279     return o;
 280 }
 281
 282 void METHOD(I2CDev, Root, Get)
 283 {
 284     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
 285     ULONG idx;
 286
 287     if (IS_I2CDEV_ATTR(msg->attrID, idx))
 288     {
 289         switch (idx)
 290         {
 291             case aoHidd_I2CDevice_Driver:
 292                 *msg->storage = (IPTR)dev->driver;
 293                 break;
 294
 295             case aoHidd_I2CDevice_Address:
 296                 *msg->storage = dev->address;
 297                 break;
 298
 299             case aoHidd_I2CDevice_Name:
 300                 *msg->storage = (IPTR)dev->name;
 301                 break;
 302
 303             case aoHidd_I2CDevice_HoldTime:
 304                 *msg->storage = dev->HoldTime;
 305                 break;
 306
 307             case aoHidd_I2CDevice_BitTimeout:
 308                 *msg->storage = dev->BitTimeout;
 309                 break;
 310
 311             case aoHidd_I2CDevice_ByteTimeout:
 312                 *msg->storage = dev->ByteTimeout;
 313                 break;
 314
 315             case aoHidd_I2CDevice_AcknTimeout:
 316                 *msg->storage = dev->AcknTimeout;
 317                 break;
 318
 319             case aoHidd_I2CDevice_StartTimeout:
 320                 *msg->storage = dev->StartTimeout;
 321                 break;
 322
 323             case aoHidd_I2CDevice_RiseFallTime:
 324                 *msg->storage = dev->RiseFallTime;
 325                 break;
 326         }
 327     }
 328     else
 329     {
 330         OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 331     }
 332 }
 333
 334 void METHOD(I2CDev, Root, Set)
 335 {
 336     tDevData *dev = (tDevData *)OOP_INST_DATA(cl, o);
 337     ULONG idx;
 338     struct TagItem *tag, *tags = msg->attrList;
 339
 340     while ((tag = NextTagItem(&tags)))
 341     {
 342         if (IS_I2CDEV_ATTR(tag->ti_Tag, idx))
 343         {
 344             switch (idx)
 345             {
 346                 case aoHidd_I2CDevice_HoldTime:
 347                     dev->HoldTime = tag->ti_Data;
 348                     break;
 349
 350                 case aoHidd_I2CDevice_BitTimeout:
 351                     dev->BitTimeout = tag->ti_Data;
 352                     break;
 353
 354                 case aoHidd_I2CDevice_ByteTimeout:
 355                     dev->ByteTimeout = tag->ti_Data;
 356                     break;
 357
 358                 case aoHidd_I2CDevice_AcknTimeout:
 359                     dev->AcknTimeout = tag->ti_Data;
 360                     break;
 361
 362                 case aoHidd_I2CDevice_StartTimeout:
 363                     dev->StartTimeout = tag->ti_Data;
 364                     break;
 365
 366                 case aoHidd_I2CDevice_RiseFallTime:
 367                     dev->RiseFallTime = tag->ti_Data;
 368                     break;
 369             }
 370         }
 371     }
 372 }
 373