Commit 128818f1 authored by Lee Jones's avatar Lee Jones
Browse files

Merge branches 'ib-mfd-arm-iio-pwm-4.11', 'ib-mfd-input-4.11-1',... 

Merge branches 'ib-mfd-arm-iio-pwm-4.11', 'ib-mfd-input-4.11-1', 'ib-mfd-mtd-4.11' and 'ib-mfd-power-supply-4.11' into ibs-for-mfd-merged
parents 93fbe91b 6ccc3a33 87eb832a 888f9743

Documentation/mtd/intel-spi.txt

0 → 100644
+88 −0
Original line number Diff line number Diff line 
Upgrading BIOS using intel-spi

------------------------------



Many Intel CPUs like Baytrail and Braswell include SPI serial flash host

controller which is used to hold BIOS and other platform specific data.

Since contents of the SPI serial flash is crucial for machine to function,

it is typically protected by different hardware protection mechanisms to

avoid accidental (or on purpose) overwrite of the content.



Not all manufacturers protect the SPI serial flash, mainly because it

allows upgrading the BIOS image directly from an OS.



The intel-spi driver makes it possible to read and write the SPI serial

flash, if certain protection bits are not set and locked. If it finds

any of them set, the whole MTD device is made read-only to prevent

partial overwrites. By default the driver exposes SPI serial flash

contents as read-only but it can be changed from kernel command line,

passing "intel-spi.writeable=1".



Please keep in mind that overwriting the BIOS image on SPI serial flash

might render the machine unbootable and requires special equipment like

Dediprog to revive. You have been warned!



Below are the steps how to upgrade MinnowBoard MAX BIOS directly from

Linux.



 1) Download and extract the latest Minnowboard MAX BIOS SPI image

    [1]. At the time writing this the latest image is v92.



 2) Install mtd-utils package [2]. We need this in order to erase the SPI

    serial flash. Distros like Debian and Fedora have this prepackaged with

    name "mtd-utils".



 3) Add "intel-spi.writeable=1" to the kernel command line and reboot

    the board (you can also reload the driver passing "writeable=1" as

    module parameter to modprobe).



 4) Once the board is up and running again, find the right MTD partition

    (it is named as "BIOS"):



    # cat /proc/mtd

    dev:    size   erasesize  name

    mtd0: 00800000 00001000 "BIOS"



    So here it will be /dev/mtd0 but it may vary.



 5) Make backup of the existing image first:



    # dd if=/dev/mtd0ro of=bios.bak

    16384+0 records in

    16384+0 records out

    8388608 bytes (8.4 MB) copied, 10.0269 s, 837 kB/s



 6) Verify the backup



    # sha1sum /dev/mtd0ro bios.bak

    fdbb011920572ca6c991377c4b418a0502668b73  /dev/mtd0ro

    fdbb011920572ca6c991377c4b418a0502668b73  bios.bak



    The SHA1 sums must match. Otherwise do not continue any further!



 7) Erase the SPI serial flash. After this step, do not reboot the

    board! Otherwise it will not start anymore.



    # flash_erase /dev/mtd0 0 0

    Erasing 4 Kibyte @ 7ff000 -- 100 % complete



 8) Once completed without errors you can write the new BIOS image:



    # dd if=MNW2MAX1.X64.0092.R01.1605221712.bin of=/dev/mtd0



 9) Verify that the new content of the SPI serial flash matches the new

    BIOS image:



    # sha1sum /dev/mtd0ro MNW2MAX1.X64.0092.R01.1605221712.bin

    9b4df9e4be2057fceec3a5529ec3d950836c87a2  /dev/mtd0ro

    9b4df9e4be2057fceec3a5529ec3d950836c87a2 MNW2MAX1.X64.0092.R01.1605221712.bin



    The SHA1 sums should match.



 10) Now you can reboot your board and observe the new BIOS starting up

     properly.



References

----------



[1] https://firmware.intel.com/sites/default/files/MinnowBoard.MAX_.X64.92.R01.zip

[2] http://www.linux-mtd.infradead.org/

drivers/input/keyboard/cros_ec_keyb.c

