/* 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 3 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
/** library to communicate with the Maxim DS1307 I2C RTC IC (code)
 *  @file rtc_ds1307.c
 *  @author King Kévin <kingkevin@cuvoodoo.info>
 *  @date 2016-2017
 *  @note peripherals used: I2C @ref i2c_master_i2c
 */

/* standard libraries */
#include <stdint.h> // standard integer types
#include <stdio.h> // standard I/O facilities
#include <stdlib.h> // general utilities

/* STM32 (including CM3) libraries */
#include <libopencm3/stm32/rcc.h> // real-time control clock library
#include <libopencm3/stm32/gpio.h> // general purpose input output library
#include <libopencm3/stm32/i2c.h> // I2C library

#include "global.h" // global utilities
#include "rtc_ds1307.h" // RTC header and definitions
#include "i2c_master.h" // i2c utilities

#define RTC_DS1307_I2C_ADDR 0x68 /**< DS1307 I2C address (fixed to 0b1101000) */

void rtc_ds1307_setup(void)
{
	// configure I2C peripheral
	i2c_master_setup(false); // DS1307 only supports normal mode (up to 100 kHz)
}

bool rtc_ds1307_oscillator_disabled(void)
{
	uint8_t data[1] = {0}; // to read data over I2C
	const uint8_t address[] = {0x00}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read a single byte containing CH value
		return false;
	}
	return data[0]&0x80; // return CH bit value to indicate if oscillator is disabled
}

uint16_t rtc_ds1307_read_square_wave(void)
{
	uint16_t to_return = 0; // square wave frequency to return (in Hz)
	uint8_t data[1] = {0}; // to read data over I2C
	const uint16_t rtc_ds1307_rs[] = {1, 4096, 8192, 32768}; // RS1/RS0 values
	const uint8_t address[] = {0x07}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read a single byte containing control register
		return 0xffff; // error occurred
	}
	if (data[0]&0x10) { // verify if the square wave is enabled (SQWE)
		to_return = rtc_ds1307_rs[data[0]&0x03]; // read RS1/RS0 and get value
	} else {
		to_return = 0; // square wave output is disabled
	}
	return to_return;
}

uint8_t rtc_ds1307_read_seconds(void)
{
	uint8_t to_return = 0; // seconds to return
	uint8_t data[1] = {0}; // to read data over I2C
	const uint8_t address[] = {0x00}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read a single byte containing value
		return 0xff;
	}
	to_return = ((data[0]&0x70)>>4)*10+(data[0]&0x0f); // convert BCD coding into seconds
	return to_return;
}

uint8_t rtc_ds1307_read_minutes(void)
{
	uint8_t to_return = 0; // minutes to return
	uint8_t data[1] = {0}; // to read data over I2C
	const uint8_t address[] = {0x01}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read a single byte containing value
		return 0xff;
	}
	to_return = (data[0]>>4)*10+(data[0]&0x0f); // convert BCD coding into minutes
	return to_return;
}

uint8_t rtc_ds1307_read_hours(void)
{
	uint8_t to_return = 0; // hours to return
	uint8_t data[1] = {0}; // to read data over I2C
	const uint8_t address[] = {0x02}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read a single byte containing value
		return 0xff;
	}
	if (data[0]&0x40) { // 12 hour mode
		if (data[0]&0x02) { // PM
			to_return += 12; // add the 12 hours
		}
		to_return += ((data[0]&0x10)>>4)*10; // convert BCD coding into hours (first digit)
	} else {
		to_return = ((data[0]&0x30)>>4)*10; // convert BCD coding into hours (first digit)
	}
	to_return += (data[0]&0x0f); // convert BCD coding into hours (second digit)
	return to_return;
}

uint8_t rtc_ds1307_read_day(void)
{
	uint8_t to_return = 0; // day to return
	uint8_t data[1] = {0}; // to read data over I2C
	const uint8_t address[] = {0x03}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read a single byte containing value
		return 0xff;
	}
	to_return = (data[0]&0x07); // convert BCD coding into days
	return to_return;
}

uint8_t rtc_ds1307_read_date(void)
{
	uint8_t to_return = 0; // date to return
	uint8_t data[1] = {0}; // to read data over I2C
	const uint8_t address[] = {0x04}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read a single byte containing value
		return 0xff;
	}
	to_return = ((data[0]&0x30)>>4)*10+(data[0]&0x0f); // convert BCD coding into date
	return to_return;
}

