← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/tc/tc-driver.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/tc/tc-driver.c
 
1
/*
 
2
 *      TURBOchannel driver services.
 
3
 *
 
4
 *      Copyright (c) 2005  James Simmons
 
5
 *      Copyright (c) 2006  Maciej W. Rozycki
 
6
 *
 
7
 *      Loosely based on drivers/dio/dio-driver.c and
 
8
 *      drivers/pci/pci-driver.c.
 
9
 *
 
10
 *      This file is subject to the terms and conditions of the GNU
 
11
 *      General Public License.  See the file "COPYING" in the main
 
12
 *      directory of this archive for more details.
 
13
 */
 
14
 
 
15
#include <linux/init.h>
 
16
#include <linux/module.h>
 
17
#include <linux/tc.h>
 
18
 
 
19
/**
 
20
 * tc_register_driver - register a new TC driver
 
21
 * @drv: the driver structure to register
 
22
 *
 
23
 * Adds the driver structure to the list of registered drivers
 
24
 * Returns a negative value on error, otherwise 0.
 
25
 * If no error occurred, the driver remains registered even if
 
26
 * no device was claimed during registration.
 
27
 */
 
28
int tc_register_driver(struct tc_driver *tdrv)
 
29
{
 
30
        return driver_register(&tdrv->driver);
 
31
}
 
32
EXPORT_SYMBOL(tc_register_driver);
 
33
 
 
34
/**
 
35
 * tc_unregister_driver - unregister a TC driver
 
36
 * @drv: the driver structure to unregister
 
37
 *
 
38
 * Deletes the driver structure from the list of registered TC drivers,
 
39
 * gives it a chance to clean up by calling its remove() function for
 
40
 * each device it was responsible for, and marks those devices as
 
41
 * driverless.
 
42
 */
 
43
void tc_unregister_driver(struct tc_driver *tdrv)
 
44
{
 
45
        driver_unregister(&tdrv->driver);
 
46
}
 
47
EXPORT_SYMBOL(tc_unregister_driver);
 
48
 
 
49
/**
 
50
 * tc_match_device - tell if a TC device structure has a matching
 
51
 *                   TC device ID structure
 
52
 * @tdrv: the TC driver to earch for matching TC device ID strings
 
53
 * @tdev: the TC device structure to match against
 
54
 *
 
55
 * Used by a driver to check whether a TC device present in the
 
56
 * system is in its list of supported devices.  Returns the matching
 
57
 * tc_device_id structure or %NULL if there is no match.
 
58
 */
 
59
const struct tc_device_id *tc_match_device(struct tc_driver *tdrv,
 
60
                                           struct tc_dev *tdev)
 
61
{
 
62
        const struct tc_device_id *id = tdrv->id_table;
 
63
 
 
64
        if (id) {
 
65
                while (id->name[0] || id->vendor[0]) {
 
66
                        if (strcmp(tdev->name, id->name) == 0 &&
 
67
                            strcmp(tdev->vendor, id->vendor) == 0)
 
68
                                return id;
 
69
                        id++;
 
70
                }
 
71
        }
 
72
        return NULL;
 
73
}
 
74
EXPORT_SYMBOL(tc_match_device);
 
75
 
 
76
/**
 
77
 * tc_bus_match - Tell if a device structure has a matching
 
78
 *                TC device ID structure
 
79
 * @dev: the device structure to match against
 
80
 * @drv: the device driver to search for matching TC device ID strings
 
81
 *
 
82
 * Used by a driver to check whether a TC device present in the
 
83
 * system is in its list of supported devices.  Returns 1 if there
 
84
 * is a match or 0 otherwise.
 
85
 */
 
86
static int tc_bus_match(struct device *dev, struct device_driver *drv)
 
87
{
 
88
        struct tc_dev *tdev = to_tc_dev(dev);
 
89
        struct tc_driver *tdrv = to_tc_driver(drv);
 
90
        const struct tc_device_id *id;
 
91
 
 
92
        id = tc_match_device(tdrv, tdev);
 
93
        if (id)
 
94
                return 1;
 
95
 
 
96
        return 0;
 
97
}
 
98
 
 
99
struct bus_type tc_bus_type = {
 
100
        .name   = "tc",
 
101
        .match  = tc_bus_match,
 
102
};
 
103
EXPORT_SYMBOL(tc_bus_type);
 
104
 
 
105
static int __init tc_driver_init(void)
 
106
{
 
107
        return bus_register(&tc_bus_type);
 
108
}
 
109
 
 
110
postcore_initcall(tc_driver_init);