static int roverp5p_pcmcia_configure_socket(struct soc_pcmcia_socket *skt, const socket_state_t *state) { /* Silently ignore Vpp, output enable, speaker enable. */ debug_func ("Reset:%d Vcc:%d\n", (state->flags & SS_RESET) ? 1 : 0, state->Vcc); roverp5p_pcmcia_hw_rst (state->flags & SS_RESET); /* Apply socket voltage */ switch (state->Vcc) { case 0: SET_ROVERP5P_GPIO (CF_PWR_ON, 1); SET_ROVERP5P_GPIO (CF_BUS_nON, 1); /*GPIO_CLR (GPIO_NR_ROVERP5P_CF_PWR_ON); GPIO_CLR (GPIO_NR_ROVERP5P_CF_BUS_nON);*/ break; case 50: /*GPIO_SET (GPIO_NR_ROVERP5P_CF_PWR_ON); break;*/ case 33: /* Apply power to socket */ SET_ROVERP5P_GPIO (CF_PWR_ON, 0); SET_ROVERP5P_GPIO (CF_BUS_nON, 0); /*GPIO_SET (GPIO_NR_ROVERP5P_CF_PWR_ON); GPIO_SET (GPIO_NR_ROVERP5P_CF_BUS_nON);*/ break; default: printk (KERN_ERR "%s: Unsupported Vcc:%d\n", __FUNCTION__, state->Vcc); } return 0; }
static int aximx5_lcd_set_power (struct lcd_device *ld, int state) { struct mediaq11xx_base *mq_base = class_get_devdata (&ld->class_dev); int lcdfp_state = mq_base->get_power (mq_base, MEDIAQ_11XX_FP_DEVICE_ID) ? 1 : 0; int fpctl_state = mq_base->get_power (mq_base, MEDIAQ_11XX_FB_DEVICE_ID) ? 1 : 0; int new_lcdfp_state = (state < 1) ? 1 : 0; int new_fpctl_state = (state < 4) ? 1 : 0; debug_func ("state:%d\n", state); if (new_lcdfp_state != lcdfp_state) mq_base->set_power (mq_base, MEDIAQ_11XX_FP_DEVICE_ID, new_lcdfp_state); if (new_fpctl_state != fpctl_state) mq_base->set_power (mq_base, MEDIAQ_11XX_FB_DEVICE_ID, new_fpctl_state); if (new_lcdfp_state) /* MediaQ GPIO 1 seems connected to flat-panel power */ mq_base->set_GPIO (mq_base, GPIO_NR_AXIMX5_MQ1132_FP_ENABLE, MQ_GPIO_OUT1); else /* Output '0' to MQ1132 GPIO 1 */ mq_base->set_GPIO (mq_base, GPIO_NR_AXIMX5_MQ1132_FP_ENABLE, MQ_GPIO_OUT0); return 0; }
static int aximx5_lcd_set_contrast (struct lcd_device *ld, int contrast) { struct mediaq11xx_base *mq_base = class_get_devdata (&ld->class_dev); u32 x; debug_func ("contrast:%d\n", contrast); /* Well... this is kind of tricky but here's how it works: * On 24-bit TFT panels the R,G,B channels are output via * the FD0..FD23 MQ1132' outputs. There are separate enable * bits for these pins in FP07R, which we will use. * Basically we just mask out (setting them to '1') * the lowest 1..8 bits of every color component thus * effectively reducing the number of bits for them. */ if (contrast > 7) contrast = 7; contrast = 7 ^ contrast; x = (1 << contrast) - 1; mq_base->regs->FP.pin_output_data |= 0x00ffffff; mq_base->regs->FP.pin_output_select_1 = (mq_base->regs->FP.pin_output_select_1 & 0xff000000) | x | (x << 8) | (x << 16); return 0; }
static int aximx5_lcd_remove(struct platform_device *dev) { debug_func ("\n"); lcd_device_unregister (mqfb_lcd_device); return 0; }
static void roverp5p_pcmcia_hw_rst (int state) { debug_func ("\n"); SET_ROVERP5P_GPIO (CF_RESET, state); /* if (state) GPIO_SET (GPIO_NR_ROVERP5P_CF_RESET); else GPIO_CLR (GPIO_NR_ROVERP5P_CF_RESET);*/ }
static int roverp5p_fp_remove (struct device *dev) { debug_func ("\n"); backlight_device_unregister (mqfb_backlight_device); lcd_device_unregister (mqfb_lcd_device); return 0; }
static int roverp5p_backlight_get_power (struct backlight_device *bd) { struct mediaq11xx_base *mq_base = class_get_devdata (&bd->class_dev); debug_func ("\n"); return mq_base->get_GPIO (mq_base, 64) ? 0 : 4; }
void main() { if ( DEBUG ) { debug_func(); return; } Polygon_2 poly; int numOfPoints; double x,y; std::fstream myfile; myfile.open ("out.txt"); myfile >> numOfPoints; std::vector<int> rArray(numOfPoints); int r; for (int i=0; i<numOfPoints; ++i) { myfile >> x >> y >> r; poly.push_back( Point_2(x,y) ); rArray [i] = r; } myfile.close(); Shor shor; shor.load_polygon (poly); shor.load_rArray (rArray); shor.play(); shor.build_triangulation(); shor.simplify_triangulation(); std::ofstream out("outC.txt"); std::streambuf *coutbuf = std::cout.rdbuf(); //save old buf std::cout.rdbuf(out.rdbuf()); //redirect std::cout to out.txt! for ( int i = 0 , len = (int)shor.triangulated.size(); i < len ; ++i ) { std::cout << shor.triangulated[i][0][0] << " " << shor.triangulated[i][0][1] <<std::endl; std::cout << shor.triangulated[i][1][0] << " " << shor.triangulated[i][1][1] <<std::endl; std::cout << shor.triangulated[i][2][0] << " " << shor.triangulated[i][2][1] <<std::endl; } //system("pause"); }
static int aximx5_lcd_get_contrast (struct lcd_device *ld) { struct mediaq11xx_base *mq_base = class_get_devdata (&ld->class_dev); u32 c, x; debug_func ("\n"); x = (mq_base->regs->FP.pin_output_select_1 & 0x7f); for (c = 7; x; x >>= 1, c--) ; return c; }
static int roverp5p_backlight_get_brightness (struct backlight_device *bd) { u32 x, y; debug_func ("\n"); x = PWM_PWDUTY0 & 0x3ff; y = PWM_PERVAL0 & 0x3ff; // To avoid division, we'll approximate y to nearest 2^n-1. // PocketPC is using 0xfe as PERVAL0 and we're using 0x3ff. x <<= (10 - fls (y)); return x; }
static int aximx5_lcd_get_power (struct lcd_device *ld) { struct mediaq11xx_base *mq_base = class_get_devdata (&ld->class_dev); int lcdfp_state = mq_base->get_power (mq_base, MEDIAQ_11XX_FP_DEVICE_ID); int fpctl_state = mq_base->get_power (mq_base, MEDIAQ_11XX_FB_DEVICE_ID); debug_func ("\n"); if (lcdfp_state == 0) { if (fpctl_state == 0) return 4; else return 2; } return 0; }
static int roverp5p_backlight_set_power (struct backlight_device *bd, int state) { struct mediaq11xx_base *mq_base = class_get_devdata (&bd->class_dev); debug_func ("state:%d\n", state); /* Turn off backlight power */ if (state == 0) { mq_base->set_GPIO (mq_base, 64, MQ_GPIO_IN | MQ_GPIO_OUT1); if (PWM_PWDUTY0 & 0x3ff) CKEN |= CKEN0_PWM0; else CKEN &= ~CKEN0_PWM0; } else { CKEN &= ~CKEN0_PWM0; mq_base->set_GPIO (mq_base, 64, MQ_GPIO_IN | MQ_GPIO_OUT0); } return 0; }
static int roverp5p_backlight_set_brightness (struct backlight_device *bd, int brightness) { debug_func ("brightness:%d\n", brightness); if (brightness > 0x3ff) brightness = 0x3ff; /* LCD brightness on Dell Axim is driven by PWM0. * We'll set the pre-scaler to 8, and the period to 1024, this * means the backlight refresh rate will be 3686400/(8*1024) = * 450 Hz which is quite enough. */ PWM_CTRL0 = 7; /* pre-scaler */ PWM_PWDUTY0 = brightness; /* duty cycle */ PWM_PERVAL0 = 0x3ff; /* period */ if (brightness) CKEN |= CKEN0_PWM0; else CKEN &= ~CKEN0_PWM0; return 0; }
static int aximx5_lcd_suspend(struct platform_device *dev, pm_message_t state) { debug_func ("\n"); return 0; }
/* * Disable card status IRQs on suspend. */ static void roverp5p_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt) { debug_func ("\n"); roverp5p_pcmcia_hw_rst(1); soc_pcmcia_disable_irqs(skt, cd_irqs, ARRAY_SIZE(cd_irqs)); }
static int roverp5p_fp_suspend (struct device *dev, u32 state, u32 level) { debug_func ("\n"); return 0; }
static int roverp5p_fp_resume (struct device *dev, u32 level) { debug_func ("\n"); return 0; }
/* * Enable card status IRQs on (re-)initialisation. This can * be called at initialisation, power management event, or * pcmcia event. */ static void roverp5p_pcmcia_socket_init(struct soc_pcmcia_socket *skt) { debug_func ("\n"); soc_pcmcia_enable_irqs (skt, cd_irqs, ARRAY_SIZE(cd_irqs)); }
static int __init roverp5p_fp_init(void) { debug_func ("\n"); return driver_register (&roverp5p_fp_device_driver); }
static void __exit roverp5p_fp_exit(void) { debug_func ("\n"); driver_unregister (&roverp5p_fp_device_driver); }
static void __exit aximx5_lcd_exit(void) { debug_func ("\n"); platform_driver_unregister(&aximx5_lcd_driver); }
static int __init aximx5_lcd_init(void) { debug_func ("\n"); return platform_driver_register(&aximx5_lcd_driver); }
static int aximx5_lcd_resume(struct platform_device *dev) { debug_func ("\n"); return 0; }