v4l2 adv7180视频解码驱动求助

求助大家，adv7180视频解码驱动问题，
[root@jeff/]#insmod adv7180.ko
adv7180 0-0040: chip found @ 0x80 (s3c2410-i2c)
adv7180: Failed to probe: -6

1. /*
   
2. * adv7180.c Analog Devices ADV7180 video decoder driver
   
3. * Copyright (c) 2009 Intel Corporation
   
4. */
   
5. #include <linux/module.h>
   
6. #include <linux/init.h>
   
7. #include <linux/errno.h>
   
8. #include <linux/kernel.h>
   
9. #include <linux/interrupt.h>
   
10. #include <linux/i2c.h>
    
11. #include <linux/slab.h>
    
12. #include <media/v4l2-ioctl.h>
    
13. #include <linux/videodev2.h>
    
14. #include <media/v4l2-device.h>
    
15. #include <media/v4l2-chip-ident.h>
    
16. #include <linux/mutex.h>
    
17. 
    
18. #define DRIVER_NAME "adv7180"
    
19. 
    
20. struct adv7180_state {
    
21.         struct v4l2_subdev        sd;
    
22.         struct work_struct        work;
    
23.         struct mutex                mutex; /* mutual excl. when accessing chip */
    
24.         int                        irq;
    
25.         v4l2_std_id                curr_norm;
    
26.         bool                        autodetect;
    
27. };
    
28. 
    
29. static v4l2_std_id adv7180_std_to_v4l2(u8 status1)
    
30. {
    
31.         switch (status1 & ADV7180_STATUS1_AUTOD_MASK) {
    
32.         case ADV7180_STATUS1_AUTOD_NTSM_M_J:
    
33.                 return V4L2_STD_NTSC;
    
34.         case ADV7180_STATUS1_AUTOD_NTSC_4_43:
    
35.                 return V4L2_STD_NTSC_443;
    
36.         case ADV7180_STATUS1_AUTOD_PAL_M:
    
37.                 return V4L2_STD_PAL_M;
    
38.         case ADV7180_STATUS1_AUTOD_PAL_60:
    
39.                 return V4L2_STD_PAL_60;
    
40.         case ADV7180_STATUS1_AUTOD_PAL_B_G:
    
41.                 return V4L2_STD_PAL;
    
42.         case ADV7180_STATUS1_AUTOD_SECAM:
    
43.                 return V4L2_STD_SECAM;
    
44.         case ADV7180_STATUS1_AUTOD_PAL_COMB:
    
45.                 return V4L2_STD_PAL_Nc | V4L2_STD_PAL_N;
    
46.         case ADV7180_STATUS1_AUTOD_SECAM_525:
    
47.                 return V4L2_STD_SECAM;
    
48.         default:
    
49.                 return V4L2_STD_UNKNOWN;
    
50.         }
    
51. }
    
52. 
    
53. static int v4l2_std_to_adv7180(v4l2_std_id std)
    
54. {
    
55.         if (std == V4L2_STD_PAL_60)
    
56.                 return ADV7180_INPUT_CONTROL_PAL60;
    
57.         if (std == V4L2_STD_NTSC_443)
    
58.                 return ADV7180_INPUT_CONTROL_NTSC_443;
    
59.         if (std == V4L2_STD_PAL_N)
    
60.                 return ADV7180_INPUT_CONTROL_PAL_N;
    
61.         if (std == V4L2_STD_PAL_M)
    
62.                 return ADV7180_INPUT_CONTROL_PAL_M;
    
63.         if (std == V4L2_STD_PAL_Nc)
    
64.                 return ADV7180_INPUT_CONTROL_PAL_COMB_N;
    
65. 
    
66.         if (std & V4L2_STD_PAL)
    
67.                 return ADV7180_INPUT_CONTROL_PAL_BG;
    
68.         if (std & V4L2_STD_NTSC)
    
69.                 return ADV7180_INPUT_CONTROL_NTSC_M;
    
70.         if (std & V4L2_STD_SECAM)
    
71.                 return ADV7180_INPUT_CONTROL_PAL_SECAM;
    
72. 
    
73.         return -EINVAL;
    
74. }
    
75. 
    
76. static u32 adv7180_status_to_v4l2(u8 status1)
    
77. {
    
78.         if (!(status1 & ADV7180_STATUS1_IN_LOCK))
    
79.                 return V4L2_IN_ST_NO_SIGNAL;
    
80. 
    
81.         return 0;
    
82. }
    
83. 
    
84. static int __adv7180_status(struct i2c_client *client, u32 *status,
    
85.         v4l2_std_id *std)
    
