2 * cec-api.c - HDMI Consumer Electronics Control framework - API
4 * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
6 * This program is free software; you may redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
11 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
12 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
13 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
14 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
15 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
16 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 #include <linux/errno.h>
21 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/kmod.h>
25 #include <linux/ktime.h>
26 #include <linux/slab.h>
28 #include <linux/string.h>
29 #include <linux/types.h>
30 #include <linux/uaccess.h>
31 #include <linux/version.h>
35 static inline struct cec_devnode
*cec_devnode_data(struct file
*filp
)
37 struct cec_fh
*fh
= filp
->private_data
;
39 return &fh
->adap
->devnode
;
42 /* CEC file operations */
44 static unsigned int cec_poll(struct file
*filp
,
45 struct poll_table_struct
*poll
)
47 struct cec_devnode
*devnode
= cec_devnode_data(filp
);
48 struct cec_fh
*fh
= filp
->private_data
;
49 struct cec_adapter
*adap
= fh
->adap
;
52 if (!devnode
->registered
)
53 return POLLERR
| POLLHUP
;
54 mutex_lock(&adap
->lock
);
55 if (adap
->is_configured
&&
56 adap
->transmit_queue_sz
< CEC_MAX_MSG_TX_QUEUE_SZ
)
57 res
|= POLLOUT
| POLLWRNORM
;
59 res
|= POLLIN
| POLLRDNORM
;
60 if (fh
->pending_events
)
62 poll_wait(filp
, &fh
->wait
, poll
);
63 mutex_unlock(&adap
->lock
);
67 static bool cec_is_busy(const struct cec_adapter
*adap
,
68 const struct cec_fh
*fh
)
70 bool valid_initiator
= adap
->cec_initiator
&& adap
->cec_initiator
== fh
;
71 bool valid_follower
= adap
->cec_follower
&& adap
->cec_follower
== fh
;
74 * Exclusive initiators and followers can always access the CEC adapter
76 if (valid_initiator
|| valid_follower
)
79 * All others can only access the CEC adapter if there is no
80 * exclusive initiator and they are in INITIATOR mode.
82 return adap
->cec_initiator
||
83 fh
->mode_initiator
== CEC_MODE_NO_INITIATOR
;
86 static long cec_adap_g_caps(struct cec_adapter
*adap
,
87 struct cec_caps __user
*parg
)
89 struct cec_caps caps
= {};
91 strlcpy(caps
.driver
, adap
->devnode
.parent
->driver
->name
,
93 strlcpy(caps
.name
, adap
->name
, sizeof(caps
.name
));
94 caps
.available_log_addrs
= adap
->available_log_addrs
;
95 caps
.capabilities
= adap
->capabilities
;
96 caps
.version
= LINUX_VERSION_CODE
;
97 if (copy_to_user(parg
, &caps
, sizeof(caps
)))
102 static long cec_adap_g_phys_addr(struct cec_adapter
*adap
,
107 mutex_lock(&adap
->lock
);
108 phys_addr
= adap
->phys_addr
;
109 mutex_unlock(&adap
->lock
);
110 if (copy_to_user(parg
, &phys_addr
, sizeof(phys_addr
)))
115 static long cec_adap_s_phys_addr(struct cec_adapter
*adap
, struct cec_fh
*fh
,
116 bool block
, __u16 __user
*parg
)
121 if (!(adap
->capabilities
& CEC_CAP_PHYS_ADDR
))
123 if (copy_from_user(&phys_addr
, parg
, sizeof(phys_addr
)))
126 err
= cec_phys_addr_validate(phys_addr
, NULL
, NULL
);
129 mutex_lock(&adap
->lock
);
130 if (cec_is_busy(adap
, fh
))
133 __cec_s_phys_addr(adap
, phys_addr
, block
);
134 mutex_unlock(&adap
->lock
);
138 static long cec_adap_g_log_addrs(struct cec_adapter
*adap
,
139 struct cec_log_addrs __user
*parg
)
141 struct cec_log_addrs log_addrs
;
143 mutex_lock(&adap
->lock
);
144 log_addrs
= adap
->log_addrs
;
145 if (!adap
->is_configured
)
146 memset(log_addrs
.log_addr
, CEC_LOG_ADDR_INVALID
,
147 sizeof(log_addrs
.log_addr
));
148 mutex_unlock(&adap
->lock
);
150 if (copy_to_user(parg
, &log_addrs
, sizeof(log_addrs
)))
155 static long cec_adap_s_log_addrs(struct cec_adapter
*adap
, struct cec_fh
*fh
,
156 bool block
, struct cec_log_addrs __user
*parg
)
158 struct cec_log_addrs log_addrs
;
161 if (!(adap
->capabilities
& CEC_CAP_LOG_ADDRS
))
163 if (copy_from_user(&log_addrs
, parg
, sizeof(log_addrs
)))
165 log_addrs
.flags
&= CEC_LOG_ADDRS_FL_ALLOW_UNREG_FALLBACK
;
166 mutex_lock(&adap
->lock
);
167 if (!adap
->is_configuring
&&
168 (!log_addrs
.num_log_addrs
|| !adap
->is_configured
) &&
169 !cec_is_busy(adap
, fh
)) {
170 err
= __cec_s_log_addrs(adap
, &log_addrs
, block
);
172 log_addrs
= adap
->log_addrs
;
174 mutex_unlock(&adap
->lock
);
177 if (copy_to_user(parg
, &log_addrs
, sizeof(log_addrs
)))
182 static long cec_transmit(struct cec_adapter
*adap
, struct cec_fh
*fh
,
183 bool block
, struct cec_msg __user
*parg
)
185 struct cec_msg msg
= {};
188 if (!(adap
->capabilities
& CEC_CAP_TRANSMIT
))
190 if (copy_from_user(&msg
, parg
, sizeof(msg
)))
192 mutex_lock(&adap
->lock
);
193 if (!adap
->is_configured
)
195 else if (cec_is_busy(adap
, fh
))
198 err
= cec_transmit_msg_fh(adap
, &msg
, fh
, block
);
199 mutex_unlock(&adap
->lock
);
202 if (copy_to_user(parg
, &msg
, sizeof(msg
)))
207 /* Called by CEC_RECEIVE: wait for a message to arrive */
208 static int cec_receive_msg(struct cec_fh
*fh
, struct cec_msg
*msg
, bool block
)
210 u32 timeout
= msg
->timeout
;
214 mutex_lock(&fh
->lock
);
215 /* Are there received messages queued up? */
216 if (fh
->queued_msgs
) {
217 /* Yes, return the first one */
218 struct cec_msg_entry
*entry
=
219 list_first_entry(&fh
->msgs
,
220 struct cec_msg_entry
, list
);
222 list_del(&entry
->list
);
226 mutex_unlock(&fh
->lock
);
227 /* restore original timeout value */
228 msg
->timeout
= timeout
;
232 /* No, return EAGAIN in non-blocking mode or wait */
233 mutex_unlock(&fh
->lock
);
235 /* Return when in non-blocking mode */
240 /* The user specified a timeout */
241 res
= wait_event_interruptible_timeout(fh
->wait
,
243 msecs_to_jiffies(msg
->timeout
));
249 /* Wait indefinitely */
250 res
= wait_event_interruptible(fh
->wait
,
253 /* Exit on error, otherwise loop to get the new message */
258 static long cec_receive(struct cec_adapter
*adap
, struct cec_fh
*fh
,
259 bool block
, struct cec_msg __user
*parg
)
261 struct cec_msg msg
= {};
264 if (copy_from_user(&msg
, parg
, sizeof(msg
)))
266 mutex_lock(&adap
->lock
);
267 if (!adap
->is_configured
&& fh
->mode_follower
< CEC_MODE_MONITOR
)
269 mutex_unlock(&adap
->lock
);
273 err
= cec_receive_msg(fh
, &msg
, block
);
276 if (copy_to_user(parg
, &msg
, sizeof(msg
)))
281 static long cec_dqevent(struct cec_adapter
*adap
, struct cec_fh
*fh
,
282 bool block
, struct cec_event __user
*parg
)
284 struct cec_event
*ev
= NULL
;
289 mutex_lock(&fh
->lock
);
290 while (!fh
->pending_events
&& block
) {
291 mutex_unlock(&fh
->lock
);
292 err
= wait_event_interruptible(fh
->wait
, fh
->pending_events
);
295 mutex_lock(&fh
->lock
);
298 /* Find the oldest event */
299 for (i
= 0; i
< CEC_NUM_EVENTS
; i
++) {
300 if (fh
->pending_events
& (1 << (i
+ 1)) &&
301 fh
->events
[i
].ts
<= ts
) {
311 if (copy_to_user(parg
, ev
, sizeof(*ev
))) {
316 fh
->pending_events
&= ~(1 << ev
->event
);
319 mutex_unlock(&fh
->lock
);
323 static long cec_g_mode(struct cec_adapter
*adap
, struct cec_fh
*fh
,
326 u32 mode
= fh
->mode_initiator
| fh
->mode_follower
;
328 if (copy_to_user(parg
, &mode
, sizeof(mode
)))
333 static long cec_s_mode(struct cec_adapter
*adap
, struct cec_fh
*fh
,
341 if (copy_from_user(&mode
, parg
, sizeof(mode
)))
343 if (mode
& ~(CEC_MODE_INITIATOR_MSK
| CEC_MODE_FOLLOWER_MSK
))
346 mode_initiator
= mode
& CEC_MODE_INITIATOR_MSK
;
347 mode_follower
= mode
& CEC_MODE_FOLLOWER_MSK
;
349 if (mode_initiator
> CEC_MODE_EXCL_INITIATOR
||
350 mode_follower
> CEC_MODE_MONITOR_ALL
)
353 if (mode_follower
== CEC_MODE_MONITOR_ALL
&&
354 !(adap
->capabilities
& CEC_CAP_MONITOR_ALL
))
357 /* Follower modes should always be able to send CEC messages */
358 if ((mode_initiator
== CEC_MODE_NO_INITIATOR
||
359 !(adap
->capabilities
& CEC_CAP_TRANSMIT
)) &&
360 mode_follower
>= CEC_MODE_FOLLOWER
&&
361 mode_follower
<= CEC_MODE_EXCL_FOLLOWER_PASSTHRU
)
364 /* Monitor modes require CEC_MODE_NO_INITIATOR */
365 if (mode_initiator
&& mode_follower
>= CEC_MODE_MONITOR
)
368 /* Monitor modes require CAP_NET_ADMIN */
369 if (mode_follower
>= CEC_MODE_MONITOR
&& !capable(CAP_NET_ADMIN
))
372 mutex_lock(&adap
->lock
);
374 * You can't become exclusive follower if someone else already
377 if ((mode_follower
== CEC_MODE_EXCL_FOLLOWER
||
378 mode_follower
== CEC_MODE_EXCL_FOLLOWER_PASSTHRU
) &&
379 adap
->cec_follower
&& adap
->cec_follower
!= fh
)
382 * You can't become exclusive initiator if someone else already
385 if (mode_initiator
== CEC_MODE_EXCL_INITIATOR
&&
386 adap
->cec_initiator
&& adap
->cec_initiator
!= fh
)
390 bool old_mon_all
= fh
->mode_follower
== CEC_MODE_MONITOR_ALL
;
391 bool new_mon_all
= mode_follower
== CEC_MODE_MONITOR_ALL
;
393 if (old_mon_all
!= new_mon_all
) {
395 err
= cec_monitor_all_cnt_inc(adap
);
397 cec_monitor_all_cnt_dec(adap
);
402 mutex_unlock(&adap
->lock
);
406 if (fh
->mode_follower
== CEC_MODE_FOLLOWER
)
407 adap
->follower_cnt
--;
408 if (mode_follower
== CEC_MODE_FOLLOWER
)
409 adap
->follower_cnt
++;
410 if (mode_follower
== CEC_MODE_EXCL_FOLLOWER
||
411 mode_follower
== CEC_MODE_EXCL_FOLLOWER_PASSTHRU
) {
413 mode_follower
== CEC_MODE_EXCL_FOLLOWER_PASSTHRU
;
414 adap
->cec_follower
= fh
;
415 } else if (adap
->cec_follower
== fh
) {
416 adap
->passthrough
= false;
417 adap
->cec_follower
= NULL
;
419 if (mode_initiator
== CEC_MODE_EXCL_INITIATOR
)
420 adap
->cec_initiator
= fh
;
421 else if (adap
->cec_initiator
== fh
)
422 adap
->cec_initiator
= NULL
;
423 fh
->mode_initiator
= mode_initiator
;
424 fh
->mode_follower
= mode_follower
;
425 mutex_unlock(&adap
->lock
);
429 static long cec_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
431 struct cec_devnode
*devnode
= cec_devnode_data(filp
);
432 struct cec_fh
*fh
= filp
->private_data
;
433 struct cec_adapter
*adap
= fh
->adap
;
434 bool block
= !(filp
->f_flags
& O_NONBLOCK
);
435 void __user
*parg
= (void __user
*)arg
;
437 if (!devnode
->registered
)
441 case CEC_ADAP_G_CAPS
:
442 return cec_adap_g_caps(adap
, parg
);
444 case CEC_ADAP_G_PHYS_ADDR
:
445 return cec_adap_g_phys_addr(adap
, parg
);
447 case CEC_ADAP_S_PHYS_ADDR
:
448 return cec_adap_s_phys_addr(adap
, fh
, block
, parg
);
450 case CEC_ADAP_G_LOG_ADDRS
:
451 return cec_adap_g_log_addrs(adap
, parg
);
453 case CEC_ADAP_S_LOG_ADDRS
:
454 return cec_adap_s_log_addrs(adap
, fh
, block
, parg
);
457 return cec_transmit(adap
, fh
, block
, parg
);
460 return cec_receive(adap
, fh
, block
, parg
);
463 return cec_dqevent(adap
, fh
, block
, parg
);
466 return cec_g_mode(adap
, fh
, parg
);
469 return cec_s_mode(adap
, fh
, parg
);
476 static int cec_open(struct inode
*inode
, struct file
*filp
)
478 struct cec_devnode
*devnode
=
479 container_of(inode
->i_cdev
, struct cec_devnode
, cdev
);
480 struct cec_adapter
*adap
= to_cec_adapter(devnode
);
481 struct cec_fh
*fh
= kzalloc(sizeof(*fh
), GFP_KERNEL
);
483 * Initial events that are automatically sent when the cec device is
486 struct cec_event ev_state
= {
487 .event
= CEC_EVENT_STATE_CHANGE
,
488 .flags
= CEC_EVENT_FL_INITIAL_STATE
,
495 INIT_LIST_HEAD(&fh
->msgs
);
496 INIT_LIST_HEAD(&fh
->xfer_list
);
497 mutex_init(&fh
->lock
);
498 init_waitqueue_head(&fh
->wait
);
500 fh
->mode_initiator
= CEC_MODE_INITIATOR
;
503 err
= cec_get_device(devnode
);
509 filp
->private_data
= fh
;
511 mutex_lock(&devnode
->lock
);
512 /* Queue up initial state events */
513 ev_state
.state_change
.phys_addr
= adap
->phys_addr
;
514 ev_state
.state_change
.log_addr_mask
= adap
->log_addrs
.log_addr_mask
;
515 cec_queue_event_fh(fh
, &ev_state
, 0);
517 list_add(&fh
->list
, &devnode
->fhs
);
518 mutex_unlock(&devnode
->lock
);
523 /* Override for the release function */
524 static int cec_release(struct inode
*inode
, struct file
*filp
)
526 struct cec_devnode
*devnode
= cec_devnode_data(filp
);
527 struct cec_adapter
*adap
= to_cec_adapter(devnode
);
528 struct cec_fh
*fh
= filp
->private_data
;
530 mutex_lock(&adap
->lock
);
531 if (adap
->cec_initiator
== fh
)
532 adap
->cec_initiator
= NULL
;
533 if (adap
->cec_follower
== fh
) {
534 adap
->cec_follower
= NULL
;
535 adap
->passthrough
= false;
537 if (fh
->mode_follower
== CEC_MODE_FOLLOWER
)
538 adap
->follower_cnt
--;
539 if (fh
->mode_follower
== CEC_MODE_MONITOR_ALL
)
540 cec_monitor_all_cnt_dec(adap
);
541 mutex_unlock(&adap
->lock
);
543 mutex_lock(&devnode
->lock
);
545 mutex_unlock(&devnode
->lock
);
547 /* Unhook pending transmits from this filehandle. */
548 mutex_lock(&adap
->lock
);
549 while (!list_empty(&fh
->xfer_list
)) {
550 struct cec_data
*data
=
551 list_first_entry(&fh
->xfer_list
, struct cec_data
, xfer_list
);
553 data
->blocking
= false;
555 list_del(&data
->xfer_list
);
557 mutex_unlock(&adap
->lock
);
558 while (!list_empty(&fh
->msgs
)) {
559 struct cec_msg_entry
*entry
=
560 list_first_entry(&fh
->msgs
, struct cec_msg_entry
, list
);
562 list_del(&entry
->list
);
567 cec_put_device(devnode
);
568 filp
->private_data
= NULL
;
572 const struct file_operations cec_devnode_fops
= {
573 .owner
= THIS_MODULE
,
575 .unlocked_ioctl
= cec_ioctl
,
576 .release
= cec_release
,