[PATCH 1/2] rust: macros: allow optional trailing comma in module!

[PATCH 1/2] rust: macros: allow optional trailing comma in module!

[Eunsoo Eun]

From: Eunsoo Eun <naturale@hufs.ac.kr>

Make the `module!` macro syntax more flexible by allowing an optional
trailing comma after the last field. This makes it consistent with
Rust’s general syntax patterns where trailing commas are allowed in
structs, arrays, and other comma-separated lists.

For example, these are now all valid:

    module! {
        type: MyModule,
        name: "mymodule",
        license: "GPL"  // No trailing comma
    }

    module! {
        type: MyModule,
        name: "mymodule",
        license: "GPL",  // With trailing comma
    }

This change also allows optional trailing commas in array fields like
`authors`, `alias`, and `firmware`:

    module! {
        type: MyModule,
        name: "mymodule",
        authors: ["Author 1", "Author 2"],  // No trailing comma
        license: "GPL"
    }

    module! {
        type: MyModule,
        name: "mymodule",
        authors: ["Author 1", "Author 2",], // With trailing comma
        license: "GPL"
    }

Suggested-by: Benno Lossin <benno.lossin@proton.me>
Link: https://github.com/Rust-for-Linux/linux/issues/1172
Signed-off-by: Eunsoo Eun <naturale@hufs.ac.kr>
---
 rust/macros/concat_idents.rs |  9 ++++++++
 rust/macros/module.rs        | 42 ++++++++++++++++++++++++++++++------
 2 files changed, 45 insertions(+), 6 deletions(-)

