qmi_rmnet.c 34 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543
  1. /*
  2. * Copyright (c) 2018-2021, The Linux Foundation. All rights reserved.
  3. *
  4. * This program is free software; you can redistribute it and/or modify
  5. * it under the terms of the GNU General Public License version 2 and
  6. * only version 2 as published by the Free Software Foundation.
  7. *
  8. * This program is distributed in the hope that it will be useful,
  9. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. * GNU General Public License for more details.
  12. */
  13. #include <linux/soc/qcom/qmi.h>
  14. #include "qmi_rmnet_i.h"
  15. #include "qmi_rmnet.h"
  16. #include "rmnet_qmi.h"
  17. #include "dfc.h"
  18. #include <linux/rtnetlink.h>
  19. #include <uapi/linux/rtnetlink.h>
  20. #include <net/pkt_sched.h>
  21. #include <net/tcp.h>
  22. #include <linux/module.h>
  23. #include <linux/moduleparam.h>
  24. #include <linux/ip.h>
  25. #include <linux/ipv6.h>
  26. #include <linux/alarmtimer.h>
  27. #define NLMSG_FLOW_ACTIVATE 1
  28. #define NLMSG_FLOW_DEACTIVATE 2
  29. #define NLMSG_CLIENT_SETUP 4
  30. #define NLMSG_CLIENT_DELETE 5
  31. #define NLMSG_SCALE_FACTOR 6
  32. #define NLMSG_WQ_FREQUENCY 7
  33. #define NLMSG_CHANNEL_SWITCH 8
  34. #define FLAG_DFC_MASK 0x000F
  35. #define FLAG_POWERSAVE_MASK 0x0010
  36. #define FLAG_QMAP_MASK 0x0020
  37. #define FLAG_PS_EXT_MASK 0x0040
  38. #define FLAG_TO_MODE(f) ((f) & FLAG_DFC_MASK)
  39. #define DFC_SUPPORTED_MODE(m) \
  40. ((m) == DFC_MODE_SA)
  41. #define FLAG_TO_QMAP(f) ((f) & FLAG_QMAP_MASK)
  42. #define FLAG_TO_PS_EXT(f) ((f) & FLAG_PS_EXT_MASK)
  43. int dfc_mode;
  44. int dfc_qmap;
  45. int dfc_ps_ext;
  46. unsigned int rmnet_wq_frequency __read_mostly = 1000;
  47. #define PS_WORK_ACTIVE_BIT 0
  48. #define NO_DELAY (0x0000 * HZ)
  49. #define PS_INTERVAL_MS (rmnet_wq_frequency)
  50. #define PS_INTERVAL_KT (ms_to_ktime(PS_INTERVAL_MS))
  51. #define PS_INTERVAL_JF (msecs_to_jiffies(PS_INTERVAL_MS))
  52. #define WATCHDOG_EXPIRE_JF (msecs_to_jiffies(50))
  53. #ifdef CONFIG_QTI_QMI_DFC
  54. static unsigned int qmi_rmnet_scale_factor = 5;
  55. static LIST_HEAD(qos_cleanup_list);
  56. #endif
  57. static int
  58. qmi_rmnet_del_flow(struct net_device *dev, struct tcmsg *tcm,
  59. struct qmi_info *qmi);
  60. struct qmi_elem_info data_ep_id_type_v01_ei[] = {
  61. {
  62. .data_type = QMI_SIGNED_4_BYTE_ENUM,
  63. .elem_len = 1,
  64. .elem_size = sizeof(enum data_ep_type_enum_v01),
  65. .array_type = NO_ARRAY,
  66. .tlv_type = QMI_COMMON_TLV_TYPE,
  67. .offset = offsetof(struct data_ep_id_type_v01,
  68. ep_type),
  69. .ei_array = NULL,
  70. },
  71. {
  72. .data_type = QMI_UNSIGNED_4_BYTE,
  73. .elem_len = 1,
  74. .elem_size = sizeof(u32),
  75. .array_type = NO_ARRAY,
  76. .tlv_type = QMI_COMMON_TLV_TYPE,
  77. .offset = offsetof(struct data_ep_id_type_v01,
  78. iface_id),
  79. .ei_array = NULL,
  80. },
  81. {
  82. .data_type = QMI_EOTI,
  83. .elem_len = 0,
  84. .elem_size = 0,
  85. .array_type = NO_ARRAY,
  86. .tlv_type = QMI_COMMON_TLV_TYPE,
  87. .offset = 0,
  88. .ei_array = NULL,
  89. },
  90. };
  91. EXPORT_SYMBOL(data_ep_id_type_v01_ei);
  92. void *qmi_rmnet_has_dfc_client(struct qmi_info *qmi)
  93. {
  94. int i;
  95. if (!qmi)
  96. return NULL;
  97. for (i = 0; i < MAX_CLIENT_NUM; i++) {
  98. if (qmi->dfc_clients[i])
  99. return qmi->dfc_clients[i];
  100. }
  101. return NULL;
  102. }
  103. static inline int
  104. qmi_rmnet_has_client(struct qmi_info *qmi)
  105. {
  106. if (qmi->wda_client)
  107. return 1;
  108. return qmi_rmnet_has_dfc_client(qmi) ? 1 : 0;
  109. }
  110. static int
  111. qmi_rmnet_has_pending(struct qmi_info *qmi)
  112. {
  113. int i;
  114. if (qmi->wda_pending)
  115. return 1;
  116. for (i = 0; i < MAX_CLIENT_NUM; i++) {
  117. if (qmi->dfc_pending[i])
  118. return 1;
  119. }
  120. return 0;
  121. }
  122. #ifdef CONFIG_QTI_QMI_DFC
  123. static void
  124. qmi_rmnet_clean_flow_list(struct qos_info *qos)
  125. {
  126. struct rmnet_bearer_map *bearer, *br_tmp;
  127. struct rmnet_flow_map *itm, *fl_tmp;
  128. ASSERT_RTNL();
  129. list_for_each_entry_safe(itm, fl_tmp, &qos->flow_head, list) {
  130. list_del(&itm->list);
  131. kfree(itm);
  132. }
  133. list_for_each_entry_safe(bearer, br_tmp, &qos->bearer_head, list) {
  134. list_del(&bearer->list);
  135. kfree(bearer);
  136. }
  137. memset(qos->mq, 0, sizeof(qos->mq));
  138. }
  139. struct rmnet_flow_map *
  140. qmi_rmnet_get_flow_map(struct qos_info *qos, u32 flow_id, int ip_type)
  141. {
  142. struct rmnet_flow_map *itm;
  143. if (!qos)
  144. return NULL;
  145. list_for_each_entry(itm, &qos->flow_head, list) {
  146. if ((itm->flow_id == flow_id) && (itm->ip_type == ip_type))
  147. return itm;
  148. }
  149. return NULL;
  150. }
  151. struct rmnet_bearer_map *
  152. qmi_rmnet_get_bearer_map(struct qos_info *qos, uint8_t bearer_id)
  153. {
  154. struct rmnet_bearer_map *itm;
  155. if (!qos)
  156. return NULL;
  157. list_for_each_entry(itm, &qos->bearer_head, list) {
  158. if (itm->bearer_id == bearer_id)
  159. return itm;
  160. }
  161. return NULL;
  162. }
  163. static void qmi_rmnet_update_flow_map(struct rmnet_flow_map *itm,
  164. struct rmnet_flow_map *new_map)
  165. {
  166. itm->bearer_id = new_map->bearer_id;
  167. itm->flow_id = new_map->flow_id;
  168. itm->ip_type = new_map->ip_type;
  169. itm->mq_idx = new_map->mq_idx;
  170. }
  171. int qmi_rmnet_flow_control(struct net_device *dev, u32 mq_idx, int enable)
  172. {
  173. struct netdev_queue *q;
  174. if (unlikely(mq_idx >= dev->num_tx_queues))
  175. return 0;
  176. q = netdev_get_tx_queue(dev, mq_idx);
  177. if (unlikely(!q))
  178. return 0;
  179. if (enable)
  180. netif_tx_wake_queue(q);
  181. else
  182. netif_tx_stop_queue(q);
  183. trace_dfc_qmi_tc(dev->name, mq_idx, enable);
  184. return 0;
  185. }
  186. /**
  187. * qmi_rmnet_watchdog_fn - watchdog timer func
  188. */
  189. static void qmi_rmnet_watchdog_fn(struct timer_list *t)
  190. {
  191. struct rmnet_bearer_map *bearer;
  192. bearer = container_of(t, struct rmnet_bearer_map, watchdog);
  193. trace_dfc_watchdog(bearer->qos->mux_id, bearer->bearer_id, 2);
  194. spin_lock_bh(&bearer->qos->qos_lock);
  195. if (bearer->watchdog_quit)
  196. goto done;
  197. /*
  198. * Possible stall, try to recover. Enable 80% query and jumpstart
  199. * the bearer if disabled.
  200. */
  201. bearer->watchdog_expire_cnt++;
  202. bearer->bytes_in_flight = 0;
  203. if (!bearer->grant_size) {
  204. bearer->grant_size = DEFAULT_CALL_GRANT;
  205. bearer->grant_thresh = qmi_rmnet_grant_per(bearer->grant_size);
  206. dfc_bearer_flow_ctl(bearer->qos->vnd_dev, bearer, bearer->qos);
  207. } else {
  208. bearer->grant_thresh = qmi_rmnet_grant_per(bearer->grant_size);
  209. }
  210. done:
  211. bearer->watchdog_started = false;
  212. spin_unlock_bh(&bearer->qos->qos_lock);
  213. }
  214. /**
  215. * qmi_rmnet_watchdog_add - add the bearer to watch
  216. * Needs to be called with qos_lock
  217. */
  218. void qmi_rmnet_watchdog_add(struct rmnet_bearer_map *bearer)
  219. {
  220. bearer->watchdog_quit = false;
  221. if (bearer->watchdog_started)
  222. return;
  223. bearer->watchdog_started = true;
  224. mod_timer(&bearer->watchdog, jiffies + WATCHDOG_EXPIRE_JF);
  225. trace_dfc_watchdog(bearer->qos->mux_id, bearer->bearer_id, 1);
  226. }
  227. /**
  228. * qmi_rmnet_watchdog_remove - remove the bearer from watch
  229. * Needs to be called with qos_lock
  230. */
  231. void qmi_rmnet_watchdog_remove(struct rmnet_bearer_map *bearer)
  232. {
  233. bearer->watchdog_quit = true;
  234. if (!bearer->watchdog_started)
  235. return;
  236. del_timer(&bearer->watchdog);
  237. bearer->watchdog_started = false;
  238. trace_dfc_watchdog(bearer->qos->mux_id, bearer->bearer_id, 0);
  239. }
  240. /**
  241. * qmi_rmnet_bearer_clean - clean the removed bearer
  242. * Needs to be called with rtn_lock but not qos_lock
  243. */
  244. static void qmi_rmnet_bearer_clean(struct qos_info *qos)
  245. {
  246. if (qos->removed_bearer) {
  247. qos->removed_bearer->watchdog_quit = true;
  248. del_timer_sync(&qos->removed_bearer->watchdog);
  249. qos->removed_bearer->ch_switch.timer_quit = true;
  250. del_timer_sync(&qos->removed_bearer->ch_switch.guard_timer);
  251. kfree(qos->removed_bearer);
  252. qos->removed_bearer = NULL;
  253. }
  254. }
  255. static struct rmnet_bearer_map *__qmi_rmnet_bearer_get(
  256. struct qos_info *qos_info, u8 bearer_id)
  257. {
  258. struct rmnet_bearer_map *bearer;
  259. bearer = qmi_rmnet_get_bearer_map(qos_info, bearer_id);
  260. if (bearer) {
  261. bearer->flow_ref++;
  262. } else {
  263. bearer = kzalloc(sizeof(*bearer), GFP_ATOMIC);
  264. if (!bearer)
  265. return NULL;
  266. bearer->bearer_id = bearer_id;
  267. bearer->flow_ref = 1;
  268. bearer->grant_size = DEFAULT_CALL_GRANT;
  269. bearer->grant_thresh = qmi_rmnet_grant_per(bearer->grant_size);
  270. bearer->mq_idx = INVALID_MQ;
  271. bearer->ack_mq_idx = INVALID_MQ;
  272. bearer->qos = qos_info;
  273. timer_setup(&bearer->watchdog, qmi_rmnet_watchdog_fn, 0);
  274. timer_setup(&bearer->ch_switch.guard_timer,
  275. rmnet_ll_guard_fn, 0);
  276. list_add(&bearer->list, &qos_info->bearer_head);
  277. }
  278. return bearer;
  279. }
  280. static void __qmi_rmnet_bearer_put(struct net_device *dev,
  281. struct qos_info *qos_info,
  282. struct rmnet_bearer_map *bearer,
  283. bool reset)
  284. {
  285. struct mq_map *mq;
  286. int i, j;
  287. if (bearer && --bearer->flow_ref == 0) {
  288. for (i = 0; i < MAX_MQ_NUM; i++) {
  289. mq = &qos_info->mq[i];
  290. if (mq->bearer != bearer)
  291. continue;
  292. mq->bearer = NULL;
  293. mq->is_ll_ch = false;
  294. mq->drop_on_remove = reset;
  295. smp_mb();
  296. qmi_rmnet_flow_control(dev, i, 1);
  297. if (dfc_mode == DFC_MODE_SA) {
  298. j = i + ACK_MQ_OFFSET;
  299. qmi_rmnet_flow_control(dev, j, 1);
  300. }
  301. }
  302. /* Remove from bearer map */
  303. list_del(&bearer->list);
  304. qos_info->removed_bearer = bearer;
  305. }
  306. }
  307. static void __qmi_rmnet_update_mq(struct net_device *dev,
  308. struct qos_info *qos_info,
  309. struct rmnet_bearer_map *bearer,
  310. struct rmnet_flow_map *itm)
  311. {
  312. struct mq_map *mq;
  313. /* In SA mode default mq is not associated with any bearer */
  314. if (dfc_mode == DFC_MODE_SA && itm->mq_idx == DEFAULT_MQ_NUM)
  315. return;
  316. mq = &qos_info->mq[itm->mq_idx];
  317. if (!mq->bearer) {
  318. mq->bearer = bearer;
  319. mq->is_ll_ch = bearer->ch_switch.current_ch;
  320. mq->drop_on_remove = false;
  321. smp_mb();
  322. if (dfc_mode == DFC_MODE_SA) {
  323. bearer->mq_idx = itm->mq_idx;
  324. bearer->ack_mq_idx = itm->mq_idx + ACK_MQ_OFFSET;
  325. } else {
  326. bearer->mq_idx = itm->mq_idx;
  327. }
  328. qmi_rmnet_flow_control(dev, itm->mq_idx,
  329. bearer->grant_size > 0 ? 1 : 0);
  330. if (dfc_mode == DFC_MODE_SA)
  331. qmi_rmnet_flow_control(dev, bearer->ack_mq_idx,
  332. bearer->grant_size > 0 ? 1 : 0);
  333. }
  334. }
  335. static int __qmi_rmnet_rebind_flow(struct net_device *dev,
  336. struct qos_info *qos_info,
  337. struct rmnet_flow_map *itm,
  338. struct rmnet_flow_map *new_map)
  339. {
  340. struct rmnet_bearer_map *bearer;
  341. __qmi_rmnet_bearer_put(dev, qos_info, itm->bearer, false);
  342. bearer = __qmi_rmnet_bearer_get(qos_info, new_map->bearer_id);
  343. if (!bearer)
  344. return -ENOMEM;
  345. qmi_rmnet_update_flow_map(itm, new_map);
  346. itm->bearer = bearer;
  347. __qmi_rmnet_update_mq(dev, qos_info, bearer, itm);
  348. return 0;
  349. }
  350. static int qmi_rmnet_add_flow(struct net_device *dev, struct tcmsg *tcm,
  351. struct qmi_info *qmi)
  352. {
  353. struct qos_info *qos_info = (struct qos_info *)rmnet_get_qos_pt(dev);
  354. struct rmnet_flow_map new_map, *itm;
  355. struct rmnet_bearer_map *bearer;
  356. struct tcmsg tmp_tcm;
  357. int rc = 0;
  358. if (!qos_info || !tcm || tcm->tcm_handle >= MAX_MQ_NUM)
  359. return -EINVAL;
  360. ASSERT_RTNL();
  361. /* flow activate
  362. * tcm->tcm__pad1 - bearer_id, tcm->tcm_parent - flow_id,
  363. * tcm->tcm_ifindex - ip_type, tcm->tcm_handle - mq_idx
  364. */
  365. new_map.bearer_id = tcm->tcm__pad1;
  366. new_map.flow_id = tcm->tcm_parent;
  367. new_map.ip_type = tcm->tcm_ifindex;
  368. new_map.mq_idx = tcm->tcm_handle;
  369. trace_dfc_flow_info(dev->name, new_map.bearer_id, new_map.flow_id,
  370. new_map.ip_type, new_map.mq_idx, 1);
  371. again:
  372. spin_lock_bh(&qos_info->qos_lock);
  373. itm = qmi_rmnet_get_flow_map(qos_info, new_map.flow_id,
  374. new_map.ip_type);
  375. if (itm) {
  376. if (itm->bearer_id != new_map.bearer_id) {
  377. rc = __qmi_rmnet_rebind_flow(
  378. dev, qos_info, itm, &new_map);
  379. goto done;
  380. } else if (itm->mq_idx != new_map.mq_idx) {
  381. tmp_tcm.tcm__pad1 = itm->bearer_id;
  382. tmp_tcm.tcm_parent = itm->flow_id;
  383. tmp_tcm.tcm_ifindex = itm->ip_type;
  384. tmp_tcm.tcm_handle = itm->mq_idx;
  385. spin_unlock_bh(&qos_info->qos_lock);
  386. qmi_rmnet_del_flow(dev, &tmp_tcm, qmi);
  387. goto again;
  388. } else {
  389. goto done;
  390. }
  391. }
  392. /* Create flow map */
  393. itm = kzalloc(sizeof(*itm), GFP_ATOMIC);
  394. if (!itm) {
  395. spin_unlock_bh(&qos_info->qos_lock);
  396. return -ENOMEM;
  397. }
  398. qmi_rmnet_update_flow_map(itm, &new_map);
  399. list_add(&itm->list, &qos_info->flow_head);
  400. /* Create or update bearer map */
  401. bearer = __qmi_rmnet_bearer_get(qos_info, new_map.bearer_id);
  402. if (!bearer) {
  403. rc = -ENOMEM;
  404. goto done;
  405. }
  406. itm->bearer = bearer;
  407. __qmi_rmnet_update_mq(dev, qos_info, bearer, itm);
  408. done:
  409. spin_unlock_bh(&qos_info->qos_lock);
  410. qmi_rmnet_bearer_clean(qos_info);
  411. return rc;
  412. }
  413. static int
  414. qmi_rmnet_del_flow(struct net_device *dev, struct tcmsg *tcm,
  415. struct qmi_info *qmi)
  416. {
  417. struct qos_info *qos_info = (struct qos_info *)rmnet_get_qos_pt(dev);
  418. struct rmnet_flow_map new_map, *itm;
  419. if (!qos_info)
  420. return -EINVAL;
  421. ASSERT_RTNL();
  422. /* flow deactivate
  423. * tcm->tcm__pad1 - bearer_id, tcm->tcm_parent - flow_id,
  424. * tcm->tcm_ifindex - ip_type
  425. */
  426. spin_lock_bh(&qos_info->qos_lock);
  427. new_map.bearer_id = tcm->tcm__pad1;
  428. new_map.flow_id = tcm->tcm_parent;
  429. new_map.ip_type = tcm->tcm_ifindex;
  430. itm = qmi_rmnet_get_flow_map(qos_info, new_map.flow_id,
  431. new_map.ip_type);
  432. if (itm) {
  433. trace_dfc_flow_info(dev->name, new_map.bearer_id,
  434. new_map.flow_id, new_map.ip_type,
  435. itm->mq_idx, 0);
  436. __qmi_rmnet_bearer_put(dev, qos_info, itm->bearer, true);
  437. /* Remove from flow map */
  438. list_del(&itm->list);
  439. kfree(itm);
  440. }
  441. if (list_empty(&qos_info->flow_head))
  442. netif_tx_wake_all_queues(dev);
  443. spin_unlock_bh(&qos_info->qos_lock);
  444. qmi_rmnet_bearer_clean(qos_info);
  445. return 0;
  446. }
  447. static void qmi_rmnet_query_flows(struct qmi_info *qmi)
  448. {
  449. int i;
  450. for (i = 0; i < MAX_CLIENT_NUM; i++) {
  451. if (qmi->dfc_clients[i] && !dfc_qmap &&
  452. !qmi->dfc_client_exiting[i])
  453. dfc_qmi_query_flow(qmi->dfc_clients[i]);
  454. }
  455. }
  456. struct rmnet_bearer_map *qmi_rmnet_get_bearer_noref(struct qos_info *qos_info,
  457. u8 bearer_id)
  458. {
  459. struct rmnet_bearer_map *bearer;
  460. bearer = __qmi_rmnet_bearer_get(qos_info, bearer_id);
  461. if (bearer)
  462. bearer->flow_ref--;
  463. return bearer;
  464. }
  465. #else
  466. static inline void
  467. qmi_rmnet_update_flow_map(struct rmnet_flow_map *itm,
  468. struct rmnet_flow_map *new_map)
  469. {
  470. }
  471. static inline int
  472. qmi_rmnet_add_flow(struct net_device *dev, struct tcmsg *tcm,
  473. struct qmi_info *qmi)
  474. {
  475. return -EINVAL;
  476. }
  477. static inline int
  478. qmi_rmnet_del_flow(struct net_device *dev, struct tcmsg *tcm,
  479. struct qmi_info *qmi)
  480. {
  481. return -EINVAL;
  482. }
  483. static inline void qmi_rmnet_query_flows(struct qmi_info *qmi)
  484. {
  485. }
  486. #endif
  487. static int
  488. qmi_rmnet_setup_client(void *port, struct qmi_info *qmi, struct tcmsg *tcm)
  489. {
  490. int idx, err = 0;
  491. struct svc_info svc;
  492. ASSERT_RTNL();
  493. /* client setup
  494. * tcm->tcm_handle - instance, tcm->tcm_info - ep_type,
  495. * tcm->tcm_parent - iface_id, tcm->tcm_ifindex - flags
  496. */
  497. idx = (tcm->tcm_handle == 0) ? 0 : 1;
  498. if (!qmi) {
  499. qmi = kzalloc(sizeof(struct qmi_info), GFP_ATOMIC);
  500. if (!qmi)
  501. return -ENOMEM;
  502. qmi->ws = wakeup_source_register(NULL, "RMNET_DFC");
  503. rmnet_init_qmi_pt(port, qmi);
  504. }
  505. qmi->flag = tcm->tcm_ifindex;
  506. qmi->ps_ext = FLAG_TO_PS_EXT(qmi->flag);
  507. svc.instance = tcm->tcm_handle;
  508. svc.ep_type = tcm->tcm_info;
  509. svc.iface_id = tcm->tcm_parent;
  510. if (DFC_SUPPORTED_MODE(dfc_mode) &&
  511. !qmi->dfc_clients[idx] && !qmi->dfc_pending[idx]) {
  512. if (dfc_qmap)
  513. err = dfc_qmap_client_init(port, idx, &svc, qmi);
  514. else
  515. err = dfc_qmi_client_init(port, idx, &svc, qmi);
  516. qmi->dfc_client_exiting[idx] = false;
  517. }
  518. if ((tcm->tcm_ifindex & FLAG_POWERSAVE_MASK) &&
  519. (idx == 0) && !qmi->wda_client && !qmi->wda_pending) {
  520. err = wda_qmi_client_init(port, &svc, qmi);
  521. }
  522. return err;
  523. }
  524. static int
  525. __qmi_rmnet_delete_client(void *port, struct qmi_info *qmi, int idx)
  526. {
  527. void *data = NULL;
  528. ASSERT_RTNL();
  529. if (qmi->dfc_clients[idx])
  530. data = qmi->dfc_clients[idx];
  531. else if (qmi->dfc_pending[idx])
  532. data = qmi->dfc_pending[idx];
  533. if (data) {
  534. if (dfc_qmap)
  535. dfc_qmap_client_exit(data);
  536. else
  537. dfc_qmi_client_exit(data);
  538. qmi->dfc_clients[idx] = NULL;
  539. qmi->dfc_pending[idx] = NULL;
  540. }
  541. if (!qmi_rmnet_has_client(qmi) && !qmi_rmnet_has_pending(qmi)) {
  542. rmnet_reset_qmi_pt(port);
  543. wakeup_source_unregister(qmi->ws);
  544. kfree(qmi);
  545. return 0;
  546. }
  547. return 1;
  548. }
  549. static void
  550. qmi_rmnet_delete_client(void *port, struct qmi_info *qmi, struct tcmsg *tcm)
  551. {
  552. int idx;
  553. void *data = NULL;
  554. /* client delete: tcm->tcm_handle - instance*/
  555. idx = (tcm->tcm_handle == 0) ? 0 : 1;
  556. ASSERT_RTNL();
  557. if (qmi->wda_client)
  558. data = qmi->wda_client;
  559. else if (qmi->wda_pending)
  560. data = qmi->wda_pending;
  561. if ((idx == 0) && data) {
  562. wda_qmi_client_exit(data);
  563. qmi->wda_client = NULL;
  564. qmi->wda_pending = NULL;
  565. } else {
  566. qmi->dfc_client_exiting[idx] = true;
  567. qmi_rmnet_flush_ps_wq();
  568. }
  569. __qmi_rmnet_delete_client(port, qmi, idx);
  570. }
  571. int qmi_rmnet_change_link(struct net_device *dev, void *port, void *tcm_pt,
  572. int attr_len)
  573. {
  574. struct qmi_info *qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  575. struct tcmsg *tcm = (struct tcmsg *)tcm_pt;
  576. void *wda_data = NULL;
  577. int rc = 0;
  578. switch (tcm->tcm_family) {
  579. case NLMSG_FLOW_ACTIVATE:
  580. if (!qmi || !DFC_SUPPORTED_MODE(dfc_mode) ||
  581. !qmi_rmnet_has_dfc_client(qmi))
  582. return rc;
  583. qmi_rmnet_add_flow(dev, tcm, qmi);
  584. break;
  585. case NLMSG_FLOW_DEACTIVATE:
  586. if (!qmi || !DFC_SUPPORTED_MODE(dfc_mode))
  587. return rc;
  588. qmi_rmnet_del_flow(dev, tcm, qmi);
  589. break;
  590. case NLMSG_CLIENT_SETUP:
  591. dfc_mode = FLAG_TO_MODE(tcm->tcm_ifindex);
  592. dfc_qmap = FLAG_TO_QMAP(tcm->tcm_ifindex);
  593. dfc_ps_ext = FLAG_TO_PS_EXT(tcm->tcm_ifindex);
  594. if (!DFC_SUPPORTED_MODE(dfc_mode) &&
  595. !(tcm->tcm_ifindex & FLAG_POWERSAVE_MASK))
  596. return rc;
  597. if (qmi_rmnet_setup_client(port, qmi, tcm) < 0) {
  598. /* retrieve qmi again as it could have been changed */
  599. qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  600. if (qmi &&
  601. !qmi_rmnet_has_client(qmi) &&
  602. !qmi_rmnet_has_pending(qmi)) {
  603. rmnet_reset_qmi_pt(port);
  604. wakeup_source_unregister(qmi->ws);
  605. kfree(qmi);
  606. }
  607. return rc;
  608. }
  609. if (tcm->tcm_ifindex & FLAG_POWERSAVE_MASK) {
  610. qmi_rmnet_work_init(port);
  611. rmnet_set_powersave_format(port);
  612. }
  613. rmnet_ll_wq_init();
  614. break;
  615. case NLMSG_CLIENT_DELETE:
  616. if (!qmi)
  617. return rc;
  618. if (tcm->tcm_handle == 0) { /* instance 0 */
  619. rmnet_clear_powersave_format(port);
  620. if (qmi->wda_client)
  621. wda_data = qmi->wda_client;
  622. else if (qmi->wda_pending)
  623. wda_data = qmi->wda_pending;
  624. wda_qmi_client_release(wda_data);
  625. qmi_rmnet_work_exit(port);
  626. }
  627. qmi_rmnet_delete_client(port, qmi, tcm);
  628. rmnet_ll_wq_exit();
  629. break;
  630. case NLMSG_SCALE_FACTOR:
  631. if (!tcm->tcm_ifindex)
  632. return rc;
  633. qmi_rmnet_scale_factor = tcm->tcm_ifindex;
  634. break;
  635. case NLMSG_WQ_FREQUENCY:
  636. if (tcm->tcm_ifindex >= 100)
  637. rmnet_wq_frequency = tcm->tcm_ifindex;
  638. else
  639. rc = -EINVAL;
  640. break;
  641. case NLMSG_CHANNEL_SWITCH:
  642. if (!qmi || !DFC_SUPPORTED_MODE(dfc_mode) ||
  643. !qmi_rmnet_has_dfc_client(qmi))
  644. return rc;
  645. rc = rmnet_ll_switch(dev, tcm, attr_len);
  646. break;
  647. default:
  648. pr_debug("%s(): No handler\n", __func__);
  649. break;
  650. }
  651. return rc;
  652. }
  653. EXPORT_SYMBOL(qmi_rmnet_change_link);
  654. void qmi_rmnet_qmi_exit(void *qmi_pt, void *port)
  655. {
  656. struct qmi_info *qmi = (struct qmi_info *)qmi_pt;
  657. int i;
  658. void *data = NULL;
  659. if (!qmi)
  660. return;
  661. ASSERT_RTNL();
  662. if (qmi->wda_client)
  663. data = qmi->wda_client;
  664. else if (qmi->wda_pending)
  665. data = qmi->wda_pending;
  666. wda_qmi_client_release(data);
  667. qmi_rmnet_work_exit(port);
  668. rmnet_ll_wq_exit();
  669. if (data) {
  670. wda_qmi_client_exit(data);
  671. qmi->wda_client = NULL;
  672. qmi->wda_pending = NULL;
  673. }
  674. for (i = 0; i < MAX_CLIENT_NUM; i++) {
  675. if (!__qmi_rmnet_delete_client(port, qmi, i))
  676. return;
  677. }
  678. }
  679. EXPORT_SYMBOL(qmi_rmnet_qmi_exit);
  680. void qmi_rmnet_enable_all_flows(struct net_device *dev)
  681. {
  682. struct qos_info *qos;
  683. struct rmnet_bearer_map *bearer;
  684. bool do_wake;
  685. qos = (struct qos_info *)rmnet_get_qos_pt(dev);
  686. if (!qos)
  687. return;
  688. spin_lock_bh(&qos->qos_lock);
  689. list_for_each_entry(bearer, &qos->bearer_head, list) {
  690. bearer->seq = 0;
  691. bearer->ack_req = 0;
  692. bearer->bytes_in_flight = 0;
  693. bearer->tcp_bidir = false;
  694. bearer->rat_switch = false;
  695. qmi_rmnet_watchdog_remove(bearer);
  696. if (bearer->tx_off)
  697. continue;
  698. do_wake = !bearer->grant_size;
  699. bearer->grant_size = DEFAULT_GRANT;
  700. bearer->grant_thresh = qmi_rmnet_grant_per(DEFAULT_GRANT);
  701. if (do_wake)
  702. dfc_bearer_flow_ctl(dev, bearer, qos);
  703. }
  704. spin_unlock_bh(&qos->qos_lock);
  705. }
  706. EXPORT_SYMBOL(qmi_rmnet_enable_all_flows);
  707. bool qmi_rmnet_all_flows_enabled(struct net_device *dev)
  708. {
  709. struct qos_info *qos;
  710. struct rmnet_bearer_map *bearer;
  711. bool ret = true;
  712. qos = (struct qos_info *)rmnet_get_qos_pt(dev);
  713. if (!qos)
  714. return true;
  715. spin_lock_bh(&qos->qos_lock);
  716. list_for_each_entry(bearer, &qos->bearer_head, list) {
  717. if (!bearer->grant_size) {
  718. ret = false;
  719. break;
  720. }
  721. }
  722. spin_unlock_bh(&qos->qos_lock);
  723. return ret;
  724. }
  725. EXPORT_SYMBOL(qmi_rmnet_all_flows_enabled);
  726. /**
  727. * rmnet_prepare_ps_bearers - get disabled bearers and
  728. * reset enabled bearers
  729. */
  730. void qmi_rmnet_prepare_ps_bearers(struct net_device *dev, u8 *num_bearers,
  731. u8 *bearer_id)
  732. {
  733. struct qos_info *qos;
  734. struct rmnet_bearer_map *bearer;
  735. u8 current_num_bearers = 0;
  736. u8 num_bearers_left = 0;
  737. qos = (struct qos_info *)rmnet_get_qos_pt(dev);
  738. if (!qos || !num_bearers)
  739. return;
  740. spin_lock_bh(&qos->qos_lock);
  741. num_bearers_left = *num_bearers;
  742. list_for_each_entry(bearer, &qos->bearer_head, list) {
  743. if (bearer->grant_size) {
  744. bearer->seq = 0;
  745. bearer->ack_req = 0;
  746. bearer->bytes_in_flight = 0;
  747. bearer->tcp_bidir = false;
  748. bearer->rat_switch = false;
  749. qmi_rmnet_watchdog_remove(bearer);
  750. bearer->grant_size = DEFAULT_GRANT;
  751. bearer->grant_thresh =
  752. qmi_rmnet_grant_per(DEFAULT_GRANT);
  753. } else if (num_bearers_left) {
  754. if (bearer_id)
  755. bearer_id[current_num_bearers] =
  756. bearer->bearer_id;
  757. current_num_bearers++;
  758. num_bearers_left--;
  759. } else {
  760. pr_err("DFC: no bearer space\n");
  761. }
  762. }
  763. *num_bearers = current_num_bearers;
  764. spin_unlock_bh(&qos->qos_lock);
  765. }
  766. EXPORT_SYMBOL(qmi_rmnet_prepare_ps_bearers);
  767. #ifdef CONFIG_QTI_QMI_DFC
  768. bool qmi_rmnet_get_flow_state(struct net_device *dev, struct sk_buff *skb,
  769. bool *drop, bool *is_low_latency)
  770. {
  771. struct qos_info *qos = rmnet_get_qos_pt(dev);
  772. int txq = skb->queue_mapping;
  773. if (txq > ACK_MQ_OFFSET)
  774. txq -= ACK_MQ_OFFSET;
  775. if (unlikely(!qos || txq >= MAX_MQ_NUM))
  776. return false;
  777. /* If the bearer is gone, packets may need to be dropped */
  778. *drop = (txq != DEFAULT_MQ_NUM && !READ_ONCE(qos->mq[txq].bearer) &&
  779. READ_ONCE(qos->mq[txq].drop_on_remove));
  780. *is_low_latency = READ_ONCE(qos->mq[txq].is_ll_ch);
  781. return true;
  782. }
  783. EXPORT_SYMBOL(qmi_rmnet_get_flow_state);
  784. void qmi_rmnet_burst_fc_check(struct net_device *dev,
  785. int ip_type, u32 mark, unsigned int len)
  786. {
  787. struct qos_info *qos = rmnet_get_qos_pt(dev);
  788. if (!qos)
  789. return;
  790. dfc_qmi_burst_check(dev, qos, ip_type, mark, len);
  791. }
  792. EXPORT_SYMBOL(qmi_rmnet_burst_fc_check);
  793. static bool _qmi_rmnet_is_tcp_ack(struct sk_buff *skb)
  794. {
  795. struct tcphdr *th;
  796. int ip_hdr_len;
  797. int ip_payload_len;
  798. if (skb->protocol == htons(ETH_P_IP) &&
  799. ip_hdr(skb)->protocol == IPPROTO_TCP) {
  800. ip_hdr_len = ip_hdr(skb)->ihl << 2;
  801. ip_payload_len = ntohs(ip_hdr(skb)->tot_len) - ip_hdr_len;
  802. } else if (skb->protocol == htons(ETH_P_IPV6) &&
  803. ipv6_hdr(skb)->nexthdr == IPPROTO_TCP) {
  804. ip_hdr_len = sizeof(struct ipv6hdr);
  805. ip_payload_len = ntohs(ipv6_hdr(skb)->payload_len);
  806. } else {
  807. return false;
  808. }
  809. th = (struct tcphdr *)(skb->data + ip_hdr_len);
  810. /* no longer looking for ACK flag */
  811. if (ip_payload_len == th->doff << 2)
  812. return true;
  813. return false;
  814. }
  815. static inline bool qmi_rmnet_is_tcp_ack(struct sk_buff *skb)
  816. {
  817. /* Locally generated TCP acks */
  818. if (skb_is_tcp_pure_ack(skb))
  819. return true;
  820. /* Forwarded */
  821. if (unlikely(_qmi_rmnet_is_tcp_ack(skb)))
  822. return true;
  823. return false;
  824. }
  825. static int qmi_rmnet_get_queue_sa(struct qos_info *qos, struct sk_buff *skb)
  826. {
  827. struct rmnet_flow_map *itm;
  828. int ip_type;
  829. int txq = DEFAULT_MQ_NUM;
  830. /* Put NDP in default mq */
  831. if (skb->protocol == htons(ETH_P_IPV6) &&
  832. ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6 &&
  833. icmp6_hdr(skb)->icmp6_type >= 133 &&
  834. icmp6_hdr(skb)->icmp6_type <= 137) {
  835. return DEFAULT_MQ_NUM;
  836. }
  837. ip_type = (skb->protocol == htons(ETH_P_IPV6)) ? AF_INET6 : AF_INET;
  838. spin_lock_bh(&qos->qos_lock);
  839. itm = qmi_rmnet_get_flow_map(qos, skb->mark, ip_type);
  840. if (unlikely(!itm))
  841. goto done;
  842. /* Put the packet in the assigned mq except TCP ack */
  843. if (likely(itm->bearer) && qmi_rmnet_is_tcp_ack(skb))
  844. txq = itm->bearer->ack_mq_idx;
  845. else
  846. txq = itm->mq_idx;
  847. done:
  848. spin_unlock_bh(&qos->qos_lock);
  849. return txq;
  850. }
  851. int qmi_rmnet_get_queue(struct net_device *dev, struct sk_buff *skb)
  852. {
  853. struct qos_info *qos = rmnet_get_qos_pt(dev);
  854. int txq = 0, ip_type = AF_INET;
  855. struct rmnet_flow_map *itm;
  856. u32 mark = skb->mark;
  857. if (!qos)
  858. return 0;
  859. if (likely(dfc_mode == DFC_MODE_SA))
  860. return qmi_rmnet_get_queue_sa(qos, skb);
  861. ip_type = (skb->protocol == htons(ETH_P_IPV6)) ? AF_INET6 : AF_INET;
  862. spin_lock_bh(&qos->qos_lock);
  863. itm = qmi_rmnet_get_flow_map(qos, mark, ip_type);
  864. if (itm)
  865. txq = itm->mq_idx;
  866. spin_unlock_bh(&qos->qos_lock);
  867. return txq;
  868. }
  869. EXPORT_SYMBOL(qmi_rmnet_get_queue);
  870. inline unsigned int qmi_rmnet_grant_per(unsigned int grant)
  871. {
  872. return grant / qmi_rmnet_scale_factor;
  873. }
  874. EXPORT_SYMBOL(qmi_rmnet_grant_per);
  875. void *qmi_rmnet_qos_init(struct net_device *real_dev,
  876. struct net_device *vnd_dev, u8 mux_id)
  877. {
  878. struct qos_info *qos;
  879. qos = kzalloc(sizeof(*qos), GFP_KERNEL);
  880. if (!qos)
  881. return NULL;
  882. qos->mux_id = mux_id;
  883. qos->real_dev = real_dev;
  884. qos->vnd_dev = vnd_dev;
  885. qos->tran_num = 0;
  886. INIT_LIST_HEAD(&qos->flow_head);
  887. INIT_LIST_HEAD(&qos->bearer_head);
  888. spin_lock_init(&qos->qos_lock);
  889. return qos;
  890. }
  891. EXPORT_SYMBOL(qmi_rmnet_qos_init);
  892. void qmi_rmnet_qos_exit_pre(void *qos)
  893. {
  894. struct qos_info *qosi = (struct qos_info *)qos;
  895. struct rmnet_bearer_map *bearer;
  896. if (!qos)
  897. return;
  898. list_for_each_entry(bearer, &qosi->bearer_head, list) {
  899. bearer->watchdog_quit = true;
  900. del_timer_sync(&bearer->watchdog);
  901. bearer->ch_switch.timer_quit = true;
  902. del_timer_sync(&bearer->ch_switch.guard_timer);
  903. }
  904. list_add(&qosi->list, &qos_cleanup_list);
  905. }
  906. EXPORT_SYMBOL(qmi_rmnet_qos_exit_pre);
  907. void qmi_rmnet_qos_exit_post(void)
  908. {
  909. struct qos_info *qos, *tmp;
  910. synchronize_rcu();
  911. list_for_each_entry_safe(qos, tmp, &qos_cleanup_list, list) {
  912. list_del(&qos->list);
  913. qmi_rmnet_clean_flow_list(qos);
  914. kfree(qos);
  915. }
  916. }
  917. EXPORT_SYMBOL(qmi_rmnet_qos_exit_post);
  918. #endif
  919. #ifdef CONFIG_QTI_QMI_POWER_COLLAPSE
  920. static struct workqueue_struct *rmnet_ps_wq;
  921. static struct rmnet_powersave_work *rmnet_work;
  922. static bool rmnet_work_quit;
  923. static bool rmnet_work_inited;
  924. static LIST_HEAD(ps_list);
  925. static u8 ps_bearer_id[32];
  926. struct rmnet_powersave_work {
  927. struct delayed_work work;
  928. struct alarm atimer;
  929. void *port;
  930. u64 old_rx_pkts;
  931. u64 old_tx_pkts;
  932. };
  933. void qmi_rmnet_ps_on_notify(void *port)
  934. {
  935. struct qmi_rmnet_ps_ind *tmp;
  936. list_for_each_entry_rcu(tmp, &ps_list, list)
  937. tmp->ps_on_handler(port);
  938. }
  939. EXPORT_SYMBOL(qmi_rmnet_ps_on_notify);
  940. void qmi_rmnet_ps_off_notify(void *port)
  941. {
  942. struct qmi_rmnet_ps_ind *tmp;
  943. list_for_each_entry_rcu(tmp, &ps_list, list)
  944. tmp->ps_off_handler(port);
  945. }
  946. EXPORT_SYMBOL(qmi_rmnet_ps_off_notify);
  947. int qmi_rmnet_ps_ind_register(void *port,
  948. struct qmi_rmnet_ps_ind *ps_ind)
  949. {
  950. if (!port || !ps_ind || !ps_ind->ps_on_handler ||
  951. !ps_ind->ps_off_handler)
  952. return -EINVAL;
  953. list_add_rcu(&ps_ind->list, &ps_list);
  954. return 0;
  955. }
  956. EXPORT_SYMBOL(qmi_rmnet_ps_ind_register);
  957. int qmi_rmnet_ps_ind_deregister(void *port,
  958. struct qmi_rmnet_ps_ind *ps_ind)
  959. {
  960. struct qmi_rmnet_ps_ind *tmp;
  961. if (!port || !ps_ind)
  962. return -EINVAL;
  963. list_for_each_entry_rcu(tmp, &ps_list, list) {
  964. if (tmp == ps_ind) {
  965. list_del_rcu(&ps_ind->list);
  966. goto done;
  967. }
  968. }
  969. done:
  970. return 0;
  971. }
  972. EXPORT_SYMBOL(qmi_rmnet_ps_ind_deregister);
  973. int qmi_rmnet_set_powersave_mode(void *port, uint8_t enable)
  974. {
  975. int rc = -EINVAL;
  976. struct qmi_info *qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  977. if (!qmi || !qmi->wda_client)
  978. return rc;
  979. rc = wda_set_powersave_mode(qmi->wda_client, enable);
  980. if (rc < 0) {
  981. pr_err("%s() failed set powersave mode[%u], err=%d\n",
  982. __func__, enable, rc);
  983. return rc;
  984. }
  985. return 0;
  986. }
  987. EXPORT_SYMBOL(qmi_rmnet_set_powersave_mode);
  988. static void qmi_rmnet_work_restart(void *port)
  989. {
  990. rcu_read_lock();
  991. if (!rmnet_work_quit)
  992. queue_delayed_work(rmnet_ps_wq, &rmnet_work->work, NO_DELAY);
  993. rcu_read_unlock();
  994. }
  995. static enum alarmtimer_restart qmi_rmnet_work_alarm(struct alarm *atimer,
  996. ktime_t now)
  997. {
  998. struct rmnet_powersave_work *real_work;
  999. real_work = container_of(atimer, struct rmnet_powersave_work, atimer);
  1000. qmi_rmnet_work_restart(real_work->port);
  1001. return ALARMTIMER_NORESTART;
  1002. }
  1003. static void dfc_wakelock_acquire(struct qmi_info *qmi)
  1004. {
  1005. if (qmi && !qmi->wakelock_active) {
  1006. __pm_stay_awake(qmi->ws);
  1007. qmi->wakelock_active = true;
  1008. }
  1009. }
  1010. static void dfc_wakelock_release(struct qmi_info *qmi)
  1011. {
  1012. if (qmi && qmi->wakelock_active) {
  1013. __pm_relax(qmi->ws);
  1014. qmi->wakelock_active = false;
  1015. }
  1016. }
  1017. static void qmi_rmnet_check_stats(struct work_struct *work)
  1018. {
  1019. struct rmnet_powersave_work *real_work;
  1020. struct qmi_info *qmi;
  1021. u64 rxd, txd;
  1022. u64 rx, tx;
  1023. bool dl_msg_active;
  1024. bool use_alarm_timer = true;
  1025. real_work = container_of(to_delayed_work(work),
  1026. struct rmnet_powersave_work, work);
  1027. if (unlikely(!real_work || !real_work->port))
  1028. return;
  1029. qmi = (struct qmi_info *)rmnet_get_qmi_pt(real_work->port);
  1030. if (unlikely(!qmi))
  1031. return;
  1032. dfc_wakelock_release(qmi);
  1033. rmnet_get_packets(real_work->port, &rx, &tx);
  1034. rxd = rx - real_work->old_rx_pkts;
  1035. txd = tx - real_work->old_tx_pkts;
  1036. real_work->old_rx_pkts = rx;
  1037. real_work->old_tx_pkts = tx;
  1038. dl_msg_active = qmi->dl_msg_active;
  1039. qmi->dl_msg_active = false;
  1040. if (qmi->ps_enabled) {
  1041. /* Ready to accept grant */
  1042. qmi->ps_ignore_grant = false;
  1043. /* Register to get QMI DFC and DL marker */
  1044. if (qmi_rmnet_set_powersave_mode(real_work->port, 0) < 0)
  1045. goto end;
  1046. qmi->ps_enabled = false;
  1047. /* Do a query when coming out of powersave */
  1048. qmi_rmnet_query_flows(qmi);
  1049. if (rmnet_get_powersave_notif(real_work->port))
  1050. qmi_rmnet_ps_off_notify(real_work->port);
  1051. goto end;
  1052. }
  1053. if (!rxd && !txd) {
  1054. /* If no DL msg received and there is a flow disabled,
  1055. * (likely in RLF), no need to enter powersave
  1056. */
  1057. if (!dl_msg_active &&
  1058. !rmnet_all_flows_enabled(real_work->port)) {
  1059. use_alarm_timer = false;
  1060. goto end;
  1061. }
  1062. /* Deregister to suppress QMI DFC and DL marker */
  1063. if (qmi_rmnet_set_powersave_mode(real_work->port, 1) < 0)
  1064. goto end;
  1065. qmi->ps_enabled = true;
  1066. /* Ignore grant after going into powersave */
  1067. qmi->ps_ignore_grant = true;
  1068. /* Clear the bit before enabling flow so pending packets
  1069. * can trigger the work again
  1070. */
  1071. clear_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active);
  1072. rmnet_enable_all_flows(real_work->port);
  1073. if (rmnet_get_powersave_notif(real_work->port))
  1074. qmi_rmnet_ps_on_notify(real_work->port);
  1075. return;
  1076. }
  1077. end:
  1078. rcu_read_lock();
  1079. if (!rmnet_work_quit) {
  1080. if (use_alarm_timer) {
  1081. /* Suspend will fail and get delayed for 2s if
  1082. * alarmtimer expires within 2s. Hold a wakelock
  1083. * for the actual timer duration to prevent suspend
  1084. */
  1085. if (PS_INTERVAL_MS < 2000)
  1086. dfc_wakelock_acquire(qmi);
  1087. alarm_start_relative(&real_work->atimer,
  1088. PS_INTERVAL_KT);
  1089. } else {
  1090. queue_delayed_work(rmnet_ps_wq, &real_work->work,
  1091. PS_INTERVAL_JF);
  1092. }
  1093. }
  1094. rcu_read_unlock();
  1095. }
  1096. static void qmi_rmnet_check_stats_2(struct work_struct *work)
  1097. {
  1098. struct rmnet_powersave_work *real_work;
  1099. struct qmi_info *qmi;
  1100. u64 rxd, txd;
  1101. u64 rx, tx;
  1102. u8 num_bearers;
  1103. real_work = container_of(to_delayed_work(work),
  1104. struct rmnet_powersave_work, work);
  1105. if (unlikely(!real_work->port))
  1106. return;
  1107. qmi = (struct qmi_info *)rmnet_get_qmi_pt(real_work->port);
  1108. if (unlikely(!qmi))
  1109. return;
  1110. if (PS_INTERVAL_MS < 2000)
  1111. dfc_wakelock_acquire(qmi);
  1112. rmnet_get_packets(real_work->port, &rx, &tx);
  1113. rxd = rx - real_work->old_rx_pkts;
  1114. txd = tx - real_work->old_tx_pkts;
  1115. real_work->old_rx_pkts = rx;
  1116. real_work->old_tx_pkts = tx;
  1117. if (qmi->ps_enabled) {
  1118. /* Ready to accept grant */
  1119. qmi->ps_ignore_grant = false;
  1120. /* Out of powersave */
  1121. if (dfc_qmap_set_powersave(0, 0, NULL))
  1122. goto end;
  1123. qmi->ps_enabled = false;
  1124. if (rmnet_get_powersave_notif(real_work->port))
  1125. qmi_rmnet_ps_off_notify(real_work->port);
  1126. goto end;
  1127. }
  1128. if (!rxd && !txd) {
  1129. qmi->ps_ignore_grant = true;
  1130. qmi->ps_enabled = true;
  1131. clear_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active);
  1132. smp_mb();
  1133. num_bearers = sizeof(ps_bearer_id);
  1134. memset(ps_bearer_id, 0, sizeof(ps_bearer_id));
  1135. rmnet_prepare_ps_bearers(real_work->port, &num_bearers,
  1136. ps_bearer_id);
  1137. /* Enter powersave */
  1138. dfc_qmap_set_powersave(1, num_bearers, ps_bearer_id);
  1139. if (rmnet_get_powersave_notif(real_work->port))
  1140. qmi_rmnet_ps_on_notify(real_work->port);
  1141. dfc_wakelock_release(qmi);
  1142. return;
  1143. }
  1144. end:
  1145. rcu_read_lock();
  1146. if (!rmnet_work_quit)
  1147. alarm_start_relative(&real_work->atimer, PS_INTERVAL_KT);
  1148. else
  1149. dfc_wakelock_release(qmi);
  1150. rcu_read_unlock();
  1151. }
  1152. static void qmi_rmnet_work_set_active(void *port, int status)
  1153. {
  1154. struct qmi_info *qmi;
  1155. qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  1156. if (unlikely(!qmi))
  1157. return;
  1158. if (status)
  1159. set_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active);
  1160. else
  1161. clear_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active);
  1162. }
  1163. void qmi_rmnet_work_init(void *port)
  1164. {
  1165. if (rmnet_ps_wq)
  1166. return;
  1167. rmnet_ps_wq = alloc_workqueue("rmnet_powersave_work",
  1168. WQ_CPU_INTENSIVE, 1);
  1169. if (!rmnet_ps_wq)
  1170. return;
  1171. rmnet_work = kzalloc(sizeof(*rmnet_work), GFP_ATOMIC);
  1172. if (!rmnet_work) {
  1173. destroy_workqueue(rmnet_ps_wq);
  1174. rmnet_ps_wq = NULL;
  1175. return;
  1176. }
  1177. if (dfc_qmap && dfc_ps_ext)
  1178. INIT_DEFERRABLE_WORK(&rmnet_work->work,
  1179. qmi_rmnet_check_stats_2);
  1180. else
  1181. INIT_DEFERRABLE_WORK(&rmnet_work->work, qmi_rmnet_check_stats);
  1182. alarm_init(&rmnet_work->atimer, ALARM_BOOTTIME, qmi_rmnet_work_alarm);
  1183. rmnet_work->port = port;
  1184. rmnet_get_packets(rmnet_work->port, &rmnet_work->old_rx_pkts,
  1185. &rmnet_work->old_tx_pkts);
  1186. rmnet_work_quit = false;
  1187. qmi_rmnet_work_set_active(rmnet_work->port, 0);
  1188. rmnet_work_inited = true;
  1189. }
  1190. EXPORT_SYMBOL(qmi_rmnet_work_init);
  1191. void qmi_rmnet_work_maybe_restart(void *port)
  1192. {
  1193. struct qmi_info *qmi;
  1194. qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  1195. if (unlikely(!qmi || !rmnet_work_inited))
  1196. return;
  1197. if (!test_and_set_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active)) {
  1198. qmi->ps_ignore_grant = false;
  1199. qmi_rmnet_work_restart(port);
  1200. }
  1201. }
  1202. EXPORT_SYMBOL(qmi_rmnet_work_maybe_restart);
  1203. void qmi_rmnet_work_exit(void *port)
  1204. {
  1205. if (!rmnet_ps_wq || !rmnet_work)
  1206. return;
  1207. rmnet_work_quit = true;
  1208. synchronize_rcu();
  1209. rmnet_work_inited = false;
  1210. alarm_cancel(&rmnet_work->atimer);
  1211. cancel_delayed_work_sync(&rmnet_work->work);
  1212. destroy_workqueue(rmnet_ps_wq);
  1213. qmi_rmnet_work_set_active(port, 0);
  1214. rmnet_ps_wq = NULL;
  1215. kfree(rmnet_work);
  1216. rmnet_work = NULL;
  1217. dfc_wakelock_release((struct qmi_info *)rmnet_get_qmi_pt(port));
  1218. }
  1219. EXPORT_SYMBOL(qmi_rmnet_work_exit);
  1220. void qmi_rmnet_set_dl_msg_active(void *port)
  1221. {
  1222. struct qmi_info *qmi;
  1223. qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  1224. if (unlikely(!qmi))
  1225. return;
  1226. qmi->dl_msg_active = true;
  1227. }
  1228. EXPORT_SYMBOL(qmi_rmnet_set_dl_msg_active);
  1229. void qmi_rmnet_flush_ps_wq(void)
  1230. {
  1231. if (rmnet_ps_wq)
  1232. flush_workqueue(rmnet_ps_wq);
  1233. }
  1234. bool qmi_rmnet_ignore_grant(void *port)
  1235. {
  1236. struct qmi_info *qmi;
  1237. qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  1238. if (unlikely(!qmi))
  1239. return false;
  1240. return qmi->ps_ignore_grant;
  1241. }
  1242. EXPORT_SYMBOL(qmi_rmnet_ignore_grant);
  1243. #endif