Commit 4ba85265 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for_linus' of git://cavan.codon.org.uk/platform-drivers-x86 

Pull x86 platform driver updates from Matthew Garrett:
 "Support for the new keyboard features on the Thinkpad Carbon, a bunch
  of updates for the Sony and Toshiba drivers, a new driver for upcoming
  Alienware hardware and a few misc fixes.  There's a couple of patches
  that got Acked today but aren't invasive, so I'll send a further PR
  for them next week"

* 'for_linus' of git://cavan.codon.org.uk/platform-drivers-x86: (28 commits)
  alienware-wmi: cover some scenarios where memory allocations would fail
  Add WMI driver for controlling AlienFX features on some Alienware products
  fujitsu-tablet: add support for Lifebook T901 and T902
  x86, platform: Make HP_WIRELESS option text more descriptive
  x86, acpi: LLVMLinux: Remove nested functions from Thinkpad ACPI
  save and restore adaptive keyboard mode for suspend and,resume
  support Thinkpad X1 Carbon 2nd generation's adaptive keyboard
  toshiba_acpi: Fix whitespace
  toshiba_acpi: Update version and copyright info
  toshiba_acpi: Add accelerometer support
  toshiba_acpi: Add ECO mode led support
  toshiba_acpi: Add touchpad enable/disable support-
  toshiba_acpi: Add keyboard backlight support
  toshiba_acpi: Adapt Illumination code to use SCI
  toshiba_acpi: Add System Configuration Interface
  thinkpad_acpi: Fix inconsistent mute LED after resume
  sonypi: Simplify dependencies
  Revert "X86 platform: New BayTrail IOSF-SB MBI driver"
  sony-laptop: remove useless sony-laptop versioning
  sony-laptop: add smart connect control function
  ...
parents dd76a786 562c7cec

drivers/char/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -408,7 +408,7 @@ config APPLICOM 


config SONYPI

	tristate "Sony Vaio Programmable I/O Control Device support"

	depends on X86 && PCI && INPUT && !64BIT

	depends on X86_32 && PCI && INPUT

	---help---

	  This driver enables access to the Sony Programmable I/O Control

	  Device which can be found in many (all ?) Sony Vaio laptops.

drivers/platform/x86/Kconfig

+13 −9
Original line number Diff line number Diff line
@@ -53,6 +53,18 @@ config ACERHDF 
	  If you have an Acer Aspire One netbook, say Y or M

	  here.



config ALIENWARE_WMI

	tristate "Alienware Special feature control"

	depends on ACPI

	depends on LEDS_CLASS

	depends on NEW_LEDS

	depends on ACPI_WMI

	---help---

	 This is a driver for controlling Alienware BIOS driven

	 features.  It exposes an interface for controlling the AlienFX

	 zones on Alienware machines that don't contain a dedicated AlienFX

	 USB MCU such as the X51 and X51-R2.



config ASUS_LAPTOP

	tristate "Asus Laptop Extras"

	depends on ACPI
@@ -196,7 +208,7 @@ config HP_ACCEL 
	  be called hp_accel.



config HP_WIRELESS

	tristate "HP WIRELESS"

	tristate "HP wireless button"

	depends on ACPI

	depends on INPUT

	help
@@ -817,12 +829,4 @@ config PVPANIC 
	  a paravirtualized device provided by QEMU; it lets a virtual machine

	  (guest) communicate panic events to the host.



config INTEL_BAYTRAIL_MBI

	tristate

	depends on PCI

	---help---

	  Needed on Baytrail platforms for access to the IOSF Sideband Mailbox

	  Interface. This is a requirement for systems that need to configure

	  the PUNIT for power management features such as RAPL.



endif # X86_PLATFORM_DEVICES

drivers/platform/x86/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -55,4 +55,4 @@ obj-$(CONFIG_INTEL_RST) += intel-rst.o 
obj-$(CONFIG_INTEL_SMARTCONNECT)	+= intel-smartconnect.o