diff --git a/rust/macros/concat_idents.rs b/rust/macros/concat_idents.rs
index 7e4b450f3a50..c139e1658b4a 100644
--- a/rust/macros/concat_idents.rs
+++ b/rust/macros/concat_idents.rs
@@ -17,6 +17,15 @@ pub(crate) fn concat_idents(ts: TokenStream) -> TokenStream {
     let a = expect_ident(&mut it);
     assert_eq!(expect_punct(&mut it), ',');
     let b = expect_ident(&mut it);
+    
+    // Check for optional trailing comma
+    if let Some(TokenTree::Punct(punct)) = it.clone().next() {
+        if punct.as_char() == ',' {
+            // Consume the trailing comma
+            it.next();
+        }
+    }
+    
     assert!(it.next().is_none(), "only two idents can be concatenated");
     let res = Ident::new(&format!("{a}{b}"), b.span());
     TokenStream::from_iter([TokenTree::Ident(res)])
diff --git a/rust/macros/module.rs b/rust/macros/module.rs
index 2ddd2eeb2852..d37492457be5 100644
--- a/rust/macros/module.rs
+++ b/rust/macros/module.rs
@@ -13,10 +13,27 @@ fn expect_string_array(it: &mut token_stream::IntoIter) -> Vec<String> {
     while let Some(val) = try_string(&mut it) {
         assert!(val.is_ascii(), "Expected ASCII string");
         values.push(val);
-        match it.next() {
-            Some(TokenTree::Punct(punct)) => assert_eq!(punct.as_char(), ','),
-            None => break,
-            _ => panic!("Expected ',' or end of array"),
+
+        // Check for optional trailing comma
+        match it.clone().next() {
+            Some(TokenTree::Punct(punct)) if punct.as_char() == ',' => {
+                // Consume the comma
+                it.next();
+                // Check if there's another string after the comma
+                if it.clone().next().is_none() {
+                    // Trailing comma at end of array is allowed
+                    break;
+                }
+            }
+            Some(TokenTree::Literal(_)) => {
+                // Next item is a string literal, comma was required
+                panic!("Expected ',' between array elements");
+            }
+            None => {
+                // End of array, no comma needed
+                break;
+            }
+            Some(_) => panic!("Expected ',' or end of array"),
         }
     }
     values
@@ -143,9 +160,22 @@ fn parse(it: &mut token_stream::IntoIter) -> Self {
                 _ => panic!("Unknown key \"{key}\". Valid keys are: {EXPECTED_KEYS:?}."),
             }
 
-            assert_eq!(expect_punct(it), ',');
-
             seen_keys.push(key);
+
+            // Check for optional trailing comma
+            match it.clone().next() {
+                Some(TokenTree::Punct(punct)) if punct.as_char() == ',' => {
+                    // Consume the comma
+                    it.next();
+                }
+                Some(TokenTree::Ident(_)) => {
+                    // Next item is an identifier, comma was required
+                    panic!("Expected ',' between module properties");
+                }
+                _ => {
+                    // End of input or closing brace, comma is optional
+                }
+            }
         }
 
         expect_end(it);
-- 
2.49.0

[PATCH 1/2] spi: spi-pci1xxxx: Drop MSI-X usage as unsupported by DMA engine

[Eunsoo Eun]

From: Thangaraj Samynathan <thangaraj.s@microchip.com>

Removes MSI-X from the interrupt request path, as the DMA engine used by
the SPI controller does not support MSI-X interrupts.

Signed-off-by: Thangaraj Samynathan <thangaraj.s@microchip.com>
Link: https://patch.msgid.link/20250612023059.71726-1-thangaraj.s@microchip.com
Signed-off-by: Mark Brown <broonie@kernel.org>
---
 drivers/spi/spi-pci1xxxx.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/spi/spi-pci1xxxx.c b/drivers/spi/spi-pci1xxxx.c
index 9112d8a1a0c8..e27642c4dea4 100644
--- a/drivers/spi/spi-pci1xxxx.c
+++ b/drivers/spi/spi-pci1xxxx.c
@@ -762,7 +762,7 @@ static int pci1xxxx_spi_probe(struct pci_dev *pdev, const struct pci_device_id *
 				return -EINVAL;
 
 			num_vector = pci_alloc_irq_vectors(pdev, 1, hw_inst_cnt,
-							   PCI_IRQ_ALL_TYPES);
+							   PCI_IRQ_INTX | PCI_IRQ_MSI);
 			if (num_vector < 0) {
 				dev_err(&pdev->dev, "Error allocating MSI vectors\n");
 				return num_vector;
-- 
2.49.0

Re: [PATCH 1/2] rust: macros: allow optional trailing comma in module!

[Charalampos Mitrodimas]

Eunsoo Eun <ewhk9887@gmail.com> writes:

> From: Eunsoo Eun <naturale@hufs.ac.kr>
>
> Make the `module!` macro syntax more flexible by allowing an optional
> trailing comma after the last field. This makes it consistent with
> Rust’s general syntax patterns where trailing commas are allowed in
> structs, arrays, and other comma-separated lists.
>
> For example, these are now all valid:
>
>     module! {
>         type: MyModule,
>         name: "mymodule",
>         license: "GPL"  // No trailing comma
>     }
>
>     module! {
>         type: MyModule,
>         name: "mymodule",
>         license: "GPL",  // With trailing comma
>     }
>
> This change also allows optional trailing commas in array fields like
> `authors`, `alias`, and `firmware`:
>
>     module! {
>         type: MyModule,
>         name: "mymodule",
>         authors: ["Author 1", "Author 2"],  // No trailing comma
>         license: "GPL"
>     }
>
>     module! {
>         type: MyModule,
>         name: "mymodule",
>         authors: ["Author 1", "Author 2",], // With trailing comma
>         license: "GPL"
>     }
>
> Suggested-by: Benno Lossin <benno.lossin@proton.me>
> Link: https://github.com/Rust-for-Linux/linux/issues/1172
> Signed-off-by: Eunsoo Eun <naturale@hufs.ac.kr>
> ---
>  rust/macros/concat_idents.rs |  9 ++++++++
>  rust/macros/module.rs        | 42 ++++++++++++++++++++++++++++++------
>  2 files changed, 45 insertions(+), 6 deletions(-)
>
> diff --git a/rust/macros/concat_idents.rs b/rust/macros/concat_idents.rs
> index 7e4b450f3a50..c139e1658b4a 100644
> --- a/rust/macros/concat_idents.rs
> +++ b/rust/macros/concat_idents.rs
> @@ -17,6 +17,15 @@ pub(crate) fn concat_idents(ts: TokenStream) -> TokenStream {
>      let a = expect_ident(&mut it);
>      assert_eq!(expect_punct(&mut it), ',');
>      let b = expect_ident(&mut it);
> +    

We have some whitespaces here ^

> +    // Check for optional trailing comma
> +    if let Some(TokenTree::Punct(punct)) = it.clone().next() {
> +        if punct.as_char() == ',' {
> +            // Consume the trailing comma
> +            it.next();
> +        }
> +    }
> +    

Whitespaces also here ^.

Maybe you can add a new helper function for this one?

>      assert!(it.next().is_none(), "only two idents can be concatenated");
>      let res = Ident::new(&format!("{a}{b}"), b.span());
>      TokenStream::from_iter([TokenTree::Ident(res)])
> diff --git a/rust/macros/module.rs b/rust/macros/module.rs
> index 2ddd2eeb2852..d37492457be5 100644
> --- a/rust/macros/module.rs
> +++ b/rust/macros/module.rs
> @@ -13,10 +13,27 @@ fn expect_string_array(it: &mut token_stream::IntoIter) -> Vec<String> {
>      while let Some(val) = try_string(&mut it) {
>          assert!(val.is_ascii(), "Expected ASCII string");
>          values.push(val);
> -        match it.next() {
> -            Some(TokenTree::Punct(punct)) => assert_eq!(punct.as_char(), ','),
> -            None => break,
> -            _ => panic!("Expected ',' or end of array"),
> +
> +        // Check for optional trailing comma
> +        match it.clone().next() {

We might be able to do something like this here,
   let next_token = it.clone().next();
   match next_token {
         ...

> +            Some(TokenTree::Punct(punct)) if punct.as_char() == ',' => {
> +                // Consume the comma
> +                it.next();
> +                // Check if there's another string after the comma
> +                if it.clone().next().is_none() {
> +                    // Trailing comma at end of array is allowed
> +                    break;
> +                }

Lose this, and let it check naturally?

> +            }
> +            Some(TokenTree::Literal(_)) => {
> +                // Next item is a string literal, comma was required
> +                panic!("Expected ',' between array elements");
> +            }
> +            None => {
> +                // End of array, no comma needed
> +                break;
> +            }
> +            Some(_) => panic!("Expected ',' or end of array"),
>          }
>      }
>      values
> @@ -143,9 +160,22 @@ fn parse(it: &mut token_stream::IntoIter) -> Self {
>                  _ => panic!("Unknown key \"{key}\". Valid keys are: {EXPECTED_KEYS:?}."),
>              }
>  
> -            assert_eq!(expect_punct(it), ',');
> -
>              seen_keys.push(key);
> +
> +            // Check for optional trailing comma
> +            match it.clone().next() {
> +                Some(TokenTree::Punct(punct)) if punct.as_char() == ',' => {
> +                    // Consume the comma
> +                    it.next();
> +                }
> +                Some(TokenTree::Ident(_)) => {
> +                    // Next item is an identifier, comma was required
> +                    panic!("Expected ',' between module properties");
> +                }
> +                _ => {
> +                    // End of input or closing brace, comma is optional
> +                }
> +            }
>          }
>  
>          expect_end(it);

Re: [PATCH 1/2] rust: macros: allow optional trailing comma in module!

[Benno Lossin]

I didn't get the second patch advertised in the subject, did something
go wrong when sending the patch?

On Sat Jun 14, 2025 at 10:13 AM CEST, Eunsoo Eun wrote:
> From: Eunsoo Eun <naturale@hufs.ac.kr>
>
> Make the `module!` macro syntax more flexible by allowing an optional
> trailing comma after the last field. This makes it consistent with
> Rust’s general syntax patterns where trailing commas are allowed in
> structs, arrays, and other comma-separated lists.
>
> For example, these are now all valid:
>
>     module! {
>         type: MyModule,
>         name: "mymodule",
>         license: "GPL"  // No trailing comma
>     }
>
>     module! {
>         type: MyModule,
>         name: "mymodule",
>         license: "GPL",  // With trailing comma
>     }
>
> This change also allows optional trailing commas in array fields like
> `authors`, `alias`, and `firmware`:
>
>     module! {
>         type: MyModule,
>         name: "mymodule",
>         authors: ["Author 1", "Author 2"],  // No trailing comma
>         license: "GPL"
>     }
>
>     module! {
>         type: MyModule,
>         name: "mymodule",
>         authors: ["Author 1", "Author 2",], // With trailing comma
>         license: "GPL"
>     }
>
> Suggested-by: Benno Lossin <benno.lossin@proton.me>
> Link: https://github.com/Rust-for-Linux/linux/issues/1172
> Signed-off-by: Eunsoo Eun <naturale@hufs.ac.kr>
> ---
>  rust/macros/concat_idents.rs |  9 ++++++++
>  rust/macros/module.rs        | 42 ++++++++++++++++++++++++++++++------
>  2 files changed, 45 insertions(+), 6 deletions(-)
>
> diff --git a/rust/macros/concat_idents.rs b/rust/macros/concat_idents.rs
> index 7e4b450f3a50..c139e1658b4a 100644
> --- a/rust/macros/concat_idents.rs
> +++ b/rust/macros/concat_idents.rs
> @@ -17,6 +17,15 @@ pub(crate) fn concat_idents(ts: TokenStream) -> TokenStream {
>      let a = expect_ident(&mut it);
>      assert_eq!(expect_punct(&mut it), ',');
>      let b = expect_ident(&mut it);
> +    
> +    // Check for optional trailing comma
> +    if let Some(TokenTree::Punct(punct)) = it.clone().next() {

Please avoid cloning the iterator, as that is inefficient. Instead use
`peekable()` to create an iterator with a `peek` function.

> +        if punct.as_char() == ',' {
> +            // Consume the trailing comma
> +            it.next();
> +        }

This allows any kind of trailing token in concat_idents, but only a
comma should be allowed.

> +    }
> +    
>      assert!(it.next().is_none(), "only two idents can be concatenated");
>      let res = Ident::new(&format!("{a}{b}"), b.span());
>      TokenStream::from_iter([TokenTree::Ident(res)])
> diff --git a/rust/macros/module.rs b/rust/macros/module.rs
> index 2ddd2eeb2852..d37492457be5 100644
> --- a/rust/macros/module.rs
> +++ b/rust/macros/module.rs
> @@ -13,10 +13,27 @@ fn expect_string_array(it: &mut token_stream::IntoIter) -> Vec<String> {
>      while let Some(val) = try_string(&mut it) {
>          assert!(val.is_ascii(), "Expected ASCII string");
>          values.push(val);
> -        match it.next() {
> -            Some(TokenTree::Punct(punct)) => assert_eq!(punct.as_char(), ','),
> -            None => break,
> -            _ => panic!("Expected ',' or end of array"),
> +
> +        // Check for optional trailing comma
> +        match it.clone().next() {

Please avoid cloning the iterator, as that is inefficient. Instead use
`peekable()` to create an iterator with a `peek` function.

> +            Some(TokenTree::Punct(punct)) if punct.as_char() == ',' => {
> +                // Consume the comma
> +                it.next();
> +                // Check if there's another string after the comma
> +                if it.clone().next().is_none() {
> +                    // Trailing comma at end of array is allowed
> +                    break;
> +                }
> +            }
> +            Some(TokenTree::Literal(_)) => {
> +                // Next item is a string literal, comma was required
> +                panic!("Expected ',' between array elements");
> +            }
> +            None => {
> +                // End of array, no comma needed
> +                break;
> +            }
> +            Some(_) => panic!("Expected ',' or end of array"),
>          }
>      }
>      values
> @@ -143,9 +160,22 @@ fn parse(it: &mut token_stream::IntoIter) -> Self {
>                  _ => panic!("Unknown key \"{key}\". Valid keys are: {EXPECTED_KEYS:?}."),
>              }
>  
> -            assert_eq!(expect_punct(it), ',');
> -
>              seen_keys.push(key);
> +
> +            // Check for optional trailing comma
> +            match it.clone().next() {
> +                Some(TokenTree::Punct(punct)) if punct.as_char() == ',' => {
> +                    // Consume the comma
> +                    it.next();
> +                }
> +                Some(TokenTree::Ident(_)) => {
> +                    // Next item is an identifier, comma was required
> +                    panic!("Expected ',' between module properties");
> +                }
> +                _ => {
> +                    // End of input or closing brace, comma is optional

This also could be a new opening group or other punctuation, which would
be wrong.

---
Cheers,
Benno

> +                }
> +            }
>          }
>  
>          expect_end(it);

Re: [PATCH 1/2] rust: macros: allow optional trailing comma in module!

[Mark Brown]

On Sat, 14 Jun 2025 17:13:09 +0900, Eunsoo Eun wrote:
> Make the `module!` macro syntax more flexible by allowing an optional
> trailing comma after the last field. This makes it consistent with
> Rust’s general syntax patterns where trailing commas are allowed in
> structs, arrays, and other comma-separated lists.
> 
> For example, these are now all valid:
> 
> [...]

Applied to

   https://git.kernel.org/pub/scm/linux/kernel/git/broonie/regulator.git for-next

Thanks!

[1/2] rust: macros: allow optional trailing comma in module!
      (no commit info)
[1/2] spi: spi-pci1xxxx: Drop MSI-X usage as unsupported by DMA engine
      commit: 9f0ad43b158d07bc7144d219ceabdea36e28e392

All being well this means that it will be integrated into the linux-next
tree (usually sometime in the next 24 hours) and sent to Linus during
the next merge window (or sooner if it is a bug fix), however if
problems are discovered then the patch may be dropped or reverted.

You may get further e-mails resulting from automated or manual testing
and review of the tree, please engage with people reporting problems and
send followup patches addressing any issues that are reported if needed.

If any updates are required or you are submitting further changes they
should be sent as incremental updates against current git, existing
patches will not be replaced.

Please add any relevant lists and maintainers to the CCs when replying
to this mail.

Thanks,
Mark

Re: [PATCH 1/2] spi: spi-pci1xxxx: Drop MSI-X usage as unsupported by DMA engine

[Miguel Ojeda]

On Sat, Jun 14, 2025 at 10:14 AM Eunsoo Eun <ewhk9887@gmail.com> wrote:
>
> From: Thangaraj Samynathan <thangaraj.s@microchip.com>
>
> Removes MSI-X from the interrupt request path, as the DMA engine used by
> the SPI controller does not support MSI-X interrupts.
>
> Signed-off-by: Thangaraj Samynathan <thangaraj.s@microchip.com>
> Link: https://patch.msgid.link/20250612023059.71726-1-thangaraj.s@microchip.com
> Signed-off-by: Mark Brown <broonie@kernel.org>

For some reason this came as a "1/2" patch in the same email thread as
a Rust one, and that got things confusing. This patch looks
spurious/bogus, i.e. it is already in mainline, and it is not authored
nor signed by you, and it is not even numbered as "2/2".

Do you know what happened?

Thanks!

Cheers,
Miguel

Re: [PATCH 1/2] rust: macros: allow optional trailing comma in module!

[Miguel Ojeda]

On Sat, Jun 14, 2025 at 8:16 PM Benno Lossin <lossin@kernel.org> wrote:
>
> I didn't get the second patch advertised in the subject, did something
> go wrong when sending the patch?

It seems the series is somehow broken:

    https://lore.kernel.org/rust-for-linux/CANiq72=QUbe-koU-BEhEJ1-7AafC0kGcG6HOhiVaR1TWqPoLFg@mail.gmail.com/

Cheers,
Miguel

Re: [PATCH 1/2] spi: spi-pci1xxxx: Drop MSI-X usage as unsupported by DMA engine

[Thangaraj.S]

Hi Miguel,
On Tue, 2025-06-17 at 10:05 +0200, Miguel Ojeda wrote:
> EXTERNAL EMAIL: Do not click links or open attachments unless you
> know the content is safe
> 
> On Sat, Jun 14, 2025 at 10:14 AM Eunsoo Eun <ewhk9887@gmail.com>
> wrote:
> > From: Thangaraj Samynathan <thangaraj.s@microchip.com>
> > 
> > Removes MSI-X from the interrupt request path, as the DMA engine
> > used by
> > the SPI controller does not support MSI-X interrupts.
> > 
> > Signed-off-by: Thangaraj Samynathan <thangaraj.s@microchip.com>
> > Link: 
> > https://patch.msgid.link/20250612023059.71726-1-thangaraj.s@microchip.com
> > Signed-off-by: Mark Brown <broonie@kernel.org>
> 
> For some reason this came as a "1/2" patch in the same email thread
> as
> a Rust one, and that got things confusing. This patch looks
> spurious/bogus, i.e. it is already in mainline, and it is not
> authored
> nor signed by you, and it is not even numbered as "2/2".
> 
> Do you know what happened?
> 

Thanks for pointing it out. There was a mistake on my end during patch
generation - the patch isn't part of a series, but it was mistakenly
created with an incorrect header. Apologies for the confusion, and I'll
make sure to avoid this in the future.

Thanks,
Thanngaraj Samynathan
> Thanks!
> 
> Cheers,
> Miguel

Re: [PATCH 1/2] spi: spi-pci1xxxx: Drop MSI-X usage as unsupported by DMA engine

[Miguel Ojeda]

On Thu, Jun 19, 2025 at 5:44 AM <Thangaraj.S@microchip.com> wrote:
>
> Thanks for pointing it out. There was a mistake on my end during patch
> generation - the patch isn't part of a series, but it was mistakenly
> created with an incorrect header. Apologies for the confusion, and I'll
> make sure to avoid this in the future.

You're welcome, and no worries! Email/Git can be tricky sometimes :)

Cheers,
Miguel