fwupd/plugins/flashrom/fu-flashrom-device.c

/*
 * Copyright (C) 2017 Richard Hughes <richard@hughsie.com>
 *
 * SPDX-License-Identifier: LGPL-2.1+
 */

#include "config.h"

#include "fu-flashrom-device.h"

#include <libflashrom.h>

typedef struct {
	FuFlashromDevice		 parent_instance;
	gchar				*programmer_name;
	gchar				*programmer_args;
	gsize				 flash_size;
	struct flashrom_flashctx	*flashctx;
	struct flashrom_programmer	*flashprog;
} FuFlashromDevicePrivate;

G_DEFINE_TYPE_WITH_PRIVATE (FuFlashromDevice, fu_flashrom_device, FU_TYPE_DEVICE)

#define GET_PRIVATE(o) (fu_flashrom_device_get_instance_private (o))

void
fu_flashrom_device_set_programmer_name (FuFlashromDevice *self, const gchar *name)
{
	FuFlashromDevicePrivate *priv = GET_PRIVATE (self);
	g_return_if_fail (FU_IS_FLASHROM_DEVICE (self));
	g_free (priv->programmer_name);
	priv->programmer_name = g_strdup (name);
}

gchar *
fu_flashrom_device_get_programmer_name (FuFlashromDevice *self)
{
	FuFlashromDevicePrivate *priv = GET_PRIVATE (self);
	g_return_val_if_fail (FU_IS_FLASHROM_DEVICE (self), NULL);
	return priv->programmer_name;
}

void
fu_flashrom_device_set_programmer_args (FuFlashromDevice *self, const gchar *args)
{
	FuFlashromDevicePrivate *priv = GET_PRIVATE (self);
	g_return_if_fail (FU_IS_FLASHROM_DEVICE (self));
	g_free (priv->programmer_args);
	priv->programmer_args = g_strdup (args);
}

gsize
fu_flashrom_device_get_flash_size (FuFlashromDevice *self)
{
	FuFlashromDevicePrivate *priv = GET_PRIVATE (self);
	g_return_val_if_fail (FU_IS_FLASHROM_DEVICE (self), 0);
	return priv->flash_size;
}

struct flashrom_flashctx *
fu_flashrom_device_get_flashctx (FuFlashromDevice *self)
{
	FuFlashromDevicePrivate *priv = GET_PRIVATE (self);
	g_return_val_if_fail (FU_IS_FLASHROM_DEVICE (self), NULL);
	return priv->flashctx;
}

static void
fu_flashrom_device_init (FuFlashromDevice *self)
{
	fu_device_add_protocol (FU_DEVICE (self), "org.flashrom");
}

static void
fu_flashrom_device_finalize (GObject *object)
{
	FuFlashromDevicePrivate *priv = GET_PRIVATE (FU_FLASHROM_DEVICE (object));
	g_free (priv->programmer_name);
	g_free (priv->programmer_args);
	G_OBJECT_CLASS (fu_flashrom_device_parent_class)->finalize (object);
}

static gboolean
fu_flashrom_device_set_quirk_kv (FuDevice *device,
				 const gchar *key,
				 const gchar *value,
				 GError **error)
{
	if (g_strcmp0 (key, "PciBcrAddr") == 0) {
		guint64 tmp = fu_common_strtoull (value);
		fu_device_set_metadata_integer (device, "PciBcrAddr", tmp);
		return TRUE;
	}
	if (g_strcmp0 (key, "FlashromProgrammer") == 0) {
		fu_flashrom_device_set_programmer_name (FU_FLASHROM_DEVICE (device), value);
		return TRUE;
	}
	g_set_error_literal (error,
			     G_IO_ERROR,
			     G_IO_ERROR_NOT_SUPPORTED,
			     "no supported");
	return FALSE;
}

static gboolean
fu_flashrom_device_prepare (FuDevice *device,
			    FwupdInstallFlags flags,
			    GError **error)
{
	FuFlashromDevicePrivate *priv = GET_PRIVATE (FU_FLASHROM_DEVICE (device));
	gint rc;

	if (priv->programmer_name == NULL) {
		g_set_error_literal (error,
				     FWUPD_ERROR,
				     FWUPD_ERROR_NOT_SUPPORTED,
				     "programmer not specified");
		return FALSE;
	}

	if (flashrom_programmer_init (&priv->flashprog, priv->programmer_name,
				      priv->programmer_args)) {
		g_set_error_literal (error,
				     FWUPD_ERROR,
				     FWUPD_ERROR_NOT_SUPPORTED,
				     "programmer initialization failed");
		return FALSE;
	}
	rc = flashrom_flash_probe (&priv->flashctx, priv->flashprog, NULL);
	if (rc == 3) {
		g_set_error_literal (error,
				     FWUPD_ERROR,
				     FWUPD_ERROR_NOT_SUPPORTED,
				     "flash probe failed: multiple chips were found");
		return FALSE;
	}
	if (rc == 2) {
		g_set_error_literal (error,
				     FWUPD_ERROR,
				     FWUPD_ERROR_NOT_SUPPORTED,
				     "flash probe failed: no chip was found");
		return FALSE;
	}
	if (rc != 0) {
		g_set_error_literal (error,
				     FWUPD_ERROR,
				     FWUPD_ERROR_NOT_SUPPORTED,
				     "flash probe failed: unknown error");
		return FALSE;
	}
	priv->flash_size = flashrom_flash_getsize (priv->flashctx);
	if (priv->flash_size == 0) {
		g_set_error_literal (error,
				     FWUPD_ERROR,
				     FWUPD_ERROR_NOT_SUPPORTED,
				     "flash size zero");
		return FALSE;
	}

	return TRUE;
}

static gboolean
fu_flashrom_device_cleanup (FuDevice *device,
			    FwupdInstallFlags flags,
			    GError **error)
{
	FuFlashromDevicePrivate *priv = GET_PRIVATE (FU_FLASHROM_DEVICE (device));
	flashrom_flash_release (priv->flashctx);
	flashrom_programmer_shutdown (priv->flashprog);
	return TRUE;
}

static void
fu_flashrom_device_class_init (FuFlashromDeviceClass *klass)
{
	GObjectClass *object_class = G_OBJECT_CLASS (klass);
	FuDeviceClass *klass_device = FU_DEVICE_CLASS (klass);
	object_class->finalize = fu_flashrom_device_finalize;
	klass_device->set_quirk_kv = fu_flashrom_device_set_quirk_kv;
	klass_device->prepare = fu_flashrom_device_prepare;
	klass_device->cleanup = fu_flashrom_device_cleanup;
}