hci_event.c 75.4 KB
Newer Older
1
/*
Linus Torvalds's avatar
Linus Torvalds committed
2
   BlueZ - Bluetooth protocol stack for Linux
3
   Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10 11 12 13 14

   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15 16 17
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
Linus Torvalds's avatar
Linus Torvalds committed
18 19
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

20 21
   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
Linus Torvalds's avatar
Linus Torvalds committed
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
   SOFTWARE IS DISCLAIMED.
*/

/* Bluetooth HCI event handling. */

#include <linux/module.h>

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/interrupt.h>
#include <linux/notifier.h>
#include <net/sock.h>

#include <asm/system.h>
42
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
43 44 45 46 47
#include <asm/unaligned.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>

48 49
static int enable_le;

Linus Torvalds's avatar
Linus Torvalds committed
50 51
/* Handle HCI Event packets */

52
static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
53
{
54
	__u8 status = *((__u8 *) skb->data);
Linus Torvalds's avatar
Linus Torvalds committed
55

56
	BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds's avatar
Linus Torvalds committed
57

58 59 60 61
	if (status) {
		hci_dev_lock(hdev);
		mgmt_stop_discovery_failed(hdev, status);
		hci_dev_unlock(hdev);
62
		return;
63
	}
Linus Torvalds's avatar
Linus Torvalds committed
64

65 66
	clear_bit(HCI_INQUIRY, &hdev->flags);

67
	hci_dev_lock(hdev);
68
	mgmt_discovering(hdev, 0);
69
	hci_dev_unlock(hdev);
70

71
	hci_req_complete(hdev, HCI_OP_INQUIRY_CANCEL, status);
72 73 74

	hci_conn_check_pending(hdev);
}
75

76 77 78
static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);
79

80
	BT_DBG("%s status 0x%x", hdev->name, status);
81

82 83
	if (status)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
84

85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
	hci_conn_check_pending(hdev);
}

static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev, struct sk_buff *skb)
{
	BT_DBG("%s", hdev->name);
}

static void hci_cc_role_discovery(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_role_discovery *rp = (void *) skb->data;
	struct hci_conn *conn;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

	hci_dev_lock(hdev);

	conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
	if (conn) {
		if (rp->role)
			conn->link_mode &= ~HCI_LM_MASTER;
		else
			conn->link_mode |= HCI_LM_MASTER;
Linus Torvalds's avatar
Linus Torvalds committed
111
	}
112 113

	hci_dev_unlock(hdev);
Linus Torvalds's avatar
Linus Torvalds committed
114 115
}

116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
static void hci_cc_read_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_read_link_policy *rp = (void *) skb->data;
	struct hci_conn *conn;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

	hci_dev_lock(hdev);

	conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
	if (conn)
		conn->link_policy = __le16_to_cpu(rp->policy);

	hci_dev_unlock(hdev);
}

135
static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
136
{
137
	struct hci_rp_write_link_policy *rp = (void *) skb->data;
Linus Torvalds's avatar
Linus Torvalds committed
138
	struct hci_conn *conn;
139
	void *sent;
Linus Torvalds's avatar
Linus Torvalds committed
140

141
	BT_DBG("%s status 0x%x", hdev->name, rp->status);
Linus Torvalds's avatar
Linus Torvalds committed
142

143 144
	if (rp->status)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
145

146 147 148
	sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
	if (!sent)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
149

150
	hci_dev_lock(hdev);
Linus Torvalds's avatar
Linus Torvalds committed
151

152
	conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
153
	if (conn)
154
		conn->link_policy = get_unaligned_le16(sent + 2);
Linus Torvalds's avatar
Linus Torvalds committed
155

156 157
	hci_dev_unlock(hdev);
}
Linus Torvalds's avatar
Linus Torvalds committed
158

159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
static void hci_cc_read_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_read_def_link_policy *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

	hdev->link_policy = __le16_to_cpu(rp->policy);
}

static void hci_cc_write_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);
	void *sent;

	BT_DBG("%s status 0x%x", hdev->name, status);

	sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY);
	if (!sent)
		return;

	if (!status)
		hdev->link_policy = get_unaligned_le16(sent);

185
	hci_req_complete(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, status);
186 187
}

188 189 190
static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);
191

192
	BT_DBG("%s status 0x%x", hdev->name, status);
193

194 195
	clear_bit(HCI_RESET, &hdev->flags);

196
	hci_req_complete(hdev, HCI_OP_RESET, status);
