wl1251: make local symbols static
[pandora-wifi.git] / drivers / net / wireless / wl12xx / wl1251_sdio.c
1 /*
2  * wl12xx SDIO routines
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software
15  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
16  * 02110-1301 USA
17  *
18  * Copyright (C) 2005 Texas Instruments Incorporated
19  * Copyright (C) 2008 Google Inc
20  * Copyright (C) 2009 Bob Copeland (me@bobcopeland.com)
21  */
22 #include <linux/module.h>
23 #include <linux/mod_devicetable.h>
24 #include <linux/mmc/sdio_func.h>
25 #include <linux/mmc/sdio_ids.h>
26
27 #include "wl1251.h"
28
29 #ifndef SDIO_VENDOR_ID_TI
30 #define SDIO_VENDOR_ID_TI               0x104c
31 #endif
32
33 #ifndef SDIO_DEVICE_ID_TI_WL1251
34 #define SDIO_DEVICE_ID_TI_WL1251        0x9066
35 #endif
36
37 static struct sdio_func *wl_to_func(struct wl1251 *wl)
38 {
39         return wl->if_priv;
40 }
41
42 static void wl1251_sdio_interrupt(struct sdio_func *func)
43 {
44         struct wl1251 *wl = sdio_get_drvdata(func);
45
46         wl1251_debug(DEBUG_IRQ, "IRQ");
47
48         /* FIXME should be synchronous for sdio */
49         ieee80211_queue_work(wl->hw, &wl->irq_work);
50 }
51
52 static const struct sdio_device_id wl1251_devices[] = {
53         { SDIO_DEVICE(SDIO_VENDOR_ID_TI, SDIO_DEVICE_ID_TI_WL1251) },
54         {}
55 };
56 MODULE_DEVICE_TABLE(sdio, wl1251_devices);
57
58
59 static void wl1251_sdio_read(struct wl1251 *wl, int addr,
60                              void *buf, size_t len)
61 {
62         int ret;
63         struct sdio_func *func = wl_to_func(wl);
64
65         sdio_claim_host(func);
66         ret = sdio_memcpy_fromio(func, buf, addr, len);
67         if (ret)
68                 wl1251_error("sdio read failed (%d)", ret);
69         sdio_release_host(func);
70 }
71
72 static void wl1251_sdio_write(struct wl1251 *wl, int addr,
73                               void *buf, size_t len)
74 {
75         int ret;
76         struct sdio_func *func = wl_to_func(wl);
77
78         sdio_claim_host(func);
79         ret = sdio_memcpy_toio(func, addr, buf, len);
80         if (ret)
81                 wl1251_error("sdio write failed (%d)", ret);
82         sdio_release_host(func);
83 }
84
85 static void wl1251_sdio_reset(struct wl1251 *wl)
86 {
87 }
88
89 static void wl1251_sdio_enable_irq(struct wl1251 *wl)
90 {
91         struct sdio_func *func = wl_to_func(wl);
92
93         sdio_claim_host(func);
94         sdio_claim_irq(func, wl1251_sdio_interrupt);
95         sdio_release_host(func);
96 }
97
98 static void wl1251_sdio_disable_irq(struct wl1251 *wl)
99 {
100         struct sdio_func *func = wl_to_func(wl);
101
102         sdio_claim_host(func);
103         sdio_release_irq(func);
104         sdio_release_host(func);
105 }
106
107 static void wl1251_sdio_set_power(bool enable)
108 {
109 }
110
111 static const struct wl1251_if_operations wl1251_sdio_ops = {
112         .read = wl1251_sdio_read,
113         .write = wl1251_sdio_write,
114         .reset = wl1251_sdio_reset,
115         .enable_irq = wl1251_sdio_enable_irq,
116         .disable_irq = wl1251_sdio_disable_irq,
117 };
118
119 static int wl1251_sdio_probe(struct sdio_func *func,
120                              const struct sdio_device_id *id)
121 {
122         int ret;
123         struct wl1251 *wl;
124         struct ieee80211_hw *hw;
125
126         hw = wl1251_alloc_hw();
127         if (IS_ERR(hw))
128                 return PTR_ERR(hw);
129
130         wl = hw->priv;
131
132         sdio_claim_host(func);
133         ret = sdio_enable_func(func);
134         if (ret)
135                 goto release;
136
137         sdio_set_block_size(func, 512);
138
139         SET_IEEE80211_DEV(hw, &func->dev);
140         wl->if_priv = func;
141         wl->if_ops = &wl1251_sdio_ops;
142         wl->set_power = wl1251_sdio_set_power;
143
144         sdio_release_host(func);
145         ret = wl1251_init_ieee80211(wl);
146         if (ret)
147                 goto disable;
148
149         sdio_set_drvdata(func, wl);
150         return ret;
151
152 disable:
153         sdio_claim_host(func);
154         sdio_disable_func(func);
155 release:
156         sdio_release_host(func);
157         return ret;
158 }
159
160 static void __devexit wl1251_sdio_remove(struct sdio_func *func)
161 {
162         struct wl1251 *wl = sdio_get_drvdata(func);
163
164         wl1251_free_hw(wl);
165
166         sdio_claim_host(func);
167         sdio_release_irq(func);
168         sdio_disable_func(func);
169         sdio_release_host(func);
170 }
171
172 static struct sdio_driver wl1251_sdio_driver = {
173         .name           = "wl1251_sdio",
174         .id_table       = wl1251_devices,
175         .probe          = wl1251_sdio_probe,
176         .remove         = __devexit_p(wl1251_sdio_remove),
177 };
178
179 static int __init wl1251_sdio_init(void)
180 {
181         int err;
182
183         err = sdio_register_driver(&wl1251_sdio_driver);
184         if (err)
185                 wl1251_error("failed to register sdio driver: %d", err);
186         return err;
187 }
188
189 static void __exit wl1251_sdio_exit(void)
190 {
191         sdio_unregister_driver(&wl1251_sdio_driver);
192         wl1251_notice("unloaded");
193 }
194
195 module_init(wl1251_sdio_init);
196 module_exit(wl1251_sdio_exit);
197
198 MODULE_LICENSE("GPL");
199 MODULE_AUTHOR("Kalle Valo <kalle.valo@nokia.com>");