obj-$(CONFIG_PVPANIC)           += pvpanic.o

obj-$(CONFIG_INTEL_BAYTRAIL_MBI)	+= intel_baytrail.o
 
obj-$(CONFIG_ALIENWARE_WMI)	+= alienware-wmi.o

drivers/platform/x86/alienware-wmi.c

0 → 100644
+565 −0
Original line number Diff line number Diff line 
/*

 * Alienware AlienFX control

 *

 * Copyright (C) 2014 Dell Inc <mario_limonciello@dell.com>

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 */



#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt



#include <linux/acpi.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/dmi.h>

#include <linux/acpi.h>

#include <linux/leds.h>



#define LEGACY_CONTROL_GUID		"A90597CE-A997-11DA-B012-B622A1EF5492"

#define LEGACY_POWER_CONTROL_GUID	"A80593CE-A997-11DA-B012-B622A1EF5492"

#define WMAX_CONTROL_GUID		"A70591CE-A997-11DA-B012-B622A1EF5492"



#define WMAX_METHOD_HDMI_SOURCE		0x1

#define WMAX_METHOD_HDMI_STATUS		0x2

#define WMAX_METHOD_BRIGHTNESS		0x3

#define WMAX_METHOD_ZONE_CONTROL	0x4



MODULE_AUTHOR("Mario Limonciello <mario_limonciello@dell.com>");

MODULE_DESCRIPTION("Alienware special feature control");

MODULE_LICENSE("GPL");

MODULE_ALIAS("wmi:" LEGACY_CONTROL_GUID);

MODULE_ALIAS("wmi:" WMAX_CONTROL_GUID);



enum INTERFACE_FLAGS {

	LEGACY,

	WMAX,

};



enum LEGACY_CONTROL_STATES {

	LEGACY_RUNNING = 1,

	LEGACY_BOOTING = 0,

	LEGACY_SUSPEND = 3,

};



enum WMAX_CONTROL_STATES {

	WMAX_RUNNING = 0xFF,

	WMAX_BOOTING = 0,

	WMAX_SUSPEND = 3,

};



struct quirk_entry {

	u8 num_zones;

};



static struct quirk_entry *quirks;



static struct quirk_entry quirk_unknown = {

	.num_zones = 2,

};



static struct quirk_entry quirk_x51_family = {

	.num_zones = 3,

};



static int dmi_matched(const struct dmi_system_id *dmi)

{

	quirks = dmi->driver_data;

	return 1;

}



static struct dmi_system_id alienware_quirks[] = {

	{

	 .callback = dmi_matched,

	 .ident = "Alienware X51 R1",

	 .matches = {

		     DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),

		     DMI_MATCH(DMI_PRODUCT_NAME, "Alienware X51"),

		     },

	 .driver_data = &quirk_x51_family,

	 },

	{

	 .callback = dmi_matched,

	 .ident = "Alienware X51 R2",

	 .matches = {

		     DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),

		     DMI_MATCH(DMI_PRODUCT_NAME, "Alienware X51 R2"),

		     },

	 .driver_data = &quirk_x51_family,

	 },

	{}

};



struct color_platform {

	u8 blue;

	u8 green;

	u8 red;

} __packed;



struct platform_zone {

	u8 location;

	struct device_attribute *attr;

	struct color_platform colors;

};



struct wmax_brightness_args {

	u32 led_mask;

	u32 percentage;

};



struct hdmi_args {

	u8 arg;

};



struct legacy_led_args {

	struct color_platform colors;

	u8 brightness;

	u8 state;

} __packed;



struct wmax_led_args {

	u32 led_mask;

	struct color_platform colors;

	u8 state;

} __packed;



static struct platform_device *platform_device;

static struct device_attribute *zone_dev_attrs;

static struct attribute **zone_attrs;

static struct platform_zone *zone_data;



static struct platform_driver platform_driver = {

	.driver = {

		   .name = "alienware-wmi",

		   .owner = THIS_MODULE,

		   }

};



