mk-rootfs.sh

hc

2023-12-11 072de836f53be56a70cecf70b43ae43b7ce17376

 kernel/drivers/iio/proximity/as3935.c
..
..
@@ -7,6 +7,7 @@
7
7
  */
8
8
 
9
9
 #include <linux/module.h>
10
+#include <linux/mod_devicetable.h>
10
11
 #include <linux/init.h>
11
12
 #include <linux/interrupt.h>
12
13
 #include <linux/delay.h>
..
..
@@ -14,7 +15,6 @@
14
15
 #include <linux/mutex.h>
15
16
 #include <linux/err.h>
16
17
 #include <linux/irq.h>
17
-#include <linux/gpio.h>
18
18
 #include <linux/spi/spi.h>
19
19
 #include <linux/iio/iio.h>
20
20
 #include <linux/iio/sysfs.h>
..
..
@@ -22,8 +22,6 @@
22
22
 #include <linux/iio/trigger_consumer.h>
23
23
 #include <linux/iio/buffer.h>
24
24
 #include <linux/iio/triggered_buffer.h>
25
-#include <linux/of_gpio.h>
26
-
27
25
 
28
26
 #define AS3935_AFE_GAIN		0x00
29
27
 #define AS3935_AFE_MASK		0x3F
..
..
@@ -349,21 +347,29 @@
349
347
 #define AS3935_PM_OPS NULL
350
348
 #endif
351
349
 
350
+static void as3935_stop_work(void *data)
351
+{
352
+	struct iio_dev *indio_dev = data;
353
+	struct as3935_state *st = iio_priv(indio_dev);
354
+
355
+	cancel_delayed_work_sync(&st->work);
356
+}
357
+
352
358
 static int as3935_probe(struct spi_device *spi)
