Merge "msm: ipa: add support for Ethernet Bridging" (a2502b7d) · Commits · e / devices / android_kernel_sony_msm8994

drivers/platform/msm/ipa/ipa.c

+268 −25

Original line number	Diff line number	Diff line
		@@ -154,6 +154,12 @@
		#define IPA_IOC_NOTIFY_WAN_EMBMS_CONNECTED32 _IOWR(IPA_IOC_MAGIC, \
		IPA_IOCTL_NOTIFY_WAN_EMBMS_CONNECTED, \
		compat_uptr_t)
		#define IPA_IOC_ADD_HDR_PROC_CTX32 _IOWR(IPA_IOC_MAGIC, \
		IPA_IOCTL_ADD_HDR_PROC_CTX, \
		compat_uptr_t)
		#define IPA_IOC_DEL_HDR_PROC_CTX32 _IOWR(IPA_IOC_MAGIC, \
		IPA_IOCTL_DEL_HDR_PROC_CTX, \
		compat_uptr_t)

		/**
		* struct ipa_ioc_nat_alloc_mem32 - nat table memory allocation
		@@ -875,6 +881,65 @@ static long ipa_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
		break;
		}
		break;
		case IPA_IOC_ADD_HDR_PROC_CTX:
		if (copy_from_user(header, (u8 *)arg,
		sizeof(struct ipa_ioc_add_hdr_proc_ctx))) {
		retval = -EFAULT;
		break;
		}
		pyld_sz =
		sizeof(struct ipa_ioc_add_hdr_proc_ctx) +
		((struct ipa_ioc_add_hdr_proc_ctx )header)->num_proc_ctxs
		sizeof(struct ipa_hdr_proc_ctx_add);
		param = kzalloc(pyld_sz, GFP_KERNEL);
		if (!param) {
		retval = -ENOMEM;
		break;
		}
		if (copy_from_user(param, (u8 *)arg, pyld_sz)) {
		retval = -EFAULT;
		break;
		}
		if (ipa_add_hdr_proc_ctx(
		(struct ipa_ioc_add_hdr_proc_ctx *)param)) {
		retval = -EFAULT;
		break;
		}
		if (copy_to_user((u8 *)arg, param, pyld_sz)) {
		retval = -EFAULT;
		break;
		}
		break;
		case IPA_IOC_DEL_HDR_PROC_CTX:
		if (copy_from_user(header, (u8 *)arg,
		sizeof(struct ipa_ioc_del_hdr_proc_ctx))) {
		retval = -EFAULT;
		break;
		}
		pyld_sz =
		sizeof(struct ipa_ioc_del_hdr_proc_ctx) +
		((struct ipa_ioc_del_hdr_proc_ctx )header)->num_hdls
		sizeof(struct ipa_hdr_proc_ctx_del);
		param = kzalloc(pyld_sz, GFP_KERNEL);
		if (!param) {
		retval = -ENOMEM;
		break;
		}
		if (copy_from_user(param, (u8 *)arg, pyld_sz)) {
		retval = -EFAULT;
		break;
		}
		if (ipa_del_hdr_proc_ctx(
		(struct ipa_ioc_del_hdr_proc_ctx *)param)) {
		retval = -EFAULT;
		break;
		}
		if (copy_to_user((u8 *)arg, param, pyld_sz)) {
		retval = -EFAULT;
		break;
		}
		break;

		default: /* redundant, as cmd was checked against MAXNR */
		ipa_dec_client_disable_clks();
		return -ENOTTY;
		@@ -1019,6 +1084,9 @@ static int ipa_init_smem_region(int memory_region_size,
		struct ipa_mem_buffer mem;
		int rc;

		if (memory_region_size == 0)
		return 0;

		memset(&desc, 0, sizeof(desc));
		memset(&cmd, 0, sizeof(cmd));
		memset(&mem, 0, sizeof(mem));
		@@ -1084,6 +1152,14 @@ int ipa_init_q6_smem(void)
		return rc;
		}

		rc = ipa_init_smem_region(IPA_MEM_PART(modem_hdr_proc_ctx_size),
		IPA_MEM_PART(modem_hdr_proc_ctx_ofst));
		if (rc) {
		IPAERR("failed to initialize Modem proc ctx RAM memory\n");
		ipa_dec_client_disable_clks();
		return rc;
		}

		ipa_dec_client_disable_clks();

		return rc;
		@@ -1450,7 +1526,7 @@ int ipa_q6_cleanup(void)
		return 0;
		}

		static int ipa_init_sram(void)
		int _ipa_init_sram_v2(void)
		{
		u32 *ipa_sram_mmio;
		unsigned long phys_addr;
		@@ -1459,16 +1535,71 @@ static int ipa_init_sram(void)
		struct ipa_mem_buffer mem;
		int rc = 0;

		if (ipa_ctx->ipa_hw_type == IPA_HW_v2_5) {
		phys_addr = ipa_ctx->ipa_wrapper_base +
		ipa_ctx->ctrl->ipa_reg_base_ofst +
		IPA_SRAM_SW_FIRST_v2_5;
		} else {
		phys_addr = ipa_ctx->ipa_wrapper_base +
		ipa_ctx->ctrl->ipa_reg_base_ofst +
		IPA_SRAM_DIRECT_ACCESS_N_OFST_v2_0(
		ipa_ctx->smem_restricted_bytes / 4);

		ipa_sram_mmio = ioremap(phys_addr,
		ipa_ctx->smem_sz - ipa_ctx->smem_restricted_bytes);
		if (!ipa_sram_mmio) {
		IPAERR("fail to ioremap IPA SRAM\n");
		return -ENOMEM;
		}

		#define IPA_SRAM_SET(ofst, val) (ipa_sram_mmio[(ofst - 4) / 4] = val)

		IPA_SRAM_SET(IPA_MEM_PART(v6_flt_ofst) - 4, IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(v6_flt_ofst), IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(v4_rt_ofst) - 4, IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(v4_rt_ofst), IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(v6_rt_ofst), IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(modem_hdr_ofst), IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(modem_ofst), IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(apps_v4_flt_ofst), IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(uc_info_ofst), IPA_MEM_CANARY_VAL);

		iounmap(ipa_sram_mmio);

		mem.size = IPA_STATUS_CLEAR_SIZE;
		mem.base = dma_alloc_coherent(ipa_ctx->pdev, mem.size, &mem.phys_base,
		GFP_KERNEL);
		if (!mem.base) {
		IPAERR("fail to alloc DMA buff of size %d\n", mem.size);
		return -ENOMEM;
		}
		memset(mem.base, 0, mem.size);

		cmd.size = mem.size;
		cmd.system_addr = mem.phys_base;
		cmd.local_addr = IPA_STATUS_CLEAR_OFST;
		desc.opcode = IPA_DMA_SHARED_MEM;
		desc.pyld = &cmd;
		desc.len = sizeof(struct ipa_hw_imm_cmd_dma_shared_mem);
		desc.type = IPA_IMM_CMD_DESC;

		if (ipa_send_cmd(1, &desc)) {
		IPAERR("fail to send immediate command\n");
		rc = -EFAULT;
		}

		dma_free_coherent(ipa_ctx->pdev, mem.size, mem.base, mem.phys_base);
		return rc;
		}

		int _ipa_init_sram_v2_5(void)
		{
		u32 *ipa_sram_mmio;
		unsigned long phys_addr;
		struct ipa_hw_imm_cmd_dma_shared_mem cmd = { 0 };
		struct ipa_desc desc = { 0 };
		struct ipa_mem_buffer mem;
		int rc = 0;

		phys_addr = ipa_ctx->ipa_wrapper_base +
		ipa_ctx->ctrl->ipa_reg_base_ofst +
		IPA_SRAM_SW_FIRST_v2_5;

		ipa_sram_mmio = ioremap(phys_addr,
		ipa_ctx->smem_sz - ipa_ctx->smem_restricted_bytes);
		if (!ipa_sram_mmio) {
		@@ -1484,6 +1615,9 @@ static int ipa_init_sram(void)
		IPA_SRAM_SET(IPA_MEM_PART(v4_rt_ofst), IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(v6_rt_ofst), IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(modem_hdr_ofst), IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(modem_hdr_proc_ctx_ofst) - 4,
		IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(modem_hdr_proc_ctx_ofst), IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(modem_ofst), IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(apps_v4_flt_ofst), IPA_MEM_CANARY_VAL);
		IPA_SRAM_SET(IPA_MEM_PART(uc_info_ofst), IPA_MEM_CANARY_VAL);
		@@ -1516,7 +1650,7 @@ static int ipa_init_sram(void)
		return rc;
		}

		static int ipa_init_hdr(void)
		int _ipa_init_hdr_v2(void)
		{
		struct ipa_desc desc = { 0 };
		struct ipa_mem_buffer mem;
		@@ -1552,7 +1686,83 @@ static int ipa_init_hdr(void)
		return rc;
		}

		static int ipa_init_rt4(void)
		int _ipa_init_hdr_v2_5(void)
		{
		struct ipa_desc desc = { 0 };
		struct ipa_mem_buffer mem;
		struct ipa_hdr_init_local cmd = { 0 };
		struct ipa_hw_imm_cmd_dma_shared_mem dma_cmd = { 0 };

		mem.size = IPA_MEM_PART(modem_hdr_size) + IPA_MEM_PART(apps_hdr_size);
		mem.base = dma_alloc_coherent(ipa_ctx->pdev, mem.size, &mem.phys_base,
		GFP_KERNEL);
		if (!mem.base) {
		IPAERR("fail to alloc DMA buff of size %d\n", mem.size);
		return -ENOMEM;
		}
		memset(mem.base, 0, mem.size);

		cmd.hdr_table_src_addr = mem.phys_base;
		cmd.size_hdr_table = mem.size;
		cmd.hdr_table_dst_addr = ipa_ctx->smem_restricted_bytes +
		IPA_MEM_PART(modem_hdr_ofst);

		desc.opcode = IPA_HDR_INIT_LOCAL;
		desc.pyld = &cmd;
		desc.len = sizeof(struct ipa_hdr_init_local);
		desc.type = IPA_IMM_CMD_DESC;
		IPA_DUMP_BUFF(mem.base, mem.phys_base, mem.size);

		if (ipa_send_cmd(1, &desc)) {
		IPAERR("fail to send immediate command\n");
		dma_free_coherent(ipa_ctx->pdev,
		mem.size, mem.base,
		mem.phys_base);
		return -EFAULT;
		}

		dma_free_coherent(ipa_ctx->pdev, mem.size, mem.base, mem.phys_base);

		mem.size = IPA_MEM_PART(modem_hdr_proc_ctx_size) +
		IPA_MEM_PART(apps_hdr_proc_ctx_size);
		mem.base = dma_alloc_coherent(ipa_ctx->pdev, mem.size, &mem.phys_base,
		GFP_KERNEL);
		if (!mem.base) {
		IPAERR("fail to alloc DMA buff of size %d\n", mem.size);
		return -ENOMEM;
		}
		memset(mem.base, 0, mem.size);
		memset(&desc, 0, sizeof(desc));

		dma_cmd.system_addr = mem.phys_base;
		dma_cmd.local_addr = ipa_ctx->smem_restricted_bytes +
		IPA_MEM_PART(modem_hdr_proc_ctx_ofst);
		dma_cmd.size = mem.size;
		desc.opcode = IPA_DMA_SHARED_MEM;
		desc.pyld = &dma_cmd;
		desc.len = sizeof(struct ipa_hw_imm_cmd_dma_shared_mem);
		desc.type = IPA_IMM_CMD_DESC;
		IPA_DUMP_BUFF(mem.base, mem.phys_base, mem.size);

		if (ipa_send_cmd(1, &desc)) {
		IPAERR("fail to send immediate command\n");
		dma_free_coherent(ipa_ctx->pdev,
		mem.size,
		mem.base,
		mem.phys_base);
		return -EFAULT;
		}

		ipa_write_reg(ipa_ctx->mmio,
		IPA_LOCAL_PKT_PROC_CNTXT_BASE_OFST,
		dma_cmd.local_addr);

		dma_free_coherent(ipa_ctx->pdev, mem.size, mem.base, mem.phys_base);

		return 0;
		}

		int _ipa_init_rt4_v2(void)
		{
		struct ipa_desc desc = { 0 };
		struct ipa_mem_buffer mem;
		@@ -1603,7 +1813,7 @@ static int ipa_init_rt4(void)
		return rc;
		}

		static int ipa_init_rt6(void)
		int _ipa_init_rt6_v2(void)
		{
		struct ipa_desc desc = { 0 };
		struct ipa_mem_buffer mem;
		@@ -1654,7 +1864,7 @@ static int ipa_init_rt6(void)
		return rc;
		}

		static int ipa_init_flt4(void)
		int _ipa_init_flt4_v2(void)
		{
		struct ipa_desc desc = { 0 };
		struct ipa_mem_buffer mem;
		@@ -1703,7 +1913,7 @@ static int ipa_init_flt4(void)
		return rc;
		}

		static int ipa_init_flt6(void)
		int _ipa_init_flt6_v2(void)
		{
		struct ipa_desc desc = { 0 };
		struct ipa_mem_buffer mem;
		@@ -1771,15 +1981,23 @@ static int ipa_setup_apps_pipes(void)
		}
		IPADBG("Apps to IPA cmd pipe is connected\n");

		if (ipa_ctx->ipa_hw_type == IPA_HW_v2_0 \|\|
		ipa_ctx->ipa_hw_type == IPA_HW_v2_5) {
		ipa_init_sram();
		ipa_init_hdr();
		ipa_init_rt4();
		ipa_init_rt6();
		ipa_init_flt4();
		ipa_init_flt6();
		}
		ipa_ctx->ctrl->ipa_init_sram();
		IPADBG("SRAM initialized\n");

		ipa_ctx->ctrl->ipa_init_hdr();
		IPADBG("HDR initialized\n");

		ipa_ctx->ctrl->ipa_init_rt4();
		IPADBG("V4 RT initialized\n");

		ipa_ctx->ctrl->ipa_init_rt6();
		IPADBG("V6 RT initialized\n");

		ipa_ctx->ctrl->ipa_init_flt4();
		IPADBG("V4 FLT initialized\n");

		ipa_ctx->ctrl->ipa_init_flt6();
		IPADBG("V6 FLT initialized\n");

		if (ipa_setup_exception_path()) {
		IPAERR(":fail to setup excp path\n");
		@@ -2820,6 +3038,21 @@ static int ipa_init(const struct ipa_plat_drv_res *resource_p,
		result = -ENOMEM;
		goto fail_hdr_offset_cache;
		}
		ipa_ctx->hdr_proc_ctx_cache = kmem_cache_create("IPA HDR PROC CTX",
		sizeof(struct ipa_hdr_proc_ctx_entry), 0, 0, NULL);
		if (!ipa_ctx->hdr_proc_ctx_cache) {
		IPAERR(":ipa hdr proc ctx cache create failed\n");
		result = -ENOMEM;
		goto fail_hdr_proc_ctx_cache;
		}
		ipa_ctx->hdr_proc_ctx_offset_cache =
		kmem_cache_create("IPA HDR PROC CTX OFFSET",
		sizeof(struct ipa_hdr_proc_ctx_offset_entry), 0, 0, NULL);
		if (!ipa_ctx->hdr_proc_ctx_offset_cache) {
		IPAERR(":ipa hdr proc ctx off cache create failed\n");
		result = -ENOMEM;
		goto fail_hdr_proc_ctx_offset_cache;
		}
		ipa_ctx->rt_tbl_cache = kmem_cache_create("IPA RT TBL",
		sizeof(struct ipa_rt_tbl), 0, 0, NULL);
		if (!ipa_ctx->rt_tbl_cache) {
		@@ -2875,6 +3108,12 @@ static int ipa_init(const struct ipa_plat_drv_res *resource_p,
		INIT_LIST_HEAD(&ipa_ctx->hdr_tbl.head_offset_list[i]);
		INIT_LIST_HEAD(&ipa_ctx->hdr_tbl.head_free_offset_list[i]);
		}
		INIT_LIST_HEAD(&ipa_ctx->hdr_proc_ctx_tbl.head_proc_ctx_entry_list);
		for (i = 0; i < IPA_HDR_PROC_CTX_BIN_MAX; i++) {
		INIT_LIST_HEAD(&ipa_ctx->hdr_proc_ctx_tbl.head_offset_list[i]);
		INIT_LIST_HEAD(&ipa_ctx->
		hdr_proc_ctx_tbl.head_free_offset_list[i]);
		}
		INIT_LIST_HEAD(&ipa_ctx->rt_tbl_set[IPA_IP_v4].head_rt_tbl_list);
		INIT_LIST_HEAD(&ipa_ctx->rt_tbl_set[IPA_IP_v6].head_rt_tbl_list);
		for (i = 0; i < IPA_NUM_PIPES; i++) {
		@@ -3099,6 +3338,10 @@ fail_rx_pkt_wrapper_cache:
		fail_tx_pkt_wrapper_cache:
		kmem_cache_destroy(ipa_ctx->rt_tbl_cache);
		fail_rt_tbl_cache:
		kmem_cache_destroy(ipa_ctx->hdr_proc_ctx_offset_cache);
		fail_hdr_proc_ctx_offset_cache:
		kmem_cache_destroy(ipa_ctx->hdr_proc_ctx_cache);
		fail_hdr_proc_ctx_cache:
		kmem_cache_destroy(ipa_ctx->hdr_offset_cache);
		fail_hdr_offset_cache:
		kmem_cache_destroy(ipa_ctx->hdr_cache);

drivers/platform/msm/ipa/ipa_debugfs.c

+149 −26

Original line number	Diff line number	Diff line
		@@ -63,11 +63,20 @@ const char *ipa_event_name[] = {
		__stringify(ECM_DISCONNECT),
		};

		const char *ipa_hdr_proc_type_name[] = {
		__stringify(IPA_HDR_PROC_NONE),
		__stringify(IPA_HDR_PROC_ETHII_TO_ETHII),
		__stringify(IPA_HDR_PROC_ETHII_TO_802_3),
		__stringify(IPA_HDR_PROC_802_3_TO_ETHII),
		__stringify(IPA_HDR_PROC_802_3_TO_802_3),
		};

		static struct dentry *dent;
		static struct dentry *dfile_gen_reg;
		static struct dentry *dfile_ep_reg;
		static struct dentry *dfile_ep_holb;
		static struct dentry *dfile_hdr;
		static struct dentry *dfile_proc_ctx;
		static struct dentry *dfile_ip4_rt;
		static struct dentry *dfile_ip6_rt;
		static struct dentry *dfile_ip4_flt;
		@@ -363,33 +372,53 @@ static ssize_t ipa_read_hdr(struct file file, char __user ubuf, size_t count,
		loff_t *ppos)
		{
		int nbytes = 0;
		int cnt = 0;
		int i = 0;
		struct ipa_hdr_entry *entry;

		mutex_lock(&ipa_ctx->lock);

		if (ipa_ctx->hdr_tbl_lcl)
		pr_err("Table resides on local memory\n");
		else
		pr_err("Table resides on system (ddr) memory\n");

		list_for_each_entry(entry, &ipa_ctx->hdr_tbl.head_hdr_entry_list,
		link) {
		nbytes = scnprintf(dbg_buff + cnt, IPA_MAX_MSG_LEN - cnt,
		"name:%s len=%d ref=%d partial=%d lcl=%d ofst=%u ",
		if (entry->is_hdr_proc_ctx) {
		nbytes = scnprintf(
		dbg_buff,
		IPA_MAX_MSG_LEN,
		"name:%s len=%d ref=%d partial=%d "
		"phys_base=0x%pa ",
		entry->name,
		entry->hdr_len, entry->ref_cnt,
		entry->hdr_len,
		entry->ref_cnt,
		entry->is_partial,
		&entry->phys_base);
		} else {
		nbytes = scnprintf(
		dbg_buff,
		IPA_MAX_MSG_LEN,
		"name:%s len=%d ref=%d partial=%d ofst=%u ",
		entry->name,
		entry->hdr_len,
		entry->ref_cnt,
		entry->is_partial,
		ipa_ctx->hdr_tbl_lcl,
		entry->offset_entry->offset >> 2);
		}
		for (i = 0; i < entry->hdr_len; i++) {
		scnprintf(dbg_buff + cnt + nbytes + i * 2,
		IPA_MAX_MSG_LEN - cnt - nbytes - i * 2,
		scnprintf(dbg_buff + nbytes + i * 2,
		IPA_MAX_MSG_LEN - nbytes - i * 2,
		"%02x", entry->hdr[i]);
		}
		scnprintf(dbg_buff + cnt + nbytes + entry->hdr_len * 2,
		IPA_MAX_MSG_LEN - cnt - nbytes - entry->hdr_len * 2,
		scnprintf(dbg_buff + nbytes + entry->hdr_len * 2,
		IPA_MAX_MSG_LEN - nbytes - entry->hdr_len * 2,
		"\n");
		cnt += nbytes + entry->hdr_len * 2 + 1;
		pr_err("%s", dbg_buff);
		}
		mutex_unlock(&ipa_ctx->lock);

		return simple_read_from_buffer(ubuf, count, ppos, dbg_buff, cnt);
		return 0;
		}

		static int ipa_attrib_dump(struct ipa_rule_attrib *attrib,
		@@ -489,6 +518,19 @@ static int ipa_attrib_dump(struct ipa_rule_attrib *attrib,
		if (attrib->attrib_mask & IPA_FLT_FRAGMENT)
		pr_err("frg ");

		if ((attrib->attrib_mask & IPA_FLT_MAC_SRC_ADDR_ETHER_II) \|\|
		(attrib->attrib_mask & IPA_FLT_MAC_SRC_ADDR_802_3)) {
		pr_err("src_mac_addr:%pM ", attrib->src_mac_addr);
		}

		if ((attrib->attrib_mask & IPA_FLT_MAC_DST_ADDR_ETHER_II) \|\|
		(attrib->attrib_mask & IPA_FLT_MAC_DST_ADDR_802_3)) {
		pr_err("dst_mac_addr:%pM ", attrib->dst_mac_addr);
		}

		if (attrib->attrib_mask & IPA_FLT_MAC_ETHER_TYPE)
		pr_err("ether_type:%x ", attrib->ether_type);

		pr_err("\n");
		return 0;
		}
		@@ -584,38 +626,62 @@ static ssize_t ipa_read_rt(struct file file, char __user ubuf, size_t count,
		struct ipa_rt_entry *entry;
		struct ipa_rt_tbl_set *set;
		enum ipa_ip_type ip = (enum ipa_ip_type)file->private_data;
		u32 hdr_ofst;
		u32 ofst;
		u32 ofst_words;

		set = &ipa_ctx->rt_tbl_set[ip];

		mutex_lock(&ipa_ctx->lock);

		if (ip == IPA_IP_v6) {
		if (ipa_ctx->ip6_rt_tbl_lcl)
		pr_err("Table Resides on local memory\n");
		pr_err("Table resides on local memory\n");
		else
		pr_err("Table Resides on system(ddr) memory\n");
		pr_err("Table resides on system (ddr) memory\n");
		} else if (ip == IPA_IP_v4) {
		if (ipa_ctx->ip4_rt_tbl_lcl)
		pr_err("Table Resides on local memory\n");
		pr_err("Table resides on local memory\n");
		else
		pr_err("Table Resides on system(ddr) memory\n");
		pr_err("Table resides on system (ddr) memory\n");
		}

		list_for_each_entry(tbl, &set->head_rt_tbl_list, link) {
		i = 0;
		list_for_each_entry(entry, &tbl->head_rt_rule_list, link) {
		if (entry->proc_ctx) {
		ofst = entry->proc_ctx->offset_entry->offset;
		ofst_words =
		(ofst +
		ipa_ctx->hdr_proc_ctx_tbl.start_offset)
		>> 5;

		pr_err(
		"tbl_idx:%d tbl_name:%s tbl_ref:%u "
		"rule_idx:%d dst:%d ep:%d S:%u "
		"proc_ctx[32B]:%u attrib_mask:%08x ",
		entry->tbl->idx, entry->tbl->name,
		entry->tbl->ref_cnt, i, entry->rule.dst,
		ipa_get_ep_mapping(entry->rule.dst),
		!ipa_ctx->hdr_tbl_lcl,
		ofst_words,
		entry->rule.attrib.attrib_mask);
		} else {
		if (entry->hdr)
		hdr_ofst = entry->hdr->offset_entry->offset;
		ofst = entry->hdr->offset_entry->offset;
		else
		hdr_ofst = 0;
		ofst = 0;

		pr_err(
		"tbl_idx:%d tbl_name:%s tbl_ref:%u rule_idx:%d dst:%d ep:%d S:%u hdr_ofst[words]:%u attrib_mask:%08x ",
		"tbl_idx:%d tbl_name:%s tbl_ref:%u "
		"rule_idx:%d dst:%d ep:%d S:%u "
		"hdr_ofst[words]:%u attrib_mask:%08x ",
		entry->tbl->idx, entry->tbl->name,
		entry->tbl->ref_cnt, i, entry->rule.dst,
		ipa_get_ep_mapping(entry->rule.dst),
		!ipa_ctx->hdr_tbl_lcl,
		hdr_ofst >> 2,
		ofst >> 2,
		entry->rule.attrib.attrib_mask);
		}

		ipa_attrib_dump(&entry->rule.attrib, ip);
		i++;
		@@ -626,6 +692,52 @@ static ssize_t ipa_read_rt(struct file file, char __user ubuf, size_t count,
		return 0;
		}

		static ssize_t ipa_read_proc_ctx(struct file file, char __user ubuf,
		size_t count, loff_t *ppos)
		{
		int nbytes = 0;
		struct ipa_hdr_proc_ctx_tbl *tbl;
		struct ipa_hdr_proc_ctx_entry *entry;
		u32 ofst_words;

		tbl = &ipa_ctx->hdr_proc_ctx_tbl;

		mutex_lock(&ipa_ctx->lock);

		if (ipa_ctx->hdr_proc_ctx_tbl_lcl)
		pr_info("Table resides on local memory\n");
		else
		pr_info("Table resides on system(ddr) memory\n");

		list_for_each_entry(entry, &tbl->head_proc_ctx_entry_list, link) {
		ofst_words = (entry->offset_entry->offset +
		ipa_ctx->hdr_proc_ctx_tbl.start_offset)
		>> 5;
		if (entry->hdr->is_hdr_proc_ctx) {
		nbytes += scnprintf(dbg_buff + nbytes,
		IPA_MAX_MSG_LEN - nbytes,
		"id:%u hdr_proc_type:%s proc_ctx[32B]:%u "
		"hdr_phys_base:0x%pa\n",
		entry->id,
		ipa_hdr_proc_type_name[entry->type],
		ofst_words,
		&entry->hdr->phys_base);
		} else {
		nbytes += scnprintf(dbg_buff + nbytes,
		IPA_MAX_MSG_LEN - nbytes,
		"id:%u hdr_proc_type:%s proc_ctx[32B]:%u "
		"hdr[words]:%u\n",
		entry->id,
		ipa_hdr_proc_type_name[entry->type],
		ofst_words,
		entry->hdr->offset_entry->offset >> 2);
		}
		}
		mutex_unlock(&ipa_ctx->lock);

		return simple_read_from_buffer(ubuf, count, ppos, dbg_buff, nbytes);
		}

		static ssize_t ipa_read_flt(struct file file, char __user ubuf, size_t count,
		loff_t *ppos)
		{
		@@ -1323,6 +1435,10 @@ const struct file_operations ipa_rt_ops = {
		.open = ipa_open_dbg,
		};

		const struct file_operations ipa_proc_ctx_ops = {
		.read = ipa_read_proc_ctx,
		};

		const struct file_operations ipa_flt_ops = {
		.read = ipa_read_flt,
		.open = ipa_open_dbg,
		@@ -1407,6 +1523,13 @@ void ipa_debugfs_init(void)
		goto fail;
		}

		dfile_proc_ctx = debugfs_create_file("proc_ctx", read_only_mode, dent,
		0, &ipa_proc_ctx_ops);
		if (!dfile_hdr \|\| IS_ERR(dfile_hdr)) {
		IPAERR("fail to create file for debug_fs proc_ctx\n");
		goto fail;
		}

		dfile_ip4_rt = debugfs_create_file("ip4_rt", read_only_mode, dent,
		(void *)IPA_IP_v4, &ipa_rt_ops);
		if (!dfile_ip4_rt \|\| IS_ERR(dfile_ip4_rt)) {

drivers/platform/msm/ipa/ipa_hdr.c

+649 −31

File changed.

Preview size limit exceeded, changes collapsed.

drivers/platform/msm/ipa/ipa_hw_defs.h

+49 −0

Original line number	Diff line number	Diff line
		@@ -35,6 +35,12 @@
		#define IPA_DMA_SHARED_MEM (19)
		#define IPA_IP_PACKET_TAG_STATUS (20)

		/* Processing context TLV type */
		#define IPA_PROC_CTX_TLV_TYPE_END 0
		#define IPA_PROC_CTX_TLV_TYPE_HDR_ADD 1
		#define IPA_PROC_CTX_TLV_TYPE_PROC_CMD 3


		/**
		* struct ipa_flt_rule_hw_hdr - HW header of IPA filter rule
		* @word: filtering rule properties
		@@ -72,6 +78,8 @@ struct ipa_flt_rule_hw_hdr {
		* @pipe_dest_idx: destination pipe index
		* @system: changed from local to system due to HW change
		* @hdr_offset: header offset
		* @proc_ctx: whether hdr_offset points to header table or to
		* header processing context table
		*/
		struct ipa_rt_rule_hw_hdr {
		union {
		@@ -82,6 +90,13 @@ struct ipa_rt_rule_hw_hdr {
		u32 system:1;
		u32 hdr_offset:10;
		} hdr;
		struct {
		u32 en_rule:16;
		u32 pipe_dest_idx:5;
		u32 system:1;
		u32 hdr_offset:9;
		u32 proc_ctx:1;
		} hdr_v2_5;
		} u;
		};

		@@ -163,6 +178,40 @@ struct ipa_hdr_init_system {
		u64 rsvd:32;
		};

		/**
		* struct ipa_hdr_proc_ctx_tlv -
		* HW structure of IPA processing context header - TLV part
		* @type: 0 - end type
		* 1 - header addition type
		* 3 - processing command type
		* @length: number of bytes after tlv
		* for type:
		* 0 - needs to be 0
		* 1 - header addition length
		* 3 - number of 32B including type and length.
		* @value: specific value for type
		* for type:
		* 0 - needs to be 0
		* 1 - header length
		* 3 - command ID (see IPA_HDR_UCP_* definitions)
		*/
		struct ipa_hdr_proc_ctx_tlv {
		u32 type:8;
		u32 length:8;
		u32 value:16;
		};

		/**
		* struct ipa_hdr_proc_ctx_hdr_add -
		* HW structure of IPA processing context - add header tlv
		* @tlv: IPA processing context TLV
		* @hdr_addr: processing context header address
		*/
		struct ipa_hdr_proc_ctx_hdr_add {
		struct ipa_hdr_proc_ctx_tlv tlv;
		u32 hdr_addr;
		};

		#define IPA_A5_MUX_HDR_EXCP_FLAG_IP BIT(7)
		#define IPA_A5_MUX_HDR_EXCP_FLAG_NAT BIT(6)
		#define IPA_A5_MUX_HDR_EXCP_FLAG_SW_FLT BIT(5)

drivers/platform/msm/ipa/ipa_i.h

+138 −3

File changed.

Preview size limit exceeded, changes collapsed.