]> Pileus Git - ~andy/linux/blob - drivers/phy/phy-core.c
macvlan: Add support for 'always_on' offload features
[~andy/linux] / drivers / phy / phy-core.c
1 /*
2  * phy-core.c  --  Generic Phy framework.
3  *
4  * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com
5  *
6  * Author: Kishon Vijay Abraham I <kishon@ti.com>
7  *
8  * This program is free software; you can redistribute  it and/or modify it
9  * under  the terms of  the GNU General  Public License as published by the
10  * Free Software Foundation;  either version 2 of the  License, or (at your
11  * option) any later version.
12  */
13
14 #include <linux/kernel.h>
15 #include <linux/export.h>
16 #include <linux/module.h>
17 #include <linux/err.h>
18 #include <linux/device.h>
19 #include <linux/slab.h>
20 #include <linux/of.h>
21 #include <linux/phy/phy.h>
22 #include <linux/idr.h>
23 #include <linux/pm_runtime.h>
24
25 static struct class *phy_class;
26 static DEFINE_MUTEX(phy_provider_mutex);
27 static LIST_HEAD(phy_provider_list);
28 static DEFINE_IDA(phy_ida);
29
30 static void devm_phy_release(struct device *dev, void *res)
31 {
32         struct phy *phy = *(struct phy **)res;
33
34         phy_put(phy);
35 }
36
37 static void devm_phy_provider_release(struct device *dev, void *res)
38 {
39         struct phy_provider *phy_provider = *(struct phy_provider **)res;
40
41         of_phy_provider_unregister(phy_provider);
42 }
43
44 static void devm_phy_consume(struct device *dev, void *res)
45 {
46         struct phy *phy = *(struct phy **)res;
47
48         phy_destroy(phy);
49 }
50
51 static int devm_phy_match(struct device *dev, void *res, void *match_data)
52 {
53         return res == match_data;
54 }
55
56 static struct phy *phy_lookup(struct device *device, const char *port)
57 {
58         unsigned int count;
59         struct phy *phy;
60         struct device *dev;
61         struct phy_consumer *consumers;
62         struct class_dev_iter iter;
63
64         class_dev_iter_init(&iter, phy_class, NULL, NULL);
65         while ((dev = class_dev_iter_next(&iter))) {
66                 phy = to_phy(dev);
67                 count = phy->init_data->num_consumers;
68                 consumers = phy->init_data->consumers;
69                 while (count--) {
70                         if (!strcmp(consumers->dev_name, dev_name(device)) &&
71                                         !strcmp(consumers->port, port)) {
72                                 class_dev_iter_exit(&iter);
73                                 return phy;
74                         }
75                         consumers++;
76                 }
77         }
78
79         class_dev_iter_exit(&iter);
80         return ERR_PTR(-ENODEV);
81 }
82
83 static struct phy_provider *of_phy_provider_lookup(struct device_node *node)
84 {
85         struct phy_provider *phy_provider;
86
87         list_for_each_entry(phy_provider, &phy_provider_list, list) {
88                 if (phy_provider->dev->of_node == node)
89                         return phy_provider;
90         }
91
92         return ERR_PTR(-EPROBE_DEFER);
93 }
94
95 int phy_pm_runtime_get(struct phy *phy)
96 {
97         int ret;
98
99         if (!pm_runtime_enabled(&phy->dev))
100                 return -ENOTSUPP;
101
102         ret = pm_runtime_get(&phy->dev);
103         if (ret < 0 && ret != -EINPROGRESS)
104                 pm_runtime_put_noidle(&phy->dev);
105
106         return ret;
107 }
108 EXPORT_SYMBOL_GPL(phy_pm_runtime_get);
109
110 int phy_pm_runtime_get_sync(struct phy *phy)
111 {
112         int ret;
113
114         if (!pm_runtime_enabled(&phy->dev))
115                 return -ENOTSUPP;
116
117         ret = pm_runtime_get_sync(&phy->dev);
118         if (ret < 0)
119                 pm_runtime_put_sync(&phy->dev);
120
121         return ret;
122 }
123 EXPORT_SYMBOL_GPL(phy_pm_runtime_get_sync);
124
125 int phy_pm_runtime_put(struct phy *phy)
126 {
127         if (!pm_runtime_enabled(&phy->dev))
128                 return -ENOTSUPP;
129
130         return pm_runtime_put(&phy->dev);
131 }
132 EXPORT_SYMBOL_GPL(phy_pm_runtime_put);
133
134 int phy_pm_runtime_put_sync(struct phy *phy)
135 {
136         if (!pm_runtime_enabled(&phy->dev))
137                 return -ENOTSUPP;
138
139         return pm_runtime_put_sync(&phy->dev);
140 }
141 EXPORT_SYMBOL_GPL(phy_pm_runtime_put_sync);
142
143 void phy_pm_runtime_allow(struct phy *phy)
144 {
145         if (!pm_runtime_enabled(&phy->dev))
146                 return;
147
148         pm_runtime_allow(&phy->dev);
149 }
150 EXPORT_SYMBOL_GPL(phy_pm_runtime_allow);
151
152 void phy_pm_runtime_forbid(struct phy *phy)
153 {
154         if (!pm_runtime_enabled(&phy->dev))
155                 return;
156
157         pm_runtime_forbid(&phy->dev);
158 }
159 EXPORT_SYMBOL_GPL(phy_pm_runtime_forbid);
160
161 int phy_init(struct phy *phy)
162 {
163         int ret;
164
165         if (!phy)
166                 return 0;
167
168         ret = phy_pm_runtime_get_sync(phy);
169         if (ret < 0 && ret != -ENOTSUPP)
170                 return ret;
171
172         mutex_lock(&phy->mutex);
173         if (phy->init_count == 0 && phy->ops->init) {
174                 ret = phy->ops->init(phy);
175                 if (ret < 0) {
176                         dev_err(&phy->dev, "phy init failed --> %d\n", ret);
177                         goto out;
178                 }
179         }
180         ++phy->init_count;
181
182 out:
183         mutex_unlock(&phy->mutex);
184         phy_pm_runtime_put(phy);
185         return ret;
186 }
187 EXPORT_SYMBOL_GPL(phy_init);
188
189 int phy_exit(struct phy *phy)
190 {
191         int ret;
192
193         if (!phy)
194                 return 0;
195
196         ret = phy_pm_runtime_get_sync(phy);
197         if (ret < 0 && ret != -ENOTSUPP)
198                 return ret;
199
200         mutex_lock(&phy->mutex);
201         if (phy->init_count == 1 && phy->ops->exit) {
202                 ret = phy->ops->exit(phy);
203                 if (ret < 0) {
204                         dev_err(&phy->dev, "phy exit failed --> %d\n", ret);
205                         goto out;
206                 }
207         }
208         --phy->init_count;
209
210 out:
211         mutex_unlock(&phy->mutex);
212         phy_pm_runtime_put(phy);
213         return ret;
214 }
215 EXPORT_SYMBOL_GPL(phy_exit);
216
217 int phy_power_on(struct phy *phy)
218 {
219         int ret;
220
221         if (!phy)
222                 return 0;
223
224         ret = phy_pm_runtime_get_sync(phy);
225         if (ret < 0 && ret != -ENOTSUPP)
226                 return ret;
227
228         mutex_lock(&phy->mutex);
229         if (phy->power_count == 0 && phy->ops->power_on) {
230                 ret = phy->ops->power_on(phy);
231                 if (ret < 0) {
232                         dev_err(&phy->dev, "phy poweron failed --> %d\n", ret);
233                         goto out;
234                 }
235         }
236         ++phy->power_count;
237         mutex_unlock(&phy->mutex);
238         return 0;
239
240 out:
241         mutex_unlock(&phy->mutex);
242         phy_pm_runtime_put_sync(phy);
243
244         return ret;
245 }
246 EXPORT_SYMBOL_GPL(phy_power_on);
247
248 int phy_power_off(struct phy *phy)
249 {
250         int ret;
251
252         if (!phy)
253                 return 0;
254
255         mutex_lock(&phy->mutex);
256         if (phy->power_count == 1 && phy->ops->power_off) {
257                 ret =  phy->ops->power_off(phy);
258                 if (ret < 0) {
259                         dev_err(&phy->dev, "phy poweroff failed --> %d\n", ret);
260                         mutex_unlock(&phy->mutex);
261                         return ret;
262                 }
263         }
264         --phy->power_count;
265         mutex_unlock(&phy->mutex);
266         phy_pm_runtime_put(phy);
267
268         return 0;
269 }
270 EXPORT_SYMBOL_GPL(phy_power_off);
271
272 /**
273  * of_phy_get() - lookup and obtain a reference to a phy by phandle
274  * @dev: device that requests this phy
275  * @index: the index of the phy
276  *
277  * Returns the phy associated with the given phandle value,
278  * after getting a refcount to it or -ENODEV if there is no such phy or
279  * -EPROBE_DEFER if there is a phandle to the phy, but the device is
280  * not yet loaded. This function uses of_xlate call back function provided
281  * while registering the phy_provider to find the phy instance.
282  */
283 static struct phy *of_phy_get(struct device *dev, int index)
284 {
285         int ret;
286         struct phy_provider *phy_provider;
287         struct phy *phy = NULL;
288         struct of_phandle_args args;
289
290         ret = of_parse_phandle_with_args(dev->of_node, "phys", "#phy-cells",
291                 index, &args);
292         if (ret) {
293                 dev_dbg(dev, "failed to get phy in %s node\n",
294                         dev->of_node->full_name);
295                 return ERR_PTR(-ENODEV);
296         }
297
298         mutex_lock(&phy_provider_mutex);
299         phy_provider = of_phy_provider_lookup(args.np);
300         if (IS_ERR(phy_provider) || !try_module_get(phy_provider->owner)) {
301                 phy = ERR_PTR(-EPROBE_DEFER);
302                 goto err0;
303         }
304
305         phy = phy_provider->of_xlate(phy_provider->dev, &args);
306         module_put(phy_provider->owner);
307
308 err0:
309         mutex_unlock(&phy_provider_mutex);
310         of_node_put(args.np);
311
312         return phy;
313 }
314
315 /**
316  * phy_put() - release the PHY
317  * @phy: the phy returned by phy_get()
318  *
319  * Releases a refcount the caller received from phy_get().
320  */
321 void phy_put(struct phy *phy)
322 {
323         if (!phy || IS_ERR(phy))
324                 return;
325
326         module_put(phy->ops->owner);
327         put_device(&phy->dev);
328 }
329 EXPORT_SYMBOL_GPL(phy_put);
330
331 /**
332  * devm_phy_put() - release the PHY
333  * @dev: device that wants to release this phy
334  * @phy: the phy returned by devm_phy_get()
335  *
336  * destroys the devres associated with this phy and invokes phy_put
337  * to release the phy.
338  */
339 void devm_phy_put(struct device *dev, struct phy *phy)
340 {
341         int r;
342
343         if (!phy)
344                 return;
345
346         r = devres_destroy(dev, devm_phy_release, devm_phy_match, phy);
347         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
348 }
349 EXPORT_SYMBOL_GPL(devm_phy_put);
350
351 /**
352  * of_phy_simple_xlate() - returns the phy instance from phy provider
353  * @dev: the PHY provider device
354  * @args: of_phandle_args (not used here)
355  *
356  * Intended to be used by phy provider for the common case where #phy-cells is
357  * 0. For other cases where #phy-cells is greater than '0', the phy provider
358  * should provide a custom of_xlate function that reads the *args* and returns
359  * the appropriate phy.
360  */
361 struct phy *of_phy_simple_xlate(struct device *dev, struct of_phandle_args
362         *args)
363 {
364         struct phy *phy;
365         struct class_dev_iter iter;
366         struct device_node *node = dev->of_node;
367
368         class_dev_iter_init(&iter, phy_class, NULL, NULL);
369         while ((dev = class_dev_iter_next(&iter))) {
370                 phy = to_phy(dev);
371                 if (node != phy->dev.of_node)
372                         continue;
373
374                 class_dev_iter_exit(&iter);
375                 return phy;
376         }
377
378         class_dev_iter_exit(&iter);
379         return ERR_PTR(-ENODEV);
380 }
381 EXPORT_SYMBOL_GPL(of_phy_simple_xlate);
382
383 /**
384  * phy_get() - lookup and obtain a reference to a phy.
385  * @dev: device that requests this phy
386  * @string: the phy name as given in the dt data or the name of the controller
387  * port for non-dt case
388  *
389  * Returns the phy driver, after getting a refcount to it; or
390  * -ENODEV if there is no such phy.  The caller is responsible for
391  * calling phy_put() to release that count.
392  */
393 struct phy *phy_get(struct device *dev, const char *string)
394 {
395         int index = 0;
396         struct phy *phy;
397
398         if (string == NULL) {
399                 dev_WARN(dev, "missing string\n");
400                 return ERR_PTR(-EINVAL);
401         }
402
403         if (dev->of_node) {
404                 index = of_property_match_string(dev->of_node, "phy-names",
405                         string);
406                 phy = of_phy_get(dev, index);
407                 if (IS_ERR(phy)) {
408                         dev_err(dev, "unable to find phy\n");
409                         return phy;
410                 }
411         } else {
412                 phy = phy_lookup(dev, string);
413                 if (IS_ERR(phy)) {
414                         dev_err(dev, "unable to find phy\n");
415                         return phy;
416                 }
417         }
418
419         if (!try_module_get(phy->ops->owner))
420                 return ERR_PTR(-EPROBE_DEFER);
421
422         get_device(&phy->dev);
423
424         return phy;
425 }
426 EXPORT_SYMBOL_GPL(phy_get);
427
428 /**
429  * phy_optional_get() - lookup and obtain a reference to an optional phy.
430  * @dev: device that requests this phy
431  * @string: the phy name as given in the dt data or the name of the controller
432  * port for non-dt case
433  *
434  * Returns the phy driver, after getting a refcount to it; or
435  * NULL if there is no such phy.  The caller is responsible for
436  * calling phy_put() to release that count.
437  */
438 struct phy *phy_optional_get(struct device *dev, const char *string)
439 {
440         struct phy *phy = phy_get(dev, string);
441
442         if (PTR_ERR(phy) == -ENODEV)
443                 phy = NULL;
444
445         return phy;
446 }
447 EXPORT_SYMBOL_GPL(phy_optional_get);
448
449 /**
450  * devm_phy_get() - lookup and obtain a reference to a phy.
451  * @dev: device that requests this phy
452  * @string: the phy name as given in the dt data or phy device name
453  * for non-dt case
454  *
455  * Gets the phy using phy_get(), and associates a device with it using
456  * devres. On driver detach, release function is invoked on the devres data,
457  * then, devres data is freed.
458  */
459 struct phy *devm_phy_get(struct device *dev, const char *string)
460 {
461         struct phy **ptr, *phy;
462
463         ptr = devres_alloc(devm_phy_release, sizeof(*ptr), GFP_KERNEL);
464         if (!ptr)
465                 return ERR_PTR(-ENOMEM);
466
467         phy = phy_get(dev, string);
468         if (!IS_ERR(phy)) {
469                 *ptr = phy;
470                 devres_add(dev, ptr);
471         } else {
472                 devres_free(ptr);
473         }
474
475         return phy;
476 }
477 EXPORT_SYMBOL_GPL(devm_phy_get);
478
479 /**
480  * devm_phy_optional_get() - lookup and obtain a reference to an optional phy.
481  * @dev: device that requests this phy
482  * @string: the phy name as given in the dt data or phy device name
483  * for non-dt case
484  *
485  * Gets the phy using phy_get(), and associates a device with it using
486  * devres. On driver detach, release function is invoked on the devres
487  * data, then, devres data is freed. This differs to devm_phy_get() in
488  * that if the phy does not exist, it is not considered an error and
489  * -ENODEV will not be returned. Instead the NULL phy is returned,
490  * which can be passed to all other phy consumer calls.
491  */
492 struct phy *devm_phy_optional_get(struct device *dev, const char *string)
493 {
494         struct phy *phy = devm_phy_get(dev, string);
495
496         if (PTR_ERR(phy) == -ENODEV)
497                 phy = NULL;
498
499         return phy;
500 }
501 EXPORT_SYMBOL_GPL(devm_phy_optional_get);
502
503 /**
504  * phy_create() - create a new phy
505  * @dev: device that is creating the new phy
506  * @ops: function pointers for performing phy operations
507  * @init_data: contains the list of PHY consumers or NULL
508  *
509  * Called to create a phy using phy framework.
510  */
511 struct phy *phy_create(struct device *dev, const struct phy_ops *ops,
512         struct phy_init_data *init_data)
513 {
514         int ret;
515         int id;
516         struct phy *phy;
517
518         if (WARN_ON(!dev))
519                 return ERR_PTR(-EINVAL);
520
521         phy = kzalloc(sizeof(*phy), GFP_KERNEL);
522         if (!phy)
523                 return ERR_PTR(-ENOMEM);
524
525         id = ida_simple_get(&phy_ida, 0, 0, GFP_KERNEL);
526         if (id < 0) {
527                 dev_err(dev, "unable to get id\n");
528                 ret = id;
529                 goto free_phy;
530         }
531
532         device_initialize(&phy->dev);
533         mutex_init(&phy->mutex);
534
535         phy->dev.class = phy_class;
536         phy->dev.parent = dev;
537         phy->dev.of_node = dev->of_node;
538         phy->id = id;
539         phy->ops = ops;
540         phy->init_data = init_data;
541
542         ret = dev_set_name(&phy->dev, "phy-%s.%d", dev_name(dev), id);
543         if (ret)
544                 goto put_dev;
545
546         ret = device_add(&phy->dev);
547         if (ret)
548                 goto put_dev;
549
550         if (pm_runtime_enabled(dev)) {
551                 pm_runtime_enable(&phy->dev);
552                 pm_runtime_no_callbacks(&phy->dev);
553         }
554
555         return phy;
556
557 put_dev:
558         put_device(&phy->dev);
559         ida_remove(&phy_ida, phy->id);
560 free_phy:
561         kfree(phy);
562         return ERR_PTR(ret);
563 }
564 EXPORT_SYMBOL_GPL(phy_create);
565
566 /**
567  * devm_phy_create() - create a new phy
568  * @dev: device that is creating the new phy
569  * @ops: function pointers for performing phy operations
570  * @init_data: contains the list of PHY consumers or NULL
571  *
572  * Creates a new PHY device adding it to the PHY class.
573  * While at that, it also associates the device with the phy using devres.
574  * On driver detach, release function is invoked on the devres data,
575  * then, devres data is freed.
576  */
577 struct phy *devm_phy_create(struct device *dev, const struct phy_ops *ops,
578         struct phy_init_data *init_data)
579 {
580         struct phy **ptr, *phy;
581
582         ptr = devres_alloc(devm_phy_consume, sizeof(*ptr), GFP_KERNEL);
583         if (!ptr)
584                 return ERR_PTR(-ENOMEM);
585
586         phy = phy_create(dev, ops, init_data);
587         if (!IS_ERR(phy)) {
588                 *ptr = phy;
589                 devres_add(dev, ptr);
590         } else {
591                 devres_free(ptr);
592         }
593
594         return phy;
595 }
596 EXPORT_SYMBOL_GPL(devm_phy_create);
597
598 /**
599  * phy_destroy() - destroy the phy
600  * @phy: the phy to be destroyed
601  *
602  * Called to destroy the phy.
603  */
604 void phy_destroy(struct phy *phy)
605 {
606         pm_runtime_disable(&phy->dev);
607         device_unregister(&phy->dev);
608 }
609 EXPORT_SYMBOL_GPL(phy_destroy);
610
611 /**
612  * devm_phy_destroy() - destroy the PHY
613  * @dev: device that wants to release this phy
614  * @phy: the phy returned by devm_phy_get()
615  *
616  * destroys the devres associated with this phy and invokes phy_destroy
617  * to destroy the phy.
618  */
619 void devm_phy_destroy(struct device *dev, struct phy *phy)
620 {
621         int r;
622
623         r = devres_destroy(dev, devm_phy_consume, devm_phy_match, phy);
624         dev_WARN_ONCE(dev, r, "couldn't find PHY resource\n");
625 }
626 EXPORT_SYMBOL_GPL(devm_phy_destroy);
627
628 /**
629  * __of_phy_provider_register() - create/register phy provider with the framework
630  * @dev: struct device of the phy provider
631  * @owner: the module owner containing of_xlate
632  * @of_xlate: function pointer to obtain phy instance from phy provider
633  *
634  * Creates struct phy_provider from dev and of_xlate function pointer.
635  * This is used in the case of dt boot for finding the phy instance from
636  * phy provider.
637  */
638 struct phy_provider *__of_phy_provider_register(struct device *dev,
639         struct module *owner, struct phy * (*of_xlate)(struct device *dev,
640         struct of_phandle_args *args))
641 {
642         struct phy_provider *phy_provider;
643
644         phy_provider = kzalloc(sizeof(*phy_provider), GFP_KERNEL);
645         if (!phy_provider)
646                 return ERR_PTR(-ENOMEM);
647
648         phy_provider->dev = dev;
649         phy_provider->owner = owner;
650         phy_provider->of_xlate = of_xlate;
651
652         mutex_lock(&phy_provider_mutex);
653         list_add_tail(&phy_provider->list, &phy_provider_list);
654         mutex_unlock(&phy_provider_mutex);
655
656         return phy_provider;
657 }
658 EXPORT_SYMBOL_GPL(__of_phy_provider_register);
659
660 /**
661  * __devm_of_phy_provider_register() - create/register phy provider with the
662  * framework
663  * @dev: struct device of the phy provider
664  * @owner: the module owner containing of_xlate
665  * @of_xlate: function pointer to obtain phy instance from phy provider
666  *
667  * Creates struct phy_provider from dev and of_xlate function pointer.
668  * This is used in the case of dt boot for finding the phy instance from
669  * phy provider. While at that, it also associates the device with the
670  * phy provider using devres. On driver detach, release function is invoked
671  * on the devres data, then, devres data is freed.
672  */
673 struct phy_provider *__devm_of_phy_provider_register(struct device *dev,
674         struct module *owner, struct phy * (*of_xlate)(struct device *dev,
675         struct of_phandle_args *args))
676 {
677         struct phy_provider **ptr, *phy_provider;
678
679         ptr = devres_alloc(devm_phy_provider_release, sizeof(*ptr), GFP_KERNEL);
680         if (!ptr)
681                 return ERR_PTR(-ENOMEM);
682
683         phy_provider = __of_phy_provider_register(dev, owner, of_xlate);
684         if (!IS_ERR(phy_provider)) {
685                 *ptr = phy_provider;
686                 devres_add(dev, ptr);
687         } else {
688                 devres_free(ptr);
689         }
690
691         return phy_provider;
692 }
693 EXPORT_SYMBOL_GPL(__devm_of_phy_provider_register);
694
695 /**
696  * of_phy_provider_unregister() - unregister phy provider from the framework
697  * @phy_provider: phy provider returned by of_phy_provider_register()
698  *
699  * Removes the phy_provider created using of_phy_provider_register().
700  */
701 void of_phy_provider_unregister(struct phy_provider *phy_provider)
702 {
703         if (IS_ERR(phy_provider))
704                 return;
705
706         mutex_lock(&phy_provider_mutex);
707         list_del(&phy_provider->list);
708         kfree(phy_provider);
709         mutex_unlock(&phy_provider_mutex);
710 }
711 EXPORT_SYMBOL_GPL(of_phy_provider_unregister);
712
713 /**
714  * devm_of_phy_provider_unregister() - remove phy provider from the framework
715  * @dev: struct device of the phy provider
716  *
717  * destroys the devres associated with this phy provider and invokes
718  * of_phy_provider_unregister to unregister the phy provider.
719  */
720 void devm_of_phy_provider_unregister(struct device *dev,
721         struct phy_provider *phy_provider) {
722         int r;
723
724         r = devres_destroy(dev, devm_phy_provider_release, devm_phy_match,
725                 phy_provider);
726         dev_WARN_ONCE(dev, r, "couldn't find PHY provider device resource\n");
727 }
728 EXPORT_SYMBOL_GPL(devm_of_phy_provider_unregister);
729
730 /**
731  * phy_release() - release the phy
732  * @dev: the dev member within phy
733  *
734  * When the last reference to the device is removed, it is called
735  * from the embedded kobject as release method.
736  */
737 static void phy_release(struct device *dev)
738 {
739         struct phy *phy;
740
741         phy = to_phy(dev);
742         dev_vdbg(dev, "releasing '%s'\n", dev_name(dev));
743         ida_remove(&phy_ida, phy->id);
744         kfree(phy);
745 }
746
747 static int __init phy_core_init(void)
748 {
749         phy_class = class_create(THIS_MODULE, "phy");
750         if (IS_ERR(phy_class)) {
751                 pr_err("failed to create phy class --> %ld\n",
752                         PTR_ERR(phy_class));
753                 return PTR_ERR(phy_class);
754         }
755
756         phy_class->dev_release = phy_release;
757
758         return 0;
759 }
760 module_init(phy_core_init);
761
762 static void __exit phy_core_exit(void)
763 {
764         class_destroy(phy_class);
765 }
766 module_exit(phy_core_exit);
767
768 MODULE_DESCRIPTION("Generic PHY Framework");
769 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
770 MODULE_LICENSE("GPL v2");