197 198

	hdev->dev_flags = 0;
199
}
200

201 202 203 204
static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);
	void *sent;
205

206
	BT_DBG("%s status 0x%x", hdev->name, status);
207

208 209 210
	sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
	if (!sent)
		return;
211

212 213
	hci_dev_lock(hdev);

214
	if (test_bit(HCI_MGMT, &hdev->flags))
215
		mgmt_set_local_name_complete(hdev, sent, status);
216

217 218
	if (status == 0)
		memcpy(hdev->dev_name, sent, HCI_MAX_NAME_LENGTH);
219

220
	hci_dev_unlock(hdev);
221 222 223 224 225 226 227 228 229 230 231
}

static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_read_local_name *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

232
	memcpy(hdev->dev_name, rp->name, HCI_MAX_NAME_LENGTH);
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
}

static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);
	void *sent;

	BT_DBG("%s status 0x%x", hdev->name, status);

	sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
	if (!sent)
		return;

	if (!status) {
		__u8 param = *((__u8 *) sent);

		if (param == AUTH_ENABLED)
			set_bit(HCI_AUTH, &hdev->flags);
		else
			clear_bit(HCI_AUTH, &hdev->flags);
Linus Torvalds's avatar
Linus Torvalds committed
253
	}
254

255
	hci_req_complete(hdev, HCI_OP_WRITE_AUTH_ENABLE, status);
Linus Torvalds's avatar
Linus Torvalds committed
256 257
}

258
static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
259
{
260
	__u8 status = *((__u8 *) skb->data);
Linus Torvalds's avatar
Linus Torvalds committed
261 262
	void *sent;

263
	BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds's avatar
Linus Torvalds committed
264

265 266 267
	sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
	if (!sent)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
268

269 270 271 272 273 274 275 276
	if (!status) {
		__u8 param = *((__u8 *) sent);

		if (param)
			set_bit(HCI_ENCRYPT, &hdev->flags);
		else
			clear_bit(HCI_ENCRYPT, &hdev->flags);
	}
Linus Torvalds's avatar
Linus Torvalds committed
277

278
	hci_req_complete(hdev, HCI_OP_WRITE_ENCRYPT_MODE, status);
279
}
Linus Torvalds's avatar
Linus Torvalds committed
280

281 282
static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
{
283 284
	__u8 param, status = *((__u8 *) skb->data);
	int old_pscan, old_iscan;
285
	void *sent;
Linus Torvalds's avatar
Linus Torvalds committed
286

287
	BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds's avatar
Linus Torvalds committed
288

289 290 291
	sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
	if (!sent)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
292

293 294
	param = *((__u8 *) sent);

295 296
	hci_dev_lock(hdev);

297
	if (status != 0) {
298
		mgmt_write_scan_failed(hdev, param, status);
299 300 301 302
		hdev->discov_timeout = 0;
		goto done;
	}

303 304 305 306 307 308
	old_pscan = test_and_clear_bit(HCI_PSCAN, &hdev->flags);
	old_iscan = test_and_clear_bit(HCI_ISCAN, &hdev->flags);

	if (param & SCAN_INQUIRY) {
		set_bit(HCI_ISCAN, &hdev->flags);
		if (!old_iscan)
309
			mgmt_discoverable(hdev, 1);
310 311 312 313 314
		if (hdev->discov_timeout > 0) {
			int to = msecs_to_jiffies(hdev->discov_timeout * 1000);
			queue_delayed_work(hdev->workqueue, &hdev->discov_off,
									to);
		}
315
	} else if (old_iscan)
316
		mgmt_discoverable(hdev, 0);
317 318 319 320

	if (param & SCAN_PAGE) {
		set_bit(HCI_PSCAN, &hdev->flags);
		if (!old_pscan)
321
			mgmt_connectable(hdev, 1);
322
	} else if (old_pscan)
323
		mgmt_connectable(hdev, 0);
Linus Torvalds's avatar
Linus Torvalds committed
324

325
done:
326
	hci_dev_unlock(hdev);
327
	hci_req_complete(hdev, HCI_OP_WRITE_SCAN_ENABLE, status);
328
}
Linus Torvalds's avatar
Linus Torvalds committed
329

330 331 332
static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
Linus Torvalds's avatar
Linus Torvalds committed
333

334
	BT_DBG("%s status 0x%x", hdev->name, rp->status);
Linus Torvalds's avatar
Linus Torvalds committed
335

