home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / lxapi32.zip / I2C / i2ccore.c < prev    next >
C/C++ Source or Header  |  2002-04-26  |  21KB  |  687 lines
  1. /* $Id: i2ccore.c,v 1.2 2002/04/26 23:08:58 smilcke Exp $ */
  2.  
  3. /*
  4.  * i2ccore.c
  5.  * Autor:               Stefan Milcke
  6.  * Erstellt am:         30.10.2001
  7.  * Letzte Aenderung am: 14.03.2002
  8.  *
  9. */
  10.  
  11. #include <linux/module.h>
  12. #include <linux/kernel.h>
  13. #include <linux/errno.h>
  14. #include <linux/slab.h>
  15. #include <linux/init.h>
  16. #include <linux/i2c.h>
  17.  
  18. #define I2C_LOCK(adap) down(&adap->lock)
  19. #define I2C_UNLOCK(adap) up(&adap->lock)
  20.  
  21. #define ADAP_LOCK()    down(&adap_lock)
  22. #define ADAP_UNLOCK()    up(&adap_lock)
  23.  
  24. #define DRV_LOCK()    down(&driver_lock)
  25. #define DRV_UNLOCK()    up(&driver_lock)
  26.  
  27. #ifdef USEPRINTK
  28. #define DEB(x) if (i2c_debug>=1) x;
  29. #define DEB2(x) if (i2c_debug>=2) x;
  30. #else
  31. #define DEB(x)
  32. #define DEB2(x)
  33. #endif
  34.  
  35. /**** lock for writing to global variables: the adapter & driver list */
  36. struct semaphore adap_lock;
  37. struct semaphore driver_lock;
  38.  
  39. /**** adapter list */
  40. static struct i2c_adapter *adapters[I2C_ADAP_MAX];
  41. static int adap_count;
  42.  
  43. /**** drivers list */
  44. static struct i2c_driver *drivers[I2C_DRIVER_MAX];
  45. static int driver_count;
  46.  
  47. /**** debug level */
  48. static int i2c_debug=0;
  49.  
  50. //------------------------------ i2c_add_adapter -------------------------------
  51. int i2c_add_adapter(struct i2c_adapter *adap)
  52. {
  53.  int i,j,res;
  54.  ADAP_LOCK();
  55.  for(i = 0; i < I2C_ADAP_MAX; i++)
  56.   if(NULL == adapters[i])
  57.    break;
  58.  if(I2C_ADAP_MAX == i)
  59.  {
  60.   CPK(printk(KERN_WARNING " i2c-core.o: register_adapter(%s) - enlarge I2C_ADAP_MAX.\n", adap->name));
  61.   res = -ENOMEM;
  62.   goto ERROR0;
  63.  }
  64.  adapters[i] = adap;
  65.  adap_count++;
  66.  ADAP_UNLOCK();
  67.  // init data types
  68.  init_MUTEX(&adap->lock);
  69.  // inform drivers of new adapters
  70.  DRV_LOCK();    
  71.  for(j=0;j<I2C_DRIVER_MAX;j++)
  72.   if(drivers[j]!=NULL && (drivers[j]->flags&(I2C_DF_NOTIFY|I2C_DF_DUMMY)))
  73.    // We ignore the return code; if it fails, too bad
  74.    drivers[j]->attach_adapter(adap);
  75.  DRV_UNLOCK();
  76.  DEB(printk("i2c-core.o: adapter %s registered as adapter %d.\n",adap->name,i));
  77.  return 0;    
  78. ERROR0:
  79.     ADAP_UNLOCK();
  80.     return res;
  81. }
  82.  
  83. //------------------------------ i2c_del_adapter -------------------------------
  84. int i2c_del_adapter(struct i2c_adapter *adap)
  85. {
  86.  int i,j,res;
  87.  ADAP_LOCK();
  88.  for(i=0;i<I2C_ADAP_MAX;i++)
  89.   if(adap==adapters[i])
  90.    break;
  91.  if(I2C_ADAP_MAX==i)
  92.  {
  93.   CPK(printk("i2ccore: unregister_adapter adap [%s] not found.\n",adap->name));
  94.   res=-ENODEV;
  95.   goto ERROR0;
  96.  }
  97.  // Dummy drivers do not register their clients, so we have to use a trick here:
  98.  // we call driver->attach_adapter to *detach* it! Of course, each dummy driver
  99.  // should know about this or hell will break loose...
  100.  DRV_LOCK();
  101.  for(j=0;j<I2C_DRIVER_MAX;j++)
  102.   if(drivers[j]&&(drivers[j]->flags&I2C_DF_DUMMY))
  103.    if((res=drivers[j]->attach_adapter(adap)))
  104.    {
  105.     CPK(printk("i2ccore: can't detach adapter %s while detaching driver %s: driver not detached!"
  106.            ,adap->name,drivers[j]->name));
  107.     goto ERROR1;
  108.    }
  109.  DRV_UNLOCK();
  110.  // detach any active clients. This must be done first, because it can fail;
  111.  // In which case we give up.
  112.  for(j=0;j<I2C_CLIENT_MAX;j++)
  113.  {
  114.   struct i2c_client *client=adap->clients[j];
  115.   if(client!=NULL)
  116.    if((res=client->driver->detach_client(client)))
  117.    {
  118.     CPK(printk("i2ccore: adapter %s not unregistered, because client at address %02x can't be detached."
  119.            ,adap->name,client->addr));
  120.     goto ERROR0;
  121.    }
  122.  }
  123.  adapters[i]=NULL;
  124.  adap_count--;
  125.  ADAP_UNLOCK();
  126.  CPK(printk("i2ccore: adapter unregistered: %s\n",adap->name));
  127.  return 0;
  128. ERROR0:
  129.  ADAP_UNLOCK();
  130.  return res;
  131. ERROR1:
  132.  DRV_UNLOCK();
  133.  return res;
  134. }
  135.  
  136. #ifdef TARGET_OS2
  137. unsigned long OS2_i2c_add_driver(struct i2c_driver *driver);
  138. unsigned long OS2_i2c_del_driver(struct i2c_driver *driver);
  139. #endif
  140. //------------------------------- i2c_add_driver -------------------------------
  141. int i2c_add_driver(struct i2c_driver *driver)
  142. {
  143.  int i;
  144.  DRV_LOCK();
  145.  for(i=0;i<I2C_DRIVER_MAX;i++)
  146.   if(NULL==drivers[i])
  147.    break;
  148.  if(I2C_DRIVER_MAX==i)
  149.  {
  150.   CPK(printk(KERN_WARNING "i2ccore: register_driver(%s) - enlarge I2C_DRIVER_MAX.\n"
  151.          ,driver->name));
  152.   DRV_UNLOCK();
  153.   return -ENOMEM;
  154.  }
  155.  drivers[i]=driver;
  156.  driver_count++;
  157.  DRV_UNLOCK(); // driver was successfully added
  158.  DEB(printk("i2ccore: driver %s registered.\n",driver->name));
  159.  ADAP_LOCK();
  160.  // Now look for instances of driver on our adapters
  161.  if(driver->flags&(I2C_DF_NOTIFY|I2C_DF_DUMMY))
  162.  {
  163.   for(i=0;i<I2C_ADAP_MAX;i++)
  164.    if(adapters[i]!=NULL)
  165.     driver->attach_adapter(adapters[i]);
  166.  }
  167.  ADAP_UNLOCK();
  168. #ifdef TARGET_OS2
  169.  OS2_i2c_add_driver(driver);
  170. #endif
  171.  return 0;
  172. }
  173.  
  174. //------------------------------- i2c_del_driver -------------------------------
  175. int i2c_del_driver(struct i2c_driver *driver)
  176. {
  177.  int i,j,k,res;
  178.  DRV_LOCK();
  179.  for(i=0;i<I2C_DRIVER_MAX;i++)
  180.   if(driver==drivers[i])
  181.    break;
  182.  if(I2C_DRIVER_MAX==i)
  183.  {
  184.   CPK(printk(KERN_WARNING "i2ccore: unregister driver: [%s] not found\n"
  185.          ,driver->name));
  186.   DRV_UNLOCK();
  187.   return -ENODEV;
  188.  }
  189.  // Have a look at each adapter, if clients of this driver are still attached.
  190.  // If so, detach them to be able to kill the driver afterwards.
  191.  DEB2(printk("i2ccore: unregister_driver - looking for clients.\n"));
  192.  // removing clients does not depend on the notify flag, else invalid operation
  193.  // might (will!) result, when using stale client pointers.
  194.  ADAP_LOCK();
  195.  for(k=0;k<I2C_ADAP_MAX;k++)
  196.  {
  197.   struct i2c_adapter *adap=adapters[k];
  198.   if(adap==NULL) // skip empty entries
  199.    continue;
  200.   DEB2(printk("i2ccore: examining adapter %s:\n",adap->name));
  201.   if(driver->flags&I2C_DF_DUMMY)
  202.   { // DUMMY drivers do not register their clients, so we have to use a trick
  203.     // here: we call driver->attach_adapter to *detach* it! Of course, each
  204.     // dummy driver should know about this or hell will break loose ...
  205.    if((res=driver->attach_adapter(adap)))
  206.    {
  207.     CPK(printk("i2ccore: while unregistering dummy driver %s, adapter %s could not be detached properly; driver not unloaded!"
  208.            ,driver->name,adap->name));
  209.     ADAP_UNLOCK();
  210.     return res;
  211.    }
  212.   }
  213.   else
  214.   {
  215.    for(j=0;j<I2C_CLIENT_MAX;j++)
  216.    {
  217.     struct i2c_client *client=adap->clients[j];
  218.     if(client!=NULL && client->driver==driver)
  219.     {
  220.      DEB2(printk("i2ccore: detaching client %s:\n",client->name));
  221.      if((res=driver->detach_client(client)))
  222.      {
  223.       CPK(printk("i2ccore: while unregistering driver %s the client at address %02x of adapters %s could not be detached; driver not unloaded!"
  224.              ,driver->name,client->addr,adap->name));
  225.       ADAP_UNLOCK();
  226.       return res;
  227.      }
  228.     }
  229.    }
  230.   }
  231.  }
  232.  ADAP_UNLOCK();
  233.  drivers[i]=NULL;
  234.  driver_count--;
  235.  DRV_UNLOCK();
  236.  DEB(printk("i2ccore: driver unregistered: %s\n",driver->name));
  237. #ifdef TARGET_OS2
  238.  OS2_i2c_del_driver(driver);
  239. #endif
  240.  return 0;
  241. }
  242.  
  243. //------------------------------- i2c_check_addr -------------------------------
  244. int i2c_check_addr(struct i2c_adapter *adapter,int addr)
  245. {
  246.  int i;
  247.  for(i=0;i<I2C_CLIENT_MAX;i++)
  248.   if(adapter->clients[i]&&(adapter->clients[i]->addr==addr))
  249.    return -EBUSY;
  250.  return 0;
  251. }
  252.  
  253. //----------------------------- i2c_attach_client ------------------------------
  254. int i2c_attach_client(struct i2c_client *client)
  255. {
  256.  struct i2c_adapter *adapter=client->adapter;
  257.  int i;
  258.  if(i2c_check_addr(client->adapter,client->addr))
  259.   return -EBUSY;
  260.  for(i=0;i<I2C_CLIENT_MAX;i++)
  261.   if(NULL==adapter->clients[i])
  262.    break;
  263.  if(I2C_CLIENT_MAX==i)
  264.  {
  265.   CPK(printk(KERN_WARNING "i2ccore: attach_client(%s) - enlarge I2C_CLIENT_MAX.\n"
  266.          ,client->name));
  267.   return -ENOMEM;
  268.  }
  269.  adapter->clients[i]=client;
  270.  adapter->client_count++;
  271.  if(adapter->client_register)
  272.   if(adapter->client_register(client))
  273.    CPK(printk("i2ccore: warning: client_register seems to have failed for client %02x at adapter %s\n"
  274.           ,client->addr,adapter->name));
  275.  DEB(printk("i2ccore: client [%s] registered to adapter [%s](pos. %d).\n"
  276.             ,client->name,adapter->name,i));
  277.  if(client->flags&I2C_CLIENT_ALLOW_USE)
  278.   client->usage_count=0;
  279.  return 0;
  280. }
  281.  
  282. //----------------------------- i2c_detach_client ------------------------------
  283. int i2c_detach_client(struct i2c_client *client)
  284. {
  285.  struct i2c_adapter *adapter = client->adapter;
  286.  int i,res;
  287.  for(i = 0; i < I2C_CLIENT_MAX; i++)
  288.   if (client == adapter->clients[i])
  289.    break;
  290.  if(I2C_CLIENT_MAX == i)
  291.  {
  292.   CPK(printk(KERN_WARNING " i2c-core.o: unregister_client [%s] not found\n",
  293.          client->name));
  294.   return -ENODEV;
  295.  }
  296.  if((client->flags & I2C_CLIENT_ALLOW_USE) && (client->usage_count>0))
  297.   return -EBUSY;
  298.  if(adapter->client_unregister != NULL)
  299.   if ((res = adapter->client_unregister(client)))
  300.   {
  301.    CPK(printk("i2c-core.o: client_unregister [%s] failed, client not detached"
  302.           ,client->name));
  303.    return res;
  304.   }
  305.  adapter->clients[i] = NULL;
  306.  adapter->client_count--;
  307.  DEB(printk("i2c-core.o: client [%s] unregistered.\n",client->name));
  308.  return 0;
  309. }
  310.  
  311. //----------------------------- i2c_inc_use_client -----------------------------
  312. void i2c_inc_use_client(struct i2c_client *client)
  313. {
  314.  if(client->driver->inc_use != NULL)
  315.   client->driver->inc_use(client);
  316.  if(client->adapter->inc_use != NULL)
  317.   client->adapter->inc_use(client->adapter);
  318. }
  319.  
  320. //----------------------------- i2c_dec_use_client -----------------------------
  321. void i2c_dec_use_client(struct i2c_client *client)
  322. {
  323.  if(client->driver->dec_use != NULL)
  324.   client->driver->dec_use(client);
  325.  if(client->adapter->dec_use != NULL)
  326.   client->adapter->dec_use(client->adapter);
  327. }
  328.  
  329. //-------------------------------- i2c_transfer --------------------------------
  330. int i2c_transfer(struct i2c_adapter *adap,struct i2c_msg msgs[],int num)
  331. {
  332.  int ret;
  333.  if(adap->algo->master_xfer)
  334.  {
  335.   DEB2(printk("i2ccore: master_xfer: %s with %d msgs.\n"
  336.               ,adap->name,num));
  337.   I2C_LOCK(adap);
  338.   ret=adap->algo->master_xfer(adap,msgs,num);
  339.   I2C_UNLOCK(adap);
  340.   return ret;
  341.  }
  342.  else
  343.  {
  344.   CPK(printk("i2ccore: I2C adapter %04x: I2C level transfers not supported\n"
  345.          ,adap->id));
  346.   return -ENOSYS;
  347.  }
  348. }
  349.  
  350. //------------------------------ i2c_master_send -------------------------------
  351. int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
  352. {
  353.  int ret;
  354.  struct i2c_adapter *adap=client->adapter;
  355.  struct i2c_msg msg;
  356.  if (client->adapter->algo->master_xfer)
  357.  {
  358.   msg.addr   = client->addr;
  359.   msg.flags = client->flags & I2C_M_TEN;
  360.   msg.len = count;
  361.   (const char *)msg.buf = buf;
  362.   CPK(printk("i2ccore: master_send: writing %d bytes on %s.\n",
  363.             count,client->adapter->name));
  364.   I2C_LOCK(adap);
  365.   ret = adap->algo->master_xfer(adap,&msg,1);
  366.   I2C_UNLOCK(adap);
  367.   // if everything went ok (i.e. 1 msg transmitted), return #bytes
  368.   // transmitted, else error code.
  369.   return (ret == 1 )? count : ret;
  370.  }
  371.  else
  372.  {
  373.   CPK(printk("i2ccore: I2C adapter %04x: I2C level transfers not supported\n",
  374.              client->adapter->id));
  375.         return -ENOSYS;
  376.     }
  377. }
  378. //------------------------------ i2c_master_recv -------------------------------
  379. int i2c_master_recv(struct i2c_client *client,char *buf,int count)
  380. {
  381.  struct i2c_adapter *adap=client->adapter;
  382.  struct i2c_msg msg;
  383.  int ret;
  384.  if(client->adapter->algo->master_xfer)
  385.  {
  386.   msg.addr   = client->addr;
  387.   msg.flags = client->flags & I2C_M_TEN;
  388.   msg.flags |= I2C_M_RD;
  389.   msg.len = count;
  390.   msg.buf = buf;
  391.   CPK(printk("i2ccore: master_recv: reading %d bytes on %s.\n",
  392.             count,client->adapter->name));
  393.   I2C_LOCK(adap);
  394.   ret = adap->algo->master_xfer(adap,&msg,1);
  395.   I2C_UNLOCK(adap);
  396.   CPK(printk("i2ccore: master_recv: return:%d (count:%d, addr:0x%02x)\n",
  397.          ret, count, client->addr));
  398.   // if everything went ok (i.e. 1 msg transmitted), return #bytes
  399.   // transmitted, else error code.
  400.   return (ret == 1 )? count : ret;
  401.  }
  402.  else
  403.  {
  404.   CPK(printk("i2ccore: I2C adapter %04x: I2C level transfers not supported\n",
  405.          client->adapter->id));
  406.   return -ENOSYS;
  407.  }
  408. }
  409.  
  410. //--------------------------------- i2c_probe ----------------------------------
  411. int i2c_probe(struct i2c_adapter *adapter,
  412.                    struct i2c_client_address_data *address_data,
  413.                    i2c_client_found_addr_proc *found_proc)
  414. {
  415.  int addr,i,found,err;
  416.  int adap_id = i2c_adapter_id(adapter);
  417.  // Forget it if we can't probe using SMBUS_QUICK
  418.  if(!i2c_check_functionality(adapter,I2C_FUNC_SMBUS_QUICK))
  419.   return -1;
  420.  for(addr = 0x00; addr <= 0x7f; addr++)
  421.  { // Skip if already in use */
  422.   if(i2c_check_addr(adapter,addr))
  423.    continue;
  424.   // If it is in one of the force entries, we don't do any detection at all
  425.   found = 0;
  426.   for(i = 0; !found && (address_data->force[i] != I2C_CLIENT_END); i += 3)
  427.   {
  428.    if(((adap_id == address_data->force[i]) ||
  429.               (address_data->force[i] == ANY_I2C_BUS)) &&
  430.                  (addr == address_data->force[i+1]))
  431.    {
  432.     DEB2(printk("i2c-core.o: found force parameter for adapter %d, addr %04x\n"
  433.                 ,adap_id,addr));
  434.     if((err = found_proc(adapter,addr,0,0)))
  435.      return err;
  436.     found = 1;
  437.    }
  438.   }
  439.   if(found)
  440.    continue;
  441.   // If this address is in one of the ignores, we can forget about it right now
  442.   for (i = 0;!found && (address_data->ignore[i] != I2C_CLIENT_END); i += 2)
  443.   {
  444.    if(((adap_id == address_data->ignore[i]) ||
  445.              ((address_data->ignore[i] == ANY_I2C_BUS))) &&
  446.              (addr == address_data->ignore[i+1]))
  447.    {
  448.     DEB2(printk("i2c-core.o: found ignore parameter for adapter %d, addr %04x\n"
  449.          ,adap_id ,addr));
  450.     found = 1;
  451.    }
  452.   }
  453.   for(i = 0;!found && (address_data->ignore_range[i] != I2C_CLIENT_END);i += 3)
  454.   {
  455.    if(((adap_id == address_data->ignore_range[i]) ||
  456.              ((address_data->ignore_range[i]==ANY_I2C_BUS))) &&
  457.              (addr >= address_data->ignore_range[i+1]) &&
  458.              (addr <= address_data->ignore_range[i+2]))
  459.    {
  460.     DEB2(printk("i2c-core.o: found ignore_range parameter for adapter %d, addr %04x\n"
  461.                 , adap_id,addr));
  462.     found = 1;
  463.    }
  464.   }
  465.   if(found)
  466.    continue;
  467.   // Now, we will do a detection, but only if it is in the normal or probe entries
  468.   for(i = 0;!found && (address_data->normal_i2c[i] != I2C_CLIENT_END);i += 1)
  469.   {
  470.    if(addr == address_data->normal_i2c[i])
  471.    {
  472.     found = 1;
  473.     DEB2(printk("i2c-core.o: found normal i2c entry for adapter %d, addr %02x"
  474.                 , adap_id,addr));
  475.    }
  476.   }
  477.   for(i = 0;!found && (address_data->normal_i2c_range[i] != I2C_CLIENT_END);i+=2)
  478.   {
  479.    if((addr >= address_data->normal_i2c_range[i]) &&
  480.       (addr <= address_data->normal_i2c_range[i+1]))
  481.    {
  482.     found = 1;
  483.     DEB2(printk("i2c-core.o: found normal i2c_range entry for adapter %d, addr %04x\n"
  484.                 , adap_id,addr));
  485.    }
  486.   }
  487.   for(i = 0;!found && (address_data->probe[i] != I2C_CLIENT_END);i += 2)
  488.   {
  489.    if(((adap_id == address_data->probe[i]) ||
  490.       ((address_data->probe[i] == ANY_I2C_BUS))) &&
  491.        (addr == address_data->probe[i+1]))
  492.    {
  493.     found = 1;
  494.     DEB2(printk("i2c-core.o: found probe parameter for adapter %d, addr %04x\n"
  495.                 , adap_id,addr));
  496.    }
  497.   }
  498.   for(i = 0;!found && (address_data->probe_range[i] != I2C_CLIENT_END);i += 3)
  499.   {
  500.    if(((adap_id == address_data->probe_range[i]) ||
  501.        (address_data->probe_range[i] == ANY_I2C_BUS)) &&
  502.       (addr >= address_data->probe_range[i+1]) &&
  503.       (addr <= address_data->probe_range[i+2]))
  504.    {
  505.     found = 1;
  506.     DEB2(printk("i2c-core.o: found probe_range parameter for adapter %d, addr %04x\n"
  507.                 , adap_id,addr));
  508.    }
  509.   }
  510.   if(!found)
  511.    continue;
  512.   // OK, so we really should examine this address. First check whether there is some client here at all!
  513.   if(i2c_smbus_xfer(adapter,addr,0,0,0,I2C_SMBUS_QUICK,NULL) >= 0)
  514.    if((err = found_proc(adapter,addr,0,-1)))
  515.     return err;
  516.  }
  517.  return 0;
  518. }
  519.  
  520. //------------------------------- i2c_adapter_id -------------------------------
  521. int i2c_adapter_id(struct i2c_adapter *adap)
  522. {
  523.  int i;
  524.  for(i=0;i<I2C_ADAP_MAX;i++)
  525.   if(adap==adapters[i])
  526.    return i;
  527.  return -1;
  528. }
  529.  
  530. //--------------------------- i2c_smbus_xfer_emulate ---------------------------
  531. // Simulate a SMBus command using the i2c protocol No checking of parameters is done!
  532. static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
  533.                                    unsigned short flags,
  534.                                    char read_write, u8 command, int size,
  535.                                    union i2c_smbus_data * data)
  536. {
  537.  // So we need to generate a series of msgs. In the case of writing, we need to
  538.  // use only one message; when reading, we need two. We initialize most things
  539.  // with sane defaults, to keep the code below somewhat simpler.
  540.  unsigned char msgbuf0[34];
  541.  unsigned char msgbuf1[34];
  542.  int num = read_write == I2C_SMBUS_READ?2:1;
  543.  int i;
  544.  struct i2c_msg msg[2];
  545.  msg[0].addr=addr;
  546.  msg[0].flags=flags;
  547.  msg[0].len=1;
  548.  msg[0].buf=msgbuf0;
  549.  msg[1].addr=addr;
  550.  msg[1].flags=flags | I2C_M_RD;
  551.  msg[1].len=0;
  552.  msg[1].buf=msgbuf1;
  553.  msgbuf0[0] = command;
  554.  switch(size)
  555.  {
  556.   case I2C_SMBUS_QUICK:
  557.    msg[0].len = 0;
  558.     // Special case: The read/write field is used as data
  559.    msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
  560.    num = 1;
  561.    break;
  562.   case I2C_SMBUS_BYTE:
  563.    if(read_write == I2C_SMBUS_READ)
  564.    { // Special case: only a read!
  565.     msg[0].flags = I2C_M_RD | flags;
  566.     num = 1;
  567.    }
  568.    break;
  569.   case I2C_SMBUS_BYTE_DATA:
  570.    if(read_write == I2C_SMBUS_READ)
  571.     msg[1].len = 1;
  572.    else
  573.    {
  574.     msg[0].len = 2;
  575.     msgbuf0[1] = data->byte;
  576.    }
  577.    break;
  578.   case I2C_SMBUS_WORD_DATA:
  579.    if(read_write == I2C_SMBUS_READ)
  580.     msg[1].len = 2;
  581.    else
  582.    {
  583.     msg[0].len=3;
  584.     msgbuf0[1] = data->word & 0xff;
  585.     msgbuf0[2] = (data->word >> 8) & 0xff;
  586.    }
  587.    break;
  588.   case I2C_SMBUS_PROC_CALL:
  589.    num = 2; /* Special case */
  590.    msg[0].len = 3;
  591.    msg[1].len = 2;
  592.    msgbuf0[1] = data->word & 0xff;
  593.    msgbuf0[2] = (data->word >> 8) & 0xff;
  594.    break;
  595.   case I2C_SMBUS_BLOCK_DATA:
  596.    if(read_write == I2C_SMBUS_READ)
  597.    {
  598.     CPK(printk("i2c-core.o: Block read not supported under I2C emulation!\n"));
  599.     return -1;
  600.    }
  601.    else
  602.    {
  603.     msg[0].len = data->block[0] + 2;
  604.     if(msg[0].len > 34)
  605.     {
  606.      CPK(printk("i2c-core.o: smbus_access called with invalid block write size (%d)\n",
  607.              msg[0].len));
  608.      return -1;
  609.     }
  610.     for(i = 1; i <= msg[0].len; i++)
  611.      msgbuf0[i] = data->block[i-1];
  612.    }
  613.    break;
  614.   default:
  615.    CPK(printk("i2c-core.o: smbus_access called with invalid size (%d)\n",size));
  616.    return -1;
  617.  }
  618.  if(i2c_transfer(adapter, msg, num) < 0)
  619.   return -1;
  620.  if(read_write == I2C_SMBUS_READ)
  621.  switch(size)
  622.  {
  623.   case I2C_SMBUS_BYTE:
  624.    data->byte = msgbuf0[0];
  625.    break;
  626.   case I2C_SMBUS_BYTE_DATA:
  627.    data->byte = msgbuf1[0];
  628.    break;
  629.   case I2C_SMBUS_WORD_DATA:
  630.   case I2C_SMBUS_PROC_CALL:
  631.    data->word = msgbuf1[0] | (msgbuf1[1] << 8);
  632.    break;
  633.  }
  634.  return 0;
  635. }
  636.  
  637. //------------------------------- i2c_smbus_xfer -------------------------------
  638. s32 i2c_smbus_xfer(struct i2c_adapter *adapter,u16 addr
  639.                    ,unsigned short flags
  640.                    ,char read_write,u8 command,int size
  641.                    ,union i2c_smbus_data *data)
  642. {
  643.  s32 res;
  644.  flags=flags&I2C_M_TEN;
  645.  if(adapter->algo->smbus_xfer)
  646.  {
  647.   I2C_LOCK(adapter);
  648.   res=adapter->algo->smbus_xfer(adapter,addr,flags,read_write,command,size,data);
  649.   I2C_UNLOCK(adapter);
  650.  }
  651.  else
  652.   res=i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,command,size,data);
  653.  return res;
  654. }
  655.  
  656. //--------------------------- i2c_get_functionality ----------------------------
  657. // You should always define 'functionality'; the 'else' is just for
  658. // backward compatibility.
  659. u32 i2c_get_functionality(struct i2c_adapter *adap)
  660. {
  661.  if(adap->algo->functionality)
  662.   return adap->algo->functionality(adap);
  663.  else
  664.   return 0xffffffff;
  665. }
  666.  
  667. //-------------------------- i2c_check_functionality ---------------------------
  668. int i2c_check_functionality(struct i2c_adapter *adap,u32 func)
  669. {
  670.  u32 adap_func=i2c_get_functionality(adap);
  671.  return (func & adap_func)==func;
  672. }
  673.  
  674. //---------------------------------- i2c_init ----------------------------------
  675. int __init i2c_init(void)
  676. {
  677.  CPK(printk("i2ccore: i2c core module\n"));
  678.  memset(adapters,0,sizeof(adapters));
  679.  memset(drivers,0,sizeof(drivers));
  680.  adap_count=0;
  681.  driver_count=0;
  682.  init_MUTEX(&adap_lock);
  683.  init_MUTEX(&driver_lock);
  684.  return 0;
  685. }
  686.  
  687.