Attachment #630132 for bug #716226

View | Details | Raw Unified | Return to bug 716226
Collapse All | Expand All

Lines 2069-2075 Link Here

(-)dahdi-linux-3.1.0-before/drivers/dahdi/ap400/ap400_drv.c (-3 / +2 lines)
2069	// Remap PCI address	2069	// Remap PCI address
2070	wc->memaddr = pci_resource_start(pdev, 2);	2070	wc->memaddr = pci_resource_start(pdev, 2);
2071	wc->memlen = pci_resource_len(pdev, 2);	2071	wc->memlen = pci_resource_len(pdev, 2);
2072	wc->membase = ioremap_nocache(wc->memaddr, wc->memlen);	2072	wc->membase = ioremap(wc->memaddr, wc->memlen);
2073	if(wc->membase == NULL) {	2073	if(wc->membase == NULL) {
2074	printk("AP400: ioremap failed!\n");	2074	printk("AP400: ioremap failed!\n");
2075	res = -EIO;	2075	res = -EIO;
Lines 2205-2212 Link Here
2205	bar_size[2] = wc->memlen;	2205	bar_size[2] = wc->memlen;
2206	for (i = 0; i < 2; i++) {	2206	for (i = 0; i < 2; i++) {
2207	bar_size[i] = (u32) pci_resource_len(pdev, i);	2207	bar_size[i] = (u32) pci_resource_len(pdev, i);
2208	base_addr[i] = ioremap_nocache(pci_resource_start(pdev, i),	2208	base_addr[i] = ioremap(pci_resource_start(pdev, i), bar_size[i]);
2209	bar_size[i]);
2210	if (base_addr[i] == NULL) {	2209	if (base_addr[i] == NULL) {
2211	printk(KERN_ERR "Memory map failed\n");	2210	printk(KERN_ERR "Memory map failed\n");
2212	res = -ENODEV;	2211	res = -ENODEV;

Lines 1015-1020 Link Here

(-)dahdi-linux-3.1.0-before/drivers/dahdi/dahdi-base.c (+9 lines)
1015	return single_open(file, dahdi_seq_show, PDE_DATA(inode));	1015	return single_open(file, dahdi_seq_show, PDE_DATA(inode));
1016	}	1016	}
1017		1017
		1018	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
1018	static const struct file_operations dahdi_proc_ops = {	1019	static const struct file_operations dahdi_proc_ops = {
1019	.owner = THIS_MODULE,	1020	.owner = THIS_MODULE,
1020	.open = dahdi_proc_open,	1021	.open = dahdi_proc_open,
Lines 1022-1027 Link Here
1022	.llseek = seq_lseek,	1023	.llseek = seq_lseek,
1023	.release = single_release,	1024	.release = single_release,
1024	};	1025	};
		1026	#else
		1027	static const struct proc_ops dahdi_proc_ops = {
		1028	.proc_open = dahdi_proc_open,
		1029	.proc_read = seq_read,
		1030	.proc_lseek = seq_lseek,
		1031	.proc_release = single_release,
		1032	};
		1033	#endif
1025		1034
1026	#endif	1035	#endif
1027		1036




	return single_open(file, ztdethmf_proc_show, NULL);
}

#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
static const struct file_operations ztdethmf_proc_fops = {
	.open           = ztdethmf_proc_open,
	.read           = seq_read,
	.llseek         = seq_lseek,
	.release        = seq_release,
};
#else
static const struct proc_ops ztdethmf_proc_fops = {
	.proc_open      = ztdethmf_proc_open,
	.proc_read      = seq_read,
	.proc_lseek     = seq_lseek,
	.proc_release   = seq_release,
};
#endif

#endif

static int __init ztdethmf_init(void)

Lines 153-159 Link Here

(-)dahdi-linux-3.1.0-before/drivers/dahdi/xpp/card_bri.c (+14 lines)
153	static bool bri_packet_is_valid(xpacket_t *pack);	153	static bool bri_packet_is_valid(xpacket_t *pack);
154	static void bri_packet_dump(const char msg, xpacket_t pack);	154	static void bri_packet_dump(const char msg, xpacket_t pack);
155	#ifdef CONFIG_PROC_FS	155	#ifdef CONFIG_PROC_FS
		156	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
156	static const struct file_operations proc_bri_info_ops;	157	static const struct file_operations proc_bri_info_ops;
		158	#else
		159	static const struct proc_ops proc_bri_info_ops;
		160	#endif
157	#endif	161	#endif
158	static int bri_spanconfig(struct file file, struct dahdi_span span,	162	static int bri_spanconfig(struct file file, struct dahdi_span span,
159	struct dahdi_lineconfig *lc);	163	struct dahdi_lineconfig *lc);
Lines 1740-1745 Link Here
1740	return single_open(file, proc_bri_info_show, PDE_DATA(inode));	1744	return single_open(file, proc_bri_info_show, PDE_DATA(inode));
1741	}	1745	}
1742		1746
		1747	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
1743	static const struct file_operations proc_bri_info_ops = {	1748	static const struct file_operations proc_bri_info_ops = {
1744	.owner = THIS_MODULE,	1749	.owner = THIS_MODULE,
1745	.open = proc_bri_info_open,	1750	.open = proc_bri_info_open,
Lines 1747-1752 Link Here
1747	.llseek = seq_lseek,	1752	.llseek = seq_lseek,
1748	.release = single_release,	1753	.release = single_release,
1749	};	1754	};
		1755	#else
		1756	static const struct proc_ops proc_bri_info_ops = {
		1757	.proc_open = proc_bri_info_open,
		1758	.proc_read = seq_read,
		1759	.proc_lseek = seq_lseek,
		1760	.proc_release = single_release,
		1761	};
		1762	#endif
		1763
1750	#endif	1764	#endif
1751		1765
1752	static int bri_xpd_probe(struct device *dev)	1766	static int bri_xpd_probe(struct device *dev)

Lines 107-115 Link Here

(-)dahdi-linux-3.1.0-before/drivers/dahdi/xpp/card_fxo.c (+26 lines)
107	static bool fxo_packet_is_valid(xpacket_t *pack);	107	static bool fxo_packet_is_valid(xpacket_t *pack);
108	static void fxo_packet_dump(const char msg, xpacket_t pack);	108	static void fxo_packet_dump(const char msg, xpacket_t pack);
109	#ifdef CONFIG_PROC_FS	109	#ifdef CONFIG_PROC_FS
		110	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
110	static const struct file_operations proc_fxo_info_ops;	111	static const struct file_operations proc_fxo_info_ops;
		112	#else
		113	static const struct proc_ops proc_fxo_info_ops;
		114	#endif
111	#ifdef WITH_METERING	115	#ifdef WITH_METERING
		116	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
112	static const struct file_operations proc_xpd_metering_ops;	117	static const struct file_operations proc_xpd_metering_ops;
		118	#else
		119	static const struct proc_ops proc_xpd_metering_ops;
		120	#endif
113	#endif	121	#endif
114	#endif	122	#endif
115	static void dahdi_report_battery(xpd_t *xpd, lineno_t chan);	123	static void dahdi_report_battery(xpd_t *xpd, lineno_t chan);
Lines 1484-1489 Link Here
1484	return single_open(file, proc_fxo_info_show, PDE_DATA(inode));	1492	return single_open(file, proc_fxo_info_show, PDE_DATA(inode));
1485	}	1493	}
1486		1494
		1495	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
