enable can1

hc

2023-11-30 6c9be420e167ee7ce45c0309586f09ddab28ac15

 kernel/net/rfkill/rfkill-bt.c
..
..
@@ -25,6 +25,7 @@
25
25
 #include <linux/rfkill-bt.h>
26
26
 #include <linux/rfkill-wlan.h>
27
27
 #include <linux/wakelock.h>
28
+#include <linux/input.h>
28
29
 #include <linux/interrupt.h>
29
30
 #include <asm/irq.h>
30
31
 #include <linux/suspend.h>
..
..
@@ -69,9 +70,11 @@
69
70
 	struct wake_lock bt_irq_wl;
70
71
 	struct delayed_work bt_sleep_delay_work;
71
72
 	int irq_req;
73
+	bool enable_power_key;
72
74
 };
73
75
 
74
76
 static struct rfkill_rk_data *g_rfkill = NULL;
77
+static struct input_dev *power_key_dev;
75
78
 
76
79
 static const char bt_name[] =
77
80
 #if defined(CONFIG_BCM4330)
..
..
@@ -113,6 +116,20 @@
113
116
 #endif
114
117
 	;
115
118
 
119
+static int rfkill_rk_power_key_up(void)
120
+{
121
+	if (!power_key_dev)
122
+		return -ENODEV;
123
+
124
+	input_report_key(power_key_dev, KEY_POWER, 1);
125
+	input_sync(power_key_dev);
126
+	msleep(20);
127
+	input_report_key(power_key_dev, KEY_POWER, 0);
128
+	input_sync(power_key_dev);
129
+
130
+	return 0;
131
+}
132
+
116
133
 static irqreturn_t rfkill_rk_wake_host_irq(int irq, void *dev)
117
134
 {
118
135
 	struct rfkill_rk_data *rfkill = dev;
..
..
@@ -123,6 +140,16 @@
123
140
 
124
141
 	wake_lock_timeout(&rfkill->bt_irq_wl,
125
142
 			  msecs_to_jiffies(BT_IRQ_WAKELOCK_TIMEOUT));
143
+
144
+	if (rfkill->enable_power_key)
145
+		return IRQ_WAKE_THREAD;
146
+
147
+	return IRQ_HANDLED;
148
+}
149
+
150
+static irqreturn_t rfkill_rk_wake_host_irq_thread(int irq, void *dev)
151
+{
152
+	rfkill_rk_power_key_up();
126
153
 
127
154
 	return IRQ_HANDLED;
128
155
 }
..
..
@@ -165,11 +192,12 @@
165
192
 		LOG("Request irq for bt wakeup host\n");
166
193
 		irq->irq = gpio_to_irq(irq->gpio.io);
167
194
 		sprintf(irq->name, "%s_irq", irq->gpio.name);
168
-		ret = request_irq(irq->irq, rfkill_rk_wake_host_irq,
169
-				  (irq->gpio.enable == GPIO_ACTIVE_LOW) ?
170
-					  IRQF_TRIGGER_FALLING :
171
-					  IRQF_TRIGGER_RISING,
172
-				  irq->name, rfkill);
195
+		ret = request_threaded_irq(irq->irq, rfkill_rk_wake_host_irq,
196
+					   rfkill_rk_wake_host_irq_thread,
197
+					   IRQF_ONESHOT | ((irq->gpio.enable == GPIO_ACTIVE_LOW) ?
198
+					   IRQF_TRIGGER_FALLING :
199
+					   IRQF_TRIGGER_RISING),
200
+					   irq->name, rfkill);
173
201
 		if (ret)
174
202
 			goto fail2;
175
203
 		rfkill->irq_req = 1;
..
..
@@ -271,7 +299,8 @@
271
299
 
272
300
 	return 0;
273
301
 }
274
-static int proc_rk_set_power(void *data, bool blocked)
302
+
303
+static int rfkill_rk_set_power(void *data, bool blocked)
275
304
 {
276
305
 	struct rfkill_rk_data *rfkill = data;
277
306
 	struct rfkill_rk_gpio *wake_host = &rfkill->pdata->wake_host_irq.gpio;
..
..
@@ -363,113 +392,6 @@
363
392
 				LOG("%s: cannot get wifi power state!\n", __func__);
364
393
 				return -EPERM;
365
394
 			}
