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 res
|= POLLOUT
| POLLWRNORM
;
58 res
|= POLLIN
| POLLRDNORM
;
59 if (fh
->pending_events
)
61 poll_wait(filp
, &fh
->wait
, poll
);
62 mutex_unlock(&adap
->lock
);
66 static bool cec_is_busy(const struct cec_adapter
*adap
,
67 const struct cec_fh
*fh
)
69 bool valid_initiator
= adap
->cec_initiator
&& adap
->cec_initiator
== fh
;
70 bool valid_follower
= adap
->cec_follower
&& adap
->cec_follower
== fh
;
73 * Exclusive initiators and followers can always access the CEC adapter
75 if (valid_initiator
|| valid_follower
)
78 * All others can only access the CEC adapter if there is no
79 * exclusive initiator and they are in INITIATOR mode.
81 return adap
->cec_initiator
||
82 fh
->mode_initiator
== CEC_MODE_NO_INITIATOR
;
85 static long cec_adap_g_caps(struct cec_adapter
*adap
,
86 struct cec_caps __user
*parg
)
88 struct cec_caps caps
= {};
90 strlcpy(caps
.driver
, adap
->devnode
.parent
->driver
->name
,
92 strlcpy(caps
.name
, adap
->name
, sizeof(caps
.name
));
93 caps
.available_log_addrs
= adap
->available_log_addrs
;
94 caps
.capabilities
= adap
->capabilities
;
95 caps
.version
= LINUX_VERSION_CODE
;
96 if (copy_to_user(parg
, &caps
, sizeof(caps
)))
101 static long cec_adap_g_phys_addr(struct cec_adapter
*adap
,
106 mutex_lock(&adap
->lock
);
107 phys_addr
= adap
->phys_addr
;
108 mutex_unlock(&adap
->lock
);
109 if (copy_to_user(parg
, &phys_addr
, sizeof(phys_addr
)))
114 static long cec_adap_s_phys_addr(struct cec_adapter
*adap
, struct cec_fh
*fh
,
115 bool block
, __u16 __user
*parg
)
120 if (!(adap
->capabilities
& CEC_CAP_PHYS_ADDR
))
122 if (copy_from_user(&phys_addr
, parg
, sizeof(phys_addr
)))
125 err
= cec_phys_addr_validate(phys_addr
, NULL
, NULL
);
128 mutex_lock(&adap
->lock
);
129 if (cec_is_busy(adap
, fh
))
132 __cec_s_phys_addr(adap
, phys_addr
, block
);
133 mutex_unlock(&adap
->lock
);
137 static long cec_adap_g_log_addrs(struct cec_adapter
*adap
,
138 struct cec_log_addrs __user
*parg
)
140 struct cec_log_addrs log_addrs
;
142 mutex_lock(&adap
->lock
);
143 log_addrs
= adap
->log_addrs
;
144 if (!adap
->is_configured
)
145 memset(log_addrs
.log_addr
, CEC_LOG_ADDR_INVALID
,
146 sizeof(log_addrs
.log_addr
));
147 mutex_unlock(&adap
->lock
);
149 if (copy_to_user(parg
, &log_addrs
, sizeof(log_addrs
)))
154 static long cec_adap_s_log_addrs(struct cec_adapter
*adap
, struct cec_fh
*fh
,
155 bool block
, struct cec_log_addrs __user
*parg
)
157 struct cec_log_addrs log_addrs
;
160 if (!(adap
->capabilities
& CEC_CAP_LOG_ADDRS
))
162 if (copy_from_user(&log_addrs
, parg
, sizeof(log_addrs
)))
165 mutex_lock(&adap
->lock
);
166 if (!adap
->is_configuring
&&
167 (!log_addrs
.num_log_addrs
|| !adap
->is_configured
) &&
168 !cec_is_busy(adap
, fh
)) {
169 err
= __cec_s_log_addrs(adap
, &log_addrs
, block
);
171 log_addrs
= adap
->log_addrs
;
173 mutex_unlock(&adap
->lock
);
176 if (copy_to_user(parg
, &log_addrs
, sizeof(log_addrs
)))
181 static long cec_transmit(struct cec_adapter
*adap
, struct cec_fh
*fh
,
182 bool block
, struct cec_msg __user
*parg
)
184 struct cec_msg msg
= {};
187 if (!(adap
->capabilities
& CEC_CAP_TRANSMIT
))
189 if (copy_from_user(&msg
, parg
, sizeof(msg
)))
191 mutex_lock(&adap
->lock
);
192 if (!adap
->is_configured
) {
194 } else if (cec_is_busy(adap
, fh
)) {
197 if (!block
|| !msg
.reply
)
199 err
= cec_transmit_msg_fh(adap
, &msg
, fh
, block
);
201 mutex_unlock(&adap
->lock
);
204 if (copy_to_user(parg
, &msg
, sizeof(msg
)))
209 /* Called by CEC_RECEIVE: wait for a message to arrive */
210 static int cec_receive_msg(struct cec_fh
*fh
, struct cec_msg
*msg
, bool block
)
215 mutex_lock(&fh
->lock
);
216 /* Are there received messages queued up? */
217 if (fh
->queued_msgs
) {
218 /* Yes, return the first one */
219 struct cec_msg_entry
*entry
=
220 list_first_entry(&fh
->msgs
,
221 struct cec_msg_entry
, list
);
223 list_del(&entry
->list
);
227 mutex_unlock(&fh
->lock
);
231 /* No, return EAGAIN in non-blocking mode or wait */
232 mutex_unlock(&fh
->lock
);
234 /* Return when in non-blocking mode */
239 /* The user specified a timeout */
240 res
= wait_event_interruptible_timeout(fh
->wait
,
242 msecs_to_jiffies(msg
->timeout
));
248 /* Wait indefinitely */
249 res
= wait_event_interruptible(fh
->wait
,
252 /* Exit on error, otherwise loop to get the new message */
257 static long cec_receive(struct cec_adapter
*adap
, struct cec_fh
*fh
,
258 bool block
, struct cec_msg __user
*parg
)
260 struct cec_msg msg
= {};
263 if (copy_from_user(&msg
, parg
, sizeof(msg
)))
265 mutex_lock(&adap
->lock
);
266 if (!adap
->is_configured
&& fh
->mode_follower
< CEC_MODE_MONITOR
)
268 mutex_unlock(&adap
->lock
);
272 err
= cec_receive_msg(fh
, &msg
, block
);
275 if (copy_to_user(parg
, &msg
, sizeof(msg
)))
280 static long cec_dqevent(struct cec_adapter
*adap
, struct cec_fh
*fh
,
281 bool block
, struct cec_event __user
*parg
)
283 struct cec_event
*ev
= NULL
;
288 mutex_lock(&fh
->lock
);
289 while (!fh
->pending_events
&& block
) {
290 mutex_unlock(&fh
->lock
);
291 err
= wait_event_interruptible(fh
->wait
, fh
->pending_events
);
294 mutex_lock(&fh
->lock
);
297 /* Find the oldest event */
298 for (i
= 0; i
< CEC_NUM_EVENTS
; i
++) {
299 if (fh
->pending_events
& (1 << (i
+ 1)) &&
300 fh
->events
[i
].ts
<= ts
) {
310 if (copy_to_user(parg
, ev
, sizeof(*ev
))) {
315 fh
->pending_events
&= ~(1 << ev
->event
);
318 mutex_unlock(&fh
->lock
);
322 static long cec_g_mode(struct cec_adapter
*adap
, struct cec_fh
*fh
,
325 u32 mode
= fh
->mode_initiator
| fh
->mode_follower
;
327 if (copy_to_user(parg
, &mode
, sizeof(mode
)))
332 static long cec_s_mode(struct cec_adapter
*adap
, struct cec_fh
*fh
,
340 if (copy_from_user(&mode
, parg
, sizeof(mode
)))
342 if (mode
& ~(CEC_MODE_INITIATOR_MSK
| CEC_MODE_FOLLOWER_MSK
))
345 mode_initiator
= mode
& CEC_MODE_INITIATOR_MSK
;
346 mode_follower
= mode
& CEC_MODE_FOLLOWER_MSK
;
348 if (mode_initiator
> CEC_MODE_EXCL_INITIATOR
||
349 mode_follower
> CEC_MODE_MONITOR_ALL
)
352 if (mode_follower
== CEC_MODE_MONITOR_ALL
&&
353 !(adap
->capabilities
& CEC_CAP_MONITOR_ALL
))
356 /* Follower modes should always be able to send CEC messages */
357 if ((mode_initiator
== CEC_MODE_NO_INITIATOR
||
358 !(adap
->capabilities
& CEC_CAP_TRANSMIT
)) &&
359 mode_follower
>= CEC_MODE_FOLLOWER
&&
360 mode_follower
<= CEC_MODE_EXCL_FOLLOWER_PASSTHRU
)
363 /* Monitor modes require CEC_MODE_NO_INITIATOR */
364 if (mode_initiator
&& mode_follower
>= CEC_MODE_MONITOR
)
367 /* Monitor modes require CAP_NET_ADMIN */
368 if (mode_follower
>= CEC_MODE_MONITOR
&& !capable(CAP_NET_ADMIN
))
371 mutex_lock(&adap
->lock
);
373 * You can't become exclusive follower if someone else already
376 if ((mode_follower
== CEC_MODE_EXCL_FOLLOWER
||
377 mode_follower
== CEC_MODE_EXCL_FOLLOWER_PASSTHRU
) &&
378 adap
->cec_follower
&& adap
->cec_follower
!= fh
)
381 * You can't become exclusive initiator if someone else already
384 if (mode_initiator
== CEC_MODE_EXCL_INITIATOR
&&
385 adap
->cec_initiator
&& adap
->cec_initiator
!= fh
)
389 bool old_mon_all
= fh
->mode_follower
== CEC_MODE_MONITOR_ALL
;
390 bool new_mon_all
= mode_follower
== CEC_MODE_MONITOR_ALL
;
392 if (old_mon_all
!= new_mon_all
) {
394 err
= cec_monitor_all_cnt_inc(adap
);
396 cec_monitor_all_cnt_dec(adap
);
401 mutex_unlock(&adap
->lock
);
405 if (fh
->mode_follower
== CEC_MODE_FOLLOWER
)
406 adap
->follower_cnt
--;
407 if (mode_follower
== CEC_MODE_FOLLOWER
)
408 adap
->follower_cnt
++;
409 if (mode_follower
== CEC_MODE_EXCL_FOLLOWER
||
410 mode_follower
== CEC_MODE_EXCL_FOLLOWER_PASSTHRU
) {
412 mode_follower
== CEC_MODE_EXCL_FOLLOWER_PASSTHRU
;
413 adap
->cec_follower
= fh
;
414 } else if (adap
->cec_follower
== fh
) {
415 adap
->passthrough
= false;
416 adap
->cec_follower
= NULL
;
418 if (mode_initiator
== CEC_MODE_EXCL_INITIATOR
)
419 adap
->cec_initiator
= fh
;
420 else if (adap
->cec_initiator
== fh
)
421 adap
->cec_initiator
= NULL
;
422 fh
->mode_initiator
= mode_initiator
;
423 fh
->mode_follower
= mode_follower
;
424 mutex_unlock(&adap
->lock
);
428 static long cec_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
430 struct cec_devnode
*devnode
= cec_devnode_data(filp
);
431 struct cec_fh
*fh
= filp
->private_data
;
432 struct cec_adapter
*adap
= fh
->adap
;
433 bool block
= !(filp
->f_flags
& O_NONBLOCK
);
434 void __user
*parg
= (void __user
*)arg
;
436 if (!devnode
->registered
)
440 case CEC_ADAP_G_CAPS
:
441 return cec_adap_g_caps(adap
, parg
);
443 case CEC_ADAP_G_PHYS_ADDR
:
444 return cec_adap_g_phys_addr(adap
, parg
);
446 case CEC_ADAP_S_PHYS_ADDR
:
447 return cec_adap_s_phys_addr(adap
, fh
, block
, parg
);
449 case CEC_ADAP_G_LOG_ADDRS
:
450 return cec_adap_g_log_addrs(adap
, parg
);
452 case CEC_ADAP_S_LOG_ADDRS
:
453 return cec_adap_s_log_addrs(adap
, fh
, block
, parg
);
456 return cec_transmit(adap
, fh
, block
, parg
);
459 return cec_receive(adap
, fh
, block
, parg
);
462 return cec_dqevent(adap
, fh
, block
, parg
);
465 return cec_g_mode(adap
, fh
, parg
);
468 return cec_s_mode(adap
, fh
, parg
);
475 static int cec_open(struct inode
*inode
, struct file
*filp
)
477 struct cec_devnode
*devnode
=
478 container_of(inode
->i_cdev
, struct cec_devnode
, cdev
);
479 struct cec_adapter
*adap
= to_cec_adapter(devnode
);
480 struct cec_fh
*fh
= kzalloc(sizeof(*fh
), GFP_KERNEL
);
482 * Initial events that are automatically sent when the cec device is
485 struct cec_event ev_state
= {
486 .event
= CEC_EVENT_STATE_CHANGE
,
487 .flags
= CEC_EVENT_FL_INITIAL_STATE
,
494 INIT_LIST_HEAD(&fh
->msgs
);
495 INIT_LIST_HEAD(&fh
->xfer_list
);
496 mutex_init(&fh
->lock
);
497 init_waitqueue_head(&fh
->wait
);
499 fh
->mode_initiator
= CEC_MODE_INITIATOR
;
502 err
= cec_get_device(devnode
);
508 filp
->private_data
= fh
;
510 mutex_lock(&devnode
->fhs_lock
);
511 /* Queue up initial state events */
512 ev_state
.state_change
.phys_addr
= adap
->phys_addr
;
513 ev_state
.state_change
.log_addr_mask
= adap
->log_addrs
.log_addr_mask
;
514 cec_queue_event_fh(fh
, &ev_state
, 0);
516 list_add(&fh
->list
, &devnode
->fhs
);
517 mutex_unlock(&devnode
->fhs_lock
);
522 /* Override for the release function */
523 static int cec_release(struct inode
*inode
, struct file
*filp
)
525 struct cec_devnode
*devnode
= cec_devnode_data(filp
);
526 struct cec_adapter
*adap
= to_cec_adapter(devnode
);
527 struct cec_fh
*fh
= filp
->private_data
;
529 mutex_lock(&adap
->lock
);
530 if (adap
->cec_initiator
== fh
)
531 adap
->cec_initiator
= NULL
;
532 if (adap
->cec_follower
== fh
) {
533 adap
->cec_follower
= NULL
;
534 adap
->passthrough
= false;
536 if (fh
->mode_follower
== CEC_MODE_FOLLOWER
)
537 adap
->follower_cnt
--;
538 if (fh
->mode_follower
== CEC_MODE_MONITOR_ALL
)
539 cec_monitor_all_cnt_dec(adap
);
540 mutex_unlock(&adap
->lock
);
542 mutex_lock(&devnode
->fhs_lock
);
544 mutex_unlock(&devnode
->fhs_lock
);
546 /* Unhook pending transmits from this filehandle. */
547 mutex_lock(&adap
->lock
);
548 while (!list_empty(&fh
->xfer_list
)) {
549 struct cec_data
*data
=
550 list_first_entry(&fh
->xfer_list
, struct cec_data
, xfer_list
);
552 data
->blocking
= false;
554 list_del(&data
->xfer_list
);
556 mutex_unlock(&adap
->lock
);
557 while (!list_empty(&fh
->msgs
)) {
558 struct cec_msg_entry
*entry
=
559 list_first_entry(&fh
->msgs
, struct cec_msg_entry
, list
);
561 list_del(&entry
->list
);
566 cec_put_device(devnode
);
567 filp
->private_data
= NULL
;
571 const struct file_operations cec_devnode_fops
= {
572 .owner
= THIS_MODULE
,
574 .unlocked_ioctl
= cec_ioctl
,
575 .release
= cec_release
,