uint8_t rtc_ds1307_read_month(void)
{
	uint8_t to_return = 0; // month to return
	uint8_t data[1] = {0}; // to read data over I2C
	const uint8_t address[] = {0x05}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read a single byte containing value
		return 0xff;
	}
	to_return = ((data[0]&0x10)>>4)*10+(data[0]&0x0f); // convert BCD coding into month
	return to_return;
}

uint8_t rtc_ds1307_read_year(void)
{
	uint8_t data[1] = {0}; // to read data over I2C
	const uint8_t address[] = {0x06}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read a single byte containing value
		return 0xff;
	}
	uint8_t to_return = ((data[0]&0xf0)>>4)*10+(data[0]&0x0f); // convert BCD coding into year
	return to_return;
}

uint8_t* rtc_ds1307_read_time(void)
{
	static uint8_t time[7] = {0}; // store time {seconds, minutes, hours, day, date, month, year}
	uint8_t data[7] = {0}; // to read data over I2C
	const uint8_t address[] = {0x00}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read all time bytes
		return NULL; // error occurred
	}
	time[0] = ((data[0]&0x70)>>4)*10+(data[0]&0x0f); // convert seconds from BCD
	time[1] = (data[1]>>4)*10+(data[1]&0x0f); // convert minutes from BCD
	time[2] = 0; // re-initialize hours
	if (data[2]&0x40) { // 12 hour mode
		if (data[2]&0x02) { // PM
			time[2] += 12; // add the 12 hours
		}
		time[2] += ((data[2]&0x10)>>4)*10; // convert BCD coding into hours (first digit)
	} else {
		time[2] = ((data[2]&0x30)>>4)*10; // convert BCD coding into hours (first digit)
	}
	time[2] += (data[2]&0x0f); // convert BCD coding into hours (second digit)
	time[3] = (data[3]&0x07); // convert BCD coding into days
	time[4] = ((data[4]&0x30)>>4)*10+(data[4]&0x0f); // convert BCD coding into date
	time[5] = ((data[5]&0x10)>>4)*10+(data[5]&0x0f); // convert BCD coding into month
	time[6] = ((data[6]&0xf0)>>4)*10+(data[6]&0x0f); // convert BCD coding into year
	return time;
}

bool rtc_ds1307_read_ram(uint8_t* data, uint8_t start, uint8_t length)
{
	// sanity checks
	if (data==NULL || length==0) { // nothing to read
		return false;
	}
	if (start>55 || start+length>56) { // out of bounds RAM
		return false;
	}

	const uint8_t address[] = {0x08+start}; // memory address for data
	return i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // read RAM (starting at 0x08)
}

bool rtc_ds1307_oscillator_disable(void)
{
	uint8_t data[1] = {0}; // to write CH value data over I2C
	const uint8_t address[] = {0x00}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read seconds with CH value
		return false;
	}
	data[0] |= 0x80; // set CH to disable oscillator
	return i2c_master_write(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // write current seconds with CH value
}

bool rtc_ds1307_oscillator_enable(void)
{
	uint8_t data[1] = {0}; // to write CH value data over I2C
	const uint8_t address[] = {0x00}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read seconds with CH value
		return false;
	}
	data[0] &= 0x7f; // clear CH to enable oscillator
	return i2c_master_write(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // write current seconds with CH value
}

bool rtc_ds1307_write_square_wave(uint16_t frequency)
{
	uint8_t data[1] = {0}; // to write control register value data over I2C
	switch (frequency) { // set RS1/RS0 based on frequency
		case 0:
			data[0] = 0;
			break;
		case 1:
			data[0] = 0|(1<<4);
			break;
		case 4096:
			data[0] = 1|(1<<4);
			break;
		case 8192:
			data[0] = 2|(1<<4);
			break;
		case 32768:
			data[0] = 3|(1<<4);
			break;
		default: // unspecified frequency
			return false;
	}
	const uint8_t address[] = {0x07}; // memory address for data
	return i2c_master_write(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // write current seconds with CH value
}

bool rtc_ds1307_write_seconds(uint8_t seconds)
{
	if (seconds>59) {
		return false;
	}
	uint8_t data[1] = {0}; // to read CH value data and write seconds value over I2C
	const uint8_t address[] = {0x00}; // memory address for data
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data))) { // read seconds with CH value
		return false;
	}
	data[0] &= 0x80; // only keep CH flag
	data[0] |= (((seconds/10)%6)<<4)+(seconds%10); // encode seconds in BCD format

	return i2c_master_write(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // write current seconds with previous CH value
}

