qmi_rmnet.c 27 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229
  1. /*
  2. * Copyright (c) 2018-2020, 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 <linux/module.h>
  22. #include <linux/moduleparam.h>
  23. #include <linux/ip.h>
  24. #include <linux/ipv6.h>
  25. #include <linux/alarmtimer.h>
  26. #define NLMSG_FLOW_ACTIVATE 1
  27. #define NLMSG_FLOW_DEACTIVATE 2
  28. #define NLMSG_CLIENT_SETUP 4
  29. #define NLMSG_CLIENT_DELETE 5
  30. #define NLMSG_SCALE_FACTOR 6
  31. #define NLMSG_WQ_FREQUENCY 7
  32. #define FLAG_DFC_MASK 0x000F
  33. #define FLAG_POWERSAVE_MASK 0x0010
  34. #define FLAG_QMAP_MASK 0x0020
  35. #define FLAG_TO_MODE(f) ((f) & FLAG_DFC_MASK)
  36. #define DFC_SUPPORTED_MODE(m) \
  37. ((m) == DFC_MODE_FLOW_ID || (m) == DFC_MODE_MQ_NUM || \
  38. (m) == DFC_MODE_SA)
  39. #define FLAG_TO_QMAP(f) ((f) & FLAG_QMAP_MASK)
  40. int dfc_mode;
  41. int dfc_qmap;
  42. #define IS_ANCILLARY(type) ((type) != AF_INET && (type) != AF_INET6)
  43. unsigned int rmnet_wq_frequency __read_mostly = 1000;
  44. #define PS_WORK_ACTIVE_BIT 0
  45. #define PS_INTERVAL (((!rmnet_wq_frequency) ? \
  46. 1 : rmnet_wq_frequency/10) * (HZ/100))
  47. #define NO_DELAY (0x0000 * HZ)
  48. #define PS_INTERVAL_KT (ms_to_ktime(1000))
  49. #ifdef CONFIG_QTI_QMI_DFC
  50. static unsigned int qmi_rmnet_scale_factor = 5;
  51. static LIST_HEAD(qos_cleanup_list);
  52. #endif
  53. static int
  54. qmi_rmnet_del_flow(struct net_device *dev, struct tcmsg *tcm,
  55. struct qmi_info *qmi);
  56. struct qmi_elem_info data_ep_id_type_v01_ei[] = {
  57. {
  58. .data_type = QMI_SIGNED_4_BYTE_ENUM,
  59. .elem_len = 1,
  60. .elem_size = sizeof(enum data_ep_type_enum_v01),
  61. .array_type = NO_ARRAY,
  62. .tlv_type = QMI_COMMON_TLV_TYPE,
  63. .offset = offsetof(struct data_ep_id_type_v01,
  64. ep_type),
  65. .ei_array = NULL,
  66. },
  67. {
  68. .data_type = QMI_UNSIGNED_4_BYTE,
  69. .elem_len = 1,
  70. .elem_size = sizeof(u32),
  71. .array_type = NO_ARRAY,
  72. .tlv_type = QMI_COMMON_TLV_TYPE,
  73. .offset = offsetof(struct data_ep_id_type_v01,
  74. iface_id),
  75. .ei_array = NULL,
  76. },
  77. {
  78. .data_type = QMI_EOTI,
  79. .elem_len = 0,
  80. .elem_size = 0,
  81. .array_type = NO_ARRAY,
  82. .tlv_type = QMI_COMMON_TLV_TYPE,
  83. .offset = 0,
  84. .ei_array = NULL,
  85. },
  86. };
  87. EXPORT_SYMBOL(data_ep_id_type_v01_ei);
  88. void *qmi_rmnet_has_dfc_client(struct qmi_info *qmi)
  89. {
  90. int i;
  91. if (!qmi)
  92. return NULL;
  93. for (i = 0; i < MAX_CLIENT_NUM; i++) {
  94. if (qmi->dfc_clients[i])
  95. return qmi->dfc_clients[i];
  96. }
  97. return NULL;
  98. }
  99. static inline int
  100. qmi_rmnet_has_client(struct qmi_info *qmi)
  101. {
  102. if (qmi->wda_client)
  103. return 1;
  104. return qmi_rmnet_has_dfc_client(qmi) ? 1 : 0;
  105. }
  106. static int
  107. qmi_rmnet_has_pending(struct qmi_info *qmi)
  108. {
  109. int i;
  110. if (qmi->wda_pending)
  111. return 1;
  112. for (i = 0; i < MAX_CLIENT_NUM; i++) {
  113. if (qmi->dfc_pending[i])
  114. return 1;
  115. }
  116. return 0;
  117. }
  118. #ifdef CONFIG_QTI_QMI_DFC
  119. static void
  120. qmi_rmnet_clean_flow_list(struct qos_info *qos)
  121. {
  122. struct rmnet_bearer_map *bearer, *br_tmp;
  123. struct rmnet_flow_map *itm, *fl_tmp;
  124. ASSERT_RTNL();
  125. list_for_each_entry_safe(itm, fl_tmp, &qos->flow_head, list) {
  126. list_del(&itm->list);
  127. kfree(itm);
  128. }
  129. list_for_each_entry_safe(bearer, br_tmp, &qos->bearer_head, list) {
  130. list_del(&bearer->list);
  131. kfree(bearer);
  132. }
  133. memset(qos->mq, 0, sizeof(qos->mq));
  134. }
  135. struct rmnet_flow_map *
  136. qmi_rmnet_get_flow_map(struct qos_info *qos, u32 flow_id, int ip_type)
  137. {
  138. struct rmnet_flow_map *itm;
  139. if (!qos)
  140. return NULL;
  141. list_for_each_entry(itm, &qos->flow_head, list) {
  142. if ((itm->flow_id == flow_id) && (itm->ip_type == ip_type))
  143. return itm;
  144. }
  145. return NULL;
  146. }
  147. struct rmnet_bearer_map *
  148. qmi_rmnet_get_bearer_map(struct qos_info *qos, uint8_t bearer_id)
  149. {
  150. struct rmnet_bearer_map *itm;
  151. if (!qos)
  152. return NULL;
  153. list_for_each_entry(itm, &qos->bearer_head, list) {
  154. if (itm->bearer_id == bearer_id)
  155. return itm;
  156. }
  157. return NULL;
  158. }
  159. static void qmi_rmnet_update_flow_map(struct rmnet_flow_map *itm,
  160. struct rmnet_flow_map *new_map)
  161. {
  162. itm->bearer_id = new_map->bearer_id;
  163. itm->flow_id = new_map->flow_id;
  164. itm->ip_type = new_map->ip_type;
  165. itm->mq_idx = new_map->mq_idx;
  166. }
  167. int qmi_rmnet_flow_control(struct net_device *dev, u32 mq_idx, int enable)
  168. {
  169. struct netdev_queue *q;
  170. if (unlikely(mq_idx >= dev->num_tx_queues))
  171. return 0;
  172. q = netdev_get_tx_queue(dev, mq_idx);
  173. if (unlikely(!q))
  174. return 0;
  175. if (enable)
  176. netif_tx_wake_queue(q);
  177. else
  178. netif_tx_stop_queue(q);
  179. trace_dfc_qmi_tc(dev->name, mq_idx, enable);
  180. return 0;
  181. }
  182. static void qmi_rmnet_reset_txq(struct net_device *dev, unsigned int txq)
  183. {
  184. struct Qdisc *qdisc;
  185. if (unlikely(txq >= dev->num_tx_queues))
  186. return;
  187. qdisc = rtnl_dereference(netdev_get_tx_queue(dev, txq)->qdisc);
  188. if (qdisc) {
  189. spin_lock_bh(qdisc_lock(qdisc));
  190. qdisc_reset(qdisc);
  191. spin_unlock_bh(qdisc_lock(qdisc));
  192. }
  193. }
  194. static struct rmnet_bearer_map *__qmi_rmnet_bearer_get(
  195. struct qos_info *qos_info, u8 bearer_id)
  196. {
  197. struct rmnet_bearer_map *bearer;
  198. bearer = qmi_rmnet_get_bearer_map(qos_info, bearer_id);
  199. if (bearer) {
  200. bearer->flow_ref++;
  201. } else {
  202. bearer = kzalloc(sizeof(*bearer), GFP_ATOMIC);
  203. if (!bearer)
  204. return NULL;
  205. bearer->bearer_id = bearer_id;
  206. bearer->flow_ref = 1;
  207. bearer->grant_size = DEFAULT_CALL_GRANT;
  208. bearer->grant_thresh = qmi_rmnet_grant_per(bearer->grant_size);
  209. bearer->mq_idx = INVALID_MQ;
  210. bearer->ack_mq_idx = INVALID_MQ;
  211. list_add(&bearer->list, &qos_info->bearer_head);
  212. }
  213. return bearer;
  214. }
  215. static void __qmi_rmnet_bearer_put(struct net_device *dev,
  216. struct qos_info *qos_info,
  217. struct rmnet_bearer_map *bearer,
  218. bool reset)
  219. {
  220. struct mq_map *mq;
  221. int i, j;
  222. if (bearer && --bearer->flow_ref == 0) {
  223. for (i = 0; i < MAX_MQ_NUM; i++) {
  224. mq = &qos_info->mq[i];
  225. if (mq->bearer != bearer)
  226. continue;
  227. mq->bearer = NULL;
  228. if (reset) {
  229. qmi_rmnet_reset_txq(dev, i);
  230. qmi_rmnet_flow_control(dev, i, 1);
  231. if (dfc_mode == DFC_MODE_SA) {
  232. j = i + ACK_MQ_OFFSET;
  233. qmi_rmnet_reset_txq(dev, j);
  234. qmi_rmnet_flow_control(dev, j, 1);
  235. }
  236. }
  237. }
  238. /* Remove from bearer map */
  239. list_del(&bearer->list);
  240. kfree(bearer);
  241. }
  242. }
  243. static void __qmi_rmnet_update_mq(struct net_device *dev,
  244. struct qos_info *qos_info,
  245. struct rmnet_bearer_map *bearer,
  246. struct rmnet_flow_map *itm)
  247. {
  248. struct mq_map *mq;
  249. /* In SA mode default mq is not associated with any bearer */
  250. if (dfc_mode == DFC_MODE_SA && itm->mq_idx == DEFAULT_MQ_NUM)
  251. return;
  252. mq = &qos_info->mq[itm->mq_idx];
  253. if (!mq->bearer) {
  254. mq->bearer = bearer;
  255. if (dfc_mode == DFC_MODE_SA) {
  256. bearer->mq_idx = itm->mq_idx;
  257. bearer->ack_mq_idx = itm->mq_idx + ACK_MQ_OFFSET;
  258. } else {
  259. if (IS_ANCILLARY(itm->ip_type))
  260. bearer->ack_mq_idx = itm->mq_idx;
  261. else
  262. bearer->mq_idx = itm->mq_idx;
  263. }
  264. qmi_rmnet_flow_control(dev, itm->mq_idx,
  265. bearer->grant_size > 0 ? 1 : 0);
  266. if (dfc_mode == DFC_MODE_SA)
  267. qmi_rmnet_flow_control(dev, bearer->ack_mq_idx,
  268. bearer->grant_size > 0 ? 1 : 0);
  269. }
  270. }
  271. static int __qmi_rmnet_rebind_flow(struct net_device *dev,
  272. struct qos_info *qos_info,
  273. struct rmnet_flow_map *itm,
  274. struct rmnet_flow_map *new_map)
  275. {
  276. struct rmnet_bearer_map *bearer;
  277. __qmi_rmnet_bearer_put(dev, qos_info, itm->bearer, false);
  278. bearer = __qmi_rmnet_bearer_get(qos_info, new_map->bearer_id);
  279. if (!bearer)
  280. return -ENOMEM;
  281. qmi_rmnet_update_flow_map(itm, new_map);
  282. itm->bearer = bearer;
  283. __qmi_rmnet_update_mq(dev, qos_info, bearer, itm);
  284. return 0;
  285. }
  286. static int qmi_rmnet_add_flow(struct net_device *dev, struct tcmsg *tcm,
  287. struct qmi_info *qmi)
  288. {
  289. struct qos_info *qos_info = (struct qos_info *)rmnet_get_qos_pt(dev);
  290. struct rmnet_flow_map new_map, *itm;
  291. struct rmnet_bearer_map *bearer;
  292. struct tcmsg tmp_tcm;
  293. int rc = 0;
  294. if (!qos_info || !tcm || tcm->tcm_handle >= MAX_MQ_NUM)
  295. return -EINVAL;
  296. ASSERT_RTNL();
  297. /* flow activate
  298. * tcm->tcm__pad1 - bearer_id, tcm->tcm_parent - flow_id,
  299. * tcm->tcm_ifindex - ip_type, tcm->tcm_handle - mq_idx
  300. */
  301. new_map.bearer_id = tcm->tcm__pad1;
  302. new_map.flow_id = tcm->tcm_parent;
  303. new_map.ip_type = tcm->tcm_ifindex;
  304. new_map.mq_idx = tcm->tcm_handle;
  305. trace_dfc_flow_info(dev->name, new_map.bearer_id, new_map.flow_id,
  306. new_map.ip_type, new_map.mq_idx, 1);
  307. again:
  308. spin_lock_bh(&qos_info->qos_lock);
  309. itm = qmi_rmnet_get_flow_map(qos_info, new_map.flow_id,
  310. new_map.ip_type);
  311. if (itm) {
  312. if (itm->bearer_id != new_map.bearer_id) {
  313. rc = __qmi_rmnet_rebind_flow(
  314. dev, qos_info, itm, &new_map);
  315. goto done;
  316. } else if (itm->mq_idx != new_map.mq_idx) {
  317. tmp_tcm.tcm__pad1 = itm->bearer_id;
  318. tmp_tcm.tcm_parent = itm->flow_id;
  319. tmp_tcm.tcm_ifindex = itm->ip_type;
  320. tmp_tcm.tcm_handle = itm->mq_idx;
  321. spin_unlock_bh(&qos_info->qos_lock);
  322. qmi_rmnet_del_flow(dev, &tmp_tcm, qmi);
  323. goto again;
  324. } else {
  325. goto done;
  326. }
  327. }
  328. /* Create flow map */
  329. itm = kzalloc(sizeof(*itm), GFP_ATOMIC);
  330. if (!itm) {
  331. spin_unlock_bh(&qos_info->qos_lock);
  332. return -ENOMEM;
  333. }
  334. qmi_rmnet_update_flow_map(itm, &new_map);
  335. list_add(&itm->list, &qos_info->flow_head);
  336. /* Create or update bearer map */
  337. bearer = __qmi_rmnet_bearer_get(qos_info, new_map.bearer_id);
  338. if (!bearer) {
  339. rc = -ENOMEM;
  340. goto done;
  341. }
  342. itm->bearer = bearer;
  343. __qmi_rmnet_update_mq(dev, qos_info, bearer, itm);
  344. done:
  345. spin_unlock_bh(&qos_info->qos_lock);
  346. return rc;
  347. }
  348. static int
  349. qmi_rmnet_del_flow(struct net_device *dev, struct tcmsg *tcm,
  350. struct qmi_info *qmi)
  351. {
  352. struct qos_info *qos_info = (struct qos_info *)rmnet_get_qos_pt(dev);
  353. struct rmnet_flow_map new_map, *itm;
  354. if (!qos_info)
  355. return -EINVAL;
  356. ASSERT_RTNL();
  357. /* flow deactivate
  358. * tcm->tcm__pad1 - bearer_id, tcm->tcm_parent - flow_id,
  359. * tcm->tcm_ifindex - ip_type
  360. */
  361. spin_lock_bh(&qos_info->qos_lock);
  362. new_map.bearer_id = tcm->tcm__pad1;
  363. new_map.flow_id = tcm->tcm_parent;
  364. new_map.ip_type = tcm->tcm_ifindex;
  365. itm = qmi_rmnet_get_flow_map(qos_info, new_map.flow_id,
  366. new_map.ip_type);
  367. if (itm) {
  368. trace_dfc_flow_info(dev->name, new_map.bearer_id,
  369. new_map.flow_id, new_map.ip_type,
  370. itm->mq_idx, 0);
  371. __qmi_rmnet_bearer_put(dev, qos_info, itm->bearer, true);
  372. /* Remove from flow map */
  373. list_del(&itm->list);
  374. kfree(itm);
  375. }
  376. if (list_empty(&qos_info->flow_head))
  377. netif_tx_wake_all_queues(dev);
  378. spin_unlock_bh(&qos_info->qos_lock);
  379. return 0;
  380. }
  381. static void qmi_rmnet_query_flows(struct qmi_info *qmi)
  382. {
  383. int i;
  384. for (i = 0; i < MAX_CLIENT_NUM; i++) {
  385. if (qmi->dfc_clients[i] && !dfc_qmap)
  386. dfc_qmi_query_flow(qmi->dfc_clients[i]);
  387. }
  388. }
  389. struct rmnet_bearer_map *qmi_rmnet_get_bearer_noref(struct qos_info *qos_info,
  390. u8 bearer_id)
  391. {
  392. struct rmnet_bearer_map *bearer;
  393. bearer = __qmi_rmnet_bearer_get(qos_info, bearer_id);
  394. if (bearer)
  395. bearer->flow_ref--;
  396. return bearer;
  397. }
  398. #else
  399. static inline void
  400. qmi_rmnet_update_flow_map(struct rmnet_flow_map *itm,
  401. struct rmnet_flow_map *new_map)
  402. {
  403. }
  404. static inline int
  405. qmi_rmnet_add_flow(struct net_device *dev, struct tcmsg *tcm,
  406. struct qmi_info *qmi)
  407. {
  408. return -EINVAL;
  409. }
  410. static inline int
  411. qmi_rmnet_del_flow(struct net_device *dev, struct tcmsg *tcm,
  412. struct qmi_info *qmi)
  413. {
  414. return -EINVAL;
  415. }
  416. static inline void qmi_rmnet_query_flows(struct qmi_info *qmi)
  417. {
  418. }
  419. #endif
  420. static int
  421. qmi_rmnet_setup_client(void *port, struct qmi_info *qmi, struct tcmsg *tcm)
  422. {
  423. int idx, err = 0;
  424. struct svc_info svc;
  425. ASSERT_RTNL();
  426. /* client setup
  427. * tcm->tcm_handle - instance, tcm->tcm_info - ep_type,
  428. * tcm->tcm_parent - iface_id, tcm->tcm_ifindex - flags
  429. */
  430. idx = (tcm->tcm_handle == 0) ? 0 : 1;
  431. if (!qmi) {
  432. qmi = kzalloc(sizeof(struct qmi_info), GFP_ATOMIC);
  433. if (!qmi)
  434. return -ENOMEM;
  435. rmnet_init_qmi_pt(port, qmi);
  436. }
  437. qmi->flag = tcm->tcm_ifindex;
  438. svc.instance = tcm->tcm_handle;
  439. svc.ep_type = tcm->tcm_info;
  440. svc.iface_id = tcm->tcm_parent;
  441. if (DFC_SUPPORTED_MODE(dfc_mode) &&
  442. !qmi->dfc_clients[idx] && !qmi->dfc_pending[idx]) {
  443. if (dfc_qmap)
  444. err = dfc_qmap_client_init(port, idx, &svc, qmi);
  445. else
  446. err = dfc_qmi_client_init(port, idx, &svc, qmi);
  447. }
  448. if ((tcm->tcm_ifindex & FLAG_POWERSAVE_MASK) &&
  449. (idx == 0) && !qmi->wda_client && !qmi->wda_pending) {
  450. err = wda_qmi_client_init(port, &svc, qmi);
  451. }
  452. return err;
  453. }
  454. static int
  455. __qmi_rmnet_delete_client(void *port, struct qmi_info *qmi, int idx)
  456. {
  457. void *data = NULL;
  458. ASSERT_RTNL();
  459. if (qmi->dfc_clients[idx])
  460. data = qmi->dfc_clients[idx];
  461. else if (qmi->dfc_pending[idx])
  462. data = qmi->dfc_pending[idx];
  463. if (data) {
  464. if (dfc_qmap)
  465. dfc_qmap_client_exit(data);
  466. else
  467. dfc_qmi_client_exit(data);
  468. qmi->dfc_clients[idx] = NULL;
  469. qmi->dfc_pending[idx] = NULL;
  470. }
  471. if (!qmi_rmnet_has_client(qmi) && !qmi_rmnet_has_pending(qmi)) {
  472. rmnet_reset_qmi_pt(port);
  473. kfree(qmi);
  474. return 0;
  475. }
  476. return 1;
  477. }
  478. static void
  479. qmi_rmnet_delete_client(void *port, struct qmi_info *qmi, struct tcmsg *tcm)
  480. {
  481. int idx;
  482. void *data = NULL;
  483. /* client delete: tcm->tcm_handle - instance*/
  484. idx = (tcm->tcm_handle == 0) ? 0 : 1;
  485. ASSERT_RTNL();
  486. if (qmi->wda_client)
  487. data = qmi->wda_client;
  488. else if (qmi->wda_pending)
  489. data = qmi->wda_pending;
  490. if ((idx == 0) && data) {
  491. wda_qmi_client_exit(data);
  492. qmi->wda_client = NULL;
  493. qmi->wda_pending = NULL;
  494. } else {
  495. qmi_rmnet_flush_ps_wq();
  496. }
  497. __qmi_rmnet_delete_client(port, qmi, idx);
  498. }
  499. void qmi_rmnet_change_link(struct net_device *dev, void *port, void *tcm_pt)
  500. {
  501. struct qmi_info *qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  502. struct tcmsg *tcm = (struct tcmsg *)tcm_pt;
  503. switch (tcm->tcm_family) {
  504. case NLMSG_FLOW_ACTIVATE:
  505. if (!qmi || !DFC_SUPPORTED_MODE(dfc_mode) ||
  506. !qmi_rmnet_has_dfc_client(qmi))
  507. return;
  508. qmi_rmnet_add_flow(dev, tcm, qmi);
  509. break;
  510. case NLMSG_FLOW_DEACTIVATE:
  511. if (!qmi || !DFC_SUPPORTED_MODE(dfc_mode))
  512. return;
  513. qmi_rmnet_del_flow(dev, tcm, qmi);
  514. break;
  515. case NLMSG_CLIENT_SETUP:
  516. dfc_mode = FLAG_TO_MODE(tcm->tcm_ifindex);
  517. dfc_qmap = FLAG_TO_QMAP(tcm->tcm_ifindex);
  518. if (!DFC_SUPPORTED_MODE(dfc_mode) &&
  519. !(tcm->tcm_ifindex & FLAG_POWERSAVE_MASK))
  520. return;
  521. if (qmi_rmnet_setup_client(port, qmi, tcm) < 0) {
  522. /* retrieve qmi again as it could have been changed */
  523. qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  524. if (qmi &&
  525. !qmi_rmnet_has_client(qmi) &&
  526. !qmi_rmnet_has_pending(qmi)) {
  527. rmnet_reset_qmi_pt(port);
  528. kfree(qmi);
  529. }
  530. } else if (tcm->tcm_ifindex & FLAG_POWERSAVE_MASK) {
  531. qmi_rmnet_work_init(port);
  532. rmnet_set_powersave_format(port);
  533. }
  534. break;
  535. case NLMSG_CLIENT_DELETE:
  536. if (!qmi)
  537. return;
  538. if (tcm->tcm_handle == 0) { /* instance 0 */
  539. rmnet_clear_powersave_format(port);
  540. qmi_rmnet_work_exit(port);
  541. }
  542. qmi_rmnet_delete_client(port, qmi, tcm);
  543. break;
  544. case NLMSG_SCALE_FACTOR:
  545. if (!tcm->tcm_ifindex)
  546. return;
  547. qmi_rmnet_scale_factor = tcm->tcm_ifindex;
  548. break;
  549. case NLMSG_WQ_FREQUENCY:
  550. rmnet_wq_frequency = tcm->tcm_ifindex;
  551. break;
  552. default:
  553. pr_debug("%s(): No handler\n", __func__);
  554. break;
  555. }
  556. }
  557. EXPORT_SYMBOL(qmi_rmnet_change_link);
  558. void qmi_rmnet_qmi_exit(void *qmi_pt, void *port)
  559. {
  560. struct qmi_info *qmi = (struct qmi_info *)qmi_pt;
  561. int i;
  562. void *data = NULL;
  563. if (!qmi)
  564. return;
  565. ASSERT_RTNL();
  566. qmi_rmnet_work_exit(port);
  567. if (qmi->wda_client)
  568. data = qmi->wda_client;
  569. else if (qmi->wda_pending)
  570. data = qmi->wda_pending;
  571. if (data) {
  572. wda_qmi_client_exit(data);
  573. qmi->wda_client = NULL;
  574. qmi->wda_pending = NULL;
  575. }
  576. for (i = 0; i < MAX_CLIENT_NUM; i++) {
  577. if (!__qmi_rmnet_delete_client(port, qmi, i))
  578. return;
  579. }
  580. }
  581. EXPORT_SYMBOL(qmi_rmnet_qmi_exit);
  582. void qmi_rmnet_enable_all_flows(struct net_device *dev)
  583. {
  584. struct qos_info *qos;
  585. struct rmnet_bearer_map *bearer;
  586. bool do_wake;
  587. qos = (struct qos_info *)rmnet_get_qos_pt(dev);
  588. if (!qos)
  589. return;
  590. spin_lock_bh(&qos->qos_lock);
  591. list_for_each_entry(bearer, &qos->bearer_head, list) {
  592. if (bearer->tx_off)
  593. continue;
  594. do_wake = !bearer->grant_size;
  595. bearer->grant_size = DEFAULT_GRANT;
  596. bearer->grant_thresh = qmi_rmnet_grant_per(DEFAULT_GRANT);
  597. bearer->seq = 0;
  598. bearer->ack_req = 0;
  599. bearer->tcp_bidir = false;
  600. bearer->rat_switch = false;
  601. if (do_wake)
  602. dfc_bearer_flow_ctl(dev, bearer, qos);
  603. }
  604. spin_unlock_bh(&qos->qos_lock);
  605. }
  606. EXPORT_SYMBOL(qmi_rmnet_enable_all_flows);
  607. bool qmi_rmnet_all_flows_enabled(struct net_device *dev)
  608. {
  609. struct qos_info *qos;
  610. struct rmnet_bearer_map *bearer;
  611. bool ret = true;
  612. qos = (struct qos_info *)rmnet_get_qos_pt(dev);
  613. if (!qos)
  614. return true;
  615. spin_lock_bh(&qos->qos_lock);
  616. list_for_each_entry(bearer, &qos->bearer_head, list) {
  617. if (!bearer->grant_size) {
  618. ret = false;
  619. break;
  620. }
  621. }
  622. spin_unlock_bh(&qos->qos_lock);
  623. return ret;
  624. }
  625. EXPORT_SYMBOL(qmi_rmnet_all_flows_enabled);
  626. #ifdef CONFIG_QTI_QMI_DFC
  627. void qmi_rmnet_burst_fc_check(struct net_device *dev,
  628. int ip_type, u32 mark, unsigned int len)
  629. {
  630. struct qos_info *qos = rmnet_get_qos_pt(dev);
  631. if (!qos)
  632. return;
  633. dfc_qmi_burst_check(dev, qos, ip_type, mark, len);
  634. }
  635. EXPORT_SYMBOL(qmi_rmnet_burst_fc_check);
  636. static bool qmi_rmnet_is_tcp_ack(struct sk_buff *skb)
  637. {
  638. unsigned int len = skb->len;
  639. switch (skb->protocol) {
  640. /* TCPv4 ACKs */
  641. case htons(ETH_P_IP):
  642. if ((ip_hdr(skb)->protocol == IPPROTO_TCP) &&
  643. (ip_hdr(skb)->ihl == 5) &&
  644. (len == 40 || len == 52) &&
  645. ((tcp_flag_word(tcp_hdr(skb)) &
  646. cpu_to_be32(0x00FF0000)) == TCP_FLAG_ACK))
  647. return true;
  648. break;
  649. /* TCPv6 ACKs */
  650. case htons(ETH_P_IPV6):
  651. if ((ipv6_hdr(skb)->nexthdr == IPPROTO_TCP) &&
  652. (len == 60 || len == 72) &&
  653. ((tcp_flag_word(tcp_hdr(skb)) &
  654. cpu_to_be32(0x00FF0000)) == TCP_FLAG_ACK))
  655. return true;
  656. break;
  657. }
  658. return false;
  659. }
  660. static int qmi_rmnet_get_queue_sa(struct qos_info *qos, struct sk_buff *skb)
  661. {
  662. struct rmnet_flow_map *itm;
  663. int ip_type;
  664. int txq = DEFAULT_MQ_NUM;
  665. /* Put NDP in default mq */
  666. if (skb->protocol == htons(ETH_P_IPV6) &&
  667. ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6 &&
  668. icmp6_hdr(skb)->icmp6_type >= 133 &&
  669. icmp6_hdr(skb)->icmp6_type <= 137) {
  670. return DEFAULT_MQ_NUM;
  671. }
  672. ip_type = (skb->protocol == htons(ETH_P_IPV6)) ? AF_INET6 : AF_INET;
  673. spin_lock_bh(&qos->qos_lock);
  674. itm = qmi_rmnet_get_flow_map(qos, skb->mark, ip_type);
  675. if (unlikely(!itm))
  676. goto done;
  677. /* Put the packet in the assigned mq except TCP ack */
  678. if (likely(itm->bearer) && qmi_rmnet_is_tcp_ack(skb))
  679. txq = itm->bearer->ack_mq_idx;
  680. else
  681. txq = itm->mq_idx;
  682. done:
  683. spin_unlock_bh(&qos->qos_lock);
  684. return txq;
  685. }
  686. int qmi_rmnet_get_queue(struct net_device *dev, struct sk_buff *skb)
  687. {
  688. struct qos_info *qos = rmnet_get_qos_pt(dev);
  689. int txq = 0, ip_type = AF_INET;
  690. struct rmnet_flow_map *itm;
  691. u32 mark = skb->mark;
  692. if (!qos)
  693. return 0;
  694. /* If mark is mq num return it */
  695. if (dfc_mode == DFC_MODE_MQ_NUM)
  696. return mark;
  697. if (dfc_mode == DFC_MODE_SA)
  698. return qmi_rmnet_get_queue_sa(qos, skb);
  699. /* Default flows */
  700. if (!mark) {
  701. if (qmi_rmnet_is_tcp_ack(skb))
  702. return 1;
  703. else
  704. return 0;
  705. }
  706. ip_type = (skb->protocol == htons(ETH_P_IPV6)) ? AF_INET6 : AF_INET;
  707. /* Dedicated flows */
  708. spin_lock_bh(&qos->qos_lock);
  709. itm = qmi_rmnet_get_flow_map(qos, mark, ip_type);
  710. if (unlikely(!itm))
  711. goto done;
  712. txq = itm->mq_idx;
  713. done:
  714. spin_unlock_bh(&qos->qos_lock);
  715. return txq;
  716. }
  717. EXPORT_SYMBOL(qmi_rmnet_get_queue);
  718. inline unsigned int qmi_rmnet_grant_per(unsigned int grant)
  719. {
  720. return grant / qmi_rmnet_scale_factor;
  721. }
  722. EXPORT_SYMBOL(qmi_rmnet_grant_per);
  723. void *qmi_rmnet_qos_init(struct net_device *real_dev, u8 mux_id)
  724. {
  725. struct qos_info *qos;
  726. qos = kzalloc(sizeof(*qos), GFP_KERNEL);
  727. if (!qos)
  728. return NULL;
  729. qos->mux_id = mux_id;
  730. qos->real_dev = real_dev;
  731. qos->tran_num = 0;
  732. INIT_LIST_HEAD(&qos->flow_head);
  733. INIT_LIST_HEAD(&qos->bearer_head);
  734. spin_lock_init(&qos->qos_lock);
  735. return qos;
  736. }
  737. EXPORT_SYMBOL(qmi_rmnet_qos_init);
  738. void qmi_rmnet_qos_exit_pre(void *qos)
  739. {
  740. if (!qos)
  741. return;
  742. list_add(&((struct qos_info *)qos)->list, &qos_cleanup_list);
  743. }
  744. EXPORT_SYMBOL(qmi_rmnet_qos_exit_pre);
  745. void qmi_rmnet_qos_exit_post(void)
  746. {
  747. struct qos_info *qos, *tmp;
  748. synchronize_rcu();
  749. list_for_each_entry_safe(qos, tmp, &qos_cleanup_list, list) {
  750. list_del(&qos->list);
  751. qmi_rmnet_clean_flow_list(qos);
  752. kfree(qos);
  753. }
  754. }
  755. EXPORT_SYMBOL(qmi_rmnet_qos_exit_post);
  756. #endif
  757. #ifdef CONFIG_QTI_QMI_POWER_COLLAPSE
  758. static struct workqueue_struct *rmnet_ps_wq;
  759. static struct rmnet_powersave_work *rmnet_work;
  760. static bool rmnet_work_quit;
  761. static LIST_HEAD(ps_list);
  762. struct rmnet_powersave_work {
  763. struct delayed_work work;
  764. struct alarm atimer;
  765. void *port;
  766. u64 old_rx_pkts;
  767. u64 old_tx_pkts;
  768. };
  769. void qmi_rmnet_ps_on_notify(void *port)
  770. {
  771. struct qmi_rmnet_ps_ind *tmp;
  772. list_for_each_entry_rcu(tmp, &ps_list, list)
  773. tmp->ps_on_handler(port);
  774. }
  775. EXPORT_SYMBOL(qmi_rmnet_ps_on_notify);
  776. void qmi_rmnet_ps_off_notify(void *port)
  777. {
  778. struct qmi_rmnet_ps_ind *tmp;
  779. list_for_each_entry_rcu(tmp, &ps_list, list)
  780. tmp->ps_off_handler(port);
  781. }
  782. EXPORT_SYMBOL(qmi_rmnet_ps_off_notify);
  783. int qmi_rmnet_ps_ind_register(void *port,
  784. struct qmi_rmnet_ps_ind *ps_ind)
  785. {
  786. if (!port || !ps_ind || !ps_ind->ps_on_handler ||
  787. !ps_ind->ps_off_handler)
  788. return -EINVAL;
  789. list_add_rcu(&ps_ind->list, &ps_list);
  790. return 0;
  791. }
  792. EXPORT_SYMBOL(qmi_rmnet_ps_ind_register);
  793. int qmi_rmnet_ps_ind_deregister(void *port,
  794. struct qmi_rmnet_ps_ind *ps_ind)
  795. {
  796. struct qmi_rmnet_ps_ind *tmp;
  797. if (!port || !ps_ind)
  798. return -EINVAL;
  799. list_for_each_entry_rcu(tmp, &ps_list, list) {
  800. if (tmp == ps_ind) {
  801. list_del_rcu(&ps_ind->list);
  802. goto done;
  803. }
  804. }
  805. done:
  806. return 0;
  807. }
  808. EXPORT_SYMBOL(qmi_rmnet_ps_ind_deregister);
  809. int qmi_rmnet_set_powersave_mode(void *port, uint8_t enable)
  810. {
  811. int rc = -EINVAL;
  812. struct qmi_info *qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  813. if (!qmi || !qmi->wda_client)
  814. return rc;
  815. rc = wda_set_powersave_mode(qmi->wda_client, enable);
  816. if (rc < 0) {
  817. pr_err("%s() failed set powersave mode[%u], err=%d\n",
  818. __func__, enable, rc);
  819. return rc;
  820. }
  821. return 0;
  822. }
  823. EXPORT_SYMBOL(qmi_rmnet_set_powersave_mode);
  824. static void qmi_rmnet_work_restart(void *port)
  825. {
  826. rcu_read_lock();
  827. if (!rmnet_work_quit)
  828. queue_delayed_work(rmnet_ps_wq, &rmnet_work->work, NO_DELAY);
  829. rcu_read_unlock();
  830. }
  831. static enum alarmtimer_restart qmi_rmnet_work_alarm(struct alarm *atimer,
  832. ktime_t now)
  833. {
  834. struct rmnet_powersave_work *real_work;
  835. real_work = container_of(atimer, struct rmnet_powersave_work, atimer);
  836. qmi_rmnet_work_restart(real_work->port);
  837. return ALARMTIMER_NORESTART;
  838. }
  839. static void qmi_rmnet_check_stats(struct work_struct *work)
  840. {
  841. struct rmnet_powersave_work *real_work;
  842. struct qmi_info *qmi;
  843. u64 rxd, txd;
  844. u64 rx, tx;
  845. bool dl_msg_active;
  846. bool use_alarm_timer = true;
  847. real_work = container_of(to_delayed_work(work),
  848. struct rmnet_powersave_work, work);
  849. if (unlikely(!real_work || !real_work->port))
  850. return;
  851. qmi = (struct qmi_info *)rmnet_get_qmi_pt(real_work->port);
  852. if (unlikely(!qmi))
  853. return;
  854. if (qmi->ps_enabled) {
  855. /* Ready to accept grant */
  856. qmi->ps_ignore_grant = false;
  857. /* Register to get QMI DFC and DL marker */
  858. if (qmi_rmnet_set_powersave_mode(real_work->port, 0) < 0)
  859. goto end;
  860. qmi->ps_enabled = false;
  861. /* Do a query when coming out of powersave */
  862. qmi_rmnet_query_flows(qmi);
  863. if (rmnet_get_powersave_notif(real_work->port))
  864. qmi_rmnet_ps_off_notify(real_work->port);
  865. goto end;
  866. }
  867. rmnet_get_packets(real_work->port, &rx, &tx);
  868. rxd = rx - real_work->old_rx_pkts;
  869. txd = tx - real_work->old_tx_pkts;
  870. real_work->old_rx_pkts = rx;
  871. real_work->old_tx_pkts = tx;
  872. dl_msg_active = qmi->dl_msg_active;
  873. qmi->dl_msg_active = false;
  874. if (!rxd && !txd) {
  875. /* If no DL msg received and there is a flow disabled,
  876. * (likely in RLF), no need to enter powersave
  877. */
  878. if (!dl_msg_active &&
  879. !rmnet_all_flows_enabled(real_work->port)) {
  880. use_alarm_timer = false;
  881. goto end;
  882. }
  883. /* Deregister to suppress QMI DFC and DL marker */
  884. if (qmi_rmnet_set_powersave_mode(real_work->port, 1) < 0)
  885. goto end;
  886. qmi->ps_enabled = true;
  887. /* Ignore grant after going into powersave */
  888. qmi->ps_ignore_grant = true;
  889. /* Clear the bit before enabling flow so pending packets
  890. * can trigger the work again
  891. */
  892. clear_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active);
  893. rmnet_enable_all_flows(real_work->port);
  894. if (rmnet_get_powersave_notif(real_work->port))
  895. qmi_rmnet_ps_on_notify(real_work->port);
  896. return;
  897. }
  898. end:
  899. rcu_read_lock();
  900. if (!rmnet_work_quit) {
  901. if (use_alarm_timer)
  902. alarm_start_relative(&real_work->atimer,
  903. PS_INTERVAL_KT);
  904. else
  905. queue_delayed_work(rmnet_ps_wq, &real_work->work,
  906. PS_INTERVAL);
  907. }
  908. rcu_read_unlock();
  909. }
  910. static void qmi_rmnet_work_set_active(void *port, int status)
  911. {
  912. struct qmi_info *qmi;
  913. qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  914. if (unlikely(!qmi))
  915. return;
  916. if (status)
  917. set_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active);
  918. else
  919. clear_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active);
  920. }
  921. void qmi_rmnet_work_init(void *port)
  922. {
  923. if (rmnet_ps_wq)
  924. return;
  925. rmnet_ps_wq = alloc_workqueue("rmnet_powersave_work",
  926. WQ_MEM_RECLAIM | WQ_CPU_INTENSIVE, 1);
  927. if (!rmnet_ps_wq)
  928. return;
  929. rmnet_work = kzalloc(sizeof(*rmnet_work), GFP_ATOMIC);
  930. if (!rmnet_work) {
  931. destroy_workqueue(rmnet_ps_wq);
  932. rmnet_ps_wq = NULL;
  933. return;
  934. }
  935. INIT_DEFERRABLE_WORK(&rmnet_work->work, qmi_rmnet_check_stats);
  936. alarm_init(&rmnet_work->atimer, ALARM_BOOTTIME, qmi_rmnet_work_alarm);
  937. rmnet_work->port = port;
  938. rmnet_get_packets(rmnet_work->port, &rmnet_work->old_rx_pkts,
  939. &rmnet_work->old_tx_pkts);
  940. rmnet_work_quit = false;
  941. qmi_rmnet_work_set_active(rmnet_work->port, 1);
  942. queue_delayed_work(rmnet_ps_wq, &rmnet_work->work, PS_INTERVAL);
  943. }
  944. EXPORT_SYMBOL(qmi_rmnet_work_init);
  945. void qmi_rmnet_work_maybe_restart(void *port)
  946. {
  947. struct qmi_info *qmi;
  948. qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  949. if (unlikely(!qmi))
  950. return;
  951. if (!test_and_set_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active))
  952. qmi_rmnet_work_restart(port);
  953. }
  954. EXPORT_SYMBOL(qmi_rmnet_work_maybe_restart);
  955. void qmi_rmnet_work_exit(void *port)
  956. {
  957. if (!rmnet_ps_wq || !rmnet_work)
  958. return;
  959. rmnet_work_quit = true;
  960. synchronize_rcu();
  961. alarm_cancel(&rmnet_work->atimer);
  962. cancel_delayed_work_sync(&rmnet_work->work);
  963. destroy_workqueue(rmnet_ps_wq);
  964. qmi_rmnet_work_set_active(port, 0);
  965. rmnet_ps_wq = NULL;
  966. kfree(rmnet_work);
  967. rmnet_work = NULL;
  968. }
  969. EXPORT_SYMBOL(qmi_rmnet_work_exit);
  970. void qmi_rmnet_set_dl_msg_active(void *port)
  971. {
  972. struct qmi_info *qmi;
  973. qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  974. if (unlikely(!qmi))
  975. return;
  976. qmi->dl_msg_active = true;
  977. }
  978. EXPORT_SYMBOL(qmi_rmnet_set_dl_msg_active);
  979. void qmi_rmnet_flush_ps_wq(void)
  980. {
  981. if (rmnet_ps_wq)
  982. flush_workqueue(rmnet_ps_wq);
  983. }
  984. bool qmi_rmnet_ignore_grant(void *port)
  985. {
  986. struct qmi_info *qmi;
  987. qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);
  988. if (unlikely(!qmi))
  989. return false;
  990. return qmi->ps_ignore_grant;
  991. }
  992. EXPORT_SYMBOL(qmi_rmnet_ignore_grant);
  993. #endif