~ubuntu-branches/ubuntu/lucid/ndiswrapper/lucid : revision 4

1

/*

2

3

*

4

* This program is free software; you can redistribute it and/or modify

5

* it under the terms of the GNU General Public License as published by

30

#include <linux/if_arp.h>

31

#include <net/iw_handler.h>

32

#include <linux/rtnetlink.h>

33

#include <asm/scatterlist.h>

34

#include <asm/uaccess.h>

35

36

#include "wrapper.h"

37

#include "pe_linker.h"

38

37

#include "iw_ndis.h"

39

38

#include "loader.h"

40

39

40

41

#ifdef CONFIG_X86_64

42

#include "wrapper_exports.h"

43

#endif

44

41

45

#ifndef NDISWRAPPER_VERSION

42

#error You must run make from the toplevel directory

46

#error ndiswrapper version is not defined; run 'make' only from ndiswrapper \

47

directory or driver directory

43

48

#endif

44

49

45

/* Define this if you are developing and ndis_init_one crashes.

46

When using the old PCI-API a reboot is not needed when this

47

function crashes. A simple rmmod -f will do the trick and

48

you can try again.

49

*/

50

51

50

static char *if_name = "wlan%d";

52

51

int proc_uid, proc_gid;

53

52

static int hangcheck_interval;

53

int debug;

54

/* used to implement Windows spinlocks */

55

spinlock_t spinlock_kspin_lock;

54

56

55

57

NW_MODULE_PARM_STRING(if_name, 0400);

56

MODULE_PARM_DESC(if_name, "Network interface name or template (default: wlan%d)");

58

MODULE_PARM_DESC(if_name, "Network interface name or template "

59

"(default: wlan%d)");

57

60

NW_MODULE_PARM_INT(proc_uid, 0600);

58

MODULE_PARM_DESC(proc_uid, "The uid of the files created in /proc (default: 0).");

61

MODULE_PARM_DESC(proc_uid, "The uid of the files created in /proc "

62

"(default: 0).");

59

63

NW_MODULE_PARM_INT(proc_gid, 0600);

60

MODULE_PARM_DESC(proc_gid, "The gid of the files created in /proc (default: 0).");

64

MODULE_PARM_DESC(proc_gid, "The gid of the files created in /proc "

65

"(default: 0).");

61

66

NW_MODULE_PARM_INT(hangcheck_interval, 0600);

62

67

/* 0 - default value provided by NDIS driver,

63

68

* positive value - force hangcheck interval to that many seconds

64

69

* negative value - disable hangcheck

65

70

*/

66

MODULE_PARM_DESC(hangcheck_interval, "The interval, in seconds, for checking if driver is hung. (default: 0)");

67

68

extern struct list_head wrap_allocs;

69

extern struct wrap_spinlock wrap_allocs_lock;

70

extern struct wrap_spinlock dispatch_event_lock;

71

NW_MODULE_PARM_INT(debug, 0600);

72

MODULE_PARM_DESC(debug, "debug level");

73

74

MODULE_PARM_DESC(hangcheck_interval, "The interval, in seconds, for checking"

75

" if driver is hung. (default: 0)");

76

77

MODULE_AUTHOR("ndiswrapper team <ndiswrapper-general@lists.sourceforge.net>");

78

#ifdef MODULE_VERSION

79

MODULE_VERSION(NDISWRAPPER_VERSION);

80

#endif

72

81

static void ndis_set_rx_mode(struct net_device *dev);

82

static void set_multicast_list(struct net_device *dev,

83

struct ndis_handle *handle);

73

84

74

85

/*

75

86

* MiniportReset

76

87

*/

77

int miniport_reset(struct ndis_handle *handle)

88

NDIS_STATUS miniport_reset(struct ndis_handle *handle)

78

89

