买了正点原子的PAJ7620U2，唤醒操作在linux驱动里如何下啊，请教下

ent102

stm32的PAJ7620唤醒：
void GS_WakeUp(void){        GS_IIC_Start();        GS_IIC_Send_Byte(PAJ7620_ID);//发写命令        GS_IIC_Stop();//释放总线}



linux唤醒 ：
msg.addr  = mydevinfo->dev_i2c_client->addr; /* i2c_dev地址 */
  msg.flags = 0;                               /* 标记为发送数据 */
  msg.buf   = 0;                      /* 写入缓冲区数据 */
  msg.len   = 0;                      /* 写入的数据长度 */

  i2c_transfer (mydevinfo->dev_i2c_client->adapter, msg, 1);

这么干行吗，唤醒操作

xiaotaotao

1. #include <linux/module.h>
   
2. #include <linux/i2c.h>
   
3. #include <linux/delay.h>
   
4. #include <linux/miscdevice.h>
   
5. #include <linux/uaccess.h>
   
6. #include <linux/interrupt.h>
   
7. #include <linux/fcntl.h>
   
8. #include <linux/of_gpio.h>
   
9. 
   
10. #define GESTURE_MODE        0
    
11. #define PROXIMITY_MODE        1
    
12. 
    
13. /* 应用层ioctl CMD */
    
14. #define PAJ_CMD_SET_MODE                0x9000
    
15. 
    
16. #define COUNTER_CLOCKWISE_MASK        BIT(7)        //逆时针
    
17. #define CLOCKWISE_MASK                        BIT(6)        //顺时针
    
18. #define BACKWARD_MASK                        BIT(5)        //向后
    
19. #define FORWARD_MASK                        BIT(4)        //向前
    
20. #define RIGHT_MASK                                BIT(3)        //向右
    
21. #define LEFT_MASK                                BIT(2)        //向左
    
22. #define DOWN_MASK                                BIT(1)        //向下
    
23. #define UP_MASK                                        BIT(0)        //向上
    
24. #define WAVE_MASK                                BIT(0)        //挥动
    
25. 
    
26. enum gesture_type_t {
    
27.         WAVE = 0,
    
28.         UP,
    
29.         DOWN,
    
30.         LEFT,
    
31.         RIGHT,
    
32.         FORWARD,
    
33.         BACKWARD,
    
34.         CLOCKWISE,
    
35.         COUNTER_CLOCKWISE,
    
36. };
    
37. 
    
38. struct p_mode_obj_attr {
    
39.         u8 brightness;
    
40.         u16 size;
    
41. };
    
42. 
    
43. struct paj7620u2_dev {
    
44.         struct i2c_client *client;
    
45.         struct miscdevice mdev;                //定义一个杂散设备
    
46.         struct mutex lock;                        //互斥锁
    
47.         int mode;                                        //当前模式
    
48.         int gpio;                        //中断引脚
    
49.         atomic_t count;
    
50.         struct fasync_struct *async_queue;        //异步通知队列
    
51. };
    
52. 
    
53. struct paj7620u2_dev paj7620u2;                //实例化paj7620u2设备
    
54. 
    
55. static const u8 _init_cfg_table[][2] = {
    
56.         {0xEF,0x00},
    
57.         {0x37,0x07},
    
58.         {0x38,0x17},
    
59.         {0x39,0x06},
    
60.         {0x41,0x00},
    
61.         {0x42,0x00},
    
62.         {0x46,0x2D},
    
63.         {0x47,0x0F},
    
64.         {0x48,0x3C},
    
65.         {0x49,0x00},
    
66.         {0x4A,0x1E},
    
67.         {0x4C,0x20},
    
68.         {0x51,0x10},
    
69.         {0x5E,0x10},
    
70.         {0x60,0x27},
    
71.         {0x80,0x42},
    
72.         {0x81,0x44},
    
73.         {0x82,0x04},
    
74.         {0x8B,0x01},
    
75.         {0x90,0x06},
    
76.         {0x95,0x0A},
    
77.         {0x96,0x0C},
    
78.         {0x97,0x05},
    
79.         {0x9A,0x14},
    
80.         {0x9C,0x3F},
    
81.         {0xA5,0x19},
    
82.         {0xCC,0x19},
    
83.         {0xCD,0x0B},
    
84.         {0xCE,0x13},
    
85.         {0xCF,0x64},
    
86.         {0xD0,0x21},
    
87.         {0xEF,0x01},
    
88.         {0x02,0x0F},
    
89.         {0x03,0x10},
    
90.         {0x04,0x02},
    
91.         {0x25,0x01},
    
92.         {0x27,0x39},
    
93.         {0x28,0x7F},
    
94.         {0x29,0x08},
    
95.         {0x3E,0xFF},
    
96.         {0x5E,0x3D},
    
97.         {0x65,0x96},
    
98.         {0x67,0x97},
    
99.         {0x69,0xCD},
    
100.         {0x6A,0x01},
     
101.         {0x6D,0x2C},
     
102.         {0x6E,0x01},
     
103.         {0x72,0x01},
     
104.         {0x73,0x35},
     
105.         {0x74,0x00},
     
106.         {0x77,0x01},
     
107. };
     
108. 
     
109. static const u8 _proximity_cfg_table[][2] = {
     
110.         {0xEF,0x00},
     
111.         {0x41,0x00},
     
112.         {0x42,0x00},
     
113.         {0x48,0x3C},
     
114.         {0x49,0x00},
     
115.         {0x51,0x13},
     
116.         {0x83,0x20},
     
117.         {0x84,0x20},
     
118.         {0x85,0x00},
     
119.         {0x86,0x10},
     
120.         {0x87,0x00},
     
121.         {0x88,0x05},
     
122.         {0x89,0x18},
     
123.         {0x8A,0x10},
     
124.         {0x9f,0xf8},
     
125.         {0x69,0x96},
     
126.         {0x6A,0x02},
     
127.         {0xEF,0x01},
     
128.         {0x01,0x1E},
     
129.         {0x02,0x0F},
     
130.         {0x03,0x10},
     
131.         {0x04,0x02},
     
132.         {0x41,0x50},
     
133.         {0x43,0x34},
     
134.         {0x65,0xCE},
     
135.         {0x66,0x0B},
     
136.         {0x67,0xCE},
     
137.         {0x68,0x0B},
     
138.         {0x69,0xE9},
     
139.         {0x6A,0x05},
     
140.         {0x6B,0x50},
     
141.         {0x6C,0xC3},
     
142.         {0x6D,0x50},
     
143.         {0x6E,0xC3},
     
144.         {0x74,0x05},
     
145. };
     
146. 
     
147. static const u8 _gesture_cfg_table[][2] = {
     
148.         {0xEF,0x00},
     
149.         {0x41,0x00},
     
150.         {0x42,0x00},
     
151.         {0xEF,0x00},
     
152.         {0x48,0x3C},
     
153.         {0x49,0x00},
     
154.         {0x51,0x10},
     
155.         {0x83,0x20},
     
156.         {0x9F,0xF9},
     
157.         {0xEF,0x01},
     
158.         {0x01,0x1E},
     
159.         {0x02,0x0F},
     
160.         {0x03,0x10},
     
161.         {0x04,0x02},
     
162.         {0x41,0x40},
     
163.         {0x43,0x30},
     
164.         {0x65,0x96},
     
165.         {0x66,0x00},
     
166.         {0x67,0x97},
     
167.         {0x68,0x01},
     
168.         {0x69,0xCD},
     
169.         {0x6A,0x01},
     
170.         {0x6B,0xB0},
     
171.         {0x6C,0x04},
     
172.         {0x6D,0x2C},
     
173.         {0x6E,0x01},
     
174.         {0x74,0x00},
     
175.         {0xEF,0x00},
     
176.         {0x41,0xFF},
     
177.         {0x42,0x01},
     
178. };
     
179. 
     
180. static int paj7620u2_i2c_write(u8 addr, u8 val)
     
181. {
     
182.         struct i2c_client *client = paj7620u2.client;
     
183.         struct i2c_msg msg;
     
184.         u8 buf[3] = {0};
     
185.         int ret;
     
186. 
     
187.         buf[0] = addr;                //填充地址
     
188.         buf[1] = val;                //填充写入数据
     
189. 
     
190.         msg.flags = 0;        //i2c写
     
191.         msg.addr = client->addr;
     
192.         msg.buf = buf;
     
193.         msg.len = 2;
     
194. 
     
195.         ret = i2c_transfer(client->adapter, &msg, 1);
     
196.         if (1 == ret)
     
197.                 return 0;
     
198.         else {
     
199.                 dev_err(&client->dev, "%s: write error, addr=0x%x val=%d.\n",
     
200.                                         __func__, addr, val);
     
201.                 return -1;
     
202.         }
     
203. }
     
204. 
     
205. static int paj7620u2_i2c_read(u8 addr, u8 *val)
     
206. {
     
207.         struct i2c_client *client = paj7620u2.client;
     
208.         struct i2c_msg msg[2];
     
209.         int ret;
     
210. 
     
211.         msg[0].flags = 0;        // i2c写
     
212.         msg[0].addr = client->addr;
     
213.         msg[0].buf = &addr;
     
214.         msg[0].len = 1;
     
215. 
     
216.         msg[1].flags = I2C_M_RD;        //i2c读
     
217.         msg[1].addr = client->addr;
     
218.         msg[1].buf = val;
     
219.         msg[1].len = 1;
     
220. 
     
221.         ret = i2c_transfer(client->adapter, msg, 2);
     
222.         if (2 == ret)
     
223.                 return 0;
     
224.         else {
     
225.                 dev_err(&client->dev, "%s: read error, addr=0x%x.\n",
     
226.                                         __func__, addr);
     
227.                 return -1;
     
228.         }
     
229. }
     
230. 
     
231. static int paj7620u2_proximity_mode(void)
     
232. {
     
233.         int len = sizeof(_proximity_cfg_table) / 2;
     
234.         int i;
     
235.         int ret;
     
236. 
     
237.         for (i = 0; i < len; i++) {
     
238. 
     
239.                 ret = paj7620u2_i2c_write(_proximity_cfg_table[i][0],
     
240.                                         _proximity_cfg_table[i][1]);
     
241.                 if (ret)
     
242.                         return ret;
     
243.         }
     
244. 
     
245.         paj7620u2.mode = PROXIMITY_MODE;
     
246.         return 0;
     
247. }
     
248. 
     
249. static int paj7620u2_gesture_mode(void)
     
250. {
     
251.         int len = sizeof(_gesture_cfg_table) / 2;
     
252.         int i;
     
253.         int ret;
     
254. 
     
255.         for (i = 0; i < len; i++) {
     
256. 
     
257.                 ret = paj7620u2_i2c_write(_gesture_cfg_table[i][0],
     
258.                                         _gesture_cfg_table[i][1]);
     
259.                 if (ret)
     
260.                         return ret;
     
261.         }
     
262. 
     
263.         paj7620u2.mode = GESTURE_MODE;
     
264.         return 0;
     
265. }
     
266. 
     
267. static void paj7620u2_send_write_cmd(void)
     
268. {
     
269.         struct i2c_client *client = paj7620u2.client;
     
270.         struct i2c_msg msg;
     
271.         u8 buf[2] = {0};
     
272. 
     
273.         buf[0] = 0xFF;
     
274. 
     
275.         msg.flags = 0;        //i2c写
     
276.         msg.addr = client->addr;
     
277.         msg.buf = buf;
     
278.         msg.len = 1;
     
279. 
     
280.         i2c_transfer(client->adapter, &msg, 1);
     
281. }
     
282. 
     
283. static int paj7620u2_wakeup(void)
     
284. {
     
285.         u8 status = 0x00;
     
286.         int count = 0;
     
287.         int ret;
     
288. 
     
289.         /* 唤醒 */
     
290. wakeup:
     
291.         count++;
     
292.         msleep(5);
     
293.         paj7620u2_send_write_cmd();
     
294. 
     
295.         msleep(5);
     
296.         paj7620u2_i2c_read(0x00, &status);
     
297.         if (0x20 != status) {
     
298.                 if (2 == count)
     
299.                         return -1;
     
300. 
     
301.                 goto wakeup;
     
302.         }
     
303. 
     
304.         ret = paj7620u2_i2c_write(0xEF, 0x01);        //进入BANK1寄存器组
     
305.         if (ret)
     
306.                 return ret;
     
307. 
     
308.         ret = paj7620u2_i2c_write(0x72, 0x01);        //使能
     
309.         if (ret)
     
310.                 return ret;
     
311. 
     
312.         return 0;
     
313. }
     
314. 
     
315. static int paj7620u2_open(struct inode *inode, struct file *filp)
     
316. {
     
317.         int count;
     
318. 
     
319.         if (!atomic_dec_and_test(&paj7620u2.count)) {
     
320.                 printk(KERN_ERR "paj7620: Device is busy!\n");
     
321.                 atomic_inc(&paj7620u2.count);
     
322.                 return -EBUSY;
     
323.         }
     
324. 
     
325.         return 0;
     
326. }
     
327. 
     
328. static ssize_t paj7620u2_read(struct file *filp, char __user *buf,
     
329.                         size_t cnt, loff_t *offt)
     
330. {
     
331.         struct i2c_client *client = paj7620u2.client;
     
332.         u8 data[2] = {0};
     
333. 
     
334.         mutex_lock(&paj7620u2.lock);
     
335.         paj7620u2_i2c_write(0xEF, 0x00);        //进入BANK0寄存器组
     
336. 
     
337.         if (GESTURE_MODE == paj7620u2.mode) {
     
338.                 int gesture;
     
339. 
     
340.                 paj7620u2_i2c_read(0x43, data);
     
341.                 switch (data[0]) {
     
342.                 case UP_MASK: gesture = UP; break;
     
343.                 case DOWN_MASK: gesture = DOWN; break;
     
344.                 case LEFT_MASK: gesture = LEFT; break;
     
345.                 case RIGHT_MASK: gesture = RIGHT; break;
     
346.                 case FORWARD_MASK: gesture = FORWARD; break;
     
347.                 case BACKWARD_MASK: gesture = BACKWARD; break;
     
348.                 case CLOCKWISE_MASK: gesture = CLOCKWISE; break;
     
349.                 case COUNTER_CLOCKWISE_MASK:
     
350.                         gesture = COUNTER_CLOCKWISE;
     
351.                         break;
     
352.                 default:
     
353.                         gesture = -1;
     
354.                         break;
     
355.                 }
     
356. 
     
357.                 paj7620u2_i2c_read(0x44, data);
     
358.                 if (WAVE_MASK == data[0])
     
359.                         gesture = WAVE;
     
360. 
     
361.                 mutex_unlock(&paj7620u2.lock);
     
362.                 return copy_to_user(buf, &gesture, sizeof(int));
     
363.         } else if (PROXIMITY_MODE == paj7620u2.mode) {
     
364.                 struct p_mode_obj_attr attr;
     
365. 
     
366.                 paj7620u2_i2c_read(0xB0, data);
     
367.                 attr.brightness = data[0];
     
368.                 paj7620u2_i2c_read(0xB1, data);
     
369.                 paj7620u2_i2c_read(0xB2, &data[1]);
     
370.                 attr.size = (((u16)data[1] & 0x0F) << 8) | (u16)data[0];
     
371. 
     
372.                 mutex_unlock(&paj7620u2.lock);
     
373.                 return copy_to_user(buf, &attr, sizeof(attr));
     
374.         }
     
375. 
     
376.         mutex_unlock(&paj7620u2.lock);
     
377.         dev_err(&client->dev, "Please set the working mode\n");
     
378.         return -1;
     
379. }
     
380. 
     
381. static long paj7620u2_ioctl(struct file *file,
     
382.                         unsigned int cmd, unsigned long arg)
     
383. {
     
384.         u8 data;
     
385. 
     
386.         switch (cmd) {
     
387.         /* 设置模式 */
     
388.         case PAJ_CMD_SET_MODE: {
     
389.                 mutex_lock(&paj7620u2.lock);
     
390. 
     
391.                 if (GESTURE_MODE == arg &&
     
392.                         GESTURE_MODE != paj7620u2.mode)
     
393.                         paj7620u2_gesture_mode();
     
394.                 else if (PROXIMITY_MODE == arg &&
     
395.                         PROXIMITY_MODE != paj7620u2.mode)
     
396.                         paj7620u2_proximity_mode();
     
397. 
     
398.                 /* 清除中断标志位 */
     
399.                 paj7620u2_i2c_write(0xEF, 0x00);
     
400.                 paj7620u2_i2c_read(0x43, &data);
     
401.                 paj7620u2_i2c_read(0x44, &data);
     
402.                 mutex_unlock(&paj7620u2.lock);
     
403.         }
     
404.                 break;
     
405. 
     
406.         default:
     
407.                 break;
     
408.         }
     
409. 
     
410.         return 0;
     
411. }
     
412. 
     
413. static int paj7620u2_fasync(int fd, struct file *filp, int on)
     
414. {
     
415.         return fasync_helper(fd, filp, on, &paj7620u2.async_queue);
     
416. }
     
417. 
     
418. static int paj7620u2_release(struct inode *inode, struct file *filp)
     
419. {
     
420.         atomic_inc(&paj7620u2.count);
     
421.         return paj7620u2_fasync(-1, filp, 0);
     
422. }
     
423. 
     
424. static struct file_operations paj7620u2_fops = {
     
425.         .owner                        = THIS_MODULE,
     
426.         .open                        = paj7620u2_open,
     
427.         .read                        = paj7620u2_read,
     
428.         .release                = paj7620u2_release,
     
429.         .unlocked_ioctl        = paj7620u2_ioctl,
     
430.         .fasync                        = paj7620u2_fasync,
     
431. };
     
432. 
     
433. static irqreturn_t paj7620u2_i2c_isr(int irq, void *dev_id)
     
434. {
     
435.         kill_fasync(&paj7620u2.async_queue, SIGIO, POLL_IN);
     
436.         return IRQ_HANDLED;
     
437. }
     
438. 
     
439. static int paj7620u2_irq_init(struct i2c_client *client)
     
440. {
     
441.         struct device_node *node = client->dev.of_node;
     
442.         int ret;
     
443. 
     
444.         /* 获取中断引脚 */
     
445.         paj7620u2.gpio = of_get_named_gpio(node, "interrupt-gpio", 0);
     
446.         if (!gpio_is_valid(paj7620u2.gpio)) {
     
447.                 dev_err(&client->dev, "Failed to get paj7620 interrupt gpio\n");
     
448.                 return paj7620u2.gpio;
     
449.         }
     
450. 
     
451.         ret = devm_gpio_request_one(&client->dev, paj7620u2.gpio,
     
452.                                 GPIOF_OUT_INIT_HIGH, "interrupt gpio");
     
453.         if (ret < 0)
     
454.                 return ret;
     
455. 
     
456.         /* 申请中断 */
     
457.         gpio_direction_input(paj7620u2.gpio);
     
458.         ret = devm_request_threaded_irq(&client->dev, gpio_to_irq(paj7620u2.gpio),
     
459.                                 NULL, paj7620u2_i2c_isr, IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
     
460.                                 client->name, NULL);
     
461.         if (ret) {
     
462.                 dev_err(&client->dev, "Failed to request paj7620u2 IRQ.\n");
     
463.                 return ret;
     
464.         }
     
465. 
     
466.         return 0;
     
467. }
     
468. 
     
469. static int paj7620u2_init(struct i2c_client *client)
     
470. {
     
471.         int len = sizeof(_init_cfg_table) / 2;
     
472.         u8 status = 0x00;
     
473.         int i = 0;
     
474.         int ret;
     
475. 
     
476.         /* 唤醒 */
     
477.         ret = paj7620u2_wakeup();
     
478.         if (ret) {
     
479.                 dev_err(&client->dev, "Failed to wakeup paj7620u2.\n");
     
480.                 return ret;
     
481.         }
     
482. 
     
483.         /* 初始化 */
     
484.         for (i = 0; i < len; i++) {
     
485. 
     
486.                 ret = paj7620u2_i2c_write(_init_cfg_table[i][0],
     
487.                                         _init_cfg_table[i][1]);
     
488.                 if (ret)
     
489.                         return ret;
     
490.         }
     
491. 
     
492.         /* 清除中断状态寄存器标志位 */
     
493.         ret = paj7620u2_i2c_write(0xEF, 0x00);        //进入BANK0寄存器组
     
494.         if (ret)
     
495.                 return ret;
     
496. 
     
497.         paj7620u2_i2c_read(0x43, &status);        //读中断状态挂起寄存器
     
498.         paj7620u2_i2c_read(0x44, &status);
     
499. 
     
500.         /* 当前模式 */
     
501.         paj7620u2.mode = -1;
     
502. 
     
503.         return 0;
     
504. }
     
505. 
     
506. static int paj7620u2_i2c_probe(struct i2c_client *client,
     
507.                         const struct i2c_device_id *id)
     
508. {
     
509.         struct miscdevice *mdev;
     
510.         int ret;
     
511. 
     
512.         paj7620u2.client = client;
     
513.         atomic_set(&paj7620u2.count, 1);
     
514. 
     
515.         /* 初始化互斥锁 */
     
516.         mutex_init(&paj7620u2.lock);
     
517. 
     
518.         /* 初始化paj7620u2 */
     
519.         ret = paj7620u2_init(client);
     
520.         if (ret)
     
521.                 return ret;
     
522. 
     
523.         /* 注册中断服务函数 */
     
524.         ret = paj7620u2_irq_init(client);
     
525.         if (ret)
     
526.                 return ret;
     
527. 
     
528.         /* struct miscdevice类型对象 */
     
529.         mdev = &paj7620u2.mdev;
     
530.         mdev->name = "paj7620u2";
     
531.         mdev->minor = MISC_DYNAMIC_MINOR;
     
532.         mdev->fops = &paj7620u2_fops;
     
533.         mdev->parent = NULL;
     
534. 
     
535.         /* 注册杂散类设备 */
     
536.         return misc_register(mdev);
     
537. }
     
538. 
     
539. static int paj7620u2_i2c_remove(struct i2c_client *client)
     
540. {
     
541.         misc_deregister(&paj7620u2.mdev);
     
542.         return 0;
     
543. }
     
544. 
     
545. static const struct of_device_id paj7620u2_of_match[] = {
     
546.         { .compatible = "PixArt,paj7620u2", },
     
547.         {},
     
548. };
     
549. MODULE_DEVICE_TABLE(of, paj7620u2_of_match);
     
550. 
     
551. static struct i2c_driver paj7620u2_driver = {
     
552.         .driver = {
     
553.                 .owner                        = THIS_MODULE,
     
554.                 .name                        = "paj7620u2",
     
555.                 .of_match_table        = paj7620u2_of_match,
     
556.         },
     
557.         .probe                = paj7620u2_i2c_probe,
     
558.         .remove                = paj7620u2_i2c_remove,
     
559. };
     
560. module_i2c_driver(paj7620u2_driver);
     
561. 
     
562. MODULE_DESCRIPTION("PAJ7620U2 Integrated Gesture Recognition Sensor Driver");
     
563. MODULE_AUTHOR("Deng Tao <773904075@qq.com>, ALIENTEK, Inc.");
     
564. MODULE_LICENSE("GPL");
     

复制代码

ent102

xiaotaotao 发表于 2021-4-13 15:48

感谢，我得慢慢看，真多啊