git.baikalelectronics.ru Git

1 /*

3 *

4 * Author: Tony Li <tony.li@freescale.com>

5 * Jason Jin <Jason.jin@freescale.com>

6 *

7 * The hwirq alloc and free code reuse from sysdev/mpic_msi.c

8 *

9 * This program is free software; you can redistribute it and/or

10 * modify it under the terms of the GNU General Public License

11 * as published by the Free Software Foundation; version 2 of the

12 * License.

13 *

14 */

15 #include <linux/irq.h>

16 #include <linux/bootmem.h>

17 #include <linux/msi.h>

18 #include <linux/pci.h>

19 #include <linux/slab.h>

20 #include <linux/of_platform.h>

21 #include <sysdev/fsl_soc.h>

22 #include <asm/prom.h>

23 #include <asm/hw_irq.h>

24 #include <asm/ppc-pci.h>

25 #include <asm/mpic.h>

26 #include "fsl_msi.h"

28 LIST_HEAD(msi_head);

30 struct fsl_msi_feature {

31 u32 fsl_pic_ip;

32 u32 msiir_offset;

33 };

35 struct fsl_msi_cascade_data {

36 struct fsl_msi *msi_data;

37 int index;

38 };

40 static inline u32 fsl_msi_read(u32 __iomem *base, unsigned int reg)

41 {

42 return in_be32(base + (reg >> 2));

43 }

45 /*

46 * We do not need this actually. The MSIR register has been read once

47 * in the cascade interrupt. So, this MSI interrupt has been acked

48 */

49 static void fsl_msi_end_irq(unsigned int virq)

50 {

51 }

53 static struct irq_chip fsl_msi_chip = {

54 .mask = mask_msi_irq,

55 .unmask = unmask_msi_irq,

56 .ack = fsl_msi_end_irq,

57 .name = "FSL-MSI",

58 };

60 static int fsl_msi_host_map(struct irq_host *h, unsigned int virq,

61 irq_hw_number_t hw)

62 {

63 struct fsl_msi *msi_data = h->host_data;

64 struct irq_chip *chip = &fsl_msi_chip;

66 irq_to_desc(virq)->status |= IRQ_TYPE_EDGE_FALLING;

68 set_irq_chip_data(virq, msi_data);

69 set_irq_chip_and_handler(virq, chip, handle_edge_irq);

71 return 0;

72 }

74 static struct irq_host_ops fsl_msi_host_ops = {

75 .map = fsl_msi_host_map,

76 };

78 static int fsl_msi_init_allocator(struct fsl_msi *msi_data)

79 {

80 int rc;

82 rc = msi_bitmap_alloc(&msi_data->bitmap, NR_MSI_IRQS,

83 msi_data->irqhost->of_node);

84 if (rc)

85 return rc;

87 rc = msi_bitmap_reserve_dt_hwirqs(&msi_data->bitmap);

88 if (rc < 0) {

89 msi_bitmap_free(&msi_data->bitmap);

90 return rc;

91 }

93 return 0;

94 }

96 static int fsl_msi_check_device(struct pci_dev *pdev, int nvec, int type)

97 {

98 if (type == PCI_CAP_ID_MSIX)

99 pr_debug("fslmsi: MSI-X untested, trying anyway.\n");

100

101 return 0;

102 }

103

104 static void fsl_teardown_msi_irqs(struct pci_dev *pdev)

105 {

106 struct msi_desc *entry;

107 struct fsl_msi *msi_data;

108

109 list_for_each_entry(entry, &pdev->msi_list, list) {

110 if (entry->irq == NO_IRQ)

111 continue;

112 msi_data = get_irq_data(entry->irq);

113 set_irq_msi(entry->irq, NULL);

114 msi_bitmap_free_hwirqs(&msi_data->bitmap,

115 virq_to_hw(entry->irq), 1);

116 irq_dispose_mapping(entry->irq);

117 }

118

119 return;

120 }

121

122 static void fsl_compose_msi_msg(struct pci_dev *pdev, int hwirq,

123 struct msi_msg *msg,

124 struct fsl_msi *fsl_msi_data)

125 {

126 struct fsl_msi *msi_data = fsl_msi_data;

127 struct pci_controller *hose = pci_bus_to_host(pdev->bus);

128 u32 base = 0;

129

130 pci_bus_read_config_dword(hose->bus,

131 PCI_DEVFN(0, 0), PCI_BASE_ADDRESS_0, &base);

132

133 msg->address_lo = msi_data->msi_addr_lo + base;

134 msg->address_hi = msi_data->msi_addr_hi;

135 msg->data = hwirq;

136

137 pr_debug("%s: allocated srs: %d, ibs: %d\n",

138 __func__, hwirq / IRQS_PER_MSI_REG, hwirq % IRQS_PER_MSI_REG);

139 }

