1 /* 2 * phy.c -- USB phy handling 3 * 4 * Copyright (C) 2004-2013 Texas Instruments 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 #include <linux/kernel.h> 12 #include <linux/export.h> 13 #include <linux/err.h> 14 #include <linux/device.h> 15 #include <linux/module.h> 16 #include <linux/slab.h> 17 #include <linux/of.h> 18 19 #include <linux/usb/phy.h> 20 21 static LIST_HEAD(phy_list); 22 static LIST_HEAD(phy_bind_list); 23 static DEFINE_SPINLOCK(phy_lock); 24 25 static struct usb_phy *__usb_find_phy(struct list_head *list, 26 enum usb_phy_type type) 27 { 28 struct usb_phy *phy = NULL; 29 30 list_for_each_entry(phy, list, head) { 31 if (phy->type != type) 32 continue; 33 34 return phy; 35 } 36 37 return ERR_PTR(-ENODEV); 38 } 39 40 static struct usb_phy *__usb_find_phy_dev(struct device *dev, 41 struct list_head *list, u8 index) 42 { 43 struct usb_phy_bind *phy_bind = NULL; 44 45 list_for_each_entry(phy_bind, list, list) { 46 if (!(strcmp(phy_bind->dev_name, dev_name(dev))) && 47 phy_bind->index == index) { 48 if (phy_bind->phy) 49 return phy_bind->phy; 50 else 51 return ERR_PTR(-EPROBE_DEFER); 52 } 53 } 54 55 return ERR_PTR(-ENODEV); 56 } 57 58 static struct usb_phy *__of_usb_find_phy(struct device_node *node) 59 { 60 struct usb_phy *phy; 61 62 list_for_each_entry(phy, &phy_list, head) { 63 if (node != phy->dev->of_node) 64 continue; 65 66 return phy; 67 } 68 69 return ERR_PTR(-ENODEV); 70 } 71 72 static void devm_usb_phy_release(struct device *dev, void *res) 73 { 74 struct usb_phy *phy = *(struct usb_phy **)res; 75 76 usb_put_phy(phy); 77 } 78 79 static int devm_usb_phy_match(struct device *dev, void *res, void *match_data) 80 { 81 return res == match_data; 82 } 83 84 /** 85 * devm_usb_get_phy - find the USB PHY 86 * @dev - device that requests this phy 87 * @type - the type of the phy the controller requires 88 * 89 * Gets the phy using usb_get_phy(), and associates a device with it using 90 * devres. On driver detach, release function is invoked on the devres data, 91 * then, devres data is freed. 92 * 93 * For use by USB host and peripheral drivers. 94 */ 95 struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type) 96 { 97 struct usb_phy **ptr, *phy; 98 99 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL); 100 if (!ptr) 101 return ERR_PTR(-ENOMEM); 102 103 phy = usb_get_phy(type); 104 if (!IS_ERR(phy)) { 105 *ptr = phy; 106 devres_add(dev, ptr); 107 } else 108 devres_free(ptr); 109 110 return phy; 111 } 112 EXPORT_SYMBOL_GPL(devm_usb_get_phy); 113 114 /** 115 * usb_get_phy - find the USB PHY 116 * @type - the type of the phy the controller requires 117 * 118 * Returns the phy driver, after getting a refcount to it; or 119 * -ENODEV if there is no such phy. The caller is responsible for 120 * calling usb_put_phy() to release that count. 121 * 122 * For use by USB host and peripheral drivers. 123 */ 124 struct usb_phy *usb_get_phy(enum usb_phy_type type) 125 { 126 struct usb_phy *phy = NULL; 127 unsigned long flags; 128 129 spin_lock_irqsave(&phy_lock, flags); 130 131 phy = __usb_find_phy(&phy_list, type); 132 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) { 133 pr_debug("PHY: unable to find transceiver of type %s\n", 134 usb_phy_type_string(type)); 135 if (!IS_ERR(phy)) 136 phy = ERR_PTR(-ENODEV); 137 138 goto err0; 139 } 140 141 get_device(phy->dev); 142 143 err0: 144 spin_unlock_irqrestore(&phy_lock, flags); 145 146 return phy; 147 } 148 EXPORT_SYMBOL_GPL(usb_get_phy); 149 150 /** 151 * devm_usb_get_phy_by_phandle - find the USB PHY by phandle 152 * @dev - device that requests this phy 153 * @phandle - name of the property holding the phy phandle value 154 * @index - the index of the phy 155 * 156 * Returns the phy driver associated with the given phandle value, 157 * after getting a refcount to it, -ENODEV if there is no such phy or 158 * -EPROBE_DEFER if there is a phandle to the phy, but the device is 159 * not yet loaded. While at that, it also associates the device with 160 * the phy using devres. On driver detach, release function is invoked 161 * on the devres data, then, devres data is freed. 162 * 163 * For use by USB host and peripheral drivers. 164 */ 165 struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev, 166 const char *phandle, u8 index) 167 { 168 struct usb_phy *phy = ERR_PTR(-ENOMEM), **ptr; 169 unsigned long flags; 170 struct device_node *node; 171 172 if (!dev->of_node) { 173 dev_dbg(dev, "device does not have a device node entry\n"); 174 return ERR_PTR(-EINVAL); 175 } 176 177 node = of_parse_phandle(dev->of_node, phandle, index); 178 if (!node) { 179 dev_dbg(dev, "failed to get %s phandle in %s node\n", phandle, 180 dev->of_node->full_name); 181 return ERR_PTR(-ENODEV); 182 } 183 184 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL); 185 if (!ptr) { 186 dev_dbg(dev, "failed to allocate memory for devres\n"); 187 goto err0; 188 } 189 190 spin_lock_irqsave(&phy_lock, flags); 191 192 phy = __of_usb_find_phy(node); 193 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) { 194 if (!IS_ERR(phy)) 195 phy = ERR_PTR(-EPROBE_DEFER); 196 197 devres_free(ptr); 198 goto err1; 199 } 200 201 *ptr = phy; 202 devres_add(dev, ptr); 203 204 get_device(phy->dev); 205 206 err1: 207 spin_unlock_irqrestore(&phy_lock, flags); 208 209 err0: 210 of_node_put(node); 211 212 return phy; 213 } 214 EXPORT_SYMBOL_GPL(devm_usb_get_phy_by_phandle); 215 216 /** 217 * usb_get_phy_dev - find the USB PHY 218 * @dev - device that requests this phy 219 * @index - the index of the phy 220 * 221 * Returns the phy driver, after getting a refcount to it; or 222 * -ENODEV if there is no such phy. The caller is responsible for 223 * calling usb_put_phy() to release that count. 224 * 225 * For use by USB host and peripheral drivers. 226 */ 227 struct usb_phy *usb_get_phy_dev(struct device *dev, u8 index) 228 { 229 struct usb_phy *phy = NULL; 230 unsigned long flags; 231 232 spin_lock_irqsave(&phy_lock, flags); 233 234 phy = __usb_find_phy_dev(dev, &phy_bind_list, index); 235 if (IS_ERR(phy) || !try_module_get(phy->dev->driver->owner)) { 236 dev_dbg(dev, "unable to find transceiver\n"); 237 if (!IS_ERR(phy)) 238 phy = ERR_PTR(-ENODEV); 239 240 goto err0; 241 } 242 243 get_device(phy->dev); 244 245 err0: 246 spin_unlock_irqrestore(&phy_lock, flags); 247 248 return phy; 249 } 250 EXPORT_SYMBOL_GPL(usb_get_phy_dev); 251 252 /** 253 * devm_usb_get_phy_dev - find the USB PHY using device ptr and index 254 * @dev - device that requests this phy 255 * @index - the index of the phy 256 * 257 * Gets the phy using usb_get_phy_dev(), and associates a device with it using 258 * devres. On driver detach, release function is invoked on the devres data, 259 * then, devres data is freed. 260 * 261 * For use by USB host and peripheral drivers. 262 */ 263 struct usb_phy *devm_usb_get_phy_dev(struct device *dev, u8 index) 264 { 265 struct usb_phy **ptr, *phy; 266 267 ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL); 268 if (!ptr) 269 return NULL; 270 271 phy = usb_get_phy_dev(dev, index); 272 if (!IS_ERR(phy)) { 273 *ptr = phy; 274 devres_add(dev, ptr); 275 } else 276 devres_free(ptr); 277 278 return phy; 279 } 280 EXPORT_SYMBOL_GPL(devm_usb_get_phy_dev); 281 282 /** 283 * devm_usb_put_phy - release the USB PHY 284 * @dev - device that wants to release this phy 285 * @phy - the phy returned by devm_usb_get_phy() 286 * 287 * destroys the devres associated with this phy and invokes usb_put_phy 288 * to release the phy. 289 * 290 * For use by USB host and peripheral drivers. 291 */ 292 void devm_usb_put_phy(struct device *dev, struct usb_phy *phy) 293 { 294 int r; 295 296 r = devres_destroy(dev, devm_usb_phy_release, devm_usb_phy_match, phy); 297 dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n"); 298 } 299 EXPORT_SYMBOL_GPL(devm_usb_put_phy); 300 301 /** 302 * usb_put_phy - release the USB PHY 303 * @x: the phy returned by usb_get_phy() 304 * 305 * Releases a refcount the caller received from usb_get_phy(). 306 * 307 * For use by USB host and peripheral drivers. 308 */ 309 void usb_put_phy(struct usb_phy *x) 310 { 311 if (x) { 312 struct module *owner = x->dev->driver->owner; 313 314 put_device(x->dev); 315 module_put(owner); 316 } 317 } 318 EXPORT_SYMBOL_GPL(usb_put_phy); 319 320 /** 321 * usb_add_phy - declare the USB PHY 322 * @x: the USB phy to be used; or NULL 323 * @type - the type of this PHY 324 * 325 * This call is exclusively for use by phy drivers, which 326 * coordinate the activities of drivers for host and peripheral 327 * controllers, and in some cases for VBUS current regulation. 328 */ 329 int usb_add_phy(struct usb_phy *x, enum usb_phy_type type) 330 { 331 int ret = 0; 332 unsigned long flags; 333 struct usb_phy *phy; 334 335 if (x->type != USB_PHY_TYPE_UNDEFINED) { 336 dev_err(x->dev, "not accepting initialized PHY %s\n", x->label); 337 return -EINVAL; 338 } 339 340 ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier); 341 342 spin_lock_irqsave(&phy_lock, flags); 343 344 list_for_each_entry(phy, &phy_list, head) { 345 if (phy->type == type) { 346 ret = -EBUSY; 347 dev_err(x->dev, "transceiver type %s already exists\n", 348 usb_phy_type_string(type)); 349 goto out; 350 } 351 } 352 353 x->type = type; 354 list_add_tail(&x->head, &phy_list); 355 356 out: 357 spin_unlock_irqrestore(&phy_lock, flags); 358 return ret; 359 } 360 EXPORT_SYMBOL_GPL(usb_add_phy); 361 362 /** 363 * usb_add_phy_dev - declare the USB PHY 364 * @x: the USB phy to be used; or NULL 365 * 366 * This call is exclusively for use by phy drivers, which 367 * coordinate the activities of drivers for host and peripheral 368 * controllers, and in some cases for VBUS current regulation. 369 */ 370 int usb_add_phy_dev(struct usb_phy *x) 371 { 372 struct usb_phy_bind *phy_bind; 373 unsigned long flags; 374 375 if (!x->dev) { 376 dev_err(x->dev, "no device provided for PHY\n"); 377 return -EINVAL; 378 } 379 380 ATOMIC_INIT_NOTIFIER_HEAD(&x->notifier); 381 382 spin_lock_irqsave(&phy_lock, flags); 383 list_for_each_entry(phy_bind, &phy_bind_list, list) 384 if (!(strcmp(phy_bind->phy_dev_name, dev_name(x->dev)))) 385 phy_bind->phy = x; 386 387 list_add_tail(&x->head, &phy_list); 388 389 spin_unlock_irqrestore(&phy_lock, flags); 390 return 0; 391 } 392 EXPORT_SYMBOL_GPL(usb_add_phy_dev); 393 394 /** 395 * usb_remove_phy - remove the OTG PHY 396 * @x: the USB OTG PHY to be removed; 397 * 398 * This reverts the effects of usb_add_phy 399 */ 400 void usb_remove_phy(struct usb_phy *x) 401 { 402 unsigned long flags; 403 struct usb_phy_bind *phy_bind; 404 405 spin_lock_irqsave(&phy_lock, flags); 406 if (x) { 407 list_for_each_entry(phy_bind, &phy_bind_list, list) 408 if (phy_bind->phy == x) 409 phy_bind->phy = NULL; 410 list_del(&x->head); 411 } 412 spin_unlock_irqrestore(&phy_lock, flags); 413 } 414 EXPORT_SYMBOL_GPL(usb_remove_phy); 415 416 /** 417 * usb_bind_phy - bind the phy and the controller that uses the phy 418 * @dev_name: the device name of the device that will bind to the phy 419 * @index: index to specify the port number 420 * @phy_dev_name: the device name of the phy 421 * 422 * Fills the phy_bind structure with the dev_name and phy_dev_name. This will 423 * be used when the phy driver registers the phy and when the controller 424 * requests this phy. 425 * 426 * To be used by platform specific initialization code. 427 */ 428 int usb_bind_phy(const char *dev_name, u8 index, 429 const char *phy_dev_name) 430 { 431 struct usb_phy_bind *phy_bind; 432 unsigned long flags; 433 434 phy_bind = kzalloc(sizeof(*phy_bind), GFP_KERNEL); 435 if (!phy_bind) 436 return -ENOMEM; 437 438 phy_bind->dev_name = dev_name; 439 phy_bind->phy_dev_name = phy_dev_name; 440 phy_bind->index = index; 441 442 spin_lock_irqsave(&phy_lock, flags); 443 list_add_tail(&phy_bind->list, &phy_bind_list); 444 spin_unlock_irqrestore(&phy_lock, flags); 445 446 return 0; 447 } 448 EXPORT_SYMBOL_GPL(usb_bind_phy); 449 450 /** 451 * usb_phy_set_event - set event to phy event 452 * @x: the phy returned by usb_get_phy(); 453 * 454 * This sets event to phy event 455 */ 456 void usb_phy_set_event(struct usb_phy *x, unsigned long event) 457 { 458 x->last_event = event; 459 } 460 EXPORT_SYMBOL_GPL(usb_phy_set_event); 461