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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
hermes.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：14k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

hermes.c：源码内容
  1. /* hermes.c
  2.  *
  3.  * Driver core for the "Hermes" wireless MAC controller, as used in
  4.  * the Lucent Orinoco and Cabletron RoamAbout cards. It should also
  5.  * work on the hfa3841 and hfa3842 MAC controller chips used in the
  6.  * Prism II chipsets.
  7.  *
  8.  * This is not a complete driver, just low-level access routines for
  9.  * the MAC controller itself.
  10.  *
  11.  * Based on the prism2 driver from Absolute Value Systems' linux-wlan
  12.  * project, the Linux wvlan_cs driver, Lucent's HCF-Light
  13.  * (wvlan_hcf.c) library, and the NetBSD wireless driver (in no
  14.  * particular order).
  15.  *
  16.  * Copyright (C) 2000, David Gibson, Linuxcare Australia <hermes@gibson.dropbear.id.au>
  17.  * Copyright (C) 2001, David Gibson, IBM <hermes@gibson.dropbear.id.au>
  18.  * 
  19.  * The contents of this file are subject to the Mozilla Public License
  20.  * Version 1.1 (the "License"); you may not use this file except in
  21.  * compliance with the License. You may obtain a copy of the License
  22.  * at http://www.mozilla.org/MPL/
  23.  *
  24.  * Software distributed under the License is distributed on an "AS IS"
  25.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  26.  * the License for the specific language governing rights and
  27.  * limitations under the License.
  28.  *
  29.  * Alternatively, the contents of this file may be used under the
  30.  * terms of the GNU General Public License version 2 (the "GPL"), in
  31.  * which case the provisions of the GPL are applicable instead of the
  32.  * above.  If you wish to allow the use of your version of this file
  33.  * only under the terms of the GPL and not to allow others to use your
  34.  * version of this file under the MPL, indicate your decision by
  35.  * deleting the provisions above and replace them with the notice and
  36.  * other provisions required by the GPL.  If you do not delete the
  37.  * provisions above, a recipient may use your version of this file
  38.  * under either the MPL or the GPL.
  39.  */
  41. #include <linux/config.h>
  43. #include <linux/module.h>
  44. #include <linux/types.h>
  45. #include <linux/threads.h>
  46. #include <linux/smp.h>
  47. #include <asm/io.h>
  48. #include <linux/ptrace.h>
  49. #include <linux/delay.h>
  50. #include <linux/init.h>
  51. #include <linux/kernel.h>
  52. #include <asm/errno.h>
  54. #include "hermes.h"
  56. static char version[] __initdata = "hermes.c: 5 Apr 2002 David Gibson <hermes@gibson.dropbear.id.au>";
  57. MODULE_DESCRIPTION("Low-level driver helper for Lucent Hermes chipset and Prism II HFA384x wireless MAC controller");
  58. MODULE_AUTHOR("David Gibson <hermes@gibson.dropbear.id.au>");
  59. #ifdef MODULE_LICENSE
  60. MODULE_LICENSE("Dual MPL/GPL");
  61. #endif
  63. /* These are maximum timeouts. Most often, card wil react much faster */
  64. #define CMD_BUSY_TIMEOUT (100) /* In iterations of ~1us */
  65. #define CMD_INIT_TIMEOUT (50000) /* in iterations of ~10us */
  66. #define CMD_COMPL_TIMEOUT (20000) /* in iterations of ~10us */
  67. #define ALLOC_COMPL_TIMEOUT (1000) /* in iterations of ~10us */
  69. /*
  70.  * Debugging helpers
  71.  */
  73. #undef HERMES_DEBUG
  74. #ifdef HERMES_DEBUG
  76. #include <stdarg.h>
  78. #define DMSG(stuff...) do {printk(KERN_DEBUG "hermes @ 0x%x: " , hw->iobase); 
  79. printk(stuff);} while (0)
  81. #define DEBUG(lvl, stuff...) if ( (lvl) <= HERMES_DEBUG) DMSG(stuff)
  83. #else /* ! HERMES_DEBUG */
  85. #define DEBUG(lvl, stuff...) do { } while (0)
  87. #endif /* ! HERMES_DEBUG */
  89. #define IO_TYPE(hw) ((hw)->io_space ? "IO " : "MEM ")
  91. /*
  92.  * Internal functions
  93.  */
  95. /* Issue a command to the chip. Waiting for it to complete is the caller's
  96.    problem.
  98.    Returns -EBUSY if the command register is busy, 0 on success.
  100.    Callable from any context.
  101. */
  102. static int hermes_issue_cmd(hermes_t *hw, u16 cmd, u16 param0)
  103. {
  104. int k = CMD_BUSY_TIMEOUT;
  105. u16 reg;
  107. /* First wait for the command register to unbusy */
  108. reg = hermes_read_regn(hw, CMD);
  109. while ( (reg & HERMES_CMD_BUSY) && k ) {
  110. k--;
  111. udelay(1);
  112. reg = hermes_read_regn(hw, CMD);
  113. }
  114. DEBUG(3, "hermes_issue_cmd: did %d retries.n", CMD_BUSY_TIMEOUT-k);
  115. if (reg & HERMES_CMD_BUSY) {
  116. return -EBUSY;
  117. }
  119. hermes_write_regn(hw, PARAM2, 0);
  120. hermes_write_regn(hw, PARAM1, 0);
  121. hermes_write_regn(hw, PARAM0, param0);
  122. hermes_write_regn(hw, CMD, cmd);
  124. return 0;
  125. }
  127. /*
  128.  * Function definitions
  129.  */
  131. void hermes_struct_init(hermes_t *hw, ulong address,
  132. int io_space, int reg_spacing)
  133. {
  134. hw->iobase = address;
  135. hw->io_space = io_space;
  136. hw->reg_spacing = reg_spacing;
  137. hw->inten = 0x0;
  139. #ifdef HERMES_DEBUG_BUFFER
  140. hw->dbufp = 0;
  141. memset(&hw->dbuf, 0xff, sizeof(hw->dbuf));
  142. memset(&hw->profile, 0, sizeof(hw->profile));
  143. #endif
  144. }
  146. int hermes_reset(hermes_t *hw)
  147. {
  148. u16 status, reg;
  149. int err = 0;
  150. int k;
  152. /* We don't want to be interrupted while resetting the chipset */
  153. hw->inten = 0x0;
  154. hermes_write_regn(hw, INTEN, 0);
  155. hermes_write_regn(hw, EVACK, 0xffff);
  157. /* Normally it's a "can't happen" for the command register to
  158.            be busy when we go to issue a command because we are
  159.            serializing all commands.  However we want to have some
  160.            chance of resetting the card even if it gets into a stupid
  161.            state, so we actually wait to see if the command register
  162.            will unbusy itself here. */
  163. k = CMD_BUSY_TIMEOUT;
  164. reg = hermes_read_regn(hw, CMD);
  165. while (k && (reg & HERMES_CMD_BUSY)) {
  166. if (reg == 0xffff) /* Special case - the card has probably been removed,
  167.       so don't wait for the timeout */
  168. return -ENODEV;
  170. k--;
  171. udelay(1);
  172. reg = hermes_read_regn(hw, CMD);
  173. }
  175. /* No need to explicitly handle the timeout - if we've timed
  176.    out hermes_issue_cmd() will probably return -EBUSY below */
  178. /* According to the documentation, EVSTAT may contain
  179.    obsolete event occurrence information.  We have to acknowledge
  180.    it by writing EVACK. */
  181. reg = hermes_read_regn(hw, EVSTAT);
  182. hermes_write_regn(hw, EVACK, reg);
  184. /* We don't use hermes_docmd_wait here, because the reset wipes
  185.    the magic constant in SWSUPPORT0 away, and it gets confused */
  186. err = hermes_issue_cmd(hw, HERMES_CMD_INIT, 0);
  187. if (err)
  188. return err;
  190. reg = hermes_read_regn(hw, EVSTAT);
  191. k = CMD_INIT_TIMEOUT;
  192. while ( (! (reg & HERMES_EV_CMD)) && k) {
  193. k--;
  194. udelay(10);
  195. reg = hermes_read_regn(hw, EVSTAT);
  196. }
  198. DEBUG(0, "Reset completed in %d iterationsn", CMD_INIT_TIMEOUT - k);
  200. hermes_write_regn(hw, SWSUPPORT0, HERMES_MAGIC);
  202. if (! hermes_present(hw)) {
  203. DEBUG(0, "hermes @ 0x%x: Card removed during reset.n",
  204.        hw->iobase);
  205. err = -ENODEV;
  206. goto out;
  207. }
  209. if (! (reg & HERMES_EV_CMD)) {
  210. printk(KERN_ERR "hermes @ %s0x%lx: " 
  211.        "Timeout waiting for card to reset (reg=0x%04x)!n",
  212.        IO_TYPE(hw), hw->iobase, reg);
  213. err = -ETIMEDOUT;
  214. goto out;
  215. }
  217. status = hermes_read_regn(hw, STATUS);
  219. hermes_write_regn(hw, EVACK, HERMES_EV_CMD);
  221. if (status & HERMES_STATUS_RESULT)
  222. err = -EIO;
  224.  out:
  225. return err;
  226. }
  228. /* Issue a command to the chip, and (busy!) wait for it to
  229.  * complete.
  230.  *
  231.  * Returns: < 0 on internal error, 0 on success, > 0 on error returned by the firmware
  232.  *
  233.  * Callable from any context, but locking is your problem. */
  234. int hermes_docmd_wait(hermes_t *hw, u16 cmd, u16 parm0, hermes_response_t *resp)
  235. {
  236. int err;
  237. int k;
  238. u16 reg;
  239. u16 status;
  241. err = hermes_issue_cmd(hw, cmd, parm0);
  242. if (err) {
  243. if (! hermes_present(hw)) {
  244. printk(KERN_WARNING "hermes @ %s0x%lx: "
  245.        "Card removed while issuing command.n",
  246.        IO_TYPE(hw), hw->iobase);
  247. err = -ENODEV;
  248. } else 
  249. printk(KERN_ERR "hermes @ %s0x%lx: Error %d issuing command.n",
  250.        IO_TYPE(hw), hw->iobase, err);
  251. goto out;
  252. }
  254. reg = hermes_read_regn(hw, EVSTAT);
  255. k = CMD_COMPL_TIMEOUT;
  256. while ( (! (reg & HERMES_EV_CMD)) && k) {
  257. k--;
  258. udelay(10);
  259. reg = hermes_read_regn(hw, EVSTAT);
  260. }
  262. if (! hermes_present(hw)) {
  263. printk(KERN_WARNING "hermes @ %s0x%lx: "
  264.        "Card removed while waiting for command completion.n",
  265.        IO_TYPE(hw), hw->iobase);
  266. err = -ENODEV;
  267. goto out;
  268. }
  270. if (! (reg & HERMES_EV_CMD)) {
  271. printk(KERN_ERR "hermes @ %s0x%lx: "
  272.        "Timeout waiting for command completion.n",
  273.        IO_TYPE(hw), hw->iobase);
  274. err = -ETIMEDOUT;
  275. goto out;
  276. }
  278. status = hermes_read_regn(hw, STATUS);
  279. if (resp) {
  280. resp->status = status;
  281. resp->resp0 = hermes_read_regn(hw, RESP0);
  282. resp->resp1 = hermes_read_regn(hw, RESP1);
  283. resp->resp2 = hermes_read_regn(hw, RESP2);
  284. }
  286. hermes_write_regn(hw, EVACK, HERMES_EV_CMD);
  288. if (status & HERMES_STATUS_RESULT)
  289. err = -EIO;
  291.  out:
  292. return err;
  293. }
  295. int hermes_allocate(hermes_t *hw, u16 size, u16 *fid)
  296. {
  297. int err = 0;
  298. int k;
  299. u16 reg;
  301. if ( (size < HERMES_ALLOC_LEN_MIN) || (size > HERMES_ALLOC_LEN_MAX) )
  302. return -EINVAL;
  304. err = hermes_docmd_wait(hw, HERMES_CMD_ALLOC, size, NULL);
  305. if (err) {
  306. printk(KERN_WARNING "hermes @ %s0x%lx: "
  307.        "Frame allocation command failed (0x%X).n",
  308.        IO_TYPE(hw), hw->iobase, err);
  309. return err;
  310. }
  312. reg = hermes_read_regn(hw, EVSTAT);
  313. k = ALLOC_COMPL_TIMEOUT;
  314. while ( (! (reg & HERMES_EV_ALLOC)) && k) {
  315. k--;
  316. udelay(10);
  317. reg = hermes_read_regn(hw, EVSTAT);
  318. }
  320. if (! hermes_present(hw)) {
  321. printk(KERN_WARNING "hermes @ %s0x%lx: "
  322.        "Card removed waiting for frame allocation.n",
  323.        IO_TYPE(hw), hw->iobase);
  324. return -ENODEV;
  325. }
  327. if (! (reg & HERMES_EV_ALLOC)) {
  328. printk(KERN_ERR "hermes @ %s0x%lx: "
  329.        "Timeout waiting for frame allocationn",
  330.        IO_TYPE(hw), hw->iobase);
  331. return -ETIMEDOUT;
  332. }
  334. *fid = hermes_read_regn(hw, ALLOCFID);
  335. hermes_write_regn(hw, EVACK, HERMES_EV_ALLOC);
  337. return 0;
  338. }
  341. /* Set up a BAP to read a particular chunk of data from card's internal buffer.
  342.  *
  343.  * Returns: < 0 on internal failure (errno), 0 on success, >0 on error
  344.  * from firmware
  345.  *
  346.  * Callable from any context */
  347. static int hermes_bap_seek(hermes_t *hw, int bap, u16 id, u16 offset)
  348. {
  349. int sreg = bap ? HERMES_SELECT1 : HERMES_SELECT0;
  350. int oreg = bap ? HERMES_OFFSET1 : HERMES_OFFSET0;
  351. int k;
  352. u16 reg;
  354. /* Paranoia.. */
  355. if ( (offset > HERMES_BAP_OFFSET_MAX) || (offset % 2) )
  356. return -EINVAL;
  358. k = HERMES_BAP_BUSY_TIMEOUT;
  359. reg = hermes_read_reg(hw, oreg);
  360. while ((reg & HERMES_OFFSET_BUSY) && k) {
  361. k--;
  362. udelay(1);
  363. reg = hermes_read_reg(hw, oreg);
  364. }
  366. #ifdef HERMES_DEBUG_BUFFER
  367. hw->profile[HERMES_BAP_BUSY_TIMEOUT - k]++;
  369. if (k < HERMES_BAP_BUSY_TIMEOUT) {
  370. struct hermes_debug_entry *e = 
  371. &hw->dbuf[(hw->dbufp++) % HERMES_DEBUG_BUFSIZE];
  372. e->bap = bap;
  373. e->id = id;
  374. e->offset = offset;
  375. e->cycles = HERMES_BAP_BUSY_TIMEOUT - k;
  376. }
  377. #endif
  379. if (reg & HERMES_OFFSET_BUSY)
  380. return -ETIMEDOUT;
  382. /* Now we actually set up the transfer */
  383. hermes_write_reg(hw, sreg, id);
  384. hermes_write_reg(hw, oreg, offset);
  386. /* Wait for the BAP to be ready */
  387. k = HERMES_BAP_BUSY_TIMEOUT;
  388. reg = hermes_read_reg(hw, oreg);
  389. while ( (reg & (HERMES_OFFSET_BUSY | HERMES_OFFSET_ERR)) && k) {
  390. k--;
  391. udelay(1);
  392. reg = hermes_read_reg(hw, oreg);
  393. }
  395. if (reg & HERMES_OFFSET_BUSY) {
  396. DEBUG(1,"hermes_bap_seek: timeoutn");
  397. return -ETIMEDOUT;
  398. }
  400. if (reg & HERMES_OFFSET_ERR) {
  401. DEBUG(1,"hermes_bap_seek: BAP errorn");
  402. return -EIO;
  403. }
  406. return 0;
  407. }
  409. /* Read a block of data from the chip's buffer, via the
  410.  * BAP. Synchronization/serialization is the caller's problem.  len
  411.  * must be even.
  412.  *
  413.  * Returns: < 0 on internal failure (errno), 0 on success, > 0 on error from firmware
  414.  */
  415. int hermes_bap_pread(hermes_t *hw, int bap, void *buf, int len,
  416.      u16 id, u16 offset)
  417. {
  418. int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;
  419. int err = 0;
  421. if ( (len < 0) || (len % 2) )
  422. return -EINVAL;
  424. err = hermes_bap_seek(hw, bap, id, offset);
  425. if (err)
  426. goto out;
  428. /* Actually do the transfer */
  429. hermes_read_words(hw, dreg, buf, len/2);
  431.  out:
  432. return err;
  433. }
  435. /* Write a block of data to the chip's buffer, via the
  436.  * BAP. Synchronization/serialization is the caller's problem. len
  437.  * must be even.
  438.  *
  439.  * Returns: < 0 on internal failure (errno), 0 on success, > 0 on error from firmware
  440.  */
  441. int hermes_bap_pwrite(hermes_t *hw, int bap, const void *buf, int len,
  442.       u16 id, u16 offset)
  443. {
  444. int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;
  445. int err = 0;
  447. if ( (len < 0) || (len % 2) )
  448. return -EINVAL;
  450. err = hermes_bap_seek(hw, bap, id, offset);
  451. if (err)
  452. goto out;
  454. /* Actually do the transfer */
  455. hermes_write_words(hw, dreg, buf, len/2);
  457.  out:
  458. return err;
  459. }
  461. /* Read a Length-Type-Value record from the card.
  462.  *
  463.  * If length is NULL, we ignore the length read from the card, and
  464.  * read the entire buffer regardless. This is useful because some of
  465.  * the configuration records appear to have incorrect lengths in
  466.  * practice.
  467.  *
  468.  * Callable from user or bh context.  */
  469. int hermes_read_ltv(hermes_t *hw, int bap, u16 rid, int bufsize,
  470.     u16 *length, void *buf)
  471. {
  472. int err = 0;
  473. int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;
  474. u16 rlength, rtype;
  476. if ( (bufsize < 0) || (bufsize % 2) )
  477. return -EINVAL;
  479. err = hermes_docmd_wait(hw, HERMES_CMD_ACCESS, rid, NULL);
  480. if (err)
  481. goto out;
  483. err = hermes_bap_seek(hw, bap, rid, 0);
  484. if (err)
  485. goto out;
  487. rlength = hermes_read_reg(hw, dreg);
  488. rtype = hermes_read_reg(hw, dreg);
  490. if (length)
  491. *length = rlength;
  493. if (rtype != rid)
  494. printk(KERN_WARNING "hermes @ %s0x%lx: "
  495.        "hermes_read_ltv(): rid  (0x%04x) does not match type (0x%04x)n",
  496.        IO_TYPE(hw), hw->iobase, rid, rtype);
  497. if (HERMES_RECLEN_TO_BYTES(rlength) > bufsize)
  498. printk(KERN_WARNING "hermes @ %s0x%lx: "
  499.        "Truncating LTV record from %d to %d bytes. "
  500.        "(rid=0x%04x, len=0x%04x)n",
  501.        IO_TYPE(hw), hw->iobase,
  502.        HERMES_RECLEN_TO_BYTES(rlength), bufsize, rid, rlength);
  504. /* FIXME: we should read the min of the requested length and
  505.            the actual record length */
  506. hermes_read_words(hw, dreg, buf, bufsize / 2);
  508.  out:
  509. return err;
  510. }
  512. int hermes_write_ltv(hermes_t *hw, int bap, u16 rid, 
  513.      u16 length, const void *value)
  514. {
  515. int dreg = bap ? HERMES_DATA1 : HERMES_DATA0;
  516. int err = 0;
  517. int count;
  519. DEBUG(3, "write_ltv(): bap=%d rid=0x%04x length=%d (value=0x%04x)n",
  520.       bap, rid, length, * ((u16 *)value));
  522. err = hermes_bap_seek(hw, bap, rid, 0);
  523. if (err)
  524. goto out;
  526. hermes_write_reg(hw, dreg, length);
  527. hermes_write_reg(hw, dreg, rid);
  529. count = length - 1;
  531. hermes_write_words(hw, dreg, value, count);
  533. err = hermes_docmd_wait(hw, HERMES_CMD_ACCESS | HERMES_CMD_WRITE, 
  534. rid, NULL);
  536.  out:
  537. return err;
  538. }
  540. EXPORT_SYMBOL(hermes_struct_init);
  541. EXPORT_SYMBOL(hermes_reset);
  542. EXPORT_SYMBOL(hermes_docmd_wait);
  543. EXPORT_SYMBOL(hermes_allocate);
  545. EXPORT_SYMBOL(hermes_bap_pread);
  546. EXPORT_SYMBOL(hermes_bap_pwrite);
  547. EXPORT_SYMBOL(hermes_read_ltv);
  548. EXPORT_SYMBOL(hermes_write_ltv);
  550. static int __init init_hermes(void)
  551. {
  552. printk(KERN_DEBUG "%sn", version);
  554. return 0;
  555. }
  557. module_init(init_hermes);