{

79

unsigned int res = 0;

80

90

KIRQL irql;

81

struct miniport_char *miniport = &handle->driver->miniport_char;

91

NDIS_STATUS res = 0;

92

struct miniport_char *miniport;

93

UINT cur_lookahead;

94

UINT max_lookahead;

82

95

83

TRACEENTER2("%s", "");

96

TRACEENTER2("handle: %p", handle);

84

97

85

98

if (handle->reset_status)

86

99

return NDIS_STATUS_PENDING;

87

100

88

101

if (down_interruptible(&handle->ndis_comm_mutex))

89

102

TRACEEXIT3(return NDIS_STATUS_FAILURE);

90

103

miniport = &handle->driver->miniport_char;

91

104

/* reset_status is used for two purposes: to check if windows

92

105

* driver needs us to reset filters etc (as per NDIS) and to

93

106

* check if another reset is in progress */

94

107

handle->reset_status = NDIS_STATUS_PENDING;

95

108

handle->ndis_comm_res = NDIS_STATUS_PENDING;

96

109

handle->ndis_comm_done = 0;

110

cur_lookahead = handle->cur_lookahead;

111

max_lookahead = handle->max_lookahead;

97

112

irql = raise_irql(DISPATCH_LEVEL);

98

res = miniport->reset(&handle->reset_status, handle->adapter_ctx);

113

res = LIN2WIN2(miniport->reset, &handle->reset_status,

114

handle->adapter_ctx);

99

115

lower_irql(irql);

100

116

101

117

DBGTRACE2("res = %08X, reset_status = %08X",

102

118

res, handle->reset_status);

103

119

if (res == NDIS_STATUS_PENDING) {

104

if (!wait_event_interruptible_timeout(

120

if (wait_event_interruptible_timeout(

105

121

handle->ndis_comm_wq,

106

122

(handle->ndis_comm_done == 1), 1*HZ))

107

handle->ndis_comm_res = NDIS_STATUS_FAILURE;

108

res = handle->ndis_comm_res;

123

res = handle->ndis_comm_res;

124

else

125

res = NDIS_STATUS_FAILURE;

109

126

DBGTRACE2("res = %08X, reset_status = %08X",

110

127

res, handle->reset_status);

111

128

}

114

131

res, handle->reset_status);

115

132

116

133

if (res == NDIS_STATUS_SUCCESS && handle->reset_status) {

117

handle->rx_packet = &NdisMIndicateReceivePacket;

118

handle->send_complete = &NdisMSendComplete;

119

handle->send_resource_avail = &NdisMSendResourcesAvailable;

120

handle->status = &NdisMIndicateStatus;

121

handle->status_complete = &NdisMIndicateStatusComplete;

122

handle->query_complete = &NdisMQueryInformationComplete;

123

handle->set_complete = &NdisMSetInformationComplete;

124

handle->reset_complete = &NdisMResetComplete;

134

/* NDIS says we should set lookahead size (?)

135

* functional address (?) or multicast filter */

136

handle->cur_lookahead = cur_lookahead;

137

handle->max_lookahead = max_lookahead;

125

138

ndis_set_rx_mode(handle->net_dev);

126

139

}

127

140

handle->reset_status = 0;

134

147

* Perform a sync query and deal with the possibility of an async operation.

135

148

* This function must be called from process context as it will sleep.

136

149

*/

137

int miniport_query_info_needed(struct ndis_handle *handle, unsigned int oid,

138

char *buf, unsigned int bufsize,

139

unsigned int *needed)

150

NDIS_STATUS miniport_query_info_needed(struct ndis_handle *handle,

151

ndis_oid oid, void *buf,

152

ULONG bufsize, ULONG *needed)

140

153

{

141

unsigned int res, written;

154

NDIS_STATUS res;

155

ULONG written;

156

struct miniport_char *miniport = &handle->driver->miniport_char;

142

157

KIRQL irql;

143

struct miniport_char *miniport = &handle->driver->miniport_char;

144

158

145

159

TRACEENTER3("query is at %p", miniport->query);

146

160

147

161

if (down_interruptible(&handle->ndis_comm_mutex))

148

162

TRACEEXIT3(return NDIS_STATUS_FAILURE);

149

150

163

handle->ndis_comm_done = 0;

151

164

irql = raise_irql(DISPATCH_LEVEL);

152

res = miniport->query(handle->adapter_ctx, oid, buf, bufsize,

153

&written, needed);

165

res = LIN2WIN6(miniport->query, handle->adapter_ctx, oid, buf, bufsize,

166

&written, needed);

154

167

lower_irql(irql);

155

168

156

169

DBGTRACE3("res = %08x", res);

157

170

if (res == NDIS_STATUS_PENDING) {

158

171

/* wait for NdisMQueryInformationComplete upto HZ */

159

if (!wait_event_interruptible_timeout(

172

if (wait_event_interruptible_timeout(

160

173

handle->ndis_comm_wq,

161

174

(handle->ndis_comm_done == 1), 1*HZ))

162

handle->ndis_comm_res = NDIS_STATUS_FAILURE;

163

res = handle->ndis_comm_res;

175

res = handle->ndis_comm_res;

176

else

177

res = NDIS_STATUS_FAILURE;

164

178

}

165

179

up(&handle->ndis_comm_mutex);

166

180

TRACEEXIT3(return res);

167

181

}

168

182

169

int miniport_query_info(struct ndis_handle *handle, unsigned int oid,

170

char *buf, unsigned int bufsize)

183

NDIS_STATUS miniport_query_info(struct ndis_handle *handle, ndis_oid oid,

184

void *buf, ULONG bufsize)

171

185

{

172

unsigned int res, needed;

186

NDIS_STATUS res;

187

ULONG needed;

173

188

174

res = miniport_query_info_needed(handle, oid, buf, bufsize,

175

&needed);

189

res = miniport_query_info_needed(handle, oid, buf, bufsize, &needed);

176

190

return res;

177

191

}

178

192

181

195

* Perform a sync setinfo and deal with the possibility of an async operation.

182

196

* This function must be called from process context as it will sleep.

183

197

*/

184

int miniport_set_info(struct ndis_handle *handle, unsigned int oid, char *buf,

185

unsigned int bufsize)

198

NDIS_STATUS miniport_set_info(struct ndis_handle *handle, ndis_oid oid,

199

void *buf, ULONG bufsize)

186

200

{

187

unsigned int res, written, needed;

201

NDIS_STATUS res;

202

ULONG written, needed;

203

struct miniport_char *miniport = &handle->driver->miniport_char;

188

204

KIRQL irql;

189

struct miniport_char *miniport = &handle->driver->miniport_char;

190

205

191

206

TRACEENTER3("setinfo is at %p", miniport->setinfo);

192

207

193

208

if (down_interruptible(&handle->ndis_comm_mutex))

194

209

TRACEEXIT3(return NDIS_STATUS_FAILURE);

195

196

210

handle->ndis_comm_done = 0;

197

211

irql = raise_irql(DISPATCH_LEVEL);

198

res = miniport->setinfo(handle->adapter_ctx, oid, buf, bufsize,

199

&written, &needed);

212

res = LIN2WIN6(miniport->setinfo, handle->adapter_ctx, oid, buf,

213

bufsize, &written, &needed);

214

lower_irql(irql);

200

215

DBGTRACE3("res = %08x", res);

201

lower_irql(irql);

202

216

203

217

if (res == NDIS_STATUS_PENDING) {

204

218

/* wait for NdisMSetInformationComplete upto HZ */

205

if (!wait_event_interruptible_timeout(

219

if (wait_event_interruptible_timeout(

206

220

handle->ndis_comm_wq,

207

221

(handle->ndis_comm_done == 1), 1*HZ))

208

handle->ndis_comm_res = NDIS_STATUS_FAILURE;

209

res = handle->ndis_comm_res;

222

res = handle->ndis_comm_res;

223

else

224

res = NDIS_STATUS_FAILURE;

210

225

}

211

226

up(&handle->ndis_comm_mutex);

212

227

if (needed)

216

231

}

217

232

218

233

/* Make a query that has an int as the result. */

219

int miniport_query_int(struct ndis_handle *handle, int oid, int *data)

234

NDIS_STATUS miniport_query_int(struct ndis_handle *handle, ndis_oid oid,

235

void *data)

220

236

{

221

unsigned int res;

237

NDIS_STATUS res;

222

238

223

res = miniport_query_info(handle, oid, (char*)data, sizeof(int));

239

res = miniport_query_info(handle, oid, data, sizeof(ULONG));

224

240

if (!res)

225

241

return 0;

226

*data = 0;

242

*((char *)data) = 0;

227

243

return res;

228

244

}

229

245

230

246

/* Set an int */

231

int miniport_set_int(struct ndis_handle *handle, int oid, int data)

232

{

233

return miniport_set_info(handle, oid, (char *)&data, sizeof(int));

234

}

235

236

#ifdef HAVE_ETHTOOL

237

static u32 ndis_get_link(struct net_device *dev)

238

{

239

struct ndis_handle *handle = dev->priv;

240

return handle->link_status;

241

}

242

243

static struct ethtool_ops ndis_ethtool_ops = {

244

.get_link = ndis_get_link,

245

};

246

#endif

247

NDIS_STATUS miniport_set_int(struct ndis_handle *handle, ndis_oid oid,

248

ULONG data)

249

{

250

return miniport_set_info(handle, oid, &data, sizeof(data));

251

}

247

252

248

253

/*

249

254

* MiniportInitialize

250

255

*/

251

int miniport_init(struct ndis_handle *handle)

256

NDIS_STATUS miniport_init(struct ndis_handle *handle)

252

257

{

253

NDIS_STATUS status;

254

UINT medium_index, res;

255

UINT medium_array[] = {NDIS_MEDIUM_802_3};

258

NDIS_STATUS status, res;

259

UINT medium_index;

260

UINT medium_array[] = {NdisMedium802_3};

256

261

struct miniport_char *miniport = &handle->driver->miniport_char;

257

262

258

263

TRACEENTER1("driver init routine is at %p", miniport->init);

260

265

ERROR("%s", "initialization function is not setup correctly");

261

266

return -EINVAL;

262

267

}

263

res = miniport->init(&status, &medium_index, medium_array,

264

sizeof(medium_array) / sizeof(medium_array[0]),

265

handle, handle);

268

res = LIN2WIN6(miniport->init, &status, &medium_index, medium_array,

269

sizeof(medium_array) / sizeof(medium_array[0]),

270

handle, handle);

266

271

if (res)

267

272

return res;

268

273

return 0;

276

281

struct miniport_char *miniport = &handle->driver->miniport_char;

277

282

TRACEENTER1("driver halt is at %p", miniport->halt);

278

283

279

miniport_set_int(handle, NDIS_OID_PNP_SET_POWER, NDIS_PM_STATE_D3);

284

miniport_set_int(handle, OID_PNP_SET_POWER, NdisDeviceStateD3);

280

285

281

miniport->halt(handle->adapter_ctx);

286

LIN2WIN1(miniport->halt, handle->adapter_ctx);

282

287

283

288

ndis_exit_handle(handle);

289

misc_funcs_exit_handle(handle);

284

290

285

291

if (handle->device->bustype == NDIS_PCI_BUS)

286

292

pci_set_power_state(handle->dev.pci, 3);

295

301

TRACEENTER3("%s", "");

296

302

297

303

if (handle->reset_status == 0) {

298

int res;

304

NDIS_STATUS res;

299

305

struct miniport_char *miniport;

300

306

301

307

miniport = &handle->driver->miniport_char;

302

308

irql = raise_irql(DISPATCH_LEVEL);

303

res = miniport->hangcheck(handle->adapter_ctx);

309

res = LIN2WIN1(miniport->hangcheck, handle->adapter_ctx);

304

310

lower_irql(irql);

305

311

if (res) {

306

312

WARNING("%s is being reset", handle->net_dev->name);

310

316

}

311

317

}

312

318

313

wrap_spin_lock(&handle->timers_lock, PASSIVE_LEVEL);

319

kspin_lock(&handle->timers_lock);

314

320

if (handle->hangcheck_active) {

315

321

handle->hangcheck_timer.expires =

316

322

jiffies + handle->hangcheck_interval;

317

323

add_timer(&handle->hangcheck_timer);

318

324

}

319

wrap_spin_unlock(&handle->timers_lock);

325

kspin_unlock(&handle->timers_lock);

320

326

321

327

TRACEEXIT3(return);

322

328

}

330

336

}

331

337

332

338

init_timer(&handle->hangcheck_timer);

333

handle->hangcheck_timer.data = (unsigned long) handle;

339

handle->hangcheck_timer.data = (unsigned long)handle;

334

340

handle->hangcheck_timer.function = &hangcheck_proc;

335

341

336

wrap_spin_lock(&handle->timers_lock, PASSIVE_LEVEL);

342

kspin_lock(&handle->timers_lock);

337

343

add_timer(&handle->hangcheck_timer);

338

344

handle->hangcheck_active = 1;

339

wrap_spin_unlock(&handle->timers_lock);

345

kspin_unlock(&handle->timers_lock);

340

346

return;

341

347

}

342

348

346

352

handle->hangcheck_interval <= 0)

347

353

return;

348

354

349

wrap_spin_lock(&handle->timers_lock, PASSIVE_LEVEL);

355

kspin_lock(&handle->timers_lock);

350

356

handle->hangcheck_active = 0;

351

357

del_timer(&handle->hangcheck_timer);

352

wrap_spin_unlock(&handle->timers_lock);

358

kspin_unlock(&handle->timers_lock);

353

359

}

354

360

355

361

static void stats_proc(unsigned long data)

365

371

static void stats_timer_add(struct ndis_handle *handle)

366

372

{

367

373

init_timer(&handle->stats_timer);

368

handle->stats_timer.data = (unsigned long) handle;

374

handle->stats_timer.data = (unsigned long)handle;

369

375

handle->stats_timer.function = &stats_proc;

370

376

handle->stats_timer.expires = jiffies + 2 * HZ;

371

377

add_timer(&handle->stats_timer);

373

379

374

380

static void stats_timer_del(struct ndis_handle *handle)

375

381

{

376

wrap_spin_lock(&handle->timers_lock, PASSIVE_LEVEL);

382

kspin_lock(&handle->timers_lock);

377

383

del_timer_sync(&handle->stats_timer);

378

wrap_spin_unlock(&handle->timers_lock);

384

kspin_unlock(&handle->timers_lock);

379

385

}

380

386

381

387

static int ndis_open(struct net_device *dev)

394

400

netif_stop_queue(dev);

395

401

netif_device_detach(dev);

396

402

}

397

398

403

return 0;

399

404

}

