[deliverable/linux.git] / drivers / media / pci / netup_unidvb / netup_unidvb_ci.c

/*
 * netup_unidvb_ci.c
 *
 * DVB CAM support for NetUP Universal Dual DVB-CI
 *
 * Copyright (C) 2014 NetUP Inc.
 * Copyright (C) 2014 Sergey Kozlov <serjk@netup.ru>
 * Copyright (C) 2014 Abylay Ospan <aospan@netup.ru>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kmod.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include "netup_unidvb.h"

/* CI slot 0 base address */
#define CAM0_CONFIG		0x0
#define CAM0_IO			0x8000
#define CAM0_MEM		0x10000
#define CAM0_SZ			32
/* CI slot 1 base address */
#define CAM1_CONFIG		0x20000
#define CAM1_IO			0x28000
#define CAM1_MEM		0x30000
#define CAM1_SZ			32
/* ctrlstat registers */
#define CAM_CTRLSTAT_READ_SET	0x4980
#define CAM_CTRLSTAT_CLR	0x4982
/* register bits */
#define BIT_CAM_STCHG		(1<<0)
#define BIT_CAM_PRESENT		(1<<1)
#define BIT_CAM_RESET		(1<<2)
#define BIT_CAM_BYPASS		(1<<3)
#define BIT_CAM_READY		(1<<4)
#define BIT_CAM_ERROR		(1<<5)
#define BIT_CAM_OVERCURR	(1<<6)
/* BIT_CAM_BYPASS bit shift for SLOT 1 */
#define CAM1_SHIFT 8

irqreturn_t netup_ci_interrupt(struct netup_unidvb_dev *ndev)
{
	writew(0x101, ndev->bmmio0 + CAM_CTRLSTAT_CLR);
	return IRQ_HANDLED;
}

static int netup_unidvb_ci_slot_ts_ctl(struct dvb_ca_en50221 *en50221,
				       int slot)
{
	struct netup_ci_state *state = en50221->data;
	struct netup_unidvb_dev *dev = state->dev;
	u16 shift = (state->nr == 1) ? CAM1_SHIFT : 0;

	dev_dbg(&dev->pci_dev->dev, "%s(): CAM_CTRLSTAT=0x%x\n",
		__func__, readw(dev->bmmio0 + CAM_CTRLSTAT_READ_SET));
	if (slot != 0)
		return -EINVAL;
	/* pass data to CAM module */
	writew(BIT_CAM_BYPASS << shift, dev->bmmio0 + CAM_CTRLSTAT_CLR);
	dev_dbg(&dev->pci_dev->dev, "%s(): CAM_CTRLSTAT=0x%x done\n",
		__func__, readw(dev->bmmio0 + CAM_CTRLSTAT_READ_SET));
	return 0;
}

static int netup_unidvb_ci_slot_shutdown(struct dvb_ca_en50221 *en50221,
					 int slot)
{
	struct netup_ci_state *state = en50221->data;
	struct netup_unidvb_dev *dev = state->dev;

	dev_dbg(&dev->pci_dev->dev, "%s()\n", __func__);
	return 0;
}

static int netup_unidvb_ci_slot_reset(struct dvb_ca_en50221 *en50221,
				      int slot)
{
	struct netup_ci_state *state = en50221->data;
	struct netup_unidvb_dev *dev = state->dev;
	unsigned long timeout = 0;
	u16 shift = (state->nr == 1) ? CAM1_SHIFT : 0;
	u16 ci_stat = 0;
	int reset_counter = 3;

	dev_dbg(&dev->pci_dev->dev, "%s(): CAM_CTRLSTAT_READ_SET=0x%x\n",
		__func__, readw(dev->bmmio0 + CAM_CTRLSTAT_READ_SET));
reset:
	timeout = jiffies + msecs_to_jiffies(5000);
	/* start reset */
	writew(BIT_CAM_RESET << shift, dev->bmmio0 + CAM_CTRLSTAT_READ_SET);
	dev_dbg(&dev->pci_dev->dev, "%s(): waiting for reset\n", __func__);
	/* wait until reset done */
	while (time_before(jiffies, timeout)) {
		ci_stat = readw(dev->bmmio0 + CAM_CTRLSTAT_READ_SET);
		if (ci_stat & (BIT_CAM_READY << shift))
			break;
		udelay(1000);
	}
	if (!(ci_stat & (BIT_CAM_READY << shift)) && reset_counter > 0) {
		dev_dbg(&dev->pci_dev->dev,
			"%s(): CAMP reset timeout! Will try again..\n",
			 __func__);
		reset_counter--;
		goto reset;
	}
	return 0;
}

