projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / otus / usbdrv.c
CommitLineData
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
49extern void zfDumpDescriptor(zdev_t* dev, u16_t type);
50//extern void zfiWlanQueryMacAddress(zdev_t* dev, u8_t* addr);
51
52// ISR handler
4bd43f50 53irqreturn_t usbdrv_intr(int, void *, struct pt_regs *);
4bd43f50
LR		 54
55// Network Device interface related function
56int usbdrv_open(struct net_device *);
57int usbdrv_close(struct net_device *);
58int usbdrv_change_mtu(struct net_device *, int);
59int usbdrv_set_mac(struct net_device *, void *);
60int usbdrv_xmit_frame(struct sk_buff *, struct net_device *);
61void usbdrv_set_multi(struct net_device *);
62struct net_device_stats *usbdrv_get_stats(struct net_device *);
63
64//wireless extension helper functions
65int usbdrv_ioctl_setessid(struct net_device *dev, struct iw_point *erq);
66int usbdrv_ioctl_getessid(struct net_device *dev, struct iw_point *erq);
67int usbdrv_ioctl_setrts(struct net_device *dev, struct iw_param *rrq);
68/* Wireless Extension Handler functions */
69int usbdrvwext_giwmode(struct net_device *dev, struct iw_request_info* info,
70 __u32 *mode, char *extra);
71int zfLnxPrivateIoctl(struct usbdrv_private *macp, struct zdap_ioctl *zdreq);
72
73void zfLnx10msTimer(struct net_device* dev);
74int zfUnregisterWdsDev(struct net_device* parentDev, u16_t wdsId);
75int zfRegisterWdsDev(struct net_device* parentDev, u16_t wdsId);
76int zfWdsOpen(struct net_device *dev);
77int zfWdsClose(struct net_device *dev);
78int zfLnxVapOpen(struct net_device *dev);
79int zfLnxVapClose(struct net_device *dev);
80int zfLnxVapXmitFrame(struct sk_buff *skb, struct net_device *dev);
81int zfLnxRegisterVapDev(struct net_device* parentDev, u16_t vapId);
82int usbdrv_wpa_ioctl(struct net_device *dev, struct athr_wlan_param *zdparm);
83extern u16_t zfLnxGetVapId(zdev_t* dev);
84extern u16_t zfLnxCheckTxBufferCnt(zdev_t *dev);
85extern UsbTxQ_t *zfLnxGetUsbTxBuffer(zdev_t *dev);
86
87extern u16_t zfLnxAuthNotify(zdev_t* dev, u16_t* macAddr);
88extern u16_t zfLnxAsocNotify(zdev_t* dev, u16_t* macAddr, u8_t* body, u16_t bodySize, u16_t port);
89extern u16_t zfLnxDisAsocNotify(zdev_t* dev, u8_t* macAddr, u16_t port);
90extern u16_t zfLnxApConnectNotify(zdev_t* dev, u8_t* macAddr, u16_t port);
91extern void zfLnxConnectNotify(zdev_t* dev, u16_t status, u16_t* bssid);
92extern void zfLnxScanNotify(zdev_t* dev, struct zsScanResult* result);
93extern void zfLnxStatisticsNotify(zdev_t* dev, struct zsStastics* result);
94extern void zfLnxMicFailureNotify(zdev_t* dev, u16_t* addr, u16_t status);
95extern void zfLnxApMicFailureNotify(zdev_t* dev, u8_t* addr, zbuf_t* buf);
96extern void zfLnxIbssPartnerNotify(zdev_t* dev, u16_t status, struct zsPartnerNotifyEvent *event);
97extern void zfLnxMacAddressNotify(zdev_t* dev, u8_t* addr);
98extern void zfLnxSendCompleteIndication(zdev_t* dev, zbuf_t* buf);
99extern void zfLnxRecvEth(zdev_t* dev, zbuf_t* buf, u16_t port);
100extern void zfLnxRestoreBufData(zdev_t* dev, zbuf_t* buf);
101#ifdef ZM_ENABLE_CENC
102extern u16_t zfLnxCencAsocNotify(zdev_t* dev, u16_t* macAddr, u8_t* body, u16_t bodySize, u16_t port);
103#endif //ZM_ENABLE_CENC
104extern void zfLnxWatchDogNotify(zdev_t* dev);
105extern void zfLnxRecv80211(zdev_t* dev, zbuf_t* buf, struct zsAdditionInfo* addInfo);
106extern 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		 116extern int usbdrv_ioctl_setessid(struct net_device *dev, struct iw_point *erq);
117extern int usbdrv_ioctl_setrts(struct net_device *dev, struct iw_param *rrq);
118/* Wireless Extension Handler functions */
119extern int usbdrvwext_giwname(struct net_device *dev, struct iw_request_info *info,
120 union iwreq_data *wrq, char *extra);
121extern int usbdrvwext_siwfreq(struct net_device *dev, struct iw_request_info *info,
122 struct iw_freq *freq, char *extra);
123extern int usbdrvwext_giwfreq(struct net_device *dev, struct iw_request_info *info,
124 struct iw_freq *freq, char *extra);
125extern int usbdrvwext_siwmode(struct net_device *dev, struct iw_request_info *info,
126 union iwreq_data *wrq, char *extra);
127extern int usbdrvwext_giwmode(struct net_device *dev, struct iw_request_info *info,
128 __u32 *mode, char *extra);
129extern int usbdrvwext_siwsens(struct net_device *dev, struct iw_request_info *info,
130 struct iw_param *sens, char *extra);
131extern int usbdrvwext_giwsens(struct net_device *dev, struct iw_request_info *info,
132 struct iw_param *sens, char *extra);
133extern int usbdrvwext_giwrange(struct net_device *dev, struct iw_request_info *info,
134 struct iw_point *data, char *extra);
135extern int usbdrvwext_siwap(struct net_device *dev, struct iw_request_info *info,
136 struct sockaddr *MacAddr, char *extra);
137extern int usbdrvwext_giwap(struct net_device *dev, struct iw_request_info *info,
138 struct sockaddr *MacAddr, char *extra);
139extern int usbdrvwext_iwaplist(struct net_device *dev, struct iw_request_info *info,
140 struct iw_point *data, char *extra);
141extern int usbdrvwext_siwscan(struct net_device *dev, struct iw_request_info *info,
142 struct iw_point *data, char *extra);
143extern int usbdrvwext_giwscan(struct net_device *dev, struct iw_request_info *info,
144 struct iw_point *data, char *extra);
145extern int usbdrvwext_siwessid(struct net_device *dev, struct iw_request_info *info,
146 struct iw_point *essid, char *extra);
147extern int usbdrvwext_giwessid(struct net_device *dev, struct iw_request_info *info,
148 struct iw_point *essid, char *extra);
149extern int usbdrvwext_siwnickn(struct net_device *dev, struct iw_request_info *info,
150 struct iw_point *data, char *nickname);
151extern int usbdrvwext_giwnickn(struct net_device *dev, struct iw_request_info *info,
152 struct iw_point *data, char *nickname);
153extern int usbdrvwext_siwrate(struct net_device *dev, struct iw_request_info *info,
154 struct iw_param *frq, char *extra);
155extern int usbdrvwext_giwrate(struct net_device *dev, struct iw_request_info *info,
156 struct iw_param *frq, char *extra);
157extern int usbdrvwext_siwrts(struct net_device *dev, struct iw_request_info *info,
158 struct iw_param *rts, char *extra);
159extern int usbdrvwext_giwrts(struct net_device *dev, struct iw_request_info *info,
160 struct iw_param *rts, char *extra);
161extern int usbdrvwext_siwfrag(struct net_device *dev, struct iw_request_info *info,
162 struct iw_param *frag, char *extra);
163extern int usbdrvwext_giwfrag(struct net_device *dev, struct iw_request_info *info,
164 struct iw_param *frag, char *extra);
165extern int usbdrvwext_siwtxpow(struct net_device *dev, struct iw_request_info *info,
166 struct iw_param *rrq, char *extra);
167extern int usbdrvwext_giwtxpow(struct net_device *dev, struct iw_request_info *info,
168 struct iw_param *rrq, char *extra);
169extern int usbdrvwext_siwretry(struct net_device *dev, struct iw_request_info *info,
170 struct iw_param *rrq, char *extra);
171extern int usbdrvwext_giwretry(struct net_device *dev, struct iw_request_info *info,
172 struct iw_param *rrq, char *extra);
173extern int usbdrvwext_siwencode(struct net_device *dev, struct iw_request_info *info,
174 struct iw_point *erq, char *key);
175extern int usbdrvwext_giwencode(struct net_device *dev, struct iw_request_info *info,
176 struct iw_point *erq, char *key);
177extern int usbdrvwext_siwpower(struct net_device *dev, struct iw_request_info *info,
178 struct iw_param *frq, char *extra);
179extern int usbdrvwext_giwpower(struct net_device *dev, struct iw_request_info *info,
180 struct iw_param *frq, char *extra);
181extern int usbdrv_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
182/*
183 * Structures to export the Wireless Handlers
184 */
185
186struct 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		 202static 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
252static 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 276static 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 */
290struct zsVapStruct vap[ZM_VAP_PORT_NUMBER];
291void 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 304irqreturn_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
331int 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;
454exit:
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
478struct 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
507int 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
522exit:
523 read_unlock(&(macp->isolate_lock));
524 return rc;
525}
526
527
528
529void
530usbdrv_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
548int 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
557void zfLnxUnlinkAllUrbs(struct usbdrv_private *macp);
558
559int usbdrv_close(struct net_device *dev)
560{
561extern 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
614int 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
657void 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 */
677void 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
696void 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
711void 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
720void 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
731int 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
752int 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
775int 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		 814static 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		 829int 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
880int 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
910extern int usbdrv_open(struct net_device *dev);
911extern int usbdrv_close(struct net_device *dev);
912extern int usbdrv_xmit_frame(struct sk_buff *skb, struct net_device *dev);
913extern int usbdrv_xmit_frame(struct sk_buff *skb, struct net_device *dev);
914extern int usbdrv_change_mtu(struct net_device *dev, int new_mtu);
915extern void usbdrv_set_multi(struct net_device *dev);
916extern int usbdrv_set_mac(struct net_device *dev, void *addr);
917extern struct net_device_stats * usbdrv_get_stats(struct net_device *dev);
918extern int usbdrv_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
919extern UsbTxQ_t *zfLnxGetUsbTxBuffer(struct net_device *dev);
920
921int 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
1011void 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
1038void 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		 1066static 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		 1078u8_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
1123u8_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}
kernel source for telekom puls (alcatel/mediatek)