static struct attribute_group zone_attribute_group = {

	.name = "rgb_zones",

};



static u8 interface;

static u8 lighting_control_state;

static u8 global_brightness;



/*

 * Helpers used for zone control

*/

static int parse_rgb(const char *buf, struct platform_zone *zone)

{

	long unsigned int rgb;

	int ret;

	union color_union {

		struct color_platform cp;

		int package;

	} repackager;



	ret = kstrtoul(buf, 16, &rgb);

	if (ret)

		return ret;



	/* RGB triplet notation is 24-bit hexadecimal */

	if (rgb > 0xFFFFFF)

		return -EINVAL;



	repackager.package = rgb & 0x0f0f0f0f;

	pr_debug("alienware-wmi: r: %d g:%d b: %d\n",

		 repackager.cp.red, repackager.cp.green, repackager.cp.blue);

	zone->colors = repackager.cp;

	return 0;

}



static struct platform_zone *match_zone(struct device_attribute *attr)

{

	int i;

	for (i = 0; i < quirks->num_zones; i++) {

		if ((struct device_attribute *)zone_data[i].attr == attr) {

			pr_debug("alienware-wmi: matched zone location: %d\n",

				 zone_data[i].location);

			return &zone_data[i];

		}

	}

	return NULL;

}



/*

 * Individual RGB zone control

*/

static int alienware_update_led(struct platform_zone *zone)

{

	int method_id;

	acpi_status status;

	char *guid;

	struct acpi_buffer input;

	struct legacy_led_args legacy_args;

	struct wmax_led_args wmax_args;

	if (interface == WMAX) {

		wmax_args.led_mask = 1 << zone->location;

		wmax_args.colors = zone->colors;

		wmax_args.state = lighting_control_state;

		guid = WMAX_CONTROL_GUID;

		method_id = WMAX_METHOD_ZONE_CONTROL;



		input.length = (acpi_size) sizeof(wmax_args);

		input.pointer = &wmax_args;

	} else {

		legacy_args.colors = zone->colors;

		legacy_args.brightness = global_brightness;

		legacy_args.state = 0;

		if (lighting_control_state == LEGACY_BOOTING ||

		    lighting_control_state == LEGACY_SUSPEND) {

			guid = LEGACY_POWER_CONTROL_GUID;

			legacy_args.state = lighting_control_state;

		} else

			guid = LEGACY_CONTROL_GUID;

		method_id = zone->location + 1;



		input.length = (acpi_size) sizeof(legacy_args);

		input.pointer = &legacy_args;

	}

	pr_debug("alienware-wmi: guid %s method %d\n", guid, method_id);



	status = wmi_evaluate_method(guid, 1, method_id, &input, NULL);

	if (ACPI_FAILURE(status))

		pr_err("alienware-wmi: zone set failure: %u\n", status);

	return ACPI_FAILURE(status);

}



static ssize_t zone_show(struct device *dev, struct device_attribute *attr,

			 char *buf)

{

	struct platform_zone *target_zone;

	target_zone = match_zone(attr);

	if (target_zone == NULL)

		return sprintf(buf, "red: -1, green: -1, blue: -1\n");

	return sprintf(buf, "red: %d, green: %d, blue: %d\n",

		       target_zone->colors.red,

		       target_zone->colors.green, target_zone->colors.blue);



}



static ssize_t zone_set(struct device *dev, struct device_attribute *attr,

			const char *buf, size_t count)

{

	struct platform_zone *target_zone;

	int ret;

	target_zone = match_zone(attr);

	if (target_zone == NULL) {

		pr_err("alienware-wmi: invalid target zone\n");

		return 1;

	}

	ret = parse_rgb(buf, target_zone);

	if (ret)

		return ret;

	ret = alienware_update_led(target_zone);

	return ret ? ret : count;

}



/*

 * LED Brightness (Global)

*/

static int wmax_brightness(int brightness)

