1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * c8sectpfe-common.c - C8SECTPFE STi DVB driver
4  *
5  * Copyright (c) STMicroelectronics 2015
6  *
7  *   Author: Peter Griffin <peter.griffin@linaro.org>
8  *
9  */
10 #include <linux/completion.h>
11 #include <linux/delay.h>
12 #include <linux/device.h>
13 #include <linux/dvb/dmx.h>
14 #include <linux/errno.h>
15 #include <linux/init.h>
16 #include <linux/interrupt.h>
17 #include <linux/io.h>
18 #include <linux/ioport.h>
19 #include <linux/module.h>
20 #include <linux/slab.h>
21 #include <linux/time.h>
22 #include <linux/wait.h>
23 
24 #include <media/dmxdev.h>
25 #include <media/dvbdev.h>
26 #include <media/dvb_demux.h>
27 #include <media/dvb_frontend.h>
28 #include <media/dvb_net.h>
29 
30 #include "c8sectpfe-common.h"
31 #include "c8sectpfe-core.h"
32 #include "c8sectpfe-dvb.h"
33 
34 static int register_dvb(struct stdemux *demux, struct dvb_adapter *adap,
35 				void *start_feed, void *stop_feed,
36 				struct c8sectpfei *fei)
37 {
38 	int result;
39 
40 	demux->dvb_demux.dmx.capabilities = DMX_TS_FILTERING |
41 					DMX_SECTION_FILTERING |
42 					DMX_MEMORY_BASED_FILTERING;
43 
44 	demux->dvb_demux.priv = demux;
45 	demux->dvb_demux.filternum = C8SECTPFE_MAXCHANNEL;
46 	demux->dvb_demux.feednum = C8SECTPFE_MAXCHANNEL;
47 
48 	demux->dvb_demux.start_feed = start_feed;
49 	demux->dvb_demux.stop_feed = stop_feed;
50 	demux->dvb_demux.write_to_decoder = NULL;
51 
52 	result = dvb_dmx_init(&demux->dvb_demux);
53 	if (result < 0) {
54 		dev_err(fei->dev, "dvb_dmx_init failed (errno = %d)\n",
55 			result);
56 		goto err_dmx;
57 	}
58 
59 	demux->dmxdev.filternum = demux->dvb_demux.filternum;
60 	demux->dmxdev.demux = &demux->dvb_demux.dmx;
61 	demux->dmxdev.capabilities = 0;
62 
63 	result = dvb_dmxdev_init(&demux->dmxdev, adap);
64 	if (result < 0) {
65 		dev_err(fei->dev, "dvb_dmxdev_init failed (errno = %d)\n",
66 			result);
67 
68 		goto err_dmxdev;
69 	}
70 
71 	demux->hw_frontend.source = DMX_FRONTEND_0 + demux->tsin_index;
72 
73 	result = demux->dvb_demux.dmx.add_frontend(&demux->dvb_demux.dmx,
74 						&demux->hw_frontend);
75 	if (result < 0) {
76 		dev_err(fei->dev, "add_frontend failed (errno = %d)\n", result);
77 		goto err_fe_hw;
78 	}
79 
80 	demux->mem_frontend.source = DMX_MEMORY_FE;
81 	result = demux->dvb_demux.dmx.add_frontend(&demux->dvb_demux.dmx,
82 						&demux->mem_frontend);
83 	if (result < 0) {
84 		dev_err(fei->dev, "add_frontend failed (%d)\n", result);
85 		goto err_fe_mem;
86 	}
87 
88 	result = demux->dvb_demux.dmx.connect_frontend(&demux->dvb_demux.dmx,
89 							&demux->hw_frontend);
90 	if (result < 0) {
91 		dev_err(fei->dev, "connect_frontend (%d)\n", result);
92 		goto err_fe_con;
93 	}
94 
95 	return 0;
96 
97 err_fe_con:
98 	demux->dvb_demux.dmx.remove_frontend(&demux->dvb_demux.dmx,
99 						     &demux->mem_frontend);
100 err_fe_mem:
101 	demux->dvb_demux.dmx.remove_frontend(&demux->dvb_demux.dmx,
102 						     &demux->hw_frontend);
103 err_fe_hw:
104 	dvb_dmxdev_release(&demux->dmxdev);
105 err_dmxdev:
106 	dvb_dmx_release(&demux->dvb_demux);
107 err_dmx:
108 	return result;
109 
110 }
111 
112 static void unregister_dvb(struct stdemux *demux)
113 {
114 
115 	demux->dvb_demux.dmx.remove_frontend(&demux->dvb_demux.dmx,
116 						     &demux->mem_frontend);
117 
118 	demux->dvb_demux.dmx.remove_frontend(&demux->dvb_demux.dmx,
119 						     &demux->hw_frontend);
120 
121 	dvb_dmxdev_release(&demux->dmxdev);
122 
123 	dvb_dmx_release(&demux->dvb_demux);
124 }
125 
126 static struct c8sectpfe *c8sectpfe_create(struct c8sectpfei *fei,
127 				void *start_feed,
128 				void *stop_feed)
129 {
130 	struct c8sectpfe *c8sectpfe;
131 	int result;
132 	int i, j;
133 
134 	short int ids[] = { -1 };
135 
136 	c8sectpfe = kzalloc(sizeof(struct c8sectpfe), GFP_KERNEL);
137 	if (!c8sectpfe)
138 		goto err1;
139 
140 	mutex_init(&c8sectpfe->lock);
141 
142 	c8sectpfe->device = fei->dev;
143 
144 	result = dvb_register_adapter(&c8sectpfe->adapter, "STi c8sectpfe",
145 					THIS_MODULE, fei->dev, ids);
146 	if (result < 0) {
147 		dev_err(fei->dev, "dvb_register_adapter failed (errno = %d)\n",
148 			result);
149 		goto err2;
150 	}
151 
152 	c8sectpfe->adapter.priv = fei;
153 
154 	for (i = 0; i < fei->tsin_count; i++) {
155 
156 		c8sectpfe->demux[i].tsin_index = i;
157 		c8sectpfe->demux[i].c8sectpfei = fei;
158 
159 		result = register_dvb(&c8sectpfe->demux[i], &c8sectpfe->adapter,
160 				start_feed, stop_feed, fei);
161 		if (result < 0) {
162 			dev_err(fei->dev,
163 				"register_dvb feed=%d failed (errno = %d)\n",
164 				result, i);
165 
166 			/* we take a all or nothing approach */
167 			for (j = 0; j < i; j++)
168 				unregister_dvb(&c8sectpfe->demux[j]);
169 			goto err3;
170 		}
171 	}
172 
173 	c8sectpfe->num_feeds = fei->tsin_count;
174 
175 	return c8sectpfe;
176 err3:
177 	dvb_unregister_adapter(&c8sectpfe->adapter);
178 err2:
179 	kfree(c8sectpfe);
180 err1:
181 	return NULL;
182 };
183 
184 static void c8sectpfe_delete(struct c8sectpfe *c8sectpfe)
185 {
186 	int i;
187 
188 	if (!c8sectpfe)
189 		return;
190 
191 	for (i = 0; i < c8sectpfe->num_feeds; i++)
192 		unregister_dvb(&c8sectpfe->demux[i]);
193 
194 	dvb_unregister_adapter(&c8sectpfe->adapter);
195 
196 	kfree(c8sectpfe);
197 };
198 
199 void c8sectpfe_tuner_unregister_frontend(struct c8sectpfe *c8sectpfe,
200 					struct c8sectpfei *fei)
201 {
202 	int n;
203 	struct channel_info *tsin;
204 
205 	for (n = 0; n < fei->tsin_count; n++) {
206 
207 		tsin = fei->channel_data[n];
208 
209 		if (tsin) {
210 			if (tsin->frontend) {
211 				dvb_unregister_frontend(tsin->frontend);
212 				dvb_frontend_detach(tsin->frontend);
213 			}
214 
215 			i2c_put_adapter(tsin->i2c_adapter);
216 
217 			if (tsin->i2c_client) {
218 				module_put(tsin->i2c_client->dev.driver->owner);
219 				i2c_unregister_device(tsin->i2c_client);
220 			}
221 		}
222 	}
223 
224 	c8sectpfe_delete(c8sectpfe);
225 };
226 
227 int c8sectpfe_tuner_register_frontend(struct c8sectpfe **c8sectpfe,
228 				struct c8sectpfei *fei,
229 				void *start_feed,
230 				void *stop_feed)
231 {
232 	struct channel_info *tsin;
233 	struct dvb_frontend *frontend;
234 	int n, res;
235 
236 	*c8sectpfe = c8sectpfe_create(fei, start_feed, stop_feed);
237 	if (!*c8sectpfe)
238 		return -ENOMEM;
239 
240 	for (n = 0; n < fei->tsin_count; n++) {
241 		tsin = fei->channel_data[n];
242 
243 		res = c8sectpfe_frontend_attach(&frontend, *c8sectpfe, tsin, n);
244 		if (res)
245 			goto err;
246 
247 		res = dvb_register_frontend(&c8sectpfe[0]->adapter, frontend);
248 		if (res < 0) {
249 			dev_err(fei->dev, "dvb_register_frontend failed (%d)\n",
250 				res);
251 			goto err;
252 		}
253 
254 		tsin->frontend = frontend;
255 	}
256 
257 	return 0;
258 
259 err:
260 	c8sectpfe_tuner_unregister_frontend(*c8sectpfe, fei);
261 	return res;
262 }
263