source: mainline/uspace/drv/bus/isa/isa.c@ 38d150e

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 38d150e was 38d150e, checked in by Jiri Svoboda <jiri@…>, 8 years ago

Prefer to get memory allocation functions through the standard stdlib header.
  • Property mode set to 100644
File size: 18.7 KB
Line 
1/*
2 * Copyright (c) 2010 Lenka Trochtova
3 * Copyright (c) 2011 Jiri Svoboda
4 * Copyright (c) 2011 Jan Vesely
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * - Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * - Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * - The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31/**
32 * @defgroup isa ISA bus driver.
33 * @brief HelenOS ISA bus driver.
34 * @{
35 */
36
37/** @file
38 */
39
40#include <adt/list.h>
41#include <assert.h>
42#include <stdio.h>
43#include <errno.h>
44#include <stdbool.h>
45#include <fibril_synch.h>
46#include <stdlib.h>
47#include <str.h>
48#include <str_error.h>
49#include <ctype.h>
50#include <macros.h>
51#include <stdlib.h>
52#include <dirent.h>
53#include <ipc/irc.h>
54#include <ipc/services.h>
55#include <vfs/vfs.h>
56#include <irc.h>
57#include <ns.h>
58
59#include <ddf/driver.h>
60#include <ddf/log.h>
61#include <ops/hw_res.h>
62#include <ops/pio_window.h>
63
64#include <device/hw_res.h>
65#include <device/pio_window.h>
66
67#include <pci_dev_iface.h>
68
69#include "i8237.h"
70
71#define NAME "isa"
72#define ISA_CHILD_FUN_CONF_PATH "/drv/isa/isa.dev"
73#define EBUS_CHILD_FUN_CONF_PATH "/drv/isa/ebus.dev"
74
75#define ISA_MAX_HW_RES 5
76
77typedef struct {
78 fibril_mutex_t mutex;
79 uint16_t pci_vendor_id;
80 uint16_t pci_device_id;
81 uint8_t pci_class;
82 uint8_t pci_subclass;
83 ddf_dev_t *dev;
84 ddf_fun_t *fctl;
85 pio_window_t pio_win;
86 list_t functions;
87} isa_bus_t;
88
89typedef struct isa_fun {
90 fibril_mutex_t mutex;
91 ddf_fun_t *fnode;
92 hw_resource_t resources[ISA_MAX_HW_RES];
93 hw_resource_list_t hw_resources;
94 link_t bus_link;
95} isa_fun_t;
96
97/** Obtain soft-state from device node */
98static isa_bus_t *isa_bus(ddf_dev_t *dev)
99{
100 return ddf_dev_data_get(dev);
101}
102
103/** Obtain soft-state from function node */
104static isa_fun_t *isa_fun(ddf_fun_t *fun)
105{
106 return ddf_fun_data_get(fun);
107}
108
109static hw_resource_list_t *isa_fun_get_resources(ddf_fun_t *fnode)
110{
111 isa_fun_t *fun = isa_fun(fnode);
112 assert(fun);
113
114 return &fun->hw_resources;
115}
116
117static bool isa_fun_owns_interrupt(isa_fun_t *fun, int irq)
118{
119 const hw_resource_list_t *res = &fun->hw_resources;
120
121 /* Check that specified irq really belongs to the function */
122 for (size_t i = 0; i < res->count; ++i) {
123 if (res->resources[i].type == INTERRUPT &&
124 res->resources[i].res.interrupt.irq == irq) {
125 return true;
126 }
127 }
128
129 return false;
130}
131
132static int isa_fun_enable_interrupt(ddf_fun_t *fnode, int irq)
133{
134 isa_fun_t *fun = isa_fun(fnode);
135
136 if (!isa_fun_owns_interrupt(fun, irq))
137 return EINVAL;
138
139 return irc_enable_interrupt(irq);
140}
141
142static int isa_fun_disable_interrupt(ddf_fun_t *fnode, int irq)
143{
144 isa_fun_t *fun = isa_fun(fnode);
145
146 if (!isa_fun_owns_interrupt(fun, irq))
147 return EINVAL;
148
149 return irc_disable_interrupt(irq);
150}
151
152static int isa_fun_clear_interrupt(ddf_fun_t *fnode, int irq)
153{
154 isa_fun_t *fun = isa_fun(fnode);
155
156 if (!isa_fun_owns_interrupt(fun, irq))
157 return EINVAL;
158
159 return irc_clear_interrupt(irq);
160}
161
162static int isa_fun_setup_dma(ddf_fun_t *fnode,
163 unsigned int channel, uint32_t pa, uint32_t size, uint8_t mode)
164{
165 assert(fnode);
166 isa_fun_t *fun = isa_fun(fnode);
167 assert(fun);
168 const hw_resource_list_t *res = &fun->hw_resources;
169 assert(res);
170
171 for (size_t i = 0; i < res->count; ++i) {
172 /* Check for assigned channel */
173 if (((res->resources[i].type == DMA_CHANNEL_16) &&
174 (res->resources[i].res.dma_channel.dma16 == channel)) ||
175 ((res->resources[i].type == DMA_CHANNEL_8) &&
176 (res->resources[i].res.dma_channel.dma8 == channel))) {
177 return dma_channel_setup(channel, pa, size, mode);
178 }
179 }
180
181 return EINVAL;
182}
183
184static int isa_fun_remain_dma(ddf_fun_t *fnode,
185 unsigned channel, size_t *size)
186{
187 assert(size);
188 assert(fnode);
189 isa_fun_t *fun = isa_fun(fnode);
190 assert(fun);
191 const hw_resource_list_t *res = &fun->hw_resources;
192 assert(res);
193
194 for (size_t i = 0; i < res->count; ++i) {
195 /* Check for assigned channel */
196 if (((res->resources[i].type == DMA_CHANNEL_16) &&
197 (res->resources[i].res.dma_channel.dma16 == channel)) ||
198 ((res->resources[i].type == DMA_CHANNEL_8) &&
199 (res->resources[i].res.dma_channel.dma8 == channel))) {
200 return dma_channel_remain(channel, size);
201 }
202 }
203
204 return EINVAL;
205}
206
207static hw_res_ops_t isa_fun_hw_res_ops = {
208 .get_resource_list = isa_fun_get_resources,
209 .enable_interrupt = isa_fun_enable_interrupt,
210 .disable_interrupt = isa_fun_disable_interrupt,
211 .clear_interrupt = isa_fun_clear_interrupt,
212 .dma_channel_setup = isa_fun_setup_dma,
213 .dma_channel_remain = isa_fun_remain_dma,
214};
215
216static pio_window_t *isa_fun_get_pio_window(ddf_fun_t *fnode)
217{
218 ddf_dev_t *dev = ddf_fun_get_dev(fnode);
219 isa_bus_t *isa = isa_bus(dev);
220 assert(isa);
221
222 return &isa->pio_win;
223}
224
225static pio_window_ops_t isa_fun_pio_window_ops = {
226 .get_pio_window = isa_fun_get_pio_window
227};
228
229static ddf_dev_ops_t isa_fun_ops= {
230 .interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops,
231 .interfaces[PIO_WINDOW_DEV_IFACE] = &isa_fun_pio_window_ops,
232};
233
234static int isa_dev_add(ddf_dev_t *dev);
235static int isa_dev_remove(ddf_dev_t *dev);
236static int isa_fun_online(ddf_fun_t *fun);
237static int isa_fun_offline(ddf_fun_t *fun);
238
239/** The isa device driver's standard operations */
240static driver_ops_t isa_ops = {
241 .dev_add = &isa_dev_add,
242 .dev_remove = &isa_dev_remove,
243 .fun_online = &isa_fun_online,
244 .fun_offline = &isa_fun_offline
245};
246
247/** The isa device driver structure. */
248static driver_t isa_driver = {
249 .name = NAME,
250 .driver_ops = &isa_ops
251};
252
253static isa_fun_t *isa_fun_create(isa_bus_t *isa, const char *name)
254{
255 ddf_fun_t *fnode = ddf_fun_create(isa->dev, fun_inner, name);
256 if (fnode == NULL)
257 return NULL;
258
259 isa_fun_t *fun = ddf_fun_data_alloc(fnode, sizeof(isa_fun_t));
260 if (fun == NULL) {
261 ddf_fun_destroy(fnode);
262 return NULL;
263 }
264
265 fibril_mutex_initialize(&fun->mutex);
266 fun->hw_resources.resources = fun->resources;
267
268 fun->fnode = fnode;
269 return fun;
270}
271
272static char *fun_conf_read(const char *conf_path)
273{
274 bool suc = false;
275 char *buf = NULL;
276 bool opened = false;
277 int fd;
278 size_t len;
279 ssize_t r;
280 struct stat st;
281
282 fd = vfs_lookup_open(conf_path, WALK_REGULAR, MODE_READ);
283 if (fd < 0) {
284 ddf_msg(LVL_ERROR, "Unable to open %s", conf_path);
285 goto cleanup;
286 }
287
288 opened = true;
289
290 if (vfs_stat(fd, &st) != EOK) {
291 ddf_msg(LVL_ERROR, "Unable to vfs_stat %d", fd);
292 goto cleanup;
293 }
294
295 len = st.size;
296 if (len == 0) {
297 ddf_msg(LVL_ERROR, "Configuration file '%s' is empty.",
298 conf_path);
299 goto cleanup;
300 }
301
302 buf = malloc(len + 1);
303 if (buf == NULL) {
304 ddf_msg(LVL_ERROR, "Memory allocation failed.");
305 goto cleanup;
306 }
307
308 r = vfs_read(fd, (aoff64_t []) {0}, buf, len);
309 if (r < 0) {
310 ddf_msg(LVL_ERROR, "Unable to read file '%s'.", conf_path);
311 goto cleanup;
312 }
313
314 buf[len] = 0;
315
316 suc = true;
317
318cleanup:
319 if (!suc && buf != NULL) {
320 free(buf);
321 buf = NULL;
322 }
323
324 if (opened)
325 vfs_put(fd);
326
327 return buf;
328}
329
330static char *str_get_line(char *str, char **next)
331{
332 char *line = str;
333 *next = NULL;
334
335 if (str == NULL) {
336 return NULL;
337 }
338
339 while (*str != '\0' && *str != '\n') {
340 str++;
341 }
342
343 if (*str != '\0') {
344 *next = str + 1;
345 }
346
347 *str = '\0';
348 return line;
349}
350
351static bool line_empty(const char *line)
352{
353 while (line != NULL && *line != 0) {
354 if (!isspace(*line))
355 return false;
356 line++;
357 }
358
359 return true;
360}
361
362static char *get_device_name(char *line)
363{
364 /* Skip leading spaces. */
365 while (*line != '\0' && isspace(*line)) {
366 line++;
367 }
368
369 /* Get the name part of the rest of the line. */
370 str_tok(line, ":", NULL);
371 return line;
372}
373
374static inline const char *skip_spaces(const char *line)
375{
376 /* Skip leading spaces. */
377 while (*line != '\0' && isspace(*line))
378 line++;
379
380 return line;
381}
382
383static void isa_fun_add_irq(isa_fun_t *fun, int irq)
384{
385 size_t count = fun->hw_resources.count;
386 hw_resource_t *resources = fun->hw_resources.resources;
387
388 if (count < ISA_MAX_HW_RES) {
389 resources[count].type = INTERRUPT;
390 resources[count].res.interrupt.irq = irq;
391
392 fun->hw_resources.count++;
393
394 ddf_msg(LVL_NOTE, "Added irq 0x%x to function %s", irq,
395 ddf_fun_get_name(fun->fnode));
396 }
397}
398
399static void isa_fun_add_dma(isa_fun_t *fun, int dma)
400{
401 size_t count = fun->hw_resources.count;
402 hw_resource_t *resources = fun->hw_resources.resources;
403
404 if (count < ISA_MAX_HW_RES) {
405 if ((dma > 0) && (dma < 4)) {
406 resources[count].type = DMA_CHANNEL_8;
407 resources[count].res.dma_channel.dma8 = dma;
408
409 fun->hw_resources.count++;
410 ddf_msg(LVL_NOTE, "Added dma 0x%x to function %s", dma,
411 ddf_fun_get_name(fun->fnode));
412
413 return;
414 }
415
416 if ((dma > 4) && (dma < 8)) {
417 resources[count].type = DMA_CHANNEL_16;
418 resources[count].res.dma_channel.dma16 = dma;
419
420 fun->hw_resources.count++;
421 ddf_msg(LVL_NOTE, "Added dma 0x%x to function %s", dma,
422 ddf_fun_get_name(fun->fnode));
423
424 return;
425 }
426
427 ddf_msg(LVL_WARN, "Skipped dma 0x%x for function %s", dma,
428 ddf_fun_get_name(fun->fnode));
429 }
430}
431
432static void isa_fun_add_io_range(isa_fun_t *fun, size_t addr, size_t len)
433{
434 size_t count = fun->hw_resources.count;
435 hw_resource_t *resources = fun->hw_resources.resources;
436
437 isa_bus_t *isa = isa_bus(ddf_fun_get_dev(fun->fnode));
438
439 if (count < ISA_MAX_HW_RES) {
440 resources[count].type = IO_RANGE;
441 resources[count].res.io_range.address = addr;
442 resources[count].res.io_range.address += isa->pio_win.io.base;
443 resources[count].res.io_range.size = len;
444 resources[count].res.io_range.relative = false;
445 resources[count].res.io_range.endianness = LITTLE_ENDIAN;
446
447 fun->hw_resources.count++;
448
449 ddf_msg(LVL_NOTE, "Added io range (addr=0x%x, size=0x%x) to "
450 "function %s", (unsigned int) addr, (unsigned int) len,
451 ddf_fun_get_name(fun->fnode));
452 }
453}
454
455static void isa_fun_add_mem_range(isa_fun_t *fun, uintptr_t addr, size_t len)
456{
457 size_t count = fun->hw_resources.count;
458 hw_resource_t *resources = fun->hw_resources.resources;
459
460 isa_bus_t *isa = isa_bus(ddf_fun_get_dev(fun->fnode));
461
462 if (count < ISA_MAX_HW_RES) {
463 resources[count].type = MEM_RANGE;
464 resources[count].res.mem_range.address = addr;
465 resources[count].res.mem_range.address += isa->pio_win.mem.base;
466 resources[count].res.mem_range.size = len;
467 resources[count].res.mem_range.relative = true;
468 resources[count].res.mem_range.endianness = LITTLE_ENDIAN;
469
470 fun->hw_resources.count++;
471
472 ddf_msg(LVL_NOTE, "Added mem range (addr=0x%zx, size=0x%x) to "
473 "function %s", (uintptr_t) addr, (unsigned int) len,
474 ddf_fun_get_name(fun->fnode));
475 }
476}
477
478static void fun_parse_irq(isa_fun_t *fun, const char *val)
479{
480 int irq = 0;
481 char *end = NULL;
482
483 val = skip_spaces(val);
484 irq = (int) strtol(val, &end, 10);
485
486 if (val != end)
487 isa_fun_add_irq(fun, irq);
488}
489
490static void fun_parse_dma(isa_fun_t *fun, const char *val)
491{
492 char *end = NULL;
493
494 val = skip_spaces(val);
495 const int dma = strtol(val, &end, 10);
496
497 if (val != end)
498 isa_fun_add_dma(fun, dma);
499}
500
501static void fun_parse_io_range(isa_fun_t *fun, const char *val)
502{
503 size_t addr, len;
504 char *end = NULL;
505
506 val = skip_spaces(val);
507 addr = strtol(val, &end, 0x10);
508
509 if (val == end)
510 return;
511
512 val = skip_spaces(end);
513 len = strtol(val, &end, 0x10);
514
515 if (val == end)
516 return;
517
518 isa_fun_add_io_range(fun, addr, len);
519}
520
521static void fun_parse_mem_range(isa_fun_t *fun, const char *val)
522{
523 uintptr_t addr;
524 size_t len;
525 char *end = NULL;
526
527 val = skip_spaces(val);
528 addr = strtoul(val, &end, 0x10);
529
530 if (val == end)
531 return;
532
533 val = skip_spaces(end);
534 len = strtol(val, &end, 0x10);
535
536 if (val == end)
537 return;
538
539 isa_fun_add_mem_range(fun, addr, len);
540}
541
542static void get_match_id(char **id, const char *val)
543{
544 const char *end = val;
545
546 while (!isspace(*end))
547 end++;
548
549 size_t size = end - val + 1;
550 *id = (char *)malloc(size);
551 str_cpy(*id, size, val);
552}
553
554static void fun_parse_match_id(isa_fun_t *fun, const char *val)
555{
556 char *id = NULL;
557 char *end = NULL;
558
559 val = skip_spaces(val);
560
561 int score = (int)strtol(val, &end, 10);
562 if (val == end) {
563 ddf_msg(LVL_ERROR, "Cannot read match score for function "
564 "%s.", ddf_fun_get_name(fun->fnode));
565 return;
566 }
567
568 val = skip_spaces(end);
569 get_match_id(&id, val);
570 if (id == NULL) {
571 ddf_msg(LVL_ERROR, "Cannot read match ID for function %s.",
572 ddf_fun_get_name(fun->fnode));
573 return;
574 }
575
576 ddf_msg(LVL_DEBUG, "Adding match id '%s' with score %d to "
577 "function %s", id, score, ddf_fun_get_name(fun->fnode));
578
579 int rc = ddf_fun_add_match_id(fun->fnode, id, score);
580 if (rc != EOK) {
581 ddf_msg(LVL_ERROR, "Failed adding match ID: %s",
582 str_error(rc));
583 }
584
585 free(id);
586}
587
588static bool prop_parse(isa_fun_t *fun, const char *line, const char *prop,
589 void (*read_fn)(isa_fun_t *, const char *))
590{
591 size_t proplen = str_size(prop);
592
593 if (str_lcmp(line, prop, proplen) == 0) {
594 line += proplen;
595 line = skip_spaces(line);
596 (*read_fn)(fun, line);
597
598 return true;
599 }
600
601 return false;
602}
603
604static void fun_prop_parse(isa_fun_t *fun, const char *line)
605{
606 /* Skip leading spaces. */
607 line = skip_spaces(line);
608
609 if (!prop_parse(fun, line, "io_range", &fun_parse_io_range) &&
610 !prop_parse(fun, line, "mem_range", &fun_parse_mem_range) &&
611 !prop_parse(fun, line, "irq", &fun_parse_irq) &&
612 !prop_parse(fun, line, "dma", &fun_parse_dma) &&
613 !prop_parse(fun, line, "match", &fun_parse_match_id)) {
614
615 ddf_msg(LVL_ERROR, "Undefined device property at line '%s'",
616 line);
617 }
618}
619
620static char *isa_fun_read_info(char *fun_conf, isa_bus_t *isa)
621{
622 char *line;
623
624 /* Skip empty lines. */
625 do {
626 line = str_get_line(fun_conf, &fun_conf);
627
628 if (line == NULL) {
629 /* no more lines */
630 return NULL;
631 }
632
633 } while (line_empty(line));
634
635 /* Get device name. */
636 const char *fun_name = get_device_name(line);
637 if (fun_name == NULL)
638 return NULL;
639
640 isa_fun_t *fun = isa_fun_create(isa, fun_name);
641 if (fun == NULL) {
642 return NULL;
643 }
644
645 /* Get properties of the device (match ids, irq and io range). */
646 while (true) {
647 line = str_get_line(fun_conf, &fun_conf);
648
649 if (line_empty(line)) {
650 /* no more device properties */
651 break;
652 }
653
654 /*
655 * Get the device's property from the configuration line
656 * and store it in the device structure.
657 */
658 fun_prop_parse(fun, line);
659 }
660
661 /* Set device operations to the device. */
662 ddf_fun_set_ops(fun->fnode, &isa_fun_ops);
663
664 ddf_msg(LVL_DEBUG, "Binding function %s.", ddf_fun_get_name(fun->fnode));
665
666 /* XXX Handle error */
667 (void) ddf_fun_bind(fun->fnode);
668
669 list_append(&fun->bus_link, &isa->functions);
670
671 return fun_conf;
672}
673
674static void isa_functions_add(isa_bus_t *isa)
675{
676#define BASE_CLASS_BRIDGE 0x06
677#define SUB_CLASS_BRIDGE_ISA 0x01
678 bool isa_bridge = ((isa->pci_class == BASE_CLASS_BRIDGE) &&
679 (isa->pci_subclass == SUB_CLASS_BRIDGE_ISA));
680
681#define VENDOR_ID_SUN 0x108e
682#define DEVICE_ID_EBUS 0x1000
683 bool ebus = ((isa->pci_vendor_id == VENDOR_ID_SUN) &&
684 (isa->pci_device_id == DEVICE_ID_EBUS));
685
686 const char *conf_path = NULL;
687 if (isa_bridge)
688 conf_path = ISA_CHILD_FUN_CONF_PATH;
689 else if (ebus)
690 conf_path = EBUS_CHILD_FUN_CONF_PATH;
691
692 char *conf = fun_conf_read(conf_path);
693 while (conf != NULL && *conf != '\0') {
694 conf = isa_fun_read_info(conf, isa);
695 }
696 free(conf);
697}
698
699static int isa_dev_add(ddf_dev_t *dev)
700{
701 async_sess_t *sess;
702 int rc;
703
704 ddf_msg(LVL_DEBUG, "isa_dev_add, device handle = %d",
705 (int) ddf_dev_get_handle(dev));
706
707 isa_bus_t *isa = ddf_dev_data_alloc(dev, sizeof(isa_bus_t));
708 if (isa == NULL)
709 return ENOMEM;
710
711 fibril_mutex_initialize(&isa->mutex);
712 isa->dev = dev;
713 list_initialize(&isa->functions);
714
715 sess = ddf_dev_parent_sess_get(dev);
716 if (sess == NULL) {
717 ddf_msg(LVL_ERROR, "isa_dev_add failed to connect to the "
718 "parent driver.");
719 return ENOENT;
720 }
721
722 rc = pci_config_space_read_16(sess, PCI_VENDOR_ID, &isa->pci_vendor_id);
723 if (rc != EOK)
724 return rc;
725 rc = pci_config_space_read_16(sess, PCI_DEVICE_ID, &isa->pci_device_id);
726 if (rc != EOK)
727 return rc;
728 rc = pci_config_space_read_8(sess, PCI_BASE_CLASS, &isa->pci_class);
729 if (rc != EOK)
730 return rc;
731 rc = pci_config_space_read_8(sess, PCI_SUB_CLASS, &isa->pci_subclass);
732 if (rc != EOK)
733 return rc;
734
735 rc = pio_window_get(sess, &isa->pio_win);
736 if (rc != EOK) {
737 ddf_msg(LVL_ERROR, "isa_dev_add failed to get PIO window "
738 "for the device.");
739 return rc;
740 }
741
742 /* Make the bus device more visible. Does not do anything. */
743 ddf_msg(LVL_DEBUG, "Adding a 'ctl' function");
744
745 fibril_mutex_lock(&isa->mutex);
746
747 isa->fctl = ddf_fun_create(dev, fun_exposed, "ctl");
748 if (isa->fctl == NULL) {
749 ddf_msg(LVL_ERROR, "Failed creating control function.");
750 return EXDEV;
751 }
752
753 if (ddf_fun_bind(isa->fctl) != EOK) {
754 ddf_fun_destroy(isa->fctl);
755 ddf_msg(LVL_ERROR, "Failed binding control function.");
756 return EXDEV;
757 }
758
759 /* Add functions as specified in the configuration file. */
760 isa_functions_add(isa);
761 ddf_msg(LVL_NOTE, "Finished enumerating legacy functions");
762
763 fibril_mutex_unlock(&isa->mutex);
764
765 return EOK;
766}
767
768static int isa_dev_remove(ddf_dev_t *dev)
769{
770 isa_bus_t *isa = isa_bus(dev);
771
772 fibril_mutex_lock(&isa->mutex);
773
774 while (!list_empty(&isa->functions)) {
775 isa_fun_t *fun = list_get_instance(list_first(&isa->functions),
776 isa_fun_t, bus_link);
777
778 int rc = ddf_fun_offline(fun->fnode);
779 if (rc != EOK) {
780 fibril_mutex_unlock(&isa->mutex);
781 ddf_msg(LVL_ERROR, "Failed offlining %s", ddf_fun_get_name(fun->fnode));
782 return rc;
783 }
784
785 rc = ddf_fun_unbind(fun->fnode);
786 if (rc != EOK) {
787 fibril_mutex_unlock(&isa->mutex);
788 ddf_msg(LVL_ERROR, "Failed unbinding %s", ddf_fun_get_name(fun->fnode));
789 return rc;
790 }
791
792 list_remove(&fun->bus_link);
793
794 ddf_fun_destroy(fun->fnode);
795 }
796
797 if (ddf_fun_unbind(isa->fctl) != EOK) {
798 fibril_mutex_unlock(&isa->mutex);
799 ddf_msg(LVL_ERROR, "Failed unbinding control function.");
800 return EXDEV;
801 }
802
803 fibril_mutex_unlock(&isa->mutex);
804
805 return EOK;
806}
807
808static int isa_fun_online(ddf_fun_t *fun)
809{
810 ddf_msg(LVL_DEBUG, "isa_fun_online()");
811 return ddf_fun_online(fun);
812}
813
814static int isa_fun_offline(ddf_fun_t *fun)
815{
816 ddf_msg(LVL_DEBUG, "isa_fun_offline()");
817 return ddf_fun_offline(fun);
818}
819
820int main(int argc, char *argv[])
821{
822 printf(NAME ": HelenOS ISA bus driver\n");
823 ddf_log_init(NAME);
824 return ddf_driver_main(&isa_driver);
825}
826
827/**
828 * @}
829 */
Note: See TracBrowser for help on using the repository browser.