From 44b396e62f133eacb9eb9080bcfc99b1844102e1 Mon Sep 17 00:00:00 2001
From: Sudha Bheemanna <b.sudha@samsung.com>
Date: Thu, 8 Sep 2016 16:01:23 +0530
Subject: [PATCH 01/16] Bluetooth: Modify fast connectable type.

This patch modifies the fast connectable function
to just set the type.

Change-Id: I0cce96f85d823f9798ae7f147c4e33ce7b18e0e3
Signed-off-by: Sudha Bheemanna <b.sudha@samsung.com>
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>
---
 net/bluetooth/hci_request.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/net/bluetooth/hci_request.c b/net/bluetooth/hci_request.c
index 876363f8..79443bb 100644
--- a/net/bluetooth/hci_request.c
+++ b/net/bluetooth/hci_request.c
@@ -352,7 +352,9 @@ void hci_req_add(struct hci_request *req, u16 opcode, u32 plen,
 void __hci_req_write_fast_connectable(struct hci_request *req, bool enable)
 {
 	struct hci_dev *hdev = req->hdev;
+#ifndef TIZEN_BT
 	struct hci_cp_write_page_scan_activity acp;
+#endif
 	u8 type;
 
 	if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED))
@@ -361,6 +363,12 @@ void __hci_req_write_fast_connectable(struct hci_request *req, bool enable)
 	if (hdev->hci_ver < BLUETOOTH_VER_1_2)
 		return;
 
+#ifdef TIZEN_BT
+	if (enable)
+		type = PAGE_SCAN_TYPE_INTERLACED;
+	else
+		type = PAGE_SCAN_TYPE_STANDARD;	/* default */
+#else
 	if (enable) {
 		type = PAGE_SCAN_TYPE_INTERLACED;
 
@@ -379,6 +387,7 @@ void __hci_req_write_fast_connectable(struct hci_request *req, bool enable)
 	    __cpu_to_le16(hdev->page_scan_window) != acp.window)
 		hci_req_add(req, HCI_OP_WRITE_PAGE_SCAN_ACTIVITY,
 			    sizeof(acp), &acp);
+#endif
 
 	if (hdev->page_scan_type != type)
 		hci_req_add(req, HCI_OP_WRITE_PAGE_SCAN_TYPE, 1, &type);
-- 
2.7.4


From 9f61ee597cc495bf1956fc36b2fa8a56307a43c0 Mon Sep 17 00:00:00 2001
From: Sudha Bheemanna <b.sudha@samsung.com>
Date: Thu, 8 Sep 2016 16:40:50 +0530
Subject: [PATCH 02/16] Bluetooth: Enable sniff mode for incoming connection

Add provision to set the link poilicy to enable sniff mode
for incoming connection.

Change-Id: Ifff9e9f0838f26a6c96d81f4cbaae43429aa231f
Signed-off-by: Sudha Bheemanna <b.sudha@samsung.com>
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>
---
 net/bluetooth/hci_conn.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c
index d4f5829..2a3b3b8 100644
--- a/net/bluetooth/hci_conn.c
+++ b/net/bluetooth/hci_conn.c
@@ -536,6 +536,11 @@ struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
 	conn->tx_power = HCI_TX_POWER_INVALID;
 	conn->max_tx_power = HCI_TX_POWER_INVALID;
 
+#ifdef TIZEN_BT
+	/* enable sniff mode for incoming connection */
+	conn->link_policy = hdev->link_policy;
+#endif
+
 	set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
 	conn->disc_timeout = HCI_DISCONN_TIMEOUT;
 
-- 
2.7.4


From f596367819a6b2d66ccf83f0ead6465b07810f64 Mon Sep 17 00:00:00 2001
From: Sudha Bheemanna <b.sudha@samsung.com>
Date: Thu, 8 Sep 2016 17:01:39 +0530
Subject: [PATCH 03/16] Bluetooth: Cancel the Sniff timer

This patch adds code to cancel the sniff timer.

Change-Id: I756d3b08acf6462044d1fb204064fe12ce1238c1
Signed-off-by: Sudha Bheemanna <b.sudha@samsung.com>
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>
---
 net/bluetooth/hci_conn.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c
index 2a3b3b8..e64f0b3 100644
--- a/net/bluetooth/hci_conn.c
+++ b/net/bluetooth/hci_conn.c
@@ -1429,9 +1429,18 @@ void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
 	}
 
 timer:
+#ifdef TIZEN_BT
+	if (hdev->idle_timeout > 0) {
+		/* Sniff timer cancel */
+		cancel_delayed_work(&conn->idle_work);
+		queue_delayed_work(hdev->workqueue, &conn->idle_work,
+				   msecs_to_jiffies(hdev->idle_timeout));
+	}
+#else
 	if (hdev->idle_timeout > 0)
 		queue_delayed_work(hdev->workqueue, &conn->idle_work,
 				   msecs_to_jiffies(hdev->idle_timeout));
+#endif
 }
 
 /* Drop all connection on the device */
-- 
2.7.4


From 3374963e76ae60c9398f0018c88c8b9199076a28 Mon Sep 17 00:00:00 2001
From: Sudha Bheemanna <b.sudha@samsung.com>
Date: Mon, 12 Sep 2016 12:46:44 +0530
Subject: [PATCH 04/16] Bluetooth: Store the key if auth type is P192

This patch allows to store the key after authentication
if auth type is "HCI_LK_AUTH_COMBINATION_P192"

Change-Id: Ie44dbe7dfec361edab61aceaf9b2ca4057b88fa5
Signed-off-by: Sudha Bheemanna <b.sudha@samsung.com>
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>
---
 net/bluetooth/hci_core.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c
index c371595..b1d98ee 100644
--- a/net/bluetooth/hci_core.c
+++ b/net/bluetooth/hci_core.c
@@ -2266,6 +2266,14 @@ static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn,
 	if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03)
 		return true;
 
+#ifdef TIZEN_BT
+	/* In case of auth_type '0x01', it is authenticated by MITM.
+	 * So store it.
+	 */
+	if (key_type == HCI_LK_AUTH_COMBINATION_P192)
+		return true;
+#endif
+
 	/* If none of the above criteria match, then don't store the key
 	 * persistently */
 	return false;
-- 
2.7.4


From 547f8992e9bf4260cf0bcb0f5b550d0e14af0387 Mon Sep 17 00:00:00 2001
From: Sudha Bheemanna <b.sudha@samsung.com>
Date: Thu, 8 Sep 2016 16:21:01 +0530
Subject: [PATCH 05/16] Bluetooth: Fix issue in the Set LE privacy function.

This patch fixes not to check the hdev power before setting
LE Privacy.

Change-Id: I344ea13b1d90527e3e7554ec616cdc640b85159c
Signed-off-by: Sudha Bheemanna <b.sudha@samsung.com>
Signed-off-by: Seung-Woo Kim <sw0312.kim@samsung.com>
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>
---
 net/bluetooth/mgmt.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index 25be8b3..b67650b 100644
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -4599,9 +4599,14 @@ static int set_privacy(struct sock *sk, struct hci_dev *hdev, void *cp_data,
 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_PRIVACY,
 				       MGMT_STATUS_INVALID_PARAMS);
 
+#ifndef TIZEN_BT
+	/* commenting out since set privacy command is always rejected
+	 * if this condition is enabled.
+	 */
 	if (hdev_is_powered(hdev))
 		return mgmt_cmd_status(sk, hdev->id, MGMT_OP_SET_PRIVACY,
 				       MGMT_STATUS_REJECTED);
+#endif
 
 	hci_dev_lock(hdev);
 
-- 
2.7.4


From 2d9d4b3a28bed8976867354e146ee08d895a7a3e Mon Sep 17 00:00:00 2001
From: Sudha Bheemanna <b.sudha@samsung.com>
Date: Thu, 15 Sep 2016 10:12:09 +0530
Subject: [PATCH 06/16] Bluetooth: Add support to enable/disable IPSP

This patch supports MGMT commands and code to enable or disable
IPSP 6LowPan features.

Change-Id: Ia866ecfa517c7d7e4320f17d94d80dfeb9261e59
Signed-off-by: Sudha Bheemanna <b.sudha@samsung.com>
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>
---
 include/net/bluetooth/l2cap.h      | 11 +++++++++++
 include/net/bluetooth/mgmt_tizen.h |  6 ++++++
 net/bluetooth/6lowpan.c            | 34 ++++++++++++++++++++++++++++++++++
 net/bluetooth/mgmt.c               | 35 +++++++++++++++++++++++++++++++++++
 4 files changed, 86 insertions(+)

diff --git a/include/net/bluetooth/l2cap.h b/include/net/bluetooth/l2cap.h
index 9c50d45..c7abda1 100644
--- a/include/net/bluetooth/l2cap.h
+++ b/include/net/bluetooth/l2cap.h
@@ -950,4 +950,15 @@ void l2cap_conn_put(struct l2cap_conn *conn);
 int l2cap_register_user(struct l2cap_conn *conn, struct l2cap_user *user);
 void l2cap_unregister_user(struct l2cap_conn *conn, struct l2cap_user *user);
 
+#ifdef TIZEN_BT
+#ifdef CONFIG_BT_6LOWPAN
+/* IPSP : initialize/deinitialize 6lowpan */
+void bt_6lowpan_enable(void);
+void bt_6lowpan_disable(void);
+#else
+static inline void bt_6lowpan_enable(void) { }
+static inline void bt_6lowpan_disable(void) { }
+#endif
+#endif /* TIZEN_BT */
+
 #endif /* __L2CAP_H */
diff --git a/include/net/bluetooth/mgmt_tizen.h b/include/net/bluetooth/mgmt_tizen.h
index 982c00d..6549be1 100644
--- a/include/net/bluetooth/mgmt_tizen.h
+++ b/include/net/bluetooth/mgmt_tizen.h
@@ -167,6 +167,12 @@ struct mgmt_rp_get_adv_tx_power {
 	__s8	adv_tx_power;
 } __packed;
 
+#define MGMT_OP_ENABLE_6LOWPAN			(TIZEN_OP_CODE_BASE + 0x12)
+struct mgmt_cp_enable_6lowpan {
+	__u8	enable_6lowpan;
+} __packed;
+#define MGMT_ENABLE_BT_6LOWPAN_SIZE		1
+
 /* EVENTS */
 
 /* For device name update changes */
diff --git a/net/bluetooth/6lowpan.c b/net/bluetooth/6lowpan.c
index 3bfd747..b336725 100644
--- a/net/bluetooth/6lowpan.c
+++ b/net/bluetooth/6lowpan.c
@@ -1404,6 +1404,40 @@ static int __init bt_6lowpan_init(void)
 	return register_netdevice_notifier(&bt_6lowpan_dev_notifier);
 }
 
+#ifdef TIZEN_BT
+void bt_6lowpan_enable(void)
+{
+	if (!enable_6lowpan) {
+		disconnect_all_peers();
+
+		enable_6lowpan = true;
+
+		if (listen_chan) {
+			l2cap_chan_close(listen_chan, 0);
+			l2cap_chan_put(listen_chan);
+		}
+
+		listen_chan = bt_6lowpan_listen();
+
+		register_netdevice_notifier(&bt_6lowpan_dev_notifier);
+	}
+}
+
+void bt_6lowpan_disable(void)
+{
+	if (enable_6lowpan) {
+		if (listen_chan) {
+			l2cap_chan_close(listen_chan, 0);
+			l2cap_chan_put(listen_chan);
+			listen_chan = NULL;
+		}
+		disconnect_devices();
+		unregister_netdevice_notifier(&bt_6lowpan_dev_notifier);
+		enable_6lowpan = false;
+	}
+}
+#endif
+
 static void __exit bt_6lowpan_exit(void)
 {
 	debugfs_remove(lowpan_enable_debugfs);
diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index b67650b..bb4e312 100644
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -6506,6 +6506,40 @@ void mgmt_multi_adv_state_change_evt(struct hci_dev *hdev, u8 adv_instance,
 		sizeof(struct mgmt_ev_vendor_specific_multi_adv_state_changed),
 		NULL);
 }
