i2c slave设备读写没有ack返回

static struct imxi2c_platform_data mxci2c_data = {

       .bitrate = 20000,

};



static struct tca8424_keypad_platform_data tca8424_date = {

        .keymap_data = &tca8424_mkdata,

        .rows=16,

        .cols=8,

        .rep=1,

        .irq_is_gpio=1,

};



static struct i2c_board_info mxc_i2c2_board_info[] __initdata = {

        {

                I2C_BOARD_INFO("rtc-pcf8563", 0x51),

                .type = "pcf8563"

        },

        {

        I2C_BOARD_INFO("tca8424_keypad", 0x3b),

        .type = "tca8424_keypad" ,

        .irq  = MX53_TCA6416_IRQ,

        .platform_data = &tca8424_date

    },

};

static int tca8424_keypad_probe(struct i2c_client *client,

                                          const struct i2c_device_id *id)

{

         struct device *dev = &client->dev;

         const struct tca8424_keypad_platform_data *pdata =

                                                 dev_get_platdata(dev);

         struct tca8424_keypad *keypad_data;

         struct input_dev *input;

         const struct matrix_keymap_data *keymap_data = NULL;

         u32 rows = 0, cols = 0;

         bool rep = false;

         bool irq_is_gpio = false;

         int irq;

         int error, row_shift, max_keys;



#if 1

        /* Copy the platform data */

        if (pdata) {

                if (!pdata->keymap_data) {

                        dev_err(dev, "no keymap data defined\n");

                        return -EINVAL;

                }

                keymap_data = pdata->keymap_data;

                rows = pdata->rows;

                cols = pdata->cols;

                rep  = pdata->rep;

                irq_is_gpio = pdata->irq_is_gpio;

        }/* else {

                struct device_node *np = dev->of_node;

                int err;



                err = matrix_keypad_parse_of_params(dev, &rows, &cols);

                if (err)

                        return err;

                rep = of_property_read_bool(np, "keypad,autorepeat");

        }*/



        if (!rows || rows > TCA8424_MAX_ROWS) {

                dev_err(dev, "invalid rows\n");

                return -EINVAL;

        }



        if (!cols || cols > TCA8424_MAX_COLS) {

                dev_err(dev, "invalid columns\n");

                return -EINVAL;

        }



        /* Check i2c driver capabilities */

        if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {

                dev_err(dev, "%s adapter not supported\n",

                        dev_driver_string(&client->adapter->dev));

                return -ENODEV;

        }



        row_shift = get_count_order(cols);

        max_keys = rows << row_shift;



        /* Allocate memory for keypad_data and input device */

        keypad_data = devm_kzalloc(dev, sizeof(*keypad_data), GFP_KERNEL);

        if (!keypad_data)

                return -ENOMEM;



        keypad_data->client = client;

        keypad_data->row_shift = row_shift;

//        printk("^^^^^^^^^^^\n",keypad_data->);



        i2c_set_clientdata(client, keypad_data);



        /* Initialize the chip or fail if chip isn't present */

        error = tca8424_configure(keypad_data, rows, cols);

        if (error < 0)

                return error;

#endif

        /* Configure input device 

        input = devm_input_allocate_device(dev);

        if (!input)

                return -ENOMEM;*/



        keypad_data->input = input;

        input = input_allocate_device();

        if (!input) {

                error = -ENOMEM;

                return error;

        }

        printk("2-----row = %d,cols = %d\n",rows,cols);





        input->phys = "tca8424-keys/input0";

        input->name = client->name;

        input->id.bustype = BUS_I2C;

        input->id.vendor  = 0x0001;

        input->id.product = 0x0001;

        input->id.version = 0x0001;



        input->keycode = keymap_data->keymap;

        printk("3----------%d,keymap[0]=%d | %d\n",keymap_data->keymap_size,keymap_data->keymap[1],KEY(0, 6, KEY_RESERVED));



        matrix_keypad_build_keymap(keymap_data, row_shift, input->keycode, input->keybit);

        if (!input->keybit) {

                dev_err(dev, "Failed to build keymap\n");

                return error;

        }

        

        if (rep)

                __set_bit(EV_REP, input->evbit);

        input_set_capability(input, EV_MSC, MSC_SCAN);



        input_set_drvdata(input, keypad_data);



        irq = client->irq;

        if (irq_is_gpio)

                irq = gpio_to_irq(irq);



        printk("5----------%d,%d\n",irq,!tca8424_irq_handler);

        error = devm_request_threaded_irq(dev, irq, NULL, tca8424_irq_handler,

                                          IRQF_TRIGGER_FALLING |

//                                                IRQF_SHARED |

                                                IRQF_ONESHOT,

                                          client->name, keypad_data);

        if (error) {

                dev_err(dev, "Unable to claim irq %d; error %d\n",

                        client->irq, error);

                return error;

        }



        error = input_register_device(input);

        if (error) {

                dev_err(dev, "Unable to register input device, error: %d\n",

                        error);

                return error;

        }

        printk("[TCA8424] tca8424_keypad_probe.\n");

        return 0;

}