static int netup_unidvb_poll_ci_slot_status(struct dvb_ca_en50221 *en50221,
					    int slot, int open)
{
	struct netup_ci_state *state = en50221->data;
	struct netup_unidvb_dev *dev = state->dev;
	u16 shift = (state->nr == 1) ? CAM1_SHIFT : 0;
	u16 ci_stat = 0;

	dev_dbg(&dev->pci_dev->dev, "%s(): CAM_CTRLSTAT_READ_SET=0x%x\n",
		__func__, readw(dev->bmmio0 + CAM_CTRLSTAT_READ_SET));
	ci_stat = readw(dev->bmmio0 + CAM_CTRLSTAT_READ_SET);
	if (ci_stat & (BIT_CAM_READY << shift)) {
		state->status = DVB_CA_EN50221_POLL_CAM_PRESENT |
			DVB_CA_EN50221_POLL_CAM_READY;
	} else if (ci_stat & (BIT_CAM_PRESENT << shift)) {
		state->status = DVB_CA_EN50221_POLL_CAM_PRESENT;
	} else {
		state->status = 0;
	}
	return state->status;
}

static int netup_unidvb_ci_read_attribute_mem(struct dvb_ca_en50221 *en50221,
					      int slot, int addr)
{
	struct netup_ci_state *state = en50221->data;
	struct netup_unidvb_dev *dev = state->dev;
	u8 val = *((u8 __force *)state->membase8_io + addr);

	dev_dbg(&dev->pci_dev->dev,
		"%s(): addr=0x%x val=0x%x\n", __func__, addr, val);
	return val;
}

static int netup_unidvb_ci_write_attribute_mem(struct dvb_ca_en50221 *en50221,
					       int slot, int addr, u8 data)
{
	struct netup_ci_state *state = en50221->data;
	struct netup_unidvb_dev *dev = state->dev;

	dev_dbg(&dev->pci_dev->dev,
		"%s(): addr=0x%x data=0x%x\n", __func__, addr, data);
	*((u8 __force *)state->membase8_io + addr) = data;
	return 0;
}

static int netup_unidvb_ci_read_cam_ctl(struct dvb_ca_en50221 *en50221,
					int slot, u8 addr)
{
	struct netup_ci_state *state = en50221->data;
	struct netup_unidvb_dev *dev = state->dev;
	u8 val = *((u8 __force *)state->membase8_io + addr);

	dev_dbg(&dev->pci_dev->dev,
		"%s(): addr=0x%x val=0x%x\n", __func__, addr, val);
	return val;
}

static int netup_unidvb_ci_write_cam_ctl(struct dvb_ca_en50221 *en50221,
					 int slot, u8 addr, u8 data)
{
	struct netup_ci_state *state = en50221->data;
	struct netup_unidvb_dev *dev = state->dev;

	dev_dbg(&dev->pci_dev->dev,
		"%s(): addr=0x%x data=0x%x\n", __func__, addr, data);
	*((u8 __force *)state->membase8_io + addr) = data;
	return 0;
}

int netup_unidvb_ci_register(struct netup_unidvb_dev *dev,
			     int num, struct pci_dev *pci_dev)
{
	int result;
	struct netup_ci_state *state;

	if (num < 0 || num > 1) {
		dev_err(&pci_dev->dev, "%s(): invalid CI adapter %d\n",
			__func__, num);
		return -EINVAL;
	}
	state = &dev->ci[num];
	state->nr = num;
	state->membase8_config = dev->bmmio1 +
		((num == 0) ? CAM0_CONFIG : CAM1_CONFIG);
	state->membase8_io = dev->bmmio1 +
		((num == 0) ? CAM0_IO : CAM1_IO);
	state->dev = dev;
	state->ca.owner = THIS_MODULE;
	state->ca.read_attribute_mem = netup_unidvb_ci_read_attribute_mem;
	state->ca.write_attribute_mem = netup_unidvb_ci_write_attribute_mem;
	state->ca.read_cam_control = netup_unidvb_ci_read_cam_ctl;
	state->ca.write_cam_control = netup_unidvb_ci_write_cam_ctl;
	state->ca.slot_reset = netup_unidvb_ci_slot_reset;
	state->ca.slot_shutdown = netup_unidvb_ci_slot_shutdown;
	state->ca.slot_ts_enable = netup_unidvb_ci_slot_ts_ctl;
	state->ca.poll_slot_status = netup_unidvb_poll_ci_slot_status;
	state->ca.data = state;
	result = dvb_ca_en50221_init(&dev->frontends[num].adapter,
		&state->ca, 0, 1);
	if (result < 0) {
		dev_err(&pci_dev->dev,
			"%s(): dvb_ca_en50221_init result %d\n",
			__func__, result);
		return result;
	}
	writew(NETUP_UNIDVB_IRQ_CI, dev->bmmio0 + REG_IMASK_SET);
	dev_info(&pci_dev->dev,
		"%s(): CI adapter %d init done\n", __func__, num);
	return 0;
}