+407 −45
Original line number Diff line number Diff line
@@ -34,6 +34,8 @@ 
#include <linux/mfd/cros_ec.h>

#include <linux/mfd/cros_ec_commands.h>



#include <asm/unaligned.h>



/*

 * @rows: Number of rows in the keypad

 * @cols: Number of columns in the keypad
@@ -43,8 +45,9 @@ 
 * @valid_keys: bitmap of existing keys for each matrix column

 * @old_kb_state: bitmap of keys pressed last scan

 * @dev: Device pointer

 * @idev: Input device

 * @ec: Top level ChromeOS device to use to talk to EC

 * @idev: The input device for the matrix keys.

 * @bs_idev: The input device for non-matrix buttons and switches (or NULL).

 * @notifier: interrupt event notifier for transport devices

 */

struct cros_ec_keyb {
@@ -57,12 +60,64 @@ struct cros_ec_keyb { 
	uint8_t *old_kb_state;



	struct device *dev;

	struct input_dev *idev;

	struct cros_ec_device *ec;



	struct input_dev *idev;

	struct input_dev *bs_idev;

	struct notifier_block notifier;

};





/**

 * cros_ec_bs_map - Struct mapping Linux keycodes to EC button/switch bitmap

 * #defines

 *

 * @ev_type: The type of the input event to generate (e.g., EV_KEY).

 * @code: A linux keycode

 * @bit: A #define like EC_MKBP_POWER_BUTTON or EC_MKBP_LID_OPEN

 * @inverted: If the #define and EV_SW have opposite meanings, this is true.

 *            Only applicable to switches.

 */

struct cros_ec_bs_map {

	unsigned int ev_type;

	unsigned int code;

	u8 bit;

	bool inverted;

};



/* cros_ec_keyb_bs - Map EC button/switch #defines into kernel ones */

static const struct cros_ec_bs_map cros_ec_keyb_bs[] = {

	/* Buttons */

	{

		.ev_type	= EV_KEY,

		.code		= KEY_POWER,

		.bit		= EC_MKBP_POWER_BUTTON,

	},

	{

		.ev_type	= EV_KEY,

		.code		= KEY_VOLUMEUP,

		.bit		= EC_MKBP_VOL_UP,

	},

	{

		.ev_type	= EV_KEY,

		.code		= KEY_VOLUMEDOWN,

		.bit		= EC_MKBP_VOL_DOWN,

	},



	/* Switches */

	{

		.ev_type	= EV_SW,

		.code		= SW_LID,

		.bit		= EC_MKBP_LID_OPEN,

		.inverted	= true,

	},

	{

		.ev_type	= EV_SW,

		.code		= SW_TABLET_MODE,

		.bit		= EC_MKBP_TABLET_MODE,

	},

};



/*

 * Returns true when there is at least one combination of pressed keys that

 * results in ghosting.
@@ -149,20 +204,33 @@ static void cros_ec_keyb_process(struct cros_ec_keyb *ckdev, 
	input_sync(ckdev->idev);

}



static int cros_ec_keyb_open(struct input_dev *dev)

/**

 * cros_ec_keyb_report_bs - Report non-matrixed buttons or switches

 *

 * This takes a bitmap of buttons or switches from the EC and reports events,

 * syncing at the end.

 *

 * @ckdev: The keyboard device.

 * @ev_type: The input event type (e.g., EV_KEY).

 * @mask: A bitmap of buttons from the EC.

 */

static void cros_ec_keyb_report_bs(struct cros_ec_keyb *ckdev,

				   unsigned int ev_type, u32 mask)



{

	struct cros_ec_keyb *ckdev = input_get_drvdata(dev);

	struct input_dev *idev = ckdev->bs_idev;

	int i;



	return blocking_notifier_chain_register(&ckdev->ec->event_notifier,

						&ckdev->notifier);

}