+
+static int enable_bt_6lowpan(struct sock *sk, struct hci_dev *hdev,
+		void *data, u16 len)
+{
+	int err;
+	struct mgmt_cp_enable_6lowpan *cp = data;
+
+	BT_DBG("%s", hdev->name);
+
+	hci_dev_lock(hdev);
+
+	if (!hdev_is_powered(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ENABLE_6LOWPAN,
+				      MGMT_STATUS_NOT_POWERED);
+		goto unlocked;
+	}
+
+	if (!lmp_le_capable(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_ENABLE_6LOWPAN,
+				      MGMT_STATUS_NOT_SUPPORTED);
+		goto unlocked;
+	}
+
+	if (cp->enable_6lowpan)
+		bt_6lowpan_enable();
+	else
+		bt_6lowpan_disable();
+
+	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_ENABLE_6LOWPAN,
+				MGMT_STATUS_SUCCESS, NULL, 0);
+unlocked:
+	hci_dev_unlock(hdev);
+	return err;
+}
 #endif /* TIZEN_BT */
 
 static bool ltk_is_valid(struct mgmt_ltk_info *key)
@@ -8456,6 +8490,7 @@ static const struct hci_mgmt_handler tizen_mgmt_handlers[] = {
 	{ le_set_scan_params,      MGMT_LE_SET_SCAN_PARAMS_SIZE },
 	{ set_voice_setting,       MGMT_SET_VOICE_SETTING_SIZE },
 	{ get_adv_tx_power,        MGMT_GET_ADV_TX_POWER_SIZE },
+	{ enable_bt_6lowpan,       MGMT_ENABLE_BT_6LOWPAN_SIZE },
 };
 #endif
 
-- 
2.7.4


From 34f06a0722cdf8abcb86fcfb430bf0976096f76f Mon Sep 17 00:00:00 2001
From: Sudha Bheemanna <b.sudha@samsung.com>
Date: Thu, 15 Sep 2016 12:53:03 +0530
Subject: [PATCH 07/16] Bluetooth: IPSP Connect/Disconnect apis

This patch adds MGMT code to support IPSP connect and
disconnect apis and handle connection state changed event.

Change-Id: I1c41ec4f38cf9a108e443def3bc23c1b964e2985
Signed-off-by: Sudha Bheemanna <b.sudha@samsung.com>
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>
---
 include/net/bluetooth/hci_core.h   |   2 +
 include/net/bluetooth/l2cap.h      |   5 ++
 include/net/bluetooth/mgmt_tizen.h |  18 +++++
 net/bluetooth/6lowpan.c            |  16 ++++
 net/bluetooth/mgmt.c               | 150 +++++++++++++++++++++++++++++++++++++
 5 files changed, 191 insertions(+)

diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index 1b5d6e2..ee6d95e 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -1690,6 +1690,8 @@ void mgmt_le_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
 		u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len, u8 adv_type);
 void mgmt_multi_adv_state_change_evt(struct hci_dev *hdev, u8 adv_instance,
 		u8 state_change_reason, u16 connection_handle);
+void mgmt_6lowpan_conn_changed(struct hci_dev *hdev, char if_name[16],
+		bdaddr_t *bdaddr, u8 addr_type, bool connected);
 #endif
 
 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
diff --git a/include/net/bluetooth/l2cap.h b/include/net/bluetooth/l2cap.h
index c7abda1..312ff74 100644
--- a/include/net/bluetooth/l2cap.h
+++ b/include/net/bluetooth/l2cap.h
@@ -955,9 +955,14 @@ void l2cap_unregister_user(struct l2cap_conn *conn, struct l2cap_user *user);
 /* IPSP : initialize/deinitialize 6lowpan */
 void bt_6lowpan_enable(void);
 void bt_6lowpan_disable(void);
+/* IPSP: Connect and Disconnect */
+int _bt_6lowpan_connect(bdaddr_t *addr, u8 dst_type);
+int _bt_6lowpan_disconnect(struct l2cap_conn *conn, u8 dst_type);
 #else
 static inline void bt_6lowpan_enable(void) { }
 static inline void bt_6lowpan_disable(void) { }
+static inline int _bt_6lowpan_connect(bdaddr_t *addr, u8 dst_type) { return -ENODEV; }
+static inline int _bt_6lowpan_disconnect(struct l2cap_conn *conn, u8 dst_type) { return -ENODEV; }
 #endif
 #endif /* TIZEN_BT */
 
diff --git a/include/net/bluetooth/mgmt_tizen.h b/include/net/bluetooth/mgmt_tizen.h
index 6549be1..52a36f9 100644
--- a/include/net/bluetooth/mgmt_tizen.h
+++ b/include/net/bluetooth/mgmt_tizen.h
@@ -173,6 +173,18 @@ struct mgmt_cp_enable_6lowpan {
 } __packed;
 #define MGMT_ENABLE_BT_6LOWPAN_SIZE		1
 
+#define MGMT_OP_CONNECT_6LOWPAN			(TIZEN_OP_CODE_BASE + 0x13)
+struct mgmt_cp_connect_6lowpan {
+	struct mgmt_addr_info	addr;
+} __packed;
+#define MGMT_CONNECT_6LOWPAN_SIZE		7
+
+#define MGMT_OP_DISCONNECT_6LOWPAN		(TIZEN_OP_CODE_BASE + 0x14)
+struct mgmt_cp_disconnect_6lowpan {
+	struct	mgmt_addr_info addr;
+} __packed;
+#define MGMT_DISCONNECT_6LOWPAN_SIZE		7
+
 /* EVENTS */
 
 /* For device name update changes */
@@ -254,5 +266,11 @@ struct mgmt_ev_vendor_specific_multi_adv_state_changed {
 } __packed;
 /* LE advertisement state changed event */
 
+#define MGMT_EV_6LOWPAN_CONN_STATE_CHANGED	(TIZEN_EV_BASE + 0x0c)
+struct mgmt_ev_6lowpan_conn_state_changed {
+	struct	mgmt_addr_info addr;
+	__u8	connected;
+	__u8	ifname[16];
+} __packed;
 
 #endif	/* __MGMT_TIZEN_H */
diff --git a/net/bluetooth/6lowpan.c b/net/bluetooth/6lowpan.c
index b336725..9bd9efd 100644
--- a/net/bluetooth/6lowpan.c
+++ b/net/bluetooth/6lowpan.c
@@ -871,6 +871,12 @@ static inline void chan_ready_cb(struct l2cap_chan *chan)
 
 	add_peer_chan(chan, dev, new_netdev);
 	ifup(dev->netdev);
+
+#ifdef TIZEN_BT
+	/* IPSP: Send connection changed state info to bluez */
+	mgmt_6lowpan_conn_changed(dev->hdev, dev->netdev->name, &chan->dst,
+				  chan->dst_type, true);
+#endif
 }
 
 static inline struct l2cap_chan *chan_new_conn_cb(struct l2cap_chan *pchan)
@@ -1436,6 +1442,16 @@ void bt_6lowpan_disable(void)
 		enable_6lowpan = false;
 	}
 }
+
+int _bt_6lowpan_connect(bdaddr_t *addr, u8 dst_type)
+{
+	return bt_6lowpan_connect(addr, dst_type);
+}
+
+int _bt_6lowpan_disconnect(struct l2cap_conn *conn, u8 dst_type)
+{
+	return bt_6lowpan_disconnect(conn, dst_type);
+}
 #endif
 
 static void __exit bt_6lowpan_exit(void)
diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index bb4e312..279cb97 100644
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -6540,6 +6540,154 @@ unlocked:
 	hci_dev_unlock(hdev);
 	return err;
 }
+
+static int connect_bt_6lowpan(struct sock *sk, struct hci_dev *hdev,
+		void *data, u16 len)
+{
+	struct mgmt_cp_connect_6lowpan *cp = data;
+	__u8 addr_type = ADDR_LE_DEV_PUBLIC;
+	int err;
+
+	BT_DBG("%s", hdev->name);
+
+	hci_dev_lock(hdev);
+
+	if (!lmp_le_capable(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_CONNECT_6LOWPAN,
+				      MGMT_STATUS_NOT_SUPPORTED);
+		goto unlocked;
+	}
+
+	if (!hdev_is_powered(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_CONNECT_6LOWPAN,
+				      MGMT_STATUS_REJECTED);
+		goto unlocked;
+	}
+
+	if (bdaddr_type_is_le(cp->addr.type)) {
+		if (cp->addr.type == BDADDR_LE_PUBLIC)
+			addr_type = ADDR_LE_DEV_PUBLIC;
+		else
+			addr_type = ADDR_LE_DEV_RANDOM;
+	} else {
+		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_CONNECT_6LOWPAN,
+					MGMT_STATUS_INVALID_PARAMS, NULL, 0);
+		goto unlocked;
+	}
+
+	hci_dev_unlock(hdev);
+
+	/* 6lowpan Connect */
+	err = _bt_6lowpan_connect(&cp->addr.bdaddr, cp->addr.type);
+
+	hci_dev_lock(hdev);
+
+	if (err < 0) {
+		err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_CONNECT_6LOWPAN,
+					MGMT_STATUS_REJECTED, NULL, 0);
+
+		goto unlocked;
+	}
+
+	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_CONNECT_6LOWPAN, 0,
+				NULL, 0);
+unlocked:
+	hci_dev_unlock(hdev);
+	return err;
+}
+
+static int disconnect_bt_6lowpan(struct sock *sk, struct hci_dev *hdev,
+		void *data, u16 len)
+{
+	struct mgmt_cp_disconnect_6lowpan *cp = data;
+	struct hci_conn *conn = NULL;
+	__u8 addr_type = ADDR_LE_DEV_PUBLIC;
+	int err;
+
+	BT_DBG("%s", hdev->name);
+
+	hci_dev_lock(hdev);
+
+	if (!lmp_le_capable(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_DISCONNECT_6LOWPAN,
+				      MGMT_STATUS_NOT_SUPPORTED);
+		goto unlocked;
+	}
+
+	if (!hdev_is_powered(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_DISCONNECT_6LOWPAN,
+				      MGMT_STATUS_REJECTED);
+		goto unlocked;
+	}
+
+	if (bdaddr_type_is_le(cp->addr.type)) {
+		if (cp->addr.type == BDADDR_LE_PUBLIC)
+			addr_type = ADDR_LE_DEV_PUBLIC;
+		else
+			addr_type = ADDR_LE_DEV_RANDOM;
+	} else {
+		err = mgmt_cmd_complete(sk, hdev->id,
+					MGMT_OP_DISCONNECT_6LOWPAN,
+					MGMT_STATUS_INVALID_PARAMS, NULL, 0);
+		goto unlocked;
+	}
+
+	conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &cp->addr.bdaddr);
+	if (!conn) {
+		err = mgmt_cmd_complete(sk, hdev->id,
+					MGMT_OP_DISCONNECT_6LOWPAN,
+					MGMT_STATUS_NOT_CONNECTED, NULL, 0);
+		goto unlocked;
+	}
+
+	if (conn->dst_type != addr_type) {
+		err = mgmt_cmd_complete(sk, hdev->id,
+					MGMT_OP_DISCONNECT_6LOWPAN,
+					MGMT_STATUS_INVALID_PARAMS, NULL, 0);
+		goto unlocked;
+	}
+
+	if (conn->state != BT_CONNECTED) {
+		err = mgmt_cmd_complete(sk, hdev->id,
+					MGMT_OP_DISCONNECT_6LOWPAN,
+					MGMT_STATUS_NOT_CONNECTED, NULL, 0);
+		goto unlocked;
+	}
+
+	/* 6lowpan Disconnect */
+	err = _bt_6lowpan_disconnect(conn->l2cap_data, cp->addr.type);
+	if (err < 0) {
+		err = mgmt_cmd_complete(sk, hdev->id,
+					MGMT_OP_DISCONNECT_6LOWPAN,
+					MGMT_STATUS_REJECTED, NULL, 0);
+		goto unlocked;
+	}
+
+	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_CONNECT_6LOWPAN, 0,
+				NULL, 0);
+
+unlocked:
+	hci_dev_unlock(hdev);
+	return err;
+}
+
+void mgmt_6lowpan_conn_changed(struct hci_dev *hdev, char if_name[16],
+		bdaddr_t *bdaddr, u8 addr_type, bool connected)
+{
+	char buf[512];
+	struct mgmt_ev_6lowpan_conn_state_changed *ev = (void *)buf;
+	size_t ev_size;
+
+	memset(buf, 0, sizeof(buf));
+	bacpy(&ev->addr.bdaddr, bdaddr);
+	ev->addr.type = addr_type;
+	ev->connected = connected;
+	memcpy(ev->ifname, (__u8 *)if_name, 16);
+
+	ev_size = sizeof(*ev);
+
+	mgmt_event(MGMT_EV_6LOWPAN_CONN_STATE_CHANGED, hdev, ev, ev_size, NULL);
+}
 #endif /* TIZEN_BT */
 
 static bool ltk_is_valid(struct mgmt_ltk_info *key)