{

	acpi_status status;

	struct acpi_buffer input;

	struct wmax_brightness_args args = {

		.led_mask = 0xFF,

		.percentage = brightness,

	};

	input.length = (acpi_size) sizeof(args);

	input.pointer = &args;

	status = wmi_evaluate_method(WMAX_CONTROL_GUID, 1,

				     WMAX_METHOD_BRIGHTNESS, &input, NULL);

	if (ACPI_FAILURE(status))

		pr_err("alienware-wmi: brightness set failure: %u\n", status);

	return ACPI_FAILURE(status);

}



static void global_led_set(struct led_classdev *led_cdev,

			   enum led_brightness brightness)

{

	int ret;

	global_brightness = brightness;

	if (interface == WMAX)

		ret = wmax_brightness(brightness);

	else

		ret = alienware_update_led(&zone_data[0]);

	if (ret)

		pr_err("LED brightness update failed\n");

}



static enum led_brightness global_led_get(struct led_classdev *led_cdev)

{

	return global_brightness;

}



static struct led_classdev global_led = {

	.brightness_set = global_led_set,

	.brightness_get = global_led_get,

	.name = "alienware::global_brightness",

};



/*

 * Lighting control state device attribute (Global)

*/

static ssize_t show_control_state(struct device *dev,

				  struct device_attribute *attr, char *buf)

{

	if (lighting_control_state == LEGACY_BOOTING)

		return scnprintf(buf, PAGE_SIZE, "[booting] running suspend\n");

	else if (lighting_control_state == LEGACY_SUSPEND)

		return scnprintf(buf, PAGE_SIZE, "booting running [suspend]\n");

	return scnprintf(buf, PAGE_SIZE, "booting [running] suspend\n");

}



static ssize_t store_control_state(struct device *dev,

				   struct device_attribute *attr,

				   const char *buf, size_t count)

{

	long unsigned int val;

	if (strcmp(buf, "booting\n") == 0)

		val = LEGACY_BOOTING;

	else if (strcmp(buf, "suspend\n") == 0)

		val = LEGACY_SUSPEND;

	else if (interface == LEGACY)

		val = LEGACY_RUNNING;

	else

		val = WMAX_RUNNING;

	lighting_control_state = val;

	pr_debug("alienware-wmi: updated control state to %d\n",

		 lighting_control_state);

	return count;

}



static DEVICE_ATTR(lighting_control_state, 0644, show_control_state,

		   store_control_state);



static int alienware_zone_init(struct platform_device *dev)

{

	int i;

	char buffer[10];

	char *name;



	if (interface == WMAX) {

		global_led.max_brightness = 100;

		lighting_control_state = WMAX_RUNNING;

	} else if (interface == LEGACY) {

		global_led.max_brightness = 0x0F;

		lighting_control_state = LEGACY_RUNNING;

	}

	global_brightness = global_led.max_brightness;



	/*

	 *      - zone_dev_attrs num_zones + 1 is for individual zones and then

	 *        null terminated

	 *      - zone_attrs num_zones + 2 is for all attrs in zone_dev_attrs +

	 *        the lighting control + null terminated

	 *      - zone_data num_zones is for the distinct zones

	 */

	zone_dev_attrs =

	    kzalloc(sizeof(struct device_attribute) * (quirks->num_zones + 1),

		    GFP_KERNEL);

	if (!zone_dev_attrs)

		return -ENOMEM;



	zone_attrs =

	    kzalloc(sizeof(struct attribute *) * (quirks->num_zones + 2),

		    GFP_KERNEL);

	if (!zone_attrs)

		return -ENOMEM;



	zone_data =

	    kzalloc(sizeof(struct platform_zone) * (quirks->num_zones),

		    GFP_KERNEL);

	if (!zone_data)

		return -ENOMEM;



	for (i = 0; i < quirks->num_zones; i++) {

		sprintf(buffer, "zone%02X", i);

		name = kstrdup(buffer, GFP_KERNEL);

		if (name == NULL)

			return 1;

		sysfs_attr_init(&zone_dev_attrs[i].attr);

		zone_dev_attrs[i].attr.name = name;

		zone_dev_attrs[i].attr.mode = 0644;

		zone_dev_attrs[i].show = zone_show;

		zone_dev_attrs[i].store = zone_set;

		zone_data[i].location = i;

		zone_attrs[i] = &zone_dev_attrs[i].attr;

		zone_data[i].attr = &zone_dev_attrs[i];

	}

	zone_attrs[quirks->num_zones] = &dev_attr_lighting_control_state.attr;

	zone_attribute_group.attrs = zone_attrs;



	led_classdev_register(&dev->dev, &global_led);



	return sysfs_create_group(&dev->dev.kobj, &zone_attribute_group);

}