	for (i = 0; i < ARRAY_SIZE(cros_ec_keyb_bs); i++) {

		const struct cros_ec_bs_map *map = &cros_ec_keyb_bs[i];



static void cros_ec_keyb_close(struct input_dev *dev)

{

	struct cros_ec_keyb *ckdev = input_get_drvdata(dev);

		if (map->ev_type != ev_type)

			continue;



	blocking_notifier_chain_unregister(&ckdev->ec->event_notifier,

					   &ckdev->notifier);

		input_event(idev, ev_type, map->code,

			    !!(mask & BIT(map->bit)) ^ map->inverted);

	}

	input_sync(idev);

}



static int cros_ec_keyb_work(struct notifier_block *nb,
@@ -170,22 +238,54 @@ static int cros_ec_keyb_work(struct notifier_block *nb, 
{

	struct cros_ec_keyb *ckdev = container_of(nb, struct cros_ec_keyb,

						  notifier);

	u32 val;

	unsigned int ev_type;



	if (ckdev->ec->event_data.event_type != EC_MKBP_EVENT_KEY_MATRIX)

		return NOTIFY_DONE;

	switch (ckdev->ec->event_data.event_type) {

	case EC_MKBP_EVENT_KEY_MATRIX:

		/*

	 * If EC is not the wake source, discard key state changes during

	 * suspend.

		 * If EC is not the wake source, discard key state changes

		 * during suspend.

		 */

		if (queued_during_suspend)

			return NOTIFY_OK;



		if (ckdev->ec->event_size != ckdev->cols) {

			dev_err(ckdev->dev,

				"Discarded incomplete key matrix event.\n");

			return NOTIFY_OK;

		}

	cros_ec_keyb_process(ckdev, ckdev->ec->event_data.data.key_matrix,

		cros_ec_keyb_process(ckdev,

				     ckdev->ec->event_data.data.key_matrix,

				     ckdev->ec->event_size);

		break;



	case EC_MKBP_EVENT_BUTTON:

	case EC_MKBP_EVENT_SWITCH:

		/*

		 * If EC is not the wake source, discard key state

		 * changes during suspend. Switches will be re-checked in

		 * cros_ec_keyb_resume() to be sure nothing is lost.

		 */

		if (queued_during_suspend)

			return NOTIFY_OK;



		if (ckdev->ec->event_data.event_type == EC_MKBP_EVENT_BUTTON) {

			val = get_unaligned_le32(

					&ckdev->ec->event_data.data.buttons);

			ev_type = EV_KEY;

		} else {

			val = get_unaligned_le32(

					&ckdev->ec->event_data.data.switches);

			ev_type = EV_SW;

		}

		cros_ec_keyb_report_bs(ckdev, ev_type, val);

		break;



	default:

		return NOTIFY_DONE;

	}



	return NOTIFY_OK;

}
@@ -213,22 +313,228 @@ static void cros_ec_keyb_compute_valid_keys(struct cros_ec_keyb *ckdev) 
	}

}



static int cros_ec_keyb_probe(struct platform_device *pdev)

/**

 * cros_ec_keyb_info - Wrap the EC command EC_CMD_MKBP_INFO

 *

 * This wraps the EC_CMD_MKBP_INFO, abstracting out all of the marshalling and

 * unmarshalling and different version nonsense into something simple.

 *

 * @ec_dev: The EC device

 * @info_type: Either EC_MKBP_INFO_SUPPORTED or EC_MKBP_INFO_CURRENT.

 * @event_type: Either EC_MKBP_EVENT_BUTTON or EC_MKBP_EVENT_SWITCH.  Actually

 *              in some cases this could be EC_MKBP_EVENT_KEY_MATRIX or

 *              EC_MKBP_EVENT_HOST_EVENT too but we don't use in this driver.

 * @result: Where we'll store the result; a union

 * @result_size: The size of the result.  Expected to be the size of one of

 *               the elements in the union.

 *

 * Returns 0 if no error or -error upon error.

 */

static int cros_ec_keyb_info(struct cros_ec_device *ec_dev,

			     enum ec_mkbp_info_type info_type,

			     enum ec_mkbp_event event_type,

			     union ec_response_get_next_data *result,

			     size_t result_size)

{

	struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent);

	struct device *dev = &pdev->dev;

	struct cros_ec_keyb *ckdev;

	struct ec_params_mkbp_info *params;

	struct cros_ec_command *msg;

	int ret;



	msg = kzalloc(sizeof(*msg) + max_t(size_t, result_size,

					   sizeof(*params)), GFP_KERNEL);

	if (!msg)

		return -ENOMEM;



	msg->command = EC_CMD_MKBP_INFO;

	msg->version = 1;

	msg->outsize = sizeof(*params);

	msg->insize = result_size;

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

	params->info_type = info_type;

	params->event_type = event_type;



	ret = cros_ec_cmd_xfer(ec_dev, msg);

	if (ret < 0) {

		dev_warn(ec_dev->dev, "Transfer error %d/%d: %d\n",

			 (int)info_type, (int)event_type, ret);

	} else if (msg->result == EC_RES_INVALID_VERSION) {

		/* With older ECs we just return 0 for everything */

		memset(result, 0, result_size);

		ret = 0;

	} else if (msg->result != EC_RES_SUCCESS) {

		dev_warn(ec_dev->dev, "Error getting info %d/%d: %d\n",

			 (int)info_type, (int)event_type, msg->result);

		ret = -EPROTO;

	} else if (ret != result_size) {

		dev_warn(ec_dev->dev, "Wrong size %d/%d: %d != %zu\n",

			 (int)info_type, (int)event_type,

			 ret, result_size);

		ret = -EPROTO;

	} else {

		memcpy(result, msg->data, result_size);

		ret = 0;

	}



	kfree(msg);



	return ret;

}



/**

 * cros_ec_keyb_query_switches - Query the state of switches and report

 *

 * This will ask the EC about the current state of switches and report to the

 * kernel.  Note that we don't query for buttons because they are more

 * transitory and we'll get an update on the next release / press.

 *

 * @ckdev: The keyboard device

 *

 * Returns 0 if no error or -error upon error.

 */

static int cros_ec_keyb_query_switches(struct cros_ec_keyb *ckdev)

{

	struct cros_ec_device *ec_dev = ckdev->ec;

	union ec_response_get_next_data event_data = {};

	int ret;



	ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_CURRENT,

				EC_MKBP_EVENT_SWITCH, &event_data,

				sizeof(event_data.switches));