400

405

419

424

struct ndis_handle *handle)

420

425

{

421

426

struct dev_mc_list *mclist;

422

int i;

427

int i, size = 0;

423

428

char *list = handle->multicast_list;

424

int size = 0, res;

429

NDIS_STATUS res;

425

430

426

for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;

431

for (i = 0, mclist = dev->mc_list;

432

mclist && i < dev->mc_count && size < handle->multicast_list_size;

427

433

i++, mclist = mclist->next) {

428

434

memcpy(list, mclist->dmi_addr, ETH_ALEN);

429

435

list += ETH_ALEN;

431

437

}

432

438

DBGTRACE1("%d entries. size=%d", dev->mc_count, size);

433

439

434

res = miniport_set_info(handle, OID_802_3_MULTICAST_LIST, list,

435

size);

440

res = miniport_set_info(handle, OID_802_3_MULTICAST_LIST, list, size);

436

441

if (res)

437

442

ERROR("Unable to set multicast list (%08X)", res);

438

443

}

447

452

schedule_work(&handle->wrapper_worker);

448

453

}

449

454

450

static struct ndis_packet *alloc_packet(struct ndis_handle *handle,

451

struct ndis_buffer *buffer)

455

static struct ndis_packet *allocate_send_packet(struct ndis_handle *handle,

456

ndis_buffer *buffer)

452

457

{

453

458

struct ndis_packet *packet;

454

459

455

packet = kmalloc(sizeof(struct ndis_packet), GFP_ATOMIC);

460

packet = allocate_ndis_packet();

456

461

if (!packet)

457

462

return NULL;

458

463

459

memset(packet, 0, sizeof(*packet));

460

461

if (handle->use_scatter_gather) {

462

/* FIXME: do USB drivers call this? */

463

packet->dataphys =

464

PCI_DMA_MAP_SINGLE(handle->dev.pci,

465

buffer->data, buffer->len,

466

PCI_DMA_TODEVICE);

467

packet->sg_list.len = 1;

468

packet->sg_element.address.quad = packet->dataphys;

469

packet->sg_element.len = buffer->len;

470

packet->sg_list.elements = &packet->sg_element;

471

packet->extension.info[NDIS_SCLIST_INFO] = &packet->sg_list;

472

}

473

474

packet->private.oob_offset = offsetof(struct ndis_packet, oob_tx);

475

476

464

packet->private.nr_pages = NDIS_BUFFER_TO_SPAN_PAGES(buffer);

477

packet->private.len = buffer->len;

465

packet->private.len = MmGetMdlByteCount(buffer);

478

466

packet->private.count = 1;

479

packet->private.valid_counts = 1;

467

packet->private.valid_counts = TRUE;

480

468

481

469

packet->private.buffer_head = buffer;

482

470

packet->private.buffer_tail = buffer;

483

471

472

if (handle->use_sg_dma) {

473

packet->ndis_sg_element.address =

474

PCI_DMA_MAP_SINGLE(handle->dev.pci,

475

MmGetMdlVirtualAddress(buffer),

476

MmGetMdlByteCount(buffer),

477

PCI_DMA_TODEVICE);

478

479

packet->ndis_sg_element.length = MmGetMdlByteCount(buffer);

480

packet->ndis_sg_list.nent = 1;

481

packet->ndis_sg_list.elements = &packet->ndis_sg_element;

482

packet->extension.info[ScatterGatherListPacketInfo] =

483

&packet->ndis_sg_list;

484

}

485

484

486

return packet;

485

487

}

486

488

487

static void free_packet(struct ndis_handle *handle, struct ndis_packet *packet)

489

static void free_send_packet(struct ndis_handle *handle,

490

struct ndis_packet *packet)

488

491

{

492

ndis_buffer *buffer;

493

494

TRACEENTER3("packet: %p", packet);

489

495

if (!packet) {

490

496

ERROR("illegal packet from %p", handle);

491

497

return;

492

498

}

493

499

494

kfree(packet->private.buffer_head->data);

495

kfree(packet->private.buffer_head);

496

497

if (packet->dataphys) {

498

/* FIXME: do USB drivers call this? */

499

PCI_DMA_UNMAP_SINGLE(handle->dev.pci, packet->dataphys,

500

packet->private.len, PCI_DMA_TODEVICE);

501

}

502

503

kfree(packet);

500

buffer = packet->private.buffer_head;

501

if (handle->use_sg_dma)

502

PCI_DMA_UNMAP_SINGLE(handle->dev.pci,

503

packet->ndis_sg_element.address,

504

packet->ndis_sg_element.length,

505

PCI_DMA_TODEVICE);

506

507

DBGTRACE3("freeing buffer %p", buffer);

508

kfree(MmGetMdlVirtualAddress(buffer));

509

free_mdl(buffer);

510

511

DBGTRACE3("freeing packet %p", packet);

512

free_ndis_packet(packet);

513

TRACEEXIT3(return);

504

514

}

505

515

506

516

/*

507

517

* MiniportSend and MiniportSendPackets

508

* this function is called from bh disabled context, so no need to raise

509

* irql to DISPATCH_LEVEL during MiniportSend(Packets)

510

*/

518

* this function is called with lock held in DISPATCH_LEVEL, so no need

519

* to raise irql to DISPATCH_LEVEL during MiniportSend(Packets)

520

*/

511

521

static int send_packets(struct ndis_handle *handle, unsigned int start,

512

522

unsigned int pending)

513

523