86. {
    
87.         int status1 = i2c_smbus_read_byte_data(client, ADV7180_STATUS1_REG);
    
88. 
    
89.         if (status1 < 0)
    
90.                 return status1;
    
91. 
    
92.         if (status)
    
93.                 *status = adv7180_status_to_v4l2(status1);
    
94.         if (std)
    
95.                 *std = adv7180_std_to_v4l2(status1);
    
96. 
    
97.         return 0;
    
98. }
    
99. 
    
100. static inline struct adv7180_state *to_state(struct v4l2_subdev *sd)
     
101. {
     
102.         return container_of(sd, struct adv7180_state, sd);
     
103. }
     
104. 
     
105. static int adv7180_querystd(struct v4l2_subdev *sd, v4l2_std_id *std)
     
106. {
     
107.         struct adv7180_state *state = to_state(sd);
     
108.         int err = mutex_lock_interruptible(&state->mutex);
     
109.         if (err)
     
110.                 return err;
     
111. 
     
112.         /* when we are interrupt driven we know the state */
     
113.         if (!state->autodetect || state->irq > 0)
     
114.                 *std = state->curr_norm;
     
115.         else
     
116.                 err = __adv7180_status(v4l2_get_subdevdata(sd), NULL, std);
     
117. 
     
118.         mutex_unlock(&state->mutex);
     
119.         return err;
     
120. }
     
121. 
     
122. static int adv7180_g_input_status(struct v4l2_subdev *sd, u32 *status)
     
123. {
     
124.         struct adv7180_state *state = to_state(sd);
     
125.         int ret = mutex_lock_interruptible(&state->mutex);
     
126.         if (ret)
     
127.                 return ret;
     
128. 
     
129.         ret = __adv7180_status(v4l2_get_subdevdata(sd), status, NULL);
     
130.         mutex_unlock(&state->mutex);
     
131.         return ret;
     
132. }
     
133. 
     
134. static int adv7180_g_chip_ident(struct v4l2_subdev *sd,
     
135.         struct v4l2_dbg_chip_ident *chip)
     
136. {
     
137.         struct i2c_client *client = v4l2_get_subdevdata(sd);
     
138. 
     
139.         return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_ADV7180, 0);
     
140. }
     
141. 
     
142. static int adv7180_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
     
143. {
     
144.         struct adv7180_state *state = to_state(sd);
     
145.         struct i2c_client *client = v4l2_get_subdevdata(sd);
     
146.         int ret = mutex_lock_interruptible(&state->mutex);
     
147.         if (ret)
     
148.                 return ret;
     
149. 
     
150.         /* all standards -> autodetect */
     
151.         if (std == V4L2_STD_ALL) {
     
152.                 ret = i2c_smbus_write_byte_data(client,
     
153.                         ADV7180_INPUT_CONTROL_REG,
     
154.                         ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM);
     
155.                 if (ret < 0)
     
156.                         goto out;
     
157. 
     
158.                 __adv7180_status(client, NULL, &state->curr_norm);
     
159.                 state->autodetect = true;
     
160.         } else {
     
161.                 ret = v4l2_std_to_adv7180(std);
     
162.                 if (ret < 0)
     
163.                         goto out;
     
164. 
     
165.                 ret = i2c_smbus_write_byte_data(client,
     
166.                         ADV7180_INPUT_CONTROL_REG, ret);
     
167.                 if (ret < 0)
     
168.                         goto out;
     
169. 
     
170.                 state->curr_norm = std;
     
171.                 state->autodetect = false;
     
172.         }
     
173.         ret = 0;
     
174. out:
     
175.         mutex_unlock(&state->mutex);
     
176.         return ret;
     
177. }
     
178. 
     
179. static const struct v4l2_subdev_video_ops adv7180_video_ops = {
     
180.         .querystd = adv7180_querystd,
     
181.         .g_input_status = adv7180_g_input_status,
     
182. };
     
183. 
     
184. static const struct v4l2_subdev_core_ops adv7180_core_ops = {
     
185.         .g_chip_ident = adv7180_g_chip_ident,
     
186.         .s_std = adv7180_s_std,
     
187. };
     
188. 
     
189. static const struct v4l2_subdev_ops adv7180_ops = {
     
190.         .core = &adv7180_core_ops,
     
191.         .video = &adv7180_video_ops,
     
192. };
     
193. 
     
194. static void adv7180_work(struct work_struct *work)
     
195. {
     
196.         struct adv7180_state *state = container_of(work, struct adv7180_state,
     
197.                 work);
     
198.         struct i2c_client *client = v4l2_get_subdevdata(&state->sd);
     
199.         u8 isr3;
     
200. 
     
201.         mutex_lock(&state->mutex);
     
202.         i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG,
     
203.                 ADV7180_ADI_CTRL_IRQ_SPACE);
     
204.         isr3 = i2c_smbus_read_byte_data(client, ADV7180_ISR3_ADI);
     
205.         /* clear */
     
