queue-6.8/sparc32-fix-parport-build-with-sparc32.patch

   1 From 2c4842d42cad823e3927c9a54d8a7c30158d27d2 Mon Sep 17 00:00:00 2001
   2 From: Sasha Levin <sashal@kernel.org>
   3 Date: Sat, 24 Feb 2024 18:42:27 +0100
   4 Subject: sparc32: Fix parport build with sparc32
   5
   6 From: Sam Ravnborg <sam@ravnborg.org>
   7
   8 [ Upstream commit 91d3ff922c346d6d8cb8de5ff8d504fe0ca9e17e ]
   9
  10 include/asm/parport.h is sparc64 specific.
  11 Rename it to parport_64.h and use the generic version for sparc32.
  12
  13 This fixed all{mod,yes}config build errors like:
  14
  15 parport_pc.c:(.text):undefined-reference-to-ebus_dma_enable
  16 parport_pc.c:(.text):undefined-reference-to-ebus_dma_irq_enable
  17 parport_pc.c:(.text):undefined-reference-to-ebus_dma_register
  18
  19 The errors occur as the sparc32 build references sparc64 symbols.
  20
  21 Signed-off-by: Sam Ravnborg <sam@ravnborg.org>
  22 Cc: "David S. Miller" <davem@davemloft.net>
  23 Cc: Andreas Larsson <andreas@gaisler.com>
  24 Cc: Randy Dunlap <rdunlap@infradead.org>
  25 Cc: Maciej W. Rozycki <macro@orcam.me.uk>
  26 Closes: https://lore.kernel.org/r/20230406160548.25721-1-rdunlap@infradead.org/
  27 Fixes: 66bcd06099bb ("parport_pc: Also enable driver for PCI systems")
  28 Cc: stable@vger.kernel.org # v5.18+
  29 Tested-by: Randy Dunlap <rdunlap@infradead.org> # build-tested
  30 Reviewed-by: Andreas Larsson <andreas@gaisler.com>
  31 Signed-off-by: Andreas Larsson <andreas@gaisler.com>
  32 Link: https://lore.kernel.org/r/20240224-sam-fix-sparc32-all-builds-v2-6-1f186603c5c4@ravnborg.org
  33 Signed-off-by: Sasha Levin <sashal@kernel.org>
  34 ---
  35  arch/sparc/include/asm/parport.h    | 259 +---------------------------
  36  arch/sparc/include/asm/parport_64.h | 256 +++++++++++++++++++++++++++
  37  2 files changed, 263 insertions(+), 252 deletions(-)
  38  create mode 100644 arch/sparc/include/asm/parport_64.h
  39
  40 diff --git a/arch/sparc/include/asm/parport.h b/arch/sparc/include/asm/parport.h
  41 index 0a7ffcfd59cda..e2eed8f97665f 100644
  42 --- a/arch/sparc/include/asm/parport.h
  43 +++ b/arch/sparc/include/asm/parport.h
  44 @@ -1,256 +1,11 @@
  45  /* SPDX-License-Identifier: GPL-2.0 */
  46 -/* parport.h: sparc64 specific parport initialization and dma.
  47 - *
  48 - * Copyright (C) 1999  Eddie C. Dost  (ecd@skynet.be)
  49 - */
  50 +#ifndef ___ASM_SPARC_PARPORT_H
  51 +#define ___ASM_SPARC_PARPORT_H
  52
  53 -#ifndef _ASM_SPARC64_PARPORT_H
  54 -#define _ASM_SPARC64_PARPORT_H 1
  55 -
  56 -#include <linux/of.h>
  57 -#include <linux/platform_device.h>
  58 -
  59 -#include <asm/ebus_dma.h>
  60 -#include <asm/ns87303.h>
  61 -#include <asm/prom.h>
  62 -
  63 -#define PARPORT_PC_MAX_PORTS   PARPORT_MAX
  64 -
  65 -/*
  66 - * While sparc64 doesn't have an ISA DMA API, we provide something that looks
  67 - * close enough to make parport_pc happy
  68 - */
  69 -#define HAS_DMA
  70 -
  71 -#ifdef CONFIG_PARPORT_PC_FIFO
  72 -static DEFINE_SPINLOCK(dma_spin_lock);
  73 -
  74 -#define claim_dma_lock() \
  75 -({     unsigned long flags; \
  76 -       spin_lock_irqsave(&dma_spin_lock, flags); \
  77 -       flags; \
  78 -})
  79 -
  80 -#define release_dma_lock(__flags) \
  81 -       spin_unlock_irqrestore(&dma_spin_lock, __flags);
  82 +#if defined(__sparc__) && defined(__arch64__)
  83 +#include <asm/parport_64.h>
  84 +#else
  85 +#include <asm-generic/parport.h>
  86 +#endif
  87  #endif
  88
  89 -static struct sparc_ebus_info {
  90 -       struct ebus_dma_info info;
  91 -       unsigned int addr;
  92 -       unsigned int count;
  93 -       int lock;
  94 -
  95 -       struct parport *port;
  96 -} sparc_ebus_dmas[PARPORT_PC_MAX_PORTS];
  97 -
  98 -static DECLARE_BITMAP(dma_slot_map, PARPORT_PC_MAX_PORTS);
  99 -
 100 -static inline int request_dma(unsigned int dmanr, const char *device_id)
 101 -{
 102 -       if (dmanr >= PARPORT_PC_MAX_PORTS)
 103 -               return -EINVAL;
 104 -       if (xchg(&sparc_ebus_dmas[dmanr].lock, 1) != 0)
 105 -               return -EBUSY;
 106 -       return 0;
 107 -}
 108 -
 109 -static inline void free_dma(unsigned int dmanr)
 110 -{
 111 -       if (dmanr >= PARPORT_PC_MAX_PORTS) {
 112 -               printk(KERN_WARNING "Trying to free DMA%d\n", dmanr);
 113 -               return;
 114 -       }
 115 -       if (xchg(&sparc_ebus_dmas[dmanr].lock, 0) == 0) {
 116 -               printk(KERN_WARNING "Trying to free free DMA%d\n", dmanr);
 117 -               return;
 118 -       }
 119 -}
 120 -
 121 -static inline void enable_dma(unsigned int dmanr)
 122 -{
 123 -       ebus_dma_enable(&sparc_ebus_dmas[dmanr].info, 1);
 124 -
 125 -       if (ebus_dma_request(&sparc_ebus_dmas[dmanr].info,
 126 -                            sparc_ebus_dmas[dmanr].addr,
 127 -                            sparc_ebus_dmas[dmanr].count))
 128 -               BUG();
 129 -}
 130 -
 131 -static inline void disable_dma(unsigned int dmanr)
 132 -{
 133 -       ebus_dma_enable(&sparc_ebus_dmas[dmanr].info, 0);
 134 -}
 135 -
 136 -static inline void clear_dma_ff(unsigned int dmanr)
 137 -{
 138 -       /* nothing */
 139 -}
 140 -
 141 -static inline void set_dma_mode(unsigned int dmanr, char mode)
 142 -{
 143 -       ebus_dma_prepare(&sparc_ebus_dmas[dmanr].info, (mode != DMA_MODE_WRITE));
 144 -}
 145 -
 146 -static inline void set_dma_addr(unsigned int dmanr, unsigned int addr)
 147 -{
 148 -       sparc_ebus_dmas[dmanr].addr = addr;
 149 -}
 150 -
 151 -static inline void set_dma_count(unsigned int dmanr, unsigned int count)
 152 -{
 153 -       sparc_ebus_dmas[dmanr].count = count;
 154 -}
 155 -
 156 -static inline unsigned int get_dma_residue(unsigned int dmanr)
 157 -{
 158 -       return ebus_dma_residue(&sparc_ebus_dmas[dmanr].info);
 159 -}
 160 -
 161 -static int ecpp_probe(struct platform_device *op)
 162 -{
 163 -       unsigned long base = op->resource[0].start;
 164 -       unsigned long config = op->resource[1].start;
 165 -       unsigned long d_base = op->resource[2].start;
 166 -       unsigned long d_len;
 167 -       struct device_node *parent;
 168 -       struct parport *p;
 169 -       int slot, err;
 170 -
 171 -       parent = op->dev.of_node->parent;
 172 -       if (of_node_name_eq(parent, "dma")) {
 173 -               p = parport_pc_probe_port(base, base + 0x400,
 174 -                                         op->archdata.irqs[0], PARPORT_DMA_NOFIFO,
 175 -                                         op->dev.parent->parent, 0);
 176 -               if (!p)
 177 -                       return -ENOMEM;
 178 -               dev_set_drvdata(&op->dev, p);
 179 -               return 0;
 180 -       }
 181 -
 182 -       for (slot = 0; slot < PARPORT_PC_MAX_PORTS; slot++) {
 183 -               if (!test_and_set_bit(slot, dma_slot_map))
 184 -                       break;
 185 -       }
 186 -       err = -ENODEV;
 187 -       if (slot >= PARPORT_PC_MAX_PORTS)
 188 -               goto out_err;
 189 -
 190 -       spin_lock_init(&sparc_ebus_dmas[slot].info.lock);
 191 -
 192 -       d_len = (op->resource[2].end - d_base) + 1UL;
 193 -       sparc_ebus_dmas[slot].info.regs =
 194 -               of_ioremap(&op->resource[2], 0, d_len, "ECPP DMA");
 195 -
 196 -       if (!sparc_ebus_dmas[slot].info.regs)
 197 -               goto out_clear_map;
 198 -
 199 -       sparc_ebus_dmas[slot].info.flags = 0;
 200 -       sparc_ebus_dmas[slot].info.callback = NULL;
 201 -       sparc_ebus_dmas[slot].info.client_cookie = NULL;
 202 -       sparc_ebus_dmas[slot].info.irq = 0xdeadbeef;
 203 -       strcpy(sparc_ebus_dmas[slot].info.name, "parport");
 204 -       if (ebus_dma_register(&sparc_ebus_dmas[slot].info))
 205 -               goto out_unmap_regs;
 206 -
 207 -       ebus_dma_irq_enable(&sparc_ebus_dmas[slot].info, 1);
 208 -
 209 -       /* Configure IRQ to Push Pull, Level Low */
 210 -       /* Enable ECP, set bit 2 of the CTR first */
 211 -       outb(0x04, base + 0x02);
 212 -       ns87303_modify(config, PCR,
 213 -                      PCR_EPP_ENABLE |
 214 -                      PCR_IRQ_ODRAIN,
 215 -                      PCR_ECP_ENABLE |
 216 -                      PCR_ECP_CLK_ENA |
 217 -                      PCR_IRQ_POLAR);
 218 -
 219 -       /* CTR bit 5 controls direction of port */
 220 -       ns87303_modify(config, PTR,
 221 -                      0, PTR_LPT_REG_DIR);
 222 -
 223 -       p = parport_pc_probe_port(base, base + 0x400,
 224 -                                 op->archdata.irqs[0],
 225 -                                 slot,
 226 -                                 op->dev.parent,
 227 -                                 0);
 228 -       err = -ENOMEM;
 229 -       if (!p)
 230 -               goto out_disable_irq;
 231 -
 232 -       dev_set_drvdata(&op->dev, p);
 233 -
 234 -       return 0;
 235 -
 236 -out_disable_irq:
 237 -       ebus_dma_irq_enable(&sparc_ebus_dmas[slot].info, 0);
 238 -       ebus_dma_unregister(&sparc_ebus_dmas[slot].info);
 239 -
 240 -out_unmap_regs:
 241 -       of_iounmap(&op->resource[2], sparc_ebus_dmas[slot].info.regs, d_len);
 242 -
 243 -out_clear_map:
 244 -       clear_bit(slot, dma_slot_map);
 245 -
 246 -out_err:
 247 -       return err;
 248 -}
 249 -
 250 -static int ecpp_remove(struct platform_device *op)
 251 -{
 252 -       struct parport *p = dev_get_drvdata(&op->dev);
 253 -       int slot = p->dma;
 254 -
 255 -       parport_pc_unregister_port(p);
 256 -
 257 -       if (slot != PARPORT_DMA_NOFIFO) {
 258 -               unsigned long d_base = op->resource[2].start;
 259 -               unsigned long d_len;
 260 -
 261 -               d_len = (op->resource[2].end - d_base) + 1UL;
 262 -
 263 -               ebus_dma_irq_enable(&sparc_ebus_dmas[slot].info, 0);
 264 -               ebus_dma_unregister(&sparc_ebus_dmas[slot].info);
 265 -               of_iounmap(&op->resource[2],
 266 -                          sparc_ebus_dmas[slot].info.regs,
 267 -                          d_len);
 268 -               clear_bit(slot, dma_slot_map);
 269 -       }
 270 -
 271 -       return 0;
 272 -}
 273 -
 274 -static const struct of_device_id ecpp_match[] = {
 275 -       {
 276 -               .name = "ecpp",
 277 -       },
 278 -       {
 279 -               .name = "parallel",
 280 -               .compatible = "ecpp",
 281 -       },
 282 -       {
 283 -               .name = "parallel",
 284 -               .compatible = "ns87317-ecpp",
 285 -       },
 286 -       {
 287 -               .name = "parallel",
 288 -               .compatible = "pnpALI,1533,3",
 289 -       },
 290 -       {},
 291 -};
 292 -
 293 -static struct platform_driver ecpp_driver = {
 294 -       .driver = {
 295 -               .name = "ecpp",
 296 -               .of_match_table = ecpp_match,
 297 -       },
 298 -       .probe                  = ecpp_probe,
 299 -       .remove                 = ecpp_remove,
 300 -};
 301 -
 302 -static int parport_pc_find_nonpci_ports(int autoirq, int autodma)
 303 -{
 304 -       return platform_driver_register(&ecpp_driver);
 305 -}
 306 -
 307 -#endif /* !(_ASM_SPARC64_PARPORT_H */
 308 diff --git a/arch/sparc/include/asm/parport_64.h b/arch/sparc/include/asm/parport_64.h
 309 new file mode 100644
 310 index 0000000000000..0a7ffcfd59cda
 311 --- /dev/null
 312 +++ b/arch/sparc/include/asm/parport_64.h
 313 @@ -0,0 +1,256 @@
 314 +/* SPDX-License-Identifier: GPL-2.0 */
 315 +/* parport.h: sparc64 specific parport initialization and dma.
 316 + *
 317 + * Copyright (C) 1999  Eddie C. Dost  (ecd@skynet.be)
 318 + */
 319 +
 320 +#ifndef _ASM_SPARC64_PARPORT_H
 321 +#define _ASM_SPARC64_PARPORT_H 1
 322 +
 323 +#include <linux/of.h>
 324 +#include <linux/platform_device.h>
 325 +
 326 +#include <asm/ebus_dma.h>
 327 +#include <asm/ns87303.h>
 328 +#include <asm/prom.h>
 329 +
 330 +#define PARPORT_PC_MAX_PORTS   PARPORT_MAX
 331 +
 332 +/*
 333 + * While sparc64 doesn't have an ISA DMA API, we provide something that looks
 334 + * close enough to make parport_pc happy
 335 + */
 336 +#define HAS_DMA
 337 +
 338 +#ifdef CONFIG_PARPORT_PC_FIFO
 339 +static DEFINE_SPINLOCK(dma_spin_lock);
 340 +
 341 +#define claim_dma_lock() \
 342 +({     unsigned long flags; \
 343 +       spin_lock_irqsave(&dma_spin_lock, flags); \
 344 +       flags; \
 345 +})
 346 +
 347 +#define release_dma_lock(__flags) \
 348 +       spin_unlock_irqrestore(&dma_spin_lock, __flags);
 349 +#endif
 350 +
 351 +static struct sparc_ebus_info {
 352 +       struct ebus_dma_info info;
 353 +       unsigned int addr;
 354 +       unsigned int count;
 355 +       int lock;
 356 +
 357 +       struct parport *port;
 358 +} sparc_ebus_dmas[PARPORT_PC_MAX_PORTS];
 359 +
 360 +static DECLARE_BITMAP(dma_slot_map, PARPORT_PC_MAX_PORTS);
 361 +
 362 +static inline int request_dma(unsigned int dmanr, const char *device_id)
 363 +{
 364 +       if (dmanr >= PARPORT_PC_MAX_PORTS)
 365 +               return -EINVAL;
 366 +       if (xchg(&sparc_ebus_dmas[dmanr].lock, 1) != 0)
 367 +               return -EBUSY;
 368 +       return 0;
 369 +}
 370 +
 371 +static inline void free_dma(unsigned int dmanr)
 372 +{
 373 +       if (dmanr >= PARPORT_PC_MAX_PORTS) {
 374 +               printk(KERN_WARNING "Trying to free DMA%d\n", dmanr);
 375 +               return;
 376 +       }
 377 +       if (xchg(&sparc_ebus_dmas[dmanr].lock, 0) == 0) {
 378 +               printk(KERN_WARNING "Trying to free free DMA%d\n", dmanr);
 379 +               return;
 380 +       }
 381 +}
 382 +
 383 +static inline void enable_dma(unsigned int dmanr)
 384 +{
 385 +       ebus_dma_enable(&sparc_ebus_dmas[dmanr].info, 1);
 386 +
 387 +       if (ebus_dma_request(&sparc_ebus_dmas[dmanr].info,
 388 +                            sparc_ebus_dmas[dmanr].addr,
 389 +                            sparc_ebus_dmas[dmanr].count))
 390 +               BUG();
 391 +}
 392 +
 393 +static inline void disable_dma(unsigned int dmanr)
 394 +{
 395 +       ebus_dma_enable(&sparc_ebus_dmas[dmanr].info, 0);
 396 +}
 397 +
 398 +static inline void clear_dma_ff(unsigned int dmanr)
 399 +{
 400 +       /* nothing */
 401 +}
 402 +
 403 +static inline void set_dma_mode(unsigned int dmanr, char mode)
 404 +{
 405 +       ebus_dma_prepare(&sparc_ebus_dmas[dmanr].info, (mode != DMA_MODE_WRITE));
 406 +}
 407 +
 408 +static inline void set_dma_addr(unsigned int dmanr, unsigned int addr)
 409 +{
 410 +       sparc_ebus_dmas[dmanr].addr = addr;
 411 +}
 412 +
 413 +static inline void set_dma_count(unsigned int dmanr, unsigned int count)
 414 +{
 415 +       sparc_ebus_dmas[dmanr].count = count;
 416 +}
 417 +
 418 +static inline unsigned int get_dma_residue(unsigned int dmanr)
 419 +{
 420 +       return ebus_dma_residue(&sparc_ebus_dmas[dmanr].info);
 421 +}
 422 +
 423 +static int ecpp_probe(struct platform_device *op)
 424 +{
 425 +       unsigned long base = op->resource[0].start;
 426 +       unsigned long config = op->resource[1].start;
 427 +       unsigned long d_base = op->resource[2].start;
 428 +       unsigned long d_len;
 429 +       struct device_node *parent;
 430 +       struct parport *p;
 431 +       int slot, err;
 432 +
 433 +       parent = op->dev.of_node->parent;
 434 +       if (of_node_name_eq(parent, "dma")) {
 435 +               p = parport_pc_probe_port(base, base + 0x400,
 436 +                                         op->archdata.irqs[0], PARPORT_DMA_NOFIFO,
 437 +                                         op->dev.parent->parent, 0);
 438 +               if (!p)
 439 +                       return -ENOMEM;
 440 +               dev_set_drvdata(&op->dev, p);
 441 +               return 0;
 442 +       }
 443 +
 444 +       for (slot = 0; slot < PARPORT_PC_MAX_PORTS; slot++) {
 445 +               if (!test_and_set_bit(slot, dma_slot_map))
 446 +                       break;
 447 +       }
 448 +       err = -ENODEV;
 449 +       if (slot >= PARPORT_PC_MAX_PORTS)
 450 +               goto out_err;
 451 +
 452 +       spin_lock_init(&sparc_ebus_dmas[slot].info.lock);
 453 +
 454 +       d_len = (op->resource[2].end - d_base) + 1UL;
 455 +       sparc_ebus_dmas[slot].info.regs =
 456 +               of_ioremap(&op->resource[2], 0, d_len, "ECPP DMA");
 457 +
 458 +       if (!sparc_ebus_dmas[slot].info.regs)
 459 +               goto out_clear_map;
 460 +
 461 +       sparc_ebus_dmas[slot].info.flags = 0;
 462 +       sparc_ebus_dmas[slot].info.callback = NULL;
 463 +       sparc_ebus_dmas[slot].info.client_cookie = NULL;
 464 +       sparc_ebus_dmas[slot].info.irq = 0xdeadbeef;
 465 +       strcpy(sparc_ebus_dmas[slot].info.name, "parport");
 466 +       if (ebus_dma_register(&sparc_ebus_dmas[slot].info))
 467 +               goto out_unmap_regs;
 468 +
 469 +       ebus_dma_irq_enable(&sparc_ebus_dmas[slot].info, 1);
 470 +
 471 +       /* Configure IRQ to Push Pull, Level Low */
 472 +       /* Enable ECP, set bit 2 of the CTR first */
 473 +       outb(0x04, base + 0x02);
 474 +       ns87303_modify(config, PCR,
 475 +                      PCR_EPP_ENABLE |
 476 +                      PCR_IRQ_ODRAIN,
 477 +                      PCR_ECP_ENABLE |
 478 +                      PCR_ECP_CLK_ENA |
 479 +                      PCR_IRQ_POLAR);
 480 +
 481 +       /* CTR bit 5 controls direction of port */
 482 +       ns87303_modify(config, PTR,
 483 +                      0, PTR_LPT_REG_DIR);
 484 +
 485 +       p = parport_pc_probe_port(base, base + 0x400,
 486 +                                 op->archdata.irqs[0],
 487 +                                 slot,
 488 +                                 op->dev.parent,
 489 +                                 0);
 490 +       err = -ENOMEM;
 491 +       if (!p)
 492 +               goto out_disable_irq;
 493 +
 494 +       dev_set_drvdata(&op->dev, p);
 495 +
 496 +       return 0;
 497 +
 498 +out_disable_irq:
 499 +       ebus_dma_irq_enable(&sparc_ebus_dmas[slot].info, 0);
 500 +       ebus_dma_unregister(&sparc_ebus_dmas[slot].info);
 501 +
 502 +out_unmap_regs:
 503 +       of_iounmap(&op->resource[2], sparc_ebus_dmas[slot].info.regs, d_len);
 504 +
 505 +out_clear_map:
 506 +       clear_bit(slot, dma_slot_map);
 507 +
 508 +out_err:
 509 +       return err;
 510 +}
 511 +
 512 +static int ecpp_remove(struct platform_device *op)
 513 +{
 514 +       struct parport *p = dev_get_drvdata(&op->dev);
 515 +       int slot = p->dma;
 516 +
 517 +       parport_pc_unregister_port(p);
 518 +
 519 +       if (slot != PARPORT_DMA_NOFIFO) {
 520 +               unsigned long d_base = op->resource[2].start;
 521 +               unsigned long d_len;
 522 +
 523 +               d_len = (op->resource[2].end - d_base) + 1UL;
 524 +
 525 +               ebus_dma_irq_enable(&sparc_ebus_dmas[slot].info, 0);
 526 +               ebus_dma_unregister(&sparc_ebus_dmas[slot].info);
 527 +               of_iounmap(&op->resource[2],
 528 +                          sparc_ebus_dmas[slot].info.regs,
 529 +                          d_len);
 530 +               clear_bit(slot, dma_slot_map);
 531 +       }
 532 +
 533 +       return 0;
 534 +}
 535 +
 536 +static const struct of_device_id ecpp_match[] = {
 537 +       {
 538 +               .name = "ecpp",
 539 +       },
 540 +       {
 541 +               .name = "parallel",
 542 +               .compatible = "ecpp",
 543 +       },
 544 +       {
 545 +               .name = "parallel",
 546 +               .compatible = "ns87317-ecpp",
 547 +       },
 548 +       {
 549 +               .name = "parallel",
 550 +               .compatible = "pnpALI,1533,3",
 551 +       },
 552 +       {},
 553 +};
 554 +
 555 +static struct platform_driver ecpp_driver = {
 556 +       .driver = {
 557 +               .name = "ecpp",
 558 +               .of_match_table = ecpp_match,
 559 +       },
 560 +       .probe                  = ecpp_probe,
 561 +       .remove                 = ecpp_remove,
 562 +};
 563 +
 564 +static int parport_pc_find_nonpci_ports(int autoirq, int autodma)
 565 +{
 566 +       return platform_driver_register(&ecpp_driver);
 567 +}
 568 +
 569 +#endif /* !(_ASM_SPARC64_PARPORT_H */
 570 --
 571 2.43.0
 572