140

141 static int fsl_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)

142 {

143 int rc, hwirq = -ENOMEM;

144 unsigned int virq;

145 struct msi_desc *entry;

146 struct msi_msg msg;

147 struct fsl_msi *msi_data;

148

149 list_for_each_entry(entry, &pdev->msi_list, list) {

150 list_for_each_entry(msi_data, &msi_head, list) {

151 hwirq = msi_bitmap_alloc_hwirqs(&msi_data->bitmap, 1);

152 if (hwirq >= 0)

153 break;

154 }

155

156 if (hwirq < 0) {

157 rc = hwirq;

158 pr_debug("%s: fail allocating msi interrupt\n",

159 __func__);

160 goto out_free;

161 }

162

163 virq = irq_create_mapping(msi_data->irqhost, hwirq);

164

165 if (virq == NO_IRQ) {

166 pr_debug("%s: fail mapping hwirq 0x%x\n",

167 __func__, hwirq);

168 msi_bitmap_free_hwirqs(&msi_data->bitmap, hwirq, 1);

169 rc = -ENOSPC;

170 goto out_free;

171 }

172 set_irq_data(virq, msi_data);

173 set_irq_msi(virq, entry);

174

175 fsl_compose_msi_msg(pdev, hwirq, &msg, msi_data);

176 write_msi_msg(virq, &msg);

177 }

178 return 0;

179

180 out_free:

181 /* free by the caller of this function */

182 return rc;

183 }

184

185 static void fsl_msi_cascade(unsigned int irq, struct irq_desc *desc)

186 {

187 unsigned int cascade_irq;

188 struct fsl_msi *msi_data;

189 int msir_index = -1;

190 u32 msir_value = 0;

191 u32 intr_index;

192 u32 have_shift = 0;

193 struct fsl_msi_cascade_data *cascade_data;

194

195 cascade_data = (struct fsl_msi_cascade_data *)get_irq_data(irq);

196 msi_data = cascade_data->msi_data;

197

198 raw_spin_lock(&desc->lock);

199 if ((msi_data->feature & FSL_PIC_IP_MASK) == FSL_PIC_IP_IPIC) {

200 if (desc->chip->mask_ack)

201 desc->chip->mask_ack(irq);

202 else {

203 desc->chip->mask(irq);

204 desc->chip->ack(irq);

205 }

206 }

207

208 if (unlikely(desc->status & IRQ_INPROGRESS))

209 goto unlock;

210

211 msir_index = cascade_data->index;

212

213 if (msir_index >= NR_MSI_REG)

214 cascade_irq = NO_IRQ;

215

216 desc->status |= IRQ_INPROGRESS;

217 switch (msi_data->feature & FSL_PIC_IP_MASK) {

218 case FSL_PIC_IP_MPIC:

219 msir_value = fsl_msi_read(msi_data->msi_regs,

220 msir_index * 0x10);

221 break;

222 case FSL_PIC_IP_IPIC:

223 msir_value = fsl_msi_read(msi_data->msi_regs, msir_index * 0x4);

224 break;

225 }

226

227 while (msir_value) {

228 intr_index = ffs(msir_value) - 1;

229

230 cascade_irq = irq_linear_revmap(msi_data->irqhost,

231 msir_index * IRQS_PER_MSI_REG +

232 intr_index + have_shift);

233 if (cascade_irq != NO_IRQ)

234 generic_handle_irq(cascade_irq);

235 have_shift += intr_index + 1;

236 msir_value = msir_value >> (intr_index + 1);

237 }

238 desc->status &= ~IRQ_INPROGRESS;

239

240 switch (msi_data->feature & FSL_PIC_IP_MASK) {

241 case FSL_PIC_IP_MPIC:

242 desc->chip->eoi(irq);

243 break;

244 case FSL_PIC_IP_IPIC:

245 if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)

246 desc->chip->unmask(irq);

247 break;

248 }

249 unlock:

250 raw_spin_unlock(&desc->lock);

251 }

252

253 static int __devinit fsl_of_msi_probe(struct of_device *dev,

254 const struct of_device_id *match)

