1
2
3
4
5
6
7
8
9
10#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__
11
12#include <linux/spi/spi.h>
13#include <linux/ktime.h>
14
15#include <media/dvb_demux.h>
16#include <media/dmxdev.h>
17#include <media/dvb_frontend.h>
18#include "cxd2880.h"
19
20#define CXD2880_MAX_FILTER_SIZE 32
21#define BURST_WRITE_MAX 128
22#define MAX_TRANS_PKT 300
23
24struct cxd2880_ts_buf_info {
25 u8 read_ready:1;
26 u8 almost_full:1;
27 u8 almost_empty:1;
28 u8 overflow:1;
29 u8 underflow:1;
30 u16 pkt_num;
31};
32
33struct cxd2880_pid_config {
34 u8 is_enable;
35 u16 pid;
36};
37
38struct cxd2880_pid_filter_config {
39 u8 is_negative;
40 struct cxd2880_pid_config pid_config[CXD2880_MAX_FILTER_SIZE];
41};
42
43struct cxd2880_dvb_spi {
44 struct dvb_frontend dvb_fe;
45 struct dvb_adapter adapter;
46 struct dvb_demux demux;
47 struct dmxdev dmxdev;
48 struct dmx_frontend dmx_fe;
49 struct task_struct *cxd2880_ts_read_thread;
50 struct spi_device *spi;
51 struct mutex spi_mutex;
52 int feed_count;
53 int all_pid_feed_count;
54 u8 *ts_buf;
55 struct cxd2880_pid_filter_config filter_config;
56};
57
58DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
59
60static int cxd2880_write_spi(struct spi_device *spi, u8 *data, u32 size)
61{
62 struct spi_message msg;
63 struct spi_transfer tx;
64
65 if (!spi || !data) {
66 pr_err("invalid arg\n");
67 return -EINVAL;
68 }
69
70 memset(&tx, 0, sizeof(tx));
71 tx.tx_buf = data;
72 tx.len = size;
73
74 spi_message_init(&msg);
75 spi_message_add_tail(&tx, &msg);
76
77 return spi_sync(spi, &msg);
78}
79
80static int cxd2880_write_reg(struct spi_device *spi,
81 u8 sub_address, const u8 *data, u32 size)
82{
83 u8 send_data[BURST_WRITE_MAX + 4];
84 const u8 *write_data_top = NULL;
85 int ret = 0;
86
87 if (!spi || !data) {
88 pr_err("invalid arg\n");
89 return -EINVAL;
90 }
91 if (size > BURST_WRITE_MAX) {
92 pr_err("data size > WRITE_MAX\n");
93 return -EINVAL;
94 }
95
96 if (sub_address + size > 0x100) {
97 pr_err("out of range\n");
98 return -EINVAL;
99 }
100
101 send_data[0] = 0x0e;
102 write_data_top = data;
103
104 while (size > 0) {
105 send_data[1] = sub_address;
106 if (size > 255)
107 send_data[2] = 255;
108 else
109 send_data[2] = (u8)size;
110
111 memcpy(&send_data[3], write_data_top, send_data[2]);
112
113 ret = cxd2880_write_spi(spi, send_data, send_data[2] + 3);
114 if (ret) {
115 pr_err("write spi failed %d\n", ret);
116 break;
117 }
118 sub_address += send_data[2];
119 write_data_top += send_data[2];
120 size -= send_data[2];
121 }
122
123 return ret;
124}
125
126static int cxd2880_spi_read_ts(struct spi_device *spi,
127 u8 *read_data,
128 u32 packet_num)
129{
130 int ret;
131 u8 data[3];
132 struct spi_message message;
133 struct spi_transfer transfer[2];
134
135 if (!spi || !read_data || !packet_num) {
136 pr_err("invalid arg\n");
137 return -EINVAL;
138 }
139 if (packet_num > 0xffff) {
140 pr_err("packet num > 0xffff\n");
141 return -EINVAL;
142 }
143
144 data[0] = 0x10;
145 data[1] = packet_num >> 8;
146 data[2] = packet_num;
147
148 spi_message_init(&message);
149 memset(transfer, 0, sizeof(transfer));
150
151 transfer[0].len = 3;
152 transfer[0].tx_buf = data;
153 spi_message_add_tail(&transfer[0], &message);
154 transfer[1].len = packet_num * 188;
155 transfer[1].rx_buf = read_data;
156 spi_message_add_tail(&transfer[1], &message);
157
158 ret = spi_sync(spi, &message);
159 if (ret)
160 pr_err("spi_write_then_read failed\n");
161
162 return ret;
163}
164
165static int cxd2880_spi_read_ts_buffer_info(struct spi_device *spi,
166 struct cxd2880_ts_buf_info *info)
167{
168 u8 send_data = 0x20;
169 u8 recv_data[2];
170 int ret;
171
172 if (!spi || !info) {
173 pr_err("invalid arg\n");
174 return -EINVAL;
175 }
176
177 ret = spi_write_then_read(spi, &send_data, 1,
178 recv_data, sizeof(recv_data));
179 if (ret)
180 pr_err("spi_write_then_read failed\n");
181
182 info->read_ready = (recv_data[0] & 0x80) ? 1 : 0;
183 info->almost_full = (recv_data[0] & 0x40) ? 1 : 0;
184 info->almost_empty = (recv_data[0] & 0x20) ? 1 : 0;
185 info->overflow = (recv_data[0] & 0x10) ? 1 : 0;
186 info->underflow = (recv_data[0] & 0x08) ? 1 : 0;
187 info->pkt_num = ((recv_data[0] & 0x07) << 8) | recv_data[1];
188
189 return ret;
190}
191
192static int cxd2880_spi_clear_ts_buffer(struct spi_device *spi)
193{
194 u8 data = 0x03;
195 int ret;
196
197 ret = cxd2880_write_spi(spi, &data, 1);
198
199 if (ret)
200 pr_err("write spi failed\n");
201
202 return ret;
203}
204
205static int cxd2880_set_pid_filter(struct spi_device *spi,
206 struct cxd2880_pid_filter_config *cfg)
207{
208 u8 data[65];
209 int i;
210 u16 pid = 0;
211 int ret;
212
213 if (!spi) {
214 pr_err("invalid arg\n");
215 return -EINVAL;
216 }
217
218 data[0] = 0x00;
219 ret = cxd2880_write_reg(spi, 0x00, &data[0], 1);
220 if (ret)
221 return ret;
222 if (!cfg) {
223 data[0] = 0x02;
224 ret = cxd2880_write_reg(spi, 0x50, &data[0], 1);
225 } else {
226 data[0] = cfg->is_negative ? 0x01 : 0x00;
227
228 for (i = 0; i < CXD2880_MAX_FILTER_SIZE; i++) {
229 pid = cfg->pid_config[i].pid;
230 if (cfg->pid_config[i].is_enable) {
231 data[1 + (i * 2)] = (pid >> 8) | 0x20;
232 data[2 + (i * 2)] = pid & 0xff;
233 } else {
234 data[1 + (i * 2)] = 0x00;
235 data[2 + (i * 2)] = 0x00;
236 }
237 }
238 ret = cxd2880_write_reg(spi, 0x50, data, 65);
239 }
240
241 return ret;
242}
243
244static int cxd2880_update_pid_filter(struct cxd2880_dvb_spi *dvb_spi,
245 struct cxd2880_pid_filter_config *cfg,
246 bool is_all_pid_filter)
247{
248 int ret;
249
250 if (!dvb_spi || !cfg) {
251 pr_err("invalid arg.\n");
252 return -EINVAL;
253 }
254
255 mutex_lock(&dvb_spi->spi_mutex);
256 if (is_all_pid_filter) {
257 struct cxd2880_pid_filter_config tmpcfg;
258
259 memset(&tmpcfg, 0, sizeof(tmpcfg));
260 tmpcfg.is_negative = 1;
261 tmpcfg.pid_config[0].is_enable = 1;
262 tmpcfg.pid_config[0].pid = 0x1fff;
263
264 ret = cxd2880_set_pid_filter(dvb_spi->spi, &tmpcfg);
265 } else {
266 ret = cxd2880_set_pid_filter(dvb_spi->spi, cfg);
267 }
268 mutex_unlock(&dvb_spi->spi_mutex);
269
270 if (ret)
271 pr_err("set_pid_filter failed\n");
272
273 return ret;
274}
275
276static int cxd2880_ts_read(void *arg)
277{
278 struct cxd2880_dvb_spi *dvb_spi = NULL;
279 struct cxd2880_ts_buf_info info;
280 ktime_t start;
281 u32 i;
282 int ret;
283
284 dvb_spi = arg;
285 if (!dvb_spi) {
286 pr_err("invalid arg\n");
287 return -EINVAL;
288 }
289
290 ret = cxd2880_spi_clear_ts_buffer(dvb_spi->spi);
291 if (ret) {
292 pr_err("set_clear_ts_buffer failed\n");
293 return ret;
294 }
295
296 start = ktime_get();
297 while (!kthread_should_stop()) {
298 ret = cxd2880_spi_read_ts_buffer_info(dvb_spi->spi,
299 &info);
300 if (ret) {
301 pr_err("spi_read_ts_buffer_info error\n");
302 return ret;
303 }
304
305 if (info.pkt_num > MAX_TRANS_PKT) {
306 for (i = 0; i < info.pkt_num / MAX_TRANS_PKT; i++) {
307 cxd2880_spi_read_ts(dvb_spi->spi,
308 dvb_spi->ts_buf,
309 MAX_TRANS_PKT);
310 dvb_dmx_swfilter(&dvb_spi->demux,
311 dvb_spi->ts_buf,
312 MAX_TRANS_PKT * 188);
313 }
314 start = ktime_get();
315 } else if ((info.pkt_num > 0) &&
316 (ktime_to_ms(ktime_sub(ktime_get(), start)) >= 500)) {
317 cxd2880_spi_read_ts(dvb_spi->spi,
318 dvb_spi->ts_buf,
319 info.pkt_num);
320 dvb_dmx_swfilter(&dvb_spi->demux,
321 dvb_spi->ts_buf,
322 info.pkt_num * 188);
323 start = ktime_get();
324 } else {
325 usleep_range(10000, 11000);
326 }
327 }
328
329 return 0;
330}
331
332static int cxd2880_start_feed(struct dvb_demux_feed *feed)
333{
334 int ret = 0;
335 int i = 0;
336 struct dvb_demux *demux = NULL;
337 struct cxd2880_dvb_spi *dvb_spi = NULL;
338
339 if (!feed) {
340 pr_err("invalid arg\n");
341 return -EINVAL;
342 }
343
344 demux = feed->demux;
345 if (!demux) {
346 pr_err("feed->demux is NULL\n");
347 return -EINVAL;
348 }
349 dvb_spi = demux->priv;
350
351 if (dvb_spi->feed_count == CXD2880_MAX_FILTER_SIZE) {
352 pr_err("Exceeded maximum PID count (32).");
353 pr_err("Selected PID cannot be enabled.\n");
354 return -EINVAL;
355 }
356
357 if (feed->pid == 0x2000) {
358 if (dvb_spi->all_pid_feed_count == 0) {
359 ret = cxd2880_update_pid_filter(dvb_spi,
360 &dvb_spi->filter_config,
361 true);
362 if (ret) {
363 pr_err("update pid filter failed\n");
364 return ret;
365 }
366 }
367 dvb_spi->all_pid_feed_count++;
368
369 pr_debug("all PID feed (count = %d)\n",
370 dvb_spi->all_pid_feed_count);
371 } else {
372 struct cxd2880_pid_filter_config cfgtmp;
373
374 cfgtmp = dvb_spi->filter_config;
375
376 for (i = 0; i < CXD2880_MAX_FILTER_SIZE; i++) {
377 if (cfgtmp.pid_config[i].is_enable == 0) {
378 cfgtmp.pid_config[i].is_enable = 1;
379 cfgtmp.pid_config[i].pid = feed->pid;
380 pr_debug("store PID %d to #%d\n",
381 feed->pid, i);
382 break;
383 }
384 }
385 if (i == CXD2880_MAX_FILTER_SIZE) {
386 pr_err("PID filter is full. Assumed bug.\n");
387 return -EINVAL;
388 }
389 if (!dvb_spi->all_pid_feed_count)
390 ret = cxd2880_update_pid_filter(dvb_spi,
391 &cfgtmp,
392 false);
393 if (ret)
394 return ret;
395
396 dvb_spi->filter_config = cfgtmp;
397 }
398
399 if (dvb_spi->feed_count == 0) {
400 dvb_spi->ts_buf =
401 kmalloc(MAX_TRANS_PKT * 188,
402 GFP_KERNEL | GFP_DMA);
403 if (!dvb_spi->ts_buf) {
404 pr_err("ts buffer allocate failed\n");
405 memset(&dvb_spi->filter_config, 0,
406 sizeof(dvb_spi->filter_config));
407 dvb_spi->all_pid_feed_count = 0;
408 return -ENOMEM;
409 }
410 dvb_spi->cxd2880_ts_read_thread = kthread_run(cxd2880_ts_read,
411 dvb_spi,
412 "cxd2880_ts_read");
413 if (IS_ERR(dvb_spi->cxd2880_ts_read_thread)) {
414 pr_err("kthread_run failed/\n");
415 kfree(dvb_spi->ts_buf);
416 dvb_spi->ts_buf = NULL;
417 memset(&dvb_spi->filter_config, 0,
418 sizeof(dvb_spi->filter_config));
419 dvb_spi->all_pid_feed_count = 0;
420 return PTR_ERR(dvb_spi->cxd2880_ts_read_thread);
421 }
422 }
423
424 dvb_spi->feed_count++;
425
426 pr_debug("start feed (count %d)\n", dvb_spi->feed_count);
427 return 0;
428}
429
430static int cxd2880_stop_feed(struct dvb_demux_feed *feed)
431{
432 int i = 0;
433 int ret;
434 struct dvb_demux *demux = NULL;
435 struct cxd2880_dvb_spi *dvb_spi = NULL;
436
437 if (!feed) {
438 pr_err("invalid arg\n");
439 return -EINVAL;
440 }
441
442 demux = feed->demux;
443 if (!demux) {
444 pr_err("feed->demux is NULL\n");
445 return -EINVAL;
446 }
447 dvb_spi = demux->priv;
448
449 if (!dvb_spi->feed_count) {
450 pr_err("no feed is started\n");
451 return -EINVAL;
452 }
453
454 if (feed->pid == 0x2000) {
455
456
457
458
459
460 if (dvb_spi->all_pid_feed_count <= 0) {
461 pr_err("PID %d not found.\n", feed->pid);
462 return -EINVAL;
463 }
464 dvb_spi->all_pid_feed_count--;
465 } else {
466 struct cxd2880_pid_filter_config cfgtmp;
467
468 cfgtmp = dvb_spi->filter_config;
469
470 for (i = 0; i < CXD2880_MAX_FILTER_SIZE; i++) {
471 if (feed->pid == cfgtmp.pid_config[i].pid &&
472 cfgtmp.pid_config[i].is_enable != 0) {
473 cfgtmp.pid_config[i].is_enable = 0;
474 cfgtmp.pid_config[i].pid = 0;
475 pr_debug("removed PID %d from #%d\n",
476 feed->pid, i);
477 break;
478 }
479 }
480 dvb_spi->filter_config = cfgtmp;
481
482 if (i == CXD2880_MAX_FILTER_SIZE) {
483 pr_err("PID %d not found\n", feed->pid);
484 return -EINVAL;
485 }
486 }
487
488 ret = cxd2880_update_pid_filter(dvb_spi,
489 &dvb_spi->filter_config,
490 dvb_spi->all_pid_feed_count > 0);
491 dvb_spi->feed_count--;
492
493 if (dvb_spi->feed_count == 0) {
494 int ret_stop = 0;
495
496 ret_stop = kthread_stop(dvb_spi->cxd2880_ts_read_thread);
497 if (ret_stop) {
498 pr_err("'kthread_stop failed. (%d)\n", ret_stop);
499 ret = ret_stop;
500 }
501 kfree(dvb_spi->ts_buf);
502 dvb_spi->ts_buf = NULL;
503 }
504
505 pr_debug("stop feed ok.(count %d)\n", dvb_spi->feed_count);
506
507 return ret;
508}
509
510static const struct of_device_id cxd2880_spi_of_match[] = {
511 { .compatible = "sony,cxd2880" },
512 { }
513};
514
515MODULE_DEVICE_TABLE(of, cxd2880_spi_of_match);
516
517static int
518cxd2880_spi_probe(struct spi_device *spi)
519{
520 int ret;
521 struct cxd2880_dvb_spi *dvb_spi = NULL;
522 struct cxd2880_config config;
523
524 if (!spi) {
525 pr_err("invalid arg.\n");
526 return -EINVAL;
527 }
528
529 dvb_spi = kzalloc(sizeof(struct cxd2880_dvb_spi), GFP_KERNEL);
530 if (!dvb_spi)
531 return -ENOMEM;
532
533 dvb_spi->spi = spi;
534 mutex_init(&dvb_spi->spi_mutex);
535 dev_set_drvdata(&spi->dev, dvb_spi);
536 config.spi = spi;
537 config.spi_mutex = &dvb_spi->spi_mutex;
538
539 ret = dvb_register_adapter(&dvb_spi->adapter,
540 "CXD2880",
541 THIS_MODULE,
542 &spi->dev,
543 adapter_nr);
544 if (ret < 0) {
545 pr_err("dvb_register_adapter() failed\n");
546 goto fail_adapter;
547 }
548
549 if (!dvb_attach(cxd2880_attach, &dvb_spi->dvb_fe, &config)) {
550 pr_err("cxd2880_attach failed\n");
551 goto fail_attach;
552 }
553
554 ret = dvb_register_frontend(&dvb_spi->adapter,
555 &dvb_spi->dvb_fe);
556 if (ret < 0) {
557 pr_err("dvb_register_frontend() failed\n");
558 goto fail_frontend;
559 }
560
561 dvb_spi->demux.dmx.capabilities = DMX_TS_FILTERING;
562 dvb_spi->demux.priv = dvb_spi;
563 dvb_spi->demux.filternum = CXD2880_MAX_FILTER_SIZE;
564 dvb_spi->demux.feednum = CXD2880_MAX_FILTER_SIZE;
565 dvb_spi->demux.start_feed = cxd2880_start_feed;
566 dvb_spi->demux.stop_feed = cxd2880_stop_feed;
567
568 ret = dvb_dmx_init(&dvb_spi->demux);
569 if (ret < 0) {
570 pr_err("dvb_dmx_init() failed\n");
571 goto fail_dmx;
572 }
573
574 dvb_spi->dmxdev.filternum = CXD2880_MAX_FILTER_SIZE;
575 dvb_spi->dmxdev.demux = &dvb_spi->demux.dmx;
576 dvb_spi->dmxdev.capabilities = 0;
577 ret = dvb_dmxdev_init(&dvb_spi->dmxdev,
578 &dvb_spi->adapter);
579 if (ret < 0) {
580 pr_err("dvb_dmxdev_init() failed\n");
581 goto fail_dmxdev;
582 }
583
584 dvb_spi->dmx_fe.source = DMX_FRONTEND_0;
585 ret = dvb_spi->demux.dmx.add_frontend(&dvb_spi->demux.dmx,
586 &dvb_spi->dmx_fe);
587 if (ret < 0) {
588 pr_err("add_frontend() failed\n");
589 goto fail_dmx_fe;
590 }
591
592 ret = dvb_spi->demux.dmx.connect_frontend(&dvb_spi->demux.dmx,
593 &dvb_spi->dmx_fe);
594 if (ret < 0) {
595 pr_err("dvb_register_frontend() failed\n");
596 goto fail_fe_conn;
597 }
598
599 pr_info("Sony CXD2880 has successfully attached.\n");
600
601 return 0;
602
603fail_fe_conn:
604 dvb_spi->demux.dmx.remove_frontend(&dvb_spi->demux.dmx,
605 &dvb_spi->dmx_fe);
606fail_dmx_fe:
607 dvb_dmxdev_release(&dvb_spi->dmxdev);
608fail_dmxdev:
609 dvb_dmx_release(&dvb_spi->demux);
610fail_dmx:
611 dvb_unregister_frontend(&dvb_spi->dvb_fe);
612fail_frontend:
613 dvb_frontend_detach(&dvb_spi->dvb_fe);
614fail_attach:
615 dvb_unregister_adapter(&dvb_spi->adapter);
616fail_adapter:
617 kfree(dvb_spi);
618 return ret;
619}
620
621static int
622cxd2880_spi_remove(struct spi_device *spi)
623{
624 struct cxd2880_dvb_spi *dvb_spi;
625
626 if (!spi) {
627 pr_err("invalid arg\n");
628 return -EINVAL;
629 }
630
631 dvb_spi = dev_get_drvdata(&spi->dev);
632
633 if (!dvb_spi) {
634 pr_err("failed\n");
635 return -EINVAL;
636 }
637 dvb_spi->demux.dmx.remove_frontend(&dvb_spi->demux.dmx,
638 &dvb_spi->dmx_fe);
639 dvb_dmxdev_release(&dvb_spi->dmxdev);
640 dvb_dmx_release(&dvb_spi->demux);
641 dvb_unregister_frontend(&dvb_spi->dvb_fe);
642 dvb_frontend_detach(&dvb_spi->dvb_fe);
643 dvb_unregister_adapter(&dvb_spi->adapter);
644
645 kfree(dvb_spi);
646 pr_info("cxd2880_spi remove ok.\n");
647
648 return 0;
649}
650
651static const struct spi_device_id cxd2880_spi_id[] = {
652 { "cxd2880", 0 },
653 { }
654};
655MODULE_DEVICE_TABLE(spi, cxd2880_spi_id);
656
657static struct spi_driver cxd2880_spi_driver = {
658 .driver = {
659 .name = "cxd2880",
660 .of_match_table = cxd2880_spi_of_match,
661 },
662 .id_table = cxd2880_spi_id,
663 .probe = cxd2880_spi_probe,
664 .remove = cxd2880_spi_remove,
665};
666module_spi_driver(cxd2880_spi_driver);
667
668MODULE_DESCRIPTION("Sony CXD2880 DVB-T2/T tuner + demod driver SPI adapter");
669MODULE_AUTHOR("Sony Semiconductor Solutions Corporation");
670MODULE_LICENSE("GPL v2");
671
