API tools faq
paste
Advertisement
Guest User

x210 ec_sys patch

a guest
Sep 1st, 2019
458
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 14.66 KB | None | 0 0
raw download clone embed print report
  1. --- a/drivers/acpi/ec_sys.c 2019-03-04 02:21:29.000000000 +0300
  2. +++ b/drivers/acpi/ec_sys.c 2019-09-01 01:04:13.527773200 +0300
  3. @@ -13,6 +13,7 @@
  4. #include <linux/debugfs.h>
  5. #include <linux/module.h>
  6. #include <linux/uaccess.h>
  7. +#include <linux/delay.h>
  8. #include "internal.h"
  9.  
  10. MODULE_AUTHOR("Thomas Renninger <trenn@suse.de>");
  11. @@ -108,6 +109,712 @@
  12. .llseek = default_llseek,
  13. };
  14.  
  15. +
  16. +#define ACPI_EC_FLAG_OBF 0x01 /* Output buffer full */
  17. +#define ACPI_EC_FLAG_IBF 0x02 /* Input buffer full */
  18. +#define ACPI_EC_FLAG_CMD 0x08 /* Input buffer contains a command */
  19. +#define ACPI_EC_FLAG_BURST 0x10 /* burst mode */
  20. +#define ACPI_EC_FLAG_SCI 0x20 /* EC-SCI occurred */
  21. +
  22. +int ec_wr_cmd(struct acpi_ec *ec,u8 cmd,u8 * st)
  23. +{
  24. + u8 s=0;
  25. + u32 k;
  26. +
  27. + for(k=0;k<65535;k++)
  28. + {
  29. + s = inb(ec->command_addr);
  30. + if(!(s&ACPI_EC_FLAG_IBF))
  31. + {
  32. + outb(cmd, ec->command_addr);
  33. + if(st != NULL)
  34. + *st=s;
  35. +// printk("ec cmd=%02x k=%d ps=%02x s=%02x\n",cmd,k,s,inb(ec->command_addr));
  36. + return 0;
  37. + }
  38. + usleep_range(1,5);
  39. + }
  40. + if(st != NULL)
  41. + *st=s;
  42. + printk("!ec cmd=%02x\n",cmd);
  43. + return -ETIME;
  44. +
  45. +
  46. +}
  47. +
  48. +int ec_wr_data(struct acpi_ec *ec,u8 data, u8 * st)
  49. +{
  50. + u8 s=0;
  51. + u32 k;
  52. +
  53. + for(k=0;k<65535;k++)
  54. + {
  55. + s = inb(ec->command_addr);
  56. + if(!(s&ACPI_EC_FLAG_IBF))
  57. + {
  58. + outb(data, ec->data_addr);
  59. + if(st != NULL)
  60. + *st=s;
  61. +// printk("ec out=%02x k=%d ps=%02x s=%02x\n",data,k,s,inb(ec->command_addr));
  62. + return 0;
  63. + }
  64. + usleep_range(1,5);
  65. + }
  66. + if(st != NULL)
  67. + *st=s;
  68. + printk("!ec out=%02x\n",data);
  69. + return -ETIME;
  70. +
  71. +
  72. +}
  73. +
  74. +int ec_rd_data(struct acpi_ec *ec,u8 * data, u8 *st)
  75. +{
  76. + u8 s=0,os=0;
  77. + u32 k;
  78. + if(data != NULL)
  79. + {
  80. + for(k=0;k<65536;k++)
  81. + {
  82. + s = inb(ec->command_addr);
  83. + if(os!=s)
  84. + {
  85. +// printk("s=%02x=>%02x\n",os,s);
  86. + os=s;
  87. + }
  88. + if(st != NULL)
  89. + *st=s;
  90. + if(s&ACPI_EC_FLAG_IBF)
  91. + {
  92. + usleep_range(1,5);
  93. + continue;
  94. + }
  95. + if(s&ACPI_EC_FLAG_OBF)
  96. + {
  97. + *data=inb(ec->data_addr);
  98. + return 0;
  99. + }
  100. + usleep_range(1,5);
  101. + }
  102. + printk("RDDATA TIMEO s=%02x\n",s);
  103. + *data=inb(ec->data_addr);
  104. + if(st != NULL)
  105. + *st=s;
  106. + }
  107. + return 0;
  108. + return -ETIME;
  109. +
  110. +
  111. +}
  112. +
  113. +int ec_flush(struct acpi_ec *ec)
  114. +{
  115. + u8 s=0;
  116. + u32 k;
  117. + u8 err=0;
  118. + for(k=0;k<65535;k++)
  119. + {
  120. + s = inb(ec->command_addr);
  121. + if(!(s&ACPI_EC_FLAG_SCI))
  122. + {
  123. + return 0;
  124. + }
  125. + if(!err)
  126. + err=ec_wr_cmd(ec,0x84,NULL);
  127. + if(!err)
  128. + err=ec_rd_data(ec,&s,NULL);
  129. + if(err)
  130. + return err;
  131. +// printk("GPE=%02x\n",s);
  132. + }
  133. + return -ETIME;
  134. +}
  135. +
  136. +int ec_get_sci(struct acpi_ec *ec)
  137. +{
  138. + u8 s=0;
  139. + u32 k;
  140. + u8 err=0;
  141. + for(k=0;k<65535;k++)
  142. + {
  143. + s = inb(ec->command_addr);
  144. + if(s&ACPI_EC_FLAG_SCI)
  145. + {
  146. + if(!err)
  147. + err=ec_wr_cmd(ec,0x84,NULL);
  148. + if(!err)
  149. + err=ec_rd_data(ec,&s,NULL);
  150. + if(err)
  151. + return err;
  152. + return s;
  153. +// printk("GPE=%02x\n",s);
  154. + }
  155. + usleep_range(10,50);
  156. + }
  157. + return -ETIME;
  158. +}
  159. +
  160. +
  161. +#define EC_RAM_SIZE 0x01000000
  162. +#define EC_GPIO_SIZE 0x0100
  163. +
  164. +
  165. +
  166. +int ec_read_gpio(u32 addr, u8 *val)
  167. +{
  168. + int err=0;
  169. + u8 ob;
  170. + u8 stat,d;
  171. + struct acpi_ec *ec=first_ec;
  172. +
  173. + ob=(addr)&0xff;
  174. +
  175. +
  176. + mutex_lock(&ec->mutex);
  177. + if(!err)
  178. + err=ec_wr_cmd(ec,0x82,&stat);
  179. + if(!err)
  180. + err=ec_rd_data(ec,&d,&stat);
  181. +// printk("v=%02x\n",d);
  182. + if(!err)
  183. + err=ec_flush(ec);
  184. +
  185. +
  186. + if(!err)
  187. + err=ec_wr_cmd(ec,0xba,&stat);
  188. + if(!err)
  189. + err=ec_wr_data(ec,ob,&stat);
  190. + if(!err)
  191. + err=ec_rd_data(ec,val,&stat);
  192. +
  193. +
  194. +// printk("s=%02x\n",stat);
  195. + if(!err)
  196. + err=ec_wr_cmd(ec,0x83,&stat);
  197. +
  198. + mutex_unlock(&ec->mutex);
  199. +
  200. + return err;
  201. +}
  202. +
  203. +int ec_write_gpio(u32 addr, u8 val)
  204. +{
  205. + int err=0;
  206. + u8 ob;
  207. + u8 stat,d;
  208. + struct acpi_ec *ec=first_ec;
  209. +
  210. + ob=(addr)&0xff;
  211. + if (!write_support)
  212. + return -EINVAL;
  213. +
  214. +
  215. + mutex_lock(&ec->mutex);
  216. + if(!err)
  217. + err=ec_wr_cmd(ec,0x82,&stat);
  218. + if(!err)
  219. + err=ec_rd_data(ec,&d,&stat);
  220. +// printk("v=%02x\n",d);
  221. + if(!err)
  222. + err=ec_flush(ec);
  223. +
  224. +
  225. + if(!err)
  226. + err=ec_wr_cmd(ec,0xb9,&stat);
  227. + if(!err)
  228. + err=ec_wr_data(ec,val,&stat);
  229. +
  230. +
  231. +// printk("s=%02x\n",stat);
  232. + if(!err)
  233. + err=ec_wr_cmd(ec,0x83,&stat);
  234. +
  235. + mutex_unlock(&ec->mutex);
  236. +
  237. + return err;
  238. +}
  239. +
  240. +int ec_read_ram(u32 addr, u8 *val)
  241. +{
  242. + int err=0;
  243. + u8 ob[4];
  244. + u8 stat,d;
  245. + struct acpi_ec *ec=first_ec;
  246. +
  247. + ob[0]=(addr >>16)&0xff;
  248. + ob[1]=(addr >>8)&0xff;
  249. + ob[2]=(addr)&0xff;
  250. + ob[3]=0;
  251. +
  252. +
  253. + mutex_lock(&ec->mutex);
  254. +
  255. +
  256. + if(!err)
  257. + err=ec_wr_cmd(ec,0x82,&stat);
  258. + if(!err)
  259. + err=ec_rd_data(ec,&d,&stat);
  260. +// printk("v=%02x\n",d);
  261. + if(!err)
  262. + err=ec_flush(ec);
  263. +
  264. +
  265. + if(!err)
  266. + err=ec_wr_cmd(ec,0xbf,&stat);
  267. + if(!err)
  268. + err=ec_wr_data(ec,ob[0],&stat);
  269. + if(!err)
  270. + err=ec_wr_data(ec,ob[1],&stat);
  271. + if(!err)
  272. + err=ec_wr_data(ec,ob[2],&stat);
  273. + if(!err)
  274. + err=ec_rd_data(ec,val,&stat);
  275. +
  276. +
  277. +// printk("s=%02x\n",stat);
  278. + if(!err)
  279. + err=ec_wr_cmd(ec,0x83,&stat);
  280. +
  281. + mutex_unlock(&ec->mutex);
  282. +
  283. + return err;
  284. +}
  285. +
  286. +static int ec_write_ram(u32 addr, u8 val)
  287. +{
  288. + int err=0;
  289. + u8 ob[4];
  290. + u8 stat,d;
  291. + struct acpi_ec *ec=first_ec;
  292. + if (!write_support)
  293. + return -EINVAL;
  294. +
  295. + ob[0]=(addr >>16)&0xff;
  296. + ob[1]=(addr >>8)&0xff;
  297. + ob[2]=(addr)&0xff;
  298. + ob[3]=val;
  299. +
  300. + if(!err)
  301. + err=ec_wr_cmd(ec,0x82,&stat);
  302. + if(!err)
  303. + err=ec_rd_data(ec,&d,&stat);
  304. +// printk("v=%02x\n",d);
  305. + if(!err)
  306. + err=ec_flush(ec);
  307. +
  308. +
  309. + if(!err)
  310. + err=ec_wr_cmd(ec,0xbe,&stat);
  311. + if(!err)
  312. + err=ec_wr_data(ec,ob[0],&stat);
  313. + if(!err)
  314. + err=ec_wr_data(ec,ob[1],&stat);
  315. + if(!err)
  316. + err=ec_wr_data(ec,ob[2],&stat);
  317. + if(!err)
  318. + err=ec_wr_data(ec,ob[3],&stat);
  319. +
  320. +
  321. +// printk("s=%02x\n",stat);
  322. + if(!err)
  323. + err=ec_wr_cmd(ec,0x83,&stat);
  324. +
  325. + mutex_unlock(&ec->mutex);
  326. +
  327. + return err;
  328. +}
  329. +
  330. +int ec_read_ram_word(u32 addr, u8 *val)
  331. +{
  332. + int err=0;
  333. + u8 ob[4];
  334. + u8 stat,d;
  335. + struct acpi_ec *ec=first_ec;
  336. + if(addr&1)
  337. + return -EINVAL;
  338. + ob[0]=(addr >>16)&0xff;
  339. + ob[1]=(addr >>8)&0xff;
  340. + ob[2]=(addr)&0xff;
  341. + ob[3]=0;
  342. +
  343. +
  344. + mutex_lock(&ec->mutex);
  345. +
  346. +
  347. + if(!err)
  348. + err=ec_wr_cmd(ec,0x82,&stat);
  349. + if(!err)
  350. + err=ec_rd_data(ec,&d,&stat);
  351. +// printk("v=%02x\n",d);
  352. + if(!err)
  353. + err=ec_flush(ec);
  354. +
  355. +
  356. + if(!err)
  357. + err=ec_wr_cmd(ec,0xb8,&stat);
  358. + if(!err)
  359. + err=ec_wr_data(ec,ob[0],&stat);
  360. + if(!err)
  361. + err=ec_wr_data(ec,ob[1],&stat);
  362. + if(!err)
  363. + err=ec_wr_data(ec,ob[2],&stat);
  364. + if(!err)
  365. + err=ec_wr_data(ec,ob[3],&stat);
  366. + if(!err)
  367. + err=ec_rd_data(ec,val,&stat);
  368. +
  369. + ob[3]=2;
  370. + if(!err)
  371. + err=ec_wr_cmd(ec,0xb8,&stat);
  372. + if(!err)
  373. + err=ec_wr_data(ec,ob[0],&stat);
  374. + if(!err)
  375. + err=ec_wr_data(ec,ob[1],&stat);
  376. + if(!err)
  377. + err=ec_wr_data(ec,ob[2],&stat);
  378. + if(!err)
  379. + err=ec_wr_data(ec,ob[3],&stat);
  380. + if(!err)
  381. + err=ec_rd_data(ec,&val[1],&stat);
  382. +
  383. +// printk("s=%02x\n",stat);
  384. + if(!err)
  385. + err=ec_wr_cmd(ec,0x83,&stat);
  386. +
  387. + mutex_unlock(&ec->mutex);
  388. +
  389. + return err;
  390. +}
  391. +
  392. +static int ec_write_ram_word(u32 addr, u16 val)
  393. +{
  394. + int err=0;
  395. + u8 ob[5];
  396. + u8 stat,d;
  397. + struct acpi_ec *ec=first_ec;
  398. + if (!write_support)
  399. + return -EINVAL;
  400. + if(addr&1)
  401. + return -EINVAL;
  402. +
  403. + ob[0]=(addr >>16)&0xff;
  404. + ob[1]=(addr >>8)&0xff;
  405. + ob[2]=(addr)&0xff;
  406. + ob[3]=val&0xff;
  407. + ob[4]=val>>8;
  408. +
  409. + if(!err)
  410. + err=ec_wr_cmd(ec,0x82,&stat);
  411. + if(!err)
  412. + err=ec_rd_data(ec,&d,&stat);
  413. +// printk("v=%02x\n",d);
  414. + if(!err)
  415. + err=ec_flush(ec);
  416. +
  417. +
  418. + if(!err)
  419. + err=ec_wr_cmd(ec,0xb7,&stat);
  420. + if(!err)
  421. + err=ec_wr_data(ec,ob[0],&stat);
  422. + if(!err)
  423. + err=ec_wr_data(ec,ob[1],&stat);
  424. + if(!err)
  425. + err=ec_wr_data(ec,ob[2],&stat);
  426. + if(!err)
  427. + err=ec_wr_data(ec,ob[3],&stat);
  428. + if(!err)
  429. + err=ec_wr_data(ec,ob[4],&stat);
  430. +
  431. +
  432. +// printk("s=%02x\n",stat);
  433. + if(!err)
  434. + err=ec_wr_cmd(ec,0x83,&stat);
  435. +
  436. + mutex_unlock(&ec->mutex);
  437. +
  438. + return err;
  439. +}
  440. +
  441. +static ssize_t acpi_ec_read_ram(struct file *f, char __user *buf,
  442. + size_t count, loff_t *off)
  443. +{
  444. + /* Use this if support reading/writing multiple ECs exists in ec.c:
  445. + * struct acpi_ec *ec = ((struct seq_file *)f->private_data)->private;
  446. + */
  447. + unsigned int size = EC_RAM_SIZE;
  448. + loff_t init_off = *off;
  449. + int err = 0;
  450. + u8 byte_read[2];
  451. +
  452. + if (*off >= size)
  453. + return 0;
  454. + if (*off + count >= size) {
  455. + size -= *off;
  456. + count = size;
  457. + } else
  458. + size = count;
  459. + if((*off & 1)||(size&1))
  460. + while (size) {
  461. + err = ec_read_ram(*off, byte_read);
  462. + if (err)
  463. + return err;
  464. + if (put_user(byte_read[0], buf + *off - init_off)) {
  465. + if (*off - init_off)
  466. + return *off - init_off; /* partial read */
  467. + return -EFAULT;
  468. + }
  469. + *off += 1;
  470. + size--;
  471. + }
  472. + else
  473. + while (size) {
  474. + err = ec_read_ram_word(*off, byte_read);
  475. + if (err)
  476. + return err;
  477. + if (put_user(byte_read[0], buf + *off - init_off)) {
  478. + if (*off - init_off)
  479. + return *off - init_off; // partial read
  480. + return -EFAULT;
  481. + }
  482. + *off += 1;
  483. + size--;
  484. + if (put_user(byte_read[1], buf + *off - init_off)) {
  485. + if (*off - init_off)
  486. + return *off - init_off; // partial read
  487. + return -EFAULT;
  488. + }
  489. + *off += 1;
  490. + size--;
  491. + }
  492. +
  493. + return count;
  494. +}
  495. +
  496. +static ssize_t acpi_ec_write_ram(struct file *f, const char __user *buf,
  497. + size_t count, loff_t *off)
  498. +{
  499. + /* Use this if support reading/writing multiple ECs exists in ec.c:
  500. + * struct acpi_ec *ec = ((struct seq_file *)f->private_data)->private;
  501. + */
  502. +
  503. + unsigned int size = count;
  504. + loff_t init_off = *off;
  505. + int err = 0;
  506. +
  507. + if (!write_support)
  508. + return -EINVAL;
  509. +
  510. + if (*off >= EC_RAM_SIZE)
  511. + return 0;
  512. + if (*off + count >= EC_RAM_SIZE) {
  513. + size = EC_RAM_SIZE - *off;
  514. + count = size;
  515. + }
  516. +
  517. + if((*off & 1)||(size&1))
  518. + while (size) {
  519. + u8 byte_write;
  520. + if (get_user(byte_write, buf + *off - init_off)) {
  521. + if (*off - init_off)
  522. + return *off - init_off; /* partial write */
  523. + return -EFAULT;
  524. + }
  525. + err = ec_write_ram(*off, byte_write);
  526. + err=0;
  527. + if (err)
  528. + return err;
  529. +
  530. + *off += 1;
  531. + size--;
  532. + }
  533. + else
  534. + while (size) {
  535. + u8 byte_write[2];
  536. + if (get_user(byte_write[0], buf + *off - init_off)) {
  537. + if (*off - init_off)
  538. + return *off - init_off; /* partial write */
  539. + return -EFAULT;
  540. + }
  541. + if (get_user(byte_write[1], buf + *off - init_off+1)) {
  542. + if (*off - init_off)
  543. + return *off - init_off; /* partial write */
  544. + return -EFAULT;
  545. + }
  546. + err = ec_write_ram_word(*off, *(u16*)byte_write);
  547. + err=0;
  548. + if (err)
  549. + return err;
  550. +
  551. + *off += 2;
  552. + size-=2;
  553. + }
  554. + return count;
  555. +}
  556. +
  557. +static ssize_t acpi_ec_read_gpio(struct file *f, char __user *buf,
  558. + size_t count, loff_t *off)
  559. +{
  560. + /* Use this if support reading/writing multiple ECs exists in ec.c:
  561. + * struct acpi_ec *ec = ((struct seq_file *)f->private_data)->private;
  562. + */
  563. + unsigned int size = EC_GPIO_SIZE;
  564. + loff_t init_off = *off;
  565. + int err = 0;
  566. +
  567. + if (*off >= size)
  568. + return 0;
  569. + if (*off + count >= size) {
  570. + size -= *off;
  571. + count = size;
  572. + } else
  573. + size = count;
  574. +
  575. + while (size) {
  576. + u8 byte_read;
  577. + err = ec_read_gpio(*off, &byte_read);
  578. + if (err)
  579. + return err;
  580. + if (put_user(byte_read, buf + *off - init_off)) {
  581. + if (*off - init_off)
  582. + return *off - init_off; /* partial read */
  583. + return -EFAULT;
  584. + }
  585. + *off += 1;
  586. + size--;
  587. + }
  588. + return count;
  589. +}
  590. +
  591. +static ssize_t acpi_ec_write_gpio(struct file *f, const char __user *buf,
  592. + size_t count, loff_t *off)
  593. +{
  594. + /* Use this if support reading/writing multiple ECs exists in ec.c:
  595. + * struct acpi_ec *ec = ((struct seq_file *)f->private_data)->private;
  596. + */
  597. +
  598. + unsigned int size = count;
  599. + loff_t init_off = *off;
  600. + int err = 0;
  601. +
  602. + if (!write_support)
  603. + return -EINVAL;
  604. +
  605. + if (*off >= EC_GPIO_SIZE)
  606. + return 0;
  607. + if (*off + count >= EC_GPIO_SIZE) {
  608. + size = EC_GPIO_SIZE - *off;
  609. + count = size;
  610. + }
  611. +
  612. + while (size) {
  613. + u8 byte_write;
  614. + if (get_user(byte_write, buf + *off - init_off)) {
  615. + if (*off - init_off)
  616. + return *off - init_off; /* partial write */
  617. + return -EFAULT;
  618. + }
  619. + err = ec_write_gpio(*off, byte_write);
  620. + err=0;
  621. + if (err)
  622. + return err;
  623. +
  624. + *off += 1;
  625. + size--;
  626. + }
  627. + return count;
  628. +}
  629. +
  630. +static const struct file_operations acpi_ec_ram_ops = {
  631. + .owner = THIS_MODULE,
  632. + .open = simple_open,
  633. + .read = acpi_ec_read_ram,
  634. + .write = acpi_ec_write_ram,
  635. + .llseek = default_llseek,
  636. +};
  637. +
  638. +static const struct file_operations acpi_ec_gpio_ops = {
  639. + .owner = THIS_MODULE,
  640. + .open = simple_open,
  641. + .read = acpi_ec_read_gpio,
  642. + .write = acpi_ec_write_gpio,
  643. + .llseek = default_llseek,
  644. +};
  645. +
  646. +
  647. +
  648. +
  649. +static ssize_t acpi_ec_read_sci(struct file *f, char __user *buf,
  650. + size_t count, loff_t *off)
  651. +{
  652. + /* Use this if support reading/writing multiple ECs exists in ec.c:
  653. + * struct acpi_ec *ec = ((struct seq_file *)f->private_data)->private;
  654. + */
  655. + unsigned int size = count;
  656. + loff_t init_off = *off;
  657. + int err=0;
  658. + struct acpi_ec *ec=first_ec;
  659. +
  660. + mutex_lock(&ec->mutex);
  661. +/* if(!err)
  662. + err=ec_wr_cmd(ec,0x82,&stat);
  663. + if(!err)
  664. + err=ec_rd_data(ec,&d,&stat);*/
  665. +
  666. + while (size) {
  667. + err = ec_get_sci(ec);
  668. + if (err<0)
  669. + {
  670. + mutex_unlock(&ec->mutex);
  671. + return err;
  672. + }
  673. + if (put_user(err, buf + *off - init_off)) {
  674. + mutex_unlock(&ec->mutex);
  675. + if (*off - init_off)
  676. + return *off - init_off; /* partial read */
  677. + return -EFAULT;
  678. + }
  679. + *off += 1;
  680. + size--;
  681. + }
  682. +
  683. +/* if(!err)
  684. + err=ec_wr_cmd(ec,0x83,&stat);*/
  685. +
  686. + mutex_unlock(&ec->mutex);
  687. +
  688. + return count;
  689. +}
  690. +
  691. +static ssize_t acpi_ec_write_sci(struct file *f, const char __user *buf,
  692. + size_t count, loff_t *off)
  693. +{
  694. + /* Use this if support reading/writing multiple ECs exists in ec.c:
  695. + * struct acpi_ec *ec = ((struct seq_file *)f->private_data)->private;
  696. + */
  697. +
  698. + return -EINVAL;
  699. +
  700. +}
  701. +
  702. +
  703. +static const struct file_operations acpi_ec_sci_ops = {
  704. + .owner = THIS_MODULE,
  705. + .open = simple_open,
  706. + .read = acpi_ec_read_sci,
  707. + .write = acpi_ec_write_sci,
  708. + .llseek = default_llseek,
  709. +};
  710. +
  711. +
  712. +
  713. +
  714. +
  715. +
  716. +
  717. +
  718. +
  719. +
  720. +
  721. static int acpi_ec_add_debugfs(struct acpi_ec *ec, unsigned int ec_device_count)
  722. {
  723. struct dentry *dev_dir;
  724. @@ -136,7 +843,13 @@
  725.  
  726. if (write_support)
  727. mode = 0600;
  728. - if (!debugfs_create_file("io", mode, dev_dir, ec, &acpi_ec_io_ops))
  729. + if (!debugfs_create_file_size("io", mode, dev_dir, ec, &acpi_ec_io_ops,EC_SPACE_SIZE))
  730. + goto error;
  731. + if (!debugfs_create_file("sci", mode, dev_dir, ec, &acpi_ec_sci_ops))
  732. + goto error;
  733. + if (!debugfs_create_file_size("ram", mode, dev_dir, ec, &acpi_ec_ram_ops,EC_RAM_SIZE))
  734. + goto error;
  735. + if (!debugfs_create_file_size("gpio", mode, dev_dir, ec, &acpi_ec_gpio_ops,EC_GPIO_SIZE))
  736. goto error;
  737.  
  738. return 0;
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!