void hw_finish (struct hw *me) { if (hw_finished_p (me)) hw_abort (me, "Attempt to finish finished device"); /* Fill in the (hopefully) defined address/size cells values */ if (hw_find_property (me, "#address-cells") != NULL) me->nr_address_cells_of_hw_unit = hw_find_integer_property (me, "#address-cells"); else me->nr_address_cells_of_hw_unit = 2; if (hw_find_property (me, "#size-cells") != NULL) me->nr_size_cells_of_hw_unit = hw_find_integer_property (me, "#size-cells"); else me->nr_size_cells_of_hw_unit = 1; /* Fill in the (hopefully) defined trace variable */ if (hw_find_property (me, "trace?") != NULL) me->trace_of_hw_p = hw_find_boolean_property (me, "trace?"); /* allow global variable to define default tracing */ else if (! hw_trace_p (me) && hw_find_property (hw_root (me), "global-trace?") != NULL && hw_find_boolean_property (hw_root (me), "global-trace?")) me->trace_of_hw_p = 1; /* Allow the real device to override any methods */ me->base_of_hw->descriptor->to_finish (me); me->base_of_hw->finished_p = 1; }
signed_cell hw_tree_find_integer_property (struct hw *root, const char *path_to_property) { name_specifier spec; if (!split_property_specifier (root, path_to_property, &spec)) hw_abort (root, "Invalid property path %s", path_to_property); root = split_find_device (root, &spec); if (spec.name != NULL) hw_abort (root, "device \"%s\" not found (property \"%s\")", spec.name, path_to_property); return hw_find_integer_property (root, spec.property); }
static void attach_tx3904tmr_regs (struct hw *me, struct tx3904tmr *controller) { unsigned_word attach_address; int attach_space; unsigned attach_size; reg_property_spec reg; if (hw_find_property (me, "reg") == NULL) hw_abort (me, "Missing \"reg\" property"); if (!hw_find_reg_array_property (me, "reg", 0, ®)) hw_abort (me, "\"reg\" property must contain one addr/size entry"); hw_unit_address_to_attach_address (hw_parent (me), ®.address, &attach_space, &attach_address, me); hw_unit_size_to_attach_size (hw_parent (me), ®.size, &attach_size, me); hw_attach_address (hw_parent (me), 0, attach_space, attach_address, attach_size, me); if(hw_find_property(me, "clock") != NULL) controller->clock_ticks = (unsigned_4) hw_find_integer_property(me, "clock"); if(hw_find_property(me, "ext") != NULL) controller->ext_ticks = (unsigned_4) hw_find_integer_property(me, "ext"); controller->base_address = attach_address; }
static void bfin_ebiu_sdc_finish (struct hw *me) { struct bfin_ebiu_sdc *sdc; sdc = HW_ZALLOC (me, struct bfin_ebiu_sdc); set_hw_data (me, sdc); set_hw_io_read_buffer (me, bfin_ebiu_sdc_io_read_buffer); set_hw_io_write_buffer (me, bfin_ebiu_sdc_io_write_buffer); attach_bfin_ebiu_sdc_regs (me, sdc); sdc->type = hw_find_integer_property (me, "type"); /* Initialize the SDC. */ sdc->sdgctl = 0xE0088849; sdc->sdbctl = 0x00000000; sdc->sdrrc = 0x081A; sdc->sdstat = 0x0008; /* XXX: We boot with 64M external memory by default ... */ sdc->sdbctl |= EBE | EBSZ_64 | EBCAW_10; }
static void cris_finish (struct hw *me) { struct cris_hw *crishw; const struct hw_property *vec_for_int; const struct hw_property *multiple_int; crishw = HW_ZALLOC (me, struct cris_hw); set_hw_data (me, crishw); set_hw_ports (me, cris_ports); set_hw_port_event (me, cris_port_event); vec_for_int = hw_find_property (me, "vec-for-int"); if (vec_for_int != NULL) { unsigned32 vecsize; unsigned32 i; if (hw_property_type (vec_for_int) != array_property) hw_abort (me, "property \"vec-for-int\" has the wrong type"); vecsize = hw_property_sizeof_array (vec_for_int) / sizeof (signed_cell); if ((vecsize % 2) != 0) hw_abort (me, "translation vector does not consist of even pairs"); crishw->int_to_vec = hw_malloc (me, (vecsize/2 + 1) * sizeof (crishw->int_to_vec[0])); for (i = 0; i < vecsize/2; i++) { signed_cell portval_sc; signed_cell vec_sc; if (!hw_find_integer_array_property (me, "vec-for-int", i*2, &portval_sc) || !hw_find_integer_array_property (me, "vec-for-int", i*2 + 1, &vec_sc) || portval_sc < 0 || vec_sc < 0) hw_abort (me, "no valid vector translation pair %u", i); crishw->int_to_vec[i].portval = (unsigned32) portval_sc; crishw->int_to_vec[i].vec = (unsigned32) vec_sc; } crishw->int_to_vec[i].portval = 0; crishw->int_to_vec[i].vec = 0; } multiple_int = hw_find_property (me, "multiple-int"); if (multiple_int != NULL) { if (hw_property_type (multiple_int) == integer_property) { crishw->multiple_int_vector = hw_find_integer_property (me, "multiple-int"); crishw->multi_int_action = cris_multint_vector; } else { const char *action = hw_find_string_property (me, "multiple-int"); if (action == NULL) hw_abort (me, "property \"multiple-int\" has the wrong type"); if (strcmp (action, "abort") == 0) crishw->multi_int_action = cris_multint_abort; else if (strcmp (action, "ignore_previous") == 0) crishw->multi_int_action = cris_multint_ignore_previous; else hw_abort (me, "property \"multiple-int\" must be one of <vector number>\n" "\"abort\" and \"ignore_previous\", not \"%s\"", action); } } else crishw->multi_int_action = cris_multint_abort; }
static void print_properties (struct hw *me, struct printer *p) { const struct hw_property *property; for (property = hw_find_property (me, NULL); property != NULL; property = hw_next_property (property)) { if (hw_parent (me) == NULL) p->print (p->file, "/%s", property->name); else p->print (p->file, "%s/%s", hw_path (me), property->name); if (property->original != NULL) { p->print (p->file, " !"); p->print (p->file, "%s/%s", hw_path (property->original->owner), property->original->name); } else { switch (property->type) { case array_property: { if ((property->sizeof_array % sizeof (signed_cell)) == 0) { unsigned_cell *w = (unsigned_cell*) property->array; int cell_nr; for (cell_nr = 0; cell_nr < (property->sizeof_array / sizeof (unsigned_cell)); cell_nr++) { p->print (p->file, " 0x%lx", (unsigned long) BE2H_cell (w[cell_nr])); } } else { unsigned8 *w = (unsigned8*)property->array; p->print (p->file, " ["); while ((char*)w - (char*)property->array < property->sizeof_array) { p->print (p->file, " 0x%2x", BE2H_1 (*w)); w++; } } break; } case boolean_property: { int b = hw_find_boolean_property(me, property->name); p->print (p->file, " %s", b ? "true" : "false"); break; } #if NOT_YET case ihandle_property: { if (property->array != NULL) { device_instance *instance = hw_find_ihandle_property (me, property->name); p->print (p->file, " *%s", device_instance_path(instance)); } else { /* not yet initialized, ask the device for the path */ ihandle_runtime_property_spec spec; hw_find_ihandle_runtime_property (me, property->name, &spec); p->print (p->file, " *%s", spec.full_path); } break; } #endif case integer_property: { unsigned_word w = hw_find_integer_property (me, property->name); p->print (p->file, " 0x%lx", (unsigned long)w); break; } case range_array_property: { print_ranges_property (me, property, p); break; } case reg_array_property: { print_reg_property (me, property, p); break; } case string_property: { const char *s = hw_find_string_property (me, property->name); print_string (me, s, p); break; } case string_array_property: { print_string_array_property (me, property, p); break; } } } p->print (p->file, "\n"); } }
/* Device tree options: Required: .../reg <addr> <len> .../cmdset <primary; integer> [alt; integer] Optional: .../size <device size (must be pow of 2)> .../width <8|16|32> .../write_size <integer (must be pow of 2)> .../erase_regions <number blocks> <block size> \ [<number blocks> <block size> ...] .../voltage <vcc min> <vcc max> <vpp min> <vpp max> .../timeouts <typ unit write> <typ buf write> \ <typ block erase> <typ chip erase> \ <max unit write> <max buf write> \ <max block erase> <max chip erase> .../file <file> [ro|rw] Defaults: size: <len> from "reg" width: 8 write_size: 0 (not supported) erase_region: 1 (can only erase whole chip) voltage: 0.0V (for all) timeouts: typ: 1µs, not supported, 1ms, not supported max: 1µs, 1ms, 1ms, not supported TODO: Verify user args are valid (e.g. voltage is 8 bits). */ static void attach_cfi_regs (struct hw *me, struct cfi *cfi) { address_word attach_address; int attach_space; unsigned attach_size; reg_property_spec reg; bool fd_writable; int i, ret, fd; signed_cell ival; if (hw_find_property (me, "reg") == NULL) hw_abort (me, "Missing \"reg\" property"); if (hw_find_property (me, "cmdset") == NULL) hw_abort (me, "Missing \"cmdset\" property"); if (!hw_find_reg_array_property (me, "reg", 0, ®)) hw_abort (me, "\"reg\" property must contain three addr/size entries"); hw_unit_address_to_attach_address (hw_parent (me), ®.address, &attach_space, &attach_address, me); hw_unit_size_to_attach_size (hw_parent (me), ®.size, &attach_size, me); hw_attach_address (hw_parent (me), 0, attach_space, attach_address, attach_size, me); /* Extract the desired flash command set. */ ret = hw_find_integer_array_property (me, "cmdset", 0, &ival); if (ret != 1 && ret != 2) hw_abort (me, "\"cmdset\" property takes 1 or 2 entries"); cfi_encode_16bit (cfi->query.p_id, ival); for (i = 0; i < ARRAY_SIZE (cfi_cmdsets); ++i) if (cfi_cmdsets[i]->id == ival) cfi->cmdset = cfi_cmdsets[i]; if (cfi->cmdset == NULL) hw_abort (me, "cmdset %u not supported", ival); if (ret == 2) { hw_find_integer_array_property (me, "cmdset", 1, &ival); cfi_encode_16bit (cfi->query.a_id, ival); } /* Extract the desired device size. */ if (hw_find_property (me, "size")) cfi->dev_size = hw_find_integer_property (me, "size"); else cfi->dev_size = attach_size; cfi->query.dev_size = log2 (cfi->dev_size); /* Extract the desired flash width. */ if (hw_find_property (me, "width")) { cfi->width = hw_find_integer_property (me, "width"); if (cfi->width != 8 && cfi->width != 16 && cfi->width != 32) hw_abort (me, "\"width\" must be 8 or 16 or 32, not %u", cfi->width); } else /* Default to 8 bit. */ cfi->width = 8; /* Turn 8/16/32 into 1/2/4. */ cfi->width /= 8; /* Extract optional write buffer size. */ if (hw_find_property (me, "write_size")) { ival = hw_find_integer_property (me, "write_size"); cfi_encode_16bit (cfi->query.max_buf_write_len, log2 (ival)); } /* Extract optional erase regions. */ if (hw_find_property (me, "erase_regions")) { ret = hw_find_integer_array_property (me, "erase_regions", 0, &ival); if (ret % 2) hw_abort (me, "\"erase_regions\" must be specified in sets of 2"); cfi->erase_region_info = HW_NALLOC (me, unsigned char, ret / 2); cfi->erase_regions = HW_NALLOC (me, struct cfi_erase_region, ret / 2); for (i = 0; i < ret; i += 2) { unsigned blocks, size; hw_find_integer_array_property (me, "erase_regions", i, &ival); blocks = ival; hw_find_integer_array_property (me, "erase_regions", i + 1, &ival); size = ival; cfi_add_erase_region (me, cfi, blocks, size); } }