os-area.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837
  1. /*
  2. * PS3 flash memory os area.
  3. *
  4. * Copyright (C) 2006 Sony Computer Entertainment Inc.
  5. * Copyright 2006 Sony Corp.
  6. *
  7. * This program is free software; you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License as published by
  9. * the Free Software Foundation; version 2 of the License.
  10. *
  11. * This program is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; if not, write to the Free Software
  18. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19. */
  20. #include <linux/kernel.h>
  21. #include <linux/io.h>
  22. #include <linux/workqueue.h>
  23. #include <linux/fs.h>
  24. #include <linux/syscalls.h>
  25. #include <linux/ctype.h>
  26. #include <linux/lmb.h>
  27. #include <linux/of.h>
  28. #include <asm/prom.h>
  29. #include "platform.h"
  30. enum {
  31. OS_AREA_SEGMENT_SIZE = 0X200,
  32. };
  33. enum os_area_ldr_format {
  34. HEADER_LDR_FORMAT_RAW = 0,
  35. HEADER_LDR_FORMAT_GZIP = 1,
  36. };
  37. #define OS_AREA_HEADER_MAGIC_NUM "cell_ext_os_area"
  38. /**
  39. * struct os_area_header - os area header segment.
  40. * @magic_num: Always 'cell_ext_os_area'.
  41. * @hdr_version: Header format version number.
  42. * @db_area_offset: Starting segment number of other os database area.
  43. * @ldr_area_offset: Starting segment number of bootloader image area.
  44. * @ldr_format: HEADER_LDR_FORMAT flag.
  45. * @ldr_size: Size of bootloader image in bytes.
  46. *
  47. * Note that the docs refer to area offsets. These are offsets in units of
  48. * segments from the start of the os area (top of the header). These are
  49. * better thought of as segment numbers. The os area of the os area is
  50. * reserved for the os image.
  51. */
  52. struct os_area_header {
  53. u8 magic_num[16];
  54. u32 hdr_version;
  55. u32 db_area_offset;
  56. u32 ldr_area_offset;
  57. u32 _reserved_1;
  58. u32 ldr_format;
  59. u32 ldr_size;
  60. u32 _reserved_2[6];
  61. };
  62. enum os_area_boot_flag {
  63. PARAM_BOOT_FLAG_GAME_OS = 0,
  64. PARAM_BOOT_FLAG_OTHER_OS = 1,
  65. };
  66. enum os_area_ctrl_button {
  67. PARAM_CTRL_BUTTON_O_IS_YES = 0,
  68. PARAM_CTRL_BUTTON_X_IS_YES = 1,
  69. };
  70. /**
  71. * struct os_area_params - os area params segment.
  72. * @boot_flag: User preference of operating system, PARAM_BOOT_FLAG flag.
  73. * @num_params: Number of params in this (params) segment.
  74. * @rtc_diff: Difference in seconds between 1970 and the ps3 rtc value.
  75. * @av_multi_out: User preference of AV output, PARAM_AV_MULTI_OUT flag.
  76. * @ctrl_button: User preference of controller button config, PARAM_CTRL_BUTTON
  77. * flag.
  78. * @static_ip_addr: User preference of static IP address.
  79. * @network_mask: User preference of static network mask.
  80. * @default_gateway: User preference of static default gateway.
  81. * @dns_primary: User preference of static primary dns server.
  82. * @dns_secondary: User preference of static secondary dns server.
  83. *
  84. * The ps3 rtc maintains a read-only value that approximates seconds since
  85. * 2000-01-01 00:00:00 UTC.
  86. *
  87. * User preference of zero for static_ip_addr means use dhcp.
  88. */
  89. struct os_area_params {
  90. u32 boot_flag;
  91. u32 _reserved_1[3];
  92. u32 num_params;
  93. u32 _reserved_2[3];
  94. /* param 0 */
  95. s64 rtc_diff;
  96. u8 av_multi_out;
  97. u8 ctrl_button;
  98. u8 _reserved_3[6];
  99. /* param 1 */
  100. u8 static_ip_addr[4];
  101. u8 network_mask[4];
  102. u8 default_gateway[4];
  103. u8 _reserved_4[4];
  104. /* param 2 */
  105. u8 dns_primary[4];
  106. u8 dns_secondary[4];
  107. u8 _reserved_5[8];
  108. };
  109. #define OS_AREA_DB_MAGIC_NUM "-db-"
  110. /**
  111. * struct os_area_db - Shared flash memory database.
  112. * @magic_num: Always '-db-'.
  113. * @version: os_area_db format version number.
  114. * @index_64: byte offset of the database id index for 64 bit variables.
  115. * @count_64: number of usable 64 bit index entries
  116. * @index_32: byte offset of the database id index for 32 bit variables.
  117. * @count_32: number of usable 32 bit index entries
  118. * @index_16: byte offset of the database id index for 16 bit variables.
  119. * @count_16: number of usable 16 bit index entries
  120. *
  121. * Flash rom storage for exclusive use by guests running in the other os lpar.
  122. * The current system configuration allocates 1K (two segments) for other os
  123. * use.
  124. */
  125. struct os_area_db {
  126. u8 magic_num[4];
  127. u16 version;
  128. u16 _reserved_1;
  129. u16 index_64;
  130. u16 count_64;
  131. u16 index_32;
  132. u16 count_32;
  133. u16 index_16;
  134. u16 count_16;
  135. u32 _reserved_2;
  136. u8 _db_data[1000];
  137. };
  138. /**
  139. * enum os_area_db_owner - Data owners.
  140. */
  141. enum os_area_db_owner {
  142. OS_AREA_DB_OWNER_ANY = -1,
  143. OS_AREA_DB_OWNER_NONE = 0,
  144. OS_AREA_DB_OWNER_PROTOTYPE = 1,
  145. OS_AREA_DB_OWNER_LINUX = 2,
  146. OS_AREA_DB_OWNER_PETITBOOT = 3,
  147. OS_AREA_DB_OWNER_MAX = 32,
  148. };
  149. enum os_area_db_key {
  150. OS_AREA_DB_KEY_ANY = -1,
  151. OS_AREA_DB_KEY_NONE = 0,
  152. OS_AREA_DB_KEY_RTC_DIFF = 1,
  153. OS_AREA_DB_KEY_VIDEO_MODE = 2,
  154. OS_AREA_DB_KEY_MAX = 8,
  155. };
  156. struct os_area_db_id {
  157. int owner;
  158. int key;
  159. };
  160. static const struct os_area_db_id os_area_db_id_empty = {
  161. .owner = OS_AREA_DB_OWNER_NONE,
  162. .key = OS_AREA_DB_KEY_NONE
  163. };
  164. static const struct os_area_db_id os_area_db_id_any = {
  165. .owner = OS_AREA_DB_OWNER_ANY,
  166. .key = OS_AREA_DB_KEY_ANY
  167. };
  168. static const struct os_area_db_id os_area_db_id_rtc_diff = {
  169. .owner = OS_AREA_DB_OWNER_LINUX,
  170. .key = OS_AREA_DB_KEY_RTC_DIFF
  171. };
  172. static const struct os_area_db_id os_area_db_id_video_mode = {
  173. .owner = OS_AREA_DB_OWNER_LINUX,
  174. .key = OS_AREA_DB_KEY_VIDEO_MODE
  175. };
  176. #define SECONDS_FROM_1970_TO_2000 946684800LL
  177. /**
  178. * struct saved_params - Static working copies of data from the PS3 'os area'.
  179. *
  180. * The order of preference we use for the rtc_diff source:
  181. * 1) The database value.
  182. * 2) The game os value.
  183. * 3) The number of seconds from 1970 to 2000.
  184. */
  185. struct saved_params {
  186. unsigned int valid;
  187. s64 rtc_diff;
  188. unsigned int av_multi_out;
  189. } static saved_params;
  190. static struct property property_rtc_diff = {
  191. .name = "linux,rtc_diff",
  192. .length = sizeof(saved_params.rtc_diff),
  193. .value = &saved_params.rtc_diff,
  194. };
  195. static struct property property_av_multi_out = {
  196. .name = "linux,av_multi_out",
  197. .length = sizeof(saved_params.av_multi_out),
  198. .value = &saved_params.av_multi_out,
  199. };
  200. /**
  201. * os_area_set_property - Add or overwrite a saved_params value to the device tree.
  202. *
  203. * Overwrites an existing property.
  204. */
  205. static void os_area_set_property(struct device_node *node,
  206. struct property *prop)
  207. {
  208. int result;
  209. struct property *tmp = of_find_property(node, prop->name, NULL);
  210. if (tmp) {
  211. pr_debug("%s:%d found %s\n", __func__, __LINE__, prop->name);
  212. prom_remove_property(node, tmp);
  213. }
  214. result = prom_add_property(node, prop);
  215. if (result)
  216. pr_debug("%s:%d prom_set_property failed\n", __func__,
  217. __LINE__);
  218. }
  219. /**
  220. * os_area_get_property - Get a saved_params value from the device tree.
  221. *
  222. */
  223. static void __init os_area_get_property(struct device_node *node,
  224. struct property *prop)
  225. {
  226. const struct property *tmp = of_find_property(node, prop->name, NULL);
  227. if (tmp) {
  228. BUG_ON(prop->length != tmp->length);
  229. memcpy(prop->value, tmp->value, prop->length);
  230. } else
  231. pr_debug("%s:%d not found %s\n", __func__, __LINE__,
  232. prop->name);
  233. }
  234. static void dump_field(char *s, const u8 *field, int size_of_field)
  235. {
  236. #if defined(DEBUG)
  237. int i;
  238. for (i = 0; i < size_of_field; i++)
  239. s[i] = isprint(field[i]) ? field[i] : '.';
  240. s[i] = 0;
  241. #endif
  242. }
  243. #define dump_header(_a) _dump_header(_a, __func__, __LINE__)
  244. static void _dump_header(const struct os_area_header *h, const char *func,
  245. int line)
  246. {
  247. char str[sizeof(h->magic_num) + 1];
  248. dump_field(str, h->magic_num, sizeof(h->magic_num));
  249. pr_debug("%s:%d: h.magic_num: '%s'\n", func, line,
  250. str);
  251. pr_debug("%s:%d: h.hdr_version: %u\n", func, line,
  252. h->hdr_version);
  253. pr_debug("%s:%d: h.db_area_offset: %u\n", func, line,
  254. h->db_area_offset);
  255. pr_debug("%s:%d: h.ldr_area_offset: %u\n", func, line,
  256. h->ldr_area_offset);
  257. pr_debug("%s:%d: h.ldr_format: %u\n", func, line,
  258. h->ldr_format);
  259. pr_debug("%s:%d: h.ldr_size: %xh\n", func, line,
  260. h->ldr_size);
  261. }
  262. #define dump_params(_a) _dump_params(_a, __func__, __LINE__)
  263. static void _dump_params(const struct os_area_params *p, const char *func,
  264. int line)
  265. {
  266. pr_debug("%s:%d: p.boot_flag: %u\n", func, line, p->boot_flag);
  267. pr_debug("%s:%d: p.num_params: %u\n", func, line, p->num_params);
  268. pr_debug("%s:%d: p.rtc_diff %lld\n", func, line, p->rtc_diff);
  269. pr_debug("%s:%d: p.av_multi_out %u\n", func, line, p->av_multi_out);
  270. pr_debug("%s:%d: p.ctrl_button: %u\n", func, line, p->ctrl_button);
  271. pr_debug("%s:%d: p.static_ip_addr: %u.%u.%u.%u\n", func, line,
  272. p->static_ip_addr[0], p->static_ip_addr[1],
  273. p->static_ip_addr[2], p->static_ip_addr[3]);
  274. pr_debug("%s:%d: p.network_mask: %u.%u.%u.%u\n", func, line,
  275. p->network_mask[0], p->network_mask[1],
  276. p->network_mask[2], p->network_mask[3]);
  277. pr_debug("%s:%d: p.default_gateway: %u.%u.%u.%u\n", func, line,
  278. p->default_gateway[0], p->default_gateway[1],
  279. p->default_gateway[2], p->default_gateway[3]);
  280. pr_debug("%s:%d: p.dns_primary: %u.%u.%u.%u\n", func, line,
  281. p->dns_primary[0], p->dns_primary[1],
  282. p->dns_primary[2], p->dns_primary[3]);
  283. pr_debug("%s:%d: p.dns_secondary: %u.%u.%u.%u\n", func, line,
  284. p->dns_secondary[0], p->dns_secondary[1],
  285. p->dns_secondary[2], p->dns_secondary[3]);
  286. }
  287. static int verify_header(const struct os_area_header *header)
  288. {
  289. if (memcmp(header->magic_num, OS_AREA_HEADER_MAGIC_NUM,
  290. sizeof(header->magic_num))) {
  291. pr_debug("%s:%d magic_num failed\n", __func__, __LINE__);
  292. return -1;
  293. }
  294. if (header->hdr_version < 1) {
  295. pr_debug("%s:%d hdr_version failed\n", __func__, __LINE__);
  296. return -1;
  297. }
  298. if (header->db_area_offset > header->ldr_area_offset) {
  299. pr_debug("%s:%d offsets failed\n", __func__, __LINE__);
  300. return -1;
  301. }
  302. return 0;
  303. }
  304. static int db_verify(const struct os_area_db *db)
  305. {
  306. if (memcmp(db->magic_num, OS_AREA_DB_MAGIC_NUM,
  307. sizeof(db->magic_num))) {
  308. pr_debug("%s:%d magic_num failed\n", __func__, __LINE__);
  309. return -1;
  310. }
  311. if (db->version != 1) {
  312. pr_debug("%s:%d version failed\n", __func__, __LINE__);
  313. return -1;
  314. }
  315. return 0;
  316. }
  317. struct db_index {
  318. uint8_t owner:5;
  319. uint8_t key:3;
  320. };
  321. struct db_iterator {
  322. const struct os_area_db *db;
  323. struct os_area_db_id match_id;
  324. struct db_index *idx;
  325. struct db_index *last_idx;
  326. union {
  327. uint64_t *value_64;
  328. uint32_t *value_32;
  329. uint16_t *value_16;
  330. };
  331. };
  332. static unsigned int db_align_up(unsigned int val, unsigned int size)
  333. {
  334. return (val + (size - 1)) & (~(size - 1));
  335. }
  336. /**
  337. * db_for_each_64 - Iterator for 64 bit entries.
  338. *
  339. * A NULL value for id can be used to match all entries.
  340. * OS_AREA_DB_OWNER_ANY and OS_AREA_DB_KEY_ANY can be used to match all.
  341. */
  342. static int db_for_each_64(const struct os_area_db *db,
  343. const struct os_area_db_id *match_id, struct db_iterator *i)
  344. {
  345. next:
  346. if (!i->db) {
  347. i->db = db;
  348. i->match_id = match_id ? *match_id : os_area_db_id_any;
  349. i->idx = (void *)db + db->index_64;
  350. i->last_idx = i->idx + db->count_64;
  351. i->value_64 = (void *)db + db->index_64
  352. + db_align_up(db->count_64, 8);
  353. } else {
  354. i->idx++;
  355. i->value_64++;
  356. }
  357. if (i->idx >= i->last_idx) {
  358. pr_debug("%s:%d: reached end\n", __func__, __LINE__);
  359. return 0;
  360. }
  361. if (i->match_id.owner != OS_AREA_DB_OWNER_ANY
  362. && i->match_id.owner != (int)i->idx->owner)
  363. goto next;
  364. if (i->match_id.key != OS_AREA_DB_KEY_ANY
  365. && i->match_id.key != (int)i->idx->key)
  366. goto next;
  367. return 1;
  368. }
  369. static int db_delete_64(struct os_area_db *db, const struct os_area_db_id *id)
  370. {
  371. struct db_iterator i;
  372. for (i.db = NULL; db_for_each_64(db, id, &i); ) {
  373. pr_debug("%s:%d: got (%d:%d) %llxh\n", __func__, __LINE__,
  374. i.idx->owner, i.idx->key,
  375. (unsigned long long)*i.value_64);
  376. i.idx->owner = 0;
  377. i.idx->key = 0;
  378. *i.value_64 = 0;
  379. }
  380. return 0;
  381. }
  382. static int db_set_64(struct os_area_db *db, const struct os_area_db_id *id,
  383. uint64_t value)
  384. {
  385. struct db_iterator i;
  386. pr_debug("%s:%d: (%d:%d) <= %llxh\n", __func__, __LINE__,
  387. id->owner, id->key, (unsigned long long)value);
  388. if (!id->owner || id->owner == OS_AREA_DB_OWNER_ANY
  389. || id->key == OS_AREA_DB_KEY_ANY) {
  390. pr_debug("%s:%d: bad id: (%d:%d)\n", __func__,
  391. __LINE__, id->owner, id->key);
  392. return -1;
  393. }
  394. db_delete_64(db, id);
  395. i.db = NULL;
  396. if (db_for_each_64(db, &os_area_db_id_empty, &i)) {
  397. pr_debug("%s:%d: got (%d:%d) %llxh\n", __func__, __LINE__,
  398. i.idx->owner, i.idx->key,
  399. (unsigned long long)*i.value_64);
  400. i.idx->owner = id->owner;
  401. i.idx->key = id->key;
  402. *i.value_64 = value;
  403. pr_debug("%s:%d: set (%d:%d) <= %llxh\n", __func__, __LINE__,
  404. i.idx->owner, i.idx->key,
  405. (unsigned long long)*i.value_64);
  406. return 0;
  407. }
  408. pr_debug("%s:%d: database full.\n",
  409. __func__, __LINE__);
  410. return -1;
  411. }
  412. static int db_get_64(const struct os_area_db *db,
  413. const struct os_area_db_id *id, uint64_t *value)
  414. {
  415. struct db_iterator i;
  416. i.db = NULL;
  417. if (db_for_each_64(db, id, &i)) {
  418. *value = *i.value_64;
  419. pr_debug("%s:%d: found %lld\n", __func__, __LINE__,
  420. (long long int)*i.value_64);
  421. return 0;
  422. }
  423. pr_debug("%s:%d: not found\n", __func__, __LINE__);
  424. return -1;
  425. }
  426. static int db_get_rtc_diff(const struct os_area_db *db, int64_t *rtc_diff)
  427. {
  428. return db_get_64(db, &os_area_db_id_rtc_diff, (uint64_t*)rtc_diff);
  429. }
  430. #define dump_db(a) _dump_db(a, __func__, __LINE__)
  431. static void _dump_db(const struct os_area_db *db, const char *func,
  432. int line)
  433. {
  434. char str[sizeof(db->magic_num) + 1];
  435. dump_field(str, db->magic_num, sizeof(db->magic_num));
  436. pr_debug("%s:%d: db.magic_num: '%s'\n", func, line,
  437. str);
  438. pr_debug("%s:%d: db.version: %u\n", func, line,
  439. db->version);
  440. pr_debug("%s:%d: db.index_64: %u\n", func, line,
  441. db->index_64);
  442. pr_debug("%s:%d: db.count_64: %u\n", func, line,
  443. db->count_64);
  444. pr_debug("%s:%d: db.index_32: %u\n", func, line,
  445. db->index_32);
  446. pr_debug("%s:%d: db.count_32: %u\n", func, line,
  447. db->count_32);
  448. pr_debug("%s:%d: db.index_16: %u\n", func, line,
  449. db->index_16);
  450. pr_debug("%s:%d: db.count_16: %u\n", func, line,
  451. db->count_16);
  452. }
  453. static void os_area_db_init(struct os_area_db *db)
  454. {
  455. enum {
  456. HEADER_SIZE = offsetof(struct os_area_db, _db_data),
  457. INDEX_64_COUNT = 64,
  458. VALUES_64_COUNT = 57,
  459. INDEX_32_COUNT = 64,
  460. VALUES_32_COUNT = 57,
  461. INDEX_16_COUNT = 64,
  462. VALUES_16_COUNT = 57,
  463. };
  464. memset(db, 0, sizeof(struct os_area_db));
  465. memcpy(db->magic_num, OS_AREA_DB_MAGIC_NUM, sizeof(db->magic_num));
  466. db->version = 1;
  467. db->index_64 = HEADER_SIZE;
  468. db->count_64 = VALUES_64_COUNT;
  469. db->index_32 = HEADER_SIZE
  470. + INDEX_64_COUNT * sizeof(struct db_index)
  471. + VALUES_64_COUNT * sizeof(u64);
  472. db->count_32 = VALUES_32_COUNT;
  473. db->index_16 = HEADER_SIZE
  474. + INDEX_64_COUNT * sizeof(struct db_index)
  475. + VALUES_64_COUNT * sizeof(u64)
  476. + INDEX_32_COUNT * sizeof(struct db_index)
  477. + VALUES_32_COUNT * sizeof(u32);
  478. db->count_16 = VALUES_16_COUNT;
  479. /* Rules to check db layout. */
  480. BUILD_BUG_ON(sizeof(struct db_index) != 1);
  481. BUILD_BUG_ON(sizeof(struct os_area_db) != 2 * OS_AREA_SEGMENT_SIZE);
  482. BUILD_BUG_ON(INDEX_64_COUNT & 0x7);
  483. BUILD_BUG_ON(VALUES_64_COUNT > INDEX_64_COUNT);
  484. BUILD_BUG_ON(INDEX_32_COUNT & 0x7);
  485. BUILD_BUG_ON(VALUES_32_COUNT > INDEX_32_COUNT);
  486. BUILD_BUG_ON(INDEX_16_COUNT & 0x7);
  487. BUILD_BUG_ON(VALUES_16_COUNT > INDEX_16_COUNT);
  488. BUILD_BUG_ON(HEADER_SIZE
  489. + INDEX_64_COUNT * sizeof(struct db_index)
  490. + VALUES_64_COUNT * sizeof(u64)
  491. + INDEX_32_COUNT * sizeof(struct db_index)
  492. + VALUES_32_COUNT * sizeof(u32)
  493. + INDEX_16_COUNT * sizeof(struct db_index)
  494. + VALUES_16_COUNT * sizeof(u16)
  495. > sizeof(struct os_area_db));
  496. }
  497. /**
  498. * update_flash_db - Helper for os_area_queue_work_handler.
  499. *
  500. */
  501. static void __maybe_unused update_flash_db(void)
  502. {
  503. int result;
  504. int file;
  505. off_t offset;
  506. ssize_t count;
  507. static const unsigned int buf_len = 8 * OS_AREA_SEGMENT_SIZE;
  508. const struct os_area_header *header;
  509. struct os_area_db* db;
  510. /* Read in header and db from flash. */
  511. file = sys_open("/dev/ps3flash", O_RDWR, 0);
  512. if (file < 0) {
  513. pr_debug("%s:%d sys_open failed\n", __func__, __LINE__);
  514. goto fail_open;
  515. }
  516. header = kmalloc(buf_len, GFP_KERNEL);
  517. if (!header) {
  518. pr_debug("%s:%d kmalloc failed\n", __func__, __LINE__);
  519. goto fail_malloc;
  520. }
  521. offset = sys_lseek(file, 0, SEEK_SET);
  522. if (offset != 0) {
  523. pr_debug("%s:%d sys_lseek failed\n", __func__, __LINE__);
  524. goto fail_header_seek;
  525. }
  526. count = sys_read(file, (char __user *)header, buf_len);
  527. result = count < OS_AREA_SEGMENT_SIZE || verify_header(header)
  528. || count < header->db_area_offset * OS_AREA_SEGMENT_SIZE;
  529. if (result) {
  530. pr_debug("%s:%d verify_header failed\n", __func__, __LINE__);
  531. dump_header(header);
  532. goto fail_header;
  533. }
  534. /* Now got a good db offset and some maybe good db data. */
  535. db = (void*)header + header->db_area_offset * OS_AREA_SEGMENT_SIZE;
  536. result = db_verify(db);
  537. if (result) {
  538. printk(KERN_NOTICE "%s:%d: Verify of flash database failed, "
  539. "formatting.\n", __func__, __LINE__);
  540. dump_db(db);
  541. os_area_db_init(db);
  542. }
  543. /* Now got good db data. */
  544. db_set_64(db, &os_area_db_id_rtc_diff, saved_params.rtc_diff);
  545. offset = sys_lseek(file, header->db_area_offset * OS_AREA_SEGMENT_SIZE,
  546. SEEK_SET);
  547. if (offset != header->db_area_offset * OS_AREA_SEGMENT_SIZE) {
  548. pr_debug("%s:%d sys_lseek failed\n", __func__, __LINE__);
  549. goto fail_db_seek;
  550. }
  551. count = sys_write(file, (const char __user *)db,
  552. sizeof(struct os_area_db));
  553. if (count < sizeof(struct os_area_db)) {
  554. pr_debug("%s:%d sys_write failed\n", __func__, __LINE__);
  555. }
  556. fail_db_seek:
  557. fail_header:
  558. fail_header_seek:
  559. kfree(header);
  560. fail_malloc:
  561. sys_close(file);
  562. fail_open:
  563. return;
  564. }
  565. /**
  566. * os_area_queue_work_handler - Asynchronous write handler.
  567. *
  568. * An asynchronous write for flash memory and the device tree. Do not
  569. * call directly, use os_area_queue_work().
  570. */
  571. static void os_area_queue_work_handler(struct work_struct *work)
  572. {
  573. struct device_node *node;
  574. pr_debug(" -> %s:%d\n", __func__, __LINE__);
  575. node = of_find_node_by_path("/");
  576. if (node) {
  577. os_area_set_property(node, &property_rtc_diff);
  578. of_node_put(node);
  579. } else
  580. pr_debug("%s:%d of_find_node_by_path failed\n",
  581. __func__, __LINE__);
  582. #if defined(CONFIG_PS3_FLASH) || defined(CONFIG_PS3_FLASH_MODULE)
  583. update_flash_db();
  584. #else
  585. printk(KERN_WARNING "%s:%d: No flash rom driver configured.\n",
  586. __func__, __LINE__);
  587. #endif
  588. pr_debug(" <- %s:%d\n", __func__, __LINE__);
  589. }
  590. static void os_area_queue_work(void)
  591. {
  592. static DECLARE_WORK(q, os_area_queue_work_handler);
  593. wmb();
  594. schedule_work(&q);
  595. }
  596. /**
  597. * ps3_os_area_save_params - Copy data from os area mirror to @saved_params.
  598. *
  599. * For the convenience of the guest the HV makes a copy of the os area in
  600. * flash to a high address in the boot memory region and then puts that RAM
  601. * address and the byte count into the repository for retrieval by the guest.
  602. * We copy the data we want into a static variable and allow the memory setup
  603. * by the HV to be claimed by the lmb manager.
  604. *
  605. * The os area mirror will not be available to a second stage kernel, and
  606. * the header verify will fail. In this case, the saved_params values will
  607. * be set from flash memory or the passed in device tree in ps3_os_area_init().
  608. */
  609. void __init ps3_os_area_save_params(void)
  610. {
  611. int result;
  612. u64 lpar_addr;
  613. unsigned int size;
  614. struct os_area_header *header;
  615. struct os_area_params *params;
  616. struct os_area_db *db;
  617. pr_debug(" -> %s:%d\n", __func__, __LINE__);
  618. result = ps3_repository_read_boot_dat_info(&lpar_addr, &size);
  619. if (result) {
  620. pr_debug("%s:%d ps3_repository_read_boot_dat_info failed\n",
  621. __func__, __LINE__);
  622. return;
  623. }
  624. header = (struct os_area_header *)__va(lpar_addr);
  625. params = (struct os_area_params *)__va(lpar_addr
  626. + OS_AREA_SEGMENT_SIZE);
  627. result = verify_header(header);
  628. if (result) {
  629. /* Second stage kernels exit here. */
  630. pr_debug("%s:%d verify_header failed\n", __func__, __LINE__);
  631. dump_header(header);
  632. return;
  633. }
  634. db = (struct os_area_db *)__va(lpar_addr
  635. + header->db_area_offset * OS_AREA_SEGMENT_SIZE);
  636. dump_header(header);
  637. dump_params(params);
  638. dump_db(db);
  639. result = db_verify(db) || db_get_rtc_diff(db, &saved_params.rtc_diff);
  640. if (result)
  641. saved_params.rtc_diff = params->rtc_diff ? params->rtc_diff
  642. : SECONDS_FROM_1970_TO_2000;
  643. saved_params.av_multi_out = params->av_multi_out;
  644. saved_params.valid = 1;
  645. memset(header, 0, sizeof(*header));
  646. pr_debug(" <- %s:%d\n", __func__, __LINE__);
  647. }
  648. /**
  649. * ps3_os_area_init - Setup os area device tree properties as needed.
  650. */
  651. void __init ps3_os_area_init(void)
  652. {
  653. struct device_node *node;
  654. pr_debug(" -> %s:%d\n", __func__, __LINE__);
  655. node = of_find_node_by_path("/");
  656. if (!saved_params.valid && node) {
  657. /* Second stage kernels should have a dt entry. */
  658. os_area_get_property(node, &property_rtc_diff);
  659. os_area_get_property(node, &property_av_multi_out);
  660. }
  661. if(!saved_params.rtc_diff)
  662. saved_params.rtc_diff = SECONDS_FROM_1970_TO_2000;
  663. if (node) {
  664. os_area_set_property(node, &property_rtc_diff);
  665. os_area_set_property(node, &property_av_multi_out);
  666. of_node_put(node);
  667. } else
  668. pr_debug("%s:%d of_find_node_by_path failed\n",
  669. __func__, __LINE__);
  670. pr_debug(" <- %s:%d\n", __func__, __LINE__);
  671. }
  672. /**
  673. * ps3_os_area_get_rtc_diff - Returns the rtc diff value.
  674. */
  675. u64 ps3_os_area_get_rtc_diff(void)
  676. {
  677. return saved_params.rtc_diff;
  678. }
  679. EXPORT_SYMBOL(ps3_os_area_get_rtc_diff);
  680. /**
  681. * ps3_os_area_set_rtc_diff - Set the rtc diff value.
  682. *
  683. * An asynchronous write is needed to support writing updates from
  684. * the timer interrupt context.
  685. */
  686. void ps3_os_area_set_rtc_diff(u64 rtc_diff)
  687. {
  688. if (saved_params.rtc_diff != rtc_diff) {
  689. saved_params.rtc_diff = rtc_diff;
  690. os_area_queue_work();
  691. }
  692. }
  693. EXPORT_SYMBOL(ps3_os_area_set_rtc_diff);
  694. /**
  695. * ps3_os_area_get_av_multi_out - Returns the default video mode.
  696. */
  697. enum ps3_param_av_multi_out ps3_os_area_get_av_multi_out(void)
  698. {
  699. return saved_params.av_multi_out;
  700. }
  701. EXPORT_SYMBOL_GPL(ps3_os_area_get_av_multi_out);