1 /* 2 * w1-gpio - GPIO w1 bus master driver 3 * 4 * Copyright (C) 2007 Ville Syrjala <syrjala@sci.fi> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 8 * as published by the Free Software Foundation. 9 */ 10 11 #include <linux/init.h> 12 #include <linux/module.h> 13 #include <linux/platform_device.h> 14 #include <linux/slab.h> 15 #include <linux/w1-gpio.h> 16 #include <linux/gpio.h> 17 #include <linux/of_platform.h> 18 #include <linux/of_gpio.h> 19 #include <linux/pinctrl/consumer.h> 20 #include <linux/err.h> 21 #include <linux/of.h> 22 23 #include "../w1.h" 24 #include "../w1_int.h" 25 26 static void w1_gpio_write_bit_dir(void *data, u8 bit) 27 { 28 struct w1_gpio_platform_data *pdata = data; 29 30 if (bit) 31 gpio_direction_input(pdata->pin); 32 else 33 gpio_direction_output(pdata->pin, 0); 34 } 35 36 static void w1_gpio_write_bit_val(void *data, u8 bit) 37 { 38 struct w1_gpio_platform_data *pdata = data; 39 40 gpio_set_value(pdata->pin, bit); 41 } 42 43 static u8 w1_gpio_read_bit(void *data) 44 { 45 struct w1_gpio_platform_data *pdata = data; 46 47 return gpio_get_value(pdata->pin) ? 1 : 0; 48 } 49 50 static struct of_device_id w1_gpio_dt_ids[] = { 51 { .compatible = "w1-gpio" }, 52 {} 53 }; 54 MODULE_DEVICE_TABLE(of, w1_gpio_dt_ids); 55 56 static int w1_gpio_probe_dt(struct platform_device *pdev) 57 { 58 struct w1_gpio_platform_data *pdata = pdev->dev.platform_data; 59 struct device_node *np = pdev->dev.of_node; 60 61 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 62 if (!pdata) 63 return -ENOMEM; 64 65 if (of_get_property(np, "linux,open-drain", NULL)) 66 pdata->is_open_drain = 1; 67 68 pdata->pin = of_get_gpio(np, 0); 69 pdata->ext_pullup_enable_pin = of_get_gpio(np, 1); 70 pdev->dev.platform_data = pdata; 71 72 return 0; 73 } 74 75 static int w1_gpio_probe(struct platform_device *pdev) 76 { 77 struct w1_bus_master *master; 78 struct w1_gpio_platform_data *pdata; 79 struct pinctrl *pinctrl; 80 int err; 81 82 pinctrl = devm_pinctrl_get_select_default(&pdev->dev); 83 if (IS_ERR(pinctrl)) 84 dev_warn(&pdev->dev, "unable to select pin group\n"); 85 86 if (of_have_populated_dt()) { 87 err = w1_gpio_probe_dt(pdev); 88 if (err < 0) { 89 dev_err(&pdev->dev, "Failed to parse DT\n"); 90 return err; 91 } 92 } 93 94 pdata = pdev->dev.platform_data; 95 96 if (!pdata) { 97 dev_err(&pdev->dev, "No configuration data\n"); 98 return -ENXIO; 99 } 100 101 master = kzalloc(sizeof(struct w1_bus_master), GFP_KERNEL); 102 if (!master) { 103 dev_err(&pdev->dev, "Out of memory\n"); 104 return -ENOMEM; 105 } 106 107 err = gpio_request(pdata->pin, "w1"); 108 if (err) { 109 dev_err(&pdev->dev, "gpio_request (pin) failed\n"); 110 goto free_master; 111 } 112 113 if (gpio_is_valid(pdata->ext_pullup_enable_pin)) { 114 err = gpio_request_one(pdata->ext_pullup_enable_pin, 115 GPIOF_INIT_LOW, "w1 pullup"); 116 if (err < 0) { 117 dev_err(&pdev->dev, "gpio_request_one " 118 "(ext_pullup_enable_pin) failed\n"); 119 goto free_gpio; 120 } 121 } 122 123 master->data = pdata; 124 master->read_bit = w1_gpio_read_bit; 125 126 if (pdata->is_open_drain) { 127 gpio_direction_output(pdata->pin, 1); 128 master->write_bit = w1_gpio_write_bit_val; 129 } else { 130 gpio_direction_input(pdata->pin); 131 master->write_bit = w1_gpio_write_bit_dir; 132 } 133 134 err = w1_add_master_device(master); 135 if (err) { 136 dev_err(&pdev->dev, "w1_add_master device failed\n"); 137 goto free_gpio_ext_pu; 138 } 139 140 if (pdata->enable_external_pullup) 141 pdata->enable_external_pullup(1); 142 143 if (gpio_is_valid(pdata->ext_pullup_enable_pin)) 144 gpio_set_value(pdata->ext_pullup_enable_pin, 1); 145 146 platform_set_drvdata(pdev, master); 147 148 return 0; 149 150 free_gpio_ext_pu: 151 if (gpio_is_valid(pdata->ext_pullup_enable_pin)) 152 gpio_free(pdata->ext_pullup_enable_pin); 153 free_gpio: 154 gpio_free(pdata->pin); 155 free_master: 156 kfree(master); 157 158 return err; 159 } 160 161 static int __exit w1_gpio_remove(struct platform_device *pdev) 162 { 163 struct w1_bus_master *master = platform_get_drvdata(pdev); 164 struct w1_gpio_platform_data *pdata = pdev->dev.platform_data; 165 166 if (pdata->enable_external_pullup) 167 pdata->enable_external_pullup(0); 168 169 if (gpio_is_valid(pdata->ext_pullup_enable_pin)) 170 gpio_set_value(pdata->ext_pullup_enable_pin, 0); 171 172 w1_remove_master_device(master); 173 gpio_free(pdata->pin); 174 kfree(master); 175 176 return 0; 177 } 178 179 #ifdef CONFIG_PM 180 181 static int w1_gpio_suspend(struct platform_device *pdev, pm_message_t state) 182 { 183 struct w1_gpio_platform_data *pdata = pdev->dev.platform_data; 184 185 if (pdata->enable_external_pullup) 186 pdata->enable_external_pullup(0); 187 188 return 0; 189 } 190 191 static int w1_gpio_resume(struct platform_device *pdev) 192 { 193 struct w1_gpio_platform_data *pdata = pdev->dev.platform_data; 194 195 if (pdata->enable_external_pullup) 196 pdata->enable_external_pullup(1); 197 198 return 0; 199 } 200 201 #else 202 #define w1_gpio_suspend NULL 203 #define w1_gpio_resume NULL 204 #endif 205 206 static struct platform_driver w1_gpio_driver = { 207 .driver = { 208 .name = "w1-gpio", 209 .owner = THIS_MODULE, 210 .of_match_table = of_match_ptr(w1_gpio_dt_ids), 211 }, 212 .probe = w1_gpio_probe, 213 .remove = __exit_p(w1_gpio_remove), 214 .suspend = w1_gpio_suspend, 215 .resume = w1_gpio_resume, 216 }; 217 218 module_platform_driver(w1_gpio_driver); 219 220 MODULE_DESCRIPTION("GPIO w1 bus master driver"); 221 MODULE_AUTHOR("Ville Syrjala <syrjala@sci.fi>"); 222 MODULE_LICENSE("GPL"); 223