206.         i2c_smbus_write_byte_data(client, ADV7180_ICR3_ADI, isr3);
     
207.         i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, 0);
     
208. 
     
209.         if (isr3 & ADV7180_IRQ3_AD_CHANGE && state->autodetect)
     
210.                 __adv7180_status(client, NULL, &state->curr_norm);
     
211.         mutex_unlock(&state->mutex);
     
212. 
     
213.         enable_irq(state->irq);
     
214. }
     
215. 
     
216. static irqreturn_t adv7180_irq(int irq, void *devid)
     
217. {
     
218.         struct adv7180_state *state = devid;
     
219. 
     
220.         schedule_work(&state->work);
     
221. 
     
222.         disable_irq_nosync(state->irq);
     
223. 
     
224.         return IRQ_HANDLED;
     
225. }
     
226. 
     
227. /*
     
228. * Generic i2c probe
     
229. * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
     
230. */
     
231. 
     
232. static __devinit int adv7180_probe(struct i2c_client *client,
     
233.                         const struct i2c_device_id *id)
     
234. {
     
235.         struct adv7180_state *state;
     
236.         struct v4l2_subdev *sd;
     
237.         int ret;
     
238. 
     
239.         /* Check if the adapter supports the needed features */
     
240.         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
     
241.                 return -EIO;
     
242. 
     
243.         v4l_info(client, "chip found @ 0x%02x (%s)\n",
     
244.                         client->addr << 1, client->adapter->name);
     
245. 
     
246.         state = kzalloc(sizeof(struct adv7180_state), GFP_KERNEL);
     
247.         if (state == NULL) {
     
248.                 ret = -ENOMEM;
     
249.                 goto err;
     
250.         }
     
251. 
     
252.         state->irq = client->irq;
     
253.         INIT_WORK(&state->work, adv7180_work);
     
254.         mutex_init(&state->mutex);
     
255.         state->autodetect = true;
     
256.         sd = &state->sd;
     
257.         v4l2_i2c_subdev_init(sd, client, &adv7180_ops);
     
258. 
     
259.         /* Initialize adv7180 */
     
260.         /* Enable autodetection */
     
261.         ret = i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG,
     
262.                 ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM);
     
263.         if (ret < 0)
     
264.                 goto err_unreg_subdev;
     
265. 
     
266.         ret = i2c_smbus_write_byte_data(client, ADV7180_AUTODETECT_ENABLE_REG,
     
267.                 ADV7180_AUTODETECT_DEFAULT);
     
268.         if (ret < 0)
     
269.                 goto err_unreg_subdev;
     
270. 
     
271.         /* ITU-R BT.656-4 compatible */
     
272.         ret = i2c_smbus_write_byte_data(client,
     
273.                 ADV7180_EXTENDED_OUTPUT_CONTROL_REG,
     
274.                 ADV7180_EXTENDED_OUTPUT_CONTROL_NTSCDIS);
     
275.         if (ret < 0)
     
276.                 goto err_unreg_subdev;
     
277. 
     
278.         /* read current norm */
     
279.         __adv7180_status(client, NULL, &state->curr_norm);
     
280. 
     
281.         /* register for interrupts */
     
282.         if (state->irq > 0) {
     
283.                 ret = request_irq(state->irq, adv7180_irq, 0, DRIVER_NAME,
     
284.                         state);
     
285.                 if (ret)
     
286.                         goto err_unreg_subdev;
     
287. 
     
288.                 ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG,
     
289.                         ADV7180_ADI_CTRL_IRQ_SPACE);
     
290.                 if (ret < 0)
     
291.                         goto err_unreg_subdev;
     
292. 
     
293.                 /* config the Interrupt pin to be active low */
     
294.                 ret = i2c_smbus_write_byte_data(client, ADV7180_ICONF1_ADI,
     
295.                         ADV7180_ICONF1_ACTIVE_LOW | ADV7180_ICONF1_PSYNC_ONLY);
     
296.                 if (ret < 0)
     
297.                         goto err_unreg_subdev;
     
298. 
     
299.                 ret = i2c_smbus_write_byte_data(client, ADV7180_IMR1_ADI, 0);
     
300.                 if (ret < 0)
     
301.                         goto err_unreg_subdev;
     
302. 
     
303.                 ret = i2c_smbus_write_byte_data(client, ADV7180_IMR2_ADI, 0);
     
304.                 if (ret < 0)
     
305.                         goto err_unreg_subdev;
     
306. 
     
307.                 /* enable AD change interrupts interrupts */
     
308.                 ret = i2c_smbus_write_byte_data(client, ADV7180_IMR3_ADI,
     
309.                         ADV7180_IRQ3_AD_CHANGE);
     
310.                 if (ret < 0)
     
311.                         goto err_unreg_subdev;
     
312. 
     
