qmi_rmnet.c 34 KB

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