add audio

hc

2023-12-11 1f93a7dfd1f8d5ff7a5c53246c7534fe2332d6f4

 kernel/net/rfkill/rfkill-bt.c
..
..
@@ -25,7 +25,6 @@
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>
29
28
 #include <linux/interrupt.h>
30
29
 #include <asm/irq.h>
31
30
 #include <linux/suspend.h>
..
..
@@ -70,11 +69,9 @@
70
69
 	struct wake_lock bt_irq_wl;
71
70
 	struct delayed_work bt_sleep_delay_work;
72
71
 	int irq_req;
73
-	bool enable_power_key;
74
72
 };
75
73
 
76
74
 static struct rfkill_rk_data *g_rfkill = NULL;
77
-static struct input_dev *power_key_dev;
78
75
 
79
76
 static const char bt_name[] =
80
77
 #if defined(CONFIG_BCM4330)
..
..
@@ -116,20 +113,6 @@
116
113
 #endif
117
114
 	;
118
115
 
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
-
133
116
 static irqreturn_t rfkill_rk_wake_host_irq(int irq, void *dev)
134
117
 {
135
118
 	struct rfkill_rk_data *rfkill = dev;
..
..
@@ -140,16 +123,6 @@
140
123
 
141
124
 	wake_lock_timeout(&rfkill->bt_irq_wl,
142
125
 			  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();
153
126
 
154
127
 	return IRQ_HANDLED;
155
128
 }
..
..
@@ -192,22 +165,25 @@
192
165
 		LOG("Request irq for bt wakeup host\n");
193
166
 		irq->irq = gpio_to_irq(irq->gpio.io);
194
167
 		sprintf(irq->name, "%s_irq", irq->gpio.name);
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);
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);
201
173
 		if (ret)
202
174
 			goto fail2;
203
175
 		rfkill->irq_req = 1;
204
176
 		LOG("** disable irq\n");
205
177
 		disable_irq(irq->irq);
206
-		/*ret = disable_irq_wake(irq->irq);init irq wake is disabled,no need to disable*/
178
+		ret = enable_irq_wake(irq->irq);
179
+		if (ret)
180
+			goto fail3;
207
181
 	}
208
182
 
209
183
 	return ret;
210
184
 
185
+fail3:
186
+	free_irq(irq->irq, rfkill);
211
187
 fail2:
212
188
 	gpio_free(irq->gpio.io);
213
189
 fail1:
..
..
@@ -255,7 +231,6 @@
255
231
 {
256
232
 	struct rfkill_rk_data *rfkill = g_rfkill;
257
233
 	struct rfkill_rk_gpio *wake;
258
-	bool ret;
259
234
 
260
235
 	DBG("Enter %s\n", __func__);
261
236
 
..
..
@@ -270,7 +245,7 @@
270
245
 		return;
271
246
 	}
272
247
 
273
-	ret = cancel_delayed_work_sync(&rfkill->bt_sleep_delay_work);
248
+	cancel_delayed_work_sync(&rfkill->bt_sleep_delay_work);
274
249
 
275
250
 	rfkill_rk_sleep_bt_internal(rfkill, sleep);
276
251
 
..
..
@@ -317,6 +292,12 @@
317
292
 
318
293
 	toggle = rfkill->pdata->power_toggle;
319
294
 
295
+	if (toggle) {
296
+		if (rfkill_get_wifi_power_state(&wifi_power)) {
297
+			LOG("%s: cannot get wifi power state!\n", __func__);
298
+			return -1;
299
+		}
300
+	}
320
301
 
321
302
 	DBG("%s: toggle = %s\n", __func__, toggle ? "true" : "false");
322
303
 
..
..
@@ -388,10 +369,6 @@
388
369
 			}
389
370
 		}