1487	static const struct file_operations proc_fxo_info_ops = {	1496	static const struct file_operations proc_fxo_info_ops = {
1488	.owner = THIS_MODULE,	1497	.owner = THIS_MODULE,
1489	.open = proc_fxo_info_open,	1498	.open = proc_fxo_info_open,
Lines 1491-1496 Link Here
1491	.llseek = seq_lseek,	1500	.llseek = seq_lseek,
1492	.release = single_release,	1501	.release = single_release,
1493	};	1502	};
		1503	#else
		1504	static const struct proc_ops proc_fxo_info_ops = {
		1505	.proc_open = proc_fxo_info_open,
		1506	.proc_read = seq_read,
		1507	.proc_lseek = seq_lseek,
		1508	.proc_release = single_release,
		1509	};
		1510	#endif
1494		1511
1495	#ifdef WITH_METERING	1512	#ifdef WITH_METERING
1496	static int proc_xpd_metering_show(struct seq_file sfile, void not_used)	1513	static int proc_xpd_metering_show(struct seq_file sfile, void not_used)
Lines 1521-1526 Link Here
1521	return single_open(file, proc_xpd_metering_show, PDE_DATA(inode));	1538	return single_open(file, proc_xpd_metering_show, PDE_DATA(inode));
1522	}	1539	}
1523		1540
		1541	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