@@ -8491,6 +8639,8 @@ static const struct hci_mgmt_handler tizen_mgmt_handlers[] = {
 	{ set_voice_setting,       MGMT_SET_VOICE_SETTING_SIZE },
 	{ get_adv_tx_power,        MGMT_GET_ADV_TX_POWER_SIZE },
 	{ enable_bt_6lowpan,       MGMT_ENABLE_BT_6LOWPAN_SIZE },
+	{ connect_bt_6lowpan,      MGMT_CONNECT_6LOWPAN_SIZE },
+	{ disconnect_bt_6lowpan,   MGMT_DISCONNECT_6LOWPAN_SIZE },
 };
 #endif
 
-- 
2.7.4


From 833c0356e813e29aefeb55b2584b4bbbdfce71fc Mon Sep 17 00:00:00 2001
From: "h.sandeep" <h.sandeep@samsung.com>
Date: Fri, 16 Sep 2016 14:45:24 +0530
Subject: [PATCH 08/16] Bluetooth: Fix IPSP connection callback event issue.

This patch fixes the IPSP connection callback event issue
between kernel and bluez layer.

Change-Id: Ia4d625aa8a6dbc9da89a7d9f12308af9c90d0594
Signed-off-by: h.sandeep <h.sandeep@samsung.com>
Signed-off-by: Sudha Bheemanna <b.sudha@samsung.com>
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>
---
 net/bluetooth/l2cap_core.c | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/net/bluetooth/l2cap_core.c b/net/bluetooth/l2cap_core.c
index b96818c..c7ce0d5 100644
--- a/net/bluetooth/l2cap_core.c
+++ b/net/bluetooth/l2cap_core.c
@@ -1262,8 +1262,23 @@ static void l2cap_chan_ready(struct l2cap_chan *chan)
 	 * case of receiving data before the L2CAP info req/rsp
 	 * procedure is complete.
 	 */
+#ifndef TIZEN_BT
 	if (chan->state == BT_CONNECTED)
 		return;
+#else
+	if (chan->state == BT_CONNECTED) {
+		if (chan->psm == L2CAP_PSM_IPSP) {
+			struct l2cap_conn *conn = chan->conn;
+
+			if (conn->hcon->out)
+				return;
+			else if (conn->hcon->type != LE_LINK)
+				return;
+		} else {
+			return;
+		}
+	}
+#endif
 
 	/* This clears all conf flags, including CONF_NOT_COMPLETE */
 	chan->conf_state = 0;
@@ -6894,8 +6909,23 @@ static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid,
 	 * procdure is done simply assume that the channel is supported
 	 * and mark it as ready.
 	 */
+#ifndef TIZEN_BT
 	if (chan->chan_type == L2CAP_CHAN_FIXED)
 		l2cap_chan_ready(chan);
+#else
+	if (chan->chan_type == L2CAP_CHAN_FIXED) {
+		if (chan->psm == L2CAP_PSM_IPSP) {
+			struct l2cap_conn *conn = chan->conn;
+
+			if (conn->hcon->out)
+				l2cap_chan_ready(chan);
+			else if (conn->hcon->type != LE_LINK)
+				l2cap_chan_ready(chan);
+		} else {
+			l2cap_chan_ready(chan);
+		}
+	}
+#endif
 
 	if (chan->state != BT_CONNECTED)
 		goto drop;
-- 
2.7.4


From 8fc9276a1e356610e2df9fbd565338522cc0694f Mon Sep 17 00:00:00 2001
From: Sudha Bheemanna <b.sudha@samsung.com>
Date: Fri, 16 Sep 2016 10:38:30 +0530
Subject: [PATCH 09/16] Bluetooth: Read LE Max data length command

This patch adds the MGMT command and code to support reading
the maximum data length supported command for LE.

Change-Id: I4dc0041f2070de2ccb6a4164c8823612863c941e
Signed-off-by: Sudha Bheemanna <b.sudha@samsung.com>
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>
---
 include/net/bluetooth/hci_core.h   |  2 +
 include/net/bluetooth/mgmt_tizen.h |  9 +++++
 net/bluetooth/hci_event.c          |  9 +++++
 net/bluetooth/mgmt.c               | 79 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 99 insertions(+)

diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index ee6d95e..4fc5f3e 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -1692,6 +1692,8 @@ void mgmt_multi_adv_state_change_evt(struct hci_dev *hdev, u8 adv_instance,
 		u8 state_change_reason, u16 connection_handle);
 void mgmt_6lowpan_conn_changed(struct hci_dev *hdev, char if_name[16],
 		bdaddr_t *bdaddr, u8 addr_type, bool connected);
+void mgmt_le_read_maximum_data_length_complete(struct hci_dev *hdev,
+		u8 status);
 #endif
 
 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
diff --git a/include/net/bluetooth/mgmt_tizen.h b/include/net/bluetooth/mgmt_tizen.h
index 52a36f9..444d793 100644
--- a/include/net/bluetooth/mgmt_tizen.h
+++ b/include/net/bluetooth/mgmt_tizen.h
@@ -185,6 +185,15 @@ struct mgmt_cp_disconnect_6lowpan {
 } __packed;
 #define MGMT_DISCONNECT_6LOWPAN_SIZE		7
 