336 337
	if (rp->status)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
338

339
	memcpy(hdev->dev_class, rp->dev_class, 3);
Linus Torvalds's avatar
Linus Torvalds committed
340

341 342 343
	BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
		hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
}
Linus Torvalds's avatar
Linus Torvalds committed
344

345 346 347 348
static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);
	void *sent;
Linus Torvalds's avatar
Linus Torvalds committed
349

350
	BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds's avatar
Linus Torvalds committed
351

352 353 354
	if (status)
		return;

355 356 357
	sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
	if (!sent)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
358

359
	memcpy(hdev->dev_class, sent, 3);
360
}
Linus Torvalds's avatar
Linus Torvalds committed
361

362 363 364 365 366 367 368 369 370 371 372 373
static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_read_voice_setting *rp = (void *) skb->data;
	__u16 setting;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

	setting = __le16_to_cpu(rp->voice_setting);

374
	if (hdev->voice_setting == setting)
375 376 377 378 379 380
		return;

	hdev->voice_setting = setting;

	BT_DBG("%s voice setting 0x%04x", hdev->name, setting);

381
	if (hdev->notify)
382 383 384 385 386 387
		hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
}

static void hci_cc_write_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);
388
	__u16 setting;
389 390 391
	void *sent;

	BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds's avatar
Linus Torvalds committed
392

393 394 395
	if (status)
		return;

396 397 398
	sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
	if (!sent)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
399

400
	setting = get_unaligned_le16(sent);
Linus Torvalds's avatar
Linus Torvalds committed
401

402 403 404 405
	if (hdev->voice_setting == setting)
		return;

	hdev->voice_setting = setting;
Linus Torvalds's avatar
Linus Torvalds committed
406

407
	BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
Linus Torvalds's avatar
Linus Torvalds committed
408

409
	if (hdev->notify)
410
		hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
Linus Torvalds's avatar
Linus Torvalds committed
411 412
}

413
static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
414
{
415
	__u8 status = *((__u8 *) skb->data);
Linus Torvalds's avatar
Linus Torvalds committed
416

417
	BT_DBG("%s status 0x%x", hdev->name, status);
Linus Torvalds's avatar
Linus Torvalds committed
418

419
	hci_req_complete(hdev, HCI_OP_HOST_BUFFER_SIZE, status);
420
}
421

422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
static void hci_cc_read_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_read_ssp_mode *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

	hdev->ssp_mode = rp->mode;
}

static void hci_cc_write_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);
	void *sent;

	BT_DBG("%s status 0x%x", hdev->name, status);

	if (status)
		return;

	sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE);
	if (!sent)
		return;

	hdev->ssp_mode = *((__u8 *) sent);
}

451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
static u8 hci_get_inquiry_mode(struct hci_dev *hdev)
{
	if (hdev->features[6] & LMP_EXT_INQ)
		return 2;

	if (hdev->features[3] & LMP_RSSI_INQ)
		return 1;

	if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 &&
						hdev->lmp_subver == 0x0757)
		return 1;

	if (hdev->manufacturer == 15) {
		if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963)
			return 1;
		if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963)
			return 1;
		if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965)
			return 1;
	}

	if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 &&
						hdev->lmp_subver == 0x1805)
		return 1;

	return 0;
}

static void hci_setup_inquiry_mode(struct hci_dev *hdev)
{
	u8 mode;

	mode = hci_get_inquiry_mode(hdev);

	hci_send_cmd(hdev, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode);
}

static void hci_setup_event_mask(struct hci_dev *hdev)
{
	/* The second byte is 0xff instead of 0x9f (two reserved bits
	 * disabled) since a Broadcom 1.2 dongle doesn't respond to the
	 * command otherwise */
	u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 };

495 496
	/* CSR 1.1 dongles does not accept any bitfield so don't try to set
	 * any event mask for pre 1.2 devices */
497
	if (hdev->hci_ver < BLUETOOTH_VER_1_2)
