tree 7041fa692e8216766f8e86dc70e85643cdc678dc
parent b27dc8ec5c8f62f655b7964bc1bd12448ef788f8
author Heinrich Schuchardt <xypron.glpk@gmx.de> 1531001246 +0200
committer Tom Rini <trini@konsulko.com> 1532116504 -0400

drivers: rtc: correct week day for mc146818

For qemu-x86 the date command produces wrong days of the week:
Date: 2018-07-06 (Saturday)    Time: 18:02:03
Date: 2018-07-07 (unknown day)    Time: 21:02:06

According to a comment in the Linux driver the mc146818 only updates the
day of the week if the register value is non-zero.

Sunday is 1, saturday is 7 unlike in U-Boot (see data sheet
https://www.nxp.com/docs/en/data-sheet/MC146818.pdf).

So let's use our library function to determine the day of the week.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