313.                 ret = i2c_smbus_write_byte_data(client, ADV7180_IMR4_ADI, 0);
     
314.                 if (ret < 0)
     
315.                         goto err_unreg_subdev;
     
316. 
     
317.                 ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG,
     
318.                         0);
     
319.                 if (ret < 0)
     
320.                         goto err_unreg_subdev;
     
321.         }
     
322. 
     
323.         return 0;
     
324. 
     
325. err_unreg_subdev:
     
326.         mutex_destroy(&state->mutex);
     
327.         v4l2_device_unregister_subdev(sd);
     
328.         kfree(state);
     
329. err:
     
330.         printk(KERN_ERR DRIVER_NAME ": Failed to probe: %d\n", ret);
     
331.         return ret;
     
332. }
     
333. 
     
334. static __devexit int adv7180_remove(struct i2c_client *client)
     
335. {
     
336.         struct v4l2_subdev *sd = i2c_get_clientdata(client);
     
337.         struct adv7180_state *state = to_state(sd);
     
338. 
     
339.         if (state->irq > 0) {
     
340.                 free_irq(client->irq, state);
     
341.                 if (cancel_work_sync(&state->work)) {
     
342.                         /*
     
343.                          * Work was pending, therefore we need to enable
     
344.                          * IRQ here to balance the disable_irq() done in the
     
345.                          * interrupt handler.
     
346.                          */
     
347.                         enable_irq(state->irq);
     
348.                 }
     
349.         }
     
350. 
     
351.         mutex_destroy(&state->mutex);
     
352.         v4l2_device_unregister_subdev(sd);
     
353.         kfree(to_state(sd));
     
354.         return 0;
     
355. }
     
356. 
     
357. static const struct i2c_device_id adv7180_id[] = {
     
358.         {DRIVER_NAME, 0},
     
359.         {},
     
360. };
     
361. 
     
362. MODULE_DEVICE_TABLE(i2c, adv7180_id);
     
363. 
     
364. static struct i2c_driver adv7180_driver = {
     
365.         .driver = {
     
366.                 .owner        = THIS_MODULE,
     
367.                 .name        = DRIVER_NAME,
     
368.         },
     
369.         .probe                = adv7180_probe,
     
370.         .remove                = __devexit_p(adv7180_remove),
     
371.         .id_table        = adv7180_id,
     
372. };
     
373. 
     
374. static __init int adv7180_init(void)
     
375. {
     
376.         return i2c_add_driver(&adv7180_driver);
     
377. }
     
378. 
     
379. static __exit void adv7180_exit(void)
     
380. {
     
381.         i2c_del_driver(&adv7180_driver);
     
382. }
     
383. 
     
384. module_init(adv7180_init);
     
385. module_exit(adv7180_exit);
     
386. MODULE_LICENSE("GPL v2");
     

复制代码

检查一下mach-tq2440.c文件中中有没有添加相关的初始化代码吧。probe函数的参数来源就是mach-tq2440.c中的初始化。

是的，我改动过mach-tq2440.c  好像有进入probe函数 , 在 state = kzalloc(sizeof(struct adv7180_state), GFP_KERNEL); 出错吧，基础差了，搞不明白
static struct i2c_board_info __initdata i2c_adv7180[] = {  //jf  add   //s3c2410_i2c_board_info[]
        {
        I2C_BOARD_INFO("adv7180",0x42),   /*0x40 is addr of adv7180*/         //jf  add
//        .platform_data = 0,                                   //jf  add
        },
};

static struct platform_device *tq2440_devices[] __initdata = {
        &s3c_device_usb,
        &s3c_device_lcd,
        &s3c_device_wdt,
        &s3c_device_i2c0,
        &s3c_device_iis,
        &s3c_device_rtc,
//        &s3c_device_adv7180,                  //jf add
#ifdef CONFIG_DM9000
        &s3c_device_dm9000,
#endif
        &s3c_device_usbgadget,
        &s3c_device_uda134x,
//        &s3c_device_ts,
};

static void __init tq2440_map_io(void)
{
        s3c24xx_init_io(tq2440_iodesc, ARRAY_SIZE(tq2440_iodesc));
        s3c24xx_init_clocks(12000000);
        s3c24xx_init_uarts(tq2440_uartcfgs, ARRAY_SIZE(tq2440_uartcfgs));
}

static void __init tq2440_machine_init(void)
{
        s3c24xx_fb_set_platdata(&tq2440_fb_info);
//        s3c_device_ts.dev.platform_data = & tq2440_ts_info;
        s3c_i2c0_set_platdata(NULL);

        platform_add_devices(tq2440_devices, ARRAY_SIZE(tq2440_devices));
        i2c_register_board_info(0,i2c_adv7180,ARRAY_SIZE(i2c_adv7180));    //jf add