int
main (void)
{
/* Initialize GPIO (sets up clock) */
GPIOInit ();
/* Set LED port pin to output */
GPIOSetDir (LED_PORT, LED_BIT, 1);
GPIOSetValue (LED_PORT, LED_BIT, LED_OFF);
/* Init Power Management Routines */
pmu_init ();
/* UART setup */
UARTInit (115200, 0);
/* CDC USB Initialization */
init_usbserial ();
/* Init RFID */
rfid_init ();
/* Init emulation triggers */
trigger_init ();
/* RUN RFID loop */
loop_rfid ();
return 0;
}
int __init oprofile_arch_init(struct oprofile_operations **ops)
{
int ret = -ENODEV;
#ifdef CONFIG_CPU_XSCALE
ret = pmu_init(ops, &op_xscale_spec);
#endif
return ret;
}
static void
pmu_attach(device_t parent, device_t self, void *aux)
{
struct confargs *ca = aux;
struct pmu_softc *sc = device_private(self);
#if notyet
struct i2cbus_attach_args iba;
#endif
uint32_t regs[16];
int irq = ca->ca_intr[0];
int node, extint_node, root_node;
int nbat = 1, i, pmnode;
int type = IST_EDGE;
uint8_t cmd[2] = {2, 0};
uint8_t resp[16];
char name[256];
extint_node = of_getnode_byname(OF_parent(ca->ca_node), "extint-gpio1");
if (extint_node) {
OF_getprop(extint_node, "interrupts", &irq, 4);
type = IST_LEVEL;
}
aprint_normal(" irq %d: ", irq);
sc->sc_dev = self;
sc->sc_node = ca->ca_node;
sc->sc_memt = ca->ca_tag;
root_node = OF_finddevice("/");
sc->sc_error = 0;
sc->sc_autopoll = 0;
sc->sc_pending_eject = 0;
sc->sc_brightness = sc->sc_brightness_wanted = 0x80;
sc->sc_volume = sc->sc_volume_wanted = 0x80;
sc->sc_flags = 0;
sc->sc_callback = NULL;
sc->sc_lid_closed = 0;
if (bus_space_map(sc->sc_memt, ca->ca_reg[0] + ca->ca_baseaddr,
ca->ca_reg[1], 0, &sc->sc_memh) != 0) {
aprint_error_dev(self, "unable to map registers\n");
return;
}
sc->sc_ih = intr_establish(irq, type, IPL_TTY, pmu_intr, sc);
pmu_init(sc);
sc->sc_pmu_ops.cookie = sc;
sc->sc_pmu_ops.do_command = pmu_send;
sc->sc_pmu_ops.register_callback = pmu_register_callback;
if (pmu0 == NULL)
pmu0 = sc;
pmu_send(sc, PMU_SYSTEM_READY, 1, cmd, 16, resp);
/* check what kind of PMU we're talking to */
if (pmu_send(sc, PMU_GET_VERSION, 0, cmd, 16, resp) > 1)
aprint_normal(" rev. %d", resp[1]);
aprint_normal("\n");
node = OF_child(sc->sc_node);
while (node != 0) {
if (OF_getprop(node, "name", name, 256) == 0)
goto next;
if (strncmp(name, "pmu-i2c", 8) == 0) {
aprint_normal_dev(self, "initializing IIC bus\n");
goto next;
}
if (strncmp(name, "adb", 4) == 0) {
aprint_normal_dev(self, "initializing ADB\n");
sc->sc_adbops.cookie = sc;
sc->sc_adbops.send = pmu_adb_send;
sc->sc_adbops.poll = pmu_adb_poll;
sc->sc_adbops.autopoll = pmu_autopoll;
sc->sc_adbops.set_handler = pmu_adb_set_handler;
#if NNADB > 0
config_found_ia(self, "adb_bus", &sc->sc_adbops,
nadb_print);
#endif
goto next;
}
if (strncmp(name, "rtc", 4) == 0) {
aprint_normal_dev(self, "initializing RTC\n");
sc->sc_todr.todr_gettime = pmu_todr_get;
sc->sc_todr.todr_settime = pmu_todr_set;
sc->sc_todr.cookie = sc;
todr_attach(&sc->sc_todr);
goto next;
}
if (strncmp(name, "battery", 8) == 0)
goto next;
aprint_normal_dev(self, "%s not configured\n", name);
next:
node = OF_peer(node);
}
if (OF_finddevice("/bandit/ohare") != -1) {
aprint_normal_dev(self, "enabling ohare backlight control\n");
sc->sc_flags |= PMU_HAS_BACKLIGHT_CONTROL;
cmd[0] = 0;
cmd[1] = 0;
memset(resp, 0, 6);
if (pmu_send(sc, PMU_READ_BRIGHTNESS, 1, cmd, 16, resp) > 1) {
sc->sc_brightness_wanted = resp[1];
pmu_update_brightness(sc);
}
}
/* attach batteries */
if (of_compatible(root_node, has_legacy_battery) != -1) {
pmu_attach_legacy_battery(sc);
} else if (of_compatible(root_node, has_two_smart_batteries) != -1) {
pmu_attach_smart_battery(sc, 0);
pmu_attach_smart_battery(sc, 1);
} else {
/* check how many batteries we have */
pmnode = of_getnode_byname(ca->ca_node, "power-mgt");
if (pmnode == -1)
goto bat_done;
if (OF_getprop(pmnode, "prim-info", regs, sizeof(regs)) < 24)
goto bat_done;
nbat = regs[6] >> 16;
for (i = 0; i < nbat; i++)
pmu_attach_smart_battery(sc, i);
}
bat_done:
#if notyet
memset(&iba, 0, sizeof(iba));
iba.iba_tag = &sc->sc_i2c;
sc->sc_i2c.ic_cookie = sc;
sc->sc_i2c.ic_acquire_bus = pmu_i2c_acquire_bus;
sc->sc_i2c.ic_release_bus = pmu_i2c_release_bus;
sc->sc_i2c.ic_send_start = NULL;
sc->sc_i2c.ic_send_stop = NULL;
sc->sc_i2c.ic_initiate_xfer = NULL;
sc->sc_i2c.ic_read_byte = NULL;
sc->sc_i2c.ic_write_byte = NULL;
sc->sc_i2c.ic_exec = pmu_i2c_exec;
config_found_ia(sc->sc_dev, "i2cbus", &iba, iicbus_print);
#endif
if (kthread_create(PRI_NONE, 0, NULL, pmu_thread, sc, &sc->sc_thread,
"%s", "pmu") != 0) {
aprint_error_dev(self, "unable to create event kthread\n");
}
sc->sc_lidswitch.smpsw_name = "Lid switch";
sc->sc_lidswitch.smpsw_type = PSWITCH_TYPE_LID;
if (sysmon_pswitch_register(&sc->sc_lidswitch) != 0)
aprint_error_dev(self,
"unable to register lid switch with sysmon\n");
}
void charger_task(void)
{
int next_state;
int wait_time = T1_USEC;
timestamp_t pre_chg_start = get_time();
pmu_init();
/* Enable low current charging */
pmu_low_current_charging(1);
/* Enable charger interrupt */
gpio_enable_interrupt(GPIO_CHARGER_INT_L);
/*
* EC STOP mode support
* The charging loop can be stopped in idle state with AC unplugged.
* Charging loop will be resumed by TPSCHROME interrupt.
*/
enable_charging(0);
disable_sleep(SLEEP_MASK_CHARGING);
while (1) {
last_waken = get_time();
pmu_clear_irq();
#ifdef CONFIG_PMU_TPS65090_CHARGING_LED
update_battery_led();
#endif
/*
* When battery is extremely low, the internal voltage can not
* power on its gas guage IC. Charging loop will enable the
* charger and turn on trickle charging. For safty reason,
* charger should be disabled if the communication to battery
* failed.
*/
if (current_state == ST_PRE_CHARGING &&
get_time().val - pre_chg_start.val >= PRE_CHARGING_TIMEOUT)
next_state = ST_CHARGING_ERROR;
else
next_state = calc_next_state(current_state);
if (next_state != current_state) {
/* Reset state of charge moving average window */
rsoc_moving_average(-1);
CPRINTS("batt state %s -> %s",
state_list[current_state],
state_list[next_state]);
current_state = next_state;
switch (current_state) {
case ST_PRE_CHARGING:
pre_chg_start = get_time();
/* Fall through */
case ST_CHARGING:
if (pmu_blink_led(0))
next_state = ST_CHARGING_ERROR;
else
enable_charging(1);
break;
case ST_CHARGING_ERROR:
/*
* Enable hardware charging circuit after set
* PMU to hardware error state.
*/
if (pmu_blink_led(1))
enable_charging(0);
else
enable_charging(1);
break;
case ST_IDLE:
case ST_IDLE0:
case ST_BAD_COND:
case ST_DISCHARGING:
enable_charging(0);
/* Ignore charger error when discharging */
pmu_blink_led(0);
break;
}
}
switch (current_state) {
case ST_CHARGING:
case ST_CHARGING_ERROR:
wait_time = T2_USEC;
break;
case ST_DISCHARGING:
wait_time = T3_USEC;
break;
case ST_PRE_CHARGING:
wait_time = T1_USEC;
if (get_time().val - pre_chg_start.val >=
PRE_CHARGING_TIMEOUT)
enable_charging(0);
break;
default:
if (extpower_is_present()) {
wait_time = T1_USEC;
break;
} else if (chipset_in_state(CHIPSET_STATE_ANY_OFF)) {
wait_time = T1_OFF_USEC;
enable_sleep(SLEEP_MASK_CHARGING);
} else if (chipset_in_state(CHIPSET_STATE_SUSPEND)) {
wait_time = T1_SUSPEND_USEC;
} else {
wait_time = T1_USEC;
}
}
if (!has_pending_event) {
task_wait_event(wait_time);
disable_sleep(SLEEP_MASK_CHARGING);
} else {
has_pending_event = 0;
}
}
}
int
main (void)
{
double t;
int i, word, x, y;
const TWordPos *w;
TRGB color, *p;
/* Initialize GPIO (sets up clock) */
GPIOInit ();
/* Set LED port pin to output */
GPIOSetDir (LED_PORT, LED_PIN0, 1);
GPIOSetValue (LED_PORT, LED_PIN0, LED_OFF);
/* Init Power Management Routines */
pmu_init ();
/* setup SPI chipselect pin */
spi_init ();
spi_init_pin (SPI_CS_RGB);
/* transmit image */
t = 0;
word = 0;
while(1)
{
/* set background to red */
memset(g_data, g_cie[0x00], sizeof(g_data));
for(y=0; y<LED_Y; y++)
for(x=0; x<LED_X; x++)
{
g_data[y][x].r = g_cie[0x16];
g_data[y][x].g = g_cie[0x0B];
}
/* get next word */
i = g_sentence[word/DELAY];
word++;
if(word>=(WORD_COUNT*DELAY))
word=0;
if(i>=0)
{
w = &g_words[i];
for(i=0; i<w->length; i++)
{
/* word coordinates */
x = w->x + i;
y = w->y;
/* update color */
color.r = (sin( x*0.1+cos(y*0.1+t))*CIE_MAX_INDEX2)+CIE_MAX_INDEX2;
color.g = (cos(-y*0.2-sin(x*0.3-t))*CIE_MAX_INDEX2)+CIE_MAX_INDEX2;
color.b = (cos( x*0.5-cos(y*0.4+t))*CIE_MAX_INDEX2)+CIE_MAX_INDEX2;
p = &g_data[y][x];
p->r = g_cie[color.r];
p->g = g_cie[color.g];
p->b = g_cie[color.b];
}
}
/* send data */
update_leds();
pmu_wait_ms(1);
t+=0.01;
}
}
int
main (void)
{
uint64_t time_us;
/* Initialize GPIO (sets up clock) */
GPIOInit ();
/* Set eMeter port pin to input/pullup/hysteresis/CAP0 */
LPC_IOCON->PIO1_5 = 2| 2<<3 | 1<<5;
GPIOSetDir (EMETER_PORT, EMETER_PIN, 0);
GPIOSetValue (EMETER_PORT, EMETER_PIN, 0);
/* Set LED port pin to output */
GPIOSetDir (LED_PORT, LED_PIN0, 1);
GPIOSetDir (LED_PORT, LED_PIN1, 1);
GPIOSetValue (LED_PORT, LED_PIN0, LED_OFF);
GPIOSetValue (LED_PORT, LED_PIN1, LED_OFF);
/* Init Power Management Routines */
pmu_init ();
/* CDC USB Initialization */
init_usbserial ();
/* configure TMR32B0 for capturing eMeter pulse duration in us */
LPC_SYSCON->SYSAHBCLKCTRL |= (1 << 9);
LPC_TMR32B0->PR = SYSTEM_CORE_CLOCK/1000000;
LPC_TMR32B0->TCR = 2;
LPC_TMR32B0->CCR = 6;
/* enable TMR32B0 timer IRQ */
pulse_count = pulse_length = 0;
timer_old = LPC_TMR32B0->TC;
NVIC_EnableIRQ(TIMER_32_0_IRQn);
/* release counter */
LPC_TMR32B0->TCR = 1;
time_us=0;
while(TRUE)
{
if(pulse_length)
{
time_us+=pulse_length;
/* print count, time[s], power[mWh] */
debug_printf (
"%u,%u,%u\n",
pulse_count,
(uint32_t)(time_us/1000000UL),
(uint32_t)(3600000000000ULL/pulse_length)
);
pulse_length = 0;
}
/* blink once per second */
GPIOSetValue (LED_PORT, LED_PIN0, LED_ON);
pmu_wait_ms(50);
GPIOSetValue (LED_PORT, LED_PIN0, LED_OFF);
pmu_wait_ms(950);
}
return 0;
}
int
main (void)
{
/* accelerometer readings fifo */
TFifoEntry acc_lowpass;
TFifoEntry fifo_buf[FIFO_DEPTH];
int fifo_pos;
TFifoEntry *fifo;
uint32_t SSPdiv;
uint16_t oid_last_seen;
uint8_t cmd_buffer[64], cmd_pos, c;
uint8_t volatile *uart;
int x, y, z, moving;
volatile int t;
int i;
/* wait on boot - debounce */
for (t = 0; t < 2000000; t++);
/* Initialize GPIO (sets up clock) */
GPIOInit ();
/* initialize pins */
pin_init ();
/* fire up LED 1 */
GPIOSetValue (1, 1, 1);
/* initialize SPI */
spi_init ();
/* read device UUID */
bzero (&device_uuid, sizeof (device_uuid));
iap_read_uid (&device_uuid);
tag_id = crc16 ((uint8_t *) & device_uuid, sizeof (device_uuid));
random_seed =
device_uuid[0] ^ device_uuid[1] ^ device_uuid[2] ^ device_uuid[3];
/************ IF Plugged to computer upon reset ? ******************/
if (GPIOGetValue (0, 3))
{
/* wait some time till Bluetooth is off */
for (t = 0; t < 2000000; t++);
/* Init 3D acceleration sensor */
acc_init (1);
/* Init Flash Storage with USB */
storage_init (TRUE, tag_id);
g_storage_items = storage_items ();
/* Init Bluetooth */
bt_init (TRUE, tag_id);
/* switch to LED 2 */
GPIOSetValue (1, 1, 0);
GPIOSetValue (1, 2, 1);
/* set command buffer to empty */
cmd_pos = 0;
/* spin in loop */
while (1)
{
/* reset after USB unplug */
if (!GPIOGetValue (0, 3))
NVIC_SystemReset ();
/* if UART rx send to menue */
if (UARTCount)
{
/* blink LED1 upon Bluetooth command */
GPIOSetValue (1, 1, 1);
/* execute menue command with last character received */
/* scan through whole UART buffer */
uart = UARTBuffer;
for (i = UARTCount; i > 0; i--)
{
UARTCount--;
c = *uart++;
if ((c < ' ') && cmd_pos)
{
/* if one-character command - execute */
if (cmd_pos == 1)
main_menue (cmd_buffer[0]);
else
{
cmd_buffer[cmd_pos] = 0;
debug_printf
("Unknown command '%s' - please press H+[Enter] for help\n# ",
cmd_buffer);
}
/* set command buffer to empty */
cmd_pos = 0;
}
else if (cmd_pos < (sizeof (cmd_buffer) - 2))
cmd_buffer[cmd_pos++] = c;
}
/* reset UART buffer */
UARTCount = 0;
/* un-blink LED1 */
GPIOSetValue (1, 1, 0);
}
}
} /* End of if plugged to computer*/
/***************** IF UNPLUGGED TO PC ........********/
/* Init Bluetooth */
bt_init (FALSE, tag_id);
/* shut down up LED 1 */
GPIOSetValue (1, 1, 0);
/* Init Flash Storage without USB */
storage_init (FALSE, tag_id);
/* get current FLASH storage write postition */
g_storage_items = storage_items ();
/* initialize power management */
pmu_init ();
/* blink once to show initialized flash */
blink (1);
/* Init 3D acceleration sensor */
acc_init (0);
blink (2);
/* Initialize OpenBeacon nRF24L01 interface */
if (!nRFAPI_Init(CONFIG_TRACKER_CHANNEL, broadcast_mac, sizeof (broadcast_mac), 0))
for (;;)
{
GPIOSetValue (1, 2, 1);
pmu_sleep_ms (500);
GPIOSetValue (1, 2, 0);
pmu_sleep_ms (500);
}
/* set tx power power to high */
nRFCMD_Power (1);
/* blink three times to show flash initialized RF interface */
blink (3);
/* blink LED for 1s to show readyness */
GPIOSetValue (1, 1, 0);
GPIOSetValue (1, 2, 1);
pmu_sleep_ms (1000);
GPIOSetValue (1, 2, 0);
/* disable unused jobs */
SSPdiv = LPC_SYSCON->SSPCLKDIV;
i = 0;
oid_last_seen = 0;
/* reset proximity buffer */
prox_head = prox_tail = 0;
bzero (&prox, sizeof (prox));
/*initialize FIFO */
fifo_pos = 0;
bzero (&acc_lowpass, sizeof (acc_lowpass));
bzero (&fifo_buf, sizeof (fifo_buf));
moving = 0;
g_sequence = 0;
while (1)
{
pmu_sleep_ms (500);
LPC_SYSCON->SSPCLKDIV = SSPdiv;
acc_power (1);
pmu_sleep_ms (20);
acc_xyz_read (&x, &y, &z);
acc_power (0);
fifo = &fifo_buf[fifo_pos];
if (fifo_pos >= (FIFO_DEPTH - 1))
fifo_pos = 0;
else
fifo_pos++;
acc_lowpass.x += x - fifo->x;
fifo->x = x;
acc_lowpass.y += y - fifo->y;
fifo->y = y;
acc_lowpass.z += z - fifo->z;
fifo->z = z;
nRFAPI_SetRxMode (0);
bzero (&g_Beacon, sizeof (g_Beacon));
g_Beacon.pkt.proto = RFBPROTO_BEACONTRACKER_EXT;
g_Beacon.pkt.flags = moving ? RFBFLAGS_MOVING : 0;
g_Beacon.pkt.oid = htons (tag_id);
g_Beacon.pkt.p.tracker.strength = (i & 1) + TX_STRENGTH_OFFSET;
g_Beacon.pkt.p.tracker.seq = htonl (LPC_TMR32B0->TC);
g_Beacon.pkt.p.tracker.oid_last_seen = oid_last_seen;
g_Beacon.pkt.p.tracker.time = htons ((uint16_t)g_sequence++);
g_Beacon.pkt.p.tracker.battery = 0;
g_Beacon.pkt.crc = htons (
crc16(g_Beacon.byte, sizeof (g_Beacon) - sizeof (g_Beacon.pkt.crc))
);
nRFCMD_Power (0);
nRF_tx (g_Beacon.pkt.p.tracker.strength);
nRFCMD_Power (1);
nRFAPI_PowerDown ();
LPC_SYSCON->SSPCLKDIV = 0x00;
blink (10);
}
return 0;
}
void
setup_output()
{
char hdr[1024];
hdr[sizeof(hdr)-1] = 0;
pmu_init();
pmu_start();
for (int i = 0; i < NGBOXES; ++i)
for (int j = 0; j < 2; ++j)
{
prevnreads += pmu_rdctr(i, j, 0);
prevnwrites += pmu_rdctr(i, j, 1);
}
double ibw = (gbl.ncores-1) * 2 * gbl.hz;
labels[fInst].max = ibw;
labels[fVPU].max = ibw;
double vop = (gbl.ncores-1) * 8 * gbl.hz;
labels[fVpuSP].max = 2*vop;
labels[fVpuDP].max = vop;
// order doesn't really matter but we're used to this and it's better
// for Excel
hdrLabels[0] = "Time";
hdrLabels[1] = "Threads";
hdrIndexes[0] = fTime;
hdrIndexes[1] = fThreads;
int j = 2;
for (int i = 0; i < nfields; ++i)
if (i != fTime && i != fThreads)
{
hdrLabels[j] = labels[i].name;
hdrIndexes[j] = i;
++j;
}
hdr[0] = 0;
hdr[sizeof(hdr)-1] = 0;
bool first = true;
for (int i = 0; i < nfields; ++i)
{
if (first)
first = false;
else
strncat(hdr, ",", sizeof(hdr)-1);
strncat(hdr, hdrLabels[i], sizeof(hdr)-1);
}
strncat(hdr, "\n", sizeof(hdr)-1);
if (gbl.server)
{
setup_server();
}
else if (gbl.outfile)
{
outfile = fopen(gbl.outfile, "w");
if (outfile == NULL)
err(1, "create %s", gbl.outfile);
}
gbl.hdr[0] = 0;
gbl.hdr[sizeof(gbl.hdr)-1] = 0;
if (gbl.server)
{
for (int i = 0; i < nfields; ++i)
if (i != fTime)
snprintf(gbl.hdr+strlen(gbl.hdr), sizeof(gbl.hdr)-1,
"%s=%g,%s,%g\n",
labels[i].name,
labels[i].max,
labels[i].units,
labels[i].factor);
strncat(gbl.hdr, hdr, sizeof(gbl.hdr)-1);
}
else if (outfile)
{
for (int i = 0; i < nfields; ++i)
if (i != fTime)
fprintf(outfile, "%s=%g,%s,%g\n",
labels[i].name,
labels[i].max,
labels[i].units,
labels[i].factor);
fprintf(outfile, hdr);
}
starttsc = _rdtsc();
}