498 499 500 501 502 503 504
		return;

	events[4] |= 0x01; /* Flow Specification Complete */
	events[4] |= 0x02; /* Inquiry Result with RSSI */
	events[4] |= 0x04; /* Read Remote Extended Features Complete */
	events[5] |= 0x08; /* Synchronous Connection Complete */
	events[5] |= 0x10; /* Synchronous Connection Changed */
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542

	if (hdev->features[3] & LMP_RSSI_INQ)
		events[4] |= 0x04; /* Inquiry Result with RSSI */

	if (hdev->features[5] & LMP_SNIFF_SUBR)
		events[5] |= 0x20; /* Sniff Subrating */

	if (hdev->features[5] & LMP_PAUSE_ENC)
		events[5] |= 0x80; /* Encryption Key Refresh Complete */

	if (hdev->features[6] & LMP_EXT_INQ)
		events[5] |= 0x40; /* Extended Inquiry Result */

	if (hdev->features[6] & LMP_NO_FLUSH)
		events[7] |= 0x01; /* Enhanced Flush Complete */

	if (hdev->features[7] & LMP_LSTO)
		events[6] |= 0x80; /* Link Supervision Timeout Changed */

	if (hdev->features[6] & LMP_SIMPLE_PAIR) {
		events[6] |= 0x01;	/* IO Capability Request */
		events[6] |= 0x02;	/* IO Capability Response */
		events[6] |= 0x04;	/* User Confirmation Request */
		events[6] |= 0x08;	/* User Passkey Request */
		events[6] |= 0x10;	/* Remote OOB Data Request */
		events[6] |= 0x20;	/* Simple Pairing Complete */
		events[7] |= 0x04;	/* User Passkey Notification */
		events[7] |= 0x08;	/* Keypress Notification */
		events[7] |= 0x10;	/* Remote Host Supported
					 * Features Notification */
	}

	if (hdev->features[4] & LMP_LE)
		events[7] |= 0x20;	/* LE Meta-Event */

	hci_send_cmd(hdev, HCI_OP_SET_EVENT_MASK, sizeof(events), events);
}

543 544 545 546 547 548 549 550 551 552 553 554 555 556
static void hci_set_le_support(struct hci_dev *hdev)
{
	struct hci_cp_write_le_host_supported cp;

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

	if (enable_le) {
		cp.le = 1;
		cp.simul = !!(hdev->features[6] & LMP_SIMUL_LE_BR);
	}

	hci_send_cmd(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), &cp);
}

557 558
static void hci_setup(struct hci_dev *hdev)
{
559 560 561
	if (hdev->dev_type != HCI_BREDR)
		return;

562 563
	hci_setup_event_mask(hdev);

564
	if (hdev->hci_ver > BLUETOOTH_VER_1_1)
565 566 567 568 569 570 571 572 573 574 575 576
		hci_send_cmd(hdev, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL);

	if (hdev->features[6] & LMP_SIMPLE_PAIR) {
		u8 mode = 0x01;
		hci_send_cmd(hdev, HCI_OP_WRITE_SSP_MODE, sizeof(mode), &mode);
	}

	if (hdev->features[3] & LMP_RSSI_INQ)
		hci_setup_inquiry_mode(hdev);

	if (hdev->features[7] & LMP_INQ_TX_PWR)
		hci_send_cmd(hdev, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL);
577 578 579 580 581 582 583 584

	if (hdev->features[7] & LMP_EXTFEATURES) {
		struct hci_cp_read_local_ext_features cp;

		cp.page = 0x01;
		hci_send_cmd(hdev, HCI_OP_READ_LOCAL_EXT_FEATURES,
							sizeof(cp), &cp);
	}
585 586 587

	if (hdev->features[4] & LMP_LE)
		hci_set_le_support(hdev);
588 589
}

590 591 592
static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_read_local_version *rp = (void *) skb->data;
593

594
	BT_DBG("%s status 0x%x", hdev->name, rp->status);
595

596 597
	if (rp->status)
		return;
598

599
	hdev->hci_ver = rp->hci_ver;
600
	hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
601
	hdev->lmp_ver = rp->lmp_ver;
602
	hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
603
	hdev->lmp_subver = __le16_to_cpu(rp->lmp_subver);
604

605 606 607
	BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name,
					hdev->manufacturer,
					hdev->hci_ver, hdev->hci_rev);
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628

	if (test_bit(HCI_INIT, &hdev->flags))
		hci_setup(hdev);
}

static void hci_setup_link_policy(struct hci_dev *hdev)
{
	u16 link_policy = 0;

	if (hdev->features[0] & LMP_RSWITCH)
		link_policy |= HCI_LP_RSWITCH;
	if (hdev->features[0] & LMP_HOLD)
		link_policy |= HCI_LP_HOLD;
	if (hdev->features[0] & LMP_SNIFF)
		link_policy |= HCI_LP_SNIFF;
	if (hdev->features[1] & LMP_PARK)
		link_policy |= HCI_LP_PARK;

	link_policy = cpu_to_le16(link_policy);
	hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY,
					sizeof(link_policy), &link_policy);