390
371
 		if (toggle) {
391
-			if (rfkill_get_wifi_power_state(&wifi_power)) {
392
-				LOG("%s: cannot get wifi power state!\n", __func__);
393
-				return -EPERM;
394
-			}
395
372
 			if (!wifi_power) {
396
373
 				LOG("%s: bt will set vbat to low\n", __func__);
397
374
 				rfkill_set_wifi_bt_power(0);
..
..
@@ -409,7 +386,6 @@
409
386
 	struct rfkill_rk_data *rfkill = g_rfkill;
410
387
 	struct rfkill_rk_gpio *rts;
411
388
 	struct rfkill_rk_irq *wake_host_irq;
412
-	struct pinctrl *pinctrl = rfkill->pdata->pinctrl;
413
389
 
414
390
 	DBG("Enter %s\n", __func__);
415
391
 
..
..
@@ -420,9 +396,9 @@
420
396
 	wake_host_irq = &rfkill->pdata->wake_host_irq;
421
397
 
422
398
 	//To prevent uart to receive bt data when suspended
423
-	if (pinctrl && gpio_is_valid(rts->io)) {
399
+	if (rfkill->pdata->pinctrl && gpio_is_valid(rts->io)) {
424
400
 		DBG("Disable UART_RTS\n");
425
-		pinctrl_select_state(pinctrl, rts->gpio_state);
401
+		pinctrl_select_state(rfkill->pdata->pinctrl, rts->gpio_state);
426
402
 		gpio_direction_output(rts->io, !rts->enable);
427
403
 	}
428
404
 
..
..
@@ -434,11 +410,12 @@
434
410
 	if (gpio_is_valid(wake_host_irq->gpio.io) && bt_power_state) {
435
411
 		DBG("enable irq for bt wakeup host\n");
436
412
 		enable_irq(wake_host_irq->irq);
437
-		enable_irq_wake(wake_host_irq->irq);
438
413
 	}
439
414
 
440
415
 #ifdef CONFIG_RFKILL_RESET
441
-	rfkill_set_states(rfkill->rfkill_dev, BT_BLOCKED, false);
416
+	rfkill_init_sw_state(rfkill->rfkill_dev, BT_BLOCKED);
417
+	rfkill_set_sw_state(rfkill->rfkill_dev, BT_BLOCKED);
418
+	rfkill_set_hw_state(rfkill->rfkill_dev, false);
442
419
 	rfkill_rk_set_power(rfkill, BT_BLOCKED);
443
420
 #endif
444
421
 
..
..
@@ -450,7 +427,6 @@
450
427
 	struct rfkill_rk_data *rfkill = g_rfkill;
451
428
 	struct rfkill_rk_irq *wake_host_irq;
452
429
 	struct rfkill_rk_gpio *rts;
453
-	struct pinctrl *pinctrl = rfkill->pdata->pinctrl;
454
430
 
455
431
 	DBG("Enter %s\n", __func__);
456
432
 
..
..
@@ -463,13 +439,12 @@
463
439
 	if (gpio_is_valid(wake_host_irq->gpio.io) && bt_power_state) {
464
440
 		LOG("** disable irq\n");
465
441
 		disable_irq(wake_host_irq->irq);
466
-		disable_irq_wake(wake_host_irq->irq);
467
442
 	}
468
443
 
469
-	if (pinctrl && gpio_is_valid(rts->io)) {
444
+	if (rfkill->pdata->pinctrl && gpio_is_valid(rts->io)) {
470
445
 		DBG("Enable UART_RTS\n");
471
446
 		gpio_direction_output(rts->io, rts->enable);
472
-		pinctrl_select_state(pinctrl, rts->default_state);
447
+		pinctrl_select_state(rfkill->pdata->pinctrl, rts->default_state);
473
448
 	}
474
449
 }
475
450
 
..
..
@@ -514,56 +489,11 @@
514
489
 		return -EFAULT;
515
490
 
516
491
 	DBG("btwrite %c\n", b);
492
+	/* HCI_DEV_WRITE */
517
493
 	if (b != '0')
518
494
 		rfkill_rk_sleep_bt(BT_WAKEUP);
519
495
 	else
520
496
 		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;
567
497
 
568
498
 	return count;
569
499
 }
..
..
@@ -655,50 +585,15 @@
655
585
 }
656
586
 #endif //CONFIG_OF
657
587
 
658
-static const struct file_operations bluesleep_lpm = {
659
-	.owner = THIS_MODULE,
660
-	.read = bluesleep_read_proc_lpm,
661
-	.write = bluesleep_write_proc_lpm,
588
+static const struct proc_ops bluesleep_lpm = {
589
+	.proc_read = bluesleep_read_proc_lpm,
590
+	.proc_write = bluesleep_write_proc_lpm,
662
591
 };
663
592
 
664
-static const struct file_operations bluesleep_btwrite = {
665
-	.owner = THIS_MODULE,
666
-	.read = bluesleep_read_proc_btwrite,
667
-	.write = bluesleep_write_proc_btwrite,
593
+static const struct proc_ops bluesleep_btwrite = {
594
+	.proc_read = bluesleep_read_proc_btwrite,
595
+	.proc_write = bluesleep_write_proc_btwrite,
668
596
 };
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
597
 
703
598
 static int rfkill_rk_probe(struct platform_device *pdev)
704
599
 {
..
..
@@ -751,7 +646,7 @@
751
646
 	}
752
647
 
753
648
 	/* read/write proc entries */
754
-	ent = proc_create("lpm", 0, sleep_dir, &bluesleep_lpm);
649
+	ent = proc_create("lpm", 0444, sleep_dir, &bluesleep_lpm);
755
650
 	if (!ent) {
756
651
 		LOG("Unable to create /proc/%s/lpm entry", PROC_DIR);
757
652
 		ret = -ENOMEM;
..
..
@@ -759,17 +654,9 @@
759
654
 	}
760
655
 
761
656
 	/* read/write proc entries */
762
-	ent = proc_create("btwrite", 0, sleep_dir, &bluesleep_btwrite);
657
+	ent = proc_create("btwrite", 0444, sleep_dir, &bluesleep_btwrite);
763
658
 	if (!ent) {
764
659
 		LOG("Unable to create /proc/%s/btwrite entry", PROC_DIR);
765
-		ret = -ENOMEM;
766
-		goto fail_alloc;
767
-	}
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
660
 		ret = -ENOMEM;
774
661
 		goto fail_alloc;
775
662
 	}
..
..
@@ -809,7 +696,9 @@
809
696
 	if (!rfkill->rfkill_dev)
810
697
 		goto fail_alloc;
811
698
 
812
-	rfkill_set_states(rfkill->rfkill_dev, BT_BLOCKED, false);
699
+	rfkill_init_sw_state(rfkill->rfkill_dev, BT_BLOCKED);
700
+	rfkill_set_sw_state(rfkill->rfkill_dev, BT_BLOCKED);
701
+	rfkill_set_hw_state(rfkill->rfkill_dev, false);
813
702
 	ret = rfkill_register(rfkill->rfkill_dev);
814
703
 	if (ret < 0)
815
704
 		goto fail_rfkill;
..
..
@@ -832,16 +721,12 @@
832
721
 
833
722
 	LOG("%s device registered.\n", pdata->name);
834
723
 
835
-	if (rfkill_rk_register_power_key() != 0)
836
-		goto fail_rfkill;
837
-
838
724
 	return 0;
839
725
 
840
726
 fail_rfkill:
841
727
 	rfkill_destroy(rfkill->rfkill_dev);
842
728
 fail_alloc:
843
729
 
844
-	remove_proc_entry("powerupkey", sleep_dir);
845
730
 	remove_proc_entry("btwrite", sleep_dir);
846
731
 	remove_proc_entry("lpm", sleep_dir);
847
732
 fail_setup_wake_irq:
..
..
@@ -860,11 +745,7 @@
860
745
 
861
746
 	rfkill_unregister(rfkill->rfkill_dev);
862
747
 	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);
866
748
 
867
-	input_unregister_device(power_key_dev);
868
749
 	cancel_delayed_work_sync(&rfkill->bt_sleep_delay_work);
869
750
 
870
751
 	// free gpio