+#define MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH	(TIZEN_OP_CODE_BASE + 0x15)
+struct mgmt_rp_le_read_maximum_data_length {
+	__le16	max_tx_octets;
+	__le16	max_tx_time;
+	__le16	max_rx_octets;
+	__le16	max_rx_time;
+} __packed;
+#define MGMT_LE_READ_MAXIMUM_DATA_LENGTH_SIZE	0
+
 /* EVENTS */
 
 /* For device name update changes */
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index feb1d7e..40dbcdd 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -1351,13 +1351,22 @@ static void hci_cc_le_read_max_data_len(struct hci_dev *hdev,
 
 	BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
 
+#ifndef TIZEN_BT
 	if (rp->status)
 		return;
+#else
+	hci_dev_lock(hdev);
+#endif
 
 	hdev->le_max_tx_len = le16_to_cpu(rp->tx_len);
 	hdev->le_max_tx_time = le16_to_cpu(rp->tx_time);
 	hdev->le_max_rx_len = le16_to_cpu(rp->rx_len);
 	hdev->le_max_rx_time = le16_to_cpu(rp->rx_time);
+
+#ifdef TIZEN_BT
+	mgmt_le_read_maximum_data_length_complete(hdev, rp->status);
+	hci_dev_unlock(hdev);
+#endif
 }
 
 static void hci_cc_write_le_host_supported(struct hci_dev *hdev,
diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index 279cb97..366c1ce4 100644
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -6688,6 +6688,83 @@ void mgmt_6lowpan_conn_changed(struct hci_dev *hdev, char if_name[16],
 
 	mgmt_event(MGMT_EV_6LOWPAN_CONN_STATE_CHANGED, hdev, ev, ev_size, NULL);
 }
+
+void mgmt_le_read_maximum_data_length_complete(struct hci_dev *hdev, u8 status)
+{
+	struct mgmt_pending_cmd *cmd;
+	struct mgmt_rp_le_read_maximum_data_length rp;
+
+	BT_DBG("%s status %u", hdev->name, status);
+
+	cmd = pending_find(MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH, hdev);
+	if (!cmd)
+		return;
+
+	if (status)
+		mgmt_cmd_status(cmd->sk, hdev->id,
+				MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH,
+				mgmt_status(status));
+
+	memset(&rp, 0, sizeof(rp));
+
+	rp.max_tx_octets = cpu_to_le16(hdev->le_max_tx_len);
+	rp.max_tx_time = cpu_to_le16(hdev->le_max_tx_time);
+	rp.max_rx_octets = cpu_to_le16(hdev->le_max_rx_len);
+	rp.max_rx_time = cpu_to_le16(hdev->le_max_rx_time);
+
+	mgmt_cmd_complete(cmd->sk, hdev->id,
+			  MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH, 0,
+			  &rp, sizeof(rp));
+
+	mgmt_pending_remove(cmd);
+}
+
+static int read_maximum_le_data_length(struct sock *sk,
+		struct hci_dev *hdev, void *data, u16 len)
+{
+	struct mgmt_pending_cmd *cmd;
+	int err;
+
+	BT_DBG("read_maximum_le_data_length  %s", hdev->name);
+
+	hci_dev_lock(hdev);
+
+	if (!hdev_is_powered(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id,
+				      MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH,
+				      MGMT_STATUS_NOT_POWERED);
+		goto unlock;
+	}
+
+	if (!lmp_le_capable(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id,
+				      MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH,
+				      MGMT_STATUS_NOT_SUPPORTED);
+		goto unlock;
+	}
+
+	if (pending_find(MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH, hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id,
+				      MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH,
+				      MGMT_STATUS_BUSY);
+		goto unlock;
+	}
+
+	cmd = mgmt_pending_add(sk, MGMT_OP_LE_READ_MAXIMUM_DATA_LENGTH,
+			       hdev, data, len);
+	if (!cmd) {
+		err = -ENOMEM;
+		goto unlock;
+	}
+
+	err = hci_send_cmd(hdev, HCI_OP_LE_READ_MAX_DATA_LEN, 0, NULL);
+	if (err < 0)
+		mgmt_pending_remove(cmd);
+
+unlock:
+	hci_dev_unlock(hdev);
+	return err;
+}
 #endif /* TIZEN_BT */
 
 static bool ltk_is_valid(struct mgmt_ltk_info *key)
@@ -8641,6 +8718,8 @@ static const struct hci_mgmt_handler tizen_mgmt_handlers[] = {
 	{ enable_bt_6lowpan,       MGMT_ENABLE_BT_6LOWPAN_SIZE },
 	{ connect_bt_6lowpan,      MGMT_CONNECT_6LOWPAN_SIZE },
 	{ disconnect_bt_6lowpan,   MGMT_DISCONNECT_6LOWPAN_SIZE },
+	{ read_maximum_le_data_length,
+				   MGMT_LE_READ_MAXIMUM_DATA_LENGTH_SIZE },
 };
 #endif
 
-- 
2.7.4


From 07a3271b1bf9882d9841d4fcdae3852758377aa1 Mon Sep 17 00:00:00 2001
From: Sudha Bheemanna <b.sudha@samsung.com>
Date: Fri, 16 Sep 2016 12:09:57 +0530
Subject: [PATCH 10/16] Bluetooth: Write host suggested default le data length

This patch adds MGMT command and code for supporting write
default le data length command to the controller.

Change-Id: I3d2c8b622b7913a3ed542342e3ba8076c30dc279
Signed-off-by: Sudha Bheemanna <b.sudha@samsung.com>
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>
---
 include/net/bluetooth/hci_core.h   |  2 +
 include/net/bluetooth/mgmt_tizen.h |  7 ++++
 net/bluetooth/hci_event.c          | 13 ++++++
 net/bluetooth/mgmt.c               | 86 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 108 insertions(+)

diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index 4fc5f3e..bc05106 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -1694,6 +1694,8 @@ void mgmt_6lowpan_conn_changed(struct hci_dev *hdev, char if_name[16],
 		bdaddr_t *bdaddr, u8 addr_type, bool connected);
 void mgmt_le_read_maximum_data_length_complete(struct hci_dev *hdev,
 		u8 status);
+void mgmt_le_write_host_suggested_data_length_complete(struct hci_dev *hdev,
+		u8 status);
 #endif
 
 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
diff --git a/include/net/bluetooth/mgmt_tizen.h b/include/net/bluetooth/mgmt_tizen.h
index 444d793..0f36ecd 100644
--- a/include/net/bluetooth/mgmt_tizen.h
+++ b/include/net/bluetooth/mgmt_tizen.h
@@ -194,6 +194,13 @@ struct mgmt_rp_le_read_maximum_data_length {
 } __packed;
 #define MGMT_LE_READ_MAXIMUM_DATA_LENGTH_SIZE	0
 
+#define MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH	(TIZEN_OP_CODE_BASE + 0x16)
+struct mgmt_cp_le_write_host_suggested_data_length {
+	__le16	def_tx_octets;
+	__le16	def_tx_time;
+} __packed;
+#define MGMT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH_SIZE	4
+
 /* EVENTS */
 
 /* For device name update changes */
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 40dbcdd..0649dc1 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -1334,14 +1334,27 @@ static void hci_cc_le_write_def_data_len(struct hci_dev *hdev,
 	BT_DBG("%s status 0x%2.2x", hdev->name, status);
 
 	if (status)
+#ifndef TIZEN_BT
 		return;
+#else
+		goto unblock;
+#endif
 
 	sent = hci_sent_cmd_data(hdev, HCI_OP_LE_WRITE_DEF_DATA_LEN);
 	if (!sent)
+#ifndef TIZEN_BT
 		return;
+#else
+		goto unblock;
+#endif
 
 	hdev->le_def_tx_len = le16_to_cpu(sent->tx_len);
 	hdev->le_def_tx_time = le16_to_cpu(sent->tx_time);
+
+#ifdef TIZEN_BT
+unblock:
+	mgmt_le_write_host_suggested_data_length_complete(hdev, status);
+#endif
 }
 
 static void hci_cc_le_read_max_data_len(struct hci_dev *hdev,
diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index 366c1ce4..fbe2b96 100644
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -6765,6 +6765,90 @@ unlock:
 	hci_dev_unlock(hdev);
 	return err;
 }
+
+void mgmt_le_write_host_suggested_data_length_complete(struct hci_dev *hdev,
+		u8 status)
+{
+	struct mgmt_pending_cmd *cmd;
+
+	BT_DBG("status 0x%02x", status);
+
+	hci_dev_lock(hdev);
+
+	cmd = pending_find(MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH, hdev);
+	if (!cmd) {
+		BT_ERR("cmd not found in the pending list");
+		goto unlock;
+	}
+
+	if (status)
+		mgmt_cmd_status(cmd->sk, hdev->id,
+				MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
+				mgmt_status(status));
+	else
+		mgmt_cmd_complete(cmd->sk, hdev->id,
+				  MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
+				  0, NULL, 0);
+
+	mgmt_pending_remove(cmd);
+
+unlock:
+	hci_dev_unlock(hdev);
+}
+
+static int write_host_suggested_le_data_length(struct sock *sk,
+		struct hci_dev *hdev, void *data, u16 len)
+{
+	struct mgmt_pending_cmd *cmd;
+	struct mgmt_cp_le_write_host_suggested_data_length *cp = data;
+	struct hci_cp_le_write_def_data_len hci_data;
+	int err = 0;
+
+	BT_DBG("Write host suggested data length request for %s", hdev->name);
+
+	hci_dev_lock(hdev);
+
+	if (!hdev_is_powered(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id,
+				MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
+				MGMT_STATUS_NOT_POWERED);
+		goto unlock;
+	}
+
+	if (!lmp_le_capable(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id,
+				MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
+				MGMT_STATUS_NOT_SUPPORTED);
+		goto unlock;
+	}
+
+	if (pending_find(MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH, hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id,
+				MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
+				MGMT_STATUS_BUSY);
+		goto unlock;
+	}
+
+	cmd = mgmt_pending_add(sk, MGMT_OP_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
+			       hdev, data, len);
+	if (!cmd) {
+		err = -ENOMEM;
+		goto unlock;
+	}
+
+	hci_data.tx_len = cp->def_tx_octets;
+	hci_data.tx_time = cp->def_tx_time;
+
+	err = hci_send_cmd(hdev, HCI_OP_LE_WRITE_DEF_DATA_LEN,
+			   sizeof(hci_data), &hci_data);
+	if (err < 0)
+		mgmt_pending_remove(cmd);
+
+unlock:
+	hci_dev_unlock(hdev);
+
+	return err;
+}
 #endif /* TIZEN_BT */
 
 static bool ltk_is_valid(struct mgmt_ltk_info *key)
@@ -8720,6 +8804,8 @@ static const struct hci_mgmt_handler tizen_mgmt_handlers[] = {
 	{ disconnect_bt_6lowpan,   MGMT_DISCONNECT_6LOWPAN_SIZE },
 	{ read_maximum_le_data_length,
 				   MGMT_LE_READ_MAXIMUM_DATA_LENGTH_SIZE },
+	{ write_host_suggested_le_data_length,
+				   MGMT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH_SIZE },
 };
 #endif
 
-- 
2.7.4


From 61562387b732862d01b3070ec6faffac145ba85d Mon Sep 17 00:00:00 2001
From: Sudha Bheemanna <b.sudha@samsung.com>
Date: Fri, 16 Sep 2016 12:54:31 +0530
Subject: [PATCH 11/16] Bluetooth: Read host suggested default le data length

This patch adds MGMT command and code for supporting reading
default le data length value set at the controller.

Change-Id: I2b81982dc26ed5af4a8f8a3d3913db5d64625260
Signed-off-by: Sudha Bheemanna <b.sudha@samsung.com>
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>
---
 include/net/bluetooth/hci_core.h   |  2 +
 include/net/bluetooth/mgmt_tizen.h |  7 ++++
 net/bluetooth/hci_event.c          | 10 +++++
 net/bluetooth/mgmt.c               | 81 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 100 insertions(+)

diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index bc05106..a00527c 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -1696,6 +1696,8 @@ void mgmt_le_read_maximum_data_length_complete(struct hci_dev *hdev,
 		u8 status);
 void mgmt_le_write_host_suggested_data_length_complete(struct hci_dev *hdev,
 		u8 status);
+void mgmt_le_read_host_suggested_data_length_complete(struct hci_dev *hdev,
+		u8 status);
 #endif
 
 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
diff --git a/include/net/bluetooth/mgmt_tizen.h b/include/net/bluetooth/mgmt_tizen.h
index 0f36ecd..2d11d5b 100644
--- a/include/net/bluetooth/mgmt_tizen.h
+++ b/include/net/bluetooth/mgmt_tizen.h
@@ -201,6 +201,13 @@ struct mgmt_cp_le_write_host_suggested_data_length {
 } __packed;
 #define MGMT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH_SIZE	4
 
+#define MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH	(TIZEN_OP_CODE_BASE + 0x17)
+struct mgmt_rp_le_read_host_suggested_data_length {
+	__le16	def_tx_octets;
+	__le16	def_tx_time;
+} __packed;
+#define MGMT_LE_READ_HOST_SUGGESTED_DATA_LENGTH_SIZE	0
+
 /* EVENTS */
 
 /* For device name update changes */
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 0649dc1..5418481 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -1318,11 +1318,21 @@ static void hci_cc_le_read_def_data_len(struct hci_dev *hdev,
 
 	BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
 
+#ifdef TIZEN_BT
+	hci_dev_lock(hdev);
+#else
 	if (rp->status)
 		return;
+#endif
 
 	hdev->le_def_tx_len = le16_to_cpu(rp->tx_len);
 	hdev->le_def_tx_time = le16_to_cpu(rp->tx_time);
+
+#ifdef TIZEN_BT
+	mgmt_le_read_host_suggested_data_length_complete(hdev, rp->status);
+
+	hci_dev_unlock(hdev);
+#endif
 }
 
 static void hci_cc_le_write_def_data_len(struct hci_dev *hdev,
diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index fbe2b96..2609b95 100644
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -6849,6 +6849,85 @@ unlock:
 
 	return err;
 }
+
+void mgmt_le_read_host_suggested_data_length_complete(struct hci_dev *hdev,
+		u8 status)
+{
+	struct mgmt_pending_cmd *cmd;
+	struct mgmt_rp_le_read_host_suggested_data_length rp;
+
+	BT_DBG("%s status %u", hdev->name, status);
+
+	cmd = pending_find(MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH, hdev);
+	if (!cmd) {
+		BT_ERR("cmd not found in the pending list");
+		return;
+	}
+
+	if (status)
+		mgmt_cmd_status(cmd->sk, hdev->id,
+			MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
+			mgmt_status(status));
+
+	memset(&rp, 0, sizeof(rp));
+
+	rp.def_tx_octets = cpu_to_le16(hdev->le_def_tx_len);
+	rp.def_tx_time = cpu_to_le16(hdev->le_def_tx_time);
+
+	mgmt_cmd_complete(cmd->sk, hdev->id,
+			  MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH, 0,
+			  &rp, sizeof(rp));
+
+	mgmt_pending_remove(cmd);
+}
+
+static int read_host_suggested_data_length(struct sock *sk,
+		struct hci_dev *hdev, void *data, u16 len)
+{
+	struct mgmt_pending_cmd *cmd;
+	int err;
+
+	BT_DBG("read_host_suggested_data_length %s", hdev->name);
+
+	hci_dev_lock(hdev);
+
+	if (!hdev_is_powered(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id,
+				MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
+				MGMT_STATUS_NOT_POWERED);
+		goto unlock;
+	}
+
+	if (!lmp_le_capable(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id,
+				MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
+				MGMT_STATUS_NOT_SUPPORTED);
+		goto unlock;
+	}
+
+	if (pending_find(MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH, hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id,
+				MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
+				MGMT_STATUS_BUSY);
+		goto unlock;
+	}
+
+	cmd = mgmt_pending_add(sk, MGMT_OP_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
+			       hdev, data, len);
+	if (!cmd) {
+		err = -ENOMEM;
+		goto unlock;
+	}
+
+	err = hci_send_cmd(hdev, HCI_OP_LE_READ_DEF_DATA_LEN, 0, NULL);
+	if (err < 0)
+		mgmt_pending_remove(cmd);
+
+unlock:
+	hci_dev_unlock(hdev);
+
+	return err;
+}
 #endif /* TIZEN_BT */
 
 static bool ltk_is_valid(struct mgmt_ltk_info *key)
@@ -8806,6 +8885,8 @@ static const struct hci_mgmt_handler tizen_mgmt_handlers[] = {
 				   MGMT_LE_READ_MAXIMUM_DATA_LENGTH_SIZE },
 	{ write_host_suggested_le_data_length,
 				   MGMT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH_SIZE },
+	{ read_host_suggested_data_length,
+				   MGMT_LE_READ_HOST_SUGGESTED_DATA_LENGTH_SIZE },
 };
 #endif
 
-- 
2.7.4


From ace75290740e921b99ded4ad3f865f5f510dea0b Mon Sep 17 00:00:00 2001
From: Sudha Bheemanna <b.sudha@samsung.com>
Date: Fri, 16 Sep 2016 15:37:22 +0530
Subject: [PATCH 12/16] Bluetooth: Set le data length command and event

Sets the data length for the le data packet with in the
advised limits. MGMT command and event are added to handle
the setting of data length.

Change-Id: Ia5c2167743cc9a29190e5631973e9d52d41caa1d
Signed-off-by: Sudha Bheemanna <b.sudha@samsung.com>
Signed-off-by: Amit Purwar <amit.purwar@samsung.com>
---
 include/net/bluetooth/hci_core.h   | 14 ++++++
 include/net/bluetooth/mgmt_tizen.h | 23 +++++++++
 net/bluetooth/hci_conn.c           | 29 ++++++++++++
 net/bluetooth/hci_event.c          | 31 ++++++++++++-
 net/bluetooth/mgmt.c               | 95 ++++++++++++++++++++++++++++++++++++++
 5 files changed, 191 insertions(+), 1 deletion(-)

diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index a00527c..b51a31a 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -494,6 +494,12 @@ struct hci_conn {
 	__u8		remote_id;
 
 	unsigned int	sent;
+#ifdef TIZEN_BT
+	__u16		tx_len;
+	__u16		tx_time;
+	__u16		rx_len;
+	__u16		rx_time;
+#endif
 
 	struct sk_buff_head data_q;
 	struct list_head chan_list;
@@ -545,6 +551,10 @@ struct hci_conn_params {
 	u16 conn_latency;
 	u16 supervision_timeout;
 
+#ifdef TIZEN_BT
+	u16 max_tx_octets;
+	u16 max_tx_time;
+#endif
 	enum {
 		HCI_AUTO_CONN_DISABLED,
 		HCI_AUTO_CONN_REPORT,
@@ -1698,6 +1708,10 @@ void mgmt_le_write_host_suggested_data_length_complete(struct hci_dev *hdev,
 		u8 status);
 void mgmt_le_read_host_suggested_data_length_complete(struct hci_dev *hdev,
 		u8 status);
+void mgmt_le_data_length_change_complete(struct hci_dev *hdev,
+		bdaddr_t *bdaddr, u16 tx_octets, u16 tx_time,
+		u16 rx_octets, u16 rx_time);
+int hci_le_set_data_length(struct hci_conn *conn, u16 tx_octets, u16 tx_time);
 #endif
 
 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
diff --git a/include/net/bluetooth/mgmt_tizen.h b/include/net/bluetooth/mgmt_tizen.h
index 2d11d5b..cfb9d50 100644
--- a/include/net/bluetooth/mgmt_tizen.h
+++ b/include/net/bluetooth/mgmt_tizen.h
@@ -208,6 +208,20 @@ struct mgmt_rp_le_read_host_suggested_data_length {
 } __packed;
 #define MGMT_LE_READ_HOST_SUGGESTED_DATA_LENGTH_SIZE	0
 
+#define MGMT_OP_LE_SET_DATA_LENGTH		(TIZEN_OP_CODE_BASE + 0x18)
+struct mgmt_cp_le_set_data_length {
+	bdaddr_t	bdaddr;
+	__le16	max_tx_octets;
+	__le16	max_tx_time;
+} __packed;
+#define MGMT_LE_SET_DATA_LENGTH_SIZE		10
+
+struct mgmt_rp_le_set_data_length {
+	__u8	status;
+	__le16	handle;
+} __packed;
+#define MGMT_LE_SET_DATA_LENGTH_RSP_SIZE	3
+
 /* EVENTS */
 
 /* For device name update changes */
@@ -296,4 +310,13 @@ struct mgmt_ev_6lowpan_conn_state_changed {
 	__u8	ifname[16];
 } __packed;
 
+#define MGMT_EV_LE_DATA_LENGTH_CHANGED		(TIZEN_EV_BASE + 0x0d)
+struct mgmt_ev_le_data_length_changed {
+	struct	mgmt_addr_info addr;
+	__le16	max_tx_octets;
+	__le16	max_tx_time;
+	__le16	max_rx_octets;
+	__le16	max_rx_time;
+} __packed;
+
 #endif	/* __MGMT_TIZEN_H */
diff --git a/net/bluetooth/hci_conn.c b/net/bluetooth/hci_conn.c
index e64f0b3..ea94d77 100644
--- a/net/bluetooth/hci_conn.c
+++ b/net/bluetooth/hci_conn.c
@@ -1407,6 +1407,35 @@ int hci_conn_change_supervision_timeout(struct hci_conn *conn, __u16 timeout)
 
 	return 0;
 }
+
+int hci_le_set_data_length(struct hci_conn *conn, u16 tx_octets, u16 tx_time)
+{
+	struct hci_dev *hdev = conn->hdev;
+	struct hci_conn_params *params;
+	struct hci_cp_le_set_data_len cp;
+
+	hci_dev_lock(hdev);
+
+	params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
+	if (params) {
+		params->max_tx_octets = tx_octets;
+		params->max_tx_time = tx_time;
+	}
+
+	hci_dev_unlock(hdev);
+
+	memset(&cp, 0, sizeof(cp));
+	cp.handle = cpu_to_le16(conn->handle);
+	cp.tx_len = cpu_to_le16(tx_octets);
+	cp.tx_time = cpu_to_le16(tx_time);
+
+	hci_send_cmd(hdev, HCI_OP_LE_SET_DATA_LEN, sizeof(cp), &cp);
+
+	if (params)
+		return 0x01;
+
+	return 0x00;
+}
 #endif
 
 /* Enter active mode */
diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c
index 5418481..051f77b 100644
--- a/net/bluetooth/hci_event.c
+++ b/net/bluetooth/hci_event.c
@@ -1536,6 +1536,31 @@ static void hci_vendor_specific_evt(struct hci_dev *hdev, struct sk_buff *skb)
 		break;
 	}
 }
+
+static void hci_le_data_length_changed_complete_evt(struct hci_dev *hdev,
+		struct sk_buff *skb)
+{
+	struct hci_ev_le_data_len_change *ev = (void *)skb->data;
+	struct hci_conn *conn;
+
+	BT_DBG("%s status", hdev->name);
+
+	hci_dev_lock(hdev);
+
+	conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
+	if (conn) {
+		conn->tx_len = le16_to_cpu(ev->tx_len);
+		conn->tx_time = le16_to_cpu(ev->tx_time);
+		conn->rx_len = le16_to_cpu(ev->rx_len);
+		conn->rx_time = le16_to_cpu(ev->rx_time);
+
+		mgmt_le_data_length_change_complete(hdev, &conn->dst,
+					    conn->tx_len, conn->tx_time,
+					    conn->rx_len, conn->rx_time);
+	}
+
+	hci_dev_unlock(hdev);
+}
 #endif
 
 static void hci_cc_read_rssi(struct hci_dev *hdev, struct sk_buff *skb)
@@ -5463,7 +5488,11 @@ static void hci_le_meta_evt(struct hci_dev *hdev, struct sk_buff *skb)
 	case HCI_EV_LE_DIRECT_ADV_REPORT:
 		hci_le_direct_adv_report_evt(hdev, skb);
 		break;
-
+#ifdef TIZEN_BT
+	case HCI_EV_LE_DATA_LEN_CHANGE:
+		hci_le_data_length_changed_complete_evt(hdev, skb);
+		break;
+#endif
 	default:
 		break;
 	}
diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index 2609b95..7a398d9 100644
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -6928,6 +6928,99 @@ unlock:
 
 	return err;
 }
+
+static int set_le_data_length_params(struct sock *sk, struct hci_dev *hdev,
+		void *data, u16 len)
+{
+	struct mgmt_cp_le_set_data_length *cp = data;
+	struct mgmt_rp_le_set_data_length *rp;
+	struct mgmt_pending_cmd *cmd;
+	struct hci_conn *conn;
+	int err = 0;
+	u16 max_tx_octets, max_tx_time;
+	size_t rp_len;
+
+	BT_INFO("Set Data length for the device %s", hdev->name);
+
+	hci_dev_lock(hdev);
+
+	rp_len = sizeof(*rp);
+	rp = kmalloc(rp_len, GFP_KERNEL);
+	if (!rp) {
+		err = -ENOMEM;
+		goto unlock;
+	}
+
+	if (!hdev_is_powered(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_LE_SET_DATA_LENGTH,
+				      MGMT_STATUS_NOT_POWERED);
+		goto unlock;
+	}
+
+	if (!lmp_le_capable(hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_LE_SET_DATA_LENGTH,
+				      MGMT_STATUS_NOT_SUPPORTED);
+		goto unlock;
+	}
+
+	if (pending_find(MGMT_OP_LE_SET_DATA_LENGTH, hdev)) {
+		err = mgmt_cmd_status(sk, hdev->id, MGMT_OP_LE_SET_DATA_LENGTH,
+				      MGMT_STATUS_BUSY);
+		goto unlock;
+	}
+
+	cmd = mgmt_pending_add(sk, MGMT_OP_LE_SET_DATA_LENGTH, hdev, data, len);
+	if (!cmd) {
+		err = -ENOMEM;
+		goto unlock;
+	}
+
+	max_tx_octets = __le16_to_cpu(cp->max_tx_octets);
+	max_tx_time = __le16_to_cpu(cp->max_tx_time);
+
+	BT_DBG("max_tx_octets 0x%4.4x max_tx_time 0x%4.4x latency",
+	       max_tx_octets, max_tx_time);
+
+	conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, &cp->bdaddr);
+	if (!conn) {
+		mgmt_cmd_status(sk, hdev->id, MGMT_OP_LE_SET_DATA_LENGTH,
+				MGMT_STATUS_NOT_CONNECTED);
+		goto unlock;
+	}
+
+	hci_dev_unlock(hdev);
+
+	err = hci_le_set_data_length(conn, max_tx_octets, max_tx_time);
+	if (err < 0)
+		mgmt_pending_remove(cmd);
+
+	rp->handle = conn->handle;
+	rp->status = 0;
+
+	hci_dev_lock(hdev);
+	err = mgmt_cmd_complete(sk, hdev->id, MGMT_OP_LE_SET_DATA_LENGTH, 0,
+				rp, rp_len);
+unlock:
+	kfree(rp);
+	hci_dev_unlock(hdev);
+
+	return err;
+}
+
+void mgmt_le_data_length_change_complete(struct hci_dev *hdev,
+		bdaddr_t *bdaddr, u16 tx_octets, u16 tx_time,
+		u16 rx_octets, u16 rx_time)
+{
+	struct mgmt_ev_le_data_length_changed ev;
+
+	bacpy(&ev.addr.bdaddr, bdaddr);
+	ev.max_tx_octets = tx_octets;
+	ev.max_tx_time = tx_time;
+	ev.max_rx_octets = rx_octets;
+	ev.max_rx_time = rx_time;
+
+	mgmt_event(MGMT_EV_LE_DATA_LENGTH_CHANGED, hdev, &ev, sizeof(ev), NULL);
+}
 #endif /* TIZEN_BT */
 
 static bool ltk_is_valid(struct mgmt_ltk_info *key)
@@ -8887,6 +8980,8 @@ static const struct hci_mgmt_handler tizen_mgmt_handlers[] = {
 				   MGMT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH_SIZE },
 	{ read_host_suggested_data_length,
 				   MGMT_LE_READ_HOST_SUGGESTED_DATA_LENGTH_SIZE },
+	{ set_le_data_length_params,
+				   MGMT_LE_SET_DATA_LENGTH_SIZE },
 };
 #endif
 
-- 
2.7.4


From 95ec7e188c0e37c8d0565a354dcbf8a9fe3b1751 Mon Sep 17 00:00:00 2001
From: Jaehoon Chung <jh80.chung@samsung.com>
Date: Tue, 16 Nov 2021 12:54:43 +0900
Subject: [PATCH 13/16] ARM: defconfig: disable ANDROID_LOGGER

Disable ANDROID_LOGGER.

Change-Id: I0fa79d5f7829f59eb8467f4daa8e81a390ec57fa
Signed-off-by: Jaehoon Chung <jh80.chung@samsung.com>
---
 arch/arm64/configs/tizen_kvims_defconfig     | 1 -
 arch/arm64/configs/tizen_odroidg12_defconfig | 1 -
 2 files changed, 2 deletions(-)

diff --git a/arch/arm64/configs/tizen_kvims_defconfig b/arch/arm64/configs/tizen_kvims_defconfig
index ac53cee..5305de38 100644
--- a/arch/arm64/configs/tizen_kvims_defconfig
+++ b/arch/arm64/configs/tizen_kvims_defconfig
@@ -608,7 +608,6 @@ CONFIG_UIO=y
 CONFIG_UIO_PDRV_GENIRQ=y
 CONFIG_VIRTIO_MMIO=y
 CONFIG_STAGING=y
-CONFIG_ANDROID_LOGGER=y
 CONFIG_TIZEN=y
 CONFIG_PM_DEVFREQ=y
 CONFIG_DEVFREQ_GOV_SIMPLE_ONDEMAND=y
diff --git a/arch/arm64/configs/tizen_odroidg12_defconfig b/arch/arm64/configs/tizen_odroidg12_defconfig
index 2ee8981..941383a 100644
--- a/arch/arm64/configs/tizen_odroidg12_defconfig
+++ b/arch/arm64/configs/tizen_odroidg12_defconfig
@@ -680,7 +680,6 @@ CONFIG_R8712U=y
 CONFIG_STAGING_MEDIA=y
 CONFIG_LIRC_STAGING=y
 CONFIG_LIRC_ODROID=m
-CONFIG_ANDROID_LOGGER=y
 CONFIG_TIZEN=y
 CONFIG_PM_DEVFREQ=y
 CONFIG_DEVFREQ_GOV_SIMPLE_ONDEMAND=y
-- 
2.7.4


From 2cd1341e9c8c4fa02a1463ff1bc8e8be23ade4d3 Mon Sep 17 00:00:00 2001
From: Daniel Rosenberg <drosen@google.com>
Date: Mon, 20 Aug 2018 19:21:43 -0700
Subject: [PATCH 14/16] f2fs: checkpoint disabling

Note that, it requires "f2fs: return correct errno in f2fs_gc".

This adds a lightweight non-persistent snapshotting scheme to f2fs.