629
}
Linus Torvalds's avatar
Linus Torvalds committed
630

631 632 633
static void hci_cc_read_local_commands(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_read_local_commands *rp = (void *) skb->data;
Linus Torvalds's avatar
Linus Torvalds committed
634

635
	BT_DBG("%s status 0x%x", hdev->name, rp->status);
Linus Torvalds's avatar
Linus Torvalds committed
636

637
	if (rp->status)
638
		goto done;
Linus Torvalds's avatar
Linus Torvalds committed
639

640
	memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
641 642 643 644 645 646

	if (test_bit(HCI_INIT, &hdev->flags) && (hdev->commands[5] & 0x10))
		hci_setup_link_policy(hdev);

done:
	hci_req_complete(hdev, HCI_OP_READ_LOCAL_COMMANDS, rp->status);
647
}
Linus Torvalds's avatar
Linus Torvalds committed
648

649 650 651
static void hci_cc_read_local_features(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_read_local_features *rp = (void *) skb->data;
652

653
	BT_DBG("%s status 0x%x", hdev->name, rp->status);
Linus Torvalds's avatar
Linus Torvalds committed
654

655 656
	if (rp->status)
		return;
657

658
	memcpy(hdev->features, rp->features, 8);
659

660 661
	/* Adjust default settings according to features
	 * supported by device. */
Linus Torvalds's avatar
Linus Torvalds committed
662

663 664
	if (hdev->features[0] & LMP_3SLOT)
		hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
Linus Torvalds's avatar
Linus Torvalds committed
665

666 667
	if (hdev->features[0] & LMP_5SLOT)
		hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
Linus Torvalds's avatar
Linus Torvalds committed
668

669 670 671 672
	if (hdev->features[1] & LMP_HV2) {
		hdev->pkt_type  |= (HCI_HV2);
		hdev->esco_type |= (ESCO_HV2);
	}
Linus Torvalds's avatar
Linus Torvalds committed
673

674 675 676 677
	if (hdev->features[1] & LMP_HV3) {
		hdev->pkt_type  |= (HCI_HV3);
		hdev->esco_type |= (ESCO_HV3);
	}
Linus Torvalds's avatar
Linus Torvalds committed
678

679 680
	if (hdev->features[3] & LMP_ESCO)
		hdev->esco_type |= (ESCO_EV3);
681

682 683
	if (hdev->features[4] & LMP_EV4)
		hdev->esco_type |= (ESCO_EV4);
684

685 686
	if (hdev->features[4] & LMP_EV5)
		hdev->esco_type |= (ESCO_EV5);
Linus Torvalds's avatar
Linus Torvalds committed
687

688 689 690 691 692 693 694 695 696
	if (hdev->features[5] & LMP_EDR_ESCO_2M)
		hdev->esco_type |= (ESCO_2EV3);

	if (hdev->features[5] & LMP_EDR_ESCO_3M)
		hdev->esco_type |= (ESCO_3EV3);

	if (hdev->features[5] & LMP_EDR_3S_ESCO)
		hdev->esco_type |= (ESCO_2EV5 | ESCO_3EV5);

697 698 699 700 701 702
	BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
					hdev->features[0], hdev->features[1],
					hdev->features[2], hdev->features[3],
					hdev->features[4], hdev->features[5],
					hdev->features[6], hdev->features[7]);
}
Linus Torvalds's avatar
Linus Torvalds committed
703

704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
static void hci_cc_read_local_ext_features(struct hci_dev *hdev,
							struct sk_buff *skb)
{
	struct hci_rp_read_local_ext_features *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

	memcpy(hdev->extfeatures, rp->features, 8);

	hci_req_complete(hdev, HCI_OP_READ_LOCAL_EXT_FEATURES, rp->status);
}

719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
static void hci_cc_read_flow_control_mode(struct hci_dev *hdev,
						struct sk_buff *skb)
{
	struct hci_rp_read_flow_control_mode *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

	hdev->flow_ctl_mode = rp->mode;

	hci_req_complete(hdev, HCI_OP_READ_FLOW_CONTROL_MODE, rp->status);
}

734 735 736
static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_read_buffer_size *rp = (void *) skb->data;
Linus Torvalds's avatar
Linus Torvalds committed
737

