yenta_socket.c 39 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393
  1. /*
  2. * Regular cardbus driver ("yenta_socket")
  3. *
  4. * (C) Copyright 1999, 2000 Linus Torvalds
  5. *
  6. * Changelog:
  7. * Aug 2002: Manfred Spraul <manfred@colorfullife.com>
  8. * Dynamically adjust the size of the bridge resource
  9. *
  10. * May 2003: Dominik Brodowski <linux@brodo.de>
  11. * Merge pci_socket.c and yenta.c into one file
  12. */
  13. #include <linux/init.h>
  14. #include <linux/pci.h>
  15. #include <linux/workqueue.h>
  16. #include <linux/interrupt.h>
  17. #include <linux/delay.h>
  18. #include <linux/module.h>
  19. #include <pcmcia/cs_types.h>
  20. #include <pcmcia/ss.h>
  21. #include <pcmcia/cs.h>
  22. #include <asm/io.h>
  23. #include "yenta_socket.h"
  24. #include "i82365.h"
  25. static int disable_clkrun;
  26. module_param(disable_clkrun, bool, 0444);
  27. MODULE_PARM_DESC(disable_clkrun, "If PC card doesn't function properly, please try this option");
  28. static int isa_probe = 1;
  29. module_param(isa_probe, bool, 0444);
  30. MODULE_PARM_DESC(isa_probe, "If set ISA interrupts are probed (default). Set to N to disable probing");
  31. static int pwr_irqs_off;
  32. module_param(pwr_irqs_off, bool, 0644);
  33. MODULE_PARM_DESC(pwr_irqs_off, "Force IRQs off during power-on of slot. Use only when seeing IRQ storms!");
  34. #if 0
  35. #define debug(x,args...) printk(KERN_DEBUG "%s: " x, __func__ , ##args)
  36. #else
  37. #define debug(x,args...)
  38. #endif
  39. /* Don't ask.. */
  40. #define to_cycles(ns) ((ns)/120)
  41. #define to_ns(cycles) ((cycles)*120)
  42. /**
  43. * yenta PCI irq probing.
  44. * currently only used in the TI/EnE initialization code
  45. */
  46. #ifdef CONFIG_YENTA_TI
  47. static int yenta_probe_cb_irq(struct yenta_socket *socket);
  48. #endif
  49. static unsigned int override_bios;
  50. module_param(override_bios, uint, 0000);
  51. MODULE_PARM_DESC (override_bios, "yenta ignore bios resource allocation");
  52. /*
  53. * Generate easy-to-use ways of reading a cardbus sockets
  54. * regular memory space ("cb_xxx"), configuration space
  55. * ("config_xxx") and compatibility space ("exca_xxxx")
  56. */
  57. static inline u32 cb_readl(struct yenta_socket *socket, unsigned reg)
  58. {
  59. u32 val = readl(socket->base + reg);
  60. debug("%p %04x %08x\n", socket, reg, val);
  61. return val;
  62. }
  63. static inline void cb_writel(struct yenta_socket *socket, unsigned reg, u32 val)
  64. {
  65. debug("%p %04x %08x\n", socket, reg, val);
  66. writel(val, socket->base + reg);
  67. readl(socket->base + reg); /* avoid problems with PCI write posting */
  68. }
  69. static inline u8 config_readb(struct yenta_socket *socket, unsigned offset)
  70. {
  71. u8 val;
  72. pci_read_config_byte(socket->dev, offset, &val);
  73. debug("%p %04x %02x\n", socket, offset, val);
  74. return val;
  75. }
  76. static inline u16 config_readw(struct yenta_socket *socket, unsigned offset)
  77. {
  78. u16 val;
  79. pci_read_config_word(socket->dev, offset, &val);
  80. debug("%p %04x %04x\n", socket, offset, val);
  81. return val;
  82. }
  83. static inline u32 config_readl(struct yenta_socket *socket, unsigned offset)
  84. {
  85. u32 val;
  86. pci_read_config_dword(socket->dev, offset, &val);
  87. debug("%p %04x %08x\n", socket, offset, val);
  88. return val;
  89. }
  90. static inline void config_writeb(struct yenta_socket *socket, unsigned offset, u8 val)
  91. {
  92. debug("%p %04x %02x\n", socket, offset, val);
  93. pci_write_config_byte(socket->dev, offset, val);
  94. }
  95. static inline void config_writew(struct yenta_socket *socket, unsigned offset, u16 val)
  96. {
  97. debug("%p %04x %04x\n", socket, offset, val);
  98. pci_write_config_word(socket->dev, offset, val);
  99. }
  100. static inline void config_writel(struct yenta_socket *socket, unsigned offset, u32 val)
  101. {
  102. debug("%p %04x %08x\n", socket, offset, val);
  103. pci_write_config_dword(socket->dev, offset, val);
  104. }
  105. static inline u8 exca_readb(struct yenta_socket *socket, unsigned reg)
  106. {
  107. u8 val = readb(socket->base + 0x800 + reg);
  108. debug("%p %04x %02x\n", socket, reg, val);
  109. return val;
  110. }
  111. static inline u8 exca_readw(struct yenta_socket *socket, unsigned reg)
  112. {
  113. u16 val;
  114. val = readb(socket->base + 0x800 + reg);
  115. val |= readb(socket->base + 0x800 + reg + 1) << 8;
  116. debug("%p %04x %04x\n", socket, reg, val);
  117. return val;
  118. }
  119. static inline void exca_writeb(struct yenta_socket *socket, unsigned reg, u8 val)
  120. {
  121. debug("%p %04x %02x\n", socket, reg, val);
  122. writeb(val, socket->base + 0x800 + reg);
  123. readb(socket->base + 0x800 + reg); /* PCI write posting... */
  124. }
  125. static void exca_writew(struct yenta_socket *socket, unsigned reg, u16 val)
  126. {
  127. debug("%p %04x %04x\n", socket, reg, val);
  128. writeb(val, socket->base + 0x800 + reg);
  129. writeb(val >> 8, socket->base + 0x800 + reg + 1);
  130. /* PCI write posting... */
  131. readb(socket->base + 0x800 + reg);
  132. readb(socket->base + 0x800 + reg + 1);
  133. }
  134. static ssize_t show_yenta_registers(struct device *yentadev, struct device_attribute *attr, char *buf)
  135. {
  136. struct pci_dev *dev = to_pci_dev(yentadev);
  137. struct yenta_socket *socket = pci_get_drvdata(dev);
  138. int offset = 0, i;
  139. offset = snprintf(buf, PAGE_SIZE, "CB registers:");
  140. for (i = 0; i < 0x24; i += 4) {
  141. unsigned val;
  142. if (!(i & 15))
  143. offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n%02x:", i);
  144. val = cb_readl(socket, i);
  145. offset += snprintf(buf + offset, PAGE_SIZE - offset, " %08x", val);
  146. }
  147. offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n\nExCA registers:");
  148. for (i = 0; i < 0x45; i++) {
  149. unsigned char val;
  150. if (!(i & 7)) {
  151. if (i & 8) {
  152. memcpy(buf + offset, " -", 2);
  153. offset += 2;
  154. } else
  155. offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n%02x:", i);
  156. }
  157. val = exca_readb(socket, i);
  158. offset += snprintf(buf + offset, PAGE_SIZE - offset, " %02x", val);
  159. }
  160. buf[offset++] = '\n';
  161. return offset;
  162. }
  163. static DEVICE_ATTR(yenta_registers, S_IRUSR, show_yenta_registers, NULL);
  164. /*
  165. * Ugh, mixed-mode cardbus and 16-bit pccard state: things depend
  166. * on what kind of card is inserted..
  167. */
  168. static int yenta_get_status(struct pcmcia_socket *sock, unsigned int *value)
  169. {
  170. struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
  171. unsigned int val;
  172. u32 state = cb_readl(socket, CB_SOCKET_STATE);
  173. val = (state & CB_3VCARD) ? SS_3VCARD : 0;
  174. val |= (state & CB_XVCARD) ? SS_XVCARD : 0;
  175. val |= (state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) ? 0 : SS_PENDING;
  176. val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? SS_PENDING : 0;
  177. if (state & CB_CBCARD) {
  178. val |= SS_CARDBUS;
  179. val |= (state & CB_CARDSTS) ? SS_STSCHG : 0;
  180. val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? 0 : SS_DETECT;
  181. val |= (state & CB_PWRCYCLE) ? SS_POWERON | SS_READY : 0;
  182. } else if (state & CB_16BITCARD) {
  183. u8 status = exca_readb(socket, I365_STATUS);
  184. val |= ((status & I365_CS_DETECT) == I365_CS_DETECT) ? SS_DETECT : 0;
  185. if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) {
  186. val |= (status & I365_CS_STSCHG) ? 0 : SS_STSCHG;
  187. } else {
  188. val |= (status & I365_CS_BVD1) ? 0 : SS_BATDEAD;
  189. val |= (status & I365_CS_BVD2) ? 0 : SS_BATWARN;
  190. }
  191. val |= (status & I365_CS_WRPROT) ? SS_WRPROT : 0;
  192. val |= (status & I365_CS_READY) ? SS_READY : 0;
  193. val |= (status & I365_CS_POWERON) ? SS_POWERON : 0;
  194. }
  195. *value = val;
  196. return 0;
  197. }
  198. static void yenta_set_power(struct yenta_socket *socket, socket_state_t *state)
  199. {
  200. /* some birdges require to use the ExCA registers to power 16bit cards */
  201. if (!(cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) &&
  202. (socket->flags & YENTA_16BIT_POWER_EXCA)) {
  203. u8 reg, old;
  204. reg = old = exca_readb(socket, I365_POWER);
  205. reg &= ~(I365_VCC_MASK | I365_VPP1_MASK | I365_VPP2_MASK);
  206. /* i82365SL-DF style */
  207. if (socket->flags & YENTA_16BIT_POWER_DF) {
  208. switch (state->Vcc) {
  209. case 33: reg |= I365_VCC_3V; break;
  210. case 50: reg |= I365_VCC_5V; break;
  211. default: reg = 0; break;
  212. }
  213. switch (state->Vpp) {
  214. case 33:
  215. case 50: reg |= I365_VPP1_5V; break;
  216. case 120: reg |= I365_VPP1_12V; break;
  217. }
  218. } else {
  219. /* i82365SL-B style */
  220. switch (state->Vcc) {
  221. case 50: reg |= I365_VCC_5V; break;
  222. default: reg = 0; break;
  223. }
  224. switch (state->Vpp) {
  225. case 50: reg |= I365_VPP1_5V | I365_VPP2_5V; break;
  226. case 120: reg |= I365_VPP1_12V | I365_VPP2_12V; break;
  227. }
  228. }
  229. if (reg != old)
  230. exca_writeb(socket, I365_POWER, reg);
  231. } else {
  232. u32 reg = 0; /* CB_SC_STPCLK? */
  233. switch (state->Vcc) {
  234. case 33: reg = CB_SC_VCC_3V; break;
  235. case 50: reg = CB_SC_VCC_5V; break;
  236. default: reg = 0; break;
  237. }
  238. switch (state->Vpp) {
  239. case 33: reg |= CB_SC_VPP_3V; break;
  240. case 50: reg |= CB_SC_VPP_5V; break;
  241. case 120: reg |= CB_SC_VPP_12V; break;
  242. }
  243. if (reg != cb_readl(socket, CB_SOCKET_CONTROL))
  244. cb_writel(socket, CB_SOCKET_CONTROL, reg);
  245. }
  246. }
  247. static int yenta_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
  248. {
  249. struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
  250. u16 bridge;
  251. /* if powering down: do it immediately */
  252. if (state->Vcc == 0)
  253. yenta_set_power(socket, state);
  254. socket->io_irq = state->io_irq;
  255. bridge = config_readw(socket, CB_BRIDGE_CONTROL) & ~(CB_BRIDGE_CRST | CB_BRIDGE_INTR);
  256. if (cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) {
  257. u8 intr;
  258. bridge |= (state->flags & SS_RESET) ? CB_BRIDGE_CRST : 0;
  259. /* ISA interrupt control? */
  260. intr = exca_readb(socket, I365_INTCTL);
  261. intr = (intr & ~0xf);
  262. if (!socket->cb_irq) {
  263. intr |= state->io_irq;
  264. bridge |= CB_BRIDGE_INTR;
  265. }
  266. exca_writeb(socket, I365_INTCTL, intr);
  267. } else {
  268. u8 reg;
  269. reg = exca_readb(socket, I365_INTCTL) & (I365_RING_ENA | I365_INTR_ENA);
  270. reg |= (state->flags & SS_RESET) ? 0 : I365_PC_RESET;
  271. reg |= (state->flags & SS_IOCARD) ? I365_PC_IOCARD : 0;
  272. if (state->io_irq != socket->cb_irq) {
  273. reg |= state->io_irq;
  274. bridge |= CB_BRIDGE_INTR;
  275. }
  276. exca_writeb(socket, I365_INTCTL, reg);
  277. reg = exca_readb(socket, I365_POWER) & (I365_VCC_MASK|I365_VPP1_MASK);
  278. reg |= I365_PWR_NORESET;
  279. if (state->flags & SS_PWR_AUTO) reg |= I365_PWR_AUTO;
  280. if (state->flags & SS_OUTPUT_ENA) reg |= I365_PWR_OUT;
  281. if (exca_readb(socket, I365_POWER) != reg)
  282. exca_writeb(socket, I365_POWER, reg);
  283. /* CSC interrupt: no ISA irq for CSC */
  284. reg = I365_CSC_DETECT;
  285. if (state->flags & SS_IOCARD) {
  286. if (state->csc_mask & SS_STSCHG) reg |= I365_CSC_STSCHG;
  287. } else {
  288. if (state->csc_mask & SS_BATDEAD) reg |= I365_CSC_BVD1;
  289. if (state->csc_mask & SS_BATWARN) reg |= I365_CSC_BVD2;
  290. if (state->csc_mask & SS_READY) reg |= I365_CSC_READY;
  291. }
  292. exca_writeb(socket, I365_CSCINT, reg);
  293. exca_readb(socket, I365_CSC);
  294. if(sock->zoom_video)
  295. sock->zoom_video(sock, state->flags & SS_ZVCARD);
  296. }
  297. config_writew(socket, CB_BRIDGE_CONTROL, bridge);
  298. /* Socket event mask: get card insert/remove events.. */
  299. cb_writel(socket, CB_SOCKET_EVENT, -1);
  300. cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK);
  301. /* if powering up: do it as the last step when the socket is configured */
  302. if (state->Vcc != 0)
  303. yenta_set_power(socket, state);
  304. return 0;
  305. }
  306. static int yenta_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io)
  307. {
  308. struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
  309. int map;
  310. unsigned char ioctl, addr, enable;
  311. map = io->map;
  312. if (map > 1)
  313. return -EINVAL;
  314. enable = I365_ENA_IO(map);
  315. addr = exca_readb(socket, I365_ADDRWIN);
  316. /* Disable the window before changing it.. */
  317. if (addr & enable) {
  318. addr &= ~enable;
  319. exca_writeb(socket, I365_ADDRWIN, addr);
  320. }
  321. exca_writew(socket, I365_IO(map)+I365_W_START, io->start);
  322. exca_writew(socket, I365_IO(map)+I365_W_STOP, io->stop);
  323. ioctl = exca_readb(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map);
  324. if (io->flags & MAP_0WS) ioctl |= I365_IOCTL_0WS(map);
  325. if (io->flags & MAP_16BIT) ioctl |= I365_IOCTL_16BIT(map);
  326. if (io->flags & MAP_AUTOSZ) ioctl |= I365_IOCTL_IOCS16(map);
  327. exca_writeb(socket, I365_IOCTL, ioctl);
  328. if (io->flags & MAP_ACTIVE)
  329. exca_writeb(socket, I365_ADDRWIN, addr | enable);
  330. return 0;
  331. }
  332. static int yenta_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem)
  333. {
  334. struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
  335. struct pci_bus_region region;
  336. int map;
  337. unsigned char addr, enable;
  338. unsigned int start, stop, card_start;
  339. unsigned short word;
  340. pcibios_resource_to_bus(socket->dev, &region, mem->res);
  341. map = mem->map;
  342. start = region.start;
  343. stop = region.end;
  344. card_start = mem->card_start;
  345. if (map > 4 || start > stop || ((start ^ stop) >> 24) ||
  346. (card_start >> 26) || mem->speed > 1000)
  347. return -EINVAL;
  348. enable = I365_ENA_MEM(map);
  349. addr = exca_readb(socket, I365_ADDRWIN);
  350. if (addr & enable) {
  351. addr &= ~enable;
  352. exca_writeb(socket, I365_ADDRWIN, addr);
  353. }
  354. exca_writeb(socket, CB_MEM_PAGE(map), start >> 24);
  355. word = (start >> 12) & 0x0fff;
  356. if (mem->flags & MAP_16BIT)
  357. word |= I365_MEM_16BIT;
  358. if (mem->flags & MAP_0WS)
  359. word |= I365_MEM_0WS;
  360. exca_writew(socket, I365_MEM(map) + I365_W_START, word);
  361. word = (stop >> 12) & 0x0fff;
  362. switch (to_cycles(mem->speed)) {
  363. case 0: break;
  364. case 1: word |= I365_MEM_WS0; break;
  365. case 2: word |= I365_MEM_WS1; break;
  366. default: word |= I365_MEM_WS1 | I365_MEM_WS0; break;
  367. }
  368. exca_writew(socket, I365_MEM(map) + I365_W_STOP, word);
  369. word = ((card_start - start) >> 12) & 0x3fff;
  370. if (mem->flags & MAP_WRPROT)
  371. word |= I365_MEM_WRPROT;
  372. if (mem->flags & MAP_ATTRIB)
  373. word |= I365_MEM_REG;
  374. exca_writew(socket, I365_MEM(map) + I365_W_OFF, word);
  375. if (mem->flags & MAP_ACTIVE)
  376. exca_writeb(socket, I365_ADDRWIN, addr | enable);
  377. return 0;
  378. }
  379. static irqreturn_t yenta_interrupt(int irq, void *dev_id)
  380. {
  381. unsigned int events;
  382. struct yenta_socket *socket = (struct yenta_socket *) dev_id;
  383. u8 csc;
  384. u32 cb_event;
  385. /* Clear interrupt status for the event */
  386. cb_event = cb_readl(socket, CB_SOCKET_EVENT);
  387. cb_writel(socket, CB_SOCKET_EVENT, cb_event);
  388. csc = exca_readb(socket, I365_CSC);
  389. if (!(cb_event || csc))
  390. return IRQ_NONE;
  391. events = (cb_event & (CB_CD1EVENT | CB_CD2EVENT)) ? SS_DETECT : 0 ;
  392. events |= (csc & I365_CSC_DETECT) ? SS_DETECT : 0;
  393. if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) {
  394. events |= (csc & I365_CSC_STSCHG) ? SS_STSCHG : 0;
  395. } else {
  396. events |= (csc & I365_CSC_BVD1) ? SS_BATDEAD : 0;
  397. events |= (csc & I365_CSC_BVD2) ? SS_BATWARN : 0;
  398. events |= (csc & I365_CSC_READY) ? SS_READY : 0;
  399. }
  400. if (events)
  401. pcmcia_parse_events(&socket->socket, events);
  402. return IRQ_HANDLED;
  403. }
  404. static void yenta_interrupt_wrapper(unsigned long data)
  405. {
  406. struct yenta_socket *socket = (struct yenta_socket *) data;
  407. yenta_interrupt(0, (void *)socket);
  408. socket->poll_timer.expires = jiffies + HZ;
  409. add_timer(&socket->poll_timer);
  410. }
  411. static void yenta_clear_maps(struct yenta_socket *socket)
  412. {
  413. int i;
  414. struct resource res = { .start = 0, .end = 0x0fff };
  415. pccard_io_map io = { 0, 0, 0, 0, 1 };
  416. pccard_mem_map mem = { .res = &res, };
  417. yenta_set_socket(&socket->socket, &dead_socket);
  418. for (i = 0; i < 2; i++) {
  419. io.map = i;
  420. yenta_set_io_map(&socket->socket, &io);
  421. }
  422. for (i = 0; i < 5; i++) {
  423. mem.map = i;
  424. yenta_set_mem_map(&socket->socket, &mem);
  425. }
  426. }
  427. /* redoes voltage interrogation if required */
  428. static void yenta_interrogate(struct yenta_socket *socket)
  429. {
  430. u32 state;
  431. state = cb_readl(socket, CB_SOCKET_STATE);
  432. if (!(state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) ||
  433. (state & (CB_CDETECT1 | CB_CDETECT2 | CB_NOTACARD | CB_BADVCCREQ)) ||
  434. ((state & (CB_16BITCARD | CB_CBCARD)) == (CB_16BITCARD | CB_CBCARD)))
  435. cb_writel(socket, CB_SOCKET_FORCE, CB_CVSTEST);
  436. }
  437. /* Called at resume and initialization events */
  438. static int yenta_sock_init(struct pcmcia_socket *sock)
  439. {
  440. struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
  441. exca_writeb(socket, I365_GBLCTL, 0x00);
  442. exca_writeb(socket, I365_GENCTL, 0x00);
  443. /* Redo card voltage interrogation */
  444. yenta_interrogate(socket);
  445. yenta_clear_maps(socket);
  446. if (socket->type && socket->type->sock_init)
  447. socket->type->sock_init(socket);
  448. /* Re-enable CSC interrupts */
  449. cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK);
  450. return 0;
  451. }
  452. static int yenta_sock_suspend(struct pcmcia_socket *sock)
  453. {
  454. struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
  455. /* Disable CSC interrupts */
  456. cb_writel(socket, CB_SOCKET_MASK, 0x0);
  457. return 0;
  458. }
  459. /*
  460. * Use an adaptive allocation for the memory resource,
  461. * sometimes the memory behind pci bridges is limited:
  462. * 1/8 of the size of the io window of the parent.
  463. * max 4 MB, min 16 kB. We try very hard to not get below
  464. * the "ACC" values, though.
  465. */
  466. #define BRIDGE_MEM_MAX 4*1024*1024
  467. #define BRIDGE_MEM_ACC 128*1024
  468. #define BRIDGE_MEM_MIN 16*1024
  469. #define BRIDGE_IO_MAX 512
  470. #define BRIDGE_IO_ACC 256
  471. #define BRIDGE_IO_MIN 32
  472. #ifndef PCIBIOS_MIN_CARDBUS_IO
  473. #define PCIBIOS_MIN_CARDBUS_IO PCIBIOS_MIN_IO
  474. #endif
  475. static int yenta_search_one_res(struct resource *root, struct resource *res,
  476. u32 min)
  477. {
  478. u32 align, size, start, end;
  479. if (res->flags & IORESOURCE_IO) {
  480. align = 1024;
  481. size = BRIDGE_IO_MAX;
  482. start = PCIBIOS_MIN_CARDBUS_IO;
  483. end = ~0U;
  484. } else {
  485. unsigned long avail = root->end - root->start;
  486. int i;
  487. size = BRIDGE_MEM_MAX;
  488. if (size > avail/8) {
  489. size=(avail+1)/8;
  490. /* round size down to next power of 2 */
  491. i = 0;
  492. while ((size /= 2) != 0)
  493. i++;
  494. size = 1 << i;
  495. }
  496. if (size < min)
  497. size = min;
  498. align = size;
  499. start = PCIBIOS_MIN_MEM;
  500. end = ~0U;
  501. }
  502. do {
  503. if (allocate_resource(root, res, size, start, end, align,
  504. NULL, NULL)==0) {
  505. return 1;
  506. }
  507. size = size/2;
  508. align = size;
  509. } while (size >= min);
  510. return 0;
  511. }
  512. static int yenta_search_res(struct yenta_socket *socket, struct resource *res,
  513. u32 min)
  514. {
  515. int i;
  516. for (i=0; i<PCI_BUS_NUM_RESOURCES; i++) {
  517. struct resource * root = socket->dev->bus->resource[i];
  518. if (!root)
  519. continue;
  520. if ((res->flags ^ root->flags) &
  521. (IORESOURCE_IO | IORESOURCE_MEM | IORESOURCE_PREFETCH))
  522. continue; /* Wrong type */
  523. if (yenta_search_one_res(root, res, min))
  524. return 1;
  525. }
  526. return 0;
  527. }
  528. static int yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned type, int addr_start, int addr_end)
  529. {
  530. struct resource *root, *res;
  531. struct pci_bus_region region;
  532. unsigned mask;
  533. res = socket->dev->resource + PCI_BRIDGE_RESOURCES + nr;
  534. /* Already allocated? */
  535. if (res->parent)
  536. return 0;
  537. /* The granularity of the memory limit is 4kB, on IO it's 4 bytes */
  538. mask = ~0xfff;
  539. if (type & IORESOURCE_IO)
  540. mask = ~3;
  541. res->name = socket->dev->subordinate->name;
  542. res->flags = type;
  543. region.start = config_readl(socket, addr_start) & mask;
  544. region.end = config_readl(socket, addr_end) | ~mask;
  545. if (region.start && region.end > region.start && !override_bios) {
  546. pcibios_bus_to_resource(socket->dev, res, &region);
  547. root = pci_find_parent_resource(socket->dev, res);
  548. if (root && (request_resource(root, res) == 0))
  549. return 0;
  550. printk(KERN_INFO "yenta %s: Preassigned resource %d busy or not available, reconfiguring...\n",
  551. pci_name(socket->dev), nr);
  552. }
  553. if (type & IORESOURCE_IO) {
  554. if ((yenta_search_res(socket, res, BRIDGE_IO_MAX)) ||
  555. (yenta_search_res(socket, res, BRIDGE_IO_ACC)) ||
  556. (yenta_search_res(socket, res, BRIDGE_IO_MIN)))
  557. return 1;
  558. } else {
  559. if (type & IORESOURCE_PREFETCH) {
  560. if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) ||
  561. (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) ||
  562. (yenta_search_res(socket, res, BRIDGE_MEM_MIN)))
  563. return 1;
  564. /* Approximating prefetchable by non-prefetchable */
  565. res->flags = IORESOURCE_MEM;
  566. }
  567. if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) ||
  568. (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) ||
  569. (yenta_search_res(socket, res, BRIDGE_MEM_MIN)))
  570. return 1;
  571. }
  572. printk(KERN_INFO "yenta %s: no resource of type %x available, trying to continue...\n",
  573. pci_name(socket->dev), type);
  574. res->start = res->end = res->flags = 0;
  575. return 0;
  576. }
  577. /*
  578. * Allocate the bridge mappings for the device..
  579. */
  580. static void yenta_allocate_resources(struct yenta_socket *socket)
  581. {
  582. int program = 0;
  583. program += yenta_allocate_res(socket, 0, IORESOURCE_IO,
  584. PCI_CB_IO_BASE_0, PCI_CB_IO_LIMIT_0);
  585. program += yenta_allocate_res(socket, 1, IORESOURCE_IO,
  586. PCI_CB_IO_BASE_1, PCI_CB_IO_LIMIT_1);
  587. program += yenta_allocate_res(socket, 2, IORESOURCE_MEM|IORESOURCE_PREFETCH,
  588. PCI_CB_MEMORY_BASE_0, PCI_CB_MEMORY_LIMIT_0);
  589. program += yenta_allocate_res(socket, 3, IORESOURCE_MEM,
  590. PCI_CB_MEMORY_BASE_1, PCI_CB_MEMORY_LIMIT_1);
  591. if (program)
  592. pci_setup_cardbus(socket->dev->subordinate);
  593. }
  594. /*
  595. * Free the bridge mappings for the device..
  596. */
  597. static void yenta_free_resources(struct yenta_socket *socket)
  598. {
  599. int i;
  600. for (i=0;i<4;i++) {
  601. struct resource *res;
  602. res = socket->dev->resource + PCI_BRIDGE_RESOURCES + i;
  603. if (res->start != 0 && res->end != 0)
  604. release_resource(res);
  605. res->start = res->end = res->flags = 0;
  606. }
  607. }
  608. /*
  609. * Close it down - release our resources and go home..
  610. */
  611. static void yenta_close(struct pci_dev *dev)
  612. {
  613. struct yenta_socket *sock = pci_get_drvdata(dev);
  614. /* Remove the register attributes */
  615. device_remove_file(&dev->dev, &dev_attr_yenta_registers);
  616. /* we don't want a dying socket registered */
  617. pcmcia_unregister_socket(&sock->socket);
  618. /* Disable all events so we don't die in an IRQ storm */
  619. cb_writel(sock, CB_SOCKET_MASK, 0x0);
  620. exca_writeb(sock, I365_CSCINT, 0);
  621. if (sock->cb_irq)
  622. free_irq(sock->cb_irq, sock);
  623. else
  624. del_timer_sync(&sock->poll_timer);
  625. if (sock->base)
  626. iounmap(sock->base);
  627. yenta_free_resources(sock);
  628. pci_release_regions(dev);
  629. pci_disable_device(dev);
  630. pci_set_drvdata(dev, NULL);
  631. }
  632. static struct pccard_operations yenta_socket_operations = {
  633. .init = yenta_sock_init,
  634. .suspend = yenta_sock_suspend,
  635. .get_status = yenta_get_status,
  636. .set_socket = yenta_set_socket,
  637. .set_io_map = yenta_set_io_map,
  638. .set_mem_map = yenta_set_mem_map,
  639. };
  640. #ifdef CONFIG_YENTA_TI
  641. #include "ti113x.h"
  642. #endif
  643. #ifdef CONFIG_YENTA_RICOH
  644. #include "ricoh.h"
  645. #endif
  646. #ifdef CONFIG_YENTA_TOSHIBA
  647. #include "topic.h"
  648. #endif
  649. #ifdef CONFIG_YENTA_O2
  650. #include "o2micro.h"
  651. #endif
  652. enum {
  653. CARDBUS_TYPE_DEFAULT = -1,
  654. CARDBUS_TYPE_TI,
  655. CARDBUS_TYPE_TI113X,
  656. CARDBUS_TYPE_TI12XX,
  657. CARDBUS_TYPE_TI1250,
  658. CARDBUS_TYPE_RICOH,
  659. CARDBUS_TYPE_TOPIC95,
  660. CARDBUS_TYPE_TOPIC97,
  661. CARDBUS_TYPE_O2MICRO,
  662. CARDBUS_TYPE_ENE,
  663. };
  664. /*
  665. * Different cardbus controllers have slightly different
  666. * initialization sequences etc details. List them here..
  667. */
  668. static struct cardbus_type cardbus_type[] = {
  669. #ifdef CONFIG_YENTA_TI
  670. [CARDBUS_TYPE_TI] = {
  671. .override = ti_override,
  672. .save_state = ti_save_state,
  673. .restore_state = ti_restore_state,
  674. .sock_init = ti_init,
  675. },
  676. [CARDBUS_TYPE_TI113X] = {
  677. .override = ti113x_override,
  678. .save_state = ti_save_state,
  679. .restore_state = ti_restore_state,
  680. .sock_init = ti_init,
  681. },
  682. [CARDBUS_TYPE_TI12XX] = {
  683. .override = ti12xx_override,
  684. .save_state = ti_save_state,
  685. .restore_state = ti_restore_state,
  686. .sock_init = ti_init,
  687. },
  688. [CARDBUS_TYPE_TI1250] = {
  689. .override = ti1250_override,
  690. .save_state = ti_save_state,
  691. .restore_state = ti_restore_state,
  692. .sock_init = ti_init,
  693. },
  694. #endif
  695. #ifdef CONFIG_YENTA_RICOH
  696. [CARDBUS_TYPE_RICOH] = {
  697. .override = ricoh_override,
  698. .save_state = ricoh_save_state,
  699. .restore_state = ricoh_restore_state,
  700. },
  701. #endif
  702. #ifdef CONFIG_YENTA_TOSHIBA
  703. [CARDBUS_TYPE_TOPIC95] = {
  704. .override = topic95_override,
  705. },
  706. [CARDBUS_TYPE_TOPIC97] = {
  707. .override = topic97_override,
  708. },
  709. #endif
  710. #ifdef CONFIG_YENTA_O2
  711. [CARDBUS_TYPE_O2MICRO] = {
  712. .override = o2micro_override,
  713. .restore_state = o2micro_restore_state,
  714. },
  715. #endif
  716. #ifdef CONFIG_YENTA_TI
  717. [CARDBUS_TYPE_ENE] = {
  718. .override = ene_override,
  719. .save_state = ti_save_state,
  720. .restore_state = ti_restore_state,
  721. .sock_init = ti_init,
  722. },
  723. #endif
  724. };
  725. /*
  726. * Only probe "regular" interrupts, don't
  727. * touch dangerous spots like the mouse irq,
  728. * because there are mice that apparently
  729. * get really confused if they get fondled
  730. * too intimately.
  731. *
  732. * Default to 11, 10, 9, 7, 6, 5, 4, 3.
  733. */
  734. static u32 isa_interrupts = 0x0ef8;
  735. static unsigned int yenta_probe_irq(struct yenta_socket *socket, u32 isa_irq_mask)
  736. {
  737. int i;
  738. unsigned long val;
  739. u32 mask;
  740. /*
  741. * Probe for usable interrupts using the force
  742. * register to generate bogus card status events.
  743. */
  744. cb_writel(socket, CB_SOCKET_EVENT, -1);
  745. cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK);
  746. exca_writeb(socket, I365_CSCINT, 0);
  747. val = probe_irq_on() & isa_irq_mask;
  748. for (i = 1; i < 16; i++) {
  749. if (!((val >> i) & 1))
  750. continue;
  751. exca_writeb(socket, I365_CSCINT, I365_CSC_STSCHG | (i << 4));
  752. cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS);
  753. udelay(100);
  754. cb_writel(socket, CB_SOCKET_EVENT, -1);
  755. }
  756. cb_writel(socket, CB_SOCKET_MASK, 0);
  757. exca_writeb(socket, I365_CSCINT, 0);
  758. mask = probe_irq_mask(val) & 0xffff;
  759. return mask;
  760. }
  761. /**
  762. * yenta PCI irq probing.
  763. * currently only used in the TI/EnE initialization code
  764. */
  765. #ifdef CONFIG_YENTA_TI
  766. /* interrupt handler, only used during probing */
  767. static irqreturn_t yenta_probe_handler(int irq, void *dev_id)
  768. {
  769. struct yenta_socket *socket = (struct yenta_socket *) dev_id;
  770. u8 csc;
  771. u32 cb_event;
  772. /* Clear interrupt status for the event */
  773. cb_event = cb_readl(socket, CB_SOCKET_EVENT);
  774. cb_writel(socket, CB_SOCKET_EVENT, -1);
  775. csc = exca_readb(socket, I365_CSC);
  776. if (cb_event || csc) {
  777. socket->probe_status = 1;
  778. return IRQ_HANDLED;
  779. }
  780. return IRQ_NONE;
  781. }
  782. /* probes the PCI interrupt, use only on override functions */
  783. static int yenta_probe_cb_irq(struct yenta_socket *socket)
  784. {
  785. if (!socket->cb_irq)
  786. return -1;
  787. socket->probe_status = 0;
  788. if (request_irq(socket->cb_irq, yenta_probe_handler, IRQF_SHARED, "yenta", socket)) {
  789. printk(KERN_WARNING "Yenta: request_irq() in yenta_probe_cb_irq() failed!\n");
  790. return -1;
  791. }
  792. /* generate interrupt, wait */
  793. exca_writeb(socket, I365_CSCINT, I365_CSC_STSCHG);
  794. cb_writel(socket, CB_SOCKET_EVENT, -1);
  795. cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK);
  796. cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS);
  797. msleep(100);
  798. /* disable interrupts */
  799. cb_writel(socket, CB_SOCKET_MASK, 0);
  800. exca_writeb(socket, I365_CSCINT, 0);
  801. cb_writel(socket, CB_SOCKET_EVENT, -1);
  802. exca_readb(socket, I365_CSC);
  803. free_irq(socket->cb_irq, socket);
  804. return (int) socket->probe_status;
  805. }
  806. #endif /* CONFIG_YENTA_TI */
  807. /*
  808. * Set static data that doesn't need re-initializing..
  809. */
  810. static void yenta_get_socket_capabilities(struct yenta_socket *socket, u32 isa_irq_mask)
  811. {
  812. socket->socket.pci_irq = socket->cb_irq;
  813. if (isa_probe)
  814. socket->socket.irq_mask = yenta_probe_irq(socket, isa_irq_mask);
  815. else
  816. socket->socket.irq_mask = 0;
  817. printk(KERN_INFO "Yenta: ISA IRQ mask 0x%04x, PCI irq %d\n",
  818. socket->socket.irq_mask, socket->cb_irq);
  819. }
  820. /*
  821. * Initialize the standard cardbus registers
  822. */
  823. static void yenta_config_init(struct yenta_socket *socket)
  824. {
  825. u16 bridge;
  826. struct pci_dev *dev = socket->dev;
  827. struct pci_bus_region region;
  828. pcibios_resource_to_bus(socket->dev, &region, &dev->resource[0]);
  829. config_writel(socket, CB_LEGACY_MODE_BASE, 0);
  830. config_writel(socket, PCI_BASE_ADDRESS_0, region.start);
  831. config_writew(socket, PCI_COMMAND,
  832. PCI_COMMAND_IO |
  833. PCI_COMMAND_MEMORY |
  834. PCI_COMMAND_MASTER |
  835. PCI_COMMAND_WAIT);
  836. /* MAGIC NUMBERS! Fixme */
  837. config_writeb(socket, PCI_CACHE_LINE_SIZE, L1_CACHE_BYTES / 4);
  838. config_writeb(socket, PCI_LATENCY_TIMER, 168);
  839. config_writel(socket, PCI_PRIMARY_BUS,
  840. (176 << 24) | /* sec. latency timer */
  841. (dev->subordinate->subordinate << 16) | /* subordinate bus */
  842. (dev->subordinate->secondary << 8) | /* secondary bus */
  843. dev->subordinate->primary); /* primary bus */
  844. /*
  845. * Set up the bridging state:
  846. * - enable write posting.
  847. * - memory window 0 prefetchable, window 1 non-prefetchable
  848. * - PCI interrupts enabled if a PCI interrupt exists..
  849. */
  850. bridge = config_readw(socket, CB_BRIDGE_CONTROL);
  851. bridge &= ~(CB_BRIDGE_CRST | CB_BRIDGE_PREFETCH1 | CB_BRIDGE_ISAEN | CB_BRIDGE_VGAEN);
  852. bridge |= CB_BRIDGE_PREFETCH0 | CB_BRIDGE_POSTEN;
  853. config_writew(socket, CB_BRIDGE_CONTROL, bridge);
  854. }
  855. /**
  856. * yenta_fixup_parent_bridge - Fix subordinate bus# of the parent bridge
  857. * @cardbus_bridge: The PCI bus which the CardBus bridge bridges to
  858. *
  859. * Checks if devices on the bus which the CardBus bridge bridges to would be
  860. * invisible during PCI scans because of a misconfigured subordinate number
  861. * of the parent brige - some BIOSes seem to be too lazy to set it right.
  862. * Does the fixup carefully by checking how far it can go without conflicts.
  863. * See http://bugzilla.kernel.org/show_bug.cgi?id=2944 for more information.
  864. */
  865. static void yenta_fixup_parent_bridge(struct pci_bus *cardbus_bridge)
  866. {
  867. struct list_head *tmp;
  868. unsigned char upper_limit;
  869. /*
  870. * We only check and fix the parent bridge: All systems which need
  871. * this fixup that have been reviewed are laptops and the only bridge
  872. * which needed fixing was the parent bridge of the CardBus bridge:
  873. */
  874. struct pci_bus *bridge_to_fix = cardbus_bridge->parent;
  875. /* Check bus numbers are already set up correctly: */
  876. if (bridge_to_fix->subordinate >= cardbus_bridge->subordinate)
  877. return; /* The subordinate number is ok, nothing to do */
  878. if (!bridge_to_fix->parent)
  879. return; /* Root bridges are ok */
  880. /* stay within the limits of the bus range of the parent: */
  881. upper_limit = bridge_to_fix->parent->subordinate;
  882. /* check the bus ranges of all silbling bridges to prevent overlap */
  883. list_for_each(tmp, &bridge_to_fix->parent->children) {
  884. struct pci_bus * silbling = pci_bus_b(tmp);
  885. /*
  886. * If the silbling has a higher secondary bus number
  887. * and it's secondary is equal or smaller than our
  888. * current upper limit, set the new upper limit to
  889. * the bus number below the silbling's range:
  890. */
  891. if (silbling->secondary > bridge_to_fix->subordinate
  892. && silbling->secondary <= upper_limit)
  893. upper_limit = silbling->secondary - 1;
  894. }
  895. /* Show that the wanted subordinate number is not possible: */
  896. if (cardbus_bridge->subordinate > upper_limit)
  897. printk(KERN_WARNING "Yenta: Upper limit for fixing this "
  898. "bridge's parent bridge: #%02x\n", upper_limit);
  899. /* If we have room to increase the bridge's subordinate number, */
  900. if (bridge_to_fix->subordinate < upper_limit) {
  901. /* use the highest number of the hidden bus, within limits */
  902. unsigned char subordinate_to_assign =
  903. min(cardbus_bridge->subordinate, upper_limit);
  904. printk(KERN_INFO "Yenta: Raising subordinate bus# of parent "
  905. "bus (#%02x) from #%02x to #%02x\n",
  906. bridge_to_fix->number,
  907. bridge_to_fix->subordinate, subordinate_to_assign);
  908. /* Save the new subordinate in the bus struct of the bridge */
  909. bridge_to_fix->subordinate = subordinate_to_assign;
  910. /* and update the PCI config space with the new subordinate */
  911. pci_write_config_byte(bridge_to_fix->self,
  912. PCI_SUBORDINATE_BUS, bridge_to_fix->subordinate);
  913. }
  914. }
  915. /*
  916. * Initialize a cardbus controller. Make sure we have a usable
  917. * interrupt, and that we can map the cardbus area. Fill in the
  918. * socket information structure..
  919. */
  920. static int __devinit yenta_probe (struct pci_dev *dev, const struct pci_device_id *id)
  921. {
  922. struct yenta_socket *socket;
  923. int ret;
  924. /*
  925. * If we failed to assign proper bus numbers for this cardbus
  926. * controller during PCI probe, its subordinate pci_bus is NULL.
  927. * Bail out if so.
  928. */
  929. if (!dev->subordinate) {
  930. printk(KERN_ERR "Yenta: no bus associated with %s! "
  931. "(try 'pci=assign-busses')\n", pci_name(dev));
  932. return -ENODEV;
  933. }
  934. socket = kzalloc(sizeof(struct yenta_socket), GFP_KERNEL);
  935. if (!socket)
  936. return -ENOMEM;
  937. /* prepare pcmcia_socket */
  938. socket->socket.ops = &yenta_socket_operations;
  939. socket->socket.resource_ops = &pccard_nonstatic_ops;
  940. socket->socket.dev.parent = &dev->dev;
  941. socket->socket.driver_data = socket;
  942. socket->socket.owner = THIS_MODULE;
  943. socket->socket.features = SS_CAP_PAGE_REGS | SS_CAP_PCCARD;
  944. socket->socket.map_size = 0x1000;
  945. socket->socket.cb_dev = dev;
  946. /* prepare struct yenta_socket */
  947. socket->dev = dev;
  948. pci_set_drvdata(dev, socket);
  949. /*
  950. * Do some basic sanity checking..
  951. */
  952. if (pci_enable_device(dev)) {
  953. ret = -EBUSY;
  954. goto free;
  955. }
  956. ret = pci_request_regions(dev, "yenta_socket");
  957. if (ret)
  958. goto disable;
  959. if (!pci_resource_start(dev, 0)) {
  960. printk(KERN_ERR "No cardbus resource!\n");
  961. ret = -ENODEV;
  962. goto release;
  963. }
  964. /*
  965. * Ok, start setup.. Map the cardbus registers,
  966. * and request the IRQ.
  967. */
  968. socket->base = ioremap(pci_resource_start(dev, 0), 0x1000);
  969. if (!socket->base) {
  970. ret = -ENOMEM;
  971. goto release;
  972. }
  973. /*
  974. * report the subsystem vendor and device for help debugging
  975. * the irq stuff...
  976. */
  977. printk(KERN_INFO "Yenta: CardBus bridge found at %s [%04x:%04x]\n",
  978. pci_name(dev), dev->subsystem_vendor, dev->subsystem_device);
  979. yenta_config_init(socket);
  980. /* Disable all events */
  981. cb_writel(socket, CB_SOCKET_MASK, 0x0);
  982. /* Set up the bridge regions.. */
  983. yenta_allocate_resources(socket);
  984. socket->cb_irq = dev->irq;
  985. /* Do we have special options for the device? */
  986. if (id->driver_data != CARDBUS_TYPE_DEFAULT &&
  987. id->driver_data < ARRAY_SIZE(cardbus_type)) {
  988. socket->type = &cardbus_type[id->driver_data];
  989. ret = socket->type->override(socket);
  990. if (ret < 0)
  991. goto unmap;
  992. }
  993. /* We must finish initialization here */
  994. if (!socket->cb_irq || request_irq(socket->cb_irq, yenta_interrupt, IRQF_SHARED, "yenta", socket)) {
  995. /* No IRQ or request_irq failed. Poll */
  996. socket->cb_irq = 0; /* But zero is a valid IRQ number. */
  997. init_timer(&socket->poll_timer);
  998. socket->poll_timer.function = yenta_interrupt_wrapper;
  999. socket->poll_timer.data = (unsigned long)socket;
  1000. socket->poll_timer.expires = jiffies + HZ;
  1001. add_timer(&socket->poll_timer);
  1002. printk(KERN_INFO "Yenta: no PCI IRQ, CardBus support disabled for this socket.\n"
  1003. KERN_INFO "Yenta: check your BIOS CardBus, BIOS IRQ or ACPI settings.\n");
  1004. } else {
  1005. socket->socket.features |= SS_CAP_CARDBUS;
  1006. }
  1007. /* Figure out what the dang thing can do for the PCMCIA layer... */
  1008. yenta_interrogate(socket);
  1009. yenta_get_socket_capabilities(socket, isa_interrupts);
  1010. printk(KERN_INFO "Socket status: %08x\n", cb_readl(socket, CB_SOCKET_STATE));
  1011. yenta_fixup_parent_bridge(dev->subordinate);
  1012. /* Register it with the pcmcia layer.. */
  1013. ret = pcmcia_register_socket(&socket->socket);
  1014. if (ret == 0) {
  1015. /* Add the yenta register attributes */
  1016. ret = device_create_file(&dev->dev, &dev_attr_yenta_registers);
  1017. if (ret == 0)
  1018. goto out;
  1019. /* error path... */
  1020. pcmcia_unregister_socket(&socket->socket);
  1021. }
  1022. unmap:
  1023. iounmap(socket->base);
  1024. release:
  1025. pci_release_regions(dev);
  1026. disable:
  1027. pci_disable_device(dev);
  1028. free:
  1029. kfree(socket);
  1030. out:
  1031. return ret;
  1032. }
  1033. #ifdef CONFIG_PM
  1034. static int yenta_dev_suspend (struct pci_dev *dev, pm_message_t state)
  1035. {
  1036. struct yenta_socket *socket = pci_get_drvdata(dev);
  1037. int ret;
  1038. ret = pcmcia_socket_dev_suspend(&dev->dev, state);
  1039. if (socket) {
  1040. if (socket->type && socket->type->save_state)
  1041. socket->type->save_state(socket);
  1042. /* FIXME: pci_save_state needs to have a better interface */
  1043. pci_save_state(dev);
  1044. pci_read_config_dword(dev, 16*4, &socket->saved_state[0]);
  1045. pci_read_config_dword(dev, 17*4, &socket->saved_state[1]);
  1046. pci_disable_device(dev);
  1047. /*
  1048. * Some laptops (IBM T22) do not like us putting the Cardbus
  1049. * bridge into D3. At a guess, some other laptop will
  1050. * probably require this, so leave it commented out for now.
  1051. */
  1052. /* pci_set_power_state(dev, 3); */
  1053. }
  1054. return ret;
  1055. }
  1056. static int yenta_dev_resume (struct pci_dev *dev)
  1057. {
  1058. struct yenta_socket *socket = pci_get_drvdata(dev);
  1059. if (socket) {
  1060. int rc;
  1061. pci_set_power_state(dev, 0);
  1062. /* FIXME: pci_restore_state needs to have a better interface */
  1063. pci_restore_state(dev);
  1064. pci_write_config_dword(dev, 16*4, socket->saved_state[0]);
  1065. pci_write_config_dword(dev, 17*4, socket->saved_state[1]);
  1066. rc = pci_enable_device(dev);
  1067. if (rc)
  1068. return rc;
  1069. pci_set_master(dev);
  1070. if (socket->type && socket->type->restore_state)
  1071. socket->type->restore_state(socket);
  1072. }
  1073. return pcmcia_socket_dev_resume(&dev->dev);
  1074. }
  1075. #endif
  1076. #define CB_ID(vend,dev,type) \
  1077. { \
  1078. .vendor = vend, \
  1079. .device = dev, \
  1080. .subvendor = PCI_ANY_ID, \
  1081. .subdevice = PCI_ANY_ID, \
  1082. .class = PCI_CLASS_BRIDGE_CARDBUS << 8, \
  1083. .class_mask = ~0, \
  1084. .driver_data = CARDBUS_TYPE_##type, \
  1085. }
  1086. static struct pci_device_id yenta_table [] = {
  1087. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1031, TI),
  1088. /*
  1089. * TBD: Check if these TI variants can use more
  1090. * advanced overrides instead. (I can't get the
  1091. * data sheets for these devices. --rmk)
  1092. */
  1093. #ifdef CONFIG_YENTA_TI
  1094. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1210, TI),
  1095. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1130, TI113X),
  1096. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1131, TI113X),
  1097. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1211, TI12XX),
  1098. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1220, TI12XX),
  1099. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1221, TI12XX),
  1100. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1225, TI12XX),
  1101. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251A, TI12XX),
  1102. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251B, TI12XX),
  1103. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1420, TI12XX),
  1104. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1450, TI12XX),
  1105. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1451A, TI12XX),
  1106. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1510, TI12XX),
  1107. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1520, TI12XX),
  1108. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1620, TI12XX),
  1109. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4410, TI12XX),
  1110. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4450, TI12XX),
  1111. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4451, TI12XX),
  1112. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4510, TI12XX),
  1113. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4520, TI12XX),
  1114. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1250, TI1250),
  1115. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1410, TI1250),
  1116. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX21_XX11, TI12XX),
  1117. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X515, TI12XX),
  1118. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX12, TI12XX),
  1119. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X420, TI12XX),
  1120. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X620, TI12XX),
  1121. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7410, TI12XX),
  1122. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7510, TI12XX),
  1123. CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7610, TI12XX),
  1124. CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_710, TI12XX),
  1125. CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_712, TI12XX),
  1126. CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_720, TI12XX),
  1127. CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_722, TI12XX),
  1128. CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1211, ENE),
  1129. CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1225, ENE),
  1130. CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1410, ENE),
  1131. CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1420, ENE),
  1132. #endif /* CONFIG_YENTA_TI */
  1133. #ifdef CONFIG_YENTA_RICOH
  1134. CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C465, RICOH),
  1135. CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C466, RICOH),
  1136. CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C475, RICOH),
  1137. CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476, RICOH),
  1138. CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C478, RICOH),
  1139. #endif
  1140. #ifdef CONFIG_YENTA_TOSHIBA
  1141. CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC95, TOPIC95),
  1142. CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC97, TOPIC97),
  1143. CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC100, TOPIC97),
  1144. #endif
  1145. #ifdef CONFIG_YENTA_O2
  1146. CB_ID(PCI_VENDOR_ID_O2, PCI_ANY_ID, O2MICRO),
  1147. #endif
  1148. /* match any cardbus bridge */
  1149. CB_ID(PCI_ANY_ID, PCI_ANY_ID, DEFAULT),
  1150. { /* all zeroes */ }
  1151. };
  1152. MODULE_DEVICE_TABLE(pci, yenta_table);
  1153. static struct pci_driver yenta_cardbus_driver = {
  1154. .name = "yenta_cardbus",
  1155. .id_table = yenta_table,
  1156. .probe = yenta_probe,
  1157. .remove = __devexit_p(yenta_close),
  1158. #ifdef CONFIG_PM
  1159. .suspend = yenta_dev_suspend,
  1160. .resume = yenta_dev_resume,
  1161. #endif
  1162. };
  1163. static int __init yenta_socket_init(void)
  1164. {
  1165. return pci_register_driver (&yenta_cardbus_driver);
  1166. }
  1167. static void __exit yenta_socket_exit (void)
  1168. {
  1169. pci_unregister_driver (&yenta_cardbus_driver);
  1170. }
  1171. module_init(yenta_socket_init);
  1172. module_exit(yenta_socket_exit);
  1173. MODULE_LICENSE("GPL");