add driver 5G

hc

2024-01-31 f9004dbfff8a3fbbd7e2a88c8a4327c7f2f8e5b2

 kernel/drivers/i2c/busses/i2c-sprd.c
..
..
@@ -12,6 +12,7 @@
12
12
 #include <linux/init.h>
13
13
 #include <linux/interrupt.h>
14
14
 #include <linux/kernel.h>
15
+#include <linux/module.h>
15
16
 #include <linux/of.h>
16
17
 #include <linux/of_device.h>
17
18
 #include <linux/platform_device.h>
..
..
@@ -88,7 +89,6 @@
88
89
 	u32 count;
89
90
 	int irq;
90
91
 	int err;
91
-	bool is_suspended;
92
92
 };
93
93
 
94
94
 static void sprd_i2c_set_count(struct sprd_i2c *i2c_dev, u32 count)
..
..
@@ -290,10 +290,7 @@
290
290
 	struct sprd_i2c *i2c_dev = i2c_adap->algo_data;
291
291
 	int im, ret;
292
292
 
293
-	if (i2c_dev->is_suspended)
294
-		return -EBUSY;
295
-
296
-	ret = pm_runtime_get_sync(i2c_dev->dev);
293
+	ret = pm_runtime_resume_and_get(i2c_dev->dev);
297
294
 	if (ret < 0)
298
295
 		return ret;
299
296
 
..
..
@@ -346,9 +343,9 @@
346
343
 	writel(div1, i2c_dev->base + ADDR_DVD1);
347
344
 
348
345
 	/* Start hold timing = hold time(us) * source clock */
349
-	if (freq == 400000)
346
+	if (freq == I2C_MAX_FAST_MODE_FREQ)
350
347
 		writel((6 * apb_clk) / 10000000, i2c_dev->base + ADDR_STA0_DVD);
351
-	else if (freq == 100000)
348
+	else if (freq == I2C_MAX_STANDARD_MODE_FREQ)
352
349
 		writel((4 * apb_clk) / 1000000, i2c_dev->base + ADDR_STA0_DVD);
353
350
 }
354
351
 
..
..
@@ -475,9 +472,9 @@
475
472
 
476
473
 	i2c_dev->clk = devm_clk_get(i2c_dev->dev, "enable");
477
474
 	if (IS_ERR(i2c_dev->clk)) {
478
-		dev_warn(i2c_dev->dev, "i2c%d can't get the enable clock\n",
479
-			 i2c_dev->adap.nr);
480
-		i2c_dev->clk = NULL;
475
+		dev_err(i2c_dev->dev, "i2c%d can't get the enable clock\n",
476
+			i2c_dev->adap.nr);
477
+		return PTR_ERR(i2c_dev->clk);
481
478
 	}
482
479
 
483
480
 	return 0;
..
..
@@ -487,7 +484,6 @@
487
484
 {
488
485
 	struct device *dev = &pdev->dev;
489
486
 	struct sprd_i2c *i2c_dev;
490
-	struct resource *res;
491
487
 	u32 prop;
492
488
 	int ret;
493
489
 
..
..
@@ -497,23 +493,20 @@
497
493
 	if (!i2c_dev)
498
494
 		return -ENOMEM;
499
495
 
500
-	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
501
-	i2c_dev->base = devm_ioremap_resource(dev, res);
496
+	i2c_dev->base = devm_platform_ioremap_resource(pdev, 0);
502
497
 	if (IS_ERR(i2c_dev->base))
503
498
 		return PTR_ERR(i2c_dev->base);
504
499
 
505
500
 	i2c_dev->irq = platform_get_irq(pdev, 0);
506
-	if (i2c_dev->irq < 0) {
507
-		dev_err(&pdev->dev, "failed to get irq resource\n");
501
+	if (i2c_dev->irq < 0)
508
502
 		return i2c_dev->irq;
509
-	}
510
503
 
511
504
 	i2c_set_adapdata(&i2c_dev->adap, i2c_dev);
512
505
 	init_completion(&i2c_dev->complete);
513
506
 	snprintf(i2c_dev->adap.name, sizeof(i2c_dev->adap.name),
514
507
 		 "%s", "sprd-i2c");
515
508
 
516
-	i2c_dev->bus_freq = 100000;
509
+	i2c_dev->bus_freq = I2C_MAX_STANDARD_MODE_FREQ;
517
510
 	i2c_dev->adap.owner = THIS_MODULE;
518
511
 	i2c_dev->dev = dev;
519
512
 	i2c_dev->adap.retries = 3;
..
..
@@ -527,10 +520,14 @@
527
520
 		i2c_dev->bus_freq = prop;
528
521
 
529
522
 	/* We only support 100k and 400k now, otherwise will return error. */
530
-	if (i2c_dev->bus_freq != 100000 && i2c_dev->bus_freq != 400000)
523
+	if (i2c_dev->bus_freq != I2C_MAX_STANDARD_MODE_FREQ &&
524
+	    i2c_dev->bus_freq != I2C_MAX_FAST_MODE_FREQ)
531
525
 		return -EINVAL;
532
526
 
533
-	sprd_i2c_clk_init(i2c_dev);
527
+	ret = sprd_i2c_clk_init(i2c_dev);
528
+	if (ret)
529
+		return ret;
530
+
534
531
 	platform_set_drvdata(pdev, i2c_dev);
535
532
 
536
533
 	ret = clk_prepare_enable(i2c_dev->clk);
..
..
@@ -581,10 +578,12 @@
581
578
 
582
579
 	ret = pm_runtime_get_sync(i2c_dev->dev);
583
580
 	if (ret < 0)
584
-		return ret;
581
+		dev_err(&pdev->dev, "Failed to resume device (%pe)\n", ERR_PTR(ret));
585
582
 
586
583
 	i2c_del_adapter(&i2c_dev->adap);
587
-	clk_disable_unprepare(i2c_dev->clk);
584
+
585
+	if (ret >= 0)
586
+		clk_disable_unprepare(i2c_dev->clk);
588
587
 
589
588
 	pm_runtime_put_noidle(i2c_dev->dev);
590
589
 	pm_runtime_disable(i2c_dev->dev);
..
..
@@ -592,40 +591,34 @@
592
591
 	return 0;
593
592
 }