738
	BT_DBG("%s status 0x%x", hdev->name, rp->status);
Linus Torvalds's avatar
Linus Torvalds committed
739

740 741
	if (rp->status)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
742

743 744 745 746 747 748 749 750
	hdev->acl_mtu  = __le16_to_cpu(rp->acl_mtu);
	hdev->sco_mtu  = rp->sco_mtu;
	hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
	hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);

	if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
		hdev->sco_mtu  = 64;
		hdev->sco_pkts = 8;
Linus Torvalds's avatar
Linus Torvalds committed
751
	}
752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769

	hdev->acl_cnt = hdev->acl_pkts;
	hdev->sco_cnt = hdev->sco_pkts;

	BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name,
					hdev->acl_mtu, hdev->acl_pkts,
					hdev->sco_mtu, hdev->sco_pkts);
}

static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_read_bd_addr *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (!rp->status)
		bacpy(&hdev->bdaddr, &rp->bdaddr);

770 771 772
	hci_req_complete(hdev, HCI_OP_READ_BD_ADDR, rp->status);
}

773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794
static void hci_cc_read_data_block_size(struct hci_dev *hdev,
							struct sk_buff *skb)
{
	struct hci_rp_read_data_block_size *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

	hdev->block_mtu = __le16_to_cpu(rp->max_acl_len);
	hdev->block_len = __le16_to_cpu(rp->block_len);
	hdev->num_blocks = __le16_to_cpu(rp->num_blocks);

	hdev->block_cnt = hdev->num_blocks;

	BT_DBG("%s blk mtu %d cnt %d len %d", hdev->name, hdev->block_mtu,
					hdev->block_cnt, hdev->block_len);

	hci_req_complete(hdev, HCI_OP_READ_DATA_BLOCK_SIZE, rp->status);
}

795 796 797 798 799 800 801
static void hci_cc_write_ca_timeout(struct hci_dev *hdev, struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);

	BT_DBG("%s status 0x%x", hdev->name, status);

	hci_req_complete(hdev, HCI_OP_WRITE_CA_TIMEOUT, status);
802 803
}

804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
static void hci_cc_read_local_amp_info(struct hci_dev *hdev,
		struct sk_buff *skb)
{
	struct hci_rp_read_local_amp_info *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

	hdev->amp_status = rp->amp_status;
	hdev->amp_total_bw = __le32_to_cpu(rp->total_bw);
	hdev->amp_max_bw = __le32_to_cpu(rp->max_bw);
	hdev->amp_min_latency = __le32_to_cpu(rp->min_latency);
	hdev->amp_max_pdu = __le32_to_cpu(rp->max_pdu);
	hdev->amp_type = rp->amp_type;
	hdev->amp_pal_cap = __le16_to_cpu(rp->pal_cap);
	hdev->amp_assoc_size = __le16_to_cpu(rp->max_assoc_size);
	hdev->amp_be_flush_to = __le32_to_cpu(rp->be_flush_to);
	hdev->amp_max_flush_to = __le32_to_cpu(rp->max_flush_to);

	hci_req_complete(hdev, HCI_OP_READ_LOCAL_AMP_INFO, rp->status);
}

828 829 830 831 832 833 834 835 836 837
static void hci_cc_delete_stored_link_key(struct hci_dev *hdev,
							struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);

	BT_DBG("%s status 0x%x", hdev->name, status);

	hci_req_complete(hdev, HCI_OP_DELETE_STORED_LINK_KEY, status);
}

838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
static void hci_cc_set_event_mask(struct hci_dev *hdev, struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);

	BT_DBG("%s status 0x%x", hdev->name, status);

	hci_req_complete(hdev, HCI_OP_SET_EVENT_MASK, status);
}

static void hci_cc_write_inquiry_mode(struct hci_dev *hdev,
							struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);

	BT_DBG("%s status 0x%x", hdev->name, status);

	hci_req_complete(hdev, HCI_OP_WRITE_INQUIRY_MODE, status);
}

static void hci_cc_read_inq_rsp_tx_power(struct hci_dev *hdev,
							struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);

	BT_DBG("%s status 0x%x", hdev->name, status);

	hci_req_complete(hdev, HCI_OP_READ_INQ_RSP_TX_POWER, status);
}

static void hci_cc_set_event_flt(struct hci_dev *hdev, struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);

	BT_DBG("%s status 0x%x", hdev->name, status);

	hci_req_complete(hdev, HCI_OP_SET_EVENT_FLT, status);
}

