cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

dfl-afu-region.c (4199B)

      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 * Driver for FPGA Accelerated Function Unit (AFU) MMIO Region Management
      4 *
      5 * Copyright (C) 2017-2018 Intel Corporation, Inc.
      6 *
      7 * Authors:
      8 *   Wu Hao <hao.wu@intel.com>
      9 *   Xiao Guangrong <guangrong.xiao@linux.intel.com>
     10 */
     11#include "dfl-afu.h"
     12
     13/**
     14 * afu_mmio_region_init - init function for afu mmio region support
     15 * @pdata: afu platform device's pdata.
     16 */
     17void afu_mmio_region_init(struct dfl_feature_platform_data *pdata)
     18{
     19	struct dfl_afu *afu = dfl_fpga_pdata_get_private(pdata);
     20
     21	INIT_LIST_HEAD(&afu->regions);
     22}
     23
     24#define for_each_region(region, afu)	\
     25	list_for_each_entry((region), &(afu)->regions, node)
     26
     27static struct dfl_afu_mmio_region *get_region_by_index(struct dfl_afu *afu,
     28						       u32 region_index)
     29{
     30	struct dfl_afu_mmio_region *region;
     31
     32	for_each_region(region, afu)
     33		if (region->index == region_index)
     34			return region;
     35
     36	return NULL;
     37}
     38
     39/**
     40 * afu_mmio_region_add - add a mmio region to given feature dev.
     41 *
     42 * @region_index: region index.
     43 * @region_size: region size.
     44 * @phys: region's physical address of this region.
     45 * @flags: region flags (access permission).
     46 *
     47 * Return: 0 on success, negative error code otherwise.
     48 */
     49int afu_mmio_region_add(struct dfl_feature_platform_data *pdata,
     50			u32 region_index, u64 region_size, u64 phys, u32 flags)
     51{
     52	struct dfl_afu_mmio_region *region;
     53	struct dfl_afu *afu;
     54	int ret = 0;
     55
     56	region = devm_kzalloc(&pdata->dev->dev, sizeof(*region), GFP_KERNEL);
     57	if (!region)
     58		return -ENOMEM;
     59
     60	region->index = region_index;
     61	region->size = region_size;
     62	region->phys = phys;
     63	region->flags = flags;
     64
     65	mutex_lock(&pdata->lock);
     66
     67	afu = dfl_fpga_pdata_get_private(pdata);
     68
     69	/* check if @index already exists */
     70	if (get_region_by_index(afu, region_index)) {
     71		mutex_unlock(&pdata->lock);
     72		ret = -EEXIST;
     73		goto exit;
     74	}
     75
     76	region_size = PAGE_ALIGN(region_size);
     77	region->offset = afu->region_cur_offset;
     78	list_add(&region->node, &afu->regions);
     79
     80	afu->region_cur_offset += region_size;
     81	afu->num_regions++;
     82	mutex_unlock(&pdata->lock);
     83
     84	return 0;
     85
     86exit:
     87	devm_kfree(&pdata->dev->dev, region);
     88	return ret;
     89}
     90
     91/**
     92 * afu_mmio_region_destroy - destroy all mmio regions under given feature dev.
     93 * @pdata: afu platform device's pdata.
     94 */
     95void afu_mmio_region_destroy(struct dfl_feature_platform_data *pdata)
     96{
     97	struct dfl_afu *afu = dfl_fpga_pdata_get_private(pdata);
     98	struct dfl_afu_mmio_region *tmp, *region;
     99
    100	list_for_each_entry_safe(region, tmp, &afu->regions, node)
    101		devm_kfree(&pdata->dev->dev, region);
    102}
    103
    104/**
    105 * afu_mmio_region_get_by_index - find an afu region by index.
    106 * @pdata: afu platform device's pdata.
    107 * @region_index: region index.
    108 * @pregion: ptr to region for result.
    109 *
    110 * Return: 0 on success, negative error code otherwise.
    111 */
    112int afu_mmio_region_get_by_index(struct dfl_feature_platform_data *pdata,
    113				 u32 region_index,
    114				 struct dfl_afu_mmio_region *pregion)
    115{
    116	struct dfl_afu_mmio_region *region;
    117	struct dfl_afu *afu;
    118	int ret = 0;
    119
    120	mutex_lock(&pdata->lock);
    121	afu = dfl_fpga_pdata_get_private(pdata);
    122	region = get_region_by_index(afu, region_index);
    123	if (!region) {
    124		ret = -EINVAL;
    125		goto exit;
    126	}
    127	*pregion = *region;
    128exit:
    129	mutex_unlock(&pdata->lock);
    130	return ret;
    131}
    132
    133/**
    134 * afu_mmio_region_get_by_offset - find an afu mmio region by offset and size
    135 *
    136 * @pdata: afu platform device's pdata.
    137 * @offset: region offset from start of the device fd.
    138 * @size: region size.
    139 * @pregion: ptr to region for result.
    140 *
    141 * Find the region which fully contains the region described by input
    142 * parameters (offset and size) from the feature dev's region linked list.
    143 *
    144 * Return: 0 on success, negative error code otherwise.
    145 */
    146int afu_mmio_region_get_by_offset(struct dfl_feature_platform_data *pdata,
    147				  u64 offset, u64 size,
    148				  struct dfl_afu_mmio_region *pregion)
    149{
    150	struct dfl_afu_mmio_region *region;
    151	struct dfl_afu *afu;
    152	int ret = 0;
    153
    154	mutex_lock(&pdata->lock);
    155	afu = dfl_fpga_pdata_get_private(pdata);
    156	for_each_region(region, afu)
    157		if (region->offset <= offset &&
    158		    region->offset + region->size >= offset + size) {
    159			*pregion = *region;
    160			goto exit;
    161		}
    162	ret = -EINVAL;
    163exit:
    164	mutex_unlock(&pdata->lock);
    165	return ret;
    166}