594
593
 
595
-static int __maybe_unused sprd_i2c_suspend_noirq(struct device *pdev)
594
+static int __maybe_unused sprd_i2c_suspend_noirq(struct device *dev)
596
595
 {
597
-	struct sprd_i2c *i2c_dev = dev_get_drvdata(pdev);
596
+	struct sprd_i2c *i2c_dev = dev_get_drvdata(dev);
598
597
 
599
-	i2c_lock_bus(&i2c_dev->adap, I2C_LOCK_ROOT_ADAPTER);
600
-	i2c_dev->is_suspended = true;
601
-	i2c_unlock_bus(&i2c_dev->adap, I2C_LOCK_ROOT_ADAPTER);
602
-
603
-	return pm_runtime_force_suspend(pdev);
598
+	i2c_mark_adapter_suspended(&i2c_dev->adap);
599
+	return pm_runtime_force_suspend(dev);
604
600
 }
605
601
 
606
-static int __maybe_unused sprd_i2c_resume_noirq(struct device *pdev)
602
+static int __maybe_unused sprd_i2c_resume_noirq(struct device *dev)
607
603
 {
608
-	struct sprd_i2c *i2c_dev = dev_get_drvdata(pdev);
604
+	struct sprd_i2c *i2c_dev = dev_get_drvdata(dev);
609
605
 
610
-	i2c_lock_bus(&i2c_dev->adap, I2C_LOCK_ROOT_ADAPTER);
611
-	i2c_dev->is_suspended = false;
612
-	i2c_unlock_bus(&i2c_dev->adap, I2C_LOCK_ROOT_ADAPTER);
613
-
614
-	return pm_runtime_force_resume(pdev);
606
+	i2c_mark_adapter_resumed(&i2c_dev->adap);
607
+	return pm_runtime_force_resume(dev);
615
608
 }
616
609
 
617
-static int __maybe_unused sprd_i2c_runtime_suspend(struct device *pdev)
610
+static int __maybe_unused sprd_i2c_runtime_suspend(struct device *dev)
618
611
 {
619
-	struct sprd_i2c *i2c_dev = dev_get_drvdata(pdev);
612
+	struct sprd_i2c *i2c_dev = dev_get_drvdata(dev);
620
613
 
621
614
 	clk_disable_unprepare(i2c_dev->clk);
622
615
 
623
616
 	return 0;
624
617
 }
625
618
 
626
-static int __maybe_unused sprd_i2c_runtime_resume(struct device *pdev)
619
+static int __maybe_unused sprd_i2c_runtime_resume(struct device *dev)
627
620
 {
628
-	struct sprd_i2c *i2c_dev = dev_get_drvdata(pdev);
621
+	struct sprd_i2c *i2c_dev = dev_get_drvdata(dev);
629
622
 	int ret;
630
623
 
631
624
 	ret = clk_prepare_enable(i2c_dev->clk);
..
..
@@ -660,8 +653,7 @@
660
653
 	},
661
654
 };
662
655
 
663
-static int sprd_i2c_init(void)
664
-{
665
-	return platform_driver_register(&sprd_i2c_driver);
666
-}
667
-arch_initcall_sync(sprd_i2c_init);
656
+module_platform_driver(sprd_i2c_driver);
657
+
658
+MODULE_DESCRIPTION("Spreadtrum I2C master controller driver");
659
+MODULE_LICENSE("GPL v2");