1524	static const struct file_operations proc_xpd_metering_ops = {	1542	static const struct file_operations proc_xpd_metering_ops = {
1525	.owner = THIS_MODULE,	1543	.owner = THIS_MODULE,
1526	.open = proc_xpd_metering_open,	1544	.open = proc_xpd_metering_open,
Lines 1528-1533 Link Here
1528	.llseek = seq_lseek,	1546	.llseek = seq_lseek,
1529	.release = single_release,	1547	.release = single_release,
1530	};	1548	};
		1549	#else
		1550	static const struct proc_ops proc_xpd_metering_ops = {
		1551	.proc_open = proc_xpd_metering_open,
		1552	.proc_read = seq_read,
		1553	.proc_lseek = seq_lseek,
		1554	.proc_release = single_release,
		1555	};
		1556	#endif
1531		1557
1532	#endif	1558	#endif
1533	#endif	1559	#endif

Lines 160-168 Link Here

(-)dahdi-linux-3.1.0-before/drivers/dahdi/xpp/card_fxs.c (+25 lines)
160	static bool fxs_packet_is_valid(xpacket_t *pack);	160	static bool fxs_packet_is_valid(xpacket_t *pack);
161	static void fxs_packet_dump(const char msg, xpacket_t pack);	161	static void fxs_packet_dump(const char msg, xpacket_t pack);
162	#ifdef CONFIG_PROC_FS	162	#ifdef CONFIG_PROC_FS
		163	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
163	static const struct file_operations proc_fxs_info_ops;	164	static const struct file_operations proc_fxs_info_ops;
		165	#else
		166	static const struct proc_ops proc_fxs_info_ops;
		167	#endif
164	#ifdef WITH_METERING	168	#ifdef WITH_METERING
		169	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
165	static const struct file_operations proc_xpd_metering_ops;	170	static const struct file_operations proc_xpd_metering_ops;
		171	#else
		172	static const struct proc_ops proc_xpd_metering_ops;
		173	#endif
166	#endif	174	#endif
167	#endif	175	#endif
168	static void start_stop_vm_led(xbus_t xbus, xpd_t xpd, lineno_t pos);	176	static void start_stop_vm_led(xbus_t xbus, xpd_t xpd, lineno_t pos);
Lines 2115-2120 Link Here
2115	return single_open(file, proc_fxs_info_show, PDE_DATA(inode));	2123	return single_open(file, proc_fxs_info_show, PDE_DATA(inode));
2116	}	2124	}
2117		2125
		2126	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