bool rtc_ds1307_write_minutes(uint8_t minutes)
{
	if (minutes>59) {
		return false;
	}
	uint8_t data[1] = {0}; // to write time value
	data[0] = (((minutes/10)%6)<<4)+(minutes%10); // encode minutes in BCD format

	const uint8_t address[] = {0x01}; // memory address for data
	return i2c_master_write(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // write time value on RTC
}

bool rtc_ds1307_write_hours(uint8_t hours)
{
	if (hours>24) {
		return false;
	}
	uint8_t data[1] = {0}; // to write time value
	data[0] = (((hours/10)%3)<<4)+(hours%10); // encode hours in BCD 24h format

	const uint8_t address[] = {0x02}; // memory address for data
	return i2c_master_write(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // write time value on RTC
}

bool rtc_ds1307_write_day(uint8_t day)
{
	if (day<1 || day>7) {
		return false;
	}
	uint8_t data[1] = {0}; // to write time value
	data[0] = (day%8); // encode day in BCD format

	const uint8_t address[] = {0x03}; // memory address for data
	return i2c_master_write(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // write time value on RTC
}

bool rtc_ds1307_write_date(uint8_t date)
{
	if (date<1 || date>31) {
		return false;
	}
	uint8_t data[1] = {0}; // to write time value
	data[0] = (((date/10)%4)<<4)+(date%10); // encode date in BCD format

	const uint8_t address[] = {0x04}; // memory address for data
	return i2c_master_write(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // write time value on RTC
}

bool rtc_ds1307_write_month(uint8_t month)
{
	if (month<1 || month>12) {
		return false;
	}
	uint8_t data[1] = {0}; // to write time value
	data[0] = (((month/10)%2)<<4)+(month%10); // encode month in BCD format

	const uint8_t address[] = {0x05}; // memory address for data
	return i2c_master_write(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // write time value on RTC
}

bool rtc_ds1307_write_year(uint8_t year)
{
	if (year>99) {
		return false;
	}
	uint8_t data[1] = {0}; // to write time value
	data[0] = (((year/10)%10)<<4)+(year%10); // encode year in BCD format

	const uint8_t address[] = {0x06}; // memory address for data
	return i2c_master_write(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // write time value on RTC
}

bool rtc_ds1307_write_time(uint8_t seconds, uint8_t minutes, uint8_t hours, uint8_t day, uint8_t date, uint8_t month, uint8_t year)
{
	uint8_t data[7] = {0}; // to write all time values
	const uint8_t address[] = {0x00}; // memory address for data
	// seconds
	if (seconds>59) {
		return false;
	}
	if (!i2c_master_read(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, 1)) { // read seconds with CH value
		return false;
	}
	data[0] &= 0x80; // only keep CH flag
	data[0] |= (((seconds/10)%6)<<4)+(seconds%10); // encode seconds in BCD format
	// minutes
	if (minutes>59) {
		return false;
	}
	data[1] = (((minutes/10)%6)<<4)+(minutes%10); // encode minutes in BCD format
	// hours
	if (hours>24) {
		return false;
	}
	data[2] = (((hours/10)%3)<<4)+(hours%10); // encode hours in BCD 24h format
	// day
	if (day<1 || day>7) {
		return false;
	}
	data[3] = (day%8); // encode day in BCD format
	// date
	if (date<1 || date>31) {
		return false;
	}
	data[4] = (((date/10)%4)<<4)+(date%10); // encode date in BCD format
	// month
	if (month<1 || month>12) {
		return false;
	}
	data[5] = (((month/10)%2)<<4)+(month%10); // encode month in BCD format
	// year
	if (year>99) {
		return false;
	}
	data[6] = (((year/10)%10)<<4)+(year%10); // encode year in BCD format

	return i2c_master_write(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // write time value on RTC
}

bool rtc_ds1307_write_ram(uint8_t* data, uint8_t start, uint8_t length)
{
	// sanity checks
	if (data==NULL || length==0) { // nothing to read
		return false;
	}
	if (start>55 || start+length>56) { // out of bounds RAM
		return false;
	}
	const uint8_t address[] = {0x08+start}; // memory address for data
	return i2c_master_write(RTC_DS1307_I2C_ADDR, address, LENGTH(address), data, LENGTH(data)); // write RAM (starting at 0x08)
}