示例#1
0
bool is_same_hour(time_t t1, time_t t2)
{
    tm tm1 = time_to_tm(t1);
    tm tm2 = time_to_tm(t2);
    if ( tm1.tm_year == tm2.tm_year
        && tm1.tm_yday == tm2.tm_yday
        && tm1.tm_hour == tm2.tm_hour)
    {
        return true;
    }
    
    return false;
}
示例#2
0
static void vivid_vbi_gen_set_time_of_day(u8 *packet)
{
	struct tm tm;
	u8 checksum, i;

	time_to_tm(get_seconds(), 0, &tm);
	packet[0] = calc_parity(0x07);
	packet[1] = calc_parity(0x01);
	packet[2] = calc_parity(0x40 | tm.tm_min);
	packet[3] = calc_parity(0x40 | tm.tm_hour);
	packet[4] = calc_parity(0x40 | tm.tm_mday);
	if (tm.tm_mday == 1 && tm.tm_mon == 2 &&
	    sys_tz.tz_minuteswest > tm.tm_min + tm.tm_hour * 60)
		packet[4] = calc_parity(0x60 | tm.tm_mday);
	packet[5] = calc_parity(0x40 | (1 + tm.tm_mon));
	packet[6] = calc_parity(0x40 | (1 + tm.tm_wday));
	packet[7] = calc_parity(0x40 | ((tm.tm_year - 90) & 0x3f));
	packet[8] = calc_parity(0x0f);
	for (checksum = i = 0; i <= 8; i++)
		checksum += packet[i] & 0x7f;
	packet[9] = calc_parity(0x100 - checksum);
	checksum = 0;
	packet[10] = calc_parity(0x07);
	packet[11] = calc_parity(0x04);
	if (sys_tz.tz_minuteswest >= 0)
		packet[12] = calc_parity(0x40 | ((sys_tz.tz_minuteswest / 60) & 0x1f));
	else
		packet[12] = calc_parity(0x40 | ((24 + sys_tz.tz_minuteswest / 60) & 0x1f));
	packet[13] = calc_parity(0);
	packet[14] = calc_parity(0x0f);
	for (checksum = 0, i = 10; i <= 14; i++)
		checksum += packet[i] & 0x7f;
	packet[15] = calc_parity(0x100 - checksum);
}
示例#3
0
文件: clock.c 项目: peschuster/os-lab
ssize_t mod_clock_read(struct file* f, char *buf, size_t count, loff_t *offp ) 
{
  ssize_t len = 0;
  
  /* only output data, if offset == 0 and read_times was reset. */
  if (*offp == 0 && read_times == 0) {
    struct timeval tv;
    struct tm t;
    
    do_gettimeofday(&tv);
    
    time_to_tm(tv.tv_sec, 0, &t);
    len += sprintf(buf + len, "%d:%d:%d:%ld\n", 
                    t.tm_hour, t.tm_min, t.tm_sec, tv.tv_usec);
  }
  
  read_times += 1;
  
  /* We're returing '0' 
    -> this stops the current read process
      -> next time a read as allowed 
        -> reset 'read_times'. */
  if (len == 0) {
    read_times = 0;
  }
   
  return len;
}
static int ce1702_isp_event_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t n)
{
	int val;
	struct timespec time;
	struct tm tm_result;
	uint8_t filename[128];

	time = __current_kernel_time();
	time_to_tm(time.tv_sec, sys_tz.tz_minuteswest * 60 * (-1), &tm_result);

	sprintf(filename, "/data/event_%02d%02d%02d%02d%02d.bin", tm_result.tm_mon + 1, tm_result.tm_mday, tm_result.tm_hour, tm_result.tm_min, tm_result.tm_sec);

	sscanf(buf,"%x", &val);
	if (val) {
		int32_t rc, num_read;
		uint8_t data[130];
		uint8_t packet_size[2] = {0, };

		rc = ce1702_i2c_read(ce1702_s_interface_ctrl->sensor_i2c_addr, 0xDB, NULL, 0, packet_size,  2);
		if (rc < 0)
		{
			LDBGE("%s: num_read reading error\n", __func__);
			return n;
		}
		num_read = packet_size[0] + (packet_size[1] << 8);
		LDBGE("%s: num_read : %d, [%x|%x]\n", __func__, num_read, packet_size[0], packet_size[1]);
		if (num_read > 0) {
			mm_segment_t old_fs;
			uint8_t *dump_data;
			int32_t dump_data_len, nloop, fd;

			dump_data_len = num_read * 128 * sizeof(uint8_t);
			dump_data = kmalloc(dump_data_len, GFP_KERNEL);
			for (nloop = 0; nloop < num_read; nloop++)
			{
				rc = ce1702_i2c_read(ce1702_s_interface_ctrl->sensor_i2c_addr, 0xDC, NULL, 0, data, 130);
				if (rc < 0) {
					LDBGE("%s: %d-th reading error\n", __func__, nloop);
					continue;
				}
				memcpy(&dump_data[nloop * 128], &data[2], sizeof(uint8_t) * 128);

			}
			old_fs = get_fs();
			set_fs(KERNEL_DS);
			fd = sys_open(filename, O_RDWR | O_CREAT , 0644);
			if (fd >= 0) {
				sys_write(fd, dump_data, dump_data_len);
				sys_close(fd);
				LDBGE("%s: isp eventlog (%s) successfully writed (%d)!! \n", __func__, filename, nloop);
			}
			set_fs(old_fs);
			kfree(dump_data);

		}
	}

	return n;
}
void print_time(char *info, u32 time)
{
	struct tm t; /* it convert to year since 1900 */
	time_to_tm((time_t)(time), 0, &t);
	KDEBUG(M4SH_INFO, "%s(%d) %02d:%02d:%02d %02d/%02d/%04d\n",\
		info, (int)time, t.tm_hour, t.tm_min, t.tm_sec,\
		t.tm_mon+1, t.tm_mday, (int)t.tm_year+1900);
}
示例#6
0
static ssize_t generate_pretty_time(char* buf, time_t sec)
{
	struct tm time;

	time_to_tm(sec, 0, &time);

	return snprintf(buf, OUTSTR_SIZE, "current time: %ld-%d-%d %d:%d:%d%c", 
		time.tm_year + 1900, time.tm_mon +1, time.tm_mday, 
		time.tm_hour, time.tm_min, time.tm_sec, '\0');
}
示例#7
0
文件: fnic_trace.c 项目: 3null/linux
void copy_and_format_trace_data(struct fc_trace_hdr *tdata,
				fnic_dbgfs_t *fnic_dbgfs_prt, int *orig_len,
				u8 rdata_flag)
{
	struct tm tm;
	int j, i = 1, len;
	char *fc_trace, *fmt;
	int ethhdr_len = sizeof(struct ethhdr) - 1;
	int fcoehdr_len = sizeof(struct fcoe_hdr);
	int fchdr_len = sizeof(struct fc_frame_header);
	int max_size = fnic_fc_trace_max_pages * PAGE_SIZE * 3;

	tdata->frame_type = tdata->frame_type & 0x7F;

	len = *orig_len;

	time_to_tm(tdata->time_stamp.tv_sec, 0, &tm);

	fmt = "%02d:%02d:%04ld %02d:%02d:%02d.%09lu ns%8x       %c%8x\t";
	len += snprintf(fnic_dbgfs_prt->buffer + len,
		max_size - len,
		fmt,
		tm.tm_mon + 1, tm.tm_mday, tm.tm_year + 1900,
		tm.tm_hour, tm.tm_min, tm.tm_sec,
		tdata->time_stamp.tv_nsec, tdata->host_no,
		tdata->frame_type, tdata->frame_len);

	fc_trace = (char *)FC_TRACE_ADDRESS(tdata);

	for (j = 0; j < min_t(u8, tdata->frame_len,
		(u8)(FC_TRC_SIZE_BYTES - FC_TRC_HEADER_SIZE)); j++) {
		if (tdata->frame_type == FNIC_FC_LE) {
			len += snprintf(fnic_dbgfs_prt->buffer + len,
				max_size - len, "%c", fc_trace[j]);
		} else {
			len += snprintf(fnic_dbgfs_prt->buffer + len,
				max_size - len, "%02x", fc_trace[j] & 0xff);
			len += snprintf(fnic_dbgfs_prt->buffer + len,
				max_size - len, " ");
			if (j == ethhdr_len ||
				j == ethhdr_len + fcoehdr_len ||
				j == ethhdr_len + fcoehdr_len + fchdr_len ||
				(i > 3 && j%fchdr_len == 0)) {
				len += snprintf(fnic_dbgfs_prt->buffer
					+ len, max_size - len,
					"\n\t\t\t\t\t\t\t\t");
				i++;
			}
		} /* end of else*/
	} /* End of for loop*/
	len += snprintf(fnic_dbgfs_prt->buffer + len,
		max_size - len, "\n");
	*orig_len = len;
}
void ts2utc(struct timespec *ts, struct utc_time *utc)
{
    struct tm tm;

    time_to_tm((ts->tv_sec - (sys_tz.tz_minuteswest * 60)), 0, &tm);
    utc->year = 1900 + tm.tm_year;
    utc->mon = 1 + tm.tm_mon;
    utc->day = tm.tm_mday;
    utc->hour = tm.tm_hour;
    utc->min = tm.tm_min;
    utc->sec = tm.tm_sec;
    utc->msec = ns2ms(ts->tv_nsec);
}
void mntn_get_cur_time_str(char *poutstr, unsigned int ulen)
{
    struct tm     tm_rtc = {0};
    unsigned long    cur_secs = 0;

    if (NULL != poutstr)
    {
	cur_secs = get_seconds();
	cur_secs -= sys_tz.tz_minuteswest * 60;
	time_to_tm(cur_secs, 0, &tm_rtc);        
	snprintf(poutstr, ulen, "%lu%.2d%.2d-%.2d%.2d%.2d", 1900 + tm_rtc.tm_year, tm_rtc.tm_mon + 1, tm_rtc.tm_mday, tm_rtc.tm_hour, tm_rtc.tm_min, tm_rtc.tm_sec);
    }
}
static void rk29_adc_battery_timer_work(struct work_struct *work)
{	
      struct tm tm;
      static int fd_log = -1;
      struct rk30_adc_battery_platform_data *pdata = gBatteryData->pdata;
	rk29_adc_battery_status_samples(gBatteryData);
	
	if (poweron_check)
	{   
        poweron_check = 0;
        rk29_adc_battery_poweron_capacity_check();
	}
	
	rk29_adc_battery_voltage_samples(gBatteryData);
	rk29_adc_battery_capacity_samples(gBatteryData);
	
	/*update battery parameter after adc and capacity has been changed*/
	if(gBatteryData->bat_change)
	{
	    gBatteryData->bat_change = 0;
	    rk29_adc_battery_put_capacity(gBatteryData->bat_capacity);
		power_supply_changed(&rk29_battery_supply);
	}

	if (rk29_battery_dbg_level)
	{
    	if (++AdcTestCnt >= 20)
    	{
    	    char buf[256] = {0};
           time_to_tm(get_seconds(), 0, &tm);

    	    AdcTestCnt = 0;
#if SAVE_BAT_LOG
    	    if (fd_log < 0) {
                        fd_log = sys_open("/data/local/bat.log", O_CREAT | O_APPEND | O_RDWR, 0);
                        printk("create /data/local/bat.log, fd_log = %d\n", fd_log);
           } else {
                    sprintf(buf, "[%02d:%02d:%02d], bat_status = %d, RealAdc = %d, RealVol = %d, gBatVol = %d, gBatCap = %d, RealCapacity = %d,\
                                    dischargecnt = %d, chargecnt = %d, dc_det = %d, charge_ok = %d\n", 
                            tm.tm_hour, tm.tm_min, tm.tm_sec, gBatteryData->bat_status, AdcTestvalue, adc_to_voltage(AdcTestvalue),
                            gBatteryData->bat_voltage, gBatteryData->bat_capacity, capacitytmp, gBatCapacityDisChargeCnt, gBatCapacityChargeCnt,
                            gpio_get_value(pdata->dc_det_pin), gpio_get_value(pdata->charge_ok_pin));
                    int ret = sys_write(fd_log, (const char __user *)buf, strlen(buf));
                    printk("undate charge info, ret = %d, len=%d\n", ret, strlen(buf));
          }
#endif                        
    	    printk("Status = %d, RealAdcVal = %d, RealVol = %d,gBatVol = %d, gBatCap = %d, RealCapacity = %d, dischargecnt = %d, chargecnt = %d\n", 
    	            gBatteryData->bat_status, AdcTestvalue, adc_to_voltage(AdcTestvalue), 
    	            gBatteryData->bat_voltage, gBatteryData->bat_capacity, capacitytmp, gBatCapacityDisChargeCnt, gBatCapacityChargeCnt);
    	}
    }
示例#11
0
文件: time.c 项目: Airead/excise
static int time_init_module(void)
{
    struct timeval tv;
    struct tm tm;

    do_gettimeofday(&tv);
    pr_info("second: %ld\n", tv.tv_sec);
    time_to_tm(tv.tv_sec, 0, &tm);

    pr_info("year: %ld, month: %d, day: %d, hour: %d, minute: %d, second: %d\n",
            tm.tm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);

    return 0;
}
示例#12
0
文件: date.c 项目: Barklad/first_app
const char *show_date(unsigned long time, int tz, enum date_mode mode)
{
	struct tm *tm;
	static char timebuf[200];

	if (mode == DATE_RAW) {
		snprintf(timebuf, sizeof(timebuf), "%lu %+05d", time, tz);
		return timebuf;
	}

	if (mode == DATE_RELATIVE) {
		struct timeval now;
		gettimeofday(&now, NULL);
		return show_date_relative(time, tz, &now,
					  timebuf, sizeof(timebuf));
	}

	if (mode == DATE_LOCAL)
		tz = local_tzoffset(time);

	tm = time_to_tm(time, tz);
	if (!tm)
		return NULL;
	if (mode == DATE_SHORT)
		sprintf(timebuf, "%04d-%02d-%02d", tm->tm_year + 1900,
				tm->tm_mon + 1, tm->tm_mday);
	else if (mode == DATE_ISO8601)
		sprintf(timebuf, "%04d-%02d-%02d %02d:%02d:%02d %+05d",
				tm->tm_year + 1900,
				tm->tm_mon + 1,
				tm->tm_mday,
				tm->tm_hour, tm->tm_min, tm->tm_sec,
				tz);
	else if (mode == DATE_RFC2822)
		sprintf(timebuf, "%.3s, %d %.3s %d %02d:%02d:%02d %+05d",
			weekday_names[tm->tm_wday], tm->tm_mday,
			month_names[tm->tm_mon], tm->tm_year + 1900,
			tm->tm_hour, tm->tm_min, tm->tm_sec, tz);
	else
		sprintf(timebuf, "%.3s %.3s %d %02d:%02d:%02d %d%c%+05d",
				weekday_names[tm->tm_wday],
				month_names[tm->tm_mon],
				tm->tm_mday,
				tm->tm_hour, tm->tm_min, tm->tm_sec,
				tm->tm_year + 1900,
				(mode == DATE_LOCAL) ? 0 : ' ',
				tz);
	return timebuf;
}
示例#13
0
/**
	Function Name : deeds_clock_module_read
	Function Type : Kernel Callback Method
	Description   : Method is invoked whenever the deeds_clock file is
			read. This callback method is triggered when a read 
			operation performed on the above mentioned file
			which is registered to the file operation object.
			/proc/deeds_clock is a read only file. Whereas
			/proc/deeds_clock_config is a read/write file.
			Based on the value stored in the config file the
			clock format is modified. The possible values stored
			are 0,1.
*/
static ssize_t deeds_clock_module_read(struct file *file, char *buf, size_t count, loff_t *ppos)
{
	/** Timeval object defined for obtaining the current time in seconds. */
	struct timeval timeval_obj;
	/** Time object defined to vary the output based on specific time formats.*/
	struct tm tm_obj;
	
	int ret=0;
	
	/** 
		Kernel call obtains the current time and stores the information
		in timeval object.
	*/
	do_gettimeofday(&timeval_obj);
	
	printk(KERN_INFO "Deeds Clock Module read.\n");
	
	/** To check EOF is reached. */
	if(!finished_clock) {
	
		/** To check which clock format is in use. */
		if(option) {			
			/** Since option=1, clock format is yy-mm-dd h:m:s*/
			time_to_tm(get_seconds(),CEST/*sys_tz.tz_minuteswest * 60*/, &tm_obj);		
			ret = sprintf(buf,"current time:%04ld-%02d-%02d %02d:%02d:%02d\n", tm_obj.tm_year + 1900, tm_obj.tm_mon + 1, tm_obj.tm_mday, tm_obj.tm_hour, tm_obj.tm_min, tm_obj.tm_sec);
			if(ret < 0) {
				/** Memory Allocation Problem */
				return -ENOMEM;
			}
		}
		else {
			/** option = 0, clock format is in seconds.*/
			ret = sprintf(buf,"current time:%ld seconds\n",timeval_obj.tv_sec);
			if(ret <0) {
				/** Memory Allocation Problem */
				return -ENOMEM;			
			}
		}
		/** Flag set to true indicating EOF */
		finished_clock = 1;
		/** Total bytes read successfully returned.*/
		return ret;
	}	
	/** Successful execution of read call back. EOF reached.*/
	return 0;
}
示例#14
0
static void print_current_time(int is_new_line)
{
	struct timeval *tv;
	struct tm *t;
	tv = kmalloc(sizeof(struct timeval), GFP_KERNEL);
	t  = kmalloc(sizeof(struct tm),GFP_KERNEL) ;
	do_gettimeofday(tv);
	time_to_tm(tv->tv_sec, 0, t);

	printk(KERN_ALERT "%ld-%d-%d %d:%d:%d",t->tm_year + 1900,
			t->tm_mon + 1, t->tm_mday,(t->tm_hour + 8),
			t->tm_min,t->tm_sec);
	if (is_new_line == 1)
		printk(KERN_ALERT "\n");
	kfree(tv);
	kfree(t);
}
示例#15
0
std::string CTimerFileInfo::format_date(std::time_t tm_value)
{
    char date_buf[256];
    struct tm tm_time = time_to_tm(tm_value);
    
    // dir/prefix_year_month_day_hour_seq.suffix
    snprintf(date_buf, 256, "%04d_%02d_%02d_%02d_%02d_%02d",
             tm_time.tm_year + 1900,
             tm_time.tm_mon + 1,
             tm_time.tm_mday,
             tm_time.tm_hour,
             tm_time.tm_min,
             tm_time.tm_sec
             );
    
    std::string str = date_buf;
    
    return str;
}
示例#16
0
char *get_timestamp(void)
{   
    static char ret[400];
    struct timeval t;
    struct tm broken;
    do_gettimeofday(&t);
    time_to_tm(t.tv_sec, 0, &broken);

    if (lines_omitted == 0)
        sprintf(ret, "Log contents for time = %2d:%2d:%2d.%ld\n", 
            broken.tm_hour, broken.tm_min, broken.tm_sec, t.tv_usec);
    else
        sprintf(ret, "Log was full. %d lines were omitted.\n"
            "Log has been flushed to terminal. Beginning new log " 
            "for time = %2d:%2d:%2d.%ld\n", 
            lines_omitted, broken.tm_hour, broken.tm_min, 
            broken.tm_sec, t.tv_usec);

    return ret;
}
static ssize_t sta_connected_time_read(struct file *file, char __user *userbuf,
					size_t count, loff_t *ppos)
{
	struct sta_info *sta = file->private_data;
	struct timespec uptime;
	struct tm result;
	long connected_time_secs;
	char buf[100];
	int res;
	do_posix_clock_monotonic_gettime(&uptime);
	connected_time_secs = uptime.tv_sec - sta->last_connected;
	time_to_tm(connected_time_secs, 0, &result);
	result.tm_year -= 70;
	result.tm_mday -= 1;
	res = scnprintf(buf, sizeof(buf),
		"years  - %ld\nmonths - %d\ndays   - %d\nclock  - %d:%d:%d\n\n",
			result.tm_year, result.tm_mon, result.tm_mday,
			result.tm_hour, result.tm_min, result.tm_sec);
	return simple_read_from_buffer(userbuf, count, ppos, buf, res);
}
示例#18
0
/*
 * Prepare current date in the format required for HTTP "Date:"
 * header field. See RFC 2616 section 3.3.
 */
static void
tfw_http_prep_date(char *buf)
{
	struct tm tm;
	struct timespec ts;
	char *ptr = buf;

	static char *wday[] __read_mostly =
		{ "Sun, ", "Mon, ", "Tue, ",
		  "Wed, ", "Thu, ", "Fri, ", "Sat, " };
	static char *month[] __read_mostly =
		{ " Jan ", " Feb ", " Mar ", " Apr ", " May ", " Jun ",
		  " Jul ", " Aug ", " Sep ", " Oct ", " Nov ", " Dec " };

#define PRINT_2DIGIT(p, n)			\
	*p++ = (n <= 9) ? '0' : '0' + n / 10;	\
	*p++ = '0' + n % 10;

	getnstimeofday(&ts);
	time_to_tm(ts.tv_sec, 0, &tm);

	memcpy(ptr, wday[tm.tm_wday], 5);
	ptr += 5;
	PRINT_2DIGIT(ptr, tm.tm_mday);
	memcpy(ptr, month[tm.tm_mon], 5);
	ptr += 5;
	PRINT_2DIGIT(ptr, (tm.tm_year + 1900) / 100);
	PRINT_2DIGIT(ptr, (tm.tm_year + 1900) % 100);
	*ptr++ = ' ';
	PRINT_2DIGIT(ptr, tm.tm_hour);
	*ptr++ = ':';
	PRINT_2DIGIT(ptr, tm.tm_min);
	*ptr++ = ':';
	PRINT_2DIGIT(ptr, tm.tm_sec);
	memcpy(ptr, " GMT", 4);
#undef PRINT_2DIGIT
}
STATIC int balong_ade_overlay_commit(struct ade_compose_data_type    *ade_pri_data, void __user *p)
{
    struct overlay_compose_info comp_info;
    struct balong_fb_data_type *balongfd = NULL;
    int ret = 0;
    u32 struct_len = sizeof(struct ovly_hnd_info) * ADE_OVERLAY_MAX_LAYERS;
#if ADE_SYNC_SUPPORT
    int fenceId = 0;
    unsigned long flags;
#endif

    BUG_ON(ade_pri_data == NULL);

    balongfb_logi_display_debugfs("balong_ade_overlay_commit enter succ ! \n");

    if (copy_from_user(&comp_info, p, sizeof(comp_info))) {
        balongfb_loge("copy from user failed!\n");
        return -EFAULT;
    }

    balongfd = (struct balong_fb_data_type *)platform_get_drvdata(ade_pri_data->parent);
    BUG_ON(balongfd == NULL);
    if ((!balongfd->frame_updated) && lcd_pwr_status.panel_power_on)
    {

        balongfd->frame_updated = 1;
        lcd_pwr_status.lcd_dcm_pwr_status |= BIT(2);
        do_gettimeofday(&lcd_pwr_status.tvl_set_frame);
        time_to_tm(lcd_pwr_status.tvl_set_frame.tv_sec, 0, &lcd_pwr_status.tm_set_frame);
    }
    down(&balong_fb_blank_sem);
    if (!balongfd->ade_core_power_on) {
        up(&balong_fb_blank_sem);
        balongfb_logi("ade_core_power_on is false !\n");
        return -EPERM;
    }


    if (ADE_TRUE == comp_info.is_finished) {
        spin_lock_irqsave(&balongfd->refresh_lock, flags);
        balongfd->refresh++;
        spin_unlock_irqrestore(&balongfd->refresh_lock, flags);
        balongfd->timeline_max++;
        //release the reserved buffer of fb
        if((true == ade_pri_data->fb_reserved_flag) && (ade_pri_data->frame_count)) {
            balong_ion_free_mem_to_buddy();
            ade_pri_data->fb_reserved_flag = false;
        }

        if (PANEL_MIPI_VIDEO == ade_pri_data->lcd_type) {
            spin_lock_irqsave(&(balongfd->vsync_info.spin_lock), flags);
            set_LDI_INT_MASK_bit(balongfd->ade_base, LDI_ISR_FRAME_END_INT);
            balongfd->vsync_info.vsync_ctrl_expire_count = 0;
            spin_unlock_irqrestore(&(balongfd->vsync_info.spin_lock), flags);

            if (balongfd->vsync_info.vsync_ctrl_disabled_set) {
                if (balongfd->ldi_irq) {
                    enable_irq(balongfd->ldi_irq);
                    balongfd->vsync_info.vsync_ctrl_disabled_set = false;
                }
            }
        }

#ifndef PC_UT_TEST_ON
#ifdef CONFIG_TRACING
        trace_dot(SF, "7", 0);
#endif
#endif

#if ADE_DEBUG_LOG_ENABLE
        g_debug_frame_number = comp_info.frame_number;
#endif
    }

    ret = ade_overlay_commit(ade_pri_data, &comp_info);

    if ((ADE_TRUE == comp_info.is_finished)) {
        if (ret == 0) {
            set_LDI_INT_MASK_bit(ade_pri_data->ade_base, LDI_ISR_UNDER_FLOW_INT);
#if PARTIAL_UPDATE
            if ((PANEL_MIPI_CMD == ade_pri_data->lcd_type) && (true == balongfd->dirty_update)) {
                balongfb_set_display_region(balongfd);
                balongfd->dirty_update = false;
            }
#endif
            if (PANEL_MIPI_VIDEO == ade_pri_data->lcd_type) {
                if ((ade_pri_data->overlay_ctl.comp_info.compose_mode != OVERLAY_COMP_TYPE_ONLINE)
                    || (balongfd->vpu_power_on)){
                     /* ade_core_rate is default value (360M) */
                     balongfd->ade_set_core_rate = balongfd->ade_core_rate;
                }

                if (balongfd->last_ade_core_rate != balongfd->ade_set_core_rate) {
                    if (clk_set_rate(balongfd->ade_clk, balongfd->ade_set_core_rate) != 0) {
                          balongfb_loge("clk_set_rate ade_core_rate error \n");
                    }
                }

                balongfd->last_ade_core_rate = balongfd->ade_set_core_rate;

            }

            set_LDI_CTRL_ldi_en(ade_pri_data->ade_base, ADE_ENABLE);
            balongfd->ade_ldi_on = true;
            if (PANEL_MIPI_CMD == ade_pri_data->lcd_type) {
                set_LDI_INT_MASK_bit(balongfd->ade_base, LDI_ISR_DSI_TE0_PIN_INT);

                /* enable fake vsync timer */
                if (balongfd->frc_state != BALONG_FB_FRC_IDLE_PLAYING) {
                    balongfd->use_cmd_vsync = (balongfb_frc_get_fps(balongfd) < BALONG_FB_FRC_NORMAL_FPS ? true : false);
                }

                /* report vsync with timer */
                if (balongfd->use_cmd_vsync) {
                    hrtimer_restart(&balongfd->cmd_vsync_hrtimer);
                } else {
                    hrtimer_cancel(&balongfd->cmd_vsync_hrtimer);
                }
            }

#ifndef PC_UT_TEST_ON
#ifdef CONFIG_TRACING
            trace_dot(SF, "8", 0);
#endif
#endif

#if ADE_SYNC_SUPPORT
            /* In online/hybrid mode, ADE must create release fenceFd.
             * In offline mode, don't create release fenceFd
             * because ADE will read HAL's offline buffer instead of layer's buffer.
             */
            /*
               spin_lock_irqsave(&balongfd->refresh_lock, flags);
               balongfd->refresh++;
               spin_unlock_irqrestore(&balongfd->refresh_lock, flags);
               balongfd->timeline_max++;
             */
            if ((OVERLAY_COMP_TYPE_ONLINE == comp_info.compose_mode)
                    || (OVERLAY_COMP_TYPE_HYBRID == comp_info.compose_mode)) {

                fenceId = balong_ade_overlay_fence_create(balongfd->timeline, "ADE", balongfd->timeline_max);
                if (fenceId < 0) {
                    balongfb_loge("ADE failed to create fence!\n");
                }
                comp_info.release_fence = fenceId;
                if (copy_to_user((struct overlay_compose_info __user*)p, &comp_info, sizeof(struct overlay_compose_info))
                        && (fenceId >= 0)) {
                    fenceId = -EFAULT;
                    balongfb_loge("ADE failed to copy fence to user!\n");
                    put_unused_fd(comp_info.release_fence);

                    up(&balong_fb_blank_sem);
                    return fenceId;
                }
            }
#endif /* ADE_SYNC_SUPPORT */
            ade_overlay_handle_unlock(balongfd);
            memcpy(balongfd->locked_hnd, balongfd->locking_hnd, struct_len);
            memset(balongfd->locking_hnd, 0, struct_len);
        } else {
            ade_overlay_handle_unlock(balongfd);
            memcpy(balongfd->locked_hnd, balongfd->locking_hnd, struct_len);
            memset(balongfd->locking_hnd, 0, struct_len);
            up(&balong_fb_blank_sem);
            return ret;
        }
    }

    up(&balong_fb_blank_sem);

    balongfb_logi_display_debugfs("balong_ade_overlay_commit exit succ ! \n");
    return 0;
}
/*
 * Attempt to parse a data blob for a key as an X509 certificate.
 */
static int x509_key_preparse(struct key_preparsed_payload *prep)
{
	struct x509_certificate *cert;
	struct tm now;
	size_t srlen, sulen;
	char *desc = NULL;
	int ret;

	cert = x509_cert_parse(prep->data, prep->datalen);
	if (IS_ERR(cert))
		return PTR_ERR(cert);

	pr_devel("Cert Issuer: %s\n", cert->issuer);
	pr_devel("Cert Subject: %s\n", cert->subject);
	pr_devel("Cert Key Algo: %s\n", pkey_algo[cert->pkey_algo]);
	pr_devel("Cert Valid From: %04ld-%02d-%02d %02d:%02d:%02d\n",
		 cert->valid_from.tm_year + 1900, cert->valid_from.tm_mon + 1,
		 cert->valid_from.tm_mday, cert->valid_from.tm_hour,
		 cert->valid_from.tm_min,  cert->valid_from.tm_sec);
	pr_devel("Cert Valid To: %04ld-%02d-%02d %02d:%02d:%02d\n",
		 cert->valid_to.tm_year + 1900, cert->valid_to.tm_mon + 1,
		 cert->valid_to.tm_mday, cert->valid_to.tm_hour,
		 cert->valid_to.tm_min,  cert->valid_to.tm_sec);
	pr_devel("Cert Signature: %s + %s\n",
		 pkey_algo[cert->sig_pkey_algo],
		 pkey_hash_algo[cert->sig_hash_algo]);

	if (!cert->fingerprint || !cert->authority) {
		pr_warn("Cert for '%s' must have SubjKeyId and AuthKeyId extensions\n",
			cert->subject);
		ret = -EKEYREJECTED;
		goto error_free_cert;
	}

	time_to_tm(CURRENT_TIME.tv_sec, 0, &now);
	pr_devel("Now: %04ld-%02d-%02d %02d:%02d:%02d\n",
		 now.tm_year + 1900, now.tm_mon + 1, now.tm_mday,
		 now.tm_hour, now.tm_min,  now.tm_sec);
	if (now.tm_year < cert->valid_from.tm_year ||
	    (now.tm_year == cert->valid_from.tm_year &&
	     (now.tm_mon < cert->valid_from.tm_mon ||
	      (now.tm_mon == cert->valid_from.tm_mon &&
	       (now.tm_mday < cert->valid_from.tm_mday ||
		(now.tm_mday == cert->valid_from.tm_mday &&
		 (now.tm_hour < cert->valid_from.tm_hour ||
		  (now.tm_hour == cert->valid_from.tm_hour &&
		   (now.tm_min < cert->valid_from.tm_min ||
		    (now.tm_min == cert->valid_from.tm_min &&
		     (now.tm_sec < cert->valid_from.tm_sec
		      ))))))))))) {
		pr_warn("Cert %s is not yet valid\n", cert->fingerprint);
		/* ret = -EKEYREJECTED;
		 * goto error_free_cert; */
	}
	if (now.tm_year > cert->valid_to.tm_year ||
	    (now.tm_year == cert->valid_to.tm_year &&
	     (now.tm_mon > cert->valid_to.tm_mon ||
	      (now.tm_mon == cert->valid_to.tm_mon &&
	       (now.tm_mday > cert->valid_to.tm_mday ||
		(now.tm_mday == cert->valid_to.tm_mday &&
		 (now.tm_hour > cert->valid_to.tm_hour ||
		  (now.tm_hour == cert->valid_to.tm_hour &&
		   (now.tm_min > cert->valid_to.tm_min ||
		    (now.tm_min == cert->valid_to.tm_min &&
		     (now.tm_sec > cert->valid_to.tm_sec
		      ))))))))))) {
		pr_warn("Cert %s has expired\n", cert->fingerprint);
		ret = -EKEYEXPIRED;
		goto error_free_cert;
	}

	cert->pub->algo = x509_public_key_algorithms[cert->pkey_algo];
	cert->pub->id_type = PKEY_ID_X509;

	/* Check the signature on the key */
	if (strcmp(cert->fingerprint, cert->authority) == 0) {
		ret = x509_check_signature(cert->pub, cert);
		if (ret < 0)
			goto error_free_cert;
	}

	/* Propose a description */
	sulen = strlen(cert->subject);
	srlen = strlen(cert->fingerprint);
	ret = -ENOMEM;
	desc = kmalloc(sulen + 2 + srlen + 1, GFP_KERNEL);
	if (!desc)
		goto error_free_cert;
	memcpy(desc, cert->subject, sulen);
	desc[sulen] = ':';
	desc[sulen + 1] = ' ';
	memcpy(desc + sulen + 2, cert->fingerprint, srlen);
	desc[sulen + 2 + srlen] = 0;

	/* We're pinning the module by being linked against it */
	__module_get(public_key_subtype.owner);
	prep->type_data[0] = &public_key_subtype;
	prep->type_data[1] = cert->fingerprint;
	prep->payload = cert->pub;
	prep->description = desc;
	prep->quotalen = 100;

	/* We've finished with the certificate */
	cert->pub = NULL;
	cert->fingerprint = NULL;
	desc = NULL;
	ret = 0;

error_free_cert:
	x509_free_certificate(cert);
	return ret;
}
示例#21
0
/*
 * This RDS generator creates 57 RDS groups (one group == four RDS blocks).
 * Groups 0-3, 22-25 and 44-47 (spaced 22 groups apart) are filled with a
 * standard 0B group containing the PI code and PS name.
 *
 * Groups 4-19 and 26-41 use group 2A for the radio text.
 *
 * Group 56 contains the time (group 4A).
 *
 * All remaining groups use a filler group 15B block that just repeats
 * the PI and PTY codes.
 */
void vivid_rds_generate(struct vivid_rds_gen *rds)
{
	struct v4l2_rds_data *data = rds->data;
	unsigned grp;
	struct tm tm;
	unsigned date;
	unsigned time;
	int l;

	for (grp = 0; grp < VIVID_RDS_GEN_GROUPS; grp++, data += VIVID_RDS_GEN_BLKS_PER_GRP) {
		data[0].lsb = rds->picode & 0xff;
		data[0].msb = rds->picode >> 8;
		data[0].block = V4L2_RDS_BLOCK_A | (V4L2_RDS_BLOCK_A << 3);
		data[1].lsb = rds->pty << 5;
		data[1].msb = (rds->pty >> 3) | (rds->tp << 2);
		data[1].block = V4L2_RDS_BLOCK_B | (V4L2_RDS_BLOCK_B << 3);
		data[3].block = V4L2_RDS_BLOCK_D | (V4L2_RDS_BLOCK_D << 3);

		switch (grp) {
		case 0 ... 3:
		case 22 ... 25:
		case 44 ... 47: /* Group 0B */
			data[1].lsb |= (rds->ta << 4) | (rds->ms << 3);
			data[1].lsb |= vivid_get_di(rds, grp % 22);
			data[1].msb |= 1 << 3;
			data[2].lsb = rds->picode & 0xff;
			data[2].msb = rds->picode >> 8;
			data[2].block = V4L2_RDS_BLOCK_C_ALT | (V4L2_RDS_BLOCK_C_ALT << 3);
			data[3].lsb = rds->psname[2 * (grp % 22) + 1];
			data[3].msb = rds->psname[2 * (grp % 22)];
			break;
		case 4 ... 19:
		case 26 ... 41: /* Group 2A */
			data[1].lsb |= (grp - 4) % 22;
			data[1].msb |= 4 << 3;
			data[2].msb = rds->radiotext[4 * ((grp - 4) % 22)];
			data[2].lsb = rds->radiotext[4 * ((grp - 4) % 22) + 1];
			data[2].block = V4L2_RDS_BLOCK_C | (V4L2_RDS_BLOCK_C << 3);
			data[3].msb = rds->radiotext[4 * ((grp - 4) % 22) + 2];
			data[3].lsb = rds->radiotext[4 * ((grp - 4) % 22) + 3];
			break;
		case 56:
			/*
			 * Group 4A
			 *
			 * Uses the algorithm from Annex G of the RDS standard
			 * EN 50067:1998 to convert a UTC date to an RDS Modified
			 * Julian Day.
			 */
			time_to_tm(get_seconds(), 0, &tm);
			l = tm.tm_mon <= 1;
			date = 14956 + tm.tm_mday + ((tm.tm_year - l) * 1461) / 4 +
				((tm.tm_mon + 2 + l * 12) * 306001) / 10000;
			time = (tm.tm_hour << 12) |
			       (tm.tm_min << 6) |
			       (sys_tz.tz_minuteswest >= 0 ? 0x20 : 0) |
			       (abs(sys_tz.tz_minuteswest) / 30);
			data[1].lsb &= ~3;
			data[1].lsb |= date >> 15;
			data[1].msb |= 8 << 3;
			data[2].lsb = (date << 1) & 0xfe;
			data[2].lsb |= (time >> 16) & 1;
			data[2].msb = (date >> 7) & 0xff;
			data[2].block = V4L2_RDS_BLOCK_C | (V4L2_RDS_BLOCK_C << 3);
			data[3].lsb = time & 0xff;
			data[3].msb = (time >> 8) & 0xff;
			break;
		default: /* Group 15B */
			data[1].lsb |= (rds->ta << 4) | (rds->ms << 3);
			data[1].lsb |= vivid_get_di(rds, grp % 22);
			data[1].msb |= 0x1f << 3;
			data[2].lsb = rds->picode & 0xff;
			data[2].msb = rds->picode >> 8;
			data[2].block = V4L2_RDS_BLOCK_C_ALT | (V4L2_RDS_BLOCK_C_ALT << 3);
			data[3].lsb = rds->pty << 5;
			data[3].lsb |= (rds->ta << 4) | (rds->ms << 3);
			data[3].lsb |= vivid_get_di(rds, grp % 22);
			data[3].msb |= rds->pty >> 3;
			data[3].msb |= 0x1f << 3;
			break;
		}
	}
}
void _write_time_log(char *filename, char *data, int data_include)
{
	struct file *file;
	loff_t pos = 0;
	char *fname = NULL;
	char time_string[64] = {0};
	struct timespec my_time;
	struct tm my_date;

	mm_segment_t old_fs = get_fs();

	my_time = __current_kernel_time();
	time_to_tm(my_time.tv_sec, sys_tz.tz_minuteswest * 60 * (-1), &my_date);
	snprintf(time_string,
			sizeof(time_string),
			"%02d-%02d %02d:%02d:%02d.%03lu\n\n",
			my_date.tm_mon + 1,
			my_date.tm_mday,
			my_date.tm_hour,
			my_date.tm_min,
			my_date.tm_sec,
			(unsigned long) my_time.tv_nsec / 1000000);

	set_fs(KERNEL_DS);

	if (filename == NULL) {
		switch (mfts_mode) {
		case 0:
			fname = "/mnt/sdcard/touch_self_test.txt";
			break;
		case 1:
			fname = "/mnt/sdcard/touch_self_test_mfts_folder.txt";
			break;
		case 2:
			fname = "/mnt/sdcard/touch_self_test_mfts_flat.txt";
			break;
		case 3:
			fname = "/mnt/sdcard/touch_self_test_mfts_curved.txt";
			break;
		default:
			TOUCH_I("%s : not support mfts_mode\n", __func__);
			break;
		}
	} else {
		fname = filename;
	}

	if (fname) {
		file = filp_open(fname,
			O_WRONLY|O_CREAT|O_APPEND, 0666);
	} else {
		TOUCH_E("%s : fname is NULL, can not open FILE\n", __func__);
		return;
	}

	if (IS_ERR(file)) {
		TOUCH_I("%s :  Open file error [%s], err = %ld\n",
				__func__, fname, PTR_ERR(file));

		set_fs(old_fs);
		return;
	}

	vfs_write(file, time_string, strlen(time_string), &pos);
	filp_close(file, 0);

	set_fs(old_fs);
}
示例#23
0
文件: date.c 项目: Brian1176/git
const char *show_date(unsigned long time, int tz, enum date_mode mode)
{
	struct tm *tm;
	static struct strbuf timebuf = STRBUF_INIT;

	if (mode == DATE_RAW) {
		strbuf_reset(&timebuf);
		strbuf_addf(&timebuf, "%lu %+05d", time, tz);
		return timebuf.buf;
	}

	if (mode == DATE_RELATIVE) {
		struct timeval now;

		strbuf_reset(&timebuf);
		gettimeofday(&now, NULL);
		show_date_relative(time, tz, &now, &timebuf);
		return timebuf.buf;
	}

	if (mode == DATE_LOCAL)
		tz = local_tzoffset(time);

	tm = time_to_tm(time, tz);
	if (!tm) {
		tm = time_to_tm(0, 0);
		tz = 0;
	}

	strbuf_reset(&timebuf);
	if (mode == DATE_SHORT)
		strbuf_addf(&timebuf, "%04d-%02d-%02d", tm->tm_year + 1900,
				tm->tm_mon + 1, tm->tm_mday);
	else if (mode == DATE_ISO8601)
		strbuf_addf(&timebuf, "%04d-%02d-%02d %02d:%02d:%02d %+05d",
				tm->tm_year + 1900,
				tm->tm_mon + 1,
				tm->tm_mday,
				tm->tm_hour, tm->tm_min, tm->tm_sec,
				tz);
	else if (mode == DATE_ISO8601_STRICT) {
		char sign = (tz >= 0) ? '+' : '-';
		tz = abs(tz);
		strbuf_addf(&timebuf, "%04d-%02d-%02dT%02d:%02d:%02d%c%02d:%02d",
				tm->tm_year + 1900,
				tm->tm_mon + 1,
				tm->tm_mday,
				tm->tm_hour, tm->tm_min, tm->tm_sec,
				sign, tz / 100, tz % 100);
	} else if (mode == DATE_RFC2822)
		strbuf_addf(&timebuf, "%.3s, %d %.3s %d %02d:%02d:%02d %+05d",
			weekday_names[tm->tm_wday], tm->tm_mday,
			month_names[tm->tm_mon], tm->tm_year + 1900,
			tm->tm_hour, tm->tm_min, tm->tm_sec, tz);
	else
		strbuf_addf(&timebuf, "%.3s %.3s %d %02d:%02d:%02d %d%c%+05d",
				weekday_names[tm->tm_wday],
				month_names[tm->tm_mon],
				tm->tm_mday,
				tm->tm_hour, tm->tm_min, tm->tm_sec,
				tm->tm_year + 1900,
				(mode == DATE_LOCAL) ? 0 : ' ',
				tz);
	return timebuf.buf;
}
示例#24
0
static void modem_ssr_report_work_fn(struct work_struct *work)
{

    int fd, ret = 0;
    char report_index, index_to_write;
    char path_prefix[]="/data/logger/modem_ssr_report";
    char index_file_path[]="/data/logger/modem_ssr_index";
    char report_file_path[128];
#ifdef FEATURE_LGE_MODEM_CHIPVER_INFO
    char chip_info_path[]="/data/logger/modem_chip_info";
	struct timespec time;
	struct tm tmresult;
	char time_stamp[128];
#endif
    char watchdog_bite[]="Watchdog bite received from modem software!";
    char unexpected_reset1[]="unexpected reset external modem";
    char unexpected_reset2[]="MDM2AP_STATUS did not go high";

    mm_segment_t oldfs;

    oldfs = get_fs();
    set_fs(get_ds());

    fd = sys_open(index_file_path, O_RDONLY, 0664);
    if (fd < 0) {
        printk("%s : can't open the index file\n", __func__);
        report_index = '0';
    } else {
        ret = sys_read(fd, &report_index, 1);
        if (ret < 0) {
            printk("%s : can't read the index file\n", __func__);
            report_index = '0';
        }
        sys_close(fd);
    }

    if (report_index == '9') {
        index_to_write = '0';
    } else if (report_index >= '0' && report_index <= '8') {
        index_to_write = report_index + 1;
    } else {
        index_to_write = '1';
        report_index = '0';
    }

    fd = sys_open(index_file_path, O_WRONLY | O_CREAT | O_TRUNC, 0664);
    if (fd < 0) {
        printk("%s : can't open the index file\n", __func__);
        return;
    }

    ret = sys_write(fd, &index_to_write, 1);
    if (ret < 0) {
        printk("%s : can't write the index file\n", __func__);
        return;
    }

    ret = sys_close(fd);
    if (ret < 0) {
        printk("%s : can't close the index file\n", __func__);
        return;
    }

    sprintf(report_file_path, "%s%c", path_prefix, report_index);

    fd = sys_open(report_file_path, O_WRONLY | O_CREAT | O_TRUNC, 0664);

    if (fd < 0) {
        printk("%s : can't open the report file\n", __func__);
        return;
    }

#ifdef FEATURE_LGE_MODEM_CHIPVER_INFO
	time = __current_kernel_time();
	time_to_tm(time.tv_sec, sys_tz.tz_minuteswest * 60 * (-1),
			&tmresult);

    sprintf(time_stamp, "%02d-%02d %02d:%02d:%02d.%03lu\n",
		tmresult.tm_mon+1,tmresult.tm_mday,tmresult.tm_hour,
		tmresult.tm_min,tmresult.tm_sec,(unsigned long) time.tv_nsec/1000000);

	ret = sys_write(fd, time_stamp, strlen(time_stamp));

    if (ret < 0) {
        printk("%s : can't write the report file\n", __func__);
        return;
    }
#endif

    switch (modem_debug.modem_ssr_event) {
        case MODEM_SSR_ERR_FATAL:
            ret = sys_write(fd, modem_debug.save_ssr_reason, strlen(modem_debug.save_ssr_reason));
            break;
        case MODEM_SSR_WATCHDOG_BITE:
            ret = sys_write(fd, watchdog_bite, sizeof(watchdog_bite) - 1);
            break;
        case MODEM_SSR_UNEXPECTED_RESET1:
            ret = sys_write(fd, unexpected_reset1, sizeof(unexpected_reset1) - 1);
            break;
        case MODEM_SSR_UNEXPECTED_RESET2:
            ret = sys_write(fd, unexpected_reset2, sizeof(unexpected_reset2) - 1);
            break;
        default:
            printk("%s : modem_ssr_event error %d\n", __func__, modem_debug.modem_ssr_event);
            break;
    }

    if (ret < 0) {
        printk("%s : can't write the report file\n", __func__);
        return;
    }

    ret = sys_close(fd);

    if (ret < 0) {
        printk("%s : can't close the report file\n", __func__);
        return;
    }

#ifdef FEATURE_LGE_MODEM_CHIPVER_INFO
	fd = sys_open(chip_info_path, O_WRONLY | O_CREAT | O_TRUNC, 0664);
	if (fd < 0) {
		pr_err("can't open the report file\n");
		return;
	}

	ret = sys_write(fd, modem_debug.save_msm_chip_info, strlen(modem_debug.save_msm_chip_info));
	if (ret < 0) {
		pr_err("can't write the report file\n");
		return;
    }

    ret = sys_close(fd);
    if (ret < 0) {
        printk("%s : can't close the report file\n", __func__);
        return;
    }
#endif

    sys_sync();
    set_fs(oldfs);
}
int mipi_dsi_on(struct platform_device *pdev)
{
	int ret = 0;
	struct balong_fb_data_type *balongfd = NULL;
	unsigned long timeout = jiffies;
	if (NULL == pdev) {
		balongfb_loge("NULL Pointer\n");
		return -EINVAL;
	}

	balongfd = (struct balong_fb_data_type *)platform_get_drvdata(pdev);
	if (NULL == balongfd) {
		balongfb_loge("NULL Pointer\n");
		return -EINVAL;
	}

	/* set LCD init step before LCD on*/
	balongfd->panel_info.lcd_init_step = LCD_INIT_POWER_ON;
	ret = panel_next_on(pdev);

	/* mipi dphy clock enable */
	ret = clk_prepare_enable(balongfd->dsi_cfg_clk);
	if (ret != 0) {
		balongfb_loge("failed to enable dsi_cfg_clk, error=%d!\n", ret);
		return ret;
	}

	/* dsi pixel on */
	set_reg(balongfd->ade_base + LDI_HDMI_DSI_GT_REG, 0x0, 1, 0);
	/* mipi init */
	mipi_init(balongfd);

	/* modified for b052 bbit begin */
	/* switch to command mode */
	set_MIPIDSI_MODE_CFG(MIPIDSI_COMMAND_MODE);
	set_MIPIDSI_CMD_MODE_CFG_all_en_flag(1);

	/* 禁止向Clock Lane发起HS时钟传输请求 */
	set_MIPIDSI_LPCLK_CTRL_phy_txrequestclkhs(0);
	/* add for timeout print log */
	balongfb_loge("%s: dsi_on_time = %u,curfreq = %d\n",
			__func__,jiffies_to_msecs(jiffies-timeout),cpufreq_get_fb(0));
	timeout = jiffies;
	ret = panel_next_on(pdev);
	/* modified for b052 bbit begin */
	/* add for timeout print log */
	balongfb_loge("%s: panel_on_time = %u,curfreq = %d\n",
			__func__,jiffies_to_msecs(jiffies-timeout),cpufreq_get_fb(0));
	/* reset Core */
	set_MIPIDSI_PWR_UP_shutdownz(0);

	if (balongfd->panel_info.type == PANEL_MIPI_VIDEO) {
		/* switch to video mode */
	set_MIPIDSI_MODE_CFG(MIPIDSI_VIDEO_MODE);

#if ADE_DEBUG_LOG_ENABLE
	/* set to video lcd mode */
	g_panel_lcd_mode = 0;
#endif
	}

	if (balongfd->panel_info.type == PANEL_MIPI_CMD) {
		/* switch to cmd mode */
		set_MIPIDSI_CMD_MODE_CFG_all_en_flag(0);

#if ADE_DEBUG_LOG_ENABLE
		/* set to command lcd mode */
		g_panel_lcd_mode = 1;
#endif
	}

	/* enable generate High Speed clock */
	set_MIPIDSI_LPCLK_CTRL_phy_txrequestclkhs(1);
	/* Waking up Core */
	set_MIPIDSI_PWR_UP_shutdownz(1);
	/*set max packet size, 0x1 << 8 |0x37*/
	set_MIPIDSI_GEN_HDR(NULL, 0x137);
	lcd_pwr_status.lcd_dcm_pwr_status |= BIT(1);
	do_gettimeofday(&lcd_pwr_status.tvl_lcd_on);
	time_to_tm(lcd_pwr_status.tvl_lcd_on.tv_sec, 0, &lcd_pwr_status.tm_lcd_on);
	return ret;
}
示例#26
0
/*
 * Program the ccdc sdram address.
 * In the programed sdram address the new frame from the sensor be filled.
 */
int isp_prg_sdram_addr(cam_data *cam)
{
	int i;
	unsigned int load_address_base_index = 0;
	static struct timeval timestamp;
	unsigned int dummy_count = 0;
	unsigned int valid_buf = 0;
	struct tm timecode;

#ifndef CONFIG_CTRL_FRAME_RATE_FRM_SENSOR
	static unsigned int frame_skip_count;
	static unsigned int capture_frame_rate;
	static unsigned int current_fps	= SENS_MAX_FPS;
	static struct timeval timestamp_rec;
#endif

	if (!cam)
		return -1; 

	/* Take the current time stamp */
	do_gettimeofday(&timestamp);

#ifndef CONFIG_CTRL_FRAME_RATE_FRM_SENSOR
	if (!timestamp_rec.tv_sec && !timestamp_rec.tv_usec) 
		do_gettimeofday(&timestamp_rec);


	if (timestamp.tv_sec > timestamp_rec.tv_sec) {
		current_fps = capture_frame_rate;
		capture_frame_rate = DISABLE;
		timestamp_rec = timestamp;
	}

	capture_frame_rate++;
#endif

	if (cam->task.bit.still	== ENABLE) {
		cam->isp->isp_ccdc.reg.CCDC_SDR_ADDR = cam->still.phy_addr;
	}
	else if (cam->task.bit.capture == ENABLE) {
		for (valid_buf = 0, i = 0; i < cam->capture.available_buf; i++) {
			if ((cam->capture.frame[i].buffer.flags & (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_MAPPED)) == (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_MAPPED)) {
				if ((cam->capture.frame[i].buffer.timestamp.tv_sec < timestamp.tv_sec) || ((cam->capture.frame[i].buffer.timestamp.tv_sec == timestamp.tv_sec) && (cam->capture.frame[i].buffer.timestamp.tv_usec <= timestamp.tv_usec))) {
					memcpy(&timestamp, &cam->capture.frame[i].buffer.timestamp, sizeof(struct timeval));
					load_address_base_index	= i;
				}

				if ((cam->capture.frame[i].buffer.flags & V4L2_BUF_FLAG_DONE) == V4L2_BUF_FLAG_DONE) {
					valid_buf++;
					wake_up_interruptible(&cam->capture.capture_frame_complete);
				}
			}
			else {
				dummy_count++;
			}
		}

#ifndef CONFIG_CTRL_FRAME_RATE_FRM_SENSOR
		frame_skip_count += ((1000000 * cam->capture.s_parm.parm.capture.timeperframe.denominator) / current_fps);
		
		if (frame_skip_count > 1000000)
			frame_skip_count -=1000000;
		else
			dummy_count	= cam->capture.available_buf;
		
#endif

		if (dummy_count == cam->capture.available_buf) {
			cam->isp->isp_ccdc.reg.CCDC_SDR_ADDR = cam->capture.frame[cam->capture.available_buf].buffer.m.offset;
			cam->capture.using_buf = cam->capture.available_buf;
		}
		else {
			cam->capture.buffer_sequence++;

			/* Fill the New time stamp */
			do_gettimeofday(&cam->capture.frame[load_address_base_index].buffer.timestamp);

			cam->isp->isp_ccdc.reg.CCDC_SDR_ADDR = cam->capture.frame[load_address_base_index].buffer.m.offset;
			cam->capture.using_buf	= load_address_base_index;
			cam->capture.frame[load_address_base_index].buffer.flags |= V4L2_BUF_FLAG_DONE;

			time_to_tm(cam->capture.frame[load_address_base_index].buffer.timestamp.tv_sec,DISABLE, &timecode);

			cam->capture.frame[load_address_base_index].buffer.timecode.seconds = timecode.tm_sec;
			cam->capture.frame[load_address_base_index].buffer.timecode.minutes = timecode.tm_min;
			cam->capture.frame[load_address_base_index].buffer.timecode.hours = timecode.tm_hour;
			cam->capture.frame[load_address_base_index].buffer.timecode.type = V4L2_TC_TYPE_30FPS;
			cam->capture.frame[load_address_base_index].buffer.timecode.flags = V4L2_TC_FLAG_COLORFRAME;
			cam->capture.frame[load_address_base_index].buffer.timecode.frames = cam->capture.buffer_sequence;
			cam->capture.frame[load_address_base_index].buffer.sequence = cam->capture.buffer_sequence;
		}

		/* Note the valid buffers available in the pool */
		cam->capture.valid_buf	= valid_buf;
	}
	
	return SUCCESS;
}
示例#27
0
文件: date.c 项目: B-Rich/Git-Cheetah
const char *show_date(unsigned long time, int tz, enum date_mode mode)
{
	struct tm *tm;
	static char timebuf[200];

	if (mode == DATE_RELATIVE) {
		unsigned long diff;
		struct timeval now;
		gettimeofday(&now, NULL);
		if (now.tv_sec < time)
			return "in the future";
		diff = now.tv_sec - time;
		if (diff < 90) {
			snprintf(timebuf, sizeof(timebuf), "%lu seconds ago", diff);
			return timebuf;
		}
		/* Turn it into minutes */
		diff = (diff + 30) / 60;
		if (diff < 90) {
			snprintf(timebuf, sizeof(timebuf), "%lu minutes ago", diff);
			return timebuf;
		}
		/* Turn it into hours */
		diff = (diff + 30) / 60;
		if (diff < 36) {
			snprintf(timebuf, sizeof(timebuf), "%lu hours ago", diff);
			return timebuf;
		}
		/* We deal with number of days from here on */
		diff = (diff + 12) / 24;
		if (diff < 14) {
			snprintf(timebuf, sizeof(timebuf), "%lu days ago", diff);
			return timebuf;
		}
		/* Say weeks for the past 10 weeks or so */
		if (diff < 70) {
			snprintf(timebuf, sizeof(timebuf), "%lu weeks ago", (diff + 3) / 7);
			return timebuf;
		}
		/* Say months for the past 12 months or so */
		if (diff < 360) {
			snprintf(timebuf, sizeof(timebuf), "%lu months ago", (diff + 15) / 30);
			return timebuf;
		}
		/* Else fall back on absolute format.. */
	}

	if (mode == DATE_LOCAL)
		tz = local_tzoffset(time);

	tm = time_to_tm(time, tz);
	if (!tm)
		return NULL;
	if (mode == DATE_SHORT)
		sprintf(timebuf, "%04d-%02d-%02d", tm->tm_year + 1900,
				tm->tm_mon + 1, tm->tm_mday);
	else if (mode == DATE_ISO8601)
		sprintf(timebuf, "%04d-%02d-%02d %02d:%02d:%02d %+05d",
				tm->tm_year + 1900,
				tm->tm_mon + 1,
				tm->tm_mday,
				tm->tm_hour, tm->tm_min, tm->tm_sec,
				tz);
	else if (mode == DATE_RFC2822)
		sprintf(timebuf, "%.3s, %d %.3s %d %02d:%02d:%02d %+05d",
			weekday_names[tm->tm_wday], tm->tm_mday,
			month_names[tm->tm_mon], tm->tm_year + 1900,
			tm->tm_hour, tm->tm_min, tm->tm_sec, tz);
	else
		sprintf(timebuf, "%.3s %.3s %d %02d:%02d:%02d %d%c%+05d",
				weekday_names[tm->tm_wday],
				month_names[tm->tm_mon],
				tm->tm_mday,
				tm->tm_hour, tm->tm_min, tm->tm_sec,
				tm->tm_year + 1900,
				(mode == DATE_LOCAL) ? 0 : ' ',
				tz);
	return timebuf;
}
示例#28
0
static void cpwatcher_work_func(struct work_struct *wq)
{
	struct cpwatcher_dev *dev = cpwatcher;
	unsigned int status = 0;
    //int ret = 0;
        
	//unsigned char data;				//Blocked due to CS Issue
    struct timeval now;
    struct tm gmt_time;

	char* argv[] = {"/system/bin/ifx_coredump", "CP_CRASH_IRQ", NULL};
	char *envp[] = { "HOME=/",	"PATH=/sbin:/bin:/system/bin",	NULL };	

    do_gettimeofday(&now);
    time_to_tm(now.tv_sec, 0, &gmt_time);
        
    printk("[CPW] cpwatcher_work_func()\n");
    printk(KERN_ERR "%d-%d-%d %d:%d:%d.%ld *\n",
        gmt_time.tm_year + 1900, gmt_time.tm_mon + 1, 
        gmt_time.tm_mday, gmt_time.tm_hour - sys_tz.tz_minuteswest / 60,
        gmt_time.tm_min, gmt_time.tm_sec, now.tv_usec);
        
    time_to_stop = 1; //                                                                                                             
	if (dev->onoff) {

		cpwatcher_get_status(&status);
		printk("[CPW] %s(), status: %d\n", __FUNCTION__, status);

		if (status == 0) {//If High, CP error

            wake_lock(&dev->wake_lock);

            // UPDATE CP_CRASH_COUNT -- //Blocked due to CS Issue
            //                                                            
            //data++;
            //                                                             

            // CHECK CP_CRASH_DUMP OPTION
            //if (lge_is_crash_dump_enabled() != 1) //this line will be enabled rev.e
            {
                input_report_key(dev->input, EVENT_KEY, 1);
                input_report_key(dev->input, EVENT_KEY, 0);
                input_sync(dev->input);
                printk("[CPW] CP Crash : input_report_key(): %d\n", EVENT_KEY);
                is_cp_crash = 1; //RIP-13119 : RIL recovery should be started by USB-disconnection.
                
                //RIP-73256 - S
                if(lge_is_ril_recovery_mode_enabled() != 1)
                {
                    printk("[CPW] CP Crash : lge_is_ril_recovery_mode_enabled() = 1 ...change to CP_USB mode \n");
                    gpio_set_value(KEYBACKLIGHT_LEDS_GPIO, 1);      //Temporary -- Keybacklight on when occurs CP Crash

                    extern void muic_proc_set_cp_usb_force(void);
                    muic_proc_set_cp_usb_force();
                }
                wake_unlock(&dev->wake_lock);
                //RIP-73256 - E
                return;
            }

    //                {
    //                        extern void tegra_ehci_shutdown_global(void);
    //                        tegra_ehci_shutdown_global();
    
    //                }
    
    //        Enabled after Fixing Baudrate Issue 
    //        ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
    //        printk("[CP CRASH IRQ] launch ifx_coredump process ret:%d\n", ret);
                        
		}
	}
}
示例#29
0
文件: minigit.c 项目: ksomemo/minigit
void parse_commit_object(object_info *oi, commit *pcmt)
{
    //ヘッダー部は読み飛ばす
    char *cp = oi->buf + oi->header_length;
    //ボディのサイズはヘッダに書かれてあるのを参照する
    //char *end = oi->buf + oi->header_length + oi->size;

    char tree_sha1[41];
    char parent_sha1[41];
    char author_name[256];
    char frmted_time[256];

    /**
     * spec of commit object body
     * -------
     * tree <sha1>
     * parent <sha1>
     * [parent <sha1>
     * author  ....
     * committer ....
     *
     * message
     * --------
     */

    // skip 'tree '
    cp += 5;
    int i = 0;

    while (*cp != '\n') {
	tree_sha1[i++] = *(cp++);
    }
    tree_sha1[40] = '\0';

    cp++;

    // skip 'parent '
    if (*cp == 'p') {
	cp += 7;
	i = 0;
	while (*cp != '\n') {
	    parent_sha1[i++] = *(cp++);
	}
	parent_sha1[40] = '\0';
	cp++; // skip '\n'
    } else {
	memset(parent_sha1, '\0', 41);
    }

    validate_sha1(parent_sha1);
    //マージコミットの場合はまたparentがある。

    cp += 7; // skip 'author '
    i = 0;
    while (*cp != '>') {
	author_name[i++] = *(cp++);
    }

    author_name[i++] = *(cp++);
    author_name[i] = '\0';

    cp++;  //skip ' '
    char str_timestamp[11];
    for (i=0;i<10;i++) {
	str_timestamp[i] = *(cp++);
    }
    str_timestamp[10] = '\0';

    char timediff[6];
    cp++; //skip ' '

    for (i=0;i<5;i++) {
	timediff[i] = *(cp++);
    }
    timediff[5] = '\0';

    while (*(++cp) != '\n') ;
    cp+=2; //skip \n and \n

    time_t t;
    t = atoi(str_timestamp);
    struct tm *tm;

    int tz = atoi(timediff);

    tm = time_to_tm(t, tz);

    // see show_date in date.c#L207
    sprintf(frmted_time ,"%.3s %.3s %d %02d:%02d:%02d %d%c%+05d",
	 weekday_names[tm->tm_wday],
	 month_names[tm->tm_mon],
	 tm->tm_mday,
	 tm->tm_hour, tm->tm_min, tm->tm_sec,
	 tm->tm_year + 1900,
	 ' ',
	 tz
	 );

    strcpy(pcmt->tree_sha1, tree_sha1);
    strcpy(pcmt->parent_sha1, parent_sha1);
    strcpy(pcmt->frmted_time, frmted_time);
    strcpy(pcmt->author_name, author_name);
    pcmt->message = cp;
}