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