366
-			if (!wifi_power) {
367
-				LOG("%s: bt will set vbat to low\n", __func__);
368
-				rfkill_set_wifi_bt_power(0);
369
-			} else {
370
-				LOG("%s: bt shouldn't control the vbat\n", __func__);
371
-			}
372
-		}
373
-	}
374
-
375
-	return 0;
376
-}
377
-
378
-
379
-static int rfkill_rk_set_power(void *data, bool blocked)
380
-{
381
-	struct rfkill_rk_data *rfkill = data;
382
-	struct rfkill_rk_gpio *wake_host = &rfkill->pdata->wake_host_irq.gpio;
383
-	struct rfkill_rk_gpio *poweron = &rfkill->pdata->poweron_gpio;
384
-	struct rfkill_rk_gpio *reset = &rfkill->pdata->reset_gpio;
385
-	struct rfkill_rk_gpio *rts = &rfkill->pdata->rts_gpio;
386
-	struct pinctrl *pinctrl = rfkill->pdata->pinctrl;
387
-	int wifi_power = 0;
388
-	bool toggle = false;
389
-
390
-	DBG("Enter %s\n", __func__);
391
-
392
-	DBG("Set blocked:%d\n", blocked);
393
-
394
-	toggle = rfkill->pdata->power_toggle;
395
-
396
-	if (toggle) {
397
-		if (rfkill_get_wifi_power_state(&wifi_power)) {
398
-			LOG("%s: cannot get wifi power state!\n", __func__);
399
-			return -1;
400
-		}
401
-	}
402
-
403
-	DBG("%s: toggle = %s\n", __func__, toggle ? "true" : "false");
404
-
405
-	if (!blocked) {
406
-		if (toggle) {
407
-			rfkill_set_wifi_bt_power(1);
408
-			msleep(100);
409
-		}
410
-
411
-		rfkill_rk_sleep_bt(BT_WAKEUP); // ensure bt is wakeup
412
-
413
-		if (gpio_is_valid(wake_host->io)) {
414
-			LOG("%s: set bt wake_host high!\n", __func__);
415
-			gpio_direction_output(wake_host->io, 1);
416
-			msleep(20);
417
-		}
418
-
419
-		if (gpio_is_valid(poweron->io)) {
420
-			if (gpio_get_value(poweron->io) == !poweron->enable) {
421
-				gpio_direction_output(poweron->io,
422
-						      !poweron->enable);
423
-				msleep(20);
424
-				gpio_direction_output(poweron->io,
425
-						      poweron->enable);
426
-				msleep(20);
427
-				if (gpio_is_valid(wake_host->io))
428
-					gpio_direction_input(wake_host->io);
429
-			}
430
-		}
431
-
432
-		if (gpio_is_valid(reset->io)) {
433
-			if (gpio_get_value(reset->io) == !reset->enable) {
434
-				gpio_direction_output(reset->io,
435
-						      !reset->enable);
436
-				msleep(20);
437
-				gpio_direction_output(reset->io, reset->enable);
438
-			}
439
-		}
440
-
441
-		if (pinctrl && gpio_is_valid(rts->io)) {
442
-			pinctrl_select_state(pinctrl, rts->gpio_state);
443
-			LOG("ENABLE UART_RTS\n");
444
-			gpio_direction_output(rts->io, rts->enable);
445
-			msleep(100);
446
-			LOG("DISABLE UART_RTS\n");
447
-			gpio_direction_output(rts->io, !rts->enable);
448
-			pinctrl_select_state(pinctrl, rts->default_state);
449
-		}
450
-
451
-		bt_power_state = 1;
452
-		LOG("bt turn on power\n");
453
-		rfkill_rk_setup_wake_irq(rfkill, 1);
454
-	} else {
455
-		if (gpio_is_valid(poweron->io)) {
456
-			if (gpio_get_value(poweron->io) == poweron->enable) {
457
-				gpio_direction_output(poweron->io,
458
-						      poweron->enable);
459
-				msleep(20);
460
-			}
461
-		}
462
-
463
-		bt_power_state = 0;
464
-		LOG("bt shut off power\n");
465
-		if (gpio_is_valid(reset->io)) {
466
-			if (gpio_get_value(reset->io) == reset->enable) {
467
-				gpio_direction_output(reset->io,
468
-						      reset->enable);
469
-				msleep(20);
470
-			}
471
-		}
472
-		if (toggle) {
473
395
 			if (!wifi_power) {
474
396
 				LOG("%s: bt will set vbat to low\n", __func__);
475
397
 				rfkill_set_wifi_bt_power(0);
..
..
@@ -592,11 +514,56 @@
592
514
 		return -EFAULT;
593
515
 
594
516
 	DBG("btwrite %c\n", b);
595
-	/* HCI_DEV_WRITE */
596
517
 	if (b != '0')
597
-		proc_rk_set_power(g_rfkill, 0);
518
+		rfkill_rk_sleep_bt(BT_WAKEUP);
598
519
 	else
599
-		proc_rk_set_power(g_rfkill, 1);
520
+		rfkill_rk_sleep_bt(BT_SLEEP);
521
+
522
+	return count;
523
+}
524
+
525
+static ssize_t bluesleep_read_proc_powerupkey(struct file *file,
526
+					      char __user *buffer, size_t count,
527
+					      loff_t *data)
528
+{
529
+	struct rfkill_rk_data *rfkill = g_rfkill;
530
+	char src[2];
531
+
532
+	if (*data >= 1)
533
+		return 0;
534
+
535
+	if (!rfkill)
536
+		return -EFAULT;
537
+
538
+	src[0] = rfkill->enable_power_key ? '1' : '0';
539
+	src[1] = '\n';
540
+	if (copy_to_user(buffer, src, 2))
541
+		return -EFAULT;
542
+	*data = 1;
543
+
544
+	return 2;
545
+}
546
+
547
+static ssize_t bluesleep_write_proc_powerupkey(struct file *file,
548
+					       const char __user *buffer,
549
+					       size_t count, loff_t *data)
550
+{
551
+	char b;
552
+	struct rfkill_rk_data *rfkill = g_rfkill;
553
+
554
+	if (!rfkill)
555
+		return -EFAULT;
556
+
557
+	if (count < 1)
558
+		return -EINVAL;
559
+
560
+	if (copy_from_user(&b, buffer, 1))
561
+		return -EFAULT;
562
+
563
+	if (b != '0')
564
+		rfkill->enable_power_key = true;
565
+	else
566
+		rfkill->enable_power_key = false;
600
567
 
601
568
 	return count;
602
569
 }
..
..
@@ -700,6 +667,39 @@
700
667
 	.write = bluesleep_write_proc_btwrite,
701
668
 };
702
669
 
670
+static const struct file_operations bluesleep_powerupkey = {
671
+	.owner = THIS_MODULE,
672
+	.read = bluesleep_read_proc_powerupkey,
673
+	.write = bluesleep_write_proc_powerupkey,
674
+};
675
+
676
+static int rfkill_rk_register_power_key(void)
677
+{
678
+	int ret = 0;
679
+
680
+	/* register input device */
681
+	power_key_dev = input_allocate_device();
682
+	if (!power_key_dev) {
683
+		LOG("ir_dev: not enough memory for input device\n");
684
+		return -ENOMEM;
685
+	}
686
+
687
+	power_key_dev->name = "bt-powerkey";
688
+	power_key_dev->id.bustype = BUS_HOST;
689
+
690
+	power_key_dev->evbit[0] = BIT_MASK(EV_KEY);
691
+	set_bit(KEY_POWER, power_key_dev->keybit);
692
+
693
+	ret = input_register_device(power_key_dev);
694
+	if (ret) {
695
+		input_free_device(power_key_dev);
696
+		LOG("ir_rx_init: register input device exception, exit\n");
697
+		return -EBUSY;
698
+	}
699
+
700
+	return ret;
701
+}
702
+
703
703
 static int rfkill_rk_probe(struct platform_device *pdev)
704
704
 {
705
705
 	struct rfkill_rk_data *rfkill;
..
..
@@ -766,6 +766,14 @@
766
766
 		goto fail_alloc;
767
767
 	}
768
768
 
769
+	/* read/write proc entries */
770
+	ent = proc_create("powerupkey", 0, sleep_dir, &bluesleep_powerupkey);
771
+	if (!ent) {
772
+		LOG("Unable to create /proc/%s/powerupkey entry", PROC_DIR);
773
+		ret = -ENOMEM;
774
+		goto fail_alloc;
775
+	}
776
+
769
777
 	DBG("init gpio\n");
770
778
 
771
779
 	ret = rfkill_rk_setup_gpio(pdev, &pdata->poweron_gpio, pdata->name,
..
..
@@ -824,12 +832,16 @@
824
832
 
825
833
 	LOG("%s device registered.\n", pdata->name);
826
834
 
835
+	if (rfkill_rk_register_power_key() != 0)
836
+		goto fail_rfkill;
837
+
827
838
 	return 0;
828
839
 
829
840
 fail_rfkill:
830
841
 	rfkill_destroy(rfkill->rfkill_dev);
831
842
 fail_alloc:
832
843
 
844
+	remove_proc_entry("powerupkey", sleep_dir);
833
845
 	remove_proc_entry("btwrite", sleep_dir);
834
846
 	remove_proc_entry("lpm", sleep_dir);
835
847
 fail_setup_wake_irq:
..
..
@@ -848,7 +860,11 @@
848
860
 
849
861
 	rfkill_unregister(rfkill->rfkill_dev);
850
862
 	rfkill_destroy(rfkill->rfkill_dev);
863
+	remove_proc_entry("powerupkey", sleep_dir);
864
+	remove_proc_entry("btwrite", sleep_dir);
865
+	remove_proc_entry("lpm", sleep_dir);
851
866
 
867
+	input_unregister_device(power_key_dev);
852
868
 	cancel_delayed_work_sync(&rfkill->bt_sleep_delay_work);
853
869
 
854
870
 	// free gpio