]>
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); | |
353 | if ((mem = kmalloc(size, GFP_KERNEL)) == NULL) | |
354 | { | |
355 | rc = -EBUSY; | |
356 | goto exit; | |
357 | } | |
358 | macp->wd = mem; | |
359 | ||
360 | memset(&cbFuncTbl, 0, sizeof(struct zsCbFuncTbl)); | |
361 | cbFuncTbl.zfcbAuthNotify = zfLnxAuthNotify; | |
362 | cbFuncTbl.zfcbAuthNotify = zfLnxAuthNotify; | |
363 | cbFuncTbl.zfcbAsocNotify = zfLnxAsocNotify; | |
364 | cbFuncTbl.zfcbDisAsocNotify = zfLnxDisAsocNotify; | |
365 | cbFuncTbl.zfcbApConnectNotify = zfLnxApConnectNotify; | |
366 | cbFuncTbl.zfcbConnectNotify = zfLnxConnectNotify; | |
367 | cbFuncTbl.zfcbScanNotify = zfLnxScanNotify; | |
368 | cbFuncTbl.zfcbMicFailureNotify = zfLnxMicFailureNotify; | |
369 | cbFuncTbl.zfcbApMicFailureNotify = zfLnxApMicFailureNotify; | |
370 | cbFuncTbl.zfcbIbssPartnerNotify = zfLnxIbssPartnerNotify; | |
371 | cbFuncTbl.zfcbMacAddressNotify = zfLnxMacAddressNotify; | |
372 | cbFuncTbl.zfcbSendCompleteIndication = zfLnxSendCompleteIndication; | |
373 | cbFuncTbl.zfcbRecvEth = zfLnxRecvEth; | |
374 | cbFuncTbl.zfcbRecv80211 = zfLnxRecv80211; | |
375 | cbFuncTbl.zfcbRestoreBufData = zfLnxRestoreBufData; | |
376 | #ifdef ZM_ENABLE_CENC | |
377 | cbFuncTbl.zfcbCencAsocNotify = zfLnxCencAsocNotify; | |
378 | #endif //ZM_ENABLE_CENC | |
379 | cbFuncTbl.zfcbHwWatchDogNotify = zfLnxWatchDogNotify; | |
380 | zfiWlanOpen(dev, &cbFuncTbl); | |
381 | ||
382 | #if 0 | |
383 | { | |
384 | //u16_t mac[3] = {0x1300, 0xb6d4, 0x5aaf}; | |
385 | u16_t mac[3] = {0x8000, 0x00ab, 0x0000}; | |
386 | //zfiWlanSetMacAddress(dev, mac); | |
387 | } | |
388 | /* MAC address */ | |
389 | zfiWlanQueryMacAddress(dev, addr); | |
390 | dev->dev_addr[0] = addr[0]; | |
391 | dev->dev_addr[1] = addr[1]; | |
392 | dev->dev_addr[2] = addr[2]; | |
393 | dev->dev_addr[3] = addr[3]; | |
394 | dev->dev_addr[4] = addr[4]; | |
395 | dev->dev_addr[5] = addr[5]; | |
396 | #endif | |
2bef7a0f | 397 | /* zfwMacAddressNotify() will be called to setup dev->dev_addr[] */ |
4bd43f50 LR |
398 | |
399 | zfLnxCreateThread(dev); | |
400 | ||
2bef7a0f | 401 | mod_timer(&(macp->hbTimer10ms), jiffies + (1*HZ)/100); /* 10 ms */ |
4bd43f50 LR |
402 | |
403 | netif_carrier_on(dev); | |
404 | ||
405 | netif_start_queue(dev); | |
406 | ||
407 | #if ZM_AP_MODE == 1 | |
408 | zfiWlanSetWlanMode(dev, ZM_MODE_AP); | |
409 | zfiWlanSetBasicRate(dev, 0xf, 0, 0); | |
410 | zfiWlanSetSSID(dev, "OTUS_CWY", 8); | |
411 | zfiWlanSetDtimCount(dev, 3); | |
412 | ||
413 | #if ZM_WEP_MOME == 1 | |
414 | { | |
415 | u8_t key[16] = {0x12, 0x34, 0x56, 0x78, 0x90}; | |
416 | struct zsKeyInfo keyInfo; | |
417 | ||
418 | keyInfo.keyLength = 5; | |
419 | keyInfo.keyIndex = 0; | |
420 | keyInfo.flag = 0; | |
421 | keyInfo.key = key; | |
422 | zfiWlanSetKey(dev, keyInfo); | |
423 | ||
424 | zfiWlanSetEncryMode(dev, ZM_WEP64); | |
425 | } | |
426 | ||
427 | #if ZM_SHARE_AUTH == 1 | |
428 | zfiWlanSetAuthenticationMode(dev, 1); | |
2bef7a0f MT |
429 | #endif /* #if ZM_SHARE_AUTH == 1 */ |
430 | #endif /* #if ZM_WEP_MOME == 1 */ | |
4bd43f50 LR |
431 | |
432 | #elif ZM_PIBSS_MODE == 1 | |
433 | zfiWlanSetWlanMode(dev, ZM_MODE_PSEUDO); | |
434 | #else | |
435 | zfiWlanSetWlanMode(dev, ZM_MODE_INFRASTRUCTURE); | |
436 | #endif | |
2bef7a0f | 437 | /* zfiWlanSetChannel(dev, ZM_CHANNEL, FALSE); */ |
4bd43f50 LR |
438 | zfiWlanSetFrequency(dev, 2462000, FALSE); |
439 | zfiWlanSetRtsThreshold(dev, 32767); | |
440 | zfiWlanSetFragThreshold(dev, 0); | |
441 | ||
442 | zfiWlanEnable(dev); | |
443 | ||
444 | #ifdef ZM_ENABLE_CENC | |
4bd43f50 | 445 | macp->netlink_sk = netlink_kernel_create(NETLINK_USERSOCK, 1, NULL, THIS_MODULE); |
4bd43f50 LR |
446 | |
447 | if (macp->netlink_sk == NULL) | |
448 | { | |
449 | printk(KERN_ERR "Can't create NETLINK socket\n"); | |
450 | } | |
451 | #endif | |
452 | ||
453 | macp->DeviceOpened = 1; | |
454 | exit: | |
455 | //#ifndef CONFIG_SMP | |
456 | // read_unlock(&(macp->isolate_lock)); | |
457 | //#endif | |
458 | //zfRegisterWdsDev(dev, 0); | |
459 | //zfLnxRegisterVapDev(dev, 0); | |
460 | ||
461 | return rc; | |
462 | } | |
463 | ||
464 | ||
465 | ||
466 | ||
467 | /** | |
468 | * usbdrv_get_stats - get driver statistics | |
469 | * @dev: adapter's net_device struct | |
470 | * | |
471 | * This routine is called when the OS wants the adapter's stats returned. | |
472 | * It returns the address of the net_device_stats stucture for the device. | |
473 | * If the statistics are currently being updated, then they might be incorrect | |
474 | * for a short while. However, since this cannot actually cause damage, no | |
475 | * locking is used. | |
476 | */ | |
477 | ||
478 | struct net_device_stats * usbdrv_get_stats(struct net_device *dev) | |
479 | { | |
da3e8908 | 480 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
481 | |
482 | macp->drv_stats.net_stats.tx_errors = | |
483 | macp->drv_stats.net_stats.tx_carrier_errors + | |
484 | macp->drv_stats.net_stats.tx_aborted_errors; | |
485 | ||
486 | macp->drv_stats.net_stats.rx_errors = | |
487 | macp->drv_stats.net_stats.rx_crc_errors + | |
488 | macp->drv_stats.net_stats.rx_frame_errors + | |
489 | macp->drv_stats.net_stats.rx_length_errors; | |
490 | ||
491 | ||
492 | return &(macp->drv_stats.net_stats); | |
493 | } | |
494 | ||
495 | ||
496 | /** | |
497 | * usbdrv_set_mac - set the MAC address | |
498 | * @dev: adapter's net_device struct | |
499 | * @addr: the new address | |
500 | * | |
501 | * This routine sets the ethernet address of the board | |
502 | * Returns: | |
503 | * 0 - if successful | |
504 | * -1 - otherwise | |
505 | */ | |
506 | ||
507 | int usbdrv_set_mac(struct net_device *dev, void *addr) | |
508 | { | |
509 | struct usbdrv_private *macp; | |
510 | int rc = -1; | |
511 | ||
da3e8908 | 512 | macp = dev->ml_priv; |
4bd43f50 LR |
513 | read_lock(&(macp->isolate_lock)); |
514 | ||
515 | if (macp->driver_isolated) { | |
516 | goto exit; | |
517 | } | |
518 | ||
519 | rc = 0; | |
520 | ||
521 | ||
522 | exit: | |
523 | read_unlock(&(macp->isolate_lock)); | |
524 | return rc; | |
525 | } | |
526 | ||
527 | ||
528 | ||
529 | void | |
530 | usbdrv_isolate_driver(struct usbdrv_private *macp) | |
531 | { | |
532 | #ifndef CONFIG_SMP | |
533 | write_lock_irq(&(macp->isolate_lock)); | |
534 | #endif | |
535 | macp->driver_isolated = TRUE; | |
536 | #ifndef CONFIG_SMP | |
537 | write_unlock_irq(&(macp->isolate_lock)); | |
538 | #endif | |
539 | ||
540 | if (netif_running(macp->device)) | |
541 | { | |
542 | netif_carrier_off(macp->device); | |
543 | netif_stop_queue(macp->device); | |
544 | } | |
545 | } | |
546 | ||
547 | #define VLAN_SIZE 4 | |
548 | int usbdrv_change_mtu(struct net_device *dev, int new_mtu) | |
549 | { | |
550 | if ((new_mtu < 68) || (new_mtu > (ETH_DATA_LEN + VLAN_SIZE))) | |
551 | return -EINVAL; | |
552 | ||
553 | dev->mtu = new_mtu; | |
554 | return 0; | |
555 | } | |
556 | ||
557 | void zfLnxUnlinkAllUrbs(struct usbdrv_private *macp); | |
558 | ||
559 | int usbdrv_close(struct net_device *dev) | |
560 | { | |
561 | extern void zfHpLedCtrl(struct net_device *dev, u16_t ledId, u8_t mode); | |
562 | ||
da3e8908 | 563 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
564 | |
565 | printk(KERN_DEBUG "usbdrv_close\n"); | |
566 | ||
567 | netif_carrier_off(macp->device); | |
568 | ||
569 | del_timer_sync(&macp->hbTimer10ms); | |
570 | ||
571 | printk(KERN_DEBUG "usbdrv_netif_carrier_off\n"); | |
572 | ||
573 | usbdrv_isolate_driver(macp); | |
574 | ||
575 | printk(KERN_DEBUG "usbdrv_isolate_driver\n"); | |
576 | ||
577 | netif_carrier_off(macp->device); | |
578 | #ifdef ZM_ENABLE_CENC | |
579 | /* CENC */ | |
580 | if (macp->netlink_sk != NULL) | |
581 | { | |
582 | // sock_release(macp->netlink_sk); | |
583 | printk(KERN_ERR "usbdrv close netlink socket\n"); | |
584 | } | |
585 | #endif //ZM_ENABLE_CENC | |
586 | #if (WLAN_HOSTIF == WLAN_PCI) | |
587 | //free_irq(dev->irq, dev); | |
588 | #endif | |
589 | ||
590 | /* Turn off LED */ | |
591 | zfHpLedCtrl(dev, 0, 0); | |
592 | zfHpLedCtrl(dev, 1, 0); | |
593 | ||
594 | /* Delay for a while */ | |
595 | mdelay(10); | |
596 | ||
597 | /* clear WPA/RSN IE */ | |
598 | macp->supIe[1] = 0; | |
599 | ||
600 | /* set the isolate flag to false, so usbdrv_open can be called */ | |
601 | macp->driver_isolated = FALSE; | |
602 | ||
603 | zfiWlanClose(dev); | |
604 | kfree(macp->wd); | |
605 | ||
606 | zfLnxUnlinkAllUrbs(macp); | |
607 | ||
608 | return 0; | |
609 | } | |
610 | ||
611 | ||
612 | ||
613 | ||
614 | int usbdrv_xmit_frame(struct sk_buff *skb, struct net_device *dev) | |
615 | { | |
616 | int notify_stop = FALSE; | |
da3e8908 | 617 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
618 | |
619 | #if 0 | |
620 | /* Test code */ | |
621 | { | |
622 | struct sk_buff* s; | |
623 | ||
624 | s = skb_copy_expand(skb, 8, 0, GFP_ATOMIC); | |
625 | skb_push(s, 8); | |
626 | s->data[0] = 'z'; | |
627 | s->data[1] = 'y'; | |
628 | s->data[2] = 'd'; | |
629 | s->data[3] = 'a'; | |
630 | s->data[4] = 's'; | |
631 | printk("len1=%d, len2=%d", skb->len, s->len); | |
632 | netlink_broadcast(rtnl, s, 0, RTMGRP_LINK, GFP_ATOMIC); | |
633 | } | |
634 | #endif | |
635 | ||
636 | #if ZM_DISABLE_XMIT | |
637 | dev_kfree_skb_irq(skb); | |
638 | #else | |
639 | zfiTxSendEth(dev, skb, 0); | |
640 | #endif | |
641 | macp->drv_stats.net_stats.tx_bytes += skb->len; | |
642 | macp->drv_stats.net_stats.tx_packets++; | |
643 | ||
644 | //dev_kfree_skb_irq(skb); | |
645 | ||
646 | if (notify_stop) { | |
647 | netif_carrier_off(dev); | |
648 | netif_stop_queue(dev); | |
649 | } | |
650 | ||
6ed10654 | 651 | return NETDEV_TX_OK; |
4bd43f50 LR |
652 | } |
653 | ||
654 | ||
655 | ||
656 | ||
657 | void usbdrv_set_multi(struct net_device *dev) | |
658 | { | |
659 | ||
660 | ||
661 | if (!(dev->flags & IFF_UP)) | |
662 | return; | |
663 | ||
664 | return; | |
665 | ||
666 | } | |
667 | ||
668 | ||
669 | ||
670 | /** | |
671 | * usbdrv_clear_structs - free resources | |
672 | ||
673 | * @dev: adapter's net_device struct | |
674 | * | |
675 | * Free all device specific structs, unmap i/o address, etc. | |
676 | */ | |
677 | void usbdrv_clear_structs(struct net_device *dev) | |
678 | { | |
da3e8908 | 679 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
680 | |
681 | ||
682 | #if (WLAN_HOSTIF == WLAN_PCI) | |
683 | iounmap(macp->regp); | |
684 | ||
685 | pci_release_regions(macp->pdev); | |
686 | pci_disable_device(macp->pdev); | |
687 | pci_set_drvdata(macp->pdev, NULL); | |
688 | #endif | |
689 | ||
690 | kfree(macp); | |
691 | ||
692 | kfree(dev); | |
693 | ||
694 | } | |
695 | ||
696 | void usbdrv_remove1(struct pci_dev *pcid) | |
697 | { | |
698 | struct net_device *dev; | |
699 | struct usbdrv_private *macp; | |
700 | ||
701 | if (!(dev = (struct net_device *) pci_get_drvdata(pcid))) | |
702 | return; | |
703 | ||
da3e8908 | 704 | macp = dev->ml_priv; |
4bd43f50 LR |
705 | unregister_netdev(dev); |
706 | ||
707 | usbdrv_clear_structs(dev); | |
708 | } | |
709 | ||
710 | ||
711 | void zfLnx10msTimer(struct net_device* dev) | |
712 | { | |
da3e8908 | 713 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
714 | |
715 | mod_timer(&(macp->hbTimer10ms), jiffies + (1*HZ)/100); //10 ms | |
716 | zfiHeartBeat(dev); | |
717 | return; | |
718 | } | |
719 | ||
720 | void zfLnxInitVapStruct(void) | |
721 | { | |
722 | u16_t i; | |
723 | ||
2bef7a0f | 724 | for (i = 0; i < ZM_VAP_PORT_NUMBER; i++) |
4bd43f50 LR |
725 | { |
726 | vap[i].dev = NULL; | |
727 | vap[i].openFlag = 0; | |
728 | } | |
729 | } | |
730 | ||
731 | int zfLnxVapOpen(struct net_device *dev) | |
732 | { | |
733 | u16_t vapId; | |
734 | ||
735 | vapId = zfLnxGetVapId(dev); | |
736 | ||
737 | if (vap[vapId].openFlag == 0) | |
738 | { | |
739 | vap[vapId].openFlag = 1; | |
740 | printk("zfLnxVapOpen : device name=%s, vap ID=%d\n", dev->name, vapId); | |
741 | zfiWlanSetSSID(dev, "vap1", 4); | |
742 | zfiWlanEnable(dev); | |
743 | netif_start_queue(dev); | |
744 | } | |
745 | else | |
746 | { | |
747 | printk("VAP opened error : vap ID=%d\n", vapId); | |
748 | } | |
749 | return 0; | |
750 | } | |
751 | ||
752 | int zfLnxVapClose(struct net_device *dev) | |
753 | { | |
754 | u16_t vapId; | |
755 | ||
756 | vapId = zfLnxGetVapId(dev); | |
757 | ||
758 | if (vapId != 0xffff) | |
759 | { | |
760 | if (vap[vapId].openFlag == 1) | |
761 | { | |
762 | printk("zfLnxVapClose: device name=%s, vap ID=%d\n", dev->name, vapId); | |
763 | ||
764 | netif_stop_queue(dev); | |
765 | vap[vapId].openFlag = 0; | |
766 | } | |
767 | else | |
768 | { | |
769 | printk("VAP port was not opened : vap ID=%d\n", vapId); | |
770 | } | |
771 | } | |
772 | return 0; | |
773 | } | |
774 | ||
775 | int zfLnxVapXmitFrame(struct sk_buff *skb, struct net_device *dev) | |
776 | { | |
777 | int notify_stop = FALSE; | |
da3e8908 | 778 | struct usbdrv_private *macp = dev->ml_priv; |
4bd43f50 LR |
779 | u16_t vapId; |
780 | ||
781 | vapId = zfLnxGetVapId(dev); | |
782 | //printk("zfLnxVapXmitFrame: vap ID=%d\n", vapId); | |
783 | //printk("zfLnxVapXmitFrame(), skb=%lxh\n", (u32_t)skb); | |
784 | ||
785 | if (vapId >= ZM_VAP_PORT_NUMBER) | |
786 | { | |
787 | dev_kfree_skb_irq(skb); | |
6ed10654 | 788 | return NETDEV_TX_OK; |
4bd43f50 LR |
789 | } |
790 | #if 1 | |
791 | if (vap[vapId].openFlag == 0) | |
792 | { | |
793 | dev_kfree_skb_irq(skb); | |
6ed10654 | 794 | return NETDEV_TX_OK; |
4bd43f50 LR |
795 | } |
796 | #endif | |
797 | ||
798 | ||
799 | zfiTxSendEth(dev, skb, 0x1); | |
800 | ||
801 | macp->drv_stats.net_stats.tx_bytes += skb->len; | |
802 | macp->drv_stats.net_stats.tx_packets++; | |
803 | ||
804 | //dev_kfree_skb_irq(skb); | |
805 | ||
806 | if (notify_stop) { | |
807 | netif_carrier_off(dev); | |
808 | netif_stop_queue(dev); | |
809 | } | |
810 | ||
6ed10654 | 811 | return NETDEV_TX_OK; |
4bd43f50 LR |
812 | } |
813 | ||
17a23b38 AB |
814 | static const struct net_device_ops vap_netdev_ops = { |
815 | .ndo_open = zfLnxVapOpen, | |
816 | .ndo_stop = zfLnxVapClose, | |
817 | .ndo_start_xmit = zfLnxVapXmitFrame, | |
818 | .ndo_get_stats = usbdrv_get_stats, | |
819 | .ndo_change_mtu = usbdrv_change_mtu, | |
820 | .ndo_validate_addr = eth_validate_addr, | |
821 | .ndo_set_mac_address = eth_mac_addr, | |
822 | #ifdef ZM_HOSTAPD_SUPPORT | |
823 | .ndo_do_ioctl = usbdrv_ioctl, | |
824 | #else | |
825 | .ndo_do_ioctl = NULL, | |
826 | #endif | |
827 | }; | |
828 | ||
4bd43f50 LR |
829 | int zfLnxRegisterVapDev(struct net_device* parentDev, u16_t vapId) |
830 | { | |
831 | /* Allocate net device structure */ | |
832 | vap[vapId].dev = alloc_etherdev(0); | |
23639126 | 833 | printk("Register vap dev=%p\n", vap[vapId].dev); |
4bd43f50 LR |
834 | |
835 | if(vap[vapId].dev == NULL) { | |
836 | printk("alloc_etherdev fail\n"); | |
837 | return -ENOMEM; | |
838 | } | |
839 | ||
840 | /* Setup the default settings */ | |
841 | ether_setup(vap[vapId].dev); | |
842 | ||
843 | /* MAC address */ | |
844 | memcpy(vap[vapId].dev->dev_addr, parentDev->dev_addr, ETH_ALEN); | |
845 | ||
846 | vap[vapId].dev->irq = parentDev->irq; | |
847 | vap[vapId].dev->base_addr = parentDev->base_addr; | |
848 | vap[vapId].dev->mem_start = parentDev->mem_start; | |
849 | vap[vapId].dev->mem_end = parentDev->mem_end; | |
da3e8908 | 850 | vap[vapId].dev->ml_priv = parentDev->ml_priv; |
4bd43f50 LR |
851 | |
852 | //dev->hard_start_xmit = &zd1212_wds_xmit_frame; | |
17a23b38 | 853 | vap[vapId].dev->netdev_ops = &vap_netdev_ops; |
4bd43f50 | 854 | vap[vapId].dev->destructor = free_netdev; |
4bd43f50 LR |
855 | |
856 | vap[vapId].dev->tx_queue_len = 0; | |
857 | ||
858 | vap[vapId].dev->dev_addr[0] = parentDev->dev_addr[0]; | |
859 | vap[vapId].dev->dev_addr[1] = parentDev->dev_addr[1]; | |
860 | vap[vapId].dev->dev_addr[2] = parentDev->dev_addr[2]; | |
861 | vap[vapId].dev->dev_addr[3] = parentDev->dev_addr[3]; | |
862 | vap[vapId].dev->dev_addr[4] = parentDev->dev_addr[4]; | |
863 | vap[vapId].dev->dev_addr[5] = parentDev->dev_addr[5] + (vapId+1); | |
864 | ||
865 | /* Stop the network queue first */ | |
866 | netif_stop_queue(vap[vapId].dev); | |
867 | ||
868 | sprintf(vap[vapId].dev->name, "vap%d", vapId); | |
869 | printk("Register VAP dev success : %s\n", vap[vapId].dev->name); | |
870 | ||
871 | if(register_netdevice(vap[vapId].dev) != 0) { | |
872 | printk("register VAP device fail\n"); | |
873 | vap[vapId].dev = NULL; | |
874 | return -EINVAL; | |
875 | } | |
876 | ||
877 | return 0; | |
878 | } | |
879 | ||
880 | int zfLnxUnregisterVapDev(struct net_device* parentDev, u16_t vapId) | |
881 | { | |
882 | int ret = 0; | |
883 | ||
884 | printk("Unregister VAP dev : %s\n", vap[vapId].dev->name); | |
885 | ||
886 | if(vap[vapId].dev != NULL) { | |
23639126 | 887 | printk("Unregister vap dev=%p\n", vap[vapId].dev); |
4bd43f50 LR |
888 | // |
889 | //unregister_netdevice(wds[wdsId].dev); | |
890 | unregister_netdev(vap[vapId].dev); | |
891 | ||
892 | printk("VAP unregister_netdevice\n"); | |
893 | vap[vapId].dev = NULL; | |
894 | } | |
895 | else { | |
896 | printk("unregister VAP device: %d fail\n", vapId); | |
897 | ret = -EINVAL; | |
898 | } | |
899 | ||
900 | return ret; | |
901 | } | |
902 | ||
903 | ||
904 | ||
4bd43f50 LR |
905 | # define SUBMIT_URB(u,f) usb_submit_urb(u,f) |
906 | # define USB_ALLOC_URB(u,f) usb_alloc_urb(u,f) | |
4bd43f50 LR |
907 | |
908 | //extern void zfiWlanQueryMacAddress(zdev_t* dev, u8_t* addr); | |
4bd43f50 LR |
909 | |
910 | extern int usbdrv_open(struct net_device *dev); | |
911 | extern int usbdrv_close(struct net_device *dev); | |
912 | extern int usbdrv_xmit_frame(struct sk_buff *skb, struct net_device *dev); | |
913 | extern int usbdrv_xmit_frame(struct sk_buff *skb, struct net_device *dev); | |
914 | extern int usbdrv_change_mtu(struct net_device *dev, int new_mtu); | |
915 | extern void usbdrv_set_multi(struct net_device *dev); | |
916 | extern int usbdrv_set_mac(struct net_device *dev, void *addr); | |
917 | extern struct net_device_stats * usbdrv_get_stats(struct net_device *dev); | |
918 | extern int usbdrv_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd); | |
919 | extern UsbTxQ_t *zfLnxGetUsbTxBuffer(struct net_device *dev); | |
920 | ||
921 | int zfLnxAllocAllUrbs(struct usbdrv_private *macp) | |
922 | { | |
923 | struct usb_interface *interface = macp->interface; | |
4bd43f50 | 924 | struct usb_host_interface *iface_desc = &interface->altsetting[0]; |
4bd43f50 LR |
925 | |
926 | struct usb_endpoint_descriptor *endpoint; | |
927 | int i; | |
928 | ||
929 | /* descriptor matches, let's find the endpoints needed */ | |
930 | /* check out the endpoints */ | |
4bd43f50 LR |
931 | for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) |
932 | { | |
933 | endpoint = &iface_desc->endpoint[i].desc; | |
d0fe1911 | 934 | if (usb_endpoint_is_bulk_in(endpoint)) |
4bd43f50 LR |
935 | { |
936 | /* we found a bulk in endpoint */ | |
937 | printk(KERN_ERR "bulk in: wMaxPacketSize = %x\n", le16_to_cpu(endpoint->wMaxPacketSize)); | |
938 | } | |
939 | ||
d0fe1911 | 940 | if (usb_endpoint_is_bulk_out(endpoint)) |
4bd43f50 LR |
941 | { |
942 | /* we found a bulk out endpoint */ | |
943 | printk(KERN_ERR "bulk out: wMaxPacketSize = %x\n", le16_to_cpu(endpoint->wMaxPacketSize)); | |
944 | } | |
945 | ||
d0fe1911 | 946 | if (usb_endpoint_is_int_in(endpoint)) |
4bd43f50 LR |
947 | { |
948 | /* we found a interrupt in endpoint */ | |
949 | printk(KERN_ERR "interrupt in: wMaxPacketSize = %x\n", le16_to_cpu(endpoint->wMaxPacketSize)); | |
950 | printk(KERN_ERR "interrupt in: int_interval = %d\n", endpoint->bInterval); | |
951 | } | |
952 | ||
d0fe1911 | 953 | if (usb_endpoint_is_int_out(endpoint)) |
4bd43f50 LR |
954 | { |
955 | /* we found a interrupt out endpoint */ | |
956 | printk(KERN_ERR "interrupt out: wMaxPacketSize = %x\n", le16_to_cpu(endpoint->wMaxPacketSize)); | |
957 | printk(KERN_ERR "interrupt out: int_interval = %d\n", endpoint->bInterval); | |
958 | } | |
959 | } | |
960 | ||
961 | /* Allocate all Tx URBs */ | |
962 | for (i = 0; i < ZM_MAX_TX_URB_NUM; i++) | |
963 | { | |
964 | macp->WlanTxDataUrb[i] = USB_ALLOC_URB(0, GFP_KERNEL); | |
965 | ||
966 | if (macp->WlanTxDataUrb[i] == 0) | |
967 | { | |
968 | int j; | |
969 | ||
970 | /* Free all urbs */ | |
971 | for (j = 0; j < i; j++) | |
972 | { | |
973 | usb_free_urb(macp->WlanTxDataUrb[j]); | |
974 | } | |
975 | ||
976 | return 0; | |
977 | } | |
978 | } | |
979 | ||
980 | /* Allocate all Rx URBs */ | |
981 | for (i = 0; i < ZM_MAX_RX_URB_NUM; i++) | |
982 | { | |
983 | macp->WlanRxDataUrb[i] = USB_ALLOC_URB(0, GFP_KERNEL); | |
984 | ||
985 | if (macp->WlanRxDataUrb[i] == 0) | |
986 | { | |
987 | int j; | |
988 | ||
989 | /* Free all urbs */ | |
990 | for (j = 0; j < i; j++) | |
991 | { | |
992 | usb_free_urb(macp->WlanRxDataUrb[j]); | |
993 | } | |
994 | ||
995 | for (j = 0; j < ZM_MAX_TX_URB_NUM; j++) | |
996 | { | |
997 | usb_free_urb(macp->WlanTxDataUrb[j]); | |
998 | } | |
999 | ||
1000 | return 0; | |
1001 | } | |
1002 | } | |
1003 | ||
1004 | /* Allocate Register Read/Write USB */ | |
1005 | macp->RegOutUrb = USB_ALLOC_URB(0, GFP_KERNEL); | |
1006 | macp->RegInUrb = USB_ALLOC_URB(0, GFP_KERNEL); | |
1007 | ||
1008 | return 1; | |
1009 | } | |
1010 | ||
1011 | void zfLnxFreeAllUrbs(struct usbdrv_private *macp) | |
1012 | { | |
1013 | int i; | |
1014 | ||
1015 | /* Free all Tx URBs */ | |
1016 | for (i = 0; i < ZM_MAX_TX_URB_NUM; i++) | |
1017 | { | |
1018 | if (macp->WlanTxDataUrb[i] != NULL) | |
1019 | { | |
1020 | usb_free_urb(macp->WlanTxDataUrb[i]); | |
1021 | } | |
1022 | } | |
1023 | ||
1024 | /* Free all Rx URBs */ | |
1025 | for (i = 0; i < ZM_MAX_RX_URB_NUM; i++) | |
1026 | { | |
1027 | if (macp->WlanRxDataUrb[i] != NULL) | |
1028 | { | |
1029 | usb_free_urb(macp->WlanRxDataUrb[i]); | |
1030 | } | |
1031 | } | |
1032 | ||
1033 | /* Free USB Register Read/Write URB */ | |
1034 | usb_free_urb(macp->RegOutUrb); | |
1035 | usb_free_urb(macp->RegInUrb); | |
1036 | } | |
1037 | ||
1038 | void zfLnxUnlinkAllUrbs(struct usbdrv_private *macp) | |
1039 | { | |
1040 | int i; | |
1041 | ||
1042 | /* Unlink all Tx URBs */ | |
1043 | for (i = 0; i < ZM_MAX_TX_URB_NUM; i++) | |
1044 | { | |
1045 | if (macp->WlanTxDataUrb[i] != NULL) | |
1046 | { | |
4bd43f50 LR |
1047 | usb_unlink_urb(macp->WlanTxDataUrb[i]); |
1048 | } | |
1049 | } | |
1050 | ||
1051 | /* Unlink all Rx URBs */ | |
1052 | for (i = 0; i < ZM_MAX_RX_URB_NUM; i++) | |
1053 | { | |
1054 | if (macp->WlanRxDataUrb[i] != NULL) | |
1055 | { | |
4bd43f50 LR |
1056 | usb_unlink_urb(macp->WlanRxDataUrb[i]); |
1057 | } | |
1058 | } | |
1059 | ||
1060 | /* Unlink USB Register Read/Write URB */ | |
4bd43f50 LR |
1061 | usb_unlink_urb(macp->RegOutUrb); |
1062 | ||
4bd43f50 LR |
1063 | usb_unlink_urb(macp->RegInUrb); |
1064 | } | |
1065 | ||
17a23b38 AB |
1066 | static const struct net_device_ops otus_netdev_ops = { |
1067 | .ndo_open = usbdrv_open, | |
1068 | .ndo_stop = usbdrv_close, | |
1069 | .ndo_start_xmit = usbdrv_xmit_frame, | |
1070 | .ndo_change_mtu = usbdrv_change_mtu, | |
1071 | .ndo_get_stats = usbdrv_get_stats, | |
1072 | .ndo_set_multicast_list = usbdrv_set_multi, | |
1073 | .ndo_set_mac_address = usbdrv_set_mac, | |
1074 | .ndo_do_ioctl = usbdrv_ioctl, | |
1075 | .ndo_validate_addr = eth_validate_addr, | |
1076 | }; | |
1077 | ||
4bd43f50 LR |
1078 | u8_t zfLnxInitSetup(struct net_device *dev, struct usbdrv_private *macp) |
1079 | { | |
1080 | //unsigned char addr[6]; | |
1081 | ||
1082 | //init_MUTEX(&macp->ps_sem); | |
1083 | //init_MUTEX(&macp->reg_sem); | |
1084 | //init_MUTEX(&macp->bcn_sem); | |
1085 | //init_MUTEX(&macp->config_sem); | |
1086 | ||
1087 | spin_lock_init(&(macp->cs_lock)); | |
1088 | #if 0 | |
1089 | /* MAC address */ | |
1090 | zfiWlanQueryMacAddress(dev, addr); | |
1091 | dev->dev_addr[0] = addr[0]; | |
1092 | dev->dev_addr[1] = addr[1]; | |
1093 | dev->dev_addr[2] = addr[2]; | |
1094 | dev->dev_addr[3] = addr[3]; | |
1095 | dev->dev_addr[4] = addr[4]; | |
1096 | dev->dev_addr[5] = addr[5]; | |
1097 | #endif | |
4bd43f50 | 1098 | dev->wireless_handlers = (struct iw_handler_def *)&p80211wext_handler_def; |
4bd43f50 | 1099 | |
17a23b38 | 1100 | dev->netdev_ops = &otus_netdev_ops; |
4bd43f50 LR |
1101 | |
1102 | dev->flags |= IFF_MULTICAST; | |
1103 | ||
4bd43f50 LR |
1104 | dev->dev_addr[0] = 0x00; |
1105 | dev->dev_addr[1] = 0x03; | |
1106 | dev->dev_addr[2] = 0x7f; | |
1107 | dev->dev_addr[3] = 0x11; | |
1108 | dev->dev_addr[4] = 0x22; | |
1109 | dev->dev_addr[5] = 0x33; | |
4bd43f50 LR |
1110 | |
1111 | /* Initialize Heart Beat timer */ | |
1112 | init_timer(&macp->hbTimer10ms); | |
1113 | macp->hbTimer10ms.data = (unsigned long)dev; | |
1114 | macp->hbTimer10ms.function = (void *)&zfLnx10msTimer; | |
1115 | ||
1116 | /* Initialize WDS and VAP data structure */ | |
1117 | //zfInitWdsStruct(); | |
1118 | zfLnxInitVapStruct(); | |
1119 | ||
1120 | return 1; | |
1121 | } | |
1122 | ||
1123 | u8_t zfLnxClearStructs(struct net_device *dev) | |
1124 | { | |
1125 | u16_t ii; | |
1126 | u16_t TxQCnt; | |
1127 | ||
1128 | TxQCnt = zfLnxCheckTxBufferCnt(dev); | |
1129 | ||
1130 | printk(KERN_ERR "TxQCnt: %d\n", TxQCnt); | |
1131 | ||
2bef7a0f | 1132 | for (ii = 0; ii < TxQCnt; ii++) { |
4bd43f50 LR |
1133 | UsbTxQ_t *TxQ = zfLnxGetUsbTxBuffer(dev); |
1134 | ||
1135 | printk(KERN_ERR "dev_kfree_skb_any\n"); | |
1136 | /* Free buffer */ | |
1137 | dev_kfree_skb_any(TxQ->buf); | |
1138 | } | |
1139 | ||
1140 | return 0; | |
1141 | } |