876 877 878 879 880 881 882 883
static void hci_cc_pin_code_reply(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_pin_code_reply *rp = (void *) skb->data;
	struct hci_cp_pin_code_reply *cp;
	struct hci_conn *conn;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

884 885
	hci_dev_lock(hdev);

886
	if (test_bit(HCI_MGMT, &hdev->flags))
887
		mgmt_pin_code_reply_complete(hdev, &rp->bdaddr, rp->status);
888 889

	if (rp->status != 0)
890
		goto unlock;
891 892 893

	cp = hci_sent_cmd_data(hdev, HCI_OP_PIN_CODE_REPLY);
	if (!cp)
894
		goto unlock;
895 896 897 898

	conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
	if (conn)
		conn->pin_length = cp->pin_len;
899 900 901

unlock:
	hci_dev_unlock(hdev);
902 903 904 905 906 907 908 909
}

static void hci_cc_pin_code_neg_reply(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_pin_code_neg_reply *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

910 911
	hci_dev_lock(hdev);

912
	if (test_bit(HCI_MGMT, &hdev->flags))
913
		mgmt_pin_code_neg_reply_complete(hdev, &rp->bdaddr,
914
								rp->status);
915 916

	hci_dev_unlock(hdev);
917
}
918

919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
static void hci_cc_le_read_buffer_size(struct hci_dev *hdev,
				       struct sk_buff *skb)
{
	struct hci_rp_le_read_buffer_size *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

	hdev->le_mtu = __le16_to_cpu(rp->le_mtu);
	hdev->le_pkts = rp->le_max_pkt;

	hdev->le_cnt = hdev->le_pkts;

	BT_DBG("%s le mtu %d:%d", hdev->name, hdev->le_mtu, hdev->le_pkts);

	hci_req_complete(hdev, HCI_OP_LE_READ_BUFFER_SIZE, rp->status);
}
938

939 940 941 942 943 944
static void hci_cc_user_confirm_reply(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_user_confirm_reply *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

945 946
	hci_dev_lock(hdev);

947
	if (test_bit(HCI_MGMT, &hdev->flags))
948
		mgmt_user_confirm_reply_complete(hdev, &rp->bdaddr,
949
								rp->status);
950 951

	hci_dev_unlock(hdev);
952 953 954 955 956 957 958 959 960
}

static void hci_cc_user_confirm_neg_reply(struct hci_dev *hdev,
							struct sk_buff *skb)
{
	struct hci_rp_user_confirm_reply *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

961 962
	hci_dev_lock(hdev);

963
	if (test_bit(HCI_MGMT, &hdev->flags))
964
		mgmt_user_confirm_neg_reply_complete(hdev, &rp->bdaddr,
965
								rp->status);
966 967

	hci_dev_unlock(hdev);
968 969
}

970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000
static void hci_cc_user_passkey_reply(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_user_confirm_reply *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	hci_dev_lock(hdev);

	if (test_bit(HCI_MGMT, &hdev->flags))
		mgmt_user_passkey_reply_complete(hdev, &rp->bdaddr,
								rp->status);

	hci_dev_unlock(hdev);
}

static void hci_cc_user_passkey_neg_reply(struct hci_dev *hdev,
							struct sk_buff *skb)
{
	struct hci_rp_user_confirm_reply *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	hci_dev_lock(hdev);

	if (test_bit(HCI_MGMT, &hdev->flags))
		mgmt_user_passkey_neg_reply_complete(hdev, &rp->bdaddr,
								rp->status);

	hci_dev_unlock(hdev);
}

1001 1002 1003 1004 1005 1006 1007
static void hci_cc_read_local_oob_data_reply(struct hci_dev *hdev,
							struct sk_buff *skb)
{
	struct hci_rp_read_local_oob_data *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

1008
	hci_dev_lock(hdev);
1009
	mgmt_read_local_oob_data_reply_complete(hdev, rp->hash,
1010
						rp->randomizer, rp->status);
1011
	hci_dev_unlock(hdev);
1012 1013
}

1014 1015 1016 1017 1018 1019 1020
static void hci_cc_le_set_scan_param(struct hci_dev *hdev, struct sk_buff *skb)
{
	__u8 status = *((__u8 *) skb->data);

	BT_DBG("%s status 0x%x", hdev->name, status);
}

1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
static void hci_cc_le_set_scan_enable(struct hci_dev *hdev,
					struct sk_buff *skb)
{
	struct hci_cp_le_set_scan_enable *cp;
	__u8 status = *((__u8 *) skb->data);

