/* * Copyright (c) 2008, XenSource Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of XenSource Inc. nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include "tapdisk.h" #include "tapdisk-utils.h" #include "tapdisk-driver.h" #include "tapdisk-server.h" #include "tapdisk-interface.h" #ifdef DEBUG #define DBG(_f, _a...) tlog_write(TLOG_DBG, _f, ##_a) #else #define DBG(_f, _a...) ((void)0) #endif #define WARN(_f, _a...) tlog_write(TLOG_WARN, _f, ##_a) #define RADIX_TREE_PAGE_SHIFT 12 /* 4K pages */ #define RADIX_TREE_PAGE_SIZE (1 << RADIX_TREE_PAGE_SHIFT) #define RADIX_TREE_NODE_SHIFT 9 /* 512B nodes */ #define RADIX_TREE_NODE_SIZE (1 << RADIX_TREE_NODE_SHIFT) #define RADIX_TREE_NODE_MASK (RADIX_TREE_NODE_SIZE - 1) #define BLOCK_CACHE_NODES_PER_PAGE (1 << (RADIX_TREE_PAGE_SHIFT - RADIX_TREE_NODE_SHIFT)) #define BLOCK_CACHE_MAX_SIZE (10 << 20) /* 100MB cache */ #define BLOCK_CACHE_REQUESTS (TAPDISK_DATA_REQUESTS << 3) #define BLOCK_CACHE_PAGE_IDLETIME 60 typedef struct radix_tree radix_tree_t; typedef struct radix_tree_node radix_tree_node_t; typedef struct radix_tree_link radix_tree_link_t; typedef struct radix_tree_leaf radix_tree_leaf_t; typedef struct radix_tree_page radix_tree_page_t; typedef struct block_cache block_cache_t; typedef struct block_cache_request block_cache_request_t; typedef struct block_cache_stats block_cache_stats_t; struct radix_tree_page { char *buf; size_t size; uint64_t sec; radix_tree_link_t *owners[BLOCK_CACHE_NODES_PER_PAGE]; }; struct radix_tree_leaf { radix_tree_page_t *page; char *buf; }; struct radix_tree_link { uint32_t time; union { radix_tree_node_t *next; radix_tree_leaf_t leaf; } u; }; struct radix_tree_node { int height; radix_tree_link_t links[RADIX_TREE_NODE_SIZE]; }; struct radix_tree { int height; uint64_t size; uint32_t nodes; radix_tree_node_t *root; block_cache_t *cache; }; struct block_cache_request { int err; char *buf; uint64_t secs; td_request_t treq; block_cache_t *cache; }; struct block_cache_stats { uint64_t reads; uint64_t hits; uint64_t misses; uint64_t prunes; }; struct block_cache { int ptype; char *name; uint64_t sectors; block_cache_request_t requests[BLOCK_CACHE_REQUESTS]; block_cache_request_t *request_free_list[BLOCK_CACHE_REQUESTS]; int requests_free; event_id_t timeout_id; radix_tree_t tree; block_cache_stats_t stats; }; static inline uint64_t radix_tree_calculate_size(int height) { return (uint64_t)RADIX_TREE_NODE_SIZE << (height * RADIX_TREE_NODE_SHIFT); } static inline int radix_tree_calculate_height(uint64_t sectors) { int height; uint64_t tree_size; height = 1; /* always allocate root node */ tree_size = radix_tree_calculate_size(height); while (sectors > tree_size) tree_size = radix_tree_calculate_size(++height); return height; } static inline int radix_tree_index(radix_tree_node_t *node, uint64_t sector) { return ((sector >> (node->height * RADIX_TREE_NODE_SHIFT)) & RADIX_TREE_NODE_MASK); } static inline int radix_tree_node_contains_leaves(radix_tree_t *tree, radix_tree_node_t *node) { return (node->height == 0); } static inline int radix_tree_node_is_root(radix_tree_t *tree, radix_tree_node_t *node) { return (node->height == tree->height); } static inline uint64_t radix_tree_size(radix_tree_t *tree) { return tree->size + tree->nodes * sizeof(radix_tree_node_t); } static inline void radix_tree_clear_link(radix_tree_link_t *link) { if (link) memset(link, 0, sizeof(radix_tree_link_t)); } static inline radix_tree_node_t * radix_tree_allocate_node(radix_tree_t *tree, int height) { radix_tree_node_t *node; node = calloc(1, sizeof(radix_tree_node_t)); if (!node) return NULL; node->height = height; tree->nodes++; return node; } static inline radix_tree_node_t * radix_tree_allocate_child_node(radix_tree_t *tree, radix_tree_node_t *parent) { return radix_tree_allocate_node(tree, parent->height - 1); } void radix_tree_free_node(radix_tree_t *tree, radix_tree_node_t *node) { if (!node) return; free(node); tree->nodes--; } static inline radix_tree_page_t * radix_tree_allocate_page(radix_tree_t *tree, char *buf, uint64_t sec, size_t size) { radix_tree_page_t *page; page = calloc(1, sizeof(radix_tree_page_t)); if (!page) return NULL; page->buf = buf; page->sec = sec; page->size = size; tree->size += size; return page; } static inline void radix_tree_free_page(radix_tree_t *tree, radix_tree_page_t *page) { int i; for (i = 0; i < page->size >> RADIX_TREE_NODE_SHIFT; i++) DBG("%s: ejecting sector 0x%llx\n", tree->cache->name, page->sec + i); tree->cache->stats.prunes += (page->size >> RADIX_TREE_NODE_SHIFT); tree->size -= page->size; free(page->buf); free(page); } /* * remove a leaf and the shared radix_tree_page_t containing its buffer. * leaves are deleted, nodes are not; gc will reap the nodes later. */ static void radix_tree_remove_page(radix_tree_t *tree, radix_tree_page_t *page) { int i; if (!page) return; for (i = 0; i < BLOCK_CACHE_NODES_PER_PAGE; i++) radix_tree_clear_link(page->owners[i]); radix_tree_free_page(tree, page); } static void radix_tree_insert_leaf(radix_tree_t *tree, radix_tree_link_t *link, radix_tree_page_t *page, off_t off) { int i; if (off + RADIX_TREE_NODE_SIZE > page->size) return; for (i = 0; i < BLOCK_CACHE_NODES_PER_PAGE; i++) { if (page->owners[i]) continue; page->owners[i] = link; link->u.leaf.page = page; link->u.leaf.buf = page->buf + off; break; } } static char * radix_tree_find_leaf(radix_tree_t *tree, uint64_t sector) { int idx; struct timeval now; radix_tree_link_t *link; radix_tree_node_t *node; node = tree->root; gettimeofday(&now, NULL); do { idx = radix_tree_index(node, sector); link = node->links + idx; link->time = now.tv_sec; if (radix_tree_node_contains_leaves(tree, node)) return link->u.leaf.buf; if (!link->u.next) return NULL; node = link
/*
    ChibiOS - Copyright (C) 2006..2016 Giovanni Di Sirio

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

#include "ch.h"
#include "hal.h"

#define ADC_GRP1_NUM_CHANNELS   1
#define ADC_GRP1_BUF_DEPTH      8

#define ADC_GRP2_NUM_CHANNELS   4
#define ADC_GRP2_BUF_DEPTH      16

static adcsample_t samples1[ADC_GRP1_NUM_CHANNELS * ADC_GRP1_BUF_DEPTH];
static adcsample_t samples2[ADC_GRP2_NUM_CHANNELS * ADC_GRP2_BUF_DEPTH];

/*
 * ADC streaming callback.
 */
