Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2015-2018, Intel Corporation.
4 * Copyright (c) 2021, IBM Corp.
5 */
6
7#include <linux/device.h>
8#include <linux/list.h>
9#include <linux/module.h>
10#include <linux/mutex.h>
11
12#include "kcs_bmc.h"
13
14/* Implement both the device and client interfaces here */
15#include "kcs_bmc_device.h"
16#include "kcs_bmc_client.h"
17
18/* Record registered devices and drivers */
19static DEFINE_MUTEX(kcs_bmc_lock);
20static LIST_HEAD(kcs_bmc_devices);
21static LIST_HEAD(kcs_bmc_drivers);
22
23/* Consumer data access */
24
25u8 kcs_bmc_read_data(struct kcs_bmc_device *kcs_bmc)
26{
27 return kcs_bmc->ops->io_inputb(kcs_bmc, kcs_bmc->ioreg.idr);
28}
29EXPORT_SYMBOL(kcs_bmc_read_data);
30
31void kcs_bmc_write_data(struct kcs_bmc_device *kcs_bmc, u8 data)
32{
33 kcs_bmc->ops->io_outputb(kcs_bmc, kcs_bmc->ioreg.odr, data);
34}
35EXPORT_SYMBOL(kcs_bmc_write_data);
36
37u8 kcs_bmc_read_status(struct kcs_bmc_device *kcs_bmc)
38{
39 return kcs_bmc->ops->io_inputb(kcs_bmc, kcs_bmc->ioreg.str);
40}
41EXPORT_SYMBOL(kcs_bmc_read_status);
42
43void kcs_bmc_write_status(struct kcs_bmc_device *kcs_bmc, u8 data)
44{
45 kcs_bmc->ops->io_outputb(kcs_bmc, kcs_bmc->ioreg.str, data);
46}
47EXPORT_SYMBOL(kcs_bmc_write_status);
48
49void kcs_bmc_update_status(struct kcs_bmc_device *kcs_bmc, u8 mask, u8 val)
50{
51 kcs_bmc->ops->io_updateb(kcs_bmc, kcs_bmc->ioreg.str, mask, val);
52}
53EXPORT_SYMBOL(kcs_bmc_update_status);
54
55irqreturn_t kcs_bmc_handle_event(struct kcs_bmc_device *kcs_bmc)
56{
57 struct kcs_bmc_client *client;
58 irqreturn_t rc = IRQ_NONE;
59 unsigned long flags;
60
61 spin_lock_irqsave(&kcs_bmc->lock, flags);
62 client = kcs_bmc->client;
63 if (client)
64 rc = client->ops->event(client);
65 spin_unlock_irqrestore(&kcs_bmc->lock, flags);
66
67 return rc;
68}
69EXPORT_SYMBOL(kcs_bmc_handle_event);
70
71int kcs_bmc_enable_device(struct kcs_bmc_device *kcs_bmc, struct kcs_bmc_client *client)
72{
73 int rc;
74
75 spin_lock_irq(&kcs_bmc->lock);
76 if (kcs_bmc->client) {
77 rc = -EBUSY;
78 } else {
79 u8 mask = KCS_BMC_EVENT_TYPE_IBF;
80
81 kcs_bmc->client = client;
82 kcs_bmc_update_event_mask(kcs_bmc, mask, mask);
83 rc = 0;
84 }
85 spin_unlock_irq(&kcs_bmc->lock);
86
87 return rc;
88}
89EXPORT_SYMBOL(kcs_bmc_enable_device);
90
91void kcs_bmc_disable_device(struct kcs_bmc_device *kcs_bmc, struct kcs_bmc_client *client)
92{
93 spin_lock_irq(&kcs_bmc->lock);
94 if (client == kcs_bmc->client) {
95 u8 mask = KCS_BMC_EVENT_TYPE_IBF | KCS_BMC_EVENT_TYPE_OBE;
96
97 kcs_bmc_update_event_mask(kcs_bmc, mask, 0);
98 kcs_bmc->client = NULL;
99 }
100 spin_unlock_irq(&kcs_bmc->lock);
101}
102EXPORT_SYMBOL(kcs_bmc_disable_device);
103
104int kcs_bmc_add_device(struct kcs_bmc_device *kcs_bmc)
105{
106 struct kcs_bmc_driver *drv;
107 int error = 0;
108 int rc;
109
110 spin_lock_init(&kcs_bmc->lock);
111 kcs_bmc->client = NULL;
112
113 mutex_lock(&kcs_bmc_lock);
114 list_add(&kcs_bmc->entry, &kcs_bmc_devices);
115 list_for_each_entry(drv, &kcs_bmc_drivers, entry) {
116 rc = drv->ops->add_device(kcs_bmc);
117 if (!rc)
118 continue;
119
120 dev_err(kcs_bmc->dev, "Failed to add chardev for KCS channel %d: %d",
121 kcs_bmc->channel, rc);
122 error = rc;
123 }
124 mutex_unlock(&kcs_bmc_lock);
125
126 return error;
127}
128EXPORT_SYMBOL(kcs_bmc_add_device);
129
130void kcs_bmc_remove_device(struct kcs_bmc_device *kcs_bmc)
131{
132 struct kcs_bmc_driver *drv;
133 int rc;
134
135 mutex_lock(&kcs_bmc_lock);
136 list_del(&kcs_bmc->entry);
137 list_for_each_entry(drv, &kcs_bmc_drivers, entry) {
138 rc = drv->ops->remove_device(kcs_bmc);
139 if (rc)
140 dev_err(kcs_bmc->dev, "Failed to remove chardev for KCS channel %d: %d",
141 kcs_bmc->channel, rc);
142 }
143 mutex_unlock(&kcs_bmc_lock);
144}
145EXPORT_SYMBOL(kcs_bmc_remove_device);
146
147void kcs_bmc_register_driver(struct kcs_bmc_driver *drv)
148{
149 struct kcs_bmc_device *kcs_bmc;
150 int rc;
151
152 mutex_lock(&kcs_bmc_lock);
153 list_add(&drv->entry, &kcs_bmc_drivers);
154 list_for_each_entry(kcs_bmc, &kcs_bmc_devices, entry) {
155 rc = drv->ops->add_device(kcs_bmc);
156 if (rc)
157 dev_err(kcs_bmc->dev, "Failed to add driver for KCS channel %d: %d",
158 kcs_bmc->channel, rc);
159 }
160 mutex_unlock(&kcs_bmc_lock);
161}
162EXPORT_SYMBOL(kcs_bmc_register_driver);
163
164void kcs_bmc_unregister_driver(struct kcs_bmc_driver *drv)
165{
166 struct kcs_bmc_device *kcs_bmc;
167 int rc;
168
169 mutex_lock(&kcs_bmc_lock);
170 list_del(&drv->entry);
171 list_for_each_entry(kcs_bmc, &kcs_bmc_devices, entry) {
172 rc = drv->ops->remove_device(kcs_bmc);
173 if (rc)
174 dev_err(kcs_bmc->dev, "Failed to remove driver for KCS channel %d: %d",
175 kcs_bmc->channel, rc);
176 }
177 mutex_unlock(&kcs_bmc_lock);
178}
179EXPORT_SYMBOL(kcs_bmc_unregister_driver);
180
181void kcs_bmc_update_event_mask(struct kcs_bmc_device *kcs_bmc, u8 mask, u8 events)
182{
183 kcs_bmc->ops->irq_mask_update(kcs_bmc, mask, events);
184}
185EXPORT_SYMBOL(kcs_bmc_update_event_mask);
186
187MODULE_LICENSE("GPL v2");
188MODULE_AUTHOR("Haiyue Wang <haiyue.wang@linux.intel.com>");
189MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
190MODULE_DESCRIPTION("KCS BMC to handle the IPMI request from system software");
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2015-2018, Intel Corporation.
4 */
5
6#define pr_fmt(fmt) "kcs-bmc: " fmt
7
8#include <linux/errno.h>
9#include <linux/io.h>
10#include <linux/ipmi_bmc.h>
11#include <linux/module.h>
12#include <linux/platform_device.h>
13#include <linux/poll.h>
14#include <linux/sched.h>
15#include <linux/slab.h>
16
17#include "kcs_bmc.h"
18
19#define DEVICE_NAME "ipmi-kcs"
20
21#define KCS_MSG_BUFSIZ 1000
22
23#define KCS_ZERO_DATA 0
24
25
26/* IPMI 2.0 - Table 9-1, KCS Interface Status Register Bits */
27#define KCS_STATUS_STATE(state) (state << 6)
28#define KCS_STATUS_STATE_MASK GENMASK(7, 6)
29#define KCS_STATUS_CMD_DAT BIT(3)
30#define KCS_STATUS_SMS_ATN BIT(2)
31#define KCS_STATUS_IBF BIT(1)
32#define KCS_STATUS_OBF BIT(0)
33
34/* IPMI 2.0 - Table 9-2, KCS Interface State Bits */
35enum kcs_states {
36 IDLE_STATE = 0,
37 READ_STATE = 1,
38 WRITE_STATE = 2,
39 ERROR_STATE = 3,
40};
41
42/* IPMI 2.0 - Table 9-3, KCS Interface Control Codes */
43#define KCS_CMD_GET_STATUS_ABORT 0x60
44#define KCS_CMD_WRITE_START 0x61
45#define KCS_CMD_WRITE_END 0x62
46#define KCS_CMD_READ_BYTE 0x68
47
48static inline u8 read_data(struct kcs_bmc *kcs_bmc)
49{
50 return kcs_bmc->io_inputb(kcs_bmc, kcs_bmc->ioreg.idr);
51}
52
53static inline void write_data(struct kcs_bmc *kcs_bmc, u8 data)
54{
55 kcs_bmc->io_outputb(kcs_bmc, kcs_bmc->ioreg.odr, data);
56}
57
58static inline u8 read_status(struct kcs_bmc *kcs_bmc)
59{
60 return kcs_bmc->io_inputb(kcs_bmc, kcs_bmc->ioreg.str);
61}
62
63static inline void write_status(struct kcs_bmc *kcs_bmc, u8 data)
64{
65 kcs_bmc->io_outputb(kcs_bmc, kcs_bmc->ioreg.str, data);
66}
67
68static void update_status_bits(struct kcs_bmc *kcs_bmc, u8 mask, u8 val)
69{
70 u8 tmp = read_status(kcs_bmc);
71
72 tmp &= ~mask;
73 tmp |= val & mask;
74
75 write_status(kcs_bmc, tmp);
76}
77
78static inline void set_state(struct kcs_bmc *kcs_bmc, u8 state)
79{
80 update_status_bits(kcs_bmc, KCS_STATUS_STATE_MASK,
81 KCS_STATUS_STATE(state));
82}
83
84static void kcs_force_abort(struct kcs_bmc *kcs_bmc)
85{
86 set_state(kcs_bmc, ERROR_STATE);
87 read_data(kcs_bmc);
88 write_data(kcs_bmc, KCS_ZERO_DATA);
89
90 kcs_bmc->phase = KCS_PHASE_ERROR;
91 kcs_bmc->data_in_avail = false;
92 kcs_bmc->data_in_idx = 0;
93}
94
95static void kcs_bmc_handle_data(struct kcs_bmc *kcs_bmc)
96{
97 u8 data;
98
99 switch (kcs_bmc->phase) {
100 case KCS_PHASE_WRITE_START:
101 kcs_bmc->phase = KCS_PHASE_WRITE_DATA;
102 fallthrough;
103
104 case KCS_PHASE_WRITE_DATA:
105 if (kcs_bmc->data_in_idx < KCS_MSG_BUFSIZ) {
106 set_state(kcs_bmc, WRITE_STATE);
107 write_data(kcs_bmc, KCS_ZERO_DATA);
108 kcs_bmc->data_in[kcs_bmc->data_in_idx++] =
109 read_data(kcs_bmc);
110 } else {
111 kcs_force_abort(kcs_bmc);
112 kcs_bmc->error = KCS_LENGTH_ERROR;
113 }
114 break;
115
116 case KCS_PHASE_WRITE_END_CMD:
117 if (kcs_bmc->data_in_idx < KCS_MSG_BUFSIZ) {
118 set_state(kcs_bmc, READ_STATE);
119 kcs_bmc->data_in[kcs_bmc->data_in_idx++] =
120 read_data(kcs_bmc);
121 kcs_bmc->phase = KCS_PHASE_WRITE_DONE;
122 kcs_bmc->data_in_avail = true;
123 wake_up_interruptible(&kcs_bmc->queue);
124 } else {
125 kcs_force_abort(kcs_bmc);
126 kcs_bmc->error = KCS_LENGTH_ERROR;
127 }
128 break;
129
130 case KCS_PHASE_READ:
131 if (kcs_bmc->data_out_idx == kcs_bmc->data_out_len)
132 set_state(kcs_bmc, IDLE_STATE);
133
134 data = read_data(kcs_bmc);
135 if (data != KCS_CMD_READ_BYTE) {
136 set_state(kcs_bmc, ERROR_STATE);
137 write_data(kcs_bmc, KCS_ZERO_DATA);
138 break;
139 }
140
141 if (kcs_bmc->data_out_idx == kcs_bmc->data_out_len) {
142 write_data(kcs_bmc, KCS_ZERO_DATA);
143 kcs_bmc->phase = KCS_PHASE_IDLE;
144 break;
145 }
146
147 write_data(kcs_bmc,
148 kcs_bmc->data_out[kcs_bmc->data_out_idx++]);
149 break;
150
151 case KCS_PHASE_ABORT_ERROR1:
152 set_state(kcs_bmc, READ_STATE);
153 read_data(kcs_bmc);
154 write_data(kcs_bmc, kcs_bmc->error);
155 kcs_bmc->phase = KCS_PHASE_ABORT_ERROR2;
156 break;
157
158 case KCS_PHASE_ABORT_ERROR2:
159 set_state(kcs_bmc, IDLE_STATE);
160 read_data(kcs_bmc);
161 write_data(kcs_bmc, KCS_ZERO_DATA);
162 kcs_bmc->phase = KCS_PHASE_IDLE;
163 break;
164
165 default:
166 kcs_force_abort(kcs_bmc);
167 break;
168 }
169}
170
171static void kcs_bmc_handle_cmd(struct kcs_bmc *kcs_bmc)
172{
173 u8 cmd;
174
175 set_state(kcs_bmc, WRITE_STATE);
176 write_data(kcs_bmc, KCS_ZERO_DATA);
177
178 cmd = read_data(kcs_bmc);
179 switch (cmd) {
180 case KCS_CMD_WRITE_START:
181 kcs_bmc->phase = KCS_PHASE_WRITE_START;
182 kcs_bmc->error = KCS_NO_ERROR;
183 kcs_bmc->data_in_avail = false;
184 kcs_bmc->data_in_idx = 0;
185 break;
186
187 case KCS_CMD_WRITE_END:
188 if (kcs_bmc->phase != KCS_PHASE_WRITE_DATA) {
189 kcs_force_abort(kcs_bmc);
190 break;
191 }
192
193 kcs_bmc->phase = KCS_PHASE_WRITE_END_CMD;
194 break;
195
196 case KCS_CMD_GET_STATUS_ABORT:
197 if (kcs_bmc->error == KCS_NO_ERROR)
198 kcs_bmc->error = KCS_ABORTED_BY_COMMAND;
199
200 kcs_bmc->phase = KCS_PHASE_ABORT_ERROR1;
201 kcs_bmc->data_in_avail = false;
202 kcs_bmc->data_in_idx = 0;
203 break;
204
205 default:
206 kcs_force_abort(kcs_bmc);
207 kcs_bmc->error = KCS_ILLEGAL_CONTROL_CODE;
208 break;
209 }
210}
211
212int kcs_bmc_handle_event(struct kcs_bmc *kcs_bmc)
213{
214 unsigned long flags;
215 int ret = -ENODATA;
216 u8 status;
217
218 spin_lock_irqsave(&kcs_bmc->lock, flags);
219
220 status = read_status(kcs_bmc);
221 if (status & KCS_STATUS_IBF) {
222 if (!kcs_bmc->running)
223 kcs_force_abort(kcs_bmc);
224 else if (status & KCS_STATUS_CMD_DAT)
225 kcs_bmc_handle_cmd(kcs_bmc);
226 else
227 kcs_bmc_handle_data(kcs_bmc);
228
229 ret = 0;
230 }
231
232 spin_unlock_irqrestore(&kcs_bmc->lock, flags);
233
234 return ret;
235}
236EXPORT_SYMBOL(kcs_bmc_handle_event);
237
238static inline struct kcs_bmc *to_kcs_bmc(struct file *filp)
239{
240 return container_of(filp->private_data, struct kcs_bmc, miscdev);
241}
242
243static int kcs_bmc_open(struct inode *inode, struct file *filp)
244{
245 struct kcs_bmc *kcs_bmc = to_kcs_bmc(filp);
246 int ret = 0;
247
248 spin_lock_irq(&kcs_bmc->lock);
249 if (!kcs_bmc->running)
250 kcs_bmc->running = 1;
251 else
252 ret = -EBUSY;
253 spin_unlock_irq(&kcs_bmc->lock);
254
255 return ret;
256}
257
258static __poll_t kcs_bmc_poll(struct file *filp, poll_table *wait)
259{
260 struct kcs_bmc *kcs_bmc = to_kcs_bmc(filp);
261 __poll_t mask = 0;
262
263 poll_wait(filp, &kcs_bmc->queue, wait);
264
265 spin_lock_irq(&kcs_bmc->lock);
266 if (kcs_bmc->data_in_avail)
267 mask |= EPOLLIN;
268 spin_unlock_irq(&kcs_bmc->lock);
269
270 return mask;
271}
272
273static ssize_t kcs_bmc_read(struct file *filp, char __user *buf,
274 size_t count, loff_t *ppos)
275{
276 struct kcs_bmc *kcs_bmc = to_kcs_bmc(filp);
277 bool data_avail;
278 size_t data_len;
279 ssize_t ret;
280
281 if (!(filp->f_flags & O_NONBLOCK))
282 wait_event_interruptible(kcs_bmc->queue,
283 kcs_bmc->data_in_avail);
284
285 mutex_lock(&kcs_bmc->mutex);
286
287 spin_lock_irq(&kcs_bmc->lock);
288 data_avail = kcs_bmc->data_in_avail;
289 if (data_avail) {
290 data_len = kcs_bmc->data_in_idx;
291 memcpy(kcs_bmc->kbuffer, kcs_bmc->data_in, data_len);
292 }
293 spin_unlock_irq(&kcs_bmc->lock);
294
295 if (!data_avail) {
296 ret = -EAGAIN;
297 goto out_unlock;
298 }
299
300 if (count < data_len) {
301 pr_err("channel=%u with too large data : %zu\n",
302 kcs_bmc->channel, data_len);
303
304 spin_lock_irq(&kcs_bmc->lock);
305 kcs_force_abort(kcs_bmc);
306 spin_unlock_irq(&kcs_bmc->lock);
307
308 ret = -EOVERFLOW;
309 goto out_unlock;
310 }
311
312 if (copy_to_user(buf, kcs_bmc->kbuffer, data_len)) {
313 ret = -EFAULT;
314 goto out_unlock;
315 }
316
317 ret = data_len;
318
319 spin_lock_irq(&kcs_bmc->lock);
320 if (kcs_bmc->phase == KCS_PHASE_WRITE_DONE) {
321 kcs_bmc->phase = KCS_PHASE_WAIT_READ;
322 kcs_bmc->data_in_avail = false;
323 kcs_bmc->data_in_idx = 0;
324 } else {
325 ret = -EAGAIN;
326 }
327 spin_unlock_irq(&kcs_bmc->lock);
328
329out_unlock:
330 mutex_unlock(&kcs_bmc->mutex);
331
332 return ret;
333}
334
335static ssize_t kcs_bmc_write(struct file *filp, const char __user *buf,
336 size_t count, loff_t *ppos)
337{
338 struct kcs_bmc *kcs_bmc = to_kcs_bmc(filp);
339 ssize_t ret;
340
341 /* a minimum response size '3' : netfn + cmd + ccode */
342 if (count < 3 || count > KCS_MSG_BUFSIZ)
343 return -EINVAL;
344
345 mutex_lock(&kcs_bmc->mutex);
346
347 if (copy_from_user(kcs_bmc->kbuffer, buf, count)) {
348 ret = -EFAULT;
349 goto out_unlock;
350 }
351
352 spin_lock_irq(&kcs_bmc->lock);
353 if (kcs_bmc->phase == KCS_PHASE_WAIT_READ) {
354 kcs_bmc->phase = KCS_PHASE_READ;
355 kcs_bmc->data_out_idx = 1;
356 kcs_bmc->data_out_len = count;
357 memcpy(kcs_bmc->data_out, kcs_bmc->kbuffer, count);
358 write_data(kcs_bmc, kcs_bmc->data_out[0]);
359 ret = count;
360 } else {
361 ret = -EINVAL;
362 }
363 spin_unlock_irq(&kcs_bmc->lock);
364
365out_unlock:
366 mutex_unlock(&kcs_bmc->mutex);
367
368 return ret;
369}
370
371static long kcs_bmc_ioctl(struct file *filp, unsigned int cmd,
372 unsigned long arg)
373{
374 struct kcs_bmc *kcs_bmc = to_kcs_bmc(filp);
375 long ret = 0;
376
377 spin_lock_irq(&kcs_bmc->lock);
378
379 switch (cmd) {
380 case IPMI_BMC_IOCTL_SET_SMS_ATN:
381 update_status_bits(kcs_bmc, KCS_STATUS_SMS_ATN,
382 KCS_STATUS_SMS_ATN);
383 break;
384
385 case IPMI_BMC_IOCTL_CLEAR_SMS_ATN:
386 update_status_bits(kcs_bmc, KCS_STATUS_SMS_ATN,
387 0);
388 break;
389
390 case IPMI_BMC_IOCTL_FORCE_ABORT:
391 kcs_force_abort(kcs_bmc);
392 break;
393
394 default:
395 ret = -EINVAL;
396 break;
397 }
398
399 spin_unlock_irq(&kcs_bmc->lock);
400
401 return ret;
402}
403
404static int kcs_bmc_release(struct inode *inode, struct file *filp)
405{
406 struct kcs_bmc *kcs_bmc = to_kcs_bmc(filp);
407
408 spin_lock_irq(&kcs_bmc->lock);
409 kcs_bmc->running = 0;
410 kcs_force_abort(kcs_bmc);
411 spin_unlock_irq(&kcs_bmc->lock);
412
413 return 0;
414}
415
416static const struct file_operations kcs_bmc_fops = {
417 .owner = THIS_MODULE,
418 .open = kcs_bmc_open,
419 .read = kcs_bmc_read,
420 .write = kcs_bmc_write,
421 .release = kcs_bmc_release,
422 .poll = kcs_bmc_poll,
423 .unlocked_ioctl = kcs_bmc_ioctl,
424};
425
426struct kcs_bmc *kcs_bmc_alloc(struct device *dev, int sizeof_priv, u32 channel)
427{
428 struct kcs_bmc *kcs_bmc;
429
430 kcs_bmc = devm_kzalloc(dev, sizeof(*kcs_bmc) + sizeof_priv, GFP_KERNEL);
431 if (!kcs_bmc)
432 return NULL;
433
434 spin_lock_init(&kcs_bmc->lock);
435 kcs_bmc->channel = channel;
436
437 mutex_init(&kcs_bmc->mutex);
438 init_waitqueue_head(&kcs_bmc->queue);
439
440 kcs_bmc->data_in = devm_kmalloc(dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
441 kcs_bmc->data_out = devm_kmalloc(dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
442 kcs_bmc->kbuffer = devm_kmalloc(dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
443
444 kcs_bmc->miscdev.minor = MISC_DYNAMIC_MINOR;
445 kcs_bmc->miscdev.name = devm_kasprintf(dev, GFP_KERNEL, "%s%u",
446 DEVICE_NAME, channel);
447 if (!kcs_bmc->data_in || !kcs_bmc->data_out || !kcs_bmc->kbuffer ||
448 !kcs_bmc->miscdev.name)
449 return NULL;
450 kcs_bmc->miscdev.fops = &kcs_bmc_fops;
451
452 return kcs_bmc;
453}
454EXPORT_SYMBOL(kcs_bmc_alloc);
455
456MODULE_LICENSE("GPL v2");
457MODULE_AUTHOR("Haiyue Wang <haiyue.wang@linux.intel.com>");
458MODULE_DESCRIPTION("KCS BMC to handle the IPMI request from system software");