与Linux中没有微控制器的I2C设备进行通讯

Question

If I do not want to use Raspberry or Arduino, how can I get access to a I2C bus to talk to a device. I see a lot of examples for raspberry and lots for Arduino but none of them use the code that is shown below. The code below probes and uses struct i2c_driver . The code also initializes in kernel with module_init :

#include <linux/module.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/i2c.h>
#include <linux/i2c-id.h>
#include <linux/videodev2.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/log2.h>

#include <media/v4l2-ioctl.h>
#include <media/v4l2-device.h>
#include <media/v4l2-chip-ident.h>
#include <media/v4l2-subdev.h>
#include <media/soc_camera.h>

#include "adv7403_regs.h"

#define DRIVER_NAME "adv7403"

struct adv7403_state {
          struct v4l2_subdev subdev;
};

static __devinit int adv7403_probe(struct i2c_client *client,
                              const struct i2c_device_id *id)
{
          struct adv7403_state *state;
          int ret;

          /* Check if the adapter supports the needed features */
          if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                    return -EIO;

          v4l_info(client, "chip found @ 0x%02x (%s)\n",
                              client->addr << 1, client->adapter->name);

          state = kzalloc(sizeof(struct adv7403_state), GFP_KERNEL);
          if (state == NULL) {
                    ret = -ENOMEM;
                    goto err;
          }
        else{
                    printk(KERN_ERR DRIVER_NAME ": Detected %d\n");
          }

err:
          printk(KERN_ERR DRIVER_NAME ": Failed to probe: %d\n", ret);
          return ret;
}


static __devexit int adv7403_remove(struct i2c_client *client)
{
          struct v4l2_subdev *sd = i2c_get_clientdata(client);

          v4l2_device_unregister_subdev(sd);
          return 0;
}

static const struct i2c_device_id adv7403_id[] = {
          {DRIVER_NAME, 0},
          {},
};

MODULE_DEVICE_TABLE(i2c, adv7403_id);

static struct i2c_driver adv7403_driver = {
          .driver = {
                    .owner          = THIS_MODULE,
                    .name          = DRIVER_NAME,
          },
        .probe                    = adv7403_probe,
        .remove                    = adv7403_remove,
          .id_table          = adv7403_id
};

static int __init adv7403_mod_init(void)
{
          printk(" ADV7403 Video Decoder Device Driver inserted to kernel \n");
          return i2c_add_driver(&adv7403_driver);
}

static void __exit adv7403_mod_exit(void)
{
        printk(" ADV7403 Video Decoder Device Driver removed from kernel \n");
          i2c_del_driver(&adv7403_driver);
}

module_init(adv7403_mod_init);
module_exit(adv7403_mod_exit);

Answer 1

There is (apparently) a way to use python and either a serial port (through optoisolators) or a parallel port to form a I2C bus pyi2c

I have no idea if the library works - however I think it satisfies the requirement. Every linux host has at least a serial port.

If there are only USB ports, there are USB-I2C/SPI/UART bridges made by FTDI and Silicon Labs that have driver support in recent kernels. You can always add I2C or SPI support later with this strategy.

Answer 2

You have to have registered I2C bus driver first to talk to the I2C clients.

This is not a bus (adapter) driver but a chip (client) driver. Which when registered just calls a probe() function which checks if I2C client is present.

There is no other functionality in this driver eg callbacks registered with the kernel I2C layer, which are used to access HW registers on the chip, so what is the purpose of this driver?