redonkable
/
remarkable-linux
1
0
Fork 0
Code Releases Activity

otgcontrol: adjust to 8 char tab width and squeeze code within 80 chars, dyndbg 

Convert printk's to dev_dbg.

Fix tabs (8 chars) and wrap lines to fit within 80 chars, according to kernel
standards.
pull/10/head
Steinar Bakkemo 2020-10-08 20:03:39 +02:00
parent 5e2d8da943
commit d6cdbfc9bb
12 changed files with 1543 additions and 569 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/misc/rm-otgcontrol/Makefile
View File

@ -5,3 +5,5 @@ otgcontrol-objs += otgcontrol_fsm.o
otgcontrol-objs += otgcontrol_onewire.o otgcontrol-objs += otgcontrol_onewire.o
otgcontrol-objs += otgcontrol_charging_ctrl.o otgcontrol-objs += otgcontrol_charging_ctrl.o
otgcontrol-objs += otgcontrol_dr_mode.o otgcontrol-objs += otgcontrol_dr_mode.o
ccflags-$(CONFIG_RM_OTGCONTROL) += -DDEBUG

56
drivers/misc/rm-otgcontrol/otgcontrol_charging_ctrl.c
View File

@ -1,62 +1,80 @@
#include "otgcontrol_charging_ctrl.h" #include "otgcontrol_charging_ctrl.h"
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/printk.h>
#include <linux/power_supply.h> #include <linux/power_supply.h>
int otgcontrol_change_otg_charge_mode(struct rm_otgcontrol_data *otgc_data, int mode) int otgcontrol_change_otg_charge_mode(struct rm_otgcontrol_data *otgc_data,
int mode)
{ {
int ret; int ret;
union power_supply_propval property_val; union power_supply_propval property_val;
printk("%s: Enter\n", __func__);
switch(mode) switch(mode)
{ {
case OTG1_CHARGERMODE_CHARGE: case OTG1_CHARGERMODE_CHARGE:
printk("%s: Setting OTG1 chargermode (CHARGE)\n", __func__); dev_dbg(otgc_data->dev,
"%s: Setting OTG1 chargermode (CHARGE)\n",
__func__);
property_val.intval = POWER_SUPPLY_MODE_CHARGER; property_val.intval = POWER_SUPPLY_MODE_CHARGER;
ret = power_supply_set_property(otgc_data->pdata->vbus_supply, ret = power_supply_set_property(otgc_data->pdata->vbus_supply,
POWER_SUPPLY_PROP_CHARGER_MODE, POWER_SUPPLY_PROP_CHARGER_MODE,
&property_val); &property_val);
if (ret < 0) { if (ret < 0) {
printk("%s: Failed to set charger mode\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to set charger mode\n",
__func__);
return ret; return ret;
} }
property_val.intval = 1; property_val.intval = 1;
ret = power_supply_set_property(otgc_data->pdata->vbus_supply, ret = power_supply_set_property(otgc_data->pdata->vbus_supply,
POWER_SUPPLY_PROP_ONLINE, POWER_SUPPLY_PROP_ONLINE,
&property_val); &property_val);
if (ret < 0) { if (ret < 0) {
printk("%s: Failed to enable charging after changing charger mode\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to enable charging after "
"changing charger mode\n",
__func__);
return ret; return ret;
} }
break; break;
case OTG1_CHARGERMODE_OTG: case OTG1_CHARGERMODE_OTG:
printk("%s: Setting OTG1 chargermode (OTG)\n", __func__); dev_dbg(otgc_data->dev,
"%s: Setting OTG1 chargermode (OTG)\n",
__func__);
property_val.intval = POWER_SUPPLY_MODE_OTG_SUPPLY; property_val.intval = POWER_SUPPLY_MODE_OTG_SUPPLY;
ret = power_supply_set_property(otgc_data->pdata->vbus_supply, ret = power_supply_set_property(otgc_data->pdata->vbus_supply,
POWER_SUPPLY_PROP_CHARGER_MODE, POWER_SUPPLY_PROP_CHARGER_MODE,
&property_val); &property_val);
if (ret < 0) { if (ret < 0) {
printk("%s: Failed to set charger mode\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to set charger mode\n",
__func__);
return ret; return ret;
} }
property_val.intval = 1; property_val.intval = 1;
ret = power_supply_set_property(otgc_data->pdata->vbus_supply, ret = power_supply_set_property(otgc_data->pdata->vbus_supply,
POWER_SUPPLY_PROP_ONLINE, POWER_SUPPLY_PROP_ONLINE,
&property_val); &property_val);
if (ret < 0) { if (ret < 0) {
printk("%s: Failed to enable charging after changing charger mode\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to enable charging after changing "
"charger mode\n",
__func__);
return ret; return ret;
} }
break; break;
default: default:
printk("%s: Unable to set OTG1 chargermode (invalid mode %d)", __func__, mode); dev_dbg(otgc_data->dev,
"%s: Unable to set OTG1 chargermode (invalid mode %d)",
__func__, mode);
return -EINVAL; return -EINVAL;
} }

6
drivers/misc/rm-otgcontrol/otgcontrol_charging_ctrl.h
View File

@ -3,10 +3,10 @@
#include <linux/rm-otgcontrol.h> #include <linux/rm-otgcontrol.h>
#define OTG1_CHARGERMODE_CHARGE 0 #define OTG1_CHARGERMODE_CHARGE 0
#define OTG1_CHARGERMODE_OTG 1 #define OTG1_CHARGERMODE_OTG 1
int otgcontrol_change_otg_charge_mode(struct rm_otgcontrol_data *otgc_data, int otgcontrol_change_otg_charge_mode(struct rm_otgcontrol_data *otgc_data,
int mode); int mode);
#endif /* __OTGCONTROL_CHARGING_CTRL_H__ */ #endif /* __OTGCONTROL_CHARGING_CTRL_H__ */

54
drivers/misc/rm-otgcontrol/otgcontrol_dr_mode.c
View File

@ -12,18 +12,34 @@ int otgcontrol_init_extcon(struct rm_otgcontrol_data *otgc_data)
{ {
int ret; int ret;
printk("%s: Allocating extcon device\n", __func__); dev_dbg(otgc_data->dev,
otgc_data->extcon_dev = devm_extcon_dev_allocate(otgc_data->dev, usb_extcon_cable); "%s: Allocating extcon device\n",
__func__);
otgc_data->extcon_dev = devm_extcon_dev_allocate(otgc_data->dev,
usb_extcon_cable);
if (IS_ERR(otgc_data->extcon_dev)) { if (IS_ERR(otgc_data->extcon_dev)) {
dev_err(otgc_data->dev, "%s: failed to allocate extcon device\n", __func__); dev_err(otgc_data->dev,
"%s: failed to allocate extcon device\n",
__func__);
return -ENOMEM; return -ENOMEM;
} }
printk("%s: Registering extcon device\n", __func__); dev_dbg(otgc_data->dev,
"%s: Registering extcon device\n",
__func__);
ret = devm_extcon_dev_register(otgc_data->dev, otgc_data->extcon_dev); ret = devm_extcon_dev_register(otgc_data->dev, otgc_data->extcon_dev);
if (ret < 0) { if (ret < 0) {
dev_err(otgc_data->dev, "%s: Failed to register extcon device\n", __func__); dev_err(otgc_data->dev,
printk("%s: De-allocating extcon device\n", __func__); "%s: Failed to register extcon device\n",
__func__);
dev_dbg(otgc_data->dev,
"%s: De-allocating extcon device\n",
__func__);
kfree(otgc_data->extcon_dev); kfree(otgc_data->extcon_dev);
otgc_data->extcon_dev = NULL; otgc_data->extcon_dev = NULL;
return ret; return ret;
@ -46,17 +62,33 @@ int otgcontrol_set_dr_mode(struct rm_otgcontrol_data *otgc_data, int mode)
switch(mode) switch(mode)
{ {
case OTG1_DR_MODE__DEVICE: case OTG1_DR_MODE__DEVICE:
printk("%s: Switching OTG1 DR mode -> DEVICE\n", __func__); dev_dbg(otgc_data->dev,
return extcon_set_state_sync(otgc_data->extcon_dev, EXTCON_USB_HOST, false); "%s: Switching OTG1 DR mode -> DEVICE\n",
__func__);
return extcon_set_state_sync(otgc_data->extcon_dev,
EXTCON_USB_HOST,
false);
break; break;
case OTG1_DR_MODE__HOST: case OTG1_DR_MODE__HOST:
printk("%s: Switching OTG1 DR mode -> HOST\n", __func__); dev_dbg(otgc_data->dev,
return extcon_set_state_sync(otgc_data->extcon_dev, EXTCON_USB_HOST, true); "%s: Switching OTG1 DR mode -> HOST\n",
__func__);
return extcon_set_state_sync(otgc_data->extcon_dev,
EXTCON_USB_HOST,
true);
break; break;
default: default:
printk("%s: unable to switch OTG1 DR mode (unknown mode %d)\n", __func__, mode); dev_dbg(otgc_data->dev,
"%s: unable to switch OTG1 DR mode (unknown mode %d)\n",
__func__,
mode);
return -EINVAL; return -EINVAL;
} }
return 0; return 0;

4
drivers/misc/rm-otgcontrol/otgcontrol_dr_mode.h
View File

@ -3,8 +3,8 @@
#include <linux/rm-otgcontrol.h> #include <linux/rm-otgcontrol.h>
#define OTG1_DR_MODE__DEVICE 0 #define OTG1_DR_MODE__DEVICE 0
#define OTG1_DR_MODE__HOST 1 #define OTG1_DR_MODE__HOST 1
int otgcontrol_init_extcon(struct rm_otgcontrol_data *otgc_data); int otgcontrol_init_extcon(struct rm_otgcontrol_data *otgc_data);
void otgcontrol_uninit_extcon(struct rm_otgcontrol_data *otgc_data); void otgcontrol_uninit_extcon(struct rm_otgcontrol_data *otgc_data);

1106
drivers/misc/rm-otgcontrol/otgcontrol_fsm.c
View File

File diff suppressed because it is too large Load Diff

4
drivers/misc/rm-otgcontrol/otgcontrol_fsm.h
View File

@ -4,7 +4,9 @@
#include <linux/rm-otgcontrol.h> #include <linux/rm-otgcontrol.h>
int otgcontrol_init_fsm(struct rm_otgcontrol_data *otgc_data); int otgcontrol_init_fsm(struct rm_otgcontrol_data *otgc_data);
int otgcontrol_handleInput(struct rm_otgcontrol_data *otgc_data, int signal, void *param); int otgcontrol_handleInput(struct rm_otgcontrol_data *otgc_data,
int signal,
void *param);
#define OTG_MODE__MANUAL_CONTROL 0 #define OTG_MODE__MANUAL_CONTROL 0
#define OTG_MODE__ONEWIRE_AUTH 1 #define OTG_MODE__ONEWIRE_AUTH 1

252
drivers/misc/rm-otgcontrol/otgcontrol_main.c
View File

@ -7,15 +7,13 @@
* Released under the GPL version 2 only. * Released under the GPL version 2 only.
* *
*/ */
/* Internal includes */
#include <linux/rm-otgcontrol.h>
#include "otgcontrol_sysfs.h" #include "otgcontrol_sysfs.h"
#include "otgcontrol_fsm.h" #include "otgcontrol_fsm.h"
#include "otgcontrol_dr_mode.h" #include "otgcontrol_dr_mode.h"
#include "otgcontrol_onewire.h" #include "otgcontrol_onewire.h"
/* Required Linux includes */ #include <linux/rm-otgcontrol.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/version.h> #include <linux/version.h>
#include <linux/module.h> #include <linux/module.h>
@ -31,50 +29,63 @@
#include <linux/string.h> #include <linux/string.h>
#include <linux/gpio.h> #include <linux/gpio.h>
#include <linux/of_gpio.h> #include <linux/of_gpio.h>
/* Sysfs */
#include <linux/kobject.h>
/* Device Tree */
#include <linux/io.h> #include <linux/io.h>
#include <linux/of.h> #include <linux/of.h>
#include <linux/of_irq.h> #include <linux/of_irq.h>
#include <linux/kobject.h>
/* Linking to charger/vbus supply driver */
#include <linux/power_supply.h> #include <linux/power_supply.h>
/* Faking of VID signal to otg driver */
#include <linux/extcon.h> #include <linux/extcon.h>
static int rm_otgcontrol_init(struct rm_otgcontrol_data *otgc_data) static int rm_otgcontrol_init(struct rm_otgcontrol_data *otgc_data)
{ {
int ret = 0; int ret = 0;
printk("%s: Initiating sysfs nodes\n", __func__); dev_dbg(otgc_data->dev,
"%s: Initiating sysfs nodes\n",
__func__);
ret = otgcontrol_init_sysfs_nodes(otgc_data); ret = otgcontrol_init_sysfs_nodes(otgc_data);
if (ret < 0) if (ret < 0)
return ret; return ret;
printk("%s: Initiating extcon device to control USB OTG dr mode\n", __func__); dev_dbg(otgc_data->dev,
"%s: Initiating extcon device to control USB OTG dr mode\n",
__func__);
ret = otgcontrol_init_extcon(otgc_data); ret = otgcontrol_init_extcon(otgc_data);
if (ret < 0) { if (ret < 0) {
printk("%s: Failed to initiate extron (%d)\n", __func__, ret); dev_err(otgc_data->dev,
"%s: Failed to initiate extron (%d)\n",
__func__, ret);
return ret; return ret;
} }
printk("%s: Initiating onewire state and setting to default state (GPIO)\n", __func__); dev_dbg(otgc_data->dev,
"%s: Initiating onewire state and setting to default state "
"(GPIO)\n",
__func__);
ret = otgcontrol_init_one_wire_mux_state(otgc_data); ret = otgcontrol_init_one_wire_mux_state(otgc_data);
if (ret < 0) { if (ret < 0) {
printk("%s: Failed to initiate onewire pincontrol configuration\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to initiate onewire pincontrol "
"configuration\n",
__func__);
return ret; return ret;
} }
printk("%s: Initiating one-wire gpio irq\n", __func__); dev_dbg(otgc_data->dev,
"%s: Initiating one-wire gpio irq\n",
__func__);
ret = otgcontrol_init_gpio_irq(otgc_data); ret = otgcontrol_init_gpio_irq(otgc_data);
if (ret < 0) if (ret < 0)
return ret; return ret;
printk("%s: Initiating fsm to start in AUTHORIZED MODE !!\n", __func__); dev_dbg(otgc_data->dev,
"%s: Initiating fsm to start in AUTHORIZED MODE !!\n",
__func__);
ret = otgcontrol_init_fsm(otgc_data); ret = otgcontrol_init_fsm(otgc_data);
return ret; return ret;
} }
@ -88,61 +99,111 @@ static int rm_otgcontrol_parse_dt(struct rm_otgcontrol_data *otgc_data)
const char *vbus_supply_name; const char *vbus_supply_name;
int ret = 0; int ret = 0;
printk("[---- SBA ----] %s: Enter\n", __func__); dev_dbg(otgc_data->dev,
"%s: Enter\n",
__func__);
if (of_find_property(np, "vbus-supply", NULL)) { if (of_find_property(np, "vbus-supply", NULL)) {
printk("%s: Found vbus-supply property, trying to get get vbus powersupply by phandle\n", __func__); dev_dbg(otgc_data->dev,
pdata->vbus_supply = power_supply_get_by_phandle(np, "vbus-supply"); "%s: Found vbus-supply property, "
"trying to get get vbus powersupply by phandle\n",
__func__);
pdata->vbus_supply = power_supply_get_by_phandle(np,
"vbus-supply");
if (IS_ERR_OR_NULL(pdata->vbus_supply)) { if (IS_ERR_OR_NULL(pdata->vbus_supply)) {
printk("[---- SBA ----] %s: vbus supply not ready, defering probe\n", __func__); dev_dbg(otgc_data->dev,
"%s: vbus supply not ready, defering probe\n",
__func__);
return -EPROBE_DEFER; return -EPROBE_DEFER;
} }
} }
else if (of_find_property(np, "vbus-supply-name", NULL)) { else if (of_find_property(np, "vbus-supply-name", NULL)) {
printk("[---- SBA ----] %s: Found vbus-supply-name property, trying to read it\n", __func__); dev_dbg(otgc_data->dev,
ret = of_property_read_string(np, "vbus-supply-name", &vbus_supply_name); "%s: Found vbus-supply-name property, "
"trying to read it\n",
__func__);
ret = of_property_read_string(np,
"vbus-supply-name",
&vbus_supply_name);
if (ret) { if (ret) {
printk("[---- SBA ----] %s: Failed to read property vbus-supply-name (code %d)\n", __func__, ret); dev_err(otgc_data->dev,
"%s: Failed to read property vbus-supply-name "
"(code %d)\n",
__func__, ret);
return -EINVAL; return -EINVAL;
} }
printk("[---- SBA ----] %s: Read vbus-supply-name: %s, trying to get reference to it\n", __func__, vbus_supply_name); dev_dbg(otgc_data->dev,
"%s: Read vbus-supply-name: %s, "
"trying to get reference to it\n",
__func__, vbus_supply_name);
pdata->vbus_supply = power_supply_get_by_name(vbus_supply_name); pdata->vbus_supply = power_supply_get_by_name(vbus_supply_name);
if (IS_ERR(pdata->vbus_supply)) { if (IS_ERR(pdata->vbus_supply)) {
printk("[---- SBA ----] %s: vbus supply not ready, defering probe\n", __func__); dev_dbg(otgc_data->dev,
"%s: vbus supply not ready, defering probe\n",
__func__);
return -EPROBE_DEFER; return -EPROBE_DEFER;
} }
} }
else { else {
printk("[---- SBA ----] %s: Required vbus-supply-name property not given !\n", __func__); dev_dbg(otgc_data->dev,
"%s: Required vbus-supply-name property not given !\n",
__func__);
return -EINVAL; return -EINVAL;
} }
printk("[---- SBA ----] %s: Got pointer to vbus-supply\n", __func__);
dev_dbg(otgc_data->dev,
"%s: Got pointer to vbus-supply\n",
__func__);
if (of_find_property(np, "one-wire-tty-name", NULL)) { if (of_find_property(np, "one-wire-tty-name", NULL)) {
printk("[---- SBA ----] %s: Found one-wire-tty-name property, trying to read it\n", __func__); dev_dbg(otgc_data->dev,
ret = of_property_read_string(np, "one-wire-tty-name", &otgc_data->one_wire_tty_name); "%s: Found one-wire-tty-name property, "
"trying to read it\n",
__func__);
ret = of_property_read_string(np,
"one-wire-tty-name",
&otgc_data->one_wire_tty_name);
if (ret) { if (ret) {
printk("[---- SBA ----] %s: Failed to read property one-wire-tty-name (code %d)\n", __func__, ret); dev_err(otgc_data->dev,
"%s: Failed to read property one-wire-tty-name "
"(code %d)\n",
__func__, ret);
return -EINVAL; return -EINVAL;
} }
} }
else { else {
printk("%s: required property one-wire-tty-name not given !\n", __func__); dev_dbg(otgc_data->dev,
"%s: required property one-wire-tty-name not given !\n",
__func__);
return -EINVAL; return -EINVAL;
} }
if (of_find_property(np, "one-wire-gpios", NULL)) { if (of_find_property(np, "one-wire-gpios", NULL)) {
printk("[---- SBA ----] %s: Found one-wire-gpio property, trying to read it\n", __func__); dev_dbg(otgc_data->dev,
otgc_data->one_wire_gpio = devm_gpiod_get(otgc_data->dev, "one-wire", GPIOD_IN); "%s: Found one-wire-gpio property, trying to read it\n",
__func__);
otgc_data->one_wire_gpio = devm_gpiod_get(otgc_data->dev,
"one-wire",
GPIOD_IN);
if (IS_ERR(otgc_data->one_wire_gpio)) { if (IS_ERR(otgc_data->one_wire_gpio)) {
printk("%s: Failed to read property one-wire-gpio (code %ld)\n", __func__, PTR_ERR(otgc_data->one_wire_gpio)); dev_err(otgc_data->dev,
"%s: Failed to read property one-wire-gpio "
"(code %ld)\n",
__func__,
PTR_ERR(otgc_data->one_wire_gpio));
return PTR_ERR(otgc_data->one_wire_gpio); return PTR_ERR(otgc_data->one_wire_gpio);
} }
} }
else { else {
printk("%s: required property one-wire-gpio not given !\n", __func__); dev_dbg(otgc_data->dev,
"%s: required property one-wire-gpio not given !\n",
__func__);
return -EINVAL; return -EINVAL;
} }
@ -157,21 +218,35 @@ static int rm_otgcontrol_probe(struct platform_device *pdev)
int ret = 0; int ret = 0;
printk("[---- SBA ----] %s: Enter:\n", __func__); dev_dbg(&pdev->dev,
"%s: rM OTGCONTROL Driver Loading\n",
__func__);
pr_info("%s: rM OTGCONTROL Driver Loading\n", __func__); dev_dbg(&pdev->dev,
"%s: Allocating otgcontrol_data\n",
__func__);
printk("[---- SBA ----] %s: Allocating otgcontrol_data\n", __func__); otgc_data = devm_kzalloc(&pdev->dev,
otgc_data = devm_kzalloc(&pdev->dev, sizeof(struct rm_otgcontrol_data), GFP_KERNEL); sizeof(struct rm_otgcontrol_data),
GFP_KERNEL);
if (!otgc_data) { if (!otgc_data) {
printk("[---- SBA ----] %s: Failed to allocate otgc_data\n", __func__); dev_err(&pdev->dev,
"%s: Failed to allocate otgc_data\n",
__func__);
return -ENOMEM; return -ENOMEM;
} }
printk("[---- SBA ----] %s: Allocating otgcontrol_data\n", __func__); dev_dbg(&pdev->dev,
pdata = devm_kzalloc(&pdev->dev, sizeof(struct rm_otgcontrol_platform_data), GFP_KERNEL); "%s: Allocating otgcontrol_data\n",
__func__);
pdata = devm_kzalloc(&pdev->dev,
sizeof(struct rm_otgcontrol_platform_data),
GFP_KERNEL);
if (unlikely(!pdata)) { if (unlikely(!pdata)) {
pr_err("[---- SBA ----] %s: Failed to allocate pdata\n", __func__); dev_err(&pdev->dev,
"%s: Failed to allocate pdata\n",
__func__);
pdata = ERR_PTR(-ENOMEM); pdata = ERR_PTR(-ENOMEM);
ret = -ENOMEM; ret = -ENOMEM;
goto error_1; goto error_1;
@ -181,24 +256,46 @@ static int rm_otgcontrol_probe(struct platform_device *pdev)
otgc_data->pdata = pdata; otgc_data->pdata = pdata;
#if defined(CONFIG_OF) #if defined(CONFIG_OF)
printk("[---- SBA ---] %s: Reading platform data from devicetree\n", __func__); dev_dbg(&pdev->dev,
"%s: Reading platform data from devicetree\n",
__func__);
ret = rm_otgcontrol_parse_dt(otgc_data); ret = rm_otgcontrol_parse_dt(otgc_data);
if (ret < 0) { if (ret < 0) {
pr_err("[---- SBA ----] %s: Failed to load platform data from devicetree\n", __func__); dev_err(&pdev->dev,
"%s: Failed to load platform data from devicetree, "
"code %d\n",
__func__,
ret);
goto error_2; goto error_2;
} }
#else #else
printk("[---- SBA ----] %s: Driver does not support non-dt configuration\n", __func__); dev_dbg(&pdev->dev,
"%s: Driver does not support non-dt configuration\n",
__func__);
ret = -ENOTSUP; ret = -ENOTSUP;
goto error_2; goto error_2;
#endif #endif
printk("[---- SBA ----] %s: Setting otgc_data reference in pdev, and initiating\n", __func__); dev_dbg(&pdev->dev,
"%s: Setting otgc_data reference in pdev, and initiating\n",
__func__);
ret = rm_otgcontrol_init(otgc_data); ret = rm_otgcontrol_init(otgc_data);
if(ret < 0) if(ret < 0) {
dev_err(&pdev->dev,
"%s: Failed to init otgcontrol, "
"code %d\n",
__func__,
ret);
goto error_3; goto error_3;
}
platform_set_drvdata(pdev, otgc_data); platform_set_drvdata(pdev, otgc_data);
dev_info(&pdev->dev,
"Loaded successfully !\n");
return 0; return 0;
error_3: error_3:
@ -220,24 +317,34 @@ static int rm_otgcontrol_remove(struct platform_device *pdev)
{ {
struct rm_otgcontrol_data *otgc_data = platform_get_drvdata(pdev); struct rm_otgcontrol_data *otgc_data = platform_get_drvdata(pdev);
printk("[---- SBA ----]otgcontrol1 %s Enter:\n", __func__); dev_dbg(otgc_data->dev,
"%s: Un-initializing sysfs nodes\n",
printk("%s: Un-initializing sysfs nodes\n", __func__); __func__);
otgcontrol_uninit_sysfs_nodes(otgc_data); otgcontrol_uninit_sysfs_nodes(otgc_data);
printk("%s: Un-initializing extcon device\n", __func__); dev_dbg(otgc_data->dev,
"%s: Un-initializing extcon device\n",
__func__);
otgcontrol_uninit_extcon(otgc_data); otgcontrol_uninit_extcon(otgc_data);
printk("%s: Un-initializing one-wire pinctrl\n", __func__); dev_dbg(otgc_data->dev,
"%s: Un-initializing one-wire pinctrl\n",
__func__);
otgcontrol_uninit_one_wire_mux_state(otgc_data); otgcontrol_uninit_one_wire_mux_state(otgc_data);
printk("%s: Un-initialize gpio irq\n", __func__); dev_dbg(otgc_data->dev,
"%s: Un-initialize gpio irq\n",
__func__);
otgcontrol_uninit_gpio_irq(otgc_data); otgcontrol_uninit_gpio_irq(otgc_data);
printk("%s: Freeing otgc->pdata\n", __func__); dev_dbg(otgc_data->dev,
"%s: Freeing otgc->pdata\n",
__func__);
devm_kfree(&pdev->dev, otgc_data->pdata); devm_kfree(&pdev->dev, otgc_data->pdata);
printk("%s: Freeing otgc\n", __func__); dev_dbg(otgc_data->dev,
"%s: Freeing otgc\n",
__func__);
devm_kfree(&pdev->dev, otgc_data); devm_kfree(&pdev->dev, otgc_data);
return 0; return 0;
@ -246,14 +353,14 @@ static int rm_otgcontrol_remove(struct platform_device *pdev)
#if defined CONFIG_PM #if defined CONFIG_PM
static int rm_otgcontrol_suspend(struct device *dev) static int rm_otgcontrol_suspend(struct device *dev)
{ {
printk("[---- SBA ----] %s Enter:\n", __func__); dev_dbg(dev, "%s Enter:\n", __func__);
return 0; return 0;
} }
static int rm_otgcontrol_resume(struct device *dev) static int rm_otgcontrol_resume(struct device *dev)
{ {
printk("[---- SBA ----] %s Enter:\n", __func__); dev_dbg(dev, "%s Enter:\n", __func__);
return 0; return 0;
} }
@ -271,12 +378,12 @@ MODULE_DEVICE_TABLE(of, rm_otgcontrol_dt_ids);
#endif #endif
static SIMPLE_DEV_PM_OPS(rm_otgcontrol_pm_ops, static SIMPLE_DEV_PM_OPS(rm_otgcontrol_pm_ops,
rm_otgcontrol_suspend, rm_otgcontrol_suspend,
rm_otgcontrol_resume); rm_otgcontrol_resume);
static struct platform_driver rm_otgcontrol_driver = { static struct platform_driver rm_otgcontrol_driver = {
.driver = { .driver = {
.name = "rM OTG Control", .name = "rm_otg_control",
.owner = THIS_MODULE, .owner = THIS_MODULE,
#ifdef CONFIG_PM #ifdef CONFIG_PM
.pm = &rm_otgcontrol_pm_ops, .pm = &rm_otgcontrol_pm_ops,
@ -293,17 +400,23 @@ static int __init otgcontrol_init(void)
{ {
int ret; int ret;
printk("%s: Registering platform driver 'rm-otgcontrol'\n", __func__); pr_debug("%s: Registering platform driver 'rm-otgcontrol'\n",
__func__);
ret = platform_driver_register(&rm_otgcontrol_driver); ret = platform_driver_register(&rm_otgcontrol_driver);
if (ret < 0) if (ret < 0)
printk("%s: Failed to register platform driver 'rm-otgcontrol', code %d\n", __func__, ret); pr_err("%s: Failed to register platform driver, code %d\n",
__func__,
ret);
return ret; return ret;
} }
static void __exit otgcontrol_exit(void) static void __exit otgcontrol_exit(void)
{ {
printk("%s: Unregistering platform driver 'rm-otgcontrol'\n", __func__); pr_debug("%s: Unregistering platform driver 'rm-otgcontrol'\n",
__func__);
platform_driver_unregister(&rm_otgcontrol_driver); platform_driver_unregister(&rm_otgcontrol_driver);
} }
@ -311,6 +424,7 @@ module_init(otgcontrol_init);
module_exit(otgcontrol_exit); module_exit(otgcontrol_exit);
MODULE_LICENSE("GPL v2"); MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("reMarkable OTG control driver, to enable authentication of devices connecting through the USB OTG interface"); MODULE_DESCRIPTION("reMarkable OTG control driver, to enable authentication of "
"devices connecting through the USB OTG interface");
MODULE_VERSION("1.0"); MODULE_VERSION("1.0");
MODULE_AUTHOR("Steinar Bakkemo <steinar.bakkemo@remarkable.no"); MODULE_AUTHOR("Steinar Bakkemo <steinar.bakkemo@remarkable.no");

343
drivers/misc/rm-otgcontrol/otgcontrol_onewire.c
View File

@ -2,7 +2,6 @@
#include "otgcontrol_fsm.h" #include "otgcontrol_fsm.h"
#include <linux/export.h> #include <linux/export.h>
#include <linux/printk.h>
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/pinctrl/consumer.h> #include <linux/pinctrl/consumer.h>
#include <linux/irq.h> #include <linux/irq.h>
@ -11,47 +10,78 @@
#include <linux/gpio/consumer.h> #include <linux/gpio/consumer.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <linux/mutex.h>
#define DEBUG #define ONE_WIRE_GPIO_DEBOUNCE_MS 500 /* ms */
#define ONE_WIRE_GPIO_DEBOUNCE_MS 500 /* ms */
int otgcontrol_init_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data) int otgcontrol_init_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data)
{ {
int ret; int ret;
pr_info("%s: Initiating one-wire pinctrl states\n", __func__); dev_dbg(otgc_data->dev,
"%s: Initiating one-wire pinctrl states\n",
__func__);
otgc_data->one_wire_pinctrl = devm_pinctrl_get(otgc_data->dev); otgc_data->one_wire_pinctrl = devm_pinctrl_get(otgc_data->dev);
if (IS_ERR(otgc_data->one_wire_pinctrl)) { if (IS_ERR(otgc_data->one_wire_pinctrl)) {
dev_err(otgc_data->dev, "%s: Failed to get pinctrl\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to get pinctrl\n",
__func__);
return PTR_ERR(otgc_data->one_wire_pinctrl); return PTR_ERR(otgc_data->one_wire_pinctrl);
} }
otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__GPIO] = pinctrl_lookup_state(otgc_data->one_wire_pinctrl, "default"); otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__GPIO] =
pinctrl_lookup_state(otgc_data->one_wire_pinctrl,
"default");
if (IS_ERR(otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__GPIO])) { if (IS_ERR(otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__GPIO])) {
dev_err(otgc_data->dev, "%s: Failed to configure one-wire-gpio state\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to configure one-wire-gpio state\n",
__func__);
devm_pinctrl_put(otgc_data->one_wire_pinctrl); devm_pinctrl_put(otgc_data->one_wire_pinctrl);
return PTR_ERR(otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__GPIO]); return PTR_ERR(otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__GPIO]);
} }
otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_TX] = pinctrl_lookup_state(otgc_data->one_wire_pinctrl, "one_wire_uart_tx"); otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_TX] =
pinctrl_lookup_state(otgc_data->one_wire_pinctrl,
"one_wire_uart_tx");
if (IS_ERR(otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_TX])) { if (IS_ERR(otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_TX])) {
dev_err(otgc_data->dev, "%s: Failed to configure one-wire-uart-tx state\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to configure one-wire-uart-tx state\n",
__func__);
devm_pinctrl_put(otgc_data->one_wire_pinctrl); devm_pinctrl_put(otgc_data->one_wire_pinctrl);
return PTR_ERR(otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_TX]); return PTR_ERR(otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_TX]);
} }
otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_RX] = pinctrl_lookup_state(otgc_data->one_wire_pinctrl, "one_wire_uart_rx"); otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_RX] =
pinctrl_lookup_state(otgc_data->one_wire_pinctrl,
"one_wire_uart_rx");
if (IS_ERR(otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_RX])) { if (IS_ERR(otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_RX])) {
dev_err(otgc_data->dev, "%s: Failed to configure one-wire-uart-rx\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to configure one-wire-uart-rx\n",
__func__);
devm_pinctrl_put(otgc_data->one_wire_pinctrl); devm_pinctrl_put(otgc_data->one_wire_pinctrl);
return PTR_ERR(otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_RX]); return PTR_ERR(otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_RX]);
} }
pr_info("%s: Setting default state (GPIO)\n", __func__); dev_dbg(otgc_data->dev,
ret = pinctrl_select_state(otgc_data->one_wire_pinctrl, otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__GPIO]); "%s: Setting default state (GPIO)\n",
__func__);
ret = pinctrl_select_state(
otgc_data->one_wire_pinctrl,
otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__GPIO]);
if (ret < 0) { if (ret < 0) {
dev_err(otgc_data->dev, "%s: Failed to set default state (GPIO)\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to set default state (GPIO)\n",
__func__);
devm_pinctrl_put(otgc_data->one_wire_pinctrl); devm_pinctrl_put(otgc_data->one_wire_pinctrl);
return ret; return ret;
} }
@ -60,47 +90,72 @@ int otgcontrol_init_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data)
void otgcontrol_uninit_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data) void otgcontrol_uninit_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data)
{ {
if ((otgc_data->one_wire_pinctrl != NULL) && !IS_ERR(otgc_data->one_wire_pinctrl)) { if ((otgc_data->one_wire_pinctrl != NULL) &&
!IS_ERR(otgc_data->one_wire_pinctrl)) {
devm_pinctrl_put(otgc_data->one_wire_pinctrl); devm_pinctrl_put(otgc_data->one_wire_pinctrl);
otgc_data->one_wire_pinctrl = NULL; otgc_data->one_wire_pinctrl = NULL;
} }
} }
int otgcontrol_switch_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data, int state) int otgcontrol_switch_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data,
int state)
{ {
int ret; int ret;
switch(state) switch(state)
{ {
case OTG1_ONEWIRE_STATE__GPIO: case OTG1_ONEWIRE_STATE__GPIO:
pr_info("%s: Switching onewire state -> GPIO\n", __func__); dev_dbg(otgc_data->dev,
ret = pinctrl_select_state(otgc_data->one_wire_pinctrl, otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__GPIO]); "%s: Switching onewire state -> GPIO\n",
__func__);
ret = pinctrl_select_state(
otgc_data->one_wire_pinctrl,
otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__GPIO]);
if (ret < 0) { if (ret < 0) {
dev_err(otgc_data->dev, "%s: Failed to set pinctrl state\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to set pinctrl state\n",
__func__);
return ret; return ret;
} }
break; break;
case OTG1_ONEWIRE_STATE__UART_RX: case OTG1_ONEWIRE_STATE__UART_RX:
pr_info("%s: Switching onewire state -> UART RX\n", __func__); dev_dbg(otgc_data->dev,
ret = pinctrl_select_state(otgc_data->one_wire_pinctrl, otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_RX]); "%s: Switching onewire state -> UART RX\n",
__func__);
ret = pinctrl_select_state(
otgc_data->one_wire_pinctrl,
otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_RX]);
if (ret < 0) { if (ret < 0) {
dev_err(otgc_data->dev, "%s: Failed to set pinctrl state\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to set pinctrl state\n",
__func__);
return ret; return ret;
} }
break; break;
case OTG1_ONEWIRE_STATE__UART_TX: case OTG1_ONEWIRE_STATE__UART_TX:
pr_info("%s: switching onewire state -> UART TX\n", __func__); dev_dbg(otgc_data->dev,
ret = pinctrl_select_state(otgc_data->one_wire_pinctrl, otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_TX]); "%s: switching onewire state -> UART TX\n",
__func__);
ret = pinctrl_select_state(
otgc_data->one_wire_pinctrl,
otgc_data->one_wire_pinctrl_states[OTG1_ONEWIRE_STATE__UART_TX]);
if (ret < 0) { if (ret < 0) {
dev_err(otgc_data->dev, "%s: Failed to set pinctrl state\n", __func__); dev_err(otgc_data->dev,
"%s: Failed to set pinctrl state\n",
__func__);
return ret; return ret;
} }
break; break;
default: default:
dev_err(otgc_data->dev, "%s: unable to switch onewire state (unknown state %d)\n", __func__, state); dev_err(otgc_data->dev,
"%s: unable to switch onewire state (unknown state %d)\n",
__func__, state);
return -EINVAL; return -EINVAL;
} }
@ -131,50 +186,85 @@ int otgcontrol_init_gpio_irq(struct rm_otgcontrol_data *otgc_data)
{ {
int ret; int ret;
pr_info("%s: Setting local gpio debounce jiffies\n", __func__); dev_dbg(otgc_data->dev,
otgc_data->one_wire_gpio_debounce_jiffies = msecs_to_jiffies(ONE_WIRE_GPIO_DEBOUNCE_MS); "%s: Setting local gpio debounce jiffies\n",
__func__);
pr_info("%s: Initiating irq worker\n", __func__); otgc_data->one_wire_gpio_debounce_jiffies =
INIT_DELAYED_WORK(&otgc_data->one_wire_gpio_irq_work_queue, otgcontrol_gpio_irq_work); msecs_to_jiffies(ONE_WIRE_GPIO_DEBOUNCE_MS);
pr_info("%s: Getting IRQ from given gpio (%d)\n", dev_dbg(otgc_data->dev,
"%s: Initiating irq worker\n",
__func__);
INIT_DELAYED_WORK(&otgc_data->one_wire_gpio_irq_work_queue,
otgcontrol_gpio_irq_work);
dev_dbg(otgc_data->dev,
"%s: Getting IRQ from given gpio (%d)\n",
__func__, __func__,
desc_to_gpio(otgc_data->one_wire_gpio)); desc_to_gpio(otgc_data->one_wire_gpio));
otgc_data->one_wire_gpio_irq = gpiod_to_irq(otgc_data->one_wire_gpio); otgc_data->one_wire_gpio_irq = gpiod_to_irq(otgc_data->one_wire_gpio);
if (otgc_data->one_wire_gpio_irq < 0) { if (otgc_data->one_wire_gpio_irq < 0) {
dev_err(otgc_data->dev, "%s: Failed to get irq for given gpio (%d)\n", dev_err(otgc_data->dev,
__func__, "%s: Failed to get irq for given gpio (%d)\n",
desc_to_gpio(otgc_data->one_wire_gpio)); __func__,
desc_to_gpio(otgc_data->one_wire_gpio));
return otgc_data->one_wire_gpio_irq; return otgc_data->one_wire_gpio_irq;
} }
otgc_data->one_wire_gpio_state = otgcontrol_get_current_gpio_state(otgc_data); otgc_data->one_wire_gpio_state =
pr_info("%s: Current GPIO state: %s\n", __func__, otgcontrol_gpio_state_name(otgc_data->one_wire_gpio_state)); otgcontrol_get_current_gpio_state(otgc_data);
dev_dbg(otgc_data->dev,
"%s: Current GPIO state: %s\n",
__func__,
otgcontrol_gpio_state_name(otgc_data->one_wire_gpio_state));
dev_dbg(otgc_data->dev,
"%s: Clearing is-handling flag\n",
__func__);
pr_info("%s: Clearing is-handling flag\n", __func__);
otgc_data->one_wire_gpio_irq_is_handling = false; otgc_data->one_wire_gpio_irq_is_handling = false;
pr_info("%s: Requesting threaded irq\n", __func__); dev_dbg(otgc_data->dev,
ret = devm_request_threaded_irq(otgc_data->dev, otgc_data->one_wire_gpio_irq, NULL, "%s: Requesting threaded irq\n",
otgcontrol_gpio_irq_handler, __func__);
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT,
"one_wire_gpio_irq", otgc_data); ret = devm_request_threaded_irq(
otgc_data->dev,
otgc_data->one_wire_gpio_irq,
NULL,
otgcontrol_gpio_irq_handler,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT,
"one_wire_gpio_irq",
otgc_data);
if (ret < 0) { if (ret < 0) {
dev_err(otgc_data->dev, "%s: Failed to request handler for IRQ (%d) given for GPIO (%d)\n", dev_err(otgc_data->dev,
__func__, "%s: Failed to request handler for IRQ (%d) "
otgc_data->one_wire_gpio_irq, "given for GPIO (%d)\n",
desc_to_gpio(otgc_data->one_wire_gpio)); __func__,
otgc_data->one_wire_gpio_irq,
desc_to_gpio(otgc_data->one_wire_gpio));
return ret; return ret;
} }
mutex_lock(&otgc_data->lock);
otgc_data->one_wire_gpio_irq_is_active = true; otgc_data->one_wire_gpio_irq_is_active = true;
mutex_unlock(&otgc_data->lock);
return 0; return 0;
} }
void otgcontrol_uninit_gpio_irq(struct rm_otgcontrol_data *otgc_data) void otgcontrol_uninit_gpio_irq(struct rm_otgcontrol_data *otgc_data)
{ {
printk("%s: Freeing irq\n", __func__); dev_dbg(otgc_data->dev,
devm_free_irq(otgc_data->dev, otgc_data->one_wire_gpio_irq, otgc_data); "%s: Freeing irq\n",
__func__);
devm_free_irq(otgc_data->dev,
otgc_data->one_wire_gpio_irq,
otgc_data);
} }
void otgcontrol_activate_gpio_irq(struct rm_otgcontrol_data *otgc_data) void otgcontrol_activate_gpio_irq(struct rm_otgcontrol_data *otgc_data)
@ -198,13 +288,22 @@ static irqreturn_t otgcontrol_gpio_irq_handler(int irq, void *data)
struct rm_otgcontrol_data *otgc_data = (struct rm_otgcontrol_data*)data; struct rm_otgcontrol_data *otgc_data = (struct rm_otgcontrol_data*)data;
if (otgc_data->one_wire_gpio_irq_is_handling) { if (otgc_data->one_wire_gpio_irq_is_handling) {
pr_info("%s: Is already handling irq, ignoring this\n", __func__); dev_dbg(otgc_data->dev,
"%s: Is already handling irq, ignoring this\n",
__func__);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
else { else {
pr_info("%s: Queueing IRQ handling for execution in %d ms\n", __func__, ONE_WIRE_GPIO_DEBOUNCE_MS); dev_dbg(otgc_data->dev,
"%s: Queueing IRQ handling for execution in %d ms\n",
__func__,
ONE_WIRE_GPIO_DEBOUNCE_MS);
otgc_data->one_wire_gpio_irq_is_handling = true; otgc_data->one_wire_gpio_irq_is_handling = true;
queue_delayed_work(system_power_efficient_wq, &otgc_data->one_wire_gpio_irq_work_queue, otgc_data->one_wire_gpio_debounce_jiffies);
queue_delayed_work(system_power_efficient_wq,
&otgc_data->one_wire_gpio_irq_work_queue,
otgc_data->one_wire_gpio_debounce_jiffies);
} }
return IRQ_HANDLED; return IRQ_HANDLED;
@ -214,26 +313,50 @@ static void otgcontrol_gpio_irq_work(struct work_struct *work)
{ {
int cur_gpio_state; int cur_gpio_state;
struct delayed_work *delayed_work = container_of(work, struct delayed_work, work); struct delayed_work *delayed_work =
struct rm_otgcontrol_data *otgc_data = container_of(delayed_work, struct rm_otgcontrol_data, one_wire_gpio_irq_work_queue); container_of(work,
struct delayed_work,
work);
struct rm_otgcontrol_data *otgc_data =
container_of(delayed_work,
struct rm_otgcontrol_data,
one_wire_gpio_irq_work_queue);
dev_dbg(otgc_data->dev,
"%s: Checking current gpio state\n",
__func__);
pr_info("%s: Checking current gpio state\n", __func__);
cur_gpio_state = otgcontrol_get_current_gpio_state(otgc_data); cur_gpio_state = otgcontrol_get_current_gpio_state(otgc_data);
if (cur_gpio_state != otgc_data->one_wire_gpio_state) { if (cur_gpio_state != otgc_data->one_wire_gpio_state) {
pr_info("%s: GPIO state changed -> %s\n", __func__, otgcontrol_gpio_state_name(cur_gpio_state)); dev_dbg(otgc_data->dev,
"%s: GPIO state changed -> %s\n",
__func__,
otgcontrol_gpio_state_name(cur_gpio_state));
otgc_data->one_wire_gpio_state = cur_gpio_state; otgc_data->one_wire_gpio_state = cur_gpio_state;
if (otgc_data->one_wire_gpio_state == OTG1_ONEWIRE_GPIO_STATE__DEVICE_CONNECTED) if (otgc_data->one_wire_gpio_state ==
otgcontrol_handleInput(otgc_data, OTG1_EVENT__DEVICE_CONNECTED, NULL); OTG1_ONEWIRE_GPIO_STATE__DEVICE_CONNECTED)
otgcontrol_handleInput(otgc_data,
OTG1_EVENT__DEVICE_CONNECTED,
NULL);
else else
otgcontrol_handleInput(otgc_data, OTG1_EVENT__DEVICE_DISCONNECTED, NULL); otgcontrol_handleInput(otgc_data,
OTG1_EVENT__DEVICE_DISCONNECTED,
NULL);
} }
pr_info("%s: Resetting is-handling flag\n", __func__); dev_dbg(otgc_data->dev,
"%s: Resetting is-handling flag\n",
__func__);
otgc_data->one_wire_gpio_irq_is_handling = false; otgc_data->one_wire_gpio_irq_is_handling = false;
} }
int otgcontrol_onewire_write_tty(struct rm_otgcontrol_data *otgc_data, char *device_name, char *text_to_send) int otgcontrol_onewire_write_tty(struct rm_otgcontrol_data *otgc_data,
char *device_name,
char *text_to_send)
{ {
// Create variables // Create variables
struct file *f; struct file *f;
@ -245,31 +368,55 @@ int otgcontrol_onewire_write_tty(struct rm_otgcontrol_data *otgc_data, char *dev
for(i = 0;i < 128;i++) for(i = 0;i < 128;i++)
buf[i] = 0; buf[i] = 0;
pr_info("%s: Trying to open %s\n", __func__, device_name); dev_dbg(otgc_data->dev, "%s: Trying to open %s\n",
__func__,
device_name);
f = filp_open(device_name, O_RDWR, 0); f = filp_open(device_name, O_RDWR, 0);
if(f == NULL) { if(f == NULL) {
dev_err(otgc_data->dev, "%s: filp_open error!!.\n", __func__); dev_err(otgc_data->dev,
"%s: filp_open error!!.\n",
__func__);
return -1; return -1;
} }
else { else {
// Get current segment descriptor // Get current segment descriptor
pr_info("%s: Getting current segment descriptor\n", __func__); dev_dbg(otgc_data->dev,
"%s: Getting current segment descriptor\n",
__func__);
fs = get_fs(); fs = get_fs();
// Set segment descriptor associated to kernel space // Set segment descriptor associated to kernel space
pr_info("%s: Setting segment descriptor\n", __func__); dev_dbg(otgc_data->dev,
"%s: Setting segment descriptor\n",
__func__);
set_fs(get_ds()); set_fs(get_ds());
//Write to the file //Write to the file
pr_info("%s: Writing '%s' to file\n", __func__, text_to_send); dev_dbg(otgc_data->dev,
kernel_write(f, text_to_send, strlen(text_to_send), &f->f_pos); "%s: Writing '%s' to file\n",
__func__,
text_to_send);
kernel_write(f,
text_to_send,
strlen(text_to_send),
&f->f_pos);
// f->f_op->write(f, text_to_send, strlen(text_to_send), &f->f_pos); // f->f_op->write(f, text_to_send, strlen(text_to_send), &f->f_pos);
// Restore segment descriptor // Restore segment descriptor
pr_info("%s: Restoring segment descriptor\n", __func__); dev_dbg(otgc_data->dev,
"%s: Restoring segment descriptor\n",
__func__);
set_fs(fs); set_fs(fs);
pr_info("%s: Closing file\n", __func__); dev_dbg(otgc_data->dev,
"%s: Closing file\n",
__func__);
filp_close(f,NULL); filp_close(f,NULL);
return 0; return 0;
} }
@ -285,33 +432,54 @@ int otgcontrol_onewire_read_until_cr(struct rm_otgcontrol_data *otgc_data, char
f = filp_open(device_name, O_RDONLY, 0); f = filp_open(device_name, O_RDONLY, 0);
if(f == NULL) { if(f == NULL) {
dev_err(otgc_data->dev, "%s: filp_open error!!.\n", __func__); dev_err(otgc_data->dev,
"%s: filp_open error!!.\n",
__func__);
return -1; return -1;
} }
else { else {
// Get current segment descriptor // Get current segment descriptor
pr_info("%s: Getting current segment descriptor\n", __func__); dev_dbg(otgc_data->dev,
"%s: Getting current segment descriptor\n",
__func__);
fs = get_fs(); fs = get_fs();
// Set segment descriptor associated to kernel space // Set segment descriptor associated to kernel space
pr_info("%s: Setting segment descriptor\n", __func__); dev_dbg(otgc_data->dev,
"%s: Setting segment descriptor\n",
__func__);
set_fs(get_ds()); set_fs(get_ds());
pos = 0; pos = 0;
int state = 0; int state = 0;
pr_info("%s: Starting read loop\n", __func__); dev_dbg(otgc_data->dev,
"%s: Starting read loop\n",
__func__);
do { do {
// Read the file // Read the file
// f->f_op->read(f, &newchar, 1, &f->f_pos); // f->f_op->read(f, &newchar, 1, &f->f_pos);
kernel_read(f, &newchar, 1, &f->f_pos); kernel_read(f,
pr_info("%s: <-%c (0x%02x)\n", __func__, newchar, newchar); &newchar,
1,
&f->f_pos);
dev_dbg(otgc_data->dev,
"%s: <-%c (0x%02x)\n",
__func__,
newchar, newchar);
switch(state) switch(state)
{ {
case 0: case 0:
// Wait : // Wait :
if (newchar == ':') { if (newchar == ':') {
pr_info("%s: SOF\n", __func__); dev_dbg(otgc_data->dev,
"%s: SOF\n",
__func__);
state = 1; state = 1;
} }
break; break;
@ -322,16 +490,29 @@ int otgcontrol_onewire_read_until_cr(struct rm_otgcontrol_data *otgc_data, char
} }
} }
}while((newchar != '#') && (pos < maxlen)); }while((newchar != '#') && (pos < maxlen));
pr_info("%s: Done\n", __func__);
dev_dbg(otgc_data->dev,
"%s: Done\n",
__func__);
// Restore segment descriptor // Restore segment descriptor
pr_info("%s: Restoring segment descriptor\n", __func__); dev_dbg(otgc_data->dev,
"%s: Restoring segment descriptor\n",
__func__);
set_fs(fs); set_fs(fs);
pr_info("%s: Closing file\n", __func__); dev_dbg(otgc_data->dev,
filp_close(f,NULL); "%s: Closing file\n",
__func__);
filp_close(f, NULL);
dev_dbg(otgc_data->dev,
"%s: Returning %d bytes read\n",
__func__,
pos);
pr_info("%s: Returning %d bytes read\n", __func__, pos);
return pos; return pos;
} }
} }

25
drivers/misc/rm-otgcontrol/otgcontrol_onewire.h
View File

@ -6,20 +6,18 @@
#include <linux/workqueue.h> #include <linux/workqueue.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#define OTG1_ONEWIRE_STATE__GPIO 0 #define OTG1_ONEWIRE_STATE__GPIO 0
#define OTG1_ONEWIRE_STATE__UART_TX 1 #define OTG1_ONEWIRE_STATE__UART_TX 1
#define OTG1_ONEWIRE_STATE__UART_RX 2 #define OTG1_ONEWIRE_STATE__UART_RX 2
/******************************************************** #define OTG1_ONEWIRE_GPIO_STATE__DEVICE_CONNECTED 0
* State definitions to be used when reading GPIO input #define OTG1_ONEWIRE_GPIO_STATE__DEVICE_NOT_CONNECTED 1
********************************************************/
#define OTG1_ONEWIRE_GPIO_STATE__DEVICE_CONNECTED 0
#define OTG1_ONEWIRE_GPIO_STATE__DEVICE_NOT_CONNECTED 1
int otgcontrol_init_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data); int otgcontrol_init_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data);
void otgcontrol_uninit_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data); void otgcontrol_uninit_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data);
int otgcontrol_switch_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data, int newState); int otgcontrol_switch_one_wire_mux_state(struct rm_otgcontrol_data *otgc_data,
int newState);
int otgcontrol_get_current_gpio_state(struct rm_otgcontrol_data *otgc_data); int otgcontrol_get_current_gpio_state(struct rm_otgcontrol_data *otgc_data);
const char *otgcontrol_gpio_state_name(int state); const char *otgcontrol_gpio_state_name(int state);
int otgcontrol_init_gpio_irq(struct rm_otgcontrol_data *otgc_data); int otgcontrol_init_gpio_irq(struct rm_otgcontrol_data *otgc_data);
@ -28,7 +26,12 @@ void otgcontrol_activate_gpio_irq(struct rm_otgcontrol_data *otgc_data);
void otgcontrol_deactivate_gpio_irq(struct rm_otgcontrol_data *otgc_data); void otgcontrol_deactivate_gpio_irq(struct rm_otgcontrol_data *otgc_data);
static irqreturn_t otgcontrol_gpio_irq_handler(int irq, void *data); static irqreturn_t otgcontrol_gpio_irq_handler(int irq, void *data);
static void otgcontrol_gpio_irq_work(struct work_struct *work); static void otgcontrol_gpio_irq_work(struct work_struct *work);
int otgcontrol_onewire_read_until_cr(struct rm_otgcontrol_data *otgc_data, char *device_name, char *buf, int maxlen); int otgcontrol_onewire_read_until_cr(struct rm_otgcontrol_data *otgc_data,
int otgcontrol_onewire_write_tty(struct rm_otgcontrol_data *otgc_data, char *device_name, char *text_to_send); char *device_name,
char *buf,
int maxlen);
int otgcontrol_onewire_write_tty(struct rm_otgcontrol_data *otgc_data,
char *device_name,
char *text_to_send);
#endif /* __OTGCONTROL_ONE_WIRE_H__ */ #endif /* __OTGCONTROL_ONE_WIRE_H__ */

