Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 1 | /* |
| 2 | * Driver for SMSC USB3503 USB 2.0 hub controller driver |
| 3 | * |
| 4 | * Copyright (c) 2012-2013 Dongjin Kim (tobetter@gmail.com) |
| 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 as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 19 | */ |
| 20 | |
Marek Szyprowski | 657d898 | 2014-05-22 13:21:38 +0200 | [diff] [blame] | 21 | #include <linux/clk.h> |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 22 | #include <linux/i2c.h> |
| 23 | #include <linux/gpio.h> |
| 24 | #include <linux/delay.h> |
| 25 | #include <linux/slab.h> |
| 26 | #include <linux/module.h> |
Dongjin Kim | eab8050 | 2013-01-24 02:47:10 +0900 | [diff] [blame] | 27 | #include <linux/of_gpio.h> |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 28 | #include <linux/platform_device.h> |
| 29 | #include <linux/platform_data/usb3503.h> |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 30 | #include <linux/regmap.h> |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 31 | |
| 32 | #define USB3503_VIDL 0x00 |
| 33 | #define USB3503_VIDM 0x01 |
| 34 | #define USB3503_PIDL 0x02 |
| 35 | #define USB3503_PIDM 0x03 |
| 36 | #define USB3503_DIDL 0x04 |
| 37 | #define USB3503_DIDM 0x05 |
| 38 | |
| 39 | #define USB3503_CFG1 0x06 |
| 40 | #define USB3503_SELF_BUS_PWR (1 << 7) |
| 41 | |
| 42 | #define USB3503_CFG2 0x07 |
| 43 | #define USB3503_CFG3 0x08 |
| 44 | #define USB3503_NRD 0x09 |
| 45 | |
| 46 | #define USB3503_PDS 0x0a |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 47 | |
| 48 | #define USB3503_SP_ILOCK 0xe7 |
| 49 | #define USB3503_SPILOCK_CONNECT (1 << 1) |
| 50 | #define USB3503_SPILOCK_CONFIG (1 << 0) |
| 51 | |
| 52 | #define USB3503_CFGP 0xee |
| 53 | #define USB3503_CLKSUSP (1 << 7) |
| 54 | |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 55 | #define USB3503_RESET 0xff |
| 56 | |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 57 | struct usb3503 { |
| 58 | enum usb3503_mode mode; |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 59 | struct regmap *regmap; |
| 60 | struct device *dev; |
Marek Szyprowski | 657d898 | 2014-05-22 13:21:38 +0200 | [diff] [blame] | 61 | struct clk *clk; |
Dongjin Kim | e8e44a4 | 2013-05-22 05:20:08 +0900 | [diff] [blame] | 62 | u8 port_off_mask; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 63 | int gpio_intn; |
| 64 | int gpio_reset; |
| 65 | int gpio_connect; |
Marek Szyprowski | 657d898 | 2014-05-22 13:21:38 +0200 | [diff] [blame] | 66 | bool secondary_ref_clk; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 67 | }; |
| 68 | |
Mark Brown | 8e7245b | 2013-08-09 11:41:51 +0100 | [diff] [blame] | 69 | static int usb3503_reset(struct usb3503 *hub, int state) |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 70 | { |
Mark Brown | 8e7245b | 2013-08-09 11:41:51 +0100 | [diff] [blame] | 71 | if (!state && gpio_is_valid(hub->gpio_connect)) |
| 72 | gpio_set_value_cansleep(hub->gpio_connect, 0); |
| 73 | |
| 74 | if (gpio_is_valid(hub->gpio_reset)) |
| 75 | gpio_set_value_cansleep(hub->gpio_reset, state); |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 76 | |
Julius Werner | 06a962f | 2013-05-31 18:34:52 -0700 | [diff] [blame] | 77 | /* Wait T_HUBINIT == 4ms for hub logic to stabilize */ |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 78 | if (state) |
Julius Werner | 06a962f | 2013-05-31 18:34:52 -0700 | [diff] [blame] | 79 | usleep_range(4000, 10000); |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 80 | |
| 81 | return 0; |
| 82 | } |
| 83 | |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 84 | static int usb3503_connect(struct usb3503 *hub) |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 85 | { |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 86 | struct device *dev = hub->dev; |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 87 | int err; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 88 | |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 89 | usb3503_reset(hub, 1); |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 90 | |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 91 | if (hub->regmap) { |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 92 | /* SP_ILOCK: set connect_n, config_n for config */ |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 93 | err = regmap_write(hub->regmap, USB3503_SP_ILOCK, |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 94 | (USB3503_SPILOCK_CONNECT |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 95 | | USB3503_SPILOCK_CONFIG)); |
| 96 | if (err < 0) { |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 97 | dev_err(dev, "SP_ILOCK failed (%d)\n", err); |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 98 | return err; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 99 | } |
| 100 | |
Tobias Jakobi | 4463e15 | 2014-09-05 07:19:48 +0200 | [diff] [blame] | 101 | /* PDS : Set the ports which are disabled in self-powered mode. */ |
Dongjin Kim | e8e44a4 | 2013-05-22 05:20:08 +0900 | [diff] [blame] | 102 | if (hub->port_off_mask) { |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 103 | err = regmap_update_bits(hub->regmap, USB3503_PDS, |
| 104 | hub->port_off_mask, |
Dongjin Kim | e8e44a4 | 2013-05-22 05:20:08 +0900 | [diff] [blame] | 105 | hub->port_off_mask); |
| 106 | if (err < 0) { |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 107 | dev_err(dev, "PDS failed (%d)\n", err); |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 108 | return err; |
Dongjin Kim | e8e44a4 | 2013-05-22 05:20:08 +0900 | [diff] [blame] | 109 | } |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 110 | } |
| 111 | |
Tobias Jakobi | 4463e15 | 2014-09-05 07:19:48 +0200 | [diff] [blame] | 112 | /* CFG1 : Set SELF_BUS_PWR, this enables self-powered operation. */ |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 113 | err = regmap_update_bits(hub->regmap, USB3503_CFG1, |
| 114 | USB3503_SELF_BUS_PWR, |
| 115 | USB3503_SELF_BUS_PWR); |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 116 | if (err < 0) { |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 117 | dev_err(dev, "CFG1 failed (%d)\n", err); |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 118 | return err; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 119 | } |
| 120 | |
| 121 | /* SP_LOCK: clear connect_n, config_n for hub connect */ |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 122 | err = regmap_update_bits(hub->regmap, USB3503_SP_ILOCK, |
| 123 | (USB3503_SPILOCK_CONNECT |
| 124 | | USB3503_SPILOCK_CONFIG), 0); |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 125 | if (err < 0) { |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 126 | dev_err(dev, "SP_ILOCK failed (%d)\n", err); |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 127 | return err; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 128 | } |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 129 | } |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 130 | |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 131 | if (gpio_is_valid(hub->gpio_connect)) |
| 132 | gpio_set_value_cansleep(hub->gpio_connect, 1); |
Mark Brown | 8e7245b | 2013-08-09 11:41:51 +0100 | [diff] [blame] | 133 | |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 134 | hub->mode = USB3503_MODE_HUB; |
| 135 | dev_info(dev, "switched to HUB mode\n"); |
| 136 | |
| 137 | return 0; |
| 138 | } |
| 139 | |
| 140 | static int usb3503_switch_mode(struct usb3503 *hub, enum usb3503_mode mode) |
| 141 | { |
| 142 | struct device *dev = hub->dev; |
| 143 | int err = 0; |
| 144 | |
| 145 | switch (mode) { |
| 146 | case USB3503_MODE_HUB: |
| 147 | err = usb3503_connect(hub); |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 148 | break; |
| 149 | |
| 150 | case USB3503_MODE_STANDBY: |
Mark Brown | 8e7245b | 2013-08-09 11:41:51 +0100 | [diff] [blame] | 151 | usb3503_reset(hub, 0); |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 152 | dev_info(dev, "switched to STANDBY mode\n"); |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 153 | break; |
| 154 | |
| 155 | default: |
Mark Brown | dd8e670 | 2013-08-09 11:41:54 +0100 | [diff] [blame] | 156 | dev_err(dev, "unknown mode is requested\n"); |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 157 | err = -EINVAL; |
| 158 | break; |
| 159 | } |
| 160 | |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 161 | return err; |
| 162 | } |
| 163 | |
Mark Brown | 68b1413 | 2013-08-09 11:41:52 +0100 | [diff] [blame] | 164 | static const struct regmap_config usb3503_regmap_config = { |
| 165 | .reg_bits = 8, |
| 166 | .val_bits = 8, |
| 167 | |
| 168 | .max_register = USB3503_RESET, |
| 169 | }; |
| 170 | |
Mark Brown | 2487e3e | 2013-08-09 11:41:53 +0100 | [diff] [blame] | 171 | static int usb3503_probe(struct usb3503 *hub) |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 172 | { |
Mark Brown | 2487e3e | 2013-08-09 11:41:53 +0100 | [diff] [blame] | 173 | struct device *dev = hub->dev; |
| 174 | struct usb3503_platform_data *pdata = dev_get_platdata(dev); |
| 175 | struct device_node *np = dev->of_node; |
| 176 | int err; |
Mark Brown | e5a0c87 | 2013-08-09 11:41:55 +0100 | [diff] [blame] | 177 | u32 mode = USB3503_MODE_HUB; |
Dongjin Kim | e8b58b4 | 2013-05-22 05:20:09 +0900 | [diff] [blame] | 178 | const u32 *property; |
| 179 | int len; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 180 | |
Dongjin Kim | eab8050 | 2013-01-24 02:47:10 +0900 | [diff] [blame] | 181 | if (pdata) { |
Dongjin Kim | e8e44a4 | 2013-05-22 05:20:08 +0900 | [diff] [blame] | 182 | hub->port_off_mask = pdata->port_off_mask; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 183 | hub->gpio_intn = pdata->gpio_intn; |
| 184 | hub->gpio_connect = pdata->gpio_connect; |
| 185 | hub->gpio_reset = pdata->gpio_reset; |
| 186 | hub->mode = pdata->initial_mode; |
Dongjin Kim | eab8050 | 2013-01-24 02:47:10 +0900 | [diff] [blame] | 187 | } else if (np) { |
Marek Szyprowski | 657d898 | 2014-05-22 13:21:38 +0200 | [diff] [blame] | 188 | struct clk *clk; |
Dongjin Kim | e8b58b4 | 2013-05-22 05:20:09 +0900 | [diff] [blame] | 189 | hub->port_off_mask = 0; |
| 190 | |
Marek Szyprowski | 657d898 | 2014-05-22 13:21:38 +0200 | [diff] [blame] | 191 | clk = devm_clk_get(dev, "refclk"); |
| 192 | if (IS_ERR(clk) && PTR_ERR(clk) != -ENOENT) { |
Tushar Behera | ec5734c | 2014-06-17 16:38:50 +0530 | [diff] [blame] | 193 | dev_err(dev, "unable to request refclk (%ld)\n", |
| 194 | PTR_ERR(clk)); |
Marek Szyprowski | 657d898 | 2014-05-22 13:21:38 +0200 | [diff] [blame] | 195 | return PTR_ERR(clk); |
| 196 | } |
| 197 | |
| 198 | if (!IS_ERR(clk)) { |
| 199 | u32 rate = 0; |
| 200 | hub->clk = clk; |
| 201 | |
| 202 | if (!of_property_read_u32(np, "refclk-frequency", |
| 203 | &rate)) { |
| 204 | |
| 205 | switch (rate) { |
| 206 | case 38400000: |
| 207 | case 26000000: |
| 208 | case 19200000: |
| 209 | case 12000000: |
| 210 | hub->secondary_ref_clk = 0; |
| 211 | break; |
| 212 | case 24000000: |
| 213 | case 27000000: |
| 214 | case 25000000: |
| 215 | case 50000000: |
| 216 | hub->secondary_ref_clk = 1; |
| 217 | break; |
| 218 | default: |
| 219 | dev_err(dev, |
| 220 | "unsupported reference clock rate (%d)\n", |
| 221 | (int) rate); |
| 222 | return -EINVAL; |
| 223 | } |
| 224 | err = clk_set_rate(hub->clk, rate); |
| 225 | if (err) { |
| 226 | dev_err(dev, |
| 227 | "unable to set reference clock rate to %d\n", |
| 228 | (int) rate); |
| 229 | return err; |
| 230 | } |
| 231 | } |
| 232 | |
| 233 | err = clk_prepare_enable(hub->clk); |
| 234 | if (err) { |
| 235 | dev_err(dev, |
| 236 | "unable to enable reference clock\n"); |
| 237 | return err; |
| 238 | } |
| 239 | } |
| 240 | |
Dongjin Kim | e8b58b4 | 2013-05-22 05:20:09 +0900 | [diff] [blame] | 241 | property = of_get_property(np, "disabled-ports", &len); |
| 242 | if (property && (len / sizeof(u32)) > 0) { |
| 243 | int i; |
| 244 | for (i = 0; i < len / sizeof(u32); i++) { |
| 245 | u32 port = be32_to_cpu(property[i]); |
| 246 | if ((1 <= port) && (port <= 3)) |
| 247 | hub->port_off_mask |= (1 << port); |
| 248 | } |
| 249 | } |
| 250 | |
Mark Brown | 42416cc | 2013-08-07 20:28:24 +0100 | [diff] [blame] | 251 | hub->gpio_intn = of_get_named_gpio(np, "intn-gpios", 0); |
Dongjin Kim | eab8050 | 2013-01-24 02:47:10 +0900 | [diff] [blame] | 252 | if (hub->gpio_intn == -EPROBE_DEFER) |
| 253 | return -EPROBE_DEFER; |
Mark Brown | 42416cc | 2013-08-07 20:28:24 +0100 | [diff] [blame] | 254 | hub->gpio_connect = of_get_named_gpio(np, "connect-gpios", 0); |
Dongjin Kim | eab8050 | 2013-01-24 02:47:10 +0900 | [diff] [blame] | 255 | if (hub->gpio_connect == -EPROBE_DEFER) |
| 256 | return -EPROBE_DEFER; |
Julius Werner | ccf92c9 | 2013-05-31 18:34:50 -0700 | [diff] [blame] | 257 | hub->gpio_reset = of_get_named_gpio(np, "reset-gpios", 0); |
Dongjin Kim | eab8050 | 2013-01-24 02:47:10 +0900 | [diff] [blame] | 258 | if (hub->gpio_reset == -EPROBE_DEFER) |
| 259 | return -EPROBE_DEFER; |
| 260 | of_property_read_u32(np, "initial-mode", &mode); |
| 261 | hub->mode = mode; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 262 | } |
| 263 | |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 264 | if (hub->port_off_mask && !hub->regmap) |
| 265 | dev_err(dev, "Ports disabled with no control interface\n"); |
| 266 | |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 267 | if (gpio_is_valid(hub->gpio_intn)) { |
Marek Szyprowski | 657d898 | 2014-05-22 13:21:38 +0200 | [diff] [blame] | 268 | int val = hub->secondary_ref_clk ? GPIOF_OUT_INIT_LOW : |
| 269 | GPIOF_OUT_INIT_HIGH; |
| 270 | err = devm_gpio_request_one(dev, hub->gpio_intn, val, |
| 271 | "usb3503 intn"); |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 272 | if (err) { |
Mark Brown | 2487e3e | 2013-08-09 11:41:53 +0100 | [diff] [blame] | 273 | dev_err(dev, |
Tobias Jakobi | 6b08442 | 2014-09-05 07:19:46 +0200 | [diff] [blame] | 274 | "unable to request GPIO %d as interrupt pin (%d)\n", |
Mark Brown | 2487e3e | 2013-08-09 11:41:53 +0100 | [diff] [blame] | 275 | hub->gpio_intn, err); |
Mark Brown | cffedd6 | 2013-08-07 22:02:54 +0100 | [diff] [blame] | 276 | return err; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 277 | } |
| 278 | } |
| 279 | |
| 280 | if (gpio_is_valid(hub->gpio_connect)) { |
Mark Brown | 2487e3e | 2013-08-09 11:41:53 +0100 | [diff] [blame] | 281 | err = devm_gpio_request_one(dev, hub->gpio_connect, |
Mark Brown | 8e7245b | 2013-08-09 11:41:51 +0100 | [diff] [blame] | 282 | GPIOF_OUT_INIT_LOW, "usb3503 connect"); |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 283 | if (err) { |
Mark Brown | 2487e3e | 2013-08-09 11:41:53 +0100 | [diff] [blame] | 284 | dev_err(dev, |
| 285 | "unable to request GPIO %d as connect pin (%d)\n", |
| 286 | hub->gpio_connect, err); |
Mark Brown | cffedd6 | 2013-08-07 22:02:54 +0100 | [diff] [blame] | 287 | return err; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 288 | } |
| 289 | } |
| 290 | |
| 291 | if (gpio_is_valid(hub->gpio_reset)) { |
Mark Brown | 2487e3e | 2013-08-09 11:41:53 +0100 | [diff] [blame] | 292 | err = devm_gpio_request_one(dev, hub->gpio_reset, |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 293 | GPIOF_OUT_INIT_LOW, "usb3503 reset"); |
| 294 | if (err) { |
Mark Brown | 2487e3e | 2013-08-09 11:41:53 +0100 | [diff] [blame] | 295 | dev_err(dev, |
| 296 | "unable to request GPIO %d as reset pin (%d)\n", |
| 297 | hub->gpio_reset, err); |
Mark Brown | cffedd6 | 2013-08-07 22:02:54 +0100 | [diff] [blame] | 298 | return err; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 299 | } |
| 300 | } |
| 301 | |
Dongjin Kim | eab8050 | 2013-01-24 02:47:10 +0900 | [diff] [blame] | 302 | usb3503_switch_mode(hub, hub->mode); |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 303 | |
Mark Brown | dd8e670 | 2013-08-09 11:41:54 +0100 | [diff] [blame] | 304 | dev_info(dev, "%s: probed in %s mode\n", __func__, |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 305 | (hub->mode == USB3503_MODE_HUB) ? "hub" : "standby"); |
| 306 | |
| 307 | return 0; |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 308 | } |
| 309 | |
Mark Brown | 2487e3e | 2013-08-09 11:41:53 +0100 | [diff] [blame] | 310 | static int usb3503_i2c_probe(struct i2c_client *i2c, |
| 311 | const struct i2c_device_id *id) |
| 312 | { |
| 313 | struct usb3503 *hub; |
| 314 | int err; |
| 315 | |
| 316 | hub = devm_kzalloc(&i2c->dev, sizeof(struct usb3503), GFP_KERNEL); |
| 317 | if (!hub) { |
| 318 | dev_err(&i2c->dev, "private data alloc fail\n"); |
| 319 | return -ENOMEM; |
| 320 | } |
| 321 | |
| 322 | i2c_set_clientdata(i2c, hub); |
| 323 | hub->regmap = devm_regmap_init_i2c(i2c, &usb3503_regmap_config); |
| 324 | if (IS_ERR(hub->regmap)) { |
| 325 | err = PTR_ERR(hub->regmap); |
| 326 | dev_err(&i2c->dev, "Failed to initialise regmap: %d\n", err); |
| 327 | return err; |
| 328 | } |
| 329 | hub->dev = &i2c->dev; |
| 330 | |
| 331 | return usb3503_probe(hub); |
| 332 | } |
| 333 | |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 334 | static int usb3503_platform_probe(struct platform_device *pdev) |
| 335 | { |
| 336 | struct usb3503 *hub; |
| 337 | |
| 338 | hub = devm_kzalloc(&pdev->dev, sizeof(struct usb3503), GFP_KERNEL); |
| 339 | if (!hub) { |
| 340 | dev_err(&pdev->dev, "private data alloc fail\n"); |
| 341 | return -ENOMEM; |
| 342 | } |
| 343 | hub->dev = &pdev->dev; |
| 344 | |
| 345 | return usb3503_probe(hub); |
| 346 | } |
| 347 | |
Joonyoung Shim | ecdc071 | 2014-07-10 14:22:34 +0900 | [diff] [blame] | 348 | #ifdef CONFIG_PM_SLEEP |
| 349 | static int usb3503_i2c_suspend(struct device *dev) |
| 350 | { |
| 351 | struct i2c_client *client = to_i2c_client(dev); |
| 352 | struct usb3503 *hub = i2c_get_clientdata(client); |
| 353 | |
| 354 | usb3503_switch_mode(hub, USB3503_MODE_STANDBY); |
| 355 | |
| 356 | if (hub->clk) |
| 357 | clk_disable_unprepare(hub->clk); |
| 358 | |
| 359 | return 0; |
| 360 | } |
| 361 | |
| 362 | static int usb3503_i2c_resume(struct device *dev) |
| 363 | { |
| 364 | struct i2c_client *client = to_i2c_client(dev); |
| 365 | struct usb3503 *hub = i2c_get_clientdata(client); |
| 366 | |
| 367 | if (hub->clk) |
| 368 | clk_prepare_enable(hub->clk); |
| 369 | |
| 370 | usb3503_switch_mode(hub, hub->mode); |
| 371 | |
| 372 | return 0; |
| 373 | } |
| 374 | #endif |
| 375 | |
| 376 | static SIMPLE_DEV_PM_OPS(usb3503_i2c_pm_ops, usb3503_i2c_suspend, |
| 377 | usb3503_i2c_resume); |
| 378 | |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 379 | static const struct i2c_device_id usb3503_id[] = { |
| 380 | { USB3503_I2C_NAME, 0 }, |
| 381 | { } |
| 382 | }; |
| 383 | MODULE_DEVICE_TABLE(i2c, usb3503_id); |
| 384 | |
Dongjin Kim | eab8050 | 2013-01-24 02:47:10 +0900 | [diff] [blame] | 385 | #ifdef CONFIG_OF |
| 386 | static const struct of_device_id usb3503_of_match[] = { |
| 387 | { .compatible = "smsc,usb3503", }, |
Mark Brown | 5bdd1f4 | 2013-08-09 11:41:56 +0100 | [diff] [blame] | 388 | { .compatible = "smsc,usb3503a", }, |
Dongjin Kim | eab8050 | 2013-01-24 02:47:10 +0900 | [diff] [blame] | 389 | {}, |
| 390 | }; |
| 391 | MODULE_DEVICE_TABLE(of, usb3503_of_match); |
| 392 | #endif |
| 393 | |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 394 | static struct i2c_driver usb3503_i2c_driver = { |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 395 | .driver = { |
| 396 | .name = USB3503_I2C_NAME, |
Joonyoung Shim | ecdc071 | 2014-07-10 14:22:34 +0900 | [diff] [blame] | 397 | .pm = &usb3503_i2c_pm_ops, |
Dongjin Kim | eab8050 | 2013-01-24 02:47:10 +0900 | [diff] [blame] | 398 | .of_match_table = of_match_ptr(usb3503_of_match), |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 399 | }, |
Mark Brown | 2487e3e | 2013-08-09 11:41:53 +0100 | [diff] [blame] | 400 | .probe = usb3503_i2c_probe, |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 401 | .id_table = usb3503_id, |
| 402 | }; |
| 403 | |
Mark Brown | 3f0d1c6 | 2013-08-09 11:41:58 +0100 | [diff] [blame] | 404 | static struct platform_driver usb3503_platform_driver = { |
| 405 | .driver = { |
| 406 | .name = USB3503_I2C_NAME, |
| 407 | .of_match_table = of_match_ptr(usb3503_of_match), |
| 408 | .owner = THIS_MODULE, |
| 409 | }, |
| 410 | .probe = usb3503_platform_probe, |
| 411 | }; |
| 412 | |
| 413 | static int __init usb3503_init(void) |
| 414 | { |
| 415 | int err; |
| 416 | |
| 417 | err = i2c_register_driver(THIS_MODULE, &usb3503_i2c_driver); |
| 418 | if (err != 0) |
| 419 | pr_err("usb3503: Failed to register I2C driver: %d\n", err); |
| 420 | |
| 421 | err = platform_driver_register(&usb3503_platform_driver); |
| 422 | if (err != 0) |
| 423 | pr_err("usb3503: Failed to register platform driver: %d\n", |
| 424 | err); |
| 425 | |
| 426 | return 0; |
| 427 | } |
| 428 | module_init(usb3503_init); |
| 429 | |
| 430 | static void __exit usb3503_exit(void) |
| 431 | { |
| 432 | platform_driver_unregister(&usb3503_platform_driver); |
| 433 | i2c_del_driver(&usb3503_i2c_driver); |
| 434 | } |
| 435 | module_exit(usb3503_exit); |
Dongjin Kim | 6a099c6 | 2012-12-08 05:18:44 +0900 | [diff] [blame] | 436 | |
| 437 | MODULE_AUTHOR("Dongjin Kim <tobetter@gmail.com>"); |
| 438 | MODULE_DESCRIPTION("USB3503 USB HUB driver"); |
| 439 | MODULE_LICENSE("GPL"); |