2118	static const struct file_operations proc_fxs_info_ops = {	2127	static const struct file_operations proc_fxs_info_ops = {
2119	.owner = THIS_MODULE,	2128	.owner = THIS_MODULE,
2120	.open = proc_fxs_info_open,	2129	.open = proc_fxs_info_open,
Lines 2122-2127 Link Here
2122	.llseek = seq_lseek,	2131	.llseek = seq_lseek,
2123	.release = single_release,	2132	.release = single_release,
2124	};	2133	};
		2134	#else
		2135	static const struct proc_ops proc_fxs_info_ops = {
		2136	.proc_open = proc_fxs_info_open,
		2137	.proc_read = seq_read,
		2138	.proc_lseek = seq_lseek,
		2139	.proc_release = single_release,
		2140	};
		2141	#endif
2125		2142
2126	#ifdef WITH_METERING	2143	#ifdef WITH_METERING
2127	static ssize_t proc_xpd_metering_write(struct file *file,	2144	static ssize_t proc_xpd_metering_write(struct file *file,
Lines 2165-2176 Link Here
2165	file->private_data = PDE_DATA(inode);	2182	file->private_data = PDE_DATA(inode);
2166	}	2183	}
2167		2184
		2185	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
2168	static const struct file_operations proc_xpd_metering_ops = {	2186	static const struct file_operations proc_xpd_metering_ops = {
2169	.owner = THIS_MODULE,	2187	.owner = THIS_MODULE,
2170	.open = proc_xpd_metering_open,	2188	.open = proc_xpd_metering_open,
2171	.write = proc_xpd_metering_write,	2189	.write = proc_xpd_metering_write,
2172	.release = single_release,	2190	.release = single_release,
2173	};	2191	};
		2192	#else
		2193	static const struct proc_ops proc_xpd_metering_ops = {
		2194	.proc_open = proc_xpd_metering_open,
		2195	.proc_write = proc_xpd_metering_write,
		2196	.proc_release = single_release,
		2197	};
		2198	#endif
2174	#endif	2199	#endif
2175	#endif	2200	#endif
2176		2201

Lines 50-56 Link Here

(-)dahdi-linux-3.1.0-before/drivers/dahdi/xpp/xbus-core.c (-1 / +33 lines)
50	#ifdef PROTOCOL_DEBUG	50	#ifdef PROTOCOL_DEBUG
51	#ifdef CONFIG_PROC_FS	51	#ifdef CONFIG_PROC_FS
52	#define PROC_XBUS_COMMAND "command"	52	#define PROC_XBUS_COMMAND "command"
		53	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
53	static const struct file_operations proc_xbus_command_ops;	54	static const struct file_operations proc_xbus_command_ops;
		55	#else
		56	static const struct proc_ops proc_xbus_command_ops;
		57	#endif
54	#endif	58	#endif
55	#endif	59	#endif
56		60
Lines 65-71 Link Here
65	"Register devices automatically (1) or not (0). UNUSED.");	69	"Register devices automatically (1) or not (0). UNUSED.");
66		70
67	#ifdef CONFIG_PROC_FS	71	#ifdef CONFIG_PROC_FS
		72	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
68	static const struct file_operations xbus_read_proc_ops;	73	static const struct file_operations xbus_read_proc_ops;
		74	#else
		75	static const struct proc_ops xbus_read_proc_ops;
		76	#endif
69	#endif	77	#endif
70	static void transport_init(xbus_t xbus, struct xbus_ops ops,	78	static void transport_init(xbus_t xbus, struct xbus_ops ops,
71	ushort max_send_size,	79	ushort max_send_size,
Lines 1828-1833 Link Here
1828	return single_open(file, xbus_proc_show, PDE_DATA(inode));	1836	return single_open(file, xbus_proc_show, PDE_DATA(inode));
1829	}	1837	}
1830		1838
		1839	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
