pcmcia.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833
  1. /*
  2. * Sonics Silicon Backplane
  3. * PCMCIA-Hostbus related functions
  4. *
  5. * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
  6. * Copyright 2007-2008 Michael Buesch <m@bues.ch>
  7. *
  8. * Licensed under the GNU/GPL. See COPYING for details.
  9. */
  10. #include "ssb_private.h"
  11. #include <linux/ssb/ssb.h>
  12. #include <linux/delay.h>
  13. #include <linux/io.h>
  14. #include <linux/etherdevice.h>
  15. #include <pcmcia/cistpl.h>
  16. #include <pcmcia/ciscode.h>
  17. #include <pcmcia/ds.h>
  18. #include <pcmcia/cisreg.h>
  19. /* Define the following to 1 to enable a printk on each coreswitch. */
  20. #define SSB_VERBOSE_PCMCIACORESWITCH_DEBUG 0
  21. /* PCMCIA configuration registers */
  22. #define SSB_PCMCIA_ADDRESS0 0x2E
  23. #define SSB_PCMCIA_ADDRESS1 0x30
  24. #define SSB_PCMCIA_ADDRESS2 0x32
  25. #define SSB_PCMCIA_MEMSEG 0x34
  26. #define SSB_PCMCIA_SPROMCTL 0x36
  27. #define SSB_PCMCIA_SPROMCTL_IDLE 0
  28. #define SSB_PCMCIA_SPROMCTL_WRITE 1
  29. #define SSB_PCMCIA_SPROMCTL_READ 2
  30. #define SSB_PCMCIA_SPROMCTL_WRITEEN 4
  31. #define SSB_PCMCIA_SPROMCTL_WRITEDIS 7
  32. #define SSB_PCMCIA_SPROMCTL_DONE 8
  33. #define SSB_PCMCIA_SPROM_DATALO 0x38
  34. #define SSB_PCMCIA_SPROM_DATAHI 0x3A
  35. #define SSB_PCMCIA_SPROM_ADDRLO 0x3C
  36. #define SSB_PCMCIA_SPROM_ADDRHI 0x3E
  37. /* Hardware invariants CIS tuples */
  38. #define SSB_PCMCIA_CIS 0x80
  39. #define SSB_PCMCIA_CIS_ID 0x01
  40. #define SSB_PCMCIA_CIS_BOARDREV 0x02
  41. #define SSB_PCMCIA_CIS_PA 0x03
  42. #define SSB_PCMCIA_CIS_PA_PA0B0_LO 0
  43. #define SSB_PCMCIA_CIS_PA_PA0B0_HI 1
  44. #define SSB_PCMCIA_CIS_PA_PA0B1_LO 2
  45. #define SSB_PCMCIA_CIS_PA_PA0B1_HI 3
  46. #define SSB_PCMCIA_CIS_PA_PA0B2_LO 4
  47. #define SSB_PCMCIA_CIS_PA_PA0B2_HI 5
  48. #define SSB_PCMCIA_CIS_PA_ITSSI 6
  49. #define SSB_PCMCIA_CIS_PA_MAXPOW 7
  50. #define SSB_PCMCIA_CIS_OEMNAME 0x04
  51. #define SSB_PCMCIA_CIS_CCODE 0x05
  52. #define SSB_PCMCIA_CIS_ANTENNA 0x06
  53. #define SSB_PCMCIA_CIS_ANTGAIN 0x07
  54. #define SSB_PCMCIA_CIS_BFLAGS 0x08
  55. #define SSB_PCMCIA_CIS_LEDS 0x09
  56. /* PCMCIA SPROM size. */
  57. #define SSB_PCMCIA_SPROM_SIZE 256
  58. #define SSB_PCMCIA_SPROM_SIZE_BYTES (SSB_PCMCIA_SPROM_SIZE * sizeof(u16))
  59. /* Write to a PCMCIA configuration register. */
  60. static int ssb_pcmcia_cfg_write(struct ssb_bus *bus, u8 offset, u8 value)
  61. {
  62. int res;
  63. res = pcmcia_write_config_byte(bus->host_pcmcia, offset, value);
  64. if (unlikely(res != 0))
  65. return -EBUSY;
  66. return 0;
  67. }
  68. /* Read from a PCMCIA configuration register. */
  69. static int ssb_pcmcia_cfg_read(struct ssb_bus *bus, u8 offset, u8 *value)
  70. {
  71. int res;
  72. res = pcmcia_read_config_byte(bus->host_pcmcia, offset, value);
  73. if (unlikely(res != 0))
  74. return -EBUSY;
  75. return 0;
  76. }
  77. int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
  78. u8 coreidx)
  79. {
  80. int err;
  81. int attempts = 0;
  82. u32 cur_core;
  83. u32 addr;
  84. u32 read_addr;
  85. u8 val;
  86. addr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE;
  87. while (1) {
  88. err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS0,
  89. (addr & 0x0000F000) >> 12);
  90. if (err)
  91. goto error;
  92. err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS1,
  93. (addr & 0x00FF0000) >> 16);
  94. if (err)
  95. goto error;
  96. err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS2,
  97. (addr & 0xFF000000) >> 24);
  98. if (err)
  99. goto error;
  100. read_addr = 0;
  101. err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS0, &val);
  102. if (err)
  103. goto error;
  104. read_addr |= ((u32)(val & 0x0F)) << 12;
  105. err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS1, &val);
  106. if (err)
  107. goto error;
  108. read_addr |= ((u32)val) << 16;
  109. err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS2, &val);
  110. if (err)
  111. goto error;
  112. read_addr |= ((u32)val) << 24;
  113. cur_core = (read_addr - SSB_ENUM_BASE) / SSB_CORE_SIZE;
  114. if (cur_core == coreidx)
  115. break;
  116. err = -ETIMEDOUT;
  117. if (attempts++ > SSB_BAR0_MAX_RETRIES)
  118. goto error;
  119. udelay(10);
  120. }
  121. return 0;
  122. error:
  123. pr_err("Failed to switch to core %u\n", coreidx);
  124. return err;
  125. }
  126. static int ssb_pcmcia_switch_core(struct ssb_bus *bus, struct ssb_device *dev)
  127. {
  128. int err;
  129. #if SSB_VERBOSE_PCMCIACORESWITCH_DEBUG
  130. pr_info("Switching to %s core, index %d\n",
  131. ssb_core_name(dev->id.coreid), dev->core_index);
  132. #endif
  133. err = ssb_pcmcia_switch_coreidx(bus, dev->core_index);
  134. if (!err)
  135. bus->mapped_device = dev;
  136. return err;
  137. }
  138. int ssb_pcmcia_switch_segment(struct ssb_bus *bus, u8 seg)
  139. {
  140. int attempts = 0;
  141. int err;
  142. u8 val;
  143. WARN_ON((seg != 0) && (seg != 1));
  144. while (1) {
  145. err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_MEMSEG, seg);
  146. if (err)
  147. goto error;
  148. err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_MEMSEG, &val);
  149. if (err)
  150. goto error;
  151. if (val == seg)
  152. break;
  153. err = -ETIMEDOUT;
  154. if (unlikely(attempts++ > SSB_BAR0_MAX_RETRIES))
  155. goto error;
  156. udelay(10);
  157. }
  158. bus->mapped_pcmcia_seg = seg;
  159. return 0;
  160. error:
  161. pr_err("Failed to switch pcmcia segment\n");
  162. return err;
  163. }
  164. static int select_core_and_segment(struct ssb_device *dev,
  165. u16 *offset)
  166. {
  167. struct ssb_bus *bus = dev->bus;
  168. int err;
  169. u8 need_segment;
  170. if (*offset >= 0x800) {
  171. *offset -= 0x800;
  172. need_segment = 1;
  173. } else
  174. need_segment = 0;
  175. if (unlikely(dev != bus->mapped_device)) {
  176. err = ssb_pcmcia_switch_core(bus, dev);
  177. if (unlikely(err))
  178. return err;
  179. }
  180. if (unlikely(need_segment != bus->mapped_pcmcia_seg)) {
  181. err = ssb_pcmcia_switch_segment(bus, need_segment);
  182. if (unlikely(err))
  183. return err;
  184. }
  185. return 0;
  186. }
  187. static u8 ssb_pcmcia_read8(struct ssb_device *dev, u16 offset)
  188. {
  189. struct ssb_bus *bus = dev->bus;
  190. unsigned long flags;
  191. int err;
  192. u8 value = 0xFF;
  193. spin_lock_irqsave(&bus->bar_lock, flags);
  194. err = select_core_and_segment(dev, &offset);
  195. if (likely(!err))
  196. value = readb(bus->mmio + offset);
  197. spin_unlock_irqrestore(&bus->bar_lock, flags);
  198. return value;
  199. }
  200. static u16 ssb_pcmcia_read16(struct ssb_device *dev, u16 offset)
  201. {
  202. struct ssb_bus *bus = dev->bus;
  203. unsigned long flags;
  204. int err;
  205. u16 value = 0xFFFF;
  206. spin_lock_irqsave(&bus->bar_lock, flags);
  207. err = select_core_and_segment(dev, &offset);
  208. if (likely(!err))
  209. value = readw(bus->mmio + offset);
  210. spin_unlock_irqrestore(&bus->bar_lock, flags);
  211. return value;
  212. }
  213. static u32 ssb_pcmcia_read32(struct ssb_device *dev, u16 offset)
  214. {
  215. struct ssb_bus *bus = dev->bus;
  216. unsigned long flags;
  217. int err;
  218. u32 lo = 0xFFFFFFFF, hi = 0xFFFFFFFF;
  219. spin_lock_irqsave(&bus->bar_lock, flags);
  220. err = select_core_and_segment(dev, &offset);
  221. if (likely(!err)) {
  222. lo = readw(bus->mmio + offset);
  223. hi = readw(bus->mmio + offset + 2);
  224. }
  225. spin_unlock_irqrestore(&bus->bar_lock, flags);
  226. return (lo | (hi << 16));
  227. }
  228. #ifdef CONFIG_SSB_BLOCKIO
  229. static void ssb_pcmcia_block_read(struct ssb_device *dev, void *buffer,
  230. size_t count, u16 offset, u8 reg_width)
  231. {
  232. struct ssb_bus *bus = dev->bus;
  233. unsigned long flags;
  234. void __iomem *addr = bus->mmio + offset;
  235. int err;
  236. spin_lock_irqsave(&bus->bar_lock, flags);
  237. err = select_core_and_segment(dev, &offset);
  238. if (unlikely(err)) {
  239. memset(buffer, 0xFF, count);
  240. goto unlock;
  241. }
  242. switch (reg_width) {
  243. case sizeof(u8): {
  244. u8 *buf = buffer;
  245. while (count) {
  246. *buf = __raw_readb(addr);
  247. buf++;
  248. count--;
  249. }
  250. break;
  251. }
  252. case sizeof(u16): {
  253. __le16 *buf = buffer;
  254. WARN_ON(count & 1);
  255. while (count) {
  256. *buf = (__force __le16)__raw_readw(addr);
  257. buf++;
  258. count -= 2;
  259. }
  260. break;
  261. }
  262. case sizeof(u32): {
  263. __le16 *buf = buffer;
  264. WARN_ON(count & 3);
  265. while (count) {
  266. *buf = (__force __le16)__raw_readw(addr);
  267. buf++;
  268. *buf = (__force __le16)__raw_readw(addr + 2);
  269. buf++;
  270. count -= 4;
  271. }
  272. break;
  273. }
  274. default:
  275. WARN_ON(1);
  276. }
  277. unlock:
  278. spin_unlock_irqrestore(&bus->bar_lock, flags);
  279. }
  280. #endif /* CONFIG_SSB_BLOCKIO */
  281. static void ssb_pcmcia_write8(struct ssb_device *dev, u16 offset, u8 value)
  282. {
  283. struct ssb_bus *bus = dev->bus;
  284. unsigned long flags;
  285. int err;
  286. spin_lock_irqsave(&bus->bar_lock, flags);
  287. err = select_core_and_segment(dev, &offset);
  288. if (likely(!err))
  289. writeb(value, bus->mmio + offset);
  290. spin_unlock_irqrestore(&bus->bar_lock, flags);
  291. }
  292. static void ssb_pcmcia_write16(struct ssb_device *dev, u16 offset, u16 value)
  293. {
  294. struct ssb_bus *bus = dev->bus;
  295. unsigned long flags;
  296. int err;
  297. spin_lock_irqsave(&bus->bar_lock, flags);
  298. err = select_core_and_segment(dev, &offset);
  299. if (likely(!err))
  300. writew(value, bus->mmio + offset);
  301. spin_unlock_irqrestore(&bus->bar_lock, flags);
  302. }
  303. static void ssb_pcmcia_write32(struct ssb_device *dev, u16 offset, u32 value)
  304. {
  305. struct ssb_bus *bus = dev->bus;
  306. unsigned long flags;
  307. int err;
  308. spin_lock_irqsave(&bus->bar_lock, flags);
  309. err = select_core_and_segment(dev, &offset);
  310. if (likely(!err)) {
  311. writew((value & 0x0000FFFF), bus->mmio + offset);
  312. writew(((value & 0xFFFF0000) >> 16), bus->mmio + offset + 2);
  313. }
  314. spin_unlock_irqrestore(&bus->bar_lock, flags);
  315. }
  316. #ifdef CONFIG_SSB_BLOCKIO
  317. static void ssb_pcmcia_block_write(struct ssb_device *dev, const void *buffer,
  318. size_t count, u16 offset, u8 reg_width)
  319. {
  320. struct ssb_bus *bus = dev->bus;
  321. unsigned long flags;
  322. void __iomem *addr = bus->mmio + offset;
  323. int err;
  324. spin_lock_irqsave(&bus->bar_lock, flags);
  325. err = select_core_and_segment(dev, &offset);
  326. if (unlikely(err))
  327. goto unlock;
  328. switch (reg_width) {
  329. case sizeof(u8): {
  330. const u8 *buf = buffer;
  331. while (count) {
  332. __raw_writeb(*buf, addr);
  333. buf++;
  334. count--;
  335. }
  336. break;
  337. }
  338. case sizeof(u16): {
  339. const __le16 *buf = buffer;
  340. WARN_ON(count & 1);
  341. while (count) {
  342. __raw_writew((__force u16)(*buf), addr);
  343. buf++;
  344. count -= 2;
  345. }
  346. break;
  347. }
  348. case sizeof(u32): {
  349. const __le16 *buf = buffer;
  350. WARN_ON(count & 3);
  351. while (count) {
  352. __raw_writew((__force u16)(*buf), addr);
  353. buf++;
  354. __raw_writew((__force u16)(*buf), addr + 2);
  355. buf++;
  356. count -= 4;
  357. }
  358. break;
  359. }
  360. default:
  361. WARN_ON(1);
  362. }
  363. unlock:
  364. spin_unlock_irqrestore(&bus->bar_lock, flags);
  365. }
  366. #endif /* CONFIG_SSB_BLOCKIO */
  367. /* Not "static", as it's used in main.c */
  368. const struct ssb_bus_ops ssb_pcmcia_ops = {
  369. .read8 = ssb_pcmcia_read8,
  370. .read16 = ssb_pcmcia_read16,
  371. .read32 = ssb_pcmcia_read32,
  372. .write8 = ssb_pcmcia_write8,
  373. .write16 = ssb_pcmcia_write16,
  374. .write32 = ssb_pcmcia_write32,
  375. #ifdef CONFIG_SSB_BLOCKIO
  376. .block_read = ssb_pcmcia_block_read,
  377. .block_write = ssb_pcmcia_block_write,
  378. #endif
  379. };
  380. static int ssb_pcmcia_sprom_command(struct ssb_bus *bus, u8 command)
  381. {
  382. unsigned int i;
  383. int err;
  384. u8 value;
  385. err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROMCTL, command);
  386. if (err)
  387. return err;
  388. for (i = 0; i < 1000; i++) {
  389. err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROMCTL, &value);
  390. if (err)
  391. return err;
  392. if (value & SSB_PCMCIA_SPROMCTL_DONE)
  393. return 0;
  394. udelay(10);
  395. }
  396. return -ETIMEDOUT;
  397. }
  398. /* offset is the 16bit word offset */
  399. static int ssb_pcmcia_sprom_read(struct ssb_bus *bus, u16 offset, u16 *value)
  400. {
  401. int err;
  402. u8 lo, hi;
  403. offset *= 2; /* Make byte offset */
  404. err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
  405. (offset & 0x00FF));
  406. if (err)
  407. return err;
  408. err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
  409. (offset & 0xFF00) >> 8);
  410. if (err)
  411. return err;
  412. err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_READ);
  413. if (err)
  414. return err;
  415. err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATALO, &lo);
  416. if (err)
  417. return err;
  418. err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATAHI, &hi);
  419. if (err)
  420. return err;
  421. *value = (lo | (((u16)hi) << 8));
  422. return 0;
  423. }
  424. /* offset is the 16bit word offset */
  425. static int ssb_pcmcia_sprom_write(struct ssb_bus *bus, u16 offset, u16 value)
  426. {
  427. int err;
  428. offset *= 2; /* Make byte offset */
  429. err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
  430. (offset & 0x00FF));
  431. if (err)
  432. return err;
  433. err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
  434. (offset & 0xFF00) >> 8);
  435. if (err)
  436. return err;
  437. err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATALO,
  438. (value & 0x00FF));
  439. if (err)
  440. return err;
  441. err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATAHI,
  442. (value & 0xFF00) >> 8);
  443. if (err)
  444. return err;
  445. err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITE);
  446. if (err)
  447. return err;
  448. msleep(20);
  449. return 0;
  450. }
  451. /* Read the SPROM image. bufsize is in 16bit words. */
  452. static int ssb_pcmcia_sprom_read_all(struct ssb_bus *bus, u16 *sprom)
  453. {
  454. int err, i;
  455. for (i = 0; i < SSB_PCMCIA_SPROM_SIZE; i++) {
  456. err = ssb_pcmcia_sprom_read(bus, i, &sprom[i]);
  457. if (err)
  458. return err;
  459. }
  460. return 0;
  461. }
  462. /* Write the SPROM image. size is in 16bit words. */
  463. static int ssb_pcmcia_sprom_write_all(struct ssb_bus *bus, const u16 *sprom)
  464. {
  465. int i, err;
  466. bool failed = 0;
  467. size_t size = SSB_PCMCIA_SPROM_SIZE;
  468. pr_notice("Writing SPROM. Do NOT turn off the power! Please stand by...\n");
  469. err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEEN);
  470. if (err) {
  471. pr_notice("Could not enable SPROM write access\n");
  472. return -EBUSY;
  473. }
  474. pr_notice("[ 0%%");
  475. msleep(500);
  476. for (i = 0; i < size; i++) {
  477. if (i == size / 4)
  478. pr_cont("25%%");
  479. else if (i == size / 2)
  480. pr_cont("50%%");
  481. else if (i == (size * 3) / 4)
  482. pr_cont("75%%");
  483. else if (i % 2)
  484. pr_cont(".");
  485. err = ssb_pcmcia_sprom_write(bus, i, sprom[i]);
  486. if (err) {
  487. pr_notice("Failed to write to SPROM\n");
  488. failed = 1;
  489. break;
  490. }
  491. }
  492. err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEDIS);
  493. if (err) {
  494. pr_notice("Could not disable SPROM write access\n");
  495. failed = 1;
  496. }
  497. msleep(500);
  498. if (!failed) {
  499. pr_cont("100%% ]\n");
  500. pr_notice("SPROM written\n");
  501. }
  502. return failed ? -EBUSY : 0;
  503. }
  504. static int ssb_pcmcia_sprom_check_crc(const u16 *sprom, size_t size)
  505. {
  506. //TODO
  507. return 0;
  508. }
  509. #define GOTO_ERROR_ON(condition, description) do { \
  510. if (unlikely(condition)) { \
  511. error_description = description; \
  512. goto error; \
  513. } \
  514. } while (0)
  515. static int ssb_pcmcia_get_mac(struct pcmcia_device *p_dev,
  516. tuple_t *tuple,
  517. void *priv)
  518. {
  519. struct ssb_sprom *sprom = priv;
  520. if (tuple->TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID)
  521. return -EINVAL;
  522. if (tuple->TupleDataLen != ETH_ALEN + 2)
  523. return -EINVAL;
  524. if (tuple->TupleData[1] != ETH_ALEN)
  525. return -EINVAL;
  526. memcpy(sprom->il0mac, &tuple->TupleData[2], ETH_ALEN);
  527. return 0;
  528. };
  529. static int ssb_pcmcia_do_get_invariants(struct pcmcia_device *p_dev,
  530. tuple_t *tuple,
  531. void *priv)
  532. {
  533. struct ssb_init_invariants *iv = priv;
  534. struct ssb_sprom *sprom = &iv->sprom;
  535. struct ssb_boardinfo *bi = &iv->boardinfo;
  536. const char *error_description;
  537. GOTO_ERROR_ON(tuple->TupleDataLen < 1, "VEN tpl < 1");
  538. switch (tuple->TupleData[0]) {
  539. case SSB_PCMCIA_CIS_ID:
  540. GOTO_ERROR_ON((tuple->TupleDataLen != 5) &&
  541. (tuple->TupleDataLen != 7),
  542. "id tpl size");
  543. bi->vendor = tuple->TupleData[1] |
  544. ((u16)tuple->TupleData[2] << 8);
  545. break;
  546. case SSB_PCMCIA_CIS_BOARDREV:
  547. GOTO_ERROR_ON(tuple->TupleDataLen != 2,
  548. "boardrev tpl size");
  549. sprom->board_rev = tuple->TupleData[1];
  550. break;
  551. case SSB_PCMCIA_CIS_PA:
  552. GOTO_ERROR_ON((tuple->TupleDataLen != 9) &&
  553. (tuple->TupleDataLen != 10),
  554. "pa tpl size");
  555. sprom->pa0b0 = tuple->TupleData[1] |
  556. ((u16)tuple->TupleData[2] << 8);
  557. sprom->pa0b1 = tuple->TupleData[3] |
  558. ((u16)tuple->TupleData[4] << 8);
  559. sprom->pa0b2 = tuple->TupleData[5] |
  560. ((u16)tuple->TupleData[6] << 8);
  561. sprom->itssi_a = tuple->TupleData[7];
  562. sprom->itssi_bg = tuple->TupleData[7];
  563. sprom->maxpwr_a = tuple->TupleData[8];
  564. sprom->maxpwr_bg = tuple->TupleData[8];
  565. break;
  566. case SSB_PCMCIA_CIS_OEMNAME:
  567. /* We ignore this. */
  568. break;
  569. case SSB_PCMCIA_CIS_CCODE:
  570. GOTO_ERROR_ON(tuple->TupleDataLen != 2,
  571. "ccode tpl size");
  572. sprom->country_code = tuple->TupleData[1];
  573. break;
  574. case SSB_PCMCIA_CIS_ANTENNA:
  575. GOTO_ERROR_ON(tuple->TupleDataLen != 2,
  576. "ant tpl size");
  577. sprom->ant_available_a = tuple->TupleData[1];
  578. sprom->ant_available_bg = tuple->TupleData[1];
  579. break;
  580. case SSB_PCMCIA_CIS_ANTGAIN:
  581. GOTO_ERROR_ON(tuple->TupleDataLen != 2,
  582. "antg tpl size");
  583. sprom->antenna_gain.a0 = tuple->TupleData[1];
  584. sprom->antenna_gain.a1 = tuple->TupleData[1];
  585. sprom->antenna_gain.a2 = tuple->TupleData[1];
  586. sprom->antenna_gain.a3 = tuple->TupleData[1];
  587. break;
  588. case SSB_PCMCIA_CIS_BFLAGS:
  589. GOTO_ERROR_ON((tuple->TupleDataLen != 3) &&
  590. (tuple->TupleDataLen != 5),
  591. "bfl tpl size");
  592. sprom->boardflags_lo = tuple->TupleData[1] |
  593. ((u16)tuple->TupleData[2] << 8);
  594. break;
  595. case SSB_PCMCIA_CIS_LEDS:
  596. GOTO_ERROR_ON(tuple->TupleDataLen != 5,
  597. "leds tpl size");
  598. sprom->gpio0 = tuple->TupleData[1];
  599. sprom->gpio1 = tuple->TupleData[2];
  600. sprom->gpio2 = tuple->TupleData[3];
  601. sprom->gpio3 = tuple->TupleData[4];
  602. break;
  603. }
  604. return -ENOSPC; /* continue with next entry */
  605. error:
  606. pr_err("PCMCIA: Failed to fetch device invariants: %s\n",
  607. error_description);
  608. return -ENODEV;
  609. }
  610. int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
  611. struct ssb_init_invariants *iv)
  612. {
  613. struct ssb_sprom *sprom = &iv->sprom;
  614. int res;
  615. memset(sprom, 0xFF, sizeof(*sprom));
  616. sprom->revision = 1;
  617. sprom->boardflags_lo = 0;
  618. sprom->boardflags_hi = 0;
  619. /* First fetch the MAC address. */
  620. res = pcmcia_loop_tuple(bus->host_pcmcia, CISTPL_FUNCE,
  621. ssb_pcmcia_get_mac, sprom);
  622. if (res != 0) {
  623. pr_err("PCMCIA: Failed to fetch MAC address\n");
  624. return -ENODEV;
  625. }
  626. /* Fetch the vendor specific tuples. */
  627. res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS,
  628. ssb_pcmcia_do_get_invariants, iv);
  629. if ((res == 0) || (res == -ENOSPC))
  630. return 0;
  631. pr_err("PCMCIA: Failed to fetch device invariants\n");
  632. return -ENODEV;
  633. }
  634. static ssize_t ssb_pcmcia_attr_sprom_show(struct device *pcmciadev,
  635. struct device_attribute *attr,
  636. char *buf)
  637. {
  638. struct pcmcia_device *pdev =
  639. container_of(pcmciadev, struct pcmcia_device, dev);
  640. struct ssb_bus *bus;
  641. bus = ssb_pcmcia_dev_to_bus(pdev);
  642. if (!bus)
  643. return -ENODEV;
  644. return ssb_attr_sprom_show(bus, buf,
  645. ssb_pcmcia_sprom_read_all);
  646. }
  647. static ssize_t ssb_pcmcia_attr_sprom_store(struct device *pcmciadev,
  648. struct device_attribute *attr,
  649. const char *buf, size_t count)
  650. {
  651. struct pcmcia_device *pdev =
  652. container_of(pcmciadev, struct pcmcia_device, dev);
  653. struct ssb_bus *bus;
  654. bus = ssb_pcmcia_dev_to_bus(pdev);
  655. if (!bus)
  656. return -ENODEV;
  657. return ssb_attr_sprom_store(bus, buf, count,
  658. ssb_pcmcia_sprom_check_crc,
  659. ssb_pcmcia_sprom_write_all);
  660. }
  661. static DEVICE_ATTR(ssb_sprom, 0600,
  662. ssb_pcmcia_attr_sprom_show,
  663. ssb_pcmcia_attr_sprom_store);
  664. static int ssb_pcmcia_cor_setup(struct ssb_bus *bus, u8 cor)
  665. {
  666. u8 val;
  667. int err;
  668. err = ssb_pcmcia_cfg_read(bus, cor, &val);
  669. if (err)
  670. return err;
  671. val &= ~COR_SOFT_RESET;
  672. val |= COR_FUNC_ENA | COR_IREQ_ENA | COR_LEVEL_REQ;
  673. err = ssb_pcmcia_cfg_write(bus, cor, val);
  674. if (err)
  675. return err;
  676. msleep(40);
  677. return 0;
  678. }
  679. /* Initialize the PCMCIA hardware. This is called on Init and Resume. */
  680. int ssb_pcmcia_hardware_setup(struct ssb_bus *bus)
  681. {
  682. int err;
  683. if (bus->bustype != SSB_BUSTYPE_PCMCIA)
  684. return 0;
  685. /* Switch segment to a known state and sync
  686. * bus->mapped_pcmcia_seg with hardware state. */
  687. ssb_pcmcia_switch_segment(bus, 0);
  688. /* Init the COR register. */
  689. err = ssb_pcmcia_cor_setup(bus, CISREG_COR);
  690. if (err)
  691. return err;
  692. /* Some cards also need this register to get poked. */
  693. err = ssb_pcmcia_cor_setup(bus, CISREG_COR + 0x80);
  694. if (err)
  695. return err;
  696. return 0;
  697. }
  698. void ssb_pcmcia_exit(struct ssb_bus *bus)
  699. {
  700. if (bus->bustype != SSB_BUSTYPE_PCMCIA)
  701. return;
  702. device_remove_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
  703. }
  704. int ssb_pcmcia_init(struct ssb_bus *bus)
  705. {
  706. int err;
  707. if (bus->bustype != SSB_BUSTYPE_PCMCIA)
  708. return 0;
  709. err = ssb_pcmcia_hardware_setup(bus);
  710. if (err)
  711. goto error;
  712. bus->sprom_size = SSB_PCMCIA_SPROM_SIZE;
  713. mutex_init(&bus->sprom_mutex);
  714. err = device_create_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
  715. if (err)
  716. goto error;
  717. return 0;
  718. error:
  719. pr_err("Failed to initialize PCMCIA host device\n");
  720. return err;
  721. }