nvram_64.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742
  1. /*
  2. * c 2001 PPC 64 Team, IBM Corp
  3. *
  4. * This program is free software; you can redistribute it and/or
  5. * modify it under the terms of the GNU General Public License
  6. * as published by the Free Software Foundation; either version
  7. * 2 of the License, or (at your option) any later version.
  8. *
  9. * /dev/nvram driver for PPC64
  10. *
  11. * This perhaps should live in drivers/char
  12. *
  13. * TODO: Split the /dev/nvram part (that one can use
  14. * drivers/char/generic_nvram.c) from the arch & partition
  15. * parsing code.
  16. */
  17. #include <linux/module.h>
  18. #include <linux/types.h>
  19. #include <linux/errno.h>
  20. #include <linux/fs.h>
  21. #include <linux/miscdevice.h>
  22. #include <linux/fcntl.h>
  23. #include <linux/nvram.h>
  24. #include <linux/init.h>
  25. #include <linux/slab.h>
  26. #include <linux/spinlock.h>
  27. #include <asm/uaccess.h>
  28. #include <asm/nvram.h>
  29. #include <asm/rtas.h>
  30. #include <asm/prom.h>
  31. #include <asm/machdep.h>
  32. #undef DEBUG_NVRAM
  33. #define NVRAM_HEADER_LEN sizeof(struct nvram_header)
  34. #define NVRAM_BLOCK_LEN NVRAM_HEADER_LEN
  35. #define NVRAM_MAX_REQ 2079
  36. #define NVRAM_MIN_REQ 1055
  37. /* If change this size, then change the size of NVNAME_LEN */
  38. struct nvram_header {
  39. unsigned char signature;
  40. unsigned char checksum;
  41. unsigned short length;
  42. char name[12];
  43. };
  44. struct nvram_partition {
  45. struct list_head partition;
  46. struct nvram_header header;
  47. unsigned int index;
  48. };
  49. static struct nvram_partition * nvram_part;
  50. static long nvram_error_log_index = -1;
  51. static long nvram_error_log_size = 0;
  52. struct err_log_info {
  53. int error_type;
  54. unsigned int seq_num;
  55. };
  56. static loff_t dev_nvram_llseek(struct file *file, loff_t offset, int origin)
  57. {
  58. int size;
  59. if (ppc_md.nvram_size == NULL)
  60. return -ENODEV;
  61. size = ppc_md.nvram_size();
  62. switch (origin) {
  63. case 1:
  64. offset += file->f_pos;
  65. break;
  66. case 2:
  67. offset += size;
  68. break;
  69. }
  70. if (offset < 0)
  71. return -EINVAL;
  72. file->f_pos = offset;
  73. return file->f_pos;
  74. }
  75. static ssize_t dev_nvram_read(struct file *file, char __user *buf,
  76. size_t count, loff_t *ppos)
  77. {
  78. ssize_t ret;
  79. char *tmp = NULL;
  80. ssize_t size;
  81. ret = -ENODEV;
  82. if (!ppc_md.nvram_size)
  83. goto out;
  84. ret = 0;
  85. size = ppc_md.nvram_size();
  86. if (*ppos >= size || size < 0)
  87. goto out;
  88. count = min_t(size_t, count, size - *ppos);
  89. count = min(count, PAGE_SIZE);
  90. ret = -ENOMEM;
  91. tmp = kmalloc(count, GFP_KERNEL);
  92. if (!tmp)
  93. goto out;
  94. ret = ppc_md.nvram_read(tmp, count, ppos);
  95. if (ret <= 0)
  96. goto out;
  97. if (copy_to_user(buf, tmp, ret))
  98. ret = -EFAULT;
  99. out:
  100. kfree(tmp);
  101. return ret;
  102. }
  103. static ssize_t dev_nvram_write(struct file *file, const char __user *buf,
  104. size_t count, loff_t *ppos)
  105. {
  106. ssize_t ret;
  107. char *tmp = NULL;
  108. ssize_t size;
  109. ret = -ENODEV;
  110. if (!ppc_md.nvram_size)
  111. goto out;
  112. ret = 0;
  113. size = ppc_md.nvram_size();
  114. if (*ppos >= size || size < 0)
  115. goto out;
  116. count = min_t(size_t, count, size - *ppos);
  117. count = min(count, PAGE_SIZE);
  118. ret = -ENOMEM;
  119. tmp = kmalloc(count, GFP_KERNEL);
  120. if (!tmp)
  121. goto out;
  122. ret = -EFAULT;
  123. if (copy_from_user(tmp, buf, count))
  124. goto out;
  125. ret = ppc_md.nvram_write(tmp, count, ppos);
  126. out:
  127. kfree(tmp);
  128. return ret;
  129. }
  130. static long dev_nvram_ioctl(struct file *file, unsigned int cmd,
  131. unsigned long arg)
  132. {
  133. switch(cmd) {
  134. #ifdef CONFIG_PPC_PMAC
  135. case OBSOLETE_PMAC_NVRAM_GET_OFFSET:
  136. printk(KERN_WARNING "nvram: Using obsolete PMAC_NVRAM_GET_OFFSET ioctl\n");
  137. case IOC_NVRAM_GET_OFFSET: {
  138. int part, offset;
  139. if (!machine_is(powermac))
  140. return -EINVAL;
  141. if (copy_from_user(&part, (void __user*)arg, sizeof(part)) != 0)
  142. return -EFAULT;
  143. if (part < pmac_nvram_OF || part > pmac_nvram_NR)
  144. return -EINVAL;
  145. offset = pmac_get_partition(part);
  146. if (offset < 0)
  147. return offset;
  148. if (copy_to_user((void __user*)arg, &offset, sizeof(offset)) != 0)
  149. return -EFAULT;
  150. return 0;
  151. }
  152. #endif /* CONFIG_PPC_PMAC */
  153. default:
  154. return -EINVAL;
  155. }
  156. }
  157. const struct file_operations nvram_fops = {
  158. .owner = THIS_MODULE,
  159. .llseek = dev_nvram_llseek,
  160. .read = dev_nvram_read,
  161. .write = dev_nvram_write,
  162. .unlocked_ioctl = dev_nvram_ioctl,
  163. };
  164. static struct miscdevice nvram_dev = {
  165. NVRAM_MINOR,
  166. "nvram",
  167. &nvram_fops
  168. };
  169. #ifdef DEBUG_NVRAM
  170. static void __init nvram_print_partitions(char * label)
  171. {
  172. struct list_head * p;
  173. struct nvram_partition * tmp_part;
  174. printk(KERN_WARNING "--------%s---------\n", label);
  175. printk(KERN_WARNING "indx\t\tsig\tchks\tlen\tname\n");
  176. list_for_each(p, &nvram_part->partition) {
  177. tmp_part = list_entry(p, struct nvram_partition, partition);
  178. printk(KERN_WARNING "%4d \t%02x\t%02x\t%d\t%s\n",
  179. tmp_part->index, tmp_part->header.signature,
  180. tmp_part->header.checksum, tmp_part->header.length,
  181. tmp_part->header.name);
  182. }
  183. }
  184. #endif
  185. static int __init nvram_write_header(struct nvram_partition * part)
  186. {
  187. loff_t tmp_index;
  188. int rc;
  189. tmp_index = part->index;
  190. rc = ppc_md.nvram_write((char *)&part->header, NVRAM_HEADER_LEN, &tmp_index);
  191. return rc;
  192. }
  193. static unsigned char __init nvram_checksum(struct nvram_header *p)
  194. {
  195. unsigned int c_sum, c_sum2;
  196. unsigned short *sp = (unsigned short *)p->name; /* assume 6 shorts */
  197. c_sum = p->signature + p->length + sp[0] + sp[1] + sp[2] + sp[3] + sp[4] + sp[5];
  198. /* The sum may have spilled into the 3rd byte. Fold it back. */
  199. c_sum = ((c_sum & 0xffff) + (c_sum >> 16)) & 0xffff;
  200. /* The sum cannot exceed 2 bytes. Fold it into a checksum */
  201. c_sum2 = (c_sum >> 8) + (c_sum << 8);
  202. c_sum = ((c_sum + c_sum2) >> 8) & 0xff;
  203. return c_sum;
  204. }
  205. static int __init nvram_remove_os_partition(void)
  206. {
  207. struct list_head *i;
  208. struct list_head *j;
  209. struct nvram_partition * part;
  210. struct nvram_partition * cur_part;
  211. int rc;
  212. list_for_each(i, &nvram_part->partition) {
  213. part = list_entry(i, struct nvram_partition, partition);
  214. if (part->header.signature != NVRAM_SIG_OS)
  215. continue;
  216. /* Make os partition a free partition */
  217. part->header.signature = NVRAM_SIG_FREE;
  218. sprintf(part->header.name, "wwwwwwwwwwww");
  219. part->header.checksum = nvram_checksum(&part->header);
  220. /* Merge contiguous free partitions backwards */
  221. list_for_each_prev(j, &part->partition) {
  222. cur_part = list_entry(j, struct nvram_partition, partition);
  223. if (cur_part == nvram_part || cur_part->header.signature != NVRAM_SIG_FREE) {
  224. break;
  225. }
  226. part->header.length += cur_part->header.length;
  227. part->header.checksum = nvram_checksum(&part->header);
  228. part->index = cur_part->index;
  229. list_del(&cur_part->partition);
  230. kfree(cur_part);
  231. j = &part->partition; /* fixup our loop */
  232. }
  233. /* Merge contiguous free partitions forwards */
  234. list_for_each(j, &part->partition) {
  235. cur_part = list_entry(j, struct nvram_partition, partition);
  236. if (cur_part == nvram_part || cur_part->header.signature != NVRAM_SIG_FREE) {
  237. break;
  238. }
  239. part->header.length += cur_part->header.length;
  240. part->header.checksum = nvram_checksum(&part->header);
  241. list_del(&cur_part->partition);
  242. kfree(cur_part);
  243. j = &part->partition; /* fixup our loop */
  244. }
  245. rc = nvram_write_header(part);
  246. if (rc <= 0) {
  247. printk(KERN_ERR "nvram_remove_os_partition: nvram_write failed (%d)\n", rc);
  248. return rc;
  249. }
  250. }
  251. return 0;
  252. }
  253. /**
  254. * nvram_create_partition - Create a partition in nvram
  255. * @name: name of the partition to create
  256. * @sig: signature of the partition to create
  257. * @req_size: size of data to allocate in bytes
  258. * @min_size: minimum acceptable size (0 means req_size)
  259. */
  260. static int __init nvram_create_partition(const char *name, int sig,
  261. int req_size, int min_size)
  262. {
  263. struct nvram_partition *part;
  264. struct nvram_partition *new_part;
  265. struct nvram_partition *free_part = NULL;
  266. static char nv_init_vals[16];
  267. loff_t tmp_index;
  268. long size = 0;
  269. int rc;
  270. /* Convert sizes from bytes to blocks */
  271. req_size = _ALIGN_UP(req_size, NVRAM_BLOCK_LEN) / NVRAM_BLOCK_LEN;
  272. min_size = _ALIGN_UP(min_size, NVRAM_BLOCK_LEN) / NVRAM_BLOCK_LEN;
  273. /* If no minimum size specified, make it the same as the
  274. * requested size
  275. */
  276. if (min_size == 0)
  277. min_size = req_size;
  278. /* Now add one block to each for the header */
  279. req_size += 1;
  280. min_size += 1;
  281. /* Find a free partition that will give us the maximum needed size
  282. If can't find one that will give us the minimum size needed */
  283. list_for_each_entry(part, &nvram_part->partition, partition) {
  284. if (part->header.signature != NVRAM_SIG_FREE)
  285. continue;
  286. if (part->header.length >= req_size) {
  287. size = req_size;
  288. free_part = part;
  289. break;
  290. }
  291. if (part->header.length > size &&
  292. part->header.length >= min_size) {
  293. size = part->header.length;
  294. free_part = part;
  295. }
  296. }
  297. if (!size)
  298. return -ENOSPC;
  299. /* Create our OS partition */
  300. new_part = kmalloc(sizeof(*new_part), GFP_KERNEL);
  301. if (!new_part) {
  302. printk(KERN_ERR "nvram_create_os_partition: kmalloc failed\n");
  303. return -ENOMEM;
  304. }
  305. new_part->index = free_part->index;
  306. new_part->header.signature = sig;
  307. new_part->header.length = size;
  308. strncpy(new_part->header.name, name, 12);
  309. new_part->header.checksum = nvram_checksum(&new_part->header);
  310. rc = nvram_write_header(new_part);
  311. if (rc <= 0) {
  312. printk(KERN_ERR "nvram_create_os_partition: nvram_write_header "
  313. "failed (%d)\n", rc);
  314. return rc;
  315. }
  316. /* Clear the partition */
  317. for (tmp_index = new_part->index + NVRAM_HEADER_LEN;
  318. tmp_index < ((size - 1) * NVRAM_BLOCK_LEN);
  319. tmp_index += NVRAM_BLOCK_LEN) {
  320. rc = ppc_md.nvram_write(nv_init_vals, NVRAM_BLOCK_LEN, &tmp_index);
  321. if (rc <= 0) {
  322. pr_err("nvram_create_partition: nvram_write failed (%d)\n", rc);
  323. return rc;
  324. }
  325. }
  326. nvram_error_log_index = new_part->index + NVRAM_HEADER_LEN;
  327. nvram_error_log_size = ((part->header.length - 1) *
  328. NVRAM_BLOCK_LEN) - sizeof(struct err_log_info);
  329. list_add_tail(&new_part->partition, &free_part->partition);
  330. if (free_part->header.length <= size) {
  331. list_del(&free_part->partition);
  332. kfree(free_part);
  333. return 0;
  334. }
  335. /* Adjust the partition we stole the space from */
  336. free_part->index += size * NVRAM_BLOCK_LEN;
  337. free_part->header.length -= size;
  338. free_part->header.checksum = nvram_checksum(&free_part->header);
  339. rc = nvram_write_header(free_part);
  340. if (rc <= 0) {
  341. printk(KERN_ERR "nvram_create_os_partition: nvram_write_header "
  342. "failed (%d)\n", rc);
  343. return rc;
  344. }
  345. return 0;
  346. }
  347. /* nvram_setup_partition
  348. *
  349. * This will setup the partition we need for buffering the
  350. * error logs and cleanup partitions if needed.
  351. *
  352. * The general strategy is the following:
  353. * 1.) If there is ppc64,linux partition large enough then use it.
  354. * 2.) If there is not a ppc64,linux partition large enough, search
  355. * for a free partition that is large enough.
  356. * 3.) If there is not a free partition large enough remove
  357. * _all_ OS partitions and consolidate the space.
  358. * 4.) Will first try getting a chunk that will satisfy the maximum
  359. * error log size (NVRAM_MAX_REQ).
  360. * 5.) If the max chunk cannot be allocated then try finding a chunk
  361. * that will satisfy the minum needed (NVRAM_MIN_REQ).
  362. */
  363. static int __init nvram_setup_partition(void)
  364. {
  365. struct list_head * p;
  366. struct nvram_partition * part;
  367. int rc;
  368. /* For now, we don't do any of this on pmac, until I
  369. * have figured out if it's worth killing some unused stuffs
  370. * in our nvram, as Apple defined partitions use pretty much
  371. * all of the space
  372. */
  373. if (machine_is(powermac))
  374. return -ENOSPC;
  375. /* see if we have an OS partition that meets our needs.
  376. will try getting the max we need. If not we'll delete
  377. partitions and try again. */
  378. list_for_each(p, &nvram_part->partition) {
  379. part = list_entry(p, struct nvram_partition, partition);
  380. if (part->header.signature != NVRAM_SIG_OS)
  381. continue;
  382. if (strcmp(part->header.name, "ppc64,linux"))
  383. continue;
  384. if ((part->header.length - 1) * NVRAM_BLOCK_LEN >= NVRAM_MIN_REQ) {
  385. /* found our partition */
  386. nvram_error_log_index = part->index + NVRAM_HEADER_LEN;
  387. nvram_error_log_size = ((part->header.length - 1) *
  388. NVRAM_BLOCK_LEN) - sizeof(struct err_log_info);
  389. return 0;
  390. }
  391. }
  392. /* try creating a partition with the free space we have */
  393. rc = nvram_create_partition("ppc64,linux", NVRAM_SIG_OS,
  394. NVRAM_MAX_REQ, NVRAM_MIN_REQ);
  395. if (!rc)
  396. return 0;
  397. /* need to free up some space */
  398. rc = nvram_remove_os_partition();
  399. if (rc) {
  400. return rc;
  401. }
  402. /* create a partition in this new space */
  403. rc = nvram_create_partition("ppc64,linux", NVRAM_SIG_OS,
  404. NVRAM_MAX_REQ, NVRAM_MIN_REQ);
  405. if (rc) {
  406. printk(KERN_ERR "nvram_create_partition: Could not find a "
  407. "NVRAM partition large enough\n");
  408. return rc;
  409. }
  410. return 0;
  411. }
  412. static int __init nvram_scan_partitions(void)
  413. {
  414. loff_t cur_index = 0;
  415. struct nvram_header phead;
  416. struct nvram_partition * tmp_part;
  417. unsigned char c_sum;
  418. char * header;
  419. int total_size;
  420. int err;
  421. if (ppc_md.nvram_size == NULL)
  422. return -ENODEV;
  423. total_size = ppc_md.nvram_size();
  424. header = kmalloc(NVRAM_HEADER_LEN, GFP_KERNEL);
  425. if (!header) {
  426. printk(KERN_ERR "nvram_scan_partitions: Failed kmalloc\n");
  427. return -ENOMEM;
  428. }
  429. while (cur_index < total_size) {
  430. err = ppc_md.nvram_read(header, NVRAM_HEADER_LEN, &cur_index);
  431. if (err != NVRAM_HEADER_LEN) {
  432. printk(KERN_ERR "nvram_scan_partitions: Error parsing "
  433. "nvram partitions\n");
  434. goto out;
  435. }
  436. cur_index -= NVRAM_HEADER_LEN; /* nvram_read will advance us */
  437. memcpy(&phead, header, NVRAM_HEADER_LEN);
  438. err = 0;
  439. c_sum = nvram_checksum(&phead);
  440. if (c_sum != phead.checksum) {
  441. printk(KERN_WARNING "WARNING: nvram partition checksum"
  442. " was %02x, should be %02x!\n",
  443. phead.checksum, c_sum);
  444. printk(KERN_WARNING "Terminating nvram partition scan\n");
  445. goto out;
  446. }
  447. if (!phead.length) {
  448. printk(KERN_WARNING "WARNING: nvram corruption "
  449. "detected: 0-length partition\n");
  450. goto out;
  451. }
  452. tmp_part = (struct nvram_partition *)
  453. kmalloc(sizeof(struct nvram_partition), GFP_KERNEL);
  454. err = -ENOMEM;
  455. if (!tmp_part) {
  456. printk(KERN_ERR "nvram_scan_partitions: kmalloc failed\n");
  457. goto out;
  458. }
  459. memcpy(&tmp_part->header, &phead, NVRAM_HEADER_LEN);
  460. tmp_part->index = cur_index;
  461. list_add_tail(&tmp_part->partition, &nvram_part->partition);
  462. cur_index += phead.length * NVRAM_BLOCK_LEN;
  463. }
  464. err = 0;
  465. out:
  466. kfree(header);
  467. return err;
  468. }
  469. static int __init nvram_init(void)
  470. {
  471. int error;
  472. int rc;
  473. BUILD_BUG_ON(NVRAM_BLOCK_LEN != 16);
  474. if (ppc_md.nvram_size == NULL || ppc_md.nvram_size() <= 0)
  475. return -ENODEV;
  476. rc = misc_register(&nvram_dev);
  477. if (rc != 0) {
  478. printk(KERN_ERR "nvram_init: failed to register device\n");
  479. return rc;
  480. }
  481. /* initialize our anchor for the nvram partition list */
  482. nvram_part = kmalloc(sizeof(struct nvram_partition), GFP_KERNEL);
  483. if (!nvram_part) {
  484. printk(KERN_ERR "nvram_init: Failed kmalloc\n");
  485. return -ENOMEM;
  486. }
  487. INIT_LIST_HEAD(&nvram_part->partition);
  488. /* Get all the NVRAM partitions */
  489. error = nvram_scan_partitions();
  490. if (error) {
  491. printk(KERN_ERR "nvram_init: Failed nvram_scan_partitions\n");
  492. return error;
  493. }
  494. if(nvram_setup_partition())
  495. printk(KERN_WARNING "nvram_init: Could not find nvram partition"
  496. " for nvram buffered error logging.\n");
  497. #ifdef DEBUG_NVRAM
  498. nvram_print_partitions("NVRAM Partitions");
  499. #endif
  500. return rc;
  501. }
  502. void __exit nvram_cleanup(void)
  503. {
  504. misc_deregister( &nvram_dev );
  505. }
  506. #ifdef CONFIG_PPC_PSERIES
  507. /* nvram_write_error_log
  508. *
  509. * We need to buffer the error logs into nvram to ensure that we have
  510. * the failure information to decode. If we have a severe error there
  511. * is no way to guarantee that the OS or the machine is in a state to
  512. * get back to user land and write the error to disk. For example if
  513. * the SCSI device driver causes a Machine Check by writing to a bad
  514. * IO address, there is no way of guaranteeing that the device driver
  515. * is in any state that is would also be able to write the error data
  516. * captured to disk, thus we buffer it in NVRAM for analysis on the
  517. * next boot.
  518. *
  519. * In NVRAM the partition containing the error log buffer will looks like:
  520. * Header (in bytes):
  521. * +-----------+----------+--------+------------+------------------+
  522. * | signature | checksum | length | name | data |
  523. * |0 |1 |2 3|4 15|16 length-1|
  524. * +-----------+----------+--------+------------+------------------+
  525. *
  526. * The 'data' section would look like (in bytes):
  527. * +--------------+------------+-----------------------------------+
  528. * | event_logged | sequence # | error log |
  529. * |0 3|4 7|8 nvram_error_log_size-1|
  530. * +--------------+------------+-----------------------------------+
  531. *
  532. * event_logged: 0 if event has not been logged to syslog, 1 if it has
  533. * sequence #: The unique sequence # for each event. (until it wraps)
  534. * error log: The error log from event_scan
  535. */
  536. int nvram_write_error_log(char * buff, int length,
  537. unsigned int err_type, unsigned int error_log_cnt)
  538. {
  539. int rc;
  540. loff_t tmp_index;
  541. struct err_log_info info;
  542. if (nvram_error_log_index == -1) {
  543. return -ESPIPE;
  544. }
  545. if (length > nvram_error_log_size) {
  546. length = nvram_error_log_size;
  547. }
  548. info.error_type = err_type;
  549. info.seq_num = error_log_cnt;
  550. tmp_index = nvram_error_log_index;
  551. rc = ppc_md.nvram_write((char *)&info, sizeof(struct err_log_info), &tmp_index);
  552. if (rc <= 0) {
  553. printk(KERN_ERR "nvram_write_error_log: Failed nvram_write (%d)\n", rc);
  554. return rc;
  555. }
  556. rc = ppc_md.nvram_write(buff, length, &tmp_index);
  557. if (rc <= 0) {
  558. printk(KERN_ERR "nvram_write_error_log: Failed nvram_write (%d)\n", rc);
  559. return rc;
  560. }
  561. return 0;
  562. }
  563. /* nvram_read_error_log
  564. *
  565. * Reads nvram for error log for at most 'length'
  566. */
  567. int nvram_read_error_log(char * buff, int length,
  568. unsigned int * err_type, unsigned int * error_log_cnt)
  569. {
  570. int rc;
  571. loff_t tmp_index;
  572. struct err_log_info info;
  573. if (nvram_error_log_index == -1)
  574. return -1;
  575. if (length > nvram_error_log_size)
  576. length = nvram_error_log_size;
  577. tmp_index = nvram_error_log_index;
  578. rc = ppc_md.nvram_read((char *)&info, sizeof(struct err_log_info), &tmp_index);
  579. if (rc <= 0) {
  580. printk(KERN_ERR "nvram_read_error_log: Failed nvram_read (%d)\n", rc);
  581. return rc;
  582. }
  583. rc = ppc_md.nvram_read(buff, length, &tmp_index);
  584. if (rc <= 0) {
  585. printk(KERN_ERR "nvram_read_error_log: Failed nvram_read (%d)\n", rc);
  586. return rc;
  587. }
  588. *error_log_cnt = info.seq_num;
  589. *err_type = info.error_type;
  590. return 0;
  591. }
  592. /* This doesn't actually zero anything, but it sets the event_logged
  593. * word to tell that this event is safely in syslog.
  594. */
  595. int nvram_clear_error_log(void)
  596. {
  597. loff_t tmp_index;
  598. int clear_word = ERR_FLAG_ALREADY_LOGGED;
  599. int rc;
  600. if (nvram_error_log_index == -1)
  601. return -1;
  602. tmp_index = nvram_error_log_index;
  603. rc = ppc_md.nvram_write((char *)&clear_word, sizeof(int), &tmp_index);
  604. if (rc <= 0) {
  605. printk(KERN_ERR "nvram_clear_error_log: Failed nvram_write (%d)\n", rc);
  606. return rc;
  607. }
  608. return 0;
  609. }
  610. #endif /* CONFIG_PPC_PSERIES */
  611. module_init(nvram_init);
  612. module_exit(nvram_cleanup);
  613. MODULE_LICENSE("GPL");