1831	static const struct file_operations xbus_read_proc_ops = {	1840	static const struct file_operations xbus_read_proc_ops = {
1832	.owner = THIS_MODULE,	1841	.owner = THIS_MODULE,
1833	.open = xbus_read_proc_open,	1842	.open = xbus_read_proc_open,
Lines 1835-1840 Link Here
1835	.llseek = seq_lseek,	1844	.llseek = seq_lseek,
1836	.release = single_release,	1845	.release = single_release,
1837	};	1846	};
		1847	#else
		1848	static const struct proc_ops xbus_read_proc_ops = {
		1849	.proc_open = xbus_read_proc_open,
		1850	.proc_read = seq_read,
		1851	.proc_lseek = seq_lseek,
		1852	.proc_release = single_release,
		1853	};
		1854	#endif
1838		1855
1839	#ifdef PROTOCOL_DEBUG	1856	#ifdef PROTOCOL_DEBUG
1840	static ssize_t proc_xbus_command_write(struct file *file,	1857	static ssize_t proc_xbus_command_write(struct file *file,
Lines 1927-1937 Link Here
1927	return 0;	1944	return 0;
1928	}	1945	}
1929		1946
		1947	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
1930	static const struct file_operations proc_xbus_command_ops = {	1948	static const struct file_operations proc_xbus_command_ops = {
1931	.owner = THIS_MODULE,	1949	.owner = THIS_MODULE,
1932	.open = proc_xbus_command_open,	1950	.open = proc_xbus_command_open,
1933	.write = proc_xbus_command_write,	1951	.write = proc_xbus_command_write,
1934	};	1952	};
		1953	#else
		1954	static const struct proc_ops proc_xbus_command_ops = {
		1955	.proc_open = proc_xbus_command_open,
		1956	.proc_write = proc_xbus_command_write,
		1957	};
		1958	#endif
1935	#endif	1959	#endif
1936		1960
1937	static int xpp_proc_read_show(struct seq_file sfile, void data)	1961	static int xpp_proc_read_show(struct seq_file sfile, void data)
Lines 1961-1966 Link Here
1961	return single_open(file, xpp_proc_read_show, PDE_DATA(inode));	1985	return single_open(file, xpp_proc_read_show, PDE_DATA(inode));
1962	}	1986	}
1963		1987
		1988	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
1964	static const struct file_operations xpp_proc_read_ops = {	1989	static const struct file_operations xpp_proc_read_ops = {
1965	.owner = THIS_MODULE,	1990	.owner = THIS_MODULE,
1966	.open = xpp_proc_read_open,	1991	.open = xpp_proc_read_open,
Lines 1968-1974 Link Here
1968	.llseek = seq_lseek,	1993	.llseek = seq_lseek,
1969	.release = single_release,	1994	.release = single_release,
1970	};	1995	};
1971		1996	#else
		1997	static const struct proc_ops xpp_proc_read_ops = {
		1998	.proc_open = xpp_proc_read_open,
		1999	.proc_read = seq_read,
		2000	.proc_lseek = seq_lseek,
		2001	.proc_release = single_release,
		2002	};
		2003	#endif
1972	#endif	2004	#endif
1973		2005
1974	static void transport_init(xbus_t xbus, struct xbus_ops ops,	2006	static void transport_init(xbus_t xbus, struct xbus_ops ops,

Lines 103-109 Link Here

(-)dahdi-linux-3.1.0-before/drivers/dahdi/xpp/xpp_dahdi.c (+13 lines)
103	}	103	}
104		104
105	#ifdef CONFIG_PROC_FS	105	#ifdef CONFIG_PROC_FS
		106	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
106	static const struct file_operations xpd_read_proc_ops;	107	static const struct file_operations xpd_read_proc_ops;
		108	#else
		109	static const struct proc_ops xpd_read_proc_ops;
		110	#endif
107	#endif	111	#endif
108		112
109	/------------------------- XPD Management -------------------------/	113	/------------------------- XPD Management -------------------------/
Lines 392-397 Link Here
392	return single_open(file, xpd_read_proc_show, PDE_DATA(inode));	396	return single_open(file, xpd_read_proc_show, PDE_DATA(inode));
393	}	397	}
394		398
		399	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
