aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/rc/ene_ir.c
diff options
context:
space:
mode:
authorDavid Härdeman <david@hardeman.nu>2010-10-29 15:08:23 -0400
committerMauro Carvalho Chehab <mchehab@redhat.com>2010-12-29 05:16:37 -0500
commitd8b4b5822f51e2142b731b42c81e3f03eec475b2 (patch)
treefce9a9b7ca5031adc95fbd6be118352fb2527da5 /drivers/media/rc/ene_ir.c
parent4c7b355df6e7f05304e05f6b7a286e59a5f1cc54 (diff)
[media] ir-core: make struct rc_dev the primary interface
This patch merges the ir_input_dev and ir_dev_props structs into a single struct called rc_dev. The drivers and various functions in rc-core used by the drivers are also changed to use rc_dev as the primary interface when dealing with rc-core. This means that the input_dev is abstracted away from the drivers which is necessary if we ever want to support multiple input devs per rc device. The new API is similar to what the input subsystem uses, i.e: rc_device_alloc() rc_device_free() rc_device_register() rc_device_unregister() [mchehab@redhat.com: Fix compilation on mceusb and cx231xx, due to merge conflicts] Signed-off-by: David Härdeman <david@hardeman.nu> Acked-by: Jarod Wilson <jarod@redhat.com> Tested-by: Jarod Wilson <jarod@redhat.com> Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Diffstat (limited to 'drivers/media/rc/ene_ir.c')
-rw-r--r--drivers/media/rc/ene_ir.c129
1 files changed, 60 insertions, 69 deletions
diff --git a/drivers/media/rc/ene_ir.c b/drivers/media/rc/ene_ir.c
index 7637babcd262..0a4151f03c7e 100644
--- a/drivers/media/rc/ene_ir.c
+++ b/drivers/media/rc/ene_ir.c
@@ -37,9 +37,7 @@
37#include <linux/interrupt.h> 37#include <linux/interrupt.h>
38#include <linux/sched.h> 38#include <linux/sched.h>
39#include <linux/slab.h> 39#include <linux/slab.h>
40#include <linux/input.h>
41#include <media/ir-core.h> 40#include <media/ir-core.h>
42#include <media/ir-common.h>
43#include "ene_ir.h" 41#include "ene_ir.h"
44 42
45static int sample_period; 43static int sample_period;
@@ -357,7 +355,7 @@ void ene_rx_sense_carrier(struct ene_device *dev)
357 ev.carrier_report = true; 355 ev.carrier_report = true;
358 ev.carrier = carrier; 356 ev.carrier = carrier;
359 ev.duty_cycle = duty_cycle; 357 ev.duty_cycle = duty_cycle;
360 ir_raw_event_store(dev->idev, &ev); 358 ir_raw_event_store(dev->rdev, &ev);
361 } 359 }
362} 360}
363 361
@@ -448,32 +446,32 @@ static void ene_rx_setup(struct ene_device *dev)
448 446
449select_timeout: 447select_timeout:
450 if (dev->rx_fan_input_inuse) { 448 if (dev->rx_fan_input_inuse) {
451 dev->props->rx_resolution = MS_TO_NS(ENE_FW_SAMPLE_PERIOD_FAN); 449 dev->rdev->rx_resolution = MS_TO_NS(ENE_FW_SAMPLE_PERIOD_FAN);
452 450
453 /* Fan input doesn't support timeouts, it just ends the 451 /* Fan input doesn't support timeouts, it just ends the
454 input with a maximum sample */ 452 input with a maximum sample */
455 dev->props->min_timeout = dev->props->max_timeout = 453 dev->rdev->min_timeout = dev->rdev->max_timeout =
456 MS_TO_NS(ENE_FW_SMPL_BUF_FAN_MSK * 454 MS_TO_NS(ENE_FW_SMPL_BUF_FAN_MSK *
457 ENE_FW_SAMPLE_PERIOD_FAN); 455 ENE_FW_SAMPLE_PERIOD_FAN);
458 } else { 456 } else {
459 dev->props->rx_resolution = MS_TO_NS(sample_period); 457 dev->rdev->rx_resolution = MS_TO_NS(sample_period);
460 458
461 /* Theoreticly timeout is unlimited, but we cap it 459 /* Theoreticly timeout is unlimited, but we cap it
462 * because it was seen that on one device, it 460 * because it was seen that on one device, it
463 * would stop sending spaces after around 250 msec. 461 * would stop sending spaces after around 250 msec.
464 * Besides, this is close to 2^32 anyway and timeout is u32. 462 * Besides, this is close to 2^32 anyway and timeout is u32.
465 */ 463 */
466 dev->props->min_timeout = MS_TO_NS(127 * sample_period); 464 dev->rdev->min_timeout = MS_TO_NS(127 * sample_period);
467 dev->props->max_timeout = MS_TO_NS(200000); 465 dev->rdev->max_timeout = MS_TO_NS(200000);
468 } 466 }
469 467
470 if (dev->hw_learning_and_tx_capable) 468 if (dev->hw_learning_and_tx_capable)
471 dev->props->tx_resolution = MS_TO_NS(sample_period); 469 dev->rdev->tx_resolution = MS_TO_NS(sample_period);
472 470
473 if (dev->props->timeout > dev->props->max_timeout) 471 if (dev->rdev->timeout > dev->rdev->max_timeout)
474 dev->props->timeout = dev->props->max_timeout; 472 dev->rdev->timeout = dev->rdev->max_timeout;
475 if (dev->props->timeout < dev->props->min_timeout) 473 if (dev->rdev->timeout < dev->rdev->min_timeout)
476 dev->props->timeout = dev->props->min_timeout; 474 dev->rdev->timeout = dev->rdev->min_timeout;
477} 475}
478 476
479/* Enable the device for receive */ 477/* Enable the device for receive */
@@ -504,7 +502,7 @@ static void ene_rx_enable(struct ene_device *dev)
504 ene_set_reg_mask(dev, ENE_FW1, ENE_FW1_ENABLE | ENE_FW1_IRQ); 502 ene_set_reg_mask(dev, ENE_FW1, ENE_FW1_ENABLE | ENE_FW1_IRQ);
505 503
506 /* enter idle mode */ 504 /* enter idle mode */
507 ir_raw_event_set_idle(dev->idev, true); 505 ir_raw_event_set_idle(dev->rdev, true);
508 dev->rx_enabled = true; 506 dev->rx_enabled = true;
509} 507}
510 508
@@ -518,7 +516,7 @@ static void ene_rx_disable(struct ene_device *dev)
518 /* disable hardware IRQ and firmware flag */ 516 /* disable hardware IRQ and firmware flag */
519 ene_clear_reg_mask(dev, ENE_FW1, ENE_FW1_ENABLE | ENE_FW1_IRQ); 517 ene_clear_reg_mask(dev, ENE_FW1, ENE_FW1_ENABLE | ENE_FW1_IRQ);
520 518
521 ir_raw_event_set_idle(dev->idev, true); 519 ir_raw_event_set_idle(dev->rdev, true);
522 dev->rx_enabled = false; 520 dev->rx_enabled = false;
523} 521}
524 522
@@ -805,10 +803,10 @@ static irqreturn_t ene_isr(int irq, void *data)
805 803
806 ev.duration = MS_TO_NS(hw_sample); 804 ev.duration = MS_TO_NS(hw_sample);
807 ev.pulse = pulse; 805 ev.pulse = pulse;
808 ir_raw_event_store_with_filter(dev->idev, &ev); 806 ir_raw_event_store_with_filter(dev->rdev, &ev);
809 } 807 }
810 808
811 ir_raw_event_handle(dev->idev); 809 ir_raw_event_handle(dev->rdev);
812unlock: 810unlock:
813 spin_unlock_irqrestore(&dev->hw_lock, flags); 811 spin_unlock_irqrestore(&dev->hw_lock, flags);
814 return retval; 812 return retval;
@@ -823,7 +821,7 @@ static void ene_setup_default_settings(struct ene_device *dev)
823 dev->learning_mode_enabled = learning_mode_force; 821 dev->learning_mode_enabled = learning_mode_force;
824 822
825 /* Set reasonable default timeout */ 823 /* Set reasonable default timeout */
826 dev->props->timeout = MS_TO_NS(150000); 824 dev->rdev->timeout = MS_TO_NS(150000);
827} 825}
828 826
829/* Upload all hardware settings at once. Used at load and resume time */ 827/* Upload all hardware settings at once. Used at load and resume time */
@@ -838,9 +836,9 @@ static void ene_setup_hw_settings(struct ene_device *dev)
838} 836}
839 837
840/* outside interface: called on first open*/ 838/* outside interface: called on first open*/
841static int ene_open(void *data) 839static int ene_open(struct rc_dev *rdev)
842{ 840{
843 struct ene_device *dev = (struct ene_device *)data; 841 struct ene_device *dev = rdev->priv;
844 unsigned long flags; 842 unsigned long flags;
845 843
846 spin_lock_irqsave(&dev->hw_lock, flags); 844 spin_lock_irqsave(&dev->hw_lock, flags);
@@ -850,9 +848,9 @@ static int ene_open(void *data)
850} 848}
851 849
852/* outside interface: called on device close*/ 850/* outside interface: called on device close*/
853static void ene_close(void *data) 851static void ene_close(struct rc_dev *rdev)
854{ 852{
855 struct ene_device *dev = (struct ene_device *)data; 853 struct ene_device *dev = rdev->priv;
856 unsigned long flags; 854 unsigned long flags;
857 spin_lock_irqsave(&dev->hw_lock, flags); 855 spin_lock_irqsave(&dev->hw_lock, flags);
858 856
@@ -861,9 +859,9 @@ static void ene_close(void *data)
861} 859}
862 860
863/* outside interface: set transmitter mask */ 861/* outside interface: set transmitter mask */
864static int ene_set_tx_mask(void *data, u32 tx_mask) 862static int ene_set_tx_mask(struct rc_dev *rdev, u32 tx_mask)
865{ 863{
866 struct ene_device *dev = (struct ene_device *)data; 864 struct ene_device *dev = rdev->priv;
867 dbg("TX: attempt to set transmitter mask %02x", tx_mask); 865 dbg("TX: attempt to set transmitter mask %02x", tx_mask);
868 866
869 /* invalid txmask */ 867 /* invalid txmask */
@@ -879,9 +877,9 @@ static int ene_set_tx_mask(void *data, u32 tx_mask)
879} 877}
880 878
881/* outside interface : set tx carrier */ 879/* outside interface : set tx carrier */
882static int ene_set_tx_carrier(void *data, u32 carrier) 880static int ene_set_tx_carrier(struct rc_dev *rdev, u32 carrier)
883{ 881{
884 struct ene_device *dev = (struct ene_device *)data; 882 struct ene_device *dev = rdev->priv;
885 u32 period = 2000000 / carrier; 883 u32 period = 2000000 / carrier;
886 884
887 dbg("TX: attempt to set tx carrier to %d kHz", carrier); 885 dbg("TX: attempt to set tx carrier to %d kHz", carrier);
@@ -900,9 +898,9 @@ static int ene_set_tx_carrier(void *data, u32 carrier)
900} 898}
901 899
902/*outside interface : set tx duty cycle */ 900/*outside interface : set tx duty cycle */
903static int ene_set_tx_duty_cycle(void *data, u32 duty_cycle) 901static int ene_set_tx_duty_cycle(struct rc_dev *rdev, u32 duty_cycle)
904{ 902{
905 struct ene_device *dev = (struct ene_device *)data; 903 struct ene_device *dev = rdev->priv;
906 dbg("TX: setting duty cycle to %d%%", duty_cycle); 904 dbg("TX: setting duty cycle to %d%%", duty_cycle);
907 dev->tx_duty_cycle = duty_cycle; 905 dev->tx_duty_cycle = duty_cycle;
908 ene_tx_set_carrier(dev); 906 ene_tx_set_carrier(dev);
@@ -910,9 +908,9 @@ static int ene_set_tx_duty_cycle(void *data, u32 duty_cycle)
910} 908}
911 909
912/* outside interface: enable learning mode */ 910/* outside interface: enable learning mode */
913static int ene_set_learning_mode(void *data, int enable) 911static int ene_set_learning_mode(struct rc_dev *rdev, int enable)
914{ 912{
915 struct ene_device *dev = (struct ene_device *)data; 913 struct ene_device *dev = rdev->priv;
916 unsigned long flags; 914 unsigned long flags;
917 if (enable == dev->learning_mode_enabled) 915 if (enable == dev->learning_mode_enabled)
918 return 0; 916 return 0;
@@ -926,9 +924,9 @@ static int ene_set_learning_mode(void *data, int enable)
926 return 0; 924 return 0;
927} 925}
928 926
929static int ene_set_carrier_report(void *data, int enable) 927static int ene_set_carrier_report(struct rc_dev *rdev, int enable)
930{ 928{
931 struct ene_device *dev = (struct ene_device *)data; 929 struct ene_device *dev = rdev->priv;
932 unsigned long flags; 930 unsigned long flags;
933 931
934 if (enable == dev->carrier_detect_enabled) 932 if (enable == dev->carrier_detect_enabled)
@@ -944,18 +942,20 @@ static int ene_set_carrier_report(void *data, int enable)
944} 942}
945 943
946/* outside interface: enable or disable idle mode */ 944/* outside interface: enable or disable idle mode */
947static void ene_set_idle(void *data, bool idle) 945static void ene_set_idle(struct rc_dev *rdev, bool idle)
948{ 946{
947 struct ene_device *dev = rdev->priv;
948
949 if (idle) { 949 if (idle) {
950 ene_rx_reset((struct ene_device *)data); 950 ene_rx_reset(dev);
951 dbg("RX: end of data"); 951 dbg("RX: end of data");
952 } 952 }
953} 953}
954 954
955/* outside interface: transmit */ 955/* outside interface: transmit */
956static int ene_transmit(void *data, int *buf, u32 n) 956static int ene_transmit(struct rc_dev *rdev, int *buf, u32 n)
957{ 957{
958 struct ene_device *dev = (struct ene_device *)data; 958 struct ene_device *dev = rdev->priv;
959 unsigned long flags; 959 unsigned long flags;
960 960
961 dev->tx_buffer = buf; 961 dev->tx_buffer = buf;
@@ -992,16 +992,13 @@ static int ene_transmit(void *data, int *buf, u32 n)
992static int ene_probe(struct pnp_dev *pnp_dev, const struct pnp_device_id *id) 992static int ene_probe(struct pnp_dev *pnp_dev, const struct pnp_device_id *id)
993{ 993{
994 int error = -ENOMEM; 994 int error = -ENOMEM;
995 struct ir_dev_props *ir_props; 995 struct rc_dev *rdev;
996 struct input_dev *input_dev;
997 struct ene_device *dev; 996 struct ene_device *dev;
998 997
999 /* allocate memory */ 998 /* allocate memory */
1000 input_dev = input_allocate_device();
1001 ir_props = kzalloc(sizeof(struct ir_dev_props), GFP_KERNEL);
1002 dev = kzalloc(sizeof(struct ene_device), GFP_KERNEL); 999 dev = kzalloc(sizeof(struct ene_device), GFP_KERNEL);
1003 1000 rdev = rc_allocate_device();
1004 if (!input_dev || !ir_props || !dev) 1001 if (!dev || !rdev)
1005 goto error1; 1002 goto error1;
1006 1003
1007 /* validate resources */ 1004 /* validate resources */
@@ -1054,24 +1051,25 @@ static int ene_probe(struct pnp_dev *pnp_dev, const struct pnp_device_id *id)
1054 if (!dev->hw_learning_and_tx_capable) 1051 if (!dev->hw_learning_and_tx_capable)
1055 learning_mode_force = false; 1052 learning_mode_force = false;
1056 1053
1057 ir_props->driver_type = RC_DRIVER_IR_RAW; 1054 rdev->driver_type = RC_DRIVER_IR_RAW;
1058 ir_props->allowed_protos = IR_TYPE_ALL; 1055 rdev->allowed_protos = IR_TYPE_ALL;
1059 ir_props->priv = dev; 1056 rdev->priv = dev;
1060 ir_props->open = ene_open; 1057 rdev->open = ene_open;
1061 ir_props->close = ene_close; 1058 rdev->close = ene_close;
1062 ir_props->s_idle = ene_set_idle; 1059 rdev->s_idle = ene_set_idle;
1063 1060 rdev->driver_name = ENE_DRIVER_NAME;
1064 dev->props = ir_props; 1061 rdev->map_name = RC_MAP_RC6_MCE;
1065 dev->idev = input_dev; 1062 rdev->input_name = "ENE eHome Infrared Remote Receiver";
1066 1063
1067 if (dev->hw_learning_and_tx_capable) { 1064 if (dev->hw_learning_and_tx_capable) {
1068 ir_props->s_learning_mode = ene_set_learning_mode; 1065 rdev->s_learning_mode = ene_set_learning_mode;
1069 init_completion(&dev->tx_complete); 1066 init_completion(&dev->tx_complete);
1070 ir_props->tx_ir = ene_transmit; 1067 rdev->tx_ir = ene_transmit;
1071 ir_props->s_tx_mask = ene_set_tx_mask; 1068 rdev->s_tx_mask = ene_set_tx_mask;
1072 ir_props->s_tx_carrier = ene_set_tx_carrier; 1069 rdev->s_tx_carrier = ene_set_tx_carrier;
1073 ir_props->s_tx_duty_cycle = ene_set_tx_duty_cycle; 1070 rdev->s_tx_duty_cycle = ene_set_tx_duty_cycle;
1074 ir_props->s_carrier_report = ene_set_carrier_report; 1071 rdev->s_carrier_report = ene_set_carrier_report;
1072 rdev->input_name = "ENE eHome Infrared Remote Transceiver";
1075 } 1073 }
1076 1074
1077 ene_rx_setup_hw_buffer(dev); 1075 ene_rx_setup_hw_buffer(dev);
@@ -1081,16 +1079,11 @@ static int ene_probe(struct pnp_dev *pnp_dev, const struct pnp_device_id *id)
1081 device_set_wakeup_capable(&pnp_dev->dev, true); 1079 device_set_wakeup_capable(&pnp_dev->dev, true);
1082 device_set_wakeup_enable(&pnp_dev->dev, true); 1080 device_set_wakeup_enable(&pnp_dev->dev, true);
1083 1081
1084 if (dev->hw_learning_and_tx_capable) 1082 error = rc_register_device(rdev);
1085 input_dev->name = "ENE eHome Infrared Remote Transceiver"; 1083 if (error < 0)
1086 else
1087 input_dev->name = "ENE eHome Infrared Remote Receiver";
1088
1089 error = -ENODEV;
1090 if (ir_input_register(input_dev, RC_MAP_RC6_MCE, ir_props,
1091 ENE_DRIVER_NAME))
1092 goto error; 1084 goto error;
1093 1085
1086 dev->rdev = rdev;
1094 ene_notice("driver has been succesfully loaded"); 1087 ene_notice("driver has been succesfully loaded");
1095 return 0; 1088 return 0;
1096error: 1089error:
@@ -1099,8 +1092,7 @@ error:
1099 if (dev && dev->hw_io >= 0) 1092 if (dev && dev->hw_io >= 0)
1100 release_region(dev->hw_io, ENE_IO_SIZE); 1093 release_region(dev->hw_io, ENE_IO_SIZE);
1101error1: 1094error1:
1102 input_free_device(input_dev); 1095 rc_free_device(rdev);
1103 kfree(ir_props);
1104 kfree(dev); 1096 kfree(dev);
1105 return error; 1097 return error;
1106} 1098}
@@ -1118,8 +1110,7 @@ static void ene_remove(struct pnp_dev *pnp_dev)
1118 1110
1119 free_irq(dev->irq, dev); 1111 free_irq(dev->irq, dev);
1120 release_region(dev->hw_io, ENE_IO_SIZE); 1112 release_region(dev->hw_io, ENE_IO_SIZE);
1121 ir_input_unregister(dev->idev); 1113 rc_unregister_device(dev->rdev);
1122 kfree(dev->props);
1123 kfree(dev); 1114 kfree(dev);
1124} 1115}
1125 1116