写了一个pca9633的iic驱动

----------------------------------------------------------------------------------------

#include <linux/module.h>

#include <linux/delay.h>

#include <linux/string.h>

#include <linux/ctype.h>

#include <linux/leds.h>

#include <linux/err.h>

#include <linux/i2c.h>

#include <linux/workqueue.h>

#include <linux/slab.h>

#include <linux/device.h>

#include <linux/types.h>

#define PCA9633_LED0            0

#define PCA9633_LED1            1

#define PCA9633_LED2            2

#define PCA9633_LED3            3

#define PCA9633_LED_OFF         0x0    

#define PCA9633_LED_ON          0x1  

#define PCA9633_LED_PWM         0x2  

#define PCA9633_LED_GRP_PWM     0x3  

#define PCA9633_MODE1           0x00

#define PCA9633_MODE2           0x01

#define PCA9633_PWM_BASE        0x02

#define PCA9633_LEDOUT          0x08

static struct class *__g_pca9633_class = NULL;

static struct i2c_client *__g_i2c_client = NULL;

static const struct i2c_device_id pca9633_id[] = {

        {"pca9633",0},

        {}

};

MODULE_DEVICE_TABLE(i2c, pca9633_id);

void pca9633_control_brightness(int brightness)

{

  int i,shift;

  u8  ledout,mask;

  for(i=0;i<4;i++)

  {

    ledout = i2c_smbus_read_byte_data(__g_i2c_client, PCA9633_LEDOUT);

        shift  = 2 * i;// led  num

        mask   = 0x3 << shift;

    if(brightness>255||brightness<0)

        brightness = 255;

        switch (brightness) {

        case 255:

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        (ledout & ~mask) | (PCA9633_LED_ON << shift));

                break;

        case 0:

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        ledout & ~mask);

                break;

        default:

                i2c_smbus_write_byte_data(__g_i2c_client,

                        PCA9633_PWM_BASE + i,

                        brightness);

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        (ledout & ~mask) | (PCA9633_LED_PWM << shift));

                break;

        }

  }

}

EXPORT_SYMBOL(pca9633_control_brightness);

static ssize_t pca9633_led0_brightness(struct class *cls,struct class_attribute *attr,

                         const char *_buf, size_t _count)

{

    int brightness= 0;

        u8  ledout = i2c_smbus_read_byte_data(__g_i2c_client, PCA9633_LEDOUT);

        int shift = 2 * PCA9633_LED0;// led  num

        u8  mask = 0x3 << shift;

    brightness =  simple_strtol(_buf, NULL, 10);

    if(brightness>255)

        brightness = 255;

        switch (brightness) {

        case 255:

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        (ledout & ~mask) | (PCA9633_LED_ON << shift));

                break;

        case 0:

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        ledout & ~mask);

                break;

        default:

                i2c_smbus_write_byte_data(__g_i2c_client,

                        PCA9633_PWM_BASE + PCA9633_LED0,

                        brightness);

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        (ledout & ~mask) | (PCA9633_LED_PWM << shift));

                break;

        }

    return _count;

}

static ssize_t pca9633_led1_brightness(struct class *cls,struct class_attribute *attr,

                         const char *_buf, size_t _count)

{

    int brightness= 0;

        u8  ledout = i2c_smbus_read_byte_data(__g_i2c_client, PCA9633_LEDOUT);

        int shift = 2 * PCA9633_LED1;// led  num

        u8  mask = 0x3 << shift;

    brightness =  simple_strtol(_buf, NULL, 10);

    if(brightness>255)

        brightness = 255;

        switch (brightness) {

        case 255:

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        (ledout & ~mask) | (PCA9633_LED_ON << shift));

                break;

        case 0:

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        ledout & ~mask);

                break;

        default:

                i2c_smbus_write_byte_data(__g_i2c_client,

                        PCA9633_PWM_BASE + PCA9633_LED1,

                        brightness);

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        (ledout & ~mask) | (PCA9633_LED_PWM << shift));

                break;

        }

    return _count;

}

static ssize_t pca9633_led2_brightness(struct class *cls,struct class_attribute *attr,

                         const char *_buf, size_t _count)

{

    int brightness= 0;

        u8  ledout = i2c_smbus_read_byte_data(__g_i2c_client, PCA9633_LEDOUT);

        int shift = 2 * PCA9633_LED2;// led  num

        u8  mask = 0x3 << shift;

    brightness =  simple_strtol(_buf, NULL, 10);

    if(brightness>255)

        brightness = 255;

        switch (brightness) {

        case 255:

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        (ledout & ~mask) | (PCA9633_LED_ON << shift));

                break;

        case 0:

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        ledout & ~mask);

                break;

        default:

                i2c_smbus_write_byte_data(__g_i2c_client,

                        PCA9633_PWM_BASE + PCA9633_LED2,

                        brightness);

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        (ledout & ~mask) | (PCA9633_LED_PWM << shift));

                break;

        }

    return _count;

}