395	static const struct file_operations xpd_read_proc_ops = {	400	static const struct file_operations xpd_read_proc_ops = {
396	.owner = THIS_MODULE,	401	.owner = THIS_MODULE,
397	.open = xpd_read_proc_open,	402	.open = xpd_read_proc_open,
Lines 399-404 Link Here
399	.llseek = seq_lseek,	404	.llseek = seq_lseek,
400	.release = single_release,	405	.release = single_release,
401	};	406	};
		407	#else
		408	static const struct proc_ops xpd_read_proc_ops = {
		409	.proc_open = xpd_read_proc_open,
		410	.proc_read = seq_read,
		411	.proc_lseek = seq_lseek,
		412	.proc_release = single_release,
		413	};
		414	#endif
402		415
403	#endif	416	#endif
404		417

Lines 228-234 Link Here

(-)dahdi-linux-3.1.0-before/drivers/dahdi/xpp/xpp_usb.c (-1 / +13 lines)
228	const struct usb_device_id *id);	228	const struct usb_device_id *id);
229	static void xusb_disconnect(struct usb_interface *interface);	229	static void xusb_disconnect(struct usb_interface *interface);
230	#ifdef CONFIG_PROC_FS	230	#ifdef CONFIG_PROC_FS
		231	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
231	static const struct file_operations xusb_read_proc_ops;	232	static const struct file_operations xusb_read_proc_ops;
		233	#else
		234	static const struct proc_ops xusb_read_proc_ops;
		235	#endif
232	#endif	236	#endif
233		237
234	/------------------------------------------------------------------/	238	/------------------------------------------------------------------/
Lines 1108-1113 Link Here
1108	return single_open(file, xusb_read_proc_show, PDE_DATA(inode));	1112	return single_open(file, xusb_read_proc_show, PDE_DATA(inode));
1109	}	1113	}
1110		1114
		1115	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
1111	static const struct file_operations xusb_read_proc_ops = {	1116	static const struct file_operations xusb_read_proc_ops = {
1112	.owner = THIS_MODULE,	1117	.owner = THIS_MODULE,
1113	.open = xusb_read_proc_open,	1118	.open = xusb_read_proc_open,
Lines 1115-1121 Link Here
1115	.llseek = seq_lseek,	1120	.llseek = seq_lseek,
1116	.release = single_release,	1121	.release = single_release,
1117	};	1122	};
1118		1123	#else
		1124	static const struct proc_ops xusb_read_proc_ops = {
		1125	.proc_open = xusb_read_proc_open,
		1126	.proc_read = seq_read,
		1127	.proc_lseek = seq_lseek,
		1128	.proc_release = single_release,
		1129	};
		1130	#endif
1119		1131
1120	#endif	1132	#endif
1121		1133

Return to bug 716226

Lines 733-744 Link Here

(-)dahdi-linux-3.1.0-before/drivers/dahdi/dahdi_dynamic_ethmf.c (+10 lines)
733	return single_open(file, ztdethmf_proc_show, NULL);	733	return single_open(file, ztdethmf_proc_show, NULL);
734	}	734	}
735		735
		736	#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 6, 0)
736	static const struct file_operations ztdethmf_proc_fops = {	737	static const struct file_operations ztdethmf_proc_fops = {
737	.open = ztdethmf_proc_open,	738	.open = ztdethmf_proc_open,
738	.read = seq_read,	739	.read = seq_read,
739	.llseek = seq_lseek,	740	.llseek = seq_lseek,
740	.release = seq_release,	741	.release = seq_release,
741	};	742	};
		743	#else
		744	static const struct proc_ops ztdethmf_proc_fops = {
		745	.proc_open = ztdethmf_proc_open,
		746	.proc_read = seq_read,
		747	.proc_lseek = seq_lseek,
		748	.proc_release = seq_release,
		749	};
		750	#endif
		751
742	#endif	752	#endif
743		753
744	static int __init ztdethmf_init(void)	754	static int __init ztdethmf_init(void)