static void alienware_zone_exit(struct platform_device *dev)

{

	sysfs_remove_group(&dev->dev.kobj, &zone_attribute_group);

	led_classdev_unregister(&global_led);

	if (zone_dev_attrs) {

		int i;

		for (i = 0; i < quirks->num_zones; i++)

			kfree(zone_dev_attrs[i].attr.name);

	}

	kfree(zone_dev_attrs);

	kfree(zone_data);

	kfree(zone_attrs);

}



/*

	The HDMI mux sysfs node indicates the status of the HDMI input mux.

	It can toggle between standard system GPU output and HDMI input.

*/

static ssize_t show_hdmi(struct device *dev, struct device_attribute *attr,

			 char *buf)

{

	acpi_status status;

	struct acpi_buffer input;

	union acpi_object *obj;

	u32 tmp = 0;

	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };

	struct hdmi_args in_args = {

		.arg = 0,

	};

	input.length = (acpi_size) sizeof(in_args);

	input.pointer = &in_args;

	status = wmi_evaluate_method(WMAX_CONTROL_GUID, 1,

				     WMAX_METHOD_HDMI_STATUS, &input, &output);



	if (ACPI_SUCCESS(status)) {

		obj = (union acpi_object *)output.pointer;

		if (obj && obj->type == ACPI_TYPE_INTEGER)

			tmp = (u32) obj->integer.value;

		if (tmp == 1)

			return scnprintf(buf, PAGE_SIZE,

					 "[input] gpu unknown\n");

		else if (tmp == 2)

			return scnprintf(buf, PAGE_SIZE,

					 "input [gpu] unknown\n");

	}

	pr_err("alienware-wmi: unknown HDMI status: %d\n", status);

	return scnprintf(buf, PAGE_SIZE, "input gpu [unknown]\n");

}



static ssize_t toggle_hdmi(struct device *dev, struct device_attribute *attr,

			   const char *buf, size_t count)

{

	struct acpi_buffer input;

	acpi_status status;

	struct hdmi_args args;

	if (strcmp(buf, "gpu\n") == 0)

		args.arg = 1;

	else if (strcmp(buf, "input\n") == 0)

		args.arg = 2;

	else

		args.arg = 3;

	pr_debug("alienware-wmi: setting hdmi to %d : %s", args.arg, buf);

	input.length = (acpi_size) sizeof(args);

	input.pointer = &args;

	status = wmi_evaluate_method(WMAX_CONTROL_GUID, 1,

				     WMAX_METHOD_HDMI_SOURCE, &input, NULL);

	if (ACPI_FAILURE(status))

		pr_err("alienware-wmi: HDMI toggle failed: results: %u\n",

		       status);

	return count;

}



static DEVICE_ATTR(hdmi, S_IRUGO | S_IWUSR, show_hdmi, toggle_hdmi);



static void remove_hdmi(struct platform_device *device)

{

	device_remove_file(&device->dev, &dev_attr_hdmi);

}



static int create_hdmi(void)

{

	int ret = -ENOMEM;

	ret = device_create_file(&platform_device->dev, &dev_attr_hdmi);

	if (ret)

		goto error_create_hdmi;

	return 0;



error_create_hdmi:

	remove_hdmi(platform_device);

	return ret;

}



