Dear Mauro I am very glad to hear your message. Being busy, thank you for taking care of fixing patches as well also. And we will improve about your below comments continuously. Regards & Thanks Takiguchi > -----Original Message----- > From: Mauro Carvalho Chehab [mailto:mchehab@xxxxxxxxxxxxxxxx] > Sent: Wednesday, March 7, 2018 7:15 PM > To: Takiguchi, Yasunari (SSS) > Cc: linux-kernel@xxxxxxxxxxxxxxx; devicetree@xxxxxxxxxxxxxxx; > linux-media@xxxxxxxxxxxxxxx; tbird20d@xxxxxxxxx; > frowand.list@xxxxxxxxx; Yamamoto, Masayuki (SSS); Nozawa, Hideki (STWN); > Yonezawa, Kota (SSS); Matsumoto, Toshihiko (SSS); Watanabe, Satoshi (SSS) > Subject: Re: [PATCH v5 02/12] [media] cxd2880-spi: Add support for CXD2880 > SPI interface > > Em Thu, 18 Jan 2018 17:46:10 +0900 > <Yasunari.Takiguchi@xxxxxxxx> escreveu: > > > From: Yasunari Takiguchi <Yasunari.Takiguchi@xxxxxxxx> > > > > This is the SPI adapter part of the driver for the Sony CXD2880 > > DVB-T2/T tuner + demodulator. > > Thanks for the patches! > > The patch series look ok. Just a few nitpicks that could be solved later. > > I had to apply a few patches to make it build and remove some warnings > with W=1. Patches sent. > > With that, I'm applying this series. > > Regards, > Mauro > > > > > Signed-off-by: Yasunari Takiguchi <Yasunari.Takiguchi@xxxxxxxx> > > Signed-off-by: Masayuki Yamamoto <Masayuki.Yamamoto@xxxxxxxx> > > Signed-off-by: Hideki Nozawa <Hideki.Nozawa@xxxxxxxx> > > Signed-off-by: Kota Yonezawa <Kota.Yonezawa@xxxxxxxx> > > Signed-off-by: Toshihiko Matsumoto <Toshihiko.Matsumoto@xxxxxxxx> > > Signed-off-by: Satoshi Watanabe <Satoshi.C.Watanabe@xxxxxxxx> > > --- > > > > [Change list] > > Changes in V5 > > Using SPDX-License-Identifier > > drivers/media/spi/cxd2880-spi.c > > -modified typo about "ivnalid" -> "invalid" > > -modified typo about "drvier" -> "driver" > > -removed unnecessary if() > > -modified return error code > > -reduction of valiable names > > -removed unnecessary parentheses > > -changed members of struct cxd2880_ts_buf_info > > > > Changes in V4 > > drivers/media/spi/cxd2880-spi.c > > -removed Camel case > > -removed unnecessary initialization at variable declaration > > -removed unnecessary brace {} > > > > Changes in V3 > > drivers/media/spi/cxd2880-spi.c > > -adjusted of indent spaces > > -removed unnecessary cast > > -changed debugging code > > -changed timeout method > > -modified coding style of if() > > -changed hexadecimal code to lower case. > > > > Changes in V2 > > drivers/media/spi/cxd2880-spi.c > > -Modified PID filter setting. > > > > drivers/media/spi/cxd2880-spi.c | 670 > > ++++++++++++++++++++++++++++++++++++++++ > > 1 file changed, 670 insertions(+) > > create mode 100644 drivers/media/spi/cxd2880-spi.c > > > > diff --git a/drivers/media/spi/cxd2880-spi.c > > b/drivers/media/spi/cxd2880-spi.c new file mode 100644 index > > 000000000000..857e4c0d7a92 > > --- /dev/null > > +++ b/drivers/media/spi/cxd2880-spi.c > > @@ -0,0 +1,670 @@ > > +// SPDX-License-Identifier: GPL-2.0 > > +/* > > + * cxd2880-spi.c > > + * Sony CXD2880 DVB-T2/T tuner + demodulator driver > > + * SPI adapter > > + * > > + * Copyright (C) 2016, 2017, 2018 Sony Semiconductor Solutions > > +Corporation */ > > + > > +#define pr_fmt(fmt) KBUILD_MODNAME ": %s: " fmt, __func__ > > + > > +#include <linux/spi/spi.h> > > +#include <linux/ktime.h> > > + > > +#include "dvb_demux.h" > > +#include "dmxdev.h" > > +#include "dvb_frontend.h" > > +#include "cxd2880.h" > > + > > +#define CXD2880_MAX_FILTER_SIZE 32 > > +#define BURST_WRITE_MAX 128 > > +#define MAX_TRANS_PKT 300 > > + > > +struct cxd2880_ts_buf_info { > > + u8 read_ready:1; > > + u8 almost_full:1; > > + u8 almost_empty:1; > > + u8 overflow:1; > > + u8 underflow:1; > > + u16 pkt_num; > > +}; > > + > > +struct cxd2880_pid_config { > > + u8 is_enable; > > + u16 pid; > > +}; > > + > > +struct cxd2880_pid_filter_config { > > + u8 is_negative; > > + struct cxd2880_pid_config pid_config[CXD2880_MAX_FILTER_SIZE]; > > +}; > > + > > +struct cxd2880_dvb_spi { > > + struct dvb_frontend dvb_fe; > > + struct dvb_adapter adapter; > > + struct dvb_demux demux; > > + struct dmxdev dmxdev; > > + struct dmx_frontend dmx_fe; > > + struct task_struct *cxd2880_ts_read_thread; > > + struct spi_device *spi; > > + struct mutex spi_mutex; /* For SPI access exclusive control */ > > + int feed_count; > > + int all_pid_feed_count; > > + u8 *ts_buf; > > + struct cxd2880_pid_filter_config filter_config; }; > > + > > +DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); > > + > > +static int cxd2880_write_spi(struct spi_device *spi, u8 *data, u32 > > +size) { > > + struct spi_message msg; > > + struct spi_transfer tx; > > + > > + if (!spi || !data) { > > + pr_err("invalid arg\n"); > > + return -EINVAL; > > + } > > + > > + memset(&tx, 0, sizeof(tx)); > > Nitpick: > > instead, you could just declare tx as: > > struct spi_transfer tx = {}; > > and get rid of memset (same applies to similar code blocks). > > > > + tx.tx_buf = data; > > + tx.len = size; > > + > > + spi_message_init(&msg); > > + spi_message_add_tail(&tx, &msg); > > + > > + return spi_sync(spi, &msg); > > +} > > + > > +static int cxd2880_write_reg(struct spi_device *spi, > > + u8 sub_address, const u8 *data, u32 size) > { > > + u8 send_data[BURST_WRITE_MAX + 4]; > > + const u8 *write_data_top = NULL; > > + int ret = 0; > > + > > + if (!spi || !data) { > > + pr_err("invalid arg\n"); > > + return -EINVAL; > > + } > > + if (size > BURST_WRITE_MAX) { > > + pr_err("data size > WRITE_MAX\n"); > > + return -EINVAL; > > + } > > + > > + if (sub_address + size > 0x100) { > > + pr_err("out of range\n"); > > + return -EINVAL; > > + } > > It is better to use dev_err(spi->dev, ...) instead of pr_err(). > > > > + > > + send_data[0] = 0x0e; > > + write_data_top = data; > > + > > + while (size > 0) { > > + send_data[1] = sub_address; > > + if (size > 255) > > + send_data[2] = 255; > > + else > > + send_data[2] = (u8)size; > > + > > + memcpy(&send_data[3], write_data_top, send_data[2]); > > + > > + ret = cxd2880_write_spi(spi, send_data, send_data[2] + > 3); > > + if (ret) { > > + pr_err("write spi failed %d\n", ret); > > + break; > > + } > > + sub_address += send_data[2]; > > + write_data_top += send_data[2]; > > + size -= send_data[2]; > > + } > > + > > + return ret; > > +} > > + > > +static int cxd2880_spi_read_ts(struct spi_device *spi, > > + u8 *read_data, > > + u32 packet_num) > > +{ > > + int ret; > > + u8 data[3]; > > + struct spi_message message; > > + struct spi_transfer transfer[2]; > > + > > + if (!spi || !read_data || !packet_num) { > > + pr_err("invalid arg\n"); > > + return -EINVAL; > > + } > > + if (packet_num > 0xffff) { > > + pr_err("packet num > 0xffff\n"); > > + return -EINVAL; > > + } > > + > > + data[0] = 0x10; > > + data[1] = packet_num >> 8; > > + data[2] = packet_num; > > + > > + spi_message_init(&message); > > + memset(transfer, 0, sizeof(transfer)); > > + > > + transfer[0].len = 3; > > + transfer[0].tx_buf = data; > > + spi_message_add_tail(&transfer[0], &message); > > + transfer[1].len = packet_num * 188; > > + transfer[1].rx_buf = read_data; > > + spi_message_add_tail(&transfer[1], &message); > > + > > + ret = spi_sync(spi, &message); > > + if (ret) > > + pr_err("spi_write_then_read failed\n"); > > + > > + return ret; > > +} > > + > > +static int cxd2880_spi_read_ts_buffer_info(struct spi_device *spi, > > + struct cxd2880_ts_buf_info > *info) { > > + u8 send_data = 0x20; > > + u8 recv_data[2]; > > + int ret; > > + > > + if (!spi || !info) { > > + pr_err("invalid arg\n"); > > + return -EINVAL; > > + } > > + > > + ret = spi_write_then_read(spi, &send_data, 1, > > + recv_data, sizeof(recv_data)); > > + if (ret) > > + pr_err("spi_write_then_read failed\n"); > > + > > + info->read_ready = (recv_data[0] & 0x80) ? 1 : 0; > > + info->almost_full = (recv_data[0] & 0x40) ? 1 : 0; > > + info->almost_empty = (recv_data[0] & 0x20) ? 1 : 0; > > + info->overflow = (recv_data[0] & 0x10) ? 1 : 0; > > + info->underflow = (recv_data[0] & 0x08) ? 1 : 0; > > + info->pkt_num = ((recv_data[0] & 0x07) << 8) | recv_data[1]; > > + > > + return ret; > > +} > > + > > +static int cxd2880_spi_clear_ts_buffer(struct spi_device *spi) { > > + u8 data = 0x03; > > + int ret; > > + > > + ret = cxd2880_write_spi(spi, &data, 1); > > + > > + if (ret) > > + pr_err("write spi failed\n"); > > + > > + return ret; > > +} > > + > > +static int cxd2880_set_pid_filter(struct spi_device *spi, > > + struct cxd2880_pid_filter_config > *cfg) { > > + u8 data[65]; > > + int i; > > + u16 pid = 0; > > + int ret; > > + > > + if (!spi) { > > + pr_err("invalid arg\n"); > > + return -EINVAL; > > + } > > + > > + data[0] = 0x00; > > + ret = cxd2880_write_reg(spi, 0x00, &data[0], 1); > > + if (ret) > > + return ret; > > + if (!cfg) { > > + data[0] = 0x02; > > + ret = cxd2880_write_reg(spi, 0x50, &data[0], 1); > > + } else { > > + data[0] = cfg->is_negative ? 0x01 : 0x00; > > + > > + for (i = 0; i < CXD2880_MAX_FILTER_SIZE; i++) { > > + pid = cfg->pid_config[i].pid; > > + if (cfg->pid_config[i].is_enable) { > > + data[1 + (i * 2)] = (pid >> 8) | 0x20; > > + data[2 + (i * 2)] = pid & 0xff; > > + } else { > > + data[1 + (i * 2)] = 0x00; > > + data[2 + (i * 2)] = 0x00; > > + } > > + } > > + ret = cxd2880_write_reg(spi, 0x50, data, 65); > > + } > > + > > + return ret; > > +} > > + > > +static int cxd2880_update_pid_filter(struct cxd2880_dvb_spi > *dvb_spi, > > + struct cxd2880_pid_filter_config > *cfg, > > + bool is_all_pid_filter) > > +{ > > + int ret; > > + > > + if (!dvb_spi || !cfg) { > > + pr_err("invalid arg.\n"); > > + return -EINVAL; > > + } > > + > > + mutex_lock(&dvb_spi->spi_mutex); > > + if (is_all_pid_filter) { > > + struct cxd2880_pid_filter_config tmpcfg; > > + > > + memset(&tmpcfg, 0, sizeof(tmpcfg)); > > + tmpcfg.is_negative = 1; > > + tmpcfg.pid_config[0].is_enable = 1; > > + tmpcfg.pid_config[0].pid = 0x1fff; > > + > > + ret = cxd2880_set_pid_filter(dvb_spi->spi, &tmpcfg); > > + } else { > > + ret = cxd2880_set_pid_filter(dvb_spi->spi, cfg); > > + } > > + mutex_unlock(&dvb_spi->spi_mutex); > > + > > + if (ret) > > + pr_err("set_pid_filter failed\n"); > > + > > + return ret; > > +} > > + > > +static int cxd2880_ts_read(void *arg) { > > + struct cxd2880_dvb_spi *dvb_spi = NULL; > > + struct cxd2880_ts_buf_info info; > > + ktime_t start; > > + u32 i; > > + int ret; > > + > > + dvb_spi = arg; > > + if (!dvb_spi) { > > + pr_err("invalid arg\n"); > > + return -EINVAL; > > + } > > + > > + ret = cxd2880_spi_clear_ts_buffer(dvb_spi->spi); > > + if (ret) { > > + pr_err("set_clear_ts_buffer failed\n"); > > + return ret; > > + } > > + > > + start = ktime_get(); > > + while (!kthread_should_stop()) { > > + ret = cxd2880_spi_read_ts_buffer_info(dvb_spi->spi, > > + &info); > > + if (ret) { > > + pr_err("spi_read_ts_buffer_info error\n"); > > + return ret; > > + } > > + > > + if (info.pkt_num > MAX_TRANS_PKT) { > > + for (i = 0; i < info.pkt_num / MAX_TRANS_PKT; i++) > { > > + cxd2880_spi_read_ts(dvb_spi->spi, > > + dvb_spi->ts_buf, > > + MAX_TRANS_PKT); > > + dvb_dmx_swfilter(&dvb_spi->demux, > > + dvb_spi->ts_buf, > > + MAX_TRANS_PKT * 188); > > + } > > + start = ktime_get(); > > + } else if ((info.pkt_num > 0) && > > + (ktime_to_ms(ktime_sub(ktime_get(), start)) > >= 500)) { > > + cxd2880_spi_read_ts(dvb_spi->spi, > > + dvb_spi->ts_buf, > > + info.pkt_num); > > + dvb_dmx_swfilter(&dvb_spi->demux, > > + dvb_spi->ts_buf, > > + info.pkt_num * 188); > > + start = ktime_get(); > > + } else { > > + usleep_range(10000, 11000); > > + } > > + } > > + > > + return 0; > > +} > > + > > +static int cxd2880_start_feed(struct dvb_demux_feed *feed) { > > + int ret = 0; > > + int i = 0; > > + struct dvb_demux *demux = NULL; > > + struct cxd2880_dvb_spi *dvb_spi = NULL; > > + > > + if (!feed) { > > + pr_err("invalid arg\n"); > > + return -EINVAL; > > + } > > + > > + demux = feed->demux; > > + if (!demux) { > > + pr_err("feed->demux is NULL\n"); > > + return -EINVAL; > > + } > > + dvb_spi = demux->priv; > > + > > + if (dvb_spi->feed_count == CXD2880_MAX_FILTER_SIZE) { > > + pr_err("Exceeded maximum PID count (32)."); > > + pr_err("Selected PID cannot be enabled.\n"); > > + return -EINVAL; > > + } > > + > > + if (feed->pid == 0x2000) { > > + if (dvb_spi->all_pid_feed_count == 0) { > > + ret = cxd2880_update_pid_filter(dvb_spi, > > + > &dvb_spi->filter_config, > > + true); > > + if (ret) { > > + pr_err("update pid filter failed\n"); > > + return ret; > > + } > > + } > > + dvb_spi->all_pid_feed_count++; > > + > > + pr_debug("all PID feed (count = %d)\n", > > + dvb_spi->all_pid_feed_count); > > + } else { > > + struct cxd2880_pid_filter_config cfgtmp; > > + > > + cfgtmp = dvb_spi->filter_config; > > + > > + for (i = 0; i < CXD2880_MAX_FILTER_SIZE; i++) { > > + if (cfgtmp.pid_config[i].is_enable == 0) { > > + cfgtmp.pid_config[i].is_enable = 1; > > + cfgtmp.pid_config[i].pid = feed->pid; > > + pr_debug("store PID %d to #%d\n", > > + feed->pid, i); > > + break; > > + } > > + } > > + if (i == CXD2880_MAX_FILTER_SIZE) { > > + pr_err("PID filter is full. Assumed bug.\n"); > > "Assumed bug"? What do you mean? > > If the hardware filters are full, it is likely an userspace problem, not > a Kernel bug. > > > + return -EINVAL; > > + } > > + if (!dvb_spi->all_pid_feed_count) > > + ret = cxd2880_update_pid_filter(dvb_spi, > > + &cfgtmp, > > + false); > > + if (ret) > > + return ret; > > + > > + dvb_spi->filter_config = cfgtmp; > > + } > > + > > + if (dvb_spi->feed_count == 0) { > > + dvb_spi->ts_buf = > > + kmalloc(MAX_TRANS_PKT * 188, > > + GFP_KERNEL | GFP_DMA); > > > + if (!dvb_spi->ts_buf) { > > + pr_err("ts buffer allocate failed\n"); > > + memset(&dvb_spi->filter_config, 0, > > + sizeof(dvb_spi->filter_config)); > > + dvb_spi->all_pid_feed_count = 0; > > + return -ENOMEM; > > + } > > + dvb_spi->cxd2880_ts_read_thread = > kthread_run(cxd2880_ts_read, > > + dvb_spi, > > + > "cxd2880_ts_read"); > > + if (IS_ERR(dvb_spi->cxd2880_ts_read_thread)) { > > + pr_err("kthread_run failed/\n"); > > + kfree(dvb_spi->ts_buf); > > + dvb_spi->ts_buf = NULL; > > + memset(&dvb_spi->filter_config, 0, > > + sizeof(dvb_spi->filter_config)); > > + dvb_spi->all_pid_feed_count = 0; > > + return > PTR_ERR(dvb_spi->cxd2880_ts_read_thread); > > + } > > + } > > + > > + dvb_spi->feed_count++; > > + > > + pr_debug("start feed (count %d)\n", dvb_spi->feed_count); > > + return 0; > > +} > > + > > +static int cxd2880_stop_feed(struct dvb_demux_feed *feed) { > > + int i = 0; > > + int ret; > > + struct dvb_demux *demux = NULL; > > + struct cxd2880_dvb_spi *dvb_spi = NULL; > > + > > + if (!feed) { > > + pr_err("invalid arg\n"); > > + return -EINVAL; > > + } > > + > > + demux = feed->demux; > > + if (!demux) { > > + pr_err("feed->demux is NULL\n"); > > + return -EINVAL; > > + } > > + dvb_spi = demux->priv; > > + > > + if (!dvb_spi->feed_count) { > > + pr_err("no feed is started\n"); > > + return -EINVAL; > > + } > > + > > + if (feed->pid == 0x2000) { > > + /* > > + * Special PID case. > > + * Number of 0x2000 feed request was stored > > + * in dvb_spi->all_pid_feed_count. > > + */ > > + if (dvb_spi->all_pid_feed_count <= 0) { > > + pr_err("PID %d not found.\n", feed->pid); > > + return -EINVAL; > > + } > > + dvb_spi->all_pid_feed_count--; > > + } else { > > + struct cxd2880_pid_filter_config cfgtmp; > > + > > + cfgtmp = dvb_spi->filter_config; > > + > > + for (i = 0; i < CXD2880_MAX_FILTER_SIZE; i++) { > > + if (feed->pid == cfgtmp.pid_config[i].pid && > > + cfgtmp.pid_config[i].is_enable != 0) { > > + cfgtmp.pid_config[i].is_enable = 0; > > + cfgtmp.pid_config[i].pid = 0; > > + pr_debug("removed PID %d from #%d\n", > > + feed->pid, i); > > + break; > > + } > > + } > > + dvb_spi->filter_config = cfgtmp; > > + > > + if (i == CXD2880_MAX_FILTER_SIZE) { > > + pr_err("PID %d not found\n", feed->pid); > > + return -EINVAL; > > + } > > + } > > + > > + ret = cxd2880_update_pid_filter(dvb_spi, > > + &dvb_spi->filter_config, > > + dvb_spi->all_pid_feed_count > > 0); > > + dvb_spi->feed_count--; > > + > > + if (dvb_spi->feed_count == 0) { > > + int ret_stop = 0; > > + > > + ret_stop = > kthread_stop(dvb_spi->cxd2880_ts_read_thread); > > + if (ret_stop) { > > + pr_err("'kthread_stop failed. (%d)\n", > ret_stop); > > + ret = ret_stop; > > + } > > + kfree(dvb_spi->ts_buf); > > + dvb_spi->ts_buf = NULL; > > + } > > + > > + pr_debug("stop feed ok.(count %d)\n", dvb_spi->feed_count); > > + > > + return ret; > > +} > > + > > +static const struct of_device_id cxd2880_spi_of_match[] = { > > + { .compatible = "sony,cxd2880" }, > > + { /* sentinel */ } > > +}; > > + > > +MODULE_DEVICE_TABLE(of, cxd2880_spi_of_match); > > + > > +static int > > +cxd2880_spi_probe(struct spi_device *spi) { > > + int ret; > > + struct cxd2880_dvb_spi *dvb_spi = NULL; > > + struct cxd2880_config config; > > + > > + if (!spi) { > > + pr_err("invalid arg.\n"); > > + return -EINVAL; > > + } > > + > > + dvb_spi = kzalloc(sizeof(struct cxd2880_dvb_spi), GFP_KERNEL); > > + if (!dvb_spi) > > + return -ENOMEM; > > + > > + dvb_spi->spi = spi; > > + mutex_init(&dvb_spi->spi_mutex); > > + dev_set_drvdata(&spi->dev, dvb_spi); > > + config.spi = spi; > > + config.spi_mutex = &dvb_spi->spi_mutex; > > + > > + ret = dvb_register_adapter(&dvb_spi->adapter, > > + "CXD2880", > > + THIS_MODULE, > > + &spi->dev, > > + adapter_nr); > > + if (ret < 0) { > > + pr_err("dvb_register_adapter() failed\n"); > > + goto fail_adapter; > > + } > > + > > + if (!dvb_attach(cxd2880_attach, &dvb_spi->dvb_fe, &config)) { > > + pr_err("cxd2880_attach failed\n"); > > + goto fail_attach; > > + } > > + > > + ret = dvb_register_frontend(&dvb_spi->adapter, > > + &dvb_spi->dvb_fe); > > + if (ret < 0) { > > + pr_err("dvb_register_frontend() failed\n"); > > + goto fail_frontend; > > + } > > + > > + dvb_spi->demux.dmx.capabilities = DMX_TS_FILTERING; > > + dvb_spi->demux.priv = dvb_spi; > > + dvb_spi->demux.filternum = CXD2880_MAX_FILTER_SIZE; > > + dvb_spi->demux.feednum = CXD2880_MAX_FILTER_SIZE; > > + dvb_spi->demux.start_feed = cxd2880_start_feed; > > + dvb_spi->demux.stop_feed = cxd2880_stop_feed; > > + > > + ret = dvb_dmx_init(&dvb_spi->demux); > > + if (ret < 0) { > > + pr_err("dvb_dmx_init() failed\n"); > > + goto fail_dmx; > > + } > > + > > + dvb_spi->dmxdev.filternum = CXD2880_MAX_FILTER_SIZE; > > + dvb_spi->dmxdev.demux = &dvb_spi->demux.dmx; > > + dvb_spi->dmxdev.capabilities = 0; > > + ret = dvb_dmxdev_init(&dvb_spi->dmxdev, > > + &dvb_spi->adapter); > > + if (ret < 0) { > > + pr_err("dvb_dmxdev_init() failed\n"); > > + goto fail_dmxdev; > > + } > > + > > + dvb_spi->dmx_fe.source = DMX_FRONTEND_0; > > + ret = dvb_spi->demux.dmx.add_frontend(&dvb_spi->demux.dmx, > > + &dvb_spi->dmx_fe); > > + if (ret < 0) { > > + pr_err("add_frontend() failed\n"); > > + goto fail_dmx_fe; > > + } > > + > > + ret = dvb_spi->demux.dmx.connect_frontend(&dvb_spi->demux.dmx, > > + &dvb_spi->dmx_fe); > > + if (ret < 0) { > > + pr_err("dvb_register_frontend() failed\n"); > > + goto fail_fe_conn; > > + } > > + > > + pr_info("Sony CXD2880 has successfully attached.\n"); > > + > > + return 0; > > + > > +fail_fe_conn: > > + dvb_spi->demux.dmx.remove_frontend(&dvb_spi->demux.dmx, > > + &dvb_spi->dmx_fe); > > +fail_dmx_fe: > > + dvb_dmxdev_release(&dvb_spi->dmxdev); > > +fail_dmxdev: > > + dvb_dmx_release(&dvb_spi->demux); > > +fail_dmx: > > + dvb_unregister_frontend(&dvb_spi->dvb_fe); > > +fail_frontend: > > + dvb_frontend_detach(&dvb_spi->dvb_fe); > > +fail_attach: > > + dvb_unregister_adapter(&dvb_spi->adapter); > > +fail_adapter: > > + kfree(dvb_spi); > > + return ret; > > +} > > + > > +static int > > +cxd2880_spi_remove(struct spi_device *spi) { > > + struct cxd2880_dvb_spi *dvb_spi; > > + > > + if (!spi) { > > + pr_err("invalid arg\n"); > > + return -EINVAL; > > + } > > + > > + dvb_spi = dev_get_drvdata(&spi->dev); > > + > > + if (!dvb_spi) { > > + pr_err("failed\n"); > > + return -EINVAL; > > + } > > + dvb_spi->demux.dmx.remove_frontend(&dvb_spi->demux.dmx, > > + &dvb_spi->dmx_fe); > > + dvb_dmxdev_release(&dvb_spi->dmxdev); > > + dvb_dmx_release(&dvb_spi->demux); > > + dvb_unregister_frontend(&dvb_spi->dvb_fe); > > + dvb_frontend_detach(&dvb_spi->dvb_fe); > > + dvb_unregister_adapter(&dvb_spi->adapter); > > + > > + kfree(dvb_spi); > > + pr_info("cxd2880_spi remove ok.\n"); > > + > > + return 0; > > +} > > + > > +static const struct spi_device_id cxd2880_spi_id[] = { > > + { "cxd2880", 0 }, > > + { /* sentinel */ } > > +}; > > +MODULE_DEVICE_TABLE(spi, cxd2880_spi_id); > > + > > +static struct spi_driver cxd2880_spi_driver = { > > + .driver = { > > + .name = "cxd2880", > > + .of_match_table = cxd2880_spi_of_match, > > + }, > > + .id_table = cxd2880_spi_id, > > + .probe = cxd2880_spi_probe, > > + .remove = cxd2880_spi_remove, > > +}; > > +module_spi_driver(cxd2880_spi_driver); > > + > > +MODULE_DESCRIPTION("Sony CXD2880 DVB-T2/T tuner + demod driver SPI > > +adapter"); MODULE_AUTHOR("Sony Semiconductor Solutions > Corporation"); > > +MODULE_LICENSE("GPL v2"); > > > > Thanks, > Mauro
