drivers/media/spi/cxd2880-spi.c

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