| #ifdef ANDROID /* Should work fine on non Android platforms, but is only necessary on Android */ |
| #ifdef BROADCOM |
| |
| /* Broadcom platform implementation using the NEXUS API. |
| Only the GFHD254 is supported via this API as of now. */ |
| |
| #include <fcntl.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "brcm-platform.h" |
| |
| #include "nexus_avs.h" |
| #include "nexus_pwm.h" |
| #include "nexus_gpio.h" |
| #include "nxclient.h" |
| |
| #define UNUSED __attribute__((unused)) |
| #define ARRAYSIZE(x) (sizeof(x) / sizeof(x[0])) |
| |
| static void init_gfhd254(struct platform_info* p); |
| static double get_avs_voltage_7252(struct Voltage* v); |
| static double get_avs_temperature_7252(struct Temp* t); |
| |
| /* This is an array. Of structs! It contains structs of |
| the type platform_info. The platform_info struct provides |
| much useful information for use in all sorts of fun |
| operations. Structs are considered "aggregate types", |
| which you can of course read all about by pointing your |
| browser at Google and searching for your favorite version |
| of our beloved C standard, such as ISO/IEC 9899:TC3! */ |
| struct platform_info platforms[] = { |
| { |
| .name = "GFHD254", |
| .init = init_gfhd254, |
| .leds = { |
| .led_red = { |
| .is_present = 1, // AON_GPIO_05 |
| .type = AON, |
| .pin = 5, |
| .old_val = -1, |
| }, |
| .led_blue = { |
| .is_present = 0, |
| }, |
| .led_activity = { |
| .is_present = 1, // AON_GPIO_04 |
| .pin = 4, |
| .type = AON, |
| .old_val = -1, |
| }, |
| .led_standby = { |
| .is_present = 0, |
| }, |
| .led_brightness = { |
| .is_present = 1, // GPIO_098 |
| .open_drain = 0, |
| .pwm_index = 2, |
| .old_percent = -1, |
| }, |
| }, |
| .reset_button = { |
| .is_present = 1, // GPIO_009 |
| .pin = 9, |
| .type = STANDARD, |
| .old_val = -1, |
| }, |
| .fan_tick = { |
| .is_present = 1, // GPIO 78 |
| .pin = 78, |
| .type = STANDARD, |
| .old_val = -1, |
| }, |
| .fan_control = { |
| .is_present = 1, // GPIO_098 |
| .open_drain = 0, |
| .pwm_index = 3, |
| .old_percent = -1, |
| }, |
| .temp_monitor = { |
| .is_present = 1, // 7252 AVS_RO_REGISTERS_0 |
| .get_temp = get_avs_temperature_7252, |
| }, |
| .voltage_monitor = { |
| .is_present = 1, |
| .get_voltage = get_avs_voltage_7252, |
| }, |
| } |
| }; |
| |
| struct platform_info *get_platform_info(const char *platform_name) { |
| for (unsigned int i = 0; i < ARRAYSIZE(platforms); ++i) { |
| struct platform_info *p = &platforms[i]; |
| if (0 == strncmp(platform_name, p->name, strlen(p->name))) { |
| return p; |
| } |
| } |
| fprintf(stderr, "No support for platform %s", platform_name); |
| return NULL; |
| } |
| |
| static NEXUS_GpioType get_nexus_type(enum GpioType type) { |
| switch (type) { |
| case STANDARD: |
| return NEXUS_GpioType_eStandard; |
| case AON: |
| return NEXUS_GpioType_eAonStandard; |
| } |
| |
| /* If we added a GpioType and are using it and never updated this, we |
| are going to have a bad time somewhere. Return an invalid val and let |
| nxclient handle it, while logging the problem. */ |
| fprintf(stderr, "No matching NEXUS type for GPIO: %d\n", type); |
| return -1; |
| } |
| |
| // Don't need to set direction for GFHD254 |
| static void initialize_gpio(struct Gpio* gpio) { |
| if (!gpio || !gpio->is_present) |
| return; |
| |
| /* TODO(doughorn): Cannot set pinmux from NEXUS? Can retrieve |
| pinmux information but can't set it because it is 'dangerous'. |
| So we can use the raw Read/WriteRegister functions. These, however, |
| are also dangerous and their "indiscriminate use will result in |
| system failure." Seems to work properly without us setting... */ |
| NEXUS_GpioSettings gpioSettings; |
| NEXUS_GpioHandle handle; |
| NEXUS_GpioType type = get_nexus_type(gpio->type); |
| |
| NEXUS_Gpio_GetDefaultSettings(type, &gpioSettings); |
| gpioSettings.mode = NEXUS_GpioMode_eOutputPushPull; |
| gpioSettings.interruptMode = NEXUS_GpioInterrupt_eDisabled; |
| |
| handle = NEXUS_Gpio_Open(type, gpio->pin, &gpioSettings); |
| if (!handle) { |
| fprintf(stderr, "Failed opening GPIO pin %d. gpio-mailbox cannot continue.\n", gpio->pin); |
| platform_cleanup(); |
| exit(EXIT_FAILURE); |
| } |
| |
| NEXUS_Gpio_Close(handle); |
| } |
| |
| /* TODO(doughorn): We can probably avoid calling GetAvsStatus twice for |
| the voltage and temp individually, but the poll rate is low enough |
| that it most likely doesn't matter...*/ |
| static double get_avs_voltage_7252(UNUSED struct Voltage* v) { |
| NEXUS_AvsStatus status; |
| if (NEXUS_GetAvsStatus(&status)) { |
| fprintf(stderr, "Could not get AVS status. Aborting...\n"); |
| platform_cleanup(); |
| exit(EXIT_FAILURE); |
| } |
| |
| /* NEXUS_AvsStatus.voltage measured in millivolts */ |
| return (double)status.voltage / 1000; |
| } |
| |
| static double get_avs_temperature_7252(UNUSED struct Temp* t) { |
| NEXUS_AvsStatus status; |
| |
| if (NEXUS_GetAvsStatus(&status)) { |
| fprintf(stderr, "Could not get AVS status. Aborting...\n"); |
| platform_cleanup(); |
| exit(EXIT_FAILURE); |
| } |
| |
| /* Temp is in thousands of a degree. */ |
| return (double)status.temperature / 1000; |
| } |
| |
| static void init_gfhd254(struct platform_info* p) { |
| NEXUS_PwmChannelSettings pwmSettings; |
| NEXUS_PwmChannelHandle pwm; |
| NEXUS_PwmFreqModeType frequencyMode; |
| |
| /* Set the control word for the led brightness PWM to 0xf. |
| This is used to control the output frequency from the |
| variable rate clock. */ |
| NEXUS_Pwm_GetDefaultChannelSettings(&pwmSettings); |
| pwm = NEXUS_Pwm_OpenChannel(2, &pwmSettings); |
| if (NEXUS_Pwm_SetControlWord(pwm, 0xf)) { |
| fprintf(stderr, "Failed setting control word for PWM.\n"); |
| platform_cleanup(); |
| exit(EXIT_FAILURE); |
| } |
| |
| NEXUS_Pwm_CloseChannel(pwm); |
| |
| /* Set the control word for the fan to 0x2000. */ |
| NEXUS_Pwm_GetDefaultChannelSettings(&pwmSettings); |
| pwm = NEXUS_Pwm_OpenChannel(3, &pwmSettings); |
| if (NEXUS_Pwm_SetControlWord(pwm, 0x2000)) { |
| fprintf(stderr, "Failed setting control word for PWM.\n"); |
| platform_cleanup(); |
| exit(EXIT_FAILURE); |
| } |
| |
| NEXUS_Pwm_CloseChannel(pwm); |
| |
| set_pwm(&p->leds.led_brightness, 27); |
| } |
| |
| void platform_cleanup() { |
| NxClient_Uninit(); |
| } |
| |
| int platform_init(struct platform_info* p) { |
| if (NxClient_Join(NULL)) { |
| fprintf(stderr, "gpio-mailbox failed to connect to nxserver. Aborting...\n"); |
| return -1; |
| } |
| |
| if (p->init) { |
| (*p->init)(p); |
| } |
| |
| initialize_gpio(&p->leds.led_red); |
| initialize_gpio(&p->leds.led_blue); |
| initialize_gpio(&p->leds.led_activity); |
| initialize_gpio(&p->leds.led_standby); |
| return 0; |
| } |
| |
| void set_gpio(struct Gpio *gpio, int level) { |
| if (!gpio || !gpio->is_present || gpio->old_val == level) { |
| // If this is the same value as last time, don't do anything, for two |
| // reasons: |
| // 1) If you set the gpio too often, it seems to stay low (the led |
| // stays off). |
| // 2) If some process other than us is twiddling a led, this way we |
| // won't interfere with it. |
| return; |
| } |
| |
| gpio->old_val = level; |
| |
| NEXUS_GpioSettings gpioSettings; |
| NEXUS_GpioHandle handle; |
| uint32_t error; |
| NEXUS_GpioType type = get_nexus_type(gpio->type); |
| |
| handle = NEXUS_Gpio_Open(type, gpio->pin, NULL); |
| if (!handle) { |
| fprintf(stderr, "Failed opening GPIO pin %d. Cannot continue.\n", gpio->pin); |
| platform_cleanup(); |
| exit(EXIT_FAILURE); |
| } |
| |
| NEXUS_Gpio_GetSettings(handle, &gpioSettings); |
| gpioSettings.value = level ? NEXUS_GpioValue_eHigh : NEXUS_GpioValue_eLow; |
| if ((error = NEXUS_Gpio_SetSettings(handle, &gpioSettings))) { |
| fprintf(stderr, "Failed setting GPIO pin %d. Cannot continue.\n", gpio->pin); |
| platform_cleanup(); |
| exit(EXIT_FAILURE); |
| } |
| |
| NEXUS_Gpio_Close(handle); |
| } |
| |
| int get_gpio(struct Gpio *gpio) { |
| if (!gpio || !gpio->is_present) |
| return 0; |
| |
| NEXUS_GpioStatus status; |
| NEXUS_GpioHandle handle; |
| uint32_t error; |
| NEXUS_GpioType type = get_nexus_type(gpio->type); |
| |
| handle = NEXUS_Gpio_Open(type, gpio->pin, NULL); |
| |
| if (!handle) { |
| fprintf(stderr, "Failed opening GPIO pin %d. Cannot continue.\n", gpio->pin); |
| platform_cleanup(); |
| exit(EXIT_FAILURE); |
| } |
| |
| if ((error = NEXUS_Gpio_GetStatus(handle, &status))) { |
| fprintf(stderr, "Failed getting status of GPIO pin %d. Cannot continue.\n", gpio->pin); |
| platform_cleanup(); |
| exit(EXIT_FAILURE); |
| } |
| |
| NEXUS_Gpio_Close(handle); |
| |
| return status.value != NEXUS_GpioValue_eLow; |
| } |
| |
| /* |
| Set the pwm. See set_pwm in brcm-direct.c |
| for details. |
| */ |
| void set_pwm(struct PwmControl *f, int percent) { |
| if (percent < 0) percent = 0; |
| if (percent > 100) percent = 100; |
| if (percent == f->old_percent) return; |
| f->old_percent = percent; |
| uint32_t period = f->pwm_index % 2 ? 0x91 : 0x63; |
| |
| NEXUS_PwmChannelSettings pwmSettings; |
| NEXUS_PwmChannelHandle pwm; |
| uint16_t onInterval = (period * percent)/100; |
| |
| NEXUS_Pwm_GetDefaultChannelSettings(&pwmSettings); |
| pwmSettings.openDrain = f->open_drain; |
| pwmSettings.eFreqMode = NEXUS_PwmFreqModeType_eConstant; |
| pwm = NEXUS_Pwm_OpenChannel(f->pwm_index, &pwmSettings); |
| |
| if (NEXUS_Pwm_SetOnAndPeriodInterval(pwm, onInterval, period)) { |
| fprintf(stderr, "Could not set ON and PERIOD for PWM. Aborting...\n"); |
| platform_cleanup(); |
| exit(EXIT_FAILURE); |
| } |
| |
| if (NEXUS_Pwm_Start(pwm)) { |
| fprintf(stderr, "Could not start PWM %d!\n", f->pwm_index); |
| platform_cleanup(); |
| exit(EXIT_FAILURE); |
| } |
| |
| NEXUS_Pwm_CloseChannel(pwm); |
| } |
| |
| #endif // BROADCOM |
| #endif // ANDROID |