size_t nx = 0, ny = 0;
static void adccallback(ADCDriver *adcp, adcsample_t *buffer, size_t n) {

  (void)adcp;
  if (samples2 == buffer) {
    nx += n;
  }
  else {
    ny += n;
  }
}

static void adcerrorcallback(ADCDriver *adcp, adcerror_t err) {

  (void)adcp;
  (void)err;
}

/*
 * ADC conversion group.
 * Mode:        Linear buffer, 8 samples of 1 channel, SW triggered.
 * Channels:    IN10.
 */
static const ADCConversionGroup adcgrpcfg1 = {
  FALSE,
  ADC_GRP1_NUM_CHANNELS,
  NULL,
  adcerrorcallback,
  ADC_CFGR1_CONT | ADC_CFGR1_RES_12BIT,             /* CFGR1 */
  0,                                                /* CFGR2 */
  ADC_TR(0, 0),                                     /* TR */
  ADC_SMPR_SMP_1P5,                                 /* SMPR */
  ADC_CHSELR_CHSEL10                                /* CHSELR */
};

/*
 * ADC conversion group.
 * Mode:        Continuous, 16 samples of 8 channels, SW triggered.
 * Channels:    IN10, IN11, VRef, Sensor.
 */
static const ADCConversionGroup adcgrpcfg2 = {
  TRUE,
  ADC_GRP2_NUM_CHANNELS,
  adccallback,
  adcerrorcallback,
  ADC_CFGR1_CONT | ADC_CFGR1_RES_12BIT,             /* CFGR1 */
  0,                                                /* CFGR2 */
  ADC_TR(0, 0),                                     /* TR */
  ADC_SMPR_SMP_28P5,                                /* SMPR */
  ADC_CHSELR_CHSEL10 | ADC_CHSELR_CHSEL11 |
  ADC_CHSELR_CHSEL17 | ADC_CHSELR_CHSEL18           /* CHSELR */
};

