1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* Copyright (c) 2021 IBM Corp. */ |
3 | |
4 | #include <linux/delay.h> |
5 | #include <linux/device.h> |
6 | #include <linux/errno.h> |
7 | #include <linux/list.h> |
8 | #include <linux/module.h> |
9 | #include <linux/sched/signal.h> |
10 | #include <linux/serio.h> |
11 | #include <linux/slab.h> |
12 | |
13 | #include "kcs_bmc_client.h" |
14 | |
15 | struct kcs_bmc_serio { |
16 | struct list_head entry; |
17 | |
18 | struct kcs_bmc_client client; |
19 | struct serio *port; |
20 | |
21 | spinlock_t lock; |
22 | }; |
23 | |
24 | static inline struct kcs_bmc_serio *client_to_kcs_bmc_serio(struct kcs_bmc_client *client) |
25 | { |
26 | return container_of(client, struct kcs_bmc_serio, client); |
27 | } |
28 | |
29 | static irqreturn_t kcs_bmc_serio_event(struct kcs_bmc_client *client) |
30 | { |
31 | struct kcs_bmc_serio *priv; |
32 | u8 handled = IRQ_NONE; |
33 | u8 status; |
34 | |
35 | priv = client_to_kcs_bmc_serio(client); |
36 | |
37 | spin_lock(lock: &priv->lock); |
38 | |
39 | status = kcs_bmc_read_status(kcs_bmc: client->dev); |
40 | |
41 | if (status & KCS_BMC_STR_IBF) |
42 | handled = serio_interrupt(serio: priv->port, data: kcs_bmc_read_data(kcs_bmc: client->dev), flags: 0); |
43 | |
44 | spin_unlock(lock: &priv->lock); |
45 | |
46 | return handled; |
47 | } |
48 | |
49 | static const struct kcs_bmc_client_ops kcs_bmc_serio_client_ops = { |
50 | .event = kcs_bmc_serio_event, |
51 | }; |
52 | |
53 | static int kcs_bmc_serio_open(struct serio *port) |
54 | { |
55 | struct kcs_bmc_serio *priv = port->port_data; |
56 | |
57 | return kcs_bmc_enable_device(kcs_bmc: priv->client.dev, client: &priv->client); |
58 | } |
59 | |
60 | static void kcs_bmc_serio_close(struct serio *port) |
61 | { |
62 | struct kcs_bmc_serio *priv = port->port_data; |
63 | |
64 | kcs_bmc_disable_device(kcs_bmc: priv->client.dev, client: &priv->client); |
65 | } |
66 | |
67 | static DEFINE_SPINLOCK(kcs_bmc_serio_instances_lock); |
68 | static LIST_HEAD(kcs_bmc_serio_instances); |
69 | |
70 | static int kcs_bmc_serio_add_device(struct kcs_bmc_device *kcs_bmc) |
71 | { |
72 | struct kcs_bmc_serio *priv; |
73 | struct serio *port; |
74 | |
75 | priv = devm_kzalloc(dev: kcs_bmc->dev, size: sizeof(*priv), GFP_KERNEL); |
76 | if (!priv) |
77 | return -ENOMEM; |
78 | |
79 | /* Use kzalloc() as the allocation is cleaned up with kfree() via serio_unregister_port() */ |
80 | port = kzalloc(size: sizeof(*port), GFP_KERNEL); |
81 | if (!port) |
82 | return -ENOMEM; |
83 | |
84 | port->id.type = SERIO_8042; |
85 | port->open = kcs_bmc_serio_open; |
86 | port->close = kcs_bmc_serio_close; |
87 | port->port_data = priv; |
88 | port->dev.parent = kcs_bmc->dev; |
89 | |
90 | spin_lock_init(&priv->lock); |
91 | priv->port = port; |
92 | priv->client.dev = kcs_bmc; |
93 | priv->client.ops = &kcs_bmc_serio_client_ops; |
94 | |
95 | spin_lock_irq(lock: &kcs_bmc_serio_instances_lock); |
96 | list_add(new: &priv->entry, head: &kcs_bmc_serio_instances); |
97 | spin_unlock_irq(lock: &kcs_bmc_serio_instances_lock); |
98 | |
99 | serio_register_port(port); |
100 | |
101 | dev_info(kcs_bmc->dev, "Initialised serio client for channel %d" , kcs_bmc->channel); |
102 | |
103 | return 0; |
104 | } |
105 | |
106 | static int kcs_bmc_serio_remove_device(struct kcs_bmc_device *kcs_bmc) |
107 | { |
108 | struct kcs_bmc_serio *priv = NULL, *pos; |
109 | |
110 | spin_lock_irq(lock: &kcs_bmc_serio_instances_lock); |
111 | list_for_each_entry(pos, &kcs_bmc_serio_instances, entry) { |
112 | if (pos->client.dev == kcs_bmc) { |
113 | priv = pos; |
114 | list_del(entry: &pos->entry); |
115 | break; |
116 | } |
117 | } |
118 | spin_unlock_irq(lock: &kcs_bmc_serio_instances_lock); |
119 | |
120 | if (!priv) |
121 | return -ENODEV; |
122 | |
123 | /* kfree()s priv->port via put_device() */ |
124 | serio_unregister_port(serio: priv->port); |
125 | |
126 | /* Ensure the IBF IRQ is disabled if we were the active client */ |
127 | kcs_bmc_disable_device(kcs_bmc, client: &priv->client); |
128 | |
129 | devm_kfree(dev: priv->client.dev->dev, p: priv); |
130 | |
131 | return 0; |
132 | } |
133 | |
134 | static const struct kcs_bmc_driver_ops kcs_bmc_serio_driver_ops = { |
135 | .add_device = kcs_bmc_serio_add_device, |
136 | .remove_device = kcs_bmc_serio_remove_device, |
137 | }; |
138 | |
139 | static struct kcs_bmc_driver kcs_bmc_serio_driver = { |
140 | .ops = &kcs_bmc_serio_driver_ops, |
141 | }; |
142 | |
143 | static int __init kcs_bmc_serio_init(void) |
144 | { |
145 | kcs_bmc_register_driver(drv: &kcs_bmc_serio_driver); |
146 | |
147 | return 0; |
148 | } |
149 | module_init(kcs_bmc_serio_init); |
150 | |
151 | static void __exit kcs_bmc_serio_exit(void) |
152 | { |
153 | kcs_bmc_unregister_driver(drv: &kcs_bmc_serio_driver); |
154 | } |
155 | module_exit(kcs_bmc_serio_exit); |
156 | |
157 | MODULE_LICENSE("GPL v2" ); |
158 | MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>" ); |
159 | MODULE_DESCRIPTION("Adapter driver for serio access to BMC KCS devices" ); |
160 | |