205
drivers/misc/rm-otgcontrol/otgcontrol_sysfs.c
View File

@ -5,13 +5,13 @@
#include "otgcontrol_onewire.h" #include "otgcontrol_onewire.h"
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/printk.h>
#include <linux/kobject.h> #include <linux/kobject.h>
#include <linux/sysfs.h> #include <linux/sysfs.h>
#include <linux/export.h> #include <linux/export.h>
#include <linux/power_supply.h> #include <linux/power_supply.h>
#define to_otgcontrol_data(kobj_attr_ptr, kobj_attr_member) container_of(kobj_attr_ptr, struct rm_otgcontrol_data, kobj_attr_member); #define to_otgcontrol_data(kobj_attr_ptr, kobj_attr_member) \
container_of(kobj_attr_ptr, struct rm_otgcontrol_data, kobj_attr_member);
#define SYSFS_PARENT_NODE NULL #define SYSFS_PARENT_NODE NULL
#define SYSFS_NODE_NAME "otgcontrol" #define SYSFS_NODE_NAME "otgcontrol"
@ -20,8 +20,11 @@
#define CONTROL_GROUP_ATTRIBUTE_COUNT 4 #define CONTROL_GROUP_ATTRIBUTE_COUNT 4
static struct attribute *control_attrs[CONTROL_GROUP_ATTRIBUTE_COUNT + 1] = { static struct attribute *control_attrs[CONTROL_GROUP_ATTRIBUTE_COUNT + 1] = {
NULL, NULL, NULL, NULL, /* CONTROL_GROUP_ATTRIBUTE_COUNT number of initializing NULLs */ /* CONTROL_GROUP_ATTRIBUTE_COUNT number of initializing NULLs */
NULL /* NULL terminating the list */ NULL, NULL, NULL, NULL,
/* NULL terminating the list */
NULL
}; };
struct attribute_group control_attr_group = { struct attribute_group control_attr_group = {
@ -30,8 +33,11 @@ struct attribute_group control_attr_group = {
}; };
struct attribute *status_attrs[STATUS_GROUP_ATTRIBUTE_COUNT + 1] = { struct attribute *status_attrs[STATUS_GROUP_ATTRIBUTE_COUNT + 1] = {
NULL, /* STATUS_GROUP_ATTRIBUTE_COUNT number of NULLS */ /* STATUS_GROUP_ATTRIBUTE_COUNT number of NULLS */
NULL /* NULL terminating the list */ NULL,
/* NULL terminating the list */
NULL
}; };
struct attribute_group status_attr_group = { struct attribute_group status_attr_group = {
@ -39,73 +45,126 @@ struct attribute_group status_attr_group = {
.name = "status" .name = "status"
}; };
static ssize_t attribute_show(struct kobject *kobj, struct kobj_attribute *attr, static ssize_t attribute_show(struct kobject *kobj,
char *buf) struct kobj_attribute *attr,
char *buf)
{ {
int var; int var;
struct rm_otgcontrol_data *otgc_data; struct rm_otgcontrol_data *otgc_data;
printk("%s: Enter\n", __func__);
if (strcmp(attr->attr.name, "otg1_device_connected") == 0) { if (strcmp(attr->attr.name, "otg1_device_connected") == 0) {
otgc_data = to_otgcontrol_data(attr, otg1_device_connected_attribute); otgc_data = to_otgcontrol_data(attr,
printk("%s: Returning cur otg1_device_connected value (%d)\n", __func__, otgc_data->otg1_device_connected); otg1_device_connected_attribute);
dev_dbg(otgc_data->dev,
"%s: Returning cur otg1_device_connected value (%d)\n",
__func__,
otgc_data->otg1_device_connected);
var = otgc_data->otg1_device_connected; var = otgc_data->otg1_device_connected;
} }
else if (strcmp(attr->attr.name, "otg1_dr_mode") == 0) { else if (strcmp(attr->attr.name, "otg1_dr_mode") == 0) {
otgc_data = to_otgcontrol_data(attr, otg1_dr_mode_attribute); otgc_data = to_otgcontrol_data(attr,
printk("%s: Returning cur otg1_id_state value (%d)\n", __func__, otgc_data->otg1_dr_mode); otg1_dr_mode_attribute);
dev_dbg(otgc_data->dev,
"%s: Returning cur otg1_id_state value (%d)\n",
__func__,
otgc_data->otg1_dr_mode);
var = otgc_data->otg1_dr_mode; var = otgc_data->otg1_dr_mode;
} }
else if (strcmp(attr->attr.name, "otg1_chargermode") == 0) { else if (strcmp(attr->attr.name, "otg1_chargermode") == 0) {
otgc_data = to_otgcontrol_data(attr, otg1_chargermode_attribute); otgc_data = to_otgcontrol_data(attr,
printk("%s: Returning cur otg1_chargermode value (%d)\n", __func__, otgc_data->otg1_chargermode); otg1_chargermode_attribute);
dev_dbg(otgc_data->dev,
"%s: Returning cur otg1_chargermode value (%d)\n",
__func__,
otgc_data->otg1_chargermode);
var = otgc_data->otg1_chargermode; var = otgc_data->otg1_chargermode;
} }
else if (strcmp(attr->attr.name, "otg1_controllermode") == 0) { else if (strcmp(attr->attr.name, "otg1_controllermode") == 0) {
otgc_data = to_otgcontrol_data(attr, otg1_controllermode_attribute); otgc_data = to_otgcontrol_data(attr,
printk("%s: Returning cur otg1_controllermode value (%d)\n", __func__, otgc_data->otg1_controllermode); otg1_controllermode_attribute);
dev_dbg(otgc_data->dev,
"%s: Returning cur otg1_controllermode value (%d)\n",
__func__,
otgc_data->otg1_controllermode);
var = otgc_data->otg1_controllermode; var = otgc_data->otg1_controllermode;
} }
else { else {
printk("%s: Invalid attribute name (%s)\n", __func__, attr->attr.name); dev_dbg(otgc_data->dev,
"%s: Invalid attribute name (%s)\n",
__func__,
attr->attr.name);
return -EINVAL; return -EINVAL;
} }
return sprintf(buf, "%d\n", var); return sprintf(buf, "%d\n", var);
} }
static ssize_t attribute_store(struct kobject *kobj, struct kobj_attribute *attr, static ssize_t attribute_store(struct kobject *kobj,
const char *buf, size_t count) struct kobj_attribute *attr,
const char *buf,
size_t count)
{ {
struct rm_otgcontrol_data *otgc_data; struct rm_otgcontrol_data *otgc_data;
int var, ret; int var, ret;
printk("%s: Enter\n", __func__);
ret = kstrtoint(buf, 10, &var); ret = kstrtoint(buf, 10, &var);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (strcmp(attr->attr.name, "otg1_dr_mode") == 0) { if (strcmp(attr->attr.name, "otg1_dr_mode") == 0) {
otgc_data = to_otgcontrol_data(attr, otg1_dr_mode_attribute); otgc_data = to_otgcontrol_data(attr,
printk("%s: Setting new otg1 dr mode (%d)\n", __func__, var); otg1_dr_mode_attribute);
ret = otgcontrol_set_dr_mode(otgc_data, var);
dev_dbg(otgc_data->dev,
"%s: Setting new otg1 dr mode (%d)\n",
__func__,
var);
ret = otgcontrol_set_dr_mode(otgc_data,
var);
} }
else if (strcmp(attr->attr.name, "otg1_chargermode") == 0) { else if (strcmp(attr->attr.name, "otg1_chargermode") == 0) {
otgc_data = to_otgcontrol_data(attr, otg1_chargermode_attribute); otgc_data = to_otgcontrol_data(attr, otg1_chargermode_attribute);
printk("%s: Setting new otg1 chargermode (%d)\n", __func__, var);
ret = otgcontrol_change_otg_charge_mode(otgc_data, var); dev_dbg(otgc_data->dev,
"%s: Setting new otg1 chargermode (%d)\n",
__func__,
var);
ret = otgcontrol_change_otg_charge_mode(otgc_data,
var);
} }
else if (strcmp(attr->attr.name, "otg1_controllermode") == 0) { else if (strcmp(attr->attr.name, "otg1_controllermode") == 0) {
otgc_data = to_otgcontrol_data(attr, otg1_controllermode_attribute); otgc_data = to_otgcontrol_data(attr,
printk("%s: Setting new otg1 controllermode (%d)\n", __func__, var); otg1_controllermode_attribute);
ret = otgcontrol_handleInput(otgc_data, OTG1_EVENT__MODE_CHANGE_REQUESTED, (void*)&var);
dev_dbg(otgc_data->dev,
"%s: Setting new otg1 controllermode (%d)\n",
__func__,
var);
ret = otgcontrol_handleInput(otgc_data,
OTG1_EVENT__MODE_CHANGE_REQUESTED,
(void*)&var);
} }
else if (strcmp(attr->attr.name, "otg1_pinctrlstate") == 0) { else if (strcmp(attr->attr.name, "otg1_pinctrlstate") == 0) {
otgc_data = to_otgcontrol_data(attr, otg1_pinctrlstate_attribute); otgc_data = to_otgcontrol_data(attr,
printk("%s: Setting new pinctrlstate (%d)\n", __func__, var); otg1_pinctrlstate_attribute);
ret = otgcontrol_switch_one_wire_mux_state(otgc_data, var); dev_dbg(otgc_data->dev,
"%s: Setting new pinctrlstate (%d)\n",
__func__,
var);
ret = otgcontrol_switch_one_wire_mux_state(otgc_data,
var);
} }
else { else {
return -EINVAL; return -EINVAL;
@ -115,10 +174,15 @@ static ssize_t attribute_store(struct kobject *kobj, struct kobj_attribute *attr
} }
void otgcontrol_create_kobj_property(struct kobj_attribute *attr, void otgcontrol_create_kobj_property(struct kobj_attribute *attr,
const char *name, const char *name,
int permission, int permission,
ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr, char *buf), ssize_t (*show)(struct kobject *kobj,
ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count)) struct kobj_attribute *attr,
char *buf),
ssize_t (*store)(struct kobject *kobj,
struct kobj_attribute *attr,
const char *buf,
size_t count))
{ {
attr->attr.name = name; attr->attr.name = name;
attr->attr.mode = VERIFY_OCTAL_PERMISSIONS(S_IRUGO | S_IWUSR); attr->attr.mode = VERIFY_OCTAL_PERMISSIONS(S_IRUGO | S_IWUSR);
@ -131,32 +195,33 @@ int otgcontrol_init_sysfs_nodes(struct rm_otgcontrol_data *otgc_data)
struct kobject *otgcontrol_kobj; struct kobject *otgcontrol_kobj;
int retval; int retval;
printk("%s: Enter\n", __func__); dev_dbg(otgc_data->dev,
"%s: Creating control properties (R/W)\n",
__func__);
printk("%s: Creating control properties (R/W)\n", __func__);
otgcontrol_create_kobj_property(&otgc_data->otg1_dr_mode_attribute, otgcontrol_create_kobj_property(&otgc_data->otg1_dr_mode_attribute,
"otg1_dr_mode", "otg1_dr_mode",
S_IRUGO | S_IWUSR, S_IRUGO | S_IWUSR,
attribute_show, attribute_show,
attribute_store); attribute_store);
otgcontrol_create_kobj_property(&otgc_data->otg1_chargermode_attribute, otgcontrol_create_kobj_property(&otgc_data->otg1_chargermode_attribute,
"otg1_chargermode", "otg1_chargermode",
S_IRUGO | S_IWUSR, S_IRUGO | S_IWUSR,
attribute_show, attribute_show,
attribute_store); attribute_store);
otgcontrol_create_kobj_property(&otgc_data->otg1_controllermode_attribute, otgcontrol_create_kobj_property(&otgc_data->otg1_controllermode_attribute,
"otg1_controllermode", "otg1_controllermode",
S_IRUGO | S_IWUSR, S_IRUGO | S_IWUSR,
attribute_show, attribute_show,
attribute_store); attribute_store);
otgcontrol_create_kobj_property(&otgc_data->otg1_pinctrlstate_attribute, otgcontrol_create_kobj_property(&otgc_data->otg1_pinctrlstate_attribute,
"otg1_pinctrlstate", "otg1_pinctrlstate",
S_IRUGO | S_IWUSR, S_IRUGO | S_IWUSR,
attribute_show, attribute_show,
attribute_store); attribute_store);
control_attrs[0] = &otgc_data->otg1_dr_mode_attribute.attr; control_attrs[0] = &otgc_data->otg1_dr_mode_attribute.attr;
control_attrs[1] = &otgc_data->otg1_chargermode_attribute.attr; control_attrs[1] = &otgc_data->otg1_chargermode_attribute.attr;
@ -164,23 +229,30 @@ int otgcontrol_init_sysfs_nodes(struct rm_otgcontrol_data *otgc_data)
control_attrs[3] = &otgc_data->otg1_pinctrlstate_attribute.attr; control_attrs[3] = &otgc_data->otg1_pinctrlstate_attribute.attr;
control_attrs[4] = NULL; /* NULL termination of the list */ control_attrs[4] = NULL; /* NULL termination of the list */
printk("%s: Creating status properties (R)\n", __func__); dev_dbg(otgc_data->dev,
"%s: Creating status properties (R)\n",
__func__);
otgcontrol_create_kobj_property(&otgc_data->otg1_device_connected_attribute, otgcontrol_create_kobj_property(&otgc_data->otg1_device_connected_attribute,
"otg1_device_connected", "otg1_device_connected",
S_IRUGO, S_IRUGO,
attribute_show, attribute_show,
attribute_store); attribute_store);
status_attrs[0] = &otgc_data->otg1_device_connected_attribute.attr; status_attrs[0] = &otgc_data->otg1_device_connected_attribute.attr;
status_attrs[1] = NULL; /* NULL termination of the list */ status_attrs[1] = NULL; /* NULL termination of the list */
otgcontrol_kobj = kobject_create_and_add(SYSFS_NODE_NAME, SYSFS_PARENT_NODE); otgcontrol_kobj = kobject_create_and_add(SYSFS_NODE_NAME,
SYSFS_PARENT_NODE);
if (!otgcontrol_kobj) if (!otgcontrol_kobj)
return -ENOMEM; return -ENOMEM;
/* Create the files associated with this kobject */ /* Create the files associated with this kobject */
retval = sysfs_create_group(otgcontrol_kobj, &control_attr_group); retval = sysfs_create_group(otgcontrol_kobj,
retval = sysfs_create_group(otgcontrol_kobj, &status_attr_group); &control_attr_group);
retval = sysfs_create_group(otgcontrol_kobj,
&status_attr_group);
if (retval) { if (retval) {
otgc_data->kobject = otgcontrol_kobj; otgc_data->kobject = otgcontrol_kobj;
} }
@ -191,7 +263,10 @@ int otgcontrol_init_sysfs_nodes(struct rm_otgcontrol_data *otgc_data)
void otgcontrol_uninit_sysfs_nodes(struct rm_otgcontrol_data *otgc_data) void otgcontrol_uninit_sysfs_nodes(struct rm_otgcontrol_data *otgc_data)
{ {
printk("%s: Decrementing kobject refcount\n", __func__); dev_dbg(otgc_data->dev,
"%s: Decrementing kobject refcount\n",
__func__);
if((otgc_data->kobject != NULL) && !IS_ERR(otgc_data->kobject)) { if((otgc_data->kobject != NULL) && !IS_ERR(otgc_data->kobject)) {
sysfs_remove_group(otgc_data->kobject, &control_attr_group); sysfs_remove_group(otgc_data->kobject, &control_attr_group);
sysfs_remove_group(otgc_data->kobject, &status_attr_group); sysfs_remove_group(otgc_data->kobject, &status_attr_group);

55
include/linux/rm-otgcontrol.h
View File

@ -3,6 +3,7 @@
#include <linux/kobject.h> #include <linux/kobject.h>
#include <linux/pinctrl/pinctrl.h> #include <linux/pinctrl/pinctrl.h>
#include <linux/mutex.h>
#include <linux/extcon.h> #include <linux/extcon.h>
struct rm_otgcontrol_platform_data { struct rm_otgcontrol_platform_data {
@ -10,42 +11,44 @@ struct rm_otgcontrol_platform_data {
}; };
struct rm_otgcontrol_data { struct rm_otgcontrol_data {
struct device *dev; struct device *dev;
struct rm_otgcontrol_platform_data *pdata; struct rm_otgcontrol_platform_data *pdata;
struct extcon_dev *extcon_dev; struct mutex lock;
const char *one_wire_tty_name; struct extcon_dev *extcon_dev;
struct gpio_desc *one_wire_gpio;
int one_wire_gpio_irq;
unsigned long one_wire_gpio_debounce_jiffies;
struct delayed_work one_wire_gpio_irq_work_queue;
bool one_wire_gpio_irq_is_active;
int one_wire_gpio_state;
bool one_wire_gpio_irq_is_handling;
int otg_controlstate; const char *one_wire_tty_name;
int mode_requested; struct gpio_desc *one_wire_gpio;
int one_wire_gpio_irq;
unsigned long one_wire_gpio_debounce_jiffies;
struct delayed_work one_wire_gpio_irq_work_queue;
bool one_wire_gpio_irq_is_active;
int one_wire_gpio_state;
bool one_wire_gpio_irq_is_handling;
struct pinctrl* one_wire_pinctrl; int otg_controlstate;
struct pinctrl_state* one_wire_pinctrl_states[3]; int mode_requested;
struct kobject* kobject; struct pinctrl* one_wire_pinctrl;
struct pinctrl_state* one_wire_pinctrl_states[3];
struct kobj_attribute otg1_device_connected_attribute; struct kobject* kobject;
bool otg1_device_connected;
struct kobj_attribute otg1_dr_mode_attribute; struct kobj_attribute otg1_device_connected_attribute;
int otg1_dr_mode; bool otg1_device_connected;
struct kobj_attribute otg1_chargermode_attribute; struct kobj_attribute otg1_dr_mode_attribute;
int otg1_chargermode; int otg1_dr_mode;
struct kobj_attribute otg1_controllermode_attribute; struct kobj_attribute otg1_chargermode_attribute;
int otg1_controllermode; int otg1_chargermode;
struct kobj_attribute otg1_pinctrlstate_attribute; struct kobj_attribute otg1_controllermode_attribute;
int otg1_pinctrlstate; int otg1_controllermode;
struct kobj_attribute otg1_pinctrlstate_attribute;
int otg1_pinctrlstate;
}; };
#endif /* __RM_OTGCONTROL_H */ #endif /* __RM_OTGCONTROL_H */