	BT_DBG("%s status 0x%x", hdev->name, status);

	if (status)
		return;

	cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_SCAN_ENABLE);
	if (!cp)
		return;

1036
	if (cp->enable == 0x01) {
1037 1038
		set_bit(HCI_LE_SCAN, &hdev->dev_flags);

1039
		cancel_delayed_work_sync(&hdev->adv_work);
1040 1041

		hci_dev_lock(hdev);
1042
		hci_adv_entries_clear(hdev);
1043
		hci_dev_unlock(hdev);
1044
	} else if (cp->enable == 0x00) {
1045 1046
		clear_bit(HCI_LE_SCAN, &hdev->dev_flags);

1047 1048 1049
		cancel_delayed_work_sync(&hdev->adv_work);
		queue_delayed_work(hdev->workqueue, &hdev->adv_work,
						 jiffies + ADV_CLEAR_TIMEOUT);
1050
	}
1051 1052
}

1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
static void hci_cc_le_ltk_reply(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_le_ltk_reply *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

	hci_req_complete(hdev, HCI_OP_LE_LTK_REPLY, rp->status);
}

static void hci_cc_le_ltk_neg_reply(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct hci_rp_le_ltk_neg_reply *rp = (void *) skb->data;

	BT_DBG("%s status 0x%x", hdev->name, rp->status);

	if (rp->status)
		return;

	hci_req_complete(hdev, HCI_OP_LE_LTK_NEG_REPLY, rp->status);
}

1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
static inline void hci_cc_write_le_host_supported(struct hci_dev *hdev,
							struct sk_buff *skb)
{
	struct hci_cp_read_local_ext_features cp;
	__u8 status = *((__u8 *) skb->data);

	BT_DBG("%s status 0x%x", hdev->name, status);

	if (status)
		return;

	cp.page = 0x01;
	hci_send_cmd(hdev, HCI_OP_READ_LOCAL_EXT_FEATURES, sizeof(cp), &cp);
}

1092 1093 1094 1095 1096
static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
{
	BT_DBG("%s status 0x%x", hdev->name, status);

	if (status) {
1097
		hci_req_complete(hdev, HCI_OP_INQUIRY, status);
1098
		hci_conn_check_pending(hdev);
1099
		hci_dev_lock(hdev);
1100
		if (test_bit(HCI_MGMT, &hdev->flags))
1101
			mgmt_start_discovery_failed(hdev, status);
1102
		hci_dev_unlock(hdev);
1103 1104 1105
		return;
	}

1106 1107
	set_bit(HCI_INQUIRY, &hdev->flags);

1108
	hci_dev_lock(hdev);
1109
	mgmt_discovering(hdev, 1);
1110
	hci_dev_unlock(hdev);
Linus Torvalds's avatar
Linus Torvalds committed
1111 1112 1113 1114
}

static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
{
1115
	struct hci_cp_create_conn *cp;
Linus Torvalds's avatar
Linus Torvalds committed
1116 1117
	struct hci_conn *conn;

1118 1119 1120
	BT_DBG("%s status 0x%x", hdev->name, status);

	cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
Linus Torvalds's avatar
Linus Torvalds committed
1121 1122 1123 1124 1125 1126 1127
	if (!cp)
		return;

	hci_dev_lock(hdev);

	conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);

1128
	BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
Linus Torvalds's avatar
Linus Torvalds committed
1129 1130 1131

	if (status) {
		if (conn && conn->state == BT_CONNECT) {
1132 1133 1134 1135 1136 1137
			if (status != 0x0c || conn->attempt > 2) {
				conn->state = BT_CLOSED;
				hci_proto_connect_cfm(conn, status);
				hci_conn_del(conn);
			} else
				conn->state = BT_CONNECT2;
Linus Torvalds's avatar
Linus Torvalds committed
1138 1139 1140 1141 1142 1143 1144 1145
		}
	} else {
		if (!conn) {
			conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
			if (conn) {
				conn->out = 1;
				conn->link_mode |= HCI_LM_MASTER;
			} else
1146
				BT_ERR("No memory for new connection");
Linus Torvalds's avatar
Linus Torvalds committed
1147 1148 1149 1150 1151 1152
		}
	}

	hci_dev_unlock(hdev);
}

1153
static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
Linus Torvalds's avatar
Linus Torvalds committed
1154
{