	if (ret)

		return ret;



	cros_ec_keyb_report_bs(ckdev, EV_SW,

			       get_unaligned_le32(&event_data.switches));



	return 0;

}



/**

 * cros_ec_keyb_resume - Resume the keyboard

 *

 * We use the resume notification as a chance to query the EC for switches.

 *

 * @dev: The keyboard device

 *

 * Returns 0 if no error or -error upon error.

 */

static __maybe_unused int cros_ec_keyb_resume(struct device *dev)

{

	struct cros_ec_keyb *ckdev = dev_get_drvdata(dev);



	if (ckdev->bs_idev)

		return cros_ec_keyb_query_switches(ckdev);



	return 0;

}



/**

 * cros_ec_keyb_register_bs - Register non-matrix buttons/switches

 *

 * Handles all the bits of the keyboard driver related to non-matrix buttons

 * and switches, including asking the EC about which are present and telling

 * the kernel to expect them.

 *

 * If this device has no support for buttons and switches we'll return no error

 * but the ckdev->bs_idev will remain NULL when this function exits.

 *

 * @ckdev: The keyboard device

 *

 * Returns 0 if no error or -error upon error.

 */

static int cros_ec_keyb_register_bs(struct cros_ec_keyb *ckdev)

{

	struct cros_ec_device *ec_dev = ckdev->ec;

	struct device *dev = ckdev->dev;

	struct input_dev *idev;

	struct device_node *np;

	int err;

	union ec_response_get_next_data event_data = {};

	const char *phys;

	u32 buttons;

	u32 switches;

	int ret;

	int i;



	ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_SUPPORTED,

				EC_MKBP_EVENT_BUTTON, &event_data,

				sizeof(event_data.buttons));

	if (ret)

		return ret;

	buttons = get_unaligned_le32(&event_data.buttons);



	ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_SUPPORTED,

				EC_MKBP_EVENT_SWITCH, &event_data,

				sizeof(event_data.switches));

	if (ret)

		return ret;

	switches = get_unaligned_le32(&event_data.switches);



	if (!buttons && !switches)

		return 0;



	np = pdev->dev.of_node;

	if (!np)

		return -ENODEV;

	/*

	 * We call the non-matrix buttons/switches 'input1', if present.

	 * Allocate phys before input dev, to ensure correct tear-down

	 * ordering.

	 */

	phys = devm_kasprintf(dev, GFP_KERNEL, "%s/input1", ec_dev->phys_name);

	if (!phys)

		return -ENOMEM;



	ckdev = devm_kzalloc(dev, sizeof(*ckdev), GFP_KERNEL);

	if (!ckdev)

	idev = devm_input_allocate_device(dev);

	if (!idev)

		return -ENOMEM;



	idev->name = "cros_ec_buttons";

	idev->phys = phys;

	__set_bit(EV_REP, idev->evbit);



	idev->id.bustype = BUS_VIRTUAL;

	idev->id.version = 1;

	idev->id.product = 0;

	idev->dev.parent = dev;



	input_set_drvdata(idev, ckdev);

	ckdev->bs_idev = idev;



	for (i = 0; i < ARRAY_SIZE(cros_ec_keyb_bs); i++) {

		const struct cros_ec_bs_map *map = &cros_ec_keyb_bs[i];



		if (buttons & BIT(map->bit))

			input_set_capability(idev, map->ev_type, map->code);

	}



	ret = cros_ec_keyb_query_switches(ckdev);

	if (ret) {

		dev_err(dev, "cannot query switches\n");

		return ret;

	}



	ret = input_register_device(ckdev->bs_idev);

	if (ret) {

		dev_err(dev, "cannot register input device\n");

		return ret;

	}



	return 0;

}