353
359
 {
360
+	struct device *dev = &spi->dev;
354
361
 	struct iio_dev *indio_dev;
355
362
 	struct iio_trigger *trig;
356
363
 	struct as3935_state *st;
357
-	struct device_node *np = spi->dev.of_node;
358
364
 	int ret;
359
365
 
360
366
 	/* Be sure lightning event interrupt is specified */
361
367
 	if (!spi->irq) {
362
-		dev_err(&spi->dev, "unable to get event interrupt\n");
368
+		dev_err(dev, "unable to get event interrupt\n");
363
369
 		return -EINVAL;
364
370
 	}
365
371
 
366
-	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
372
+	indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
367
373
 	if (!indio_dev)
368
374
 		return -ENOMEM;
369
375
 
..
..
@@ -372,41 +378,36 @@
372
378
 
373
379
 	spi_set_drvdata(spi, indio_dev);
374
380
 	mutex_init(&st->lock);
375
-	INIT_DELAYED_WORK(&st->work, as3935_event_work);
376
381
 
377
-	ret = of_property_read_u32(np,
382
+	ret = device_property_read_u32(dev,
378
383
 			"ams,tuning-capacitor-pf", &st->tune_cap);
379
384
 	if (ret) {
380
385
 		st->tune_cap = 0;
381
-		dev_warn(&spi->dev,
382
-			"no tuning-capacitor-pf set, defaulting to %d",
386
+		dev_warn(dev, "no tuning-capacitor-pf set, defaulting to %d",
383
387
 			st->tune_cap);
384
388
 	}
385
389
 
386
390
 	if (st->tune_cap > MAX_PF_CAP) {
387
-		dev_err(&spi->dev,
388
-			"wrong tuning-capacitor-pf setting of %d\n",
391
+		dev_err(dev, "wrong tuning-capacitor-pf setting of %d\n",
389
392
 			st->tune_cap);
390
393
 		return -EINVAL;
391
394
 	}
392
395
 
393
-	ret = of_property_read_u32(np,
396
+	ret = device_property_read_u32(dev,
394
397
 			"ams,nflwdth", &st->nflwdth_reg);
395
398
 	if (!ret && st->nflwdth_reg > AS3935_NFLWDTH_MASK) {
396
-		dev_err(&spi->dev,
397
-			"invalid nflwdth setting of %d\n",
399
+		dev_err(dev, "invalid nflwdth setting of %d\n",
398
400
 			st->nflwdth_reg);
399
401
 		return -EINVAL;
400
402
 	}
401
403
 
402
-	indio_dev->dev.parent = &spi->dev;
403
404
 	indio_dev->name = spi_get_device_id(spi)->name;
404
405
 	indio_dev->channels = as3935_channels;
405
406
 	indio_dev->num_channels = ARRAY_SIZE(as3935_channels);
406
407
 	indio_dev->modes = INDIO_DIRECT_MODE;
407
408
 	indio_dev->info = &as3935_info;
408
409
 
409
-	trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d",
410
+	trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
410
411
 				      indio_dev->name, indio_dev->id);
411
412
 
412
413
 	if (!trig)
..
..
@@ -418,58 +419,44 @@
418
419
 	iio_trigger_set_drvdata(trig, indio_dev);
419
420
 	trig->ops = &iio_interrupt_trigger_ops;
420
421
 
421
-	ret = iio_trigger_register(trig);
422
+	ret = devm_iio_trigger_register(dev, trig);
422
423
 	if (ret) {
423
-		dev_err(&spi->dev, "failed to register trigger\n");
424
+		dev_err(dev, "failed to register trigger\n");
424
425
 		return ret;
425
426
 	}
426
427
 
427
-	ret = iio_triggered_buffer_setup(indio_dev, iio_pollfunc_store_time,
428
-		&as3935_trigger_handler, NULL);
428
+	ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
429
+					      iio_pollfunc_store_time,
430
+					      as3935_trigger_handler, NULL);
429
431
 
430
432
 	if (ret) {
431
-		dev_err(&spi->dev, "cannot setup iio trigger\n");
432
-		goto unregister_trigger;
433
+		dev_err(dev, "cannot setup iio trigger\n");
434
+		return ret;
433
435
 	}
434
436
 
435
437
 	calibrate_as3935(st);
436
438
 
437
-	ret = devm_request_irq(&spi->dev, spi->irq,
439
+	INIT_DELAYED_WORK(&st->work, as3935_event_work);
440
+	ret = devm_add_action(dev, as3935_stop_work, indio_dev);
441
+	if (ret)
442
+		return ret;
443
+
444
+	ret = devm_request_irq(dev, spi->irq,
438
445
 				&as3935_interrupt_handler,
439
446
 				IRQF_TRIGGER_RISING,
440
-				dev_name(&spi->dev),
447
+				dev_name(dev),
441
448
 				indio_dev);
442
449
 
443
450
 	if (ret) {
444
-		dev_err(&spi->dev, "unable to request irq\n");
445
-		goto unregister_buffer;
451
+		dev_err(dev, "unable to request irq\n");
452
+		return ret;
446
453
 	}
447
454
 
448
-	ret = iio_device_register(indio_dev);
455
+	ret = devm_iio_device_register(dev, indio_dev);
449
456
 	if (ret < 0) {
450
-		dev_err(&spi->dev, "unable to register device\n");
451
-		goto unregister_buffer;
457
+		dev_err(dev, "unable to register device\n");
458
+		return ret;
452
459
 	}
453
-	return 0;
454
-
455
-unregister_buffer:
456
-	iio_triggered_buffer_cleanup(indio_dev);
457
-
458
-unregister_trigger:
459
-	iio_trigger_unregister(st->trig);
460
-
461
-	return ret;
462
-}
463
-
464
-static int as3935_remove(struct spi_device *spi)
465
-{
466
-	struct iio_dev *indio_dev = spi_get_drvdata(spi);
467
-	struct as3935_state *st = iio_priv(indio_dev);
468
-
469
-	iio_device_unregister(indio_dev);
470
-	iio_triggered_buffer_cleanup(indio_dev);
471
-	iio_trigger_unregister(st->trig);
472
-
473
460
 	return 0;
474
461
 }
475
462
 
..
..
@@ -488,11 +475,10 @@
488
475
 static struct spi_driver as3935_driver = {
489
476
 	.driver = {
490
477
 		.name	= "as3935",
491
-		.of_match_table = of_match_ptr(as3935_of_match),
478
+		.of_match_table = as3935_of_match,
492
479
 		.pm	= AS3935_PM_OPS,
493
480
 	},
494
481
 	.probe		= as3935_probe,
495
-	.remove		= as3935_remove,
496
482
 	.id_table	= as3935_id,
497
483
 };
498
484
 module_spi_driver(as3935_driver);