arch/common/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;
 173         const struct TagItem *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;
 340     const struct TagItem *tags = msg->attrList;
 341
 342     while ((tag = NextTagItem(&tags)))
 343     {
 344         if (IS_I2CDEV_ATTR(tag->ti_Tag, idx))
 345         {
 346             switch (idx)
 347             {
 348                 case aoHidd_I2CDevice_HoldTime:
 349                     dev->HoldTime = tag->ti_Data;
 350                     break;
 351
 352                 case aoHidd_I2CDevice_BitTimeout:
 353                     dev->BitTimeout = tag->ti_Data;
 354                     break;
 355
 356                 case aoHidd_I2CDevice_ByteTimeout:
 357                     dev->ByteTimeout = tag->ti_Data;
 358                     break;
 359
 360                 case aoHidd_I2CDevice_AcknTimeout:
 361                     dev->AcknTimeout = tag->ti_Data;
 362                     break;
 363
 364                 case aoHidd_I2CDevice_StartTimeout:
 365                     dev->StartTimeout = tag->ti_Data;
 366                     break;
 367
 368                 case aoHidd_I2CDevice_RiseFallTime:
 369                     dev->RiseFallTime = tag->ti_Data;
 370                     break;
 371             }
 372         }
 373     }
 374 }
 375