void netup_unidvb_ci_unregister(struct netup_unidvb_dev *dev, int num)
{
	struct netup_ci_state *state;

	dev_dbg(&dev->pci_dev->dev, "%s()\n", __func__);
	if (num < 0 || num > 1) {
		dev_err(&dev->pci_dev->dev, "%s(): invalid CI adapter %d\n",
				__func__, num);
		return;
	}
	state = &dev->ci[num];
	dvb_ca_en50221_release(&state->ca);
}
Commit	Line	Data
52b1eaf4 KS	1	/*
	2	* netup_unidvb_ci.c
	3	*
	4	* DVB CAM support for NetUP Universal Dual DVB-CI
	5	*
	6	* Copyright (C) 2014 NetUP Inc.
	7	* Copyright (C) 2014 Sergey Kozlov <serjk@netup.ru>
	8	* Copyright (C) 2014 Abylay Ospan <aospan@netup.ru>
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*/
	20
	21	#include <linux/init.h>
	22	#include <linux/module.h>
	23	#include <linux/moduleparam.h>
	24	#include <linux/kmod.h>
	25	#include <linux/kernel.h>
	26	#include <linux/slab.h>
	27	#include <linux/interrupt.h>
	28	#include <linux/delay.h>
	29	#include "netup_unidvb.h"
	30
	31	/* CI slot 0 base address */
	32	#define CAM0_CONFIG 0x0
	33	#define CAM0_IO 0x8000
	34	#define CAM0_MEM 0x10000
	35	#define CAM0_SZ 32
	36	/* CI slot 1 base address */
	37	#define CAM1_CONFIG 0x20000
	38	#define CAM1_IO 0x28000
	39	#define CAM1_MEM 0x30000
	40	#define CAM1_SZ 32
	41	/* ctrlstat registers */
	42	#define CAM_CTRLSTAT_READ_SET 0x4980
	43	#define CAM_CTRLSTAT_CLR 0x4982
	44	/* register bits */
	45	#define BIT_CAM_STCHG (1<<0)
	46	#define BIT_CAM_PRESENT (1<<1)
	47	#define BIT_CAM_RESET (1<<2)
	48	#define BIT_CAM_BYPASS (1<<3)
	49	#define BIT_CAM_READY (1<<4)
	50	#define BIT_CAM_ERROR (1<<5)
	51	#define BIT_CAM_OVERCURR (1<<6)
	52	/* BIT_CAM_BYPASS bit shift for SLOT 1 */
	53	#define CAM1_SHIFT 8
	54
	55	irqreturn_t netup_ci_interrupt(struct netup_unidvb_dev *ndev)
	56	{
	57	writew(0x101, ndev->bmmio0 + CAM_CTRLSTAT_CLR);
	58	return IRQ_HANDLED;
	59	}
	60
	61	static int netup_unidvb_ci_slot_ts_ctl(struct dvb_ca_en50221 *en50221,
	62	int slot)
	63	{
	64	struct netup_ci_state *state = en50221->data;
65	struct netup_unidvb_dev *dev = state->dev;
66	u16 shift = (state->nr == 1) ? CAM1_SHIFT : 0;
67
68	dev_dbg(&dev->pci_dev->dev, "%s(): CAM_CTRLSTAT=0x%x\n",
69	__func__, readw(dev->bmmio0 + CAM_CTRLSTAT_READ_SET));
70	if (slot != 0)
71	return -EINVAL;
72	/* pass data to CAM module */
73	writew(BIT_CAM_BYPASS << shift, dev->bmmio0 + CAM_CTRLSTAT_CLR);
74	dev_dbg(&dev->pci_dev->dev, "%s(): CAM_CTRLSTAT=0x%x done\n",
75	__func__, readw(dev->bmmio0 + CAM_CTRLSTAT_READ_SET));
76	return 0;
77	}
78
79	static int netup_unidvb_ci_slot_shutdown(struct dvb_ca_en50221 *en50221,
80	int slot)
81	{
82	struct netup_ci_state *state = en50221->data;
83	struct netup_unidvb_dev *dev = state->dev;
84
85	dev_dbg(&dev->pci_dev->dev, "%s()\n", __func__);
86	return 0;
87	}
88
89	static int netup_unidvb_ci_slot_reset(struct dvb_ca_en50221 *en50221,
90	int slot)
91	{
92	struct netup_ci_state *state = en50221->data;
93	struct netup_unidvb_dev *dev = state->dev;
94	unsigned long timeout = 0;
95	u16 shift = (state->nr == 1) ? CAM1_SHIFT : 0;
96	u16 ci_stat = 0;
97	int reset_counter = 3;
98
99	dev_dbg(&dev->pci_dev->dev, "%s(): CAM_CTRLSTAT_READ_SET=0x%x\n",
100	__func__, readw(dev->bmmio0 + CAM_CTRLSTAT_READ_SET));
101	reset:
102	timeout = jiffies + msecs_to_jiffies(5000);
103	/* start reset */
104	writew(BIT_CAM_RESET << shift, dev->bmmio0 + CAM_CTRLSTAT_READ_SET);
105	dev_dbg(&dev->pci_dev->dev, "%s(): waiting for reset\n", __func__);
106	/* wait until reset done */
107	while (time_before(jiffies, timeout)) {
108	ci_stat = readw(dev->bmmio0 + CAM_CTRLSTAT_READ_SET);
109	if (ci_stat & (BIT_CAM_READY << shift))
110	break;
111	udelay(1000);
112	}
113	if (!(ci_stat & (BIT_CAM_READY << shift)) && reset_counter > 0) {
114	dev_dbg(&dev->pci_dev->dev,
115	"%s(): CAMP reset timeout! Will try again..\n",
116	__func__);
117	reset_counter--;
118	goto reset;
119	}
120	return 0;
121	}
122
123	static int netup_unidvb_poll_ci_slot_status(struct dvb_ca_en50221 *en50221,
124	int slot, int open)
125	{
126	struct netup_ci_state *state = en50221->data;
127	struct netup_unidvb_dev *dev = state->dev;
128	u16 shift = (state->nr == 1) ? CAM1_SHIFT : 0;
129	u16 ci_stat = 0;
130
131	dev_dbg(&dev->pci_dev->dev, "%s(): CAM_CTRLSTAT_READ_SET=0x%x\n",
132	__func__, readw(dev->bmmio0 + CAM_CTRLSTAT_READ_SET));
133	ci_stat = readw(dev->bmmio0 + CAM_CTRLSTAT_READ_SET);
134	if (ci_stat & (BIT_CAM_READY << shift)) {
135	state->status = DVB_CA_EN50221_POLL_CAM_PRESENT \|
136	DVB_CA_EN50221_POLL_CAM_READY;
137	} else if (ci_stat & (BIT_CAM_PRESENT << shift)) {
138	state->status = DVB_CA_EN50221_POLL_CAM_PRESENT;
139	} else {
140	state->status = 0;
141	}
142	return state->status;
143	}
144
145	static int netup_unidvb_ci_read_attribute_mem(struct dvb_ca_en50221 *en50221,
146	int slot, int addr)
147	{
148	struct netup_ci_state *state = en50221->data;
149	struct netup_unidvb_dev *dev = state->dev;
340ccedb	150	u8 val = ((u8 __force )state->membase8_io + addr);
52b1eaf4 KS	151
	152	dev_dbg(&dev->pci_dev->dev,
	153	"%s(): addr=0x%x val=0x%x\n", __func__, addr, val);
	154	return val;
	155	}
	156
	157	static int netup_unidvb_ci_write_attribute_mem(struct dvb_ca_en50221 *en50221,
	158	int slot, int addr, u8 data)
	159	{
	160	struct netup_ci_state *state = en50221->data;
	161	struct netup_unidvb_dev *dev = state->dev;
	162
	163	dev_dbg(&dev->pci_dev->dev,
	164	"%s(): addr=0x%x data=0x%x\n", __func__, addr, data);
340ccedb	165	((u8 __force )state->membase8_io + addr) = data;
52b1eaf4 KS	166	return 0;
	167	}
	168
	169	static int netup_unidvb_ci_read_cam_ctl(struct dvb_ca_en50221 *en50221,
	170	int slot, u8 addr)
	171	{
	172	struct netup_ci_state *state = en50221->data;
	173	struct netup_unidvb_dev *dev = state->dev;
340ccedb	174	u8 val = ((u8 __force )state->membase8_io + addr);
52b1eaf4 KS	175
	176	dev_dbg(&dev->pci_dev->dev,
	177	"%s(): addr=0x%x val=0x%x\n", __func__, addr, val);
	178	return val;
	179	}
	180
	181	static int netup_unidvb_ci_write_cam_ctl(struct dvb_ca_en50221 *en50221,
	182	int slot, u8 addr, u8 data)
	183	{
	184	struct netup_ci_state *state = en50221->data;
	185	struct netup_unidvb_dev *dev = state->dev;
	186
	187	dev_dbg(&dev->pci_dev->dev,
	188	"%s(): addr=0x%x data=0x%x\n", __func__, addr, data);
340ccedb	189	((u8 __force )state->membase8_io + addr) = data;
52b1eaf4 KS	190	return 0;
	191	}
	192
	193	int netup_unidvb_ci_register(struct netup_unidvb_dev *dev,
	194	int num, struct pci_dev *pci_dev)
	195	{
	196	int result;
	197	struct netup_ci_state *state;
	198
	199	if (num < 0 \|\| num > 1) {
	200	dev_err(&pci_dev->dev, "%s(): invalid CI adapter %d\n",
	201	__func__, num);
	202	return -EINVAL;
	203	}
	204	state = &dev->ci[num];
	205	state->nr = num;
	206	state->membase8_config = dev->bmmio1 +
	207	((num == 0) ? CAM0_CONFIG : CAM1_CONFIG);
	208	state->membase8_io = dev->bmmio1 +
	209	((num == 0) ? CAM0_IO : CAM1_IO);
	210	state->dev = dev;
	211	state->ca.owner = THIS_MODULE;
	212	state->ca.read_attribute_mem = netup_unidvb_ci_read_attribute_mem;
	213	state->ca.write_attribute_mem = netup_unidvb_ci_write_attribute_mem;
	214	state->ca.read_cam_control = netup_unidvb_ci_read_cam_ctl;
	215	state->ca.write_cam_control = netup_unidvb_ci_write_cam_ctl;
	216	state->ca.slot_reset = netup_unidvb_ci_slot_reset;
	217	state->ca.slot_shutdown = netup_unidvb_ci_slot_shutdown;
	218	state->ca.slot_ts_enable = netup_unidvb_ci_slot_ts_ctl;
	219	state->ca.poll_slot_status = netup_unidvb_poll_ci_slot_status;
	220	state->ca.data = state;
	221	result = dvb_ca_en50221_init(&dev->frontends[num].adapter,
	222	&state->ca, 0, 1);
	223	if (result < 0) {
	224	dev_err(&pci_dev->dev,
	225	"%s(): dvb_ca_en50221_init result %d\n",
	226	__func__, result);
	227	return result;
	228	}
d91b1d91	229	writew(NETUP_UNIDVB_IRQ_CI, dev->bmmio0 + REG_IMASK_SET);
52b1eaf4 KS	230	dev_info(&pci_dev->dev,
	231	"%s(): CI adapter %d init done\n", __func__, num);
	232	return 0;
	233	}
	234
	235	void netup_unidvb_ci_unregister(struct netup_unidvb_dev *dev, int num)
	236	{
	237	struct netup_ci_state *state;
	238
	239	dev_dbg(&dev->pci_dev->dev, "%s()\n", __func__);
	240	if (num < 0 \|\| num > 1) {
	241	dev_err(&dev->pci_dev->dev, "%s(): invalid CI adapter %d\n",
	242	__func__, num);
	243	return;
	244	}
	245	state = &dev->ci[num];
	246	dvb_ca_en50221_release(&state->ca);
	247	}
	248