/**

 * cros_ec_keyb_register_bs - Register matrix keys

 *

 * Handles all the bits of the keyboard driver related to matrix keys.

 *

 * @ckdev: The keyboard device

 *

 * Returns 0 if no error or -error upon error.

 */

static int cros_ec_keyb_register_matrix(struct cros_ec_keyb *ckdev)

{

	struct cros_ec_device *ec_dev = ckdev->ec;

	struct device *dev = ckdev->dev;

	struct input_dev *idev;

	const char *phys;

	int err;



	err = matrix_keypad_parse_of_params(dev, &ckdev->rows, &ckdev->cols);

	if (err)

		return err;
@@ -241,27 +547,28 @@ static int cros_ec_keyb_probe(struct platform_device *pdev) 
	if (!ckdev->old_kb_state)

		return -ENOMEM;



	/*

	 * We call the keyboard matrix 'input0'. Allocate phys before input

	 * dev, to ensure correct tear-down ordering.

	 */

	phys = devm_kasprintf(dev, GFP_KERNEL, "%s/input0", ec_dev->phys_name);

	if (!phys)

		return -ENOMEM;



	idev = devm_input_allocate_device(dev);

	if (!idev)

		return -ENOMEM;



	ckdev->ec = ec;

	ckdev->notifier.notifier_call = cros_ec_keyb_work;

	ckdev->dev = dev;

	dev_set_drvdata(dev, ckdev);



	idev->name = CROS_EC_DEV_NAME;

	idev->phys = ec->phys_name;

	idev->phys = phys;

	__set_bit(EV_REP, idev->evbit);



	idev->id.bustype = BUS_VIRTUAL;

	idev->id.version = 1;

	idev->id.product = 0;

	idev->dev.parent = dev;

	idev->open = cros_ec_keyb_open;

	idev->close = cros_ec_keyb_close;



	ckdev->ghost_filter = of_property_read_bool(np,

	ckdev->ghost_filter = of_property_read_bool(dev->of_node,

					"google,needs-ghost-filter");



	err = matrix_keypad_build_keymap(NULL, NULL, ckdev->rows, ckdev->cols,
@@ -287,6 +594,57 @@ static int cros_ec_keyb_probe(struct platform_device *pdev) 
	return 0;

}



static int cros_ec_keyb_probe(struct platform_device *pdev)

{

	struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent);

	struct device *dev = &pdev->dev;

	struct cros_ec_keyb *ckdev;

	int err;



	if (!dev->of_node)

		return -ENODEV;



	ckdev = devm_kzalloc(dev, sizeof(*ckdev), GFP_KERNEL);

	if (!ckdev)

		return -ENOMEM;



	ckdev->ec = ec;

	ckdev->dev = dev;

	dev_set_drvdata(dev, ckdev);



	err = cros_ec_keyb_register_matrix(ckdev);

	if (err) {

		dev_err(dev, "cannot register matrix inputs: %d\n", err);

		return err;

	}



	err = cros_ec_keyb_register_bs(ckdev);

	if (err) {

		dev_err(dev, "cannot register non-matrix inputs: %d\n", err);

		return err;

	}



	ckdev->notifier.notifier_call = cros_ec_keyb_work;

	err = blocking_notifier_chain_register(&ckdev->ec->event_notifier,

					       &ckdev->notifier);

	if (err) {

		dev_err(dev, "cannot register notifier: %d\n", err);

		return err;

	}



	return 0;

}



static int cros_ec_keyb_remove(struct platform_device *pdev)

{

	struct cros_ec_keyb *ckdev = dev_get_drvdata(&pdev->dev);



	blocking_notifier_chain_unregister(&ckdev->ec->event_notifier,

					   &ckdev->notifier);



	return 0;

}



#ifdef CONFIG_OF

static const struct of_device_id cros_ec_keyb_of_match[] = {

	{ .compatible = "google,cros-ec-keyb" },
@@ -295,11 +653,15 @@ static const struct of_device_id cros_ec_keyb_of_match[] = { 
MODULE_DEVICE_TABLE(of, cros_ec_keyb_of_match);

#endif



static const SIMPLE_DEV_PM_OPS(cros_ec_keyb_pm_ops, NULL, cros_ec_keyb_resume);



static struct platform_driver cros_ec_keyb_driver = {

	.probe = cros_ec_keyb_probe,

	.remove = cros_ec_keyb_remove,

	.driver = {

		.name = "cros-ec-keyb",

		.of_match_table = of_match_ptr(cros_ec_keyb_of_match),

		.pm = &cros_ec_keyb_pm_ops,

	},

};

drivers/mfd/lpc_ich.c

+131 −0
Original line number Diff line number Diff line
@@ -56,6 +56,7 @@ 
 *	document number TBD : Wildcat Point-LP

 *	document number TBD : 9 Series

 *	document number TBD : Lewisburg

 *	document number TBD : Apollo Lake SoC

 */



#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
@@ -83,6 +84,17 @@ 
#define ACPIBASE_GCS_OFF	0x3410

#define ACPIBASE_GCS_END	0x3414



#define SPIBASE_BYT		0x54

#define SPIBASE_BYT_SZ		512

#define SPIBASE_BYT_EN		BIT(1)



#define SPIBASE_LPT		0x3800

#define SPIBASE_LPT_SZ		512

#define BCR			0xdc

#define BCR_WPD			BIT(0)



#define SPIBASE_APL_SZ		4096



#define GPIOBASE_ICH0		0x58

#define GPIOCTRL_ICH0		0x5C

#define GPIOBASE_ICH6		0x48
@@ -133,6 +145,12 @@ static struct resource gpio_ich_res[] = { 
	},

};



static struct resource intel_spi_res[] = {

	{

		.flags = IORESOURCE_MEM,

	}

};



static struct mfd_cell lpc_ich_wdt_cell = {

	.name = "iTCO_wdt",

	.num_resources = ARRAY_SIZE(wdt_ich_res),
@@ -147,6 +165,14 @@ static struct mfd_cell lpc_ich_gpio_cell = { 
	.ignore_resource_conflicts = true,

};





static struct mfd_cell lpc_ich_spi_cell = {

	.name = "intel-spi",

	.num_resources = ARRAY_SIZE(intel_spi_res),

	.resources = intel_spi_res,

	.ignore_resource_conflicts = true,

};



/* chipset related info */

enum lpc_chipsets {

	LPC_ICH = 0,	/* ICH */
@@ -216,6 +242,7 @@ enum lpc_chipsets { 
	LPC_BRASWELL,	/* Braswell SoC */

	LPC_LEWISBURG,	/* Lewisburg */

	LPC_9S,		/* 9 Series */

	LPC_APL,	/* Apollo Lake SoC */

};



static struct lpc_ich_info lpc_chipset_info[] = {
@@ -494,10 +521,12 @@ static struct lpc_ich_info lpc_chipset_info[] = { 
		.name = "Lynx Point",

		.iTCO_version = 2,

		.gpio_version = ICH_V5_GPIO,

		.spi_type = INTEL_SPI_LPT,

	},

	[LPC_LPT_LP] = {

		.name = "Lynx Point_LP",

		.iTCO_version = 2,

		.spi_type = INTEL_SPI_LPT,

	},

	[LPC_WBG] = {

		.name = "Wellsburg",
@@ -511,6 +540,7 @@ static struct lpc_ich_info lpc_chipset_info[] = { 
	[LPC_BAYTRAIL] = {

		.name = "Bay Trail SoC",

		.iTCO_version = 3,

		.spi_type = INTEL_SPI_BYT,

	},

	[LPC_COLETO] = {

		.name = "Coleto Creek",
@@ -519,10 +549,12 @@ static struct lpc_ich_info lpc_chipset_info[] = { 
	[LPC_WPT_LP] = {

		.name = "Wildcat Point_LP",

		.iTCO_version = 2,

		.spi_type = INTEL_SPI_LPT,

	},

	[LPC_BRASWELL] = {

		.name = "Braswell SoC",

		.iTCO_version = 3,

		.spi_type = INTEL_SPI_BYT,

	},

	[LPC_LEWISBURG] = {

		.name = "Lewisburg",
@@ -533,6 +565,10 @@ static struct lpc_ich_info lpc_chipset_info[] = { 
		.iTCO_version = 2,

		.gpio_version = ICH_V5_GPIO,

	},

	[LPC_APL] = {

		.name = "Apollo Lake SoC",

		.spi_type = INTEL_SPI_BXT,

	},

};



/*
@@ -681,6 +717,7 @@ static const struct pci_device_id lpc_ich_ids[] = { 
	{ PCI_VDEVICE(INTEL, 0x3b14), LPC_3420},

	{ PCI_VDEVICE(INTEL, 0x3b16), LPC_3450},

	{ PCI_VDEVICE(INTEL, 0x5031), LPC_EP80579},

	{ PCI_VDEVICE(INTEL, 0x5ae8), LPC_APL},

	{ PCI_VDEVICE(INTEL, 0x8c40), LPC_LPT},

	{ PCI_VDEVICE(INTEL, 0x8c41), LPC_LPT},

	{ PCI_VDEVICE(INTEL, 0x8c42), LPC_LPT},
@@ -1056,6 +1093,94 @@ static int lpc_ich_init_wdt(struct pci_dev *dev) 
	return ret;

}



static int lpc_ich_init_spi(struct pci_dev *dev)

{

	struct lpc_ich_priv *priv = pci_get_drvdata(dev);

	struct resource *res = &intel_spi_res[0];

	struct intel_spi_boardinfo *info;

	u32 spi_base, rcba, bcr;



	info = devm_kzalloc(&dev->dev, sizeof(*info), GFP_KERNEL);

	if (!info)

		return -ENOMEM;



	info->type = lpc_chipset_info[priv->chipset].spi_type;



	switch (info->type) {

	case INTEL_SPI_BYT:

		pci_read_config_dword(dev, SPIBASE_BYT, &spi_base);

		if (spi_base & SPIBASE_BYT_EN) {

			res->start = spi_base & ~(SPIBASE_BYT_SZ - 1);

			res->end = res->start + SPIBASE_BYT_SZ - 1;

		}

		break;



	case INTEL_SPI_LPT:

		pci_read_config_dword(dev, RCBABASE, &rcba);

		if (rcba & 1) {

			spi_base = round_down(rcba, SPIBASE_LPT_SZ);

			res->start = spi_base + SPIBASE_LPT;

			res->end = res->start + SPIBASE_LPT_SZ - 1;



			/*

			 * Try to make the flash chip writeable now by

			 * setting BCR_WPD. It it fails we tell the driver

			 * that it can only read the chip.

			 */

			pci_read_config_dword(dev, BCR, &bcr);

			if (!(bcr & BCR_WPD)) {

				bcr |= BCR_WPD;

				pci_write_config_dword(dev, BCR, bcr);

				pci_read_config_dword(dev, BCR, &bcr);

			}

			info->writeable = !!(bcr & BCR_WPD);

		}

		break;



	case INTEL_SPI_BXT: {

		unsigned int p2sb = PCI_DEVFN(13, 0);

		unsigned int spi = PCI_DEVFN(13, 2);

		struct pci_bus *bus = dev->bus;



		/*

		 * The P2SB is hidden by BIOS and we need to unhide it in

		 * order to read BAR of the SPI flash device. Once that is

		 * done we hide it again.

		 */

		pci_bus_write_config_byte(bus, p2sb, 0xe1, 0x0);

		pci_bus_read_config_dword(bus, spi, PCI_BASE_ADDRESS_0,

					  &spi_base);

		if (spi_base != ~0) {

			res->start = spi_base & 0xfffffff0;

			res->end = res->start + SPIBASE_APL_SZ - 1;



			pci_bus_read_config_dword(bus, spi, BCR, &bcr);

			if (!(bcr & BCR_WPD)) {

				bcr |= BCR_WPD;

				pci_bus_write_config_dword(bus, spi, BCR, bcr);

				pci_bus_read_config_dword(bus, spi, BCR, &bcr);

			}

			info->writeable = !!(bcr & BCR_WPD);

		}



		pci_bus_write_config_byte(bus, p2sb, 0xe1, 0x1);

		break;

	}



	default:

		return -EINVAL;

	}



	if (!res->start)

		return -ENODEV;



	lpc_ich_spi_cell.platform_data = info;

	lpc_ich_spi_cell.pdata_size = sizeof(*info);



	return mfd_add_devices(&dev->dev, PLATFORM_DEVID_NONE,

			       &lpc_ich_spi_cell, 1, NULL, 0, NULL);

}



static int lpc_ich_probe(struct pci_dev *dev,

				const struct pci_device_id *id)

{
@@ -1099,6 +1224,12 @@ static int lpc_ich_probe(struct pci_dev *dev, 
			cell_added = true;

	}



	if (lpc_chipset_info[priv->chipset].spi_type) {

		ret = lpc_ich_init_spi(dev);

		if (!ret)

			cell_added = true;

	}



	/*

	 * We only care if at least one or none of the cells registered

	 * successfully.

drivers/mtd/spi-nor/Kconfig

+20 −0
Original line number Diff line number Diff line
@@ -76,4 +76,24 @@ config SPI_NXP_SPIFI 
	  Flash. Enable this option if you have a device with a SPIFI

	  controller and want to access the Flash as a mtd device.



config SPI_INTEL_SPI

	tristate



config SPI_INTEL_SPI_PLATFORM

	tristate "Intel PCH/PCU SPI flash platform driver" if EXPERT

	depends on X86

	select SPI_INTEL_SPI

	help

	  This enables platform support for the Intel PCH/PCU SPI

	  controller in master mode. This controller is present in modern

	  Intel hardware and is used to hold BIOS and other persistent

	  settings. Using this driver it is possible to upgrade BIOS

	  directly from Linux.



	  Say N here unless you know what you are doing. Overwriting the

	  SPI flash may render the system unbootable.



	  To compile this driver as a module, choose M here: the module

	  will be called intel-spi-platform.



endif # MTD_SPI_NOR

drivers/mtd/spi-nor/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -5,3 +5,5 @@ obj-$(CONFIG_SPI_FSL_QUADSPI) += fsl-quadspi.o 
obj-$(CONFIG_SPI_HISI_SFC)	+= hisi-sfc.o

obj-$(CONFIG_MTD_MT81xx_NOR)    += mtk-quadspi.o

obj-$(CONFIG_SPI_NXP_SPIFI)	+= nxp-spifi.o

obj-$(CONFIG_SPI_INTEL_SPI)	+= intel-spi.o

obj-$(CONFIG_SPI_INTEL_SPI_PLATFORM)	+= intel-spi-platform.o