static int __init alienware_wmi_init(void)

{

	int ret;



	if (wmi_has_guid(LEGACY_CONTROL_GUID))

		interface = LEGACY;

	else if (wmi_has_guid(WMAX_CONTROL_GUID))

		interface = WMAX;

	else {

		pr_warn("alienware-wmi: No known WMI GUID found\n");

		return -ENODEV;

	}



	dmi_check_system(alienware_quirks);

	if (quirks == NULL)

		quirks = &quirk_unknown;



	ret = platform_driver_register(&platform_driver);

	if (ret)

		goto fail_platform_driver;

	platform_device = platform_device_alloc("alienware-wmi", -1);

	if (!platform_device) {

		ret = -ENOMEM;

		goto fail_platform_device1;

	}

	ret = platform_device_add(platform_device);

	if (ret)

		goto fail_platform_device2;



	if (interface == WMAX) {

		ret = create_hdmi();

		if (ret)

			goto fail_prep_hdmi;

	}



	ret = alienware_zone_init(platform_device);

	if (ret)

		goto fail_prep_zones;



	return 0;



fail_prep_zones:

	alienware_zone_exit(platform_device);

fail_prep_hdmi:

	platform_device_del(platform_device);

fail_platform_device2:

	platform_device_put(platform_device);

fail_platform_device1:

	platform_driver_unregister(&platform_driver);

fail_platform_driver:

	return ret;

}



module_init(alienware_wmi_init);



static void __exit alienware_wmi_exit(void)

{

	if (platform_device) {

		alienware_zone_exit(platform_device);

		remove_hdmi(platform_device);

		platform_device_unregister(platform_device);

		platform_driver_unregister(&platform_driver);

	}

}



module_exit(alienware_wmi_exit);

drivers/platform/x86/fujitsu-tablet.c

+65 −0
Original line number Diff line number Diff line
@@ -71,6 +71,44 @@ static unsigned short keymap_Lifebook_Tseries[KEYMAP_LEN] __initdata = { 
	KEY_LEFTALT

};



static unsigned short keymap_Lifebook_T901[KEYMAP_LEN] __initdata = {

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_SCROLLDOWN,

	KEY_SCROLLUP,

	KEY_CYCLEWINDOWS,

	KEY_LEFTCTRL,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_LEFTMETA

};



static unsigned short keymap_Lifebook_T902[KEYMAP_LEN] __initdata = {

	KEY_RESERVED,

	KEY_VOLUMEDOWN,

	KEY_VOLUMEUP,

	KEY_CYCLEWINDOWS,

	KEY_PROG1,

	KEY_PROG2,

	KEY_LEFTMETA,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

	KEY_RESERVED,

};



static unsigned short keymap_Lifebook_U810[KEYMAP_LEN] __initdata = {

	KEY_RESERVED,

	KEY_RESERVED,
@@ -300,6 +338,33 @@ static int fujitsu_dmi_stylistic(const struct dmi_system_id *dmi) 
}



static const struct dmi_system_id dmi_ids[] __initconst = {

	{

		.callback = fujitsu_dmi_lifebook,

		.ident = "Fujitsu Lifebook T901",

		.matches = {

			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),

			DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook T901")

		},

		.driver_data = keymap_Lifebook_T901

	},

	{

		.callback = fujitsu_dmi_lifebook,

		.ident = "Fujitsu Lifebook T901",

		.matches = {

			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),

			DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK T901")

		},

		.driver_data = keymap_Lifebook_T901

	},

	{

		.callback = fujitsu_dmi_lifebook,

		.ident = "Fujitsu Lifebook T902",

		.matches = {

			DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),

			DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK T902")

		},

		.driver_data = keymap_Lifebook_T902

	},

	{

		.callback = fujitsu_dmi_lifebook,

		.ident = "Fujitsu Siemens P/T Series",

CRA Git | Maintained and supported by SUSTech CRA and CCSE