853e04b7cb361d45257f80dcafdcf121cd340c63
[linux-2.6.git] / drivers / media / dvb / firewire / firedtv-ci.c
1 /*
2  * FireDTV driver (formerly known as FireSAT)
3  *
4  * Copyright (C) 2004 Andreas Monitzer <andy@monitzer.com>
5  * Copyright (C) 2008 Henrik Kurelid <henrik@kurelid.se>
6  *
7  *      This program is free software; you can redistribute it and/or
8  *      modify it under the terms of the GNU General Public License as
9  *      published by the Free Software Foundation; either version 2 of
10  *      the License, or (at your option) any later version.
11  */
12
13 #include <linux/device.h>
14 #include <linux/dvb/ca.h>
15 #include <linux/fs.h>
16 #include <linux/module.h>
17
18 #include <dvbdev.h>
19
20 #include "firedtv.h"
21
22 #define EN50221_TAG_APP_INFO_ENQUIRY    0x9f8020
23 #define EN50221_TAG_CA_INFO_ENQUIRY     0x9f8030
24 #define EN50221_TAG_CA_PMT              0x9f8032
25 #define EN50221_TAG_ENTER_MENU          0x9f8022
26
27 static int fdtv_ca_ready(struct firedtv_tuner_status *stat)
28 {
29         return stat->ca_initialization_status   == 1 &&
30                stat->ca_error_flag              == 0 &&
31                stat->ca_dvb_flag                == 1 &&
32                stat->ca_module_present_status   == 1;
33 }
34
35 static int fdtv_get_ca_flags(struct firedtv_tuner_status *stat)
36 {
37         int flags = 0;
38
39         if (stat->ca_module_present_status == 1)
40                 flags |= CA_CI_MODULE_PRESENT;
41         if (stat->ca_initialization_status == 1 &&
42             stat->ca_error_flag            == 0 &&
43             stat->ca_dvb_flag              == 1)
44                 flags |= CA_CI_MODULE_READY;
45         return flags;
46 }
47
48 static int fdtv_ca_reset(struct firedtv *fdtv)
49 {
50         return avc_ca_reset(fdtv) ? -EFAULT : 0;
51 }
52
53 static int fdtv_ca_get_caps(void *arg)
54 {
55         struct ca_caps *cap = arg;
56
57         cap->slot_num = 1;
58         cap->slot_type = CA_CI;
59         cap->descr_num = 1;
60         cap->descr_type = CA_ECD;
61         return 0;
62 }
63
64 static int fdtv_ca_get_slot_info(struct firedtv *fdtv, void *arg)
65 {
66         struct firedtv_tuner_status stat;
67         struct ca_slot_info *slot = arg;
68
69         if (avc_tuner_status(fdtv, &stat))
70                 return -EFAULT;
71
72         if (slot->num != 0)
73                 return -EFAULT;
74
75         slot->type = CA_CI;
76         slot->flags = fdtv_get_ca_flags(&stat);
77         return 0;
78 }
79
80 static int fdtv_ca_app_info(struct firedtv *fdtv, void *arg)
81 {
82         struct ca_msg *reply = arg;
83
84         return avc_ca_app_info(fdtv, reply->msg, &reply->length) ? -EFAULT : 0;
85 }
86
87 static int fdtv_ca_info(struct firedtv *fdtv, void *arg)
88 {
89         struct ca_msg *reply = arg;
90
91         return avc_ca_info(fdtv, reply->msg, &reply->length) ? -EFAULT : 0;
92 }
93
94 static int fdtv_ca_get_mmi(struct firedtv *fdtv, void *arg)
95 {
96         struct ca_msg *reply = arg;
97
98         return avc_ca_get_mmi(fdtv, reply->msg, &reply->length) ? -EFAULT : 0;
99 }
100
101 static int fdtv_ca_get_msg(struct firedtv *fdtv, void *arg)
102 {
103         struct firedtv_tuner_status stat;
104         int err;
105
106         switch (fdtv->ca_last_command) {
107         case EN50221_TAG_APP_INFO_ENQUIRY:
108                 err = fdtv_ca_app_info(fdtv, arg);
109                 break;
110         case EN50221_TAG_CA_INFO_ENQUIRY:
111                 err = fdtv_ca_info(fdtv, arg);
112                 break;
113         default:
114                 if (avc_tuner_status(fdtv, &stat))
115                         err = -EFAULT;
116                 else if (stat.ca_mmi == 1)
117                         err = fdtv_ca_get_mmi(fdtv, arg);
118                 else {
119                         dev_info(fdtv->device, "unhandled CA message 0x%08x\n",
120                                  fdtv->ca_last_command);
121                         err = -EFAULT;
122                 }
123         }
124         fdtv->ca_last_command = 0;
125         return err;
126 }
127
128 static int fdtv_ca_pmt(struct firedtv *fdtv, void *arg)
129 {
130         struct ca_msg *msg = arg;
131         int data_pos;
132         int data_length;
133         int i;
134
135         data_pos = 4;
136         if (msg->msg[3] & 0x80) {
137                 data_length = 0;
138                 for (i = 0; i < (msg->msg[3] & 0x7f); i++)
139                         data_length = (data_length << 8) + msg->msg[data_pos++];
140         } else {
141                 data_length = msg->msg[3];
142         }
143
144         return avc_ca_pmt(fdtv, &msg->msg[data_pos], data_length) ? -EFAULT : 0;
145 }
146
147 static int fdtv_ca_send_msg(struct firedtv *fdtv, void *arg)
148 {
149         struct ca_msg *msg = arg;
150         int err;
151
152         /* Do we need a semaphore for this? */
153         fdtv->ca_last_command =
154                 (msg->msg[0] << 16) + (msg->msg[1] << 8) + msg->msg[2];
155         switch (fdtv->ca_last_command) {
156         case EN50221_TAG_CA_PMT:
157                 err = fdtv_ca_pmt(fdtv, arg);
158                 break;
159         case EN50221_TAG_APP_INFO_ENQUIRY:
160                 /* handled in ca_get_msg */
161                 err = 0;
162                 break;
163         case EN50221_TAG_CA_INFO_ENQUIRY:
164                 /* handled in ca_get_msg */
165                 err = 0;
166                 break;
167         case EN50221_TAG_ENTER_MENU:
168                 err = avc_ca_enter_menu(fdtv);
169                 break;
170         default:
171                 dev_err(fdtv->device, "unhandled CA message 0x%08x\n",
172                         fdtv->ca_last_command);
173                 err = -EFAULT;
174         }
175         return err;
176 }
177
178 static int fdtv_ca_ioctl(struct inode *inode, struct file *file,
179                             unsigned int cmd, void *arg)
180 {
181         struct dvb_device *dvbdev = file->private_data;
182         struct firedtv *fdtv = dvbdev->priv;
183         struct firedtv_tuner_status stat;
184         int err;
185
186         switch (cmd) {
187         case CA_RESET:
188                 err = fdtv_ca_reset(fdtv);
189                 break;
190         case CA_GET_CAP:
191                 err = fdtv_ca_get_caps(arg);
192                 break;
193         case CA_GET_SLOT_INFO:
194                 err = fdtv_ca_get_slot_info(fdtv, arg);
195                 break;
196         case CA_GET_MSG:
197                 err = fdtv_ca_get_msg(fdtv, arg);
198                 break;
199         case CA_SEND_MSG:
200                 err = fdtv_ca_send_msg(fdtv, arg);
201                 break;
202         default:
203                 dev_info(fdtv->device, "unhandled CA ioctl %u\n", cmd);
204                 err = -EOPNOTSUPP;
205         }
206
207         /* FIXME Is this necessary? */
208         avc_tuner_status(fdtv, &stat);
209
210         return err;
211 }
212
213 static unsigned int fdtv_ca_io_poll(struct file *file, poll_table *wait)
214 {
215         return POLLIN;
216 }
217
218 static const struct file_operations fdtv_ca_fops = {
219         .owner          = THIS_MODULE,
220         .ioctl          = dvb_generic_ioctl,
221         .open           = dvb_generic_open,
222         .release        = dvb_generic_release,
223         .poll           = fdtv_ca_io_poll,
224 };
225
226 static struct dvb_device fdtv_ca = {
227         .users          = 1,
228         .readers        = 1,
229         .writers        = 1,
230         .fops           = &fdtv_ca_fops,
231         .kernel_ioctl   = fdtv_ca_ioctl,
232 };
233
234 int fdtv_ca_register(struct firedtv *fdtv)
235 {
236         struct firedtv_tuner_status stat;
237         int err;
238
239         if (avc_tuner_status(fdtv, &stat))
240                 return -EINVAL;
241
242         if (!fdtv_ca_ready(&stat))
243                 return -EFAULT;
244
245         err = dvb_register_device(&fdtv->adapter, &fdtv->cadev,
246                                   &fdtv_ca, fdtv, DVB_DEVICE_CA);
247
248         if (stat.ca_application_info == 0)
249                 dev_err(fdtv->device, "CaApplicationInfo is not set\n");
250         if (stat.ca_date_time_request == 1)
251                 avc_ca_get_time_date(fdtv, &fdtv->ca_time_interval);
252
253         return err;
254 }
255
256 void fdtv_ca_release(struct firedtv *fdtv)
257 {
258         if (fdtv->cadev)
259                 dvb_unregister_device(fdtv->cadev);
260 }