?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: winbond: mac80211 - unify config_interface and bss_info_changed
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / winbond / wbusb.c
blob745279c528a24143a7c0a6b312cd45e6f37b432b
1 /*
2 * Copyright 2008 Pavel Machek <pavel@suse.cz>
3 *
4 * Distribute under GPLv2.
5 *
6 * The original driver was written by:
7 * Jeff Lee <YY_Lee@issc.com.tw>
8 *
9 * and was adapted to the 2.6 kernel by:
10 * Costantino Leandro (Rxart Desktop) <le_costantino@pixartargentina.com.ar>
11 */
12 #include <net/mac80211.h>
13 #include <linux/usb.h>
14
15 #include "core.h"
16 #include "mds_f.h"
17 #include "mlmetxrx_f.h"
18 #include "mto.h"
19 #include "wbhal_f.h"
20 #include "wblinux_f.h"
21
22 MODULE_DESCRIPTION("IS89C35 802.11bg WLAN USB Driver");
23 MODULE_LICENSE("GPL");
24 MODULE_VERSION("0.1");
25
26 static struct usb_device_id wb35_table[] __devinitdata = {
27 { USB_DEVICE(0x0416, 0x0035) },
28 { USB_DEVICE(0x18E8, 0x6201) },
29 { USB_DEVICE(0x18E8, 0x6206) },
30 { USB_DEVICE(0x18E8, 0x6217) },
31 { USB_DEVICE(0x18E8, 0x6230) },
32 { USB_DEVICE(0x18E8, 0x6233) },
33 { USB_DEVICE(0x1131, 0x2035) },
34 { 0, }
35 };
36
37 MODULE_DEVICE_TABLE(usb, wb35_table);
38
39 static struct ieee80211_rate wbsoft_rates[] = {
40 { .bitrate = 10, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
41 };
42
43 static struct ieee80211_channel wbsoft_channels[] = {
44 { .center_freq = 2412 },
45 };
46
47 static struct ieee80211_supported_band wbsoft_band_2GHz = {
48 .channels = wbsoft_channels,
49 .n_channels = ARRAY_SIZE(wbsoft_channels),
50 .bitrates = wbsoft_rates,
51 .n_bitrates = ARRAY_SIZE(wbsoft_rates),
52 };
53
54 static int wbsoft_add_interface(struct ieee80211_hw *dev,
55 struct ieee80211_if_init_conf *conf)
56 {
57 printk("wbsoft_add interface called\n");
58 return 0;
59 }
60
61 static void wbsoft_remove_interface(struct ieee80211_hw *dev,
62 struct ieee80211_if_init_conf *conf)
63 {
64 printk("wbsoft_remove interface called\n");
65 }
66
67 static void wbsoft_stop(struct ieee80211_hw *hw)
68 {
69 printk(KERN_INFO "%s called\n", __func__);
70 }
71
72 static int wbsoft_get_stats(struct ieee80211_hw *hw,
73 struct ieee80211_low_level_stats *stats)
74 {
75 printk(KERN_INFO "%s called\n", __func__);
76 return 0;
77 }
78
79 static int wbsoft_get_tx_stats(struct ieee80211_hw *hw,
80 struct ieee80211_tx_queue_stats *stats)
81 {
82 printk(KERN_INFO "%s called\n", __func__);
83 return 0;
84 }
85
86 static void wbsoft_configure_filter(struct ieee80211_hw *dev,
87 unsigned int changed_flags,
88 unsigned int *total_flags,
89 int mc_count, struct dev_mc_list *mclist)
90 {
91 unsigned int new_flags;
92
93 new_flags = 0;
94
95 if (*total_flags & FIF_PROMISC_IN_BSS)
96 new_flags |= FIF_PROMISC_IN_BSS;
97 else if ((*total_flags & FIF_ALLMULTI) || (mc_count > 32))
98 new_flags |= FIF_ALLMULTI;
99
100 dev->flags &= ~IEEE80211_HW_RX_INCLUDES_FCS;
101
102 *total_flags = new_flags;
103 }
104
105 static int wbsoft_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
106 {
107 struct wbsoft_priv *priv = dev->priv;
108
109 MLMESendFrame(priv, skb->data, skb->len, FRAME_TYPE_802_11_MANAGEMENT);
110
111 return NETDEV_TX_OK;
112 }
113
114 static int wbsoft_start(struct ieee80211_hw *dev)
115 {
116 struct wbsoft_priv *priv = dev->priv;
117
118 priv->enabled = true;
119
120 return 0;
121 }
122
123 static void hal_set_radio_mode(struct hw_data *pHwData, unsigned char radio_off)
124 {
125 struct wb35_reg *reg = &pHwData->reg;
126
127 if (pHwData->SurpriseRemove)
128 return;
129
130 if (radio_off) //disable Baseband receive off
131 {
132 pHwData->CurrentRadioSw = 1; // off
133 reg->M24_MacControl &= 0xffffffbf;
134 } else {
135 pHwData->CurrentRadioSw = 0; // on
136 reg->M24_MacControl |= 0x00000040;
137 }
138 Wb35Reg_Write(pHwData, 0x0824, reg->M24_MacControl);
139 }
140
141 static void hal_set_beacon_period(struct hw_data *pHwData, u16 beacon_period)
142 {
143 u32 tmp;
144
145 if (pHwData->SurpriseRemove)
146 return;
147
148 pHwData->BeaconPeriod = beacon_period;
149 tmp = pHwData->BeaconPeriod << 16;
150 tmp |= pHwData->ProbeDelay;
151 Wb35Reg_Write(pHwData, 0x0848, tmp);
152 }
153
154 static void
155 hal_set_current_channel_ex(struct hw_data *pHwData, ChanInfo channel)
156 {
157 struct wb35_reg *reg = &pHwData->reg;
158
159 if (pHwData->SurpriseRemove)
160 return;
161
162 printk("Going to channel: %d/%d\n", channel.band, channel.ChanNo);
163
164 RFSynthesizer_SwitchingChannel(pHwData, channel); // Switch channel
165 pHwData->Channel = channel.ChanNo;
166 pHwData->band = channel.band;
167 #ifdef _PE_STATE_DUMP_
168 printk("Set channel is %d, band =%d\n", pHwData->Channel,
169 pHwData->band);
170 #endif
171 reg->M28_MacControl &= ~0xff; // Clean channel information field
172 reg->M28_MacControl |= channel.ChanNo;
173 Wb35Reg_WriteWithCallbackValue(pHwData, 0x0828, reg->M28_MacControl,
174 (s8 *) & channel, sizeof(ChanInfo));
175 }
176
177 static void hal_set_current_channel(struct hw_data *pHwData, ChanInfo channel)
178 {
179 hal_set_current_channel_ex(pHwData, channel);
180 }
181
182 static void hal_set_accept_broadcast(struct hw_data *pHwData, u8 enable)
183 {
184 struct wb35_reg *reg = &pHwData->reg;
185
186 if (pHwData->SurpriseRemove)
187 return;
188
189 reg->M00_MacControl &= ~0x02000000; //The HW value
190
191 if (enable)
192 reg->M00_MacControl |= 0x02000000; //The HW value
193
194 Wb35Reg_Write(pHwData, 0x0800, reg->M00_MacControl);
195 }
196
197 //for wep key error detection, we need to accept broadcast packets to be received temporary.
198 static void hal_set_accept_promiscuous(struct hw_data *pHwData, u8 enable)
199 {
200 struct wb35_reg *reg = &pHwData->reg;
201
202 if (pHwData->SurpriseRemove)
203 return;
204 if (enable) {
205 reg->M00_MacControl |= 0x00400000;
206 Wb35Reg_Write(pHwData, 0x0800, reg->M00_MacControl);
207 } else {
208 reg->M00_MacControl &= ~0x00400000;
209 Wb35Reg_Write(pHwData, 0x0800, reg->M00_MacControl);
210 }
211 }
212
213 static void hal_set_accept_multicast(struct hw_data *pHwData, u8 enable)
214 {
215 struct wb35_reg *reg = &pHwData->reg;
216
217 if (pHwData->SurpriseRemove)
218 return;
219
220 reg->M00_MacControl &= ~0x01000000; //The HW value
221 if (enable)
222 reg->M00_MacControl |= 0x01000000; //The HW value
223 Wb35Reg_Write(pHwData, 0x0800, reg->M00_MacControl);
224 }
225
226 static void hal_set_accept_beacon(struct hw_data *pHwData, u8 enable)
227 {
228 struct wb35_reg *reg = &pHwData->reg;
229
230 if (pHwData->SurpriseRemove)
231 return;
232
233 // 20040108 debug
234 if (!enable) //Due to SME and MLME are not suitable for 35
235 return;
236
237 reg->M00_MacControl &= ~0x04000000; //The HW value
238 if (enable)
239 reg->M00_MacControl |= 0x04000000; //The HW value
240
241 Wb35Reg_Write(pHwData, 0x0800, reg->M00_MacControl);
242 }
243
244 static int wbsoft_config(struct ieee80211_hw *dev, u32 changed)
245 {
246 struct wbsoft_priv *priv = dev->priv;
247 struct ieee80211_conf *conf = &dev->conf;
248 ChanInfo ch;
249
250 printk("wbsoft_config called\n");
251
252 /* Should use channel_num, or something, as that is already pre-translated */
253 ch.band = 1;
254 ch.ChanNo = 1;
255
256 hal_set_current_channel(&priv->sHwData, ch);
257 hal_set_beacon_period(&priv->sHwData, conf->beacon_int);
258 hal_set_accept_broadcast(&priv->sHwData, 1);
259 hal_set_accept_promiscuous(&priv->sHwData, 1);
260 hal_set_accept_multicast(&priv->sHwData, 1);
261 hal_set_accept_beacon(&priv->sHwData, 1);
262 hal_set_radio_mode(&priv->sHwData, 0);
263
264 return 0;
265 }
266
267 static u64 wbsoft_get_tsf(struct ieee80211_hw *dev)
268 {
269 printk("wbsoft_get_tsf called\n");
270 return 0;
271 }
272
273 static const struct ieee80211_ops wbsoft_ops = {
274 .tx = wbsoft_tx,
275 .start = wbsoft_start,
276 .stop = wbsoft_stop,
277 .add_interface = wbsoft_add_interface,
278 .remove_interface = wbsoft_remove_interface,
279 .config = wbsoft_config,
280 .configure_filter = wbsoft_configure_filter,
281 .get_stats = wbsoft_get_stats,
282 .get_tx_stats = wbsoft_get_tx_stats,
283 .get_tsf = wbsoft_get_tsf,
284 };
285
286 static void
287 hal_set_ethernet_address(struct hw_data *pHwData, u8 * current_address)
288 {
289 u32 ltmp[2];
290
291 if (pHwData->SurpriseRemove)
292 return;
293
294 memcpy(pHwData->CurrentMacAddress, current_address, ETH_ALEN);
295
296 ltmp[0] = cpu_to_le32(*(u32 *) pHwData->CurrentMacAddress);
297 ltmp[1] =
298 cpu_to_le32(*(u32 *) (pHwData->CurrentMacAddress + 4)) & 0xffff;
299
300 Wb35Reg_BurstWrite(pHwData, 0x03e8, ltmp, 2, AUTO_INCREMENT);
301 }
302
303 static void
304 hal_get_permanent_address(struct hw_data *pHwData, u8 * pethernet_address)
305 {
306 if (pHwData->SurpriseRemove)
307 return;
308
309 memcpy(pethernet_address, pHwData->PermanentMacAddress, 6);
310 }
311
312 static void hal_stop(struct hw_data *pHwData)
313 {
314 struct wb35_reg *reg = &pHwData->reg;
315
316 pHwData->Wb35Rx.rx_halt = 1;
317 Wb35Rx_stop(pHwData);
318
319 pHwData->Wb35Tx.tx_halt = 1;
320 Wb35Tx_stop(pHwData);
321
322 reg->D00_DmaControl &= ~0xc0000000; //Tx Off, Rx Off
323 Wb35Reg_Write(pHwData, 0x0400, reg->D00_DmaControl);
324 }
325
326 static unsigned char hal_idle(struct hw_data *pHwData)
327 {
328 struct wb35_reg *reg = &pHwData->reg;
329 struct wb_usb *pWbUsb = &pHwData->WbUsb;
330
331 if (!pHwData->SurpriseRemove
332 && (pWbUsb->DetectCount || reg->EP0vm_state != VM_STOP))
333 return false;
334
335 return true;
336 }
337
338 u8 hal_get_antenna_number(struct hw_data *pHwData)
339 {
340 struct wb35_reg *reg = &pHwData->reg;
341
342 if ((reg->BB2C & BIT(11)) == 0)
343 return 0;
344 else
345 return 1;
346 }
347
348 /* 0 : radio on; 1: radio off */
349 static u8 hal_get_hw_radio_off(struct hw_data * pHwData)
350 {
351 struct wb35_reg *reg = &pHwData->reg;
352
353 if (pHwData->SurpriseRemove)
354 return 1;
355
356 //read the bit16 of register U1B0
357 Wb35Reg_Read(pHwData, 0x3b0, &reg->U1B0);
358 if ((reg->U1B0 & 0x00010000)) {
359 pHwData->CurrentRadioHw = 1;
360 return 1;
361 } else {
362 pHwData->CurrentRadioHw = 0;
363 return 0;
364 }
365 }
366
367 static u8 LED_GRAY[20] = {
368 0, 3, 4, 6, 8, 10, 11, 12, 13, 14, 15, 14, 13, 12, 11, 10, 8, 6, 4, 2
369 };
370
371 static u8 LED_GRAY2[30] = {
372 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
373 0, 15, 14, 13, 12, 11, 10, 9, 8
374 };
375
376 static void hal_led_control(unsigned long data)
377 {
378 struct wbsoft_priv *adapter = (struct wbsoft_priv *)data;
379 struct hw_data *pHwData = &adapter->sHwData;
380 struct wb35_reg *reg = &pHwData->reg;
381 u32 LEDSet = (pHwData->SoftwareSet & HAL_LED_SET_MASK) >> HAL_LED_SET_SHIFT;
382 u32 TimeInterval = 500, ltmp, ltmp2;
383 ltmp = 0;
384
385 if (pHwData->SurpriseRemove)
386 return;
387
388 if (pHwData->LED_control) {
389 ltmp2 = pHwData->LED_control & 0xff;
390 if (ltmp2 == 5) // 5 is WPS mode
391 {
392 TimeInterval = 100;
393 ltmp2 = (pHwData->LED_control >> 8) & 0xff;
394 switch (ltmp2) {
395 case 1: // [0.2 On][0.1 Off]...
396 pHwData->LED_Blinking %= 3;
397 ltmp = 0x1010; // Led 1 & 0 Green and Red
398 if (pHwData->LED_Blinking == 2) // Turn off
399 ltmp = 0;
400 break;
401 case 2: // [0.1 On][0.1 Off]...
402 pHwData->LED_Blinking %= 2;
403 ltmp = 0x0010; // Led 0 red color
404 if (pHwData->LED_Blinking) // Turn off
405 ltmp = 0;
406 break;
407 case 3: // [0.1 On][0.1 Off][0.1 On][0.1 Off][0.1 On][0.1 Off][0.1 On][0.1 Off][0.1 On][0.1 Off][0.5 Off]...
408 pHwData->LED_Blinking %= 15;
409 ltmp = 0x0010; // Led 0 red color
410 if ((pHwData->LED_Blinking >= 9) || (pHwData->LED_Blinking % 2)) // Turn off 0.6 sec
411 ltmp = 0;
412 break;
413 case 4: // [300 On][ off ]
414 ltmp = 0x1000; // Led 1 Green color
415 if (pHwData->LED_Blinking >= 3000)
416 ltmp = 0; // led maybe on after 300sec * 32bit counter overlap.
417 break;
418 }
419 pHwData->LED_Blinking++;
420
421 reg->U1BC_LEDConfigure = ltmp;
422 if (LEDSet != 7) // Only 111 mode has 2 LEDs on PCB.
423 {
424 reg->U1BC_LEDConfigure |= (ltmp & 0xff) << 8; // Copy LED result to each LED control register
425 reg->U1BC_LEDConfigure |= (ltmp & 0xff00) >> 8;
426 }
427 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure);
428 }
429 } else if (pHwData->CurrentRadioSw || pHwData->CurrentRadioHw) // If radio off
430 {
431 if (reg->U1BC_LEDConfigure & 0x1010) {
432 reg->U1BC_LEDConfigure &= ~0x1010;
433 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure);
434 }
435 } else {
436 switch (LEDSet) {
437 case 4: // [100] Only 1 Led be placed on PCB and use pin 21 of IC. Use LED_0 for showing
438 if (!pHwData->LED_LinkOn) // Blink only if not Link On
439 {
440 // Blinking if scanning is on progress
441 if (pHwData->LED_Scanning) {
442 if (pHwData->LED_Blinking == 0) {
443 reg->U1BC_LEDConfigure |= 0x10;
444 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_0 On
445 pHwData->LED_Blinking = 1;
446 TimeInterval = 300;
447 } else {
448 reg->U1BC_LEDConfigure &= ~0x10;
449 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_0 Off
450 pHwData->LED_Blinking = 0;
451 TimeInterval = 300;
452 }
453 } else {
454 //Turn Off LED_0
455 if (reg->U1BC_LEDConfigure & 0x10) {
456 reg->U1BC_LEDConfigure &= ~0x10;
457 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_0 Off
458 }
459 }
460 } else {
461 // Turn On LED_0
462 if ((reg->U1BC_LEDConfigure & 0x10) == 0) {
463 reg->U1BC_LEDConfigure |= 0x10;
464 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_0 Off
465 }
466 }
467 break;
468
469 case 6: // [110] Only 1 Led be placed on PCB and use pin 21 of IC. Use LED_0 for showing
470 if (!pHwData->LED_LinkOn) // Blink only if not Link On
471 {
472 // Blinking if scanning is on progress
473 if (pHwData->LED_Scanning) {
474 if (pHwData->LED_Blinking == 0) {
475 reg->U1BC_LEDConfigure &= ~0xf;
476 reg->U1BC_LEDConfigure |= 0x10;
477 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_0 On
478 pHwData->LED_Blinking = 1;
479 TimeInterval = 300;
480 } else {
481 reg->U1BC_LEDConfigure &= ~0x1f;
482 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_0 Off
483 pHwData->LED_Blinking = 0;
484 TimeInterval = 300;
485 }
486 } else {
487 // 20060901 Gray blinking if in disconnect state and not scanning
488 ltmp = reg->U1BC_LEDConfigure;
489 reg->U1BC_LEDConfigure &= ~0x1f;
490 if (LED_GRAY2[(pHwData->LED_Blinking % 30)]) {
491 reg->U1BC_LEDConfigure |= 0x10;
492 reg->U1BC_LEDConfigure |=
493 LED_GRAY2[(pHwData->LED_Blinking % 30)];
494 }
495 pHwData->LED_Blinking++;
496 if (reg->U1BC_LEDConfigure != ltmp)
497 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_0 Off
498 TimeInterval = 100;
499 }
500 } else {
501 // Turn On LED_0
502 if ((reg->U1BC_LEDConfigure & 0x10) == 0) {
503 reg->U1BC_LEDConfigure |= 0x10;
504 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_0 Off
505 }
506 }
507 break;
508
509 case 5: // [101] Only 1 Led be placed on PCB and use LED_1 for showing
510 if (!pHwData->LED_LinkOn) // Blink only if not Link On
511 {
512 // Blinking if scanning is on progress
513 if (pHwData->LED_Scanning) {
514 if (pHwData->LED_Blinking == 0) {
515 reg->U1BC_LEDConfigure |=
516 0x1000;
517 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_1 On
518 pHwData->LED_Blinking = 1;
519 TimeInterval = 300;
520 } else {
521 reg->U1BC_LEDConfigure &=
522 ~0x1000;
523 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_1 Off
524 pHwData->LED_Blinking = 0;
525 TimeInterval = 300;
526 }
527 } else {
528 //Turn Off LED_1
529 if (reg->U1BC_LEDConfigure & 0x1000) {
530 reg->U1BC_LEDConfigure &=
531 ~0x1000;
532 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_1 Off
533 }
534 }
535 } else {
536 // Is transmitting/receiving ??
537 if ((adapter->RxByteCount !=
538 pHwData->RxByteCountLast)
539 || (adapter->TxByteCount !=
540 pHwData->TxByteCountLast)) {
541 if ((reg->U1BC_LEDConfigure & 0x3000) !=
542 0x3000) {
543 reg->U1BC_LEDConfigure |=
544 0x3000;
545 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_1 On
546 }
547 // Update variable
548 pHwData->RxByteCountLast =
549 adapter->RxByteCount;
550 pHwData->TxByteCountLast =
551 adapter->TxByteCount;
552 TimeInterval = 200;
553 } else {
554 // Turn On LED_1 and blinking if transmitting/receiving
555 if ((reg->U1BC_LEDConfigure & 0x3000) !=
556 0x1000) {
557 reg->U1BC_LEDConfigure &=
558 ~0x3000;
559 reg->U1BC_LEDConfigure |=
560 0x1000;
561 Wb35Reg_Write(pHwData, 0x03bc, reg->U1BC_LEDConfigure); // LED_1 On
562 }
563 }
564 }
565 break;
566
567 default: // Default setting. 2 LED be placed on PCB. LED_0: Link On LED_1 Active
568 if ((reg->U1BC_LEDConfigure & 0x3000) != 0x3000) {
569 reg->U1BC_LEDConfigure |= 0x3000; // LED_1 is always on and event enable
570 Wb35Reg_Write(pHwData, 0x03bc,
571 reg->U1BC_LEDConfigure);
572 }
573
574 if (pHwData->LED_Blinking) {
575 // Gray blinking
576 reg->U1BC_LEDConfigure &= ~0x0f;
577 reg->U1BC_LEDConfigure |= 0x10;
578 reg->U1BC_LEDConfigure |=
579 LED_GRAY[(pHwData->LED_Blinking - 1) % 20];
580 Wb35Reg_Write(pHwData, 0x03bc,
581 reg->U1BC_LEDConfigure);
582
583 pHwData->LED_Blinking += 2;
584 if (pHwData->LED_Blinking < 40)
585 TimeInterval = 100;
586 else {
587 pHwData->LED_Blinking = 0; // Stop blinking
588 reg->U1BC_LEDConfigure &= ~0x0f;
589 Wb35Reg_Write(pHwData, 0x03bc,
590 reg->U1BC_LEDConfigure);
591 }
592 break;
593 }
594
595 if (pHwData->LED_LinkOn) {
596 if (!(reg->U1BC_LEDConfigure & 0x10)) // Check the LED_0
597 {
598 //Try to turn ON LED_0 after gray blinking
599 reg->U1BC_LEDConfigure |= 0x10;
600 pHwData->LED_Blinking = 1; //Start blinking
601 TimeInterval = 50;
602 }
603 } else {
604 if (reg->U1BC_LEDConfigure & 0x10) // Check the LED_0
605 {
606 reg->U1BC_LEDConfigure &= ~0x10;
607 Wb35Reg_Write(pHwData, 0x03bc,
608 reg->U1BC_LEDConfigure);
609 }
610 }
611 break;
612 }
613
614 //20060828.1 Active send null packet to avoid AP disconnect
615 if (pHwData->LED_LinkOn) {
616 pHwData->NullPacketCount += TimeInterval;
617 if (pHwData->NullPacketCount >=
618 DEFAULT_NULL_PACKET_COUNT) {
619 pHwData->NullPacketCount = 0;
620 }
621 }
622 }
623
624 pHwData->time_count += TimeInterval;
625 Wb35Tx_CurrentTime(adapter, pHwData->time_count); // 20060928 add
626 pHwData->LEDTimer.expires = jiffies + msecs_to_jiffies(TimeInterval);
627 add_timer(&pHwData->LEDTimer);
628 }
629
630 static int hal_init_hardware(struct ieee80211_hw *hw)
631 {
632 struct wbsoft_priv *priv = hw->priv;
633 struct hw_data *pHwData = &priv->sHwData;
634 u16 SoftwareSet;
635
636 pHwData->MaxReceiveLifeTime = DEFAULT_MSDU_LIFE_TIME;
637 pHwData->FragmentThreshold = DEFAULT_FRAGMENT_THRESHOLD;
638
639 if (!Wb35Reg_initial(pHwData))
640 goto error_reg_destroy;
641
642 if (!Wb35Tx_initial(pHwData))
643 goto error_tx_destroy;
644
645 if (!Wb35Rx_initial(pHwData))
646 goto error_rx_destroy;
647
648 init_timer(&pHwData->LEDTimer);
649 pHwData->LEDTimer.function = hal_led_control;
650 pHwData->LEDTimer.data = (unsigned long)priv;
651 pHwData->LEDTimer.expires = jiffies + msecs_to_jiffies(1000);
652 add_timer(&pHwData->LEDTimer);
653
654 SoftwareSet = hal_software_set(pHwData);
655
656 #ifdef Vendor2
657 // Try to make sure the EEPROM contain
658 SoftwareSet >>= 8;
659 if (SoftwareSet != 0x82)
660 return false;
661 #endif
662
663 Wb35Rx_start(hw);
664 Wb35Tx_EP2VM_start(priv);
665
666 return 0;
667
668 error_rx_destroy:
669 Wb35Rx_destroy(pHwData);
670 error_tx_destroy:
671 Wb35Tx_destroy(pHwData);
672 error_reg_destroy:
673 Wb35Reg_destroy(pHwData);
674
675 pHwData->SurpriseRemove = 1;
676 return -EINVAL;
677 }
678
679 static int wb35_hw_init(struct ieee80211_hw *hw)
680 {
681 struct wbsoft_priv *priv = hw->priv;
682 struct hw_data *pHwData = &priv->sHwData;
683 u8 EEPROM_region;
684 u8 HwRadioOff;
685 u8 *pMacAddr2;
686 u8 *pMacAddr;
687 int err;
688
689 pHwData->phy_type = RF_DECIDE_BY_INF;
690
691 priv->Mds.TxRTSThreshold = DEFAULT_RTSThreshold;
692 priv->Mds.TxFragmentThreshold = DEFAULT_FRAGMENT_THRESHOLD;
693
694 priv->sLocalPara.region_INF = REGION_AUTO;
695 priv->sLocalPara.TxRateMode = RATE_AUTO;
696 priv->sLocalPara.bMacOperationMode = MODE_802_11_BG;
697 priv->sLocalPara.MTUsize = MAX_ETHERNET_PACKET_SIZE;
698 priv->sLocalPara.bPreambleMode = AUTO_MODE;
699 priv->sLocalPara.bWepKeyError = false;
700 priv->sLocalPara.bToSelfPacketReceived = false;
701 priv->sLocalPara.WepKeyDetectTimerCount = 2 * 100; /* 2 seconds */
702
703 priv->sLocalPara.RadioOffStatus.boSwRadioOff = false;
704
705 err = hal_init_hardware(hw);
706 if (err)
707 goto error;
708
709 EEPROM_region = hal_get_region_from_EEPROM(pHwData);
710 if (EEPROM_region != REGION_AUTO)
711 priv->sLocalPara.region = EEPROM_region;
712 else {
713 if (priv->sLocalPara.region_INF != REGION_AUTO)
714 priv->sLocalPara.region = priv->sLocalPara.region_INF;
715 else
716 priv->sLocalPara.region = REGION_USA; /* default setting */
717 }
718
719 // Get Software setting flag from hal
720 priv->sLocalPara.boAntennaDiversity = false;
721 if (hal_software_set(pHwData) & 0x00000001)
722 priv->sLocalPara.boAntennaDiversity = true;
723
724 Mds_initial(priv);
725
726 /*
727 * If no user-defined address in the registry, use the addresss
728 * "burned" on the NIC instead.
729 */
730 pMacAddr = priv->sLocalPara.ThisMacAddress;
731 pMacAddr2 = priv->sLocalPara.PermanentAddress;
732
733 /* Reading ethernet address from EEPROM */
734 hal_get_permanent_address(pHwData, priv->sLocalPara.PermanentAddress);
735 if (memcmp(pMacAddr, "\x00\x00\x00\x00\x00\x00", MAC_ADDR_LENGTH) == 0)
736 memcpy(pMacAddr, pMacAddr2, MAC_ADDR_LENGTH);
737 else {
738 /* Set the user define MAC address */
739 hal_set_ethernet_address(pHwData,
740 priv->sLocalPara.ThisMacAddress);
741 }
742
743 priv->sLocalPara.bAntennaNo = hal_get_antenna_number(pHwData);
744 #ifdef _PE_STATE_DUMP_
745 printk("Driver init, antenna no = %d\n", psLOCAL->bAntennaNo);
746 #endif
747 hal_get_hw_radio_off(pHwData);
748
749 /* Waiting for HAL setting OK */
750 while (!hal_idle(pHwData))
751 msleep(10);
752
753 MTO_Init(priv);
754
755 HwRadioOff = hal_get_hw_radio_off(pHwData);
756 priv->sLocalPara.RadioOffStatus.boHwRadioOff = !!HwRadioOff;
757
758 hal_set_radio_mode(pHwData,
759 (unsigned char)(priv->sLocalPara.RadioOffStatus.
760 boSwRadioOff
761 || priv->sLocalPara.RadioOffStatus.
762 boHwRadioOff));
763
764 /* Notify hal that the driver is ready now. */
765 hal_driver_init_OK(pHwData) = 1;
766
767 error:
768 return err;
769 }
770
771 static int wb35_probe(struct usb_interface *intf,
772 const struct usb_device_id *id_table)
773 {
774 struct usb_device *udev = interface_to_usbdev(intf);
775 struct usb_endpoint_descriptor *endpoint;
776 struct usb_host_interface *interface;
777 struct ieee80211_hw *dev;
778 struct wbsoft_priv *priv;
779 struct wb_usb *pWbUsb;
780 int nr, err;
781 u32 ltmp;
782
783 usb_get_dev(udev);
784
785 /* Check the device if it already be opened */
786 nr = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
787 0x01,
788 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
789 0x0, 0x400, &ltmp, 4, HZ * 100);
790 if (nr < 0) {
791 err = nr;
792 goto error;
793 }
794
795 /* Is already initialized? */
796 ltmp = cpu_to_le32(ltmp);
797 if (ltmp) {
798 err = -EBUSY;
799 goto error;
800 }
801
802 dev = ieee80211_alloc_hw(sizeof(*priv), &wbsoft_ops);
803 if (!dev) {
804 err = -ENOMEM;
805 goto error;
806 }
807
808 priv = dev->priv;
809
810 spin_lock_init(&priv->SpinLock);
811
812 pWbUsb = &priv->sHwData.WbUsb;
813 pWbUsb->udev = udev;
814
815 interface = intf->cur_altsetting;
816 endpoint = &interface->endpoint[0].desc;
817
818 if (endpoint[2].wMaxPacketSize == 512) {
819 printk("[w35und] Working on USB 2.0\n");
820 pWbUsb->IsUsb20 = 1;
821 }
822
823 err = wb35_hw_init(dev);
824 if (err)
825 goto error_free_hw;
826
827 SET_IEEE80211_DEV(dev, &udev->dev);
828 {
829 struct hw_data *pHwData = &priv->sHwData;
830 unsigned char dev_addr[MAX_ADDR_LEN];
831 hal_get_permanent_address(pHwData, dev_addr);
832 SET_IEEE80211_PERM_ADDR(dev, dev_addr);
833 }
834
835 dev->extra_tx_headroom = 12; /* FIXME */
836 dev->flags = IEEE80211_HW_SIGNAL_UNSPEC;
837 dev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
838
839 dev->channel_change_time = 1000;
840 dev->max_signal = 100;
841 dev->queues = 1;
842
843 dev->wiphy->bands[IEEE80211_BAND_2GHZ] = &wbsoft_band_2GHz;
844
845 err = ieee80211_register_hw(dev);
846 if (err)
847 goto error_free_hw;
848
849 usb_set_intfdata(intf, dev);
850
851 return 0;
852
853 error_free_hw:
854 ieee80211_free_hw(dev);
855 error:
856 usb_put_dev(udev);
857 return err;
858 }
859
860 static void hal_halt(struct hw_data *pHwData)
861 {
862 del_timer_sync(&pHwData->LEDTimer);
863 /* XXX: Wait for Timer DPC exit. */
864 msleep(100);
865 Wb35Rx_destroy(pHwData);
866 Wb35Tx_destroy(pHwData);
867 Wb35Reg_destroy(pHwData);
868 }
869
870 static void wb35_hw_halt(struct wbsoft_priv *adapter)
871 {
872 Mds_Destroy(adapter);
873
874 /* Turn off Rx and Tx hardware ability */
875 hal_stop(&adapter->sHwData);
876 #ifdef _PE_USB_INI_DUMP_
877 printk("[w35und] Hal_stop O.K.\n");
878 #endif
879 /* Waiting Irp completed */
880 msleep(100);
881
882 hal_halt(&adapter->sHwData);
883 }
884
885 static void wb35_disconnect(struct usb_interface *intf)
886 {
887 struct ieee80211_hw *hw = usb_get_intfdata(intf);
888 struct wbsoft_priv *priv = hw->priv;
889
890 wb35_hw_halt(priv);
891
892 ieee80211_stop_queues(hw);
893 ieee80211_unregister_hw(hw);
894 ieee80211_free_hw(hw);
895
896 usb_set_intfdata(intf, NULL);
897 usb_put_dev(interface_to_usbdev(intf));
898 }
899
900 static struct usb_driver wb35_driver = {
901 .name = "w35und",
902 .id_table = wb35_table,
903 .probe = wb35_probe,
904 .disconnect = wb35_disconnect,
905 };
906
907 static int __init wb35_init(void)
908 {
909 return usb_register(&wb35_driver);
910 }
911
912 static void __exit wb35_exit(void)
913 {
914 usb_deregister(&wb35_driver);
915 }
916
917 module_init(wb35_init);
918 module_exit(wb35_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree