Commit | Line | Data |
---|---|---|
4bd43f50 LR |
1 | /* |
2 | * Copyright (c) 2007-2008 Atheros Communications Inc. | |
3 | * | |
4 | * Permission to use, copy, modify, and/or distribute this software for any | |
5 | * purpose with or without fee is hereby granted, provided that the above | |
6 | * copyright notice and this permission notice appear in all copies. | |
7 | * | |
8 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
9 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
10 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |
11 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
12 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
13 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |
14 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
15 | */ | |
16 | /* Module Name : usbdrv.c */ | |
17 | /* */ | |
18 | /* Abstract */ | |
19 | /* This module contains network interface up/down related functions.*/ | |
20 | /* */ | |
21 | /* NOTES */ | |
22 | /* Platform dependent. */ | |
23 | /* */ | |
24 | /************************************************************************/ | |
25 | ||
26 | /* src/usbdrv.c */ | |
27 | ||
28 | #define ZM_PIBSS_MODE 0 | |
29 | #define ZM_AP_MODE 0 | |
30 | #define ZM_CHANNEL 11 | |
31 | #define ZM_WEP_MOME 0 | |
32 | #define ZM_SHARE_AUTH 0 | |
33 | #define ZM_DISABLE_XMIT 0 | |
34 | ||
35 | #include "usbdrv.h" | |
36 | #include "oal_dt.h" | |
37 | #include "80211core/pub_zfi.h" | |
38 | ||
39 | #include "linux/netlink.h" | |
40 | #include "linux/rtnetlink.h" | |
5a0e3ad6 | 41 | #include "linux/slab.h" |
4bd43f50 | 42 | |
4bd43f50 | 43 | #include <net/iw_handler.h> |
4bd43f50 LR |
44 | |
45 | #ifdef ZM_HOSTAPD_SUPPORT | |
46 | #include "athr_common.h" | |
47 | #endif | |
48 | ||
49 | extern void zfDumpDescriptor(zdev_t* dev, u16_t type); | |
50 | //extern void zfiWlanQueryMacAddress(zdev_t* dev, u8_t* addr); | |
51 | ||
52 | // ISR handler | |
4bd43f50 | 53 | irqreturn_t usbdrv_intr(int, void *, struct pt_regs *); |
4bd43f50 LR |
54 | |
55 | // Network Device interface related function | |
56 | int usbdrv_open(struct net_device *); | |
57 | int usbdrv_close(struct net_device *); | |
58 | int usbdrv_change_mtu(struct net_device *, int); | |
59 | int usbdrv_set_mac(struct net_device *, void *); | |
60 | int usbdrv_xmit_frame(struct sk_buff *, struct net_device *); | |
61 | void usbdrv_set_multi(struct net_device *); | |
62 | struct net_device_stats *usbdrv_get_stats(struct net_device *); | |
63 | ||
64 | //wireless extension helper functions | |
65 | int usbdrv_ioctl_setessid(struct net_device *dev, struct iw_point *erq); | |
66 | int usbdrv_ioctl_getessid(struct net_device *dev, struct iw_point *erq); | |
67 | int usbdrv_ioctl_setrts(struct net_device *dev, struct iw_param *rrq); | |
68 | /* Wireless Extension Handler functions */ | |
69 | int usbdrvwext_giwmode(struct net_device *dev, struct iw_request_info* info, | |
70 | __u32 *mode, char *extra); | |
71 | int zfLnxPrivateIoctl(struct usbdrv_private *macp, struct zdap_ioctl *zdreq); | |
72 | ||
73 | void zfLnx10msTimer(struct net_device* dev); | |
74 | int zfUnregisterWdsDev(struct net_device* parentDev, u16_t wdsId); | |
75 | int zfRegisterWdsDev(struct net_device* parentDev, u16_t wdsId); | |
76 | int zfWdsOpen(struct net_device *dev); | |
77 | int zfWdsClose(struct net_device *dev); | |
78 | int zfLnxVapOpen(struct net_device *dev); | |
79 | int zfLnxVapClose(struct net_device *dev); | |
80 | int zfLnxVapXmitFrame(struct sk_buff *skb, struct net_device *dev); | |
81 | int zfLnxRegisterVapDev(struct net_device* parentDev, u16_t vapId); | |
82 | int usbdrv_wpa_ioctl(struct net_device *dev, struct athr_wlan_param *zdparm); | |
83 | extern u16_t zfLnxGetVapId(zdev_t* dev); | |
84 | extern u16_t zfLnxCheckTxBufferCnt(zdev_t *dev); | |
85 | extern UsbTxQ_t *zfLnxGetUsbTxBuffer(zdev_t *dev); | |
86 | ||
87 | extern u16_t zfLnxAuthNotify(zdev_t* dev, u16_t* macAddr); | |
88 | extern u16_t zfLnxAsocNotify(zdev_t* dev, u16_t* macAddr, u8_t* body, u16_t bodySize, u16_t port); | |
89 | extern u16_t zfLnxDisAsocNotify(zdev_t* dev, u8_t* macAddr, u16_t port); | |
90 | extern u16_t zfLnxApConnectNotify(zdev_t* dev, u8_t* macAddr, u16_t port); | |
91 | extern void zfLnxConnectNotify(zdev_t* dev, u16_t status, u16_t* bssid); | |
92 | extern void zfLnxScanNotify(zdev_t* dev, struct zsScanResult* result); | |
93 | extern void zfLnxStatisticsNotify(zdev_t* dev, struct zsStastics* result); | |
94 | extern void zfLnxMicFailureNotify(zdev_t* dev, u16_t* addr, u16_t status); | |
95 | extern void zfLnxApMicFailureNotify(zdev_t* dev, u8_t* addr, zbuf_t* buf); | |
96 | extern void zfLnxIbssPartnerNotify(zdev_t* dev, u16_t status, struct zsPartnerNotifyEvent *event); | |
97 | extern void zfLnxMacAddressNotify(zdev_t* dev, u8_t* addr); | |
98 | extern void zfLnxSendCompleteIndication(zdev_t* dev, zbuf_t* buf); | |
99 | extern void zfLnxRecvEth(zdev_t* dev, zbuf_t* buf, u16_t port); | |
100 | extern void zfLnxRestoreBufData(zdev_t* dev, zbuf_t* buf); | |
101 | #ifdef ZM_ENABLE_CENC | |
102 | extern u16_t zfLnxCencAsocNotify(zdev_t* dev, u16_t* macAddr, u8_t* body, u16_t bodySize, u16_t port); | |
103 | #endif //ZM_ENABLE_CENC | |
104 | extern void zfLnxWatchDogNotify(zdev_t* dev); | |
105 | extern void zfLnxRecv80211(zdev_t* dev, zbuf_t* buf, struct zsAdditionInfo* addInfo); | |
106 | extern u8_t zfLnxCreateThread(zdev_t *dev); | |
107 | ||
108 | /****************************************************************************** | |
109 | * P U B L I C D A T A | |
110 | ******************************************************************************* | |
111 | */ | |
112 | ||
113 | /* Definition of Wireless Extension */ | |
114 | ||
2bef7a0f | 115 | /* wireless extension helper functions */ |
4bd43f50 LR |
116 | extern int usbdrv_ioctl_setessid(struct net_device *dev, struct iw_point *erq); |
117 | extern int usbdrv_ioctl_setrts(struct net_device *dev, struct iw_param *rrq); | |
118 | /* Wireless Extension Handler functions */ | |
119 | extern int usbdrvwext_giwname(struct net_device *dev, struct iw_request_info *info, | |
120 | union iwreq_data *wrq, char *extra); | |
121 | extern int usbdrvwext_siwfreq(struct net_device *dev, struct iw_request_info *info, | |
122 | struct iw_freq *freq, char *extra); | |
123 | extern int usbdrvwext_giwfreq(struct net_device *dev, struct iw_request_info *info, | |
124 | struct iw_freq *freq, char *extra); | |
125 | extern int usbdrvwext_siwmode(struct net_device *dev, struct iw_request_info *info, | |
126 | union iwreq_data *wrq, char *extra); | |
127 | extern int usbdrvwext_giwmode(struct net_device *dev, struct iw_request_info *info, | |
128 | __u32 *mode, char *extra); | |
129 | extern int usbdrvwext_siwsens(struct net_device *dev, struct iw_request_info *info, | |
130 | struct iw_param *sens, char *extra); | |
131 | extern int usbdrvwext_giwsens(struct net_device *dev, struct iw_request_info *info, | |
132 | struct iw_param *sens, char *extra); | |
133 | extern int usbdrvwext_giwrange(struct net_device *dev, struct iw_request_info *info, | |
134 | struct iw_point *data, char *extra); | |
135 | extern int usbdrvwext_siwap(struct net_device *dev, struct iw_request_info *info, | |
136 | struct sockaddr *MacAddr, char *extra); | |
137 | extern int usbdrvwext_giwap(struct net_device *dev, struct iw_request_info *info, | |
138 | struct sockaddr *MacAddr, char *extra); | |
139 | extern int usbdrvwext_iwaplist(struct net_device *dev, struct iw_request_info *info, | |
140 | struct iw_point *data, char *extra); | |
141 | extern int usbdrvwext_siwscan(struct net_device *dev, struct iw_request_info *info, | |
142 | struct iw_point *data, char *extra); | |
143 | extern int usbdrvwext_giwscan(struct net_device *dev, struct iw_request_info *info, | |
144 | struct iw_point *data, char *extra); | |
145 | extern int usbdrvwext_siwessid(struct net_device *dev, struct iw_request_info *info, | |
146 | struct iw_point *essid, char *extra); | |
147 | extern int usbdrvwext_giwessid(struct net_device *dev, struct iw_request_info *info, | |
148 | struct iw_point *essid, char *extra); | |
149 | extern int usbdrvwext_siwnickn(struct net_device *dev, struct iw_request_info *info, | |
150 | struct iw_point *data, char *nickname); | |
151 | extern int usbdrvwext_giwnickn(struct net_device *dev, struct iw_request_info *info, | |
152 | struct iw_point *data, char *nickname); | |
153 | extern int usbdrvwext_siwrate(struct net_device *dev, struct iw_request_info *info, | |
154 | struct iw_param *frq, char *extra); | |
155 | extern int usbdrvwext_giwrate(struct net_device *dev, struct iw_request_info *info, | |
156 | struct iw_param *frq, char *extra); | |
157 | extern int usbdrvwext_siwrts(struct net_device *dev, struct iw_request_info *info, | |
158 | struct iw_param *rts, char *extra); | |
159 | extern int usbdrvwext_giwrts(struct net_device *dev, struct iw_request_info *info, | |
160 | struct iw_param *rts, char *extra); | |
161 | extern int usbdrvwext_siwfrag(struct net_device *dev, struct iw_request_info *info, | |
162 | struct iw_param *frag, char *extra); | |
163 | extern int usbdrvwext_giwfrag(struct net_device *dev, struct iw_request_info *info, | |
164 | struct iw_param *frag, char *extra); | |
165 | extern int usbdrvwext_siwtxpow(struct net_device *dev, struct iw_request_info *info, | |
166 | struct iw_param *rrq, char *extra); | |
167 | extern int usbdrvwext_giwtxpow(struct net_device *dev, struct iw_request_info *info, | |
168 | struct iw_param *rrq, char *extra); | |
169 | extern int usbdrvwext_siwretry(struct net_device *dev, struct iw_request_info *info, | |
170 | struct iw_param *rrq, char *extra); | |
171 | extern int usbdrvwext_giwretry(struct net_device *dev, struct iw_request_info *info, | |
172 | struct iw_param *rrq, char *extra); | |
173 | extern int usbdrvwext_siwencode(struct net_device *dev, struct iw_request_info *info, | |
174 | struct iw_point *erq, char *key); | |
175 | extern int usbdrvwext_giwencode(struct net_device *dev, struct iw_request_info *info, | |
176 | struct iw_point *erq, char *key); | |
177 | extern int usbdrvwext_siwpower(struct net_device *dev, struct iw_request_info *info, | |
178 | struct iw_param *frq, char *extra); | |
179 | extern int usbdrvwext_giwpower(struct net_device *dev, struct iw_request_info *info, | |
180 | struct iw_param *frq, char *extra); | |
181 | extern int usbdrv_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd); | |
182 | /* | |
183 | * Structures to export the Wireless Handlers | |
184 | */ | |
185 | ||
186 | struct iw_priv_args usbdrv_private_args[] = { | |
187 | // { SIOCIWFIRSTPRIV + 0x0, 0, 0, "list_bss" }, | |
188 | // { SIOCIWFIRSTPRIV + 0x1, 0, 0, "card_reset" }, | |
189 | { SIOCIWFIRSTPRIV + 0x2, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_auth" }, /* 0 - open, 1 - shared key */ | |
190 | { SIOCIWFIRSTPRIV + 0x3, 0, IW_PRIV_TYPE_CHAR | 12, "get_auth" }, | |
191 | // { SIOCIWFIRSTPRIV + 0x4, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_preamble" }, /* 0 - long, 1 - short */ | |
192 | // { SIOCIWFIRSTPRIV + 0x5, 0, IW_PRIV_TYPE_CHAR | 6, "get_preamble" }, | |
193 | // { SIOCIWFIRSTPRIV + 0x6, 0, 0, "cnt" }, | |
194 | // { SIOCIWFIRSTPRIV + 0x7, 0, 0, "regs" }, | |
195 | // { SIOCIWFIRSTPRIV + 0x8, 0, 0, "probe" }, | |
196 | // { SIOCIWFIRSTPRIV + 0x9, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "dbg_flag" }, | |
197 | // { SIOCIWFIRSTPRIV + 0xA, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "connect" }, | |
198 | // { SIOCIWFIRSTPRIV + 0xB, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_mac_mode" }, | |
199 | // { SIOCIWFIRSTPRIV + 0xC, 0, IW_PRIV_TYPE_CHAR | 12, "get_mac_mode" }, | |
200 | }; | |
201 | ||
4bd43f50 LR |
202 | static iw_handler usbdrvwext_handler[] = { |
203 | (iw_handler) NULL, /* SIOCSIWCOMMIT */ | |
204 | (iw_handler) usbdrvwext_giwname, /* SIOCGIWNAME */ | |
205 | (iw_handler) NULL, /* SIOCSIWNWID */ | |
206 | (iw_handler) NULL, /* SIOCGIWNWID */ | |
207 | (iw_handler) usbdrvwext_siwfreq, /* SIOCSIWFREQ */ | |
208 | (iw_handler) usbdrvwext_giwfreq, /* SIOCGIWFREQ */ | |
209 | (iw_handler) usbdrvwext_siwmode, /* SIOCSIWMODE */ | |
210 | (iw_handler) usbdrvwext_giwmode, /* SIOCGIWMODE */ | |
211 | (iw_handler) usbdrvwext_siwsens, /* SIOCSIWSENS */ | |
212 | (iw_handler) usbdrvwext_giwsens, /* SIOCGIWSENS */ | |
213 | (iw_handler) NULL, /* not used */ /* SIOCSIWRANGE */ | |
214 | (iw_handler) usbdrvwext_giwrange, /* SIOCGIWRANGE */ | |
215 | (iw_handler) NULL, /* not used */ /* SIOCSIWPRIV */ | |
216 | (iw_handler) NULL, /* kernel code */ /* SIOCGIWPRIV */ | |
217 | (iw_handler) NULL, /* not used */ /* SIOCSIWSTATS */ | |
218 | (iw_handler) NULL, /* kernel code */ /* SIOCGIWSTATS */ | |
219 | (iw_handler) NULL, /* SIOCSIWSPY */ | |
220 | (iw_handler) NULL, /* SIOCGIWSPY */ | |
221 | (iw_handler) NULL, /* -- hole -- */ | |
222 | (iw_handler) NULL, /* -- hole -- */ | |
223 | (iw_handler) usbdrvwext_siwap, /* SIOCSIWAP */ | |
224 | (iw_handler) usbdrvwext_giwap, /* SIOCGIWAP */ | |
225 | (iw_handler) NULL, /* -- hole -- */ | |
226 | (iw_handler) usbdrvwext_iwaplist, /* SIOCGIWAPLIST */ | |
4bd43f50 LR |
227 | (iw_handler) usbdrvwext_siwscan, /* SIOCSIWSCAN */ |
228 | (iw_handler) usbdrvwext_giwscan, /* SIOCGIWSCAN */ | |
4bd43f50 LR |
229 | (iw_handler) usbdrvwext_siwessid, /* SIOCSIWESSID */ |
230 | (iw_handler) usbdrvwext_giwessid, /* SIOCGIWESSID */ | |
231 | ||
232 | (iw_handler) usbdrvwext_siwnickn, /* SIOCSIWNICKN */ | |
233 | (iw_handler) usbdrvwext_giwnickn, /* SIOCGIWNICKN */ | |
234 | (iw_handler) NULL, /* -- hole -- */ | |
235 | (iw_handler) NULL, /* -- hole -- */ | |
236 | (iw_handler) usbdrvwext_siwrate, /* SIOCSIWRATE */ | |
237 | (iw_handler) usbdrvwext_giwrate, /* SIOCGIWRATE */ | |
238 | (iw_handler) usbdrvwext_siwrts, /* SIOCSIWRTS */ | |
239 | (iw_handler) usbdrvwext_giwrts, /* SIOCGIWRTS */ | |
240 | (iw_handler) usbdrvwext_siwfrag, /* SIOCSIWFRAG */ | |
241 | (iw_handler) usbdrvwext_giwfrag, /* SIOCGIWFRAG */ | |
242 | (iw_handler) usbdrvwext_siwtxpow, /* SIOCSIWTXPOW */ | |
243 | (iw_handler) usbdrvwext_giwtxpow, /* SIOCGIWTXPOW */ | |
244 | (iw_handler) usbdrvwext_siwretry, /* SIOCSIWRETRY */ | |
245 | (iw_handler) usbdrvwext_giwretry, /* SIOCGIWRETRY */ | |
246 | (iw_handler) usbdrvwext_siwencode, /* SIOCSIWENCODE */ | |
247 | (iw_handler) usbdrvwext_giwencode, /* SIOCGIWENCODE */ | |
248 | (iw_handler) usbdrvwext_siwpower, /* SIOCSIWPOWER */ | |
249 | (iw_handler) usbdrvwext_giwpower, /* SIOCGIWPOWER */ | |
250 | }; | |
251 | ||
252 | static const iw_handler usbdrv_private_handler[] = | |
253 | { | |
254 | //(iw_handler) usbdrvwext_setparam, /* SIOCWFIRSTPRIV+0 */ | |
255 | //(iw_handler) usbdrvwext_getparam, /* SIOCWFIRSTPRIV+1 */ | |
256 | //(iw_handler) usbdrvwext_setkey, /* SIOCWFIRSTPRIV+2 */ | |
257 | //(iw_handler) usbdrvwext_setwmmparams, /* SIOCWFIRSTPRIV+3 */ | |
258 | //(iw_handler) usbdrvwext_delkey, /* SIOCWFIRSTPRIV+4 */ | |
259 | //(iw_handler) usbdrvwext_getwmmparams, /* SIOCWFIRSTPRIV+5 */ | |
260 | //(iw_handler) usbdrvwext_setmlme, /* SIOCWFIRSTPRIV+6 */ | |
261 | //(iw_handler) usbdrvwext_getchaninfo, /* SIOCWFIRSTPRIV+7 */ | |
262 | //(iw_handler) usbdrvwext_setoptie, /* SIOCWFIRSTPRIV+8 */ | |
263 | //(iw_handler) usbdrvwext_getoptie, /* SIOCWFIRSTPRIV+9 */ | |
264 | //(iw_handler) usbdrvwext_addmac, /* SIOCWFIRSTPRIV+10 */ | |
265 | //(iw_handler) usbdrvwext_getscanresults, /* SIOCWFIRSTPRIV+11 */ | |
266 | //(iw_handler) usbdrvwext_delmac, /* SIOCWFIRSTPRIV+12 */ | |
267 | //(iw_handler) usbdrvwext_getchanlist, /* SIOCWFIRSTPRIV+13 */ | |
268 | //(iw_handler) usbdrvwext_setchanlist, /* SIOCWFIRSTPRIV+14 */ | |
269 | //(iw_handler) NULL, /* SIOCWFIRSTPRIV+15 */ | |
270 | //(iw_handler) usbdrvwext_chanswitch, /* SIOCWFIRSTPRIV+16 */ | |
271 | //(iw_handler) usbdrvwext_setmode, /* SIOCWFIRSTPRIV+17 */ | |
272 | //(iw_handler) usbdrvwext_getmode, /* SIOCWFIRSTPRIV+18 */ | |
273 | NULL, /* SIOCIWFIRSTPRIV */ | |
274 | }; | |
275 | ||
063e95c7 | 276 | static struct iw_handler_def p80211wext_handler_def = { |
4bd43f50 LR |
277 | .num_standard = sizeof(usbdrvwext_handler) / sizeof(iw_handler), |
278 | .num_private = sizeof(usbdrv_private_handler)/sizeof(iw_handler), | |
279 | .num_private_args = sizeof(usbdrv_private_args)/sizeof(struct iw_priv_args), | |
280 | .standard = usbdrvwext_handler, | |
281 | .private = (iw_handler *) usbdrv_private_handler, | |
282 | .private_args = (struct iw_priv_args *) usbdrv_private_args | |
283 | }; | |
4bd43f50 LR |
284 | |
285 | /* WDS */ | |
2bef7a0f MT |
286 | /* struct zsWdsStruct wds[ZM_WDS_PORT_NUMBER]; */ |
287 | /* void zfInitWdsStruct(void); */ | |
4bd43f50 LR |
288 | |
289 | /* VAP */ | |
290 | struct zsVapStruct vap[ZM_VAP_PORT_NUMBER]; | |
291 | void zfLnxInitVapStruct(void); | |
292 | ||
293 | ||
294 | /** | |
295 | * usbdrv_intr - interrupt handler | |
296 | * @irq: the IRQ number | |
297 | * @dev_inst: the net_device struct | |
298 | * @regs: registers (unused) | |
299 | * | |
300 | * This routine is the ISR for the usbdrv board. It services | |
301 | * the RX & TX queues & starts the RU if it has stopped due | |
302 | * to no resources. | |
303 | */ | |
4bd43f50 | 304 | irqreturn_t usbdrv_intr(int irq, void *dev_inst, struct pt_regs *regs) |
4bd43f50 LR |
305 | { |
306 | struct net_device *dev; | |
307 | struct usbdrv_private *macp; | |
308 | ||
309 | dev = dev_inst; | |
da3e8908 | 310 | macp = dev->ml_priv; |
4bd43f50 LR |
311 | |
312 | ||
313 | /* Read register error, card may be unpluged */ | |
314 | if (0)//(intr_status == -1) | |
4bd43f50 | 315 | return IRQ_NONE; |
4bd43f50 LR |
316 | |
317 | /* the device is closed, don't continue or else bad things may happen. */ | |
2bef7a0f | 318 | if (!netif_running(dev)) |
4bd43f50 | 319 | return IRQ_NONE; |
4bd43f50 | 320 | |
2bef7a0f | 321 | if (macp->driver_isolated) |
4bd43f50 | 322 | return IRQ_NONE; |
4bd43f50 LR |
323 | |
324 | #if (WLAN_HOSTIF == WLAN_PCI) | |
325 | //zfiIsrPci(dev); | |
326 | #endif | |
327 | ||
4bd43f50 | 328 | return IRQ_HANDLED; |
4bd43f50 LR |
329 | } |
330 | ||
331 | int usbdrv_open(struct net_device *dev) | |
332 | { | |
da3e8908 | 333 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
334 | int rc = 0; |
335 | u16_t size; | |
336 | void* mem; | |
337 | //unsigned char addr[6]; | |
338 | struct zsCbFuncTbl cbFuncTbl; | |
339 | ||
340 | printk("Enter open()\n"); | |
341 | ||
2bef7a0f MT |
342 | /* |
343 | * #ifndef CONFIG_SMP | |
344 | * read_lock(&(macp->isolate_lock)); | |
345 | * #endif | |
346 | */ | |
4bd43f50 LR |
347 | if (macp->driver_isolated) { |
348 | rc = -EBUSY; | |
349 | goto exit; | |
350 | } | |
351 | ||
352 | size = zfiGlobalDataSize(dev); | |
62fa4526 JP |
353 | mem = kmalloc(size, GFP_KERNEL); |
354 | if (mem == NULL) | |
4bd43f50 LR |
355 | { |
356 | rc = -EBUSY; | |
357 | goto exit; | |
358 | } | |
359 | macp->wd = mem; | |
360 | ||
361 | memset(&cbFuncTbl, 0, sizeof(struct zsCbFuncTbl)); | |
362 | cbFuncTbl.zfcbAuthNotify = zfLnxAuthNotify; | |
363 | cbFuncTbl.zfcbAuthNotify = zfLnxAuthNotify; | |
364 | cbFuncTbl.zfcbAsocNotify = zfLnxAsocNotify; | |
365 | cbFuncTbl.zfcbDisAsocNotify = zfLnxDisAsocNotify; | |
366 | cbFuncTbl.zfcbApConnectNotify = zfLnxApConnectNotify; | |
367 | cbFuncTbl.zfcbConnectNotify = zfLnxConnectNotify; | |
368 | cbFuncTbl.zfcbScanNotify = zfLnxScanNotify; | |
369 | cbFuncTbl.zfcbMicFailureNotify = zfLnxMicFailureNotify; | |
370 | cbFuncTbl.zfcbApMicFailureNotify = zfLnxApMicFailureNotify; | |
371 | cbFuncTbl.zfcbIbssPartnerNotify = zfLnxIbssPartnerNotify; | |
372 | cbFuncTbl.zfcbMacAddressNotify = zfLnxMacAddressNotify; | |
373 | cbFuncTbl.zfcbSendCompleteIndication = zfLnxSendCompleteIndication; | |
374 | cbFuncTbl.zfcbRecvEth = zfLnxRecvEth; | |
375 | cbFuncTbl.zfcbRecv80211 = zfLnxRecv80211; | |
376 | cbFuncTbl.zfcbRestoreBufData = zfLnxRestoreBufData; | |
377 | #ifdef ZM_ENABLE_CENC | |
378 | cbFuncTbl.zfcbCencAsocNotify = zfLnxCencAsocNotify; | |
379 | #endif //ZM_ENABLE_CENC | |
380 | cbFuncTbl.zfcbHwWatchDogNotify = zfLnxWatchDogNotify; | |
381 | zfiWlanOpen(dev, &cbFuncTbl); | |
382 | ||
383 | #if 0 | |
384 | { | |
385 | //u16_t mac[3] = {0x1300, 0xb6d4, 0x5aaf}; | |
386 | u16_t mac[3] = {0x8000, 0x00ab, 0x0000}; | |
387 | //zfiWlanSetMacAddress(dev, mac); | |
388 | } | |
389 | /* MAC address */ | |
390 | zfiWlanQueryMacAddress(dev, addr); | |
391 | dev->dev_addr[0] = addr[0]; | |
392 | dev->dev_addr[1] = addr[1]; | |
393 | dev->dev_addr[2] = addr[2]; | |
394 | dev->dev_addr[3] = addr[3]; | |
395 | dev->dev_addr[4] = addr[4]; | |
396 | dev->dev_addr[5] = addr[5]; | |
397 | #endif | |
2bef7a0f | 398 | /* zfwMacAddressNotify() will be called to setup dev->dev_addr[] */ |
4bd43f50 LR |
399 | |
400 | zfLnxCreateThread(dev); | |
401 | ||
2bef7a0f | 402 | mod_timer(&(macp->hbTimer10ms), jiffies + (1*HZ)/100); /* 10 ms */ |
4bd43f50 LR |
403 | |
404 | netif_carrier_on(dev); | |
405 | ||
406 | netif_start_queue(dev); | |
407 | ||
408 | #if ZM_AP_MODE == 1 | |
409 | zfiWlanSetWlanMode(dev, ZM_MODE_AP); | |
410 | zfiWlanSetBasicRate(dev, 0xf, 0, 0); | |
411 | zfiWlanSetSSID(dev, "OTUS_CWY", 8); | |
412 | zfiWlanSetDtimCount(dev, 3); | |
413 | ||
414 | #if ZM_WEP_MOME == 1 | |
415 | { | |
416 | u8_t key[16] = {0x12, 0x34, 0x56, 0x78, 0x90}; | |
417 | struct zsKeyInfo keyInfo; | |
418 | ||
419 | keyInfo.keyLength = 5; | |
420 | keyInfo.keyIndex = 0; | |
421 | keyInfo.flag = 0; | |
422 | keyInfo.key = key; | |
423 | zfiWlanSetKey(dev, keyInfo); | |
424 | ||
425 | zfiWlanSetEncryMode(dev, ZM_WEP64); | |
426 | } | |
427 | ||
428 | #if ZM_SHARE_AUTH == 1 | |
429 | zfiWlanSetAuthenticationMode(dev, 1); | |
2bef7a0f MT |
430 | #endif /* #if ZM_SHARE_AUTH == 1 */ |
431 | #endif /* #if ZM_WEP_MOME == 1 */ | |
4bd43f50 LR |
432 | |
433 | #elif ZM_PIBSS_MODE == 1 | |
434 | zfiWlanSetWlanMode(dev, ZM_MODE_PSEUDO); | |
435 | #else | |
436 | zfiWlanSetWlanMode(dev, ZM_MODE_INFRASTRUCTURE); | |
437 | #endif | |
2bef7a0f | 438 | /* zfiWlanSetChannel(dev, ZM_CHANNEL, FALSE); */ |
4bd43f50 LR |
439 | zfiWlanSetFrequency(dev, 2462000, FALSE); |
440 | zfiWlanSetRtsThreshold(dev, 32767); | |
441 | zfiWlanSetFragThreshold(dev, 0); | |
442 | ||
443 | zfiWlanEnable(dev); | |
444 | ||
445 | #ifdef ZM_ENABLE_CENC | |
4bd43f50 | 446 | macp->netlink_sk = netlink_kernel_create(NETLINK_USERSOCK, 1, NULL, THIS_MODULE); |
4bd43f50 LR |
447 | |
448 | if (macp->netlink_sk == NULL) | |
449 | { | |
450 | printk(KERN_ERR "Can't create NETLINK socket\n"); | |
451 | } | |
452 | #endif | |
453 | ||
454 | macp->DeviceOpened = 1; | |
455 | exit: | |
456 | //#ifndef CONFIG_SMP | |
457 | // read_unlock(&(macp->isolate_lock)); | |
458 | //#endif | |
459 | //zfRegisterWdsDev(dev, 0); | |
460 | //zfLnxRegisterVapDev(dev, 0); | |
461 | ||
462 | return rc; | |
463 | } | |
464 | ||
465 | ||
466 | ||
467 | ||
468 | /** | |
469 | * usbdrv_get_stats - get driver statistics | |
470 | * @dev: adapter's net_device struct | |
471 | * | |
472 | * This routine is called when the OS wants the adapter's stats returned. | |
473 | * It returns the address of the net_device_stats stucture for the device. | |
474 | * If the statistics are currently being updated, then they might be incorrect | |
475 | * for a short while. However, since this cannot actually cause damage, no | |
476 | * locking is used. | |
477 | */ | |
478 | ||
479 | struct net_device_stats * usbdrv_get_stats(struct net_device *dev) | |
480 | { | |
da3e8908 | 481 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
482 | |
483 | macp->drv_stats.net_stats.tx_errors = | |
484 | macp->drv_stats.net_stats.tx_carrier_errors + | |
485 | macp->drv_stats.net_stats.tx_aborted_errors; | |
486 | ||
487 | macp->drv_stats.net_stats.rx_errors = | |
488 | macp->drv_stats.net_stats.rx_crc_errors + | |
489 | macp->drv_stats.net_stats.rx_frame_errors + | |
490 | macp->drv_stats.net_stats.rx_length_errors; | |
491 | ||
492 | ||
493 | return &(macp->drv_stats.net_stats); | |
494 | } | |
495 | ||
496 | ||
497 | /** | |
498 | * usbdrv_set_mac - set the MAC address | |
499 | * @dev: adapter's net_device struct | |
500 | * @addr: the new address | |
501 | * | |
502 | * This routine sets the ethernet address of the board | |
503 | * Returns: | |
504 | * 0 - if successful | |
505 | * -1 - otherwise | |
506 | */ | |
507 | ||
508 | int usbdrv_set_mac(struct net_device *dev, void *addr) | |
509 | { | |
510 | struct usbdrv_private *macp; | |
511 | int rc = -1; | |
512 | ||
da3e8908 | 513 | macp = dev->ml_priv; |
4bd43f50 LR |
514 | read_lock(&(macp->isolate_lock)); |
515 | ||
516 | if (macp->driver_isolated) { | |
517 | goto exit; | |
518 | } | |
519 | ||
520 | rc = 0; | |
521 | ||
522 | ||
523 | exit: | |
524 | read_unlock(&(macp->isolate_lock)); | |
525 | return rc; | |
526 | } | |
527 | ||
528 | ||
529 | ||
530 | void | |
531 | usbdrv_isolate_driver(struct usbdrv_private *macp) | |
532 | { | |
533 | #ifndef CONFIG_SMP | |
534 | write_lock_irq(&(macp->isolate_lock)); | |
535 | #endif | |
536 | macp->driver_isolated = TRUE; | |
537 | #ifndef CONFIG_SMP | |
538 | write_unlock_irq(&(macp->isolate_lock)); | |
539 | #endif | |
540 | ||
541 | if (netif_running(macp->device)) | |
542 | { | |
543 | netif_carrier_off(macp->device); | |
544 | netif_stop_queue(macp->device); | |
545 | } | |
546 | } | |
547 | ||
548 | #define VLAN_SIZE 4 | |
549 | int usbdrv_change_mtu(struct net_device *dev, int new_mtu) | |
550 | { | |
551 | if ((new_mtu < 68) || (new_mtu > (ETH_DATA_LEN + VLAN_SIZE))) | |
552 | return -EINVAL; | |
553 | ||
554 | dev->mtu = new_mtu; | |
555 | return 0; | |
556 | } | |
557 | ||
558 | void zfLnxUnlinkAllUrbs(struct usbdrv_private *macp); | |
559 | ||
560 | int usbdrv_close(struct net_device *dev) | |
561 | { | |
562 | extern void zfHpLedCtrl(struct net_device *dev, u16_t ledId, u8_t mode); | |
563 | ||
da3e8908 | 564 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
565 | |
566 | printk(KERN_DEBUG "usbdrv_close\n"); | |
567 | ||
568 | netif_carrier_off(macp->device); | |
569 | ||
570 | del_timer_sync(&macp->hbTimer10ms); | |
571 | ||
572 | printk(KERN_DEBUG "usbdrv_netif_carrier_off\n"); | |
573 | ||
574 | usbdrv_isolate_driver(macp); | |
575 | ||
576 | printk(KERN_DEBUG "usbdrv_isolate_driver\n"); | |
577 | ||
578 | netif_carrier_off(macp->device); | |
579 | #ifdef ZM_ENABLE_CENC | |
580 | /* CENC */ | |
581 | if (macp->netlink_sk != NULL) | |
582 | { | |
583 | // sock_release(macp->netlink_sk); | |
584 | printk(KERN_ERR "usbdrv close netlink socket\n"); | |
585 | } | |
586 | #endif //ZM_ENABLE_CENC | |
587 | #if (WLAN_HOSTIF == WLAN_PCI) | |
588 | //free_irq(dev->irq, dev); | |
589 | #endif | |
590 | ||
591 | /* Turn off LED */ | |
592 | zfHpLedCtrl(dev, 0, 0); | |
593 | zfHpLedCtrl(dev, 1, 0); | |
594 | ||
595 | /* Delay for a while */ | |
596 | mdelay(10); | |
597 | ||
598 | /* clear WPA/RSN IE */ | |
599 | macp->supIe[1] = 0; | |
600 | ||
601 | /* set the isolate flag to false, so usbdrv_open can be called */ | |
602 | macp->driver_isolated = FALSE; | |
603 | ||
604 | zfiWlanClose(dev); | |
605 | kfree(macp->wd); | |
606 | ||
607 | zfLnxUnlinkAllUrbs(macp); | |
608 | ||
609 | return 0; | |
610 | } | |
611 | ||
612 | ||
613 | ||
614 | ||
615 | int usbdrv_xmit_frame(struct sk_buff *skb, struct net_device *dev) | |
616 | { | |
617 | int notify_stop = FALSE; | |
da3e8908 | 618 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
619 | |
620 | #if 0 | |
621 | /* Test code */ | |
622 | { | |
623 | struct sk_buff* s; | |
624 | ||
625 | s = skb_copy_expand(skb, 8, 0, GFP_ATOMIC); | |
626 | skb_push(s, 8); | |
627 | s->data[0] = 'z'; | |
628 | s->data[1] = 'y'; | |
629 | s->data[2] = 'd'; | |
630 | s->data[3] = 'a'; | |
631 | s->data[4] = 's'; | |
632 | printk("len1=%d, len2=%d", skb->len, s->len); | |
633 | netlink_broadcast(rtnl, s, 0, RTMGRP_LINK, GFP_ATOMIC); | |
634 | } | |
635 | #endif | |
636 | ||
637 | #if ZM_DISABLE_XMIT | |
638 | dev_kfree_skb_irq(skb); | |
639 | #else | |
640 | zfiTxSendEth(dev, skb, 0); | |
641 | #endif | |
642 | macp->drv_stats.net_stats.tx_bytes += skb->len; | |
643 | macp->drv_stats.net_stats.tx_packets++; | |
644 | ||
645 | //dev_kfree_skb_irq(skb); | |
646 | ||
647 | if (notify_stop) { | |
648 | netif_carrier_off(dev); | |
649 | netif_stop_queue(dev); | |
650 | } | |
651 | ||
6ed10654 | 652 | return NETDEV_TX_OK; |
4bd43f50 LR |
653 | } |
654 | ||
655 | ||
656 | ||
657 | ||
658 | void usbdrv_set_multi(struct net_device *dev) | |
659 | { | |
660 | ||
661 | ||
662 | if (!(dev->flags & IFF_UP)) | |
663 | return; | |
664 | ||
665 | return; | |
666 | ||
667 | } | |
668 | ||
669 | ||
670 | ||
671 | /** | |
672 | * usbdrv_clear_structs - free resources | |
673 | ||
674 | * @dev: adapter's net_device struct | |
675 | * | |
676 | * Free all device specific structs, unmap i/o address, etc. | |
677 | */ | |
678 | void usbdrv_clear_structs(struct net_device *dev) | |
679 | { | |
da3e8908 | 680 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
681 | |
682 | ||
683 | #if (WLAN_HOSTIF == WLAN_PCI) | |
684 | iounmap(macp->regp); | |
685 | ||
686 | pci_release_regions(macp->pdev); | |
687 | pci_disable_device(macp->pdev); | |
688 | pci_set_drvdata(macp->pdev, NULL); | |
689 | #endif | |
690 | ||
691 | kfree(macp); | |
692 | ||
693 | kfree(dev); | |
694 | ||
695 | } | |
696 | ||
697 | void usbdrv_remove1(struct pci_dev *pcid) | |
698 | { | |
699 | struct net_device *dev; | |
700 | struct usbdrv_private *macp; | |
701 | ||
62fa4526 JP |
702 | dev = (struct net_device *)pci_get_drvdata(pcid); |
703 | if (!dev) | |
4bd43f50 LR |
704 | return; |
705 | ||
da3e8908 | 706 | macp = dev->ml_priv; |
4bd43f50 LR |
707 | unregister_netdev(dev); |
708 | ||
709 | usbdrv_clear_structs(dev); | |
710 | } | |
711 | ||
712 | ||
713 | void zfLnx10msTimer(struct net_device* dev) | |
714 | { | |
da3e8908 | 715 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
716 | |
717 | mod_timer(&(macp->hbTimer10ms), jiffies + (1*HZ)/100); //10 ms | |
718 | zfiHeartBeat(dev); | |
719 | return; | |
720 | } | |
721 | ||
722 | void zfLnxInitVapStruct(void) | |
723 | { | |
724 | u16_t i; | |
725 | ||
2bef7a0f | 726 | for (i = 0; i < ZM_VAP_PORT_NUMBER; i++) |
4bd43f50 LR |
727 | { |
728 | vap[i].dev = NULL; | |
729 | vap[i].openFlag = 0; | |
730 | } | |
731 | } | |
732 | ||
733 | int zfLnxVapOpen(struct net_device *dev) | |
734 | { | |
735 | u16_t vapId; | |
736 | ||
737 | vapId = zfLnxGetVapId(dev); | |
738 | ||
739 | if (vap[vapId].openFlag == 0) | |
740 | { | |
741 | vap[vapId].openFlag = 1; | |
742 | printk("zfLnxVapOpen : device name=%s, vap ID=%d\n", dev->name, vapId); | |
743 | zfiWlanSetSSID(dev, "vap1", 4); | |
744 | zfiWlanEnable(dev); | |
745 | netif_start_queue(dev); | |
746 | } | |
747 | else | |
748 | { | |
749 | printk("VAP opened error : vap ID=%d\n", vapId); | |
750 | } | |
751 | return 0; | |
752 | } | |
753 | ||
754 | int zfLnxVapClose(struct net_device *dev) | |
755 | { | |
756 | u16_t vapId; | |
757 | ||
758 | vapId = zfLnxGetVapId(dev); | |
759 | ||
760 | if (vapId != 0xffff) | |
761 | { | |
762 | if (vap[vapId].openFlag == 1) | |
763 | { | |
764 | printk("zfLnxVapClose: device name=%s, vap ID=%d\n", dev->name, vapId); | |
765 | ||
766 | netif_stop_queue(dev); | |
767 | vap[vapId].openFlag = 0; | |
768 | } | |
769 | else | |
770 | { | |
771 | printk("VAP port was not opened : vap ID=%d\n", vapId); | |
772 | } | |
773 | } | |
774 | return 0; | |
775 | } | |
776 | ||
777 | int zfLnxVapXmitFrame(struct sk_buff *skb, struct net_device *dev) | |
778 | { | |
779 | int notify_stop = FALSE; | |
da3e8908 | 780 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
781 | u16_t vapId; |
782 | ||
783 | vapId = zfLnxGetVapId(dev); | |
784 | //printk("zfLnxVapXmitFrame: vap ID=%d\n", vapId); | |
785 | //printk("zfLnxVapXmitFrame(), skb=%lxh\n", (u32_t)skb); | |
786 | ||
787 | if (vapId >= ZM_VAP_PORT_NUMBER) | |
788 | { | |
789 | dev_kfree_skb_irq(skb); | |
6ed10654 | 790 | return NETDEV_TX_OK; |
4bd43f50 LR |
791 | } |
792 | #if 1 | |
793 | if (vap[vapId].openFlag == 0) | |
794 | { | |
795 | dev_kfree_skb_irq(skb); | |
6ed10654 | 796 | return NETDEV_TX_OK; |
4bd43f50 LR |
797 | } |
798 | #endif | |
799 | ||
800 | ||
801 | zfiTxSendEth(dev, skb, 0x1); | |
802 | ||
803 | macp->drv_stats.net_stats.tx_bytes += skb->len; | |
804 | macp->drv_stats.net_stats.tx_packets++; | |
805 | ||
806 | //dev_kfree_skb_irq(skb); | |
807 | ||
808 | if (notify_stop) { | |
809 | netif_carrier_off(dev); | |
810 | netif_stop_queue(dev); | |
811 | } | |
812 | ||
6ed10654 | 813 | return NETDEV_TX_OK; |
4bd43f50 LR |
814 | } |
815 | ||
17a23b38 AB |
816 | static const struct net_device_ops vap_netdev_ops = { |
817 | .ndo_open = zfLnxVapOpen, | |
818 | .ndo_stop = zfLnxVapClose, | |
819 | .ndo_start_xmit = zfLnxVapXmitFrame, | |
820 | .ndo_get_stats = usbdrv_get_stats, | |
821 | .ndo_change_mtu = usbdrv_change_mtu, | |
822 | .ndo_validate_addr = eth_validate_addr, | |
823 | .ndo_set_mac_address = eth_mac_addr, | |
824 | #ifdef ZM_HOSTAPD_SUPPORT | |
825 | .ndo_do_ioctl = usbdrv_ioctl, | |
826 | #else | |
827 | .ndo_do_ioctl = NULL, | |
828 | #endif | |
829 | }; | |
830 | ||
4bd43f50 LR |
831 | int zfLnxRegisterVapDev(struct net_device* parentDev, u16_t vapId) |
832 | { | |
833 | /* Allocate net device structure */ | |
834 | vap[vapId].dev = alloc_etherdev(0); | |
23639126 | 835 | printk("Register vap dev=%p\n", vap[vapId].dev); |
4bd43f50 LR |
836 | |
837 | if(vap[vapId].dev == NULL) { | |
838 | printk("alloc_etherdev fail\n"); | |
839 | return -ENOMEM; | |
840 | } | |
841 | ||
842 | /* Setup the default settings */ | |
843 | ether_setup(vap[vapId].dev); | |
844 | ||
845 | /* MAC address */ | |
846 | memcpy(vap[vapId].dev->dev_addr, parentDev->dev_addr, ETH_ALEN); | |
847 | ||
848 | vap[vapId].dev->irq = parentDev->irq; | |
849 | vap[vapId].dev->base_addr = parentDev->base_addr; | |
850 | vap[vapId].dev->mem_start = parentDev->mem_start; | |
851 | vap[vapId].dev->mem_end = parentDev->mem_end; | |
da3e8908 | 852 | vap[vapId].dev->ml_priv = parentDev->ml_priv; |
4bd43f50 LR |
853 | |
854 | //dev->hard_start_xmit = &zd1212_wds_xmit_frame; | |
17a23b38 | 855 | vap[vapId].dev->netdev_ops = &vap_netdev_ops; |
4bd43f50 | 856 | vap[vapId].dev->destructor = free_netdev; |
4bd43f50 LR |
857 | |
858 | vap[vapId].dev->tx_queue_len = 0; | |
859 | ||
860 | vap[vapId].dev->dev_addr[0] = parentDev->dev_addr[0]; | |
861 | vap[vapId].dev->dev_addr[1] = parentDev->dev_addr[1]; | |
862 | vap[vapId].dev->dev_addr[2] = parentDev->dev_addr[2]; | |
863 | vap[vapId].dev->dev_addr[3] = parentDev->dev_addr[3]; | |
864 | vap[vapId].dev->dev_addr[4] = parentDev->dev_addr[4]; | |
865 | vap[vapId].dev->dev_addr[5] = parentDev->dev_addr[5] + (vapId+1); | |
866 | ||
867 | /* Stop the network queue first */ | |
868 | netif_stop_queue(vap[vapId].dev); | |
869 | ||
870 | sprintf(vap[vapId].dev->name, "vap%d", vapId); | |
871 | printk("Register VAP dev success : %s\n", vap[vapId].dev->name); | |
872 | ||
873 | if(register_netdevice(vap[vapId].dev) != 0) { | |
874 | printk("register VAP device fail\n"); | |
875 | vap[vapId].dev = NULL; | |
876 | return -EINVAL; | |
877 | } | |
878 | ||
879 | return 0; | |
880 | } | |
881 | ||
882 | int zfLnxUnregisterVapDev(struct net_device* parentDev, u16_t vapId) | |
883 | { | |
884 | int ret = 0; | |
885 | ||
886 | printk("Unregister VAP dev : %s\n", vap[vapId].dev->name); | |
887 | ||
888 | if(vap[vapId].dev != NULL) { | |
23639126 | 889 | printk("Unregister vap dev=%p\n", vap[vapId].dev); |
4bd43f50 LR |
890 | // |
891 | //unregister_netdevice(wds[wdsId].dev); | |
892 | unregister_netdev(vap[vapId].dev); | |
893 | ||
894 | printk("VAP unregister_netdevice\n"); | |
895 | vap[vapId].dev = NULL; | |
896 | } | |
897 | else { | |
898 | printk("unregister VAP device: %d fail\n", vapId); | |
899 | ret = -EINVAL; | |
900 | } | |
901 | ||
902 | return ret; | |
903 | } | |
904 | ||
905 | ||
906 | ||
4bd43f50 LR |
907 | # define SUBMIT_URB(u,f) usb_submit_urb(u,f) |
908 | # define USB_ALLOC_URB(u,f) usb_alloc_urb(u,f) | |
4bd43f50 LR |
909 | |
910 | //extern void zfiWlanQueryMacAddress(zdev_t* dev, u8_t* addr); | |
4bd43f50 LR |
911 | |
912 | extern int usbdrv_open(struct net_device *dev); | |
913 | extern int usbdrv_close(struct net_device *dev); | |
914 | extern int usbdrv_xmit_frame(struct sk_buff *skb, struct net_device *dev); | |
915 | extern int usbdrv_xmit_frame(struct sk_buff *skb, struct net_device *dev); | |
916 | extern int usbdrv_change_mtu(struct net_device *dev, int new_mtu); | |
917 | extern void usbdrv_set_multi(struct net_device *dev); | |
918 | extern int usbdrv_set_mac(struct net_device *dev, void *addr); | |
919 | extern struct net_device_stats * usbdrv_get_stats(struct net_device *dev); | |
920 | extern int usbdrv_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd); | |
921 | extern UsbTxQ_t *zfLnxGetUsbTxBuffer(struct net_device *dev); | |
922 | ||
923 | int zfLnxAllocAllUrbs(struct usbdrv_private *macp) | |
924 | { | |
925 | struct usb_interface *interface = macp->interface; | |
4bd43f50 | 926 | struct usb_host_interface *iface_desc = &interface->altsetting[0]; |
4bd43f50 LR |
927 | |
928 | struct usb_endpoint_descriptor *endpoint; | |
929 | int i; | |
930 | ||
931 | /* descriptor matches, let's find the endpoints needed */ | |
932 | /* check out the endpoints */ | |
4bd43f50 LR |
933 | for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) |
934 | { | |
935 | endpoint = &iface_desc->endpoint[i].desc; | |
d0fe1911 | 936 | if (usb_endpoint_is_bulk_in(endpoint)) |
4bd43f50 LR |
937 | { |
938 | /* we found a bulk in endpoint */ | |
939 | printk(KERN_ERR "bulk in: wMaxPacketSize = %x\n", le16_to_cpu(endpoint->wMaxPacketSize)); | |
940 | } | |
941 | ||
d0fe1911 | 942 | if (usb_endpoint_is_bulk_out(endpoint)) |
4bd43f50 LR |
943 | { |
944 | /* we found a bulk out endpoint */ | |
945 | printk(KERN_ERR "bulk out: wMaxPacketSize = %x\n", le16_to_cpu(endpoint->wMaxPacketSize)); | |
946 | } | |
947 | ||
d0fe1911 | 948 | if (usb_endpoint_is_int_in(endpoint)) |
4bd43f50 LR |
949 | { |
950 | /* we found a interrupt in endpoint */ | |
951 | printk(KERN_ERR "interrupt in: wMaxPacketSize = %x\n", le16_to_cpu(endpoint->wMaxPacketSize)); | |
952 | printk(KERN_ERR "interrupt in: int_interval = %d\n", endpoint->bInterval); | |
953 | } | |
954 | ||
d0fe1911 | 955 | if (usb_endpoint_is_int_out(endpoint)) |
4bd43f50 LR |
956 | { |
957 | /* we found a interrupt out endpoint */ | |
958 | printk(KERN_ERR "interrupt out: wMaxPacketSize = %x\n", le16_to_cpu(endpoint->wMaxPacketSize)); | |
959 | printk(KERN_ERR "interrupt out: int_interval = %d\n", endpoint->bInterval); | |
960 | } | |
961 | } | |
962 | ||
963 | /* Allocate all Tx URBs */ | |
964 | for (i = 0; i < ZM_MAX_TX_URB_NUM; i++) | |
965 | { | |
966 | macp->WlanTxDataUrb[i] = USB_ALLOC_URB(0, GFP_KERNEL); | |
967 | ||
968 | if (macp->WlanTxDataUrb[i] == 0) | |
969 | { | |
970 | int j; | |
971 | ||
972 | /* Free all urbs */ | |
973 | for (j = 0; j < i; j++) | |
974 | { | |
975 | usb_free_urb(macp->WlanTxDataUrb[j]); | |
976 | } | |
977 | ||
978 | return 0; | |
979 | } | |
980 | } | |
981 | ||
982 | /* Allocate all Rx URBs */ | |
983 | for (i = 0; i < ZM_MAX_RX_URB_NUM; i++) | |
984 | { | |
985 | macp->WlanRxDataUrb[i] = USB_ALLOC_URB(0, GFP_KERNEL); | |
986 | ||
987 | if (macp->WlanRxDataUrb[i] == 0) | |
988 | { | |
989 | int j; | |
990 | ||
991 | /* Free all urbs */ | |
992 | for (j = 0; j < i; j++) | |
993 | { | |
994 | usb_free_urb(macp->WlanRxDataUrb[j]); | |
995 | } | |
996 | ||
997 | for (j = 0; j < ZM_MAX_TX_URB_NUM; j++) | |
998 | { | |
999 | usb_free_urb(macp->WlanTxDataUrb[j]); | |
1000 | } | |
1001 | ||
1002 | return 0; | |
1003 | } | |
1004 | } | |
1005 | ||
1006 | /* Allocate Register Read/Write USB */ | |
1007 | macp->RegOutUrb = USB_ALLOC_URB(0, GFP_KERNEL); | |
1008 | macp->RegInUrb = USB_ALLOC_URB(0, GFP_KERNEL); | |
1009 | ||
1010 | return 1; | |
1011 | } | |
1012 | ||
1013 | void zfLnxFreeAllUrbs(struct usbdrv_private *macp) | |
1014 | { | |
1015 | int i; | |
1016 | ||
1017 | /* Free all Tx URBs */ | |
1018 | for (i = 0; i < ZM_MAX_TX_URB_NUM; i++) | |
1019 | { | |
1020 | if (macp->WlanTxDataUrb[i] != NULL) | |
1021 | { | |
1022 | usb_free_urb(macp->WlanTxDataUrb[i]); | |
1023 | } | |
1024 | } | |
1025 | ||
1026 | /* Free all Rx URBs */ | |
1027 | for (i = 0; i < ZM_MAX_RX_URB_NUM; i++) | |
1028 | { | |
1029 | if (macp->WlanRxDataUrb[i] != NULL) | |
1030 | { | |
1031 | usb_free_urb(macp->WlanRxDataUrb[i]); | |
1032 | } | |
1033 | } | |
1034 | ||
1035 | /* Free USB Register Read/Write URB */ | |
1036 | usb_free_urb(macp->RegOutUrb); | |
1037 | usb_free_urb(macp->RegInUrb); | |
1038 | } | |
1039 | ||
1040 | void zfLnxUnlinkAllUrbs(struct usbdrv_private *macp) | |
1041 | { | |
1042 | int i; | |
1043 | ||
1044 | /* Unlink all Tx URBs */ | |
1045 | for (i = 0; i < ZM_MAX_TX_URB_NUM; i++) | |
1046 | { | |
1047 | if (macp->WlanTxDataUrb[i] != NULL) | |
1048 | { | |
4bd43f50 LR |
1049 | usb_unlink_urb(macp->WlanTxDataUrb[i]); |
1050 | } | |
1051 | } | |
1052 | ||
1053 | /* Unlink all Rx URBs */ | |
1054 | for (i = 0; i < ZM_MAX_RX_URB_NUM; i++) | |
1055 | { | |
1056 | if (macp->WlanRxDataUrb[i] != NULL) | |
1057 | { | |
4bd43f50 LR |
1058 | usb_unlink_urb(macp->WlanRxDataUrb[i]); |
1059 | } | |
1060 | } | |
1061 | ||
1062 | /* Unlink USB Register Read/Write URB */ | |
4bd43f50 LR |
1063 | usb_unlink_urb(macp->RegOutUrb); |
1064 | ||
4bd43f50 LR |
1065 | usb_unlink_urb(macp->RegInUrb); |
1066 | } | |
1067 | ||
17a23b38 AB |
1068 | static const struct net_device_ops otus_netdev_ops = { |
1069 | .ndo_open = usbdrv_open, | |
1070 | .ndo_stop = usbdrv_close, | |
1071 | .ndo_start_xmit = usbdrv_xmit_frame, | |
1072 | .ndo_change_mtu = usbdrv_change_mtu, | |
1073 | .ndo_get_stats = usbdrv_get_stats, | |
1074 | .ndo_set_multicast_list = usbdrv_set_multi, | |
1075 | .ndo_set_mac_address = usbdrv_set_mac, | |
1076 | .ndo_do_ioctl = usbdrv_ioctl, | |
1077 | .ndo_validate_addr = eth_validate_addr, | |
1078 | }; | |
1079 | ||
4bd43f50 LR |
1080 | u8_t zfLnxInitSetup(struct net_device *dev, struct usbdrv_private *macp) |
1081 | { | |
1082 | //unsigned char addr[6]; | |
1083 | ||
1084 | //init_MUTEX(&macp->ps_sem); | |
1085 | //init_MUTEX(&macp->reg_sem); | |
1086 | //init_MUTEX(&macp->bcn_sem); | |
1087 | //init_MUTEX(&macp->config_sem); | |
1088 | ||
1089 | spin_lock_init(&(macp->cs_lock)); | |
1090 | #if 0 | |
1091 | /* MAC address */ | |
1092 | zfiWlanQueryMacAddress(dev, addr); | |
1093 | dev->dev_addr[0] = addr[0]; | |
1094 | dev->dev_addr[1] = addr[1]; | |
1095 | dev->dev_addr[2] = addr[2]; | |
1096 | dev->dev_addr[3] = addr[3]; | |
1097 | dev->dev_addr[4] = addr[4]; | |
1098 | dev->dev_addr[5] = addr[5]; | |
1099 | #endif | |
4bd43f50 | 1100 | dev->wireless_handlers = (struct iw_handler_def *)&p80211wext_handler_def; |
4bd43f50 | 1101 | |
17a23b38 | 1102 | dev->netdev_ops = &otus_netdev_ops; |
4bd43f50 LR |
1103 | |
1104 | dev->flags |= IFF_MULTICAST; | |
1105 | ||
4bd43f50 LR |
1106 | dev->dev_addr[0] = 0x00; |
1107 | dev->dev_addr[1] = 0x03; | |
1108 | dev->dev_addr[2] = 0x7f; | |
1109 | dev->dev_addr[3] = 0x11; | |
1110 | dev->dev_addr[4] = 0x22; | |
1111 | dev->dev_addr[5] = 0x33; | |
4bd43f50 LR |
1112 | |
1113 | /* Initialize Heart Beat timer */ | |
1114 | init_timer(&macp->hbTimer10ms); | |
1115 | macp->hbTimer10ms.data = (unsigned long)dev; | |
1116 | macp->hbTimer10ms.function = (void *)&zfLnx10msTimer; | |
1117 | ||
1118 | /* Initialize WDS and VAP data structure */ | |
1119 | //zfInitWdsStruct(); | |
1120 | zfLnxInitVapStruct(); | |
1121 | ||
1122 | return 1; | |
1123 | } | |
1124 | ||
1125 | u8_t zfLnxClearStructs(struct net_device *dev) | |
1126 | { | |
1127 | u16_t ii; | |
1128 | u16_t TxQCnt; | |
1129 | ||
1130 | TxQCnt = zfLnxCheckTxBufferCnt(dev); | |
1131 | ||
1132 | printk(KERN_ERR "TxQCnt: %d\n", TxQCnt); | |
1133 | ||
2bef7a0f | 1134 | for (ii = 0; ii < TxQCnt; ii++) { |
4bd43f50 LR |
1135 | UsbTxQ_t *TxQ = zfLnxGetUsbTxBuffer(dev); |
1136 | ||
1137 | printk(KERN_ERR "dev_kfree_skb_any\n"); | |
1138 | /* Free buffer */ | |
1139 | dev_kfree_skb_any(TxQ->buf); | |
1140 | } | |
1141 | ||
1142 | return 0; | |
1143 | } |