1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * i2sbus driver 4 * 5 * Copyright 2006-2008 Johannes Berg <johannes@sipsolutions.net> 6 */ 7 8 #include <linux/module.h> 9 #include <linux/slab.h> 10 #include <linux/pci.h> 11 #include <linux/interrupt.h> 12 #include <linux/dma-mapping.h> 13 #include <linux/of_address.h> 14 #include <linux/of_irq.h> 15 16 #include <sound/core.h> 17 18 #include <asm/macio.h> 19 #include <asm/dbdma.h> 20 21 #include "../soundbus.h" 22 #include "i2sbus.h" 23 24 MODULE_LICENSE("GPL"); 25 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>"); 26 MODULE_DESCRIPTION("Apple Soundbus: I2S support"); 27 28 static int force; 29 module_param(force, int, 0444); 30 MODULE_PARM_DESC(force, "Force loading i2sbus even when" 31 " no layout-id property is present"); 32 33 static const struct of_device_id i2sbus_match[] = { 34 { .name = "i2s" }, 35 { } 36 }; 37 38 MODULE_DEVICE_TABLE(of, i2sbus_match); 39 40 static int alloc_dbdma_descriptor_ring(struct i2sbus_dev *i2sdev, 41 struct dbdma_command_mem *r, 42 int numcmds) 43 { 44 /* one more for rounding, one for branch back, one for stop command */ 45 r->size = (numcmds + 3) * sizeof(struct dbdma_cmd); 46 /* We use the PCI APIs for now until the generic one gets fixed 47 * enough or until we get some macio-specific versions 48 */ 49 r->space = dma_alloc_coherent(&macio_get_pci_dev(i2sdev->macio)->dev, 50 r->size, &r->bus_addr, GFP_KERNEL); 51 if (!r->space) 52 return -ENOMEM; 53 54 r->cmds = (void*)DBDMA_ALIGN(r->space); 55 r->bus_cmd_start = r->bus_addr + 56 (dma_addr_t)((char*)r->cmds - (char*)r->space); 57 58 return 0; 59 } 60 61 static void free_dbdma_descriptor_ring(struct i2sbus_dev *i2sdev, 62 struct dbdma_command_mem *r) 63 { 64 if (!r->space) return; 65 66 dma_free_coherent(&macio_get_pci_dev(i2sdev->macio)->dev, 67 r->size, r->space, r->bus_addr); 68 } 69 70 static void i2sbus_release_dev(struct device *dev) 71 { 72 struct i2sbus_dev *i2sdev; 73 int i; 74 75 i2sdev = container_of(dev, struct i2sbus_dev, sound.ofdev.dev); 76 iounmap(i2sdev->intfregs); 77 iounmap(i2sdev->out.dbdma); 78 iounmap(i2sdev->in.dbdma); 79 for (i = aoa_resource_i2smmio; i <= aoa_resource_rxdbdma; i++) 80 release_and_free_resource(i2sdev->allocated_resource[i]); 81 free_dbdma_descriptor_ring(i2sdev, &i2sdev->out.dbdma_ring); 82 free_dbdma_descriptor_ring(i2sdev, &i2sdev->in.dbdma_ring); 83 for (i = aoa_resource_i2smmio; i <= aoa_resource_rxdbdma; i++) 84 free_irq(i2sdev->interrupts[i], i2sdev); 85 i2sbus_control_remove_dev(i2sdev->control, i2sdev); 86 mutex_destroy(&i2sdev->lock); 87 kfree(i2sdev); 88 } 89 90 static irqreturn_t i2sbus_bus_intr(int irq, void *devid) 91 { 92 struct i2sbus_dev *dev = devid; 93 u32 intreg; 94 95 spin_lock(&dev->low_lock); 96 intreg = in_le32(&dev->intfregs->intr_ctl); 97 98 /* acknowledge interrupt reasons */ 99 out_le32(&dev->intfregs->intr_ctl, intreg); 100 101 spin_unlock(&dev->low_lock); 102 103 return IRQ_HANDLED; 104 } 105 106 107 /* 108 * XXX FIXME: We test the layout_id's here to get the proper way of 109 * mapping in various registers, thanks to bugs in Apple device-trees. 110 * We could instead key off the machine model and the name of the i2s 111 * node (i2s-a). This we'll do when we move it all to macio_asic.c 112 * and have that export items for each sub-node too. 113 */ 114 static int i2sbus_get_and_fixup_rsrc(struct device_node *np, int index, 115 int layout, struct resource *res) 116 { 117 struct device_node *parent; 118 int pindex, rc = -ENXIO; 119 const u32 *reg; 120 121 /* Machines with layout 76 and 36 (K2 based) have a weird device 122 * tree what we need to special case. 123 * Normal machines just fetch the resource from the i2s-X node. 124 * Darwin further divides normal machines into old and new layouts 125 * with a subtely different code path but that doesn't seem necessary 126 * in practice, they just bloated it. In addition, even on our K2 127 * case the i2s-modem node, if we ever want to handle it, uses the 128 * normal layout 129 */ 130 if (layout != 76 && layout != 36) 131 return of_address_to_resource(np, index, res); 132 133 parent = of_get_parent(np); 134 pindex = (index == aoa_resource_i2smmio) ? 0 : 1; 135 rc = of_address_to_resource(parent, pindex, res); 136 if (rc) 137 goto bail; 138 reg = of_get_property(np, "reg", NULL); 139 if (reg == NULL) { 140 rc = -ENXIO; 141 goto bail; 142 } 143 res->start += reg[index * 2]; 144 res->end = res->start + reg[index * 2 + 1] - 1; 145 bail: 146 of_node_put(parent); 147 return rc; 148 } 149 150 /* Returns 1 if added, 0 for otherwise; don't return a negative value! */ 151 /* FIXME: look at device node refcounting */ 152 static int i2sbus_add_dev(struct macio_dev *macio, 153 struct i2sbus_control *control, 154 struct device_node *np) 155 { 156 struct i2sbus_dev *dev; 157 struct device_node *child, *sound = NULL; 158 struct resource *r; 159 int i, layout = 0, rlen, ok = force; 160 char node_name[6]; 161 static const char *rnames[] = { "i2sbus: %pOFn (control)", 162 "i2sbus: %pOFn (tx)", 163 "i2sbus: %pOFn (rx)" }; 164 static const irq_handler_t ints[] = { 165 i2sbus_bus_intr, 166 i2sbus_tx_intr, 167 i2sbus_rx_intr 168 }; 169 170 if (snprintf(node_name, sizeof(node_name), "%pOFn", np) != 5) 171 return 0; 172 if (strncmp(node_name, "i2s-", 4)) 173 return 0; 174 175 dev = kzalloc(sizeof(struct i2sbus_dev), GFP_KERNEL); 176 if (!dev) 177 return 0; 178 179 i = 0; 180 for_each_child_of_node(np, child) { 181 if (of_node_name_eq(child, "sound")) { 182 i++; 183 sound = child; 184 } 185 } 186 if (i == 1) { 187 const u32 *id = of_get_property(sound, "layout-id", NULL); 188 189 if (id) { 190 layout = *id; 191 snprintf(dev->sound.modalias, 32, 192 "sound-layout-%d", layout); 193 ok = 1; 194 } else { 195 id = of_get_property(sound, "device-id", NULL); 196 /* 197 * We probably cannot handle all device-id machines, 198 * so restrict to those we do handle for now. 199 */ 200 if (id && (*id == 22 || *id == 14 || *id == 35 || 201 *id == 31 || *id == 44)) { 202 snprintf(dev->sound.modalias, 32, 203 "aoa-device-id-%d", *id); 204 ok = 1; 205 layout = -1; 206 } 207 } 208 } 209 /* for the time being, until we can handle non-layout-id 210 * things in some fabric, refuse to attach if there is no 211 * layout-id property or we haven't been forced to attach. 212 * When there are two i2s busses and only one has a layout-id, 213 * then this depends on the order, but that isn't important 214 * either as the second one in that case is just a modem. */ 215 if (!ok) { 216 kfree(dev); 217 return 0; 218 } 219 220 mutex_init(&dev->lock); 221 spin_lock_init(&dev->low_lock); 222 dev->sound.ofdev.archdata.dma_mask = macio->ofdev.archdata.dma_mask; 223 dev->sound.ofdev.dev.of_node = np; 224 dev->sound.ofdev.dev.dma_mask = &dev->sound.ofdev.archdata.dma_mask; 225 dev->sound.ofdev.dev.parent = &macio->ofdev.dev; 226 dev->sound.ofdev.dev.release = i2sbus_release_dev; 227 dev->sound.attach_codec = i2sbus_attach_codec; 228 dev->sound.detach_codec = i2sbus_detach_codec; 229 dev->sound.pcmid = -1; 230 dev->macio = macio; 231 dev->control = control; 232 dev->bus_number = node_name[4] - 'a'; 233 INIT_LIST_HEAD(&dev->sound.codec_list); 234 235 for (i = aoa_resource_i2smmio; i <= aoa_resource_rxdbdma; i++) { 236 dev->interrupts[i] = -1; 237 snprintf(dev->rnames[i], sizeof(dev->rnames[i]), 238 rnames[i], np); 239 } 240 for (i = aoa_resource_i2smmio; i <= aoa_resource_rxdbdma; i++) { 241 int irq = irq_of_parse_and_map(np, i); 242 if (request_irq(irq, ints[i], 0, dev->rnames[i], dev)) 243 goto err; 244 dev->interrupts[i] = irq; 245 } 246 247 248 /* Resource handling is problematic as some device-trees contain 249 * useless crap (ugh ugh ugh). We work around that here by calling 250 * specific functions for calculating the appropriate resources. 251 * 252 * This will all be moved to macio_asic.c at one point 253 */ 254 for (i = aoa_resource_i2smmio; i <= aoa_resource_rxdbdma; i++) { 255 if (i2sbus_get_and_fixup_rsrc(np,i,layout,&dev->resources[i])) 256 goto err; 257 /* If only we could use our resource dev->resources[i]... 258 * but request_resource doesn't know about parents and 259 * contained resources... 260 */ 261 dev->allocated_resource[i] = 262 request_mem_region(dev->resources[i].start, 263 resource_size(&dev->resources[i]), 264 dev->rnames[i]); 265 if (!dev->allocated_resource[i]) { 266 printk(KERN_ERR "i2sbus: failed to claim resource %d!\n", i); 267 goto err; 268 } 269 } 270 271 r = &dev->resources[aoa_resource_i2smmio]; 272 rlen = resource_size(r); 273 if (rlen < sizeof(struct i2s_interface_regs)) 274 goto err; 275 dev->intfregs = ioremap(r->start, rlen); 276 277 r = &dev->resources[aoa_resource_txdbdma]; 278 rlen = resource_size(r); 279 if (rlen < sizeof(struct dbdma_regs)) 280 goto err; 281 dev->out.dbdma = ioremap(r->start, rlen); 282 283 r = &dev->resources[aoa_resource_rxdbdma]; 284 rlen = resource_size(r); 285 if (rlen < sizeof(struct dbdma_regs)) 286 goto err; 287 dev->in.dbdma = ioremap(r->start, rlen); 288 289 if (!dev->intfregs || !dev->out.dbdma || !dev->in.dbdma) 290 goto err; 291 292 if (alloc_dbdma_descriptor_ring(dev, &dev->out.dbdma_ring, 293 MAX_DBDMA_COMMANDS)) 294 goto err; 295 if (alloc_dbdma_descriptor_ring(dev, &dev->in.dbdma_ring, 296 MAX_DBDMA_COMMANDS)) 297 goto err; 298 299 if (i2sbus_control_add_dev(dev->control, dev)) { 300 printk(KERN_ERR "i2sbus: control layer didn't like bus\n"); 301 goto err; 302 } 303 304 if (soundbus_add_one(&dev->sound)) { 305 printk(KERN_DEBUG "i2sbus: device registration error!\n"); 306 if (dev->sound.ofdev.dev.kobj.state_initialized) { 307 soundbus_dev_put(&dev->sound); 308 return 0; 309 } 310 goto err; 311 } 312 313 /* enable this cell */ 314 i2sbus_control_cell(dev->control, dev, 1); 315 i2sbus_control_enable(dev->control, dev); 316 i2sbus_control_clock(dev->control, dev, 1); 317 318 return 1; 319 err: 320 for (i=0;i<3;i++) 321 if (dev->interrupts[i] != -1) 322 free_irq(dev->interrupts[i], dev); 323 free_dbdma_descriptor_ring(dev, &dev->out.dbdma_ring); 324 free_dbdma_descriptor_ring(dev, &dev->in.dbdma_ring); 325 iounmap(dev->intfregs); 326 iounmap(dev->out.dbdma); 327 iounmap(dev->in.dbdma); 328 for (i=0;i<3;i++) 329 release_and_free_resource(dev->allocated_resource[i]); 330 mutex_destroy(&dev->lock); 331 kfree(dev); 332 return 0; 333 } 334 335 static int i2sbus_probe(struct macio_dev* dev, const struct of_device_id *match) 336 { 337 struct device_node *np = NULL; 338 int got = 0, err; 339 struct i2sbus_control *control = NULL; 340 341 err = i2sbus_control_init(dev, &control); 342 if (err) 343 return err; 344 if (!control) { 345 printk(KERN_ERR "i2sbus_control_init API breakage\n"); 346 return -ENODEV; 347 } 348 349 while ((np = of_get_next_child(dev->ofdev.dev.of_node, np))) { 350 if (of_device_is_compatible(np, "i2sbus") || 351 of_device_is_compatible(np, "i2s-modem")) { 352 got += i2sbus_add_dev(dev, control, np); 353 } 354 } 355 356 if (!got) { 357 /* found none, clean up */ 358 i2sbus_control_destroy(control); 359 return -ENODEV; 360 } 361 362 dev_set_drvdata(&dev->ofdev.dev, control); 363 364 return 0; 365 } 366 367 static int i2sbus_remove(struct macio_dev* dev) 368 { 369 struct i2sbus_control *control = dev_get_drvdata(&dev->ofdev.dev); 370 struct i2sbus_dev *i2sdev, *tmp; 371 372 list_for_each_entry_safe(i2sdev, tmp, &control->list, item) 373 soundbus_remove_one(&i2sdev->sound); 374 375 return 0; 376 } 377 378 #ifdef CONFIG_PM 379 static int i2sbus_suspend(struct macio_dev* dev, pm_message_t state) 380 { 381 struct i2sbus_control *control = dev_get_drvdata(&dev->ofdev.dev); 382 struct codec_info_item *cii; 383 struct i2sbus_dev* i2sdev; 384 int err, ret = 0; 385 386 list_for_each_entry(i2sdev, &control->list, item) { 387 /* Notify codecs */ 388 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) { 389 err = 0; 390 if (cii->codec->suspend) 391 err = cii->codec->suspend(cii, state); 392 if (err) 393 ret = err; 394 } 395 396 /* wait until streams are stopped */ 397 i2sbus_wait_for_stop_both(i2sdev); 398 } 399 400 return ret; 401 } 402 403 static int i2sbus_resume(struct macio_dev* dev) 404 { 405 struct i2sbus_control *control = dev_get_drvdata(&dev->ofdev.dev); 406 struct codec_info_item *cii; 407 struct i2sbus_dev* i2sdev; 408 int err, ret = 0; 409 410 list_for_each_entry(i2sdev, &control->list, item) { 411 /* reset i2s bus format etc. */ 412 i2sbus_pcm_prepare_both(i2sdev); 413 414 /* Notify codecs so they can re-initialize */ 415 list_for_each_entry(cii, &i2sdev->sound.codec_list, list) { 416 err = 0; 417 if (cii->codec->resume) 418 err = cii->codec->resume(cii); 419 if (err) 420 ret = err; 421 } 422 } 423 424 return ret; 425 } 426 #endif /* CONFIG_PM */ 427 428 static int i2sbus_shutdown(struct macio_dev* dev) 429 { 430 return 0; 431 } 432 433 static struct macio_driver i2sbus_drv = { 434 .driver = { 435 .name = "soundbus-i2s", 436 .owner = THIS_MODULE, 437 .of_match_table = i2sbus_match, 438 }, 439 .probe = i2sbus_probe, 440 .remove = i2sbus_remove, 441 #ifdef CONFIG_PM 442 .suspend = i2sbus_suspend, 443 .resume = i2sbus_resume, 444 #endif 445 .shutdown = i2sbus_shutdown, 446 }; 447 448 static int __init soundbus_i2sbus_init(void) 449 { 450 return macio_register_driver(&i2sbus_drv); 451 } 452 453 static void __exit soundbus_i2sbus_exit(void) 454 { 455 macio_unregister_driver(&i2sbus_drv); 456 } 457 458 module_init(soundbus_i2sbus_init); 459 module_exit(soundbus_i2sbus_exit); 460