static ssize_t pca9633_led3_brightness(struct class *cls,struct class_attribute *attr,

                         const char *_buf, size_t _count)

{

    int brightness= 0;

        u8  ledout = i2c_smbus_read_byte_data(__g_i2c_client, PCA9633_LEDOUT);

        int shift = 2 * PCA9633_LED3;// led  num

        u8  mask = 0x3 << shift;

    brightness =  simple_strtol(_buf, NULL, 10);

    if(brightness>255)

        brightness = 255;

        switch (brightness) {

        case 255:

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        (ledout & ~mask) | (PCA9633_LED_ON << shift));

                break;

        case 0:

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        ledout & ~mask);

                break;

        default:

                i2c_smbus_write_byte_data(__g_i2c_client,

                        PCA9633_PWM_BASE + PCA9633_LED3,

                        brightness);

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                        (ledout & ~mask) | (PCA9633_LED_PWM << shift));

                break;

        }

    return _count;

}

static CLASS_ATTR(led0_brightness,0666,NULL,pca9633_led0_brightness);

static CLASS_ATTR(led1_brightness,0666,NULL,pca9633_led1_brightness);

static CLASS_ATTR(led2_brightness,0666,NULL,pca9633_led2_brightness);

static CLASS_ATTR(led3_brightness,0666,NULL,pca9633_led3_brightness);

static int pca9633_probe(struct i2c_client *client,

                 const struct i2c_device_id *id)

{

    int err = 0;

    u8  ledout = 0;

    int i = 0;

    __g_i2c_client = client;

    __g_pca9633_class = class_create(THIS_MODULE,"pca9633");

        if(NULL==__g_pca9633_class)

        return -ENOMEM;

    device_create(__g_pca9633_class,NULL,0,NULL,"pca9633");

    err = class_create_file(__g_pca9633_class,&class_attr_led0_brightness);

        err = class_create_file(__g_pca9633_class,&class_attr_led1_brightness);

        err = class_create_file(__g_pca9633_class,&class_attr_led2_brightness);

        err = class_create_file(__g_pca9633_class,&class_attr_led3_brightness);

    if(err<0)

    return err;

        /* Disable LED all-call address and set normal mode */

        i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_MODE1, 0x00);

        /* Turn off LEDs */

        i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT, 0x00);

        for(i=0;i<4;i++)

        {

            ledout = i2c_smbus_read_byte_data(__g_i2c_client, PCA9633_LEDOUT);

                i2c_smbus_write_byte_data(__g_i2c_client, PCA9633_LEDOUT,

                                        (ledout & ~(0x3<<(2*i))) | (PCA9633_LED_ON << (2*i)));

        }

        return err;

}

static int pca9633_remove(struct i2c_client *client)

{

    class_remove_file(__g_pca9633_class,&class_attr_led0_brightness);

        class_remove_file(__g_pca9633_class,&class_attr_led1_brightness);

        class_remove_file(__g_pca9633_class,&class_attr_led2_brightness);

        class_remove_file(__g_pca9633_class,&class_attr_led3_brightness);

    device_destroy(__g_pca9633_class,0);

    class_destroy(__g_pca9633_class);

        __g_pca9633_class = NULL;

        __g_i2c_client = NULL;

        return 0;

}

static struct i2c_driver pca9633_driver = {

        .driver = {

                .name   = "leds-pca9633",

                .owner  = THIS_MODULE,

        },

        .probe  = pca9633_probe,

        .remove = pca9633_remove,

        .id_table = pca9633_id,

};

//module_i2c_driver(pca9633_driver);

static int __init pca9633_driver_init(void)

{

   return i2c_add_driver(&pca9633_driver);

}

static void __exit pca9633_driver_exit(void)

{

    i2c_del_driver(&pca9633_driver);

}

fs_initcall(pca9633_driver_init);

module_exit(pca9633_driver_exit);

MODULE_AUTHOR("Poco ");

MODULE_DESCRIPTION("PCA9633 LED driver");

MODULE_LICENSE("GPL v2");

--------------------------------------------------------------------------------

&i2c2 {

        status = "okay";

pca9633: pca9633 {

        compatible = "nxp,pca9633";

        #address-cells = <1>;

        #size-cells = <0>;

        reg = <0x62>;

};

----------------------------------------------------------------------------------

可以用的，compatible 弱匹配pca9633