Merge tag 'tag-chrome-platform-for-v6.8' of...

	return ret;

}

static int cros_ec_sensor_ring_median_cmp(const void *pv1, const void *pv2)

static void cros_ec_sensor_ring_median_swap(s64 *a, s64 *b)

{

	s64 v1 = *(s64 *)pv1;

	s64 v2 = *(s64 *)pv2;

	if (v1 > v2)

		return 1;

	else if (v1 < v2)

		return -1;

	else

		return 0;

	s64 tmp = *a;

	*a = *b;

	*b = tmp;

}

/*

 * cros_ec_sensor_ring_median: Gets median of an array of numbers

 *

 * For now it's implemented using an inefficient > O(n) sort then return

 * the middle element. A more optimal method would be something like

 * quickselect, but given that n = 64 we can probably live with it in the

 * name of clarity.

 * It's implemented using the quickselect algorithm, which achieves an

 * average time complexity of O(n) the middle element. In the worst case,

 * the runtime of quickselect could regress to O(n^2). To mitigate this,

 * algorithms like median-of-medians exist, which can guarantee O(n) even

 * in the worst case. However, these algorithms come with a higher

 * overhead and are more complex to implement, making quickselect a

 * pragmatic choice for our use case.

 *

 * Warning: the input array gets modified (sorted)!

 * Warning: the input array gets modified!

 */

static s64 cros_ec_sensor_ring_median(s64 *array, size_t length)

{

	sort(array, length, sizeof(s64), cros_ec_sensor_ring_median_cmp, NULL);

	return array[length / 2];

	int lo = 0;

	int hi = length - 1;

	while (lo <= hi) {

		int mid = lo + (hi - lo) / 2;

		int pivot, i;

		if (array[lo] > array[mid])

			cros_ec_sensor_ring_median_swap(&array[lo], &array[mid]);

		if (array[lo] > array[hi])

			cros_ec_sensor_ring_median_swap(&array[lo], &array[hi]);

		if (array[mid] < array[hi])

			cros_ec_sensor_ring_median_swap(&array[mid], &array[hi]);

		pivot = array[hi];

		i = lo - 1;

		for (int j = lo; j < hi; j++)

			if (array[j] < pivot)

				cros_ec_sensor_ring_median_swap(&array[++i], &array[j]);

		/* The pivot's index corresponds to i+1. */

		cros_ec_sensor_ring_median_swap(&array[i + 1], &array[hi]);

		if (i + 1 == length / 2)

			return array[i + 1];

		if (i + 1 > length / 2)

			hi = i;

		else

			lo = i + 2;

	}

	/* Should never reach here. */

	return -1;

}

/*

 *

 * While a and b are recorded at accurate times (due to the EC real time

 * nature); c is pretty untrustworthy, even though it's recorded the

 * first thing in ec_irq_handler(). There is a very good change we'll get

 * added lantency due to:

 * first thing in ec_irq_handler(). There is a very good chance we'll get

 * added latency due to:

 *   other irqs

 *   ddrfreq

 *   cpuidle

 *                                 ringbuffer.

 *

 * This is the new spreading code, assumes every sample's timestamp

 * preceeds the sample. Run if tight_timestamps == true.

 * precedes the sample. Run if tight_timestamps == true.

 *

 * Sometimes the EC receives only one interrupt (hence timestamp) for

 * a batch of samples. Only the first sample will have the correct

			} else {

				/*

				 * Push first sample in the batch to the,

				 * kifo, it's guaranteed to be correct, the

				 * kfifo, it's guaranteed to be correct, the

				 * rest will follow later on.

				 */

				sample_idx = 1;

 *           last_out -->

 *

 *

 * We spread time for the samples using perod p = (current - TS1)/4.

 * We spread time for the samples using period p = (current - TS1)/4.

 * between TS1 and TS2: [TS1+p/4, TS1+2p/4, TS1+3p/4, current_timestamp].

 *

 */

	struct device *dev = kobj_to_dev(kobj);

	struct cros_ec_dev *ec = to_cros_ec_dev(dev);

	struct cros_ec_device *ecdev = ec->ec_dev;

	struct ec_params_vbnvcontext *params;

	struct cros_ec_command *msg;

	/*

	 * This should be a pointer to the same type as op field in

	 * struct ec_params_vbnvcontext.

	 */

	uint32_t *params_op;

	int err;

	const size_t para_sz = sizeof(params->op);

	const size_t para_sz = sizeof(*params_op);

	const size_t resp_sz = sizeof(struct ec_response_vbnvcontext);

	const size_t payload = max(para_sz, resp_sz);

		return -ENOMEM;

	/* NB: we only kmalloc()ated enough space for the op field */

	params = (struct ec_params_vbnvcontext *)msg->data;

	params->op = EC_VBNV_CONTEXT_OP_READ;

	params_op = (uint32_t *)msg->data;

	*params_op = EC_VBNV_CONTEXT_OP_READ;

	msg->version = EC_VER_VBNV_CONTEXT;

	msg->command = EC_CMD_VBNV_CONTEXT;

free_dev_data:

	hangup_device(dev_data);

free_minor:

	ida_simple_remove(&event_ida, minor);

	ida_free(&event_ida, minor);

	return error;

}

	struct event_device_data *dev_data = adev->driver_data;

	cdev_device_del(&dev_data->cdev, &dev_data->dev);

	ida_simple_remove(&event_ida, MINOR(dev_data->dev.devt));

	ida_free(&event_ida, MINOR(dev_data->dev.devt));

	hangup_device(dev_data);

}

	dev_data = kzalloc(sizeof(*dev_data), GFP_KERNEL);

	if (!dev_data) {

		ida_simple_remove(&telem_ida, minor);

		ida_free(&telem_ida, minor);

		return -ENOMEM;

	}

	error = cdev_device_add(&dev_data->cdev, &dev_data->dev);

	if (error) {

		put_device(&dev_data->dev);

		ida_simple_remove(&telem_ida, minor);

		ida_free(&telem_ida, minor);

		return error;

	}

	struct telem_device_data *dev_data = platform_get_drvdata(pdev);

	cdev_device_del(&dev_data->cdev, &dev_data->dev);

	ida_simple_remove(&telem_ida, MINOR(dev_data->dev.devt));

	ida_free(&telem_ida, MINOR(dev_data->dev.devt));

	put_device(&dev_data->dev);

}