255 {

256 struct fsl_msi *msi;

257 struct resource res;

258 int err, i, count;

259 int rc;

260 int virt_msir;

261 const u32 *p;

262 struct fsl_msi_feature *features = match->data;

263 struct fsl_msi_cascade_data *cascade_data = NULL;

264

265 printk(KERN_DEBUG "Setting up Freescale MSI support\n");

266

267 msi = kzalloc(sizeof(struct fsl_msi), GFP_KERNEL);

268 if (!msi) {

269 dev_err(&dev->dev, "No memory for MSI structure\n");

270 err = -ENOMEM;

271 goto error_out;

272 }

273

274 msi->irqhost = irq_alloc_host(dev->node, IRQ_HOST_MAP_LINEAR,

275 NR_MSI_IRQS, &fsl_msi_host_ops, 0);

276

277 if (msi->irqhost == NULL) {

278 dev_err(&dev->dev, "No memory for MSI irqhost\n");

279 err = -ENOMEM;

280 goto error_out;

281 }

282

283 /* Get the MSI reg base */

284 err = of_address_to_resource(dev->node, 0, &res);

285 if (err) {

286 dev_err(&dev->dev, "%s resource error!\n",

287 dev->node->full_name);

288 goto error_out;

289 }

290

291 msi->msi_regs = ioremap(res.start, res.end - res.start + 1);

292 if (!msi->msi_regs) {

293 dev_err(&dev->dev, "ioremap problem failed\n");

294 goto error_out;

295 }

296

297 msi->feature = features->fsl_pic_ip;

298

299 msi->irqhost->host_data = msi;

300

301 msi->msi_addr_hi = 0x0;

302 msi->msi_addr_lo = features->msiir_offset + (res.start & 0xfffff);

303

304 rc = fsl_msi_init_allocator(msi);

305 if (rc) {

306 dev_err(&dev->dev, "Error allocating MSI bitmap\n");

307 goto error_out;

308 }

309

310 p = of_get_property(dev->node, "interrupts", &count);

311 if (!p) {

312 dev_err(&dev->dev, "no interrupts property found on %s\n",

313 dev->node->full_name);

314 err = -ENODEV;

315 goto error_out;

316 }

317 if (count % 8 != 0) {

318 dev_err(&dev->dev, "Malformed interrupts property on %s\n",

319 dev->node->full_name);

320 err = -EINVAL;

321 goto error_out;

322 }

323

324 count /= sizeof(u32);

325 for (i = 0; i < count / 2; i++) {

326 if (i > NR_MSI_REG)

327 break;

328 virt_msir = irq_of_parse_and_map(dev->node, i);

329 if (virt_msir != NO_IRQ) {

330 cascade_data = kzalloc(

331 sizeof(struct fsl_msi_cascade_data),

332 GFP_KERNEL);

333 if (!cascade_data) {

334 dev_err(&dev->dev,

335 "No memory for MSI cascade data\n");

336 err = -ENOMEM;

337 goto error_out;

338 }

339 cascade_data->index = i;

340 cascade_data->msi_data = msi;

341 set_irq_data(virt_msir, (void *)cascade_data);

342 set_irq_chained_handler(virt_msir, fsl_msi_cascade);

343 }

344 }

345

346 list_add_tail(&msi->list, &msi_head);

347

348 /* The multiple setting ppc_md.setup_msi_irqs will not harm things */

349 if (!ppc_md.setup_msi_irqs) {

350 ppc_md.setup_msi_irqs = fsl_setup_msi_irqs;

351 ppc_md.teardown_msi_irqs = fsl_teardown_msi_irqs;

352 ppc_md.msi_check_device = fsl_msi_check_device;

353 } else if (ppc_md.setup_msi_irqs != fsl_setup_msi_irqs) {

354 dev_err(&dev->dev, "Different MSI driver already installed!\n");

355 err = -ENODEV;

356 goto error_out;

357 }

358 return 0;

359 error_out:

360 kfree(msi);

361 return err;

362 }

363

364 static const struct fsl_msi_feature mpic_msi_feature = {

365 .fsl_pic_ip = FSL_PIC_IP_MPIC,

366 .msiir_offset = 0x140,

367 };

368

369 static const struct fsl_msi_feature ipic_msi_feature = {

370 .fsl_pic_ip = FSL_PIC_IP_IPIC,

371 .msiir_offset = 0x38,

372 };

373

374 static const struct of_device_id fsl_of_msi_ids[] = {

375 {

376 .compatible = "fsl,mpic-msi",

377 .data = (void *)&mpic_msi_feature,

378 },

379 {

380 .compatible = "fsl,ipic-msi",

381 .data = (void *)&ipic_msi_feature,

382 },

383 {}

384 };

385

386 static struct of_platform_driver fsl_of_msi_driver = {

387 .name = "fsl-msi",

388 .match_table = fsl_of_msi_ids,

389 .probe = fsl_of_msi_probe,

390 };

391

392 static __init int fsl_of_msi_init(void)

393 {

394 return of_register_platform_driver(&fsl_of_msi_driver);

395 }

396

397 subsys_initcall(fsl_of_msi_init);