Merge branch 'regulator-4.20' into regulator-linus
[sfrench/cifs-2.6.git] / drivers / media / pci / smipcie / smipcie-main.c
1 /*
2  * SMI PCIe driver for DVBSky cards.
3  *
4  * Copyright (C) 2014 Max nibble <nibble.max@gmail.com>
5  *
6  *    This program is free software; you can redistribute it and/or modify
7  *    it under the terms of the GNU General Public License as published by
8  *    the Free Software Foundation; either version 2 of the License, or
9  *    (at your option) any later version.
10  *
11  *    This program is distributed in the hope that it will be useful,
12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *    GNU General Public License for more details.
15  */
16
17 #include "smipcie.h"
18 #include "m88ds3103.h"
19 #include "ts2020.h"
20 #include "m88rs6000t.h"
21 #include "si2168.h"
22 #include "si2157.h"
23
24 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
25
26 static int smi_hw_init(struct smi_dev *dev)
27 {
28         u32 port_mux, port_ctrl, int_stat;
29
30         /* set port mux.*/
31         port_mux = smi_read(MUX_MODE_CTRL);
32         port_mux &= ~(rbPaMSMask);
33         port_mux |= rbPaMSDtvNoGpio;
34         port_mux &= ~(rbPbMSMask);
35         port_mux |= rbPbMSDtvNoGpio;
36         port_mux &= ~(0x0f0000);
37         port_mux |= 0x50000;
38         smi_write(MUX_MODE_CTRL, port_mux);
39
40         /* set DTV register.*/
41         /* Port A */
42         port_ctrl = smi_read(VIDEO_CTRL_STATUS_A);
43         port_ctrl &= ~0x01;
44         smi_write(VIDEO_CTRL_STATUS_A, port_ctrl);
45         port_ctrl = smi_read(MPEG2_CTRL_A);
46         port_ctrl &= ~0x40;
47         port_ctrl |= 0x80;
48         smi_write(MPEG2_CTRL_A, port_ctrl);
49         /* Port B */
50         port_ctrl = smi_read(VIDEO_CTRL_STATUS_B);
51         port_ctrl &= ~0x01;
52         smi_write(VIDEO_CTRL_STATUS_B, port_ctrl);
53         port_ctrl = smi_read(MPEG2_CTRL_B);
54         port_ctrl &= ~0x40;
55         port_ctrl |= 0x80;
56         smi_write(MPEG2_CTRL_B, port_ctrl);
57
58         /* disable and clear interrupt.*/
59         smi_write(MSI_INT_ENA_CLR, ALL_INT);
60         int_stat = smi_read(MSI_INT_STATUS);
61         smi_write(MSI_INT_STATUS_CLR, int_stat);
62
63         /* reset demod.*/
64         smi_clear(PERIPHERAL_CTRL, 0x0303);
65         msleep(50);
66         smi_set(PERIPHERAL_CTRL, 0x0101);
67         return 0;
68 }
69
70 /* i2c bit bus.*/
71 static void smi_i2c_cfg(struct smi_dev *dev, u32 sw_ctl)
72 {
73         u32 dwCtrl;
74
75         dwCtrl = smi_read(sw_ctl);
76         dwCtrl &= ~0x18; /* disable output.*/
77         dwCtrl |= 0x21; /* reset and software mode.*/
78         dwCtrl &= ~0xff00;
79         dwCtrl |= 0x6400;
80         smi_write(sw_ctl, dwCtrl);
81         msleep(20);
82         dwCtrl = smi_read(sw_ctl);
83         dwCtrl &= ~0x20;
84         smi_write(sw_ctl, dwCtrl);
85 }
86
87 static void smi_i2c_setsda(struct smi_dev *dev, int state, u32 sw_ctl)
88 {
89         if (state) {
90                 /* set as input.*/
91                 smi_clear(sw_ctl, SW_I2C_MSK_DAT_EN);
92         } else {
93                 smi_clear(sw_ctl, SW_I2C_MSK_DAT_OUT);
94                 /* set as output.*/
95                 smi_set(sw_ctl, SW_I2C_MSK_DAT_EN);
96         }
97 }
98
99 static void smi_i2c_setscl(void *data, int state, u32 sw_ctl)
100 {
101         struct smi_dev *dev = data;
102
103         if (state) {
104                 /* set as input.*/
105                 smi_clear(sw_ctl, SW_I2C_MSK_CLK_EN);
106         } else {
107                 smi_clear(sw_ctl, SW_I2C_MSK_CLK_OUT);
108                 /* set as output.*/
109                 smi_set(sw_ctl, SW_I2C_MSK_CLK_EN);
110         }
111 }
112
113 static int smi_i2c_getsda(void *data, u32 sw_ctl)
114 {
115         struct smi_dev *dev = data;
116         /* set as input.*/
117         smi_clear(sw_ctl, SW_I2C_MSK_DAT_EN);
118         udelay(1);
119         return (smi_read(sw_ctl) & SW_I2C_MSK_DAT_IN) ? 1 : 0;
120 }
121
122 static int smi_i2c_getscl(void *data, u32 sw_ctl)
123 {
124         struct smi_dev *dev = data;
125         /* set as input.*/
126         smi_clear(sw_ctl, SW_I2C_MSK_CLK_EN);
127         udelay(1);
128         return (smi_read(sw_ctl) & SW_I2C_MSK_CLK_IN) ? 1 : 0;
129 }
130 /* i2c 0.*/
131 static void smi_i2c0_setsda(void *data, int state)
132 {
133         struct smi_dev *dev = data;
134
135         smi_i2c_setsda(dev, state, I2C_A_SW_CTL);
136 }
137
138 static void smi_i2c0_setscl(void *data, int state)
139 {
140         struct smi_dev *dev = data;
141
142         smi_i2c_setscl(dev, state, I2C_A_SW_CTL);
143 }
144
145 static int smi_i2c0_getsda(void *data)
146 {
147         struct smi_dev *dev = data;
148
149         return  smi_i2c_getsda(dev, I2C_A_SW_CTL);
150 }
151
152 static int smi_i2c0_getscl(void *data)
153 {
154         struct smi_dev *dev = data;
155
156         return  smi_i2c_getscl(dev, I2C_A_SW_CTL);
157 }
158 /* i2c 1.*/
159 static void smi_i2c1_setsda(void *data, int state)
160 {
161         struct smi_dev *dev = data;
162
163         smi_i2c_setsda(dev, state, I2C_B_SW_CTL);
164 }
165
166 static void smi_i2c1_setscl(void *data, int state)
167 {
168         struct smi_dev *dev = data;
169
170         smi_i2c_setscl(dev, state, I2C_B_SW_CTL);
171 }
172
173 static int smi_i2c1_getsda(void *data)
174 {
175         struct smi_dev *dev = data;
176
177         return  smi_i2c_getsda(dev, I2C_B_SW_CTL);
178 }
179
180 static int smi_i2c1_getscl(void *data)
181 {
182         struct smi_dev *dev = data;
183
184         return  smi_i2c_getscl(dev, I2C_B_SW_CTL);
185 }
186
187 static int smi_i2c_init(struct smi_dev *dev)
188 {
189         int ret;
190
191         /* i2c bus 0 */
192         smi_i2c_cfg(dev, I2C_A_SW_CTL);
193         i2c_set_adapdata(&dev->i2c_bus[0], dev);
194         strscpy(dev->i2c_bus[0].name, "SMI-I2C0", sizeof(dev->i2c_bus[0].name));
195         dev->i2c_bus[0].owner = THIS_MODULE;
196         dev->i2c_bus[0].dev.parent = &dev->pci_dev->dev;
197         dev->i2c_bus[0].algo_data = &dev->i2c_bit[0];
198         dev->i2c_bit[0].data = dev;
199         dev->i2c_bit[0].setsda = smi_i2c0_setsda;
200         dev->i2c_bit[0].setscl = smi_i2c0_setscl;
201         dev->i2c_bit[0].getsda = smi_i2c0_getsda;
202         dev->i2c_bit[0].getscl = smi_i2c0_getscl;
203         dev->i2c_bit[0].udelay = 12;
204         dev->i2c_bit[0].timeout = 10;
205         /* Raise SCL and SDA */
206         smi_i2c0_setsda(dev, 1);
207         smi_i2c0_setscl(dev, 1);
208
209         ret = i2c_bit_add_bus(&dev->i2c_bus[0]);
210         if (ret < 0)
211                 return ret;
212
213         /* i2c bus 1 */
214         smi_i2c_cfg(dev, I2C_B_SW_CTL);
215         i2c_set_adapdata(&dev->i2c_bus[1], dev);
216         strscpy(dev->i2c_bus[1].name, "SMI-I2C1", sizeof(dev->i2c_bus[1].name));
217         dev->i2c_bus[1].owner = THIS_MODULE;
218         dev->i2c_bus[1].dev.parent = &dev->pci_dev->dev;
219         dev->i2c_bus[1].algo_data = &dev->i2c_bit[1];
220         dev->i2c_bit[1].data = dev;
221         dev->i2c_bit[1].setsda = smi_i2c1_setsda;
222         dev->i2c_bit[1].setscl = smi_i2c1_setscl;
223         dev->i2c_bit[1].getsda = smi_i2c1_getsda;
224         dev->i2c_bit[1].getscl = smi_i2c1_getscl;
225         dev->i2c_bit[1].udelay = 12;
226         dev->i2c_bit[1].timeout = 10;
227         /* Raise SCL and SDA */
228         smi_i2c1_setsda(dev, 1);
229         smi_i2c1_setscl(dev, 1);
230
231         ret = i2c_bit_add_bus(&dev->i2c_bus[1]);
232         if (ret < 0)
233                 i2c_del_adapter(&dev->i2c_bus[0]);
234
235         return ret;
236 }
237
238 static void smi_i2c_exit(struct smi_dev *dev)
239 {
240         i2c_del_adapter(&dev->i2c_bus[0]);
241         i2c_del_adapter(&dev->i2c_bus[1]);
242 }
243
244 static int smi_read_eeprom(struct i2c_adapter *i2c, u16 reg, u8 *data, u16 size)
245 {
246         int ret;
247         u8 b0[2] = { (reg >> 8) & 0xff, reg & 0xff };
248
249         struct i2c_msg msg[] = {
250                 { .addr = 0x50, .flags = 0,
251                         .buf = b0, .len = 2 },
252                 { .addr = 0x50, .flags = I2C_M_RD,
253                         .buf = data, .len = size }
254         };
255
256         ret = i2c_transfer(i2c, msg, 2);
257
258         if (ret != 2) {
259                 dev_err(&i2c->dev, "%s: reg=0x%x (error=%d)\n",
260                         __func__, reg, ret);
261                 return ret;
262         }
263         return ret;
264 }
265
266 /* ts port interrupt operations */
267 static void smi_port_disableInterrupt(struct smi_port *port)
268 {
269         struct smi_dev *dev = port->dev;
270
271         smi_write(MSI_INT_ENA_CLR,
272                 (port->_dmaInterruptCH0 | port->_dmaInterruptCH1));
273 }
274
275 static void smi_port_enableInterrupt(struct smi_port *port)
276 {
277         struct smi_dev *dev = port->dev;
278
279         smi_write(MSI_INT_ENA_SET,
280                 (port->_dmaInterruptCH0 | port->_dmaInterruptCH1));
281 }
282
283 static void smi_port_clearInterrupt(struct smi_port *port)
284 {
285         struct smi_dev *dev = port->dev;
286
287         smi_write(MSI_INT_STATUS_CLR,
288                 (port->_dmaInterruptCH0 | port->_dmaInterruptCH1));
289 }
290
291 /* tasklet handler: DMA data to dmx.*/
292 static void smi_dma_xfer(unsigned long data)
293 {
294         struct smi_port *port = (struct smi_port *) data;
295         struct smi_dev *dev = port->dev;
296         u32 intr_status, finishedData, dmaManagement;
297         u8 dmaChan0State, dmaChan1State;
298
299         intr_status = port->_int_status;
300         dmaManagement = smi_read(port->DMA_MANAGEMENT);
301         dmaChan0State = (u8)((dmaManagement & 0x00000030) >> 4);
302         dmaChan1State = (u8)((dmaManagement & 0x00300000) >> 20);
303
304         /* CH-0 DMA interrupt.*/
305         if ((intr_status & port->_dmaInterruptCH0) && (dmaChan0State == 0x01)) {
306                 dev_dbg(&dev->pci_dev->dev,
307                         "Port[%d]-DMA CH0 engine complete successful !\n",
308                         port->idx);
309                 finishedData = smi_read(port->DMA_CHAN0_TRANS_STATE);
310                 finishedData &= 0x003FFFFF;
311                 /* value of DMA_PORT0_CHAN0_TRANS_STATE register [21:0]
312                  * indicate dma total transfer length and
313                  * zero of [21:0] indicate dma total transfer length
314                  * equal to 0x400000 (4MB)*/
315                 if (finishedData == 0)
316                         finishedData = 0x00400000;
317                 if (finishedData != SMI_TS_DMA_BUF_SIZE) {
318                         dev_dbg(&dev->pci_dev->dev,
319                                 "DMA CH0 engine complete length mismatched, finish data=%d !\n",
320                                 finishedData);
321                 }
322                 dvb_dmx_swfilter_packets(&port->demux,
323                         port->cpu_addr[0], (finishedData / 188));
324                 /*dvb_dmx_swfilter(&port->demux,
325                         port->cpu_addr[0], finishedData);*/
326         }
327         /* CH-1 DMA interrupt.*/
328         if ((intr_status & port->_dmaInterruptCH1) && (dmaChan1State == 0x01)) {
329                 dev_dbg(&dev->pci_dev->dev,
330                         "Port[%d]-DMA CH1 engine complete successful !\n",
331                         port->idx);
332                 finishedData = smi_read(port->DMA_CHAN1_TRANS_STATE);
333                 finishedData &= 0x003FFFFF;
334                 /* value of DMA_PORT0_CHAN0_TRANS_STATE register [21:0]
335                  * indicate dma total transfer length and
336                  * zero of [21:0] indicate dma total transfer length
337                  * equal to 0x400000 (4MB)*/
338                 if (finishedData == 0)
339                         finishedData = 0x00400000;
340                 if (finishedData != SMI_TS_DMA_BUF_SIZE) {
341                         dev_dbg(&dev->pci_dev->dev,
342                                 "DMA CH1 engine complete length mismatched, finish data=%d !\n",
343                                 finishedData);
344                 }
345                 dvb_dmx_swfilter_packets(&port->demux,
346                         port->cpu_addr[1], (finishedData / 188));
347                 /*dvb_dmx_swfilter(&port->demux,
348                         port->cpu_addr[1], finishedData);*/
349         }
350         /* restart DMA.*/
351         if (intr_status & port->_dmaInterruptCH0)
352                 dmaManagement |= 0x00000002;
353         if (intr_status & port->_dmaInterruptCH1)
354                 dmaManagement |= 0x00020000;
355         smi_write(port->DMA_MANAGEMENT, dmaManagement);
356         /* Re-enable interrupts */
357         smi_port_enableInterrupt(port);
358 }
359
360 static void smi_port_dma_free(struct smi_port *port)
361 {
362         if (port->cpu_addr[0]) {
363                 pci_free_consistent(port->dev->pci_dev, SMI_TS_DMA_BUF_SIZE,
364                                     port->cpu_addr[0], port->dma_addr[0]);
365                 port->cpu_addr[0] = NULL;
366         }
367         if (port->cpu_addr[1]) {
368                 pci_free_consistent(port->dev->pci_dev, SMI_TS_DMA_BUF_SIZE,
369                                     port->cpu_addr[1], port->dma_addr[1]);
370                 port->cpu_addr[1] = NULL;
371         }
372 }
373
374 static int smi_port_init(struct smi_port *port, int dmaChanUsed)
375 {
376         dev_dbg(&port->dev->pci_dev->dev,
377                 "%s, port %d, dmaused %d\n", __func__, port->idx, dmaChanUsed);
378         port->enable = 0;
379         if (port->idx == 0) {
380                 /* Port A */
381                 port->_dmaInterruptCH0 = dmaChanUsed & 0x01;
382                 port->_dmaInterruptCH1 = dmaChanUsed & 0x02;
383
384                 port->DMA_CHAN0_ADDR_LOW        = DMA_PORTA_CHAN0_ADDR_LOW;
385                 port->DMA_CHAN0_ADDR_HI         = DMA_PORTA_CHAN0_ADDR_HI;
386                 port->DMA_CHAN0_TRANS_STATE     = DMA_PORTA_CHAN0_TRANS_STATE;
387                 port->DMA_CHAN0_CONTROL         = DMA_PORTA_CHAN0_CONTROL;
388                 port->DMA_CHAN1_ADDR_LOW        = DMA_PORTA_CHAN1_ADDR_LOW;
389                 port->DMA_CHAN1_ADDR_HI         = DMA_PORTA_CHAN1_ADDR_HI;
390                 port->DMA_CHAN1_TRANS_STATE     = DMA_PORTA_CHAN1_TRANS_STATE;
391                 port->DMA_CHAN1_CONTROL         = DMA_PORTA_CHAN1_CONTROL;
392                 port->DMA_MANAGEMENT            = DMA_PORTA_MANAGEMENT;
393         } else {
394                 /* Port B */
395                 port->_dmaInterruptCH0 = (dmaChanUsed << 2) & 0x04;
396                 port->_dmaInterruptCH1 = (dmaChanUsed << 2) & 0x08;
397
398                 port->DMA_CHAN0_ADDR_LOW        = DMA_PORTB_CHAN0_ADDR_LOW;
399                 port->DMA_CHAN0_ADDR_HI         = DMA_PORTB_CHAN0_ADDR_HI;
400                 port->DMA_CHAN0_TRANS_STATE     = DMA_PORTB_CHAN0_TRANS_STATE;
401                 port->DMA_CHAN0_CONTROL         = DMA_PORTB_CHAN0_CONTROL;
402                 port->DMA_CHAN1_ADDR_LOW        = DMA_PORTB_CHAN1_ADDR_LOW;
403                 port->DMA_CHAN1_ADDR_HI         = DMA_PORTB_CHAN1_ADDR_HI;
404                 port->DMA_CHAN1_TRANS_STATE     = DMA_PORTB_CHAN1_TRANS_STATE;
405                 port->DMA_CHAN1_CONTROL         = DMA_PORTB_CHAN1_CONTROL;
406                 port->DMA_MANAGEMENT            = DMA_PORTB_MANAGEMENT;
407         }
408
409         if (port->_dmaInterruptCH0) {
410                 port->cpu_addr[0] = pci_alloc_consistent(port->dev->pci_dev,
411                                         SMI_TS_DMA_BUF_SIZE,
412                                         &port->dma_addr[0]);
413                 if (!port->cpu_addr[0]) {
414                         dev_err(&port->dev->pci_dev->dev,
415                                 "Port[%d] DMA CH0 memory allocation failed!\n",
416                                 port->idx);
417                         goto err;
418                 }
419         }
420
421         if (port->_dmaInterruptCH1) {
422                 port->cpu_addr[1] = pci_alloc_consistent(port->dev->pci_dev,
423                                         SMI_TS_DMA_BUF_SIZE,
424                                         &port->dma_addr[1]);
425                 if (!port->cpu_addr[1]) {
426                         dev_err(&port->dev->pci_dev->dev,
427                                 "Port[%d] DMA CH1 memory allocation failed!\n",
428                                 port->idx);
429                         goto err;
430                 }
431         }
432
433         smi_port_disableInterrupt(port);
434         tasklet_init(&port->tasklet, smi_dma_xfer, (unsigned long)port);
435         tasklet_disable(&port->tasklet);
436         port->enable = 1;
437         return 0;
438 err:
439         smi_port_dma_free(port);
440         return -ENOMEM;
441 }
442
443 static void smi_port_exit(struct smi_port *port)
444 {
445         smi_port_disableInterrupt(port);
446         tasklet_kill(&port->tasklet);
447         smi_port_dma_free(port);
448         port->enable = 0;
449 }
450
451 static int smi_port_irq(struct smi_port *port, u32 int_status)
452 {
453         u32 port_req_irq = port->_dmaInterruptCH0 | port->_dmaInterruptCH1;
454         int handled = 0;
455
456         if (int_status & port_req_irq) {
457                 smi_port_disableInterrupt(port);
458                 port->_int_status = int_status;
459                 smi_port_clearInterrupt(port);
460                 tasklet_schedule(&port->tasklet);
461                 handled = 1;
462         }
463         return handled;
464 }
465
466 static irqreturn_t smi_irq_handler(int irq, void *dev_id)
467 {
468         struct smi_dev *dev = dev_id;
469         struct smi_port *port0 = &dev->ts_port[0];
470         struct smi_port *port1 = &dev->ts_port[1];
471         struct smi_rc *ir = &dev->ir;
472         int handled = 0;
473
474         u32 intr_status = smi_read(MSI_INT_STATUS);
475
476         /* ts0 interrupt.*/
477         if (dev->info->ts_0)
478                 handled += smi_port_irq(port0, intr_status);
479
480         /* ts1 interrupt.*/
481         if (dev->info->ts_1)
482                 handled += smi_port_irq(port1, intr_status);
483
484         /* ir interrupt.*/
485         handled += smi_ir_irq(ir, intr_status);
486
487         return IRQ_RETVAL(handled);
488 }
489
490 static struct i2c_client *smi_add_i2c_client(struct i2c_adapter *adapter,
491                         struct i2c_board_info *info)
492 {
493         struct i2c_client *client;
494
495         request_module(info->type);
496         client = i2c_new_device(adapter, info);
497         if (client == NULL || client->dev.driver == NULL)
498                 goto err_add_i2c_client;
499
500         if (!try_module_get(client->dev.driver->owner)) {
501                 i2c_unregister_device(client);
502                 goto err_add_i2c_client;
503         }
504         return client;
505
506 err_add_i2c_client:
507         client = NULL;
508         return client;
509 }
510
511 static void smi_del_i2c_client(struct i2c_client *client)
512 {
513         module_put(client->dev.driver->owner);
514         i2c_unregister_device(client);
515 }
516
517 static const struct m88ds3103_config smi_dvbsky_m88ds3103_cfg = {
518         .i2c_addr = 0x68,
519         .clock = 27000000,
520         .i2c_wr_max = 33,
521         .clock_out = 0,
522         .ts_mode = M88DS3103_TS_PARALLEL,
523         .ts_clk = 16000,
524         .ts_clk_pol = 1,
525         .agc = 0x99,
526         .lnb_hv_pol = 0,
527         .lnb_en_pol = 1,
528 };
529
530 static int smi_dvbsky_m88ds3103_fe_attach(struct smi_port *port)
531 {
532         int ret = 0;
533         struct smi_dev *dev = port->dev;
534         struct i2c_adapter *i2c;
535         /* tuner I2C module */
536         struct i2c_adapter *tuner_i2c_adapter;
537         struct i2c_client *tuner_client;
538         struct i2c_board_info tuner_info;
539         struct ts2020_config ts2020_config = {};
540         memset(&tuner_info, 0, sizeof(struct i2c_board_info));
541         i2c = (port->idx == 0) ? &dev->i2c_bus[0] : &dev->i2c_bus[1];
542
543         /* attach demod */
544         port->fe = dvb_attach(m88ds3103_attach,
545                         &smi_dvbsky_m88ds3103_cfg, i2c, &tuner_i2c_adapter);
546         if (!port->fe) {
547                 ret = -ENODEV;
548                 return ret;
549         }
550         /* attach tuner */
551         ts2020_config.fe = port->fe;
552         strscpy(tuner_info.type, "ts2020", I2C_NAME_SIZE);
553         tuner_info.addr = 0x60;
554         tuner_info.platform_data = &ts2020_config;
555         tuner_client = smi_add_i2c_client(tuner_i2c_adapter, &tuner_info);
556         if (!tuner_client) {
557                 ret = -ENODEV;
558                 goto err_tuner_i2c_device;
559         }
560
561         /* delegate signal strength measurement to tuner */
562         port->fe->ops.read_signal_strength =
563                         port->fe->ops.tuner_ops.get_rf_strength;
564
565         port->i2c_client_tuner = tuner_client;
566         return ret;
567
568 err_tuner_i2c_device:
569         dvb_frontend_detach(port->fe);
570         return ret;
571 }
572
573 static const struct m88ds3103_config smi_dvbsky_m88rs6000_cfg = {
574         .i2c_addr = 0x69,
575         .clock = 27000000,
576         .i2c_wr_max = 33,
577         .ts_mode = M88DS3103_TS_PARALLEL,
578         .ts_clk = 16000,
579         .ts_clk_pol = 1,
580         .agc = 0x99,
581         .lnb_hv_pol = 0,
582         .lnb_en_pol = 1,
583 };
584
585 static int smi_dvbsky_m88rs6000_fe_attach(struct smi_port *port)
586 {
587         int ret = 0;
588         struct smi_dev *dev = port->dev;
589         struct i2c_adapter *i2c;
590         /* tuner I2C module */
591         struct i2c_adapter *tuner_i2c_adapter;
592         struct i2c_client *tuner_client;
593         struct i2c_board_info tuner_info;
594         struct m88rs6000t_config m88rs6000t_config;
595
596         memset(&tuner_info, 0, sizeof(struct i2c_board_info));
597         i2c = (port->idx == 0) ? &dev->i2c_bus[0] : &dev->i2c_bus[1];
598
599         /* attach demod */
600         port->fe = dvb_attach(m88ds3103_attach,
601                         &smi_dvbsky_m88rs6000_cfg, i2c, &tuner_i2c_adapter);
602         if (!port->fe) {
603                 ret = -ENODEV;
604                 return ret;
605         }
606         /* attach tuner */
607         m88rs6000t_config.fe = port->fe;
608         strscpy(tuner_info.type, "m88rs6000t", I2C_NAME_SIZE);
609         tuner_info.addr = 0x21;
610         tuner_info.platform_data = &m88rs6000t_config;
611         tuner_client = smi_add_i2c_client(tuner_i2c_adapter, &tuner_info);
612         if (!tuner_client) {
613                 ret = -ENODEV;
614                 goto err_tuner_i2c_device;
615         }
616
617         /* delegate signal strength measurement to tuner */
618         port->fe->ops.read_signal_strength =
619                         port->fe->ops.tuner_ops.get_rf_strength;
620
621         port->i2c_client_tuner = tuner_client;
622         return ret;
623
624 err_tuner_i2c_device:
625         dvb_frontend_detach(port->fe);
626         return ret;
627 }
628
629 static int smi_dvbsky_sit2_fe_attach(struct smi_port *port)
630 {
631         int ret = 0;
632         struct smi_dev *dev = port->dev;
633         struct i2c_adapter *i2c;
634         struct i2c_adapter *tuner_i2c_adapter;
635         struct i2c_client *client_tuner, *client_demod;
636         struct i2c_board_info client_info;
637         struct si2168_config si2168_config;
638         struct si2157_config si2157_config;
639
640         /* select i2c bus */
641         i2c = (port->idx == 0) ? &dev->i2c_bus[0] : &dev->i2c_bus[1];
642
643         /* attach demod */
644         memset(&si2168_config, 0, sizeof(si2168_config));
645         si2168_config.i2c_adapter = &tuner_i2c_adapter;
646         si2168_config.fe = &port->fe;
647         si2168_config.ts_mode = SI2168_TS_PARALLEL;
648
649         memset(&client_info, 0, sizeof(struct i2c_board_info));
650         strscpy(client_info.type, "si2168", I2C_NAME_SIZE);
651         client_info.addr = 0x64;
652         client_info.platform_data = &si2168_config;
653
654         client_demod = smi_add_i2c_client(i2c, &client_info);
655         if (!client_demod) {
656                 ret = -ENODEV;
657                 return ret;
658         }
659         port->i2c_client_demod = client_demod;
660
661         /* attach tuner */
662         memset(&si2157_config, 0, sizeof(si2157_config));
663         si2157_config.fe = port->fe;
664         si2157_config.if_port = 1;
665
666         memset(&client_info, 0, sizeof(struct i2c_board_info));
667         strscpy(client_info.type, "si2157", I2C_NAME_SIZE);
668         client_info.addr = 0x60;
669         client_info.platform_data = &si2157_config;
670
671         client_tuner = smi_add_i2c_client(tuner_i2c_adapter, &client_info);
672         if (!client_tuner) {
673                 smi_del_i2c_client(port->i2c_client_demod);
674                 port->i2c_client_demod = NULL;
675                 ret = -ENODEV;
676                 return ret;
677         }
678         port->i2c_client_tuner = client_tuner;
679         return ret;
680 }
681
682 static int smi_fe_init(struct smi_port *port)
683 {
684         int ret = 0;
685         struct smi_dev *dev = port->dev;
686         struct dvb_adapter *adap = &port->dvb_adapter;
687         u8 mac_ee[16];
688
689         dev_dbg(&port->dev->pci_dev->dev,
690                 "%s: port %d, fe_type = %d\n",
691                 __func__, port->idx, port->fe_type);
692         switch (port->fe_type) {
693         case DVBSKY_FE_M88DS3103:
694                 ret = smi_dvbsky_m88ds3103_fe_attach(port);
695                 break;
696         case DVBSKY_FE_M88RS6000:
697                 ret = smi_dvbsky_m88rs6000_fe_attach(port);
698                 break;
699         case DVBSKY_FE_SIT2:
700                 ret = smi_dvbsky_sit2_fe_attach(port);
701                 break;
702         }
703         if (ret < 0)
704                 return ret;
705
706         /* register dvb frontend */
707         ret = dvb_register_frontend(adap, port->fe);
708         if (ret < 0) {
709                 if (port->i2c_client_tuner)
710                         smi_del_i2c_client(port->i2c_client_tuner);
711                 if (port->i2c_client_demod)
712                         smi_del_i2c_client(port->i2c_client_demod);
713                 dvb_frontend_detach(port->fe);
714                 return ret;
715         }
716         /* init MAC.*/
717         ret = smi_read_eeprom(&dev->i2c_bus[0], 0xc0, mac_ee, 16);
718         dev_info(&port->dev->pci_dev->dev,
719                 "%s port %d MAC: %pM\n", dev->info->name,
720                 port->idx, mac_ee + (port->idx)*8);
721         memcpy(adap->proposed_mac, mac_ee + (port->idx)*8, 6);
722         return ret;
723 }
724
725 static void smi_fe_exit(struct smi_port *port)
726 {
727         dvb_unregister_frontend(port->fe);
728         /* remove I2C demod and tuner */
729         if (port->i2c_client_tuner)
730                 smi_del_i2c_client(port->i2c_client_tuner);
731         if (port->i2c_client_demod)
732                 smi_del_i2c_client(port->i2c_client_demod);
733         dvb_frontend_detach(port->fe);
734 }
735
736 static int my_dvb_dmx_ts_card_init(struct dvb_demux *dvbdemux, char *id,
737                             int (*start_feed)(struct dvb_demux_feed *),
738                             int (*stop_feed)(struct dvb_demux_feed *),
739                             void *priv)
740 {
741         dvbdemux->priv = priv;
742
743         dvbdemux->filternum = 256;
744         dvbdemux->feednum = 256;
745         dvbdemux->start_feed = start_feed;
746         dvbdemux->stop_feed = stop_feed;
747         dvbdemux->write_to_decoder = NULL;
748         dvbdemux->dmx.capabilities = (DMX_TS_FILTERING |
749                                       DMX_SECTION_FILTERING |
750                                       DMX_MEMORY_BASED_FILTERING);
751         return dvb_dmx_init(dvbdemux);
752 }
753
754 static int my_dvb_dmxdev_ts_card_init(struct dmxdev *dmxdev,
755                                struct dvb_demux *dvbdemux,
756                                struct dmx_frontend *hw_frontend,
757                                struct dmx_frontend *mem_frontend,
758                                struct dvb_adapter *dvb_adapter)
759 {
760         int ret;
761
762         dmxdev->filternum = 256;
763         dmxdev->demux = &dvbdemux->dmx;
764         dmxdev->capabilities = 0;
765         ret = dvb_dmxdev_init(dmxdev, dvb_adapter);
766         if (ret < 0)
767                 return ret;
768
769         hw_frontend->source = DMX_FRONTEND_0;
770         dvbdemux->dmx.add_frontend(&dvbdemux->dmx, hw_frontend);
771         mem_frontend->source = DMX_MEMORY_FE;
772         dvbdemux->dmx.add_frontend(&dvbdemux->dmx, mem_frontend);
773         return dvbdemux->dmx.connect_frontend(&dvbdemux->dmx, hw_frontend);
774 }
775
776 static u32 smi_config_DMA(struct smi_port *port)
777 {
778         struct smi_dev *dev = port->dev;
779         u32 totalLength = 0, dmaMemPtrLow, dmaMemPtrHi, dmaCtlReg;
780         u8 chanLatencyTimer = 0, dmaChanEnable = 1, dmaTransStart = 1;
781         u32 dmaManagement = 0, tlpTransUnit = DMA_TRANS_UNIT_188;
782         u8 tlpTc = 0, tlpTd = 1, tlpEp = 0, tlpAttr = 0;
783         u64 mem;
784
785         dmaManagement = smi_read(port->DMA_MANAGEMENT);
786         /* Setup Channel-0 */
787         if (port->_dmaInterruptCH0) {
788                 totalLength = SMI_TS_DMA_BUF_SIZE;
789                 mem = port->dma_addr[0];
790                 dmaMemPtrLow = mem & 0xffffffff;
791                 dmaMemPtrHi = mem >> 32;
792                 dmaCtlReg = (totalLength) | (tlpTransUnit << 22) | (tlpTc << 25)
793                         | (tlpTd << 28) | (tlpEp << 29) | (tlpAttr << 30);
794                 dmaManagement |= dmaChanEnable | (dmaTransStart << 1)
795                         | (chanLatencyTimer << 8);
796                 /* write DMA register, start DMA engine */
797                 smi_write(port->DMA_CHAN0_ADDR_LOW, dmaMemPtrLow);
798                 smi_write(port->DMA_CHAN0_ADDR_HI, dmaMemPtrHi);
799                 smi_write(port->DMA_CHAN0_CONTROL, dmaCtlReg);
800         }
801         /* Setup Channel-1 */
802         if (port->_dmaInterruptCH1) {
803                 totalLength = SMI_TS_DMA_BUF_SIZE;
804                 mem = port->dma_addr[1];
805                 dmaMemPtrLow = mem & 0xffffffff;
806                 dmaMemPtrHi = mem >> 32;
807                 dmaCtlReg = (totalLength) | (tlpTransUnit << 22) | (tlpTc << 25)
808                         | (tlpTd << 28) | (tlpEp << 29) | (tlpAttr << 30);
809                 dmaManagement |= (dmaChanEnable << 16) | (dmaTransStart << 17)
810                         | (chanLatencyTimer << 24);
811                 /* write DMA register, start DMA engine */
812                 smi_write(port->DMA_CHAN1_ADDR_LOW, dmaMemPtrLow);
813                 smi_write(port->DMA_CHAN1_ADDR_HI, dmaMemPtrHi);
814                 smi_write(port->DMA_CHAN1_CONTROL, dmaCtlReg);
815         }
816         return dmaManagement;
817 }
818
819 static int smi_start_feed(struct dvb_demux_feed *dvbdmxfeed)
820 {
821         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
822         struct smi_port *port = dvbdmx->priv;
823         struct smi_dev *dev = port->dev;
824         u32 dmaManagement;
825
826         if (port->users++ == 0) {
827                 dmaManagement = smi_config_DMA(port);
828                 smi_port_clearInterrupt(port);
829                 smi_port_enableInterrupt(port);
830                 smi_write(port->DMA_MANAGEMENT, dmaManagement);
831                 tasklet_enable(&port->tasklet);
832         }
833         return port->users;
834 }
835
836 static int smi_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
837 {
838         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
839         struct smi_port *port = dvbdmx->priv;
840         struct smi_dev *dev = port->dev;
841
842         if (--port->users)
843                 return port->users;
844
845         tasklet_disable(&port->tasklet);
846         smi_port_disableInterrupt(port);
847         smi_clear(port->DMA_MANAGEMENT, 0x30003);
848         return 0;
849 }
850
851 static int smi_dvb_init(struct smi_port *port)
852 {
853         int ret;
854         struct dvb_adapter *adap = &port->dvb_adapter;
855         struct dvb_demux *dvbdemux = &port->demux;
856
857         dev_dbg(&port->dev->pci_dev->dev,
858                 "%s, port %d\n", __func__, port->idx);
859
860         ret = dvb_register_adapter(adap, "SMI_DVB", THIS_MODULE,
861                                    &port->dev->pci_dev->dev,
862                                    adapter_nr);
863         if (ret < 0) {
864                 dev_err(&port->dev->pci_dev->dev, "Fail to register DVB adapter.\n");
865                 return ret;
866         }
867         ret = my_dvb_dmx_ts_card_init(dvbdemux, "SW demux",
868                                       smi_start_feed,
869                                       smi_stop_feed, port);
870         if (ret < 0)
871                 goto err_del_dvb_register_adapter;
872
873         ret = my_dvb_dmxdev_ts_card_init(&port->dmxdev, &port->demux,
874                                          &port->hw_frontend,
875                                          &port->mem_frontend, adap);
876         if (ret < 0)
877                 goto err_del_dvb_dmx;
878
879         ret = dvb_net_init(adap, &port->dvbnet, port->dmxdev.demux);
880         if (ret < 0)
881                 goto err_del_dvb_dmxdev;
882         return 0;
883 err_del_dvb_dmxdev:
884         dvbdemux->dmx.close(&dvbdemux->dmx);
885         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &port->hw_frontend);
886         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &port->mem_frontend);
887         dvb_dmxdev_release(&port->dmxdev);
888 err_del_dvb_dmx:
889         dvb_dmx_release(&port->demux);
890 err_del_dvb_register_adapter:
891         dvb_unregister_adapter(&port->dvb_adapter);
892         return ret;
893 }
894
895 static void smi_dvb_exit(struct smi_port *port)
896 {
897         struct dvb_demux *dvbdemux = &port->demux;
898
899         dvb_net_release(&port->dvbnet);
900
901         dvbdemux->dmx.close(&dvbdemux->dmx);
902         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &port->hw_frontend);
903         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &port->mem_frontend);
904         dvb_dmxdev_release(&port->dmxdev);
905         dvb_dmx_release(&port->demux);
906
907         dvb_unregister_adapter(&port->dvb_adapter);
908 }
909
910 static int smi_port_attach(struct smi_dev *dev,
911                 struct smi_port *port, int index)
912 {
913         int ret, dmachs;
914
915         port->dev = dev;
916         port->idx = index;
917         port->fe_type = (index == 0) ? dev->info->fe_0 : dev->info->fe_1;
918         dmachs = (index == 0) ? dev->info->ts_0 : dev->info->ts_1;
919         /* port init.*/
920         ret = smi_port_init(port, dmachs);
921         if (ret < 0)
922                 return ret;
923         /* dvb init.*/
924         ret = smi_dvb_init(port);
925         if (ret < 0)
926                 goto err_del_port_init;
927         /* fe init.*/
928         ret = smi_fe_init(port);
929         if (ret < 0)
930                 goto err_del_dvb_init;
931         return 0;
932 err_del_dvb_init:
933         smi_dvb_exit(port);
934 err_del_port_init:
935         smi_port_exit(port);
936         return ret;
937 }
938
939 static void smi_port_detach(struct smi_port *port)
940 {
941         smi_fe_exit(port);
942         smi_dvb_exit(port);
943         smi_port_exit(port);
944 }
945
946 static int smi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
947 {
948         struct smi_dev *dev;
949         int ret = -ENOMEM;
950
951         if (pci_enable_device(pdev) < 0)
952                 return -ENODEV;
953
954         dev = kzalloc(sizeof(struct smi_dev), GFP_KERNEL);
955         if (!dev) {
956                 ret = -ENOMEM;
957                 goto err_pci_disable_device;
958         }
959
960         dev->pci_dev = pdev;
961         pci_set_drvdata(pdev, dev);
962         dev->info = (struct smi_cfg_info *) id->driver_data;
963         dev_info(&dev->pci_dev->dev,
964                 "card detected: %s\n", dev->info->name);
965
966         dev->nr = dev->info->type;
967         dev->lmmio = ioremap(pci_resource_start(dev->pci_dev, 0),
968                             pci_resource_len(dev->pci_dev, 0));
969         if (!dev->lmmio) {
970                 ret = -ENOMEM;
971                 goto err_kfree;
972         }
973
974         /* should we set to 32bit DMA? */
975         ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
976         if (ret < 0)
977                 goto err_pci_iounmap;
978
979         pci_set_master(pdev);
980
981         ret = smi_hw_init(dev);
982         if (ret < 0)
983                 goto err_pci_iounmap;
984
985         ret = smi_i2c_init(dev);
986         if (ret < 0)
987                 goto err_pci_iounmap;
988
989         if (dev->info->ts_0) {
990                 ret = smi_port_attach(dev, &dev->ts_port[0], 0);
991                 if (ret < 0)
992                         goto err_del_i2c_adaptor;
993         }
994
995         if (dev->info->ts_1) {
996                 ret = smi_port_attach(dev, &dev->ts_port[1], 1);
997                 if (ret < 0)
998                         goto err_del_port0_attach;
999         }
1000
1001         ret = smi_ir_init(dev);
1002         if (ret < 0)
1003                 goto err_del_port1_attach;
1004
1005 #ifdef CONFIG_PCI_MSI /* to do msi interrupt.???*/
1006         if (pci_msi_enabled())
1007                 ret = pci_enable_msi(dev->pci_dev);
1008         if (ret)
1009                 dev_info(&dev->pci_dev->dev, "MSI not available.\n");
1010 #endif
1011
1012         ret = request_irq(dev->pci_dev->irq, smi_irq_handler,
1013                            IRQF_SHARED, "SMI_PCIE", dev);
1014         if (ret < 0)
1015                 goto err_del_ir;
1016
1017         smi_ir_start(&dev->ir);
1018         return 0;
1019
1020 err_del_ir:
1021         smi_ir_exit(dev);
1022 err_del_port1_attach:
1023         if (dev->info->ts_1)
1024                 smi_port_detach(&dev->ts_port[1]);
1025 err_del_port0_attach:
1026         if (dev->info->ts_0)
1027                 smi_port_detach(&dev->ts_port[0]);
1028 err_del_i2c_adaptor:
1029         smi_i2c_exit(dev);
1030 err_pci_iounmap:
1031         iounmap(dev->lmmio);
1032 err_kfree:
1033         pci_set_drvdata(pdev, NULL);
1034         kfree(dev);
1035 err_pci_disable_device:
1036         pci_disable_device(pdev);
1037         return ret;
1038 }
1039
1040 static void smi_remove(struct pci_dev *pdev)
1041 {
1042         struct smi_dev *dev = pci_get_drvdata(pdev);
1043
1044         smi_write(MSI_INT_ENA_CLR, ALL_INT);
1045         free_irq(dev->pci_dev->irq, dev);
1046 #ifdef CONFIG_PCI_MSI
1047         pci_disable_msi(dev->pci_dev);
1048 #endif
1049         if (dev->info->ts_1)
1050                 smi_port_detach(&dev->ts_port[1]);
1051         if (dev->info->ts_0)
1052                 smi_port_detach(&dev->ts_port[0]);
1053
1054         smi_ir_exit(dev);
1055         smi_i2c_exit(dev);
1056         iounmap(dev->lmmio);
1057         pci_set_drvdata(pdev, NULL);
1058         pci_disable_device(pdev);
1059         kfree(dev);
1060 }
1061
1062 /* DVBSky cards */
1063 static const struct smi_cfg_info dvbsky_s950_cfg = {
1064         .type = SMI_DVBSKY_S950,
1065         .name = "DVBSky S950 V3",
1066         .ts_0 = SMI_TS_NULL,
1067         .ts_1 = SMI_TS_DMA_BOTH,
1068         .fe_0 = DVBSKY_FE_NULL,
1069         .fe_1 = DVBSKY_FE_M88DS3103,
1070         .rc_map = RC_MAP_DVBSKY,
1071 };
1072
1073 static const struct smi_cfg_info dvbsky_s952_cfg = {
1074         .type = SMI_DVBSKY_S952,
1075         .name = "DVBSky S952 V3",
1076         .ts_0 = SMI_TS_DMA_BOTH,
1077         .ts_1 = SMI_TS_DMA_BOTH,
1078         .fe_0 = DVBSKY_FE_M88RS6000,
1079         .fe_1 = DVBSKY_FE_M88RS6000,
1080         .rc_map = RC_MAP_DVBSKY,
1081 };
1082
1083 static const struct smi_cfg_info dvbsky_t9580_cfg = {
1084         .type = SMI_DVBSKY_T9580,
1085         .name = "DVBSky T9580 V3",
1086         .ts_0 = SMI_TS_DMA_BOTH,
1087         .ts_1 = SMI_TS_DMA_BOTH,
1088         .fe_0 = DVBSKY_FE_SIT2,
1089         .fe_1 = DVBSKY_FE_M88DS3103,
1090         .rc_map = RC_MAP_DVBSKY,
1091 };
1092
1093 static const struct smi_cfg_info technotrend_s2_4200_cfg = {
1094         .type = SMI_TECHNOTREND_S2_4200,
1095         .name = "TechnoTrend TT-budget S2-4200 Twin",
1096         .ts_0 = SMI_TS_DMA_BOTH,
1097         .ts_1 = SMI_TS_DMA_BOTH,
1098         .fe_0 = DVBSKY_FE_M88RS6000,
1099         .fe_1 = DVBSKY_FE_M88RS6000,
1100         .rc_map = RC_MAP_TT_1500,
1101 };
1102
1103 /* PCI IDs */
1104 #define SMI_ID(_subvend, _subdev, _driverdata) {        \
1105         .vendor      = SMI_VID,    .device    = SMI_PID, \
1106         .subvendor   = _subvend, .subdevice = _subdev, \
1107         .driver_data = (unsigned long)&_driverdata }
1108
1109 static const struct pci_device_id smi_id_table[] = {
1110         SMI_ID(0x4254, 0x0550, dvbsky_s950_cfg),
1111         SMI_ID(0x4254, 0x0552, dvbsky_s952_cfg),
1112         SMI_ID(0x4254, 0x5580, dvbsky_t9580_cfg),
1113         SMI_ID(0x13c2, 0x3016, technotrend_s2_4200_cfg),
1114         {0}
1115 };
1116 MODULE_DEVICE_TABLE(pci, smi_id_table);
1117
1118 static struct pci_driver smipcie_driver = {
1119         .name = "SMI PCIe driver",
1120         .id_table = smi_id_table,
1121         .probe = smi_probe,
1122         .remove = smi_remove,
1123 };
1124
1125 module_pci_driver(smipcie_driver);
1126
1127 MODULE_AUTHOR("Max nibble <nibble.max@gmail.com>");
1128 MODULE_DESCRIPTION("SMI PCIe driver");
1129 MODULE_LICENSE("GPL");