To use, mount with the option checkpoint=disable, and to return to
normal operation, remount with checkpoint=enable. If the filesystem
is shut down before remounting with checkpoint=enable, it will revert
back to its apparent state when it was first mounted with
checkpoint=disable. This is useful for situations where you wish to be
able to roll back the state of the disk in case of some critical
failure.

Signed-off-by: Daniel Rosenberg <drosen@google.com>
[Jaegeuk Kim: use SB_RDONLY instead of MS_RDONLY]
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
[dwoo08.lee: port from android-common-kernel branch android-4.9-q commit f22f93a90601]
Signed-off-by: Dongwoo Lee <dwoo08.lee@samsung.com>

Change-Id: I7020cb09b360b291b324baae71882e64a7776ed8
---
 Documentation/filesystems/f2fs.txt |   5 ++
 fs/f2fs/checkpoint.c               |  12 ++++
 fs/f2fs/data.c                     |  11 ++++
 fs/f2fs/debug.c                    |   3 +-
 fs/f2fs/f2fs.h                     |  18 ++++++
 fs/f2fs/file.c                     |  12 +++-
 fs/f2fs/gc.c                       |   9 ++-
 fs/f2fs/inode.c                    |   6 +-
 fs/f2fs/namei.c                    |  19 ++++++
 fs/f2fs/segment.c                  |  98 ++++++++++++++++++++++++++++--
 fs/f2fs/segment.h                  |  15 +++++
 fs/f2fs/super.c                    | 120 +++++++++++++++++++++++++++++++++++++
 include/linux/f2fs_fs.h            |   1 +
 13 files changed, 320 insertions(+), 9 deletions(-)

diff --git a/Documentation/filesystems/f2fs.txt b/Documentation/filesystems/f2fs.txt
index 193a034..9a17cd9 100644
--- a/Documentation/filesystems/f2fs.txt
+++ b/Documentation/filesystems/f2fs.txt
@@ -190,6 +190,11 @@ fsync_mode=%s          Control the policy of fsync. Currently supports "posix",
                        non-atomic files likewise "nobarrier" mount option.
 test_dummy_encryption  Enable dummy encryption, which provides a fake fscrypt
                        context. The fake fscrypt context is used by xfstests.
+checkpoint=%s          Set to "disable" to turn off checkpointing. Set to "enable"
+                       to reenable checkpointing. Is enabled by default. While
+                       disabled, any unmounting or unexpected shutdowns will cause
+                       the filesystem contents to appear as they did when the
+                       filesystem was mounted with that option.
 
 ================================================================================
 DEBUGFS ENTRIES
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 79134af..0bf44b5 100644
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -1194,6 +1194,11 @@ static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc)
 	if (is_sbi_flag_set(sbi, SBI_NEED_FSCK))
 		__set_ckpt_flags(ckpt, CP_FSCK_FLAG);
 
+	if (is_sbi_flag_set(sbi, SBI_CP_DISABLED))
+		__set_ckpt_flags(ckpt, CP_DISABLED_FLAG);
+	else
+		__clear_ckpt_flags(ckpt, CP_DISABLED_FLAG);
+
 	/* set this flag to activate crc|cp_ver for recovery */
 	__set_ckpt_flags(ckpt, CP_CRC_RECOVERY_FLAG);
 	__clear_ckpt_flags(ckpt, CP_NOCRC_RECOVERY_FLAG);
@@ -1392,6 +1397,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
 
 	clear_sbi_flag(sbi, SBI_IS_DIRTY);
 	clear_sbi_flag(sbi, SBI_NEED_CP);
+	sbi->unusable_block_count = 0;
 	__set_cp_next_pack(sbi);
 
 	/*
@@ -1416,6 +1422,12 @@ int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
 	unsigned long long ckpt_ver;
 	int err = 0;
 
+	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
+		if (cpc->reason != CP_PAUSE)
+			return 0;
+		f2fs_msg(sbi->sb, KERN_WARNING,
+				"Start checkpoint disabled!");
+	}
 	mutex_lock(&sbi->cp_mutex);
 
 	if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) &&
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index f838236..5aa811f 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1644,6 +1644,10 @@ static inline bool check_inplace_update_policy(struct inode *inode,
 			is_inode_flag_set(inode, FI_NEED_IPU))
 		return true;
 
+	if (unlikely(fio && is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
+			!is_checkpointed_data(sbi, fio->old_blkaddr)))
+		return true;
+
 	return false;
 }
 
@@ -1674,6 +1678,9 @@ bool should_update_outplace(struct inode *inode, struct f2fs_io_info *fio)
 			return true;
 		if (IS_ATOMIC_WRITTEN_PAGE(fio->page))
 			return true;
+		if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
+			is_checkpointed_data(sbi, fio->old_blkaddr)))
+			return true;
 	}
 	return false;
 }
@@ -2272,6 +2279,10 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
 #endif
 	trace_f2fs_write_begin(inode, pos, len, flags);
 
+	err = f2fs_is_checkpoint_ready(sbi);
+	if (err)
+		goto fail;
+
 	if (f2fs_is_atomic_file(inode) &&
 			!available_free_memory(sbi, INMEM_PAGES)) {
 		err = -ENOMEM;
diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index a66107b..4355d7ce 100644
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -268,7 +268,8 @@ static int stat_show(struct seq_file *s, void *v)
 		seq_printf(s, "\n=====[ partition info(%pg). #%d, %s, CP: %s]=====\n",
 			si->sbi->sb->s_bdev, i++,
 			f2fs_readonly(si->sbi->sb) ? "RO": "RW",
-			f2fs_cp_error(si->sbi) ? "Error": "Good");
+			is_set_ckpt_flags(si->sbi, CP_DISABLED_FLAG) ?
+			"Disabled" : (f2fs_cp_error(si->sbi) ? "Error" : "Good"));
 		seq_printf(s, "[SB: 1] [CP: 2] [SIT: %d] [NAT: %d] ",
 			   si->sit_area_segs, si->nat_area_segs);
 		seq_printf(s, "[SSA: %d] [MAIN: %d",
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 6194c16..2b53d0d 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -98,6 +98,7 @@ extern char *fault_name[FAULT_MAX];
 #define F2FS_MOUNT_QUOTA		0x00400000
 #define F2FS_MOUNT_INLINE_XATTR_SIZE	0x00800000
 #define F2FS_MOUNT_RESERVE_ROOT		0x01000000
+#define F2FS_MOUNT_DISABLE_CHECKPOINT	0x02000000
 
 #define F2FS_OPTION(sbi)	((sbi)->mount_opt)
 #define clear_opt(sbi, option)	(F2FS_OPTION(sbi).opt &= ~F2FS_MOUNT_##option)
@@ -176,6 +177,7 @@ enum {
 #define	CP_RECOVERY	0x00000008
 #define	CP_DISCARD	0x00000010
 #define CP_TRIMMED	0x00000020
+#define CP_PAUSE	0x00000040
 
 #define MAX_DISCARD_BLOCKS(sbi)		BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST		8	/* issue 8 discards per round */
