开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ide-proc.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：27k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

ide-proc.c：源码内容
  1. /*
  2.  *  linux/drivers/ide/ide-proc.c Version 1.03 January  2, 1998
  3.  *
  4.  *  Copyright (C) 1997-1998 Mark Lord
  5.  */
  7. /*
  8.  * This is the /proc/ide/ filesystem implementation.
  9.  *
  10.  * The major reason this exists is to provide sufficient access
  11.  * to driver and config data, such that user-mode programs can
  12.  * be developed to handle chipset tuning for most PCI interfaces.
  13.  * This should provide better utilities, and less kernel bloat.
  14.  *
  15.  * The entire pci config space for a PCI interface chipset can be
  16.  * retrieved by just reading it.  e.g.    "cat /proc/ide3/config"
  17.  *
  18.  * To modify registers *safely*, do something like:
  19.  *   echo "P40:88" >/proc/ide/ide3/config
  20.  * That expression writes 0x88 to pci config register 0x40
  21.  * on the chip which controls ide3.  Multiple tuples can be issued,
  22.  * and the writes will be completed as an atomic set:
  23.  *   echo "P40:88 P41:35 P42:00 P43:00" >/proc/ide/ide3/config
  24.  *
  25.  * All numbers must be specified using pairs of ascii hex digits.
  26.  * It is important to note that these writes will be performed
  27.  * after waiting for the IDE controller (both interfaces)
  28.  * to be completely idle, to ensure no corruption of I/O in progress.
  29.  *
  30.  * Non-PCI registers can also be written, using "R" in place of "P"
  31.  * in the above examples.  The size of the port transfer is determined
  32.  * by the number of pairs of hex digits given for the data.  If a two
  33.  * digit value is given, the write will be a byte operation; if four
  34.  * digits are used, the write will be performed as a 16-bit operation;
  35.  * and if eight digits are specified, a 32-bit "dword" write will be
  36.  * performed.  Odd numbers of digits are not permitted.
  37.  *
  38.  * If there is an error *anywhere* in the string of registers/data
  39.  * then *none* of the writes will be performed.
  40.  *
  41.  * Drive/Driver settings can be retrieved by reading the drive's
  42.  * "settings" files.  e.g.    "cat /proc/ide0/hda/settings"
  43.  * To write a new value "val" into a specific setting "name", use:
  44.  *   echo "name:val" >/proc/ide/ide0/hda/settings
  45.  *
  46.  * Also useful, "cat /proc/ide0/hda/[identify, smart_values,
  47.  * smart_thresholds, capabilities]" will issue an IDENTIFY /
  48.  * PACKET_IDENTIFY / SMART_READ_VALUES / SMART_READ_THRESHOLDS /
  49.  * SENSE CAPABILITIES command to /dev/hda, and then dump out the
  50.  * returned data as 256 16-bit words.  The "hdparm" utility will
  51.  * be updated someday soon to use this mechanism.
  52.  *
  53.  * Feel free to develop and distribute fancy GUI configuration
  54.  * utilities for your favorite PCI chipsets.  I'll be working on
  55.  * one for the Promise 20246 someday soon.  -ml
  56.  *
  57.  */
  59. #include <linux/config.h>
  60. #include <asm/uaccess.h>
  61. #include <linux/errno.h>
  62. #include <linux/sched.h>
  63. #include <linux/proc_fs.h>
  64. #include <linux/stat.h>
  65. #include <linux/mm.h>
  66. #include <linux/pci.h>
  67. #include <linux/ctype.h>
  68. #include <linux/ide.h>
  70. #include <asm/io.h>
  72. #ifndef MIN
  73. #define MIN(a,b) (((a) < (b)) ? (a) : (b))
  74. #endif
  76. #ifdef CONFIG_BLK_DEV_AEC62XX
  77. extern byte aec62xx_proc;
  78. int (*aec62xx_display_info)(char *, char **, off_t, int) = NULL;
  79. #endif /* CONFIG_BLK_DEV_AEC62XX */
  80. #ifdef CONFIG_BLK_DEV_ALI15X3
  81. extern byte ali_proc;
  82. int (*ali_display_info)(char *, char **, off_t, int) = NULL;
  83. #endif /* CONFIG_BLK_DEV_ALI15X3 */
  84. #ifdef CONFIG_BLK_DEV_AMD74XX
  85. extern byte amd74xx_proc;
  86. int (*amd74xx_display_info)(char *, char **, off_t, int) = NULL;
  87. #endif /* CONFIG_BLK_DEV_AMD74XX */
  88. #ifdef CONFIG_BLK_DEV_CMD64X
  89. extern byte cmd64x_proc;
  90. int (*cmd64x_display_info)(char *, char **, off_t, int) = NULL;
  91. #endif /* CONFIG_BLK_DEV_CMD64X */
  92. #ifdef CONFIG_BLK_DEV_CS5530
  93. extern byte cs5530_proc;
  94. int (*cs5530_display_info)(char *, char **, off_t, int) = NULL;
  95. #endif /* CONFIG_BLK_DEV_CS5530 */
  96. #ifdef CONFIG_BLK_DEV_HPT34X
  97. extern byte hpt34x_proc;
  98. int (*hpt34x_display_info)(char *, char **, off_t, int) = NULL;
  99. #endif /* CONFIG_BLK_DEV_HPT34X */
  100. #ifdef CONFIG_BLK_DEV_HPT366
  101. extern byte hpt366_proc;
  102. int (*hpt366_display_info)(char *, char **, off_t, int) = NULL;
  103. #endif /* CONFIG_BLK_DEV_HPT366 */
  104. #ifdef CONFIG_BLK_DEV_PDC202XX
  105. extern byte pdc202xx_proc;
  106. int (*pdc202xx_display_info)(char *, char **, off_t, int) = NULL;
  107. #endif /* CONFIG_BLK_DEV_PDC202XX */
  108. #ifdef CONFIG_BLK_DEV_PIIX
  109. extern byte piix_proc;
  110. int (*piix_display_info)(char *, char **, off_t, int) = NULL;
  111. #endif /* CONFIG_BLK_DEV_PIIX */
  112. #ifdef CONFIG_BLK_DEV_SVWKS
  113. extern byte svwks_proc;
  114. int (*svwks_display_info)(char *, char **, off_t, int) = NULL;
  115. #endif /* CONFIG_BLK_DEV_SVWKS */
  116. #ifdef CONFIG_BLK_DEV_SIS5513
  117. extern byte sis_proc;
  118. int (*sis_display_info)(char *, char **, off_t, int) = NULL;
  119. #endif /* CONFIG_BLK_DEV_SIS5513 */
  120. #ifdef CONFIG_BLK_DEV_SLC90E66
  121. extern byte slc90e66_proc;
  122. int (*slc90e66_display_info)(char *, char **, off_t, int) = NULL;
  123. #endif /* CONFIG_BLK_DEV_SLC90E66 */
  124. #ifdef CONFIG_BLK_DEV_VIA82CXXX
  125. extern byte via_proc;
  126. int (*via_display_info)(char *, char **, off_t, int) = NULL;
  127. #endif /* CONFIG_BLK_DEV_VIA82CXXX */
  129. static int ide_getxdigit(char c)
  130. {
  131. int digit;
  132. if (isdigit(c))
  133. digit = c - '0';
  134. else if (isxdigit(c))
  135. digit = tolower(c) - 'a' + 10;
  136. else
  137. digit = -1;
  138. return digit;
  139. }
  141. static int xx_xx_parse_error (const char *data, unsigned long len, const char *msg)
  142. {
  143. char errbuf[16];
  144. int i;
  145. if (len >= sizeof(errbuf))
  146. len = sizeof(errbuf) - 1;
  147. for (i = 0; i < len; ++i) {
  148. char c = data[i];
  149. if (!c || c == 'n')
  150. c = '';
  151. else if (iscntrl(c))
  152. c = '?';
  153. errbuf[i] = c;
  154. }
  155. errbuf[i] = '';
  156. printk("proc_ide: error: %s: '%s'n", msg, errbuf);
  157. return -EINVAL;
  158. }
  160. static struct proc_dir_entry * proc_ide_root = NULL;
  162. static int proc_ide_write_config
  163. (struct file *file, const char *buffer, unsigned long count, void *data)
  164. {
  165. ide_hwif_t *hwif = (ide_hwif_t *)data;
  166. int for_real = 0;
  167. unsigned long startn = 0, n, flags;
  168. const char *start = NULL, *msg = NULL;
  170. if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
  171. return -EACCES;
  172. /*
  173.  * Skip over leading whitespace
  174.  */
  175. while (count && isspace(*buffer)) {
  176. --count;
  177. ++buffer;
  178. }
  179. /*
  180.  * Do one full pass to verify all parameters,
  181.  * then do another to actually write the regs.
  182.  */
  183. save_flags(flags); /* all CPUs */
  184. do {
  185. const char *p;
  186. if (for_real) {
  187. unsigned long timeout = jiffies + (3 * HZ);
  188. ide_hwgroup_t *mygroup = (ide_hwgroup_t *)(hwif->hwgroup);
  189. ide_hwgroup_t *mategroup = NULL;
  190. if (hwif->mate && hwif->mate->hwgroup)
  191. mategroup = (ide_hwgroup_t *)(hwif->mate->hwgroup);
  192. cli(); /* all CPUs; ensure all writes are done together */
  193. while (mygroup->busy || (mategroup && mategroup->busy)) {
  194. sti(); /* all CPUs */
  195. if (0 < (signed long)(jiffies - timeout)) {
  196. printk("/proc/ide/%s/config: channel(s) busy, cannot writen", hwif->name);
  197. restore_flags(flags); /* all CPUs */
  198. return -EBUSY;
  199. }
  200. cli(); /* all CPUs */
  201. }
  202. }
  203. p = buffer;
  204. n = count;
  205. while (n > 0) {
  206. int d, digits;
  207. unsigned int reg = 0, val = 0, is_pci;
  208. start = p;
  209. startn = n--;
  210. switch (*p++) {
  211. case 'R': is_pci = 0;
  212. break;
  213. case 'P': is_pci = 1;
  214. #ifdef CONFIG_BLK_DEV_IDEPCI
  215. if (hwif->pci_dev && !IDE_PCI_DEVID_EQ(hwif->pci_devid, IDE_PCI_DEVID_NULL))
  216. break;
  217. #endif /* CONFIG_BLK_DEV_IDEPCI */
  218. msg = "not a PCI device";
  219. goto parse_error;
  220. default: msg = "expected 'R' or 'P'";
  221. goto parse_error;
  222. }
  223. digits = 0;
  224. while (n > 0 && (d = ide_getxdigit(*p)) >= 0) {
  225. reg = (reg << 4) | d;
  226. --n;
  227. ++p;
  228. ++digits;
  229. }
  230. if (!digits || (digits > 4) || (is_pci && reg > 0xff)) {
  231. msg = "bad/missing register number";
  232. goto parse_error;
  233. }
  234. if (n-- == 0 || *p++ != ':') {
  235. msg = "missing ':'";
  236. goto parse_error;
  237. }
  238. digits = 0;
  239. while (n > 0 && (d = ide_getxdigit(*p)) >= 0) {
  240. val = (val << 4) | d;
  241. --n;
  242. ++p;
  243. ++digits;
  244. }
  245. if (digits != 2 && digits != 4 && digits != 8) {
  246. msg = "bad data, 2/4/8 digits required";
  247. goto parse_error;
  248. }
  249. if (n > 0 && !isspace(*p)) {
  250. msg = "expected whitespace after data";
  251. goto parse_error;
  252. }
  253. while (n > 0 && isspace(*p)) {
  254. --n;
  255. ++p;
  256. }
  257. #ifdef CONFIG_BLK_DEV_IDEPCI
  258. if (is_pci && (reg & ((digits >> 1) - 1))) {
  259. msg = "misaligned access";
  260. goto parse_error;
  261. }
  262. #endif /* CONFIG_BLK_DEV_IDEPCI */
  263. if (for_real) {
  264. #if 0
  265. printk("proc_ide_write_config: type=%c, reg=0x%x, val=0x%x, digits=%dn", is_pci ? "PCI" : "non-PCI", reg, val, digits);
  266. #endif
  267. if (is_pci) {
  268. #ifdef CONFIG_BLK_DEV_IDEPCI
  269. int rc = 0;
  270. struct pci_dev *dev = hwif->pci_dev;
  271. switch (digits) {
  272. case 2: msg = "byte";
  273. rc = pci_write_config_byte(dev, reg, val);
  274. break;
  275. case 4: msg = "word";
  276. rc = pci_write_config_word(dev, reg, val);
  277. break;
  278. case 8: msg = "dword";
  279. rc = pci_write_config_dword(dev, reg, val);
  280. break;
  281. }
  282. if (rc) {
  283. restore_flags(flags); /* all CPUs */
  284. printk("proc_ide_write_config: error writing %s at bus %02x dev %02x reg 0x%x value 0x%xn",
  285. msg, dev->bus->number, dev->devfn, reg, val);
  286. printk("proc_ide_write_config: error %dn", rc);
  287. return -EIO;
  288. }
  289. #endif /* CONFIG_BLK_DEV_IDEPCI */
  290. } else { /* not pci */
  291. #if !defined(__mc68000__) && !defined(CONFIG_APUS)
  293. /*
  294.  * Geert Uytterhoeven
  295.  *
  296.  * unless you can explain me what it really does.
  297.  * On m68k, we don't have outw() and outl() yet,
  298.  * and I need a good reason to implement it.
  299.  * 
  300.  * BTW, IMHO the main remaining portability problem with the IDE driver 
  301.  * is that it mixes IO (ioport) and MMIO (iomem) access on different platforms.
  302.  * 
  303.  * I think all accesses should be done using
  304.  * 
  305.  *     ide_in[bwl](ide_device_instance, offset)
  306.  *     ide_out[bwl](ide_device_instance, value, offset)
  307.  * 
  308.  * so the architecture specific code can #define ide_{in,out}[bwl] to the
  309.  * appropriate function.
  310.  * 
  311.  */
  312. switch (digits) {
  313. case 2: outb(val, reg);
  314. break;
  315. case 4: outw(val, reg);
  316. break;
  317. case 8: outl(val, reg);
  318. break;
  319. }
  320. #endif /* !__mc68000__ && !CONFIG_APUS */
  321. }
  322. }
  323. }
  324. } while (!for_real++);
  325. restore_flags(flags); /* all CPUs */
  326. return count;
  327. parse_error:
  328. restore_flags(flags); /* all CPUs */
  329. printk("parse errorn");
  330. return xx_xx_parse_error(start, startn, msg);
  331. }
  333. static int proc_ide_read_config
  334. (char *page, char **start, off_t off, int count, int *eof, void *data)
  335. {
  336. char *out = page;
  337. int len;
  339. #ifdef CONFIG_BLK_DEV_IDEPCI
  340. ide_hwif_t *hwif = (ide_hwif_t *)data;
  341. struct pci_dev *dev = hwif->pci_dev;
  342. if (!IDE_PCI_DEVID_EQ(hwif->pci_devid, IDE_PCI_DEVID_NULL) && dev && dev->bus) {
  343. int reg = 0;
  345. out += sprintf(out, "pci bus %02x device %02x vid %04x did %04x channel %dn",
  346. dev->bus->number, dev->devfn, hwif->pci_devid.vid, hwif->pci_devid.did, hwif->channel);
  347. do {
  348. byte val;
  349. int rc = pci_read_config_byte(dev, reg, &val);
  350. if (rc) {
  351. printk("proc_ide_read_config: error %d reading bus %02x dev %02x reg 0x%02xn",
  352. rc, dev->bus->number, dev->devfn, reg);
  353. out += sprintf(out, "??%c", (++reg & 0xf) ? ' ' : 'n');
  354. } else
  355. out += sprintf(out, "%02x%c", val, (++reg & 0xf) ? ' ' : 'n');
  356. } while (reg < 0x100);
  357. } else
  358. #endif /* CONFIG_BLK_DEV_IDEPCI */
  359. out += sprintf(out, "(none)n");
  360. len = out - page;
  361. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  362. }
  365. static int ide_getdigit(char c)
  366. {
  367. int digit;
  368. if (isdigit(c))
  369. digit = c - '0';
  370. else
  371. digit = -1;
  372. return digit;
  373. }
  375. static int proc_ide_read_drivers
  376. (char *page, char **start, off_t off, int count, int *eof, void *data)
  377. {
  378. char *out = page;
  379. int len;
  380. ide_module_t *p = ide_modules;
  381. ide_driver_t *driver;
  383. while (p) {
  384. driver = (ide_driver_t *) p->info;
  385. if (driver)
  386. out += sprintf(out, "%s version %sn", driver->name, driver->version);
  387. p = p->next;
  388. }
  389. len = out - page;
  390. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  391. }
  393. static int proc_ide_read_imodel
  394. (char *page, char **start, off_t off, int count, int *eof, void *data)
  395. {
  396. ide_hwif_t *hwif = (ide_hwif_t *) data;
  397. int len;
  398. const char *name;
  400. switch (hwif->chipset) {
  401. case ide_unknown: name = "(none)"; break;
  402. case ide_generic: name = "generic"; break;
  403. case ide_pci: name = "pci"; break;
  404. case ide_cmd640: name = "cmd640"; break;
  405. case ide_dtc2278: name = "dtc2278"; break;
  406. case ide_ali14xx: name = "ali14xx"; break;
  407. case ide_qd65xx: name = "qd65xx"; break;
  408. case ide_umc8672: name = "umc8672"; break;
  409. case ide_ht6560b: name = "ht6560b"; break;
  410. case ide_pdc4030: name = "pdc4030"; break;
  411. case ide_rz1000: name = "rz1000"; break;
  412. case ide_trm290: name = "trm290"; break;
  413. case ide_cmd646: name = "cmd646"; break;
  414. case ide_cy82c693: name = "cy82c693"; break;
  415. case ide_4drives: name = "4drives"; break;
  416. case ide_pmac: name = "mac-io"; break;
  417. case ide_acorn: name = "acorn"; break;
  418. default: name = "(unknown)"; break;
  419. }
  420. len = sprintf(page, "%sn", name);
  421. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  422. }
  424. static int proc_ide_read_mate
  425. (char *page, char **start, off_t off, int count, int *eof, void *data)
  426. {
  427. ide_hwif_t *hwif = (ide_hwif_t *) data;
  428. int len;
  430. if (hwif && hwif->mate && hwif->mate->present)
  431. len = sprintf(page, "%sn", hwif->mate->name);
  432. else
  433. len = sprintf(page, "(none)n");
  434. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  435. }
  437. static int proc_ide_read_channel
  438. (char *page, char **start, off_t off, int count, int *eof, void *data)
  439. {
  440. ide_hwif_t *hwif = (ide_hwif_t *) data;
  441. int len;
  443. page[0] = hwif->channel ? '1' : '0';
  444. page[1] = 'n';
  445. len = 2;
  446. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  447. }
  449. static int proc_ide_get_identify(ide_drive_t *drive, byte *buf)
  450. {
  451. return ide_wait_cmd(drive, (drive->media == ide_disk) ? WIN_IDENTIFY : WIN_PIDENTIFY, 0, 0, 1, buf);
  452. }
  454. static int proc_ide_read_identify
  455. (char *page, char **start, off_t off, int count, int *eof, void *data)
  456. {
  457. ide_drive_t *drive = (ide_drive_t *)data;
  458. int len = 0, i = 0;
  460. if (drive && !proc_ide_get_identify(drive, page)) {
  461. unsigned short *val = ((unsigned short *)page) + 2;
  462. char *out = ((char *)val) + (SECTOR_WORDS * 4);
  463. page = out;
  464. do {
  465. out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : 'n');
  466. val += 1;
  467. } while (i < (SECTOR_WORDS * 2));
  468. len = out - page;
  469. }
  470. else
  471. len = sprintf(page, "n");
  472. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  473. }
  475. static int proc_ide_read_settings
  476. (char *page, char **start, off_t off, int count, int *eof, void *data)
  477. {
  478. ide_drive_t *drive = (ide_drive_t *) data;
  479. ide_settings_t *setting = (ide_settings_t *) drive->settings;
  480. char *out = page;
  481. int len, rc, mul_factor, div_factor;
  483. out += sprintf(out, "nametttvaluettminttmaxttmoden");
  484. out += sprintf(out, "----ttt-----tt---tt---tt----n");
  485. while(setting) {
  486. mul_factor = setting->mul_factor;
  487. div_factor = setting->div_factor;
  488. out += sprintf(out, "%-24s", setting->name);
  489. if ((rc = ide_read_setting(drive, setting)) >= 0)
  490. out += sprintf(out, "%-16d", rc * mul_factor / div_factor);
  491. else
  492. out += sprintf(out, "%-16s", "write-only");
  493. out += sprintf(out, "%-16d%-16d", (setting->min * mul_factor + div_factor - 1) / div_factor, setting->max * mul_factor / div_factor);
  494. if (setting->rw & SETTING_READ)
  495. out += sprintf(out, "r");
  496. if (setting->rw & SETTING_WRITE)
  497. out += sprintf(out, "w");
  498. out += sprintf(out, "n");
  499. setting = setting->next;
  500. }
  501. len = out - page;
  502. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  503. }
  505. #define MAX_LEN 30
  507. static int proc_ide_write_settings
  508. (struct file *file, const char *buffer, unsigned long count, void *data)
  509. {
  510. ide_drive_t *drive = (ide_drive_t *) data;
  511. char name[MAX_LEN + 1];
  512. int for_real = 0, len;
  513. unsigned long n;
  514. const char *start = NULL;
  515. ide_settings_t *setting;
  517. if (!capable(CAP_SYS_ADMIN))
  518. return -EACCES;
  519. /*
  520.  * Skip over leading whitespace
  521.  */
  522. while (count && isspace(*buffer)) {
  523. --count;
  524. ++buffer;
  525. }
  526. /*
  527.  * Do one full pass to verify all parameters,
  528.  * then do another to actually write the new settings.
  529.  */
  530. do {
  531. const char *p;
  532. p = buffer;
  533. n = count;
  534. while (n > 0) {
  535. int d, digits;
  536. unsigned int val = 0;
  537. start = p;
  539. while (n > 0 && *p != ':') {
  540. --n;
  541. p++;
  542. }
  543. if (*p != ':')
  544. goto parse_error;
  545. len = IDE_MIN(p - start, MAX_LEN);
  546. strncpy(name, start, IDE_MIN(len, MAX_LEN));
  547. name[len] = 0;
  549. if (n > 0) {
  550. --n;
  551. p++;
  552. } else
  553. goto parse_error;
  555. digits = 0;
  556. while (n > 0 && (d = ide_getdigit(*p)) >= 0) {
  557. val = (val * 10) + d;
  558. --n;
  559. ++p;
  560. ++digits;
  561. }
  562. if (n > 0 && !isspace(*p))
  563. goto parse_error;
  564. while (n > 0 && isspace(*p)) {
  565. --n;
  566. ++p;
  567. }
  568. setting = ide_find_setting_by_name(drive, name);
  569. if (!setting)
  570. goto parse_error;
  572. if (for_real)
  573. ide_write_setting(drive, setting, val * setting->div_factor / setting->mul_factor);
  574. }
  575. } while (!for_real++);
  576. return count;
  577. parse_error:
  578. printk("proc_ide_write_settings(): parse errorn");
  579. return -EINVAL;
  580. }
  582. int proc_ide_read_capacity
  583. (char *page, char **start, off_t off, int count, int *eof, void *data)
  584. {
  585. ide_drive_t *drive = (ide_drive_t *) data;
  586. ide_driver_t    *driver = (ide_driver_t *) drive->driver;
  587. int len;
  589. if (!driver)
  590. len = sprintf(page, "(none)n");
  591.         else
  592. len = sprintf(page,"%lin", ((ide_driver_t *)drive->driver)->capacity(drive));
  593. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  594. }
  596. int proc_ide_read_geometry
  597. (char *page, char **start, off_t off, int count, int *eof, void *data)
  598. {
  599. ide_drive_t *drive = (ide_drive_t *) data;
  600. char *out = page;
  601. int len;
  603. out += sprintf(out,"physical     %d/%d/%dn", drive->cyl, drive->head, drive->sect);
  604. out += sprintf(out,"logical      %d/%d/%dn", drive->bios_cyl, drive->bios_head, drive->bios_sect);
  605. len = out - page;
  606. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  607. }
  609. static int proc_ide_read_dmodel
  610. (char *page, char **start, off_t off, int count, int *eof, void *data)
  611. {
  612. ide_drive_t *drive = (ide_drive_t *) data;
  613. struct hd_driveid *id = drive->id;
  614. int len;
  616. len = sprintf(page, "%.40sn", (id && id->model[0]) ? (char *)id->model : "(none)");
  617. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  618. }
  620. static int proc_ide_read_driver
  621. (char *page, char **start, off_t off, int count, int *eof, void *data)
  622. {
  623. ide_drive_t *drive = (ide_drive_t *) data;
  624. ide_driver_t *driver = (ide_driver_t *) drive->driver;
  625. int len;
  627. if (!driver)
  628. len = sprintf(page, "(none)n");
  629. else
  630. len = sprintf(page, "%s version %sn", driver->name, driver->version);
  631. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  632. }
  634. static int proc_ide_write_driver
  635. (struct file *file, const char *buffer, unsigned long count, void *data)
  636. {
  637. ide_drive_t *drive = (ide_drive_t *) data;
  639. if (!capable(CAP_SYS_ADMIN))
  640. return -EACCES;
  641. if (ide_replace_subdriver(drive, buffer))
  642. return -EINVAL;
  643. return count;
  644. }
  646. static int proc_ide_read_media
  647. (char *page, char **start, off_t off, int count, int *eof, void *data)
  648. {
  649. ide_drive_t *drive = (ide_drive_t *) data;
  650. const char *media;
  651. int len;
  653. switch (drive->media) {
  654. case ide_disk: media = "diskn";
  655. break;
  656. case ide_cdrom: media = "cdromn";
  657. break;
  658. case ide_tape: media = "tapen";
  659. break;
  660. case ide_floppy:media = "floppyn";
  661. break;
  662. default: media = "UNKNOWNn";
  663. break;
  664. }
  665. strcpy(page,media);
  666. len = strlen(media);
  667. PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
  668. }
  670. static ide_proc_entry_t generic_drive_entries[] = {
  671. { "driver", S_IFREG|S_IRUGO, proc_ide_read_driver, proc_ide_write_driver },
  672. { "identify", S_IFREG|S_IRUSR, proc_ide_read_identify, NULL },
  673. { "media", S_IFREG|S_IRUGO, proc_ide_read_media, NULL },
  674. { "model", S_IFREG|S_IRUGO, proc_ide_read_dmodel, NULL },
  675. { "settings", S_IFREG|S_IRUSR|S_IWUSR,proc_ide_read_settings, proc_ide_write_settings },
  676. { NULL, 0, NULL, NULL }
  677. };
  679. void ide_add_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p, void *data)
  680. {
  681. struct proc_dir_entry *ent;
  683. if (!dir || !p)
  684. return;
  685. while (p->name != NULL) {
  686. ent = create_proc_entry(p->name, p->mode, dir);
  687. if (!ent) return;
  688. ent->nlink = 1;
  689. ent->data = data;
  690. ent->read_proc = p->read_proc;
  691. ent->write_proc = p->write_proc;
  692. p++;
  693. }
  694. }
  696. void ide_remove_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p)
  697. {
  698. if (!dir || !p)
  699. return;
  700. while (p->name != NULL) {
  701. remove_proc_entry(p->name, dir);
  702. p++;
  703. }
  704. }
  706. static void create_proc_ide_drives(ide_hwif_t *hwif)
  707. {
  708. int d;
  709. struct proc_dir_entry *ent;
  710. struct proc_dir_entry *parent = hwif->proc;
  711. char name[64];
  713. for (d = 0; d < MAX_DRIVES; d++) {
  714. ide_drive_t *drive = &hwif->drives[d];
  715. ide_driver_t *driver = drive->driver;
  717. if (!drive->present)
  718. continue;
  719. if (drive->proc)
  720. continue;
  722. drive->proc = proc_mkdir(drive->name, parent);
  723. if (drive->proc) {
  724. ide_add_proc_entries(drive->proc, generic_drive_entries, drive);
  725. if (driver) {
  726. ide_add_proc_entries(drive->proc, generic_subdriver_entries, drive);
  727. ide_add_proc_entries(drive->proc, driver->proc, drive);
  728. }
  729. }
  730. sprintf(name,"ide%d/%s", (drive->name[2]-'a')/2, drive->name);
  731. ent = proc_symlink(drive->name, proc_ide_root, name);
  732. if (!ent) return;
  733. }
  734. }
  736. void destroy_proc_ide_drives(ide_hwif_t *hwif)
  737. {
  738. int d;
  740. for (d = 0; d < MAX_DRIVES; d++) {
  741. ide_drive_t *drive = &hwif->drives[d];
  742. ide_driver_t *driver = drive->driver;
  744. if (!drive->proc)
  745. continue;
  746. if (driver)
  747. ide_remove_proc_entries(drive->proc, driver->proc);
  748. ide_remove_proc_entries(drive->proc, generic_drive_entries);
  749. remove_proc_entry(drive->name, proc_ide_root);
  750. remove_proc_entry(drive->name, hwif->proc);
  751. drive->proc = NULL;
  752. }
  753. }
  755. static ide_proc_entry_t hwif_entries[] = {
  756. { "channel", S_IFREG|S_IRUGO, proc_ide_read_channel, NULL },
  757. { "config", S_IFREG|S_IRUGO|S_IWUSR,proc_ide_read_config, proc_ide_write_config },
  758. { "mate", S_IFREG|S_IRUGO, proc_ide_read_mate, NULL },
  759. { "model", S_IFREG|S_IRUGO, proc_ide_read_imodel, NULL },
  760. { NULL, 0, NULL, NULL }
  761. };
  763. void create_proc_ide_interfaces(void)
  764. {
  765. int h;
  767. for (h = 0; h < MAX_HWIFS; h++) {
  768. ide_hwif_t *hwif = &ide_hwifs[h];
  770. if (!hwif->present)
  771. continue;
  772. if (!hwif->proc) {
  773. hwif->proc = proc_mkdir(hwif->name, proc_ide_root);
  774. if (!hwif->proc)
  775. return;
  776. ide_add_proc_entries(hwif->proc, hwif_entries, hwif);
  777. }
  778. create_proc_ide_drives(hwif);
  779. }
  780. }
  782. static void destroy_proc_ide_interfaces(void)
  783. {
  784. int h;
  786. for (h = 0; h < MAX_HWIFS; h++) {
  787. ide_hwif_t *hwif = &ide_hwifs[h];
  788. int exist = (hwif->proc != NULL);
  789. #if 0
  790. if (!hwif->present)
  791. continue;
  792. #endif
  793. if (exist) {
  794. destroy_proc_ide_drives(hwif);
  795. ide_remove_proc_entries(hwif->proc, hwif_entries);
  796. remove_proc_entry(hwif->name, proc_ide_root);
  797. hwif->proc = NULL;
  798. } else
  799. continue;
  800. }
  801. }
  803. void proc_ide_create(void)
  804. {
  805. proc_ide_root = proc_mkdir("ide", 0);
  806. if (!proc_ide_root) return;
  808. create_proc_ide_interfaces();
  810. create_proc_read_entry("drivers", 0, proc_ide_root,
  811. proc_ide_read_drivers, NULL);
  813. #ifdef CONFIG_BLK_DEV_AEC62XX
  814. if ((aec62xx_display_info) && (aec62xx_proc))
  815. create_proc_info_entry("aec62xx", 0, proc_ide_root, aec62xx_display_info);
  816. #endif /* CONFIG_BLK_DEV_AEC62XX */
  817. #ifdef CONFIG_BLK_DEV_ALI15X3
  818. if ((ali_display_info) && (ali_proc))
  819. create_proc_info_entry("ali", 0, proc_ide_root, ali_display_info);
  820. #endif /* CONFIG_BLK_DEV_ALI15X3 */
  821. #ifdef CONFIG_BLK_DEV_AMD74XX
  822. if ((amd74xx_display_info) && (amd74xx_proc))
  823. create_proc_info_entry("amd74xx", 0, proc_ide_root, amd74xx_display_info);
  824. #endif /* CONFIG_BLK_DEV_AMD74XX */
  825. #ifdef CONFIG_BLK_DEV_CMD64X
  826. if ((cmd64x_display_info) && (cmd64x_proc))
  827. create_proc_info_entry("cmd64x", 0, proc_ide_root, cmd64x_display_info);
  828. #endif /* CONFIG_BLK_DEV_CMD64X */
  829. #ifdef CONFIG_BLK_DEV_CS5530
  830. if ((cs5530_display_info) && (cs5530_proc))
  831. create_proc_info_entry("cs5530", 0, proc_ide_root, cs5530_display_info);
  832. #endif /* CONFIG_BLK_DEV_CS5530 */
  833. #ifdef CONFIG_BLK_DEV_HPT34X
  834. if ((hpt34x_display_info) && (hpt34x_proc))
  835. create_proc_info_entry("hpt34x", 0, proc_ide_root, hpt34x_display_info);
  836. #endif /* CONFIG_BLK_DEV_HPT34X */
  837. #ifdef CONFIG_BLK_DEV_HPT366
  838. if ((hpt366_display_info) && (hpt366_proc))
  839. create_proc_info_entry("hpt366", 0, proc_ide_root, hpt366_display_info);
  840. #endif /* CONFIG_BLK_DEV_HPT366 */
  841. #ifdef CONFIG_BLK_DEV_SVWKS
  842. if ((svwks_display_info) && (svwks_proc))
  843. create_proc_info_entry("svwks", 0, proc_ide_root, svwks_display_info);
  844. #endif /* CONFIG_BLK_DEV_SVWKS */
  845. #ifdef CONFIG_BLK_DEV_PDC202XX
  846. if ((pdc202xx_display_info) && (pdc202xx_proc))
  847. create_proc_info_entry("pdc202xx", 0, proc_ide_root, pdc202xx_display_info);
  848. #endif /* CONFIG_BLK_DEV_PDC202XX */
  849. #ifdef CONFIG_BLK_DEV_PIIX
  850. if ((piix_display_info) && (piix_proc))
  851. create_proc_info_entry("piix", 0, proc_ide_root, piix_display_info);
  852. #endif /* CONFIG_BLK_DEV_PIIX */
  853. #ifdef CONFIG_BLK_DEV_SIS5513
  854. if ((sis_display_info) && (sis_proc))
  855. create_proc_info_entry("sis", 0, proc_ide_root, sis_display_info);
  856. #endif /* CONFIG_BLK_DEV_SIS5513 */
  857. #ifdef CONFIG_BLK_DEV_SLC90E66
  858. if ((slc90e66_display_info) && (slc90e66_proc))
  859. create_proc_info_entry("slc90e66", 0, proc_ide_root, slc90e66_display_info);
  860. #endif /* CONFIG_BLK_DEV_SLC90E66 */
  861. #ifdef CONFIG_BLK_DEV_VIA82CXXX
  862. if ((via_display_info) && (via_proc))
  863. create_proc_info_entry("via", 0, proc_ide_root, via_display_info);
  864. #endif /* CONFIG_BLK_DEV_VIA82CXXX */
  865. }
  867. void proc_ide_destroy(void)
  868. {
  869. /*
  870.  * Mmmm.. does this free up all resources,
  871.  * or do we need to do a more proper cleanup here ??
  872.  */
  873. #ifdef CONFIG_BLK_DEV_AEC62XX
  874. if ((aec62xx_display_info) && (aec62xx_proc))
  875. remove_proc_entry("ide/aec62xx",0);
  876. #endif /* CONFIG_BLK_DEV_AEC62XX */
  877. #ifdef CONFIG_BLK_DEV_ALI15X3
  878. if ((ali_display_info) && (ali_proc))
  879. remove_proc_entry("ide/ali",0);
  880. #endif /* CONFIG_BLK_DEV_ALI15X3 */
  881. #ifdef CONFIG_BLK_DEV_AMD74XX
  882. if ((amd74xx_display_info) && (amd74xx_proc))
  883. remove_proc_entry("ide/amd74xx",0);
  884. #endif /* CONFIG_BLK_DEV_AMD74XX */
  885. #ifdef CONFIG_BLK_DEV_CMD64X
  886. if ((cmd64x_display_info) && (cmd64x_proc))
  887. remove_proc_entry("ide/cmd64x",0);
  888. #endif /* CONFIG_BLK_DEV_CMD64X */
  889. #ifdef CONFIG_BLK_DEV_CS5530
  890. if ((cs5530_display_info) && (cs5530_proc))
  891. remove_proc_entry("ide/cs5530",0);
  892. #endif /* CONFIG_BLK_DEV_CS5530 */
  893. #ifdef CONFIG_BLK_DEV_HPT34X
  894. if ((hpt34x_display_info) && (hpt34x_proc))
  895. remove_proc_entry("ide/hpt34x",0);
  896. #endif /* CONFIG_BLK_DEV_HPT34X */
  897. #ifdef CONFIG_BLK_DEV_HPT366
  898. if ((hpt366_display_info) && (hpt366_proc))
  899. remove_proc_entry("ide/hpt366",0);
  900. #endif /* CONFIG_BLK_DEV_HPT366 */
  901. #ifdef CONFIG_BLK_DEV_PDC202XX
  902. if ((pdc202xx_display_info) && (pdc202xx_proc))
  903. remove_proc_entry("ide/pdc202xx",0);
  904. #endif /* CONFIG_BLK_DEV_PDC202XX */
  905. #ifdef CONFIG_BLK_DEV_PIIX
  906. if ((piix_display_info) && (piix_proc))
  907. remove_proc_entry("ide/piix",0);
  908. #endif /* CONFIG_BLK_DEV_PIIX */
  909. #ifdef CONFIG_BLK_DEV_SVWKS
  910. if ((svwks_display_info) && (svwks_proc))
  911. remove_proc_entry("ide/svwks",0);
  912. #endif /* CONFIG_BLK_DEV_SVWKS */
  913. #ifdef CONFIG_BLK_DEV_SIS5513
  914. if ((sis_display_info) && (sis_proc))
  915. remove_proc_entry("ide/sis", 0);
  916. #endif /* CONFIG_BLK_DEV_SIS5513 */
  917. #ifdef CONFIG_BLK_DEV_SLC90E66
  918. if ((slc90e66_display_info) && (slc90e66_proc))
  919. remove_proc_entry("ide/slc90e66",0);
  920. #endif /* CONFIG_BLK_DEV_SLC90E66 */
  921. #ifdef CONFIG_BLK_DEV_VIA82CXXX
  922. if ((via_display_info) && (via_proc))
  923. remove_proc_entry("ide/via",0);
  924. #endif /* CONFIG_BLK_DEV_VIA82CXXX */
  926. remove_proc_entry("ide/drivers", 0);
  927. destroy_proc_ide_interfaces();
  928. remove_proc_entry("ide", 0);
  929. }