/*
 * Red LEDs blinker thread, times are in milliseconds.
 */
static THD_WORKING_AREA(waThread1, 128);
static THD_FUNCTION(Thread1, arg) {

  (void)arg;
  chRegSetThreadName("blinker");
  while (true) {
    palSetPad(GPIOA, GPIOA_LED_GREEN);
    chThdSleepMilliseconds(500);
    palClearPad(GPIOA, GPIOA_LED_GREEN);
    chThdSleepMilliseconds(500);
  }
}

/*
 * Application entry point.
 */
int main(void) {

  /*
   * System initializations.
   * - HAL initialization, this also initializes the configured device drivers
   *   and performs the board-specific initializations.
   * - Kernel initialization, the main() function becomes a thread and the
   *   RTOS is active.
   */
  halInit();
  chSysInit();

  /*
   * Setting up analog inputs used by the demo.
   */
  palSetGroupMode(GPIOC, PAL_PORT_BIT(0) | PAL_PORT_BIT(1),
                  0, PAL_MODE_INPUT_ANALOG);

  /*
   * Creates the blinker thread.
   */
  chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);

  /*
   * Activates the ADC1 driver and the temperature sensor.
   */
  adcStart(&ADCD1, NULL);
  adcSTM32SetCCR(ADC_CCR_TSEN | ADC_CCR_VREFEN);

  /*
   * Linear conversion.
   */
  adcConvert(&ADCD1, &adcgrpcfg1, samples1, ADC_GRP1_BUF_DEPTH);
  chThdSleepMilliseconds(1000);

  /*
   * Starts an ADC continuous conversion.
   */
  adcStartConversion(&ADCD1, &adcgrpcfg2, samples2, ADC_GRP2_BUF_DEPTH);

  /*
   * Normal main() thread activity, in this demo it does nothing.
   */
  while (true) {
    if (!palReadPad(GPIOC, GPIOC_BUTTON)) {
      adcStopConversion(&ADCD1);
      adcSTM32SetCCR(0);
    }
    chThdSleepMilliseconds(500);
  }
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-10 14:19:49 +0000