@@ -185,6 +187,7 @@ enum {
 #define DEF_DISCARD_URGENT_UTIL		80	/* do more discard over 80% */
 #define DEF_CP_INTERVAL			60	/* 60 secs */
 #define DEF_IDLE_INTERVAL		5	/* 5 secs */
+#define DEF_DISABLE_INTERVAL		5       /* 5 secs */
 
 struct cp_control {
 	int reason;
@@ -1056,11 +1059,13 @@ enum {
 	SBI_POR_DOING,				/* recovery is doing or not */
 	SBI_NEED_SB_WRITE,			/* need to recover superblock */
 	SBI_NEED_CP,				/* need to checkpoint */
+	SBI_CP_DISABLED,                        /* CP was disabled last mount */
 };
 
 enum {
 	CP_TIME,
 	REQ_TIME,
+	DISABLE_TIME,
 	MAX_TIME,
 };
 
@@ -1172,6 +1177,9 @@ struct f2fs_sb_info {
 	block_t reserved_blocks;		/* configurable reserved blocks */
 	block_t current_reserved_blocks;	/* current reserved blocks */
 
+	/* Additional tracking for no checkpoint mode */
+	block_t unusable_block_count;           /* # of blocks saved by last cp */
+
 	unsigned int nquota_files;		/* # of quota sysfile */
 
 	u32 s_next_generation;			/* for NFS support */
@@ -1664,6 +1672,9 @@ static inline int inc_valid_block_count(struct f2fs_sb_info *sbi,
 	if (!__allow_reserved_blocks(sbi, inode, true))
 		avail_user_block_count -= F2FS_OPTION(sbi).root_reserved_blocks;
 
+	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
+		avail_user_block_count -= sbi->unusable_block_count;
+
 	if (unlikely(sbi->total_valid_block_count > avail_user_block_count)) {
 		diff = sbi->total_valid_block_count - avail_user_block_count;
 		if (diff > *count)
@@ -1870,6 +1881,8 @@ static inline int inc_valid_node_count(struct f2fs_sb_info *sbi,
 
 	if (!__allow_reserved_blocks(sbi, inode, false))
 		valid_block_count += F2FS_OPTION(sbi).root_reserved_blocks;
+	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
+		valid_block_count += sbi->unusable_block_count;
 
 	if (unlikely(valid_block_count > sbi->user_block_count)) {
 		spin_unlock(&sbi->stat_lock);
@@ -2849,6 +2862,8 @@ void drop_discard_cmd(struct f2fs_sb_info *sbi);
 void stop_discard_thread(struct f2fs_sb_info *sbi);
 bool f2fs_wait_discard_bios(struct f2fs_sb_info *sbi);
 void clear_prefree_segments(struct f2fs_sb_info *sbi, struct cp_control *cpc);
+void f2fs_dirty_to_prefree(struct f2fs_sb_info *sbi);
+int f2fs_disable_cp_again(struct f2fs_sb_info *sbi);
 void release_discard_addrs(struct f2fs_sb_info *sbi);
 int npages_for_summary_flush(struct f2fs_sb_info *sbi, bool for_ra);
 void allocate_new_segments(struct f2fs_sb_info *sbi);
@@ -3364,6 +3379,9 @@ static inline bool f2fs_may_encrypt(struct inode *inode)
 
 static inline bool f2fs_force_buffered_io(struct inode *inode, int rw)
 {
+	if (is_sbi_flag_set(F2FS_I_SB(inode), SBI_CP_DISABLED))
+		return true;
+
 	return (f2fs_post_read_required(inode) ||
 			(rw == WRITE && test_opt(F2FS_I_SB(inode), LFS)) ||
 			F2FS_I_SB(inode)->s_ndevs);
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 0561020..1609e02 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -214,7 +214,8 @@ static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
 		.for_reclaim = 0,
 	};
 
-	if (unlikely(f2fs_readonly(inode->i_sb)))
+	if (unlikely(f2fs_readonly(inode->i_sb) ||
+			 is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
 		return 0;
 
 	trace_f2fs_sync_file_enter(inode);
@@ -2109,6 +2110,12 @@ static int f2fs_ioc_write_checkpoint(struct file *filp, unsigned long arg)
 	if (f2fs_readonly(sbi->sb))
 		return -EROFS;
 
+	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
+		f2fs_msg(sbi->sb, KERN_INFO,
+				"Skipping Checkpoint. Checkpoints currently disabled.");
+		return -EINVAL;
+	}
+
 	ret = mnt_want_write_file(filp);
 	if (ret)
 		return ret;
@@ -2475,6 +2482,9 @@ static int f2fs_ioc_flush_device(struct file *filp, unsigned long arg)
 	if (f2fs_readonly(sbi->sb))
 		return -EROFS;
 
+	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
+		return -EINVAL;
+
 	if (copy_from_user(&range, (struct f2fs_flush_device __user *)arg,
 							sizeof(range)))
 		return -EFAULT;
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 59005e0..bce2e7e 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -375,6 +375,10 @@ static int get_victim_by_default(struct f2fs_sb_info *sbi,
 
 		if (sec_usage_check(sbi, secno))
 			goto next;
+		/* Don't touch checkpointed data */
+		if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
+					get_ckpt_valid_blocks(sbi, segno)))
+			goto next;
 		if (gc_type == BG_GC && test_bit(secno, dirty_i->victim_secmap))
 			goto next;
 		if (gc_type == FG_GC && p.alloc_mode == LFS &&
@@ -1056,7 +1060,8 @@ gc_more:
 		 * threshold, we can make them free by checkpoint. Then, we
 		 * secure free segments which doesn't need fggc any more.
 		 */
-		if (prefree_segments(sbi)) {
+		if (prefree_segments(sbi) &&
+				!is_sbi_flag_set(sbi, SBI_CP_DISABLED)) {
 			ret = write_checkpoint(sbi, &cpc);
 			if (ret)
 				goto stop;
@@ -1089,7 +1094,7 @@ gc_more:
 			goto gc_more;
 		}
 
-		if (gc_type == FG_GC)
+		if (gc_type == FG_GC && !is_sbi_flag_set(sbi, SBI_CP_DISABLED))
 			ret = write_checkpoint(sbi, &cpc);
 	}
 stop:
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index d4b3545..838a7af 100644
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -544,6 +544,9 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
 	if (!is_inode_flag_set(inode, FI_DIRTY_INODE))
 		return 0;
 
+	if (f2fs_is_checkpoint_ready(sbi))
+		return -ENOSPC;
+
 	/*
 	 * We need to balance fs here to prevent from producing dirty node pages
 	 * during the urgent cleaning time when runing out of free sections.
@@ -626,7 +629,8 @@ no_delete:
 	stat_dec_inline_dir(inode);
 	stat_dec_inline_inode(inode);
 
-	if (likely(!is_set_ckpt_flags(sbi, CP_ERROR_FLAG)))
+	if (likely(!is_set_ckpt_flags(sbi, CP_ERROR_FLAG) &&
+				!is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
 		f2fs_bug_on(sbi, is_inode_flag_set(inode, FI_DIRTY_INODE));
 	else
 		f2fs_inode_synced(inode);
diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index f1e1ff1..fa95531 100644
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -19,6 +19,7 @@
 
 #include "f2fs.h"
 #include "node.h"
+#include "segment.h"
 #include "xattr.h"
 #include "acl.h"
 #include <trace/events/f2fs.h>
@@ -269,6 +270,9 @@ static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 
 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
+	err = f2fs_is_checkpoint_ready(sbi);
+	if (err)
+		return err;
 
 	err = dquot_initialize(dir);
 	if (err)
@@ -315,6 +319,9 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
 
 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
+	err = f2fs_is_checkpoint_ready(sbi);
+	if (err)
+		return err;
 
 	err = fscrypt_prepare_link(old_dentry, dir, dentry);
 	if (err)
@@ -561,6 +568,9 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
 
 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
+	err = f2fs_is_checkpoint_ready(sbi);
+	if (err)
+		return err;
 
 	err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize,
 				      &disk_link);
@@ -690,6 +700,9 @@ static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
 
 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
+	err = f2fs_is_checkpoint_ready(sbi);
+	if (err)
+		return err;
 
 	err = dquot_initialize(dir);
 	if (err)
@@ -824,6 +837,9 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
+	err = f2fs_is_checkpoint_ready(sbi);
+	if (err)
+		return err;
 
 	if (is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
 			(!projid_eq(F2FS_I(new_dir)->i_projid,
@@ -1009,6 +1025,9 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
 
 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
+	err = f2fs_is_checkpoint_ready(sbi);
+	if (err)
+		return err;
 
 	if ((is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
 			!projid_eq(F2FS_I(new_dir)->i_projid,
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 9dc1e0d..5befb1a 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -179,6 +179,8 @@ bool need_SSR(struct f2fs_sb_info *sbi)
 		return false;
 	if (sbi->gc_thread && sbi->gc_thread->gc_urgent)
 		return true;
+	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
+		return true;
 
 	return free_sections(sbi) <= (node_secs + 2 * dent_secs + imeta_secs +
 			SM_I(sbi)->min_ssr_sections + reserved_sections(sbi));
@@ -470,6 +472,9 @@ void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need)
 	if (need && excess_cached_nats(sbi))
 		f2fs_balance_fs_bg(sbi);
 
+	if (f2fs_is_checkpoint_ready(sbi))
+		return;
+
 	/*
 	 * We should do GC or end up with checkpoint, if there are so many dirty
 	 * dir/node pages without enough free segments.
@@ -784,7 +789,7 @@ static void __remove_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno,
 static void locate_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno)
 {
 	struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
-	unsigned short valid_blocks;
+	unsigned short valid_blocks, ckpt_valid_blocks;
 
 	if (segno == NULL_SEGNO || IS_CURSEG(sbi, segno))
 		return;
@@ -792,8 +797,10 @@ static void locate_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno)
 	mutex_lock(&dirty_i->seglist_lock);
 
 	valid_blocks = get_valid_blocks(sbi, segno, false);
+	ckpt_valid_blocks = get_ckpt_valid_blocks(sbi, segno);
 
-	if (valid_blocks == 0) {
+	if (valid_blocks == 0 && (!is_sbi_flag_set(sbi, SBI_CP_DISABLED) ||
+				ckpt_valid_blocks == sbi->blocks_per_seg)) {
 		__locate_dirty_segment(sbi, segno, PRE);
 		__remove_dirty_segment(sbi, segno, DIRTY);
 	} else if (valid_blocks < sbi->blocks_per_seg) {
@@ -806,6 +813,66 @@ static void locate_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno)
 	mutex_unlock(&dirty_i->seglist_lock);
 }
 
+/* This moves currently empty dirty blocks to prefree. Must hold seglist_lock */
+void f2fs_dirty_to_prefree(struct f2fs_sb_info *sbi)
+{
+	struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
+	unsigned int segno;
+
+	mutex_lock(&dirty_i->seglist_lock);
+	for_each_set_bit(segno, dirty_i->dirty_segmap[DIRTY], MAIN_SEGS(sbi)) {
+		if (get_valid_blocks(sbi, segno, false))
+			continue;
+		if (IS_CURSEG(sbi, segno))
+			continue;
+		__locate_dirty_segment(sbi, segno, PRE);
+		__remove_dirty_segment(sbi, segno, DIRTY);
+	}
+	mutex_unlock(&dirty_i->seglist_lock);
+}
+
+int f2fs_disable_cp_again(struct f2fs_sb_info *sbi)
+{
+	struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
+	block_t ovp = overprovision_segments(sbi) << sbi->log_blocks_per_seg;
+	block_t holes[2] = {0, 0};      /* DATA and NODE */
+	struct seg_entry *se;
+	unsigned int segno;
+
+	mutex_lock(&dirty_i->seglist_lock);
+	for_each_set_bit(segno, dirty_i->dirty_segmap[DIRTY], MAIN_SEGS(sbi)) {
+		se = get_seg_entry(sbi, segno);
+		if (IS_NODESEG(se->type))
+			holes[NODE] += sbi->blocks_per_seg - se->valid_blocks;
+		else
+			holes[DATA] += sbi->blocks_per_seg - se->valid_blocks;
+	}
+	mutex_unlock(&dirty_i->seglist_lock);
+
+	if (holes[DATA] > ovp || holes[NODE] > ovp)
+		return -EAGAIN;
+	return 0;
+}
+
+/* This is only used by SBI_CP_DISABLED */
+static unsigned int get_free_segment(struct f2fs_sb_info *sbi)
+{
+	struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
+	unsigned int segno = 0;
+
+	mutex_lock(&dirty_i->seglist_lock);
+	for_each_set_bit(segno, dirty_i->dirty_segmap[DIRTY], MAIN_SEGS(sbi)) {
+		if (get_valid_blocks(sbi, segno, false))
+			continue;
+		if (get_ckpt_valid_blocks(sbi, segno))
+			continue;
+		mutex_unlock(&dirty_i->seglist_lock);
+		return segno;
+	}
+	mutex_unlock(&dirty_i->seglist_lock);
+	return NULL_SEGNO;
+}
+
 static struct discard_cmd *__create_discard_cmd(struct f2fs_sb_info *sbi,
 		struct block_device *bdev, block_t lstart,
 		block_t start, block_t len)
@@ -1827,7 +1894,8 @@ static void update_sit_entry(struct f2fs_sb_info *sbi, block_t blkaddr, int del)
 			sbi->discard_blks--;
 
 		/* don't overwrite by SSR to keep node chain */
-		if (IS_NODESEG(se->type)) {
+		if (IS_NODESEG(se->type) &&
+			is_sbi_flag_set(sbi, SBI_CP_DISABLED)) {
 			if (!f2fs_test_and_set_bit(offset, se->ckpt_valid_map))
 				se->ckpt_valid_blocks++;
 		}
@@ -1849,6 +1917,15 @@ static void update_sit_entry(struct f2fs_sb_info *sbi, block_t blkaddr, int del)
 			f2fs_bug_on(sbi, 1);
 			se->valid_blocks++;
 			del = 0;
+		} else if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
+			/*
+			 * If checkpoints are off, we must not reuse data that
+			 * was used in the previous checkpoint. If it was used
+			 * before, we must track that to know how much space we
+			 * really have.
+			 */
+			if (f2fs_test_bit(offset, se->ckpt_valid_map))
+				sbi->unusable_block_count++;
 		}
 
 		if (f2fs_discard_en(sbi) &&
@@ -2128,6 +2205,9 @@ static unsigned int __get_next_segno(struct f2fs_sb_info *sbi, int type)
 	if (sbi->segs_per_sec != 1)
 		return CURSEG_I(sbi, type)->segno;
 
+	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
+		return 0;
+
 	if (test_opt(sbi, NOHEAP) &&
 		(type == CURSEG_HOT_DATA || IS_NODESEG(type)))
 		return 0;
@@ -2271,6 +2351,15 @@ static int get_ssr_segment(struct f2fs_sb_info *sbi, int type)
 			return 1;
 		}
 	}
+
+	/* find valid_blocks=0 in dirty list */
+	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
+		segno = get_free_segment(sbi);
+		if (segno != NULL_SEGNO) {
+			curseg->next_segno = segno;
+			return 1;
+		}
+	}
 	return 0;
 }
 
@@ -2288,7 +2377,8 @@ static void allocate_segment_by_default(struct f2fs_sb_info *sbi,
 	else if (!is_set_ckpt_flags(sbi, CP_CRC_RECOVERY_FLAG) &&
 					type == CURSEG_WARM_NODE)
 		new_curseg(sbi, type, false);
-	else if (curseg->alloc_type == LFS && is_next_segment_free(sbi, type))
+	else if (curseg->alloc_type == LFS && is_next_segment_free(sbi, type) &&
+			likely(!is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
 		new_curseg(sbi, type, false);
 	else if (need_SSR(sbi) && get_ssr_segment(sbi, type))
 		change_curseg(sbi, type);
diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index 0af6dca..b507202 100644
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -340,6 +340,12 @@ static inline unsigned int get_valid_blocks(struct f2fs_sb_info *sbi,
 		return get_seg_entry(sbi, segno)->valid_blocks;
 }
 
+static inline unsigned int get_ckpt_valid_blocks(struct f2fs_sb_info *sbi,
+				unsigned int segno)
+{
+	return get_seg_entry(sbi, segno)->ckpt_valid_blocks;
+}
+
 static inline void seg_info_from_raw_sit(struct seg_entry *se,
 					struct f2fs_sit_entry *rs)
 {
@@ -576,6 +582,15 @@ static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi,
 		reserved_sections(sbi) + needed);
 }
 
+static inline int f2fs_is_checkpoint_ready(struct f2fs_sb_info *sbi)
+{
+	if (likely(!is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
+		return 0;
+	if (likely(!has_not_enough_free_secs(sbi, 0, 0)))
+		return 0;
+	return -ENOSPC;
+}
+
 static inline bool excess_prefree_segs(struct f2fs_sb_info *sbi)
 {
 	return prefree_segments(sbi) > SM_I(sbi)->rec_prefree_segments;
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 0f95dce..be58d77 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -133,6 +133,7 @@ enum {
 	Opt_alloc,
 	Opt_fsync,
 	Opt_test_dummy_encryption,
+	Opt_checkpoint,
 	Opt_err,
 };
 
@@ -190,6 +191,7 @@ static match_table_t f2fs_tokens = {
 	{Opt_alloc, "alloc_mode=%s"},
 	{Opt_fsync, "fsync_mode=%s"},
 	{Opt_test_dummy_encryption, "test_dummy_encryption"},
+	{Opt_checkpoint, "checkpoint=%s"},
 	{Opt_err, NULL},
 };
 
@@ -765,6 +767,23 @@ static int parse_options(struct super_block *sb, char *options)
 					"Test dummy encryption mount option ignored");
 #endif
 			break;
+		case Opt_checkpoint:
+			name = match_strdup(&args[0]);
+			if (!name)
+				return -ENOMEM;
+
+			if (strlen(name) == 6 &&
+					!strncmp(name, "enable", 6)) {
+				clear_opt(sbi, DISABLE_CHECKPOINT);
+			} else if (strlen(name) == 7 &&
+					!strncmp(name, "disable", 7)) {
+				set_opt(sbi, DISABLE_CHECKPOINT);
+			} else {
+				kfree(name);
+				return -EINVAL;
+			}
+			kfree(name);
+			break;
 		default:
 			f2fs_msg(sb, KERN_ERR,
 				"Unrecognized mount option \"%s\" or missing value",
@@ -810,6 +829,12 @@ static int parse_options(struct super_block *sb, char *options)
 		}
 	}
 
+	if (test_opt(sbi, DISABLE_CHECKPOINT) && test_opt(sbi, LFS)) {
+		f2fs_msg(sb, KERN_ERR,
+				"LFS not compatible with checkpoint=disable\n");
+		return -EINVAL;
+	}
+
 	/* Not pass down write hints if the number of active logs is lesser
 	 * than NR_CURSEG_TYPE.
 	 */
@@ -1066,6 +1091,8 @@ int f2fs_sync_fs(struct super_block *sb, int sync)
 
 	if (unlikely(f2fs_cp_error(sbi)))
 		return 0;
+	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
+		return 0;
 
 	trace_f2fs_sync_fs(sb, sync);
 
@@ -1165,6 +1192,11 @@ static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
 	buf->f_blocks = total_count - start_count;
 	buf->f_bfree = user_block_count - valid_user_blocks(sbi) -
 						sbi->current_reserved_blocks;
+	if (unlikely(buf->f_bfree <= sbi->unusable_block_count))
+		buf->f_bfree = 0;
+	else
+		buf->f_bfree -= sbi->unusable_block_count;
+
 	if (buf->f_bfree > F2FS_OPTION(sbi).root_reserved_blocks)
 		buf->f_bavail = buf->f_bfree -
 				F2FS_OPTION(sbi).root_reserved_blocks;
@@ -1340,6 +1372,9 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
 	else if (F2FS_OPTION(sbi).alloc_mode == ALLOC_MODE_REUSE)
 		seq_printf(seq, ",alloc_mode=%s", "reuse");
 
+	if (test_opt(sbi, DISABLE_CHECKPOINT))
+		seq_puts(seq, ",checkpoint=disable");
+
 	if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_POSIX)
 		seq_printf(seq, ",fsync_mode=%s", "posix");
 	else if (F2FS_OPTION(sbi).fsync_mode == FSYNC_MODE_STRICT)
@@ -1365,6 +1400,7 @@ static void default_options(struct f2fs_sb_info *sbi)
 	set_opt(sbi, EXTENT_CACHE);
 	set_opt(sbi, NOHEAP);
 	sbi->sb->s_flags |= MS_LAZYTIME;
+	clear_opt(sbi, DISABLE_CHECKPOINT);
 	set_opt(sbi, FLUSH_MERGE);
 	if (f2fs_sb_has_blkzoned(sbi->sb)) {
 		set_opt_mode(sbi, F2FS_MOUNT_LFS);
@@ -1388,6 +1424,57 @@ static void default_options(struct f2fs_sb_info *sbi)
 #ifdef CONFIG_QUOTA
 static int f2fs_enable_quotas(struct super_block *sb);
 #endif
+
+static int f2fs_disable_checkpoint(struct f2fs_sb_info *sbi)
+{
+	struct cp_control cpc;
+	int err;
+
+	sbi->sb->s_flags |= MS_ACTIVE;
+
+	mutex_lock(&sbi->gc_mutex);
+	f2fs_update_time(sbi, DISABLE_TIME);
+
+	while (!f2fs_time_over(sbi, DISABLE_TIME)) {
+		err = f2fs_gc(sbi, true, false, NULL_SEGNO);
+		if (err == -ENODATA)
+			break;
+		if (err && err != -EAGAIN) {
+			mutex_unlock(&sbi->gc_mutex);
+			return err;
+		}
+	}
+	mutex_unlock(&sbi->gc_mutex);
+
+	err = sync_filesystem(sbi->sb);
+	if (err)
+		return err;
+
+	if (f2fs_disable_cp_again(sbi))
+		return -EAGAIN;
+
+	mutex_lock(&sbi->gc_mutex);
+	cpc.reason = CP_PAUSE;
+	set_sbi_flag(sbi, SBI_CP_DISABLED);
+	write_checkpoint(sbi, &cpc);
+
+	sbi->unusable_block_count = 0;
+	mutex_unlock(&sbi->gc_mutex);
+	return 0;
+}
+
+static void f2fs_enable_checkpoint(struct f2fs_sb_info *sbi)
+{
+	mutex_lock(&sbi->gc_mutex);
+	f2fs_dirty_to_prefree(sbi);
+
+	clear_sbi_flag(sbi, SBI_CP_DISABLED);
+	set_sbi_flag(sbi, SBI_IS_DIRTY);
+	mutex_unlock(&sbi->gc_mutex);
+
+	f2fs_sync_fs(sbi->sb, 1);
+}
+
 static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 {
 	struct f2fs_sb_info *sbi = F2FS_SB(sb);
@@ -1397,6 +1484,8 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 	bool need_restart_gc = false;
 	bool need_stop_gc = false;
 	bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);
+	bool disable_checkpoint = test_opt(sbi, DISABLE_CHECKPOINT);
+	bool checkpoint_changed;
 #ifdef CONFIG_QUOTA
 	int i, j;
 #endif
@@ -1441,6 +1530,8 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 	err = parse_options(sb, data);
 	if (err)
 		goto restore_opts;
+	checkpoint_changed =
+		disable_checkpoint != test_opt(sbi, DISABLE_CHECKPOINT);
 
 	/*
 	 * Previous and new state of filesystem is RO,
@@ -1474,6 +1565,13 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 		goto restore_opts;
 	}
 
+	if ((*flags & MS_RDONLY) && test_opt(sbi, DISABLE_CHECKPOINT)) {
+		err = -EINVAL;
+		f2fs_msg(sbi->sb, KERN_WARNING,
+				"disabling checkpoint not compatible with read-only");
+		goto restore_opts;
+	}
+
 	/*
 	 * We stop the GC thread if FS is mounted as RO
 	 * or if background_gc = off is passed in mount
@@ -1502,6 +1600,16 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 		clear_sbi_flag(sbi, SBI_IS_CLOSE);
 	}
 
+	if (checkpoint_changed) {
+		if (test_opt(sbi, DISABLE_CHECKPOINT)) {
+			err = f2fs_disable_checkpoint(sbi);
+			if (err)
+				goto restore_gc;
+		} else {
+			f2fs_enable_checkpoint(sbi);
+		}
+	}
+
 	/*
 	 * We stop issue flush thread if FS is mounted as RO
 	 * or if flush_merge is not passed in mount option.
@@ -2426,6 +2534,7 @@ static void init_sb_info(struct f2fs_sb_info *sbi)
 	sbi->dir_level = DEF_DIR_LEVEL;
 	sbi->interval_time[CP_TIME] = DEF_CP_INTERVAL;
 	sbi->interval_time[REQ_TIME] = DEF_IDLE_INTERVAL;
+	sbi->interval_time[DISABLE_TIME] = DEF_DISABLE_INTERVAL;
 	clear_sbi_flag(sbi, SBI_NEED_FSCK);
 
 	for (i = 0; i < NR_COUNT_TYPE; i++)
@@ -3021,6 +3130,9 @@ try_onemore:
 	if (err)
 		goto free_meta;
 
+	if (unlikely(is_set_ckpt_flags(sbi, CP_DISABLED_FLAG)))
+		goto skip_recovery;
+
 	/* recover fsynced data */
 	if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) {
 		/*
@@ -3060,6 +3172,14 @@ skip_recovery:
 	/* recover_fsync_data() cleared this already */
 	clear_sbi_flag(sbi, SBI_POR_DOING);
 
+	if (test_opt(sbi, DISABLE_CHECKPOINT)) {
+		err = f2fs_disable_checkpoint(sbi);
+		if (err)
+			goto free_meta;
+	} else if (is_set_ckpt_flags(sbi, CP_DISABLED_FLAG)) {
+		f2fs_enable_checkpoint(sbi);
+	}
+
 	/*
 	 * If filesystem is not mounted as read-only then
 	 * do start the gc_thread.
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index aa5db8b..d885420 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -118,6 +118,7 @@ struct f2fs_super_block {
 /*
  * For checkpoint
  */
+#define CP_DISABLED_FLAG		0x00001000
 #define CP_LARGE_NAT_BITMAP_FLAG	0x00000400
 #define CP_NOCRC_RECOVERY_FLAG	0x00000200
 #define CP_TRIMMED_FLAG		0x00000100
-- 
2.7.4


From 807584df1d5f372074d914624d94c2c69c3de362 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <jaegeuk@kernel.org>
Date: Wed, 17 Nov 2021 21:20:52 +0900
Subject: [PATCH 15/16] f2fs: flush data when enabling checkpoint back

During checkpoint=disable period, f2fs bypasses all the synchronous IOs such as
sync and fsync. So, when enabling it back, we must flush all of them in order
to keep the data persistent. Otherwise, suddern power-cut right after enabling
checkpoint will cause data loss.

Fixes: 4354994 ("f2fs: checkpoint disabling")
Cc: stable@vger.kernel.org
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
[dwoo08.lee: backport from mainline commit b0ff4fe746fd]
Signed-off-by: Dongwoo Lee <dwoo08.lee@samsung.com>

Change-Id: Ic0810d99c5a3938e191461bd66e7862a4a68e12b
---
 fs/f2fs/super.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index be58d77..dacb3bc 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -1465,6 +1465,9 @@ static int f2fs_disable_checkpoint(struct f2fs_sb_info *sbi)
 
 static void f2fs_enable_checkpoint(struct f2fs_sb_info *sbi)
 {
+	/* we should flush all the data to keep data consistency */
+	sync_inodes_sb(sbi->sb);
+
 	mutex_lock(&sbi->gc_mutex);
 	f2fs_dirty_to_prefree(sbi);
 
-- 
2.7.4


From d8abbead904db6ccda11b7deb855525eda487bf1 Mon Sep 17 00:00:00 2001
From: Chao Yu <chao@kernel.org>
Date: Thu, 18 Nov 2021 15:35:20 +0900
Subject: [PATCH 16/16] f2fs: fix wrong checkpoint_changed value in
 f2fs_remount()

In f2fs_remount(), return value of test_opt() is an unsigned int type
variable, however when we compare it to a bool type variable, it cause
wrong result, fix it.

Fixes: 4354994f097d ("f2fs: checkpoint disabling")
Signed-off-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
[dwoo08.lee: backport from mainline commit 277afbde6ca2]
Signed-off-by: Dongwoo Lee <dwoo08.lee@samsung.com>

Change-Id: Icd4dfff441bf84f605d8d09de7be89da88548654
---
 fs/f2fs/super.c | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index dacb3bc..071d602 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -1487,8 +1487,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 	bool need_restart_gc = false;
 	bool need_stop_gc = false;
 	bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);
-	bool disable_checkpoint = test_opt(sbi, DISABLE_CHECKPOINT);
-	bool checkpoint_changed;
+	bool enable_checkpoint = !test_opt(sbi, DISABLE_CHECKPOINT);
 #ifdef CONFIG_QUOTA
 	int i, j;
 #endif
@@ -1533,8 +1532,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 	err = parse_options(sb, data);
 	if (err)
 		goto restore_opts;
-	checkpoint_changed =
-		disable_checkpoint != test_opt(sbi, DISABLE_CHECKPOINT);
+
 
 	/*
 	 * Previous and new state of filesystem is RO,
@@ -1603,7 +1601,7 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
 		clear_sbi_flag(sbi, SBI_IS_CLOSE);
 	}
 
-	if (checkpoint_changed) {
+	if (enable_checkpoint == !!test_opt(sbi, DISABLE_CHECKPOINT)) {
 		if (test_opt(sbi, DISABLE_CHECKPOINT)) {
 			err = f2fs_disable_checkpoint(sbi);
 			if (err)
-- 
2.7.4