{

514

int res;

524

NDIS_STATUS res;

515

525

struct miniport_char *miniport = &handle->driver->miniport_char;

516

526

unsigned int sent, n;

517

527

struct ndis_packet *packet;

518

528

519

529

TRACEENTER3("start: %d, pending: %d", start, pending);

520

530

531

if (pending > handle->max_send_packets)

532

n = handle->max_send_packets;

533

else

534

n = pending;

535

521

536

if (miniport->send_packets) {

522

537

unsigned int i;

523

if (pending > handle->max_send_packets)

524

n = handle->max_send_packets;

525

else

526

n = pending;

527

528

DBG_BLOCK() {

529

if (n > 1)

530

DBGTRACE3("sending %d packets", n);

531

}

532

533

/* copy packets from xmit_ring to linear xmit_array array */

538

/* copy packets from xmit ring to linear xmit array */

534

539

for (i = 0; i < n; i++) {

535

540

int j = (start + i) % XMIT_RING_SIZE;

536

541

handle->xmit_array[i] = handle->xmit_ring[j];

537

542

}

538

miniport->send_packets(handle->adapter_ctx,

539

handle->xmit_array, n);

543

LIN2WIN3(miniport->send_packets, handle->adapter_ctx,

544

handle->xmit_array, n);

545

DBGTRACE3("sent");

540

546

if (test_bit(ATTR_SERIALIZED, &handle->attributes)) {

541

for (sent = 0; sent < n && handle->send_ok;

542

sent++) {

547

for (sent = 0; sent < n && handle->send_ok; sent++) {

543

548

packet = handle->xmit_array[sent];

544

switch(packet->status) {

549

switch(packet->oob_data.status) {

545

550

case NDIS_STATUS_SUCCESS:

546

551

sendpacket_done(handle, packet);

547

552

break;

552

557

break;

553

558

case NDIS_STATUS_FAILURE:

554

559

default:

555

free_packet(handle, packet);

560

free_send_packet(handle, packet);

556

561

break;

557

562

}

558

563

}

561

566

}

562

567

} else {

563

568

packet = handle->xmit_ring[start];

564

res = miniport->send(handle->adapter_ctx, packet, 0);

569

res = LIN2WIN3(miniport->send, handle->adapter_ctx, packet, 0);

565

570

566

571

sent = 1;

567

572

switch (res) {

575

580

sent = 0;

576

581

break;

577

582

case NDIS_STATUS_FAILURE:

578

free_packet(handle, packet);

583

free_send_packet(handle, packet);

579

584

break;

580

585

}

581

586

}

586

591

{

587

592

struct ndis_handle *handle = (struct ndis_handle *)param;

588

593

int n;

594

KIRQL irql;

589

595

590

596

TRACEENTER3("send_ok %d", handle->send_ok);

591

597

592

598

/* some drivers e.g., new RT2500 driver, crash if any packets

593

599

* are sent when the card is not associated */

594

600

while (handle->send_ok) {

595

wrap_spin_lock(&handle->xmit_ring_lock, DISPATCH_LEVEL);

601

irql = kspin_lock_irql(&handle->xmit_lock, DISPATCH_LEVEL);

596

602

if (handle->xmit_ring_pending == 0) {

597

wrap_spin_unlock(&handle->xmit_ring_lock);

603

kspin_unlock_irql(&handle->xmit_lock, irql);

598

604

break;

599

605

}

600

606

n = send_packets(handle, handle->xmit_ring_start,

604

610

handle->xmit_ring_pending -= n;

605

611

if (n > 0 && netif_queue_stopped(handle->net_dev))

606

612

netif_wake_queue(handle->net_dev);

607

wrap_spin_unlock(&handle->xmit_ring_lock);

613

kspin_unlock_irql(&handle->xmit_lock, irql);

608

614

}

609

615

610

616

TRACEEXIT3(return);

616

622

void sendpacket_done(struct ndis_handle *handle, struct ndis_packet *packet)

617

623

{

618

624

TRACEENTER3("%s", "");

619

wrap_spin_lock(&handle->send_packet_done_lock, PASSIVE_LEVEL);

625

kspin_lock(&handle->send_packet_done_lock);

620

626

handle->stats.tx_bytes += packet->private.len;

621

627

handle->stats.tx_packets++;

622

free_packet(handle, packet);

623

wrap_spin_unlock(&handle->send_packet_done_lock);

628

free_send_packet(handle, packet);

629

kspin_unlock(&handle->send_packet_done_lock);

624

630

TRACEEXIT3(return);

625

631

}

626

632

633

639

static int start_xmit(struct sk_buff *skb, struct net_device *dev)

634

640

{

635

641

struct ndis_handle *handle = dev->priv;

636

struct ndis_buffer *buffer;

642

ndis_buffer *buffer;

637

643

struct ndis_packet *packet;

638

644

unsigned int xmit_ring_next_slot;

645

char *data;

646

KIRQL irql;

639

647

640

char *data = kmalloc(skb->len, GFP_ATOMIC);

648

data = kmalloc(skb->len, GFP_ATOMIC);

641

649

if (!data)

642

650

return 1;

643

651

644

buffer = kmalloc(sizeof(struct ndis_buffer), GFP_ATOMIC);

652

buffer = allocate_init_mdl(data, skb->len);

645

653

if (!buffer) {

646

654

kfree(data);

647

655

return 1;

648

656

}

657

packet = allocate_send_packet(handle, buffer);

658

if (!packet) {

659

free_mdl(buffer);

660

kfree(data);

661

return 1;

662

}

649

663

650

664

skb_copy_and_csum_dev(skb, data);

651

buffer->data = data;

652

buffer->next = 0;

653

buffer->len = skb->len;

654

packet = alloc_packet(handle, buffer);

655

if (!packet) {

656

kfree(buffer);

657

kfree(data);

658

return 1;

659

}

660

665

dev_kfree_skb(skb);

661

666

662

wrap_spin_lock(&handle->xmit_ring_lock, PASSIVE_LEVEL);

667

irql = kspin_lock_irql(&handle->xmit_lock, DISPATCH_LEVEL);

663

668

xmit_ring_next_slot =

664

669

(handle->xmit_ring_start +

665

670

handle->xmit_ring_pending) % XMIT_RING_SIZE;

667

672

handle->xmit_ring_pending++;

668

673

if (handle->xmit_ring_pending == XMIT_RING_SIZE)

669

674

netif_stop_queue(handle->net_dev);

670

wrap_spin_unlock(&handle->xmit_ring_lock);

675

kspin_unlock_irql(&handle->xmit_lock, irql);

671

676

672

677

schedule_work(&handle->xmit_work);

673

678

674

679

return 0;

675

680

}

676

681

677

int ndis_suspend_pci(struct pci_dev *pdev, u32 state)

682

int ndiswrapper_suspend_pci(struct pci_dev *pdev, u32 state)

678

683

{

679

684

struct net_device *dev;

680

685

struct ndis_handle *handle;

681

int res, pm_state;

686

int pm_state;

687

NDIS_STATUS res;

682

688

683

689

if (!pdev)

684

690

return -1;

689

695

690

696

if (test_bit(HW_SUSPENDED, &handle->hw_status) ||

691

697

test_bit(HW_HALTED, &handle->hw_status))

692

return 0;

698

return -1;

693

699

694

DBGTRACE2("irql: %d", KeGetCurrentIrql());

700

DBGTRACE2("irql: %d", current_irql());

695

701

DBGTRACE2("%s: detaching device", dev->name);

696

702

if (netif_running(dev)) {

697

703

netif_stop_queue(dev);

707

713

} else {

708

714

int i;

709

715

/* some drivers don't support D2, so force D3 */

710

pm_state = NDIS_PM_STATE_D3;

716

pm_state = NdisDeviceStateD3;

711

717

/* use copy; query_power changes this value */

712

718

i = pm_state;

713

res = miniport_query_int(handle, NDIS_OID_PNP_QUERY_POWER, &i);

719

res = miniport_query_int(handle, OID_PNP_QUERY_POWER, &i);

714

720

DBGTRACE2("%s: query power to state %d returns %08X",

715

721

dev->name, pm_state, res);

716

722

if (res) {

719

725

miniport_halt(handle);

720

726

set_bit(HW_HALTED, &handle->hw_status);

721

727

} else {

722

res = miniport_set_int(handle, NDIS_OID_PNP_SET_POWER,

728

res = miniport_set_int(handle, OID_PNP_SET_POWER,

723

729

pm_state);

724

730

DBGTRACE2("suspending returns %08X", res);

725

731

set_bit(HW_SUSPENDED, &handle->hw_status);

737

743

return 0;

738

744

}

739

745

740

int ndis_resume_pci(struct pci_dev *pdev)

746

int ndiswrapper_resume_pci(struct pci_dev *pdev)

741

747

{

742

748

struct net_device *dev;

743

749

struct ndis_handle *handle;

751

757

752

758

if (!(test_bit(HW_SUSPENDED, &handle->hw_status) ||

753

759

test_bit(HW_HALTED, &handle->hw_status)))

754

return 0;

760

return -1;

755

761

756

762

pci_enable_device(pdev);

757

763

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,9)

759

765

#else

760

766

pci_restore_state(pdev, handle->pci_state);

761

767

#endif

762

DBGTRACE2("irql: %d", KeGetCurrentIrql());

768

DBGTRACE2("irql: %d", current_irql());

763

769

set_bit(SUSPEND_RESUME, &handle->wrapper_work);

764

770

schedule_work(&handle->wrapper_worker);

765

771

return 0;

766

772

}

767

773

768

void ndis_remove_one(struct ndis_handle *handle)

774

void ndiswrapper_remove_one_dev(struct ndis_handle *handle)

769

775

{

770

struct miniport_char *miniport = &handle->driver->miniport_char;

776

KIRQL irql;

771

777

772

778

TRACEENTER1("%s", handle->net_dev->name);

773

779

780

set_bit(SHUTDOWN, &handle->wrapper_work);

781

774

782

stats_timer_del(handle);

775

783

hangcheck_del(handle);

776

784

ndiswrapper_procfs_remove_iface(handle);

778

786

ndis_close(handle->net_dev);

779

787

netif_carrier_off(handle->net_dev);

780

788

781

set_bit(SHUTDOWN, &handle->wrapper_work);

782

783

789

/* flush_scheduled_work here causes crash with 2.4 kernels */

784

790

/* instead, throw away pending packets */

785

wrap_spin_lock(&handle->xmit_ring_lock, DISPATCH_LEVEL);

791

irql = kspin_lock_irql(&handle->xmit_lock, DISPATCH_LEVEL);

786

792

while (handle->xmit_ring_pending) {

787

793

struct ndis_packet *packet;

788

794

789

795

packet = handle->xmit_ring[handle->xmit_ring_start];

790

free_packet(handle, packet);

796

free_send_packet(handle, packet);

791

797

handle->xmit_ring_start =

792

798

(handle->xmit_ring_start + 1) % XMIT_RING_SIZE;

793

799

handle->xmit_ring_pending--;

794

800

}

795

wrap_spin_unlock(&handle->xmit_ring_lock);

801

kspin_unlock_irql(&handle->xmit_lock, irql);

796

802

797

miniport_set_int(handle, NDIS_OID_DISASSOCIATE, 0);

803

miniport_set_int(handle, OID_802_11_DISASSOCIATE, 0);

798

804

799

805

if (handle->net_dev)

800

806

unregister_netdev(handle->net_dev);

801

807

802

printk(KERN_INFO "%s: device %s removed\n", DRV_NAME,

808

printk(KERN_INFO "%s: device %s removed\n", DRIVER_NAME,

803

809

handle->net_dev->name);

804

810

811

#if 0

805

812

DBGTRACE1("%d, %p",

806

813

test_bit(ATTR_SURPRISE_REMOVE, &handle->attributes),

807

814

miniport->pnp_event_notify);

808

815

if (test_bit(ATTR_SURPRISE_REMOVE, &handle->attributes) &&

809

816

miniport->pnp_event_notify) {

810

miniport->pnp_event_notify(handle->adapter_ctx,

811

NDIS_PNP_SURPRISE_REMOVED,

812

NULL, 0);

817

LIN2WIN4(miniport->pnp_event_notify, handle->adapter_ctx,

818

NdisDevicePnPEventSurpriseRemoved, NULL, 0);

813

819

}

814

820

#endif

815

821

DBGTRACE1("halting device %s", handle->driver->name);

816

822

miniport_halt(handle);

817

823

DBGTRACE1("halt successful");

818

824

825

if (handle->xmit_array)

826

kfree(handle->xmit_array);

819

827

if (handle->multicast_list)

820

828

kfree(handle->multicast_list);

821

829

if (handle->net_dev)

822

830

free_netdev(handle->net_dev);

823

824

if (handle->phys_device_obj)

825

kfree(handle->phys_device_obj);

831

TRACEEXIT1(return);

826

832

}

827

833

828

834

static void link_status_handler(struct ndis_handle *handle)

830

836

struct ndis_assoc_info *ndis_assoc_info;

831

837

unsigned char *wpa_assoc_info, *assoc_info, *p, *ies;

832

838

union iwreq_data wrqu;

833

unsigned int i, res;

839

unsigned int i;

840

NDIS_STATUS res;

834

841

const int assoc_size = sizeof(*ndis_assoc_info) + IW_CUSTOM_MAX;

835

842

struct encr_info *encr_info = &handle->encr_info;

836

843

837

TRACEENTER2("");

838

839

DBGTRACE2("link status: %d", handle->link_status);

844

TRACEENTER2("link status: %d", handle->link_status);

840

845

if (handle->link_status == 0) {

841

if (handle->encr_mode == ENCR1_ENABLED ||

842

handle->op_mode == NDIS_MODE_ADHOC) {

846

if (handle->encr_mode == Ndis802_11Encryption1Enabled ||

847

handle->infrastructure_mode == Ndis802_11IBSS) {

843

848

for (i = 0; i < MAX_ENCR_KEYS; i++) {

844

849

if (encr_info->keys[i].length == 0)

845

850

continue;

846

if (add_wep_key(handle, encr_info->keys[i].key,

847

encr_info->keys[i].length, i))

848

WARNING("setting wep key %d failed",

849

i);

851

add_wep_key(handle, encr_info->keys[i].key,

852

encr_info->keys[i].length, i);

850

853

}

851

854

852

855

set_bit(SET_ESSID, &handle->wrapper_work);

853

856

schedule_work(&handle->wrapper_worker);

854

857

TRACEEXIT2(return);

855

856

858

}

857

859

/* FIXME: not clear if NDIS says keys should

858

860

* be cleared here */

865

867

TRACEEXIT2(return);

866

868

}

867

869

868

if (!test_bit(CAPA_WPA, &handle->capa))

870

if (!test_bit(Ndis802_11Encryption2Enabled, &handle->capa) &&

871

!test_bit(Ndis802_11Encryption3Enabled, &handle->capa))

869

872

TRACEEXIT2(return);

870

873

871

874

assoc_info = kmalloc(assoc_size, GFP_KERNEL);

883

886

ndis_assoc_info->req_ie_length;

884

887

ndis_assoc_info->resp_ie_length = IW_CUSTOM_MAX / 2;

885

888

886

res = miniport_query_info(handle, NDIS_OID_ASSOC_INFO, assoc_info,

887

assoc_size);

889

res = miniport_query_info(handle, OID_802_11_ASSOCIATION_INFORMATION,

890

assoc_info, assoc_size);

888

891

if (res) {

889

892

DBGTRACE2("query assoc_info failed (%08X)", res);

890

893

kfree(assoc_info);

942

945

static void set_packet_filter(struct ndis_handle *handle)

943

946

{

944

947

struct net_device *dev = (struct net_device *)handle->net_dev;

945

unsigned long packet_filter;

946

unsigned int res;

948

ULONG packet_filter;

949

NDIS_STATUS res;

947

950

948

951

packet_filter = (NDIS_PACKET_TYPE_DIRECTED |

949

952

NDIS_PACKET_TYPE_BROADCAST |

950

953

NDIS_PACKET_TYPE_ALL_MULTICAST);

951

954

952

955

if (dev->flags & IFF_PROMISC) {

953

DBGTRACE1("%s", "Going into promiscuous mode");

954

printk(KERN_WARNING "promiscuous mode is not "

955

"supported by NDIS; only packets sent "

956

"from/to this host will be seen\n");

957

packet_filter |= NDIS_PACKET_TYPE_ALL_LOCAL;

956

packet_filter |= NDIS_PACKET_TYPE_ALL_LOCAL |

957

NDIS_PACKET_TYPE_PROMISCUOUS;

958

} else if ((dev->mc_count > handle->multicast_list_size) ||

959

(dev->flags & IFF_ALLMULTI) ||

960

(handle->multicast_list == 0)) {

961

/* Too many to filter perfectly -- accept all multicasts. */

962

963

DBGTRACE1("Multicast list to long. Accepting all");

961

/* too many to filter perfectly -- accept all multicasts. */

962

DBGTRACE1("multicast list too long; accepting all");

964

963

packet_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;

965

964

} else if (dev->mc_count > 0) {

966

965

packet_filter |= NDIS_PACKET_TYPE_MULTICAST;

967

966

set_multicast_list(dev, handle);

968

967

}

969

968

970

res = miniport_set_info(handle, NDIS_OID_PACKET_FILTER,

971

(char *)&packet_filter, sizeof(packet_filter));

969

res = miniport_set_info(handle, OID_GEN_CURRENT_PACKET_FILTER,

970

&packet_filter, sizeof(packet_filter));

971

if (res && (packet_filter & NDIS_PACKET_TYPE_PROMISCUOUS)) {

972

/* 802.11 drivers may fail when PROMISCUOUS flag is

973

* set, so try without */

974

packet_filter &= ~NDIS_PACKET_TYPE_PROMISCUOUS;

975

res = miniport_set_info(handle, OID_GEN_CURRENT_PACKET_FILTER,

976

&packet_filter, sizeof(packet_filter));

977

}

972

978

if (res && res != NDIS_STATUS_NOT_SUPPORTED)

973

ERROR("Unable to set packet filter (%08X)", res);

979

ERROR("unable to set packet filter (%08X)", res);

974

980

TRACEEXIT2(return);

975

981

}

976

982

978

984

{

979

985

struct iw_statistics *iw_stats = &handle->wireless_stats;

980

986

struct ndis_wireless_stats ndis_stats;

981

long rssi;

982

unsigned int res;

987

ndis_rssi rssi;

988

NDIS_STATUS res;

983

989

984

990

if (handle->reset_status)

985

991

return;

986

res = miniport_query_info(handle, NDIS_OID_RSSI, (char *)&rssi,

992

res = miniport_query_info(handle, OID_802_11_RSSI, &rssi,

987

993

sizeof(rssi));

988

994

iw_stats->qual.level = rssi;

989

995

990

996

memset(&ndis_stats, 0, sizeof(ndis_stats));

991

res = miniport_query_info(handle, NDIS_OID_STATISTICS,

992

(char *)&ndis_stats, sizeof(ndis_stats));

997

res = miniport_query_info(handle, OID_802_11_STATISTICS,

998

&ndis_stats, sizeof(ndis_stats));

993

999

if (res == NDIS_STATUS_NOT_SUPPORTED)

994

1000

iw_stats->qual.qual = ((rssi & 0x7F) * 100) / 154;

995

1001

else {

996

iw_stats->discard.retries = (__u32)ndis_stats.retry +

997

(__u32)ndis_stats.multi_retry;

998

iw_stats->discard.misc = (__u32)ndis_stats.fcs_err +

999

(__u32)ndis_stats.rtss_fail +

1000

(__u32)ndis_stats.ack_fail +

1001

(__u32)ndis_stats.frame_dup;

1002

iw_stats->discard.retries = (u32)ndis_stats.retry +

1003

(u32)ndis_stats.multi_retry;

1004

iw_stats->discard.misc = (u32)ndis_stats.fcs_err +

1005

(u32)ndis_stats.rtss_fail +

1006

(u32)ndis_stats.ack_fail +

1007

(u32)ndis_stats.frame_dup;

1002

1008

1003

if ((__u32)ndis_stats.tx_frag)

1009

if ((u32)ndis_stats.tx_frag)

1004

1010

iw_stats->qual.qual = 100 - 100 *

1005

((__u32)ndis_stats.retry +

1006

2 * (__u32)ndis_stats.multi_retry +

1007

3 * (__u32)ndis_stats.failed) /

1008

(6 * (__u32)ndis_stats.tx_frag);

1011

((u32)ndis_stats.retry +

1012

2 * (u32)ndis_stats.multi_retry +

1013

3 * (u32)ndis_stats.failed) /

1014

(6 * (u32)ndis_stats.tx_frag);

1009

1015

else

1010

1016

iw_stats->qual.qual = 100;

1011

1017

}

1018

1024

return &handle->wireless_stats;

1019

1025

}

1020

1026

1027

#ifdef HAVE_ETHTOOL

1028

static u32 ndis_get_link(struct net_device *dev)

1029

{

1030

struct ndis_handle *handle = dev->priv;

1031

return handle->link_status;

1032

}

1033

1034

static struct ethtool_ops ndis_ethtool_ops = {

1035

.get_link = ndis_get_link,

1036

};

1037

#endif

1038

1021

1039

/* worker procedure to take care of setting/checking various states */

1022

1040

static void wrapper_worker_proc(void *param)

1023

1041

{

1028

1046

if (test_bit(SHUTDOWN, &handle->wrapper_work))

1029

1047

TRACEEXIT3(return);

1030

1048

1031

if (test_and_clear_bit(SET_OP_MODE, &handle->wrapper_work))

1032

set_mode(handle, handle->op_mode);

1049

if (test_and_clear_bit(SET_INFRA_MODE, &handle->wrapper_work))

1050

set_infra_mode(handle, handle->infrastructure_mode);

1033

1051

1034

if (test_and_clear_bit(WRAPPER_LINK_STATUS, &handle->wrapper_work))

1052

if (test_and_clear_bit(LINK_STATUS_CHANGED, &handle->wrapper_work))

1035

1053

link_status_handler(handle);

1036

1054

1037

1055

if (test_and_clear_bit(SET_ESSID, &handle->wrapper_work))

1044

1062

update_wireless_stats(handle);

1045

1063

1046

1064

if (test_and_clear_bit(SUSPEND_RESUME, &handle->wrapper_work)) {

1047

unsigned int res;

1065

NDIS_STATUS res;

1048

1066

struct net_device *net_dev = handle->net_dev;

1049

1067

1050

1068

if (test_bit(HW_HALTED, &handle->hw_status)) {

1053

1071

ERROR("initialization failed: %08X", res);

1054

1072

clear_bit(HW_HALTED, &handle->hw_status);

1055

1073

} else {

1056

res = miniport_set_int(handle, NDIS_OID_PNP_SET_POWER,

1057

NDIS_PM_STATE_D0);

1074

res = miniport_set_int(handle, OID_PNP_SET_POWER,

1075

NdisDeviceStateD0);

1058

1076

clear_bit(HW_SUSPENDED, &handle->hw_status);

1059

1077

DBGTRACE2("%s: setting power to state %d returns %d",

1060

net_dev->name, NDIS_PM_STATE_D0, res);

1078

net_dev->name, NdisDeviceStateD0, res);

1061

1079

if (res)

1062

1080

WARNING("No pnp capabilities for pm (%08X)",

1063

1081

res);

1066

1084

/*

1067

1085

if (miniport->pnp_event_notify) {

1068

1086

INFO("%s", "calling pnp_event_notify");

1069

miniport->pnp_event_notify(handle,

1087

LIN2WIN4(miniport->pnp_event_notify, handle,

1070

1088

NDIS_PNP_PROFILE_CHANGED,

1071

1089

&profile_inf, sizeof(profile_inf));

1072

1090

}

1076

1094

if (!res) {

1077

1095

hangcheck_add(handle);

1078

1096

stats_timer_add(handle);

1079

miniport_set_int(handle, NDIS_OID_BSSID_LIST_SCAN, 0);

1097

set_scan(handle);

1080

1098

set_bit(SET_ESSID, &handle->wrapper_work);

1081

1099

schedule_work(&handle->wrapper_worker);

1082

1100

1095

1113

static void check_capa(struct ndis_handle *handle)

1096

1114

{

1097

1115

int i, mode;

1098

unsigned int res;

1116

NDIS_STATUS res;

1099

1117

struct ndis_assoc_info ndis_assoc_info;

1100

1118

struct ndis_add_key ndis_key;

1101

1119

1102

1120

TRACEENTER1("%s", "");

1103

1121

1104

1122

/* check if WEP is supported */

1105

if (set_encr_mode(handle, ENCR1_ENABLED) ||

1106

miniport_query_int(handle, NDIS_OID_ENCR_STATUS, &i))

1107

;

1108

else

1109

set_bit(CAPA_WEP, &handle->capa);

1123

if (set_encr_mode(handle, Ndis802_11Encryption1Enabled) == 0 &&

1124

miniport_query_int(handle,

1125

OID_802_11_ENCRYPTION_STATUS, &i) == 0 &&

1126

(i == Ndis802_11Encryption1Enabled ||

1127

i == Ndis802_11Encryption1KeyAbsent))

1128

set_bit(Ndis802_11Encryption1Enabled, &handle->capa);

1110

1129

1111

1130

/* check if WPA is supported */

1112

set_encr_mode(handle, ENCR_DISABLED);

1113

1131

DBGTRACE2("%s", "");

1114

if (set_auth_mode(handle, AUTHMODE_WPA) ||

1115

miniport_query_int(handle, NDIS_OID_AUTH_MODE, &i) ||

1116

i != AUTHMODE_WPA)

1132

if (set_auth_mode(handle, Ndis802_11AuthModeWPA) ||

1133

miniport_query_int(handle, OID_802_11_AUTHENTICATION_MODE, &i) ||

1134

i != Ndis802_11AuthModeWPA)

1117

1135

TRACEEXIT1(return);

1118

1136

1119

1137

/* check for highest encryption */

1120

for (mode = ENCR3_ENABLED; mode != ENCR_DISABLED; ) {

1121

DBGTRACE1("checking encryption mode %d", mode);

1122

if (set_encr_mode(handle, mode) ||

1123

miniport_query_int(handle, NDIS_OID_ENCR_STATUS, &i))

1124

i = ENCR_DISABLED;

1138

if (set_encr_mode(handle, Ndis802_11Encryption3Enabled) == 0 &&

1139

miniport_query_int(handle,

1140

OID_802_11_ENCRYPTION_STATUS, &i) == 0 &&

1141

(i == Ndis802_11Encryption3Enabled ||

1142

i == Ndis802_11Encryption3KeyAbsent))

1143

mode = Ndis802_11Encryption3Enabled;

1144

else if (set_encr_mode(handle, Ndis802_11Encryption2Enabled) == 0 &&

1145

miniport_query_int(handle,

1146

OID_802_11_ENCRYPTION_STATUS, &i) == 0 &&

1147

(i == Ndis802_11Encryption2Enabled ||

1148

i == Ndis802_11Encryption2KeyAbsent))

1149

mode = Ndis802_11Encryption2Enabled;

1150

else if (set_encr_mode(handle, Ndis802_11Encryption1Enabled) == 0 &&

1151

miniport_query_int(handle,

1152

OID_802_11_ENCRYPTION_STATUS, &i) == 0 &&

1153

(i == Ndis802_11Encryption1Enabled ||

1154

i == Ndis802_11Encryption1KeyAbsent))

1155

mode = Ndis802_11Encryption1Enabled;

1156

else

1157

mode = Ndis802_11EncryptionDisabled;

1125

1158

1126

if (mode == ENCR3_ENABLED) {

1127

if (i == mode || i == ENCR3_ABSENT)

1128

break;

1129

else

1130

mode = ENCR2_ENABLED;

1131

} else if (mode == ENCR2_ENABLED) {

1132

if (i == mode || i == ENCR2_ABSENT)

1133

break;

1134

else

1135

mode = ENCR1_ENABLED;

1136

} else

1137

mode = ENCR_DISABLED;

1138

}

1139

1159

DBGTRACE1("highest encryption mode supported = %d", mode);

1140

set_encr_mode(handle, mode);

1141

1160

1142

if (mode == ENCR_DISABLED)

1161

if (mode == Ndis802_11EncryptionDisabled)

1143

1162

TRACEEXIT1(return);

1144

1163

1145

set_bit(CAPA_WEP, &handle->capa);

1146

if (mode == ENCR1_ENABLED)

1164

set_bit(Ndis802_11Encryption1Enabled, &handle->capa);

1165

if (mode == Ndis802_11Encryption1Enabled)

1147

1166

TRACEEXIT1(return);

1148

1167

1149

1168

ndis_key.length = 32;

1150

1169

ndis_key.index = 0xC0000001;

1151

1170

ndis_key.struct_size = sizeof(ndis_key);

1152

res = miniport_set_info(handle, NDIS_OID_ADD_KEY, (char *)&ndis_key,

1171

res = miniport_set_info(handle, OID_802_11_ADD_KEY, &ndis_key,

1153

1172

ndis_key.struct_size);

1154

1173

1155

DBGTRACE2("add key returns %08X, size = %ld\n",

1156

res, (unsigned long)sizeof(ndis_key));

1174

DBGTRACE2("add key returns %08X, size = %lu",

1175

res, (unsigned long)sizeof(ndis_key));

1157

1176

if (res != NDIS_STATUS_INVALID_DATA)

1158

1177

TRACEEXIT1(return);

1159

res = miniport_query_info(handle, NDIS_OID_ASSOC_INFO,

1160

(char *)&ndis_assoc_info,

1161

sizeof(ndis_assoc_info));

1178

res = miniport_query_info(handle, OID_802_11_ASSOCIATION_INFORMATION,

1179

&ndis_assoc_info, sizeof(ndis_assoc_info));

1162

1180

DBGTRACE2("assoc info returns %d", res);

1163

1181

if (res == NDIS_STATUS_NOT_SUPPORTED)

1164

1182

TRACEEXIT1(return);

1165

1183

1166

set_bit(CAPA_WPA, &handle->capa);

1167

if (mode == ENCR3_ENABLED)

1168

set_bit(CAPA_AES, &handle->capa);

1169

set_bit(CAPA_TKIP, &handle->capa);

1184

set_bit(Ndis802_11Encryption2Enabled, &handle->capa);

1185

if (mode == Ndis802_11Encryption3Enabled)

1186

set_bit(Ndis802_11Encryption3Enabled, &handle->capa);

1170

1187

1171

1188

TRACEEXIT1(return);

1172

1189

}

1179

1196

int i = test_bit(ATTR_HALT_ON_SUSPEND, &handle->attributes);

1180

1197

set_bit(ATTR_HALT_ON_SUSPEND, &handle->attributes);

1181

1198

if (handle->device->bustype == NDIS_PCI_BUS) {

1182

ndis_suspend_pci(handle->dev.pci, 3);

1183

ndis_resume_pci(handle->dev.pci);

1199

ndiswrapper_suspend_pci(handle->dev.pci, 3);

1200

ndiswrapper_resume_pci(handle->dev.pci);

1184

1201

}

1185

1202

1186

1203

if (!i)

1193

1210

struct ndis_handle *handle = dev->priv;

1194

1211

struct sockaddr *addr = p;

1195

1212

struct ndis_config_param param;

1196

struct ustring key, ansi;

1197

unsigned int i, ret;

1213

struct unicode_string key;

1214

struct ansi_string ansi;

1215

unsigned int i;

1216

NDIS_STATUS res;

1198

1217

unsigned char mac_string[3 * ETH_ALEN];

1199

1218

mac_address mac;

1200

1219

1203

1222

for (i = 0; i < sizeof(mac); i++)

1204

1223

mac[i] = addr->sa_data[i];

1205

1224

memset(mac_string, 0, sizeof(mac_string));

1206

ret = snprintf(mac_string, sizeof(mac_string), MACSTR,

1225

res = snprintf(mac_string, sizeof(mac_string), MACSTR,

1207

1226

MAC2STR(mac));

1208

DBGTRACE2("ret = %d, mac_tring = %s", ret, mac_string);

1209

if (ret != (sizeof(mac_string) - 1))

1227

DBGTRACE2("res = %d, mac_tring = %s", res, mac_string);

1228

if (res != (sizeof(mac_string) - 1))

1210

1229

TRACEEXIT1(return -EINVAL);

1211

1230

1212

1231

ansi.buf = "mac_address";

1222

1241

TRACEEXIT1(return -EINVAL);

1223

1242

}

1224

1243

param.type = NDIS_CONFIG_PARAM_STRING;

1225

NdisWriteConfiguration(&ret, handle, &key, &param);

1226

if (ret != NDIS_STATUS_SUCCESS)

1244

NdisWriteConfiguration(&res, handle, &key, &param);

1245

if (res != NDIS_STATUS_SUCCESS) {

1246

RtlFreeUnicodeString(&key);

1247

RtlFreeUnicodeString(&param.data.ustring);

1227

1248

TRACEEXIT1(return -EINVAL);

1249

}

1228

1250

ndis_reinit(handle);

1229

1251

memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);

1230

1252

RtlFreeUnicodeString(&key);

1235

1257

int setup_dev(struct net_device *dev)

1236

1258

{

1237

1259

struct ndis_handle *handle = dev->priv;

1238

unsigned int i, res;

1260

unsigned int i;

1261

NDIS_STATUS res;

1239

1262

mac_address mac;

1240

1263

union iwreq_data wrqu;

1241

1264

1246

1269

strncpy(dev->name, if_name, IFNAMSIZ-1);

1247

1270

dev->name[IFNAMSIZ-1] = '\0';

1248

1271

1249

DBGTRACE1("%s: Querying for mac", DRV_NAME);

1272

DBGTRACE1("%s: querying for mac", DRIVER_NAME);

1250

1273

res = miniport_query_info(handle, OID_802_3_CURRENT_ADDRESS,

1251

&mac[0], sizeof(mac));

1274

mac, sizeof(mac));

1275

if (res) {

1276

ERROR("%s", "unable to get mac address from driver");

1277

return -EINVAL;

1278

}

1252

1279

DBGTRACE1("mac:" MACSTR, MAC2STR(mac));

1253

if (res) {

1254

ERROR("%s", "unable to get mac address from driver");

1255

return -EINVAL;

1256

}

1257

1280

memcpy(&dev->dev_addr, mac, ETH_ALEN);

1258

1281

1259

1282

handle->max_send_packets = 1;

1272

1295

GFP_KERNEL);

1273

1296

if (!handle->xmit_array) {

1274

1297

ERROR("couldn't allocate memory for tx_packets");

1275

return -EINVAL;

1298

return -ENOMEM;

1276

1299

}

1277

1300

}

1278

1301

DBGTRACE2("maximum send packets used by ndiswrapper: %d",

1280

1303

1281

1304

memset(&wrqu, 0, sizeof(wrqu));

1282

1305

1283

miniport_set_int(handle, NDIS_OID_POWER_MODE, NDIS_POWER_OFF);

1284

set_mode(handle, NDIS_MODE_INFRA);

1306

miniport_set_int(handle, OID_802_11_NETWORK_TYPE_IN_USE,

1307

Ndis802_11Automode);

1308

set_infra_mode(handle, Ndis802_11Infrastructure);

1285

1309

set_essid(handle, "", 0);

1286

1310

1287

1311

res = miniport_query_int(handle, OID_802_3_MAXIMUM_LIST_SIZE, &i);

1295

1319

kmalloc(handle->multicast_list_size * ETH_ALEN,

1296

1320

GFP_KERNEL);

1297

1321

1298

if (set_privacy_filter(handle, NDIS_PRIV_ACCEPT_ALL))

1322

if (set_privacy_filter(handle, Ndis802_11PrivFilterAcceptAll))

1299

1323

WARNING("%s", "Unable to set privacy filter");

1300

1324

1301

1325

ndis_set_rx_mode(dev);

1324

1348

}

1325

1349

1326

1350

netif_stop_queue(dev);

1327

printk(KERN_INFO "%s: %s ethernet device " MACSTR " using driver %s\n",

1328

dev->name, DRV_NAME, MAC2STR(dev->dev_addr),

1329

handle->driver->name);

1351

printk(KERN_INFO "%s: %s ethernet device " MACSTR " using driver %s,"

1352

" configuration file %s\n",

1353

dev->name, DRIVER_NAME, MAC2STR(dev->dev_addr),

1354

handle->driver->name, handle->device->conf_file_name);

1330

1355

1331

1356

check_capa(handle);

1332

1357

1333

1358

DBGTRACE1("capbilities = %ld", handle->capa);

1334

1359

printk(KERN_INFO "%s: encryption modes supported: %s%s%s\n",

1335

1360

dev->name,

1336

test_bit(CAPA_WEP, &handle->capa) ? "WEP" : "none",

1337

test_bit(CAPA_TKIP, &handle->capa) ? ", WPA with TKIP" : "",

1338

test_bit(CAPA_AES, &handle->capa) ? ", WPA with AES/CCMP" : "");

1361

test_bit(Ndis802_11Encryption1Enabled, &handle->capa) ?

1362

"WEP" : "none",

1363

test_bit(Ndis802_11Encryption2Enabled, &handle->capa) ?

1364

", WPA with TKIP" : "",

1365

test_bit(Ndis802_11Encryption3Enabled, &handle->capa) ?

1366

", WPA with AES/CCMP" : "");

1339

1367

1340

1368

/* check_capa changes auth_mode and encr_mode, so set them again */

1341

set_mode(handle, NDIS_MODE_INFRA);

1342

set_auth_mode(handle, AUTHMODE_OPEN);

1343

set_encr_mode(handle, ENCR_DISABLED);

1369

set_infra_mode(handle, Ndis802_11Infrastructure);

1370

set_auth_mode(handle, Ndis802_11AuthModeOpen);

1371

set_encr_mode(handle, Ndis802_11EncryptionDisabled);

1372

set_essid(handle, "", 0);

1344

1373

1345

1374

/* some cards (e.g., RaLink) need a scan before they can associate */

1346

miniport_set_int(handle, NDIS_OID_BSSID_LIST_SCAN, 0);

1375

set_scan(handle);

1347

1376

1348

1377

hangcheck_add(handle);

1349

1378

stats_timer_add(handle);

1369

1398

SET_MODULE_OWNER(dev);

1370

1399

1371

1400

handle = dev->priv;

1401

DBGTRACE1("handle= %p", handle);

1372

1402

1373

1403

/* Poison the fileds as they may contain function pointers

1374

1404

* which my be called by the driver */

1381

1411

handle->net_dev = dev;

1382

1412

handle->ndis_irq = NULL;

1383

1413

1414

kspin_lock_init(&handle->xmit_lock);

1384

1415

init_MUTEX(&handle->ndis_comm_mutex);

1385

1416

init_waitqueue_head(&handle->ndis_comm_wq);

1386

1417

handle->ndis_comm_done = 0;

1389

1420

handle->send_ok = 0;

1390

1421

1391

1422

INIT_WORK(&handle->xmit_work, xmit_worker, handle);

1392

wrap_spin_lock_init(&handle->xmit_ring_lock);

1393

1423

handle->xmit_ring_start = 0;

1394

1424

handle->xmit_ring_pending = 0;

1395

1425

1396

wrap_spin_lock_init(&handle->send_packet_done_lock);

1426

kspin_lock_init(&handle->send_packet_done_lock);

1397

1427

1398

handle->encr_mode = ENCR_DISABLED;

1399

handle->auth_mode = AUTHMODE_OPEN;

1428

handle->encr_mode = Ndis802_11EncryptionDisabled;

1429

handle->auth_mode = Ndis802_11AuthModeOpen;

1400

1430

handle->capa = 0;

1401

1431

handle->attributes = 0;

1402

1432

1403

1433

handle->reset_status = 0;

1404

1434

1405

1435

INIT_LIST_HEAD(&handle->timers);

1406

wrap_spin_lock_init(&handle->timers_lock);

1436

kspin_lock_init(&handle->timers_lock);

1407

1437

1408

handle->rx_packet = &NdisMIndicateReceivePacket;

1409

handle->send_complete = &NdisMSendComplete;

1410

handle->send_resource_avail = &NdisMSendResourcesAvailable;

1411

handle->status = &NdisMIndicateStatus;

1412

handle->status_complete = &NdisMIndicateStatusComplete;

1413

handle->query_complete = &NdisMQueryInformationComplete;

1414

handle->set_complete = &NdisMSetInformationComplete;

1415

handle->reset_complete = &NdisMResetComplete;

1416

handle->eth_rx_indicate = &EthRxIndicateHandler;

1417

handle->eth_rx_complete = &EthRxComplete;

1418

handle->td_complete = &NdisMTransferDataComplete;

1438

handle->rx_packet = WRAP_FUNC_PTR(NdisMIndicateReceivePacket);

1439

handle->send_complete = WRAP_FUNC_PTR(NdisMSendComplete);

1440

handle->send_resource_avail =

1441

WRAP_FUNC_PTR(NdisMSendResourcesAvailable);

1442

handle->status = WRAP_FUNC_PTR(NdisMIndicateStatus);

1443

handle->status_complete = WRAP_FUNC_PTR(NdisMIndicateStatusComplete);

1444

handle->query_complete = WRAP_FUNC_PTR(NdisMQueryInformationComplete);

1445

handle->set_complete = WRAP_FUNC_PTR(NdisMSetInformationComplete);

1446

handle->reset_complete = WRAP_FUNC_PTR(NdisMResetComplete);

1447

handle->eth_rx_indicate = WRAP_FUNC_PTR(EthRxIndicateHandler);

1448

handle->eth_rx_complete = WRAP_FUNC_PTR(EthRxComplete);

1449

handle->td_complete = WRAP_FUNC_PTR(NdisMTransferDataComplete);

1419

1450

handle->driver->miniport_char.adapter_shutdown = NULL;

1420

1451

1421

1452

handle->map_count = 0;

1430

1461

memset(&handle->essid, 0, sizeof(handle->essid));

1431

1462

memset(&handle->encr_info, 0, sizeof(handle->encr_info));

1432

1463

1433

handle->op_mode = IW_MODE_INFRA;

1464

handle->infrastructure_mode = Ndis802_11Infrastructure;

1434

1465

1435

1466

INIT_WORK(&handle->wrapper_worker, wrapper_worker_proc, handle);

1436

1467

1445

1476

loader_exit();

1446

1477

ndiswrapper_procfs_remove();

1447

1478

ndis_exit();

1479

ntoskernel_exit();

1480

misc_funcs_exit();

1448

1481

}

1449

1482

1450

1483

static int __init wrapper_init(void)

1451

1484

{

1485

char *argv[] = {"loadndisdriver",

1452

1486

#if defined DEBUG && DEBUG >= 1

1453

char *argv[] = {"loadndisdriver", "1", NDISWRAPPER_VERSION, "-a", 0};

1487

"1"

1454

1488

#else

1455

char *argv[] = {"loadndisdriver", "0", NDISWRAPPER_VERSION, "-a", 0};

1489

"0"

1456

1490

#endif

1457

char *env[] = {0};

1491

, NDISWRAPPER_VERSION, "-a", 0};

1492

char *env[] = {NULL};

1458

1493

int err;

1459

1494

1495

spin_lock_init(&spinlock_kspin_lock);

1496

#if defined(DEBUG) && DEBUG > 0

1497

debug = DEBUG;

1498

#else

1499

debug = 0;

1500

#endif

1460

1501

printk(KERN_INFO "%s version %s%s loaded (preempt=%s,smp=%s)\n",

1461

DRV_NAME, NDISWRAPPER_VERSION, EXTRA_VERSION,

1502

DRIVER_NAME, NDISWRAPPER_VERSION, EXTRA_VERSION,

1462

1503

#if defined CONFIG_PREEMPT

1463

1504

"yes",

1464

1505

#else

1471

1512

#endif

1472

1513

);

1473

1514

1474

if (loader_init())

1475

TRACEEXIT1(return -EPERM);

1476

if (ndis_init()) {

1515

if (misc_funcs_init() || ntoskernel_init() || ndis_init() ||

1516

loader_init()

1517

#ifdef CONFIG_USB

1518

|| usb_init()

1519

#endif

1520

) {

1477

1521

module_cleanup();

1522

ERROR("couldn't initialize %s", DRIVER_NAME);

1478

1523

TRACEEXIT1(return -EPERM);

1479

}

1480

usb_init();

1481

INIT_LIST_HEAD(&wrap_allocs);

1482

wrap_spin_lock_init(&wrap_allocs_lock);

1483

wrap_spin_lock_init(&dispatch_event_lock);

1524

}

1484

1525

ndiswrapper_procfs_init();

1485

1526

DBGTRACE1("%s", "calling loadndisdriver");

1527

err = call_usermodehelper("/sbin/loadndisdriver", argv, env

1486

1528

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)

1487

err = call_usermodehelper("/sbin/loadndisdriver", argv, env, 1);

1488

#else

1489

err = call_usermodehelper("/sbin/loadndisdriver", argv, env);

1529

, 1

1490

1530

#endif

1491

1531

);

1492

1532

if (err) {

1493

1533

ERROR("loadndiswrapper failed (%d); check system log "

1494

1534

"for messages from 'loadndisdriver'", err);